~hc/RK356X_SDK_RELEASE.git

..	..	@@ -1,12 +1,8 @@
	1	+/* SPDX-License-Identifier: GPL-2.0-or-later */
1	2	/* internal AFS stuff
2	3	*
3	4	* Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4	5	* Written by David Howells (dhowells@redhat.com)
5		- *
6		- * This program is free software; you can redistribute it and/or
7		- * modify it under the terms of the GNU General Public License
8		- * as published by the Free Software Foundation; either version
9		- * 2 of the License, or (at your option) any later version.
10	6	*/
11	7
12	8	#include <linux/compiler.h>
..	..	@@ -22,6 +18,7 @@
22	18	#include <linux/backing-dev.h>
23	19	#include <linux/uuid.h>
24	20	#include <linux/mm_types.h>
	21	+#include <linux/dns_resolver.h>
25	22	#include <net/net_namespace.h>
26	23	#include <net/netns/generic.h>
27	24	#include <net/sock.h>
..	..	@@ -35,24 +32,31 @@
35	32	struct pagevec;
36	33	struct afs_call;
37	34
38		-struct afs_mount_params {
39		- bool rwpath; /* T if the parent should be considered R/W */
	35	+/*
	36	+ * Partial file-locking emulation mode. (The problem being that AFS3 only
	37	+ * allows whole-file locks and no upgrading/downgrading).
	38	+ */
	39	+enum afs_flock_mode {
	40	+ afs_flock_mode_unset,
	41	+ afs_flock_mode_local, /* Local locking only */
	42	+ afs_flock_mode_openafs, /* Don't get server lock for a partial lock */
	43	+ afs_flock_mode_strict, /* Always get a server lock for a partial lock */
	44	+ afs_flock_mode_write, /* Get an exclusive server lock for a partial lock */
	45	+};
	46	+
	47	+struct afs_fs_context {
40	48	bool force; /* T to force cell type */
41	49	bool autocell; /* T if set auto mount operation */
42	50	bool dyn_root; /* T if dynamic root */
	51	+ bool no_cell; /* T if the source is "none" (for dynroot) */
	52	+ enum afs_flock_mode flock_mode; /* Partial file-locking emulation mode */
43	53	afs_voltype_t type; /* type of volume requested */
44		- int volnamesz; /* size of volume name */
	54	+ unsigned int volnamesz; /* size of volume name */
45	55	const char volname; / name of volume to mount */
46		- struct net net_ns; / Network namespace in effect */
47	56	struct afs_net net; / the AFS net namespace stuff */
48	57	struct afs_cell cell; / cell in which to find volume */
49	58	struct afs_volume volume; / volume record */
50	59	struct key key; / key to use for secure mounting */
51		-};
52		-
53		-struct afs_iget_data {
54		- struct afs_fid fid;
55		- struct afs_volume volume; / volume on which resides */
56	60	};
57	61
58	62	enum afs_call_state {
..	..	@@ -70,15 +74,19 @@
70	74	* List of server addresses.
71	75	*/
72	76	struct afs_addr_list {
73		- struct rcu_head rcu; /* Must be first */
	77	+ struct rcu_head rcu;
74	78	refcount_t usage;
75	79	u32 version; /* Version */
76		- unsigned short nr_addrs;
77		- unsigned short index; /* Address currently in use */
78		- unsigned short nr_ipv4; /* Number of IPv4 addresses */
79		- unsigned long probed; /* Mask of servers that have been probed */
80		- unsigned long yfs; /* Mask of servers that are YFS */
	80	+ unsigned char max_addrs;
	81	+ unsigned char nr_addrs;
	82	+ unsigned char preferred; /* Preferred address */
	83	+ unsigned char nr_ipv4; /* Number of IPv4 addresses */
	84	+ enum dns_record_source source:8;
	85	+ enum dns_lookup_status status:8;
	86	+ unsigned long failed; /* Mask of addrs that failed locally/ICMP */
	87	+ unsigned long responded; /* Mask of addrs that responded */
81	88	struct sockaddr_rxrpc addrs[];
	89	+#define AFS_MAX_ADDRESSES ((unsigned int)(sizeof(unsigned long) * 8))
82	90	};
83	91
84	92	/*
..	..	@@ -86,48 +94,61 @@
86	94	*/
87	95	struct afs_call {
88	96	const struct afs_call_type type; / type of call */
	97	+ struct afs_addr_list alist; / Address is alist[addr_ix] */
89	98	wait_queue_head_t waitq; /* processes awaiting completion */
90	99	struct work_struct async_work; /* async I/O processor */
91	100	struct work_struct work; /* actual work processor */
92	101	struct rxrpc_call rxcall; / RxRPC call handle */
93	102	struct key key; / security for this call */
94	103	struct afs_net net; / The network namespace */
95		- struct afs_server cm_server; / Server affected by incoming CM call */
96		- struct afs_cb_interest cbi; / Callback interest for server used */
	104	+ struct afs_server server; / The fileserver record if fs op (pins ref) */
	105	+ struct afs_vlserver vlserver; / The vlserver record if vl op */
97	106	void request; / request data (first part) */
98		- struct address_space mapping; / Pages being written from */
	107	+ struct iov_iter def_iter; /* Default buffer/data iterator */
	108	+ struct iov_iter iter; / Iterator currently in use */
	109	+ union { /* Convenience for ->def_iter */
	110	+ struct kvec kvec[1];
	111	+ struct bio_vec bvec[1];
	112	+ };
99	113	void buffer; / reply receive buffer */
100		- void reply[4]; / Where to put the reply */
101		- pgoff_t first; /* first page in mapping to deal with */
102		- pgoff_t last; /* last page in mapping to deal with */
103		- size_t offset; /* offset into received data store */
	114	+ union {
	115	+ long ret0; /* Value to reply with instead of 0 */
	116	+ struct afs_addr_list *ret_alist;
	117	+ struct afs_vldb_entry *ret_vldb;
	118	+ char *ret_str;
	119	+ };
	120	+ struct afs_operation *op;
	121	+ unsigned int server_index;
104	122	atomic_t usage;
105	123	enum afs_call_state state;
106	124	spinlock_t state_lock;
107	125	int error; /* error code */
108	126	u32 abort_code; /* Remote abort ID or 0 */
	127	+ unsigned int max_lifespan; /* Maximum lifespan to set if not 0 */
109	128	unsigned request_size; /* size of request data */
110	129	unsigned reply_max; /* maximum size of reply */
111		- unsigned first_offset; /* offset into mapping[first] */
112		- unsigned int cb_break; /* cb_break + cb_s_break before the call */
113		- union {
114		- unsigned last_to; /* amount of mapping[last] */
115		- unsigned count2; /* count used in unmarshalling */
116		- };
	130	+ unsigned count2; /* count used in unmarshalling */
117	131	unsigned char unmarshall; /* unmarshalling phase */
118		- bool incoming; /* T if incoming call */
	132	+ unsigned char addr_ix; /* Address in ->alist */
	133	+ bool drop_ref; /* T if need to drop ref for incoming call */
119	134	bool send_pages; /* T if data from mapping should be sent */
120	135	bool need_attention; /* T if RxRPC poked us */
121	136	bool async; /* T if asynchronous */
122		- bool ret_reply0; /* T if should return reply[0] on success */
123	137	bool upgrade; /* T to request service upgrade */
	138	+ bool intr; /* T if interruptible */
	139	+ bool unmarshalling_error; /* T if an unmarshalling error occurred */
124	140	u16 service_id; /* Actual service ID (after upgrade) */
125	141	unsigned int debug_id; /* Trace ID */
126	142	u32 operation_ID; /* operation ID for an incoming call */
127	143	u32 count; /* count for use in unmarshalling */
128		- __be32 tmp; /* place to extract temporary data */
129		- afs_dataversion_t expected_version; /* Updated version expected from store */
130		- afs_dataversion_t expected_version_2; /* 2nd updated version expected from store */
	144	+ union { /* place to extract temporary data */
	145	+ struct {
	146	+ __be32 tmp_u;
	147	+ __be32 tmp;
	148	+ } __attribute__((packed));
	149	+ __be64 tmp64;
	150	+ };
	151	+ ktime_t issue_time; /* Time of issue of operation */
131	152	};
132	153
133	154	struct afs_call_type {
..	..	@@ -144,6 +165,9 @@
144	165
145	166	/* Work function */
146	167	void (work)(struct work_struct work);
	168	+
	169	+ /* Call done function (gets called immediately on success or failure) */
	170	+ void (done)(struct afs_call call);
147	171	};
148	172
149	173	/*
..	..	@@ -183,7 +207,9 @@
183	207	refcount_t usage;
184	208	unsigned int index; /* Which page we're reading into */
185	209	unsigned int nr_pages;
186		- void (page_done)(struct afs_call , struct afs_read *);
	210	+ unsigned int offset; /* offset into current page */
	211	+ struct afs_vnode *vnode;
	212	+ void (page_done)(struct afs_read );
187	213	struct page **pages;
188	214	struct page *array[];
189	215	};
..	..	@@ -196,6 +222,7 @@
196	222	struct net net_ns; / Network namespace */
197	223	struct afs_cell cell; / The cell in which the volume resides */
198	224	struct afs_volume volume; / volume record */
	225	+ enum afs_flock_mode flock_mode:8; /* File locking emulation mode */
199	226	bool dyn_root; /* True if dynamic root */
200	227	};
201	228
..	..	@@ -235,11 +262,12 @@
235	262
236	263	/* Cell database */
237	264	struct rb_root cells;
238		- struct afs_cell __rcu *ws_cell;
	265	+ struct afs_cell *ws_cell;
