xref: /openbmc/linux/fs/nfs/nfs4proc.c (revision ae3473231e77a3f1909d48cd144cebe5e1d049b3)
1 /*
2  *  fs/nfs/nfs4proc.c
3  *
4  *  Client-side procedure declarations for NFSv4.
5  *
6  *  Copyright (c) 2002 The Regents of the University of Michigan.
7  *  All rights reserved.
8  *
9  *  Kendrick Smith <kmsmith@umich.edu>
10  *  Andy Adamson   <andros@umich.edu>
11  *
12  *  Redistribution and use in source and binary forms, with or without
13  *  modification, are permitted provided that the following conditions
14  *  are met:
15  *
16  *  1. Redistributions of source code must retain the above copyright
17  *     notice, this list of conditions and the following disclaimer.
18  *  2. Redistributions in binary form must reproduce the above copyright
19  *     notice, this list of conditions and the following disclaimer in the
20  *     documentation and/or other materials provided with the distribution.
21  *  3. Neither the name of the University nor the names of its
22  *     contributors may be used to endorse or promote products derived
23  *     from this software without specific prior written permission.
24  *
25  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
26  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
27  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
30  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
31  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
32  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  */
37 
38 #include <linux/mm.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
41 #include <linux/file.h>
42 #include <linux/string.h>
43 #include <linux/ratelimit.h>
44 #include <linux/printk.h>
45 #include <linux/slab.h>
46 #include <linux/sunrpc/clnt.h>
47 #include <linux/nfs.h>
48 #include <linux/nfs4.h>
49 #include <linux/nfs_fs.h>
50 #include <linux/nfs_page.h>
51 #include <linux/nfs_mount.h>
52 #include <linux/namei.h>
53 #include <linux/mount.h>
54 #include <linux/module.h>
55 #include <linux/xattr.h>
56 #include <linux/utsname.h>
57 #include <linux/freezer.h>
58 
59 #include "nfs4_fs.h"
60 #include "delegation.h"
61 #include "internal.h"
62 #include "iostat.h"
63 #include "callback.h"
64 #include "pnfs.h"
65 #include "netns.h"
66 #include "nfs4idmap.h"
67 #include "nfs4session.h"
68 #include "fscache.h"
69 
70 #include "nfs4trace.h"
71 
72 #define NFSDBG_FACILITY		NFSDBG_PROC
73 
74 #define NFS4_POLL_RETRY_MIN	(HZ/10)
75 #define NFS4_POLL_RETRY_MAX	(15*HZ)
76 
77 /* file attributes which can be mapped to nfs attributes */
78 #define NFS4_VALID_ATTRS (ATTR_MODE \
79 	| ATTR_UID \
80 	| ATTR_GID \
81 	| ATTR_SIZE \
82 	| ATTR_ATIME \
83 	| ATTR_MTIME \
84 	| ATTR_CTIME \
85 	| ATTR_ATIME_SET \
86 	| ATTR_MTIME_SET)
87 
88 struct nfs4_opendata;
89 static int _nfs4_proc_open(struct nfs4_opendata *data);
90 static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
91 static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
92 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
93 static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *, struct nfs4_label *label);
94 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr, struct nfs4_label *label);
95 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
96 			    struct nfs_fattr *fattr, struct iattr *sattr,
97 			    struct nfs_open_context *ctx, struct nfs4_label *ilabel,
98 			    struct nfs4_label *olabel);
99 #ifdef CONFIG_NFS_V4_1
100 static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *,
101 		struct rpc_cred *);
102 static int nfs41_free_stateid(struct nfs_server *, const nfs4_stateid *,
103 		struct rpc_cred *, bool);
104 #endif
105 
106 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
107 static inline struct nfs4_label *
108 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
109 	struct iattr *sattr, struct nfs4_label *label)
110 {
111 	int err;
112 
113 	if (label == NULL)
114 		return NULL;
115 
116 	if (nfs_server_capable(dir, NFS_CAP_SECURITY_LABEL) == 0)
117 		return NULL;
118 
119 	err = security_dentry_init_security(dentry, sattr->ia_mode,
120 				&dentry->d_name, (void **)&label->label, &label->len);
121 	if (err == 0)
122 		return label;
123 
124 	return NULL;
125 }
126 static inline void
127 nfs4_label_release_security(struct nfs4_label *label)
128 {
129 	if (label)
130 		security_release_secctx(label->label, label->len);
131 }
132 static inline u32 *nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
133 {
134 	if (label)
135 		return server->attr_bitmask;
136 
137 	return server->attr_bitmask_nl;
138 }
139 #else
140 static inline struct nfs4_label *
141 nfs4_label_init_security(struct inode *dir, struct dentry *dentry,
142 	struct iattr *sattr, struct nfs4_label *l)
143 { return NULL; }
144 static inline void
145 nfs4_label_release_security(struct nfs4_label *label)
146 { return; }
147 static inline u32 *
148 nfs4_bitmask(struct nfs_server *server, struct nfs4_label *label)
149 { return server->attr_bitmask; }
150 #endif
151 
152 /* Prevent leaks of NFSv4 errors into userland */
153 static int nfs4_map_errors(int err)
154 {
155 	if (err >= -1000)
156 		return err;
157 	switch (err) {
158 	case -NFS4ERR_RESOURCE:
159 	case -NFS4ERR_LAYOUTTRYLATER:
160 	case -NFS4ERR_RECALLCONFLICT:
161 		return -EREMOTEIO;
162 	case -NFS4ERR_WRONGSEC:
163 	case -NFS4ERR_WRONG_CRED:
164 		return -EPERM;
165 	case -NFS4ERR_BADOWNER:
166 	case -NFS4ERR_BADNAME:
167 		return -EINVAL;
168 	case -NFS4ERR_SHARE_DENIED:
169 		return -EACCES;
170 	case -NFS4ERR_MINOR_VERS_MISMATCH:
171 		return -EPROTONOSUPPORT;
172 	case -NFS4ERR_FILE_OPEN:
173 		return -EBUSY;
174 	default:
175 		dprintk("%s could not handle NFSv4 error %d\n",
176 				__func__, -err);
177 		break;
178 	}
179 	return -EIO;
180 }
181 
182 /*
183  * This is our standard bitmap for GETATTR requests.
184  */
185 const u32 nfs4_fattr_bitmap[3] = {
186 	FATTR4_WORD0_TYPE
187 	| FATTR4_WORD0_CHANGE
188 	| FATTR4_WORD0_SIZE
189 	| FATTR4_WORD0_FSID
190 	| FATTR4_WORD0_FILEID,
191 	FATTR4_WORD1_MODE
192 	| FATTR4_WORD1_NUMLINKS
193 	| FATTR4_WORD1_OWNER
194 	| FATTR4_WORD1_OWNER_GROUP
195 	| FATTR4_WORD1_RAWDEV
196 	| FATTR4_WORD1_SPACE_USED
197 	| FATTR4_WORD1_TIME_ACCESS
198 	| FATTR4_WORD1_TIME_METADATA
199 	| FATTR4_WORD1_TIME_MODIFY
200 	| FATTR4_WORD1_MOUNTED_ON_FILEID,
201 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
202 	FATTR4_WORD2_SECURITY_LABEL
203 #endif
204 };
205 
206 static const u32 nfs4_pnfs_open_bitmap[3] = {
207 	FATTR4_WORD0_TYPE
208 	| FATTR4_WORD0_CHANGE
209 	| FATTR4_WORD0_SIZE
210 	| FATTR4_WORD0_FSID
211 	| FATTR4_WORD0_FILEID,
212 	FATTR4_WORD1_MODE
213 	| FATTR4_WORD1_NUMLINKS
214 	| FATTR4_WORD1_OWNER
215 	| FATTR4_WORD1_OWNER_GROUP
216 	| FATTR4_WORD1_RAWDEV
217 	| FATTR4_WORD1_SPACE_USED
218 	| FATTR4_WORD1_TIME_ACCESS
219 	| FATTR4_WORD1_TIME_METADATA
220 	| FATTR4_WORD1_TIME_MODIFY,
221 	FATTR4_WORD2_MDSTHRESHOLD
222 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
223 	| FATTR4_WORD2_SECURITY_LABEL
224 #endif
225 };
226 
227 static const u32 nfs4_open_noattr_bitmap[3] = {
228 	FATTR4_WORD0_TYPE
229 	| FATTR4_WORD0_FILEID,
230 };
231 
232 const u32 nfs4_statfs_bitmap[3] = {
233 	FATTR4_WORD0_FILES_AVAIL
234 	| FATTR4_WORD0_FILES_FREE
235 	| FATTR4_WORD0_FILES_TOTAL,
236 	FATTR4_WORD1_SPACE_AVAIL
237 	| FATTR4_WORD1_SPACE_FREE
238 	| FATTR4_WORD1_SPACE_TOTAL
239 };
240 
241 const u32 nfs4_pathconf_bitmap[3] = {
242 	FATTR4_WORD0_MAXLINK
243 	| FATTR4_WORD0_MAXNAME,
244 	0
245 };
246 
247 const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
248 			| FATTR4_WORD0_MAXREAD
249 			| FATTR4_WORD0_MAXWRITE
250 			| FATTR4_WORD0_LEASE_TIME,
251 			FATTR4_WORD1_TIME_DELTA
252 			| FATTR4_WORD1_FS_LAYOUT_TYPES,
253 			FATTR4_WORD2_LAYOUT_BLKSIZE
254 			| FATTR4_WORD2_CLONE_BLKSIZE
255 };
256 
257 const u32 nfs4_fs_locations_bitmap[3] = {
258 	FATTR4_WORD0_TYPE
259 	| FATTR4_WORD0_CHANGE
260 	| FATTR4_WORD0_SIZE
261 	| FATTR4_WORD0_FSID
262 	| FATTR4_WORD0_FILEID
263 	| FATTR4_WORD0_FS_LOCATIONS,
264 	FATTR4_WORD1_MODE
265 	| FATTR4_WORD1_NUMLINKS
266 	| FATTR4_WORD1_OWNER
267 	| FATTR4_WORD1_OWNER_GROUP
268 	| FATTR4_WORD1_RAWDEV
269 	| FATTR4_WORD1_SPACE_USED
270 	| FATTR4_WORD1_TIME_ACCESS
271 	| FATTR4_WORD1_TIME_METADATA
272 	| FATTR4_WORD1_TIME_MODIFY
273 	| FATTR4_WORD1_MOUNTED_ON_FILEID,
274 };
275 
276 static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
277 		struct nfs4_readdir_arg *readdir)
278 {
279 	__be32 *start, *p;
280 
281 	if (cookie > 2) {
282 		readdir->cookie = cookie;
283 		memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
284 		return;
285 	}
286 
287 	readdir->cookie = 0;
288 	memset(&readdir->verifier, 0, sizeof(readdir->verifier));
289 	if (cookie == 2)
290 		return;
291 
292 	/*
293 	 * NFSv4 servers do not return entries for '.' and '..'
294 	 * Therefore, we fake these entries here.  We let '.'
295 	 * have cookie 0 and '..' have cookie 1.  Note that
296 	 * when talking to the server, we always send cookie 0
297 	 * instead of 1 or 2.
298 	 */
299 	start = p = kmap_atomic(*readdir->pages);
300 
301 	if (cookie == 0) {
302 		*p++ = xdr_one;                                  /* next */
303 		*p++ = xdr_zero;                   /* cookie, first word */
304 		*p++ = xdr_one;                   /* cookie, second word */
305 		*p++ = xdr_one;                             /* entry len */
306 		memcpy(p, ".\0\0\0", 4);                        /* entry */
307 		p++;
308 		*p++ = xdr_one;                         /* bitmap length */
309 		*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
310 		*p++ = htonl(8);              /* attribute buffer length */
311 		p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry)));
312 	}
313 
314 	*p++ = xdr_one;                                  /* next */
315 	*p++ = xdr_zero;                   /* cookie, first word */
316 	*p++ = xdr_two;                   /* cookie, second word */
317 	*p++ = xdr_two;                             /* entry len */
318 	memcpy(p, "..\0\0", 4);                         /* entry */
319 	p++;
320 	*p++ = xdr_one;                         /* bitmap length */
321 	*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
322 	*p++ = htonl(8);              /* attribute buffer length */
323 	p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent)));
324 
325 	readdir->pgbase = (char *)p - (char *)start;
326 	readdir->count -= readdir->pgbase;
327 	kunmap_atomic(start);
328 }
329 
330 static void nfs4_test_and_free_stateid(struct nfs_server *server,
331 		nfs4_stateid *stateid,
332 		struct rpc_cred *cred)
333 {
334 	const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
335 
336 	ops->test_and_free_expired(server, stateid, cred);
337 }
338 
339 static void __nfs4_free_revoked_stateid(struct nfs_server *server,
340 		nfs4_stateid *stateid,
341 		struct rpc_cred *cred)
342 {
343 	stateid->type = NFS4_REVOKED_STATEID_TYPE;
344 	nfs4_test_and_free_stateid(server, stateid, cred);
345 }
346 
347 static void nfs4_free_revoked_stateid(struct nfs_server *server,
348 		const nfs4_stateid *stateid,
349 		struct rpc_cred *cred)
350 {
351 	nfs4_stateid tmp;
352 
353 	nfs4_stateid_copy(&tmp, stateid);
354 	__nfs4_free_revoked_stateid(server, &tmp, cred);
355 }
356 
357 static long nfs4_update_delay(long *timeout)
358 {
359 	long ret;
360 	if (!timeout)
361 		return NFS4_POLL_RETRY_MAX;
362 	if (*timeout <= 0)
363 		*timeout = NFS4_POLL_RETRY_MIN;
364 	if (*timeout > NFS4_POLL_RETRY_MAX)
365 		*timeout = NFS4_POLL_RETRY_MAX;
366 	ret = *timeout;
367 	*timeout <<= 1;
368 	return ret;
369 }
370 
371 static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
372 {
373 	int res = 0;
374 
375 	might_sleep();
376 
377 	freezable_schedule_timeout_killable_unsafe(
378 		nfs4_update_delay(timeout));
379 	if (fatal_signal_pending(current))
380 		res = -ERESTARTSYS;
381 	return res;
382 }
383 
384 /* This is the error handling routine for processes that are allowed
385  * to sleep.
386  */
387 static int nfs4_do_handle_exception(struct nfs_server *server,
388 		int errorcode, struct nfs4_exception *exception)
389 {
390 	struct nfs_client *clp = server->nfs_client;
391 	struct nfs4_state *state = exception->state;
392 	const nfs4_stateid *stateid = exception->stateid;
393 	struct inode *inode = exception->inode;
394 	int ret = errorcode;
395 
396 	exception->delay = 0;
397 	exception->recovering = 0;
398 	exception->retry = 0;
399 
400 	if (stateid == NULL && state != NULL)
401 		stateid = &state->stateid;
402 
403 	switch(errorcode) {
404 		case 0:
405 			return 0;
406 		case -NFS4ERR_DELEG_REVOKED:
407 		case -NFS4ERR_ADMIN_REVOKED:
408 		case -NFS4ERR_EXPIRED:
409 		case -NFS4ERR_BAD_STATEID:
410 			if (inode != NULL && stateid != NULL) {
411 				nfs_inode_find_state_and_recover(inode,
412 						stateid);
413 				goto wait_on_recovery;
414 			}
415 		case -NFS4ERR_OPENMODE:
416 			if (inode) {
417 				int err;
418 
419 				err = nfs_async_inode_return_delegation(inode,
420 						stateid);
421 				if (err == 0)
422 					goto wait_on_recovery;
423 				if (stateid != NULL && stateid->type == NFS4_DELEGATION_STATEID_TYPE) {
424 					exception->retry = 1;
425 					break;
426 				}
427 			}
428 			if (state == NULL)
429 				break;
430 			ret = nfs4_schedule_stateid_recovery(server, state);
431 			if (ret < 0)
432 				break;
433 			goto wait_on_recovery;
434 		case -NFS4ERR_STALE_STATEID:
435 		case -NFS4ERR_STALE_CLIENTID:
436 			nfs4_schedule_lease_recovery(clp);
437 			goto wait_on_recovery;
438 		case -NFS4ERR_MOVED:
439 			ret = nfs4_schedule_migration_recovery(server);
440 			if (ret < 0)
441 				break;
442 			goto wait_on_recovery;
443 		case -NFS4ERR_LEASE_MOVED:
444 			nfs4_schedule_lease_moved_recovery(clp);
445 			goto wait_on_recovery;
446 #if defined(CONFIG_NFS_V4_1)
447 		case -NFS4ERR_BADSESSION:
448 		case -NFS4ERR_BADSLOT:
449 		case -NFS4ERR_BAD_HIGH_SLOT:
450 		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
451 		case -NFS4ERR_DEADSESSION:
452 		case -NFS4ERR_SEQ_FALSE_RETRY:
453 		case -NFS4ERR_SEQ_MISORDERED:
454 			dprintk("%s ERROR: %d Reset session\n", __func__,
455 				errorcode);
456 			nfs4_schedule_session_recovery(clp->cl_session, errorcode);
457 			goto wait_on_recovery;
458 #endif /* defined(CONFIG_NFS_V4_1) */
459 		case -NFS4ERR_FILE_OPEN:
460 			if (exception->timeout > HZ) {
461 				/* We have retried a decent amount, time to
462 				 * fail
463 				 */
464 				ret = -EBUSY;
465 				break;
466 			}
467 		case -NFS4ERR_DELAY:
468 			nfs_inc_server_stats(server, NFSIOS_DELAY);
469 		case -NFS4ERR_GRACE:
470 		case -NFS4ERR_LAYOUTTRYLATER:
471 		case -NFS4ERR_RECALLCONFLICT:
472 			exception->delay = 1;
473 			return 0;
474 
475 		case -NFS4ERR_RETRY_UNCACHED_REP:
476 		case -NFS4ERR_OLD_STATEID:
477 			exception->retry = 1;
478 			break;
479 		case -NFS4ERR_BADOWNER:
480 			/* The following works around a Linux server bug! */
481 		case -NFS4ERR_BADNAME:
482 			if (server->caps & NFS_CAP_UIDGID_NOMAP) {
483 				server->caps &= ~NFS_CAP_UIDGID_NOMAP;
484 				exception->retry = 1;
485 				printk(KERN_WARNING "NFS: v4 server %s "
486 						"does not accept raw "
487 						"uid/gids. "
488 						"Reenabling the idmapper.\n",
489 						server->nfs_client->cl_hostname);
490 			}
491 	}
492 	/* We failed to handle the error */
493 	return nfs4_map_errors(ret);
494 wait_on_recovery:
495 	exception->recovering = 1;
496 	return 0;
497 }
498 
499 /* This is the error handling routine for processes that are allowed
500  * to sleep.
501  */
502 int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
503 {
504 	struct nfs_client *clp = server->nfs_client;
505 	int ret;
506 
507 	ret = nfs4_do_handle_exception(server, errorcode, exception);
508 	if (exception->delay) {
509 		ret = nfs4_delay(server->client, &exception->timeout);
510 		goto out_retry;
511 	}
512 	if (exception->recovering) {
513 		ret = nfs4_wait_clnt_recover(clp);
514 		if (test_bit(NFS_MIG_FAILED, &server->mig_status))
515 			return -EIO;
516 		goto out_retry;
517 	}
518 	return ret;
519 out_retry:
520 	if (ret == 0)
521 		exception->retry = 1;
522 	return ret;
523 }
524 
525 static int
526 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
527 		int errorcode, struct nfs4_exception *exception)
528 {
529 	struct nfs_client *clp = server->nfs_client;
530 	int ret;
531 
532 	ret = nfs4_do_handle_exception(server, errorcode, exception);
533 	if (exception->delay) {
534 		rpc_delay(task, nfs4_update_delay(&exception->timeout));
535 		goto out_retry;
536 	}
537 	if (exception->recovering) {
538 		rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
539 		if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
540 			rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
541 		goto out_retry;
542 	}
543 	if (test_bit(NFS_MIG_FAILED, &server->mig_status))
544 		ret = -EIO;
545 	return ret;
546 out_retry:
547 	if (ret == 0)
548 		exception->retry = 1;
549 	return ret;
550 }
551 
552 static int
553 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
554 			struct nfs4_state *state, long *timeout)
555 {
556 	struct nfs4_exception exception = {
557 		.state = state,
558 	};
559 
560 	if (task->tk_status >= 0)
561 		return 0;
562 	if (timeout)
563 		exception.timeout = *timeout;
564 	task->tk_status = nfs4_async_handle_exception(task, server,
565 			task->tk_status,
566 			&exception);
567 	if (exception.delay && timeout)
568 		*timeout = exception.timeout;
569 	if (exception.retry)
570 		return -EAGAIN;
571 	return 0;
572 }
573 
574 /*
575  * Return 'true' if 'clp' is using an rpc_client that is integrity protected
576  * or 'false' otherwise.
577  */
578 static bool _nfs4_is_integrity_protected(struct nfs_client *clp)
579 {
580 	rpc_authflavor_t flavor = clp->cl_rpcclient->cl_auth->au_flavor;
581 
582 	if (flavor == RPC_AUTH_GSS_KRB5I ||
583 	    flavor == RPC_AUTH_GSS_KRB5P)
584 		return true;
585 
586 	return false;
587 }
588 
589 static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
590 {
591 	spin_lock(&clp->cl_lock);
592 	if (time_before(clp->cl_last_renewal,timestamp))
593 		clp->cl_last_renewal = timestamp;
594 	spin_unlock(&clp->cl_lock);
595 }
596 
597 static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
598 {
599 	struct nfs_client *clp = server->nfs_client;
600 
601 	if (!nfs4_has_session(clp))
602 		do_renew_lease(clp, timestamp);
603 }
604 
605 struct nfs4_call_sync_data {
606 	const struct nfs_server *seq_server;
607 	struct nfs4_sequence_args *seq_args;
608 	struct nfs4_sequence_res *seq_res;
609 };
610 
611 void nfs4_init_sequence(struct nfs4_sequence_args *args,
612 			struct nfs4_sequence_res *res, int cache_reply)
613 {
614 	args->sa_slot = NULL;
615 	args->sa_cache_this = cache_reply;
616 	args->sa_privileged = 0;
617 
618 	res->sr_slot = NULL;
619 }
620 
621 static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
622 {
623 	args->sa_privileged = 1;
624 }
625 
626 int nfs40_setup_sequence(struct nfs4_slot_table *tbl,
627 			 struct nfs4_sequence_args *args,
628 			 struct nfs4_sequence_res *res,
629 			 struct rpc_task *task)
630 {
631 	struct nfs4_slot *slot;
632 
633 	/* slot already allocated? */
634 	if (res->sr_slot != NULL)
635 		goto out_start;
636 
637 	spin_lock(&tbl->slot_tbl_lock);
638 	if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
639 		goto out_sleep;
640 
641 	slot = nfs4_alloc_slot(tbl);
642 	if (IS_ERR(slot)) {
643 		if (slot == ERR_PTR(-ENOMEM))
644 			task->tk_timeout = HZ >> 2;
645 		goto out_sleep;
646 	}
647 	spin_unlock(&tbl->slot_tbl_lock);
648 
649 	slot->privileged = args->sa_privileged ? 1 : 0;
650 	args->sa_slot = slot;
651 	res->sr_slot = slot;
652 
653 out_start:
654 	rpc_call_start(task);
655 	return 0;
656 
657 out_sleep:
658 	if (args->sa_privileged)
659 		rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
660 				NULL, RPC_PRIORITY_PRIVILEGED);
661 	else
662 		rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
663 	spin_unlock(&tbl->slot_tbl_lock);
664 	return -EAGAIN;
665 }
666 EXPORT_SYMBOL_GPL(nfs40_setup_sequence);
667 
668 static void nfs40_sequence_free_slot(struct nfs4_sequence_res *res)
669 {
670 	struct nfs4_slot *slot = res->sr_slot;
671 	struct nfs4_slot_table *tbl;
672 
673 	tbl = slot->table;
674 	spin_lock(&tbl->slot_tbl_lock);
675 	if (!nfs41_wake_and_assign_slot(tbl, slot))
676 		nfs4_free_slot(tbl, slot);
677 	spin_unlock(&tbl->slot_tbl_lock);
678 
679 	res->sr_slot = NULL;
680 }
681 
682 static int nfs40_sequence_done(struct rpc_task *task,
683 			       struct nfs4_sequence_res *res)
684 {
685 	if (res->sr_slot != NULL)
686 		nfs40_sequence_free_slot(res);
687 	return 1;
688 }
689 
690 #if defined(CONFIG_NFS_V4_1)
691 
692 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
693 {
694 	struct nfs4_session *session;
695 	struct nfs4_slot_table *tbl;
696 	struct nfs4_slot *slot = res->sr_slot;
697 	bool send_new_highest_used_slotid = false;
698 
699 	tbl = slot->table;
700 	session = tbl->session;
701 
702 	/* Bump the slot sequence number */
703 	if (slot->seq_done)
704 		slot->seq_nr++;
705 	slot->seq_done = 0;
706 
707 	spin_lock(&tbl->slot_tbl_lock);
708 	/* Be nice to the server: try to ensure that the last transmitted
709 	 * value for highest_user_slotid <= target_highest_slotid
710 	 */
711 	if (tbl->highest_used_slotid > tbl->target_highest_slotid)
712 		send_new_highest_used_slotid = true;
713 
714 	if (nfs41_wake_and_assign_slot(tbl, slot)) {
715 		send_new_highest_used_slotid = false;
716 		goto out_unlock;
717 	}
718 	nfs4_free_slot(tbl, slot);
719 
720 	if (tbl->highest_used_slotid != NFS4_NO_SLOT)
721 		send_new_highest_used_slotid = false;
722 out_unlock:
723 	spin_unlock(&tbl->slot_tbl_lock);
724 	res->sr_slot = NULL;
725 	if (send_new_highest_used_slotid)
726 		nfs41_notify_server(session->clp);
727 	if (waitqueue_active(&tbl->slot_waitq))
728 		wake_up_all(&tbl->slot_waitq);
729 }
730 
731 static int nfs41_sequence_process(struct rpc_task *task,
732 		struct nfs4_sequence_res *res)
733 {
734 	struct nfs4_session *session;
735 	struct nfs4_slot *slot = res->sr_slot;
736 	struct nfs_client *clp;
737 	bool interrupted = false;
738 	int ret = 1;
739 
740 	if (slot == NULL)
741 		goto out_noaction;
742 	/* don't increment the sequence number if the task wasn't sent */
743 	if (!RPC_WAS_SENT(task))
744 		goto out;
745 
746 	session = slot->table->session;
747 
748 	if (slot->interrupted) {
749 		slot->interrupted = 0;
750 		interrupted = true;
751 	}
752 
753 	trace_nfs4_sequence_done(session, res);
754 	/* Check the SEQUENCE operation status */
755 	switch (res->sr_status) {
756 	case 0:
757 		/* If previous op on slot was interrupted and we reused
758 		 * the seq# and got a reply from the cache, then retry
759 		 */
760 		if (task->tk_status == -EREMOTEIO && interrupted) {
761 			++slot->seq_nr;
762 			goto retry_nowait;
763 		}
764 		/* Update the slot's sequence and clientid lease timer */
765 		slot->seq_done = 1;
766 		clp = session->clp;
767 		do_renew_lease(clp, res->sr_timestamp);
768 		/* Check sequence flags */
769 		nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags,
770 				!!slot->privileged);
771 		nfs41_update_target_slotid(slot->table, slot, res);
772 		break;
773 	case 1:
774 		/*
775 		 * sr_status remains 1 if an RPC level error occurred.
776 		 * The server may or may not have processed the sequence
777 		 * operation..
778 		 * Mark the slot as having hosted an interrupted RPC call.
779 		 */
780 		slot->interrupted = 1;
781 		goto out;
782 	case -NFS4ERR_DELAY:
783 		/* The server detected a resend of the RPC call and
784 		 * returned NFS4ERR_DELAY as per Section 2.10.6.2
785 		 * of RFC5661.
786 		 */
787 		dprintk("%s: slot=%u seq=%u: Operation in progress\n",
788 			__func__,
789 			slot->slot_nr,
790 			slot->seq_nr);
791 		goto out_retry;
792 	case -NFS4ERR_BADSLOT:
793 		/*
794 		 * The slot id we used was probably retired. Try again
795 		 * using a different slot id.
796 		 */
797 		goto retry_nowait;
798 	case -NFS4ERR_SEQ_MISORDERED:
799 		/*
800 		 * Was the last operation on this sequence interrupted?
801 		 * If so, retry after bumping the sequence number.
802 		 */
803 		if (interrupted) {
804 			++slot->seq_nr;
805 			goto retry_nowait;
806 		}
807 		/*
808 		 * Could this slot have been previously retired?
809 		 * If so, then the server may be expecting seq_nr = 1!
810 		 */
811 		if (slot->seq_nr != 1) {
812 			slot->seq_nr = 1;
813 			goto retry_nowait;
814 		}
815 		break;
816 	case -NFS4ERR_SEQ_FALSE_RETRY:
817 		++slot->seq_nr;
818 		goto retry_nowait;
819 	case -NFS4ERR_DEADSESSION:
820 	case -NFS4ERR_BADSESSION:
821 		nfs4_schedule_session_recovery(session, res->sr_status);
822 		goto retry_nowait;
823 	default:
824 		/* Just update the slot sequence no. */
825 		slot->seq_done = 1;
826 	}
827 out:
828 	/* The session may be reset by one of the error handlers. */
829 	dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
830 out_noaction:
831 	return ret;
832 retry_nowait:
833 	if (rpc_restart_call_prepare(task)) {
834 		nfs41_sequence_free_slot(res);
835 		task->tk_status = 0;
836 		ret = 0;
837 	}
838 	goto out;
839 out_retry:
840 	if (!rpc_restart_call(task))
841 		goto out;
842 	rpc_delay(task, NFS4_POLL_RETRY_MAX);
843 	return 0;
844 }
845 
846 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
847 {
848 	if (!nfs41_sequence_process(task, res))
849 		return 0;
850 	if (res->sr_slot != NULL)
851 		nfs41_sequence_free_slot(res);
852 	return 1;
853 
854 }
855 EXPORT_SYMBOL_GPL(nfs41_sequence_done);
856 
857 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
858 {
859 	if (res->sr_slot == NULL)
860 		return 1;
861 	if (res->sr_slot->table->session != NULL)
862 		return nfs41_sequence_process(task, res);
863 	return nfs40_sequence_done(task, res);
864 }
865 
866 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
867 {
868 	if (res->sr_slot != NULL) {
869 		if (res->sr_slot->table->session != NULL)
870 			nfs41_sequence_free_slot(res);
871 		else
872 			nfs40_sequence_free_slot(res);
873 	}
874 }
875 
876 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
877 {
878 	if (res->sr_slot == NULL)
879 		return 1;
880 	if (!res->sr_slot->table->session)
881 		return nfs40_sequence_done(task, res);
882 	return nfs41_sequence_done(task, res);
883 }
884 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
885 
886 int nfs41_setup_sequence(struct nfs4_session *session,
887 				struct nfs4_sequence_args *args,
888 				struct nfs4_sequence_res *res,
889 				struct rpc_task *task)
890 {
891 	struct nfs4_slot *slot;
892 	struct nfs4_slot_table *tbl;
893 
894 	dprintk("--> %s\n", __func__);
895 	/* slot already allocated? */
896 	if (res->sr_slot != NULL)
897 		goto out_success;
898 
899 	tbl = &session->fc_slot_table;
900 
901 	task->tk_timeout = 0;
902 
903 	spin_lock(&tbl->slot_tbl_lock);
904 	if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
905 	    !args->sa_privileged) {
906 		/* The state manager will wait until the slot table is empty */
907 		dprintk("%s session is draining\n", __func__);
908 		goto out_sleep;
909 	}
910 
911 	slot = nfs4_alloc_slot(tbl);
912 	if (IS_ERR(slot)) {
913 		/* If out of memory, try again in 1/4 second */
914 		if (slot == ERR_PTR(-ENOMEM))
915 			task->tk_timeout = HZ >> 2;
916 		dprintk("<-- %s: no free slots\n", __func__);
917 		goto out_sleep;
918 	}
919 	spin_unlock(&tbl->slot_tbl_lock);
920 
921 	slot->privileged = args->sa_privileged ? 1 : 0;
922 	args->sa_slot = slot;
923 
924 	dprintk("<-- %s slotid=%u seqid=%u\n", __func__,
925 			slot->slot_nr, slot->seq_nr);
926 
927 	res->sr_slot = slot;
928 	res->sr_timestamp = jiffies;
929 	res->sr_status_flags = 0;
930 	/*
931 	 * sr_status is only set in decode_sequence, and so will remain
932 	 * set to 1 if an rpc level failure occurs.
933 	 */
934 	res->sr_status = 1;
935 	trace_nfs4_setup_sequence(session, args);
936 out_success:
937 	rpc_call_start(task);
938 	return 0;
939 out_sleep:
940 	/* Privileged tasks are queued with top priority */
941 	if (args->sa_privileged)
942 		rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
943 				NULL, RPC_PRIORITY_PRIVILEGED);
944 	else
945 		rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
946 	spin_unlock(&tbl->slot_tbl_lock);
947 	return -EAGAIN;
948 }
949 EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
950 
951 static int nfs4_setup_sequence(const struct nfs_server *server,
952 			       struct nfs4_sequence_args *args,
953 			       struct nfs4_sequence_res *res,
954 			       struct rpc_task *task)
955 {
956 	struct nfs4_session *session = nfs4_get_session(server);
957 	int ret = 0;
958 
959 	if (!session)
960 		return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
961 					    args, res, task);
962 
963 	dprintk("--> %s clp %p session %p sr_slot %u\n",
964 		__func__, session->clp, session, res->sr_slot ?
965 			res->sr_slot->slot_nr : NFS4_NO_SLOT);
966 
967 	ret = nfs41_setup_sequence(session, args, res, task);
968 
969 	dprintk("<-- %s status=%d\n", __func__, ret);
970 	return ret;
971 }
972 
973 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
974 {
975 	struct nfs4_call_sync_data *data = calldata;
976 	struct nfs4_session *session = nfs4_get_session(data->seq_server);
977 
978 	dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);
979 
980 	nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
981 }
982 
983 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
984 {
985 	struct nfs4_call_sync_data *data = calldata;
986 
987 	nfs41_sequence_done(task, data->seq_res);
988 }
989 
990 static const struct rpc_call_ops nfs41_call_sync_ops = {
991 	.rpc_call_prepare = nfs41_call_sync_prepare,
992 	.rpc_call_done = nfs41_call_sync_done,
993 };
994 
995 #else	/* !CONFIG_NFS_V4_1 */
996 
997 static int nfs4_setup_sequence(const struct nfs_server *server,
998 			       struct nfs4_sequence_args *args,
999 			       struct nfs4_sequence_res *res,
1000 			       struct rpc_task *task)
1001 {
1002 	return nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
1003 				    args, res, task);
1004 }
1005 
1006 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1007 {
1008 	return nfs40_sequence_done(task, res);
1009 }
1010 
1011 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
1012 {
1013 	if (res->sr_slot != NULL)
1014 		nfs40_sequence_free_slot(res);
1015 }
1016 
1017 int nfs4_sequence_done(struct rpc_task *task,
1018 		       struct nfs4_sequence_res *res)
1019 {
1020 	return nfs40_sequence_done(task, res);
1021 }
1022 EXPORT_SYMBOL_GPL(nfs4_sequence_done);
1023 
1024 #endif	/* !CONFIG_NFS_V4_1 */
1025 
1026 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1027 {
1028 	struct nfs4_call_sync_data *data = calldata;
1029 	nfs4_setup_sequence(data->seq_server,
1030 				data->seq_args, data->seq_res, task);
1031 }
1032 
1033 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1034 {
1035 	struct nfs4_call_sync_data *data = calldata;
1036 	nfs4_sequence_done(task, data->seq_res);
1037 }
1038 
1039 static const struct rpc_call_ops nfs40_call_sync_ops = {
1040 	.rpc_call_prepare = nfs40_call_sync_prepare,
1041 	.rpc_call_done = nfs40_call_sync_done,
1042 };
1043 
1044 static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
1045 				   struct nfs_server *server,
1046 				   struct rpc_message *msg,
1047 				   struct nfs4_sequence_args *args,
1048 				   struct nfs4_sequence_res *res)
1049 {
1050 	int ret;
1051 	struct rpc_task *task;
1052 	struct nfs_client *clp = server->nfs_client;
1053 	struct nfs4_call_sync_data data = {
1054 		.seq_server = server,
1055 		.seq_args = args,
1056 		.seq_res = res,
1057 	};
1058 	struct rpc_task_setup task_setup = {
1059 		.rpc_client = clnt,
1060 		.rpc_message = msg,
1061 		.callback_ops = clp->cl_mvops->call_sync_ops,
1062 		.callback_data = &data
1063 	};
1064 
1065 	task = rpc_run_task(&task_setup);
1066 	if (IS_ERR(task))
1067 		ret = PTR_ERR(task);
1068 	else {
1069 		ret = task->tk_status;
1070 		rpc_put_task(task);
1071 	}
1072 	return ret;
1073 }
1074 
1075 int nfs4_call_sync(struct rpc_clnt *clnt,
1076 		   struct nfs_server *server,
1077 		   struct rpc_message *msg,
1078 		   struct nfs4_sequence_args *args,
1079 		   struct nfs4_sequence_res *res,
1080 		   int cache_reply)
1081 {
1082 	nfs4_init_sequence(args, res, cache_reply);
1083 	return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1084 }
1085 
1086 static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
1087 {
1088 	struct nfs_inode *nfsi = NFS_I(dir);
1089 
1090 	spin_lock(&dir->i_lock);
1091 	nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
1092 	if (cinfo->atomic && cinfo->before == dir->i_version) {
1093 		nfsi->cache_validity &= ~NFS_INO_REVAL_PAGECACHE;
1094 		nfsi->attrtimeo_timestamp = jiffies;
1095 	} else {
1096 		nfs_force_lookup_revalidate(dir);
1097 		if (cinfo->before != dir->i_version)
1098 			nfsi->cache_validity |= NFS_INO_INVALID_ACCESS |
1099 				NFS_INO_INVALID_ACL;
1100 	}
1101 	dir->i_version = cinfo->after;
1102 	nfsi->attr_gencount = nfs_inc_attr_generation_counter();
1103 	nfs_fscache_invalidate(dir);
1104 	spin_unlock(&dir->i_lock);
1105 }
1106 
1107 struct nfs4_opendata {
1108 	struct kref kref;
1109 	struct nfs_openargs o_arg;
1110 	struct nfs_openres o_res;
1111 	struct nfs_open_confirmargs c_arg;
1112 	struct nfs_open_confirmres c_res;
1113 	struct nfs4_string owner_name;
1114 	struct nfs4_string group_name;
1115 	struct nfs4_label *a_label;
1116 	struct nfs_fattr f_attr;
1117 	struct nfs4_label *f_label;
1118 	struct dentry *dir;
1119 	struct dentry *dentry;
1120 	struct nfs4_state_owner *owner;
1121 	struct nfs4_state *state;
1122 	struct iattr attrs;
1123 	unsigned long timestamp;
1124 	unsigned int rpc_done : 1;
1125 	unsigned int file_created : 1;
1126 	unsigned int is_recover : 1;
1127 	int rpc_status;
1128 	int cancelled;
1129 };
1130 
1131 static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
1132 		int err, struct nfs4_exception *exception)
1133 {
1134 	if (err != -EINVAL)
1135 		return false;
1136 	if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1137 		return false;
1138 	server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
1139 	exception->retry = 1;
1140 	return true;
1141 }
1142 
1143 static u32
1144 nfs4_map_atomic_open_share(struct nfs_server *server,
1145 		fmode_t fmode, int openflags)
1146 {
1147 	u32 res = 0;
1148 
1149 	switch (fmode & (FMODE_READ | FMODE_WRITE)) {
1150 	case FMODE_READ:
1151 		res = NFS4_SHARE_ACCESS_READ;
1152 		break;
1153 	case FMODE_WRITE:
1154 		res = NFS4_SHARE_ACCESS_WRITE;
1155 		break;
1156 	case FMODE_READ|FMODE_WRITE:
1157 		res = NFS4_SHARE_ACCESS_BOTH;
1158 	}
1159 	if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
1160 		goto out;
1161 	/* Want no delegation if we're using O_DIRECT */
1162 	if (openflags & O_DIRECT)
1163 		res |= NFS4_SHARE_WANT_NO_DELEG;
1164 out:
1165 	return res;
1166 }
1167 
1168 static enum open_claim_type4
1169 nfs4_map_atomic_open_claim(struct nfs_server *server,
1170 		enum open_claim_type4 claim)
1171 {
1172 	if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
1173 		return claim;
1174 	switch (claim) {
1175 	default:
1176 		return claim;
1177 	case NFS4_OPEN_CLAIM_FH:
1178 		return NFS4_OPEN_CLAIM_NULL;
1179 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1180 		return NFS4_OPEN_CLAIM_DELEGATE_CUR;
1181 	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1182 		return NFS4_OPEN_CLAIM_DELEGATE_PREV;
1183 	}
1184 }
1185 
1186 static void nfs4_init_opendata_res(struct nfs4_opendata *p)
1187 {
1188 	p->o_res.f_attr = &p->f_attr;
1189 	p->o_res.f_label = p->f_label;
1190 	p->o_res.seqid = p->o_arg.seqid;
1191 	p->c_res.seqid = p->c_arg.seqid;
1192 	p->o_res.server = p->o_arg.server;
1193 	p->o_res.access_request = p->o_arg.access;
1194 	nfs_fattr_init(&p->f_attr);
1195 	nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
1196 }
1197 
1198 static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
1199 		struct nfs4_state_owner *sp, fmode_t fmode, int flags,
1200 		const struct iattr *attrs,
1201 		struct nfs4_label *label,
1202 		enum open_claim_type4 claim,
1203 		gfp_t gfp_mask)
1204 {
1205 	struct dentry *parent = dget_parent(dentry);
1206 	struct inode *dir = d_inode(parent);
1207 	struct nfs_server *server = NFS_SERVER(dir);
1208 	struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
1209 	struct nfs4_opendata *p;
1210 
1211 	p = kzalloc(sizeof(*p), gfp_mask);
1212 	if (p == NULL)
1213 		goto err;
1214 
1215 	p->f_label = nfs4_label_alloc(server, gfp_mask);
1216 	if (IS_ERR(p->f_label))
1217 		goto err_free_p;
1218 
1219 	p->a_label = nfs4_label_alloc(server, gfp_mask);
1220 	if (IS_ERR(p->a_label))
1221 		goto err_free_f;
1222 
1223 	alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
1224 	p->o_arg.seqid = alloc_seqid(&sp->so_seqid, gfp_mask);
1225 	if (IS_ERR(p->o_arg.seqid))
1226 		goto err_free_label;
1227 	nfs_sb_active(dentry->d_sb);
1228 	p->dentry = dget(dentry);
1229 	p->dir = parent;
1230 	p->owner = sp;
1231 	atomic_inc(&sp->so_count);
1232 	p->o_arg.open_flags = flags;
1233 	p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
1234 	p->o_arg.umask = current_umask();
1235 	p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
1236 	p->o_arg.share_access = nfs4_map_atomic_open_share(server,
1237 			fmode, flags);
1238 	/* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
1239 	 * will return permission denied for all bits until close */
1240 	if (!(flags & O_EXCL)) {
1241 		/* ask server to check for all possible rights as results
1242 		 * are cached */
1243 		switch (p->o_arg.claim) {
1244 		default:
1245 			break;
1246 		case NFS4_OPEN_CLAIM_NULL:
1247 		case NFS4_OPEN_CLAIM_FH:
1248 			p->o_arg.access = NFS4_ACCESS_READ |
1249 				NFS4_ACCESS_MODIFY |
1250 				NFS4_ACCESS_EXTEND |
1251 				NFS4_ACCESS_EXECUTE;
1252 		}
1253 	}
1254 	p->o_arg.clientid = server->nfs_client->cl_clientid;
1255 	p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
1256 	p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
1257 	p->o_arg.name = &dentry->d_name;
1258 	p->o_arg.server = server;
1259 	p->o_arg.bitmask = nfs4_bitmask(server, label);
1260 	p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
1261 	p->o_arg.label = nfs4_label_copy(p->a_label, label);
1262 	switch (p->o_arg.claim) {
1263 	case NFS4_OPEN_CLAIM_NULL:
1264 	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1265 	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1266 		p->o_arg.fh = NFS_FH(dir);
1267 		break;
1268 	case NFS4_OPEN_CLAIM_PREVIOUS:
1269 	case NFS4_OPEN_CLAIM_FH:
1270 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1271 	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1272 		p->o_arg.fh = NFS_FH(d_inode(dentry));
1273 	}
1274 	if (attrs != NULL && attrs->ia_valid != 0) {
1275 		__u32 verf[2];
1276 
1277 		p->o_arg.u.attrs = &p->attrs;
1278 		memcpy(&p->attrs, attrs, sizeof(p->attrs));
1279 
1280 		verf[0] = jiffies;
1281 		verf[1] = current->pid;
1282 		memcpy(p->o_arg.u.verifier.data, verf,
1283 				sizeof(p->o_arg.u.verifier.data));
1284 	}
1285 	p->c_arg.fh = &p->o_res.fh;
1286 	p->c_arg.stateid = &p->o_res.stateid;
1287 	p->c_arg.seqid = p->o_arg.seqid;
1288 	nfs4_init_opendata_res(p);
1289 	kref_init(&p->kref);
1290 	return p;
1291 
1292 err_free_label:
1293 	nfs4_label_free(p->a_label);
1294 err_free_f:
1295 	nfs4_label_free(p->f_label);
1296 err_free_p:
1297 	kfree(p);
1298 err:
1299 	dput(parent);
1300 	return NULL;
1301 }
1302 
1303 static void nfs4_opendata_free(struct kref *kref)
1304 {
1305 	struct nfs4_opendata *p = container_of(kref,
1306 			struct nfs4_opendata, kref);
1307 	struct super_block *sb = p->dentry->d_sb;
1308 
1309 	nfs_free_seqid(p->o_arg.seqid);
1310 	nfs4_sequence_free_slot(&p->o_res.seq_res);
1311 	if (p->state != NULL)
1312 		nfs4_put_open_state(p->state);
1313 	nfs4_put_state_owner(p->owner);
1314 
1315 	nfs4_label_free(p->a_label);
1316 	nfs4_label_free(p->f_label);
1317 
1318 	dput(p->dir);
1319 	dput(p->dentry);
1320 	nfs_sb_deactive(sb);
1321 	nfs_fattr_free_names(&p->f_attr);
1322 	kfree(p->f_attr.mdsthreshold);
1323 	kfree(p);
1324 }
1325 
1326 static void nfs4_opendata_put(struct nfs4_opendata *p)
1327 {
1328 	if (p != NULL)
1329 		kref_put(&p->kref, nfs4_opendata_free);
1330 }
1331 
1332 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
1333 {
1334 	int ret;
1335 
1336 	ret = rpc_wait_for_completion_task(task);
1337 	return ret;
1338 }
1339 
1340 static bool nfs4_mode_match_open_stateid(struct nfs4_state *state,
1341 		fmode_t fmode)
1342 {
1343 	switch(fmode & (FMODE_READ|FMODE_WRITE)) {
1344 	case FMODE_READ|FMODE_WRITE:
1345 		return state->n_rdwr != 0;
1346 	case FMODE_WRITE:
1347 		return state->n_wronly != 0;
1348 	case FMODE_READ:
1349 		return state->n_rdonly != 0;
1350 	}
1351 	WARN_ON_ONCE(1);
1352 	return false;
1353 }
1354 
1355 static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
1356 {
1357 	int ret = 0;
1358 
1359 	if (open_mode & (O_EXCL|O_TRUNC))
1360 		goto out;
1361 	switch (mode & (FMODE_READ|FMODE_WRITE)) {
1362 		case FMODE_READ:
1363 			ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
1364 				&& state->n_rdonly != 0;
1365 			break;
1366 		case FMODE_WRITE:
1367 			ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
1368 				&& state->n_wronly != 0;
1369 			break;
1370 		case FMODE_READ|FMODE_WRITE:
1371 			ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
1372 				&& state->n_rdwr != 0;
1373 	}
1374 out:
1375 	return ret;
1376 }
1377 
1378 static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode,
1379 		enum open_claim_type4 claim)
1380 {
1381 	if (delegation == NULL)
1382 		return 0;
1383 	if ((delegation->type & fmode) != fmode)
1384 		return 0;
1385 	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
1386 		return 0;
1387 	switch (claim) {
1388 	case NFS4_OPEN_CLAIM_NULL:
1389 	case NFS4_OPEN_CLAIM_FH:
1390 		break;
1391 	case NFS4_OPEN_CLAIM_PREVIOUS:
1392 		if (!test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
1393 			break;
1394 	default:
1395 		return 0;
1396 	}
1397 	nfs_mark_delegation_referenced(delegation);
1398 	return 1;
1399 }
1400 
1401 static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
1402 {
1403 	switch (fmode) {
1404 		case FMODE_WRITE:
1405 			state->n_wronly++;
1406 			break;
1407 		case FMODE_READ:
1408 			state->n_rdonly++;
1409 			break;
1410 		case FMODE_READ|FMODE_WRITE:
1411 			state->n_rdwr++;
1412 	}
1413 	nfs4_state_set_mode_locked(state, state->state | fmode);
1414 }
1415 
1416 #ifdef CONFIG_NFS_V4_1
1417 static bool nfs_open_stateid_recover_openmode(struct nfs4_state *state)
1418 {
1419 	if (state->n_rdonly && !test_bit(NFS_O_RDONLY_STATE, &state->flags))
1420 		return true;
1421 	if (state->n_wronly && !test_bit(NFS_O_WRONLY_STATE, &state->flags))
1422 		return true;
1423 	if (state->n_rdwr && !test_bit(NFS_O_RDWR_STATE, &state->flags))
1424 		return true;
1425 	return false;
1426 }
1427 #endif /* CONFIG_NFS_V4_1 */
1428 
1429 static void nfs_test_and_clear_all_open_stateid(struct nfs4_state *state)
1430 {
1431 	struct nfs_client *clp = state->owner->so_server->nfs_client;
1432 	bool need_recover = false;
1433 
1434 	if (test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags) && state->n_rdonly)
1435 		need_recover = true;
1436 	if (test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags) && state->n_wronly)
1437 		need_recover = true;
1438 	if (test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags) && state->n_rdwr)
1439 		need_recover = true;
1440 	if (need_recover)
1441 		nfs4_state_mark_reclaim_nograce(clp, state);
1442 }
1443 
1444 static bool nfs_need_update_open_stateid(struct nfs4_state *state,
1445 		const nfs4_stateid *stateid, nfs4_stateid *freeme)
1446 {
1447 	if (test_and_set_bit(NFS_OPEN_STATE, &state->flags) == 0)
1448 		return true;
1449 	if (!nfs4_stateid_match_other(stateid, &state->open_stateid)) {
1450 		nfs4_stateid_copy(freeme, &state->open_stateid);
1451 		nfs_test_and_clear_all_open_stateid(state);
1452 		return true;
1453 	}
1454 	if (nfs4_stateid_is_newer(stateid, &state->open_stateid))
1455 		return true;
1456 	return false;
1457 }
1458 
1459 static void nfs_resync_open_stateid_locked(struct nfs4_state *state)
1460 {
1461 	if (!(state->n_wronly || state->n_rdonly || state->n_rdwr))
1462 		return;
1463 	if (state->n_wronly)
1464 		set_bit(NFS_O_WRONLY_STATE, &state->flags);
1465 	if (state->n_rdonly)
1466 		set_bit(NFS_O_RDONLY_STATE, &state->flags);
1467 	if (state->n_rdwr)
1468 		set_bit(NFS_O_RDWR_STATE, &state->flags);
1469 	set_bit(NFS_OPEN_STATE, &state->flags);
1470 }
1471 
1472 static void nfs_clear_open_stateid_locked(struct nfs4_state *state,
1473 		nfs4_stateid *stateid, fmode_t fmode)
1474 {
1475 	clear_bit(NFS_O_RDWR_STATE, &state->flags);
1476 	switch (fmode & (FMODE_READ|FMODE_WRITE)) {
1477 	case FMODE_WRITE:
1478 		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1479 		break;
1480 	case FMODE_READ:
1481 		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1482 		break;
1483 	case 0:
1484 		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1485 		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1486 		clear_bit(NFS_OPEN_STATE, &state->flags);
1487 	}
1488 	if (stateid == NULL)
1489 		return;
1490 	/* Handle OPEN+OPEN_DOWNGRADE races */
1491 	if (nfs4_stateid_match_other(stateid, &state->open_stateid) &&
1492 	    !nfs4_stateid_is_newer(stateid, &state->open_stateid)) {
1493 		nfs_resync_open_stateid_locked(state);
1494 		return;
1495 	}
1496 	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1497 		nfs4_stateid_copy(&state->stateid, stateid);
1498 	nfs4_stateid_copy(&state->open_stateid, stateid);
1499 }
1500 
1501 static void nfs_clear_open_stateid(struct nfs4_state *state,
1502 	nfs4_stateid *arg_stateid,
1503 	nfs4_stateid *stateid, fmode_t fmode)
1504 {
1505 	write_seqlock(&state->seqlock);
1506 	/* Ignore, if the CLOSE argment doesn't match the current stateid */
1507 	if (nfs4_state_match_open_stateid_other(state, arg_stateid))
1508 		nfs_clear_open_stateid_locked(state, stateid, fmode);
1509 	write_sequnlock(&state->seqlock);
1510 	if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1511 		nfs4_schedule_state_manager(state->owner->so_server->nfs_client);
1512 }
1513 
1514 static void nfs_set_open_stateid_locked(struct nfs4_state *state,
1515 		const nfs4_stateid *stateid, fmode_t fmode,
1516 		nfs4_stateid *freeme)
1517 {
1518 	switch (fmode) {
1519 		case FMODE_READ:
1520 			set_bit(NFS_O_RDONLY_STATE, &state->flags);
1521 			break;
1522 		case FMODE_WRITE:
1523 			set_bit(NFS_O_WRONLY_STATE, &state->flags);
1524 			break;
1525 		case FMODE_READ|FMODE_WRITE:
1526 			set_bit(NFS_O_RDWR_STATE, &state->flags);
1527 	}
1528 	if (!nfs_need_update_open_stateid(state, stateid, freeme))
1529 		return;
1530 	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1531 		nfs4_stateid_copy(&state->stateid, stateid);
1532 	nfs4_stateid_copy(&state->open_stateid, stateid);
1533 }
1534 
1535 static void __update_open_stateid(struct nfs4_state *state,
1536 		const nfs4_stateid *open_stateid,
1537 		const nfs4_stateid *deleg_stateid,
1538 		fmode_t fmode,
1539 		nfs4_stateid *freeme)
1540 {
1541 	/*
1542 	 * Protect the call to nfs4_state_set_mode_locked and
1543 	 * serialise the stateid update
1544 	 */
1545 	spin_lock(&state->owner->so_lock);
1546 	write_seqlock(&state->seqlock);
1547 	if (deleg_stateid != NULL) {
1548 		nfs4_stateid_copy(&state->stateid, deleg_stateid);
1549 		set_bit(NFS_DELEGATED_STATE, &state->flags);
1550 	}
1551 	if (open_stateid != NULL)
1552 		nfs_set_open_stateid_locked(state, open_stateid, fmode, freeme);
1553 	write_sequnlock(&state->seqlock);
1554 	update_open_stateflags(state, fmode);
1555 	spin_unlock(&state->owner->so_lock);
1556 }
1557 
1558 static int update_open_stateid(struct nfs4_state *state,
1559 		const nfs4_stateid *open_stateid,
1560 		const nfs4_stateid *delegation,
1561 		fmode_t fmode)
1562 {
1563 	struct nfs_server *server = NFS_SERVER(state->inode);
1564 	struct nfs_client *clp = server->nfs_client;
1565 	struct nfs_inode *nfsi = NFS_I(state->inode);
1566 	struct nfs_delegation *deleg_cur;
1567 	nfs4_stateid freeme = { };
1568 	int ret = 0;
1569 
1570 	fmode &= (FMODE_READ|FMODE_WRITE);
1571 
1572 	rcu_read_lock();
1573 	deleg_cur = rcu_dereference(nfsi->delegation);
1574 	if (deleg_cur == NULL)
1575 		goto no_delegation;
1576 
1577 	spin_lock(&deleg_cur->lock);
1578 	if (rcu_dereference(nfsi->delegation) != deleg_cur ||
1579 	   test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1580 	    (deleg_cur->type & fmode) != fmode)
1581 		goto no_delegation_unlock;
1582 
1583 	if (delegation == NULL)
1584 		delegation = &deleg_cur->stateid;
1585 	else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1586 		goto no_delegation_unlock;
1587 
1588 	nfs_mark_delegation_referenced(deleg_cur);
1589 	__update_open_stateid(state, open_stateid, &deleg_cur->stateid,
1590 			fmode, &freeme);
1591 	ret = 1;
1592 no_delegation_unlock:
1593 	spin_unlock(&deleg_cur->lock);
1594 no_delegation:
1595 	rcu_read_unlock();
1596 
1597 	if (!ret && open_stateid != NULL) {
1598 		__update_open_stateid(state, open_stateid, NULL, fmode, &freeme);
1599 		ret = 1;
1600 	}
1601 	if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags))
1602 		nfs4_schedule_state_manager(clp);
1603 	if (freeme.type != 0)
1604 		nfs4_test_and_free_stateid(server, &freeme,
1605 				state->owner->so_cred);
1606 
1607 	return ret;
1608 }
1609 
1610 static bool nfs4_update_lock_stateid(struct nfs4_lock_state *lsp,
1611 		const nfs4_stateid *stateid)
1612 {
1613 	struct nfs4_state *state = lsp->ls_state;
1614 	bool ret = false;
1615 
1616 	spin_lock(&state->state_lock);
1617 	if (!nfs4_stateid_match_other(stateid, &lsp->ls_stateid))
1618 		goto out_noupdate;
1619 	if (!nfs4_stateid_is_newer(stateid, &lsp->ls_stateid))
1620 		goto out_noupdate;
1621 	nfs4_stateid_copy(&lsp->ls_stateid, stateid);
1622 	ret = true;
1623 out_noupdate:
1624 	spin_unlock(&state->state_lock);
1625 	return ret;
1626 }
1627 
1628 static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1629 {
1630 	struct nfs_delegation *delegation;
1631 
1632 	rcu_read_lock();
1633 	delegation = rcu_dereference(NFS_I(inode)->delegation);
1634 	if (delegation == NULL || (delegation->type & fmode) == fmode) {
1635 		rcu_read_unlock();
1636 		return;
1637 	}
1638 	rcu_read_unlock();
1639 	nfs4_inode_return_delegation(inode);
1640 }
1641 
1642 static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1643 {
1644 	struct nfs4_state *state = opendata->state;
1645 	struct nfs_inode *nfsi = NFS_I(state->inode);
1646 	struct nfs_delegation *delegation;
1647 	int open_mode = opendata->o_arg.open_flags;
1648 	fmode_t fmode = opendata->o_arg.fmode;
1649 	enum open_claim_type4 claim = opendata->o_arg.claim;
1650 	nfs4_stateid stateid;
1651 	int ret = -EAGAIN;
1652 
1653 	for (;;) {
1654 		spin_lock(&state->owner->so_lock);
1655 		if (can_open_cached(state, fmode, open_mode)) {
1656 			update_open_stateflags(state, fmode);
1657 			spin_unlock(&state->owner->so_lock);
1658 			goto out_return_state;
1659 		}
1660 		spin_unlock(&state->owner->so_lock);
1661 		rcu_read_lock();
1662 		delegation = rcu_dereference(nfsi->delegation);
1663 		if (!can_open_delegated(delegation, fmode, claim)) {
1664 			rcu_read_unlock();
1665 			break;
1666 		}
1667 		/* Save the delegation */
1668 		nfs4_stateid_copy(&stateid, &delegation->stateid);
1669 		rcu_read_unlock();
1670 		nfs_release_seqid(opendata->o_arg.seqid);
1671 		if (!opendata->is_recover) {
1672 			ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
1673 			if (ret != 0)
1674 				goto out;
1675 		}
1676 		ret = -EAGAIN;
1677 
1678 		/* Try to update the stateid using the delegation */
1679 		if (update_open_stateid(state, NULL, &stateid, fmode))
1680 			goto out_return_state;
1681 	}
1682 out:
1683 	return ERR_PTR(ret);
1684 out_return_state:
1685 	atomic_inc(&state->count);
1686 	return state;
1687 }
1688 
1689 static void
1690 nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
1691 {
1692 	struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
1693 	struct nfs_delegation *delegation;
1694 	int delegation_flags = 0;
1695 
1696 	rcu_read_lock();
1697 	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1698 	if (delegation)
1699 		delegation_flags = delegation->flags;
1700 	rcu_read_unlock();
1701 	switch (data->o_arg.claim) {
1702 	default:
1703 		break;
1704 	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1705 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1706 		pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
1707 				   "returning a delegation for "
1708 				   "OPEN(CLAIM_DELEGATE_CUR)\n",
1709 				   clp->cl_hostname);
1710 		return;
1711 	}
1712 	if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
1713 		nfs_inode_set_delegation(state->inode,
1714 					 data->owner->so_cred,
1715 					 &data->o_res);
1716 	else
1717 		nfs_inode_reclaim_delegation(state->inode,
1718 					     data->owner->so_cred,
1719 					     &data->o_res);
1720 }
1721 
1722 /*
1723  * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
1724  * and update the nfs4_state.
1725  */
1726 static struct nfs4_state *
1727 _nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
1728 {
1729 	struct inode *inode = data->state->inode;
1730 	struct nfs4_state *state = data->state;
1731 	int ret;
1732 
1733 	if (!data->rpc_done) {
1734 		if (data->rpc_status) {
1735 			ret = data->rpc_status;
1736 			goto err;
1737 		}
1738 		/* cached opens have already been processed */
1739 		goto update;
1740 	}
1741 
1742 	ret = nfs_refresh_inode(inode, &data->f_attr);
1743 	if (ret)
1744 		goto err;
1745 
1746 	if (data->o_res.delegation_type != 0)
1747 		nfs4_opendata_check_deleg(data, state);
1748 update:
1749 	update_open_stateid(state, &data->o_res.stateid, NULL,
1750 			    data->o_arg.fmode);
1751 	atomic_inc(&state->count);
1752 
1753 	return state;
1754 err:
1755 	return ERR_PTR(ret);
1756 
1757 }
1758 
1759 static struct nfs4_state *
1760 _nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1761 {
1762 	struct inode *inode;
1763 	struct nfs4_state *state = NULL;
1764 	int ret;
1765 
1766 	if (!data->rpc_done) {
1767 		state = nfs4_try_open_cached(data);
1768 		trace_nfs4_cached_open(data->state);
1769 		goto out;
1770 	}
1771 
1772 	ret = -EAGAIN;
1773 	if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1774 		goto err;
1775 	inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr, data->f_label);
1776 	ret = PTR_ERR(inode);
1777 	if (IS_ERR(inode))
1778 		goto err;
1779 	ret = -ENOMEM;
1780 	state = nfs4_get_open_state(inode, data->owner);
1781 	if (state == NULL)
1782 		goto err_put_inode;
1783 	if (data->o_res.delegation_type != 0)
1784 		nfs4_opendata_check_deleg(data, state);
1785 	update_open_stateid(state, &data->o_res.stateid, NULL,
1786 			data->o_arg.fmode);
1787 	iput(inode);
1788 out:
1789 	nfs_release_seqid(data->o_arg.seqid);
1790 	return state;
1791 err_put_inode:
1792 	iput(inode);
1793 err:
1794 	return ERR_PTR(ret);
1795 }
1796 
1797 static struct nfs4_state *
1798 nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1799 {
1800 	struct nfs4_state *ret;
1801 
1802 	if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
1803 		ret =_nfs4_opendata_reclaim_to_nfs4_state(data);
1804 	else
1805 		ret = _nfs4_opendata_to_nfs4_state(data);
1806 	nfs4_sequence_free_slot(&data->o_res.seq_res);
1807 	return ret;
1808 }
1809 
1810 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
1811 {
1812 	struct nfs_inode *nfsi = NFS_I(state->inode);
1813 	struct nfs_open_context *ctx;
1814 
1815 	spin_lock(&state->inode->i_lock);
1816 	list_for_each_entry(ctx, &nfsi->open_files, list) {
1817 		if (ctx->state != state)
1818 			continue;
1819 		get_nfs_open_context(ctx);
1820 		spin_unlock(&state->inode->i_lock);
1821 		return ctx;
1822 	}
1823 	spin_unlock(&state->inode->i_lock);
1824 	return ERR_PTR(-ENOENT);
1825 }
1826 
1827 static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
1828 		struct nfs4_state *state, enum open_claim_type4 claim)
1829 {
1830 	struct nfs4_opendata *opendata;
1831 
1832 	opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
1833 			NULL, NULL, claim, GFP_NOFS);
1834 	if (opendata == NULL)
1835 		return ERR_PTR(-ENOMEM);
1836 	opendata->state = state;
1837 	atomic_inc(&state->count);
1838 	return opendata;
1839 }
1840 
1841 static int nfs4_open_recover_helper(struct nfs4_opendata *opendata,
1842 		fmode_t fmode)
1843 {
1844 	struct nfs4_state *newstate;
1845 	int ret;
1846 
1847 	if (!nfs4_mode_match_open_stateid(opendata->state, fmode))
1848 		return 0;
1849 	opendata->o_arg.open_flags = 0;
1850 	opendata->o_arg.fmode = fmode;
1851 	opendata->o_arg.share_access = nfs4_map_atomic_open_share(
1852 			NFS_SB(opendata->dentry->d_sb),
1853 			fmode, 0);
1854 	memset(&opendata->o_res, 0, sizeof(opendata->o_res));
1855 	memset(&opendata->c_res, 0, sizeof(opendata->c_res));
1856 	nfs4_init_opendata_res(opendata);
1857 	ret = _nfs4_recover_proc_open(opendata);
1858 	if (ret != 0)
1859 		return ret;
1860 	newstate = nfs4_opendata_to_nfs4_state(opendata);
1861 	if (IS_ERR(newstate))
1862 		return PTR_ERR(newstate);
1863 	if (newstate != opendata->state)
1864 		ret = -ESTALE;
1865 	nfs4_close_state(newstate, fmode);
1866 	return ret;
1867 }
1868 
1869 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
1870 {
1871 	int ret;
1872 
1873 	/* Don't trigger recovery in nfs_test_and_clear_all_open_stateid */
1874 	clear_bit(NFS_O_RDWR_STATE, &state->flags);
1875 	clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1876 	clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1877 	/* memory barrier prior to reading state->n_* */
1878 	clear_bit(NFS_DELEGATED_STATE, &state->flags);
1879 	clear_bit(NFS_OPEN_STATE, &state->flags);
1880 	smp_rmb();
1881 	ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
1882 	if (ret != 0)
1883 		return ret;
1884 	ret = nfs4_open_recover_helper(opendata, FMODE_WRITE);
1885 	if (ret != 0)
1886 		return ret;
1887 	ret = nfs4_open_recover_helper(opendata, FMODE_READ);
1888 	if (ret != 0)
1889 		return ret;
1890 	/*
1891 	 * We may have performed cached opens for all three recoveries.
1892 	 * Check if we need to update the current stateid.
1893 	 */
1894 	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1895 	    !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1896 		write_seqlock(&state->seqlock);
1897 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1898 			nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1899 		write_sequnlock(&state->seqlock);
1900 	}
1901 	return 0;
1902 }
1903 
1904 /*
1905  * OPEN_RECLAIM:
1906  * 	reclaim state on the server after a reboot.
1907  */
1908 static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1909 {
1910 	struct nfs_delegation *delegation;
1911 	struct nfs4_opendata *opendata;
1912 	fmode_t delegation_type = 0;
1913 	int status;
1914 
1915 	opendata = nfs4_open_recoverdata_alloc(ctx, state,
1916 			NFS4_OPEN_CLAIM_PREVIOUS);
1917 	if (IS_ERR(opendata))
1918 		return PTR_ERR(opendata);
1919 	rcu_read_lock();
1920 	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1921 	if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1922 		delegation_type = delegation->type;
1923 	rcu_read_unlock();
1924 	opendata->o_arg.u.delegation_type = delegation_type;
1925 	status = nfs4_open_recover(opendata, state);
1926 	nfs4_opendata_put(opendata);
1927 	return status;
1928 }
1929 
1930 static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
1931 {
1932 	struct nfs_server *server = NFS_SERVER(state->inode);
1933 	struct nfs4_exception exception = { };
1934 	int err;
1935 	do {
1936 		err = _nfs4_do_open_reclaim(ctx, state);
1937 		trace_nfs4_open_reclaim(ctx, 0, err);
1938 		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
1939 			continue;
1940 		if (err != -NFS4ERR_DELAY)
1941 			break;
1942 		nfs4_handle_exception(server, err, &exception);
1943 	} while (exception.retry);
1944 	return err;
1945 }
1946 
1947 static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
1948 {
1949 	struct nfs_open_context *ctx;
1950 	int ret;
1951 
1952 	ctx = nfs4_state_find_open_context(state);
1953 	if (IS_ERR(ctx))
1954 		return -EAGAIN;
1955 	ret = nfs4_do_open_reclaim(ctx, state);
1956 	put_nfs_open_context(ctx);
1957 	return ret;
1958 }
1959 
1960 static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
1961 {
1962 	switch (err) {
1963 		default:
1964 			printk(KERN_ERR "NFS: %s: unhandled error "
1965 					"%d.\n", __func__, err);
1966 		case 0:
1967 		case -ENOENT:
1968 		case -EAGAIN:
1969 		case -ESTALE:
1970 			break;
1971 		case -NFS4ERR_BADSESSION:
1972 		case -NFS4ERR_BADSLOT:
1973 		case -NFS4ERR_BAD_HIGH_SLOT:
1974 		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1975 		case -NFS4ERR_DEADSESSION:
1976 			set_bit(NFS_DELEGATED_STATE, &state->flags);
1977 			nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
1978 			return -EAGAIN;
1979 		case -NFS4ERR_STALE_CLIENTID:
1980 		case -NFS4ERR_STALE_STATEID:
1981 			set_bit(NFS_DELEGATED_STATE, &state->flags);
1982 			/* Don't recall a delegation if it was lost */
1983 			nfs4_schedule_lease_recovery(server->nfs_client);
1984 			return -EAGAIN;
1985 		case -NFS4ERR_MOVED:
1986 			nfs4_schedule_migration_recovery(server);
1987 			return -EAGAIN;
1988 		case -NFS4ERR_LEASE_MOVED:
1989 			nfs4_schedule_lease_moved_recovery(server->nfs_client);
1990 			return -EAGAIN;
1991 		case -NFS4ERR_DELEG_REVOKED:
1992 		case -NFS4ERR_ADMIN_REVOKED:
1993 		case -NFS4ERR_EXPIRED:
1994 		case -NFS4ERR_BAD_STATEID:
1995 		case -NFS4ERR_OPENMODE:
1996 			nfs_inode_find_state_and_recover(state->inode,
1997 					stateid);
1998 			nfs4_schedule_stateid_recovery(server, state);
1999 			return -EAGAIN;
2000 		case -NFS4ERR_DELAY:
2001 		case -NFS4ERR_GRACE:
2002 			set_bit(NFS_DELEGATED_STATE, &state->flags);
2003 			ssleep(1);
2004 			return -EAGAIN;
2005 		case -ENOMEM:
2006 		case -NFS4ERR_DENIED:
2007 			/* kill_proc(fl->fl_pid, SIGLOST, 1); */
2008 			return 0;
2009 	}
2010 	return err;
2011 }
2012 
2013 int nfs4_open_delegation_recall(struct nfs_open_context *ctx,
2014 		struct nfs4_state *state, const nfs4_stateid *stateid,
2015 		fmode_t type)
2016 {
2017 	struct nfs_server *server = NFS_SERVER(state->inode);
2018 	struct nfs4_opendata *opendata;
2019 	int err = 0;
2020 
2021 	opendata = nfs4_open_recoverdata_alloc(ctx, state,
2022 			NFS4_OPEN_CLAIM_DELEG_CUR_FH);
2023 	if (IS_ERR(opendata))
2024 		return PTR_ERR(opendata);
2025 	nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
2026 	write_seqlock(&state->seqlock);
2027 	nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2028 	write_sequnlock(&state->seqlock);
2029 	clear_bit(NFS_DELEGATED_STATE, &state->flags);
2030 	switch (type & (FMODE_READ|FMODE_WRITE)) {
2031 	case FMODE_READ|FMODE_WRITE:
2032 	case FMODE_WRITE:
2033 		err = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE);
2034 		if (err)
2035 			break;
2036 		err = nfs4_open_recover_helper(opendata, FMODE_WRITE);
2037 		if (err)
2038 			break;
2039 	case FMODE_READ:
2040 		err = nfs4_open_recover_helper(opendata, FMODE_READ);
2041 	}
2042 	nfs4_opendata_put(opendata);
2043 	return nfs4_handle_delegation_recall_error(server, state, stateid, err);
2044 }
2045 
2046 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2047 {
2048 	struct nfs4_opendata *data = calldata;
2049 
2050 	nfs40_setup_sequence(data->o_arg.server->nfs_client->cl_slot_tbl,
2051 			     &data->c_arg.seq_args, &data->c_res.seq_res, task);
2052 }
2053 
2054 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2055 {
2056 	struct nfs4_opendata *data = calldata;
2057 
2058 	nfs40_sequence_done(task, &data->c_res.seq_res);
2059 
2060 	data->rpc_status = task->tk_status;
2061 	if (data->rpc_status == 0) {
2062 		nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
2063 		nfs_confirm_seqid(&data->owner->so_seqid, 0);
2064 		renew_lease(data->o_res.server, data->timestamp);
2065 		data->rpc_done = 1;
2066 	}
2067 }
2068 
2069 static void nfs4_open_confirm_release(void *calldata)
2070 {
2071 	struct nfs4_opendata *data = calldata;
2072 	struct nfs4_state *state = NULL;
2073 
2074 	/* If this request hasn't been cancelled, do nothing */
2075 	if (data->cancelled == 0)
2076 		goto out_free;
2077 	/* In case of error, no cleanup! */
2078 	if (!data->rpc_done)
2079 		goto out_free;
2080 	state = nfs4_opendata_to_nfs4_state(data);
2081 	if (!IS_ERR(state))
2082 		nfs4_close_state(state, data->o_arg.fmode);
2083 out_free:
2084 	nfs4_opendata_put(data);
2085 }
2086 
2087 static const struct rpc_call_ops nfs4_open_confirm_ops = {
2088 	.rpc_call_prepare = nfs4_open_confirm_prepare,
2089 	.rpc_call_done = nfs4_open_confirm_done,
2090 	.rpc_release = nfs4_open_confirm_release,
2091 };
2092 
2093 /*
2094  * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
2095  */
2096 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
2097 {
2098 	struct nfs_server *server = NFS_SERVER(d_inode(data->dir));
2099 	struct rpc_task *task;
2100 	struct  rpc_message msg = {
2101 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
2102 		.rpc_argp = &data->c_arg,
2103 		.rpc_resp = &data->c_res,
2104 		.rpc_cred = data->owner->so_cred,
2105 	};
2106 	struct rpc_task_setup task_setup_data = {
2107 		.rpc_client = server->client,
2108 		.rpc_message = &msg,
2109 		.callback_ops = &nfs4_open_confirm_ops,
2110 		.callback_data = data,
2111 		.workqueue = nfsiod_workqueue,
2112 		.flags = RPC_TASK_ASYNC,
2113 	};
2114 	int status;
2115 
2116 	nfs4_init_sequence(&data->c_arg.seq_args, &data->c_res.seq_res, 1);
2117 	kref_get(&data->kref);
2118 	data->rpc_done = 0;
2119 	data->rpc_status = 0;
2120 	data->timestamp = jiffies;
2121 	if (data->is_recover)
2122 		nfs4_set_sequence_privileged(&data->c_arg.seq_args);
2123 	task = rpc_run_task(&task_setup_data);
2124 	if (IS_ERR(task))
2125 		return PTR_ERR(task);
2126 	status = nfs4_wait_for_completion_rpc_task(task);
2127 	if (status != 0) {
2128 		data->cancelled = 1;
2129 		smp_wmb();
2130 	} else
2131 		status = data->rpc_status;
2132 	rpc_put_task(task);
2133 	return status;
2134 }
2135 
2136 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
2137 {
2138 	struct nfs4_opendata *data = calldata;
2139 	struct nfs4_state_owner *sp = data->owner;
2140 	struct nfs_client *clp = sp->so_server->nfs_client;
2141 	enum open_claim_type4 claim = data->o_arg.claim;
2142 
2143 	if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2144 		goto out_wait;
2145 	/*
2146 	 * Check if we still need to send an OPEN call, or if we can use
2147 	 * a delegation instead.
2148 	 */
2149 	if (data->state != NULL) {
2150 		struct nfs_delegation *delegation;
2151 
2152 		if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
2153 			goto out_no_action;
2154 		rcu_read_lock();
2155 		delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
2156 		if (can_open_delegated(delegation, data->o_arg.fmode, claim))
2157 			goto unlock_no_action;
2158 		rcu_read_unlock();
2159 	}
2160 	/* Update client id. */
2161 	data->o_arg.clientid = clp->cl_clientid;
2162 	switch (claim) {
2163 	default:
2164 		break;
2165 	case NFS4_OPEN_CLAIM_PREVIOUS:
2166 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
2167 	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
2168 		data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
2169 	case NFS4_OPEN_CLAIM_FH:
2170 		task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
2171 		nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
2172 	}
2173 	data->timestamp = jiffies;
2174 	if (nfs4_setup_sequence(data->o_arg.server,
2175 				&data->o_arg.seq_args,
2176 				&data->o_res.seq_res,
2177 				task) != 0)
2178 		nfs_release_seqid(data->o_arg.seqid);
2179 
2180 	/* Set the create mode (note dependency on the session type) */
2181 	data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
2182 	if (data->o_arg.open_flags & O_EXCL) {
2183 		data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
2184 		if (nfs4_has_persistent_session(clp))
2185 			data->o_arg.createmode = NFS4_CREATE_GUARDED;
2186 		else if (clp->cl_mvops->minor_version > 0)
2187 			data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
2188 	}
2189 	return;
2190 unlock_no_action:
2191 	trace_nfs4_cached_open(data->state);
2192 	rcu_read_unlock();
2193 out_no_action:
2194 	task->tk_action = NULL;
2195 out_wait:
2196 	nfs4_sequence_done(task, &data->o_res.seq_res);
2197 }
2198 
2199 static void nfs4_open_done(struct rpc_task *task, void *calldata)
2200 {
2201 	struct nfs4_opendata *data = calldata;
2202 
2203 	data->rpc_status = task->tk_status;
2204 
2205 	if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2206 		return;
2207 
2208 	if (task->tk_status == 0) {
2209 		if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
2210 			switch (data->o_res.f_attr->mode & S_IFMT) {
2211 			case S_IFREG:
2212 				break;
2213 			case S_IFLNK:
2214 				data->rpc_status = -ELOOP;
2215 				break;
2216 			case S_IFDIR:
2217 				data->rpc_status = -EISDIR;
2218 				break;
2219 			default:
2220 				data->rpc_status = -ENOTDIR;
2221 			}
2222 		}
2223 		renew_lease(data->o_res.server, data->timestamp);
2224 		if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
2225 			nfs_confirm_seqid(&data->owner->so_seqid, 0);
2226 	}
2227 	data->rpc_done = 1;
2228 }
2229 
2230 static void nfs4_open_release(void *calldata)
2231 {
2232 	struct nfs4_opendata *data = calldata;
2233 	struct nfs4_state *state = NULL;
2234 
2235 	/* If this request hasn't been cancelled, do nothing */
2236 	if (data->cancelled == 0)
2237 		goto out_free;
2238 	/* In case of error, no cleanup! */
2239 	if (data->rpc_status != 0 || !data->rpc_done)
2240 		goto out_free;
2241 	/* In case we need an open_confirm, no cleanup! */
2242 	if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
2243 		goto out_free;
2244 	state = nfs4_opendata_to_nfs4_state(data);
2245 	if (!IS_ERR(state))
2246 		nfs4_close_state(state, data->o_arg.fmode);
2247 out_free:
2248 	nfs4_opendata_put(data);
2249 }
2250 
2251 static const struct rpc_call_ops nfs4_open_ops = {
2252 	.rpc_call_prepare = nfs4_open_prepare,
2253 	.rpc_call_done = nfs4_open_done,
2254 	.rpc_release = nfs4_open_release,
2255 };
2256 
2257 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
2258 {
2259 	struct inode *dir = d_inode(data->dir);
2260 	struct nfs_server *server = NFS_SERVER(dir);
2261 	struct nfs_openargs *o_arg = &data->o_arg;
2262 	struct nfs_openres *o_res = &data->o_res;
2263 	struct rpc_task *task;
2264 	struct rpc_message msg = {
2265 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
2266 		.rpc_argp = o_arg,
2267 		.rpc_resp = o_res,
2268 		.rpc_cred = data->owner->so_cred,
2269 	};
2270 	struct rpc_task_setup task_setup_data = {
2271 		.rpc_client = server->client,
2272 		.rpc_message = &msg,
2273 		.callback_ops = &nfs4_open_ops,
2274 		.callback_data = data,
2275 		.workqueue = nfsiod_workqueue,
2276 		.flags = RPC_TASK_ASYNC,
2277 	};
2278 	int status;
2279 
2280 	nfs4_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
2281 	kref_get(&data->kref);
2282 	data->rpc_done = 0;
2283 	data->rpc_status = 0;
2284 	data->cancelled = 0;
2285 	data->is_recover = 0;
2286 	if (isrecover) {
2287 		nfs4_set_sequence_privileged(&o_arg->seq_args);
2288 		data->is_recover = 1;
2289 	}
2290 	task = rpc_run_task(&task_setup_data);
2291         if (IS_ERR(task))
2292                 return PTR_ERR(task);
2293         status = nfs4_wait_for_completion_rpc_task(task);
2294         if (status != 0) {
2295                 data->cancelled = 1;
2296                 smp_wmb();
2297         } else
2298                 status = data->rpc_status;
2299         rpc_put_task(task);
2300 
2301 	return status;
2302 }
2303 
2304 static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
2305 {
2306 	struct inode *dir = d_inode(data->dir);
2307 	struct nfs_openres *o_res = &data->o_res;
2308         int status;
2309 
2310 	status = nfs4_run_open_task(data, 1);
2311 	if (status != 0 || !data->rpc_done)
2312 		return status;
2313 
2314 	nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);
2315 
2316 	if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2317 		status = _nfs4_proc_open_confirm(data);
2318 		if (status != 0)
2319 			return status;
2320 	}
2321 
2322 	return status;
2323 }
2324 
2325 /*
2326  * Additional permission checks in order to distinguish between an
2327  * open for read, and an open for execute. This works around the
2328  * fact that NFSv4 OPEN treats read and execute permissions as being
2329  * the same.
2330  * Note that in the non-execute case, we want to turn off permission
2331  * checking if we just created a new file (POSIX open() semantics).
2332  */
2333 static int nfs4_opendata_access(struct rpc_cred *cred,
2334 				struct nfs4_opendata *opendata,
2335 				struct nfs4_state *state, fmode_t fmode,
2336 				int openflags)
2337 {
2338 	struct nfs_access_entry cache;
2339 	u32 mask;
2340 
2341 	/* access call failed or for some reason the server doesn't
2342 	 * support any access modes -- defer access call until later */
2343 	if (opendata->o_res.access_supported == 0)
2344 		return 0;
2345 
2346 	mask = 0;
2347 	/*
2348 	 * Use openflags to check for exec, because fmode won't
2349 	 * always have FMODE_EXEC set when file open for exec.
2350 	 */
2351 	if (openflags & __FMODE_EXEC) {
2352 		/* ONLY check for exec rights */
2353 		mask = MAY_EXEC;
2354 	} else if ((fmode & FMODE_READ) && !opendata->file_created)
2355 		mask = MAY_READ;
2356 
2357 	cache.cred = cred;
2358 	cache.jiffies = jiffies;
2359 	nfs_access_set_mask(&cache, opendata->o_res.access_result);
2360 	nfs_access_add_cache(state->inode, &cache);
2361 
2362 	if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
2363 		return 0;
2364 
2365 	/* even though OPEN succeeded, access is denied. Close the file */
2366 	nfs4_close_state(state, fmode);
2367 	return -EACCES;
2368 }
2369 
2370 /*
2371  * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
2372  */
2373 static int _nfs4_proc_open(struct nfs4_opendata *data)
2374 {
2375 	struct inode *dir = d_inode(data->dir);
2376 	struct nfs_server *server = NFS_SERVER(dir);
2377 	struct nfs_openargs *o_arg = &data->o_arg;
2378 	struct nfs_openres *o_res = &data->o_res;
2379 	int status;
2380 
2381 	status = nfs4_run_open_task(data, 0);
2382 	if (!data->rpc_done)
2383 		return status;
2384 	if (status != 0) {
2385 		if (status == -NFS4ERR_BADNAME &&
2386 				!(o_arg->open_flags & O_CREAT))
2387 			return -ENOENT;
2388 		return status;
2389 	}
2390 
2391 	nfs_fattr_map_and_free_names(server, &data->f_attr);
2392 
2393 	if (o_arg->open_flags & O_CREAT) {
2394 		update_changeattr(dir, &o_res->cinfo);
2395 		if (o_arg->open_flags & O_EXCL)
2396 			data->file_created = 1;
2397 		else if (o_res->cinfo.before != o_res->cinfo.after)
2398 			data->file_created = 1;
2399 	}
2400 	if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
2401 		server->caps &= ~NFS_CAP_POSIX_LOCK;
2402 	if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
2403 		status = _nfs4_proc_open_confirm(data);
2404 		if (status != 0)
2405 			return status;
2406 	}
2407 	if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
2408 		nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr, o_res->f_label);
2409 	return 0;
2410 }
2411 
2412 static int nfs4_recover_expired_lease(struct nfs_server *server)
2413 {
2414 	return nfs4_client_recover_expired_lease(server->nfs_client);
2415 }
2416 
2417 /*
2418  * OPEN_EXPIRED:
2419  * 	reclaim state on the server after a network partition.
2420  * 	Assumes caller holds the appropriate lock
2421  */
2422 static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2423 {
2424 	struct nfs4_opendata *opendata;
2425 	int ret;
2426 
2427 	opendata = nfs4_open_recoverdata_alloc(ctx, state,
2428 			NFS4_OPEN_CLAIM_FH);
2429 	if (IS_ERR(opendata))
2430 		return PTR_ERR(opendata);
2431 	ret = nfs4_open_recover(opendata, state);
2432 	if (ret == -ESTALE)
2433 		d_drop(ctx->dentry);
2434 	nfs4_opendata_put(opendata);
2435 	return ret;
2436 }
2437 
2438 static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
2439 {
2440 	struct nfs_server *server = NFS_SERVER(state->inode);
2441 	struct nfs4_exception exception = { };
2442 	int err;
2443 
2444 	do {
2445 		err = _nfs4_open_expired(ctx, state);
2446 		trace_nfs4_open_expired(ctx, 0, err);
2447 		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
2448 			continue;
2449 		switch (err) {
2450 		default:
2451 			goto out;
2452 		case -NFS4ERR_GRACE:
2453 		case -NFS4ERR_DELAY:
2454 			nfs4_handle_exception(server, err, &exception);
2455 			err = 0;
2456 		}
2457 	} while (exception.retry);
2458 out:
2459 	return err;
2460 }
2461 
2462 static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2463 {
2464 	struct nfs_open_context *ctx;
2465 	int ret;
2466 
2467 	ctx = nfs4_state_find_open_context(state);
2468 	if (IS_ERR(ctx))
2469 		return -EAGAIN;
2470 	ret = nfs4_do_open_expired(ctx, state);
2471 	put_nfs_open_context(ctx);
2472 	return ret;
2473 }
2474 
2475 static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state,
2476 		const nfs4_stateid *stateid)
2477 {
2478 	nfs_remove_bad_delegation(state->inode, stateid);
2479 	write_seqlock(&state->seqlock);
2480 	nfs4_stateid_copy(&state->stateid, &state->open_stateid);
2481 	write_sequnlock(&state->seqlock);
2482 	clear_bit(NFS_DELEGATED_STATE, &state->flags);
2483 }
2484 
2485 static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
2486 {
2487 	if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
2488 		nfs_finish_clear_delegation_stateid(state, NULL);
2489 }
2490 
2491 static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2492 {
2493 	/* NFSv4.0 doesn't allow for delegation recovery on open expire */
2494 	nfs40_clear_delegation_stateid(state);
2495 	return nfs4_open_expired(sp, state);
2496 }
2497 
2498 static int nfs40_test_and_free_expired_stateid(struct nfs_server *server,
2499 		nfs4_stateid *stateid,
2500 		struct rpc_cred *cred)
2501 {
2502 	return -NFS4ERR_BAD_STATEID;
2503 }
2504 
2505 #if defined(CONFIG_NFS_V4_1)
2506 static int nfs41_test_and_free_expired_stateid(struct nfs_server *server,
2507 		nfs4_stateid *stateid,
2508 		struct rpc_cred *cred)
2509 {
2510 	int status;
2511 
2512 	switch (stateid->type) {
2513 	default:
2514 		break;
2515 	case NFS4_INVALID_STATEID_TYPE:
2516 	case NFS4_SPECIAL_STATEID_TYPE:
2517 		return -NFS4ERR_BAD_STATEID;
2518 	case NFS4_REVOKED_STATEID_TYPE:
2519 		goto out_free;
2520 	}
2521 
2522 	status = nfs41_test_stateid(server, stateid, cred);
2523 	switch (status) {
2524 	case -NFS4ERR_EXPIRED:
2525 	case -NFS4ERR_ADMIN_REVOKED:
2526 	case -NFS4ERR_DELEG_REVOKED:
2527 		break;
2528 	default:
2529 		return status;
2530 	}
2531 out_free:
2532 	/* Ack the revoked state to the server */
2533 	nfs41_free_stateid(server, stateid, cred, true);
2534 	return -NFS4ERR_EXPIRED;
2535 }
2536 
2537 static void nfs41_check_delegation_stateid(struct nfs4_state *state)
2538 {
2539 	struct nfs_server *server = NFS_SERVER(state->inode);
2540 	nfs4_stateid stateid;
2541 	struct nfs_delegation *delegation;
2542 	struct rpc_cred *cred;
2543 	int status;
2544 
2545 	/* Get the delegation credential for use by test/free_stateid */
2546 	rcu_read_lock();
2547 	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
2548 	if (delegation == NULL) {
2549 		rcu_read_unlock();
2550 		return;
2551 	}
2552 
2553 	nfs4_stateid_copy(&stateid, &delegation->stateid);
2554 	if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
2555 		rcu_read_unlock();
2556 		nfs_finish_clear_delegation_stateid(state, &stateid);
2557 		return;
2558 	}
2559 
2560 	if (!test_and_clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) {
2561 		rcu_read_unlock();
2562 		return;
2563 	}
2564 
2565 	cred = get_rpccred(delegation->cred);
2566 	rcu_read_unlock();
2567 	status = nfs41_test_and_free_expired_stateid(server, &stateid, cred);
2568 	trace_nfs4_test_delegation_stateid(state, NULL, status);
2569 	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
2570 		nfs_finish_clear_delegation_stateid(state, &stateid);
2571 
2572 	put_rpccred(cred);
2573 }
2574 
2575 /**
2576  * nfs41_check_expired_locks - possibly free a lock stateid
2577  *
2578  * @state: NFSv4 state for an inode
2579  *
2580  * Returns NFS_OK if recovery for this stateid is now finished.
2581  * Otherwise a negative NFS4ERR value is returned.
2582  */
2583 static int nfs41_check_expired_locks(struct nfs4_state *state)
2584 {
2585 	int status, ret = NFS_OK;
2586 	struct nfs4_lock_state *lsp, *prev = NULL;
2587 	struct nfs_server *server = NFS_SERVER(state->inode);
2588 
2589 	if (!test_bit(LK_STATE_IN_USE, &state->flags))
2590 		goto out;
2591 
2592 	spin_lock(&state->state_lock);
2593 	list_for_each_entry(lsp, &state->lock_states, ls_locks) {
2594 		if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
2595 			struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
2596 
2597 			atomic_inc(&lsp->ls_count);
2598 			spin_unlock(&state->state_lock);
2599 
2600 			nfs4_put_lock_state(prev);
2601 			prev = lsp;
2602 
2603 			status = nfs41_test_and_free_expired_stateid(server,
2604 					&lsp->ls_stateid,
2605 					cred);
2606 			trace_nfs4_test_lock_stateid(state, lsp, status);
2607 			if (status == -NFS4ERR_EXPIRED ||
2608 			    status == -NFS4ERR_BAD_STATEID) {
2609 				clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
2610 				lsp->ls_stateid.type = NFS4_INVALID_STATEID_TYPE;
2611 				if (!recover_lost_locks)
2612 					set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
2613 			} else if (status != NFS_OK) {
2614 				ret = status;
2615 				nfs4_put_lock_state(prev);
2616 				goto out;
2617 			}
2618 			spin_lock(&state->state_lock);
2619 		}
2620 	}
2621 	spin_unlock(&state->state_lock);
2622 	nfs4_put_lock_state(prev);
2623 out:
2624 	return ret;
2625 }
2626 
2627 /**
2628  * nfs41_check_open_stateid - possibly free an open stateid
2629  *
2630  * @state: NFSv4 state for an inode
2631  *
2632  * Returns NFS_OK if recovery for this stateid is now finished.
2633  * Otherwise a negative NFS4ERR value is returned.
2634  */
2635 static int nfs41_check_open_stateid(struct nfs4_state *state)
2636 {
2637 	struct nfs_server *server = NFS_SERVER(state->inode);
2638 	nfs4_stateid *stateid = &state->open_stateid;
2639 	struct rpc_cred *cred = state->owner->so_cred;
2640 	int status;
2641 
2642 	if (test_bit(NFS_OPEN_STATE, &state->flags) == 0) {
2643 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)  {
2644 			if (nfs4_have_delegation(state->inode, state->state))
2645 				return NFS_OK;
2646 			return -NFS4ERR_OPENMODE;
2647 		}
2648 		return -NFS4ERR_BAD_STATEID;
2649 	}
2650 	status = nfs41_test_and_free_expired_stateid(server, stateid, cred);
2651 	trace_nfs4_test_open_stateid(state, NULL, status);
2652 	if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID) {
2653 		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2654 		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2655 		clear_bit(NFS_O_RDWR_STATE, &state->flags);
2656 		clear_bit(NFS_OPEN_STATE, &state->flags);
2657 		stateid->type = NFS4_INVALID_STATEID_TYPE;
2658 	}
2659 	if (status != NFS_OK)
2660 		return status;
2661 	if (nfs_open_stateid_recover_openmode(state))
2662 		return -NFS4ERR_OPENMODE;
2663 	return NFS_OK;
2664 }
2665 
2666 static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
2667 {
2668 	int status;
2669 
2670 	nfs41_check_delegation_stateid(state);
2671 	status = nfs41_check_expired_locks(state);
2672 	if (status != NFS_OK)
2673 		return status;
2674 	status = nfs41_check_open_stateid(state);
2675 	if (status != NFS_OK)
2676 		status = nfs4_open_expired(sp, state);
2677 	return status;
2678 }
2679 #endif
2680 
2681 /*
2682  * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
2683  * fields corresponding to attributes that were used to store the verifier.
2684  * Make sure we clobber those fields in the later setattr call
2685  */
2686 static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata,
2687 				struct iattr *sattr, struct nfs4_label **label)
2688 {
2689 	const u32 *attrset = opendata->o_res.attrset;
2690 
2691 	if ((attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
2692 	    !(sattr->ia_valid & ATTR_ATIME_SET))
2693 		sattr->ia_valid |= ATTR_ATIME;
2694 
2695 	if ((attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
2696 	    !(sattr->ia_valid & ATTR_MTIME_SET))
2697 		sattr->ia_valid |= ATTR_MTIME;
2698 
2699 	/* Except MODE, it seems harmless of setting twice. */
2700 	if ((attrset[1] & FATTR4_WORD1_MODE))
2701 		sattr->ia_valid &= ~ATTR_MODE;
2702 
2703 	if (attrset[2] & FATTR4_WORD2_SECURITY_LABEL)
2704 		*label = NULL;
2705 }
2706 
2707 static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
2708 		fmode_t fmode,
2709 		int flags,
2710 		struct nfs_open_context *ctx)
2711 {
2712 	struct nfs4_state_owner *sp = opendata->owner;
2713 	struct nfs_server *server = sp->so_server;
2714 	struct dentry *dentry;
2715 	struct nfs4_state *state;
2716 	unsigned int seq;
2717 	int ret;
2718 
2719 	seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
2720 
2721 	ret = _nfs4_proc_open(opendata);
2722 	if (ret != 0)
2723 		goto out;
2724 
2725 	state = nfs4_opendata_to_nfs4_state(opendata);
2726 	ret = PTR_ERR(state);
2727 	if (IS_ERR(state))
2728 		goto out;
2729 	if (server->caps & NFS_CAP_POSIX_LOCK)
2730 		set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);
2731 	if (opendata->o_res.rflags & NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK)
2732 		set_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags);
2733 
2734 	dentry = opendata->dentry;
2735 	if (d_really_is_negative(dentry)) {
2736 		struct dentry *alias;
2737 		d_drop(dentry);
2738 		alias = d_exact_alias(dentry, state->inode);
2739 		if (!alias)
2740 			alias = d_splice_alias(igrab(state->inode), dentry);
2741 		/* d_splice_alias() can't fail here - it's a non-directory */
2742 		if (alias) {
2743 			dput(ctx->dentry);
2744 			ctx->dentry = dentry = alias;
2745 		}
2746 		nfs_set_verifier(dentry,
2747 				nfs_save_change_attribute(d_inode(opendata->dir)));
2748 	}
2749 
2750 	ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
2751 	if (ret != 0)
2752 		goto out;
2753 
2754 	ctx->state = state;
2755 	if (d_inode(dentry) == state->inode) {
2756 		nfs_inode_attach_open_context(ctx);
2757 		if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
2758 			nfs4_schedule_stateid_recovery(server, state);
2759 	}
2760 out:
2761 	return ret;
2762 }
2763 
2764 /*
2765  * Returns a referenced nfs4_state
2766  */
2767 static int _nfs4_do_open(struct inode *dir,
2768 			struct nfs_open_context *ctx,
2769 			int flags,
2770 			struct iattr *sattr,
2771 			struct nfs4_label *label,
2772 			int *opened)
2773 {
2774 	struct nfs4_state_owner  *sp;
2775 	struct nfs4_state     *state = NULL;
2776 	struct nfs_server       *server = NFS_SERVER(dir);
2777 	struct nfs4_opendata *opendata;
2778 	struct dentry *dentry = ctx->dentry;
2779 	struct rpc_cred *cred = ctx->cred;
2780 	struct nfs4_threshold **ctx_th = &ctx->mdsthreshold;
2781 	fmode_t fmode = ctx->mode & (FMODE_READ|FMODE_WRITE|FMODE_EXEC);
2782 	enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
2783 	struct nfs4_label *olabel = NULL;
2784 	int status;
2785 
2786 	/* Protect against reboot recovery conflicts */
2787 	status = -ENOMEM;
2788 	sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
2789 	if (sp == NULL) {
2790 		dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
2791 		goto out_err;
2792 	}
2793 	status = nfs4_recover_expired_lease(server);
2794 	if (status != 0)
2795 		goto err_put_state_owner;
2796 	if (d_really_is_positive(dentry))
2797 		nfs4_return_incompatible_delegation(d_inode(dentry), fmode);
2798 	status = -ENOMEM;
2799 	if (d_really_is_positive(dentry))
2800 		claim = NFS4_OPEN_CLAIM_FH;
2801 	opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
2802 			label, claim, GFP_KERNEL);
2803 	if (opendata == NULL)
2804 		goto err_put_state_owner;
2805 
2806 	if (label) {
2807 		olabel = nfs4_label_alloc(server, GFP_KERNEL);
2808 		if (IS_ERR(olabel)) {
2809 			status = PTR_ERR(olabel);
2810 			goto err_opendata_put;
2811 		}
2812 	}
2813 
2814 	if (server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
2815 		if (!opendata->f_attr.mdsthreshold) {
2816 			opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
2817 			if (!opendata->f_attr.mdsthreshold)
2818 				goto err_free_label;
2819 		}
2820 		opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
2821 	}
2822 	if (d_really_is_positive(dentry))
2823 		opendata->state = nfs4_get_open_state(d_inode(dentry), sp);
2824 
2825 	status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx);
2826 	if (status != 0)
2827 		goto err_free_label;
2828 	state = ctx->state;
2829 
2830 	if ((opendata->o_arg.open_flags & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL) &&
2831 	    (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
2832 		nfs4_exclusive_attrset(opendata, sattr, &label);
2833 		/*
2834 		 * send create attributes which was not set by open
2835 		 * with an extra setattr.
2836 		 */
2837 		if (sattr->ia_valid & NFS4_VALID_ATTRS) {
2838 			nfs_fattr_init(opendata->o_res.f_attr);
2839 			status = nfs4_do_setattr(state->inode, cred,
2840 					opendata->o_res.f_attr, sattr,
2841 					ctx, label, olabel);
2842 			if (status == 0) {
2843 				nfs_setattr_update_inode(state->inode, sattr,
2844 						opendata->o_res.f_attr);
2845 				nfs_setsecurity(state->inode, opendata->o_res.f_attr, olabel);
2846 			}
2847 		}
2848 	}
2849 	if (opened && opendata->file_created)
2850 		*opened |= FILE_CREATED;
2851 
2852 	if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server)) {
2853 		*ctx_th = opendata->f_attr.mdsthreshold;
2854 		opendata->f_attr.mdsthreshold = NULL;
2855 	}
2856 
2857 	nfs4_label_free(olabel);
2858 
2859 	nfs4_opendata_put(opendata);
2860 	nfs4_put_state_owner(sp);
2861 	return 0;
2862 err_free_label:
2863 	nfs4_label_free(olabel);
2864 err_opendata_put:
2865 	nfs4_opendata_put(opendata);
2866 err_put_state_owner:
2867 	nfs4_put_state_owner(sp);
2868 out_err:
2869 	return status;
2870 }
2871 
2872 
2873 static struct nfs4_state *nfs4_do_open(struct inode *dir,
2874 					struct nfs_open_context *ctx,
2875 					int flags,
2876 					struct iattr *sattr,
2877 					struct nfs4_label *label,
2878 					int *opened)
2879 {
2880 	struct nfs_server *server = NFS_SERVER(dir);
2881 	struct nfs4_exception exception = { };
2882 	struct nfs4_state *res;
2883 	int status;
2884 
2885 	do {
2886 		status = _nfs4_do_open(dir, ctx, flags, sattr, label, opened);
2887 		res = ctx->state;
2888 		trace_nfs4_open_file(ctx, flags, status);
2889 		if (status == 0)
2890 			break;
2891 		/* NOTE: BAD_SEQID means the server and client disagree about the
2892 		 * book-keeping w.r.t. state-changing operations
2893 		 * (OPEN/CLOSE/LOCK/LOCKU...)
2894 		 * It is actually a sign of a bug on the client or on the server.
2895 		 *
2896 		 * If we receive a BAD_SEQID error in the particular case of
2897 		 * doing an OPEN, we assume that nfs_increment_open_seqid() will
2898 		 * have unhashed the old state_owner for us, and that we can
2899 		 * therefore safely retry using a new one. We should still warn
2900 		 * the user though...
2901 		 */
2902 		if (status == -NFS4ERR_BAD_SEQID) {
2903 			pr_warn_ratelimited("NFS: v4 server %s "
2904 					" returned a bad sequence-id error!\n",
2905 					NFS_SERVER(dir)->nfs_client->cl_hostname);
2906 			exception.retry = 1;
2907 			continue;
2908 		}
2909 		/*
2910 		 * BAD_STATEID on OPEN means that the server cancelled our
2911 		 * state before it received the OPEN_CONFIRM.
2912 		 * Recover by retrying the request as per the discussion
2913 		 * on Page 181 of RFC3530.
2914 		 */
2915 		if (status == -NFS4ERR_BAD_STATEID) {
2916 			exception.retry = 1;
2917 			continue;
2918 		}
2919 		if (status == -EAGAIN) {
2920 			/* We must have found a delegation */
2921 			exception.retry = 1;
2922 			continue;
2923 		}
2924 		if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
2925 			continue;
2926 		res = ERR_PTR(nfs4_handle_exception(server,
2927 					status, &exception));
2928 	} while (exception.retry);
2929 	return res;
2930 }
2931 
2932 static int _nfs4_do_setattr(struct inode *inode,
2933 			    struct nfs_setattrargs *arg,
2934 			    struct nfs_setattrres *res,
2935 			    struct rpc_cred *cred,
2936 			    struct nfs_open_context *ctx)
2937 {
2938 	struct nfs_server *server = NFS_SERVER(inode);
2939         struct rpc_message msg = {
2940 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
2941 		.rpc_argp	= arg,
2942 		.rpc_resp	= res,
2943 		.rpc_cred	= cred,
2944         };
2945 	struct rpc_cred *delegation_cred = NULL;
2946 	unsigned long timestamp = jiffies;
2947 	fmode_t fmode;
2948 	bool truncate;
2949 	int status;
2950 
2951 	nfs_fattr_init(res->fattr);
2952 
2953 	/* Servers should only apply open mode checks for file size changes */
2954 	truncate = (arg->iap->ia_valid & ATTR_SIZE) ? true : false;
2955 	fmode = truncate ? FMODE_WRITE : FMODE_READ;
2956 
2957 	if (nfs4_copy_delegation_stateid(inode, fmode, &arg->stateid, &delegation_cred)) {
2958 		/* Use that stateid */
2959 	} else if (truncate && ctx != NULL) {
2960 		struct nfs_lock_context *l_ctx;
2961 		if (!nfs4_valid_open_stateid(ctx->state))
2962 			return -EBADF;
2963 		l_ctx = nfs_get_lock_context(ctx);
2964 		if (IS_ERR(l_ctx))
2965 			return PTR_ERR(l_ctx);
2966 		status = nfs4_select_rw_stateid(ctx->state, FMODE_WRITE, l_ctx,
2967 						&arg->stateid, &delegation_cred);
2968 		nfs_put_lock_context(l_ctx);
2969 		if (status == -EIO)
2970 			return -EBADF;
2971 	} else
2972 		nfs4_stateid_copy(&arg->stateid, &zero_stateid);
2973 	if (delegation_cred)
2974 		msg.rpc_cred = delegation_cred;
2975 
2976 	status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
2977 
2978 	put_rpccred(delegation_cred);
2979 	if (status == 0 && ctx != NULL)
2980 		renew_lease(server, timestamp);
2981 	trace_nfs4_setattr(inode, &arg->stateid, status);
2982 	return status;
2983 }
2984 
2985 static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
2986 			   struct nfs_fattr *fattr, struct iattr *sattr,
2987 			   struct nfs_open_context *ctx, struct nfs4_label *ilabel,
2988 			   struct nfs4_label *olabel)
2989 {
2990 	struct nfs_server *server = NFS_SERVER(inode);
2991 	struct nfs4_state *state = ctx ? ctx->state : NULL;
2992         struct nfs_setattrargs  arg = {
2993                 .fh             = NFS_FH(inode),
2994                 .iap            = sattr,
2995 		.server		= server,
2996 		.bitmask = server->attr_bitmask,
2997 		.label		= ilabel,
2998         };
2999         struct nfs_setattrres  res = {
3000 		.fattr		= fattr,
3001 		.label		= olabel,
3002 		.server		= server,
3003         };
3004 	struct nfs4_exception exception = {
3005 		.state = state,
3006 		.inode = inode,
3007 		.stateid = &arg.stateid,
3008 	};
3009 	int err;
3010 
3011 	arg.bitmask = nfs4_bitmask(server, ilabel);
3012 	if (ilabel)
3013 		arg.bitmask = nfs4_bitmask(server, olabel);
3014 
3015 	do {
3016 		err = _nfs4_do_setattr(inode, &arg, &res, cred, ctx);
3017 		switch (err) {
3018 		case -NFS4ERR_OPENMODE:
3019 			if (!(sattr->ia_valid & ATTR_SIZE)) {
3020 				pr_warn_once("NFSv4: server %s is incorrectly "
3021 						"applying open mode checks to "
3022 						"a SETATTR that is not "
3023 						"changing file size.\n",
3024 						server->nfs_client->cl_hostname);
3025 			}
3026 			if (state && !(state->state & FMODE_WRITE)) {
3027 				err = -EBADF;
3028 				if (sattr->ia_valid & ATTR_OPEN)
3029 					err = -EACCES;
3030 				goto out;
3031 			}
3032 		}
3033 		err = nfs4_handle_exception(server, err, &exception);
3034 	} while (exception.retry);
3035 out:
3036 	return err;
3037 }
3038 
3039 static bool
3040 nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3041 {
3042 	if (inode == NULL || !nfs_have_layout(inode))
3043 		return false;
3044 
3045 	return pnfs_wait_on_layoutreturn(inode, task);
3046 }
3047 
3048 struct nfs4_closedata {
3049 	struct inode *inode;
3050 	struct nfs4_state *state;
3051 	struct nfs_closeargs arg;
3052 	struct nfs_closeres res;
3053 	struct {
3054 		struct nfs4_layoutreturn_args arg;
3055 		struct nfs4_layoutreturn_res res;
3056 		struct nfs4_xdr_opaque_data ld_private;
3057 		u32 roc_barrier;
3058 		bool roc;
3059 	} lr;
3060 	struct nfs_fattr fattr;
3061 	unsigned long timestamp;
3062 };
3063 
3064 static void nfs4_free_closedata(void *data)
3065 {
3066 	struct nfs4_closedata *calldata = data;
3067 	struct nfs4_state_owner *sp = calldata->state->owner;
3068 	struct super_block *sb = calldata->state->inode->i_sb;
3069 
3070 	if (calldata->lr.roc)
3071 		pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res,
3072 				calldata->res.lr_ret);
3073 	nfs4_put_open_state(calldata->state);
3074 	nfs_free_seqid(calldata->arg.seqid);
3075 	nfs4_put_state_owner(sp);
3076 	nfs_sb_deactive(sb);
3077 	kfree(calldata);
3078 }
3079 
3080 static void nfs4_close_done(struct rpc_task *task, void *data)
3081 {
3082 	struct nfs4_closedata *calldata = data;
3083 	struct nfs4_state *state = calldata->state;
3084 	struct nfs_server *server = NFS_SERVER(calldata->inode);
3085 	nfs4_stateid *res_stateid = NULL;
3086 
3087 	dprintk("%s: begin!\n", __func__);
3088 	if (!nfs4_sequence_done(task, &calldata->res.seq_res))
3089 		return;
3090 	trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
3091 
3092 	/* Handle Layoutreturn errors */
3093 	if (calldata->arg.lr_args && task->tk_status != 0) {
3094 		switch (calldata->res.lr_ret) {
3095 		default:
3096 			calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3097 			break;
3098 		case 0:
3099 			calldata->arg.lr_args = NULL;
3100 			calldata->res.lr_res = NULL;
3101 			break;
3102 		case -NFS4ERR_ADMIN_REVOKED:
3103 		case -NFS4ERR_DELEG_REVOKED:
3104 		case -NFS4ERR_EXPIRED:
3105 		case -NFS4ERR_BAD_STATEID:
3106 		case -NFS4ERR_OLD_STATEID:
3107 		case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
3108 		case -NFS4ERR_WRONG_CRED:
3109 			calldata->arg.lr_args = NULL;
3110 			calldata->res.lr_res = NULL;
3111 			calldata->res.lr_ret = 0;
3112 			rpc_restart_call_prepare(task);
3113 			return;
3114 		}
3115 	}
3116 
3117         /* hmm. we are done with the inode, and in the process of freeing
3118 	 * the state_owner. we keep this around to process errors
3119 	 */
3120 	switch (task->tk_status) {
3121 		case 0:
3122 			res_stateid = &calldata->res.stateid;
3123 			renew_lease(server, calldata->timestamp);
3124 			break;
3125 		case -NFS4ERR_ACCESS:
3126 			if (calldata->arg.bitmask != NULL) {
3127 				calldata->arg.bitmask = NULL;
3128 				calldata->res.fattr = NULL;
3129 				task->tk_status = 0;
3130 				rpc_restart_call_prepare(task);
3131 				goto out_release;
3132 
3133 			}
3134 			break;
3135 		case -NFS4ERR_ADMIN_REVOKED:
3136 		case -NFS4ERR_STALE_STATEID:
3137 		case -NFS4ERR_EXPIRED:
3138 			nfs4_free_revoked_stateid(server,
3139 					&calldata->arg.stateid,
3140 					task->tk_msg.rpc_cred);
3141 		case -NFS4ERR_OLD_STATEID:
3142 		case -NFS4ERR_BAD_STATEID:
3143 			if (!nfs4_stateid_match(&calldata->arg.stateid,
3144 						&state->open_stateid)) {
3145 				rpc_restart_call_prepare(task);
3146 				goto out_release;
3147 			}
3148 			if (calldata->arg.fmode == 0)
3149 				break;
3150 		default:
3151 			if (nfs4_async_handle_error(task, server, state, NULL) == -EAGAIN) {
3152 				rpc_restart_call_prepare(task);
3153 				goto out_release;
3154 			}
3155 	}
3156 	nfs_clear_open_stateid(state, &calldata->arg.stateid,
3157 			res_stateid, calldata->arg.fmode);
3158 out_release:
3159 	nfs_release_seqid(calldata->arg.seqid);
3160 	nfs_refresh_inode(calldata->inode, &calldata->fattr);
3161 	dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
3162 }
3163 
3164 static void nfs4_close_prepare(struct rpc_task *task, void *data)
3165 {
3166 	struct nfs4_closedata *calldata = data;
3167 	struct nfs4_state *state = calldata->state;
3168 	struct inode *inode = calldata->inode;
3169 	bool is_rdonly, is_wronly, is_rdwr;
3170 	int call_close = 0;
3171 
3172 	dprintk("%s: begin!\n", __func__);
3173 	if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3174 		goto out_wait;
3175 
3176 	task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
3177 	spin_lock(&state->owner->so_lock);
3178 	is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
3179 	is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
3180 	is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
3181 	nfs4_stateid_copy(&calldata->arg.stateid, &state->open_stateid);
3182 	/* Calculate the change in open mode */
3183 	calldata->arg.fmode = 0;
3184 	if (state->n_rdwr == 0) {
3185 		if (state->n_rdonly == 0)
3186 			call_close |= is_rdonly;
3187 		else if (is_rdonly)
3188 			calldata->arg.fmode |= FMODE_READ;
3189 		if (state->n_wronly == 0)
3190 			call_close |= is_wronly;
3191 		else if (is_wronly)
3192 			calldata->arg.fmode |= FMODE_WRITE;
3193 		if (calldata->arg.fmode != (FMODE_READ|FMODE_WRITE))
3194 			call_close |= is_rdwr;
3195 	} else if (is_rdwr)
3196 		calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;
3197 
3198 	if (!nfs4_valid_open_stateid(state) ||
3199 	    test_bit(NFS_OPEN_STATE, &state->flags) == 0)
3200 		call_close = 0;
3201 	spin_unlock(&state->owner->so_lock);
3202 
3203 	if (!call_close) {
3204 		/* Note: exit _without_ calling nfs4_close_done */
3205 		goto out_no_action;
3206 	}
3207 
3208 	if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
3209 		nfs_release_seqid(calldata->arg.seqid);
3210 		goto out_wait;
3211 	}
3212 
3213 	if (calldata->arg.fmode == 0)
3214 		task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3215 
3216 	if (calldata->arg.fmode == 0 || calldata->arg.fmode == FMODE_READ) {
3217 		/* Close-to-open cache consistency revalidation */
3218 		if (!nfs4_have_delegation(inode, FMODE_READ))
3219 			calldata->arg.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
3220 		else
3221 			calldata->arg.bitmask = NULL;
3222 	}
3223 
3224 	calldata->arg.share_access =
3225 		nfs4_map_atomic_open_share(NFS_SERVER(inode),
3226 				calldata->arg.fmode, 0);
3227 
3228 	if (calldata->res.fattr == NULL)
3229 		calldata->arg.bitmask = NULL;
3230 	else if (calldata->arg.bitmask == NULL)
3231 		calldata->res.fattr = NULL;
3232 	calldata->timestamp = jiffies;
3233 	if (nfs4_setup_sequence(NFS_SERVER(inode),
3234 				&calldata->arg.seq_args,
3235 				&calldata->res.seq_res,
3236 				task) != 0)
3237 		nfs_release_seqid(calldata->arg.seqid);
3238 	dprintk("%s: done!\n", __func__);
3239 	return;
3240 out_no_action:
3241 	task->tk_action = NULL;
3242 out_wait:
3243 	nfs4_sequence_done(task, &calldata->res.seq_res);
3244 }
3245 
3246 static const struct rpc_call_ops nfs4_close_ops = {
3247 	.rpc_call_prepare = nfs4_close_prepare,
3248 	.rpc_call_done = nfs4_close_done,
3249 	.rpc_release = nfs4_free_closedata,
3250 };
3251 
3252 /*
3253  * It is possible for data to be read/written from a mem-mapped file
3254  * after the sys_close call (which hits the vfs layer as a flush).
3255  * This means that we can't safely call nfsv4 close on a file until
3256  * the inode is cleared. This in turn means that we are not good
3257  * NFSv4 citizens - we do not indicate to the server to update the file's
3258  * share state even when we are done with one of the three share
3259  * stateid's in the inode.
3260  *
3261  * NOTE: Caller must be holding the sp->so_owner semaphore!
3262  */
3263 int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
3264 {
3265 	struct nfs_server *server = NFS_SERVER(state->inode);
3266 	struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
3267 	struct nfs4_closedata *calldata;
3268 	struct nfs4_state_owner *sp = state->owner;
3269 	struct rpc_task *task;
3270 	struct rpc_message msg = {
3271 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
3272 		.rpc_cred = state->owner->so_cred,
3273 	};
3274 	struct rpc_task_setup task_setup_data = {
3275 		.rpc_client = server->client,
3276 		.rpc_message = &msg,
3277 		.callback_ops = &nfs4_close_ops,
3278 		.workqueue = nfsiod_workqueue,
3279 		.flags = RPC_TASK_ASYNC,
3280 	};
3281 	int status = -ENOMEM;
3282 
3283 	nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_CLEANUP,
3284 		&task_setup_data.rpc_client, &msg);
3285 
3286 	calldata = kzalloc(sizeof(*calldata), gfp_mask);
3287 	if (calldata == NULL)
3288 		goto out;
3289 	nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
3290 	calldata->inode = state->inode;
3291 	calldata->state = state;
3292 	calldata->arg.fh = NFS_FH(state->inode);
3293 	/* Serialization for the sequence id */
3294 	alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
3295 	calldata->arg.seqid = alloc_seqid(&state->owner->so_seqid, gfp_mask);
3296 	if (IS_ERR(calldata->arg.seqid))
3297 		goto out_free_calldata;
3298 	nfs_fattr_init(&calldata->fattr);
3299 	calldata->arg.fmode = 0;
3300 	calldata->lr.arg.ld_private = &calldata->lr.ld_private;
3301 	calldata->res.fattr = &calldata->fattr;
3302 	calldata->res.seqid = calldata->arg.seqid;
3303 	calldata->res.server = server;
3304 	calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3305 	calldata->lr.roc = pnfs_roc(state->inode,
3306 			&calldata->lr.arg, &calldata->lr.res, msg.rpc_cred);
3307 	if (calldata->lr.roc) {
3308 		calldata->arg.lr_args = &calldata->lr.arg;
3309 		calldata->res.lr_res = &calldata->lr.res;
3310 	}
3311 	nfs_sb_active(calldata->inode->i_sb);
3312 
3313 	msg.rpc_argp = &calldata->arg;
3314 	msg.rpc_resp = &calldata->res;
3315 	task_setup_data.callback_data = calldata;
3316 	task = rpc_run_task(&task_setup_data);
3317 	if (IS_ERR(task))
3318 		return PTR_ERR(task);
3319 	status = 0;
3320 	if (wait)
3321 		status = rpc_wait_for_completion_task(task);
3322 	rpc_put_task(task);
3323 	return status;
3324 out_free_calldata:
3325 	kfree(calldata);
3326 out:
3327 	nfs4_put_open_state(state);
3328 	nfs4_put_state_owner(sp);
3329 	return status;
3330 }
3331 
3332 static struct inode *
3333 nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx,
3334 		int open_flags, struct iattr *attr, int *opened)
3335 {
3336 	struct nfs4_state *state;
3337 	struct nfs4_label l = {0, 0, 0, NULL}, *label = NULL;
3338 
3339 	label = nfs4_label_init_security(dir, ctx->dentry, attr, &l);
3340 
3341 	/* Protect against concurrent sillydeletes */
3342 	state = nfs4_do_open(dir, ctx, open_flags, attr, label, opened);
3343 
3344 	nfs4_label_release_security(label);
3345 
3346 	if (IS_ERR(state))
3347 		return ERR_CAST(state);
3348 	return state->inode;
3349 }
3350 
3351 static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
3352 {
3353 	if (ctx->state == NULL)
3354 		return;
3355 	if (is_sync)
3356 		nfs4_close_sync(ctx->state, ctx->mode);
3357 	else
3358 		nfs4_close_state(ctx->state, ctx->mode);
3359 }
3360 
3361 #define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)
3362 #define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL)
3363 #define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL)
3364 
3365 static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3366 {
3367 	u32 bitmask[3] = {}, minorversion = server->nfs_client->cl_minorversion;
3368 	struct nfs4_server_caps_arg args = {
3369 		.fhandle = fhandle,
3370 		.bitmask = bitmask,
3371 	};
3372 	struct nfs4_server_caps_res res = {};
3373 	struct rpc_message msg = {
3374 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
3375 		.rpc_argp = &args,
3376 		.rpc_resp = &res,
3377 	};
3378 	int status;
3379 
3380 	bitmask[0] = FATTR4_WORD0_SUPPORTED_ATTRS |
3381 		     FATTR4_WORD0_FH_EXPIRE_TYPE |
3382 		     FATTR4_WORD0_LINK_SUPPORT |
3383 		     FATTR4_WORD0_SYMLINK_SUPPORT |
3384 		     FATTR4_WORD0_ACLSUPPORT;
3385 	if (minorversion)
3386 		bitmask[2] = FATTR4_WORD2_SUPPATTR_EXCLCREAT;
3387 
3388 	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3389 	if (status == 0) {
3390 		/* Sanity check the server answers */
3391 		switch (minorversion) {
3392 		case 0:
3393 			res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3394 			res.attr_bitmask[2] = 0;
3395 			break;
3396 		case 1:
3397 			res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3398 			break;
3399 		case 2:
3400 			res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3401 		}
3402 		memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3403 		server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
3404 				NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
3405 				NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
3406 				NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
3407 				NFS_CAP_CTIME|NFS_CAP_MTIME|
3408 				NFS_CAP_SECURITY_LABEL);
3409 		if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3410 				res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3411 			server->caps |= NFS_CAP_ACLS;
3412 		if (res.has_links != 0)
3413 			server->caps |= NFS_CAP_HARDLINKS;
3414 		if (res.has_symlinks != 0)
3415 			server->caps |= NFS_CAP_SYMLINKS;
3416 		if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
3417 			server->caps |= NFS_CAP_FILEID;
3418 		if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
3419 			server->caps |= NFS_CAP_MODE;
3420 		if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
3421 			server->caps |= NFS_CAP_NLINK;
3422 		if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
3423 			server->caps |= NFS_CAP_OWNER;
3424 		if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
3425 			server->caps |= NFS_CAP_OWNER_GROUP;
3426 		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
3427 			server->caps |= NFS_CAP_ATIME;
3428 		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
3429 			server->caps |= NFS_CAP_CTIME;
3430 		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
3431 			server->caps |= NFS_CAP_MTIME;
3432 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
3433 		if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3434 			server->caps |= NFS_CAP_SECURITY_LABEL;
3435 #endif
3436 		memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3437 				sizeof(server->attr_bitmask));
3438 		server->attr_bitmask_nl[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
3439 
3440 		memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3441 		server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
3442 		server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
3443 		server->cache_consistency_bitmask[2] = 0;
3444 		memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3445 			sizeof(server->exclcreat_bitmask));
3446 		server->acl_bitmask = res.acl_bitmask;
3447 		server->fh_expire_type = res.fh_expire_type;
3448 	}
3449 
3450 	return status;
3451 }
3452 
3453 int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
3454 {
3455 	struct nfs4_exception exception = { };
3456 	int err;
3457 	do {
3458 		err = nfs4_handle_exception(server,
3459 				_nfs4_server_capabilities(server, fhandle),
3460 				&exception);
3461 	} while (exception.retry);
3462 	return err;
3463 }
3464 
3465 static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3466 		struct nfs_fsinfo *info)
3467 {
3468 	u32 bitmask[3];
3469 	struct nfs4_lookup_root_arg args = {
3470 		.bitmask = bitmask,
3471 	};
3472 	struct nfs4_lookup_res res = {
3473 		.server = server,
3474 		.fattr = info->fattr,
3475 		.fh = fhandle,
3476 	};
3477 	struct rpc_message msg = {
3478 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
3479 		.rpc_argp = &args,
3480 		.rpc_resp = &res,
3481 	};
3482 
3483 	bitmask[0] = nfs4_fattr_bitmap[0];
3484 	bitmask[1] = nfs4_fattr_bitmap[1];
3485 	/*
3486 	 * Process the label in the upcoming getfattr
3487 	 */
3488 	bitmask[2] = nfs4_fattr_bitmap[2] & ~FATTR4_WORD2_SECURITY_LABEL;
3489 
3490 	nfs_fattr_init(info->fattr);
3491 	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3492 }
3493 
3494 static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
3495 		struct nfs_fsinfo *info)
3496 {
3497 	struct nfs4_exception exception = { };
3498 	int err;
3499 	do {
3500 		err = _nfs4_lookup_root(server, fhandle, info);
3501 		trace_nfs4_lookup_root(server, fhandle, info->fattr, err);
3502 		switch (err) {
3503 		case 0:
3504 		case -NFS4ERR_WRONGSEC:
3505 			goto out;
3506 		default:
3507 			err = nfs4_handle_exception(server, err, &exception);
3508 		}
3509 	} while (exception.retry);
3510 out:
3511 	return err;
3512 }
3513 
3514 static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3515 				struct nfs_fsinfo *info, rpc_authflavor_t flavor)
3516 {
3517 	struct rpc_auth_create_args auth_args = {
3518 		.pseudoflavor = flavor,
3519 	};
3520 	struct rpc_auth *auth;
3521 	int ret;
3522 
3523 	auth = rpcauth_create(&auth_args, server->client);
3524 	if (IS_ERR(auth)) {
3525 		ret = -EACCES;
3526 		goto out;
3527 	}
3528 	ret = nfs4_lookup_root(server, fhandle, info);
3529 out:
3530 	return ret;
3531 }
3532 
3533 /*
3534  * Retry pseudoroot lookup with various security flavors.  We do this when:
3535  *
3536  *   NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
3537  *   NFSv4.1: the server does not support the SECINFO_NO_NAME operation
3538  *
3539  * Returns zero on success, or a negative NFS4ERR value, or a
3540  * negative errno value.
3541  */
3542 static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
3543 			      struct nfs_fsinfo *info)
3544 {
3545 	/* Per 3530bis 15.33.5 */
3546 	static const rpc_authflavor_t flav_array[] = {
3547 		RPC_AUTH_GSS_KRB5P,
3548 		RPC_AUTH_GSS_KRB5I,
3549 		RPC_AUTH_GSS_KRB5,
3550 		RPC_AUTH_UNIX,			/* courtesy */
3551 		RPC_AUTH_NULL,
3552 	};
3553 	int status = -EPERM;
3554 	size_t i;
3555 
3556 	if (server->auth_info.flavor_len > 0) {
3557 		/* try each flavor specified by user */
3558 		for (i = 0; i < server->auth_info.flavor_len; i++) {
3559 			status = nfs4_lookup_root_sec(server, fhandle, info,
3560 						server->auth_info.flavors[i]);
3561 			if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3562 				continue;
3563 			break;
3564 		}
3565 	} else {
3566 		/* no flavors specified by user, try default list */
3567 		for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
3568 			status = nfs4_lookup_root_sec(server, fhandle, info,
3569 						      flav_array[i]);
3570 			if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
3571 				continue;
3572 			break;
3573 		}
3574 	}
3575 
3576 	/*
3577 	 * -EACCESS could mean that the user doesn't have correct permissions
3578 	 * to access the mount.  It could also mean that we tried to mount
3579 	 * with a gss auth flavor, but rpc.gssd isn't running.  Either way,
3580 	 * existing mount programs don't handle -EACCES very well so it should
3581 	 * be mapped to -EPERM instead.
3582 	 */
3583 	if (status == -EACCES)
3584 		status = -EPERM;
3585 	return status;
3586 }
3587 
3588 /**
3589  * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
3590  * @server: initialized nfs_server handle
3591  * @fhandle: we fill in the pseudo-fs root file handle
3592  * @info: we fill in an FSINFO struct
3593  * @auth_probe: probe the auth flavours
3594  *
3595  * Returns zero on success, or a negative errno.
3596  */
3597 int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
3598 			 struct nfs_fsinfo *info,
3599 			 bool auth_probe)
3600 {
3601 	int status = 0;
3602 
3603 	if (!auth_probe)
3604 		status = nfs4_lookup_root(server, fhandle, info);
3605 
3606 	if (auth_probe || status == NFS4ERR_WRONGSEC)
3607 		status = server->nfs_client->cl_mvops->find_root_sec(server,
3608 				fhandle, info);
3609 
3610 	if (status == 0)
3611 		status = nfs4_server_capabilities(server, fhandle);
3612 	if (status == 0)
3613 		status = nfs4_do_fsinfo(server, fhandle, info);
3614 
3615 	return nfs4_map_errors(status);
3616 }
3617 
3618 static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
3619 			      struct nfs_fsinfo *info)
3620 {
3621 	int error;
3622 	struct nfs_fattr *fattr = info->fattr;
3623 	struct nfs4_label *label = NULL;
3624 
3625 	error = nfs4_server_capabilities(server, mntfh);
3626 	if (error < 0) {
3627 		dprintk("nfs4_get_root: getcaps error = %d\n", -error);
3628 		return error;
3629 	}
3630 
3631 	label = nfs4_label_alloc(server, GFP_KERNEL);
3632 	if (IS_ERR(label))
3633 		return PTR_ERR(label);
3634 
3635 	error = nfs4_proc_getattr(server, mntfh, fattr, label);
3636 	if (error < 0) {
3637 		dprintk("nfs4_get_root: getattr error = %d\n", -error);
3638 		goto err_free_label;
3639 	}
3640 
3641 	if (fattr->valid & NFS_ATTR_FATTR_FSID &&
3642 	    !nfs_fsid_equal(&server->fsid, &fattr->fsid))
3643 		memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));
3644 
3645 err_free_label:
3646 	nfs4_label_free(label);
3647 
3648 	return error;
3649 }
3650 
3651 /*
3652  * Get locations and (maybe) other attributes of a referral.
3653  * Note that we'll actually follow the referral later when
3654  * we detect fsid mismatch in inode revalidation
3655  */
3656 static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
3657 			     const struct qstr *name, struct nfs_fattr *fattr,
3658 			     struct nfs_fh *fhandle)
3659 {
3660 	int status = -ENOMEM;
3661 	struct page *page = NULL;
3662 	struct nfs4_fs_locations *locations = NULL;
3663 
3664 	page = alloc_page(GFP_KERNEL);
3665 	if (page == NULL)
3666 		goto out;
3667 	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
3668 	if (locations == NULL)
3669 		goto out;
3670 
3671 	status = nfs4_proc_fs_locations(client, dir, name, locations, page);
3672 	if (status != 0)
3673 		goto out;
3674 
3675 	/*
3676 	 * If the fsid didn't change, this is a migration event, not a
3677 	 * referral.  Cause us to drop into the exception handler, which
3678 	 * will kick off migration recovery.
3679 	 */
3680 	if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
3681 		dprintk("%s: server did not return a different fsid for"
3682 			" a referral at %s\n", __func__, name->name);
3683 		status = -NFS4ERR_MOVED;
3684 		goto out;
3685 	}
3686 	/* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
3687 	nfs_fixup_referral_attributes(&locations->fattr);
3688 
3689 	/* replace the lookup nfs_fattr with the locations nfs_fattr */
3690 	memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
3691 	memset(fhandle, 0, sizeof(struct nfs_fh));
3692 out:
3693 	if (page)
3694 		__free_page(page);
3695 	kfree(locations);
3696 	return status;
3697 }
3698 
3699 static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3700 				struct nfs_fattr *fattr, struct nfs4_label *label)
3701 {
3702 	struct nfs4_getattr_arg args = {
3703 		.fh = fhandle,
3704 		.bitmask = server->attr_bitmask,
3705 	};
3706 	struct nfs4_getattr_res res = {
3707 		.fattr = fattr,
3708 		.label = label,
3709 		.server = server,
3710 	};
3711 	struct rpc_message msg = {
3712 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
3713 		.rpc_argp = &args,
3714 		.rpc_resp = &res,
3715 	};
3716 
3717 	args.bitmask = nfs4_bitmask(server, label);
3718 
3719 	nfs_fattr_init(fattr);
3720 	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3721 }
3722 
3723 static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
3724 				struct nfs_fattr *fattr, struct nfs4_label *label)
3725 {
3726 	struct nfs4_exception exception = { };
3727 	int err;
3728 	do {
3729 		err = _nfs4_proc_getattr(server, fhandle, fattr, label);
3730 		trace_nfs4_getattr(server, fhandle, fattr, err);
3731 		err = nfs4_handle_exception(server, err,
3732 				&exception);
3733 	} while (exception.retry);
3734 	return err;
3735 }
3736 
3737 /*
3738  * The file is not closed if it is opened due to the a request to change
3739  * the size of the file. The open call will not be needed once the
3740  * VFS layer lookup-intents are implemented.
3741  *
3742  * Close is called when the inode is destroyed.
3743  * If we haven't opened the file for O_WRONLY, we
3744  * need to in the size_change case to obtain a stateid.
3745  *
3746  * Got race?
3747  * Because OPEN is always done by name in nfsv4, it is
3748  * possible that we opened a different file by the same
3749  * name.  We can recognize this race condition, but we
3750  * can't do anything about it besides returning an error.
3751  *
3752  * This will be fixed with VFS changes (lookup-intent).
3753  */
3754 static int
3755 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
3756 		  struct iattr *sattr)
3757 {
3758 	struct inode *inode = d_inode(dentry);
3759 	struct rpc_cred *cred = NULL;
3760 	struct nfs_open_context *ctx = NULL;
3761 	struct nfs4_label *label = NULL;
3762 	int status;
3763 
3764 	if (pnfs_ld_layoutret_on_setattr(inode) &&
3765 	    sattr->ia_valid & ATTR_SIZE &&
3766 	    sattr->ia_size < i_size_read(inode))
3767 		pnfs_commit_and_return_layout(inode);
3768 
3769 	nfs_fattr_init(fattr);
3770 
3771 	/* Deal with open(O_TRUNC) */
3772 	if (sattr->ia_valid & ATTR_OPEN)
3773 		sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME);
3774 
3775 	/* Optimization: if the end result is no change, don't RPC */
3776 	if ((sattr->ia_valid & ~(ATTR_FILE|ATTR_OPEN)) == 0)
3777 		return 0;
3778 
3779 	/* Search for an existing open(O_WRITE) file */
3780 	if (sattr->ia_valid & ATTR_FILE) {
3781 
3782 		ctx = nfs_file_open_context(sattr->ia_file);
3783 		if (ctx)
3784 			cred = ctx->cred;
3785 	}
3786 
3787 	label = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
3788 	if (IS_ERR(label))
3789 		return PTR_ERR(label);
3790 
3791 	status = nfs4_do_setattr(inode, cred, fattr, sattr, ctx, NULL, label);
3792 	if (status == 0) {
3793 		nfs_setattr_update_inode(inode, sattr, fattr);
3794 		nfs_setsecurity(inode, fattr, label);
3795 	}
3796 	nfs4_label_free(label);
3797 	return status;
3798 }
3799 
3800 static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
3801 		const struct qstr *name, struct nfs_fh *fhandle,
3802 		struct nfs_fattr *fattr, struct nfs4_label *label)
3803 {
3804 	struct nfs_server *server = NFS_SERVER(dir);
3805 	int		       status;
3806 	struct nfs4_lookup_arg args = {
3807 		.bitmask = server->attr_bitmask,
3808 		.dir_fh = NFS_FH(dir),
3809 		.name = name,
3810 	};
3811 	struct nfs4_lookup_res res = {
3812 		.server = server,
3813 		.fattr = fattr,
3814 		.label = label,
3815 		.fh = fhandle,
3816 	};
3817 	struct rpc_message msg = {
3818 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
3819 		.rpc_argp = &args,
3820 		.rpc_resp = &res,
3821 	};
3822 
3823 	args.bitmask = nfs4_bitmask(server, label);
3824 
3825 	nfs_fattr_init(fattr);
3826 
3827 	dprintk("NFS call  lookup %s\n", name->name);
3828 	status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
3829 	dprintk("NFS reply lookup: %d\n", status);
3830 	return status;
3831 }
3832 
3833 static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
3834 {
3835 	fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
3836 		NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
3837 	fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
3838 	fattr->nlink = 2;
3839 }
3840 
3841 static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
3842 				   const struct qstr *name, struct nfs_fh *fhandle,
3843 				   struct nfs_fattr *fattr, struct nfs4_label *label)
3844 {
3845 	struct nfs4_exception exception = { };
3846 	struct rpc_clnt *client = *clnt;
3847 	int err;
3848 	do {
3849 		err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr, label);
3850 		trace_nfs4_lookup(dir, name, err);
3851 		switch (err) {
3852 		case -NFS4ERR_BADNAME:
3853 			err = -ENOENT;
3854 			goto out;
3855 		case -NFS4ERR_MOVED:
3856 			err = nfs4_get_referral(client, dir, name, fattr, fhandle);
3857 			if (err == -NFS4ERR_MOVED)
3858 				err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3859 			goto out;
3860 		case -NFS4ERR_WRONGSEC:
3861 			err = -EPERM;
3862 			if (client != *clnt)
3863 				goto out;
3864 			client = nfs4_negotiate_security(client, dir, name);
3865 			if (IS_ERR(client))
3866 				return PTR_ERR(client);
3867 
3868 			exception.retry = 1;
3869 			break;
3870 		default:
3871 			err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
3872 		}
3873 	} while (exception.retry);
3874 
3875 out:
3876 	if (err == 0)
3877 		*clnt = client;
3878 	else if (client != *clnt)
3879 		rpc_shutdown_client(client);
3880 
3881 	return err;
3882 }
3883 
3884 static int nfs4_proc_lookup(struct inode *dir, const struct qstr *name,
3885 			    struct nfs_fh *fhandle, struct nfs_fattr *fattr,
3886 			    struct nfs4_label *label)
3887 {
3888 	int status;
3889 	struct rpc_clnt *client = NFS_CLIENT(dir);
3890 
3891 	status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, label);
3892 	if (client != NFS_CLIENT(dir)) {
3893 		rpc_shutdown_client(client);
3894 		nfs_fixup_secinfo_attributes(fattr);
3895 	}
3896 	return status;
3897 }
3898 
3899 struct rpc_clnt *
3900 nfs4_proc_lookup_mountpoint(struct inode *dir, const struct qstr *name,
3901 			    struct nfs_fh *fhandle, struct nfs_fattr *fattr)
3902 {
3903 	struct rpc_clnt *client = NFS_CLIENT(dir);
3904 	int status;
3905 
3906 	status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr, NULL);
3907 	if (status < 0)
3908 		return ERR_PTR(status);
3909 	return (client == NFS_CLIENT(dir)) ? rpc_clone_client(client) : client;
3910 }
3911 
3912 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3913 {
3914 	struct nfs_server *server = NFS_SERVER(inode);
3915 	struct nfs4_accessargs args = {
3916 		.fh = NFS_FH(inode),
3917 		.bitmask = server->cache_consistency_bitmask,
3918 	};
3919 	struct nfs4_accessres res = {
3920 		.server = server,
3921 	};
3922 	struct rpc_message msg = {
3923 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
3924 		.rpc_argp = &args,
3925 		.rpc_resp = &res,
3926 		.rpc_cred = entry->cred,
3927 	};
3928 	int mode = entry->mask;
3929 	int status = 0;
3930 
3931 	/*
3932 	 * Determine which access bits we want to ask for...
3933 	 */
3934 	if (mode & MAY_READ)
3935 		args.access |= NFS4_ACCESS_READ;
3936 	if (S_ISDIR(inode->i_mode)) {
3937 		if (mode & MAY_WRITE)
3938 			args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
3939 		if (mode & MAY_EXEC)
3940 			args.access |= NFS4_ACCESS_LOOKUP;
3941 	} else {
3942 		if (mode & MAY_WRITE)
3943 			args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
3944 		if (mode & MAY_EXEC)
3945 			args.access |= NFS4_ACCESS_EXECUTE;
3946 	}
3947 
3948 	res.fattr = nfs_alloc_fattr();
3949 	if (res.fattr == NULL)
3950 		return -ENOMEM;
3951 
3952 	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3953 	if (!status) {
3954 		nfs_access_set_mask(entry, res.access);
3955 		nfs_refresh_inode(inode, res.fattr);
3956 	}
3957 	nfs_free_fattr(res.fattr);
3958 	return status;
3959 }
3960 
3961 static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
3962 {
3963 	struct nfs4_exception exception = { };
3964 	int err;
3965 	do {
3966 		err = _nfs4_proc_access(inode, entry);
3967 		trace_nfs4_access(inode, err);
3968 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
3969 				&exception);
3970 	} while (exception.retry);
3971 	return err;
3972 }
3973 
3974 /*
3975  * TODO: For the time being, we don't try to get any attributes
3976  * along with any of the zero-copy operations READ, READDIR,
3977  * READLINK, WRITE.
3978  *
3979  * In the case of the first three, we want to put the GETATTR
3980  * after the read-type operation -- this is because it is hard
3981  * to predict the length of a GETATTR response in v4, and thus
3982  * align the READ data correctly.  This means that the GETATTR
3983  * may end up partially falling into the page cache, and we should
3984  * shift it into the 'tail' of the xdr_buf before processing.
3985  * To do this efficiently, we need to know the total length
3986  * of data received, which doesn't seem to be available outside
3987  * of the RPC layer.
3988  *
3989  * In the case of WRITE, we also want to put the GETATTR after
3990  * the operation -- in this case because we want to make sure
3991  * we get the post-operation mtime and size.
3992  *
3993  * Both of these changes to the XDR layer would in fact be quite
3994  * minor, but I decided to leave them for a subsequent patch.
3995  */
3996 static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
3997 		unsigned int pgbase, unsigned int pglen)
3998 {
3999 	struct nfs4_readlink args = {
4000 		.fh       = NFS_FH(inode),
4001 		.pgbase	  = pgbase,
4002 		.pglen    = pglen,
4003 		.pages    = &page,
4004 	};
4005 	struct nfs4_readlink_res res;
4006 	struct rpc_message msg = {
4007 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
4008 		.rpc_argp = &args,
4009 		.rpc_resp = &res,
4010 	};
4011 
4012 	return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
4013 }
4014 
4015 static int nfs4_proc_readlink(struct inode *inode, struct page *page,
4016 		unsigned int pgbase, unsigned int pglen)
4017 {
4018 	struct nfs4_exception exception = { };
4019 	int err;
4020 	do {
4021 		err = _nfs4_proc_readlink(inode, page, pgbase, pglen);
4022 		trace_nfs4_readlink(inode, err);
4023 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
4024 				&exception);
4025 	} while (exception.retry);
4026 	return err;
4027 }
4028 
4029 /*
4030  * This is just for mknod.  open(O_CREAT) will always do ->open_context().
4031  */
4032 static int
4033 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
4034 		 int flags)
4035 {
4036 	struct nfs_server *server = NFS_SERVER(dir);
4037 	struct nfs4_label l, *ilabel = NULL;
4038 	struct nfs_open_context *ctx;
4039 	struct nfs4_state *state;
4040 	int status = 0;
4041 
4042 	ctx = alloc_nfs_open_context(dentry, FMODE_READ, NULL);
4043 	if (IS_ERR(ctx))
4044 		return PTR_ERR(ctx);
4045 
4046 	ilabel = nfs4_label_init_security(dir, dentry, sattr, &l);
4047 
4048 	if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4049 		sattr->ia_mode &= ~current_umask();
4050 	state = nfs4_do_open(dir, ctx, flags, sattr, ilabel, NULL);
4051 	if (IS_ERR(state)) {
4052 		status = PTR_ERR(state);
4053 		goto out;
4054 	}
4055 out:
4056 	nfs4_label_release_security(ilabel);
4057 	put_nfs_open_context(ctx);
4058 	return status;
4059 }
4060 
4061 static int _nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4062 {
4063 	struct nfs_server *server = NFS_SERVER(dir);
4064 	struct nfs_removeargs args = {
4065 		.fh = NFS_FH(dir),
4066 		.name = *name,
4067 	};
4068 	struct nfs_removeres res = {
4069 		.server = server,
4070 	};
4071 	struct rpc_message msg = {
4072 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
4073 		.rpc_argp = &args,
4074 		.rpc_resp = &res,
4075 	};
4076 	int status;
4077 
4078 	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4079 	if (status == 0)
4080 		update_changeattr(dir, &res.cinfo);
4081 	return status;
4082 }
4083 
4084 static int nfs4_proc_remove(struct inode *dir, const struct qstr *name)
4085 {
4086 	struct nfs4_exception exception = { };
4087 	int err;
4088 	do {
4089 		err = _nfs4_proc_remove(dir, name);
4090 		trace_nfs4_remove(dir, name, err);
4091 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
4092 				&exception);
4093 	} while (exception.retry);
4094 	return err;
4095 }
4096 
4097 static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
4098 {
4099 	struct nfs_server *server = NFS_SERVER(dir);
4100 	struct nfs_removeargs *args = msg->rpc_argp;
4101 	struct nfs_removeres *res = msg->rpc_resp;
4102 
4103 	res->server = server;
4104 	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
4105 	nfs4_init_sequence(&args->seq_args, &res->seq_res, 1);
4106 
4107 	nfs_fattr_init(res->dir_attr);
4108 }
4109 
4110 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4111 {
4112 	nfs4_setup_sequence(NFS_SB(data->dentry->d_sb),
4113 			&data->args.seq_args,
4114 			&data->res.seq_res,
4115 			task);
4116 }
4117 
4118 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
4119 {
4120 	struct nfs_unlinkdata *data = task->tk_calldata;
4121 	struct nfs_removeres *res = &data->res;
4122 
4123 	if (!nfs4_sequence_done(task, &res->seq_res))
4124 		return 0;
4125 	if (nfs4_async_handle_error(task, res->server, NULL,
4126 				    &data->timeout) == -EAGAIN)
4127 		return 0;
4128 	update_changeattr(dir, &res->cinfo);
4129 	return 1;
4130 }
4131 
4132 static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
4133 {
4134 	struct nfs_server *server = NFS_SERVER(dir);
4135 	struct nfs_renameargs *arg = msg->rpc_argp;
4136 	struct nfs_renameres *res = msg->rpc_resp;
4137 
4138 	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
4139 	res->server = server;
4140 	nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1);
4141 }
4142 
4143 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4144 {
4145 	nfs4_setup_sequence(NFS_SERVER(data->old_dir),
4146 			&data->args.seq_args,
4147 			&data->res.seq_res,
4148 			task);
4149 }
4150 
4151 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4152 				 struct inode *new_dir)
4153 {
4154 	struct nfs_renamedata *data = task->tk_calldata;
4155 	struct nfs_renameres *res = &data->res;
4156 
4157 	if (!nfs4_sequence_done(task, &res->seq_res))
4158 		return 0;
4159 	if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4160 		return 0;
4161 
4162 	update_changeattr(old_dir, &res->old_cinfo);
4163 	update_changeattr(new_dir, &res->new_cinfo);
4164 	return 1;
4165 }
4166 
4167 static int _nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4168 {
4169 	struct nfs_server *server = NFS_SERVER(inode);
4170 	struct nfs4_link_arg arg = {
4171 		.fh     = NFS_FH(inode),
4172 		.dir_fh = NFS_FH(dir),
4173 		.name   = name,
4174 		.bitmask = server->attr_bitmask,
4175 	};
4176 	struct nfs4_link_res res = {
4177 		.server = server,
4178 		.label = NULL,
4179 	};
4180 	struct rpc_message msg = {
4181 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
4182 		.rpc_argp = &arg,
4183 		.rpc_resp = &res,
4184 	};
4185 	int status = -ENOMEM;
4186 
4187 	res.fattr = nfs_alloc_fattr();
4188 	if (res.fattr == NULL)
4189 		goto out;
4190 
4191 	res.label = nfs4_label_alloc(server, GFP_KERNEL);
4192 	if (IS_ERR(res.label)) {
4193 		status = PTR_ERR(res.label);
4194 		goto out;
4195 	}
4196 	arg.bitmask = nfs4_bitmask(server, res.label);
4197 
4198 	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4199 	if (!status) {
4200 		update_changeattr(dir, &res.cinfo);
4201 		status = nfs_post_op_update_inode(inode, res.fattr);
4202 		if (!status)
4203 			nfs_setsecurity(inode, res.fattr, res.label);
4204 	}
4205 
4206 
4207 	nfs4_label_free(res.label);
4208 
4209 out:
4210 	nfs_free_fattr(res.fattr);
4211 	return status;
4212 }
4213 
4214 static int nfs4_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
4215 {
4216 	struct nfs4_exception exception = { };
4217 	int err;
4218 	do {
4219 		err = nfs4_handle_exception(NFS_SERVER(inode),
4220 				_nfs4_proc_link(inode, dir, name),
4221 				&exception);
4222 	} while (exception.retry);
4223 	return err;
4224 }
4225 
4226 struct nfs4_createdata {
4227 	struct rpc_message msg;
4228 	struct nfs4_create_arg arg;
4229 	struct nfs4_create_res res;
4230 	struct nfs_fh fh;
4231 	struct nfs_fattr fattr;
4232 	struct nfs4_label *label;
4233 };
4234 
4235 static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
4236 		const struct qstr *name, struct iattr *sattr, u32 ftype)
4237 {
4238 	struct nfs4_createdata *data;
4239 
4240 	data = kzalloc(sizeof(*data), GFP_KERNEL);
4241 	if (data != NULL) {
4242 		struct nfs_server *server = NFS_SERVER(dir);
4243 
4244 		data->label = nfs4_label_alloc(server, GFP_KERNEL);
4245 		if (IS_ERR(data->label))
4246 			goto out_free;
4247 
4248 		data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
4249 		data->msg.rpc_argp = &data->arg;
4250 		data->msg.rpc_resp = &data->res;
4251 		data->arg.dir_fh = NFS_FH(dir);
4252 		data->arg.server = server;
4253 		data->arg.name = name;
4254 		data->arg.attrs = sattr;
4255 		data->arg.ftype = ftype;
4256 		data->arg.bitmask = nfs4_bitmask(server, data->label);
4257 		data->arg.umask = current_umask();
4258 		data->res.server = server;
4259 		data->res.fh = &data->fh;
4260 		data->res.fattr = &data->fattr;
4261 		data->res.label = data->label;
4262 		nfs_fattr_init(data->res.fattr);
4263 	}
4264 	return data;
4265 out_free:
4266 	kfree(data);
4267 	return NULL;
4268 }
4269 
4270 static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
4271 {
4272 	int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
4273 				    &data->arg.seq_args, &data->res.seq_res, 1);
4274 	if (status == 0) {
4275 		update_changeattr(dir, &data->res.dir_cinfo);
4276 		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, data->res.label);
4277 	}
4278 	return status;
4279 }
4280 
4281 static void nfs4_free_createdata(struct nfs4_createdata *data)
4282 {
4283 	nfs4_label_free(data->label);
4284 	kfree(data);
4285 }
4286 
4287 static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4288 		struct page *page, unsigned int len, struct iattr *sattr,
4289 		struct nfs4_label *label)
4290 {
4291 	struct nfs4_createdata *data;
4292 	int status = -ENAMETOOLONG;
4293 
4294 	if (len > NFS4_MAXPATHLEN)
4295 		goto out;
4296 
4297 	status = -ENOMEM;
4298 	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
4299 	if (data == NULL)
4300 		goto out;
4301 
4302 	data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
4303 	data->arg.u.symlink.pages = &page;
4304 	data->arg.u.symlink.len = len;
4305 	data->arg.label = label;
4306 
4307 	status = nfs4_do_create(dir, dentry, data);
4308 
4309 	nfs4_free_createdata(data);
4310 out:
4311 	return status;
4312 }
4313 
4314 static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
4315 		struct page *page, unsigned int len, struct iattr *sattr)
4316 {
4317 	struct nfs4_exception exception = { };
4318 	struct nfs4_label l, *label = NULL;
4319 	int err;
4320 
4321 	label = nfs4_label_init_security(dir, dentry, sattr, &l);
4322 
4323 	do {
4324 		err = _nfs4_proc_symlink(dir, dentry, page, len, sattr, label);
4325 		trace_nfs4_symlink(dir, &dentry->d_name, err);
4326 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
4327 				&exception);
4328 	} while (exception.retry);
4329 
4330 	nfs4_label_release_security(label);
4331 	return err;
4332 }
4333 
4334 static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4335 		struct iattr *sattr, struct nfs4_label *label)
4336 {
4337 	struct nfs4_createdata *data;
4338 	int status = -ENOMEM;
4339 
4340 	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
4341 	if (data == NULL)
4342 		goto out;
4343 
4344 	data->arg.label = label;
4345 	status = nfs4_do_create(dir, dentry, data);
4346 
4347 	nfs4_free_createdata(data);
4348 out:
4349 	return status;
4350 }
4351 
4352 static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
4353 		struct iattr *sattr)
4354 {
4355 	struct nfs_server *server = NFS_SERVER(dir);
4356 	struct nfs4_exception exception = { };
4357 	struct nfs4_label l, *label = NULL;
4358 	int err;
4359 
4360 	label = nfs4_label_init_security(dir, dentry, sattr, &l);
4361 
4362 	if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4363 		sattr->ia_mode &= ~current_umask();
4364 	do {
4365 		err = _nfs4_proc_mkdir(dir, dentry, sattr, label);
4366 		trace_nfs4_mkdir(dir, &dentry->d_name, err);
4367 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
4368 				&exception);
4369 	} while (exception.retry);
4370 	nfs4_label_release_security(label);
4371 
4372 	return err;
4373 }
4374 
4375 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4376 		u64 cookie, struct page **pages, unsigned int count, int plus)
4377 {
4378 	struct inode		*dir = d_inode(dentry);
4379 	struct nfs4_readdir_arg args = {
4380 		.fh = NFS_FH(dir),
4381 		.pages = pages,
4382 		.pgbase = 0,
4383 		.count = count,
4384 		.bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask,
4385 		.plus = plus,
4386 	};
4387 	struct nfs4_readdir_res res;
4388 	struct rpc_message msg = {
4389 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
4390 		.rpc_argp = &args,
4391 		.rpc_resp = &res,
4392 		.rpc_cred = cred,
4393 	};
4394 	int			status;
4395 
4396 	dprintk("%s: dentry = %pd2, cookie = %Lu\n", __func__,
4397 			dentry,
4398 			(unsigned long long)cookie);
4399 	nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
4400 	res.pgbase = args.pgbase;
4401 	status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
4402 	if (status >= 0) {
4403 		memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
4404 		status += args.pgbase;
4405 	}
4406 
4407 	nfs_invalidate_atime(dir);
4408 
4409 	dprintk("%s: returns %d\n", __func__, status);
4410 	return status;
4411 }
4412 
4413 static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
4414 		u64 cookie, struct page **pages, unsigned int count, int plus)
4415 {
4416 	struct nfs4_exception exception = { };
4417 	int err;
4418 	do {
4419 		err = _nfs4_proc_readdir(dentry, cred, cookie,
4420 				pages, count, plus);
4421 		trace_nfs4_readdir(d_inode(dentry), err);
4422 		err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err,
4423 				&exception);
4424 	} while (exception.retry);
4425 	return err;
4426 }
4427 
4428 static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4429 		struct iattr *sattr, struct nfs4_label *label, dev_t rdev)
4430 {
4431 	struct nfs4_createdata *data;
4432 	int mode = sattr->ia_mode;
4433 	int status = -ENOMEM;
4434 
4435 	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
4436 	if (data == NULL)
4437 		goto out;
4438 
4439 	if (S_ISFIFO(mode))
4440 		data->arg.ftype = NF4FIFO;
4441 	else if (S_ISBLK(mode)) {
4442 		data->arg.ftype = NF4BLK;
4443 		data->arg.u.device.specdata1 = MAJOR(rdev);
4444 		data->arg.u.device.specdata2 = MINOR(rdev);
4445 	}
4446 	else if (S_ISCHR(mode)) {
4447 		data->arg.ftype = NF4CHR;
4448 		data->arg.u.device.specdata1 = MAJOR(rdev);
4449 		data->arg.u.device.specdata2 = MINOR(rdev);
4450 	} else if (!S_ISSOCK(mode)) {
4451 		status = -EINVAL;
4452 		goto out_free;
4453 	}
4454 
4455 	data->arg.label = label;
4456 	status = nfs4_do_create(dir, dentry, data);
4457 out_free:
4458 	nfs4_free_createdata(data);
4459 out:
4460 	return status;
4461 }
4462 
4463 static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
4464 		struct iattr *sattr, dev_t rdev)
4465 {
4466 	struct nfs_server *server = NFS_SERVER(dir);
4467 	struct nfs4_exception exception = { };
4468 	struct nfs4_label l, *label = NULL;
4469 	int err;
4470 
4471 	label = nfs4_label_init_security(dir, dentry, sattr, &l);
4472 
4473 	if (!(server->attr_bitmask[2] & FATTR4_WORD2_MODE_UMASK))
4474 		sattr->ia_mode &= ~current_umask();
4475 	do {
4476 		err = _nfs4_proc_mknod(dir, dentry, sattr, label, rdev);
4477 		trace_nfs4_mknod(dir, &dentry->d_name, err);
4478 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
4479 				&exception);
4480 	} while (exception.retry);
4481 
4482 	nfs4_label_release_security(label);
4483 
4484 	return err;
4485 }
4486 
4487 static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
4488 		 struct nfs_fsstat *fsstat)
4489 {
4490 	struct nfs4_statfs_arg args = {
4491 		.fh = fhandle,
4492 		.bitmask = server->attr_bitmask,
4493 	};
4494 	struct nfs4_statfs_res res = {
4495 		.fsstat = fsstat,
4496 	};
4497 	struct rpc_message msg = {
4498 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
4499 		.rpc_argp = &args,
4500 		.rpc_resp = &res,
4501 	};
4502 
4503 	nfs_fattr_init(fsstat->fattr);
4504 	return  nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4505 }
4506 
4507 static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
4508 {
4509 	struct nfs4_exception exception = { };
4510 	int err;
4511 	do {
4512 		err = nfs4_handle_exception(server,
4513 				_nfs4_proc_statfs(server, fhandle, fsstat),
4514 				&exception);
4515 	} while (exception.retry);
4516 	return err;
4517 }
4518 
4519 static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
4520 		struct nfs_fsinfo *fsinfo)
4521 {
4522 	struct nfs4_fsinfo_arg args = {
4523 		.fh = fhandle,
4524 		.bitmask = server->attr_bitmask,
4525 	};
4526 	struct nfs4_fsinfo_res res = {
4527 		.fsinfo = fsinfo,
4528 	};
4529 	struct rpc_message msg = {
4530 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
4531 		.rpc_argp = &args,
4532 		.rpc_resp = &res,
4533 	};
4534 
4535 	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4536 }
4537 
4538 static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4539 {
4540 	struct nfs4_exception exception = { };
4541 	unsigned long now = jiffies;
4542 	int err;
4543 
4544 	do {
4545 		err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
4546 		trace_nfs4_fsinfo(server, fhandle, fsinfo->fattr, err);
4547 		if (err == 0) {
4548 			nfs4_set_lease_period(server->nfs_client,
4549 					fsinfo->lease_time * HZ,
4550 					now);
4551 			break;
4552 		}
4553 		err = nfs4_handle_exception(server, err, &exception);
4554 	} while (exception.retry);
4555 	return err;
4556 }
4557 
4558 static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
4559 {
4560 	int error;
4561 
4562 	nfs_fattr_init(fsinfo->fattr);
4563 	error = nfs4_do_fsinfo(server, fhandle, fsinfo);
4564 	if (error == 0) {
4565 		/* block layout checks this! */
4566 		server->pnfs_blksize = fsinfo->blksize;
4567 		set_pnfs_layoutdriver(server, fhandle, fsinfo);
4568 	}
4569 
4570 	return error;
4571 }
4572 
4573 static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4574 		struct nfs_pathconf *pathconf)
4575 {
4576 	struct nfs4_pathconf_arg args = {
4577 		.fh = fhandle,
4578 		.bitmask = server->attr_bitmask,
4579 	};
4580 	struct nfs4_pathconf_res res = {
4581 		.pathconf = pathconf,
4582 	};
4583 	struct rpc_message msg = {
4584 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
4585 		.rpc_argp = &args,
4586 		.rpc_resp = &res,
4587 	};
4588 
4589 	/* None of the pathconf attributes are mandatory to implement */
4590 	if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
4591 		memset(pathconf, 0, sizeof(*pathconf));
4592 		return 0;
4593 	}
4594 
4595 	nfs_fattr_init(pathconf->fattr);
4596 	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4597 }
4598 
4599 static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
4600 		struct nfs_pathconf *pathconf)
4601 {
4602 	struct nfs4_exception exception = { };
4603 	int err;
4604 
4605 	do {
4606 		err = nfs4_handle_exception(server,
4607 				_nfs4_proc_pathconf(server, fhandle, pathconf),
4608 				&exception);
4609 	} while (exception.retry);
4610 	return err;
4611 }
4612 
4613 int nfs4_set_rw_stateid(nfs4_stateid *stateid,
4614 		const struct nfs_open_context *ctx,
4615 		const struct nfs_lock_context *l_ctx,
4616 		fmode_t fmode)
4617 {
4618 	return nfs4_select_rw_stateid(ctx->state, fmode, l_ctx, stateid, NULL);
4619 }
4620 EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);
4621 
4622 static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
4623 		const struct nfs_open_context *ctx,
4624 		const struct nfs_lock_context *l_ctx,
4625 		fmode_t fmode)
4626 {
4627 	nfs4_stateid current_stateid;
4628 
4629 	/* If the current stateid represents a lost lock, then exit */
4630 	if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode) == -EIO)
4631 		return true;
4632 	return nfs4_stateid_match(stateid, &current_stateid);
4633 }
4634 
4635 static bool nfs4_error_stateid_expired(int err)
4636 {
4637 	switch (err) {
4638 	case -NFS4ERR_DELEG_REVOKED:
4639 	case -NFS4ERR_ADMIN_REVOKED:
4640 	case -NFS4ERR_BAD_STATEID:
4641 	case -NFS4ERR_STALE_STATEID:
4642 	case -NFS4ERR_OLD_STATEID:
4643 	case -NFS4ERR_OPENMODE:
4644 	case -NFS4ERR_EXPIRED:
4645 		return true;
4646 	}
4647 	return false;
4648 }
4649 
4650 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
4651 {
4652 	struct nfs_server *server = NFS_SERVER(hdr->inode);
4653 
4654 	trace_nfs4_read(hdr, task->tk_status);
4655 	if (task->tk_status < 0) {
4656 		struct nfs4_exception exception = {
4657 			.inode = hdr->inode,
4658 			.state = hdr->args.context->state,
4659 			.stateid = &hdr->args.stateid,
4660 		};
4661 		task->tk_status = nfs4_async_handle_exception(task,
4662 				server, task->tk_status, &exception);
4663 		if (exception.retry) {
4664 			rpc_restart_call_prepare(task);
4665 			return -EAGAIN;
4666 		}
4667 	}
4668 
4669 	if (task->tk_status > 0)
4670 		renew_lease(server, hdr->timestamp);
4671 	return 0;
4672 }
4673 
4674 static bool nfs4_read_stateid_changed(struct rpc_task *task,
4675 		struct nfs_pgio_args *args)
4676 {
4677 
4678 	if (!nfs4_error_stateid_expired(task->tk_status) ||
4679 		nfs4_stateid_is_current(&args->stateid,
4680 				args->context,
4681 				args->lock_context,
4682 				FMODE_READ))
4683 		return false;
4684 	rpc_restart_call_prepare(task);
4685 	return true;
4686 }
4687 
4688 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4689 {
4690 
4691 	dprintk("--> %s\n", __func__);
4692 
4693 	if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4694 		return -EAGAIN;
4695 	if (nfs4_read_stateid_changed(task, &hdr->args))
4696 		return -EAGAIN;
4697 	if (task->tk_status > 0)
4698 		nfs_invalidate_atime(hdr->inode);
4699 	return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4700 				    nfs4_read_done_cb(task, hdr);
4701 }
4702 
4703 static void nfs4_proc_read_setup(struct nfs_pgio_header *hdr,
4704 				 struct rpc_message *msg)
4705 {
4706 	hdr->timestamp   = jiffies;
4707 	if (!hdr->pgio_done_cb)
4708 		hdr->pgio_done_cb = nfs4_read_done_cb;
4709 	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
4710 	nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0);
4711 }
4712 
4713 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
4714 				      struct nfs_pgio_header *hdr)
4715 {
4716 	if (nfs4_setup_sequence(NFS_SERVER(hdr->inode),
4717 			&hdr->args.seq_args,
4718 			&hdr->res.seq_res,
4719 			task))
4720 		return 0;
4721 	if (nfs4_set_rw_stateid(&hdr->args.stateid, hdr->args.context,
4722 				hdr->args.lock_context,
4723 				hdr->rw_ops->rw_mode) == -EIO)
4724 		return -EIO;
4725 	if (unlikely(test_bit(NFS_CONTEXT_BAD, &hdr->args.context->flags)))
4726 		return -EIO;
4727 	return 0;
4728 }
4729 
4730 static int nfs4_write_done_cb(struct rpc_task *task,
4731 			      struct nfs_pgio_header *hdr)
4732 {
4733 	struct inode *inode = hdr->inode;
4734 
4735 	trace_nfs4_write(hdr, task->tk_status);
4736 	if (task->tk_status < 0) {
4737 		struct nfs4_exception exception = {
4738 			.inode = hdr->inode,
4739 			.state = hdr->args.context->state,
4740 			.stateid = &hdr->args.stateid,
4741 		};
4742 		task->tk_status = nfs4_async_handle_exception(task,
4743 				NFS_SERVER(inode), task->tk_status,
4744 				&exception);
4745 		if (exception.retry) {
4746 			rpc_restart_call_prepare(task);
4747 			return -EAGAIN;
4748 		}
4749 	}
4750 	if (task->tk_status >= 0) {
4751 		renew_lease(NFS_SERVER(inode), hdr->timestamp);
4752 		nfs_writeback_update_inode(hdr);
4753 	}
4754 	return 0;
4755 }
4756 
4757 static bool nfs4_write_stateid_changed(struct rpc_task *task,
4758 		struct nfs_pgio_args *args)
4759 {
4760 
4761 	if (!nfs4_error_stateid_expired(task->tk_status) ||
4762 		nfs4_stateid_is_current(&args->stateid,
4763 				args->context,
4764 				args->lock_context,
4765 				FMODE_WRITE))
4766 		return false;
4767 	rpc_restart_call_prepare(task);
4768 	return true;
4769 }
4770 
4771 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
4772 {
4773 	if (!nfs4_sequence_done(task, &hdr->res.seq_res))
4774 		return -EAGAIN;
4775 	if (nfs4_write_stateid_changed(task, &hdr->args))
4776 		return -EAGAIN;
4777 	return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
4778 		nfs4_write_done_cb(task, hdr);
4779 }
4780 
4781 static
4782 bool nfs4_write_need_cache_consistency_data(struct nfs_pgio_header *hdr)
4783 {
4784 	/* Don't request attributes for pNFS or O_DIRECT writes */
4785 	if (hdr->ds_clp != NULL || hdr->dreq != NULL)
4786 		return false;
4787 	/* Otherwise, request attributes if and only if we don't hold
4788 	 * a delegation
4789 	 */
4790 	return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
4791 }
4792 
4793 static void nfs4_proc_write_setup(struct nfs_pgio_header *hdr,
4794 				  struct rpc_message *msg)
4795 {
4796 	struct nfs_server *server = NFS_SERVER(hdr->inode);
4797 
4798 	if (!nfs4_write_need_cache_consistency_data(hdr)) {
4799 		hdr->args.bitmask = NULL;
4800 		hdr->res.fattr = NULL;
4801 	} else
4802 		hdr->args.bitmask = server->cache_consistency_bitmask;
4803 
4804 	if (!hdr->pgio_done_cb)
4805 		hdr->pgio_done_cb = nfs4_write_done_cb;
4806 	hdr->res.server = server;
4807 	hdr->timestamp   = jiffies;
4808 
4809 	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
4810 	nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 1);
4811 }
4812 
4813 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
4814 {
4815 	nfs4_setup_sequence(NFS_SERVER(data->inode),
4816 			&data->args.seq_args,
4817 			&data->res.seq_res,
4818 			task);
4819 }
4820 
4821 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
4822 {
4823 	struct inode *inode = data->inode;
4824 
4825 	trace_nfs4_commit(data, task->tk_status);
4826 	if (nfs4_async_handle_error(task, NFS_SERVER(inode),
4827 				    NULL, NULL) == -EAGAIN) {
4828 		rpc_restart_call_prepare(task);
4829 		return -EAGAIN;
4830 	}
4831 	return 0;
4832 }
4833 
4834 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
4835 {
4836 	if (!nfs4_sequence_done(task, &data->res.seq_res))
4837 		return -EAGAIN;
4838 	return data->commit_done_cb(task, data);
4839 }
4840 
4841 static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
4842 {
4843 	struct nfs_server *server = NFS_SERVER(data->inode);
4844 
4845 	if (data->commit_done_cb == NULL)
4846 		data->commit_done_cb = nfs4_commit_done_cb;
4847 	data->res.server = server;
4848 	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
4849 	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4850 }
4851 
4852 struct nfs4_renewdata {
4853 	struct nfs_client	*client;
4854 	unsigned long		timestamp;
4855 };
4856 
4857 /*
4858  * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
4859  * standalone procedure for queueing an asynchronous RENEW.
4860  */
4861 static void nfs4_renew_release(void *calldata)
4862 {
4863 	struct nfs4_renewdata *data = calldata;
4864 	struct nfs_client *clp = data->client;
4865 
4866 	if (atomic_read(&clp->cl_count) > 1)
4867 		nfs4_schedule_state_renewal(clp);
4868 	nfs_put_client(clp);
4869 	kfree(data);
4870 }
4871 
4872 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
4873 {
4874 	struct nfs4_renewdata *data = calldata;
4875 	struct nfs_client *clp = data->client;
4876 	unsigned long timestamp = data->timestamp;
4877 
4878 	trace_nfs4_renew_async(clp, task->tk_status);
4879 	switch (task->tk_status) {
4880 	case 0:
4881 		break;
4882 	case -NFS4ERR_LEASE_MOVED:
4883 		nfs4_schedule_lease_moved_recovery(clp);
4884 		break;
4885 	default:
4886 		/* Unless we're shutting down, schedule state recovery! */
4887 		if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
4888 			return;
4889 		if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
4890 			nfs4_schedule_lease_recovery(clp);
4891 			return;
4892 		}
4893 		nfs4_schedule_path_down_recovery(clp);
4894 	}
4895 	do_renew_lease(clp, timestamp);
4896 }
4897 
4898 static const struct rpc_call_ops nfs4_renew_ops = {
4899 	.rpc_call_done = nfs4_renew_done,
4900 	.rpc_release = nfs4_renew_release,
4901 };
4902 
4903 static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
4904 {
4905 	struct rpc_message msg = {
4906 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4907 		.rpc_argp	= clp,
4908 		.rpc_cred	= cred,
4909 	};
4910 	struct nfs4_renewdata *data;
4911 
4912 	if (renew_flags == 0)
4913 		return 0;
4914 	if (!atomic_inc_not_zero(&clp->cl_count))
4915 		return -EIO;
4916 	data = kmalloc(sizeof(*data), GFP_NOFS);
4917 	if (data == NULL)
4918 		return -ENOMEM;
4919 	data->client = clp;
4920 	data->timestamp = jiffies;
4921 	return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
4922 			&nfs4_renew_ops, data);
4923 }
4924 
4925 static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
4926 {
4927 	struct rpc_message msg = {
4928 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_RENEW],
4929 		.rpc_argp	= clp,
4930 		.rpc_cred	= cred,
4931 	};
4932 	unsigned long now = jiffies;
4933 	int status;
4934 
4935 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4936 	if (status < 0)
4937 		return status;
4938 	do_renew_lease(clp, now);
4939 	return 0;
4940 }
4941 
4942 static inline int nfs4_server_supports_acls(struct nfs_server *server)
4943 {
4944 	return server->caps & NFS_CAP_ACLS;
4945 }
4946 
4947 /* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
4948  * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
4949  * the stack.
4950  */
4951 #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
4952 
4953 static int buf_to_pages_noslab(const void *buf, size_t buflen,
4954 		struct page **pages)
4955 {
4956 	struct page *newpage, **spages;
4957 	int rc = 0;
4958 	size_t len;
4959 	spages = pages;
4960 
4961 	do {
4962 		len = min_t(size_t, PAGE_SIZE, buflen);
4963 		newpage = alloc_page(GFP_KERNEL);
4964 
4965 		if (newpage == NULL)
4966 			goto unwind;
4967 		memcpy(page_address(newpage), buf, len);
4968                 buf += len;
4969                 buflen -= len;
4970 		*pages++ = newpage;
4971 		rc++;
4972 	} while (buflen != 0);
4973 
4974 	return rc;
4975 
4976 unwind:
4977 	for(; rc > 0; rc--)
4978 		__free_page(spages[rc-1]);
4979 	return -ENOMEM;
4980 }
4981 
4982 struct nfs4_cached_acl {
4983 	int cached;
4984 	size_t len;
4985 	char data[0];
4986 };
4987 
4988 static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
4989 {
4990 	struct nfs_inode *nfsi = NFS_I(inode);
4991 
4992 	spin_lock(&inode->i_lock);
4993 	kfree(nfsi->nfs4_acl);
4994 	nfsi->nfs4_acl = acl;
4995 	spin_unlock(&inode->i_lock);
4996 }
4997 
4998 static void nfs4_zap_acl_attr(struct inode *inode)
4999 {
5000 	nfs4_set_cached_acl(inode, NULL);
5001 }
5002 
5003 static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
5004 {
5005 	struct nfs_inode *nfsi = NFS_I(inode);
5006 	struct nfs4_cached_acl *acl;
5007 	int ret = -ENOENT;
5008 
5009 	spin_lock(&inode->i_lock);
5010 	acl = nfsi->nfs4_acl;
5011 	if (acl == NULL)
5012 		goto out;
5013 	if (buf == NULL) /* user is just asking for length */
5014 		goto out_len;
5015 	if (acl->cached == 0)
5016 		goto out;
5017 	ret = -ERANGE; /* see getxattr(2) man page */
5018 	if (acl->len > buflen)
5019 		goto out;
5020 	memcpy(buf, acl->data, acl->len);
5021 out_len:
5022 	ret = acl->len;
5023 out:
5024 	spin_unlock(&inode->i_lock);
5025 	return ret;
5026 }
5027 
5028 static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
5029 {
5030 	struct nfs4_cached_acl *acl;
5031 	size_t buflen = sizeof(*acl) + acl_len;
5032 
5033 	if (buflen <= PAGE_SIZE) {
5034 		acl = kmalloc(buflen, GFP_KERNEL);
5035 		if (acl == NULL)
5036 			goto out;
5037 		acl->cached = 1;
5038 		_copy_from_pages(acl->data, pages, pgbase, acl_len);
5039 	} else {
5040 		acl = kmalloc(sizeof(*acl), GFP_KERNEL);
5041 		if (acl == NULL)
5042 			goto out;
5043 		acl->cached = 0;
5044 	}
5045 	acl->len = acl_len;
5046 out:
5047 	nfs4_set_cached_acl(inode, acl);
5048 }
5049 
5050 /*
5051  * The getxattr API returns the required buffer length when called with a
5052  * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
5053  * the required buf.  On a NULL buf, we send a page of data to the server
5054  * guessing that the ACL request can be serviced by a page. If so, we cache
5055  * up to the page of ACL data, and the 2nd call to getxattr is serviced by
5056  * the cache. If not so, we throw away the page, and cache the required
5057  * length. The next getxattr call will then produce another round trip to
5058  * the server, this time with the input buf of the required size.
5059  */
5060 static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5061 {
5062 	struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
5063 	struct nfs_getaclargs args = {
5064 		.fh = NFS_FH(inode),
5065 		.acl_pages = pages,
5066 		.acl_len = buflen,
5067 	};
5068 	struct nfs_getaclres res = {
5069 		.acl_len = buflen,
5070 	};
5071 	struct rpc_message msg = {
5072 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
5073 		.rpc_argp = &args,
5074 		.rpc_resp = &res,
5075 	};
5076 	unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5077 	int ret = -ENOMEM, i;
5078 
5079 	/* As long as we're doing a round trip to the server anyway,
5080 	 * let's be prepared for a page of acl data. */
5081 	if (npages == 0)
5082 		npages = 1;
5083 	if (npages > ARRAY_SIZE(pages))
5084 		return -ERANGE;
5085 
5086 	for (i = 0; i < npages; i++) {
5087 		pages[i] = alloc_page(GFP_KERNEL);
5088 		if (!pages[i])
5089 			goto out_free;
5090 	}
5091 
5092 	/* for decoding across pages */
5093 	res.acl_scratch = alloc_page(GFP_KERNEL);
5094 	if (!res.acl_scratch)
5095 		goto out_free;
5096 
5097 	args.acl_len = npages * PAGE_SIZE;
5098 
5099 	dprintk("%s  buf %p buflen %zu npages %d args.acl_len %zu\n",
5100 		__func__, buf, buflen, npages, args.acl_len);
5101 	ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
5102 			     &msg, &args.seq_args, &res.seq_res, 0);
5103 	if (ret)
5104 		goto out_free;
5105 
5106 	/* Handle the case where the passed-in buffer is too short */
5107 	if (res.acl_flags & NFS4_ACL_TRUNC) {
5108 		/* Did the user only issue a request for the acl length? */
5109 		if (buf == NULL)
5110 			goto out_ok;
5111 		ret = -ERANGE;
5112 		goto out_free;
5113 	}
5114 	nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
5115 	if (buf) {
5116 		if (res.acl_len > buflen) {
5117 			ret = -ERANGE;
5118 			goto out_free;
5119 		}
5120 		_copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
5121 	}
5122 out_ok:
5123 	ret = res.acl_len;
5124 out_free:
5125 	for (i = 0; i < npages; i++)
5126 		if (pages[i])
5127 			__free_page(pages[i]);
5128 	if (res.acl_scratch)
5129 		__free_page(res.acl_scratch);
5130 	return ret;
5131 }
5132 
5133 static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
5134 {
5135 	struct nfs4_exception exception = { };
5136 	ssize_t ret;
5137 	do {
5138 		ret = __nfs4_get_acl_uncached(inode, buf, buflen);
5139 		trace_nfs4_get_acl(inode, ret);
5140 		if (ret >= 0)
5141 			break;
5142 		ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
5143 	} while (exception.retry);
5144 	return ret;
5145 }
5146 
5147 static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
5148 {
5149 	struct nfs_server *server = NFS_SERVER(inode);
5150 	int ret;
5151 
5152 	if (!nfs4_server_supports_acls(server))
5153 		return -EOPNOTSUPP;
5154 	ret = nfs_revalidate_inode(server, inode);
5155 	if (ret < 0)
5156 		return ret;
5157 	if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
5158 		nfs_zap_acl_cache(inode);
5159 	ret = nfs4_read_cached_acl(inode, buf, buflen);
5160 	if (ret != -ENOENT)
5161 		/* -ENOENT is returned if there is no ACL or if there is an ACL
5162 		 * but no cached acl data, just the acl length */
5163 		return ret;
5164 	return nfs4_get_acl_uncached(inode, buf, buflen);
5165 }
5166 
5167 static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5168 {
5169 	struct nfs_server *server = NFS_SERVER(inode);
5170 	struct page *pages[NFS4ACL_MAXPAGES];
5171 	struct nfs_setaclargs arg = {
5172 		.fh		= NFS_FH(inode),
5173 		.acl_pages	= pages,
5174 		.acl_len	= buflen,
5175 	};
5176 	struct nfs_setaclres res;
5177 	struct rpc_message msg = {
5178 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_SETACL],
5179 		.rpc_argp	= &arg,
5180 		.rpc_resp	= &res,
5181 	};
5182 	unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
5183 	int ret, i;
5184 
5185 	if (!nfs4_server_supports_acls(server))
5186 		return -EOPNOTSUPP;
5187 	if (npages > ARRAY_SIZE(pages))
5188 		return -ERANGE;
5189 	i = buf_to_pages_noslab(buf, buflen, arg.acl_pages);
5190 	if (i < 0)
5191 		return i;
5192 	nfs4_inode_return_delegation(inode);
5193 	ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5194 
5195 	/*
5196 	 * Free each page after tx, so the only ref left is
5197 	 * held by the network stack
5198 	 */
5199 	for (; i > 0; i--)
5200 		put_page(pages[i-1]);
5201 
5202 	/*
5203 	 * Acl update can result in inode attribute update.
5204 	 * so mark the attribute cache invalid.
5205 	 */
5206 	spin_lock(&inode->i_lock);
5207 	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
5208 	spin_unlock(&inode->i_lock);
5209 	nfs_access_zap_cache(inode);
5210 	nfs_zap_acl_cache(inode);
5211 	return ret;
5212 }
5213 
5214 static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
5215 {
5216 	struct nfs4_exception exception = { };
5217 	int err;
5218 	do {
5219 		err = __nfs4_proc_set_acl(inode, buf, buflen);
5220 		trace_nfs4_set_acl(inode, err);
5221 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
5222 				&exception);
5223 	} while (exception.retry);
5224 	return err;
5225 }
5226 
5227 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
5228 static int _nfs4_get_security_label(struct inode *inode, void *buf,
5229 					size_t buflen)
5230 {
5231 	struct nfs_server *server = NFS_SERVER(inode);
5232 	struct nfs_fattr fattr;
5233 	struct nfs4_label label = {0, 0, buflen, buf};
5234 
5235 	u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5236 	struct nfs4_getattr_arg arg = {
5237 		.fh		= NFS_FH(inode),
5238 		.bitmask	= bitmask,
5239 	};
5240 	struct nfs4_getattr_res res = {
5241 		.fattr		= &fattr,
5242 		.label		= &label,
5243 		.server		= server,
5244 	};
5245 	struct rpc_message msg = {
5246 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
5247 		.rpc_argp	= &arg,
5248 		.rpc_resp	= &res,
5249 	};
5250 	int ret;
5251 
5252 	nfs_fattr_init(&fattr);
5253 
5254 	ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
5255 	if (ret)
5256 		return ret;
5257 	if (!(fattr.valid & NFS_ATTR_FATTR_V4_SECURITY_LABEL))
5258 		return -ENOENT;
5259 	if (buflen < label.len)
5260 		return -ERANGE;
5261 	return 0;
5262 }
5263 
5264 static int nfs4_get_security_label(struct inode *inode, void *buf,
5265 					size_t buflen)
5266 {
5267 	struct nfs4_exception exception = { };
5268 	int err;
5269 
5270 	if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5271 		return -EOPNOTSUPP;
5272 
5273 	do {
5274 		err = _nfs4_get_security_label(inode, buf, buflen);
5275 		trace_nfs4_get_security_label(inode, err);
5276 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
5277 				&exception);
5278 	} while (exception.retry);
5279 	return err;
5280 }
5281 
5282 static int _nfs4_do_set_security_label(struct inode *inode,
5283 		struct nfs4_label *ilabel,
5284 		struct nfs_fattr *fattr,
5285 		struct nfs4_label *olabel)
5286 {
5287 
5288 	struct iattr sattr = {0};
5289 	struct nfs_server *server = NFS_SERVER(inode);
5290 	const u32 bitmask[3] = { 0, 0, FATTR4_WORD2_SECURITY_LABEL };
5291 	struct nfs_setattrargs arg = {
5292 		.fh             = NFS_FH(inode),
5293 		.iap            = &sattr,
5294 		.server		= server,
5295 		.bitmask	= bitmask,
5296 		.label		= ilabel,
5297 	};
5298 	struct nfs_setattrres res = {
5299 		.fattr		= fattr,
5300 		.label		= olabel,
5301 		.server		= server,
5302 	};
5303 	struct rpc_message msg = {
5304 		.rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
5305 		.rpc_argp       = &arg,
5306 		.rpc_resp       = &res,
5307 	};
5308 	int status;
5309 
5310 	nfs4_stateid_copy(&arg.stateid, &zero_stateid);
5311 
5312 	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5313 	if (status)
5314 		dprintk("%s failed: %d\n", __func__, status);
5315 
5316 	return status;
5317 }
5318 
5319 static int nfs4_do_set_security_label(struct inode *inode,
5320 		struct nfs4_label *ilabel,
5321 		struct nfs_fattr *fattr,
5322 		struct nfs4_label *olabel)
5323 {
5324 	struct nfs4_exception exception = { };
5325 	int err;
5326 
5327 	do {
5328 		err = _nfs4_do_set_security_label(inode, ilabel,
5329 				fattr, olabel);
5330 		trace_nfs4_set_security_label(inode, err);
5331 		err = nfs4_handle_exception(NFS_SERVER(inode), err,
5332 				&exception);
5333 	} while (exception.retry);
5334 	return err;
5335 }
5336 
5337 static int
5338 nfs4_set_security_label(struct inode *inode, const void *buf, size_t buflen)
5339 {
5340 	struct nfs4_label ilabel, *olabel = NULL;
5341 	struct nfs_fattr fattr;
5342 	struct rpc_cred *cred;
5343 	int status;
5344 
5345 	if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL))
5346 		return -EOPNOTSUPP;
5347 
5348 	nfs_fattr_init(&fattr);
5349 
5350 	ilabel.pi = 0;
5351 	ilabel.lfs = 0;
5352 	ilabel.label = (char *)buf;
5353 	ilabel.len = buflen;
5354 
5355 	cred = rpc_lookup_cred();
5356 	if (IS_ERR(cred))
5357 		return PTR_ERR(cred);
5358 
5359 	olabel = nfs4_label_alloc(NFS_SERVER(inode), GFP_KERNEL);
5360 	if (IS_ERR(olabel)) {
5361 		status = -PTR_ERR(olabel);
5362 		goto out;
5363 	}
5364 
5365 	status = nfs4_do_set_security_label(inode, &ilabel, &fattr, olabel);
5366 	if (status == 0)
5367 		nfs_setsecurity(inode, &fattr, olabel);
5368 
5369 	nfs4_label_free(olabel);
5370 out:
5371 	put_rpccred(cred);
5372 	return status;
5373 }
5374 #endif	/* CONFIG_NFS_V4_SECURITY_LABEL */
5375 
5376 
5377 static void nfs4_init_boot_verifier(const struct nfs_client *clp,
5378 				    nfs4_verifier *bootverf)
5379 {
5380 	__be32 verf[2];
5381 
5382 	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
5383 		/* An impossible timestamp guarantees this value
5384 		 * will never match a generated boot time. */
5385 		verf[0] = cpu_to_be32(U32_MAX);
5386 		verf[1] = cpu_to_be32(U32_MAX);
5387 	} else {
5388 		struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
5389 		u64 ns = ktime_to_ns(nn->boot_time);
5390 
5391 		verf[0] = cpu_to_be32(ns >> 32);
5392 		verf[1] = cpu_to_be32(ns);
5393 	}
5394 	memcpy(bootverf->data, verf, sizeof(bootverf->data));
5395 }
5396 
5397 static int
5398 nfs4_init_nonuniform_client_string(struct nfs_client *clp)
5399 {
5400 	size_t len;
5401 	char *str;
5402 
5403 	if (clp->cl_owner_id != NULL)
5404 		return 0;
5405 
5406 	rcu_read_lock();
5407 	len = 14 + strlen(clp->cl_ipaddr) + 1 +
5408 		strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR)) +
5409 		1 +
5410 		strlen(rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO)) +
5411 		1;
5412 	rcu_read_unlock();
5413 
5414 	if (len > NFS4_OPAQUE_LIMIT + 1)
5415 		return -EINVAL;
5416 
5417 	/*
5418 	 * Since this string is allocated at mount time, and held until the
5419 	 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5420 	 * about a memory-reclaim deadlock.
5421 	 */
5422 	str = kmalloc(len, GFP_KERNEL);
5423 	if (!str)
5424 		return -ENOMEM;
5425 
5426 	rcu_read_lock();
5427 	scnprintf(str, len, "Linux NFSv4.0 %s/%s %s",
5428 			clp->cl_ipaddr,
5429 			rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
5430 			rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_PROTO));
5431 	rcu_read_unlock();
5432 
5433 	clp->cl_owner_id = str;
5434 	return 0;
5435 }
5436 
5437 static int
5438 nfs4_init_uniquifier_client_string(struct nfs_client *clp)
5439 {
5440 	size_t len;
5441 	char *str;
5442 
5443 	len = 10 + 10 + 1 + 10 + 1 +
5444 		strlen(nfs4_client_id_uniquifier) + 1 +
5445 		strlen(clp->cl_rpcclient->cl_nodename) + 1;
5446 
5447 	if (len > NFS4_OPAQUE_LIMIT + 1)
5448 		return -EINVAL;
5449 
5450 	/*
5451 	 * Since this string is allocated at mount time, and held until the
5452 	 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5453 	 * about a memory-reclaim deadlock.
5454 	 */
5455 	str = kmalloc(len, GFP_KERNEL);
5456 	if (!str)
5457 		return -ENOMEM;
5458 
5459 	scnprintf(str, len, "Linux NFSv%u.%u %s/%s",
5460 			clp->rpc_ops->version, clp->cl_minorversion,
5461 			nfs4_client_id_uniquifier,
5462 			clp->cl_rpcclient->cl_nodename);
5463 	clp->cl_owner_id = str;
5464 	return 0;
5465 }
5466 
5467 static int
5468 nfs4_init_uniform_client_string(struct nfs_client *clp)
5469 {
5470 	size_t len;
5471 	char *str;
5472 
5473 	if (clp->cl_owner_id != NULL)
5474 		return 0;
5475 
5476 	if (nfs4_client_id_uniquifier[0] != '\0')
5477 		return nfs4_init_uniquifier_client_string(clp);
5478 
5479 	len = 10 + 10 + 1 + 10 + 1 +
5480 		strlen(clp->cl_rpcclient->cl_nodename) + 1;
5481 
5482 	if (len > NFS4_OPAQUE_LIMIT + 1)
5483 		return -EINVAL;
5484 
5485 	/*
5486 	 * Since this string is allocated at mount time, and held until the
5487 	 * nfs_client is destroyed, we can use GFP_KERNEL here w/o worrying
5488 	 * about a memory-reclaim deadlock.
5489 	 */
5490 	str = kmalloc(len, GFP_KERNEL);
5491 	if (!str)
5492 		return -ENOMEM;
5493 
5494 	scnprintf(str, len, "Linux NFSv%u.%u %s",
5495 			clp->rpc_ops->version, clp->cl_minorversion,
5496 			clp->cl_rpcclient->cl_nodename);
5497 	clp->cl_owner_id = str;
5498 	return 0;
5499 }
5500 
5501 /*
5502  * nfs4_callback_up_net() starts only "tcp" and "tcp6" callback
5503  * services.  Advertise one based on the address family of the
5504  * clientaddr.
5505  */
5506 static unsigned int
5507 nfs4_init_callback_netid(const struct nfs_client *clp, char *buf, size_t len)
5508 {
5509 	if (strchr(clp->cl_ipaddr, ':') != NULL)
5510 		return scnprintf(buf, len, "tcp6");
5511 	else
5512 		return scnprintf(buf, len, "tcp");
5513 }
5514 
5515 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
5516 {
5517 	struct nfs4_setclientid *sc = calldata;
5518 
5519 	if (task->tk_status == 0)
5520 		sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
5521 }
5522 
5523 static const struct rpc_call_ops nfs4_setclientid_ops = {
5524 	.rpc_call_done = nfs4_setclientid_done,
5525 };
5526 
5527 /**
5528  * nfs4_proc_setclientid - Negotiate client ID
5529  * @clp: state data structure
5530  * @program: RPC program for NFSv4 callback service
5531  * @port: IP port number for NFS4 callback service
5532  * @cred: RPC credential to use for this call
5533  * @res: where to place the result
5534  *
5535  * Returns zero, a negative errno, or a negative NFS4ERR status code.
5536  */
5537 int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
5538 		unsigned short port, struct rpc_cred *cred,
5539 		struct nfs4_setclientid_res *res)
5540 {
5541 	nfs4_verifier sc_verifier;
5542 	struct nfs4_setclientid setclientid = {
5543 		.sc_verifier = &sc_verifier,
5544 		.sc_prog = program,
5545 		.sc_clnt = clp,
5546 	};
5547 	struct rpc_message msg = {
5548 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
5549 		.rpc_argp = &setclientid,
5550 		.rpc_resp = res,
5551 		.rpc_cred = cred,
5552 	};
5553 	struct rpc_task *task;
5554 	struct rpc_task_setup task_setup_data = {
5555 		.rpc_client = clp->cl_rpcclient,
5556 		.rpc_message = &msg,
5557 		.callback_ops = &nfs4_setclientid_ops,
5558 		.callback_data = &setclientid,
5559 		.flags = RPC_TASK_TIMEOUT,
5560 	};
5561 	int status;
5562 
5563 	/* nfs_client_id4 */
5564 	nfs4_init_boot_verifier(clp, &sc_verifier);
5565 
5566 	if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
5567 		status = nfs4_init_uniform_client_string(clp);
5568 	else
5569 		status = nfs4_init_nonuniform_client_string(clp);
5570 
5571 	if (status)
5572 		goto out;
5573 
5574 	/* cb_client4 */
5575 	setclientid.sc_netid_len =
5576 				nfs4_init_callback_netid(clp,
5577 						setclientid.sc_netid,
5578 						sizeof(setclientid.sc_netid));
5579 	setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
5580 				sizeof(setclientid.sc_uaddr), "%s.%u.%u",
5581 				clp->cl_ipaddr, port >> 8, port & 255);
5582 
5583 	dprintk("NFS call  setclientid auth=%s, '%s'\n",
5584 		clp->cl_rpcclient->cl_auth->au_ops->au_name,
5585 		clp->cl_owner_id);
5586 	task = rpc_run_task(&task_setup_data);
5587 	if (IS_ERR(task)) {
5588 		status = PTR_ERR(task);
5589 		goto out;
5590 	}
5591 	status = task->tk_status;
5592 	if (setclientid.sc_cred) {
5593 		clp->cl_acceptor = rpcauth_stringify_acceptor(setclientid.sc_cred);
5594 		put_rpccred(setclientid.sc_cred);
5595 	}
5596 	rpc_put_task(task);
5597 out:
5598 	trace_nfs4_setclientid(clp, status);
5599 	dprintk("NFS reply setclientid: %d\n", status);
5600 	return status;
5601 }
5602 
5603 /**
5604  * nfs4_proc_setclientid_confirm - Confirm client ID
5605  * @clp: state data structure
5606  * @res: result of a previous SETCLIENTID
5607  * @cred: RPC credential to use for this call
5608  *
5609  * Returns zero, a negative errno, or a negative NFS4ERR status code.
5610  */
5611 int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
5612 		struct nfs4_setclientid_res *arg,
5613 		struct rpc_cred *cred)
5614 {
5615 	struct rpc_message msg = {
5616 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
5617 		.rpc_argp = arg,
5618 		.rpc_cred = cred,
5619 	};
5620 	int status;
5621 
5622 	dprintk("NFS call  setclientid_confirm auth=%s, (client ID %llx)\n",
5623 		clp->cl_rpcclient->cl_auth->au_ops->au_name,
5624 		clp->cl_clientid);
5625 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5626 	trace_nfs4_setclientid_confirm(clp, status);
5627 	dprintk("NFS reply setclientid_confirm: %d\n", status);
5628 	return status;
5629 }
5630 
5631 struct nfs4_delegreturndata {
5632 	struct nfs4_delegreturnargs args;
5633 	struct nfs4_delegreturnres res;
5634 	struct nfs_fh fh;
5635 	nfs4_stateid stateid;
5636 	unsigned long timestamp;
5637 	struct {
5638 		struct nfs4_layoutreturn_args arg;
5639 		struct nfs4_layoutreturn_res res;
5640 		struct nfs4_xdr_opaque_data ld_private;
5641 		u32 roc_barrier;
5642 		bool roc;
5643 	} lr;
5644 	struct nfs_fattr fattr;
5645 	int rpc_status;
5646 	struct inode *inode;
5647 };
5648 
5649 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
5650 {
5651 	struct nfs4_delegreturndata *data = calldata;
5652 
5653 	if (!nfs4_sequence_done(task, &data->res.seq_res))
5654 		return;
5655 
5656 	trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
5657 
5658 	/* Handle Layoutreturn errors */
5659 	if (data->args.lr_args && task->tk_status != 0) {
5660 		switch(data->res.lr_ret) {
5661 		default:
5662 			data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5663 			break;
5664 		case 0:
5665 			data->args.lr_args = NULL;
5666 			data->res.lr_res = NULL;
5667 			break;
5668 		case -NFS4ERR_ADMIN_REVOKED:
5669 		case -NFS4ERR_DELEG_REVOKED:
5670 		case -NFS4ERR_EXPIRED:
5671 		case -NFS4ERR_BAD_STATEID:
5672 		case -NFS4ERR_OLD_STATEID:
5673 		case -NFS4ERR_UNKNOWN_LAYOUTTYPE:
5674 		case -NFS4ERR_WRONG_CRED:
5675 			data->args.lr_args = NULL;
5676 			data->res.lr_res = NULL;
5677 			data->res.lr_ret = 0;
5678 			rpc_restart_call_prepare(task);
5679 			return;
5680 		}
5681 	}
5682 
5683 	switch (task->tk_status) {
5684 	case 0:
5685 		renew_lease(data->res.server, data->timestamp);
5686 		break;
5687 	case -NFS4ERR_ADMIN_REVOKED:
5688 	case -NFS4ERR_DELEG_REVOKED:
5689 	case -NFS4ERR_EXPIRED:
5690 		nfs4_free_revoked_stateid(data->res.server,
5691 				data->args.stateid,
5692 				task->tk_msg.rpc_cred);
5693 	case -NFS4ERR_BAD_STATEID:
5694 	case -NFS4ERR_OLD_STATEID:
5695 	case -NFS4ERR_STALE_STATEID:
5696 		task->tk_status = 0;
5697 		break;
5698 	case -NFS4ERR_ACCESS:
5699 		if (data->args.bitmask) {
5700 			data->args.bitmask = NULL;
5701 			data->res.fattr = NULL;
5702 			task->tk_status = 0;
5703 			rpc_restart_call_prepare(task);
5704 			return;
5705 		}
5706 	default:
5707 		if (nfs4_async_handle_error(task, data->res.server,
5708 					    NULL, NULL) == -EAGAIN) {
5709 			rpc_restart_call_prepare(task);
5710 			return;
5711 		}
5712 	}
5713 	data->rpc_status = task->tk_status;
5714 }
5715 
5716 static void nfs4_delegreturn_release(void *calldata)
5717 {
5718 	struct nfs4_delegreturndata *data = calldata;
5719 	struct inode *inode = data->inode;
5720 
5721 	if (inode) {
5722 		if (data->lr.roc)
5723 			pnfs_roc_release(&data->lr.arg, &data->lr.res,
5724 					data->res.lr_ret);
5725 		nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
5726 		nfs_iput_and_deactive(inode);
5727 	}
5728 	kfree(calldata);
5729 }
5730 
5731 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
5732 {
5733 	struct nfs4_delegreturndata *d_data;
5734 
5735 	d_data = (struct nfs4_delegreturndata *)data;
5736 
5737 	if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task))
5738 		return;
5739 
5740 	nfs4_setup_sequence(d_data->res.server,
5741 			&d_data->args.seq_args,
5742 			&d_data->res.seq_res,
5743 			task);
5744 }
5745 
5746 static const struct rpc_call_ops nfs4_delegreturn_ops = {
5747 	.rpc_call_prepare = nfs4_delegreturn_prepare,
5748 	.rpc_call_done = nfs4_delegreturn_done,
5749 	.rpc_release = nfs4_delegreturn_release,
5750 };
5751 
5752 static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5753 {
5754 	struct nfs4_delegreturndata *data;
5755 	struct nfs_server *server = NFS_SERVER(inode);
5756 	struct rpc_task *task;
5757 	struct rpc_message msg = {
5758 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
5759 		.rpc_cred = cred,
5760 	};
5761 	struct rpc_task_setup task_setup_data = {
5762 		.rpc_client = server->client,
5763 		.rpc_message = &msg,
5764 		.callback_ops = &nfs4_delegreturn_ops,
5765 		.flags = RPC_TASK_ASYNC,
5766 	};
5767 	int status = 0;
5768 
5769 	data = kzalloc(sizeof(*data), GFP_NOFS);
5770 	if (data == NULL)
5771 		return -ENOMEM;
5772 	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
5773 
5774 	nfs4_state_protect(server->nfs_client,
5775 			NFS_SP4_MACH_CRED_CLEANUP,
5776 			&task_setup_data.rpc_client, &msg);
5777 
5778 	data->args.fhandle = &data->fh;
5779 	data->args.stateid = &data->stateid;
5780 	data->args.bitmask = server->cache_consistency_bitmask;
5781 	nfs_copy_fh(&data->fh, NFS_FH(inode));
5782 	nfs4_stateid_copy(&data->stateid, stateid);
5783 	data->res.fattr = &data->fattr;
5784 	data->res.server = server;
5785 	data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
5786 	data->lr.arg.ld_private = &data->lr.ld_private;
5787 	nfs_fattr_init(data->res.fattr);
5788 	data->timestamp = jiffies;
5789 	data->rpc_status = 0;
5790 	data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res, cred);
5791 	data->inode = nfs_igrab_and_active(inode);
5792 	if (data->inode) {
5793 		if (data->lr.roc) {
5794 			data->args.lr_args = &data->lr.arg;
5795 			data->res.lr_res = &data->lr.res;
5796 		}
5797 	} else if (data->lr.roc) {
5798 		pnfs_roc_release(&data->lr.arg, &data->lr.res, 0);
5799 		data->lr.roc = false;
5800 	}
5801 
5802 	task_setup_data.callback_data = data;
5803 	msg.rpc_argp = &data->args;
5804 	msg.rpc_resp = &data->res;
5805 	task = rpc_run_task(&task_setup_data);
5806 	if (IS_ERR(task))
5807 		return PTR_ERR(task);
5808 	if (!issync)
5809 		goto out;
5810 	status = nfs4_wait_for_completion_rpc_task(task);
5811 	if (status != 0)
5812 		goto out;
5813 	status = data->rpc_status;
5814 out:
5815 	rpc_put_task(task);
5816 	return status;
5817 }
5818 
5819 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
5820 {
5821 	struct nfs_server *server = NFS_SERVER(inode);
5822 	struct nfs4_exception exception = { };
5823 	int err;
5824 	do {
5825 		err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
5826 		trace_nfs4_delegreturn(inode, stateid, err);
5827 		switch (err) {
5828 			case -NFS4ERR_STALE_STATEID:
5829 			case -NFS4ERR_EXPIRED:
5830 			case 0:
5831 				return 0;
5832 		}
5833 		err = nfs4_handle_exception(server, err, &exception);
5834 	} while (exception.retry);
5835 	return err;
5836 }
5837 
5838 static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5839 {
5840 	struct inode *inode = state->inode;
5841 	struct nfs_server *server = NFS_SERVER(inode);
5842 	struct nfs_client *clp = server->nfs_client;
5843 	struct nfs_lockt_args arg = {
5844 		.fh = NFS_FH(inode),
5845 		.fl = request,
5846 	};
5847 	struct nfs_lockt_res res = {
5848 		.denied = request,
5849 	};
5850 	struct rpc_message msg = {
5851 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
5852 		.rpc_argp       = &arg,
5853 		.rpc_resp       = &res,
5854 		.rpc_cred	= state->owner->so_cred,
5855 	};
5856 	struct nfs4_lock_state *lsp;
5857 	int status;
5858 
5859 	arg.lock_owner.clientid = clp->cl_clientid;
5860 	status = nfs4_set_lock_state(state, request);
5861 	if (status != 0)
5862 		goto out;
5863 	lsp = request->fl_u.nfs4_fl.owner;
5864 	arg.lock_owner.id = lsp->ls_seqid.owner_id;
5865 	arg.lock_owner.s_dev = server->s_dev;
5866 	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
5867 	switch (status) {
5868 		case 0:
5869 			request->fl_type = F_UNLCK;
5870 			break;
5871 		case -NFS4ERR_DENIED:
5872 			status = 0;
5873 	}
5874 	request->fl_ops->fl_release_private(request);
5875 	request->fl_ops = NULL;
5876 out:
5877 	return status;
5878 }
5879 
5880 static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
5881 {
5882 	struct nfs4_exception exception = { };
5883 	int err;
5884 
5885 	do {
5886 		err = _nfs4_proc_getlk(state, cmd, request);
5887 		trace_nfs4_get_lock(request, state, cmd, err);
5888 		err = nfs4_handle_exception(NFS_SERVER(state->inode), err,
5889 				&exception);
5890 	} while (exception.retry);
5891 	return err;
5892 }
5893 
5894 struct nfs4_unlockdata {
5895 	struct nfs_locku_args arg;
5896 	struct nfs_locku_res res;
5897 	struct nfs4_lock_state *lsp;
5898 	struct nfs_open_context *ctx;
5899 	struct file_lock fl;
5900 	struct nfs_server *server;
5901 	unsigned long timestamp;
5902 };
5903 
5904 static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
5905 		struct nfs_open_context *ctx,
5906 		struct nfs4_lock_state *lsp,
5907 		struct nfs_seqid *seqid)
5908 {
5909 	struct nfs4_unlockdata *p;
5910 	struct inode *inode = lsp->ls_state->inode;
5911 
5912 	p = kzalloc(sizeof(*p), GFP_NOFS);
5913 	if (p == NULL)
5914 		return NULL;
5915 	p->arg.fh = NFS_FH(inode);
5916 	p->arg.fl = &p->fl;
5917 	p->arg.seqid = seqid;
5918 	p->res.seqid = seqid;
5919 	p->lsp = lsp;
5920 	atomic_inc(&lsp->ls_count);
5921 	/* Ensure we don't close file until we're done freeing locks! */
5922 	p->ctx = get_nfs_open_context(ctx);
5923 	memcpy(&p->fl, fl, sizeof(p->fl));
5924 	p->server = NFS_SERVER(inode);
5925 	return p;
5926 }
5927 
5928 static void nfs4_locku_release_calldata(void *data)
5929 {
5930 	struct nfs4_unlockdata *calldata = data;
5931 	nfs_free_seqid(calldata->arg.seqid);
5932 	nfs4_put_lock_state(calldata->lsp);
5933 	put_nfs_open_context(calldata->ctx);
5934 	kfree(calldata);
5935 }
5936 
5937 static void nfs4_locku_done(struct rpc_task *task, void *data)
5938 {
5939 	struct nfs4_unlockdata *calldata = data;
5940 
5941 	if (!nfs4_sequence_done(task, &calldata->res.seq_res))
5942 		return;
5943 	switch (task->tk_status) {
5944 		case 0:
5945 			renew_lease(calldata->server, calldata->timestamp);
5946 			locks_lock_inode_wait(calldata->lsp->ls_state->inode, &calldata->fl);
5947 			if (nfs4_update_lock_stateid(calldata->lsp,
5948 					&calldata->res.stateid))
5949 				break;
5950 		case -NFS4ERR_ADMIN_REVOKED:
5951 		case -NFS4ERR_EXPIRED:
5952 			nfs4_free_revoked_stateid(calldata->server,
5953 					&calldata->arg.stateid,
5954 					task->tk_msg.rpc_cred);
5955 		case -NFS4ERR_BAD_STATEID:
5956 		case -NFS4ERR_OLD_STATEID:
5957 		case -NFS4ERR_STALE_STATEID:
5958 			if (!nfs4_stateid_match(&calldata->arg.stateid,
5959 						&calldata->lsp->ls_stateid))
5960 				rpc_restart_call_prepare(task);
5961 			break;
5962 		default:
5963 			if (nfs4_async_handle_error(task, calldata->server,
5964 						    NULL, NULL) == -EAGAIN)
5965 				rpc_restart_call_prepare(task);
5966 	}
5967 	nfs_release_seqid(calldata->arg.seqid);
5968 }
5969 
5970 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
5971 {
5972 	struct nfs4_unlockdata *calldata = data;
5973 
5974 	if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
5975 		goto out_wait;
5976 	nfs4_stateid_copy(&calldata->arg.stateid, &calldata->lsp->ls_stateid);
5977 	if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
5978 		/* Note: exit _without_ running nfs4_locku_done */
5979 		goto out_no_action;
5980 	}
5981 	calldata->timestamp = jiffies;
5982 	if (nfs4_setup_sequence(calldata->server,
5983 				&calldata->arg.seq_args,
5984 				&calldata->res.seq_res,
5985 				task) != 0)
5986 		nfs_release_seqid(calldata->arg.seqid);
5987 	return;
5988 out_no_action:
5989 	task->tk_action = NULL;
5990 out_wait:
5991 	nfs4_sequence_done(task, &calldata->res.seq_res);
5992 }
5993 
5994 static const struct rpc_call_ops nfs4_locku_ops = {
5995 	.rpc_call_prepare = nfs4_locku_prepare,
5996 	.rpc_call_done = nfs4_locku_done,
5997 	.rpc_release = nfs4_locku_release_calldata,
5998 };
5999 
6000 static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
6001 		struct nfs_open_context *ctx,
6002 		struct nfs4_lock_state *lsp,
6003 		struct nfs_seqid *seqid)
6004 {
6005 	struct nfs4_unlockdata *data;
6006 	struct rpc_message msg = {
6007 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
6008 		.rpc_cred = ctx->cred,
6009 	};
6010 	struct rpc_task_setup task_setup_data = {
6011 		.rpc_client = NFS_CLIENT(lsp->ls_state->inode),
6012 		.rpc_message = &msg,
6013 		.callback_ops = &nfs4_locku_ops,
6014 		.workqueue = nfsiod_workqueue,
6015 		.flags = RPC_TASK_ASYNC,
6016 	};
6017 
6018 	nfs4_state_protect(NFS_SERVER(lsp->ls_state->inode)->nfs_client,
6019 		NFS_SP4_MACH_CRED_CLEANUP, &task_setup_data.rpc_client, &msg);
6020 
6021 	/* Ensure this is an unlock - when canceling a lock, the
6022 	 * canceled lock is passed in, and it won't be an unlock.
6023 	 */
6024 	fl->fl_type = F_UNLCK;
6025 
6026 	data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
6027 	if (data == NULL) {
6028 		nfs_free_seqid(seqid);
6029 		return ERR_PTR(-ENOMEM);
6030 	}
6031 
6032 	nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
6033 	msg.rpc_argp = &data->arg;
6034 	msg.rpc_resp = &data->res;
6035 	task_setup_data.callback_data = data;
6036 	return rpc_run_task(&task_setup_data);
6037 }
6038 
6039 static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
6040 {
6041 	struct inode *inode = state->inode;
6042 	struct nfs4_state_owner *sp = state->owner;
6043 	struct nfs_inode *nfsi = NFS_I(inode);
6044 	struct nfs_seqid *seqid;
6045 	struct nfs4_lock_state *lsp;
6046 	struct rpc_task *task;
6047 	struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
6048 	int status = 0;
6049 	unsigned char fl_flags = request->fl_flags;
6050 
6051 	status = nfs4_set_lock_state(state, request);
6052 	/* Unlock _before_ we do the RPC call */
6053 	request->fl_flags |= FL_EXISTS;
6054 	/* Exclude nfs_delegation_claim_locks() */
6055 	mutex_lock(&sp->so_delegreturn_mutex);
6056 	/* Exclude nfs4_reclaim_open_stateid() - note nesting! */
6057 	down_read(&nfsi->rwsem);
6058 	if (locks_lock_inode_wait(inode, request) == -ENOENT) {
6059 		up_read(&nfsi->rwsem);
6060 		mutex_unlock(&sp->so_delegreturn_mutex);
6061 		goto out;
6062 	}
6063 	up_read(&nfsi->rwsem);
6064 	mutex_unlock(&sp->so_delegreturn_mutex);
6065 	if (status != 0)
6066 		goto out;
6067 	/* Is this a delegated lock? */
6068 	lsp = request->fl_u.nfs4_fl.owner;
6069 	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
6070 		goto out;
6071 	alloc_seqid = NFS_SERVER(inode)->nfs_client->cl_mvops->alloc_seqid;
6072 	seqid = alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
6073 	status = -ENOMEM;
6074 	if (IS_ERR(seqid))
6075 		goto out;
6076 	task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
6077 	status = PTR_ERR(task);
6078 	if (IS_ERR(task))
6079 		goto out;
6080 	status = nfs4_wait_for_completion_rpc_task(task);
6081 	rpc_put_task(task);
6082 out:
6083 	request->fl_flags = fl_flags;
6084 	trace_nfs4_unlock(request, state, F_SETLK, status);
6085 	return status;
6086 }
6087 
6088 struct nfs4_lockdata {
6089 	struct nfs_lock_args arg;
6090 	struct nfs_lock_res res;
6091 	struct nfs4_lock_state *lsp;
6092 	struct nfs_open_context *ctx;
6093 	struct file_lock fl;
6094 	unsigned long timestamp;
6095 	int rpc_status;
6096 	int cancelled;
6097 	struct nfs_server *server;
6098 };
6099 
6100 static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
6101 		struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
6102 		gfp_t gfp_mask)
6103 {
6104 	struct nfs4_lockdata *p;
6105 	struct inode *inode = lsp->ls_state->inode;
6106 	struct nfs_server *server = NFS_SERVER(inode);
6107 	struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t);
6108 
6109 	p = kzalloc(sizeof(*p), gfp_mask);
6110 	if (p == NULL)
6111 		return NULL;
6112 
6113 	p->arg.fh = NFS_FH(inode);
6114 	p->arg.fl = &p->fl;
6115 	p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
6116 	if (IS_ERR(p->arg.open_seqid))
6117 		goto out_free;
6118 	alloc_seqid = server->nfs_client->cl_mvops->alloc_seqid;
6119 	p->arg.lock_seqid = alloc_seqid(&lsp->ls_seqid, gfp_mask);
6120 	if (IS_ERR(p->arg.lock_seqid))
6121 		goto out_free_seqid;
6122 	p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
6123 	p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
6124 	p->arg.lock_owner.s_dev = server->s_dev;
6125 	p->res.lock_seqid = p->arg.lock_seqid;
6126 	p->lsp = lsp;
6127 	p->server = server;
6128 	atomic_inc(&lsp->ls_count);
6129 	p->ctx = get_nfs_open_context(ctx);
6130 	get_file(fl->fl_file);
6131 	memcpy(&p->fl, fl, sizeof(p->fl));
6132 	return p;
6133 out_free_seqid:
6134 	nfs_free_seqid(p->arg.open_seqid);
6135 out_free:
6136 	kfree(p);
6137 	return NULL;
6138 }
6139 
6140 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6141 {
6142 	struct nfs4_lockdata *data = calldata;
6143 	struct nfs4_state *state = data->lsp->ls_state;
6144 
6145 	dprintk("%s: begin!\n", __func__);
6146 	if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
6147 		goto out_wait;
6148 	/* Do we need to do an open_to_lock_owner? */
6149 	if (!test_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags)) {
6150 		if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
6151 			goto out_release_lock_seqid;
6152 		}
6153 		nfs4_stateid_copy(&data->arg.open_stateid,
6154 				&state->open_stateid);
6155 		data->arg.new_lock_owner = 1;
6156 		data->res.open_seqid = data->arg.open_seqid;
6157 	} else {
6158 		data->arg.new_lock_owner = 0;
6159 		nfs4_stateid_copy(&data->arg.lock_stateid,
6160 				&data->lsp->ls_stateid);
6161 	}
6162 	if (!nfs4_valid_open_stateid(state)) {
6163 		data->rpc_status = -EBADF;
6164 		task->tk_action = NULL;
6165 		goto out_release_open_seqid;
6166 	}
6167 	data->timestamp = jiffies;
6168 	if (nfs4_setup_sequence(data->server,
6169 				&data->arg.seq_args,
6170 				&data->res.seq_res,
6171 				task) == 0)
6172 		return;
6173 out_release_open_seqid:
6174 	nfs_release_seqid(data->arg.open_seqid);
6175 out_release_lock_seqid:
6176 	nfs_release_seqid(data->arg.lock_seqid);
6177 out_wait:
6178 	nfs4_sequence_done(task, &data->res.seq_res);
6179 	dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
6180 }
6181 
6182 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
6183 {
6184 	struct nfs4_lockdata *data = calldata;
6185 	struct nfs4_lock_state *lsp = data->lsp;
6186 
6187 	dprintk("%s: begin!\n", __func__);
6188 
6189 	if (!nfs4_sequence_done(task, &data->res.seq_res))
6190 		return;
6191 
6192 	data->rpc_status = task->tk_status;
6193 	switch (task->tk_status) {
6194 	case 0:
6195 		renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)),
6196 				data->timestamp);
6197 		if (data->arg.new_lock) {
6198 			data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS);
6199 			if (locks_lock_inode_wait(lsp->ls_state->inode, &data->fl) < 0) {
6200 				rpc_restart_call_prepare(task);
6201 				break;
6202 			}
6203 		}
6204 		if (data->arg.new_lock_owner != 0) {
6205 			nfs_confirm_seqid(&lsp->ls_seqid, 0);
6206 			nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
6207 			set_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
6208 		} else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
6209 			rpc_restart_call_prepare(task);
6210 		break;
6211 	case -NFS4ERR_BAD_STATEID:
6212 	case -NFS4ERR_OLD_STATEID:
6213 	case -NFS4ERR_STALE_STATEID:
6214 	case -NFS4ERR_EXPIRED:
6215 		if (data->arg.new_lock_owner != 0) {
6216 			if (!nfs4_stateid_match(&data->arg.open_stateid,
6217 						&lsp->ls_state->open_stateid))
6218 				rpc_restart_call_prepare(task);
6219 		} else if (!nfs4_stateid_match(&data->arg.lock_stateid,
6220 						&lsp->ls_stateid))
6221 				rpc_restart_call_prepare(task);
6222 	}
6223 	dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
6224 }
6225 
6226 static void nfs4_lock_release(void *calldata)
6227 {
6228 	struct nfs4_lockdata *data = calldata;
6229 
6230 	dprintk("%s: begin!\n", __func__);
6231 	nfs_free_seqid(data->arg.open_seqid);
6232 	if (data->cancelled != 0) {
6233 		struct rpc_task *task;
6234 		task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
6235 				data->arg.lock_seqid);
6236 		if (!IS_ERR(task))
6237 			rpc_put_task_async(task);
6238 		dprintk("%s: cancelling lock!\n", __func__);
6239 	} else
6240 		nfs_free_seqid(data->arg.lock_seqid);
6241 	nfs4_put_lock_state(data->lsp);
6242 	put_nfs_open_context(data->ctx);
6243 	fput(data->fl.fl_file);
6244 	kfree(data);
6245 	dprintk("%s: done!\n", __func__);
6246 }
6247 
6248 static const struct rpc_call_ops nfs4_lock_ops = {
6249 	.rpc_call_prepare = nfs4_lock_prepare,
6250 	.rpc_call_done = nfs4_lock_done,
6251 	.rpc_release = nfs4_lock_release,
6252 };
6253 
6254 static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
6255 {
6256 	switch (error) {
6257 	case -NFS4ERR_ADMIN_REVOKED:
6258 	case -NFS4ERR_EXPIRED:
6259 	case -NFS4ERR_BAD_STATEID:
6260 		lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6261 		if (new_lock_owner != 0 ||
6262 		   test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
6263 			nfs4_schedule_stateid_recovery(server, lsp->ls_state);
6264 		break;
6265 	case -NFS4ERR_STALE_STATEID:
6266 		lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
6267 		nfs4_schedule_lease_recovery(server->nfs_client);
6268 	};
6269 }
6270 
6271 static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
6272 {
6273 	struct nfs4_lockdata *data;
6274 	struct rpc_task *task;
6275 	struct rpc_message msg = {
6276 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
6277 		.rpc_cred = state->owner->so_cred,
6278 	};
6279 	struct rpc_task_setup task_setup_data = {
6280 		.rpc_client = NFS_CLIENT(state->inode),
6281 		.rpc_message = &msg,
6282 		.callback_ops = &nfs4_lock_ops,
6283 		.workqueue = nfsiod_workqueue,
6284 		.flags = RPC_TASK_ASYNC,
6285 	};
6286 	int ret;
6287 
6288 	dprintk("%s: begin!\n", __func__);
6289 	data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
6290 			fl->fl_u.nfs4_fl.owner,
6291 			recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
6292 	if (data == NULL)
6293 		return -ENOMEM;
6294 	if (IS_SETLKW(cmd))
6295 		data->arg.block = 1;
6296 	nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
6297 	msg.rpc_argp = &data->arg;
6298 	msg.rpc_resp = &data->res;
6299 	task_setup_data.callback_data = data;
6300 	if (recovery_type > NFS_LOCK_NEW) {
6301 		if (recovery_type == NFS_LOCK_RECLAIM)
6302 			data->arg.reclaim = NFS_LOCK_RECLAIM;
6303 		nfs4_set_sequence_privileged(&data->arg.seq_args);
6304 	} else
6305 		data->arg.new_lock = 1;
6306 	task = rpc_run_task(&task_setup_data);
6307 	if (IS_ERR(task))
6308 		return PTR_ERR(task);
6309 	ret = nfs4_wait_for_completion_rpc_task(task);
6310 	if (ret == 0) {
6311 		ret = data->rpc_status;
6312 		if (ret)
6313 			nfs4_handle_setlk_error(data->server, data->lsp,
6314 					data->arg.new_lock_owner, ret);
6315 	} else
6316 		data->cancelled = 1;
6317 	rpc_put_task(task);
6318 	dprintk("%s: done, ret = %d!\n", __func__, ret);
6319 	trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
6320 	return ret;
6321 }
6322 
6323 static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
6324 {
6325 	struct nfs_server *server = NFS_SERVER(state->inode);
6326 	struct nfs4_exception exception = {
6327 		.inode = state->inode,
6328 	};
6329 	int err;
6330 
6331 	do {
6332 		/* Cache the lock if possible... */
6333 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6334 			return 0;
6335 		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
6336 		if (err != -NFS4ERR_DELAY)
6337 			break;
6338 		nfs4_handle_exception(server, err, &exception);
6339 	} while (exception.retry);
6340 	return err;
6341 }
6342 
6343 static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
6344 {
6345 	struct nfs_server *server = NFS_SERVER(state->inode);
6346 	struct nfs4_exception exception = {
6347 		.inode = state->inode,
6348 	};
6349 	int err;
6350 
6351 	err = nfs4_set_lock_state(state, request);
6352 	if (err != 0)
6353 		return err;
6354 	if (!recover_lost_locks) {
6355 		set_bit(NFS_LOCK_LOST, &request->fl_u.nfs4_fl.owner->ls_flags);
6356 		return 0;
6357 	}
6358 	do {
6359 		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
6360 			return 0;
6361 		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
6362 		switch (err) {
6363 		default:
6364 			goto out;
6365 		case -NFS4ERR_GRACE:
6366 		case -NFS4ERR_DELAY:
6367 			nfs4_handle_exception(server, err, &exception);
6368 			err = 0;
6369 		}
6370 	} while (exception.retry);
6371 out:
6372 	return err;
6373 }
6374 
6375 #if defined(CONFIG_NFS_V4_1)
6376 static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
6377 {
6378 	struct nfs4_lock_state *lsp;
6379 	int status;
6380 
6381 	status = nfs4_set_lock_state(state, request);
6382 	if (status != 0)
6383 		return status;
6384 	lsp = request->fl_u.nfs4_fl.owner;
6385 	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) ||
6386 	    test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
6387 		return 0;
6388 	status = nfs4_lock_expired(state, request);
6389 	return status;
6390 }
6391 #endif
6392 
6393 static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6394 {
6395 	struct nfs_inode *nfsi = NFS_I(state->inode);
6396 	struct nfs4_state_owner *sp = state->owner;
6397 	unsigned char fl_flags = request->fl_flags;
6398 	int status;
6399 
6400 	request->fl_flags |= FL_ACCESS;
6401 	status = locks_lock_inode_wait(state->inode, request);
6402 	if (status < 0)
6403 		goto out;
6404 	mutex_lock(&sp->so_delegreturn_mutex);
6405 	down_read(&nfsi->rwsem);
6406 	if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
6407 		/* Yes: cache locks! */
6408 		/* ...but avoid races with delegation recall... */
6409 		request->fl_flags = fl_flags & ~FL_SLEEP;
6410 		status = locks_lock_inode_wait(state->inode, request);
6411 		up_read(&nfsi->rwsem);
6412 		mutex_unlock(&sp->so_delegreturn_mutex);
6413 		goto out;
6414 	}
6415 	up_read(&nfsi->rwsem);
6416 	mutex_unlock(&sp->so_delegreturn_mutex);
6417 	status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
6418 out:
6419 	request->fl_flags = fl_flags;
6420 	return status;
6421 }
6422 
6423 static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6424 {
6425 	struct nfs4_exception exception = {
6426 		.state = state,
6427 		.inode = state->inode,
6428 	};
6429 	int err;
6430 
6431 	do {
6432 		err = _nfs4_proc_setlk(state, cmd, request);
6433 		if (err == -NFS4ERR_DENIED)
6434 			err = -EAGAIN;
6435 		err = nfs4_handle_exception(NFS_SERVER(state->inode),
6436 				err, &exception);
6437 	} while (exception.retry);
6438 	return err;
6439 }
6440 
6441 #define NFS4_LOCK_MINTIMEOUT (1 * HZ)
6442 #define NFS4_LOCK_MAXTIMEOUT (30 * HZ)
6443 
6444 static int
6445 nfs4_retry_setlk_simple(struct nfs4_state *state, int cmd,
6446 			struct file_lock *request)
6447 {
6448 	int		status = -ERESTARTSYS;
6449 	unsigned long	timeout = NFS4_LOCK_MINTIMEOUT;
6450 
6451 	while(!signalled()) {
6452 		status = nfs4_proc_setlk(state, cmd, request);
6453 		if ((status != -EAGAIN) || IS_SETLK(cmd))
6454 			break;
6455 		freezable_schedule_timeout_interruptible(timeout);
6456 		timeout *= 2;
6457 		timeout = min_t(unsigned long, NFS4_LOCK_MAXTIMEOUT, timeout);
6458 		status = -ERESTARTSYS;
6459 	}
6460 	return status;
6461 }
6462 
6463 #ifdef CONFIG_NFS_V4_1
6464 struct nfs4_lock_waiter {
6465 	struct task_struct	*task;
6466 	struct inode		*inode;
6467 	struct nfs_lowner	*owner;
6468 	bool			notified;
6469 };
6470 
6471 static int
6472 nfs4_wake_lock_waiter(wait_queue_t *wait, unsigned int mode, int flags, void *key)
6473 {
6474 	int ret;
6475 	struct cb_notify_lock_args *cbnl = key;
6476 	struct nfs4_lock_waiter	*waiter	= wait->private;
6477 	struct nfs_lowner	*lowner = &cbnl->cbnl_owner,
6478 				*wowner = waiter->owner;
6479 
6480 	/* Only wake if the callback was for the same owner */
6481 	if (lowner->clientid != wowner->clientid ||
6482 	    lowner->id != wowner->id		 ||
6483 	    lowner->s_dev != wowner->s_dev)
6484 		return 0;
6485 
6486 	/* Make sure it's for the right inode */
6487 	if (nfs_compare_fh(NFS_FH(waiter->inode), &cbnl->cbnl_fh))
6488 		return 0;
6489 
6490 	waiter->notified = true;
6491 
6492 	/* override "private" so we can use default_wake_function */
6493 	wait->private = waiter->task;
6494 	ret = autoremove_wake_function(wait, mode, flags, key);
6495 	wait->private = waiter;
6496 	return ret;
6497 }
6498 
6499 static int
6500 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6501 {
6502 	int status = -ERESTARTSYS;
6503 	unsigned long flags;
6504 	struct nfs4_lock_state *lsp = request->fl_u.nfs4_fl.owner;
6505 	struct nfs_server *server = NFS_SERVER(state->inode);
6506 	struct nfs_client *clp = server->nfs_client;
6507 	wait_queue_head_t *q = &clp->cl_lock_waitq;
6508 	struct nfs_lowner owner = { .clientid = clp->cl_clientid,
6509 				    .id = lsp->ls_seqid.owner_id,
6510 				    .s_dev = server->s_dev };
6511 	struct nfs4_lock_waiter waiter = { .task  = current,
6512 					   .inode = state->inode,
6513 					   .owner = &owner,
6514 					   .notified = false };
6515 	wait_queue_t wait;
6516 
6517 	/* Don't bother with waitqueue if we don't expect a callback */
6518 	if (!test_bit(NFS_STATE_MAY_NOTIFY_LOCK, &state->flags))
6519 		return nfs4_retry_setlk_simple(state, cmd, request);
6520 
6521 	init_wait(&wait);
6522 	wait.private = &waiter;
6523 	wait.func = nfs4_wake_lock_waiter;
6524 	add_wait_queue(q, &wait);
6525 
6526 	while(!signalled()) {
6527 		status = nfs4_proc_setlk(state, cmd, request);
6528 		if ((status != -EAGAIN) || IS_SETLK(cmd))
6529 			break;
6530 
6531 		status = -ERESTARTSYS;
6532 		spin_lock_irqsave(&q->lock, flags);
6533 		if (waiter.notified) {
6534 			spin_unlock_irqrestore(&q->lock, flags);
6535 			continue;
6536 		}
6537 		set_current_state(TASK_INTERRUPTIBLE);
6538 		spin_unlock_irqrestore(&q->lock, flags);
6539 
6540 		freezable_schedule_timeout_interruptible(NFS4_LOCK_MAXTIMEOUT);
6541 	}
6542 
6543 	finish_wait(q, &wait);
6544 	return status;
6545 }
6546 #else /* !CONFIG_NFS_V4_1 */
6547 static inline int
6548 nfs4_retry_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
6549 {
6550 	return nfs4_retry_setlk_simple(state, cmd, request);
6551 }
6552 #endif
6553 
6554 static int
6555 nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
6556 {
6557 	struct nfs_open_context *ctx;
6558 	struct nfs4_state *state;
6559 	int status;
6560 
6561 	/* verify open state */
6562 	ctx = nfs_file_open_context(filp);
6563 	state = ctx->state;
6564 
6565 	if (request->fl_start < 0 || request->fl_end < 0)
6566 		return -EINVAL;
6567 
6568 	if (IS_GETLK(cmd)) {
6569 		if (state != NULL)
6570 			return nfs4_proc_getlk(state, F_GETLK, request);
6571 		return 0;
6572 	}
6573 
6574 	if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
6575 		return -EINVAL;
6576 
6577 	if (request->fl_type == F_UNLCK) {
6578 		if (state != NULL)
6579 			return nfs4_proc_unlck(state, cmd, request);
6580 		return 0;
6581 	}
6582 
6583 	if (state == NULL)
6584 		return -ENOLCK;
6585 
6586 	if ((request->fl_flags & FL_POSIX) &&
6587 	    !test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
6588 		return -ENOLCK;
6589 
6590 	/*
6591 	 * Don't rely on the VFS having checked the file open mode,
6592 	 * since it won't do this for flock() locks.
6593 	 */
6594 	switch (request->fl_type) {
6595 	case F_RDLCK:
6596 		if (!(filp->f_mode & FMODE_READ))
6597 			return -EBADF;
6598 		break;
6599 	case F_WRLCK:
6600 		if (!(filp->f_mode & FMODE_WRITE))
6601 			return -EBADF;
6602 	}
6603 
6604 	status = nfs4_set_lock_state(state, request);
6605 	if (status != 0)
6606 		return status;
6607 
6608 	return nfs4_retry_setlk(state, cmd, request);
6609 }
6610 
6611 int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
6612 {
6613 	struct nfs_server *server = NFS_SERVER(state->inode);
6614 	int err;
6615 
6616 	err = nfs4_set_lock_state(state, fl);
6617 	if (err != 0)
6618 		return err;
6619 	err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
6620 	return nfs4_handle_delegation_recall_error(server, state, stateid, err);
6621 }
6622 
6623 struct nfs_release_lockowner_data {
6624 	struct nfs4_lock_state *lsp;
6625 	struct nfs_server *server;
6626 	struct nfs_release_lockowner_args args;
6627 	struct nfs_release_lockowner_res res;
6628 	unsigned long timestamp;
6629 };
6630 
6631 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
6632 {
6633 	struct nfs_release_lockowner_data *data = calldata;
6634 	struct nfs_server *server = data->server;
6635 	nfs40_setup_sequence(server->nfs_client->cl_slot_tbl,
6636 			     &data->args.seq_args, &data->res.seq_res, task);
6637 	data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6638 	data->timestamp = jiffies;
6639 }
6640 
6641 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
6642 {
6643 	struct nfs_release_lockowner_data *data = calldata;
6644 	struct nfs_server *server = data->server;
6645 
6646 	nfs40_sequence_done(task, &data->res.seq_res);
6647 
6648 	switch (task->tk_status) {
6649 	case 0:
6650 		renew_lease(server, data->timestamp);
6651 		break;
6652 	case -NFS4ERR_STALE_CLIENTID:
6653 	case -NFS4ERR_EXPIRED:
6654 		nfs4_schedule_lease_recovery(server->nfs_client);
6655 		break;
6656 	case -NFS4ERR_LEASE_MOVED:
6657 	case -NFS4ERR_DELAY:
6658 		if (nfs4_async_handle_error(task, server,
6659 					    NULL, NULL) == -EAGAIN)
6660 			rpc_restart_call_prepare(task);
6661 	}
6662 }
6663 
6664 static void nfs4_release_lockowner_release(void *calldata)
6665 {
6666 	struct nfs_release_lockowner_data *data = calldata;
6667 	nfs4_free_lock_state(data->server, data->lsp);
6668 	kfree(calldata);
6669 }
6670 
6671 static const struct rpc_call_ops nfs4_release_lockowner_ops = {
6672 	.rpc_call_prepare = nfs4_release_lockowner_prepare,
6673 	.rpc_call_done = nfs4_release_lockowner_done,
6674 	.rpc_release = nfs4_release_lockowner_release,
6675 };
6676 
6677 static void
6678 nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
6679 {
6680 	struct nfs_release_lockowner_data *data;
6681 	struct rpc_message msg = {
6682 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
6683 	};
6684 
6685 	if (server->nfs_client->cl_mvops->minor_version != 0)
6686 		return;
6687 
6688 	data = kmalloc(sizeof(*data), GFP_NOFS);
6689 	if (!data)
6690 		return;
6691 	data->lsp = lsp;
6692 	data->server = server;
6693 	data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
6694 	data->args.lock_owner.id = lsp->ls_seqid.owner_id;
6695 	data->args.lock_owner.s_dev = server->s_dev;
6696 
6697 	msg.rpc_argp = &data->args;
6698 	msg.rpc_resp = &data->res;
6699 	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
6700 	rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
6701 }
6702 
6703 #define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"
6704 
6705 static int nfs4_xattr_set_nfs4_acl(const struct xattr_handler *handler,
6706 				   struct dentry *unused, struct inode *inode,
6707 				   const char *key, const void *buf,
6708 				   size_t buflen, int flags)
6709 {
6710 	return nfs4_proc_set_acl(inode, buf, buflen);
6711 }
6712 
6713 static int nfs4_xattr_get_nfs4_acl(const struct xattr_handler *handler,
6714 				   struct dentry *unused, struct inode *inode,
6715 				   const char *key, void *buf, size_t buflen)
6716 {
6717 	return nfs4_proc_get_acl(inode, buf, buflen);
6718 }
6719 
6720 static bool nfs4_xattr_list_nfs4_acl(struct dentry *dentry)
6721 {
6722 	return nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)));
6723 }
6724 
6725 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
6726 
6727 static int nfs4_xattr_set_nfs4_label(const struct xattr_handler *handler,
6728 				     struct dentry *unused, struct inode *inode,
6729 				     const char *key, const void *buf,
6730 				     size_t buflen, int flags)
6731 {
6732 	if (security_ismaclabel(key))
6733 		return nfs4_set_security_label(inode, buf, buflen);
6734 
6735 	return -EOPNOTSUPP;
6736 }
6737 
6738 static int nfs4_xattr_get_nfs4_label(const struct xattr_handler *handler,
6739 				     struct dentry *unused, struct inode *inode,
6740 				     const char *key, void *buf, size_t buflen)
6741 {
6742 	if (security_ismaclabel(key))
6743 		return nfs4_get_security_label(inode, buf, buflen);
6744 	return -EOPNOTSUPP;
6745 }
6746 
6747 static ssize_t
6748 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6749 {
6750 	int len = 0;
6751 
6752 	if (nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) {
6753 		len = security_inode_listsecurity(inode, list, list_len);
6754 		if (list_len && len > list_len)
6755 			return -ERANGE;
6756 	}
6757 	return len;
6758 }
6759 
6760 static const struct xattr_handler nfs4_xattr_nfs4_label_handler = {
6761 	.prefix = XATTR_SECURITY_PREFIX,
6762 	.get	= nfs4_xattr_get_nfs4_label,
6763 	.set	= nfs4_xattr_set_nfs4_label,
6764 };
6765 
6766 #else
6767 
6768 static ssize_t
6769 nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)
6770 {
6771 	return 0;
6772 }
6773 
6774 #endif
6775 
6776 /*
6777  * nfs_fhget will use either the mounted_on_fileid or the fileid
6778  */
6779 static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
6780 {
6781 	if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
6782 	       (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
6783 	      (fattr->valid & NFS_ATTR_FATTR_FSID) &&
6784 	      (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
6785 		return;
6786 
6787 	fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
6788 		NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
6789 	fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
6790 	fattr->nlink = 2;
6791 }
6792 
6793 static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6794 				   const struct qstr *name,
6795 				   struct nfs4_fs_locations *fs_locations,
6796 				   struct page *page)
6797 {
6798 	struct nfs_server *server = NFS_SERVER(dir);
6799 	u32 bitmask[3] = {
6800 		[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6801 	};
6802 	struct nfs4_fs_locations_arg args = {
6803 		.dir_fh = NFS_FH(dir),
6804 		.name = name,
6805 		.page = page,
6806 		.bitmask = bitmask,
6807 	};
6808 	struct nfs4_fs_locations_res res = {
6809 		.fs_locations = fs_locations,
6810 	};
6811 	struct rpc_message msg = {
6812 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6813 		.rpc_argp = &args,
6814 		.rpc_resp = &res,
6815 	};
6816 	int status;
6817 
6818 	dprintk("%s: start\n", __func__);
6819 
6820 	/* Ask for the fileid of the absent filesystem if mounted_on_fileid
6821 	 * is not supported */
6822 	if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
6823 		bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
6824 	else
6825 		bitmask[0] |= FATTR4_WORD0_FILEID;
6826 
6827 	nfs_fattr_init(&fs_locations->fattr);
6828 	fs_locations->server = server;
6829 	fs_locations->nlocations = 0;
6830 	status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
6831 	dprintk("%s: returned status = %d\n", __func__, status);
6832 	return status;
6833 }
6834 
6835 int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
6836 			   const struct qstr *name,
6837 			   struct nfs4_fs_locations *fs_locations,
6838 			   struct page *page)
6839 {
6840 	struct nfs4_exception exception = { };
6841 	int err;
6842 	do {
6843 		err = _nfs4_proc_fs_locations(client, dir, name,
6844 				fs_locations, page);
6845 		trace_nfs4_get_fs_locations(dir, name, err);
6846 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
6847 				&exception);
6848 	} while (exception.retry);
6849 	return err;
6850 }
6851 
6852 /*
6853  * This operation also signals the server that this client is
6854  * performing migration recovery.  The server can stop returning
6855  * NFS4ERR_LEASE_MOVED to this client.  A RENEW operation is
6856  * appended to this compound to identify the client ID which is
6857  * performing recovery.
6858  */
6859 static int _nfs40_proc_get_locations(struct inode *inode,
6860 				     struct nfs4_fs_locations *locations,
6861 				     struct page *page, struct rpc_cred *cred)
6862 {
6863 	struct nfs_server *server = NFS_SERVER(inode);
6864 	struct rpc_clnt *clnt = server->client;
6865 	u32 bitmask[2] = {
6866 		[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6867 	};
6868 	struct nfs4_fs_locations_arg args = {
6869 		.clientid	= server->nfs_client->cl_clientid,
6870 		.fh		= NFS_FH(inode),
6871 		.page		= page,
6872 		.bitmask	= bitmask,
6873 		.migration	= 1,		/* skip LOOKUP */
6874 		.renew		= 1,		/* append RENEW */
6875 	};
6876 	struct nfs4_fs_locations_res res = {
6877 		.fs_locations	= locations,
6878 		.migration	= 1,
6879 		.renew		= 1,
6880 	};
6881 	struct rpc_message msg = {
6882 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6883 		.rpc_argp	= &args,
6884 		.rpc_resp	= &res,
6885 		.rpc_cred	= cred,
6886 	};
6887 	unsigned long now = jiffies;
6888 	int status;
6889 
6890 	nfs_fattr_init(&locations->fattr);
6891 	locations->server = server;
6892 	locations->nlocations = 0;
6893 
6894 	nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6895 	nfs4_set_sequence_privileged(&args.seq_args);
6896 	status = nfs4_call_sync_sequence(clnt, server, &msg,
6897 					&args.seq_args, &res.seq_res);
6898 	if (status)
6899 		return status;
6900 
6901 	renew_lease(server, now);
6902 	return 0;
6903 }
6904 
6905 #ifdef CONFIG_NFS_V4_1
6906 
6907 /*
6908  * This operation also signals the server that this client is
6909  * performing migration recovery.  The server can stop asserting
6910  * SEQ4_STATUS_LEASE_MOVED for this client.  The client ID
6911  * performing this operation is identified in the SEQUENCE
6912  * operation in this compound.
6913  *
6914  * When the client supports GETATTR(fs_locations_info), it can
6915  * be plumbed in here.
6916  */
6917 static int _nfs41_proc_get_locations(struct inode *inode,
6918 				     struct nfs4_fs_locations *locations,
6919 				     struct page *page, struct rpc_cred *cred)
6920 {
6921 	struct nfs_server *server = NFS_SERVER(inode);
6922 	struct rpc_clnt *clnt = server->client;
6923 	u32 bitmask[2] = {
6924 		[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
6925 	};
6926 	struct nfs4_fs_locations_arg args = {
6927 		.fh		= NFS_FH(inode),
6928 		.page		= page,
6929 		.bitmask	= bitmask,
6930 		.migration	= 1,		/* skip LOOKUP */
6931 	};
6932 	struct nfs4_fs_locations_res res = {
6933 		.fs_locations	= locations,
6934 		.migration	= 1,
6935 	};
6936 	struct rpc_message msg = {
6937 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
6938 		.rpc_argp	= &args,
6939 		.rpc_resp	= &res,
6940 		.rpc_cred	= cred,
6941 	};
6942 	int status;
6943 
6944 	nfs_fattr_init(&locations->fattr);
6945 	locations->server = server;
6946 	locations->nlocations = 0;
6947 
6948 	nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
6949 	nfs4_set_sequence_privileged(&args.seq_args);
6950 	status = nfs4_call_sync_sequence(clnt, server, &msg,
6951 					&args.seq_args, &res.seq_res);
6952 	if (status == NFS4_OK &&
6953 	    res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
6954 		status = -NFS4ERR_LEASE_MOVED;
6955 	return status;
6956 }
6957 
6958 #endif	/* CONFIG_NFS_V4_1 */
6959 
6960 /**
6961  * nfs4_proc_get_locations - discover locations for a migrated FSID
6962  * @inode: inode on FSID that is migrating
6963  * @locations: result of query
6964  * @page: buffer
6965  * @cred: credential to use for this operation
6966  *
6967  * Returns NFS4_OK on success, a negative NFS4ERR status code if the
6968  * operation failed, or a negative errno if a local error occurred.
6969  *
6970  * On success, "locations" is filled in, but if the server has
6971  * no locations information, NFS_ATTR_FATTR_V4_LOCATIONS is not
6972  * asserted.
6973  *
6974  * -NFS4ERR_LEASE_MOVED is returned if the server still has leases
6975  * from this client that require migration recovery.
6976  */
6977 int nfs4_proc_get_locations(struct inode *inode,
6978 			    struct nfs4_fs_locations *locations,
6979 			    struct page *page, struct rpc_cred *cred)
6980 {
6981 	struct nfs_server *server = NFS_SERVER(inode);
6982 	struct nfs_client *clp = server->nfs_client;
6983 	const struct nfs4_mig_recovery_ops *ops =
6984 					clp->cl_mvops->mig_recovery_ops;
6985 	struct nfs4_exception exception = { };
6986 	int status;
6987 
6988 	dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
6989 		(unsigned long long)server->fsid.major,
6990 		(unsigned long long)server->fsid.minor,
6991 		clp->cl_hostname);
6992 	nfs_display_fhandle(NFS_FH(inode), __func__);
6993 
6994 	do {
6995 		status = ops->get_locations(inode, locations, page, cred);
6996 		if (status != -NFS4ERR_DELAY)
6997 			break;
6998 		nfs4_handle_exception(server, status, &exception);
6999 	} while (exception.retry);
7000 	return status;
7001 }
7002 
7003 /*
7004  * This operation also signals the server that this client is
7005  * performing "lease moved" recovery.  The server can stop
7006  * returning NFS4ERR_LEASE_MOVED to this client.  A RENEW operation
7007  * is appended to this compound to identify the client ID which is
7008  * performing recovery.
7009  */
7010 static int _nfs40_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7011 {
7012 	struct nfs_server *server = NFS_SERVER(inode);
7013 	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
7014 	struct rpc_clnt *clnt = server->client;
7015 	struct nfs4_fsid_present_arg args = {
7016 		.fh		= NFS_FH(inode),
7017 		.clientid	= clp->cl_clientid,
7018 		.renew		= 1,		/* append RENEW */
7019 	};
7020 	struct nfs4_fsid_present_res res = {
7021 		.renew		= 1,
7022 	};
7023 	struct rpc_message msg = {
7024 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7025 		.rpc_argp	= &args,
7026 		.rpc_resp	= &res,
7027 		.rpc_cred	= cred,
7028 	};
7029 	unsigned long now = jiffies;
7030 	int status;
7031 
7032 	res.fh = nfs_alloc_fhandle();
7033 	if (res.fh == NULL)
7034 		return -ENOMEM;
7035 
7036 	nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7037 	nfs4_set_sequence_privileged(&args.seq_args);
7038 	status = nfs4_call_sync_sequence(clnt, server, &msg,
7039 						&args.seq_args, &res.seq_res);
7040 	nfs_free_fhandle(res.fh);
7041 	if (status)
7042 		return status;
7043 
7044 	do_renew_lease(clp, now);
7045 	return 0;
7046 }
7047 
7048 #ifdef CONFIG_NFS_V4_1
7049 
7050 /*
7051  * This operation also signals the server that this client is
7052  * performing "lease moved" recovery.  The server can stop asserting
7053  * SEQ4_STATUS_LEASE_MOVED for this client.  The client ID performing
7054  * this operation is identified in the SEQUENCE operation in this
7055  * compound.
7056  */
7057 static int _nfs41_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7058 {
7059 	struct nfs_server *server = NFS_SERVER(inode);
7060 	struct rpc_clnt *clnt = server->client;
7061 	struct nfs4_fsid_present_arg args = {
7062 		.fh		= NFS_FH(inode),
7063 	};
7064 	struct nfs4_fsid_present_res res = {
7065 	};
7066 	struct rpc_message msg = {
7067 		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_FSID_PRESENT],
7068 		.rpc_argp	= &args,
7069 		.rpc_resp	= &res,
7070 		.rpc_cred	= cred,
7071 	};
7072 	int status;
7073 
7074 	res.fh = nfs_alloc_fhandle();
7075 	if (res.fh == NULL)
7076 		return -ENOMEM;
7077 
7078 	nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
7079 	nfs4_set_sequence_privileged(&args.seq_args);
7080 	status = nfs4_call_sync_sequence(clnt, server, &msg,
7081 						&args.seq_args, &res.seq_res);
7082 	nfs_free_fhandle(res.fh);
7083 	if (status == NFS4_OK &&
7084 	    res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
7085 		status = -NFS4ERR_LEASE_MOVED;
7086 	return status;
7087 }
7088 
7089 #endif	/* CONFIG_NFS_V4_1 */
7090 
7091 /**
7092  * nfs4_proc_fsid_present - Is this FSID present or absent on server?
7093  * @inode: inode on FSID to check
7094  * @cred: credential to use for this operation
7095  *
7096  * Server indicates whether the FSID is present, moved, or not
7097  * recognized.  This operation is necessary to clear a LEASE_MOVED
7098  * condition for this client ID.
7099  *
7100  * Returns NFS4_OK if the FSID is present on this server,
7101  * -NFS4ERR_MOVED if the FSID is no longer present, a negative
7102  *  NFS4ERR code if some error occurred on the server, or a
7103  *  negative errno if a local failure occurred.
7104  */
7105 int nfs4_proc_fsid_present(struct inode *inode, struct rpc_cred *cred)
7106 {
7107 	struct nfs_server *server = NFS_SERVER(inode);
7108 	struct nfs_client *clp = server->nfs_client;
7109 	const struct nfs4_mig_recovery_ops *ops =
7110 					clp->cl_mvops->mig_recovery_ops;
7111 	struct nfs4_exception exception = { };
7112 	int status;
7113 
7114 	dprintk("%s: FSID %llx:%llx on \"%s\"\n", __func__,
7115 		(unsigned long long)server->fsid.major,
7116 		(unsigned long long)server->fsid.minor,
7117 		clp->cl_hostname);
7118 	nfs_display_fhandle(NFS_FH(inode), __func__);
7119 
7120 	do {
7121 		status = ops->fsid_present(inode, cred);
7122 		if (status != -NFS4ERR_DELAY)
7123 			break;
7124 		nfs4_handle_exception(server, status, &exception);
7125 	} while (exception.retry);
7126 	return status;
7127 }
7128 
7129 /**
7130  * If 'use_integrity' is true and the state managment nfs_client
7131  * cl_rpcclient is using krb5i/p, use the integrity protected cl_rpcclient
7132  * and the machine credential as per RFC3530bis and RFC5661 Security
7133  * Considerations sections. Otherwise, just use the user cred with the
7134  * filesystem's rpc_client.
7135  */
7136 static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors, bool use_integrity)
7137 {
7138 	int status;
7139 	struct nfs4_secinfo_arg args = {
7140 		.dir_fh = NFS_FH(dir),
7141 		.name   = name,
7142 	};
7143 	struct nfs4_secinfo_res res = {
7144 		.flavors     = flavors,
7145 	};
7146 	struct rpc_message msg = {
7147 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
7148 		.rpc_argp = &args,
7149 		.rpc_resp = &res,
7150 	};
7151 	struct rpc_clnt *clnt = NFS_SERVER(dir)->client;
7152 	struct rpc_cred *cred = NULL;
7153 
7154 	if (use_integrity) {
7155 		clnt = NFS_SERVER(dir)->nfs_client->cl_rpcclient;
7156 		cred = nfs4_get_clid_cred(NFS_SERVER(dir)->nfs_client);
7157 		msg.rpc_cred = cred;
7158 	}
7159 
7160 	dprintk("NFS call  secinfo %s\n", name->name);
7161 
7162 	nfs4_state_protect(NFS_SERVER(dir)->nfs_client,
7163 		NFS_SP4_MACH_CRED_SECINFO, &clnt, &msg);
7164 
7165 	status = nfs4_call_sync(clnt, NFS_SERVER(dir), &msg, &args.seq_args,
7166 				&res.seq_res, 0);
7167 	dprintk("NFS reply  secinfo: %d\n", status);
7168 
7169 	if (cred)
7170 		put_rpccred(cred);
7171 
7172 	return status;
7173 }
7174 
7175 int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
7176 		      struct nfs4_secinfo_flavors *flavors)
7177 {
7178 	struct nfs4_exception exception = { };
7179 	int err;
7180 	do {
7181 		err = -NFS4ERR_WRONGSEC;
7182 
7183 		/* try to use integrity protection with machine cred */
7184 		if (_nfs4_is_integrity_protected(NFS_SERVER(dir)->nfs_client))
7185 			err = _nfs4_proc_secinfo(dir, name, flavors, true);
7186 
7187 		/*
7188 		 * if unable to use integrity protection, or SECINFO with
7189 		 * integrity protection returns NFS4ERR_WRONGSEC (which is
7190 		 * disallowed by spec, but exists in deployed servers) use
7191 		 * the current filesystem's rpc_client and the user cred.
7192 		 */
7193 		if (err == -NFS4ERR_WRONGSEC)
7194 			err = _nfs4_proc_secinfo(dir, name, flavors, false);
7195 
7196 		trace_nfs4_secinfo(dir, name, err);
7197 		err = nfs4_handle_exception(NFS_SERVER(dir), err,
7198 				&exception);
7199 	} while (exception.retry);
7200 	return err;
7201 }
7202 
7203 #ifdef CONFIG_NFS_V4_1
7204 /*
7205  * Check the exchange flags returned by the server for invalid flags, having
7206  * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
7207  * DS flags set.
7208  */
7209 static int nfs4_check_cl_exchange_flags(u32 flags)
7210 {
7211 	if (flags & ~EXCHGID4_FLAG_MASK_R)
7212 		goto out_inval;
7213 	if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
7214 	    (flags & EXCHGID4_FLAG_USE_NON_PNFS))
7215 		goto out_inval;
7216 	if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
7217 		goto out_inval;
7218 	return NFS_OK;
7219 out_inval:
7220 	return -NFS4ERR_INVAL;
7221 }
7222 
7223 static bool
7224 nfs41_same_server_scope(struct nfs41_server_scope *a,
7225 			struct nfs41_server_scope *b)
7226 {
7227 	if (a->server_scope_sz == b->server_scope_sz &&
7228 	    memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
7229 		return true;
7230 
7231 	return false;
7232 }
7233 
7234 static void
7235 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
7236 {
7237 }
7238 
7239 static const struct rpc_call_ops nfs4_bind_one_conn_to_session_ops = {
7240 	.rpc_call_done =  &nfs4_bind_one_conn_to_session_done,
7241 };
7242 
7243 /*
7244  * nfs4_proc_bind_one_conn_to_session()
7245  *
7246  * The 4.1 client currently uses the same TCP connection for the
7247  * fore and backchannel.
7248  */
7249 static
7250 int nfs4_proc_bind_one_conn_to_session(struct rpc_clnt *clnt,
7251 		struct rpc_xprt *xprt,
7252 		struct nfs_client *clp,
7253 		struct rpc_cred *cred)
7254 {
7255 	int status;
7256 	struct nfs41_bind_conn_to_session_args args = {
7257 		.client = clp,
7258 		.dir = NFS4_CDFC4_FORE_OR_BOTH,
7259 	};
7260 	struct nfs41_bind_conn_to_session_res res;
7261 	struct rpc_message msg = {
7262 		.rpc_proc =
7263 			&nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
7264 		.rpc_argp = &args,
7265 		.rpc_resp = &res,
7266 		.rpc_cred = cred,
7267 	};
7268 	struct rpc_task_setup task_setup_data = {
7269 		.rpc_client = clnt,
7270 		.rpc_xprt = xprt,
7271 		.callback_ops = &nfs4_bind_one_conn_to_session_ops,
7272 		.rpc_message = &msg,
7273 		.flags = RPC_TASK_TIMEOUT,
7274 	};
7275 	struct rpc_task *task;
7276 
7277 	dprintk("--> %s\n", __func__);
7278 
7279 	nfs4_copy_sessionid(&args.sessionid, &clp->cl_session->sess_id);
7280 	if (!(clp->cl_session->flags & SESSION4_BACK_CHAN))
7281 		args.dir = NFS4_CDFC4_FORE;
7282 
7283 	/* Do not set the backchannel flag unless this is clnt->cl_xprt */
7284 	if (xprt != rcu_access_pointer(clnt->cl_xprt))
7285 		args.dir = NFS4_CDFC4_FORE;
7286 
7287 	task = rpc_run_task(&task_setup_data);
7288 	if (!IS_ERR(task)) {
7289 		status = task->tk_status;
7290 		rpc_put_task(task);
7291 	} else
7292 		status = PTR_ERR(task);
7293 	trace_nfs4_bind_conn_to_session(clp, status);
7294 	if (status == 0) {
7295 		if (memcmp(res.sessionid.data,
7296 		    clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
7297 			dprintk("NFS: %s: Session ID mismatch\n", __func__);
7298 			status = -EIO;
7299 			goto out;
7300 		}
7301 		if ((res.dir & args.dir) != res.dir || res.dir == 0) {
7302 			dprintk("NFS: %s: Unexpected direction from server\n",
7303 				__func__);
7304 			status = -EIO;
7305 			goto out;
7306 		}
7307 		if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
7308 			dprintk("NFS: %s: Server returned RDMA mode = true\n",
7309 				__func__);
7310 			status = -EIO;
7311 			goto out;
7312 		}
7313 	}
7314 out:
7315 	dprintk("<-- %s status= %d\n", __func__, status);
7316 	return status;
7317 }
7318 
7319 struct rpc_bind_conn_calldata {
7320 	struct nfs_client *clp;
7321 	struct rpc_cred *cred;
7322 };
7323 
7324 static int
7325 nfs4_proc_bind_conn_to_session_callback(struct rpc_clnt *clnt,
7326 		struct rpc_xprt *xprt,
7327 		void *calldata)
7328 {
7329 	struct rpc_bind_conn_calldata *p = calldata;
7330 
7331 	return nfs4_proc_bind_one_conn_to_session(clnt, xprt, p->clp, p->cred);
7332 }
7333 
7334 int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
7335 {
7336 	struct rpc_bind_conn_calldata data = {
7337 		.clp = clp,
7338 		.cred = cred,
7339 	};
7340 	return rpc_clnt_iterate_for_each_xprt(clp->cl_rpcclient,
7341 			nfs4_proc_bind_conn_to_session_callback, &data);
7342 }
7343 
7344 /*
7345  * Minimum set of SP4_MACH_CRED operations from RFC 5661 in the enforce map
7346  * and operations we'd like to see to enable certain features in the allow map
7347  */
7348 static const struct nfs41_state_protection nfs4_sp4_mach_cred_request = {
7349 	.how = SP4_MACH_CRED,
7350 	.enforce.u.words = {
7351 		[1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7352 		      1 << (OP_EXCHANGE_ID - 32) |
7353 		      1 << (OP_CREATE_SESSION - 32) |
7354 		      1 << (OP_DESTROY_SESSION - 32) |
7355 		      1 << (OP_DESTROY_CLIENTID - 32)
7356 	},
7357 	.allow.u.words = {
7358 		[0] = 1 << (OP_CLOSE) |
7359 		      1 << (OP_OPEN_DOWNGRADE) |
7360 		      1 << (OP_LOCKU) |
7361 		      1 << (OP_DELEGRETURN) |
7362 		      1 << (OP_COMMIT),
7363 		[1] = 1 << (OP_SECINFO - 32) |
7364 		      1 << (OP_SECINFO_NO_NAME - 32) |
7365 		      1 << (OP_LAYOUTRETURN - 32) |
7366 		      1 << (OP_TEST_STATEID - 32) |
7367 		      1 << (OP_FREE_STATEID - 32) |
7368 		      1 << (OP_WRITE - 32)
7369 	}
7370 };
7371 
7372 /*
7373  * Select the state protection mode for client `clp' given the server results
7374  * from exchange_id in `sp'.
7375  *
7376  * Returns 0 on success, negative errno otherwise.
7377  */
7378 static int nfs4_sp4_select_mode(struct nfs_client *clp,
7379 				 struct nfs41_state_protection *sp)
7380 {
7381 	static const u32 supported_enforce[NFS4_OP_MAP_NUM_WORDS] = {
7382 		[1] = 1 << (OP_BIND_CONN_TO_SESSION - 32) |
7383 		      1 << (OP_EXCHANGE_ID - 32) |
7384 		      1 << (OP_CREATE_SESSION - 32) |
7385 		      1 << (OP_DESTROY_SESSION - 32) |
7386 		      1 << (OP_DESTROY_CLIENTID - 32)
7387 	};
7388 	unsigned int i;
7389 
7390 	if (sp->how == SP4_MACH_CRED) {
7391 		/* Print state protect result */
7392 		dfprintk(MOUNT, "Server SP4_MACH_CRED support:\n");
7393 		for (i = 0; i <= LAST_NFS4_OP; i++) {
7394 			if (test_bit(i, sp->enforce.u.longs))
7395 				dfprintk(MOUNT, "  enforce op %d\n", i);
7396 			if (test_bit(i, sp->allow.u.longs))
7397 				dfprintk(MOUNT, "  allow op %d\n", i);
7398 		}
7399 
7400 		/* make sure nothing is on enforce list that isn't supported */
7401 		for (i = 0; i < NFS4_OP_MAP_NUM_WORDS; i++) {
7402 			if (sp->enforce.u.words[i] & ~supported_enforce[i]) {
7403 				dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7404 				return -EINVAL;
7405 			}
7406 		}
7407 
7408 		/*
7409 		 * Minimal mode - state operations are allowed to use machine
7410 		 * credential.  Note this already happens by default, so the
7411 		 * client doesn't have to do anything more than the negotiation.
7412 		 *
7413 		 * NOTE: we don't care if EXCHANGE_ID is in the list -
7414 		 *       we're already using the machine cred for exchange_id
7415 		 *       and will never use a different cred.
7416 		 */
7417 		if (test_bit(OP_BIND_CONN_TO_SESSION, sp->enforce.u.longs) &&
7418 		    test_bit(OP_CREATE_SESSION, sp->enforce.u.longs) &&
7419 		    test_bit(OP_DESTROY_SESSION, sp->enforce.u.longs) &&
7420 		    test_bit(OP_DESTROY_CLIENTID, sp->enforce.u.longs)) {
7421 			dfprintk(MOUNT, "sp4_mach_cred:\n");
7422 			dfprintk(MOUNT, "  minimal mode enabled\n");
7423 			set_bit(NFS_SP4_MACH_CRED_MINIMAL, &clp->cl_sp4_flags);
7424 		} else {
7425 			dfprintk(MOUNT, "sp4_mach_cred: disabled\n");
7426 			return -EINVAL;
7427 		}
7428 
7429 		if (test_bit(OP_CLOSE, sp->allow.u.longs) &&
7430 		    test_bit(OP_OPEN_DOWNGRADE, sp->allow.u.longs) &&
7431 		    test_bit(OP_DELEGRETURN, sp->allow.u.longs) &&
7432 		    test_bit(OP_LOCKU, sp->allow.u.longs)) {
7433 			dfprintk(MOUNT, "  cleanup mode enabled\n");
7434 			set_bit(NFS_SP4_MACH_CRED_CLEANUP, &clp->cl_sp4_flags);
7435 		}
7436 
7437 		if (test_bit(OP_LAYOUTRETURN, sp->allow.u.longs)) {
7438 			dfprintk(MOUNT, "  pnfs cleanup mode enabled\n");
7439 			set_bit(NFS_SP4_MACH_CRED_PNFS_CLEANUP,
7440 				&clp->cl_sp4_flags);
7441 		}
7442 
7443 		if (test_bit(OP_SECINFO, sp->allow.u.longs) &&
7444 		    test_bit(OP_SECINFO_NO_NAME, sp->allow.u.longs)) {
7445 			dfprintk(MOUNT, "  secinfo mode enabled\n");
7446 			set_bit(NFS_SP4_MACH_CRED_SECINFO, &clp->cl_sp4_flags);
7447 		}
7448 
7449 		if (test_bit(OP_TEST_STATEID, sp->allow.u.longs) &&
7450 		    test_bit(OP_FREE_STATEID, sp->allow.u.longs)) {
7451 			dfprintk(MOUNT, "  stateid mode enabled\n");
7452 			set_bit(NFS_SP4_MACH_CRED_STATEID, &clp->cl_sp4_flags);
7453 		}
7454 
7455 		if (test_bit(OP_WRITE, sp->allow.u.longs)) {
7456 			dfprintk(MOUNT, "  write mode enabled\n");
7457 			set_bit(NFS_SP4_MACH_CRED_WRITE, &clp->cl_sp4_flags);
7458 		}
7459 
7460 		if (test_bit(OP_COMMIT, sp->allow.u.longs)) {
7461 			dfprintk(MOUNT, "  commit mode enabled\n");
7462 			set_bit(NFS_SP4_MACH_CRED_COMMIT, &clp->cl_sp4_flags);
7463 		}
7464 	}
7465 
7466 	return 0;
7467 }
7468 
7469 struct nfs41_exchange_id_data {
7470 	struct nfs41_exchange_id_res res;
7471 	struct nfs41_exchange_id_args args;
7472 	struct rpc_xprt *xprt;
7473 	int rpc_status;
7474 };
7475 
7476 static void nfs4_exchange_id_done(struct rpc_task *task, void *data)
7477 {
7478 	struct nfs41_exchange_id_data *cdata =
7479 					(struct nfs41_exchange_id_data *)data;
7480 	struct nfs_client *clp = cdata->args.client;
7481 	int status = task->tk_status;
7482 
7483 	trace_nfs4_exchange_id(clp, status);
7484 
7485 	if (status == 0)
7486 		status = nfs4_check_cl_exchange_flags(cdata->res.flags);
7487 
7488 	if (cdata->xprt && status == 0) {
7489 		status = nfs4_detect_session_trunking(clp, &cdata->res,
7490 						      cdata->xprt);
7491 		goto out;
7492 	}
7493 
7494 	if (status  == 0)
7495 		status = nfs4_sp4_select_mode(clp, &cdata->res.state_protect);
7496 
7497 	if (status == 0) {
7498 		clp->cl_clientid = cdata->res.clientid;
7499 		clp->cl_exchange_flags = cdata->res.flags;
7500 		/* Client ID is not confirmed */
7501 		if (!(cdata->res.flags & EXCHGID4_FLAG_CONFIRMED_R)) {
7502 			clear_bit(NFS4_SESSION_ESTABLISHED,
7503 			&clp->cl_session->session_state);
7504 			clp->cl_seqid = cdata->res.seqid;
7505 		}
7506 
7507 		kfree(clp->cl_serverowner);
7508 		clp->cl_serverowner = cdata->res.server_owner;
7509 		cdata->res.server_owner = NULL;
7510 
7511 		/* use the most recent implementation id */
7512 		kfree(clp->cl_implid);
7513 		clp->cl_implid = cdata->res.impl_id;
7514 		cdata->res.impl_id = NULL;
7515 
7516 		if (clp->cl_serverscope != NULL &&
7517 		    !nfs41_same_server_scope(clp->cl_serverscope,
7518 					cdata->res.server_scope)) {
7519 			dprintk("%s: server_scope mismatch detected\n",
7520 				__func__);
7521 			set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
7522 			kfree(clp->cl_serverscope);
7523 			clp->cl_serverscope = NULL;
7524 		}
7525 
7526 		if (clp->cl_serverscope == NULL) {
7527 			clp->cl_serverscope = cdata->res.server_scope;
7528 			cdata->res.server_scope = NULL;
7529 		}
7530 		/* Save the EXCHANGE_ID verifier session trunk tests */
7531 		memcpy(clp->cl_confirm.data, cdata->args.verifier->data,
7532 		       sizeof(clp->cl_confirm.data));
7533 	}
7534 out:
7535 	cdata->rpc_status = status;
7536 	return;
7537 }
7538 
7539 static void nfs4_exchange_id_release(void *data)
7540 {
7541 	struct nfs41_exchange_id_data *cdata =
7542 					(struct nfs41_exchange_id_data *)data;
7543 
7544 	nfs_put_client(cdata->args.client);
7545 	if (cdata->xprt) {
7546 		xprt_put(cdata->xprt);
7547 		rpc_clnt_xprt_switch_put(cdata->args.client->cl_rpcclient);
7548 	}
7549 	kfree(cdata->res.impl_id);
7550 	kfree(cdata->res.server_scope);
7551 	kfree(cdata->res.server_owner);
7552 	kfree(cdata);
7553 }
7554 
7555 static const struct rpc_call_ops nfs4_exchange_id_call_ops = {
7556 	.rpc_call_done = nfs4_exchange_id_done,
7557 	.rpc_release = nfs4_exchange_id_release,
7558 };
7559 
7560 /*
7561  * _nfs4_proc_exchange_id()
7562  *
7563  * Wrapper for EXCHANGE_ID operation.
7564  */
7565 static int _nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred,
7566 			u32 sp4_how, struct rpc_xprt *xprt)
7567 {
7568 	nfs4_verifier verifier;
7569 	struct rpc_message msg = {
7570 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
7571 		.rpc_cred = cred,
7572 	};
7573 	struct rpc_task_setup task_setup_data = {
7574 		.rpc_client = clp->cl_rpcclient,
7575 		.callback_ops = &nfs4_exchange_id_call_ops,
7576 		.rpc_message = &msg,
7577 		.flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
7578 	};
7579 	struct nfs41_exchange_id_data *calldata;
7580 	struct rpc_task *task;
7581 	int status = -EIO;
7582 
7583 	if (!atomic_inc_not_zero(&clp->cl_count))
7584 		goto out;
7585 
7586 	status = -ENOMEM;
7587 	calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
7588 	if (!calldata)
7589 		goto out;
7590 
7591 	if (!xprt)
7592 		nfs4_init_boot_verifier(clp, &verifier);
7593 
7594 	status = nfs4_init_uniform_client_string(clp);
7595 	if (status)
7596 		goto out_calldata;
7597 
7598 	dprintk("NFS call  exchange_id auth=%s, '%s'\n",
7599 		clp->cl_rpcclient->cl_auth->au_ops->au_name,
7600 		clp->cl_owner_id);
7601 
7602 	calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
7603 						GFP_NOFS);
7604 	status = -ENOMEM;
7605 	if (unlikely(calldata->res.server_owner == NULL))
7606 		goto out_calldata;
7607 
7608 	calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
7609 					GFP_NOFS);
7610 	if (unlikely(calldata->res.server_scope == NULL))
7611 		goto out_server_owner;
7612 
7613 	calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
7614 	if (unlikely(calldata->res.impl_id == NULL))
7615 		goto out_server_scope;
7616 
7617 	switch (sp4_how) {
7618 	case SP4_NONE:
7619 		calldata->args.state_protect.how = SP4_NONE;
7620 		break;
7621 
7622 	case SP4_MACH_CRED:
7623 		calldata->args.state_protect = nfs4_sp4_mach_cred_request;
7624 		break;
7625 
7626 	default:
7627 		/* unsupported! */
7628 		WARN_ON_ONCE(1);
7629 		status = -EINVAL;
7630 		goto out_impl_id;
7631 	}
7632 	if (xprt) {
7633 		calldata->xprt = xprt;
7634 		task_setup_data.rpc_xprt = xprt;
7635 		task_setup_data.flags =
7636 				RPC_TASK_SOFT|RPC_TASK_SOFTCONN|RPC_TASK_ASYNC;
7637 		calldata->args.verifier = &clp->cl_confirm;
7638 	} else {
7639 		calldata->args.verifier = &verifier;
7640 	}
7641 	calldata->args.client = clp;
7642 #ifdef CONFIG_NFS_V4_1_MIGRATION
7643 	calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7644 	EXCHGID4_FLAG_BIND_PRINC_STATEID |
7645 	EXCHGID4_FLAG_SUPP_MOVED_MIGR,
7646 #else
7647 	calldata->args.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER |
7648 	EXCHGID4_FLAG_BIND_PRINC_STATEID,
7649 #endif
7650 	msg.rpc_argp = &calldata->args;
7651 	msg.rpc_resp = &calldata->res;
7652 	task_setup_data.callback_data = calldata;
7653 
7654 	task = rpc_run_task(&task_setup_data);
7655 	if (IS_ERR(task)) {
7656 	status = PTR_ERR(task);
7657 		goto out_impl_id;
7658 	}
7659 
7660 	if (!xprt) {
7661 		status = rpc_wait_for_completion_task(task);
7662 		if (!status)
7663 			status = calldata->rpc_status;
7664 	} else	/* session trunking test */
7665 		status = calldata->rpc_status;
7666 
7667 	rpc_put_task(task);
7668 out:
7669 	if (clp->cl_implid != NULL)
7670 		dprintk("NFS reply exchange_id: Server Implementation ID: "
7671 			"domain: %s, name: %s, date: %llu,%u\n",
7672 			clp->cl_implid->domain, clp->cl_implid->name,
7673 			clp->cl_implid->date.seconds,
7674 			clp->cl_implid->date.nseconds);
7675 	dprintk("NFS reply exchange_id: %d\n", status);
7676 	return status;
7677 
7678 out_impl_id:
7679 	kfree(calldata->res.impl_id);
7680 out_server_scope:
7681 	kfree(calldata->res.server_scope);
7682 out_server_owner:
7683 	kfree(calldata->res.server_owner);
7684 out_calldata:
7685 	kfree(calldata);
7686 	goto out;
7687 }
7688 
7689 /*
7690  * nfs4_proc_exchange_id()
7691  *
7692  * Returns zero, a negative errno, or a negative NFS4ERR status code.
7693  *
7694  * Since the clientid has expired, all compounds using sessions
7695  * associated with the stale clientid will be returning
7696  * NFS4ERR_BADSESSION in the sequence operation, and will therefore
7697  * be in some phase of session reset.
7698  *
7699  * Will attempt to negotiate SP4_MACH_CRED if krb5i / krb5p auth is used.
7700  */
7701 int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
7702 {
7703 	rpc_authflavor_t authflavor = clp->cl_rpcclient->cl_auth->au_flavor;
7704 	int status;
7705 
7706 	/* try SP4_MACH_CRED if krb5i/p	*/
7707 	if (authflavor == RPC_AUTH_GSS_KRB5I ||
7708 	    authflavor == RPC_AUTH_GSS_KRB5P) {
7709 		status = _nfs4_proc_exchange_id(clp, cred, SP4_MACH_CRED, NULL);
7710 		if (!status)
7711 			return 0;
7712 	}
7713 
7714 	/* try SP4_NONE */
7715 	return _nfs4_proc_exchange_id(clp, cred, SP4_NONE, NULL);
7716 }
7717 
7718 /**
7719  * nfs4_test_session_trunk
7720  *
7721  * This is an add_xprt_test() test function called from
7722  * rpc_clnt_setup_test_and_add_xprt.
7723  *
7724  * The rpc_xprt_switch is referrenced by rpc_clnt_setup_test_and_add_xprt
7725  * and is dereferrenced in nfs4_exchange_id_release
7726  *
7727  * Upon success, add the new transport to the rpc_clnt
7728  *
7729  * @clnt: struct rpc_clnt to get new transport
7730  * @xprt: the rpc_xprt to test
7731  * @data: call data for _nfs4_proc_exchange_id.
7732  */
7733 int nfs4_test_session_trunk(struct rpc_clnt *clnt, struct rpc_xprt *xprt,
7734 			    void *data)
7735 {
7736 	struct nfs4_add_xprt_data *adata = (struct nfs4_add_xprt_data *)data;
7737 	u32 sp4_how;
7738 
7739 	dprintk("--> %s try %s\n", __func__,
7740 		xprt->address_strings[RPC_DISPLAY_ADDR]);
7741 
7742 	sp4_how = (adata->clp->cl_sp4_flags == 0 ? SP4_NONE : SP4_MACH_CRED);
7743 
7744 	/* Test connection for session trunking. Async exchange_id call */
7745 	return  _nfs4_proc_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
7746 }
7747 EXPORT_SYMBOL_GPL(nfs4_test_session_trunk);
7748 
7749 static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
7750 		struct rpc_cred *cred)
7751 {
7752 	struct rpc_message msg = {
7753 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
7754 		.rpc_argp = clp,
7755 		.rpc_cred = cred,
7756 	};
7757 	int status;
7758 
7759 	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
7760 	trace_nfs4_destroy_clientid(clp, status);
7761 	if (status)
7762 		dprintk("NFS: Got error %d from the server %s on "
7763 			"DESTROY_CLIENTID.", status, clp->cl_hostname);
7764 	return status;
7765 }
7766 
7767 static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
7768 		struct rpc_cred *cred)
7769 {
7770 	unsigned int loop;
7771 	int ret;
7772 
7773 	for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
7774 		ret = _nfs4_proc_destroy_clientid(clp, cred);
7775 		switch (ret) {
7776 		case -NFS4ERR_DELAY:
7777 		case -NFS4ERR_CLIENTID_BUSY:
7778 			ssleep(1);
7779 			break;
7780 		default:
7781 			return ret;
7782 		}
7783 	}
7784 	return 0;
7785 }
7786 
7787 int nfs4_destroy_clientid(struct nfs_client *clp)
7788 {
7789 	struct rpc_cred *cred;
7790 	int ret = 0;
7791 
7792 	if (clp->cl_mvops->minor_version < 1)
7793 		goto out;
7794 	if (clp->cl_exchange_flags == 0)
7795 		goto out;
7796 	if (clp->cl_preserve_clid)
7797 		goto out;
7798 	cred = nfs4_get_clid_cred(clp);
7799 	ret = nfs4_proc_destroy_clientid(clp, cred);
7800 	if (cred)
7801 		put_rpccred(cred);
7802 	switch (ret) {
7803 	case 0:
7804 	case -NFS4ERR_STALE_CLIENTID:
7805 		clp->cl_exchange_flags = 0;
7806 	}
7807 out:
7808 	return ret;
7809 }
7810 
7811 struct nfs4_get_lease_time_data {
7812 	struct nfs4_get_lease_time_args *args;
7813 	struct nfs4_get_lease_time_res *res;
7814 	struct nfs_client *clp;
7815 };
7816 
7817 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
7818 					void *calldata)
7819 {
7820 	struct nfs4_get_lease_time_data *data =
7821 			(struct nfs4_get_lease_time_data *)calldata;
7822 
7823 	dprintk("--> %s\n", __func__);
7824 	/* just setup sequence, do not trigger session recovery
7825 	   since we're invoked within one */
7826 	nfs41_setup_sequence(data->clp->cl_session,
7827 			&data->args->la_seq_args,
7828 			&data->res->lr_seq_res,
7829 			task);
7830 	dprintk("<-- %s\n", __func__);
7831 }
7832 
7833 /*
7834  * Called from nfs4_state_manager thread for session setup, so don't recover
7835  * from sequence operation or clientid errors.
7836  */
7837 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
7838 {
7839 	struct nfs4_get_lease_time_data *data =
7840 			(struct nfs4_get_lease_time_data *)calldata;
7841 
7842 	dprintk("--> %s\n", __func__);
7843 	if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
7844 		return;
7845 	switch (task->tk_status) {
7846 	case -NFS4ERR_DELAY:
7847 	case -NFS4ERR_GRACE:
7848 		dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
7849 		rpc_delay(task, NFS4_POLL_RETRY_MIN);
7850 		task->tk_status = 0;
7851 		/* fall through */
7852 	case -NFS4ERR_RETRY_UNCACHED_REP:
7853 		rpc_restart_call_prepare(task);
7854 		return;
7855 	}
7856 	dprintk("<-- %s\n", __func__);
7857 }
7858 
7859 static const struct rpc_call_ops nfs4_get_lease_time_ops = {
7860 	.rpc_call_prepare = nfs4_get_lease_time_prepare,
7861 	.rpc_call_done = nfs4_get_lease_time_done,
7862 };
7863 
7864 int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
7865 {
7866 	struct rpc_task *task;
7867 	struct nfs4_get_lease_time_args args;
7868 	struct nfs4_get_lease_time_res res = {
7869 		.lr_fsinfo = fsinfo,
7870 	};
7871 	struct nfs4_get_lease_time_data data = {
7872 		.args = &args,
7873 		.res = &res,
7874 		.clp = clp,
7875 	};
7876 	struct rpc_message msg = {
7877 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
7878 		.rpc_argp = &args,
7879 		.rpc_resp = &res,
7880 	};
7881 	struct rpc_task_setup task_setup = {
7882 		.rpc_client = clp->cl_rpcclient,
7883 		.rpc_message = &msg,
7884 		.callback_ops = &nfs4_get_lease_time_ops,
7885 		.callback_data = &data,
7886 		.flags = RPC_TASK_TIMEOUT,
7887 	};
7888 	int status;
7889 
7890 	nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
7891 	nfs4_set_sequence_privileged(&args.la_seq_args);
7892 	dprintk("--> %s\n", __func__);
7893 	task = rpc_run_task(&task_setup);
7894 
7895 	if (IS_ERR(task))
7896 		status = PTR_ERR(task);
7897 	else {
7898 		status = task->tk_status;
7899 		rpc_put_task(task);
7900 	}
7901 	dprintk("<-- %s return %d\n", __func__, status);
7902 
7903 	return status;
7904 }
7905 
7906 /*
7907  * Initialize the values to be used by the client in CREATE_SESSION
7908  * If nfs4_init_session set the fore channel request and response sizes,
7909  * use them.
7910  *
7911  * Set the back channel max_resp_sz_cached to zero to force the client to
7912  * always set csa_cachethis to FALSE because the current implementation
7913  * of the back channel DRC only supports caching the CB_SEQUENCE operation.
7914  */
7915 static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args,
7916 				    struct rpc_clnt *clnt)
7917 {
7918 	unsigned int max_rqst_sz, max_resp_sz;
7919 	unsigned int max_bc_payload = rpc_max_bc_payload(clnt);
7920 
7921 	max_rqst_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxwrite_overhead;
7922 	max_resp_sz = NFS_MAX_FILE_IO_SIZE + nfs41_maxread_overhead;
7923 
7924 	/* Fore channel attributes */
7925 	args->fc_attrs.max_rqst_sz = max_rqst_sz;
7926 	args->fc_attrs.max_resp_sz = max_resp_sz;
7927 	args->fc_attrs.max_ops = NFS4_MAX_OPS;
7928 	args->fc_attrs.max_reqs = max_session_slots;
7929 
7930 	dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
7931 		"max_ops=%u max_reqs=%u\n",
7932 		__func__,
7933 		args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
7934 		args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
7935 
7936 	/* Back channel attributes */
7937 	args->bc_attrs.max_rqst_sz = max_bc_payload;
7938 	args->bc_attrs.max_resp_sz = max_bc_payload;
7939 	args->bc_attrs.max_resp_sz_cached = 0;
7940 	args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
7941 	args->bc_attrs.max_reqs = min_t(unsigned short, max_session_cb_slots, 1);
7942 
7943 	dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
7944 		"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
7945 		__func__,
7946 		args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
7947 		args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
7948 		args->bc_attrs.max_reqs);
7949 }
7950 
7951 static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args,
7952 		struct nfs41_create_session_res *res)
7953 {
7954 	struct nfs4_channel_attrs *sent = &args->fc_attrs;
7955 	struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
7956 
7957 	if (rcvd->max_resp_sz > sent->max_resp_sz)
7958 		return -EINVAL;
7959 	/*
7960 	 * Our requested max_ops is the minimum we need; we're not
7961 	 * prepared to break up compounds into smaller pieces than that.
7962 	 * So, no point even trying to continue if the server won't
7963 	 * cooperate:
7964 	 */
7965 	if (rcvd->max_ops < sent->max_ops)
7966 		return -EINVAL;
7967 	if (rcvd->max_reqs == 0)
7968 		return -EINVAL;
7969 	if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
7970 		rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
7971 	return 0;
7972 }
7973 
7974 static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args,
7975 		struct nfs41_create_session_res *res)
7976 {
7977 	struct nfs4_channel_attrs *sent = &args->bc_attrs;
7978 	struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
7979 
7980 	if (!(res->flags & SESSION4_BACK_CHAN))
7981 		goto out;
7982 	if (rcvd->max_rqst_sz > sent->max_rqst_sz)
7983 		return -EINVAL;
7984 	if (rcvd->max_resp_sz < sent->max_resp_sz)
7985 		return -EINVAL;
7986 	if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
7987 		return -EINVAL;
7988 	if (rcvd->max_ops > sent->max_ops)
7989 		return -EINVAL;
7990 	if (rcvd->max_reqs > sent->max_reqs)
7991 		return -EINVAL;
7992 out:
7993 	return 0;
7994 }
7995 
7996 static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
7997 				     struct nfs41_create_session_res *res)
7998 {
7999 	int ret;
8000 
8001 	ret = nfs4_verify_fore_channel_attrs(args, res);
8002 	if (ret)
8003 		return ret;
8004 	return nfs4_verify_back_channel_attrs(args, res);
8005 }
8006 
8007 static void nfs4_update_session(struct nfs4_session *session,
8008 		struct nfs41_create_session_res *res)
8009 {
8010 	nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
8011 	/* Mark client id and session as being confirmed */
8012 	session->clp->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
8013 	set_bit(NFS4_SESSION_ESTABLISHED, &session->session_state);
8014 	session->flags = res->flags;
8015 	memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
8016 	if (res->flags & SESSION4_BACK_CHAN)
8017 		memcpy(&session->bc_attrs, &res->bc_attrs,
8018 				sizeof(session->bc_attrs));
8019 }
8020 
8021 static int _nfs4_proc_create_session(struct nfs_client *clp,
8022 		struct rpc_cred *cred)
8023 {
8024 	struct nfs4_session *session = clp->cl_session;
8025 	struct nfs41_create_session_args args = {
8026 		.client = clp,
8027 		.clientid = clp->cl_clientid,
8028 		.seqid = clp->cl_seqid,
8029 		.cb_program = NFS4_CALLBACK,
8030 	};
8031 	struct nfs41_create_session_res res;
8032 
8033 	struct rpc_message msg = {
8034 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
8035 		.rpc_argp = &args,
8036 		.rpc_resp = &res,
8037 		.rpc_cred = cred,
8038 	};
8039 	int status;
8040 
8041 	nfs4_init_channel_attrs(&args, clp->cl_rpcclient);
8042 	args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
8043 
8044 	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
8045 	trace_nfs4_create_session(clp, status);
8046 
8047 	switch (status) {
8048 	case -NFS4ERR_STALE_CLIENTID:
8049 	case -NFS4ERR_DELAY:
8050 	case -ETIMEDOUT:
8051 	case -EACCES:
8052 	case -EAGAIN:
8053 		goto out;
8054 	};
8055 
8056 	clp->cl_seqid++;
8057 	if (!status) {
8058 		/* Verify the session's negotiated channel_attrs values */
8059 		status = nfs4_verify_channel_attrs(&args, &res);
8060 		/* Increment the clientid slot sequence id */
8061 		if (status)
8062 			goto out;
8063 		nfs4_update_session(session, &res);
8064 	}
8065 out:
8066 	return status;
8067 }
8068 
8069 /*
8070  * Issues a CREATE_SESSION operation to the server.
8071  * It is the responsibility of the caller to verify the session is
8072  * expired before calling this routine.
8073  */
8074 int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
8075 {
8076 	int status;
8077 	unsigned *ptr;
8078 	struct nfs4_session *session = clp->cl_session;
8079 
8080 	dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);
8081 
8082 	status = _nfs4_proc_create_session(clp, cred);
8083 	if (status)
8084 		goto out;
8085 
8086 	/* Init or reset the session slot tables */
8087 	status = nfs4_setup_session_slot_tables(session);
8088 	dprintk("slot table setup returned %d\n", status);
8089 	if (status)
8090 		goto out;
8091 
8092 	ptr = (unsigned *)&session->sess_id.data[0];
8093 	dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
8094 		clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
8095 out:
8096 	dprintk("<-- %s\n", __func__);
8097 	return status;
8098 }
8099 
8100 /*
8101  * Issue the over-the-wire RPC DESTROY_SESSION.
8102  * The caller must serialize access to this routine.
8103  */
8104 int nfs4_proc_destroy_session(struct nfs4_session *session,
8105 		struct rpc_cred *cred)
8106 {
8107 	struct rpc_message msg = {
8108 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
8109 		.rpc_argp = session,
8110 		.rpc_cred = cred,
8111 	};
8112 	int status = 0;
8113 
8114 	dprintk("--> nfs4_proc_destroy_session\n");
8115 
8116 	/* session is still being setup */
8117 	if (!test_and_clear_bit(NFS4_SESSION_ESTABLISHED, &session->session_state))
8118 		return 0;
8119 
8120 	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
8121 	trace_nfs4_destroy_session(session->clp, status);
8122 
8123 	if (status)
8124 		dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
8125 			"Session has been destroyed regardless...\n", status);
8126 
8127 	dprintk("<-- nfs4_proc_destroy_session\n");
8128 	return status;
8129 }
8130 
8131 /*
8132  * Renew the cl_session lease.
8133  */
8134 struct nfs4_sequence_data {
8135 	struct nfs_client *clp;
8136 	struct nfs4_sequence_args args;
8137 	struct nfs4_sequence_res res;
8138 };
8139 
8140 static void nfs41_sequence_release(void *data)
8141 {
8142 	struct nfs4_sequence_data *calldata = data;
8143 	struct nfs_client *clp = calldata->clp;
8144 
8145 	if (atomic_read(&clp->cl_count) > 1)
8146 		nfs4_schedule_state_renewal(clp);
8147 	nfs_put_client(clp);
8148 	kfree(calldata);
8149 }
8150 
8151 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8152 {
8153 	switch(task->tk_status) {
8154 	case -NFS4ERR_DELAY:
8155 		rpc_delay(task, NFS4_POLL_RETRY_MAX);
8156 		return -EAGAIN;
8157 	default:
8158 		nfs4_schedule_lease_recovery(clp);
8159 	}
8160 	return 0;
8161 }
8162 
8163 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
8164 {
8165 	struct nfs4_sequence_data *calldata = data;
8166 	struct nfs_client *clp = calldata->clp;
8167 
8168 	if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
8169 		return;
8170 
8171 	trace_nfs4_sequence(clp, task->tk_status);
8172 	if (task->tk_status < 0) {
8173 		dprintk("%s ERROR %d\n", __func__, task->tk_status);
8174 		if (atomic_read(&clp->cl_count) == 1)
8175 			goto out;
8176 
8177 		if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
8178 			rpc_restart_call_prepare(task);
8179 			return;
8180 		}
8181 	}
8182 	dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
8183 out:
8184 	dprintk("<-- %s\n", __func__);
8185 }
8186 
8187 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
8188 {
8189 	struct nfs4_sequence_data *calldata = data;
8190 	struct nfs_client *clp = calldata->clp;
8191 	struct nfs4_sequence_args *args;
8192 	struct nfs4_sequence_res *res;
8193 
8194 	args = task->tk_msg.rpc_argp;
8195 	res = task->tk_msg.rpc_resp;
8196 
8197 	nfs41_setup_sequence(clp->cl_session, args, res, task);
8198 }
8199 
8200 static const struct rpc_call_ops nfs41_sequence_ops = {
8201 	.rpc_call_done = nfs41_sequence_call_done,
8202 	.rpc_call_prepare = nfs41_sequence_prepare,
8203 	.rpc_release = nfs41_sequence_release,
8204 };
8205 
8206 static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
8207 		struct rpc_cred *cred,
8208 		bool is_privileged)
8209 {
8210 	struct nfs4_sequence_data *calldata;
8211 	struct rpc_message msg = {
8212 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
8213 		.rpc_cred = cred,
8214 	};
8215 	struct rpc_task_setup task_setup_data = {
8216 		.rpc_client = clp->cl_rpcclient,
8217 		.rpc_message = &msg,
8218 		.callback_ops = &nfs41_sequence_ops,
8219 		.flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
8220 	};
8221 
8222 	if (!atomic_inc_not_zero(&clp->cl_count))
8223 		return ERR_PTR(-EIO);
8224 	calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8225 	if (calldata == NULL) {
8226 		nfs_put_client(clp);
8227 		return ERR_PTR(-ENOMEM);
8228 	}
8229 	nfs4_init_sequence(&calldata->args, &calldata->res, 0);
8230 	if (is_privileged)
8231 		nfs4_set_sequence_privileged(&calldata->args);
8232 	msg.rpc_argp = &calldata->args;
8233 	msg.rpc_resp = &calldata->res;
8234 	calldata->clp = clp;
8235 	task_setup_data.callback_data = calldata;
8236 
8237 	return rpc_run_task(&task_setup_data);
8238 }
8239 
8240 static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
8241 {
8242 	struct rpc_task *task;
8243 	int ret = 0;
8244 
8245 	if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
8246 		return -EAGAIN;
8247 	task = _nfs41_proc_sequence(clp, cred, false);
8248 	if (IS_ERR(task))
8249 		ret = PTR_ERR(task);
8250 	else
8251 		rpc_put_task_async(task);
8252 	dprintk("<-- %s status=%d\n", __func__, ret);
8253 	return ret;
8254 }
8255 
8256 static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
8257 {
8258 	struct rpc_task *task;
8259 	int ret;
8260 
8261 	task = _nfs41_proc_sequence(clp, cred, true);
8262 	if (IS_ERR(task)) {
8263 		ret = PTR_ERR(task);
8264 		goto out;
8265 	}
8266 	ret = rpc_wait_for_completion_task(task);
8267 	if (!ret)
8268 		ret = task->tk_status;
8269 	rpc_put_task(task);
8270 out:
8271 	dprintk("<-- %s status=%d\n", __func__, ret);
8272 	return ret;
8273 }
8274 
8275 struct nfs4_reclaim_complete_data {
8276 	struct nfs_client *clp;
8277 	struct nfs41_reclaim_complete_args arg;
8278 	struct nfs41_reclaim_complete_res res;
8279 };
8280 
8281 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
8282 {
8283 	struct nfs4_reclaim_complete_data *calldata = data;
8284 
8285 	nfs41_setup_sequence(calldata->clp->cl_session,
8286 			&calldata->arg.seq_args,
8287 			&calldata->res.seq_res,
8288 			task);
8289 }
8290 
8291 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
8292 {
8293 	switch(task->tk_status) {
8294 	case 0:
8295 	case -NFS4ERR_COMPLETE_ALREADY:
8296 	case -NFS4ERR_WRONG_CRED: /* What to do here? */
8297 		break;
8298 	case -NFS4ERR_DELAY:
8299 		rpc_delay(task, NFS4_POLL_RETRY_MAX);
8300 		/* fall through */
8301 	case -NFS4ERR_RETRY_UNCACHED_REP:
8302 		return -EAGAIN;
8303 	default:
8304 		nfs4_schedule_lease_recovery(clp);
8305 	}
8306 	return 0;
8307 }
8308 
8309 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
8310 {
8311 	struct nfs4_reclaim_complete_data *calldata = data;
8312 	struct nfs_client *clp = calldata->clp;
8313 	struct nfs4_sequence_res *res = &calldata->res.seq_res;
8314 
8315 	dprintk("--> %s\n", __func__);
8316 	if (!nfs41_sequence_done(task, res))
8317 		return;
8318 
8319 	trace_nfs4_reclaim_complete(clp, task->tk_status);
8320 	if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
8321 		rpc_restart_call_prepare(task);
8322 		return;
8323 	}
8324 	dprintk("<-- %s\n", __func__);
8325 }
8326 
8327 static void nfs4_free_reclaim_complete_data(void *data)
8328 {
8329 	struct nfs4_reclaim_complete_data *calldata = data;
8330 
8331 	kfree(calldata);
8332 }
8333 
8334 static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
8335 	.rpc_call_prepare = nfs4_reclaim_complete_prepare,
8336 	.rpc_call_done = nfs4_reclaim_complete_done,
8337 	.rpc_release = nfs4_free_reclaim_complete_data,
8338 };
8339 
8340 /*
8341  * Issue a global reclaim complete.
8342  */
8343 static int nfs41_proc_reclaim_complete(struct nfs_client *clp,
8344 		struct rpc_cred *cred)
8345 {
8346 	struct nfs4_reclaim_complete_data *calldata;
8347 	struct rpc_task *task;
8348 	struct rpc_message msg = {
8349 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
8350 		.rpc_cred = cred,
8351 	};
8352 	struct rpc_task_setup task_setup_data = {
8353 		.rpc_client = clp->cl_rpcclient,
8354 		.rpc_message = &msg,
8355 		.callback_ops = &nfs4_reclaim_complete_call_ops,
8356 		.flags = RPC_TASK_ASYNC,
8357 	};
8358 	int status = -ENOMEM;
8359 
8360 	dprintk("--> %s\n", __func__);
8361 	calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
8362 	if (calldata == NULL)
8363 		goto out;
8364 	calldata->clp = clp;
8365 	calldata->arg.one_fs = 0;
8366 
8367 	nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
8368 	nfs4_set_sequence_privileged(&calldata->arg.seq_args);
8369 	msg.rpc_argp = &calldata->arg;
8370 	msg.rpc_resp = &calldata->res;
8371 	task_setup_data.callback_data = calldata;
8372 	task = rpc_run_task(&task_setup_data);
8373 	if (IS_ERR(task)) {
8374 		status = PTR_ERR(task);
8375 		goto out;
8376 	}
8377 	status = nfs4_wait_for_completion_rpc_task(task);
8378 	if (status == 0)
8379 		status = task->tk_status;
8380 	rpc_put_task(task);
8381 	return 0;
8382 out:
8383 	dprintk("<-- %s status=%d\n", __func__, status);
8384 	return status;
8385 }
8386 
8387 static void
8388 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
8389 {
8390 	struct nfs4_layoutget *lgp = calldata;
8391 	struct nfs_server *server = NFS_SERVER(lgp->args.inode);
8392 	struct nfs4_session *session = nfs4_get_session(server);
8393 
8394 	dprintk("--> %s\n", __func__);
8395 	nfs41_setup_sequence(session, &lgp->args.seq_args,
8396 				&lgp->res.seq_res, task);
8397 	dprintk("<-- %s\n", __func__);
8398 }
8399 
8400 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
8401 {
8402 	struct nfs4_layoutget *lgp = calldata;
8403 
8404 	dprintk("--> %s\n", __func__);
8405 	nfs41_sequence_process(task, &lgp->res.seq_res);
8406 	dprintk("<-- %s\n", __func__);
8407 }
8408 
8409 static int
8410 nfs4_layoutget_handle_exception(struct rpc_task *task,
8411 		struct nfs4_layoutget *lgp, struct nfs4_exception *exception)
8412 {
8413 	struct inode *inode = lgp->args.inode;
8414 	struct nfs_server *server = NFS_SERVER(inode);
8415 	struct pnfs_layout_hdr *lo;
8416 	int nfs4err = task->tk_status;
8417 	int err, status = 0;
8418 	LIST_HEAD(head);
8419 
8420 	dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
8421 
8422 	switch (nfs4err) {
8423 	case 0:
8424 		goto out;
8425 
8426 	/*
8427 	 * NFS4ERR_LAYOUTUNAVAILABLE means we are not supposed to use pnfs
8428 	 * on the file. set tk_status to -ENODATA to tell upper layer to
8429 	 * retry go inband.
8430 	 */
8431 	case -NFS4ERR_LAYOUTUNAVAILABLE:
8432 		status = -ENODATA;
8433 		goto out;
8434 	/*
8435 	 * NFS4ERR_BADLAYOUT means the MDS cannot return a layout of
8436 	 * length lgp->args.minlength != 0 (see RFC5661 section 18.43.3).
8437 	 */
8438 	case -NFS4ERR_BADLAYOUT:
8439 		status = -EOVERFLOW;
8440 		goto out;
8441 	/*
8442 	 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
8443 	 * (or clients) writing to the same RAID stripe except when
8444 	 * the minlength argument is 0 (see RFC5661 section 18.43.3).
8445 	 *
8446 	 * Treat it like we would RECALLCONFLICT -- we retry for a little
8447 	 * while, and then eventually give up.
8448 	 */
8449 	case -NFS4ERR_LAYOUTTRYLATER:
8450 		if (lgp->args.minlength == 0) {
8451 			status = -EOVERFLOW;
8452 			goto out;
8453 		}
8454 		status = -EBUSY;
8455 		break;
8456 	case -NFS4ERR_RECALLCONFLICT:
8457 		status = -ERECALLCONFLICT;
8458 		break;
8459 	case -NFS4ERR_DELEG_REVOKED:
8460 	case -NFS4ERR_ADMIN_REVOKED:
8461 	case -NFS4ERR_EXPIRED:
8462 	case -NFS4ERR_BAD_STATEID:
8463 		exception->timeout = 0;
8464 		spin_lock(&inode->i_lock);
8465 		lo = NFS_I(inode)->layout;
8466 		/* If the open stateid was bad, then recover it. */
8467 		if (!lo || test_bit(NFS_LAYOUT_INVALID_STID, &lo->plh_flags) ||
8468 		    nfs4_stateid_match_other(&lgp->args.stateid,
8469 					&lgp->args.ctx->state->stateid)) {
8470 			spin_unlock(&inode->i_lock);
8471 			exception->state = lgp->args.ctx->state;
8472 			exception->stateid = &lgp->args.stateid;
8473 			break;
8474 		}
8475 
8476 		/*
8477 		 * Mark the bad layout state as invalid, then retry
8478 		 */
8479 		pnfs_mark_layout_stateid_invalid(lo, &head);
8480 		spin_unlock(&inode->i_lock);
8481 		pnfs_free_lseg_list(&head);
8482 		status = -EAGAIN;
8483 		goto out;
8484 	}
8485 
8486 	err = nfs4_handle_exception(server, nfs4err, exception);
8487 	if (!status) {
8488 		if (exception->retry)
8489 			status = -EAGAIN;
8490 		else
8491 			status = err;
8492 	}
8493 out:
8494 	dprintk("<-- %s\n", __func__);
8495 	return status;
8496 }
8497 
8498 static size_t max_response_pages(struct nfs_server *server)
8499 {
8500 	u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
8501 	return nfs_page_array_len(0, max_resp_sz);
8502 }
8503 
8504 static void nfs4_free_pages(struct page **pages, size_t size)
8505 {
8506 	int i;
8507 
8508 	if (!pages)
8509 		return;
8510 
8511 	for (i = 0; i < size; i++) {
8512 		if (!pages[i])
8513 			break;
8514 		__free_page(pages[i]);
8515 	}
8516 	kfree(pages);
8517 }
8518 
8519 static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
8520 {
8521 	struct page **pages;
8522 	int i;
8523 
8524 	pages = kcalloc(size, sizeof(struct page *), gfp_flags);
8525 	if (!pages) {
8526 		dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
8527 		return NULL;
8528 	}
8529 
8530 	for (i = 0; i < size; i++) {
8531 		pages[i] = alloc_page(gfp_flags);
8532 		if (!pages[i]) {
8533 			dprintk("%s: failed to allocate page\n", __func__);
8534 			nfs4_free_pages(pages, size);
8535 			return NULL;
8536 		}
8537 	}
8538 
8539 	return pages;
8540 }
8541 
8542 static void nfs4_layoutget_release(void *calldata)
8543 {
8544 	struct nfs4_layoutget *lgp = calldata;
8545 	struct inode *inode = lgp->args.inode;
8546 	struct nfs_server *server = NFS_SERVER(inode);
8547 	size_t max_pages = max_response_pages(server);
8548 
8549 	dprintk("--> %s\n", __func__);
8550 	nfs4_free_pages(lgp->args.layout.pages, max_pages);
8551 	pnfs_put_layout_hdr(NFS_I(inode)->layout);
8552 	put_nfs_open_context(lgp->args.ctx);
8553 	kfree(calldata);
8554 	dprintk("<-- %s\n", __func__);
8555 }
8556 
8557 static const struct rpc_call_ops nfs4_layoutget_call_ops = {
8558 	.rpc_call_prepare = nfs4_layoutget_prepare,
8559 	.rpc_call_done = nfs4_layoutget_done,
8560 	.rpc_release = nfs4_layoutget_release,
8561 };
8562 
8563 struct pnfs_layout_segment *
8564 nfs4_proc_layoutget(struct nfs4_layoutget *lgp, long *timeout, gfp_t gfp_flags)
8565 {
8566 	struct inode *inode = lgp->args.inode;
8567 	struct nfs_server *server = NFS_SERVER(inode);
8568 	size_t max_pages = max_response_pages(server);
8569 	struct rpc_task *task;
8570 	struct rpc_message msg = {
8571 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
8572 		.rpc_argp = &lgp->args,
8573 		.rpc_resp = &lgp->res,
8574 		.rpc_cred = lgp->cred,
8575 	};
8576 	struct rpc_task_setup task_setup_data = {
8577 		.rpc_client = server->client,
8578 		.rpc_message = &msg,
8579 		.callback_ops = &nfs4_layoutget_call_ops,
8580 		.callback_data = lgp,
8581 		.flags = RPC_TASK_ASYNC,
8582 	};
8583 	struct pnfs_layout_segment *lseg = NULL;
8584 	struct nfs4_exception exception = {
8585 		.inode = inode,
8586 		.timeout = *timeout,
8587 	};
8588 	int status = 0;
8589 
8590 	dprintk("--> %s\n", __func__);
8591 
8592 	/* nfs4_layoutget_release calls pnfs_put_layout_hdr */
8593 	pnfs_get_layout_hdr(NFS_I(inode)->layout);
8594 
8595 	lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
8596 	if (!lgp->args.layout.pages) {
8597 		nfs4_layoutget_release(lgp);
8598 		return ERR_PTR(-ENOMEM);
8599 	}
8600 	lgp->args.layout.pglen = max_pages * PAGE_SIZE;
8601 
8602 	lgp->res.layoutp = &lgp->args.layout;
8603 	lgp->res.seq_res.sr_slot = NULL;
8604 	nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
8605 
8606 	task = rpc_run_task(&task_setup_data);
8607 	if (IS_ERR(task))
8608 		return ERR_CAST(task);
8609 	status = nfs4_wait_for_completion_rpc_task(task);
8610 	if (status == 0) {
8611 		status = nfs4_layoutget_handle_exception(task, lgp, &exception);
8612 		*timeout = exception.timeout;
8613 	}
8614 
8615 	trace_nfs4_layoutget(lgp->args.ctx,
8616 			&lgp->args.range,
8617 			&lgp->res.range,
8618 			&lgp->res.stateid,
8619 			status);
8620 
8621 	/* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
8622 	if (status == 0 && lgp->res.layoutp->len)
8623 		lseg = pnfs_layout_process(lgp);
8624 	nfs4_sequence_free_slot(&lgp->res.seq_res);
8625 	rpc_put_task(task);
8626 	dprintk("<-- %s status=%d\n", __func__, status);
8627 	if (status)
8628 		return ERR_PTR(status);
8629 	return lseg;
8630 }
8631 
8632 static void
8633 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
8634 {
8635 	struct nfs4_layoutreturn *lrp = calldata;
8636 
8637 	dprintk("--> %s\n", __func__);
8638 	nfs41_setup_sequence(lrp->clp->cl_session,
8639 			&lrp->args.seq_args,
8640 			&lrp->res.seq_res,
8641 			task);
8642 }
8643 
8644 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
8645 {
8646 	struct nfs4_layoutreturn *lrp = calldata;
8647 	struct nfs_server *server;
8648 
8649 	dprintk("--> %s\n", __func__);
8650 
8651 	if (!nfs41_sequence_process(task, &lrp->res.seq_res))
8652 		return;
8653 
8654 	server = NFS_SERVER(lrp->args.inode);
8655 	switch (task->tk_status) {
8656 	default:
8657 		task->tk_status = 0;
8658 	case 0:
8659 		break;
8660 	case -NFS4ERR_DELAY:
8661 		if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
8662 			break;
8663 		nfs4_sequence_free_slot(&lrp->res.seq_res);
8664 		rpc_restart_call_prepare(task);
8665 		return;
8666 	}
8667 	dprintk("<-- %s\n", __func__);
8668 }
8669 
8670 static void nfs4_layoutreturn_release(void *calldata)
8671 {
8672 	struct nfs4_layoutreturn *lrp = calldata;
8673 	struct pnfs_layout_hdr *lo = lrp->args.layout;
8674 
8675 	dprintk("--> %s\n", __func__);
8676 	pnfs_layoutreturn_free_lsegs(lo, &lrp->args.stateid, &lrp->args.range,
8677 			lrp->res.lrs_present ? &lrp->res.stateid : NULL);
8678 	nfs4_sequence_free_slot(&lrp->res.seq_res);
8679 	if (lrp->ld_private.ops && lrp->ld_private.ops->free)
8680 		lrp->ld_private.ops->free(&lrp->ld_private);
8681 	pnfs_put_layout_hdr(lrp->args.layout);
8682 	nfs_iput_and_deactive(lrp->inode);
8683 	kfree(calldata);
8684 	dprintk("<-- %s\n", __func__);
8685 }
8686 
8687 static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
8688 	.rpc_call_prepare = nfs4_layoutreturn_prepare,
8689 	.rpc_call_done = nfs4_layoutreturn_done,
8690 	.rpc_release = nfs4_layoutreturn_release,
8691 };
8692 
8693 int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp, bool sync)
8694 {
8695 	struct rpc_task *task;
8696 	struct rpc_message msg = {
8697 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
8698 		.rpc_argp = &lrp->args,
8699 		.rpc_resp = &lrp->res,
8700 		.rpc_cred = lrp->cred,
8701 	};
8702 	struct rpc_task_setup task_setup_data = {
8703 		.rpc_client = NFS_SERVER(lrp->args.inode)->client,
8704 		.rpc_message = &msg,
8705 		.callback_ops = &nfs4_layoutreturn_call_ops,
8706 		.callback_data = lrp,
8707 	};
8708 	int status = 0;
8709 
8710 	nfs4_state_protect(NFS_SERVER(lrp->args.inode)->nfs_client,
8711 			NFS_SP4_MACH_CRED_PNFS_CLEANUP,
8712 			&task_setup_data.rpc_client, &msg);
8713 
8714 	dprintk("--> %s\n", __func__);
8715 	if (!sync) {
8716 		lrp->inode = nfs_igrab_and_active(lrp->args.inode);
8717 		if (!lrp->inode) {
8718 			nfs4_layoutreturn_release(lrp);
8719 			return -EAGAIN;
8720 		}
8721 		task_setup_data.flags |= RPC_TASK_ASYNC;
8722 	}
8723 	nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
8724 	task = rpc_run_task(&task_setup_data);
8725 	if (IS_ERR(task))
8726 		return PTR_ERR(task);
8727 	if (sync)
8728 		status = task->tk_status;
8729 	trace_nfs4_layoutreturn(lrp->args.inode, &lrp->args.stateid, status);
8730 	dprintk("<-- %s status=%d\n", __func__, status);
8731 	rpc_put_task(task);
8732 	return status;
8733 }
8734 
8735 static int
8736 _nfs4_proc_getdeviceinfo(struct nfs_server *server,
8737 		struct pnfs_device *pdev,
8738 		struct rpc_cred *cred)
8739 {
8740 	struct nfs4_getdeviceinfo_args args = {
8741 		.pdev = pdev,
8742 		.notify_types = NOTIFY_DEVICEID4_CHANGE |
8743 			NOTIFY_DEVICEID4_DELETE,
8744 	};
8745 	struct nfs4_getdeviceinfo_res res = {
8746 		.pdev = pdev,
8747 	};
8748 	struct rpc_message msg = {
8749 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
8750 		.rpc_argp = &args,
8751 		.rpc_resp = &res,
8752 		.rpc_cred = cred,
8753 	};
8754 	int status;
8755 
8756 	dprintk("--> %s\n", __func__);
8757 	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
8758 	if (res.notification & ~args.notify_types)
8759 		dprintk("%s: unsupported notification\n", __func__);
8760 	if (res.notification != args.notify_types)
8761 		pdev->nocache = 1;
8762 
8763 	dprintk("<-- %s status=%d\n", __func__, status);
8764 
8765 	return status;
8766 }
8767 
8768 int nfs4_proc_getdeviceinfo(struct nfs_server *server,
8769 		struct pnfs_device *pdev,
8770 		struct rpc_cred *cred)
8771 {
8772 	struct nfs4_exception exception = { };
8773 	int err;
8774 
8775 	do {
8776 		err = nfs4_handle_exception(server,
8777 					_nfs4_proc_getdeviceinfo(server, pdev, cred),
8778 					&exception);
8779 	} while (exception.retry);
8780 	return err;
8781 }
8782 EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);
8783 
8784 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
8785 {
8786 	struct nfs4_layoutcommit_data *data = calldata;
8787 	struct nfs_server *server = NFS_SERVER(data->args.inode);
8788 	struct nfs4_session *session = nfs4_get_session(server);
8789 
8790 	nfs41_setup_sequence(session,
8791 			&data->args.seq_args,
8792 			&data->res.seq_res,
8793 			task);
8794 }
8795 
8796 static void
8797 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
8798 {
8799 	struct nfs4_layoutcommit_data *data = calldata;
8800 	struct nfs_server *server = NFS_SERVER(data->args.inode);
8801 
8802 	if (!nfs41_sequence_done(task, &data->res.seq_res))
8803 		return;
8804 
8805 	switch (task->tk_status) { /* Just ignore these failures */
8806 	case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
8807 	case -NFS4ERR_BADIOMODE:     /* no IOMODE_RW layout for range */
8808 	case -NFS4ERR_BADLAYOUT:     /* no layout */
8809 	case -NFS4ERR_GRACE:	    /* loca_recalim always false */
8810 		task->tk_status = 0;
8811 	case 0:
8812 		break;
8813 	default:
8814 		if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
8815 			rpc_restart_call_prepare(task);
8816 			return;
8817 		}
8818 	}
8819 }
8820 
8821 static void nfs4_layoutcommit_release(void *calldata)
8822 {
8823 	struct nfs4_layoutcommit_data *data = calldata;
8824 
8825 	pnfs_cleanup_layoutcommit(data);
8826 	nfs_post_op_update_inode_force_wcc(data->args.inode,
8827 					   data->res.fattr);
8828 	put_rpccred(data->cred);
8829 	nfs_iput_and_deactive(data->inode);
8830 	kfree(data);
8831 }
8832 
8833 static const struct rpc_call_ops nfs4_layoutcommit_ops = {
8834 	.rpc_call_prepare = nfs4_layoutcommit_prepare,
8835 	.rpc_call_done = nfs4_layoutcommit_done,
8836 	.rpc_release = nfs4_layoutcommit_release,
8837 };
8838 
8839 int
8840 nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
8841 {
8842 	struct rpc_message msg = {
8843 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
8844 		.rpc_argp = &data->args,
8845 		.rpc_resp = &data->res,
8846 		.rpc_cred = data->cred,
8847 	};
8848 	struct rpc_task_setup task_setup_data = {
8849 		.task = &data->task,
8850 		.rpc_client = NFS_CLIENT(data->args.inode),
8851 		.rpc_message = &msg,
8852 		.callback_ops = &nfs4_layoutcommit_ops,
8853 		.callback_data = data,
8854 	};
8855 	struct rpc_task *task;
8856 	int status = 0;
8857 
8858 	dprintk("NFS: initiating layoutcommit call. sync %d "
8859 		"lbw: %llu inode %lu\n", sync,
8860 		data->args.lastbytewritten,
8861 		data->args.inode->i_ino);
8862 
8863 	if (!sync) {
8864 		data->inode = nfs_igrab_and_active(data->args.inode);
8865 		if (data->inode == NULL) {
8866 			nfs4_layoutcommit_release(data);
8867 			return -EAGAIN;
8868 		}
8869 		task_setup_data.flags = RPC_TASK_ASYNC;
8870 	}
8871 	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
8872 	task = rpc_run_task(&task_setup_data);
8873 	if (IS_ERR(task))
8874 		return PTR_ERR(task);
8875 	if (sync)
8876 		status = task->tk_status;
8877 	trace_nfs4_layoutcommit(data->args.inode, &data->args.stateid, status);
8878 	dprintk("%s: status %d\n", __func__, status);
8879 	rpc_put_task(task);
8880 	return status;
8881 }
8882 
8883 /**
8884  * Use the state managment nfs_client cl_rpcclient, which uses krb5i (if
8885  * possible) as per RFC3530bis and RFC5661 Security Considerations sections
8886  */
8887 static int
8888 _nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8889 		    struct nfs_fsinfo *info,
8890 		    struct nfs4_secinfo_flavors *flavors, bool use_integrity)
8891 {
8892 	struct nfs41_secinfo_no_name_args args = {
8893 		.style = SECINFO_STYLE_CURRENT_FH,
8894 	};
8895 	struct nfs4_secinfo_res res = {
8896 		.flavors = flavors,
8897 	};
8898 	struct rpc_message msg = {
8899 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
8900 		.rpc_argp = &args,
8901 		.rpc_resp = &res,
8902 	};
8903 	struct rpc_clnt *clnt = server->client;
8904 	struct rpc_cred *cred = NULL;
8905 	int status;
8906 
8907 	if (use_integrity) {
8908 		clnt = server->nfs_client->cl_rpcclient;
8909 		cred = nfs4_get_clid_cred(server->nfs_client);
8910 		msg.rpc_cred = cred;
8911 	}
8912 
8913 	dprintk("--> %s\n", __func__);
8914 	status = nfs4_call_sync(clnt, server, &msg, &args.seq_args,
8915 				&res.seq_res, 0);
8916 	dprintk("<-- %s status=%d\n", __func__, status);
8917 
8918 	if (cred)
8919 		put_rpccred(cred);
8920 
8921 	return status;
8922 }
8923 
8924 static int
8925 nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
8926 			   struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
8927 {
8928 	struct nfs4_exception exception = { };
8929 	int err;
8930 	do {
8931 		/* first try using integrity protection */
8932 		err = -NFS4ERR_WRONGSEC;
8933 
8934 		/* try to use integrity protection with machine cred */
8935 		if (_nfs4_is_integrity_protected(server->nfs_client))
8936 			err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8937 							  flavors, true);
8938 
8939 		/*
8940 		 * if unable to use integrity protection, or SECINFO with
8941 		 * integrity protection returns NFS4ERR_WRONGSEC (which is
8942 		 * disallowed by spec, but exists in deployed servers) use
8943 		 * the current filesystem's rpc_client and the user cred.
8944 		 */
8945 		if (err == -NFS4ERR_WRONGSEC)
8946 			err = _nfs41_proc_secinfo_no_name(server, fhandle, info,
8947 							  flavors, false);
8948 
8949 		switch (err) {
8950 		case 0:
8951 		case -NFS4ERR_WRONGSEC:
8952 		case -ENOTSUPP:
8953 			goto out;
8954 		default:
8955 			err = nfs4_handle_exception(server, err, &exception);
8956 		}
8957 	} while (exception.retry);
8958 out:
8959 	return err;
8960 }
8961 
8962 static int
8963 nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
8964 		    struct nfs_fsinfo *info)
8965 {
8966 	int err;
8967 	struct page *page;
8968 	rpc_authflavor_t flavor = RPC_AUTH_MAXFLAVOR;
8969 	struct nfs4_secinfo_flavors *flavors;
8970 	struct nfs4_secinfo4 *secinfo;
8971 	int i;
8972 
8973 	page = alloc_page(GFP_KERNEL);
8974 	if (!page) {
8975 		err = -ENOMEM;
8976 		goto out;
8977 	}
8978 
8979 	flavors = page_address(page);
8980 	err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
8981 
8982 	/*
8983 	 * Fall back on "guess and check" method if
8984 	 * the server doesn't support SECINFO_NO_NAME
8985 	 */
8986 	if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
8987 		err = nfs4_find_root_sec(server, fhandle, info);
8988 		goto out_freepage;
8989 	}
8990 	if (err)
8991 		goto out_freepage;
8992 
8993 	for (i = 0; i < flavors->num_flavors; i++) {
8994 		secinfo = &flavors->flavors[i];
8995 
8996 		switch (secinfo->flavor) {
8997 		case RPC_AUTH_NULL:
8998 		case RPC_AUTH_UNIX:
8999 		case RPC_AUTH_GSS:
9000 			flavor = rpcauth_get_pseudoflavor(secinfo->flavor,
9001 					&secinfo->flavor_info);
9002 			break;
9003 		default:
9004 			flavor = RPC_AUTH_MAXFLAVOR;
9005 			break;
9006 		}
9007 
9008 		if (!nfs_auth_info_match(&server->auth_info, flavor))
9009 			flavor = RPC_AUTH_MAXFLAVOR;
9010 
9011 		if (flavor != RPC_AUTH_MAXFLAVOR) {
9012 			err = nfs4_lookup_root_sec(server, fhandle,
9013 						   info, flavor);
9014 			if (!err)
9015 				break;
9016 		}
9017 	}
9018 
9019 	if (flavor == RPC_AUTH_MAXFLAVOR)
9020 		err = -EPERM;
9021 
9022 out_freepage:
9023 	put_page(page);
9024 	if (err == -EACCES)
9025 		return -EPERM;
9026 out:
9027 	return err;
9028 }
9029 
9030 static int _nfs41_test_stateid(struct nfs_server *server,
9031 		nfs4_stateid *stateid,
9032 		struct rpc_cred *cred)
9033 {
9034 	int status;
9035 	struct nfs41_test_stateid_args args = {
9036 		.stateid = stateid,
9037 	};
9038 	struct nfs41_test_stateid_res res;
9039 	struct rpc_message msg = {
9040 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
9041 		.rpc_argp = &args,
9042 		.rpc_resp = &res,
9043 		.rpc_cred = cred,
9044 	};
9045 	struct rpc_clnt *rpc_client = server->client;
9046 
9047 	nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9048 		&rpc_client, &msg);
9049 
9050 	dprintk("NFS call  test_stateid %p\n", stateid);
9051 	nfs4_init_sequence(&args.seq_args, &res.seq_res, 0);
9052 	nfs4_set_sequence_privileged(&args.seq_args);
9053 	status = nfs4_call_sync_sequence(rpc_client, server, &msg,
9054 			&args.seq_args, &res.seq_res);
9055 	if (status != NFS_OK) {
9056 		dprintk("NFS reply test_stateid: failed, %d\n", status);
9057 		return status;
9058 	}
9059 	dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
9060 	return -res.status;
9061 }
9062 
9063 static void nfs4_handle_delay_or_session_error(struct nfs_server *server,
9064 		int err, struct nfs4_exception *exception)
9065 {
9066 	exception->retry = 0;
9067 	switch(err) {
9068 	case -NFS4ERR_DELAY:
9069 	case -NFS4ERR_RETRY_UNCACHED_REP:
9070 		nfs4_handle_exception(server, err, exception);
9071 		break;
9072 	case -NFS4ERR_BADSESSION:
9073 	case -NFS4ERR_BADSLOT:
9074 	case -NFS4ERR_BAD_HIGH_SLOT:
9075 	case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
9076 	case -NFS4ERR_DEADSESSION:
9077 		nfs4_do_handle_exception(server, err, exception);
9078 	}
9079 }
9080 
9081 /**
9082  * nfs41_test_stateid - perform a TEST_STATEID operation
9083  *
9084  * @server: server / transport on which to perform the operation
9085  * @stateid: state ID to test
9086  * @cred: credential
9087  *
9088  * Returns NFS_OK if the server recognizes that "stateid" is valid.
9089  * Otherwise a negative NFS4ERR value is returned if the operation
9090  * failed or the state ID is not currently valid.
9091  */
9092 static int nfs41_test_stateid(struct nfs_server *server,
9093 		nfs4_stateid *stateid,
9094 		struct rpc_cred *cred)
9095 {
9096 	struct nfs4_exception exception = { };
9097 	int err;
9098 	do {
9099 		err = _nfs41_test_stateid(server, stateid, cred);
9100 		nfs4_handle_delay_or_session_error(server, err, &exception);
9101 	} while (exception.retry);
9102 	return err;
9103 }
9104 
9105 struct nfs_free_stateid_data {
9106 	struct nfs_server *server;
9107 	struct nfs41_free_stateid_args args;
9108 	struct nfs41_free_stateid_res res;
9109 };
9110 
9111 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
9112 {
9113 	struct nfs_free_stateid_data *data = calldata;
9114 	nfs41_setup_sequence(nfs4_get_session(data->server),
9115 			&data->args.seq_args,
9116 			&data->res.seq_res,
9117 			task);
9118 }
9119 
9120 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
9121 {
9122 	struct nfs_free_stateid_data *data = calldata;
9123 
9124 	nfs41_sequence_done(task, &data->res.seq_res);
9125 
9126 	switch (task->tk_status) {
9127 	case -NFS4ERR_DELAY:
9128 		if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
9129 			rpc_restart_call_prepare(task);
9130 	}
9131 }
9132 
9133 static void nfs41_free_stateid_release(void *calldata)
9134 {
9135 	kfree(calldata);
9136 }
9137 
9138 static const struct rpc_call_ops nfs41_free_stateid_ops = {
9139 	.rpc_call_prepare = nfs41_free_stateid_prepare,
9140 	.rpc_call_done = nfs41_free_stateid_done,
9141 	.rpc_release = nfs41_free_stateid_release,
9142 };
9143 
9144 static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
9145 		const nfs4_stateid *stateid,
9146 		struct rpc_cred *cred,
9147 		bool privileged)
9148 {
9149 	struct rpc_message msg = {
9150 		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
9151 		.rpc_cred = cred,
9152 	};
9153 	struct rpc_task_setup task_setup = {
9154 		.rpc_client = server->client,
9155 		.rpc_message = &msg,
9156 		.callback_ops = &nfs41_free_stateid_ops,
9157 		.flags = RPC_TASK_ASYNC,
9158 	};
9159 	struct nfs_free_stateid_data *data;
9160 
9161 	nfs4_state_protect(server->nfs_client, NFS_SP4_MACH_CRED_STATEID,
9162 		&task_setup.rpc_client, &msg);
9163 
9164 	dprintk("NFS call  free_stateid %p\n", stateid);
9165 	data = kmalloc(sizeof(*data), GFP_NOFS);
9166 	if (!data)
9167 		return ERR_PTR(-ENOMEM);
9168 	data->server = server;
9169 	nfs4_stateid_copy(&data->args.stateid, stateid);
9170 
9171 	task_setup.callback_data = data;
9172 
9173 	msg.rpc_argp = &data->args;
9174 	msg.rpc_resp = &data->res;
9175 	nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
9176 	if (privileged)
9177 		nfs4_set_sequence_privileged(&data->args.seq_args);
9178 
9179 	return rpc_run_task(&task_setup);
9180 }
9181 
9182 /**
9183  * nfs41_free_stateid - perform a FREE_STATEID operation
9184  *
9185  * @server: server / transport on which to perform the operation
9186  * @stateid: state ID to release
9187  * @cred: credential
9188  * @is_recovery: set to true if this call needs to be privileged
9189  *
9190  * Note: this function is always asynchronous.
9191  */
9192 static int nfs41_free_stateid(struct nfs_server *server,
9193 		const nfs4_stateid *stateid,
9194 		struct rpc_cred *cred,
9195 		bool is_recovery)
9196 {
9197 	struct rpc_task *task;
9198 
9199 	task = _nfs41_free_stateid(server, stateid, cred, is_recovery);
9200 	if (IS_ERR(task))
9201 		return PTR_ERR(task);
9202 	rpc_put_task(task);
9203 	return 0;
9204 }
9205 
9206 static void
9207 nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
9208 {
9209 	struct rpc_cred *cred = lsp->ls_state->owner->so_cred;
9210 
9211 	nfs41_free_stateid(server, &lsp->ls_stateid, cred, false);
9212 	nfs4_free_lock_state(server, lsp);
9213 }
9214 
9215 static bool nfs41_match_stateid(const nfs4_stateid *s1,
9216 		const nfs4_stateid *s2)
9217 {
9218 	if (s1->type != s2->type)
9219 		return false;
9220 
9221 	if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
9222 		return false;
9223 
9224 	if (s1->seqid == s2->seqid)
9225 		return true;
9226 	if (s1->seqid == 0 || s2->seqid == 0)
9227 		return true;
9228 
9229 	return false;
9230 }
9231 
9232 #endif /* CONFIG_NFS_V4_1 */
9233 
9234 static bool nfs4_match_stateid(const nfs4_stateid *s1,
9235 		const nfs4_stateid *s2)
9236 {
9237 	return nfs4_stateid_match(s1, s2);
9238 }
9239 
9240 
9241 static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
9242 	.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9243 	.state_flag_bit	= NFS_STATE_RECLAIM_REBOOT,
9244 	.recover_open	= nfs4_open_reclaim,
9245 	.recover_lock	= nfs4_lock_reclaim,
9246 	.establish_clid = nfs4_init_clientid,
9247 	.detect_trunking = nfs40_discover_server_trunking,
9248 };
9249 
9250 #if defined(CONFIG_NFS_V4_1)
9251 static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
9252 	.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
9253 	.state_flag_bit	= NFS_STATE_RECLAIM_REBOOT,
9254 	.recover_open	= nfs4_open_reclaim,
9255 	.recover_lock	= nfs4_lock_reclaim,
9256 	.establish_clid = nfs41_init_clientid,
9257 	.reclaim_complete = nfs41_proc_reclaim_complete,
9258 	.detect_trunking = nfs41_discover_server_trunking,
9259 };
9260 #endif /* CONFIG_NFS_V4_1 */
9261 
9262 static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
9263 	.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9264 	.state_flag_bit	= NFS_STATE_RECLAIM_NOGRACE,
9265 	.recover_open	= nfs40_open_expired,
9266 	.recover_lock	= nfs4_lock_expired,
9267 	.establish_clid = nfs4_init_clientid,
9268 };
9269 
9270 #if defined(CONFIG_NFS_V4_1)
9271 static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
9272 	.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
9273 	.state_flag_bit	= NFS_STATE_RECLAIM_NOGRACE,
9274 	.recover_open	= nfs41_open_expired,
9275 	.recover_lock	= nfs41_lock_expired,
9276 	.establish_clid = nfs41_init_clientid,
9277 };
9278 #endif /* CONFIG_NFS_V4_1 */
9279 
9280 static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
9281 	.sched_state_renewal = nfs4_proc_async_renew,
9282 	.get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
9283 	.renew_lease = nfs4_proc_renew,
9284 };
9285 
9286 #if defined(CONFIG_NFS_V4_1)
9287 static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
9288 	.sched_state_renewal = nfs41_proc_async_sequence,
9289 	.get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
9290 	.renew_lease = nfs4_proc_sequence,
9291 };
9292 #endif
9293 
9294 static const struct nfs4_mig_recovery_ops nfs40_mig_recovery_ops = {
9295 	.get_locations = _nfs40_proc_get_locations,
9296 	.fsid_present = _nfs40_proc_fsid_present,
9297 };
9298 
9299 #if defined(CONFIG_NFS_V4_1)
9300 static const struct nfs4_mig_recovery_ops nfs41_mig_recovery_ops = {
9301 	.get_locations = _nfs41_proc_get_locations,
9302 	.fsid_present = _nfs41_proc_fsid_present,
9303 };
9304 #endif	/* CONFIG_NFS_V4_1 */
9305 
9306 static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
9307 	.minor_version = 0,
9308 	.init_caps = NFS_CAP_READDIRPLUS
9309 		| NFS_CAP_ATOMIC_OPEN
9310 		| NFS_CAP_POSIX_LOCK,
9311 	.init_client = nfs40_init_client,
9312 	.shutdown_client = nfs40_shutdown_client,
9313 	.match_stateid = nfs4_match_stateid,
9314 	.find_root_sec = nfs4_find_root_sec,
9315 	.free_lock_state = nfs4_release_lockowner,
9316 	.test_and_free_expired = nfs40_test_and_free_expired_stateid,
9317 	.alloc_seqid = nfs_alloc_seqid,
9318 	.call_sync_ops = &nfs40_call_sync_ops,
9319 	.reboot_recovery_ops = &nfs40_reboot_recovery_ops,
9320 	.nograce_recovery_ops = &nfs40_nograce_recovery_ops,
9321 	.state_renewal_ops = &nfs40_state_renewal_ops,
9322 	.mig_recovery_ops = &nfs40_mig_recovery_ops,
9323 };
9324 
9325 #if defined(CONFIG_NFS_V4_1)
9326 static struct nfs_seqid *
9327 nfs_alloc_no_seqid(struct nfs_seqid_counter *arg1, gfp_t arg2)
9328 {
9329 	return NULL;
9330 }
9331 
9332 static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
9333 	.minor_version = 1,
9334 	.init_caps = NFS_CAP_READDIRPLUS
9335 		| NFS_CAP_ATOMIC_OPEN
9336 		| NFS_CAP_POSIX_LOCK
9337 		| NFS_CAP_STATEID_NFSV41
9338 		| NFS_CAP_ATOMIC_OPEN_V1,
9339 	.init_client = nfs41_init_client,
9340 	.shutdown_client = nfs41_shutdown_client,
9341 	.match_stateid = nfs41_match_stateid,
9342 	.find_root_sec = nfs41_find_root_sec,
9343 	.free_lock_state = nfs41_free_lock_state,
9344 	.test_and_free_expired = nfs41_test_and_free_expired_stateid,
9345 	.alloc_seqid = nfs_alloc_no_seqid,
9346 	.session_trunk = nfs4_test_session_trunk,
9347 	.call_sync_ops = &nfs41_call_sync_ops,
9348 	.reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9349 	.nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9350 	.state_renewal_ops = &nfs41_state_renewal_ops,
9351 	.mig_recovery_ops = &nfs41_mig_recovery_ops,
9352 };
9353 #endif
9354 
9355 #if defined(CONFIG_NFS_V4_2)
9356 static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
9357 	.minor_version = 2,
9358 	.init_caps = NFS_CAP_READDIRPLUS
9359 		| NFS_CAP_ATOMIC_OPEN
9360 		| NFS_CAP_POSIX_LOCK
9361 		| NFS_CAP_STATEID_NFSV41
9362 		| NFS_CAP_ATOMIC_OPEN_V1
9363 		| NFS_CAP_ALLOCATE
9364 		| NFS_CAP_COPY
9365 		| NFS_CAP_DEALLOCATE
9366 		| NFS_CAP_SEEK
9367 		| NFS_CAP_LAYOUTSTATS
9368 		| NFS_CAP_CLONE,
9369 	.init_client = nfs41_init_client,
9370 	.shutdown_client = nfs41_shutdown_client,
9371 	.match_stateid = nfs41_match_stateid,
9372 	.find_root_sec = nfs41_find_root_sec,
9373 	.free_lock_state = nfs41_free_lock_state,
9374 	.call_sync_ops = &nfs41_call_sync_ops,
9375 	.test_and_free_expired = nfs41_test_and_free_expired_stateid,
9376 	.alloc_seqid = nfs_alloc_no_seqid,
9377 	.session_trunk = nfs4_test_session_trunk,
9378 	.reboot_recovery_ops = &nfs41_reboot_recovery_ops,
9379 	.nograce_recovery_ops = &nfs41_nograce_recovery_ops,
9380 	.state_renewal_ops = &nfs41_state_renewal_ops,
9381 	.mig_recovery_ops = &nfs41_mig_recovery_ops,
9382 };
9383 #endif
9384 
9385 const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
9386 	[0] = &nfs_v4_0_minor_ops,
9387 #if defined(CONFIG_NFS_V4_1)
9388 	[1] = &nfs_v4_1_minor_ops,
9389 #endif
9390 #if defined(CONFIG_NFS_V4_2)
9391 	[2] = &nfs_v4_2_minor_ops,
9392 #endif
9393 };
9394 
9395 static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size)
9396 {
9397 	ssize_t error, error2;
9398 
9399 	error = generic_listxattr(dentry, list, size);
9400 	if (error < 0)
9401 		return error;
9402 	if (list) {
9403 		list += error;
9404 		size -= error;
9405 	}
9406 
9407 	error2 = nfs4_listxattr_nfs4_label(d_inode(dentry), list, size);
9408 	if (error2 < 0)
9409 		return error2;
9410 	return error + error2;
9411 }
9412 
9413 static const struct inode_operations nfs4_dir_inode_operations = {
9414 	.create		= nfs_create,
9415 	.lookup		= nfs_lookup,
9416 	.atomic_open	= nfs_atomic_open,
9417 	.link		= nfs_link,
9418 	.unlink		= nfs_unlink,
9419 	.symlink	= nfs_symlink,
9420 	.mkdir		= nfs_mkdir,
9421 	.rmdir		= nfs_rmdir,
9422 	.mknod		= nfs_mknod,
9423 	.rename		= nfs_rename,
9424 	.permission	= nfs_permission,
9425 	.getattr	= nfs_getattr,
9426 	.setattr	= nfs_setattr,
9427 	.listxattr	= nfs4_listxattr,
9428 };
9429 
9430 static const struct inode_operations nfs4_file_inode_operations = {
9431 	.permission	= nfs_permission,
9432 	.getattr	= nfs_getattr,
9433 	.setattr	= nfs_setattr,
9434 	.listxattr	= nfs4_listxattr,
9435 };
9436 
9437 const struct nfs_rpc_ops nfs_v4_clientops = {
9438 	.version	= 4,			/* protocol version */
9439 	.dentry_ops	= &nfs4_dentry_operations,
9440 	.dir_inode_ops	= &nfs4_dir_inode_operations,
9441 	.file_inode_ops	= &nfs4_file_inode_operations,
9442 	.file_ops	= &nfs4_file_operations,
9443 	.getroot	= nfs4_proc_get_root,
9444 	.submount	= nfs4_submount,
9445 	.try_mount	= nfs4_try_mount,
9446 	.getattr	= nfs4_proc_getattr,
9447 	.setattr	= nfs4_proc_setattr,
9448 	.lookup		= nfs4_proc_lookup,
9449 	.access		= nfs4_proc_access,
9450 	.readlink	= nfs4_proc_readlink,
9451 	.create		= nfs4_proc_create,
9452 	.remove		= nfs4_proc_remove,
9453 	.unlink_setup	= nfs4_proc_unlink_setup,
9454 	.unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
9455 	.unlink_done	= nfs4_proc_unlink_done,
9456 	.rename_setup	= nfs4_proc_rename_setup,
9457 	.rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
9458 	.rename_done	= nfs4_proc_rename_done,
9459 	.link		= nfs4_proc_link,
9460 	.symlink	= nfs4_proc_symlink,
9461 	.mkdir		= nfs4_proc_mkdir,
9462 	.rmdir		= nfs4_proc_remove,
9463 	.readdir	= nfs4_proc_readdir,
9464 	.mknod		= nfs4_proc_mknod,
9465 	.statfs		= nfs4_proc_statfs,
9466 	.fsinfo		= nfs4_proc_fsinfo,
9467 	.pathconf	= nfs4_proc_pathconf,
9468 	.set_capabilities = nfs4_server_capabilities,
9469 	.decode_dirent	= nfs4_decode_dirent,
9470 	.pgio_rpc_prepare = nfs4_proc_pgio_rpc_prepare,
9471 	.read_setup	= nfs4_proc_read_setup,
9472 	.read_done	= nfs4_read_done,
9473 	.write_setup	= nfs4_proc_write_setup,
9474 	.write_done	= nfs4_write_done,
9475 	.commit_setup	= nfs4_proc_commit_setup,
9476 	.commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
9477 	.commit_done	= nfs4_commit_done,
9478 	.lock		= nfs4_proc_lock,
9479 	.clear_acl_cache = nfs4_zap_acl_attr,
9480 	.close_context  = nfs4_close_context,
9481 	.open_context	= nfs4_atomic_open,
9482 	.have_delegation = nfs4_have_delegation,
9483 	.return_delegation = nfs4_inode_return_delegation,
9484 	.alloc_client	= nfs4_alloc_client,
9485 	.init_client	= nfs4_init_client,
9486 	.free_client	= nfs4_free_client,
9487 	.create_server	= nfs4_create_server,
9488 	.clone_server	= nfs_clone_server,
9489 };
9490 
9491 static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
9492 	.name	= XATTR_NAME_NFSV4_ACL,
9493 	.list	= nfs4_xattr_list_nfs4_acl,
9494 	.get	= nfs4_xattr_get_nfs4_acl,
9495 	.set	= nfs4_xattr_set_nfs4_acl,
9496 };
9497 
9498 const struct xattr_handler *nfs4_xattr_handlers[] = {
9499 	&nfs4_xattr_nfs4_acl_handler,
9500 #ifdef CONFIG_NFS_V4_SECURITY_LABEL
9501 	&nfs4_xattr_nfs4_label_handler,
9502 #endif
9503 	NULL
9504 };
9505 
9506 /*
9507  * Local variables:
9508  *  c-basic-offset: 8
9509  * End:
9510  */
9511