1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/nfs/nfs3xdr.c
5 * XDR functions to encode/decode NFSv3 RPC arguments and results.
7 * Copyright (C) 1996, 1997 Olaf Kirch
10 #include <linux/param.h>
11 #include <linux/time.h>
13 #include <linux/errno.h>
14 #include <linux/string.h>
16 #include <linux/pagemap.h>
17 #include <linux/proc_fs.h>
18 #include <linux/kdev_t.h>
19 #include <linux/sunrpc/clnt.h>
20 #include <linux/nfs.h>
21 #include <linux/nfs3.h>
22 #include <linux/nfs_fs.h>
23 #include <linux/nfsacl.h>
27 #define NFSDBG_FACILITY NFSDBG_XDR
29 /* Mapping from NFS error code to "errno" error code. */
30 #define errno_NFSERR_IO EIO
33 * Declare the space requirements for NFS arguments and replies as
34 * number of 32bit-words
36 #define NFS3_pagepad_sz (1) /* Page padding */
37 #define NFS3_fhandle_sz (1+16)
38 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
39 #define NFS3_post_op_fh_sz (1+NFS3_fh_sz)
40 #define NFS3_sattr_sz (15)
41 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
42 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
43 #define NFS3_fattr_sz (21)
44 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
45 #define NFS3_wcc_attr_sz (6)
46 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
47 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
48 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
49 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
51 #define NFS3_getattrargs_sz (NFS3_fh_sz)
52 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
53 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz)
54 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
55 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
56 #define NFS3_readargs_sz (NFS3_fh_sz+3)
57 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
58 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
59 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
60 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
61 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
62 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
63 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
64 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
65 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
66 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
67 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
69 #define NFS3_getattrres_sz (1+NFS3_fattr_sz)
70 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz)
71 #define NFS3_removeres_sz (NFS3_setattrres_sz)
72 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
73 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
74 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+NFS3_pagepad_sz)
75 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3+NFS3_pagepad_sz)
76 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
77 #define NFS3_createres_sz (1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
78 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
79 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
80 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2+NFS3_pagepad_sz)
81 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
82 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
83 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
84 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
86 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
87 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \
88 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
89 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \
90 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+\
92 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
94 static int nfs3_stat_to_errno(enum nfs_stat
);
97 * Map file type to S_IFMT bits
99 static const umode_t nfs_type2fmt
[] = {
106 [NF3SOCK
] = S_IFSOCK
,
110 static struct user_namespace
*rpc_userns(const struct rpc_clnt
*clnt
)
112 if (clnt
&& clnt
->cl_cred
)
113 return clnt
->cl_cred
->user_ns
;
114 return &init_user_ns
;
117 static struct user_namespace
*rpc_rqst_userns(const struct rpc_rqst
*rqstp
)
120 return rpc_userns(rqstp
->rq_task
->tk_client
);
121 return &init_user_ns
;
125 * Encode/decode NFSv3 basic data types
127 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
128 * "NFS Version 3 Protocol Specification".
130 * Not all basic data types have their own encoding and decoding
131 * functions. For run-time efficiency, some data types are encoded
135 static void encode_uint32(struct xdr_stream
*xdr
, u32 value
)
137 __be32
*p
= xdr_reserve_space(xdr
, 4);
138 *p
= cpu_to_be32(value
);
141 static int decode_uint32(struct xdr_stream
*xdr
, u32
*value
)
145 p
= xdr_inline_decode(xdr
, 4);
148 *value
= be32_to_cpup(p
);
152 static int decode_uint64(struct xdr_stream
*xdr
, u64
*value
)
156 p
= xdr_inline_decode(xdr
, 8);
159 xdr_decode_hyper(p
, value
);
166 * typedef uint64 fileid3;
168 static __be32
*xdr_decode_fileid3(__be32
*p
, u64
*fileid
)
170 return xdr_decode_hyper(p
, fileid
);
173 static int decode_fileid3(struct xdr_stream
*xdr
, u64
*fileid
)
175 return decode_uint64(xdr
, fileid
);
181 * typedef string filename3<>;
183 static void encode_filename3(struct xdr_stream
*xdr
,
184 const char *name
, u32 length
)
188 WARN_ON_ONCE(length
> NFS3_MAXNAMLEN
);
189 p
= xdr_reserve_space(xdr
, 4 + length
);
190 xdr_encode_opaque(p
, name
, length
);
193 static int decode_inline_filename3(struct xdr_stream
*xdr
,
194 const char **name
, u32
*length
)
199 p
= xdr_inline_decode(xdr
, 4);
202 count
= be32_to_cpup(p
);
203 if (count
> NFS3_MAXNAMLEN
)
204 goto out_nametoolong
;
205 p
= xdr_inline_decode(xdr
, count
);
208 *name
= (const char *)p
;
213 dprintk("NFS: returned filename too long: %u\n", count
);
214 return -ENAMETOOLONG
;
220 * typedef string nfspath3<>;
222 static void encode_nfspath3(struct xdr_stream
*xdr
, struct page
**pages
,
225 encode_uint32(xdr
, length
);
226 xdr_write_pages(xdr
, pages
, 0, length
);
229 static int decode_nfspath3(struct xdr_stream
*xdr
)
234 p
= xdr_inline_decode(xdr
, 4);
237 count
= be32_to_cpup(p
);
238 if (unlikely(count
>= xdr
->buf
->page_len
|| count
> NFS3_MAXPATHLEN
))
239 goto out_nametoolong
;
240 recvd
= xdr_read_pages(xdr
, count
);
241 if (unlikely(count
> recvd
))
243 xdr_terminate_string(xdr
->buf
, count
);
247 dprintk("NFS: returned pathname too long: %u\n", count
);
248 return -ENAMETOOLONG
;
250 dprintk("NFS: server cheating in pathname result: "
251 "count %u > recvd %u\n", count
, recvd
);
258 * typedef uint64 cookie3
260 static __be32
*xdr_encode_cookie3(__be32
*p
, u64 cookie
)
262 return xdr_encode_hyper(p
, cookie
);
265 static int decode_cookie3(struct xdr_stream
*xdr
, u64
*cookie
)
267 return decode_uint64(xdr
, cookie
);
273 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
275 static __be32
*xdr_encode_cookieverf3(__be32
*p
, const __be32
*verifier
)
277 memcpy(p
, verifier
, NFS3_COOKIEVERFSIZE
);
278 return p
+ XDR_QUADLEN(NFS3_COOKIEVERFSIZE
);
281 static int decode_cookieverf3(struct xdr_stream
*xdr
, __be32
*verifier
)
285 p
= xdr_inline_decode(xdr
, NFS3_COOKIEVERFSIZE
);
288 memcpy(verifier
, p
, NFS3_COOKIEVERFSIZE
);
295 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
297 static void encode_createverf3(struct xdr_stream
*xdr
, const __be32
*verifier
)
301 p
= xdr_reserve_space(xdr
, NFS3_CREATEVERFSIZE
);
302 memcpy(p
, verifier
, NFS3_CREATEVERFSIZE
);
305 static int decode_writeverf3(struct xdr_stream
*xdr
, struct nfs_write_verifier
*verifier
)
309 p
= xdr_inline_decode(xdr
, NFS3_WRITEVERFSIZE
);
312 memcpy(verifier
->data
, p
, NFS3_WRITEVERFSIZE
);
319 * typedef uint64 size3;
321 static __be32
*xdr_decode_size3(__be32
*p
, u64
*size
)
323 return xdr_decode_hyper(p
, size
);
334 #define NFS3_OK NFS_OK
336 static int decode_nfsstat3(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
340 p
= xdr_inline_decode(xdr
, 4);
343 if (unlikely(*p
!= cpu_to_be32(NFS3_OK
)))
348 *status
= be32_to_cpup(p
);
349 trace_nfs_xdr_status(xdr
, (int)*status
);
366 static void encode_ftype3(struct xdr_stream
*xdr
, const u32 type
)
368 encode_uint32(xdr
, type
);
371 static __be32
*xdr_decode_ftype3(__be32
*p
, umode_t
*mode
)
375 type
= be32_to_cpup(p
++);
378 *mode
= nfs_type2fmt
[type
];
390 static void encode_specdata3(struct xdr_stream
*xdr
, const dev_t rdev
)
394 p
= xdr_reserve_space(xdr
, 8);
395 *p
++ = cpu_to_be32(MAJOR(rdev
));
396 *p
= cpu_to_be32(MINOR(rdev
));
399 static __be32
*xdr_decode_specdata3(__be32
*p
, dev_t
*rdev
)
401 unsigned int major
, minor
;
403 major
= be32_to_cpup(p
++);
404 minor
= be32_to_cpup(p
++);
405 *rdev
= MKDEV(major
, minor
);
406 if (MAJOR(*rdev
) != major
|| MINOR(*rdev
) != minor
)
415 * opaque data<NFS3_FHSIZE>;
418 static void encode_nfs_fh3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
422 WARN_ON_ONCE(fh
->size
> NFS3_FHSIZE
);
423 p
= xdr_reserve_space(xdr
, 4 + fh
->size
);
424 xdr_encode_opaque(p
, fh
->data
, fh
->size
);
427 static int decode_nfs_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
432 p
= xdr_inline_decode(xdr
, 4);
435 length
= be32_to_cpup(p
++);
436 if (unlikely(length
> NFS3_FHSIZE
))
438 p
= xdr_inline_decode(xdr
, length
);
442 memcpy(fh
->data
, p
, length
);
445 dprintk("NFS: file handle size (%u) too big\n", length
);
449 static void zero_nfs_fh3(struct nfs_fh
*fh
)
451 memset(fh
, 0, sizeof(*fh
));
462 static __be32
*xdr_encode_nfstime3(__be32
*p
, const struct timespec64
*timep
)
464 *p
++ = cpu_to_be32((u32
)timep
->tv_sec
);
465 *p
++ = cpu_to_be32(timep
->tv_nsec
);
469 static __be32
*xdr_decode_nfstime3(__be32
*p
, struct timespec64
*timep
)
471 timep
->tv_sec
= be32_to_cpup(p
++);
472 timep
->tv_nsec
= be32_to_cpup(p
++);
481 * SET_TO_SERVER_TIME = 1,
482 * SET_TO_CLIENT_TIME = 2
485 * union set_mode3 switch (bool set_it) {
492 * union set_uid3 switch (bool set_it) {
499 * union set_gid3 switch (bool set_it) {
506 * union set_size3 switch (bool set_it) {
513 * union set_atime switch (time_how set_it) {
514 * case SET_TO_CLIENT_TIME:
520 * union set_mtime switch (time_how set_it) {
521 * case SET_TO_CLIENT_TIME:
536 static void encode_sattr3(struct xdr_stream
*xdr
, const struct iattr
*attr
,
537 struct user_namespace
*userns
)
543 * In order to make only a single xdr_reserve_space() call,
544 * pre-compute the total number of bytes to be reserved.
545 * Six boolean values, one for each set_foo field, are always
546 * present in the encoded result, so start there.
549 if (attr
->ia_valid
& ATTR_MODE
)
551 if (attr
->ia_valid
& ATTR_UID
)
553 if (attr
->ia_valid
& ATTR_GID
)
555 if (attr
->ia_valid
& ATTR_SIZE
)
557 if (attr
->ia_valid
& ATTR_ATIME_SET
)
559 if (attr
->ia_valid
& ATTR_MTIME_SET
)
561 p
= xdr_reserve_space(xdr
, nbytes
);
563 if (attr
->ia_valid
& ATTR_MODE
) {
565 *p
++ = cpu_to_be32(attr
->ia_mode
& S_IALLUGO
);
569 if (attr
->ia_valid
& ATTR_UID
) {
571 *p
++ = cpu_to_be32(from_kuid_munged(userns
, attr
->ia_uid
));
575 if (attr
->ia_valid
& ATTR_GID
) {
577 *p
++ = cpu_to_be32(from_kgid_munged(userns
, attr
->ia_gid
));
581 if (attr
->ia_valid
& ATTR_SIZE
) {
583 p
= xdr_encode_hyper(p
, (u64
)attr
->ia_size
);
587 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
589 p
= xdr_encode_nfstime3(p
, &attr
->ia_atime
);
590 } else if (attr
->ia_valid
& ATTR_ATIME
) {
595 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
597 xdr_encode_nfstime3(p
, &attr
->ia_mtime
);
598 } else if (attr
->ia_valid
& ATTR_MTIME
) {
623 static int decode_fattr3(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
624 struct user_namespace
*userns
)
629 p
= xdr_inline_decode(xdr
, NFS3_fattr_sz
<< 2);
633 p
= xdr_decode_ftype3(p
, &fmode
);
635 fattr
->mode
= (be32_to_cpup(p
++) & ~S_IFMT
) | fmode
;
636 fattr
->nlink
= be32_to_cpup(p
++);
637 fattr
->uid
= make_kuid(userns
, be32_to_cpup(p
++));
638 if (!uid_valid(fattr
->uid
))
640 fattr
->gid
= make_kgid(userns
, be32_to_cpup(p
++));
641 if (!gid_valid(fattr
->gid
))
644 p
= xdr_decode_size3(p
, &fattr
->size
);
645 p
= xdr_decode_size3(p
, &fattr
->du
.nfs3
.used
);
646 p
= xdr_decode_specdata3(p
, &fattr
->rdev
);
648 p
= xdr_decode_hyper(p
, &fattr
->fsid
.major
);
649 fattr
->fsid
.minor
= 0;
651 p
= xdr_decode_fileid3(p
, &fattr
->fileid
);
652 p
= xdr_decode_nfstime3(p
, &fattr
->atime
);
653 p
= xdr_decode_nfstime3(p
, &fattr
->mtime
);
654 xdr_decode_nfstime3(p
, &fattr
->ctime
);
655 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
657 fattr
->valid
|= NFS_ATTR_FATTR_V3
;
660 dprintk("NFS: returned invalid uid\n");
663 dprintk("NFS: returned invalid gid\n");
670 * union post_op_attr switch (bool attributes_follow) {
677 static int decode_post_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
678 struct user_namespace
*userns
)
682 p
= xdr_inline_decode(xdr
, 4);
686 return decode_fattr3(xdr
, fattr
, userns
);
698 static int decode_wcc_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
702 p
= xdr_inline_decode(xdr
, NFS3_wcc_attr_sz
<< 2);
706 fattr
->valid
|= NFS_ATTR_FATTR_PRESIZE
707 | NFS_ATTR_FATTR_PRECHANGE
708 | NFS_ATTR_FATTR_PREMTIME
709 | NFS_ATTR_FATTR_PRECTIME
;
711 p
= xdr_decode_size3(p
, &fattr
->pre_size
);
712 p
= xdr_decode_nfstime3(p
, &fattr
->pre_mtime
);
713 xdr_decode_nfstime3(p
, &fattr
->pre_ctime
);
714 fattr
->pre_change_attr
= nfs_timespec_to_change_attr(&fattr
->pre_ctime
);
721 * union pre_op_attr switch (bool attributes_follow) {
723 * wcc_attr attributes;
731 * pre_op_attr before;
732 * post_op_attr after;
735 static int decode_pre_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
739 p
= xdr_inline_decode(xdr
, 4);
743 return decode_wcc_attr(xdr
, fattr
);
747 static int decode_wcc_data(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
748 struct user_namespace
*userns
)
752 error
= decode_pre_op_attr(xdr
, fattr
);
755 error
= decode_post_op_attr(xdr
, fattr
, userns
);
763 * union post_op_fh3 switch (bool handle_follows) {
770 static int decode_post_op_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
772 __be32
*p
= xdr_inline_decode(xdr
, 4);
776 return decode_nfs_fh3(xdr
, fh
);
784 * struct diropargs3 {
789 static void encode_diropargs3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
790 const char *name
, u32 length
)
792 encode_nfs_fh3(xdr
, fh
);
793 encode_filename3(xdr
, name
, length
);
798 * NFSv3 XDR encode functions
800 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
801 * "NFS Version 3 Protocol Specification".
807 * struct GETATTR3args {
811 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst
*req
,
812 struct xdr_stream
*xdr
,
815 const struct nfs_fh
*fh
= data
;
817 encode_nfs_fh3(xdr
, fh
);
823 * union sattrguard3 switch (bool check) {
825 * nfstime3 obj_ctime;
830 * struct SETATTR3args {
832 * sattr3 new_attributes;
836 static void encode_sattrguard3(struct xdr_stream
*xdr
,
837 const struct nfs3_sattrargs
*args
)
842 p
= xdr_reserve_space(xdr
, 4 + 8);
844 xdr_encode_nfstime3(p
, &args
->guardtime
);
846 p
= xdr_reserve_space(xdr
, 4);
851 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst
*req
,
852 struct xdr_stream
*xdr
,
855 const struct nfs3_sattrargs
*args
= data
;
856 encode_nfs_fh3(xdr
, args
->fh
);
857 encode_sattr3(xdr
, args
->sattr
, rpc_rqst_userns(req
));
858 encode_sattrguard3(xdr
, args
);
864 * struct LOOKUP3args {
868 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst
*req
,
869 struct xdr_stream
*xdr
,
872 const struct nfs3_diropargs
*args
= data
;
874 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
880 * struct ACCESS3args {
885 static void encode_access3args(struct xdr_stream
*xdr
,
886 const struct nfs3_accessargs
*args
)
888 encode_nfs_fh3(xdr
, args
->fh
);
889 encode_uint32(xdr
, args
->access
);
892 static void nfs3_xdr_enc_access3args(struct rpc_rqst
*req
,
893 struct xdr_stream
*xdr
,
896 const struct nfs3_accessargs
*args
= data
;
898 encode_access3args(xdr
, args
);
902 * 3.3.5 READLINK3args
904 * struct READLINK3args {
908 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst
*req
,
909 struct xdr_stream
*xdr
,
912 const struct nfs3_readlinkargs
*args
= data
;
914 encode_nfs_fh3(xdr
, args
->fh
);
915 rpc_prepare_reply_pages(req
, args
->pages
, args
->pgbase
, args
->pglen
,
916 NFS3_readlinkres_sz
- NFS3_pagepad_sz
);
928 static void encode_read3args(struct xdr_stream
*xdr
,
929 const struct nfs_pgio_args
*args
)
933 encode_nfs_fh3(xdr
, args
->fh
);
935 p
= xdr_reserve_space(xdr
, 8 + 4);
936 p
= xdr_encode_hyper(p
, args
->offset
);
937 *p
= cpu_to_be32(args
->count
);
940 static void nfs3_xdr_enc_read3args(struct rpc_rqst
*req
,
941 struct xdr_stream
*xdr
,
944 const struct nfs_pgio_args
*args
= data
;
945 unsigned int replen
= args
->replen
? args
->replen
:
946 NFS3_readres_sz
- NFS3_pagepad_sz
;
948 encode_read3args(xdr
, args
);
949 rpc_prepare_reply_pages(req
, args
->pages
, args
->pgbase
,
950 args
->count
, replen
);
951 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
963 * struct WRITE3args {
971 static void encode_write3args(struct xdr_stream
*xdr
,
972 const struct nfs_pgio_args
*args
)
976 encode_nfs_fh3(xdr
, args
->fh
);
978 p
= xdr_reserve_space(xdr
, 8 + 4 + 4 + 4);
979 p
= xdr_encode_hyper(p
, args
->offset
);
980 *p
++ = cpu_to_be32(args
->count
);
981 *p
++ = cpu_to_be32(args
->stable
);
982 *p
= cpu_to_be32(args
->count
);
983 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, args
->count
);
986 static void nfs3_xdr_enc_write3args(struct rpc_rqst
*req
,
987 struct xdr_stream
*xdr
,
990 const struct nfs_pgio_args
*args
= data
;
992 encode_write3args(xdr
, args
);
993 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1005 * union createhow3 switch (createmode3 mode) {
1008 * sattr3 obj_attributes;
1013 * struct CREATE3args {
1018 static void encode_createhow3(struct xdr_stream
*xdr
,
1019 const struct nfs3_createargs
*args
,
1020 struct user_namespace
*userns
)
1022 encode_uint32(xdr
, args
->createmode
);
1023 switch (args
->createmode
) {
1024 case NFS3_CREATE_UNCHECKED
:
1025 case NFS3_CREATE_GUARDED
:
1026 encode_sattr3(xdr
, args
->sattr
, userns
);
1028 case NFS3_CREATE_EXCLUSIVE
:
1029 encode_createverf3(xdr
, args
->verifier
);
1036 static void nfs3_xdr_enc_create3args(struct rpc_rqst
*req
,
1037 struct xdr_stream
*xdr
,
1040 const struct nfs3_createargs
*args
= data
;
1042 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1043 encode_createhow3(xdr
, args
, rpc_rqst_userns(req
));
1049 * struct MKDIR3args {
1051 * sattr3 attributes;
1054 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst
*req
,
1055 struct xdr_stream
*xdr
,
1058 const struct nfs3_mkdirargs
*args
= data
;
1060 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1061 encode_sattr3(xdr
, args
->sattr
, rpc_rqst_userns(req
));
1065 * 3.3.10 SYMLINK3args
1067 * struct symlinkdata3 {
1068 * sattr3 symlink_attributes;
1069 * nfspath3 symlink_data;
1072 * struct SYMLINK3args {
1074 * symlinkdata3 symlink;
1077 static void encode_symlinkdata3(struct xdr_stream
*xdr
,
1079 struct user_namespace
*userns
)
1081 const struct nfs3_symlinkargs
*args
= data
;
1083 encode_sattr3(xdr
, args
->sattr
, userns
);
1084 encode_nfspath3(xdr
, args
->pages
, args
->pathlen
);
1087 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst
*req
,
1088 struct xdr_stream
*xdr
,
1091 const struct nfs3_symlinkargs
*args
= data
;
1093 encode_diropargs3(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
1094 encode_symlinkdata3(xdr
, args
, rpc_rqst_userns(req
));
1095 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1101 * struct devicedata3 {
1102 * sattr3 dev_attributes;
1106 * union mknoddata3 switch (ftype3 type) {
1109 * devicedata3 device;
1112 * sattr3 pipe_attributes;
1117 * struct MKNOD3args {
1122 static void encode_devicedata3(struct xdr_stream
*xdr
,
1123 const struct nfs3_mknodargs
*args
,
1124 struct user_namespace
*userns
)
1126 encode_sattr3(xdr
, args
->sattr
, userns
);
1127 encode_specdata3(xdr
, args
->rdev
);
1130 static void encode_mknoddata3(struct xdr_stream
*xdr
,
1131 const struct nfs3_mknodargs
*args
,
1132 struct user_namespace
*userns
)
1134 encode_ftype3(xdr
, args
->type
);
1135 switch (args
->type
) {
1138 encode_devicedata3(xdr
, args
, userns
);
1142 encode_sattr3(xdr
, args
->sattr
, userns
);
1152 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst
*req
,
1153 struct xdr_stream
*xdr
,
1156 const struct nfs3_mknodargs
*args
= data
;
1158 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1159 encode_mknoddata3(xdr
, args
, rpc_rqst_userns(req
));
1163 * 3.3.12 REMOVE3args
1165 * struct REMOVE3args {
1166 * diropargs3 object;
1169 static void nfs3_xdr_enc_remove3args(struct rpc_rqst
*req
,
1170 struct xdr_stream
*xdr
,
1173 const struct nfs_removeargs
*args
= data
;
1175 encode_diropargs3(xdr
, args
->fh
, args
->name
.name
, args
->name
.len
);
1179 * 3.3.14 RENAME3args
1181 * struct RENAME3args {
1186 static void nfs3_xdr_enc_rename3args(struct rpc_rqst
*req
,
1187 struct xdr_stream
*xdr
,
1190 const struct nfs_renameargs
*args
= data
;
1191 const struct qstr
*old
= args
->old_name
;
1192 const struct qstr
*new = args
->new_name
;
1194 encode_diropargs3(xdr
, args
->old_dir
, old
->name
, old
->len
);
1195 encode_diropargs3(xdr
, args
->new_dir
, new->name
, new->len
);
1201 * struct LINK3args {
1206 static void nfs3_xdr_enc_link3args(struct rpc_rqst
*req
,
1207 struct xdr_stream
*xdr
,
1210 const struct nfs3_linkargs
*args
= data
;
1212 encode_nfs_fh3(xdr
, args
->fromfh
);
1213 encode_diropargs3(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
1217 * 3.3.16 READDIR3args
1219 * struct READDIR3args {
1222 * cookieverf3 cookieverf;
1226 static void encode_readdir3args(struct xdr_stream
*xdr
,
1227 const struct nfs3_readdirargs
*args
)
1231 encode_nfs_fh3(xdr
, args
->fh
);
1233 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4);
1234 p
= xdr_encode_cookie3(p
, args
->cookie
);
1235 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1236 *p
= cpu_to_be32(args
->count
);
1239 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst
*req
,
1240 struct xdr_stream
*xdr
,
1243 const struct nfs3_readdirargs
*args
= data
;
1245 encode_readdir3args(xdr
, args
);
1246 rpc_prepare_reply_pages(req
, args
->pages
, 0, args
->count
,
1247 NFS3_readdirres_sz
- NFS3_pagepad_sz
);
1251 * 3.3.17 READDIRPLUS3args
1253 * struct READDIRPLUS3args {
1256 * cookieverf3 cookieverf;
1261 static void encode_readdirplus3args(struct xdr_stream
*xdr
,
1262 const struct nfs3_readdirargs
*args
)
1266 encode_nfs_fh3(xdr
, args
->fh
);
1268 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4 + 4);
1269 p
= xdr_encode_cookie3(p
, args
->cookie
);
1270 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1273 * readdirplus: need dircount + buffer size.
1274 * We just make sure we make dircount big enough
1276 *p
++ = cpu_to_be32(args
->count
>> 3);
1278 *p
= cpu_to_be32(args
->count
);
1281 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst
*req
,
1282 struct xdr_stream
*xdr
,
1285 const struct nfs3_readdirargs
*args
= data
;
1287 encode_readdirplus3args(xdr
, args
);
1288 rpc_prepare_reply_pages(req
, args
->pages
, 0, args
->count
,
1289 NFS3_readdirres_sz
- NFS3_pagepad_sz
);
1293 * 3.3.21 COMMIT3args
1295 * struct COMMIT3args {
1301 static void encode_commit3args(struct xdr_stream
*xdr
,
1302 const struct nfs_commitargs
*args
)
1306 encode_nfs_fh3(xdr
, args
->fh
);
1308 p
= xdr_reserve_space(xdr
, 8 + 4);
1309 p
= xdr_encode_hyper(p
, args
->offset
);
1310 *p
= cpu_to_be32(args
->count
);
1313 static void nfs3_xdr_enc_commit3args(struct rpc_rqst
*req
,
1314 struct xdr_stream
*xdr
,
1317 const struct nfs_commitargs
*args
= data
;
1319 encode_commit3args(xdr
, args
);
1322 #ifdef CONFIG_NFS_V3_ACL
1324 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst
*req
,
1325 struct xdr_stream
*xdr
,
1328 const struct nfs3_getaclargs
*args
= data
;
1330 encode_nfs_fh3(xdr
, args
->fh
);
1331 encode_uint32(xdr
, args
->mask
);
1332 if (args
->mask
& (NFS_ACL
| NFS_DFACL
)) {
1333 rpc_prepare_reply_pages(req
, args
->pages
, 0,
1334 NFSACL_MAXPAGES
<< PAGE_SHIFT
,
1335 ACL3_getaclres_sz
- NFS3_pagepad_sz
);
1336 req
->rq_rcv_buf
.flags
|= XDRBUF_SPARSE_PAGES
;
1340 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst
*req
,
1341 struct xdr_stream
*xdr
,
1344 const struct nfs3_setaclargs
*args
= data
;
1348 encode_nfs_fh3(xdr
, NFS_FH(args
->inode
));
1349 encode_uint32(xdr
, args
->mask
);
1351 base
= req
->rq_slen
;
1352 if (args
->npages
!= 0)
1353 xdr_write_pages(xdr
, args
->pages
, 0, args
->len
);
1355 xdr_reserve_space(xdr
, args
->len
);
1357 error
= nfsacl_encode(xdr
->buf
, base
, args
->inode
,
1358 (args
->mask
& NFS_ACL
) ?
1359 args
->acl_access
: NULL
, 1, 0);
1360 /* FIXME: this is just broken */
1362 error
= nfsacl_encode(xdr
->buf
, base
+ error
, args
->inode
,
1363 (args
->mask
& NFS_DFACL
) ?
1364 args
->acl_default
: NULL
, 1,
1369 #endif /* CONFIG_NFS_V3_ACL */
1372 * NFSv3 XDR decode functions
1374 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1375 * "NFS Version 3 Protocol Specification".
1381 * struct GETATTR3resok {
1382 * fattr3 obj_attributes;
1385 * union GETATTR3res switch (nfsstat3 status) {
1387 * GETATTR3resok resok;
1392 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst
*req
,
1393 struct xdr_stream
*xdr
,
1396 enum nfs_stat status
;
1399 error
= decode_nfsstat3(xdr
, &status
);
1400 if (unlikely(error
))
1402 if (status
!= NFS3_OK
)
1404 error
= decode_fattr3(xdr
, result
, rpc_rqst_userns(req
));
1408 return nfs3_stat_to_errno(status
);
1414 * struct SETATTR3resok {
1418 * struct SETATTR3resfail {
1422 * union SETATTR3res switch (nfsstat3 status) {
1424 * SETATTR3resok resok;
1426 * SETATTR3resfail resfail;
1429 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst
*req
,
1430 struct xdr_stream
*xdr
,
1433 enum nfs_stat status
;
1436 error
= decode_nfsstat3(xdr
, &status
);
1437 if (unlikely(error
))
1439 error
= decode_wcc_data(xdr
, result
, rpc_rqst_userns(req
));
1440 if (unlikely(error
))
1442 if (status
!= NFS3_OK
)
1447 return nfs3_stat_to_errno(status
);
1453 * struct LOOKUP3resok {
1455 * post_op_attr obj_attributes;
1456 * post_op_attr dir_attributes;
1459 * struct LOOKUP3resfail {
1460 * post_op_attr dir_attributes;
1463 * union LOOKUP3res switch (nfsstat3 status) {
1465 * LOOKUP3resok resok;
1467 * LOOKUP3resfail resfail;
1470 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst
*req
,
1471 struct xdr_stream
*xdr
,
1474 struct user_namespace
*userns
= rpc_rqst_userns(req
);
1475 struct nfs3_diropres
*result
= data
;
1476 enum nfs_stat status
;
1479 error
= decode_nfsstat3(xdr
, &status
);
1480 if (unlikely(error
))
1482 if (status
!= NFS3_OK
)
1484 error
= decode_nfs_fh3(xdr
, result
->fh
);
1485 if (unlikely(error
))
1487 error
= decode_post_op_attr(xdr
, result
->fattr
, userns
);
1488 if (unlikely(error
))
1490 error
= decode_post_op_attr(xdr
, result
->dir_attr
, userns
);
1494 error
= decode_post_op_attr(xdr
, result
->dir_attr
, userns
);
1495 if (unlikely(error
))
1497 return nfs3_stat_to_errno(status
);
1503 * struct ACCESS3resok {
1504 * post_op_attr obj_attributes;
1508 * struct ACCESS3resfail {
1509 * post_op_attr obj_attributes;
1512 * union ACCESS3res switch (nfsstat3 status) {
1514 * ACCESS3resok resok;
1516 * ACCESS3resfail resfail;
1519 static int nfs3_xdr_dec_access3res(struct rpc_rqst
*req
,
1520 struct xdr_stream
*xdr
,
1523 struct nfs3_accessres
*result
= data
;
1524 enum nfs_stat status
;
1527 error
= decode_nfsstat3(xdr
, &status
);
1528 if (unlikely(error
))
1530 error
= decode_post_op_attr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
1531 if (unlikely(error
))
1533 if (status
!= NFS3_OK
)
1535 error
= decode_uint32(xdr
, &result
->access
);
1539 return nfs3_stat_to_errno(status
);
1543 * 3.3.5 READLINK3res
1545 * struct READLINK3resok {
1546 * post_op_attr symlink_attributes;
1550 * struct READLINK3resfail {
1551 * post_op_attr symlink_attributes;
1554 * union READLINK3res switch (nfsstat3 status) {
1556 * READLINK3resok resok;
1558 * READLINK3resfail resfail;
1561 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst
*req
,
1562 struct xdr_stream
*xdr
,
1565 enum nfs_stat status
;
1568 error
= decode_nfsstat3(xdr
, &status
);
1569 if (unlikely(error
))
1571 error
= decode_post_op_attr(xdr
, result
, rpc_rqst_userns(req
));
1572 if (unlikely(error
))
1574 if (status
!= NFS3_OK
)
1576 error
= decode_nfspath3(xdr
);
1580 return nfs3_stat_to_errno(status
);
1586 * struct READ3resok {
1587 * post_op_attr file_attributes;
1593 * struct READ3resfail {
1594 * post_op_attr file_attributes;
1597 * union READ3res switch (nfsstat3 status) {
1601 * READ3resfail resfail;
1604 static int decode_read3resok(struct xdr_stream
*xdr
,
1605 struct nfs_pgio_res
*result
)
1607 u32 eof
, count
, ocount
, recvd
;
1610 p
= xdr_inline_decode(xdr
, 4 + 4 + 4);
1613 count
= be32_to_cpup(p
++);
1614 eof
= be32_to_cpup(p
++);
1615 ocount
= be32_to_cpup(p
++);
1616 if (unlikely(ocount
!= count
))
1618 recvd
= xdr_read_pages(xdr
, count
);
1619 if (unlikely(count
> recvd
))
1623 result
->count
= count
;
1626 dprintk("NFS: READ count doesn't match length of opaque: "
1627 "count %u != ocount %u\n", count
, ocount
);
1630 dprintk("NFS: server cheating in read result: "
1631 "count %u > recvd %u\n", count
, recvd
);
1637 static int nfs3_xdr_dec_read3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1640 struct nfs_pgio_res
*result
= data
;
1642 enum nfs_stat status
;
1645 pos
= xdr_stream_pos(xdr
);
1646 error
= decode_nfsstat3(xdr
, &status
);
1647 if (unlikely(error
))
1649 error
= decode_post_op_attr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
1650 if (unlikely(error
))
1652 result
->op_status
= status
;
1653 if (status
!= NFS3_OK
)
1655 result
->replen
= 3 + ((xdr_stream_pos(xdr
) - pos
) >> 2);
1656 error
= decode_read3resok(xdr
, result
);
1660 return nfs3_stat_to_errno(status
);
1672 * struct WRITE3resok {
1673 * wcc_data file_wcc;
1675 * stable_how committed;
1679 * struct WRITE3resfail {
1680 * wcc_data file_wcc;
1683 * union WRITE3res switch (nfsstat3 status) {
1685 * WRITE3resok resok;
1687 * WRITE3resfail resfail;
1690 static int decode_write3resok(struct xdr_stream
*xdr
,
1691 struct nfs_pgio_res
*result
)
1695 p
= xdr_inline_decode(xdr
, 4 + 4);
1698 result
->count
= be32_to_cpup(p
++);
1699 result
->verf
->committed
= be32_to_cpup(p
++);
1700 if (unlikely(result
->verf
->committed
> NFS_FILE_SYNC
))
1702 if (decode_writeverf3(xdr
, &result
->verf
->verifier
))
1704 return result
->count
;
1706 dprintk("NFS: bad stable_how value: %u\n", result
->verf
->committed
);
1710 static int nfs3_xdr_dec_write3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1713 struct nfs_pgio_res
*result
= data
;
1714 enum nfs_stat status
;
1717 error
= decode_nfsstat3(xdr
, &status
);
1718 if (unlikely(error
))
1720 error
= decode_wcc_data(xdr
, result
->fattr
, rpc_rqst_userns(req
));
1721 if (unlikely(error
))
1723 result
->op_status
= status
;
1724 if (status
!= NFS3_OK
)
1726 error
= decode_write3resok(xdr
, result
);
1730 return nfs3_stat_to_errno(status
);
1736 * struct CREATE3resok {
1738 * post_op_attr obj_attributes;
1742 * struct CREATE3resfail {
1746 * union CREATE3res switch (nfsstat3 status) {
1748 * CREATE3resok resok;
1750 * CREATE3resfail resfail;
1753 static int decode_create3resok(struct xdr_stream
*xdr
,
1754 struct nfs3_diropres
*result
,
1755 struct user_namespace
*userns
)
1759 error
= decode_post_op_fh3(xdr
, result
->fh
);
1760 if (unlikely(error
))
1762 error
= decode_post_op_attr(xdr
, result
->fattr
, userns
);
1763 if (unlikely(error
))
1765 /* The server isn't required to return a file handle.
1766 * If it didn't, force the client to perform a LOOKUP
1767 * to determine the correct file handle and attribute
1768 * values for the new object. */
1769 if (result
->fh
->size
== 0)
1770 result
->fattr
->valid
= 0;
1771 error
= decode_wcc_data(xdr
, result
->dir_attr
, userns
);
1776 static int nfs3_xdr_dec_create3res(struct rpc_rqst
*req
,
1777 struct xdr_stream
*xdr
,
1780 struct user_namespace
*userns
= rpc_rqst_userns(req
);
1781 struct nfs3_diropres
*result
= data
;
1782 enum nfs_stat status
;
1785 error
= decode_nfsstat3(xdr
, &status
);
1786 if (unlikely(error
))
1788 if (status
!= NFS3_OK
)
1790 error
= decode_create3resok(xdr
, result
, userns
);
1794 error
= decode_wcc_data(xdr
, result
->dir_attr
, userns
);
1795 if (unlikely(error
))
1797 return nfs3_stat_to_errno(status
);
1803 * struct REMOVE3resok {
1807 * struct REMOVE3resfail {
1811 * union REMOVE3res switch (nfsstat3 status) {
1813 * REMOVE3resok resok;
1815 * REMOVE3resfail resfail;
1818 static int nfs3_xdr_dec_remove3res(struct rpc_rqst
*req
,
1819 struct xdr_stream
*xdr
,
1822 struct nfs_removeres
*result
= data
;
1823 enum nfs_stat status
;
1826 error
= decode_nfsstat3(xdr
, &status
);
1827 if (unlikely(error
))
1829 error
= decode_wcc_data(xdr
, result
->dir_attr
, rpc_rqst_userns(req
));
1830 if (unlikely(error
))
1832 if (status
!= NFS3_OK
)
1837 return nfs3_stat_to_errno(status
);
1843 * struct RENAME3resok {
1844 * wcc_data fromdir_wcc;
1845 * wcc_data todir_wcc;
1848 * struct RENAME3resfail {
1849 * wcc_data fromdir_wcc;
1850 * wcc_data todir_wcc;
1853 * union RENAME3res switch (nfsstat3 status) {
1855 * RENAME3resok resok;
1857 * RENAME3resfail resfail;
1860 static int nfs3_xdr_dec_rename3res(struct rpc_rqst
*req
,
1861 struct xdr_stream
*xdr
,
1864 struct user_namespace
*userns
= rpc_rqst_userns(req
);
1865 struct nfs_renameres
*result
= data
;
1866 enum nfs_stat status
;
1869 error
= decode_nfsstat3(xdr
, &status
);
1870 if (unlikely(error
))
1872 error
= decode_wcc_data(xdr
, result
->old_fattr
, userns
);
1873 if (unlikely(error
))
1875 error
= decode_wcc_data(xdr
, result
->new_fattr
, userns
);
1876 if (unlikely(error
))
1878 if (status
!= NFS3_OK
)
1883 return nfs3_stat_to_errno(status
);
1889 * struct LINK3resok {
1890 * post_op_attr file_attributes;
1891 * wcc_data linkdir_wcc;
1894 * struct LINK3resfail {
1895 * post_op_attr file_attributes;
1896 * wcc_data linkdir_wcc;
1899 * union LINK3res switch (nfsstat3 status) {
1903 * LINK3resfail resfail;
1906 static int nfs3_xdr_dec_link3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1909 struct user_namespace
*userns
= rpc_rqst_userns(req
);
1910 struct nfs3_linkres
*result
= data
;
1911 enum nfs_stat status
;
1914 error
= decode_nfsstat3(xdr
, &status
);
1915 if (unlikely(error
))
1917 error
= decode_post_op_attr(xdr
, result
->fattr
, userns
);
1918 if (unlikely(error
))
1920 error
= decode_wcc_data(xdr
, result
->dir_attr
, userns
);
1921 if (unlikely(error
))
1923 if (status
!= NFS3_OK
)
1928 return nfs3_stat_to_errno(status
);
1932 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1933 * the local page cache
1934 * @xdr: XDR stream where entry resides
1935 * @entry: buffer to fill in with entry data
1936 * @plus: boolean indicating whether this should be a readdirplus entry
1938 * Returns zero if successful, otherwise a negative errno value is
1941 * This function is not invoked during READDIR reply decoding, but
1942 * rather whenever an application invokes the getdents(2) system call
1943 * on a directory already in our cache.
1951 * fhandle3 filehandle;
1952 * post_op_attr3 attributes;
1953 * entry3 *nextentry;
1957 * struct entryplus3 {
1961 * post_op_attr name_attributes;
1962 * post_op_fh3 name_handle;
1963 * entryplus3 *nextentry;
1966 int nfs3_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
1969 struct user_namespace
*userns
= rpc_userns(entry
->server
->client
);
1970 struct nfs_entry old
= *entry
;
1975 p
= xdr_inline_decode(xdr
, 4);
1978 if (*p
== xdr_zero
) {
1979 p
= xdr_inline_decode(xdr
, 4);
1988 error
= decode_fileid3(xdr
, &entry
->ino
);
1989 if (unlikely(error
))
1992 error
= decode_inline_filename3(xdr
, &entry
->name
, &entry
->len
);
1993 if (unlikely(error
))
1996 error
= decode_cookie3(xdr
, &new_cookie
);
1997 if (unlikely(error
))
2000 entry
->d_type
= DT_UNKNOWN
;
2003 entry
->fattr
->valid
= 0;
2004 error
= decode_post_op_attr(xdr
, entry
->fattr
, userns
);
2005 if (unlikely(error
))
2007 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_V3
)
2008 entry
->d_type
= nfs_umode_to_dtype(entry
->fattr
->mode
);
2010 if (entry
->fattr
->fileid
!= entry
->ino
) {
2011 entry
->fattr
->mounted_on_fileid
= entry
->ino
;
2012 entry
->fattr
->valid
|= NFS_ATTR_FATTR_MOUNTED_ON_FILEID
;
2015 /* In fact, a post_op_fh3: */
2016 p
= xdr_inline_decode(xdr
, 4);
2019 if (*p
!= xdr_zero
) {
2020 error
= decode_nfs_fh3(xdr
, entry
->fh
);
2021 if (unlikely(error
)) {
2022 if (error
== -E2BIG
)
2027 zero_nfs_fh3(entry
->fh
);
2030 entry
->prev_cookie
= entry
->cookie
;
2031 entry
->cookie
= new_cookie
;
2036 dprintk("NFS: directory entry contains invalid file handle\n");
2042 * 3.3.16 READDIR3res
2049 * struct READDIR3resok {
2050 * post_op_attr dir_attributes;
2051 * cookieverf3 cookieverf;
2055 * struct READDIR3resfail {
2056 * post_op_attr dir_attributes;
2059 * union READDIR3res switch (nfsstat3 status) {
2061 * READDIR3resok resok;
2063 * READDIR3resfail resfail;
2066 * Read the directory contents into the page cache, but otherwise
2067 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2068 * during subsequent nfs_readdir() calls.
2070 static int decode_dirlist3(struct xdr_stream
*xdr
)
2072 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
2075 static int decode_readdir3resok(struct xdr_stream
*xdr
,
2076 struct nfs3_readdirres
*result
,
2077 struct user_namespace
*userns
)
2081 error
= decode_post_op_attr(xdr
, result
->dir_attr
, userns
);
2082 if (unlikely(error
))
2084 /* XXX: do we need to check if result->verf != NULL ? */
2085 error
= decode_cookieverf3(xdr
, result
->verf
);
2086 if (unlikely(error
))
2088 error
= decode_dirlist3(xdr
);
2093 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst
*req
,
2094 struct xdr_stream
*xdr
,
2097 struct nfs3_readdirres
*result
= data
;
2098 enum nfs_stat status
;
2101 error
= decode_nfsstat3(xdr
, &status
);
2102 if (unlikely(error
))
2104 if (status
!= NFS3_OK
)
2106 error
= decode_readdir3resok(xdr
, result
, rpc_rqst_userns(req
));
2110 error
= decode_post_op_attr(xdr
, result
->dir_attr
, rpc_rqst_userns(req
));
2111 if (unlikely(error
))
2113 return nfs3_stat_to_errno(status
);
2119 * struct FSSTAT3resok {
2120 * post_op_attr obj_attributes;
2130 * struct FSSTAT3resfail {
2131 * post_op_attr obj_attributes;
2134 * union FSSTAT3res switch (nfsstat3 status) {
2136 * FSSTAT3resok resok;
2138 * FSSTAT3resfail resfail;
2141 static int decode_fsstat3resok(struct xdr_stream
*xdr
,
2142 struct nfs_fsstat
*result
)
2146 p
= xdr_inline_decode(xdr
, 8 * 6 + 4);
2149 p
= xdr_decode_size3(p
, &result
->tbytes
);
2150 p
= xdr_decode_size3(p
, &result
->fbytes
);
2151 p
= xdr_decode_size3(p
, &result
->abytes
);
2152 p
= xdr_decode_size3(p
, &result
->tfiles
);
2153 p
= xdr_decode_size3(p
, &result
->ffiles
);
2154 xdr_decode_size3(p
, &result
->afiles
);
2155 /* ignore invarsec */
2159 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst
*req
,
2160 struct xdr_stream
*xdr
,
2163 struct nfs_fsstat
*result
= data
;
2164 enum nfs_stat status
;
2167 error
= decode_nfsstat3(xdr
, &status
);
2168 if (unlikely(error
))
2170 error
= decode_post_op_attr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
2171 if (unlikely(error
))
2173 if (status
!= NFS3_OK
)
2175 error
= decode_fsstat3resok(xdr
, result
);
2179 return nfs3_stat_to_errno(status
);
2185 * struct FSINFO3resok {
2186 * post_op_attr obj_attributes;
2194 * size3 maxfilesize;
2195 * nfstime3 time_delta;
2196 * uint32 properties;
2199 * struct FSINFO3resfail {
2200 * post_op_attr obj_attributes;
2203 * union FSINFO3res switch (nfsstat3 status) {
2205 * FSINFO3resok resok;
2207 * FSINFO3resfail resfail;
2210 static int decode_fsinfo3resok(struct xdr_stream
*xdr
,
2211 struct nfs_fsinfo
*result
)
2215 p
= xdr_inline_decode(xdr
, 4 * 7 + 8 + 8 + 4);
2218 result
->rtmax
= be32_to_cpup(p
++);
2219 result
->rtpref
= be32_to_cpup(p
++);
2220 result
->rtmult
= be32_to_cpup(p
++);
2221 result
->wtmax
= be32_to_cpup(p
++);
2222 result
->wtpref
= be32_to_cpup(p
++);
2223 result
->wtmult
= be32_to_cpup(p
++);
2224 result
->dtpref
= be32_to_cpup(p
++);
2225 p
= xdr_decode_size3(p
, &result
->maxfilesize
);
2226 xdr_decode_nfstime3(p
, &result
->time_delta
);
2228 /* ignore properties */
2229 result
->lease_time
= 0;
2233 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst
*req
,
2234 struct xdr_stream
*xdr
,
2237 struct nfs_fsinfo
*result
= data
;
2238 enum nfs_stat status
;
2241 error
= decode_nfsstat3(xdr
, &status
);
2242 if (unlikely(error
))
2244 error
= decode_post_op_attr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
2245 if (unlikely(error
))
2247 if (status
!= NFS3_OK
)
2249 error
= decode_fsinfo3resok(xdr
, result
);
2253 return nfs3_stat_to_errno(status
);
2257 * 3.3.20 PATHCONF3res
2259 * struct PATHCONF3resok {
2260 * post_op_attr obj_attributes;
2264 * bool chown_restricted;
2265 * bool case_insensitive;
2266 * bool case_preserving;
2269 * struct PATHCONF3resfail {
2270 * post_op_attr obj_attributes;
2273 * union PATHCONF3res switch (nfsstat3 status) {
2275 * PATHCONF3resok resok;
2277 * PATHCONF3resfail resfail;
2280 static int decode_pathconf3resok(struct xdr_stream
*xdr
,
2281 struct nfs_pathconf
*result
)
2285 p
= xdr_inline_decode(xdr
, 4 * 6);
2288 result
->max_link
= be32_to_cpup(p
++);
2289 result
->max_namelen
= be32_to_cpup(p
);
2290 /* ignore remaining fields */
2294 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst
*req
,
2295 struct xdr_stream
*xdr
,
2298 struct nfs_pathconf
*result
= data
;
2299 enum nfs_stat status
;
2302 error
= decode_nfsstat3(xdr
, &status
);
2303 if (unlikely(error
))
2305 error
= decode_post_op_attr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
2306 if (unlikely(error
))
2308 if (status
!= NFS3_OK
)
2310 error
= decode_pathconf3resok(xdr
, result
);
2314 return nfs3_stat_to_errno(status
);
2320 * struct COMMIT3resok {
2321 * wcc_data file_wcc;
2325 * struct COMMIT3resfail {
2326 * wcc_data file_wcc;
2329 * union COMMIT3res switch (nfsstat3 status) {
2331 * COMMIT3resok resok;
2333 * COMMIT3resfail resfail;
2336 static int nfs3_xdr_dec_commit3res(struct rpc_rqst
*req
,
2337 struct xdr_stream
*xdr
,
2340 struct nfs_commitres
*result
= data
;
2341 struct nfs_writeverf
*verf
= result
->verf
;
2342 enum nfs_stat status
;
2345 error
= decode_nfsstat3(xdr
, &status
);
2346 if (unlikely(error
))
2348 error
= decode_wcc_data(xdr
, result
->fattr
, rpc_rqst_userns(req
));
2349 if (unlikely(error
))
2351 result
->op_status
= status
;
2352 if (status
!= NFS3_OK
)
2354 error
= decode_writeverf3(xdr
, &verf
->verifier
);
2356 verf
->committed
= NFS_FILE_SYNC
;
2360 return nfs3_stat_to_errno(status
);
2363 #ifdef CONFIG_NFS_V3_ACL
2365 static inline int decode_getacl3resok(struct xdr_stream
*xdr
,
2366 struct nfs3_getaclres
*result
,
2367 struct user_namespace
*userns
)
2369 struct posix_acl
**acl
;
2370 unsigned int *aclcnt
;
2374 error
= decode_post_op_attr(xdr
, result
->fattr
, userns
);
2375 if (unlikely(error
))
2377 error
= decode_uint32(xdr
, &result
->mask
);
2378 if (unlikely(error
))
2381 if (result
->mask
& ~(NFS_ACL
|NFS_ACLCNT
|NFS_DFACL
|NFS_DFACLCNT
))
2384 hdrlen
= xdr_stream_pos(xdr
);
2387 if (result
->mask
& NFS_ACL
)
2388 acl
= &result
->acl_access
;
2390 if (result
->mask
& NFS_ACLCNT
)
2391 aclcnt
= &result
->acl_access_count
;
2392 error
= nfsacl_decode(xdr
->buf
, hdrlen
, aclcnt
, acl
);
2393 if (unlikely(error
<= 0))
2397 if (result
->mask
& NFS_DFACL
)
2398 acl
= &result
->acl_default
;
2400 if (result
->mask
& NFS_DFACLCNT
)
2401 aclcnt
= &result
->acl_default_count
;
2402 error
= nfsacl_decode(xdr
->buf
, hdrlen
+ error
, aclcnt
, acl
);
2403 if (unlikely(error
<= 0))
2410 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst
*req
,
2411 struct xdr_stream
*xdr
,
2414 enum nfs_stat status
;
2417 error
= decode_nfsstat3(xdr
, &status
);
2418 if (unlikely(error
))
2420 if (status
!= NFS3_OK
)
2422 error
= decode_getacl3resok(xdr
, result
, rpc_rqst_userns(req
));
2426 return nfs3_stat_to_errno(status
);
2429 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst
*req
,
2430 struct xdr_stream
*xdr
,
2433 enum nfs_stat status
;
2436 error
= decode_nfsstat3(xdr
, &status
);
2437 if (unlikely(error
))
2439 if (status
!= NFS3_OK
)
2441 error
= decode_post_op_attr(xdr
, result
, rpc_rqst_userns(req
));
2445 return nfs3_stat_to_errno(status
);
2448 #endif /* CONFIG_NFS_V3_ACL */
2452 * We need to translate between nfs status return values and
2453 * the local errno values which may not be the same.
2455 static const struct {
2460 { NFSERR_PERM
, -EPERM
},
2461 { NFSERR_NOENT
, -ENOENT
},
2462 { NFSERR_IO
, -errno_NFSERR_IO
},
2463 { NFSERR_NXIO
, -ENXIO
},
2464 /* { NFSERR_EAGAIN, -EAGAIN }, */
2465 { NFSERR_ACCES
, -EACCES
},
2466 { NFSERR_EXIST
, -EEXIST
},
2467 { NFSERR_XDEV
, -EXDEV
},
2468 { NFSERR_NODEV
, -ENODEV
},
2469 { NFSERR_NOTDIR
, -ENOTDIR
},
2470 { NFSERR_ISDIR
, -EISDIR
},
2471 { NFSERR_INVAL
, -EINVAL
},
2472 { NFSERR_FBIG
, -EFBIG
},
2473 { NFSERR_NOSPC
, -ENOSPC
},
2474 { NFSERR_ROFS
, -EROFS
},
2475 { NFSERR_MLINK
, -EMLINK
},
2476 { NFSERR_NAMETOOLONG
, -ENAMETOOLONG
},
2477 { NFSERR_NOTEMPTY
, -ENOTEMPTY
},
2478 { NFSERR_DQUOT
, -EDQUOT
},
2479 { NFSERR_STALE
, -ESTALE
},
2480 { NFSERR_REMOTE
, -EREMOTE
},
2482 { NFSERR_WFLUSH
, -EWFLUSH
},
2484 { NFSERR_BADHANDLE
, -EBADHANDLE
},
2485 { NFSERR_NOT_SYNC
, -ENOTSYNC
},
2486 { NFSERR_BAD_COOKIE
, -EBADCOOKIE
},
2487 { NFSERR_NOTSUPP
, -ENOTSUPP
},
2488 { NFSERR_TOOSMALL
, -ETOOSMALL
},
2489 { NFSERR_SERVERFAULT
, -EREMOTEIO
},
2490 { NFSERR_BADTYPE
, -EBADTYPE
},
2491 { NFSERR_JUKEBOX
, -EJUKEBOX
},
2496 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2497 * @status: NFS status code to convert
2499 * Returns a local errno value, or -EIO if the NFS status code is
2500 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2502 static int nfs3_stat_to_errno(enum nfs_stat status
)
2506 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
2507 if (nfs_errtbl
[i
].stat
== (int)status
)
2508 return nfs_errtbl
[i
].errno
;
2510 dprintk("NFS: Unrecognized nfs status value: %u\n", status
);
2511 return nfs_errtbl
[i
].errno
;
2515 #define PROC(proc, argtype, restype, timer) \
2516 [NFS3PROC_##proc] = { \
2517 .p_proc = NFS3PROC_##proc, \
2518 .p_encode = nfs3_xdr_enc_##argtype##3args, \
2519 .p_decode = nfs3_xdr_dec_##restype##3res, \
2520 .p_arglen = NFS3_##argtype##args_sz, \
2521 .p_replen = NFS3_##restype##res_sz, \
2523 .p_statidx = NFS3PROC_##proc, \
2527 const struct rpc_procinfo nfs3_procedures
[] = {
2528 PROC(GETATTR
, getattr
, getattr
, 1),
2529 PROC(SETATTR
, setattr
, setattr
, 0),
2530 PROC(LOOKUP
, lookup
, lookup
, 2),
2531 PROC(ACCESS
, access
, access
, 1),
2532 PROC(READLINK
, readlink
, readlink
, 3),
2533 PROC(READ
, read
, read
, 3),
2534 PROC(WRITE
, write
, write
, 4),
2535 PROC(CREATE
, create
, create
, 0),
2536 PROC(MKDIR
, mkdir
, create
, 0),
2537 PROC(SYMLINK
, symlink
, create
, 0),
2538 PROC(MKNOD
, mknod
, create
, 0),
2539 PROC(REMOVE
, remove
, remove
, 0),
2540 PROC(RMDIR
, lookup
, setattr
, 0),
2541 PROC(RENAME
, rename
, rename
, 0),
2542 PROC(LINK
, link
, link
, 0),
2543 PROC(READDIR
, readdir
, readdir
, 3),
2544 PROC(READDIRPLUS
, readdirplus
, readdir
, 3),
2545 PROC(FSSTAT
, getattr
, fsstat
, 0),
2546 PROC(FSINFO
, getattr
, fsinfo
, 0),
2547 PROC(PATHCONF
, getattr
, pathconf
, 0),
2548 PROC(COMMIT
, commit
, commit
, 5),
2551 static unsigned int nfs_version3_counts
[ARRAY_SIZE(nfs3_procedures
)];
2552 const struct rpc_version nfs_version3
= {
2554 .nrprocs
= ARRAY_SIZE(nfs3_procedures
),
2555 .procs
= nfs3_procedures
,
2556 .counts
= nfs_version3_counts
,
2559 #ifdef CONFIG_NFS_V3_ACL
2560 static const struct rpc_procinfo nfs3_acl_procedures
[] = {
2561 [ACLPROC3_GETACL
] = {
2562 .p_proc
= ACLPROC3_GETACL
,
2563 .p_encode
= nfs3_xdr_enc_getacl3args
,
2564 .p_decode
= nfs3_xdr_dec_getacl3res
,
2565 .p_arglen
= ACL3_getaclargs_sz
,
2566 .p_replen
= ACL3_getaclres_sz
,
2570 [ACLPROC3_SETACL
] = {
2571 .p_proc
= ACLPROC3_SETACL
,
2572 .p_encode
= nfs3_xdr_enc_setacl3args
,
2573 .p_decode
= nfs3_xdr_dec_setacl3res
,
2574 .p_arglen
= ACL3_setaclargs_sz
,
2575 .p_replen
= ACL3_setaclres_sz
,
2581 static unsigned int nfs3_acl_counts
[ARRAY_SIZE(nfs3_acl_procedures
)];
2582 const struct rpc_version nfsacl_version3
= {
2584 .nrprocs
= ARRAY_SIZE(nfs3_acl_procedures
),
2585 .procs
= nfs3_acl_procedures
,
2586 .counts
= nfs3_acl_counts
,
2588 #endif /* CONFIG_NFS_V3_ACL */