[linux.git] / fs / lockd / xdr4.c

/*
 * linux/fs/lockd/xdr4.c
 *
 * XDR support for lockd and the lock client.
 *
 * Copyright (C) 1995, 1996 Olaf Kirch <[email protected]>
 * Copyright (C) 1999, Trond Myklebust <[email protected]>
 */

#include <linux/types.h>
#include <linux/sched.h>
#include <linux/utsname.h>
#include <linux/nfs.h>

#include <linux/sunrpc/xdr.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/svc.h>
#include <linux/sunrpc/stats.h>
#include <linux/lockd/lockd.h>

#define NLMDBG_FACILITY		NLMDBG_XDR

static inline loff_t
s64_to_loff_t(__s64 offset)
{
	return (loff_t)offset;
}


static inline s64
loff_t_to_s64(loff_t offset)
{
	s64 res;
	if (offset > NLM4_OFFSET_MAX)
		res = NLM4_OFFSET_MAX;
	else if (offset < -NLM4_OFFSET_MAX)
		res = -NLM4_OFFSET_MAX;
	else
		res = offset;
	return res;
}

/*
 * XDR functions for basic NLM types
 */
static __be32 *
nlm4_decode_cookie(__be32 *p, struct nlm_cookie *c)
{
	unsigned int	len;

	len = ntohl(*p++);
	
	if(len==0)
	{
		c->len=4;
		memset(c->data, 0, 4);	/* hockeypux brain damage */
	}
	else if(len<=NLM_MAXCOOKIELEN)
	{
		c->len=len;
		memcpy(c->data, p, len);
		p+=XDR_QUADLEN(len);
	}
	else 
	{
		dprintk("lockd: bad cookie size %d (only cookies under "
			"%d bytes are supported.)\n",
				len, NLM_MAXCOOKIELEN);
		return NULL;
	}
	return p;
}

static __be32 *
nlm4_encode_cookie(__be32 *p, struct nlm_cookie *c)
{
	*p++ = htonl(c->len);
	memcpy(p, c->data, c->len);
	p+=XDR_QUADLEN(c->len);
	return p;
}

static __be32 *
nlm4_decode_fh(__be32 *p, struct nfs_fh *f)
{
	memset(f->data, 0, sizeof(f->data));
	f->size = ntohl(*p++);
	if (f->size > NFS_MAXFHSIZE) {
		dprintk("lockd: bad fhandle size %d (should be <=%d)\n",
			f->size, NFS_MAXFHSIZE);
		return NULL;
	}
      	memcpy(f->data, p, f->size);
	return p + XDR_QUADLEN(f->size);
}

static __be32 *
nlm4_encode_fh(__be32 *p, struct nfs_fh *f)
{
	*p++ = htonl(f->size);
	if (f->size) p[XDR_QUADLEN(f->size)-1] = 0; /* don't leak anything */
	memcpy(p, f->data, f->size);
	return p + XDR_QUADLEN(f->size);
}

/*
 * Encode and decode owner handle
 */
static __be32 *
nlm4_decode_oh(__be32 *p, struct xdr_netobj *oh)
{
	return xdr_decode_netobj(p, oh);
}

static __be32 *
nlm4_encode_oh(__be32 *p, struct xdr_netobj *oh)
{
	return xdr_encode_netobj(p, oh);
}

static __be32 *
nlm4_decode_lock(__be32 *p, struct nlm_lock *lock)
{
	struct file_lock	*fl = &lock->fl;
	__u64			len, start;
	__s64			end;

	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
					    &lock->len, NLM_MAXSTRLEN))
	 || !(p = nlm4_decode_fh(p, &lock->fh))
	 || !(p = nlm4_decode_oh(p, &lock->oh)))
		return NULL;
	lock->svid  = ntohl(*p++);

	locks_init_lock(fl);
	fl->fl_owner = current->files;
	fl->fl_pid   = (pid_t)lock->svid;
	fl->fl_flags = FL_POSIX;
	fl->fl_type  = F_RDLCK;		/* as good as anything else */
	p = xdr_decode_hyper(p, &start);
	p = xdr_decode_hyper(p, &len);
	end = start + len - 1;

	fl->fl_start = s64_to_loff_t(start);

	if (len == 0 || end < 0)
		fl->fl_end = OFFSET_MAX;
	else
		fl->fl_end = s64_to_loff_t(end);
	return p;
}

/*
 * Encode a lock as part of an NLM call
 */