239	266	struct work_struct cells_manager;
240	267	struct timer_list cells_timer;
241	268	atomic_t cells_outstanding;
242		- seqlock_t cells_lock;
	269	+ struct rw_semaphore cells_lock;
	270	+ struct mutex cells_alias_lock;
243	271
244	272	struct mutex proc_cells_lock;
245	273	struct hlist_head proc_cells;
..	..	@@ -248,9 +276,10 @@
248	276	* cell, but in practice, people create aliases and subsets and there's
249	277	* no easy way to distinguish them.
250	278	*/
251		- seqlock_t fs_lock; /* For fs_servers */
	279	+ seqlock_t fs_lock; /* For fs_servers, fs_probe_, fs_proc /
252	280	struct rb_root fs_servers; /* afs_server (by server UUID or address) */
253		- struct list_head fs_updates; /* afs_server (by update_at) */
	281	+ struct list_head fs_probe_fast; /* List of afs_server to probe at 30s intervals */
	282	+ struct list_head fs_probe_slow; /* List of afs_server to probe at 5m intervals */
254	283	struct hlist_head fs_proc; /* procfs servers list */
255	284
256	285	struct hlist_head fs_addresses4; /* afs_server (by lowest IPv4 addr) */
..	..	@@ -259,6 +288,9 @@
259	288
260	289	struct work_struct fs_manager;
261	290	struct timer_list fs_timer;
	291	+
	292	+ struct work_struct fs_prober;
	293	+ struct timer_list fs_probe_timer;
262	294	atomic_t servers_outstanding;
263	295
264	296	/* File locking renewal management */
..	..	@@ -293,6 +325,7 @@
293	325	AFS_CELL_DEACTIVATING,
294	326	AFS_CELL_INACTIVE,
295	327	AFS_CELL_FAILED,
	328	+ AFS_CELL_REMOVED,
296	329	};
297	330
298	331	/*
..	..	@@ -309,8 +342,10 @@
309	342	* for authentication and encryption. The cell name is not typically used in
310	343	* the protocol.
311	344	*
312		- * There is no easy way to determine if two cells are aliases or one is a
313		- * subset of another.
	345	+ * Two cells are determined to be aliases if they have an explicit alias (YFS
	346	+ * only), share any VL servers in common or have at least one volume in common.
	347	+ * "In common" means that the address list of the VL servers or the fileservers
	348	+ * share at least one endpoint.
314	349	*/
315	350	struct afs_cell {
316	351	union {
..	..	@@ -318,6 +353,8 @@
318	353	struct rb_node net_node; /* Node in net->cells */
319	354	};
320	355	struct afs_net *net;
	356	+ struct afs_cell alias_of; / The cell this is an alias of */
	357	+ struct afs_volume root_volume; / The root.cell volume if there is one */
321	358	struct key anonymous_key; / anonymous user key for this cell */
322	359	struct work_struct manager; /* Manager for init/deinit/dns */
323	360	struct hlist_node proc_link; /* /proc cell list link */
..	..	@@ -326,25 +363,92 @@
326	363	#endif
327	364	time64_t dns_expiry; /* Time AFSDB/SRV record expires */
328	365	time64_t last_inactive; /* Time of last drop of usage count */
329		- atomic_t usage;
	366	+ atomic_t ref; /* Struct refcount */
	367	+ atomic_t active; /* Active usage counter */
330	368	unsigned long flags;
331		-#define AFS_CELL_FL_NOT_READY 0 /* The cell record is not ready for use */
332		-#define AFS_CELL_FL_NO_GC 1 /* The cell was added manually, don't auto-gc */
333		-#define AFS_CELL_FL_NOT_FOUND 2 /* Permanent DNS error */
334		-#define AFS_CELL_FL_DNS_FAIL 3 /* Failed to access DNS */
335		-#define AFS_CELL_FL_NO_LOOKUP_YET 4 /* Not completed first DNS lookup yet */
	369	+#define AFS_CELL_FL_NO_GC 0 /* The cell was added manually, don't auto-gc */
	370	+#define AFS_CELL_FL_DO_LOOKUP 1 /* DNS lookup requested */
	371	+#define AFS_CELL_FL_CHECK_ALIAS 2 /* Need to check for aliases */
336	372	enum afs_cell_state state;
337	373	short error;
	374	+ enum dns_record_source dns_source:8; /* Latest source of data from lookup */
	375	+ enum dns_lookup_status dns_status:8; /* Latest status of data from lookup */
	376	+ unsigned int dns_lookup_count; /* Counter of DNS lookups */
	377	+ unsigned int debug_id;
	378	+
	379	+ /* The volumes belonging to this cell */
	380	+ struct rb_root volumes; /* Tree of volumes on this server */
	381	+ struct hlist_head proc_volumes; /* procfs volume list */
	382	+ seqlock_t volume_lock; /* For volumes */
338	383
339	384	/* Active fileserver interaction state. */
340		- struct list_head proc_volumes; /* procfs volume list */
341		- rwlock_t proc_lock;
	385	+ struct rb_root fs_servers; /* afs_server (by server UUID) */
	386	+ seqlock_t fs_lock; /* For fs_servers */
342	387
343	388	/* VL server list. */
344		- rwlock_t vl_addrs_lock; /* Lock on vl_addrs */
345		- struct afs_addr_list __rcu vl_addrs; / List of VL servers */
	389	+ rwlock_t vl_servers_lock; /* Lock on vl_servers */
	390	+ struct afs_vlserver_list __rcu *vl_servers;
	391	+
346	392	u8 name_len; /* Length of name */
347		- char name[64 + 1]; /* Cell name, case-flattened and NUL-padded */
	393	+ char name; / Cell name, case-flattened and NUL-padded */
	394	+};
	395	+
	396	+/*
	397	+ * Volume Location server record.
	398	+ */
	399	+struct afs_vlserver {
	400	+ struct rcu_head rcu;
	401	+ struct afs_addr_list __rcu addresses; / List of addresses for this VL server */
	402	+ unsigned long flags;
	403	+#define AFS_VLSERVER_FL_PROBED 0 /* The VL server has been probed */
	404	+#define AFS_VLSERVER_FL_PROBING 1 /* VL server is being probed */
	405	+#define AFS_VLSERVER_FL_IS_YFS 2 /* Server is YFS not AFS */
	406	+#define AFS_VLSERVER_FL_RESPONDING 3 /* VL server is responding */
	407	+ rwlock_t lock; /* Lock on addresses */
	408	+ atomic_t usage;
	409	+ unsigned int rtt; /* Server's current RTT in uS */
	410	+
	411	+ /* Probe state */
	412	+ wait_queue_head_t probe_wq;
	413	+ atomic_t probe_outstanding;
	414	+ spinlock_t probe_lock;
	415	+ struct {
	416	+ unsigned int rtt; /* RTT in uS */
	417	+ u32 abort_code;
	418	+ short error;
	419	+ unsigned short flags;
	420	+#define AFS_VLSERVER_PROBE_RESPONDED 0x01 /* At least once response (may be abort) */
	421	+#define AFS_VLSERVER_PROBE_IS_YFS 0x02 /* The peer appears to be YFS */
	422	+#define AFS_VLSERVER_PROBE_NOT_YFS 0x04 /* The peer appears not to be YFS */
	423	+#define AFS_VLSERVER_PROBE_LOCAL_FAILURE 0x08 /* A local failure prevented a probe */
	424	+ } probe;
	425	+
	426	+ u16 port;
	427	+ u16 name_len; /* Length of name */
	428	+ char name[]; /* Server name, case-flattened */
	429	+};
	430	+
	431	+/*
	432	+ * Weighted list of Volume Location servers.
	433	+ */
	434	+struct afs_vlserver_entry {
	435	+ u16 priority; /* Preference (as SRV) */
	436	+ u16 weight; /* Weight (as SRV) */
	437	+ enum dns_record_source source:8;
	438	+ enum dns_lookup_status status:8;
	439	+ struct afs_vlserver *server;
	440	+};
	441	+
	442	+struct afs_vlserver_list {
	443	+ struct rcu_head rcu;
	444	+ atomic_t usage;
	445	+ u8 nr_servers;
	446	+ u8 index; /* Server currently in use */
	447	+ u8 preferred; /* Preferred server */
	448	+ enum dns_record_source source:8;
	449	+ enum dns_lookup_status status:8;
	450	+ rwlock_t lock;
	451	+ struct afs_vlserver_entry servers[];
348	452	};
349	453
350	454	/*
..	..	@@ -363,6 +467,7 @@
363	467	#define AFS_VLDB_QUERY_ERROR 4 /* - VL server returned error */
364	468
365	469	uuid_t fs_server[AFS_NMAXNSERVERS];
	470	+ u32 addr_version[AFS_NMAXNSERVERS]; /* Registration change counters */
366	471	u8 fs_mask[AFS_NMAXNSERVERS];
367	472	#define AFS_VOL_VTM_RW 0x01 /* R/W version of the volume is available (on this server) */
368	473	#define AFS_VOL_VTM_RO 0x02 /* R/O version of the volume is available (on this server) */
..	..	@@ -384,69 +489,67 @@
384	489	};
385	490
386	491	struct afs_addr_list __rcu *addresses;
387		- struct rb_node uuid_rb; /* Link in net->servers */
	492	+ struct afs_cell cell; / Cell to which belongs (pins ref) */
	493	+ struct rb_node uuid_rb; /* Link in net->fs_servers */
	494	+ struct afs_server __rcu uuid_next; / Next server with same UUID */
	495	+ struct afs_server uuid_prev; / Previous server with same UUID */
	496	+ struct list_head probe_link; /* Link in net->fs_probe_list */
