1	/* SPDX-License-Identifier: GPL-2.0-or-later */
2	/* internal AFS stuff
3	*
4	* Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5	* Written by David Howells (dhowells@redhat.com)
6	*/
7
8	#include <linux/compiler.h>
9	#include <linux/kernel.h>
10	#include <linux/ktime.h>
11	#include <linux/fs.h>
12	#include <linux/filelock.h>
13	#include <linux/pagemap.h>
14	#include <linux/rxrpc.h>
15	#include <linux/key.h>
16	#include <linux/workqueue.h>
17	#include <linux/sched.h>
18	#include <linux/fscache.h>
19	#include <linux/backing-dev.h>
20	#include <linux/uuid.h>
21	#include <linux/mm_types.h>
22	#include <linux/dns_resolver.h>
23	#include <net/net_namespace.h>
24	#include <net/netns/generic.h>
25	#include <net/sock.h>
26	#include <net/af_rxrpc.h>
27
28	#include "afs.h"
29	#include "afs_vl.h"
30
31	#define AFS_CELL_MAX_ADDRS 15
32
33	struct pagevec;
34	struct afs_call;
35	struct afs_vnode;
36
37	/*
38	* Partial file-locking emulation mode. (The problem being that AFS3 only
39	* allows whole-file locks and no upgrading/downgrading).
40	*/
41	enum afs_flock_mode {
42	afs_flock_mode_unset,
43	afs_flock_mode_local, /* Local locking only */
44	afs_flock_mode_openafs, /* Don't get server lock for a partial lock */
45	afs_flock_mode_strict, /* Always get a server lock for a partial lock */
46	afs_flock_mode_write, /* Get an exclusive server lock for a partial lock */
47	};
48
49	struct afs_fs_context {
50	bool force; /* T to force cell type */
51	bool autocell; /* T if set auto mount operation */
52	bool dyn_root; /* T if dynamic root */
53	bool no_cell; /* T if the source is "none" (for dynroot) */
54	enum afs_flock_mode flock_mode; /* Partial file-locking emulation mode */
55	afs_voltype_t type; /* type of volume requested */
56	unsigned int volnamesz; /* size of volume name */
57	const char *volname; /* name of volume to mount */
58	struct afs_net *net; /* the AFS net namespace stuff */
59	struct afs_cell *cell; /* cell in which to find volume */
60	struct afs_volume *volume; /* volume record */
61	struct key *key; /* key to use for secure mounting */
62	};
63
64	enum afs_call_state {
65	AFS_CALL_CL_REQUESTING, /* Client: Request is being sent */
66	AFS_CALL_CL_AWAIT_REPLY, /* Client: Awaiting reply */
67	AFS_CALL_CL_PROC_REPLY, /* Client: rxrpc call complete; processing reply */
68	AFS_CALL_SV_AWAIT_OP_ID, /* Server: Awaiting op ID */
69	AFS_CALL_SV_AWAIT_REQUEST, /* Server: Awaiting request data */
70	AFS_CALL_SV_REPLYING, /* Server: Replying */
71	AFS_CALL_SV_AWAIT_ACK, /* Server: Awaiting final ACK */
72	AFS_CALL_COMPLETE, /* Completed or failed */
73	};
74
75	/*
76	* List of server addresses.
77	*/
78	struct afs_addr_list {
79	struct rcu_head rcu;
80	refcount_t usage;
81	u32 version; /* Version */
82	unsigned char max_addrs;
83	unsigned char nr_addrs;
84	unsigned char preferred; /* Preferred address */
85	unsigned char nr_ipv4; /* Number of IPv4 addresses */
86	enum dns_record_source source:8;
87	enum dns_lookup_status status:8;
88	unsigned long failed; /* Mask of addrs that failed locally/ICMP */
89	unsigned long responded; /* Mask of addrs that responded */
90	struct sockaddr_rxrpc addrs[] __counted_by(max_addrs);
91	#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
92	};
93
94	/*
95	* a record of an in-progress RxRPC call
96	*/
97	struct afs_call {
98	const struct afs_call_type *type; /* type of call */
99	struct afs_addr_list *alist; /* Address is alist[addr_ix] */
100	wait_queue_head_t waitq; /* processes awaiting completion */
101	struct work_struct async_work; /* async I/O processor */
102	struct work_struct work; /* actual work processor */
103	struct rxrpc_call *rxcall; /* RxRPC call handle */
104	struct key *key; /* security for this call */
105	struct afs_net *net; /* The network namespace */
106	struct afs_server *server; /* The fileserver record if fs op (pins ref) */
107	struct afs_vlserver *vlserver; /* The vlserver record if vl op */
108	void *request; /* request data (first part) */
109	size_t iov_len; /* Size of *iter to be used */
110	struct iov_iter def_iter; /* Default buffer/data iterator */
111	struct iov_iter *write_iter; /* Iterator defining write to be made */
112	struct iov_iter *iter; /* Iterator currently in use */
113	union { /* Convenience for ->def_iter */
114	struct kvec kvec[1];
115	struct bio_vec bvec[1];
116	};
117	void *buffer; /* reply receive buffer */
118	union {
119	long ret0; /* Value to reply with instead of 0 */
120	struct afs_addr_list *ret_alist;
121	struct afs_vldb_entry *ret_vldb;
122	char *ret_str;
123	};
124	struct afs_operation *op;
125	unsigned int server_index;
126	refcount_t ref;
127	enum afs_call_state state;
128	spinlock_t state_lock;
129	int error; /* error code */
130	u32 abort_code; /* Remote abort ID or 0 */
131	unsigned int max_lifespan; /* Maximum lifespan in secs to set if not 0 */
132	unsigned request_size; /* size of request data */
133	unsigned reply_max; /* maximum size of reply */
134	unsigned count2; /* count used in unmarshalling */
135	unsigned char unmarshall; /* unmarshalling phase */
136	unsigned char addr_ix; /* Address in ->alist */
137	bool drop_ref; /* T if need to drop ref for incoming call */
138	bool need_attention; /* T if RxRPC poked us */
139	bool async; /* T if asynchronous */
140	bool upgrade; /* T to request service upgrade */
141	bool intr; /* T if interruptible */
142	bool unmarshalling_error; /* T if an unmarshalling error occurred */
143	u16 service_id; /* Actual service ID (after upgrade) */
144	unsigned int debug_id; /* Trace ID */
145	u32 operation_ID; /* operation ID for an incoming call */
146	u32 count; /* count for use in unmarshalling */
147	union { /* place to extract temporary data */
148	struct {
149	__be32 tmp_u;
150	__be32 tmp;
151	} __attribute__((packed));
152	__be64 tmp64;
153	};
154	ktime_t issue_time; /* Time of issue of operation */
155	};
156
157	struct afs_call_type {
158	const char *name;
159	unsigned int op; /* Really enum afs_fs_operation */
160
161	/* deliver request or reply data to an call
162	* - returning an error will cause the call to be aborted
163	*/
164	int (*deliver)(struct afs_call *call);
165
166	/* clean up a call */
167	void (*destructor)(struct afs_call *call);
168
169	/* Work function */
170	void (*work)(struct work_struct *work);
171
172	/* Call done function (gets called immediately on success or failure) */
173	void (*done)(struct afs_call *call);
174	};
175
176	/*
177	* Key available for writeback on a file.
178	*/
179	struct afs_wb_key {
180	refcount_t usage;
181	struct key *key;
182	struct list_head vnode_link; /* Link in vnode->wb_keys */
183	};
184
185	/*
186	* AFS open file information record. Pointed to by file->private_data.
187	*/
188	struct afs_file {
189	struct key *key; /* The key this file was opened with */
190	struct afs_wb_key *wb; /* Writeback key record for this file */
191	};
192
193	static inline struct key *afs_file_key(struct file *file)
194	{
195	struct afs_file *af = file->private_data;
196
197	return af->key;
198	}
199
200	/*
201	* Record of an outstanding read operation on a vnode.
202	*/
203	struct afs_read {
204	loff_t pos; /* Where to start reading */
205	loff_t len; /* How much we're asking for */
206	loff_t actual_len; /* How much we're actually getting */
207	loff_t file_size; /* File size returned by server */
208	struct key *key; /* The key to use to reissue the read */
209	struct afs_vnode *vnode; /* The file being read into. */
210	struct netfs_io_subrequest *subreq; /* Fscache helper read request this belongs to */
211	afs_dataversion_t data_version; /* Version number returned by server */
212	refcount_t usage;
213	unsigned int call_debug_id;
214	unsigned int nr_pages;
215	int error;
216	void (*done)(struct afs_read *);
217	void (*cleanup)(struct afs_read *);
218	struct iov_iter *iter; /* Iterator representing the buffer */
219	struct iov_iter def_iter; /* Default iterator */
220	};
221
222	/*
223	* AFS superblock private data
224	* - there's one superblock per volume
225	*/
226	struct afs_super_info {
227	struct net *net_ns; /* Network namespace */
228	struct afs_cell *cell; /* The cell in which the volume resides */
229	struct afs_volume *volume; /* volume record */
230	enum afs_flock_mode flock_mode:8; /* File locking emulation mode */
231	bool dyn_root; /* True if dynamic root */
232	};
233
234	static inline struct afs_super_info *AFS_FS_S(struct super_block *sb)
235	{
236	return sb->s_fs_info;
237	}
238
239	extern struct file_system_type afs_fs_type;
240
241	/*
242	* Set of substitutes for @sys.
243	*/
244	struct afs_sysnames {
245	#define AFS_NR_SYSNAME 16
246	char *subs[AFS_NR_SYSNAME];
247	refcount_t usage;
248	unsigned short nr;
249	char blank[1];
250	};
251
252	/*
253	* AFS network namespace record.
254	*/
255	struct afs_net {
256	struct net *net; /* Backpointer to the owning net namespace */
257	struct afs_uuid uuid;
258	bool live; /* F if this namespace is being removed */
259
260	/* AF_RXRPC I/O stuff */
261	struct socket *socket;
262	struct afs_call *spare_incoming_call;
263	struct work_struct charge_preallocation_work;
264	struct mutex socket_mutex;
265	atomic_t nr_outstanding_calls;
266	atomic_t nr_superblocks;
267
268	/* Cell database */
269	struct rb_root cells;
270	struct afs_cell *ws_cell;
271	struct work_struct cells_manager;
272	struct timer_list cells_timer;
273	atomic_t cells_outstanding;
274	struct rw_semaphore cells_lock;
275	struct mutex cells_alias_lock;
276
277	struct mutex proc_cells_lock;
278	struct hlist_head proc_cells;
279
280	/* Known servers. Theoretically each fileserver can only be in one
281	* cell, but in practice, people create aliases and subsets and there's
282	* no easy way to distinguish them.
283	*/
284	seqlock_t fs_lock; /* For fs_servers, fs_probe_*, fs_proc */
285	struct rb_root fs_servers; /* afs_server (by server UUID or address) */
286	struct list_head fs_probe_fast; /* List of afs_server to probe at 30s intervals */
287	struct list_head fs_probe_slow; /* List of afs_server to probe at 5m intervals */
288	struct hlist_head fs_proc; /* procfs servers list */
289
290	struct hlist_head fs_addresses4; /* afs_server (by lowest IPv4 addr) */
291	struct hlist_head fs_addresses6; /* afs_server (by lowest IPv6 addr) */
292	seqlock_t fs_addr_lock; /* For fs_addresses[46] */
293
294	struct work_struct fs_manager;
295	struct timer_list fs_timer;
296
297	struct work_struct fs_prober;
298	struct timer_list fs_probe_timer;
299	atomic_t servers_outstanding;
300
301	/* File locking renewal management */
302	struct mutex lock_manager_mutex;
303
304	/* Misc */
305	struct super_block *dynroot_sb; /* Dynamic root mount superblock */
306	struct proc_dir_entry *proc_afs; /* /proc/net/afs directory */
307	struct afs_sysnames *sysnames;
308	rwlock_t sysnames_lock;
309
310	/* Statistics counters */
311	atomic_t n_lookup; /* Number of lookups done */
312	atomic_t n_reval; /* Number of dentries needing revalidation */
313	atomic_t n_inval; /* Number of invalidations by the server */
314	atomic_t n_relpg; /* Number of invalidations by release_folio */
315	atomic_t n_read_dir; /* Number of directory pages read */
316	atomic_t n_dir_cr; /* Number of directory entry creation edits */
317	atomic_t n_dir_rm; /* Number of directory entry removal edits */
318	atomic_t n_stores; /* Number of store ops */
319	atomic_long_t n_store_bytes; /* Number of bytes stored */
320	atomic_long_t n_fetch_bytes; /* Number of bytes fetched */
321	atomic_t n_fetches; /* Number of data fetch ops */
322	};
323
324	extern const char afs_init_sysname[];
325
326	enum afs_cell_state {
327	AFS_CELL_UNSET,
328	AFS_CELL_ACTIVATING,
329	AFS_CELL_ACTIVE,
330	AFS_CELL_DEACTIVATING,
331	AFS_CELL_INACTIVE,
332	AFS_CELL_FAILED,
333	AFS_CELL_REMOVED,
334	};
335
336	/*
337	* AFS cell record.
338	*
339	* This is a tricky concept to get right as it is possible to create aliases
340	* simply by pointing AFSDB/SRV records for two names at the same set of VL
341	* servers; it is also possible to do things like setting up two sets of VL
342	* servers, one of which provides a superset of the volumes provided by the
343	* other (for internal/external division, for example).
344	*
345	* Cells only exist in the sense that (a) a cell's name maps to a set of VL
346	* servers and (b) a cell's name is used by the client to select the key to use
347	* for authentication and encryption. The cell name is not typically used in
348	* the protocol.
349	*
350	* Two cells are determined to be aliases if they have an explicit alias (YFS
351	* only), share any VL servers in common or have at least one volume in common.
352	* "In common" means that the address list of the VL servers or the fileservers
353	* share at least one endpoint.
354	*/
355	struct afs_cell {
356	union {
357	struct rcu_head rcu;
358	struct rb_node net_node; /* Node in net->cells */
359	};
360	struct afs_net *net;
361	struct afs_cell *alias_of; /* The cell this is an alias of */
362	struct afs_volume *root_volume; /* The root.cell volume if there is one */
363	struct key *anonymous_key; /* anonymous user key for this cell */
364	struct work_struct manager; /* Manager for init/deinit/dns */
365	struct hlist_node proc_link; /* /proc cell list link */
366	time64_t dns_expiry; /* Time AFSDB/SRV record expires */
367	time64_t last_inactive; /* Time of last drop of usage count */
368	refcount_t ref; /* Struct refcount */
369	atomic_t active; /* Active usage counter */
370	unsigned long flags;
371	#define AFS_CELL_FL_NO_GC 0 /* The cell was added manually, don't auto-gc */
372	#define AFS_CELL_FL_DO_LOOKUP 1 /* DNS lookup requested */
373	#define AFS_CELL_FL_CHECK_ALIAS 2 /* Need to check for aliases */
374	enum afs_cell_state state;
375	short error;
376	enum dns_record_source dns_source:8; /* Latest source of data from lookup */
377	enum dns_lookup_status dns_status:8; /* Latest status of data from lookup */
378	unsigned int dns_lookup_count; /* Counter of DNS lookups */
379	unsigned int debug_id;
380
381	/* The volumes belonging to this cell */
382	struct rb_root volumes; /* Tree of volumes on this server */
383	struct hlist_head proc_volumes; /* procfs volume list */
384	seqlock_t volume_lock; /* For volumes */
385
386	/* Active fileserver interaction state. */
387	struct rb_root fs_servers; /* afs_server (by server UUID) */
388	seqlock_t fs_lock; /* For fs_servers */
389	struct rw_semaphore fs_open_mmaps_lock;
390	struct list_head fs_open_mmaps; /* List of vnodes that are mmapped */
391	atomic_t fs_s_break; /* Counter of CB.InitCallBackState messages */
392
393	/* VL server list. */
394	rwlock_t vl_servers_lock; /* Lock on vl_servers */
395	struct afs_vlserver_list __rcu *vl_servers;
396
397	u8 name_len; /* Length of name */
398	char *name; /* Cell name, case-flattened and NUL-padded */
399	};
400
401	/*
402	* Volume Location server record.
403	*/
404	struct afs_vlserver {
405	struct rcu_head rcu;
406	struct afs_addr_list __rcu *addresses; /* List of addresses for this VL server */
407	unsigned long flags;
408	#define AFS_VLSERVER_FL_PROBED 0 /* The VL server has been probed */
409	#define AFS_VLSERVER_FL_PROBING 1 /* VL server is being probed */
410	#define AFS_VLSERVER_FL_IS_YFS 2 /* Server is YFS not AFS */
411	#define AFS_VLSERVER_FL_RESPONDING 3 /* VL server is responding */
412	rwlock_t lock; /* Lock on addresses */
413	refcount_t ref;
414	unsigned int rtt; /* Server's current RTT in uS */
415
416	/* Probe state */
417	wait_queue_head_t probe_wq;
418	atomic_t probe_outstanding;
419	spinlock_t probe_lock;
420	struct {
421	unsigned int rtt; /* RTT in uS */
422	u32 abort_code;
423	short error;
424	unsigned short flags;
425	#define AFS_VLSERVER_PROBE_RESPONDED 0x01 /* At least once response (may be abort) */
426	#define AFS_VLSERVER_PROBE_IS_YFS 0x02 /* The peer appears to be YFS */
427	#define AFS_VLSERVER_PROBE_NOT_YFS 0x04 /* The peer appears not to be YFS */
428	#define AFS_VLSERVER_PROBE_LOCAL_FAILURE 0x08 /* A local failure prevented a probe */
429	} probe;
430
431	u16 port;
432	u16 name_len; /* Length of name */
433	char name[]; /* Server name, case-flattened */
434	};
435
436	/*
437	* Weighted list of Volume Location servers.
438	*/
439	struct afs_vlserver_entry {
440	u16 priority; /* Preference (as SRV) */
441	u16 weight; /* Weight (as SRV) */
442	enum dns_record_source source:8;
443	enum dns_lookup_status status:8;
444	struct afs_vlserver *server;
445	};
446
447	struct afs_vlserver_list {
448	struct rcu_head rcu;
449	refcount_t ref;
450	u8 nr_servers;
451	u8 index; /* Server currently in use */
452	u8 preferred; /* Preferred server */
453	enum dns_record_source source:8;
454	enum dns_lookup_status status:8;
455	rwlock_t lock;
456	struct afs_vlserver_entry servers[];
457	};
458
459	/*
460	* Cached VLDB entry.
461	*
462	* This is pointed to by cell->vldb_entries, indexed by name.
463	*/
464	struct afs_vldb_entry {
465	afs_volid_t vid[3]; /* Volume IDs for R/W, R/O and Bak volumes */
466
467	unsigned long flags;
468	#define AFS_VLDB_HAS_RW 0 /* - R/W volume exists */
469	#define AFS_VLDB_HAS_RO 1 /* - R/O volume exists */
470	#define AFS_VLDB_HAS_BAK 2 /* - Backup volume exists */
471	#define AFS_VLDB_QUERY_VALID 3 /* - Record is valid */
472	#define AFS_VLDB_QUERY_ERROR 4 /* - VL server returned error */
473
474	uuid_t fs_server[AFS_NMAXNSERVERS];
475	u32 addr_version[AFS_NMAXNSERVERS]; /* Registration change counters */
476	u8 fs_mask[AFS_NMAXNSERVERS];
477	#define AFS_VOL_VTM_RW 0x01 /* R/W version of the volume is available (on this server) */
478	#define AFS_VOL_VTM_RO 0x02 /* R/O version of the volume is available (on this server) */
479	#define AFS_VOL_VTM_BAK 0x04 /* backup version of the volume is available (on this server) */
480	short error;
481	u8 nr_servers; /* Number of server records */
482	u8 name_len;
483	u8 name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
484	};
485
486	/*
487	* Record of fileserver with which we're actively communicating.
488	*/
489	struct afs_server {
490	struct rcu_head rcu;
491	union {
492	uuid_t uuid; /* Server ID */
493	struct afs_uuid _uuid;
494	};
495
496	struct afs_addr_list __rcu *addresses;
497	struct afs_cell *cell; /* Cell to which belongs (pins ref) */
498	struct rb_node uuid_rb; /* Link in net->fs_servers */
499	struct afs_server __rcu *uuid_next; /* Next server with same UUID */
500	struct afs_server *uuid_prev; /* Previous server with same UUID */
501	struct list_head probe_link; /* Link in net->fs_probe_list */
502	struct hlist_node addr4_link; /* Link in net->fs_addresses4 */
503	struct hlist_node addr6_link; /* Link in net->fs_addresses6 */
504	struct hlist_node proc_link; /* Link in net->fs_proc */
505	struct work_struct initcb_work; /* Work for CB.InitCallBackState* */
506	struct afs_server *gc_next; /* Next server in manager's list */
507	time64_t unuse_time; /* Time at which last unused */
508	unsigned long flags;
509	#define AFS_SERVER_FL_RESPONDING 0 /* The server is responding */
510	#define AFS_SERVER_FL_UPDATING 1
511	#define AFS_SERVER_FL_NEEDS_UPDATE 2 /* Fileserver address list is out of date */
512	#define AFS_SERVER_FL_NOT_READY 4 /* The record is not ready for use */
513	#define AFS_SERVER_FL_NOT_FOUND 5 /* VL server says no such server */
514	#define AFS_SERVER_FL_VL_FAIL 6 /* Failed to access VL server */
515	#define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */
516	#define AFS_SERVER_FL_IS_YFS 16 /* Server is YFS not AFS */
517	#define AFS_SERVER_FL_NO_IBULK 17 /* Fileserver doesn't support FS.InlineBulkStatus */
518	#define AFS_SERVER_FL_NO_RM2 18 /* Fileserver doesn't support YFS.RemoveFile2 */
519	#define AFS_SERVER_FL_HAS_FS64 19 /* Fileserver supports FS.{Fetch,Store}Data64 */
520	refcount_t ref; /* Object refcount */
521	atomic_t active; /* Active user count */
522	u32 addr_version; /* Address list version */
523	unsigned int rtt; /* Server's current RTT in uS */
524	unsigned int debug_id; /* Debugging ID for traces */
525
526	/* file service access */
527	rwlock_t fs_lock; /* access lock */
528
529	/* callback promise management */
530	unsigned cb_s_break; /* Break-everything counter. */
531
532	/* Probe state */
533	unsigned long probed_at; /* Time last probe was dispatched (jiffies) */
534	wait_queue_head_t probe_wq;
535	atomic_t probe_outstanding;
536	spinlock_t probe_lock;
537	struct {
538	unsigned int rtt; /* RTT in uS */
539	u32 abort_code;
540	short error;
541	bool responded:1;
542	bool is_yfs:1;
543	bool not_yfs:1;
544	bool local_failure:1;
545	} probe;
546	};
547
548	/*
549	* Replaceable volume server list.
550	*/
551	struct afs_server_entry {
552	struct afs_server *server;
553	};
554
555	struct afs_server_list {
556	afs_volid_t vids[AFS_MAXTYPES]; /* Volume IDs */
557	refcount_t usage;
558	unsigned char nr_servers;
559	unsigned char preferred; /* Preferred server */
560	unsigned short vnovol_mask; /* Servers to be skipped due to VNOVOL */
561	unsigned int seq; /* Set to ->servers_seq when installed */
562	rwlock_t lock;
563	struct afs_server_entry servers[];
564	};
565
566	/*
567	* Live AFS volume management.
568	*/
569	struct afs_volume {
570	union {
571	struct rcu_head rcu;
572	afs_volid_t vid; /* volume ID */
573	};
574	refcount_t ref;
575	time64_t update_at; /* Time at which to next update */
576	struct afs_cell *cell; /* Cell to which belongs (pins ref) */
577	struct rb_node cell_node; /* Link in cell->volumes */
578	struct hlist_node proc_link; /* Link in cell->proc_volumes */
579	struct super_block __rcu *sb; /* Superblock on which inodes reside */
580	unsigned long flags;
581	#define AFS_VOLUME_NEEDS_UPDATE 0 /* - T if an update needs performing */
582	#define AFS_VOLUME_UPDATING 1 /* - T if an update is in progress */
583	#define AFS_VOLUME_WAIT 2 /* - T if users must wait for update */
584	#define AFS_VOLUME_DELETED 3 /* - T if volume appears deleted */
585	#define AFS_VOLUME_OFFLINE 4 /* - T if volume offline notice given */
586	#define AFS_VOLUME_BUSY 5 /* - T if volume busy notice given */
587	#define AFS_VOLUME_MAYBE_NO_IBULK 6 /* - T if some servers don't have InlineBulkStatus */
588	#ifdef CONFIG_AFS_FSCACHE
589	struct fscache_volume *cache; /* Caching cookie */
590	#endif
591	struct afs_server_list __rcu *servers; /* List of servers on which volume resides */
592	rwlock_t servers_lock; /* Lock for ->servers */
593	unsigned int servers_seq; /* Incremented each time ->servers changes */
594
595	unsigned cb_v_break; /* Break-everything counter. */
596	rwlock_t cb_v_break_lock;
597
598	afs_voltype_t type; /* type of volume */
599	char type_force; /* force volume type (suppress R/O -> R/W) */
600	u8 name_len;
601	u8 name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
602	};
603
604	enum afs_lock_state {
605	AFS_VNODE_LOCK_NONE, /* The vnode has no lock on the server */
606	AFS_VNODE_LOCK_WAITING_FOR_CB, /* We're waiting for the server to break the callback */
607	AFS_VNODE_LOCK_SETTING, /* We're asking the server for a lock */
608	AFS_VNODE_LOCK_GRANTED, /* We have a lock on the server */
609	AFS_VNODE_LOCK_EXTENDING, /* We're extending a lock on the server */
610	AFS_VNODE_LOCK_NEED_UNLOCK, /* We need to unlock on the server */
611	AFS_VNODE_LOCK_UNLOCKING, /* We're telling the server to unlock */
612	AFS_VNODE_LOCK_DELETED, /* The vnode has been deleted whilst we have a lock */
613	};
614
615	/*
616	* AFS inode private data.
617	*
618	* Note that afs_alloc_inode() *must* reset anything that could incorrectly
619	* leak from one inode to another.
620	*/
621	struct afs_vnode {
622	struct netfs_inode netfs; /* Netfslib context and vfs inode */
623	struct afs_volume *volume; /* volume on which vnode resides */
624	struct afs_fid fid; /* the file identifier for this inode */
625	struct afs_file_status status; /* AFS status info for this file */
626	afs_dataversion_t invalid_before; /* Child dentries are invalid before this */
627	struct afs_permits __rcu *permit_cache; /* cache of permits so far obtained */
628	struct mutex io_lock; /* Lock for serialising I/O on this mutex */
629	struct rw_semaphore validate_lock; /* lock for validating this vnode */
630	struct rw_semaphore rmdir_lock; /* Lock for rmdir vs sillyrename */
631	struct key *silly_key; /* Silly rename key */
632	spinlock_t wb_lock; /* lock for wb_keys */
633	spinlock_t lock; /* waitqueue/flags lock */
634	unsigned long flags;
635	#define AFS_VNODE_CB_PROMISED 0 /* Set if vnode has a callback promise */
636	#define AFS_VNODE_UNSET 1 /* set if vnode attributes not yet set */
637	#define AFS_VNODE_DIR_VALID 2 /* Set if dir contents are valid */
638	#define AFS_VNODE_ZAP_DATA 3 /* set if vnode's data should be invalidated */
639	#define AFS_VNODE_DELETED 4 /* set if vnode deleted on server */
640	#define AFS_VNODE_MOUNTPOINT 5 /* set if vnode is a mountpoint symlink */
641	#define AFS_VNODE_AUTOCELL 6 /* set if Vnode is an auto mount point */
642	#define AFS_VNODE_PSEUDODIR 7 /* set if Vnode is a pseudo directory */
643	#define AFS_VNODE_NEW_CONTENT 8 /* Set if file has new content (create/trunc-0) */
644	#define AFS_VNODE_SILLY_DELETED 9 /* Set if file has been silly-deleted */
645	#define AFS_VNODE_MODIFYING 10 /* Set if we're performing a modification op */
646
647	struct list_head wb_keys; /* List of keys available for writeback */
648	struct list_head pending_locks; /* locks waiting to be granted */
649	struct list_head granted_locks; /* locks granted on this file */
650	struct delayed_work lock_work; /* work to be done in locking */
651	struct key *lock_key; /* Key to be used in lock ops */
652	ktime_t locked_at; /* Time at which lock obtained */
653	enum afs_lock_state lock_state : 8;
654	afs_lock_type_t lock_type : 8;
655
656	/* outstanding callback notification on this file */
657	struct work_struct cb_work; /* Work for mmap'd files */
658	struct list_head cb_mmap_link; /* Link in cell->fs_open_mmaps */
659	void *cb_server; /* Server with callback/filelock */
660	atomic_t cb_nr_mmap; /* Number of mmaps */
661	unsigned int cb_fs_s_break; /* Mass server break counter (cell->fs_s_break) */
662	unsigned int cb_s_break; /* Mass break counter on ->server */
663	unsigned int cb_v_break; /* Mass break counter on ->volume */
664	unsigned int cb_break; /* Break counter on vnode */
665	seqlock_t cb_lock; /* Lock for ->cb_server, ->status, ->cb_*break */
666
667	time64_t cb_expires_at; /* time at which callback expires */
668	};
669
670	static inline struct fscache_cookie *afs_vnode_cache(struct afs_vnode *vnode)
671	{
672	#ifdef CONFIG_AFS_FSCACHE
673	return netfs_i_cookie(ctx: &vnode->netfs);
674	#else
675	return NULL;
676	#endif
677	}
678
679	static inline void afs_vnode_set_cache(struct afs_vnode *vnode,
680	struct fscache_cookie *cookie)
681	{
682	#ifdef CONFIG_AFS_FSCACHE
683	vnode->netfs.cache = cookie;
684	if (cookie)
685	mapping_set_release_always(mapping: vnode->netfs.inode.i_mapping);
686	#endif
687	}
688
689	/*
690	* cached security record for one user's attempt to access a vnode
691	*/
692	struct afs_permit {
693	struct key *key; /* RxRPC ticket holding a security context */
694	afs_access_t access; /* CallerAccess value for this key */
695	};
696
697	/*
698	* Immutable cache of CallerAccess records from attempts to access vnodes.
699	* These may be shared between multiple vnodes.
700	*/
701	struct afs_permits {
702	struct rcu_head rcu;
703	struct hlist_node hash_node; /* Link in hash */
704	unsigned long h; /* Hash value for this permit list */
705	refcount_t usage;
706	unsigned short nr_permits; /* Number of records */
707	bool invalidated; /* Invalidated due to key change */
708	struct afs_permit permits[] __counted_by(nr_permits); /* List of permits sorted by key pointer */
709	};
710
711	/*
712	* Error prioritisation and accumulation.
713	*/
714	struct afs_error {
715	short error; /* Accumulated error */
716	bool responded; /* T if server responded */
717	};
718
719	/*
720	* Cursor for iterating over a server's address list.
721	*/
722	struct afs_addr_cursor {
723	struct afs_addr_list *alist; /* Current address list (pins ref) */
724	unsigned long tried; /* Tried addresses */
725	signed char index; /* Current address */
726	bool responded; /* T if the current address responded */
727	unsigned short nr_iterations; /* Number of address iterations */
728	short error;
729	u32 abort_code;
730	};
731
732	/*
733	* Cursor for iterating over a set of volume location servers.
734	*/
735	struct afs_vl_cursor {
736	struct afs_addr_cursor ac;
737	struct afs_cell *cell; /* The cell we're querying */
738	struct afs_vlserver_list *server_list; /* Current server list (pins ref) */
739	struct afs_vlserver *server; /* Server on which this resides */
740	struct key *key; /* Key for the server */
741	unsigned long untried; /* Bitmask of untried servers */
742	short index; /* Current server */
743	short error;
744	unsigned short flags;
745	#define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */
746	#define AFS_VL_CURSOR_RETRY 0x0002 /* Set to do a retry */
747	#define AFS_VL_CURSOR_RETRIED 0x0004 /* Set if started a retry */
748	unsigned short nr_iterations; /* Number of server iterations */
749	};
750
751	/*
752	* Fileserver operation methods.
753	*/
754	struct afs_operation_ops {
755	void (*issue_afs_rpc)(struct afs_operation *op);
756	void (*issue_yfs_rpc)(struct afs_operation *op);
757	void (*success)(struct afs_operation *op);
758	void (*aborted)(struct afs_operation *op);
759	void (*failed)(struct afs_operation *op);
760	void (*edit_dir)(struct afs_operation *op);
761	void (*put)(struct afs_operation *op);
762	};
763
764	struct afs_vnode_param {
765	struct afs_vnode *vnode;
766	struct afs_fid fid; /* Fid to access */
767	struct afs_status_cb scb; /* Returned status and callback promise */
768	afs_dataversion_t dv_before; /* Data version before the call */
769	unsigned int cb_break_before; /* cb_break + cb_s_break before the call */
770	u8 dv_delta; /* Expected change in data version */
771	bool put_vnode:1; /* T if we have a ref on the vnode */
772	bool need_io_lock:1; /* T if we need the I/O lock on this */
773	bool update_ctime:1; /* Need to update the ctime */
774	bool set_size:1; /* Must update i_size */
775	bool op_unlinked:1; /* True if file was unlinked by op */
776	bool speculative:1; /* T if speculative status fetch (no vnode lock) */
777	bool modification:1; /* Set if the content gets modified */
778	};
779
780	/*
781	* Fileserver operation wrapper, handling server and address rotation
782	* asynchronously. May make simultaneous calls to multiple servers.
783	*/
784	struct afs_operation {
785	struct afs_net *net; /* Network namespace */
786	struct key *key; /* Key for the cell */
787	const struct afs_call_type *type; /* Type of call done */
788	const struct afs_operation_ops *ops;
789
790	/* Parameters/results for the operation */
791	struct afs_volume *volume; /* Volume being accessed */
792	struct afs_vnode_param file[2];
793	struct afs_vnode_param *more_files;
794	struct afs_volsync volsync;
795	struct dentry *dentry; /* Dentry to be altered */
796	struct dentry *dentry_2; /* Second dentry to be altered */
797	struct timespec64 mtime; /* Modification time to record */
798	struct timespec64 ctime; /* Change time to set */
799	short nr_files; /* Number of entries in file[], more_files */
800	short error;
801	unsigned int debug_id;
802
803	unsigned int cb_v_break; /* Volume break counter before op */
804	unsigned int cb_s_break; /* Server break counter before op */
805
806	union {
807	struct {
808	int which; /* Which ->file[] to fetch for */
809	} fetch_status;
810	struct {
811	int reason; /* enum afs_edit_dir_reason */
812	mode_t mode;
813	const char *symlink;
814	} create;
815	struct {
816	bool need_rehash;
817	} unlink;
818	struct {
819	struct dentry *rehash;
820	struct dentry *tmp;
821	bool new_negative;
822	} rename;
823	struct {
824	struct afs_read *req;
825	} fetch;
826	struct {
827	afs_lock_type_t type;
828	} lock;
829	struct {
830	struct iov_iter *write_iter;
831	loff_t pos;
832	loff_t size;
833	loff_t i_size;
834	bool laundering; /* Laundering page, PG_writeback not set */
835	} store;
836	struct {
837	struct iattr *attr;
838	loff_t old_i_size;
839	} setattr;
840	struct afs_acl *acl;
841	struct yfs_acl *yacl;
842	struct {
843	struct afs_volume_status vs;
844	struct kstatfs *buf;
845	} volstatus;
846	};
847
848	/* Fileserver iteration state */
849	struct afs_addr_cursor ac;
850	struct afs_server_list *server_list; /* Current server list (pins ref) */
851	struct afs_server *server; /* Server we're using (ref pinned by server_list) */
852	struct afs_call *call;
853	unsigned long untried; /* Bitmask of untried servers */
854	short index; /* Current server */
855	unsigned short nr_iterations; /* Number of server iterations */
856
857	unsigned int flags;
858	#define AFS_OPERATION_STOP 0x0001 /* Set to cease iteration */
859	#define AFS_OPERATION_VBUSY 0x0002 /* Set if seen VBUSY */
860	#define AFS_OPERATION_VMOVED 0x0004 /* Set if seen VMOVED */
861	#define AFS_OPERATION_VNOVOL 0x0008 /* Set if seen VNOVOL */
862	#define AFS_OPERATION_CUR_ONLY 0x0010 /* Set if current server only (file lock held) */
863	#define AFS_OPERATION_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
864	#define AFS_OPERATION_UNINTR 0x0040 /* Set if op is uninterruptible */
865	#define AFS_OPERATION_DOWNGRADE 0x0080 /* Set to retry with downgraded opcode */
866	#define AFS_OPERATION_LOCK_0 0x0100 /* Set if have io_lock on file[0] */
867	#define AFS_OPERATION_LOCK_1 0x0200 /* Set if have io_lock on file[1] */
868	#define AFS_OPERATION_TRIED_ALL 0x0400 /* Set if we've tried all the fileservers */
869	#define AFS_OPERATION_RETRY_SERVER 0x0800 /* Set if we should retry the current server */
870	#define AFS_OPERATION_DIR_CONFLICT 0x1000 /* Set if we detected a 3rd-party dir change */
871	};
872
873	/*
874	* Cache auxiliary data.
875	*/
876	struct afs_vnode_cache_aux {
877	__be64 data_version;
878	} __packed;
879
880	static inline void afs_set_cache_aux(struct afs_vnode *vnode,
881	struct afs_vnode_cache_aux *aux)
882	{
883	aux->data_version = cpu_to_be64(vnode->status.data_version);
884	}
885
886	static inline void afs_invalidate_cache(struct afs_vnode *vnode, unsigned int flags)
887	{
888	struct afs_vnode_cache_aux aux;
889
890	afs_set_cache_aux(vnode, aux: &aux);
891	fscache_invalidate(cookie: afs_vnode_cache(vnode), aux_data: &aux,
892	size: i_size_read(inode: &vnode->netfs.inode), flags);
893	}
894
895	/*
896	* We use folio->private to hold the amount of the folio that we've written to,
897	* splitting the field into two parts. However, we need to represent a range
898	* 0...FOLIO_SIZE, so we reduce the resolution if the size of the folio
899	* exceeds what we can encode.
900	*/
901	#ifdef CONFIG_64BIT
902	#define __AFS_FOLIO_PRIV_MASK 0x7fffffffUL
903	#define __AFS_FOLIO_PRIV_SHIFT 32
904	#define __AFS_FOLIO_PRIV_MMAPPED 0x80000000UL
905	#else
906	#define __AFS_FOLIO_PRIV_MASK 0x7fffUL
907	#define __AFS_FOLIO_PRIV_SHIFT 16
908	#define __AFS_FOLIO_PRIV_MMAPPED 0x8000UL
909	#endif
910
911	static inline unsigned int afs_folio_dirty_resolution(struct folio *folio)
912	{
913	int shift = folio_shift(folio) - (__AFS_FOLIO_PRIV_SHIFT - 1);
914	return (shift > 0) ? shift : 0;
915	}
916
917	static inline size_t afs_folio_dirty_from(struct folio *folio, unsigned long priv)
918	{
919	unsigned long x = priv & __AFS_FOLIO_PRIV_MASK;
920
921	/* The lower bound is inclusive */
922	return x << afs_folio_dirty_resolution(folio);
923	}
924
925	static inline size_t afs_folio_dirty_to(struct folio *folio, unsigned long priv)
926	{
927	unsigned long x = (priv >> __AFS_FOLIO_PRIV_SHIFT) & __AFS_FOLIO_PRIV_MASK;
928
929	/* The upper bound is immediately beyond the region */
930	return (x + 1) << afs_folio_dirty_resolution(folio);
931	}
932
933	static inline unsigned long afs_folio_dirty(struct folio *folio, size_t from, size_t to)
934	{
935	unsigned int res = afs_folio_dirty_resolution(folio);
936	from >>= res;
937	to = (to - 1) >> res;
938	return (to << __AFS_FOLIO_PRIV_SHIFT) | from;
939	}
940
941	static inline unsigned long afs_folio_dirty_mmapped(unsigned long priv)
942	{
943	return priv | __AFS_FOLIO_PRIV_MMAPPED;
944	}
945
946	static inline bool afs_is_folio_dirty_mmapped(unsigned long priv)
947	{
948	return priv & __AFS_FOLIO_PRIV_MMAPPED;
949	}
950
951	#include <trace/events/afs.h>
952
953	/*****************************************************************************/
954	/*
955	* addr_list.c
956	*/
957	static inline struct afs_addr_list *afs_get_addrlist(struct afs_addr_list *alist)
958	{
959	if (alist)
960	refcount_inc(r: &alist->usage);
961	return alist;
962	}
963	extern struct afs_addr_list *afs_alloc_addrlist(unsigned int,
964	unsigned short,
965	unsigned short);
966	extern void afs_put_addrlist(struct afs_addr_list *);
967	extern struct afs_vlserver_list *afs_parse_text_addrs(struct afs_net *,
968	const char *, size_t, char,
969	unsigned short, unsigned short);
970	extern struct afs_vlserver_list *afs_dns_query(struct afs_cell *, time64_t *);
971	extern bool afs_iterate_addresses(struct afs_addr_cursor *);
972	extern int afs_end_cursor(struct afs_addr_cursor *);
973
974	extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
975	extern void afs_merge_fs_addr6(struct afs_addr_list *, __be32 *, u16);
976
977	/*
978	* callback.c
979	*/
980	extern void afs_invalidate_mmap_work(struct work_struct *);
981	extern void afs_server_init_callback_work(struct work_struct *work);
982	extern void afs_init_callback_state(struct afs_server *);
983	extern void __afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
984	extern void afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
985	extern void afs_break_callbacks(struct afs_server *, size_t, struct afs_callback_break *);
986
987	static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
988	{
989	return vnode->cb_break + vnode->cb_v_break;
990	}
991
992	static inline bool afs_cb_is_broken(unsigned int cb_break,
993	const struct afs_vnode *vnode)
994	{
995	return cb_break != (vnode->cb_break + vnode->volume->cb_v_break);
996	}
997
998	/*
999	* cell.c
1000	*/
1001	extern int afs_cell_init(struct afs_net *, const char *);
1002	extern struct afs_cell *afs_find_cell(struct afs_net *, const char *, unsigned,
1003	enum afs_cell_trace);
1004	extern struct afs_cell *afs_lookup_cell(struct afs_net *, const char *, unsigned,
1005	const char *, bool);
1006	extern struct afs_cell *afs_use_cell(struct afs_cell *, enum afs_cell_trace);
1007	extern void afs_unuse_cell(struct afs_net *, struct afs_cell *, enum afs_cell_trace);
1008	extern struct afs_cell *afs_get_cell(struct afs_cell *, enum afs_cell_trace);
1009	extern void afs_see_cell(struct afs_cell *, enum afs_cell_trace);
1010	extern void afs_put_cell(struct afs_cell *, enum afs_cell_trace);
1011	extern void afs_queue_cell(struct afs_cell *, enum afs_cell_trace);
1012	extern void afs_manage_cells(struct work_struct *);
1013	extern void afs_cells_timer(struct timer_list *);
1014	extern void __net_exit afs_cell_purge(struct afs_net *);
1015
1016	/*
1017	* cmservice.c
1018	*/
1019	extern bool afs_cm_incoming_call(struct afs_call *);
1020
1021	/*
1022	* dir.c
1023	*/
1024	extern const struct file_operations afs_dir_file_operations;
1025	extern const struct inode_operations afs_dir_inode_operations;
1026	extern const struct address_space_operations afs_dir_aops;
1027	extern const struct dentry_operations afs_fs_dentry_operations;
1028
1029	extern void afs_d_release(struct dentry *);
1030	extern void afs_check_for_remote_deletion(struct afs_operation *);
1031
1032	/*
1033	* dir_edit.c
1034	*/
1035	extern void afs_edit_dir_add(struct afs_vnode *, struct qstr *, struct afs_fid *,
1036	enum afs_edit_dir_reason);
1037	extern void afs_edit_dir_remove(struct afs_vnode *, struct qstr *, enum afs_edit_dir_reason);
1038
1039	/*
1040	* dir_silly.c
1041	*/
1042	extern int afs_sillyrename(struct afs_vnode *, struct afs_vnode *,
1043	struct dentry *, struct key *);
1044	extern int afs_silly_iput(struct dentry *, struct inode *);
1045
1046	/*
1047	* dynroot.c
1048	*/
1049	extern const struct inode_operations afs_dynroot_inode_operations;
1050	extern const struct dentry_operations afs_dynroot_dentry_operations;
1051
1052	extern struct inode *afs_try_auto_mntpt(struct dentry *, struct inode *);
1053	extern int afs_dynroot_mkdir(struct afs_net *, struct afs_cell *);
1054	extern void afs_dynroot_rmdir(struct afs_net *, struct afs_cell *);
1055	extern int afs_dynroot_populate(struct super_block *);
1056	extern void afs_dynroot_depopulate(struct super_block *);
1057
1058	/*
1059	* file.c
1060	*/
1061	extern const struct address_space_operations afs_file_aops;
1062	extern const struct address_space_operations afs_symlink_aops;
1063	extern const struct inode_operations afs_file_inode_operations;
1064	extern const struct file_operations afs_file_operations;
1065	extern const struct netfs_request_ops afs_req_ops;
1066
1067	extern int afs_cache_wb_key(struct afs_vnode *, struct afs_file *);
1068	extern void afs_put_wb_key(struct afs_wb_key *);
1069	extern int afs_open(struct inode *, struct file *);
1070	extern int afs_release(struct inode *, struct file *);
1071	extern int afs_fetch_data(struct afs_vnode *, struct afs_read *);
1072	extern struct afs_read *afs_alloc_read(gfp_t);
1073	extern void afs_put_read(struct afs_read *);
1074	extern int afs_write_inode(struct inode *, struct writeback_control *);
1075
1076	static inline struct afs_read *afs_get_read(struct afs_read *req)
1077	{
1078	refcount_inc(r: &req->usage);
1079	return req;
1080	}
1081
1082	/*
1083	* flock.c
1084	*/
1085	extern struct workqueue_struct *afs_lock_manager;
1086
1087	extern void afs_lock_op_done(struct afs_call *);
1088	extern void afs_lock_work(struct work_struct *);
1089	extern void afs_lock_may_be_available(struct afs_vnode *);
1090	extern int afs_lock(struct file *, int, struct file_lock *);
1091	extern int afs_flock(struct file *, int, struct file_lock *);
1092
1093	/*
1094	* fsclient.c
1095	*/
1096	extern void afs_fs_fetch_status(struct afs_operation *);
1097	extern void afs_fs_fetch_data(struct afs_operation *);
1098	extern void afs_fs_create_file(struct afs_operation *);
1099	extern void afs_fs_make_dir(struct afs_operation *);
1100	extern void afs_fs_remove_file(struct afs_operation *);
1101	extern void afs_fs_remove_dir(struct afs_operation *);
1102	extern void afs_fs_link(struct afs_operation *);
1103	extern void afs_fs_symlink(struct afs_operation *);
1104	extern void afs_fs_rename(struct afs_operation *);
1105	extern void afs_fs_store_data(struct afs_operation *);
1106	extern void afs_fs_setattr(struct afs_operation *);
1107	extern void afs_fs_get_volume_status(struct afs_operation *);
1108	extern void afs_fs_set_lock(struct afs_operation *);
1109	extern void afs_fs_extend_lock(struct afs_operation *);
1110	extern void afs_fs_release_lock(struct afs_operation *);
1111	extern int afs_fs_give_up_all_callbacks(struct afs_net *, struct afs_server *,
1112	struct afs_addr_cursor *, struct key *);
1113	extern bool afs_fs_get_capabilities(struct afs_net *, struct afs_server *,
1114	struct afs_addr_cursor *, struct key *);
1115	extern void afs_fs_inline_bulk_status(struct afs_operation *);
1116
1117	struct afs_acl {
1118	u32 size;
1119	u8 data[];
1120	};
1121
1122	extern void afs_fs_fetch_acl(struct afs_operation *);
1123	extern void afs_fs_store_acl(struct afs_operation *);
1124
1125	/*
1126	* fs_operation.c
1127	*/
1128	extern struct afs_operation *afs_alloc_operation(struct key *, struct afs_volume *);
1129	extern int afs_put_operation(struct afs_operation *);
1130	extern bool afs_begin_vnode_operation(struct afs_operation *);
1131	extern void afs_wait_for_operation(struct afs_operation *);
1132	extern int afs_do_sync_operation(struct afs_operation *);
1133
1134	static inline void afs_op_nomem(struct afs_operation *op)
1135	{
1136	op->error = -ENOMEM;
1137	}
1138
1139	static inline void afs_op_set_vnode(struct afs_operation *op, unsigned int n,
1140	struct afs_vnode *vnode)
1141	{
1142	op->file[n].vnode = vnode;
1143	op->file[n].need_io_lock = true;
1144	}
1145
1146	static inline void afs_op_set_fid(struct afs_operation *op, unsigned int n,
1147	const struct afs_fid *fid)
1148	{
1149	op->file[n].fid = *fid;
1150	}
1151
1152	/*
1153	* fs_probe.c
1154	*/
1155	extern void afs_fileserver_probe_result(struct afs_call *);
1156	extern void afs_fs_probe_fileserver(struct afs_net *, struct afs_server *, struct key *, bool);
1157	extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
1158	extern void afs_probe_fileserver(struct afs_net *, struct afs_server *);
1159	extern void afs_fs_probe_dispatcher(struct work_struct *);
1160	extern int afs_wait_for_one_fs_probe(struct afs_server *, bool);
1161	extern void afs_fs_probe_cleanup(struct afs_net *);
1162
1163	/*
1164	* inode.c
1165	*/
1166	extern const struct afs_operation_ops afs_fetch_status_operation;
1167
1168	extern void afs_vnode_commit_status(struct afs_operation *, struct afs_vnode_param *);
1169	extern int afs_fetch_status(struct afs_vnode *, struct key *, bool, afs_access_t *);
1170	extern int afs_ilookup5_test_by_fid(struct inode *, void *);
1171	extern struct inode *afs_iget_pseudo_dir(struct super_block *, bool);
1172	extern struct inode *afs_iget(struct afs_operation *, struct afs_vnode_param *);
1173	extern struct inode *afs_root_iget(struct super_block *, struct key *);
1174	extern bool afs_check_validity(struct afs_vnode *);
1175	extern int afs_validate(struct afs_vnode *, struct key *);
1176	bool afs_pagecache_valid(struct afs_vnode *);
1177	extern int afs_getattr(struct mnt_idmap *idmap, const struct path *,
1178	struct kstat *, u32, unsigned int);
1179	extern int afs_setattr(struct mnt_idmap *idmap, struct dentry *, struct iattr *);
1180	extern void afs_evict_inode(struct inode *);
1181	extern int afs_drop_inode(struct inode *);
1182
1183	/*
1184	* main.c
1185	*/
1186	extern struct workqueue_struct *afs_wq;
1187	extern int afs_net_id;
1188
1189	static inline struct afs_net *afs_net(struct net *net)
1190	{
1191	return net_generic(net, id: afs_net_id);
1192	}
1193
1194	static inline struct afs_net *afs_sb2net(struct super_block *sb)
1195	{
1196	return afs_net(net: AFS_FS_S(sb)->net_ns);
1197	}
1198
1199	static inline struct afs_net *afs_d2net(struct dentry *dentry)
1200	{
1201	return afs_sb2net(sb: dentry->d_sb);
1202	}
1203
1204	static inline struct afs_net *afs_i2net(struct inode *inode)
1205	{
1206	return afs_sb2net(sb: inode->i_sb);
1207	}
1208
1209	static inline struct afs_net *afs_v2net(struct afs_vnode *vnode)
1210	{
1211	return afs_i2net(inode: &vnode->netfs.inode);
1212	}
1213
1214	static inline struct afs_net *afs_sock2net(struct sock *sk)
1215	{
1216	return net_generic(net: sock_net(sk), id: afs_net_id);
1217	}
1218
1219	static inline void __afs_stat(atomic_t *s)
1220	{
1221	atomic_inc(v: s);
1222	}
1223
1224	#define afs_stat_v(vnode, n) __afs_stat(&afs_v2net(vnode)->n)
1225
1226	/*
1227	* misc.c
1228	*/
1229	extern int afs_abort_to_error(u32);
1230	extern void afs_prioritise_error(struct afs_error *, int, u32);
1231
1232	/*
1233	* mntpt.c
1234	*/
1235	extern const struct inode_operations afs_mntpt_inode_operations;
1236	extern const struct inode_operations afs_autocell_inode_operations;
1237	extern const struct file_operations afs_mntpt_file_operations;
1238
1239	extern struct vfsmount *afs_d_automount(struct path *);
1240	extern void afs_mntpt_kill_timer(void);
1241
1242	/*
1243	* proc.c
1244	*/
1245	#ifdef CONFIG_PROC_FS
1246	extern int __net_init afs_proc_init(struct afs_net *);
1247	extern void __net_exit afs_proc_cleanup(struct afs_net *);
1248	extern int afs_proc_cell_setup(struct afs_cell *);
1249	extern void afs_proc_cell_remove(struct afs_cell *);
1250	extern void afs_put_sysnames(struct afs_sysnames *);
1251	#else
1252	static inline int afs_proc_init(struct afs_net *net) { return 0; }
1253	static inline void afs_proc_cleanup(struct afs_net *net) {}
1254	static inline int afs_proc_cell_setup(struct afs_cell *cell) { return 0; }
1255	static inline void afs_proc_cell_remove(struct afs_cell *cell) {}
1256	static inline void afs_put_sysnames(struct afs_sysnames *sysnames) {}
1257	#endif
1258
1259	/*
1260	* rotate.c
1261	*/
1262	extern bool afs_select_fileserver(struct afs_operation *);
1263	extern void afs_dump_edestaddrreq(const struct afs_operation *);
1264
1265	/*
1266	* rxrpc.c
1267	*/
1268	extern struct workqueue_struct *afs_async_calls;
1269
1270	extern int __net_init afs_open_socket(struct afs_net *);
1271	extern void __net_exit afs_close_socket(struct afs_net *);
1272	extern void afs_charge_preallocation(struct work_struct *);
1273	extern void afs_put_call(struct afs_call *);
1274	extern void afs_make_call(struct afs_addr_cursor *, struct afs_call *, gfp_t);
1275	extern long afs_wait_for_call_to_complete(struct afs_call *, struct afs_addr_cursor *);
1276	extern struct afs_call *afs_alloc_flat_call(struct afs_net *,
1277	const struct afs_call_type *,
1278	size_t, size_t);
1279	extern void afs_flat_call_destructor(struct afs_call *);
1280	extern void afs_send_empty_reply(struct afs_call *);
1281	extern void afs_send_simple_reply(struct afs_call *, const void *, size_t);
1282	extern int afs_extract_data(struct afs_call *, bool);
1283	extern int afs_protocol_error(struct afs_call *, enum afs_eproto_cause);
1284
1285	static inline void afs_make_op_call(struct afs_operation *op, struct afs_call *call,
1286	gfp_t gfp)
1287	{
1288	op->call = call;
1289	op->type = call->type;
1290	call->op = op;
1291	call->key = op->key;
1292	call->intr = !(op->flags & AFS_OPERATION_UNINTR);
1293	afs_make_call(&op->ac, call, gfp);
1294	}
1295
1296	static inline void afs_extract_begin(struct afs_call *call, void *buf, size_t size)
1297	{
1298	call->iov_len = size;
1299	call->kvec[0].iov_base = buf;
1300	call->kvec[0].iov_len = size;
1301	iov_iter_kvec(i: &call->def_iter, ITER_DEST, kvec: call->kvec, nr_segs: 1, count: size);
1302	}
1303
1304	static inline void afs_extract_to_tmp(struct afs_call *call)
1305	{
1306	call->iov_len = sizeof(call->tmp);
1307	afs_extract_begin(call, buf: &call->tmp, size: sizeof(call->tmp));
1308	}
1309
1310	static inline void afs_extract_to_tmp64(struct afs_call *call)
1311	{
1312	call->iov_len = sizeof(call->tmp64);
1313	afs_extract_begin(call, buf: &call->tmp64, size: sizeof(call->tmp64));
1314	}
1315
1316	static inline void afs_extract_discard(struct afs_call *call, size_t size)
1317	{
1318	call->iov_len = size;
1319	iov_iter_discard(i: &call->def_iter, ITER_DEST, count: size);
1320	}
1321
1322	static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
1323	{
1324	call->iov_len = size;
1325	afs_extract_begin(call, buf: call->buffer, size);
1326	}
1327
1328	static inline int afs_transfer_reply(struct afs_call *call)
1329	{
1330	return afs_extract_data(call, false);
1331	}
1332
1333	static inline bool afs_check_call_state(struct afs_call *call,
1334	enum afs_call_state state)
1335	{
1336	return READ_ONCE(call->state) == state;
1337	}
1338
1339	static inline bool afs_set_call_state(struct afs_call *call,
1340	enum afs_call_state from,
1341	enum afs_call_state to)
1342	{
1343	bool ok = false;
1344
1345	spin_lock_bh(lock: &call->state_lock);
1346	if (call->state == from) {
1347	call->state = to;
1348	trace_afs_call_state(call, from, to, ret: 0, remote_abort: 0);
1349	ok = true;
1350	}
1351	spin_unlock_bh(lock: &call->state_lock);
1352	return ok;
1353	}
1354
1355	static inline void afs_set_call_complete(struct afs_call *call,
1356	int error, u32 remote_abort)
1357	{
1358	enum afs_call_state state;
1359	bool ok = false;
1360
1361	spin_lock_bh(lock: &call->state_lock);
1362	state = call->state;
1363	if (state != AFS_CALL_COMPLETE) {
1364	call->abort_code = remote_abort;
1365	call->error = error;
1366	call->state = AFS_CALL_COMPLETE;
1367	trace_afs_call_state(call, from: state, to: AFS_CALL_COMPLETE,
1368	ret: error, remote_abort);
1369	ok = true;
1370	}
1371	spin_unlock_bh(lock: &call->state_lock);
1372	if (ok) {
1373	trace_afs_call_done(call);
1374
1375	/* Asynchronous calls have two refs to release - one from the alloc and
1376	* one queued with the work item - and we can't just deallocate the
1377	* call because the work item may be queued again.
1378	*/
1379	if (call->drop_ref)
1380	afs_put_call(call);
1381	}
1382	}
1383
1384	/*
1385	* security.c
1386	*/
1387	extern void afs_put_permits(struct afs_permits *);
1388	extern void afs_clear_permits(struct afs_vnode *);
1389	extern void afs_cache_permit(struct afs_vnode *, struct key *, unsigned int,
1390	struct afs_status_cb *);
1391	extern struct key *afs_request_key(struct afs_cell *);
1392	extern struct key *afs_request_key_rcu(struct afs_cell *);
1393	extern int afs_check_permit(struct afs_vnode *, struct key *, afs_access_t *);
1394	extern int afs_permission(struct mnt_idmap *, struct inode *, int);
1395	extern void __exit afs_clean_up_permit_cache(void);
1396
1397	/*
1398	* server.c
1399	*/
1400	extern spinlock_t afs_server_peer_lock;
1401
1402	extern struct afs_server *afs_find_server(struct afs_net *,
1403	const struct sockaddr_rxrpc *);
1404	extern struct afs_server *afs_find_server_by_uuid(struct afs_net *, const uuid_t *);
1405	extern struct afs_server *afs_lookup_server(struct afs_cell *, struct key *, const uuid_t *, u32);
1406	extern struct afs_server *afs_get_server(struct afs_server *, enum afs_server_trace);
1407	extern struct afs_server *afs_use_server(struct afs_server *, enum afs_server_trace);
1408	extern void afs_unuse_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1409	extern void afs_unuse_server_notime(struct afs_net *, struct afs_server *, enum afs_server_trace);
1410	extern void afs_put_server(struct afs_net *, struct afs_server *, enum afs_server_trace);
1411	extern void afs_manage_servers(struct work_struct *);
1412	extern void afs_servers_timer(struct timer_list *);
1413	extern void afs_fs_probe_timer(struct timer_list *);
1414	extern void __net_exit afs_purge_servers(struct afs_net *);
1415	extern bool afs_check_server_record(struct afs_operation *, struct afs_server *);
1416
1417	static inline void afs_inc_servers_outstanding(struct afs_net *net)
1418	{
1419	atomic_inc(v: &net->servers_outstanding);
1420	}
1421
1422	static inline void afs_dec_servers_outstanding(struct afs_net *net)
1423	{
1424	if (atomic_dec_and_test(v: &net->servers_outstanding))
1425	wake_up_var(var: &net->servers_outstanding);
1426	}
1427
1428	static inline bool afs_is_probing_server(struct afs_server *server)
1429	{
1430	return list_empty(head: &server->probe_link);
1431	}
1432
1433	/*
1434	* server_list.c
1435	*/
1436	static inline struct afs_server_list *afs_get_serverlist(struct afs_server_list *slist)
1437	{
1438	refcount_inc(r: &slist->usage);
1439	return slist;
1440	}
1441
1442	extern void afs_put_serverlist(struct afs_net *, struct afs_server_list *);
1443	extern struct afs_server_list *afs_alloc_server_list(struct afs_cell *, struct key *,
1444	struct afs_vldb_entry *,
1445	u8);
1446	extern bool afs_annotate_server_list(struct afs_server_list *, struct afs_server_list *);
1447
1448	/*
1449	* super.c
1450	*/
1451	extern int __init afs_fs_init(void);
1452	extern void afs_fs_exit(void);
1453
1454	/*
1455	* vlclient.c
1456	*/
1457	extern struct afs_vldb_entry *afs_vl_get_entry_by_name_u(struct afs_vl_cursor *,
1458	const char *, int);
1459	extern struct afs_addr_list *afs_vl_get_addrs_u(struct afs_vl_cursor *, const uuid_t *);
1460	extern struct afs_call *afs_vl_get_capabilities(struct afs_net *, struct afs_addr_cursor *,
1461	struct key *, struct afs_vlserver *, unsigned int);
1462	extern struct afs_addr_list *afs_yfsvl_get_endpoints(struct afs_vl_cursor *, const uuid_t *);
1463	extern char *afs_yfsvl_get_cell_name(struct afs_vl_cursor *);
1464
1465	/*
1466	* vl_alias.c
1467	*/
1468	extern int afs_cell_detect_alias(struct afs_cell *, struct key *);
1469
1470	/*
1471	* vl_probe.c
1472	*/
1473	extern void afs_vlserver_probe_result(struct afs_call *);
1474	extern int afs_send_vl_probes(struct afs_net *, struct key *, struct afs_vlserver_list *);
1475	extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
1476
1477	/*
1478	* vl_rotate.c
1479	*/
1480	extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
1481	struct afs_cell *, struct key *);
1482	extern bool afs_select_vlserver(struct afs_vl_cursor *);
1483	extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
1484	extern int afs_end_vlserver_operation(struct afs_vl_cursor *);
1485
1486	/*
1487	* vlserver_list.c
1488	*/
1489	static inline struct afs_vlserver *afs_get_vlserver(struct afs_vlserver *vlserver)
1490	{
1491	refcount_inc(r: &vlserver->ref);
1492	return vlserver;
1493	}
1494
1495	static inline struct afs_vlserver_list *afs_get_vlserverlist(struct afs_vlserver_list *vllist)
1496	{
1497	if (vllist)
1498	refcount_inc(r: &vllist->ref);
1499	return vllist;
1500	}
1501
1502	extern struct afs_vlserver *afs_alloc_vlserver(const char *, size_t, unsigned short);
1503	extern void afs_put_vlserver(struct afs_net *, struct afs_vlserver *);
1504	extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
1505	extern void afs_put_vlserverlist(struct afs_net *, struct afs_vlserver_list *);
1506	extern struct afs_vlserver_list *afs_extract_vlserver_list(struct afs_cell *,
1507	const void *, size_t);
1508
1509	/*
1510	* volume.c
1511	*/
1512	extern struct afs_volume *afs_create_volume(struct afs_fs_context *);
1513	extern int afs_activate_volume(struct afs_volume *);
1514	extern void afs_deactivate_volume(struct afs_volume *);
1515	extern struct afs_volume *afs_get_volume(struct afs_volume *, enum afs_volume_trace);
1516	extern void afs_put_volume(struct afs_net *, struct afs_volume *, enum afs_volume_trace);
1517	extern int afs_check_volume_status(struct afs_volume *, struct afs_operation *);
1518
1519	/*
1520	* write.c
1521	*/
1522	#ifdef CONFIG_AFS_FSCACHE
1523	bool afs_dirty_folio(struct address_space *, struct folio *);
1524	#else
1525	#define afs_dirty_folio filemap_dirty_folio
1526	#endif
1527	extern int afs_write_begin(struct file *file, struct address_space *mapping,
1528	loff_t pos, unsigned len,
1529	struct page **pagep, void **fsdata);
1530	extern int afs_write_end(struct file *file, struct address_space *mapping,
1531	loff_t pos, unsigned len, unsigned copied,
1532	struct page *page, void *fsdata);
1533	extern int afs_writepage(struct page *, struct writeback_control *);
1534	extern int afs_writepages(struct address_space *, struct writeback_control *);
1535	extern ssize_t afs_file_write(struct kiocb *, struct iov_iter *);
1536	extern int afs_fsync(struct file *, loff_t, loff_t, int);
1537	extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
1538	extern void afs_prune_wb_keys(struct afs_vnode *);
1539	int afs_launder_folio(struct folio *);
1540
1541	/*
1542	* xattr.c
1543	*/
1544	extern const struct xattr_handler * const afs_xattr_handlers[];
1545
1546	/*
1547	* yfsclient.c
1548	*/
1549	extern void yfs_fs_fetch_data(struct afs_operation *);
1550	extern void yfs_fs_create_file(struct afs_operation *);
1551	extern void yfs_fs_make_dir(struct afs_operation *);
1552	extern void yfs_fs_remove_file2(struct afs_operation *);
1553	extern void yfs_fs_remove_file(struct afs_operation *);
1554	extern void yfs_fs_remove_dir(struct afs_operation *);
1555	extern void yfs_fs_link(struct afs_operation *);
1556	extern void yfs_fs_symlink(struct afs_operation *);
1557	extern void yfs_fs_rename(struct afs_operation *);
1558	extern void yfs_fs_store_data(struct afs_operation *);
1559	extern void yfs_fs_setattr(struct afs_operation *);
1560	extern void yfs_fs_get_volume_status(struct afs_operation *);
1561	extern void yfs_fs_set_lock(struct afs_operation *);
1562	extern void yfs_fs_extend_lock(struct afs_operation *);
1563	extern void yfs_fs_release_lock(struct afs_operation *);
1564	extern void yfs_fs_fetch_status(struct afs_operation *);
1565	extern void yfs_fs_inline_bulk_status(struct afs_operation *);
1566
1567	struct yfs_acl {
1568	struct afs_acl *acl; /* Dir/file/symlink ACL */
1569	struct afs_acl *vol_acl; /* Whole volume ACL */
1570	u32 inherit_flag; /* True if ACL is inherited from parent dir */
1571	u32 num_cleaned; /* Number of ACEs removed due to subject removal */
1572	unsigned int flags;
1573	#define YFS_ACL_WANT_ACL 0x01 /* Set if caller wants ->acl */
1574	#define YFS_ACL_WANT_VOL_ACL 0x02 /* Set if caller wants ->vol_acl */
1575	};
1576
1577	extern void yfs_free_opaque_acl(struct yfs_acl *);
1578	extern void yfs_fs_fetch_opaque_acl(struct afs_operation *);
1579	extern void yfs_fs_store_opaque_acl2(struct afs_operation *);
1580
1581	/*
1582	* Miscellaneous inline functions.
1583	*/
1584	static inline struct afs_vnode *AFS_FS_I(struct inode *inode)
1585	{
1586	return container_of(inode, struct afs_vnode, netfs.inode);
1587	}
1588
1589	static inline struct inode *AFS_VNODE_TO_I(struct afs_vnode *vnode)
1590	{
1591	return &vnode->netfs.inode;
1592	}
1593
1594	/*
1595	* Note that a dentry got changed. We need to set d_fsdata to the data version
1596	* number derived from the result of the operation. It doesn't matter if
1597	* d_fsdata goes backwards as we'll just revalidate.
1598	*/
1599	static inline void afs_update_dentry_version(struct afs_operation *op,
1600	struct afs_vnode_param *dir_vp,
1601	struct dentry *dentry)
1602	{
1603	if (!op->error)
1604	dentry->d_fsdata =
1605	(void *)(unsigned long)dir_vp->scb.status.data_version;
1606	}
1607
1608	/*
1609	* Set the file size and block count. Estimate the number of 512 bytes blocks
1610	* used, rounded up to nearest 1K for consistency with other AFS clients.
1611	*/
1612	static inline void afs_set_i_size(struct afs_vnode *vnode, u64 size)
1613	{
1614	i_size_write(inode: &vnode->netfs.inode, i_size: size);
1615	vnode->netfs.inode.i_blocks = ((size + 1023) >> 10) << 1;
1616	}
1617
1618	/*
1619	* Check for a conflicting operation on a directory that we just unlinked from.
1620	* If someone managed to sneak a link or an unlink in on the file we just
1621	* unlinked, we won't be able to trust nlink on an AFS file (but not YFS).
1622	*/
1623	static inline void afs_check_dir_conflict(struct afs_operation *op,
1624	struct afs_vnode_param *dvp)
1625	{
1626	if (dvp->dv_before + dvp->dv_delta != dvp->scb.status.data_version)
1627	op->flags |= AFS_OPERATION_DIR_CONFLICT;
1628	}
1629
1630	static inline int afs_io_error(struct afs_call *call, enum afs_io_error where)
1631	{
1632	trace_afs_io_error(call: call->debug_id, error: -EIO, where);
1633	return -EIO;
1634	}
1635
1636	static inline int afs_bad(struct afs_vnode *vnode, enum afs_file_error where)
1637	{
1638	trace_afs_file_error(vnode, error: -EIO, where);
1639	return -EIO;
1640	}
1641
1642	/*****************************************************************************/
1643	/*
1644	* debug tracing
1645	*/
1646	extern unsigned afs_debug;
1647
1648	#define dbgprintk(FMT,...) \
1649	printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
1650
1651	#define kenter(FMT,...) dbgprintk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1652	#define kleave(FMT,...) dbgprintk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1653	#define kdebug(FMT,...) dbgprintk(" "FMT ,##__VA_ARGS__)
1654
1655
1656	#if defined(__KDEBUG)
1657	#define _enter(FMT,...) kenter(FMT,##__VA_ARGS__)
1658	#define _leave(FMT,...) kleave(FMT,##__VA_ARGS__)
1659	#define _debug(FMT,...) kdebug(FMT,##__VA_ARGS__)
1660
1661	#elif defined(CONFIG_AFS_DEBUG)
1662	#define AFS_DEBUG_KENTER 0x01
1663	#define AFS_DEBUG_KLEAVE 0x02
1664	#define AFS_DEBUG_KDEBUG 0x04
1665
1666	#define _enter(FMT,...) \
1667	do { \
1668	if (unlikely(afs_debug & AFS_DEBUG_KENTER)) \
1669	kenter(FMT,##__VA_ARGS__); \
1670	} while (0)
1671
1672	#define _leave(FMT,...) \
1673	do { \
1674	if (unlikely(afs_debug & AFS_DEBUG_KLEAVE)) \
1675	kleave(FMT,##__VA_ARGS__); \
1676	} while (0)
1677
1678	#define _debug(FMT,...) \
1679	do { \
1680	if (unlikely(afs_debug & AFS_DEBUG_KDEBUG)) \
1681	kdebug(FMT,##__VA_ARGS__); \
1682	} while (0)
1683
1684	#else
1685	#define _enter(FMT,...) no_printk("==> %s("FMT")",__func__ ,##__VA_ARGS__)
1686	#define _leave(FMT,...) no_printk("<== %s()"FMT"",__func__ ,##__VA_ARGS__)
1687	#define _debug(FMT,...) no_printk(" "FMT ,##__VA_ARGS__)
1688	#endif
1689
1690	/*
1691	* debug assertion checking
1692	*/
1693	#if 1 // defined(__KDEBUGALL)
1694
1695	#define ASSERT(X) \
1696	do { \
1697	if (unlikely(!(X))) { \
1698	printk(KERN_ERR "\n"); \
1699	printk(KERN_ERR "AFS: Assertion failed\n"); \
1700	BUG(); \
1701	} \
1702	} while(0)
1703
1704	#define ASSERTCMP(X, OP, Y) \
1705	do { \
1706	if (unlikely(!((X) OP (Y)))) { \
1707	printk(KERN_ERR "\n"); \
1708	printk(KERN_ERR "AFS: Assertion failed\n"); \
1709	printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1710	(unsigned long)(X), (unsigned long)(Y)); \
1711	printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1712	(unsigned long)(X), (unsigned long)(Y)); \
1713	BUG(); \
1714	} \
1715	} while(0)
1716
1717	#define ASSERTRANGE(L, OP1, N, OP2, H) \
1718	do { \
1719	if (unlikely(!((L) OP1 (N)) || !((N) OP2 (H)))) { \
1720	printk(KERN_ERR "\n"); \
1721	printk(KERN_ERR "AFS: Assertion failed\n"); \
1722	printk(KERN_ERR "%lu "#OP1" %lu "#OP2" %lu is false\n", \
1723	(unsigned long)(L), (unsigned long)(N), \
1724	(unsigned long)(H)); \
1725	printk(KERN_ERR "0x%lx "#OP1" 0x%lx "#OP2" 0x%lx is false\n", \
1726	(unsigned long)(L), (unsigned long)(N), \
1727	(unsigned long)(H)); \
1728	BUG(); \
1729	} \
1730	} while(0)
1731
1732	#define ASSERTIF(C, X) \
1733	do { \
1734	if (unlikely((C) && !(X))) { \
1735	printk(KERN_ERR "\n"); \
1736	printk(KERN_ERR "AFS: Assertion failed\n"); \
1737	BUG(); \
1738	} \
1739	} while(0)
1740
1741	#define ASSERTIFCMP(C, X, OP, Y) \
1742	do { \
1743	if (unlikely((C) && !((X) OP (Y)))) { \
1744	printk(KERN_ERR "\n"); \
1745	printk(KERN_ERR "AFS: Assertion failed\n"); \
1746	printk(KERN_ERR "%lu " #OP " %lu is false\n", \
1747	(unsigned long)(X), (unsigned long)(Y)); \
1748	printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
1749	(unsigned long)(X), (unsigned long)(Y)); \
1750	BUG(); \
1751	} \
1752	} while(0)
1753
1754	#else
1755
1756	#define ASSERT(X) \
1757	do { \
1758	} while(0)
1759
1760	#define ASSERTCMP(X, OP, Y) \
1761	do { \
1762	} while(0)
1763
1764	#define ASSERTRANGE(L, OP1, N, OP2, H) \
1765	do { \
1766	} while(0)
1767
1768	#define ASSERTIF(C, X) \
1769	do { \
1770	} while(0)
1771
1772	#define ASSERTIFCMP(C, X, OP, Y) \
1773	do { \
1774	} while(0)
1775
1776	#endif /* __KDEBUGALL */
1777