static __be32 *
nlm4_encode_lock(__be32 *p, struct nlm_lock *lock)
{
	struct file_lock	*fl = &lock->fl;
	__s64			start, len;

	if (!(p = xdr_encode_string(p, lock->caller))
	 || !(p = nlm4_encode_fh(p, &lock->fh))
	 || !(p = nlm4_encode_oh(p, &lock->oh)))
		return NULL;

	if (fl->fl_start > NLM4_OFFSET_MAX
	 || (fl->fl_end > NLM4_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
		return NULL;

	*p++ = htonl(lock->svid);

	start = loff_t_to_s64(fl->fl_start);
	if (fl->fl_end == OFFSET_MAX)
		len = 0;
	else
		len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);

	p = xdr_encode_hyper(p, start);
	p = xdr_encode_hyper(p, len);

	return p;
}

/*
 * Encode result of a TEST/TEST_MSG call
 */
static __be32 *
nlm4_encode_testres(__be32 *p, struct nlm_res *resp)
{
	s64		start, len;

	dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
		return NULL;
	*p++ = resp->status;

	if (resp->status == nlm_lck_denied) {
		struct file_lock	*fl = &resp->lock.fl;

		*p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
		*p++ = htonl(resp->lock.svid);

		/* Encode owner handle. */
		if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
			return NULL;

		start = loff_t_to_s64(fl->fl_start);
		if (fl->fl_end == OFFSET_MAX)
			len = 0;
		else
			len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
		
		p = xdr_encode_hyper(p, start);
		p = xdr_encode_hyper(p, len);
		dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n",
			resp->status, (int)resp->lock.svid, fl->fl_type,
			(long long)fl->fl_start,  (long long)fl->fl_end);
	}

	dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
	return p;
}


/*
 * First, the server side XDR functions
 */
int
nlm4svc_decode_testargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
{
	u32	exclusive;

	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
		return 0;

	exclusive = ntohl(*p++);
	if (!(p = nlm4_decode_lock(p, &argp->lock)))
		return 0;
	if (exclusive)
		argp->lock.fl.fl_type = F_WRLCK;

	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_encode_testres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_encode_testres(p, resp)))
		return 0;
	return xdr_ressize_check(rqstp, p);
}

int
nlm4svc_decode_lockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
{
	u32	exclusive;

	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
		return 0;
	argp->block  = ntohl(*p++);
	exclusive    = ntohl(*p++);
	if (!(p = nlm4_decode_lock(p, &argp->lock)))
		return 0;
	if (exclusive)
		argp->lock.fl.fl_type = F_WRLCK;
	argp->reclaim = ntohl(*p++);
	argp->state   = ntohl(*p++);
	argp->monitor = 1;		/* monitor client by default */

	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_cancargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
{
	u32	exclusive;

	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
		return 0;
	argp->block = ntohl(*p++);
	exclusive = ntohl(*p++);
	if (!(p = nlm4_decode_lock(p, &argp->lock)))
		return 0;
	if (exclusive)
		argp->lock.fl.fl_type = F_WRLCK;
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_unlockargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
{
	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
	 || !(p = nlm4_decode_lock(p, &argp->lock)))
		return 0;
	argp->lock.fl.fl_type = F_UNLCK;
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_shareargs(struct svc_rqst *rqstp, __be32 *p, nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	memset(lock, 0, sizeof(*lock));
	locks_init_lock(&lock->fl);
	lock->svid = ~(u32) 0;
	lock->fl.fl_pid = (pid_t)lock->svid;

	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
	 || !(p = xdr_decode_string_inplace(p, &lock->caller,
					    &lock->len, NLM_MAXSTRLEN))
	 || !(p = nlm4_decode_fh(p, &lock->fh))
	 || !(p = nlm4_decode_oh(p, &lock->oh)))
		return 0;
	argp->fsm_mode = ntohl(*p++);
	argp->fsm_access = ntohl(*p++);
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_encode_shareres(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
		return 0;
	*p++ = resp->status;
	*p++ = xdr_zero;		/* sequence argument */
	return xdr_ressize_check(rqstp, p);
}

int
nlm4svc_encode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
		return 0;
	*p++ = resp->status;
	return xdr_ressize_check(rqstp, p);
}

int
nlm4svc_decode_notify(struct svc_rqst *rqstp, __be32 *p, struct nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
					    &lock->len, NLM_MAXSTRLEN)))
		return 0;
	argp->state = ntohl(*p++);
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_reboot(struct svc_rqst *rqstp, __be32 *p, struct nlm_reboot *argp)
{
	if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
		return 0;
	argp->state = ntohl(*p++);
	memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
	p += XDR_QUADLEN(SM_PRIV_SIZE);
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_res(struct svc_rqst *rqstp, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
		return 0;
	resp->status = *p++;
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_decode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
{
	return xdr_argsize_check(rqstp, p);
}

int
nlm4svc_encode_void(struct svc_rqst *rqstp, __be32 *p, void *dummy)
{
	return xdr_ressize_check(rqstp, p);
}

/*
 * Now, the client side XDR functions
 */
#ifdef NLMCLNT_SUPPORT_SHARES
static int
nlm4clt_decode_void(struct rpc_rqst *req, __be32 *p, void *ptr)
{
	return 0;
}
#endif

static int
nlm4clt_encode_testargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
		return -EIO;
	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	if (!(p = nlm4_encode_lock(p, lock)))
		return -EIO;
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_decode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
		return -EIO;
	resp->status = *p++;
	if (resp->status == nlm_lck_denied) {
		struct file_lock	*fl = &resp->lock.fl;
		u32			excl;
		__u64			start, len;
		__s64			end;

		memset(&resp->lock, 0, sizeof(resp->lock));
		locks_init_lock(fl);
		excl = ntohl(*p++);
		resp->lock.svid = ntohl(*p++);
		fl->fl_pid = (pid_t)resp->lock.svid;
		if (!(p = nlm4_decode_oh(p, &resp->lock.oh)))
			return -EIO;

		fl->fl_flags = FL_POSIX;
		fl->fl_type  = excl? F_WRLCK : F_RDLCK;
		p = xdr_decode_hyper(p, &start);
		p = xdr_decode_hyper(p, &len);
		end = start + len - 1;

		fl->fl_start = s64_to_loff_t(start);
		if (len == 0 || end < 0)
			fl->fl_end = OFFSET_MAX;
		else
			fl->fl_end = s64_to_loff_t(end);
	}
	return 0;
}


static int
nlm4clt_encode_lockargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
		return -EIO;
	*p++ = argp->block? xdr_one : xdr_zero;
	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	if (!(p = nlm4_encode_lock(p, lock)))
		return -EIO;
	*p++ = argp->reclaim? xdr_one : xdr_zero;
	*p++ = htonl(argp->state);
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_encode_cancargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
		return -EIO;
	*p++ = argp->block? xdr_one : xdr_zero;
	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	if (!(p = nlm4_encode_lock(p, lock)))
		return -EIO;
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_encode_unlockargs(struct rpc_rqst *req, __be32 *p, nlm_args *argp)
{
	struct nlm_lock	*lock = &argp->lock;

	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
		return -EIO;
	if (!(p = nlm4_encode_lock(p, lock)))
		return -EIO;
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_encode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
		return -EIO;
	*p++ = resp->status;
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_encode_testres(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_encode_testres(p, resp)))
		return -EIO;
	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	return 0;
}

