| /* |
| * 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/slab.h> |
| #include <linux/utsname.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 "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) |
| #define NFS_readres_sz (1+NFS_fattr_sz+1) |
| #define NFS_writeres_sz (NFS_attrstat_sz) |
| #define NFS_stat_sz (1) |
| #define NFS_readdirres_sz (1) |
| #define NFS_statfsres_sz (1+NFS_info_sz) |
| |
| /* |
| * Common NFS XDR functions as inlines |
| */ |
| static inline __be32 * |
| xdr_encode_fhandle(__be32 *p, const struct nfs_fh *fhandle) |
| { |
| memcpy(p, fhandle->data, NFS2_FHSIZE); |
| return p + XDR_QUADLEN(NFS2_FHSIZE); |
| } |
| |
| static inline __be32 * |
| xdr_decode_fhandle(__be32 *p, struct nfs_fh *fhandle) |
| { |
| /* NFSv2 handles have a fixed length */ |
| fhandle->size = NFS2_FHSIZE; |
| memcpy(fhandle->data, p, NFS2_FHSIZE); |
| return p + XDR_QUADLEN(NFS2_FHSIZE); |
| } |
| |
| static inline __be32* |
| xdr_encode_time(__be32 *p, struct timespec *timep) |
| { |
| *p++ = htonl(timep->tv_sec); |
| /* Convert nanoseconds into microseconds */ |
| *p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0); |
| return p; |
| } |
| |
| static inline __be32* |
| xdr_encode_current_server_time(__be32 *p, struct timespec *timep) |
| { |
| /* |
| * 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 boxes work correctly. See description of |
| * sattr in section 6.1 of "NFS Illustrated" by |
| * Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5 |
| */ |
| *p++ = htonl(timep->tv_sec); |
| *p++ = htonl(1000000); |
| return p; |
| } |
| |
| static inline __be32* |
| xdr_decode_time(__be32 *p, struct timespec *timep) |
| { |
| timep->tv_sec = ntohl(*p++); |
| /* Convert microseconds into nanoseconds */ |
| timep->tv_nsec = ntohl(*p++) * 1000; |
| return p; |
| } |
| |
| static __be32 * |
| xdr_decode_fattr(__be32 *p, struct nfs_fattr *fattr) |
| { |
| u32 rdev; |
| fattr->type = (enum nfs_ftype) ntohl(*p++); |
| fattr->mode = ntohl(*p++); |
| fattr->nlink = ntohl(*p++); |
| fattr->uid = ntohl(*p++); |
| fattr->gid = ntohl(*p++); |
| fattr->size = ntohl(*p++); |
| fattr->du.nfs2.blocksize = ntohl(*p++); |
| rdev = ntohl(*p++); |
| fattr->du.nfs2.blocks = ntohl(*p++); |
| fattr->fsid.major = ntohl(*p++); |
| fattr->fsid.minor = 0; |
| fattr->fileid = ntohl(*p++); |
| p = xdr_decode_time(p, &fattr->atime); |
| p = xdr_decode_time(p, &fattr->mtime); |
| p = xdr_decode_time(p, &fattr->ctime); |
| fattr->valid |= NFS_ATTR_FATTR_V2; |
| fattr->rdev = new_decode_dev(rdev); |
| if (fattr->type == NFCHR && rdev == NFS2_FIFO_DEV) { |
| fattr->type = NFFIFO; |
| fattr->mode = (fattr->mode & ~S_IFMT) | S_IFIFO; |
| fattr->rdev = 0; |
| } |
| return p; |
| } |
| |
| static inline __be32 * |
| xdr_encode_sattr(__be32 *p, struct iattr *attr) |
| { |
| const __be32 not_set = __constant_htonl(0xFFFFFFFF); |
| |
| *p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set; |
| *p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set; |
| *p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set; |
| *p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : 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++ = not_set; |
| *p++ = not_set; |
| } |
| |
| if (attr->ia_valid & ATTR_MTIME_SET) { |
| p = xdr_encode_time(p, &attr->ia_mtime); |
| } else if (attr->ia_valid & ATTR_MTIME) { |
| p = xdr_encode_current_server_time(p, &attr->ia_mtime); |
| } else { |
| *p++ = not_set; |
| *p++ = not_set; |
| } |
| return p; |
| } |
| |
| /* |
| * NFS encode functions |
| */ |
| /* |
| * Encode file handle argument |
| * GETATTR, READLINK, STATFS |
| */ |
| static int |
| nfs_xdr_fhandle(struct rpc_rqst *req, __be32 *p, struct nfs_fh *fh) |
| { |
| p = xdr_encode_fhandle(p, fh); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode SETATTR arguments |
| */ |
| static int |
| nfs_xdr_sattrargs(struct rpc_rqst *req, __be32 *p, struct nfs_sattrargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fh); |
| p = xdr_encode_sattr(p, args->sattr); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode directory ops argument |
| * LOOKUP, RMDIR |
| */ |
| static int |
| nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fh); |
| p = xdr_encode_array(p, args->name, args->len); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode REMOVE argument |
| */ |
| static int |
| nfs_xdr_removeargs(struct rpc_rqst *req, __be32 *p, const struct nfs_removeargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fh); |
| p = xdr_encode_array(p, args->name.name, args->name.len); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Arguments to a READ call. Since we read data directly into the page |
| * cache, we also set up the reply iovec here so that iov[1] points |
| * exactly to the page we want to fetch. |
| */ |
| static int |
| nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args) |
| { |
| struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; |
| unsigned int replen; |
| u32 offset = (u32)args->offset; |
| u32 count = args->count; |
| |
| p = xdr_encode_fhandle(p, args->fh); |
| *p++ = htonl(offset); |
| *p++ = htonl(count); |
| *p++ = htonl(count); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| |
| /* Inline the page array */ |
| replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2; |
| xdr_inline_pages(&req->rq_rcv_buf, replen, |
| args->pages, args->pgbase, count); |
| req->rq_rcv_buf.flags |= XDRBUF_READ; |
| return 0; |
| } |
| |
| /* |
| * Decode READ reply |
| */ |
| static int |
| nfs_xdr_readres(struct rpc_rqst *req, __be32 *p, struct nfs_readres *res) |
| { |
| struct kvec *iov = req->rq_rcv_buf.head; |
| size_t hdrlen; |
| u32 count, recvd; |
| int status; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| p = xdr_decode_fattr(p, res->fattr); |
| |
| count = ntohl(*p++); |
| res->eof = 0; |
| hdrlen = (u8 *) p - (u8 *) iov->iov_base; |
| if (iov->iov_len < hdrlen) { |
| dprintk("NFS: READ reply header overflowed:" |
| "length %Zu > %Zu\n", hdrlen, iov->iov_len); |
| return -errno_NFSERR_IO; |
| } else if (iov->iov_len != hdrlen) { |
| dprintk("NFS: READ header is short. iovec will be shifted.\n"); |
| xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen); |
| } |
| |
| recvd = req->rq_rcv_buf.len - hdrlen; |
| if (count > recvd) { |
| dprintk("NFS: server cheating in read reply: " |
| "count %u > recvd %u\n", count, recvd); |
| count = recvd; |
| } |
| |
| dprintk("RPC: readres OK count %u\n", count); |
| if (count < res->count) |
| res->count = count; |
| |
| return count; |
| } |
| |
| |
| /* |
| * Write arguments. Splice the buffer to be written into the iovec. |
| */ |
| static int |
| nfs_xdr_writeargs(struct rpc_rqst *req, __be32 *p, struct nfs_writeargs *args) |
| { |
| struct xdr_buf *sndbuf = &req->rq_snd_buf; |
| u32 offset = (u32)args->offset; |
| u32 count = args->count; |
| |
| p = xdr_encode_fhandle(p, args->fh); |
| *p++ = htonl(offset); |
| *p++ = htonl(offset); |
| *p++ = htonl(count); |
| *p++ = htonl(count); |
| sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); |
| |
| /* Copy the page array */ |
| xdr_encode_pages(sndbuf, args->pages, args->pgbase, count); |
| sndbuf->flags |= XDRBUF_WRITE; |
| return 0; |
| } |
| |
| /* |
| * Encode create arguments |
| * CREATE, MKDIR |
| */ |
| static int |
| nfs_xdr_createargs(struct rpc_rqst *req, __be32 *p, struct nfs_createargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fh); |
| p = xdr_encode_array(p, args->name, args->len); |
| p = xdr_encode_sattr(p, args->sattr); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode RENAME arguments |
| */ |
| static int |
| nfs_xdr_renameargs(struct rpc_rqst *req, __be32 *p, struct nfs_renameargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fromfh); |
| p = xdr_encode_array(p, args->fromname, args->fromlen); |
| p = xdr_encode_fhandle(p, args->tofh); |
| p = xdr_encode_array(p, args->toname, args->tolen); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode LINK arguments |
| */ |
| static int |
| nfs_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs_linkargs *args) |
| { |
| p = xdr_encode_fhandle(p, args->fromfh); |
| p = xdr_encode_fhandle(p, args->tofh); |
| p = xdr_encode_array(p, args->toname, args->tolen); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| return 0; |
| } |
| |
| /* |
| * Encode SYMLINK arguments |
| */ |
| static int |
| nfs_xdr_symlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_symlinkargs *args) |
| { |
| struct xdr_buf *sndbuf = &req->rq_snd_buf; |
| size_t pad; |
| |
| p = xdr_encode_fhandle(p, args->fromfh); |
| p = xdr_encode_array(p, args->fromname, args->fromlen); |
| *p++ = htonl(args->pathlen); |
| sndbuf->len = xdr_adjust_iovec(sndbuf->head, p); |
| |
| xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen); |
| |
| /* |
| * xdr_encode_pages may have added a few bytes to ensure the |
| * pathname ends on a 4-byte boundary. Start encoding the |
| * attributes after the pad bytes. |
| */ |
| pad = sndbuf->tail->iov_len; |
| if (pad > 0) |
| p++; |
| p = xdr_encode_sattr(p, args->sattr); |
| sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad; |
| return 0; |
| } |
| |
| /* |
| * Encode arguments to readdir call |
| */ |
| static int |
| nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args) |
| { |
| struct rpc_task *task = req->rq_task; |
| struct rpc_auth *auth = task->tk_msg.rpc_cred->cr_auth; |
| unsigned int replen; |
| u32 count = args->count; |
| |
| p = xdr_encode_fhandle(p, args->fh); |
| *p++ = htonl(args->cookie); |
| *p++ = htonl(count); /* see above */ |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| |
| /* Inline the page array */ |
| replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2; |
| xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count); |
| return 0; |
| } |
| |
| /* |
| * Decode the result of a readdir call. |
| * We're not really decoding anymore, we just leave the buffer untouched |
| * and only check that it is syntactically correct. |
| * The real decoding happens in nfs_decode_entry below, called directly |
| * from nfs_readdir for each entry. |
| */ |
| static int |
| nfs_xdr_readdirres(struct rpc_rqst *req, __be32 *p, void *dummy) |
| { |
| struct xdr_buf *rcvbuf = &req->rq_rcv_buf; |
| struct kvec *iov = rcvbuf->head; |
| struct page **page; |
| size_t hdrlen; |
| unsigned int pglen, recvd; |
| u32 len; |
| int status, nr = 0; |
| __be32 *end, *entry, *kaddr; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| |
| hdrlen = (u8 *) p - (u8 *) iov->iov_base; |
| if (iov->iov_len < hdrlen) { |
| dprintk("NFS: READDIR reply header overflowed:" |
| "length %Zu > %Zu\n", hdrlen, iov->iov_len); |
| return -errno_NFSERR_IO; |
| } else if (iov->iov_len != hdrlen) { |
| dprintk("NFS: READDIR header is short. iovec will be shifted.\n"); |
| xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); |
| } |
| |
| pglen = rcvbuf->page_len; |
| recvd = rcvbuf->len - hdrlen; |
| if (pglen > recvd) |
| pglen = recvd; |
| page = rcvbuf->pages; |
| kaddr = p = kmap_atomic(*page, KM_USER0); |
| end = (__be32 *)((char *)p + pglen); |
| entry = p; |
| |
| /* Make sure the packet actually has a value_follows and EOF entry */ |
| if ((entry + 1) > end) |
| goto short_pkt; |
| |
| for (; *p++; nr++) { |
| if (p + 2 > end) |
| goto short_pkt; |
| p++; /* fileid */ |
| len = ntohl(*p++); |
| p += XDR_QUADLEN(len) + 1; /* name plus cookie */ |
| if (len > NFS2_MAXNAMLEN) { |
| dprintk("NFS: giant filename in readdir (len 0x%x)!\n", |
| len); |
| goto err_unmap; |
| } |
| if (p + 2 > end) |
| goto short_pkt; |
| entry = p; |
| } |
| |
| /* |
| * Apparently some server sends responses that are a valid size, but |
| * contain no entries, and have value_follows==0 and EOF==0. For |
| * those, just set the EOF marker. |
| */ |
| if (!nr && entry[1] == 0) { |
| dprintk("NFS: readdir reply truncated!\n"); |
| entry[1] = 1; |
| } |
| out: |
| kunmap_atomic(kaddr, KM_USER0); |
| return nr; |
| short_pkt: |
| /* |
| * When we get a short packet there are 2 possibilities. We can |
| * return an error, or fix up the response to look like a valid |
| * response and return what we have so far. If there are no |
| * entries and the packet was short, then return -EIO. If there |
| * are valid entries in the response, return them and pretend that |
| * the call was successful, but incomplete. The caller can retry the |
| * readdir starting at the last cookie. |
| */ |
| entry[0] = entry[1] = 0; |
| if (!nr) |
| nr = -errno_NFSERR_IO; |
| goto out; |
| err_unmap: |
| nr = -errno_NFSERR_IO; |
| goto out; |
| } |
| |
| __be32 * |
| nfs_decode_dirent(__be32 *p, struct nfs_entry *entry, int plus) |
| { |
| if (!*p++) { |
| if (!*p) |
| return ERR_PTR(-EAGAIN); |
| entry->eof = 1; |
| return ERR_PTR(-EBADCOOKIE); |
| } |
| |
| entry->ino = ntohl(*p++); |
| entry->len = ntohl(*p++); |
| entry->name = (const char *) p; |
| p += XDR_QUADLEN(entry->len); |
| entry->prev_cookie = entry->cookie; |
| entry->cookie = ntohl(*p++); |
| entry->eof = !p[0] && p[1]; |
| |
| return p; |
| } |
| |
| /* |
| * NFS XDR decode functions |
| */ |
| /* |
| * Decode simple status reply |
| */ |
| static int |
| nfs_xdr_stat(struct rpc_rqst *req, __be32 *p, void *dummy) |
| { |
| int status; |
| |
| if ((status = ntohl(*p++)) != 0) |
| status = nfs_stat_to_errno(status); |
| return status; |
| } |
| |
| /* |
| * Decode attrstat reply |
| * GETATTR, SETATTR, WRITE |
| */ |
| static int |
| nfs_xdr_attrstat(struct rpc_rqst *req, __be32 *p, struct nfs_fattr *fattr) |
| { |
| int status; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| xdr_decode_fattr(p, fattr); |
| return 0; |
| } |
| |
| /* |
| * Decode diropres reply |
| * LOOKUP, CREATE, MKDIR |
| */ |
| static int |
| nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res) |
| { |
| int status; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| p = xdr_decode_fhandle(p, res->fh); |
| xdr_decode_fattr(p, res->fattr); |
| return 0; |
| } |
| |
| /* |
| * Encode READLINK args |
| */ |
| static int |
| nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args) |
| { |
| struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth; |
| unsigned int replen; |
| |
| p = xdr_encode_fhandle(p, args->fh); |
| req->rq_slen = xdr_adjust_iovec(req->rq_svec, p); |
| |
| /* Inline the page array */ |
| replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2; |
| xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen); |
| return 0; |
| } |
| |
| /* |
| * Decode READLINK reply |
| */ |
| static int |
| nfs_xdr_readlinkres(struct rpc_rqst *req, __be32 *p, void *dummy) |
| { |
| struct xdr_buf *rcvbuf = &req->rq_rcv_buf; |
| struct kvec *iov = rcvbuf->head; |
| size_t hdrlen; |
| u32 len, recvd; |
| char *kaddr; |
| int status; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| /* Convert length of symlink */ |
| len = ntohl(*p++); |
| if (len >= rcvbuf->page_len) { |
| dprintk("nfs: server returned giant symlink!\n"); |
| return -ENAMETOOLONG; |
| } |
| hdrlen = (u8 *) p - (u8 *) iov->iov_base; |
| if (iov->iov_len < hdrlen) { |
| dprintk("NFS: READLINK reply header overflowed:" |
| "length %Zu > %Zu\n", hdrlen, iov->iov_len); |
| return -errno_NFSERR_IO; |
| } else if (iov->iov_len != hdrlen) { |
| dprintk("NFS: READLINK header is short. iovec will be shifted.\n"); |
| xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen); |
| } |
| recvd = req->rq_rcv_buf.len - hdrlen; |
| if (recvd < len) { |
| dprintk("NFS: server cheating in readlink reply: " |
| "count %u > recvd %u\n", len, recvd); |
| return -EIO; |
| } |
| |
| /* NULL terminate the string we got */ |
| kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0); |
| kaddr[len+rcvbuf->page_base] = '\0'; |
| kunmap_atomic(kaddr, KM_USER0); |
| return 0; |
| } |
| |
| /* |
| * Decode WRITE reply |
| */ |
| static int |
| nfs_xdr_writeres(struct rpc_rqst *req, __be32 *p, struct nfs_writeres *res) |
| { |
| res->verf->committed = NFS_FILE_SYNC; |
| return nfs_xdr_attrstat(req, p, res->fattr); |
| } |
| |
| /* |
| * Decode STATFS reply |
| */ |
| static int |
| nfs_xdr_statfsres(struct rpc_rqst *req, __be32 *p, struct nfs2_fsstat *res) |
| { |
| int status; |
| |
| if ((status = ntohl(*p++))) |
| return nfs_stat_to_errno(status); |
| |
| res->tsize = ntohl(*p++); |
| res->bsize = ntohl(*p++); |
| res->blocks = ntohl(*p++); |
| res->bfree = ntohl(*p++); |
| res->bavail = ntohl(*p++); |
| return 0; |
| } |
| |
| /* |
| * We need to translate between nfs status return values and |
| * the local errno values which may not be the same. |
| */ |
| static 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, -ESERVERFAULT }, |
| { NFSERR_BADTYPE, -EBADTYPE }, |
| { NFSERR_JUKEBOX, -EJUKEBOX }, |
| { -1, -EIO } |
| }; |
| |
| /* |
| * Convert an NFS error code to a local one. |
| * This one is used jointly by NFSv2 and NFSv3. |
| */ |
| int |
| nfs_stat_to_errno(int stat) |
| { |
| int i; |
| |
| for (i = 0; nfs_errtbl[i].stat != -1; i++) { |
| if (nfs_errtbl[i].stat == stat) |
| return nfs_errtbl[i].errno; |
| } |
| dprintk("nfs_stat_to_errno: bad nfs status return value: %d\n", stat); |
| return nfs_errtbl[i].errno; |
| } |
| |
| #define PROC(proc, argtype, restype, timer) \ |
| [NFSPROC_##proc] = { \ |
| .p_proc = NFSPROC_##proc, \ |
| .p_encode = (kxdrproc_t) nfs_xdr_##argtype, \ |
| .p_decode = (kxdrproc_t) nfs_xdr_##restype, \ |
| .p_arglen = NFS_##argtype##_sz, \ |
| .p_replen = NFS_##restype##_sz, \ |
| .p_timer = timer, \ |
| .p_statidx = NFSPROC_##proc, \ |
| .p_name = #proc, \ |
| } |
| 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), |
| }; |
| |
| struct rpc_version nfs_version2 = { |
| .number = 2, |
| .nrprocs = ARRAY_SIZE(nfs_procedures), |
| .procs = nfs_procedures |
| }; |