388	497	struct hlist_node addr4_link; /* Link in net->fs_addresses4 */
389	498	struct hlist_node addr6_link; /* Link in net->fs_addresses6 */
390	499	struct hlist_node proc_link; /* Link in net->fs_proc */
391	500	struct afs_server gc_next; / Next server in manager's list */
392		- time64_t put_time; /* Time at which last put */
393		- time64_t update_at; /* Time at which to next update the record */
	501	+ time64_t unuse_time; /* Time at which last unused */
394	502	unsigned long flags;
395		-#define AFS_SERVER_FL_NEW 0 /* New server, don't inc cb_s_break */
396		-#define AFS_SERVER_FL_NOT_READY 1 /* The record is not ready for use */
397		-#define AFS_SERVER_FL_NOT_FOUND 2 /* VL server says no such server */
398		-#define AFS_SERVER_FL_VL_FAIL 3 /* Failed to access VL server */
399		-#define AFS_SERVER_FL_UPDATING 4
400		-#define AFS_SERVER_FL_PROBED 5 /* The fileserver has been probed */
401		-#define AFS_SERVER_FL_PROBING 6 /* Fileserver is being probed */
402		-#define AFS_SERVER_FL_NO_IBULK 7 /* Fileserver doesn't support FS.InlineBulkStatus */
	503	+#define AFS_SERVER_FL_RESPONDING 0 /* The server is responding */
	504	+#define AFS_SERVER_FL_UPDATING 1
	505	+#define AFS_SERVER_FL_NEEDS_UPDATE 2 /* Fileserver address list is out of date */
	506	+#define AFS_SERVER_FL_NOT_READY 4 /* The record is not ready for use */
	507	+#define AFS_SERVER_FL_NOT_FOUND 5 /* VL server says no such server */
	508	+#define AFS_SERVER_FL_VL_FAIL 6 /* Failed to access VL server */
403	509	#define AFS_SERVER_FL_MAY_HAVE_CB 8 /* May have callbacks on this fileserver */
404		- atomic_t usage;
	510	+#define AFS_SERVER_FL_IS_YFS 16 /* Server is YFS not AFS */
	511	+#define AFS_SERVER_FL_NO_IBULK 17 /* Fileserver doesn't support FS.InlineBulkStatus */
	512	+#define AFS_SERVER_FL_NO_RM2 18 /* Fileserver doesn't support YFS.RemoveFile2 */
	513	+ atomic_t ref; /* Object refcount */
	514	+ atomic_t active; /* Active user count */
405	515	u32 addr_version; /* Address list version */
	516	+ unsigned int rtt; /* Server's current RTT in uS */
	517	+ unsigned int debug_id; /* Debugging ID for traces */
406	518
407	519	/* file service access */
408	520	rwlock_t fs_lock; /* access lock */
409	521
410	522	/* callback promise management */
411		- struct hlist_head cb_volumes; /* List of volume interests on this server */
412	523	unsigned cb_s_break; /* Break-everything counter. */
413		- rwlock_t cb_break_lock; /* Volume finding lock */
	524	+
	525	+ /* Probe state */
	526	+ unsigned long probed_at; /* Time last probe was dispatched (jiffies) */
	527	+ wait_queue_head_t probe_wq;
	528	+ atomic_t probe_outstanding;
	529	+ spinlock_t probe_lock;
	530	+ struct {
	531	+ unsigned int rtt; /* RTT in uS */
	532	+ u32 abort_code;
	533	+ short error;
	534	+ bool responded:1;
	535	+ bool is_yfs:1;
	536	+ bool not_yfs:1;
	537	+ bool local_failure:1;
	538	+ } probe;
414	539	};
415	540
416	541	/*
417		- * Volume collation in the server's callback interest list.
418		- */
419		-struct afs_vol_interest {
420		- struct hlist_node srv_link; /* Link in server->cb_volumes */
421		- struct hlist_head cb_interests; /* List of callback interests on the server */
422		- afs_volid_t vid; /* Volume ID to match */
423		- unsigned int usage;
424		-};
425		-
426		-/*
427		- * Interest by a superblock on a server.
428		- */
429		-struct afs_cb_interest {
430		- struct hlist_node cb_vlink; /* Link in vol_interest->cb_interests */
431		- struct afs_vol_interest *vol_interest;
432		- struct afs_server server; / Server on which this interest resides */
433		- struct super_block sb; / Superblock on which inodes reside */
434		- afs_volid_t vid; /* Volume ID to match */
435		- refcount_t usage;
436		-};
437		-
438		-/*
439		- * Replaceable server list.
	542	+ * Replaceable volume server list.
440	543	*/
441	544	struct afs_server_entry {
442	545	struct afs_server *server;
443		- struct afs_cb_interest *cb_interest;
444	546	};
445	547
446	548	struct afs_server_list {
	549	+ afs_volid_t vids[AFS_MAXTYPES]; /* Volume IDs */
447	550	refcount_t usage;
448		- unsigned short nr_servers;
449		- unsigned short index; /* Server currently in use */
	551	+ unsigned char nr_servers;
	552	+ unsigned char preferred; /* Preferred server */
450	553	unsigned short vnovol_mask; /* Servers to be skipped due to VNOVOL */
451	554	unsigned int seq; /* Set to ->servers_seq when installed */
452	555	rwlock_t lock;
..	..	@@ -457,11 +560,16 @@
457	560	* Live AFS volume management.
458	561	*/
459	562	struct afs_volume {
460		- afs_volid_t vid; /* volume ID */
	563	+ union {
	564	+ struct rcu_head rcu;
	565	+ afs_volid_t vid; /* volume ID */
	566	+ };
461	567	atomic_t usage;
462	568	time64_t update_at; /* Time at which to next update */
463	569	struct afs_cell cell; / Cell to which belongs (pins ref) */
464		- struct list_head proc_link; /* Link in cell->vl_proc */
	570	+ struct rb_node cell_node; /* Link in cell->volumes */
	571	+ struct hlist_node proc_link; /* Link in cell->proc_volumes */
	572	+ struct super_block __rcu sb; / Superblock on which inodes reside */
465	573	unsigned long flags;
466	574	#define AFS_VOLUME_NEEDS_UPDATE 0 /* - T if an update needs performing */
467	575	#define AFS_VOLUME_UPDATING 1 /* - T if an update is in progress */
..	..	@@ -469,10 +577,11 @@
469	577	#define AFS_VOLUME_DELETED 3 /* - T if volume appears deleted */
470	578	#define AFS_VOLUME_OFFLINE 4 /* - T if volume offline notice given */
471	579	#define AFS_VOLUME_BUSY 5 /* - T if volume busy notice given */
	580	+#define AFS_VOLUME_MAYBE_NO_IBULK 6 /* - T if some servers don't have InlineBulkStatus */
472	581	#ifdef CONFIG_AFS_FSCACHE
473	582	struct fscache_cookie cache; / caching cookie */
474	583	#endif
475		- struct afs_server_list servers; / List of servers on which volume resides */
	584	+ struct afs_server_list __rcu servers; / List of servers on which volume resides */
476	585	rwlock_t servers_lock; /* Lock for ->servers */
477	586	unsigned int servers_seq; /* Incremented each time ->servers changes */
478	587
..	..	@@ -480,7 +589,6 @@
480	589	rwlock_t cb_v_break_lock;
481	590
482	591	afs_voltype_t type; /* type of volume */
483		- short error;
484	592	char type_force; /* force volume type (suppress R/O -> R/W) */
485	593	u8 name_len;
486	594	u8 name[AFS_MAXVOLNAME + 1]; /* NUL-padded volume name */
..	..	@@ -494,6 +602,7 @@
494	602	AFS_VNODE_LOCK_EXTENDING, /* We're extending a lock on the server */
495	603	AFS_VNODE_LOCK_NEED_UNLOCK, /* We need to unlock on the server */
496	604	AFS_VNODE_LOCK_UNLOCKING, /* We're telling the server to unlock */
	605	+ AFS_VNODE_LOCK_DELETED, /* The vnode has been deleted whilst we have a lock */
497	606	};
498	607
499	608	/*
..	..	@@ -515,6 +624,8 @@
515	624	struct afs_permits __rcu permit_cache; / cache of permits so far obtained */
516	625	struct mutex io_lock; /* Lock for serialising I/O on this mutex */
517	626	struct rw_semaphore validate_lock; /* lock for validating this vnode */
	627	+ struct rw_semaphore rmdir_lock; /* Lock for rmdir vs sillyrename */
	628	+ struct key silly_key; / Silly rename key */
518	629	spinlock_t wb_lock; /* lock for wb_keys */
519	630	spinlock_t lock; /* waitqueue/flags lock */
520	631	unsigned long flags;
..	..	@@ -527,26 +638,36 @@
527	638	#define AFS_VNODE_AUTOCELL 6 /* set if Vnode is an auto mount point */
528	639	#define AFS_VNODE_PSEUDODIR 7 /* set if Vnode is a pseudo directory */
529	640	#define AFS_VNODE_NEW_CONTENT 8 /* Set if file has new content (create/trunc-0) */
	641	+#define AFS_VNODE_SILLY_DELETED 9 /* Set if file has been silly-deleted */
	642	+#define AFS_VNODE_MODIFYING 10 /* Set if we're performing a modification op */
530	643
531	644	struct list_head wb_keys; /* List of keys available for writeback */
532	645	struct list_head pending_locks; /* locks waiting to be granted */
533	646	struct list_head granted_locks; /* locks granted on this file */
534	647	struct delayed_work lock_work; /* work to be done in locking */
535	648	struct key lock_key; / Key to be used in lock ops */
	649	+ ktime_t locked_at; /* Time at which lock obtained */
536	650	enum afs_lock_state lock_state : 8;
537	651	afs_lock_type_t lock_type : 8;
538	652
539	653	/* outstanding callback notification on this file */
540		- struct afs_cb_interest cb_interest; / Server on which this resides */
	654	+ void cb_server; / Server with callback/filelock */
541	655	unsigned int cb_s_break; /* Mass break counter on ->server */
542	656	unsigned int cb_v_break; /* Mass break counter on ->volume */
543	657	unsigned int cb_break; /* Break counter on vnode */
544		- seqlock_t cb_lock; /* Lock for ->cb_interest, ->status, ->cb_break /
	658	+ seqlock_t cb_lock; /* Lock for ->cb_server, ->status, ->cb_break /
545	659
546	660	time64_t cb_expires_at; /* time at which callback expires */
547		- unsigned cb_version; /* callback version */
548		- afs_callback_type_t cb_type; /* type of callback */
549	661	};
	662	+
	663	+static inline struct fscache_cookie afs_vnode_cache(struct afs_vnode vnode)
	664	+{
	665	+#ifdef CONFIG_AFS_FSCACHE
	666	+ return vnode->cache;
	667	+#else
	668	+ return NULL;
	669	+#endif
	670	+}