static int
nlm4clt_decode_res(struct rpc_rqst *req, __be32 *p, struct nlm_res *resp)
{
	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
		return -EIO;
	resp->status = *p++;
	return 0;
}

#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
#  error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
#endif

#if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)
#  error "NLM host name cannot be larger than NLM's maximum string length!"
#endif

/*
 * Buffer requirements for NLM
 */
#define NLM4_void_sz		0
#define NLM4_cookie_sz		1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
#define NLM4_caller_sz		1+XDR_QUADLEN(NLMCLNT_OHSIZE)
#define NLM4_owner_sz		1+XDR_QUADLEN(NLMCLNT_OHSIZE)
#define NLM4_fhandle_sz		1+XDR_QUADLEN(NFS3_FHSIZE)
#define NLM4_lock_sz		5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz
#define NLM4_holder_sz		6+NLM4_owner_sz

#define NLM4_testargs_sz	NLM4_cookie_sz+1+NLM4_lock_sz
#define NLM4_lockargs_sz	NLM4_cookie_sz+4+NLM4_lock_sz
#define NLM4_cancargs_sz	NLM4_cookie_sz+2+NLM4_lock_sz
#define NLM4_unlockargs_sz	NLM4_cookie_sz+NLM4_lock_sz

#define NLM4_testres_sz		NLM4_cookie_sz+1+NLM4_holder_sz
#define NLM4_res_sz		NLM4_cookie_sz+1
#define NLM4_norep_sz		0

/*
 * For NLM, a void procedure really returns nothing
 */
#define nlm4clt_decode_norep	NULL

#define PROC(proc, argtype, restype)					\
[NLMPROC_##proc] = {							\
	.p_proc      = NLMPROC_##proc,					\
	.p_encode    = (kxdrproc_t) nlm4clt_encode_##argtype,		\
	.p_decode    = (kxdrproc_t) nlm4clt_decode_##restype,		\
	.p_arglen    = NLM4_##argtype##_sz,				\
	.p_replen    = NLM4_##restype##_sz,				\
	.p_statidx   = NLMPROC_##proc,					\
	.p_name      = #proc,						\
	}

static struct rpc_procinfo	nlm4_procedures[] = {
    PROC(TEST,		testargs,	testres),
    PROC(LOCK,		lockargs,	res),
    PROC(CANCEL,	cancargs,	res),
    PROC(UNLOCK,	unlockargs,	res),
    PROC(GRANTED,	testargs,	res),
    PROC(TEST_MSG,	testargs,	norep),
    PROC(LOCK_MSG,	lockargs,	norep),
    PROC(CANCEL_MSG,	cancargs,	norep),
    PROC(UNLOCK_MSG,	unlockargs,	norep),
    PROC(GRANTED_MSG,	testargs,	norep),
    PROC(TEST_RES,	testres,	norep),
    PROC(LOCK_RES,	res,		norep),
    PROC(CANCEL_RES,	res,		norep),
    PROC(UNLOCK_RES,	res,		norep),
    PROC(GRANTED_RES,	res,		norep),
#ifdef NLMCLNT_SUPPORT_SHARES
    PROC(SHARE,		shareargs,	shareres),
    PROC(UNSHARE,	shareargs,	shareres),
    PROC(NM_LOCK,	lockargs,	res),
    PROC(FREE_ALL,	notify,		void),
#endif
};

