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_sattr_sz (15)
39 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
40 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
41 #define NFS3_fattr_sz (21)
42 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
43 #define NFS3_wcc_attr_sz (6)
44 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
45 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
46 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
47 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
49 #define NFS3_getattrargs_sz (NFS3_fh_sz)
50 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
51 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz)
52 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
53 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
54 #define NFS3_readargs_sz (NFS3_fh_sz+3)
55 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
56 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
57 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
58 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
59 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
60 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
61 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
62 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
63 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
64 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
65 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
67 #define NFS3_getattrres_sz (1+NFS3_fattr_sz)
68 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz)
69 #define NFS3_removeres_sz (NFS3_setattrres_sz)
70 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
71 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
72 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1+1)
73 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3+1)
74 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
75 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
76 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
77 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
78 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2+1)
79 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
80 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
81 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
82 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
84 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
85 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \
86 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
87 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \
88 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE)+1)
89 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
91 static int nfs3_stat_to_errno(enum nfs_stat);
94 * Map file type to S_IFMT bits
96 static const umode_t nfs_type2fmt[] = {
103 [NF3SOCK] = S_IFSOCK,
107 static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt)
109 if (clnt && clnt->cl_cred)
110 return clnt->cl_cred->user_ns;
111 return &init_user_ns;
114 static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp)
117 return rpc_userns(rqstp->rq_task->tk_client);
118 return &init_user_ns;
122 * Encode/decode NFSv3 basic data types
124 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
125 * "NFS Version 3 Protocol Specification".
127 * Not all basic data types have their own encoding and decoding
128 * functions. For run-time efficiency, some data types are encoded
132 static void encode_uint32(struct xdr_stream *xdr, u32 value)
134 __be32 *p = xdr_reserve_space(xdr, 4);
135 *p = cpu_to_be32(value);
138 static int decode_uint32(struct xdr_stream *xdr, u32 *value)
142 p = xdr_inline_decode(xdr, 4);
145 *value = be32_to_cpup(p);
149 static int decode_uint64(struct xdr_stream *xdr, u64 *value)
153 p = xdr_inline_decode(xdr, 8);
156 xdr_decode_hyper(p, value);
163 * typedef uint64 fileid3;
165 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
167 return xdr_decode_hyper(p, fileid);
170 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
172 return decode_uint64(xdr, fileid);
178 * typedef string filename3<>;
180 static void encode_filename3(struct xdr_stream *xdr,
181 const char *name, u32 length)
185 WARN_ON_ONCE(length > NFS3_MAXNAMLEN);
186 p = xdr_reserve_space(xdr, 4 + length);
187 xdr_encode_opaque(p, name, length);
190 static int decode_inline_filename3(struct xdr_stream *xdr,
191 const char **name, u32 *length)
196 p = xdr_inline_decode(xdr, 4);
199 count = be32_to_cpup(p);
200 if (count > NFS3_MAXNAMLEN)
201 goto out_nametoolong;
202 p = xdr_inline_decode(xdr, count);
205 *name = (const char *)p;
210 dprintk("NFS: returned filename too long: %u\n", count);
211 return -ENAMETOOLONG;
217 * typedef string nfspath3<>;
219 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
222 encode_uint32(xdr, length);
223 xdr_write_pages(xdr, pages, 0, length);
226 static int decode_nfspath3(struct xdr_stream *xdr)
231 p = xdr_inline_decode(xdr, 4);
234 count = be32_to_cpup(p);
235 if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
236 goto out_nametoolong;
237 recvd = xdr_read_pages(xdr, count);
238 if (unlikely(count > recvd))
240 xdr_terminate_string(xdr->buf, count);
244 dprintk("NFS: returned pathname too long: %u\n", count);
245 return -ENAMETOOLONG;
247 dprintk("NFS: server cheating in pathname result: "
248 "count %u > recvd %u\n", count, recvd);
255 * typedef uint64 cookie3
257 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
259 return xdr_encode_hyper(p, cookie);
262 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
264 return decode_uint64(xdr, cookie);
270 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
272 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
274 memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
275 return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
278 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
282 p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
285 memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
292 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
294 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
298 p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
299 memcpy(p, verifier, NFS3_CREATEVERFSIZE);
302 static int decode_writeverf3(struct xdr_stream *xdr, struct nfs_write_verifier *verifier)
306 p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
309 memcpy(verifier->data, p, NFS3_WRITEVERFSIZE);
316 * typedef uint64 size3;
318 static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
320 return xdr_decode_hyper(p, size);
331 #define NFS3_OK NFS_OK
333 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
337 p = xdr_inline_decode(xdr, 4);
340 if (unlikely(*p != cpu_to_be32(NFS3_OK)))
345 *status = be32_to_cpup(p);
346 trace_nfs_xdr_status(xdr, (int)*status);
363 static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
365 encode_uint32(xdr, type);
368 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
372 type = be32_to_cpup(p++);
375 *mode = nfs_type2fmt[type];
387 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
391 p = xdr_reserve_space(xdr, 8);
392 *p++ = cpu_to_be32(MAJOR(rdev));
393 *p = cpu_to_be32(MINOR(rdev));
396 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
398 unsigned int major, minor;
400 major = be32_to_cpup(p++);
401 minor = be32_to_cpup(p++);
402 *rdev = MKDEV(major, minor);
403 if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
412 * opaque data<NFS3_FHSIZE>;
415 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
419 WARN_ON_ONCE(fh->size > NFS3_FHSIZE);
420 p = xdr_reserve_space(xdr, 4 + fh->size);
421 xdr_encode_opaque(p, fh->data, fh->size);
424 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
429 p = xdr_inline_decode(xdr, 4);
432 length = be32_to_cpup(p++);
433 if (unlikely(length > NFS3_FHSIZE))
435 p = xdr_inline_decode(xdr, length);
439 memcpy(fh->data, p, length);
442 dprintk("NFS: file handle size (%u) too big\n", length);
446 static void zero_nfs_fh3(struct nfs_fh *fh)
448 memset(fh, 0, sizeof(*fh));
459 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec64 *timep)
461 *p++ = cpu_to_be32((u32)timep->tv_sec);
462 *p++ = cpu_to_be32(timep->tv_nsec);
466 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec64 *timep)
468 timep->tv_sec = be32_to_cpup(p++);
469 timep->tv_nsec = be32_to_cpup(p++);
478 * SET_TO_SERVER_TIME = 1,
479 * SET_TO_CLIENT_TIME = 2
482 * union set_mode3 switch (bool set_it) {
489 * union set_uid3 switch (bool set_it) {
496 * union set_gid3 switch (bool set_it) {
503 * union set_size3 switch (bool set_it) {
510 * union set_atime switch (time_how set_it) {
511 * case SET_TO_CLIENT_TIME:
517 * union set_mtime switch (time_how set_it) {
518 * case SET_TO_CLIENT_TIME:
533 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr,
534 struct user_namespace *userns)
540 * In order to make only a single xdr_reserve_space() call,
541 * pre-compute the total number of bytes to be reserved.
542 * Six boolean values, one for each set_foo field, are always
543 * present in the encoded result, so start there.
546 if (attr->ia_valid & ATTR_MODE)
548 if (attr->ia_valid & ATTR_UID)
550 if (attr->ia_valid & ATTR_GID)
552 if (attr->ia_valid & ATTR_SIZE)
554 if (attr->ia_valid & ATTR_ATIME_SET)
556 if (attr->ia_valid & ATTR_MTIME_SET)
558 p = xdr_reserve_space(xdr, nbytes);
560 if (attr->ia_valid & ATTR_MODE) {
562 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
566 if (attr->ia_valid & ATTR_UID) {
568 *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid));
572 if (attr->ia_valid & ATTR_GID) {
574 *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid));
578 if (attr->ia_valid & ATTR_SIZE) {
580 p = xdr_encode_hyper(p, (u64)attr->ia_size);
584 if (attr->ia_valid & ATTR_ATIME_SET) {
586 p = xdr_encode_nfstime3(p, &attr->ia_atime);
587 } else if (attr->ia_valid & ATTR_ATIME) {
592 if (attr->ia_valid & ATTR_MTIME_SET) {
594 xdr_encode_nfstime3(p, &attr->ia_mtime);
595 } else if (attr->ia_valid & ATTR_MTIME) {
620 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr,
621 struct user_namespace *userns)
626 p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
630 p = xdr_decode_ftype3(p, &fmode);
632 fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
633 fattr->nlink = be32_to_cpup(p++);
634 fattr->uid = make_kuid(userns, be32_to_cpup(p++));
635 if (!uid_valid(fattr->uid))
637 fattr->gid = make_kgid(userns, be32_to_cpup(p++));
638 if (!gid_valid(fattr->gid))
641 p = xdr_decode_size3(p, &fattr->size);
642 p = xdr_decode_size3(p, &fattr->du.nfs3.used);
643 p = xdr_decode_specdata3(p, &fattr->rdev);
645 p = xdr_decode_hyper(p, &fattr->fsid.major);
646 fattr->fsid.minor = 0;
648 p = xdr_decode_fileid3(p, &fattr->fileid);
649 p = xdr_decode_nfstime3(p, &fattr->atime);
650 p = xdr_decode_nfstime3(p, &fattr->mtime);
651 xdr_decode_nfstime3(p, &fattr->ctime);
652 fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime);
654 fattr->valid |= NFS_ATTR_FATTR_V3;
657 dprintk("NFS: returned invalid uid\n");
660 dprintk("NFS: returned invalid gid\n");
667 * union post_op_attr switch (bool attributes_follow) {
674 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr,
675 struct user_namespace *userns)
679 p = xdr_inline_decode(xdr, 4);
683 return decode_fattr3(xdr, fattr, userns);
695 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
699 p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
703 fattr->valid |= NFS_ATTR_FATTR_PRESIZE
704 | NFS_ATTR_FATTR_PRECHANGE
705 | NFS_ATTR_FATTR_PREMTIME
706 | NFS_ATTR_FATTR_PRECTIME;
708 p = xdr_decode_size3(p, &fattr->pre_size);
709 p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
710 xdr_decode_nfstime3(p, &fattr->pre_ctime);
711 fattr->pre_change_attr = nfs_timespec_to_change_attr(&fattr->pre_ctime);
718 * union pre_op_attr switch (bool attributes_follow) {
720 * wcc_attr attributes;
728 * pre_op_attr before;
729 * post_op_attr after;
732 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
736 p = xdr_inline_decode(xdr, 4);
740 return decode_wcc_attr(xdr, fattr);
744 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr,
745 struct user_namespace *userns)
749 error = decode_pre_op_attr(xdr, fattr);
752 error = decode_post_op_attr(xdr, fattr, userns);
760 * union post_op_fh3 switch (bool handle_follows) {
767 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
769 __be32 *p = xdr_inline_decode(xdr, 4);
773 return decode_nfs_fh3(xdr, fh);
781 * struct diropargs3 {
786 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
787 const char *name, u32 length)
789 encode_nfs_fh3(xdr, fh);
790 encode_filename3(xdr, name, length);
795 * NFSv3 XDR encode functions
797 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
798 * "NFS Version 3 Protocol Specification".
804 * struct GETATTR3args {
808 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
809 struct xdr_stream *xdr,
812 const struct nfs_fh *fh = data;
814 encode_nfs_fh3(xdr, fh);
820 * union sattrguard3 switch (bool check) {
822 * nfstime3 obj_ctime;
827 * struct SETATTR3args {
829 * sattr3 new_attributes;
833 static void encode_sattrguard3(struct xdr_stream *xdr,
834 const struct nfs3_sattrargs *args)
839 p = xdr_reserve_space(xdr, 4 + 8);
841 xdr_encode_nfstime3(p, &args->guardtime);
843 p = xdr_reserve_space(xdr, 4);
848 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
849 struct xdr_stream *xdr,
852 const struct nfs3_sattrargs *args = data;
853 encode_nfs_fh3(xdr, args->fh);
854 encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
855 encode_sattrguard3(xdr, args);
861 * struct LOOKUP3args {
865 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
866 struct xdr_stream *xdr,
869 const struct nfs3_diropargs *args = data;
871 encode_diropargs3(xdr, args->fh, args->name, args->len);
877 * struct ACCESS3args {
882 static void encode_access3args(struct xdr_stream *xdr,
883 const struct nfs3_accessargs *args)
885 encode_nfs_fh3(xdr, args->fh);
886 encode_uint32(xdr, args->access);
889 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
890 struct xdr_stream *xdr,
893 const struct nfs3_accessargs *args = data;
895 encode_access3args(xdr, args);
899 * 3.3.5 READLINK3args
901 * struct READLINK3args {
905 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
906 struct xdr_stream *xdr,
909 const struct nfs3_readlinkargs *args = data;
911 encode_nfs_fh3(xdr, args->fh);
912 rpc_prepare_reply_pages(req, args->pages, args->pgbase,
913 args->pglen, NFS3_readlinkres_sz);
925 static void encode_read3args(struct xdr_stream *xdr,
926 const struct nfs_pgio_args *args)
930 encode_nfs_fh3(xdr, args->fh);
932 p = xdr_reserve_space(xdr, 8 + 4);
933 p = xdr_encode_hyper(p, args->offset);
934 *p = cpu_to_be32(args->count);
937 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
938 struct xdr_stream *xdr,
941 const struct nfs_pgio_args *args = data;
942 unsigned int replen = args->replen ? args->replen : NFS3_readres_sz;
944 encode_read3args(xdr, args);
945 rpc_prepare_reply_pages(req, args->pages, args->pgbase,
946 args->count, replen);
947 req->rq_rcv_buf.flags |= XDRBUF_READ;
959 * struct WRITE3args {
967 static void encode_write3args(struct xdr_stream *xdr,
968 const struct nfs_pgio_args *args)
972 encode_nfs_fh3(xdr, args->fh);
974 p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
975 p = xdr_encode_hyper(p, args->offset);
976 *p++ = cpu_to_be32(args->count);
977 *p++ = cpu_to_be32(args->stable);
978 *p = cpu_to_be32(args->count);
979 xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
982 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
983 struct xdr_stream *xdr,
986 const struct nfs_pgio_args *args = data;
988 encode_write3args(xdr, args);
989 xdr->buf->flags |= XDRBUF_WRITE;
1001 * union createhow3 switch (createmode3 mode) {
1004 * sattr3 obj_attributes;
1009 * struct CREATE3args {
1014 static void encode_createhow3(struct xdr_stream *xdr,
1015 const struct nfs3_createargs *args,
1016 struct user_namespace *userns)
1018 encode_uint32(xdr, args->createmode);
1019 switch (args->createmode) {
1020 case NFS3_CREATE_UNCHECKED:
1021 case NFS3_CREATE_GUARDED:
1022 encode_sattr3(xdr, args->sattr, userns);
1024 case NFS3_CREATE_EXCLUSIVE:
1025 encode_createverf3(xdr, args->verifier);
1032 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1033 struct xdr_stream *xdr,
1036 const struct nfs3_createargs *args = data;
1038 encode_diropargs3(xdr, args->fh, args->name, args->len);
1039 encode_createhow3(xdr, args, rpc_rqst_userns(req));
1045 * struct MKDIR3args {
1047 * sattr3 attributes;
1050 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1051 struct xdr_stream *xdr,
1054 const struct nfs3_mkdirargs *args = data;
1056 encode_diropargs3(xdr, args->fh, args->name, args->len);
1057 encode_sattr3(xdr, args->sattr, rpc_rqst_userns(req));
1061 * 3.3.10 SYMLINK3args
1063 * struct symlinkdata3 {
1064 * sattr3 symlink_attributes;
1065 * nfspath3 symlink_data;
1068 * struct SYMLINK3args {
1070 * symlinkdata3 symlink;
1073 static void encode_symlinkdata3(struct xdr_stream *xdr,
1075 struct user_namespace *userns)
1077 const struct nfs3_symlinkargs *args = data;
1079 encode_sattr3(xdr, args->sattr, userns);
1080 encode_nfspath3(xdr, args->pages, args->pathlen);
1083 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1084 struct xdr_stream *xdr,
1087 const struct nfs3_symlinkargs *args = data;
1089 encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1090 encode_symlinkdata3(xdr, args, rpc_rqst_userns(req));
1091 xdr->buf->flags |= XDRBUF_WRITE;
1097 * struct devicedata3 {
1098 * sattr3 dev_attributes;
1102 * union mknoddata3 switch (ftype3 type) {
1105 * devicedata3 device;
1108 * sattr3 pipe_attributes;
1113 * struct MKNOD3args {
1118 static void encode_devicedata3(struct xdr_stream *xdr,
1119 const struct nfs3_mknodargs *args,
1120 struct user_namespace *userns)
1122 encode_sattr3(xdr, args->sattr, userns);
1123 encode_specdata3(xdr, args->rdev);
1126 static void encode_mknoddata3(struct xdr_stream *xdr,
1127 const struct nfs3_mknodargs *args,
1128 struct user_namespace *userns)
1130 encode_ftype3(xdr, args->type);
1131 switch (args->type) {
1134 encode_devicedata3(xdr, args, userns);
1138 encode_sattr3(xdr, args->sattr, userns);
1148 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1149 struct xdr_stream *xdr,
1152 const struct nfs3_mknodargs *args = data;
1154 encode_diropargs3(xdr, args->fh, args->name, args->len);
1155 encode_mknoddata3(xdr, args, rpc_rqst_userns(req));
1159 * 3.3.12 REMOVE3args
1161 * struct REMOVE3args {
1162 * diropargs3 object;
1165 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1166 struct xdr_stream *xdr,
1169 const struct nfs_removeargs *args = data;
1171 encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1175 * 3.3.14 RENAME3args
1177 * struct RENAME3args {
1182 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1183 struct xdr_stream *xdr,
1186 const struct nfs_renameargs *args = data;
1187 const struct qstr *old = args->old_name;
1188 const struct qstr *new = args->new_name;
1190 encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1191 encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1197 * struct LINK3args {
1202 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1203 struct xdr_stream *xdr,
1206 const struct nfs3_linkargs *args = data;
1208 encode_nfs_fh3(xdr, args->fromfh);
1209 encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1213 * 3.3.16 READDIR3args
1215 * struct READDIR3args {
1218 * cookieverf3 cookieverf;
1222 static void encode_readdir3args(struct xdr_stream *xdr,
1223 const struct nfs3_readdirargs *args)
1227 encode_nfs_fh3(xdr, args->fh);
1229 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1230 p = xdr_encode_cookie3(p, args->cookie);
1231 p = xdr_encode_cookieverf3(p, args->verf);
1232 *p = cpu_to_be32(args->count);
1235 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1236 struct xdr_stream *xdr,
1239 const struct nfs3_readdirargs *args = data;
1241 encode_readdir3args(xdr, args);
1242 rpc_prepare_reply_pages(req, args->pages, 0,
1243 args->count, NFS3_readdirres_sz);
1247 * 3.3.17 READDIRPLUS3args
1249 * struct READDIRPLUS3args {
1252 * cookieverf3 cookieverf;
1257 static void encode_readdirplus3args(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 + 4);
1265 p = xdr_encode_cookie3(p, args->cookie);
1266 p = xdr_encode_cookieverf3(p, args->verf);
1269 * readdirplus: need dircount + buffer size.
1270 * We just make sure we make dircount big enough
1272 *p++ = cpu_to_be32(args->count >> 3);
1274 *p = cpu_to_be32(args->count);
1277 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1278 struct xdr_stream *xdr,
1281 const struct nfs3_readdirargs *args = data;
1283 encode_readdirplus3args(xdr, args);
1284 rpc_prepare_reply_pages(req, args->pages, 0,
1285 args->count, NFS3_readdirres_sz);
1289 * 3.3.21 COMMIT3args
1291 * struct COMMIT3args {
1297 static void encode_commit3args(struct xdr_stream *xdr,
1298 const struct nfs_commitargs *args)
1302 encode_nfs_fh3(xdr, args->fh);
1304 p = xdr_reserve_space(xdr, 8 + 4);
1305 p = xdr_encode_hyper(p, args->offset);
1306 *p = cpu_to_be32(args->count);
1309 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1310 struct xdr_stream *xdr,
1313 const struct nfs_commitargs *args = data;
1315 encode_commit3args(xdr, args);
1318 #ifdef CONFIG_NFS_V3_ACL
1320 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1321 struct xdr_stream *xdr,
1324 const struct nfs3_getaclargs *args = data;
1326 encode_nfs_fh3(xdr, args->fh);
1327 encode_uint32(xdr, args->mask);
1328 if (args->mask & (NFS_ACL | NFS_DFACL)) {
1329 rpc_prepare_reply_pages(req, args->pages, 0,
1330 NFSACL_MAXPAGES << PAGE_SHIFT,
1332 req->rq_rcv_buf.flags |= XDRBUF_SPARSE_PAGES;
1336 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1337 struct xdr_stream *xdr,
1340 const struct nfs3_setaclargs *args = data;
1344 encode_nfs_fh3(xdr, NFS_FH(args->inode));
1345 encode_uint32(xdr, args->mask);
1347 base = req->rq_slen;
1348 if (args->npages != 0)
1349 xdr_write_pages(xdr, args->pages, 0, args->len);
1351 xdr_reserve_space(xdr, args->len);
1353 error = nfsacl_encode(xdr->buf, base, args->inode,
1354 (args->mask & NFS_ACL) ?
1355 args->acl_access : NULL, 1, 0);
1356 /* FIXME: this is just broken */
1358 error = nfsacl_encode(xdr->buf, base + error, args->inode,
1359 (args->mask & NFS_DFACL) ?
1360 args->acl_default : NULL, 1,
1365 #endif /* CONFIG_NFS_V3_ACL */
1368 * NFSv3 XDR decode functions
1370 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1371 * "NFS Version 3 Protocol Specification".
1377 * struct GETATTR3resok {
1378 * fattr3 obj_attributes;
1381 * union GETATTR3res switch (nfsstat3 status) {
1383 * GETATTR3resok resok;
1388 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req,
1389 struct xdr_stream *xdr,
1392 enum nfs_stat status;
1395 error = decode_nfsstat3(xdr, &status);
1396 if (unlikely(error))
1398 if (status != NFS3_OK)
1400 error = decode_fattr3(xdr, result, rpc_rqst_userns(req));
1404 return nfs3_stat_to_errno(status);
1410 * struct SETATTR3resok {
1414 * struct SETATTR3resfail {
1418 * union SETATTR3res switch (nfsstat3 status) {
1420 * SETATTR3resok resok;
1422 * SETATTR3resfail resfail;
1425 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req,
1426 struct xdr_stream *xdr,
1429 enum nfs_stat status;
1432 error = decode_nfsstat3(xdr, &status);
1433 if (unlikely(error))
1435 error = decode_wcc_data(xdr, result, rpc_rqst_userns(req));
1436 if (unlikely(error))
1438 if (status != NFS3_OK)
1443 return nfs3_stat_to_errno(status);
1449 * struct LOOKUP3resok {
1451 * post_op_attr obj_attributes;
1452 * post_op_attr dir_attributes;
1455 * struct LOOKUP3resfail {
1456 * post_op_attr dir_attributes;
1459 * union LOOKUP3res switch (nfsstat3 status) {
1461 * LOOKUP3resok resok;
1463 * LOOKUP3resfail resfail;
1466 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req,
1467 struct xdr_stream *xdr,
1470 struct user_namespace *userns = rpc_rqst_userns(req);
1471 struct nfs3_diropres *result = data;
1472 enum nfs_stat status;
1475 error = decode_nfsstat3(xdr, &status);
1476 if (unlikely(error))
1478 if (status != NFS3_OK)
1480 error = decode_nfs_fh3(xdr, result->fh);
1481 if (unlikely(error))
1483 error = decode_post_op_attr(xdr, result->fattr, userns);
1484 if (unlikely(error))
1486 error = decode_post_op_attr(xdr, result->dir_attr, userns);
1490 error = decode_post_op_attr(xdr, result->dir_attr, userns);
1491 if (unlikely(error))
1493 return nfs3_stat_to_errno(status);
1499 * struct ACCESS3resok {
1500 * post_op_attr obj_attributes;
1504 * struct ACCESS3resfail {
1505 * post_op_attr obj_attributes;
1508 * union ACCESS3res switch (nfsstat3 status) {
1510 * ACCESS3resok resok;
1512 * ACCESS3resfail resfail;
1515 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req,
1516 struct xdr_stream *xdr,
1519 struct nfs3_accessres *result = data;
1520 enum nfs_stat status;
1523 error = decode_nfsstat3(xdr, &status);
1524 if (unlikely(error))
1526 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1527 if (unlikely(error))
1529 if (status != NFS3_OK)
1531 error = decode_uint32(xdr, &result->access);
1535 return nfs3_stat_to_errno(status);
1539 * 3.3.5 READLINK3res
1541 * struct READLINK3resok {
1542 * post_op_attr symlink_attributes;
1546 * struct READLINK3resfail {
1547 * post_op_attr symlink_attributes;
1550 * union READLINK3res switch (nfsstat3 status) {
1552 * READLINK3resok resok;
1554 * READLINK3resfail resfail;
1557 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req,
1558 struct xdr_stream *xdr,
1561 enum nfs_stat status;
1564 error = decode_nfsstat3(xdr, &status);
1565 if (unlikely(error))
1567 error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
1568 if (unlikely(error))
1570 if (status != NFS3_OK)
1572 error = decode_nfspath3(xdr);
1576 return nfs3_stat_to_errno(status);
1582 * struct READ3resok {
1583 * post_op_attr file_attributes;
1589 * struct READ3resfail {
1590 * post_op_attr file_attributes;
1593 * union READ3res switch (nfsstat3 status) {
1597 * READ3resfail resfail;
1600 static int decode_read3resok(struct xdr_stream *xdr,
1601 struct nfs_pgio_res *result)
1603 u32 eof, count, ocount, recvd;
1606 p = xdr_inline_decode(xdr, 4 + 4 + 4);
1609 count = be32_to_cpup(p++);
1610 eof = be32_to_cpup(p++);
1611 ocount = be32_to_cpup(p++);
1612 if (unlikely(ocount != count))
1614 recvd = xdr_read_pages(xdr, count);
1615 if (unlikely(count > recvd))
1619 result->count = count;
1622 dprintk("NFS: READ count doesn't match length of opaque: "
1623 "count %u != ocount %u\n", count, ocount);
1626 dprintk("NFS: server cheating in read result: "
1627 "count %u > recvd %u\n", count, recvd);
1633 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1636 struct nfs_pgio_res *result = data;
1638 enum nfs_stat status;
1641 pos = xdr_stream_pos(xdr);
1642 error = decode_nfsstat3(xdr, &status);
1643 if (unlikely(error))
1645 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
1646 if (unlikely(error))
1648 result->op_status = status;
1649 if (status != NFS3_OK)
1651 result->replen = 4 + ((xdr_stream_pos(xdr) - pos) >> 2);
1652 error = decode_read3resok(xdr, result);
1656 return nfs3_stat_to_errno(status);
1668 * struct WRITE3resok {
1669 * wcc_data file_wcc;
1671 * stable_how committed;
1675 * struct WRITE3resfail {
1676 * wcc_data file_wcc;
1679 * union WRITE3res switch (nfsstat3 status) {
1681 * WRITE3resok resok;
1683 * WRITE3resfail resfail;
1686 static int decode_write3resok(struct xdr_stream *xdr,
1687 struct nfs_pgio_res *result)
1691 p = xdr_inline_decode(xdr, 4 + 4);
1694 result->count = be32_to_cpup(p++);
1695 result->verf->committed = be32_to_cpup(p++);
1696 if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1698 if (decode_writeverf3(xdr, &result->verf->verifier))
1700 return result->count;
1702 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1706 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1709 struct nfs_pgio_res *result = data;
1710 enum nfs_stat status;
1713 error = decode_nfsstat3(xdr, &status);
1714 if (unlikely(error))
1716 error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
1717 if (unlikely(error))
1719 result->op_status = status;
1720 if (status != NFS3_OK)
1722 error = decode_write3resok(xdr, result);
1726 return nfs3_stat_to_errno(status);
1732 * struct CREATE3resok {
1734 * post_op_attr obj_attributes;
1738 * struct CREATE3resfail {
1742 * union CREATE3res switch (nfsstat3 status) {
1744 * CREATE3resok resok;
1746 * CREATE3resfail resfail;
1749 static int decode_create3resok(struct xdr_stream *xdr,
1750 struct nfs3_diropres *result,
1751 struct user_namespace *userns)
1755 error = decode_post_op_fh3(xdr, result->fh);
1756 if (unlikely(error))
1758 error = decode_post_op_attr(xdr, result->fattr, userns);
1759 if (unlikely(error))
1761 /* The server isn't required to return a file handle.
1762 * If it didn't, force the client to perform a LOOKUP
1763 * to determine the correct file handle and attribute
1764 * values for the new object. */
1765 if (result->fh->size == 0)
1766 result->fattr->valid = 0;
1767 error = decode_wcc_data(xdr, result->dir_attr, userns);
1772 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req,
1773 struct xdr_stream *xdr,
1776 struct user_namespace *userns = rpc_rqst_userns(req);
1777 struct nfs3_diropres *result = data;
1778 enum nfs_stat status;
1781 error = decode_nfsstat3(xdr, &status);
1782 if (unlikely(error))
1784 if (status != NFS3_OK)
1786 error = decode_create3resok(xdr, result, userns);
1790 error = decode_wcc_data(xdr, result->dir_attr, userns);
1791 if (unlikely(error))
1793 return nfs3_stat_to_errno(status);
1799 * struct REMOVE3resok {
1803 * struct REMOVE3resfail {
1807 * union REMOVE3res switch (nfsstat3 status) {
1809 * REMOVE3resok resok;
1811 * REMOVE3resfail resfail;
1814 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req,
1815 struct xdr_stream *xdr,
1818 struct nfs_removeres *result = data;
1819 enum nfs_stat status;
1822 error = decode_nfsstat3(xdr, &status);
1823 if (unlikely(error))
1825 error = decode_wcc_data(xdr, result->dir_attr, rpc_rqst_userns(req));
1826 if (unlikely(error))
1828 if (status != NFS3_OK)
1833 return nfs3_stat_to_errno(status);
1839 * struct RENAME3resok {
1840 * wcc_data fromdir_wcc;
1841 * wcc_data todir_wcc;
1844 * struct RENAME3resfail {
1845 * wcc_data fromdir_wcc;
1846 * wcc_data todir_wcc;
1849 * union RENAME3res switch (nfsstat3 status) {
1851 * RENAME3resok resok;
1853 * RENAME3resfail resfail;
1856 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req,
1857 struct xdr_stream *xdr,
1860 struct user_namespace *userns = rpc_rqst_userns(req);
1861 struct nfs_renameres *result = data;
1862 enum nfs_stat status;
1865 error = decode_nfsstat3(xdr, &status);
1866 if (unlikely(error))
1868 error = decode_wcc_data(xdr, result->old_fattr, userns);
1869 if (unlikely(error))
1871 error = decode_wcc_data(xdr, result->new_fattr, userns);
1872 if (unlikely(error))
1874 if (status != NFS3_OK)
1879 return nfs3_stat_to_errno(status);
1885 * struct LINK3resok {
1886 * post_op_attr file_attributes;
1887 * wcc_data linkdir_wcc;
1890 * struct LINK3resfail {
1891 * post_op_attr file_attributes;
1892 * wcc_data linkdir_wcc;
1895 * union LINK3res switch (nfsstat3 status) {
1899 * LINK3resfail resfail;
1902 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, struct xdr_stream *xdr,
1905 struct user_namespace *userns = rpc_rqst_userns(req);
1906 struct nfs3_linkres *result = data;
1907 enum nfs_stat status;
1910 error = decode_nfsstat3(xdr, &status);
1911 if (unlikely(error))
1913 error = decode_post_op_attr(xdr, result->fattr, userns);
1914 if (unlikely(error))
1916 error = decode_wcc_data(xdr, result->dir_attr, userns);
1917 if (unlikely(error))
1919 if (status != NFS3_OK)
1924 return nfs3_stat_to_errno(status);
1928 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1929 * the local page cache
1930 * @xdr: XDR stream where entry resides
1931 * @entry: buffer to fill in with entry data
1932 * @plus: boolean indicating whether this should be a readdirplus entry
1934 * Returns zero if successful, otherwise a negative errno value is
1937 * This function is not invoked during READDIR reply decoding, but
1938 * rather whenever an application invokes the getdents(2) system call
1939 * on a directory already in our cache.
1947 * fhandle3 filehandle;
1948 * post_op_attr3 attributes;
1949 * entry3 *nextentry;
1953 * struct entryplus3 {
1957 * post_op_attr name_attributes;
1958 * post_op_fh3 name_handle;
1959 * entryplus3 *nextentry;
1962 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1965 struct user_namespace *userns = rpc_userns(entry->server->client);
1966 struct nfs_entry old = *entry;
1971 p = xdr_inline_decode(xdr, 4);
1974 if (*p == xdr_zero) {
1975 p = xdr_inline_decode(xdr, 4);
1984 error = decode_fileid3(xdr, &entry->ino);
1985 if (unlikely(error))
1988 error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1989 if (unlikely(error))
1992 error = decode_cookie3(xdr, &new_cookie);
1993 if (unlikely(error))
1996 entry->d_type = DT_UNKNOWN;
1999 entry->fattr->valid = 0;
2000 error = decode_post_op_attr(xdr, entry->fattr, userns);
2001 if (unlikely(error))
2003 if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
2004 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
2006 if (entry->fattr->fileid != entry->ino) {
2007 entry->fattr->mounted_on_fileid = entry->ino;
2008 entry->fattr->valid |= NFS_ATTR_FATTR_MOUNTED_ON_FILEID;
2011 /* In fact, a post_op_fh3: */
2012 p = xdr_inline_decode(xdr, 4);
2015 if (*p != xdr_zero) {
2016 error = decode_nfs_fh3(xdr, entry->fh);
2017 if (unlikely(error)) {
2018 if (error == -E2BIG)
2023 zero_nfs_fh3(entry->fh);
2026 entry->prev_cookie = entry->cookie;
2027 entry->cookie = new_cookie;
2032 dprintk("NFS: directory entry contains invalid file handle\n");
2038 * 3.3.16 READDIR3res
2045 * struct READDIR3resok {
2046 * post_op_attr dir_attributes;
2047 * cookieverf3 cookieverf;
2051 * struct READDIR3resfail {
2052 * post_op_attr dir_attributes;
2055 * union READDIR3res switch (nfsstat3 status) {
2057 * READDIR3resok resok;
2059 * READDIR3resfail resfail;
2062 * Read the directory contents into the page cache, but otherwise
2063 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2064 * during subsequent nfs_readdir() calls.
2066 static int decode_dirlist3(struct xdr_stream *xdr)
2068 return xdr_read_pages(xdr, xdr->buf->page_len);
2071 static int decode_readdir3resok(struct xdr_stream *xdr,
2072 struct nfs3_readdirres *result,
2073 struct user_namespace *userns)
2077 error = decode_post_op_attr(xdr, result->dir_attr, userns);
2078 if (unlikely(error))
2080 /* XXX: do we need to check if result->verf != NULL ? */
2081 error = decode_cookieverf3(xdr, result->verf);
2082 if (unlikely(error))
2084 error = decode_dirlist3(xdr);
2089 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req,
2090 struct xdr_stream *xdr,
2093 struct nfs3_readdirres *result = data;
2094 enum nfs_stat status;
2097 error = decode_nfsstat3(xdr, &status);
2098 if (unlikely(error))
2100 if (status != NFS3_OK)
2102 error = decode_readdir3resok(xdr, result, rpc_rqst_userns(req));
2106 error = decode_post_op_attr(xdr, result->dir_attr, rpc_rqst_userns(req));
2107 if (unlikely(error))
2109 return nfs3_stat_to_errno(status);
2115 * struct FSSTAT3resok {
2116 * post_op_attr obj_attributes;
2126 * struct FSSTAT3resfail {
2127 * post_op_attr obj_attributes;
2130 * union FSSTAT3res switch (nfsstat3 status) {
2132 * FSSTAT3resok resok;
2134 * FSSTAT3resfail resfail;
2137 static int decode_fsstat3resok(struct xdr_stream *xdr,
2138 struct nfs_fsstat *result)
2142 p = xdr_inline_decode(xdr, 8 * 6 + 4);
2145 p = xdr_decode_size3(p, &result->tbytes);
2146 p = xdr_decode_size3(p, &result->fbytes);
2147 p = xdr_decode_size3(p, &result->abytes);
2148 p = xdr_decode_size3(p, &result->tfiles);
2149 p = xdr_decode_size3(p, &result->ffiles);
2150 xdr_decode_size3(p, &result->afiles);
2151 /* ignore invarsec */
2155 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req,
2156 struct xdr_stream *xdr,
2159 struct nfs_fsstat *result = data;
2160 enum nfs_stat status;
2163 error = decode_nfsstat3(xdr, &status);
2164 if (unlikely(error))
2166 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2167 if (unlikely(error))
2169 if (status != NFS3_OK)
2171 error = decode_fsstat3resok(xdr, result);
2175 return nfs3_stat_to_errno(status);
2181 * struct FSINFO3resok {
2182 * post_op_attr obj_attributes;
2190 * size3 maxfilesize;
2191 * nfstime3 time_delta;
2192 * uint32 properties;
2195 * struct FSINFO3resfail {
2196 * post_op_attr obj_attributes;
2199 * union FSINFO3res switch (nfsstat3 status) {
2201 * FSINFO3resok resok;
2203 * FSINFO3resfail resfail;
2206 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2207 struct nfs_fsinfo *result)
2211 p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2214 result->rtmax = be32_to_cpup(p++);
2215 result->rtpref = be32_to_cpup(p++);
2216 result->rtmult = be32_to_cpup(p++);
2217 result->wtmax = be32_to_cpup(p++);
2218 result->wtpref = be32_to_cpup(p++);
2219 result->wtmult = be32_to_cpup(p++);
2220 result->dtpref = be32_to_cpup(p++);
2221 p = xdr_decode_size3(p, &result->maxfilesize);
2222 xdr_decode_nfstime3(p, &result->time_delta);
2224 /* ignore properties */
2225 result->lease_time = 0;
2229 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req,
2230 struct xdr_stream *xdr,
2233 struct nfs_fsinfo *result = data;
2234 enum nfs_stat status;
2237 error = decode_nfsstat3(xdr, &status);
2238 if (unlikely(error))
2240 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2241 if (unlikely(error))
2243 if (status != NFS3_OK)
2245 error = decode_fsinfo3resok(xdr, result);
2249 return nfs3_stat_to_errno(status);
2253 * 3.3.20 PATHCONF3res
2255 * struct PATHCONF3resok {
2256 * post_op_attr obj_attributes;
2260 * bool chown_restricted;
2261 * bool case_insensitive;
2262 * bool case_preserving;
2265 * struct PATHCONF3resfail {
2266 * post_op_attr obj_attributes;
2269 * union PATHCONF3res switch (nfsstat3 status) {
2271 * PATHCONF3resok resok;
2273 * PATHCONF3resfail resfail;
2276 static int decode_pathconf3resok(struct xdr_stream *xdr,
2277 struct nfs_pathconf *result)
2281 p = xdr_inline_decode(xdr, 4 * 6);
2284 result->max_link = be32_to_cpup(p++);
2285 result->max_namelen = be32_to_cpup(p);
2286 /* ignore remaining fields */
2290 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req,
2291 struct xdr_stream *xdr,
2294 struct nfs_pathconf *result = data;
2295 enum nfs_stat status;
2298 error = decode_nfsstat3(xdr, &status);
2299 if (unlikely(error))
2301 error = decode_post_op_attr(xdr, result->fattr, rpc_rqst_userns(req));
2302 if (unlikely(error))
2304 if (status != NFS3_OK)
2306 error = decode_pathconf3resok(xdr, result);
2310 return nfs3_stat_to_errno(status);
2316 * struct COMMIT3resok {
2317 * wcc_data file_wcc;
2321 * struct COMMIT3resfail {
2322 * wcc_data file_wcc;
2325 * union COMMIT3res switch (nfsstat3 status) {
2327 * COMMIT3resok resok;
2329 * COMMIT3resfail resfail;
2332 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req,
2333 struct xdr_stream *xdr,
2336 struct nfs_commitres *result = data;
2337 enum nfs_stat status;
2340 error = decode_nfsstat3(xdr, &status);
2341 if (unlikely(error))
2343 error = decode_wcc_data(xdr, result->fattr, rpc_rqst_userns(req));
2344 if (unlikely(error))
2346 result->op_status = status;
2347 if (status != NFS3_OK)
2349 error = decode_writeverf3(xdr, &result->verf->verifier);
2353 return nfs3_stat_to_errno(status);
2356 #ifdef CONFIG_NFS_V3_ACL
2358 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2359 struct nfs3_getaclres *result,
2360 struct user_namespace *userns)
2362 struct posix_acl **acl;
2363 unsigned int *aclcnt;
2367 error = decode_post_op_attr(xdr, result->fattr, userns);
2368 if (unlikely(error))
2370 error = decode_uint32(xdr, &result->mask);
2371 if (unlikely(error))
2374 if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2377 hdrlen = xdr_stream_pos(xdr);
2380 if (result->mask & NFS_ACL)
2381 acl = &result->acl_access;
2383 if (result->mask & NFS_ACLCNT)
2384 aclcnt = &result->acl_access_count;
2385 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2386 if (unlikely(error <= 0))
2390 if (result->mask & NFS_DFACL)
2391 acl = &result->acl_default;
2393 if (result->mask & NFS_DFACLCNT)
2394 aclcnt = &result->acl_default_count;
2395 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2396 if (unlikely(error <= 0))
2403 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req,
2404 struct xdr_stream *xdr,
2407 enum nfs_stat status;
2410 error = decode_nfsstat3(xdr, &status);
2411 if (unlikely(error))
2413 if (status != NFS3_OK)
2415 error = decode_getacl3resok(xdr, result, rpc_rqst_userns(req));
2419 return nfs3_stat_to_errno(status);
2422 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req,
2423 struct xdr_stream *xdr,
2426 enum nfs_stat status;
2429 error = decode_nfsstat3(xdr, &status);
2430 if (unlikely(error))
2432 if (status != NFS3_OK)
2434 error = decode_post_op_attr(xdr, result, rpc_rqst_userns(req));
2438 return nfs3_stat_to_errno(status);
2441 #endif /* CONFIG_NFS_V3_ACL */
2445 * We need to translate between nfs status return values and
2446 * the local errno values which may not be the same.
2448 static const struct {
2453 { NFSERR_PERM, -EPERM },
2454 { NFSERR_NOENT, -ENOENT },
2455 { NFSERR_IO, -errno_NFSERR_IO},
2456 { NFSERR_NXIO, -ENXIO },
2457 /* { NFSERR_EAGAIN, -EAGAIN }, */
2458 { NFSERR_ACCES, -EACCES },
2459 { NFSERR_EXIST, -EEXIST },
2460 { NFSERR_XDEV, -EXDEV },
2461 { NFSERR_NODEV, -ENODEV },
2462 { NFSERR_NOTDIR, -ENOTDIR },
2463 { NFSERR_ISDIR, -EISDIR },
2464 { NFSERR_INVAL, -EINVAL },
2465 { NFSERR_FBIG, -EFBIG },
2466 { NFSERR_NOSPC, -ENOSPC },
2467 { NFSERR_ROFS, -EROFS },
2468 { NFSERR_MLINK, -EMLINK },
2469 { NFSERR_NAMETOOLONG, -ENAMETOOLONG },
2470 { NFSERR_NOTEMPTY, -ENOTEMPTY },
2471 { NFSERR_DQUOT, -EDQUOT },
2472 { NFSERR_STALE, -ESTALE },
2473 { NFSERR_REMOTE, -EREMOTE },
2475 { NFSERR_WFLUSH, -EWFLUSH },
2477 { NFSERR_BADHANDLE, -EBADHANDLE },
2478 { NFSERR_NOT_SYNC, -ENOTSYNC },
2479 { NFSERR_BAD_COOKIE, -EBADCOOKIE },
2480 { NFSERR_NOTSUPP, -ENOTSUPP },
2481 { NFSERR_TOOSMALL, -ETOOSMALL },
2482 { NFSERR_SERVERFAULT, -EREMOTEIO },
2483 { NFSERR_BADTYPE, -EBADTYPE },
2484 { NFSERR_JUKEBOX, -EJUKEBOX },
2489 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2490 * @status: NFS status code to convert
2492 * Returns a local errno value, or -EIO if the NFS status code is
2493 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2495 static int nfs3_stat_to_errno(enum nfs_stat status)
2499 for (i = 0; nfs_errtbl[i].stat != -1; i++) {
2500 if (nfs_errtbl[i].stat == (int)status)
2501 return nfs_errtbl[i].errno;
2503 dprintk("NFS: Unrecognized nfs status value: %u\n", status);
2504 return nfs_errtbl[i].errno;
2508 #define PROC(proc, argtype, restype, timer) \
2509 [NFS3PROC_##proc] = { \
2510 .p_proc = NFS3PROC_##proc, \
2511 .p_encode = nfs3_xdr_enc_##argtype##3args, \
2512 .p_decode = nfs3_xdr_dec_##restype##3res, \
2513 .p_arglen = NFS3_##argtype##args_sz, \
2514 .p_replen = NFS3_##restype##res_sz, \
2516 .p_statidx = NFS3PROC_##proc, \
2520 const struct rpc_procinfo nfs3_procedures[] = {
2521 PROC(GETATTR, getattr, getattr, 1),
2522 PROC(SETATTR, setattr, setattr, 0),
2523 PROC(LOOKUP, lookup, lookup, 2),
2524 PROC(ACCESS, access, access, 1),
2525 PROC(READLINK, readlink, readlink, 3),
2526 PROC(READ, read, read, 3),
2527 PROC(WRITE, write, write, 4),
2528 PROC(CREATE, create, create, 0),
2529 PROC(MKDIR, mkdir, create, 0),
2530 PROC(SYMLINK, symlink, create, 0),
2531 PROC(MKNOD, mknod, create, 0),
2532 PROC(REMOVE, remove, remove, 0),
2533 PROC(RMDIR, lookup, setattr, 0),
2534 PROC(RENAME, rename, rename, 0),
2535 PROC(LINK, link, link, 0),
2536 PROC(READDIR, readdir, readdir, 3),
2537 PROC(READDIRPLUS, readdirplus, readdir, 3),
2538 PROC(FSSTAT, getattr, fsstat, 0),
2539 PROC(FSINFO, getattr, fsinfo, 0),
2540 PROC(PATHCONF, getattr, pathconf, 0),
2541 PROC(COMMIT, commit, commit, 5),
2544 static unsigned int nfs_version3_counts[ARRAY_SIZE(nfs3_procedures)];
2545 const struct rpc_version nfs_version3 = {
2547 .nrprocs = ARRAY_SIZE(nfs3_procedures),
2548 .procs = nfs3_procedures,
2549 .counts = nfs_version3_counts,
2552 #ifdef CONFIG_NFS_V3_ACL
2553 static const struct rpc_procinfo nfs3_acl_procedures[] = {
2554 [ACLPROC3_GETACL] = {
2555 .p_proc = ACLPROC3_GETACL,
2556 .p_encode = nfs3_xdr_enc_getacl3args,
2557 .p_decode = nfs3_xdr_dec_getacl3res,
2558 .p_arglen = ACL3_getaclargs_sz,
2559 .p_replen = ACL3_getaclres_sz,
2563 [ACLPROC3_SETACL] = {
2564 .p_proc = ACLPROC3_SETACL,
2565 .p_encode = nfs3_xdr_enc_setacl3args,
2566 .p_decode = nfs3_xdr_dec_setacl3res,
2567 .p_arglen = ACL3_setaclargs_sz,
2568 .p_replen = ACL3_setaclres_sz,
2574 static unsigned int nfs3_acl_counts[ARRAY_SIZE(nfs3_acl_procedures)];
2575 const struct rpc_version nfsacl_version3 = {
2577 .nrprocs = ARRAY_SIZE(nfs3_acl_procedures),
2578 .procs = nfs3_acl_procedures,
2579 .counts = nfs3_acl_counts,
2581 #endif /* CONFIG_NFS_V3_ACL */