550	671
551	672	/*
552	673	* cached security record for one user's attempt to access a vnode
..	..	@@ -571,12 +692,11 @@
571	692	};
572	693
573	694	/*
574		- * record of one of a system's set of network interfaces
	695	+ * Error prioritisation and accumulation.
575	696	*/
576		-struct afs_interface {
577		- struct in_addr address; /* IPv4 address bound to interface */
578		- struct in_addr netmask; /* netmask applied to address */
579		- unsigned mtu; /* MTU of interface */
	697	+struct afs_error {
	698	+ short error; /* Accumulated error */
	699	+ bool responded; /* T if server responded */
580	700	};
581	701
582	702	/*
..	..	@@ -584,35 +704,153 @@
584	704	*/
585	705	struct afs_addr_cursor {
586	706	struct afs_addr_list alist; / Current address list (pins ref) */
587		- struct sockaddr_rxrpc *addr;
588		- u32 abort_code;
589		- unsigned short start; /* Starting point in alist->addrs[] */
590		- unsigned short index; /* Wrapping offset from start to current addr */
591		- short error;
592		- bool begun; /* T if we've begun iteration */
	707	+ unsigned long tried; /* Tried addresses */
	708	+ signed char index; /* Current address */
593	709	bool responded; /* T if the current address responded */
	710	+ unsigned short nr_iterations; /* Number of address iterations */
	711	+ short error;
	712	+ u32 abort_code;
594	713	};
595	714
596	715	/*
597		- * Cursor for iterating over a set of fileservers.
	716	+ * Cursor for iterating over a set of volume location servers.
598	717	*/
599		-struct afs_fs_cursor {
	718	+struct afs_vl_cursor {
600	719	struct afs_addr_cursor ac;
601		- struct afs_vnode *vnode;
602		- struct afs_server_list server_list; / Current server list (pins ref) */
603		- struct afs_cb_interest cbi; / Server on which this resides (pins ref) */
	720	+ struct afs_cell cell; / The cell we're querying */
	721	+ struct afs_vlserver_list server_list; / Current server list (pins ref) */
	722	+ struct afs_vlserver server; / Server on which this resides */
604	723	struct key key; / Key for the server */
605		- unsigned int cb_break; /* cb_break + cb_s_break before the call */
606		- unsigned int cb_break_2; /* cb_break + cb_s_break (2nd vnode) */
607		- unsigned char start; /* Initial index in server list */
608		- unsigned char index; /* Number of servers tried beyond start */
	724	+ unsigned long untried; /* Bitmask of untried servers */
	725	+ short index; /* Current server */
	726	+ short error;
609	727	unsigned short flags;
610		-#define AFS_FS_CURSOR_STOP 0x0001 /* Set to cease iteration */
611		-#define AFS_FS_CURSOR_VBUSY 0x0002 /* Set if seen VBUSY */
612		-#define AFS_FS_CURSOR_VMOVED 0x0004 /* Set if seen VMOVED */
613		-#define AFS_FS_CURSOR_VNOVOL 0x0008 /* Set if seen VNOVOL */
614		-#define AFS_FS_CURSOR_CUR_ONLY 0x0010 /* Set if current server only (file lock held) */
615		-#define AFS_FS_CURSOR_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
	728	+#define AFS_VL_CURSOR_STOP 0x0001 /* Set to cease iteration */
	729	+#define AFS_VL_CURSOR_RETRY 0x0002 /* Set to do a retry */
	730	+#define AFS_VL_CURSOR_RETRIED 0x0004 /* Set if started a retry */
	731	+ unsigned short nr_iterations; /* Number of server iterations */
	732	+};
	733	+
	734	+/*
	735	+ * Fileserver operation methods.
	736	+ */
	737	+struct afs_operation_ops {
	738	+ void (issue_afs_rpc)(struct afs_operation op);
	739	+ void (issue_yfs_rpc)(struct afs_operation op);
	740	+ void (success)(struct afs_operation op);
	741	+ void (aborted)(struct afs_operation op);
	742	+ void (edit_dir)(struct afs_operation op);
	743	+ void (put)(struct afs_operation op);
	744	+};
	745	+
	746	+struct afs_vnode_param {
	747	+ struct afs_vnode *vnode;
	748	+ struct afs_fid fid; /* Fid to access */
	749	+ struct afs_status_cb scb; /* Returned status and callback promise */
	750	+ afs_dataversion_t dv_before; /* Data version before the call */
	751	+ unsigned int cb_break_before; /* cb_break + cb_s_break before the call */
	752	+ u8 dv_delta; /* Expected change in data version */
	753	+ bool put_vnode:1; /* T if we have a ref on the vnode */
	754	+ bool need_io_lock:1; /* T if we need the I/O lock on this */
	755	+ bool update_ctime:1; /* Need to update the ctime */
	756	+ bool set_size:1; /* Must update i_size */
	757	+ bool op_unlinked:1; /* True if file was unlinked by op */
	758	+ bool speculative:1; /* T if speculative status fetch (no vnode lock) */
	759	+ bool modification:1; /* Set if the content gets modified */
	760	+};
	761	+
	762	+/*
	763	+ * Fileserver operation wrapper, handling server and address rotation
	764	+ * asynchronously. May make simultaneous calls to multiple servers.
	765	+ */
	766	+struct afs_operation {
	767	+ struct afs_net net; / Network namespace */
	768	+ struct key key; / Key for the cell */
	769	+ const struct afs_call_type type; / Type of call done */
	770	+ const struct afs_operation_ops *ops;
	771	+
	772	+ /* Parameters/results for the operation */
	773	+ struct afs_volume volume; / Volume being accessed */
	774	+ struct afs_vnode_param file[2];
	775	+ struct afs_vnode_param *more_files;
	776	+ struct afs_volsync volsync;
	777	+ struct dentry dentry; / Dentry to be altered */
	778	+ struct dentry dentry_2; / Second dentry to be altered */
	779	+ struct timespec64 mtime; /* Modification time to record */
	780	+ struct timespec64 ctime; /* Change time to set */
	781	+ short nr_files; /* Number of entries in file[], more_files */
	782	+ short error;
	783	+ unsigned int debug_id;
	784	+
	785	+ unsigned int cb_v_break; /* Volume break counter before op */
	786	+ unsigned int cb_s_break; /* Server break counter before op */
	787	+
	788	+ union {
	789	+ struct {
	790	+ int which; /* Which ->file[] to fetch for */
	791	+ } fetch_status;
	792	+ struct {
	793	+ int reason; /* enum afs_edit_dir_reason */
	794	+ mode_t mode;
	795	+ const char *symlink;
	796	+ } create;
	797	+ struct {
	798	+ bool need_rehash;
	799	+ } unlink;
	800	+ struct {
	801	+ struct dentry *rehash;
	802	+ struct dentry *tmp;
	803	+ bool new_negative;
	804	+ } rename;
	805	+ struct {
	806	+ struct afs_read *req;
	807	+ } fetch;
	808	+ struct {
	809	+ afs_lock_type_t type;
	810	+ } lock;
	811	+ struct {
	812	+ struct address_space mapping; / Pages being written from */
	813	+ pgoff_t first; /* first page in mapping to deal with */
	814	+ pgoff_t last; /* last page in mapping to deal with */
	815	+ unsigned first_offset; /* offset into mapping[first] */
	816	+ unsigned last_to; /* amount of mapping[last] */
	817	+ bool laundering; /* Laundering page, PG_writeback not set */
	818	+ } store;
	819	+ struct {
	820	+ struct iattr *attr;
	821	+ loff_t old_i_size;
	822	+ } setattr;
	823	+ struct afs_acl *acl;
	824	+ struct yfs_acl *yacl;
	825	+ struct {
	826	+ struct afs_volume_status vs;
	827	+ struct kstatfs *buf;
	828	+ } volstatus;
	829	+ };
	830	+
	831	+ /* Fileserver iteration state */
	832	+ struct afs_addr_cursor ac;
	833	+ struct afs_server_list server_list; / Current server list (pins ref) */
	834	+ struct afs_server server; / Server we're using (ref pinned by server_list) */
	835	+ struct afs_call *call;
	836	+ unsigned long untried; /* Bitmask of untried servers */
	837	+ short index; /* Current server */
	838	+ unsigned short nr_iterations; /* Number of server iterations */
	839	+
	840	+ unsigned int flags;
	841	+#define AFS_OPERATION_STOP 0x0001 /* Set to cease iteration */
	842	+#define AFS_OPERATION_VBUSY 0x0002 /* Set if seen VBUSY */
	843	+#define AFS_OPERATION_VMOVED 0x0004 /* Set if seen VMOVED */
	844	+#define AFS_OPERATION_VNOVOL 0x0008 /* Set if seen VNOVOL */
	845	+#define AFS_OPERATION_CUR_ONLY 0x0010 /* Set if current server only (file lock held) */
	846	+#define AFS_OPERATION_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
	847	+#define AFS_OPERATION_UNINTR 0x0040 /* Set if op is uninterruptible */
	848	+#define AFS_OPERATION_DOWNGRADE 0x0080 /* Set to retry with downgraded opcode */
	849	+#define AFS_OPERATION_LOCK_0 0x0100 /* Set if have io_lock on file[0] */
	850	+#define AFS_OPERATION_LOCK_1 0x0200 /* Set if have io_lock on file[1] */
	851	+#define AFS_OPERATION_TRIED_ALL 0x0400 /* Set if we've tried all the fileservers */
	852	+#define AFS_OPERATION_RETRY_SERVER 0x0800 /* Set if we should retry the current server */
	853	+#define AFS_OPERATION_DIR_CONFLICT 0x1000 /* Set if we detected a 3rd-party dir change */
616	854	};
617	855
618	856	/*
..	..	@@ -621,6 +859,62 @@
621	859	struct afs_vnode_cache_aux {
622	860	u64 data_version;
623	861	} __packed;
	862	+
	863	+/*
	864	+ * We use page->private to hold the amount of the page that we've written to,
	865	+ * splitting the field into two parts. However, we need to represent a range
	866	+ * 0...PAGE_SIZE, so we reduce the resolution if the size of the page
	867	+ * exceeds what we can encode.
	868	+ */
	869	+#ifdef CONFIG_64BIT
	870	+#define __AFS_PAGE_PRIV_MASK 0x7fffffffUL
	871	+#define __AFS_PAGE_PRIV_SHIFT 32
	872	+#define __AFS_PAGE_PRIV_MMAPPED 0x80000000UL
	873	+#else
	874	+#define __AFS_PAGE_PRIV_MASK 0x7fffUL
	875	+#define __AFS_PAGE_PRIV_SHIFT 16
	876	+#define __AFS_PAGE_PRIV_MMAPPED 0x8000UL
	877	+#endif
	878	+
	879	+static inline unsigned int afs_page_dirty_resolution(void)
	880	+{
	881	+ int shift = PAGE_SHIFT - (__AFS_PAGE_PRIV_SHIFT - 1);
	882	+ return (shift > 0) ? shift : 0;
	883	+}
	884	+
	885	+static inline size_t afs_page_dirty_from(unsigned long priv)
	886	+{
	887	+ unsigned long x = priv & __AFS_PAGE_PRIV_MASK;
	888	+
	889	+ /* The lower bound is inclusive */
	890	+ return x << afs_page_dirty_resolution();
	891	+}
	892	+
	893	+static inline size_t afs_page_dirty_to(unsigned long priv)
	894	+{
	895	+ unsigned long x = (priv >> __AFS_PAGE_PRIV_SHIFT) & __AFS_PAGE_PRIV_MASK;
	896	+
	897	+ /* The upper bound is immediately beyond the region */
	898	+ return (x + 1) << afs_page_dirty_resolution();
	899	+}
	900	+
	901	+static inline unsigned long afs_page_dirty(size_t from, size_t to)
	902	+{
	903	+ unsigned int res = afs_page_dirty_resolution();
	904	+ from >>= res;
	905	+ to = (to - 1) >> res;
	906	+ return (to << __AFS_PAGE_PRIV_SHIFT) \| from;
	907	+}
	908	+
	909	+static inline unsigned long afs_page_dirty_mmapped(unsigned long priv)
	910	+{
	911	+ return priv \| __AFS_PAGE_PRIV_MMAPPED;
	912	+}
	913	+
	914	+static inline bool afs_is_page_dirty_mmapped(unsigned long priv)
	915	+{
	916	+ return priv & __AFS_PAGE_PRIV_MMAPPED;
	917	+}
624	918
625	919	#include <trace/events/afs.h>
626	920
..	..	@@ -638,12 +932,12 @@
638	932	unsigned short,
639	933	unsigned short);
640	934	extern void afs_put_addrlist(struct afs_addr_list *);
641		-extern struct afs_addr_list afs_parse_text_addrs(const char , size_t, char,
642		- unsigned short, unsigned short);
643		-extern struct afs_addr_list afs_dns_query(struct afs_cell , time64_t *);
	935	+extern struct afs_vlserver_list afs_parse_text_addrs(struct afs_net ,
	936	+ const char *, size_t, char,
	937	+ unsigned short, unsigned short);
	938	+extern struct afs_vlserver_list afs_dns_query(struct afs_cell , time64_t *);
644	939	extern bool afs_iterate_addresses(struct afs_addr_cursor *);
645	940	extern int afs_end_cursor(struct afs_addr_cursor *);
646		-extern int afs_set_vl_cursor(struct afs_addr_cursor , struct afs_cell );
647	941
648	942	extern void afs_merge_fs_addr4(struct afs_addr_list *, __be32, u16);
649	943	extern void afs_merge_fs_addr6(struct afs_addr_list , __be32 , u16);
..	..	@@ -666,41 +960,35 @@
666	960	* callback.c
667	961	*/
668	962	extern void afs_init_callback_state(struct afs_server *);
669		-extern void afs_break_callback(struct afs_vnode *);
670		-extern void afs_break_callbacks(struct afs_server , size_t, struct afs_callback_break);
671		-
672		-extern int afs_register_server_cb_interest(struct afs_vnode *,
673		- struct afs_server_list *, unsigned int);
674		-extern void afs_put_cb_interest(struct afs_net , struct afs_cb_interest );
675		-extern void afs_clear_callback_interests(struct afs_net , struct afs_server_list );
676		-
677		-static inline struct afs_cb_interest afs_get_cb_interest(struct afs_cb_interest cbi)
678		-{
679		- if (cbi)
680		- refcount_inc(&cbi->usage);
681		- return cbi;
682		-}
	963	+extern void __afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
	964	+extern void afs_break_callback(struct afs_vnode *, enum afs_cb_break_reason);
	965	+extern void afs_break_callbacks(struct afs_server , size_t, struct afs_callback_break );
683	966
684	967	static inline unsigned int afs_calc_vnode_cb_break(struct afs_vnode *vnode)
685	968	{
686		- return vnode->cb_break + vnode->cb_s_break + vnode->cb_v_break;
	969	+ return vnode->cb_break + vnode->cb_v_break;
687	970	}
688	971
689		-static inline unsigned int afs_cb_break_sum(struct afs_vnode *vnode,
690		- struct afs_cb_interest *cbi)
	972	+static inline bool afs_cb_is_broken(unsigned int cb_break,
	973	+ const struct afs_vnode *vnode)
691	974	{
692		- return vnode->cb_break + cbi->server->cb_s_break + vnode->volume->cb_v_break;
	975	+ return cb_break != (vnode->cb_break + vnode->volume->cb_v_break);
693	976	}
694	977
695	978	/*
696	979	* cell.c
697	980	*/
698	981	extern int afs_cell_init(struct afs_net , const char );
699		-extern struct afs_cell afs_lookup_cell_rcu(struct afs_net , const char *, unsigned);
	982	+extern struct afs_cell afs_find_cell(struct afs_net , const char *, unsigned,
	983	+ enum afs_cell_trace);
700	984	extern struct afs_cell afs_lookup_cell(struct afs_net , const char *, unsigned,
701	985	const char *, bool);
702		-extern struct afs_cell afs_get_cell(struct afs_cell );
703		-extern void afs_put_cell(struct afs_net , struct afs_cell );
	986	+extern struct afs_cell afs_use_cell(struct afs_cell , enum afs_cell_trace);
	987	+extern void afs_unuse_cell(struct afs_net , struct afs_cell , enum afs_cell_trace);
	988	+extern struct afs_cell afs_get_cell(struct afs_cell , enum afs_cell_trace);
	989	+extern void afs_see_cell(struct afs_cell *, enum afs_cell_trace);
	990	+extern void afs_put_cell(struct afs_cell *, enum afs_cell_trace);
	991	+extern void afs_queue_cell(struct afs_cell *, enum afs_cell_trace);
704	992	extern void afs_manage_cells(struct work_struct *);
705	993	extern void afs_cells_timer(struct timer_list *);
706	994	extern void __net_exit afs_cell_purge(struct afs_net *);
..	..	@@ -719,6 +1007,7 @@
719	1007	extern const struct dentry_operations afs_fs_dentry_operations;
720	1008
721	1009	extern void afs_d_release(struct dentry *);
	1010	+extern void afs_check_for_remote_deletion(struct afs_operation *);
722	1011
723	1012	/*
724	1013	* dir_edit.c
..	..	@@ -728,9 +1017,15 @@
728	1017	extern void afs_edit_dir_remove(struct afs_vnode , struct qstr , enum afs_edit_dir_reason);
729	1018
730	1019	/*
	1020	+ * dir_silly.c
	1021	+ */
	1022	+extern int afs_sillyrename(struct afs_vnode , struct afs_vnode ,
	1023	+ struct dentry , struct key );
	1024	+extern int afs_silly_iput(struct dentry , struct inode );
	1025	+
	1026	+/*
731	1027	* dynroot.c
732	1028	*/
733		-extern const struct file_operations afs_dynroot_file_operations;
734	1029	extern const struct inode_operations afs_dynroot_inode_operations;
735	1030	extern const struct dentry_operations afs_dynroot_dentry_operations;
736	1031
..	..	@@ -755,11 +1050,18 @@
755	1050	extern int afs_page_filler(void , struct page );
756	1051	extern void afs_put_read(struct afs_read *);
757	1052
	1053	+static inline struct afs_read afs_get_read(struct afs_read req)
	1054	+{
	1055	+ refcount_inc(&req->usage);
	1056	+ return req;
	1057	+}
	1058	+
758	1059	/*
759	1060	* flock.c
760	1061	*/
761	1062	extern struct workqueue_struct *afs_lock_manager;
762	1063
	1064	+extern void afs_lock_op_done(struct afs_call *);
763	1065	extern void afs_lock_work(struct work_struct *);
764	1066	extern void afs_lock_may_be_available(struct afs_vnode *);
765	1067	extern int afs_lock(struct file , int, struct file_lock );
..	..	@@ -768,53 +1070,85 @@
768	1070	/*
769	1071	* fsclient.c
770	1072	*/
771		-#define AFS_VNODE_NOT_YET_SET 0x01
772		-#define AFS_VNODE_META_CHANGED 0x02
773		-#define AFS_VNODE_DATA_CHANGED 0x04
774		-extern void afs_update_inode_from_status(struct afs_vnode , struct afs_file_status ,
775		- const afs_dataversion_t *, u8);
776		-
777		-extern int afs_fs_fetch_file_status(struct afs_fs_cursor , struct afs_volsync , bool);
778		-extern int afs_fs_give_up_callbacks(struct afs_net , struct afs_server );
779		-extern int afs_fs_fetch_data(struct afs_fs_cursor , struct afs_read );
780		-extern int afs_fs_create(struct afs_fs_cursor , const char , umode_t, u64,
781		- struct afs_fid , struct afs_file_status , struct afs_callback *);
782		-extern int afs_fs_remove(struct afs_fs_cursor , const char , bool, u64);
783		-extern int afs_fs_link(struct afs_fs_cursor , struct afs_vnode , const char *, u64);
784		-extern int afs_fs_symlink(struct afs_fs_cursor , const char , const char *, u64,
785		- struct afs_fid , struct afs_file_status );
786		-extern int afs_fs_rename(struct afs_fs_cursor , const char ,
787		- struct afs_vnode , const char , u64, u64);
788		-extern int afs_fs_store_data(struct afs_fs_cursor , struct address_space ,
789		- pgoff_t, pgoff_t, unsigned, unsigned);
790		-extern int afs_fs_setattr(struct afs_fs_cursor , struct iattr );
791		-extern int afs_fs_get_volume_status(struct afs_fs_cursor , struct afs_volume_status );
792		-extern int afs_fs_set_lock(struct afs_fs_cursor *, afs_lock_type_t);
793		-extern int afs_fs_extend_lock(struct afs_fs_cursor *);
794		-extern int afs_fs_release_lock(struct afs_fs_cursor *);
	1073	+extern void afs_fs_fetch_status(struct afs_operation *);
	1074	+extern void afs_fs_fetch_data(struct afs_operation *);
	1075	+extern void afs_fs_create_file(struct afs_operation *);
	1076	+extern void afs_fs_make_dir(struct afs_operation *);
	1077	+extern void afs_fs_remove_file(struct afs_operation *);
	1078	+extern void afs_fs_remove_dir(struct afs_operation *);
	1079	+extern void afs_fs_link(struct afs_operation *);
	1080	+extern void afs_fs_symlink(struct afs_operation *);
	1081	+extern void afs_fs_rename(struct afs_operation *);
	1082	+extern void afs_fs_store_data(struct afs_operation *);
	1083	+extern void afs_fs_setattr(struct afs_operation *);
	1084	+extern void afs_fs_get_volume_status(struct afs_operation *);
	1085	+extern void afs_fs_set_lock(struct afs_operation *);
	1086	+extern void afs_fs_extend_lock(struct afs_operation *);
	1087	+extern void afs_fs_release_lock(struct afs_operation *);
795	1088	extern int afs_fs_give_up_all_callbacks(struct afs_net , struct afs_server ,
796	1089	struct afs_addr_cursor , struct key );
797		-extern int afs_fs_get_capabilities(struct afs_net , struct afs_server ,
798		- struct afs_addr_cursor , struct key );
799		-extern int afs_fs_inline_bulk_status(struct afs_fs_cursor , struct afs_net ,
800		- struct afs_fid , struct afs_file_status ,
801		- struct afs_callback *, unsigned int,
802		- struct afs_volsync *);
803		-extern int afs_fs_fetch_status(struct afs_fs_cursor , struct afs_net ,
804		- struct afs_fid , struct afs_file_status ,
805		- struct afs_callback , struct afs_volsync );
	1090	+extern bool afs_fs_get_capabilities(struct afs_net , struct afs_server ,
	1091	+ struct afs_addr_cursor , struct key );
	1092	+extern void afs_fs_inline_bulk_status(struct afs_operation *);
	1093	+
	1094	+struct afs_acl {
	1095	+ u32 size;
	1096	+ u8 data[];
	1097	+};
	1098	+
	1099	+extern void afs_fs_fetch_acl(struct afs_operation *);
	1100	+extern void afs_fs_store_acl(struct afs_operation *);
	1101	+
	1102	+/*
	1103	+ * fs_operation.c
	1104	+ */
	1105	+extern struct afs_operation afs_alloc_operation(struct key , struct afs_volume *);
	1106	+extern int afs_put_operation(struct afs_operation *);
	1107	+extern bool afs_begin_vnode_operation(struct afs_operation *);
	1108	+extern void afs_wait_for_operation(struct afs_operation *);
	1109	+extern int afs_do_sync_operation(struct afs_operation *);
	1110	+
	1111	+static inline void afs_op_nomem(struct afs_operation *op)
	1112	+{
	1113	+ op->error = -ENOMEM;
	1114	+}
	1115	+
	1116	+static inline void afs_op_set_vnode(struct afs_operation *op, unsigned int n,
	1117	+ struct afs_vnode *vnode)
	1118	+{
	1119	+ op->file[n].vnode = vnode;
	1120	+ op->file[n].need_io_lock = true;
	1121	+}
	1122	+
	1123	+static inline void afs_op_set_fid(struct afs_operation *op, unsigned int n,
	1124	+ const struct afs_fid *fid)
	1125	+{
	1126	+ op->file[n].fid = *fid;
	1127	+}
	1128	+
	1129	+/*
	1130	+ * fs_probe.c
	1131	+ */
	1132	+extern void afs_fileserver_probe_result(struct afs_call *);
	1133	+extern void afs_fs_probe_fileserver(struct afs_net , struct afs_server , struct key *, bool);
	1134	+extern int afs_wait_for_fs_probes(struct afs_server_list *, unsigned long);
	1135	+extern void afs_probe_fileserver(struct afs_net , struct afs_server );
	1136	+extern void afs_fs_probe_dispatcher(struct work_struct *);
	1137	+extern int afs_wait_for_one_fs_probe(struct afs_server *, bool);
	1138	+extern void afs_fs_probe_cleanup(struct afs_net *);
806	1139
807	1140	/*
808	1141	* inode.c
809	1142	*/
810		-extern int afs_fetch_status(struct afs_vnode , struct key , bool);
811		-extern int afs_iget5_test(struct inode , void );
	1143	+extern const struct afs_operation_ops afs_fetch_status_operation;
	1144	+
	1145	+extern void afs_vnode_commit_status(struct afs_operation , struct afs_vnode_param );
	1146	+extern int afs_fetch_status(struct afs_vnode , struct key , bool, afs_access_t *);
	1147	+extern int afs_ilookup5_test_by_fid(struct inode , void );
812	1148	extern struct inode afs_iget_pseudo_dir(struct super_block , bool);
813		-extern struct inode afs_iget(struct super_block , struct key *,
814		- struct afs_fid , struct afs_file_status ,
815		- struct afs_callback *,
816		- struct afs_cb_interest *);
817		-extern void afs_zap_data(struct afs_vnode *);
	1149	+extern struct inode afs_iget(struct afs_operation , struct afs_vnode_param *);
	1150	+extern struct inode afs_root_iget(struct super_block , struct key *);
	1151	+extern bool afs_check_validity(struct afs_vnode *);
818	1152	extern int afs_validate(struct afs_vnode , struct key );
819	1153	extern int afs_getattr(const struct path , struct kstat , u32, unsigned int);
820	1154	extern int afs_setattr(struct dentry , struct iattr );
..	..	@@ -868,6 +1202,7 @@
868	1202	* misc.c
869	1203	*/
870	1204	extern int afs_abort_to_error(u32);
	1205	+extern void afs_prioritise_error(struct afs_error *, int, u32);
871	1206
872	1207	/*
873	1208	* mntpt.c
..	..	@@ -878,12 +1213,6 @@
878	1213
879	1214	extern struct vfsmount afs_d_automount(struct path );
880	1215	extern void afs_mntpt_kill_timer(void);
881		-
882		-/*
883		- * netdevices.c
884		- */
885		-extern int afs_get_ipv4_interfaces(struct afs_net , struct afs_interface ,
886		- size_t, bool);
887	1216
888	1217	/*
889	1218	* proc.c
..	..	@@ -905,11 +1234,8 @@
905	1234	/*
906	1235	* rotate.c
907	1236	*/
908		-extern bool afs_begin_vnode_operation(struct afs_fs_cursor , struct afs_vnode ,
909		- struct key *);
910		-extern bool afs_select_fileserver(struct afs_fs_cursor *);
911		-extern bool afs_select_current_fileserver(struct afs_fs_cursor *);
912		-extern int afs_end_vnode_operation(struct afs_fs_cursor *);
	1237	+extern bool afs_select_fileserver(struct afs_operation *);
	1238	+extern void afs_dump_edestaddrreq(const struct afs_operation *);
913	1239
914	1240	/*
915	1241	* rxrpc.c
..	..	@@ -920,20 +1246,58 @@
920	1246	extern void __net_exit afs_close_socket(struct afs_net *);
921	1247	extern void afs_charge_preallocation(struct work_struct *);
922	1248	extern void afs_put_call(struct afs_call *);
923		-extern int afs_queue_call_work(struct afs_call *);
924		-extern long afs_make_call(struct afs_addr_cursor , struct afs_call , gfp_t, bool);
	1249	+extern void afs_make_call(struct afs_addr_cursor , struct afs_call , gfp_t);
	1250	+extern long afs_wait_for_call_to_complete(struct afs_call , struct afs_addr_cursor );
925	1251	extern struct afs_call afs_alloc_flat_call(struct afs_net ,
926	1252	const struct afs_call_type *,
927	1253	size_t, size_t);
928	1254	extern void afs_flat_call_destructor(struct afs_call *);
929	1255	extern void afs_send_empty_reply(struct afs_call *);
930	1256	extern void afs_send_simple_reply(struct afs_call , const void , size_t);
931		-extern int afs_extract_data(struct afs_call , void , size_t, bool);
932		-extern int afs_protocol_error(struct afs_call *, int);
	1257	+extern int afs_extract_data(struct afs_call *, bool);
	1258	+extern int afs_protocol_error(struct afs_call *, enum afs_eproto_cause);
	1259	+
	1260	+static inline void afs_make_op_call(struct afs_operation op, struct afs_call call,
	1261	+ gfp_t gfp)
	1262	+{
	1263	+ op->call = call;
	1264	+ op->type = call->type;
	1265	+ call->op = op;
	1266	+ call->key = op->key;
	1267	+ call->intr = !(op->flags & AFS_OPERATION_UNINTR);
	1268	+ afs_make_call(&op->ac, call, gfp);
	1269	+}
	1270	+
	1271	+static inline void afs_extract_begin(struct afs_call call, void buf, size_t size)
	1272	+{
	1273	+ call->kvec[0].iov_base = buf;
	1274	+ call->kvec[0].iov_len = size;
	1275	+ iov_iter_kvec(&call->def_iter, READ, call->kvec, 1, size);
	1276	+}
	1277	+
	1278	+static inline void afs_extract_to_tmp(struct afs_call *call)
	1279	+{
	1280	+ afs_extract_begin(call, &call->tmp, sizeof(call->tmp));
	1281	+}
	1282	+
	1283	+static inline void afs_extract_to_tmp64(struct afs_call *call)
	1284	+{
	1285	+ afs_extract_begin(call, &call->tmp64, sizeof(call->tmp64));
	1286	+}
	1287	+
	1288	+static inline void afs_extract_discard(struct afs_call *call, size_t size)
	1289	+{
	1290	+ iov_iter_discard(&call->def_iter, READ, size);
	1291	+}
	1292	+
	1293	+static inline void afs_extract_to_buf(struct afs_call *call, size_t size)
	1294	+{
	1295	+ afs_extract_begin(call, call->buffer, size);
	1296	+}
933	1297
934	1298	static inline int afs_transfer_reply(struct afs_call *call)
935	1299	{
936		- return afs_extract_data(call, call->buffer, call->reply_max, false);
	1300	+ return afs_extract_data(call, false);
937	1301	}
938	1302
939	1303	static inline bool afs_check_call_state(struct afs_call *call,
..	..	@@ -975,8 +1339,16 @@
975	1339	ok = true;
976	1340	}
977	1341	spin_unlock_bh(&call->state_lock);
978		- if (ok)
	1342	+ if (ok) {
979	1343	trace_afs_call_done(call);
	1344	+
	1345	+ /* Asynchronous calls have two refs to release - one from the alloc and
	1346	+ * one queued with the work item - and we can't just deallocate the
	1347	+ * call because the work item may be queued again.
	1348	+ */
	1349	+ if (call->drop_ref)
	1350	+ afs_put_call(call);
	1351	+ }