struct rpc_version	nlm_version4 = {
	.number		= 4,
	.nrprocs	= 24,
	.procs		= nlm4_procedures,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/lockd/xdr4.c
	3	*
	4	* XDR support for lockd and the lock client.
	5	*
	6	* Copyright (C) 1995, 1996 Olaf Kirch <[email protected]>
	7	* Copyright (C) 1999, Trond Myklebust <[email protected]>
	8	*/
	9
	10	#include <linux/types.h>
	11	#include <linux/sched.h>
	12	#include <linux/utsname.h>
	13	#include <linux/nfs.h>
	14
	15	#include <linux/sunrpc/xdr.h>
	16	#include <linux/sunrpc/clnt.h>
	17	#include <linux/sunrpc/svc.h>
	18	#include <linux/sunrpc/stats.h>
	19	#include <linux/lockd/lockd.h>
1da177e4 LT	20
	21	#define NLMDBG_FACILITY NLMDBG_XDR
	22
	23	static inline loff_t
	24	s64_to_loff_t(__s64 offset)
	25	{
	26	return (loff_t)offset;
	27	}
	28
	29
	30	static inline s64
	31	loff_t_to_s64(loff_t offset)
	32	{
	33	s64 res;
	34	if (offset > NLM4_OFFSET_MAX)
	35	res = NLM4_OFFSET_MAX;
	36	else if (offset < -NLM4_OFFSET_MAX)
	37	res = -NLM4_OFFSET_MAX;
	38	else
	39	res = offset;
	40	return res;
	41	}
	42
	43	/*
	44	* XDR functions for basic NLM types
	45	*/
52921e02 AV	46	static __be32 *
52921e02 AV	47	nlm4_decode_cookie(__be32 p, struct nlm_cookie c)
1da177e4 LT	48	{
	49	unsigned int len;
	50
	51	len = ntohl(*p++);
	52
	53	if(len==0)
	54	{
	55	c->len=4;
	56	memset(c->data, 0, 4); /* hockeypux brain damage */
	57	}
	58	else if(len<=NLM_MAXCOOKIELEN)
	59	{
	60	c->len=len;
	61	memcpy(c->data, p, len);
	62	p+=XDR_QUADLEN(len);
	63	}
	64	else
	65	{
e159a08b CL	66	dprintk("lockd: bad cookie size %d (only cookies under "
	67	"%d bytes are supported.)\n",
	68	len, NLM_MAXCOOKIELEN);
1da177e4 LT	69	return NULL;
	70	}
	71	return p;
	72	}
	73
52921e02 AV	74	static __be32 *
52921e02 AV	75	nlm4_encode_cookie(__be32 p, struct nlm_cookie c)
1da177e4 LT	76	{
	77	*p++ = htonl(c->len);
	78	memcpy(p, c->data, c->len);
	79	p+=XDR_QUADLEN(c->len);
	80	return p;
	81	}
	82
52921e02 AV	83	static __be32 *
52921e02 AV	84	nlm4_decode_fh(__be32 p, struct nfs_fh f)
1da177e4 LT	85	{
	86	memset(f->data, 0, sizeof(f->data));
	87	f->size = ntohl(*p++);
	88	if (f->size > NFS_MAXFHSIZE) {
e159a08b	89	dprintk("lockd: bad fhandle size %d (should be <=%d)\n",
1da177e4 LT	90	f->size, NFS_MAXFHSIZE);
	91	return NULL;
	92	}
	93	memcpy(f->data, p, f->size);
	94	return p + XDR_QUADLEN(f->size);
	95	}
	96
52921e02 AV	97	static __be32 *
52921e02 AV	98	nlm4_encode_fh(__be32 p, struct nfs_fh f)
1da177e4 LT	99	{
	100	*p++ = htonl(f->size);
	101	if (f->size) p[XDR_QUADLEN(f->size)-1] = 0; /* don't leak anything */
	102	memcpy(p, f->data, f->size);
	103	return p + XDR_QUADLEN(f->size);
	104	}
	105
	106	/*
	107	* Encode and decode owner handle
	108	*/
52921e02 AV	109	static __be32 *
52921e02 AV	110	nlm4_decode_oh(__be32 p, struct xdr_netobj oh)
1da177e4 LT	111	{
	112	return xdr_decode_netobj(p, oh);
	113	}
	114
52921e02 AV	115	static __be32 *
52921e02 AV	116	nlm4_encode_oh(__be32 p, struct xdr_netobj oh)
1da177e4 LT	117	{
	118	return xdr_encode_netobj(p, oh);
	119	}
	120
52921e02 AV	121	static __be32 *
52921e02 AV	122	nlm4_decode_lock(__be32 p, struct nlm_lock lock)
1da177e4 LT	123	{
1da177e4 LT	124	struct file_lock *fl = &lock->fl;
d48c5f41 TM	125	__u64 len, start;
d48c5f41 TM	126	__s64 end;
1da177e4 LT	127
	128	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
	129	&lock->len, NLM_MAXSTRLEN))
	130	\|\| !(p = nlm4_decode_fh(p, &lock->fh))
	131	\|\| !(p = nlm4_decode_oh(p, &lock->oh)))
	132	return NULL;
