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>
26 #define NFSDBG_FACILITY NFSDBG_XDR
28 /* Mapping from NFS error code to "errno" error code. */
29 #define errno_NFSERR_IO EIO
32 * Declare the space requirements for NFS arguments and replies as
33 * number of 32bit-words
35 #define NFS3_fhandle_sz (1+16)
36 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
37 #define NFS3_sattr_sz (15)
38 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
39 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
40 #define NFS3_fattr_sz (21)
41 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
42 #define NFS3_wcc_attr_sz (6)
43 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
44 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
45 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
46 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
48 #define NFS3_getattrargs_sz (NFS3_fh_sz)
49 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
50 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz)
51 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
52 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
53 #define NFS3_readargs_sz (NFS3_fh_sz+3)
54 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
55 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
56 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
57 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
58 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
59 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
60 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
61 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
62 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
63 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
64 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
66 #define NFS3_getattrres_sz (1+NFS3_fattr_sz)
67 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz)
68 #define NFS3_removeres_sz (NFS3_setattrres_sz)
69 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
70 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
71 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1)
72 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3)
73 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
74 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
75 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
76 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
77 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2)
78 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
79 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
80 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
81 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
83 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
84 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \
85 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
86 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \
87 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
88 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
90 static int nfs3_stat_to_errno(enum nfs_stat
);
93 * Map file type to S_IFMT bits
95 static const umode_t nfs_type2fmt
[] = {
102 [NF3SOCK
] = S_IFSOCK
,
107 * While encoding arguments, set up the reply buffer in advance to
108 * receive reply data directly into the page cache.
110 static void prepare_reply_buffer(struct rpc_rqst
*req
, struct page
**pages
,
111 unsigned int base
, unsigned int len
,
112 unsigned int bufsize
)
114 struct rpc_auth
*auth
= req
->rq_cred
->cr_auth
;
117 replen
= RPC_REPHDRSIZE
+ auth
->au_rslack
+ bufsize
;
118 xdr_inline_pages(&req
->rq_rcv_buf
, replen
<< 2, pages
, base
, len
);
122 * Handle decode buffer overflows out-of-line.
124 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
126 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
127 "Remaining buffer length is %tu words.\n",
128 func
, xdr
->end
- xdr
->p
);
133 * Encode/decode NFSv3 basic data types
135 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
136 * "NFS Version 3 Protocol Specification".
138 * Not all basic data types have their own encoding and decoding
139 * functions. For run-time efficiency, some data types are encoded
143 static void encode_uint32(struct xdr_stream
*xdr
, u32 value
)
145 __be32
*p
= xdr_reserve_space(xdr
, 4);
146 *p
= cpu_to_be32(value
);
149 static int decode_uint32(struct xdr_stream
*xdr
, u32
*value
)
153 p
= xdr_inline_decode(xdr
, 4);
154 if (unlikely(p
== NULL
))
156 *value
= be32_to_cpup(p
);
159 print_overflow_msg(__func__
, xdr
);
163 static int decode_uint64(struct xdr_stream
*xdr
, u64
*value
)
167 p
= xdr_inline_decode(xdr
, 8);
168 if (unlikely(p
== NULL
))
170 xdr_decode_hyper(p
, value
);
173 print_overflow_msg(__func__
, xdr
);
180 * typedef uint64 fileid3;
182 static __be32
*xdr_decode_fileid3(__be32
*p
, u64
*fileid
)
184 return xdr_decode_hyper(p
, fileid
);
187 static int decode_fileid3(struct xdr_stream
*xdr
, u64
*fileid
)
189 return decode_uint64(xdr
, fileid
);
195 * typedef string filename3<>;
197 static void encode_filename3(struct xdr_stream
*xdr
,
198 const char *name
, u32 length
)
202 WARN_ON_ONCE(length
> NFS3_MAXNAMLEN
);
203 p
= xdr_reserve_space(xdr
, 4 + length
);
204 xdr_encode_opaque(p
, name
, length
);
207 static int decode_inline_filename3(struct xdr_stream
*xdr
,
208 const char **name
, u32
*length
)
213 p
= xdr_inline_decode(xdr
, 4);
214 if (unlikely(p
== NULL
))
216 count
= be32_to_cpup(p
);
217 if (count
> NFS3_MAXNAMLEN
)
218 goto out_nametoolong
;
219 p
= xdr_inline_decode(xdr
, count
);
220 if (unlikely(p
== NULL
))
222 *name
= (const char *)p
;
227 dprintk("NFS: returned filename too long: %u\n", count
);
228 return -ENAMETOOLONG
;
230 print_overflow_msg(__func__
, xdr
);
237 * typedef string nfspath3<>;
239 static void encode_nfspath3(struct xdr_stream
*xdr
, struct page
**pages
,
242 encode_uint32(xdr
, length
);
243 xdr_write_pages(xdr
, pages
, 0, length
);
246 static int decode_nfspath3(struct xdr_stream
*xdr
)
251 p
= xdr_inline_decode(xdr
, 4);
252 if (unlikely(p
== NULL
))
254 count
= be32_to_cpup(p
);
255 if (unlikely(count
>= xdr
->buf
->page_len
|| count
> NFS3_MAXPATHLEN
))
256 goto out_nametoolong
;
257 recvd
= xdr_read_pages(xdr
, count
);
258 if (unlikely(count
> recvd
))
260 xdr_terminate_string(xdr
->buf
, count
);
264 dprintk("NFS: returned pathname too long: %u\n", count
);
265 return -ENAMETOOLONG
;
267 dprintk("NFS: server cheating in pathname result: "
268 "count %u > recvd %u\n", count
, recvd
);
271 print_overflow_msg(__func__
, xdr
);
278 * typedef uint64 cookie3
280 static __be32
*xdr_encode_cookie3(__be32
*p
, u64 cookie
)
282 return xdr_encode_hyper(p
, cookie
);
285 static int decode_cookie3(struct xdr_stream
*xdr
, u64
*cookie
)
287 return decode_uint64(xdr
, cookie
);
293 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
295 static __be32
*xdr_encode_cookieverf3(__be32
*p
, const __be32
*verifier
)
297 memcpy(p
, verifier
, NFS3_COOKIEVERFSIZE
);
298 return p
+ XDR_QUADLEN(NFS3_COOKIEVERFSIZE
);
301 static int decode_cookieverf3(struct xdr_stream
*xdr
, __be32
*verifier
)
305 p
= xdr_inline_decode(xdr
, NFS3_COOKIEVERFSIZE
);
306 if (unlikely(p
== NULL
))
308 memcpy(verifier
, p
, NFS3_COOKIEVERFSIZE
);
311 print_overflow_msg(__func__
, xdr
);
318 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
320 static void encode_createverf3(struct xdr_stream
*xdr
, const __be32
*verifier
)
324 p
= xdr_reserve_space(xdr
, NFS3_CREATEVERFSIZE
);
325 memcpy(p
, verifier
, NFS3_CREATEVERFSIZE
);
328 static int decode_writeverf3(struct xdr_stream
*xdr
, struct nfs_write_verifier
*verifier
)
332 p
= xdr_inline_decode(xdr
, NFS3_WRITEVERFSIZE
);
333 if (unlikely(p
== NULL
))
335 memcpy(verifier
->data
, p
, NFS3_WRITEVERFSIZE
);
338 print_overflow_msg(__func__
, xdr
);
345 * typedef uint64 size3;
347 static __be32
*xdr_decode_size3(__be32
*p
, u64
*size
)
349 return xdr_decode_hyper(p
, size
);
360 #define NFS3_OK NFS_OK
362 static int decode_nfsstat3(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
366 p
= xdr_inline_decode(xdr
, 4);
367 if (unlikely(p
== NULL
))
369 *status
= be32_to_cpup(p
);
372 print_overflow_msg(__func__
, xdr
);
389 static void encode_ftype3(struct xdr_stream
*xdr
, const u32 type
)
391 encode_uint32(xdr
, type
);
394 static __be32
*xdr_decode_ftype3(__be32
*p
, umode_t
*mode
)
398 type
= be32_to_cpup(p
++);
401 *mode
= nfs_type2fmt
[type
];
413 static void encode_specdata3(struct xdr_stream
*xdr
, const dev_t rdev
)
417 p
= xdr_reserve_space(xdr
, 8);
418 *p
++ = cpu_to_be32(MAJOR(rdev
));
419 *p
= cpu_to_be32(MINOR(rdev
));
422 static __be32
*xdr_decode_specdata3(__be32
*p
, dev_t
*rdev
)
424 unsigned int major
, minor
;
426 major
= be32_to_cpup(p
++);
427 minor
= be32_to_cpup(p
++);
428 *rdev
= MKDEV(major
, minor
);
429 if (MAJOR(*rdev
) != major
|| MINOR(*rdev
) != minor
)
438 * opaque data<NFS3_FHSIZE>;
441 static void encode_nfs_fh3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
445 WARN_ON_ONCE(fh
->size
> NFS3_FHSIZE
);
446 p
= xdr_reserve_space(xdr
, 4 + fh
->size
);
447 xdr_encode_opaque(p
, fh
->data
, fh
->size
);
450 static int decode_nfs_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
455 p
= xdr_inline_decode(xdr
, 4);
456 if (unlikely(p
== NULL
))
458 length
= be32_to_cpup(p
++);
459 if (unlikely(length
> NFS3_FHSIZE
))
461 p
= xdr_inline_decode(xdr
, length
);
462 if (unlikely(p
== NULL
))
465 memcpy(fh
->data
, p
, length
);
468 dprintk("NFS: file handle size (%u) too big\n", length
);
471 print_overflow_msg(__func__
, xdr
);
475 static void zero_nfs_fh3(struct nfs_fh
*fh
)
477 memset(fh
, 0, sizeof(*fh
));
488 static __be32
*xdr_encode_nfstime3(__be32
*p
, const struct timespec
*timep
)
490 *p
++ = cpu_to_be32(timep
->tv_sec
);
491 *p
++ = cpu_to_be32(timep
->tv_nsec
);
495 static __be32
*xdr_decode_nfstime3(__be32
*p
, struct timespec
*timep
)
497 timep
->tv_sec
= be32_to_cpup(p
++);
498 timep
->tv_nsec
= be32_to_cpup(p
++);
507 * SET_TO_SERVER_TIME = 1,
508 * SET_TO_CLIENT_TIME = 2
511 * union set_mode3 switch (bool set_it) {
518 * union set_uid3 switch (bool set_it) {
525 * union set_gid3 switch (bool set_it) {
532 * union set_size3 switch (bool set_it) {
539 * union set_atime switch (time_how set_it) {
540 * case SET_TO_CLIENT_TIME:
546 * union set_mtime switch (time_how set_it) {
547 * case SET_TO_CLIENT_TIME:
562 static void encode_sattr3(struct xdr_stream
*xdr
, const struct iattr
*attr
)
568 * In order to make only a single xdr_reserve_space() call,
569 * pre-compute the total number of bytes to be reserved.
570 * Six boolean values, one for each set_foo field, are always
571 * present in the encoded result, so start there.
574 if (attr
->ia_valid
& ATTR_MODE
)
576 if (attr
->ia_valid
& ATTR_UID
)
578 if (attr
->ia_valid
& ATTR_GID
)
580 if (attr
->ia_valid
& ATTR_SIZE
)
582 if (attr
->ia_valid
& ATTR_ATIME_SET
)
584 if (attr
->ia_valid
& ATTR_MTIME_SET
)
586 p
= xdr_reserve_space(xdr
, nbytes
);
588 if (attr
->ia_valid
& ATTR_MODE
) {
590 *p
++ = cpu_to_be32(attr
->ia_mode
& S_IALLUGO
);
594 if (attr
->ia_valid
& ATTR_UID
) {
596 *p
++ = cpu_to_be32(from_kuid(&init_user_ns
, attr
->ia_uid
));
600 if (attr
->ia_valid
& ATTR_GID
) {
602 *p
++ = cpu_to_be32(from_kgid(&init_user_ns
, attr
->ia_gid
));
606 if (attr
->ia_valid
& ATTR_SIZE
) {
608 p
= xdr_encode_hyper(p
, (u64
)attr
->ia_size
);
612 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
614 p
= xdr_encode_nfstime3(p
, &attr
->ia_atime
);
615 } else if (attr
->ia_valid
& ATTR_ATIME
) {
620 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
622 xdr_encode_nfstime3(p
, &attr
->ia_mtime
);
623 } else if (attr
->ia_valid
& ATTR_MTIME
) {
648 static int decode_fattr3(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
653 p
= xdr_inline_decode(xdr
, NFS3_fattr_sz
<< 2);
654 if (unlikely(p
== NULL
))
657 p
= xdr_decode_ftype3(p
, &fmode
);
659 fattr
->mode
= (be32_to_cpup(p
++) & ~S_IFMT
) | fmode
;
660 fattr
->nlink
= be32_to_cpup(p
++);
661 fattr
->uid
= make_kuid(&init_user_ns
, be32_to_cpup(p
++));
662 if (!uid_valid(fattr
->uid
))
664 fattr
->gid
= make_kgid(&init_user_ns
, be32_to_cpup(p
++));
665 if (!gid_valid(fattr
->gid
))
668 p
= xdr_decode_size3(p
, &fattr
->size
);
669 p
= xdr_decode_size3(p
, &fattr
->du
.nfs3
.used
);
670 p
= xdr_decode_specdata3(p
, &fattr
->rdev
);
672 p
= xdr_decode_hyper(p
, &fattr
->fsid
.major
);
673 fattr
->fsid
.minor
= 0;
675 p
= xdr_decode_fileid3(p
, &fattr
->fileid
);
676 p
= xdr_decode_nfstime3(p
, &fattr
->atime
);
677 p
= xdr_decode_nfstime3(p
, &fattr
->mtime
);
678 xdr_decode_nfstime3(p
, &fattr
->ctime
);
679 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
681 fattr
->valid
|= NFS_ATTR_FATTR_V3
;
684 dprintk("NFS: returned invalid uid\n");
687 dprintk("NFS: returned invalid gid\n");
690 print_overflow_msg(__func__
, xdr
);
697 * union post_op_attr switch (bool attributes_follow) {
704 static int decode_post_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
708 p
= xdr_inline_decode(xdr
, 4);
709 if (unlikely(p
== NULL
))
712 return decode_fattr3(xdr
, fattr
);
715 print_overflow_msg(__func__
, xdr
);
727 static int decode_wcc_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
731 p
= xdr_inline_decode(xdr
, NFS3_wcc_attr_sz
<< 2);
732 if (unlikely(p
== NULL
))
735 fattr
->valid
|= NFS_ATTR_FATTR_PRESIZE
736 | NFS_ATTR_FATTR_PRECHANGE
737 | NFS_ATTR_FATTR_PREMTIME
738 | NFS_ATTR_FATTR_PRECTIME
;
740 p
= xdr_decode_size3(p
, &fattr
->pre_size
);
741 p
= xdr_decode_nfstime3(p
, &fattr
->pre_mtime
);
742 xdr_decode_nfstime3(p
, &fattr
->pre_ctime
);
743 fattr
->pre_change_attr
= nfs_timespec_to_change_attr(&fattr
->pre_ctime
);
747 print_overflow_msg(__func__
, xdr
);
753 * union pre_op_attr switch (bool attributes_follow) {
755 * wcc_attr attributes;
763 * pre_op_attr before;
764 * post_op_attr after;
767 static int decode_pre_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
771 p
= xdr_inline_decode(xdr
, 4);
772 if (unlikely(p
== NULL
))
775 return decode_wcc_attr(xdr
, fattr
);
778 print_overflow_msg(__func__
, xdr
);
782 static int decode_wcc_data(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
786 error
= decode_pre_op_attr(xdr
, fattr
);
789 error
= decode_post_op_attr(xdr
, fattr
);
797 * union post_op_fh3 switch (bool handle_follows) {
804 static int decode_post_op_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
806 __be32
*p
= xdr_inline_decode(xdr
, 4);
807 if (unlikely(p
== NULL
))
810 return decode_nfs_fh3(xdr
, fh
);
814 print_overflow_msg(__func__
, xdr
);
821 * struct diropargs3 {
826 static void encode_diropargs3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
827 const char *name
, u32 length
)
829 encode_nfs_fh3(xdr
, fh
);
830 encode_filename3(xdr
, name
, length
);
835 * NFSv3 XDR encode functions
837 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
838 * "NFS Version 3 Protocol Specification".
844 * struct GETATTR3args {
848 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst
*req
,
849 struct xdr_stream
*xdr
,
852 const struct nfs_fh
*fh
= data
;
854 encode_nfs_fh3(xdr
, fh
);
860 * union sattrguard3 switch (bool check) {
862 * nfstime3 obj_ctime;
867 * struct SETATTR3args {
869 * sattr3 new_attributes;
873 static void encode_sattrguard3(struct xdr_stream
*xdr
,
874 const struct nfs3_sattrargs
*args
)
879 p
= xdr_reserve_space(xdr
, 4 + 8);
881 xdr_encode_nfstime3(p
, &args
->guardtime
);
883 p
= xdr_reserve_space(xdr
, 4);
888 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst
*req
,
889 struct xdr_stream
*xdr
,
892 const struct nfs3_sattrargs
*args
= data
;
893 encode_nfs_fh3(xdr
, args
->fh
);
894 encode_sattr3(xdr
, args
->sattr
);
895 encode_sattrguard3(xdr
, args
);
901 * struct LOOKUP3args {
905 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst
*req
,
906 struct xdr_stream
*xdr
,
909 const struct nfs3_diropargs
*args
= data
;
911 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
917 * struct ACCESS3args {
922 static void encode_access3args(struct xdr_stream
*xdr
,
923 const struct nfs3_accessargs
*args
)
925 encode_nfs_fh3(xdr
, args
->fh
);
926 encode_uint32(xdr
, args
->access
);
929 static void nfs3_xdr_enc_access3args(struct rpc_rqst
*req
,
930 struct xdr_stream
*xdr
,
933 const struct nfs3_accessargs
*args
= data
;
935 encode_access3args(xdr
, args
);
939 * 3.3.5 READLINK3args
941 * struct READLINK3args {
945 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst
*req
,
946 struct xdr_stream
*xdr
,
949 const struct nfs3_readlinkargs
*args
= data
;
951 encode_nfs_fh3(xdr
, args
->fh
);
952 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
953 args
->pglen
, NFS3_readlinkres_sz
);
965 static void encode_read3args(struct xdr_stream
*xdr
,
966 const struct nfs_pgio_args
*args
)
970 encode_nfs_fh3(xdr
, args
->fh
);
972 p
= xdr_reserve_space(xdr
, 8 + 4);
973 p
= xdr_encode_hyper(p
, args
->offset
);
974 *p
= cpu_to_be32(args
->count
);
977 static void nfs3_xdr_enc_read3args(struct rpc_rqst
*req
,
978 struct xdr_stream
*xdr
,
981 const struct nfs_pgio_args
*args
= data
;
983 encode_read3args(xdr
, args
);
984 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
985 args
->count
, NFS3_readres_sz
);
986 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
998 * struct WRITE3args {
1002 * stable_how stable;
1006 static void encode_write3args(struct xdr_stream
*xdr
,
1007 const struct nfs_pgio_args
*args
)
1011 encode_nfs_fh3(xdr
, args
->fh
);
1013 p
= xdr_reserve_space(xdr
, 8 + 4 + 4 + 4);
1014 p
= xdr_encode_hyper(p
, args
->offset
);
1015 *p
++ = cpu_to_be32(args
->count
);
1016 *p
++ = cpu_to_be32(args
->stable
);
1017 *p
= cpu_to_be32(args
->count
);
1018 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, args
->count
);
1021 static void nfs3_xdr_enc_write3args(struct rpc_rqst
*req
,
1022 struct xdr_stream
*xdr
,
1025 const struct nfs_pgio_args
*args
= data
;
1027 encode_write3args(xdr
, args
);
1028 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1034 * enum createmode3 {
1040 * union createhow3 switch (createmode3 mode) {
1043 * sattr3 obj_attributes;
1048 * struct CREATE3args {
1053 static void encode_createhow3(struct xdr_stream
*xdr
,
1054 const struct nfs3_createargs
*args
)
1056 encode_uint32(xdr
, args
->createmode
);
1057 switch (args
->createmode
) {
1058 case NFS3_CREATE_UNCHECKED
:
1059 case NFS3_CREATE_GUARDED
:
1060 encode_sattr3(xdr
, args
->sattr
);
1062 case NFS3_CREATE_EXCLUSIVE
:
1063 encode_createverf3(xdr
, args
->verifier
);
1070 static void nfs3_xdr_enc_create3args(struct rpc_rqst
*req
,
1071 struct xdr_stream
*xdr
,
1074 const struct nfs3_createargs
*args
= data
;
1076 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1077 encode_createhow3(xdr
, args
);
1083 * struct MKDIR3args {
1085 * sattr3 attributes;
1088 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst
*req
,
1089 struct xdr_stream
*xdr
,
1092 const struct nfs3_mkdirargs
*args
= data
;
1094 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1095 encode_sattr3(xdr
, args
->sattr
);
1099 * 3.3.10 SYMLINK3args
1101 * struct symlinkdata3 {
1102 * sattr3 symlink_attributes;
1103 * nfspath3 symlink_data;
1106 * struct SYMLINK3args {
1108 * symlinkdata3 symlink;
1111 static void encode_symlinkdata3(struct xdr_stream
*xdr
,
1114 const struct nfs3_symlinkargs
*args
= data
;
1116 encode_sattr3(xdr
, args
->sattr
);
1117 encode_nfspath3(xdr
, args
->pages
, args
->pathlen
);
1120 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst
*req
,
1121 struct xdr_stream
*xdr
,
1124 const struct nfs3_symlinkargs
*args
= data
;
1126 encode_diropargs3(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
1127 encode_symlinkdata3(xdr
, args
);
1128 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1134 * struct devicedata3 {
1135 * sattr3 dev_attributes;
1139 * union mknoddata3 switch (ftype3 type) {
1142 * devicedata3 device;
1145 * sattr3 pipe_attributes;
1150 * struct MKNOD3args {
1155 static void encode_devicedata3(struct xdr_stream
*xdr
,
1156 const struct nfs3_mknodargs
*args
)
1158 encode_sattr3(xdr
, args
->sattr
);
1159 encode_specdata3(xdr
, args
->rdev
);
1162 static void encode_mknoddata3(struct xdr_stream
*xdr
,
1163 const struct nfs3_mknodargs
*args
)
1165 encode_ftype3(xdr
, args
->type
);
1166 switch (args
->type
) {
1169 encode_devicedata3(xdr
, args
);
1173 encode_sattr3(xdr
, args
->sattr
);
1183 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst
*req
,
1184 struct xdr_stream
*xdr
,
1187 const struct nfs3_mknodargs
*args
= data
;
1189 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1190 encode_mknoddata3(xdr
, args
);
1194 * 3.3.12 REMOVE3args
1196 * struct REMOVE3args {
1197 * diropargs3 object;
1200 static void nfs3_xdr_enc_remove3args(struct rpc_rqst
*req
,
1201 struct xdr_stream
*xdr
,
1204 const struct nfs_removeargs
*args
= data
;
1206 encode_diropargs3(xdr
, args
->fh
, args
->name
.name
, args
->name
.len
);
1210 * 3.3.14 RENAME3args
1212 * struct RENAME3args {
1217 static void nfs3_xdr_enc_rename3args(struct rpc_rqst
*req
,
1218 struct xdr_stream
*xdr
,
1221 const struct nfs_renameargs
*args
= data
;
1222 const struct qstr
*old
= args
->old_name
;
1223 const struct qstr
*new = args
->new_name
;
1225 encode_diropargs3(xdr
, args
->old_dir
, old
->name
, old
->len
);
1226 encode_diropargs3(xdr
, args
->new_dir
, new->name
, new->len
);
1232 * struct LINK3args {
1237 static void nfs3_xdr_enc_link3args(struct rpc_rqst
*req
,
1238 struct xdr_stream
*xdr
,
1241 const struct nfs3_linkargs
*args
= data
;
1243 encode_nfs_fh3(xdr
, args
->fromfh
);
1244 encode_diropargs3(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
1248 * 3.3.16 READDIR3args
1250 * struct READDIR3args {
1253 * cookieverf3 cookieverf;
1257 static void encode_readdir3args(struct xdr_stream
*xdr
,
1258 const struct nfs3_readdirargs
*args
)
1262 encode_nfs_fh3(xdr
, args
->fh
);
1264 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4);
1265 p
= xdr_encode_cookie3(p
, args
->cookie
);
1266 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1267 *p
= cpu_to_be32(args
->count
);
1270 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst
*req
,
1271 struct xdr_stream
*xdr
,
1274 const struct nfs3_readdirargs
*args
= data
;
1276 encode_readdir3args(xdr
, args
);
1277 prepare_reply_buffer(req
, args
->pages
, 0,
1278 args
->count
, NFS3_readdirres_sz
);
1282 * 3.3.17 READDIRPLUS3args
1284 * struct READDIRPLUS3args {
1287 * cookieverf3 cookieverf;
1292 static void encode_readdirplus3args(struct xdr_stream
*xdr
,
1293 const struct nfs3_readdirargs
*args
)
1297 encode_nfs_fh3(xdr
, args
->fh
);
1299 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4 + 4);
1300 p
= xdr_encode_cookie3(p
, args
->cookie
);
1301 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1304 * readdirplus: need dircount + buffer size.
1305 * We just make sure we make dircount big enough
1307 *p
++ = cpu_to_be32(args
->count
>> 3);
1309 *p
= cpu_to_be32(args
->count
);
1312 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst
*req
,
1313 struct xdr_stream
*xdr
,
1316 const struct nfs3_readdirargs
*args
= data
;
1318 encode_readdirplus3args(xdr
, args
);
1319 prepare_reply_buffer(req
, args
->pages
, 0,
1320 args
->count
, NFS3_readdirres_sz
);
1324 * 3.3.21 COMMIT3args
1326 * struct COMMIT3args {
1332 static void encode_commit3args(struct xdr_stream
*xdr
,
1333 const struct nfs_commitargs
*args
)
1337 encode_nfs_fh3(xdr
, args
->fh
);
1339 p
= xdr_reserve_space(xdr
, 8 + 4);
1340 p
= xdr_encode_hyper(p
, args
->offset
);
1341 *p
= cpu_to_be32(args
->count
);
1344 static void nfs3_xdr_enc_commit3args(struct rpc_rqst
*req
,
1345 struct xdr_stream
*xdr
,
1348 const struct nfs_commitargs
*args
= data
;
1350 encode_commit3args(xdr
, args
);
1353 #ifdef CONFIG_NFS_V3_ACL
1355 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst
*req
,
1356 struct xdr_stream
*xdr
,
1359 const struct nfs3_getaclargs
*args
= data
;
1361 encode_nfs_fh3(xdr
, args
->fh
);
1362 encode_uint32(xdr
, args
->mask
);
1363 if (args
->mask
& (NFS_ACL
| NFS_DFACL
))
1364 prepare_reply_buffer(req
, args
->pages
, 0,
1365 NFSACL_MAXPAGES
<< PAGE_SHIFT
,
1369 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst
*req
,
1370 struct xdr_stream
*xdr
,
1373 const struct nfs3_setaclargs
*args
= data
;
1377 encode_nfs_fh3(xdr
, NFS_FH(args
->inode
));
1378 encode_uint32(xdr
, args
->mask
);
1380 base
= req
->rq_slen
;
1381 if (args
->npages
!= 0)
1382 xdr_write_pages(xdr
, args
->pages
, 0, args
->len
);
1384 xdr_reserve_space(xdr
, args
->len
);
1386 error
= nfsacl_encode(xdr
->buf
, base
, args
->inode
,
1387 (args
->mask
& NFS_ACL
) ?
1388 args
->acl_access
: NULL
, 1, 0);
1389 /* FIXME: this is just broken */
1391 error
= nfsacl_encode(xdr
->buf
, base
+ error
, args
->inode
,
1392 (args
->mask
& NFS_DFACL
) ?
1393 args
->acl_default
: NULL
, 1,
1398 #endif /* CONFIG_NFS_V3_ACL */
1401 * NFSv3 XDR decode functions
1403 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1404 * "NFS Version 3 Protocol Specification".
1410 * struct GETATTR3resok {
1411 * fattr3 obj_attributes;
1414 * union GETATTR3res switch (nfsstat3 status) {
1416 * GETATTR3resok resok;
1421 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst
*req
,
1422 struct xdr_stream
*xdr
,
1425 enum nfs_stat status
;
1428 error
= decode_nfsstat3(xdr
, &status
);
1429 if (unlikely(error
))
1431 if (status
!= NFS3_OK
)
1433 error
= decode_fattr3(xdr
, result
);
1437 return nfs3_stat_to_errno(status
);
1443 * struct SETATTR3resok {
1447 * struct SETATTR3resfail {
1451 * union SETATTR3res switch (nfsstat3 status) {
1453 * SETATTR3resok resok;
1455 * SETATTR3resfail resfail;
1458 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst
*req
,
1459 struct xdr_stream
*xdr
,
1462 enum nfs_stat status
;
1465 error
= decode_nfsstat3(xdr
, &status
);
1466 if (unlikely(error
))
1468 error
= decode_wcc_data(xdr
, result
);
1469 if (unlikely(error
))
1471 if (status
!= NFS3_OK
)
1476 return nfs3_stat_to_errno(status
);
1482 * struct LOOKUP3resok {
1484 * post_op_attr obj_attributes;
1485 * post_op_attr dir_attributes;
1488 * struct LOOKUP3resfail {
1489 * post_op_attr dir_attributes;
1492 * union LOOKUP3res switch (nfsstat3 status) {
1494 * LOOKUP3resok resok;
1496 * LOOKUP3resfail resfail;
1499 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst
*req
,
1500 struct xdr_stream
*xdr
,
1503 struct nfs3_diropres
*result
= data
;
1504 enum nfs_stat status
;
1507 error
= decode_nfsstat3(xdr
, &status
);
1508 if (unlikely(error
))
1510 if (status
!= NFS3_OK
)
1512 error
= decode_nfs_fh3(xdr
, result
->fh
);
1513 if (unlikely(error
))
1515 error
= decode_post_op_attr(xdr
, result
->fattr
);
1516 if (unlikely(error
))
1518 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1522 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1523 if (unlikely(error
))
1525 return nfs3_stat_to_errno(status
);
1531 * struct ACCESS3resok {
1532 * post_op_attr obj_attributes;
1536 * struct ACCESS3resfail {
1537 * post_op_attr obj_attributes;
1540 * union ACCESS3res switch (nfsstat3 status) {
1542 * ACCESS3resok resok;
1544 * ACCESS3resfail resfail;
1547 static int nfs3_xdr_dec_access3res(struct rpc_rqst
*req
,
1548 struct xdr_stream
*xdr
,
1551 struct nfs3_accessres
*result
= data
;
1552 enum nfs_stat status
;
1555 error
= decode_nfsstat3(xdr
, &status
);
1556 if (unlikely(error
))
1558 error
= decode_post_op_attr(xdr
, result
->fattr
);
1559 if (unlikely(error
))
1561 if (status
!= NFS3_OK
)
1563 error
= decode_uint32(xdr
, &result
->access
);
1567 return nfs3_stat_to_errno(status
);
1571 * 3.3.5 READLINK3res
1573 * struct READLINK3resok {
1574 * post_op_attr symlink_attributes;
1578 * struct READLINK3resfail {
1579 * post_op_attr symlink_attributes;
1582 * union READLINK3res switch (nfsstat3 status) {
1584 * READLINK3resok resok;
1586 * READLINK3resfail resfail;
1589 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst
*req
,
1590 struct xdr_stream
*xdr
,
1593 enum nfs_stat status
;
1596 error
= decode_nfsstat3(xdr
, &status
);
1597 if (unlikely(error
))
1599 error
= decode_post_op_attr(xdr
, result
);
1600 if (unlikely(error
))
1602 if (status
!= NFS3_OK
)
1604 error
= decode_nfspath3(xdr
);
1608 return nfs3_stat_to_errno(status
);
1614 * struct READ3resok {
1615 * post_op_attr file_attributes;
1621 * struct READ3resfail {
1622 * post_op_attr file_attributes;
1625 * union READ3res switch (nfsstat3 status) {
1629 * READ3resfail resfail;
1632 static int decode_read3resok(struct xdr_stream
*xdr
,
1633 struct nfs_pgio_res
*result
)
1635 u32 eof
, count
, ocount
, recvd
;
1638 p
= xdr_inline_decode(xdr
, 4 + 4 + 4);
1639 if (unlikely(p
== NULL
))
1641 count
= be32_to_cpup(p
++);
1642 eof
= be32_to_cpup(p
++);
1643 ocount
= be32_to_cpup(p
++);
1644 if (unlikely(ocount
!= count
))
1646 recvd
= xdr_read_pages(xdr
, count
);
1647 if (unlikely(count
> recvd
))
1651 result
->count
= count
;
1654 dprintk("NFS: READ count doesn't match length of opaque: "
1655 "count %u != ocount %u\n", count
, ocount
);
1658 dprintk("NFS: server cheating in read result: "
1659 "count %u > recvd %u\n", count
, recvd
);
1664 print_overflow_msg(__func__
, xdr
);
1668 static int nfs3_xdr_dec_read3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1671 struct nfs_pgio_res
*result
= data
;
1672 enum nfs_stat status
;
1675 error
= decode_nfsstat3(xdr
, &status
);
1676 if (unlikely(error
))
1678 error
= decode_post_op_attr(xdr
, result
->fattr
);
1679 if (unlikely(error
))
1681 result
->op_status
= status
;
1682 if (status
!= NFS3_OK
)
1684 error
= decode_read3resok(xdr
, result
);
1688 return nfs3_stat_to_errno(status
);
1700 * struct WRITE3resok {
1701 * wcc_data file_wcc;
1703 * stable_how committed;
1707 * struct WRITE3resfail {
1708 * wcc_data file_wcc;
1711 * union WRITE3res switch (nfsstat3 status) {
1713 * WRITE3resok resok;
1715 * WRITE3resfail resfail;
1718 static int decode_write3resok(struct xdr_stream
*xdr
,
1719 struct nfs_pgio_res
*result
)
1723 p
= xdr_inline_decode(xdr
, 4 + 4);
1724 if (unlikely(p
== NULL
))
1726 result
->count
= be32_to_cpup(p
++);
1727 result
->verf
->committed
= be32_to_cpup(p
++);
1728 if (unlikely(result
->verf
->committed
> NFS_FILE_SYNC
))
1730 if (decode_writeverf3(xdr
, &result
->verf
->verifier
))
1732 return result
->count
;
1734 dprintk("NFS: bad stable_how value: %u\n", result
->verf
->committed
);
1737 print_overflow_msg(__func__
, xdr
);
1742 static int nfs3_xdr_dec_write3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1745 struct nfs_pgio_res
*result
= data
;
1746 enum nfs_stat status
;
1749 error
= decode_nfsstat3(xdr
, &status
);
1750 if (unlikely(error
))
1752 error
= decode_wcc_data(xdr
, result
->fattr
);
1753 if (unlikely(error
))
1755 result
->op_status
= status
;
1756 if (status
!= NFS3_OK
)
1758 error
= decode_write3resok(xdr
, result
);
1762 return nfs3_stat_to_errno(status
);
1768 * struct CREATE3resok {
1770 * post_op_attr obj_attributes;
1774 * struct CREATE3resfail {
1778 * union CREATE3res switch (nfsstat3 status) {
1780 * CREATE3resok resok;
1782 * CREATE3resfail resfail;
1785 static int decode_create3resok(struct xdr_stream
*xdr
,
1786 struct nfs3_diropres
*result
)
1790 error
= decode_post_op_fh3(xdr
, result
->fh
);
1791 if (unlikely(error
))
1793 error
= decode_post_op_attr(xdr
, result
->fattr
);
1794 if (unlikely(error
))
1796 /* The server isn't required to return a file handle.
1797 * If it didn't, force the client to perform a LOOKUP
1798 * to determine the correct file handle and attribute
1799 * values for the new object. */
1800 if (result
->fh
->size
== 0)
1801 result
->fattr
->valid
= 0;
1802 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1807 static int nfs3_xdr_dec_create3res(struct rpc_rqst
*req
,
1808 struct xdr_stream
*xdr
,
1811 struct nfs3_diropres
*result
= data
;
1812 enum nfs_stat status
;
1815 error
= decode_nfsstat3(xdr
, &status
);
1816 if (unlikely(error
))
1818 if (status
!= NFS3_OK
)
1820 error
= decode_create3resok(xdr
, result
);
1824 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1825 if (unlikely(error
))
1827 return nfs3_stat_to_errno(status
);
1833 * struct REMOVE3resok {
1837 * struct REMOVE3resfail {
1841 * union REMOVE3res switch (nfsstat3 status) {
1843 * REMOVE3resok resok;
1845 * REMOVE3resfail resfail;
1848 static int nfs3_xdr_dec_remove3res(struct rpc_rqst
*req
,
1849 struct xdr_stream
*xdr
,
1852 struct nfs_removeres
*result
= data
;
1853 enum nfs_stat status
;
1856 error
= decode_nfsstat3(xdr
, &status
);
1857 if (unlikely(error
))
1859 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1860 if (unlikely(error
))
1862 if (status
!= NFS3_OK
)
1867 return nfs3_stat_to_errno(status
);
1873 * struct RENAME3resok {
1874 * wcc_data fromdir_wcc;
1875 * wcc_data todir_wcc;
1878 * struct RENAME3resfail {
1879 * wcc_data fromdir_wcc;
1880 * wcc_data todir_wcc;
1883 * union RENAME3res switch (nfsstat3 status) {
1885 * RENAME3resok resok;
1887 * RENAME3resfail resfail;
1890 static int nfs3_xdr_dec_rename3res(struct rpc_rqst
*req
,
1891 struct xdr_stream
*xdr
,
1894 struct nfs_renameres
*result
= data
;
1895 enum nfs_stat status
;
1898 error
= decode_nfsstat3(xdr
, &status
);
1899 if (unlikely(error
))
1901 error
= decode_wcc_data(xdr
, result
->old_fattr
);
1902 if (unlikely(error
))
1904 error
= decode_wcc_data(xdr
, result
->new_fattr
);
1905 if (unlikely(error
))
1907 if (status
!= NFS3_OK
)
1912 return nfs3_stat_to_errno(status
);
1918 * struct LINK3resok {
1919 * post_op_attr file_attributes;
1920 * wcc_data linkdir_wcc;
1923 * struct LINK3resfail {
1924 * post_op_attr file_attributes;
1925 * wcc_data linkdir_wcc;
1928 * union LINK3res switch (nfsstat3 status) {
1932 * LINK3resfail resfail;
1935 static int nfs3_xdr_dec_link3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1938 struct nfs3_linkres
*result
= data
;
1939 enum nfs_stat status
;
1942 error
= decode_nfsstat3(xdr
, &status
);
1943 if (unlikely(error
))
1945 error
= decode_post_op_attr(xdr
, result
->fattr
);
1946 if (unlikely(error
))
1948 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1949 if (unlikely(error
))
1951 if (status
!= NFS3_OK
)
1956 return nfs3_stat_to_errno(status
);
1960 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1961 * the local page cache
1962 * @xdr: XDR stream where entry resides
1963 * @entry: buffer to fill in with entry data
1964 * @plus: boolean indicating whether this should be a readdirplus entry
1966 * Returns zero if successful, otherwise a negative errno value is
1969 * This function is not invoked during READDIR reply decoding, but
1970 * rather whenever an application invokes the getdents(2) system call
1971 * on a directory already in our cache.
1979 * fhandle3 filehandle;
1980 * post_op_attr3 attributes;
1981 * entry3 *nextentry;
1985 * struct entryplus3 {
1989 * post_op_attr name_attributes;
1990 * post_op_fh3 name_handle;
1991 * entryplus3 *nextentry;
1994 int nfs3_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
1997 struct nfs_entry old
= *entry
;
2001 p
= xdr_inline_decode(xdr
, 4);
2002 if (unlikely(p
== NULL
))
2004 if (*p
== xdr_zero
) {
2005 p
= xdr_inline_decode(xdr
, 4);
2006 if (unlikely(p
== NULL
))
2014 error
= decode_fileid3(xdr
, &entry
->ino
);
2015 if (unlikely(error
))
2018 error
= decode_inline_filename3(xdr
, &entry
->name
, &entry
->len
);
2019 if (unlikely(error
))
2022 entry
->prev_cookie
= entry
->cookie
;
2023 error
= decode_cookie3(xdr
, &entry
->cookie
);
2024 if (unlikely(error
))
2027 entry
->d_type
= DT_UNKNOWN
;
2030 entry
->fattr
->valid
= 0;
2031 error
= decode_post_op_attr(xdr
, entry
->fattr
);
2032 if (unlikely(error
))
2034 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_V3
)
2035 entry
->d_type
= nfs_umode_to_dtype(entry
->fattr
->mode
);
2037 if (entry
->fattr
->fileid
!= entry
->ino
) {
2038 entry
->fattr
->mounted_on_fileid
= entry
->ino
;
2039 entry
->fattr
->valid
|= NFS_ATTR_FATTR_MOUNTED_ON_FILEID
;
2042 /* In fact, a post_op_fh3: */
2043 p
= xdr_inline_decode(xdr
, 4);
2044 if (unlikely(p
== NULL
))
2046 if (*p
!= xdr_zero
) {
2047 error
= decode_nfs_fh3(xdr
, entry
->fh
);
2048 if (unlikely(error
)) {
2049 if (error
== -E2BIG
)
2054 zero_nfs_fh3(entry
->fh
);
2060 print_overflow_msg(__func__
, xdr
);
2063 dprintk("NFS: directory entry contains invalid file handle\n");
2069 * 3.3.16 READDIR3res
2076 * struct READDIR3resok {
2077 * post_op_attr dir_attributes;
2078 * cookieverf3 cookieverf;
2082 * struct READDIR3resfail {
2083 * post_op_attr dir_attributes;
2086 * union READDIR3res switch (nfsstat3 status) {
2088 * READDIR3resok resok;
2090 * READDIR3resfail resfail;
2093 * Read the directory contents into the page cache, but otherwise
2094 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2095 * during subsequent nfs_readdir() calls.
2097 static int decode_dirlist3(struct xdr_stream
*xdr
)
2099 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
2102 static int decode_readdir3resok(struct xdr_stream
*xdr
,
2103 struct nfs3_readdirres
*result
)
2107 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2108 if (unlikely(error
))
2110 /* XXX: do we need to check if result->verf != NULL ? */
2111 error
= decode_cookieverf3(xdr
, result
->verf
);
2112 if (unlikely(error
))
2114 error
= decode_dirlist3(xdr
);
2119 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst
*req
,
2120 struct xdr_stream
*xdr
,
2123 struct nfs3_readdirres
*result
= data
;
2124 enum nfs_stat status
;
2127 error
= decode_nfsstat3(xdr
, &status
);
2128 if (unlikely(error
))
2130 if (status
!= NFS3_OK
)
2132 error
= decode_readdir3resok(xdr
, result
);
2136 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2137 if (unlikely(error
))
2139 return nfs3_stat_to_errno(status
);
2145 * struct FSSTAT3resok {
2146 * post_op_attr obj_attributes;
2156 * struct FSSTAT3resfail {
2157 * post_op_attr obj_attributes;
2160 * union FSSTAT3res switch (nfsstat3 status) {
2162 * FSSTAT3resok resok;
2164 * FSSTAT3resfail resfail;
2167 static int decode_fsstat3resok(struct xdr_stream
*xdr
,
2168 struct nfs_fsstat
*result
)
2172 p
= xdr_inline_decode(xdr
, 8 * 6 + 4);
2173 if (unlikely(p
== NULL
))
2175 p
= xdr_decode_size3(p
, &result
->tbytes
);
2176 p
= xdr_decode_size3(p
, &result
->fbytes
);
2177 p
= xdr_decode_size3(p
, &result
->abytes
);
2178 p
= xdr_decode_size3(p
, &result
->tfiles
);
2179 p
= xdr_decode_size3(p
, &result
->ffiles
);
2180 xdr_decode_size3(p
, &result
->afiles
);
2181 /* ignore invarsec */
2184 print_overflow_msg(__func__
, xdr
);
2188 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst
*req
,
2189 struct xdr_stream
*xdr
,
2192 struct nfs_fsstat
*result
= data
;
2193 enum nfs_stat status
;
2196 error
= decode_nfsstat3(xdr
, &status
);
2197 if (unlikely(error
))
2199 error
= decode_post_op_attr(xdr
, result
->fattr
);
2200 if (unlikely(error
))
2202 if (status
!= NFS3_OK
)
2204 error
= decode_fsstat3resok(xdr
, result
);
2208 return nfs3_stat_to_errno(status
);
2214 * struct FSINFO3resok {
2215 * post_op_attr obj_attributes;
2223 * size3 maxfilesize;
2224 * nfstime3 time_delta;
2225 * uint32 properties;
2228 * struct FSINFO3resfail {
2229 * post_op_attr obj_attributes;
2232 * union FSINFO3res switch (nfsstat3 status) {
2234 * FSINFO3resok resok;
2236 * FSINFO3resfail resfail;
2239 static int decode_fsinfo3resok(struct xdr_stream
*xdr
,
2240 struct nfs_fsinfo
*result
)
2244 p
= xdr_inline_decode(xdr
, 4 * 7 + 8 + 8 + 4);
2245 if (unlikely(p
== NULL
))
2247 result
->rtmax
= be32_to_cpup(p
++);
2248 result
->rtpref
= be32_to_cpup(p
++);
2249 result
->rtmult
= be32_to_cpup(p
++);
2250 result
->wtmax
= be32_to_cpup(p
++);
2251 result
->wtpref
= be32_to_cpup(p
++);
2252 result
->wtmult
= be32_to_cpup(p
++);
2253 result
->dtpref
= be32_to_cpup(p
++);
2254 p
= xdr_decode_size3(p
, &result
->maxfilesize
);
2255 xdr_decode_nfstime3(p
, &result
->time_delta
);
2257 /* ignore properties */
2258 result
->lease_time
= 0;
2261 print_overflow_msg(__func__
, xdr
);
2265 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst
*req
,
2266 struct xdr_stream
*xdr
,
2269 struct nfs_fsinfo
*result
= data
;
2270 enum nfs_stat status
;
2273 error
= decode_nfsstat3(xdr
, &status
);
2274 if (unlikely(error
))
2276 error
= decode_post_op_attr(xdr
, result
->fattr
);
2277 if (unlikely(error
))
2279 if (status
!= NFS3_OK
)
2281 error
= decode_fsinfo3resok(xdr
, result
);
2285 return nfs3_stat_to_errno(status
);
2289 * 3.3.20 PATHCONF3res
2291 * struct PATHCONF3resok {
2292 * post_op_attr obj_attributes;
2296 * bool chown_restricted;
2297 * bool case_insensitive;
2298 * bool case_preserving;
2301 * struct PATHCONF3resfail {
2302 * post_op_attr obj_attributes;
2305 * union PATHCONF3res switch (nfsstat3 status) {
2307 * PATHCONF3resok resok;
2309 * PATHCONF3resfail resfail;
2312 static int decode_pathconf3resok(struct xdr_stream
*xdr
,
2313 struct nfs_pathconf
*result
)
2317 p
= xdr_inline_decode(xdr
, 4 * 6);
2318 if (unlikely(p
== NULL
))
2320 result
->max_link
= be32_to_cpup(p
++);
2321 result
->max_namelen
= be32_to_cpup(p
);
2322 /* ignore remaining fields */
2325 print_overflow_msg(__func__
, xdr
);
2329 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst
*req
,
2330 struct xdr_stream
*xdr
,
2333 struct nfs_pathconf
*result
= data
;
2334 enum nfs_stat status
;
2337 error
= decode_nfsstat3(xdr
, &status
);
2338 if (unlikely(error
))
2340 error
= decode_post_op_attr(xdr
, result
->fattr
);
2341 if (unlikely(error
))
2343 if (status
!= NFS3_OK
)
2345 error
= decode_pathconf3resok(xdr
, result
);
2349 return nfs3_stat_to_errno(status
);
2355 * struct COMMIT3resok {
2356 * wcc_data file_wcc;
2360 * struct COMMIT3resfail {
2361 * wcc_data file_wcc;
2364 * union COMMIT3res switch (nfsstat3 status) {
2366 * COMMIT3resok resok;
2368 * COMMIT3resfail resfail;
2371 static int nfs3_xdr_dec_commit3res(struct rpc_rqst
*req
,
2372 struct xdr_stream
*xdr
,
2375 struct nfs_commitres
*result
= data
;
2376 struct nfs_writeverf
*verf
= result
->verf
;
2377 enum nfs_stat status
;
2380 error
= decode_nfsstat3(xdr
, &status
);
2381 if (unlikely(error
))
2383 error
= decode_wcc_data(xdr
, result
->fattr
);
2384 if (unlikely(error
))
2386 result
->op_status
= status
;
2387 if (status
!= NFS3_OK
)
2389 error
= decode_writeverf3(xdr
, &verf
->verifier
);
2391 verf
->committed
= NFS_FILE_SYNC
;
2395 return nfs3_stat_to_errno(status
);
2398 #ifdef CONFIG_NFS_V3_ACL
2400 static inline int decode_getacl3resok(struct xdr_stream
*xdr
,
2401 struct nfs3_getaclres
*result
)
2403 struct posix_acl
**acl
;
2404 unsigned int *aclcnt
;
2408 error
= decode_post_op_attr(xdr
, result
->fattr
);
2409 if (unlikely(error
))
2411 error
= decode_uint32(xdr
, &result
->mask
);
2412 if (unlikely(error
))
2415 if (result
->mask
& ~(NFS_ACL
|NFS_ACLCNT
|NFS_DFACL
|NFS_DFACLCNT
))
2418 hdrlen
= xdr_stream_pos(xdr
);
2421 if (result
->mask
& NFS_ACL
)
2422 acl
= &result
->acl_access
;
2424 if (result
->mask
& NFS_ACLCNT
)
2425 aclcnt
= &result
->acl_access_count
;
2426 error
= nfsacl_decode(xdr
->buf
, hdrlen
, aclcnt
, acl
);
2427 if (unlikely(error
<= 0))
2431 if (result
->mask
& NFS_DFACL
)
2432 acl
= &result
->acl_default
;
2434 if (result
->mask
& NFS_DFACLCNT
)
2435 aclcnt
= &result
->acl_default_count
;
2436 error
= nfsacl_decode(xdr
->buf
, hdrlen
+ error
, aclcnt
, acl
);
2437 if (unlikely(error
<= 0))
2444 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst
*req
,
2445 struct xdr_stream
*xdr
,
2448 enum nfs_stat status
;
2451 error
= decode_nfsstat3(xdr
, &status
);
2452 if (unlikely(error
))
2454 if (status
!= NFS3_OK
)
2456 error
= decode_getacl3resok(xdr
, result
);
2460 return nfs3_stat_to_errno(status
);
2463 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst
*req
,
2464 struct xdr_stream
*xdr
,
2467 enum nfs_stat status
;
2470 error
= decode_nfsstat3(xdr
, &status
);
2471 if (unlikely(error
))
2473 if (status
!= NFS3_OK
)
2475 error
= decode_post_op_attr(xdr
, result
);
2479 return nfs3_stat_to_errno(status
);
2482 #endif /* CONFIG_NFS_V3_ACL */
2486 * We need to translate between nfs status return values and
2487 * the local errno values which may not be the same.
2489 static const struct {
2494 { NFSERR_PERM
, -EPERM
},
2495 { NFSERR_NOENT
, -ENOENT
},
2496 { NFSERR_IO
, -errno_NFSERR_IO
},
2497 { NFSERR_NXIO
, -ENXIO
},
2498 /* { NFSERR_EAGAIN, -EAGAIN }, */
2499 { NFSERR_ACCES
, -EACCES
},
2500 { NFSERR_EXIST
, -EEXIST
},
2501 { NFSERR_XDEV
, -EXDEV
},
2502 { NFSERR_NODEV
, -ENODEV
},
2503 { NFSERR_NOTDIR
, -ENOTDIR
},
2504 { NFSERR_ISDIR
, -EISDIR
},
2505 { NFSERR_INVAL
, -EINVAL
},
2506 { NFSERR_FBIG
, -EFBIG
},
2507 { NFSERR_NOSPC
, -ENOSPC
},
2508 { NFSERR_ROFS
, -EROFS
},
2509 { NFSERR_MLINK
, -EMLINK
},
2510 { NFSERR_NAMETOOLONG
, -ENAMETOOLONG
},
2511 { NFSERR_NOTEMPTY
, -ENOTEMPTY
},
2512 { NFSERR_DQUOT
, -EDQUOT
},
2513 { NFSERR_STALE
, -ESTALE
},
2514 { NFSERR_REMOTE
, -EREMOTE
},
2516 { NFSERR_WFLUSH
, -EWFLUSH
},
2518 { NFSERR_BADHANDLE
, -EBADHANDLE
},
2519 { NFSERR_NOT_SYNC
, -ENOTSYNC
},
2520 { NFSERR_BAD_COOKIE
, -EBADCOOKIE
},
2521 { NFSERR_NOTSUPP
, -ENOTSUPP
},
2522 { NFSERR_TOOSMALL
, -ETOOSMALL
},
2523 { NFSERR_SERVERFAULT
, -EREMOTEIO
},
2524 { NFSERR_BADTYPE
, -EBADTYPE
},
2525 { NFSERR_JUKEBOX
, -EJUKEBOX
},
2530 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2531 * @status: NFS status code to convert
2533 * Returns a local errno value, or -EIO if the NFS status code is
2534 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2536 static int nfs3_stat_to_errno(enum nfs_stat status
)
2540 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
2541 if (nfs_errtbl
[i
].stat
== (int)status
)
2542 return nfs_errtbl
[i
].errno
;
2544 dprintk("NFS: Unrecognized nfs status value: %u\n", status
);
2545 return nfs_errtbl
[i
].errno
;
2549 #define PROC(proc, argtype, restype, timer) \
2550 [NFS3PROC_##proc] = { \
2551 .p_proc = NFS3PROC_##proc, \
2552 .p_encode = nfs3_xdr_enc_##argtype##3args, \
2553 .p_decode = nfs3_xdr_dec_##restype##3res, \
2554 .p_arglen = NFS3_##argtype##args_sz, \
2555 .p_replen = NFS3_##restype##res_sz, \
2557 .p_statidx = NFS3PROC_##proc, \
2561 const struct rpc_procinfo nfs3_procedures
[] = {
2562 PROC(GETATTR
, getattr
, getattr
, 1),
2563 PROC(SETATTR
, setattr
, setattr
, 0),
2564 PROC(LOOKUP
, lookup
, lookup
, 2),
2565 PROC(ACCESS
, access
, access
, 1),
2566 PROC(READLINK
, readlink
, readlink
, 3),
2567 PROC(READ
, read
, read
, 3),
2568 PROC(WRITE
, write
, write
, 4),
2569 PROC(CREATE
, create
, create
, 0),
2570 PROC(MKDIR
, mkdir
, create
, 0),
2571 PROC(SYMLINK
, symlink
, create
, 0),
2572 PROC(MKNOD
, mknod
, create
, 0),
2573 PROC(REMOVE
, remove
, remove
, 0),
2574 PROC(RMDIR
, lookup
, setattr
, 0),
2575 PROC(RENAME
, rename
, rename
, 0),
2576 PROC(LINK
, link
, link
, 0),
2577 PROC(READDIR
, readdir
, readdir
, 3),
2578 PROC(READDIRPLUS
, readdirplus
, readdir
, 3),
2579 PROC(FSSTAT
, getattr
, fsstat
, 0),
2580 PROC(FSINFO
, getattr
, fsinfo
, 0),
2581 PROC(PATHCONF
, getattr
, pathconf
, 0),
2582 PROC(COMMIT
, commit
, commit
, 5),
2585 static unsigned int nfs_version3_counts
[ARRAY_SIZE(nfs3_procedures
)];
2586 const struct rpc_version nfs_version3
= {
2588 .nrprocs
= ARRAY_SIZE(nfs3_procedures
),
2589 .procs
= nfs3_procedures
,
2590 .counts
= nfs_version3_counts
,
2593 #ifdef CONFIG_NFS_V3_ACL
2594 static const struct rpc_procinfo nfs3_acl_procedures
[] = {
2595 [ACLPROC3_GETACL
] = {
2596 .p_proc
= ACLPROC3_GETACL
,
2597 .p_encode
= nfs3_xdr_enc_getacl3args
,
2598 .p_decode
= nfs3_xdr_dec_getacl3res
,
2599 .p_arglen
= ACL3_getaclargs_sz
,
2600 .p_replen
= ACL3_getaclres_sz
,
2604 [ACLPROC3_SETACL
] = {
2605 .p_proc
= ACLPROC3_SETACL
,
2606 .p_encode
= nfs3_xdr_enc_setacl3args
,
2607 .p_decode
= nfs3_xdr_dec_setacl3res
,
2608 .p_arglen
= ACL3_setaclargs_sz
,
2609 .p_replen
= ACL3_setaclres_sz
,
2615 static unsigned int nfs3_acl_counts
[ARRAY_SIZE(nfs3_acl_procedures
)];
2616 const struct rpc_version nfsacl_version3
= {
2618 .nrprocs
= ARRAY_SIZE(nfs3_acl_procedures
),
2619 .procs
= nfs3_acl_procedures
,
2620 .counts
= nfs3_acl_counts
,
2622 #endif /* CONFIG_NFS_V3_ACL */