980	1352	}
981	1353
982	1354	/*
..	..	@@ -984,9 +1356,11 @@
984	1356	*/
985	1357	extern void afs_put_permits(struct afs_permits *);
986	1358	extern void afs_clear_permits(struct afs_vnode *);
987		-extern void afs_cache_permit(struct afs_vnode , struct key , unsigned int);
	1359	+extern void afs_cache_permit(struct afs_vnode , struct key , unsigned int,
	1360	+ struct afs_status_cb *);
988	1361	extern void afs_zap_permits(struct rcu_head *);
989	1362	extern struct key afs_request_key(struct afs_cell );
	1363	+extern struct key afs_request_key_rcu(struct afs_cell );
990	1364	extern int afs_check_permit(struct afs_vnode , struct key , afs_access_t *);
991	1365	extern int afs_permission(struct inode *, int);
992	1366	extern void __exit afs_clean_up_permit_cache(void);
..	..	@@ -996,22 +1370,36 @@
996	1370	*/
997	1371	extern spinlock_t afs_server_peer_lock;
998	1372
999		-static inline struct afs_server afs_get_server(struct afs_server server)
1000		-{
1001		- atomic_inc(&server->usage);
1002		- return server;
1003		-}
1004		-
1005	1373	extern struct afs_server afs_find_server(struct afs_net ,
1006	1374	const struct sockaddr_rxrpc *);
1007	1375	extern struct afs_server afs_find_server_by_uuid(struct afs_net , const uuid_t *);
1008		-extern struct afs_server afs_lookup_server(struct afs_cell , struct key , const uuid_t );
1009		-extern void afs_put_server(struct afs_net , struct afs_server );
	1376	+extern struct afs_server afs_lookup_server(struct afs_cell , struct key , const uuid_t , u32);
	1377	+extern struct afs_server afs_get_server(struct afs_server , enum afs_server_trace);
	1378	+extern struct afs_server afs_use_server(struct afs_server , enum afs_server_trace);
	1379	+extern void afs_unuse_server(struct afs_net , struct afs_server , enum afs_server_trace);
	1380	+extern void afs_unuse_server_notime(struct afs_net , struct afs_server , enum afs_server_trace);
	1381	+extern void afs_put_server(struct afs_net , struct afs_server , enum afs_server_trace);