7bab377f	133	lock->svid = ntohl(*p++);
1da177e4 LT	134
	135	locks_init_lock(fl);
	136	fl->fl_owner = current->files;
7bab377f	137	fl->fl_pid = (pid_t)lock->svid;
1da177e4 LT	138	fl->fl_flags = FL_POSIX;
	139	fl->fl_type = F_RDLCK; /* as good as anything else */
	140	p = xdr_decode_hyper(p, &start);
	141	p = xdr_decode_hyper(p, &len);
	142	end = start + len - 1;
	143
	144	fl->fl_start = s64_to_loff_t(start);
	145
	146	if (len == 0 \|\| end < 0)
	147	fl->fl_end = OFFSET_MAX;
	148	else
	149	fl->fl_end = s64_to_loff_t(end);
	150	return p;
	151	}
	152
	153	/*
	154	* Encode a lock as part of an NLM call
	155	*/
52921e02 AV	156	static __be32 *
52921e02 AV	157	nlm4_encode_lock(__be32 p, struct nlm_lock lock)
1da177e4 LT	158	{
	159	struct file_lock *fl = &lock->fl;
	160	__s64 start, len;
	161
	162	if (!(p = xdr_encode_string(p, lock->caller))
	163	\|\| !(p = nlm4_encode_fh(p, &lock->fh))
	164	\|\| !(p = nlm4_encode_oh(p, &lock->oh)))
	165	return NULL;
	166
	167	if (fl->fl_start > NLM4_OFFSET_MAX
	168	\|\| (fl->fl_end > NLM4_OFFSET_MAX && fl->fl_end != OFFSET_MAX))
	169	return NULL;
	170
7bab377f	171	*p++ = htonl(lock->svid);
1da177e4 LT	172
	173	start = loff_t_to_s64(fl->fl_start);
	174	if (fl->fl_end == OFFSET_MAX)
	175	len = 0;
	176	else
	177	len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
	178
	179	p = xdr_encode_hyper(p, start);
	180	p = xdr_encode_hyper(p, len);
	181
	182	return p;
	183	}
	184
	185	/*
	186	* Encode result of a TEST/TEST_MSG call
	187	*/
52921e02 AV	188	static __be32 *
52921e02 AV	189	nlm4_encode_testres(__be32 p, struct nlm_res resp)
1da177e4 LT	190	{
	191	s64 start, len;
	192
	193	dprintk("xdr: before encode_testres (p %p resp %p)\n", p, resp);
	194	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
	195	return NULL;
	196	*p++ = resp->status;
	197
	198	if (resp->status == nlm_lck_denied) {
	199	struct file_lock *fl = &resp->lock.fl;
	200
	201	*p++ = (fl->fl_type == F_RDLCK)? xdr_zero : xdr_one;
7bab377f	202	*p++ = htonl(resp->lock.svid);
1da177e4 LT	203
	204	/* Encode owner handle. */
	205	if (!(p = xdr_encode_netobj(p, &resp->lock.oh)))
	206	return NULL;
	207
	208	start = loff_t_to_s64(fl->fl_start);
	209	if (fl->fl_end == OFFSET_MAX)
	210	len = 0;
	211	else
	212	len = loff_t_to_s64(fl->fl_end - fl->fl_start + 1);
	213
	214	p = xdr_encode_hyper(p, start);
	215	p = xdr_encode_hyper(p, len);
7bab377f TM	216	dprintk("xdr: encode_testres (status %u pid %d type %d start %Ld end %Ld)\n",
7bab377f TM	217	resp->status, (int)resp->lock.svid, fl->fl_type,
1da177e4 LT	218	(long long)fl->fl_start, (long long)fl->fl_end);
	219	}
	220
	221	dprintk("xdr: after encode_testres (p %p resp %p)\n", p, resp);
	222	return p;
	223	}
	224
	225
	226	/*
	227	* First, the server side XDR functions
	228	*/
	229	int
52921e02	230	nlm4svc_decode_testargs(struct svc_rqst rqstp, __be32 p, nlm_args *argp)
1da177e4 LT	231	{
	232	u32 exclusive;
	233
	234	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
	235	return 0;
	236
	237	exclusive = ntohl(*p++);
	238	if (!(p = nlm4_decode_lock(p, &argp->lock)))
	239	return 0;
	240	if (exclusive)
	241	argp->lock.fl.fl_type = F_WRLCK;
	242
	243	return xdr_argsize_check(rqstp, p);
	244	}
	245
	246	int
52921e02	247	nlm4svc_encode_testres(struct svc_rqst rqstp, __be32 p, struct nlm_res *resp)
1da177e4 LT	248	{
	249	if (!(p = nlm4_encode_testres(p, resp)))
	250	return 0;
	251	return xdr_ressize_check(rqstp, p);
	252	}
	253
	254	int
