2 * Server-side XDR for NFSv4
4 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * Kendrick Smith <kmsmith@umich.edu>
8 * Andy Adamson <andros@umich.edu>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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.
36 #include <linux/file.h>
37 #include <linux/slab.h>
38 #include <linux/namei.h>
39 #include <linux/statfs.h>
40 #include <linux/utsname.h>
41 #include <linux/pagemap.h>
42 #include <linux/sunrpc/svcauth_gss.h>
43 #include <linux/sunrpc/addr.h>
44 #include <linux/xattr.h>
45 #include <uapi/linux/xattr.h>
55 #include "filecache.h"
59 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
60 #include <linux/security.h>
64 #define NFSDDBG_FACILITY NFSDDBG_XDR
66 const u32 nfsd_suppattrs
[3][3] = {
67 {NFSD4_SUPPORTED_ATTRS_WORD0
,
68 NFSD4_SUPPORTED_ATTRS_WORD1
,
69 NFSD4_SUPPORTED_ATTRS_WORD2
},
71 {NFSD4_1_SUPPORTED_ATTRS_WORD0
,
72 NFSD4_1_SUPPORTED_ATTRS_WORD1
,
73 NFSD4_1_SUPPORTED_ATTRS_WORD2
},
75 {NFSD4_1_SUPPORTED_ATTRS_WORD0
,
76 NFSD4_1_SUPPORTED_ATTRS_WORD1
,
77 NFSD4_2_SUPPORTED_ATTRS_WORD2
},
81 * As per referral draft, the fsid for a referral MUST be different from the fsid of the containing
82 * directory in order to indicate to the client that a filesystem boundary is present
83 * We use a fixed fsid for a referral
85 #define NFS4_REFERRAL_FSID_MAJOR 0x8000000ULL
86 #define NFS4_REFERRAL_FSID_MINOR 0x8000000ULL
89 check_filename(char *str
, int len
)
95 if (len
> NFS4_MAXNAMLEN
)
96 return nfserr_nametoolong
;
97 if (isdotent(str
, len
))
98 return nfserr_badname
;
99 for (i
= 0; i
< len
; i
++)
101 return nfserr_badname
;
105 static int zero_clientid(clientid_t
*clid
)
107 return (clid
->cl_boot
== 0) && (clid
->cl_id
== 0);
111 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
112 * @argp: NFSv4 compound argument structure
113 * @len: length of buffer to allocate
115 * Allocates a buffer of size @len to be freed when processing the compound
116 * operation described in @argp finishes.
119 svcxdr_tmpalloc(struct nfsd4_compoundargs
*argp
, u32 len
)
121 struct svcxdr_tmpbuf
*tb
;
123 tb
= kmalloc(sizeof(*tb
) + len
, GFP_KERNEL
);
126 tb
->next
= argp
->to_free
;
132 * For xdr strings that need to be passed to other kernel api's
133 * as null-terminated strings.
135 * Note null-terminating in place usually isn't safe since the
136 * buffer might end on a page boundary.
139 svcxdr_dupstr(struct nfsd4_compoundargs
*argp
, void *buf
, u32 len
)
141 char *p
= svcxdr_tmpalloc(argp
, len
+ 1);
151 svcxdr_savemem(struct nfsd4_compoundargs
*argp
, __be32
*p
, u32 len
)
156 * The location of the decoded data item is stable,
157 * so @p is OK to use. This is the common case.
159 if (p
!= argp
->xdr
->scratch
.iov_base
)
162 tmp
= svcxdr_tmpalloc(argp
, len
);
170 * NFSv4 basic data type decoders
174 * This helper handles variable-length opaques which belong to protocol
175 * elements that this implementation does not support.
178 nfsd4_decode_ignored_string(struct nfsd4_compoundargs
*argp
, u32 maxlen
)
182 if (xdr_stream_decode_u32(argp
->xdr
, &len
) < 0)
183 return nfserr_bad_xdr
;
184 if (maxlen
&& len
> maxlen
)
185 return nfserr_bad_xdr
;
186 if (!xdr_inline_decode(argp
->xdr
, len
))
187 return nfserr_bad_xdr
;
193 nfsd4_decode_opaque(struct nfsd4_compoundargs
*argp
, struct xdr_netobj
*o
)
198 if (xdr_stream_decode_u32(argp
->xdr
, &len
) < 0)
199 return nfserr_bad_xdr
;
200 if (len
== 0 || len
> NFS4_OPAQUE_LIMIT
)
201 return nfserr_bad_xdr
;
202 p
= xdr_inline_decode(argp
->xdr
, len
);
204 return nfserr_bad_xdr
;
205 o
->data
= svcxdr_savemem(argp
, p
, len
);
207 return nfserr_jukebox
;
214 nfsd4_decode_component4(struct nfsd4_compoundargs
*argp
, char **namp
, u32
*lenp
)
218 if (xdr_stream_decode_u32(argp
->xdr
, lenp
) < 0)
219 return nfserr_bad_xdr
;
220 p
= xdr_inline_decode(argp
->xdr
, *lenp
);
222 return nfserr_bad_xdr
;
223 status
= check_filename((char *)p
, *lenp
);
226 *namp
= svcxdr_savemem(argp
, p
, *lenp
);
228 return nfserr_jukebox
;
234 nfsd4_decode_nfstime4(struct nfsd4_compoundargs
*argp
, struct timespec64
*tv
)
238 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
* 3);
240 return nfserr_bad_xdr
;
241 p
= xdr_decode_hyper(p
, &tv
->tv_sec
);
242 tv
->tv_nsec
= be32_to_cpup(p
++);
243 if (tv
->tv_nsec
>= (u32
)1000000000)
249 nfsd4_decode_verifier4(struct nfsd4_compoundargs
*argp
, nfs4_verifier
*verf
)
253 p
= xdr_inline_decode(argp
->xdr
, NFS4_VERIFIER_SIZE
);
255 return nfserr_bad_xdr
;
256 memcpy(verf
->data
, p
, sizeof(verf
->data
));
261 * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
262 * @argp: NFSv4 compound argument structure
263 * @bmval: pointer to an array of u32's to decode into
264 * @bmlen: size of the @bmval array
266 * The server needs to return nfs_ok rather than nfserr_bad_xdr when
267 * encountering bitmaps containing bits it does not recognize. This
268 * includes bits in bitmap words past WORDn, where WORDn is the last
269 * bitmap WORD the implementation currently supports. Thus we are
270 * careful here to simply ignore bits in bitmap words that this
271 * implementation has yet to support explicitly.
274 * %nfs_ok: @bmval populated successfully
275 * %nfserr_bad_xdr: the encoded bitmap was invalid
278 nfsd4_decode_bitmap4(struct nfsd4_compoundargs
*argp
, u32
*bmval
, u32 bmlen
)
283 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
284 return nfserr_bad_xdr
;
287 return nfserr_bad_xdr
;
288 p
= xdr_inline_decode(argp
->xdr
, count
<< 2);
290 return nfserr_bad_xdr
;
293 bmval
[i
++] = be32_to_cpup(p
++);
301 nfsd4_decode_nfsace4(struct nfsd4_compoundargs
*argp
, struct nfs4_ace
*ace
)
306 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->type
) < 0)
307 return nfserr_bad_xdr
;
308 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->flag
) < 0)
309 return nfserr_bad_xdr
;
310 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->access_mask
) < 0)
311 return nfserr_bad_xdr
;
313 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
314 return nfserr_bad_xdr
;
315 p
= xdr_inline_decode(argp
->xdr
, length
);
317 return nfserr_bad_xdr
;
318 ace
->whotype
= nfs4_acl_get_whotype((char *)p
, length
);
319 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
321 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
322 status
= nfsd_map_name_to_gid(argp
->rqstp
,
323 (char *)p
, length
, &ace
->who_gid
);
325 status
= nfsd_map_name_to_uid(argp
->rqstp
,
326 (char *)p
, length
, &ace
->who_uid
);
331 /* A counted array of nfsace4's */
332 static noinline __be32
333 nfsd4_decode_acl(struct nfsd4_compoundargs
*argp
, struct nfs4_acl
**acl
)
335 struct nfs4_ace
*ace
;
339 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
340 return nfserr_bad_xdr
;
342 if (count
> xdr_stream_remaining(argp
->xdr
) / 20)
344 * Even with 4-byte names there wouldn't be
345 * space for that many aces; something fishy is
350 *acl
= svcxdr_tmpalloc(argp
, nfs4_acl_bytes(count
));
352 return nfserr_jukebox
;
354 (*acl
)->naces
= count
;
355 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ count
; ace
++) {
356 status
= nfsd4_decode_nfsace4(argp
, ace
);
364 static noinline __be32
365 nfsd4_decode_security_label(struct nfsd4_compoundargs
*argp
,
366 struct xdr_netobj
*label
)
371 if (xdr_stream_decode_u32(argp
->xdr
, &lfs
) < 0)
372 return nfserr_bad_xdr
;
373 if (xdr_stream_decode_u32(argp
->xdr
, &pi
) < 0)
374 return nfserr_bad_xdr
;
376 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
377 return nfserr_bad_xdr
;
378 if (length
> NFS4_MAXLABELLEN
)
379 return nfserr_badlabel
;
380 p
= xdr_inline_decode(argp
->xdr
, length
);
382 return nfserr_bad_xdr
;
384 label
->data
= svcxdr_dupstr(argp
, p
, length
);
386 return nfserr_jukebox
;
392 nfsd4_decode_fattr4(struct nfsd4_compoundargs
*argp
, u32
*bmval
, u32 bmlen
,
393 struct iattr
*iattr
, struct nfs4_acl
**acl
,
394 struct xdr_netobj
*label
, int *umask
)
396 unsigned int starting_pos
;
401 status
= nfsd4_decode_bitmap4(argp
, bmval
, bmlen
);
403 return nfserr_bad_xdr
;
405 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
406 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
407 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
) {
408 if (nfsd_attrs_supported(argp
->minorversion
, bmval
))
410 return nfserr_attrnotsupp
;
413 if (xdr_stream_decode_u32(argp
->xdr
, &attrlist4_count
) < 0)
414 return nfserr_bad_xdr
;
415 starting_pos
= xdr_stream_pos(argp
->xdr
);
417 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
420 if (xdr_stream_decode_u64(argp
->xdr
, &size
) < 0)
421 return nfserr_bad_xdr
;
422 iattr
->ia_size
= size
;
423 iattr
->ia_valid
|= ATTR_SIZE
;
425 if (bmval
[0] & FATTR4_WORD0_ACL
) {
426 status
= nfsd4_decode_acl(argp
, acl
);
431 if (bmval
[1] & FATTR4_WORD1_MODE
) {
434 if (xdr_stream_decode_u32(argp
->xdr
, &mode
) < 0)
435 return nfserr_bad_xdr
;
436 iattr
->ia_mode
= mode
;
437 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
438 iattr
->ia_valid
|= ATTR_MODE
;
440 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
443 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
444 return nfserr_bad_xdr
;
445 p
= xdr_inline_decode(argp
->xdr
, length
);
447 return nfserr_bad_xdr
;
448 status
= nfsd_map_name_to_uid(argp
->rqstp
, (char *)p
, length
,
452 iattr
->ia_valid
|= ATTR_UID
;
454 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
457 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
458 return nfserr_bad_xdr
;
459 p
= xdr_inline_decode(argp
->xdr
, length
);
461 return nfserr_bad_xdr
;
462 status
= nfsd_map_name_to_gid(argp
->rqstp
, (char *)p
, length
,
466 iattr
->ia_valid
|= ATTR_GID
;
468 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
471 if (xdr_stream_decode_u32(argp
->xdr
, &set_it
) < 0)
472 return nfserr_bad_xdr
;
474 case NFS4_SET_TO_CLIENT_TIME
:
475 status
= nfsd4_decode_nfstime4(argp
, &iattr
->ia_atime
);
478 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
480 case NFS4_SET_TO_SERVER_TIME
:
481 iattr
->ia_valid
|= ATTR_ATIME
;
484 return nfserr_bad_xdr
;
487 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
490 if (xdr_stream_decode_u32(argp
->xdr
, &set_it
) < 0)
491 return nfserr_bad_xdr
;
493 case NFS4_SET_TO_CLIENT_TIME
:
494 status
= nfsd4_decode_nfstime4(argp
, &iattr
->ia_mtime
);
497 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
499 case NFS4_SET_TO_SERVER_TIME
:
500 iattr
->ia_valid
|= ATTR_MTIME
;
503 return nfserr_bad_xdr
;
507 if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL
) &&
508 bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) {
509 status
= nfsd4_decode_security_label(argp
, label
);
513 if (bmval
[2] & FATTR4_WORD2_MODE_UMASK
) {
517 return nfserr_bad_xdr
;
518 if (xdr_stream_decode_u32(argp
->xdr
, &mode
) < 0)
519 return nfserr_bad_xdr
;
520 iattr
->ia_mode
= mode
& (S_IFMT
| S_IALLUGO
);
521 if (xdr_stream_decode_u32(argp
->xdr
, &mask
) < 0)
522 return nfserr_bad_xdr
;
523 *umask
= mask
& S_IRWXUGO
;
524 iattr
->ia_valid
|= ATTR_MODE
;
527 /* request sanity: did attrlist4 contain the expected number of words? */
528 if (attrlist4_count
!= xdr_stream_pos(argp
->xdr
) - starting_pos
)
529 return nfserr_bad_xdr
;
535 nfsd4_decode_stateid4(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
539 p
= xdr_inline_decode(argp
->xdr
, NFS4_STATEID_SIZE
);
541 return nfserr_bad_xdr
;
542 sid
->si_generation
= be32_to_cpup(p
++);
543 memcpy(&sid
->si_opaque
, p
, sizeof(sid
->si_opaque
));
548 nfsd4_decode_clientid4(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
552 p
= xdr_inline_decode(argp
->xdr
, sizeof(__be64
));
554 return nfserr_bad_xdr
;
555 memcpy(clientid
, p
, sizeof(*clientid
));
560 nfsd4_decode_state_owner4(struct nfsd4_compoundargs
*argp
,
561 clientid_t
*clientid
, struct xdr_netobj
*owner
)
565 status
= nfsd4_decode_clientid4(argp
, clientid
);
568 return nfsd4_decode_opaque(argp
, owner
);
571 #ifdef CONFIG_NFSD_PNFS
573 nfsd4_decode_deviceid4(struct nfsd4_compoundargs
*argp
,
574 struct nfsd4_deviceid
*devid
)
578 p
= xdr_inline_decode(argp
->xdr
, NFS4_DEVICEID4_SIZE
);
580 return nfserr_bad_xdr
;
581 memcpy(devid
, p
, sizeof(*devid
));
586 nfsd4_decode_layoutupdate4(struct nfsd4_compoundargs
*argp
,
587 struct nfsd4_layoutcommit
*lcp
)
589 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_layout_type
) < 0)
590 return nfserr_bad_xdr
;
591 if (lcp
->lc_layout_type
< LAYOUT_NFSV4_1_FILES
)
592 return nfserr_bad_xdr
;
593 if (lcp
->lc_layout_type
>= LAYOUT_TYPE_MAX
)
594 return nfserr_bad_xdr
;
596 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_up_len
) < 0)
597 return nfserr_bad_xdr
;
598 if (lcp
->lc_up_len
> 0) {
599 lcp
->lc_up_layout
= xdr_inline_decode(argp
->xdr
, lcp
->lc_up_len
);
600 if (!lcp
->lc_up_layout
)
601 return nfserr_bad_xdr
;
608 nfsd4_decode_layoutreturn4(struct nfsd4_compoundargs
*argp
,
609 struct nfsd4_layoutreturn
*lrp
)
613 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_return_type
) < 0)
614 return nfserr_bad_xdr
;
615 switch (lrp
->lr_return_type
) {
617 if (xdr_stream_decode_u64(argp
->xdr
, &lrp
->lr_seg
.offset
) < 0)
618 return nfserr_bad_xdr
;
619 if (xdr_stream_decode_u64(argp
->xdr
, &lrp
->lr_seg
.length
) < 0)
620 return nfserr_bad_xdr
;
621 status
= nfsd4_decode_stateid4(argp
, &lrp
->lr_sid
);
624 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lrf_body_len
) < 0)
625 return nfserr_bad_xdr
;
626 if (lrp
->lrf_body_len
> 0) {
627 lrp
->lrf_body
= xdr_inline_decode(argp
->xdr
, lrp
->lrf_body_len
);
629 return nfserr_bad_xdr
;
634 lrp
->lr_seg
.offset
= 0;
635 lrp
->lr_seg
.length
= NFS4_MAX_UINT64
;
638 return nfserr_bad_xdr
;
644 #endif /* CONFIG_NFSD_PNFS */
647 nfsd4_decode_sessionid4(struct nfsd4_compoundargs
*argp
,
648 struct nfs4_sessionid
*sessionid
)
652 p
= xdr_inline_decode(argp
->xdr
, NFS4_MAX_SESSIONID_LEN
);
654 return nfserr_bad_xdr
;
655 memcpy(sessionid
->data
, p
, sizeof(sessionid
->data
));
659 /* Defined in Appendix A of RFC 5531 */
661 nfsd4_decode_authsys_parms(struct nfsd4_compoundargs
*argp
,
662 struct nfsd4_cb_sec
*cbs
)
664 u32 stamp
, gidcount
, uid
, gid
;
667 if (xdr_stream_decode_u32(argp
->xdr
, &stamp
) < 0)
668 return nfserr_bad_xdr
;
670 status
= nfsd4_decode_ignored_string(argp
, 255);
673 if (xdr_stream_decode_u32(argp
->xdr
, &uid
) < 0)
674 return nfserr_bad_xdr
;
675 if (xdr_stream_decode_u32(argp
->xdr
, &gid
) < 0)
676 return nfserr_bad_xdr
;
677 if (xdr_stream_decode_u32(argp
->xdr
, &gidcount
) < 0)
678 return nfserr_bad_xdr
;
680 return nfserr_bad_xdr
;
681 p
= xdr_inline_decode(argp
->xdr
, gidcount
<< 2);
683 return nfserr_bad_xdr
;
684 if (cbs
->flavor
== (u32
)(-1)) {
685 struct user_namespace
*userns
= nfsd_user_namespace(argp
->rqstp
);
687 kuid_t kuid
= make_kuid(userns
, uid
);
688 kgid_t kgid
= make_kgid(userns
, gid
);
689 if (uid_valid(kuid
) && gid_valid(kgid
)) {
692 cbs
->flavor
= RPC_AUTH_UNIX
;
694 dprintk("RPC_AUTH_UNIX with invalid uid or gid, ignoring!\n");
702 nfsd4_decode_gss_cb_handles4(struct nfsd4_compoundargs
*argp
,
703 struct nfsd4_cb_sec
*cbs
)
708 dprintk("RPC_AUTH_GSS callback secflavor not supported!\n");
710 if (xdr_stream_decode_u32(argp
->xdr
, &service
) < 0)
711 return nfserr_bad_xdr
;
712 if (service
< RPC_GSS_SVC_NONE
|| service
> RPC_GSS_SVC_PRIVACY
)
713 return nfserr_bad_xdr
;
714 /* gcbp_handle_from_server */
715 status
= nfsd4_decode_ignored_string(argp
, 0);
718 /* gcbp_handle_from_client */
719 status
= nfsd4_decode_ignored_string(argp
, 0);
726 /* a counted array of callback_sec_parms4 items */
728 nfsd4_decode_cb_sec(struct nfsd4_compoundargs
*argp
, struct nfsd4_cb_sec
*cbs
)
730 u32 i
, secflavor
, nr_secflavs
;
733 /* callback_sec_params4 */
734 if (xdr_stream_decode_u32(argp
->xdr
, &nr_secflavs
) < 0)
735 return nfserr_bad_xdr
;
737 cbs
->flavor
= (u32
)(-1);
739 /* Is this legal? Be generous, take it to mean AUTH_NONE: */
742 for (i
= 0; i
< nr_secflavs
; ++i
) {
743 if (xdr_stream_decode_u32(argp
->xdr
, &secflavor
) < 0)
744 return nfserr_bad_xdr
;
748 if (cbs
->flavor
== (u32
)(-1))
749 cbs
->flavor
= RPC_AUTH_NULL
;
752 status
= nfsd4_decode_authsys_parms(argp
, cbs
);
757 status
= nfsd4_decode_gss_cb_handles4(argp
, cbs
);
771 * NFSv4 operation argument decoders
775 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
,
776 struct nfsd4_access
*access
)
778 if (xdr_stream_decode_u32(argp
->xdr
, &access
->ac_req_access
) < 0)
779 return nfserr_bad_xdr
;
784 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
786 if (xdr_stream_decode_u32(argp
->xdr
, &close
->cl_seqid
) < 0)
787 return nfserr_bad_xdr
;
788 return nfsd4_decode_stateid4(argp
, &close
->cl_stateid
);
793 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
795 if (xdr_stream_decode_u64(argp
->xdr
, &commit
->co_offset
) < 0)
796 return nfserr_bad_xdr
;
797 if (xdr_stream_decode_u32(argp
->xdr
, &commit
->co_count
) < 0)
798 return nfserr_bad_xdr
;
803 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
807 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_type
) < 0)
808 return nfserr_bad_xdr
;
809 switch (create
->cr_type
) {
811 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_datalen
) < 0)
812 return nfserr_bad_xdr
;
813 p
= xdr_inline_decode(argp
->xdr
, create
->cr_datalen
);
815 return nfserr_bad_xdr
;
816 create
->cr_data
= svcxdr_dupstr(argp
, p
, create
->cr_datalen
);
817 if (!create
->cr_data
)
818 return nfserr_jukebox
;
822 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_specdata1
) < 0)
823 return nfserr_bad_xdr
;
824 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_specdata2
) < 0)
825 return nfserr_bad_xdr
;
833 status
= nfsd4_decode_component4(argp
, &create
->cr_name
,
834 &create
->cr_namelen
);
837 status
= nfsd4_decode_fattr4(argp
, create
->cr_bmval
,
838 ARRAY_SIZE(create
->cr_bmval
),
839 &create
->cr_iattr
, &create
->cr_acl
,
840 &create
->cr_label
, &create
->cr_umask
);
848 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
850 return nfsd4_decode_stateid4(argp
, &dr
->dr_stateid
);
854 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
856 return nfsd4_decode_bitmap4(argp
, getattr
->ga_bmval
,
857 ARRAY_SIZE(getattr
->ga_bmval
));
861 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
863 return nfsd4_decode_component4(argp
, &link
->li_name
, &link
->li_namelen
);
867 nfsd4_decode_open_to_lock_owner4(struct nfsd4_compoundargs
*argp
,
868 struct nfsd4_lock
*lock
)
872 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_new_open_seqid
) < 0)
873 return nfserr_bad_xdr
;
874 status
= nfsd4_decode_stateid4(argp
, &lock
->lk_new_open_stateid
);
877 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_new_lock_seqid
) < 0)
878 return nfserr_bad_xdr
;
879 return nfsd4_decode_state_owner4(argp
, &lock
->lk_new_clientid
,
880 &lock
->lk_new_owner
);
884 nfsd4_decode_exist_lock_owner4(struct nfsd4_compoundargs
*argp
,
885 struct nfsd4_lock
*lock
)
889 status
= nfsd4_decode_stateid4(argp
, &lock
->lk_old_lock_stateid
);
892 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_old_lock_seqid
) < 0)
893 return nfserr_bad_xdr
;
899 nfsd4_decode_locker4(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
901 if (xdr_stream_decode_bool(argp
->xdr
, &lock
->lk_is_new
) < 0)
902 return nfserr_bad_xdr
;
904 return nfsd4_decode_open_to_lock_owner4(argp
, lock
);
905 return nfsd4_decode_exist_lock_owner4(argp
, lock
);
909 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
911 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_type
) < 0)
912 return nfserr_bad_xdr
;
913 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
914 return nfserr_bad_xdr
;
915 if (xdr_stream_decode_bool(argp
->xdr
, &lock
->lk_reclaim
) < 0)
916 return nfserr_bad_xdr
;
917 if (xdr_stream_decode_u64(argp
->xdr
, &lock
->lk_offset
) < 0)
918 return nfserr_bad_xdr
;
919 if (xdr_stream_decode_u64(argp
->xdr
, &lock
->lk_length
) < 0)
920 return nfserr_bad_xdr
;
921 return nfsd4_decode_locker4(argp
, lock
);
925 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
927 if (xdr_stream_decode_u32(argp
->xdr
, &lockt
->lt_type
) < 0)
928 return nfserr_bad_xdr
;
929 if ((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
930 return nfserr_bad_xdr
;
931 if (xdr_stream_decode_u64(argp
->xdr
, &lockt
->lt_offset
) < 0)
932 return nfserr_bad_xdr
;
933 if (xdr_stream_decode_u64(argp
->xdr
, &lockt
->lt_length
) < 0)
934 return nfserr_bad_xdr
;
935 return nfsd4_decode_state_owner4(argp
, &lockt
->lt_clientid
,
940 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
944 if (xdr_stream_decode_u32(argp
->xdr
, &locku
->lu_type
) < 0)
945 return nfserr_bad_xdr
;
946 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
947 return nfserr_bad_xdr
;
948 if (xdr_stream_decode_u32(argp
->xdr
, &locku
->lu_seqid
) < 0)
949 return nfserr_bad_xdr
;
950 status
= nfsd4_decode_stateid4(argp
, &locku
->lu_stateid
);
953 if (xdr_stream_decode_u64(argp
->xdr
, &locku
->lu_offset
) < 0)
954 return nfserr_bad_xdr
;
955 if (xdr_stream_decode_u64(argp
->xdr
, &locku
->lu_length
) < 0)
956 return nfserr_bad_xdr
;
962 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
964 return nfsd4_decode_component4(argp
, &lookup
->lo_name
, &lookup
->lo_len
);
968 nfsd4_decode_createhow4(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
972 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_createmode
) < 0)
973 return nfserr_bad_xdr
;
974 switch (open
->op_createmode
) {
975 case NFS4_CREATE_UNCHECKED
:
976 case NFS4_CREATE_GUARDED
:
977 status
= nfsd4_decode_fattr4(argp
, open
->op_bmval
,
978 ARRAY_SIZE(open
->op_bmval
),
979 &open
->op_iattr
, &open
->op_acl
,
980 &open
->op_label
, &open
->op_umask
);
984 case NFS4_CREATE_EXCLUSIVE
:
985 status
= nfsd4_decode_verifier4(argp
, &open
->op_verf
);
989 case NFS4_CREATE_EXCLUSIVE4_1
:
990 if (argp
->minorversion
< 1)
991 return nfserr_bad_xdr
;
992 status
= nfsd4_decode_verifier4(argp
, &open
->op_verf
);
995 status
= nfsd4_decode_fattr4(argp
, open
->op_bmval
,
996 ARRAY_SIZE(open
->op_bmval
),
997 &open
->op_iattr
, &open
->op_acl
,
998 &open
->op_label
, &open
->op_umask
);
1003 return nfserr_bad_xdr
;
1010 nfsd4_decode_openflag4(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
1014 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_create
) < 0)
1015 return nfserr_bad_xdr
;
1016 switch (open
->op_create
) {
1017 case NFS4_OPEN_NOCREATE
:
1019 case NFS4_OPEN_CREATE
:
1020 status
= nfsd4_decode_createhow4(argp
, open
);
1025 return nfserr_bad_xdr
;
1031 static __be32
nfsd4_decode_share_access(struct nfsd4_compoundargs
*argp
, u32
*share_access
, u32
*deleg_want
, u32
*deleg_when
)
1035 if (xdr_stream_decode_u32(argp
->xdr
, &w
) < 0)
1036 return nfserr_bad_xdr
;
1037 *share_access
= w
& NFS4_SHARE_ACCESS_MASK
;
1038 *deleg_want
= w
& NFS4_SHARE_WANT_MASK
;
1040 *deleg_when
= w
& NFS4_SHARE_WHEN_MASK
;
1042 switch (w
& NFS4_SHARE_ACCESS_MASK
) {
1043 case NFS4_SHARE_ACCESS_READ
:
1044 case NFS4_SHARE_ACCESS_WRITE
:
1045 case NFS4_SHARE_ACCESS_BOTH
:
1048 return nfserr_bad_xdr
;
1050 w
&= ~NFS4_SHARE_ACCESS_MASK
;
1053 if (!argp
->minorversion
)
1054 return nfserr_bad_xdr
;
1055 switch (w
& NFS4_SHARE_WANT_MASK
) {
1056 case NFS4_SHARE_WANT_NO_PREFERENCE
:
1057 case NFS4_SHARE_WANT_READ_DELEG
:
1058 case NFS4_SHARE_WANT_WRITE_DELEG
:
1059 case NFS4_SHARE_WANT_ANY_DELEG
:
1060 case NFS4_SHARE_WANT_NO_DELEG
:
1061 case NFS4_SHARE_WANT_CANCEL
:
1064 return nfserr_bad_xdr
;
1066 w
&= ~NFS4_SHARE_WANT_MASK
;
1070 if (!deleg_when
) /* open_downgrade */
1071 return nfserr_inval
;
1073 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
:
1074 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
:
1075 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
|
1076 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
):
1079 return nfserr_bad_xdr
;
1082 static __be32
nfsd4_decode_share_deny(struct nfsd4_compoundargs
*argp
, u32
*x
)
1084 if (xdr_stream_decode_u32(argp
->xdr
, x
) < 0)
1085 return nfserr_bad_xdr
;
1086 /* Note: unlike access bits, deny bits may be zero. */
1087 if (*x
& ~NFS4_SHARE_DENY_BOTH
)
1088 return nfserr_bad_xdr
;
1094 nfsd4_decode_open_claim4(struct nfsd4_compoundargs
*argp
,
1095 struct nfsd4_open
*open
)
1099 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_claim_type
) < 0)
1100 return nfserr_bad_xdr
;
1101 switch (open
->op_claim_type
) {
1102 case NFS4_OPEN_CLAIM_NULL
:
1103 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
1104 status
= nfsd4_decode_component4(argp
, &open
->op_fname
,
1105 &open
->op_fnamelen
);
1109 case NFS4_OPEN_CLAIM_PREVIOUS
:
1110 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_delegate_type
) < 0)
1111 return nfserr_bad_xdr
;
1113 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
1114 status
= nfsd4_decode_stateid4(argp
, &open
->op_delegate_stateid
);
1117 status
= nfsd4_decode_component4(argp
, &open
->op_fname
,
1118 &open
->op_fnamelen
);
1122 case NFS4_OPEN_CLAIM_FH
:
1123 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
1124 if (argp
->minorversion
< 1)
1125 return nfserr_bad_xdr
;
1128 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1129 if (argp
->minorversion
< 1)
1130 return nfserr_bad_xdr
;
1131 status
= nfsd4_decode_stateid4(argp
, &open
->op_delegate_stateid
);
1136 return nfserr_bad_xdr
;
1143 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
1148 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
1149 open
->op_iattr
.ia_valid
= 0;
1150 open
->op_openowner
= NULL
;
1152 open
->op_xdr_error
= 0;
1153 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_seqid
) < 0)
1154 return nfserr_bad_xdr
;
1155 /* deleg_want is ignored */
1156 status
= nfsd4_decode_share_access(argp
, &open
->op_share_access
,
1157 &open
->op_deleg_want
, &dummy
);
1160 status
= nfsd4_decode_share_deny(argp
, &open
->op_share_deny
);
1163 status
= nfsd4_decode_state_owner4(argp
, &open
->op_clientid
,
1167 status
= nfsd4_decode_openflag4(argp
, open
);
1170 return nfsd4_decode_open_claim4(argp
, open
);
1174 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
1178 if (argp
->minorversion
>= 1)
1179 return nfserr_notsupp
;
1181 status
= nfsd4_decode_stateid4(argp
, &open_conf
->oc_req_stateid
);
1184 if (xdr_stream_decode_u32(argp
->xdr
, &open_conf
->oc_seqid
) < 0)
1185 return nfserr_bad_xdr
;
1191 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
1195 status
= nfsd4_decode_stateid4(argp
, &open_down
->od_stateid
);
1198 if (xdr_stream_decode_u32(argp
->xdr
, &open_down
->od_seqid
) < 0)
1199 return nfserr_bad_xdr
;
1200 /* deleg_want is ignored */
1201 status
= nfsd4_decode_share_access(argp
, &open_down
->od_share_access
,
1202 &open_down
->od_deleg_want
, NULL
);
1205 return nfsd4_decode_share_deny(argp
, &open_down
->od_share_deny
);
1209 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
1213 if (xdr_stream_decode_u32(argp
->xdr
, &putfh
->pf_fhlen
) < 0)
1214 return nfserr_bad_xdr
;
1215 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
1216 return nfserr_bad_xdr
;
1217 p
= xdr_inline_decode(argp
->xdr
, putfh
->pf_fhlen
);
1219 return nfserr_bad_xdr
;
1220 putfh
->pf_fhval
= svcxdr_savemem(argp
, p
, putfh
->pf_fhlen
);
1221 if (!putfh
->pf_fhval
)
1222 return nfserr_jukebox
;
1228 nfsd4_decode_putpubfh(struct nfsd4_compoundargs
*argp
, void *p
)
1230 if (argp
->minorversion
== 0)
1232 return nfserr_notsupp
;
1236 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
1240 status
= nfsd4_decode_stateid4(argp
, &read
->rd_stateid
);
1243 if (xdr_stream_decode_u64(argp
->xdr
, &read
->rd_offset
) < 0)
1244 return nfserr_bad_xdr
;
1245 if (xdr_stream_decode_u32(argp
->xdr
, &read
->rd_length
) < 0)
1246 return nfserr_bad_xdr
;
1252 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
1256 if (xdr_stream_decode_u64(argp
->xdr
, &readdir
->rd_cookie
) < 0)
1257 return nfserr_bad_xdr
;
1258 status
= nfsd4_decode_verifier4(argp
, &readdir
->rd_verf
);
1261 if (xdr_stream_decode_u32(argp
->xdr
, &readdir
->rd_dircount
) < 0)
1262 return nfserr_bad_xdr
;
1263 if (xdr_stream_decode_u32(argp
->xdr
, &readdir
->rd_maxcount
) < 0)
1264 return nfserr_bad_xdr
;
1265 if (xdr_stream_decode_uint32_array(argp
->xdr
, readdir
->rd_bmval
,
1266 ARRAY_SIZE(readdir
->rd_bmval
)) < 0)
1267 return nfserr_bad_xdr
;
1273 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
1275 return nfsd4_decode_component4(argp
, &remove
->rm_name
, &remove
->rm_namelen
);
1279 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
1283 status
= nfsd4_decode_component4(argp
, &rename
->rn_sname
, &rename
->rn_snamelen
);
1286 return nfsd4_decode_component4(argp
, &rename
->rn_tname
, &rename
->rn_tnamelen
);
1290 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
1292 return nfsd4_decode_clientid4(argp
, clientid
);
1296 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
1297 struct nfsd4_secinfo
*secinfo
)
1299 return nfsd4_decode_component4(argp
, &secinfo
->si_name
, &secinfo
->si_namelen
);
1303 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
1307 status
= nfsd4_decode_stateid4(argp
, &setattr
->sa_stateid
);
1310 return nfsd4_decode_fattr4(argp
, setattr
->sa_bmval
,
1311 ARRAY_SIZE(setattr
->sa_bmval
),
1312 &setattr
->sa_iattr
, &setattr
->sa_acl
,
1313 &setattr
->sa_label
, NULL
);
1317 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
1321 if (argp
->minorversion
>= 1)
1322 return nfserr_notsupp
;
1324 status
= nfsd4_decode_verifier4(argp
, &setclientid
->se_verf
);
1327 status
= nfsd4_decode_opaque(argp
, &setclientid
->se_name
);
1330 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_prog
) < 0)
1331 return nfserr_bad_xdr
;
1332 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_netid_len
) < 0)
1333 return nfserr_bad_xdr
;
1334 p
= xdr_inline_decode(argp
->xdr
, setclientid
->se_callback_netid_len
);
1336 return nfserr_bad_xdr
;
1337 setclientid
->se_callback_netid_val
= svcxdr_savemem(argp
, p
,
1338 setclientid
->se_callback_netid_len
);
1339 if (!setclientid
->se_callback_netid_val
)
1340 return nfserr_jukebox
;
1342 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_addr_len
) < 0)
1343 return nfserr_bad_xdr
;
1344 p
= xdr_inline_decode(argp
->xdr
, setclientid
->se_callback_addr_len
);
1346 return nfserr_bad_xdr
;
1347 setclientid
->se_callback_addr_val
= svcxdr_savemem(argp
, p
,
1348 setclientid
->se_callback_addr_len
);
1349 if (!setclientid
->se_callback_addr_val
)
1350 return nfserr_jukebox
;
1351 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_ident
) < 0)
1352 return nfserr_bad_xdr
;
1358 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
1362 if (argp
->minorversion
>= 1)
1363 return nfserr_notsupp
;
1365 status
= nfsd4_decode_clientid4(argp
, &scd_c
->sc_clientid
);
1368 return nfsd4_decode_verifier4(argp
, &scd_c
->sc_confirm
);
1371 /* Also used for NVERIFY */
1373 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
1377 status
= nfsd4_decode_bitmap4(argp
, verify
->ve_bmval
,
1378 ARRAY_SIZE(verify
->ve_bmval
));
1382 /* For convenience's sake, we compare raw xdr'd attributes in
1383 * nfsd4_proc_verify */
1385 if (xdr_stream_decode_u32(argp
->xdr
, &verify
->ve_attrlen
) < 0)
1386 return nfserr_bad_xdr
;
1387 p
= xdr_inline_decode(argp
->xdr
, verify
->ve_attrlen
);
1389 return nfserr_bad_xdr
;
1390 verify
->ve_attrval
= svcxdr_savemem(argp
, p
, verify
->ve_attrlen
);
1391 if (!verify
->ve_attrval
)
1392 return nfserr_jukebox
;
1398 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
1402 status
= nfsd4_decode_stateid4(argp
, &write
->wr_stateid
);
1405 if (xdr_stream_decode_u64(argp
->xdr
, &write
->wr_offset
) < 0)
1406 return nfserr_bad_xdr
;
1407 if (xdr_stream_decode_u32(argp
->xdr
, &write
->wr_stable_how
) < 0)
1408 return nfserr_bad_xdr
;
1409 if (write
->wr_stable_how
> NFS_FILE_SYNC
)
1410 return nfserr_bad_xdr
;
1411 if (xdr_stream_decode_u32(argp
->xdr
, &write
->wr_buflen
) < 0)
1412 return nfserr_bad_xdr
;
1413 if (!xdr_stream_subsegment(argp
->xdr
, &write
->wr_payload
, write
->wr_buflen
))
1414 return nfserr_bad_xdr
;
1420 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1424 if (argp
->minorversion
>= 1)
1425 return nfserr_notsupp
;
1427 status
= nfsd4_decode_state_owner4(argp
, &rlockowner
->rl_clientid
,
1428 &rlockowner
->rl_owner
);
1432 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1433 return nfserr_inval
;
1438 static __be32
nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs
*argp
, struct nfsd4_backchannel_ctl
*bc
)
1440 if (xdr_stream_decode_u32(argp
->xdr
, &bc
->bc_cb_program
) < 0)
1441 return nfserr_bad_xdr
;
1442 return nfsd4_decode_cb_sec(argp
, &bc
->bc_cb_sec
);
1445 static __be32
nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs
*argp
, struct nfsd4_bind_conn_to_session
*bcts
)
1447 u32 use_conn_in_rdma_mode
;
1450 status
= nfsd4_decode_sessionid4(argp
, &bcts
->sessionid
);
1453 if (xdr_stream_decode_u32(argp
->xdr
, &bcts
->dir
) < 0)
1454 return nfserr_bad_xdr
;
1455 if (xdr_stream_decode_u32(argp
->xdr
, &use_conn_in_rdma_mode
) < 0)
1456 return nfserr_bad_xdr
;
1462 nfsd4_decode_state_protect_ops(struct nfsd4_compoundargs
*argp
,
1463 struct nfsd4_exchange_id
*exid
)
1467 status
= nfsd4_decode_bitmap4(argp
, exid
->spo_must_enforce
,
1468 ARRAY_SIZE(exid
->spo_must_enforce
));
1470 return nfserr_bad_xdr
;
1471 status
= nfsd4_decode_bitmap4(argp
, exid
->spo_must_allow
,
1472 ARRAY_SIZE(exid
->spo_must_allow
));
1474 return nfserr_bad_xdr
;
1480 * This implementation currently does not support SP4_SSV.
1481 * This decoder simply skips over these arguments.
1483 static noinline __be32
1484 nfsd4_decode_ssv_sp_parms(struct nfsd4_compoundargs
*argp
,
1485 struct nfsd4_exchange_id
*exid
)
1487 u32 count
, window
, num_gss_handles
;
1491 status
= nfsd4_decode_state_protect_ops(argp
, exid
);
1495 /* ssp_hash_algs<> */
1496 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1497 return nfserr_bad_xdr
;
1499 status
= nfsd4_decode_ignored_string(argp
, 0);
1504 /* ssp_encr_algs<> */
1505 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1506 return nfserr_bad_xdr
;
1508 status
= nfsd4_decode_ignored_string(argp
, 0);
1513 if (xdr_stream_decode_u32(argp
->xdr
, &window
) < 0)
1514 return nfserr_bad_xdr
;
1515 if (xdr_stream_decode_u32(argp
->xdr
, &num_gss_handles
) < 0)
1516 return nfserr_bad_xdr
;
1522 nfsd4_decode_state_protect4_a(struct nfsd4_compoundargs
*argp
,
1523 struct nfsd4_exchange_id
*exid
)
1527 if (xdr_stream_decode_u32(argp
->xdr
, &exid
->spa_how
) < 0)
1528 return nfserr_bad_xdr
;
1529 switch (exid
->spa_how
) {
1533 status
= nfsd4_decode_state_protect_ops(argp
, exid
);
1538 status
= nfsd4_decode_ssv_sp_parms(argp
, exid
);
1543 return nfserr_bad_xdr
;
1550 nfsd4_decode_nfs_impl_id4(struct nfsd4_compoundargs
*argp
,
1551 struct nfsd4_exchange_id
*exid
)
1556 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1557 return nfserr_bad_xdr
;
1562 /* Note that RFC 8881 places no length limit on
1563 * nii_domain, but this implementation permits no
1564 * more than NFS4_OPAQUE_LIMIT bytes */
1565 status
= nfsd4_decode_opaque(argp
, &exid
->nii_domain
);
1568 /* Note that RFC 8881 places no length limit on
1569 * nii_name, but this implementation permits no
1570 * more than NFS4_OPAQUE_LIMIT bytes */
1571 status
= nfsd4_decode_opaque(argp
, &exid
->nii_name
);
1574 status
= nfsd4_decode_nfstime4(argp
, &exid
->nii_time
);
1579 return nfserr_bad_xdr
;
1586 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1587 struct nfsd4_exchange_id
*exid
)
1591 status
= nfsd4_decode_verifier4(argp
, &exid
->verifier
);
1594 status
= nfsd4_decode_opaque(argp
, &exid
->clname
);
1597 if (xdr_stream_decode_u32(argp
->xdr
, &exid
->flags
) < 0)
1598 return nfserr_bad_xdr
;
1599 status
= nfsd4_decode_state_protect4_a(argp
, exid
);
1602 return nfsd4_decode_nfs_impl_id4(argp
, exid
);
1606 nfsd4_decode_channel_attrs4(struct nfsd4_compoundargs
*argp
,
1607 struct nfsd4_channel_attrs
*ca
)
1611 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
* 7);
1613 return nfserr_bad_xdr
;
1615 /* headerpadsz is ignored */
1617 ca
->maxreq_sz
= be32_to_cpup(p
++);
1618 ca
->maxresp_sz
= be32_to_cpup(p
++);
1619 ca
->maxresp_cached
= be32_to_cpup(p
++);
1620 ca
->maxops
= be32_to_cpup(p
++);
1621 ca
->maxreqs
= be32_to_cpup(p
++);
1622 ca
->nr_rdma_attrs
= be32_to_cpup(p
);
1623 switch (ca
->nr_rdma_attrs
) {
1627 if (xdr_stream_decode_u32(argp
->xdr
, &ca
->rdma_attrs
) < 0)
1628 return nfserr_bad_xdr
;
1631 return nfserr_bad_xdr
;
1638 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1639 struct nfsd4_create_session
*sess
)
1643 status
= nfsd4_decode_clientid4(argp
, &sess
->clientid
);
1646 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->seqid
) < 0)
1647 return nfserr_bad_xdr
;
1648 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->flags
) < 0)
1649 return nfserr_bad_xdr
;
1650 status
= nfsd4_decode_channel_attrs4(argp
, &sess
->fore_channel
);
1653 status
= nfsd4_decode_channel_attrs4(argp
, &sess
->back_channel
);
1656 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->callback_prog
) < 0)
1657 return nfserr_bad_xdr
;
1658 status
= nfsd4_decode_cb_sec(argp
, &sess
->cb_sec
);
1666 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1667 struct nfsd4_destroy_session
*destroy_session
)
1669 return nfsd4_decode_sessionid4(argp
, &destroy_session
->sessionid
);
1673 nfsd4_decode_free_stateid(struct nfsd4_compoundargs
*argp
,
1674 struct nfsd4_free_stateid
*free_stateid
)
1676 return nfsd4_decode_stateid4(argp
, &free_stateid
->fr_stateid
);
1679 #ifdef CONFIG_NFSD_PNFS
1681 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs
*argp
,
1682 struct nfsd4_getdeviceinfo
*gdev
)
1686 status
= nfsd4_decode_deviceid4(argp
, &gdev
->gd_devid
);
1689 if (xdr_stream_decode_u32(argp
->xdr
, &gdev
->gd_layout_type
) < 0)
1690 return nfserr_bad_xdr
;
1691 if (xdr_stream_decode_u32(argp
->xdr
, &gdev
->gd_maxcount
) < 0)
1692 return nfserr_bad_xdr
;
1693 if (xdr_stream_decode_uint32_array(argp
->xdr
,
1694 &gdev
->gd_notify_types
, 1) < 0)
1695 return nfserr_bad_xdr
;
1701 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs
*argp
,
1702 struct nfsd4_layoutcommit
*lcp
)
1706 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_seg
.offset
) < 0)
1707 return nfserr_bad_xdr
;
1708 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_seg
.length
) < 0)
1709 return nfserr_bad_xdr
;
1710 if (xdr_stream_decode_bool(argp
->xdr
, &lcp
->lc_reclaim
) < 0)
1711 return nfserr_bad_xdr
;
1712 status
= nfsd4_decode_stateid4(argp
, &lcp
->lc_sid
);
1715 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_newoffset
) < 0)
1716 return nfserr_bad_xdr
;
1717 if (lcp
->lc_newoffset
) {
1718 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_last_wr
) < 0)
1719 return nfserr_bad_xdr
;
1721 lcp
->lc_last_wr
= 0;
1722 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
);
1724 return nfserr_bad_xdr
;
1725 if (xdr_item_is_present(p
)) {
1726 status
= nfsd4_decode_nfstime4(argp
, &lcp
->lc_mtime
);
1730 lcp
->lc_mtime
.tv_nsec
= UTIME_NOW
;
1732 return nfsd4_decode_layoutupdate4(argp
, lcp
);
1736 nfsd4_decode_layoutget(struct nfsd4_compoundargs
*argp
,
1737 struct nfsd4_layoutget
*lgp
)
1741 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_signal
) < 0)
1742 return nfserr_bad_xdr
;
1743 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_layout_type
) < 0)
1744 return nfserr_bad_xdr
;
1745 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_seg
.iomode
) < 0)
1746 return nfserr_bad_xdr
;
1747 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_seg
.offset
) < 0)
1748 return nfserr_bad_xdr
;
1749 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_seg
.length
) < 0)
1750 return nfserr_bad_xdr
;
1751 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_minlength
) < 0)
1752 return nfserr_bad_xdr
;
1753 status
= nfsd4_decode_stateid4(argp
, &lgp
->lg_sid
);
1756 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_maxcount
) < 0)
1757 return nfserr_bad_xdr
;
1763 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs
*argp
,
1764 struct nfsd4_layoutreturn
*lrp
)
1766 if (xdr_stream_decode_bool(argp
->xdr
, &lrp
->lr_reclaim
) < 0)
1767 return nfserr_bad_xdr
;
1768 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_layout_type
) < 0)
1769 return nfserr_bad_xdr
;
1770 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_seg
.iomode
) < 0)
1771 return nfserr_bad_xdr
;
1772 return nfsd4_decode_layoutreturn4(argp
, lrp
);
1774 #endif /* CONFIG_NFSD_PNFS */
1776 static __be32
nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
1777 struct nfsd4_secinfo_no_name
*sin
)
1779 if (xdr_stream_decode_u32(argp
->xdr
, &sin
->sin_style
) < 0)
1780 return nfserr_bad_xdr
;
1785 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1786 struct nfsd4_sequence
*seq
)
1790 status
= nfsd4_decode_sessionid4(argp
, &seq
->sessionid
);
1793 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
* 4);
1795 return nfserr_bad_xdr
;
1796 seq
->seqid
= be32_to_cpup(p
++);
1797 seq
->slotid
= be32_to_cpup(p
++);
1798 seq
->maxslots
= be32_to_cpup(p
++);
1799 seq
->cachethis
= be32_to_cpup(p
);
1805 nfsd4_decode_test_stateid(struct nfsd4_compoundargs
*argp
, struct nfsd4_test_stateid
*test_stateid
)
1807 struct nfsd4_test_stateid_id
*stateid
;
1811 if (xdr_stream_decode_u32(argp
->xdr
, &test_stateid
->ts_num_ids
) < 0)
1812 return nfserr_bad_xdr
;
1814 INIT_LIST_HEAD(&test_stateid
->ts_stateid_list
);
1815 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
1816 stateid
= svcxdr_tmpalloc(argp
, sizeof(*stateid
));
1818 return nfserrno(-ENOMEM
); /* XXX: not jukebox? */
1819 INIT_LIST_HEAD(&stateid
->ts_id_list
);
1820 list_add_tail(&stateid
->ts_id_list
, &test_stateid
->ts_stateid_list
);
1821 status
= nfsd4_decode_stateid4(argp
, &stateid
->ts_id_stateid
);
1829 static __be32
nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs
*argp
,
1830 struct nfsd4_destroy_clientid
*dc
)
1832 return nfsd4_decode_clientid4(argp
, &dc
->clientid
);
1835 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
,
1836 struct nfsd4_reclaim_complete
*rc
)
1838 if (xdr_stream_decode_bool(argp
->xdr
, &rc
->rca_one_fs
) < 0)
1839 return nfserr_bad_xdr
;
1844 nfsd4_decode_fallocate(struct nfsd4_compoundargs
*argp
,
1845 struct nfsd4_fallocate
*fallocate
)
1849 status
= nfsd4_decode_stateid4(argp
, &fallocate
->falloc_stateid
);
1852 if (xdr_stream_decode_u64(argp
->xdr
, &fallocate
->falloc_offset
) < 0)
1853 return nfserr_bad_xdr
;
1854 if (xdr_stream_decode_u64(argp
->xdr
, &fallocate
->falloc_length
) < 0)
1855 return nfserr_bad_xdr
;
1860 static __be32
nfsd4_decode_nl4_server(struct nfsd4_compoundargs
*argp
,
1861 struct nl4_server
*ns
)
1863 struct nfs42_netaddr
*naddr
;
1866 if (xdr_stream_decode_u32(argp
->xdr
, &ns
->nl4_type
) < 0)
1867 return nfserr_bad_xdr
;
1869 /* currently support for 1 inter-server source server */
1870 switch (ns
->nl4_type
) {
1872 naddr
= &ns
->u
.nl4_addr
;
1874 if (xdr_stream_decode_u32(argp
->xdr
, &naddr
->netid_len
) < 0)
1875 return nfserr_bad_xdr
;
1876 if (naddr
->netid_len
> RPCBIND_MAXNETIDLEN
)
1877 return nfserr_bad_xdr
;
1879 p
= xdr_inline_decode(argp
->xdr
, naddr
->netid_len
);
1881 return nfserr_bad_xdr
;
1882 memcpy(naddr
->netid
, p
, naddr
->netid_len
);
1884 if (xdr_stream_decode_u32(argp
->xdr
, &naddr
->addr_len
) < 0)
1885 return nfserr_bad_xdr
;
1886 if (naddr
->addr_len
> RPCBIND_MAXUADDRLEN
)
1887 return nfserr_bad_xdr
;
1889 p
= xdr_inline_decode(argp
->xdr
, naddr
->addr_len
);
1891 return nfserr_bad_xdr
;
1892 memcpy(naddr
->addr
, p
, naddr
->addr_len
);
1895 return nfserr_bad_xdr
;
1902 nfsd4_decode_copy(struct nfsd4_compoundargs
*argp
, struct nfsd4_copy
*copy
)
1904 struct nl4_server
*ns_dummy
;
1905 u32 consecutive
, i
, count
;
1908 status
= nfsd4_decode_stateid4(argp
, ©
->cp_src_stateid
);
1911 status
= nfsd4_decode_stateid4(argp
, ©
->cp_dst_stateid
);
1914 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_src_pos
) < 0)
1915 return nfserr_bad_xdr
;
1916 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_dst_pos
) < 0)
1917 return nfserr_bad_xdr
;
1918 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_count
) < 0)
1919 return nfserr_bad_xdr
;
1920 /* ca_consecutive: we always do consecutive copies */
1921 if (xdr_stream_decode_u32(argp
->xdr
, &consecutive
) < 0)
1922 return nfserr_bad_xdr
;
1923 if (xdr_stream_decode_u32(argp
->xdr
, ©
->cp_synchronous
) < 0)
1924 return nfserr_bad_xdr
;
1926 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1927 return nfserr_bad_xdr
;
1928 copy
->cp_intra
= false;
1929 if (count
== 0) { /* intra-server copy */
1930 copy
->cp_intra
= true;
1934 /* decode all the supplied server addresses but use only the first */
1935 status
= nfsd4_decode_nl4_server(argp
, ©
->cp_src
);
1939 ns_dummy
= kmalloc(sizeof(struct nl4_server
), GFP_KERNEL
);
1940 if (ns_dummy
== NULL
)
1941 return nfserrno(-ENOMEM
); /* XXX: jukebox? */
1942 for (i
= 0; i
< count
- 1; i
++) {
1943 status
= nfsd4_decode_nl4_server(argp
, ns_dummy
);
1955 nfsd4_decode_copy_notify(struct nfsd4_compoundargs
*argp
,
1956 struct nfsd4_copy_notify
*cn
)
1960 status
= nfsd4_decode_stateid4(argp
, &cn
->cpn_src_stateid
);
1963 return nfsd4_decode_nl4_server(argp
, &cn
->cpn_dst
);
1967 nfsd4_decode_offload_status(struct nfsd4_compoundargs
*argp
,
1968 struct nfsd4_offload_status
*os
)
1970 return nfsd4_decode_stateid4(argp
, &os
->stateid
);
1974 nfsd4_decode_seek(struct nfsd4_compoundargs
*argp
, struct nfsd4_seek
*seek
)
1978 status
= nfsd4_decode_stateid4(argp
, &seek
->seek_stateid
);
1981 if (xdr_stream_decode_u64(argp
->xdr
, &seek
->seek_offset
) < 0)
1982 return nfserr_bad_xdr
;
1983 if (xdr_stream_decode_u32(argp
->xdr
, &seek
->seek_whence
) < 0)
1984 return nfserr_bad_xdr
;
1990 nfsd4_decode_clone(struct nfsd4_compoundargs
*argp
, struct nfsd4_clone
*clone
)
1994 status
= nfsd4_decode_stateid4(argp
, &clone
->cl_src_stateid
);
1997 status
= nfsd4_decode_stateid4(argp
, &clone
->cl_dst_stateid
);
2000 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_src_pos
) < 0)
2001 return nfserr_bad_xdr
;
2002 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_dst_pos
) < 0)
2003 return nfserr_bad_xdr
;
2004 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_count
) < 0)
2005 return nfserr_bad_xdr
;
2011 * XDR data that is more than PAGE_SIZE in size is normally part of a
2012 * read or write. However, the size of extended attributes is limited
2013 * by the maximum request size, and then further limited by the underlying
2014 * filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX
2015 * is 64k). Since there is no kvec- or page-based interface to xattrs,
2016 * and we're not dealing with contiguous pages, we need to do some copying.
2020 * Decode data into buffer.
2023 nfsd4_vbuf_from_vector(struct nfsd4_compoundargs
*argp
, struct xdr_buf
*xdr
,
2024 char **bufp
, u32 buflen
)
2026 struct page
**pages
= xdr
->pages
;
2027 struct kvec
*head
= xdr
->head
;
2031 if (buflen
<= head
->iov_len
) {
2033 * We're in luck, the head has enough space. Just return
2034 * the head, no need for copying.
2036 *bufp
= head
->iov_base
;
2040 tmp
= svcxdr_tmpalloc(argp
, buflen
);
2042 return nfserr_jukebox
;
2045 memcpy(dp
, head
->iov_base
, head
->iov_len
);
2046 buflen
-= head
->iov_len
;
2047 dp
+= head
->iov_len
;
2049 while (buflen
> 0) {
2050 len
= min_t(u32
, buflen
, PAGE_SIZE
);
2051 memcpy(dp
, page_address(*pages
), len
);
2063 * Get a user extended attribute name from the XDR buffer.
2064 * It will not have the "user." prefix, so prepend it.
2065 * Lastly, check for nul characters in the name.
2068 nfsd4_decode_xattr_name(struct nfsd4_compoundargs
*argp
, char **namep
)
2070 char *name
, *sp
, *dp
;
2074 if (xdr_stream_decode_u32(argp
->xdr
, &namelen
) < 0)
2075 return nfserr_bad_xdr
;
2076 if (namelen
> (XATTR_NAME_MAX
- XATTR_USER_PREFIX_LEN
))
2077 return nfserr_nametoolong
;
2079 return nfserr_bad_xdr
;
2080 p
= xdr_inline_decode(argp
->xdr
, namelen
);
2082 return nfserr_bad_xdr
;
2083 name
= svcxdr_tmpalloc(argp
, namelen
+ XATTR_USER_PREFIX_LEN
+ 1);
2085 return nfserr_jukebox
;
2086 memcpy(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
);
2089 * Copy the extended attribute name over while checking for 0
2093 dp
= name
+ XATTR_USER_PREFIX_LEN
;
2098 return nfserr_bad_xdr
;
2109 * A GETXATTR op request comes without a length specifier. We just set the
2110 * maximum length for the reply based on XATTR_SIZE_MAX and the maximum
2111 * channel reply size. nfsd_getxattr will probe the length of the xattr,
2112 * check it against getxa_len, and allocate + return the value.
2115 nfsd4_decode_getxattr(struct nfsd4_compoundargs
*argp
,
2116 struct nfsd4_getxattr
*getxattr
)
2121 status
= nfsd4_decode_xattr_name(argp
, &getxattr
->getxa_name
);
2125 maxcount
= svc_max_payload(argp
->rqstp
);
2126 maxcount
= min_t(u32
, XATTR_SIZE_MAX
, maxcount
);
2128 getxattr
->getxa_len
= maxcount
;
2134 nfsd4_decode_setxattr(struct nfsd4_compoundargs
*argp
,
2135 struct nfsd4_setxattr
*setxattr
)
2137 u32 flags
, maxcount
, size
;
2140 if (xdr_stream_decode_u32(argp
->xdr
, &flags
) < 0)
2141 return nfserr_bad_xdr
;
2143 if (flags
> SETXATTR4_REPLACE
)
2144 return nfserr_inval
;
2145 setxattr
->setxa_flags
= flags
;
2147 status
= nfsd4_decode_xattr_name(argp
, &setxattr
->setxa_name
);
2151 maxcount
= svc_max_payload(argp
->rqstp
);
2152 maxcount
= min_t(u32
, XATTR_SIZE_MAX
, maxcount
);
2154 if (xdr_stream_decode_u32(argp
->xdr
, &size
) < 0)
2155 return nfserr_bad_xdr
;
2156 if (size
> maxcount
)
2157 return nfserr_xattr2big
;
2159 setxattr
->setxa_len
= size
;
2161 struct xdr_buf payload
;
2163 if (!xdr_stream_subsegment(argp
->xdr
, &payload
, size
))
2164 return nfserr_bad_xdr
;
2165 status
= nfsd4_vbuf_from_vector(argp
, &payload
,
2166 &setxattr
->setxa_buf
, size
);
2173 nfsd4_decode_listxattrs(struct nfsd4_compoundargs
*argp
,
2174 struct nfsd4_listxattrs
*listxattrs
)
2178 if (xdr_stream_decode_u64(argp
->xdr
, &listxattrs
->lsxa_cookie
) < 0)
2179 return nfserr_bad_xdr
;
2182 * If the cookie is too large to have even one user.x attribute
2183 * plus trailing '\0' left in a maximum size buffer, it's invalid.
2185 if (listxattrs
->lsxa_cookie
>=
2186 (XATTR_LIST_MAX
/ (XATTR_USER_PREFIX_LEN
+ 2)))
2187 return nfserr_badcookie
;
2189 if (xdr_stream_decode_u32(argp
->xdr
, &maxcount
) < 0)
2190 return nfserr_bad_xdr
;
2192 /* Always need at least 2 words (length and one character) */
2193 return nfserr_inval
;
2195 maxcount
= min(maxcount
, svc_max_payload(argp
->rqstp
));
2196 listxattrs
->lsxa_maxcount
= maxcount
;
2202 nfsd4_decode_removexattr(struct nfsd4_compoundargs
*argp
,
2203 struct nfsd4_removexattr
*removexattr
)
2205 return nfsd4_decode_xattr_name(argp
, &removexattr
->rmxa_name
);
2209 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
2215 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
2217 return nfserr_notsupp
;
2220 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
2222 static const nfsd4_dec nfsd4_dec_ops
[] = {
2223 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
2224 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
2225 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
2226 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
2227 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2228 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
2229 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
2230 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2231 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
2232 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
2233 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
2234 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
2235 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
2236 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
2237 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
2238 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
2239 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2240 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
2241 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
2242 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
2243 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_putpubfh
,
2244 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2245 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
2246 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
2247 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
2248 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
2249 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
2250 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
2251 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2252 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2253 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
2254 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
2255 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
2256 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
2257 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
2258 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
2259 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
2261 /* new operations for NFSv4.1 */
2262 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_backchannel_ctl
,
2263 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_bind_conn_to_session
,
2264 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
2265 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
2266 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
2267 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_free_stateid
,
2268 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2269 #ifdef CONFIG_NFSD_PNFS
2270 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_getdeviceinfo
,
2271 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2272 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_layoutcommit
,
2273 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_layoutget
,
2274 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_layoutreturn
,
2276 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2277 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2278 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2279 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2280 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2282 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
2283 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
2284 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2285 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_test_stateid
,
2286 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2287 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_destroy_clientid
,
2288 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
2290 /* new operations for NFSv4.2 */
2291 [OP_ALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
2292 [OP_COPY
] = (nfsd4_dec
)nfsd4_decode_copy
,
2293 [OP_COPY_NOTIFY
] = (nfsd4_dec
)nfsd4_decode_copy_notify
,
2294 [OP_DEALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
2295 [OP_IO_ADVISE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2296 [OP_LAYOUTERROR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2297 [OP_LAYOUTSTATS
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2298 [OP_OFFLOAD_CANCEL
] = (nfsd4_dec
)nfsd4_decode_offload_status
,
2299 [OP_OFFLOAD_STATUS
] = (nfsd4_dec
)nfsd4_decode_offload_status
,
2300 [OP_READ_PLUS
] = (nfsd4_dec
)nfsd4_decode_read
,
2301 [OP_SEEK
] = (nfsd4_dec
)nfsd4_decode_seek
,
2302 [OP_WRITE_SAME
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2303 [OP_CLONE
] = (nfsd4_dec
)nfsd4_decode_clone
,
2304 /* RFC 8276 extended atributes operations */
2305 [OP_GETXATTR
] = (nfsd4_dec
)nfsd4_decode_getxattr
,
2306 [OP_SETXATTR
] = (nfsd4_dec
)nfsd4_decode_setxattr
,
2307 [OP_LISTXATTRS
] = (nfsd4_dec
)nfsd4_decode_listxattrs
,
2308 [OP_REMOVEXATTR
] = (nfsd4_dec
)nfsd4_decode_removexattr
,
2312 nfsd4_opnum_in_range(struct nfsd4_compoundargs
*argp
, struct nfsd4_op
*op
)
2314 if (op
->opnum
< FIRST_NFS4_OP
)
2316 else if (argp
->minorversion
== 0 && op
->opnum
> LAST_NFS40_OP
)
2318 else if (argp
->minorversion
== 1 && op
->opnum
> LAST_NFS41_OP
)
2320 else if (argp
->minorversion
== 2 && op
->opnum
> LAST_NFS42_OP
)
2326 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
2328 struct nfsd4_op
*op
;
2329 bool cachethis
= false;
2330 int auth_slack
= argp
->rqstp
->rq_auth_slack
;
2331 int max_reply
= auth_slack
+ 8; /* opcnt, status */
2337 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->taglen
) < 0)
2339 max_reply
+= XDR_UNIT
;
2341 if (unlikely(argp
->taglen
)) {
2342 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
2344 p
= xdr_inline_decode(argp
->xdr
, argp
->taglen
);
2347 argp
->tag
= svcxdr_savemem(argp
, p
, argp
->taglen
);
2350 max_reply
+= xdr_align_size(argp
->taglen
);
2353 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->minorversion
) < 0)
2355 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->opcnt
) < 0)
2359 * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
2360 * here, so we return success at the xdr level so that
2361 * nfsd4_proc can handle this is an NFS-level error.
2363 if (argp
->opcnt
> NFSD_MAX_OPS_PER_COMPOUND
)
2366 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
2367 argp
->ops
= kzalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
2369 argp
->ops
= argp
->iops
;
2370 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
2375 if (argp
->minorversion
> NFSD_SUPPORTED_MINOR_VERSION
)
2378 for (i
= 0; i
< argp
->opcnt
; i
++) {
2382 if (xdr_stream_decode_u32(argp
->xdr
, &op
->opnum
) < 0)
2384 if (nfsd4_opnum_in_range(argp
, op
)) {
2385 op
->status
= nfsd4_dec_ops
[op
->opnum
](argp
, &op
->u
);
2386 if (op
->status
!= nfs_ok
)
2387 trace_nfsd_compound_decode_err(argp
->rqstp
,
2392 op
->opnum
= OP_ILLEGAL
;
2393 op
->status
= nfserr_op_illegal
;
2395 op
->opdesc
= OPDESC(op
);
2397 * We'll try to cache the result in the DRC if any one
2398 * op in the compound wants to be cached:
2400 cachethis
|= nfsd4_cache_this_op(op
);
2402 if (op
->opnum
== OP_READ
|| op
->opnum
== OP_READ_PLUS
) {
2404 readbytes
+= nfsd4_max_reply(argp
->rqstp
, op
);
2406 max_reply
+= nfsd4_max_reply(argp
->rqstp
, op
);
2408 * OP_LOCK and OP_LOCKT may return a conflicting lock.
2409 * (Special case because it will just skip encoding this
2410 * if it runs out of xdr buffer space, and it is the only
2411 * operation that behaves this way.)
2413 if (op
->opnum
== OP_LOCK
|| op
->opnum
== OP_LOCKT
)
2414 max_reply
+= NFS4_OPAQUE_LIMIT
;
2421 /* Sessions make the DRC unnecessary: */
2422 if (argp
->minorversion
)
2424 svc_reserve(argp
->rqstp
, max_reply
+ readbytes
);
2425 argp
->rqstp
->rq_cachetype
= cachethis
? RC_REPLBUFF
: RC_NOCACHE
;
2427 if (readcount
> 1 || max_reply
> PAGE_SIZE
- auth_slack
)
2428 clear_bit(RQ_SPLICE_OK
, &argp
->rqstp
->rq_flags
);
2433 static __be32
*encode_change(__be32
*p
, struct kstat
*stat
, struct inode
*inode
,
2434 struct svc_export
*exp
)
2436 if (exp
->ex_flags
& NFSEXP_V4ROOT
) {
2437 *p
++ = cpu_to_be32(convert_to_wallclock(exp
->cd
->flush_time
));
2440 p
= xdr_encode_hyper(p
, nfsd4_change_attribute(stat
, inode
));
2445 * ctime (in NFSv4, time_metadata) is not writeable, and the client
2446 * doesn't really care what resolution could theoretically be stored by
2449 * The client cares how close together changes can be while still
2450 * guaranteeing ctime changes. For most filesystems (which have
2451 * timestamps with nanosecond fields) that is limited by the resolution
2452 * of the time returned from current_time() (which I'm assuming to be
2455 static __be32
*encode_time_delta(__be32
*p
, struct inode
*inode
)
2457 struct timespec64 ts
;
2460 ns
= max_t(u32
, NSEC_PER_SEC
/HZ
, inode
->i_sb
->s_time_gran
);
2461 ts
= ns_to_timespec64(ns
);
2463 p
= xdr_encode_hyper(p
, ts
.tv_sec
);
2464 *p
++ = cpu_to_be32(ts
.tv_nsec
);
2469 static __be32
*encode_cinfo(__be32
*p
, struct nfsd4_change_info
*c
)
2471 *p
++ = cpu_to_be32(c
->atomic
);
2472 p
= xdr_encode_hyper(p
, c
->before_change
);
2473 p
= xdr_encode_hyper(p
, c
->after_change
);
2477 /* Encode as an array of strings the string given with components
2478 * separated @sep, escaped with esc_enter and esc_exit.
2480 static __be32
nfsd4_encode_components_esc(struct xdr_stream
*xdr
, char sep
,
2481 char *components
, char esc_enter
,
2487 int strlen
, count
=0;
2488 char *str
, *end
, *next
;
2490 dprintk("nfsd4_encode_components(%s)\n", components
);
2492 pathlen_offset
= xdr
->buf
->len
;
2493 p
= xdr_reserve_space(xdr
, 4);
2495 return nfserr_resource
;
2496 p
++; /* We will fill this in with @count later */
2498 end
= str
= components
;
2500 bool found_esc
= false;
2502 /* try to parse as esc_start, ..., esc_end, sep */
2503 if (*str
== esc_enter
) {
2504 for (; *end
&& (*end
!= esc_exit
); end
++)
2505 /* find esc_exit or end of string */;
2507 if (*end
&& (!*next
|| *next
== sep
)) {
2514 for (; *end
&& (*end
!= sep
); end
++)
2515 /* find sep or end of string */;
2519 p
= xdr_reserve_space(xdr
, strlen
+ 4);
2521 return nfserr_resource
;
2522 p
= xdr_encode_opaque(p
, str
, strlen
);
2532 pathlen
= htonl(count
);
2533 write_bytes_to_xdr_buf(xdr
->buf
, pathlen_offset
, &pathlen
, 4);
2537 /* Encode as an array of strings the string given with components
2540 static __be32
nfsd4_encode_components(struct xdr_stream
*xdr
, char sep
,
2543 return nfsd4_encode_components_esc(xdr
, sep
, components
, 0, 0);
2547 * encode a location element of a fs_locations structure
2549 static __be32
nfsd4_encode_fs_location4(struct xdr_stream
*xdr
,
2550 struct nfsd4_fs_location
*location
)
2554 status
= nfsd4_encode_components_esc(xdr
, ':', location
->hosts
,
2558 status
= nfsd4_encode_components(xdr
, '/', location
->path
);
2565 * Encode a path in RFC3530 'pathname4' format
2567 static __be32
nfsd4_encode_path(struct xdr_stream
*xdr
,
2568 const struct path
*root
,
2569 const struct path
*path
)
2571 struct path cur
= *path
;
2573 struct dentry
**components
= NULL
;
2574 unsigned int ncomponents
= 0;
2575 __be32 err
= nfserr_jukebox
;
2577 dprintk("nfsd4_encode_components(");
2580 /* First walk the path up to the nfsd root, and store the
2581 * dentries/path components in an array.
2584 if (path_equal(&cur
, root
))
2586 if (cur
.dentry
== cur
.mnt
->mnt_root
) {
2587 if (follow_up(&cur
))
2591 if ((ncomponents
& 15) == 0) {
2592 struct dentry
**new;
2593 new = krealloc(components
,
2594 sizeof(*new) * (ncomponents
+ 16),
2600 components
[ncomponents
++] = cur
.dentry
;
2601 cur
.dentry
= dget_parent(cur
.dentry
);
2603 err
= nfserr_resource
;
2604 p
= xdr_reserve_space(xdr
, 4);
2607 *p
++ = cpu_to_be32(ncomponents
);
2609 while (ncomponents
) {
2610 struct dentry
*dentry
= components
[ncomponents
- 1];
2613 spin_lock(&dentry
->d_lock
);
2614 len
= dentry
->d_name
.len
;
2615 p
= xdr_reserve_space(xdr
, len
+ 4);
2617 spin_unlock(&dentry
->d_lock
);
2620 p
= xdr_encode_opaque(p
, dentry
->d_name
.name
, len
);
2621 dprintk("/%pd", dentry
);
2622 spin_unlock(&dentry
->d_lock
);
2631 dput(components
[--ncomponents
]);
2637 static __be32
nfsd4_encode_fsloc_fsroot(struct xdr_stream
*xdr
,
2638 struct svc_rqst
*rqstp
, const struct path
*path
)
2640 struct svc_export
*exp_ps
;
2643 exp_ps
= rqst_find_fsidzero_export(rqstp
);
2645 return nfserrno(PTR_ERR(exp_ps
));
2646 res
= nfsd4_encode_path(xdr
, &exp_ps
->ex_path
, path
);
2652 * encode a fs_locations structure
2654 static __be32
nfsd4_encode_fs_locations(struct xdr_stream
*xdr
,
2655 struct svc_rqst
*rqstp
, struct svc_export
*exp
)
2660 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
2662 status
= nfsd4_encode_fsloc_fsroot(xdr
, rqstp
, &exp
->ex_path
);
2665 p
= xdr_reserve_space(xdr
, 4);
2667 return nfserr_resource
;
2668 *p
++ = cpu_to_be32(fslocs
->locations_count
);
2669 for (i
=0; i
<fslocs
->locations_count
; i
++) {
2670 status
= nfsd4_encode_fs_location4(xdr
, &fslocs
->locations
[i
]);
2677 static u32
nfs4_file_type(umode_t mode
)
2679 switch (mode
& S_IFMT
) {
2680 case S_IFIFO
: return NF4FIFO
;
2681 case S_IFCHR
: return NF4CHR
;
2682 case S_IFDIR
: return NF4DIR
;
2683 case S_IFBLK
: return NF4BLK
;
2684 case S_IFLNK
: return NF4LNK
;
2685 case S_IFREG
: return NF4REG
;
2686 case S_IFSOCK
: return NF4SOCK
;
2687 default: return NF4BAD
;
2691 static inline __be32
2692 nfsd4_encode_aclname(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2693 struct nfs4_ace
*ace
)
2695 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
2696 return nfs4_acl_write_who(xdr
, ace
->whotype
);
2697 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
2698 return nfsd4_encode_group(xdr
, rqstp
, ace
->who_gid
);
2700 return nfsd4_encode_user(xdr
, rqstp
, ace
->who_uid
);
2703 static inline __be32
2704 nfsd4_encode_layout_types(struct xdr_stream
*xdr
, u32 layout_types
)
2707 unsigned long i
= hweight_long(layout_types
);
2709 p
= xdr_reserve_space(xdr
, 4 + 4 * i
);
2711 return nfserr_resource
;
2713 *p
++ = cpu_to_be32(i
);
2715 for (i
= LAYOUT_NFSV4_1_FILES
; i
< LAYOUT_TYPE_MAX
; ++i
)
2716 if (layout_types
& (1 << i
))
2717 *p
++ = cpu_to_be32(i
);
2722 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2723 FATTR4_WORD0_RDATTR_ERROR)
2724 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2725 #define WORD2_ABSENT_FS_ATTRS 0
2727 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2728 static inline __be32
2729 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2730 struct lsmcontext
*context
)
2734 p
= xdr_reserve_space(xdr
, context
->len
+ 4 + 4 + 4);
2736 return nfserr_resource
;
2739 * For now we use a 0 here to indicate the null translation; in
2740 * the future we may place a call to translation code here.
2742 *p
++ = cpu_to_be32(0); /* lfs */
2743 *p
++ = cpu_to_be32(0); /* pi */
2744 p
= xdr_encode_opaque(p
, context
->context
, context
->len
);
2748 static inline __be32
2749 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2750 struct lsmcontext
*context
)
2754 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*bmval2
, u32
*rdattr_err
)
2756 /* As per referral draft: */
2757 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
2758 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
2759 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
2760 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
2761 *rdattr_err
= NFSERR_MOVED
;
2763 return nfserr_moved
;
2765 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
2766 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
2767 *bmval2
&= WORD2_ABSENT_FS_ATTRS
;
2772 static int get_parent_attributes(struct svc_export
*exp
, struct kstat
*stat
)
2774 struct path path
= exp
->ex_path
;
2778 while (follow_up(&path
)) {
2779 if (path
.dentry
!= path
.mnt
->mnt_root
)
2782 err
= vfs_getattr(&path
, stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2788 nfsd4_encode_bitmap(struct xdr_stream
*xdr
, u32 bmval0
, u32 bmval1
, u32 bmval2
)
2793 p
= xdr_reserve_space(xdr
, 16);
2796 *p
++ = cpu_to_be32(3);
2797 *p
++ = cpu_to_be32(bmval0
);
2798 *p
++ = cpu_to_be32(bmval1
);
2799 *p
++ = cpu_to_be32(bmval2
);
2800 } else if (bmval1
) {
2801 p
= xdr_reserve_space(xdr
, 12);
2804 *p
++ = cpu_to_be32(2);
2805 *p
++ = cpu_to_be32(bmval0
);
2806 *p
++ = cpu_to_be32(bmval1
);
2808 p
= xdr_reserve_space(xdr
, 8);
2811 *p
++ = cpu_to_be32(1);
2812 *p
++ = cpu_to_be32(bmval0
);
2817 return nfserr_resource
;
2821 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2825 nfsd4_encode_fattr(struct xdr_stream
*xdr
, struct svc_fh
*fhp
,
2826 struct svc_export
*exp
,
2827 struct dentry
*dentry
, u32
*bmval
,
2828 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2830 u32 bmval0
= bmval
[0];
2831 u32 bmval1
= bmval
[1];
2832 u32 bmval2
= bmval
[2];
2834 struct svc_fh
*tempfh
= NULL
;
2835 struct kstatfs statfs
;
2837 int starting_len
= xdr
->buf
->len
;
2845 struct nfs4_acl
*acl
= NULL
;
2846 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2847 struct lsmcontext context
= { };
2849 bool contextsupport
= false;
2850 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2851 u32 minorversion
= resp
->cstate
.minorversion
;
2852 struct path path
= {
2853 .mnt
= exp
->ex_path
.mnt
,
2856 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
2858 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
2859 BUG_ON(!nfsd_attrs_supported(minorversion
, bmval
));
2861 if (exp
->ex_fslocs
.migrated
) {
2862 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &bmval2
, &rdattr_err
);
2867 err
= vfs_getattr(&path
, &stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2870 if ((bmval0
& (FATTR4_WORD0_FILES_AVAIL
| FATTR4_WORD0_FILES_FREE
|
2871 FATTR4_WORD0_FILES_TOTAL
| FATTR4_WORD0_MAXNAME
)) ||
2872 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
2873 FATTR4_WORD1_SPACE_TOTAL
))) {
2874 err
= vfs_statfs(&path
, &statfs
);
2878 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
2879 tempfh
= kmalloc(sizeof(struct svc_fh
), GFP_KERNEL
);
2880 status
= nfserr_jukebox
;
2883 fh_init(tempfh
, NFS4_FHSIZE
);
2884 status
= fh_compose(tempfh
, exp
, dentry
, NULL
);
2889 if (bmval0
& FATTR4_WORD0_ACL
) {
2890 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
2891 if (err
== -EOPNOTSUPP
)
2892 bmval0
&= ~FATTR4_WORD0_ACL
;
2893 else if (err
== -EINVAL
) {
2894 status
= nfserr_attrnotsupp
;
2896 } else if (err
!= 0)
2900 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2901 if ((bmval2
& FATTR4_WORD2_SECURITY_LABEL
) ||
2902 bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2903 if (exp
->ex_flags
& NFSEXP_SECURITY_LABEL
)
2904 err
= security_inode_getsecctx(d_inode(dentry
),
2908 contextsupport
= (err
== 0);
2909 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2910 if (err
== -EOPNOTSUPP
)
2911 bmval2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2916 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2918 status
= nfsd4_encode_bitmap(xdr
, bmval0
, bmval1
, bmval2
);
2922 attrlen_offset
= xdr
->buf
->len
;
2923 p
= xdr_reserve_space(xdr
, 4);
2926 p
++; /* to be backfilled later */
2928 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2931 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
2933 if (!IS_POSIXACL(dentry
->d_inode
))
2934 supp
[0] &= ~FATTR4_WORD0_ACL
;
2935 if (!contextsupport
)
2936 supp
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
2938 p
= xdr_reserve_space(xdr
, 12);
2941 *p
++ = cpu_to_be32(2);
2942 *p
++ = cpu_to_be32(supp
[0]);
2943 *p
++ = cpu_to_be32(supp
[1]);
2945 p
= xdr_reserve_space(xdr
, 16);
2948 *p
++ = cpu_to_be32(3);
2949 *p
++ = cpu_to_be32(supp
[0]);
2950 *p
++ = cpu_to_be32(supp
[1]);
2951 *p
++ = cpu_to_be32(supp
[2]);
2954 if (bmval0
& FATTR4_WORD0_TYPE
) {
2955 p
= xdr_reserve_space(xdr
, 4);
2958 dummy
= nfs4_file_type(stat
.mode
);
2959 if (dummy
== NF4BAD
) {
2960 status
= nfserr_serverfault
;
2963 *p
++ = cpu_to_be32(dummy
);
2965 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
2966 p
= xdr_reserve_space(xdr
, 4);
2969 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
2970 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
);
2972 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
|
2973 NFS4_FH_VOL_RENAME
);
2975 if (bmval0
& FATTR4_WORD0_CHANGE
) {
2976 p
= xdr_reserve_space(xdr
, 8);
2979 p
= encode_change(p
, &stat
, d_inode(dentry
), exp
);
2981 if (bmval0
& FATTR4_WORD0_SIZE
) {
2982 p
= xdr_reserve_space(xdr
, 8);
2985 p
= xdr_encode_hyper(p
, stat
.size
);
2987 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
2988 p
= xdr_reserve_space(xdr
, 4);
2991 *p
++ = cpu_to_be32(1);
2993 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
2994 p
= xdr_reserve_space(xdr
, 4);
2997 *p
++ = cpu_to_be32(1);
2999 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
3000 p
= xdr_reserve_space(xdr
, 4);
3003 *p
++ = cpu_to_be32(0);
3005 if (bmval0
& FATTR4_WORD0_FSID
) {
3006 p
= xdr_reserve_space(xdr
, 16);
3009 if (exp
->ex_fslocs
.migrated
) {
3010 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MAJOR
);
3011 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MINOR
);
3012 } else switch(fsid_source(fhp
)) {
3013 case FSIDSOURCE_FSID
:
3014 p
= xdr_encode_hyper(p
, (u64
)exp
->ex_fsid
);
3015 p
= xdr_encode_hyper(p
, (u64
)0);
3017 case FSIDSOURCE_DEV
:
3018 *p
++ = cpu_to_be32(0);
3019 *p
++ = cpu_to_be32(MAJOR(stat
.dev
));
3020 *p
++ = cpu_to_be32(0);
3021 *p
++ = cpu_to_be32(MINOR(stat
.dev
));
3023 case FSIDSOURCE_UUID
:
3024 p
= xdr_encode_opaque_fixed(p
, exp
->ex_uuid
,
3029 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
3030 p
= xdr_reserve_space(xdr
, 4);
3033 *p
++ = cpu_to_be32(0);
3035 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
3036 p
= xdr_reserve_space(xdr
, 4);
3039 *p
++ = cpu_to_be32(nn
->nfsd4_lease
);
3041 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
3042 p
= xdr_reserve_space(xdr
, 4);
3045 *p
++ = cpu_to_be32(rdattr_err
);
3047 if (bmval0
& FATTR4_WORD0_ACL
) {
3048 struct nfs4_ace
*ace
;
3051 p
= xdr_reserve_space(xdr
, 4);
3055 *p
++ = cpu_to_be32(0);
3058 p
= xdr_reserve_space(xdr
, 4);
3061 *p
++ = cpu_to_be32(acl
->naces
);
3063 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
3064 p
= xdr_reserve_space(xdr
, 4*3);
3067 *p
++ = cpu_to_be32(ace
->type
);
3068 *p
++ = cpu_to_be32(ace
->flag
);
3069 *p
++ = cpu_to_be32(ace
->access_mask
&
3071 status
= nfsd4_encode_aclname(xdr
, rqstp
, ace
);
3077 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
3078 p
= xdr_reserve_space(xdr
, 4);
3081 *p
++ = cpu_to_be32(IS_POSIXACL(dentry
->d_inode
) ?
3082 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
3084 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
3085 p
= xdr_reserve_space(xdr
, 4);
3088 *p
++ = cpu_to_be32(1);
3090 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
3091 p
= xdr_reserve_space(xdr
, 4);
3094 *p
++ = cpu_to_be32(0);
3096 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
3097 p
= xdr_reserve_space(xdr
, 4);
3100 *p
++ = cpu_to_be32(1);
3102 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
3103 p
= xdr_reserve_space(xdr
, 4);
3106 *p
++ = cpu_to_be32(1);
3108 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
3109 p
= xdr_reserve_space(xdr
, fhp
->fh_handle
.fh_size
+ 4);
3112 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_base
,
3113 fhp
->fh_handle
.fh_size
);
3115 if (bmval0
& FATTR4_WORD0_FILEID
) {
3116 p
= xdr_reserve_space(xdr
, 8);
3119 p
= xdr_encode_hyper(p
, stat
.ino
);
3121 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
3122 p
= xdr_reserve_space(xdr
, 8);
3125 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
3127 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
3128 p
= xdr_reserve_space(xdr
, 8);
3131 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
3133 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
3134 p
= xdr_reserve_space(xdr
, 8);
3137 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_files
);
3139 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
3140 status
= nfsd4_encode_fs_locations(xdr
, rqstp
, exp
);
3144 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
3145 p
= xdr_reserve_space(xdr
, 4);
3148 *p
++ = cpu_to_be32(1);
3150 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
3151 p
= xdr_reserve_space(xdr
, 8);
3154 p
= xdr_encode_hyper(p
, exp
->ex_path
.mnt
->mnt_sb
->s_maxbytes
);
3156 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
3157 p
= xdr_reserve_space(xdr
, 4);
3160 *p
++ = cpu_to_be32(255);
3162 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
3163 p
= xdr_reserve_space(xdr
, 4);
3166 *p
++ = cpu_to_be32(statfs
.f_namelen
);
3168 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
3169 p
= xdr_reserve_space(xdr
, 8);
3172 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
3174 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
3175 p
= xdr_reserve_space(xdr
, 8);
3178 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
3180 if (bmval1
& FATTR4_WORD1_MODE
) {
3181 p
= xdr_reserve_space(xdr
, 4);
3184 *p
++ = cpu_to_be32(stat
.mode
& S_IALLUGO
);
3186 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
3187 p
= xdr_reserve_space(xdr
, 4);
3190 *p
++ = cpu_to_be32(1);
3192 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
3193 p
= xdr_reserve_space(xdr
, 4);
3196 *p
++ = cpu_to_be32(stat
.nlink
);
3198 if (bmval1
& FATTR4_WORD1_OWNER
) {
3199 status
= nfsd4_encode_user(xdr
, rqstp
, stat
.uid
);
3203 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
3204 status
= nfsd4_encode_group(xdr
, rqstp
, stat
.gid
);
3208 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
3209 p
= xdr_reserve_space(xdr
, 8);
3212 *p
++ = cpu_to_be32((u32
) MAJOR(stat
.rdev
));
3213 *p
++ = cpu_to_be32((u32
) MINOR(stat
.rdev
));
3215 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
3216 p
= xdr_reserve_space(xdr
, 8);
3219 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
3220 p
= xdr_encode_hyper(p
, dummy64
);
3222 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
3223 p
= xdr_reserve_space(xdr
, 8);
3226 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
3227 p
= xdr_encode_hyper(p
, dummy64
);
3229 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
3230 p
= xdr_reserve_space(xdr
, 8);
3233 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
3234 p
= xdr_encode_hyper(p
, dummy64
);
3236 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
3237 p
= xdr_reserve_space(xdr
, 8);
3240 dummy64
= (u64
)stat
.blocks
<< 9;
3241 p
= xdr_encode_hyper(p
, dummy64
);
3243 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
3244 p
= xdr_reserve_space(xdr
, 12);
3247 p
= xdr_encode_hyper(p
, (s64
)stat
.atime
.tv_sec
);
3248 *p
++ = cpu_to_be32(stat
.atime
.tv_nsec
);
3250 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
3251 p
= xdr_reserve_space(xdr
, 12);
3254 p
= encode_time_delta(p
, d_inode(dentry
));
3256 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
3257 p
= xdr_reserve_space(xdr
, 12);
3260 p
= xdr_encode_hyper(p
, (s64
)stat
.ctime
.tv_sec
);
3261 *p
++ = cpu_to_be32(stat
.ctime
.tv_nsec
);
3263 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
3264 p
= xdr_reserve_space(xdr
, 12);
3267 p
= xdr_encode_hyper(p
, (s64
)stat
.mtime
.tv_sec
);
3268 *p
++ = cpu_to_be32(stat
.mtime
.tv_nsec
);
3270 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
3271 struct kstat parent_stat
;
3274 p
= xdr_reserve_space(xdr
, 8);
3278 * Get parent's attributes if not ignoring crossmount
3279 * and this is the root of a cross-mounted filesystem.
3281 if (ignore_crossmnt
== 0 &&
3282 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
3283 err
= get_parent_attributes(exp
, &parent_stat
);
3286 ino
= parent_stat
.ino
;
3288 p
= xdr_encode_hyper(p
, ino
);
3290 #ifdef CONFIG_NFSD_PNFS
3291 if (bmval1
& FATTR4_WORD1_FS_LAYOUT_TYPES
) {
3292 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
3297 if (bmval2
& FATTR4_WORD2_LAYOUT_TYPES
) {
3298 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
3303 if (bmval2
& FATTR4_WORD2_LAYOUT_BLKSIZE
) {
3304 p
= xdr_reserve_space(xdr
, 4);
3307 *p
++ = cpu_to_be32(stat
.blksize
);
3309 #endif /* CONFIG_NFSD_PNFS */
3310 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
3313 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
3314 supp
[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0
;
3315 supp
[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1
;
3316 supp
[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2
;
3318 status
= nfsd4_encode_bitmap(xdr
, supp
[0], supp
[1], supp
[2]);
3323 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3324 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
3325 status
= nfsd4_encode_security_label(xdr
, rqstp
, &context
);
3331 if (bmval2
& FATTR4_WORD2_XATTR_SUPPORT
) {
3332 p
= xdr_reserve_space(xdr
, 4);
3335 err
= xattr_supported_namespace(d_inode(dentry
),
3337 *p
++ = cpu_to_be32(err
== 0);
3340 attrlen
= htonl(xdr
->buf
->len
- attrlen_offset
- 4);
3341 write_bytes_to_xdr_buf(xdr
->buf
, attrlen_offset
, &attrlen
, 4);
3345 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3346 if (context
.context
)
3347 security_release_secctx(&context
);
3348 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3355 xdr_truncate_encode(xdr
, starting_len
);
3358 status
= nfserrno(err
);
3361 status
= nfserr_resource
;
3365 static void svcxdr_init_encode_from_buffer(struct xdr_stream
*xdr
,
3366 struct xdr_buf
*buf
, __be32
*p
, int bytes
)
3368 xdr
->scratch
.iov_len
= 0;
3369 memset(buf
, 0, sizeof(struct xdr_buf
));
3370 buf
->head
[0].iov_base
= p
;
3371 buf
->head
[0].iov_len
= 0;
3374 xdr
->iov
= buf
->head
;
3376 xdr
->end
= (void *)p
+ bytes
;
3377 buf
->buflen
= bytes
;
3380 __be32
nfsd4_encode_fattr_to_buf(__be32
**p
, int words
,
3381 struct svc_fh
*fhp
, struct svc_export
*exp
,
3382 struct dentry
*dentry
, u32
*bmval
,
3383 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
3385 struct xdr_buf dummy
;
3386 struct xdr_stream xdr
;
3389 svcxdr_init_encode_from_buffer(&xdr
, &dummy
, *p
, words
<< 2);
3390 ret
= nfsd4_encode_fattr(&xdr
, fhp
, exp
, dentry
, bmval
, rqstp
,
3396 static inline int attributes_need_mount(u32
*bmval
)
3398 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
3400 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
3406 nfsd4_encode_dirent_fattr(struct xdr_stream
*xdr
, struct nfsd4_readdir
*cd
,
3407 const char *name
, int namlen
)
3409 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
3410 struct dentry
*dentry
;
3412 int ignore_crossmnt
= 0;
3414 dentry
= lookup_positive_unlocked(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
3416 return nfserrno(PTR_ERR(dentry
));
3420 * In the case of a mountpoint, the client may be asking for
3421 * attributes that are only properties of the underlying filesystem
3422 * as opposed to the cross-mounted file system. In such a case,
3423 * we will not follow the cross mount and will fill the attribtutes
3424 * directly from the mountpoint dentry.
3426 if (nfsd_mountpoint(dentry
, exp
)) {
3429 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
3430 && !attributes_need_mount(cd
->rd_bmval
)) {
3431 ignore_crossmnt
= 1;
3435 * Why the heck aren't we just using nfsd_lookup??
3436 * Different "."/".." handling? Something else?
3437 * At least, add a comment here to explain....
3439 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
3441 nfserr
= nfserrno(err
);
3444 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
3450 nfserr
= nfsd4_encode_fattr(xdr
, NULL
, exp
, dentry
, cd
->rd_bmval
,
3451 cd
->rd_rqstp
, ignore_crossmnt
);
3459 nfsd4_encode_rdattr_error(struct xdr_stream
*xdr
, __be32 nfserr
)
3463 p
= xdr_reserve_space(xdr
, 20);
3467 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
3468 *p
++ = htonl(0); /* bmval1 */
3470 *p
++ = htonl(4); /* attribute length */
3471 *p
++ = nfserr
; /* no htonl */
3476 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
3477 loff_t offset
, u64 ino
, unsigned int d_type
)
3479 struct readdir_cd
*ccd
= ccdv
;
3480 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
3481 struct xdr_stream
*xdr
= cd
->xdr
;
3482 int start_offset
= xdr
->buf
->len
;
3484 u32 name_and_cookie
;
3486 __be32 nfserr
= nfserr_toosmall
;
3490 /* In nfsv4, "." and ".." never make it onto the wire.. */
3491 if (name
&& isdotent(name
, namlen
)) {
3492 cd
->common
.err
= nfs_ok
;
3496 if (cd
->cookie_offset
) {
3497 wire_offset
= cpu_to_be64(offset
);
3498 write_bytes_to_xdr_buf(xdr
->buf
, cd
->cookie_offset
,
3502 p
= xdr_reserve_space(xdr
, 4);
3505 *p
++ = xdr_one
; /* mark entry present */
3506 cookie_offset
= xdr
->buf
->len
;
3507 p
= xdr_reserve_space(xdr
, 3*4 + namlen
);
3510 p
= xdr_encode_hyper(p
, NFS_OFFSET_MAX
); /* offset of next entry */
3511 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
3513 nfserr
= nfsd4_encode_dirent_fattr(xdr
, cd
, name
, namlen
);
3517 case nfserr_resource
:
3518 nfserr
= nfserr_toosmall
;
3521 xdr_truncate_encode(xdr
, start_offset
);
3525 * If the client requested the RDATTR_ERROR attribute,
3526 * we stuff the error code into this attribute
3527 * and continue. If this attribute was not requested,
3528 * then in accordance with the spec, we fail the
3529 * entire READDIR operation(!)
3531 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
3533 p
= nfsd4_encode_rdattr_error(xdr
, nfserr
);
3535 nfserr
= nfserr_toosmall
;
3539 nfserr
= nfserr_toosmall
;
3540 entry_bytes
= xdr
->buf
->len
- start_offset
;
3541 if (entry_bytes
> cd
->rd_maxcount
)
3543 cd
->rd_maxcount
-= entry_bytes
;
3545 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", so
3546 * let's always let through the first entry, at least:
3548 if (!cd
->rd_dircount
)
3550 name_and_cookie
= 4 + 4 * XDR_QUADLEN(namlen
) + 8;
3551 if (name_and_cookie
> cd
->rd_dircount
&& cd
->cookie_offset
)
3553 cd
->rd_dircount
-= min(cd
->rd_dircount
, name_and_cookie
);
3555 cd
->cookie_offset
= cookie_offset
;
3557 cd
->common
.err
= nfs_ok
;
3560 xdr_truncate_encode(xdr
, start_offset
);
3561 cd
->common
.err
= nfserr
;
3566 nfsd4_encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
3570 p
= xdr_reserve_space(xdr
, sizeof(stateid_t
));
3572 return nfserr_resource
;
3573 *p
++ = cpu_to_be32(sid
->si_generation
);
3574 p
= xdr_encode_opaque_fixed(p
, &sid
->si_opaque
,
3575 sizeof(stateid_opaque_t
));
3580 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
3582 struct xdr_stream
*xdr
= &resp
->xdr
;
3585 p
= xdr_reserve_space(xdr
, 8);
3587 return nfserr_resource
;
3588 *p
++ = cpu_to_be32(access
->ac_supported
);
3589 *p
++ = cpu_to_be32(access
->ac_resp_access
);
3593 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
3595 struct xdr_stream
*xdr
= &resp
->xdr
;
3598 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 8);
3600 return nfserr_resource
;
3601 p
= xdr_encode_opaque_fixed(p
, bcts
->sessionid
.data
,
3602 NFS4_MAX_SESSIONID_LEN
);
3603 *p
++ = cpu_to_be32(bcts
->dir
);
3604 /* Upshifting from TCP to RDMA is not supported */
3605 *p
++ = cpu_to_be32(0);
3610 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
3612 struct xdr_stream
*xdr
= &resp
->xdr
;
3614 return nfsd4_encode_stateid(xdr
, &close
->cl_stateid
);
3619 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
3621 struct xdr_stream
*xdr
= &resp
->xdr
;
3624 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3626 return nfserr_resource
;
3627 p
= xdr_encode_opaque_fixed(p
, commit
->co_verf
.data
,
3628 NFS4_VERIFIER_SIZE
);
3633 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
3635 struct xdr_stream
*xdr
= &resp
->xdr
;
3638 p
= xdr_reserve_space(xdr
, 20);
3640 return nfserr_resource
;
3641 encode_cinfo(p
, &create
->cr_cinfo
);
3642 return nfsd4_encode_bitmap(xdr
, create
->cr_bmval
[0],
3643 create
->cr_bmval
[1], create
->cr_bmval
[2]);
3647 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
3649 struct svc_fh
*fhp
= getattr
->ga_fhp
;
3650 struct xdr_stream
*xdr
= &resp
->xdr
;
3652 return nfsd4_encode_fattr(xdr
, fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
3653 getattr
->ga_bmval
, resp
->rqstp
, 0);
3657 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
3659 struct xdr_stream
*xdr
= &resp
->xdr
;
3660 struct svc_fh
*fhp
= *fhpp
;
3664 len
= fhp
->fh_handle
.fh_size
;
3665 p
= xdr_reserve_space(xdr
, len
+ 4);
3667 return nfserr_resource
;
3668 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_base
, len
);
3673 * Including all fields other than the name, a LOCK4denied structure requires
3674 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3677 nfsd4_encode_lock_denied(struct xdr_stream
*xdr
, struct nfsd4_lock_denied
*ld
)
3679 struct xdr_netobj
*conf
= &ld
->ld_owner
;
3683 p
= xdr_reserve_space(xdr
, 32 + XDR_LEN(conf
->len
));
3686 * Don't fail to return the result just because we can't
3687 * return the conflicting open:
3695 return nfserr_resource
;
3697 p
= xdr_encode_hyper(p
, ld
->ld_start
);
3698 p
= xdr_encode_hyper(p
, ld
->ld_length
);
3699 *p
++ = cpu_to_be32(ld
->ld_type
);
3701 p
= xdr_encode_opaque_fixed(p
, &ld
->ld_clientid
, 8);
3702 p
= xdr_encode_opaque(p
, conf
->data
, conf
->len
);
3704 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
3705 p
= xdr_encode_hyper(p
, (u64
)0); /* clientid */
3706 *p
++ = cpu_to_be32(0); /* length of owner name */
3708 return nfserr_denied
;
3712 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
3714 struct xdr_stream
*xdr
= &resp
->xdr
;
3717 nfserr
= nfsd4_encode_stateid(xdr
, &lock
->lk_resp_stateid
);
3718 else if (nfserr
== nfserr_denied
)
3719 nfserr
= nfsd4_encode_lock_denied(xdr
, &lock
->lk_denied
);
3725 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
3727 struct xdr_stream
*xdr
= &resp
->xdr
;
3729 if (nfserr
== nfserr_denied
)
3730 nfsd4_encode_lock_denied(xdr
, &lockt
->lt_denied
);
3735 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
3737 struct xdr_stream
*xdr
= &resp
->xdr
;
3739 return nfsd4_encode_stateid(xdr
, &locku
->lu_stateid
);
3744 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
3746 struct xdr_stream
*xdr
= &resp
->xdr
;
3749 p
= xdr_reserve_space(xdr
, 20);
3751 return nfserr_resource
;
3752 p
= encode_cinfo(p
, &link
->li_cinfo
);
3758 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
3760 struct xdr_stream
*xdr
= &resp
->xdr
;
3763 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_stateid
);
3766 p
= xdr_reserve_space(xdr
, 24);
3768 return nfserr_resource
;
3769 p
= encode_cinfo(p
, &open
->op_cinfo
);
3770 *p
++ = cpu_to_be32(open
->op_rflags
);
3772 nfserr
= nfsd4_encode_bitmap(xdr
, open
->op_bmval
[0], open
->op_bmval
[1],
3777 p
= xdr_reserve_space(xdr
, 4);
3779 return nfserr_resource
;
3781 *p
++ = cpu_to_be32(open
->op_delegate_type
);
3782 switch (open
->op_delegate_type
) {
3783 case NFS4_OPEN_DELEGATE_NONE
:
3785 case NFS4_OPEN_DELEGATE_READ
:
3786 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3789 p
= xdr_reserve_space(xdr
, 20);
3791 return nfserr_resource
;
3792 *p
++ = cpu_to_be32(open
->op_recall
);
3795 * TODO: ACE's in delegations
3797 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3798 *p
++ = cpu_to_be32(0);
3799 *p
++ = cpu_to_be32(0);
3800 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3802 case NFS4_OPEN_DELEGATE_WRITE
:
3803 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3806 p
= xdr_reserve_space(xdr
, 32);
3808 return nfserr_resource
;
3809 *p
++ = cpu_to_be32(0);
3812 * TODO: space_limit's in delegations
3814 *p
++ = cpu_to_be32(NFS4_LIMIT_SIZE
);
3815 *p
++ = cpu_to_be32(~(u32
)0);
3816 *p
++ = cpu_to_be32(~(u32
)0);
3819 * TODO: ACE's in delegations
3821 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3822 *p
++ = cpu_to_be32(0);
3823 *p
++ = cpu_to_be32(0);
3824 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3826 case NFS4_OPEN_DELEGATE_NONE_EXT
: /* 4.1 */
3827 switch (open
->op_why_no_deleg
) {
3828 case WND4_CONTENTION
:
3830 p
= xdr_reserve_space(xdr
, 8);
3832 return nfserr_resource
;
3833 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3834 /* deleg signaling not supported yet: */
3835 *p
++ = cpu_to_be32(0);
3838 p
= xdr_reserve_space(xdr
, 4);
3840 return nfserr_resource
;
3841 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3847 /* XXX save filehandle here */
3852 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
3854 struct xdr_stream
*xdr
= &resp
->xdr
;
3856 return nfsd4_encode_stateid(xdr
, &oc
->oc_resp_stateid
);
3860 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
3862 struct xdr_stream
*xdr
= &resp
->xdr
;
3864 return nfsd4_encode_stateid(xdr
, &od
->od_stateid
);
3867 static __be32
nfsd4_encode_splice_read(
3868 struct nfsd4_compoundres
*resp
,
3869 struct nfsd4_read
*read
,
3870 struct file
*file
, unsigned long maxcount
)
3872 struct xdr_stream
*xdr
= &resp
->xdr
;
3873 struct xdr_buf
*buf
= xdr
->buf
;
3874 int status
, space_left
;
3877 __be32
*p
= xdr
->p
- 2;
3879 /* Make sure there will be room for padding if needed */
3880 if (xdr
->end
- xdr
->p
< 1)
3881 return nfserr_resource
;
3883 nfserr
= nfsd_splice_read(read
->rd_rqstp
, read
->rd_fhp
,
3884 file
, read
->rd_offset
, &maxcount
, &eof
);
3885 read
->rd_length
= maxcount
;
3888 status
= svc_encode_result_payload(read
->rd_rqstp
,
3889 buf
->head
[0].iov_len
, maxcount
);
3891 nfserr
= nfserrno(status
);
3895 *(p
++) = htonl(eof
);
3896 *(p
++) = htonl(maxcount
);
3898 buf
->page_len
= maxcount
;
3899 buf
->len
+= maxcount
;
3900 xdr
->page_ptr
+= (buf
->page_base
+ maxcount
+ PAGE_SIZE
- 1)
3903 /* Use rest of head for padding and remaining ops: */
3904 buf
->tail
[0].iov_base
= xdr
->p
;
3905 buf
->tail
[0].iov_len
= 0;
3906 xdr
->iov
= buf
->tail
;
3908 int pad
= 4 - (maxcount
&3);
3912 buf
->tail
[0].iov_base
+= maxcount
&3;
3913 buf
->tail
[0].iov_len
= pad
;
3917 space_left
= min_t(int, (void *)xdr
->end
- (void *)xdr
->p
,
3918 buf
->buflen
- buf
->len
);
3919 buf
->buflen
= buf
->len
+ space_left
;
3920 xdr
->end
= (__be32
*)((void *)xdr
->end
+ space_left
);
3926 * nfsd_splice_actor may have already messed with the
3927 * page length; reset it so as not to confuse
3928 * xdr_truncate_encode in our caller.
3934 static __be32
nfsd4_encode_readv(struct nfsd4_compoundres
*resp
,
3935 struct nfsd4_read
*read
,
3936 struct file
*file
, unsigned long maxcount
)
3938 struct xdr_stream
*xdr
= &resp
->xdr
;
3940 int starting_len
= xdr
->buf
->len
- 8;
3945 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, maxcount
);
3946 if (read
->rd_vlen
< 0)
3947 return nfserr_resource
;
3949 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
3950 resp
->rqstp
->rq_vec
, read
->rd_vlen
, &maxcount
,
3952 read
->rd_length
= maxcount
;
3955 if (svc_encode_result_payload(resp
->rqstp
, starting_len
+ 8, maxcount
))
3957 xdr_truncate_encode(xdr
, starting_len
+ 8 + xdr_align_size(maxcount
));
3960 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
3961 tmp
= htonl(maxcount
);
3962 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
3965 pad
= (maxcount
&3) ? 4 - (maxcount
&3) : 0;
3966 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 8 + maxcount
,
3973 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3974 struct nfsd4_read
*read
)
3976 unsigned long maxcount
;
3977 struct xdr_stream
*xdr
= &resp
->xdr
;
3979 int starting_len
= xdr
->buf
->len
;
3984 file
= read
->rd_nf
->nf_file
;
3986 p
= xdr_reserve_space(xdr
, 8); /* eof flag and byte count */
3988 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
));
3989 return nfserr_resource
;
3991 if (resp
->xdr
.buf
->page_len
&&
3992 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
)) {
3994 return nfserr_resource
;
3996 xdr_commit_encode(xdr
);
3998 maxcount
= svc_max_payload(resp
->rqstp
);
3999 maxcount
= min_t(unsigned long, maxcount
,
4000 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4001 maxcount
= min_t(unsigned long, maxcount
, read
->rd_length
);
4003 if (file
->f_op
->splice_read
&&
4004 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
))
4005 nfserr
= nfsd4_encode_splice_read(resp
, read
, file
, maxcount
);
4007 nfserr
= nfsd4_encode_readv(resp
, read
, file
, maxcount
);
4010 xdr_truncate_encode(xdr
, starting_len
);
4016 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
4021 struct xdr_stream
*xdr
= &resp
->xdr
;
4022 int length_offset
= xdr
->buf
->len
;
4026 p
= xdr_reserve_space(xdr
, 4);
4028 return nfserr_resource
;
4029 maxcount
= PAGE_SIZE
;
4031 p
= xdr_reserve_space(xdr
, maxcount
);
4033 return nfserr_resource
;
4035 * XXX: By default, vfs_readlink() will truncate symlinks if they
4036 * would overflow the buffer. Is this kosher in NFSv4? If not, one
4037 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4038 * that truncation occurred, and return NFS4ERR_RESOURCE.
4040 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
,
4041 (char *)p
, &maxcount
);
4042 if (nfserr
== nfserr_isdir
)
4043 nfserr
= nfserr_inval
;
4046 status
= svc_encode_result_payload(readlink
->rl_rqstp
, length_offset
,
4049 nfserr
= nfserrno(status
);
4053 wire_count
= htonl(maxcount
);
4054 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
, &wire_count
, 4);
4055 xdr_truncate_encode(xdr
, length_offset
+ 4 + ALIGN(maxcount
, 4));
4057 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
+ 4 + maxcount
,
4058 &zero
, 4 - (maxcount
&3));
4062 xdr_truncate_encode(xdr
, length_offset
);
4067 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
4073 struct xdr_stream
*xdr
= &resp
->xdr
;
4074 int starting_len
= xdr
->buf
->len
;
4077 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
4079 return nfserr_resource
;
4081 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
4082 *p
++ = cpu_to_be32(0);
4083 *p
++ = cpu_to_be32(0);
4084 resp
->xdr
.buf
->head
[0].iov_len
= ((char *)resp
->xdr
.p
)
4085 - (char *)resp
->xdr
.buf
->head
[0].iov_base
;
4088 * Number of bytes left for directory entries allowing for the
4089 * final 8 bytes of the readdir and a following failed op:
4091 bytes_left
= xdr
->buf
->buflen
- xdr
->buf
->len
4092 - COMPOUND_ERR_SLACK_SPACE
- 8;
4093 if (bytes_left
< 0) {
4094 nfserr
= nfserr_resource
;
4097 maxcount
= svc_max_payload(resp
->rqstp
);
4098 maxcount
= min_t(u32
, readdir
->rd_maxcount
, maxcount
);
4100 * Note the rfc defines rd_maxcount as the size of the
4101 * READDIR4resok structure, which includes the verifier above
4102 * and the 8 bytes encoded at the end of this function:
4104 if (maxcount
< 16) {
4105 nfserr
= nfserr_toosmall
;
4108 maxcount
= min_t(int, maxcount
-16, bytes_left
);
4110 /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
4111 if (!readdir
->rd_dircount
)
4112 readdir
->rd_dircount
= svc_max_payload(resp
->rqstp
);
4115 readdir
->rd_maxcount
= maxcount
;
4116 readdir
->common
.err
= 0;
4117 readdir
->cookie_offset
= 0;
4119 offset
= readdir
->rd_cookie
;
4120 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
4122 &readdir
->common
, nfsd4_encode_dirent
);
4123 if (nfserr
== nfs_ok
&&
4124 readdir
->common
.err
== nfserr_toosmall
&&
4125 xdr
->buf
->len
== starting_len
+ 8) {
4126 /* nothing encoded; which limit did we hit?: */
4127 if (maxcount
- 16 < bytes_left
)
4128 /* It was the fault of rd_maxcount: */
4129 nfserr
= nfserr_toosmall
;
4131 /* We ran out of buffer space: */
4132 nfserr
= nfserr_resource
;
4137 if (readdir
->cookie_offset
) {
4138 wire_offset
= cpu_to_be64(offset
);
4139 write_bytes_to_xdr_buf(xdr
->buf
, readdir
->cookie_offset
,
4143 p
= xdr_reserve_space(xdr
, 8);
4148 *p
++ = 0; /* no more entries */
4149 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
4153 xdr_truncate_encode(xdr
, starting_len
);
4158 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
4160 struct xdr_stream
*xdr
= &resp
->xdr
;
4163 p
= xdr_reserve_space(xdr
, 20);
4165 return nfserr_resource
;
4166 p
= encode_cinfo(p
, &remove
->rm_cinfo
);
4171 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
4173 struct xdr_stream
*xdr
= &resp
->xdr
;
4176 p
= xdr_reserve_space(xdr
, 40);
4178 return nfserr_resource
;
4179 p
= encode_cinfo(p
, &rename
->rn_sinfo
);
4180 p
= encode_cinfo(p
, &rename
->rn_tinfo
);
4185 nfsd4_do_encode_secinfo(struct xdr_stream
*xdr
, struct svc_export
*exp
)
4187 u32 i
, nflavs
, supported
;
4188 struct exp_flavor_info
*flavs
;
4189 struct exp_flavor_info def_flavs
[2];
4190 __be32
*p
, *flavorsp
;
4191 static bool report
= true;
4193 if (exp
->ex_nflavors
) {
4194 flavs
= exp
->ex_flavors
;
4195 nflavs
= exp
->ex_nflavors
;
4196 } else { /* Handling of some defaults in absence of real secinfo: */
4198 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
4200 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
4201 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
4202 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
4204 flavs
[0].pseudoflavor
4205 = svcauth_gss_flavor(exp
->ex_client
);
4208 flavs
[0].pseudoflavor
4209 = exp
->ex_client
->flavour
->flavour
;
4214 p
= xdr_reserve_space(xdr
, 4);
4216 return nfserr_resource
;
4217 flavorsp
= p
++; /* to be backfilled later */
4219 for (i
= 0; i
< nflavs
; i
++) {
4220 rpc_authflavor_t pf
= flavs
[i
].pseudoflavor
;
4221 struct rpcsec_gss_info info
;
4223 if (rpcauth_get_gssinfo(pf
, &info
) == 0) {
4225 p
= xdr_reserve_space(xdr
, 4 + 4 +
4226 XDR_LEN(info
.oid
.len
) + 4 + 4);
4228 return nfserr_resource
;
4229 *p
++ = cpu_to_be32(RPC_AUTH_GSS
);
4230 p
= xdr_encode_opaque(p
, info
.oid
.data
, info
.oid
.len
);
4231 *p
++ = cpu_to_be32(info
.qop
);
4232 *p
++ = cpu_to_be32(info
.service
);
4233 } else if (pf
< RPC_AUTH_MAXFLAVOR
) {
4235 p
= xdr_reserve_space(xdr
, 4);
4237 return nfserr_resource
;
4238 *p
++ = cpu_to_be32(pf
);
4241 pr_warn("NFS: SECINFO: security flavor %u "
4242 "is not supported\n", pf
);
4246 if (nflavs
!= supported
)
4248 *flavorsp
= htonl(supported
);
4253 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4254 struct nfsd4_secinfo
*secinfo
)
4256 struct xdr_stream
*xdr
= &resp
->xdr
;
4258 return nfsd4_do_encode_secinfo(xdr
, secinfo
->si_exp
);
4262 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4263 struct nfsd4_secinfo_no_name
*secinfo
)
4265 struct xdr_stream
*xdr
= &resp
->xdr
;
4267 return nfsd4_do_encode_secinfo(xdr
, secinfo
->sin_exp
);
4271 * The SETATTR encode routine is special -- it always encodes a bitmap,
4272 * regardless of the error status.
4275 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
4277 struct xdr_stream
*xdr
= &resp
->xdr
;
4280 p
= xdr_reserve_space(xdr
, 16);
4282 return nfserr_resource
;
4284 *p
++ = cpu_to_be32(3);
4285 *p
++ = cpu_to_be32(0);
4286 *p
++ = cpu_to_be32(0);
4287 *p
++ = cpu_to_be32(0);
4290 *p
++ = cpu_to_be32(3);
4291 *p
++ = cpu_to_be32(setattr
->sa_bmval
[0]);
4292 *p
++ = cpu_to_be32(setattr
->sa_bmval
[1]);
4293 *p
++ = cpu_to_be32(setattr
->sa_bmval
[2]);
4299 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
4301 struct xdr_stream
*xdr
= &resp
->xdr
;
4305 p
= xdr_reserve_space(xdr
, 8 + NFS4_VERIFIER_SIZE
);
4307 return nfserr_resource
;
4308 p
= xdr_encode_opaque_fixed(p
, &scd
->se_clientid
, 8);
4309 p
= xdr_encode_opaque_fixed(p
, &scd
->se_confirm
,
4310 NFS4_VERIFIER_SIZE
);
4312 else if (nfserr
== nfserr_clid_inuse
) {
4313 p
= xdr_reserve_space(xdr
, 8);
4315 return nfserr_resource
;
4316 *p
++ = cpu_to_be32(0);
4317 *p
++ = cpu_to_be32(0);
4323 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
4325 struct xdr_stream
*xdr
= &resp
->xdr
;
4328 p
= xdr_reserve_space(xdr
, 16);
4330 return nfserr_resource
;
4331 *p
++ = cpu_to_be32(write
->wr_bytes_written
);
4332 *p
++ = cpu_to_be32(write
->wr_how_written
);
4333 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4334 NFS4_VERIFIER_SIZE
);
4339 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4340 struct nfsd4_exchange_id
*exid
)
4342 struct xdr_stream
*xdr
= &resp
->xdr
;
4347 int server_scope_sz
;
4348 uint64_t minor_id
= 0;
4349 struct nfsd_net
*nn
= net_generic(SVC_NET(resp
->rqstp
), nfsd_net_id
);
4351 major_id
= nn
->nfsd_name
;
4352 major_id_sz
= strlen(nn
->nfsd_name
);
4353 server_scope
= nn
->nfsd_name
;
4354 server_scope_sz
= strlen(nn
->nfsd_name
);
4356 p
= xdr_reserve_space(xdr
,
4357 8 /* eir_clientid */ +
4358 4 /* eir_sequenceid */ +
4362 return nfserr_resource
;
4364 p
= xdr_encode_opaque_fixed(p
, &exid
->clientid
, 8);
4365 *p
++ = cpu_to_be32(exid
->seqid
);
4366 *p
++ = cpu_to_be32(exid
->flags
);
4368 *p
++ = cpu_to_be32(exid
->spa_how
);
4370 switch (exid
->spa_how
) {
4374 /* spo_must_enforce bitmap: */
4375 nfserr
= nfsd4_encode_bitmap(xdr
,
4376 exid
->spo_must_enforce
[0],
4377 exid
->spo_must_enforce
[1],
4378 exid
->spo_must_enforce
[2]);
4381 /* spo_must_allow bitmap: */
4382 nfserr
= nfsd4_encode_bitmap(xdr
,
4383 exid
->spo_must_allow
[0],
4384 exid
->spo_must_allow
[1],
4385 exid
->spo_must_allow
[2]);
4393 p
= xdr_reserve_space(xdr
,
4394 8 /* so_minor_id */ +
4395 4 /* so_major_id.len */ +
4396 (XDR_QUADLEN(major_id_sz
) * 4) +
4397 4 /* eir_server_scope.len */ +
4398 (XDR_QUADLEN(server_scope_sz
) * 4) +
4399 4 /* eir_server_impl_id.count (0) */);
4401 return nfserr_resource
;
4403 /* The server_owner struct */
4404 p
= xdr_encode_hyper(p
, minor_id
); /* Minor id */
4406 p
= xdr_encode_opaque(p
, major_id
, major_id_sz
);
4409 p
= xdr_encode_opaque(p
, server_scope
, server_scope_sz
);
4411 /* Implementation id */
4412 *p
++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
4417 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4418 struct nfsd4_create_session
*sess
)
4420 struct xdr_stream
*xdr
= &resp
->xdr
;
4423 p
= xdr_reserve_space(xdr
, 24);
4425 return nfserr_resource
;
4426 p
= xdr_encode_opaque_fixed(p
, sess
->sessionid
.data
,
4427 NFS4_MAX_SESSIONID_LEN
);
4428 *p
++ = cpu_to_be32(sess
->seqid
);
4429 *p
++ = cpu_to_be32(sess
->flags
);
4431 p
= xdr_reserve_space(xdr
, 28);
4433 return nfserr_resource
;
4434 *p
++ = cpu_to_be32(0); /* headerpadsz */
4435 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreq_sz
);
4436 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_sz
);
4437 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_cached
);
4438 *p
++ = cpu_to_be32(sess
->fore_channel
.maxops
);
4439 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreqs
);
4440 *p
++ = cpu_to_be32(sess
->fore_channel
.nr_rdma_attrs
);
4442 if (sess
->fore_channel
.nr_rdma_attrs
) {
4443 p
= xdr_reserve_space(xdr
, 4);
4445 return nfserr_resource
;
4446 *p
++ = cpu_to_be32(sess
->fore_channel
.rdma_attrs
);
4449 p
= xdr_reserve_space(xdr
, 28);
4451 return nfserr_resource
;
4452 *p
++ = cpu_to_be32(0); /* headerpadsz */
4453 *p
++ = cpu_to_be32(sess
->back_channel
.maxreq_sz
);
4454 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_sz
);
4455 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_cached
);
4456 *p
++ = cpu_to_be32(sess
->back_channel
.maxops
);
4457 *p
++ = cpu_to_be32(sess
->back_channel
.maxreqs
);
4458 *p
++ = cpu_to_be32(sess
->back_channel
.nr_rdma_attrs
);
4460 if (sess
->back_channel
.nr_rdma_attrs
) {
4461 p
= xdr_reserve_space(xdr
, 4);
4463 return nfserr_resource
;
4464 *p
++ = cpu_to_be32(sess
->back_channel
.rdma_attrs
);
4470 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4471 struct nfsd4_sequence
*seq
)
4473 struct xdr_stream
*xdr
= &resp
->xdr
;
4476 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 20);
4478 return nfserr_resource
;
4479 p
= xdr_encode_opaque_fixed(p
, seq
->sessionid
.data
,
4480 NFS4_MAX_SESSIONID_LEN
);
4481 *p
++ = cpu_to_be32(seq
->seqid
);
4482 *p
++ = cpu_to_be32(seq
->slotid
);
4483 /* Note slotid's are numbered from zero: */
4484 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_highest_slotid */
4485 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_target_highest_slotid */
4486 *p
++ = cpu_to_be32(seq
->status_flags
);
4488 resp
->cstate
.data_offset
= xdr
->buf
->len
; /* DRC cache data pointer */
4493 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4494 struct nfsd4_test_stateid
*test_stateid
)
4496 struct xdr_stream
*xdr
= &resp
->xdr
;
4497 struct nfsd4_test_stateid_id
*stateid
, *next
;
4500 p
= xdr_reserve_space(xdr
, 4 + (4 * test_stateid
->ts_num_ids
));
4502 return nfserr_resource
;
4503 *p
++ = htonl(test_stateid
->ts_num_ids
);
4505 list_for_each_entry_safe(stateid
, next
, &test_stateid
->ts_stateid_list
, ts_id_list
) {
4506 *p
++ = stateid
->ts_id_status
;
4512 #ifdef CONFIG_NFSD_PNFS
4514 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4515 struct nfsd4_getdeviceinfo
*gdev
)
4517 struct xdr_stream
*xdr
= &resp
->xdr
;
4518 const struct nfsd4_layout_ops
*ops
;
4519 u32 starting_len
= xdr
->buf
->len
, needed_len
;
4522 p
= xdr_reserve_space(xdr
, 4);
4524 return nfserr_resource
;
4526 *p
++ = cpu_to_be32(gdev
->gd_layout_type
);
4528 /* If maxcount is 0 then just update notifications */
4529 if (gdev
->gd_maxcount
!= 0) {
4530 ops
= nfsd4_layout_ops
[gdev
->gd_layout_type
];
4531 nfserr
= ops
->encode_getdeviceinfo(xdr
, gdev
);
4534 * We don't bother to burden the layout drivers with
4535 * enforcing gd_maxcount, just tell the client to
4536 * come back with a bigger buffer if it's not enough.
4538 if (xdr
->buf
->len
+ 4 > gdev
->gd_maxcount
)
4544 if (gdev
->gd_notify_types
) {
4545 p
= xdr_reserve_space(xdr
, 4 + 4);
4547 return nfserr_resource
;
4548 *p
++ = cpu_to_be32(1); /* bitmap length */
4549 *p
++ = cpu_to_be32(gdev
->gd_notify_types
);
4551 p
= xdr_reserve_space(xdr
, 4);
4553 return nfserr_resource
;
4559 dprintk("%s: maxcount too small\n", __func__
);
4560 needed_len
= xdr
->buf
->len
+ 4 /* notifications */;
4561 xdr_truncate_encode(xdr
, starting_len
);
4562 p
= xdr_reserve_space(xdr
, 4);
4564 return nfserr_resource
;
4565 *p
++ = cpu_to_be32(needed_len
);
4566 return nfserr_toosmall
;
4570 nfsd4_encode_layoutget(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4571 struct nfsd4_layoutget
*lgp
)
4573 struct xdr_stream
*xdr
= &resp
->xdr
;
4574 const struct nfsd4_layout_ops
*ops
;
4577 p
= xdr_reserve_space(xdr
, 36 + sizeof(stateid_opaque_t
));
4579 return nfserr_resource
;
4581 *p
++ = cpu_to_be32(1); /* we always set return-on-close */
4582 *p
++ = cpu_to_be32(lgp
->lg_sid
.si_generation
);
4583 p
= xdr_encode_opaque_fixed(p
, &lgp
->lg_sid
.si_opaque
,
4584 sizeof(stateid_opaque_t
));
4586 *p
++ = cpu_to_be32(1); /* we always return a single layout */
4587 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.offset
);
4588 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.length
);
4589 *p
++ = cpu_to_be32(lgp
->lg_seg
.iomode
);
4590 *p
++ = cpu_to_be32(lgp
->lg_layout_type
);
4592 ops
= nfsd4_layout_ops
[lgp
->lg_layout_type
];
4593 return ops
->encode_layoutget(xdr
, lgp
);
4597 nfsd4_encode_layoutcommit(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4598 struct nfsd4_layoutcommit
*lcp
)
4600 struct xdr_stream
*xdr
= &resp
->xdr
;
4603 p
= xdr_reserve_space(xdr
, 4);
4605 return nfserr_resource
;
4606 *p
++ = cpu_to_be32(lcp
->lc_size_chg
);
4607 if (lcp
->lc_size_chg
) {
4608 p
= xdr_reserve_space(xdr
, 8);
4610 return nfserr_resource
;
4611 p
= xdr_encode_hyper(p
, lcp
->lc_newsize
);
4618 nfsd4_encode_layoutreturn(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4619 struct nfsd4_layoutreturn
*lrp
)
4621 struct xdr_stream
*xdr
= &resp
->xdr
;
4624 p
= xdr_reserve_space(xdr
, 4);
4626 return nfserr_resource
;
4627 *p
++ = cpu_to_be32(lrp
->lrs_present
);
4628 if (lrp
->lrs_present
)
4629 return nfsd4_encode_stateid(xdr
, &lrp
->lr_sid
);
4632 #endif /* CONFIG_NFSD_PNFS */
4635 nfsd42_encode_write_res(struct nfsd4_compoundres
*resp
,
4636 struct nfsd42_write_res
*write
, bool sync
)
4639 p
= xdr_reserve_space(&resp
->xdr
, 4);
4641 return nfserr_resource
;
4644 *p
++ = cpu_to_be32(0);
4647 *p
++ = cpu_to_be32(1);
4648 nfserr
= nfsd4_encode_stateid(&resp
->xdr
, &write
->cb_stateid
);
4652 p
= xdr_reserve_space(&resp
->xdr
, 8 + 4 + NFS4_VERIFIER_SIZE
);
4654 return nfserr_resource
;
4656 p
= xdr_encode_hyper(p
, write
->wr_bytes_written
);
4657 *p
++ = cpu_to_be32(write
->wr_stable_how
);
4658 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4659 NFS4_VERIFIER_SIZE
);
4664 nfsd42_encode_nl4_server(struct nfsd4_compoundres
*resp
, struct nl4_server
*ns
)
4666 struct xdr_stream
*xdr
= &resp
->xdr
;
4667 struct nfs42_netaddr
*addr
;
4670 p
= xdr_reserve_space(xdr
, 4);
4671 *p
++ = cpu_to_be32(ns
->nl4_type
);
4673 switch (ns
->nl4_type
) {
4675 addr
= &ns
->u
.nl4_addr
;
4677 /* netid_len, netid, uaddr_len, uaddr (port included
4678 * in RPCBIND_MAXUADDRLEN)
4680 p
= xdr_reserve_space(xdr
,
4682 (XDR_QUADLEN(addr
->netid_len
) * 4) +
4684 (XDR_QUADLEN(addr
->addr_len
) * 4));
4686 return nfserr_resource
;
4688 *p
++ = cpu_to_be32(addr
->netid_len
);
4689 p
= xdr_encode_opaque_fixed(p
, addr
->netid
,
4691 *p
++ = cpu_to_be32(addr
->addr_len
);
4692 p
= xdr_encode_opaque_fixed(p
, addr
->addr
,
4696 WARN_ON_ONCE(ns
->nl4_type
!= NL4_NETADDR
);
4697 return nfserr_inval
;
4704 nfsd4_encode_copy(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4705 struct nfsd4_copy
*copy
)
4709 nfserr
= nfsd42_encode_write_res(resp
, ©
->cp_res
,
4710 !!copy
->cp_synchronous
);
4714 p
= xdr_reserve_space(&resp
->xdr
, 4 + 4);
4715 *p
++ = xdr_one
; /* cr_consecutive */
4716 *p
++ = cpu_to_be32(copy
->cp_synchronous
);
4721 nfsd4_encode_offload_status(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4722 struct nfsd4_offload_status
*os
)
4724 struct xdr_stream
*xdr
= &resp
->xdr
;
4727 p
= xdr_reserve_space(xdr
, 8 + 4);
4729 return nfserr_resource
;
4730 p
= xdr_encode_hyper(p
, os
->count
);
4731 *p
++ = cpu_to_be32(0);
4736 nfsd4_encode_read_plus_data(struct nfsd4_compoundres
*resp
,
4737 struct nfsd4_read
*read
,
4738 unsigned long *maxcount
, u32
*eof
,
4741 struct xdr_stream
*xdr
= &resp
->xdr
;
4742 struct file
*file
= read
->rd_nf
->nf_file
;
4743 int starting_len
= xdr
->buf
->len
;
4749 hole_pos
= pos
? *pos
: vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4750 if (hole_pos
> read
->rd_offset
)
4751 *maxcount
= min_t(unsigned long, *maxcount
, hole_pos
- read
->rd_offset
);
4752 *maxcount
= min_t(unsigned long, *maxcount
, (xdr
->buf
->buflen
- xdr
->buf
->len
));
4754 /* Content type, offset, byte count */
4755 p
= xdr_reserve_space(xdr
, 4 + 8 + 4);
4757 return nfserr_resource
;
4759 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, *maxcount
);
4760 if (read
->rd_vlen
< 0)
4761 return nfserr_resource
;
4763 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
4764 resp
->rqstp
->rq_vec
, read
->rd_vlen
, maxcount
, eof
);
4767 xdr_truncate_encode(xdr
, starting_len
+ 16 + xdr_align_size(*maxcount
));
4769 tmp
= htonl(NFS4_CONTENT_DATA
);
4770 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4771 tmp64
= cpu_to_be64(read
->rd_offset
);
4772 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp64
, 8);
4773 tmp
= htonl(*maxcount
);
4774 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 12, &tmp
, 4);
4777 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 16 + *maxcount
, &tmp
,
4778 xdr_pad_size(*maxcount
));
4783 nfsd4_encode_read_plus_hole(struct nfsd4_compoundres
*resp
,
4784 struct nfsd4_read
*read
,
4785 unsigned long *maxcount
, u32
*eof
)
4787 struct file
*file
= read
->rd_nf
->nf_file
;
4788 loff_t data_pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_DATA
);
4789 loff_t f_size
= i_size_read(file_inode(file
));
4790 unsigned long count
;
4793 if (data_pos
== -ENXIO
)
4795 else if (data_pos
<= read
->rd_offset
|| (data_pos
< f_size
&& data_pos
% PAGE_SIZE
))
4796 return nfsd4_encode_read_plus_data(resp
, read
, maxcount
, eof
, &f_size
);
4797 count
= data_pos
- read
->rd_offset
;
4799 /* Content type, offset, byte count */
4800 p
= xdr_reserve_space(&resp
->xdr
, 4 + 8 + 8);
4802 return nfserr_resource
;
4804 *p
++ = htonl(NFS4_CONTENT_HOLE
);
4805 p
= xdr_encode_hyper(p
, read
->rd_offset
);
4806 p
= xdr_encode_hyper(p
, count
);
4808 *eof
= (read
->rd_offset
+ count
) >= f_size
;
4809 *maxcount
= min_t(unsigned long, count
, *maxcount
);
4814 nfsd4_encode_read_plus(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4815 struct nfsd4_read
*read
)
4817 unsigned long maxcount
, count
;
4818 struct xdr_stream
*xdr
= &resp
->xdr
;
4820 int starting_len
= xdr
->buf
->len
;
4821 int last_segment
= xdr
->buf
->len
;
4830 file
= read
->rd_nf
->nf_file
;
4832 /* eof flag, segment count */
4833 p
= xdr_reserve_space(xdr
, 4 + 4);
4835 return nfserr_resource
;
4836 xdr_commit_encode(xdr
);
4838 maxcount
= svc_max_payload(resp
->rqstp
);
4839 maxcount
= min_t(unsigned long, maxcount
,
4840 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4841 maxcount
= min_t(unsigned long, maxcount
, read
->rd_length
);
4844 eof
= read
->rd_offset
>= i_size_read(file_inode(file
));
4848 pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4849 is_data
= pos
> read
->rd_offset
;
4851 while (count
> 0 && !eof
) {
4854 nfserr
= nfsd4_encode_read_plus_data(resp
, read
, &maxcount
, &eof
,
4855 segments
== 0 ? &pos
: NULL
);
4857 nfserr
= nfsd4_encode_read_plus_hole(resp
, read
, &maxcount
, &eof
);
4861 read
->rd_offset
+= maxcount
;
4863 last_segment
= xdr
->buf
->len
;
4868 if (nfserr
&& segments
== 0)
4869 xdr_truncate_encode(xdr
, starting_len
);
4872 xdr_truncate_encode(xdr
, last_segment
);
4877 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4878 tmp
= htonl(segments
);
4879 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
4886 nfsd4_encode_copy_notify(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4887 struct nfsd4_copy_notify
*cn
)
4889 struct xdr_stream
*xdr
= &resp
->xdr
;
4896 p
= xdr_reserve_space(xdr
, 12);
4898 return nfserr_resource
;
4900 /* cnr_lease_time */
4901 p
= xdr_encode_hyper(p
, cn
->cpn_sec
);
4902 *p
++ = cpu_to_be32(cn
->cpn_nsec
);
4905 nfserr
= nfsd4_encode_stateid(xdr
, &cn
->cpn_cnr_stateid
);
4909 /* cnr_src.nl_nsvr */
4910 p
= xdr_reserve_space(xdr
, 4);
4912 return nfserr_resource
;
4914 *p
++ = cpu_to_be32(1);
4916 return nfsd42_encode_nl4_server(resp
, &cn
->cpn_src
);
4920 nfsd4_encode_seek(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4921 struct nfsd4_seek
*seek
)
4925 p
= xdr_reserve_space(&resp
->xdr
, 4 + 8);
4926 *p
++ = cpu_to_be32(seek
->seek_eof
);
4927 p
= xdr_encode_hyper(p
, seek
->seek_pos
);
4933 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
4939 * Encode kmalloc-ed buffer in to XDR stream.
4942 nfsd4_vbuf_to_stream(struct xdr_stream
*xdr
, char *buf
, u32 buflen
)
4947 cplen
= min_t(unsigned long, buflen
,
4948 ((void *)xdr
->end
- (void *)xdr
->p
));
4949 p
= xdr_reserve_space(xdr
, cplen
);
4951 return nfserr_resource
;
4953 memcpy(p
, buf
, cplen
);
4958 cplen
= min_t(u32
, buflen
, PAGE_SIZE
);
4959 p
= xdr_reserve_space(xdr
, cplen
);
4961 return nfserr_resource
;
4963 memcpy(p
, buf
, cplen
);
4965 if (cplen
< PAGE_SIZE
) {
4967 * We're done, with a length that wasn't page
4968 * aligned, so possibly not word aligned. Pad
4969 * any trailing bytes with 0.
4971 xdr_encode_opaque_fixed(p
, NULL
, cplen
);
4975 buflen
-= PAGE_SIZE
;
4983 nfsd4_encode_getxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4984 struct nfsd4_getxattr
*getxattr
)
4986 struct xdr_stream
*xdr
= &resp
->xdr
;
4989 p
= xdr_reserve_space(xdr
, 4);
4991 return nfserr_resource
;
4993 *p
= cpu_to_be32(getxattr
->getxa_len
);
4995 if (getxattr
->getxa_len
== 0)
4998 err
= nfsd4_vbuf_to_stream(xdr
, getxattr
->getxa_buf
,
4999 getxattr
->getxa_len
);
5001 kvfree(getxattr
->getxa_buf
);
5007 nfsd4_encode_setxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5008 struct nfsd4_setxattr
*setxattr
)
5010 struct xdr_stream
*xdr
= &resp
->xdr
;
5013 p
= xdr_reserve_space(xdr
, 20);
5015 return nfserr_resource
;
5017 encode_cinfo(p
, &setxattr
->setxa_cinfo
);
5023 * See if there are cookie values that can be rejected outright.
5026 nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs
*listxattrs
,
5029 u64 cookie
= listxattrs
->lsxa_cookie
;
5032 * If the cookie is larger than the maximum number we can fit
5033 * in either the buffer we just got back from vfs_listxattr, or,
5034 * XDR-encoded, in the return buffer, it's invalid.
5036 if (cookie
> (listxattrs
->lsxa_len
) / (XATTR_USER_PREFIX_LEN
+ 2))
5037 return nfserr_badcookie
;
5039 if (cookie
> (listxattrs
->lsxa_maxcount
/
5040 (XDR_QUADLEN(XATTR_USER_PREFIX_LEN
+ 2) + 4)))
5041 return nfserr_badcookie
;
5043 *offsetp
= (u32
)cookie
;
5048 nfsd4_encode_listxattrs(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5049 struct nfsd4_listxattrs
*listxattrs
)
5051 struct xdr_stream
*xdr
= &resp
->xdr
;
5052 u32 cookie_offset
, count_offset
, eof
;
5053 u32 left
, xdrleft
, slen
, count
;
5063 status
= nfsd4_listxattr_validate_cookie(listxattrs
, &offset
);
5068 * Reserve space for the cookie and the name array count. Record
5069 * the offsets to save them later.
5071 cookie_offset
= xdr
->buf
->len
;
5072 count_offset
= cookie_offset
+ 8;
5073 p
= xdr_reserve_space(xdr
, 12);
5075 status
= nfserr_resource
;
5080 left
= listxattrs
->lsxa_len
;
5081 sp
= listxattrs
->lsxa_buf
;
5084 xdrleft
= listxattrs
->lsxa_maxcount
;
5086 while (left
> 0 && xdrleft
> 0) {
5090 * Check if this is a "user." attribute, skip it if not.
5092 if (strncmp(sp
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
))
5095 slen
-= XATTR_USER_PREFIX_LEN
;
5096 xdrlen
= 4 + ((slen
+ 3) & ~3);
5097 if (xdrlen
> xdrleft
) {
5100 * Can't even fit the first attribute name.
5102 status
= nfserr_toosmall
;
5109 left
-= XATTR_USER_PREFIX_LEN
;
5110 sp
+= XATTR_USER_PREFIX_LEN
;
5111 if (nuser
++ < offset
)
5115 p
= xdr_reserve_space(xdr
, xdrlen
);
5117 status
= nfserr_resource
;
5121 xdr_encode_opaque(p
, sp
, slen
);
5131 * If there were user attributes to copy, but we didn't copy
5132 * any, the offset was too large (e.g. the cookie was invalid).
5134 if (nuser
> 0 && count
== 0) {
5135 status
= nfserr_badcookie
;
5140 p
= xdr_reserve_space(xdr
, 4);
5142 status
= nfserr_resource
;
5145 *p
= cpu_to_be32(eof
);
5147 cookie
= offset
+ count
;
5149 write_bytes_to_xdr_buf(xdr
->buf
, cookie_offset
, &cookie
, 8);
5150 tmp
= cpu_to_be32(count
);
5151 write_bytes_to_xdr_buf(xdr
->buf
, count_offset
, &tmp
, 4);
5153 if (listxattrs
->lsxa_len
)
5154 kvfree(listxattrs
->lsxa_buf
);
5159 nfsd4_encode_removexattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5160 struct nfsd4_removexattr
*removexattr
)
5162 struct xdr_stream
*xdr
= &resp
->xdr
;
5165 p
= xdr_reserve_space(xdr
, 20);
5167 return nfserr_resource
;
5169 p
= encode_cinfo(p
, &removexattr
->rmxa_cinfo
);
5173 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
5176 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5177 * since we don't need to filter out obsolete ops as this is
5178 * done in the decoding phase.
5180 static const nfsd4_enc nfsd4_enc_ops
[] = {
5181 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
5182 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
5183 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
5184 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
5185 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5186 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5187 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
5188 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
5189 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
5190 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
5191 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
5192 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
5193 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5194 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5195 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5196 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
5197 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5198 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
5199 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
5200 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5201 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5202 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5203 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
5204 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
5205 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
5206 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
5207 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
5208 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
5209 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5210 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5211 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
5212 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
5213 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
5214 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
5215 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5216 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
5217 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
5219 /* NFSv4.1 operations */
5220 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5221 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
5222 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
5223 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
5224 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5225 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5226 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5227 #ifdef CONFIG_NFSD_PNFS
5228 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_getdeviceinfo
,
5229 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5230 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_layoutcommit
,
5231 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_layoutget
,
5232 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_layoutreturn
,
5234 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
5235 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5236 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
5237 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
5238 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5240 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
5241 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
5242 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
5243 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
5244 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5245 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5246 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5248 /* NFSv4.2 operations */
5249 [OP_ALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5250 [OP_COPY
] = (nfsd4_enc
)nfsd4_encode_copy
,
5251 [OP_COPY_NOTIFY
] = (nfsd4_enc
)nfsd4_encode_copy_notify
,
5252 [OP_DEALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5253 [OP_IO_ADVISE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5254 [OP_LAYOUTERROR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5255 [OP_LAYOUTSTATS
] = (nfsd4_enc
)nfsd4_encode_noop
,
5256 [OP_OFFLOAD_CANCEL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5257 [OP_OFFLOAD_STATUS
] = (nfsd4_enc
)nfsd4_encode_offload_status
,
5258 [OP_READ_PLUS
] = (nfsd4_enc
)nfsd4_encode_read_plus
,
5259 [OP_SEEK
] = (nfsd4_enc
)nfsd4_encode_seek
,
5260 [OP_WRITE_SAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
5261 [OP_CLONE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5263 /* RFC 8276 extended atributes operations */
5264 [OP_GETXATTR
] = (nfsd4_enc
)nfsd4_encode_getxattr
,
5265 [OP_SETXATTR
] = (nfsd4_enc
)nfsd4_encode_setxattr
,
5266 [OP_LISTXATTRS
] = (nfsd4_enc
)nfsd4_encode_listxattrs
,
5267 [OP_REMOVEXATTR
] = (nfsd4_enc
)nfsd4_encode_removexattr
,
5271 * Calculate whether we still have space to encode repsize bytes.
5272 * There are two considerations:
5273 * - For NFS versions >=4.1, the size of the reply must stay within
5275 * - For all NFS versions, we must stay within limited preallocated
5278 * This is called before the operation is processed, so can only provide
5279 * an upper estimate. For some nonidempotent operations (such as
5280 * getattr), it's not necessarily a problem if that estimate is wrong,
5281 * as we can fail it after processing without significant side effects.
5283 __be32
nfsd4_check_resp_size(struct nfsd4_compoundres
*resp
, u32 respsize
)
5285 struct xdr_buf
*buf
= &resp
->rqstp
->rq_res
;
5286 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5288 if (buf
->len
+ respsize
<= buf
->buflen
)
5290 if (!nfsd4_has_session(&resp
->cstate
))
5291 return nfserr_resource
;
5292 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
) {
5294 return nfserr_rep_too_big_to_cache
;
5296 return nfserr_rep_too_big
;
5300 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
5302 struct xdr_stream
*xdr
= &resp
->xdr
;
5303 struct nfs4_stateowner
*so
= resp
->cstate
.replay_owner
;
5304 struct svc_rqst
*rqstp
= resp
->rqstp
;
5305 const struct nfsd4_operation
*opdesc
= op
->opdesc
;
5306 int post_err_offset
;
5310 p
= xdr_reserve_space(xdr
, 8);
5315 *p
++ = cpu_to_be32(op
->opnum
);
5316 post_err_offset
= xdr
->buf
->len
;
5318 if (op
->opnum
== OP_ILLEGAL
)
5320 if (op
->status
&& opdesc
&&
5321 !(opdesc
->op_flags
& OP_NONTRIVIAL_ERROR_ENCODE
))
5323 BUG_ON(op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
5324 !nfsd4_enc_ops
[op
->opnum
]);
5325 encoder
= nfsd4_enc_ops
[op
->opnum
];
5326 op
->status
= encoder(resp
, op
->status
, &op
->u
);
5328 trace_nfsd_compound_encode_err(rqstp
, op
->opnum
, op
->status
);
5329 if (opdesc
&& opdesc
->op_release
)
5330 opdesc
->op_release(&op
->u
);
5331 xdr_commit_encode(xdr
);
5333 /* nfsd4_check_resp_size guarantees enough room for error status */
5335 int space_needed
= 0;
5336 if (!nfsd4_last_compound_op(rqstp
))
5337 space_needed
= COMPOUND_ERR_SLACK_SPACE
;
5338 op
->status
= nfsd4_check_resp_size(resp
, space_needed
);
5340 if (op
->status
== nfserr_resource
&& nfsd4_has_session(&resp
->cstate
)) {
5341 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5343 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
)
5344 op
->status
= nfserr_rep_too_big_to_cache
;
5346 op
->status
= nfserr_rep_too_big
;
5348 if (op
->status
== nfserr_resource
||
5349 op
->status
== nfserr_rep_too_big
||
5350 op
->status
== nfserr_rep_too_big_to_cache
) {
5352 * The operation may have already been encoded or
5353 * partially encoded. No op returns anything additional
5354 * in the case of one of these three errors, so we can
5355 * just truncate back to after the status. But it's a
5356 * bug if we had to do this on a non-idempotent op:
5358 warn_on_nonidempotent_op(op
);
5359 xdr_truncate_encode(xdr
, post_err_offset
);
5362 int len
= xdr
->buf
->len
- post_err_offset
;
5364 so
->so_replay
.rp_status
= op
->status
;
5365 so
->so_replay
.rp_buflen
= len
;
5366 read_bytes_from_xdr_buf(xdr
->buf
, post_err_offset
,
5367 so
->so_replay
.rp_buf
, len
);
5370 /* Note that op->status is already in network byte order: */
5371 write_bytes_to_xdr_buf(xdr
->buf
, post_err_offset
- 4, &op
->status
, 4);
5375 * Encode the reply stored in the stateowner reply cache
5377 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5378 * previously sent already encoded operation.
5381 nfsd4_encode_replay(struct xdr_stream
*xdr
, struct nfsd4_op
*op
)
5384 struct nfs4_replay
*rp
= op
->replay
;
5386 p
= xdr_reserve_space(xdr
, 8 + rp
->rp_buflen
);
5391 *p
++ = cpu_to_be32(op
->opnum
);
5392 *p
++ = rp
->rp_status
; /* already xdr'ed */
5394 p
= xdr_encode_opaque_fixed(p
, rp
->rp_buf
, rp
->rp_buflen
);
5397 void nfsd4_release_compoundargs(struct svc_rqst
*rqstp
)
5399 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5401 if (args
->ops
!= args
->iops
) {
5403 args
->ops
= args
->iops
;
5405 while (args
->to_free
) {
5406 struct svcxdr_tmpbuf
*tb
= args
->to_free
;
5407 args
->to_free
= tb
->next
;
5413 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
)
5415 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5417 /* svcxdr_tmp_alloc */
5418 args
->to_free
= NULL
;
5420 args
->xdr
= &rqstp
->rq_arg_stream
;
5421 args
->ops
= args
->iops
;
5422 args
->rqstp
= rqstp
;
5424 return nfsd4_decode_compound(args
);
5428 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
)
5430 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
5431 struct xdr_buf
*buf
= resp
->xdr
.buf
;
5433 WARN_ON_ONCE(buf
->len
!= buf
->head
[0].iov_len
+ buf
->page_len
+
5434 buf
->tail
[0].iov_len
);
5436 *p
= resp
->cstate
.status
;
5438 rqstp
->rq_next_page
= resp
->xdr
.page_ptr
+ 1;
5441 *p
++ = htonl(resp
->taglen
);
5442 memcpy(p
, resp
->tag
, resp
->taglen
);
5443 p
+= XDR_QUADLEN(resp
->taglen
);
5444 *p
++ = htonl(resp
->opcnt
);
5446 nfsd4_sequence_done(resp
);