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
)
282 status
= xdr_stream_decode_uint32_array(argp
->xdr
, bmval
, bmlen
);
283 return status
== -EBADMSG
? nfserr_bad_xdr
: nfs_ok
;
287 nfsd4_decode_nfsace4(struct nfsd4_compoundargs
*argp
, struct nfs4_ace
*ace
)
292 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->type
) < 0)
293 return nfserr_bad_xdr
;
294 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->flag
) < 0)
295 return nfserr_bad_xdr
;
296 if (xdr_stream_decode_u32(argp
->xdr
, &ace
->access_mask
) < 0)
297 return nfserr_bad_xdr
;
299 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
300 return nfserr_bad_xdr
;
301 p
= xdr_inline_decode(argp
->xdr
, length
);
303 return nfserr_bad_xdr
;
304 ace
->whotype
= nfs4_acl_get_whotype((char *)p
, length
);
305 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
307 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
308 status
= nfsd_map_name_to_gid(argp
->rqstp
,
309 (char *)p
, length
, &ace
->who_gid
);
311 status
= nfsd_map_name_to_uid(argp
->rqstp
,
312 (char *)p
, length
, &ace
->who_uid
);
317 /* A counted array of nfsace4's */
318 static noinline __be32
319 nfsd4_decode_acl(struct nfsd4_compoundargs
*argp
, struct nfs4_acl
**acl
)
321 struct nfs4_ace
*ace
;
325 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
326 return nfserr_bad_xdr
;
328 if (count
> xdr_stream_remaining(argp
->xdr
) / 20)
330 * Even with 4-byte names there wouldn't be
331 * space for that many aces; something fishy is
336 *acl
= svcxdr_tmpalloc(argp
, nfs4_acl_bytes(count
));
338 return nfserr_jukebox
;
340 (*acl
)->naces
= count
;
341 for (ace
= (*acl
)->aces
; ace
< (*acl
)->aces
+ count
; ace
++) {
342 status
= nfsd4_decode_nfsace4(argp
, ace
);
350 static noinline __be32
351 nfsd4_decode_security_label(struct nfsd4_compoundargs
*argp
,
352 struct xdr_netobj
*label
)
357 if (xdr_stream_decode_u32(argp
->xdr
, &lfs
) < 0)
358 return nfserr_bad_xdr
;
359 if (xdr_stream_decode_u32(argp
->xdr
, &pi
) < 0)
360 return nfserr_bad_xdr
;
362 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
363 return nfserr_bad_xdr
;
364 if (length
> NFS4_MAXLABELLEN
)
365 return nfserr_badlabel
;
366 p
= xdr_inline_decode(argp
->xdr
, length
);
368 return nfserr_bad_xdr
;
370 label
->data
= svcxdr_dupstr(argp
, p
, length
);
372 return nfserr_jukebox
;
378 nfsd4_decode_fattr4(struct nfsd4_compoundargs
*argp
, u32
*bmval
, u32 bmlen
,
379 struct iattr
*iattr
, struct nfs4_acl
**acl
,
380 struct xdr_netobj
*label
, int *umask
)
382 unsigned int starting_pos
;
387 status
= nfsd4_decode_bitmap4(argp
, bmval
, bmlen
);
389 return nfserr_bad_xdr
;
391 if (bmval
[0] & ~NFSD_WRITEABLE_ATTRS_WORD0
392 || bmval
[1] & ~NFSD_WRITEABLE_ATTRS_WORD1
393 || bmval
[2] & ~NFSD_WRITEABLE_ATTRS_WORD2
) {
394 if (nfsd_attrs_supported(argp
->minorversion
, bmval
))
396 return nfserr_attrnotsupp
;
399 if (xdr_stream_decode_u32(argp
->xdr
, &attrlist4_count
) < 0)
400 return nfserr_bad_xdr
;
401 starting_pos
= xdr_stream_pos(argp
->xdr
);
403 if (bmval
[0] & FATTR4_WORD0_SIZE
) {
406 if (xdr_stream_decode_u64(argp
->xdr
, &size
) < 0)
407 return nfserr_bad_xdr
;
408 iattr
->ia_size
= size
;
409 iattr
->ia_valid
|= ATTR_SIZE
;
411 if (bmval
[0] & FATTR4_WORD0_ACL
) {
412 status
= nfsd4_decode_acl(argp
, acl
);
417 if (bmval
[1] & FATTR4_WORD1_MODE
) {
420 if (xdr_stream_decode_u32(argp
->xdr
, &mode
) < 0)
421 return nfserr_bad_xdr
;
422 iattr
->ia_mode
= mode
;
423 iattr
->ia_mode
&= (S_IFMT
| S_IALLUGO
);
424 iattr
->ia_valid
|= ATTR_MODE
;
426 if (bmval
[1] & FATTR4_WORD1_OWNER
) {
429 if (xdr_stream_decode_u32(argp
->xdr
, &length
) < 0)
430 return nfserr_bad_xdr
;
431 p
= xdr_inline_decode(argp
->xdr
, length
);
433 return nfserr_bad_xdr
;
434 status
= nfsd_map_name_to_uid(argp
->rqstp
, (char *)p
, length
,
438 iattr
->ia_valid
|= ATTR_UID
;
440 if (bmval
[1] & FATTR4_WORD1_OWNER_GROUP
) {
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_gid(argp
->rqstp
, (char *)p
, length
,
452 iattr
->ia_valid
|= ATTR_GID
;
454 if (bmval
[1] & FATTR4_WORD1_TIME_ACCESS_SET
) {
457 if (xdr_stream_decode_u32(argp
->xdr
, &set_it
) < 0)
458 return nfserr_bad_xdr
;
460 case NFS4_SET_TO_CLIENT_TIME
:
461 status
= nfsd4_decode_nfstime4(argp
, &iattr
->ia_atime
);
464 iattr
->ia_valid
|= (ATTR_ATIME
| ATTR_ATIME_SET
);
466 case NFS4_SET_TO_SERVER_TIME
:
467 iattr
->ia_valid
|= ATTR_ATIME
;
470 return nfserr_bad_xdr
;
473 if (bmval
[1] & FATTR4_WORD1_TIME_CREATE
) {
474 struct timespec64 ts
;
476 /* No Linux filesystem supports setting this attribute. */
477 bmval
[1] &= ~FATTR4_WORD1_TIME_CREATE
;
478 status
= nfsd4_decode_nfstime4(argp
, &ts
);
482 if (bmval
[1] & FATTR4_WORD1_TIME_MODIFY_SET
) {
485 if (xdr_stream_decode_u32(argp
->xdr
, &set_it
) < 0)
486 return nfserr_bad_xdr
;
488 case NFS4_SET_TO_CLIENT_TIME
:
489 status
= nfsd4_decode_nfstime4(argp
, &iattr
->ia_mtime
);
492 iattr
->ia_valid
|= (ATTR_MTIME
| ATTR_MTIME_SET
);
494 case NFS4_SET_TO_SERVER_TIME
:
495 iattr
->ia_valid
|= ATTR_MTIME
;
498 return nfserr_bad_xdr
;
502 if (IS_ENABLED(CONFIG_NFSD_V4_SECURITY_LABEL
) &&
503 bmval
[2] & FATTR4_WORD2_SECURITY_LABEL
) {
504 status
= nfsd4_decode_security_label(argp
, label
);
508 if (bmval
[2] & FATTR4_WORD2_MODE_UMASK
) {
512 return nfserr_bad_xdr
;
513 if (xdr_stream_decode_u32(argp
->xdr
, &mode
) < 0)
514 return nfserr_bad_xdr
;
515 iattr
->ia_mode
= mode
& (S_IFMT
| S_IALLUGO
);
516 if (xdr_stream_decode_u32(argp
->xdr
, &mask
) < 0)
517 return nfserr_bad_xdr
;
518 *umask
= mask
& S_IRWXUGO
;
519 iattr
->ia_valid
|= ATTR_MODE
;
522 /* request sanity: did attrlist4 contain the expected number of words? */
523 if (attrlist4_count
!= xdr_stream_pos(argp
->xdr
) - starting_pos
)
524 return nfserr_bad_xdr
;
530 nfsd4_decode_stateid4(struct nfsd4_compoundargs
*argp
, stateid_t
*sid
)
534 p
= xdr_inline_decode(argp
->xdr
, NFS4_STATEID_SIZE
);
536 return nfserr_bad_xdr
;
537 sid
->si_generation
= be32_to_cpup(p
++);
538 memcpy(&sid
->si_opaque
, p
, sizeof(sid
->si_opaque
));
543 nfsd4_decode_clientid4(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
547 p
= xdr_inline_decode(argp
->xdr
, sizeof(__be64
));
549 return nfserr_bad_xdr
;
550 memcpy(clientid
, p
, sizeof(*clientid
));
555 nfsd4_decode_state_owner4(struct nfsd4_compoundargs
*argp
,
556 clientid_t
*clientid
, struct xdr_netobj
*owner
)
560 status
= nfsd4_decode_clientid4(argp
, clientid
);
563 return nfsd4_decode_opaque(argp
, owner
);
566 #ifdef CONFIG_NFSD_PNFS
568 nfsd4_decode_deviceid4(struct nfsd4_compoundargs
*argp
,
569 struct nfsd4_deviceid
*devid
)
573 p
= xdr_inline_decode(argp
->xdr
, NFS4_DEVICEID4_SIZE
);
575 return nfserr_bad_xdr
;
576 memcpy(devid
, p
, sizeof(*devid
));
581 nfsd4_decode_layoutupdate4(struct nfsd4_compoundargs
*argp
,
582 struct nfsd4_layoutcommit
*lcp
)
584 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_layout_type
) < 0)
585 return nfserr_bad_xdr
;
586 if (lcp
->lc_layout_type
< LAYOUT_NFSV4_1_FILES
)
587 return nfserr_bad_xdr
;
588 if (lcp
->lc_layout_type
>= LAYOUT_TYPE_MAX
)
589 return nfserr_bad_xdr
;
591 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_up_len
) < 0)
592 return nfserr_bad_xdr
;
593 if (lcp
->lc_up_len
> 0) {
594 lcp
->lc_up_layout
= xdr_inline_decode(argp
->xdr
, lcp
->lc_up_len
);
595 if (!lcp
->lc_up_layout
)
596 return nfserr_bad_xdr
;
603 nfsd4_decode_layoutreturn4(struct nfsd4_compoundargs
*argp
,
604 struct nfsd4_layoutreturn
*lrp
)
608 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_return_type
) < 0)
609 return nfserr_bad_xdr
;
610 switch (lrp
->lr_return_type
) {
612 if (xdr_stream_decode_u64(argp
->xdr
, &lrp
->lr_seg
.offset
) < 0)
613 return nfserr_bad_xdr
;
614 if (xdr_stream_decode_u64(argp
->xdr
, &lrp
->lr_seg
.length
) < 0)
615 return nfserr_bad_xdr
;
616 status
= nfsd4_decode_stateid4(argp
, &lrp
->lr_sid
);
619 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lrf_body_len
) < 0)
620 return nfserr_bad_xdr
;
621 if (lrp
->lrf_body_len
> 0) {
622 lrp
->lrf_body
= xdr_inline_decode(argp
->xdr
, lrp
->lrf_body_len
);
624 return nfserr_bad_xdr
;
629 lrp
->lr_seg
.offset
= 0;
630 lrp
->lr_seg
.length
= NFS4_MAX_UINT64
;
633 return nfserr_bad_xdr
;
639 #endif /* CONFIG_NFSD_PNFS */
642 nfsd4_decode_sessionid4(struct nfsd4_compoundargs
*argp
,
643 struct nfs4_sessionid
*sessionid
)
647 p
= xdr_inline_decode(argp
->xdr
, NFS4_MAX_SESSIONID_LEN
);
649 return nfserr_bad_xdr
;
650 memcpy(sessionid
->data
, p
, sizeof(sessionid
->data
));
654 /* Defined in Appendix A of RFC 5531 */
656 nfsd4_decode_authsys_parms(struct nfsd4_compoundargs
*argp
,
657 struct nfsd4_cb_sec
*cbs
)
659 u32 stamp
, gidcount
, uid
, gid
;
662 if (xdr_stream_decode_u32(argp
->xdr
, &stamp
) < 0)
663 return nfserr_bad_xdr
;
665 status
= nfsd4_decode_ignored_string(argp
, 255);
668 if (xdr_stream_decode_u32(argp
->xdr
, &uid
) < 0)
669 return nfserr_bad_xdr
;
670 if (xdr_stream_decode_u32(argp
->xdr
, &gid
) < 0)
671 return nfserr_bad_xdr
;
672 if (xdr_stream_decode_u32(argp
->xdr
, &gidcount
) < 0)
673 return nfserr_bad_xdr
;
675 return nfserr_bad_xdr
;
676 p
= xdr_inline_decode(argp
->xdr
, gidcount
<< 2);
678 return nfserr_bad_xdr
;
679 if (cbs
->flavor
== (u32
)(-1)) {
680 struct user_namespace
*userns
= nfsd_user_namespace(argp
->rqstp
);
682 kuid_t kuid
= make_kuid(userns
, uid
);
683 kgid_t kgid
= make_kgid(userns
, gid
);
684 if (uid_valid(kuid
) && gid_valid(kgid
)) {
687 cbs
->flavor
= RPC_AUTH_UNIX
;
689 dprintk("RPC_AUTH_UNIX with invalid uid or gid, ignoring!\n");
697 nfsd4_decode_gss_cb_handles4(struct nfsd4_compoundargs
*argp
,
698 struct nfsd4_cb_sec
*cbs
)
703 dprintk("RPC_AUTH_GSS callback secflavor not supported!\n");
705 if (xdr_stream_decode_u32(argp
->xdr
, &service
) < 0)
706 return nfserr_bad_xdr
;
707 if (service
< RPC_GSS_SVC_NONE
|| service
> RPC_GSS_SVC_PRIVACY
)
708 return nfserr_bad_xdr
;
709 /* gcbp_handle_from_server */
710 status
= nfsd4_decode_ignored_string(argp
, 0);
713 /* gcbp_handle_from_client */
714 status
= nfsd4_decode_ignored_string(argp
, 0);
721 /* a counted array of callback_sec_parms4 items */
723 nfsd4_decode_cb_sec(struct nfsd4_compoundargs
*argp
, struct nfsd4_cb_sec
*cbs
)
725 u32 i
, secflavor
, nr_secflavs
;
728 /* callback_sec_params4 */
729 if (xdr_stream_decode_u32(argp
->xdr
, &nr_secflavs
) < 0)
730 return nfserr_bad_xdr
;
732 cbs
->flavor
= (u32
)(-1);
734 /* Is this legal? Be generous, take it to mean AUTH_NONE: */
737 for (i
= 0; i
< nr_secflavs
; ++i
) {
738 if (xdr_stream_decode_u32(argp
->xdr
, &secflavor
) < 0)
739 return nfserr_bad_xdr
;
743 if (cbs
->flavor
== (u32
)(-1))
744 cbs
->flavor
= RPC_AUTH_NULL
;
747 status
= nfsd4_decode_authsys_parms(argp
, cbs
);
752 status
= nfsd4_decode_gss_cb_handles4(argp
, cbs
);
766 * NFSv4 operation argument decoders
770 nfsd4_decode_access(struct nfsd4_compoundargs
*argp
,
771 struct nfsd4_access
*access
)
773 if (xdr_stream_decode_u32(argp
->xdr
, &access
->ac_req_access
) < 0)
774 return nfserr_bad_xdr
;
779 nfsd4_decode_close(struct nfsd4_compoundargs
*argp
, struct nfsd4_close
*close
)
781 if (xdr_stream_decode_u32(argp
->xdr
, &close
->cl_seqid
) < 0)
782 return nfserr_bad_xdr
;
783 return nfsd4_decode_stateid4(argp
, &close
->cl_stateid
);
788 nfsd4_decode_commit(struct nfsd4_compoundargs
*argp
, struct nfsd4_commit
*commit
)
790 if (xdr_stream_decode_u64(argp
->xdr
, &commit
->co_offset
) < 0)
791 return nfserr_bad_xdr
;
792 if (xdr_stream_decode_u32(argp
->xdr
, &commit
->co_count
) < 0)
793 return nfserr_bad_xdr
;
798 nfsd4_decode_create(struct nfsd4_compoundargs
*argp
, struct nfsd4_create
*create
)
802 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_type
) < 0)
803 return nfserr_bad_xdr
;
804 switch (create
->cr_type
) {
806 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_datalen
) < 0)
807 return nfserr_bad_xdr
;
808 p
= xdr_inline_decode(argp
->xdr
, create
->cr_datalen
);
810 return nfserr_bad_xdr
;
811 create
->cr_data
= svcxdr_dupstr(argp
, p
, create
->cr_datalen
);
812 if (!create
->cr_data
)
813 return nfserr_jukebox
;
817 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_specdata1
) < 0)
818 return nfserr_bad_xdr
;
819 if (xdr_stream_decode_u32(argp
->xdr
, &create
->cr_specdata2
) < 0)
820 return nfserr_bad_xdr
;
828 status
= nfsd4_decode_component4(argp
, &create
->cr_name
,
829 &create
->cr_namelen
);
832 status
= nfsd4_decode_fattr4(argp
, create
->cr_bmval
,
833 ARRAY_SIZE(create
->cr_bmval
),
834 &create
->cr_iattr
, &create
->cr_acl
,
835 &create
->cr_label
, &create
->cr_umask
);
843 nfsd4_decode_delegreturn(struct nfsd4_compoundargs
*argp
, struct nfsd4_delegreturn
*dr
)
845 return nfsd4_decode_stateid4(argp
, &dr
->dr_stateid
);
849 nfsd4_decode_getattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_getattr
*getattr
)
851 return nfsd4_decode_bitmap4(argp
, getattr
->ga_bmval
,
852 ARRAY_SIZE(getattr
->ga_bmval
));
856 nfsd4_decode_link(struct nfsd4_compoundargs
*argp
, struct nfsd4_link
*link
)
858 return nfsd4_decode_component4(argp
, &link
->li_name
, &link
->li_namelen
);
862 nfsd4_decode_open_to_lock_owner4(struct nfsd4_compoundargs
*argp
,
863 struct nfsd4_lock
*lock
)
867 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_new_open_seqid
) < 0)
868 return nfserr_bad_xdr
;
869 status
= nfsd4_decode_stateid4(argp
, &lock
->lk_new_open_stateid
);
872 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_new_lock_seqid
) < 0)
873 return nfserr_bad_xdr
;
874 return nfsd4_decode_state_owner4(argp
, &lock
->lk_new_clientid
,
875 &lock
->lk_new_owner
);
879 nfsd4_decode_exist_lock_owner4(struct nfsd4_compoundargs
*argp
,
880 struct nfsd4_lock
*lock
)
884 status
= nfsd4_decode_stateid4(argp
, &lock
->lk_old_lock_stateid
);
887 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_old_lock_seqid
) < 0)
888 return nfserr_bad_xdr
;
894 nfsd4_decode_locker4(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
896 if (xdr_stream_decode_bool(argp
->xdr
, &lock
->lk_is_new
) < 0)
897 return nfserr_bad_xdr
;
899 return nfsd4_decode_open_to_lock_owner4(argp
, lock
);
900 return nfsd4_decode_exist_lock_owner4(argp
, lock
);
904 nfsd4_decode_lock(struct nfsd4_compoundargs
*argp
, struct nfsd4_lock
*lock
)
906 if (xdr_stream_decode_u32(argp
->xdr
, &lock
->lk_type
) < 0)
907 return nfserr_bad_xdr
;
908 if ((lock
->lk_type
< NFS4_READ_LT
) || (lock
->lk_type
> NFS4_WRITEW_LT
))
909 return nfserr_bad_xdr
;
910 if (xdr_stream_decode_bool(argp
->xdr
, &lock
->lk_reclaim
) < 0)
911 return nfserr_bad_xdr
;
912 if (xdr_stream_decode_u64(argp
->xdr
, &lock
->lk_offset
) < 0)
913 return nfserr_bad_xdr
;
914 if (xdr_stream_decode_u64(argp
->xdr
, &lock
->lk_length
) < 0)
915 return nfserr_bad_xdr
;
916 return nfsd4_decode_locker4(argp
, lock
);
920 nfsd4_decode_lockt(struct nfsd4_compoundargs
*argp
, struct nfsd4_lockt
*lockt
)
922 if (xdr_stream_decode_u32(argp
->xdr
, &lockt
->lt_type
) < 0)
923 return nfserr_bad_xdr
;
924 if ((lockt
->lt_type
< NFS4_READ_LT
) || (lockt
->lt_type
> NFS4_WRITEW_LT
))
925 return nfserr_bad_xdr
;
926 if (xdr_stream_decode_u64(argp
->xdr
, &lockt
->lt_offset
) < 0)
927 return nfserr_bad_xdr
;
928 if (xdr_stream_decode_u64(argp
->xdr
, &lockt
->lt_length
) < 0)
929 return nfserr_bad_xdr
;
930 return nfsd4_decode_state_owner4(argp
, &lockt
->lt_clientid
,
935 nfsd4_decode_locku(struct nfsd4_compoundargs
*argp
, struct nfsd4_locku
*locku
)
939 if (xdr_stream_decode_u32(argp
->xdr
, &locku
->lu_type
) < 0)
940 return nfserr_bad_xdr
;
941 if ((locku
->lu_type
< NFS4_READ_LT
) || (locku
->lu_type
> NFS4_WRITEW_LT
))
942 return nfserr_bad_xdr
;
943 if (xdr_stream_decode_u32(argp
->xdr
, &locku
->lu_seqid
) < 0)
944 return nfserr_bad_xdr
;
945 status
= nfsd4_decode_stateid4(argp
, &locku
->lu_stateid
);
948 if (xdr_stream_decode_u64(argp
->xdr
, &locku
->lu_offset
) < 0)
949 return nfserr_bad_xdr
;
950 if (xdr_stream_decode_u64(argp
->xdr
, &locku
->lu_length
) < 0)
951 return nfserr_bad_xdr
;
957 nfsd4_decode_lookup(struct nfsd4_compoundargs
*argp
, struct nfsd4_lookup
*lookup
)
959 return nfsd4_decode_component4(argp
, &lookup
->lo_name
, &lookup
->lo_len
);
963 nfsd4_decode_createhow4(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
967 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_createmode
) < 0)
968 return nfserr_bad_xdr
;
969 switch (open
->op_createmode
) {
970 case NFS4_CREATE_UNCHECKED
:
971 case NFS4_CREATE_GUARDED
:
972 status
= nfsd4_decode_fattr4(argp
, open
->op_bmval
,
973 ARRAY_SIZE(open
->op_bmval
),
974 &open
->op_iattr
, &open
->op_acl
,
975 &open
->op_label
, &open
->op_umask
);
979 case NFS4_CREATE_EXCLUSIVE
:
980 status
= nfsd4_decode_verifier4(argp
, &open
->op_verf
);
984 case NFS4_CREATE_EXCLUSIVE4_1
:
985 if (argp
->minorversion
< 1)
986 return nfserr_bad_xdr
;
987 status
= nfsd4_decode_verifier4(argp
, &open
->op_verf
);
990 status
= nfsd4_decode_fattr4(argp
, open
->op_bmval
,
991 ARRAY_SIZE(open
->op_bmval
),
992 &open
->op_iattr
, &open
->op_acl
,
993 &open
->op_label
, &open
->op_umask
);
998 return nfserr_bad_xdr
;
1005 nfsd4_decode_openflag4(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
1009 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_create
) < 0)
1010 return nfserr_bad_xdr
;
1011 switch (open
->op_create
) {
1012 case NFS4_OPEN_NOCREATE
:
1014 case NFS4_OPEN_CREATE
:
1015 status
= nfsd4_decode_createhow4(argp
, open
);
1020 return nfserr_bad_xdr
;
1026 static __be32
nfsd4_decode_share_access(struct nfsd4_compoundargs
*argp
, u32
*share_access
, u32
*deleg_want
, u32
*deleg_when
)
1030 if (xdr_stream_decode_u32(argp
->xdr
, &w
) < 0)
1031 return nfserr_bad_xdr
;
1032 *share_access
= w
& NFS4_SHARE_ACCESS_MASK
;
1033 *deleg_want
= w
& NFS4_SHARE_WANT_MASK
;
1035 *deleg_when
= w
& NFS4_SHARE_WHEN_MASK
;
1037 switch (w
& NFS4_SHARE_ACCESS_MASK
) {
1038 case NFS4_SHARE_ACCESS_READ
:
1039 case NFS4_SHARE_ACCESS_WRITE
:
1040 case NFS4_SHARE_ACCESS_BOTH
:
1043 return nfserr_bad_xdr
;
1045 w
&= ~NFS4_SHARE_ACCESS_MASK
;
1048 if (!argp
->minorversion
)
1049 return nfserr_bad_xdr
;
1050 switch (w
& NFS4_SHARE_WANT_MASK
) {
1051 case NFS4_SHARE_WANT_NO_PREFERENCE
:
1052 case NFS4_SHARE_WANT_READ_DELEG
:
1053 case NFS4_SHARE_WANT_WRITE_DELEG
:
1054 case NFS4_SHARE_WANT_ANY_DELEG
:
1055 case NFS4_SHARE_WANT_NO_DELEG
:
1056 case NFS4_SHARE_WANT_CANCEL
:
1059 return nfserr_bad_xdr
;
1061 w
&= ~NFS4_SHARE_WANT_MASK
;
1065 if (!deleg_when
) /* open_downgrade */
1066 return nfserr_inval
;
1068 case NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
:
1069 case NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
:
1070 case (NFS4_SHARE_SIGNAL_DELEG_WHEN_RESRC_AVAIL
|
1071 NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
):
1074 return nfserr_bad_xdr
;
1077 static __be32
nfsd4_decode_share_deny(struct nfsd4_compoundargs
*argp
, u32
*x
)
1079 if (xdr_stream_decode_u32(argp
->xdr
, x
) < 0)
1080 return nfserr_bad_xdr
;
1081 /* Note: unlike access bits, deny bits may be zero. */
1082 if (*x
& ~NFS4_SHARE_DENY_BOTH
)
1083 return nfserr_bad_xdr
;
1089 nfsd4_decode_open_claim4(struct nfsd4_compoundargs
*argp
,
1090 struct nfsd4_open
*open
)
1094 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_claim_type
) < 0)
1095 return nfserr_bad_xdr
;
1096 switch (open
->op_claim_type
) {
1097 case NFS4_OPEN_CLAIM_NULL
:
1098 case NFS4_OPEN_CLAIM_DELEGATE_PREV
:
1099 status
= nfsd4_decode_component4(argp
, &open
->op_fname
,
1100 &open
->op_fnamelen
);
1104 case NFS4_OPEN_CLAIM_PREVIOUS
:
1105 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_delegate_type
) < 0)
1106 return nfserr_bad_xdr
;
1108 case NFS4_OPEN_CLAIM_DELEGATE_CUR
:
1109 status
= nfsd4_decode_stateid4(argp
, &open
->op_delegate_stateid
);
1112 status
= nfsd4_decode_component4(argp
, &open
->op_fname
,
1113 &open
->op_fnamelen
);
1117 case NFS4_OPEN_CLAIM_FH
:
1118 case NFS4_OPEN_CLAIM_DELEG_PREV_FH
:
1119 if (argp
->minorversion
< 1)
1120 return nfserr_bad_xdr
;
1123 case NFS4_OPEN_CLAIM_DELEG_CUR_FH
:
1124 if (argp
->minorversion
< 1)
1125 return nfserr_bad_xdr
;
1126 status
= nfsd4_decode_stateid4(argp
, &open
->op_delegate_stateid
);
1131 return nfserr_bad_xdr
;
1138 nfsd4_decode_open(struct nfsd4_compoundargs
*argp
, struct nfsd4_open
*open
)
1143 memset(open
->op_bmval
, 0, sizeof(open
->op_bmval
));
1144 open
->op_iattr
.ia_valid
= 0;
1145 open
->op_openowner
= NULL
;
1147 open
->op_xdr_error
= 0;
1148 if (xdr_stream_decode_u32(argp
->xdr
, &open
->op_seqid
) < 0)
1149 return nfserr_bad_xdr
;
1150 /* deleg_want is ignored */
1151 status
= nfsd4_decode_share_access(argp
, &open
->op_share_access
,
1152 &open
->op_deleg_want
, &dummy
);
1155 status
= nfsd4_decode_share_deny(argp
, &open
->op_share_deny
);
1158 status
= nfsd4_decode_state_owner4(argp
, &open
->op_clientid
,
1162 status
= nfsd4_decode_openflag4(argp
, open
);
1165 return nfsd4_decode_open_claim4(argp
, open
);
1169 nfsd4_decode_open_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_confirm
*open_conf
)
1173 if (argp
->minorversion
>= 1)
1174 return nfserr_notsupp
;
1176 status
= nfsd4_decode_stateid4(argp
, &open_conf
->oc_req_stateid
);
1179 if (xdr_stream_decode_u32(argp
->xdr
, &open_conf
->oc_seqid
) < 0)
1180 return nfserr_bad_xdr
;
1186 nfsd4_decode_open_downgrade(struct nfsd4_compoundargs
*argp
, struct nfsd4_open_downgrade
*open_down
)
1190 status
= nfsd4_decode_stateid4(argp
, &open_down
->od_stateid
);
1193 if (xdr_stream_decode_u32(argp
->xdr
, &open_down
->od_seqid
) < 0)
1194 return nfserr_bad_xdr
;
1195 /* deleg_want is ignored */
1196 status
= nfsd4_decode_share_access(argp
, &open_down
->od_share_access
,
1197 &open_down
->od_deleg_want
, NULL
);
1200 return nfsd4_decode_share_deny(argp
, &open_down
->od_share_deny
);
1204 nfsd4_decode_putfh(struct nfsd4_compoundargs
*argp
, struct nfsd4_putfh
*putfh
)
1208 if (xdr_stream_decode_u32(argp
->xdr
, &putfh
->pf_fhlen
) < 0)
1209 return nfserr_bad_xdr
;
1210 if (putfh
->pf_fhlen
> NFS4_FHSIZE
)
1211 return nfserr_bad_xdr
;
1212 p
= xdr_inline_decode(argp
->xdr
, putfh
->pf_fhlen
);
1214 return nfserr_bad_xdr
;
1215 putfh
->pf_fhval
= svcxdr_savemem(argp
, p
, putfh
->pf_fhlen
);
1216 if (!putfh
->pf_fhval
)
1217 return nfserr_jukebox
;
1223 nfsd4_decode_putpubfh(struct nfsd4_compoundargs
*argp
, void *p
)
1225 if (argp
->minorversion
== 0)
1227 return nfserr_notsupp
;
1231 nfsd4_decode_read(struct nfsd4_compoundargs
*argp
, struct nfsd4_read
*read
)
1235 status
= nfsd4_decode_stateid4(argp
, &read
->rd_stateid
);
1238 if (xdr_stream_decode_u64(argp
->xdr
, &read
->rd_offset
) < 0)
1239 return nfserr_bad_xdr
;
1240 if (xdr_stream_decode_u32(argp
->xdr
, &read
->rd_length
) < 0)
1241 return nfserr_bad_xdr
;
1247 nfsd4_decode_readdir(struct nfsd4_compoundargs
*argp
, struct nfsd4_readdir
*readdir
)
1251 if (xdr_stream_decode_u64(argp
->xdr
, &readdir
->rd_cookie
) < 0)
1252 return nfserr_bad_xdr
;
1253 status
= nfsd4_decode_verifier4(argp
, &readdir
->rd_verf
);
1256 if (xdr_stream_decode_u32(argp
->xdr
, &readdir
->rd_dircount
) < 0)
1257 return nfserr_bad_xdr
;
1258 if (xdr_stream_decode_u32(argp
->xdr
, &readdir
->rd_maxcount
) < 0)
1259 return nfserr_bad_xdr
;
1260 if (xdr_stream_decode_uint32_array(argp
->xdr
, readdir
->rd_bmval
,
1261 ARRAY_SIZE(readdir
->rd_bmval
)) < 0)
1262 return nfserr_bad_xdr
;
1268 nfsd4_decode_remove(struct nfsd4_compoundargs
*argp
, struct nfsd4_remove
*remove
)
1270 return nfsd4_decode_component4(argp
, &remove
->rm_name
, &remove
->rm_namelen
);
1274 nfsd4_decode_rename(struct nfsd4_compoundargs
*argp
, struct nfsd4_rename
*rename
)
1278 status
= nfsd4_decode_component4(argp
, &rename
->rn_sname
, &rename
->rn_snamelen
);
1281 return nfsd4_decode_component4(argp
, &rename
->rn_tname
, &rename
->rn_tnamelen
);
1285 nfsd4_decode_renew(struct nfsd4_compoundargs
*argp
, clientid_t
*clientid
)
1287 return nfsd4_decode_clientid4(argp
, clientid
);
1291 nfsd4_decode_secinfo(struct nfsd4_compoundargs
*argp
,
1292 struct nfsd4_secinfo
*secinfo
)
1294 return nfsd4_decode_component4(argp
, &secinfo
->si_name
, &secinfo
->si_namelen
);
1298 nfsd4_decode_setattr(struct nfsd4_compoundargs
*argp
, struct nfsd4_setattr
*setattr
)
1302 status
= nfsd4_decode_stateid4(argp
, &setattr
->sa_stateid
);
1305 return nfsd4_decode_fattr4(argp
, setattr
->sa_bmval
,
1306 ARRAY_SIZE(setattr
->sa_bmval
),
1307 &setattr
->sa_iattr
, &setattr
->sa_acl
,
1308 &setattr
->sa_label
, NULL
);
1312 nfsd4_decode_setclientid(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid
*setclientid
)
1316 if (argp
->minorversion
>= 1)
1317 return nfserr_notsupp
;
1319 status
= nfsd4_decode_verifier4(argp
, &setclientid
->se_verf
);
1322 status
= nfsd4_decode_opaque(argp
, &setclientid
->se_name
);
1325 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_prog
) < 0)
1326 return nfserr_bad_xdr
;
1327 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_netid_len
) < 0)
1328 return nfserr_bad_xdr
;
1329 p
= xdr_inline_decode(argp
->xdr
, setclientid
->se_callback_netid_len
);
1331 return nfserr_bad_xdr
;
1332 setclientid
->se_callback_netid_val
= svcxdr_savemem(argp
, p
,
1333 setclientid
->se_callback_netid_len
);
1334 if (!setclientid
->se_callback_netid_val
)
1335 return nfserr_jukebox
;
1337 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_addr_len
) < 0)
1338 return nfserr_bad_xdr
;
1339 p
= xdr_inline_decode(argp
->xdr
, setclientid
->se_callback_addr_len
);
1341 return nfserr_bad_xdr
;
1342 setclientid
->se_callback_addr_val
= svcxdr_savemem(argp
, p
,
1343 setclientid
->se_callback_addr_len
);
1344 if (!setclientid
->se_callback_addr_val
)
1345 return nfserr_jukebox
;
1346 if (xdr_stream_decode_u32(argp
->xdr
, &setclientid
->se_callback_ident
) < 0)
1347 return nfserr_bad_xdr
;
1353 nfsd4_decode_setclientid_confirm(struct nfsd4_compoundargs
*argp
, struct nfsd4_setclientid_confirm
*scd_c
)
1357 if (argp
->minorversion
>= 1)
1358 return nfserr_notsupp
;
1360 status
= nfsd4_decode_clientid4(argp
, &scd_c
->sc_clientid
);
1363 return nfsd4_decode_verifier4(argp
, &scd_c
->sc_confirm
);
1366 /* Also used for NVERIFY */
1368 nfsd4_decode_verify(struct nfsd4_compoundargs
*argp
, struct nfsd4_verify
*verify
)
1372 status
= nfsd4_decode_bitmap4(argp
, verify
->ve_bmval
,
1373 ARRAY_SIZE(verify
->ve_bmval
));
1377 /* For convenience's sake, we compare raw xdr'd attributes in
1378 * nfsd4_proc_verify */
1380 if (xdr_stream_decode_u32(argp
->xdr
, &verify
->ve_attrlen
) < 0)
1381 return nfserr_bad_xdr
;
1382 p
= xdr_inline_decode(argp
->xdr
, verify
->ve_attrlen
);
1384 return nfserr_bad_xdr
;
1385 verify
->ve_attrval
= svcxdr_savemem(argp
, p
, verify
->ve_attrlen
);
1386 if (!verify
->ve_attrval
)
1387 return nfserr_jukebox
;
1393 nfsd4_decode_write(struct nfsd4_compoundargs
*argp
, struct nfsd4_write
*write
)
1397 status
= nfsd4_decode_stateid4(argp
, &write
->wr_stateid
);
1400 if (xdr_stream_decode_u64(argp
->xdr
, &write
->wr_offset
) < 0)
1401 return nfserr_bad_xdr
;
1402 if (xdr_stream_decode_u32(argp
->xdr
, &write
->wr_stable_how
) < 0)
1403 return nfserr_bad_xdr
;
1404 if (write
->wr_stable_how
> NFS_FILE_SYNC
)
1405 return nfserr_bad_xdr
;
1406 if (xdr_stream_decode_u32(argp
->xdr
, &write
->wr_buflen
) < 0)
1407 return nfserr_bad_xdr
;
1408 if (!xdr_stream_subsegment(argp
->xdr
, &write
->wr_payload
, write
->wr_buflen
))
1409 return nfserr_bad_xdr
;
1415 nfsd4_decode_release_lockowner(struct nfsd4_compoundargs
*argp
, struct nfsd4_release_lockowner
*rlockowner
)
1419 if (argp
->minorversion
>= 1)
1420 return nfserr_notsupp
;
1422 status
= nfsd4_decode_state_owner4(argp
, &rlockowner
->rl_clientid
,
1423 &rlockowner
->rl_owner
);
1427 if (argp
->minorversion
&& !zero_clientid(&rlockowner
->rl_clientid
))
1428 return nfserr_inval
;
1433 static __be32
nfsd4_decode_backchannel_ctl(struct nfsd4_compoundargs
*argp
, struct nfsd4_backchannel_ctl
*bc
)
1435 if (xdr_stream_decode_u32(argp
->xdr
, &bc
->bc_cb_program
) < 0)
1436 return nfserr_bad_xdr
;
1437 return nfsd4_decode_cb_sec(argp
, &bc
->bc_cb_sec
);
1440 static __be32
nfsd4_decode_bind_conn_to_session(struct nfsd4_compoundargs
*argp
, struct nfsd4_bind_conn_to_session
*bcts
)
1442 u32 use_conn_in_rdma_mode
;
1445 status
= nfsd4_decode_sessionid4(argp
, &bcts
->sessionid
);
1448 if (xdr_stream_decode_u32(argp
->xdr
, &bcts
->dir
) < 0)
1449 return nfserr_bad_xdr
;
1450 if (xdr_stream_decode_u32(argp
->xdr
, &use_conn_in_rdma_mode
) < 0)
1451 return nfserr_bad_xdr
;
1457 nfsd4_decode_state_protect_ops(struct nfsd4_compoundargs
*argp
,
1458 struct nfsd4_exchange_id
*exid
)
1462 status
= nfsd4_decode_bitmap4(argp
, exid
->spo_must_enforce
,
1463 ARRAY_SIZE(exid
->spo_must_enforce
));
1465 return nfserr_bad_xdr
;
1466 status
= nfsd4_decode_bitmap4(argp
, exid
->spo_must_allow
,
1467 ARRAY_SIZE(exid
->spo_must_allow
));
1469 return nfserr_bad_xdr
;
1475 * This implementation currently does not support SP4_SSV.
1476 * This decoder simply skips over these arguments.
1478 static noinline __be32
1479 nfsd4_decode_ssv_sp_parms(struct nfsd4_compoundargs
*argp
,
1480 struct nfsd4_exchange_id
*exid
)
1482 u32 count
, window
, num_gss_handles
;
1486 status
= nfsd4_decode_state_protect_ops(argp
, exid
);
1490 /* ssp_hash_algs<> */
1491 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1492 return nfserr_bad_xdr
;
1494 status
= nfsd4_decode_ignored_string(argp
, 0);
1499 /* ssp_encr_algs<> */
1500 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1501 return nfserr_bad_xdr
;
1503 status
= nfsd4_decode_ignored_string(argp
, 0);
1508 if (xdr_stream_decode_u32(argp
->xdr
, &window
) < 0)
1509 return nfserr_bad_xdr
;
1510 if (xdr_stream_decode_u32(argp
->xdr
, &num_gss_handles
) < 0)
1511 return nfserr_bad_xdr
;
1517 nfsd4_decode_state_protect4_a(struct nfsd4_compoundargs
*argp
,
1518 struct nfsd4_exchange_id
*exid
)
1522 if (xdr_stream_decode_u32(argp
->xdr
, &exid
->spa_how
) < 0)
1523 return nfserr_bad_xdr
;
1524 switch (exid
->spa_how
) {
1528 status
= nfsd4_decode_state_protect_ops(argp
, exid
);
1533 status
= nfsd4_decode_ssv_sp_parms(argp
, exid
);
1538 return nfserr_bad_xdr
;
1545 nfsd4_decode_nfs_impl_id4(struct nfsd4_compoundargs
*argp
,
1546 struct nfsd4_exchange_id
*exid
)
1551 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1552 return nfserr_bad_xdr
;
1557 /* Note that RFC 8881 places no length limit on
1558 * nii_domain, but this implementation permits no
1559 * more than NFS4_OPAQUE_LIMIT bytes */
1560 status
= nfsd4_decode_opaque(argp
, &exid
->nii_domain
);
1563 /* Note that RFC 8881 places no length limit on
1564 * nii_name, but this implementation permits no
1565 * more than NFS4_OPAQUE_LIMIT bytes */
1566 status
= nfsd4_decode_opaque(argp
, &exid
->nii_name
);
1569 status
= nfsd4_decode_nfstime4(argp
, &exid
->nii_time
);
1574 return nfserr_bad_xdr
;
1581 nfsd4_decode_exchange_id(struct nfsd4_compoundargs
*argp
,
1582 struct nfsd4_exchange_id
*exid
)
1586 status
= nfsd4_decode_verifier4(argp
, &exid
->verifier
);
1589 status
= nfsd4_decode_opaque(argp
, &exid
->clname
);
1592 if (xdr_stream_decode_u32(argp
->xdr
, &exid
->flags
) < 0)
1593 return nfserr_bad_xdr
;
1594 status
= nfsd4_decode_state_protect4_a(argp
, exid
);
1597 return nfsd4_decode_nfs_impl_id4(argp
, exid
);
1601 nfsd4_decode_channel_attrs4(struct nfsd4_compoundargs
*argp
,
1602 struct nfsd4_channel_attrs
*ca
)
1606 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
* 7);
1608 return nfserr_bad_xdr
;
1610 /* headerpadsz is ignored */
1612 ca
->maxreq_sz
= be32_to_cpup(p
++);
1613 ca
->maxresp_sz
= be32_to_cpup(p
++);
1614 ca
->maxresp_cached
= be32_to_cpup(p
++);
1615 ca
->maxops
= be32_to_cpup(p
++);
1616 ca
->maxreqs
= be32_to_cpup(p
++);
1617 ca
->nr_rdma_attrs
= be32_to_cpup(p
);
1618 switch (ca
->nr_rdma_attrs
) {
1622 if (xdr_stream_decode_u32(argp
->xdr
, &ca
->rdma_attrs
) < 0)
1623 return nfserr_bad_xdr
;
1626 return nfserr_bad_xdr
;
1633 nfsd4_decode_create_session(struct nfsd4_compoundargs
*argp
,
1634 struct nfsd4_create_session
*sess
)
1638 status
= nfsd4_decode_clientid4(argp
, &sess
->clientid
);
1641 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->seqid
) < 0)
1642 return nfserr_bad_xdr
;
1643 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->flags
) < 0)
1644 return nfserr_bad_xdr
;
1645 status
= nfsd4_decode_channel_attrs4(argp
, &sess
->fore_channel
);
1648 status
= nfsd4_decode_channel_attrs4(argp
, &sess
->back_channel
);
1651 if (xdr_stream_decode_u32(argp
->xdr
, &sess
->callback_prog
) < 0)
1652 return nfserr_bad_xdr
;
1653 status
= nfsd4_decode_cb_sec(argp
, &sess
->cb_sec
);
1661 nfsd4_decode_destroy_session(struct nfsd4_compoundargs
*argp
,
1662 struct nfsd4_destroy_session
*destroy_session
)
1664 return nfsd4_decode_sessionid4(argp
, &destroy_session
->sessionid
);
1668 nfsd4_decode_free_stateid(struct nfsd4_compoundargs
*argp
,
1669 struct nfsd4_free_stateid
*free_stateid
)
1671 return nfsd4_decode_stateid4(argp
, &free_stateid
->fr_stateid
);
1674 #ifdef CONFIG_NFSD_PNFS
1676 nfsd4_decode_getdeviceinfo(struct nfsd4_compoundargs
*argp
,
1677 struct nfsd4_getdeviceinfo
*gdev
)
1681 status
= nfsd4_decode_deviceid4(argp
, &gdev
->gd_devid
);
1684 if (xdr_stream_decode_u32(argp
->xdr
, &gdev
->gd_layout_type
) < 0)
1685 return nfserr_bad_xdr
;
1686 if (xdr_stream_decode_u32(argp
->xdr
, &gdev
->gd_maxcount
) < 0)
1687 return nfserr_bad_xdr
;
1688 if (xdr_stream_decode_uint32_array(argp
->xdr
,
1689 &gdev
->gd_notify_types
, 1) < 0)
1690 return nfserr_bad_xdr
;
1696 nfsd4_decode_layoutcommit(struct nfsd4_compoundargs
*argp
,
1697 struct nfsd4_layoutcommit
*lcp
)
1701 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_seg
.offset
) < 0)
1702 return nfserr_bad_xdr
;
1703 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_seg
.length
) < 0)
1704 return nfserr_bad_xdr
;
1705 if (xdr_stream_decode_bool(argp
->xdr
, &lcp
->lc_reclaim
) < 0)
1706 return nfserr_bad_xdr
;
1707 status
= nfsd4_decode_stateid4(argp
, &lcp
->lc_sid
);
1710 if (xdr_stream_decode_u32(argp
->xdr
, &lcp
->lc_newoffset
) < 0)
1711 return nfserr_bad_xdr
;
1712 if (lcp
->lc_newoffset
) {
1713 if (xdr_stream_decode_u64(argp
->xdr
, &lcp
->lc_last_wr
) < 0)
1714 return nfserr_bad_xdr
;
1716 lcp
->lc_last_wr
= 0;
1717 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
);
1719 return nfserr_bad_xdr
;
1720 if (xdr_item_is_present(p
)) {
1721 status
= nfsd4_decode_nfstime4(argp
, &lcp
->lc_mtime
);
1725 lcp
->lc_mtime
.tv_nsec
= UTIME_NOW
;
1727 return nfsd4_decode_layoutupdate4(argp
, lcp
);
1731 nfsd4_decode_layoutget(struct nfsd4_compoundargs
*argp
,
1732 struct nfsd4_layoutget
*lgp
)
1736 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_signal
) < 0)
1737 return nfserr_bad_xdr
;
1738 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_layout_type
) < 0)
1739 return nfserr_bad_xdr
;
1740 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_seg
.iomode
) < 0)
1741 return nfserr_bad_xdr
;
1742 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_seg
.offset
) < 0)
1743 return nfserr_bad_xdr
;
1744 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_seg
.length
) < 0)
1745 return nfserr_bad_xdr
;
1746 if (xdr_stream_decode_u64(argp
->xdr
, &lgp
->lg_minlength
) < 0)
1747 return nfserr_bad_xdr
;
1748 status
= nfsd4_decode_stateid4(argp
, &lgp
->lg_sid
);
1751 if (xdr_stream_decode_u32(argp
->xdr
, &lgp
->lg_maxcount
) < 0)
1752 return nfserr_bad_xdr
;
1758 nfsd4_decode_layoutreturn(struct nfsd4_compoundargs
*argp
,
1759 struct nfsd4_layoutreturn
*lrp
)
1761 if (xdr_stream_decode_bool(argp
->xdr
, &lrp
->lr_reclaim
) < 0)
1762 return nfserr_bad_xdr
;
1763 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_layout_type
) < 0)
1764 return nfserr_bad_xdr
;
1765 if (xdr_stream_decode_u32(argp
->xdr
, &lrp
->lr_seg
.iomode
) < 0)
1766 return nfserr_bad_xdr
;
1767 return nfsd4_decode_layoutreturn4(argp
, lrp
);
1769 #endif /* CONFIG_NFSD_PNFS */
1771 static __be32
nfsd4_decode_secinfo_no_name(struct nfsd4_compoundargs
*argp
,
1772 struct nfsd4_secinfo_no_name
*sin
)
1774 if (xdr_stream_decode_u32(argp
->xdr
, &sin
->sin_style
) < 0)
1775 return nfserr_bad_xdr
;
1780 nfsd4_decode_sequence(struct nfsd4_compoundargs
*argp
,
1781 struct nfsd4_sequence
*seq
)
1785 status
= nfsd4_decode_sessionid4(argp
, &seq
->sessionid
);
1788 p
= xdr_inline_decode(argp
->xdr
, XDR_UNIT
* 4);
1790 return nfserr_bad_xdr
;
1791 seq
->seqid
= be32_to_cpup(p
++);
1792 seq
->slotid
= be32_to_cpup(p
++);
1793 seq
->maxslots
= be32_to_cpup(p
++);
1794 seq
->cachethis
= be32_to_cpup(p
);
1800 nfsd4_decode_test_stateid(struct nfsd4_compoundargs
*argp
, struct nfsd4_test_stateid
*test_stateid
)
1802 struct nfsd4_test_stateid_id
*stateid
;
1806 if (xdr_stream_decode_u32(argp
->xdr
, &test_stateid
->ts_num_ids
) < 0)
1807 return nfserr_bad_xdr
;
1809 INIT_LIST_HEAD(&test_stateid
->ts_stateid_list
);
1810 for (i
= 0; i
< test_stateid
->ts_num_ids
; i
++) {
1811 stateid
= svcxdr_tmpalloc(argp
, sizeof(*stateid
));
1813 return nfserr_jukebox
;
1814 INIT_LIST_HEAD(&stateid
->ts_id_list
);
1815 list_add_tail(&stateid
->ts_id_list
, &test_stateid
->ts_stateid_list
);
1816 status
= nfsd4_decode_stateid4(argp
, &stateid
->ts_id_stateid
);
1824 static __be32
nfsd4_decode_destroy_clientid(struct nfsd4_compoundargs
*argp
,
1825 struct nfsd4_destroy_clientid
*dc
)
1827 return nfsd4_decode_clientid4(argp
, &dc
->clientid
);
1830 static __be32
nfsd4_decode_reclaim_complete(struct nfsd4_compoundargs
*argp
,
1831 struct nfsd4_reclaim_complete
*rc
)
1833 if (xdr_stream_decode_bool(argp
->xdr
, &rc
->rca_one_fs
) < 0)
1834 return nfserr_bad_xdr
;
1839 nfsd4_decode_fallocate(struct nfsd4_compoundargs
*argp
,
1840 struct nfsd4_fallocate
*fallocate
)
1844 status
= nfsd4_decode_stateid4(argp
, &fallocate
->falloc_stateid
);
1847 if (xdr_stream_decode_u64(argp
->xdr
, &fallocate
->falloc_offset
) < 0)
1848 return nfserr_bad_xdr
;
1849 if (xdr_stream_decode_u64(argp
->xdr
, &fallocate
->falloc_length
) < 0)
1850 return nfserr_bad_xdr
;
1855 static __be32
nfsd4_decode_nl4_server(struct nfsd4_compoundargs
*argp
,
1856 struct nl4_server
*ns
)
1858 struct nfs42_netaddr
*naddr
;
1861 if (xdr_stream_decode_u32(argp
->xdr
, &ns
->nl4_type
) < 0)
1862 return nfserr_bad_xdr
;
1864 /* currently support for 1 inter-server source server */
1865 switch (ns
->nl4_type
) {
1867 naddr
= &ns
->u
.nl4_addr
;
1869 if (xdr_stream_decode_u32(argp
->xdr
, &naddr
->netid_len
) < 0)
1870 return nfserr_bad_xdr
;
1871 if (naddr
->netid_len
> RPCBIND_MAXNETIDLEN
)
1872 return nfserr_bad_xdr
;
1874 p
= xdr_inline_decode(argp
->xdr
, naddr
->netid_len
);
1876 return nfserr_bad_xdr
;
1877 memcpy(naddr
->netid
, p
, naddr
->netid_len
);
1879 if (xdr_stream_decode_u32(argp
->xdr
, &naddr
->addr_len
) < 0)
1880 return nfserr_bad_xdr
;
1881 if (naddr
->addr_len
> RPCBIND_MAXUADDRLEN
)
1882 return nfserr_bad_xdr
;
1884 p
= xdr_inline_decode(argp
->xdr
, naddr
->addr_len
);
1886 return nfserr_bad_xdr
;
1887 memcpy(naddr
->addr
, p
, naddr
->addr_len
);
1890 return nfserr_bad_xdr
;
1897 nfsd4_decode_copy(struct nfsd4_compoundargs
*argp
, struct nfsd4_copy
*copy
)
1899 u32 consecutive
, i
, count
, sync
;
1900 struct nl4_server
*ns_dummy
;
1903 status
= nfsd4_decode_stateid4(argp
, ©
->cp_src_stateid
);
1906 status
= nfsd4_decode_stateid4(argp
, ©
->cp_dst_stateid
);
1909 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_src_pos
) < 0)
1910 return nfserr_bad_xdr
;
1911 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_dst_pos
) < 0)
1912 return nfserr_bad_xdr
;
1913 if (xdr_stream_decode_u64(argp
->xdr
, ©
->cp_count
) < 0)
1914 return nfserr_bad_xdr
;
1915 /* ca_consecutive: we always do consecutive copies */
1916 if (xdr_stream_decode_u32(argp
->xdr
, &consecutive
) < 0)
1917 return nfserr_bad_xdr
;
1918 if (xdr_stream_decode_bool(argp
->xdr
, &sync
) < 0)
1919 return nfserr_bad_xdr
;
1920 nfsd4_copy_set_sync(copy
, sync
);
1922 if (xdr_stream_decode_u32(argp
->xdr
, &count
) < 0)
1923 return nfserr_bad_xdr
;
1924 copy
->cp_src
= svcxdr_tmpalloc(argp
, sizeof(*copy
->cp_src
));
1925 if (copy
->cp_src
== NULL
)
1926 return nfserr_jukebox
;
1927 if (count
== 0) { /* intra-server copy */
1928 __set_bit(NFSD4_COPY_F_INTRA
, ©
->cp_flags
);
1932 /* decode all the supplied server addresses but use only the first */
1933 status
= nfsd4_decode_nl4_server(argp
, copy
->cp_src
);
1937 ns_dummy
= kmalloc(sizeof(struct nl4_server
), GFP_KERNEL
);
1938 if (ns_dummy
== NULL
)
1939 return nfserr_jukebox
;
1940 for (i
= 0; i
< count
- 1; i
++) {
1941 status
= nfsd4_decode_nl4_server(argp
, ns_dummy
);
1953 nfsd4_decode_copy_notify(struct nfsd4_compoundargs
*argp
,
1954 struct nfsd4_copy_notify
*cn
)
1958 cn
->cpn_src
= svcxdr_tmpalloc(argp
, sizeof(*cn
->cpn_src
));
1959 if (cn
->cpn_src
== NULL
)
1960 return nfserr_jukebox
;
1961 cn
->cpn_dst
= svcxdr_tmpalloc(argp
, sizeof(*cn
->cpn_dst
));
1962 if (cn
->cpn_dst
== NULL
)
1963 return nfserr_jukebox
;
1965 status
= nfsd4_decode_stateid4(argp
, &cn
->cpn_src_stateid
);
1968 return nfsd4_decode_nl4_server(argp
, cn
->cpn_dst
);
1972 nfsd4_decode_offload_status(struct nfsd4_compoundargs
*argp
,
1973 struct nfsd4_offload_status
*os
)
1975 return nfsd4_decode_stateid4(argp
, &os
->stateid
);
1979 nfsd4_decode_seek(struct nfsd4_compoundargs
*argp
, struct nfsd4_seek
*seek
)
1983 status
= nfsd4_decode_stateid4(argp
, &seek
->seek_stateid
);
1986 if (xdr_stream_decode_u64(argp
->xdr
, &seek
->seek_offset
) < 0)
1987 return nfserr_bad_xdr
;
1988 if (xdr_stream_decode_u32(argp
->xdr
, &seek
->seek_whence
) < 0)
1989 return nfserr_bad_xdr
;
1995 nfsd4_decode_clone(struct nfsd4_compoundargs
*argp
, struct nfsd4_clone
*clone
)
1999 status
= nfsd4_decode_stateid4(argp
, &clone
->cl_src_stateid
);
2002 status
= nfsd4_decode_stateid4(argp
, &clone
->cl_dst_stateid
);
2005 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_src_pos
) < 0)
2006 return nfserr_bad_xdr
;
2007 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_dst_pos
) < 0)
2008 return nfserr_bad_xdr
;
2009 if (xdr_stream_decode_u64(argp
->xdr
, &clone
->cl_count
) < 0)
2010 return nfserr_bad_xdr
;
2016 * XDR data that is more than PAGE_SIZE in size is normally part of a
2017 * read or write. However, the size of extended attributes is limited
2018 * by the maximum request size, and then further limited by the underlying
2019 * filesystem limits. This can exceed PAGE_SIZE (currently, XATTR_SIZE_MAX
2020 * is 64k). Since there is no kvec- or page-based interface to xattrs,
2021 * and we're not dealing with contiguous pages, we need to do some copying.
2025 * Decode data into buffer.
2028 nfsd4_vbuf_from_vector(struct nfsd4_compoundargs
*argp
, struct xdr_buf
*xdr
,
2029 char **bufp
, u32 buflen
)
2031 struct page
**pages
= xdr
->pages
;
2032 struct kvec
*head
= xdr
->head
;
2036 if (buflen
<= head
->iov_len
) {
2038 * We're in luck, the head has enough space. Just return
2039 * the head, no need for copying.
2041 *bufp
= head
->iov_base
;
2045 tmp
= svcxdr_tmpalloc(argp
, buflen
);
2047 return nfserr_jukebox
;
2050 memcpy(dp
, head
->iov_base
, head
->iov_len
);
2051 buflen
-= head
->iov_len
;
2052 dp
+= head
->iov_len
;
2054 while (buflen
> 0) {
2055 len
= min_t(u32
, buflen
, PAGE_SIZE
);
2056 memcpy(dp
, page_address(*pages
), len
);
2068 * Get a user extended attribute name from the XDR buffer.
2069 * It will not have the "user." prefix, so prepend it.
2070 * Lastly, check for nul characters in the name.
2073 nfsd4_decode_xattr_name(struct nfsd4_compoundargs
*argp
, char **namep
)
2075 char *name
, *sp
, *dp
;
2079 if (xdr_stream_decode_u32(argp
->xdr
, &namelen
) < 0)
2080 return nfserr_bad_xdr
;
2081 if (namelen
> (XATTR_NAME_MAX
- XATTR_USER_PREFIX_LEN
))
2082 return nfserr_nametoolong
;
2084 return nfserr_bad_xdr
;
2085 p
= xdr_inline_decode(argp
->xdr
, namelen
);
2087 return nfserr_bad_xdr
;
2088 name
= svcxdr_tmpalloc(argp
, namelen
+ XATTR_USER_PREFIX_LEN
+ 1);
2090 return nfserr_jukebox
;
2091 memcpy(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
);
2094 * Copy the extended attribute name over while checking for 0
2098 dp
= name
+ XATTR_USER_PREFIX_LEN
;
2103 return nfserr_bad_xdr
;
2114 * A GETXATTR op request comes without a length specifier. We just set the
2115 * maximum length for the reply based on XATTR_SIZE_MAX and the maximum
2116 * channel reply size. nfsd_getxattr will probe the length of the xattr,
2117 * check it against getxa_len, and allocate + return the value.
2120 nfsd4_decode_getxattr(struct nfsd4_compoundargs
*argp
,
2121 struct nfsd4_getxattr
*getxattr
)
2126 status
= nfsd4_decode_xattr_name(argp
, &getxattr
->getxa_name
);
2130 maxcount
= svc_max_payload(argp
->rqstp
);
2131 maxcount
= min_t(u32
, XATTR_SIZE_MAX
, maxcount
);
2133 getxattr
->getxa_len
= maxcount
;
2139 nfsd4_decode_setxattr(struct nfsd4_compoundargs
*argp
,
2140 struct nfsd4_setxattr
*setxattr
)
2142 u32 flags
, maxcount
, size
;
2145 if (xdr_stream_decode_u32(argp
->xdr
, &flags
) < 0)
2146 return nfserr_bad_xdr
;
2148 if (flags
> SETXATTR4_REPLACE
)
2149 return nfserr_inval
;
2150 setxattr
->setxa_flags
= flags
;
2152 status
= nfsd4_decode_xattr_name(argp
, &setxattr
->setxa_name
);
2156 maxcount
= svc_max_payload(argp
->rqstp
);
2157 maxcount
= min_t(u32
, XATTR_SIZE_MAX
, maxcount
);
2159 if (xdr_stream_decode_u32(argp
->xdr
, &size
) < 0)
2160 return nfserr_bad_xdr
;
2161 if (size
> maxcount
)
2162 return nfserr_xattr2big
;
2164 setxattr
->setxa_len
= size
;
2166 struct xdr_buf payload
;
2168 if (!xdr_stream_subsegment(argp
->xdr
, &payload
, size
))
2169 return nfserr_bad_xdr
;
2170 status
= nfsd4_vbuf_from_vector(argp
, &payload
,
2171 &setxattr
->setxa_buf
, size
);
2178 nfsd4_decode_listxattrs(struct nfsd4_compoundargs
*argp
,
2179 struct nfsd4_listxattrs
*listxattrs
)
2183 if (xdr_stream_decode_u64(argp
->xdr
, &listxattrs
->lsxa_cookie
) < 0)
2184 return nfserr_bad_xdr
;
2187 * If the cookie is too large to have even one user.x attribute
2188 * plus trailing '\0' left in a maximum size buffer, it's invalid.
2190 if (listxattrs
->lsxa_cookie
>=
2191 (XATTR_LIST_MAX
/ (XATTR_USER_PREFIX_LEN
+ 2)))
2192 return nfserr_badcookie
;
2194 if (xdr_stream_decode_u32(argp
->xdr
, &maxcount
) < 0)
2195 return nfserr_bad_xdr
;
2197 /* Always need at least 2 words (length and one character) */
2198 return nfserr_inval
;
2200 maxcount
= min(maxcount
, svc_max_payload(argp
->rqstp
));
2201 listxattrs
->lsxa_maxcount
= maxcount
;
2207 nfsd4_decode_removexattr(struct nfsd4_compoundargs
*argp
,
2208 struct nfsd4_removexattr
*removexattr
)
2210 return nfsd4_decode_xattr_name(argp
, &removexattr
->rmxa_name
);
2214 nfsd4_decode_noop(struct nfsd4_compoundargs
*argp
, void *p
)
2220 nfsd4_decode_notsupp(struct nfsd4_compoundargs
*argp
, void *p
)
2222 return nfserr_notsupp
;
2225 typedef __be32(*nfsd4_dec
)(struct nfsd4_compoundargs
*argp
, void *);
2227 static const nfsd4_dec nfsd4_dec_ops
[] = {
2228 [OP_ACCESS
] = (nfsd4_dec
)nfsd4_decode_access
,
2229 [OP_CLOSE
] = (nfsd4_dec
)nfsd4_decode_close
,
2230 [OP_COMMIT
] = (nfsd4_dec
)nfsd4_decode_commit
,
2231 [OP_CREATE
] = (nfsd4_dec
)nfsd4_decode_create
,
2232 [OP_DELEGPURGE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2233 [OP_DELEGRETURN
] = (nfsd4_dec
)nfsd4_decode_delegreturn
,
2234 [OP_GETATTR
] = (nfsd4_dec
)nfsd4_decode_getattr
,
2235 [OP_GETFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2236 [OP_LINK
] = (nfsd4_dec
)nfsd4_decode_link
,
2237 [OP_LOCK
] = (nfsd4_dec
)nfsd4_decode_lock
,
2238 [OP_LOCKT
] = (nfsd4_dec
)nfsd4_decode_lockt
,
2239 [OP_LOCKU
] = (nfsd4_dec
)nfsd4_decode_locku
,
2240 [OP_LOOKUP
] = (nfsd4_dec
)nfsd4_decode_lookup
,
2241 [OP_LOOKUPP
] = (nfsd4_dec
)nfsd4_decode_noop
,
2242 [OP_NVERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
2243 [OP_OPEN
] = (nfsd4_dec
)nfsd4_decode_open
,
2244 [OP_OPENATTR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2245 [OP_OPEN_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_open_confirm
,
2246 [OP_OPEN_DOWNGRADE
] = (nfsd4_dec
)nfsd4_decode_open_downgrade
,
2247 [OP_PUTFH
] = (nfsd4_dec
)nfsd4_decode_putfh
,
2248 [OP_PUTPUBFH
] = (nfsd4_dec
)nfsd4_decode_putpubfh
,
2249 [OP_PUTROOTFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2250 [OP_READ
] = (nfsd4_dec
)nfsd4_decode_read
,
2251 [OP_READDIR
] = (nfsd4_dec
)nfsd4_decode_readdir
,
2252 [OP_READLINK
] = (nfsd4_dec
)nfsd4_decode_noop
,
2253 [OP_REMOVE
] = (nfsd4_dec
)nfsd4_decode_remove
,
2254 [OP_RENAME
] = (nfsd4_dec
)nfsd4_decode_rename
,
2255 [OP_RENEW
] = (nfsd4_dec
)nfsd4_decode_renew
,
2256 [OP_RESTOREFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2257 [OP_SAVEFH
] = (nfsd4_dec
)nfsd4_decode_noop
,
2258 [OP_SECINFO
] = (nfsd4_dec
)nfsd4_decode_secinfo
,
2259 [OP_SETATTR
] = (nfsd4_dec
)nfsd4_decode_setattr
,
2260 [OP_SETCLIENTID
] = (nfsd4_dec
)nfsd4_decode_setclientid
,
2261 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_dec
)nfsd4_decode_setclientid_confirm
,
2262 [OP_VERIFY
] = (nfsd4_dec
)nfsd4_decode_verify
,
2263 [OP_WRITE
] = (nfsd4_dec
)nfsd4_decode_write
,
2264 [OP_RELEASE_LOCKOWNER
] = (nfsd4_dec
)nfsd4_decode_release_lockowner
,
2266 /* new operations for NFSv4.1 */
2267 [OP_BACKCHANNEL_CTL
] = (nfsd4_dec
)nfsd4_decode_backchannel_ctl
,
2268 [OP_BIND_CONN_TO_SESSION
]= (nfsd4_dec
)nfsd4_decode_bind_conn_to_session
,
2269 [OP_EXCHANGE_ID
] = (nfsd4_dec
)nfsd4_decode_exchange_id
,
2270 [OP_CREATE_SESSION
] = (nfsd4_dec
)nfsd4_decode_create_session
,
2271 [OP_DESTROY_SESSION
] = (nfsd4_dec
)nfsd4_decode_destroy_session
,
2272 [OP_FREE_STATEID
] = (nfsd4_dec
)nfsd4_decode_free_stateid
,
2273 [OP_GET_DIR_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2274 #ifdef CONFIG_NFSD_PNFS
2275 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_getdeviceinfo
,
2276 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2277 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_layoutcommit
,
2278 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_layoutget
,
2279 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_layoutreturn
,
2281 [OP_GETDEVICEINFO
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2282 [OP_GETDEVICELIST
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2283 [OP_LAYOUTCOMMIT
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2284 [OP_LAYOUTGET
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2285 [OP_LAYOUTRETURN
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2287 [OP_SECINFO_NO_NAME
] = (nfsd4_dec
)nfsd4_decode_secinfo_no_name
,
2288 [OP_SEQUENCE
] = (nfsd4_dec
)nfsd4_decode_sequence
,
2289 [OP_SET_SSV
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2290 [OP_TEST_STATEID
] = (nfsd4_dec
)nfsd4_decode_test_stateid
,
2291 [OP_WANT_DELEGATION
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2292 [OP_DESTROY_CLIENTID
] = (nfsd4_dec
)nfsd4_decode_destroy_clientid
,
2293 [OP_RECLAIM_COMPLETE
] = (nfsd4_dec
)nfsd4_decode_reclaim_complete
,
2295 /* new operations for NFSv4.2 */
2296 [OP_ALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
2297 [OP_COPY
] = (nfsd4_dec
)nfsd4_decode_copy
,
2298 [OP_COPY_NOTIFY
] = (nfsd4_dec
)nfsd4_decode_copy_notify
,
2299 [OP_DEALLOCATE
] = (nfsd4_dec
)nfsd4_decode_fallocate
,
2300 [OP_IO_ADVISE
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2301 [OP_LAYOUTERROR
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2302 [OP_LAYOUTSTATS
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2303 [OP_OFFLOAD_CANCEL
] = (nfsd4_dec
)nfsd4_decode_offload_status
,
2304 [OP_OFFLOAD_STATUS
] = (nfsd4_dec
)nfsd4_decode_offload_status
,
2305 [OP_READ_PLUS
] = (nfsd4_dec
)nfsd4_decode_read
,
2306 [OP_SEEK
] = (nfsd4_dec
)nfsd4_decode_seek
,
2307 [OP_WRITE_SAME
] = (nfsd4_dec
)nfsd4_decode_notsupp
,
2308 [OP_CLONE
] = (nfsd4_dec
)nfsd4_decode_clone
,
2309 /* RFC 8276 extended atributes operations */
2310 [OP_GETXATTR
] = (nfsd4_dec
)nfsd4_decode_getxattr
,
2311 [OP_SETXATTR
] = (nfsd4_dec
)nfsd4_decode_setxattr
,
2312 [OP_LISTXATTRS
] = (nfsd4_dec
)nfsd4_decode_listxattrs
,
2313 [OP_REMOVEXATTR
] = (nfsd4_dec
)nfsd4_decode_removexattr
,
2317 nfsd4_opnum_in_range(struct nfsd4_compoundargs
*argp
, struct nfsd4_op
*op
)
2319 if (op
->opnum
< FIRST_NFS4_OP
)
2321 else if (argp
->minorversion
== 0 && op
->opnum
> LAST_NFS40_OP
)
2323 else if (argp
->minorversion
== 1 && op
->opnum
> LAST_NFS41_OP
)
2325 else if (argp
->minorversion
== 2 && op
->opnum
> LAST_NFS42_OP
)
2331 nfsd4_decode_compound(struct nfsd4_compoundargs
*argp
)
2333 struct nfsd4_op
*op
;
2334 bool cachethis
= false;
2335 int auth_slack
= argp
->rqstp
->rq_auth_slack
;
2336 int max_reply
= auth_slack
+ 8; /* opcnt, status */
2342 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->taglen
) < 0)
2344 max_reply
+= XDR_UNIT
;
2346 if (unlikely(argp
->taglen
)) {
2347 if (argp
->taglen
> NFSD4_MAX_TAGLEN
)
2349 p
= xdr_inline_decode(argp
->xdr
, argp
->taglen
);
2352 argp
->tag
= svcxdr_savemem(argp
, p
, argp
->taglen
);
2355 max_reply
+= xdr_align_size(argp
->taglen
);
2358 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->minorversion
) < 0)
2360 if (xdr_stream_decode_u32(argp
->xdr
, &argp
->opcnt
) < 0)
2364 * NFS4ERR_RESOURCE is a more helpful error than GARBAGE_ARGS
2365 * here, so we return success at the xdr level so that
2366 * nfsd4_proc can handle this is an NFS-level error.
2368 if (argp
->opcnt
> NFSD_MAX_OPS_PER_COMPOUND
)
2371 if (argp
->opcnt
> ARRAY_SIZE(argp
->iops
)) {
2372 argp
->ops
= kzalloc(argp
->opcnt
* sizeof(*argp
->ops
), GFP_KERNEL
);
2374 argp
->ops
= argp
->iops
;
2375 dprintk("nfsd: couldn't allocate room for COMPOUND\n");
2380 if (argp
->minorversion
> NFSD_SUPPORTED_MINOR_VERSION
)
2383 for (i
= 0; i
< argp
->opcnt
; i
++) {
2387 if (xdr_stream_decode_u32(argp
->xdr
, &op
->opnum
) < 0)
2389 if (nfsd4_opnum_in_range(argp
, op
)) {
2390 op
->status
= nfsd4_dec_ops
[op
->opnum
](argp
, &op
->u
);
2391 if (op
->status
!= nfs_ok
)
2392 trace_nfsd_compound_decode_err(argp
->rqstp
,
2397 op
->opnum
= OP_ILLEGAL
;
2398 op
->status
= nfserr_op_illegal
;
2400 op
->opdesc
= OPDESC(op
);
2402 * We'll try to cache the result in the DRC if any one
2403 * op in the compound wants to be cached:
2405 cachethis
|= nfsd4_cache_this_op(op
);
2407 if (op
->opnum
== OP_READ
|| op
->opnum
== OP_READ_PLUS
) {
2409 readbytes
+= nfsd4_max_reply(argp
->rqstp
, op
);
2411 max_reply
+= nfsd4_max_reply(argp
->rqstp
, op
);
2413 * OP_LOCK and OP_LOCKT may return a conflicting lock.
2414 * (Special case because it will just skip encoding this
2415 * if it runs out of xdr buffer space, and it is the only
2416 * operation that behaves this way.)
2418 if (op
->opnum
== OP_LOCK
|| op
->opnum
== OP_LOCKT
)
2419 max_reply
+= NFS4_OPAQUE_LIMIT
;
2426 /* Sessions make the DRC unnecessary: */
2427 if (argp
->minorversion
)
2429 svc_reserve(argp
->rqstp
, max_reply
+ readbytes
);
2430 argp
->rqstp
->rq_cachetype
= cachethis
? RC_REPLBUFF
: RC_NOCACHE
;
2432 if (readcount
> 1 || max_reply
> PAGE_SIZE
- auth_slack
)
2433 __clear_bit(RQ_SPLICE_OK
, &argp
->rqstp
->rq_flags
);
2438 static __be32
*encode_change(__be32
*p
, struct kstat
*stat
, struct inode
*inode
,
2439 struct svc_export
*exp
)
2441 if (exp
->ex_flags
& NFSEXP_V4ROOT
) {
2442 *p
++ = cpu_to_be32(convert_to_wallclock(exp
->cd
->flush_time
));
2445 p
= xdr_encode_hyper(p
, nfsd4_change_attribute(stat
, inode
));
2450 * ctime (in NFSv4, time_metadata) is not writeable, and the client
2451 * doesn't really care what resolution could theoretically be stored by
2454 * The client cares how close together changes can be while still
2455 * guaranteeing ctime changes. For most filesystems (which have
2456 * timestamps with nanosecond fields) that is limited by the resolution
2457 * of the time returned from current_time() (which I'm assuming to be
2460 static __be32
*encode_time_delta(__be32
*p
, struct inode
*inode
)
2462 struct timespec64 ts
;
2465 ns
= max_t(u32
, NSEC_PER_SEC
/HZ
, inode
->i_sb
->s_time_gran
);
2466 ts
= ns_to_timespec64(ns
);
2468 p
= xdr_encode_hyper(p
, ts
.tv_sec
);
2469 *p
++ = cpu_to_be32(ts
.tv_nsec
);
2474 static __be32
*encode_cinfo(__be32
*p
, struct nfsd4_change_info
*c
)
2476 *p
++ = cpu_to_be32(c
->atomic
);
2477 p
= xdr_encode_hyper(p
, c
->before_change
);
2478 p
= xdr_encode_hyper(p
, c
->after_change
);
2482 /* Encode as an array of strings the string given with components
2483 * separated @sep, escaped with esc_enter and esc_exit.
2485 static __be32
nfsd4_encode_components_esc(struct xdr_stream
*xdr
, char sep
,
2486 char *components
, char esc_enter
,
2492 int strlen
, count
=0;
2493 char *str
, *end
, *next
;
2495 dprintk("nfsd4_encode_components(%s)\n", components
);
2497 pathlen_offset
= xdr
->buf
->len
;
2498 p
= xdr_reserve_space(xdr
, 4);
2500 return nfserr_resource
;
2501 p
++; /* We will fill this in with @count later */
2503 end
= str
= components
;
2505 bool found_esc
= false;
2507 /* try to parse as esc_start, ..., esc_end, sep */
2508 if (*str
== esc_enter
) {
2509 for (; *end
&& (*end
!= esc_exit
); end
++)
2510 /* find esc_exit or end of string */;
2512 if (*end
&& (!*next
|| *next
== sep
)) {
2519 for (; *end
&& (*end
!= sep
); end
++)
2520 /* find sep or end of string */;
2524 p
= xdr_reserve_space(xdr
, strlen
+ 4);
2526 return nfserr_resource
;
2527 p
= xdr_encode_opaque(p
, str
, strlen
);
2537 pathlen
= htonl(count
);
2538 write_bytes_to_xdr_buf(xdr
->buf
, pathlen_offset
, &pathlen
, 4);
2542 /* Encode as an array of strings the string given with components
2545 static __be32
nfsd4_encode_components(struct xdr_stream
*xdr
, char sep
,
2548 return nfsd4_encode_components_esc(xdr
, sep
, components
, 0, 0);
2552 * encode a location element of a fs_locations structure
2554 static __be32
nfsd4_encode_fs_location4(struct xdr_stream
*xdr
,
2555 struct nfsd4_fs_location
*location
)
2559 status
= nfsd4_encode_components_esc(xdr
, ':', location
->hosts
,
2563 status
= nfsd4_encode_components(xdr
, '/', location
->path
);
2570 * Encode a path in RFC3530 'pathname4' format
2572 static __be32
nfsd4_encode_path(struct xdr_stream
*xdr
,
2573 const struct path
*root
,
2574 const struct path
*path
)
2576 struct path cur
= *path
;
2578 struct dentry
**components
= NULL
;
2579 unsigned int ncomponents
= 0;
2580 __be32 err
= nfserr_jukebox
;
2582 dprintk("nfsd4_encode_components(");
2585 /* First walk the path up to the nfsd root, and store the
2586 * dentries/path components in an array.
2589 if (path_equal(&cur
, root
))
2591 if (cur
.dentry
== cur
.mnt
->mnt_root
) {
2592 if (follow_up(&cur
))
2596 if ((ncomponents
& 15) == 0) {
2597 struct dentry
**new;
2598 new = krealloc(components
,
2599 sizeof(*new) * (ncomponents
+ 16),
2605 components
[ncomponents
++] = cur
.dentry
;
2606 cur
.dentry
= dget_parent(cur
.dentry
);
2608 err
= nfserr_resource
;
2609 p
= xdr_reserve_space(xdr
, 4);
2612 *p
++ = cpu_to_be32(ncomponents
);
2614 while (ncomponents
) {
2615 struct dentry
*dentry
= components
[ncomponents
- 1];
2618 spin_lock(&dentry
->d_lock
);
2619 len
= dentry
->d_name
.len
;
2620 p
= xdr_reserve_space(xdr
, len
+ 4);
2622 spin_unlock(&dentry
->d_lock
);
2625 p
= xdr_encode_opaque(p
, dentry
->d_name
.name
, len
);
2626 dprintk("/%pd", dentry
);
2627 spin_unlock(&dentry
->d_lock
);
2636 dput(components
[--ncomponents
]);
2642 static __be32
nfsd4_encode_fsloc_fsroot(struct xdr_stream
*xdr
,
2643 struct svc_rqst
*rqstp
, const struct path
*path
)
2645 struct svc_export
*exp_ps
;
2648 exp_ps
= rqst_find_fsidzero_export(rqstp
);
2650 return nfserrno(PTR_ERR(exp_ps
));
2651 res
= nfsd4_encode_path(xdr
, &exp_ps
->ex_path
, path
);
2657 * encode a fs_locations structure
2659 static __be32
nfsd4_encode_fs_locations(struct xdr_stream
*xdr
,
2660 struct svc_rqst
*rqstp
, struct svc_export
*exp
)
2665 struct nfsd4_fs_locations
*fslocs
= &exp
->ex_fslocs
;
2667 status
= nfsd4_encode_fsloc_fsroot(xdr
, rqstp
, &exp
->ex_path
);
2670 p
= xdr_reserve_space(xdr
, 4);
2672 return nfserr_resource
;
2673 *p
++ = cpu_to_be32(fslocs
->locations_count
);
2674 for (i
=0; i
<fslocs
->locations_count
; i
++) {
2675 status
= nfsd4_encode_fs_location4(xdr
, &fslocs
->locations
[i
]);
2682 static u32
nfs4_file_type(umode_t mode
)
2684 switch (mode
& S_IFMT
) {
2685 case S_IFIFO
: return NF4FIFO
;
2686 case S_IFCHR
: return NF4CHR
;
2687 case S_IFDIR
: return NF4DIR
;
2688 case S_IFBLK
: return NF4BLK
;
2689 case S_IFLNK
: return NF4LNK
;
2690 case S_IFREG
: return NF4REG
;
2691 case S_IFSOCK
: return NF4SOCK
;
2692 default: return NF4BAD
;
2696 static inline __be32
2697 nfsd4_encode_aclname(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2698 struct nfs4_ace
*ace
)
2700 if (ace
->whotype
!= NFS4_ACL_WHO_NAMED
)
2701 return nfs4_acl_write_who(xdr
, ace
->whotype
);
2702 else if (ace
->flag
& NFS4_ACE_IDENTIFIER_GROUP
)
2703 return nfsd4_encode_group(xdr
, rqstp
, ace
->who_gid
);
2705 return nfsd4_encode_user(xdr
, rqstp
, ace
->who_uid
);
2708 static inline __be32
2709 nfsd4_encode_layout_types(struct xdr_stream
*xdr
, u32 layout_types
)
2712 unsigned long i
= hweight_long(layout_types
);
2714 p
= xdr_reserve_space(xdr
, 4 + 4 * i
);
2716 return nfserr_resource
;
2718 *p
++ = cpu_to_be32(i
);
2720 for (i
= LAYOUT_NFSV4_1_FILES
; i
< LAYOUT_TYPE_MAX
; ++i
)
2721 if (layout_types
& (1 << i
))
2722 *p
++ = cpu_to_be32(i
);
2727 #define WORD0_ABSENT_FS_ATTRS (FATTR4_WORD0_FS_LOCATIONS | FATTR4_WORD0_FSID | \
2728 FATTR4_WORD0_RDATTR_ERROR)
2729 #define WORD1_ABSENT_FS_ATTRS FATTR4_WORD1_MOUNTED_ON_FILEID
2730 #define WORD2_ABSENT_FS_ATTRS 0
2732 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2733 static inline __be32
2734 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2735 void *context
, int len
)
2739 p
= xdr_reserve_space(xdr
, len
+ 4 + 4 + 4);
2741 return nfserr_resource
;
2744 * For now we use a 0 here to indicate the null translation; in
2745 * the future we may place a call to translation code here.
2747 *p
++ = cpu_to_be32(0); /* lfs */
2748 *p
++ = cpu_to_be32(0); /* pi */
2749 p
= xdr_encode_opaque(p
, context
, len
);
2753 static inline __be32
2754 nfsd4_encode_security_label(struct xdr_stream
*xdr
, struct svc_rqst
*rqstp
,
2755 void *context
, int len
)
2759 static __be32
fattr_handle_absent_fs(u32
*bmval0
, u32
*bmval1
, u32
*bmval2
, u32
*rdattr_err
)
2761 /* As per referral draft: */
2762 if (*bmval0
& ~WORD0_ABSENT_FS_ATTRS
||
2763 *bmval1
& ~WORD1_ABSENT_FS_ATTRS
) {
2764 if (*bmval0
& FATTR4_WORD0_RDATTR_ERROR
||
2765 *bmval0
& FATTR4_WORD0_FS_LOCATIONS
)
2766 *rdattr_err
= NFSERR_MOVED
;
2768 return nfserr_moved
;
2770 *bmval0
&= WORD0_ABSENT_FS_ATTRS
;
2771 *bmval1
&= WORD1_ABSENT_FS_ATTRS
;
2772 *bmval2
&= WORD2_ABSENT_FS_ATTRS
;
2777 static int get_parent_attributes(struct svc_export
*exp
, struct kstat
*stat
)
2779 struct path path
= exp
->ex_path
;
2783 while (follow_up(&path
)) {
2784 if (path
.dentry
!= path
.mnt
->mnt_root
)
2787 err
= vfs_getattr(&path
, stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2793 nfsd4_encode_bitmap(struct xdr_stream
*xdr
, u32 bmval0
, u32 bmval1
, u32 bmval2
)
2798 p
= xdr_reserve_space(xdr
, 16);
2801 *p
++ = cpu_to_be32(3);
2802 *p
++ = cpu_to_be32(bmval0
);
2803 *p
++ = cpu_to_be32(bmval1
);
2804 *p
++ = cpu_to_be32(bmval2
);
2805 } else if (bmval1
) {
2806 p
= xdr_reserve_space(xdr
, 12);
2809 *p
++ = cpu_to_be32(2);
2810 *p
++ = cpu_to_be32(bmval0
);
2811 *p
++ = cpu_to_be32(bmval1
);
2813 p
= xdr_reserve_space(xdr
, 8);
2816 *p
++ = cpu_to_be32(1);
2817 *p
++ = cpu_to_be32(bmval0
);
2822 return nfserr_resource
;
2826 * Note: @fhp can be NULL; in this case, we might have to compose the filehandle
2830 nfsd4_encode_fattr(struct xdr_stream
*xdr
, struct svc_fh
*fhp
,
2831 struct svc_export
*exp
,
2832 struct dentry
*dentry
, u32
*bmval
,
2833 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
2835 u32 bmval0
= bmval
[0];
2836 u32 bmval1
= bmval
[1];
2837 u32 bmval2
= bmval
[2];
2839 struct svc_fh
*tempfh
= NULL
;
2840 struct kstatfs statfs
;
2841 __be32
*p
, *attrlen_p
;
2842 int starting_len
= xdr
->buf
->len
;
2849 struct nfs4_acl
*acl
= NULL
;
2850 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2851 void *context
= NULL
;
2854 bool contextsupport
= false;
2855 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2856 u32 minorversion
= resp
->cstate
.minorversion
;
2857 struct path path
= {
2858 .mnt
= exp
->ex_path
.mnt
,
2861 struct nfsd_net
*nn
= net_generic(SVC_NET(rqstp
), nfsd_net_id
);
2863 BUG_ON(bmval1
& NFSD_WRITEONLY_ATTRS_WORD1
);
2864 BUG_ON(!nfsd_attrs_supported(minorversion
, bmval
));
2866 if (exp
->ex_fslocs
.migrated
) {
2867 status
= fattr_handle_absent_fs(&bmval0
, &bmval1
, &bmval2
, &rdattr_err
);
2872 err
= vfs_getattr(&path
, &stat
, STATX_BASIC_STATS
, AT_STATX_SYNC_AS_STAT
);
2875 if (!(stat
.result_mask
& STATX_BTIME
))
2876 /* underlying FS does not offer btime so we can't share it */
2877 bmval1
&= ~FATTR4_WORD1_TIME_CREATE
;
2878 if ((bmval0
& (FATTR4_WORD0_FILES_AVAIL
| FATTR4_WORD0_FILES_FREE
|
2879 FATTR4_WORD0_FILES_TOTAL
| FATTR4_WORD0_MAXNAME
)) ||
2880 (bmval1
& (FATTR4_WORD1_SPACE_AVAIL
| FATTR4_WORD1_SPACE_FREE
|
2881 FATTR4_WORD1_SPACE_TOTAL
))) {
2882 err
= vfs_statfs(&path
, &statfs
);
2886 if ((bmval0
& (FATTR4_WORD0_FILEHANDLE
| FATTR4_WORD0_FSID
)) && !fhp
) {
2887 tempfh
= kmalloc(sizeof(struct svc_fh
), GFP_KERNEL
);
2888 status
= nfserr_jukebox
;
2891 fh_init(tempfh
, NFS4_FHSIZE
);
2892 status
= fh_compose(tempfh
, exp
, dentry
, NULL
);
2897 if (bmval0
& FATTR4_WORD0_ACL
) {
2898 err
= nfsd4_get_nfs4_acl(rqstp
, dentry
, &acl
);
2899 if (err
== -EOPNOTSUPP
)
2900 bmval0
&= ~FATTR4_WORD0_ACL
;
2901 else if (err
== -EINVAL
) {
2902 status
= nfserr_attrnotsupp
;
2904 } else if (err
!= 0)
2908 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
2909 if ((bmval2
& FATTR4_WORD2_SECURITY_LABEL
) ||
2910 bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2911 if (exp
->ex_flags
& NFSEXP_SECURITY_LABEL
)
2912 err
= security_inode_getsecctx(d_inode(dentry
),
2913 &context
, &contextlen
);
2916 contextsupport
= (err
== 0);
2917 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
2918 if (err
== -EOPNOTSUPP
)
2919 bmval2
&= ~FATTR4_WORD2_SECURITY_LABEL
;
2924 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
2926 status
= nfsd4_encode_bitmap(xdr
, bmval0
, bmval1
, bmval2
);
2930 attrlen_offset
= xdr
->buf
->len
;
2931 attrlen_p
= xdr_reserve_space(xdr
, XDR_UNIT
);
2935 if (bmval0
& FATTR4_WORD0_SUPPORTED_ATTRS
) {
2938 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
2940 if (!IS_POSIXACL(dentry
->d_inode
))
2941 supp
[0] &= ~FATTR4_WORD0_ACL
;
2942 if (!contextsupport
)
2943 supp
[2] &= ~FATTR4_WORD2_SECURITY_LABEL
;
2945 p
= xdr_reserve_space(xdr
, 12);
2948 *p
++ = cpu_to_be32(2);
2949 *p
++ = cpu_to_be32(supp
[0]);
2950 *p
++ = cpu_to_be32(supp
[1]);
2952 p
= xdr_reserve_space(xdr
, 16);
2955 *p
++ = cpu_to_be32(3);
2956 *p
++ = cpu_to_be32(supp
[0]);
2957 *p
++ = cpu_to_be32(supp
[1]);
2958 *p
++ = cpu_to_be32(supp
[2]);
2961 if (bmval0
& FATTR4_WORD0_TYPE
) {
2962 p
= xdr_reserve_space(xdr
, 4);
2965 dummy
= nfs4_file_type(stat
.mode
);
2966 if (dummy
== NF4BAD
) {
2967 status
= nfserr_serverfault
;
2970 *p
++ = cpu_to_be32(dummy
);
2972 if (bmval0
& FATTR4_WORD0_FH_EXPIRE_TYPE
) {
2973 p
= xdr_reserve_space(xdr
, 4);
2976 if (exp
->ex_flags
& NFSEXP_NOSUBTREECHECK
)
2977 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
);
2979 *p
++ = cpu_to_be32(NFS4_FH_PERSISTENT
|
2980 NFS4_FH_VOL_RENAME
);
2982 if (bmval0
& FATTR4_WORD0_CHANGE
) {
2983 p
= xdr_reserve_space(xdr
, 8);
2986 p
= encode_change(p
, &stat
, d_inode(dentry
), exp
);
2988 if (bmval0
& FATTR4_WORD0_SIZE
) {
2989 p
= xdr_reserve_space(xdr
, 8);
2992 p
= xdr_encode_hyper(p
, stat
.size
);
2994 if (bmval0
& FATTR4_WORD0_LINK_SUPPORT
) {
2995 p
= xdr_reserve_space(xdr
, 4);
2998 *p
++ = cpu_to_be32(1);
3000 if (bmval0
& FATTR4_WORD0_SYMLINK_SUPPORT
) {
3001 p
= xdr_reserve_space(xdr
, 4);
3004 *p
++ = cpu_to_be32(1);
3006 if (bmval0
& FATTR4_WORD0_NAMED_ATTR
) {
3007 p
= xdr_reserve_space(xdr
, 4);
3010 *p
++ = cpu_to_be32(0);
3012 if (bmval0
& FATTR4_WORD0_FSID
) {
3013 p
= xdr_reserve_space(xdr
, 16);
3016 if (exp
->ex_fslocs
.migrated
) {
3017 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MAJOR
);
3018 p
= xdr_encode_hyper(p
, NFS4_REFERRAL_FSID_MINOR
);
3019 } else switch(fsid_source(fhp
)) {
3020 case FSIDSOURCE_FSID
:
3021 p
= xdr_encode_hyper(p
, (u64
)exp
->ex_fsid
);
3022 p
= xdr_encode_hyper(p
, (u64
)0);
3024 case FSIDSOURCE_DEV
:
3025 *p
++ = cpu_to_be32(0);
3026 *p
++ = cpu_to_be32(MAJOR(stat
.dev
));
3027 *p
++ = cpu_to_be32(0);
3028 *p
++ = cpu_to_be32(MINOR(stat
.dev
));
3030 case FSIDSOURCE_UUID
:
3031 p
= xdr_encode_opaque_fixed(p
, exp
->ex_uuid
,
3036 if (bmval0
& FATTR4_WORD0_UNIQUE_HANDLES
) {
3037 p
= xdr_reserve_space(xdr
, 4);
3040 *p
++ = cpu_to_be32(0);
3042 if (bmval0
& FATTR4_WORD0_LEASE_TIME
) {
3043 p
= xdr_reserve_space(xdr
, 4);
3046 *p
++ = cpu_to_be32(nn
->nfsd4_lease
);
3048 if (bmval0
& FATTR4_WORD0_RDATTR_ERROR
) {
3049 p
= xdr_reserve_space(xdr
, 4);
3052 *p
++ = cpu_to_be32(rdattr_err
);
3054 if (bmval0
& FATTR4_WORD0_ACL
) {
3055 struct nfs4_ace
*ace
;
3058 p
= xdr_reserve_space(xdr
, 4);
3062 *p
++ = cpu_to_be32(0);
3065 p
= xdr_reserve_space(xdr
, 4);
3068 *p
++ = cpu_to_be32(acl
->naces
);
3070 for (ace
= acl
->aces
; ace
< acl
->aces
+ acl
->naces
; ace
++) {
3071 p
= xdr_reserve_space(xdr
, 4*3);
3074 *p
++ = cpu_to_be32(ace
->type
);
3075 *p
++ = cpu_to_be32(ace
->flag
);
3076 *p
++ = cpu_to_be32(ace
->access_mask
&
3078 status
= nfsd4_encode_aclname(xdr
, rqstp
, ace
);
3084 if (bmval0
& FATTR4_WORD0_ACLSUPPORT
) {
3085 p
= xdr_reserve_space(xdr
, 4);
3088 *p
++ = cpu_to_be32(IS_POSIXACL(dentry
->d_inode
) ?
3089 ACL4_SUPPORT_ALLOW_ACL
|ACL4_SUPPORT_DENY_ACL
: 0);
3091 if (bmval0
& FATTR4_WORD0_CANSETTIME
) {
3092 p
= xdr_reserve_space(xdr
, 4);
3095 *p
++ = cpu_to_be32(1);
3097 if (bmval0
& FATTR4_WORD0_CASE_INSENSITIVE
) {
3098 p
= xdr_reserve_space(xdr
, 4);
3101 *p
++ = cpu_to_be32(0);
3103 if (bmval0
& FATTR4_WORD0_CASE_PRESERVING
) {
3104 p
= xdr_reserve_space(xdr
, 4);
3107 *p
++ = cpu_to_be32(1);
3109 if (bmval0
& FATTR4_WORD0_CHOWN_RESTRICTED
) {
3110 p
= xdr_reserve_space(xdr
, 4);
3113 *p
++ = cpu_to_be32(1);
3115 if (bmval0
& FATTR4_WORD0_FILEHANDLE
) {
3116 p
= xdr_reserve_space(xdr
, fhp
->fh_handle
.fh_size
+ 4);
3119 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_raw
,
3120 fhp
->fh_handle
.fh_size
);
3122 if (bmval0
& FATTR4_WORD0_FILEID
) {
3123 p
= xdr_reserve_space(xdr
, 8);
3126 p
= xdr_encode_hyper(p
, stat
.ino
);
3128 if (bmval0
& FATTR4_WORD0_FILES_AVAIL
) {
3129 p
= xdr_reserve_space(xdr
, 8);
3132 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
3134 if (bmval0
& FATTR4_WORD0_FILES_FREE
) {
3135 p
= xdr_reserve_space(xdr
, 8);
3138 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_ffree
);
3140 if (bmval0
& FATTR4_WORD0_FILES_TOTAL
) {
3141 p
= xdr_reserve_space(xdr
, 8);
3144 p
= xdr_encode_hyper(p
, (u64
) statfs
.f_files
);
3146 if (bmval0
& FATTR4_WORD0_FS_LOCATIONS
) {
3147 status
= nfsd4_encode_fs_locations(xdr
, rqstp
, exp
);
3151 if (bmval0
& FATTR4_WORD0_HOMOGENEOUS
) {
3152 p
= xdr_reserve_space(xdr
, 4);
3155 *p
++ = cpu_to_be32(1);
3157 if (bmval0
& FATTR4_WORD0_MAXFILESIZE
) {
3158 p
= xdr_reserve_space(xdr
, 8);
3161 p
= xdr_encode_hyper(p
, exp
->ex_path
.mnt
->mnt_sb
->s_maxbytes
);
3163 if (bmval0
& FATTR4_WORD0_MAXLINK
) {
3164 p
= xdr_reserve_space(xdr
, 4);
3167 *p
++ = cpu_to_be32(255);
3169 if (bmval0
& FATTR4_WORD0_MAXNAME
) {
3170 p
= xdr_reserve_space(xdr
, 4);
3173 *p
++ = cpu_to_be32(statfs
.f_namelen
);
3175 if (bmval0
& FATTR4_WORD0_MAXREAD
) {
3176 p
= xdr_reserve_space(xdr
, 8);
3179 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
3181 if (bmval0
& FATTR4_WORD0_MAXWRITE
) {
3182 p
= xdr_reserve_space(xdr
, 8);
3185 p
= xdr_encode_hyper(p
, (u64
) svc_max_payload(rqstp
));
3187 if (bmval1
& FATTR4_WORD1_MODE
) {
3188 p
= xdr_reserve_space(xdr
, 4);
3191 *p
++ = cpu_to_be32(stat
.mode
& S_IALLUGO
);
3193 if (bmval1
& FATTR4_WORD1_NO_TRUNC
) {
3194 p
= xdr_reserve_space(xdr
, 4);
3197 *p
++ = cpu_to_be32(1);
3199 if (bmval1
& FATTR4_WORD1_NUMLINKS
) {
3200 p
= xdr_reserve_space(xdr
, 4);
3203 *p
++ = cpu_to_be32(stat
.nlink
);
3205 if (bmval1
& FATTR4_WORD1_OWNER
) {
3206 status
= nfsd4_encode_user(xdr
, rqstp
, stat
.uid
);
3210 if (bmval1
& FATTR4_WORD1_OWNER_GROUP
) {
3211 status
= nfsd4_encode_group(xdr
, rqstp
, stat
.gid
);
3215 if (bmval1
& FATTR4_WORD1_RAWDEV
) {
3216 p
= xdr_reserve_space(xdr
, 8);
3219 *p
++ = cpu_to_be32((u32
) MAJOR(stat
.rdev
));
3220 *p
++ = cpu_to_be32((u32
) MINOR(stat
.rdev
));
3222 if (bmval1
& FATTR4_WORD1_SPACE_AVAIL
) {
3223 p
= xdr_reserve_space(xdr
, 8);
3226 dummy64
= (u64
)statfs
.f_bavail
* (u64
)statfs
.f_bsize
;
3227 p
= xdr_encode_hyper(p
, dummy64
);
3229 if (bmval1
& FATTR4_WORD1_SPACE_FREE
) {
3230 p
= xdr_reserve_space(xdr
, 8);
3233 dummy64
= (u64
)statfs
.f_bfree
* (u64
)statfs
.f_bsize
;
3234 p
= xdr_encode_hyper(p
, dummy64
);
3236 if (bmval1
& FATTR4_WORD1_SPACE_TOTAL
) {
3237 p
= xdr_reserve_space(xdr
, 8);
3240 dummy64
= (u64
)statfs
.f_blocks
* (u64
)statfs
.f_bsize
;
3241 p
= xdr_encode_hyper(p
, dummy64
);
3243 if (bmval1
& FATTR4_WORD1_SPACE_USED
) {
3244 p
= xdr_reserve_space(xdr
, 8);
3247 dummy64
= (u64
)stat
.blocks
<< 9;
3248 p
= xdr_encode_hyper(p
, dummy64
);
3250 if (bmval1
& FATTR4_WORD1_TIME_ACCESS
) {
3251 p
= xdr_reserve_space(xdr
, 12);
3254 p
= xdr_encode_hyper(p
, (s64
)stat
.atime
.tv_sec
);
3255 *p
++ = cpu_to_be32(stat
.atime
.tv_nsec
);
3257 if (bmval1
& FATTR4_WORD1_TIME_DELTA
) {
3258 p
= xdr_reserve_space(xdr
, 12);
3261 p
= encode_time_delta(p
, d_inode(dentry
));
3263 if (bmval1
& FATTR4_WORD1_TIME_METADATA
) {
3264 p
= xdr_reserve_space(xdr
, 12);
3267 p
= xdr_encode_hyper(p
, (s64
)stat
.ctime
.tv_sec
);
3268 *p
++ = cpu_to_be32(stat
.ctime
.tv_nsec
);
3270 if (bmval1
& FATTR4_WORD1_TIME_MODIFY
) {
3271 p
= xdr_reserve_space(xdr
, 12);
3274 p
= xdr_encode_hyper(p
, (s64
)stat
.mtime
.tv_sec
);
3275 *p
++ = cpu_to_be32(stat
.mtime
.tv_nsec
);
3277 if (bmval1
& FATTR4_WORD1_TIME_CREATE
) {
3278 p
= xdr_reserve_space(xdr
, 12);
3281 p
= xdr_encode_hyper(p
, (s64
)stat
.btime
.tv_sec
);
3282 *p
++ = cpu_to_be32(stat
.btime
.tv_nsec
);
3284 if (bmval1
& FATTR4_WORD1_MOUNTED_ON_FILEID
) {
3285 struct kstat parent_stat
;
3288 p
= xdr_reserve_space(xdr
, 8);
3292 * Get parent's attributes if not ignoring crossmount
3293 * and this is the root of a cross-mounted filesystem.
3295 if (ignore_crossmnt
== 0 &&
3296 dentry
== exp
->ex_path
.mnt
->mnt_root
) {
3297 err
= get_parent_attributes(exp
, &parent_stat
);
3300 ino
= parent_stat
.ino
;
3302 p
= xdr_encode_hyper(p
, ino
);
3304 #ifdef CONFIG_NFSD_PNFS
3305 if (bmval1
& FATTR4_WORD1_FS_LAYOUT_TYPES
) {
3306 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
3311 if (bmval2
& FATTR4_WORD2_LAYOUT_TYPES
) {
3312 status
= nfsd4_encode_layout_types(xdr
, exp
->ex_layout_types
);
3317 if (bmval2
& FATTR4_WORD2_LAYOUT_BLKSIZE
) {
3318 p
= xdr_reserve_space(xdr
, 4);
3321 *p
++ = cpu_to_be32(stat
.blksize
);
3323 #endif /* CONFIG_NFSD_PNFS */
3324 if (bmval2
& FATTR4_WORD2_SUPPATTR_EXCLCREAT
) {
3327 memcpy(supp
, nfsd_suppattrs
[minorversion
], sizeof(supp
));
3328 supp
[0] &= NFSD_SUPPATTR_EXCLCREAT_WORD0
;
3329 supp
[1] &= NFSD_SUPPATTR_EXCLCREAT_WORD1
;
3330 supp
[2] &= NFSD_SUPPATTR_EXCLCREAT_WORD2
;
3332 status
= nfsd4_encode_bitmap(xdr
, supp
[0], supp
[1], supp
[2]);
3337 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3338 if (bmval2
& FATTR4_WORD2_SECURITY_LABEL
) {
3339 status
= nfsd4_encode_security_label(xdr
, rqstp
, context
,
3346 if (bmval2
& FATTR4_WORD2_XATTR_SUPPORT
) {
3347 p
= xdr_reserve_space(xdr
, 4);
3350 err
= xattr_supported_namespace(d_inode(dentry
),
3352 *p
++ = cpu_to_be32(err
== 0);
3355 *attrlen_p
= cpu_to_be32(xdr
->buf
->len
- attrlen_offset
- XDR_UNIT
);
3359 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
3361 security_release_secctx(context
, contextlen
);
3362 #endif /* CONFIG_NFSD_V4_SECURITY_LABEL */
3369 xdr_truncate_encode(xdr
, starting_len
);
3372 status
= nfserrno(err
);
3375 status
= nfserr_resource
;
3379 static void svcxdr_init_encode_from_buffer(struct xdr_stream
*xdr
,
3380 struct xdr_buf
*buf
, __be32
*p
, int bytes
)
3382 xdr
->scratch
.iov_len
= 0;
3383 memset(buf
, 0, sizeof(struct xdr_buf
));
3384 buf
->head
[0].iov_base
= p
;
3385 buf
->head
[0].iov_len
= 0;
3388 xdr
->iov
= buf
->head
;
3390 xdr
->end
= (void *)p
+ bytes
;
3391 buf
->buflen
= bytes
;
3394 __be32
nfsd4_encode_fattr_to_buf(__be32
**p
, int words
,
3395 struct svc_fh
*fhp
, struct svc_export
*exp
,
3396 struct dentry
*dentry
, u32
*bmval
,
3397 struct svc_rqst
*rqstp
, int ignore_crossmnt
)
3399 struct xdr_buf dummy
;
3400 struct xdr_stream xdr
;
3403 svcxdr_init_encode_from_buffer(&xdr
, &dummy
, *p
, words
<< 2);
3404 ret
= nfsd4_encode_fattr(&xdr
, fhp
, exp
, dentry
, bmval
, rqstp
,
3410 static inline int attributes_need_mount(u32
*bmval
)
3412 if (bmval
[0] & ~(FATTR4_WORD0_RDATTR_ERROR
| FATTR4_WORD0_LEASE_TIME
))
3414 if (bmval
[1] & ~FATTR4_WORD1_MOUNTED_ON_FILEID
)
3420 nfsd4_encode_dirent_fattr(struct xdr_stream
*xdr
, struct nfsd4_readdir
*cd
,
3421 const char *name
, int namlen
)
3423 struct svc_export
*exp
= cd
->rd_fhp
->fh_export
;
3424 struct dentry
*dentry
;
3426 int ignore_crossmnt
= 0;
3428 dentry
= lookup_positive_unlocked(name
, cd
->rd_fhp
->fh_dentry
, namlen
);
3430 return nfserrno(PTR_ERR(dentry
));
3434 * In the case of a mountpoint, the client may be asking for
3435 * attributes that are only properties of the underlying filesystem
3436 * as opposed to the cross-mounted file system. In such a case,
3437 * we will not follow the cross mount and will fill the attribtutes
3438 * directly from the mountpoint dentry.
3440 if (nfsd_mountpoint(dentry
, exp
)) {
3443 if (!(exp
->ex_flags
& NFSEXP_V4ROOT
)
3444 && !attributes_need_mount(cd
->rd_bmval
)) {
3445 ignore_crossmnt
= 1;
3449 * Why the heck aren't we just using nfsd_lookup??
3450 * Different "."/".." handling? Something else?
3451 * At least, add a comment here to explain....
3453 err
= nfsd_cross_mnt(cd
->rd_rqstp
, &dentry
, &exp
);
3455 nfserr
= nfserrno(err
);
3458 nfserr
= check_nfsd_access(exp
, cd
->rd_rqstp
);
3464 nfserr
= nfsd4_encode_fattr(xdr
, NULL
, exp
, dentry
, cd
->rd_bmval
,
3465 cd
->rd_rqstp
, ignore_crossmnt
);
3473 nfsd4_encode_rdattr_error(struct xdr_stream
*xdr
, __be32 nfserr
)
3477 p
= xdr_reserve_space(xdr
, 20);
3481 *p
++ = htonl(FATTR4_WORD0_RDATTR_ERROR
); /* bmval0 */
3482 *p
++ = htonl(0); /* bmval1 */
3484 *p
++ = htonl(4); /* attribute length */
3485 *p
++ = nfserr
; /* no htonl */
3490 nfsd4_encode_dirent(void *ccdv
, const char *name
, int namlen
,
3491 loff_t offset
, u64 ino
, unsigned int d_type
)
3493 struct readdir_cd
*ccd
= ccdv
;
3494 struct nfsd4_readdir
*cd
= container_of(ccd
, struct nfsd4_readdir
, common
);
3495 struct xdr_stream
*xdr
= cd
->xdr
;
3496 int start_offset
= xdr
->buf
->len
;
3498 u32 name_and_cookie
;
3500 __be32 nfserr
= nfserr_toosmall
;
3504 /* In nfsv4, "." and ".." never make it onto the wire.. */
3505 if (name
&& isdotent(name
, namlen
)) {
3506 cd
->common
.err
= nfs_ok
;
3510 if (cd
->cookie_offset
) {
3511 wire_offset
= cpu_to_be64(offset
);
3512 write_bytes_to_xdr_buf(xdr
->buf
, cd
->cookie_offset
,
3516 p
= xdr_reserve_space(xdr
, 4);
3519 *p
++ = xdr_one
; /* mark entry present */
3520 cookie_offset
= xdr
->buf
->len
;
3521 p
= xdr_reserve_space(xdr
, 3*4 + namlen
);
3524 p
= xdr_encode_hyper(p
, OFFSET_MAX
); /* offset of next entry */
3525 p
= xdr_encode_array(p
, name
, namlen
); /* name length & name */
3527 nfserr
= nfsd4_encode_dirent_fattr(xdr
, cd
, name
, namlen
);
3531 case nfserr_resource
:
3532 nfserr
= nfserr_toosmall
;
3535 xdr_truncate_encode(xdr
, start_offset
);
3539 * If the client requested the RDATTR_ERROR attribute,
3540 * we stuff the error code into this attribute
3541 * and continue. If this attribute was not requested,
3542 * then in accordance with the spec, we fail the
3543 * entire READDIR operation(!)
3545 if (!(cd
->rd_bmval
[0] & FATTR4_WORD0_RDATTR_ERROR
))
3547 p
= nfsd4_encode_rdattr_error(xdr
, nfserr
);
3549 nfserr
= nfserr_toosmall
;
3553 nfserr
= nfserr_toosmall
;
3554 entry_bytes
= xdr
->buf
->len
- start_offset
;
3555 if (entry_bytes
> cd
->rd_maxcount
)
3557 cd
->rd_maxcount
-= entry_bytes
;
3559 * RFC 3530 14.2.24 describes rd_dircount as only a "hint", and
3560 * notes that it could be zero. If it is zero, then the server
3561 * should enforce only the rd_maxcount value.
3563 if (cd
->rd_dircount
) {
3564 name_and_cookie
= 4 + 4 * XDR_QUADLEN(namlen
) + 8;
3565 if (name_and_cookie
> cd
->rd_dircount
&& cd
->cookie_offset
)
3567 cd
->rd_dircount
-= min(cd
->rd_dircount
, name_and_cookie
);
3568 if (!cd
->rd_dircount
)
3569 cd
->rd_maxcount
= 0;
3572 cd
->cookie_offset
= cookie_offset
;
3574 cd
->common
.err
= nfs_ok
;
3577 xdr_truncate_encode(xdr
, start_offset
);
3578 cd
->common
.err
= nfserr
;
3583 nfsd4_encode_stateid(struct xdr_stream
*xdr
, stateid_t
*sid
)
3587 p
= xdr_reserve_space(xdr
, sizeof(stateid_t
));
3589 return nfserr_resource
;
3590 *p
++ = cpu_to_be32(sid
->si_generation
);
3591 p
= xdr_encode_opaque_fixed(p
, &sid
->si_opaque
,
3592 sizeof(stateid_opaque_t
));
3597 nfsd4_encode_access(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_access
*access
)
3599 struct xdr_stream
*xdr
= resp
->xdr
;
3602 p
= xdr_reserve_space(xdr
, 8);
3604 return nfserr_resource
;
3605 *p
++ = cpu_to_be32(access
->ac_supported
);
3606 *p
++ = cpu_to_be32(access
->ac_resp_access
);
3610 static __be32
nfsd4_encode_bind_conn_to_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_bind_conn_to_session
*bcts
)
3612 struct xdr_stream
*xdr
= resp
->xdr
;
3615 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 8);
3617 return nfserr_resource
;
3618 p
= xdr_encode_opaque_fixed(p
, bcts
->sessionid
.data
,
3619 NFS4_MAX_SESSIONID_LEN
);
3620 *p
++ = cpu_to_be32(bcts
->dir
);
3621 /* Upshifting from TCP to RDMA is not supported */
3622 *p
++ = cpu_to_be32(0);
3627 nfsd4_encode_close(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_close
*close
)
3629 struct xdr_stream
*xdr
= resp
->xdr
;
3631 return nfsd4_encode_stateid(xdr
, &close
->cl_stateid
);
3636 nfsd4_encode_commit(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_commit
*commit
)
3638 struct xdr_stream
*xdr
= resp
->xdr
;
3641 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
3643 return nfserr_resource
;
3644 p
= xdr_encode_opaque_fixed(p
, commit
->co_verf
.data
,
3645 NFS4_VERIFIER_SIZE
);
3650 nfsd4_encode_create(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_create
*create
)
3652 struct xdr_stream
*xdr
= resp
->xdr
;
3655 p
= xdr_reserve_space(xdr
, 20);
3657 return nfserr_resource
;
3658 encode_cinfo(p
, &create
->cr_cinfo
);
3659 return nfsd4_encode_bitmap(xdr
, create
->cr_bmval
[0],
3660 create
->cr_bmval
[1], create
->cr_bmval
[2]);
3664 nfsd4_encode_getattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_getattr
*getattr
)
3666 struct svc_fh
*fhp
= getattr
->ga_fhp
;
3667 struct xdr_stream
*xdr
= resp
->xdr
;
3669 return nfsd4_encode_fattr(xdr
, fhp
, fhp
->fh_export
, fhp
->fh_dentry
,
3670 getattr
->ga_bmval
, resp
->rqstp
, 0);
3674 nfsd4_encode_getfh(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct svc_fh
**fhpp
)
3676 struct xdr_stream
*xdr
= resp
->xdr
;
3677 struct svc_fh
*fhp
= *fhpp
;
3681 len
= fhp
->fh_handle
.fh_size
;
3682 p
= xdr_reserve_space(xdr
, len
+ 4);
3684 return nfserr_resource
;
3685 p
= xdr_encode_opaque(p
, &fhp
->fh_handle
.fh_raw
, len
);
3690 * Including all fields other than the name, a LOCK4denied structure requires
3691 * 8(clientid) + 4(namelen) + 8(offset) + 8(length) + 4(type) = 32 bytes.
3694 nfsd4_encode_lock_denied(struct xdr_stream
*xdr
, struct nfsd4_lock_denied
*ld
)
3696 struct xdr_netobj
*conf
= &ld
->ld_owner
;
3700 p
= xdr_reserve_space(xdr
, 32 + XDR_LEN(conf
->len
));
3703 * Don't fail to return the result just because we can't
3704 * return the conflicting open:
3712 return nfserr_resource
;
3714 p
= xdr_encode_hyper(p
, ld
->ld_start
);
3715 p
= xdr_encode_hyper(p
, ld
->ld_length
);
3716 *p
++ = cpu_to_be32(ld
->ld_type
);
3718 p
= xdr_encode_opaque_fixed(p
, &ld
->ld_clientid
, 8);
3719 p
= xdr_encode_opaque(p
, conf
->data
, conf
->len
);
3721 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */
3722 p
= xdr_encode_hyper(p
, (u64
)0); /* clientid */
3723 *p
++ = cpu_to_be32(0); /* length of owner name */
3725 return nfserr_denied
;
3729 nfsd4_encode_lock(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lock
*lock
)
3731 struct xdr_stream
*xdr
= resp
->xdr
;
3734 nfserr
= nfsd4_encode_stateid(xdr
, &lock
->lk_resp_stateid
);
3735 else if (nfserr
== nfserr_denied
)
3736 nfserr
= nfsd4_encode_lock_denied(xdr
, &lock
->lk_denied
);
3742 nfsd4_encode_lockt(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_lockt
*lockt
)
3744 struct xdr_stream
*xdr
= resp
->xdr
;
3746 if (nfserr
== nfserr_denied
)
3747 nfsd4_encode_lock_denied(xdr
, &lockt
->lt_denied
);
3752 nfsd4_encode_locku(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_locku
*locku
)
3754 struct xdr_stream
*xdr
= resp
->xdr
;
3756 return nfsd4_encode_stateid(xdr
, &locku
->lu_stateid
);
3761 nfsd4_encode_link(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_link
*link
)
3763 struct xdr_stream
*xdr
= resp
->xdr
;
3766 p
= xdr_reserve_space(xdr
, 20);
3768 return nfserr_resource
;
3769 p
= encode_cinfo(p
, &link
->li_cinfo
);
3775 nfsd4_encode_open(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open
*open
)
3777 struct xdr_stream
*xdr
= resp
->xdr
;
3780 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_stateid
);
3783 p
= xdr_reserve_space(xdr
, 24);
3785 return nfserr_resource
;
3786 p
= encode_cinfo(p
, &open
->op_cinfo
);
3787 *p
++ = cpu_to_be32(open
->op_rflags
);
3789 nfserr
= nfsd4_encode_bitmap(xdr
, open
->op_bmval
[0], open
->op_bmval
[1],
3794 p
= xdr_reserve_space(xdr
, 4);
3796 return nfserr_resource
;
3798 *p
++ = cpu_to_be32(open
->op_delegate_type
);
3799 switch (open
->op_delegate_type
) {
3800 case NFS4_OPEN_DELEGATE_NONE
:
3802 case NFS4_OPEN_DELEGATE_READ
:
3803 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3806 p
= xdr_reserve_space(xdr
, 20);
3808 return nfserr_resource
;
3809 *p
++ = cpu_to_be32(open
->op_recall
);
3812 * TODO: ACE's in delegations
3814 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3815 *p
++ = cpu_to_be32(0);
3816 *p
++ = cpu_to_be32(0);
3817 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3819 case NFS4_OPEN_DELEGATE_WRITE
:
3820 nfserr
= nfsd4_encode_stateid(xdr
, &open
->op_delegate_stateid
);
3823 p
= xdr_reserve_space(xdr
, 32);
3825 return nfserr_resource
;
3826 *p
++ = cpu_to_be32(0);
3829 * TODO: space_limit's in delegations
3831 *p
++ = cpu_to_be32(NFS4_LIMIT_SIZE
);
3832 *p
++ = cpu_to_be32(~(u32
)0);
3833 *p
++ = cpu_to_be32(~(u32
)0);
3836 * TODO: ACE's in delegations
3838 *p
++ = cpu_to_be32(NFS4_ACE_ACCESS_ALLOWED_ACE_TYPE
);
3839 *p
++ = cpu_to_be32(0);
3840 *p
++ = cpu_to_be32(0);
3841 *p
++ = cpu_to_be32(0); /* XXX: is NULL principal ok? */
3843 case NFS4_OPEN_DELEGATE_NONE_EXT
: /* 4.1 */
3844 switch (open
->op_why_no_deleg
) {
3845 case WND4_CONTENTION
:
3847 p
= xdr_reserve_space(xdr
, 8);
3849 return nfserr_resource
;
3850 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3851 /* deleg signaling not supported yet: */
3852 *p
++ = cpu_to_be32(0);
3855 p
= xdr_reserve_space(xdr
, 4);
3857 return nfserr_resource
;
3858 *p
++ = cpu_to_be32(open
->op_why_no_deleg
);
3864 /* XXX save filehandle here */
3869 nfsd4_encode_open_confirm(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_confirm
*oc
)
3871 struct xdr_stream
*xdr
= resp
->xdr
;
3873 return nfsd4_encode_stateid(xdr
, &oc
->oc_resp_stateid
);
3877 nfsd4_encode_open_downgrade(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_open_downgrade
*od
)
3879 struct xdr_stream
*xdr
= resp
->xdr
;
3881 return nfsd4_encode_stateid(xdr
, &od
->od_stateid
);
3884 static __be32
nfsd4_encode_splice_read(
3885 struct nfsd4_compoundres
*resp
,
3886 struct nfsd4_read
*read
,
3887 struct file
*file
, unsigned long maxcount
)
3889 struct xdr_stream
*xdr
= resp
->xdr
;
3890 struct xdr_buf
*buf
= xdr
->buf
;
3891 int status
, space_left
;
3894 /* Make sure there will be room for padding if needed */
3895 if (xdr
->end
- xdr
->p
< 1)
3896 return nfserr_resource
;
3898 nfserr
= nfsd_splice_read(read
->rd_rqstp
, read
->rd_fhp
,
3899 file
, read
->rd_offset
, &maxcount
,
3901 read
->rd_length
= maxcount
;
3904 status
= svc_encode_result_payload(read
->rd_rqstp
,
3905 buf
->head
[0].iov_len
, maxcount
);
3907 nfserr
= nfserrno(status
);
3911 buf
->page_len
= maxcount
;
3912 buf
->len
+= maxcount
;
3913 xdr
->page_ptr
+= (buf
->page_base
+ maxcount
+ PAGE_SIZE
- 1)
3916 /* Use rest of head for padding and remaining ops: */
3917 buf
->tail
[0].iov_base
= xdr
->p
;
3918 buf
->tail
[0].iov_len
= 0;
3919 xdr
->iov
= buf
->tail
;
3921 int pad
= 4 - (maxcount
&3);
3925 buf
->tail
[0].iov_base
+= maxcount
&3;
3926 buf
->tail
[0].iov_len
= pad
;
3930 space_left
= min_t(int, (void *)xdr
->end
- (void *)xdr
->p
,
3931 buf
->buflen
- buf
->len
);
3932 buf
->buflen
= buf
->len
+ space_left
;
3933 xdr
->end
= (__be32
*)((void *)xdr
->end
+ space_left
);
3939 * nfsd_splice_actor may have already messed with the
3940 * page length; reset it so as not to confuse
3941 * xdr_truncate_encode in our caller.
3947 static __be32
nfsd4_encode_readv(struct nfsd4_compoundres
*resp
,
3948 struct nfsd4_read
*read
,
3949 struct file
*file
, unsigned long maxcount
)
3951 struct xdr_stream
*xdr
= resp
->xdr
;
3952 unsigned int starting_len
= xdr
->buf
->len
;
3953 __be32 zero
= xdr_zero
;
3956 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, maxcount
);
3957 if (read
->rd_vlen
< 0)
3958 return nfserr_resource
;
3960 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
3961 resp
->rqstp
->rq_vec
, read
->rd_vlen
, &maxcount
,
3963 read
->rd_length
= maxcount
;
3966 if (svc_encode_result_payload(resp
->rqstp
, starting_len
, maxcount
))
3968 xdr_truncate_encode(xdr
, starting_len
+ xdr_align_size(maxcount
));
3970 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ maxcount
, &zero
,
3971 xdr_pad_size(maxcount
));
3976 nfsd4_encode_read(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
3977 struct nfsd4_read
*read
)
3979 bool splice_ok
= test_bit(RQ_SPLICE_OK
, &resp
->rqstp
->rq_flags
);
3980 unsigned long maxcount
;
3981 struct xdr_stream
*xdr
= resp
->xdr
;
3983 int starting_len
= xdr
->buf
->len
;
3988 file
= read
->rd_nf
->nf_file
;
3990 p
= xdr_reserve_space(xdr
, 8); /* eof flag and byte count */
3992 WARN_ON_ONCE(splice_ok
);
3993 return nfserr_resource
;
3995 if (resp
->xdr
->buf
->page_len
&& splice_ok
) {
3997 return nfserr_resource
;
3999 xdr_commit_encode(xdr
);
4001 maxcount
= min_t(unsigned long, read
->rd_length
,
4002 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4004 if (file
->f_op
->splice_read
&& splice_ok
)
4005 nfserr
= nfsd4_encode_splice_read(resp
, read
, file
, maxcount
);
4007 nfserr
= nfsd4_encode_readv(resp
, read
, file
, maxcount
);
4009 xdr_truncate_encode(xdr
, starting_len
);
4013 p
= xdr_encode_bool(p
, read
->rd_eof
);
4014 *p
= cpu_to_be32(read
->rd_length
);
4019 nfsd4_encode_readlink(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readlink
*readlink
)
4021 __be32
*p
, *maxcount_p
, zero
= xdr_zero
;
4022 struct xdr_stream
*xdr
= resp
->xdr
;
4023 int length_offset
= xdr
->buf
->len
;
4024 int maxcount
, status
;
4026 maxcount_p
= xdr_reserve_space(xdr
, XDR_UNIT
);
4028 return nfserr_resource
;
4029 maxcount
= PAGE_SIZE
;
4031 p
= xdr_reserve_space(xdr
, maxcount
);
4033 return nfserr_resource
;
4035 * XXX: By default, vfs_readlink() will truncate symlinks if they
4036 * would overflow the buffer. Is this kosher in NFSv4? If not, one
4037 * easy fix is: if vfs_readlink() precisely fills the buffer, assume
4038 * that truncation occurred, and return NFS4ERR_RESOURCE.
4040 nfserr
= nfsd_readlink(readlink
->rl_rqstp
, readlink
->rl_fhp
,
4041 (char *)p
, &maxcount
);
4042 if (nfserr
== nfserr_isdir
)
4043 nfserr
= nfserr_inval
;
4046 status
= svc_encode_result_payload(readlink
->rl_rqstp
, length_offset
,
4049 nfserr
= nfserrno(status
);
4052 *maxcount_p
= cpu_to_be32(maxcount
);
4053 xdr_truncate_encode(xdr
, length_offset
+ 4 + xdr_align_size(maxcount
));
4054 write_bytes_to_xdr_buf(xdr
->buf
, length_offset
+ 4 + maxcount
, &zero
,
4055 xdr_pad_size(maxcount
));
4059 xdr_truncate_encode(xdr
, length_offset
);
4064 nfsd4_encode_readdir(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_readdir
*readdir
)
4070 struct xdr_stream
*xdr
= resp
->xdr
;
4071 int starting_len
= xdr
->buf
->len
;
4074 p
= xdr_reserve_space(xdr
, NFS4_VERIFIER_SIZE
);
4076 return nfserr_resource
;
4078 /* XXX: Following NFSv3, we ignore the READDIR verifier for now. */
4079 *p
++ = cpu_to_be32(0);
4080 *p
++ = cpu_to_be32(0);
4081 xdr
->buf
->head
[0].iov_len
= (char *)xdr
->p
-
4082 (char *)xdr
->buf
->head
[0].iov_base
;
4085 * Number of bytes left for directory entries allowing for the
4086 * final 8 bytes of the readdir and a following failed op:
4088 bytes_left
= xdr
->buf
->buflen
- xdr
->buf
->len
4089 - COMPOUND_ERR_SLACK_SPACE
- 8;
4090 if (bytes_left
< 0) {
4091 nfserr
= nfserr_resource
;
4094 maxcount
= svc_max_payload(resp
->rqstp
);
4095 maxcount
= min_t(u32
, readdir
->rd_maxcount
, maxcount
);
4097 * Note the rfc defines rd_maxcount as the size of the
4098 * READDIR4resok structure, which includes the verifier above
4099 * and the 8 bytes encoded at the end of this function:
4101 if (maxcount
< 16) {
4102 nfserr
= nfserr_toosmall
;
4105 maxcount
= min_t(int, maxcount
-16, bytes_left
);
4107 /* RFC 3530 14.2.24 allows us to ignore dircount when it's 0: */
4108 if (!readdir
->rd_dircount
)
4109 readdir
->rd_dircount
= svc_max_payload(resp
->rqstp
);
4112 readdir
->rd_maxcount
= maxcount
;
4113 readdir
->common
.err
= 0;
4114 readdir
->cookie_offset
= 0;
4116 offset
= readdir
->rd_cookie
;
4117 nfserr
= nfsd_readdir(readdir
->rd_rqstp
, readdir
->rd_fhp
,
4119 &readdir
->common
, nfsd4_encode_dirent
);
4120 if (nfserr
== nfs_ok
&&
4121 readdir
->common
.err
== nfserr_toosmall
&&
4122 xdr
->buf
->len
== starting_len
+ 8) {
4123 /* nothing encoded; which limit did we hit?: */
4124 if (maxcount
- 16 < bytes_left
)
4125 /* It was the fault of rd_maxcount: */
4126 nfserr
= nfserr_toosmall
;
4128 /* We ran out of buffer space: */
4129 nfserr
= nfserr_resource
;
4134 if (readdir
->cookie_offset
) {
4135 wire_offset
= cpu_to_be64(offset
);
4136 write_bytes_to_xdr_buf(xdr
->buf
, readdir
->cookie_offset
,
4140 p
= xdr_reserve_space(xdr
, 8);
4145 *p
++ = 0; /* no more entries */
4146 *p
++ = htonl(readdir
->common
.err
== nfserr_eof
);
4150 xdr_truncate_encode(xdr
, starting_len
);
4155 nfsd4_encode_remove(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_remove
*remove
)
4157 struct xdr_stream
*xdr
= resp
->xdr
;
4160 p
= xdr_reserve_space(xdr
, 20);
4162 return nfserr_resource
;
4163 p
= encode_cinfo(p
, &remove
->rm_cinfo
);
4168 nfsd4_encode_rename(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_rename
*rename
)
4170 struct xdr_stream
*xdr
= resp
->xdr
;
4173 p
= xdr_reserve_space(xdr
, 40);
4175 return nfserr_resource
;
4176 p
= encode_cinfo(p
, &rename
->rn_sinfo
);
4177 p
= encode_cinfo(p
, &rename
->rn_tinfo
);
4182 nfsd4_do_encode_secinfo(struct xdr_stream
*xdr
, struct svc_export
*exp
)
4184 u32 i
, nflavs
, supported
;
4185 struct exp_flavor_info
*flavs
;
4186 struct exp_flavor_info def_flavs
[2];
4187 __be32
*p
, *flavorsp
;
4188 static bool report
= true;
4190 if (exp
->ex_nflavors
) {
4191 flavs
= exp
->ex_flavors
;
4192 nflavs
= exp
->ex_nflavors
;
4193 } else { /* Handling of some defaults in absence of real secinfo: */
4195 if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_UNIX
) {
4197 flavs
[0].pseudoflavor
= RPC_AUTH_UNIX
;
4198 flavs
[1].pseudoflavor
= RPC_AUTH_NULL
;
4199 } else if (exp
->ex_client
->flavour
->flavour
== RPC_AUTH_GSS
) {
4201 flavs
[0].pseudoflavor
4202 = svcauth_gss_flavor(exp
->ex_client
);
4205 flavs
[0].pseudoflavor
4206 = exp
->ex_client
->flavour
->flavour
;
4211 p
= xdr_reserve_space(xdr
, 4);
4213 return nfserr_resource
;
4214 flavorsp
= p
++; /* to be backfilled later */
4216 for (i
= 0; i
< nflavs
; i
++) {
4217 rpc_authflavor_t pf
= flavs
[i
].pseudoflavor
;
4218 struct rpcsec_gss_info info
;
4220 if (rpcauth_get_gssinfo(pf
, &info
) == 0) {
4222 p
= xdr_reserve_space(xdr
, 4 + 4 +
4223 XDR_LEN(info
.oid
.len
) + 4 + 4);
4225 return nfserr_resource
;
4226 *p
++ = cpu_to_be32(RPC_AUTH_GSS
);
4227 p
= xdr_encode_opaque(p
, info
.oid
.data
, info
.oid
.len
);
4228 *p
++ = cpu_to_be32(info
.qop
);
4229 *p
++ = cpu_to_be32(info
.service
);
4230 } else if (pf
< RPC_AUTH_MAXFLAVOR
) {
4232 p
= xdr_reserve_space(xdr
, 4);
4234 return nfserr_resource
;
4235 *p
++ = cpu_to_be32(pf
);
4238 pr_warn("NFS: SECINFO: security flavor %u "
4239 "is not supported\n", pf
);
4243 if (nflavs
!= supported
)
4245 *flavorsp
= htonl(supported
);
4250 nfsd4_encode_secinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4251 struct nfsd4_secinfo
*secinfo
)
4253 struct xdr_stream
*xdr
= resp
->xdr
;
4255 return nfsd4_do_encode_secinfo(xdr
, secinfo
->si_exp
);
4259 nfsd4_encode_secinfo_no_name(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4260 struct nfsd4_secinfo_no_name
*secinfo
)
4262 struct xdr_stream
*xdr
= resp
->xdr
;
4264 return nfsd4_do_encode_secinfo(xdr
, secinfo
->sin_exp
);
4268 * The SETATTR encode routine is special -- it always encodes a bitmap,
4269 * regardless of the error status.
4272 nfsd4_encode_setattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setattr
*setattr
)
4274 struct xdr_stream
*xdr
= resp
->xdr
;
4277 p
= xdr_reserve_space(xdr
, 16);
4279 return nfserr_resource
;
4281 *p
++ = cpu_to_be32(3);
4282 *p
++ = cpu_to_be32(0);
4283 *p
++ = cpu_to_be32(0);
4284 *p
++ = cpu_to_be32(0);
4287 *p
++ = cpu_to_be32(3);
4288 *p
++ = cpu_to_be32(setattr
->sa_bmval
[0]);
4289 *p
++ = cpu_to_be32(setattr
->sa_bmval
[1]);
4290 *p
++ = cpu_to_be32(setattr
->sa_bmval
[2]);
4296 nfsd4_encode_setclientid(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_setclientid
*scd
)
4298 struct xdr_stream
*xdr
= resp
->xdr
;
4302 p
= xdr_reserve_space(xdr
, 8 + NFS4_VERIFIER_SIZE
);
4304 return nfserr_resource
;
4305 p
= xdr_encode_opaque_fixed(p
, &scd
->se_clientid
, 8);
4306 p
= xdr_encode_opaque_fixed(p
, &scd
->se_confirm
,
4307 NFS4_VERIFIER_SIZE
);
4309 else if (nfserr
== nfserr_clid_inuse
) {
4310 p
= xdr_reserve_space(xdr
, 8);
4312 return nfserr_resource
;
4313 *p
++ = cpu_to_be32(0);
4314 *p
++ = cpu_to_be32(0);
4320 nfsd4_encode_write(struct nfsd4_compoundres
*resp
, __be32 nfserr
, struct nfsd4_write
*write
)
4322 struct xdr_stream
*xdr
= resp
->xdr
;
4325 p
= xdr_reserve_space(xdr
, 16);
4327 return nfserr_resource
;
4328 *p
++ = cpu_to_be32(write
->wr_bytes_written
);
4329 *p
++ = cpu_to_be32(write
->wr_how_written
);
4330 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4331 NFS4_VERIFIER_SIZE
);
4336 nfsd4_encode_exchange_id(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4337 struct nfsd4_exchange_id
*exid
)
4339 struct xdr_stream
*xdr
= resp
->xdr
;
4344 int server_scope_sz
;
4345 uint64_t minor_id
= 0;
4346 struct nfsd_net
*nn
= net_generic(SVC_NET(resp
->rqstp
), nfsd_net_id
);
4348 major_id
= nn
->nfsd_name
;
4349 major_id_sz
= strlen(nn
->nfsd_name
);
4350 server_scope
= nn
->nfsd_name
;
4351 server_scope_sz
= strlen(nn
->nfsd_name
);
4353 p
= xdr_reserve_space(xdr
,
4354 8 /* eir_clientid */ +
4355 4 /* eir_sequenceid */ +
4359 return nfserr_resource
;
4361 p
= xdr_encode_opaque_fixed(p
, &exid
->clientid
, 8);
4362 *p
++ = cpu_to_be32(exid
->seqid
);
4363 *p
++ = cpu_to_be32(exid
->flags
);
4365 *p
++ = cpu_to_be32(exid
->spa_how
);
4367 switch (exid
->spa_how
) {
4371 /* spo_must_enforce bitmap: */
4372 nfserr
= nfsd4_encode_bitmap(xdr
,
4373 exid
->spo_must_enforce
[0],
4374 exid
->spo_must_enforce
[1],
4375 exid
->spo_must_enforce
[2]);
4378 /* spo_must_allow bitmap: */
4379 nfserr
= nfsd4_encode_bitmap(xdr
,
4380 exid
->spo_must_allow
[0],
4381 exid
->spo_must_allow
[1],
4382 exid
->spo_must_allow
[2]);
4390 p
= xdr_reserve_space(xdr
,
4391 8 /* so_minor_id */ +
4392 4 /* so_major_id.len */ +
4393 (XDR_QUADLEN(major_id_sz
) * 4) +
4394 4 /* eir_server_scope.len */ +
4395 (XDR_QUADLEN(server_scope_sz
) * 4) +
4396 4 /* eir_server_impl_id.count (0) */);
4398 return nfserr_resource
;
4400 /* The server_owner struct */
4401 p
= xdr_encode_hyper(p
, minor_id
); /* Minor id */
4403 p
= xdr_encode_opaque(p
, major_id
, major_id_sz
);
4406 p
= xdr_encode_opaque(p
, server_scope
, server_scope_sz
);
4408 /* Implementation id */
4409 *p
++ = cpu_to_be32(0); /* zero length nfs_impl_id4 array */
4414 nfsd4_encode_create_session(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4415 struct nfsd4_create_session
*sess
)
4417 struct xdr_stream
*xdr
= resp
->xdr
;
4420 p
= xdr_reserve_space(xdr
, 24);
4422 return nfserr_resource
;
4423 p
= xdr_encode_opaque_fixed(p
, sess
->sessionid
.data
,
4424 NFS4_MAX_SESSIONID_LEN
);
4425 *p
++ = cpu_to_be32(sess
->seqid
);
4426 *p
++ = cpu_to_be32(sess
->flags
);
4428 p
= xdr_reserve_space(xdr
, 28);
4430 return nfserr_resource
;
4431 *p
++ = cpu_to_be32(0); /* headerpadsz */
4432 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreq_sz
);
4433 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_sz
);
4434 *p
++ = cpu_to_be32(sess
->fore_channel
.maxresp_cached
);
4435 *p
++ = cpu_to_be32(sess
->fore_channel
.maxops
);
4436 *p
++ = cpu_to_be32(sess
->fore_channel
.maxreqs
);
4437 *p
++ = cpu_to_be32(sess
->fore_channel
.nr_rdma_attrs
);
4439 if (sess
->fore_channel
.nr_rdma_attrs
) {
4440 p
= xdr_reserve_space(xdr
, 4);
4442 return nfserr_resource
;
4443 *p
++ = cpu_to_be32(sess
->fore_channel
.rdma_attrs
);
4446 p
= xdr_reserve_space(xdr
, 28);
4448 return nfserr_resource
;
4449 *p
++ = cpu_to_be32(0); /* headerpadsz */
4450 *p
++ = cpu_to_be32(sess
->back_channel
.maxreq_sz
);
4451 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_sz
);
4452 *p
++ = cpu_to_be32(sess
->back_channel
.maxresp_cached
);
4453 *p
++ = cpu_to_be32(sess
->back_channel
.maxops
);
4454 *p
++ = cpu_to_be32(sess
->back_channel
.maxreqs
);
4455 *p
++ = cpu_to_be32(sess
->back_channel
.nr_rdma_attrs
);
4457 if (sess
->back_channel
.nr_rdma_attrs
) {
4458 p
= xdr_reserve_space(xdr
, 4);
4460 return nfserr_resource
;
4461 *p
++ = cpu_to_be32(sess
->back_channel
.rdma_attrs
);
4467 nfsd4_encode_sequence(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4468 struct nfsd4_sequence
*seq
)
4470 struct xdr_stream
*xdr
= resp
->xdr
;
4473 p
= xdr_reserve_space(xdr
, NFS4_MAX_SESSIONID_LEN
+ 20);
4475 return nfserr_resource
;
4476 p
= xdr_encode_opaque_fixed(p
, seq
->sessionid
.data
,
4477 NFS4_MAX_SESSIONID_LEN
);
4478 *p
++ = cpu_to_be32(seq
->seqid
);
4479 *p
++ = cpu_to_be32(seq
->slotid
);
4480 /* Note slotid's are numbered from zero: */
4481 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_highest_slotid */
4482 *p
++ = cpu_to_be32(seq
->maxslots
- 1); /* sr_target_highest_slotid */
4483 *p
++ = cpu_to_be32(seq
->status_flags
);
4485 resp
->cstate
.data_offset
= xdr
->buf
->len
; /* DRC cache data pointer */
4490 nfsd4_encode_test_stateid(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4491 struct nfsd4_test_stateid
*test_stateid
)
4493 struct xdr_stream
*xdr
= resp
->xdr
;
4494 struct nfsd4_test_stateid_id
*stateid
, *next
;
4497 p
= xdr_reserve_space(xdr
, 4 + (4 * test_stateid
->ts_num_ids
));
4499 return nfserr_resource
;
4500 *p
++ = htonl(test_stateid
->ts_num_ids
);
4502 list_for_each_entry_safe(stateid
, next
, &test_stateid
->ts_stateid_list
, ts_id_list
) {
4503 *p
++ = stateid
->ts_id_status
;
4509 #ifdef CONFIG_NFSD_PNFS
4511 nfsd4_encode_getdeviceinfo(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4512 struct nfsd4_getdeviceinfo
*gdev
)
4514 struct xdr_stream
*xdr
= resp
->xdr
;
4515 const struct nfsd4_layout_ops
*ops
;
4516 u32 starting_len
= xdr
->buf
->len
, needed_len
;
4519 p
= xdr_reserve_space(xdr
, 4);
4521 return nfserr_resource
;
4523 *p
++ = cpu_to_be32(gdev
->gd_layout_type
);
4525 /* If maxcount is 0 then just update notifications */
4526 if (gdev
->gd_maxcount
!= 0) {
4527 ops
= nfsd4_layout_ops
[gdev
->gd_layout_type
];
4528 nfserr
= ops
->encode_getdeviceinfo(xdr
, gdev
);
4531 * We don't bother to burden the layout drivers with
4532 * enforcing gd_maxcount, just tell the client to
4533 * come back with a bigger buffer if it's not enough.
4535 if (xdr
->buf
->len
+ 4 > gdev
->gd_maxcount
)
4541 if (gdev
->gd_notify_types
) {
4542 p
= xdr_reserve_space(xdr
, 4 + 4);
4544 return nfserr_resource
;
4545 *p
++ = cpu_to_be32(1); /* bitmap length */
4546 *p
++ = cpu_to_be32(gdev
->gd_notify_types
);
4548 p
= xdr_reserve_space(xdr
, 4);
4550 return nfserr_resource
;
4556 dprintk("%s: maxcount too small\n", __func__
);
4557 needed_len
= xdr
->buf
->len
+ 4 /* notifications */;
4558 xdr_truncate_encode(xdr
, starting_len
);
4559 p
= xdr_reserve_space(xdr
, 4);
4561 return nfserr_resource
;
4562 *p
++ = cpu_to_be32(needed_len
);
4563 return nfserr_toosmall
;
4567 nfsd4_encode_layoutget(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4568 struct nfsd4_layoutget
*lgp
)
4570 struct xdr_stream
*xdr
= resp
->xdr
;
4571 const struct nfsd4_layout_ops
*ops
;
4574 p
= xdr_reserve_space(xdr
, 36 + sizeof(stateid_opaque_t
));
4576 return nfserr_resource
;
4578 *p
++ = cpu_to_be32(1); /* we always set return-on-close */
4579 *p
++ = cpu_to_be32(lgp
->lg_sid
.si_generation
);
4580 p
= xdr_encode_opaque_fixed(p
, &lgp
->lg_sid
.si_opaque
,
4581 sizeof(stateid_opaque_t
));
4583 *p
++ = cpu_to_be32(1); /* we always return a single layout */
4584 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.offset
);
4585 p
= xdr_encode_hyper(p
, lgp
->lg_seg
.length
);
4586 *p
++ = cpu_to_be32(lgp
->lg_seg
.iomode
);
4587 *p
++ = cpu_to_be32(lgp
->lg_layout_type
);
4589 ops
= nfsd4_layout_ops
[lgp
->lg_layout_type
];
4590 return ops
->encode_layoutget(xdr
, lgp
);
4594 nfsd4_encode_layoutcommit(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4595 struct nfsd4_layoutcommit
*lcp
)
4597 struct xdr_stream
*xdr
= resp
->xdr
;
4600 p
= xdr_reserve_space(xdr
, 4);
4602 return nfserr_resource
;
4603 *p
++ = cpu_to_be32(lcp
->lc_size_chg
);
4604 if (lcp
->lc_size_chg
) {
4605 p
= xdr_reserve_space(xdr
, 8);
4607 return nfserr_resource
;
4608 p
= xdr_encode_hyper(p
, lcp
->lc_newsize
);
4615 nfsd4_encode_layoutreturn(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4616 struct nfsd4_layoutreturn
*lrp
)
4618 struct xdr_stream
*xdr
= resp
->xdr
;
4621 p
= xdr_reserve_space(xdr
, 4);
4623 return nfserr_resource
;
4624 *p
++ = cpu_to_be32(lrp
->lrs_present
);
4625 if (lrp
->lrs_present
)
4626 return nfsd4_encode_stateid(xdr
, &lrp
->lr_sid
);
4629 #endif /* CONFIG_NFSD_PNFS */
4632 nfsd42_encode_write_res(struct nfsd4_compoundres
*resp
,
4633 struct nfsd42_write_res
*write
, bool sync
)
4636 p
= xdr_reserve_space(resp
->xdr
, 4);
4638 return nfserr_resource
;
4641 *p
++ = cpu_to_be32(0);
4644 *p
++ = cpu_to_be32(1);
4645 nfserr
= nfsd4_encode_stateid(resp
->xdr
, &write
->cb_stateid
);
4649 p
= xdr_reserve_space(resp
->xdr
, 8 + 4 + NFS4_VERIFIER_SIZE
);
4651 return nfserr_resource
;
4653 p
= xdr_encode_hyper(p
, write
->wr_bytes_written
);
4654 *p
++ = cpu_to_be32(write
->wr_stable_how
);
4655 p
= xdr_encode_opaque_fixed(p
, write
->wr_verifier
.data
,
4656 NFS4_VERIFIER_SIZE
);
4661 nfsd42_encode_nl4_server(struct nfsd4_compoundres
*resp
, struct nl4_server
*ns
)
4663 struct xdr_stream
*xdr
= resp
->xdr
;
4664 struct nfs42_netaddr
*addr
;
4667 p
= xdr_reserve_space(xdr
, 4);
4668 *p
++ = cpu_to_be32(ns
->nl4_type
);
4670 switch (ns
->nl4_type
) {
4672 addr
= &ns
->u
.nl4_addr
;
4674 /* netid_len, netid, uaddr_len, uaddr (port included
4675 * in RPCBIND_MAXUADDRLEN)
4677 p
= xdr_reserve_space(xdr
,
4679 (XDR_QUADLEN(addr
->netid_len
) * 4) +
4681 (XDR_QUADLEN(addr
->addr_len
) * 4));
4683 return nfserr_resource
;
4685 *p
++ = cpu_to_be32(addr
->netid_len
);
4686 p
= xdr_encode_opaque_fixed(p
, addr
->netid
,
4688 *p
++ = cpu_to_be32(addr
->addr_len
);
4689 p
= xdr_encode_opaque_fixed(p
, addr
->addr
,
4693 WARN_ON_ONCE(ns
->nl4_type
!= NL4_NETADDR
);
4694 return nfserr_inval
;
4701 nfsd4_encode_copy(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4702 struct nfsd4_copy
*copy
)
4706 nfserr
= nfsd42_encode_write_res(resp
, ©
->cp_res
,
4707 nfsd4_copy_is_sync(copy
));
4711 p
= xdr_reserve_space(resp
->xdr
, 4 + 4);
4712 *p
++ = xdr_one
; /* cr_consecutive */
4713 *p
= nfsd4_copy_is_sync(copy
) ? xdr_one
: xdr_zero
;
4718 nfsd4_encode_offload_status(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4719 struct nfsd4_offload_status
*os
)
4721 struct xdr_stream
*xdr
= resp
->xdr
;
4724 p
= xdr_reserve_space(xdr
, 8 + 4);
4726 return nfserr_resource
;
4727 p
= xdr_encode_hyper(p
, os
->count
);
4728 *p
++ = cpu_to_be32(0);
4733 nfsd4_encode_read_plus_data(struct nfsd4_compoundres
*resp
,
4734 struct nfsd4_read
*read
,
4735 unsigned long *maxcount
, u32
*eof
,
4738 struct xdr_stream
*xdr
= resp
->xdr
;
4739 struct file
*file
= read
->rd_nf
->nf_file
;
4740 int starting_len
= xdr
->buf
->len
;
4746 hole_pos
= pos
? *pos
: vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4747 if (hole_pos
> read
->rd_offset
)
4748 *maxcount
= min_t(unsigned long, *maxcount
, hole_pos
- read
->rd_offset
);
4749 *maxcount
= min_t(unsigned long, *maxcount
, (xdr
->buf
->buflen
- xdr
->buf
->len
));
4751 /* Content type, offset, byte count */
4752 p
= xdr_reserve_space(xdr
, 4 + 8 + 4);
4754 return nfserr_resource
;
4756 read
->rd_vlen
= xdr_reserve_space_vec(xdr
, resp
->rqstp
->rq_vec
, *maxcount
);
4757 if (read
->rd_vlen
< 0)
4758 return nfserr_resource
;
4760 nfserr
= nfsd_readv(resp
->rqstp
, read
->rd_fhp
, file
, read
->rd_offset
,
4761 resp
->rqstp
->rq_vec
, read
->rd_vlen
, maxcount
, eof
);
4764 xdr_truncate_encode(xdr
, starting_len
+ 16 + xdr_align_size(*maxcount
));
4766 tmp
= htonl(NFS4_CONTENT_DATA
);
4767 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4768 tmp64
= cpu_to_be64(read
->rd_offset
);
4769 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp64
, 8);
4770 tmp
= htonl(*maxcount
);
4771 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 12, &tmp
, 4);
4774 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 16 + *maxcount
, &tmp
,
4775 xdr_pad_size(*maxcount
));
4780 nfsd4_encode_read_plus_hole(struct nfsd4_compoundres
*resp
,
4781 struct nfsd4_read
*read
,
4782 unsigned long *maxcount
, u32
*eof
)
4784 struct file
*file
= read
->rd_nf
->nf_file
;
4785 loff_t data_pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_DATA
);
4786 loff_t f_size
= i_size_read(file_inode(file
));
4787 unsigned long count
;
4790 if (data_pos
== -ENXIO
)
4792 else if (data_pos
<= read
->rd_offset
|| (data_pos
< f_size
&& data_pos
% PAGE_SIZE
))
4793 return nfsd4_encode_read_plus_data(resp
, read
, maxcount
, eof
, &f_size
);
4794 count
= data_pos
- read
->rd_offset
;
4796 /* Content type, offset, byte count */
4797 p
= xdr_reserve_space(resp
->xdr
, 4 + 8 + 8);
4799 return nfserr_resource
;
4801 *p
++ = htonl(NFS4_CONTENT_HOLE
);
4802 p
= xdr_encode_hyper(p
, read
->rd_offset
);
4803 p
= xdr_encode_hyper(p
, count
);
4805 *eof
= (read
->rd_offset
+ count
) >= f_size
;
4806 *maxcount
= min_t(unsigned long, count
, *maxcount
);
4811 nfsd4_encode_read_plus(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4812 struct nfsd4_read
*read
)
4814 unsigned long maxcount
, count
;
4815 struct xdr_stream
*xdr
= resp
->xdr
;
4817 int starting_len
= xdr
->buf
->len
;
4818 int last_segment
= xdr
->buf
->len
;
4827 file
= read
->rd_nf
->nf_file
;
4829 /* eof flag, segment count */
4830 p
= xdr_reserve_space(xdr
, 4 + 4);
4832 return nfserr_resource
;
4833 xdr_commit_encode(xdr
);
4835 maxcount
= min_t(unsigned long, read
->rd_length
,
4836 (xdr
->buf
->buflen
- xdr
->buf
->len
));
4839 eof
= read
->rd_offset
>= i_size_read(file_inode(file
));
4843 pos
= vfs_llseek(file
, read
->rd_offset
, SEEK_HOLE
);
4844 is_data
= pos
> read
->rd_offset
;
4846 while (count
> 0 && !eof
) {
4849 nfserr
= nfsd4_encode_read_plus_data(resp
, read
, &maxcount
, &eof
,
4850 segments
== 0 ? &pos
: NULL
);
4852 nfserr
= nfsd4_encode_read_plus_hole(resp
, read
, &maxcount
, &eof
);
4856 read
->rd_offset
+= maxcount
;
4858 last_segment
= xdr
->buf
->len
;
4863 if (nfserr
&& segments
== 0)
4864 xdr_truncate_encode(xdr
, starting_len
);
4867 xdr_truncate_encode(xdr
, last_segment
);
4872 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
, &tmp
, 4);
4873 tmp
= htonl(segments
);
4874 write_bytes_to_xdr_buf(xdr
->buf
, starting_len
+ 4, &tmp
, 4);
4881 nfsd4_encode_copy_notify(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4882 struct nfsd4_copy_notify
*cn
)
4884 struct xdr_stream
*xdr
= resp
->xdr
;
4891 p
= xdr_reserve_space(xdr
, 12);
4893 return nfserr_resource
;
4895 /* cnr_lease_time */
4896 p
= xdr_encode_hyper(p
, cn
->cpn_sec
);
4897 *p
++ = cpu_to_be32(cn
->cpn_nsec
);
4900 nfserr
= nfsd4_encode_stateid(xdr
, &cn
->cpn_cnr_stateid
);
4904 /* cnr_src.nl_nsvr */
4905 p
= xdr_reserve_space(xdr
, 4);
4907 return nfserr_resource
;
4909 *p
++ = cpu_to_be32(1);
4911 nfserr
= nfsd42_encode_nl4_server(resp
, cn
->cpn_src
);
4916 nfsd4_encode_seek(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4917 struct nfsd4_seek
*seek
)
4921 p
= xdr_reserve_space(resp
->xdr
, 4 + 8);
4922 *p
++ = cpu_to_be32(seek
->seek_eof
);
4923 p
= xdr_encode_hyper(p
, seek
->seek_pos
);
4929 nfsd4_encode_noop(struct nfsd4_compoundres
*resp
, __be32 nfserr
, void *p
)
4935 * Encode kmalloc-ed buffer in to XDR stream.
4938 nfsd4_vbuf_to_stream(struct xdr_stream
*xdr
, char *buf
, u32 buflen
)
4943 cplen
= min_t(unsigned long, buflen
,
4944 ((void *)xdr
->end
- (void *)xdr
->p
));
4945 p
= xdr_reserve_space(xdr
, cplen
);
4947 return nfserr_resource
;
4949 memcpy(p
, buf
, cplen
);
4954 cplen
= min_t(u32
, buflen
, PAGE_SIZE
);
4955 p
= xdr_reserve_space(xdr
, cplen
);
4957 return nfserr_resource
;
4959 memcpy(p
, buf
, cplen
);
4961 if (cplen
< PAGE_SIZE
) {
4963 * We're done, with a length that wasn't page
4964 * aligned, so possibly not word aligned. Pad
4965 * any trailing bytes with 0.
4967 xdr_encode_opaque_fixed(p
, NULL
, cplen
);
4971 buflen
-= PAGE_SIZE
;
4979 nfsd4_encode_getxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
4980 struct nfsd4_getxattr
*getxattr
)
4982 struct xdr_stream
*xdr
= resp
->xdr
;
4985 p
= xdr_reserve_space(xdr
, 4);
4987 return nfserr_resource
;
4989 *p
= cpu_to_be32(getxattr
->getxa_len
);
4991 if (getxattr
->getxa_len
== 0)
4994 err
= nfsd4_vbuf_to_stream(xdr
, getxattr
->getxa_buf
,
4995 getxattr
->getxa_len
);
4997 kvfree(getxattr
->getxa_buf
);
5003 nfsd4_encode_setxattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5004 struct nfsd4_setxattr
*setxattr
)
5006 struct xdr_stream
*xdr
= resp
->xdr
;
5009 p
= xdr_reserve_space(xdr
, 20);
5011 return nfserr_resource
;
5013 encode_cinfo(p
, &setxattr
->setxa_cinfo
);
5019 * See if there are cookie values that can be rejected outright.
5022 nfsd4_listxattr_validate_cookie(struct nfsd4_listxattrs
*listxattrs
,
5025 u64 cookie
= listxattrs
->lsxa_cookie
;
5028 * If the cookie is larger than the maximum number we can fit
5029 * in either the buffer we just got back from vfs_listxattr, or,
5030 * XDR-encoded, in the return buffer, it's invalid.
5032 if (cookie
> (listxattrs
->lsxa_len
) / (XATTR_USER_PREFIX_LEN
+ 2))
5033 return nfserr_badcookie
;
5035 if (cookie
> (listxattrs
->lsxa_maxcount
/
5036 (XDR_QUADLEN(XATTR_USER_PREFIX_LEN
+ 2) + 4)))
5037 return nfserr_badcookie
;
5039 *offsetp
= (u32
)cookie
;
5044 nfsd4_encode_listxattrs(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5045 struct nfsd4_listxattrs
*listxattrs
)
5047 struct xdr_stream
*xdr
= resp
->xdr
;
5048 u32 cookie_offset
, count_offset
, eof
;
5049 u32 left
, xdrleft
, slen
, count
;
5059 status
= nfsd4_listxattr_validate_cookie(listxattrs
, &offset
);
5064 * Reserve space for the cookie and the name array count. Record
5065 * the offsets to save them later.
5067 cookie_offset
= xdr
->buf
->len
;
5068 count_offset
= cookie_offset
+ 8;
5069 p
= xdr_reserve_space(xdr
, 12);
5071 status
= nfserr_resource
;
5076 left
= listxattrs
->lsxa_len
;
5077 sp
= listxattrs
->lsxa_buf
;
5080 xdrleft
= listxattrs
->lsxa_maxcount
;
5082 while (left
> 0 && xdrleft
> 0) {
5086 * Check if this is a "user." attribute, skip it if not.
5088 if (strncmp(sp
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
))
5091 slen
-= XATTR_USER_PREFIX_LEN
;
5092 xdrlen
= 4 + ((slen
+ 3) & ~3);
5093 if (xdrlen
> xdrleft
) {
5096 * Can't even fit the first attribute name.
5098 status
= nfserr_toosmall
;
5105 left
-= XATTR_USER_PREFIX_LEN
;
5106 sp
+= XATTR_USER_PREFIX_LEN
;
5107 if (nuser
++ < offset
)
5111 p
= xdr_reserve_space(xdr
, xdrlen
);
5113 status
= nfserr_resource
;
5117 xdr_encode_opaque(p
, sp
, slen
);
5127 * If there were user attributes to copy, but we didn't copy
5128 * any, the offset was too large (e.g. the cookie was invalid).
5130 if (nuser
> 0 && count
== 0) {
5131 status
= nfserr_badcookie
;
5136 p
= xdr_reserve_space(xdr
, 4);
5138 status
= nfserr_resource
;
5141 *p
= cpu_to_be32(eof
);
5143 cookie
= offset
+ count
;
5145 write_bytes_to_xdr_buf(xdr
->buf
, cookie_offset
, &cookie
, 8);
5146 tmp
= cpu_to_be32(count
);
5147 write_bytes_to_xdr_buf(xdr
->buf
, count_offset
, &tmp
, 4);
5149 if (listxattrs
->lsxa_len
)
5150 kvfree(listxattrs
->lsxa_buf
);
5155 nfsd4_encode_removexattr(struct nfsd4_compoundres
*resp
, __be32 nfserr
,
5156 struct nfsd4_removexattr
*removexattr
)
5158 struct xdr_stream
*xdr
= resp
->xdr
;
5161 p
= xdr_reserve_space(xdr
, 20);
5163 return nfserr_resource
;
5165 p
= encode_cinfo(p
, &removexattr
->rmxa_cinfo
);
5169 typedef __be32(* nfsd4_enc
)(struct nfsd4_compoundres
*, __be32
, void *);
5172 * Note: nfsd4_enc_ops vector is shared for v4.0 and v4.1
5173 * since we don't need to filter out obsolete ops as this is
5174 * done in the decoding phase.
5176 static const nfsd4_enc nfsd4_enc_ops
[] = {
5177 [OP_ACCESS
] = (nfsd4_enc
)nfsd4_encode_access
,
5178 [OP_CLOSE
] = (nfsd4_enc
)nfsd4_encode_close
,
5179 [OP_COMMIT
] = (nfsd4_enc
)nfsd4_encode_commit
,
5180 [OP_CREATE
] = (nfsd4_enc
)nfsd4_encode_create
,
5181 [OP_DELEGPURGE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5182 [OP_DELEGRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5183 [OP_GETATTR
] = (nfsd4_enc
)nfsd4_encode_getattr
,
5184 [OP_GETFH
] = (nfsd4_enc
)nfsd4_encode_getfh
,
5185 [OP_LINK
] = (nfsd4_enc
)nfsd4_encode_link
,
5186 [OP_LOCK
] = (nfsd4_enc
)nfsd4_encode_lock
,
5187 [OP_LOCKT
] = (nfsd4_enc
)nfsd4_encode_lockt
,
5188 [OP_LOCKU
] = (nfsd4_enc
)nfsd4_encode_locku
,
5189 [OP_LOOKUP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5190 [OP_LOOKUPP
] = (nfsd4_enc
)nfsd4_encode_noop
,
5191 [OP_NVERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5192 [OP_OPEN
] = (nfsd4_enc
)nfsd4_encode_open
,
5193 [OP_OPENATTR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5194 [OP_OPEN_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_open_confirm
,
5195 [OP_OPEN_DOWNGRADE
] = (nfsd4_enc
)nfsd4_encode_open_downgrade
,
5196 [OP_PUTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5197 [OP_PUTPUBFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5198 [OP_PUTROOTFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5199 [OP_READ
] = (nfsd4_enc
)nfsd4_encode_read
,
5200 [OP_READDIR
] = (nfsd4_enc
)nfsd4_encode_readdir
,
5201 [OP_READLINK
] = (nfsd4_enc
)nfsd4_encode_readlink
,
5202 [OP_REMOVE
] = (nfsd4_enc
)nfsd4_encode_remove
,
5203 [OP_RENAME
] = (nfsd4_enc
)nfsd4_encode_rename
,
5204 [OP_RENEW
] = (nfsd4_enc
)nfsd4_encode_noop
,
5205 [OP_RESTOREFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5206 [OP_SAVEFH
] = (nfsd4_enc
)nfsd4_encode_noop
,
5207 [OP_SECINFO
] = (nfsd4_enc
)nfsd4_encode_secinfo
,
5208 [OP_SETATTR
] = (nfsd4_enc
)nfsd4_encode_setattr
,
5209 [OP_SETCLIENTID
] = (nfsd4_enc
)nfsd4_encode_setclientid
,
5210 [OP_SETCLIENTID_CONFIRM
] = (nfsd4_enc
)nfsd4_encode_noop
,
5211 [OP_VERIFY
] = (nfsd4_enc
)nfsd4_encode_noop
,
5212 [OP_WRITE
] = (nfsd4_enc
)nfsd4_encode_write
,
5213 [OP_RELEASE_LOCKOWNER
] = (nfsd4_enc
)nfsd4_encode_noop
,
5215 /* NFSv4.1 operations */
5216 [OP_BACKCHANNEL_CTL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5217 [OP_BIND_CONN_TO_SESSION
] = (nfsd4_enc
)nfsd4_encode_bind_conn_to_session
,
5218 [OP_EXCHANGE_ID
] = (nfsd4_enc
)nfsd4_encode_exchange_id
,
5219 [OP_CREATE_SESSION
] = (nfsd4_enc
)nfsd4_encode_create_session
,
5220 [OP_DESTROY_SESSION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5221 [OP_FREE_STATEID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5222 [OP_GET_DIR_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5223 #ifdef CONFIG_NFSD_PNFS
5224 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_getdeviceinfo
,
5225 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5226 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_layoutcommit
,
5227 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_layoutget
,
5228 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_layoutreturn
,
5230 [OP_GETDEVICEINFO
] = (nfsd4_enc
)nfsd4_encode_noop
,
5231 [OP_GETDEVICELIST
] = (nfsd4_enc
)nfsd4_encode_noop
,
5232 [OP_LAYOUTCOMMIT
] = (nfsd4_enc
)nfsd4_encode_noop
,
5233 [OP_LAYOUTGET
] = (nfsd4_enc
)nfsd4_encode_noop
,
5234 [OP_LAYOUTRETURN
] = (nfsd4_enc
)nfsd4_encode_noop
,
5236 [OP_SECINFO_NO_NAME
] = (nfsd4_enc
)nfsd4_encode_secinfo_no_name
,
5237 [OP_SEQUENCE
] = (nfsd4_enc
)nfsd4_encode_sequence
,
5238 [OP_SET_SSV
] = (nfsd4_enc
)nfsd4_encode_noop
,
5239 [OP_TEST_STATEID
] = (nfsd4_enc
)nfsd4_encode_test_stateid
,
5240 [OP_WANT_DELEGATION
] = (nfsd4_enc
)nfsd4_encode_noop
,
5241 [OP_DESTROY_CLIENTID
] = (nfsd4_enc
)nfsd4_encode_noop
,
5242 [OP_RECLAIM_COMPLETE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5244 /* NFSv4.2 operations */
5245 [OP_ALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5246 [OP_COPY
] = (nfsd4_enc
)nfsd4_encode_copy
,
5247 [OP_COPY_NOTIFY
] = (nfsd4_enc
)nfsd4_encode_copy_notify
,
5248 [OP_DEALLOCATE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5249 [OP_IO_ADVISE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5250 [OP_LAYOUTERROR
] = (nfsd4_enc
)nfsd4_encode_noop
,
5251 [OP_LAYOUTSTATS
] = (nfsd4_enc
)nfsd4_encode_noop
,
5252 [OP_OFFLOAD_CANCEL
] = (nfsd4_enc
)nfsd4_encode_noop
,
5253 [OP_OFFLOAD_STATUS
] = (nfsd4_enc
)nfsd4_encode_offload_status
,
5254 [OP_READ_PLUS
] = (nfsd4_enc
)nfsd4_encode_read_plus
,
5255 [OP_SEEK
] = (nfsd4_enc
)nfsd4_encode_seek
,
5256 [OP_WRITE_SAME
] = (nfsd4_enc
)nfsd4_encode_noop
,
5257 [OP_CLONE
] = (nfsd4_enc
)nfsd4_encode_noop
,
5259 /* RFC 8276 extended atributes operations */
5260 [OP_GETXATTR
] = (nfsd4_enc
)nfsd4_encode_getxattr
,
5261 [OP_SETXATTR
] = (nfsd4_enc
)nfsd4_encode_setxattr
,
5262 [OP_LISTXATTRS
] = (nfsd4_enc
)nfsd4_encode_listxattrs
,
5263 [OP_REMOVEXATTR
] = (nfsd4_enc
)nfsd4_encode_removexattr
,
5267 * Calculate whether we still have space to encode repsize bytes.
5268 * There are two considerations:
5269 * - For NFS versions >=4.1, the size of the reply must stay within
5271 * - For all NFS versions, we must stay within limited preallocated
5274 * This is called before the operation is processed, so can only provide
5275 * an upper estimate. For some nonidempotent operations (such as
5276 * getattr), it's not necessarily a problem if that estimate is wrong,
5277 * as we can fail it after processing without significant side effects.
5279 __be32
nfsd4_check_resp_size(struct nfsd4_compoundres
*resp
, u32 respsize
)
5281 struct xdr_buf
*buf
= &resp
->rqstp
->rq_res
;
5282 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5284 if (buf
->len
+ respsize
<= buf
->buflen
)
5286 if (!nfsd4_has_session(&resp
->cstate
))
5287 return nfserr_resource
;
5288 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
) {
5290 return nfserr_rep_too_big_to_cache
;
5292 return nfserr_rep_too_big
;
5296 nfsd4_encode_operation(struct nfsd4_compoundres
*resp
, struct nfsd4_op
*op
)
5298 struct xdr_stream
*xdr
= resp
->xdr
;
5299 struct nfs4_stateowner
*so
= resp
->cstate
.replay_owner
;
5300 struct svc_rqst
*rqstp
= resp
->rqstp
;
5301 const struct nfsd4_operation
*opdesc
= op
->opdesc
;
5302 int post_err_offset
;
5306 p
= xdr_reserve_space(xdr
, 8);
5311 *p
++ = cpu_to_be32(op
->opnum
);
5312 post_err_offset
= xdr
->buf
->len
;
5314 if (op
->opnum
== OP_ILLEGAL
)
5316 if (op
->status
&& opdesc
&&
5317 !(opdesc
->op_flags
& OP_NONTRIVIAL_ERROR_ENCODE
))
5319 BUG_ON(op
->opnum
>= ARRAY_SIZE(nfsd4_enc_ops
) ||
5320 !nfsd4_enc_ops
[op
->opnum
]);
5321 encoder
= nfsd4_enc_ops
[op
->opnum
];
5322 op
->status
= encoder(resp
, op
->status
, &op
->u
);
5324 trace_nfsd_compound_encode_err(rqstp
, op
->opnum
, op
->status
);
5325 if (opdesc
&& opdesc
->op_release
)
5326 opdesc
->op_release(&op
->u
);
5327 xdr_commit_encode(xdr
);
5329 /* nfsd4_check_resp_size guarantees enough room for error status */
5331 int space_needed
= 0;
5332 if (!nfsd4_last_compound_op(rqstp
))
5333 space_needed
= COMPOUND_ERR_SLACK_SPACE
;
5334 op
->status
= nfsd4_check_resp_size(resp
, space_needed
);
5336 if (op
->status
== nfserr_resource
&& nfsd4_has_session(&resp
->cstate
)) {
5337 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
5339 if (slot
->sl_flags
& NFSD4_SLOT_CACHETHIS
)
5340 op
->status
= nfserr_rep_too_big_to_cache
;
5342 op
->status
= nfserr_rep_too_big
;
5344 if (op
->status
== nfserr_resource
||
5345 op
->status
== nfserr_rep_too_big
||
5346 op
->status
== nfserr_rep_too_big_to_cache
) {
5348 * The operation may have already been encoded or
5349 * partially encoded. No op returns anything additional
5350 * in the case of one of these three errors, so we can
5351 * just truncate back to after the status. But it's a
5352 * bug if we had to do this on a non-idempotent op:
5354 warn_on_nonidempotent_op(op
);
5355 xdr_truncate_encode(xdr
, post_err_offset
);
5358 int len
= xdr
->buf
->len
- post_err_offset
;
5360 so
->so_replay
.rp_status
= op
->status
;
5361 so
->so_replay
.rp_buflen
= len
;
5362 read_bytes_from_xdr_buf(xdr
->buf
, post_err_offset
,
5363 so
->so_replay
.rp_buf
, len
);
5370 * Encode the reply stored in the stateowner reply cache
5372 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5373 * previously sent already encoded operation.
5376 nfsd4_encode_replay(struct xdr_stream
*xdr
, struct nfsd4_op
*op
)
5379 struct nfs4_replay
*rp
= op
->replay
;
5381 p
= xdr_reserve_space(xdr
, 8 + rp
->rp_buflen
);
5386 *p
++ = cpu_to_be32(op
->opnum
);
5387 *p
++ = rp
->rp_status
; /* already xdr'ed */
5389 p
= xdr_encode_opaque_fixed(p
, rp
->rp_buf
, rp
->rp_buflen
);
5392 void nfsd4_release_compoundargs(struct svc_rqst
*rqstp
)
5394 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5396 if (args
->ops
!= args
->iops
) {
5398 args
->ops
= args
->iops
;
5400 while (args
->to_free
) {
5401 struct svcxdr_tmpbuf
*tb
= args
->to_free
;
5402 args
->to_free
= tb
->next
;
5408 nfs4svc_decode_compoundargs(struct svc_rqst
*rqstp
, struct xdr_stream
*xdr
)
5410 struct nfsd4_compoundargs
*args
= rqstp
->rq_argp
;
5412 /* svcxdr_tmp_alloc */
5413 args
->to_free
= NULL
;
5416 args
->ops
= args
->iops
;
5417 args
->rqstp
= rqstp
;
5419 return nfsd4_decode_compound(args
);
5423 nfs4svc_encode_compoundres(struct svc_rqst
*rqstp
, struct xdr_stream
*xdr
)
5425 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
5426 struct xdr_buf
*buf
= xdr
->buf
;
5429 WARN_ON_ONCE(buf
->len
!= buf
->head
[0].iov_len
+ buf
->page_len
+
5430 buf
->tail
[0].iov_len
);
5433 * Send buffer space for the following items is reserved
5434 * at the top of nfsd4_proc_compound().
5438 *p
++ = resp
->cstate
.status
;
5440 rqstp
->rq_next_page
= xdr
->page_ptr
+ 1;
5442 *p
++ = htonl(resp
->taglen
);
5443 memcpy(p
, resp
->tag
, resp
->taglen
);
5444 p
+= XDR_QUADLEN(resp
->taglen
);
5445 *p
++ = htonl(resp
->opcnt
);
5447 nfsd4_sequence_done(resp
);