xref: /openbmc/linux/fs/nfsd/nfs4xdr.c (revision 405db98b)
1 /*
2  *  Server-side XDR 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 
36 #include <linux/file.h>
37 #include <linux/slab.h>
38 #include <linux/namei.h>
39 #include <linux/statfs.h>
40 #include <linux/utsname.h>
41 #include <linux/pagemap.h>
42 #include <linux/sunrpc/svcauth_gss.h>
43 #include <linux/sunrpc/addr.h>
44 #include <linux/xattr.h>
45 #include <uapi/linux/xattr.h>
46 
47 #include "idmap.h"
48 #include "acl.h"
49 #include "xdr4.h"
50 #include "vfs.h"
51 #include "state.h"
52 #include "cache.h"
53 #include "netns.h"
54 #include "pnfs.h"
55 #include "filecache.h"
56 
57 #include "trace.h"
58 
59 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
60 #include <linux/security.h>
61 #endif
62 
63 
64 #define NFSDDBG_FACILITY		NFSDDBG_XDR
65 
66 const u32 nfsd_suppattrs[3][3] = {
67 	{NFSD4_SUPPORTED_ATTRS_WORD0,
68 	 NFSD4_SUPPORTED_ATTRS_WORD1,
69 	 NFSD4_SUPPORTED_ATTRS_WORD2},
70 
71 	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
72 	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
73 	 NFSD4_1_SUPPORTED_ATTRS_WORD2},
74 
75 	{NFSD4_1_SUPPORTED_ATTRS_WORD0,
76 	 NFSD4_1_SUPPORTED_ATTRS_WORD1,
77 	 NFSD4_2_SUPPORTED_ATTRS_WORD2},
78 };
79 
80 /*
81  * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
82  * directory in order to indicate to the client that a filesystem boundary is present
83  * We use a fixed fsid for a referral
84  */
85 #define NFS4_REFERRAL_FSID_MAJOR	0x8000000ULL
86 #define NFS4_REFERRAL_FSID_MINOR	0x8000000ULL
87 
88 static __be32
89 check_filename(char *str, int len)
90 {
91 	int i;
92 
93 	if (len == 0)
94 		return nfserr_inval;
95 	if (len > NFS4_MAXNAMLEN)
96 		return nfserr_nametoolong;
97 	if (isdotent(str, len))
98 		return nfserr_badname;
99 	for (i = 0; i < len; i++)
100 		if (str[i] == '/')
101 			return nfserr_badname;
102 	return 0;
103 }
104 
105 static int zero_clientid(clientid_t *clid)
106 {
107 	return (clid->cl_boot == 0) && (clid->cl_id == 0);
108 }
109 
110 /**
111  * svcxdr_tmpalloc - allocate memory to be freed after compound processing
112  * @argp: NFSv4 compound argument structure
113  * @len: length of buffer to allocate
114  *
115  * Allocates a buffer of size @len to be freed when processing the compound
116  * operation described in @argp finishes.
117  */
118 static void *
119 svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len)
120 {
121 	struct svcxdr_tmpbuf *tb;
122 
123 	tb = kmalloc(sizeof(*tb) + len, GFP_KERNEL);
124 	if (!tb)
125 		return NULL;
126 	tb->next = argp->to_free;
127 	argp->to_free = tb;
128 	return tb->buf;
129 }
130 
131 /*
132  * For xdr strings that need to be passed to other kernel api's
133  * as null-terminated strings.
134  *
135  * Note null-terminating in place usually isn't safe since the
136  * buffer might end on a page boundary.
137  */
138 static char *
139 svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)
140 {
141 	char *p = svcxdr_tmpalloc(argp, len + 1);
142 
143 	if (!p)
144 		return NULL;
145 	memcpy(p, buf, len);
146 	p[len] = '\0';
147 	return p;
148 }
149 
150 static void *
151 svcxdr_savemem(struct nfsd4_compoundargs *argp, __be32 *p, u32 len)
152 {
153 	__be32 *tmp;
154 
155 	/*
156 	 * The location of the decoded data item is stable,
157 	 * so @p is OK to use. This is the common case.
158 	 */
159 	if (p != argp->xdr->scratch.iov_base)
160 		return p;
161 
162 	tmp = svcxdr_tmpalloc(argp, len);
163 	if (!tmp)
164 		return NULL;
165 	memcpy(tmp, p, len);
166 	return tmp;
167 }
168 
169 /*
170  * NFSv4 basic data type decoders
171  */
172 
173 /*
174  * This helper handles variable-length opaques which belong to protocol
175  * elements that this implementation does not support.
176  */
177 static __be32
178 nfsd4_decode_ignored_string(struct nfsd4_compoundargs *argp, u32 maxlen)
179 {
180 	u32 len;
181 
182 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)
183 		return nfserr_bad_xdr;
184 	if (maxlen && len > maxlen)
185 		return nfserr_bad_xdr;
186 	if (!xdr_inline_decode(argp->xdr, len))
187 		return nfserr_bad_xdr;
188 
189 	return nfs_ok;
190 }
191 
192 static __be32
193 nfsd4_decode_opaque(struct nfsd4_compoundargs *argp, struct xdr_netobj *o)
194 {
195 	__be32 *p;
196 	u32 len;
197 
198 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)
199 		return nfserr_bad_xdr;
200 	if (len == 0 || len > NFS4_OPAQUE_LIMIT)
201 		return nfserr_bad_xdr;
202 	p = xdr_inline_decode(argp->xdr, len);
203 	if (!p)
204 		return nfserr_bad_xdr;
205 	o->data = svcxdr_savemem(argp, p, len);
206 	if (!o->data)
207 		return nfserr_jukebox;
208 	o->len = len;
209 
210 	return nfs_ok;
211 }
212 
213 static __be32
214 nfsd4_decode_component4(struct nfsd4_compoundargs *argp, char **namp, u32 *lenp)
215 {
216 	__be32 *p, status;
217 
218 	if (xdr_stream_decode_u32(argp->xdr, lenp) < 0)
219 		return nfserr_bad_xdr;
220 	p = xdr_inline_decode(argp->xdr, *lenp);
221 	if (!p)
222 		return nfserr_bad_xdr;
223 	status = check_filename((char *)p, *lenp);
224 	if (status)
225 		return status;
226 	*namp = svcxdr_savemem(argp, p, *lenp);
227 	if (!*namp)
228 		return nfserr_jukebox;
229 
230 	return nfs_ok;
231 }
232 
233 static __be32
234 nfsd4_decode_nfstime4(struct nfsd4_compoundargs *argp, struct timespec64 *tv)
235 {
236 	__be32 *p;
237 
238 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 3);
239 	if (!p)
240 		return nfserr_bad_xdr;
241 	p = xdr_decode_hyper(p, &tv->tv_sec);
242 	tv->tv_nsec = be32_to_cpup(p++);
243 	if (tv->tv_nsec >= (u32)1000000000)
244 		return nfserr_inval;
245 	return nfs_ok;
246 }
247 
248 static __be32
249 nfsd4_decode_verifier4(struct nfsd4_compoundargs *argp, nfs4_verifier *verf)
250 {
251 	__be32 *p;
252 
253 	p = xdr_inline_decode(argp->xdr, NFS4_VERIFIER_SIZE);
254 	if (!p)
255 		return nfserr_bad_xdr;
256 	memcpy(verf->data, p, sizeof(verf->data));
257 	return nfs_ok;
258 }
259 
260 /**
261  * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
262  * @argp: NFSv4 compound argument structure
263  * @bmval: pointer to an array of u32's to decode into
264  * @bmlen: size of the @bmval array
265  *
266  * The server needs to return nfs_ok rather than nfserr_bad_xdr when
267  * encountering bitmaps containing bits it does not recognize. This
268  * includes bits in bitmap words past WORDn, where WORDn is the last
269  * bitmap WORD the implementation currently supports. Thus we are
270  * careful here to simply ignore bits in bitmap words that this
271  * implementation has yet to support explicitly.
272  *
273  * Return values:
274  *   %nfs_ok: @bmval populated successfully
275  *   %nfserr_bad_xdr: the encoded bitmap was invalid
276  */
277 static __be32
278 nfsd4_decode_bitmap4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen)
279 {
280 	u32 i, count;
281 	__be32 *p;
282 
283 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
284 		return nfserr_bad_xdr;
285 	/* request sanity */
286 	if (count > 1000)
287 		return nfserr_bad_xdr;
288 	p = xdr_inline_decode(argp->xdr, count << 2);
289 	if (!p)
290 		return nfserr_bad_xdr;
291 	for (i = 0; i < bmlen; i++)
292 		bmval[i] = (i < count) ? be32_to_cpup(p++) : 0;
293 
294 	return nfs_ok;
295 }
296 
297 static __be32
298 nfsd4_decode_nfsace4(struct nfsd4_compoundargs *argp, struct nfs4_ace *ace)
299 {
300 	__be32 *p, status;
301 	u32 length;
302 
303 	if (xdr_stream_decode_u32(argp->xdr, &ace->type) < 0)
304 		return nfserr_bad_xdr;
305 	if (xdr_stream_decode_u32(argp->xdr, &ace->flag) < 0)
306 		return nfserr_bad_xdr;
307 	if (xdr_stream_decode_u32(argp->xdr, &ace->access_mask) < 0)
308 		return nfserr_bad_xdr;
309 
310 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
311 		return nfserr_bad_xdr;
312 	p = xdr_inline_decode(argp->xdr, length);
313 	if (!p)
314 		return nfserr_bad_xdr;
315 	ace->whotype = nfs4_acl_get_whotype((char *)p, length);
316 	if (ace->whotype != NFS4_ACL_WHO_NAMED)
317 		status = nfs_ok;
318 	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
319 		status = nfsd_map_name_to_gid(argp->rqstp,
320 				(char *)p, length, &ace->who_gid);
321 	else
322 		status = nfsd_map_name_to_uid(argp->rqstp,
323 				(char *)p, length, &ace->who_uid);
324 
325 	return status;
326 }
327 
328 /* A counted array of nfsace4's */
329 static noinline __be32
330 nfsd4_decode_acl(struct nfsd4_compoundargs *argp, struct nfs4_acl **acl)
331 {
332 	struct nfs4_ace *ace;
333 	__be32 status;
334 	u32 count;
335 
336 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
337 		return nfserr_bad_xdr;
338 
339 	if (count > xdr_stream_remaining(argp->xdr) / 20)
340 		/*
341 		 * Even with 4-byte names there wouldn't be
342 		 * space for that many aces; something fishy is
343 		 * going on:
344 		 */
345 		return nfserr_fbig;
346 
347 	*acl = svcxdr_tmpalloc(argp, nfs4_acl_bytes(count));
348 	if (*acl == NULL)
349 		return nfserr_jukebox;
350 
351 	(*acl)->naces = count;
352 	for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) {
353 		status = nfsd4_decode_nfsace4(argp, ace);
354 		if (status)
355 			return status;
356 	}
357 
358 	return nfs_ok;
359 }
360 
361 static noinline __be32
362 nfsd4_decode_security_label(struct nfsd4_compoundargs *argp,
363 			    struct xdr_netobj *label)
364 {
365 	u32 lfs, pi, length;
366 	__be32 *p;
367 
368 	if (xdr_stream_decode_u32(argp->xdr, &lfs) < 0)
369 		return nfserr_bad_xdr;
370 	if (xdr_stream_decode_u32(argp->xdr, &pi) < 0)
371 		return nfserr_bad_xdr;
372 
373 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
374 		return nfserr_bad_xdr;
375 	if (length > NFS4_MAXLABELLEN)
376 		return nfserr_badlabel;
377 	p = xdr_inline_decode(argp->xdr, length);
378 	if (!p)
379 		return nfserr_bad_xdr;
380 	label->len = length;
381 	label->data = svcxdr_dupstr(argp, p, length);
382 	if (!label->data)
383 		return nfserr_jukebox;
384 
385 	return nfs_ok;
386 }
387 
388 static __be32
389 nfsd4_decode_fattr4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen,
390 		    struct iattr *iattr, struct nfs4_acl **acl,
391 		    struct xdr_netobj *label, int *umask)
392 {
393 	unsigned int starting_pos;
394 	u32 attrlist4_count;
395 	__be32 *p, status;
396 
397 	iattr->ia_valid = 0;
398 	status = nfsd4_decode_bitmap4(argp, bmval, bmlen);
399 	if (status)
400 		return nfserr_bad_xdr;
401 
402 	if (bmval[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
403 	    || bmval[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
404 	    || bmval[2] & ~NFSD_WRITEABLE_ATTRS_WORD2) {
405 		if (nfsd_attrs_supported(argp->minorversion, bmval))
406 			return nfserr_inval;
407 		return nfserr_attrnotsupp;
408 	}
409 
410 	if (xdr_stream_decode_u32(argp->xdr, &attrlist4_count) < 0)
411 		return nfserr_bad_xdr;
412 	starting_pos = xdr_stream_pos(argp->xdr);
413 
414 	if (bmval[0] & FATTR4_WORD0_SIZE) {
415 		u64 size;
416 
417 		if (xdr_stream_decode_u64(argp->xdr, &size) < 0)
418 			return nfserr_bad_xdr;
419 		iattr->ia_size = size;
420 		iattr->ia_valid |= ATTR_SIZE;
421 	}
422 	if (bmval[0] & FATTR4_WORD0_ACL) {
423 		status = nfsd4_decode_acl(argp, acl);
424 		if (status)
425 			return status;
426 	} else
427 		*acl = NULL;
428 	if (bmval[1] & FATTR4_WORD1_MODE) {
429 		u32 mode;
430 
431 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)
432 			return nfserr_bad_xdr;
433 		iattr->ia_mode = mode;
434 		iattr->ia_mode &= (S_IFMT | S_IALLUGO);
435 		iattr->ia_valid |= ATTR_MODE;
436 	}
437 	if (bmval[1] & FATTR4_WORD1_OWNER) {
438 		u32 length;
439 
440 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
441 			return nfserr_bad_xdr;
442 		p = xdr_inline_decode(argp->xdr, length);
443 		if (!p)
444 			return nfserr_bad_xdr;
445 		status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length,
446 					      &iattr->ia_uid);
447 		if (status)
448 			return status;
449 		iattr->ia_valid |= ATTR_UID;
450 	}
451 	if (bmval[1] & FATTR4_WORD1_OWNER_GROUP) {
452 		u32 length;
453 
454 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)
455 			return nfserr_bad_xdr;
456 		p = xdr_inline_decode(argp->xdr, length);
457 		if (!p)
458 			return nfserr_bad_xdr;
459 		status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length,
460 					      &iattr->ia_gid);
461 		if (status)
462 			return status;
463 		iattr->ia_valid |= ATTR_GID;
464 	}
465 	if (bmval[1] & FATTR4_WORD1_TIME_ACCESS_SET) {
466 		u32 set_it;
467 
468 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)
469 			return nfserr_bad_xdr;
470 		switch (set_it) {
471 		case NFS4_SET_TO_CLIENT_TIME:
472 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_atime);
473 			if (status)
474 				return status;
475 			iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);
476 			break;
477 		case NFS4_SET_TO_SERVER_TIME:
478 			iattr->ia_valid |= ATTR_ATIME;
479 			break;
480 		default:
481 			return nfserr_bad_xdr;
482 		}
483 	}
484 	if (bmval[1] & FATTR4_WORD1_TIME_MODIFY_SET) {
485 		u32 set_it;
486 
487 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)
488 			return nfserr_bad_xdr;
489 		switch (set_it) {
490 		case NFS4_SET_TO_CLIENT_TIME:
491 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_mtime);
492 			if (status)
493 				return status;
494 			iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);
495 			break;
496 		case NFS4_SET_TO_SERVER_TIME:
497 			iattr->ia_valid |= ATTR_MTIME;
498 			break;
499 		default:
500 			return nfserr_bad_xdr;
501 		}
502 	}
503 	label->len = 0;
504 	if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL) &&
505 	    bmval[2] & FATTR4_WORD2_SECURITY_LABEL) {
506 		status = nfsd4_decode_security_label(argp, label);
507 		if (status)
508 			return status;
509 	}
510 	if (bmval[2] & FATTR4_WORD2_MODE_UMASK) {
511 		u32 mode, mask;
512 
513 		if (!umask)
514 			return nfserr_bad_xdr;
515 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)
516 			return nfserr_bad_xdr;
517 		iattr->ia_mode = mode & (S_IFMT | S_IALLUGO);
518 		if (xdr_stream_decode_u32(argp->xdr, &mask) < 0)
519 			return nfserr_bad_xdr;
520 		*umask = mask & S_IRWXUGO;
521 		iattr->ia_valid |= ATTR_MODE;
522 	}
523 
524 	/* request sanity: did attrlist4 contain the expected number of words? */
525 	if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos)
526 		return nfserr_bad_xdr;
527 
528 	return nfs_ok;
529 }
530 
531 static __be32
532 nfsd4_decode_stateid4(struct nfsd4_compoundargs *argp, stateid_t *sid)
533 {
534 	__be32 *p;
535 
536 	p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE);
537 	if (!p)
538 		return nfserr_bad_xdr;
539 	sid->si_generation = be32_to_cpup(p++);
540 	memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque));
541 	return nfs_ok;
542 }
543 
544 static __be32
545 nfsd4_decode_clientid4(struct nfsd4_compoundargs *argp, clientid_t *clientid)
546 {
547 	__be32 *p;
548 
549 	p = xdr_inline_decode(argp->xdr, sizeof(__be64));
550 	if (!p)
551 		return nfserr_bad_xdr;
552 	memcpy(clientid, p, sizeof(*clientid));
553 	return nfs_ok;
554 }
555 
556 static __be32
557 nfsd4_decode_state_owner4(struct nfsd4_compoundargs *argp,
558 			  clientid_t *clientid, struct xdr_netobj *owner)
559 {
560 	__be32 status;
561 
562 	status = nfsd4_decode_clientid4(argp, clientid);
563 	if (status)
564 		return status;
565 	return nfsd4_decode_opaque(argp, owner);
566 }
567 
568 #ifdef CONFIG_NFSD_PNFS
569 static __be32
570 nfsd4_decode_deviceid4(struct nfsd4_compoundargs *argp,
571 		       struct nfsd4_deviceid *devid)
572 {
573 	__be32 *p;
574 
575 	p = xdr_inline_decode(argp->xdr, NFS4_DEVICEID4_SIZE);
576 	if (!p)
577 		return nfserr_bad_xdr;
578 	memcpy(devid, p, sizeof(*devid));
579 	return nfs_ok;
580 }
581 
582 static __be32
583 nfsd4_decode_layoutupdate4(struct nfsd4_compoundargs *argp,
584 			   struct nfsd4_layoutcommit *lcp)
585 {
586 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0)
587 		return nfserr_bad_xdr;
588 	if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES)
589 		return nfserr_bad_xdr;
590 	if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX)
591 		return nfserr_bad_xdr;
592 
593 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_up_len) < 0)
594 		return nfserr_bad_xdr;
595 	if (lcp->lc_up_len > 0) {
596 		lcp->lc_up_layout = xdr_inline_decode(argp->xdr, lcp->lc_up_len);
597 		if (!lcp->lc_up_layout)
598 			return nfserr_bad_xdr;
599 	}
600 
601 	return nfs_ok;
602 }
603 
604 static __be32
605 nfsd4_decode_layoutreturn4(struct nfsd4_compoundargs *argp,
606 			   struct nfsd4_layoutreturn *lrp)
607 {
608 	__be32 status;
609 
610 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0)
611 		return nfserr_bad_xdr;
612 	switch (lrp->lr_return_type) {
613 	case RETURN_FILE:
614 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0)
615 			return nfserr_bad_xdr;
616 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0)
617 			return nfserr_bad_xdr;
618 		status = nfsd4_decode_stateid4(argp, &lrp->lr_sid);
619 		if (status)
620 			return status;
621 		if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0)
622 			return nfserr_bad_xdr;
623 		if (lrp->lrf_body_len > 0) {
624 			lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len);
625 			if (!lrp->lrf_body)
626 				return nfserr_bad_xdr;
627 		}
628 		break;
629 	case RETURN_FSID:
630 	case RETURN_ALL:
631 		lrp->lr_seg.offset = 0;
632 		lrp->lr_seg.length = NFS4_MAX_UINT64;
633 		break;
634 	default:
635 		return nfserr_bad_xdr;
636 	}
637 
638 	return nfs_ok;
639 }
640 
641 #endif /* CONFIG_NFSD_PNFS */
642 
643 static __be32
644 nfsd4_decode_sessionid4(struct nfsd4_compoundargs *argp,
645 			struct nfs4_sessionid *sessionid)
646 {
647 	__be32 *p;
648 
649 	p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN);
650 	if (!p)
651 		return nfserr_bad_xdr;
652 	memcpy(sessionid->data, p, sizeof(sessionid->data));
653 	return nfs_ok;
654 }
655 
656 /* Defined in Appendix A of RFC 5531 */
657 static __be32
658 nfsd4_decode_authsys_parms(struct nfsd4_compoundargs *argp,
659 			   struct nfsd4_cb_sec *cbs)
660 {
661 	u32 stamp, gidcount, uid, gid;
662 	__be32 *p, status;
663 
664 	if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0)
665 		return nfserr_bad_xdr;
666 	/* machine name */
667 	status = nfsd4_decode_ignored_string(argp, 255);
668 	if (status)
669 		return status;
670 	if (xdr_stream_decode_u32(argp->xdr, &uid) < 0)
671 		return nfserr_bad_xdr;
672 	if (xdr_stream_decode_u32(argp->xdr, &gid) < 0)
673 		return nfserr_bad_xdr;
674 	if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0)
675 		return nfserr_bad_xdr;
676 	if (gidcount > 16)
677 		return nfserr_bad_xdr;
678 	p = xdr_inline_decode(argp->xdr, gidcount << 2);
679 	if (!p)
680 		return nfserr_bad_xdr;
681 	if (cbs->flavor == (u32)(-1)) {
682 		struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);
683 
684 		kuid_t kuid = make_kuid(userns, uid);
685 		kgid_t kgid = make_kgid(userns, gid);
686 		if (uid_valid(kuid) && gid_valid(kgid)) {
687 			cbs->uid = kuid;
688 			cbs->gid = kgid;
689 			cbs->flavor = RPC_AUTH_UNIX;
690 		} else {
691 			dprintk("RPC_AUTH_UNIX with invalid uid or gid, ignoring!\n");
692 		}
693 	}
694 
695 	return nfs_ok;
696 }
697 
698 static __be32
699 nfsd4_decode_gss_cb_handles4(struct nfsd4_compoundargs *argp,
700 			     struct nfsd4_cb_sec *cbs)
701 {
702 	__be32 status;
703 	u32 service;
704 
705 	dprintk("RPC_AUTH_GSS callback secflavor not supported!\n");
706 
707 	if (xdr_stream_decode_u32(argp->xdr, &service) < 0)
708 		return nfserr_bad_xdr;
709 	if (service < RPC_GSS_SVC_NONE || service > RPC_GSS_SVC_PRIVACY)
710 		return nfserr_bad_xdr;
711 	/* gcbp_handle_from_server */
712 	status = nfsd4_decode_ignored_string(argp, 0);
713 	if (status)
714 		return status;
715 	/* gcbp_handle_from_client */
716 	status = nfsd4_decode_ignored_string(argp, 0);
717 	if (status)
718 		return status;
719 
720 	return nfs_ok;
721 }
722 
723 /* a counted array of callback_sec_parms4 items */
724 static __be32
725 nfsd4_decode_cb_sec(struct nfsd4_compoundargs *argp, struct nfsd4_cb_sec *cbs)
726 {
727 	u32 i, secflavor, nr_secflavs;
728 	__be32 status;
729 
730 	/* callback_sec_params4 */
731 	if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0)
732 		return nfserr_bad_xdr;
733 	if (nr_secflavs)
734 		cbs->flavor = (u32)(-1);
735 	else
736 		/* Is this legal? Be generous, take it to mean AUTH_NONE: */
737 		cbs->flavor = 0;
738 
739 	for (i = 0; i < nr_secflavs; ++i) {
740 		if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0)
741 			return nfserr_bad_xdr;
742 		switch (secflavor) {
743 		case RPC_AUTH_NULL:
744 			/* void */
745 			if (cbs->flavor == (u32)(-1))
746 				cbs->flavor = RPC_AUTH_NULL;
747 			break;
748 		case RPC_AUTH_UNIX:
749 			status = nfsd4_decode_authsys_parms(argp, cbs);
750 			if (status)
751 				return status;
752 			break;
753 		case RPC_AUTH_GSS:
754 			status = nfsd4_decode_gss_cb_handles4(argp, cbs);
755 			if (status)
756 				return status;
757 			break;
758 		default:
759 			return nfserr_inval;
760 		}
761 	}
762 
763 	return nfs_ok;
764 }
765 
766 
767 /*
768  * NFSv4 operation argument decoders
769  */
770 
771 static __be32
772 nfsd4_decode_access(struct nfsd4_compoundargs *argp,
773 		    struct nfsd4_access *access)
774 {
775 	if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0)
776 		return nfserr_bad_xdr;
777 	return nfs_ok;
778 }
779 
780 static __be32
781 nfsd4_decode_close(struct nfsd4_compoundargs *argp, struct nfsd4_close *close)
782 {
783 	if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0)
784 		return nfserr_bad_xdr;
785 	return nfsd4_decode_stateid4(argp, &close->cl_stateid);
786 }
787 
788 
789 static __be32
790 nfsd4_decode_commit(struct nfsd4_compoundargs *argp, struct nfsd4_commit *commit)
791 {
792 	if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0)
793 		return nfserr_bad_xdr;
794 	if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0)
795 		return nfserr_bad_xdr;
796 	return nfs_ok;
797 }
798 
799 static __be32
800 nfsd4_decode_create(struct nfsd4_compoundargs *argp, struct nfsd4_create *create)
801 {
802 	__be32 *p, status;
803 
804 	if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0)
805 		return nfserr_bad_xdr;
806 	switch (create->cr_type) {
807 	case NF4LNK:
808 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0)
809 			return nfserr_bad_xdr;
810 		p = xdr_inline_decode(argp->xdr, create->cr_datalen);
811 		if (!p)
812 			return nfserr_bad_xdr;
813 		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);
814 		if (!create->cr_data)
815 			return nfserr_jukebox;
816 		break;
817 	case NF4BLK:
818 	case NF4CHR:
819 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0)
820 			return nfserr_bad_xdr;
821 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0)
822 			return nfserr_bad_xdr;
823 		break;
824 	case NF4SOCK:
825 	case NF4FIFO:
826 	case NF4DIR:
827 	default:
828 		break;
829 	}
830 	status = nfsd4_decode_component4(argp, &create->cr_name,
831 					 &create->cr_namelen);
832 	if (status)
833 		return status;
834 	status = nfsd4_decode_fattr4(argp, create->cr_bmval,
835 				    ARRAY_SIZE(create->cr_bmval),
836 				    &create->cr_iattr, &create->cr_acl,
837 				    &create->cr_label, &create->cr_umask);
838 	if (status)
839 		return status;
840 
841 	return nfs_ok;
842 }
843 
844 static inline __be32
845 nfsd4_decode_delegreturn(struct nfsd4_compoundargs *argp, struct nfsd4_delegreturn *dr)
846 {
847 	return nfsd4_decode_stateid4(argp, &dr->dr_stateid);
848 }
849 
850 static inline __be32
851 nfsd4_decode_getattr(struct nfsd4_compoundargs *argp, struct nfsd4_getattr *getattr)
852 {
853 	return nfsd4_decode_bitmap4(argp, getattr->ga_bmval,
854 				    ARRAY_SIZE(getattr->ga_bmval));
855 }
856 
857 static __be32
858 nfsd4_decode_link(struct nfsd4_compoundargs *argp, struct nfsd4_link *link)
859 {
860 	return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen);
861 }
862 
863 static __be32
864 nfsd4_decode_open_to_lock_owner4(struct nfsd4_compoundargs *argp,
865 				 struct nfsd4_lock *lock)
866 {
867 	__be32 status;
868 
869 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0)
870 		return nfserr_bad_xdr;
871 	status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid);
872 	if (status)
873 		return status;
874 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0)
875 		return nfserr_bad_xdr;
876 	return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid,
877 					 &lock->lk_new_owner);
878 }
879 
880 static __be32
881 nfsd4_decode_exist_lock_owner4(struct nfsd4_compoundargs *argp,
882 			       struct nfsd4_lock *lock)
883 {
884 	__be32 status;
885 
886 	status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid);
887 	if (status)
888 		return status;
889 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0)
890 		return nfserr_bad_xdr;
891 
892 	return nfs_ok;
893 }
894 
895 static __be32
896 nfsd4_decode_locker4(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
897 {
898 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0)
899 		return nfserr_bad_xdr;
900 	if (lock->lk_is_new)
901 		return nfsd4_decode_open_to_lock_owner4(argp, lock);
902 	return nfsd4_decode_exist_lock_owner4(argp, lock);
903 }
904 
905 static __be32
906 nfsd4_decode_lock(struct nfsd4_compoundargs *argp, struct nfsd4_lock *lock)
907 {
908 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0)
909 		return nfserr_bad_xdr;
910 	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))
911 		return nfserr_bad_xdr;
912 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0)
913 		return nfserr_bad_xdr;
914 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0)
915 		return nfserr_bad_xdr;
916 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0)
917 		return nfserr_bad_xdr;
918 	return nfsd4_decode_locker4(argp, lock);
919 }
920 
921 static __be32
922 nfsd4_decode_lockt(struct nfsd4_compoundargs *argp, struct nfsd4_lockt *lockt)
923 {
924 	if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0)
925 		return nfserr_bad_xdr;
926 	if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))
927 		return nfserr_bad_xdr;
928 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0)
929 		return nfserr_bad_xdr;
930 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0)
931 		return nfserr_bad_xdr;
932 	return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid,
933 					 &lockt->lt_owner);
934 }
935 
936 static __be32
937 nfsd4_decode_locku(struct nfsd4_compoundargs *argp, struct nfsd4_locku *locku)
938 {
939 	__be32 status;
940 
941 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0)
942 		return nfserr_bad_xdr;
943 	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))
944 		return nfserr_bad_xdr;
945 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0)
946 		return nfserr_bad_xdr;
947 	status = nfsd4_decode_stateid4(argp, &locku->lu_stateid);
948 	if (status)
949 		return status;
950 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0)
951 		return nfserr_bad_xdr;
952 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0)
953 		return nfserr_bad_xdr;
954 
955 	return nfs_ok;
956 }
957 
958 static __be32
959 nfsd4_decode_lookup(struct nfsd4_compoundargs *argp, struct nfsd4_lookup *lookup)
960 {
961 	return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len);
962 }
963 
964 static __be32
965 nfsd4_decode_createhow4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
966 {
967 	__be32 status;
968 
969 	if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0)
970 		return nfserr_bad_xdr;
971 	switch (open->op_createmode) {
972 	case NFS4_CREATE_UNCHECKED:
973 	case NFS4_CREATE_GUARDED:
974 		status = nfsd4_decode_fattr4(argp, open->op_bmval,
975 					     ARRAY_SIZE(open->op_bmval),
976 					     &open->op_iattr, &open->op_acl,
977 					     &open->op_label, &open->op_umask);
978 		if (status)
979 			return status;
980 		break;
981 	case NFS4_CREATE_EXCLUSIVE:
982 		status = nfsd4_decode_verifier4(argp, &open->op_verf);
983 		if (status)
984 			return status;
985 		break;
986 	case NFS4_CREATE_EXCLUSIVE4_1:
987 		if (argp->minorversion < 1)
988 			return nfserr_bad_xdr;
989 		status = nfsd4_decode_verifier4(argp, &open->op_verf);
990 		if (status)
991 			return status;
992 		status = nfsd4_decode_fattr4(argp, open->op_bmval,
993 					     ARRAY_SIZE(open->op_bmval),
994 					     &open->op_iattr, &open->op_acl,
995 					     &open->op_label, &open->op_umask);
996 		if (status)
997 			return status;
998 		break;
999 	default:
1000 		return nfserr_bad_xdr;
1001 	}
1002 
1003 	return nfs_ok;
1004 }
1005 
1006 static __be32
1007 nfsd4_decode_openflag4(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
1008 {
1009 	__be32 status;
1010 
1011 	if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0)
1012 		return nfserr_bad_xdr;
1013 	switch (open->op_create) {
1014 	case NFS4_OPEN_NOCREATE:
1015 		break;
1016 	case NFS4_OPEN_CREATE:
1017 		status = nfsd4_decode_createhow4(argp, open);
1018 		if (status)
1019 			return status;
1020 		break;
1021 	default:
1022 		return nfserr_bad_xdr;
1023 	}
1024 
1025 	return nfs_ok;
1026 }
1027 
1028 static __be32 nfsd4_decode_share_access(struct nfsd4_compoundargs *argp, u32 *share_access, u32 *deleg_want, u32 *deleg_when)
1029 {
1030 	u32 w;
1031 
1032 	if (xdr_stream_decode_u32(argp->xdr, &w) < 0)
1033 		return nfserr_bad_xdr;
1034 	*share_access = w & NFS4_SHARE_ACCESS_MASK;
1035 	*deleg_want = w & NFS4_SHARE_WANT_MASK;
1036 	if (deleg_when)
1037 		*deleg_when = w & NFS4_SHARE_WHEN_MASK;
1038 
1039 	switch (w & NFS4_SHARE_ACCESS_MASK) {
1040 	case NFS4_SHARE_ACCESS_READ:
1041 	case NFS4_SHARE_ACCESS_WRITE:
1042 	case NFS4_SHARE_ACCESS_BOTH:
1043 		break;
1044 	default:
1045 		return nfserr_bad_xdr;
1046 	}
1047 	w &= ~NFS4_SHARE_ACCESS_MASK;
1048 	if (!w)
1049 		return nfs_ok;
1050 	if (!argp->minorversion)
1051 		return nfserr_bad_xdr;
1052 	switch (w & NFS4_SHARE_WANT_MASK) {
1053 	case NFS4_SHARE_WANT_NO_PREFERENCE:
1054 	case NFS4_SHARE_WANT_READ_DELEG:
1055 	case NFS4_SHARE_WANT_WRITE_DELEG:
1056 	case NFS4_SHARE_WANT_ANY_DELEG:
1057 	case NFS4_SHARE_WANT_NO_DELEG:
1058 	case NFS4_SHARE_WANT_CANCEL:
1059 		break;
1060 	default:
1061 		return nfserr_bad_xdr;
1062 	}
1063 	w &= ~NFS4_SHARE_WANT_MASK;
1064 	if (!w)
1065 		return nfs_ok;
1066 
1067 	if (!deleg_when)	/* open_downgrade */
1068 		return nfserr_inval;
1069 	switch (w) {
1070 	case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL:
1071 	case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED:
1072 	case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL |
1073 	      NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED):
1074 		return nfs_ok;
1075 	}
1076 	return nfserr_bad_xdr;
1077 }
1078 
1079 static __be32 nfsd4_decode_share_deny(struct nfsd4_compoundargs *argp, u32 *x)
1080 {
1081 	if (xdr_stream_decode_u32(argp->xdr, x) < 0)
1082 		return nfserr_bad_xdr;
1083 	/* Note: unlike access bits, deny bits may be zero. */
1084 	if (*x & ~NFS4_SHARE_DENY_BOTH)
1085 		return nfserr_bad_xdr;
1086 
1087 	return nfs_ok;
1088 }
1089 
1090 static __be32
1091 nfsd4_decode_open_claim4(struct nfsd4_compoundargs *argp,
1092 			 struct nfsd4_open *open)
1093 {
1094 	__be32 status;
1095 
1096 	if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0)
1097 		return nfserr_bad_xdr;
1098 	switch (open->op_claim_type) {
1099 	case NFS4_OPEN_CLAIM_NULL:
1100 	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
1101 		status = nfsd4_decode_component4(argp, &open->op_fname,
1102 						 &open->op_fnamelen);
1103 		if (status)
1104 			return status;
1105 		break;
1106 	case NFS4_OPEN_CLAIM_PREVIOUS:
1107 		if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0)
1108 			return nfserr_bad_xdr;
1109 		break;
1110 	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
1111 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);
1112 		if (status)
1113 			return status;
1114 		status = nfsd4_decode_component4(argp, &open->op_fname,
1115 						 &open->op_fnamelen);
1116 		if (status)
1117 			return status;
1118 		break;
1119 	case NFS4_OPEN_CLAIM_FH:
1120 	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1121 		if (argp->minorversion < 1)
1122 			return nfserr_bad_xdr;
1123 		/* void */
1124 		break;
1125 	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
1126 		if (argp->minorversion < 1)
1127 			return nfserr_bad_xdr;
1128 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);
1129 		if (status)
1130 			return status;
1131 		break;
1132 	default:
1133 		return nfserr_bad_xdr;
1134 	}
1135 
1136 	return nfs_ok;
1137 }
1138 
1139 static __be32
1140 nfsd4_decode_open(struct nfsd4_compoundargs *argp, struct nfsd4_open *open)
1141 {
1142 	__be32 status;
1143 	u32 dummy;
1144 
1145 	memset(open->op_bmval, 0, sizeof(open->op_bmval));
1146 	open->op_iattr.ia_valid = 0;
1147 	open->op_openowner = NULL;
1148 
1149 	open->op_xdr_error = 0;
1150 	if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0)
1151 		return nfserr_bad_xdr;
1152 	/* deleg_want is ignored */
1153 	status = nfsd4_decode_share_access(argp, &open->op_share_access,
1154 					   &open->op_deleg_want, &dummy);
1155 	if (status)
1156 		return status;
1157 	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);
1158 	if (status)
1159 		return status;
1160 	status = nfsd4_decode_state_owner4(argp, &open->op_clientid,
1161 					   &open->op_owner);
1162 	if (status)
1163 		return status;
1164 	status = nfsd4_decode_openflag4(argp, open);
1165 	if (status)
1166 		return status;
1167 	return nfsd4_decode_open_claim4(argp, open);
1168 }
1169 
1170 static __be32
1171 nfsd4_decode_open_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_open_confirm *open_conf)
1172 {
1173 	__be32 status;
1174 
1175 	if (argp->minorversion >= 1)
1176 		return nfserr_notsupp;
1177 
1178 	status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid);
1179 	if (status)
1180 		return status;
1181 	if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0)
1182 		return nfserr_bad_xdr;
1183 
1184 	return nfs_ok;
1185 }
1186 
1187 static __be32
1188 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs *argp, struct nfsd4_open_downgrade *open_down)
1189 {
1190 	__be32 status;
1191 
1192 	status = nfsd4_decode_stateid4(argp, &open_down->od_stateid);
1193 	if (status)
1194 		return status;
1195 	if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0)
1196 		return nfserr_bad_xdr;
1197 	/* deleg_want is ignored */
1198 	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,
1199 					   &open_down->od_deleg_want, NULL);
1200 	if (status)
1201 		return status;
1202 	return nfsd4_decode_share_deny(argp, &open_down->od_share_deny);
1203 }
1204 
1205 static __be32
1206 nfsd4_decode_putfh(struct nfsd4_compoundargs *argp, struct nfsd4_putfh *putfh)
1207 {
1208 	__be32 *p;
1209 
1210 	if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0)
1211 		return nfserr_bad_xdr;
1212 	if (putfh->pf_fhlen > NFS4_FHSIZE)
1213 		return nfserr_bad_xdr;
1214 	p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen);
1215 	if (!p)
1216 		return nfserr_bad_xdr;
1217 	putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen);
1218 	if (!putfh->pf_fhval)
1219 		return nfserr_jukebox;
1220 
1221 	return nfs_ok;
1222 }
1223 
1224 static __be32
1225 nfsd4_decode_putpubfh(struct nfsd4_compoundargs *argp, void *p)
1226 {
1227 	if (argp->minorversion == 0)
1228 		return nfs_ok;
1229 	return nfserr_notsupp;
1230 }
1231 
1232 static __be32
1233 nfsd4_decode_read(struct nfsd4_compoundargs *argp, struct nfsd4_read *read)
1234 {
1235 	__be32 status;
1236 
1237 	status = nfsd4_decode_stateid4(argp, &read->rd_stateid);
1238 	if (status)
1239 		return status;
1240 	if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0)
1241 		return nfserr_bad_xdr;
1242 	if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0)
1243 		return nfserr_bad_xdr;
1244 
1245 	return nfs_ok;
1246 }
1247 
1248 static __be32
1249 nfsd4_decode_readdir(struct nfsd4_compoundargs *argp, struct nfsd4_readdir *readdir)
1250 {
1251 	__be32 status;
1252 
1253 	if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0)
1254 		return nfserr_bad_xdr;
1255 	status = nfsd4_decode_verifier4(argp, &readdir->rd_verf);
1256 	if (status)
1257 		return status;
1258 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0)
1259 		return nfserr_bad_xdr;
1260 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0)
1261 		return nfserr_bad_xdr;
1262 	if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval,
1263 					   ARRAY_SIZE(readdir->rd_bmval)) < 0)
1264 		return nfserr_bad_xdr;
1265 
1266 	return nfs_ok;
1267 }
1268 
1269 static __be32
1270 nfsd4_decode_remove(struct nfsd4_compoundargs *argp, struct nfsd4_remove *remove)
1271 {
1272 	return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen);
1273 }
1274 
1275 static __be32
1276 nfsd4_decode_rename(struct nfsd4_compoundargs *argp, struct nfsd4_rename *rename)
1277 {
1278 	__be32 status;
1279 
1280 	status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen);
1281 	if (status)
1282 		return status;
1283 	return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen);
1284 }
1285 
1286 static __be32
1287 nfsd4_decode_renew(struct nfsd4_compoundargs *argp, clientid_t *clientid)
1288 {
1289 	return nfsd4_decode_clientid4(argp, clientid);
1290 }
1291 
1292 static __be32
1293 nfsd4_decode_secinfo(struct nfsd4_compoundargs *argp,
1294 		     struct nfsd4_secinfo *secinfo)
1295 {
1296 	return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen);
1297 }
1298 
1299 static __be32
1300 nfsd4_decode_setattr(struct nfsd4_compoundargs *argp, struct nfsd4_setattr *setattr)
1301 {
1302 	__be32 status;
1303 
1304 	status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid);
1305 	if (status)
1306 		return status;
1307 	return nfsd4_decode_fattr4(argp, setattr->sa_bmval,
1308 				   ARRAY_SIZE(setattr->sa_bmval),
1309 				   &setattr->sa_iattr, &setattr->sa_acl,
1310 				   &setattr->sa_label, NULL);
1311 }
1312 
1313 static __be32
1314 nfsd4_decode_setclientid(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid *setclientid)
1315 {
1316 	__be32 *p, status;
1317 
1318 	if (argp->minorversion >= 1)
1319 		return nfserr_notsupp;
1320 
1321 	status = nfsd4_decode_verifier4(argp, &setclientid->se_verf);
1322 	if (status)
1323 		return status;
1324 	status = nfsd4_decode_opaque(argp, &setclientid->se_name);
1325 	if (status)
1326 		return status;
1327 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0)
1328 		return nfserr_bad_xdr;
1329 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0)
1330 		return nfserr_bad_xdr;
1331 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len);
1332 	if (!p)
1333 		return nfserr_bad_xdr;
1334 	setclientid->se_callback_netid_val = svcxdr_savemem(argp, p,
1335 						setclientid->se_callback_netid_len);
1336 	if (!setclientid->se_callback_netid_val)
1337 		return nfserr_jukebox;
1338 
1339 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0)
1340 		return nfserr_bad_xdr;
1341 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len);
1342 	if (!p)
1343 		return nfserr_bad_xdr;
1344 	setclientid->se_callback_addr_val = svcxdr_savemem(argp, p,
1345 						setclientid->se_callback_addr_len);
1346 	if (!setclientid->se_callback_addr_val)
1347 		return nfserr_jukebox;
1348 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0)
1349 		return nfserr_bad_xdr;
1350 
1351 	return nfs_ok;
1352 }
1353 
1354 static __be32
1355 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs *argp, struct nfsd4_setclientid_confirm *scd_c)
1356 {
1357 	__be32 status;
1358 
1359 	if (argp->minorversion >= 1)
1360 		return nfserr_notsupp;
1361 
1362 	status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid);
1363 	if (status)
1364 		return status;
1365 	return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm);
1366 }
1367 
1368 /* Also used for NVERIFY */
1369 static __be32
1370 nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verify)
1371 {
1372 	__be32 *p, status;
1373 
1374 	status = nfsd4_decode_bitmap4(argp, verify->ve_bmval,
1375 				      ARRAY_SIZE(verify->ve_bmval));
1376 	if (status)
1377 		return status;
1378 
1379 	/* For convenience's sake, we compare raw xdr'd attributes in
1380 	 * nfsd4_proc_verify */
1381 
1382 	if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0)
1383 		return nfserr_bad_xdr;
1384 	p = xdr_inline_decode(argp->xdr, verify->ve_attrlen);
1385 	if (!p)
1386 		return nfserr_bad_xdr;
1387 	verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen);
1388 	if (!verify->ve_attrval)
1389 		return nfserr_jukebox;
1390 
1391 	return nfs_ok;
1392 }
1393 
1394 static __be32
1395 nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write)
1396 {
1397 	__be32 status;
1398 
1399 	status = nfsd4_decode_stateid4(argp, &write->wr_stateid);
1400 	if (status)
1401 		return status;
1402 	if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0)
1403 		return nfserr_bad_xdr;
1404 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0)
1405 		return nfserr_bad_xdr;
1406 	if (write->wr_stable_how > NFS_FILE_SYNC)
1407 		return nfserr_bad_xdr;
1408 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0)
1409 		return nfserr_bad_xdr;
1410 	if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen))
1411 		return nfserr_bad_xdr;
1412 
1413 	return nfs_ok;
1414 }
1415 
1416 static __be32
1417 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs *argp, struct nfsd4_release_lockowner *rlockowner)
1418 {
1419 	__be32 status;
1420 
1421 	if (argp->minorversion >= 1)
1422 		return nfserr_notsupp;
1423 
1424 	status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid,
1425 					   &rlockowner->rl_owner);
1426 	if (status)
1427 		return status;
1428 
1429 	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))
1430 		return nfserr_inval;
1431 
1432 	return nfs_ok;
1433 }
1434 
1435 static __be32 nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs *argp, struct nfsd4_backchannel_ctl *bc)
1436 {
1437 	if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0)
1438 		return nfserr_bad_xdr;
1439 	return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);
1440 }
1441 
1442 static __be32 nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs *argp, struct nfsd4_bind_conn_to_session *bcts)
1443 {
1444 	u32 use_conn_in_rdma_mode;
1445 	__be32 status;
1446 
1447 	status = nfsd4_decode_sessionid4(argp, &bcts->sessionid);
1448 	if (status)
1449 		return status;
1450 	if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0)
1451 		return nfserr_bad_xdr;
1452 	if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0)
1453 		return nfserr_bad_xdr;
1454 
1455 	return nfs_ok;
1456 }
1457 
1458 static __be32
1459 nfsd4_decode_state_protect_ops(struct nfsd4_compoundargs *argp,
1460 			       struct nfsd4_exchange_id *exid)
1461 {
1462 	__be32 status;
1463 
1464 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce,
1465 				      ARRAY_SIZE(exid->spo_must_enforce));
1466 	if (status)
1467 		return nfserr_bad_xdr;
1468 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow,
1469 				      ARRAY_SIZE(exid->spo_must_allow));
1470 	if (status)
1471 		return nfserr_bad_xdr;
1472 
1473 	return nfs_ok;
1474 }
1475 
1476 /*
1477  * This implementation currently does not support SP4_SSV.
1478  * This decoder simply skips over these arguments.
1479  */
1480 static noinline __be32
1481 nfsd4_decode_ssv_sp_parms(struct nfsd4_compoundargs *argp,
1482 			  struct nfsd4_exchange_id *exid)
1483 {
1484 	u32 count, window, num_gss_handles;
1485 	__be32 status;
1486 
1487 	/* ssp_ops */
1488 	status = nfsd4_decode_state_protect_ops(argp, exid);
1489 	if (status)
1490 		return status;
1491 
1492 	/* ssp_hash_algs<> */
1493 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1494 		return nfserr_bad_xdr;
1495 	while (count--) {
1496 		status = nfsd4_decode_ignored_string(argp, 0);
1497 		if (status)
1498 			return status;
1499 	}
1500 
1501 	/* ssp_encr_algs<> */
1502 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1503 		return nfserr_bad_xdr;
1504 	while (count--) {
1505 		status = nfsd4_decode_ignored_string(argp, 0);
1506 		if (status)
1507 			return status;
1508 	}
1509 
1510 	if (xdr_stream_decode_u32(argp->xdr, &window) < 0)
1511 		return nfserr_bad_xdr;
1512 	if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0)
1513 		return nfserr_bad_xdr;
1514 
1515 	return nfs_ok;
1516 }
1517 
1518 static __be32
1519 nfsd4_decode_state_protect4_a(struct nfsd4_compoundargs *argp,
1520 			      struct nfsd4_exchange_id *exid)
1521 {
1522 	__be32 status;
1523 
1524 	if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0)
1525 		return nfserr_bad_xdr;
1526 	switch (exid->spa_how) {
1527 	case SP4_NONE:
1528 		break;
1529 	case SP4_MACH_CRED:
1530 		status = nfsd4_decode_state_protect_ops(argp, exid);
1531 		if (status)
1532 			return status;
1533 		break;
1534 	case SP4_SSV:
1535 		status = nfsd4_decode_ssv_sp_parms(argp, exid);
1536 		if (status)
1537 			return status;
1538 		break;
1539 	default:
1540 		return nfserr_bad_xdr;
1541 	}
1542 
1543 	return nfs_ok;
1544 }
1545 
1546 static __be32
1547 nfsd4_decode_nfs_impl_id4(struct nfsd4_compoundargs *argp,
1548 			  struct nfsd4_exchange_id *exid)
1549 {
1550 	__be32 status;
1551 	u32 count;
1552 
1553 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1554 		return nfserr_bad_xdr;
1555 	switch (count) {
1556 	case 0:
1557 		break;
1558 	case 1:
1559 		/* Note that RFC 8881 places no length limit on
1560 		 * nii_domain, but this implementation permits no
1561 		 * more than NFS4_OPAQUE_LIMIT bytes */
1562 		status = nfsd4_decode_opaque(argp, &exid->nii_domain);
1563 		if (status)
1564 			return status;
1565 		/* Note that RFC 8881 places no length limit on
1566 		 * nii_name, but this implementation permits no
1567 		 * more than NFS4_OPAQUE_LIMIT bytes */
1568 		status = nfsd4_decode_opaque(argp, &exid->nii_name);
1569 		if (status)
1570 			return status;
1571 		status = nfsd4_decode_nfstime4(argp, &exid->nii_time);
1572 		if (status)
1573 			return status;
1574 		break;
1575 	default:
1576 		return nfserr_bad_xdr;
1577 	}
1578 
1579 	return nfs_ok;
1580 }
1581 
1582 static __be32
1583 nfsd4_decode_exchange_id(struct nfsd4_compoundargs *argp,
1584 			 struct nfsd4_exchange_id *exid)
1585 {
1586 	__be32 status;
1587 
1588 	status = nfsd4_decode_verifier4(argp, &exid->verifier);
1589 	if (status)
1590 		return status;
1591 	status = nfsd4_decode_opaque(argp, &exid->clname);
1592 	if (status)
1593 		return status;
1594 	if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0)
1595 		return nfserr_bad_xdr;
1596 	status = nfsd4_decode_state_protect4_a(argp, exid);
1597 	if (status)
1598 		return status;
1599 	return nfsd4_decode_nfs_impl_id4(argp, exid);
1600 }
1601 
1602 static __be32
1603 nfsd4_decode_channel_attrs4(struct nfsd4_compoundargs *argp,
1604 			    struct nfsd4_channel_attrs *ca)
1605 {
1606 	__be32 *p;
1607 
1608 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7);
1609 	if (!p)
1610 		return nfserr_bad_xdr;
1611 
1612 	/* headerpadsz is ignored */
1613 	p++;
1614 	ca->maxreq_sz = be32_to_cpup(p++);
1615 	ca->maxresp_sz = be32_to_cpup(p++);
1616 	ca->maxresp_cached = be32_to_cpup(p++);
1617 	ca->maxops = be32_to_cpup(p++);
1618 	ca->maxreqs = be32_to_cpup(p++);
1619 	ca->nr_rdma_attrs = be32_to_cpup(p);
1620 	switch (ca->nr_rdma_attrs) {
1621 	case 0:
1622 		break;
1623 	case 1:
1624 		if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0)
1625 			return nfserr_bad_xdr;
1626 		break;
1627 	default:
1628 		return nfserr_bad_xdr;
1629 	}
1630 
1631 	return nfs_ok;
1632 }
1633 
1634 static __be32
1635 nfsd4_decode_create_session(struct nfsd4_compoundargs *argp,
1636 			    struct nfsd4_create_session *sess)
1637 {
1638 	__be32 status;
1639 
1640 	status = nfsd4_decode_clientid4(argp, &sess->clientid);
1641 	if (status)
1642 		return status;
1643 	if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0)
1644 		return nfserr_bad_xdr;
1645 	if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0)
1646 		return nfserr_bad_xdr;
1647 	status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel);
1648 	if (status)
1649 		return status;
1650 	status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel);
1651 	if (status)
1652 		return status;
1653 	if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0)
1654 		return nfserr_bad_xdr;
1655 	status = nfsd4_decode_cb_sec(argp, &sess->cb_sec);
1656 	if (status)
1657 		return status;
1658 
1659 	return nfs_ok;
1660 }
1661 
1662 static __be32
1663 nfsd4_decode_destroy_session(struct nfsd4_compoundargs *argp,
1664 			     struct nfsd4_destroy_session *destroy_session)
1665 {
1666 	return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid);
1667 }
1668 
1669 static __be32
1670 nfsd4_decode_free_stateid(struct nfsd4_compoundargs *argp,
1671 			  struct nfsd4_free_stateid *free_stateid)
1672 {
1673 	return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid);
1674 }
1675 
1676 #ifdef CONFIG_NFSD_PNFS
1677 static __be32
1678 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs *argp,
1679 		struct nfsd4_getdeviceinfo *gdev)
1680 {
1681 	__be32 status;
1682 
1683 	status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid);
1684 	if (status)
1685 		return status;
1686 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0)
1687 		return nfserr_bad_xdr;
1688 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0)
1689 		return nfserr_bad_xdr;
1690 	if (xdr_stream_decode_uint32_array(argp->xdr,
1691 					   &gdev->gd_notify_types, 1) < 0)
1692 		return nfserr_bad_xdr;
1693 
1694 	return nfs_ok;
1695 }
1696 
1697 static __be32
1698 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs *argp,
1699 			  struct nfsd4_layoutcommit *lcp)
1700 {
1701 	__be32 *p, status;
1702 
1703 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0)
1704 		return nfserr_bad_xdr;
1705 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0)
1706 		return nfserr_bad_xdr;
1707 	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0)
1708 		return nfserr_bad_xdr;
1709 	status = nfsd4_decode_stateid4(argp, &lcp->lc_sid);
1710 	if (status)
1711 		return status;
1712 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0)
1713 		return nfserr_bad_xdr;
1714 	if (lcp->lc_newoffset) {
1715 		if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0)
1716 			return nfserr_bad_xdr;
1717 	} else
1718 		lcp->lc_last_wr = 0;
1719 	p = xdr_inline_decode(argp->xdr, XDR_UNIT);
1720 	if (!p)
1721 		return nfserr_bad_xdr;
1722 	if (xdr_item_is_present(p)) {
1723 		status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime);
1724 		if (status)
1725 			return status;
1726 	} else {
1727 		lcp->lc_mtime.tv_nsec = UTIME_NOW;
1728 	}
1729 	return nfsd4_decode_layoutupdate4(argp, lcp);
1730 }
1731 
1732 static __be32
1733 nfsd4_decode_layoutget(struct nfsd4_compoundargs *argp,
1734 		struct nfsd4_layoutget *lgp)
1735 {
1736 	__be32 status;
1737 
1738 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0)
1739 		return nfserr_bad_xdr;
1740 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0)
1741 		return nfserr_bad_xdr;
1742 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0)
1743 		return nfserr_bad_xdr;
1744 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0)
1745 		return nfserr_bad_xdr;
1746 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0)
1747 		return nfserr_bad_xdr;
1748 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0)
1749 		return nfserr_bad_xdr;
1750 	status = nfsd4_decode_stateid4(argp, &lgp->lg_sid);
1751 	if (status)
1752 		return status;
1753 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0)
1754 		return nfserr_bad_xdr;
1755 
1756 	return nfs_ok;
1757 }
1758 
1759 static __be32
1760 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs *argp,
1761 		struct nfsd4_layoutreturn *lrp)
1762 {
1763 	if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0)
1764 		return nfserr_bad_xdr;
1765 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0)
1766 		return nfserr_bad_xdr;
1767 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0)
1768 		return nfserr_bad_xdr;
1769 	return nfsd4_decode_layoutreturn4(argp, lrp);
1770 }
1771 #endif /* CONFIG_NFSD_PNFS */
1772 
1773 static __be32 nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs *argp,
1774 					   struct nfsd4_secinfo_no_name *sin)
1775 {
1776 	if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0)
1777 		return nfserr_bad_xdr;
1778 	return nfs_ok;
1779 }
1780 
1781 static __be32
1782 nfsd4_decode_sequence(struct nfsd4_compoundargs *argp,
1783 		      struct nfsd4_sequence *seq)
1784 {
1785 	__be32 *p, status;
1786 
1787 	status = nfsd4_decode_sessionid4(argp, &seq->sessionid);
1788 	if (status)
1789 		return status;
1790 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4);
1791 	if (!p)
1792 		return nfserr_bad_xdr;
1793 	seq->seqid = be32_to_cpup(p++);
1794 	seq->slotid = be32_to_cpup(p++);
1795 	seq->maxslots = be32_to_cpup(p++);
1796 	seq->cachethis = be32_to_cpup(p);
1797 
1798 	return nfs_ok;
1799 }
1800 
1801 static __be32
1802 nfsd4_decode_test_stateid(struct nfsd4_compoundargs *argp, struct nfsd4_test_stateid *test_stateid)
1803 {
1804 	struct nfsd4_test_stateid_id *stateid;
1805 	__be32 status;
1806 	u32 i;
1807 
1808 	if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0)
1809 		return nfserr_bad_xdr;
1810 
1811 	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);
1812 	for (i = 0; i < test_stateid->ts_num_ids; i++) {
1813 		stateid = svcxdr_tmpalloc(argp, sizeof(*stateid));
1814 		if (!stateid)
1815 			return nfserrno(-ENOMEM);	/* XXX: not jukebox? */
1816 		INIT_LIST_HEAD(&stateid->ts_id_list);
1817 		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);
1818 		status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid);
1819 		if (status)
1820 			return status;
1821 	}
1822 
1823 	return nfs_ok;
1824 }
1825 
1826 static __be32 nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs *argp,
1827 					    struct nfsd4_destroy_clientid *dc)
1828 {
1829 	return nfsd4_decode_clientid4(argp, &dc->clientid);
1830 }
1831 
1832 static __be32 nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs *argp,
1833 					    struct nfsd4_reclaim_complete *rc)
1834 {
1835 	if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0)
1836 		return nfserr_bad_xdr;
1837 	return nfs_ok;
1838 }
1839 
1840 static __be32
1841 nfsd4_decode_fallocate(struct nfsd4_compoundargs *argp,
1842 		       struct nfsd4_fallocate *fallocate)
1843 {
1844 	__be32 status;
1845 
1846 	status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid);
1847 	if (status)
1848 		return status;
1849 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0)
1850 		return nfserr_bad_xdr;
1851 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0)
1852 		return nfserr_bad_xdr;
1853 
1854 	return nfs_ok;
1855 }
1856 
1857 static __be32 nfsd4_decode_nl4_server(struct nfsd4_compoundargs *argp,
1858 				      struct nl4_server *ns)
1859 {
1860 	struct nfs42_netaddr *naddr;
1861 	__be32 *p;
1862 
1863 	if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0)
1864 		return nfserr_bad_xdr;
1865 
1866 	/* currently support for 1 inter-server source server */
1867 	switch (ns->nl4_type) {
1868 	case NL4_NETADDR:
1869 		naddr = &ns->u.nl4_addr;
1870 
1871 		if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0)
1872 			return nfserr_bad_xdr;
1873 		if (naddr->netid_len > RPCBIND_MAXNETIDLEN)
1874 			return nfserr_bad_xdr;
1875 
1876 		p = xdr_inline_decode(argp->xdr, naddr->netid_len);
1877 		if (!p)
1878 			return nfserr_bad_xdr;
1879 		memcpy(naddr->netid, p, naddr->netid_len);
1880 
1881 		if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0)
1882 			return nfserr_bad_xdr;
1883 		if (naddr->addr_len > RPCBIND_MAXUADDRLEN)
1884 			return nfserr_bad_xdr;
1885 
1886 		p = xdr_inline_decode(argp->xdr, naddr->addr_len);
1887 		if (!p)
1888 			return nfserr_bad_xdr;
1889 		memcpy(naddr->addr, p, naddr->addr_len);
1890 		break;
1891 	default:
1892 		return nfserr_bad_xdr;
1893 	}
1894 
1895 	return nfs_ok;
1896 }
1897 
1898 static __be32
1899 nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)
1900 {
1901 	struct nl4_server *ns_dummy;
1902 	u32 consecutive, i, count;
1903 	__be32 status;
1904 
1905 	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);
1906 	if (status)
1907 		return status;
1908 	status = nfsd4_decode_stateid4(argp, &copy->cp_dst_stateid);
1909 	if (status)
1910 		return status;
1911 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_src_pos) < 0)
1912 		return nfserr_bad_xdr;
1913 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_dst_pos) < 0)
1914 		return nfserr_bad_xdr;
1915 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_count) < 0)
1916 		return nfserr_bad_xdr;
1917 	/* ca_consecutive: we always do consecutive copies */
1918 	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)
1919 		return nfserr_bad_xdr;
1920 	if (xdr_stream_decode_u32(argp->xdr, &copy->cp_synchronous) < 0)
1921 		return nfserr_bad_xdr;
1922 
1923 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
1924 		return nfserr_bad_xdr;
1925 	copy->cp_intra = false;
1926 	if (count == 0) { /* intra-server copy */
1927 		copy->cp_intra = true;
1928 		return nfs_ok;
1929 	}
1930 
1931 	/* decode all the supplied server addresses but use only the first */
1932 	status = nfsd4_decode_nl4_server(argp, &copy->cp_src);
1933 	if (status)
1934 		return status;
1935 
1936 	ns_dummy = kmalloc(sizeof(struct nl4_server), GFP_KERNEL);
1937 	if (ns_dummy == NULL)
1938 		return nfserrno(-ENOMEM);	/* XXX: jukebox? */
1939 	for (i = 0; i < count - 1; i++) {
1940 		status = nfsd4_decode_nl4_server(argp, ns_dummy);
1941 		if (status) {
1942 			kfree(ns_dummy);
1943 			return status;
1944 		}
1945 	}
1946 	kfree(ns_dummy);
1947 
1948 	return nfs_ok;
1949 }
1950 
1951 static __be32
1952 nfsd4_decode_copy_notify(struct nfsd4_compoundargs *argp,
1953 			 struct nfsd4_copy_notify *cn)
1954 {
1955 	__be32 status;
1956 
1957 	status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid);
1958 	if (status)
1959 		return status;
1960 	return nfsd4_decode_nl4_server(argp, &cn->cpn_dst);
1961 }
1962 
1963 static __be32
1964 nfsd4_decode_offload_status(struct nfsd4_compoundargs *argp,
1965 			    struct nfsd4_offload_status *os)
1966 {
1967 	return nfsd4_decode_stateid4(argp, &os->stateid);
1968 }
1969 
1970 static __be32
1971 nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek)
1972 {
1973 	__be32 status;
1974 
1975 	status = nfsd4_decode_stateid4(argp, &seek->seek_stateid);
1976 	if (status)
1977 		return status;
1978 	if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0)
1979 		return nfserr_bad_xdr;
1980 	if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0)
1981 		return nfserr_bad_xdr;
1982 
1983 	return nfs_ok;
1984 }
1985 
1986 static __be32
1987 nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone)
1988 {
1989 	__be32 status;
1990 
1991 	status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid);
1992 	if (status)
1993 		return status;
1994 	status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid);
1995 	if (status)
1996 		return status;
1997 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0)
1998 		return nfserr_bad_xdr;
1999 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0)
2000 		return nfserr_bad_xdr;
2001 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0)
2002 		return nfserr_bad_xdr;
2003 
2004 	return nfs_ok;
2005 }
2006 
2007 /*
2008  * XDR data that is more than PAGE_SIZE in size is normally part of a
2009  * read or write. However, the size of extended attributes is limited
2010  * by the maximum request size, and then further limited by the underlying
2011  * filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX
2012  * is 64k). Since there is no kvec- or page-based interface to xattrs,
2013  * and we're not dealing with contiguous pages, we need to do some copying.
2014  */
2015 
2016 /*
2017  * Decode data into buffer.
2018  */
2019 static __be32
2020 nfsd4_vbuf_from_vector(struct nfsd4_compoundargs *argp, struct xdr_buf *xdr,
2021 		       char **bufp, u32 buflen)
2022 {
2023 	struct page **pages = xdr->pages;
2024 	struct kvec *head = xdr->head;
2025 	char *tmp, *dp;
2026 	u32 len;
2027 
2028 	if (buflen <= head->iov_len) {
2029 		/*
2030 		 * We're in luck, the head has enough space. Just return
2031 		 * the head, no need for copying.
2032 		 */
2033 		*bufp = head->iov_base;
2034 		return 0;
2035 	}
2036 
2037 	tmp = svcxdr_tmpalloc(argp, buflen);
2038 	if (tmp == NULL)
2039 		return nfserr_jukebox;
2040 
2041 	dp = tmp;
2042 	memcpy(dp, head->iov_base, head->iov_len);
2043 	buflen -= head->iov_len;
2044 	dp += head->iov_len;
2045 
2046 	while (buflen > 0) {
2047 		len = min_t(u32, buflen, PAGE_SIZE);
2048 		memcpy(dp, page_address(*pages), len);
2049 
2050 		buflen -= len;
2051 		dp += len;
2052 		pages++;
2053 	}
2054 
2055 	*bufp = tmp;
2056 	return 0;
2057 }
2058 
2059 /*
2060  * Get a user extended attribute name from the XDR buffer.
2061  * It will not have the "user." prefix, so prepend it.
2062  * Lastly, check for nul characters in the name.
2063  */
2064 static __be32
2065 nfsd4_decode_xattr_name(struct nfsd4_compoundargs *argp, char **namep)
2066 {
2067 	char *name, *sp, *dp;
2068 	u32 namelen, cnt;
2069 	__be32 *p;
2070 
2071 	if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0)
2072 		return nfserr_bad_xdr;
2073 	if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))
2074 		return nfserr_nametoolong;
2075 	if (namelen == 0)
2076 		return nfserr_bad_xdr;
2077 	p = xdr_inline_decode(argp->xdr, namelen);
2078 	if (!p)
2079 		return nfserr_bad_xdr;
2080 	name = svcxdr_tmpalloc(argp, namelen + XATTR_USER_PREFIX_LEN + 1);
2081 	if (!name)
2082 		return nfserr_jukebox;
2083 	memcpy(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
2084 
2085 	/*
2086 	 * Copy the extended attribute name over while checking for 0
2087 	 * characters.
2088 	 */
2089 	sp = (char *)p;
2090 	dp = name + XATTR_USER_PREFIX_LEN;
2091 	cnt = namelen;
2092 
2093 	while (cnt-- > 0) {
2094 		if (*sp == '\0')
2095 			return nfserr_bad_xdr;
2096 		*dp++ = *sp++;
2097 	}
2098 	*dp = '\0';
2099 
2100 	*namep = name;
2101 
2102 	return nfs_ok;
2103 }
2104 
2105 /*
2106  * A GETXATTR op request comes without a length specifier. We just set the
2107  * maximum length for the reply based on XATTR_SIZE_MAX and the maximum
2108  * channel reply size. nfsd_getxattr will probe the length of the xattr,
2109  * check it against getxa_len, and allocate + return the value.
2110  */
2111 static __be32
2112 nfsd4_decode_getxattr(struct nfsd4_compoundargs *argp,
2113 		      struct nfsd4_getxattr *getxattr)
2114 {
2115 	__be32 status;
2116 	u32 maxcount;
2117 
2118 	status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);
2119 	if (status)
2120 		return status;
2121 
2122 	maxcount = svc_max_payload(argp->rqstp);
2123 	maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
2124 
2125 	getxattr->getxa_len = maxcount;
2126 
2127 	return status;
2128 }
2129 
2130 static __be32
2131 nfsd4_decode_setxattr(struct nfsd4_compoundargs *argp,
2132 		      struct nfsd4_setxattr *setxattr)
2133 {
2134 	u32 flags, maxcount, size;
2135 	__be32 status;
2136 
2137 	if (xdr_stream_decode_u32(argp->xdr, &flags) < 0)
2138 		return nfserr_bad_xdr;
2139 
2140 	if (flags > SETXATTR4_REPLACE)
2141 		return nfserr_inval;
2142 	setxattr->setxa_flags = flags;
2143 
2144 	status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);
2145 	if (status)
2146 		return status;
2147 
2148 	maxcount = svc_max_payload(argp->rqstp);
2149 	maxcount = min_t(u32, XATTR_SIZE_MAX, maxcount);
2150 
2151 	if (xdr_stream_decode_u32(argp->xdr, &size) < 0)
2152 		return nfserr_bad_xdr;
2153 	if (size > maxcount)
2154 		return nfserr_xattr2big;
2155 
2156 	setxattr->setxa_len = size;
2157 	if (size > 0) {
2158 		struct xdr_buf payload;
2159 
2160 		if (!xdr_stream_subsegment(argp->xdr, &payload, size))
2161 			return nfserr_bad_xdr;
2162 		status = nfsd4_vbuf_from_vector(argp, &payload,
2163 						&setxattr->setxa_buf, size);
2164 	}
2165 
2166 	return nfs_ok;
2167 }
2168 
2169 static __be32
2170 nfsd4_decode_listxattrs(struct nfsd4_compoundargs *argp,
2171 			struct nfsd4_listxattrs *listxattrs)
2172 {
2173 	u32 maxcount;
2174 
2175 	if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0)
2176 		return nfserr_bad_xdr;
2177 
2178 	/*
2179 	 * If the cookie  is too large to have even one user.x attribute
2180 	 * plus trailing '\0' left in a maximum size buffer, it's invalid.
2181 	 */
2182 	if (listxattrs->lsxa_cookie >=
2183 	    (XATTR_LIST_MAX / (XATTR_USER_PREFIX_LEN + 2)))
2184 		return nfserr_badcookie;
2185 
2186 	if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0)
2187 		return nfserr_bad_xdr;
2188 	if (maxcount < 8)
2189 		/* Always need at least 2 words (length and one character) */
2190 		return nfserr_inval;
2191 
2192 	maxcount = min(maxcount, svc_max_payload(argp->rqstp));
2193 	listxattrs->lsxa_maxcount = maxcount;
2194 
2195 	return nfs_ok;
2196 }
2197 
2198 static __be32
2199 nfsd4_decode_removexattr(struct nfsd4_compoundargs *argp,
2200 			 struct nfsd4_removexattr *removexattr)
2201 {
2202 	return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);
2203 }
2204 
2205 static __be32
2206 nfsd4_decode_noop(struct nfsd4_compoundargs *argp, void *p)
2207 {
2208 	return nfs_ok;
2209 }
2210 
2211 static __be32
2212 nfsd4_decode_notsupp(struct nfsd4_compoundargs *argp, void *p)
2213 {
2214 	return nfserr_notsupp;
2215 }
2216 
2217 typedef __be32(*nfsd4_dec)(struct nfsd4_compoundargs *argp, void *);
2218 
2219 static const nfsd4_dec nfsd4_dec_ops[] = {
2220 	[OP_ACCESS]		= (nfsd4_dec)nfsd4_decode_access,
2221 	[OP_CLOSE]		= (nfsd4_dec)nfsd4_decode_close,
2222 	[OP_COMMIT]		= (nfsd4_dec)nfsd4_decode_commit,
2223 	[OP_CREATE]		= (nfsd4_dec)nfsd4_decode_create,
2224 	[OP_DELEGPURGE]		= (nfsd4_dec)nfsd4_decode_notsupp,
2225 	[OP_DELEGRETURN]	= (nfsd4_dec)nfsd4_decode_delegreturn,
2226 	[OP_GETATTR]		= (nfsd4_dec)nfsd4_decode_getattr,
2227 	[OP_GETFH]		= (nfsd4_dec)nfsd4_decode_noop,
2228 	[OP_LINK]		= (nfsd4_dec)nfsd4_decode_link,
2229 	[OP_LOCK]		= (nfsd4_dec)nfsd4_decode_lock,
2230 	[OP_LOCKT]		= (nfsd4_dec)nfsd4_decode_lockt,
2231 	[OP_LOCKU]		= (nfsd4_dec)nfsd4_decode_locku,
2232 	[OP_LOOKUP]		= (nfsd4_dec)nfsd4_decode_lookup,
2233 	[OP_LOOKUPP]		= (nfsd4_dec)nfsd4_decode_noop,
2234 	[OP_NVERIFY]		= (nfsd4_dec)nfsd4_decode_verify,
2235 	[OP_OPEN]		= (nfsd4_dec)nfsd4_decode_open,
2236 	[OP_OPENATTR]		= (nfsd4_dec)nfsd4_decode_notsupp,
2237 	[OP_OPEN_CONFIRM]	= (nfsd4_dec)nfsd4_decode_open_confirm,
2238 	[OP_OPEN_DOWNGRADE]	= (nfsd4_dec)nfsd4_decode_open_downgrade,
2239 	[OP_PUTFH]		= (nfsd4_dec)nfsd4_decode_putfh,
2240 	[OP_PUTPUBFH]		= (nfsd4_dec)nfsd4_decode_putpubfh,
2241 	[OP_PUTROOTFH]		= (nfsd4_dec)nfsd4_decode_noop,
2242 	[OP_READ]		= (nfsd4_dec)nfsd4_decode_read,
2243 	[OP_READDIR]		= (nfsd4_dec)nfsd4_decode_readdir,
2244 	[OP_READLINK]		= (nfsd4_dec)nfsd4_decode_noop,
2245 	[OP_REMOVE]		= (nfsd4_dec)nfsd4_decode_remove,
2246 	[OP_RENAME]		= (nfsd4_dec)nfsd4_decode_rename,
2247 	[OP_RENEW]		= (nfsd4_dec)nfsd4_decode_renew,
2248 	[OP_RESTOREFH]		= (nfsd4_dec)nfsd4_decode_noop,
2249 	[OP_SAVEFH]		= (nfsd4_dec)nfsd4_decode_noop,
2250 	[OP_SECINFO]		= (nfsd4_dec)nfsd4_decode_secinfo,
2251 	[OP_SETATTR]		= (nfsd4_dec)nfsd4_decode_setattr,
2252 	[OP_SETCLIENTID]	= (nfsd4_dec)nfsd4_decode_setclientid,
2253 	[OP_SETCLIENTID_CONFIRM] = (nfsd4_dec)nfsd4_decode_setclientid_confirm,
2254 	[OP_VERIFY]		= (nfsd4_dec)nfsd4_decode_verify,
2255 	[OP_WRITE]		= (nfsd4_dec)nfsd4_decode_write,
2256 	[OP_RELEASE_LOCKOWNER]	= (nfsd4_dec)nfsd4_decode_release_lockowner,
2257 
2258 	/* new operations for NFSv4.1 */
2259 	[OP_BACKCHANNEL_CTL]	= (nfsd4_dec)nfsd4_decode_backchannel_ctl,
2260 	[OP_BIND_CONN_TO_SESSION]= (nfsd4_dec)nfsd4_decode_bind_conn_to_session,
2261 	[OP_EXCHANGE_ID]	= (nfsd4_dec)nfsd4_decode_exchange_id,
2262 	[OP_CREATE_SESSION]	= (nfsd4_dec)nfsd4_decode_create_session,
2263 	[OP_DESTROY_SESSION]	= (nfsd4_dec)nfsd4_decode_destroy_session,
2264 	[OP_FREE_STATEID]	= (nfsd4_dec)nfsd4_decode_free_stateid,
2265 	[OP_GET_DIR_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
2266 #ifdef CONFIG_NFSD_PNFS
2267 	[OP_GETDEVICEINFO]	= (nfsd4_dec)nfsd4_decode_getdeviceinfo,
2268 	[OP_GETDEVICELIST]	= (nfsd4_dec)nfsd4_decode_notsupp,
2269 	[OP_LAYOUTCOMMIT]	= (nfsd4_dec)nfsd4_decode_layoutcommit,
2270 	[OP_LAYOUTGET]		= (nfsd4_dec)nfsd4_decode_layoutget,
2271 	[OP_LAYOUTRETURN]	= (nfsd4_dec)nfsd4_decode_layoutreturn,
2272 #else
2273 	[OP_GETDEVICEINFO]	= (nfsd4_dec)nfsd4_decode_notsupp,
2274 	[OP_GETDEVICELIST]	= (nfsd4_dec)nfsd4_decode_notsupp,
2275 	[OP_LAYOUTCOMMIT]	= (nfsd4_dec)nfsd4_decode_notsupp,
2276 	[OP_LAYOUTGET]		= (nfsd4_dec)nfsd4_decode_notsupp,
2277 	[OP_LAYOUTRETURN]	= (nfsd4_dec)nfsd4_decode_notsupp,
2278 #endif
2279 	[OP_SECINFO_NO_NAME]	= (nfsd4_dec)nfsd4_decode_secinfo_no_name,
2280 	[OP_SEQUENCE]		= (nfsd4_dec)nfsd4_decode_sequence,
2281 	[OP_SET_SSV]		= (nfsd4_dec)nfsd4_decode_notsupp,
2282 	[OP_TEST_STATEID]	= (nfsd4_dec)nfsd4_decode_test_stateid,
2283 	[OP_WANT_DELEGATION]	= (nfsd4_dec)nfsd4_decode_notsupp,
2284 	[OP_DESTROY_CLIENTID]	= (nfsd4_dec)nfsd4_decode_destroy_clientid,
2285 	[OP_RECLAIM_COMPLETE]	= (nfsd4_dec)nfsd4_decode_reclaim_complete,
2286 
2287 	/* new operations for NFSv4.2 */
2288 	[OP_ALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
2289 	[OP_COPY]		= (nfsd4_dec)nfsd4_decode_copy,
2290 	[OP_COPY_NOTIFY]	= (nfsd4_dec)nfsd4_decode_copy_notify,
2291 	[OP_DEALLOCATE]		= (nfsd4_dec)nfsd4_decode_fallocate,
2292 	[OP_IO_ADVISE]		= (nfsd4_dec)nfsd4_decode_notsupp,
2293 	[OP_LAYOUTERROR]	= (nfsd4_dec)nfsd4_decode_notsupp,
2294 	[OP_LAYOUTSTATS]	= (nfsd4_dec)nfsd4_decode_notsupp,
2295 	[OP_OFFLOAD_CANCEL]	= (nfsd4_dec)nfsd4_decode_offload_status,
2296 	[OP_OFFLOAD_STATUS]	= (nfsd4_dec)nfsd4_decode_offload_status,
2297 	[OP_READ_PLUS]		= (nfsd4_dec)nfsd4_decode_read,
2298 	[OP_SEEK]		= (nfsd4_dec)nfsd4_decode_seek,
2299 	[OP_WRITE_SAME]		= (nfsd4_dec)nfsd4_decode_notsupp,
2300 	[OP_CLONE]		= (nfsd4_dec)nfsd4_decode_clone,
2301 	/* RFC 8276 extended atributes operations */
2302 	[OP_GETXATTR]		= (nfsd4_dec)nfsd4_decode_getxattr,
2303 	[OP_SETXATTR]		= (nfsd4_dec)nfsd4_decode_setxattr,
2304 	[OP_LISTXATTRS]		= (nfsd4_dec)nfsd4_decode_listxattrs,
2305 	[OP_REMOVEXATTR]	= (nfsd4_dec)nfsd4_decode_removexattr,
2306 };
2307 
2308 static inline bool
2309 nfsd4_opnum_in_range(struct nfsd4_compoundargs *argp, struct nfsd4_op *op)
2310 {
2311 	if (op->opnum < FIRST_NFS4_OP)
2312 		return false;
2313 	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)
2314 		return false;
2315 	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)
2316 		return false;
2317 	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)
2318 		return false;
2319 	return true;
2320 }
2321 
2322 static bool
2323 nfsd4_decode_compound(struct nfsd4_compoundargs *argp)
2324 {
2325 	struct nfsd4_op *op;
2326 	bool cachethis = false;
2327 	int auth_slack= argp->rqstp->rq_auth_slack;
2328 	int max_reply = auth_slack + 8; /* opcnt, status */
2329 	int readcount = 0;
2330 	int readbytes = 0;
2331 	__be32 *p;
2332 	int i;
2333 
2334 	if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0)
2335 		return false;
2336 	max_reply += XDR_UNIT;
2337 	argp->tag = NULL;
2338 	if (unlikely(argp->taglen)) {
2339 		if (argp->taglen > NFSD4_MAX_TAGLEN)
2340 			return false;
2341 		p = xdr_inline_decode(argp->xdr, argp->taglen);
2342 		if (!p)
2343 			return false;
2344 		argp->tag = svcxdr_savemem(argp, p, argp->taglen);
2345 		if (!argp->tag)
2346 			return false;
2347 		max_reply += xdr_align_size(argp->taglen);
2348 	}
2349 
2350 	if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)
2351 		return false;
2352 	if (xdr_stream_decode_u32(argp->xdr, &argp->opcnt) < 0)
2353 		return false;
2354 
2355 	/*
2356 	 * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
2357 	 * here, so we return success at the xdr level so that
2358 	 * nfsd4_proc can handle this is an NFS-level error.
2359 	 */
2360 	if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND)
2361 		return true;
2362 
2363 	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {
2364 		argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL);
2365 		if (!argp->ops) {
2366 			argp->ops = argp->iops;
2367 			dprintk("nfsd: couldn't allocate room for COMPOUND\n");
2368 			return false;
2369 		}
2370 	}
2371 
2372 	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)
2373 		argp->opcnt = 0;
2374 
2375 	for (i = 0; i < argp->opcnt; i++) {
2376 		op = &argp->ops[i];
2377 		op->replay = NULL;
2378 
2379 		if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)
2380 			return false;
2381 		if (nfsd4_opnum_in_range(argp, op)) {
2382 			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);
2383 			if (op->status != nfs_ok)
2384 				trace_nfsd_compound_decode_err(argp->rqstp,
2385 							       argp->opcnt, i,
2386 							       op->opnum,
2387 							       op->status);
2388 		} else {
2389 			op->opnum = OP_ILLEGAL;
2390 			op->status = nfserr_op_illegal;
2391 		}
2392 		op->opdesc = OPDESC(op);
2393 		/*
2394 		 * We'll try to cache the result in the DRC if any one
2395 		 * op in the compound wants to be cached:
2396 		 */
2397 		cachethis |= nfsd4_cache_this_op(op);
2398 
2399 		if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {
2400 			readcount++;
2401 			readbytes += nfsd4_max_reply(argp->rqstp, op);
2402 		} else
2403 			max_reply += nfsd4_max_reply(argp->rqstp, op);
2404 		/*
2405 		 * OP_LOCK and OP_LOCKT may return a conflicting lock.
2406 		 * (Special case because it will just skip encoding this
2407 		 * if it runs out of xdr buffer space, and it is the only
2408 		 * operation that behaves this way.)
2409 		 */
2410 		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)
2411 			max_reply += NFS4_OPAQUE_LIMIT;
2412 
2413 		if (op->status) {
2414 			argp->opcnt = i+1;
2415 			break;
2416 		}
2417 	}
2418 	/* Sessions make the DRC unnecessary: */
2419 	if (argp->minorversion)
2420 		cachethis = false;
2421 	svc_reserve(argp->rqstp, max_reply + readbytes);
2422 	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;
2423 
2424 	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)
2425 		clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags);
2426 
2427 	return true;
2428 }
2429 
2430 static __be32 *encode_change(__be32 *p, struct kstat *stat, struct inode *inode,
2431 			     struct svc_export *exp)
2432 {
2433 	if (exp->ex_flags & NFSEXP_V4ROOT) {
2434 		*p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time));
2435 		*p++ = 0;
2436 	} else
2437 		p = xdr_encode_hyper(p, nfsd4_change_attribute(stat, inode));
2438 	return p;
2439 }
2440 
2441 /*
2442  * ctime (in NFSv4, time_metadata) is not writeable, and the client
2443  * doesn't really care what resolution could theoretically be stored by
2444  * the filesystem.
2445  *
2446  * The client cares how close together changes can be while still
2447  * guaranteeing ctime changes.  For most filesystems (which have
2448  * timestamps with nanosecond fields) that is limited by the resolution
2449  * of the time returned from current_time() (which I'm assuming to be
2450  * 1/HZ).
2451  */
2452 static __be32 *encode_time_delta(__be32 *p, struct inode *inode)
2453 {
2454 	struct timespec64 ts;
2455 	u32 ns;
2456 
2457 	ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);
2458 	ts = ns_to_timespec64(ns);
2459 
2460 	p = xdr_encode_hyper(p, ts.tv_sec);
2461 	*p++ = cpu_to_be32(ts.tv_nsec);
2462 
2463 	return p;
2464 }
2465 
2466 static __be32 *encode_cinfo(__be32 *p, struct nfsd4_change_info *c)
2467 {
2468 	*p++ = cpu_to_be32(c->atomic);
2469 	p = xdr_encode_hyper(p, c->before_change);
2470 	p = xdr_encode_hyper(p, c->after_change);
2471 	return p;
2472 }
2473 
2474 /* Encode as an array of strings the string given with components
2475  * separated @sep, escaped with esc_enter and esc_exit.
2476  */
2477 static __be32 nfsd4_encode_components_esc(struct xdr_stream *xdr, char sep,
2478 					  char *components, char esc_enter,
2479 					  char esc_exit)
2480 {
2481 	__be32 *p;
2482 	__be32 pathlen;
2483 	int pathlen_offset;
2484 	int strlen, count=0;
2485 	char *str, *end, *next;
2486 
2487 	dprintk("nfsd4_encode_components(%s)\n", components);
2488 
2489 	pathlen_offset = xdr->buf->len;
2490 	p = xdr_reserve_space(xdr, 4);
2491 	if (!p)
2492 		return nfserr_resource;
2493 	p++; /* We will fill this in with @count later */
2494 
2495 	end = str = components;
2496 	while (*end) {
2497 		bool found_esc = false;
2498 
2499 		/* try to parse as esc_start, ..., esc_end, sep */
2500 		if (*str == esc_enter) {
2501 			for (; *end && (*end != esc_exit); end++)
2502 				/* find esc_exit or end of string */;
2503 			next = end + 1;
2504 			if (*end && (!*next || *next == sep)) {
2505 				str++;
2506 				found_esc = true;
2507 			}
2508 		}
2509 
2510 		if (!found_esc)
2511 			for (; *end && (*end != sep); end++)
2512 				/* find sep or end of string */;
2513 
2514 		strlen = end - str;
2515 		if (strlen) {
2516 			p = xdr_reserve_space(xdr, strlen + 4);
2517 			if (!p)
2518 				return nfserr_resource;
2519 			p = xdr_encode_opaque(p, str, strlen);
2520 			count++;
2521 		}
2522 		else
2523 			end++;
2524 		if (found_esc)
2525 			end = next;
2526 
2527 		str = end;
2528 	}
2529 	pathlen = htonl(count);
2530 	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);
2531 	return 0;
2532 }
2533 
2534 /* Encode as an array of strings the string given with components
2535  * separated @sep.
2536  */
2537 static __be32 nfsd4_encode_components(struct xdr_stream *xdr, char sep,
2538 				      char *components)
2539 {
2540 	return nfsd4_encode_components_esc(xdr, sep, components, 0, 0);
2541 }
2542 
2543 /*
2544  * encode a location element of a fs_locations structure
2545  */
2546 static __be32 nfsd4_encode_fs_location4(struct xdr_stream *xdr,
2547 					struct nfsd4_fs_location *location)
2548 {
2549 	__be32 status;
2550 
2551 	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,
2552 						'[', ']');
2553 	if (status)
2554 		return status;
2555 	status = nfsd4_encode_components(xdr, '/', location->path);
2556 	if (status)
2557 		return status;
2558 	return 0;
2559 }
2560 
2561 /*
2562  * Encode a path in RFC3530 'pathname4' format
2563  */
2564 static __be32 nfsd4_encode_path(struct xdr_stream *xdr,
2565 				const struct path *root,
2566 				const struct path *path)
2567 {
2568 	struct path cur = *path;
2569 	__be32 *p;
2570 	struct dentry **components = NULL;
2571 	unsigned int ncomponents = 0;
2572 	__be32 err = nfserr_jukebox;
2573 
2574 	dprintk("nfsd4_encode_components(");
2575 
2576 	path_get(&cur);
2577 	/* First walk the path up to the nfsd root, and store the
2578 	 * dentries/path components in an array.
2579 	 */
2580 	for (;;) {
2581 		if (path_equal(&cur, root))
2582 			break;
2583 		if (cur.dentry == cur.mnt->mnt_root) {
2584 			if (follow_up(&cur))
2585 				continue;
2586 			goto out_free;
2587 		}
2588 		if ((ncomponents & 15) == 0) {
2589 			struct dentry **new;
2590 			new = krealloc(components,
2591 					sizeof(*new) * (ncomponents + 16),
2592 					GFP_KERNEL);
2593 			if (!new)
2594 				goto out_free;
2595 			components = new;
2596 		}
2597 		components[ncomponents++] = cur.dentry;
2598 		cur.dentry = dget_parent(cur.dentry);
2599 	}
2600 	err = nfserr_resource;
2601 	p = xdr_reserve_space(xdr, 4);
2602 	if (!p)
2603 		goto out_free;
2604 	*p++ = cpu_to_be32(ncomponents);
2605 
2606 	while (ncomponents) {
2607 		struct dentry *dentry = components[ncomponents - 1];
2608 		unsigned int len;
2609 
2610 		spin_lock(&dentry->d_lock);
2611 		len = dentry->d_name.len;
2612 		p = xdr_reserve_space(xdr, len + 4);
2613 		if (!p) {
2614 			spin_unlock(&dentry->d_lock);
2615 			goto out_free;
2616 		}
2617 		p = xdr_encode_opaque(p, dentry->d_name.name, len);
2618 		dprintk("/%pd", dentry);
2619 		spin_unlock(&dentry->d_lock);
2620 		dput(dentry);
2621 		ncomponents--;
2622 	}
2623 
2624 	err = 0;
2625 out_free:
2626 	dprintk(")\n");
2627 	while (ncomponents)
2628 		dput(components[--ncomponents]);
2629 	kfree(components);
2630 	path_put(&cur);
2631 	return err;
2632 }
2633 
2634 static __be32 nfsd4_encode_fsloc_fsroot(struct xdr_stream *xdr,
2635 			struct svc_rqst *rqstp, const struct path *path)
2636 {
2637 	struct svc_export *exp_ps;
2638 	__be32 res;
2639 
2640 	exp_ps = rqst_find_fsidzero_export(rqstp);
2641 	if (IS_ERR(exp_ps))
2642 		return nfserrno(PTR_ERR(exp_ps));
2643 	res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path);
2644 	exp_put(exp_ps);
2645 	return res;
2646 }
2647 
2648 /*
2649  *  encode a fs_locations structure
2650  */
2651 static __be32 nfsd4_encode_fs_locations(struct xdr_stream *xdr,
2652 			struct svc_rqst *rqstp, struct svc_export *exp)
2653 {
2654 	__be32 status;
2655 	int i;
2656 	__be32 *p;
2657 	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;
2658 
2659 	status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path);
2660 	if (status)
2661 		return status;
2662 	p = xdr_reserve_space(xdr, 4);
2663 	if (!p)
2664 		return nfserr_resource;
2665 	*p++ = cpu_to_be32(fslocs->locations_count);
2666 	for (i=0; i<fslocs->locations_count; i++) {
2667 		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);
2668 		if (status)
2669 			return status;
2670 	}
2671 	return 0;
2672 }
2673 
2674 static u32 nfs4_file_type(umode_t mode)
2675 {
2676 	switch (mode & S_IFMT) {
2677 	case S_IFIFO:	return NF4FIFO;
2678 	case S_IFCHR:	return NF4CHR;
2679 	case S_IFDIR:	return NF4DIR;
2680 	case S_IFBLK:	return NF4BLK;
2681 	case S_IFLNK:	return NF4LNK;
2682 	case S_IFREG:	return NF4REG;
2683 	case S_IFSOCK:	return NF4SOCK;
2684 	default:	return NF4BAD;
2685 	}
2686 }
2687 
2688 static inline __be32
2689 nfsd4_encode_aclname(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2690 		     struct nfs4_ace *ace)
2691 {
2692 	if (ace->whotype != NFS4_ACL_WHO_NAMED)
2693 		return nfs4_acl_write_who(xdr, ace->whotype);
2694 	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)
2695 		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);
2696 	else
2697 		return nfsd4_encode_user(xdr, rqstp, ace->who_uid);
2698 }
2699 
2700 static inline __be32
2701 nfsd4_encode_layout_types(struct xdr_stream *xdr, u32 layout_types)
2702 {
2703 	__be32		*p;
2704 	unsigned long	i = hweight_long(layout_types);
2705 
2706 	p = xdr_reserve_space(xdr, 4 + 4 * i);
2707 	if (!p)
2708 		return nfserr_resource;
2709 
2710 	*p++ = cpu_to_be32(i);
2711 
2712 	for (i = LAYOUT_NFSV4_1_FILES; i < LAYOUT_TYPE_MAX; ++i)
2713 		if (layout_types & (1 << i))
2714 			*p++ = cpu_to_be32(i);
2715 
2716 	return 0;
2717 }
2718 
2719 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2720 			      FATTR4_WORD0_RDATTR_ERROR)
2721 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2722 #define WORD2_ABSENT_FS_ATTRS 0
2723 
2724 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2725 static inline __be32
2726 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2727 			    void *context, int len)
2728 {
2729 	__be32 *p;
2730 
2731 	p = xdr_reserve_space(xdr, len + 4 + 4 + 4);
2732 	if (!p)
2733 		return nfserr_resource;
2734 
2735 	/*
2736 	 * For now we use a 0 here to indicate the null translation; in
2737 	 * the future we may place a call to translation code here.
2738 	 */
2739 	*p++ = cpu_to_be32(0); /* lfs */
2740 	*p++ = cpu_to_be32(0); /* pi */
2741 	p = xdr_encode_opaque(p, context, len);
2742 	return 0;
2743 }
2744 #else
2745 static inline __be32
2746 nfsd4_encode_security_label(struct xdr_stream *xdr, struct svc_rqst *rqstp,
2747 			    void *context, int len)
2748 { return 0; }
2749 #endif
2750 
2751 static __be32 fattr_handle_absent_fs(u32 *bmval0, u32 *bmval1, u32 *bmval2, u32 *rdattr_err)
2752 {
2753 	/* As per referral draft:  */
2754 	if (*bmval0 & ~WORD0_ABSENT_FS_ATTRS ||
2755 	    *bmval1 & ~WORD1_ABSENT_FS_ATTRS) {
2756 		if (*bmval0 & FATTR4_WORD0_RDATTR_ERROR ||
2757 	            *bmval0 & FATTR4_WORD0_FS_LOCATIONS)
2758 			*rdattr_err = NFSERR_MOVED;
2759 		else
2760 			return nfserr_moved;
2761 	}
2762 	*bmval0 &= WORD0_ABSENT_FS_ATTRS;
2763 	*bmval1 &= WORD1_ABSENT_FS_ATTRS;
2764 	*bmval2 &= WORD2_ABSENT_FS_ATTRS;
2765 	return 0;
2766 }
2767 
2768 
2769 static int get_parent_attributes(struct svc_export *exp, struct kstat *stat)
2770 {
2771 	struct path path = exp->ex_path;
2772 	int err;
2773 
2774 	path_get(&path);
2775 	while (follow_up(&path)) {
2776 		if (path.dentry != path.mnt->mnt_root)
2777 			break;
2778 	}
2779 	err = vfs_getattr(&path, stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2780 	path_put(&path);
2781 	return err;
2782 }
2783 
2784 static __be32
2785 nfsd4_encode_bitmap(struct xdr_stream *xdr, u32 bmval0, u32 bmval1, u32 bmval2)
2786 {
2787 	__be32 *p;
2788 
2789 	if (bmval2) {
2790 		p = xdr_reserve_space(xdr, 16);
2791 		if (!p)
2792 			goto out_resource;
2793 		*p++ = cpu_to_be32(3);
2794 		*p++ = cpu_to_be32(bmval0);
2795 		*p++ = cpu_to_be32(bmval1);
2796 		*p++ = cpu_to_be32(bmval2);
2797 	} else if (bmval1) {
2798 		p = xdr_reserve_space(xdr, 12);
2799 		if (!p)
2800 			goto out_resource;
2801 		*p++ = cpu_to_be32(2);
2802 		*p++ = cpu_to_be32(bmval0);
2803 		*p++ = cpu_to_be32(bmval1);
2804 	} else {
2805 		p = xdr_reserve_space(xdr, 8);
2806 		if (!p)
2807 			goto out_resource;
2808 		*p++ = cpu_to_be32(1);
2809 		*p++ = cpu_to_be32(bmval0);
2810 	}
2811 
2812 	return 0;
2813 out_resource:
2814 	return nfserr_resource;
2815 }
2816 
2817 /*
2818  * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2819  * ourselves.
2820  */
2821 static __be32
2822 nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp,
2823 		struct svc_export *exp,
2824 		struct dentry *dentry, u32 *bmval,
2825 		struct svc_rqst *rqstp, int ignore_crossmnt)
2826 {
2827 	u32 bmval0 = bmval[0];
2828 	u32 bmval1 = bmval[1];
2829 	u32 bmval2 = bmval[2];
2830 	struct kstat stat;
2831 	struct svc_fh *tempfh = NULL;
2832 	struct kstatfs statfs;
2833 	__be32 *p;
2834 	int starting_len = xdr->buf->len;
2835 	int attrlen_offset;
2836 	__be32 attrlen;
2837 	u32 dummy;
2838 	u64 dummy64;
2839 	u32 rdattr_err = 0;
2840 	__be32 status;
2841 	int err;
2842 	struct nfs4_acl *acl = NULL;
2843 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2844 	void *context = NULL;
2845 	int contextlen;
2846 #endif
2847 	bool contextsupport = false;
2848 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
2849 	u32 minorversion = resp->cstate.minorversion;
2850 	struct path path = {
2851 		.mnt	= exp->ex_path.mnt,
2852 		.dentry	= dentry,
2853 	};
2854 	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2855 
2856 	BUG_ON(bmval1 & NFSD_WRITEONLY_ATTRS_WORD1);
2857 	BUG_ON(!nfsd_attrs_supported(minorversion, bmval));
2858 
2859 	if (exp->ex_fslocs.migrated) {
2860 		status = fattr_handle_absent_fs(&bmval0, &bmval1, &bmval2, &rdattr_err);
2861 		if (status)
2862 			goto out;
2863 	}
2864 
2865 	err = vfs_getattr(&path, &stat, STATX_BASIC_STATS, AT_STATX_SYNC_AS_STAT);
2866 	if (err)
2867 		goto out_nfserr;
2868 	if ((bmval0 & (FATTR4_WORD0_FILES_AVAIL | FATTR4_WORD0_FILES_FREE |
2869 			FATTR4_WORD0_FILES_TOTAL | FATTR4_WORD0_MAXNAME)) ||
2870 	    (bmval1 & (FATTR4_WORD1_SPACE_AVAIL | FATTR4_WORD1_SPACE_FREE |
2871 		       FATTR4_WORD1_SPACE_TOTAL))) {
2872 		err = vfs_statfs(&path, &statfs);
2873 		if (err)
2874 			goto out_nfserr;
2875 	}
2876 	if ((bmval0 & (FATTR4_WORD0_FILEHANDLE | FATTR4_WORD0_FSID)) && !fhp) {
2877 		tempfh = kmalloc(sizeof(struct svc_fh), GFP_KERNEL);
2878 		status = nfserr_jukebox;
2879 		if (!tempfh)
2880 			goto out;
2881 		fh_init(tempfh, NFS4_FHSIZE);
2882 		status = fh_compose(tempfh, exp, dentry, NULL);
2883 		if (status)
2884 			goto out;
2885 		fhp = tempfh;
2886 	}
2887 	if (bmval0 & FATTR4_WORD0_ACL) {
2888 		err = nfsd4_get_nfs4_acl(rqstp, dentry, &acl);
2889 		if (err == -EOPNOTSUPP)
2890 			bmval0 &= ~FATTR4_WORD0_ACL;
2891 		else if (err == -EINVAL) {
2892 			status = nfserr_attrnotsupp;
2893 			goto out;
2894 		} else if (err != 0)
2895 			goto out_nfserr;
2896 	}
2897 
2898 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2899 	if ((bmval2 & FATTR4_WORD2_SECURITY_LABEL) ||
2900 	     bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2901 		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)
2902 			err = security_inode_getsecctx(d_inode(dentry),
2903 						&context, &contextlen);
2904 		else
2905 			err = -EOPNOTSUPP;
2906 		contextsupport = (err == 0);
2907 		if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
2908 			if (err == -EOPNOTSUPP)
2909 				bmval2 &= ~FATTR4_WORD2_SECURITY_LABEL;
2910 			else if (err)
2911 				goto out_nfserr;
2912 		}
2913 	}
2914 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2915 
2916 	status = nfsd4_encode_bitmap(xdr, bmval0, bmval1, bmval2);
2917 	if (status)
2918 		goto out;
2919 
2920 	attrlen_offset = xdr->buf->len;
2921 	p = xdr_reserve_space(xdr, 4);
2922 	if (!p)
2923 		goto out_resource;
2924 	p++;                /* to be backfilled later */
2925 
2926 	if (bmval0 & FATTR4_WORD0_SUPPORTED_ATTRS) {
2927 		u32 supp[3];
2928 
2929 		memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
2930 
2931 		if (!IS_POSIXACL(dentry->d_inode))
2932 			supp[0] &= ~FATTR4_WORD0_ACL;
2933 		if (!contextsupport)
2934 			supp[2] &= ~FATTR4_WORD2_SECURITY_LABEL;
2935 		if (!supp[2]) {
2936 			p = xdr_reserve_space(xdr, 12);
2937 			if (!p)
2938 				goto out_resource;
2939 			*p++ = cpu_to_be32(2);
2940 			*p++ = cpu_to_be32(supp[0]);
2941 			*p++ = cpu_to_be32(supp[1]);
2942 		} else {
2943 			p = xdr_reserve_space(xdr, 16);
2944 			if (!p)
2945 				goto out_resource;
2946 			*p++ = cpu_to_be32(3);
2947 			*p++ = cpu_to_be32(supp[0]);
2948 			*p++ = cpu_to_be32(supp[1]);
2949 			*p++ = cpu_to_be32(supp[2]);
2950 		}
2951 	}
2952 	if (bmval0 & FATTR4_WORD0_TYPE) {
2953 		p = xdr_reserve_space(xdr, 4);
2954 		if (!p)
2955 			goto out_resource;
2956 		dummy = nfs4_file_type(stat.mode);
2957 		if (dummy == NF4BAD) {
2958 			status = nfserr_serverfault;
2959 			goto out;
2960 		}
2961 		*p++ = cpu_to_be32(dummy);
2962 	}
2963 	if (bmval0 & FATTR4_WORD0_FH_EXPIRE_TYPE) {
2964 		p = xdr_reserve_space(xdr, 4);
2965 		if (!p)
2966 			goto out_resource;
2967 		if (exp->ex_flags & NFSEXP_NOSUBTREECHECK)
2968 			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT);
2969 		else
2970 			*p++ = cpu_to_be32(NFS4_FH_PERSISTENT|
2971 						NFS4_FH_VOL_RENAME);
2972 	}
2973 	if (bmval0 & FATTR4_WORD0_CHANGE) {
2974 		p = xdr_reserve_space(xdr, 8);
2975 		if (!p)
2976 			goto out_resource;
2977 		p = encode_change(p, &stat, d_inode(dentry), exp);
2978 	}
2979 	if (bmval0 & FATTR4_WORD0_SIZE) {
2980 		p = xdr_reserve_space(xdr, 8);
2981 		if (!p)
2982 			goto out_resource;
2983 		p = xdr_encode_hyper(p, stat.size);
2984 	}
2985 	if (bmval0 & FATTR4_WORD0_LINK_SUPPORT) {
2986 		p = xdr_reserve_space(xdr, 4);
2987 		if (!p)
2988 			goto out_resource;
2989 		*p++ = cpu_to_be32(1);
2990 	}
2991 	if (bmval0 & FATTR4_WORD0_SYMLINK_SUPPORT) {
2992 		p = xdr_reserve_space(xdr, 4);
2993 		if (!p)
2994 			goto out_resource;
2995 		*p++ = cpu_to_be32(1);
2996 	}
2997 	if (bmval0 & FATTR4_WORD0_NAMED_ATTR) {
2998 		p = xdr_reserve_space(xdr, 4);
2999 		if (!p)
3000 			goto out_resource;
3001 		*p++ = cpu_to_be32(0);
3002 	}
3003 	if (bmval0 & FATTR4_WORD0_FSID) {
3004 		p = xdr_reserve_space(xdr, 16);
3005 		if (!p)
3006 			goto out_resource;
3007 		if (exp->ex_fslocs.migrated) {
3008 			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MAJOR);
3009 			p = xdr_encode_hyper(p, NFS4_REFERRAL_FSID_MINOR);
3010 		} else switch(fsid_source(fhp)) {
3011 		case FSIDSOURCE_FSID:
3012 			p = xdr_encode_hyper(p, (u64)exp->ex_fsid);
3013 			p = xdr_encode_hyper(p, (u64)0);
3014 			break;
3015 		case FSIDSOURCE_DEV:
3016 			*p++ = cpu_to_be32(0);
3017 			*p++ = cpu_to_be32(MAJOR(stat.dev));
3018 			*p++ = cpu_to_be32(0);
3019 			*p++ = cpu_to_be32(MINOR(stat.dev));
3020 			break;
3021 		case FSIDSOURCE_UUID:
3022 			p = xdr_encode_opaque_fixed(p, exp->ex_uuid,
3023 								EX_UUID_LEN);
3024 			break;
3025 		}
3026 	}
3027 	if (bmval0 & FATTR4_WORD0_UNIQUE_HANDLES) {
3028 		p = xdr_reserve_space(xdr, 4);
3029 		if (!p)
3030 			goto out_resource;
3031 		*p++ = cpu_to_be32(0);
3032 	}
3033 	if (bmval0 & FATTR4_WORD0_LEASE_TIME) {
3034 		p = xdr_reserve_space(xdr, 4);
3035 		if (!p)
3036 			goto out_resource;
3037 		*p++ = cpu_to_be32(nn->nfsd4_lease);
3038 	}
3039 	if (bmval0 & FATTR4_WORD0_RDATTR_ERROR) {
3040 		p = xdr_reserve_space(xdr, 4);
3041 		if (!p)
3042 			goto out_resource;
3043 		*p++ = cpu_to_be32(rdattr_err);
3044 	}
3045 	if (bmval0 & FATTR4_WORD0_ACL) {
3046 		struct nfs4_ace *ace;
3047 
3048 		if (acl == NULL) {
3049 			p = xdr_reserve_space(xdr, 4);
3050 			if (!p)
3051 				goto out_resource;
3052 
3053 			*p++ = cpu_to_be32(0);
3054 			goto out_acl;
3055 		}
3056 		p = xdr_reserve_space(xdr, 4);
3057 		if (!p)
3058 			goto out_resource;
3059 		*p++ = cpu_to_be32(acl->naces);
3060 
3061 		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {
3062 			p = xdr_reserve_space(xdr, 4*3);
3063 			if (!p)
3064 				goto out_resource;
3065 			*p++ = cpu_to_be32(ace->type);
3066 			*p++ = cpu_to_be32(ace->flag);
3067 			*p++ = cpu_to_be32(ace->access_mask &
3068 							NFS4_ACE_MASK_ALL);
3069 			status = nfsd4_encode_aclname(xdr, rqstp, ace);
3070 			if (status)
3071 				goto out;
3072 		}
3073 	}
3074 out_acl:
3075 	if (bmval0 & FATTR4_WORD0_ACLSUPPORT) {
3076 		p = xdr_reserve_space(xdr, 4);
3077 		if (!p)
3078 			goto out_resource;
3079 		*p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ?
3080 			ACL4_SUPPORT_ALLOW_ACL|ACL4_SUPPORT_DENY_ACL : 0);
3081 	}
3082 	if (bmval0 & FATTR4_WORD0_CANSETTIME) {
3083 		p = xdr_reserve_space(xdr, 4);
3084 		if (!p)
3085 			goto out_resource;
3086 		*p++ = cpu_to_be32(1);
3087 	}
3088 	if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) {
3089 		p = xdr_reserve_space(xdr, 4);
3090 		if (!p)
3091 			goto out_resource;
3092 		*p++ = cpu_to_be32(0);
3093 	}
3094 	if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) {
3095 		p = xdr_reserve_space(xdr, 4);
3096 		if (!p)
3097 			goto out_resource;
3098 		*p++ = cpu_to_be32(1);
3099 	}
3100 	if (bmval0 & FATTR4_WORD0_CHOWN_RESTRICTED) {
3101 		p = xdr_reserve_space(xdr, 4);
3102 		if (!p)
3103 			goto out_resource;
3104 		*p++ = cpu_to_be32(1);
3105 	}
3106 	if (bmval0 & FATTR4_WORD0_FILEHANDLE) {
3107 		p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4);
3108 		if (!p)
3109 			goto out_resource;
3110 		p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw,
3111 					fhp->fh_handle.fh_size);
3112 	}
3113 	if (bmval0 & FATTR4_WORD0_FILEID) {
3114 		p = xdr_reserve_space(xdr, 8);
3115 		if (!p)
3116 			goto out_resource;
3117 		p = xdr_encode_hyper(p, stat.ino);
3118 	}
3119 	if (bmval0 & FATTR4_WORD0_FILES_AVAIL) {
3120 		p = xdr_reserve_space(xdr, 8);
3121 		if (!p)
3122 			goto out_resource;
3123 		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
3124 	}
3125 	if (bmval0 & FATTR4_WORD0_FILES_FREE) {
3126 		p = xdr_reserve_space(xdr, 8);
3127 		if (!p)
3128 			goto out_resource;
3129 		p = xdr_encode_hyper(p, (u64) statfs.f_ffree);
3130 	}
3131 	if (bmval0 & FATTR4_WORD0_FILES_TOTAL) {
3132 		p = xdr_reserve_space(xdr, 8);
3133 		if (!p)
3134 			goto out_resource;
3135 		p = xdr_encode_hyper(p, (u64) statfs.f_files);
3136 	}
3137 	if (bmval0 & FATTR4_WORD0_FS_LOCATIONS) {
3138 		status = nfsd4_encode_fs_locations(xdr, rqstp, exp);
3139 		if (status)
3140 			goto out;
3141 	}
3142 	if (bmval0 & FATTR4_WORD0_HOMOGENEOUS) {
3143 		p = xdr_reserve_space(xdr, 4);
3144 		if (!p)
3145 			goto out_resource;
3146 		*p++ = cpu_to_be32(1);
3147 	}
3148 	if (bmval0 & FATTR4_WORD0_MAXFILESIZE) {
3149 		p = xdr_reserve_space(xdr, 8);
3150 		if (!p)
3151 			goto out_resource;
3152 		p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes);
3153 	}
3154 	if (bmval0 & FATTR4_WORD0_MAXLINK) {
3155 		p = xdr_reserve_space(xdr, 4);
3156 		if (!p)
3157 			goto out_resource;
3158 		*p++ = cpu_to_be32(255);
3159 	}
3160 	if (bmval0 & FATTR4_WORD0_MAXNAME) {
3161 		p = xdr_reserve_space(xdr, 4);
3162 		if (!p)
3163 			goto out_resource;
3164 		*p++ = cpu_to_be32(statfs.f_namelen);
3165 	}
3166 	if (bmval0 & FATTR4_WORD0_MAXREAD) {
3167 		p = xdr_reserve_space(xdr, 8);
3168 		if (!p)
3169 			goto out_resource;
3170 		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
3171 	}
3172 	if (bmval0 & FATTR4_WORD0_MAXWRITE) {
3173 		p = xdr_reserve_space(xdr, 8);
3174 		if (!p)
3175 			goto out_resource;
3176 		p = xdr_encode_hyper(p, (u64) svc_max_payload(rqstp));
3177 	}
3178 	if (bmval1 & FATTR4_WORD1_MODE) {
3179 		p = xdr_reserve_space(xdr, 4);
3180 		if (!p)
3181 			goto out_resource;
3182 		*p++ = cpu_to_be32(stat.mode & S_IALLUGO);
3183 	}
3184 	if (bmval1 & FATTR4_WORD1_NO_TRUNC) {
3185 		p = xdr_reserve_space(xdr, 4);
3186 		if (!p)
3187 			goto out_resource;
3188 		*p++ = cpu_to_be32(1);
3189 	}
3190 	if (bmval1 & FATTR4_WORD1_NUMLINKS) {
3191 		p = xdr_reserve_space(xdr, 4);
3192 		if (!p)
3193 			goto out_resource;
3194 		*p++ = cpu_to_be32(stat.nlink);
3195 	}
3196 	if (bmval1 & FATTR4_WORD1_OWNER) {
3197 		status = nfsd4_encode_user(xdr, rqstp, stat.uid);
3198 		if (status)
3199 			goto out;
3200 	}
3201 	if (bmval1 & FATTR4_WORD1_OWNER_GROUP) {
3202 		status = nfsd4_encode_group(xdr, rqstp, stat.gid);
3203 		if (status)
3204 			goto out;
3205 	}
3206 	if (bmval1 & FATTR4_WORD1_RAWDEV) {
3207 		p = xdr_reserve_space(xdr, 8);
3208 		if (!p)
3209 			goto out_resource;
3210 		*p++ = cpu_to_be32((u32) MAJOR(stat.rdev));
3211 		*p++ = cpu_to_be32((u32) MINOR(stat.rdev));
3212 	}
3213 	if (bmval1 & FATTR4_WORD1_SPACE_AVAIL) {
3214 		p = xdr_reserve_space(xdr, 8);
3215 		if (!p)
3216 			goto out_resource;
3217 		dummy64 = (u64)statfs.f_bavail * (u64)statfs.f_bsize;
3218 		p = xdr_encode_hyper(p, dummy64);
3219 	}
3220 	if (bmval1 & FATTR4_WORD1_SPACE_FREE) {
3221 		p = xdr_reserve_space(xdr, 8);
3222 		if (!p)
3223 			goto out_resource;
3224 		dummy64 = (u64)statfs.f_bfree * (u64)statfs.f_bsize;
3225 		p = xdr_encode_hyper(p, dummy64);
3226 	}
3227 	if (bmval1 & FATTR4_WORD1_SPACE_TOTAL) {
3228 		p = xdr_reserve_space(xdr, 8);
3229 		if (!p)
3230 			goto out_resource;
3231 		dummy64 = (u64)statfs.f_blocks * (u64)statfs.f_bsize;
3232 		p = xdr_encode_hyper(p, dummy64);
3233 	}
3234 	if (bmval1 & FATTR4_WORD1_SPACE_USED) {
3235 		p = xdr_reserve_space(xdr, 8);
3236 		if (!p)
3237 			goto out_resource;
3238 		dummy64 = (u64)stat.blocks << 9;
3239 		p = xdr_encode_hyper(p, dummy64);
3240 	}
3241 	if (bmval1 & FATTR4_WORD1_TIME_ACCESS) {
3242 		p = xdr_reserve_space(xdr, 12);
3243 		if (!p)
3244 			goto out_resource;
3245 		p = xdr_encode_hyper(p, (s64)stat.atime.tv_sec);
3246 		*p++ = cpu_to_be32(stat.atime.tv_nsec);
3247 	}
3248 	if (bmval1 & FATTR4_WORD1_TIME_DELTA) {
3249 		p = xdr_reserve_space(xdr, 12);
3250 		if (!p)
3251 			goto out_resource;
3252 		p = encode_time_delta(p, d_inode(dentry));
3253 	}
3254 	if (bmval1 & FATTR4_WORD1_TIME_METADATA) {
3255 		p = xdr_reserve_space(xdr, 12);
3256 		if (!p)
3257 			goto out_resource;
3258 		p = xdr_encode_hyper(p, (s64)stat.ctime.tv_sec);
3259 		*p++ = cpu_to_be32(stat.ctime.tv_nsec);
3260 	}
3261 	if (bmval1 & FATTR4_WORD1_TIME_MODIFY) {
3262 		p = xdr_reserve_space(xdr, 12);
3263 		if (!p)
3264 			goto out_resource;
3265 		p = xdr_encode_hyper(p, (s64)stat.mtime.tv_sec);
3266 		*p++ = cpu_to_be32(stat.mtime.tv_nsec);
3267 	}
3268 	if (bmval1 & FATTR4_WORD1_MOUNTED_ON_FILEID) {
3269 		struct kstat parent_stat;
3270 		u64 ino = stat.ino;
3271 
3272 		p = xdr_reserve_space(xdr, 8);
3273 		if (!p)
3274                 	goto out_resource;
3275 		/*
3276 		 * Get parent's attributes if not ignoring crossmount
3277 		 * and this is the root of a cross-mounted filesystem.
3278 		 */
3279 		if (ignore_crossmnt == 0 &&
3280 		    dentry == exp->ex_path.mnt->mnt_root) {
3281 			err = get_parent_attributes(exp, &parent_stat);
3282 			if (err)
3283 				goto out_nfserr;
3284 			ino = parent_stat.ino;
3285 		}
3286 		p = xdr_encode_hyper(p, ino);
3287 	}
3288 #ifdef CONFIG_NFSD_PNFS
3289 	if (bmval1 & FATTR4_WORD1_FS_LAYOUT_TYPES) {
3290 		status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
3291 		if (status)
3292 			goto out;
3293 	}
3294 
3295 	if (bmval2 & FATTR4_WORD2_LAYOUT_TYPES) {
3296 		status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types);
3297 		if (status)
3298 			goto out;
3299 	}
3300 
3301 	if (bmval2 & FATTR4_WORD2_LAYOUT_BLKSIZE) {
3302 		p = xdr_reserve_space(xdr, 4);
3303 		if (!p)
3304 			goto out_resource;
3305 		*p++ = cpu_to_be32(stat.blksize);
3306 	}
3307 #endif /* CONFIG_NFSD_PNFS */
3308 	if (bmval2 & FATTR4_WORD2_SUPPATTR_EXCLCREAT) {
3309 		u32 supp[3];
3310 
3311 		memcpy(supp, nfsd_suppattrs[minorversion], sizeof(supp));
3312 		supp[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0;
3313 		supp[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1;
3314 		supp[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2;
3315 
3316 		status = nfsd4_encode_bitmap(xdr, supp[0], supp[1], supp[2]);
3317 		if (status)
3318 			goto out;
3319 	}
3320 
3321 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3322 	if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) {
3323 		status = nfsd4_encode_security_label(xdr, rqstp, context,
3324 								contextlen);
3325 		if (status)
3326 			goto out;
3327 	}
3328 #endif
3329 
3330 	if (bmval2 & FATTR4_WORD2_XATTR_SUPPORT) {
3331 		p = xdr_reserve_space(xdr, 4);
3332 		if (!p)
3333 			goto out_resource;
3334 		err = xattr_supported_namespace(d_inode(dentry),
3335 						XATTR_USER_PREFIX);
3336 		*p++ = cpu_to_be32(err == 0);
3337 	}
3338 
3339 	attrlen = htonl(xdr->buf->len - attrlen_offset - 4);
3340 	write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4);
3341 	status = nfs_ok;
3342 
3343 out:
3344 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3345 	if (context)
3346 		security_release_secctx(context, contextlen);
3347 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3348 	kfree(acl);
3349 	if (tempfh) {
3350 		fh_put(tempfh);
3351 		kfree(tempfh);
3352 	}
3353 	if (status)
3354 		xdr_truncate_encode(xdr, starting_len);
3355 	return status;
3356 out_nfserr:
3357 	status = nfserrno(err);
3358 	goto out;
3359 out_resource:
3360 	status = nfserr_resource;
3361 	goto out;
3362 }
3363 
3364 static void svcxdr_init_encode_from_buffer(struct xdr_stream *xdr,
3365 				struct xdr_buf *buf, __be32 *p, int bytes)
3366 {
3367 	xdr->scratch.iov_len = 0;
3368 	memset(buf, 0, sizeof(struct xdr_buf));
3369 	buf->head[0].iov_base = p;
3370 	buf->head[0].iov_len = 0;
3371 	buf->len = 0;
3372 	xdr->buf = buf;
3373 	xdr->iov = buf->head;
3374 	xdr->p = p;
3375 	xdr->end = (void *)p + bytes;
3376 	buf->buflen = bytes;
3377 }
3378 
3379 __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
3380 			struct svc_fh *fhp, struct svc_export *exp,
3381 			struct dentry *dentry, u32 *bmval,
3382 			struct svc_rqst *rqstp, int ignore_crossmnt)
3383 {
3384 	struct xdr_buf dummy;
3385 	struct xdr_stream xdr;
3386 	__be32 ret;
3387 
3388 	svcxdr_init_encode_from_buffer(&xdr, &dummy, *p, words << 2);
3389 	ret = nfsd4_encode_fattr(&xdr, fhp, exp, dentry, bmval, rqstp,
3390 							ignore_crossmnt);
3391 	*p = xdr.p;
3392 	return ret;
3393 }
3394 
3395 static inline int attributes_need_mount(u32 *bmval)
3396 {
3397 	if (bmval[0] & ~(FATTR4_WORD0_RDATTR_ERROR | FATTR4_WORD0_LEASE_TIME))
3398 		return 1;
3399 	if (bmval[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID)
3400 		return 1;
3401 	return 0;
3402 }
3403 
3404 static __be32
3405 nfsd4_encode_dirent_fattr(struct xdr_stream *xdr, struct nfsd4_readdir *cd,
3406 			const char *name, int namlen)
3407 {
3408 	struct svc_export *exp = cd->rd_fhp->fh_export;
3409 	struct dentry *dentry;
3410 	__be32 nfserr;
3411 	int ignore_crossmnt = 0;
3412 
3413 	dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);
3414 	if (IS_ERR(dentry))
3415 		return nfserrno(PTR_ERR(dentry));
3416 
3417 	exp_get(exp);
3418 	/*
3419 	 * In the case of a mountpoint, the client may be asking for
3420 	 * attributes that are only properties of the underlying filesystem
3421 	 * as opposed to the cross-mounted file system. In such a case,
3422 	 * we will not follow the cross mount and will fill the attribtutes
3423 	 * directly from the mountpoint dentry.
3424 	 */
3425 	if (nfsd_mountpoint(dentry, exp)) {
3426 		int err;
3427 
3428 		if (!(exp->ex_flags & NFSEXP_V4ROOT)
3429 				&& !attributes_need_mount(cd->rd_bmval)) {
3430 			ignore_crossmnt = 1;
3431 			goto out_encode;
3432 		}
3433 		/*
3434 		 * Why the heck aren't we just using nfsd_lookup??
3435 		 * Different "."/".." handling?  Something else?
3436 		 * At least, add a comment here to explain....
3437 		 */
3438 		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);
3439 		if (err) {
3440 			nfserr = nfserrno(err);
3441 			goto out_put;
3442 		}
3443 		nfserr = check_nfsd_access(exp, cd->rd_rqstp);
3444 		if (nfserr)
3445 			goto out_put;
3446 
3447 	}
3448 out_encode:
3449 	nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval,
3450 					cd->rd_rqstp, ignore_crossmnt);
3451 out_put:
3452 	dput(dentry);
3453 	exp_put(exp);
3454 	return nfserr;
3455 }
3456 
3457 static __be32 *
3458 nfsd4_encode_rdattr_error(struct xdr_stream *xdr, __be32 nfserr)
3459 {
3460 	__be32 *p;
3461 
3462 	p = xdr_reserve_space(xdr, 20);
3463 	if (!p)
3464 		return NULL;
3465 	*p++ = htonl(2);
3466 	*p++ = htonl(FATTR4_WORD0_RDATTR_ERROR); /* bmval0 */
3467 	*p++ = htonl(0);			 /* bmval1 */
3468 
3469 	*p++ = htonl(4);     /* attribute length */
3470 	*p++ = nfserr;       /* no htonl */
3471 	return p;
3472 }
3473 
3474 static int
3475 nfsd4_encode_dirent(void *ccdv, const char *name, int namlen,
3476 		    loff_t offset, u64 ino, unsigned int d_type)
3477 {
3478 	struct readdir_cd *ccd = ccdv;
3479 	struct nfsd4_readdir *cd = container_of(ccd, struct nfsd4_readdir, common);
3480 	struct xdr_stream *xdr = cd->xdr;
3481 	int start_offset = xdr->buf->len;
3482 	int cookie_offset;
3483 	u32 name_and_cookie;
3484 	int entry_bytes;
3485 	__be32 nfserr = nfserr_toosmall;
3486 	__be64 wire_offset;
3487 	__be32 *p;
3488 
3489 	/* In nfsv4, "." and ".." never make it onto the wire.. */
3490 	if (name && isdotent(name, namlen)) {
3491 		cd->common.err = nfs_ok;
3492 		return 0;
3493 	}
3494 
3495 	if (cd->cookie_offset) {
3496 		wire_offset = cpu_to_be64(offset);
3497 		write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset,
3498 							&wire_offset, 8);
3499 	}
3500 
3501 	p = xdr_reserve_space(xdr, 4);
3502 	if (!p)
3503 		goto fail;
3504 	*p++ = xdr_one;                             /* mark entry present */
3505 	cookie_offset = xdr->buf->len;
3506 	p = xdr_reserve_space(xdr, 3*4 + namlen);
3507 	if (!p)
3508 		goto fail;
3509 	p = xdr_encode_hyper(p, NFS_OFFSET_MAX);    /* offset of next entry */
3510 	p = xdr_encode_array(p, name, namlen);      /* name length & name */
3511 
3512 	nfserr = nfsd4_encode_dirent_fattr(xdr, cd, name, namlen);
3513 	switch (nfserr) {
3514 	case nfs_ok:
3515 		break;
3516 	case nfserr_resource:
3517 		nfserr = nfserr_toosmall;
3518 		goto fail;
3519 	case nfserr_noent:
3520 		xdr_truncate_encode(xdr, start_offset);
3521 		goto skip_entry;
3522 	default:
3523 		/*
3524 		 * If the client requested the RDATTR_ERROR attribute,
3525 		 * we stuff the error code into this attribute
3526 		 * and continue.  If this attribute was not requested,
3527 		 * then in accordance with the spec, we fail the
3528 		 * entire READDIR operation(!)
3529 		 */
3530 		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))
3531 			goto fail;
3532 		p = nfsd4_encode_rdattr_error(xdr, nfserr);
3533 		if (p == NULL) {
3534 			nfserr = nfserr_toosmall;
3535 			goto fail;
3536 		}
3537 	}
3538 	nfserr = nfserr_toosmall;
3539 	entry_bytes = xdr->buf->len - start_offset;
3540 	if (entry_bytes > cd->rd_maxcount)
3541 		goto fail;
3542 	cd->rd_maxcount -= entry_bytes;
3543 	/*
3544 	 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and
3545 	 * notes that it could be zero. If it is zero, then the server
3546 	 * should enforce only the rd_maxcount value.
3547 	 */
3548 	if (cd->rd_dircount) {
3549 		name_and_cookie = 4 + 4 * XDR_QUADLEN(namlen) + 8;
3550 		if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)
3551 			goto fail;
3552 		cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);
3553 		if (!cd->rd_dircount)
3554 			cd->rd_maxcount = 0;
3555 	}
3556 
3557 	cd->cookie_offset = cookie_offset;
3558 skip_entry:
3559 	cd->common.err = nfs_ok;
3560 	return 0;
3561 fail:
3562 	xdr_truncate_encode(xdr, start_offset);
3563 	cd->common.err = nfserr;
3564 	return -EINVAL;
3565 }
3566 
3567 static __be32
3568 nfsd4_encode_stateid(struct xdr_stream *xdr, stateid_t *sid)
3569 {
3570 	__be32 *p;
3571 
3572 	p = xdr_reserve_space(xdr, sizeof(stateid_t));
3573 	if (!p)
3574 		return nfserr_resource;
3575 	*p++ = cpu_to_be32(sid->si_generation);
3576 	p = xdr_encode_opaque_fixed(p, &sid->si_opaque,
3577 					sizeof(stateid_opaque_t));
3578 	return 0;
3579 }
3580 
3581 static __be32
3582 nfsd4_encode_access(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_access *access)
3583 {
3584 	struct xdr_stream *xdr = resp->xdr;
3585 	__be32 *p;
3586 
3587 	p = xdr_reserve_space(xdr, 8);
3588 	if (!p)
3589 		return nfserr_resource;
3590 	*p++ = cpu_to_be32(access->ac_supported);
3591 	*p++ = cpu_to_be32(access->ac_resp_access);
3592 	return 0;
3593 }
3594 
3595 static __be32 nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_bind_conn_to_session *bcts)
3596 {
3597 	struct xdr_stream *xdr = resp->xdr;
3598 	__be32 *p;
3599 
3600 	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 8);
3601 	if (!p)
3602 		return nfserr_resource;
3603 	p = xdr_encode_opaque_fixed(p, bcts->sessionid.data,
3604 					NFS4_MAX_SESSIONID_LEN);
3605 	*p++ = cpu_to_be32(bcts->dir);
3606 	/* Upshifting from TCP to RDMA is not supported */
3607 	*p++ = cpu_to_be32(0);
3608 	return 0;
3609 }
3610 
3611 static __be32
3612 nfsd4_encode_close(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_close *close)
3613 {
3614 	struct xdr_stream *xdr = resp->xdr;
3615 
3616 	return nfsd4_encode_stateid(xdr, &close->cl_stateid);
3617 }
3618 
3619 
3620 static __be32
3621 nfsd4_encode_commit(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_commit *commit)
3622 {
3623 	struct xdr_stream *xdr = resp->xdr;
3624 	__be32 *p;
3625 
3626 	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
3627 	if (!p)
3628 		return nfserr_resource;
3629 	p = xdr_encode_opaque_fixed(p, commit->co_verf.data,
3630 						NFS4_VERIFIER_SIZE);
3631 	return 0;
3632 }
3633 
3634 static __be32
3635 nfsd4_encode_create(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_create *create)
3636 {
3637 	struct xdr_stream *xdr = resp->xdr;
3638 	__be32 *p;
3639 
3640 	p = xdr_reserve_space(xdr, 20);
3641 	if (!p)
3642 		return nfserr_resource;
3643 	encode_cinfo(p, &create->cr_cinfo);
3644 	return nfsd4_encode_bitmap(xdr, create->cr_bmval[0],
3645 			create->cr_bmval[1], create->cr_bmval[2]);
3646 }
3647 
3648 static __be32
3649 nfsd4_encode_getattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_getattr *getattr)
3650 {
3651 	struct svc_fh *fhp = getattr->ga_fhp;
3652 	struct xdr_stream *xdr = resp->xdr;
3653 
3654 	return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry,
3655 				    getattr->ga_bmval, resp->rqstp, 0);
3656 }
3657 
3658 static __be32
3659 nfsd4_encode_getfh(struct nfsd4_compoundres *resp, __be32 nfserr, struct svc_fh **fhpp)
3660 {
3661 	struct xdr_stream *xdr = resp->xdr;
3662 	struct svc_fh *fhp = *fhpp;
3663 	unsigned int len;
3664 	__be32 *p;
3665 
3666 	len = fhp->fh_handle.fh_size;
3667 	p = xdr_reserve_space(xdr, len + 4);
3668 	if (!p)
3669 		return nfserr_resource;
3670 	p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, len);
3671 	return 0;
3672 }
3673 
3674 /*
3675 * Including all fields other than the name, a LOCK4denied structure requires
3676 *   8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3677 */
3678 static __be32
3679 nfsd4_encode_lock_denied(struct xdr_stream *xdr, struct nfsd4_lock_denied *ld)
3680 {
3681 	struct xdr_netobj *conf = &ld->ld_owner;
3682 	__be32 *p;
3683 
3684 again:
3685 	p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len));
3686 	if (!p) {
3687 		/*
3688 		 * Don't fail to return the result just because we can't
3689 		 * return the conflicting open:
3690 		 */
3691 		if (conf->len) {
3692 			kfree(conf->data);
3693 			conf->len = 0;
3694 			conf->data = NULL;
3695 			goto again;
3696 		}
3697 		return nfserr_resource;
3698 	}
3699 	p = xdr_encode_hyper(p, ld->ld_start);
3700 	p = xdr_encode_hyper(p, ld->ld_length);
3701 	*p++ = cpu_to_be32(ld->ld_type);
3702 	if (conf->len) {
3703 		p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8);
3704 		p = xdr_encode_opaque(p, conf->data, conf->len);
3705 		kfree(conf->data);
3706 	}  else {  /* non - nfsv4 lock in conflict, no clientid nor owner */
3707 		p = xdr_encode_hyper(p, (u64)0); /* clientid */
3708 		*p++ = cpu_to_be32(0); /* length of owner name */
3709 	}
3710 	return nfserr_denied;
3711 }
3712 
3713 static __be32
3714 nfsd4_encode_lock(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lock *lock)
3715 {
3716 	struct xdr_stream *xdr = resp->xdr;
3717 
3718 	if (!nfserr)
3719 		nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid);
3720 	else if (nfserr == nfserr_denied)
3721 		nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied);
3722 
3723 	return nfserr;
3724 }
3725 
3726 static __be32
3727 nfsd4_encode_lockt(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_lockt *lockt)
3728 {
3729 	struct xdr_stream *xdr = resp->xdr;
3730 
3731 	if (nfserr == nfserr_denied)
3732 		nfsd4_encode_lock_denied(xdr, &lockt->lt_denied);
3733 	return nfserr;
3734 }
3735 
3736 static __be32
3737 nfsd4_encode_locku(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_locku *locku)
3738 {
3739 	struct xdr_stream *xdr = resp->xdr;
3740 
3741 	return nfsd4_encode_stateid(xdr, &locku->lu_stateid);
3742 }
3743 
3744 
3745 static __be32
3746 nfsd4_encode_link(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_link *link)
3747 {
3748 	struct xdr_stream *xdr = resp->xdr;
3749 	__be32 *p;
3750 
3751 	p = xdr_reserve_space(xdr, 20);
3752 	if (!p)
3753 		return nfserr_resource;
3754 	p = encode_cinfo(p, &link->li_cinfo);
3755 	return 0;
3756 }
3757 
3758 
3759 static __be32
3760 nfsd4_encode_open(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open *open)
3761 {
3762 	struct xdr_stream *xdr = resp->xdr;
3763 	__be32 *p;
3764 
3765 	nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid);
3766 	if (nfserr)
3767 		return nfserr;
3768 	p = xdr_reserve_space(xdr, 24);
3769 	if (!p)
3770 		return nfserr_resource;
3771 	p = encode_cinfo(p, &open->op_cinfo);
3772 	*p++ = cpu_to_be32(open->op_rflags);
3773 
3774 	nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1],
3775 					open->op_bmval[2]);
3776 	if (nfserr)
3777 		return nfserr;
3778 
3779 	p = xdr_reserve_space(xdr, 4);
3780 	if (!p)
3781 		return nfserr_resource;
3782 
3783 	*p++ = cpu_to_be32(open->op_delegate_type);
3784 	switch (open->op_delegate_type) {
3785 	case NFS4_OPEN_DELEGATE_NONE:
3786 		break;
3787 	case NFS4_OPEN_DELEGATE_READ:
3788 		nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3789 		if (nfserr)
3790 			return nfserr;
3791 		p = xdr_reserve_space(xdr, 20);
3792 		if (!p)
3793 			return nfserr_resource;
3794 		*p++ = cpu_to_be32(open->op_recall);
3795 
3796 		/*
3797 		 * TODO: ACE's in delegations
3798 		 */
3799 		*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3800 		*p++ = cpu_to_be32(0);
3801 		*p++ = cpu_to_be32(0);
3802 		*p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3803 		break;
3804 	case NFS4_OPEN_DELEGATE_WRITE:
3805 		nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid);
3806 		if (nfserr)
3807 			return nfserr;
3808 		p = xdr_reserve_space(xdr, 32);
3809 		if (!p)
3810 			return nfserr_resource;
3811 		*p++ = cpu_to_be32(0);
3812 
3813 		/*
3814 		 * TODO: space_limit's in delegations
3815 		 */
3816 		*p++ = cpu_to_be32(NFS4_LIMIT_SIZE);
3817 		*p++ = cpu_to_be32(~(u32)0);
3818 		*p++ = cpu_to_be32(~(u32)0);
3819 
3820 		/*
3821 		 * TODO: ACE's in delegations
3822 		 */
3823 		*p++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE);
3824 		*p++ = cpu_to_be32(0);
3825 		*p++ = cpu_to_be32(0);
3826 		*p++ = cpu_to_be32(0);   /* XXX: is NULL principal ok? */
3827 		break;
3828 	case NFS4_OPEN_DELEGATE_NONE_EXT: /* 4.1 */
3829 		switch (open->op_why_no_deleg) {
3830 		case WND4_CONTENTION:
3831 		case WND4_RESOURCE:
3832 			p = xdr_reserve_space(xdr, 8);
3833 			if (!p)
3834 				return nfserr_resource;
3835 			*p++ = cpu_to_be32(open->op_why_no_deleg);
3836 			/* deleg signaling not supported yet: */
3837 			*p++ = cpu_to_be32(0);
3838 			break;
3839 		default:
3840 			p = xdr_reserve_space(xdr, 4);
3841 			if (!p)
3842 				return nfserr_resource;
3843 			*p++ = cpu_to_be32(open->op_why_no_deleg);
3844 		}
3845 		break;
3846 	default:
3847 		BUG();
3848 	}
3849 	/* XXX save filehandle here */
3850 	return 0;
3851 }
3852 
3853 static __be32
3854 nfsd4_encode_open_confirm(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_confirm *oc)
3855 {
3856 	struct xdr_stream *xdr = resp->xdr;
3857 
3858 	return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid);
3859 }
3860 
3861 static __be32
3862 nfsd4_encode_open_downgrade(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_open_downgrade *od)
3863 {
3864 	struct xdr_stream *xdr = resp->xdr;
3865 
3866 	return nfsd4_encode_stateid(xdr, &od->od_stateid);
3867 }
3868 
3869 static __be32 nfsd4_encode_splice_read(
3870 				struct nfsd4_compoundres *resp,
3871 				struct nfsd4_read *read,
3872 				struct file *file, unsigned long maxcount)
3873 {
3874 	struct xdr_stream *xdr = resp->xdr;
3875 	struct xdr_buf *buf = xdr->buf;
3876 	int status, space_left;
3877 	u32 eof;
3878 	__be32 nfserr;
3879 	__be32 *p = xdr->p - 2;
3880 
3881 	/* Make sure there will be room for padding if needed */
3882 	if (xdr->end - xdr->p < 1)
3883 		return nfserr_resource;
3884 
3885 	nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,
3886 				  file, read->rd_offset, &maxcount, &eof);
3887 	read->rd_length = maxcount;
3888 	if (nfserr)
3889 		goto out_err;
3890 	status = svc_encode_result_payload(read->rd_rqstp,
3891 					   buf->head[0].iov_len, maxcount);
3892 	if (status) {
3893 		nfserr = nfserrno(status);
3894 		goto out_err;
3895 	}
3896 
3897 	*(p++) = htonl(eof);
3898 	*(p++) = htonl(maxcount);
3899 
3900 	buf->page_len = maxcount;
3901 	buf->len += maxcount;
3902 	xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1)
3903 							/ PAGE_SIZE;
3904 
3905 	/* Use rest of head for padding and remaining ops: */
3906 	buf->tail[0].iov_base = xdr->p;
3907 	buf->tail[0].iov_len = 0;
3908 	xdr->iov = buf->tail;
3909 	if (maxcount&3) {
3910 		int pad = 4 - (maxcount&3);
3911 
3912 		*(xdr->p++) = 0;
3913 
3914 		buf->tail[0].iov_base += maxcount&3;
3915 		buf->tail[0].iov_len = pad;
3916 		buf->len += pad;
3917 	}
3918 
3919 	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,
3920 				buf->buflen - buf->len);
3921 	buf->buflen = buf->len + space_left;
3922 	xdr->end = (__be32 *)((void *)xdr->end + space_left);
3923 
3924 	return 0;
3925 
3926 out_err:
3927 	/*
3928 	 * nfsd_splice_actor may have already messed with the
3929 	 * page length; reset it so as not to confuse
3930 	 * xdr_truncate_encode in our caller.
3931 	 */
3932 	buf->page_len = 0;
3933 	return nfserr;
3934 }
3935 
3936 static __be32 nfsd4_encode_readv(struct nfsd4_compoundres *resp,
3937 				 struct nfsd4_read *read,
3938 				 struct file *file, unsigned long maxcount)
3939 {
3940 	struct xdr_stream *xdr = resp->xdr;
3941 	u32 eof;
3942 	int starting_len = xdr->buf->len - 8;
3943 	__be32 nfserr;
3944 	__be32 tmp;
3945 	int pad;
3946 
3947 	read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, maxcount);
3948 	if (read->rd_vlen < 0)
3949 		return nfserr_resource;
3950 
3951 	nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
3952 			    resp->rqstp->rq_vec, read->rd_vlen, &maxcount,
3953 			    &eof);
3954 	read->rd_length = maxcount;
3955 	if (nfserr)
3956 		return nfserr;
3957 	if (svc_encode_result_payload(resp->rqstp, starting_len + 8, maxcount))
3958 		return nfserr_io;
3959 	xdr_truncate_encode(xdr, starting_len + 8 + xdr_align_size(maxcount));
3960 
3961 	tmp = htonl(eof);
3962 	write_bytes_to_xdr_buf(xdr->buf, starting_len    , &tmp, 4);
3963 	tmp = htonl(maxcount);
3964 	write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
3965 
3966 	tmp = xdr_zero;
3967 	pad = (maxcount&3) ? 4 - (maxcount&3) : 0;
3968 	write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount,
3969 								&tmp, pad);
3970 	return 0;
3971 
3972 }
3973 
3974 static __be32
3975 nfsd4_encode_read(struct nfsd4_compoundres *resp, __be32 nfserr,
3976 		  struct nfsd4_read *read)
3977 {
3978 	unsigned long maxcount;
3979 	struct xdr_stream *xdr = resp->xdr;
3980 	struct file *file;
3981 	int starting_len = xdr->buf->len;
3982 	__be32 *p;
3983 
3984 	if (nfserr)
3985 		return nfserr;
3986 	file = read->rd_nf->nf_file;
3987 
3988 	p = xdr_reserve_space(xdr, 8); /* eof flag and byte count */
3989 	if (!p) {
3990 		WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags));
3991 		return nfserr_resource;
3992 	}
3993 	if (resp->xdr->buf->page_len &&
3994 	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) {
3995 		WARN_ON_ONCE(1);
3996 		return nfserr_resource;
3997 	}
3998 	xdr_commit_encode(xdr);
3999 
4000 	maxcount = svc_max_payload(resp->rqstp);
4001 	maxcount = min_t(unsigned long, maxcount,
4002 			 (xdr->buf->buflen - xdr->buf->len));
4003 	maxcount = min_t(unsigned long, maxcount, read->rd_length);
4004 
4005 	if (file->f_op->splice_read &&
4006 	    test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags))
4007 		nfserr = nfsd4_encode_splice_read(resp, read, file, maxcount);
4008 	else
4009 		nfserr = nfsd4_encode_readv(resp, read, file, maxcount);
4010 
4011 	if (nfserr)
4012 		xdr_truncate_encode(xdr, starting_len);
4013 
4014 	return nfserr;
4015 }
4016 
4017 static __be32
4018 nfsd4_encode_readlink(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readlink *readlink)
4019 {
4020 	int maxcount;
4021 	__be32 wire_count;
4022 	int zero = 0;
4023 	struct xdr_stream *xdr = resp->xdr;
4024 	int length_offset = xdr->buf->len;
4025 	int status;
4026 	__be32 *p;
4027 
4028 	p = xdr_reserve_space(xdr, 4);
4029 	if (!p)
4030 		return nfserr_resource;
4031 	maxcount = PAGE_SIZE;
4032 
4033 	p = xdr_reserve_space(xdr, maxcount);
4034 	if (!p)
4035 		return nfserr_resource;
4036 	/*
4037 	 * XXX: By default, vfs_readlink() will truncate symlinks if they
4038 	 * would overflow the buffer.  Is this kosher in NFSv4?  If not, one
4039 	 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4040 	 * that truncation occurred, and return NFS4ERR_RESOURCE.
4041 	 */
4042 	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,
4043 						(char *)p, &maxcount);
4044 	if (nfserr == nfserr_isdir)
4045 		nfserr = nfserr_inval;
4046 	if (nfserr)
4047 		goto out_err;
4048 	status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,
4049 					   maxcount);
4050 	if (status) {
4051 		nfserr = nfserrno(status);
4052 		goto out_err;
4053 	}
4054 
4055 	wire_count = htonl(maxcount);
4056 	write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4);
4057 	xdr_truncate_encode(xdr, length_offset + 4 + ALIGN(maxcount, 4));
4058 	if (maxcount & 3)
4059 		write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount,
4060 						&zero, 4 - (maxcount&3));
4061 	return 0;
4062 
4063 out_err:
4064 	xdr_truncate_encode(xdr, length_offset);
4065 	return nfserr;
4066 }
4067 
4068 static __be32
4069 nfsd4_encode_readdir(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_readdir *readdir)
4070 {
4071 	int maxcount;
4072 	int bytes_left;
4073 	loff_t offset;
4074 	__be64 wire_offset;
4075 	struct xdr_stream *xdr = resp->xdr;
4076 	int starting_len = xdr->buf->len;
4077 	__be32 *p;
4078 
4079 	p = xdr_reserve_space(xdr, NFS4_VERIFIER_SIZE);
4080 	if (!p)
4081 		return nfserr_resource;
4082 
4083 	/* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
4084 	*p++ = cpu_to_be32(0);
4085 	*p++ = cpu_to_be32(0);
4086 	xdr->buf->head[0].iov_len = (char *)xdr->p -
4087 				    (char *)xdr->buf->head[0].iov_base;
4088 
4089 	/*
4090 	 * Number of bytes left for directory entries allowing for the
4091 	 * final 8 bytes of the readdir and a following failed op:
4092 	 */
4093 	bytes_left = xdr->buf->buflen - xdr->buf->len
4094 			- COMPOUND_ERR_SLACK_SPACE - 8;
4095 	if (bytes_left < 0) {
4096 		nfserr = nfserr_resource;
4097 		goto err_no_verf;
4098 	}
4099 	maxcount = svc_max_payload(resp->rqstp);
4100 	maxcount = min_t(u32, readdir->rd_maxcount, maxcount);
4101 	/*
4102 	 * Note the rfc defines rd_maxcount as the size of the
4103 	 * READDIR4resok structure, which includes the verifier above
4104 	 * and the 8 bytes encoded at the end of this function:
4105 	 */
4106 	if (maxcount < 16) {
4107 		nfserr = nfserr_toosmall;
4108 		goto err_no_verf;
4109 	}
4110 	maxcount = min_t(int, maxcount-16, bytes_left);
4111 
4112 	/* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
4113 	if (!readdir->rd_dircount)
4114 		readdir->rd_dircount = svc_max_payload(resp->rqstp);
4115 
4116 	readdir->xdr = xdr;
4117 	readdir->rd_maxcount = maxcount;
4118 	readdir->common.err = 0;
4119 	readdir->cookie_offset = 0;
4120 
4121 	offset = readdir->rd_cookie;
4122 	nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp,
4123 			      &offset,
4124 			      &readdir->common, nfsd4_encode_dirent);
4125 	if (nfserr == nfs_ok &&
4126 	    readdir->common.err == nfserr_toosmall &&
4127 	    xdr->buf->len == starting_len + 8) {
4128 		/* nothing encoded; which limit did we hit?: */
4129 		if (maxcount - 16 < bytes_left)
4130 			/* It was the fault of rd_maxcount: */
4131 			nfserr = nfserr_toosmall;
4132 		else
4133 			/* We ran out of buffer space: */
4134 			nfserr = nfserr_resource;
4135 	}
4136 	if (nfserr)
4137 		goto err_no_verf;
4138 
4139 	if (readdir->cookie_offset) {
4140 		wire_offset = cpu_to_be64(offset);
4141 		write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset,
4142 							&wire_offset, 8);
4143 	}
4144 
4145 	p = xdr_reserve_space(xdr, 8);
4146 	if (!p) {
4147 		WARN_ON_ONCE(1);
4148 		goto err_no_verf;
4149 	}
4150 	*p++ = 0;	/* no more entries */
4151 	*p++ = htonl(readdir->common.err == nfserr_eof);
4152 
4153 	return 0;
4154 err_no_verf:
4155 	xdr_truncate_encode(xdr, starting_len);
4156 	return nfserr;
4157 }
4158 
4159 static __be32
4160 nfsd4_encode_remove(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_remove *remove)
4161 {
4162 	struct xdr_stream *xdr = resp->xdr;
4163 	__be32 *p;
4164 
4165 	p = xdr_reserve_space(xdr, 20);
4166 	if (!p)
4167 		return nfserr_resource;
4168 	p = encode_cinfo(p, &remove->rm_cinfo);
4169 	return 0;
4170 }
4171 
4172 static __be32
4173 nfsd4_encode_rename(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_rename *rename)
4174 {
4175 	struct xdr_stream *xdr = resp->xdr;
4176 	__be32 *p;
4177 
4178 	p = xdr_reserve_space(xdr, 40);
4179 	if (!p)
4180 		return nfserr_resource;
4181 	p = encode_cinfo(p, &rename->rn_sinfo);
4182 	p = encode_cinfo(p, &rename->rn_tinfo);
4183 	return 0;
4184 }
4185 
4186 static __be32
4187 nfsd4_do_encode_secinfo(struct xdr_stream *xdr, struct svc_export *exp)
4188 {
4189 	u32 i, nflavs, supported;
4190 	struct exp_flavor_info *flavs;
4191 	struct exp_flavor_info def_flavs[2];
4192 	__be32 *p, *flavorsp;
4193 	static bool report = true;
4194 
4195 	if (exp->ex_nflavors) {
4196 		flavs = exp->ex_flavors;
4197 		nflavs = exp->ex_nflavors;
4198 	} else { /* Handling of some defaults in absence of real secinfo: */
4199 		flavs = def_flavs;
4200 		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {
4201 			nflavs = 2;
4202 			flavs[0].pseudoflavor = RPC_AUTH_UNIX;
4203 			flavs[1].pseudoflavor = RPC_AUTH_NULL;
4204 		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {
4205 			nflavs = 1;
4206 			flavs[0].pseudoflavor
4207 					= svcauth_gss_flavor(exp->ex_client);
4208 		} else {
4209 			nflavs = 1;
4210 			flavs[0].pseudoflavor
4211 					= exp->ex_client->flavour->flavour;
4212 		}
4213 	}
4214 
4215 	supported = 0;
4216 	p = xdr_reserve_space(xdr, 4);
4217 	if (!p)
4218 		return nfserr_resource;
4219 	flavorsp = p++;		/* to be backfilled later */
4220 
4221 	for (i = 0; i < nflavs; i++) {
4222 		rpc_authflavor_t pf = flavs[i].pseudoflavor;
4223 		struct rpcsec_gss_info info;
4224 
4225 		if (rpcauth_get_gssinfo(pf, &info) == 0) {
4226 			supported++;
4227 			p = xdr_reserve_space(xdr, 4 + 4 +
4228 					      XDR_LEN(info.oid.len) + 4 + 4);
4229 			if (!p)
4230 				return nfserr_resource;
4231 			*p++ = cpu_to_be32(RPC_AUTH_GSS);
4232 			p = xdr_encode_opaque(p,  info.oid.data, info.oid.len);
4233 			*p++ = cpu_to_be32(info.qop);
4234 			*p++ = cpu_to_be32(info.service);
4235 		} else if (pf < RPC_AUTH_MAXFLAVOR) {
4236 			supported++;
4237 			p = xdr_reserve_space(xdr, 4);
4238 			if (!p)
4239 				return nfserr_resource;
4240 			*p++ = cpu_to_be32(pf);
4241 		} else {
4242 			if (report)
4243 				pr_warn("NFS: SECINFO: security flavor %u "
4244 					"is not supported\n", pf);
4245 		}
4246 	}
4247 
4248 	if (nflavs != supported)
4249 		report = false;
4250 	*flavorsp = htonl(supported);
4251 	return 0;
4252 }
4253 
4254 static __be32
4255 nfsd4_encode_secinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4256 		     struct nfsd4_secinfo *secinfo)
4257 {
4258 	struct xdr_stream *xdr = resp->xdr;
4259 
4260 	return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);
4261 }
4262 
4263 static __be32
4264 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres *resp, __be32 nfserr,
4265 		     struct nfsd4_secinfo_no_name *secinfo)
4266 {
4267 	struct xdr_stream *xdr = resp->xdr;
4268 
4269 	return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);
4270 }
4271 
4272 /*
4273  * The SETATTR encode routine is special -- it always encodes a bitmap,
4274  * regardless of the error status.
4275  */
4276 static __be32
4277 nfsd4_encode_setattr(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setattr *setattr)
4278 {
4279 	struct xdr_stream *xdr = resp->xdr;
4280 	__be32 *p;
4281 
4282 	p = xdr_reserve_space(xdr, 16);
4283 	if (!p)
4284 		return nfserr_resource;
4285 	if (nfserr) {
4286 		*p++ = cpu_to_be32(3);
4287 		*p++ = cpu_to_be32(0);
4288 		*p++ = cpu_to_be32(0);
4289 		*p++ = cpu_to_be32(0);
4290 	}
4291 	else {
4292 		*p++ = cpu_to_be32(3);
4293 		*p++ = cpu_to_be32(setattr->sa_bmval[0]);
4294 		*p++ = cpu_to_be32(setattr->sa_bmval[1]);
4295 		*p++ = cpu_to_be32(setattr->sa_bmval[2]);
4296 	}
4297 	return nfserr;
4298 }
4299 
4300 static __be32
4301 nfsd4_encode_setclientid(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_setclientid *scd)
4302 {
4303 	struct xdr_stream *xdr = resp->xdr;
4304 	__be32 *p;
4305 
4306 	if (!nfserr) {
4307 		p = xdr_reserve_space(xdr, 8 + NFS4_VERIFIER_SIZE);
4308 		if (!p)
4309 			return nfserr_resource;
4310 		p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8);
4311 		p = xdr_encode_opaque_fixed(p, &scd->se_confirm,
4312 						NFS4_VERIFIER_SIZE);
4313 	}
4314 	else if (nfserr == nfserr_clid_inuse) {
4315 		p = xdr_reserve_space(xdr, 8);
4316 		if (!p)
4317 			return nfserr_resource;
4318 		*p++ = cpu_to_be32(0);
4319 		*p++ = cpu_to_be32(0);
4320 	}
4321 	return nfserr;
4322 }
4323 
4324 static __be32
4325 nfsd4_encode_write(struct nfsd4_compoundres *resp, __be32 nfserr, struct nfsd4_write *write)
4326 {
4327 	struct xdr_stream *xdr = resp->xdr;
4328 	__be32 *p;
4329 
4330 	p = xdr_reserve_space(xdr, 16);
4331 	if (!p)
4332 		return nfserr_resource;
4333 	*p++ = cpu_to_be32(write->wr_bytes_written);
4334 	*p++ = cpu_to_be32(write->wr_how_written);
4335 	p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
4336 						NFS4_VERIFIER_SIZE);
4337 	return 0;
4338 }
4339 
4340 static __be32
4341 nfsd4_encode_exchange_id(struct nfsd4_compoundres *resp, __be32 nfserr,
4342 			 struct nfsd4_exchange_id *exid)
4343 {
4344 	struct xdr_stream *xdr = resp->xdr;
4345 	__be32 *p;
4346 	char *major_id;
4347 	char *server_scope;
4348 	int major_id_sz;
4349 	int server_scope_sz;
4350 	uint64_t minor_id = 0;
4351 	struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);
4352 
4353 	major_id = nn->nfsd_name;
4354 	major_id_sz = strlen(nn->nfsd_name);
4355 	server_scope = nn->nfsd_name;
4356 	server_scope_sz = strlen(nn->nfsd_name);
4357 
4358 	p = xdr_reserve_space(xdr,
4359 		8 /* eir_clientid */ +
4360 		4 /* eir_sequenceid */ +
4361 		4 /* eir_flags */ +
4362 		4 /* spr_how */);
4363 	if (!p)
4364 		return nfserr_resource;
4365 
4366 	p = xdr_encode_opaque_fixed(p, &exid->clientid, 8);
4367 	*p++ = cpu_to_be32(exid->seqid);
4368 	*p++ = cpu_to_be32(exid->flags);
4369 
4370 	*p++ = cpu_to_be32(exid->spa_how);
4371 
4372 	switch (exid->spa_how) {
4373 	case SP4_NONE:
4374 		break;
4375 	case SP4_MACH_CRED:
4376 		/* spo_must_enforce bitmap: */
4377 		nfserr = nfsd4_encode_bitmap(xdr,
4378 					exid->spo_must_enforce[0],
4379 					exid->spo_must_enforce[1],
4380 					exid->spo_must_enforce[2]);
4381 		if (nfserr)
4382 			return nfserr;
4383 		/* spo_must_allow bitmap: */
4384 		nfserr = nfsd4_encode_bitmap(xdr,
4385 					exid->spo_must_allow[0],
4386 					exid->spo_must_allow[1],
4387 					exid->spo_must_allow[2]);
4388 		if (nfserr)
4389 			return nfserr;
4390 		break;
4391 	default:
4392 		WARN_ON_ONCE(1);
4393 	}
4394 
4395 	p = xdr_reserve_space(xdr,
4396 		8 /* so_minor_id */ +
4397 		4 /* so_major_id.len */ +
4398 		(XDR_QUADLEN(major_id_sz) * 4) +
4399 		4 /* eir_server_scope.len */ +
4400 		(XDR_QUADLEN(server_scope_sz) * 4) +
4401 		4 /* eir_server_impl_id.count (0) */);
4402 	if (!p)
4403 		return nfserr_resource;
4404 
4405 	/* The server_owner struct */
4406 	p = xdr_encode_hyper(p, minor_id);      /* Minor id */
4407 	/* major id */
4408 	p = xdr_encode_opaque(p, major_id, major_id_sz);
4409 
4410 	/* Server scope */
4411 	p = xdr_encode_opaque(p, server_scope, server_scope_sz);
4412 
4413 	/* Implementation id */
4414 	*p++ = cpu_to_be32(0);	/* zero length nfs_impl_id4 array */
4415 	return 0;
4416 }
4417 
4418 static __be32
4419 nfsd4_encode_create_session(struct nfsd4_compoundres *resp, __be32 nfserr,
4420 			    struct nfsd4_create_session *sess)
4421 {
4422 	struct xdr_stream *xdr = resp->xdr;
4423 	__be32 *p;
4424 
4425 	p = xdr_reserve_space(xdr, 24);
4426 	if (!p)
4427 		return nfserr_resource;
4428 	p = xdr_encode_opaque_fixed(p, sess->sessionid.data,
4429 					NFS4_MAX_SESSIONID_LEN);
4430 	*p++ = cpu_to_be32(sess->seqid);
4431 	*p++ = cpu_to_be32(sess->flags);
4432 
4433 	p = xdr_reserve_space(xdr, 28);
4434 	if (!p)
4435 		return nfserr_resource;
4436 	*p++ = cpu_to_be32(0); /* headerpadsz */
4437 	*p++ = cpu_to_be32(sess->fore_channel.maxreq_sz);
4438 	*p++ = cpu_to_be32(sess->fore_channel.maxresp_sz);
4439 	*p++ = cpu_to_be32(sess->fore_channel.maxresp_cached);
4440 	*p++ = cpu_to_be32(sess->fore_channel.maxops);
4441 	*p++ = cpu_to_be32(sess->fore_channel.maxreqs);
4442 	*p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs);
4443 
4444 	if (sess->fore_channel.nr_rdma_attrs) {
4445 		p = xdr_reserve_space(xdr, 4);
4446 		if (!p)
4447 			return nfserr_resource;
4448 		*p++ = cpu_to_be32(sess->fore_channel.rdma_attrs);
4449 	}
4450 
4451 	p = xdr_reserve_space(xdr, 28);
4452 	if (!p)
4453 		return nfserr_resource;
4454 	*p++ = cpu_to_be32(0); /* headerpadsz */
4455 	*p++ = cpu_to_be32(sess->back_channel.maxreq_sz);
4456 	*p++ = cpu_to_be32(sess->back_channel.maxresp_sz);
4457 	*p++ = cpu_to_be32(sess->back_channel.maxresp_cached);
4458 	*p++ = cpu_to_be32(sess->back_channel.maxops);
4459 	*p++ = cpu_to_be32(sess->back_channel.maxreqs);
4460 	*p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs);
4461 
4462 	if (sess->back_channel.nr_rdma_attrs) {
4463 		p = xdr_reserve_space(xdr, 4);
4464 		if (!p)
4465 			return nfserr_resource;
4466 		*p++ = cpu_to_be32(sess->back_channel.rdma_attrs);
4467 	}
4468 	return 0;
4469 }
4470 
4471 static __be32
4472 nfsd4_encode_sequence(struct nfsd4_compoundres *resp, __be32 nfserr,
4473 		      struct nfsd4_sequence *seq)
4474 {
4475 	struct xdr_stream *xdr = resp->xdr;
4476 	__be32 *p;
4477 
4478 	p = xdr_reserve_space(xdr, NFS4_MAX_SESSIONID_LEN + 20);
4479 	if (!p)
4480 		return nfserr_resource;
4481 	p = xdr_encode_opaque_fixed(p, seq->sessionid.data,
4482 					NFS4_MAX_SESSIONID_LEN);
4483 	*p++ = cpu_to_be32(seq->seqid);
4484 	*p++ = cpu_to_be32(seq->slotid);
4485 	/* Note slotid's are numbered from zero: */
4486 	*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */
4487 	*p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */
4488 	*p++ = cpu_to_be32(seq->status_flags);
4489 
4490 	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */
4491 	return 0;
4492 }
4493 
4494 static __be32
4495 nfsd4_encode_test_stateid(struct nfsd4_compoundres *resp, __be32 nfserr,
4496 			  struct nfsd4_test_stateid *test_stateid)
4497 {
4498 	struct xdr_stream *xdr = resp->xdr;
4499 	struct nfsd4_test_stateid_id *stateid, *next;
4500 	__be32 *p;
4501 
4502 	p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids));
4503 	if (!p)
4504 		return nfserr_resource;
4505 	*p++ = htonl(test_stateid->ts_num_ids);
4506 
4507 	list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) {
4508 		*p++ = stateid->ts_id_status;
4509 	}
4510 
4511 	return 0;
4512 }
4513 
4514 #ifdef CONFIG_NFSD_PNFS
4515 static __be32
4516 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres *resp, __be32 nfserr,
4517 		struct nfsd4_getdeviceinfo *gdev)
4518 {
4519 	struct xdr_stream *xdr = resp->xdr;
4520 	const struct nfsd4_layout_ops *ops;
4521 	u32 starting_len = xdr->buf->len, needed_len;
4522 	__be32 *p;
4523 
4524 	p = xdr_reserve_space(xdr, 4);
4525 	if (!p)
4526 		return nfserr_resource;
4527 
4528 	*p++ = cpu_to_be32(gdev->gd_layout_type);
4529 
4530 	/* If maxcount is 0 then just update notifications */
4531 	if (gdev->gd_maxcount != 0) {
4532 		ops = nfsd4_layout_ops[gdev->gd_layout_type];
4533 		nfserr = ops->encode_getdeviceinfo(xdr, gdev);
4534 		if (nfserr) {
4535 			/*
4536 			 * We don't bother to burden the layout drivers with
4537 			 * enforcing gd_maxcount, just tell the client to
4538 			 * come back with a bigger buffer if it's not enough.
4539 			 */
4540 			if (xdr->buf->len + 4 > gdev->gd_maxcount)
4541 				goto toosmall;
4542 			return nfserr;
4543 		}
4544 	}
4545 
4546 	if (gdev->gd_notify_types) {
4547 		p = xdr_reserve_space(xdr, 4 + 4);
4548 		if (!p)
4549 			return nfserr_resource;
4550 		*p++ = cpu_to_be32(1);			/* bitmap length */
4551 		*p++ = cpu_to_be32(gdev->gd_notify_types);
4552 	} else {
4553 		p = xdr_reserve_space(xdr, 4);
4554 		if (!p)
4555 			return nfserr_resource;
4556 		*p++ = 0;
4557 	}
4558 
4559 	return 0;
4560 toosmall:
4561 	dprintk("%s: maxcount too small\n", __func__);
4562 	needed_len = xdr->buf->len + 4 /* notifications */;
4563 	xdr_truncate_encode(xdr, starting_len);
4564 	p = xdr_reserve_space(xdr, 4);
4565 	if (!p)
4566 		return nfserr_resource;
4567 	*p++ = cpu_to_be32(needed_len);
4568 	return nfserr_toosmall;
4569 }
4570 
4571 static __be32
4572 nfsd4_encode_layoutget(struct nfsd4_compoundres *resp, __be32 nfserr,
4573 		struct nfsd4_layoutget *lgp)
4574 {
4575 	struct xdr_stream *xdr = resp->xdr;
4576 	const struct nfsd4_layout_ops *ops;
4577 	__be32 *p;
4578 
4579 	p = xdr_reserve_space(xdr, 36 + sizeof(stateid_opaque_t));
4580 	if (!p)
4581 		return nfserr_resource;
4582 
4583 	*p++ = cpu_to_be32(1);	/* we always set return-on-close */
4584 	*p++ = cpu_to_be32(lgp->lg_sid.si_generation);
4585 	p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque,
4586 				    sizeof(stateid_opaque_t));
4587 
4588 	*p++ = cpu_to_be32(1);	/* we always return a single layout */
4589 	p = xdr_encode_hyper(p, lgp->lg_seg.offset);
4590 	p = xdr_encode_hyper(p, lgp->lg_seg.length);
4591 	*p++ = cpu_to_be32(lgp->lg_seg.iomode);
4592 	*p++ = cpu_to_be32(lgp->lg_layout_type);
4593 
4594 	ops = nfsd4_layout_ops[lgp->lg_layout_type];
4595 	return ops->encode_layoutget(xdr, lgp);
4596 }
4597 
4598 static __be32
4599 nfsd4_encode_layoutcommit(struct nfsd4_compoundres *resp, __be32 nfserr,
4600 			  struct nfsd4_layoutcommit *lcp)
4601 {
4602 	struct xdr_stream *xdr = resp->xdr;
4603 	__be32 *p;
4604 
4605 	p = xdr_reserve_space(xdr, 4);
4606 	if (!p)
4607 		return nfserr_resource;
4608 	*p++ = cpu_to_be32(lcp->lc_size_chg);
4609 	if (lcp->lc_size_chg) {
4610 		p = xdr_reserve_space(xdr, 8);
4611 		if (!p)
4612 			return nfserr_resource;
4613 		p = xdr_encode_hyper(p, lcp->lc_newsize);
4614 	}
4615 
4616 	return 0;
4617 }
4618 
4619 static __be32
4620 nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
4621 		struct nfsd4_layoutreturn *lrp)
4622 {
4623 	struct xdr_stream *xdr = resp->xdr;
4624 	__be32 *p;
4625 
4626 	p = xdr_reserve_space(xdr, 4);
4627 	if (!p)
4628 		return nfserr_resource;
4629 	*p++ = cpu_to_be32(lrp->lrs_present);
4630 	if (lrp->lrs_present)
4631 		return nfsd4_encode_stateid(xdr, &lrp->lr_sid);
4632 	return 0;
4633 }
4634 #endif /* CONFIG_NFSD_PNFS */
4635 
4636 static __be32
4637 nfsd42_encode_write_res(struct nfsd4_compoundres *resp,
4638 		struct nfsd42_write_res *write, bool sync)
4639 {
4640 	__be32 *p;
4641 	p = xdr_reserve_space(resp->xdr, 4);
4642 	if (!p)
4643 		return nfserr_resource;
4644 
4645 	if (sync)
4646 		*p++ = cpu_to_be32(0);
4647 	else {
4648 		__be32 nfserr;
4649 		*p++ = cpu_to_be32(1);
4650 		nfserr = nfsd4_encode_stateid(resp->xdr, &write->cb_stateid);
4651 		if (nfserr)
4652 			return nfserr;
4653 	}
4654 	p = xdr_reserve_space(resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE);
4655 	if (!p)
4656 		return nfserr_resource;
4657 
4658 	p = xdr_encode_hyper(p, write->wr_bytes_written);
4659 	*p++ = cpu_to_be32(write->wr_stable_how);
4660 	p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
4661 				    NFS4_VERIFIER_SIZE);
4662 	return nfs_ok;
4663 }
4664 
4665 static __be32
4666 nfsd42_encode_nl4_server(struct nfsd4_compoundres *resp, struct nl4_server *ns)
4667 {
4668 	struct xdr_stream *xdr = resp->xdr;
4669 	struct nfs42_netaddr *addr;
4670 	__be32 *p;
4671 
4672 	p = xdr_reserve_space(xdr, 4);
4673 	*p++ = cpu_to_be32(ns->nl4_type);
4674 
4675 	switch (ns->nl4_type) {
4676 	case NL4_NETADDR:
4677 		addr = &ns->u.nl4_addr;
4678 
4679 		/* netid_len, netid, uaddr_len, uaddr (port included
4680 		 * in RPCBIND_MAXUADDRLEN)
4681 		 */
4682 		p = xdr_reserve_space(xdr,
4683 			4 /* netid len */ +
4684 			(XDR_QUADLEN(addr->netid_len) * 4) +
4685 			4 /* uaddr len */ +
4686 			(XDR_QUADLEN(addr->addr_len) * 4));
4687 		if (!p)
4688 			return nfserr_resource;
4689 
4690 		*p++ = cpu_to_be32(addr->netid_len);
4691 		p = xdr_encode_opaque_fixed(p, addr->netid,
4692 					    addr->netid_len);
4693 		*p++ = cpu_to_be32(addr->addr_len);
4694 		p = xdr_encode_opaque_fixed(p, addr->addr,
4695 					addr->addr_len);
4696 		break;
4697 	default:
4698 		WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR);
4699 		return nfserr_inval;
4700 	}
4701 
4702 	return 0;
4703 }
4704 
4705 static __be32
4706 nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
4707 		  struct nfsd4_copy *copy)
4708 {
4709 	__be32 *p;
4710 
4711 	nfserr = nfsd42_encode_write_res(resp, &copy->cp_res,
4712 					 !!copy->cp_synchronous);
4713 	if (nfserr)
4714 		return nfserr;
4715 
4716 	p = xdr_reserve_space(resp->xdr, 4 + 4);
4717 	*p++ = xdr_one; /* cr_consecutive */
4718 	*p++ = cpu_to_be32(copy->cp_synchronous);
4719 	return 0;
4720 }
4721 
4722 static __be32
4723 nfsd4_encode_offload_status(struct nfsd4_compoundres *resp, __be32 nfserr,
4724 			    struct nfsd4_offload_status *os)
4725 {
4726 	struct xdr_stream *xdr = resp->xdr;
4727 	__be32 *p;
4728 
4729 	p = xdr_reserve_space(xdr, 8 + 4);
4730 	if (!p)
4731 		return nfserr_resource;
4732 	p = xdr_encode_hyper(p, os->count);
4733 	*p++ = cpu_to_be32(0);
4734 	return nfserr;
4735 }
4736 
4737 static __be32
4738 nfsd4_encode_read_plus_data(struct nfsd4_compoundres *resp,
4739 			    struct nfsd4_read *read,
4740 			    unsigned long *maxcount, u32 *eof,
4741 			    loff_t *pos)
4742 {
4743 	struct xdr_stream *xdr = resp->xdr;
4744 	struct file *file = read->rd_nf->nf_file;
4745 	int starting_len = xdr->buf->len;
4746 	loff_t hole_pos;
4747 	__be32 nfserr;
4748 	__be32 *p, tmp;
4749 	__be64 tmp64;
4750 
4751 	hole_pos = pos ? *pos : vfs_llseek(file, read->rd_offset, SEEK_HOLE);
4752 	if (hole_pos > read->rd_offset)
4753 		*maxcount = min_t(unsigned long, *maxcount, hole_pos - read->rd_offset);
4754 	*maxcount = min_t(unsigned long, *maxcount, (xdr->buf->buflen - xdr->buf->len));
4755 
4756 	/* Content type, offset, byte count */
4757 	p = xdr_reserve_space(xdr, 4 + 8 + 4);
4758 	if (!p)
4759 		return nfserr_resource;
4760 
4761 	read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, *maxcount);
4762 	if (read->rd_vlen < 0)
4763 		return nfserr_resource;
4764 
4765 	nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset,
4766 			    resp->rqstp->rq_vec, read->rd_vlen, maxcount, eof);
4767 	if (nfserr)
4768 		return nfserr;
4769 	xdr_truncate_encode(xdr, starting_len + 16 + xdr_align_size(*maxcount));
4770 
4771 	tmp = htonl(NFS4_CONTENT_DATA);
4772 	write_bytes_to_xdr_buf(xdr->buf, starting_len,      &tmp,   4);
4773 	tmp64 = cpu_to_be64(read->rd_offset);
4774 	write_bytes_to_xdr_buf(xdr->buf, starting_len + 4,  &tmp64, 8);
4775 	tmp = htonl(*maxcount);
4776 	write_bytes_to_xdr_buf(xdr->buf, starting_len + 12, &tmp,   4);
4777 
4778 	tmp = xdr_zero;
4779 	write_bytes_to_xdr_buf(xdr->buf, starting_len + 16 + *maxcount, &tmp,
4780 			       xdr_pad_size(*maxcount));
4781 	return nfs_ok;
4782 }
4783 
4784 static __be32
4785 nfsd4_encode_read_plus_hole(struct nfsd4_compoundres *resp,
4786 			    struct nfsd4_read *read,
4787 			    unsigned long *maxcount, u32 *eof)
4788 {
4789 	struct file *file = read->rd_nf->nf_file;
4790 	loff_t data_pos = vfs_llseek(file, read->rd_offset, SEEK_DATA);
4791 	loff_t f_size = i_size_read(file_inode(file));
4792 	unsigned long count;
4793 	__be32 *p;
4794 
4795 	if (data_pos == -ENXIO)
4796 		data_pos = f_size;
4797 	else if (data_pos <= read->rd_offset || (data_pos < f_size && data_pos % PAGE_SIZE))
4798 		return nfsd4_encode_read_plus_data(resp, read, maxcount, eof, &f_size);
4799 	count = data_pos - read->rd_offset;
4800 
4801 	/* Content type, offset, byte count */
4802 	p = xdr_reserve_space(resp->xdr, 4 + 8 + 8);
4803 	if (!p)
4804 		return nfserr_resource;
4805 
4806 	*p++ = htonl(NFS4_CONTENT_HOLE);
4807 	 p   = xdr_encode_hyper(p, read->rd_offset);
4808 	 p   = xdr_encode_hyper(p, count);
4809 
4810 	*eof = (read->rd_offset + count) >= f_size;
4811 	*maxcount = min_t(unsigned long, count, *maxcount);
4812 	return nfs_ok;
4813 }
4814 
4815 static __be32
4816 nfsd4_encode_read_plus(struct nfsd4_compoundres *resp, __be32 nfserr,
4817 		       struct nfsd4_read *read)
4818 {
4819 	unsigned long maxcount, count;
4820 	struct xdr_stream *xdr = resp->xdr;
4821 	struct file *file;
4822 	int starting_len = xdr->buf->len;
4823 	int last_segment = xdr->buf->len;
4824 	int segments = 0;
4825 	__be32 *p, tmp;
4826 	bool is_data;
4827 	loff_t pos;
4828 	u32 eof;
4829 
4830 	if (nfserr)
4831 		return nfserr;
4832 	file = read->rd_nf->nf_file;
4833 
4834 	/* eof flag, segment count */
4835 	p = xdr_reserve_space(xdr, 4 + 4);
4836 	if (!p)
4837 		return nfserr_resource;
4838 	xdr_commit_encode(xdr);
4839 
4840 	maxcount = svc_max_payload(resp->rqstp);
4841 	maxcount = min_t(unsigned long, maxcount,
4842 			 (xdr->buf->buflen - xdr->buf->len));
4843 	maxcount = min_t(unsigned long, maxcount, read->rd_length);
4844 	count    = maxcount;
4845 
4846 	eof = read->rd_offset >= i_size_read(file_inode(file));
4847 	if (eof)
4848 		goto out;
4849 
4850 	pos = vfs_llseek(file, read->rd_offset, SEEK_HOLE);
4851 	is_data = pos > read->rd_offset;
4852 
4853 	while (count > 0 && !eof) {
4854 		maxcount = count;
4855 		if (is_data)
4856 			nfserr = nfsd4_encode_read_plus_data(resp, read, &maxcount, &eof,
4857 						segments == 0 ? &pos : NULL);
4858 		else
4859 			nfserr = nfsd4_encode_read_plus_hole(resp, read, &maxcount, &eof);
4860 		if (nfserr)
4861 			goto out;
4862 		count -= maxcount;
4863 		read->rd_offset += maxcount;
4864 		is_data = !is_data;
4865 		last_segment = xdr->buf->len;
4866 		segments++;
4867 	}
4868 
4869 out:
4870 	if (nfserr && segments == 0)
4871 		xdr_truncate_encode(xdr, starting_len);
4872 	else {
4873 		if (nfserr) {
4874 			xdr_truncate_encode(xdr, last_segment);
4875 			nfserr = nfs_ok;
4876 			eof = 0;
4877 		}
4878 		tmp = htonl(eof);
4879 		write_bytes_to_xdr_buf(xdr->buf, starting_len,     &tmp, 4);
4880 		tmp = htonl(segments);
4881 		write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4);
4882 	}
4883 
4884 	return nfserr;
4885 }
4886 
4887 static __be32
4888 nfsd4_encode_copy_notify(struct nfsd4_compoundres *resp, __be32 nfserr,
4889 			 struct nfsd4_copy_notify *cn)
4890 {
4891 	struct xdr_stream *xdr = resp->xdr;
4892 	__be32 *p;
4893 
4894 	if (nfserr)
4895 		return nfserr;
4896 
4897 	/* 8 sec, 4 nsec */
4898 	p = xdr_reserve_space(xdr, 12);
4899 	if (!p)
4900 		return nfserr_resource;
4901 
4902 	/* cnr_lease_time */
4903 	p = xdr_encode_hyper(p, cn->cpn_sec);
4904 	*p++ = cpu_to_be32(cn->cpn_nsec);
4905 
4906 	/* cnr_stateid */
4907 	nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid);
4908 	if (nfserr)
4909 		return nfserr;
4910 
4911 	/* cnr_src.nl_nsvr */
4912 	p = xdr_reserve_space(xdr, 4);
4913 	if (!p)
4914 		return nfserr_resource;
4915 
4916 	*p++ = cpu_to_be32(1);
4917 
4918 	return nfsd42_encode_nl4_server(resp, &cn->cpn_src);
4919 }
4920 
4921 static __be32
4922 nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
4923 		  struct nfsd4_seek *seek)
4924 {
4925 	__be32 *p;
4926 
4927 	p = xdr_reserve_space(resp->xdr, 4 + 8);
4928 	*p++ = cpu_to_be32(seek->seek_eof);
4929 	p = xdr_encode_hyper(p, seek->seek_pos);
4930 
4931 	return 0;
4932 }
4933 
4934 static __be32
4935 nfsd4_encode_noop(struct nfsd4_compoundres *resp, __be32 nfserr, void *p)
4936 {
4937 	return nfserr;
4938 }
4939 
4940 /*
4941  * Encode kmalloc-ed buffer in to XDR stream.
4942  */
4943 static __be32
4944 nfsd4_vbuf_to_stream(struct xdr_stream *xdr, char *buf, u32 buflen)
4945 {
4946 	u32 cplen;
4947 	__be32 *p;
4948 
4949 	cplen = min_t(unsigned long, buflen,
4950 		      ((void *)xdr->end - (void *)xdr->p));
4951 	p = xdr_reserve_space(xdr, cplen);
4952 	if (!p)
4953 		return nfserr_resource;
4954 
4955 	memcpy(p, buf, cplen);
4956 	buf += cplen;
4957 	buflen -= cplen;
4958 
4959 	while (buflen) {
4960 		cplen = min_t(u32, buflen, PAGE_SIZE);
4961 		p = xdr_reserve_space(xdr, cplen);
4962 		if (!p)
4963 			return nfserr_resource;
4964 
4965 		memcpy(p, buf, cplen);
4966 
4967 		if (cplen < PAGE_SIZE) {
4968 			/*
4969 			 * We're done, with a length that wasn't page
4970 			 * aligned, so possibly not word aligned. Pad
4971 			 * any trailing bytes with 0.
4972 			 */
4973 			xdr_encode_opaque_fixed(p, NULL, cplen);
4974 			break;
4975 		}
4976 
4977 		buflen -= PAGE_SIZE;
4978 		buf += PAGE_SIZE;
4979 	}
4980 
4981 	return 0;
4982 }
4983 
4984 static __be32
4985 nfsd4_encode_getxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
4986 		      struct nfsd4_getxattr *getxattr)
4987 {
4988 	struct xdr_stream *xdr = resp->xdr;
4989 	__be32 *p, err;
4990 
4991 	p = xdr_reserve_space(xdr, 4);
4992 	if (!p)
4993 		return nfserr_resource;
4994 
4995 	*p = cpu_to_be32(getxattr->getxa_len);
4996 
4997 	if (getxattr->getxa_len == 0)
4998 		return 0;
4999 
5000 	err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,
5001 				    getxattr->getxa_len);
5002 
5003 	kvfree(getxattr->getxa_buf);
5004 
5005 	return err;
5006 }
5007 
5008 static __be32
5009 nfsd4_encode_setxattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5010 		      struct nfsd4_setxattr *setxattr)
5011 {
5012 	struct xdr_stream *xdr = resp->xdr;
5013 	__be32 *p;
5014 
5015 	p = xdr_reserve_space(xdr, 20);
5016 	if (!p)
5017 		return nfserr_resource;
5018 
5019 	encode_cinfo(p, &setxattr->setxa_cinfo);
5020 
5021 	return 0;
5022 }
5023 
5024 /*
5025  * See if there are cookie values that can be rejected outright.
5026  */
5027 static __be32
5028 nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs *listxattrs,
5029 				u32 *offsetp)
5030 {
5031 	u64 cookie = listxattrs->lsxa_cookie;
5032 
5033 	/*
5034 	 * If the cookie is larger than the maximum number we can fit
5035 	 * in either the buffer we just got back from vfs_listxattr, or,
5036 	 * XDR-encoded, in the return buffer, it's invalid.
5037 	 */
5038 	if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))
5039 		return nfserr_badcookie;
5040 
5041 	if (cookie > (listxattrs->lsxa_maxcount /
5042 		      (XDR_QUADLEN(XATTR_USER_PREFIX_LEN + 2) + 4)))
5043 		return nfserr_badcookie;
5044 
5045 	*offsetp = (u32)cookie;
5046 	return 0;
5047 }
5048 
5049 static __be32
5050 nfsd4_encode_listxattrs(struct nfsd4_compoundres *resp, __be32 nfserr,
5051 			struct nfsd4_listxattrs *listxattrs)
5052 {
5053 	struct xdr_stream *xdr = resp->xdr;
5054 	u32 cookie_offset, count_offset, eof;
5055 	u32 left, xdrleft, slen, count;
5056 	u32 xdrlen, offset;
5057 	u64 cookie;
5058 	char *sp;
5059 	__be32 status, tmp;
5060 	__be32 *p;
5061 	u32 nuser;
5062 
5063 	eof = 1;
5064 
5065 	status = nfsd4_listxattr_validate_cookie(listxattrs, &offset);
5066 	if (status)
5067 		goto out;
5068 
5069 	/*
5070 	 * Reserve space for the cookie and the name array count. Record
5071 	 * the offsets to save them later.
5072 	 */
5073 	cookie_offset = xdr->buf->len;
5074 	count_offset = cookie_offset + 8;
5075 	p = xdr_reserve_space(xdr, 12);
5076 	if (!p) {
5077 		status = nfserr_resource;
5078 		goto out;
5079 	}
5080 
5081 	count = 0;
5082 	left = listxattrs->lsxa_len;
5083 	sp = listxattrs->lsxa_buf;
5084 	nuser = 0;
5085 
5086 	xdrleft = listxattrs->lsxa_maxcount;
5087 
5088 	while (left > 0 && xdrleft > 0) {
5089 		slen = strlen(sp);
5090 
5091 		/*
5092 		 * Check if this is a "user." attribute, skip it if not.
5093 		 */
5094 		if (strncmp(sp, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
5095 			goto contloop;
5096 
5097 		slen -= XATTR_USER_PREFIX_LEN;
5098 		xdrlen = 4 + ((slen + 3) & ~3);
5099 		if (xdrlen > xdrleft) {
5100 			if (count == 0) {
5101 				/*
5102 				 * Can't even fit the first attribute name.
5103 				 */
5104 				status = nfserr_toosmall;
5105 				goto out;
5106 			}
5107 			eof = 0;
5108 			goto wreof;
5109 		}
5110 
5111 		left -= XATTR_USER_PREFIX_LEN;
5112 		sp += XATTR_USER_PREFIX_LEN;
5113 		if (nuser++ < offset)
5114 			goto contloop;
5115 
5116 
5117 		p = xdr_reserve_space(xdr, xdrlen);
5118 		if (!p) {
5119 			status = nfserr_resource;
5120 			goto out;
5121 		}
5122 
5123 		xdr_encode_opaque(p, sp, slen);
5124 
5125 		xdrleft -= xdrlen;
5126 		count++;
5127 contloop:
5128 		sp += slen + 1;
5129 		left -= slen + 1;
5130 	}
5131 
5132 	/*
5133 	 * If there were user attributes to copy, but we didn't copy
5134 	 * any, the offset was too large (e.g. the cookie was invalid).
5135 	 */
5136 	if (nuser > 0 && count == 0) {
5137 		status = nfserr_badcookie;
5138 		goto out;
5139 	}
5140 
5141 wreof:
5142 	p = xdr_reserve_space(xdr, 4);
5143 	if (!p) {
5144 		status = nfserr_resource;
5145 		goto out;
5146 	}
5147 	*p = cpu_to_be32(eof);
5148 
5149 	cookie = offset + count;
5150 
5151 	write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8);
5152 	tmp = cpu_to_be32(count);
5153 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);
5154 out:
5155 	if (listxattrs->lsxa_len)
5156 		kvfree(listxattrs->lsxa_buf);
5157 	return status;
5158 }
5159 
5160 static __be32
5161 nfsd4_encode_removexattr(struct nfsd4_compoundres *resp, __be32 nfserr,
5162 			 struct nfsd4_removexattr *removexattr)
5163 {
5164 	struct xdr_stream *xdr = resp->xdr;
5165 	__be32 *p;
5166 
5167 	p = xdr_reserve_space(xdr, 20);
5168 	if (!p)
5169 		return nfserr_resource;
5170 
5171 	p = encode_cinfo(p, &removexattr->rmxa_cinfo);
5172 	return 0;
5173 }
5174 
5175 typedef __be32(* nfsd4_enc)(struct nfsd4_compoundres *, __be32, void *);
5176 
5177 /*
5178  * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5179  * since we don't need to filter out obsolete ops as this is
5180  * done in the decoding phase.
5181  */
5182 static const nfsd4_enc nfsd4_enc_ops[] = {
5183 	[OP_ACCESS]		= (nfsd4_enc)nfsd4_encode_access,
5184 	[OP_CLOSE]		= (nfsd4_enc)nfsd4_encode_close,
5185 	[OP_COMMIT]		= (nfsd4_enc)nfsd4_encode_commit,
5186 	[OP_CREATE]		= (nfsd4_enc)nfsd4_encode_create,
5187 	[OP_DELEGPURGE]		= (nfsd4_enc)nfsd4_encode_noop,
5188 	[OP_DELEGRETURN]	= (nfsd4_enc)nfsd4_encode_noop,
5189 	[OP_GETATTR]		= (nfsd4_enc)nfsd4_encode_getattr,
5190 	[OP_GETFH]		= (nfsd4_enc)nfsd4_encode_getfh,
5191 	[OP_LINK]		= (nfsd4_enc)nfsd4_encode_link,
5192 	[OP_LOCK]		= (nfsd4_enc)nfsd4_encode_lock,
5193 	[OP_LOCKT]		= (nfsd4_enc)nfsd4_encode_lockt,
5194 	[OP_LOCKU]		= (nfsd4_enc)nfsd4_encode_locku,
5195 	[OP_LOOKUP]		= (nfsd4_enc)nfsd4_encode_noop,
5196 	[OP_LOOKUPP]		= (nfsd4_enc)nfsd4_encode_noop,
5197 	[OP_NVERIFY]		= (nfsd4_enc)nfsd4_encode_noop,
5198 	[OP_OPEN]		= (nfsd4_enc)nfsd4_encode_open,
5199 	[OP_OPENATTR]		= (nfsd4_enc)nfsd4_encode_noop,
5200 	[OP_OPEN_CONFIRM]	= (nfsd4_enc)nfsd4_encode_open_confirm,
5201 	[OP_OPEN_DOWNGRADE]	= (nfsd4_enc)nfsd4_encode_open_downgrade,
5202 	[OP_PUTFH]		= (nfsd4_enc)nfsd4_encode_noop,
5203 	[OP_PUTPUBFH]		= (nfsd4_enc)nfsd4_encode_noop,
5204 	[OP_PUTROOTFH]		= (nfsd4_enc)nfsd4_encode_noop,
5205 	[OP_READ]		= (nfsd4_enc)nfsd4_encode_read,
5206 	[OP_READDIR]		= (nfsd4_enc)nfsd4_encode_readdir,
5207 	[OP_READLINK]		= (nfsd4_enc)nfsd4_encode_readlink,
5208 	[OP_REMOVE]		= (nfsd4_enc)nfsd4_encode_remove,
5209 	[OP_RENAME]		= (nfsd4_enc)nfsd4_encode_rename,
5210 	[OP_RENEW]		= (nfsd4_enc)nfsd4_encode_noop,
5211 	[OP_RESTOREFH]		= (nfsd4_enc)nfsd4_encode_noop,
5212 	[OP_SAVEFH]		= (nfsd4_enc)nfsd4_encode_noop,
5213 	[OP_SECINFO]		= (nfsd4_enc)nfsd4_encode_secinfo,
5214 	[OP_SETATTR]		= (nfsd4_enc)nfsd4_encode_setattr,
5215 	[OP_SETCLIENTID]	= (nfsd4_enc)nfsd4_encode_setclientid,
5216 	[OP_SETCLIENTID_CONFIRM] = (nfsd4_enc)nfsd4_encode_noop,
5217 	[OP_VERIFY]		= (nfsd4_enc)nfsd4_encode_noop,
5218 	[OP_WRITE]		= (nfsd4_enc)nfsd4_encode_write,
5219 	[OP_RELEASE_LOCKOWNER]	= (nfsd4_enc)nfsd4_encode_noop,
5220 
5221 	/* NFSv4.1 operations */
5222 	[OP_BACKCHANNEL_CTL]	= (nfsd4_enc)nfsd4_encode_noop,
5223 	[OP_BIND_CONN_TO_SESSION] = (nfsd4_enc)nfsd4_encode_bind_conn_to_session,
5224 	[OP_EXCHANGE_ID]	= (nfsd4_enc)nfsd4_encode_exchange_id,
5225 	[OP_CREATE_SESSION]	= (nfsd4_enc)nfsd4_encode_create_session,
5226 	[OP_DESTROY_SESSION]	= (nfsd4_enc)nfsd4_encode_noop,
5227 	[OP_FREE_STATEID]	= (nfsd4_enc)nfsd4_encode_noop,
5228 	[OP_GET_DIR_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
5229 #ifdef CONFIG_NFSD_PNFS
5230 	[OP_GETDEVICEINFO]	= (nfsd4_enc)nfsd4_encode_getdeviceinfo,
5231 	[OP_GETDEVICELIST]	= (nfsd4_enc)nfsd4_encode_noop,
5232 	[OP_LAYOUTCOMMIT]	= (nfsd4_enc)nfsd4_encode_layoutcommit,
5233 	[OP_LAYOUTGET]		= (nfsd4_enc)nfsd4_encode_layoutget,
5234 	[OP_LAYOUTRETURN]	= (nfsd4_enc)nfsd4_encode_layoutreturn,
5235 #else
5236 	[OP_GETDEVICEINFO]	= (nfsd4_enc)nfsd4_encode_noop,
5237 	[OP_GETDEVICELIST]	= (nfsd4_enc)nfsd4_encode_noop,
5238 	[OP_LAYOUTCOMMIT]	= (nfsd4_enc)nfsd4_encode_noop,
5239 	[OP_LAYOUTGET]		= (nfsd4_enc)nfsd4_encode_noop,
5240 	[OP_LAYOUTRETURN]	= (nfsd4_enc)nfsd4_encode_noop,
5241 #endif
5242 	[OP_SECINFO_NO_NAME]	= (nfsd4_enc)nfsd4_encode_secinfo_no_name,
5243 	[OP_SEQUENCE]		= (nfsd4_enc)nfsd4_encode_sequence,
5244 	[OP_SET_SSV]		= (nfsd4_enc)nfsd4_encode_noop,
5245 	[OP_TEST_STATEID]	= (nfsd4_enc)nfsd4_encode_test_stateid,
5246 	[OP_WANT_DELEGATION]	= (nfsd4_enc)nfsd4_encode_noop,
5247 	[OP_DESTROY_CLIENTID]	= (nfsd4_enc)nfsd4_encode_noop,
5248 	[OP_RECLAIM_COMPLETE]	= (nfsd4_enc)nfsd4_encode_noop,
5249 
5250 	/* NFSv4.2 operations */
5251 	[OP_ALLOCATE]		= (nfsd4_enc)nfsd4_encode_noop,
5252 	[OP_COPY]		= (nfsd4_enc)nfsd4_encode_copy,
5253 	[OP_COPY_NOTIFY]	= (nfsd4_enc)nfsd4_encode_copy_notify,
5254 	[OP_DEALLOCATE]		= (nfsd4_enc)nfsd4_encode_noop,
5255 	[OP_IO_ADVISE]		= (nfsd4_enc)nfsd4_encode_noop,
5256 	[OP_LAYOUTERROR]	= (nfsd4_enc)nfsd4_encode_noop,
5257 	[OP_LAYOUTSTATS]	= (nfsd4_enc)nfsd4_encode_noop,
5258 	[OP_OFFLOAD_CANCEL]	= (nfsd4_enc)nfsd4_encode_noop,
5259 	[OP_OFFLOAD_STATUS]	= (nfsd4_enc)nfsd4_encode_offload_status,
5260 	[OP_READ_PLUS]		= (nfsd4_enc)nfsd4_encode_read_plus,
5261 	[OP_SEEK]		= (nfsd4_enc)nfsd4_encode_seek,
5262 	[OP_WRITE_SAME]		= (nfsd4_enc)nfsd4_encode_noop,
5263 	[OP_CLONE]		= (nfsd4_enc)nfsd4_encode_noop,
5264 
5265 	/* RFC 8276 extended atributes operations */
5266 	[OP_GETXATTR]		= (nfsd4_enc)nfsd4_encode_getxattr,
5267 	[OP_SETXATTR]		= (nfsd4_enc)nfsd4_encode_setxattr,
5268 	[OP_LISTXATTRS]		= (nfsd4_enc)nfsd4_encode_listxattrs,
5269 	[OP_REMOVEXATTR]	= (nfsd4_enc)nfsd4_encode_removexattr,
5270 };
5271 
5272 /*
5273  * Calculate whether we still have space to encode repsize bytes.
5274  * There are two considerations:
5275  *     - For NFS versions >=4.1, the size of the reply must stay within
5276  *       session limits
5277  *     - For all NFS versions, we must stay within limited preallocated
5278  *       buffer space.
5279  *
5280  * This is called before the operation is processed, so can only provide
5281  * an upper estimate.  For some nonidempotent operations (such as
5282  * getattr), it's not necessarily a problem if that estimate is wrong,
5283  * as we can fail it after processing without significant side effects.
5284  */
5285 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *resp, u32 respsize)
5286 {
5287 	struct xdr_buf *buf = &resp->rqstp->rq_res;
5288 	struct nfsd4_slot *slot = resp->cstate.slot;
5289 
5290 	if (buf->len + respsize <= buf->buflen)
5291 		return nfs_ok;
5292 	if (!nfsd4_has_session(&resp->cstate))
5293 		return nfserr_resource;
5294 	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {
5295 		WARN_ON_ONCE(1);
5296 		return nfserr_rep_too_big_to_cache;
5297 	}
5298 	return nfserr_rep_too_big;
5299 }
5300 
5301 void
5302 nfsd4_encode_operation(struct nfsd4_compoundres *resp, struct nfsd4_op *op)
5303 {
5304 	struct xdr_stream *xdr = resp->xdr;
5305 	struct nfs4_stateowner *so = resp->cstate.replay_owner;
5306 	struct svc_rqst *rqstp = resp->rqstp;
5307 	const struct nfsd4_operation *opdesc = op->opdesc;
5308 	int post_err_offset;
5309 	nfsd4_enc encoder;
5310 	__be32 *p;
5311 
5312 	p = xdr_reserve_space(xdr, 8);
5313 	if (!p) {
5314 		WARN_ON_ONCE(1);
5315 		return;
5316 	}
5317 	*p++ = cpu_to_be32(op->opnum);
5318 	post_err_offset = xdr->buf->len;
5319 
5320 	if (op->opnum == OP_ILLEGAL)
5321 		goto status;
5322 	if (op->status && opdesc &&
5323 			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))
5324 		goto status;
5325 	BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||
5326 	       !nfsd4_enc_ops[op->opnum]);
5327 	encoder = nfsd4_enc_ops[op->opnum];
5328 	op->status = encoder(resp, op->status, &op->u);
5329 	if (op->status)
5330 		trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);
5331 	if (opdesc && opdesc->op_release)
5332 		opdesc->op_release(&op->u);
5333 	xdr_commit_encode(xdr);
5334 
5335 	/* nfsd4_check_resp_size guarantees enough room for error status */
5336 	if (!op->status) {
5337 		int space_needed = 0;
5338 		if (!nfsd4_last_compound_op(rqstp))
5339 			space_needed = COMPOUND_ERR_SLACK_SPACE;
5340 		op->status = nfsd4_check_resp_size(resp, space_needed);
5341 	}
5342 	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {
5343 		struct nfsd4_slot *slot = resp->cstate.slot;
5344 
5345 		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)
5346 			op->status = nfserr_rep_too_big_to_cache;
5347 		else
5348 			op->status = nfserr_rep_too_big;
5349 	}
5350 	if (op->status == nfserr_resource ||
5351 	    op->status == nfserr_rep_too_big ||
5352 	    op->status == nfserr_rep_too_big_to_cache) {
5353 		/*
5354 		 * The operation may have already been encoded or
5355 		 * partially encoded.  No op returns anything additional
5356 		 * in the case of one of these three errors, so we can
5357 		 * just truncate back to after the status.  But it's a
5358 		 * bug if we had to do this on a non-idempotent op:
5359 		 */
5360 		warn_on_nonidempotent_op(op);
5361 		xdr_truncate_encode(xdr, post_err_offset);
5362 	}
5363 	if (so) {
5364 		int len = xdr->buf->len - post_err_offset;
5365 
5366 		so->so_replay.rp_status = op->status;
5367 		so->so_replay.rp_buflen = len;
5368 		read_bytes_from_xdr_buf(xdr->buf, post_err_offset,
5369 						so->so_replay.rp_buf, len);
5370 	}
5371 status:
5372 	/* Note that op->status is already in network byte order: */
5373 	write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4);
5374 }
5375 
5376 /*
5377  * Encode the reply stored in the stateowner reply cache
5378  *
5379  * XDR note: do not encode rp->rp_buflen: the buffer contains the
5380  * previously sent already encoded operation.
5381  */
5382 void
5383 nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op)
5384 {
5385 	__be32 *p;
5386 	struct nfs4_replay *rp = op->replay;
5387 
5388 	p = xdr_reserve_space(xdr, 8 + rp->rp_buflen);
5389 	if (!p) {
5390 		WARN_ON_ONCE(1);
5391 		return;
5392 	}
5393 	*p++ = cpu_to_be32(op->opnum);
5394 	*p++ = rp->rp_status;  /* already xdr'ed */
5395 
5396 	p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen);
5397 }
5398 
5399 void nfsd4_release_compoundargs(struct svc_rqst *rqstp)
5400 {
5401 	struct nfsd4_compoundargs *args = rqstp->rq_argp;
5402 
5403 	if (args->ops != args->iops) {
5404 		kfree(args->ops);
5405 		args->ops = args->iops;
5406 	}
5407 	while (args->to_free) {
5408 		struct svcxdr_tmpbuf *tb = args->to_free;
5409 		args->to_free = tb->next;
5410 		kfree(tb);
5411 	}
5412 }
5413 
5414 bool
5415 nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5416 {
5417 	struct nfsd4_compoundargs *args = rqstp->rq_argp;
5418 
5419 	/* svcxdr_tmp_alloc */
5420 	args->to_free = NULL;
5421 
5422 	args->xdr = xdr;
5423 	args->ops = args->iops;
5424 	args->rqstp = rqstp;
5425 
5426 	return nfsd4_decode_compound(args);
5427 }
5428 
5429 bool
5430 nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr)
5431 {
5432 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
5433 	struct xdr_buf *buf = xdr->buf;
5434 	__be32 *p;
5435 
5436 	WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len +
5437 				 buf->tail[0].iov_len);
5438 
5439 	/*
5440 	 * Send buffer space for the following items is reserved
5441 	 * at the top of nfsd4_proc_compound().
5442 	 */
5443 	p = resp->statusp;
5444 
5445 	*p++ = resp->cstate.status;
5446 
5447 	rqstp->rq_next_page = xdr->page_ptr + 1;
5448 
5449 	*p++ = htonl(resp->taglen);
5450 	memcpy(p, resp->tag, resp->taglen);
5451 	p += XDR_QUADLEN(resp->taglen);
5452 	*p++ = htonl(resp->opcnt);
5453 
5454 	nfsd4_sequence_done(resp);
5455 	return true;
5456 }
5457