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 WARN_ON_ONCE(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 encode_uint32(xdr
, length
);
242 xdr_write_pages(xdr
, pages
, 0, length
);
245 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 recvd
= xdr_read_pages(xdr
, count
);
257 if (unlikely(count
> recvd
))
259 xdr_terminate_string(xdr
->buf
, count
);
263 dprintk("NFS: returned pathname too long: %u\n", count
);
264 return -ENAMETOOLONG
;
266 dprintk("NFS: server cheating in pathname result: "
267 "count %u > recvd %u\n", count
, recvd
);
270 print_overflow_msg(__func__
, xdr
);
277 * typedef uint64 cookie3
279 static __be32
*xdr_encode_cookie3(__be32
*p
, u64 cookie
)
281 return xdr_encode_hyper(p
, cookie
);
284 static int decode_cookie3(struct xdr_stream
*xdr
, u64
*cookie
)
286 return decode_uint64(xdr
, cookie
);
292 * typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
294 static __be32
*xdr_encode_cookieverf3(__be32
*p
, const __be32
*verifier
)
296 memcpy(p
, verifier
, NFS3_COOKIEVERFSIZE
);
297 return p
+ XDR_QUADLEN(NFS3_COOKIEVERFSIZE
);
300 static int decode_cookieverf3(struct xdr_stream
*xdr
, __be32
*verifier
)
304 p
= xdr_inline_decode(xdr
, NFS3_COOKIEVERFSIZE
);
305 if (unlikely(p
== NULL
))
307 memcpy(verifier
, p
, NFS3_COOKIEVERFSIZE
);
310 print_overflow_msg(__func__
, xdr
);
317 * typedef opaque createverf3[NFS3_CREATEVERFSIZE];
319 static void encode_createverf3(struct xdr_stream
*xdr
, const __be32
*verifier
)
323 p
= xdr_reserve_space(xdr
, NFS3_CREATEVERFSIZE
);
324 memcpy(p
, verifier
, NFS3_CREATEVERFSIZE
);
327 static int decode_writeverf3(struct xdr_stream
*xdr
, struct nfs_write_verifier
*verifier
)
331 p
= xdr_inline_decode(xdr
, NFS3_WRITEVERFSIZE
);
332 if (unlikely(p
== NULL
))
334 memcpy(verifier
->data
, p
, NFS3_WRITEVERFSIZE
);
337 print_overflow_msg(__func__
, xdr
);
344 * typedef uint64 size3;
346 static __be32
*xdr_decode_size3(__be32
*p
, u64
*size
)
348 return xdr_decode_hyper(p
, size
);
359 #define NFS3_OK NFS_OK
361 static int decode_nfsstat3(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
365 p
= xdr_inline_decode(xdr
, 4);
366 if (unlikely(p
== NULL
))
368 *status
= be32_to_cpup(p
);
371 print_overflow_msg(__func__
, xdr
);
388 static void encode_ftype3(struct xdr_stream
*xdr
, const u32 type
)
390 encode_uint32(xdr
, type
);
393 static __be32
*xdr_decode_ftype3(__be32
*p
, umode_t
*mode
)
397 type
= be32_to_cpup(p
++);
400 *mode
= nfs_type2fmt
[type
];
412 static void encode_specdata3(struct xdr_stream
*xdr
, const dev_t rdev
)
416 p
= xdr_reserve_space(xdr
, 8);
417 *p
++ = cpu_to_be32(MAJOR(rdev
));
418 *p
= cpu_to_be32(MINOR(rdev
));
421 static __be32
*xdr_decode_specdata3(__be32
*p
, dev_t
*rdev
)
423 unsigned int major
, minor
;
425 major
= be32_to_cpup(p
++);
426 minor
= be32_to_cpup(p
++);
427 *rdev
= MKDEV(major
, minor
);
428 if (MAJOR(*rdev
) != major
|| MINOR(*rdev
) != minor
)
437 * opaque data<NFS3_FHSIZE>;
440 static void encode_nfs_fh3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
444 WARN_ON_ONCE(fh
->size
> NFS3_FHSIZE
);
445 p
= xdr_reserve_space(xdr
, 4 + fh
->size
);
446 xdr_encode_opaque(p
, fh
->data
, fh
->size
);
449 static int decode_nfs_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
454 p
= xdr_inline_decode(xdr
, 4);
455 if (unlikely(p
== NULL
))
457 length
= be32_to_cpup(p
++);
458 if (unlikely(length
> NFS3_FHSIZE
))
460 p
= xdr_inline_decode(xdr
, length
);
461 if (unlikely(p
== NULL
))
464 memcpy(fh
->data
, p
, length
);
467 dprintk("NFS: file handle size (%u) too big\n", length
);
470 print_overflow_msg(__func__
, xdr
);
474 static void zero_nfs_fh3(struct nfs_fh
*fh
)
476 memset(fh
, 0, sizeof(*fh
));
487 static __be32
*xdr_encode_nfstime3(__be32
*p
, const struct timespec
*timep
)
489 *p
++ = cpu_to_be32(timep
->tv_sec
);
490 *p
++ = cpu_to_be32(timep
->tv_nsec
);
494 static __be32
*xdr_decode_nfstime3(__be32
*p
, struct timespec
*timep
)
496 timep
->tv_sec
= be32_to_cpup(p
++);
497 timep
->tv_nsec
= be32_to_cpup(p
++);
506 * SET_TO_SERVER_TIME = 1,
507 * SET_TO_CLIENT_TIME = 2
510 * union set_mode3 switch (bool set_it) {
517 * union set_uid3 switch (bool set_it) {
524 * union set_gid3 switch (bool set_it) {
531 * union set_size3 switch (bool set_it) {
538 * union set_atime switch (time_how set_it) {
539 * case SET_TO_CLIENT_TIME:
545 * union set_mtime switch (time_how set_it) {
546 * case SET_TO_CLIENT_TIME:
561 static void encode_sattr3(struct xdr_stream
*xdr
, const struct iattr
*attr
)
567 * In order to make only a single xdr_reserve_space() call,
568 * pre-compute the total number of bytes to be reserved.
569 * Six boolean values, one for each set_foo field, are always
570 * present in the encoded result, so start there.
573 if (attr
->ia_valid
& ATTR_MODE
)
575 if (attr
->ia_valid
& ATTR_UID
)
577 if (attr
->ia_valid
& ATTR_GID
)
579 if (attr
->ia_valid
& ATTR_SIZE
)
581 if (attr
->ia_valid
& ATTR_ATIME_SET
)
583 if (attr
->ia_valid
& ATTR_MTIME_SET
)
585 p
= xdr_reserve_space(xdr
, nbytes
);
587 if (attr
->ia_valid
& ATTR_MODE
) {
589 *p
++ = cpu_to_be32(attr
->ia_mode
& S_IALLUGO
);
593 if (attr
->ia_valid
& ATTR_UID
) {
595 *p
++ = cpu_to_be32(from_kuid(&init_user_ns
, attr
->ia_uid
));
599 if (attr
->ia_valid
& ATTR_GID
) {
601 *p
++ = cpu_to_be32(from_kgid(&init_user_ns
, attr
->ia_gid
));
605 if (attr
->ia_valid
& ATTR_SIZE
) {
607 p
= xdr_encode_hyper(p
, (u64
)attr
->ia_size
);
611 if (attr
->ia_valid
& ATTR_ATIME_SET
) {
613 p
= xdr_encode_nfstime3(p
, &attr
->ia_atime
);
614 } else if (attr
->ia_valid
& ATTR_ATIME
) {
619 if (attr
->ia_valid
& ATTR_MTIME_SET
) {
621 xdr_encode_nfstime3(p
, &attr
->ia_mtime
);
622 } else if (attr
->ia_valid
& ATTR_MTIME
) {
647 static int decode_fattr3(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
652 p
= xdr_inline_decode(xdr
, NFS3_fattr_sz
<< 2);
653 if (unlikely(p
== NULL
))
656 p
= xdr_decode_ftype3(p
, &fmode
);
658 fattr
->mode
= (be32_to_cpup(p
++) & ~S_IFMT
) | fmode
;
659 fattr
->nlink
= be32_to_cpup(p
++);
660 fattr
->uid
= make_kuid(&init_user_ns
, be32_to_cpup(p
++));
661 if (!uid_valid(fattr
->uid
))
663 fattr
->gid
= make_kgid(&init_user_ns
, be32_to_cpup(p
++));
664 if (!gid_valid(fattr
->gid
))
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
);
678 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
680 fattr
->valid
|= NFS_ATTR_FATTR_V3
;
683 dprintk("NFS: returned invalid uid\n");
686 dprintk("NFS: returned invalid gid\n");
689 print_overflow_msg(__func__
, xdr
);
696 * union post_op_attr switch (bool attributes_follow) {
703 static int decode_post_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
707 p
= xdr_inline_decode(xdr
, 4);
708 if (unlikely(p
== NULL
))
711 return decode_fattr3(xdr
, fattr
);
714 print_overflow_msg(__func__
, xdr
);
726 static int decode_wcc_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
730 p
= xdr_inline_decode(xdr
, NFS3_wcc_attr_sz
<< 2);
731 if (unlikely(p
== NULL
))
734 fattr
->valid
|= NFS_ATTR_FATTR_PRESIZE
735 | NFS_ATTR_FATTR_PRECHANGE
736 | NFS_ATTR_FATTR_PREMTIME
737 | NFS_ATTR_FATTR_PRECTIME
;
739 p
= xdr_decode_size3(p
, &fattr
->pre_size
);
740 p
= xdr_decode_nfstime3(p
, &fattr
->pre_mtime
);
741 xdr_decode_nfstime3(p
, &fattr
->pre_ctime
);
742 fattr
->pre_change_attr
= nfs_timespec_to_change_attr(&fattr
->pre_ctime
);
746 print_overflow_msg(__func__
, xdr
);
752 * union pre_op_attr switch (bool attributes_follow) {
754 * wcc_attr attributes;
762 * pre_op_attr before;
763 * post_op_attr after;
766 static int decode_pre_op_attr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
770 p
= xdr_inline_decode(xdr
, 4);
771 if (unlikely(p
== NULL
))
774 return decode_wcc_attr(xdr
, fattr
);
777 print_overflow_msg(__func__
, xdr
);
781 static int decode_wcc_data(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
785 error
= decode_pre_op_attr(xdr
, fattr
);
788 error
= decode_post_op_attr(xdr
, fattr
);
796 * union post_op_fh3 switch (bool handle_follows) {
803 static int decode_post_op_fh3(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
805 __be32
*p
= xdr_inline_decode(xdr
, 4);
806 if (unlikely(p
== NULL
))
809 return decode_nfs_fh3(xdr
, fh
);
813 print_overflow_msg(__func__
, xdr
);
820 * struct diropargs3 {
825 static void encode_diropargs3(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
826 const char *name
, u32 length
)
828 encode_nfs_fh3(xdr
, fh
);
829 encode_filename3(xdr
, name
, length
);
834 * NFSv3 XDR encode functions
836 * NFSv3 argument types are defined in section 3.3 of RFC 1813:
837 * "NFS Version 3 Protocol Specification".
843 * struct GETATTR3args {
847 static void nfs3_xdr_enc_getattr3args(struct rpc_rqst
*req
,
848 struct xdr_stream
*xdr
,
851 const struct nfs_fh
*fh
= data
;
853 encode_nfs_fh3(xdr
, fh
);
859 * union sattrguard3 switch (bool check) {
861 * nfstime3 obj_ctime;
866 * struct SETATTR3args {
868 * sattr3 new_attributes;
872 static void encode_sattrguard3(struct xdr_stream
*xdr
,
873 const struct nfs3_sattrargs
*args
)
878 p
= xdr_reserve_space(xdr
, 4 + 8);
880 xdr_encode_nfstime3(p
, &args
->guardtime
);
882 p
= xdr_reserve_space(xdr
, 4);
887 static void nfs3_xdr_enc_setattr3args(struct rpc_rqst
*req
,
888 struct xdr_stream
*xdr
,
891 const struct nfs3_sattrargs
*args
= data
;
892 encode_nfs_fh3(xdr
, args
->fh
);
893 encode_sattr3(xdr
, args
->sattr
);
894 encode_sattrguard3(xdr
, args
);
900 * struct LOOKUP3args {
904 static void nfs3_xdr_enc_lookup3args(struct rpc_rqst
*req
,
905 struct xdr_stream
*xdr
,
908 const struct nfs3_diropargs
*args
= data
;
910 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
916 * struct ACCESS3args {
921 static void encode_access3args(struct xdr_stream
*xdr
,
922 const struct nfs3_accessargs
*args
)
924 encode_nfs_fh3(xdr
, args
->fh
);
925 encode_uint32(xdr
, args
->access
);
928 static void nfs3_xdr_enc_access3args(struct rpc_rqst
*req
,
929 struct xdr_stream
*xdr
,
932 const struct nfs3_accessargs
*args
= data
;
934 encode_access3args(xdr
, args
);
938 * 3.3.5 READLINK3args
940 * struct READLINK3args {
944 static void nfs3_xdr_enc_readlink3args(struct rpc_rqst
*req
,
945 struct xdr_stream
*xdr
,
948 const struct nfs3_readlinkargs
*args
= data
;
950 encode_nfs_fh3(xdr
, args
->fh
);
951 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
952 args
->pglen
, NFS3_readlinkres_sz
);
964 static void encode_read3args(struct xdr_stream
*xdr
,
965 const struct nfs_pgio_args
*args
)
969 encode_nfs_fh3(xdr
, args
->fh
);
971 p
= xdr_reserve_space(xdr
, 8 + 4);
972 p
= xdr_encode_hyper(p
, args
->offset
);
973 *p
= cpu_to_be32(args
->count
);
976 static void nfs3_xdr_enc_read3args(struct rpc_rqst
*req
,
977 struct xdr_stream
*xdr
,
980 const struct nfs_pgio_args
*args
= data
;
982 encode_read3args(xdr
, args
);
983 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
984 args
->count
, NFS3_readres_sz
);
985 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
997 * struct WRITE3args {
1001 * stable_how stable;
1005 static void encode_write3args(struct xdr_stream
*xdr
,
1006 const struct nfs_pgio_args
*args
)
1010 encode_nfs_fh3(xdr
, args
->fh
);
1012 p
= xdr_reserve_space(xdr
, 8 + 4 + 4 + 4);
1013 p
= xdr_encode_hyper(p
, args
->offset
);
1014 *p
++ = cpu_to_be32(args
->count
);
1015 *p
++ = cpu_to_be32(args
->stable
);
1016 *p
= cpu_to_be32(args
->count
);
1017 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, args
->count
);
1020 static void nfs3_xdr_enc_write3args(struct rpc_rqst
*req
,
1021 struct xdr_stream
*xdr
,
1024 const struct nfs_pgio_args
*args
= data
;
1026 encode_write3args(xdr
, args
);
1027 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1033 * enum createmode3 {
1039 * union createhow3 switch (createmode3 mode) {
1042 * sattr3 obj_attributes;
1047 * struct CREATE3args {
1052 static void encode_createhow3(struct xdr_stream
*xdr
,
1053 const struct nfs3_createargs
*args
)
1055 encode_uint32(xdr
, args
->createmode
);
1056 switch (args
->createmode
) {
1057 case NFS3_CREATE_UNCHECKED
:
1058 case NFS3_CREATE_GUARDED
:
1059 encode_sattr3(xdr
, args
->sattr
);
1061 case NFS3_CREATE_EXCLUSIVE
:
1062 encode_createverf3(xdr
, args
->verifier
);
1069 static void nfs3_xdr_enc_create3args(struct rpc_rqst
*req
,
1070 struct xdr_stream
*xdr
,
1073 const struct nfs3_createargs
*args
= data
;
1075 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1076 encode_createhow3(xdr
, args
);
1082 * struct MKDIR3args {
1084 * sattr3 attributes;
1087 static void nfs3_xdr_enc_mkdir3args(struct rpc_rqst
*req
,
1088 struct xdr_stream
*xdr
,
1091 const struct nfs3_mkdirargs
*args
= data
;
1093 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1094 encode_sattr3(xdr
, args
->sattr
);
1098 * 3.3.10 SYMLINK3args
1100 * struct symlinkdata3 {
1101 * sattr3 symlink_attributes;
1102 * nfspath3 symlink_data;
1105 * struct SYMLINK3args {
1107 * symlinkdata3 symlink;
1110 static void encode_symlinkdata3(struct xdr_stream
*xdr
,
1113 const struct nfs3_symlinkargs
*args
= data
;
1115 encode_sattr3(xdr
, args
->sattr
);
1116 encode_nfspath3(xdr
, args
->pages
, args
->pathlen
);
1119 static void nfs3_xdr_enc_symlink3args(struct rpc_rqst
*req
,
1120 struct xdr_stream
*xdr
,
1123 const struct nfs3_symlinkargs
*args
= data
;
1125 encode_diropargs3(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
1126 encode_symlinkdata3(xdr
, args
);
1127 xdr
->buf
->flags
|= XDRBUF_WRITE
;
1133 * struct devicedata3 {
1134 * sattr3 dev_attributes;
1138 * union mknoddata3 switch (ftype3 type) {
1141 * devicedata3 device;
1144 * sattr3 pipe_attributes;
1149 * struct MKNOD3args {
1154 static void encode_devicedata3(struct xdr_stream
*xdr
,
1155 const struct nfs3_mknodargs
*args
)
1157 encode_sattr3(xdr
, args
->sattr
);
1158 encode_specdata3(xdr
, args
->rdev
);
1161 static void encode_mknoddata3(struct xdr_stream
*xdr
,
1162 const struct nfs3_mknodargs
*args
)
1164 encode_ftype3(xdr
, args
->type
);
1165 switch (args
->type
) {
1168 encode_devicedata3(xdr
, args
);
1172 encode_sattr3(xdr
, args
->sattr
);
1182 static void nfs3_xdr_enc_mknod3args(struct rpc_rqst
*req
,
1183 struct xdr_stream
*xdr
,
1186 const struct nfs3_mknodargs
*args
= data
;
1188 encode_diropargs3(xdr
, args
->fh
, args
->name
, args
->len
);
1189 encode_mknoddata3(xdr
, args
);
1193 * 3.3.12 REMOVE3args
1195 * struct REMOVE3args {
1196 * diropargs3 object;
1199 static void nfs3_xdr_enc_remove3args(struct rpc_rqst
*req
,
1200 struct xdr_stream
*xdr
,
1203 const struct nfs_removeargs
*args
= data
;
1205 encode_diropargs3(xdr
, args
->fh
, args
->name
.name
, args
->name
.len
);
1209 * 3.3.14 RENAME3args
1211 * struct RENAME3args {
1216 static void nfs3_xdr_enc_rename3args(struct rpc_rqst
*req
,
1217 struct xdr_stream
*xdr
,
1220 const struct nfs_renameargs
*args
= data
;
1221 const struct qstr
*old
= args
->old_name
;
1222 const struct qstr
*new = args
->new_name
;
1224 encode_diropargs3(xdr
, args
->old_dir
, old
->name
, old
->len
);
1225 encode_diropargs3(xdr
, args
->new_dir
, new->name
, new->len
);
1231 * struct LINK3args {
1236 static void nfs3_xdr_enc_link3args(struct rpc_rqst
*req
,
1237 struct xdr_stream
*xdr
,
1240 const struct nfs3_linkargs
*args
= data
;
1242 encode_nfs_fh3(xdr
, args
->fromfh
);
1243 encode_diropargs3(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
1247 * 3.3.16 READDIR3args
1249 * struct READDIR3args {
1252 * cookieverf3 cookieverf;
1256 static void encode_readdir3args(struct xdr_stream
*xdr
,
1257 const struct nfs3_readdirargs
*args
)
1261 encode_nfs_fh3(xdr
, args
->fh
);
1263 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4);
1264 p
= xdr_encode_cookie3(p
, args
->cookie
);
1265 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1266 *p
= cpu_to_be32(args
->count
);
1269 static void nfs3_xdr_enc_readdir3args(struct rpc_rqst
*req
,
1270 struct xdr_stream
*xdr
,
1273 const struct nfs3_readdirargs
*args
= data
;
1275 encode_readdir3args(xdr
, args
);
1276 prepare_reply_buffer(req
, args
->pages
, 0,
1277 args
->count
, NFS3_readdirres_sz
);
1281 * 3.3.17 READDIRPLUS3args
1283 * struct READDIRPLUS3args {
1286 * cookieverf3 cookieverf;
1291 static void encode_readdirplus3args(struct xdr_stream
*xdr
,
1292 const struct nfs3_readdirargs
*args
)
1296 encode_nfs_fh3(xdr
, args
->fh
);
1298 p
= xdr_reserve_space(xdr
, 8 + NFS3_COOKIEVERFSIZE
+ 4 + 4);
1299 p
= xdr_encode_cookie3(p
, args
->cookie
);
1300 p
= xdr_encode_cookieverf3(p
, args
->verf
);
1303 * readdirplus: need dircount + buffer size.
1304 * We just make sure we make dircount big enough
1306 *p
++ = cpu_to_be32(args
->count
>> 3);
1308 *p
= cpu_to_be32(args
->count
);
1311 static void nfs3_xdr_enc_readdirplus3args(struct rpc_rqst
*req
,
1312 struct xdr_stream
*xdr
,
1315 const struct nfs3_readdirargs
*args
= data
;
1317 encode_readdirplus3args(xdr
, args
);
1318 prepare_reply_buffer(req
, args
->pages
, 0,
1319 args
->count
, NFS3_readdirres_sz
);
1323 * 3.3.21 COMMIT3args
1325 * struct COMMIT3args {
1331 static void encode_commit3args(struct xdr_stream
*xdr
,
1332 const struct nfs_commitargs
*args
)
1336 encode_nfs_fh3(xdr
, args
->fh
);
1338 p
= xdr_reserve_space(xdr
, 8 + 4);
1339 p
= xdr_encode_hyper(p
, args
->offset
);
1340 *p
= cpu_to_be32(args
->count
);
1343 static void nfs3_xdr_enc_commit3args(struct rpc_rqst
*req
,
1344 struct xdr_stream
*xdr
,
1347 const struct nfs_commitargs
*args
= data
;
1349 encode_commit3args(xdr
, args
);
1352 #ifdef CONFIG_NFS_V3_ACL
1354 static void nfs3_xdr_enc_getacl3args(struct rpc_rqst
*req
,
1355 struct xdr_stream
*xdr
,
1358 const struct nfs3_getaclargs
*args
= data
;
1360 encode_nfs_fh3(xdr
, args
->fh
);
1361 encode_uint32(xdr
, args
->mask
);
1362 if (args
->mask
& (NFS_ACL
| NFS_DFACL
))
1363 prepare_reply_buffer(req
, args
->pages
, 0,
1364 NFSACL_MAXPAGES
<< PAGE_SHIFT
,
1368 static void nfs3_xdr_enc_setacl3args(struct rpc_rqst
*req
,
1369 struct xdr_stream
*xdr
,
1372 const struct nfs3_setaclargs
*args
= data
;
1376 encode_nfs_fh3(xdr
, NFS_FH(args
->inode
));
1377 encode_uint32(xdr
, args
->mask
);
1379 base
= req
->rq_slen
;
1380 if (args
->npages
!= 0)
1381 xdr_write_pages(xdr
, args
->pages
, 0, args
->len
);
1383 xdr_reserve_space(xdr
, args
->len
);
1385 error
= nfsacl_encode(xdr
->buf
, base
, args
->inode
,
1386 (args
->mask
& NFS_ACL
) ?
1387 args
->acl_access
: NULL
, 1, 0);
1388 /* FIXME: this is just broken */
1390 error
= nfsacl_encode(xdr
->buf
, base
+ error
, args
->inode
,
1391 (args
->mask
& NFS_DFACL
) ?
1392 args
->acl_default
: NULL
, 1,
1397 #endif /* CONFIG_NFS_V3_ACL */
1400 * NFSv3 XDR decode functions
1402 * NFSv3 result types are defined in section 3.3 of RFC 1813:
1403 * "NFS Version 3 Protocol Specification".
1409 * struct GETATTR3resok {
1410 * fattr3 obj_attributes;
1413 * union GETATTR3res switch (nfsstat3 status) {
1415 * GETATTR3resok resok;
1420 static int nfs3_xdr_dec_getattr3res(struct rpc_rqst
*req
,
1421 struct xdr_stream
*xdr
,
1424 enum nfs_stat status
;
1427 error
= decode_nfsstat3(xdr
, &status
);
1428 if (unlikely(error
))
1430 if (status
!= NFS3_OK
)
1432 error
= decode_fattr3(xdr
, result
);
1436 return nfs3_stat_to_errno(status
);
1442 * struct SETATTR3resok {
1446 * struct SETATTR3resfail {
1450 * union SETATTR3res switch (nfsstat3 status) {
1452 * SETATTR3resok resok;
1454 * SETATTR3resfail resfail;
1457 static int nfs3_xdr_dec_setattr3res(struct rpc_rqst
*req
,
1458 struct xdr_stream
*xdr
,
1461 enum nfs_stat status
;
1464 error
= decode_nfsstat3(xdr
, &status
);
1465 if (unlikely(error
))
1467 error
= decode_wcc_data(xdr
, result
);
1468 if (unlikely(error
))
1470 if (status
!= NFS3_OK
)
1475 return nfs3_stat_to_errno(status
);
1481 * struct LOOKUP3resok {
1483 * post_op_attr obj_attributes;
1484 * post_op_attr dir_attributes;
1487 * struct LOOKUP3resfail {
1488 * post_op_attr dir_attributes;
1491 * union LOOKUP3res switch (nfsstat3 status) {
1493 * LOOKUP3resok resok;
1495 * LOOKUP3resfail resfail;
1498 static int nfs3_xdr_dec_lookup3res(struct rpc_rqst
*req
,
1499 struct xdr_stream
*xdr
,
1502 struct nfs3_diropres
*result
= data
;
1503 enum nfs_stat status
;
1506 error
= decode_nfsstat3(xdr
, &status
);
1507 if (unlikely(error
))
1509 if (status
!= NFS3_OK
)
1511 error
= decode_nfs_fh3(xdr
, result
->fh
);
1512 if (unlikely(error
))
1514 error
= decode_post_op_attr(xdr
, result
->fattr
);
1515 if (unlikely(error
))
1517 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1521 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
1522 if (unlikely(error
))
1524 return nfs3_stat_to_errno(status
);
1530 * struct ACCESS3resok {
1531 * post_op_attr obj_attributes;
1535 * struct ACCESS3resfail {
1536 * post_op_attr obj_attributes;
1539 * union ACCESS3res switch (nfsstat3 status) {
1541 * ACCESS3resok resok;
1543 * ACCESS3resfail resfail;
1546 static int nfs3_xdr_dec_access3res(struct rpc_rqst
*req
,
1547 struct xdr_stream
*xdr
,
1550 struct nfs3_accessres
*result
= data
;
1551 enum nfs_stat status
;
1554 error
= decode_nfsstat3(xdr
, &status
);
1555 if (unlikely(error
))
1557 error
= decode_post_op_attr(xdr
, result
->fattr
);
1558 if (unlikely(error
))
1560 if (status
!= NFS3_OK
)
1562 error
= decode_uint32(xdr
, &result
->access
);
1566 return nfs3_stat_to_errno(status
);
1570 * 3.3.5 READLINK3res
1572 * struct READLINK3resok {
1573 * post_op_attr symlink_attributes;
1577 * struct READLINK3resfail {
1578 * post_op_attr symlink_attributes;
1581 * union READLINK3res switch (nfsstat3 status) {
1583 * READLINK3resok resok;
1585 * READLINK3resfail resfail;
1588 static int nfs3_xdr_dec_readlink3res(struct rpc_rqst
*req
,
1589 struct xdr_stream
*xdr
,
1592 enum nfs_stat status
;
1595 error
= decode_nfsstat3(xdr
, &status
);
1596 if (unlikely(error
))
1598 error
= decode_post_op_attr(xdr
, result
);
1599 if (unlikely(error
))
1601 if (status
!= NFS3_OK
)
1603 error
= decode_nfspath3(xdr
);
1607 return nfs3_stat_to_errno(status
);
1613 * struct READ3resok {
1614 * post_op_attr file_attributes;
1620 * struct READ3resfail {
1621 * post_op_attr file_attributes;
1624 * union READ3res switch (nfsstat3 status) {
1628 * READ3resfail resfail;
1631 static int decode_read3resok(struct xdr_stream
*xdr
,
1632 struct nfs_pgio_res
*result
)
1634 u32 eof
, count
, ocount
, recvd
;
1637 p
= xdr_inline_decode(xdr
, 4 + 4 + 4);
1638 if (unlikely(p
== NULL
))
1640 count
= be32_to_cpup(p
++);
1641 eof
= be32_to_cpup(p
++);
1642 ocount
= be32_to_cpup(p
++);
1643 if (unlikely(ocount
!= count
))
1645 recvd
= xdr_read_pages(xdr
, count
);
1646 if (unlikely(count
> recvd
))
1650 result
->count
= count
;
1653 dprintk("NFS: READ count doesn't match length of opaque: "
1654 "count %u != ocount %u\n", count
, ocount
);
1657 dprintk("NFS: server cheating in read result: "
1658 "count %u > recvd %u\n", count
, recvd
);
1663 print_overflow_msg(__func__
, xdr
);
1667 static int nfs3_xdr_dec_read3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1670 struct nfs_pgio_res
*result
= data
;
1671 enum nfs_stat status
;
1674 error
= decode_nfsstat3(xdr
, &status
);
1675 if (unlikely(error
))
1677 error
= decode_post_op_attr(xdr
, result
->fattr
);
1678 if (unlikely(error
))
1680 result
->op_status
= status
;
1681 if (status
!= NFS3_OK
)
1683 error
= decode_read3resok(xdr
, result
);
1687 return nfs3_stat_to_errno(status
);
1699 * struct WRITE3resok {
1700 * wcc_data file_wcc;
1702 * stable_how committed;
1706 * struct WRITE3resfail {
1707 * wcc_data file_wcc;
1710 * union WRITE3res switch (nfsstat3 status) {
1712 * WRITE3resok resok;
1714 * WRITE3resfail resfail;
1717 static int decode_write3resok(struct xdr_stream
*xdr
,
1718 struct nfs_pgio_res
*result
)
1722 p
= xdr_inline_decode(xdr
, 4 + 4);
1723 if (unlikely(p
== NULL
))
1725 result
->count
= be32_to_cpup(p
++);
1726 result
->verf
->committed
= be32_to_cpup(p
++);
1727 if (unlikely(result
->verf
->committed
> NFS_FILE_SYNC
))
1729 if (decode_writeverf3(xdr
, &result
->verf
->verifier
))
1731 return result
->count
;
1733 dprintk("NFS: bad stable_how value: %u\n", result
->verf
->committed
);
1736 print_overflow_msg(__func__
, xdr
);
1741 static int nfs3_xdr_dec_write3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1744 struct nfs_pgio_res
*result
= data
;
1745 enum nfs_stat status
;
1748 error
= decode_nfsstat3(xdr
, &status
);
1749 if (unlikely(error
))
1751 error
= decode_wcc_data(xdr
, result
->fattr
);
1752 if (unlikely(error
))
1754 result
->op_status
= status
;
1755 if (status
!= NFS3_OK
)
1757 error
= decode_write3resok(xdr
, result
);
1761 return nfs3_stat_to_errno(status
);
1767 * struct CREATE3resok {
1769 * post_op_attr obj_attributes;
1773 * struct CREATE3resfail {
1777 * union CREATE3res switch (nfsstat3 status) {
1779 * CREATE3resok resok;
1781 * CREATE3resfail resfail;
1784 static int decode_create3resok(struct xdr_stream
*xdr
,
1785 struct nfs3_diropres
*result
)
1789 error
= decode_post_op_fh3(xdr
, result
->fh
);
1790 if (unlikely(error
))
1792 error
= decode_post_op_attr(xdr
, result
->fattr
);
1793 if (unlikely(error
))
1795 /* The server isn't required to return a file handle.
1796 * If it didn't, force the client to perform a LOOKUP
1797 * to determine the correct file handle and attribute
1798 * values for the new object. */
1799 if (result
->fh
->size
== 0)
1800 result
->fattr
->valid
= 0;
1801 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1806 static int nfs3_xdr_dec_create3res(struct rpc_rqst
*req
,
1807 struct xdr_stream
*xdr
,
1810 struct nfs3_diropres
*result
= data
;
1811 enum nfs_stat status
;
1814 error
= decode_nfsstat3(xdr
, &status
);
1815 if (unlikely(error
))
1817 if (status
!= NFS3_OK
)
1819 error
= decode_create3resok(xdr
, result
);
1823 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1824 if (unlikely(error
))
1826 return nfs3_stat_to_errno(status
);
1832 * struct REMOVE3resok {
1836 * struct REMOVE3resfail {
1840 * union REMOVE3res switch (nfsstat3 status) {
1842 * REMOVE3resok resok;
1844 * REMOVE3resfail resfail;
1847 static int nfs3_xdr_dec_remove3res(struct rpc_rqst
*req
,
1848 struct xdr_stream
*xdr
,
1851 struct nfs_removeres
*result
= data
;
1852 enum nfs_stat status
;
1855 error
= decode_nfsstat3(xdr
, &status
);
1856 if (unlikely(error
))
1858 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1859 if (unlikely(error
))
1861 if (status
!= NFS3_OK
)
1866 return nfs3_stat_to_errno(status
);
1872 * struct RENAME3resok {
1873 * wcc_data fromdir_wcc;
1874 * wcc_data todir_wcc;
1877 * struct RENAME3resfail {
1878 * wcc_data fromdir_wcc;
1879 * wcc_data todir_wcc;
1882 * union RENAME3res switch (nfsstat3 status) {
1884 * RENAME3resok resok;
1886 * RENAME3resfail resfail;
1889 static int nfs3_xdr_dec_rename3res(struct rpc_rqst
*req
,
1890 struct xdr_stream
*xdr
,
1893 struct nfs_renameres
*result
= data
;
1894 enum nfs_stat status
;
1897 error
= decode_nfsstat3(xdr
, &status
);
1898 if (unlikely(error
))
1900 error
= decode_wcc_data(xdr
, result
->old_fattr
);
1901 if (unlikely(error
))
1903 error
= decode_wcc_data(xdr
, result
->new_fattr
);
1904 if (unlikely(error
))
1906 if (status
!= NFS3_OK
)
1911 return nfs3_stat_to_errno(status
);
1917 * struct LINK3resok {
1918 * post_op_attr file_attributes;
1919 * wcc_data linkdir_wcc;
1922 * struct LINK3resfail {
1923 * post_op_attr file_attributes;
1924 * wcc_data linkdir_wcc;
1927 * union LINK3res switch (nfsstat3 status) {
1931 * LINK3resfail resfail;
1934 static int nfs3_xdr_dec_link3res(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1937 struct nfs3_linkres
*result
= data
;
1938 enum nfs_stat status
;
1941 error
= decode_nfsstat3(xdr
, &status
);
1942 if (unlikely(error
))
1944 error
= decode_post_op_attr(xdr
, result
->fattr
);
1945 if (unlikely(error
))
1947 error
= decode_wcc_data(xdr
, result
->dir_attr
);
1948 if (unlikely(error
))
1950 if (status
!= NFS3_OK
)
1955 return nfs3_stat_to_errno(status
);
1959 * nfs3_decode_dirent - Decode a single NFSv3 directory entry stored in
1960 * the local page cache
1961 * @xdr: XDR stream where entry resides
1962 * @entry: buffer to fill in with entry data
1963 * @plus: boolean indicating whether this should be a readdirplus entry
1965 * Returns zero if successful, otherwise a negative errno value is
1968 * This function is not invoked during READDIR reply decoding, but
1969 * rather whenever an application invokes the getdents(2) system call
1970 * on a directory already in our cache.
1978 * fhandle3 filehandle;
1979 * post_op_attr3 attributes;
1980 * entry3 *nextentry;
1984 * struct entryplus3 {
1988 * post_op_attr name_attributes;
1989 * post_op_fh3 name_handle;
1990 * entryplus3 *nextentry;
1993 int nfs3_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
1996 struct nfs_entry old
= *entry
;
2000 p
= xdr_inline_decode(xdr
, 4);
2001 if (unlikely(p
== NULL
))
2003 if (*p
== xdr_zero
) {
2004 p
= xdr_inline_decode(xdr
, 4);
2005 if (unlikely(p
== NULL
))
2013 error
= decode_fileid3(xdr
, &entry
->ino
);
2014 if (unlikely(error
))
2017 error
= decode_inline_filename3(xdr
, &entry
->name
, &entry
->len
);
2018 if (unlikely(error
))
2021 entry
->prev_cookie
= entry
->cookie
;
2022 error
= decode_cookie3(xdr
, &entry
->cookie
);
2023 if (unlikely(error
))
2026 entry
->d_type
= DT_UNKNOWN
;
2029 entry
->fattr
->valid
= 0;
2030 error
= decode_post_op_attr(xdr
, entry
->fattr
);
2031 if (unlikely(error
))
2033 if (entry
->fattr
->valid
& NFS_ATTR_FATTR_V3
)
2034 entry
->d_type
= nfs_umode_to_dtype(entry
->fattr
->mode
);
2036 if (entry
->fattr
->fileid
!= entry
->ino
) {
2037 entry
->fattr
->mounted_on_fileid
= entry
->ino
;
2038 entry
->fattr
->valid
|= NFS_ATTR_FATTR_MOUNTED_ON_FILEID
;
2041 /* In fact, a post_op_fh3: */
2042 p
= xdr_inline_decode(xdr
, 4);
2043 if (unlikely(p
== NULL
))
2045 if (*p
!= xdr_zero
) {
2046 error
= decode_nfs_fh3(xdr
, entry
->fh
);
2047 if (unlikely(error
)) {
2048 if (error
== -E2BIG
)
2053 zero_nfs_fh3(entry
->fh
);
2059 print_overflow_msg(__func__
, xdr
);
2062 dprintk("NFS: directory entry contains invalid file handle\n");
2068 * 3.3.16 READDIR3res
2075 * struct READDIR3resok {
2076 * post_op_attr dir_attributes;
2077 * cookieverf3 cookieverf;
2081 * struct READDIR3resfail {
2082 * post_op_attr dir_attributes;
2085 * union READDIR3res switch (nfsstat3 status) {
2087 * READDIR3resok resok;
2089 * READDIR3resfail resfail;
2092 * Read the directory contents into the page cache, but otherwise
2093 * don't touch them. The actual decoding is done by nfs3_decode_entry()
2094 * during subsequent nfs_readdir() calls.
2096 static int decode_dirlist3(struct xdr_stream
*xdr
)
2098 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
2101 static int decode_readdir3resok(struct xdr_stream
*xdr
,
2102 struct nfs3_readdirres
*result
)
2106 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2107 if (unlikely(error
))
2109 /* XXX: do we need to check if result->verf != NULL ? */
2110 error
= decode_cookieverf3(xdr
, result
->verf
);
2111 if (unlikely(error
))
2113 error
= decode_dirlist3(xdr
);
2118 static int nfs3_xdr_dec_readdir3res(struct rpc_rqst
*req
,
2119 struct xdr_stream
*xdr
,
2122 struct nfs3_readdirres
*result
= data
;
2123 enum nfs_stat status
;
2126 error
= decode_nfsstat3(xdr
, &status
);
2127 if (unlikely(error
))
2129 if (status
!= NFS3_OK
)
2131 error
= decode_readdir3resok(xdr
, result
);
2135 error
= decode_post_op_attr(xdr
, result
->dir_attr
);
2136 if (unlikely(error
))
2138 return nfs3_stat_to_errno(status
);
2144 * struct FSSTAT3resok {
2145 * post_op_attr obj_attributes;
2155 * struct FSSTAT3resfail {
2156 * post_op_attr obj_attributes;
2159 * union FSSTAT3res switch (nfsstat3 status) {
2161 * FSSTAT3resok resok;
2163 * FSSTAT3resfail resfail;
2166 static int decode_fsstat3resok(struct xdr_stream
*xdr
,
2167 struct nfs_fsstat
*result
)
2171 p
= xdr_inline_decode(xdr
, 8 * 6 + 4);
2172 if (unlikely(p
== NULL
))
2174 p
= xdr_decode_size3(p
, &result
->tbytes
);
2175 p
= xdr_decode_size3(p
, &result
->fbytes
);
2176 p
= xdr_decode_size3(p
, &result
->abytes
);
2177 p
= xdr_decode_size3(p
, &result
->tfiles
);
2178 p
= xdr_decode_size3(p
, &result
->ffiles
);
2179 xdr_decode_size3(p
, &result
->afiles
);
2180 /* ignore invarsec */
2183 print_overflow_msg(__func__
, xdr
);
2187 static int nfs3_xdr_dec_fsstat3res(struct rpc_rqst
*req
,
2188 struct xdr_stream
*xdr
,
2191 struct nfs_fsstat
*result
= data
;
2192 enum nfs_stat status
;
2195 error
= decode_nfsstat3(xdr
, &status
);
2196 if (unlikely(error
))
2198 error
= decode_post_op_attr(xdr
, result
->fattr
);
2199 if (unlikely(error
))
2201 if (status
!= NFS3_OK
)
2203 error
= decode_fsstat3resok(xdr
, result
);
2207 return nfs3_stat_to_errno(status
);
2213 * struct FSINFO3resok {
2214 * post_op_attr obj_attributes;
2222 * size3 maxfilesize;
2223 * nfstime3 time_delta;
2224 * uint32 properties;
2227 * struct FSINFO3resfail {
2228 * post_op_attr obj_attributes;
2231 * union FSINFO3res switch (nfsstat3 status) {
2233 * FSINFO3resok resok;
2235 * FSINFO3resfail resfail;
2238 static int decode_fsinfo3resok(struct xdr_stream
*xdr
,
2239 struct nfs_fsinfo
*result
)
2243 p
= xdr_inline_decode(xdr
, 4 * 7 + 8 + 8 + 4);
2244 if (unlikely(p
== NULL
))
2246 result
->rtmax
= be32_to_cpup(p
++);
2247 result
->rtpref
= be32_to_cpup(p
++);
2248 result
->rtmult
= be32_to_cpup(p
++);
2249 result
->wtmax
= be32_to_cpup(p
++);
2250 result
->wtpref
= be32_to_cpup(p
++);
2251 result
->wtmult
= be32_to_cpup(p
++);
2252 result
->dtpref
= be32_to_cpup(p
++);
2253 p
= xdr_decode_size3(p
, &result
->maxfilesize
);
2254 xdr_decode_nfstime3(p
, &result
->time_delta
);
2256 /* ignore properties */
2257 result
->lease_time
= 0;
2260 print_overflow_msg(__func__
, xdr
);
2264 static int nfs3_xdr_dec_fsinfo3res(struct rpc_rqst
*req
,
2265 struct xdr_stream
*xdr
,
2268 struct nfs_fsinfo
*result
= data
;
2269 enum nfs_stat status
;
2272 error
= decode_nfsstat3(xdr
, &status
);
2273 if (unlikely(error
))
2275 error
= decode_post_op_attr(xdr
, result
->fattr
);
2276 if (unlikely(error
))
2278 if (status
!= NFS3_OK
)
2280 error
= decode_fsinfo3resok(xdr
, result
);
2284 return nfs3_stat_to_errno(status
);
2288 * 3.3.20 PATHCONF3res
2290 * struct PATHCONF3resok {
2291 * post_op_attr obj_attributes;
2295 * bool chown_restricted;
2296 * bool case_insensitive;
2297 * bool case_preserving;
2300 * struct PATHCONF3resfail {
2301 * post_op_attr obj_attributes;
2304 * union PATHCONF3res switch (nfsstat3 status) {
2306 * PATHCONF3resok resok;
2308 * PATHCONF3resfail resfail;
2311 static int decode_pathconf3resok(struct xdr_stream
*xdr
,
2312 struct nfs_pathconf
*result
)
2316 p
= xdr_inline_decode(xdr
, 4 * 6);
2317 if (unlikely(p
== NULL
))
2319 result
->max_link
= be32_to_cpup(p
++);
2320 result
->max_namelen
= be32_to_cpup(p
);
2321 /* ignore remaining fields */
2324 print_overflow_msg(__func__
, xdr
);
2328 static int nfs3_xdr_dec_pathconf3res(struct rpc_rqst
*req
,
2329 struct xdr_stream
*xdr
,
2332 struct nfs_pathconf
*result
= data
;
2333 enum nfs_stat status
;
2336 error
= decode_nfsstat3(xdr
, &status
);
2337 if (unlikely(error
))
2339 error
= decode_post_op_attr(xdr
, result
->fattr
);
2340 if (unlikely(error
))
2342 if (status
!= NFS3_OK
)
2344 error
= decode_pathconf3resok(xdr
, result
);
2348 return nfs3_stat_to_errno(status
);
2354 * struct COMMIT3resok {
2355 * wcc_data file_wcc;
2359 * struct COMMIT3resfail {
2360 * wcc_data file_wcc;
2363 * union COMMIT3res switch (nfsstat3 status) {
2365 * COMMIT3resok resok;
2367 * COMMIT3resfail resfail;
2370 static int nfs3_xdr_dec_commit3res(struct rpc_rqst
*req
,
2371 struct xdr_stream
*xdr
,
2374 struct nfs_commitres
*result
= data
;
2375 enum nfs_stat status
;
2378 error
= decode_nfsstat3(xdr
, &status
);
2379 if (unlikely(error
))
2381 error
= decode_wcc_data(xdr
, result
->fattr
);
2382 if (unlikely(error
))
2384 result
->op_status
= status
;
2385 if (status
!= NFS3_OK
)
2387 error
= decode_writeverf3(xdr
, &result
->verf
->verifier
);
2391 return nfs3_stat_to_errno(status
);
2394 #ifdef CONFIG_NFS_V3_ACL
2396 static inline int decode_getacl3resok(struct xdr_stream
*xdr
,
2397 struct nfs3_getaclres
*result
)
2399 struct posix_acl
**acl
;
2400 unsigned int *aclcnt
;
2404 error
= decode_post_op_attr(xdr
, result
->fattr
);
2405 if (unlikely(error
))
2407 error
= decode_uint32(xdr
, &result
->mask
);
2408 if (unlikely(error
))
2411 if (result
->mask
& ~(NFS_ACL
|NFS_ACLCNT
|NFS_DFACL
|NFS_DFACLCNT
))
2414 hdrlen
= xdr_stream_pos(xdr
);
2417 if (result
->mask
& NFS_ACL
)
2418 acl
= &result
->acl_access
;
2420 if (result
->mask
& NFS_ACLCNT
)
2421 aclcnt
= &result
->acl_access_count
;
2422 error
= nfsacl_decode(xdr
->buf
, hdrlen
, aclcnt
, acl
);
2423 if (unlikely(error
<= 0))
2427 if (result
->mask
& NFS_DFACL
)
2428 acl
= &result
->acl_default
;
2430 if (result
->mask
& NFS_DFACLCNT
)
2431 aclcnt
= &result
->acl_default_count
;
2432 error
= nfsacl_decode(xdr
->buf
, hdrlen
+ error
, aclcnt
, acl
);
2433 if (unlikely(error
<= 0))
2440 static int nfs3_xdr_dec_getacl3res(struct rpc_rqst
*req
,
2441 struct xdr_stream
*xdr
,
2444 enum nfs_stat status
;
2447 error
= decode_nfsstat3(xdr
, &status
);
2448 if (unlikely(error
))
2450 if (status
!= NFS3_OK
)
2452 error
= decode_getacl3resok(xdr
, result
);
2456 return nfs3_stat_to_errno(status
);
2459 static int nfs3_xdr_dec_setacl3res(struct rpc_rqst
*req
,
2460 struct xdr_stream
*xdr
,
2463 enum nfs_stat status
;
2466 error
= decode_nfsstat3(xdr
, &status
);
2467 if (unlikely(error
))
2469 if (status
!= NFS3_OK
)
2471 error
= decode_post_op_attr(xdr
, result
);
2475 return nfs3_stat_to_errno(status
);
2478 #endif /* CONFIG_NFS_V3_ACL */
2482 * We need to translate between nfs status return values and
2483 * the local errno values which may not be the same.
2485 static const struct {
2490 { NFSERR_PERM
, -EPERM
},
2491 { NFSERR_NOENT
, -ENOENT
},
2492 { NFSERR_IO
, -errno_NFSERR_IO
},
2493 { NFSERR_NXIO
, -ENXIO
},
2494 /* { NFSERR_EAGAIN, -EAGAIN }, */
2495 { NFSERR_ACCES
, -EACCES
},
2496 { NFSERR_EXIST
, -EEXIST
},
2497 { NFSERR_XDEV
, -EXDEV
},
2498 { NFSERR_NODEV
, -ENODEV
},
2499 { NFSERR_NOTDIR
, -ENOTDIR
},
2500 { NFSERR_ISDIR
, -EISDIR
},
2501 { NFSERR_INVAL
, -EINVAL
},
2502 { NFSERR_FBIG
, -EFBIG
},
2503 { NFSERR_NOSPC
, -ENOSPC
},
2504 { NFSERR_ROFS
, -EROFS
},
2505 { NFSERR_MLINK
, -EMLINK
},
2506 { NFSERR_NAMETOOLONG
, -ENAMETOOLONG
},
2507 { NFSERR_NOTEMPTY
, -ENOTEMPTY
},
2508 { NFSERR_DQUOT
, -EDQUOT
},
2509 { NFSERR_STALE
, -ESTALE
},
2510 { NFSERR_REMOTE
, -EREMOTE
},
2512 { NFSERR_WFLUSH
, -EWFLUSH
},
2514 { NFSERR_BADHANDLE
, -EBADHANDLE
},
2515 { NFSERR_NOT_SYNC
, -ENOTSYNC
},
2516 { NFSERR_BAD_COOKIE
, -EBADCOOKIE
},
2517 { NFSERR_NOTSUPP
, -ENOTSUPP
},
2518 { NFSERR_TOOSMALL
, -ETOOSMALL
},
2519 { NFSERR_SERVERFAULT
, -EREMOTEIO
},
2520 { NFSERR_BADTYPE
, -EBADTYPE
},
2521 { NFSERR_JUKEBOX
, -EJUKEBOX
},
2526 * nfs3_stat_to_errno - convert an NFS status code to a local errno
2527 * @status: NFS status code to convert
2529 * Returns a local errno value, or -EIO if the NFS status code is
2530 * not recognized. This function is used jointly by NFSv2 and NFSv3.
2532 static int nfs3_stat_to_errno(enum nfs_stat status
)
2536 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
2537 if (nfs_errtbl
[i
].stat
== (int)status
)
2538 return nfs_errtbl
[i
].errno
;
2540 dprintk("NFS: Unrecognized nfs status value: %u\n", status
);
2541 return nfs_errtbl
[i
].errno
;
2545 #define PROC(proc, argtype, restype, timer) \
2546 [NFS3PROC_##proc] = { \
2547 .p_proc = NFS3PROC_##proc, \
2548 .p_encode = nfs3_xdr_enc_##argtype##3args, \
2549 .p_decode = nfs3_xdr_dec_##restype##3res, \
2550 .p_arglen = NFS3_##argtype##args_sz, \
2551 .p_replen = NFS3_##restype##res_sz, \
2553 .p_statidx = NFS3PROC_##proc, \
2557 const struct rpc_procinfo nfs3_procedures
[] = {
2558 PROC(GETATTR
, getattr
, getattr
, 1),
2559 PROC(SETATTR
, setattr
, setattr
, 0),
2560 PROC(LOOKUP
, lookup
, lookup
, 2),
2561 PROC(ACCESS
, access
, access
, 1),
2562 PROC(READLINK
, readlink
, readlink
, 3),
2563 PROC(READ
, read
, read
, 3),
2564 PROC(WRITE
, write
, write
, 4),
2565 PROC(CREATE
, create
, create
, 0),
2566 PROC(MKDIR
, mkdir
, create
, 0),
2567 PROC(SYMLINK
, symlink
, create
, 0),
2568 PROC(MKNOD
, mknod
, create
, 0),
2569 PROC(REMOVE
, remove
, remove
, 0),
2570 PROC(RMDIR
, lookup
, setattr
, 0),
2571 PROC(RENAME
, rename
, rename
, 0),
2572 PROC(LINK
, link
, link
, 0),
2573 PROC(READDIR
, readdir
, readdir
, 3),
2574 PROC(READDIRPLUS
, readdirplus
, readdir
, 3),
2575 PROC(FSSTAT
, getattr
, fsstat
, 0),
2576 PROC(FSINFO
, getattr
, fsinfo
, 0),
2577 PROC(PATHCONF
, getattr
, pathconf
, 0),
2578 PROC(COMMIT
, commit
, commit
, 5),
2581 static unsigned int nfs_version3_counts
[ARRAY_SIZE(nfs3_procedures
)];
2582 const struct rpc_version nfs_version3
= {
2584 .nrprocs
= ARRAY_SIZE(nfs3_procedures
),
2585 .procs
= nfs3_procedures
,
2586 .counts
= nfs_version3_counts
,
2589 #ifdef CONFIG_NFS_V3_ACL
2590 static const struct rpc_procinfo nfs3_acl_procedures
[] = {
2591 [ACLPROC3_GETACL
] = {
2592 .p_proc
= ACLPROC3_GETACL
,
2593 .p_encode
= nfs3_xdr_enc_getacl3args
,
2594 .p_decode
= nfs3_xdr_dec_getacl3res
,
2595 .p_arglen
= ACL3_getaclargs_sz
,
2596 .p_replen
= ACL3_getaclres_sz
,
2600 [ACLPROC3_SETACL
] = {
2601 .p_proc
= ACLPROC3_SETACL
,
2602 .p_encode
= nfs3_xdr_enc_setacl3args
,
2603 .p_decode
= nfs3_xdr_dec_setacl3res
,
2604 .p_arglen
= ACL3_setaclargs_sz
,
2605 .p_replen
= ACL3_setaclres_sz
,
2611 static unsigned int nfs3_acl_counts
[ARRAY_SIZE(nfs3_acl_procedures
)];
2612 const struct rpc_version nfsacl_version3
= {
2614 .nrprocs
= ARRAY_SIZE(nfs3_acl_procedures
),
2615 .procs
= nfs3_acl_procedures
,
2616 .counts
= nfs3_acl_counts
,
2618 #endif /* CONFIG_NFS_V3_ACL */