1010	1382	extern void afs_manage_servers(struct work_struct *);
1011	1383	extern void afs_servers_timer(struct timer_list *);
	1384	+extern void afs_fs_probe_timer(struct timer_list *);
1012	1385	extern void __net_exit afs_purge_servers(struct afs_net *);
1013		-extern bool afs_probe_fileserver(struct afs_fs_cursor *);
1014		-extern bool afs_check_server_record(struct afs_fs_cursor , struct afs_server );
	1386	+extern bool afs_check_server_record(struct afs_operation , struct afs_server );
	1387	+
	1388	+static inline void afs_inc_servers_outstanding(struct afs_net *net)
	1389	+{
	1390	+ atomic_inc(&net->servers_outstanding);
	1391	+}
	1392	+
	1393	+static inline void afs_dec_servers_outstanding(struct afs_net *net)
	1394	+{
	1395	+ if (atomic_dec_and_test(&net->servers_outstanding))
	1396	+ wake_up_var(&net->servers_outstanding);
	1397	+}
	1398	+
	1399	+static inline bool afs_is_probing_server(struct afs_server *server)
	1400	+{
	1401	+ return list_empty(&server->probe_link);
	1402	+}
1015	1403
1016	1404	/*
1017	1405	* server_list.c
..	..	@@ -1037,30 +1425,67 @@
1037	1425	/*
1038	1426	* vlclient.c
1039	1427	*/
1040		-extern struct afs_vldb_entry afs_vl_get_entry_by_name_u(struct afs_net ,
1041		- struct afs_addr_cursor *,
1042		- struct key , const char , int);
1043		-extern struct afs_addr_list afs_vl_get_addrs_u(struct afs_net , struct afs_addr_cursor *,
1044		- struct key , const uuid_t );
1045		-extern int afs_vl_get_capabilities(struct afs_net , struct afs_addr_cursor , struct key *);
1046		-extern struct afs_addr_list afs_yfsvl_get_endpoints(struct afs_net , struct afs_addr_cursor *,
1047		- struct key , const uuid_t );
	1428	+extern struct afs_vldb_entry afs_vl_get_entry_by_name_u(struct afs_vl_cursor ,
	1429	+ const char *, int);
	1430	+extern struct afs_addr_list afs_vl_get_addrs_u(struct afs_vl_cursor , const uuid_t *);
	1431	+extern struct afs_call afs_vl_get_capabilities(struct afs_net , struct afs_addr_cursor *,
	1432	+ struct key , struct afs_vlserver , unsigned int);
	1433	+extern struct afs_addr_list afs_yfsvl_get_endpoints(struct afs_vl_cursor , const uuid_t *);
	1434	+extern char afs_yfsvl_get_cell_name(struct afs_vl_cursor );
	1435	+
	1436	+/*
	1437	+ * vl_alias.c
	1438	+ */
	1439	+extern int afs_cell_detect_alias(struct afs_cell , struct key );
	1440	+
	1441	+/*
	1442	+ * vl_probe.c
	1443	+ */
	1444	+extern void afs_vlserver_probe_result(struct afs_call *);
	1445	+extern int afs_send_vl_probes(struct afs_net , struct key , struct afs_vlserver_list *);
	1446	+extern int afs_wait_for_vl_probes(struct afs_vlserver_list *, unsigned long);
	1447	+
	1448	+/*
	1449	+ * vl_rotate.c
	1450	+ */
	1451	+extern bool afs_begin_vlserver_operation(struct afs_vl_cursor *,
	1452	+ struct afs_cell , struct key );
	1453	+extern bool afs_select_vlserver(struct afs_vl_cursor *);
	1454	+extern bool afs_select_current_vlserver(struct afs_vl_cursor *);
	1455	+extern int afs_end_vlserver_operation(struct afs_vl_cursor *);
	1456	+
	1457	+/*
	1458	+ * vlserver_list.c
	1459	+ */
	1460	+static inline struct afs_vlserver afs_get_vlserver(struct afs_vlserver vlserver)
	1461	+{
	1462	+ atomic_inc(&vlserver->usage);
	1463	+ return vlserver;
	1464	+}
	1465	+
	1466	+static inline struct afs_vlserver_list afs_get_vlserverlist(struct afs_vlserver_list vllist)
	1467	+{
	1468	+ if (vllist)
	1469	+ atomic_inc(&vllist->usage);
	1470	+ return vllist;
	1471	+}
	1472	+
	1473	+extern struct afs_vlserver afs_alloc_vlserver(const char , size_t, unsigned short);
	1474	+extern void afs_put_vlserver(struct afs_net , struct afs_vlserver );
	1475	+extern struct afs_vlserver_list *afs_alloc_vlserver_list(unsigned int);
	1476	+extern void afs_put_vlserverlist(struct afs_net , struct afs_vlserver_list );
	1477	+extern struct afs_vlserver_list afs_extract_vlserver_list(struct afs_cell ,
	1478	+ const void *, size_t);