52921e02	255	nlm4svc_decode_lockargs(struct svc_rqst rqstp, __be32 p, nlm_args *argp)
1da177e4 LT	256	{
	257	u32 exclusive;
	258
	259	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
	260	return 0;
	261	argp->block = ntohl(*p++);
	262	exclusive = ntohl(*p++);
	263	if (!(p = nlm4_decode_lock(p, &argp->lock)))
	264	return 0;
	265	if (exclusive)
	266	argp->lock.fl.fl_type = F_WRLCK;
	267	argp->reclaim = ntohl(*p++);
	268	argp->state = ntohl(*p++);
	269	argp->monitor = 1; /* monitor client by default */
	270
	271	return xdr_argsize_check(rqstp, p);
	272	}
	273
	274	int
52921e02	275	nlm4svc_decode_cancargs(struct svc_rqst rqstp, __be32 p, nlm_args *argp)
1da177e4 LT	276	{
	277	u32 exclusive;
	278
	279	if (!(p = nlm4_decode_cookie(p, &argp->cookie)))
	280	return 0;
	281	argp->block = ntohl(*p++);
	282	exclusive = ntohl(*p++);
	283	if (!(p = nlm4_decode_lock(p, &argp->lock)))
	284	return 0;
	285	if (exclusive)
	286	argp->lock.fl.fl_type = F_WRLCK;
	287	return xdr_argsize_check(rqstp, p);
	288	}
	289
	290	int
52921e02	291	nlm4svc_decode_unlockargs(struct svc_rqst rqstp, __be32 p, nlm_args *argp)
1da177e4 LT	292	{
	293	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
	294	\|\| !(p = nlm4_decode_lock(p, &argp->lock)))
	295	return 0;
	296	argp->lock.fl.fl_type = F_UNLCK;
	297	return xdr_argsize_check(rqstp, p);
	298	}
	299
	300	int
52921e02	301	nlm4svc_decode_shareargs(struct svc_rqst rqstp, __be32 p, nlm_args *argp)
1da177e4 LT	302	{
	303	struct nlm_lock *lock = &argp->lock;
	304
	305	memset(lock, 0, sizeof(*lock));
	306	locks_init_lock(&lock->fl);
7bab377f TM	307	lock->svid = ~(u32) 0;
7bab377f TM	308	lock->fl.fl_pid = (pid_t)lock->svid;
1da177e4 LT	309
	310	if (!(p = nlm4_decode_cookie(p, &argp->cookie))
	311	\|\| !(p = xdr_decode_string_inplace(p, &lock->caller,
	312	&lock->len, NLM_MAXSTRLEN))
	313	\|\| !(p = nlm4_decode_fh(p, &lock->fh))
	314	\|\| !(p = nlm4_decode_oh(p, &lock->oh)))
	315	return 0;
	316	argp->fsm_mode = ntohl(*p++);
	317	argp->fsm_access = ntohl(*p++);
	318	return xdr_argsize_check(rqstp, p);
	319	}
	320
	321	int
52921e02	322	nlm4svc_encode_shareres(struct svc_rqst rqstp, __be32 p, struct nlm_res *resp)
1da177e4 LT	323	{
	324	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
	325	return 0;
	326	*p++ = resp->status;
	327	p++ = xdr_zero; / sequence argument */
	328	return xdr_ressize_check(rqstp, p);
	329	}
	330
	331	int
52921e02	332	nlm4svc_encode_res(struct svc_rqst rqstp, __be32 p, struct nlm_res *resp)
1da177e4 LT	333	{
	334	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
	335	return 0;
	336	*p++ = resp->status;
	337	return xdr_ressize_check(rqstp, p);
	338	}
	339
	340	int
52921e02	341	nlm4svc_decode_notify(struct svc_rqst rqstp, __be32 p, struct nlm_args *argp)
1da177e4 LT	342	{
	343	struct nlm_lock *lock = &argp->lock;
	344
	345	if (!(p = xdr_decode_string_inplace(p, &lock->caller,
	346	&lock->len, NLM_MAXSTRLEN)))
	347	return 0;
	348	argp->state = ntohl(*p++);
	349	return xdr_argsize_check(rqstp, p);
	350	}
	351
	352	int
52921e02	353	nlm4svc_decode_reboot(struct svc_rqst rqstp, __be32 p, struct nlm_reboot *argp)
1da177e4 LT	354	{
	355	if (!(p = xdr_decode_string_inplace(p, &argp->mon, &argp->len, SM_MAXSTRLEN)))
	356	return 0;
	357	argp->state = ntohl(*p++);
576df463 CL	358	memcpy(&argp->priv.data, p, sizeof(argp->priv.data));
576df463 CL	359	p += XDR_QUADLEN(SM_PRIV_SIZE);
1da177e4 LT	360	return xdr_argsize_check(rqstp, p);
	361	}
	362
	363	int
52921e02	364	nlm4svc_decode_res(struct svc_rqst rqstp, __be32 p, struct nlm_res *resp)
1da177e4 LT	365	{
	366	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
	367	return 0;
e8c5c045	368	resp->status = *p++;
1da177e4 LT	369	return xdr_argsize_check(rqstp, p);
	370	}
	371
	372	int
