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_fhandle_sz (1+16)
37 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
38 #define NFS3_post_op_fh_sz (1+NFS3_fh_sz)
39 #define NFS3_sattr_sz (15)
40 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
41 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
42 #define NFS3_fattr_sz (21)
43 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
44 #define NFS3_wcc_attr_sz (6)
45 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
46 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
47 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
48 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
50 #define NFS3_getattrargs_sz (NFS3_fh_sz)
51 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
52 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz)
53 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
54 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
55 #define NFS3_readargs_sz (NFS3_fh_sz+3)
56 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
57 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
58 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
59 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
60 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
61 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
62 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
63 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
64 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
65 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
66 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
68 #define NFS3_getattrres_sz (1+NFS3_fattr_sz)
69 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz)
70 #define NFS3_removeres_sz (NFS3_setattrres_sz)
71 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
72 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
73 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+1)
74 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3+1)
75 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
76 #define NFS3_createres_sz (1+NFS3_post_op_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
77 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
78 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
79 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2+1)
80 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
81 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
82 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
83 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
85 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
86 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \
87 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
88 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \
89 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+1)
90 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
92 static int nfs3_stat_to_errno(enum nfs_stat);
95 * Map file type to S_IFMT bits
97 static const umode_t nfs_type2fmt[] = {
104 [NF3SOCK] = S_IFSOCK,
108 static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt)
110 if (clnt && clnt->cl_cred)
111 return clnt->cl_cred->user_ns;
112 return &init_user_ns;
115 static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp)
118 return rpc_userns(rqstp->rq_task->tk_client);
119 return &init_user_ns;
123 * Encode/decode NFSv3 basic data types
125 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
126 * "NFS Version 3 Protocol Specification".
128 * Not all basic data types have their own encoding and decoding
129 * functions. For run-time efficiency, some data types are encoded
133 static void encode_uint32(struct xdr_stream *xdr, u32 value)
135 __be32 *p = xdr_reserve_space(xdr, 4);
136 *p = cpu_to_be32(value);
139 static int decode_uint32(struct xdr_stream *xdr, u32 *value)
143 p = xdr_inline_decode(xdr, 4);
146 *value = be32_to_cpup(p);
150 static int decode_uint64(struct xdr_stream *xdr, u64 *value)
154 p = xdr_inline_decode(xdr, 8);
157 xdr_decode_hyper(p, value);
164 * typedef uint64 fileid3;
166 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
168 return xdr_decode_hyper(p, fileid);
171 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
173 return decode_uint64(xdr, fileid);
179 * typedef string filename3<>;
181 static void encode_filename3(struct xdr_stream *xdr,
182 const char *name, u32 length)
186 WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
187 p = xdr_reserve_space(xdr, 4 + length);
188 xdr_encode_opaque(p, name, length);
191 static int decode_inline_filename3(struct xdr_stream *xdr,
192 const char **name, u32 *length)
197 p = xdr_inline_decode(xdr, 4);
200 count = be32_to_cpup(p);
201 if (count > NFS3_MAXNAMLEN)
202 goto out_nametoolong;
203 p = xdr_inline_decode(xdr, count);
206 *name = (const char *)p;
211 dprintk("NFS: returned filename too long: %u\n", count);
212 return -ENAMETOOLONG;
218 * typedef string nfspath3<>;
220 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
223 encode_uint32(xdr, length);
224 xdr_write_pages(xdr, pages, 0, length);
227 static int decode_nfspath3(struct xdr_stream *xdr)
232 p = xdr_inline_decode(xdr, 4);
235 count = be32_to_cpup(p);
236 if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
237 goto out_nametoolong;
238 recvd = xdr_read_pages(xdr, count);
239 if (unlikely(count > recvd))
241 xdr_terminate_string(xdr->buf, count);
245 dprintk("NFS: returned pathname too long: %u\n", count);
246 return -ENAMETOOLONG;
248 dprintk("NFS: server cheating in pathname result: "
249 "count %u > recvd %u\n", count, recvd);
256 * typedef uint64 cookie3
258 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
260 return xdr_encode_hyper(p, cookie);
263 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
265 return decode_uint64(xdr, cookie);
271 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
273 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
275 memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
276 return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
279 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
283 p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
286 memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
293 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
295 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
299 p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
300 memcpy(p, verifier, NFS3_CREATEVERFSIZE);
303 static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
307 p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
310 memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
317 * typedef uint64 size3;
319 static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
321 return xdr_decode_hyper(p, size);
332 #define NFS3_OK NFS_OK
334 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
338 p = xdr_inline_decode(xdr, 4);
341 if (unlikely(*p != cpu_to_be32(NFS3_OK)))
346 *status = be32_to_cpup(p);
347 trace_nfs_xdr_status(xdr, (int)*status);
364 static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
366 encode_uint32(xdr, type);
369 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
373 type = be32_to_cpup(p++);
376 *mode = nfs_type2fmt[type];
388 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
392 p = xdr_reserve_space(xdr, 8);
393 *p++ = cpu_to_be32(MAJOR(rdev));
394 *p = cpu_to_be32(MINOR(rdev));
397 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
399 unsigned int major, minor;
401 major = be32_to_cpup(p++);
402 minor = be32_to_cpup(p++);
403 *rdev = MKDEV(major, minor);
404 if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
413 * opaque data<NFS3_FHSIZE>;
416 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
420 WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
421 p = xdr_reserve_space(xdr, 4 + fh->size);
422 xdr_encode_opaque(p, fh->data, fh->size);
425 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
430 p = xdr_inline_decode(xdr, 4);
433 length = be32_to_cpup(p++);
434 if (unlikely(length > NFS3_FHSIZE))
436 p = xdr_inline_decode(xdr, length);
440 memcpy(fh->data, p, length);
443 dprintk("NFS: file handle size (%u) too big\n", length);
447 static void zero_nfs_fh3(struct nfs_fh *fh)
449 memset(fh, 0, sizeof(*fh));
460 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec *timep)
462 *p++ = cpu_to_be32(timep->tv_sec);
463 *p++ = cpu_to_be32(timep->tv_nsec);
467 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec *timep)
469 timep->tv_sec = be32_to_cpup(p++);
470 timep->tv_nsec = be32_to_cpup(p++);
479 * SET_TO_SERVER_TIME = 1,
480 * SET_TO_CLIENT_TIME = 2
483 * union set_mode3 switch (bool set_it) {
490 * union set_uid3 switch (bool set_it) {
497 * union set_gid3 switch (bool set_it) {
504 * union set_size3 switch (bool set_it) {
511 * union set_atime switch (time_how set_it) {
512 * case SET_TO_CLIENT_TIME:
518 * union set_mtime switch (time_how set_it) {
519 * case SET_TO_CLIENT_TIME:
534 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr,
535 struct user_namespace *userns)
542 * In order to make only a single xdr_reserve_space() call,
543 * pre-compute the total number of bytes to be reserved.
544 * Six boolean values, one for each set_foo field, are always
545 * present in the encoded result, so start there.
548 if (attr->ia_valid & ATTR_MODE)
550 if (attr->ia_valid & ATTR_UID)
552 if (attr->ia_valid & ATTR_GID)
554 if (attr->ia_valid & ATTR_SIZE)
556 if (attr->ia_valid & ATTR_ATIME_SET)
558 if (attr->ia_valid & ATTR_MTIME_SET)
560 p = xdr_reserve_space(xdr, nbytes);
562 if (attr->ia_valid & ATTR_MODE) {
564 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
568 if (attr->ia_valid & ATTR_UID) {
570 *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid));
574 if (attr->ia_valid & ATTR_GID) {
576 *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid));
580 if (attr->ia_valid & ATTR_SIZE) {
582 p = xdr_encode_hyper(p, (u64)attr->ia_size);
586 if (attr->ia_valid & ATTR_ATIME_SET) {
589 ts = timespec64_to_timespec(attr->ia_atime);
590 p = xdr_encode_nfstime3(p, &ts);
591 } else if (attr->ia_valid & ATTR_ATIME) {
596 if (attr->ia_valid & ATTR_MTIME_SET) {
598 ts = timespec64_to_timespec(attr->ia_mtime);
599 xdr_encode_nfstime3(p, &ts);
600 } else if (attr->ia_valid & ATTR_MTIME) {
625 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr,
626 struct user_namespace *userns)
631 p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
635 p = xdr_decode_ftype3(p, &fmode);
637 fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
638 fattr->nlink = be32_to_cpup(p++);
639 fattr->uid = make_kuid(userns, be32_to_cpup(p++));
640 if (!uid_valid(fattr->uid))
642 fattr->gid = make_kgid(userns, be32_to_cpup(p++));
643 if (!gid_valid(fattr->gid))
646 p = xdr_decode_size3(p, &fattr->size);
647 p = xdr_decode_size3(p, &fattr->du.nfs3.used);
648 p = xdr_decode_specdata3(p, &fattr->rdev);
650 p = xdr_decode_hyper(p, &fattr->fsid.major);
651 fattr->fsid.minor = 0;
653 p = xdr_decode_fileid3(p, &fattr->fileid);
654 p = xdr_decode_nfstime3(p, &fattr->atime);
655 p = xdr_decode_nfstime3(p, &fattr->mtime);
656 xdr_decode_nfstime3(p, &fattr->ctime);
657 fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
659 fattr->valid |= NFS_ATTR_FATTR_V3;
662 dprintk("NFS: returned invalid uid\n");
665 dprintk("NFS: returned invalid gid\n");
672 * union post_op_attr switch (bool attributes_follow) {
679 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
680 struct user_namespace *userns)
684 p = xdr_inline_decode(xdr, 4);
688 return decode_fattr3(xdr, fattr, userns);
700 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
704 p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
708 fattr->valid |= NFS_ATTR_FATTR_PRESIZE
709 | NFS_ATTR_FATTR_PRECHANGE
710 | NFS_ATTR_FATTR_PREMTIME
711 | NFS_ATTR_FATTR_PRECTIME;
713 p = xdr_decode_size3(p, &fattr->pre_size);
714 p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
715 xdr_decode_nfstime3(p, &fattr->pre_ctime);
716 fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
723 * union pre_op_attr switch (bool attributes_follow) {
725 * wcc_attr attributes;
733 * pre_op_attr before;
734 * post_op_attr after;
737 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
741 p = xdr_inline_decode(xdr, 4);
745 return decode_wcc_attr(xdr, fattr);
749 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr,
750 struct user_namespace *userns)
754 error = decode_pre_op_attr(xdr, fattr);
757 error = decode_post_op_attr(xdr, fattr, userns);
765 * union post_op_fh3 switch (bool handle_follows) {
772 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
774 __be32 *p = xdr_inline_decode(xdr, 4);
778 return decode_nfs_fh3(xdr, fh);
786 * struct diropargs3 {
791 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
792 const char *name, u32 length)
794 encode_nfs_fh3(xdr, fh);
795 encode_filename3(xdr, name, length);
800 * NFSv3 XDR encode functions
802 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
803 * "NFS Version 3 Protocol Specification".
809 * struct GETATTR3args {
813 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
814 struct xdr_stream *xdr,
817 const struct nfs_fh *fh = data;
819 encode_nfs_fh3(xdr, fh);
825 * union sattrguard3 switch (bool check) {
827 * nfstime3 obj_ctime;
832 * struct SETATTR3args {
834 * sattr3 new_attributes;
838 static void encode_sattrguard3(struct xdr_stream *xdr,
839 const struct nfs3_sattrargs *args)
844 p = xdr_reserve_space(xdr, 4 + 8);
846 xdr_encode_nfstime3(p, &args->guardtime);
848 p = xdr_reserve_space(xdr, 4);
853 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
854 struct xdr_stream *xdr,
857 const struct nfs3_sattrargs *args = data;
858 encode_nfs_fh3(xdr, args->fh);
859 encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
860 encode_sattrguard3(xdr, args);
866 * struct LOOKUP3args {
870 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
871 struct xdr_stream *xdr,
874 const struct nfs3_diropargs *args = data;
876 encode_diropargs3(xdr, args->fh, args->name, args->len);
882 * struct ACCESS3args {
887 static void encode_access3args(struct xdr_stream *xdr,
888 const struct nfs3_accessargs *args)
890 encode_nfs_fh3(xdr, args->fh);
891 encode_uint32(xdr, args->access);
894 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
895 struct xdr_stream *xdr,
898 const struct nfs3_accessargs *args = data;
900 encode_access3args(xdr, args);
904 * 3.3.5 READLINK3args
906 * struct READLINK3args {
910 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
911 struct xdr_stream *xdr,
914 const struct nfs3_readlinkargs *args = data;
916 encode_nfs_fh3(xdr, args->fh);
917 rpc_prepare_reply_pages(req, args->pages, args->pgbase,
918 args->pglen, NFS3_readlinkres_sz);
930 static void encode_read3args(struct xdr_stream *xdr,
931 const struct nfs_pgio_args *args)
935 encode_nfs_fh3(xdr, args->fh);
937 p = xdr_reserve_space(xdr, 8 + 4);
938 p = xdr_encode_hyper(p, args->offset);
939 *p = cpu_to_be32(args->count);
942 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
943 struct xdr_stream *xdr,
946 const struct nfs_pgio_args *args = data;
947 unsigned int replen = args->replen ? args->replen : NFS3_readres_sz;
949 encode_read3args(xdr, args);
950 rpc_prepare_reply_pages(req, args->pages, args->pgbase,
951 args->count, replen);
952 req->rq_rcv_buf.flags |= XDRBUF_READ;
964 * struct WRITE3args {
972 static void encode_write3args(struct xdr_stream *xdr,
973 const struct nfs_pgio_args *args)
977 encode_nfs_fh3(xdr, args->fh);
979 p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
980 p = xdr_encode_hyper(p, args->offset);
981 *p++ = cpu_to_be32(args->count);
982 *p++ = cpu_to_be32(args->stable);
983 *p = cpu_to_be32(args->count);
984 xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
987 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
988 struct xdr_stream *xdr,
991 const struct nfs_pgio_args *args = data;
993 encode_write3args(xdr, args);
994 xdr->buf->flags |= XDRBUF_WRITE;
1000 * enum createmode3 {
1006 * union createhow3 switch (createmode3 mode) {
1009 * sattr3 obj_attributes;
1014 * struct CREATE3args {
1019 static void encode_createhow3(struct xdr_stream *xdr,
1020 const struct nfs3_createargs *args,
1021 struct user_namespace *userns)
1023 encode_uint32(xdr, args->createmode);
1024 switch (args->createmode) {
1025 case NFS3_CREATE_UNCHECKED:
1026 case NFS3_CREATE_GUARDED:
1027 encode_sattr3(xdr, args->sattr, userns);
1029 case NFS3_CREATE_EXCLUSIVE:
1030 encode_createverf3(xdr, args->verifier);
1037 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1038 struct xdr_stream *xdr,
1041 const struct nfs3_createargs *args = data;
1043 encode_diropargs3(xdr, args->fh, args->name, args->len);
1044 encode_createhow3(xdr, args, rpc_rqst_userns(req));
1050 * struct MKDIR3args {
1052 * sattr3 attributes;
1055 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1056 struct xdr_stream *xdr,
1059 const struct nfs3_mkdirargs *args = data;
1061 encode_diropargs3(xdr, args->fh, args->name, args->len);
1062 encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
1066 * 3.3.10 SYMLINK3args
1068 * struct symlinkdata3 {
1069 * sattr3 symlink_attributes;
1070 * nfspath3 symlink_data;
1073 * struct SYMLINK3args {
1075 * symlinkdata3 symlink;
1078 static void encode_symlinkdata3(struct xdr_stream *xdr,
1080 struct user_namespace *userns)
1082 const struct nfs3_symlinkargs *args = data;
1084 encode_sattr3(xdr, args->sattr, userns);
1085 encode_nfspath3(xdr, args->pages, args->pathlen);
1088 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1089 struct xdr_stream *xdr,
1092 const struct nfs3_symlinkargs *args = data;
1094 encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1095 encode_symlinkdata3(xdr, args, rpc_rqst_userns(req));
1096 xdr->buf->flags |= XDRBUF_WRITE;
1102 * struct devicedata3 {
1103 * sattr3 dev_attributes;
1107 * union mknoddata3 switch (ftype3 type) {
1110 * devicedata3 device;
1113 * sattr3 pipe_attributes;
1118 * struct MKNOD3args {
1123 static void encode_devicedata3(struct xdr_stream *xdr,
1124 const struct nfs3_mknodargs *args,
1125 struct user_namespace *userns)
1127 encode_sattr3(xdr, args->sattr, userns);
1128 encode_specdata3(xdr, args->rdev);
1131 static void encode_mknoddata3(struct xdr_stream *xdr,
1132 const struct nfs3_mknodargs *args,
1133 struct user_namespace *userns)
1135 encode_ftype3(xdr, args->type);
1136 switch (args->type) {
1139 encode_devicedata3(xdr, args, userns);
1143 encode_sattr3(xdr, args->sattr, userns);
1153 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1154 struct xdr_stream *xdr,
1157 const struct nfs3_mknodargs *args = data;
1159 encode_diropargs3(xdr, args->fh, args->name, args->len);
1160 encode_mknoddata3(xdr, args, rpc_rqst_userns(req));
1164 * 3.3.12 REMOVE3args
1166 * struct REMOVE3args {
1167 * diropargs3 object;
1170 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1171 struct xdr_stream *xdr,
1174 const struct nfs_removeargs *args = data;
1176 encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1180 * 3.3.14 RENAME3args
1182 * struct RENAME3args {
1187 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1188 struct xdr_stream *xdr,
1191 const struct nfs_renameargs *args = data;
1192 const struct qstr *old = args->old_name;
1193 const struct qstr *new = args->new_name;
1195 encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1196 encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1202 * struct LINK3args {
1207 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1208 struct xdr_stream *xdr,
1211 const struct nfs3_linkargs *args = data;
1213 encode_nfs_fh3(xdr, args->fromfh);
1214 encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1218 * 3.3.16 READDIR3args
1220 * struct READDIR3args {
1223 * cookieverf3 cookieverf;
1227 static void encode_readdir3args(struct xdr_stream *xdr,
1228 const struct nfs3_readdirargs *args)
1232 encode_nfs_fh3(xdr, args->fh);
1234 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1235 p = xdr_encode_cookie3(p, args->cookie);
1236 p = xdr_encode_cookieverf3(p, args->verf);
1237 *p = cpu_to_be32(args->count);
1240 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1241 struct xdr_stream *xdr,
1244 const struct nfs3_readdirargs *args = data;
1246 encode_readdir3args(xdr, args);
1247 rpc_prepare_reply_pages(req, args->pages, 0,
1248 args->count, NFS3_readdirres_sz);
1252 * 3.3.17 READDIRPLUS3args
1254 * struct READDIRPLUS3args {
1257 * cookieverf3 cookieverf;
1262 static void encode_readdirplus3args(struct xdr_stream *xdr,
1263 const struct nfs3_readdirargs *args)
1267 encode_nfs_fh3(xdr, args->fh);
1269 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1270 p = xdr_encode_cookie3(p, args->cookie);
1271 p = xdr_encode_cookieverf3(p, args->verf);
1274 * readdirplus: need dircount + buffer size.
1275 * We just make sure we make dircount big enough
1277 *p++ = cpu_to_be32(args->count >> 3);
1279 *p = cpu_to_be32(args->count);
1282 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1283 struct xdr_stream *xdr,
1286 const struct nfs3_readdirargs *args = data;
1288 encode_readdirplus3args(xdr, args);
1289 rpc_prepare_reply_pages(req, args->pages, 0,
1290 args->count, NFS3_readdirres_sz);
1294 * 3.3.21 COMMIT3args
1296 * struct COMMIT3args {
1302 static void encode_commit3args(struct xdr_stream *xdr,
1303 const struct nfs_commitargs *args)
1307 encode_nfs_fh3(xdr, args->fh);
1309 p = xdr_reserve_space(xdr, 8 + 4);
1310 p = xdr_encode_hyper(p, args->offset);
1311 *p = cpu_to_be32(args->count);
1314 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1315 struct xdr_stream *xdr,
1318 const struct nfs_commitargs *args = data;
1320 encode_commit3args(xdr, args);
1323 #ifdef CONFIG_NFS_V3_ACL
1325 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1326 struct xdr_stream *xdr,
1329 const struct nfs3_getaclargs *args = data;
1331 encode_nfs_fh3(xdr, args->fh);
1332 encode_uint32(xdr, args->mask);
1333 if (args->mask & (NFS_ACL | NFS_DFACL)) {
1334 rpc_prepare_reply_pages(req, args->pages, 0,
1335 NFSACL_MAXPAGES << PAGE_SHIFT,
1337 req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
1341 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1342 struct xdr_stream *xdr,
1345 const struct nfs3_setaclargs *args = data;
1349 encode_nfs_fh3(xdr, NFS_FH(args->inode));
1350 encode_uint32(xdr, args->mask);
1352 base = req->rq_slen;
1353 if (args->npages != 0)
1354 xdr_write_pages(xdr, args->pages, 0, args->len);
1356 xdr_reserve_space(xdr, args->len);
1358 error = nfsacl_encode(xdr->buf, base, args->inode,
1359 (args->mask & NFS_ACL) ?
1360 args->acl_access : NULL, 1, 0);
1361 /* FIXME: this is just broken */
1363 error = nfsacl_encode(xdr->buf, base + error, args->inode,
1364 (args->mask & NFS_DFACL) ?
1365 args->acl_default : NULL, 1,
1370 #endif /* CONFIG_NFS_V3_ACL */
1373 * NFSv3 XDR decode functions
1375 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1376 * "NFS Version 3 Protocol Specification".
1382 * struct GETATTR3resok {
1383 * fattr3 obj_attributes;
1386 * union GETATTR3res switch (nfsstat3 status) {
1388 * GETATTR3resok resok;
1393 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1394 struct xdr_stream *xdr,
1397 enum nfs_stat status;
1400 error = decode_nfsstat3(xdr, &status);
1401 if (unlikely(error))
1403 if (status != NFS3_OK)
1405 error = decode_fattr3(xdr, result, rpc_rqst_userns(req));
1409 return nfs3_stat_to_errno(status);
1415 * struct SETATTR3resok {
1419 * struct SETATTR3resfail {
1423 * union SETATTR3res switch (nfsstat3 status) {
1425 * SETATTR3resok resok;
1427 * SETATTR3resfail resfail;
1430 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1431 struct xdr_stream *xdr,
1434 enum nfs_stat status;
1437 error = decode_nfsstat3(xdr, &status);
1438 if (unlikely(error))
1440 error = decode_wcc_data(xdr, result, rpc_rqst_userns(req));
1441 if (unlikely(error))
1443 if (status != NFS3_OK)
1448 return nfs3_stat_to_errno(status);
1454 * struct LOOKUP3resok {
1456 * post_op_attr obj_attributes;
1457 * post_op_attr dir_attributes;
1460 * struct LOOKUP3resfail {
1461 * post_op_attr dir_attributes;
1464 * union LOOKUP3res switch (nfsstat3 status) {
1466 * LOOKUP3resok resok;
1468 * LOOKUP3resfail resfail;
1471 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1472 struct xdr_stream *xdr,
1475 struct user_namespace *userns = rpc_rqst_userns(req);
1476 struct nfs3_diropres *result = data;
1477 enum nfs_stat status;
1480 error = decode_nfsstat3(xdr, &status);
1481 if (unlikely(error))
1483 if (status != NFS3_OK)
1485 error = decode_nfs_fh3(xdr, result->fh);
1486 if (unlikely(error))
1488 error = decode_post_op_attr(xdr, result->fattr, userns);
1489 if (unlikely(error))
1491 error = decode_post_op_attr(xdr, result->dir_attr, userns);
1495 error = decode_post_op_attr(xdr, result->dir_attr, userns);
1496 if (unlikely(error))
1498 return nfs3_stat_to_errno(status);
1504 * struct ACCESS3resok {
1505 * post_op_attr obj_attributes;
1509 * struct ACCESS3resfail {
1510 * post_op_attr obj_attributes;
1513 * union ACCESS3res switch (nfsstat3 status) {
1515 * ACCESS3resok resok;
1517 * ACCESS3resfail resfail;
1520 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1521 struct xdr_stream *xdr,
1524 struct nfs3_accessres *result = data;
1525 enum nfs_stat status;
1528 error = decode_nfsstat3(xdr, &status);
1529 if (unlikely(error))
1531 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1532 if (unlikely(error))
1534 if (status != NFS3_OK)
1536 error = decode_uint32(xdr, &result->access);
1540 return nfs3_stat_to_errno(status);
1544 * 3.3.5 READLINK3res
1546 * struct READLINK3resok {
1547 * post_op_attr symlink_attributes;
1551 * struct READLINK3resfail {
1552 * post_op_attr symlink_attributes;
1555 * union READLINK3res switch (nfsstat3 status) {
1557 * READLINK3resok resok;
1559 * READLINK3resfail resfail;
1562 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1563 struct xdr_stream *xdr,
1566 enum nfs_stat status;
1569 error = decode_nfsstat3(xdr, &status);
1570 if (unlikely(error))
1572 error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
1573 if (unlikely(error))
1575 if (status != NFS3_OK)
1577 error = decode_nfspath3(xdr);
1581 return nfs3_stat_to_errno(status);
1587 * struct READ3resok {
1588 * post_op_attr file_attributes;
1594 * struct READ3resfail {
1595 * post_op_attr file_attributes;
1598 * union READ3res switch (nfsstat3 status) {
1602 * READ3resfail resfail;
1605 static int decode_read3resok(struct xdr_stream *xdr,
1606 struct nfs_pgio_res *result)
1608 u32 eof, count, ocount, recvd;
1611 p = xdr_inline_decode(xdr, 4 + 4 + 4);
1614 count = be32_to_cpup(p++);
1615 eof = be32_to_cpup(p++);
1616 ocount = be32_to_cpup(p++);
1617 if (unlikely(ocount != count))
1619 recvd = xdr_read_pages(xdr, count);
1620 if (unlikely(count > recvd))
1624 result->count = count;
1627 dprintk("NFS: READ count doesn't match length of opaque: "
1628 "count %u != ocount %u\n", count, ocount);
1631 dprintk("NFS: server cheating in read result: "
1632 "count %u > recvd %u\n", count, recvd);
1638 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1641 struct nfs_pgio_res *result = data;
1643 enum nfs_stat status;
1646 pos = xdr_stream_pos(xdr);
1647 error = decode_nfsstat3(xdr, &status);
1648 if (unlikely(error))
1650 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1651 if (unlikely(error))
1653 result->op_status = status;
1654 if (status != NFS3_OK)
1656 result->replen = 4 + ((xdr_stream_pos(xdr) - pos) >> 2);
1657 error = decode_read3resok(xdr, result);
1661 return nfs3_stat_to_errno(status);
1673 * struct WRITE3resok {
1674 * wcc_data file_wcc;
1676 * stable_how committed;
1680 * struct WRITE3resfail {
1681 * wcc_data file_wcc;
1684 * union WRITE3res switch (nfsstat3 status) {
1686 * WRITE3resok resok;
1688 * WRITE3resfail resfail;
1691 static int decode_write3resok(struct xdr_stream *xdr,
1692 struct nfs_pgio_res *result)
1696 p = xdr_inline_decode(xdr, 4 + 4);
1699 result->count = be32_to_cpup(p++);
1700 result->verf->committed = be32_to_cpup(p++);
1701 if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1703 if (decode_writeverf3(xdr, &result->verf->verifier))
1705 return result->count;
1707 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1711 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1714 struct nfs_pgio_res *result = data;
1715 enum nfs_stat status;
1718 error = decode_nfsstat3(xdr, &status);
1719 if (unlikely(error))
1721 error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
1722 if (unlikely(error))
1724 result->op_status = status;
1725 if (status != NFS3_OK)
1727 error = decode_write3resok(xdr, result);
1731 return nfs3_stat_to_errno(status);
1737 * struct CREATE3resok {
1739 * post_op_attr obj_attributes;
1743 * struct CREATE3resfail {
1747 * union CREATE3res switch (nfsstat3 status) {
1749 * CREATE3resok resok;
1751 * CREATE3resfail resfail;
1754 static int decode_create3resok(struct xdr_stream *xdr,
1755 struct nfs3_diropres *result,
1756 struct user_namespace *userns)
1760 error = decode_post_op_fh3(xdr, result->fh);
1761 if (unlikely(error))
1763 error = decode_post_op_attr(xdr, result->fattr, userns);
1764 if (unlikely(error))
1766 /* The server isn't required to return a file handle.
1767 * If it didn't, force the client to perform a LOOKUP
1768 * to determine the correct file handle and attribute
1769 * values for the new object. */
1770 if (result->fh->size == 0)
1771 result->fattr->valid = 0;
1772 error = decode_wcc_data(xdr, result->dir_attr, userns);
1777 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1778 struct xdr_stream *xdr,
1781 struct user_namespace *userns = rpc_rqst_userns(req);
1782 struct nfs3_diropres *result = data;
1783 enum nfs_stat status;
1786 error = decode_nfsstat3(xdr, &status);
1787 if (unlikely(error))
1789 if (status != NFS3_OK)
1791 error = decode_create3resok(xdr, result, userns);
1795 error = decode_wcc_data(xdr, result->dir_attr, userns);
1796 if (unlikely(error))
1798 return nfs3_stat_to_errno(status);
1804 * struct REMOVE3resok {
1808 * struct REMOVE3resfail {
1812 * union REMOVE3res switch (nfsstat3 status) {
1814 * REMOVE3resok resok;
1816 * REMOVE3resfail resfail;
1819 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1820 struct xdr_stream *xdr,
1823 struct nfs_removeres *result = data;
1824 enum nfs_stat status;
1827 error = decode_nfsstat3(xdr, &status);
1828 if (unlikely(error))
1830 error = decode_wcc_data(xdr, result->dir_attr, rpc_rqst_userns(req));
1831 if (unlikely(error))
1833 if (status != NFS3_OK)
1838 return nfs3_stat_to_errno(status);
1844 * struct RENAME3resok {
1845 * wcc_data fromdir_wcc;
1846 * wcc_data todir_wcc;
1849 * struct RENAME3resfail {
1850 * wcc_data fromdir_wcc;
1851 * wcc_data todir_wcc;
1854 * union RENAME3res switch (nfsstat3 status) {
1856 * RENAME3resok resok;
1858 * RENAME3resfail resfail;
1861 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1862 struct xdr_stream *xdr,
1865 struct user_namespace *userns = rpc_rqst_userns(req);
1866 struct nfs_renameres *result = data;
1867 enum nfs_stat status;
1870 error = decode_nfsstat3(xdr, &status);
1871 if (unlikely(error))
1873 error = decode_wcc_data(xdr, result->old_fattr, userns);
1874 if (unlikely(error))
1876 error = decode_wcc_data(xdr, result->new_fattr, userns);
1877 if (unlikely(error))
1879 if (status != NFS3_OK)
1884 return nfs3_stat_to_errno(status);
1890 * struct LINK3resok {
1891 * post_op_attr file_attributes;
1892 * wcc_data linkdir_wcc;
1895 * struct LINK3resfail {
1896 * post_op_attr file_attributes;
1897 * wcc_data linkdir_wcc;
1900 * union LINK3res switch (nfsstat3 status) {
1904 * LINK3resfail resfail;
1907 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1910 struct user_namespace *userns = rpc_rqst_userns(req);
1911 struct nfs3_linkres *result = data;
1912 enum nfs_stat status;
1915 error = decode_nfsstat3(xdr, &status);
1916 if (unlikely(error))
1918 error = decode_post_op_attr(xdr, result->fattr, userns);
1919 if (unlikely(error))
1921 error = decode_wcc_data(xdr, result->dir_attr, userns);
1922 if (unlikely(error))
1924 if (status != NFS3_OK)
1929 return nfs3_stat_to_errno(status);
1933 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1934 * the local page cache
1935 * @xdr: XDR stream where entry resides
1936 * @entry: buffer to fill in with entry data
1937 * @plus: boolean indicating whether this should be a readdirplus entry
1939 * Returns zero if successful, otherwise a negative errno value is
1942 * This function is not invoked during READDIR reply decoding, but
1943 * rather whenever an application invokes the getdents(2) system call
1944 * on a directory already in our cache.
1952 * fhandle3 filehandle;
1953 * post_op_attr3 attributes;
1954 * entry3 *nextentry;
1958 * struct entryplus3 {
1962 * post_op_attr name_attributes;
1963 * post_op_fh3 name_handle;
1964 * entryplus3 *nextentry;
1967 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1970 struct user_namespace *userns = rpc_userns(entry->server->client);
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))
1994 return error == -ENAMETOOLONG ? -ENAMETOOLONG : -EAGAIN;
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))
2024 zero_nfs_fh3(entry->fh);
2027 entry->prev_cookie = entry->cookie;
2028 entry->cookie = new_cookie;
2034 * 3.3.16 READDIR3res
2041 * struct READDIR3resok {
2042 * post_op_attr dir_attributes;
2043 * cookieverf3 cookieverf;
2047 * struct READDIR3resfail {
2048 * post_op_attr dir_attributes;
2051 * union READDIR3res switch (nfsstat3 status) {
2053 * READDIR3resok resok;
2055 * READDIR3resfail resfail;
2058 * Read the directory contents into the page cache, but otherwise
2059 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2060 * during subsequent nfs_readdir() calls.
2062 static int decode_dirlist3(struct xdr_stream *xdr)
2064 return xdr_read_pages(xdr, xdr->buf->page_len);
2067 static int decode_readdir3resok(struct xdr_stream *xdr,
2068 struct nfs3_readdirres *result,
2069 struct user_namespace *userns)
2073 error = decode_post_op_attr(xdr, result->dir_attr, userns);
2074 if (unlikely(error))
2076 /* XXX: do we need to check if result->verf != NULL ? */
2077 error = decode_cookieverf3(xdr, result->verf);
2078 if (unlikely(error))
2080 error = decode_dirlist3(xdr);
2085 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2086 struct xdr_stream *xdr,
2089 struct nfs3_readdirres *result = data;
2090 enum nfs_stat status;
2093 error = decode_nfsstat3(xdr, &status);
2094 if (unlikely(error))
2096 if (status != NFS3_OK)
2098 error = decode_readdir3resok(xdr, result, rpc_rqst_userns(req));
2102 error = decode_post_op_attr(xdr, result->dir_attr, rpc_rqst_userns(req));
2103 if (unlikely(error))
2105 return nfs3_stat_to_errno(status);
2111 * struct FSSTAT3resok {
2112 * post_op_attr obj_attributes;
2122 * struct FSSTAT3resfail {
2123 * post_op_attr obj_attributes;
2126 * union FSSTAT3res switch (nfsstat3 status) {
2128 * FSSTAT3resok resok;
2130 * FSSTAT3resfail resfail;
2133 static int decode_fsstat3resok(struct xdr_stream *xdr,
2134 struct nfs_fsstat *result)
2138 p = xdr_inline_decode(xdr, 8 * 6 + 4);
2141 p = xdr_decode_size3(p, &result->tbytes);
2142 p = xdr_decode_size3(p, &result->fbytes);
2143 p = xdr_decode_size3(p, &result->abytes);
2144 p = xdr_decode_size3(p, &result->tfiles);
2145 p = xdr_decode_size3(p, &result->ffiles);
2146 xdr_decode_size3(p, &result->afiles);
2147 /* ignore invarsec */
2151 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2152 struct xdr_stream *xdr,
2155 struct nfs_fsstat *result = data;
2156 enum nfs_stat status;
2159 error = decode_nfsstat3(xdr, &status);
2160 if (unlikely(error))
2162 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2163 if (unlikely(error))
2165 if (status != NFS3_OK)
2167 error = decode_fsstat3resok(xdr, result);
2171 return nfs3_stat_to_errno(status);
2177 * struct FSINFO3resok {
2178 * post_op_attr obj_attributes;
2186 * size3 maxfilesize;
2187 * nfstime3 time_delta;
2188 * uint32 properties;
2191 * struct FSINFO3resfail {
2192 * post_op_attr obj_attributes;
2195 * union FSINFO3res switch (nfsstat3 status) {
2197 * FSINFO3resok resok;
2199 * FSINFO3resfail resfail;
2202 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2203 struct nfs_fsinfo *result)
2207 p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2210 result->rtmax = be32_to_cpup(p++);
2211 result->rtpref = be32_to_cpup(p++);
2212 result->rtmult = be32_to_cpup(p++);
2213 result->wtmax = be32_to_cpup(p++);
2214 result->wtpref = be32_to_cpup(p++);
2215 result->wtmult = be32_to_cpup(p++);
2216 result->dtpref = be32_to_cpup(p++);
2217 p = xdr_decode_size3(p, &result->maxfilesize);
2218 xdr_decode_nfstime3(p, &result->time_delta);
2220 /* ignore properties */
2221 result->lease_time = 0;
2225 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2226 struct xdr_stream *xdr,
2229 struct nfs_fsinfo *result = data;
2230 enum nfs_stat status;
2233 error = decode_nfsstat3(xdr, &status);
2234 if (unlikely(error))
2236 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2237 if (unlikely(error))
2239 if (status != NFS3_OK)
2241 error = decode_fsinfo3resok(xdr, result);
2245 return nfs3_stat_to_errno(status);
2249 * 3.3.20 PATHCONF3res
2251 * struct PATHCONF3resok {
2252 * post_op_attr obj_attributes;
2256 * bool chown_restricted;
2257 * bool case_insensitive;
2258 * bool case_preserving;
2261 * struct PATHCONF3resfail {
2262 * post_op_attr obj_attributes;
2265 * union PATHCONF3res switch (nfsstat3 status) {
2267 * PATHCONF3resok resok;
2269 * PATHCONF3resfail resfail;
2272 static int decode_pathconf3resok(struct xdr_stream *xdr,
2273 struct nfs_pathconf *result)
2277 p = xdr_inline_decode(xdr, 4 * 6);
2280 result->max_link = be32_to_cpup(p++);
2281 result->max_namelen = be32_to_cpup(p);
2282 /* ignore remaining fields */
2286 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2287 struct xdr_stream *xdr,
2290 struct nfs_pathconf *result = data;
2291 enum nfs_stat status;
2294 error = decode_nfsstat3(xdr, &status);
2295 if (unlikely(error))
2297 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2298 if (unlikely(error))
2300 if (status != NFS3_OK)
2302 error = decode_pathconf3resok(xdr, result);
2306 return nfs3_stat_to_errno(status);
2312 * struct COMMIT3resok {
2313 * wcc_data file_wcc;
2317 * struct COMMIT3resfail {
2318 * wcc_data file_wcc;
2321 * union COMMIT3res switch (nfsstat3 status) {
2323 * COMMIT3resok resok;
2325 * COMMIT3resfail resfail;
2328 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2329 struct xdr_stream *xdr,
2332 struct nfs_commitres *result = data;
2333 struct nfs_writeverf *verf = result->verf;
2334 enum nfs_stat status;
2337 error = decode_nfsstat3(xdr, &status);
2338 if (unlikely(error))
2340 error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
2341 if (unlikely(error))
2343 result->op_status = status;
2344 if (status != NFS3_OK)
2346 error = decode_writeverf3(xdr, &verf->verifier);
2348 verf->committed = NFS_FILE_SYNC;
2352 return nfs3_stat_to_errno(status);
2355 #ifdef CONFIG_NFS_V3_ACL
2357 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2358 struct nfs3_getaclres *result,
2359 struct user_namespace *userns)
2361 struct posix_acl **acl;
2362 unsigned int *aclcnt;
2366 error = decode_post_op_attr(xdr, result->fattr, userns);
2367 if (unlikely(error))
2369 error = decode_uint32(xdr, &result->mask);
2370 if (unlikely(error))
2373 if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2376 hdrlen = xdr_stream_pos(xdr);
2379 if (result->mask & NFS_ACL)
2380 acl = &result->acl_access;
2382 if (result->mask & NFS_ACLCNT)
2383 aclcnt = &result->acl_access_count;
2384 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2385 if (unlikely(error <= 0))
2389 if (result->mask & NFS_DFACL)
2390 acl = &result->acl_default;
2392 if (result->mask & NFS_DFACLCNT)
2393 aclcnt = &result->acl_default_count;
2394 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2395 if (unlikely(error <= 0))
2402 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2403 struct xdr_stream *xdr,
2406 enum nfs_stat status;
2409 error = decode_nfsstat3(xdr, &status);
2410 if (unlikely(error))
2412 if (status != NFS3_OK)
2414 error = decode_getacl3resok(xdr, result, rpc_rqst_userns(req));
2418 return nfs3_stat_to_errno(status);
2421 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2422 struct xdr_stream *xdr,
2425 enum nfs_stat status;
2428 error = decode_nfsstat3(xdr, &status);
2429 if (unlikely(error))
2431 if (status != NFS3_OK)
2433 error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
2437 return nfs3_stat_to_errno(status);
2440 #endif /* CONFIG_NFS_V3_ACL */
2444 * We need to translate between nfs status return values and
2445 * the local errno values which may not be the same.
2447 static const struct {
2452 { NFSERR_PERM, -EPERM },
2453 { NFSERR_NOENT, -ENOENT },
2454 { NFSERR_IO, -errno_NFSERR_IO},
2455 { NFSERR_NXIO, -ENXIO },
2456 /* { NFSERR_EAGAIN, -EAGAIN }, */
2457 { NFSERR_ACCES, -EACCES },
2458 { NFSERR_EXIST, -EEXIST },
2459 { NFSERR_XDEV, -EXDEV },
2460 { NFSERR_NODEV, -ENODEV },
2461 { NFSERR_NOTDIR, -ENOTDIR },
2462 { NFSERR_ISDIR, -EISDIR },
2463 { NFSERR_INVAL, -EINVAL },
2464 { NFSERR_FBIG, -EFBIG },
2465 { NFSERR_NOSPC, -ENOSPC },
2466 { NFSERR_ROFS, -EROFS },
2467 { NFSERR_MLINK, -EMLINK },
2468 { NFSERR_NAMETOOLONG, -ENAMETOOLONG },
2469 { NFSERR_NOTEMPTY, -ENOTEMPTY },
2470 { NFSERR_DQUOT, -EDQUOT },
2471 { NFSERR_STALE, -ESTALE },
2472 { NFSERR_REMOTE, -EREMOTE },
2474 { NFSERR_WFLUSH, -EWFLUSH },
2476 { NFSERR_BADHANDLE, -EBADHANDLE },
2477 { NFSERR_NOT_SYNC, -ENOTSYNC },
2478 { NFSERR_BAD_COOKIE, -EBADCOOKIE },
2479 { NFSERR_NOTSUPP, -ENOTSUPP },
2480 { NFSERR_TOOSMALL, -ETOOSMALL },
2481 { NFSERR_SERVERFAULT, -EREMOTEIO },
2482 { NFSERR_BADTYPE, -EBADTYPE },
2483 { NFSERR_JUKEBOX, -EJUKEBOX },
2488 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2489 * @status: NFS status code to convert
2491 * Returns a local errno value, or -EIO if the NFS status code is
2492 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2494 static int nfs3_stat_to_errno(enum nfs_stat status)
2498 for (i = 0; nfs_errtbl[i].stat != -1; i++) {
2499 if (nfs_errtbl[i].stat == (int)status)
2500 return nfs_errtbl[i].errno;
2502 dprintk("NFS: Unrecognized nfs status value: %u\n", status);
2503 return nfs_errtbl[i].errno;
2507 #define PROC(proc, argtype, restype, timer) \
2508 [NFS3PROC_##proc] = { \
2509 .p_proc = NFS3PROC_##proc, \
2510 .p_encode = nfs3_xdr_enc_##argtype##3args, \
2511 .p_decode = nfs3_xdr_dec_##restype##3res, \
2512 .p_arglen = NFS3_##argtype##args_sz, \
2513 .p_replen = NFS3_##restype##res_sz, \
2515 .p_statidx = NFS3PROC_##proc, \
2519 const struct rpc_procinfo nfs3_procedures[] = {
2520 PROC(GETATTR, getattr, getattr, 1),
2521 PROC(SETATTR, setattr, setattr, 0),
2522 PROC(LOOKUP, lookup, lookup, 2),
2523 PROC(ACCESS, access, access, 1),
2524 PROC(READLINK, readlink, readlink, 3),
2525 PROC(READ, read, read, 3),
2526 PROC(WRITE, write, write, 4),
2527 PROC(CREATE, create, create, 0),
2528 PROC(MKDIR, mkdir, create, 0),
2529 PROC(SYMLINK, symlink, create, 0),
2530 PROC(MKNOD, mknod, create, 0),
2531 PROC(REMOVE, remove, remove, 0),
2532 PROC(RMDIR, lookup, setattr, 0),
2533 PROC(RENAME, rename, rename, 0),
2534 PROC(LINK, link, link, 0),
2535 PROC(READDIR, readdir, readdir, 3),
2536 PROC(READDIRPLUS, readdirplus, readdir, 3),
2537 PROC(FSSTAT, getattr, fsstat, 0),
2538 PROC(FSINFO, getattr, fsinfo, 0),
2539 PROC(PATHCONF, getattr, pathconf, 0),
2540 PROC(COMMIT, commit, commit, 5),
2543 static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
2544 const struct rpc_version nfs_version3 = {
2546 .nrprocs = ARRAY_SIZE(nfs3_procedures),
2547 .procs = nfs3_procedures,
2548 .counts = nfs_version3_counts,
2551 #ifdef CONFIG_NFS_V3_ACL
2552 static const struct rpc_procinfo nfs3_acl_procedures[] = {
2553 [ACLPROC3_GETACL] = {
2554 .p_proc = ACLPROC3_GETACL,
2555 .p_encode = nfs3_xdr_enc_getacl3args,
2556 .p_decode = nfs3_xdr_dec_getacl3res,
2557 .p_arglen = ACL3_getaclargs_sz,
2558 .p_replen = ACL3_getaclres_sz,
2562 [ACLPROC3_SETACL] = {
2563 .p_proc = ACLPROC3_SETACL,
2564 .p_encode = nfs3_xdr_enc_setacl3args,
2565 .p_decode = nfs3_xdr_dec_setacl3res,
2566 .p_arglen = ACL3_setaclargs_sz,
2567 .p_replen = ACL3_setaclres_sz,
2573 static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
2574 const struct rpc_version nfsacl_version3 = {
2576 .nrprocs = ARRAY_SIZE(nfs3_acl_procedures),
2577 .procs = nfs3_acl_procedures,
2578 .counts = nfs3_acl_counts,
2580 #endif /* CONFIG_NFS_V3_ACL */