2 * linux/fs/nfs/nfs2xdr.c
4 * XDR functions to encode/decode NFS RPC arguments and results.
6 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
7 * Copyright (C) 1996 Olaf Kirch
8 * 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu>
9 * FIFO's need special handling in NFSv2
12 #include <linux/param.h>
13 #include <linux/time.h>
15 #include <linux/errno.h>
16 #include <linux/string.h>
18 #include <linux/pagemap.h>
19 #include <linux/proc_fs.h>
20 #include <linux/sunrpc/clnt.h>
21 #include <linux/nfs.h>
22 #include <linux/nfs2.h>
23 #include <linux/nfs_fs.h>
26 #define NFSDBG_FACILITY NFSDBG_XDR
28 /* Mapping from NFS error code to "errno" error code. */
29 #define errno_NFSERR_IO EIO
32 * Declare the space requirements for NFS arguments and replies as
33 * number of 32bit-words
35 #define NFS_fhandle_sz (8)
36 #define NFS_sattr_sz (8)
37 #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2))
38 #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2))
39 #define NFS_fattr_sz (17)
40 #define NFS_info_sz (5)
41 #define NFS_entry_sz (NFS_filename_sz+3)
43 #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz)
44 #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz)
45 #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz)
46 #define NFS_readlinkargs_sz (NFS_fhandle_sz)
47 #define NFS_readargs_sz (NFS_fhandle_sz+3)
48 #define NFS_writeargs_sz (NFS_fhandle_sz+4)
49 #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz)
50 #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz)
51 #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz)
52 #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz)
53 #define NFS_readdirargs_sz (NFS_fhandle_sz+2)
55 #define NFS_attrstat_sz (1+NFS_fattr_sz)
56 #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz)
57 #define NFS_readlinkres_sz (2)
58 #define NFS_readres_sz (1+NFS_fattr_sz+1)
59 #define NFS_writeres_sz (NFS_attrstat_sz)
60 #define NFS_stat_sz (1)
61 #define NFS_readdirres_sz (1)
62 #define NFS_statfsres_sz (1+NFS_info_sz)
64 static int nfs_stat_to_errno(enum nfs_stat
);
67 * While encoding arguments, set up the reply buffer in advance to
68 * receive reply data directly into the page cache.
70 static void prepare_reply_buffer(struct rpc_rqst
*req
, struct page
**pages
,
71 unsigned int base
, unsigned int len
,
74 struct rpc_auth
*auth
= req
->rq_cred
->cr_auth
;
77 replen
= RPC_REPHDRSIZE
+ auth
->au_rslack
+ bufsize
;
78 xdr_inline_pages(&req
->rq_rcv_buf
, replen
<< 2, pages
, base
, len
);
82 * Handle decode buffer overflows out-of-line.
84 static void print_overflow_msg(const char *func
, const struct xdr_stream
*xdr
)
86 dprintk("NFS: %s prematurely hit the end of our receive buffer. "
87 "Remaining buffer length is %tu words.\n",
88 func
, xdr
->end
- xdr
->p
);
93 * Encode/decode NFSv2 basic data types
95 * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
96 * "NFS: Network File System Protocol Specification".
98 * Not all basic data types have their own encoding and decoding
99 * functions. For run-time efficiency, some data types are encoded
104 * typedef opaque nfsdata<>;
106 static int decode_nfsdata(struct xdr_stream
*xdr
, struct nfs_readres
*result
)
111 p
= xdr_inline_decode(xdr
, 4);
112 if (unlikely(p
== NULL
))
114 count
= be32_to_cpup(p
);
115 recvd
= xdr_read_pages(xdr
, count
);
116 if (unlikely(count
> recvd
))
119 result
->eof
= 0; /* NFSv2 does not pass EOF flag on the wire. */
120 result
->count
= count
;
123 dprintk("NFS: server cheating in read result: "
124 "count %u > recvd %u\n", count
, recvd
);
128 print_overflow_msg(__func__
, xdr
);
142 * NFSERR_NOTDIR = 20,
147 * NFSERR_NAMETOOLONG = 63,
148 * NFSERR_NOTEMPTY = 66,
154 static int decode_stat(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
158 p
= xdr_inline_decode(xdr
, 4);
159 if (unlikely(p
== NULL
))
161 *status
= be32_to_cpup(p
);
164 print_overflow_msg(__func__
, xdr
);
181 static __be32
*xdr_decode_ftype(__be32
*p
, u32
*type
)
183 *type
= be32_to_cpup(p
++);
184 if (unlikely(*type
> NF2FIFO
))
192 * typedef opaque fhandle[FHSIZE];
194 static void encode_fhandle(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
198 BUG_ON(fh
->size
!= NFS2_FHSIZE
);
199 p
= xdr_reserve_space(xdr
, NFS2_FHSIZE
);
200 memcpy(p
, fh
->data
, NFS2_FHSIZE
);
203 static int decode_fhandle(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
207 p
= xdr_inline_decode(xdr
, NFS2_FHSIZE
);
208 if (unlikely(p
== NULL
))
210 fh
->size
= NFS2_FHSIZE
;
211 memcpy(fh
->data
, p
, NFS2_FHSIZE
);
214 print_overflow_msg(__func__
, xdr
);
222 * unsigned int seconds;
223 * unsigned int useconds;
226 static __be32
*xdr_encode_time(__be32
*p
, const struct timespec
*timep
)
228 *p
++ = cpu_to_be32(timep
->tv_sec
);
229 if (timep
->tv_nsec
!= 0)
230 *p
++ = cpu_to_be32(timep
->tv_nsec
/ NSEC_PER_USEC
);
232 *p
++ = cpu_to_be32(0);
237 * Passing the invalid value useconds=1000000 is a Sun convention for
238 * "set to current server time". It's needed to make permissions checks
239 * for the "touch" program across v2 mounts to Solaris and Irix servers
240 * work correctly. See description of sattr in section 6.1 of "NFS
241 * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5.
243 static __be32
*xdr_encode_current_server_time(__be32
*p
,
244 const struct timespec
*timep
)
246 *p
++ = cpu_to_be32(timep
->tv_sec
);
247 *p
++ = cpu_to_be32(1000000);
251 static __be32
*xdr_decode_time(__be32
*p
, struct timespec
*timep
)
253 timep
->tv_sec
= be32_to_cpup(p
++);
254 timep
->tv_nsec
= be32_to_cpup(p
++) * NSEC_PER_USEC
;
264 * unsigned int nlink;
268 * unsigned int blocksize;
270 * unsigned int blocks;
272 * unsigned int fileid;
279 static int decode_fattr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
)
284 p
= xdr_inline_decode(xdr
, NFS_fattr_sz
<< 2);
285 if (unlikely(p
== NULL
))
288 fattr
->valid
|= NFS_ATTR_FATTR_V2
;
290 p
= xdr_decode_ftype(p
, &type
);
292 fattr
->mode
= be32_to_cpup(p
++);
293 fattr
->nlink
= be32_to_cpup(p
++);
294 fattr
->uid
= be32_to_cpup(p
++);
295 fattr
->gid
= be32_to_cpup(p
++);
296 fattr
->size
= be32_to_cpup(p
++);
297 fattr
->du
.nfs2
.blocksize
= be32_to_cpup(p
++);
299 rdev
= be32_to_cpup(p
++);
300 fattr
->rdev
= new_decode_dev(rdev
);
301 if (type
== (u32
)NFCHR
&& rdev
== (u32
)NFS2_FIFO_DEV
) {
302 fattr
->mode
= (fattr
->mode
& ~S_IFMT
) | S_IFIFO
;
306 fattr
->du
.nfs2
.blocks
= be32_to_cpup(p
++);
307 fattr
->fsid
.major
= be32_to_cpup(p
++);
308 fattr
->fsid
.minor
= 0;
309 fattr
->fileid
= be32_to_cpup(p
++);
311 p
= xdr_decode_time(p
, &fattr
->atime
);
312 p
= xdr_decode_time(p
, &fattr
->mtime
);
313 xdr_decode_time(p
, &fattr
->ctime
);
314 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
318 print_overflow_msg(__func__
, xdr
);
335 #define NFS2_SATTR_NOT_SET (0xffffffff)
337 static __be32
*xdr_time_not_set(__be32
*p
)
339 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
340 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
344 static void encode_sattr(struct xdr_stream
*xdr
, const struct iattr
*attr
)
348 p
= xdr_reserve_space(xdr
, NFS_sattr_sz
<< 2);
350 if (attr
->ia_valid
& ATTR_MODE
)
351 *p
++ = cpu_to_be32(attr
->ia_mode
);
353 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
354 if (attr
->ia_valid
& ATTR_UID
)
355 *p
++ = cpu_to_be32(attr
->ia_uid
);
357 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
358 if (attr
->ia_valid
& ATTR_GID
)
359 *p
++ = cpu_to_be32(attr
->ia_gid
);
361 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
362 if (attr
->ia_valid
& ATTR_SIZE
)
363 *p
++ = cpu_to_be32((u32
)attr
->ia_size
);
365 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
367 if (attr
->ia_valid
& ATTR_ATIME_SET
)
368 p
= xdr_encode_time(p
, &attr
->ia_atime
);
369 else if (attr
->ia_valid
& ATTR_ATIME
)
370 p
= xdr_encode_current_server_time(p
, &attr
->ia_atime
);
372 p
= xdr_time_not_set(p
);
373 if (attr
->ia_valid
& ATTR_MTIME_SET
)
374 xdr_encode_time(p
, &attr
->ia_mtime
);
375 else if (attr
->ia_valid
& ATTR_MTIME
)
376 xdr_encode_current_server_time(p
, &attr
->ia_mtime
);
384 * typedef string filename<MAXNAMLEN>;
386 static void encode_filename(struct xdr_stream
*xdr
,
387 const char *name
, u32 length
)
391 BUG_ON(length
> NFS2_MAXNAMLEN
);
392 p
= xdr_reserve_space(xdr
, 4 + length
);
393 xdr_encode_opaque(p
, name
, length
);
396 static int decode_filename_inline(struct xdr_stream
*xdr
,
397 const char **name
, u32
*length
)
402 p
= xdr_inline_decode(xdr
, 4);
403 if (unlikely(p
== NULL
))
405 count
= be32_to_cpup(p
);
406 if (count
> NFS3_MAXNAMLEN
)
407 goto out_nametoolong
;
408 p
= xdr_inline_decode(xdr
, count
);
409 if (unlikely(p
== NULL
))
411 *name
= (const char *)p
;
415 dprintk("NFS: returned filename too long: %u\n", count
);
416 return -ENAMETOOLONG
;
418 print_overflow_msg(__func__
, xdr
);
425 * typedef string path<MAXPATHLEN>;
427 static void encode_path(struct xdr_stream
*xdr
, struct page
**pages
, u32 length
)
431 BUG_ON(length
> NFS2_MAXPATHLEN
);
432 p
= xdr_reserve_space(xdr
, 4);
433 *p
= cpu_to_be32(length
);
434 xdr_write_pages(xdr
, pages
, 0, length
);
437 static int decode_path(struct xdr_stream
*xdr
)
442 p
= xdr_inline_decode(xdr
, 4);
443 if (unlikely(p
== NULL
))
445 length
= be32_to_cpup(p
);
446 if (unlikely(length
>= xdr
->buf
->page_len
|| length
> NFS_MAXPATHLEN
))
448 recvd
= xdr_read_pages(xdr
, length
);
449 if (unlikely(length
> recvd
))
451 xdr_terminate_string(xdr
->buf
, length
);
454 dprintk("NFS: returned pathname too long: %u\n", length
);
455 return -ENAMETOOLONG
;
457 dprintk("NFS: server cheating in pathname result: "
458 "length %u > received %u\n", length
, recvd
);
461 print_overflow_msg(__func__
, xdr
);
468 * union attrstat switch (stat status) {
475 static int decode_attrstat(struct xdr_stream
*xdr
, struct nfs_fattr
*result
)
477 enum nfs_stat status
;
480 error
= decode_stat(xdr
, &status
);
483 if (status
!= NFS_OK
)
485 error
= decode_fattr(xdr
, result
);
489 return nfs_stat_to_errno(status
);
500 static void encode_diropargs(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
501 const char *name
, u32 length
)
503 encode_fhandle(xdr
, fh
);
504 encode_filename(xdr
, name
, length
);
510 * union diropres switch (stat status) {
520 static int decode_diropok(struct xdr_stream
*xdr
, struct nfs_diropok
*result
)
524 error
= decode_fhandle(xdr
, result
->fh
);
527 error
= decode_fattr(xdr
, result
->fattr
);
532 static int decode_diropres(struct xdr_stream
*xdr
, struct nfs_diropok
*result
)
534 enum nfs_stat status
;
537 error
= decode_stat(xdr
, &status
);
540 if (status
!= NFS_OK
)
542 error
= decode_diropok(xdr
, result
);
546 return nfs_stat_to_errno(status
);
551 * NFSv2 XDR encode functions
553 * NFSv2 argument types are defined in section 2.2 of RFC 1094:
554 * "NFS: Network File System Protocol Specification".
557 static void nfs2_xdr_enc_fhandle(struct rpc_rqst
*req
,
558 struct xdr_stream
*xdr
,
559 const struct nfs_fh
*fh
)
561 encode_fhandle(xdr
, fh
);
572 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst
*req
,
573 struct xdr_stream
*xdr
,
574 const struct nfs_sattrargs
*args
)
576 encode_fhandle(xdr
, args
->fh
);
577 encode_sattr(xdr
, args
->sattr
);
580 static void nfs2_xdr_enc_diropargs(struct rpc_rqst
*req
,
581 struct xdr_stream
*xdr
,
582 const struct nfs_diropargs
*args
)
584 encode_diropargs(xdr
, args
->fh
, args
->name
, args
->len
);
587 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst
*req
,
588 struct xdr_stream
*xdr
,
589 const struct nfs_readlinkargs
*args
)
591 encode_fhandle(xdr
, args
->fh
);
592 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
593 args
->pglen
, NFS_readlinkres_sz
);
603 * unsigned totalcount;
606 static void encode_readargs(struct xdr_stream
*xdr
,
607 const struct nfs_readargs
*args
)
609 u32 offset
= args
->offset
;
610 u32 count
= args
->count
;
613 encode_fhandle(xdr
, args
->fh
);
615 p
= xdr_reserve_space(xdr
, 4 + 4 + 4);
616 *p
++ = cpu_to_be32(offset
);
617 *p
++ = cpu_to_be32(count
);
618 *p
= cpu_to_be32(count
);
621 static void nfs2_xdr_enc_readargs(struct rpc_rqst
*req
,
622 struct xdr_stream
*xdr
,
623 const struct nfs_readargs
*args
)
625 encode_readargs(xdr
, args
);
626 prepare_reply_buffer(req
, args
->pages
, args
->pgbase
,
627 args
->count
, NFS_readres_sz
);
628 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
636 * unsigned beginoffset;
638 * unsigned totalcount;
642 static void encode_writeargs(struct xdr_stream
*xdr
,
643 const struct nfs_writeargs
*args
)
645 u32 offset
= args
->offset
;
646 u32 count
= args
->count
;
649 encode_fhandle(xdr
, args
->fh
);
651 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
652 *p
++ = cpu_to_be32(offset
);
653 *p
++ = cpu_to_be32(offset
);
654 *p
++ = cpu_to_be32(count
);
657 *p
= cpu_to_be32(count
);
658 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, count
);
661 static void nfs2_xdr_enc_writeargs(struct rpc_rqst
*req
,
662 struct xdr_stream
*xdr
,
663 const struct nfs_writeargs
*args
)
665 encode_writeargs(xdr
, args
);
666 xdr
->buf
->flags
|= XDRBUF_WRITE
;
672 * struct createargs {
677 static void nfs2_xdr_enc_createargs(struct rpc_rqst
*req
,
678 struct xdr_stream
*xdr
,
679 const struct nfs_createargs
*args
)
681 encode_diropargs(xdr
, args
->fh
, args
->name
, args
->len
);
682 encode_sattr(xdr
, args
->sattr
);
685 static void nfs2_xdr_enc_removeargs(struct rpc_rqst
*req
,
686 struct xdr_stream
*xdr
,
687 const struct nfs_removeargs
*args
)
689 encode_diropargs(xdr
, args
->fh
, args
->name
.name
, args
->name
.len
);
695 * struct renameargs {
700 static void nfs2_xdr_enc_renameargs(struct rpc_rqst
*req
,
701 struct xdr_stream
*xdr
,
702 const struct nfs_renameargs
*args
)
704 const struct qstr
*old
= args
->old_name
;
705 const struct qstr
*new = args
->new_name
;
707 encode_diropargs(xdr
, args
->old_dir
, old
->name
, old
->len
);
708 encode_diropargs(xdr
, args
->new_dir
, new->name
, new->len
);
719 static void nfs2_xdr_enc_linkargs(struct rpc_rqst
*req
,
720 struct xdr_stream
*xdr
,
721 const struct nfs_linkargs
*args
)
723 encode_fhandle(xdr
, args
->fromfh
);
724 encode_diropargs(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
728 * 2.2.14. symlinkargs
730 * struct symlinkargs {
736 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst
*req
,
737 struct xdr_stream
*xdr
,
738 const struct nfs_symlinkargs
*args
)
740 encode_diropargs(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
741 encode_path(xdr
, args
->pages
, args
->pathlen
);
742 encode_sattr(xdr
, args
->sattr
);
746 * 2.2.17. readdirargs
748 * struct readdirargs {
754 static void encode_readdirargs(struct xdr_stream
*xdr
,
755 const struct nfs_readdirargs
*args
)
759 encode_fhandle(xdr
, args
->fh
);
761 p
= xdr_reserve_space(xdr
, 4 + 4);
762 *p
++ = cpu_to_be32(args
->cookie
);
763 *p
= cpu_to_be32(args
->count
);
766 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst
*req
,
767 struct xdr_stream
*xdr
,
768 const struct nfs_readdirargs
*args
)
770 encode_readdirargs(xdr
, args
);
771 prepare_reply_buffer(req
, args
->pages
, 0,
772 args
->count
, NFS_readdirres_sz
);
776 * NFSv2 XDR decode functions
778 * NFSv2 result types are defined in section 2.2 of RFC 1094:
779 * "NFS: Network File System Protocol Specification".
782 static int nfs2_xdr_dec_stat(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
785 enum nfs_stat status
;
788 error
= decode_stat(xdr
, &status
);
791 if (status
!= NFS_OK
)
796 return nfs_stat_to_errno(status
);
799 static int nfs2_xdr_dec_attrstat(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
800 struct nfs_fattr
*result
)
802 return decode_attrstat(xdr
, result
);
805 static int nfs2_xdr_dec_diropres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
806 struct nfs_diropok
*result
)
808 return decode_diropres(xdr
, result
);
814 * union readlinkres switch (stat status) {
821 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst
*req
,
822 struct xdr_stream
*xdr
, void *__unused
)
824 enum nfs_stat status
;
827 error
= decode_stat(xdr
, &status
);
830 if (status
!= NFS_OK
)
832 error
= decode_path(xdr
);
836 return nfs_stat_to_errno(status
);
842 * union readres switch (stat status) {
850 static int nfs2_xdr_dec_readres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
851 struct nfs_readres
*result
)
853 enum nfs_stat status
;
856 error
= decode_stat(xdr
, &status
);
859 if (status
!= NFS_OK
)
861 error
= decode_fattr(xdr
, result
->fattr
);
864 error
= decode_nfsdata(xdr
, result
);
868 return nfs_stat_to_errno(status
);
871 static int nfs2_xdr_dec_writeres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
872 struct nfs_writeres
*result
)
874 /* All NFSv2 writes are "file sync" writes */
875 result
->verf
->committed
= NFS_FILE_SYNC
;
876 return decode_attrstat(xdr
, result
->fattr
);
880 * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
881 * the local page cache.
882 * @xdr: XDR stream where entry resides
883 * @entry: buffer to fill in with entry data
884 * @plus: boolean indicating whether this should be a readdirplus entry
886 * Returns zero if successful, otherwise a negative errno value is
889 * This function is not invoked during READDIR reply decoding, but
890 * rather whenever an application invokes the getdents(2) system call
891 * on a directory already in our cache.
902 int nfs2_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
908 p
= xdr_inline_decode(xdr
, 4);
909 if (unlikely(p
== NULL
))
911 if (*p
++ == xdr_zero
) {
912 p
= xdr_inline_decode(xdr
, 4);
913 if (unlikely(p
== NULL
))
915 if (*p
++ == xdr_zero
)
921 p
= xdr_inline_decode(xdr
, 4);
922 if (unlikely(p
== NULL
))
924 entry
->ino
= be32_to_cpup(p
);
926 error
= decode_filename_inline(xdr
, &entry
->name
, &entry
->len
);
931 * The type (size and byte order) of nfscookie isn't defined in
932 * RFC 1094. This implementation assumes that it's an XDR uint32.
934 entry
->prev_cookie
= entry
->cookie
;
935 p
= xdr_inline_decode(xdr
, 4);
936 if (unlikely(p
== NULL
))
938 entry
->cookie
= be32_to_cpup(p
);
940 entry
->d_type
= DT_UNKNOWN
;
945 print_overflow_msg(__func__
, xdr
);
952 * union readdirres switch (stat status) {
962 * Read the directory contents into the page cache, but don't
963 * touch them. The actual decoding is done by nfs2_decode_dirent()
964 * during subsequent nfs_readdir() calls.
966 static int decode_readdirok(struct xdr_stream
*xdr
)
968 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
971 static int nfs2_xdr_dec_readdirres(struct rpc_rqst
*req
,
972 struct xdr_stream
*xdr
, void *__unused
)
974 enum nfs_stat status
;
977 error
= decode_stat(xdr
, &status
);
980 if (status
!= NFS_OK
)
982 error
= decode_readdirok(xdr
);
986 return nfs_stat_to_errno(status
);
992 * union statfsres (stat status) {
1005 static int decode_info(struct xdr_stream
*xdr
, struct nfs2_fsstat
*result
)
1009 p
= xdr_inline_decode(xdr
, NFS_info_sz
<< 2);
1010 if (unlikely(p
== NULL
))
1012 result
->tsize
= be32_to_cpup(p
++);
1013 result
->bsize
= be32_to_cpup(p
++);
1014 result
->blocks
= be32_to_cpup(p
++);
1015 result
->bfree
= be32_to_cpup(p
++);
1016 result
->bavail
= be32_to_cpup(p
);
1019 print_overflow_msg(__func__
, xdr
);
1023 static int nfs2_xdr_dec_statfsres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1024 struct nfs2_fsstat
*result
)
1026 enum nfs_stat status
;
1029 error
= decode_stat(xdr
, &status
);
1030 if (unlikely(error
))
1032 if (status
!= NFS_OK
)
1034 error
= decode_info(xdr
, result
);
1038 return nfs_stat_to_errno(status
);
1043 * We need to translate between nfs status return values and
1044 * the local errno values which may not be the same.
1046 static const struct {
1051 { NFSERR_PERM
, -EPERM
},
1052 { NFSERR_NOENT
, -ENOENT
},
1053 { NFSERR_IO
, -errno_NFSERR_IO
},
1054 { NFSERR_NXIO
, -ENXIO
},
1055 /* { NFSERR_EAGAIN, -EAGAIN }, */
1056 { NFSERR_ACCES
, -EACCES
},
1057 { NFSERR_EXIST
, -EEXIST
},
1058 { NFSERR_XDEV
, -EXDEV
},
1059 { NFSERR_NODEV
, -ENODEV
},
1060 { NFSERR_NOTDIR
, -ENOTDIR
},
1061 { NFSERR_ISDIR
, -EISDIR
},
1062 { NFSERR_INVAL
, -EINVAL
},
1063 { NFSERR_FBIG
, -EFBIG
},
1064 { NFSERR_NOSPC
, -ENOSPC
},
1065 { NFSERR_ROFS
, -EROFS
},
1066 { NFSERR_MLINK
, -EMLINK
},
1067 { NFSERR_NAMETOOLONG
, -ENAMETOOLONG
},
1068 { NFSERR_NOTEMPTY
, -ENOTEMPTY
},
1069 { NFSERR_DQUOT
, -EDQUOT
},
1070 { NFSERR_STALE
, -ESTALE
},
1071 { NFSERR_REMOTE
, -EREMOTE
},
1073 { NFSERR_WFLUSH
, -EWFLUSH
},
1075 { NFSERR_BADHANDLE
, -EBADHANDLE
},
1076 { NFSERR_NOT_SYNC
, -ENOTSYNC
},
1077 { NFSERR_BAD_COOKIE
, -EBADCOOKIE
},
1078 { NFSERR_NOTSUPP
, -ENOTSUPP
},
1079 { NFSERR_TOOSMALL
, -ETOOSMALL
},
1080 { NFSERR_SERVERFAULT
, -EREMOTEIO
},
1081 { NFSERR_BADTYPE
, -EBADTYPE
},
1082 { NFSERR_JUKEBOX
, -EJUKEBOX
},
1087 * nfs_stat_to_errno - convert an NFS status code to a local errno
1088 * @status: NFS status code to convert
1090 * Returns a local errno value, or -EIO if the NFS status code is
1091 * not recognized. This function is used jointly by NFSv2 and NFSv3.
1093 static int nfs_stat_to_errno(enum nfs_stat status
)
1097 for (i
= 0; nfs_errtbl
[i
].stat
!= -1; i
++) {
1098 if (nfs_errtbl
[i
].stat
== (int)status
)
1099 return nfs_errtbl
[i
].errno
;
1101 dprintk("NFS: Unrecognized nfs status value: %u\n", status
);
1102 return nfs_errtbl
[i
].errno
;
1105 #define PROC(proc, argtype, restype, timer) \
1106 [NFSPROC_##proc] = { \
1107 .p_proc = NFSPROC_##proc, \
1108 .p_encode = (kxdreproc_t)nfs2_xdr_enc_##argtype, \
1109 .p_decode = (kxdrdproc_t)nfs2_xdr_dec_##restype, \
1110 .p_arglen = NFS_##argtype##_sz, \
1111 .p_replen = NFS_##restype##_sz, \
1113 .p_statidx = NFSPROC_##proc, \
1116 struct rpc_procinfo nfs_procedures
[] = {
1117 PROC(GETATTR
, fhandle
, attrstat
, 1),
1118 PROC(SETATTR
, sattrargs
, attrstat
, 0),
1119 PROC(LOOKUP
, diropargs
, diropres
, 2),
1120 PROC(READLINK
, readlinkargs
, readlinkres
, 3),
1121 PROC(READ
, readargs
, readres
, 3),
1122 PROC(WRITE
, writeargs
, writeres
, 4),
1123 PROC(CREATE
, createargs
, diropres
, 0),
1124 PROC(REMOVE
, removeargs
, stat
, 0),
1125 PROC(RENAME
, renameargs
, stat
, 0),
1126 PROC(LINK
, linkargs
, stat
, 0),
1127 PROC(SYMLINK
, symlinkargs
, stat
, 0),
1128 PROC(MKDIR
, createargs
, diropres
, 0),
1129 PROC(RMDIR
, diropargs
, stat
, 0),
1130 PROC(READDIR
, readdirargs
, readdirres
, 3),
1131 PROC(STATFS
, fhandle
, statfsres
, 0),
1134 const struct rpc_version nfs_version2
= {
1136 .nrprocs
= ARRAY_SIZE(nfs_procedures
),
1137 .procs
= nfs_procedures