1048	1479
1049	1480	/*
1050	1481	* volume.c
1051	1482	*/
1052		-static inline struct afs_volume __afs_get_volume(struct afs_volume volume)
1053		-{
1054		- if (volume)
1055		- atomic_inc(&volume->usage);
1056		- return volume;
1057		-}
1058		-
1059		-extern struct afs_volume afs_create_volume(struct afs_mount_params );
	1483	+extern struct afs_volume afs_create_volume(struct afs_fs_context );
1060	1484	extern void afs_activate_volume(struct afs_volume *);
1061	1485	extern void afs_deactivate_volume(struct afs_volume *);
1062		-extern void afs_put_volume(struct afs_cell , struct afs_volume );
1063		-extern int afs_check_volume_status(struct afs_volume , struct key );
	1486	+extern struct afs_volume afs_get_volume(struct afs_volume , enum afs_volume_trace);
	1487	+extern void afs_put_volume(struct afs_net , struct afs_volume , enum afs_volume_trace);
	1488	+extern int afs_check_volume_status(struct afs_volume , struct afs_operation );
1064	1489
1065	1490	/*
1066	1491	* write.c
..	..	@@ -1074,7 +1499,6 @@
1074	1499	struct page page, void fsdata);
1075	1500	extern int afs_writepage(struct page , struct writeback_control );
1076	1501	extern int afs_writepages(struct address_space , struct writeback_control );
1077		-extern void afs_pages_written_back(struct afs_vnode , struct afs_call );
1078	1502	extern ssize_t afs_file_write(struct kiocb , struct iov_iter );
1079	1503	extern int afs_fsync(struct file *, loff_t, loff_t, int);
1080	1504	extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);
..	..	@@ -1085,8 +1509,41 @@
1085	1509	* xattr.c
1086	1510	*/
1087	1511	extern const struct xattr_handler *afs_xattr_handlers[];
1088		-extern ssize_t afs_listxattr(struct dentry , char , size_t);
1089	1512
	1513	+/*
	1514	+ * yfsclient.c
	1515	+ */
	1516	+extern void yfs_fs_fetch_data(struct afs_operation *);
	1517	+extern void yfs_fs_create_file(struct afs_operation *);
	1518	+extern void yfs_fs_make_dir(struct afs_operation *);
	1519	+extern void yfs_fs_remove_file2(struct afs_operation *);
	1520	+extern void yfs_fs_remove_file(struct afs_operation *);
	1521	+extern void yfs_fs_remove_dir(struct afs_operation *);
	1522	+extern void yfs_fs_link(struct afs_operation *);
	1523	+extern void yfs_fs_symlink(struct afs_operation *);
	1524	+extern void yfs_fs_rename(struct afs_operation *);
	1525	+extern void yfs_fs_store_data(struct afs_operation *);
	1526	+extern void yfs_fs_setattr(struct afs_operation *);
	1527	+extern void yfs_fs_get_volume_status(struct afs_operation *);
	1528	+extern void yfs_fs_set_lock(struct afs_operation *);
	1529	+extern void yfs_fs_extend_lock(struct afs_operation *);
	1530	+extern void yfs_fs_release_lock(struct afs_operation *);
	1531	+extern void yfs_fs_fetch_status(struct afs_operation *);
	1532	+extern void yfs_fs_inline_bulk_status(struct afs_operation *);
	1533	+
	1534	+struct yfs_acl {
	1535	+ struct afs_acl acl; / Dir/file/symlink ACL */
	1536	+ struct afs_acl vol_acl; / Whole volume ACL */
	1537	+ u32 inherit_flag; /* True if ACL is inherited from parent dir */
	1538	+ u32 num_cleaned; /* Number of ACEs removed due to subject removal */
	1539	+ unsigned int flags;
	1540	+#define YFS_ACL_WANT_ACL 0x01 /* Set if caller wants ->acl */
	1541	+#define YFS_ACL_WANT_VOL_ACL 0x02 /* Set if caller wants ->vol_acl */
	1542	+};
	1543	+
	1544	+extern void yfs_free_opaque_acl(struct yfs_acl *);
	1545	+extern void yfs_fs_fetch_opaque_acl(struct afs_operation *);
	1546	+extern void yfs_fs_store_opaque_acl2(struct afs_operation *);