52921e02	373	nlm4svc_decode_void(struct svc_rqst rqstp, __be32 p, void *dummy)
1da177e4 LT	374	{
	375	return xdr_argsize_check(rqstp, p);
	376	}
	377
	378	int
52921e02	379	nlm4svc_encode_void(struct svc_rqst rqstp, __be32 p, void *dummy)
1da177e4 LT	380	{
	381	return xdr_ressize_check(rqstp, p);
	382	}
	383
	384	/*
	385	* Now, the client side XDR functions
	386	*/
	387	#ifdef NLMCLNT_SUPPORT_SHARES
	388	static int
52921e02	389	nlm4clt_decode_void(struct rpc_rqst req, __be32 p, void *ptr)
1da177e4 LT	390	{
	391	return 0;
	392	}
	393	#endif
	394
	395	static int
52921e02	396	nlm4clt_encode_testargs(struct rpc_rqst req, __be32 p, nlm_args *argp)
1da177e4 LT	397	{
	398	struct nlm_lock *lock = &argp->lock;
	399
	400	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
	401	return -EIO;
	402	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	403	if (!(p = nlm4_encode_lock(p, lock)))
	404	return -EIO;
	405	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	406	return 0;
	407	}
	408
	409	static int
52921e02	410	nlm4clt_decode_testres(struct rpc_rqst req, __be32 p, struct nlm_res *resp)
1da177e4 LT	411	{
	412	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
	413	return -EIO;
e8c5c045 AV	414	resp->status = *p++;
e8c5c045 AV	415	if (resp->status == nlm_lck_denied) {
1da177e4 LT	416	struct file_lock *fl = &resp->lock.fl;
1da177e4 LT	417	u32 excl;
d48c5f41 TM	418	__u64 start, len;
d48c5f41 TM	419	__s64 end;
1da177e4 LT	420
	421	memset(&resp->lock, 0, sizeof(resp->lock));
	422	locks_init_lock(fl);
	423	excl = ntohl(*p++);
7bab377f TM	424	resp->lock.svid = ntohl(*p++);
7bab377f TM	425	fl->fl_pid = (pid_t)resp->lock.svid;
1da177e4 LT	426	if (!(p = nlm4_decode_oh(p, &resp->lock.oh)))
	427	return -EIO;
	428
	429	fl->fl_flags = FL_POSIX;
	430	fl->fl_type = excl? F_WRLCK : F_RDLCK;
	431	p = xdr_decode_hyper(p, &start);
	432	p = xdr_decode_hyper(p, &len);
	433	end = start + len - 1;
	434
	435	fl->fl_start = s64_to_loff_t(start);
	436	if (len == 0 \|\| end < 0)
	437	fl->fl_end = OFFSET_MAX;
	438	else
	439	fl->fl_end = s64_to_loff_t(end);
	440	}
	441	return 0;
	442	}
	443
	444
	445	static int
52921e02	446	nlm4clt_encode_lockargs(struct rpc_rqst req, __be32 p, nlm_args *argp)
1da177e4 LT	447	{
	448	struct nlm_lock *lock = &argp->lock;
	449
	450	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
	451	return -EIO;
	452	*p++ = argp->block? xdr_one : xdr_zero;
	453	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	454	if (!(p = nlm4_encode_lock(p, lock)))
	455	return -EIO;
	456	*p++ = argp->reclaim? xdr_one : xdr_zero;
	457	*p++ = htonl(argp->state);
	458	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	459	return 0;
	460	}
	461
	462	static int
52921e02	463	nlm4clt_encode_cancargs(struct rpc_rqst req, __be32 p, nlm_args *argp)
1da177e4 LT	464	{
	465	struct nlm_lock *lock = &argp->lock;
	466
	467	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
	468	return -EIO;
	469	*p++ = argp->block? xdr_one : xdr_zero;
	470	*p++ = (lock->fl.fl_type == F_WRLCK)? xdr_one : xdr_zero;
	471	if (!(p = nlm4_encode_lock(p, lock)))
	472	return -EIO;
	473	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	474	return 0;
	475	}
	476
	477	static int
52921e02	478	nlm4clt_encode_unlockargs(struct rpc_rqst req, __be32 p, nlm_args *argp)
1da177e4 LT	479	{
	480	struct nlm_lock *lock = &argp->lock;
	481
	482	if (!(p = nlm4_encode_cookie(p, &argp->cookie)))
	483	return -EIO;
	484	if (!(p = nlm4_encode_lock(p, lock)))
	485	return -EIO;
	486	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	487	return 0;
	488	}
	489
	490	static int
52921e02	491	nlm4clt_encode_res(struct rpc_rqst req, __be32 p, struct nlm_res *resp)
1da177e4 LT	492	{
	493	if (!(p = nlm4_encode_cookie(p, &resp->cookie)))
	494	return -EIO;
	495	*p++ = resp->status;
	496	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	497	return 0;
	498	}
	499
	500	static int
