| Author | Tokens | Token Proportion | Commits | Commit Proportion |
|---|---|---|---|---|
| Chuck Lever | 2836 | 65.30% | 17 | 26.56% |
| Linus Torvalds (pre-git) | 833 | 19.18% | 8 | 12.50% |
| Trond Myklebust | 337 | 7.76% | 19 | 29.69% |
| Christoph Hellwig | 146 | 3.36% | 4 | 6.25% |
| Eric W. Biedermann | 62 | 1.43% | 1 | 1.56% |
| Anna Schumaker | 55 | 1.27% | 5 | 7.81% |
| Benny Halevy | 31 | 0.71% | 1 | 1.56% |
| Peng Tao | 26 | 0.60% | 1 | 1.56% |
| Art Haas | 6 | 0.14% | 1 | 1.56% |
| Dave Jones | 4 | 0.09% | 2 | 3.12% |
| Al Viro | 3 | 0.07% | 1 | 1.56% |
| Tobias Klauser | 1 | 0.02% | 1 | 1.56% |
| Talpey, Thomas | 1 | 0.02% | 1 | 1.56% |
| Greg Kroah-Hartman | 1 | 0.02% | 1 | 1.56% |
| Benjamin Coddington | 1 | 0.02% | 1 | 1.56% |
| Total | 4343 | 64 |
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156
// SPDX-License-Identifier: GPL-2.0 /* * linux/fs/nfs/nfs2xdr.c * * XDR functions to encode/decode NFS RPC arguments and results. * * Copyright (C) 1992, 1993, 1994 Rick Sladkey * Copyright (C) 1996 Olaf Kirch * 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu> * FIFO's need special handling in NFSv2 */ #include <linux/param.h> #include <linux/time.h> #include <linux/mm.h> #include <linux/errno.h> #include <linux/string.h> #include <linux/in.h> #include <linux/pagemap.h> #include <linux/proc_fs.h> #include <linux/sunrpc/clnt.h> #include <linux/nfs.h> #include <linux/nfs2.h> #include <linux/nfs_fs.h> #include "nfstrace.h" #include "internal.h" #define NFSDBG_FACILITY NFSDBG_XDR /* Mapping from NFS error code to "errno" error code. */ #define errno_NFSERR_IO EIO /* * Declare the space requirements for NFS arguments and replies as * number of 32bit-words */ #define NFS_fhandle_sz (8) #define NFS_sattr_sz (8) #define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2)) #define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2)) #define NFS_fattr_sz (17) #define NFS_info_sz (5) #define NFS_entry_sz (NFS_filename_sz+3) #define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz) #define NFS_removeargs_sz (NFS_fhandle_sz+NFS_filename_sz) #define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz) #define NFS_readlinkargs_sz (NFS_fhandle_sz) #define NFS_readargs_sz (NFS_fhandle_sz+3) #define NFS_writeargs_sz (NFS_fhandle_sz+4) #define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz) #define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz) #define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz) #define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz) #define NFS_readdirargs_sz (NFS_fhandle_sz+2) #define NFS_attrstat_sz (1+NFS_fattr_sz) #define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz) #define NFS_readlinkres_sz (2+1) #define NFS_readres_sz (1+NFS_fattr_sz+1+1) #define NFS_writeres_sz (NFS_attrstat_sz) #define NFS_stat_sz (1) #define NFS_readdirres_sz (1+1) #define NFS_statfsres_sz (1+NFS_info_sz) static int nfs_stat_to_errno(enum nfs_stat); /* * Encode/decode NFSv2 basic data types * * Basic NFSv2 data types are defined in section 2.3 of RFC 1094: * "NFS: Network File System Protocol Specification". * * Not all basic data types have their own encoding and decoding * functions. For run-time efficiency, some data types are encoded * or decoded inline. */ static struct user_namespace *rpc_userns(const struct rpc_clnt *clnt) { if (clnt && clnt->cl_cred) return clnt->cl_cred->user_ns; return &init_user_ns; } static struct user_namespace *rpc_rqst_userns(const struct rpc_rqst *rqstp) { if (rqstp->rq_task) return rpc_userns(rqstp->rq_task->tk_client); return &init_user_ns; } /* * typedef opaque nfsdata<>; */ static int decode_nfsdata(struct xdr_stream *xdr, struct nfs_pgio_res *result) { u32 recvd, count; __be32 *p; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EIO; count = be32_to_cpup(p); recvd = xdr_read_pages(xdr, count); if (unlikely(count > recvd)) goto out_cheating; out: result->eof = 0; /* NFSv2 does not pass EOF flag on the wire. */ result->count = count; return count; out_cheating: dprintk("NFS: server cheating in read result: " "count %u > recvd %u\n", count, recvd); count = recvd; goto out; } /* * enum stat { * NFS_OK = 0, * NFSERR_PERM = 1, * NFSERR_NOENT = 2, * NFSERR_IO = 5, * NFSERR_NXIO = 6, * NFSERR_ACCES = 13, * NFSERR_EXIST = 17, * NFSERR_NODEV = 19, * NFSERR_NOTDIR = 20, * NFSERR_ISDIR = 21, * NFSERR_FBIG = 27, * NFSERR_NOSPC = 28, * NFSERR_ROFS = 30, * NFSERR_NAMETOOLONG = 63, * NFSERR_NOTEMPTY = 66, * NFSERR_DQUOT = 69, * NFSERR_STALE = 70, * NFSERR_WFLUSH = 99 * }; */ static int decode_stat(struct xdr_stream *xdr, enum nfs_stat *status) { __be32 *p; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EIO; if (unlikely(*p != cpu_to_be32(NFS_OK))) goto out_status; *status = 0; return 0; out_status: *status = be32_to_cpup(p); trace_nfs_xdr_status(xdr, (int)*status); return 0; } /* * 2.3.2. ftype * * enum ftype { * NFNON = 0, * NFREG = 1, * NFDIR = 2, * NFBLK = 3, * NFCHR = 4, * NFLNK = 5 * }; * */ static __be32 *xdr_decode_ftype(__be32 *p, u32 *type) { *type = be32_to_cpup(p++); if (unlikely(*type > NF2FIFO)) *type = NFBAD; return p; } /* * 2.3.3. fhandle * * typedef opaque fhandle[FHSIZE]; */ static void encode_fhandle(struct xdr_stream *xdr, const struct nfs_fh *fh) { __be32 *p; p = xdr_reserve_space(xdr, NFS2_FHSIZE); memcpy(p, fh->data, NFS2_FHSIZE); } static int decode_fhandle(struct xdr_stream *xdr, struct nfs_fh *fh) { __be32 *p; p = xdr_inline_decode(xdr, NFS2_FHSIZE); if (unlikely(!p)) return -EIO; fh->size = NFS2_FHSIZE; memcpy(fh->data, p, NFS2_FHSIZE); return 0; } /* * 2.3.4. timeval * * struct timeval { * unsigned int seconds; * unsigned int useconds; * }; */ static __be32 *xdr_encode_time(__be32 *p, const struct timespec64 *timep) { *p++ = cpu_to_be32((u32)timep->tv_sec); if (timep->tv_nsec != 0) *p++ = cpu_to_be32(timep->tv_nsec / NSEC_PER_USEC); else *p++ = cpu_to_be32(0); return p; } /* * Passing the invalid value useconds=1000000 is a Sun convention for * "set to current server time". It's needed to make permissions checks * for the "touch" program across v2 mounts to Solaris and Irix servers * work correctly. See description of sattr in section 6.1 of "NFS * Illustrated" by Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5. */ static __be32 *xdr_encode_current_server_time(__be32 *p, const struct timespec64 *timep) { *p++ = cpu_to_be32(timep->tv_sec); *p++ = cpu_to_be32(1000000); return p; } static __be32 *xdr_decode_time(__be32 *p, struct timespec64 *timep) { timep->tv_sec = be32_to_cpup(p++); timep->tv_nsec = be32_to_cpup(p++) * NSEC_PER_USEC; return p; } /* * 2.3.5. fattr * * struct fattr { * ftype type; * unsigned int mode; * unsigned int nlink; * unsigned int uid; * unsigned int gid; * unsigned int size; * unsigned int blocksize; * unsigned int rdev; * unsigned int blocks; * unsigned int fsid; * unsigned int fileid; * timeval atime; * timeval mtime; * timeval ctime; * }; * */ static int decode_fattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, struct user_namespace *userns) { u32 rdev, type; __be32 *p; p = xdr_inline_decode(xdr, NFS_fattr_sz << 2); if (unlikely(!p)) return -EIO; fattr->valid |= NFS_ATTR_FATTR_V2; p = xdr_decode_ftype(p, &type); fattr->mode = be32_to_cpup(p++); fattr->nlink = be32_to_cpup(p++); fattr->uid = make_kuid(userns, be32_to_cpup(p++)); if (!uid_valid(fattr->uid)) goto out_uid; fattr->gid = make_kgid(userns, be32_to_cpup(p++)); if (!gid_valid(fattr->gid)) goto out_gid; fattr->size = be32_to_cpup(p++); fattr->du.nfs2.blocksize = be32_to_cpup(p++); rdev = be32_to_cpup(p++); fattr->rdev = new_decode_dev(rdev); if (type == (u32)NFCHR && rdev == (u32)NFS2_FIFO_DEV) { fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; fattr->rdev = 0; } fattr->du.nfs2.blocks = be32_to_cpup(p++); fattr->fsid.major = be32_to_cpup(p++); fattr->fsid.minor = 0; fattr->fileid = be32_to_cpup(p++); p = xdr_decode_time(p, &fattr->atime); p = xdr_decode_time(p, &fattr->mtime); xdr_decode_time(p, &fattr->ctime); fattr->change_attr = nfs_timespec_to_change_attr(&fattr->ctime); return 0; out_uid: dprintk("NFS: returned invalid uid\n"); return -EINVAL; out_gid: dprintk("NFS: returned invalid gid\n"); return -EINVAL; } /* * 2.3.6. sattr * * struct sattr { * unsigned int mode; * unsigned int uid; * unsigned int gid; * unsigned int size; * timeval atime; * timeval mtime; * }; */ #define NFS2_SATTR_NOT_SET (0xffffffff) static __be32 *xdr_time_not_set(__be32 *p) { *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); return p; } static void encode_sattr(struct xdr_stream *xdr, const struct iattr *attr, struct user_namespace *userns) { __be32 *p; p = xdr_reserve_space(xdr, NFS_sattr_sz << 2); if (attr->ia_valid & ATTR_MODE) *p++ = cpu_to_be32(attr->ia_mode); else *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); if (attr->ia_valid & ATTR_UID) *p++ = cpu_to_be32(from_kuid_munged(userns, attr->ia_uid)); else *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); if (attr->ia_valid & ATTR_GID) *p++ = cpu_to_be32(from_kgid_munged(userns, attr->ia_gid)); else *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); if (attr->ia_valid & ATTR_SIZE) *p++ = cpu_to_be32((u32)attr->ia_size); else *p++ = cpu_to_be32(NFS2_SATTR_NOT_SET); if (attr->ia_valid & ATTR_ATIME_SET) p = xdr_encode_time(p, &attr->ia_atime); else if (attr->ia_valid & ATTR_ATIME) p = xdr_encode_current_server_time(p, &attr->ia_atime); else p = xdr_time_not_set(p); if (attr->ia_valid & ATTR_MTIME_SET) xdr_encode_time(p, &attr->ia_mtime); else if (attr->ia_valid & ATTR_MTIME) xdr_encode_current_server_time(p, &attr->ia_mtime); else xdr_time_not_set(p); } /* * 2.3.7. filename * * typedef string filename<MAXNAMLEN>; */ static void encode_filename(struct xdr_stream *xdr, const char *name, u32 length) { __be32 *p; WARN_ON_ONCE(length > NFS2_MAXNAMLEN); p = xdr_reserve_space(xdr, 4 + length); xdr_encode_opaque(p, name, length); } static int decode_filename_inline(struct xdr_stream *xdr, const char **name, u32 *length) { __be32 *p; u32 count; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EIO; count = be32_to_cpup(p); if (count > NFS3_MAXNAMLEN) goto out_nametoolong; p = xdr_inline_decode(xdr, count); if (unlikely(!p)) return -EIO; *name = (const char *)p; *length = count; return 0; out_nametoolong: dprintk("NFS: returned filename too long: %u\n", count); return -ENAMETOOLONG; } /* * 2.3.8. path * * typedef string path<MAXPATHLEN>; */ static void encode_path(struct xdr_stream *xdr, struct page **pages, u32 length) { __be32 *p; p = xdr_reserve_space(xdr, 4); *p = cpu_to_be32(length); xdr_write_pages(xdr, pages, 0, length); } static int decode_path(struct xdr_stream *xdr) { u32 length, recvd; __be32 *p; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EIO; length = be32_to_cpup(p); if (unlikely(length >= xdr->buf->page_len || length > NFS_MAXPATHLEN)) goto out_size; recvd = xdr_read_pages(xdr, length); if (unlikely(length > recvd)) goto out_cheating; xdr_terminate_string(xdr->buf, length); return 0; out_size: dprintk("NFS: returned pathname too long: %u\n", length); return -ENAMETOOLONG; out_cheating: dprintk("NFS: server cheating in pathname result: " "length %u > received %u\n", length, recvd); return -EIO; } /* * 2.3.9. attrstat * * union attrstat switch (stat status) { * case NFS_OK: * fattr attributes; * default: * void; * }; */ static int decode_attrstat(struct xdr_stream *xdr, struct nfs_fattr *result, __u32 *op_status, struct user_namespace *userns) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (op_status) *op_status = status; if (status != NFS_OK) goto out_default; error = decode_fattr(xdr, result, userns); out: return error; out_default: return nfs_stat_to_errno(status); } /* * 2.3.10. diropargs * * struct diropargs { * fhandle dir; * filename name; * }; */ static void encode_diropargs(struct xdr_stream *xdr, const struct nfs_fh *fh, const char *name, u32 length) { encode_fhandle(xdr, fh); encode_filename(xdr, name, length); } /* * 2.3.11. diropres * * union diropres switch (stat status) { * case NFS_OK: * struct { * fhandle file; * fattr attributes; * } diropok; * default: * void; * }; */ static int decode_diropok(struct xdr_stream *xdr, struct nfs_diropok *result, struct user_namespace *userns) { int error; error = decode_fhandle(xdr, result->fh); if (unlikely(error)) goto out; error = decode_fattr(xdr, result->fattr, userns); out: return error; } static int decode_diropres(struct xdr_stream *xdr, struct nfs_diropok *result, struct user_namespace *userns) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (status != NFS_OK) goto out_default; error = decode_diropok(xdr, result, userns); out: return error; out_default: return nfs_stat_to_errno(status); } /* * NFSv2 XDR encode functions * * NFSv2 argument types are defined in section 2.2 of RFC 1094: * "NFS: Network File System Protocol Specification". */ static void nfs2_xdr_enc_fhandle(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_fh *fh = data; encode_fhandle(xdr, fh); } /* * 2.2.3. sattrargs * * struct sattrargs { * fhandle file; * sattr attributes; * }; */ static void nfs2_xdr_enc_sattrargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_sattrargs *args = data; encode_fhandle(xdr, args->fh); encode_sattr(xdr, args->sattr, rpc_rqst_userns(req)); } static void nfs2_xdr_enc_diropargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_diropargs *args = data; encode_diropargs(xdr, args->fh, args->name, args->len); } static void nfs2_xdr_enc_readlinkargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_readlinkargs *args = data; encode_fhandle(xdr, args->fh); rpc_prepare_reply_pages(req, args->pages, args->pgbase, args->pglen, NFS_readlinkres_sz); } /* * 2.2.7. readargs * * struct readargs { * fhandle file; * unsigned offset; * unsigned count; * unsigned totalcount; * }; */ static void encode_readargs(struct xdr_stream *xdr, const struct nfs_pgio_args *args) { u32 offset = args->offset; u32 count = args->count; __be32 *p; encode_fhandle(xdr, args->fh); p = xdr_reserve_space(xdr, 4 + 4 + 4); *p++ = cpu_to_be32(offset); *p++ = cpu_to_be32(count); *p = cpu_to_be32(count); } static void nfs2_xdr_enc_readargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_pgio_args *args = data; encode_readargs(xdr, args); rpc_prepare_reply_pages(req, args->pages, args->pgbase, args->count, NFS_readres_sz); req->rq_rcv_buf.flags |= XDRBUF_READ; } /* * 2.2.9. writeargs * * struct writeargs { * fhandle file; * unsigned beginoffset; * unsigned offset; * unsigned totalcount; * nfsdata data; * }; */ static void encode_writeargs(struct xdr_stream *xdr, const struct nfs_pgio_args *args) { u32 offset = args->offset; u32 count = args->count; __be32 *p; encode_fhandle(xdr, args->fh); p = xdr_reserve_space(xdr, 4 + 4 + 4 + 4); *p++ = cpu_to_be32(offset); *p++ = cpu_to_be32(offset); *p++ = cpu_to_be32(count); /* nfsdata */ *p = cpu_to_be32(count); xdr_write_pages(xdr, args->pages, args->pgbase, count); } static void nfs2_xdr_enc_writeargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_pgio_args *args = data; encode_writeargs(xdr, args); xdr->buf->flags |= XDRBUF_WRITE; } /* * 2.2.10. createargs * * struct createargs { * diropargs where; * sattr attributes; * }; */ static void nfs2_xdr_enc_createargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_createargs *args = data; encode_diropargs(xdr, args->fh, args->name, args->len); encode_sattr(xdr, args->sattr, rpc_rqst_userns(req)); } static void nfs2_xdr_enc_removeargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_removeargs *args = data; encode_diropargs(xdr, args->fh, args->name.name, args->name.len); } /* * 2.2.12. renameargs * * struct renameargs { * diropargs from; * diropargs to; * }; */ static void nfs2_xdr_enc_renameargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_renameargs *args = data; const struct qstr *old = args->old_name; const struct qstr *new = args->new_name; encode_diropargs(xdr, args->old_dir, old->name, old->len); encode_diropargs(xdr, args->new_dir, new->name, new->len); } /* * 2.2.13. linkargs * * struct linkargs { * fhandle from; * diropargs to; * }; */ static void nfs2_xdr_enc_linkargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_linkargs *args = data; encode_fhandle(xdr, args->fromfh); encode_diropargs(xdr, args->tofh, args->toname, args->tolen); } /* * 2.2.14. symlinkargs * * struct symlinkargs { * diropargs from; * path to; * sattr attributes; * }; */ static void nfs2_xdr_enc_symlinkargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_symlinkargs *args = data; encode_diropargs(xdr, args->fromfh, args->fromname, args->fromlen); encode_path(xdr, args->pages, args->pathlen); encode_sattr(xdr, args->sattr, rpc_rqst_userns(req)); } /* * 2.2.17. readdirargs * * struct readdirargs { * fhandle dir; * nfscookie cookie; * unsigned count; * }; */ static void encode_readdirargs(struct xdr_stream *xdr, const struct nfs_readdirargs *args) { __be32 *p; encode_fhandle(xdr, args->fh); p = xdr_reserve_space(xdr, 4 + 4); *p++ = cpu_to_be32(args->cookie); *p = cpu_to_be32(args->count); } static void nfs2_xdr_enc_readdirargs(struct rpc_rqst *req, struct xdr_stream *xdr, const void *data) { const struct nfs_readdirargs *args = data; encode_readdirargs(xdr, args); rpc_prepare_reply_pages(req, args->pages, 0, args->count, NFS_readdirres_sz); } /* * NFSv2 XDR decode functions * * NFSv2 result types are defined in section 2.2 of RFC 1094: * "NFS: Network File System Protocol Specification". */ static int nfs2_xdr_dec_stat(struct rpc_rqst *req, struct xdr_stream *xdr, void *__unused) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (status != NFS_OK) goto out_default; out: return error; out_default: return nfs_stat_to_errno(status); } static int nfs2_xdr_dec_attrstat(struct rpc_rqst *req, struct xdr_stream *xdr, void *result) { return decode_attrstat(xdr, result, NULL, rpc_rqst_userns(req)); } static int nfs2_xdr_dec_diropres(struct rpc_rqst *req, struct xdr_stream *xdr, void *result) { return decode_diropres(xdr, result, rpc_rqst_userns(req)); } /* * 2.2.6. readlinkres * * union readlinkres switch (stat status) { * case NFS_OK: * path data; * default: * void; * }; */ static int nfs2_xdr_dec_readlinkres(struct rpc_rqst *req, struct xdr_stream *xdr, void *__unused) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (status != NFS_OK) goto out_default; error = decode_path(xdr); out: return error; out_default: return nfs_stat_to_errno(status); } /* * 2.2.7. readres * * union readres switch (stat status) { * case NFS_OK: * fattr attributes; * nfsdata data; * default: * void; * }; */ static int nfs2_xdr_dec_readres(struct rpc_rqst *req, struct xdr_stream *xdr, void *data) { struct nfs_pgio_res *result = data; enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; result->op_status = status; if (status != NFS_OK) goto out_default; error = decode_fattr(xdr, result->fattr, rpc_rqst_userns(req)); if (unlikely(error)) goto out; error = decode_nfsdata(xdr, result); out: return error; out_default: return nfs_stat_to_errno(status); } static int nfs2_xdr_dec_writeres(struct rpc_rqst *req, struct xdr_stream *xdr, void *data) { struct nfs_pgio_res *result = data; /* All NFSv2 writes are "file sync" writes */ result->verf->committed = NFS_FILE_SYNC; return decode_attrstat(xdr, result->fattr, &result->op_status, rpc_rqst_userns(req)); } /** * nfs2_decode_dirent - Decode a single NFSv2 directory entry stored in * the local page cache. * @xdr: XDR stream where entry resides * @entry: buffer to fill in with entry data * @plus: boolean indicating whether this should be a readdirplus entry * * Returns zero if successful, otherwise a negative errno value is * returned. * * This function is not invoked during READDIR reply decoding, but * rather whenever an application invokes the getdents(2) system call * on a directory already in our cache. * * 2.2.17. entry * * struct entry { * unsigned fileid; * filename name; * nfscookie cookie; * entry *nextentry; * }; */ int nfs2_decode_dirent(struct xdr_stream *xdr, struct nfs_entry *entry, bool plus) { __be32 *p; int error; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EAGAIN; if (*p++ == xdr_zero) { p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EAGAIN; if (*p++ == xdr_zero) return -EAGAIN; entry->eof = 1; return -EBADCOOKIE; } p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EAGAIN; entry->ino = be32_to_cpup(p); error = decode_filename_inline(xdr, &entry->name, &entry->len); if (unlikely(error)) return error; /* * The type (size and byte order) of nfscookie isn't defined in * RFC 1094. This implementation assumes that it's an XDR uint32. */ entry->prev_cookie = entry->cookie; p = xdr_inline_decode(xdr, 4); if (unlikely(!p)) return -EAGAIN; entry->cookie = be32_to_cpup(p); entry->d_type = DT_UNKNOWN; return 0; } /* * 2.2.17. readdirres * * union readdirres switch (stat status) { * case NFS_OK: * struct { * entry *entries; * bool eof; * } readdirok; * default: * void; * }; * * Read the directory contents into the page cache, but don't * touch them. The actual decoding is done by nfs2_decode_dirent() * during subsequent nfs_readdir() calls. */ static int decode_readdirok(struct xdr_stream *xdr) { return xdr_read_pages(xdr, xdr->buf->page_len); } static int nfs2_xdr_dec_readdirres(struct rpc_rqst *req, struct xdr_stream *xdr, void *__unused) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (status != NFS_OK) goto out_default; error = decode_readdirok(xdr); out: return error; out_default: return nfs_stat_to_errno(status); } /* * 2.2.18. statfsres * * union statfsres (stat status) { * case NFS_OK: * struct { * unsigned tsize; * unsigned bsize; * unsigned blocks; * unsigned bfree; * unsigned bavail; * } info; * default: * void; * }; */ static int decode_info(struct xdr_stream *xdr, struct nfs2_fsstat *result) { __be32 *p; p = xdr_inline_decode(xdr, NFS_info_sz << 2); if (unlikely(!p)) return -EIO; result->tsize = be32_to_cpup(p++); result->bsize = be32_to_cpup(p++); result->blocks = be32_to_cpup(p++); result->bfree = be32_to_cpup(p++); result->bavail = be32_to_cpup(p); return 0; } static int nfs2_xdr_dec_statfsres(struct rpc_rqst *req, struct xdr_stream *xdr, void *result) { enum nfs_stat status; int error; error = decode_stat(xdr, &status); if (unlikely(error)) goto out; if (status != NFS_OK) goto out_default; error = decode_info(xdr, result); out: return error; out_default: return nfs_stat_to_errno(status); } /* * We need to translate between nfs status return values and * the local errno values which may not be the same. */ static const struct { int stat; int errno; } nfs_errtbl[] = { { NFS_OK, 0 }, { NFSERR_PERM, -EPERM }, { NFSERR_NOENT, -ENOENT }, { NFSERR_IO, -errno_NFSERR_IO}, { NFSERR_NXIO, -ENXIO }, /* { NFSERR_EAGAIN, -EAGAIN }, */ { NFSERR_ACCES, -EACCES }, { NFSERR_EXIST, -EEXIST }, { NFSERR_XDEV, -EXDEV }, { NFSERR_NODEV, -ENODEV }, { NFSERR_NOTDIR, -ENOTDIR }, { NFSERR_ISDIR, -EISDIR }, { NFSERR_INVAL, -EINVAL }, { NFSERR_FBIG, -EFBIG }, { NFSERR_NOSPC, -ENOSPC }, { NFSERR_ROFS, -EROFS }, { NFSERR_MLINK, -EMLINK }, { NFSERR_NAMETOOLONG, -ENAMETOOLONG }, { NFSERR_NOTEMPTY, -ENOTEMPTY }, { NFSERR_DQUOT, -EDQUOT }, { NFSERR_STALE, -ESTALE }, { NFSERR_REMOTE, -EREMOTE }, #ifdef EWFLUSH { NFSERR_WFLUSH, -EWFLUSH }, #endif { NFSERR_BADHANDLE, -EBADHANDLE }, { NFSERR_NOT_SYNC, -ENOTSYNC }, { NFSERR_BAD_COOKIE, -EBADCOOKIE }, { NFSERR_NOTSUPP, -ENOTSUPP }, { NFSERR_TOOSMALL, -ETOOSMALL }, { NFSERR_SERVERFAULT, -EREMOTEIO }, { NFSERR_BADTYPE, -EBADTYPE }, { NFSERR_JUKEBOX, -EJUKEBOX }, { -1, -EIO } }; /** * nfs_stat_to_errno - convert an NFS status code to a local errno * @status: NFS status code to convert * * Returns a local errno value, or -EIO if the NFS status code is * not recognized. This function is used jointly by NFSv2 and NFSv3. */ static int nfs_stat_to_errno(enum nfs_stat status) { int i; for (i = 0; nfs_errtbl[i].stat != -1; i++) { if (nfs_errtbl[i].stat == (int)status) return nfs_errtbl[i].errno; } dprintk("NFS: Unrecognized nfs status value: %u\n", status); return nfs_errtbl[i].errno; } #define PROC(proc, argtype, restype, timer) \ [NFSPROC_##proc] = { \ .p_proc = NFSPROC_##proc, \ .p_encode = nfs2_xdr_enc_##argtype, \ .p_decode = nfs2_xdr_dec_##restype, \ .p_arglen = NFS_##argtype##_sz, \ .p_replen = NFS_##restype##_sz, \ .p_timer = timer, \ .p_statidx = NFSPROC_##proc, \ .p_name = #proc, \ } const struct rpc_procinfo nfs_procedures[] = { PROC(GETATTR, fhandle, attrstat, 1), PROC(SETATTR, sattrargs, attrstat, 0), PROC(LOOKUP, diropargs, diropres, 2), PROC(READLINK, readlinkargs, readlinkres, 3), PROC(READ, readargs, readres, 3), PROC(WRITE, writeargs, writeres, 4), PROC(CREATE, createargs, diropres, 0), PROC(REMOVE, removeargs, stat, 0), PROC(RENAME, renameargs, stat, 0), PROC(LINK, linkargs, stat, 0), PROC(SYMLINK, symlinkargs, stat, 0), PROC(MKDIR, createargs, diropres, 0), PROC(RMDIR, diropargs, stat, 0), PROC(READDIR, readdirargs, readdirres, 3), PROC(STATFS, fhandle, statfsres, 0), }; static unsigned int nfs_version2_counts[ARRAY_SIZE(nfs_procedures)]; const struct rpc_version nfs_version2 = { .number = 2, .nrprocs = ARRAY_SIZE(nfs_procedures), .procs = nfs_procedures, .counts = nfs_version2_counts, };
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1