xref: /openbmc/linux/fs/nfsd/nfs4proc.c (revision 2c64e9cb)
1 /*
2  *  Server-side procedures for NFSv4.
3  *
4  *  Copyright (c) 2002 The Regents of the University of Michigan.
5  *  All rights reserved.
6  *
7  *  Kendrick Smith <kmsmith@umich.edu>
8  *  Andy Adamson   <andros@umich.edu>
9  *
10  *  Redistribution and use in source and binary forms, with or without
11  *  modification, are permitted provided that the following conditions
12  *  are met:
13  *
14  *  1. Redistributions of source code must retain the above copyright
15  *     notice, this list of conditions and the following disclaimer.
16  *  2. Redistributions in binary form must reproduce the above copyright
17  *     notice, this list of conditions and the following disclaimer in the
18  *     documentation and/or other materials provided with the distribution.
19  *  3. Neither the name of the University nor the names of its
20  *     contributors may be used to endorse or promote products derived
21  *     from this software without specific prior written permission.
22  *
23  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28  *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29  *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30  *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34  */
35 #include <linux/fs_struct.h>
36 #include <linux/file.h>
37 #include <linux/falloc.h>
38 #include <linux/slab.h>
39 #include <linux/kthread.h>
40 
41 #include "idmap.h"
42 #include "cache.h"
43 #include "xdr4.h"
44 #include "vfs.h"
45 #include "current_stateid.h"
46 #include "netns.h"
47 #include "acl.h"
48 #include "pnfs.h"
49 #include "trace.h"
50 
51 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
52 #include <linux/security.h>
53 
54 static inline void
55 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
56 {
57 	struct inode *inode = d_inode(resfh->fh_dentry);
58 	int status;
59 
60 	inode_lock(inode);
61 	status = security_inode_setsecctx(resfh->fh_dentry,
62 		label->data, label->len);
63 	inode_unlock(inode);
64 
65 	if (status)
66 		/*
67 		 * XXX: We should really fail the whole open, but we may
68 		 * already have created a new file, so it may be too
69 		 * late.  For now this seems the least of evils:
70 		 */
71 		bmval[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
72 
73 	return;
74 }
75 #else
76 static inline void
77 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval)
78 { }
79 #endif
80 
81 #define NFSDDBG_FACILITY		NFSDDBG_PROC
82 
83 static u32 nfsd_attrmask[] = {
84 	NFSD_WRITEABLE_ATTRS_WORD0,
85 	NFSD_WRITEABLE_ATTRS_WORD1,
86 	NFSD_WRITEABLE_ATTRS_WORD2
87 };
88 
89 static u32 nfsd41_ex_attrmask[] = {
90 	NFSD_SUPPATTR_EXCLCREAT_WORD0,
91 	NFSD_SUPPATTR_EXCLCREAT_WORD1,
92 	NFSD_SUPPATTR_EXCLCREAT_WORD2
93 };
94 
95 static __be32
96 check_attr_support(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
97 		   u32 *bmval, u32 *writable)
98 {
99 	struct dentry *dentry = cstate->current_fh.fh_dentry;
100 	struct svc_export *exp = cstate->current_fh.fh_export;
101 
102 	if (!nfsd_attrs_supported(cstate->minorversion, bmval))
103 		return nfserr_attrnotsupp;
104 	if ((bmval[0] & FATTR4_WORD0_ACL) && !IS_POSIXACL(d_inode(dentry)))
105 		return nfserr_attrnotsupp;
106 	if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) &&
107 			!(exp->ex_flags & NFSEXP_SECURITY_LABEL))
108 		return nfserr_attrnotsupp;
109 	if (writable && !bmval_is_subset(bmval, writable))
110 		return nfserr_inval;
111 	if (writable && (bmval[2] & FATTR4_WORD2_MODE_UMASK) &&
112 			(bmval[1] & FATTR4_WORD1_MODE))
113 		return nfserr_inval;
114 	return nfs_ok;
115 }
116 
117 static __be32
118 nfsd4_check_open_attributes(struct svc_rqst *rqstp,
119 	struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
120 {
121 	__be32 status = nfs_ok;
122 
123 	if (open->op_create == NFS4_OPEN_CREATE) {
124 		if (open->op_createmode == NFS4_CREATE_UNCHECKED
125 		    || open->op_createmode == NFS4_CREATE_GUARDED)
126 			status = check_attr_support(rqstp, cstate,
127 					open->op_bmval, nfsd_attrmask);
128 		else if (open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1)
129 			status = check_attr_support(rqstp, cstate,
130 					open->op_bmval, nfsd41_ex_attrmask);
131 	}
132 
133 	return status;
134 }
135 
136 static int
137 is_create_with_attrs(struct nfsd4_open *open)
138 {
139 	return open->op_create == NFS4_OPEN_CREATE
140 		&& (open->op_createmode == NFS4_CREATE_UNCHECKED
141 		    || open->op_createmode == NFS4_CREATE_GUARDED
142 		    || open->op_createmode == NFS4_CREATE_EXCLUSIVE4_1);
143 }
144 
145 /*
146  * if error occurs when setting the acl, just clear the acl bit
147  * in the returned attr bitmap.
148  */
149 static void
150 do_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
151 		struct nfs4_acl *acl, u32 *bmval)
152 {
153 	__be32 status;
154 
155 	status = nfsd4_set_nfs4_acl(rqstp, fhp, acl);
156 	if (status)
157 		/*
158 		 * We should probably fail the whole open at this point,
159 		 * but we've already created the file, so it's too late;
160 		 * So this seems the least of evils:
161 		 */
162 		bmval[0] &= ~FATTR4_WORD0_ACL;
163 }
164 
165 static inline void
166 fh_dup2(struct svc_fh *dst, struct svc_fh *src)
167 {
168 	fh_put(dst);
169 	dget(src->fh_dentry);
170 	if (src->fh_export)
171 		exp_get(src->fh_export);
172 	*dst = *src;
173 }
174 
175 static __be32
176 do_open_permission(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open, int accmode)
177 {
178 	__be32 status;
179 
180 	if (open->op_truncate &&
181 		!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
182 		return nfserr_inval;
183 
184 	accmode |= NFSD_MAY_READ_IF_EXEC;
185 
186 	if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
187 		accmode |= NFSD_MAY_READ;
188 	if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
189 		accmode |= (NFSD_MAY_WRITE | NFSD_MAY_TRUNC);
190 	if (open->op_share_deny & NFS4_SHARE_DENY_READ)
191 		accmode |= NFSD_MAY_WRITE;
192 
193 	status = fh_verify(rqstp, current_fh, S_IFREG, accmode);
194 
195 	return status;
196 }
197 
198 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh)
199 {
200 	umode_t mode = d_inode(fh->fh_dentry)->i_mode;
201 
202 	if (S_ISREG(mode))
203 		return nfs_ok;
204 	if (S_ISDIR(mode))
205 		return nfserr_isdir;
206 	/*
207 	 * Using err_symlink as our catch-all case may look odd; but
208 	 * there's no other obvious error for this case in 4.0, and we
209 	 * happen to know that it will cause the linux v4 client to do
210 	 * the right thing on attempts to open something other than a
211 	 * regular file.
212 	 */
213 	return nfserr_symlink;
214 }
215 
216 static void nfsd4_set_open_owner_reply_cache(struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh *resfh)
217 {
218 	if (nfsd4_has_session(cstate))
219 		return;
220 	fh_copy_shallow(&open->op_openowner->oo_owner.so_replay.rp_openfh,
221 			&resfh->fh_handle);
222 }
223 
224 static __be32
225 do_open_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open, struct svc_fh **resfh)
226 {
227 	struct svc_fh *current_fh = &cstate->current_fh;
228 	int accmode;
229 	__be32 status;
230 
231 	*resfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
232 	if (!*resfh)
233 		return nfserr_jukebox;
234 	fh_init(*resfh, NFS4_FHSIZE);
235 	open->op_truncate = 0;
236 
237 	if (open->op_create) {
238 		/* FIXME: check session persistence and pnfs flags.
239 		 * The nfsv4.1 spec requires the following semantics:
240 		 *
241 		 * Persistent   | pNFS   | Server REQUIRED | Client Allowed
242 		 * Reply Cache  | server |                 |
243 		 * -------------+--------+-----------------+--------------------
244 		 * no           | no     | EXCLUSIVE4_1    | EXCLUSIVE4_1
245 		 *              |        |                 | (SHOULD)
246 		 *              |        | and EXCLUSIVE4  | or EXCLUSIVE4
247 		 *              |        |                 | (SHOULD NOT)
248 		 * no           | yes    | EXCLUSIVE4_1    | EXCLUSIVE4_1
249 		 * yes          | no     | GUARDED4        | GUARDED4
250 		 * yes          | yes    | GUARDED4        | GUARDED4
251 		 */
252 
253 		/*
254 		 * Note: create modes (UNCHECKED,GUARDED...) are the same
255 		 * in NFSv4 as in v3 except EXCLUSIVE4_1.
256 		 */
257 		current->fs->umask = open->op_umask;
258 		status = do_nfsd_create(rqstp, current_fh, open->op_fname.data,
259 					open->op_fname.len, &open->op_iattr,
260 					*resfh, open->op_createmode,
261 					(u32 *)open->op_verf.data,
262 					&open->op_truncate, &open->op_created);
263 		current->fs->umask = 0;
264 
265 		if (!status && open->op_label.len)
266 			nfsd4_security_inode_setsecctx(*resfh, &open->op_label, open->op_bmval);
267 
268 		/*
269 		 * Following rfc 3530 14.2.16, and rfc 5661 18.16.4
270 		 * use the returned bitmask to indicate which attributes
271 		 * we used to store the verifier:
272 		 */
273 		if (nfsd_create_is_exclusive(open->op_createmode) && status == 0)
274 			open->op_bmval[1] |= (FATTR4_WORD1_TIME_ACCESS |
275 						FATTR4_WORD1_TIME_MODIFY);
276 	} else
277 		/*
278 		 * Note this may exit with the parent still locked.
279 		 * We will hold the lock until nfsd4_open's final
280 		 * lookup, to prevent renames or unlinks until we've had
281 		 * a chance to an acquire a delegation if appropriate.
282 		 */
283 		status = nfsd_lookup(rqstp, current_fh,
284 				     open->op_fname.data, open->op_fname.len, *resfh);
285 	if (status)
286 		goto out;
287 	status = nfsd_check_obj_isreg(*resfh);
288 	if (status)
289 		goto out;
290 
291 	if (is_create_with_attrs(open) && open->op_acl != NULL)
292 		do_set_nfs4_acl(rqstp, *resfh, open->op_acl, open->op_bmval);
293 
294 	nfsd4_set_open_owner_reply_cache(cstate, open, *resfh);
295 	accmode = NFSD_MAY_NOP;
296 	if (open->op_created ||
297 			open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
298 		accmode |= NFSD_MAY_OWNER_OVERRIDE;
299 	status = do_open_permission(rqstp, *resfh, open, accmode);
300 	set_change_info(&open->op_cinfo, current_fh);
301 out:
302 	return status;
303 }
304 
305 static __be32
306 do_open_fhandle(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
307 {
308 	struct svc_fh *current_fh = &cstate->current_fh;
309 	__be32 status;
310 	int accmode = 0;
311 
312 	/* We don't know the target directory, and therefore can not
313 	* set the change info
314 	*/
315 
316 	memset(&open->op_cinfo, 0, sizeof(struct nfsd4_change_info));
317 
318 	nfsd4_set_open_owner_reply_cache(cstate, open, current_fh);
319 
320 	open->op_truncate = (open->op_iattr.ia_valid & ATTR_SIZE) &&
321 		(open->op_iattr.ia_size == 0);
322 	/*
323 	 * In the delegation case, the client is telling us about an
324 	 * open that it *already* performed locally, some time ago.  We
325 	 * should let it succeed now if possible.
326 	 *
327 	 * In the case of a CLAIM_FH open, on the other hand, the client
328 	 * may be counting on us to enforce permissions (the Linux 4.1
329 	 * client uses this for normal opens, for example).
330 	 */
331 	if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH)
332 		accmode = NFSD_MAY_OWNER_OVERRIDE;
333 
334 	status = do_open_permission(rqstp, current_fh, open, accmode);
335 
336 	return status;
337 }
338 
339 static void
340 copy_clientid(clientid_t *clid, struct nfsd4_session *session)
341 {
342 	struct nfsd4_sessionid *sid =
343 			(struct nfsd4_sessionid *)session->se_sessionid.data;
344 
345 	clid->cl_boot = sid->clientid.cl_boot;
346 	clid->cl_id = sid->clientid.cl_id;
347 }
348 
349 static __be32
350 nfsd4_open(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
351 	   union nfsd4_op_u *u)
352 {
353 	struct nfsd4_open *open = &u->open;
354 	__be32 status;
355 	struct svc_fh *resfh = NULL;
356 	struct net *net = SVC_NET(rqstp);
357 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
358 	bool reclaim = false;
359 
360 	dprintk("NFSD: nfsd4_open filename %.*s op_openowner %p\n",
361 		(int)open->op_fname.len, open->op_fname.data,
362 		open->op_openowner);
363 
364 	/* This check required by spec. */
365 	if (open->op_create && open->op_claim_type != NFS4_OPEN_CLAIM_NULL)
366 		return nfserr_inval;
367 
368 	open->op_created = 0;
369 	/*
370 	 * RFC5661 18.51.3
371 	 * Before RECLAIM_COMPLETE done, server should deny new lock
372 	 */
373 	if (nfsd4_has_session(cstate) &&
374 	    !test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
375 		      &cstate->session->se_client->cl_flags) &&
376 	    open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
377 		return nfserr_grace;
378 
379 	if (nfsd4_has_session(cstate))
380 		copy_clientid(&open->op_clientid, cstate->session);
381 
382 	/* check seqid for replay. set nfs4_owner */
383 	status = nfsd4_process_open1(cstate, open, nn);
384 	if (status == nfserr_replay_me) {
385 		struct nfs4_replay *rp = &open->op_openowner->oo_owner.so_replay;
386 		fh_put(&cstate->current_fh);
387 		fh_copy_shallow(&cstate->current_fh.fh_handle,
388 				&rp->rp_openfh);
389 		status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
390 		if (status)
391 			dprintk("nfsd4_open: replay failed"
392 				" restoring previous filehandle\n");
393 		else
394 			status = nfserr_replay_me;
395 	}
396 	if (status)
397 		goto out;
398 	if (open->op_xdr_error) {
399 		status = open->op_xdr_error;
400 		goto out;
401 	}
402 
403 	status = nfsd4_check_open_attributes(rqstp, cstate, open);
404 	if (status)
405 		goto out;
406 
407 	/* Openowner is now set, so sequence id will get bumped.  Now we need
408 	 * these checks before we do any creates: */
409 	status = nfserr_grace;
410 	if (opens_in_grace(net) && open->op_claim_type != NFS4_OPEN_CLAIM_PREVIOUS)
411 		goto out;
412 	status = nfserr_no_grace;
413 	if (!opens_in_grace(net) && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
414 		goto out;
415 
416 	switch (open->op_claim_type) {
417 		case NFS4_OPEN_CLAIM_DELEGATE_CUR:
418 		case NFS4_OPEN_CLAIM_NULL:
419 			status = do_open_lookup(rqstp, cstate, open, &resfh);
420 			if (status)
421 				goto out;
422 			break;
423 		case NFS4_OPEN_CLAIM_PREVIOUS:
424 			status = nfs4_check_open_reclaim(&open->op_clientid,
425 							 cstate, nn);
426 			if (status)
427 				goto out;
428 			open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
429 			reclaim = true;
430 			/* fall through */
431 		case NFS4_OPEN_CLAIM_FH:
432 		case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
433 			status = do_open_fhandle(rqstp, cstate, open);
434 			if (status)
435 				goto out;
436 			resfh = &cstate->current_fh;
437 			break;
438 		case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
439              	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
440 			dprintk("NFSD: unsupported OPEN claim type %d\n",
441 				open->op_claim_type);
442 			status = nfserr_notsupp;
443 			goto out;
444 		default:
445 			dprintk("NFSD: Invalid OPEN claim type %d\n",
446 				open->op_claim_type);
447 			status = nfserr_inval;
448 			goto out;
449 	}
450 	/*
451 	 * nfsd4_process_open2() does the actual opening of the file.  If
452 	 * successful, it (1) truncates the file if open->op_truncate was
453 	 * set, (2) sets open->op_stateid, (3) sets open->op_delegation.
454 	 */
455 	status = nfsd4_process_open2(rqstp, resfh, open);
456 	WARN(status && open->op_created,
457 	     "nfsd4_process_open2 failed to open newly-created file! status=%u\n",
458 	     be32_to_cpu(status));
459 	if (reclaim && !status)
460 		nn->somebody_reclaimed = true;
461 out:
462 	if (resfh && resfh != &cstate->current_fh) {
463 		fh_dup2(&cstate->current_fh, resfh);
464 		fh_put(resfh);
465 		kfree(resfh);
466 	}
467 	nfsd4_cleanup_open_state(cstate, open);
468 	nfsd4_bump_seqid(cstate, status);
469 	return status;
470 }
471 
472 /*
473  * OPEN is the only seqid-mutating operation whose decoding can fail
474  * with a seqid-mutating error (specifically, decoding of user names in
475  * the attributes).  Therefore we have to do some processing to look up
476  * the stateowner so that we can bump the seqid.
477  */
478 static __be32 nfsd4_open_omfg(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_op *op)
479 {
480 	struct nfsd4_open *open = &op->u.open;
481 
482 	if (!seqid_mutating_err(ntohl(op->status)))
483 		return op->status;
484 	if (nfsd4_has_session(cstate))
485 		return op->status;
486 	open->op_xdr_error = op->status;
487 	return nfsd4_open(rqstp, cstate, &op->u);
488 }
489 
490 /*
491  * filehandle-manipulating ops.
492  */
493 static __be32
494 nfsd4_getfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
495 	    union nfsd4_op_u *u)
496 {
497 	u->getfh = &cstate->current_fh;
498 	return nfs_ok;
499 }
500 
501 static __be32
502 nfsd4_putfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
503 	    union nfsd4_op_u *u)
504 {
505 	struct nfsd4_putfh *putfh = &u->putfh;
506 
507 	fh_put(&cstate->current_fh);
508 	cstate->current_fh.fh_handle.fh_size = putfh->pf_fhlen;
509 	memcpy(&cstate->current_fh.fh_handle.fh_base, putfh->pf_fhval,
510 	       putfh->pf_fhlen);
511 	return fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_BYPASS_GSS);
512 }
513 
514 static __be32
515 nfsd4_putrootfh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
516 		union nfsd4_op_u *u)
517 {
518 	__be32 status;
519 
520 	fh_put(&cstate->current_fh);
521 	status = exp_pseudoroot(rqstp, &cstate->current_fh);
522 	return status;
523 }
524 
525 static __be32
526 nfsd4_restorefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
527 		union nfsd4_op_u *u)
528 {
529 	if (!cstate->save_fh.fh_dentry)
530 		return nfserr_restorefh;
531 
532 	fh_dup2(&cstate->current_fh, &cstate->save_fh);
533 	if (HAS_STATE_ID(cstate, SAVED_STATE_ID_FLAG)) {
534 		memcpy(&cstate->current_stateid, &cstate->save_stateid, sizeof(stateid_t));
535 		SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
536 	}
537 	return nfs_ok;
538 }
539 
540 static __be32
541 nfsd4_savefh(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
542 	     union nfsd4_op_u *u)
543 {
544 	fh_dup2(&cstate->save_fh, &cstate->current_fh);
545 	if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG)) {
546 		memcpy(&cstate->save_stateid, &cstate->current_stateid, sizeof(stateid_t));
547 		SET_STATE_ID(cstate, SAVED_STATE_ID_FLAG);
548 	}
549 	return nfs_ok;
550 }
551 
552 /*
553  * misc nfsv4 ops
554  */
555 static __be32
556 nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
557 	     union nfsd4_op_u *u)
558 {
559 	struct nfsd4_access *access = &u->access;
560 
561 	if (access->ac_req_access & ~NFS3_ACCESS_FULL)
562 		return nfserr_inval;
563 
564 	access->ac_resp_access = access->ac_req_access;
565 	return nfsd_access(rqstp, &cstate->current_fh, &access->ac_resp_access,
566 			   &access->ac_supported);
567 }
568 
569 static void gen_boot_verifier(nfs4_verifier *verifier, struct net *net)
570 {
571 	__be32 verf[2];
572 	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
573 
574 	/*
575 	 * This is opaque to client, so no need to byte-swap. Use
576 	 * __force to keep sparse happy. y2038 time_t overflow is
577 	 * irrelevant in this usage.
578 	 */
579 	verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec;
580 	verf[1] = (__force __be32)nn->nfssvc_boot.tv_nsec;
581 	memcpy(verifier->data, verf, sizeof(verifier->data));
582 }
583 
584 static __be32
585 nfsd4_commit(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
586 	     union nfsd4_op_u *u)
587 {
588 	struct nfsd4_commit *commit = &u->commit;
589 
590 	gen_boot_verifier(&commit->co_verf, SVC_NET(rqstp));
591 	return nfsd_commit(rqstp, &cstate->current_fh, commit->co_offset,
592 			     commit->co_count);
593 }
594 
595 static __be32
596 nfsd4_create(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
597 	     union nfsd4_op_u *u)
598 {
599 	struct nfsd4_create *create = &u->create;
600 	struct svc_fh resfh;
601 	__be32 status;
602 	dev_t rdev;
603 
604 	fh_init(&resfh, NFS4_FHSIZE);
605 
606 	status = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_NOP);
607 	if (status)
608 		return status;
609 
610 	status = check_attr_support(rqstp, cstate, create->cr_bmval,
611 				    nfsd_attrmask);
612 	if (status)
613 		return status;
614 
615 	current->fs->umask = create->cr_umask;
616 	switch (create->cr_type) {
617 	case NF4LNK:
618 		status = nfsd_symlink(rqstp, &cstate->current_fh,
619 				      create->cr_name, create->cr_namelen,
620 				      create->cr_data, &resfh);
621 		break;
622 
623 	case NF4BLK:
624 		status = nfserr_inval;
625 		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
626 		if (MAJOR(rdev) != create->cr_specdata1 ||
627 		    MINOR(rdev) != create->cr_specdata2)
628 			goto out_umask;
629 		status = nfsd_create(rqstp, &cstate->current_fh,
630 				     create->cr_name, create->cr_namelen,
631 				     &create->cr_iattr, S_IFBLK, rdev, &resfh);
632 		break;
633 
634 	case NF4CHR:
635 		status = nfserr_inval;
636 		rdev = MKDEV(create->cr_specdata1, create->cr_specdata2);
637 		if (MAJOR(rdev) != create->cr_specdata1 ||
638 		    MINOR(rdev) != create->cr_specdata2)
639 			goto out_umask;
640 		status = nfsd_create(rqstp, &cstate->current_fh,
641 				     create->cr_name, create->cr_namelen,
642 				     &create->cr_iattr,S_IFCHR, rdev, &resfh);
643 		break;
644 
645 	case NF4SOCK:
646 		status = nfsd_create(rqstp, &cstate->current_fh,
647 				     create->cr_name, create->cr_namelen,
648 				     &create->cr_iattr, S_IFSOCK, 0, &resfh);
649 		break;
650 
651 	case NF4FIFO:
652 		status = nfsd_create(rqstp, &cstate->current_fh,
653 				     create->cr_name, create->cr_namelen,
654 				     &create->cr_iattr, S_IFIFO, 0, &resfh);
655 		break;
656 
657 	case NF4DIR:
658 		create->cr_iattr.ia_valid &= ~ATTR_SIZE;
659 		status = nfsd_create(rqstp, &cstate->current_fh,
660 				     create->cr_name, create->cr_namelen,
661 				     &create->cr_iattr, S_IFDIR, 0, &resfh);
662 		break;
663 
664 	default:
665 		status = nfserr_badtype;
666 	}
667 
668 	if (status)
669 		goto out;
670 
671 	if (create->cr_label.len)
672 		nfsd4_security_inode_setsecctx(&resfh, &create->cr_label, create->cr_bmval);
673 
674 	if (create->cr_acl != NULL)
675 		do_set_nfs4_acl(rqstp, &resfh, create->cr_acl,
676 				create->cr_bmval);
677 
678 	fh_unlock(&cstate->current_fh);
679 	set_change_info(&create->cr_cinfo, &cstate->current_fh);
680 	fh_dup2(&cstate->current_fh, &resfh);
681 out:
682 	fh_put(&resfh);
683 out_umask:
684 	current->fs->umask = 0;
685 	return status;
686 }
687 
688 static __be32
689 nfsd4_getattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
690 	      union nfsd4_op_u *u)
691 {
692 	struct nfsd4_getattr *getattr = &u->getattr;
693 	__be32 status;
694 
695 	status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
696 	if (status)
697 		return status;
698 
699 	if (getattr->ga_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
700 		return nfserr_inval;
701 
702 	getattr->ga_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
703 	getattr->ga_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
704 	getattr->ga_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
705 
706 	getattr->ga_fhp = &cstate->current_fh;
707 	return nfs_ok;
708 }
709 
710 static __be32
711 nfsd4_link(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
712 	   union nfsd4_op_u *u)
713 {
714 	struct nfsd4_link *link = &u->link;
715 	__be32 status;
716 
717 	status = nfsd_link(rqstp, &cstate->current_fh,
718 			   link->li_name, link->li_namelen, &cstate->save_fh);
719 	if (!status)
720 		set_change_info(&link->li_cinfo, &cstate->current_fh);
721 	return status;
722 }
723 
724 static __be32 nfsd4_do_lookupp(struct svc_rqst *rqstp, struct svc_fh *fh)
725 {
726 	struct svc_fh tmp_fh;
727 	__be32 ret;
728 
729 	fh_init(&tmp_fh, NFS4_FHSIZE);
730 	ret = exp_pseudoroot(rqstp, &tmp_fh);
731 	if (ret)
732 		return ret;
733 	if (tmp_fh.fh_dentry == fh->fh_dentry) {
734 		fh_put(&tmp_fh);
735 		return nfserr_noent;
736 	}
737 	fh_put(&tmp_fh);
738 	return nfsd_lookup(rqstp, fh, "..", 2, fh);
739 }
740 
741 static __be32
742 nfsd4_lookupp(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
743 	      union nfsd4_op_u *u)
744 {
745 	return nfsd4_do_lookupp(rqstp, &cstate->current_fh);
746 }
747 
748 static __be32
749 nfsd4_lookup(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
750 	     union nfsd4_op_u *u)
751 {
752 	return nfsd_lookup(rqstp, &cstate->current_fh,
753 			   u->lookup.lo_name, u->lookup.lo_len,
754 			   &cstate->current_fh);
755 }
756 
757 static __be32
758 nfsd4_read(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
759 	   union nfsd4_op_u *u)
760 {
761 	struct nfsd4_read *read = &u->read;
762 	__be32 status;
763 
764 	read->rd_filp = NULL;
765 	if (read->rd_offset >= OFFSET_MAX)
766 		return nfserr_inval;
767 
768 	trace_nfsd_read_start(rqstp, &cstate->current_fh,
769 			      read->rd_offset, read->rd_length);
770 
771 	/*
772 	 * If we do a zero copy read, then a client will see read data
773 	 * that reflects the state of the file *after* performing the
774 	 * following compound.
775 	 *
776 	 * To ensure proper ordering, we therefore turn off zero copy if
777 	 * the client wants us to do more in this compound:
778 	 */
779 	if (!nfsd4_last_compound_op(rqstp))
780 		clear_bit(RQ_SPLICE_OK, &rqstp->rq_flags);
781 
782 	/* check stateid */
783 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
784 					&read->rd_stateid, RD_STATE,
785 					&read->rd_filp, &read->rd_tmp_file);
786 	if (status) {
787 		dprintk("NFSD: nfsd4_read: couldn't process stateid!\n");
788 		goto out;
789 	}
790 	status = nfs_ok;
791 out:
792 	read->rd_rqstp = rqstp;
793 	read->rd_fhp = &cstate->current_fh;
794 	return status;
795 }
796 
797 
798 static void
799 nfsd4_read_release(union nfsd4_op_u *u)
800 {
801 	if (u->read.rd_filp)
802 		fput(u->read.rd_filp);
803 	trace_nfsd_read_done(u->read.rd_rqstp, u->read.rd_fhp,
804 			     u->read.rd_offset, u->read.rd_length);
805 }
806 
807 static __be32
808 nfsd4_readdir(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
809 	      union nfsd4_op_u *u)
810 {
811 	struct nfsd4_readdir *readdir = &u->readdir;
812 	u64 cookie = readdir->rd_cookie;
813 	static const nfs4_verifier zeroverf;
814 
815 	/* no need to check permission - this will be done in nfsd_readdir() */
816 
817 	if (readdir->rd_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1)
818 		return nfserr_inval;
819 
820 	readdir->rd_bmval[0] &= nfsd_suppattrs[cstate->minorversion][0];
821 	readdir->rd_bmval[1] &= nfsd_suppattrs[cstate->minorversion][1];
822 	readdir->rd_bmval[2] &= nfsd_suppattrs[cstate->minorversion][2];
823 
824 	if ((cookie == 1) || (cookie == 2) ||
825 	    (cookie == 0 && memcmp(readdir->rd_verf.data, zeroverf.data, NFS4_VERIFIER_SIZE)))
826 		return nfserr_bad_cookie;
827 
828 	readdir->rd_rqstp = rqstp;
829 	readdir->rd_fhp = &cstate->current_fh;
830 	return nfs_ok;
831 }
832 
833 static __be32
834 nfsd4_readlink(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
835 	       union nfsd4_op_u *u)
836 {
837 	u->readlink.rl_rqstp = rqstp;
838 	u->readlink.rl_fhp = &cstate->current_fh;
839 	return nfs_ok;
840 }
841 
842 static __be32
843 nfsd4_remove(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
844 	     union nfsd4_op_u *u)
845 {
846 	struct nfsd4_remove *remove = &u->remove;
847 	__be32 status;
848 
849 	if (opens_in_grace(SVC_NET(rqstp)))
850 		return nfserr_grace;
851 	status = nfsd_unlink(rqstp, &cstate->current_fh, 0,
852 			     remove->rm_name, remove->rm_namelen);
853 	if (!status) {
854 		fh_unlock(&cstate->current_fh);
855 		set_change_info(&remove->rm_cinfo, &cstate->current_fh);
856 	}
857 	return status;
858 }
859 
860 static __be32
861 nfsd4_rename(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
862 	     union nfsd4_op_u *u)
863 {
864 	struct nfsd4_rename *rename = &u->rename;
865 	__be32 status;
866 
867 	if (opens_in_grace(SVC_NET(rqstp)))
868 		return nfserr_grace;
869 	status = nfsd_rename(rqstp, &cstate->save_fh, rename->rn_sname,
870 			     rename->rn_snamelen, &cstate->current_fh,
871 			     rename->rn_tname, rename->rn_tnamelen);
872 	if (status)
873 		return status;
874 	set_change_info(&rename->rn_sinfo, &cstate->current_fh);
875 	set_change_info(&rename->rn_tinfo, &cstate->save_fh);
876 	return nfs_ok;
877 }
878 
879 static __be32
880 nfsd4_secinfo(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
881 	      union nfsd4_op_u *u)
882 {
883 	struct nfsd4_secinfo *secinfo = &u->secinfo;
884 	struct svc_export *exp;
885 	struct dentry *dentry;
886 	__be32 err;
887 
888 	err = fh_verify(rqstp, &cstate->current_fh, S_IFDIR, NFSD_MAY_EXEC);
889 	if (err)
890 		return err;
891 	err = nfsd_lookup_dentry(rqstp, &cstate->current_fh,
892 				    secinfo->si_name, secinfo->si_namelen,
893 				    &exp, &dentry);
894 	if (err)
895 		return err;
896 	fh_unlock(&cstate->current_fh);
897 	if (d_really_is_negative(dentry)) {
898 		exp_put(exp);
899 		err = nfserr_noent;
900 	} else
901 		secinfo->si_exp = exp;
902 	dput(dentry);
903 	if (cstate->minorversion)
904 		/* See rfc 5661 section 2.6.3.1.1.8 */
905 		fh_put(&cstate->current_fh);
906 	return err;
907 }
908 
909 static __be32
910 nfsd4_secinfo_no_name(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
911 		union nfsd4_op_u *u)
912 {
913 	__be32 err;
914 
915 	switch (u->secinfo_no_name.sin_style) {
916 	case NFS4_SECINFO_STYLE4_CURRENT_FH:
917 		break;
918 	case NFS4_SECINFO_STYLE4_PARENT:
919 		err = nfsd4_do_lookupp(rqstp, &cstate->current_fh);
920 		if (err)
921 			return err;
922 		break;
923 	default:
924 		return nfserr_inval;
925 	}
926 
927 	u->secinfo_no_name.sin_exp = exp_get(cstate->current_fh.fh_export);
928 	fh_put(&cstate->current_fh);
929 	return nfs_ok;
930 }
931 
932 static void
933 nfsd4_secinfo_release(union nfsd4_op_u *u)
934 {
935 	if (u->secinfo.si_exp)
936 		exp_put(u->secinfo.si_exp);
937 }
938 
939 static void
940 nfsd4_secinfo_no_name_release(union nfsd4_op_u *u)
941 {
942 	if (u->secinfo_no_name.sin_exp)
943 		exp_put(u->secinfo_no_name.sin_exp);
944 }
945 
946 static __be32
947 nfsd4_setattr(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
948 	      union nfsd4_op_u *u)
949 {
950 	struct nfsd4_setattr *setattr = &u->setattr;
951 	__be32 status = nfs_ok;
952 	int err;
953 
954 	if (setattr->sa_iattr.ia_valid & ATTR_SIZE) {
955 		status = nfs4_preprocess_stateid_op(rqstp, cstate,
956 				&cstate->current_fh, &setattr->sa_stateid,
957 				WR_STATE, NULL, NULL);
958 		if (status) {
959 			dprintk("NFSD: nfsd4_setattr: couldn't process stateid!\n");
960 			return status;
961 		}
962 	}
963 	err = fh_want_write(&cstate->current_fh);
964 	if (err)
965 		return nfserrno(err);
966 	status = nfs_ok;
967 
968 	status = check_attr_support(rqstp, cstate, setattr->sa_bmval,
969 				    nfsd_attrmask);
970 	if (status)
971 		goto out;
972 
973 	if (setattr->sa_acl != NULL)
974 		status = nfsd4_set_nfs4_acl(rqstp, &cstate->current_fh,
975 					    setattr->sa_acl);
976 	if (status)
977 		goto out;
978 	if (setattr->sa_label.len)
979 		status = nfsd4_set_nfs4_label(rqstp, &cstate->current_fh,
980 				&setattr->sa_label);
981 	if (status)
982 		goto out;
983 	status = nfsd_setattr(rqstp, &cstate->current_fh, &setattr->sa_iattr,
984 				0, (time_t)0);
985 out:
986 	fh_drop_write(&cstate->current_fh);
987 	return status;
988 }
989 
990 static __be32
991 nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
992 	    union nfsd4_op_u *u)
993 {
994 	struct nfsd4_write *write = &u->write;
995 	stateid_t *stateid = &write->wr_stateid;
996 	struct file *filp = NULL;
997 	__be32 status = nfs_ok;
998 	unsigned long cnt;
999 	int nvecs;
1000 
1001 	if (write->wr_offset >= OFFSET_MAX)
1002 		return nfserr_inval;
1003 
1004 	cnt = write->wr_buflen;
1005 	trace_nfsd_write_start(rqstp, &cstate->current_fh,
1006 			       write->wr_offset, cnt);
1007 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1008 						stateid, WR_STATE, &filp, NULL);
1009 	if (status) {
1010 		dprintk("NFSD: nfsd4_write: couldn't process stateid!\n");
1011 		return status;
1012 	}
1013 
1014 	write->wr_how_written = write->wr_stable_how;
1015 	gen_boot_verifier(&write->wr_verifier, SVC_NET(rqstp));
1016 
1017 	nvecs = svc_fill_write_vector(rqstp, write->wr_pagelist,
1018 				      &write->wr_head, write->wr_buflen);
1019 	WARN_ON_ONCE(nvecs > ARRAY_SIZE(rqstp->rq_vec));
1020 
1021 	status = nfsd_vfs_write(rqstp, &cstate->current_fh, filp,
1022 				write->wr_offset, rqstp->rq_vec, nvecs, &cnt,
1023 				write->wr_how_written);
1024 	fput(filp);
1025 
1026 	write->wr_bytes_written = cnt;
1027 	trace_nfsd_write_done(rqstp, &cstate->current_fh,
1028 			      write->wr_offset, cnt);
1029 	return status;
1030 }
1031 
1032 static __be32
1033 nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1034 		  stateid_t *src_stateid, struct file **src,
1035 		  stateid_t *dst_stateid, struct file **dst)
1036 {
1037 	__be32 status;
1038 
1039 	if (!cstate->save_fh.fh_dentry)
1040 		return nfserr_nofilehandle;
1041 
1042 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
1043 					    src_stateid, RD_STATE, src, NULL);
1044 	if (status) {
1045 		dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
1046 		goto out;
1047 	}
1048 
1049 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1050 					    dst_stateid, WR_STATE, dst, NULL);
1051 	if (status) {
1052 		dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
1053 		goto out_put_src;
1054 	}
1055 
1056 	/* fix up for NFS-specific error code */
1057 	if (!S_ISREG(file_inode(*src)->i_mode) ||
1058 	    !S_ISREG(file_inode(*dst)->i_mode)) {
1059 		status = nfserr_wrong_type;
1060 		goto out_put_dst;
1061 	}
1062 
1063 out:
1064 	return status;
1065 out_put_dst:
1066 	fput(*dst);
1067 out_put_src:
1068 	fput(*src);
1069 	goto out;
1070 }
1071 
1072 static __be32
1073 nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1074 		union nfsd4_op_u *u)
1075 {
1076 	struct nfsd4_clone *clone = &u->clone;
1077 	struct file *src, *dst;
1078 	__be32 status;
1079 
1080 	status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
1081 				   &clone->cl_dst_stateid, &dst);
1082 	if (status)
1083 		goto out;
1084 
1085 	status = nfsd4_clone_file_range(src, clone->cl_src_pos,
1086 			dst, clone->cl_dst_pos, clone->cl_count);
1087 
1088 	fput(dst);
1089 	fput(src);
1090 out:
1091 	return status;
1092 }
1093 
1094 void nfs4_put_copy(struct nfsd4_copy *copy)
1095 {
1096 	if (!refcount_dec_and_test(&copy->refcount))
1097 		return;
1098 	kfree(copy);
1099 }
1100 
1101 static bool
1102 check_and_set_stop_copy(struct nfsd4_copy *copy)
1103 {
1104 	bool value;
1105 
1106 	spin_lock(&copy->cp_clp->async_lock);
1107 	value = copy->stopped;
1108 	if (!copy->stopped)
1109 		copy->stopped = true;
1110 	spin_unlock(&copy->cp_clp->async_lock);
1111 	return value;
1112 }
1113 
1114 static void nfsd4_stop_copy(struct nfsd4_copy *copy)
1115 {
1116 	/* only 1 thread should stop the copy */
1117 	if (!check_and_set_stop_copy(copy))
1118 		kthread_stop(copy->copy_task);
1119 	nfs4_put_copy(copy);
1120 }
1121 
1122 static struct nfsd4_copy *nfsd4_get_copy(struct nfs4_client *clp)
1123 {
1124 	struct nfsd4_copy *copy = NULL;
1125 
1126 	spin_lock(&clp->async_lock);
1127 	if (!list_empty(&clp->async_copies)) {
1128 		copy = list_first_entry(&clp->async_copies, struct nfsd4_copy,
1129 					copies);
1130 		refcount_inc(&copy->refcount);
1131 	}
1132 	spin_unlock(&clp->async_lock);
1133 	return copy;
1134 }
1135 
1136 void nfsd4_shutdown_copy(struct nfs4_client *clp)
1137 {
1138 	struct nfsd4_copy *copy;
1139 
1140 	while ((copy = nfsd4_get_copy(clp)) != NULL)
1141 		nfsd4_stop_copy(copy);
1142 }
1143 
1144 static void nfsd4_cb_offload_release(struct nfsd4_callback *cb)
1145 {
1146 	struct nfsd4_copy *copy = container_of(cb, struct nfsd4_copy, cp_cb);
1147 
1148 	nfs4_put_copy(copy);
1149 }
1150 
1151 static int nfsd4_cb_offload_done(struct nfsd4_callback *cb,
1152 				 struct rpc_task *task)
1153 {
1154 	return 1;
1155 }
1156 
1157 static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = {
1158 	.release = nfsd4_cb_offload_release,
1159 	.done = nfsd4_cb_offload_done
1160 };
1161 
1162 static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)
1163 {
1164 	copy->cp_res.wr_stable_how = NFS_UNSTABLE;
1165 	copy->cp_synchronous = sync;
1166 	gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);
1167 }
1168 
1169 static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
1170 {
1171 	ssize_t bytes_copied = 0;
1172 	size_t bytes_total = copy->cp_count;
1173 	u64 src_pos = copy->cp_src_pos;
1174 	u64 dst_pos = copy->cp_dst_pos;
1175 
1176 	do {
1177 		if (kthread_should_stop())
1178 			break;
1179 		bytes_copied = nfsd_copy_file_range(copy->file_src, src_pos,
1180 				copy->file_dst, dst_pos, bytes_total);
1181 		if (bytes_copied <= 0)
1182 			break;
1183 		bytes_total -= bytes_copied;
1184 		copy->cp_res.wr_bytes_written += bytes_copied;
1185 		src_pos += bytes_copied;
1186 		dst_pos += bytes_copied;
1187 	} while (bytes_total > 0 && !copy->cp_synchronous);
1188 	return bytes_copied;
1189 }
1190 
1191 static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync)
1192 {
1193 	__be32 status;
1194 	ssize_t bytes;
1195 
1196 	bytes = _nfsd_copy_file_range(copy);
1197 	/* for async copy, we ignore the error, client can always retry
1198 	 * to get the error
1199 	 */
1200 	if (bytes < 0 && !copy->cp_res.wr_bytes_written)
1201 		status = nfserrno(bytes);
1202 	else {
1203 		nfsd4_init_copy_res(copy, sync);
1204 		status = nfs_ok;
1205 	}
1206 
1207 	fput(copy->file_src);
1208 	fput(copy->file_dst);
1209 	return status;
1210 }
1211 
1212 static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst)
1213 {
1214 	dst->cp_src_pos = src->cp_src_pos;
1215 	dst->cp_dst_pos = src->cp_dst_pos;
1216 	dst->cp_count = src->cp_count;
1217 	dst->cp_synchronous = src->cp_synchronous;
1218 	memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));
1219 	memcpy(&dst->fh, &src->fh, sizeof(src->fh));
1220 	dst->cp_clp = src->cp_clp;
1221 	dst->file_dst = get_file(src->file_dst);
1222 	dst->file_src = get_file(src->file_src);
1223 	memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
1224 }
1225 
1226 static void cleanup_async_copy(struct nfsd4_copy *copy)
1227 {
1228 	nfs4_free_cp_state(copy);
1229 	fput(copy->file_dst);
1230 	fput(copy->file_src);
1231 	spin_lock(&copy->cp_clp->async_lock);
1232 	list_del(&copy->copies);
1233 	spin_unlock(&copy->cp_clp->async_lock);
1234 	nfs4_put_copy(copy);
1235 }
1236 
1237 static int nfsd4_do_async_copy(void *data)
1238 {
1239 	struct nfsd4_copy *copy = (struct nfsd4_copy *)data;
1240 	struct nfsd4_copy *cb_copy;
1241 
1242 	copy->nfserr = nfsd4_do_copy(copy, 0);
1243 	cb_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1244 	if (!cb_copy)
1245 		goto out;
1246 	memcpy(&cb_copy->cp_res, &copy->cp_res, sizeof(copy->cp_res));
1247 	cb_copy->cp_clp = copy->cp_clp;
1248 	cb_copy->nfserr = copy->nfserr;
1249 	memcpy(&cb_copy->fh, &copy->fh, sizeof(copy->fh));
1250 	nfsd4_init_cb(&cb_copy->cp_cb, cb_copy->cp_clp,
1251 			&nfsd4_cb_offload_ops, NFSPROC4_CLNT_CB_OFFLOAD);
1252 	nfsd4_run_cb(&cb_copy->cp_cb);
1253 out:
1254 	cleanup_async_copy(copy);
1255 	return 0;
1256 }
1257 
1258 static __be32
1259 nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1260 		union nfsd4_op_u *u)
1261 {
1262 	struct nfsd4_copy *copy = &u->copy;
1263 	__be32 status;
1264 	struct nfsd4_copy *async_copy = NULL;
1265 
1266 	status = nfsd4_verify_copy(rqstp, cstate, &copy->cp_src_stateid,
1267 				   &copy->file_src, &copy->cp_dst_stateid,
1268 				   &copy->file_dst);
1269 	if (status)
1270 		goto out;
1271 
1272 	copy->cp_clp = cstate->clp;
1273 	memcpy(&copy->fh, &cstate->current_fh.fh_handle,
1274 		sizeof(struct knfsd_fh));
1275 	if (!copy->cp_synchronous) {
1276 		struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1277 
1278 		status = nfserrno(-ENOMEM);
1279 		async_copy = kzalloc(sizeof(struct nfsd4_copy), GFP_KERNEL);
1280 		if (!async_copy)
1281 			goto out;
1282 		if (!nfs4_init_cp_state(nn, copy)) {
1283 			kfree(async_copy);
1284 			goto out;
1285 		}
1286 		refcount_set(&async_copy->refcount, 1);
1287 		memcpy(&copy->cp_res.cb_stateid, &copy->cp_stateid,
1288 			sizeof(copy->cp_stateid));
1289 		dup_copy_fields(copy, async_copy);
1290 		async_copy->copy_task = kthread_create(nfsd4_do_async_copy,
1291 				async_copy, "%s", "copy thread");
1292 		if (IS_ERR(async_copy->copy_task))
1293 			goto out_err;
1294 		spin_lock(&async_copy->cp_clp->async_lock);
1295 		list_add(&async_copy->copies,
1296 				&async_copy->cp_clp->async_copies);
1297 		spin_unlock(&async_copy->cp_clp->async_lock);
1298 		wake_up_process(async_copy->copy_task);
1299 		status = nfs_ok;
1300 	} else
1301 		status = nfsd4_do_copy(copy, 1);
1302 out:
1303 	return status;
1304 out_err:
1305 	cleanup_async_copy(async_copy);
1306 	goto out;
1307 }
1308 
1309 struct nfsd4_copy *
1310 find_async_copy(struct nfs4_client *clp, stateid_t *stateid)
1311 {
1312 	struct nfsd4_copy *copy;
1313 
1314 	spin_lock(&clp->async_lock);
1315 	list_for_each_entry(copy, &clp->async_copies, copies) {
1316 		if (memcmp(&copy->cp_stateid, stateid, NFS4_STATEID_SIZE))
1317 			continue;
1318 		refcount_inc(&copy->refcount);
1319 		spin_unlock(&clp->async_lock);
1320 		return copy;
1321 	}
1322 	spin_unlock(&clp->async_lock);
1323 	return NULL;
1324 }
1325 
1326 static __be32
1327 nfsd4_offload_cancel(struct svc_rqst *rqstp,
1328 		     struct nfsd4_compound_state *cstate,
1329 		     union nfsd4_op_u *u)
1330 {
1331 	struct nfsd4_offload_status *os = &u->offload_status;
1332 	__be32 status = 0;
1333 	struct nfsd4_copy *copy;
1334 	struct nfs4_client *clp = cstate->clp;
1335 
1336 	copy = find_async_copy(clp, &os->stateid);
1337 	if (copy)
1338 		nfsd4_stop_copy(copy);
1339 	else
1340 		status = nfserr_bad_stateid;
1341 
1342 	return status;
1343 }
1344 
1345 static __be32
1346 nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1347 		struct nfsd4_fallocate *fallocate, int flags)
1348 {
1349 	__be32 status;
1350 	struct file *file;
1351 
1352 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1353 					    &fallocate->falloc_stateid,
1354 					    WR_STATE, &file, NULL);
1355 	if (status != nfs_ok) {
1356 		dprintk("NFSD: nfsd4_fallocate: couldn't process stateid!\n");
1357 		return status;
1358 	}
1359 
1360 	status = nfsd4_vfs_fallocate(rqstp, &cstate->current_fh, file,
1361 				     fallocate->falloc_offset,
1362 				     fallocate->falloc_length,
1363 				     flags);
1364 	fput(file);
1365 	return status;
1366 }
1367 static __be32
1368 nfsd4_offload_status(struct svc_rqst *rqstp,
1369 		     struct nfsd4_compound_state *cstate,
1370 		     union nfsd4_op_u *u)
1371 {
1372 	struct nfsd4_offload_status *os = &u->offload_status;
1373 	__be32 status = 0;
1374 	struct nfsd4_copy *copy;
1375 	struct nfs4_client *clp = cstate->clp;
1376 
1377 	copy = find_async_copy(clp, &os->stateid);
1378 	if (copy) {
1379 		os->count = copy->cp_res.wr_bytes_written;
1380 		nfs4_put_copy(copy);
1381 	} else
1382 		status = nfserr_bad_stateid;
1383 
1384 	return status;
1385 }
1386 
1387 static __be32
1388 nfsd4_allocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1389 	       union nfsd4_op_u *u)
1390 {
1391 	return nfsd4_fallocate(rqstp, cstate, &u->allocate, 0);
1392 }
1393 
1394 static __be32
1395 nfsd4_deallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1396 		 union nfsd4_op_u *u)
1397 {
1398 	return nfsd4_fallocate(rqstp, cstate, &u->deallocate,
1399 			       FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE);
1400 }
1401 
1402 static __be32
1403 nfsd4_seek(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1404 	   union nfsd4_op_u *u)
1405 {
1406 	struct nfsd4_seek *seek = &u->seek;
1407 	int whence;
1408 	__be32 status;
1409 	struct file *file;
1410 
1411 	status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
1412 					    &seek->seek_stateid,
1413 					    RD_STATE, &file, NULL);
1414 	if (status) {
1415 		dprintk("NFSD: nfsd4_seek: couldn't process stateid!\n");
1416 		return status;
1417 	}
1418 
1419 	switch (seek->seek_whence) {
1420 	case NFS4_CONTENT_DATA:
1421 		whence = SEEK_DATA;
1422 		break;
1423 	case NFS4_CONTENT_HOLE:
1424 		whence = SEEK_HOLE;
1425 		break;
1426 	default:
1427 		status = nfserr_union_notsupp;
1428 		goto out;
1429 	}
1430 
1431 	/*
1432 	 * Note:  This call does change file->f_pos, but nothing in NFSD
1433 	 *        should ever file->f_pos.
1434 	 */
1435 	seek->seek_pos = vfs_llseek(file, seek->seek_offset, whence);
1436 	if (seek->seek_pos < 0)
1437 		status = nfserrno(seek->seek_pos);
1438 	else if (seek->seek_pos >= i_size_read(file_inode(file)))
1439 		seek->seek_eof = true;
1440 
1441 out:
1442 	fput(file);
1443 	return status;
1444 }
1445 
1446 /* This routine never returns NFS_OK!  If there are no other errors, it
1447  * will return NFSERR_SAME or NFSERR_NOT_SAME depending on whether the
1448  * attributes matched.  VERIFY is implemented by mapping NFSERR_SAME
1449  * to NFS_OK after the call; NVERIFY by mapping NFSERR_NOT_SAME to NFS_OK.
1450  */
1451 static __be32
1452 _nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1453 	     struct nfsd4_verify *verify)
1454 {
1455 	__be32 *buf, *p;
1456 	int count;
1457 	__be32 status;
1458 
1459 	status = fh_verify(rqstp, &cstate->current_fh, 0, NFSD_MAY_NOP);
1460 	if (status)
1461 		return status;
1462 
1463 	status = check_attr_support(rqstp, cstate, verify->ve_bmval, NULL);
1464 	if (status)
1465 		return status;
1466 
1467 	if ((verify->ve_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)
1468 	    || (verify->ve_bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1))
1469 		return nfserr_inval;
1470 	if (verify->ve_attrlen & 3)
1471 		return nfserr_inval;
1472 
1473 	/* count in words:
1474 	 *   bitmap_len(1) + bitmap(2) + attr_len(1) = 4
1475 	 */
1476 	count = 4 + (verify->ve_attrlen >> 2);
1477 	buf = kmalloc(count << 2, GFP_KERNEL);
1478 	if (!buf)
1479 		return nfserr_jukebox;
1480 
1481 	p = buf;
1482 	status = nfsd4_encode_fattr_to_buf(&p, count, &cstate->current_fh,
1483 				    cstate->current_fh.fh_export,
1484 				    cstate->current_fh.fh_dentry,
1485 				    verify->ve_bmval,
1486 				    rqstp, 0);
1487 	/*
1488 	 * If nfsd4_encode_fattr() ran out of space, assume that's because
1489 	 * the attributes are longer (hence different) than those given:
1490 	 */
1491 	if (status == nfserr_resource)
1492 		status = nfserr_not_same;
1493 	if (status)
1494 		goto out_kfree;
1495 
1496 	/* skip bitmap */
1497 	p = buf + 1 + ntohl(buf[0]);
1498 	status = nfserr_not_same;
1499 	if (ntohl(*p++) != verify->ve_attrlen)
1500 		goto out_kfree;
1501 	if (!memcmp(p, verify->ve_attrval, verify->ve_attrlen))
1502 		status = nfserr_same;
1503 
1504 out_kfree:
1505 	kfree(buf);
1506 	return status;
1507 }
1508 
1509 static __be32
1510 nfsd4_nverify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1511 	      union nfsd4_op_u *u)
1512 {
1513 	__be32 status;
1514 
1515 	status = _nfsd4_verify(rqstp, cstate, &u->verify);
1516 	return status == nfserr_not_same ? nfs_ok : status;
1517 }
1518 
1519 static __be32
1520 nfsd4_verify(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1521 	     union nfsd4_op_u *u)
1522 {
1523 	__be32 status;
1524 
1525 	status = _nfsd4_verify(rqstp, cstate, &u->nverify);
1526 	return status == nfserr_same ? nfs_ok : status;
1527 }
1528 
1529 #ifdef CONFIG_NFSD_PNFS
1530 static const struct nfsd4_layout_ops *
1531 nfsd4_layout_verify(struct svc_export *exp, unsigned int layout_type)
1532 {
1533 	if (!exp->ex_layout_types) {
1534 		dprintk("%s: export does not support pNFS\n", __func__);
1535 		return NULL;
1536 	}
1537 
1538 	if (layout_type >= LAYOUT_TYPE_MAX ||
1539 	    !(exp->ex_layout_types & (1 << layout_type))) {
1540 		dprintk("%s: layout type %d not supported\n",
1541 			__func__, layout_type);
1542 		return NULL;
1543 	}
1544 
1545 	return nfsd4_layout_ops[layout_type];
1546 }
1547 
1548 static __be32
1549 nfsd4_getdeviceinfo(struct svc_rqst *rqstp,
1550 		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1551 {
1552 	struct nfsd4_getdeviceinfo *gdp = &u->getdeviceinfo;
1553 	const struct nfsd4_layout_ops *ops;
1554 	struct nfsd4_deviceid_map *map;
1555 	struct svc_export *exp;
1556 	__be32 nfserr;
1557 
1558 	dprintk("%s: layout_type %u dev_id [0x%llx:0x%x] maxcnt %u\n",
1559 	       __func__,
1560 	       gdp->gd_layout_type,
1561 	       gdp->gd_devid.fsid_idx, gdp->gd_devid.generation,
1562 	       gdp->gd_maxcount);
1563 
1564 	map = nfsd4_find_devid_map(gdp->gd_devid.fsid_idx);
1565 	if (!map) {
1566 		dprintk("%s: couldn't find device ID to export mapping!\n",
1567 			__func__);
1568 		return nfserr_noent;
1569 	}
1570 
1571 	exp = rqst_exp_find(rqstp, map->fsid_type, map->fsid);
1572 	if (IS_ERR(exp)) {
1573 		dprintk("%s: could not find device id\n", __func__);
1574 		return nfserr_noent;
1575 	}
1576 
1577 	nfserr = nfserr_layoutunavailable;
1578 	ops = nfsd4_layout_verify(exp, gdp->gd_layout_type);
1579 	if (!ops)
1580 		goto out;
1581 
1582 	nfserr = nfs_ok;
1583 	if (gdp->gd_maxcount != 0) {
1584 		nfserr = ops->proc_getdeviceinfo(exp->ex_path.mnt->mnt_sb,
1585 				rqstp, cstate->session->se_client, gdp);
1586 	}
1587 
1588 	gdp->gd_notify_types &= ops->notify_types;
1589 out:
1590 	exp_put(exp);
1591 	return nfserr;
1592 }
1593 
1594 static void
1595 nfsd4_getdeviceinfo_release(union nfsd4_op_u *u)
1596 {
1597 	kfree(u->getdeviceinfo.gd_device);
1598 }
1599 
1600 static __be32
1601 nfsd4_layoutget(struct svc_rqst *rqstp,
1602 		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1603 {
1604 	struct nfsd4_layoutget *lgp = &u->layoutget;
1605 	struct svc_fh *current_fh = &cstate->current_fh;
1606 	const struct nfsd4_layout_ops *ops;
1607 	struct nfs4_layout_stateid *ls;
1608 	__be32 nfserr;
1609 	int accmode = NFSD_MAY_READ_IF_EXEC;
1610 
1611 	switch (lgp->lg_seg.iomode) {
1612 	case IOMODE_READ:
1613 		accmode |= NFSD_MAY_READ;
1614 		break;
1615 	case IOMODE_RW:
1616 		accmode |= NFSD_MAY_READ | NFSD_MAY_WRITE;
1617 		break;
1618 	default:
1619 		dprintk("%s: invalid iomode %d\n",
1620 			__func__, lgp->lg_seg.iomode);
1621 		nfserr = nfserr_badiomode;
1622 		goto out;
1623 	}
1624 
1625 	nfserr = fh_verify(rqstp, current_fh, 0, accmode);
1626 	if (nfserr)
1627 		goto out;
1628 
1629 	nfserr = nfserr_layoutunavailable;
1630 	ops = nfsd4_layout_verify(current_fh->fh_export, lgp->lg_layout_type);
1631 	if (!ops)
1632 		goto out;
1633 
1634 	/*
1635 	 * Verify minlength and range as per RFC5661:
1636 	 *  o  If loga_length is less than loga_minlength,
1637 	 *     the metadata server MUST return NFS4ERR_INVAL.
1638 	 *  o  If the sum of loga_offset and loga_minlength exceeds
1639 	 *     NFS4_UINT64_MAX, and loga_minlength is not
1640 	 *     NFS4_UINT64_MAX, the error NFS4ERR_INVAL MUST result.
1641 	 *  o  If the sum of loga_offset and loga_length exceeds
1642 	 *     NFS4_UINT64_MAX, and loga_length is not NFS4_UINT64_MAX,
1643 	 *     the error NFS4ERR_INVAL MUST result.
1644 	 */
1645 	nfserr = nfserr_inval;
1646 	if (lgp->lg_seg.length < lgp->lg_minlength ||
1647 	    (lgp->lg_minlength != NFS4_MAX_UINT64 &&
1648 	     lgp->lg_minlength > NFS4_MAX_UINT64 - lgp->lg_seg.offset) ||
1649 	    (lgp->lg_seg.length != NFS4_MAX_UINT64 &&
1650 	     lgp->lg_seg.length > NFS4_MAX_UINT64 - lgp->lg_seg.offset))
1651 		goto out;
1652 	if (lgp->lg_seg.length == 0)
1653 		goto out;
1654 
1655 	nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lgp->lg_sid,
1656 						true, lgp->lg_layout_type, &ls);
1657 	if (nfserr) {
1658 		trace_nfsd_layout_get_lookup_fail(&lgp->lg_sid);
1659 		goto out;
1660 	}
1661 
1662 	nfserr = nfserr_recallconflict;
1663 	if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls))
1664 		goto out_put_stid;
1665 
1666 	nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry),
1667 				     current_fh, lgp);
1668 	if (nfserr)
1669 		goto out_put_stid;
1670 
1671 	nfserr = nfsd4_insert_layout(lgp, ls);
1672 
1673 out_put_stid:
1674 	mutex_unlock(&ls->ls_mutex);
1675 	nfs4_put_stid(&ls->ls_stid);
1676 out:
1677 	return nfserr;
1678 }
1679 
1680 static void
1681 nfsd4_layoutget_release(union nfsd4_op_u *u)
1682 {
1683 	kfree(u->layoutget.lg_content);
1684 }
1685 
1686 static __be32
1687 nfsd4_layoutcommit(struct svc_rqst *rqstp,
1688 		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1689 {
1690 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;
1691 	const struct nfsd4_layout_seg *seg = &lcp->lc_seg;
1692 	struct svc_fh *current_fh = &cstate->current_fh;
1693 	const struct nfsd4_layout_ops *ops;
1694 	loff_t new_size = lcp->lc_last_wr + 1;
1695 	struct inode *inode;
1696 	struct nfs4_layout_stateid *ls;
1697 	__be32 nfserr;
1698 
1699 	nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_WRITE);
1700 	if (nfserr)
1701 		goto out;
1702 
1703 	nfserr = nfserr_layoutunavailable;
1704 	ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type);
1705 	if (!ops)
1706 		goto out;
1707 	inode = d_inode(current_fh->fh_dentry);
1708 
1709 	nfserr = nfserr_inval;
1710 	if (new_size <= seg->offset) {
1711 		dprintk("pnfsd: last write before layout segment\n");
1712 		goto out;
1713 	}
1714 	if (new_size > seg->offset + seg->length) {
1715 		dprintk("pnfsd: last write beyond layout segment\n");
1716 		goto out;
1717 	}
1718 	if (!lcp->lc_newoffset && new_size > i_size_read(inode)) {
1719 		dprintk("pnfsd: layoutcommit beyond EOF\n");
1720 		goto out;
1721 	}
1722 
1723 	nfserr = nfsd4_preprocess_layout_stateid(rqstp, cstate, &lcp->lc_sid,
1724 						false, lcp->lc_layout_type,
1725 						&ls);
1726 	if (nfserr) {
1727 		trace_nfsd_layout_commit_lookup_fail(&lcp->lc_sid);
1728 		/* fixup error code as per RFC5661 */
1729 		if (nfserr == nfserr_bad_stateid)
1730 			nfserr = nfserr_badlayout;
1731 		goto out;
1732 	}
1733 
1734 	/* LAYOUTCOMMIT does not require any serialization */
1735 	mutex_unlock(&ls->ls_mutex);
1736 
1737 	if (new_size > i_size_read(inode)) {
1738 		lcp->lc_size_chg = 1;
1739 		lcp->lc_newsize = new_size;
1740 	} else {
1741 		lcp->lc_size_chg = 0;
1742 	}
1743 
1744 	nfserr = ops->proc_layoutcommit(inode, lcp);
1745 	nfs4_put_stid(&ls->ls_stid);
1746 out:
1747 	return nfserr;
1748 }
1749 
1750 static __be32
1751 nfsd4_layoutreturn(struct svc_rqst *rqstp,
1752 		struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
1753 {
1754 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;
1755 	struct svc_fh *current_fh = &cstate->current_fh;
1756 	__be32 nfserr;
1757 
1758 	nfserr = fh_verify(rqstp, current_fh, 0, NFSD_MAY_NOP);
1759 	if (nfserr)
1760 		goto out;
1761 
1762 	nfserr = nfserr_layoutunavailable;
1763 	if (!nfsd4_layout_verify(current_fh->fh_export, lrp->lr_layout_type))
1764 		goto out;
1765 
1766 	switch (lrp->lr_seg.iomode) {
1767 	case IOMODE_READ:
1768 	case IOMODE_RW:
1769 	case IOMODE_ANY:
1770 		break;
1771 	default:
1772 		dprintk("%s: invalid iomode %d\n", __func__,
1773 			lrp->lr_seg.iomode);
1774 		nfserr = nfserr_inval;
1775 		goto out;
1776 	}
1777 
1778 	switch (lrp->lr_return_type) {
1779 	case RETURN_FILE:
1780 		nfserr = nfsd4_return_file_layouts(rqstp, cstate, lrp);
1781 		break;
1782 	case RETURN_FSID:
1783 	case RETURN_ALL:
1784 		nfserr = nfsd4_return_client_layouts(rqstp, cstate, lrp);
1785 		break;
1786 	default:
1787 		dprintk("%s: invalid return_type %d\n", __func__,
1788 			lrp->lr_return_type);
1789 		nfserr = nfserr_inval;
1790 		break;
1791 	}
1792 out:
1793 	return nfserr;
1794 }
1795 #endif /* CONFIG_NFSD_PNFS */
1796 
1797 /*
1798  * NULL call.
1799  */
1800 static __be32
1801 nfsd4_proc_null(struct svc_rqst *rqstp)
1802 {
1803 	return nfs_ok;
1804 }
1805 
1806 static inline void nfsd4_increment_op_stats(u32 opnum)
1807 {
1808 	if (opnum >= FIRST_NFS4_OP && opnum <= LAST_NFS4_OP)
1809 		nfsdstats.nfs4_opcount[opnum]++;
1810 }
1811 
1812 static const struct nfsd4_operation nfsd4_ops[];
1813 
1814 static const char *nfsd4_op_name(unsigned opnum);
1815 
1816 /*
1817  * Enforce NFSv4.1 COMPOUND ordering rules:
1818  *
1819  * Also note, enforced elsewhere:
1820  *	- SEQUENCE other than as first op results in
1821  *	  NFS4ERR_SEQUENCE_POS. (Enforced in nfsd4_sequence().)
1822  *	- BIND_CONN_TO_SESSION must be the only op in its compound.
1823  *	  (Enforced in nfsd4_bind_conn_to_session().)
1824  *	- DESTROY_SESSION must be the final operation in a compound, if
1825  *	  sessionid's in SEQUENCE and DESTROY_SESSION are the same.
1826  *	  (Enforced in nfsd4_destroy_session().)
1827  */
1828 static __be32 nfs41_check_op_ordering(struct nfsd4_compoundargs *args)
1829 {
1830 	struct nfsd4_op *first_op = &args->ops[0];
1831 
1832 	/* These ordering requirements don't apply to NFSv4.0: */
1833 	if (args->minorversion == 0)
1834 		return nfs_ok;
1835 	/* This is weird, but OK, not our problem: */
1836 	if (args->opcnt == 0)
1837 		return nfs_ok;
1838 	if (first_op->status == nfserr_op_illegal)
1839 		return nfs_ok;
1840 	if (!(nfsd4_ops[first_op->opnum].op_flags & ALLOWED_AS_FIRST_OP))
1841 		return nfserr_op_not_in_session;
1842 	if (first_op->opnum == OP_SEQUENCE)
1843 		return nfs_ok;
1844 	/*
1845 	 * So first_op is something allowed outside a session, like
1846 	 * EXCHANGE_ID; but then it has to be the only op in the
1847 	 * compound:
1848 	 */
1849 	if (args->opcnt != 1)
1850 		return nfserr_not_only_op;
1851 	return nfs_ok;
1852 }
1853 
1854 const struct nfsd4_operation *OPDESC(struct nfsd4_op *op)
1855 {
1856 	return &nfsd4_ops[op->opnum];
1857 }
1858 
1859 bool nfsd4_cache_this_op(struct nfsd4_op *op)
1860 {
1861 	if (op->opnum == OP_ILLEGAL)
1862 		return false;
1863 	return OPDESC(op)->op_flags & OP_CACHEME;
1864 }
1865 
1866 static bool need_wrongsec_check(struct svc_rqst *rqstp)
1867 {
1868 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
1869 	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1870 	struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
1871 	struct nfsd4_op *next = &argp->ops[resp->opcnt];
1872 	const struct nfsd4_operation *thisd = OPDESC(this);
1873 	const struct nfsd4_operation *nextd;
1874 
1875 	/*
1876 	 * Most ops check wronsec on our own; only the putfh-like ops
1877 	 * have special rules.
1878 	 */
1879 	if (!(thisd->op_flags & OP_IS_PUTFH_LIKE))
1880 		return false;
1881 	/*
1882 	 * rfc 5661 2.6.3.1.1.6: don't bother erroring out a
1883 	 * put-filehandle operation if we're not going to use the
1884 	 * result:
1885 	 */
1886 	if (argp->opcnt == resp->opcnt)
1887 		return false;
1888 	if (next->opnum == OP_ILLEGAL)
1889 		return false;
1890 	nextd = OPDESC(next);
1891 	/*
1892 	 * Rest of 2.6.3.1.1: certain operations will return WRONGSEC
1893 	 * errors themselves as necessary; others should check for them
1894 	 * now:
1895 	 */
1896 	return !(nextd->op_flags & OP_HANDLES_WRONGSEC);
1897 }
1898 
1899 static void svcxdr_init_encode(struct svc_rqst *rqstp,
1900 			       struct nfsd4_compoundres *resp)
1901 {
1902 	struct xdr_stream *xdr = &resp->xdr;
1903 	struct xdr_buf *buf = &rqstp->rq_res;
1904 	struct kvec *head = buf->head;
1905 
1906 	xdr->buf = buf;
1907 	xdr->iov = head;
1908 	xdr->p   = head->iov_base + head->iov_len;
1909 	xdr->end = head->iov_base + PAGE_SIZE - rqstp->rq_auth_slack;
1910 	/* Tail and page_len should be zero at this point: */
1911 	buf->len = buf->head[0].iov_len;
1912 	xdr->scratch.iov_len = 0;
1913 	xdr->page_ptr = buf->pages - 1;
1914 	buf->buflen = PAGE_SIZE * (1 + rqstp->rq_page_end - buf->pages)
1915 		- rqstp->rq_auth_slack;
1916 }
1917 
1918 /*
1919  * COMPOUND call.
1920  */
1921 static __be32
1922 nfsd4_proc_compound(struct svc_rqst *rqstp)
1923 {
1924 	struct nfsd4_compoundargs *args = rqstp->rq_argp;
1925 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
1926 	struct nfsd4_op	*op;
1927 	struct nfsd4_compound_state *cstate = &resp->cstate;
1928 	struct svc_fh *current_fh = &cstate->current_fh;
1929 	struct svc_fh *save_fh = &cstate->save_fh;
1930 	__be32		status;
1931 
1932 	svcxdr_init_encode(rqstp, resp);
1933 	resp->tagp = resp->xdr.p;
1934 	/* reserve space for: taglen, tag, and opcnt */
1935 	xdr_reserve_space(&resp->xdr, 8 + args->taglen);
1936 	resp->taglen = args->taglen;
1937 	resp->tag = args->tag;
1938 	resp->rqstp = rqstp;
1939 	cstate->minorversion = args->minorversion;
1940 	fh_init(current_fh, NFS4_FHSIZE);
1941 	fh_init(save_fh, NFS4_FHSIZE);
1942 	/*
1943 	 * Don't use the deferral mechanism for NFSv4; compounds make it
1944 	 * too hard to avoid non-idempotency problems.
1945 	 */
1946 	clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1947 
1948 	/*
1949 	 * According to RFC3010, this takes precedence over all other errors.
1950 	 */
1951 	status = nfserr_minor_vers_mismatch;
1952 	if (nfsd_minorversion(args->minorversion, NFSD_TEST) <= 0)
1953 		goto out;
1954 	status = nfserr_resource;
1955 	if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1956 		goto out;
1957 
1958 	status = nfs41_check_op_ordering(args);
1959 	if (status) {
1960 		op = &args->ops[0];
1961 		op->status = status;
1962 		resp->opcnt = 1;
1963 		goto encode_op;
1964 	}
1965 
1966 	trace_nfsd_compound(rqstp, args->opcnt);
1967 	while (!status && resp->opcnt < args->opcnt) {
1968 		op = &args->ops[resp->opcnt++];
1969 
1970 		/*
1971 		 * The XDR decode routines may have pre-set op->status;
1972 		 * for example, if there is a miscellaneous XDR error
1973 		 * it will be set to nfserr_bad_xdr.
1974 		 */
1975 		if (op->status) {
1976 			if (op->opnum == OP_OPEN)
1977 				op->status = nfsd4_open_omfg(rqstp, cstate, op);
1978 			goto encode_op;
1979 		}
1980 
1981 		if (!current_fh->fh_dentry) {
1982 			if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1983 				op->status = nfserr_nofilehandle;
1984 				goto encode_op;
1985 			}
1986 		} else if (current_fh->fh_export->ex_fslocs.migrated &&
1987 			  !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1988 			op->status = nfserr_moved;
1989 			goto encode_op;
1990 		}
1991 
1992 		fh_clear_wcc(current_fh);
1993 
1994 		/* If op is non-idempotent */
1995 		if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
1996 			/*
1997 			 * Don't execute this op if we couldn't encode a
1998 			 * succesful reply:
1999 			 */
2000 			u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
2001 			/*
2002 			 * Plus if there's another operation, make sure
2003 			 * we'll have space to at least encode an error:
2004 			 */
2005 			if (resp->opcnt < args->opcnt)
2006 				plen += COMPOUND_ERR_SLACK_SPACE;
2007 			op->status = nfsd4_check_resp_size(resp, plen);
2008 		}
2009 
2010 		if (op->status)
2011 			goto encode_op;
2012 
2013 		if (op->opdesc->op_get_currentstateid)
2014 			op->opdesc->op_get_currentstateid(cstate, &op->u);
2015 		op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
2016 
2017 		/* Only from SEQUENCE */
2018 		if (cstate->status == nfserr_replay_cache) {
2019 			dprintk("%s NFS4.1 replay from cache\n", __func__);
2020 			status = op->status;
2021 			goto out;
2022 		}
2023 		if (!op->status) {
2024 			if (op->opdesc->op_set_currentstateid)
2025 				op->opdesc->op_set_currentstateid(cstate, &op->u);
2026 
2027 			if (op->opdesc->op_flags & OP_CLEAR_STATEID)
2028 				clear_current_stateid(cstate);
2029 
2030 			if (need_wrongsec_check(rqstp))
2031 				op->status = check_nfsd_access(current_fh->fh_export, rqstp);
2032 		}
2033 encode_op:
2034 		if (op->status == nfserr_replay_me) {
2035 			op->replay = &cstate->replay_owner->so_replay;
2036 			nfsd4_encode_replay(&resp->xdr, op);
2037 			status = op->status = op->replay->rp_status;
2038 		} else {
2039 			nfsd4_encode_operation(resp, op);
2040 			status = op->status;
2041 		}
2042 
2043 		trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
2044 					   nfsd4_op_name(op->opnum));
2045 
2046 		nfsd4_cstate_clear_replay(cstate);
2047 		nfsd4_increment_op_stats(op->opnum);
2048 	}
2049 
2050 	cstate->status = status;
2051 	fh_put(current_fh);
2052 	fh_put(save_fh);
2053 	BUG_ON(cstate->replay_owner);
2054 out:
2055 	/* Reset deferral mechanism for RPC deferrals */
2056 	set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
2057 	dprintk("nfsv4 compound returned %d\n", ntohl(status));
2058 	return status;
2059 }
2060 
2061 #define op_encode_hdr_size		(2)
2062 #define op_encode_stateid_maxsz		(XDR_QUADLEN(NFS4_STATEID_SIZE))
2063 #define op_encode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2064 #define op_encode_change_info_maxsz	(5)
2065 #define nfs4_fattr_bitmap_maxsz		(4)
2066 
2067 /* We'll fall back on returning no lockowner if run out of space: */
2068 #define op_encode_lockowner_maxsz	(0)
2069 #define op_encode_lock_denied_maxsz	(8 + op_encode_lockowner_maxsz)
2070 
2071 #define nfs4_owner_maxsz		(1 + XDR_QUADLEN(IDMAP_NAMESZ))
2072 
2073 #define op_encode_ace_maxsz		(3 + nfs4_owner_maxsz)
2074 #define op_encode_delegation_maxsz	(1 + op_encode_stateid_maxsz + 1 + \
2075 					 op_encode_ace_maxsz)
2076 
2077 #define op_encode_channel_attrs_maxsz	(6 + 1 + 1)
2078 
2079 static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2080 {
2081 	return (op_encode_hdr_size) * sizeof(__be32);
2082 }
2083 
2084 static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2085 {
2086 	return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
2087 }
2088 
2089 static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2090 {
2091 	/* ac_supported, ac_resp_access */
2092 	return (op_encode_hdr_size + 2)* sizeof(__be32);
2093 }
2094 
2095 static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2096 {
2097 	return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
2098 }
2099 
2100 static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2101 {
2102 	return (op_encode_hdr_size + op_encode_change_info_maxsz
2103 		+ nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2104 }
2105 
2106 /*
2107  * Note since this is an idempotent operation we won't insist on failing
2108  * the op prematurely if the estimate is too large.  We may turn off splice
2109  * reads unnecessarily.
2110  */
2111 static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
2112 				      struct nfsd4_op *op)
2113 {
2114 	u32 *bmap = op->u.getattr.ga_bmval;
2115 	u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
2116 	u32 ret = 0;
2117 
2118 	if (bmap0 & FATTR4_WORD0_ACL)
2119 		return svc_max_payload(rqstp);
2120 	if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
2121 		return svc_max_payload(rqstp);
2122 
2123 	if (bmap1 & FATTR4_WORD1_OWNER) {
2124 		ret += IDMAP_NAMESZ + 4;
2125 		bmap1 &= ~FATTR4_WORD1_OWNER;
2126 	}
2127 	if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
2128 		ret += IDMAP_NAMESZ + 4;
2129 		bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
2130 	}
2131 	if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
2132 		ret += NFS4_FHSIZE + 4;
2133 		bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
2134 	}
2135 	if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
2136 		ret += NFS4_MAXLABELLEN + 12;
2137 		bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2138 	}
2139 	/*
2140 	 * Largest of remaining attributes are 16 bytes (e.g.,
2141 	 * supported_attributes)
2142 	 */
2143 	ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
2144 	/* bitmask, length */
2145 	ret += 20;
2146 	return ret;
2147 }
2148 
2149 static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2150 {
2151 	return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
2152 }
2153 
2154 static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2155 {
2156 	return (op_encode_hdr_size + op_encode_change_info_maxsz)
2157 		* sizeof(__be32);
2158 }
2159 
2160 static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2161 {
2162 	return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
2163 		* sizeof(__be32);
2164 }
2165 
2166 static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2167 {
2168 	return (op_encode_hdr_size + op_encode_stateid_maxsz
2169 		+ op_encode_change_info_maxsz + 1
2170 		+ nfs4_fattr_bitmap_maxsz
2171 		+ op_encode_delegation_maxsz) * sizeof(__be32);
2172 }
2173 
2174 static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2175 {
2176 	u32 maxcount = 0, rlen = 0;
2177 
2178 	maxcount = svc_max_payload(rqstp);
2179 	rlen = min(op->u.read.rd_length, maxcount);
2180 
2181 	return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
2182 }
2183 
2184 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2185 {
2186 	u32 maxcount = 0, rlen = 0;
2187 
2188 	maxcount = svc_max_payload(rqstp);
2189 	rlen = min(op->u.readdir.rd_maxcount, maxcount);
2190 
2191 	return (op_encode_hdr_size + op_encode_verifier_maxsz +
2192 		XDR_QUADLEN(rlen)) * sizeof(__be32);
2193 }
2194 
2195 static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2196 {
2197 	return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
2198 }
2199 
2200 static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2201 {
2202 	return (op_encode_hdr_size + op_encode_change_info_maxsz)
2203 		* sizeof(__be32);
2204 }
2205 
2206 static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2207 {
2208 	return (op_encode_hdr_size + op_encode_change_info_maxsz
2209 		+ op_encode_change_info_maxsz) * sizeof(__be32);
2210 }
2211 
2212 static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
2213 				       struct nfsd4_op *op)
2214 {
2215 	return (op_encode_hdr_size
2216 		+ XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
2217 }
2218 
2219 static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2220 {
2221 	return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
2222 		* sizeof(__be32);
2223 }
2224 
2225 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2226 {
2227 	return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2228 }
2229 
2230 static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2231 {
2232 	return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
2233 		(4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
2234 }
2235 
2236 static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2237 {
2238 	return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2239 								sizeof(__be32);
2240 }
2241 
2242 static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2243 {
2244 	return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
2245 }
2246 
2247 static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2248 {
2249 	return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
2250 		1 + 1 + /* eir_flags, spr_how */\
2251 		4 + /* spo_must_enforce & _allow with bitmap */\
2252 		2 + /*eir_server_owner.so_minor_id */\
2253 		/* eir_server_owner.so_major_id<> */\
2254 		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2255 		/* eir_server_scope<> */\
2256 		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2257 		1 + /* eir_server_impl_id array length */\
2258 		0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2259 }
2260 
2261 static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2262 {
2263 	return (op_encode_hdr_size + \
2264 		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2265 		2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2266 }
2267 
2268 static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2269 {
2270 	return (op_encode_hdr_size + \
2271 		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2272 		2 + /* csr_sequence, csr_flags */\
2273 		op_encode_channel_attrs_maxsz + \
2274 		op_encode_channel_attrs_maxsz) * sizeof(__be32);
2275 }
2276 
2277 static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2278 {
2279 	return (op_encode_hdr_size +
2280 		1 /* wr_callback */ +
2281 		op_encode_stateid_maxsz /* wr_callback */ +
2282 		2 /* wr_count */ +
2283 		1 /* wr_committed */ +
2284 		op_encode_verifier_maxsz +
2285 		1 /* cr_consecutive */ +
2286 		1 /* cr_synchronous */) * sizeof(__be32);
2287 }
2288 
2289 static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp,
2290 					     struct nfsd4_op *op)
2291 {
2292 	return (op_encode_hdr_size +
2293 		2 /* osr_count */ +
2294 		1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
2295 }
2296 
2297 #ifdef CONFIG_NFSD_PNFS
2298 static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2299 {
2300 	u32 maxcount = 0, rlen = 0;
2301 
2302 	maxcount = svc_max_payload(rqstp);
2303 	rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2304 
2305 	return (op_encode_hdr_size +
2306 		1 /* gd_layout_type*/ +
2307 		XDR_QUADLEN(rlen) +
2308 		2 /* gd_notify_types */) * sizeof(__be32);
2309 }
2310 
2311 /*
2312  * At this stage we don't really know what layout driver will handle the request,
2313  * so we need to define an arbitrary upper bound here.
2314  */
2315 #define MAX_LAYOUT_SIZE		128
2316 static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2317 {
2318 	return (op_encode_hdr_size +
2319 		1 /* logr_return_on_close */ +
2320 		op_encode_stateid_maxsz +
2321 		1 /* nr of layouts */ +
2322 		MAX_LAYOUT_SIZE) * sizeof(__be32);
2323 }
2324 
2325 static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2326 {
2327 	return (op_encode_hdr_size +
2328 		1 /* locr_newsize */ +
2329 		2 /* ns_size */) * sizeof(__be32);
2330 }
2331 
2332 static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2333 {
2334 	return (op_encode_hdr_size +
2335 		1 /* lrs_stateid */ +
2336 		op_encode_stateid_maxsz) * sizeof(__be32);
2337 }
2338 #endif /* CONFIG_NFSD_PNFS */
2339 
2340 
2341 static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2342 {
2343 	return (op_encode_hdr_size + 3) * sizeof(__be32);
2344 }
2345 
2346 static const struct nfsd4_operation nfsd4_ops[] = {
2347 	[OP_ACCESS] = {
2348 		.op_func = nfsd4_access,
2349 		.op_name = "OP_ACCESS",
2350 		.op_rsize_bop = nfsd4_access_rsize,
2351 	},
2352 	[OP_CLOSE] = {
2353 		.op_func = nfsd4_close,
2354 		.op_flags = OP_MODIFIES_SOMETHING,
2355 		.op_name = "OP_CLOSE",
2356 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2357 		.op_get_currentstateid = nfsd4_get_closestateid,
2358 		.op_set_currentstateid = nfsd4_set_closestateid,
2359 	},
2360 	[OP_COMMIT] = {
2361 		.op_func = nfsd4_commit,
2362 		.op_flags = OP_MODIFIES_SOMETHING,
2363 		.op_name = "OP_COMMIT",
2364 		.op_rsize_bop = nfsd4_commit_rsize,
2365 	},
2366 	[OP_CREATE] = {
2367 		.op_func = nfsd4_create,
2368 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
2369 		.op_name = "OP_CREATE",
2370 		.op_rsize_bop = nfsd4_create_rsize,
2371 	},
2372 	[OP_DELEGRETURN] = {
2373 		.op_func = nfsd4_delegreturn,
2374 		.op_flags = OP_MODIFIES_SOMETHING,
2375 		.op_name = "OP_DELEGRETURN",
2376 		.op_rsize_bop = nfsd4_only_status_rsize,
2377 		.op_get_currentstateid = nfsd4_get_delegreturnstateid,
2378 	},
2379 	[OP_GETATTR] = {
2380 		.op_func = nfsd4_getattr,
2381 		.op_flags = ALLOWED_ON_ABSENT_FS,
2382 		.op_rsize_bop = nfsd4_getattr_rsize,
2383 		.op_name = "OP_GETATTR",
2384 	},
2385 	[OP_GETFH] = {
2386 		.op_func = nfsd4_getfh,
2387 		.op_name = "OP_GETFH",
2388 		.op_rsize_bop = nfsd4_getfh_rsize,
2389 	},
2390 	[OP_LINK] = {
2391 		.op_func = nfsd4_link,
2392 		.op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2393 				| OP_CACHEME,
2394 		.op_name = "OP_LINK",
2395 		.op_rsize_bop = nfsd4_link_rsize,
2396 	},
2397 	[OP_LOCK] = {
2398 		.op_func = nfsd4_lock,
2399 		.op_flags = OP_MODIFIES_SOMETHING |
2400 				OP_NONTRIVIAL_ERROR_ENCODE,
2401 		.op_name = "OP_LOCK",
2402 		.op_rsize_bop = nfsd4_lock_rsize,
2403 		.op_set_currentstateid = nfsd4_set_lockstateid,
2404 	},
2405 	[OP_LOCKT] = {
2406 		.op_func = nfsd4_lockt,
2407 		.op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
2408 		.op_name = "OP_LOCKT",
2409 		.op_rsize_bop = nfsd4_lock_rsize,
2410 	},
2411 	[OP_LOCKU] = {
2412 		.op_func = nfsd4_locku,
2413 		.op_flags = OP_MODIFIES_SOMETHING,
2414 		.op_name = "OP_LOCKU",
2415 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2416 		.op_get_currentstateid = nfsd4_get_lockustateid,
2417 	},
2418 	[OP_LOOKUP] = {
2419 		.op_func = nfsd4_lookup,
2420 		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2421 		.op_name = "OP_LOOKUP",
2422 		.op_rsize_bop = nfsd4_only_status_rsize,
2423 	},
2424 	[OP_LOOKUPP] = {
2425 		.op_func = nfsd4_lookupp,
2426 		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2427 		.op_name = "OP_LOOKUPP",
2428 		.op_rsize_bop = nfsd4_only_status_rsize,
2429 	},
2430 	[OP_NVERIFY] = {
2431 		.op_func = nfsd4_nverify,
2432 		.op_name = "OP_NVERIFY",
2433 		.op_rsize_bop = nfsd4_only_status_rsize,
2434 	},
2435 	[OP_OPEN] = {
2436 		.op_func = nfsd4_open,
2437 		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2438 		.op_name = "OP_OPEN",
2439 		.op_rsize_bop = nfsd4_open_rsize,
2440 		.op_set_currentstateid = nfsd4_set_openstateid,
2441 	},
2442 	[OP_OPEN_CONFIRM] = {
2443 		.op_func = nfsd4_open_confirm,
2444 		.op_flags = OP_MODIFIES_SOMETHING,
2445 		.op_name = "OP_OPEN_CONFIRM",
2446 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2447 	},
2448 	[OP_OPEN_DOWNGRADE] = {
2449 		.op_func = nfsd4_open_downgrade,
2450 		.op_flags = OP_MODIFIES_SOMETHING,
2451 		.op_name = "OP_OPEN_DOWNGRADE",
2452 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2453 		.op_get_currentstateid = nfsd4_get_opendowngradestateid,
2454 		.op_set_currentstateid = nfsd4_set_opendowngradestateid,
2455 	},
2456 	[OP_PUTFH] = {
2457 		.op_func = nfsd4_putfh,
2458 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2459 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2460 		.op_name = "OP_PUTFH",
2461 		.op_rsize_bop = nfsd4_only_status_rsize,
2462 	},
2463 	[OP_PUTPUBFH] = {
2464 		.op_func = nfsd4_putrootfh,
2465 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2466 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2467 		.op_name = "OP_PUTPUBFH",
2468 		.op_rsize_bop = nfsd4_only_status_rsize,
2469 	},
2470 	[OP_PUTROOTFH] = {
2471 		.op_func = nfsd4_putrootfh,
2472 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2473 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2474 		.op_name = "OP_PUTROOTFH",
2475 		.op_rsize_bop = nfsd4_only_status_rsize,
2476 	},
2477 	[OP_READ] = {
2478 		.op_func = nfsd4_read,
2479 		.op_release = nfsd4_read_release,
2480 		.op_name = "OP_READ",
2481 		.op_rsize_bop = nfsd4_read_rsize,
2482 		.op_get_currentstateid = nfsd4_get_readstateid,
2483 	},
2484 	[OP_READDIR] = {
2485 		.op_func = nfsd4_readdir,
2486 		.op_name = "OP_READDIR",
2487 		.op_rsize_bop = nfsd4_readdir_rsize,
2488 	},
2489 	[OP_READLINK] = {
2490 		.op_func = nfsd4_readlink,
2491 		.op_name = "OP_READLINK",
2492 		.op_rsize_bop = nfsd4_readlink_rsize,
2493 	},
2494 	[OP_REMOVE] = {
2495 		.op_func = nfsd4_remove,
2496 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2497 		.op_name = "OP_REMOVE",
2498 		.op_rsize_bop = nfsd4_remove_rsize,
2499 	},
2500 	[OP_RENAME] = {
2501 		.op_func = nfsd4_rename,
2502 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2503 		.op_name = "OP_RENAME",
2504 		.op_rsize_bop = nfsd4_rename_rsize,
2505 	},
2506 	[OP_RENEW] = {
2507 		.op_func = nfsd4_renew,
2508 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2509 				| OP_MODIFIES_SOMETHING,
2510 		.op_name = "OP_RENEW",
2511 		.op_rsize_bop = nfsd4_only_status_rsize,
2512 
2513 	},
2514 	[OP_RESTOREFH] = {
2515 		.op_func = nfsd4_restorefh,
2516 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2517 				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
2518 		.op_name = "OP_RESTOREFH",
2519 		.op_rsize_bop = nfsd4_only_status_rsize,
2520 	},
2521 	[OP_SAVEFH] = {
2522 		.op_func = nfsd4_savefh,
2523 		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2524 		.op_name = "OP_SAVEFH",
2525 		.op_rsize_bop = nfsd4_only_status_rsize,
2526 	},
2527 	[OP_SECINFO] = {
2528 		.op_func = nfsd4_secinfo,
2529 		.op_release = nfsd4_secinfo_release,
2530 		.op_flags = OP_HANDLES_WRONGSEC,
2531 		.op_name = "OP_SECINFO",
2532 		.op_rsize_bop = nfsd4_secinfo_rsize,
2533 	},
2534 	[OP_SETATTR] = {
2535 		.op_func = nfsd4_setattr,
2536 		.op_name = "OP_SETATTR",
2537 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
2538 				| OP_NONTRIVIAL_ERROR_ENCODE,
2539 		.op_rsize_bop = nfsd4_setattr_rsize,
2540 		.op_get_currentstateid = nfsd4_get_setattrstateid,
2541 	},
2542 	[OP_SETCLIENTID] = {
2543 		.op_func = nfsd4_setclientid,
2544 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2545 				| OP_MODIFIES_SOMETHING | OP_CACHEME
2546 				| OP_NONTRIVIAL_ERROR_ENCODE,
2547 		.op_name = "OP_SETCLIENTID",
2548 		.op_rsize_bop = nfsd4_setclientid_rsize,
2549 	},
2550 	[OP_SETCLIENTID_CONFIRM] = {
2551 		.op_func = nfsd4_setclientid_confirm,
2552 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2553 				| OP_MODIFIES_SOMETHING | OP_CACHEME,
2554 		.op_name = "OP_SETCLIENTID_CONFIRM",
2555 		.op_rsize_bop = nfsd4_only_status_rsize,
2556 	},
2557 	[OP_VERIFY] = {
2558 		.op_func = nfsd4_verify,
2559 		.op_name = "OP_VERIFY",
2560 		.op_rsize_bop = nfsd4_only_status_rsize,
2561 	},
2562 	[OP_WRITE] = {
2563 		.op_func = nfsd4_write,
2564 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2565 		.op_name = "OP_WRITE",
2566 		.op_rsize_bop = nfsd4_write_rsize,
2567 		.op_get_currentstateid = nfsd4_get_writestateid,
2568 	},
2569 	[OP_RELEASE_LOCKOWNER] = {
2570 		.op_func = nfsd4_release_lockowner,
2571 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2572 				| OP_MODIFIES_SOMETHING,
2573 		.op_name = "OP_RELEASE_LOCKOWNER",
2574 		.op_rsize_bop = nfsd4_only_status_rsize,
2575 	},
2576 
2577 	/* NFSv4.1 operations */
2578 	[OP_EXCHANGE_ID] = {
2579 		.op_func = nfsd4_exchange_id,
2580 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2581 				| OP_MODIFIES_SOMETHING,
2582 		.op_name = "OP_EXCHANGE_ID",
2583 		.op_rsize_bop = nfsd4_exchange_id_rsize,
2584 	},
2585 	[OP_BACKCHANNEL_CTL] = {
2586 		.op_func = nfsd4_backchannel_ctl,
2587 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2588 		.op_name = "OP_BACKCHANNEL_CTL",
2589 		.op_rsize_bop = nfsd4_only_status_rsize,
2590 	},
2591 	[OP_BIND_CONN_TO_SESSION] = {
2592 		.op_func = nfsd4_bind_conn_to_session,
2593 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2594 				| OP_MODIFIES_SOMETHING,
2595 		.op_name = "OP_BIND_CONN_TO_SESSION",
2596 		.op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
2597 	},
2598 	[OP_CREATE_SESSION] = {
2599 		.op_func = nfsd4_create_session,
2600 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2601 				| OP_MODIFIES_SOMETHING,
2602 		.op_name = "OP_CREATE_SESSION",
2603 		.op_rsize_bop = nfsd4_create_session_rsize,
2604 	},
2605 	[OP_DESTROY_SESSION] = {
2606 		.op_func = nfsd4_destroy_session,
2607 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2608 				| OP_MODIFIES_SOMETHING,
2609 		.op_name = "OP_DESTROY_SESSION",
2610 		.op_rsize_bop = nfsd4_only_status_rsize,
2611 	},
2612 	[OP_SEQUENCE] = {
2613 		.op_func = nfsd4_sequence,
2614 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
2615 		.op_name = "OP_SEQUENCE",
2616 		.op_rsize_bop = nfsd4_sequence_rsize,
2617 	},
2618 	[OP_DESTROY_CLIENTID] = {
2619 		.op_func = nfsd4_destroy_clientid,
2620 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2621 				| OP_MODIFIES_SOMETHING,
2622 		.op_name = "OP_DESTROY_CLIENTID",
2623 		.op_rsize_bop = nfsd4_only_status_rsize,
2624 	},
2625 	[OP_RECLAIM_COMPLETE] = {
2626 		.op_func = nfsd4_reclaim_complete,
2627 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2628 		.op_name = "OP_RECLAIM_COMPLETE",
2629 		.op_rsize_bop = nfsd4_only_status_rsize,
2630 	},
2631 	[OP_SECINFO_NO_NAME] = {
2632 		.op_func = nfsd4_secinfo_no_name,
2633 		.op_release = nfsd4_secinfo_no_name_release,
2634 		.op_flags = OP_HANDLES_WRONGSEC,
2635 		.op_name = "OP_SECINFO_NO_NAME",
2636 		.op_rsize_bop = nfsd4_secinfo_rsize,
2637 	},
2638 	[OP_TEST_STATEID] = {
2639 		.op_func = nfsd4_test_stateid,
2640 		.op_flags = ALLOWED_WITHOUT_FH,
2641 		.op_name = "OP_TEST_STATEID",
2642 		.op_rsize_bop = nfsd4_test_stateid_rsize,
2643 	},
2644 	[OP_FREE_STATEID] = {
2645 		.op_func = nfsd4_free_stateid,
2646 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2647 		.op_name = "OP_FREE_STATEID",
2648 		.op_get_currentstateid = nfsd4_get_freestateid,
2649 		.op_rsize_bop = nfsd4_only_status_rsize,
2650 	},
2651 #ifdef CONFIG_NFSD_PNFS
2652 	[OP_GETDEVICEINFO] = {
2653 		.op_func = nfsd4_getdeviceinfo,
2654 		.op_release = nfsd4_getdeviceinfo_release,
2655 		.op_flags = ALLOWED_WITHOUT_FH,
2656 		.op_name = "OP_GETDEVICEINFO",
2657 		.op_rsize_bop = nfsd4_getdeviceinfo_rsize,
2658 	},
2659 	[OP_LAYOUTGET] = {
2660 		.op_func = nfsd4_layoutget,
2661 		.op_release = nfsd4_layoutget_release,
2662 		.op_flags = OP_MODIFIES_SOMETHING,
2663 		.op_name = "OP_LAYOUTGET",
2664 		.op_rsize_bop = nfsd4_layoutget_rsize,
2665 	},
2666 	[OP_LAYOUTCOMMIT] = {
2667 		.op_func = nfsd4_layoutcommit,
2668 		.op_flags = OP_MODIFIES_SOMETHING,
2669 		.op_name = "OP_LAYOUTCOMMIT",
2670 		.op_rsize_bop = nfsd4_layoutcommit_rsize,
2671 	},
2672 	[OP_LAYOUTRETURN] = {
2673 		.op_func = nfsd4_layoutreturn,
2674 		.op_flags = OP_MODIFIES_SOMETHING,
2675 		.op_name = "OP_LAYOUTRETURN",
2676 		.op_rsize_bop = nfsd4_layoutreturn_rsize,
2677 	},
2678 #endif /* CONFIG_NFSD_PNFS */
2679 
2680 	/* NFSv4.2 operations */
2681 	[OP_ALLOCATE] = {
2682 		.op_func = nfsd4_allocate,
2683 		.op_flags = OP_MODIFIES_SOMETHING,
2684 		.op_name = "OP_ALLOCATE",
2685 		.op_rsize_bop = nfsd4_only_status_rsize,
2686 	},
2687 	[OP_DEALLOCATE] = {
2688 		.op_func = nfsd4_deallocate,
2689 		.op_flags = OP_MODIFIES_SOMETHING,
2690 		.op_name = "OP_DEALLOCATE",
2691 		.op_rsize_bop = nfsd4_only_status_rsize,
2692 	},
2693 	[OP_CLONE] = {
2694 		.op_func = nfsd4_clone,
2695 		.op_flags = OP_MODIFIES_SOMETHING,
2696 		.op_name = "OP_CLONE",
2697 		.op_rsize_bop = nfsd4_only_status_rsize,
2698 	},
2699 	[OP_COPY] = {
2700 		.op_func = nfsd4_copy,
2701 		.op_flags = OP_MODIFIES_SOMETHING,
2702 		.op_name = "OP_COPY",
2703 		.op_rsize_bop = nfsd4_copy_rsize,
2704 	},
2705 	[OP_SEEK] = {
2706 		.op_func = nfsd4_seek,
2707 		.op_name = "OP_SEEK",
2708 		.op_rsize_bop = nfsd4_seek_rsize,
2709 	},
2710 	[OP_OFFLOAD_STATUS] = {
2711 		.op_func = nfsd4_offload_status,
2712 		.op_name = "OP_OFFLOAD_STATUS",
2713 		.op_rsize_bop = nfsd4_offload_status_rsize,
2714 	},
2715 	[OP_OFFLOAD_CANCEL] = {
2716 		.op_func = nfsd4_offload_cancel,
2717 		.op_flags = OP_MODIFIES_SOMETHING,
2718 		.op_name = "OP_OFFLOAD_CANCEL",
2719 		.op_rsize_bop = nfsd4_only_status_rsize,
2720 	},
2721 };
2722 
2723 /**
2724  * nfsd4_spo_must_allow - Determine if the compound op contains an
2725  * operation that is allowed to be sent with machine credentials
2726  *
2727  * @rqstp: a pointer to the struct svc_rqst
2728  *
2729  * Checks to see if the compound contains a spo_must_allow op
2730  * and confirms that it was sent with the proper machine creds.
2731  */
2732 
2733 bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
2734 {
2735 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
2736 	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2737 	struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2738 	struct nfsd4_compound_state *cstate = &resp->cstate;
2739 	struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
2740 	u32 opiter;
2741 
2742 	if (!cstate->minorversion)
2743 		return false;
2744 
2745 	if (cstate->spo_must_allowed == true)
2746 		return true;
2747 
2748 	opiter = resp->opcnt;
2749 	while (opiter < argp->opcnt) {
2750 		this = &argp->ops[opiter++];
2751 		if (test_bit(this->opnum, allow->u.longs) &&
2752 			cstate->clp->cl_mach_cred &&
2753 			nfsd4_mach_creds_match(cstate->clp, rqstp)) {
2754 			cstate->spo_must_allowed = true;
2755 			return true;
2756 		}
2757 	}
2758 	cstate->spo_must_allowed = false;
2759 	return false;
2760 }
2761 
2762 int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
2763 {
2764 	if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
2765 		return op_encode_hdr_size * sizeof(__be32);
2766 
2767 	BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
2768 	return OPDESC(op)->op_rsize_bop(rqstp, op);
2769 }
2770 
2771 void warn_on_nonidempotent_op(struct nfsd4_op *op)
2772 {
2773 	if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
2774 		pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
2775 			op->opnum, nfsd4_op_name(op->opnum));
2776 		WARN_ON_ONCE(1);
2777 	}
2778 }
2779 
2780 static const char *nfsd4_op_name(unsigned opnum)
2781 {
2782 	if (opnum < ARRAY_SIZE(nfsd4_ops))
2783 		return nfsd4_ops[opnum].op_name;
2784 	return "unknown_operation";
2785 }
2786 
2787 #define nfsd4_voidres			nfsd4_voidargs
2788 struct nfsd4_voidargs { int dummy; };
2789 
2790 static const struct svc_procedure nfsd_procedures4[2] = {
2791 	[NFSPROC4_NULL] = {
2792 		.pc_func = nfsd4_proc_null,
2793 		.pc_encode = nfs4svc_encode_voidres,
2794 		.pc_argsize = sizeof(struct nfsd4_voidargs),
2795 		.pc_ressize = sizeof(struct nfsd4_voidres),
2796 		.pc_cachetype = RC_NOCACHE,
2797 		.pc_xdrressize = 1,
2798 	},
2799 	[NFSPROC4_COMPOUND] = {
2800 		.pc_func = nfsd4_proc_compound,
2801 		.pc_decode = nfs4svc_decode_compoundargs,
2802 		.pc_encode = nfs4svc_encode_compoundres,
2803 		.pc_argsize = sizeof(struct nfsd4_compoundargs),
2804 		.pc_ressize = sizeof(struct nfsd4_compoundres),
2805 		.pc_release = nfsd4_release_compoundargs,
2806 		.pc_cachetype = RC_NOCACHE,
2807 		.pc_xdrressize = NFSD_BUFSIZE/4,
2808 	},
2809 };
2810 
2811 static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
2812 const struct svc_version nfsd_version4 = {
2813 	.vs_vers		= 4,
2814 	.vs_nproc		= 2,
2815 	.vs_proc		= nfsd_procedures4,
2816 	.vs_count		= nfsd_count3,
2817 	.vs_dispatch		= nfsd_dispatch,
2818 	.vs_xdrsize		= NFS4_SVC_XDRSIZE,
2819 	.vs_rpcb_optnl		= true,
2820 	.vs_need_cong_ctrl	= true,
2821 };
2822 
2823 /*
2824  * Local variables:
2825  *  c-basic-offset: 8
2826  * End:
2827  */
2828