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", and
3546 * notes that it could be zero. If it is zero, then the server
3547 * should enforce only the rd_maxcount value.
3549 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
);
3554 if (!cd
->rd_dircount
)
3555 cd
->rd_maxcount
= 0;
3558 cd
->cookie_offset
= cookie_offset
;
3560 cd
->common
.err
= nfs_ok
;
3563 xdr_truncate_encode(xdr
, start_offset
);
3564 cd
->common
.err
= nfserr
;
3569 nfsd4_encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
3573 p
= xdr_reserve_space(xdr
, sizeof(stateid_t
));
3575 return nfserr_resource
;
3576 *p
++ = cpu_to_be32(sid
->si_generation
);
3577 p
= xdr_encode_opaque_fixed(p
, &sid
->si_opaque
,
3578 sizeof(stateid_opaque_t
));
3583 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
3585 struct xdr_stream
*xdr
= resp
->xdr
;
3588 p
= xdr_reserve_space(xdr
, 8);
3590 return nfserr_resource
;
3591 *p
++ = cpu_to_be32(access
->ac_supported
);
3592 *p
++ = cpu_to_be32(access
->ac_resp_access
);
3596 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
3598 struct xdr_stream
*xdr
= resp
->xdr
;
3601 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 8);
3603 return nfserr_resource
;
3604 p
= xdr_encode_opaque_fixed(p
, bcts
->sessionid
.data
,
3605 NFS4_MAX_SESSIONID_LEN
);
3606 *p
++ = cpu_to_be32(bcts
->dir
);
3607 /* Upshifting from TCP to RDMA is not supported */
3608 *p
++ = cpu_to_be32(0);
3613 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
3615 struct xdr_stream
*xdr
= resp
->xdr
;
3617 return nfsd4_encode_stateid(xdr
, &close
->cl_stateid
);
3622 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
3624 struct xdr_stream
*xdr
= resp
->xdr
;
3627 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3629 return nfserr_resource
;
3630 p
= xdr_encode_opaque_fixed(p
, commit
->co_verf
.data
,
3631 NFS4_VERIFIER_SIZE
);
3636 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
3638 struct xdr_stream
*xdr
= resp
->xdr
;
3641 p
= xdr_reserve_space(xdr
, 20);
3643 return nfserr_resource
;
3644 encode_cinfo(p
, &create
->cr_cinfo
);
3645 return nfsd4_encode_bitmap(xdr
, create
->cr_bmval
[0],
3646 create
->cr_bmval
[1], create
->cr_bmval
[2]);
3650 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
3652 struct svc_fh
*fhp
= getattr
->ga_fhp
;
3653 struct xdr_stream
*xdr
= resp
->xdr
;
3655 return nfsd4_encode_fattr(xdr
, fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
3656 getattr
->ga_bmval
, resp
->rqstp
, 0);
3660 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
3662 struct xdr_stream
*xdr
= resp
->xdr
;
3663 struct svc_fh
*fhp
= *fhpp
;
3667 len
= fhp
->fh_handle
.fh_size
;
3668 p
= xdr_reserve_space(xdr
, len
+ 4);
3670 return nfserr_resource
;
3671 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_base
, len
);
3676 * Including all fields other than the name, a LOCK4denied structure requires
3677 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3680 nfsd4_encode_lock_denied(struct xdr_stream
*xdr
, struct nfsd4_lock_denied
*ld
)
3682 struct xdr_netobj
*conf
= &ld
->ld_owner
;
3686 p
= xdr_reserve_space(xdr
, 32 + XDR_LEN(conf
->len
));
3689 * Don't fail to return the result just because we can't
3690 * return the conflicting open:
3698 return nfserr_resource
;
3700 p
= xdr_encode_hyper(p
, ld
->ld_start
);
3701 p
= xdr_encode_hyper(p
, ld
->ld_length
);
3702 *p
++ = cpu_to_be32(ld
->ld_type
);
3704 p
= xdr_encode_opaque_fixed(p
, &ld
->ld_clientid
, 8);
3705 p
= xdr_encode_opaque(p
, conf
->data
, conf
->len
);
3707 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
3708 p
= xdr_encode_hyper(p
, (u64
)0); /* clientid */
3709 *p
++ = cpu_to_be32(0); /* length of owner name */
3711 return nfserr_denied
;
3715 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
3717 struct xdr_stream
*xdr
= resp
->xdr
;
3720 nfserr
= nfsd4_encode_stateid(xdr
, &lock
->lk_resp_stateid
);
3721 else if (nfserr
== nfserr_denied
)
3722 nfserr
= nfsd4_encode_lock_denied(xdr
, &lock
->lk_denied
);
3728 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
3730 struct xdr_stream
*xdr
= resp
->xdr
;
3732 if (nfserr
== nfserr_denied
)
3733 nfsd4_encode_lock_denied(xdr
, &lockt
->lt_denied
);
3738 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
3740 struct xdr_stream
*xdr
= resp
->xdr
;
3742 return nfsd4_encode_stateid(xdr
, &locku
->lu_stateid
);
3747 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
3749 struct xdr_stream
*xdr
= resp
->xdr
;
3752 p
= xdr_reserve_space(xdr
, 20);
3754 return nfserr_resource
;
3755 p
= encode_cinfo(p
, &link
->li_cinfo
);
3761 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
3763 struct xdr_stream
*xdr
= resp
->xdr
;
3766 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_stateid
);
3769 p
= xdr_reserve_space(xdr
, 24);
3771 return nfserr_resource
;
3772 p
= encode_cinfo(p
, &open
->op_cinfo
);
3773 *p
++ = cpu_to_be32(open
->op_rflags
);
3775 nfserr
= nfsd4_encode_bitmap(xdr
, open
->op_bmval
[0], open
->op_bmval
[1],
3780 p
= xdr_reserve_space(xdr
, 4);
3782 return nfserr_resource
;
3784 *p
++ = cpu_to_be32(open
->op_delegate_type
);
3785 switch (open
->op_delegate_type
) {
3786 case NFS4_OPEN_DELEGATE_NONE
:
3788 case NFS4_OPEN_DELEGATE_READ
:
3789 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3792 p
= xdr_reserve_space(xdr
, 20);
3794 return nfserr_resource
;
3795 *p
++ = cpu_to_be32(open
->op_recall
);
3798 * TODO: ACE's in delegations
3800 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3801 *p
++ = cpu_to_be32(0);
3802 *p
++ = cpu_to_be32(0);
3803 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3805 case NFS4_OPEN_DELEGATE_WRITE
:
3806 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3809 p
= xdr_reserve_space(xdr
, 32);
3811 return nfserr_resource
;
3812 *p
++ = cpu_to_be32(0);
3815 * TODO: space_limit's in delegations
3817 *p
++ = cpu_to_be32(NFS4_LIMIT_SIZE
);
3818 *p
++ = cpu_to_be32(~(u32
)0);
3819 *p
++ = cpu_to_be32(~(u32
)0);
3822 * TODO: ACE's in delegations
3824 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3825 *p
++ = cpu_to_be32(0);
3826 *p
++ = cpu_to_be32(0);
3827 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3829 case NFS4_OPEN_DELEGATE_NONE_EXT
: /* 4.1 */
3830 switch (open
->op_why_no_deleg
) {
3831 case WND4_CONTENTION
:
3833 p
= xdr_reserve_space(xdr
, 8);
3835 return nfserr_resource
;
3836 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3837 /* deleg signaling not supported yet: */
3838 *p
++ = cpu_to_be32(0);
3841 p
= xdr_reserve_space(xdr
, 4);
3843 return nfserr_resource
;
3844 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3850 /* XXX save filehandle here */
3855 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
3857 struct xdr_stream
*xdr
= resp
->xdr
;
3859 return nfsd4_encode_stateid(xdr
, &oc
->oc_resp_stateid
);
3863 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
3865 struct xdr_stream
*xdr
= resp
->xdr
;
3867 return nfsd4_encode_stateid(xdr
, &od
->od_stateid
);
3870 static __be32
nfsd4_encode_splice_read(
3871 struct nfsd4_compoundres
*resp
,
3872 struct nfsd4_read
*read
,
3873 struct file
*file
, unsigned long maxcount
)
3875 struct xdr_stream
*xdr
= resp
->xdr
;
3876 struct xdr_buf
*buf
= xdr
->buf
;
3877 int status
, space_left
;
3880 __be32
*p
= xdr
->p
- 2;
3882 /* Make sure there will be room for padding if needed */
3883 if (xdr
->end
- xdr
->p
< 1)
3884 return nfserr_resource
;
3886 nfserr
= nfsd_splice_read(read
->rd_rqstp
, read
->rd_fhp
,
3887 file
, read
->rd_offset
, &maxcount
, &eof
);
3888 read
->rd_length
= maxcount
;
3891 status
= svc_encode_result_payload(read
->rd_rqstp
,
3892 buf
->head
[0].iov_len
, maxcount
);
3894 nfserr
= nfserrno(status
);
3898 *(p
++) = htonl(eof
);
3899 *(p
++) = htonl(maxcount
);
3901 buf
->page_len
= maxcount
;
3902 buf
->len
+= maxcount
;
3903 xdr
->page_ptr
+= (buf
->page_base
+ maxcount
+ PAGE_SIZE
- 1)
3906 /* Use rest of head for padding and remaining ops: */
3907 buf
->tail
[0].iov_base
= xdr
->p
;
3908 buf
->tail
[0].iov_len
= 0;
3909 xdr
->iov
= buf
->tail
;
3911 int pad
= 4 - (maxcount
&3);
3915 buf
->tail
[0].iov_base
+= maxcount
&3;
3916 buf
->tail
[0].iov_len
= pad
;
3920 space_left
= min_t(int, (void *)xdr
->end
- (void *)xdr
->p
,
3921 buf
->buflen
- buf
->len
);
3922 buf
->buflen
= buf
->len
+ space_left
;
3923 xdr
->end
= (__be32
*)((void *)xdr
->end
+ space_left
);
3929 * nfsd_splice_actor may have already messed with the
3930 * page length; reset it so as not to confuse
3931 * xdr_truncate_encode in our caller.
3937 static __be32
nfsd4_encode_readv(struct nfsd4_compoundres
*resp
,
3938 struct nfsd4_read
*read
,
3939 struct file
*file
, unsigned long maxcount
)
3941 struct xdr_stream
*xdr
= resp
->xdr
;
3943 int starting_len
= xdr
->buf
->len
- 8;
3948 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, maxcount
);
3949 if (read
->rd_vlen
< 0)
3950 return nfserr_resource
;
3952 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
3953 resp
->rqstp
->rq_vec
, read
->rd_vlen
, &maxcount
,
3955 read
->rd_length
= maxcount
;
3958 if (svc_encode_result_payload(resp
->rqstp
, starting_len
+ 8, maxcount
))
3960 xdr_truncate_encode(xdr
, starting_len
+ 8 + xdr_align_size(maxcount
));
3963 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
3964 tmp
= htonl(maxcount
);
3965 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
3968 pad
= (maxcount
&3) ? 4 - (maxcount
&3) : 0;
3969 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 8 + maxcount
,
3976 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3977 struct nfsd4_read
*read
)
3979 unsigned long maxcount
;
3980 struct xdr_stream
*xdr
= resp
->xdr
;
3982 int starting_len
= xdr
->buf
->len
;
3987 file
= read
->rd_nf
->nf_file
;
3989 p
= xdr_reserve_space(xdr
, 8); /* eof flag and byte count */
3991 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
));
3992 return nfserr_resource
;
3994 if (resp
->xdr
->buf
->page_len
&&
3995 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
)) {
3997 return nfserr_resource
;
3999 xdr_commit_encode(xdr
);
4001 maxcount
= svc_max_payload(resp
->rqstp
);
4002 maxcount
= min_t(unsigned long, maxcount
,
4003 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4004 maxcount
= min_t(unsigned long, maxcount
, read
->rd_length
);
4006 if (file
->f_op
->splice_read
&&
4007 test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
))
4008 nfserr
= nfsd4_encode_splice_read(resp
, read
, file
, maxcount
);
4010 nfserr
= nfsd4_encode_readv(resp
, read
, file
, maxcount
);
4013 xdr_truncate_encode(xdr
, starting_len
);
4019 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
4024 struct xdr_stream
*xdr
= resp
->xdr
;
4025 int length_offset
= xdr
->buf
->len
;
4029 p
= xdr_reserve_space(xdr
, 4);
4031 return nfserr_resource
;
4032 maxcount
= PAGE_SIZE
;
4034 p
= xdr_reserve_space(xdr
, maxcount
);
4036 return nfserr_resource
;
4038 * XXX: By default, vfs_readlink() will truncate symlinks if they
4039 * would overflow the buffer. Is this kosher in NFSv4? If not, one
4040 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4041 * that truncation occurred, and return NFS4ERR_RESOURCE.
4043 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
,
4044 (char *)p
, &maxcount
);
4045 if (nfserr
== nfserr_isdir
)
4046 nfserr
= nfserr_inval
;
4049 status
= svc_encode_result_payload(readlink
->rl_rqstp
, length_offset
,
4052 nfserr
= nfserrno(status
);
4056 wire_count
= htonl(maxcount
);
4057 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
, &wire_count
, 4);
4058 xdr_truncate_encode(xdr
, length_offset
+ 4 + ALIGN(maxcount
, 4));
4060 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
+ 4 + maxcount
,
4061 &zero
, 4 - (maxcount
&3));
4065 xdr_truncate_encode(xdr
, length_offset
);
4070 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
4076 struct xdr_stream
*xdr
= resp
->xdr
;
4077 int starting_len
= xdr
->buf
->len
;
4080 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
4082 return nfserr_resource
;
4084 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
4085 *p
++ = cpu_to_be32(0);
4086 *p
++ = cpu_to_be32(0);
4087 xdr
->buf
->head
[0].iov_len
= (char *)xdr
->p
-
4088 (char *)xdr
->buf
->head
[0].iov_base
;
4091 * Number of bytes left for directory entries allowing for the
4092 * final 8 bytes of the readdir and a following failed op:
4094 bytes_left
= xdr
->buf
->buflen
- xdr
->buf
->len
4095 - COMPOUND_ERR_SLACK_SPACE
- 8;
4096 if (bytes_left
< 0) {
4097 nfserr
= nfserr_resource
;
4100 maxcount
= svc_max_payload(resp
->rqstp
);
4101 maxcount
= min_t(u32
, readdir
->rd_maxcount
, maxcount
);
4103 * Note the rfc defines rd_maxcount as the size of the
4104 * READDIR4resok structure, which includes the verifier above
4105 * and the 8 bytes encoded at the end of this function:
4107 if (maxcount
< 16) {
4108 nfserr
= nfserr_toosmall
;
4111 maxcount
= min_t(int, maxcount
-16, bytes_left
);
4113 /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
4114 if (!readdir
->rd_dircount
)
4115 readdir
->rd_dircount
= svc_max_payload(resp
->rqstp
);
4118 readdir
->rd_maxcount
= maxcount
;
4119 readdir
->common
.err
= 0;
4120 readdir
->cookie_offset
= 0;
4122 offset
= readdir
->rd_cookie
;
4123 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
4125 &readdir
->common
, nfsd4_encode_dirent
);
4126 if (nfserr
== nfs_ok
&&
4127 readdir
->common
.err
== nfserr_toosmall
&&
4128 xdr
->buf
->len
== starting_len
+ 8) {
4129 /* nothing encoded; which limit did we hit?: */
4130 if (maxcount
- 16 < bytes_left
)
4131 /* It was the fault of rd_maxcount: */
4132 nfserr
= nfserr_toosmall
;
4134 /* We ran out of buffer space: */
4135 nfserr
= nfserr_resource
;
4140 if (readdir
->cookie_offset
) {
4141 wire_offset
= cpu_to_be64(offset
);
4142 write_bytes_to_xdr_buf(xdr
->buf
, readdir
->cookie_offset
,
4146 p
= xdr_reserve_space(xdr
, 8);
4151 *p
++ = 0; /* no more entries */
4152 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
4156 xdr_truncate_encode(xdr
, starting_len
);
4161 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
4163 struct xdr_stream
*xdr
= resp
->xdr
;
4166 p
= xdr_reserve_space(xdr
, 20);
4168 return nfserr_resource
;
4169 p
= encode_cinfo(p
, &remove
->rm_cinfo
);
4174 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
4176 struct xdr_stream
*xdr
= resp
->xdr
;
4179 p
= xdr_reserve_space(xdr
, 40);
4181 return nfserr_resource
;
4182 p
= encode_cinfo(p
, &rename
->rn_sinfo
);
4183 p
= encode_cinfo(p
, &rename
->rn_tinfo
);
4188 nfsd4_do_encode_secinfo(struct xdr_stream
*xdr
, struct svc_export
*exp
)
4190 u32 i
, nflavs
, supported
;
4191 struct exp_flavor_info
*flavs
;
4192 struct exp_flavor_info def_flavs
[2];
4193 __be32
*p
, *flavorsp
;
4194 static bool report
= true;
4196 if (exp
->ex_nflavors
) {
4197 flavs
= exp
->ex_flavors
;
4198 nflavs
= exp
->ex_nflavors
;
4199 } else { /* Handling of some defaults in absence of real secinfo: */
4201 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
4203 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
4204 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
4205 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
4207 flavs
[0].pseudoflavor
4208 = svcauth_gss_flavor(exp
->ex_client
);
4211 flavs
[0].pseudoflavor
4212 = exp
->ex_client
->flavour
->flavour
;
4217 p
= xdr_reserve_space(xdr
, 4);
4219 return nfserr_resource
;
4220 flavorsp
= p
++; /* to be backfilled later */
4222 for (i
= 0; i
< nflavs
; i
++) {
4223 rpc_authflavor_t pf
= flavs
[i
].pseudoflavor
;
4224 struct rpcsec_gss_info info
;
4226 if (rpcauth_get_gssinfo(pf
, &info
) == 0) {
4228 p
= xdr_reserve_space(xdr
, 4 + 4 +
4229 XDR_LEN(info
.oid
.len
) + 4 + 4);
4231 return nfserr_resource
;
4232 *p
++ = cpu_to_be32(RPC_AUTH_GSS
);
4233 p
= xdr_encode_opaque(p
, info
.oid
.data
, info
.oid
.len
);
4234 *p
++ = cpu_to_be32(info
.qop
);
4235 *p
++ = cpu_to_be32(info
.service
);
4236 } else if (pf
< RPC_AUTH_MAXFLAVOR
) {
4238 p
= xdr_reserve_space(xdr
, 4);
4240 return nfserr_resource
;
4241 *p
++ = cpu_to_be32(pf
);
4244 pr_warn("NFS: SECINFO: security flavor %u "
4245 "is not supported\n", pf
);
4249 if (nflavs
!= supported
)
4251 *flavorsp
= htonl(supported
);
4256 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4257 struct nfsd4_secinfo
*secinfo
)
4259 struct xdr_stream
*xdr
= resp
->xdr
;
4261 return nfsd4_do_encode_secinfo(xdr
, secinfo
->si_exp
);
4265 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4266 struct nfsd4_secinfo_no_name
*secinfo
)
4268 struct xdr_stream
*xdr
= resp
->xdr
;
4270 return nfsd4_do_encode_secinfo(xdr
, secinfo
->sin_exp
);
4274 * The SETATTR encode routine is special -- it always encodes a bitmap,
4275 * regardless of the error status.
4278 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
4280 struct xdr_stream
*xdr
= resp
->xdr
;
4283 p
= xdr_reserve_space(xdr
, 16);
4285 return nfserr_resource
;
4287 *p
++ = cpu_to_be32(3);
4288 *p
++ = cpu_to_be32(0);
4289 *p
++ = cpu_to_be32(0);
4290 *p
++ = cpu_to_be32(0);
4293 *p
++ = cpu_to_be32(3);
4294 *p
++ = cpu_to_be32(setattr
->sa_bmval
[0]);
4295 *p
++ = cpu_to_be32(setattr
->sa_bmval
[1]);
4296 *p
++ = cpu_to_be32(setattr
->sa_bmval
[2]);
4302 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
4304 struct xdr_stream
*xdr
= resp
->xdr
;
4308 p
= xdr_reserve_space(xdr
, 8 + NFS4_VERIFIER_SIZE
);
4310 return nfserr_resource
;
4311 p
= xdr_encode_opaque_fixed(p
, &scd
->se_clientid
, 8);
4312 p
= xdr_encode_opaque_fixed(p
, &scd
->se_confirm
,
4313 NFS4_VERIFIER_SIZE
);
4315 else if (nfserr
== nfserr_clid_inuse
) {
4316 p
= xdr_reserve_space(xdr
, 8);
4318 return nfserr_resource
;
4319 *p
++ = cpu_to_be32(0);
4320 *p
++ = cpu_to_be32(0);
4326 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
4328 struct xdr_stream
*xdr
= resp
->xdr
;
4331 p
= xdr_reserve_space(xdr
, 16);
4333 return nfserr_resource
;
4334 *p
++ = cpu_to_be32(write
->wr_bytes_written
);
4335 *p
++ = cpu_to_be32(write
->wr_how_written
);
4336 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4337 NFS4_VERIFIER_SIZE
);
4342 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4343 struct nfsd4_exchange_id
*exid
)
4345 struct xdr_stream
*xdr
= resp
->xdr
;
4350 int server_scope_sz
;
4351 uint64_t minor_id
= 0;
4352 struct nfsd_net
*nn
= net_generic(SVC_NET(resp
->rqstp
), nfsd_net_id
);
4354 major_id
= nn
->nfsd_name
;
4355 major_id_sz
= strlen(nn
->nfsd_name
);
4356 server_scope
= nn
->nfsd_name
;
4357 server_scope_sz
= strlen(nn
->nfsd_name
);
4359 p
= xdr_reserve_space(xdr
,
4360 8 /* eir_clientid */ +
4361 4 /* eir_sequenceid */ +
4365 return nfserr_resource
;
4367 p
= xdr_encode_opaque_fixed(p
, &exid
->clientid
, 8);
4368 *p
++ = cpu_to_be32(exid
->seqid
);
4369 *p
++ = cpu_to_be32(exid
->flags
);
4371 *p
++ = cpu_to_be32(exid
->spa_how
);
4373 switch (exid
->spa_how
) {
4377 /* spo_must_enforce bitmap: */
4378 nfserr
= nfsd4_encode_bitmap(xdr
,
4379 exid
->spo_must_enforce
[0],
4380 exid
->spo_must_enforce
[1],
4381 exid
->spo_must_enforce
[2]);
4384 /* spo_must_allow bitmap: */
4385 nfserr
= nfsd4_encode_bitmap(xdr
,
4386 exid
->spo_must_allow
[0],
4387 exid
->spo_must_allow
[1],
4388 exid
->spo_must_allow
[2]);
4396 p
= xdr_reserve_space(xdr
,
4397 8 /* so_minor_id */ +
4398 4 /* so_major_id.len */ +
4399 (XDR_QUADLEN(major_id_sz
) * 4) +
4400 4 /* eir_server_scope.len */ +
4401 (XDR_QUADLEN(server_scope_sz
) * 4) +
4402 4 /* eir_server_impl_id.count (0) */);
4404 return nfserr_resource
;
4406 /* The server_owner struct */
4407 p
= xdr_encode_hyper(p
, minor_id
); /* Minor id */
4409 p
= xdr_encode_opaque(p
, major_id
, major_id_sz
);
4412 p
= xdr_encode_opaque(p
, server_scope
, server_scope_sz
);
4414 /* Implementation id */
4415 *p
++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
4420 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4421 struct nfsd4_create_session
*sess
)
4423 struct xdr_stream
*xdr
= resp
->xdr
;
4426 p
= xdr_reserve_space(xdr
, 24);
4428 return nfserr_resource
;
4429 p
= xdr_encode_opaque_fixed(p
, sess
->sessionid
.data
,
4430 NFS4_MAX_SESSIONID_LEN
);
4431 *p
++ = cpu_to_be32(sess
->seqid
);
4432 *p
++ = cpu_to_be32(sess
->flags
);
4434 p
= xdr_reserve_space(xdr
, 28);
4436 return nfserr_resource
;
4437 *p
++ = cpu_to_be32(0); /* headerpadsz */
4438 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreq_sz
);
4439 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_sz
);
4440 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_cached
);
4441 *p
++ = cpu_to_be32(sess
->fore_channel
.maxops
);
4442 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreqs
);
4443 *p
++ = cpu_to_be32(sess
->fore_channel
.nr_rdma_attrs
);
4445 if (sess
->fore_channel
.nr_rdma_attrs
) {
4446 p
= xdr_reserve_space(xdr
, 4);
4448 return nfserr_resource
;
4449 *p
++ = cpu_to_be32(sess
->fore_channel
.rdma_attrs
);
4452 p
= xdr_reserve_space(xdr
, 28);
4454 return nfserr_resource
;
4455 *p
++ = cpu_to_be32(0); /* headerpadsz */
4456 *p
++ = cpu_to_be32(sess
->back_channel
.maxreq_sz
);
4457 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_sz
);
4458 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_cached
);
4459 *p
++ = cpu_to_be32(sess
->back_channel
.maxops
);
4460 *p
++ = cpu_to_be32(sess
->back_channel
.maxreqs
);
4461 *p
++ = cpu_to_be32(sess
->back_channel
.nr_rdma_attrs
);
4463 if (sess
->back_channel
.nr_rdma_attrs
) {
4464 p
= xdr_reserve_space(xdr
, 4);
4466 return nfserr_resource
;
4467 *p
++ = cpu_to_be32(sess
->back_channel
.rdma_attrs
);
4473 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4474 struct nfsd4_sequence
*seq
)
4476 struct xdr_stream
*xdr
= resp
->xdr
;
4479 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 20);
4481 return nfserr_resource
;
4482 p
= xdr_encode_opaque_fixed(p
, seq
->sessionid
.data
,
4483 NFS4_MAX_SESSIONID_LEN
);
4484 *p
++ = cpu_to_be32(seq
->seqid
);
4485 *p
++ = cpu_to_be32(seq
->slotid
);
4486 /* Note slotid's are numbered from zero: */
4487 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_highest_slotid */
4488 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_target_highest_slotid */
4489 *p
++ = cpu_to_be32(seq
->status_flags
);
4491 resp
->cstate
.data_offset
= xdr
->buf
->len
; /* DRC cache data pointer */
4496 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4497 struct nfsd4_test_stateid
*test_stateid
)
4499 struct xdr_stream
*xdr
= resp
->xdr
;
4500 struct nfsd4_test_stateid_id
*stateid
, *next
;
4503 p
= xdr_reserve_space(xdr
, 4 + (4 * test_stateid
->ts_num_ids
));
4505 return nfserr_resource
;
4506 *p
++ = htonl(test_stateid
->ts_num_ids
);
4508 list_for_each_entry_safe(stateid
, next
, &test_stateid
->ts_stateid_list
, ts_id_list
) {
4509 *p
++ = stateid
->ts_id_status
;
4515 #ifdef CONFIG_NFSD_PNFS
4517 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4518 struct nfsd4_getdeviceinfo
*gdev
)
4520 struct xdr_stream
*xdr
= resp
->xdr
;
4521 const struct nfsd4_layout_ops
*ops
;
4522 u32 starting_len
= xdr
->buf
->len
, needed_len
;
4525 p
= xdr_reserve_space(xdr
, 4);
4527 return nfserr_resource
;
4529 *p
++ = cpu_to_be32(gdev
->gd_layout_type
);
4531 /* If maxcount is 0 then just update notifications */
4532 if (gdev
->gd_maxcount
!= 0) {
4533 ops
= nfsd4_layout_ops
[gdev
->gd_layout_type
];
4534 nfserr
= ops
->encode_getdeviceinfo(xdr
, gdev
);
4537 * We don't bother to burden the layout drivers with
4538 * enforcing gd_maxcount, just tell the client to
4539 * come back with a bigger buffer if it's not enough.
4541 if (xdr
->buf
->len
+ 4 > gdev
->gd_maxcount
)
4547 if (gdev
->gd_notify_types
) {
4548 p
= xdr_reserve_space(xdr
, 4 + 4);
4550 return nfserr_resource
;
4551 *p
++ = cpu_to_be32(1); /* bitmap length */
4552 *p
++ = cpu_to_be32(gdev
->gd_notify_types
);
4554 p
= xdr_reserve_space(xdr
, 4);
4556 return nfserr_resource
;
4562 dprintk("%s: maxcount too small\n", __func__
);
4563 needed_len
= xdr
->buf
->len
+ 4 /* notifications */;
4564 xdr_truncate_encode(xdr
, starting_len
);
4565 p
= xdr_reserve_space(xdr
, 4);
4567 return nfserr_resource
;
4568 *p
++ = cpu_to_be32(needed_len
);
4569 return nfserr_toosmall
;
4573 nfsd4_encode_layoutget(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4574 struct nfsd4_layoutget
*lgp
)
4576 struct xdr_stream
*xdr
= resp
->xdr
;
4577 const struct nfsd4_layout_ops
*ops
;
4580 p
= xdr_reserve_space(xdr
, 36 + sizeof(stateid_opaque_t
));
4582 return nfserr_resource
;
4584 *p
++ = cpu_to_be32(1); /* we always set return-on-close */
4585 *p
++ = cpu_to_be32(lgp
->lg_sid
.si_generation
);
4586 p
= xdr_encode_opaque_fixed(p
, &lgp
->lg_sid
.si_opaque
,
4587 sizeof(stateid_opaque_t
));
4589 *p
++ = cpu_to_be32(1); /* we always return a single layout */
4590 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.offset
);
4591 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.length
);
4592 *p
++ = cpu_to_be32(lgp
->lg_seg
.iomode
);
4593 *p
++ = cpu_to_be32(lgp
->lg_layout_type
);
4595 ops
= nfsd4_layout_ops
[lgp
->lg_layout_type
];
4596 return ops
->encode_layoutget(xdr
, lgp
);
4600 nfsd4_encode_layoutcommit(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4601 struct nfsd4_layoutcommit
*lcp
)
4603 struct xdr_stream
*xdr
= resp
->xdr
;
4606 p
= xdr_reserve_space(xdr
, 4);
4608 return nfserr_resource
;
4609 *p
++ = cpu_to_be32(lcp
->lc_size_chg
);
4610 if (lcp
->lc_size_chg
) {
4611 p
= xdr_reserve_space(xdr
, 8);
4613 return nfserr_resource
;
4614 p
= xdr_encode_hyper(p
, lcp
->lc_newsize
);
4621 nfsd4_encode_layoutreturn(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4622 struct nfsd4_layoutreturn
*lrp
)
4624 struct xdr_stream
*xdr
= resp
->xdr
;
4627 p
= xdr_reserve_space(xdr
, 4);
4629 return nfserr_resource
;
4630 *p
++ = cpu_to_be32(lrp
->lrs_present
);
4631 if (lrp
->lrs_present
)
4632 return nfsd4_encode_stateid(xdr
, &lrp
->lr_sid
);
4635 #endif /* CONFIG_NFSD_PNFS */
4638 nfsd42_encode_write_res(struct nfsd4_compoundres
*resp
,
4639 struct nfsd42_write_res
*write
, bool sync
)
4642 p
= xdr_reserve_space(resp
->xdr
, 4);
4644 return nfserr_resource
;
4647 *p
++ = cpu_to_be32(0);
4650 *p
++ = cpu_to_be32(1);
4651 nfserr
= nfsd4_encode_stateid(resp
->xdr
, &write
->cb_stateid
);
4655 p
= xdr_reserve_space(resp
->xdr
, 8 + 4 + NFS4_VERIFIER_SIZE
);
4657 return nfserr_resource
;
4659 p
= xdr_encode_hyper(p
, write
->wr_bytes_written
);
4660 *p
++ = cpu_to_be32(write
->wr_stable_how
);
4661 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4662 NFS4_VERIFIER_SIZE
);
4667 nfsd42_encode_nl4_server(struct nfsd4_compoundres
*resp
, struct nl4_server
*ns
)
4669 struct xdr_stream
*xdr
= resp
->xdr
;
4670 struct nfs42_netaddr
*addr
;
4673 p
= xdr_reserve_space(xdr
, 4);
4674 *p
++ = cpu_to_be32(ns
->nl4_type
);
4676 switch (ns
->nl4_type
) {
4678 addr
= &ns
->u
.nl4_addr
;
4680 /* netid_len, netid, uaddr_len, uaddr (port included
4681 * in RPCBIND_MAXUADDRLEN)
4683 p
= xdr_reserve_space(xdr
,
4685 (XDR_QUADLEN(addr
->netid_len
) * 4) +
4687 (XDR_QUADLEN(addr
->addr_len
) * 4));
4689 return nfserr_resource
;
4691 *p
++ = cpu_to_be32(addr
->netid_len
);
4692 p
= xdr_encode_opaque_fixed(p
, addr
->netid
,
4694 *p
++ = cpu_to_be32(addr
->addr_len
);
4695 p
= xdr_encode_opaque_fixed(p
, addr
->addr
,
4699 WARN_ON_ONCE(ns
->nl4_type
!= NL4_NETADDR
);
4700 return nfserr_inval
;
4707 nfsd4_encode_copy(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4708 struct nfsd4_copy
*copy
)
4712 nfserr
= nfsd42_encode_write_res(resp
, ©
->cp_res
,
4713 !!copy
->cp_synchronous
);
4717 p
= xdr_reserve_space(resp
->xdr
, 4 + 4);
4718 *p
++ = xdr_one
; /* cr_consecutive */
4719 *p
++ = cpu_to_be32(copy
->cp_synchronous
);
4724 nfsd4_encode_offload_status(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4725 struct nfsd4_offload_status
*os
)
4727 struct xdr_stream
*xdr
= resp
->xdr
;
4730 p
= xdr_reserve_space(xdr
, 8 + 4);
4732 return nfserr_resource
;
4733 p
= xdr_encode_hyper(p
, os
->count
);
4734 *p
++ = cpu_to_be32(0);
4739 nfsd4_encode_read_plus_data(struct nfsd4_compoundres
*resp
,
4740 struct nfsd4_read
*read
,
4741 unsigned long *maxcount
, u32
*eof
,
4744 struct xdr_stream
*xdr
= resp
->xdr
;
4745 struct file
*file
= read
->rd_nf
->nf_file
;
4746 int starting_len
= xdr
->buf
->len
;
4752 hole_pos
= pos
? *pos
: vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4753 if (hole_pos
> read
->rd_offset
)
4754 *maxcount
= min_t(unsigned long, *maxcount
, hole_pos
- read
->rd_offset
);
4755 *maxcount
= min_t(unsigned long, *maxcount
, (xdr
->buf
->buflen
- xdr
->buf
->len
));
4757 /* Content type, offset, byte count */
4758 p
= xdr_reserve_space(xdr
, 4 + 8 + 4);
4760 return nfserr_resource
;
4762 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, *maxcount
);
4763 if (read
->rd_vlen
< 0)
4764 return nfserr_resource
;
4766 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
4767 resp
->rqstp
->rq_vec
, read
->rd_vlen
, maxcount
, eof
);
4770 xdr_truncate_encode(xdr
, starting_len
+ 16 + xdr_align_size(*maxcount
));
4772 tmp
= htonl(NFS4_CONTENT_DATA
);
4773 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4774 tmp64
= cpu_to_be64(read
->rd_offset
);
4775 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp64
, 8);
4776 tmp
= htonl(*maxcount
);
4777 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 12, &tmp
, 4);
4780 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 16 + *maxcount
, &tmp
,
4781 xdr_pad_size(*maxcount
));
4786 nfsd4_encode_read_plus_hole(struct nfsd4_compoundres
*resp
,
4787 struct nfsd4_read
*read
,
4788 unsigned long *maxcount
, u32
*eof
)
4790 struct file
*file
= read
->rd_nf
->nf_file
;
4791 loff_t data_pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_DATA
);
4792 loff_t f_size
= i_size_read(file_inode(file
));
4793 unsigned long count
;
4796 if (data_pos
== -ENXIO
)
4798 else if (data_pos
<= read
->rd_offset
|| (data_pos
< f_size
&& data_pos
% PAGE_SIZE
))
4799 return nfsd4_encode_read_plus_data(resp
, read
, maxcount
, eof
, &f_size
);
4800 count
= data_pos
- read
->rd_offset
;
4802 /* Content type, offset, byte count */
4803 p
= xdr_reserve_space(resp
->xdr
, 4 + 8 + 8);
4805 return nfserr_resource
;
4807 *p
++ = htonl(NFS4_CONTENT_HOLE
);
4808 p
= xdr_encode_hyper(p
, read
->rd_offset
);
4809 p
= xdr_encode_hyper(p
, count
);
4811 *eof
= (read
->rd_offset
+ count
) >= f_size
;
4812 *maxcount
= min_t(unsigned long, count
, *maxcount
);
4817 nfsd4_encode_read_plus(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4818 struct nfsd4_read
*read
)
4820 unsigned long maxcount
, count
;
4821 struct xdr_stream
*xdr
= resp
->xdr
;
4823 int starting_len
= xdr
->buf
->len
;
4824 int last_segment
= xdr
->buf
->len
;
4833 file
= read
->rd_nf
->nf_file
;
4835 /* eof flag, segment count */
4836 p
= xdr_reserve_space(xdr
, 4 + 4);
4838 return nfserr_resource
;
4839 xdr_commit_encode(xdr
);
4841 maxcount
= svc_max_payload(resp
->rqstp
);
4842 maxcount
= min_t(unsigned long, maxcount
,
4843 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4844 maxcount
= min_t(unsigned long, maxcount
, read
->rd_length
);
4847 eof
= read
->rd_offset
>= i_size_read(file_inode(file
));
4851 pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4852 is_data
= pos
> read
->rd_offset
;
4854 while (count
> 0 && !eof
) {
4857 nfserr
= nfsd4_encode_read_plus_data(resp
, read
, &maxcount
, &eof
,
4858 segments
== 0 ? &pos
: NULL
);
4860 nfserr
= nfsd4_encode_read_plus_hole(resp
, read
, &maxcount
, &eof
);
4864 read
->rd_offset
+= maxcount
;
4866 last_segment
= xdr
->buf
->len
;
4871 if (nfserr
&& segments
== 0)
4872 xdr_truncate_encode(xdr
, starting_len
);
4875 xdr_truncate_encode(xdr
, last_segment
);
4880 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4881 tmp
= htonl(segments
);
4882 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
4889 nfsd4_encode_copy_notify(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4890 struct nfsd4_copy_notify
*cn
)
4892 struct xdr_stream
*xdr
= resp
->xdr
;
4899 p
= xdr_reserve_space(xdr
, 12);
4901 return nfserr_resource
;
4903 /* cnr_lease_time */
4904 p
= xdr_encode_hyper(p
, cn
->cpn_sec
);
4905 *p
++ = cpu_to_be32(cn
->cpn_nsec
);
4908 nfserr
= nfsd4_encode_stateid(xdr
, &cn
->cpn_cnr_stateid
);
4912 /* cnr_src.nl_nsvr */
4913 p
= xdr_reserve_space(xdr
, 4);
4915 return nfserr_resource
;
4917 *p
++ = cpu_to_be32(1);
4919 return nfsd42_encode_nl4_server(resp
, &cn
->cpn_src
);
4923 nfsd4_encode_seek(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4924 struct nfsd4_seek
*seek
)
4928 p
= xdr_reserve_space(resp
->xdr
, 4 + 8);
4929 *p
++ = cpu_to_be32(seek
->seek_eof
);
4930 p
= xdr_encode_hyper(p
, seek
->seek_pos
);
4936 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
4942 * Encode kmalloc-ed buffer in to XDR stream.
4945 nfsd4_vbuf_to_stream(struct xdr_stream
*xdr
, char *buf
, u32 buflen
)
4950 cplen
= min_t(unsigned long, buflen
,
4951 ((void *)xdr
->end
- (void *)xdr
->p
));
4952 p
= xdr_reserve_space(xdr
, cplen
);
4954 return nfserr_resource
;
4956 memcpy(p
, buf
, cplen
);
4961 cplen
= min_t(u32
, buflen
, PAGE_SIZE
);
4962 p
= xdr_reserve_space(xdr
, cplen
);
4964 return nfserr_resource
;
4966 memcpy(p
, buf
, cplen
);
4968 if (cplen
< PAGE_SIZE
) {
4970 * We're done, with a length that wasn't page
4971 * aligned, so possibly not word aligned. Pad
4972 * any trailing bytes with 0.
4974 xdr_encode_opaque_fixed(p
, NULL
, cplen
);
4978 buflen
-= PAGE_SIZE
;
4986 nfsd4_encode_getxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4987 struct nfsd4_getxattr
*getxattr
)
4989 struct xdr_stream
*xdr
= resp
->xdr
;
4992 p
= xdr_reserve_space(xdr
, 4);
4994 return nfserr_resource
;
4996 *p
= cpu_to_be32(getxattr
->getxa_len
);
4998 if (getxattr
->getxa_len
== 0)
5001 err
= nfsd4_vbuf_to_stream(xdr
, getxattr
->getxa_buf
,
5002 getxattr
->getxa_len
);
5004 kvfree(getxattr
->getxa_buf
);
5010 nfsd4_encode_setxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5011 struct nfsd4_setxattr
*setxattr
)
5013 struct xdr_stream
*xdr
= resp
->xdr
;
5016 p
= xdr_reserve_space(xdr
, 20);
5018 return nfserr_resource
;
5020 encode_cinfo(p
, &setxattr
->setxa_cinfo
);
5026 * See if there are cookie values that can be rejected outright.
5029 nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs
*listxattrs
,
5032 u64 cookie
= listxattrs
->lsxa_cookie
;
5035 * If the cookie is larger than the maximum number we can fit
5036 * in either the buffer we just got back from vfs_listxattr, or,
5037 * XDR-encoded, in the return buffer, it's invalid.
5039 if (cookie
> (listxattrs
->lsxa_len
) / (XATTR_USER_PREFIX_LEN
+ 2))
5040 return nfserr_badcookie
;
5042 if (cookie
> (listxattrs
->lsxa_maxcount
/
5043 (XDR_QUADLEN(XATTR_USER_PREFIX_LEN
+ 2) + 4)))
5044 return nfserr_badcookie
;
5046 *offsetp
= (u32
)cookie
;
5051 nfsd4_encode_listxattrs(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5052 struct nfsd4_listxattrs
*listxattrs
)
5054 struct xdr_stream
*xdr
= resp
->xdr
;
5055 u32 cookie_offset
, count_offset
, eof
;
5056 u32 left
, xdrleft
, slen
, count
;
5066 status
= nfsd4_listxattr_validate_cookie(listxattrs
, &offset
);
5071 * Reserve space for the cookie and the name array count. Record
5072 * the offsets to save them later.
5074 cookie_offset
= xdr
->buf
->len
;
5075 count_offset
= cookie_offset
+ 8;
5076 p
= xdr_reserve_space(xdr
, 12);
5078 status
= nfserr_resource
;
5083 left
= listxattrs
->lsxa_len
;
5084 sp
= listxattrs
->lsxa_buf
;
5087 xdrleft
= listxattrs
->lsxa_maxcount
;
5089 while (left
> 0 && xdrleft
> 0) {
5093 * Check if this is a "user." attribute, skip it if not.
5095 if (strncmp(sp
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
))
5098 slen
-= XATTR_USER_PREFIX_LEN
;
5099 xdrlen
= 4 + ((slen
+ 3) & ~3);
5100 if (xdrlen
> xdrleft
) {
5103 * Can't even fit the first attribute name.
5105 status
= nfserr_toosmall
;
5112 left
-= XATTR_USER_PREFIX_LEN
;
5113 sp
+= XATTR_USER_PREFIX_LEN
;
5114 if (nuser
++ < offset
)
5118 p
= xdr_reserve_space(xdr
, xdrlen
);
5120 status
= nfserr_resource
;
5124 xdr_encode_opaque(p
, sp
, slen
);
5134 * If there were user attributes to copy, but we didn't copy
5135 * any, the offset was too large (e.g. the cookie was invalid).
5137 if (nuser
> 0 && count
== 0) {
5138 status
= nfserr_badcookie
;
5143 p
= xdr_reserve_space(xdr
, 4);
5145 status
= nfserr_resource
;
5148 *p
= cpu_to_be32(eof
);
5150 cookie
= offset
+ count
;
5152 write_bytes_to_xdr_buf(xdr
->buf
, cookie_offset
, &cookie
, 8);
5153 tmp
= cpu_to_be32(count
);
5154 write_bytes_to_xdr_buf(xdr
->buf
, count_offset
, &tmp
, 4);
5156 if (listxattrs
->lsxa_len
)
5157 kvfree(listxattrs
->lsxa_buf
);
5162 nfsd4_encode_removexattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5163 struct nfsd4_removexattr
*removexattr
)
5165 struct xdr_stream
*xdr
= resp
->xdr
;
5168 p
= xdr_reserve_space(xdr
, 20);
5170 return nfserr_resource
;
5172 p
= encode_cinfo(p
, &removexattr
->rmxa_cinfo
);
5176 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
5179 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5180 * since we don't need to filter out obsolete ops as this is
5181 * done in the decoding phase.
5183 static const nfsd4_enc nfsd4_enc_ops
[] = {
5184 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
5185 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
5186 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
5187 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
5188 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5189 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5190 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
5191 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
5192 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
5193 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
5194 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
5195 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
5196 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5197 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5198 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5199 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
5200 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5201 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
5202 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
5203 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5204 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5205 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5206 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
5207 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
5208 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
5209 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
5210 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
5211 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
5212 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5213 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5214 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
5215 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
5216 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
5217 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
5218 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5219 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
5220 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
5222 /* NFSv4.1 operations */
5223 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5224 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
5225 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
5226 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
5227 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5228 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5229 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5230 #ifdef CONFIG_NFSD_PNFS
5231 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_getdeviceinfo
,
5232 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5233 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_layoutcommit
,
5234 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_layoutget
,
5235 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_layoutreturn
,
5237 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
5238 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5239 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
5240 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
5241 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5243 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
5244 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
5245 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
5246 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
5247 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5248 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5249 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5251 /* NFSv4.2 operations */
5252 [OP_ALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5253 [OP_COPY
] = (nfsd4_enc
)nfsd4_encode_copy
,
5254 [OP_COPY_NOTIFY
] = (nfsd4_enc
)nfsd4_encode_copy_notify
,
5255 [OP_DEALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5256 [OP_IO_ADVISE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5257 [OP_LAYOUTERROR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5258 [OP_LAYOUTSTATS
] = (nfsd4_enc
)nfsd4_encode_noop
,
5259 [OP_OFFLOAD_CANCEL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5260 [OP_OFFLOAD_STATUS
] = (nfsd4_enc
)nfsd4_encode_offload_status
,
5261 [OP_READ_PLUS
] = (nfsd4_enc
)nfsd4_encode_read_plus
,
5262 [OP_SEEK
] = (nfsd4_enc
)nfsd4_encode_seek
,
5263 [OP_WRITE_SAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
5264 [OP_CLONE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5266 /* RFC 8276 extended atributes operations */
5267 [OP_GETXATTR
] = (nfsd4_enc
)nfsd4_encode_getxattr
,
5268 [OP_SETXATTR
] = (nfsd4_enc
)nfsd4_encode_setxattr
,
5269 [OP_LISTXATTRS
] = (nfsd4_enc
)nfsd4_encode_listxattrs
,
5270 [OP_REMOVEXATTR
] = (nfsd4_enc
)nfsd4_encode_removexattr
,
5274 * Calculate whether we still have space to encode repsize bytes.
5275 * There are two considerations:
5276 * - For NFS versions >=4.1, the size of the reply must stay within
5278 * - For all NFS versions, we must stay within limited preallocated
5281 * This is called before the operation is processed, so can only provide
5282 * an upper estimate. For some nonidempotent operations (such as
5283 * getattr), it's not necessarily a problem if that estimate is wrong,
5284 * as we can fail it after processing without significant side effects.
5286 __be32
nfsd4_check_resp_size(struct nfsd4_compoundres
*resp
, u32 respsize
)
5288 struct xdr_buf
*buf
= &resp
->rqstp
->rq_res
;
5289 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5291 if (buf
->len
+ respsize
<= buf
->buflen
)
5293 if (!nfsd4_has_session(&resp
->cstate
))
5294 return nfserr_resource
;
5295 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
) {
5297 return nfserr_rep_too_big_to_cache
;
5299 return nfserr_rep_too_big
;
5303 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
5305 struct xdr_stream
*xdr
= resp
->xdr
;
5306 struct nfs4_stateowner
*so
= resp
->cstate
.replay_owner
;
5307 struct svc_rqst
*rqstp
= resp
->rqstp
;
5308 const struct nfsd4_operation
*opdesc
= op
->opdesc
;
5309 int post_err_offset
;
5313 p
= xdr_reserve_space(xdr
, 8);
5318 *p
++ = cpu_to_be32(op
->opnum
);
5319 post_err_offset
= xdr
->buf
->len
;
5321 if (op
->opnum
== OP_ILLEGAL
)
5323 if (op
->status
&& opdesc
&&
5324 !(opdesc
->op_flags
& OP_NONTRIVIAL_ERROR_ENCODE
))
5326 BUG_ON(op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
5327 !nfsd4_enc_ops
[op
->opnum
]);
5328 encoder
= nfsd4_enc_ops
[op
->opnum
];
5329 op
->status
= encoder(resp
, op
->status
, &op
->u
);
5331 trace_nfsd_compound_encode_err(rqstp
, op
->opnum
, op
->status
);
5332 if (opdesc
&& opdesc
->op_release
)
5333 opdesc
->op_release(&op
->u
);
5334 xdr_commit_encode(xdr
);
5336 /* nfsd4_check_resp_size guarantees enough room for error status */
5338 int space_needed
= 0;
5339 if (!nfsd4_last_compound_op(rqstp
))
5340 space_needed
= COMPOUND_ERR_SLACK_SPACE
;
5341 op
->status
= nfsd4_check_resp_size(resp
, space_needed
);
5343 if (op
->status
== nfserr_resource
&& nfsd4_has_session(&resp
->cstate
)) {
5344 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5346 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
)
5347 op
->status
= nfserr_rep_too_big_to_cache
;
5349 op
->status
= nfserr_rep_too_big
;
5351 if (op
->status
== nfserr_resource
||
5352 op
->status
== nfserr_rep_too_big
||
5353 op
->status
== nfserr_rep_too_big_to_cache
) {
5355 * The operation may have already been encoded or
5356 * partially encoded. No op returns anything additional
5357 * in the case of one of these three errors, so we can
5358 * just truncate back to after the status. But it's a
5359 * bug if we had to do this on a non-idempotent op:
5361 warn_on_nonidempotent_op(op
);
5362 xdr_truncate_encode(xdr
, post_err_offset
);
5365 int len
= xdr
->buf
->len
- post_err_offset
;
5367 so
->so_replay
.rp_status
= op
->status
;
5368 so
->so_replay
.rp_buflen
= len
;
5369 read_bytes_from_xdr_buf(xdr
->buf
, post_err_offset
,
5370 so
->so_replay
.rp_buf
, len
);
5373 /* Note that op->status is already in network byte order: */
5374 write_bytes_to_xdr_buf(xdr
->buf
, post_err_offset
- 4, &op
->status
, 4);
5378 * Encode the reply stored in the stateowner reply cache
5380 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5381 * previously sent already encoded operation.
5384 nfsd4_encode_replay(struct xdr_stream
*xdr
, struct nfsd4_op
*op
)
5387 struct nfs4_replay
*rp
= op
->replay
;
5389 p
= xdr_reserve_space(xdr
, 8 + rp
->rp_buflen
);
5394 *p
++ = cpu_to_be32(op
->opnum
);
5395 *p
++ = rp
->rp_status
; /* already xdr'ed */
5397 p
= xdr_encode_opaque_fixed(p
, rp
->rp_buf
, rp
->rp_buflen
);
5400 void nfsd4_release_compoundargs(struct svc_rqst
*rqstp
)
5402 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5404 if (args
->ops
!= args
->iops
) {
5406 args
->ops
= args
->iops
;
5408 while (args
->to_free
) {
5409 struct svcxdr_tmpbuf
*tb
= args
->to_free
;
5410 args
->to_free
= tb
->next
;
5416 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, __be32
*p
)
5418 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5420 /* svcxdr_tmp_alloc */
5421 args
->to_free
= NULL
;
5423 args
->xdr
= &rqstp
->rq_arg_stream
;
5424 args
->ops
= args
->iops
;
5425 args
->rqstp
= rqstp
;
5427 return nfsd4_decode_compound(args
);
5431 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, __be32
*p
)
5433 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
5434 struct xdr_buf
*buf
= resp
->xdr
->buf
;
5436 WARN_ON_ONCE(buf
->len
!= buf
->head
[0].iov_len
+ buf
->page_len
+
5437 buf
->tail
[0].iov_len
);
5439 *p
= resp
->cstate
.status
;
5441 rqstp
->rq_next_page
= resp
->xdr
->page_ptr
+ 1;
5444 *p
++ = htonl(resp
->taglen
);
5445 memcpy(p
, resp
->tag
, resp
->taglen
);
5446 p
+= XDR_QUADLEN(resp
->taglen
);
5447 *p
++ = htonl(resp
->opcnt
);
5449 nfsd4_sequence_done(resp
);