52921e02	501	nlm4clt_encode_testres(struct rpc_rqst req, __be32 p, struct nlm_res *resp)
1da177e4 LT	502	{
	503	if (!(p = nlm4_encode_testres(p, resp)))
	504	return -EIO;
	505	req->rq_slen = xdr_adjust_iovec(req->rq_svec, p);
	506	return 0;
	507	}
	508
	509	static int
52921e02	510	nlm4clt_decode_res(struct rpc_rqst req, __be32 p, struct nlm_res *resp)
1da177e4 LT	511	{
	512	if (!(p = nlm4_decode_cookie(p, &resp->cookie)))
	513	return -EIO;
e8c5c045	514	resp->status = *p++;
1da177e4 LT	515	return 0;
	516	}
	517
511d2e88 CL	518	#if (NLMCLNT_OHSIZE > XDR_MAX_NETOBJ)
	519	# error "NLM host name cannot be larger than XDR_MAX_NETOBJ!"
	520	#endif
	521
	522	#if (NLMCLNT_OHSIZE > NLM_MAXSTRLEN)
	523	# error "NLM host name cannot be larger than NLM's maximum string length!"
	524	#endif
	525
1da177e4 LT	526	/*
	527	* Buffer requirements for NLM
	528	*/
	529	#define NLM4_void_sz 0
	530	#define NLM4_cookie_sz 1+XDR_QUADLEN(NLM_MAXCOOKIELEN)
511d2e88 CL	531	#define NLM4_caller_sz 1+XDR_QUADLEN(NLMCLNT_OHSIZE)
511d2e88 CL	532	#define NLM4_owner_sz 1+XDR_QUADLEN(NLMCLNT_OHSIZE)
1da177e4	533	#define NLM4_fhandle_sz 1+XDR_QUADLEN(NFS3_FHSIZE)
511d2e88 CL	534	#define NLM4_lock_sz 5+NLM4_caller_sz+NLM4_owner_sz+NLM4_fhandle_sz
511d2e88 CL	535	#define NLM4_holder_sz 6+NLM4_owner_sz
1da177e4 LT	536
	537	#define NLM4_testargs_sz NLM4_cookie_sz+1+NLM4_lock_sz
	538	#define NLM4_lockargs_sz NLM4_cookie_sz+4+NLM4_lock_sz
	539	#define NLM4_cancargs_sz NLM4_cookie_sz+2+NLM4_lock_sz
	540	#define NLM4_unlockargs_sz NLM4_cookie_sz+NLM4_lock_sz
	541
	542	#define NLM4_testres_sz NLM4_cookie_sz+1+NLM4_holder_sz
	543	#define NLM4_res_sz NLM4_cookie_sz+1
	544	#define NLM4_norep_sz 0
	545
1da177e4 LT	546	/*
	547	* For NLM, a void procedure really returns nothing
	548	*/
	549	#define nlm4clt_decode_norep NULL
	550
	551	#define PROC(proc, argtype, restype) \
	552	[NLMPROC_##proc] = { \
	553	.p_proc = NLMPROC_##proc, \
	554	.p_encode = (kxdrproc_t) nlm4clt_encode_##argtype, \
	555	.p_decode = (kxdrproc_t) nlm4clt_decode_##restype, \
2bea90d4 CL	556	.p_arglen = NLM4_##argtype##_sz, \
2bea90d4 CL	557	.p_replen = NLM4_##restype##_sz, \
cc0175c1 CL	558	.p_statidx = NLMPROC_##proc, \
cc0175c1 CL	559	.p_name = #proc, \
1da177e4 LT	560	}
	561
	562	static struct rpc_procinfo nlm4_procedures[] = {
	563	PROC(TEST, testargs, testres),
	564	PROC(LOCK, lockargs, res),
	565	PROC(CANCEL, cancargs, res),
	566	PROC(UNLOCK, unlockargs, res),
	567	PROC(GRANTED, testargs, res),
	568	PROC(TEST_MSG, testargs, norep),
	569	PROC(LOCK_MSG, lockargs, norep),
	570	PROC(CANCEL_MSG, cancargs, norep),
	571	PROC(UNLOCK_MSG, unlockargs, norep),
	572	PROC(GRANTED_MSG, testargs, norep),
	573	PROC(TEST_RES, testres, norep),
	574	PROC(LOCK_RES, res, norep),
	575	PROC(CANCEL_RES, res, norep),
	576	PROC(UNLOCK_RES, res, norep),
	577	PROC(GRANTED_RES, res, norep),
	578	#ifdef NLMCLNT_SUPPORT_SHARES
	579	PROC(SHARE, shareargs, shareres),
	580	PROC(UNSHARE, shareargs, shareres),
	581	PROC(NM_LOCK, lockargs, res),
	582	PROC(FREE_ALL, notify, void),
	583	#endif
	584	};
	585
	586	struct rpc_version nlm_version4 = {
	587	.number = 4,
	588	.nrprocs = 24,
	589	.procs = nlm4_procedures,
	590	};