1090	1547
1091	1548	/*
1092	1549	* Miscellaneous inline functions.
..	..	@@ -1101,23 +1558,53 @@
1101	1558	return &vnode->vfs_inode;
1102	1559	}
1103	1560
1104		-static inline void afs_vnode_commit_status(struct afs_fs_cursor *fc,
1105		- struct afs_vnode *vnode,
1106		- unsigned int cb_break)
	1561	+/*
	1562	+ * Note that a dentry got changed. We need to set d_fsdata to the data version
	1563	+ * number derived from the result of the operation. It doesn't matter if
	1564	+ * d_fsdata goes backwards as we'll just revalidate.
	1565	+ */
	1566	+static inline void afs_update_dentry_version(struct afs_operation *op,
	1567	+ struct afs_vnode_param *dir_vp,
	1568	+ struct dentry *dentry)
1107	1569	{
1108		- if (fc->ac.error == 0)
1109		- afs_cache_permit(vnode, fc->key, cb_break);
	1570	+ if (!op->error)
	1571	+ dentry->d_fsdata =
	1572	+ (void *)(unsigned long)dir_vp->scb.status.data_version;
1110	1573	}
1111	1574
1112		-static inline void afs_check_for_remote_deletion(struct afs_fs_cursor *fc,
1113		- struct afs_vnode *vnode)
	1575	+/*
	1576	+ * Set the file size and block count. Estimate the number of 512 bytes blocks
	1577	+ * used, rounded up to nearest 1K for consistency with other AFS clients.
	1578	+ */
	1579	+static inline void afs_set_i_size(struct afs_vnode *vnode, u64 size)
1114	1580	{
1115		- if (fc->ac.error == -ENOENT) {
1116		- set_bit(AFS_VNODE_DELETED, &vnode->flags);
1117		- afs_break_callback(vnode);
1118		- }
	1581	+ i_size_write(&vnode->vfs_inode, size);
	1582	+ vnode->vfs_inode.i_blocks = ((size + 1023) >> 10) << 1;
1119	1583	}
1120	1584
	1585	+/*
	1586	+ * Check for a conflicting operation on a directory that we just unlinked from.
	1587	+ * If someone managed to sneak a link or an unlink in on the file we just
	1588	+ * unlinked, we won't be able to trust nlink on an AFS file (but not YFS).
	1589	+ */
	1590	+static inline void afs_check_dir_conflict(struct afs_operation *op,
	1591	+ struct afs_vnode_param *dvp)
	1592	+{
	1593	+ if (dvp->dv_before + dvp->dv_delta != dvp->scb.status.data_version)
	1594	+ op->flags \|= AFS_OPERATION_DIR_CONFLICT;
	1595	+}
	1596	+
	1597	+static inline int afs_io_error(struct afs_call *call, enum afs_io_error where)
	1598	+{
	1599	+ trace_afs_io_error(call->debug_id, -EIO, where);
	1600	+ return -EIO;
	1601	+}
	1602	+
	1603	+static inline int afs_bad(struct afs_vnode *vnode, enum afs_file_error where)
	1604	+{
	1605	+ trace_afs_file_error(vnode, -EIO, where);
	1606	+ return -EIO;
	1607	+}
1121	1608
1122	1609	/*****************************************************************************/
1123	1610	/*