[net-next-2.6.git] / fs / nfs / nfs2xdr.c

/*
 * 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
/* #define NFS_PARANOIA 1 */

/* 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_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 u32 *
xdr_encode_fhandle(u32 *p, struct nfs_fh *fhandle)
{
	memcpy(p, fhandle->data, NFS2_FHSIZE);
	return p + XDR_QUADLEN(NFS2_FHSIZE);
}

static inline u32 *
xdr_decode_fhandle(u32 *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 u32*
xdr_encode_time(u32 *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 u32*
xdr_encode_current_server_time(u32 *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 u32*
xdr_decode_time(u32 *p, struct timespec *timep)
{
	timep->tv_sec = ntohl(*p++);
	/* Convert microseconds into nanoseconds */
	timep->tv_nsec = ntohl(*p++) * 1000;
	return p;
}

static u32 *
xdr_decode_fattr(u32 *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;
	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 u32 *
xdr_encode_sattr(u32 *p, struct iattr *attr)
{
	const u32 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, u32 *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, u32 *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, REMOVE, RMDIR
 */
static int
nfs_xdr_diropargs(struct rpc_rqst *req, u32 *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;
}

/*
 * 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, u32 *p, struct nfs_readargs *args)
{
	struct rpc_auth	*auth = req->rq_task->tk_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);
	return 0;
}

/*
 * Decode READ reply
 */
static int
nfs_xdr_readres(struct rpc_rqst *req, u32 *p, struct nfs_readres *res)
{
	struct kvec *iov = req->rq_rcv_buf.head;
	int	status, count, recvd, hdrlen;

	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) {
		printk(KERN_WARNING "NFS: READ reply header overflowed:"
				"length %d > %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) {
		printk(KERN_WARNING "NFS: server cheating in read reply: "
			"count %d > recvd %d\n", count, recvd);
		count = recvd;
	}

	dprintk("RPC:      readres OK count %d\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, u32 *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);
	return 0;
}

/*
 * Encode create arguments
 * CREATE, MKDIR
 */
static int
nfs_xdr_createargs(struct rpc_rqst *req, u32 *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, u32 *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, u32 *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, u32 *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, u32 *p, struct nfs_readdirargs *args)
{
	struct rpc_task	*task = req->rq_task;
	struct rpc_auth	*auth = task->tk_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, u32 *p, void *dummy)
{
	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
	struct kvec *iov = rcvbuf->head;
	struct page **page;
	int hdrlen, recvd;
	int status, nr;
	unsigned int len, pglen;
	u32 *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) {
		printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
				"length %d > %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 = (u32 *)kmap_atomic(*page, KM_USER0);
	end = (u32 *)((char *)p + pglen);
	entry = p;
	for (nr = 0; *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) {
			printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!\n",
						len);
			goto err_unmap;
		}
		if (p + 2 > end)
			goto short_pkt;
		entry = p;
	}
	if (!nr && (entry[0] != 0 || entry[1] == 0))
		goto short_pkt;
 out:
	kunmap_atomic(kaddr, KM_USER0);
	return nr;
 short_pkt:
	entry[0] = entry[1] = 0;
	/* truncate listing ? */
	if (!nr) {
		printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
		entry[1] = 1;
	}
	goto out;
err_unmap:
	nr = -errno_NFSERR_IO;
	goto out;
}

u32 *
nfs_decode_dirent(u32 *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, u32 *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, u32 *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, u32 *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, u32 *p, struct nfs_readlinkargs *args)
{
	struct rpc_auth *auth = req->rq_task->tk_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, u32 *p, void *dummy)
{
	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
	struct kvec *iov = rcvbuf->head;
	int hdrlen, 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 || len <= 0) {
		dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
		return -ENAMETOOLONG;
	}
	hdrlen = (u8 *) p - (u8 *) iov->iov_base;
	if (iov->iov_len < hdrlen) {
		printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
				"length %d > %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) {
		printk(KERN_WARNING "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, u32 *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, u32 *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;
	}
	printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
	return nfs_errtbl[i].errno;
}

#ifndef MAX
# define MAX(a, b)	(((a) > (b))? (a) : (b))
#endif

#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_bufsiz   =  MAX(NFS_##argtype##_sz,NFS_##restype##_sz) << 2,	\
	.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,	diropargs,	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
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/nfs/nfs2xdr.c
	3	*
	4	* XDR functions to encode/decode NFS RPC arguments and results.
	5	*
	6	* Copyright (C) 1992, 1993, 1994 Rick Sladkey
	7	* Copyright (C) 1996 Olaf Kirch
	8	* 04 Aug 1998 Ion Badulescu <ionut@cs.columbia.edu>
	9	* FIFO's need special handling in NFSv2
	10	*/
	11
	12	#include <linux/param.h>
	13	#include <linux/time.h>
	14	#include <linux/mm.h>
	15	#include <linux/slab.h>
	16	#include <linux/utsname.h>
	17	#include <linux/errno.h>
	18	#include <linux/string.h>
	19	#include <linux/in.h>
	20	#include <linux/pagemap.h>
	21	#include <linux/proc_fs.h>
	22	#include <linux/sunrpc/clnt.h>
	23	#include <linux/nfs.h>
	24	#include <linux/nfs2.h>
	25	#include <linux/nfs_fs.h>
816724e6	26	#include "internal.h"
1da177e4 LT	27
	28	#define NFSDBG_FACILITY NFSDBG_XDR
	29	/* #define NFS_PARANOIA 1 */
	30
1da177e4 LT	31	/* Mapping from NFS error code to "errno" error code. */
	32	#define errno_NFSERR_IO EIO
	33
	34	/*
	35	* Declare the space requirements for NFS arguments and replies as
	36	* number of 32bit-words
	37	*/
	38	#define NFS_fhandle_sz (8)
	39	#define NFS_sattr_sz (8)
	40	#define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2))
	41	#define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2))
	42	#define NFS_fattr_sz (17)
	43	#define NFS_info_sz (5)
	44	#define NFS_entry_sz (NFS_filename_sz+3)
	45
	46	#define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz)
	47	#define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz)
	48	#define NFS_readlinkargs_sz (NFS_fhandle_sz)
	49	#define NFS_readargs_sz (NFS_fhandle_sz+3)
	50	#define NFS_writeargs_sz (NFS_fhandle_sz+4)
	51	#define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz)
	52	#define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz)
	53	#define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz)
94a6d753	54	#define NFS_symlinkargs_sz (NFS_diropargs_sz+1+NFS_sattr_sz)
1da177e4 LT	55	#define NFS_readdirargs_sz (NFS_fhandle_sz+2)
	56
	57	#define NFS_attrstat_sz (1+NFS_fattr_sz)
	58	#define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz)
	59	#define NFS_readlinkres_sz (2)
	60	#define NFS_readres_sz (1+NFS_fattr_sz+1)
	61	#define NFS_writeres_sz (NFS_attrstat_sz)
	62	#define NFS_stat_sz (1)
	63	#define NFS_readdirres_sz (1)
	64	#define NFS_statfsres_sz (1+NFS_info_sz)
	65
	66	/*
	67	* Common NFS XDR functions as inlines
	68	*/
	69	static inline u32 *
	70	xdr_encode_fhandle(u32 p, struct nfs_fh fhandle)
	71	{
	72	memcpy(p, fhandle->data, NFS2_FHSIZE);
	73	return p + XDR_QUADLEN(NFS2_FHSIZE);
	74	}
	75
	76	static inline u32 *
	77	xdr_decode_fhandle(u32 p, struct nfs_fh fhandle)
	78	{
	79	/* NFSv2 handles have a fixed length */
	80	fhandle->size = NFS2_FHSIZE;
	81	memcpy(fhandle->data, p, NFS2_FHSIZE);
	82	return p + XDR_QUADLEN(NFS2_FHSIZE);
	83	}
	84
	85	static inline u32*
	86	xdr_encode_time(u32 p, struct timespec timep)
	87	{
	88	*p++ = htonl(timep->tv_sec);
	89	/* Convert nanoseconds into microseconds */
	90	*p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
	91	return p;
	92	}
	93
	94	static inline u32*
	95	xdr_encode_current_server_time(u32 p, struct timespec timep)
	96	{
	97	/*
	98	* Passing the invalid value useconds=1000000 is a
	99	* Sun convention for "set to current server time".
	100	* It's needed to make permissions checks for the
	101	* "touch" program across v2 mounts to Solaris and
	102	* Irix boxes work correctly. See description of
	103	* sattr in section 6.1 of "NFS Illustrated" by
	104	* Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
	105	*/
	106	*p++ = htonl(timep->tv_sec);
	107	*p++ = htonl(1000000);
	108	return p;
	109	}
	110
	111	static inline u32*
	112	xdr_decode_time(u32 p, struct timespec timep)
	113	{
	114	timep->tv_sec = ntohl(*p++);
	115	/* Convert microseconds into nanoseconds */
	116	timep->tv_nsec = ntohl(p++) 1000;
	117	return p;
	118	}
119
120	static u32 *
121	xdr_decode_fattr(u32 p, struct nfs_fattr fattr)
122	{
123	u32 rdev;
124	fattr->type = (enum nfs_ftype) ntohl(*p++);
125	fattr->mode = ntohl(*p++);
126	fattr->nlink = ntohl(*p++);
127	fattr->uid = ntohl(*p++);
128	fattr->gid = ntohl(*p++);
129	fattr->size = ntohl(*p++);
130	fattr->du.nfs2.blocksize = ntohl(*p++);
131	rdev = ntohl(*p++);
132	fattr->du.nfs2.blocks = ntohl(*p++);
8b4bdcf8 TM	133	fattr->fsid.major = ntohl(*p++);
8b4bdcf8 TM	134	fattr->fsid.minor = 0;
1da177e4 LT	135	fattr->fileid = ntohl(*p++);
	136	p = xdr_decode_time(p, &fattr->atime);
	137	p = xdr_decode_time(p, &fattr->mtime);
	138	p = xdr_decode_time(p, &fattr->ctime);
	139	fattr->valid \|= NFS_ATTR_FATTR;
	140	fattr->rdev = new_decode_dev(rdev);
	141	if (fattr->type == NFCHR && rdev == NFS2_FIFO_DEV) {
	142	fattr->type = NFFIFO;
	143	fattr->mode = (fattr->mode & ~S_IFMT) \| S_IFIFO;
	144	fattr->rdev = 0;
	145	}
1da177e4 LT	146	return p;
	147	}
	148
1da177e4 LT	149	static inline u32 *
	150	xdr_encode_sattr(u32 p, struct iattr attr)
	151	{
eadb8c14 TM	152	const u32 not_set = __constant_htonl(0xFFFFFFFF);
	153
	154	*p++ = (attr->ia_valid & ATTR_MODE) ? htonl(attr->ia_mode) : not_set;
	155	*p++ = (attr->ia_valid & ATTR_UID) ? htonl(attr->ia_uid) : not_set;
	156	*p++ = (attr->ia_valid & ATTR_GID) ? htonl(attr->ia_gid) : not_set;
	157	*p++ = (attr->ia_valid & ATTR_SIZE) ? htonl(attr->ia_size) : not_set;
1da177e4 LT	158
	159	if (attr->ia_valid & ATTR_ATIME_SET) {
	160	p = xdr_encode_time(p, &attr->ia_atime);
	161	} else if (attr->ia_valid & ATTR_ATIME) {
	162	p = xdr_encode_current_server_time(p, &attr->ia_atime);
	163	} else {
eadb8c14 TM	164	*p++ = not_set;
eadb8c14 TM	165	*p++ = not_set;
1da177e4 LT	166	}
	167
	168	if (attr->ia_valid & ATTR_MTIME_SET) {
	169	p = xdr_encode_time(p, &attr->ia_mtime);
	170	} else if (attr->ia_valid & ATTR_MTIME) {
	171	p = xdr_encode_current_server_time(p, &attr->ia_mtime);
	172	} else {
eadb8c14 TM	173	*p++ = not_set;
eadb8c14 TM	174	*p++ = not_set;
1da177e4 LT	175	}
	176	return p;
	177	}
1da177e4 LT	178
	179	/*
	180	* NFS encode functions
	181	*/
	182	/*
	183	* Encode file handle argument
	184	* GETATTR, READLINK, STATFS
	185	*/
	186	static int
	187	nfs_xdr_fhandle(struct rpc_rqst req, u32 p, struct nfs_fh *fh)
	188	{
	189	p = xdr_encode_fhandle(p, fh);
	190	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	191	return 0;
	192	}
	193
	194	/*
	195	* Encode SETATTR arguments
	196	*/
	197	static int
	198	nfs_xdr_sattrargs(struct rpc_rqst req, u32 p, struct nfs_sattrargs *args)
	199	{
	200	p = xdr_encode_fhandle(p, args->fh);
	201	p = xdr_encode_sattr(p, args->sattr);
	202	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	203	return 0;
	204	}
	205
	206	/*
	207	* Encode directory ops argument
	208	* LOOKUP, REMOVE, RMDIR
	209	*/
	210	static int
	211	nfs_xdr_diropargs(struct rpc_rqst req, u32 p, struct nfs_diropargs *args)
	212	{
	213	p = xdr_encode_fhandle(p, args->fh);
	214	p = xdr_encode_array(p, args->name, args->len);
	215	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	216	return 0;
	217	}
	218
	219	/*
	220	* Arguments to a READ call. Since we read data directly into the page
	221	* cache, we also set up the reply iovec here so that iov[1] points
	222	* exactly to the page we want to fetch.
	223	*/
	224	static int
	225	nfs_xdr_readargs(struct rpc_rqst req, u32 p, struct nfs_readargs *args)
	226	{
	227	struct rpc_auth *auth = req->rq_task->tk_auth;
	228	unsigned int replen;
	229	u32 offset = (u32)args->offset;
	230	u32 count = args->count;
	231
	232	p = xdr_encode_fhandle(p, args->fh);
	233	*p++ = htonl(offset);
	234	*p++ = htonl(count);
	235	*p++ = htonl(count);
	236	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	237
	238	/* Inline the page array */
	239	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readres_sz) << 2;
	240	xdr_inline_pages(&req->rq_rcv_buf, replen,
	241	args->pages, args->pgbase, count);
242	return 0;
243	}
244
245	/*
246	* Decode READ reply
247	*/
248	static int
249	nfs_xdr_readres(struct rpc_rqst req, u32 p, struct nfs_readres *res)
250	{
251	struct kvec *iov = req->rq_rcv_buf.head;
252	int status, count, recvd, hdrlen;
253
254	if ((status = ntohl(*p++)))
255	return -nfs_stat_to_errno(status);
256	p = xdr_decode_fattr(p, res->fattr);
257
258	count = ntohl(*p++);
259	res->eof = 0;
260	hdrlen = (u8 ) p - (u8 ) iov->iov_base;
261	if (iov->iov_len < hdrlen) {
262	printk(KERN_WARNING "NFS: READ reply header overflowed:"
263	"length %d > %Zu\n", hdrlen, iov->iov_len);
264	return -errno_NFSERR_IO;
265	} else if (iov->iov_len != hdrlen) {
266	dprintk("NFS: READ header is short. iovec will be shifted.\n");
267	xdr_shift_buf(&req->rq_rcv_buf, iov->iov_len - hdrlen);
268	}
269
270	recvd = req->rq_rcv_buf.len - hdrlen;
271	if (count > recvd) {
272	printk(KERN_WARNING "NFS: server cheating in read reply: "
273	"count %d > recvd %d\n", count, recvd);
274	count = recvd;
275	}
276
277	dprintk("RPC: readres OK count %d\n", count);
278	if (count < res->count)
279	res->count = count;
280
281	return count;
282	}
283
284
285	/*
286	* Write arguments. Splice the buffer to be written into the iovec.
287	*/
288	static int
289	nfs_xdr_writeargs(struct rpc_rqst req, u32 p, struct nfs_writeargs *args)
290	{
291	struct xdr_buf *sndbuf = &req->rq_snd_buf;
292	u32 offset = (u32)args->offset;
293	u32 count = args->count;
294
295	p = xdr_encode_fhandle(p, args->fh);
296	*p++ = htonl(offset);
297	*p++ = htonl(offset);
298	*p++ = htonl(count);
299	*p++ = htonl(count);
300	sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
301
302	/* Copy the page array */
303	xdr_encode_pages(sndbuf, args->pages, args->pgbase, count);
304	return 0;
305	}
306
307	/*
308	* Encode create arguments
309	* CREATE, MKDIR
310	*/
311	static int
312	nfs_xdr_createargs(struct rpc_rqst req, u32 p, struct nfs_createargs *args)
313	{
314	p = xdr_encode_fhandle(p, args->fh);
315	p = xdr_encode_array(p, args->name, args->len);
316	p = xdr_encode_sattr(p, args->sattr);
317	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
318	return 0;
319	}
320
321	/*
322	* Encode RENAME arguments
323	*/
324	static int
325	nfs_xdr_renameargs(struct rpc_rqst req, u32 p, struct nfs_renameargs *args)
326	{
327	p = xdr_encode_fhandle(p, args->fromfh);
328	p = xdr_encode_array(p, args->fromname, args->fromlen);
329	p = xdr_encode_fhandle(p, args->tofh);
330	p = xdr_encode_array(p, args->toname, args->tolen);
331	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
332	return 0;
333	}
334
335	/*
336	* Encode LINK arguments
337	*/
338	static int
339	nfs_xdr_linkargs(struct rpc_rqst req, u32 p, struct nfs_linkargs *args)
340	{
341	p = xdr_encode_fhandle(p, args->fromfh);
342	p = xdr_encode_fhandle(p, args->tofh);
343	p = xdr_encode_array(p, args->toname, args->tolen);
344	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
345	return 0;
346	}
347
348	/*
349	* Encode SYMLINK arguments
350	*/
351	static int
352	nfs_xdr_symlinkargs(struct rpc_rqst req, u32 p, struct nfs_symlinkargs *args)
353	{
94a6d753 CL	354	struct xdr_buf *sndbuf = &req->rq_snd_buf;
	355	size_t pad;
	356
1da177e4 LT	357	p = xdr_encode_fhandle(p, args->fromfh);
1da177e4 LT	358	p = xdr_encode_array(p, args->fromname, args->fromlen);
94a6d753 CL	359	*p++ = htonl(args->pathlen);
	360	sndbuf->len = xdr_adjust_iovec(sndbuf->head, p);
	361
	362	xdr_encode_pages(sndbuf, args->pages, 0, args->pathlen);
	363
	364	/*
	365	* xdr_encode_pages may have added a few bytes to ensure the
	366	* pathname ends on a 4-byte boundary. Start encoding the
	367	* attributes after the pad bytes.
	368	*/
	369	pad = sndbuf->tail->iov_len;
	370	if (pad > 0)
	371	p++;
1da177e4	372	p = xdr_encode_sattr(p, args->sattr);
94a6d753	373	sndbuf->len += xdr_adjust_iovec(sndbuf->tail, p) - pad;
1da177e4 LT	374	return 0;
	375	}
	376
	377	/*
	378	* Encode arguments to readdir call
	379	*/
	380	static int
	381	nfs_xdr_readdirargs(struct rpc_rqst req, u32 p, struct nfs_readdirargs *args)
	382	{
	383	struct rpc_task *task = req->rq_task;
	384	struct rpc_auth *auth = task->tk_auth;
	385	unsigned int replen;
	386	u32 count = args->count;
	387
	388	p = xdr_encode_fhandle(p, args->fh);
	389	*p++ = htonl(args->cookie);
	390	p++ = htonl(count); / see above */
	391	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	392
	393	/* Inline the page array */
	394	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
	395	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
	396	return 0;
	397	}
	398
	399	/*
	400	* Decode the result of a readdir call.
	401	* We're not really decoding anymore, we just leave the buffer untouched
	402	* and only check that it is syntactically correct.
	403	* The real decoding happens in nfs_decode_entry below, called directly
	404	* from nfs_readdir for each entry.
	405	*/
	406	static int
	407	nfs_xdr_readdirres(struct rpc_rqst req, u32 p, void *dummy)
	408	{
	409	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
	410	struct kvec *iov = rcvbuf->head;
	411	struct page **page;
	412	int hdrlen, recvd;
	413	int status, nr;
	414	unsigned int len, pglen;
	415	u32 end, entry, *kaddr;
	416
	417	if ((status = ntohl(*p++)))
	418	return -nfs_stat_to_errno(status);
	419
	420	hdrlen = (u8 ) p - (u8 ) iov->iov_base;
	421	if (iov->iov_len < hdrlen) {
	422	printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
	423	"length %d > %Zu\n", hdrlen, iov->iov_len);
	424	return -errno_NFSERR_IO;
	425	} else if (iov->iov_len != hdrlen) {
	426	dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
	427	xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
	428	}
	429
	430	pglen = rcvbuf->page_len;
	431	recvd = rcvbuf->len - hdrlen;
	432	if (pglen > recvd)
	433	pglen = recvd;
	434	page = rcvbuf->pages;
	435	kaddr = p = (u32 )kmap_atomic(page, KM_USER0);
	436	end = (u32 )((char )p + pglen);
	437	entry = p;
