2 * linux/fs/nfs/nfs3xdr.c
4 * XDR functions to encode/decode NFSv3 RPC arguments and results.
6 * Copyright (C) 1996, 1997 Olaf Kirch
9 #include <linux/param.h>
10 #include <linux/time.h>
12 #include <linux/errno.h>
13 #include <linux/string.h>
15 #include <linux/pagemap.h>
16 #include <linux/proc_fs.h>
17 #include <linux/kdev_t.h>
18 #include <linux/sunrpc/clnt.h>
19 #include <linux/nfs.h>
20 #include <linux/nfs3.h>
21 #include <linux/nfs_fs.h>
22 #include <linux/nfsacl.h>
25 #define NFSDBG_FACILITY NFSDBG_XDR
27 /* Mapping from NFS error code to "errno" error code. */
28 #define errno_NFSERR_IO EIO
31 * Declare the space requirements for NFS arguments and replies as
32 * number of 32bit-words
34 #define NFS3_fhandle_sz (1+16)
35 #define NFS3_fh_sz (NFS3_fhandle_sz) /* shorthand */
36 #define NFS3_sattr_sz (15)
37 #define NFS3_filename_sz (1+(NFS3_MAXNAMLEN>>2))
38 #define NFS3_path_sz (1+(NFS3_MAXPATHLEN>>2))
39 #define NFS3_fattr_sz (21)
40 #define NFS3_cookieverf_sz (NFS3_COOKIEVERFSIZE>>2)
41 #define NFS3_wcc_attr_sz (6)
42 #define NFS3_pre_op_attr_sz (1+NFS3_wcc_attr_sz)
43 #define NFS3_post_op_attr_sz (1+NFS3_fattr_sz)
44 #define NFS3_wcc_data_sz (NFS3_pre_op_attr_sz+NFS3_post_op_attr_sz)
45 #define NFS3_diropargs_sz (NFS3_fh_sz+NFS3_filename_sz)
47 #define NFS3_getattrargs_sz (NFS3_fh_sz)
48 #define NFS3_setattrargs_sz (NFS3_fh_sz+NFS3_sattr_sz+3)
49 #define NFS3_lookupargs_sz (NFS3_fh_sz+NFS3_filename_sz)
50 #define NFS3_accessargs_sz (NFS3_fh_sz+1)
51 #define NFS3_readlinkargs_sz (NFS3_fh_sz)
52 #define NFS3_readargs_sz (NFS3_fh_sz+3)
53 #define NFS3_writeargs_sz (NFS3_fh_sz+5)
54 #define NFS3_createargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
55 #define NFS3_mkdirargs_sz (NFS3_diropargs_sz+NFS3_sattr_sz)
56 #define NFS3_symlinkargs_sz (NFS3_diropargs_sz+1+NFS3_sattr_sz)
57 #define NFS3_mknodargs_sz (NFS3_diropargs_sz+2+NFS3_sattr_sz)
58 #define NFS3_removeargs_sz (NFS3_fh_sz+NFS3_filename_sz)
59 #define NFS3_renameargs_sz (NFS3_diropargs_sz+NFS3_diropargs_sz)
60 #define NFS3_linkargs_sz (NFS3_fh_sz+NFS3_diropargs_sz)
61 #define NFS3_readdirargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+3)
62 #define NFS3_readdirplusargs_sz (NFS3_fh_sz+NFS3_cookieverf_sz+4)
63 #define NFS3_commitargs_sz (NFS3_fh_sz+3)
65 #define NFS3_getattrres_sz (1+NFS3_fattr_sz)
66 #define NFS3_setattrres_sz (1+NFS3_wcc_data_sz)
67 #define NFS3_removeres_sz (NFS3_setattrres_sz)
68 #define NFS3_lookupres_sz (1+NFS3_fh_sz+(2 * NFS3_post_op_attr_sz))
69 #define NFS3_accessres_sz (1+NFS3_post_op_attr_sz+1)
70 #define NFS3_readlinkres_sz (1+NFS3_post_op_attr_sz+1)
71 #define NFS3_readres_sz (1+NFS3_post_op_attr_sz+3)
72 #define NFS3_writeres_sz (1+NFS3_wcc_data_sz+4)
73 #define NFS3_createres_sz (1+NFS3_fh_sz+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
74 #define NFS3_renameres_sz (1+(2 * NFS3_wcc_data_sz))
75 #define NFS3_linkres_sz (1+NFS3_post_op_attr_sz+NFS3_wcc_data_sz)
76 #define NFS3_readdirres_sz (1+NFS3_post_op_attr_sz+2)
77 #define NFS3_fsstatres_sz (1+NFS3_post_op_attr_sz+13)
78 #define NFS3_fsinfores_sz (1+NFS3_post_op_attr_sz+12)
79 #define NFS3_pathconfres_sz (1+NFS3_post_op_attr_sz+6)
80 #define NFS3_commitres_sz (1+NFS3_wcc_data_sz+2)
82 #define ACL3_getaclargs_sz (NFS3_fh_sz+1)
83 #define ACL3_setaclargs_sz (NFS3_fh_sz+1+ \
84 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
85 #define ACL3_getaclres_sz (1+NFS3_post_op_attr_sz+1+ \
86 XDR_QUADLEN(NFS_ACL_INLINE_BUFSIZE))
87 #define ACL3_setaclres_sz (1+NFS3_post_op_attr_sz)
90 * Map file type to S_IFMT bits
92 static const umode_t nfs_type2fmt[] = {
104 * While encoding arguments, set up the reply buffer in advance to
105 * receive reply data directly into the page cache.
107 static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages,
108 unsigned int base, unsigned int len,
109 unsigned int bufsize)
111 struct rpc_auth *auth = req->rq_cred->cr_auth;
114 replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize;
115 xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len);
119 * Handle decode buffer overflows out-of-line.
121 static void print_overflow_msg(const char *func, const struct xdr_stream *xdr)
123 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
124 "Remaining buffer length is %tu words.\n",
125 func, xdr->end - xdr->p);
130 * Encode/decode NFSv3 basic data types
132 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
133 * "NFS Version 3 Protocol Specification".
135 * Not all basic data types have their own encoding and decoding
136 * functions. For run-time efficiency, some data types are encoded
140 static void encode_uint32(struct xdr_stream *xdr, u32 value)
142 __be32 *p = xdr_reserve_space(xdr, 4);
143 *p = cpu_to_be32(value);
146 static int decode_uint32(struct xdr_stream *xdr, u32 *value)
150 p = xdr_inline_decode(xdr, 4);
151 if (unlikely(p == NULL))
153 *value = be32_to_cpup(p);
156 print_overflow_msg(__func__, xdr);
160 static int decode_uint64(struct xdr_stream *xdr, u64 *value)
164 p = xdr_inline_decode(xdr, 8);
165 if (unlikely(p == NULL))
167 xdr_decode_hyper(p, value);
170 print_overflow_msg(__func__, xdr);
177 * typedef uint64 fileid3;
179 static __be32 *xdr_decode_fileid3(__be32 *p, u64 *fileid)
181 return xdr_decode_hyper(p, fileid);
184 static int decode_fileid3(struct xdr_stream *xdr, u64 *fileid)
186 return decode_uint64(xdr, fileid);
192 * typedef string filename3<>;
194 static void encode_filename3(struct xdr_stream *xdr,
195 const char *name, u32 length)
199 BUG_ON(length > NFS3_MAXNAMLEN);
200 p = xdr_reserve_space(xdr, 4 + length);
201 xdr_encode_opaque(p, name, length);
204 static int decode_inline_filename3(struct xdr_stream *xdr,
205 const char **name, u32 *length)
210 p = xdr_inline_decode(xdr, 4);
211 if (unlikely(p == NULL))
213 count = be32_to_cpup(p);
214 if (count > NFS3_MAXNAMLEN)
215 goto out_nametoolong;
216 p = xdr_inline_decode(xdr, count);
217 if (unlikely(p == NULL))
219 *name = (const char *)p;
224 dprintk("NFS: returned filename too long: %u\n", count);
225 return -ENAMETOOLONG;
227 print_overflow_msg(__func__, xdr);
234 * typedef string nfspath3<>;
236 static void encode_nfspath3(struct xdr_stream *xdr, struct page **pages,
239 BUG_ON(length > NFS3_MAXPATHLEN);
240 encode_uint32(xdr, length);
241 xdr_write_pages(xdr, pages, 0, length);
244 static int decode_nfspath3(struct xdr_stream *xdr)
250 p = xdr_inline_decode(xdr, 4);
251 if (unlikely(p == NULL))
253 count = be32_to_cpup(p);
254 if (unlikely(count >= xdr->buf->page_len || count > NFS3_MAXPATHLEN))
255 goto out_nametoolong;
256 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
257 recvd = xdr->buf->len - hdrlen;
258 if (unlikely(count > recvd))
261 xdr_read_pages(xdr, count);
262 xdr_terminate_string(xdr->buf, count);
266 dprintk("NFS: returned pathname too long: %u\n", count);
267 return -ENAMETOOLONG;
269 dprintk("NFS: server cheating in pathname result: "
270 "count %u > recvd %u\n", count, recvd);
273 print_overflow_msg(__func__, xdr);
280 * typedef uint64 cookie3
282 static __be32 *xdr_encode_cookie3(__be32 *p, u64 cookie)
284 return xdr_encode_hyper(p, cookie);
287 static int decode_cookie3(struct xdr_stream *xdr, u64 *cookie)
289 return decode_uint64(xdr, cookie);
295 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
297 static __be32 *xdr_encode_cookieverf3(__be32 *p, const __be32 *verifier)
299 memcpy(p, verifier, NFS3_COOKIEVERFSIZE);
300 return p + XDR_QUADLEN(NFS3_COOKIEVERFSIZE);
303 static int decode_cookieverf3(struct xdr_stream *xdr, __be32 *verifier)
307 p = xdr_inline_decode(xdr, NFS3_COOKIEVERFSIZE);
308 if (unlikely(p == NULL))
310 memcpy(verifier, p, NFS3_COOKIEVERFSIZE);
313 print_overflow_msg(__func__, xdr);
320 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
322 static void encode_createverf3(struct xdr_stream *xdr, const __be32 *verifier)
326 p = xdr_reserve_space(xdr, NFS3_CREATEVERFSIZE);
327 memcpy(p, verifier, NFS3_CREATEVERFSIZE);
330 static int decode_writeverf3(struct xdr_stream *xdr, __be32 *verifier)
334 p = xdr_inline_decode(xdr, NFS3_WRITEVERFSIZE);
335 if (unlikely(p == NULL))
337 memcpy(verifier, p, NFS3_WRITEVERFSIZE);
340 print_overflow_msg(__func__, xdr);
347 * typedef uint64 size3;
349 static __be32 *xdr_decode_size3(__be32 *p, u64 *size)
351 return xdr_decode_hyper(p, size);
362 #define NFS3_OK NFS_OK
364 static int decode_nfsstat3(struct xdr_stream *xdr, enum nfs_stat *status)
368 p = xdr_inline_decode(xdr, 4);
369 if (unlikely(p == NULL))
371 *status = be32_to_cpup(p);
374 print_overflow_msg(__func__, xdr);
391 static void encode_ftype3(struct xdr_stream *xdr, const u32 type)
393 BUG_ON(type > NF3FIFO);
394 encode_uint32(xdr, type);
397 static __be32 *xdr_decode_ftype3(__be32 *p, umode_t *mode)
401 type = be32_to_cpup(p++);
404 *mode = nfs_type2fmt[type];
416 static void encode_specdata3(struct xdr_stream *xdr, const dev_t rdev)
420 p = xdr_reserve_space(xdr, 8);
421 *p++ = cpu_to_be32(MAJOR(rdev));
422 *p = cpu_to_be32(MINOR(rdev));
425 static __be32 *xdr_decode_specdata3(__be32 *p, dev_t *rdev)
427 unsigned int major, minor;
429 major = be32_to_cpup(p++);
430 minor = be32_to_cpup(p++);
431 *rdev = MKDEV(major, minor);
432 if (MAJOR(*rdev) != major || MINOR(*rdev) != minor)
441 * opaque data<NFS3_FHSIZE>;
444 static void encode_nfs_fh3(struct xdr_stream *xdr, const struct nfs_fh *fh)
448 BUG_ON(fh->size > NFS3_FHSIZE);
449 p = xdr_reserve_space(xdr, 4 + fh->size);
450 xdr_encode_opaque(p, fh->data, fh->size);
453 static int decode_nfs_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
458 p = xdr_inline_decode(xdr, 4);
459 if (unlikely(p == NULL))
461 length = be32_to_cpup(p++);
462 if (unlikely(length > NFS3_FHSIZE))
464 p = xdr_inline_decode(xdr, length);
465 if (unlikely(p == NULL))
468 memcpy(fh->data, p, length);
471 dprintk("NFS: file handle size (%u) too big\n", length);
474 print_overflow_msg(__func__, xdr);
478 static void zero_nfs_fh3(struct nfs_fh *fh)
480 memset(fh, 0, sizeof(*fh));
491 static __be32 *xdr_encode_nfstime3(__be32 *p, const struct timespec *timep)
493 *p++ = cpu_to_be32(timep->tv_sec);
494 *p++ = cpu_to_be32(timep->tv_nsec);
498 static __be32 *xdr_decode_nfstime3(__be32 *p, struct timespec *timep)
500 timep->tv_sec = be32_to_cpup(p++);
501 timep->tv_nsec = be32_to_cpup(p++);
510 * SET_TO_SERVER_TIME = 1,
511 * SET_TO_CLIENT_TIME = 2
514 * union set_mode3 switch (bool set_it) {
521 * union set_uid3 switch (bool set_it) {
528 * union set_gid3 switch (bool set_it) {
535 * union set_size3 switch (bool set_it) {
542 * union set_atime switch (time_how set_it) {
543 * case SET_TO_CLIENT_TIME:
549 * union set_mtime switch (time_how set_it) {
550 * case SET_TO_CLIENT_TIME:
565 static void encode_sattr3(struct xdr_stream *xdr, const struct iattr *attr)
571 * In order to make only a single xdr_reserve_space() call,
572 * pre-compute the total number of bytes to be reserved.
573 * Six boolean values, one for each set_foo field, are always
574 * present in the encoded result, so start there.
577 if (attr->ia_valid & ATTR_MODE)
579 if (attr->ia_valid & ATTR_UID)
581 if (attr->ia_valid & ATTR_GID)
583 if (attr->ia_valid & ATTR_SIZE)
585 if (attr->ia_valid & ATTR_ATIME_SET)
587 if (attr->ia_valid & ATTR_MTIME_SET)
589 p = xdr_reserve_space(xdr, nbytes);
591 if (attr->ia_valid & ATTR_MODE) {
593 *p++ = cpu_to_be32(attr->ia_mode & S_IALLUGO);
597 if (attr->ia_valid & ATTR_UID) {
599 *p++ = cpu_to_be32(attr->ia_uid);
603 if (attr->ia_valid & ATTR_GID) {
605 *p++ = cpu_to_be32(attr->ia_gid);
609 if (attr->ia_valid & ATTR_SIZE) {
611 p = xdr_encode_hyper(p, (u64)attr->ia_size);
615 if (attr->ia_valid & ATTR_ATIME_SET) {
617 p = xdr_encode_nfstime3(p, &attr->ia_atime);
618 } else if (attr->ia_valid & ATTR_ATIME) {
623 if (attr->ia_valid & ATTR_MTIME_SET) {
625 xdr_encode_nfstime3(p, &attr->ia_mtime);
626 } else if (attr->ia_valid & ATTR_MTIME) {
651 static int decode_fattr3(struct xdr_stream *xdr, struct nfs_fattr *fattr)
656 p = xdr_inline_decode(xdr, NFS3_fattr_sz << 2);
657 if (unlikely(p == NULL))
660 p = xdr_decode_ftype3(p, &fmode);
662 fattr->mode = (be32_to_cpup(p++) & ~S_IFMT) | fmode;
663 fattr->nlink = be32_to_cpup(p++);
664 fattr->uid = be32_to_cpup(p++);
665 fattr->gid = be32_to_cpup(p++);
667 p = xdr_decode_size3(p, &fattr->size);
668 p = xdr_decode_size3(p, &fattr->du.nfs3.used);
669 p = xdr_decode_specdata3(p, &fattr->rdev);
671 p = xdr_decode_hyper(p, &fattr->fsid.major);
672 fattr->fsid.minor = 0;
674 p = xdr_decode_fileid3(p, &fattr->fileid);
675 p = xdr_decode_nfstime3(p, &fattr->atime);
676 p = xdr_decode_nfstime3(p, &fattr->mtime);
677 xdr_decode_nfstime3(p, &fattr->ctime);
679 fattr->valid |= NFS_ATTR_FATTR_V3;
682 print_overflow_msg(__func__, xdr);
689 * union post_op_attr switch (bool attributes_follow) {
696 static int decode_post_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
700 p = xdr_inline_decode(xdr, 4);
701 if (unlikely(p == NULL))
704 return decode_fattr3(xdr, fattr);
707 print_overflow_msg(__func__, xdr);
719 static int decode_wcc_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
723 p = xdr_inline_decode(xdr, NFS3_wcc_attr_sz << 2);
724 if (unlikely(p == NULL))
727 fattr->valid |= NFS_ATTR_FATTR_PRESIZE
728 | NFS_ATTR_FATTR_PREMTIME
729 | NFS_ATTR_FATTR_PRECTIME;
731 p = xdr_decode_size3(p, &fattr->pre_size);
732 p = xdr_decode_nfstime3(p, &fattr->pre_mtime);
733 xdr_decode_nfstime3(p, &fattr->pre_ctime);
737 print_overflow_msg(__func__, xdr);
743 * union pre_op_attr switch (bool attributes_follow) {
745 * wcc_attr attributes;
753 * pre_op_attr before;
754 * post_op_attr after;
757 static int decode_pre_op_attr(struct xdr_stream *xdr, struct nfs_fattr *fattr)
761 p = xdr_inline_decode(xdr, 4);
762 if (unlikely(p == NULL))
765 return decode_wcc_attr(xdr, fattr);
768 print_overflow_msg(__func__, xdr);
772 static int decode_wcc_data(struct xdr_stream *xdr, struct nfs_fattr *fattr)
776 error = decode_pre_op_attr(xdr, fattr);
779 error = decode_post_op_attr(xdr, fattr);
787 * union post_op_fh3 switch (bool handle_follows) {
794 static int decode_post_op_fh3(struct xdr_stream *xdr, struct nfs_fh *fh)
796 __be32 *p = xdr_inline_decode(xdr, 4);
797 if (unlikely(p == NULL))
800 return decode_nfs_fh3(xdr, fh);
804 print_overflow_msg(__func__, xdr);
811 * struct diropargs3 {
816 static void encode_diropargs3(struct xdr_stream *xdr, const struct nfs_fh *fh,
817 const char *name, u32 length)
819 encode_nfs_fh3(xdr, fh);
820 encode_filename3(xdr, name, length);
825 * NFSv3 XDR encode functions
827 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
828 * "NFS Version 3 Protocol Specification".
834 * struct GETATTR3args {
838 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst *req,
839 struct xdr_stream *xdr,
840 const struct nfs_fh *fh)
842 encode_nfs_fh3(xdr, fh);
848 * union sattrguard3 switch (bool check) {
850 * nfstime3 obj_ctime;
855 * struct SETATTR3args {
857 * sattr3 new_attributes;
861 static void encode_sattrguard3(struct xdr_stream *xdr,
862 const struct nfs3_sattrargs *args)
867 p = xdr_reserve_space(xdr, 4 + 8);
869 xdr_encode_nfstime3(p, &args->guardtime);
871 p = xdr_reserve_space(xdr, 4);
876 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst *req,
877 struct xdr_stream *xdr,
878 const struct nfs3_sattrargs *args)
880 encode_nfs_fh3(xdr, args->fh);
881 encode_sattr3(xdr, args->sattr);
882 encode_sattrguard3(xdr, args);
888 * struct LOOKUP3args {
892 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst *req,
893 struct xdr_stream *xdr,
894 const struct nfs3_diropargs *args)
896 encode_diropargs3(xdr, args->fh, args->name, args->len);
902 * struct ACCESS3args {
907 static void encode_access3args(struct xdr_stream *xdr,
908 const struct nfs3_accessargs *args)
910 encode_nfs_fh3(xdr, args->fh);
911 encode_uint32(xdr, args->access);
914 static void nfs3_xdr_enc_access3args(struct rpc_rqst *req,
915 struct xdr_stream *xdr,
916 const struct nfs3_accessargs *args)
918 encode_access3args(xdr, args);
922 * 3.3.5 READLINK3args
924 * struct READLINK3args {
928 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst *req,
929 struct xdr_stream *xdr,
930 const struct nfs3_readlinkargs *args)
932 encode_nfs_fh3(xdr, args->fh);
933 prepare_reply_buffer(req, args->pages, args->pgbase,
934 args->pglen, NFS3_readlinkres_sz);
946 static void encode_read3args(struct xdr_stream *xdr,
947 const struct nfs_readargs *args)
951 encode_nfs_fh3(xdr, args->fh);
953 p = xdr_reserve_space(xdr, 8 + 4);
954 p = xdr_encode_hyper(p, args->offset);
955 *p = cpu_to_be32(args->count);
958 static void nfs3_xdr_enc_read3args(struct rpc_rqst *req,
959 struct xdr_stream *xdr,
960 const struct nfs_readargs *args)
962 encode_read3args(xdr, args);
963 prepare_reply_buffer(req, args->pages, args->pgbase,
964 args->count, NFS3_readres_sz);
965 req->rq_rcv_buf.flags |= XDRBUF_READ;
977 * struct WRITE3args {
985 static void encode_write3args(struct xdr_stream *xdr,
986 const struct nfs_writeargs *args)
990 encode_nfs_fh3(xdr, args->fh);
992 p = xdr_reserve_space(xdr, 8 + 4 + 4 + 4);
993 p = xdr_encode_hyper(p, args->offset);
994 *p++ = cpu_to_be32(args->count);
995 *p++ = cpu_to_be32(args->stable);
996 *p = cpu_to_be32(args->count);
997 xdr_write_pages(xdr, args->pages, args->pgbase, args->count);
1000 static void nfs3_xdr_enc_write3args(struct rpc_rqst *req,
1001 struct xdr_stream *xdr,
1002 const struct nfs_writeargs *args)
1004 encode_write3args(xdr, args);
1005 xdr->buf->flags |= XDRBUF_WRITE;
1011 * enum createmode3 {
1017 * union createhow3 switch (createmode3 mode) {
1020 * sattr3 obj_attributes;
1025 * struct CREATE3args {
1030 static void encode_createhow3(struct xdr_stream *xdr,
1031 const struct nfs3_createargs *args)
1033 encode_uint32(xdr, args->createmode);
1034 switch (args->createmode) {
1035 case NFS3_CREATE_UNCHECKED:
1036 case NFS3_CREATE_GUARDED:
1037 encode_sattr3(xdr, args->sattr);
1039 case NFS3_CREATE_EXCLUSIVE:
1040 encode_createverf3(xdr, args->verifier);
1047 static void nfs3_xdr_enc_create3args(struct rpc_rqst *req,
1048 struct xdr_stream *xdr,
1049 const struct nfs3_createargs *args)
1051 encode_diropargs3(xdr, args->fh, args->name, args->len);
1052 encode_createhow3(xdr, args);
1058 * struct MKDIR3args {
1060 * sattr3 attributes;
1063 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst *req,
1064 struct xdr_stream *xdr,
1065 const struct nfs3_mkdirargs *args)
1067 encode_diropargs3(xdr, args->fh, args->name, args->len);
1068 encode_sattr3(xdr, args->sattr);
1072 * 3.3.10 SYMLINK3args
1074 * struct symlinkdata3 {
1075 * sattr3 symlink_attributes;
1076 * nfspath3 symlink_data;
1079 * struct SYMLINK3args {
1081 * symlinkdata3 symlink;
1084 static void encode_symlinkdata3(struct xdr_stream *xdr,
1085 const struct nfs3_symlinkargs *args)
1087 encode_sattr3(xdr, args->sattr);
1088 encode_nfspath3(xdr, args->pages, args->pathlen);
1091 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst *req,
1092 struct xdr_stream *xdr,
1093 const struct nfs3_symlinkargs *args)
1095 encode_diropargs3(xdr, args->fromfh, args->fromname, args->fromlen);
1096 encode_symlinkdata3(xdr, args);
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)
1126 encode_sattr3(xdr, args->sattr);
1127 encode_specdata3(xdr, args->rdev);
1130 static void encode_mknoddata3(struct xdr_stream *xdr,
1131 const struct nfs3_mknodargs *args)
1133 encode_ftype3(xdr, args->type);
1134 switch (args->type) {
1137 encode_devicedata3(xdr, args);
1141 encode_sattr3(xdr, args->sattr);
1151 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst *req,
1152 struct xdr_stream *xdr,
1153 const struct nfs3_mknodargs *args)
1155 encode_diropargs3(xdr, args->fh, args->name, args->len);
1156 encode_mknoddata3(xdr, args);
1160 * 3.3.12 REMOVE3args
1162 * struct REMOVE3args {
1163 * diropargs3 object;
1166 static void nfs3_xdr_enc_remove3args(struct rpc_rqst *req,
1167 struct xdr_stream *xdr,
1168 const struct nfs_removeargs *args)
1170 encode_diropargs3(xdr, args->fh, args->name.name, args->name.len);
1174 * 3.3.14 RENAME3args
1176 * struct RENAME3args {
1181 static void nfs3_xdr_enc_rename3args(struct rpc_rqst *req,
1182 struct xdr_stream *xdr,
1183 const struct nfs_renameargs *args)
1185 const struct qstr *old = args->old_name;
1186 const struct qstr *new = args->new_name;
1188 encode_diropargs3(xdr, args->old_dir, old->name, old->len);
1189 encode_diropargs3(xdr, args->new_dir, new->name, new->len);
1195 * struct LINK3args {
1200 static void nfs3_xdr_enc_link3args(struct rpc_rqst *req,
1201 struct xdr_stream *xdr,
1202 const struct nfs3_linkargs *args)
1204 encode_nfs_fh3(xdr, args->fromfh);
1205 encode_diropargs3(xdr, args->tofh, args->toname, args->tolen);
1209 * 3.3.16 READDIR3args
1211 * struct READDIR3args {
1214 * cookieverf3 cookieverf;
1218 static void encode_readdir3args(struct xdr_stream *xdr,
1219 const struct nfs3_readdirargs *args)
1223 encode_nfs_fh3(xdr, args->fh);
1225 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4);
1226 p = xdr_encode_cookie3(p, args->cookie);
1227 p = xdr_encode_cookieverf3(p, args->verf);
1228 *p = cpu_to_be32(args->count);
1231 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst *req,
1232 struct xdr_stream *xdr,
1233 const struct nfs3_readdirargs *args)
1235 encode_readdir3args(xdr, args);
1236 prepare_reply_buffer(req, args->pages, 0,
1237 args->count, NFS3_readdirres_sz);
1241 * 3.3.17 READDIRPLUS3args
1243 * struct READDIRPLUS3args {
1246 * cookieverf3 cookieverf;
1251 static void encode_readdirplus3args(struct xdr_stream *xdr,
1252 const struct nfs3_readdirargs *args)
1256 encode_nfs_fh3(xdr, args->fh);
1258 p = xdr_reserve_space(xdr, 8 + NFS3_COOKIEVERFSIZE + 4 + 4);
1259 p = xdr_encode_cookie3(p, args->cookie);
1260 p = xdr_encode_cookieverf3(p, args->verf);
1263 * readdirplus: need dircount + buffer size.
1264 * We just make sure we make dircount big enough
1266 *p++ = cpu_to_be32(args->count >> 3);
1268 *p = cpu_to_be32(args->count);
1271 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst *req,
1272 struct xdr_stream *xdr,
1273 const struct nfs3_readdirargs *args)
1275 encode_readdirplus3args(xdr, args);
1276 prepare_reply_buffer(req, args->pages, 0,
1277 args->count, NFS3_readdirres_sz);
1281 * 3.3.21 COMMIT3args
1283 * struct COMMIT3args {
1289 static void encode_commit3args(struct xdr_stream *xdr,
1290 const struct nfs_writeargs *args)
1294 encode_nfs_fh3(xdr, args->fh);
1296 p = xdr_reserve_space(xdr, 8 + 4);
1297 p = xdr_encode_hyper(p, args->offset);
1298 *p = cpu_to_be32(args->count);
1301 static void nfs3_xdr_enc_commit3args(struct rpc_rqst *req,
1302 struct xdr_stream *xdr,
1303 const struct nfs_writeargs *args)
1305 encode_commit3args(xdr, args);
1308 #ifdef CONFIG_NFS_V3_ACL
1310 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst *req,
1311 struct xdr_stream *xdr,
1312 const struct nfs3_getaclargs *args)
1314 encode_nfs_fh3(xdr, args->fh);
1315 encode_uint32(xdr, args->mask);
1316 if (args->mask & (NFS_ACL | NFS_DFACL))
1317 prepare_reply_buffer(req, args->pages, 0,
1318 NFSACL_MAXPAGES << PAGE_SHIFT,
1322 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst *req,
1323 struct xdr_stream *xdr,
1324 const struct nfs3_setaclargs *args)
1329 encode_nfs_fh3(xdr, NFS_FH(args->inode));
1330 encode_uint32(xdr, args->mask);
1331 if (args->npages != 0)
1332 xdr_write_pages(xdr, args->pages, 0, args->len);
1334 base = req->rq_slen;
1335 error = nfsacl_encode(xdr->buf, base, args->inode,
1336 (args->mask & NFS_ACL) ?
1337 args->acl_access : NULL, 1, 0);
1339 error = nfsacl_encode(xdr->buf, base + error, args->inode,
1340 (args->mask & NFS_DFACL) ?
1341 args->acl_default : NULL, 1,
1346 #endif /* CONFIG_NFS_V3_ACL */
1349 * NFSv3 XDR decode functions
1351 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1352 * "NFS Version 3 Protocol Specification".
1358 * struct GETATTR3resok {
1359 * fattr3 obj_attributes;
1362 * union GETATTR3res switch (nfsstat3 status) {
1364 * GETATTR3resok resok;
1369 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst *req, __be32 *p,
1370 struct nfs_fattr *result)
1372 struct xdr_stream xdr;
1373 enum nfs_stat status;
1376 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1377 error = decode_nfsstat3(&xdr, &status);
1378 if (unlikely(error))
1380 if (status != NFS3_OK)
1382 error = decode_fattr3(&xdr, result);
1386 return nfs_stat_to_errno(status);
1392 * struct SETATTR3resok {
1396 * struct SETATTR3resfail {
1400 * union SETATTR3res switch (nfsstat3 status) {
1402 * SETATTR3resok resok;
1404 * SETATTR3resfail resfail;
1407 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst *req, __be32 *p,
1408 struct nfs_fattr *result)
1410 struct xdr_stream xdr;
1411 enum nfs_stat status;
1414 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1415 error = decode_nfsstat3(&xdr, &status);
1416 if (unlikely(error))
1418 error = decode_wcc_data(&xdr, result);
1419 if (unlikely(error))
1421 if (status != NFS3_OK)
1426 return nfs_stat_to_errno(status);
1432 * struct LOOKUP3resok {
1434 * post_op_attr obj_attributes;
1435 * post_op_attr dir_attributes;
1438 * struct LOOKUP3resfail {
1439 * post_op_attr dir_attributes;
1442 * union LOOKUP3res switch (nfsstat3 status) {
1444 * LOOKUP3resok resok;
1446 * LOOKUP3resfail resfail;
1449 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst *req, __be32 *p,
1450 struct nfs3_diropres *result)
1452 struct xdr_stream xdr;
1453 enum nfs_stat status;
1456 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1457 error = decode_nfsstat3(&xdr, &status);
1458 if (unlikely(error))
1460 if (status != NFS3_OK)
1462 error = decode_nfs_fh3(&xdr, result->fh);
1463 if (unlikely(error))
1465 error = decode_post_op_attr(&xdr, result->fattr);
1466 if (unlikely(error))
1468 error = decode_post_op_attr(&xdr, result->dir_attr);
1472 error = decode_post_op_attr(&xdr, result->dir_attr);
1473 if (unlikely(error))
1475 return nfs_stat_to_errno(status);
1481 * struct ACCESS3resok {
1482 * post_op_attr obj_attributes;
1486 * struct ACCESS3resfail {
1487 * post_op_attr obj_attributes;
1490 * union ACCESS3res switch (nfsstat3 status) {
1492 * ACCESS3resok resok;
1494 * ACCESS3resfail resfail;
1497 static int nfs3_xdr_dec_access3res(struct rpc_rqst *req, __be32 *p,
1498 struct nfs3_accessres *result)
1500 struct xdr_stream xdr;
1501 enum nfs_stat status;
1504 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1505 error = decode_nfsstat3(&xdr, &status);
1506 if (unlikely(error))
1508 error = decode_post_op_attr(&xdr, result->fattr);
1509 if (unlikely(error))
1511 if (status != NFS3_OK)
1513 error = decode_uint32(&xdr, &result->access);
1517 return nfs_stat_to_errno(status);
1521 * 3.3.5 READLINK3res
1523 * struct READLINK3resok {
1524 * post_op_attr symlink_attributes;
1528 * struct READLINK3resfail {
1529 * post_op_attr symlink_attributes;
1532 * union READLINK3res switch (nfsstat3 status) {
1534 * READLINK3resok resok;
1536 * READLINK3resfail resfail;
1539 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst *req, __be32 *p,
1540 struct nfs_fattr *result)
1542 struct xdr_stream xdr;
1543 enum nfs_stat status;
1546 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1547 error = decode_nfsstat3(&xdr, &status);
1548 if (unlikely(error))
1550 error = decode_post_op_attr(&xdr, result);
1551 if (unlikely(error))
1553 if (status != NFS3_OK)
1555 error = decode_nfspath3(&xdr);
1559 return nfs_stat_to_errno(status);
1565 * struct READ3resok {
1566 * post_op_attr file_attributes;
1572 * struct READ3resfail {
1573 * post_op_attr file_attributes;
1576 * union READ3res switch (nfsstat3 status) {
1580 * READ3resfail resfail;
1583 static int decode_read3resok(struct xdr_stream *xdr,
1584 struct nfs_readres *result)
1586 u32 eof, count, ocount, recvd;
1590 p = xdr_inline_decode(xdr, 4 + 4 + 4);
1591 if (unlikely(p == NULL))
1593 count = be32_to_cpup(p++);
1594 eof = be32_to_cpup(p++);
1595 ocount = be32_to_cpup(p++);
1596 if (unlikely(ocount != count))
1598 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
1599 recvd = xdr->buf->len - hdrlen;
1600 if (unlikely(count > recvd))
1604 xdr_read_pages(xdr, count);
1606 result->count = count;
1609 dprintk("NFS: READ count doesn't match length of opaque: "
1610 "count %u != ocount %u\n", count, ocount);
1613 dprintk("NFS: server cheating in read result: "
1614 "count %u > recvd %u\n", count, recvd);
1619 print_overflow_msg(__func__, xdr);
1623 static int nfs3_xdr_dec_read3res(struct rpc_rqst *req, __be32 *p,
1624 struct nfs_readres *result)
1626 struct xdr_stream xdr;
1627 enum nfs_stat status;
1630 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1631 error = decode_nfsstat3(&xdr, &status);
1632 if (unlikely(error))
1634 error = decode_post_op_attr(&xdr, result->fattr);
1635 if (unlikely(error))
1637 if (status != NFS3_OK)
1639 error = decode_read3resok(&xdr, result);
1643 return nfs_stat_to_errno(status);
1655 * struct WRITE3resok {
1656 * wcc_data file_wcc;
1658 * stable_how committed;
1662 * struct WRITE3resfail {
1663 * wcc_data file_wcc;
1666 * union WRITE3res switch (nfsstat3 status) {
1668 * WRITE3resok resok;
1670 * WRITE3resfail resfail;
1673 static int decode_write3resok(struct xdr_stream *xdr,
1674 struct nfs_writeres *result)
1678 p = xdr_inline_decode(xdr, 4 + 4 + NFS3_WRITEVERFSIZE);
1679 if (unlikely(p == NULL))
1681 result->count = be32_to_cpup(p++);
1682 result->verf->committed = be32_to_cpup(p++);
1683 if (unlikely(result->verf->committed > NFS_FILE_SYNC))
1685 memcpy(result->verf->verifier, p, NFS3_WRITEVERFSIZE);
1686 return result->count;
1688 dprintk("NFS: bad stable_how value: %u\n", result->verf->committed);
1691 print_overflow_msg(__func__, xdr);
1695 static int nfs3_xdr_dec_write3res(struct rpc_rqst *req, __be32 *p,
1696 struct nfs_writeres *result)
1698 struct xdr_stream xdr;
1699 enum nfs_stat status;
1702 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1703 error = decode_nfsstat3(&xdr, &status);
1704 if (unlikely(error))
1706 error = decode_wcc_data(&xdr, result->fattr);
1707 if (unlikely(error))
1709 if (status != NFS3_OK)
1711 error = decode_write3resok(&xdr, result);
1715 return nfs_stat_to_errno(status);
1721 * struct CREATE3resok {
1723 * post_op_attr obj_attributes;
1727 * struct CREATE3resfail {
1731 * union CREATE3res switch (nfsstat3 status) {
1733 * CREATE3resok resok;
1735 * CREATE3resfail resfail;
1738 static int decode_create3resok(struct xdr_stream *xdr,
1739 struct nfs3_diropres *result)
1743 error = decode_post_op_fh3(xdr, result->fh);
1744 if (unlikely(error))
1746 error = decode_post_op_attr(xdr, result->fattr);
1747 if (unlikely(error))
1749 /* The server isn't required to return a file handle.
1750 * If it didn't, force the client to perform a LOOKUP
1751 * to determine the correct file handle and attribute
1752 * values for the new object. */
1753 if (result->fh->size == 0)
1754 result->fattr->valid = 0;
1755 error = decode_wcc_data(xdr, result->dir_attr);
1760 static int nfs3_xdr_dec_create3res(struct rpc_rqst *req, __be32 *p,
1761 struct nfs3_diropres *result)
1763 struct xdr_stream xdr;
1764 enum nfs_stat status;
1767 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1768 error = decode_nfsstat3(&xdr, &status);
1769 if (unlikely(error))
1771 if (status != NFS3_OK)
1773 error = decode_create3resok(&xdr, result);
1777 error = decode_wcc_data(&xdr, result->dir_attr);
1778 if (unlikely(error))
1780 return nfs_stat_to_errno(status);
1786 * struct REMOVE3resok {
1790 * struct REMOVE3resfail {
1794 * union REMOVE3res switch (nfsstat3 status) {
1796 * REMOVE3resok resok;
1798 * REMOVE3resfail resfail;
1801 static int nfs3_xdr_dec_remove3res(struct rpc_rqst *req, __be32 *p,
1802 struct nfs_removeres *result)
1804 struct xdr_stream xdr;
1805 enum nfs_stat status;
1808 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1809 error = decode_nfsstat3(&xdr, &status);
1810 if (unlikely(error))
1812 error = decode_wcc_data(&xdr, result->dir_attr);
1813 if (unlikely(error))
1815 if (status != NFS3_OK)
1820 return nfs_stat_to_errno(status);
1826 * struct RENAME3resok {
1827 * wcc_data fromdir_wcc;
1828 * wcc_data todir_wcc;
1831 * struct RENAME3resfail {
1832 * wcc_data fromdir_wcc;
1833 * wcc_data todir_wcc;
1836 * union RENAME3res switch (nfsstat3 status) {
1838 * RENAME3resok resok;
1840 * RENAME3resfail resfail;
1843 static int nfs3_xdr_dec_rename3res(struct rpc_rqst *req, __be32 *p,
1844 struct nfs_renameres *result)
1846 struct xdr_stream xdr;
1847 enum nfs_stat status;
1850 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1851 error = decode_nfsstat3(&xdr, &status);
1852 if (unlikely(error))
1854 error = decode_wcc_data(&xdr, result->old_fattr);
1855 if (unlikely(error))
1857 error = decode_wcc_data(&xdr, result->new_fattr);
1858 if (unlikely(error))
1860 if (status != NFS3_OK)
1865 return nfs_stat_to_errno(status);
1871 * struct LINK3resok {
1872 * post_op_attr file_attributes;
1873 * wcc_data linkdir_wcc;
1876 * struct LINK3resfail {
1877 * post_op_attr file_attributes;
1878 * wcc_data linkdir_wcc;
1881 * union LINK3res switch (nfsstat3 status) {
1885 * LINK3resfail resfail;
1888 static int nfs3_xdr_dec_link3res(struct rpc_rqst *req, __be32 *p,
1889 struct nfs3_linkres *result)
1891 struct xdr_stream xdr;
1892 enum nfs_stat status;
1895 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
1896 error = decode_nfsstat3(&xdr, &status);
1897 if (unlikely(error))
1899 error = decode_post_op_attr(&xdr, result->fattr);
1900 if (unlikely(error))
1902 error = decode_wcc_data(&xdr, result->dir_attr);
1903 if (unlikely(error))
1905 if (status != NFS3_OK)
1910 return nfs_stat_to_errno(status);
1914 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1915 * the local page cache
1916 * @xdr: XDR stream where entry resides
1917 * @entry: buffer to fill in with entry data
1918 * @plus: boolean indicating whether this should be a readdirplus entry
1920 * Returns zero if successful, otherwise a negative errno value is
1923 * This function is not invoked during READDIR reply decoding, but
1924 * rather whenever an application invokes the getdents(2) system call
1925 * on a directory already in our cache.
1933 * fhandle3 filehandle;
1934 * post_op_attr3 attributes;
1935 * entry3 *nextentry;
1939 * struct entryplus3 {
1943 * post_op_attr name_attributes;
1944 * post_op_fh3 name_handle;
1945 * entryplus3 *nextentry;
1948 int nfs3_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry,
1951 struct nfs_entry old = *entry;
1955 p = xdr_inline_decode(xdr, 4);
1956 if (unlikely(p == NULL))
1958 if (*p == xdr_zero) {
1959 p = xdr_inline_decode(xdr, 4);
1960 if (unlikely(p == NULL))
1968 error = decode_fileid3(xdr, &entry->ino);
1969 if (unlikely(error))
1972 error = decode_inline_filename3(xdr, &entry->name, &entry->len);
1973 if (unlikely(error))
1976 entry->prev_cookie = entry->cookie;
1977 error = decode_cookie3(xdr, &entry->cookie);
1978 if (unlikely(error))
1981 entry->d_type = DT_UNKNOWN;
1984 entry->fattr->valid = 0;
1985 error = decode_post_op_attr(xdr, entry->fattr);
1986 if (unlikely(error))
1988 if (entry->fattr->valid & NFS_ATTR_FATTR_V3)
1989 entry->d_type = nfs_umode_to_dtype(entry->fattr->mode);
1991 /* In fact, a post_op_fh3: */
1992 p = xdr_inline_decode(xdr, 4);
1993 if (unlikely(p == NULL))
1995 if (*p != xdr_zero) {
1996 error = decode_nfs_fh3(xdr, entry->fh);
1997 if (unlikely(error)) {
1998 if (error == -E2BIG)
2003 zero_nfs_fh3(entry->fh);
2006 /* Peek at the next entry to see if we're at EOD */
2007 p = xdr_inline_peek(xdr, 4 + 4);
2010 entry->eof = (p[0] == xdr_zero) && (p[1] != xdr_zero);
2014 print_overflow_msg(__func__, xdr);
2017 dprintk("NFS: directory entry contains invalid file handle\n");
2023 * 3.3.16 READDIR3res
2030 * struct READDIR3resok {
2031 * post_op_attr dir_attributes;
2032 * cookieverf3 cookieverf;
2036 * struct READDIR3resfail {
2037 * post_op_attr dir_attributes;
2040 * union READDIR3res switch (nfsstat3 status) {
2042 * READDIR3resok resok;
2044 * READDIR3resfail resfail;
2047 * Read the directory contents into the page cache, but otherwise
2048 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2049 * during subsequent nfs_readdir() calls.
2051 static int decode_dirlist3(struct xdr_stream *xdr)
2056 pglen = xdr->buf->page_len;
2057 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2058 recvd = xdr->buf->len - hdrlen;
2059 if (unlikely(pglen > recvd))
2062 xdr_read_pages(xdr, pglen);
2065 dprintk("NFS: server cheating in readdir result: "
2066 "pglen %u > recvd %u\n", pglen, recvd);
2071 static int decode_readdir3resok(struct xdr_stream *xdr,
2072 struct nfs3_readdirres *result)
2076 error = decode_post_op_attr(xdr, result->dir_attr);
2077 if (unlikely(error))
2079 /* XXX: do we need to check if result->verf != NULL ? */
2080 error = decode_cookieverf3(xdr, result->verf);
2081 if (unlikely(error))
2083 error = decode_dirlist3(xdr);
2088 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst *req, __be32 *p,
2089 struct nfs3_readdirres *result)
2091 struct xdr_stream xdr;
2092 enum nfs_stat status;
2095 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2096 error = decode_nfsstat3(&xdr, &status);
2097 if (unlikely(error))
2099 if (status != NFS3_OK)
2101 error = decode_readdir3resok(&xdr, result);
2105 error = decode_post_op_attr(&xdr, result->dir_attr);
2106 if (unlikely(error))
2108 return nfs_stat_to_errno(status);
2114 * struct FSSTAT3resok {
2115 * post_op_attr obj_attributes;
2125 * struct FSSTAT3resfail {
2126 * post_op_attr obj_attributes;
2129 * union FSSTAT3res switch (nfsstat3 status) {
2131 * FSSTAT3resok resok;
2133 * FSSTAT3resfail resfail;
2136 static int decode_fsstat3resok(struct xdr_stream *xdr,
2137 struct nfs_fsstat *result)
2141 p = xdr_inline_decode(xdr, 8 * 6 + 4);
2142 if (unlikely(p == NULL))
2144 p = xdr_decode_size3(p, &result->tbytes);
2145 p = xdr_decode_size3(p, &result->fbytes);
2146 p = xdr_decode_size3(p, &result->abytes);
2147 p = xdr_decode_size3(p, &result->tfiles);
2148 p = xdr_decode_size3(p, &result->ffiles);
2149 xdr_decode_size3(p, &result->afiles);
2150 /* ignore invarsec */
2153 print_overflow_msg(__func__, xdr);
2157 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst *req, __be32 *p,
2158 struct nfs_fsstat *result)
2160 struct xdr_stream xdr;
2161 enum nfs_stat status;
2164 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2165 error = decode_nfsstat3(&xdr, &status);
2166 if (unlikely(error))
2168 error = decode_post_op_attr(&xdr, result->fattr);
2169 if (unlikely(error))
2171 if (status != NFS3_OK)
2173 error = decode_fsstat3resok(&xdr, result);
2177 return nfs_stat_to_errno(status);
2183 * struct FSINFO3resok {
2184 * post_op_attr obj_attributes;
2192 * size3 maxfilesize;
2193 * nfstime3 time_delta;
2194 * uint32 properties;
2197 * struct FSINFO3resfail {
2198 * post_op_attr obj_attributes;
2201 * union FSINFO3res switch (nfsstat3 status) {
2203 * FSINFO3resok resok;
2205 * FSINFO3resfail resfail;
2208 static int decode_fsinfo3resok(struct xdr_stream *xdr,
2209 struct nfs_fsinfo *result)
2213 p = xdr_inline_decode(xdr, 4 * 7 + 8 + 8 + 4);
2214 if (unlikely(p == NULL))
2216 result->rtmax = be32_to_cpup(p++);
2217 result->rtpref = be32_to_cpup(p++);
2218 result->rtmult = be32_to_cpup(p++);
2219 result->wtmax = be32_to_cpup(p++);
2220 result->wtpref = be32_to_cpup(p++);
2221 result->wtmult = be32_to_cpup(p++);
2222 result->dtpref = be32_to_cpup(p++);
2223 p = xdr_decode_size3(p, &result->maxfilesize);
2224 xdr_decode_nfstime3(p, &result->time_delta);
2226 /* ignore properties */
2227 result->lease_time = 0;
2230 print_overflow_msg(__func__, xdr);
2234 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst *req, __be32 *p,
2235 struct nfs_fsinfo *result)
2237 struct xdr_stream xdr;
2238 enum nfs_stat status;
2241 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2242 error = decode_nfsstat3(&xdr, &status);
2243 if (unlikely(error))
2245 error = decode_post_op_attr(&xdr, result->fattr);
2246 if (unlikely(error))
2248 if (status != NFS3_OK)
2250 error = decode_fsinfo3resok(&xdr, result);
2254 return nfs_stat_to_errno(status);
2258 * 3.3.20 PATHCONF3res
2260 * struct PATHCONF3resok {
2261 * post_op_attr obj_attributes;
2265 * bool chown_restricted;
2266 * bool case_insensitive;
2267 * bool case_preserving;
2270 * struct PATHCONF3resfail {
2271 * post_op_attr obj_attributes;
2274 * union PATHCONF3res switch (nfsstat3 status) {
2276 * PATHCONF3resok resok;
2278 * PATHCONF3resfail resfail;
2281 static int decode_pathconf3resok(struct xdr_stream *xdr,
2282 struct nfs_pathconf *result)
2286 p = xdr_inline_decode(xdr, 4 * 6);
2287 if (unlikely(p == NULL))
2289 result->max_link = be32_to_cpup(p++);
2290 result->max_namelen = be32_to_cpup(p);
2291 /* ignore remaining fields */
2294 print_overflow_msg(__func__, xdr);
2298 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst *req, __be32 *p,
2299 struct nfs_pathconf *result)
2301 struct xdr_stream xdr;
2302 enum nfs_stat status;
2305 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2306 error = decode_nfsstat3(&xdr, &status);
2307 if (unlikely(error))
2309 error = decode_post_op_attr(&xdr, result->fattr);
2310 if (unlikely(error))
2312 if (status != NFS3_OK)
2314 error = decode_pathconf3resok(&xdr, result);
2318 return nfs_stat_to_errno(status);
2324 * struct COMMIT3resok {
2325 * wcc_data file_wcc;
2329 * struct COMMIT3resfail {
2330 * wcc_data file_wcc;
2333 * union COMMIT3res switch (nfsstat3 status) {
2335 * COMMIT3resok resok;
2337 * COMMIT3resfail resfail;
2340 static int nfs3_xdr_dec_commit3res(struct rpc_rqst *req, __be32 *p,
2341 struct nfs_writeres *result)
2343 struct xdr_stream xdr;
2344 enum nfs_stat status;
2347 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2348 error = decode_nfsstat3(&xdr, &status);
2349 if (unlikely(error))
2351 error = decode_wcc_data(&xdr, result->fattr);
2352 if (unlikely(error))
2354 if (status != NFS3_OK)
2356 error = decode_writeverf3(&xdr, result->verf->verifier);
2360 return nfs_stat_to_errno(status);
2363 #ifdef CONFIG_NFS_V3_ACL
2365 static inline int decode_getacl3resok(struct xdr_stream *xdr,
2366 struct nfs3_getaclres *result)
2368 struct posix_acl **acl;
2369 unsigned int *aclcnt;
2373 error = decode_post_op_attr(xdr, result->fattr);
2374 if (unlikely(error))
2376 error = decode_uint32(xdr, &result->mask);
2377 if (unlikely(error))
2380 if (result->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT))
2383 hdrlen = (u8 *)xdr->p - (u8 *)xdr->iov->iov_base;
2386 if (result->mask & NFS_ACL)
2387 acl = &result->acl_access;
2389 if (result->mask & NFS_ACLCNT)
2390 aclcnt = &result->acl_access_count;
2391 error = nfsacl_decode(xdr->buf, hdrlen, aclcnt, acl);
2392 if (unlikely(error <= 0))
2396 if (result->mask & NFS_DFACL)
2397 acl = &result->acl_default;
2399 if (result->mask & NFS_DFACLCNT)
2400 aclcnt = &result->acl_default_count;
2401 error = nfsacl_decode(xdr->buf, hdrlen + error, aclcnt, acl);
2402 if (unlikely(error <= 0))
2409 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst *req, __be32 *p,
2410 struct nfs3_getaclres *result)
2412 struct xdr_stream xdr;
2413 enum nfs_stat status;
2416 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2417 error = decode_nfsstat3(&xdr, &status);
2418 if (unlikely(error))
2420 if (status != NFS3_OK)
2422 error = decode_getacl3resok(&xdr, result);
2426 return nfs_stat_to_errno(status);
2429 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst *req, __be32 *p,
2430 struct nfs_fattr *result)
2432 struct xdr_stream xdr;
2433 enum nfs_stat status;
2436 xdr_init_decode(&xdr, &req->rq_rcv_buf, p);
2437 error = decode_nfsstat3(&xdr, &status);
2438 if (unlikely(error))
2440 if (status != NFS3_OK)
2442 error = decode_post_op_attr(&xdr, result);
2446 return nfs_stat_to_errno(status);
2449 #endif /* CONFIG_NFS_V3_ACL */
2451 #define PROC(proc, argtype, restype, timer) \
2452 [NFS3PROC_##proc] = { \
2453 .p_proc = NFS3PROC_##proc, \
2454 .p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \
2455 .p_decode = (kxdrproc_t)nfs3_xdr_dec_##restype##3res, \
2456 .p_arglen = NFS3_##argtype##args_sz, \
2457 .p_replen = NFS3_##restype##res_sz, \
2459 .p_statidx = NFS3PROC_##proc, \
2463 struct rpc_procinfo nfs3_procedures[] = {
2464 PROC(GETATTR, getattr, getattr, 1),
2465 PROC(SETATTR, setattr, setattr, 0),
2466 PROC(LOOKUP, lookup, lookup, 2),
2467 PROC(ACCESS, access, access, 1),
2468 PROC(READLINK, readlink, readlink, 3),
2469 PROC(READ, read, read, 3),
2470 PROC(WRITE, write, write, 4),
2471 PROC(CREATE, create, create, 0),
2472 PROC(MKDIR, mkdir, create, 0),
2473 PROC(SYMLINK, symlink, create, 0),
2474 PROC(MKNOD, mknod, create, 0),
2475 PROC(REMOVE, remove, remove, 0),
2476 PROC(RMDIR, lookup, setattr, 0),
2477 PROC(RENAME, rename, rename, 0),
2478 PROC(LINK, link, link, 0),
2479 PROC(READDIR, readdir, readdir, 3),
2480 PROC(READDIRPLUS, readdirplus, readdir, 3),
2481 PROC(FSSTAT, getattr, fsstat, 0),
2482 PROC(FSINFO, getattr, fsinfo, 0),
2483 PROC(PATHCONF, getattr, pathconf, 0),
2484 PROC(COMMIT, commit, commit, 5),
2487 struct rpc_version nfs_version3 = {
2489 .nrprocs = ARRAY_SIZE(nfs3_procedures),
2490 .procs = nfs3_procedures
2493 #ifdef CONFIG_NFS_V3_ACL
2494 static struct rpc_procinfo nfs3_acl_procedures[] = {
2495 [ACLPROC3_GETACL] = {
2496 .p_proc = ACLPROC3_GETACL,
2497 .p_encode = (kxdreproc_t)nfs3_xdr_enc_getacl3args,
2498 .p_decode = (kxdrproc_t)nfs3_xdr_dec_getacl3res,
2499 .p_arglen = ACL3_getaclargs_sz,
2500 .p_replen = ACL3_getaclres_sz,
2504 [ACLPROC3_SETACL] = {
2505 .p_proc = ACLPROC3_SETACL,
2506 .p_encode = (kxdreproc_t)nfs3_xdr_enc_setacl3args,
2507 .p_decode = (kxdrproc_t)nfs3_xdr_dec_setacl3res,
2508 .p_arglen = ACL3_setaclargs_sz,
2509 .p_replen = ACL3_setaclres_sz,
2515 struct rpc_version nfsacl_version3 = {
2517 .nrprocs = sizeof(nfs3_acl_procedures)/
2518 sizeof(nfs3_acl_procedures[0]),
2519 .procs = nfs3_acl_procedures,
2521 #endif /* CONFIG_NFS_V3_ACL */