1 // SPDX-License-Identifier: GPL-2.0
3 * linux/fs/nfs/nfs2xdr.c
5 * XDR functions to encode/decode NFS RPC arguments and results.
7 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
8 * Copyright (C) 1996 Olaf Kirch
9 * 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu>
10 * FIFO's need special handling in NFSv2
13 #include <linux/param.h>
14 #include <linux/time.h>
16 #include <linux/errno.h>
17 #include <linux/string.h>
19 #include <linux/pagemap.h>
20 #include <linux/proc_fs.h>
21 #include <linux/sunrpc/clnt.h>
22 #include <linux/nfs.h>
23 #include <linux/nfs2.h>
24 #include <linux/nfs_fs.h>
25 #include <linux/nfs_common.h>
29 #define NFSDBG_FACILITY NFSDBG_XDR
32 * Declare the space requirements for NFS arguments and replies as
33 * number of 32bit-words
35 #define NFS_pagepad_sz (1) /* Page padding */
36 #define NFS_fhandle_sz (8)
37 #define NFS_sattr_sz (8)
38 #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2))
39 #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2))
40 #define NFS_fattr_sz (17)
41 #define NFS_info_sz (5)
42 #define NFS_entry_sz (NFS_filename_sz+3)
44 #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz)
45 #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz)
46 #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz)
47 #define NFS_readlinkargs_sz (NFS_fhandle_sz)
48 #define NFS_readargs_sz (NFS_fhandle_sz+3)
49 #define NFS_writeargs_sz (NFS_fhandle_sz+4)
50 #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz)
51 #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz)
52 #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz)
53 #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz)
54 #define NFS_readdirargs_sz (NFS_fhandle_sz+2)
56 #define NFS_attrstat_sz (1+NFS_fattr_sz)
57 #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz)
58 #define NFS_readlinkres_sz (2+NFS_pagepad_sz)
59 #define NFS_readres_sz (1+NFS_fattr_sz+1+NFS_pagepad_sz)
60 #define NFS_writeres_sz (NFS_attrstat_sz)
61 #define NFS_stat_sz (1)
62 #define NFS_readdirres_sz (1+NFS_pagepad_sz)
63 #define NFS_statfsres_sz (1+NFS_info_sz)
66 * Encode/decode NFSv2 basic data types
68 * Basic NFSv2 data types are defined in section 2.3 of RFC 1094:
69 * "NFS: Network File System Protocol Specification".
71 * Not all basic data types have their own encoding and decoding
72 * functions. For run-time efficiency, some data types are encoded
76 static struct user_namespace
*rpc_userns(const struct rpc_clnt
*clnt
)
78 if (clnt
&& clnt
->cl_cred
)
79 return clnt
->cl_cred
->user_ns
;
83 static struct user_namespace
*rpc_rqst_userns(const struct rpc_rqst
*rqstp
)
86 return rpc_userns(rqstp
->rq_task
->tk_client
);
91 * typedef opaque nfsdata<>;
93 static int decode_nfsdata(struct xdr_stream
*xdr
, struct nfs_pgio_res
*result
)
98 p
= xdr_inline_decode(xdr
, 4);
101 count
= be32_to_cpup(p
);
102 recvd
= xdr_read_pages(xdr
, count
);
103 if (unlikely(count
> recvd
))
106 result
->eof
= 0; /* NFSv2 does not pass EOF flag on the wire. */
107 result
->count
= count
;
110 dprintk("NFS: server cheating in read result: "
111 "count %u > recvd %u\n", count
, recvd
);
126 * NFSERR_NOTDIR = 20,
131 * NFSERR_NAMETOOLONG = 63,
132 * NFSERR_NOTEMPTY = 66,
138 static int decode_stat(struct xdr_stream
*xdr
, enum nfs_stat
*status
)
142 p
= xdr_inline_decode(xdr
, 4);
145 if (unlikely(*p
!= cpu_to_be32(NFS_OK
)))
150 *status
= be32_to_cpup(p
);
151 trace_nfs_xdr_status(xdr
, (int)*status
);
168 static __be32
*xdr_decode_ftype(__be32
*p
, u32
*type
)
170 *type
= be32_to_cpup(p
++);
171 if (unlikely(*type
> NF2FIFO
))
179 * typedef opaque fhandle[FHSIZE];
181 static void encode_fhandle(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
)
185 p
= xdr_reserve_space(xdr
, NFS2_FHSIZE
);
186 memcpy(p
, fh
->data
, NFS2_FHSIZE
);
189 static int decode_fhandle(struct xdr_stream
*xdr
, struct nfs_fh
*fh
)
193 p
= xdr_inline_decode(xdr
, NFS2_FHSIZE
);
196 fh
->size
= NFS2_FHSIZE
;
197 memcpy(fh
->data
, p
, NFS2_FHSIZE
);
205 * unsigned int seconds;
206 * unsigned int useconds;
209 static __be32
*xdr_encode_time(__be32
*p
, const struct timespec64
*timep
)
211 *p
++ = cpu_to_be32((u32
)timep
->tv_sec
);
212 if (timep
->tv_nsec
!= 0)
213 *p
++ = cpu_to_be32(timep
->tv_nsec
/ NSEC_PER_USEC
);
215 *p
++ = cpu_to_be32(0);
220 * Passing the invalid value useconds=1000000 is a Sun convention for
221 * "set to current server time". It's needed to make permissions checks
222 * for the "touch" program across v2 mounts to Solaris and Irix servers
223 * work correctly. See description of sattr in section 6.1 of "NFS
224 * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5.
226 static __be32
*xdr_encode_current_server_time(__be32
*p
,
227 const struct timespec64
*timep
)
229 *p
++ = cpu_to_be32(timep
->tv_sec
);
230 *p
++ = cpu_to_be32(1000000);
234 static __be32
*xdr_decode_time(__be32
*p
, struct timespec64
*timep
)
236 timep
->tv_sec
= be32_to_cpup(p
++);
237 timep
->tv_nsec
= be32_to_cpup(p
++) * NSEC_PER_USEC
;
247 * unsigned int nlink;
251 * unsigned int blocksize;
253 * unsigned int blocks;
255 * unsigned int fileid;
262 static int decode_fattr(struct xdr_stream
*xdr
, struct nfs_fattr
*fattr
,
263 struct user_namespace
*userns
)
268 p
= xdr_inline_decode(xdr
, NFS_fattr_sz
<< 2);
272 fattr
->valid
|= NFS_ATTR_FATTR_V2
;
274 p
= xdr_decode_ftype(p
, &type
);
276 fattr
->mode
= be32_to_cpup(p
++);
277 fattr
->nlink
= be32_to_cpup(p
++);
278 fattr
->uid
= make_kuid(userns
, be32_to_cpup(p
++));
279 if (!uid_valid(fattr
->uid
))
281 fattr
->gid
= make_kgid(userns
, be32_to_cpup(p
++));
282 if (!gid_valid(fattr
->gid
))
285 fattr
->size
= be32_to_cpup(p
++);
286 fattr
->du
.nfs2
.blocksize
= be32_to_cpup(p
++);
288 rdev
= be32_to_cpup(p
++);
289 fattr
->rdev
= new_decode_dev(rdev
);
290 if (type
== (u32
)NFCHR
&& rdev
== (u32
)NFS2_FIFO_DEV
) {
291 fattr
->mode
= (fattr
->mode
& ~S_IFMT
) | S_IFIFO
;
295 fattr
->du
.nfs2
.blocks
= be32_to_cpup(p
++);
296 fattr
->fsid
.major
= be32_to_cpup(p
++);
297 fattr
->fsid
.minor
= 0;
298 fattr
->fileid
= be32_to_cpup(p
++);
300 p
= xdr_decode_time(p
, &fattr
->atime
);
301 p
= xdr_decode_time(p
, &fattr
->mtime
);
302 xdr_decode_time(p
, &fattr
->ctime
);
303 fattr
->change_attr
= nfs_timespec_to_change_attr(&fattr
->ctime
);
307 dprintk("NFS: returned invalid uid\n");
310 dprintk("NFS: returned invalid gid\n");
327 #define NFS2_SATTR_NOT_SET (0xffffffff)
329 static __be32
*xdr_time_not_set(__be32
*p
)
331 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
332 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
336 static void encode_sattr(struct xdr_stream
*xdr
, const struct iattr
*attr
,
337 struct user_namespace
*userns
)
341 p
= xdr_reserve_space(xdr
, NFS_sattr_sz
<< 2);
343 if (attr
->ia_valid
& ATTR_MODE
)
344 *p
++ = cpu_to_be32(attr
->ia_mode
);
346 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
347 if (attr
->ia_valid
& ATTR_UID
)
348 *p
++ = cpu_to_be32(from_kuid_munged(userns
, attr
->ia_uid
));
350 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
351 if (attr
->ia_valid
& ATTR_GID
)
352 *p
++ = cpu_to_be32(from_kgid_munged(userns
, attr
->ia_gid
));
354 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
355 if (attr
->ia_valid
& ATTR_SIZE
)
356 *p
++ = cpu_to_be32((u32
)attr
->ia_size
);
358 *p
++ = cpu_to_be32(NFS2_SATTR_NOT_SET
);
360 if (attr
->ia_valid
& ATTR_ATIME_SET
)
361 p
= xdr_encode_time(p
, &attr
->ia_atime
);
362 else if (attr
->ia_valid
& ATTR_ATIME
)
363 p
= xdr_encode_current_server_time(p
, &attr
->ia_atime
);
365 p
= xdr_time_not_set(p
);
366 if (attr
->ia_valid
& ATTR_MTIME_SET
)
367 xdr_encode_time(p
, &attr
->ia_mtime
);
368 else if (attr
->ia_valid
& ATTR_MTIME
)
369 xdr_encode_current_server_time(p
, &attr
->ia_mtime
);
377 * typedef string filename<MAXNAMLEN>;
379 static void encode_filename(struct xdr_stream
*xdr
,
380 const char *name
, u32 length
)
384 WARN_ON_ONCE(length
> NFS2_MAXNAMLEN
);
385 p
= xdr_reserve_space(xdr
, 4 + length
);
386 xdr_encode_opaque(p
, name
, length
);
389 static int decode_filename_inline(struct xdr_stream
*xdr
,
390 const char **name
, u32
*length
)
395 p
= xdr_inline_decode(xdr
, 4);
398 count
= be32_to_cpup(p
);
399 if (count
> NFS3_MAXNAMLEN
)
400 goto out_nametoolong
;
401 p
= xdr_inline_decode(xdr
, count
);
404 *name
= (const char *)p
;
408 dprintk("NFS: returned filename too long: %u\n", count
);
409 return -ENAMETOOLONG
;
415 * typedef string path<MAXPATHLEN>;
417 static void encode_path(struct xdr_stream
*xdr
, struct page
**pages
, u32 length
)
421 p
= xdr_reserve_space(xdr
, 4);
422 *p
= cpu_to_be32(length
);
423 xdr_write_pages(xdr
, pages
, 0, length
);
426 static int decode_path(struct xdr_stream
*xdr
)
431 p
= xdr_inline_decode(xdr
, 4);
434 length
= be32_to_cpup(p
);
435 if (unlikely(length
>= xdr
->buf
->page_len
|| length
> NFS_MAXPATHLEN
))
437 recvd
= xdr_read_pages(xdr
, length
);
438 if (unlikely(length
> recvd
))
440 xdr_terminate_string(xdr
->buf
, length
);
443 dprintk("NFS: returned pathname too long: %u\n", length
);
444 return -ENAMETOOLONG
;
446 dprintk("NFS: server cheating in pathname result: "
447 "length %u > received %u\n", length
, recvd
);
454 * union attrstat switch (stat status) {
461 static int decode_attrstat(struct xdr_stream
*xdr
, struct nfs_fattr
*result
,
463 struct user_namespace
*userns
)
465 enum nfs_stat status
;
468 error
= decode_stat(xdr
, &status
);
473 if (status
!= NFS_OK
)
475 error
= decode_fattr(xdr
, result
, userns
);
479 return nfs_stat_to_errno(status
);
490 static void encode_diropargs(struct xdr_stream
*xdr
, const struct nfs_fh
*fh
,
491 const char *name
, u32 length
)
493 encode_fhandle(xdr
, fh
);
494 encode_filename(xdr
, name
, length
);
500 * union diropres switch (stat status) {
510 static int decode_diropok(struct xdr_stream
*xdr
, struct nfs_diropok
*result
,
511 struct user_namespace
*userns
)
515 error
= decode_fhandle(xdr
, result
->fh
);
518 error
= decode_fattr(xdr
, result
->fattr
, userns
);
523 static int decode_diropres(struct xdr_stream
*xdr
, struct nfs_diropok
*result
,
524 struct user_namespace
*userns
)
526 enum nfs_stat status
;
529 error
= decode_stat(xdr
, &status
);
532 if (status
!= NFS_OK
)
534 error
= decode_diropok(xdr
, result
, userns
);
538 return nfs_stat_to_errno(status
);
543 * NFSv2 XDR encode functions
545 * NFSv2 argument types are defined in section 2.2 of RFC 1094:
546 * "NFS: Network File System Protocol Specification".
549 static void nfs2_xdr_enc_fhandle(struct rpc_rqst
*req
,
550 struct xdr_stream
*xdr
,
553 const struct nfs_fh
*fh
= data
;
555 encode_fhandle(xdr
, fh
);
566 static void nfs2_xdr_enc_sattrargs(struct rpc_rqst
*req
,
567 struct xdr_stream
*xdr
,
570 const struct nfs_sattrargs
*args
= data
;
572 encode_fhandle(xdr
, args
->fh
);
573 encode_sattr(xdr
, args
->sattr
, rpc_rqst_userns(req
));
576 static void nfs2_xdr_enc_diropargs(struct rpc_rqst
*req
,
577 struct xdr_stream
*xdr
,
580 const struct nfs_diropargs
*args
= data
;
582 encode_diropargs(xdr
, args
->fh
, args
->name
, args
->len
);
585 static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst
*req
,
586 struct xdr_stream
*xdr
,
589 const struct nfs_readlinkargs
*args
= data
;
591 encode_fhandle(xdr
, args
->fh
);
592 rpc_prepare_reply_pages(req
, args
->pages
, args
->pgbase
, args
->pglen
,
593 NFS_readlinkres_sz
- NFS_pagepad_sz
);
603 * unsigned totalcount;
606 static void encode_readargs(struct xdr_stream
*xdr
,
607 const struct nfs_pgio_args
*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
,
625 const struct nfs_pgio_args
*args
= data
;
627 encode_readargs(xdr
, args
);
628 rpc_prepare_reply_pages(req
, args
->pages
, args
->pgbase
, args
->count
,
629 NFS_readres_sz
- NFS_pagepad_sz
);
630 req
->rq_rcv_buf
.flags
|= XDRBUF_READ
;
638 * unsigned beginoffset;
640 * unsigned totalcount;
644 static void encode_writeargs(struct xdr_stream
*xdr
,
645 const struct nfs_pgio_args
*args
)
647 u32 offset
= args
->offset
;
648 u32 count
= args
->count
;
651 encode_fhandle(xdr
, args
->fh
);
653 p
= xdr_reserve_space(xdr
, 4 + 4 + 4 + 4);
654 *p
++ = cpu_to_be32(offset
);
655 *p
++ = cpu_to_be32(offset
);
656 *p
++ = cpu_to_be32(count
);
659 *p
= cpu_to_be32(count
);
660 xdr_write_pages(xdr
, args
->pages
, args
->pgbase
, count
);
663 static void nfs2_xdr_enc_writeargs(struct rpc_rqst
*req
,
664 struct xdr_stream
*xdr
,
667 const struct nfs_pgio_args
*args
= data
;
669 encode_writeargs(xdr
, args
);
670 xdr
->buf
->flags
|= XDRBUF_WRITE
;
676 * struct createargs {
681 static void nfs2_xdr_enc_createargs(struct rpc_rqst
*req
,
682 struct xdr_stream
*xdr
,
685 const struct nfs_createargs
*args
= data
;
687 encode_diropargs(xdr
, args
->fh
, args
->name
, args
->len
);
688 encode_sattr(xdr
, args
->sattr
, rpc_rqst_userns(req
));
691 static void nfs2_xdr_enc_removeargs(struct rpc_rqst
*req
,
692 struct xdr_stream
*xdr
,
695 const struct nfs_removeargs
*args
= data
;
697 encode_diropargs(xdr
, args
->fh
, args
->name
.name
, args
->name
.len
);
703 * struct renameargs {
708 static void nfs2_xdr_enc_renameargs(struct rpc_rqst
*req
,
709 struct xdr_stream
*xdr
,
712 const struct nfs_renameargs
*args
= data
;
713 const struct qstr
*old
= args
->old_name
;
714 const struct qstr
*new = args
->new_name
;
716 encode_diropargs(xdr
, args
->old_dir
, old
->name
, old
->len
);
717 encode_diropargs(xdr
, args
->new_dir
, new->name
, new->len
);
728 static void nfs2_xdr_enc_linkargs(struct rpc_rqst
*req
,
729 struct xdr_stream
*xdr
,
732 const struct nfs_linkargs
*args
= data
;
734 encode_fhandle(xdr
, args
->fromfh
);
735 encode_diropargs(xdr
, args
->tofh
, args
->toname
, args
->tolen
);
739 * 2.2.14. symlinkargs
741 * struct symlinkargs {
747 static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst
*req
,
748 struct xdr_stream
*xdr
,
751 const struct nfs_symlinkargs
*args
= data
;
753 encode_diropargs(xdr
, args
->fromfh
, args
->fromname
, args
->fromlen
);
754 encode_path(xdr
, args
->pages
, args
->pathlen
);
755 encode_sattr(xdr
, args
->sattr
, rpc_rqst_userns(req
));
759 * 2.2.17. readdirargs
761 * struct readdirargs {
767 static void encode_readdirargs(struct xdr_stream
*xdr
,
768 const struct nfs_readdirargs
*args
)
772 encode_fhandle(xdr
, args
->fh
);
774 p
= xdr_reserve_space(xdr
, 4 + 4);
775 *p
++ = cpu_to_be32(args
->cookie
);
776 *p
= cpu_to_be32(args
->count
);
779 static void nfs2_xdr_enc_readdirargs(struct rpc_rqst
*req
,
780 struct xdr_stream
*xdr
,
783 const struct nfs_readdirargs
*args
= data
;
785 encode_readdirargs(xdr
, args
);
786 rpc_prepare_reply_pages(req
, args
->pages
, 0, args
->count
,
787 NFS_readdirres_sz
- NFS_pagepad_sz
);
791 * NFSv2 XDR decode functions
793 * NFSv2 result types are defined in section 2.2 of RFC 1094:
794 * "NFS: Network File System Protocol Specification".
797 static int nfs2_xdr_dec_stat(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
800 enum nfs_stat status
;
803 error
= decode_stat(xdr
, &status
);
806 if (status
!= NFS_OK
)
811 return nfs_stat_to_errno(status
);
814 static int nfs2_xdr_dec_attrstat(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
817 return decode_attrstat(xdr
, result
, NULL
, rpc_rqst_userns(req
));
820 static int nfs2_xdr_dec_diropres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
823 return decode_diropres(xdr
, result
, rpc_rqst_userns(req
));
829 * union readlinkres switch (stat status) {
836 static int nfs2_xdr_dec_readlinkres(struct rpc_rqst
*req
,
837 struct xdr_stream
*xdr
, void *__unused
)
839 enum nfs_stat status
;
842 error
= decode_stat(xdr
, &status
);
845 if (status
!= NFS_OK
)
847 error
= decode_path(xdr
);
851 return nfs_stat_to_errno(status
);
857 * union readres switch (stat status) {
865 static int nfs2_xdr_dec_readres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
868 struct nfs_pgio_res
*result
= data
;
869 enum nfs_stat status
;
872 error
= decode_stat(xdr
, &status
);
875 result
->op_status
= status
;
876 if (status
!= NFS_OK
)
878 error
= decode_fattr(xdr
, result
->fattr
, rpc_rqst_userns(req
));
881 error
= decode_nfsdata(xdr
, result
);
885 return nfs_stat_to_errno(status
);
888 static int nfs2_xdr_dec_writeres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
891 struct nfs_pgio_res
*result
= data
;
893 /* All NFSv2 writes are "file sync" writes */
894 result
->verf
->committed
= NFS_FILE_SYNC
;
895 return decode_attrstat(xdr
, result
->fattr
, &result
->op_status
,
896 rpc_rqst_userns(req
));
900 * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in
901 * the local page cache.
902 * @xdr: XDR stream where entry resides
903 * @entry: buffer to fill in with entry data
904 * @plus: boolean indicating whether this should be a readdirplus entry
906 * Returns zero if successful, otherwise a negative errno value is
909 * This function is not invoked during READDIR reply decoding, but
910 * rather whenever an application invokes the getdents(2) system call
911 * on a directory already in our cache.
922 int nfs2_decode_dirent(struct xdr_stream
*xdr
, struct nfs_entry
*entry
,
928 p
= xdr_inline_decode(xdr
, 4);
931 if (*p
++ == xdr_zero
) {
932 p
= xdr_inline_decode(xdr
, 4);
935 if (*p
++ == xdr_zero
)
941 p
= xdr_inline_decode(xdr
, 4);
944 entry
->ino
= be32_to_cpup(p
);
946 error
= decode_filename_inline(xdr
, &entry
->name
, &entry
->len
);
948 return error
== -ENAMETOOLONG
? -ENAMETOOLONG
: -EAGAIN
;
951 * The type (size and byte order) of nfscookie isn't defined in
952 * RFC 1094. This implementation assumes that it's an XDR uint32.
954 p
= xdr_inline_decode(xdr
, 4);
957 entry
->cookie
= be32_to_cpup(p
);
959 entry
->d_type
= DT_UNKNOWN
;
967 * union readdirres switch (stat status) {
977 * Read the directory contents into the page cache, but don't
978 * touch them. The actual decoding is done by nfs2_decode_dirent()
979 * during subsequent nfs_readdir() calls.
981 static int decode_readdirok(struct xdr_stream
*xdr
)
983 return xdr_read_pages(xdr
, xdr
->buf
->page_len
);
986 static int nfs2_xdr_dec_readdirres(struct rpc_rqst
*req
,
987 struct xdr_stream
*xdr
, void *__unused
)
989 enum nfs_stat status
;
992 error
= decode_stat(xdr
, &status
);
995 if (status
!= NFS_OK
)
997 error
= decode_readdirok(xdr
);
1001 return nfs_stat_to_errno(status
);
1007 * union statfsres (stat status) {
1020 static int decode_info(struct xdr_stream
*xdr
, struct nfs2_fsstat
*result
)
1024 p
= xdr_inline_decode(xdr
, NFS_info_sz
<< 2);
1027 result
->tsize
= be32_to_cpup(p
++);
1028 result
->bsize
= be32_to_cpup(p
++);
1029 result
->blocks
= be32_to_cpup(p
++);
1030 result
->bfree
= be32_to_cpup(p
++);
1031 result
->bavail
= be32_to_cpup(p
);
1035 static int nfs2_xdr_dec_statfsres(struct rpc_rqst
*req
, struct xdr_stream
*xdr
,
1038 enum nfs_stat status
;
1041 error
= decode_stat(xdr
, &status
);
1042 if (unlikely(error
))
1044 if (status
!= NFS_OK
)
1046 error
= decode_info(xdr
, result
);
1050 return nfs_stat_to_errno(status
);
1053 #define PROC(proc, argtype, restype, timer) \
1054 [NFSPROC_##proc] = { \
1055 .p_proc = NFSPROC_##proc, \
1056 .p_encode = nfs2_xdr_enc_##argtype, \
1057 .p_decode = nfs2_xdr_dec_##restype, \
1058 .p_arglen = NFS_##argtype##_sz, \
1059 .p_replen = NFS_##restype##_sz, \
1061 .p_statidx = NFSPROC_##proc, \
1064 const struct rpc_procinfo nfs_procedures
[] = {
1065 PROC(GETATTR
, fhandle
, attrstat
, 1),
1066 PROC(SETATTR
, sattrargs
, attrstat
, 0),
1067 PROC(LOOKUP
, diropargs
, diropres
, 2),
1068 PROC(READLINK
, readlinkargs
, readlinkres
, 3),
1069 PROC(READ
, readargs
, readres
, 3),
1070 PROC(WRITE
, writeargs
, writeres
, 4),
1071 PROC(CREATE
, createargs
, diropres
, 0),
1072 PROC(REMOVE
, removeargs
, stat
, 0),
1073 PROC(RENAME
, renameargs
, stat
, 0),
1074 PROC(LINK
, linkargs
, stat
, 0),
1075 PROC(SYMLINK
, symlinkargs
, stat
, 0),
1076 PROC(MKDIR
, createargs
, diropres
, 0),
1077 PROC(RMDIR
, diropargs
, stat
, 0),
1078 PROC(READDIR
, readdirargs
, readdirres
, 3),
1079 PROC(STATFS
, fhandle
, statfsres
, 0),
1082 static unsigned int nfs_version2_counts
[ARRAY_SIZE(nfs_procedures
)];
1083 const struct rpc_version nfs_version2
= {
1085 .nrprocs
= ARRAY_SIZE(nfs_procedures
),
1086 .procs
= nfs_procedures
,
1087 .counts
= nfs_version2_counts
,