438	for (nr = 0; *p++; nr++) {
439	if (p + 2 > end)
440	goto short_pkt;
441	p++; /* fileid */
442	len = ntohl(*p++);
443	p += XDR_QUADLEN(len) + 1; /* name plus cookie */
444	if (len > NFS2_MAXNAMLEN) {
445	printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!\n",
446	len);
447	goto err_unmap;
448	}
449	if (p + 2 > end)
450	goto short_pkt;
451	entry = p;
452	}
453	if (!nr && (entry[0] != 0 \|\| entry[1] == 0))
454	goto short_pkt;
455	out:
456	kunmap_atomic(kaddr, KM_USER0);
457	return nr;
458	short_pkt:
459	entry[0] = entry[1] = 0;
460	/* truncate listing ? */
461	if (!nr) {
462	printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
463	entry[1] = 1;
464	}
465	goto out;
466	err_unmap:
467	nr = -errno_NFSERR_IO;
468	goto out;
469	}
470
471	u32 *
472	nfs_decode_dirent(u32 p, struct nfs_entry entry, int plus)
473	{
474	if (!*p++) {
475	if (!*p)
476	return ERR_PTR(-EAGAIN);
477	entry->eof = 1;
478	return ERR_PTR(-EBADCOOKIE);
479	}
480
481	entry->ino = ntohl(*p++);
482	entry->len = ntohl(*p++);
483	entry->name = (const char *) p;
484	p += XDR_QUADLEN(entry->len);
485	entry->prev_cookie = entry->cookie;
486	entry->cookie = ntohl(*p++);
487	entry->eof = !p[0] && p[1];
488
489	return p;
490	}
491
492	/*
493	* NFS XDR decode functions
494	*/
495	/*
496	* Decode simple status reply
497	*/
498	static int
499	nfs_xdr_stat(struct rpc_rqst req, u32 p, void *dummy)
500	{
501	int status;
502
503	if ((status = ntohl(*p++)) != 0)
504	status = -nfs_stat_to_errno(status);
505	return status;
506	}
507
508	/*
509	* Decode attrstat reply
510	* GETATTR, SETATTR, WRITE
511	*/
512	static int
513	nfs_xdr_attrstat(struct rpc_rqst req, u32 p, struct nfs_fattr *fattr)
514	{
515	int status;
516
517	if ((status = ntohl(*p++)))
518	return -nfs_stat_to_errno(status);
519	xdr_decode_fattr(p, fattr);
520	return 0;
521	}
522
523	/*
524	* Decode diropres reply
525	* LOOKUP, CREATE, MKDIR
526	*/
527	static int
528	nfs_xdr_diropres(struct rpc_rqst req, u32 p, struct nfs_diropok *res)
529	{
530	int status;
531
532	if ((status = ntohl(*p++)))
533	return -nfs_stat_to_errno(status);
534	p = xdr_decode_fhandle(p, res->fh);
535	xdr_decode_fattr(p, res->fattr);
536	return 0;
537	}
538
539	/*
540	* Encode READLINK args
541	*/
542	static int
543	nfs_xdr_readlinkargs(struct rpc_rqst req, u32 p, struct nfs_readlinkargs *args)
544	{
545	struct rpc_auth *auth = req->rq_task->tk_auth;
546	unsigned int replen;
547
548	p = xdr_encode_fhandle(p, args->fh);
549	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
550
551	/* Inline the page array */
552	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
553	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
554	return 0;
555	}
556
557	/*
558	* Decode READLINK reply
559	*/
560	static int
561	nfs_xdr_readlinkres(struct rpc_rqst req, u32 p, void *dummy)
562	{
563	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
564	struct kvec *iov = rcvbuf->head;
565	int hdrlen, len, recvd;
566	char *kaddr;
567	int status;
568
569	if ((status = ntohl(*p++)))
570	return -nfs_stat_to_errno(status);
571	/* Convert length of symlink */
572	len = ntohl(*p++);
573	if (len >= rcvbuf->page_len \|\| len <= 0) {
574	dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
575	return -ENAMETOOLONG;
576	}
577	hdrlen = (u8 ) p - (u8 ) iov->iov_base;
578	if (iov->iov_len < hdrlen) {
579	printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
580	"length %d > %Zu\n", hdrlen, iov->iov_len);
581	return -errno_NFSERR_IO;
582	} else if (iov->iov_len != hdrlen) {
583	dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
584	xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
585	}
586	recvd = req->rq_rcv_buf.len - hdrlen;
587	if (recvd < len) {
588	printk(KERN_WARNING "NFS: server cheating in readlink reply: "
589	"count %u > recvd %u\n", len, recvd);
590	return -EIO;
591	}
592
593	/* NULL terminate the string we got */
594	kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
595	kaddr[len+rcvbuf->page_base] = '\0';
596	kunmap_atomic(kaddr, KM_USER0);
597	return 0;
598	}
599
600	/*
601	* Decode WRITE reply
602	*/
603	static int
604	nfs_xdr_writeres(struct rpc_rqst req, u32 p, struct nfs_writeres *res)
605	{
606	res->verf->committed = NFS_FILE_SYNC;
607	return nfs_xdr_attrstat(req, p, res->fattr);
608	}
609
610	/*
611	* Decode STATFS reply
612	*/
613	static int
614	nfs_xdr_statfsres(struct rpc_rqst req, u32 p, struct nfs2_fsstat *res)
615	{
616	int status;
617
618	if ((status = ntohl(*p++)))
619	return -nfs_stat_to_errno(status);
620
621	res->tsize = ntohl(*p++);
622	res->bsize = ntohl(*p++);
623	res->blocks = ntohl(*p++);
624	res->bfree = ntohl(*p++);
625	res->bavail = ntohl(*p++);
626	return 0;
627	}
628
629	/*
630	* We need to translate between nfs status return values and
631	* the local errno values which may not be the same.
632	*/
633	static struct {
634	int stat;
635	int errno;
636	} nfs_errtbl[] = {
637	{ NFS_OK, 0 },
638	{ NFSERR_PERM, EPERM },
639	{ NFSERR_NOENT, ENOENT },
640	{ NFSERR_IO, errno_NFSERR_IO },
641	{ NFSERR_NXIO, ENXIO },
642	/* { NFSERR_EAGAIN, EAGAIN }, */
643	{ NFSERR_ACCES, EACCES },
644	{ NFSERR_EXIST, EEXIST },
645	{ NFSERR_XDEV, EXDEV },
646	{ NFSERR_NODEV, ENODEV },
647	{ NFSERR_NOTDIR, ENOTDIR },
648	{ NFSERR_ISDIR, EISDIR },
649	{ NFSERR_INVAL, EINVAL },
650	{ NFSERR_FBIG, EFBIG },
651	{ NFSERR_NOSPC, ENOSPC },
652	{ NFSERR_ROFS, EROFS },
653	{ NFSERR_MLINK, EMLINK },
654	{ NFSERR_NAMETOOLONG, ENAMETOOLONG },
655	{ NFSERR_NOTEMPTY, ENOTEMPTY },
656	{ NFSERR_DQUOT, EDQUOT },
657	{ NFSERR_STALE, ESTALE },
658	{ NFSERR_REMOTE, EREMOTE },
659	#ifdef EWFLUSH
660	{ NFSERR_WFLUSH, EWFLUSH },
661	#endif
662	{ NFSERR_BADHANDLE, EBADHANDLE },
663	{ NFSERR_NOT_SYNC, ENOTSYNC },
664	{ NFSERR_BAD_COOKIE, EBADCOOKIE },
665	{ NFSERR_NOTSUPP, ENOTSUPP },
666	{ NFSERR_TOOSMALL, ETOOSMALL },
667	{ NFSERR_SERVERFAULT, ESERVERFAULT },
668	{ NFSERR_BADTYPE, EBADTYPE },
669	{ NFSERR_JUKEBOX, EJUKEBOX },
670	{ -1, EIO }
671	};
672
673	/*
674	* Convert an NFS error code to a local one.
675	* This one is used jointly by NFSv2 and NFSv3.
676	*/
677	int
678	nfs_stat_to_errno(int stat)
679	{
680	int i;
681
682	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
683	if (nfs_errtbl[i].stat == stat)
684	return nfs_errtbl[i].errno;
685	}
686	printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
687	return nfs_errtbl[i].errno;
688	}
689
690	#ifndef MAX
691	# define MAX(a, b) (((a) > (b))? (a) : (b))
692	#endif
693
694	#define PROC(proc, argtype, restype, timer) \
695	[NFSPROC_##proc] = { \
696	.p_proc = NFSPROC_##proc, \
697	.p_encode = (kxdrproc_t) nfs_xdr_##argtype, \
698	.p_decode = (kxdrproc_t) nfs_xdr_##restype, \
699	.p_bufsiz = MAX(NFS_##argtype##_sz,NFS_##restype##_sz) << 2, \
cc0175c1 CL	700	.p_timer = timer, \
	701	.p_statidx = NFSPROC_##proc, \
	702	.p_name = #proc, \
1da177e4 LT	703	}
	704	struct rpc_procinfo nfs_procedures[] = {
	705	PROC(GETATTR, fhandle, attrstat, 1),
	706	PROC(SETATTR, sattrargs, attrstat, 0),
	707	PROC(LOOKUP, diropargs, diropres, 2),
	708	PROC(READLINK, readlinkargs, readlinkres, 3),
	709	PROC(READ, readargs, readres, 3),
	710	PROC(WRITE, writeargs, writeres, 4),
	711	PROC(CREATE, createargs, diropres, 0),
	712	PROC(REMOVE, diropargs, stat, 0),
	713	PROC(RENAME, renameargs, stat, 0),
	714	PROC(LINK, linkargs, stat, 0),
	715	PROC(SYMLINK, symlinkargs, stat, 0),
	716	PROC(MKDIR, createargs, diropres, 0),
	717	PROC(RMDIR, diropargs, stat, 0),
	718	PROC(READDIR, readdirargs, readdirres, 3),
	719	PROC(STATFS, fhandle, statfsres, 0),
	720	};
	721
	722	struct rpc_version nfs_version2 = {
	723	.number = 2,
e8c96f8c	724	.nrprocs = ARRAY_SIZE(nfs_procedures),
1da177e4 LT	725	.procs = nfs_procedures
1da177e4 LT	726	};