xref: /openbmc/linux/fs/nfsd/nfs4proc.c (revision 7d545e77)
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 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1931 	__be32		status;
1932 
1933 	svcxdr_init_encode(rqstp, resp);
1934 	resp->tagp = resp->xdr.p;
1935 	/* reserve space for: taglen, tag, and opcnt */
1936 	xdr_reserve_space(&resp->xdr, 8 + args->taglen);
1937 	resp->taglen = args->taglen;
1938 	resp->tag = args->tag;
1939 	resp->rqstp = rqstp;
1940 	cstate->minorversion = args->minorversion;
1941 	fh_init(current_fh, NFS4_FHSIZE);
1942 	fh_init(save_fh, NFS4_FHSIZE);
1943 	/*
1944 	 * Don't use the deferral mechanism for NFSv4; compounds make it
1945 	 * too hard to avoid non-idempotency problems.
1946 	 */
1947 	clear_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
1948 
1949 	/*
1950 	 * According to RFC3010, this takes precedence over all other errors.
1951 	 */
1952 	status = nfserr_minor_vers_mismatch;
1953 	if (nfsd_minorversion(nn, args->minorversion, NFSD_TEST) <= 0)
1954 		goto out;
1955 	status = nfserr_resource;
1956 	if (args->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
1957 		goto out;
1958 
1959 	status = nfs41_check_op_ordering(args);
1960 	if (status) {
1961 		op = &args->ops[0];
1962 		op->status = status;
1963 		resp->opcnt = 1;
1964 		goto encode_op;
1965 	}
1966 
1967 	trace_nfsd_compound(rqstp, args->opcnt);
1968 	while (!status && resp->opcnt < args->opcnt) {
1969 		op = &args->ops[resp->opcnt++];
1970 
1971 		/*
1972 		 * The XDR decode routines may have pre-set op->status;
1973 		 * for example, if there is a miscellaneous XDR error
1974 		 * it will be set to nfserr_bad_xdr.
1975 		 */
1976 		if (op->status) {
1977 			if (op->opnum == OP_OPEN)
1978 				op->status = nfsd4_open_omfg(rqstp, cstate, op);
1979 			goto encode_op;
1980 		}
1981 
1982 		if (!current_fh->fh_dentry) {
1983 			if (!(op->opdesc->op_flags & ALLOWED_WITHOUT_FH)) {
1984 				op->status = nfserr_nofilehandle;
1985 				goto encode_op;
1986 			}
1987 		} else if (current_fh->fh_export->ex_fslocs.migrated &&
1988 			  !(op->opdesc->op_flags & ALLOWED_ON_ABSENT_FS)) {
1989 			op->status = nfserr_moved;
1990 			goto encode_op;
1991 		}
1992 
1993 		fh_clear_wcc(current_fh);
1994 
1995 		/* If op is non-idempotent */
1996 		if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {
1997 			/*
1998 			 * Don't execute this op if we couldn't encode a
1999 			 * succesful reply:
2000 			 */
2001 			u32 plen = op->opdesc->op_rsize_bop(rqstp, op);
2002 			/*
2003 			 * Plus if there's another operation, make sure
2004 			 * we'll have space to at least encode an error:
2005 			 */
2006 			if (resp->opcnt < args->opcnt)
2007 				plen += COMPOUND_ERR_SLACK_SPACE;
2008 			op->status = nfsd4_check_resp_size(resp, plen);
2009 		}
2010 
2011 		if (op->status)
2012 			goto encode_op;
2013 
2014 		if (op->opdesc->op_get_currentstateid)
2015 			op->opdesc->op_get_currentstateid(cstate, &op->u);
2016 		op->status = op->opdesc->op_func(rqstp, cstate, &op->u);
2017 
2018 		/* Only from SEQUENCE */
2019 		if (cstate->status == nfserr_replay_cache) {
2020 			dprintk("%s NFS4.1 replay from cache\n", __func__);
2021 			status = op->status;
2022 			goto out;
2023 		}
2024 		if (!op->status) {
2025 			if (op->opdesc->op_set_currentstateid)
2026 				op->opdesc->op_set_currentstateid(cstate, &op->u);
2027 
2028 			if (op->opdesc->op_flags & OP_CLEAR_STATEID)
2029 				clear_current_stateid(cstate);
2030 
2031 			if (need_wrongsec_check(rqstp))
2032 				op->status = check_nfsd_access(current_fh->fh_export, rqstp);
2033 		}
2034 encode_op:
2035 		if (op->status == nfserr_replay_me) {
2036 			op->replay = &cstate->replay_owner->so_replay;
2037 			nfsd4_encode_replay(&resp->xdr, op);
2038 			status = op->status = op->replay->rp_status;
2039 		} else {
2040 			nfsd4_encode_operation(resp, op);
2041 			status = op->status;
2042 		}
2043 
2044 		trace_nfsd_compound_status(args->opcnt, resp->opcnt, status,
2045 					   nfsd4_op_name(op->opnum));
2046 
2047 		nfsd4_cstate_clear_replay(cstate);
2048 		nfsd4_increment_op_stats(op->opnum);
2049 	}
2050 
2051 	cstate->status = status;
2052 	fh_put(current_fh);
2053 	fh_put(save_fh);
2054 	BUG_ON(cstate->replay_owner);
2055 out:
2056 	/* Reset deferral mechanism for RPC deferrals */
2057 	set_bit(RQ_USEDEFERRAL, &rqstp->rq_flags);
2058 	dprintk("nfsv4 compound returned %d\n", ntohl(status));
2059 	return status;
2060 }
2061 
2062 #define op_encode_hdr_size		(2)
2063 #define op_encode_stateid_maxsz		(XDR_QUADLEN(NFS4_STATEID_SIZE))
2064 #define op_encode_verifier_maxsz	(XDR_QUADLEN(NFS4_VERIFIER_SIZE))
2065 #define op_encode_change_info_maxsz	(5)
2066 #define nfs4_fattr_bitmap_maxsz		(4)
2067 
2068 /* We'll fall back on returning no lockowner if run out of space: */
2069 #define op_encode_lockowner_maxsz	(0)
2070 #define op_encode_lock_denied_maxsz	(8 + op_encode_lockowner_maxsz)
2071 
2072 #define nfs4_owner_maxsz		(1 + XDR_QUADLEN(IDMAP_NAMESZ))
2073 
2074 #define op_encode_ace_maxsz		(3 + nfs4_owner_maxsz)
2075 #define op_encode_delegation_maxsz	(1 + op_encode_stateid_maxsz + 1 + \
2076 					 op_encode_ace_maxsz)
2077 
2078 #define op_encode_channel_attrs_maxsz	(6 + 1 + 1)
2079 
2080 static inline u32 nfsd4_only_status_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2081 {
2082 	return (op_encode_hdr_size) * sizeof(__be32);
2083 }
2084 
2085 static inline u32 nfsd4_status_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2086 {
2087 	return (op_encode_hdr_size + op_encode_stateid_maxsz)* sizeof(__be32);
2088 }
2089 
2090 static inline u32 nfsd4_access_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2091 {
2092 	/* ac_supported, ac_resp_access */
2093 	return (op_encode_hdr_size + 2)* sizeof(__be32);
2094 }
2095 
2096 static inline u32 nfsd4_commit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2097 {
2098 	return (op_encode_hdr_size + op_encode_verifier_maxsz) * sizeof(__be32);
2099 }
2100 
2101 static inline u32 nfsd4_create_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2102 {
2103 	return (op_encode_hdr_size + op_encode_change_info_maxsz
2104 		+ nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2105 }
2106 
2107 /*
2108  * Note since this is an idempotent operation we won't insist on failing
2109  * the op prematurely if the estimate is too large.  We may turn off splice
2110  * reads unnecessarily.
2111  */
2112 static inline u32 nfsd4_getattr_rsize(struct svc_rqst *rqstp,
2113 				      struct nfsd4_op *op)
2114 {
2115 	u32 *bmap = op->u.getattr.ga_bmval;
2116 	u32 bmap0 = bmap[0], bmap1 = bmap[1], bmap2 = bmap[2];
2117 	u32 ret = 0;
2118 
2119 	if (bmap0 & FATTR4_WORD0_ACL)
2120 		return svc_max_payload(rqstp);
2121 	if (bmap0 & FATTR4_WORD0_FS_LOCATIONS)
2122 		return svc_max_payload(rqstp);
2123 
2124 	if (bmap1 & FATTR4_WORD1_OWNER) {
2125 		ret += IDMAP_NAMESZ + 4;
2126 		bmap1 &= ~FATTR4_WORD1_OWNER;
2127 	}
2128 	if (bmap1 & FATTR4_WORD1_OWNER_GROUP) {
2129 		ret += IDMAP_NAMESZ + 4;
2130 		bmap1 &= ~FATTR4_WORD1_OWNER_GROUP;
2131 	}
2132 	if (bmap0 & FATTR4_WORD0_FILEHANDLE) {
2133 		ret += NFS4_FHSIZE + 4;
2134 		bmap0 &= ~FATTR4_WORD0_FILEHANDLE;
2135 	}
2136 	if (bmap2 & FATTR4_WORD2_SECURITY_LABEL) {
2137 		ret += NFS4_MAXLABELLEN + 12;
2138 		bmap2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2139 	}
2140 	/*
2141 	 * Largest of remaining attributes are 16 bytes (e.g.,
2142 	 * supported_attributes)
2143 	 */
2144 	ret += 16 * (hweight32(bmap0) + hweight32(bmap1) + hweight32(bmap2));
2145 	/* bitmask, length */
2146 	ret += 20;
2147 	return ret;
2148 }
2149 
2150 static inline u32 nfsd4_getfh_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2151 {
2152 	return (op_encode_hdr_size + 1) * sizeof(__be32) + NFS4_FHSIZE;
2153 }
2154 
2155 static inline u32 nfsd4_link_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2156 {
2157 	return (op_encode_hdr_size + op_encode_change_info_maxsz)
2158 		* sizeof(__be32);
2159 }
2160 
2161 static inline u32 nfsd4_lock_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2162 {
2163 	return (op_encode_hdr_size + op_encode_lock_denied_maxsz)
2164 		* sizeof(__be32);
2165 }
2166 
2167 static inline u32 nfsd4_open_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2168 {
2169 	return (op_encode_hdr_size + op_encode_stateid_maxsz
2170 		+ op_encode_change_info_maxsz + 1
2171 		+ nfs4_fattr_bitmap_maxsz
2172 		+ op_encode_delegation_maxsz) * sizeof(__be32);
2173 }
2174 
2175 static inline u32 nfsd4_read_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2176 {
2177 	u32 maxcount = 0, rlen = 0;
2178 
2179 	maxcount = svc_max_payload(rqstp);
2180 	rlen = min(op->u.read.rd_length, maxcount);
2181 
2182 	return (op_encode_hdr_size + 2 + XDR_QUADLEN(rlen)) * sizeof(__be32);
2183 }
2184 
2185 static inline u32 nfsd4_readdir_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2186 {
2187 	u32 maxcount = 0, rlen = 0;
2188 
2189 	maxcount = svc_max_payload(rqstp);
2190 	rlen = min(op->u.readdir.rd_maxcount, maxcount);
2191 
2192 	return (op_encode_hdr_size + op_encode_verifier_maxsz +
2193 		XDR_QUADLEN(rlen)) * sizeof(__be32);
2194 }
2195 
2196 static inline u32 nfsd4_readlink_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2197 {
2198 	return (op_encode_hdr_size + 1) * sizeof(__be32) + PAGE_SIZE;
2199 }
2200 
2201 static inline u32 nfsd4_remove_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2202 {
2203 	return (op_encode_hdr_size + op_encode_change_info_maxsz)
2204 		* sizeof(__be32);
2205 }
2206 
2207 static inline u32 nfsd4_rename_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2208 {
2209 	return (op_encode_hdr_size + op_encode_change_info_maxsz
2210 		+ op_encode_change_info_maxsz) * sizeof(__be32);
2211 }
2212 
2213 static inline u32 nfsd4_sequence_rsize(struct svc_rqst *rqstp,
2214 				       struct nfsd4_op *op)
2215 {
2216 	return (op_encode_hdr_size
2217 		+ XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + 5) * sizeof(__be32);
2218 }
2219 
2220 static inline u32 nfsd4_test_stateid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2221 {
2222 	return (op_encode_hdr_size + 1 + op->u.test_stateid.ts_num_ids)
2223 		* sizeof(__be32);
2224 }
2225 
2226 static inline u32 nfsd4_setattr_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2227 {
2228 	return (op_encode_hdr_size + nfs4_fattr_bitmap_maxsz) * sizeof(__be32);
2229 }
2230 
2231 static inline u32 nfsd4_secinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2232 {
2233 	return (op_encode_hdr_size + RPC_AUTH_MAXFLAVOR *
2234 		(4 + XDR_QUADLEN(GSS_OID_MAX_LEN))) * sizeof(__be32);
2235 }
2236 
2237 static inline u32 nfsd4_setclientid_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2238 {
2239 	return (op_encode_hdr_size + 2 + XDR_QUADLEN(NFS4_VERIFIER_SIZE)) *
2240 								sizeof(__be32);
2241 }
2242 
2243 static inline u32 nfsd4_write_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2244 {
2245 	return (op_encode_hdr_size + 2 + op_encode_verifier_maxsz) * sizeof(__be32);
2246 }
2247 
2248 static inline u32 nfsd4_exchange_id_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2249 {
2250 	return (op_encode_hdr_size + 2 + 1 + /* eir_clientid, eir_sequenceid */\
2251 		1 + 1 + /* eir_flags, spr_how */\
2252 		4 + /* spo_must_enforce & _allow with bitmap */\
2253 		2 + /*eir_server_owner.so_minor_id */\
2254 		/* eir_server_owner.so_major_id<> */\
2255 		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2256 		/* eir_server_scope<> */\
2257 		XDR_QUADLEN(NFS4_OPAQUE_LIMIT) + 1 +\
2258 		1 + /* eir_server_impl_id array length */\
2259 		0 /* ignored eir_server_impl_id contents */) * sizeof(__be32);
2260 }
2261 
2262 static inline u32 nfsd4_bind_conn_to_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2263 {
2264 	return (op_encode_hdr_size + \
2265 		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* bctsr_sessid */\
2266 		2 /* bctsr_dir, use_conn_in_rdma_mode */) * sizeof(__be32);
2267 }
2268 
2269 static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2270 {
2271 	return (op_encode_hdr_size + \
2272 		XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + /* sessionid */\
2273 		2 + /* csr_sequence, csr_flags */\
2274 		op_encode_channel_attrs_maxsz + \
2275 		op_encode_channel_attrs_maxsz) * sizeof(__be32);
2276 }
2277 
2278 static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2279 {
2280 	return (op_encode_hdr_size +
2281 		1 /* wr_callback */ +
2282 		op_encode_stateid_maxsz /* wr_callback */ +
2283 		2 /* wr_count */ +
2284 		1 /* wr_committed */ +
2285 		op_encode_verifier_maxsz +
2286 		1 /* cr_consecutive */ +
2287 		1 /* cr_synchronous */) * sizeof(__be32);
2288 }
2289 
2290 static inline u32 nfsd4_offload_status_rsize(struct svc_rqst *rqstp,
2291 					     struct nfsd4_op *op)
2292 {
2293 	return (op_encode_hdr_size +
2294 		2 /* osr_count */ +
2295 		1 /* osr_complete<1> optional 0 for now */) * sizeof(__be32);
2296 }
2297 
2298 #ifdef CONFIG_NFSD_PNFS
2299 static inline u32 nfsd4_getdeviceinfo_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2300 {
2301 	u32 maxcount = 0, rlen = 0;
2302 
2303 	maxcount = svc_max_payload(rqstp);
2304 	rlen = min(op->u.getdeviceinfo.gd_maxcount, maxcount);
2305 
2306 	return (op_encode_hdr_size +
2307 		1 /* gd_layout_type*/ +
2308 		XDR_QUADLEN(rlen) +
2309 		2 /* gd_notify_types */) * sizeof(__be32);
2310 }
2311 
2312 /*
2313  * At this stage we don't really know what layout driver will handle the request,
2314  * so we need to define an arbitrary upper bound here.
2315  */
2316 #define MAX_LAYOUT_SIZE		128
2317 static inline u32 nfsd4_layoutget_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2318 {
2319 	return (op_encode_hdr_size +
2320 		1 /* logr_return_on_close */ +
2321 		op_encode_stateid_maxsz +
2322 		1 /* nr of layouts */ +
2323 		MAX_LAYOUT_SIZE) * sizeof(__be32);
2324 }
2325 
2326 static inline u32 nfsd4_layoutcommit_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2327 {
2328 	return (op_encode_hdr_size +
2329 		1 /* locr_newsize */ +
2330 		2 /* ns_size */) * sizeof(__be32);
2331 }
2332 
2333 static inline u32 nfsd4_layoutreturn_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2334 {
2335 	return (op_encode_hdr_size +
2336 		1 /* lrs_stateid */ +
2337 		op_encode_stateid_maxsz) * sizeof(__be32);
2338 }
2339 #endif /* CONFIG_NFSD_PNFS */
2340 
2341 
2342 static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
2343 {
2344 	return (op_encode_hdr_size + 3) * sizeof(__be32);
2345 }
2346 
2347 static const struct nfsd4_operation nfsd4_ops[] = {
2348 	[OP_ACCESS] = {
2349 		.op_func = nfsd4_access,
2350 		.op_name = "OP_ACCESS",
2351 		.op_rsize_bop = nfsd4_access_rsize,
2352 	},
2353 	[OP_CLOSE] = {
2354 		.op_func = nfsd4_close,
2355 		.op_flags = OP_MODIFIES_SOMETHING,
2356 		.op_name = "OP_CLOSE",
2357 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2358 		.op_get_currentstateid = nfsd4_get_closestateid,
2359 		.op_set_currentstateid = nfsd4_set_closestateid,
2360 	},
2361 	[OP_COMMIT] = {
2362 		.op_func = nfsd4_commit,
2363 		.op_flags = OP_MODIFIES_SOMETHING,
2364 		.op_name = "OP_COMMIT",
2365 		.op_rsize_bop = nfsd4_commit_rsize,
2366 	},
2367 	[OP_CREATE] = {
2368 		.op_func = nfsd4_create,
2369 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME | OP_CLEAR_STATEID,
2370 		.op_name = "OP_CREATE",
2371 		.op_rsize_bop = nfsd4_create_rsize,
2372 	},
2373 	[OP_DELEGRETURN] = {
2374 		.op_func = nfsd4_delegreturn,
2375 		.op_flags = OP_MODIFIES_SOMETHING,
2376 		.op_name = "OP_DELEGRETURN",
2377 		.op_rsize_bop = nfsd4_only_status_rsize,
2378 		.op_get_currentstateid = nfsd4_get_delegreturnstateid,
2379 	},
2380 	[OP_GETATTR] = {
2381 		.op_func = nfsd4_getattr,
2382 		.op_flags = ALLOWED_ON_ABSENT_FS,
2383 		.op_rsize_bop = nfsd4_getattr_rsize,
2384 		.op_name = "OP_GETATTR",
2385 	},
2386 	[OP_GETFH] = {
2387 		.op_func = nfsd4_getfh,
2388 		.op_name = "OP_GETFH",
2389 		.op_rsize_bop = nfsd4_getfh_rsize,
2390 	},
2391 	[OP_LINK] = {
2392 		.op_func = nfsd4_link,
2393 		.op_flags = ALLOWED_ON_ABSENT_FS | OP_MODIFIES_SOMETHING
2394 				| OP_CACHEME,
2395 		.op_name = "OP_LINK",
2396 		.op_rsize_bop = nfsd4_link_rsize,
2397 	},
2398 	[OP_LOCK] = {
2399 		.op_func = nfsd4_lock,
2400 		.op_flags = OP_MODIFIES_SOMETHING |
2401 				OP_NONTRIVIAL_ERROR_ENCODE,
2402 		.op_name = "OP_LOCK",
2403 		.op_rsize_bop = nfsd4_lock_rsize,
2404 		.op_set_currentstateid = nfsd4_set_lockstateid,
2405 	},
2406 	[OP_LOCKT] = {
2407 		.op_func = nfsd4_lockt,
2408 		.op_flags = OP_NONTRIVIAL_ERROR_ENCODE,
2409 		.op_name = "OP_LOCKT",
2410 		.op_rsize_bop = nfsd4_lock_rsize,
2411 	},
2412 	[OP_LOCKU] = {
2413 		.op_func = nfsd4_locku,
2414 		.op_flags = OP_MODIFIES_SOMETHING,
2415 		.op_name = "OP_LOCKU",
2416 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2417 		.op_get_currentstateid = nfsd4_get_lockustateid,
2418 	},
2419 	[OP_LOOKUP] = {
2420 		.op_func = nfsd4_lookup,
2421 		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2422 		.op_name = "OP_LOOKUP",
2423 		.op_rsize_bop = nfsd4_only_status_rsize,
2424 	},
2425 	[OP_LOOKUPP] = {
2426 		.op_func = nfsd4_lookupp,
2427 		.op_flags = OP_HANDLES_WRONGSEC | OP_CLEAR_STATEID,
2428 		.op_name = "OP_LOOKUPP",
2429 		.op_rsize_bop = nfsd4_only_status_rsize,
2430 	},
2431 	[OP_NVERIFY] = {
2432 		.op_func = nfsd4_nverify,
2433 		.op_name = "OP_NVERIFY",
2434 		.op_rsize_bop = nfsd4_only_status_rsize,
2435 	},
2436 	[OP_OPEN] = {
2437 		.op_func = nfsd4_open,
2438 		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2439 		.op_name = "OP_OPEN",
2440 		.op_rsize_bop = nfsd4_open_rsize,
2441 		.op_set_currentstateid = nfsd4_set_openstateid,
2442 	},
2443 	[OP_OPEN_CONFIRM] = {
2444 		.op_func = nfsd4_open_confirm,
2445 		.op_flags = OP_MODIFIES_SOMETHING,
2446 		.op_name = "OP_OPEN_CONFIRM",
2447 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2448 	},
2449 	[OP_OPEN_DOWNGRADE] = {
2450 		.op_func = nfsd4_open_downgrade,
2451 		.op_flags = OP_MODIFIES_SOMETHING,
2452 		.op_name = "OP_OPEN_DOWNGRADE",
2453 		.op_rsize_bop = nfsd4_status_stateid_rsize,
2454 		.op_get_currentstateid = nfsd4_get_opendowngradestateid,
2455 		.op_set_currentstateid = nfsd4_set_opendowngradestateid,
2456 	},
2457 	[OP_PUTFH] = {
2458 		.op_func = nfsd4_putfh,
2459 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2460 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2461 		.op_name = "OP_PUTFH",
2462 		.op_rsize_bop = nfsd4_only_status_rsize,
2463 	},
2464 	[OP_PUTPUBFH] = {
2465 		.op_func = nfsd4_putrootfh,
2466 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2467 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2468 		.op_name = "OP_PUTPUBFH",
2469 		.op_rsize_bop = nfsd4_only_status_rsize,
2470 	},
2471 	[OP_PUTROOTFH] = {
2472 		.op_func = nfsd4_putrootfh,
2473 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2474 				| OP_IS_PUTFH_LIKE | OP_CLEAR_STATEID,
2475 		.op_name = "OP_PUTROOTFH",
2476 		.op_rsize_bop = nfsd4_only_status_rsize,
2477 	},
2478 	[OP_READ] = {
2479 		.op_func = nfsd4_read,
2480 		.op_release = nfsd4_read_release,
2481 		.op_name = "OP_READ",
2482 		.op_rsize_bop = nfsd4_read_rsize,
2483 		.op_get_currentstateid = nfsd4_get_readstateid,
2484 	},
2485 	[OP_READDIR] = {
2486 		.op_func = nfsd4_readdir,
2487 		.op_name = "OP_READDIR",
2488 		.op_rsize_bop = nfsd4_readdir_rsize,
2489 	},
2490 	[OP_READLINK] = {
2491 		.op_func = nfsd4_readlink,
2492 		.op_name = "OP_READLINK",
2493 		.op_rsize_bop = nfsd4_readlink_rsize,
2494 	},
2495 	[OP_REMOVE] = {
2496 		.op_func = nfsd4_remove,
2497 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2498 		.op_name = "OP_REMOVE",
2499 		.op_rsize_bop = nfsd4_remove_rsize,
2500 	},
2501 	[OP_RENAME] = {
2502 		.op_func = nfsd4_rename,
2503 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2504 		.op_name = "OP_RENAME",
2505 		.op_rsize_bop = nfsd4_rename_rsize,
2506 	},
2507 	[OP_RENEW] = {
2508 		.op_func = nfsd4_renew,
2509 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2510 				| OP_MODIFIES_SOMETHING,
2511 		.op_name = "OP_RENEW",
2512 		.op_rsize_bop = nfsd4_only_status_rsize,
2513 
2514 	},
2515 	[OP_RESTOREFH] = {
2516 		.op_func = nfsd4_restorefh,
2517 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2518 				| OP_IS_PUTFH_LIKE | OP_MODIFIES_SOMETHING,
2519 		.op_name = "OP_RESTOREFH",
2520 		.op_rsize_bop = nfsd4_only_status_rsize,
2521 	},
2522 	[OP_SAVEFH] = {
2523 		.op_func = nfsd4_savefh,
2524 		.op_flags = OP_HANDLES_WRONGSEC | OP_MODIFIES_SOMETHING,
2525 		.op_name = "OP_SAVEFH",
2526 		.op_rsize_bop = nfsd4_only_status_rsize,
2527 	},
2528 	[OP_SECINFO] = {
2529 		.op_func = nfsd4_secinfo,
2530 		.op_release = nfsd4_secinfo_release,
2531 		.op_flags = OP_HANDLES_WRONGSEC,
2532 		.op_name = "OP_SECINFO",
2533 		.op_rsize_bop = nfsd4_secinfo_rsize,
2534 	},
2535 	[OP_SETATTR] = {
2536 		.op_func = nfsd4_setattr,
2537 		.op_name = "OP_SETATTR",
2538 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME
2539 				| OP_NONTRIVIAL_ERROR_ENCODE,
2540 		.op_rsize_bop = nfsd4_setattr_rsize,
2541 		.op_get_currentstateid = nfsd4_get_setattrstateid,
2542 	},
2543 	[OP_SETCLIENTID] = {
2544 		.op_func = nfsd4_setclientid,
2545 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2546 				| OP_MODIFIES_SOMETHING | OP_CACHEME
2547 				| OP_NONTRIVIAL_ERROR_ENCODE,
2548 		.op_name = "OP_SETCLIENTID",
2549 		.op_rsize_bop = nfsd4_setclientid_rsize,
2550 	},
2551 	[OP_SETCLIENTID_CONFIRM] = {
2552 		.op_func = nfsd4_setclientid_confirm,
2553 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2554 				| OP_MODIFIES_SOMETHING | OP_CACHEME,
2555 		.op_name = "OP_SETCLIENTID_CONFIRM",
2556 		.op_rsize_bop = nfsd4_only_status_rsize,
2557 	},
2558 	[OP_VERIFY] = {
2559 		.op_func = nfsd4_verify,
2560 		.op_name = "OP_VERIFY",
2561 		.op_rsize_bop = nfsd4_only_status_rsize,
2562 	},
2563 	[OP_WRITE] = {
2564 		.op_func = nfsd4_write,
2565 		.op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
2566 		.op_name = "OP_WRITE",
2567 		.op_rsize_bop = nfsd4_write_rsize,
2568 		.op_get_currentstateid = nfsd4_get_writestateid,
2569 	},
2570 	[OP_RELEASE_LOCKOWNER] = {
2571 		.op_func = nfsd4_release_lockowner,
2572 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_ON_ABSENT_FS
2573 				| OP_MODIFIES_SOMETHING,
2574 		.op_name = "OP_RELEASE_LOCKOWNER",
2575 		.op_rsize_bop = nfsd4_only_status_rsize,
2576 	},
2577 
2578 	/* NFSv4.1 operations */
2579 	[OP_EXCHANGE_ID] = {
2580 		.op_func = nfsd4_exchange_id,
2581 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2582 				| OP_MODIFIES_SOMETHING,
2583 		.op_name = "OP_EXCHANGE_ID",
2584 		.op_rsize_bop = nfsd4_exchange_id_rsize,
2585 	},
2586 	[OP_BACKCHANNEL_CTL] = {
2587 		.op_func = nfsd4_backchannel_ctl,
2588 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2589 		.op_name = "OP_BACKCHANNEL_CTL",
2590 		.op_rsize_bop = nfsd4_only_status_rsize,
2591 	},
2592 	[OP_BIND_CONN_TO_SESSION] = {
2593 		.op_func = nfsd4_bind_conn_to_session,
2594 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2595 				| OP_MODIFIES_SOMETHING,
2596 		.op_name = "OP_BIND_CONN_TO_SESSION",
2597 		.op_rsize_bop = nfsd4_bind_conn_to_session_rsize,
2598 	},
2599 	[OP_CREATE_SESSION] = {
2600 		.op_func = nfsd4_create_session,
2601 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2602 				| OP_MODIFIES_SOMETHING,
2603 		.op_name = "OP_CREATE_SESSION",
2604 		.op_rsize_bop = nfsd4_create_session_rsize,
2605 	},
2606 	[OP_DESTROY_SESSION] = {
2607 		.op_func = nfsd4_destroy_session,
2608 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2609 				| OP_MODIFIES_SOMETHING,
2610 		.op_name = "OP_DESTROY_SESSION",
2611 		.op_rsize_bop = nfsd4_only_status_rsize,
2612 	},
2613 	[OP_SEQUENCE] = {
2614 		.op_func = nfsd4_sequence,
2615 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP,
2616 		.op_name = "OP_SEQUENCE",
2617 		.op_rsize_bop = nfsd4_sequence_rsize,
2618 	},
2619 	[OP_DESTROY_CLIENTID] = {
2620 		.op_func = nfsd4_destroy_clientid,
2621 		.op_flags = ALLOWED_WITHOUT_FH | ALLOWED_AS_FIRST_OP
2622 				| OP_MODIFIES_SOMETHING,
2623 		.op_name = "OP_DESTROY_CLIENTID",
2624 		.op_rsize_bop = nfsd4_only_status_rsize,
2625 	},
2626 	[OP_RECLAIM_COMPLETE] = {
2627 		.op_func = nfsd4_reclaim_complete,
2628 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2629 		.op_name = "OP_RECLAIM_COMPLETE",
2630 		.op_rsize_bop = nfsd4_only_status_rsize,
2631 	},
2632 	[OP_SECINFO_NO_NAME] = {
2633 		.op_func = nfsd4_secinfo_no_name,
2634 		.op_release = nfsd4_secinfo_no_name_release,
2635 		.op_flags = OP_HANDLES_WRONGSEC,
2636 		.op_name = "OP_SECINFO_NO_NAME",
2637 		.op_rsize_bop = nfsd4_secinfo_rsize,
2638 	},
2639 	[OP_TEST_STATEID] = {
2640 		.op_func = nfsd4_test_stateid,
2641 		.op_flags = ALLOWED_WITHOUT_FH,
2642 		.op_name = "OP_TEST_STATEID",
2643 		.op_rsize_bop = nfsd4_test_stateid_rsize,
2644 	},
2645 	[OP_FREE_STATEID] = {
2646 		.op_func = nfsd4_free_stateid,
2647 		.op_flags = ALLOWED_WITHOUT_FH | OP_MODIFIES_SOMETHING,
2648 		.op_name = "OP_FREE_STATEID",
2649 		.op_get_currentstateid = nfsd4_get_freestateid,
2650 		.op_rsize_bop = nfsd4_only_status_rsize,
2651 	},
2652 #ifdef CONFIG_NFSD_PNFS
2653 	[OP_GETDEVICEINFO] = {
2654 		.op_func = nfsd4_getdeviceinfo,
2655 		.op_release = nfsd4_getdeviceinfo_release,
2656 		.op_flags = ALLOWED_WITHOUT_FH,
2657 		.op_name = "OP_GETDEVICEINFO",
2658 		.op_rsize_bop = nfsd4_getdeviceinfo_rsize,
2659 	},
2660 	[OP_LAYOUTGET] = {
2661 		.op_func = nfsd4_layoutget,
2662 		.op_release = nfsd4_layoutget_release,
2663 		.op_flags = OP_MODIFIES_SOMETHING,
2664 		.op_name = "OP_LAYOUTGET",
2665 		.op_rsize_bop = nfsd4_layoutget_rsize,
2666 	},
2667 	[OP_LAYOUTCOMMIT] = {
2668 		.op_func = nfsd4_layoutcommit,
2669 		.op_flags = OP_MODIFIES_SOMETHING,
2670 		.op_name = "OP_LAYOUTCOMMIT",
2671 		.op_rsize_bop = nfsd4_layoutcommit_rsize,
2672 	},
2673 	[OP_LAYOUTRETURN] = {
2674 		.op_func = nfsd4_layoutreturn,
2675 		.op_flags = OP_MODIFIES_SOMETHING,
2676 		.op_name = "OP_LAYOUTRETURN",
2677 		.op_rsize_bop = nfsd4_layoutreturn_rsize,
2678 	},
2679 #endif /* CONFIG_NFSD_PNFS */
2680 
2681 	/* NFSv4.2 operations */
2682 	[OP_ALLOCATE] = {
2683 		.op_func = nfsd4_allocate,
2684 		.op_flags = OP_MODIFIES_SOMETHING,
2685 		.op_name = "OP_ALLOCATE",
2686 		.op_rsize_bop = nfsd4_only_status_rsize,
2687 	},
2688 	[OP_DEALLOCATE] = {
2689 		.op_func = nfsd4_deallocate,
2690 		.op_flags = OP_MODIFIES_SOMETHING,
2691 		.op_name = "OP_DEALLOCATE",
2692 		.op_rsize_bop = nfsd4_only_status_rsize,
2693 	},
2694 	[OP_CLONE] = {
2695 		.op_func = nfsd4_clone,
2696 		.op_flags = OP_MODIFIES_SOMETHING,
2697 		.op_name = "OP_CLONE",
2698 		.op_rsize_bop = nfsd4_only_status_rsize,
2699 	},
2700 	[OP_COPY] = {
2701 		.op_func = nfsd4_copy,
2702 		.op_flags = OP_MODIFIES_SOMETHING,
2703 		.op_name = "OP_COPY",
2704 		.op_rsize_bop = nfsd4_copy_rsize,
2705 	},
2706 	[OP_SEEK] = {
2707 		.op_func = nfsd4_seek,
2708 		.op_name = "OP_SEEK",
2709 		.op_rsize_bop = nfsd4_seek_rsize,
2710 	},
2711 	[OP_OFFLOAD_STATUS] = {
2712 		.op_func = nfsd4_offload_status,
2713 		.op_name = "OP_OFFLOAD_STATUS",
2714 		.op_rsize_bop = nfsd4_offload_status_rsize,
2715 	},
2716 	[OP_OFFLOAD_CANCEL] = {
2717 		.op_func = nfsd4_offload_cancel,
2718 		.op_flags = OP_MODIFIES_SOMETHING,
2719 		.op_name = "OP_OFFLOAD_CANCEL",
2720 		.op_rsize_bop = nfsd4_only_status_rsize,
2721 	},
2722 };
2723 
2724 /**
2725  * nfsd4_spo_must_allow - Determine if the compound op contains an
2726  * operation that is allowed to be sent with machine credentials
2727  *
2728  * @rqstp: a pointer to the struct svc_rqst
2729  *
2730  * Checks to see if the compound contains a spo_must_allow op
2731  * and confirms that it was sent with the proper machine creds.
2732  */
2733 
2734 bool nfsd4_spo_must_allow(struct svc_rqst *rqstp)
2735 {
2736 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
2737 	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
2738 	struct nfsd4_op *this = &argp->ops[resp->opcnt - 1];
2739 	struct nfsd4_compound_state *cstate = &resp->cstate;
2740 	struct nfs4_op_map *allow = &cstate->clp->cl_spo_must_allow;
2741 	u32 opiter;
2742 
2743 	if (!cstate->minorversion)
2744 		return false;
2745 
2746 	if (cstate->spo_must_allowed == true)
2747 		return true;
2748 
2749 	opiter = resp->opcnt;
2750 	while (opiter < argp->opcnt) {
2751 		this = &argp->ops[opiter++];
2752 		if (test_bit(this->opnum, allow->u.longs) &&
2753 			cstate->clp->cl_mach_cred &&
2754 			nfsd4_mach_creds_match(cstate->clp, rqstp)) {
2755 			cstate->spo_must_allowed = true;
2756 			return true;
2757 		}
2758 	}
2759 	cstate->spo_must_allowed = false;
2760 	return false;
2761 }
2762 
2763 int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op)
2764 {
2765 	if (op->opnum == OP_ILLEGAL || op->status == nfserr_notsupp)
2766 		return op_encode_hdr_size * sizeof(__be32);
2767 
2768 	BUG_ON(OPDESC(op)->op_rsize_bop == NULL);
2769 	return OPDESC(op)->op_rsize_bop(rqstp, op);
2770 }
2771 
2772 void warn_on_nonidempotent_op(struct nfsd4_op *op)
2773 {
2774 	if (OPDESC(op)->op_flags & OP_MODIFIES_SOMETHING) {
2775 		pr_err("unable to encode reply to nonidempotent op %d (%s)\n",
2776 			op->opnum, nfsd4_op_name(op->opnum));
2777 		WARN_ON_ONCE(1);
2778 	}
2779 }
2780 
2781 static const char *nfsd4_op_name(unsigned opnum)
2782 {
2783 	if (opnum < ARRAY_SIZE(nfsd4_ops))
2784 		return nfsd4_ops[opnum].op_name;
2785 	return "unknown_operation";
2786 }
2787 
2788 #define nfsd4_voidres			nfsd4_voidargs
2789 struct nfsd4_voidargs { int dummy; };
2790 
2791 static const struct svc_procedure nfsd_procedures4[2] = {
2792 	[NFSPROC4_NULL] = {
2793 		.pc_func = nfsd4_proc_null,
2794 		.pc_encode = nfs4svc_encode_voidres,
2795 		.pc_argsize = sizeof(struct nfsd4_voidargs),
2796 		.pc_ressize = sizeof(struct nfsd4_voidres),
2797 		.pc_cachetype = RC_NOCACHE,
2798 		.pc_xdrressize = 1,
2799 	},
2800 	[NFSPROC4_COMPOUND] = {
2801 		.pc_func = nfsd4_proc_compound,
2802 		.pc_decode = nfs4svc_decode_compoundargs,
2803 		.pc_encode = nfs4svc_encode_compoundres,
2804 		.pc_argsize = sizeof(struct nfsd4_compoundargs),
2805 		.pc_ressize = sizeof(struct nfsd4_compoundres),
2806 		.pc_release = nfsd4_release_compoundargs,
2807 		.pc_cachetype = RC_NOCACHE,
2808 		.pc_xdrressize = NFSD_BUFSIZE/4,
2809 	},
2810 };
2811 
2812 static unsigned int nfsd_count3[ARRAY_SIZE(nfsd_procedures4)];
2813 const struct svc_version nfsd_version4 = {
2814 	.vs_vers		= 4,
2815 	.vs_nproc		= 2,
2816 	.vs_proc		= nfsd_procedures4,
2817 	.vs_count		= nfsd_count3,
2818 	.vs_dispatch		= nfsd_dispatch,
2819 	.vs_xdrsize		= NFS4_SVC_XDRSIZE,
2820 	.vs_rpcb_optnl		= true,
2821 	.vs_need_cong_ctrl	= true,
2822 };
2823 
2824 /*
2825  * Local variables:
2826  *  c-basic-offset: 8
2827  * End:
2828  */
2829