11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * linux/fs/nfs/nfs2xdr.c 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * XDR functions to encode/decode NFS RPC arguments and results. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Copyright (C) 1992, 1993, 1994 Rick Sladkey 71da177e4SLinus Torvalds * Copyright (C) 1996 Olaf Kirch 81da177e4SLinus Torvalds * 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu> 91da177e4SLinus Torvalds * FIFO's need special handling in NFSv2 101da177e4SLinus Torvalds */ 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds #include <linux/param.h> 131da177e4SLinus Torvalds #include <linux/time.h> 141da177e4SLinus Torvalds #include <linux/mm.h> 151da177e4SLinus Torvalds #include <linux/errno.h> 161da177e4SLinus Torvalds #include <linux/string.h> 171da177e4SLinus Torvalds #include <linux/in.h> 181da177e4SLinus Torvalds #include <linux/pagemap.h> 191da177e4SLinus Torvalds #include <linux/proc_fs.h> 201da177e4SLinus Torvalds #include <linux/sunrpc/clnt.h> 211da177e4SLinus Torvalds #include <linux/nfs.h> 221da177e4SLinus Torvalds #include <linux/nfs2.h> 231da177e4SLinus Torvalds #include <linux/nfs_fs.h> 24816724e6STrond Myklebust #include "internal.h" 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds #define NFSDBG_FACILITY NFSDBG_XDR 271da177e4SLinus Torvalds 281da177e4SLinus Torvalds /* Mapping from NFS error code to "errno" error code. */ 291da177e4SLinus Torvalds #define errno_NFSERR_IO EIO 301da177e4SLinus Torvalds 311da177e4SLinus Torvalds /* 321da177e4SLinus Torvalds * Declare the space requirements for NFS arguments and replies as 331da177e4SLinus Torvalds * number of 32bit-words 341da177e4SLinus Torvalds */ 351da177e4SLinus Torvalds #define NFS_fhandle_sz (8) 361da177e4SLinus Torvalds #define NFS_sattr_sz (8) 371da177e4SLinus Torvalds #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2)) 381da177e4SLinus Torvalds #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2)) 391da177e4SLinus Torvalds #define NFS_fattr_sz (17) 401da177e4SLinus Torvalds #define NFS_info_sz (5) 411da177e4SLinus Torvalds #define NFS_entry_sz (NFS_filename_sz+3) 421da177e4SLinus Torvalds 431da177e4SLinus Torvalds #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz) 444fdc17b2STrond Myklebust #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz) 451da177e4SLinus Torvalds #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz) 461da177e4SLinus Torvalds #define NFS_readlinkargs_sz (NFS_fhandle_sz) 471da177e4SLinus Torvalds #define NFS_readargs_sz (NFS_fhandle_sz+3) 481da177e4SLinus Torvalds #define NFS_writeargs_sz (NFS_fhandle_sz+4) 491da177e4SLinus Torvalds #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz) 501da177e4SLinus Torvalds #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz) 511da177e4SLinus Torvalds #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz) 5294a6d753SChuck Lever #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz) 531da177e4SLinus Torvalds #define NFS_readdirargs_sz (NFS_fhandle_sz+2) 541da177e4SLinus Torvalds 551da177e4SLinus Torvalds #define NFS_attrstat_sz (1+NFS_fattr_sz) 561da177e4SLinus Torvalds #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz) 571da177e4SLinus Torvalds #define NFS_readlinkres_sz (2) 581da177e4SLinus Torvalds #define NFS_readres_sz (1+NFS_fattr_sz+1) 591da177e4SLinus Torvalds #define NFS_writeres_sz (NFS_attrstat_sz) 601da177e4SLinus Torvalds #define NFS_stat_sz (1) 611da177e4SLinus Torvalds #define NFS_readdirres_sz (1) 621da177e4SLinus Torvalds #define NFS_statfsres_sz (1+NFS_info_sz) 631da177e4SLinus Torvalds 6425a0866cSChuck Lever 6525a0866cSChuck Lever /* 6625a0866cSChuck Lever * While encoding arguments, set up the reply buffer in advance to 6725a0866cSChuck Lever * receive reply data directly into the page cache. 6825a0866cSChuck Lever */ 6925a0866cSChuck Lever static void prepare_reply_buffer(struct rpc_rqst *req, struct page **pages, 7025a0866cSChuck Lever unsigned int base, unsigned int len, 7125a0866cSChuck Lever unsigned int bufsize) 7225a0866cSChuck Lever { 7325a0866cSChuck Lever struct rpc_auth *auth = req->rq_cred->cr_auth; 7425a0866cSChuck Lever unsigned int replen; 7525a0866cSChuck Lever 7625a0866cSChuck Lever replen = RPC_REPHDRSIZE + auth->au_rslack + bufsize; 7725a0866cSChuck Lever xdr_inline_pages(&req->rq_rcv_buf, replen << 2, pages, base, len); 7825a0866cSChuck Lever } 7925a0866cSChuck Lever 8025a0866cSChuck Lever 811da177e4SLinus Torvalds /* 821da177e4SLinus Torvalds * Common NFS XDR functions as inlines 831da177e4SLinus Torvalds */ 849d787a75SAl Viro static inline __be32 * 859d787a75SAl Viro xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle) 861da177e4SLinus Torvalds { 871da177e4SLinus Torvalds /* NFSv2 handles have a fixed length */ 881da177e4SLinus Torvalds fhandle->size = NFS2_FHSIZE; 891da177e4SLinus Torvalds memcpy(fhandle->data, p, NFS2_FHSIZE); 901da177e4SLinus Torvalds return p + XDR_QUADLEN(NFS2_FHSIZE); 911da177e4SLinus Torvalds } 921da177e4SLinus Torvalds 939d787a75SAl Viro static inline __be32* 949d787a75SAl Viro xdr_decode_time(__be32 *p, struct timespec *timep) 951da177e4SLinus Torvalds { 961da177e4SLinus Torvalds timep->tv_sec = ntohl(*p++); 971da177e4SLinus Torvalds /* Convert microseconds into nanoseconds */ 981da177e4SLinus Torvalds timep->tv_nsec = ntohl(*p++) * 1000; 991da177e4SLinus Torvalds return p; 1001da177e4SLinus Torvalds } 1011da177e4SLinus Torvalds 1029d787a75SAl Viro static __be32 * 1039d787a75SAl Viro xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr) 1041da177e4SLinus Torvalds { 105bca79478STrond Myklebust u32 rdev, type; 106bca79478STrond Myklebust type = ntohl(*p++); 1071da177e4SLinus Torvalds fattr->mode = ntohl(*p++); 1081da177e4SLinus Torvalds fattr->nlink = ntohl(*p++); 1091da177e4SLinus Torvalds fattr->uid = ntohl(*p++); 1101da177e4SLinus Torvalds fattr->gid = ntohl(*p++); 1111da177e4SLinus Torvalds fattr->size = ntohl(*p++); 1121da177e4SLinus Torvalds fattr->du.nfs2.blocksize = ntohl(*p++); 1131da177e4SLinus Torvalds rdev = ntohl(*p++); 1141da177e4SLinus Torvalds fattr->du.nfs2.blocks = ntohl(*p++); 1158b4bdcf8STrond Myklebust fattr->fsid.major = ntohl(*p++); 1168b4bdcf8STrond Myklebust fattr->fsid.minor = 0; 1171da177e4SLinus Torvalds fattr->fileid = ntohl(*p++); 1181da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->atime); 1191da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->mtime); 1201da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->ctime); 1219e6e70f8STrond Myklebust fattr->valid |= NFS_ATTR_FATTR_V2; 1221da177e4SLinus Torvalds fattr->rdev = new_decode_dev(rdev); 123bca79478STrond Myklebust if (type == NFCHR && rdev == NFS2_FIFO_DEV) { 1241da177e4SLinus Torvalds fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; 1251da177e4SLinus Torvalds fattr->rdev = 0; 1261da177e4SLinus Torvalds } 1271da177e4SLinus Torvalds return p; 1281da177e4SLinus Torvalds } 1291da177e4SLinus Torvalds 1301da177e4SLinus Torvalds /* 13125a0866cSChuck Lever * Encode/decode NFSv2 basic data types 13225a0866cSChuck Lever * 13325a0866cSChuck Lever * Basic NFSv2 data types are defined in section 2.3 of RFC 1094: 13425a0866cSChuck Lever * "NFS: Network File System Protocol Specification". 13525a0866cSChuck Lever * 13625a0866cSChuck Lever * Not all basic data types have their own encoding and decoding 13725a0866cSChuck Lever * functions. For run-time efficiency, some data types are encoded 13825a0866cSChuck Lever * or decoded inline. 13925a0866cSChuck Lever */ 14025a0866cSChuck Lever 14125a0866cSChuck Lever /* 14225a0866cSChuck Lever * 2.3.3. fhandle 14325a0866cSChuck Lever * 14425a0866cSChuck Lever * typedef opaque fhandle[FHSIZE]; 14525a0866cSChuck Lever */ 14625a0866cSChuck Lever static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh) 14725a0866cSChuck Lever { 14825a0866cSChuck Lever __be32 *p; 14925a0866cSChuck Lever 15025a0866cSChuck Lever BUG_ON(fh->size != NFS2_FHSIZE); 15125a0866cSChuck Lever p = xdr_reserve_space(xdr, NFS2_FHSIZE); 15225a0866cSChuck Lever memcpy(p, fh->data, NFS2_FHSIZE); 15325a0866cSChuck Lever } 15425a0866cSChuck Lever 15525a0866cSChuck Lever /* 156282ac2a5SChuck Lever * 2.3.4. timeval 157282ac2a5SChuck Lever * 158282ac2a5SChuck Lever * struct timeval { 159282ac2a5SChuck Lever * unsigned int seconds; 160282ac2a5SChuck Lever * unsigned int useconds; 161282ac2a5SChuck Lever * }; 162282ac2a5SChuck Lever */ 163282ac2a5SChuck Lever static __be32 *xdr_encode_time(__be32 *p, const struct timespec *timep) 164282ac2a5SChuck Lever { 165282ac2a5SChuck Lever *p++ = cpu_to_be32(timep->tv_sec); 166282ac2a5SChuck Lever if (timep->tv_nsec != 0) 167282ac2a5SChuck Lever *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC); 168282ac2a5SChuck Lever else 169282ac2a5SChuck Lever *p++ = cpu_to_be32(0); 170282ac2a5SChuck Lever return p; 171282ac2a5SChuck Lever } 172282ac2a5SChuck Lever 173282ac2a5SChuck Lever /* 174282ac2a5SChuck Lever * Passing the invalid value useconds=1000000 is a Sun convention for 175282ac2a5SChuck Lever * "set to current server time". It's needed to make permissions checks 176282ac2a5SChuck Lever * for the "touch" program across v2 mounts to Solaris and Irix servers 177282ac2a5SChuck Lever * work correctly. See description of sattr in section 6.1 of "NFS 178282ac2a5SChuck Lever * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5. 179282ac2a5SChuck Lever */ 180282ac2a5SChuck Lever static __be32 *xdr_encode_current_server_time(__be32 *p, 181282ac2a5SChuck Lever const struct timespec *timep) 182282ac2a5SChuck Lever { 183282ac2a5SChuck Lever *p++ = cpu_to_be32(timep->tv_sec); 184282ac2a5SChuck Lever *p++ = cpu_to_be32(1000000); 185282ac2a5SChuck Lever return p; 186282ac2a5SChuck Lever } 187282ac2a5SChuck Lever 188282ac2a5SChuck Lever /* 18925a0866cSChuck Lever * 2.3.6. sattr 19025a0866cSChuck Lever * 19125a0866cSChuck Lever * struct sattr { 19225a0866cSChuck Lever * unsigned int mode; 19325a0866cSChuck Lever * unsigned int uid; 19425a0866cSChuck Lever * unsigned int gid; 19525a0866cSChuck Lever * unsigned int size; 19625a0866cSChuck Lever * timeval atime; 19725a0866cSChuck Lever * timeval mtime; 19825a0866cSChuck Lever * }; 19925a0866cSChuck Lever */ 20025a0866cSChuck Lever 20125a0866cSChuck Lever #define NFS2_SATTR_NOT_SET (0xffffffff) 20225a0866cSChuck Lever 20325a0866cSChuck Lever static __be32 *xdr_time_not_set(__be32 *p) 20425a0866cSChuck Lever { 20525a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 20625a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 20725a0866cSChuck Lever return p; 20825a0866cSChuck Lever } 20925a0866cSChuck Lever 21025a0866cSChuck Lever static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr) 21125a0866cSChuck Lever { 21225a0866cSChuck Lever __be32 *p; 21325a0866cSChuck Lever 21425a0866cSChuck Lever p = xdr_reserve_space(xdr, NFS_sattr_sz << 2); 21525a0866cSChuck Lever 21625a0866cSChuck Lever if (attr->ia_valid & ATTR_MODE) 21725a0866cSChuck Lever *p++ = cpu_to_be32(attr->ia_mode); 21825a0866cSChuck Lever else 21925a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 22025a0866cSChuck Lever if (attr->ia_valid & ATTR_UID) 22125a0866cSChuck Lever *p++ = cpu_to_be32(attr->ia_uid); 22225a0866cSChuck Lever else 22325a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 22425a0866cSChuck Lever if (attr->ia_valid & ATTR_GID) 22525a0866cSChuck Lever *p++ = cpu_to_be32(attr->ia_gid); 22625a0866cSChuck Lever else 22725a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 22825a0866cSChuck Lever if (attr->ia_valid & ATTR_SIZE) 22925a0866cSChuck Lever *p++ = cpu_to_be32((u32)attr->ia_size); 23025a0866cSChuck Lever else 23125a0866cSChuck Lever *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); 23225a0866cSChuck Lever 23325a0866cSChuck Lever if (attr->ia_valid & ATTR_ATIME_SET) 23425a0866cSChuck Lever p = xdr_encode_time(p, &attr->ia_atime); 23525a0866cSChuck Lever else if (attr->ia_valid & ATTR_ATIME) 23625a0866cSChuck Lever p = xdr_encode_current_server_time(p, &attr->ia_atime); 23725a0866cSChuck Lever else 23825a0866cSChuck Lever p = xdr_time_not_set(p); 23925a0866cSChuck Lever if (attr->ia_valid & ATTR_MTIME_SET) 24025a0866cSChuck Lever xdr_encode_time(p, &attr->ia_mtime); 24125a0866cSChuck Lever else if (attr->ia_valid & ATTR_MTIME) 24225a0866cSChuck Lever xdr_encode_current_server_time(p, &attr->ia_mtime); 24325a0866cSChuck Lever else 24425a0866cSChuck Lever xdr_time_not_set(p); 24525a0866cSChuck Lever } 24625a0866cSChuck Lever 24725a0866cSChuck Lever /* 24825a0866cSChuck Lever * 2.3.7. filename 24925a0866cSChuck Lever * 25025a0866cSChuck Lever * typedef string filename<MAXNAMLEN>; 25125a0866cSChuck Lever */ 25225a0866cSChuck Lever static void encode_filename(struct xdr_stream *xdr, 25325a0866cSChuck Lever const char *name, u32 length) 25425a0866cSChuck Lever { 25525a0866cSChuck Lever __be32 *p; 25625a0866cSChuck Lever 25725a0866cSChuck Lever BUG_ON(length > NFS2_MAXNAMLEN); 25825a0866cSChuck Lever p = xdr_reserve_space(xdr, 4 + length); 25925a0866cSChuck Lever xdr_encode_opaque(p, name, length); 26025a0866cSChuck Lever } 26125a0866cSChuck Lever 26225a0866cSChuck Lever /* 26325a0866cSChuck Lever * 2.3.8. path 26425a0866cSChuck Lever * 26525a0866cSChuck Lever * typedef string path<MAXPATHLEN>; 26625a0866cSChuck Lever */ 26725a0866cSChuck Lever static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length) 26825a0866cSChuck Lever { 26925a0866cSChuck Lever __be32 *p; 27025a0866cSChuck Lever 27125a0866cSChuck Lever BUG_ON(length > NFS2_MAXPATHLEN); 27225a0866cSChuck Lever p = xdr_reserve_space(xdr, 4); 27325a0866cSChuck Lever *p = cpu_to_be32(length); 27425a0866cSChuck Lever xdr_write_pages(xdr, pages, 0, length); 27525a0866cSChuck Lever } 27625a0866cSChuck Lever 27725a0866cSChuck Lever /* 27825a0866cSChuck Lever * 2.3.10. diropargs 27925a0866cSChuck Lever * 28025a0866cSChuck Lever * struct diropargs { 28125a0866cSChuck Lever * fhandle dir; 28225a0866cSChuck Lever * filename name; 28325a0866cSChuck Lever * }; 28425a0866cSChuck Lever */ 28525a0866cSChuck Lever static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh, 28625a0866cSChuck Lever const char *name, u32 length) 28725a0866cSChuck Lever { 28825a0866cSChuck Lever encode_fhandle(xdr, fh); 28925a0866cSChuck Lever encode_filename(xdr, name, length); 29025a0866cSChuck Lever } 29125a0866cSChuck Lever 29225a0866cSChuck Lever 29325a0866cSChuck Lever /* 2942d70f533SChuck Lever * NFSv2 XDR encode functions 2952d70f533SChuck Lever * 2962d70f533SChuck Lever * NFSv2 argument types are defined in section 2.2 of RFC 1094: 2972d70f533SChuck Lever * "NFS: Network File System Protocol Specification". 2981da177e4SLinus Torvalds */ 2991da177e4SLinus Torvalds 30025a0866cSChuck Lever static int nfs2_xdr_enc_fhandle(struct rpc_rqst *req, __be32 *p, 30125a0866cSChuck Lever const struct nfs_fh *fh) 30225a0866cSChuck Lever { 30325a0866cSChuck Lever struct xdr_stream xdr; 30425a0866cSChuck Lever 30525a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 30625a0866cSChuck Lever encode_fhandle(&xdr, fh); 30725a0866cSChuck Lever return 0; 30825a0866cSChuck Lever } 30925a0866cSChuck Lever 3101da177e4SLinus Torvalds /* 31125a0866cSChuck Lever * 2.2.3. sattrargs 31225a0866cSChuck Lever * 31325a0866cSChuck Lever * struct sattrargs { 31425a0866cSChuck Lever * fhandle file; 31525a0866cSChuck Lever * sattr attributes; 31625a0866cSChuck Lever * }; 31725a0866cSChuck Lever */ 31825a0866cSChuck Lever static int nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, __be32 *p, 31925a0866cSChuck Lever const struct nfs_sattrargs *args) 32025a0866cSChuck Lever { 32125a0866cSChuck Lever struct xdr_stream xdr; 32225a0866cSChuck Lever 32325a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 32425a0866cSChuck Lever encode_fhandle(&xdr, args->fh); 32525a0866cSChuck Lever encode_sattr(&xdr, args->sattr); 32625a0866cSChuck Lever return 0; 32725a0866cSChuck Lever } 32825a0866cSChuck Lever 32925a0866cSChuck Lever static int nfs2_xdr_enc_diropargs(struct rpc_rqst *req, __be32 *p, 33025a0866cSChuck Lever const struct nfs_diropargs *args) 33125a0866cSChuck Lever { 33225a0866cSChuck Lever struct xdr_stream xdr; 33325a0866cSChuck Lever 33425a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 33525a0866cSChuck Lever encode_diropargs(&xdr, args->fh, args->name, args->len); 33625a0866cSChuck Lever return 0; 33725a0866cSChuck Lever } 33825a0866cSChuck Lever 33925a0866cSChuck Lever static int nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, __be32 *p, 34025a0866cSChuck Lever const struct nfs_readlinkargs *args) 34125a0866cSChuck Lever { 34225a0866cSChuck Lever struct xdr_stream xdr; 34325a0866cSChuck Lever 34425a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 34525a0866cSChuck Lever encode_fhandle(&xdr, args->fh); 34625a0866cSChuck Lever prepare_reply_buffer(req, args->pages, args->pgbase, 34725a0866cSChuck Lever args->pglen, NFS_readlinkres_sz); 34825a0866cSChuck Lever return 0; 34925a0866cSChuck Lever } 35025a0866cSChuck Lever 3514fdc17b2STrond Myklebust /* 35225a0866cSChuck Lever * 2.2.7. readargs 35325a0866cSChuck Lever * 35425a0866cSChuck Lever * struct readargs { 35525a0866cSChuck Lever * fhandle file; 35625a0866cSChuck Lever * unsigned offset; 35725a0866cSChuck Lever * unsigned count; 35825a0866cSChuck Lever * unsigned totalcount; 35925a0866cSChuck Lever * }; 36025a0866cSChuck Lever */ 36125a0866cSChuck Lever static void encode_readargs(struct xdr_stream *xdr, 36225a0866cSChuck Lever const struct nfs_readargs *args) 36325a0866cSChuck Lever { 36425a0866cSChuck Lever u32 offset = args->offset; 36525a0866cSChuck Lever u32 count = args->count; 36625a0866cSChuck Lever __be32 *p; 36725a0866cSChuck Lever 36825a0866cSChuck Lever encode_fhandle(xdr, args->fh); 36925a0866cSChuck Lever 37025a0866cSChuck Lever p = xdr_reserve_space(xdr, 4 + 4 + 4); 37125a0866cSChuck Lever *p++ = cpu_to_be32(offset); 37225a0866cSChuck Lever *p++ = cpu_to_be32(count); 37325a0866cSChuck Lever *p = cpu_to_be32(count); 37425a0866cSChuck Lever } 37525a0866cSChuck Lever 37625a0866cSChuck Lever static int nfs2_xdr_enc_readargs(struct rpc_rqst *req, __be32 *p, 37725a0866cSChuck Lever const struct nfs_readargs *args) 37825a0866cSChuck Lever { 37925a0866cSChuck Lever struct xdr_stream xdr; 38025a0866cSChuck Lever 38125a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 38225a0866cSChuck Lever encode_readargs(&xdr, args); 38325a0866cSChuck Lever prepare_reply_buffer(req, args->pages, args->pgbase, 38425a0866cSChuck Lever args->count, NFS_readres_sz); 38525a0866cSChuck Lever req->rq_rcv_buf.flags |= XDRBUF_READ; 38625a0866cSChuck Lever return 0; 38725a0866cSChuck Lever } 38825a0866cSChuck Lever 38925a0866cSChuck Lever /* 3901da177e4SLinus Torvalds * Decode READ reply 3911da177e4SLinus Torvalds */ 3921da177e4SLinus Torvalds static int 3939d787a75SAl Viro nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res) 3941da177e4SLinus Torvalds { 3951da177e4SLinus Torvalds struct kvec *iov = req->rq_rcv_buf.head; 3966232dbbcSChuck Lever size_t hdrlen; 3976232dbbcSChuck Lever u32 count, recvd; 3986232dbbcSChuck Lever int status; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds if ((status = ntohl(*p++))) 401856dff3dSBenny Halevy return nfs_stat_to_errno(status); 4021da177e4SLinus Torvalds p = xdr_decode_fattr(p, res->fattr); 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds count = ntohl(*p++); 4051da177e4SLinus Torvalds res->eof = 0; 4061da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 4071da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 408fe82a183SChuck Lever dprintk("NFS: READ reply header overflowed:" 4096232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 4101da177e4SLinus Torvalds return -errno_NFSERR_IO; 4111da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 4121da177e4SLinus Torvalds dprintk("NFS: READ header is short. iovec will be shifted.\n"); 4131da177e4SLinus Torvalds xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen); 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds recvd = req->rq_rcv_buf.len - hdrlen; 4171da177e4SLinus Torvalds if (count > recvd) { 418fe82a183SChuck Lever dprintk("NFS: server cheating in read reply: " 4196232dbbcSChuck Lever "count %u > recvd %u\n", count, recvd); 4201da177e4SLinus Torvalds count = recvd; 4211da177e4SLinus Torvalds } 4221da177e4SLinus Torvalds 4236232dbbcSChuck Lever dprintk("RPC: readres OK count %u\n", count); 4241da177e4SLinus Torvalds if (count < res->count) 4251da177e4SLinus Torvalds res->count = count; 4261da177e4SLinus Torvalds 4271da177e4SLinus Torvalds return count; 4281da177e4SLinus Torvalds } 4291da177e4SLinus Torvalds 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds /* 43225a0866cSChuck Lever * 2.2.9. writeargs 43325a0866cSChuck Lever * 43425a0866cSChuck Lever * struct writeargs { 43525a0866cSChuck Lever * fhandle file; 43625a0866cSChuck Lever * unsigned beginoffset; 43725a0866cSChuck Lever * unsigned offset; 43825a0866cSChuck Lever * unsigned totalcount; 43925a0866cSChuck Lever * nfsdata data; 44025a0866cSChuck Lever * }; 44125a0866cSChuck Lever */ 44225a0866cSChuck Lever static void encode_writeargs(struct xdr_stream *xdr, 44325a0866cSChuck Lever const struct nfs_writeargs *args) 44425a0866cSChuck Lever { 44525a0866cSChuck Lever u32 offset = args->offset; 44625a0866cSChuck Lever u32 count = args->count; 44725a0866cSChuck Lever __be32 *p; 44825a0866cSChuck Lever 44925a0866cSChuck Lever encode_fhandle(xdr, args->fh); 45025a0866cSChuck Lever 45125a0866cSChuck Lever p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4); 45225a0866cSChuck Lever *p++ = cpu_to_be32(offset); 45325a0866cSChuck Lever *p++ = cpu_to_be32(offset); 45425a0866cSChuck Lever *p++ = cpu_to_be32(count); 45525a0866cSChuck Lever 45625a0866cSChuck Lever /* nfsdata */ 45725a0866cSChuck Lever *p = cpu_to_be32(count); 45825a0866cSChuck Lever xdr_write_pages(xdr, args->pages, args->pgbase, count); 45925a0866cSChuck Lever } 46025a0866cSChuck Lever 46125a0866cSChuck Lever static int nfs2_xdr_enc_writeargs(struct rpc_rqst *req, __be32 *p, 46225a0866cSChuck Lever const struct nfs_writeargs *args) 46325a0866cSChuck Lever { 46425a0866cSChuck Lever struct xdr_stream xdr; 46525a0866cSChuck Lever 46625a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 46725a0866cSChuck Lever encode_writeargs(&xdr, args); 46825a0866cSChuck Lever xdr.buf->flags |= XDRBUF_WRITE; 46925a0866cSChuck Lever return 0; 47025a0866cSChuck Lever } 47125a0866cSChuck Lever 47225a0866cSChuck Lever /* 47325a0866cSChuck Lever * 2.2.10. createargs 47425a0866cSChuck Lever * 47525a0866cSChuck Lever * struct createargs { 47625a0866cSChuck Lever * diropargs where; 47725a0866cSChuck Lever * sattr attributes; 47825a0866cSChuck Lever * }; 47925a0866cSChuck Lever */ 48025a0866cSChuck Lever static int nfs2_xdr_enc_createargs(struct rpc_rqst *req, __be32 *p, 48125a0866cSChuck Lever const struct nfs_createargs *args) 48225a0866cSChuck Lever { 48325a0866cSChuck Lever struct xdr_stream xdr; 48425a0866cSChuck Lever 48525a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 48625a0866cSChuck Lever encode_diropargs(&xdr, args->fh, args->name, args->len); 48725a0866cSChuck Lever encode_sattr(&xdr, args->sattr); 48825a0866cSChuck Lever return 0; 48925a0866cSChuck Lever } 49025a0866cSChuck Lever 49125a0866cSChuck Lever static int nfs2_xdr_enc_removeargs(struct rpc_rqst *req, __be32 *p, 49225a0866cSChuck Lever const struct nfs_removeargs *args) 49325a0866cSChuck Lever { 49425a0866cSChuck Lever struct xdr_stream xdr; 49525a0866cSChuck Lever 49625a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 49725a0866cSChuck Lever encode_diropargs(&xdr, args->fh, args->name.name, args->name.len); 49825a0866cSChuck Lever return 0; 49925a0866cSChuck Lever } 50025a0866cSChuck Lever 50125a0866cSChuck Lever /* 50225a0866cSChuck Lever * 2.2.12. renameargs 50325a0866cSChuck Lever * 50425a0866cSChuck Lever * struct renameargs { 50525a0866cSChuck Lever * diropargs from; 50625a0866cSChuck Lever * diropargs to; 50725a0866cSChuck Lever * }; 50825a0866cSChuck Lever */ 50925a0866cSChuck Lever static int nfs2_xdr_enc_renameargs(struct rpc_rqst *req, __be32 *p, 51025a0866cSChuck Lever const struct nfs_renameargs *args) 51125a0866cSChuck Lever { 51225a0866cSChuck Lever const struct qstr *old = args->old_name; 51325a0866cSChuck Lever const struct qstr *new = args->new_name; 51425a0866cSChuck Lever struct xdr_stream xdr; 51525a0866cSChuck Lever 51625a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 51725a0866cSChuck Lever encode_diropargs(&xdr, args->old_dir, old->name, old->len); 51825a0866cSChuck Lever encode_diropargs(&xdr, args->new_dir, new->name, new->len); 51925a0866cSChuck Lever return 0; 52025a0866cSChuck Lever } 52125a0866cSChuck Lever 52225a0866cSChuck Lever /* 52325a0866cSChuck Lever * 2.2.13. linkargs 52425a0866cSChuck Lever * 52525a0866cSChuck Lever * struct linkargs { 52625a0866cSChuck Lever * fhandle from; 52725a0866cSChuck Lever * diropargs to; 52825a0866cSChuck Lever * }; 52925a0866cSChuck Lever */ 53025a0866cSChuck Lever static int nfs2_xdr_enc_linkargs(struct rpc_rqst *req, __be32 *p, 53125a0866cSChuck Lever const struct nfs_linkargs *args) 53225a0866cSChuck Lever { 53325a0866cSChuck Lever struct xdr_stream xdr; 53425a0866cSChuck Lever 53525a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 53625a0866cSChuck Lever encode_fhandle(&xdr, args->fromfh); 53725a0866cSChuck Lever encode_diropargs(&xdr, args->tofh, args->toname, args->tolen); 53825a0866cSChuck Lever return 0; 53925a0866cSChuck Lever } 54025a0866cSChuck Lever 54125a0866cSChuck Lever /* 54225a0866cSChuck Lever * 2.2.14. symlinkargs 54325a0866cSChuck Lever * 54425a0866cSChuck Lever * struct symlinkargs { 54525a0866cSChuck Lever * diropargs from; 54625a0866cSChuck Lever * path to; 54725a0866cSChuck Lever * sattr attributes; 54825a0866cSChuck Lever * }; 54925a0866cSChuck Lever */ 55025a0866cSChuck Lever static int nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, __be32 *p, 55125a0866cSChuck Lever const struct nfs_symlinkargs *args) 55225a0866cSChuck Lever { 55325a0866cSChuck Lever struct xdr_stream xdr; 55425a0866cSChuck Lever 55525a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 55625a0866cSChuck Lever encode_diropargs(&xdr, args->fromfh, args->fromname, args->fromlen); 55725a0866cSChuck Lever encode_path(&xdr, args->pages, args->pathlen); 55825a0866cSChuck Lever encode_sattr(&xdr, args->sattr); 55925a0866cSChuck Lever return 0; 56025a0866cSChuck Lever } 56125a0866cSChuck Lever 56225a0866cSChuck Lever /* 56325a0866cSChuck Lever * 2.2.17. readdirargs 56425a0866cSChuck Lever * 56525a0866cSChuck Lever * struct readdirargs { 56625a0866cSChuck Lever * fhandle dir; 56725a0866cSChuck Lever * nfscookie cookie; 56825a0866cSChuck Lever * unsigned count; 56925a0866cSChuck Lever * }; 57025a0866cSChuck Lever */ 57125a0866cSChuck Lever static void encode_readdirargs(struct xdr_stream *xdr, 57225a0866cSChuck Lever const struct nfs_readdirargs *args) 57325a0866cSChuck Lever { 57425a0866cSChuck Lever __be32 *p; 57525a0866cSChuck Lever 57625a0866cSChuck Lever encode_fhandle(xdr, args->fh); 57725a0866cSChuck Lever 57825a0866cSChuck Lever p = xdr_reserve_space(xdr, 4 + 4); 57925a0866cSChuck Lever *p++ = cpu_to_be32(args->cookie); 58025a0866cSChuck Lever *p = cpu_to_be32(args->count); 58125a0866cSChuck Lever } 58225a0866cSChuck Lever 58325a0866cSChuck Lever static int nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, __be32 *p, 58425a0866cSChuck Lever const struct nfs_readdirargs *args) 58525a0866cSChuck Lever { 58625a0866cSChuck Lever struct xdr_stream xdr; 58725a0866cSChuck Lever 58825a0866cSChuck Lever xdr_init_encode(&xdr, &req->rq_snd_buf, p); 58925a0866cSChuck Lever encode_readdirargs(&xdr, args); 59025a0866cSChuck Lever prepare_reply_buffer(req, args->pages, 0, 59125a0866cSChuck Lever args->count, NFS_readdirres_sz); 59225a0866cSChuck Lever return 0; 59325a0866cSChuck Lever } 59425a0866cSChuck Lever 59525a0866cSChuck Lever /* 5961da177e4SLinus Torvalds * Decode the result of a readdir call. 5971da177e4SLinus Torvalds * We're not really decoding anymore, we just leave the buffer untouched 5981da177e4SLinus Torvalds * and only check that it is syntactically correct. 5991da177e4SLinus Torvalds * The real decoding happens in nfs_decode_entry below, called directly 6001da177e4SLinus Torvalds * from nfs_readdir for each entry. 6011da177e4SLinus Torvalds */ 6021da177e4SLinus Torvalds static int 6039d787a75SAl Viro nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy) 6041da177e4SLinus Torvalds { 6051da177e4SLinus Torvalds struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 6061da177e4SLinus Torvalds struct kvec *iov = rcvbuf->head; 6071da177e4SLinus Torvalds struct page **page; 6086232dbbcSChuck Lever size_t hdrlen; 6096232dbbcSChuck Lever unsigned int pglen, recvd; 610ac396128STrond Myklebust int status; 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds if ((status = ntohl(*p++))) 613856dff3dSBenny Halevy return nfs_stat_to_errno(status); 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 6161da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 617fe82a183SChuck Lever dprintk("NFS: READDIR reply header overflowed:" 6186232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 6191da177e4SLinus Torvalds return -errno_NFSERR_IO; 6201da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 6211da177e4SLinus Torvalds dprintk("NFS: READDIR header is short. iovec will be shifted.\n"); 6221da177e4SLinus Torvalds xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 6231da177e4SLinus Torvalds } 6241da177e4SLinus Torvalds 6251da177e4SLinus Torvalds pglen = rcvbuf->page_len; 6261da177e4SLinus Torvalds recvd = rcvbuf->len - hdrlen; 6271da177e4SLinus Torvalds if (pglen > recvd) 6281da177e4SLinus Torvalds pglen = recvd; 6291da177e4SLinus Torvalds page = rcvbuf->pages; 630ac396128STrond Myklebust return pglen; 6311da177e4SLinus Torvalds } 6321da177e4SLinus Torvalds 633babddc72SBryan Schumaker static void print_overflow_msg(const char *func, const struct xdr_stream *xdr) 6341da177e4SLinus Torvalds { 635babddc72SBryan Schumaker dprintk("nfs: %s: prematurely hit end of receive buffer. " 636babddc72SBryan Schumaker "Remaining buffer length is %tu words.\n", 637babddc72SBryan Schumaker func, xdr->end - xdr->p); 638babddc72SBryan Schumaker } 639babddc72SBryan Schumaker 640babddc72SBryan Schumaker __be32 * 64182f2e547SBryan Schumaker nfs_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_server *server, int plus) 642babddc72SBryan Schumaker { 643babddc72SBryan Schumaker __be32 *p; 644babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 4); 645babddc72SBryan Schumaker if (unlikely(!p)) 646babddc72SBryan Schumaker goto out_overflow; 647babddc72SBryan Schumaker if (!ntohl(*p++)) { 648babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 4); 649babddc72SBryan Schumaker if (unlikely(!p)) 650babddc72SBryan Schumaker goto out_overflow; 651babddc72SBryan Schumaker if (!ntohl(*p++)) 6521da177e4SLinus Torvalds return ERR_PTR(-EAGAIN); 6531da177e4SLinus Torvalds entry->eof = 1; 6541da177e4SLinus Torvalds return ERR_PTR(-EBADCOOKIE); 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds 657babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 8); 658babddc72SBryan Schumaker if (unlikely(!p)) 659babddc72SBryan Schumaker goto out_overflow; 660babddc72SBryan Schumaker 6611da177e4SLinus Torvalds entry->ino = ntohl(*p++); 6621da177e4SLinus Torvalds entry->len = ntohl(*p++); 663babddc72SBryan Schumaker 664babddc72SBryan Schumaker p = xdr_inline_decode(xdr, entry->len + 4); 665babddc72SBryan Schumaker if (unlikely(!p)) 666babddc72SBryan Schumaker goto out_overflow; 6671da177e4SLinus Torvalds entry->name = (const char *) p; 6681da177e4SLinus Torvalds p += XDR_QUADLEN(entry->len); 6691da177e4SLinus Torvalds entry->prev_cookie = entry->cookie; 6701da177e4SLinus Torvalds entry->cookie = ntohl(*p++); 671babddc72SBryan Schumaker 6720b26a0bfSTrond Myklebust entry->d_type = DT_UNKNOWN; 6730b26a0bfSTrond Myklebust 674babddc72SBryan Schumaker p = xdr_inline_peek(xdr, 8); 675babddc72SBryan Schumaker if (p != NULL) 6761da177e4SLinus Torvalds entry->eof = !p[0] && p[1]; 677babddc72SBryan Schumaker else 678babddc72SBryan Schumaker entry->eof = 0; 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds return p; 681babddc72SBryan Schumaker 682babddc72SBryan Schumaker out_overflow: 683babddc72SBryan Schumaker print_overflow_msg(__func__, xdr); 684463a376eSTrond Myklebust return ERR_PTR(-EAGAIN); 6851da177e4SLinus Torvalds } 6861da177e4SLinus Torvalds 6871da177e4SLinus Torvalds /* 6881da177e4SLinus Torvalds * NFS XDR decode functions 6891da177e4SLinus Torvalds */ 6901da177e4SLinus Torvalds /* 6911da177e4SLinus Torvalds * Decode simple status reply 6921da177e4SLinus Torvalds */ 6931da177e4SLinus Torvalds static int 6949d787a75SAl Viro nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy) 6951da177e4SLinus Torvalds { 6961da177e4SLinus Torvalds int status; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds if ((status = ntohl(*p++)) != 0) 699856dff3dSBenny Halevy status = nfs_stat_to_errno(status); 7001da177e4SLinus Torvalds return status; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 7031da177e4SLinus Torvalds /* 7041da177e4SLinus Torvalds * Decode attrstat reply 7051da177e4SLinus Torvalds * GETATTR, SETATTR, WRITE 7061da177e4SLinus Torvalds */ 7071da177e4SLinus Torvalds static int 7089d787a75SAl Viro nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 7091da177e4SLinus Torvalds { 7101da177e4SLinus Torvalds int status; 7111da177e4SLinus Torvalds 7121da177e4SLinus Torvalds if ((status = ntohl(*p++))) 713856dff3dSBenny Halevy return nfs_stat_to_errno(status); 7141da177e4SLinus Torvalds xdr_decode_fattr(p, fattr); 7151da177e4SLinus Torvalds return 0; 7161da177e4SLinus Torvalds } 7171da177e4SLinus Torvalds 7181da177e4SLinus Torvalds /* 7191da177e4SLinus Torvalds * Decode diropres reply 7201da177e4SLinus Torvalds * LOOKUP, CREATE, MKDIR 7211da177e4SLinus Torvalds */ 7221da177e4SLinus Torvalds static int 7239d787a75SAl Viro nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res) 7241da177e4SLinus Torvalds { 7251da177e4SLinus Torvalds int status; 7261da177e4SLinus Torvalds 7271da177e4SLinus Torvalds if ((status = ntohl(*p++))) 728856dff3dSBenny Halevy return nfs_stat_to_errno(status); 7291da177e4SLinus Torvalds p = xdr_decode_fhandle(p, res->fh); 7301da177e4SLinus Torvalds xdr_decode_fattr(p, res->fattr); 7311da177e4SLinus Torvalds return 0; 7321da177e4SLinus Torvalds } 7331da177e4SLinus Torvalds 7341da177e4SLinus Torvalds /* 7351da177e4SLinus Torvalds * Decode READLINK reply 7361da177e4SLinus Torvalds */ 7371da177e4SLinus Torvalds static int 7389d787a75SAl Viro nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy) 7391da177e4SLinus Torvalds { 7401da177e4SLinus Torvalds struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 7411da177e4SLinus Torvalds struct kvec *iov = rcvbuf->head; 7426232dbbcSChuck Lever size_t hdrlen; 7436232dbbcSChuck Lever u32 len, recvd; 7441da177e4SLinus Torvalds int status; 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds if ((status = ntohl(*p++))) 747856dff3dSBenny Halevy return nfs_stat_to_errno(status); 7481da177e4SLinus Torvalds /* Convert length of symlink */ 7491da177e4SLinus Torvalds len = ntohl(*p++); 7506232dbbcSChuck Lever if (len >= rcvbuf->page_len) { 751fe82a183SChuck Lever dprintk("nfs: server returned giant symlink!\n"); 7521da177e4SLinus Torvalds return -ENAMETOOLONG; 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 7551da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 756fe82a183SChuck Lever dprintk("NFS: READLINK reply header overflowed:" 7576232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 7581da177e4SLinus Torvalds return -errno_NFSERR_IO; 7591da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 7601da177e4SLinus Torvalds dprintk("NFS: READLINK header is short. iovec will be shifted.\n"); 7611da177e4SLinus Torvalds xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 7621da177e4SLinus Torvalds } 7631da177e4SLinus Torvalds recvd = req->rq_rcv_buf.len - hdrlen; 7641da177e4SLinus Torvalds if (recvd < len) { 765fe82a183SChuck Lever dprintk("NFS: server cheating in readlink reply: " 7661da177e4SLinus Torvalds "count %u > recvd %u\n", len, recvd); 7671da177e4SLinus Torvalds return -EIO; 7681da177e4SLinus Torvalds } 7691da177e4SLinus Torvalds 770b4687da7SChuck Lever xdr_terminate_string(rcvbuf, len); 7711da177e4SLinus Torvalds return 0; 7721da177e4SLinus Torvalds } 7731da177e4SLinus Torvalds 7741da177e4SLinus Torvalds /* 7751da177e4SLinus Torvalds * Decode WRITE reply 7761da177e4SLinus Torvalds */ 7771da177e4SLinus Torvalds static int 7789d787a75SAl Viro nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 7791da177e4SLinus Torvalds { 7801da177e4SLinus Torvalds res->verf->committed = NFS_FILE_SYNC; 7811da177e4SLinus Torvalds return nfs_xdr_attrstat(req, p, res->fattr); 7821da177e4SLinus Torvalds } 7831da177e4SLinus Torvalds 7841da177e4SLinus Torvalds /* 7851da177e4SLinus Torvalds * Decode STATFS reply 7861da177e4SLinus Torvalds */ 7871da177e4SLinus Torvalds static int 7889d787a75SAl Viro nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res) 7891da177e4SLinus Torvalds { 7901da177e4SLinus Torvalds int status; 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds if ((status = ntohl(*p++))) 793856dff3dSBenny Halevy return nfs_stat_to_errno(status); 7941da177e4SLinus Torvalds 7951da177e4SLinus Torvalds res->tsize = ntohl(*p++); 7961da177e4SLinus Torvalds res->bsize = ntohl(*p++); 7971da177e4SLinus Torvalds res->blocks = ntohl(*p++); 7981da177e4SLinus Torvalds res->bfree = ntohl(*p++); 7991da177e4SLinus Torvalds res->bavail = ntohl(*p++); 8001da177e4SLinus Torvalds return 0; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds 8031da177e4SLinus Torvalds /* 8041da177e4SLinus Torvalds * We need to translate between nfs status return values and 8051da177e4SLinus Torvalds * the local errno values which may not be the same. 8061da177e4SLinus Torvalds */ 8071da177e4SLinus Torvalds static struct { 8081da177e4SLinus Torvalds int stat; 8091da177e4SLinus Torvalds int errno; 8101da177e4SLinus Torvalds } nfs_errtbl[] = { 8111da177e4SLinus Torvalds { NFS_OK, 0 }, 812856dff3dSBenny Halevy { NFSERR_PERM, -EPERM }, 813856dff3dSBenny Halevy { NFSERR_NOENT, -ENOENT }, 814856dff3dSBenny Halevy { NFSERR_IO, -errno_NFSERR_IO}, 815856dff3dSBenny Halevy { NFSERR_NXIO, -ENXIO }, 816856dff3dSBenny Halevy /* { NFSERR_EAGAIN, -EAGAIN }, */ 817856dff3dSBenny Halevy { NFSERR_ACCES, -EACCES }, 818856dff3dSBenny Halevy { NFSERR_EXIST, -EEXIST }, 819856dff3dSBenny Halevy { NFSERR_XDEV, -EXDEV }, 820856dff3dSBenny Halevy { NFSERR_NODEV, -ENODEV }, 821856dff3dSBenny Halevy { NFSERR_NOTDIR, -ENOTDIR }, 822856dff3dSBenny Halevy { NFSERR_ISDIR, -EISDIR }, 823856dff3dSBenny Halevy { NFSERR_INVAL, -EINVAL }, 824856dff3dSBenny Halevy { NFSERR_FBIG, -EFBIG }, 825856dff3dSBenny Halevy { NFSERR_NOSPC, -ENOSPC }, 826856dff3dSBenny Halevy { NFSERR_ROFS, -EROFS }, 827856dff3dSBenny Halevy { NFSERR_MLINK, -EMLINK }, 828856dff3dSBenny Halevy { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, 829856dff3dSBenny Halevy { NFSERR_NOTEMPTY, -ENOTEMPTY }, 830856dff3dSBenny Halevy { NFSERR_DQUOT, -EDQUOT }, 831856dff3dSBenny Halevy { NFSERR_STALE, -ESTALE }, 832856dff3dSBenny Halevy { NFSERR_REMOTE, -EREMOTE }, 8331da177e4SLinus Torvalds #ifdef EWFLUSH 834856dff3dSBenny Halevy { NFSERR_WFLUSH, -EWFLUSH }, 8351da177e4SLinus Torvalds #endif 836856dff3dSBenny Halevy { NFSERR_BADHANDLE, -EBADHANDLE }, 837856dff3dSBenny Halevy { NFSERR_NOT_SYNC, -ENOTSYNC }, 838856dff3dSBenny Halevy { NFSERR_BAD_COOKIE, -EBADCOOKIE }, 839856dff3dSBenny Halevy { NFSERR_NOTSUPP, -ENOTSUPP }, 840856dff3dSBenny Halevy { NFSERR_TOOSMALL, -ETOOSMALL }, 841fdcb4577STrond Myklebust { NFSERR_SERVERFAULT, -EREMOTEIO }, 842856dff3dSBenny Halevy { NFSERR_BADTYPE, -EBADTYPE }, 843856dff3dSBenny Halevy { NFSERR_JUKEBOX, -EJUKEBOX }, 844856dff3dSBenny Halevy { -1, -EIO } 8451da177e4SLinus Torvalds }; 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds /* 8481da177e4SLinus Torvalds * Convert an NFS error code to a local one. 8491da177e4SLinus Torvalds * This one is used jointly by NFSv2 and NFSv3. 8501da177e4SLinus Torvalds */ 8511da177e4SLinus Torvalds int 8521da177e4SLinus Torvalds nfs_stat_to_errno(int stat) 8531da177e4SLinus Torvalds { 8541da177e4SLinus Torvalds int i; 8551da177e4SLinus Torvalds 8561da177e4SLinus Torvalds for (i = 0; nfs_errtbl[i].stat != -1; i++) { 8571da177e4SLinus Torvalds if (nfs_errtbl[i].stat == stat) 8581da177e4SLinus Torvalds return nfs_errtbl[i].errno; 8591da177e4SLinus Torvalds } 860fe82a183SChuck Lever dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat); 8611da177e4SLinus Torvalds return nfs_errtbl[i].errno; 8621da177e4SLinus Torvalds } 8631da177e4SLinus Torvalds 8641da177e4SLinus Torvalds #define PROC(proc, argtype, restype, timer) \ 8651da177e4SLinus Torvalds [NFSPROC_##proc] = { \ 8661da177e4SLinus Torvalds .p_proc = NFSPROC_##proc, \ 86725a0866cSChuck Lever .p_encode = (kxdrproc_t)nfs2_xdr_enc_##argtype, \ 8681da177e4SLinus Torvalds .p_decode = (kxdrproc_t) nfs_xdr_##restype, \ 8692bea90d4SChuck Lever .p_arglen = NFS_##argtype##_sz, \ 8702bea90d4SChuck Lever .p_replen = NFS_##restype##_sz, \ 871cc0175c1SChuck Lever .p_timer = timer, \ 872cc0175c1SChuck Lever .p_statidx = NFSPROC_##proc, \ 873cc0175c1SChuck Lever .p_name = #proc, \ 8741da177e4SLinus Torvalds } 8751da177e4SLinus Torvalds struct rpc_procinfo nfs_procedures[] = { 8761da177e4SLinus Torvalds PROC(GETATTR, fhandle, attrstat, 1), 8771da177e4SLinus Torvalds PROC(SETATTR, sattrargs, attrstat, 0), 8781da177e4SLinus Torvalds PROC(LOOKUP, diropargs, diropres, 2), 8791da177e4SLinus Torvalds PROC(READLINK, readlinkargs, readlinkres, 3), 8801da177e4SLinus Torvalds PROC(READ, readargs, readres, 3), 8811da177e4SLinus Torvalds PROC(WRITE, writeargs, writeres, 4), 8821da177e4SLinus Torvalds PROC(CREATE, createargs, diropres, 0), 8834fdc17b2STrond Myklebust PROC(REMOVE, removeargs, stat, 0), 8841da177e4SLinus Torvalds PROC(RENAME, renameargs, stat, 0), 8851da177e4SLinus Torvalds PROC(LINK, linkargs, stat, 0), 8861da177e4SLinus Torvalds PROC(SYMLINK, symlinkargs, stat, 0), 8871da177e4SLinus Torvalds PROC(MKDIR, createargs, diropres, 0), 8881da177e4SLinus Torvalds PROC(RMDIR, diropargs, stat, 0), 8891da177e4SLinus Torvalds PROC(READDIR, readdirargs, readdirres, 3), 8901da177e4SLinus Torvalds PROC(STATFS, fhandle, statfsres, 0), 8911da177e4SLinus Torvalds }; 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds struct rpc_version nfs_version2 = { 8941da177e4SLinus Torvalds .number = 2, 895e8c96f8cSTobias Klauser .nrprocs = ARRAY_SIZE(nfs_procedures), 8961da177e4SLinus Torvalds .procs = nfs_procedures 8971da177e4SLinus Torvalds }; 898