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 641da177e4SLinus Torvalds /* 651da177e4SLinus Torvalds * Common NFS XDR functions as inlines 661da177e4SLinus Torvalds */ 679d787a75SAl Viro static inline __be32 * 684fdc17b2STrond Myklebust xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fhandle) 691da177e4SLinus Torvalds { 701da177e4SLinus Torvalds memcpy(p, fhandle->data, NFS2_FHSIZE); 711da177e4SLinus Torvalds return p + XDR_QUADLEN(NFS2_FHSIZE); 721da177e4SLinus Torvalds } 731da177e4SLinus Torvalds 749d787a75SAl Viro static inline __be32 * 759d787a75SAl Viro xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle) 761da177e4SLinus Torvalds { 771da177e4SLinus Torvalds /* NFSv2 handles have a fixed length */ 781da177e4SLinus Torvalds fhandle->size = NFS2_FHSIZE; 791da177e4SLinus Torvalds memcpy(fhandle->data, p, NFS2_FHSIZE); 801da177e4SLinus Torvalds return p + XDR_QUADLEN(NFS2_FHSIZE); 811da177e4SLinus Torvalds } 821da177e4SLinus Torvalds 839d787a75SAl Viro static inline __be32* 849d787a75SAl Viro xdr_encode_time(__be32 *p, struct timespec *timep) 851da177e4SLinus Torvalds { 861da177e4SLinus Torvalds *p++ = htonl(timep->tv_sec); 871da177e4SLinus Torvalds /* Convert nanoseconds into microseconds */ 881da177e4SLinus Torvalds *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0); 891da177e4SLinus Torvalds return p; 901da177e4SLinus Torvalds } 911da177e4SLinus Torvalds 929d787a75SAl Viro static inline __be32* 939d787a75SAl Viro xdr_encode_current_server_time(__be32 *p, struct timespec *timep) 941da177e4SLinus Torvalds { 951da177e4SLinus Torvalds /* 961da177e4SLinus Torvalds * Passing the invalid value useconds=1000000 is a 971da177e4SLinus Torvalds * Sun convention for "set to current server time". 981da177e4SLinus Torvalds * It's needed to make permissions checks for the 991da177e4SLinus Torvalds * "touch" program across v2 mounts to Solaris and 1001da177e4SLinus Torvalds * Irix boxes work correctly. See description of 1011da177e4SLinus Torvalds * sattr in section 6.1 of "NFS Illustrated" by 1021da177e4SLinus Torvalds * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5 1031da177e4SLinus Torvalds */ 1041da177e4SLinus Torvalds *p++ = htonl(timep->tv_sec); 1051da177e4SLinus Torvalds *p++ = htonl(1000000); 1061da177e4SLinus Torvalds return p; 1071da177e4SLinus Torvalds } 1081da177e4SLinus Torvalds 1099d787a75SAl Viro static inline __be32* 1109d787a75SAl Viro xdr_decode_time(__be32 *p, struct timespec *timep) 1111da177e4SLinus Torvalds { 1121da177e4SLinus Torvalds timep->tv_sec = ntohl(*p++); 1131da177e4SLinus Torvalds /* Convert microseconds into nanoseconds */ 1141da177e4SLinus Torvalds timep->tv_nsec = ntohl(*p++) * 1000; 1151da177e4SLinus Torvalds return p; 1161da177e4SLinus Torvalds } 1171da177e4SLinus Torvalds 1189d787a75SAl Viro static __be32 * 1199d787a75SAl Viro xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr) 1201da177e4SLinus Torvalds { 121bca79478STrond Myklebust u32 rdev, type; 122bca79478STrond Myklebust type = ntohl(*p++); 1231da177e4SLinus Torvalds fattr->mode = ntohl(*p++); 1241da177e4SLinus Torvalds fattr->nlink = ntohl(*p++); 1251da177e4SLinus Torvalds fattr->uid = ntohl(*p++); 1261da177e4SLinus Torvalds fattr->gid = ntohl(*p++); 1271da177e4SLinus Torvalds fattr->size = ntohl(*p++); 1281da177e4SLinus Torvalds fattr->du.nfs2.blocksize = ntohl(*p++); 1291da177e4SLinus Torvalds rdev = ntohl(*p++); 1301da177e4SLinus Torvalds fattr->du.nfs2.blocks = ntohl(*p++); 1318b4bdcf8STrond Myklebust fattr->fsid.major = ntohl(*p++); 1328b4bdcf8STrond Myklebust fattr->fsid.minor = 0; 1331da177e4SLinus Torvalds fattr->fileid = ntohl(*p++); 1341da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->atime); 1351da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->mtime); 1361da177e4SLinus Torvalds p = xdr_decode_time(p, &fattr->ctime); 1379e6e70f8STrond Myklebust fattr->valid |= NFS_ATTR_FATTR_V2; 1381da177e4SLinus Torvalds fattr->rdev = new_decode_dev(rdev); 139bca79478STrond Myklebust if (type == NFCHR && rdev == NFS2_FIFO_DEV) { 1401da177e4SLinus Torvalds fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; 1411da177e4SLinus Torvalds fattr->rdev = 0; 1421da177e4SLinus Torvalds } 1431da177e4SLinus Torvalds return p; 1441da177e4SLinus Torvalds } 1451da177e4SLinus Torvalds 1469d787a75SAl Viro static inline __be32 * 1479d787a75SAl Viro xdr_encode_sattr(__be32 *p, struct iattr *attr) 1481da177e4SLinus Torvalds { 1499d787a75SAl Viro const __be32 not_set = __constant_htonl(0xFFFFFFFF); 150eadb8c14STrond Myklebust 151eadb8c14STrond Myklebust *p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set; 152eadb8c14STrond Myklebust *p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set; 153eadb8c14STrond Myklebust *p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set; 154eadb8c14STrond Myklebust *p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds if (attr->ia_valid & ATTR_ATIME_SET) { 1571da177e4SLinus Torvalds p = xdr_encode_time(p, &attr->ia_atime); 1581da177e4SLinus Torvalds } else if (attr->ia_valid & ATTR_ATIME) { 1591da177e4SLinus Torvalds p = xdr_encode_current_server_time(p, &attr->ia_atime); 1601da177e4SLinus Torvalds } else { 161eadb8c14STrond Myklebust *p++ = not_set; 162eadb8c14STrond Myklebust *p++ = not_set; 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds if (attr->ia_valid & ATTR_MTIME_SET) { 1661da177e4SLinus Torvalds p = xdr_encode_time(p, &attr->ia_mtime); 1671da177e4SLinus Torvalds } else if (attr->ia_valid & ATTR_MTIME) { 1681da177e4SLinus Torvalds p = xdr_encode_current_server_time(p, &attr->ia_mtime); 1691da177e4SLinus Torvalds } else { 170eadb8c14STrond Myklebust *p++ = not_set; 171eadb8c14STrond Myklebust *p++ = not_set; 1721da177e4SLinus Torvalds } 1731da177e4SLinus Torvalds return p; 1741da177e4SLinus Torvalds } 1751da177e4SLinus Torvalds 1761da177e4SLinus Torvalds /* 1771da177e4SLinus Torvalds * NFS encode functions 1781da177e4SLinus Torvalds */ 1791da177e4SLinus Torvalds /* 1801da177e4SLinus Torvalds * Encode file handle argument 1811da177e4SLinus Torvalds * GETATTR, READLINK, STATFS 1821da177e4SLinus Torvalds */ 1831da177e4SLinus Torvalds static int 1849d787a75SAl Viro nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh) 1851da177e4SLinus Torvalds { 1861da177e4SLinus Torvalds p = xdr_encode_fhandle(p, fh); 1871da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 1881da177e4SLinus Torvalds return 0; 1891da177e4SLinus Torvalds } 1901da177e4SLinus Torvalds 1911da177e4SLinus Torvalds /* 1921da177e4SLinus Torvalds * Encode SETATTR arguments 1931da177e4SLinus Torvalds */ 1941da177e4SLinus Torvalds static int 1959d787a75SAl Viro nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args) 1961da177e4SLinus Torvalds { 1971da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 1981da177e4SLinus Torvalds p = xdr_encode_sattr(p, args->sattr); 1991da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 2001da177e4SLinus Torvalds return 0; 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /* 2041da177e4SLinus Torvalds * Encode directory ops argument 2054fdc17b2STrond Myklebust * LOOKUP, RMDIR 2061da177e4SLinus Torvalds */ 2071da177e4SLinus Torvalds static int 2089d787a75SAl Viro nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args) 2091da177e4SLinus Torvalds { 2101da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 2111da177e4SLinus Torvalds p = xdr_encode_array(p, args->name, args->len); 2121da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 2131da177e4SLinus Torvalds return 0; 2141da177e4SLinus Torvalds } 2151da177e4SLinus Torvalds 2161da177e4SLinus Torvalds /* 2174fdc17b2STrond Myklebust * Encode REMOVE argument 2184fdc17b2STrond Myklebust */ 2194fdc17b2STrond Myklebust static int 2204fdc17b2STrond Myklebust nfs_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args) 2214fdc17b2STrond Myklebust { 2224fdc17b2STrond Myklebust p = xdr_encode_fhandle(p, args->fh); 2234fdc17b2STrond Myklebust p = xdr_encode_array(p, args->name.name, args->name.len); 2244fdc17b2STrond Myklebust req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 2254fdc17b2STrond Myklebust return 0; 2264fdc17b2STrond Myklebust } 2274fdc17b2STrond Myklebust 2284fdc17b2STrond Myklebust /* 2291da177e4SLinus Torvalds * Arguments to a READ call. Since we read data directly into the page 2301da177e4SLinus Torvalds * cache, we also set up the reply iovec here so that iov[1] points 2311da177e4SLinus Torvalds * exactly to the page we want to fetch. 2321da177e4SLinus Torvalds */ 2331da177e4SLinus Torvalds static int 2349d787a75SAl Viro nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args) 2351da177e4SLinus Torvalds { 236a17c2153STrond Myklebust struct rpc_auth *auth = req->rq_cred->cr_auth; 2371da177e4SLinus Torvalds unsigned int replen; 2381da177e4SLinus Torvalds u32 offset = (u32)args->offset; 2391da177e4SLinus Torvalds u32 count = args->count; 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 2421da177e4SLinus Torvalds *p++ = htonl(offset); 2431da177e4SLinus Torvalds *p++ = htonl(count); 2441da177e4SLinus Torvalds *p++ = htonl(count); 2451da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 2461da177e4SLinus Torvalds 2471da177e4SLinus Torvalds /* Inline the page array */ 2481da177e4SLinus Torvalds replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2; 2491da177e4SLinus Torvalds xdr_inline_pages(&req->rq_rcv_buf, replen, 2501da177e4SLinus Torvalds args->pages, args->pgbase, count); 2514f22ccc3S\"Talpey, Thomas\ req->rq_rcv_buf.flags |= XDRBUF_READ; 2521da177e4SLinus Torvalds return 0; 2531da177e4SLinus Torvalds } 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* 2561da177e4SLinus Torvalds * Decode READ reply 2571da177e4SLinus Torvalds */ 2581da177e4SLinus Torvalds static int 2599d787a75SAl Viro nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res) 2601da177e4SLinus Torvalds { 2611da177e4SLinus Torvalds struct kvec *iov = req->rq_rcv_buf.head; 2626232dbbcSChuck Lever size_t hdrlen; 2636232dbbcSChuck Lever u32 count, recvd; 2646232dbbcSChuck Lever int status; 2651da177e4SLinus Torvalds 2661da177e4SLinus Torvalds if ((status = ntohl(*p++))) 267856dff3dSBenny Halevy return nfs_stat_to_errno(status); 2681da177e4SLinus Torvalds p = xdr_decode_fattr(p, res->fattr); 2691da177e4SLinus Torvalds 2701da177e4SLinus Torvalds count = ntohl(*p++); 2711da177e4SLinus Torvalds res->eof = 0; 2721da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 2731da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 274fe82a183SChuck Lever dprintk("NFS: READ reply header overflowed:" 2756232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 2761da177e4SLinus Torvalds return -errno_NFSERR_IO; 2771da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 2781da177e4SLinus Torvalds dprintk("NFS: READ header is short. iovec will be shifted.\n"); 2791da177e4SLinus Torvalds xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen); 2801da177e4SLinus Torvalds } 2811da177e4SLinus Torvalds 2821da177e4SLinus Torvalds recvd = req->rq_rcv_buf.len - hdrlen; 2831da177e4SLinus Torvalds if (count > recvd) { 284fe82a183SChuck Lever dprintk("NFS: server cheating in read reply: " 2856232dbbcSChuck Lever "count %u > recvd %u\n", count, recvd); 2861da177e4SLinus Torvalds count = recvd; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2896232dbbcSChuck Lever dprintk("RPC: readres OK count %u\n", count); 2901da177e4SLinus Torvalds if (count < res->count) 2911da177e4SLinus Torvalds res->count = count; 2921da177e4SLinus Torvalds 2931da177e4SLinus Torvalds return count; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds /* 2981da177e4SLinus Torvalds * Write arguments. Splice the buffer to be written into the iovec. 2991da177e4SLinus Torvalds */ 3001da177e4SLinus Torvalds static int 3019d787a75SAl Viro nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) 3021da177e4SLinus Torvalds { 3031da177e4SLinus Torvalds struct xdr_buf *sndbuf = &req->rq_snd_buf; 3041da177e4SLinus Torvalds u32 offset = (u32)args->offset; 3051da177e4SLinus Torvalds u32 count = args->count; 3061da177e4SLinus Torvalds 3071da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 3081da177e4SLinus Torvalds *p++ = htonl(offset); 3091da177e4SLinus Torvalds *p++ = htonl(offset); 3101da177e4SLinus Torvalds *p++ = htonl(count); 3111da177e4SLinus Torvalds *p++ = htonl(count); 3121da177e4SLinus Torvalds sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); 3131da177e4SLinus Torvalds 3141da177e4SLinus Torvalds /* Copy the page array */ 3151da177e4SLinus Torvalds xdr_encode_pages(sndbuf, args->pages, args->pgbase, count); 3164f22ccc3S\"Talpey, Thomas\ sndbuf->flags |= XDRBUF_WRITE; 3171da177e4SLinus Torvalds return 0; 3181da177e4SLinus Torvalds } 3191da177e4SLinus Torvalds 3201da177e4SLinus Torvalds /* 3211da177e4SLinus Torvalds * Encode create arguments 3221da177e4SLinus Torvalds * CREATE, MKDIR 3231da177e4SLinus Torvalds */ 3241da177e4SLinus Torvalds static int 3259d787a75SAl Viro nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args) 3261da177e4SLinus Torvalds { 3271da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 3281da177e4SLinus Torvalds p = xdr_encode_array(p, args->name, args->len); 3291da177e4SLinus Torvalds p = xdr_encode_sattr(p, args->sattr); 3301da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 3311da177e4SLinus Torvalds return 0; 3321da177e4SLinus Torvalds } 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds /* 3351da177e4SLinus Torvalds * Encode RENAME arguments 3361da177e4SLinus Torvalds */ 3371da177e4SLinus Torvalds static int 3389d787a75SAl Viro nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args) 3391da177e4SLinus Torvalds { 340920769f0SJeff Layton p = xdr_encode_fhandle(p, args->old_dir); 341920769f0SJeff Layton p = xdr_encode_array(p, args->old_name->name, args->old_name->len); 342920769f0SJeff Layton p = xdr_encode_fhandle(p, args->new_dir); 343920769f0SJeff Layton p = xdr_encode_array(p, args->new_name->name, args->new_name->len); 3441da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 3451da177e4SLinus Torvalds return 0; 3461da177e4SLinus Torvalds } 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds /* 3491da177e4SLinus Torvalds * Encode LINK arguments 3501da177e4SLinus Torvalds */ 3511da177e4SLinus Torvalds static int 3529d787a75SAl Viro nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args) 3531da177e4SLinus Torvalds { 3541da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fromfh); 3551da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->tofh); 3561da177e4SLinus Torvalds p = xdr_encode_array(p, args->toname, args->tolen); 3571da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 3581da177e4SLinus Torvalds return 0; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds /* 3621da177e4SLinus Torvalds * Encode SYMLINK arguments 3631da177e4SLinus Torvalds */ 3641da177e4SLinus Torvalds static int 3659d787a75SAl Viro nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args) 3661da177e4SLinus Torvalds { 36794a6d753SChuck Lever struct xdr_buf *sndbuf = &req->rq_snd_buf; 36894a6d753SChuck Lever size_t pad; 36994a6d753SChuck Lever 3701da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fromfh); 3711da177e4SLinus Torvalds p = xdr_encode_array(p, args->fromname, args->fromlen); 37294a6d753SChuck Lever *p++ = htonl(args->pathlen); 37394a6d753SChuck Lever sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); 37494a6d753SChuck Lever 37594a6d753SChuck Lever xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen); 37694a6d753SChuck Lever 37794a6d753SChuck Lever /* 37894a6d753SChuck Lever * xdr_encode_pages may have added a few bytes to ensure the 37994a6d753SChuck Lever * pathname ends on a 4-byte boundary. Start encoding the 38094a6d753SChuck Lever * attributes after the pad bytes. 38194a6d753SChuck Lever */ 38294a6d753SChuck Lever pad = sndbuf->tail->iov_len; 38394a6d753SChuck Lever if (pad > 0) 38494a6d753SChuck Lever p++; 3851da177e4SLinus Torvalds p = xdr_encode_sattr(p, args->sattr); 38694a6d753SChuck Lever sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad; 3871da177e4SLinus Torvalds return 0; 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds /* 3911da177e4SLinus Torvalds * Encode arguments to readdir call 3921da177e4SLinus Torvalds */ 3931da177e4SLinus Torvalds static int 3949d787a75SAl Viro nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args) 3951da177e4SLinus Torvalds { 396a17c2153STrond Myklebust struct rpc_auth *auth = req->rq_cred->cr_auth; 3971da177e4SLinus Torvalds unsigned int replen; 3981da177e4SLinus Torvalds u32 count = args->count; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 4011da177e4SLinus Torvalds *p++ = htonl(args->cookie); 4021da177e4SLinus Torvalds *p++ = htonl(count); /* see above */ 4031da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 4041da177e4SLinus Torvalds 4051da177e4SLinus Torvalds /* Inline the page array */ 4061da177e4SLinus Torvalds replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2; 4071da177e4SLinus Torvalds xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count); 4081da177e4SLinus Torvalds return 0; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds 4111da177e4SLinus Torvalds /* 4121da177e4SLinus Torvalds * Decode the result of a readdir call. 4131da177e4SLinus Torvalds * We're not really decoding anymore, we just leave the buffer untouched 4141da177e4SLinus Torvalds * and only check that it is syntactically correct. 4151da177e4SLinus Torvalds * The real decoding happens in nfs_decode_entry below, called directly 4161da177e4SLinus Torvalds * from nfs_readdir for each entry. 4171da177e4SLinus Torvalds */ 4181da177e4SLinus Torvalds static int 4199d787a75SAl Viro nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy) 4201da177e4SLinus Torvalds { 4211da177e4SLinus Torvalds struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 4221da177e4SLinus Torvalds struct kvec *iov = rcvbuf->head; 4231da177e4SLinus Torvalds struct page **page; 4246232dbbcSChuck Lever size_t hdrlen; 4256232dbbcSChuck Lever unsigned int pglen, recvd; 426caa02bd5SJeff Layton int status, nr = 0; 4271da177e4SLinus Torvalds 4281da177e4SLinus Torvalds if ((status = ntohl(*p++))) 429856dff3dSBenny Halevy return nfs_stat_to_errno(status); 4301da177e4SLinus Torvalds 4311da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 4321da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 433fe82a183SChuck Lever dprintk("NFS: READDIR reply header overflowed:" 4346232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 4351da177e4SLinus Torvalds return -errno_NFSERR_IO; 4361da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 4371da177e4SLinus Torvalds dprintk("NFS: READDIR header is short. iovec will be shifted.\n"); 4381da177e4SLinus Torvalds xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 4391da177e4SLinus Torvalds } 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds pglen = rcvbuf->page_len; 4421da177e4SLinus Torvalds recvd = rcvbuf->len - hdrlen; 4431da177e4SLinus Torvalds if (pglen > recvd) 4441da177e4SLinus Torvalds pglen = recvd; 4451da177e4SLinus Torvalds page = rcvbuf->pages; 4461da177e4SLinus Torvalds return nr; 4471da177e4SLinus Torvalds } 4481da177e4SLinus Torvalds 449babddc72SBryan Schumaker static void print_overflow_msg(const char *func, const struct xdr_stream *xdr) 4501da177e4SLinus Torvalds { 451babddc72SBryan Schumaker dprintk("nfs: %s: prematurely hit end of receive buffer. " 452babddc72SBryan Schumaker "Remaining buffer length is %tu words.\n", 453babddc72SBryan Schumaker func, xdr->end - xdr->p); 454babddc72SBryan Schumaker } 455babddc72SBryan Schumaker 456babddc72SBryan Schumaker __be32 * 45782f2e547SBryan Schumaker nfs_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, struct nfs_server *server, int plus) 458babddc72SBryan Schumaker { 459babddc72SBryan Schumaker __be32 *p; 460babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 4); 461babddc72SBryan Schumaker if (unlikely(!p)) 462babddc72SBryan Schumaker goto out_overflow; 463babddc72SBryan Schumaker if (!ntohl(*p++)) { 464babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 4); 465babddc72SBryan Schumaker if (unlikely(!p)) 466babddc72SBryan Schumaker goto out_overflow; 467babddc72SBryan Schumaker if (!ntohl(*p++)) 4681da177e4SLinus Torvalds return ERR_PTR(-EAGAIN); 4691da177e4SLinus Torvalds entry->eof = 1; 4701da177e4SLinus Torvalds return ERR_PTR(-EBADCOOKIE); 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds 473babddc72SBryan Schumaker p = xdr_inline_decode(xdr, 8); 474babddc72SBryan Schumaker if (unlikely(!p)) 475babddc72SBryan Schumaker goto out_overflow; 476babddc72SBryan Schumaker 4771da177e4SLinus Torvalds entry->ino = ntohl(*p++); 4781da177e4SLinus Torvalds entry->len = ntohl(*p++); 479babddc72SBryan Schumaker 480babddc72SBryan Schumaker p = xdr_inline_decode(xdr, entry->len + 4); 481babddc72SBryan Schumaker if (unlikely(!p)) 482babddc72SBryan Schumaker goto out_overflow; 4831da177e4SLinus Torvalds entry->name = (const char *) p; 4841da177e4SLinus Torvalds p += XDR_QUADLEN(entry->len); 4851da177e4SLinus Torvalds entry->prev_cookie = entry->cookie; 4861da177e4SLinus Torvalds entry->cookie = ntohl(*p++); 487babddc72SBryan Schumaker 488babddc72SBryan Schumaker p = xdr_inline_peek(xdr, 8); 489babddc72SBryan Schumaker if (p != NULL) 4901da177e4SLinus Torvalds entry->eof = !p[0] && p[1]; 491babddc72SBryan Schumaker else 492babddc72SBryan Schumaker entry->eof = 0; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds return p; 495babddc72SBryan Schumaker 496babddc72SBryan Schumaker out_overflow: 497babddc72SBryan Schumaker print_overflow_msg(__func__, xdr); 498babddc72SBryan Schumaker return ERR_PTR(-EIO); 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds /* 5021da177e4SLinus Torvalds * NFS XDR decode functions 5031da177e4SLinus Torvalds */ 5041da177e4SLinus Torvalds /* 5051da177e4SLinus Torvalds * Decode simple status reply 5061da177e4SLinus Torvalds */ 5071da177e4SLinus Torvalds static int 5089d787a75SAl Viro nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds int status; 5111da177e4SLinus Torvalds 5121da177e4SLinus Torvalds if ((status = ntohl(*p++)) != 0) 513856dff3dSBenny Halevy status = nfs_stat_to_errno(status); 5141da177e4SLinus Torvalds return status; 5151da177e4SLinus Torvalds } 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds /* 5181da177e4SLinus Torvalds * Decode attrstat reply 5191da177e4SLinus Torvalds * GETATTR, SETATTR, WRITE 5201da177e4SLinus Torvalds */ 5211da177e4SLinus Torvalds static int 5229d787a75SAl Viro nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) 5231da177e4SLinus Torvalds { 5241da177e4SLinus Torvalds int status; 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds if ((status = ntohl(*p++))) 527856dff3dSBenny Halevy return nfs_stat_to_errno(status); 5281da177e4SLinus Torvalds xdr_decode_fattr(p, fattr); 5291da177e4SLinus Torvalds return 0; 5301da177e4SLinus Torvalds } 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds /* 5331da177e4SLinus Torvalds * Decode diropres reply 5341da177e4SLinus Torvalds * LOOKUP, CREATE, MKDIR 5351da177e4SLinus Torvalds */ 5361da177e4SLinus Torvalds static int 5379d787a75SAl Viro nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res) 5381da177e4SLinus Torvalds { 5391da177e4SLinus Torvalds int status; 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds if ((status = ntohl(*p++))) 542856dff3dSBenny Halevy return nfs_stat_to_errno(status); 5431da177e4SLinus Torvalds p = xdr_decode_fhandle(p, res->fh); 5441da177e4SLinus Torvalds xdr_decode_fattr(p, res->fattr); 5451da177e4SLinus Torvalds return 0; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds /* 5491da177e4SLinus Torvalds * Encode READLINK args 5501da177e4SLinus Torvalds */ 5511da177e4SLinus Torvalds static int 5529d787a75SAl Viro nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args) 5531da177e4SLinus Torvalds { 554a17c2153STrond Myklebust struct rpc_auth *auth = req->rq_cred->cr_auth; 5551da177e4SLinus Torvalds unsigned int replen; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds p = xdr_encode_fhandle(p, args->fh); 5581da177e4SLinus Torvalds req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds /* Inline the page array */ 5611da177e4SLinus Torvalds replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2; 5621da177e4SLinus Torvalds xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen); 5631da177e4SLinus Torvalds return 0; 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds /* 5671da177e4SLinus Torvalds * Decode READLINK reply 5681da177e4SLinus Torvalds */ 5691da177e4SLinus Torvalds static int 5709d787a75SAl Viro nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy) 5711da177e4SLinus Torvalds { 5721da177e4SLinus Torvalds struct xdr_buf *rcvbuf = &req->rq_rcv_buf; 5731da177e4SLinus Torvalds struct kvec *iov = rcvbuf->head; 5746232dbbcSChuck Lever size_t hdrlen; 5756232dbbcSChuck Lever u32 len, recvd; 5761da177e4SLinus Torvalds int status; 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds if ((status = ntohl(*p++))) 579856dff3dSBenny Halevy return nfs_stat_to_errno(status); 5801da177e4SLinus Torvalds /* Convert length of symlink */ 5811da177e4SLinus Torvalds len = ntohl(*p++); 5826232dbbcSChuck Lever if (len >= rcvbuf->page_len) { 583fe82a183SChuck Lever dprintk("nfs: server returned giant symlink!\n"); 5841da177e4SLinus Torvalds return -ENAMETOOLONG; 5851da177e4SLinus Torvalds } 5861da177e4SLinus Torvalds hdrlen = (u8 *) p - (u8 *) iov->iov_base; 5871da177e4SLinus Torvalds if (iov->iov_len < hdrlen) { 588fe82a183SChuck Lever dprintk("NFS: READLINK reply header overflowed:" 5896232dbbcSChuck Lever "length %Zu > %Zu\n", hdrlen, iov->iov_len); 5901da177e4SLinus Torvalds return -errno_NFSERR_IO; 5911da177e4SLinus Torvalds } else if (iov->iov_len != hdrlen) { 5921da177e4SLinus Torvalds dprintk("NFS: READLINK header is short. iovec will be shifted.\n"); 5931da177e4SLinus Torvalds xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); 5941da177e4SLinus Torvalds } 5951da177e4SLinus Torvalds recvd = req->rq_rcv_buf.len - hdrlen; 5961da177e4SLinus Torvalds if (recvd < len) { 597fe82a183SChuck Lever dprintk("NFS: server cheating in readlink reply: " 5981da177e4SLinus Torvalds "count %u > recvd %u\n", len, recvd); 5991da177e4SLinus Torvalds return -EIO; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 602b4687da7SChuck Lever xdr_terminate_string(rcvbuf, len); 6031da177e4SLinus Torvalds return 0; 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds /* 6071da177e4SLinus Torvalds * Decode WRITE reply 6081da177e4SLinus Torvalds */ 6091da177e4SLinus Torvalds static int 6109d787a75SAl Viro nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) 6111da177e4SLinus Torvalds { 6121da177e4SLinus Torvalds res->verf->committed = NFS_FILE_SYNC; 6131da177e4SLinus Torvalds return nfs_xdr_attrstat(req, p, res->fattr); 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds /* 6171da177e4SLinus Torvalds * Decode STATFS reply 6181da177e4SLinus Torvalds */ 6191da177e4SLinus Torvalds static int 6209d787a75SAl Viro nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res) 6211da177e4SLinus Torvalds { 6221da177e4SLinus Torvalds int status; 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds if ((status = ntohl(*p++))) 625856dff3dSBenny Halevy return nfs_stat_to_errno(status); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds res->tsize = ntohl(*p++); 6281da177e4SLinus Torvalds res->bsize = ntohl(*p++); 6291da177e4SLinus Torvalds res->blocks = ntohl(*p++); 6301da177e4SLinus Torvalds res->bfree = ntohl(*p++); 6311da177e4SLinus Torvalds res->bavail = ntohl(*p++); 6321da177e4SLinus Torvalds return 0; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds /* 6361da177e4SLinus Torvalds * We need to translate between nfs status return values and 6371da177e4SLinus Torvalds * the local errno values which may not be the same. 6381da177e4SLinus Torvalds */ 6391da177e4SLinus Torvalds static struct { 6401da177e4SLinus Torvalds int stat; 6411da177e4SLinus Torvalds int errno; 6421da177e4SLinus Torvalds } nfs_errtbl[] = { 6431da177e4SLinus Torvalds { NFS_OK, 0 }, 644856dff3dSBenny Halevy { NFSERR_PERM, -EPERM }, 645856dff3dSBenny Halevy { NFSERR_NOENT, -ENOENT }, 646856dff3dSBenny Halevy { NFSERR_IO, -errno_NFSERR_IO}, 647856dff3dSBenny Halevy { NFSERR_NXIO, -ENXIO }, 648856dff3dSBenny Halevy /* { NFSERR_EAGAIN, -EAGAIN }, */ 649856dff3dSBenny Halevy { NFSERR_ACCES, -EACCES }, 650856dff3dSBenny Halevy { NFSERR_EXIST, -EEXIST }, 651856dff3dSBenny Halevy { NFSERR_XDEV, -EXDEV }, 652856dff3dSBenny Halevy { NFSERR_NODEV, -ENODEV }, 653856dff3dSBenny Halevy { NFSERR_NOTDIR, -ENOTDIR }, 654856dff3dSBenny Halevy { NFSERR_ISDIR, -EISDIR }, 655856dff3dSBenny Halevy { NFSERR_INVAL, -EINVAL }, 656856dff3dSBenny Halevy { NFSERR_FBIG, -EFBIG }, 657856dff3dSBenny Halevy { NFSERR_NOSPC, -ENOSPC }, 658856dff3dSBenny Halevy { NFSERR_ROFS, -EROFS }, 659856dff3dSBenny Halevy { NFSERR_MLINK, -EMLINK }, 660856dff3dSBenny Halevy { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, 661856dff3dSBenny Halevy { NFSERR_NOTEMPTY, -ENOTEMPTY }, 662856dff3dSBenny Halevy { NFSERR_DQUOT, -EDQUOT }, 663856dff3dSBenny Halevy { NFSERR_STALE, -ESTALE }, 664856dff3dSBenny Halevy { NFSERR_REMOTE, -EREMOTE }, 6651da177e4SLinus Torvalds #ifdef EWFLUSH 666856dff3dSBenny Halevy { NFSERR_WFLUSH, -EWFLUSH }, 6671da177e4SLinus Torvalds #endif 668856dff3dSBenny Halevy { NFSERR_BADHANDLE, -EBADHANDLE }, 669856dff3dSBenny Halevy { NFSERR_NOT_SYNC, -ENOTSYNC }, 670856dff3dSBenny Halevy { NFSERR_BAD_COOKIE, -EBADCOOKIE }, 671856dff3dSBenny Halevy { NFSERR_NOTSUPP, -ENOTSUPP }, 672856dff3dSBenny Halevy { NFSERR_TOOSMALL, -ETOOSMALL }, 673fdcb4577STrond Myklebust { NFSERR_SERVERFAULT, -EREMOTEIO }, 674856dff3dSBenny Halevy { NFSERR_BADTYPE, -EBADTYPE }, 675856dff3dSBenny Halevy { NFSERR_JUKEBOX, -EJUKEBOX }, 676856dff3dSBenny Halevy { -1, -EIO } 6771da177e4SLinus Torvalds }; 6781da177e4SLinus Torvalds 6791da177e4SLinus Torvalds /* 6801da177e4SLinus Torvalds * Convert an NFS error code to a local one. 6811da177e4SLinus Torvalds * This one is used jointly by NFSv2 and NFSv3. 6821da177e4SLinus Torvalds */ 6831da177e4SLinus Torvalds int 6841da177e4SLinus Torvalds nfs_stat_to_errno(int stat) 6851da177e4SLinus Torvalds { 6861da177e4SLinus Torvalds int i; 6871da177e4SLinus Torvalds 6881da177e4SLinus Torvalds for (i = 0; nfs_errtbl[i].stat != -1; i++) { 6891da177e4SLinus Torvalds if (nfs_errtbl[i].stat == stat) 6901da177e4SLinus Torvalds return nfs_errtbl[i].errno; 6911da177e4SLinus Torvalds } 692fe82a183SChuck Lever dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat); 6931da177e4SLinus Torvalds return nfs_errtbl[i].errno; 6941da177e4SLinus Torvalds } 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds #define PROC(proc, argtype, restype, timer) \ 6971da177e4SLinus Torvalds [NFSPROC_##proc] = { \ 6981da177e4SLinus Torvalds .p_proc = NFSPROC_##proc, \ 6991da177e4SLinus Torvalds .p_encode = (kxdrproc_t) nfs_xdr_##argtype, \ 7001da177e4SLinus Torvalds .p_decode = (kxdrproc_t) nfs_xdr_##restype, \ 7012bea90d4SChuck Lever .p_arglen = NFS_##argtype##_sz, \ 7022bea90d4SChuck Lever .p_replen = NFS_##restype##_sz, \ 703cc0175c1SChuck Lever .p_timer = timer, \ 704cc0175c1SChuck Lever .p_statidx = NFSPROC_##proc, \ 705cc0175c1SChuck Lever .p_name = #proc, \ 7061da177e4SLinus Torvalds } 7071da177e4SLinus Torvalds struct rpc_procinfo nfs_procedures[] = { 7081da177e4SLinus Torvalds PROC(GETATTR, fhandle, attrstat, 1), 7091da177e4SLinus Torvalds PROC(SETATTR, sattrargs, attrstat, 0), 7101da177e4SLinus Torvalds PROC(LOOKUP, diropargs, diropres, 2), 7111da177e4SLinus Torvalds PROC(READLINK, readlinkargs, readlinkres, 3), 7121da177e4SLinus Torvalds PROC(READ, readargs, readres, 3), 7131da177e4SLinus Torvalds PROC(WRITE, writeargs, writeres, 4), 7141da177e4SLinus Torvalds PROC(CREATE, createargs, diropres, 0), 7154fdc17b2STrond Myklebust PROC(REMOVE, removeargs, stat, 0), 7161da177e4SLinus Torvalds PROC(RENAME, renameargs, stat, 0), 7171da177e4SLinus Torvalds PROC(LINK, linkargs, stat, 0), 7181da177e4SLinus Torvalds PROC(SYMLINK, symlinkargs, stat, 0), 7191da177e4SLinus Torvalds PROC(MKDIR, createargs, diropres, 0), 7201da177e4SLinus Torvalds PROC(RMDIR, diropargs, stat, 0), 7211da177e4SLinus Torvalds PROC(READDIR, readdirargs, readdirres, 3), 7221da177e4SLinus Torvalds PROC(STATFS, fhandle, statfsres, 0), 7231da177e4SLinus Torvalds }; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds struct rpc_version nfs_version2 = { 7261da177e4SLinus Torvalds .number = 2, 727e8c96f8cSTobias Klauser .nrprocs = ARRAY_SIZE(nfs_procedures), 7281da177e4SLinus Torvalds .procs = nfs_procedures 7291da177e4SLinus Torvalds }; 730