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)
89 static int nfs3_stat_to_errno(enum nfs_stat
);
92 * Map file type to S_IFMT bits
94 static const umode_t nfs_type2fmt
[] = {
101 [NF3SOCK
] = S_IFSOCK
,
106 * While encoding arguments, set up the reply buffer in advance to
107 * receive reply data directly into the page cache.
109 static void prepare_reply_buffer(struct rpc_rqst
*req
, struct page
**pages
,
110 unsigned int base
, unsigned int len
,
111 unsigned int bufsize
)
113 struct rpc_auth
*auth
= req
->rq_cred
->cr_auth
;
116 replen
= RPC_REPHDRSIZE
+ auth
->au_rslack
+ bufsize
;
117 xdr_inline_pages(&req
->rq_rcv_buf
, replen
<< 2, pages
, base
, len
);
121 * Handle decode buffer overflows out-of-line.
123 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
125 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
126 "Remaining buffer length is %tu words.\n",
127 func
, xdr
->end
- xdr
->p
);
132 * Encode/decode NFSv3 basic data types
134 * Basic NFSv3 data types are defined in section 2.5 of RFC 1813:
135 * "NFS Version 3 Protocol Specification".
137 * Not all basic data types have their own encoding and decoding
138 * functions. For run-time efficiency, some data types are encoded
142 static void encode_uint32(struct xdr_stream
*xdr
, u32 value
)
144 __be32
*p
= xdr_reserve_space(xdr
, 4);
145 *p
= cpu_to_be32(value
);
148 static int decode_uint32(struct xdr_stream
*xdr
, u32
*value
)
152 p
= xdr_inline_decode(xdr
, 4);
153 if (unlikely(p
== NULL
))
155 *value
= be32_to_cpup(p
);
158 print_overflow_msg(__func__
, xdr
);
162 static int decode_uint64(struct xdr_stream
*xdr
, u64
*value
)
166 p
= xdr_inline_decode(xdr
, 8);
167 if (unlikely(p
== NULL
))
169 xdr_decode_hyper(p
, value
);
172 print_overflow_msg(__func__
, xdr
);
179 * typedef uint64 fileid3;
181 static __be32
*xdr_decode_fileid3(__be32
*p
, u64
*fileid
)
183 return xdr_decode_hyper(p
, fileid
);
186 static int decode_fileid3(struct xdr_stream
*xdr
, u64
*fileid
)
188 return decode_uint64(xdr
, fileid
);
194 * typedef string filename3<>;
196 static void encode_filename3(struct xdr_stream
*xdr
,
197 const char *name
, u32 length
)
201 BUG_ON(length
> NFS3_MAXNAMLEN
);
202 p
= xdr_reserve_space(xdr
, 4 + length
);
203 xdr_encode_opaque(p
, name
, length
);
206 static int decode_inline_filename3(struct xdr_stream
*xdr
,
207 const char **name
, u32
*length
)
212 p
= xdr_inline_decode(xdr
, 4);
213 if (unlikely(p
== NULL
))
215 count
= be32_to_cpup(p
);
216 if (count
> NFS3_MAXNAMLEN
)
217 goto out_nametoolong
;
218 p
= xdr_inline_decode(xdr
, count
);
219 if (unlikely(p
== NULL
))
221 *name
= (const char *)p
;
226 dprintk("NFS: returned filename too long: %u\n", count
);
227 return -ENAMETOOLONG
;
229 print_overflow_msg(__func__
, xdr
);
236 * typedef string nfspath3<>;
238 static void encode_nfspath3(struct xdr_stream
*xdr
, struct page
**pages
,
241 BUG_ON(length
> NFS3_MAXPATHLEN
);
242 encode_uint32(xdr
, length
);
243 xdr_write_pages(xdr
, pages
, 0, length
);
246 static int decode_nfspath3(struct xdr_stream
*xdr
)
251 p
= xdr_inline_decode(xdr
, 4);
252 if (unlikely(p
== NULL
))
254 count
= be32_to_cpup(p
);
255 if (unlikely(count
>= xdr
->buf
->page_len
|| count
> NFS3_MAXPATHLEN
))
256 goto out_nametoolong
;
257 recvd
= xdr_read_pages(xdr
, count
);
258 if (unlikely(count
> recvd
))
260 xdr_terminate_string(xdr
->buf
, count
);
264 dprintk("NFS: returned pathname too long: %u\n", count
);
265 return -ENAMETOOLONG
;
267 dprintk("NFS: server cheating in pathname result: "
268 "count %u > recvd %u\n", count
, recvd
);
271 print_overflow_msg(__func__
, xdr
);
278 * typedef uint64 cookie3
280 static __be32
*xdr_encode_cookie3(__be32
*p
, u64 cookie
)
282 return xdr_encode_hyper(p
, cookie
);
285 static int decode_cookie3(struct xdr_stream
*xdr
, u64
*cookie
)
287 return decode_uint64(xdr
, cookie
);
293 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
295 static __be32
*xdr_encode_cookieverf3(__be32
*p
, const __be32
*verifier
)
297 memcpy(p
, verifier
, NFS3_COOKIEVERFSIZE
);
298 return p
+ XDR_QUADLEN(NFS3_COOKIEVERFSIZE
);
301 static int decode_cookieverf3(struct xdr_stream
*xdr
, __be32
*verifier
)
305 p
= xdr_inline_decode(xdr
, NFS3_COOKIEVERFSIZE
);
306 if (unlikely(p
== NULL
))
308 memcpy(verifier
, p
, NFS3_COOKIEVERFSIZE
);
311 print_overflow_msg(__func__
, xdr
);
318 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
320 static void encode_createverf3(struct xdr_stream
*xdr
, const __be32
*verifier
)
324 p
= xdr_reserve_space(xdr
, NFS3_CREATEVERFSIZE
);
325 memcpy(p
, verifier
, NFS3_CREATEVERFSIZE
);
328 static int decode_writeverf3(struct xdr_stream
*xdr
, __be32
*verifier
)
332 p
= xdr_inline_decode(xdr
, NFS3_WRITEVERFSIZE
);
333 if (unlikely(p
== NULL
))
335 memcpy(verifier
, p
, NFS3_WRITEVERFSIZE
);
338 print_overflow_msg(__func__
, xdr
);
345 * typedef uint64 size3;
347 static __be32
*xdr_decode_size3(__be32
*p
, u64
*size
)
349 return xdr_decode_hyper(p
, size
);
360 #define NFS3_OK NFS_OK
362 static int decode_nfsstat3(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
366 p
= xdr_inline_decode(xdr
, 4);
367 if (unlikely(p
== NULL
))
369 *status
= be32_to_cpup(p
);
372 print_overflow_msg(__func__
, xdr
);
389 static void encode_ftype3(struct xdr_stream
*xdr
, const u32 type
)
391 BUG_ON(type
> NF3FIFO
);
392 encode_uint32(xdr
, type
);
395 static __be32
*xdr_decode_ftype3(__be32
*p
, umode_t
*mode
)
399 type
= be32_to_cpup(p
++);
402 *mode
= nfs_type2fmt
[type
];
414 static void encode_specdata3(struct xdr_stream
*xdr
, const dev_t rdev
)
418 p
= xdr_reserve_space(xdr
, 8);
419 *p
++ = cpu_to_be32(MAJOR(rdev
));
420 *p
= cpu_to_be32(MINOR(rdev
));
423 static __be32
*xdr_decode_specdata3(__be32
*p
, dev_t
*rdev
)
425 unsigned int major
, minor
;
427 major
= be32_to_cpup(p
++);
428 minor
= be32_to_cpup(p
++);
429 *rdev
= MKDEV(major
, minor
);
430 if (MAJOR(*rdev
) != major
|| MINOR(*rdev
) != minor
)
439 * opaque data<NFS3_FHSIZE>;
442 static void encode_nfs_fh3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
446 BUG_ON(fh
->size
> NFS3_FHSIZE
);
447 p
= xdr_reserve_space(xdr
, 4 + fh
->size
);
448 xdr_encode_opaque(p
, fh
->data
, fh
->size
);
451 static int decode_nfs_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
456 p
= xdr_inline_decode(xdr
, 4);
457 if (unlikely(p
== NULL
))
459 length
= be32_to_cpup(p
++);
460 if (unlikely(length
> NFS3_FHSIZE
))
462 p
= xdr_inline_decode(xdr
, length
);
463 if (unlikely(p
== NULL
))
466 memcpy(fh
->data
, p
, length
);
469 dprintk("NFS: file handle size (%u) too big\n", length
);
472 print_overflow_msg(__func__
, xdr
);
476 static void zero_nfs_fh3(struct nfs_fh
*fh
)
478 memset(fh
, 0, sizeof(*fh
));
489 static __be32
*xdr_encode_nfstime3(__be32
*p
, const struct timespec
*timep
)
491 *p
++ = cpu_to_be32(timep
->tv_sec
);
492 *p
++ = cpu_to_be32(timep
->tv_nsec
);
496 static __be32
*xdr_decode_nfstime3(__be32
*p
, struct timespec
*timep
)
498 timep
->tv_sec
= be32_to_cpup(p
++);
499 timep
->tv_nsec
= be32_to_cpup(p
++);
508 * SET_TO_SERVER_TIME = 1,
509 * SET_TO_CLIENT_TIME = 2
512 * union set_mode3 switch (bool set_it) {
519 * union set_uid3 switch (bool set_it) {
526 * union set_gid3 switch (bool set_it) {
533 * union set_size3 switch (bool set_it) {
540 * union set_atime switch (time_how set_it) {
541 * case SET_TO_CLIENT_TIME:
547 * union set_mtime switch (time_how set_it) {
548 * case SET_TO_CLIENT_TIME:
563 static void encode_sattr3(struct xdr_stream
*xdr
, const struct iattr
*attr
)
569 * In order to make only a single xdr_reserve_space() call,
570 * pre-compute the total number of bytes to be reserved.
571 * Six boolean values, one for each set_foo field, are always
572 * present in the encoded result, so start there.
575 if (attr
->ia_valid
& ATTR_MODE
)
577 if (attr
->ia_valid
& ATTR_UID
)
579 if (attr
->ia_valid
& ATTR_GID
)
581 if (attr
->ia_valid
& ATTR_SIZE
)
583 if (attr
->ia_valid
& ATTR_ATIME_SET
)
585 if (attr
->ia_valid
& ATTR_MTIME_SET
)
587 p
= xdr_reserve_space(xdr
, nbytes
);
589 if (attr
->ia_valid
& ATTR_MODE
) {
591 *p
++ = cpu_to_be32(attr
->ia_mode
& S_IALLUGO
);
595 if (attr
->ia_valid
& ATTR_UID
) {
597 *p
++ = cpu_to_be32(attr
->ia_uid
);
601 if (attr
->ia_valid
& ATTR_GID
) {
603 *p
++ = cpu_to_be32(attr
->ia_gid
);
607 if (attr
->ia_valid
& ATTR_SIZE
) {
609 p
= xdr_encode_hyper(p
, (u64
)attr
->ia_size
);
613 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
615 p
= xdr_encode_nfstime3(p
, &attr
->ia_atime
);
616 } else if (attr
->ia_valid
& ATTR_ATIME
) {
621 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
623 xdr_encode_nfstime3(p
, &attr
->ia_mtime
);
624 } else if (attr
->ia_valid
& ATTR_MTIME
) {
649 static int decode_fattr3(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
654 p
= xdr_inline_decode(xdr
, NFS3_fattr_sz
<< 2);
655 if (unlikely(p
== NULL
))
658 p
= xdr_decode_ftype3(p
, &fmode
);
660 fattr
->mode
= (be32_to_cpup(p
++) & ~S_IFMT
) | fmode
;
661 fattr
->nlink
= be32_to_cpup(p
++);
662 fattr
->uid
= be32_to_cpup(p
++);
663 fattr
->gid
= be32_to_cpup(p
++);
665 p
= xdr_decode_size3(p
, &fattr
->size
);
666 p
= xdr_decode_size3(p
, &fattr
->du
.nfs3
.used
);
667 p
= xdr_decode_specdata3(p
, &fattr
->rdev
);
669 p
= xdr_decode_hyper(p
, &fattr
->fsid
.major
);
670 fattr
->fsid
.minor
= 0;
672 p
= xdr_decode_fileid3(p
, &fattr
->fileid
);
673 p
= xdr_decode_nfstime3(p
, &fattr
->atime
);
674 p
= xdr_decode_nfstime3(p
, &fattr
->mtime
);
675 xdr_decode_nfstime3(p
, &fattr
->ctime
);
676 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
678 fattr
->valid
|= NFS_ATTR_FATTR_V3
;
681 print_overflow_msg(__func__
, xdr
);
688 * union post_op_attr switch (bool attributes_follow) {
695 static int decode_post_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
699 p
= xdr_inline_decode(xdr
, 4);
700 if (unlikely(p
== NULL
))
703 return decode_fattr3(xdr
, fattr
);
706 print_overflow_msg(__func__
, xdr
);
718 static int decode_wcc_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
722 p
= xdr_inline_decode(xdr
, NFS3_wcc_attr_sz
<< 2);
723 if (unlikely(p
== NULL
))
726 fattr
->valid
|= NFS_ATTR_FATTR_PRESIZE
727 | NFS_ATTR_FATTR_PRECHANGE
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
);
734 fattr
->pre_change_attr
= nfs_timespec_to_change_attr(&fattr
->pre_ctime
);
738 print_overflow_msg(__func__
, xdr
);
744 * union pre_op_attr switch (bool attributes_follow) {
746 * wcc_attr attributes;
754 * pre_op_attr before;
755 * post_op_attr after;
758 static int decode_pre_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
762 p
= xdr_inline_decode(xdr
, 4);
763 if (unlikely(p
== NULL
))
766 return decode_wcc_attr(xdr
, fattr
);
769 print_overflow_msg(__func__
, xdr
);
773 static int decode_wcc_data(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
777 error
= decode_pre_op_attr(xdr
, fattr
);
780 error
= decode_post_op_attr(xdr
, fattr
);
788 * union post_op_fh3 switch (bool handle_follows) {
795 static int decode_post_op_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
797 __be32
*p
= xdr_inline_decode(xdr
, 4);
798 if (unlikely(p
== NULL
))
801 return decode_nfs_fh3(xdr
, fh
);
805 print_overflow_msg(__func__
, xdr
);
812 * struct diropargs3 {
817 static void encode_diropargs3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
818 const char *name
, u32 length
)
820 encode_nfs_fh3(xdr
, fh
);
821 encode_filename3(xdr
, name
, length
);
826 * NFSv3 XDR encode functions
828 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
829 * "NFS Version 3 Protocol Specification".
835 * struct GETATTR3args {
839 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst
*req
,
840 struct xdr_stream
*xdr
,
841 const struct nfs_fh
*fh
)
843 encode_nfs_fh3(xdr
, fh
);
849 * union sattrguard3 switch (bool check) {
851 * nfstime3 obj_ctime;
856 * struct SETATTR3args {
858 * sattr3 new_attributes;
862 static void encode_sattrguard3(struct xdr_stream
*xdr
,
863 const struct nfs3_sattrargs
*args
)
868 p
= xdr_reserve_space(xdr
, 4 + 8);
870 xdr_encode_nfstime3(p
, &args
->guardtime
);
872 p
= xdr_reserve_space(xdr
, 4);
877 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst
*req
,
878 struct xdr_stream
*xdr
,
879 const struct nfs3_sattrargs
*args
)
881 encode_nfs_fh3(xdr
, args
->fh
);
882 encode_sattr3(xdr
, args
->sattr
);
883 encode_sattrguard3(xdr
, args
);
889 * struct LOOKUP3args {
893 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst
*req
,
894 struct xdr_stream
*xdr
,
895 const struct nfs3_diropargs
*args
)
897 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
903 * struct ACCESS3args {
908 static void encode_access3args(struct xdr_stream
*xdr
,
909 const struct nfs3_accessargs
*args
)
911 encode_nfs_fh3(xdr
, args
->fh
);
912 encode_uint32(xdr
, args
->access
);
915 static void nfs3_xdr_enc_access3args(struct rpc_rqst
*req
,
916 struct xdr_stream
*xdr
,
917 const struct nfs3_accessargs
*args
)
919 encode_access3args(xdr
, args
);
923 * 3.3.5 READLINK3args
925 * struct READLINK3args {
929 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst
*req
,
930 struct xdr_stream
*xdr
,
931 const struct nfs3_readlinkargs
*args
)
933 encode_nfs_fh3(xdr
, args
->fh
);
934 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
935 args
->pglen
, NFS3_readlinkres_sz
);
947 static void encode_read3args(struct xdr_stream
*xdr
,
948 const struct nfs_readargs
*args
)
952 encode_nfs_fh3(xdr
, args
->fh
);
954 p
= xdr_reserve_space(xdr
, 8 + 4);
955 p
= xdr_encode_hyper(p
, args
->offset
);
956 *p
= cpu_to_be32(args
->count
);
959 static void nfs3_xdr_enc_read3args(struct rpc_rqst
*req
,
960 struct xdr_stream
*xdr
,
961 const struct nfs_readargs
*args
)
963 encode_read3args(xdr
, args
);
964 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
965 args
->count
, NFS3_readres_sz
);
966 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
978 * struct WRITE3args {
986 static void encode_write3args(struct xdr_stream
*xdr
,
987 const struct nfs_writeargs
*args
)
991 encode_nfs_fh3(xdr
, args
->fh
);
993 p
= xdr_reserve_space(xdr
, 8 + 4 + 4 + 4);
994 p
= xdr_encode_hyper(p
, args
->offset
);
995 *p
++ = cpu_to_be32(args
->count
);
996 *p
++ = cpu_to_be32(args
->stable
);
997 *p
= cpu_to_be32(args
->count
);
998 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, args
->count
);
1001 static void nfs3_xdr_enc_write3args(struct rpc_rqst
*req
,
1002 struct xdr_stream
*xdr
,
1003 const struct nfs_writeargs
*args
)
1005 encode_write3args(xdr
, args
);
1006 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1012 * enum createmode3 {
1018 * union createhow3 switch (createmode3 mode) {
1021 * sattr3 obj_attributes;
1026 * struct CREATE3args {
1031 static void encode_createhow3(struct xdr_stream
*xdr
,
1032 const struct nfs3_createargs
*args
)
1034 encode_uint32(xdr
, args
->createmode
);
1035 switch (args
->createmode
) {
1036 case NFS3_CREATE_UNCHECKED
:
1037 case NFS3_CREATE_GUARDED
:
1038 encode_sattr3(xdr
, args
->sattr
);
1040 case NFS3_CREATE_EXCLUSIVE
:
1041 encode_createverf3(xdr
, args
->verifier
);
1048 static void nfs3_xdr_enc_create3args(struct rpc_rqst
*req
,
1049 struct xdr_stream
*xdr
,
1050 const struct nfs3_createargs
*args
)
1052 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1053 encode_createhow3(xdr
, args
);
1059 * struct MKDIR3args {
1061 * sattr3 attributes;
1064 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst
*req
,
1065 struct xdr_stream
*xdr
,
1066 const struct nfs3_mkdirargs
*args
)
1068 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1069 encode_sattr3(xdr
, args
->sattr
);
1073 * 3.3.10 SYMLINK3args
1075 * struct symlinkdata3 {
1076 * sattr3 symlink_attributes;
1077 * nfspath3 symlink_data;
1080 * struct SYMLINK3args {
1082 * symlinkdata3 symlink;
1085 static void encode_symlinkdata3(struct xdr_stream
*xdr
,
1086 const struct nfs3_symlinkargs
*args
)
1088 encode_sattr3(xdr
, args
->sattr
);
1089 encode_nfspath3(xdr
, args
->pages
, args
->pathlen
);
1092 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst
*req
,
1093 struct xdr_stream
*xdr
,
1094 const struct nfs3_symlinkargs
*args
)
1096 encode_diropargs3(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
1097 encode_symlinkdata3(xdr
, args
);
1103 * struct devicedata3 {
1104 * sattr3 dev_attributes;
1108 * union mknoddata3 switch (ftype3 type) {
1111 * devicedata3 device;
1114 * sattr3 pipe_attributes;
1119 * struct MKNOD3args {
1124 static void encode_devicedata3(struct xdr_stream
*xdr
,
1125 const struct nfs3_mknodargs
*args
)
1127 encode_sattr3(xdr
, args
->sattr
);
1128 encode_specdata3(xdr
, args
->rdev
);
1131 static void encode_mknoddata3(struct xdr_stream
*xdr
,
1132 const struct nfs3_mknodargs
*args
)
1134 encode_ftype3(xdr
, args
->type
);
1135 switch (args
->type
) {
1138 encode_devicedata3(xdr
, args
);
1142 encode_sattr3(xdr
, args
->sattr
);
1152 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst
*req
,
1153 struct xdr_stream
*xdr
,
1154 const struct nfs3_mknodargs
*args
)
1156 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1157 encode_mknoddata3(xdr
, args
);
1161 * 3.3.12 REMOVE3args
1163 * struct REMOVE3args {
1164 * diropargs3 object;
1167 static void nfs3_xdr_enc_remove3args(struct rpc_rqst
*req
,
1168 struct xdr_stream
*xdr
,
1169 const struct nfs_removeargs
*args
)
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
,
1184 const struct nfs_renameargs
*args
)
1186 const struct qstr
*old
= args
->old_name
;
1187 const struct qstr
*new = args
->new_name
;
1189 encode_diropargs3(xdr
, args
->old_dir
, old
->name
, old
->len
);
1190 encode_diropargs3(xdr
, args
->new_dir
, new->name
, new->len
);
1196 * struct LINK3args {
1201 static void nfs3_xdr_enc_link3args(struct rpc_rqst
*req
,
1202 struct xdr_stream
*xdr
,
1203 const struct nfs3_linkargs
*args
)
1205 encode_nfs_fh3(xdr
, args
->fromfh
);
1206 encode_diropargs3(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
1210 * 3.3.16 READDIR3args
1212 * struct READDIR3args {
1215 * cookieverf3 cookieverf;
1219 static void encode_readdir3args(struct xdr_stream
*xdr
,
1220 const struct nfs3_readdirargs
*args
)
1224 encode_nfs_fh3(xdr
, args
->fh
);
1226 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4);
1227 p
= xdr_encode_cookie3(p
, args
->cookie
);
1228 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1229 *p
= cpu_to_be32(args
->count
);
1232 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst
*req
,
1233 struct xdr_stream
*xdr
,
1234 const struct nfs3_readdirargs
*args
)
1236 encode_readdir3args(xdr
, args
);
1237 prepare_reply_buffer(req
, args
->pages
, 0,
1238 args
->count
, NFS3_readdirres_sz
);
1242 * 3.3.17 READDIRPLUS3args
1244 * struct READDIRPLUS3args {
1247 * cookieverf3 cookieverf;
1252 static void encode_readdirplus3args(struct xdr_stream
*xdr
,
1253 const struct nfs3_readdirargs
*args
)
1257 encode_nfs_fh3(xdr
, args
->fh
);
1259 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4 + 4);
1260 p
= xdr_encode_cookie3(p
, args
->cookie
);
1261 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1264 * readdirplus: need dircount + buffer size.
1265 * We just make sure we make dircount big enough
1267 *p
++ = cpu_to_be32(args
->count
>> 3);
1269 *p
= cpu_to_be32(args
->count
);
1272 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst
*req
,
1273 struct xdr_stream
*xdr
,
1274 const struct nfs3_readdirargs
*args
)
1276 encode_readdirplus3args(xdr
, args
);
1277 prepare_reply_buffer(req
, args
->pages
, 0,
1278 args
->count
, NFS3_readdirres_sz
);
1282 * 3.3.21 COMMIT3args
1284 * struct COMMIT3args {
1290 static void encode_commit3args(struct xdr_stream
*xdr
,
1291 const struct nfs_commitargs
*args
)
1295 encode_nfs_fh3(xdr
, args
->fh
);
1297 p
= xdr_reserve_space(xdr
, 8 + 4);
1298 p
= xdr_encode_hyper(p
, args
->offset
);
1299 *p
= cpu_to_be32(args
->count
);
1302 static void nfs3_xdr_enc_commit3args(struct rpc_rqst
*req
,
1303 struct xdr_stream
*xdr
,
1304 const struct nfs_commitargs
*args
)
1306 encode_commit3args(xdr
, args
);
1309 #ifdef CONFIG_NFS_V3_ACL
1311 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst
*req
,
1312 struct xdr_stream
*xdr
,
1313 const struct nfs3_getaclargs
*args
)
1315 encode_nfs_fh3(xdr
, args
->fh
);
1316 encode_uint32(xdr
, args
->mask
);
1317 if (args
->mask
& (NFS_ACL
| NFS_DFACL
))
1318 prepare_reply_buffer(req
, args
->pages
, 0,
1319 NFSACL_MAXPAGES
<< PAGE_SHIFT
,
1323 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst
*req
,
1324 struct xdr_stream
*xdr
,
1325 const struct nfs3_setaclargs
*args
)
1330 encode_nfs_fh3(xdr
, NFS_FH(args
->inode
));
1331 encode_uint32(xdr
, args
->mask
);
1333 base
= req
->rq_slen
;
1334 if (args
->npages
!= 0)
1335 xdr_write_pages(xdr
, args
->pages
, 0, args
->len
);
1337 xdr_reserve_space(xdr
, NFS_ACL_INLINE_BUFSIZE
);
1339 error
= nfsacl_encode(xdr
->buf
, base
, args
->inode
,
1340 (args
->mask
& NFS_ACL
) ?
1341 args
->acl_access
: NULL
, 1, 0);
1343 error
= nfsacl_encode(xdr
->buf
, base
+ error
, args
->inode
,
1344 (args
->mask
& NFS_DFACL
) ?
1345 args
->acl_default
: NULL
, 1,
1350 #endif /* CONFIG_NFS_V3_ACL */
1353 * NFSv3 XDR decode functions
1355 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1356 * "NFS Version 3 Protocol Specification".
1362 * struct GETATTR3resok {
1363 * fattr3 obj_attributes;
1366 * union GETATTR3res switch (nfsstat3 status) {
1368 * GETATTR3resok resok;
1373 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst
*req
,
1374 struct xdr_stream
*xdr
,
1375 struct nfs_fattr
*result
)
1377 enum nfs_stat status
;
1380 error
= decode_nfsstat3(xdr
, &status
);
1381 if (unlikely(error
))
1383 if (status
!= NFS3_OK
)
1385 error
= decode_fattr3(xdr
, result
);
1389 return nfs3_stat_to_errno(status
);
1395 * struct SETATTR3resok {
1399 * struct SETATTR3resfail {
1403 * union SETATTR3res switch (nfsstat3 status) {
1405 * SETATTR3resok resok;
1407 * SETATTR3resfail resfail;
1410 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst
*req
,
1411 struct xdr_stream
*xdr
,
1412 struct nfs_fattr
*result
)
1414 enum nfs_stat status
;
1417 error
= decode_nfsstat3(xdr
, &status
);
1418 if (unlikely(error
))
1420 error
= decode_wcc_data(xdr
, result
);
1421 if (unlikely(error
))
1423 if (status
!= NFS3_OK
)
1428 return nfs3_stat_to_errno(status
);
1434 * struct LOOKUP3resok {
1436 * post_op_attr obj_attributes;
1437 * post_op_attr dir_attributes;
1440 * struct LOOKUP3resfail {
1441 * post_op_attr dir_attributes;
1444 * union LOOKUP3res switch (nfsstat3 status) {
1446 * LOOKUP3resok resok;
1448 * LOOKUP3resfail resfail;
1451 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst
*req
,
1452 struct xdr_stream
*xdr
,
1453 struct nfs3_diropres
*result
)
1455 enum nfs_stat status
;
1458 error
= decode_nfsstat3(xdr
, &status
);
1459 if (unlikely(error
))
1461 if (status
!= NFS3_OK
)
1463 error
= decode_nfs_fh3(xdr
, result
->fh
);
1464 if (unlikely(error
))
1466 error
= decode_post_op_attr(xdr
, result
->fattr
);
1467 if (unlikely(error
))
1469 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1473 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1474 if (unlikely(error
))
1476 return nfs3_stat_to_errno(status
);
1482 * struct ACCESS3resok {
1483 * post_op_attr obj_attributes;
1487 * struct ACCESS3resfail {
1488 * post_op_attr obj_attributes;
1491 * union ACCESS3res switch (nfsstat3 status) {
1493 * ACCESS3resok resok;
1495 * ACCESS3resfail resfail;
1498 static int nfs3_xdr_dec_access3res(struct rpc_rqst
*req
,
1499 struct xdr_stream
*xdr
,
1500 struct nfs3_accessres
*result
)
1502 enum nfs_stat status
;
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 nfs3_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
,
1540 struct xdr_stream
*xdr
,
1541 struct nfs_fattr
*result
)
1543 enum nfs_stat status
;
1546 error
= decode_nfsstat3(xdr
, &status
);
1547 if (unlikely(error
))
1549 error
= decode_post_op_attr(xdr
, result
);
1550 if (unlikely(error
))
1552 if (status
!= NFS3_OK
)
1554 error
= decode_nfspath3(xdr
);
1558 return nfs3_stat_to_errno(status
);
1564 * struct READ3resok {
1565 * post_op_attr file_attributes;
1571 * struct READ3resfail {
1572 * post_op_attr file_attributes;
1575 * union READ3res switch (nfsstat3 status) {
1579 * READ3resfail resfail;
1582 static int decode_read3resok(struct xdr_stream
*xdr
,
1583 struct nfs_readres
*result
)
1585 u32 eof
, count
, ocount
, recvd
;
1588 p
= xdr_inline_decode(xdr
, 4 + 4 + 4);
1589 if (unlikely(p
== NULL
))
1591 count
= be32_to_cpup(p
++);
1592 eof
= be32_to_cpup(p
++);
1593 ocount
= be32_to_cpup(p
++);
1594 if (unlikely(ocount
!= count
))
1596 recvd
= xdr_read_pages(xdr
, count
);
1597 if (unlikely(count
> recvd
))
1601 result
->count
= count
;
1604 dprintk("NFS: READ count doesn't match length of opaque: "
1605 "count %u != ocount %u\n", count
, ocount
);
1608 dprintk("NFS: server cheating in read result: "
1609 "count %u > recvd %u\n", count
, recvd
);
1614 print_overflow_msg(__func__
, xdr
);
1618 static int nfs3_xdr_dec_read3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1619 struct nfs_readres
*result
)
1621 enum nfs_stat status
;
1624 error
= decode_nfsstat3(xdr
, &status
);
1625 if (unlikely(error
))
1627 error
= decode_post_op_attr(xdr
, result
->fattr
);
1628 if (unlikely(error
))
1630 if (status
!= NFS3_OK
)
1632 error
= decode_read3resok(xdr
, result
);
1636 return nfs3_stat_to_errno(status
);
1648 * struct WRITE3resok {
1649 * wcc_data file_wcc;
1651 * stable_how committed;
1655 * struct WRITE3resfail {
1656 * wcc_data file_wcc;
1659 * union WRITE3res switch (nfsstat3 status) {
1661 * WRITE3resok resok;
1663 * WRITE3resfail resfail;
1666 static int decode_write3resok(struct xdr_stream
*xdr
,
1667 struct nfs_writeres
*result
)
1671 p
= xdr_inline_decode(xdr
, 4 + 4 + NFS3_WRITEVERFSIZE
);
1672 if (unlikely(p
== NULL
))
1674 result
->count
= be32_to_cpup(p
++);
1675 result
->verf
->committed
= be32_to_cpup(p
++);
1676 if (unlikely(result
->verf
->committed
> NFS_FILE_SYNC
))
1678 memcpy(result
->verf
->verifier
, p
, NFS3_WRITEVERFSIZE
);
1679 return result
->count
;
1681 dprintk("NFS: bad stable_how value: %u\n", result
->verf
->committed
);
1684 print_overflow_msg(__func__
, xdr
);
1688 static int nfs3_xdr_dec_write3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1689 struct nfs_writeres
*result
)
1691 enum nfs_stat status
;
1694 error
= decode_nfsstat3(xdr
, &status
);
1695 if (unlikely(error
))
1697 error
= decode_wcc_data(xdr
, result
->fattr
);
1698 if (unlikely(error
))
1700 if (status
!= NFS3_OK
)
1702 error
= decode_write3resok(xdr
, result
);
1706 return nfs3_stat_to_errno(status
);
1712 * struct CREATE3resok {
1714 * post_op_attr obj_attributes;
1718 * struct CREATE3resfail {
1722 * union CREATE3res switch (nfsstat3 status) {
1724 * CREATE3resok resok;
1726 * CREATE3resfail resfail;
1729 static int decode_create3resok(struct xdr_stream
*xdr
,
1730 struct nfs3_diropres
*result
)
1734 error
= decode_post_op_fh3(xdr
, result
->fh
);
1735 if (unlikely(error
))
1737 error
= decode_post_op_attr(xdr
, result
->fattr
);
1738 if (unlikely(error
))
1740 /* The server isn't required to return a file handle.
1741 * If it didn't, force the client to perform a LOOKUP
1742 * to determine the correct file handle and attribute
1743 * values for the new object. */
1744 if (result
->fh
->size
== 0)
1745 result
->fattr
->valid
= 0;
1746 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1751 static int nfs3_xdr_dec_create3res(struct rpc_rqst
*req
,
1752 struct xdr_stream
*xdr
,
1753 struct nfs3_diropres
*result
)
1755 enum nfs_stat status
;
1758 error
= decode_nfsstat3(xdr
, &status
);
1759 if (unlikely(error
))
1761 if (status
!= NFS3_OK
)
1763 error
= decode_create3resok(xdr
, result
);
1767 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1768 if (unlikely(error
))
1770 return nfs3_stat_to_errno(status
);
1776 * struct REMOVE3resok {
1780 * struct REMOVE3resfail {
1784 * union REMOVE3res switch (nfsstat3 status) {
1786 * REMOVE3resok resok;
1788 * REMOVE3resfail resfail;
1791 static int nfs3_xdr_dec_remove3res(struct rpc_rqst
*req
,
1792 struct xdr_stream
*xdr
,
1793 struct nfs_removeres
*result
)
1795 enum nfs_stat status
;
1798 error
= decode_nfsstat3(xdr
, &status
);
1799 if (unlikely(error
))
1801 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1802 if (unlikely(error
))
1804 if (status
!= NFS3_OK
)
1809 return nfs3_stat_to_errno(status
);
1815 * struct RENAME3resok {
1816 * wcc_data fromdir_wcc;
1817 * wcc_data todir_wcc;
1820 * struct RENAME3resfail {
1821 * wcc_data fromdir_wcc;
1822 * wcc_data todir_wcc;
1825 * union RENAME3res switch (nfsstat3 status) {
1827 * RENAME3resok resok;
1829 * RENAME3resfail resfail;
1832 static int nfs3_xdr_dec_rename3res(struct rpc_rqst
*req
,
1833 struct xdr_stream
*xdr
,
1834 struct nfs_renameres
*result
)
1836 enum nfs_stat status
;
1839 error
= decode_nfsstat3(xdr
, &status
);
1840 if (unlikely(error
))
1842 error
= decode_wcc_data(xdr
, result
->old_fattr
);
1843 if (unlikely(error
))
1845 error
= decode_wcc_data(xdr
, result
->new_fattr
);
1846 if (unlikely(error
))
1848 if (status
!= NFS3_OK
)
1853 return nfs3_stat_to_errno(status
);
1859 * struct LINK3resok {
1860 * post_op_attr file_attributes;
1861 * wcc_data linkdir_wcc;
1864 * struct LINK3resfail {
1865 * post_op_attr file_attributes;
1866 * wcc_data linkdir_wcc;
1869 * union LINK3res switch (nfsstat3 status) {
1873 * LINK3resfail resfail;
1876 static int nfs3_xdr_dec_link3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1877 struct nfs3_linkres
*result
)
1879 enum nfs_stat status
;
1882 error
= decode_nfsstat3(xdr
, &status
);
1883 if (unlikely(error
))
1885 error
= decode_post_op_attr(xdr
, result
->fattr
);
1886 if (unlikely(error
))
1888 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1889 if (unlikely(error
))
1891 if (status
!= NFS3_OK
)
1896 return nfs3_stat_to_errno(status
);
1900 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1901 * the local page cache
1902 * @xdr: XDR stream where entry resides
1903 * @entry: buffer to fill in with entry data
1904 * @plus: boolean indicating whether this should be a readdirplus entry
1906 * Returns zero if successful, otherwise a negative errno value is
1909 * This function is not invoked during READDIR reply decoding, but
1910 * rather whenever an application invokes the getdents(2) system call
1911 * on a directory already in our cache.
1919 * fhandle3 filehandle;
1920 * post_op_attr3 attributes;
1921 * entry3 *nextentry;
1925 * struct entryplus3 {
1929 * post_op_attr name_attributes;
1930 * post_op_fh3 name_handle;
1931 * entryplus3 *nextentry;
1934 int nfs3_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
1937 struct nfs_entry old
= *entry
;
1941 p
= xdr_inline_decode(xdr
, 4);
1942 if (unlikely(p
== NULL
))
1944 if (*p
== xdr_zero
) {
1945 p
= xdr_inline_decode(xdr
, 4);
1946 if (unlikely(p
== NULL
))
1954 error
= decode_fileid3(xdr
, &entry
->ino
);
1955 if (unlikely(error
))
1958 error
= decode_inline_filename3(xdr
, &entry
->name
, &entry
->len
);
1959 if (unlikely(error
))
1962 entry
->prev_cookie
= entry
->cookie
;
1963 error
= decode_cookie3(xdr
, &entry
->cookie
);
1964 if (unlikely(error
))
1967 entry
->d_type
= DT_UNKNOWN
;
1970 entry
->fattr
->valid
= 0;
1971 error
= decode_post_op_attr(xdr
, entry
->fattr
);
1972 if (unlikely(error
))
1974 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_V3
)
1975 entry
->d_type
= nfs_umode_to_dtype(entry
->fattr
->mode
);
1977 /* In fact, a post_op_fh3: */
1978 p
= xdr_inline_decode(xdr
, 4);
1979 if (unlikely(p
== NULL
))
1981 if (*p
!= xdr_zero
) {
1982 error
= decode_nfs_fh3(xdr
, entry
->fh
);
1983 if (unlikely(error
)) {
1984 if (error
== -E2BIG
)
1989 zero_nfs_fh3(entry
->fh
);
1995 print_overflow_msg(__func__
, xdr
);
1998 dprintk("NFS: directory entry contains invalid file handle\n");
2004 * 3.3.16 READDIR3res
2011 * struct READDIR3resok {
2012 * post_op_attr dir_attributes;
2013 * cookieverf3 cookieverf;
2017 * struct READDIR3resfail {
2018 * post_op_attr dir_attributes;
2021 * union READDIR3res switch (nfsstat3 status) {
2023 * READDIR3resok resok;
2025 * READDIR3resfail resfail;
2028 * Read the directory contents into the page cache, but otherwise
2029 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2030 * during subsequent nfs_readdir() calls.
2032 static int decode_dirlist3(struct xdr_stream
*xdr
)
2034 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
2037 static int decode_readdir3resok(struct xdr_stream
*xdr
,
2038 struct nfs3_readdirres
*result
)
2042 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2043 if (unlikely(error
))
2045 /* XXX: do we need to check if result->verf != NULL ? */
2046 error
= decode_cookieverf3(xdr
, result
->verf
);
2047 if (unlikely(error
))
2049 error
= decode_dirlist3(xdr
);
2054 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst
*req
,
2055 struct xdr_stream
*xdr
,
2056 struct nfs3_readdirres
*result
)
2058 enum nfs_stat status
;
2061 error
= decode_nfsstat3(xdr
, &status
);
2062 if (unlikely(error
))
2064 if (status
!= NFS3_OK
)
2066 error
= decode_readdir3resok(xdr
, result
);
2070 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2071 if (unlikely(error
))
2073 return nfs3_stat_to_errno(status
);
2079 * struct FSSTAT3resok {
2080 * post_op_attr obj_attributes;
2090 * struct FSSTAT3resfail {
2091 * post_op_attr obj_attributes;
2094 * union FSSTAT3res switch (nfsstat3 status) {
2096 * FSSTAT3resok resok;
2098 * FSSTAT3resfail resfail;
2101 static int decode_fsstat3resok(struct xdr_stream
*xdr
,
2102 struct nfs_fsstat
*result
)
2106 p
= xdr_inline_decode(xdr
, 8 * 6 + 4);
2107 if (unlikely(p
== NULL
))
2109 p
= xdr_decode_size3(p
, &result
->tbytes
);
2110 p
= xdr_decode_size3(p
, &result
->fbytes
);
2111 p
= xdr_decode_size3(p
, &result
->abytes
);
2112 p
= xdr_decode_size3(p
, &result
->tfiles
);
2113 p
= xdr_decode_size3(p
, &result
->ffiles
);
2114 xdr_decode_size3(p
, &result
->afiles
);
2115 /* ignore invarsec */
2118 print_overflow_msg(__func__
, xdr
);
2122 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst
*req
,
2123 struct xdr_stream
*xdr
,
2124 struct nfs_fsstat
*result
)
2126 enum nfs_stat status
;
2129 error
= decode_nfsstat3(xdr
, &status
);
2130 if (unlikely(error
))
2132 error
= decode_post_op_attr(xdr
, result
->fattr
);
2133 if (unlikely(error
))
2135 if (status
!= NFS3_OK
)
2137 error
= decode_fsstat3resok(xdr
, result
);
2141 return nfs3_stat_to_errno(status
);
2147 * struct FSINFO3resok {
2148 * post_op_attr obj_attributes;
2156 * size3 maxfilesize;
2157 * nfstime3 time_delta;
2158 * uint32 properties;
2161 * struct FSINFO3resfail {
2162 * post_op_attr obj_attributes;
2165 * union FSINFO3res switch (nfsstat3 status) {
2167 * FSINFO3resok resok;
2169 * FSINFO3resfail resfail;
2172 static int decode_fsinfo3resok(struct xdr_stream
*xdr
,
2173 struct nfs_fsinfo
*result
)
2177 p
= xdr_inline_decode(xdr
, 4 * 7 + 8 + 8 + 4);
2178 if (unlikely(p
== NULL
))
2180 result
->rtmax
= be32_to_cpup(p
++);
2181 result
->rtpref
= be32_to_cpup(p
++);
2182 result
->rtmult
= be32_to_cpup(p
++);
2183 result
->wtmax
= be32_to_cpup(p
++);
2184 result
->wtpref
= be32_to_cpup(p
++);
2185 result
->wtmult
= be32_to_cpup(p
++);
2186 result
->dtpref
= be32_to_cpup(p
++);
2187 p
= xdr_decode_size3(p
, &result
->maxfilesize
);
2188 xdr_decode_nfstime3(p
, &result
->time_delta
);
2190 /* ignore properties */
2191 result
->lease_time
= 0;
2194 print_overflow_msg(__func__
, xdr
);
2198 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst
*req
,
2199 struct xdr_stream
*xdr
,
2200 struct nfs_fsinfo
*result
)
2202 enum nfs_stat status
;
2205 error
= decode_nfsstat3(xdr
, &status
);
2206 if (unlikely(error
))
2208 error
= decode_post_op_attr(xdr
, result
->fattr
);
2209 if (unlikely(error
))
2211 if (status
!= NFS3_OK
)
2213 error
= decode_fsinfo3resok(xdr
, result
);
2217 return nfs3_stat_to_errno(status
);
2221 * 3.3.20 PATHCONF3res
2223 * struct PATHCONF3resok {
2224 * post_op_attr obj_attributes;
2228 * bool chown_restricted;
2229 * bool case_insensitive;
2230 * bool case_preserving;
2233 * struct PATHCONF3resfail {
2234 * post_op_attr obj_attributes;
2237 * union PATHCONF3res switch (nfsstat3 status) {
2239 * PATHCONF3resok resok;
2241 * PATHCONF3resfail resfail;
2244 static int decode_pathconf3resok(struct xdr_stream
*xdr
,
2245 struct nfs_pathconf
*result
)
2249 p
= xdr_inline_decode(xdr
, 4 * 6);
2250 if (unlikely(p
== NULL
))
2252 result
->max_link
= be32_to_cpup(p
++);
2253 result
->max_namelen
= be32_to_cpup(p
);
2254 /* ignore remaining fields */
2257 print_overflow_msg(__func__
, xdr
);
2261 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst
*req
,
2262 struct xdr_stream
*xdr
,
2263 struct nfs_pathconf
*result
)
2265 enum nfs_stat status
;
2268 error
= decode_nfsstat3(xdr
, &status
);
2269 if (unlikely(error
))
2271 error
= decode_post_op_attr(xdr
, result
->fattr
);
2272 if (unlikely(error
))
2274 if (status
!= NFS3_OK
)
2276 error
= decode_pathconf3resok(xdr
, result
);
2280 return nfs3_stat_to_errno(status
);
2286 * struct COMMIT3resok {
2287 * wcc_data file_wcc;
2291 * struct COMMIT3resfail {
2292 * wcc_data file_wcc;
2295 * union COMMIT3res switch (nfsstat3 status) {
2297 * COMMIT3resok resok;
2299 * COMMIT3resfail resfail;
2302 static int nfs3_xdr_dec_commit3res(struct rpc_rqst
*req
,
2303 struct xdr_stream
*xdr
,
2304 struct nfs_commitres
*result
)
2306 enum nfs_stat status
;
2309 error
= decode_nfsstat3(xdr
, &status
);
2310 if (unlikely(error
))
2312 error
= decode_wcc_data(xdr
, result
->fattr
);
2313 if (unlikely(error
))
2315 if (status
!= NFS3_OK
)
2317 error
= decode_writeverf3(xdr
, result
->verf
->verifier
);
2321 return nfs3_stat_to_errno(status
);
2324 #ifdef CONFIG_NFS_V3_ACL
2326 static inline int decode_getacl3resok(struct xdr_stream
*xdr
,
2327 struct nfs3_getaclres
*result
)
2329 struct posix_acl
**acl
;
2330 unsigned int *aclcnt
;
2334 error
= decode_post_op_attr(xdr
, result
->fattr
);
2335 if (unlikely(error
))
2337 error
= decode_uint32(xdr
, &result
->mask
);
2338 if (unlikely(error
))
2341 if (result
->mask
& ~(NFS_ACL
|NFS_ACLCNT
|NFS_DFACL
|NFS_DFACLCNT
))
2344 hdrlen
= (u8
*)xdr
->p
- (u8
*)xdr
->iov
->iov_base
;
2347 if (result
->mask
& NFS_ACL
)
2348 acl
= &result
->acl_access
;
2350 if (result
->mask
& NFS_ACLCNT
)
2351 aclcnt
= &result
->acl_access_count
;
2352 error
= nfsacl_decode(xdr
->buf
, hdrlen
, aclcnt
, acl
);
2353 if (unlikely(error
<= 0))
2357 if (result
->mask
& NFS_DFACL
)
2358 acl
= &result
->acl_default
;
2360 if (result
->mask
& NFS_DFACLCNT
)
2361 aclcnt
= &result
->acl_default_count
;
2362 error
= nfsacl_decode(xdr
->buf
, hdrlen
+ error
, aclcnt
, acl
);
2363 if (unlikely(error
<= 0))
2370 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst
*req
,
2371 struct xdr_stream
*xdr
,
2372 struct nfs3_getaclres
*result
)
2374 enum nfs_stat status
;
2377 error
= decode_nfsstat3(xdr
, &status
);
2378 if (unlikely(error
))
2380 if (status
!= NFS3_OK
)
2382 error
= decode_getacl3resok(xdr
, result
);
2386 return nfs3_stat_to_errno(status
);
2389 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst
*req
,
2390 struct xdr_stream
*xdr
,
2391 struct nfs_fattr
*result
)
2393 enum nfs_stat status
;
2396 error
= decode_nfsstat3(xdr
, &status
);
2397 if (unlikely(error
))
2399 if (status
!= NFS3_OK
)
2401 error
= decode_post_op_attr(xdr
, result
);
2405 return nfs3_stat_to_errno(status
);
2408 #endif /* CONFIG_NFS_V3_ACL */
2412 * We need to translate between nfs status return values and
2413 * the local errno values which may not be the same.
2415 static const struct {
2420 { NFSERR_PERM
, -EPERM
},
2421 { NFSERR_NOENT
, -ENOENT
},
2422 { NFSERR_IO
, -errno_NFSERR_IO
},
2423 { NFSERR_NXIO
, -ENXIO
},
2424 /* { NFSERR_EAGAIN, -EAGAIN }, */
2425 { NFSERR_ACCES
, -EACCES
},
2426 { NFSERR_EXIST
, -EEXIST
},
2427 { NFSERR_XDEV
, -EXDEV
},
2428 { NFSERR_NODEV
, -ENODEV
},
2429 { NFSERR_NOTDIR
, -ENOTDIR
},
2430 { NFSERR_ISDIR
, -EISDIR
},
2431 { NFSERR_INVAL
, -EINVAL
},
2432 { NFSERR_FBIG
, -EFBIG
},
2433 { NFSERR_NOSPC
, -ENOSPC
},
2434 { NFSERR_ROFS
, -EROFS
},
2435 { NFSERR_MLINK
, -EMLINK
},
2436 { NFSERR_NAMETOOLONG
, -ENAMETOOLONG
},
2437 { NFSERR_NOTEMPTY
, -ENOTEMPTY
},
2438 { NFSERR_DQUOT
, -EDQUOT
},
2439 { NFSERR_STALE
, -ESTALE
},
2440 { NFSERR_REMOTE
, -EREMOTE
},
2442 { NFSERR_WFLUSH
, -EWFLUSH
},
2444 { NFSERR_BADHANDLE
, -EBADHANDLE
},
2445 { NFSERR_NOT_SYNC
, -ENOTSYNC
},
2446 { NFSERR_BAD_COOKIE
, -EBADCOOKIE
},
2447 { NFSERR_NOTSUPP
, -ENOTSUPP
},
2448 { NFSERR_TOOSMALL
, -ETOOSMALL
},
2449 { NFSERR_SERVERFAULT
, -EREMOTEIO
},
2450 { NFSERR_BADTYPE
, -EBADTYPE
},
2451 { NFSERR_JUKEBOX
, -EJUKEBOX
},
2456 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2457 * @status: NFS status code to convert
2459 * Returns a local errno value, or -EIO if the NFS status code is
2460 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2462 static int nfs3_stat_to_errno(enum nfs_stat status
)
2466 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
2467 if (nfs_errtbl
[i
].stat
== (int)status
)
2468 return nfs_errtbl
[i
].errno
;
2470 dprintk("NFS: Unrecognized nfs status value: %u\n", status
);
2471 return nfs_errtbl
[i
].errno
;
2475 #define PROC(proc, argtype, restype, timer) \
2476 [NFS3PROC_##proc] = { \
2477 .p_proc = NFS3PROC_##proc, \
2478 .p_encode = (kxdreproc_t)nfs3_xdr_enc_##argtype##3args, \
2479 .p_decode = (kxdrdproc_t)nfs3_xdr_dec_##restype##3res, \
2480 .p_arglen = NFS3_##argtype##args_sz, \
2481 .p_replen = NFS3_##restype##res_sz, \
2483 .p_statidx = NFS3PROC_##proc, \
2487 struct rpc_procinfo nfs3_procedures
[] = {
2488 PROC(GETATTR
, getattr
, getattr
, 1),
2489 PROC(SETATTR
, setattr
, setattr
, 0),
2490 PROC(LOOKUP
, lookup
, lookup
, 2),
2491 PROC(ACCESS
, access
, access
, 1),
2492 PROC(READLINK
, readlink
, readlink
, 3),
2493 PROC(READ
, read
, read
, 3),
2494 PROC(WRITE
, write
, write
, 4),
2495 PROC(CREATE
, create
, create
, 0),
2496 PROC(MKDIR
, mkdir
, create
, 0),
2497 PROC(SYMLINK
, symlink
, create
, 0),
2498 PROC(MKNOD
, mknod
, create
, 0),
2499 PROC(REMOVE
, remove
, remove
, 0),
2500 PROC(RMDIR
, lookup
, setattr
, 0),
2501 PROC(RENAME
, rename
, rename
, 0),
2502 PROC(LINK
, link
, link
, 0),
2503 PROC(READDIR
, readdir
, readdir
, 3),
2504 PROC(READDIRPLUS
, readdirplus
, readdir
, 3),
2505 PROC(FSSTAT
, getattr
, fsstat
, 0),
2506 PROC(FSINFO
, getattr
, fsinfo
, 0),
2507 PROC(PATHCONF
, getattr
, pathconf
, 0),
2508 PROC(COMMIT
, commit
, commit
, 5),
2511 const struct rpc_version nfs_version3
= {
2513 .nrprocs
= ARRAY_SIZE(nfs3_procedures
),
2514 .procs
= nfs3_procedures
2517 #ifdef CONFIG_NFS_V3_ACL
2518 static struct rpc_procinfo nfs3_acl_procedures
[] = {
2519 [ACLPROC3_GETACL
] = {
2520 .p_proc
= ACLPROC3_GETACL
,
2521 .p_encode
= (kxdreproc_t
)nfs3_xdr_enc_getacl3args
,
2522 .p_decode
= (kxdrdproc_t
)nfs3_xdr_dec_getacl3res
,
2523 .p_arglen
= ACL3_getaclargs_sz
,
2524 .p_replen
= ACL3_getaclres_sz
,
2528 [ACLPROC3_SETACL
] = {
2529 .p_proc
= ACLPROC3_SETACL
,
2530 .p_encode
= (kxdreproc_t
)nfs3_xdr_enc_setacl3args
,
2531 .p_decode
= (kxdrdproc_t
)nfs3_xdr_dec_setacl3res
,
2532 .p_arglen
= ACL3_setaclargs_sz
,
2533 .p_replen
= ACL3_setaclres_sz
,
2539 const struct rpc_version nfsacl_version3
= {
2541 .nrprocs
= sizeof(nfs3_acl_procedures
)/
2542 sizeof(nfs3_acl_procedures
[0]),
2543 .procs
= nfs3_acl_procedures
,
2545 #endif /* CONFIG_NFS_V3_ACL */