[linux.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 <[email protected]>
 * 		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>

#define NFSDBG_FACILITY		NFSDBG_XDR
/* #define NFS_PARANOIA 1 */

extern int			nfs_stat_to_errno(int stat);

/* 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+NFS_path_sz+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_u.nfs3 = ntohl(*p++);
	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)
{
	p = xdr_encode_fhandle(p, args->fromfh);
	p = xdr_encode_array(p, args->fromname, args->fromlen);
	p = xdr_encode_array(p, args->topath, args->tolen);
	p = xdr_encode_sattr(p, args->sattr);
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	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		= sizeof(nfs_procedures)/sizeof(nfs_procedures[0]),
	.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 <[email protected]>
	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>
	26
	27	#define NFSDBG_FACILITY NFSDBG_XDR
	28	/* #define NFS_PARANOIA 1 */
	29
	30	extern int nfs_stat_to_errno(int stat);
	31
	32	/* Mapping from NFS error code to "errno" error code. */
	33	#define errno_NFSERR_IO EIO
	34
	35	/*
	36	* Declare the space requirements for NFS arguments and replies as
	37	* number of 32bit-words
	38	*/
	39	#define NFS_fhandle_sz (8)
	40	#define NFS_sattr_sz (8)
	41	#define NFS_filename_sz (1+(NFS2_MAXNAMLEN>>2))
	42	#define NFS_path_sz (1+(NFS2_MAXPATHLEN>>2))
	43	#define NFS_fattr_sz (17)
	44	#define NFS_info_sz (5)
	45	#define NFS_entry_sz (NFS_filename_sz+3)
	46
	47	#define NFS_diropargs_sz (NFS_fhandle_sz+NFS_filename_sz)
	48	#define NFS_sattrargs_sz (NFS_fhandle_sz+NFS_sattr_sz)
	49	#define NFS_readlinkargs_sz (NFS_fhandle_sz)
	50	#define NFS_readargs_sz (NFS_fhandle_sz+3)
	51	#define NFS_writeargs_sz (NFS_fhandle_sz+4)
	52	#define NFS_createargs_sz (NFS_diropargs_sz+NFS_sattr_sz)
	53	#define NFS_renameargs_sz (NFS_diropargs_sz+NFS_diropargs_sz)
	54	#define NFS_linkargs_sz (NFS_fhandle_sz+NFS_diropargs_sz)
	55	#define NFS_symlinkargs_sz (NFS_diropargs_sz+NFS_path_sz+NFS_sattr_sz)
	56	#define NFS_readdirargs_sz (NFS_fhandle_sz+2)
	57
	58	#define NFS_attrstat_sz (1+NFS_fattr_sz)
	59	#define NFS_diropres_sz (1+NFS_fhandle_sz+NFS_fattr_sz)
	60	#define NFS_readlinkres_sz (2)
	61	#define NFS_readres_sz (1+NFS_fattr_sz+1)
	62	#define NFS_writeres_sz (NFS_attrstat_sz)
	63	#define NFS_stat_sz (1)
	64	#define NFS_readdirres_sz (1)
65	#define NFS_statfsres_sz (1+NFS_info_sz)
66
67	/*
68	* Common NFS XDR functions as inlines
69	*/
70	static inline u32 *
71	xdr_encode_fhandle(u32 p, struct nfs_fh fhandle)
72	{
73	memcpy(p, fhandle->data, NFS2_FHSIZE);
74	return p + XDR_QUADLEN(NFS2_FHSIZE);
75	}
76
77	static inline u32 *
78	xdr_decode_fhandle(u32 p, struct nfs_fh fhandle)
79	{
80	/* NFSv2 handles have a fixed length */
81	fhandle->size = NFS2_FHSIZE;
82	memcpy(fhandle->data, p, NFS2_FHSIZE);
83	return p + XDR_QUADLEN(NFS2_FHSIZE);
84	}
85
86	static inline u32*
87	xdr_encode_time(u32 p, struct timespec timep)
88	{
89	*p++ = htonl(timep->tv_sec);
90	/* Convert nanoseconds into microseconds */
91	*p++ = htonl(timep->tv_nsec ? timep->tv_nsec / 1000 : 0);
92	return p;
93	}
94
95	static inline u32*
96	xdr_encode_current_server_time(u32 p, struct timespec timep)
97	{
98	/*
99	* Passing the invalid value useconds=1000000 is a
100	* Sun convention for "set to current server time".
101	* It's needed to make permissions checks for the
102	* "touch" program across v2 mounts to Solaris and
103	* Irix boxes work correctly. See description of
104	* sattr in section 6.1 of "NFS Illustrated" by
105	* Brent Callaghan, Addison-Wesley, ISBN 0-201-32750-5
106	*/
107	*p++ = htonl(timep->tv_sec);
108	*p++ = htonl(1000000);
109	return p;
110	}
111
112	static inline u32*
113	xdr_decode_time(u32 p, struct timespec timep)
114	{
115	timep->tv_sec = ntohl(*p++);
116	/* Convert microseconds into nanoseconds */
117	timep->tv_nsec = ntohl(p++) 1000;
118	return p;
119	}
120
121	static u32 *
122	xdr_decode_fattr(u32 p, struct nfs_fattr fattr)
123	{
124	u32 rdev;
125	fattr->type = (enum nfs_ftype) ntohl(*p++);
126	fattr->mode = ntohl(*p++);
127	fattr->nlink = ntohl(*p++);
128	fattr->uid = ntohl(*p++);
129	fattr->gid = ntohl(*p++);
130	fattr->size = ntohl(*p++);
131	fattr->du.nfs2.blocksize = ntohl(*p++);
132	rdev = ntohl(*p++);
133	fattr->du.nfs2.blocks = ntohl(*p++);
134	fattr->fsid_u.nfs3 = ntohl(*p++);
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	{
354	p = xdr_encode_fhandle(p, args->fromfh);
355	p = xdr_encode_array(p, args->fromname, args->fromlen);
356	p = xdr_encode_array(p, args->topath, args->tolen);
357	p = xdr_encode_sattr(p, args->sattr);
358	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
359	return 0;
360	}
361
362	/*
363	* Encode arguments to readdir call
364	*/
365	static int
366	nfs_xdr_readdirargs(struct rpc_rqst req, u32 p, struct nfs_readdirargs *args)
367	{
368	struct rpc_task *task = req->rq_task;
369	struct rpc_auth *auth = task->tk_auth;
370	unsigned int replen;
371	u32 count = args->count;
372
373	p = xdr_encode_fhandle(p, args->fh);
374	*p++ = htonl(args->cookie);
375	p++ = htonl(count); / see above */
376	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
377
378	/* Inline the page array */
379	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readdirres_sz) << 2;
380	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, 0, count);
381	return 0;
382	}
383
384	/*
385	* Decode the result of a readdir call.
386	* We're not really decoding anymore, we just leave the buffer untouched
387	* and only check that it is syntactically correct.
388	* The real decoding happens in nfs_decode_entry below, called directly
389	* from nfs_readdir for each entry.
390	*/
391	static int
392	nfs_xdr_readdirres(struct rpc_rqst req, u32 p, void *dummy)
393	{
394	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
395	struct kvec *iov = rcvbuf->head;
396	struct page **page;
397	int hdrlen, recvd;
398	int status, nr;
399	unsigned int len, pglen;
400	u32 end, entry, *kaddr;
401
402	if ((status = ntohl(*p++)))
403	return -nfs_stat_to_errno(status);
404
405	hdrlen = (u8 ) p - (u8 ) iov->iov_base;
406	if (iov->iov_len < hdrlen) {
407	printk(KERN_WARNING "NFS: READDIR reply header overflowed:"
408	"length %d > %Zu\n", hdrlen, iov->iov_len);
409	return -errno_NFSERR_IO;
410	} else if (iov->iov_len != hdrlen) {
411	dprintk("NFS: READDIR header is short. iovec will be shifted.\n");
412	xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
413	}
414
415	pglen = rcvbuf->page_len;
416	recvd = rcvbuf->len - hdrlen;
417	if (pglen > recvd)
418	pglen = recvd;
419	page = rcvbuf->pages;
420	kaddr = p = (u32 )kmap_atomic(page, KM_USER0);
421	end = (u32 )((char )p + pglen);
422	entry = p;
423	for (nr = 0; *p++; nr++) {
424	if (p + 2 > end)
425	goto short_pkt;
426	p++; /* fileid */
427	len = ntohl(*p++);
428	p += XDR_QUADLEN(len) + 1; /* name plus cookie */
429	if (len > NFS2_MAXNAMLEN) {
430	printk(KERN_WARNING "NFS: giant filename in readdir (len 0x%x)!\n",
431	len);
432	goto err_unmap;
433	}
434	if (p + 2 > end)
435	goto short_pkt;
436	entry = p;
437	}
438	if (!nr && (entry[0] != 0 \|\| entry[1] == 0))
439	goto short_pkt;
440	out:
441	kunmap_atomic(kaddr, KM_USER0);
442	return nr;
443	short_pkt:
444	entry[0] = entry[1] = 0;
445	/* truncate listing ? */
446	if (!nr) {
447	printk(KERN_NOTICE "NFS: readdir reply truncated!\n");
448	entry[1] = 1;
449	}
450	goto out;
451	err_unmap:
452	nr = -errno_NFSERR_IO;
453	goto out;
454	}
455
456	u32 *
457	nfs_decode_dirent(u32 p, struct nfs_entry entry, int plus)
458	{
459	if (!*p++) {
460	if (!*p)
461	return ERR_PTR(-EAGAIN);
462	entry->eof = 1;
463	return ERR_PTR(-EBADCOOKIE);
464	}
465
466	entry->ino = ntohl(*p++);
467	entry->len = ntohl(*p++);
468	entry->name = (const char *) p;
469	p += XDR_QUADLEN(entry->len);
470	entry->prev_cookie = entry->cookie;
471	entry->cookie = ntohl(*p++);
472	entry->eof = !p[0] && p[1];
473
474	return p;
475	}
476
477	/*
478	* NFS XDR decode functions
479	*/
480	/*
481	* Decode simple status reply
482	*/
483	static int
484	nfs_xdr_stat(struct rpc_rqst req, u32 p, void *dummy)
485	{
486	int status;
487
488	if ((status = ntohl(*p++)) != 0)
489	status = -nfs_stat_to_errno(status);
490	return status;
491	}
492
493	/*
494	* Decode attrstat reply
495	* GETATTR, SETATTR, WRITE
496	*/
497	static int
498	nfs_xdr_attrstat(struct rpc_rqst req, u32 p, struct nfs_fattr *fattr)
499	{
500	int status;
501
502	if ((status = ntohl(*p++)))
503	return -nfs_stat_to_errno(status);
504	xdr_decode_fattr(p, fattr);
505	return 0;
506	}
507
508	/*
509	* Decode diropres reply
510	* LOOKUP, CREATE, MKDIR
511	*/
512	static int
513	nfs_xdr_diropres(struct rpc_rqst req, u32 p, struct nfs_diropok *res)
514	{
515	int status;
516
517	if ((status = ntohl(*p++)))
518	return -nfs_stat_to_errno(status);
519	p = xdr_decode_fhandle(p, res->fh);
520	xdr_decode_fattr(p, res->fattr);
521	return 0;
522	}
523
524	/*
525	* Encode READLINK args
526	*/
527	static int
528	nfs_xdr_readlinkargs(struct rpc_rqst req, u32 p, struct nfs_readlinkargs *args)
529	{
530	struct rpc_auth *auth = req->rq_task->tk_auth;
531	unsigned int replen;
532
533	p = xdr_encode_fhandle(p, args->fh);
534	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
535
536	/* Inline the page array */
537	replen = (RPC_REPHDRSIZE + auth->au_rslack + NFS_readlinkres_sz) << 2;
538	xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages, args->pgbase, args->pglen);
539	return 0;
540	}
541
542	/*
543	* Decode READLINK reply
544	*/
545	static int
546	nfs_xdr_readlinkres(struct rpc_rqst req, u32 p, void *dummy)
547	{
548	struct xdr_buf *rcvbuf = &req->rq_rcv_buf;
549	struct kvec *iov = rcvbuf->head;
550	int hdrlen, len, recvd;
551	char *kaddr;
552	int status;
553
554	if ((status = ntohl(*p++)))
555	return -nfs_stat_to_errno(status);
556	/* Convert length of symlink */
557	len = ntohl(*p++);
558	if (len >= rcvbuf->page_len \|\| len <= 0) {
559	dprintk(KERN_WARNING "nfs: server returned giant symlink!\n");
560	return -ENAMETOOLONG;
561	}
562	hdrlen = (u8 ) p - (u8 ) iov->iov_base;
563	if (iov->iov_len < hdrlen) {
564	printk(KERN_WARNING "NFS: READLINK reply header overflowed:"
565	"length %d > %Zu\n", hdrlen, iov->iov_len);
566	return -errno_NFSERR_IO;
567	} else if (iov->iov_len != hdrlen) {
568	dprintk("NFS: READLINK header is short. iovec will be shifted.\n");
569	xdr_shift_buf(rcvbuf, iov->iov_len - hdrlen);
570	}
571	recvd = req->rq_rcv_buf.len - hdrlen;
572	if (recvd < len) {
573	printk(KERN_WARNING "NFS: server cheating in readlink reply: "
574	"count %u > recvd %u\n", len, recvd);
575	return -EIO;
576	}
577
578	/* NULL terminate the string we got */
579	kaddr = (char *)kmap_atomic(rcvbuf->pages[0], KM_USER0);
580	kaddr[len+rcvbuf->page_base] = '\0';
581	kunmap_atomic(kaddr, KM_USER0);
582	return 0;
583	}
584
585	/*
586	* Decode WRITE reply
587	*/
588	static int
589	nfs_xdr_writeres(struct rpc_rqst req, u32 p, struct nfs_writeres *res)
590	{
591	res->verf->committed = NFS_FILE_SYNC;
592	return nfs_xdr_attrstat(req, p, res->fattr);
593	}
594
595	/*
596	* Decode STATFS reply
597	*/
598	static int
599	nfs_xdr_statfsres(struct rpc_rqst req, u32 p, struct nfs2_fsstat *res)
600	{
601	int status;
602
603	if ((status = ntohl(*p++)))
604	return -nfs_stat_to_errno(status);
605
606	res->tsize = ntohl(*p++);
607	res->bsize = ntohl(*p++);
608	res->blocks = ntohl(*p++);
609	res->bfree = ntohl(*p++);
610	res->bavail = ntohl(*p++);
611	return 0;
612	}
613
614	/*
615	* We need to translate between nfs status return values and
616	* the local errno values which may not be the same.
617	*/
618	static struct {
619	int stat;
620	int errno;
621	} nfs_errtbl[] = {
622	{ NFS_OK, 0 },
623	{ NFSERR_PERM, EPERM },
624	{ NFSERR_NOENT, ENOENT },
625	{ NFSERR_IO, errno_NFSERR_IO },
626	{ NFSERR_NXIO, ENXIO },
627	/* { NFSERR_EAGAIN, EAGAIN }, */
628	{ NFSERR_ACCES, EACCES },
629	{ NFSERR_EXIST, EEXIST },
630	{ NFSERR_XDEV, EXDEV },
631	{ NFSERR_NODEV, ENODEV },
632	{ NFSERR_NOTDIR, ENOTDIR },
633	{ NFSERR_ISDIR, EISDIR },
634	{ NFSERR_INVAL, EINVAL },
635	{ NFSERR_FBIG, EFBIG },
636	{ NFSERR_NOSPC, ENOSPC },
637	{ NFSERR_ROFS, EROFS },
638	{ NFSERR_MLINK, EMLINK },
639	{ NFSERR_NAMETOOLONG, ENAMETOOLONG },
640	{ NFSERR_NOTEMPTY, ENOTEMPTY },
641	{ NFSERR_DQUOT, EDQUOT },
642	{ NFSERR_STALE, ESTALE },
643	{ NFSERR_REMOTE, EREMOTE },
644	#ifdef EWFLUSH
645	{ NFSERR_WFLUSH, EWFLUSH },
646	#endif
647	{ NFSERR_BADHANDLE, EBADHANDLE },
648	{ NFSERR_NOT_SYNC, ENOTSYNC },
649	{ NFSERR_BAD_COOKIE, EBADCOOKIE },
650	{ NFSERR_NOTSUPP, ENOTSUPP },
651	{ NFSERR_TOOSMALL, ETOOSMALL },
652	{ NFSERR_SERVERFAULT, ESERVERFAULT },
653	{ NFSERR_BADTYPE, EBADTYPE },
654	{ NFSERR_JUKEBOX, EJUKEBOX },
655	{ -1, EIO }
656	};
657
658	/*
659	* Convert an NFS error code to a local one.
660	* This one is used jointly by NFSv2 and NFSv3.
661	*/
662	int
663	nfs_stat_to_errno(int stat)
664	{
665	int i;
666
667	for (i = 0; nfs_errtbl[i].stat != -1; i++) {
668	if (nfs_errtbl[i].stat == stat)
669	return nfs_errtbl[i].errno;
670	}
671	printk(KERN_ERR "nfs_stat_to_errno: bad nfs status return value: %d\n", stat);
672	return nfs_errtbl[i].errno;
673	}
674
675	#ifndef MAX
676	# define MAX(a, b) (((a) > (b))? (a) : (b))
677	#endif
678
679	#define PROC(proc, argtype, restype, timer) \
680	[NFSPROC_##proc] = { \
681	.p_proc = NFSPROC_##proc, \
682	.p_encode = (kxdrproc_t) nfs_xdr_##argtype, \
683	.p_decode = (kxdrproc_t) nfs_xdr_##restype, \
684	.p_bufsiz = MAX(NFS_##argtype##_sz,NFS_##restype##_sz) << 2, \
cc0175c1 CL	685	.p_timer = timer, \
	686	.p_statidx = NFSPROC_##proc, \
	687	.p_name = #proc, \
1da177e4 LT	688	}
	689	struct rpc_procinfo nfs_procedures[] = {
	690	PROC(GETATTR, fhandle, attrstat, 1),
	691	PROC(SETATTR, sattrargs, attrstat, 0),
	692	PROC(LOOKUP, diropargs, diropres, 2),
	693	PROC(READLINK, readlinkargs, readlinkres, 3),
	694	PROC(READ, readargs, readres, 3),
	695	PROC(WRITE, writeargs, writeres, 4),
	696	PROC(CREATE, createargs, diropres, 0),
	697	PROC(REMOVE, diropargs, stat, 0),
	698	PROC(RENAME, renameargs, stat, 0),
	699	PROC(LINK, linkargs, stat, 0),
	700	PROC(SYMLINK, symlinkargs, stat, 0),
	701	PROC(MKDIR, createargs, diropres, 0),
	702	PROC(RMDIR, diropargs, stat, 0),
	703	PROC(READDIR, readdirargs, readdirres, 3),
	704	PROC(STATFS, fhandle, statfsres, 0),
	705	};
	706
	707	struct rpc_version nfs_version2 = {
	708	.number = 2,
	709	.nrprocs = sizeof(nfs_procedures)/sizeof(nfs_procedures[0]),
	710	.procs = nfs_procedures
	711	};