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