[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / nfs / callback_xdr.c

/*
 * linux/fs/nfs/callback_xdr.c
 *
 * Copyright (C) 2004 Trond Myklebust
 *
 * NFSv4 callback encode/decode procedures
 */
#include <linux/kernel.h>
#include <linux/sunrpc/svc.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
#include "nfs4_fs.h"
#include "callback.h"

#define CB_OP_TAGLEN_MAXSZ	(512)
#define CB_OP_HDR_RES_MAXSZ	(2 + CB_OP_TAGLEN_MAXSZ)
#define CB_OP_GETATTR_BITMAP_MAXSZ	(4)
#define CB_OP_GETATTR_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ + \
				CB_OP_GETATTR_BITMAP_MAXSZ + \
				2 + 2 + 3 + 3)
#define CB_OP_RECALL_RES_MAXSZ	(CB_OP_HDR_RES_MAXSZ)

#define NFSDBG_FACILITY NFSDBG_CALLBACK

typedef __be32 (*callback_process_op_t)(void *, void *);
typedef __be32 (*callback_decode_arg_t)(struct svc_rqst *, struct xdr_stream *, void *);
typedef __be32 (*callback_encode_res_t)(struct svc_rqst *, struct xdr_stream *, void *);


struct callback_op {
	callback_process_op_t process_op;
	callback_decode_arg_t decode_args;
	callback_encode_res_t encode_res;
	long res_maxsize;
};

static struct callback_op callback_ops[];

static __be32 nfs4_callback_null(struct svc_rqst *rqstp, void *argp, void *resp)
{
	return htonl(NFS4_OK);
}

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

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

static __be32 *read_buf(struct xdr_stream *xdr, int nbytes)
{
	__be32 *p;

	p = xdr_inline_decode(xdr, nbytes);
	if (unlikely(p == NULL))
		printk(KERN_WARNING "NFSv4 callback reply buffer overflowed!\n");
	return p;
}

static __be32 decode_string(struct xdr_stream *xdr, unsigned int *len, const char **str)
{
	__be32 *p;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	*len = ntohl(*p);

	if (*len != 0) {
		p = read_buf(xdr, *len);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*str = (const char *)p;
	} else
		*str = NULL;

	return 0;
}

static __be32 decode_fh(struct xdr_stream *xdr, struct nfs_fh *fh)
{
	__be32 *p;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	fh->size = ntohl(*p);
	if (fh->size > NFS4_FHSIZE)
		return htonl(NFS4ERR_BADHANDLE);
	p = read_buf(xdr, fh->size);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	memcpy(&fh->data[0], p, fh->size);
	memset(&fh->data[fh->size], 0, sizeof(fh->data) - fh->size);
	return 0;
}

static __be32 decode_bitmap(struct xdr_stream *xdr, uint32_t *bitmap)
{
	__be32 *p;
	unsigned int attrlen;

	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	attrlen = ntohl(*p);
	p = read_buf(xdr, attrlen << 2);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	if (likely(attrlen > 0))
		bitmap[0] = ntohl(*p++);
	if (attrlen > 1)
		bitmap[1] = ntohl(*p);
	return 0;
}

static __be32 decode_stateid(struct xdr_stream *xdr, nfs4_stateid *stateid)
{
	__be32 *p;

	p = read_buf(xdr, 16);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	memcpy(stateid->data, p, 16);
	return 0;
}

static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound_hdr_arg *hdr)
{
	__be32 *p;
	__be32 status;

	status = decode_string(xdr, &hdr->taglen, &hdr->tag);
	if (unlikely(status != 0))
		return status;
	/* We do not like overly long tags! */
	if (hdr->taglen > CB_OP_TAGLEN_MAXSZ - 12) {
		printk("NFSv4 CALLBACK %s: client sent tag of length %u\n",
				__func__, hdr->taglen);
		return htonl(NFS4ERR_RESOURCE);
	}
	p = read_buf(xdr, 12);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	hdr->minorversion = ntohl(*p++);
	/* Check minor version is zero or one. */
	if (hdr->minorversion <= 1) {
		p++;	/* skip callback_ident */
	} else {
		printk(KERN_WARNING "%s: NFSv4 server callback with "
			"illegal minor version %u!\n",
			__func__, hdr->minorversion);
		return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
	}
	hdr->nops = ntohl(*p);
	dprintk("%s: minorversion %d nops %d\n", __func__,
		hdr->minorversion, hdr->nops);
	return 0;
}

static __be32 decode_op_hdr(struct xdr_stream *xdr, unsigned int *op)
{
	__be32 *p;
	p = read_buf(xdr, 4);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	*op = ntohl(*p);
	return 0;
}

static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_getattrargs *args)
{
	__be32 status;

	status = decode_fh(xdr, &args->fh);
	if (unlikely(status != 0))
		goto out;
	args->addr = svc_addr(rqstp);
	status = decode_bitmap(xdr, args->bitmap);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr, struct cb_recallargs *args)
{
	__be32 *p;
	__be32 status;

	args->addr = svc_addr(rqstp);
	status = decode_stateid(xdr, &args->stateid);
	if (unlikely(status != 0))
		goto out;
	p = read_buf(xdr, 4);
	if (unlikely(p == NULL)) {
		status = htonl(NFS4ERR_RESOURCE);
		goto out;
	}
	args->truncate = ntohl(*p);
	status = decode_fh(xdr, &args->fh);
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

static __be32 encode_string(struct xdr_stream *xdr, unsigned int len, const char *str)
{
	__be32 *p;

	p = xdr_reserve_space(xdr, 4 + len);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	xdr_encode_opaque(p, str, len);
	return 0;
}

#define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE)
#define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY)
static __be32 encode_attr_bitmap(struct xdr_stream *xdr, const uint32_t *bitmap, __be32 **savep)
{
	__be32 bm[2];
	__be32 *p;

	bm[0] = htonl(bitmap[0] & CB_SUPPORTED_ATTR0);
	bm[1] = htonl(bitmap[1] & CB_SUPPORTED_ATTR1);
	if (bm[1] != 0) {
		p = xdr_reserve_space(xdr, 16);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(2);
		*p++ = bm[0];
		*p++ = bm[1];
	} else if (bm[0] != 0) {
		p = xdr_reserve_space(xdr, 12);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(1);
		*p++ = bm[0];
	} else {
		p = xdr_reserve_space(xdr, 8);
		if (unlikely(p == NULL))
			return htonl(NFS4ERR_RESOURCE);
		*p++ = htonl(0);
	}
	*savep = p;
	return 0;
}

static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t change)
{
	__be32 *p;

	if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
	if (unlikely(!p))
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, change);
	return 0;
}

static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, uint64_t size)
{
	__be32 *p;

	if (!(bitmap[0] & FATTR4_WORD0_SIZE))
		return 0;
	p = xdr_reserve_space(xdr, 8);
	if (unlikely(!p))
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, size);
	return 0;
}

static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *time)
{
	__be32 *p;

	p = xdr_reserve_space(xdr, 12);
	if (unlikely(!p))
		return htonl(NFS4ERR_RESOURCE);
	p = xdr_encode_hyper(p, time->tv_sec);
	*p = htonl(time->tv_nsec);
	return 0;
}

static __be32 encode_attr_ctime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
		return 0;
	return encode_attr_time(xdr,time);
}

static __be32 encode_attr_mtime(struct xdr_stream *xdr, const uint32_t *bitmap, const struct timespec *time)
{
	if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
		return 0;
	return encode_attr_time(xdr,time);
}

static __be32 encode_compound_hdr_res(struct xdr_stream *xdr, struct cb_compound_hdr_res *hdr)
{
	__be32 status;

	hdr->status = xdr_reserve_space(xdr, 4);
	if (unlikely(hdr->status == NULL))
		return htonl(NFS4ERR_RESOURCE);
	status = encode_string(xdr, hdr->taglen, hdr->tag);
	if (unlikely(status != 0))
		return status;
	hdr->nops = xdr_reserve_space(xdr, 4);
	if (unlikely(hdr->nops == NULL))
		return htonl(NFS4ERR_RESOURCE);
	return 0;
}

static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
{
	__be32 *p;
	
	p = xdr_reserve_space(xdr, 8);
	if (unlikely(p == NULL))
		return htonl(NFS4ERR_RESOURCE);
	*p++ = htonl(op);
	*p = res;
	return 0;
}

static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr, const struct cb_getattrres *res)
{
	__be32 *savep = NULL;
	__be32 status = res->status;
	
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_bitmap(xdr, res->bitmap, &savep);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_change(xdr, res->bitmap, res->change_attr);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_size(xdr, res->bitmap, res->size);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);
	if (unlikely(status != 0))
		goto out;
	status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
	*savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
out:
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
	return status;
}

static __be32 process_op(struct svc_rqst *rqstp,
		struct xdr_stream *xdr_in, void *argp,
		struct xdr_stream *xdr_out, void *resp)
{
	struct callback_op *op = &callback_ops[0];
	unsigned int op_nr = OP_CB_ILLEGAL;
	__be32 status = 0;
	long maxlen;
	__be32 res;

	dprintk("%s: start\n", __func__);
	status = decode_op_hdr(xdr_in, &op_nr);
	if (likely(status == 0)) {
		switch (op_nr) {
			case OP_CB_GETATTR:
			case OP_CB_RECALL:
				op = &callback_ops[op_nr];
				break;
			default:
				op_nr = OP_CB_ILLEGAL;
				op = &callback_ops[0];
				status = htonl(NFS4ERR_OP_ILLEGAL);
		}
	}

	maxlen = xdr_out->end - xdr_out->p;
	if (maxlen > 0 && maxlen < PAGE_SIZE) {
		if (likely(status == 0 && op->decode_args != NULL))
			status = op->decode_args(rqstp, xdr_in, argp);
		if (likely(status == 0 && op->process_op != NULL))
			status = op->process_op(argp, resp);
	} else
		status = htonl(NFS4ERR_RESOURCE);

	res = encode_op_hdr(xdr_out, op_nr, status);
	if (status == 0)
		status = res;
	if (op->encode_res != NULL && status == 0)
		status = op->encode_res(rqstp, xdr_out, resp);
	dprintk("%s: done, status = %d\n", __func__, ntohl(status));
	return status;
}

/*
 * Decode, process and encode a COMPOUND
 */
static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
{
	struct cb_compound_hdr_arg hdr_arg = { 0 };
	struct cb_compound_hdr_res hdr_res = { NULL };
	struct xdr_stream xdr_in, xdr_out;
	__be32 *p;
	__be32 status;
	unsigned int nops = 0;

	dprintk("%s: start\n", __func__);

	xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);

	p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
	xdr_init_encode(&xdr_out, &rqstp->rq_res, p);

	status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
	if (status == __constant_htonl(NFS4ERR_RESOURCE))
		return rpc_garbage_args;

	hdr_res.taglen = hdr_arg.taglen;
	hdr_res.tag = hdr_arg.tag;
	if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
		return rpc_system_err;

	while (status == 0 && nops != hdr_arg.nops) {
		status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp);
		nops++;
	}

	*hdr_res.status = status;
	*hdr_res.nops = htonl(nops);
	dprintk("%s: done, status = %u\n", __func__, ntohl(status));
	return rpc_success;
}

/*
 * Define NFS4 callback COMPOUND ops.
 */
static struct callback_op callback_ops[] = {
	[0] = {
		.res_maxsize = CB_OP_HDR_RES_MAXSZ,
	},
	[OP_CB_GETATTR] = {
		.process_op = (callback_process_op_t)nfs4_callback_getattr,
		.decode_args = (callback_decode_arg_t)decode_getattr_args,
		.encode_res = (callback_encode_res_t)encode_getattr_res,
		.res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
	},
	[OP_CB_RECALL] = {
		.process_op = (callback_process_op_t)nfs4_callback_recall,
		.decode_args = (callback_decode_arg_t)decode_recall_args,
		.res_maxsize = CB_OP_RECALL_RES_MAXSZ,
	}
};

/*
 * Define NFS4 callback procedures
 */
static struct svc_procedure nfs4_callback_procedures1[] = {
	[CB_NULL] = {
		.pc_func = nfs4_callback_null,
		.pc_decode = (kxdrproc_t)nfs4_decode_void,
		.pc_encode = (kxdrproc_t)nfs4_encode_void,
		.pc_xdrressize = 1,
	},
	[CB_COMPOUND] = {
		.pc_func = nfs4_callback_compound,
		.pc_encode = (kxdrproc_t)nfs4_encode_void,
		.pc_argsize = 256,
		.pc_ressize = 256,
		.pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
	}
};

struct svc_version nfs4_callback_version1 = {
	.vs_vers = 1,
	.vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
	.vs_proc = nfs4_callback_procedures1,
	.vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
	.vs_dispatch = NULL,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/fs/nfs/callback_xdr.c
	3	*
	4	* Copyright (C) 2004 Trond Myklebust
	5	*
	6	* NFSv4 callback encode/decode procedures
	7	*/
1da177e4 LT	8	#include <linux/kernel.h>
	9	#include <linux/sunrpc/svc.h>
	10	#include <linux/nfs4.h>
	11	#include <linux/nfs_fs.h>
4ce79717	12	#include "nfs4_fs.h"
1da177e4 LT	13	#include "callback.h"
	14
	15	#define CB_OP_TAGLEN_MAXSZ (512)
	16	#define CB_OP_HDR_RES_MAXSZ (2 + CB_OP_TAGLEN_MAXSZ)
	17	#define CB_OP_GETATTR_BITMAP_MAXSZ (4)
	18	#define CB_OP_GETATTR_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ + \
	19	CB_OP_GETATTR_BITMAP_MAXSZ + \
	20	2 + 2 + 3 + 3)
	21	#define CB_OP_RECALL_RES_MAXSZ (CB_OP_HDR_RES_MAXSZ)
	22
	23	#define NFSDBG_FACILITY NFSDBG_CALLBACK
	24
e6f684f6 AV	25	typedef __be32 (callback_process_op_t)(void , void *);
	26	typedef __be32 (callback_decode_arg_t)(struct svc_rqst , struct xdr_stream , void );
	27	typedef __be32 (callback_encode_res_t)(struct svc_rqst , struct xdr_stream , void );
1da177e4 LT	28
	29
	30	struct callback_op {
	31	callback_process_op_t process_op;
	32	callback_decode_arg_t decode_args;
	33	callback_encode_res_t encode_res;
	34	long res_maxsize;
	35	};
	36
	37	static struct callback_op callback_ops[];
	38
7111c66e	39	static __be32 nfs4_callback_null(struct svc_rqst rqstp, void argp, void *resp)
1da177e4 LT	40	{
	41	return htonl(NFS4_OK);
	42	}
	43
5704fdeb	44	static int nfs4_decode_void(struct svc_rqst rqstp, __be32 p, void *dummy)
1da177e4 LT	45	{
	46	return xdr_argsize_check(rqstp, p);
	47	}
	48
5704fdeb	49	static int nfs4_encode_void(struct svc_rqst rqstp, __be32 p, void *dummy)
1da177e4 LT	50	{
	51	return xdr_ressize_check(rqstp, p);
	52	}
	53
5704fdeb	54	static __be32 read_buf(struct xdr_stream xdr, int nbytes)
1da177e4	55	{
5704fdeb	56	__be32 *p;
1da177e4 LT	57
	58	p = xdr_inline_decode(xdr, nbytes);
	59	if (unlikely(p == NULL))
	60	printk(KERN_WARNING "NFSv4 callback reply buffer overflowed!\n");
	61	return p;
	62	}
	63
e6f684f6	64	static __be32 decode_string(struct xdr_stream xdr, unsigned int len, const char **str)
1da177e4	65	{
5704fdeb	66	__be32 *p;
1da177e4 LT	67
	68	p = read_buf(xdr, 4);
	69	if (unlikely(p == NULL))
	70	return htonl(NFS4ERR_RESOURCE);
	71	len = ntohl(p);
	72
	73	if (*len != 0) {
	74	p = read_buf(xdr, *len);
	75	if (unlikely(p == NULL))
	76	return htonl(NFS4ERR_RESOURCE);
	77	str = (const char )p;
	78	} else
	79	*str = NULL;
	80
	81	return 0;
	82	}
	83
e6f684f6	84	static __be32 decode_fh(struct xdr_stream xdr, struct nfs_fh fh)
1da177e4	85	{
5704fdeb	86	__be32 *p;
1da177e4 LT	87
	88	p = read_buf(xdr, 4);
	89	if (unlikely(p == NULL))
	90	return htonl(NFS4ERR_RESOURCE);
	91	fh->size = ntohl(*p);
	92	if (fh->size > NFS4_FHSIZE)
	93	return htonl(NFS4ERR_BADHANDLE);
	94	p = read_buf(xdr, fh->size);
	95	if (unlikely(p == NULL))
	96	return htonl(NFS4ERR_RESOURCE);
	97	memcpy(&fh->data[0], p, fh->size);
	98	memset(&fh->data[fh->size], 0, sizeof(fh->data) - fh->size);
	99	return 0;
	100	}
	101
e6f684f6	102	static __be32 decode_bitmap(struct xdr_stream xdr, uint32_t bitmap)
1da177e4	103	{
5704fdeb	104	__be32 *p;
1da177e4 LT	105	unsigned int attrlen;
	106
	107	p = read_buf(xdr, 4);
	108	if (unlikely(p == NULL))
	109	return htonl(NFS4ERR_RESOURCE);
	110	attrlen = ntohl(*p);
	111	p = read_buf(xdr, attrlen << 2);
	112	if (unlikely(p == NULL))
	113	return htonl(NFS4ERR_RESOURCE);
	114	if (likely(attrlen > 0))
	115	bitmap[0] = ntohl(*p++);
	116	if (attrlen > 1)
	117	bitmap[1] = ntohl(*p);
	118	return 0;
	119	}
	120
e6f684f6	121	static __be32 decode_stateid(struct xdr_stream xdr, nfs4_stateid stateid)
1da177e4	122	{
5704fdeb	123	__be32 *p;
1da177e4 LT	124
	125	p = read_buf(xdr, 16);
	126	if (unlikely(p == NULL))
	127	return htonl(NFS4ERR_RESOURCE);
	128	memcpy(stateid->data, p, 16);
	129	return 0;
	130	}
	131
e6f684f6	132	static __be32 decode_compound_hdr_arg(struct xdr_stream xdr, struct cb_compound_hdr_arg hdr)
1da177e4	133	{
5704fdeb	134	__be32 *p;
e6f684f6	135	__be32 status;
1da177e4 LT	136
	137	status = decode_string(xdr, &hdr->taglen, &hdr->tag);
	138	if (unlikely(status != 0))
	139	return status;
	140	/* We do not like overly long tags! */
5cce428d	141	if (hdr->taglen > CB_OP_TAGLEN_MAXSZ - 12) {
1da177e4	142	printk("NFSv4 CALLBACK %s: client sent tag of length %u\n",
3110ff80	143	__func__, hdr->taglen);
1da177e4 LT	144	return htonl(NFS4ERR_RESOURCE);
	145	}
	146	p = read_buf(xdr, 12);
	147	if (unlikely(p == NULL))
	148	return htonl(NFS4ERR_RESOURCE);
b8f2ef84	149	hdr->minorversion = ntohl(*p++);
48a9e2d2 BH	150	/* Check minor version is zero or one. */
	151	if (hdr->minorversion <= 1) {
	152	p++; /* skip callback_ident */
	153	} else {
b8f2ef84 BH	154	printk(KERN_WARNING "%s: NFSv4 server callback with "
	155	"illegal minor version %u!\n",
	156	__func__, hdr->minorversion);
1da177e4 LT	157	return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
1da177e4 LT	158	}
1da177e4	159	hdr->nops = ntohl(*p);
b8f2ef84 BH	160	dprintk("%s: minorversion %d nops %d\n", __func__,
b8f2ef84 BH	161	hdr->minorversion, hdr->nops);
1da177e4 LT	162	return 0;
	163	}
	164
e6f684f6	165	static __be32 decode_op_hdr(struct xdr_stream xdr, unsigned int op)
1da177e4	166	{
5704fdeb	167	__be32 *p;
1da177e4 LT	168	p = read_buf(xdr, 4);
	169	if (unlikely(p == NULL))
	170	return htonl(NFS4ERR_RESOURCE);
	171	op = ntohl(p);
	172	return 0;
	173	}
	174
e6f684f6	175	static __be32 decode_getattr_args(struct svc_rqst rqstp, struct xdr_stream xdr, struct cb_getattrargs *args)
1da177e4	176	{
e6f684f6	177	__be32 status;
1da177e4 LT	178
	179	status = decode_fh(xdr, &args->fh);
	180	if (unlikely(status != 0))
	181	goto out;
671beed7	182	args->addr = svc_addr(rqstp);
1da177e4 LT	183	status = decode_bitmap(xdr, args->bitmap);
1da177e4 LT	184	out:
3110ff80	185	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
1da177e4 LT	186	return status;
	187	}
	188
e6f684f6	189	static __be32 decode_recall_args(struct svc_rqst rqstp, struct xdr_stream xdr, struct cb_recallargs *args)
1da177e4	190	{
5704fdeb	191	__be32 *p;
e6f684f6	192	__be32 status;
1da177e4	193
c1d35866	194	args->addr = svc_addr(rqstp);
1da177e4 LT	195	status = decode_stateid(xdr, &args->stateid);
	196	if (unlikely(status != 0))
	197	goto out;
	198	p = read_buf(xdr, 4);
	199	if (unlikely(p == NULL)) {
	200	status = htonl(NFS4ERR_RESOURCE);
	201	goto out;
	202	}
	203	args->truncate = ntohl(*p);
	204	status = decode_fh(xdr, &args->fh);
	205	out:
3110ff80	206	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
3873bc50	207	return status;
1da177e4 LT	208	}
1da177e4 LT	209
e6f684f6	210	static __be32 encode_string(struct xdr_stream xdr, unsigned int len, const char str)
1da177e4	211	{
5704fdeb	212	__be32 *p;
1da177e4 LT	213
	214	p = xdr_reserve_space(xdr, 4 + len);
	215	if (unlikely(p == NULL))
	216	return htonl(NFS4ERR_RESOURCE);
	217	xdr_encode_opaque(p, str, len);
	218	return 0;
	219	}
	220
	221	#define CB_SUPPORTED_ATTR0 (FATTR4_WORD0_CHANGE\|FATTR4_WORD0_SIZE)
	222	#define CB_SUPPORTED_ATTR1 (FATTR4_WORD1_TIME_METADATA\|FATTR4_WORD1_TIME_MODIFY)
5704fdeb	223	static __be32 encode_attr_bitmap(struct xdr_stream xdr, const uint32_t bitmap, __be32 **savep)
1da177e4	224	{
5704fdeb AV	225	__be32 bm[2];
5704fdeb AV	226	__be32 *p;
1da177e4 LT	227
	228	bm[0] = htonl(bitmap[0] & CB_SUPPORTED_ATTR0);
	229	bm[1] = htonl(bitmap[1] & CB_SUPPORTED_ATTR1);
	230	if (bm[1] != 0) {
	231	p = xdr_reserve_space(xdr, 16);
	232	if (unlikely(p == NULL))
	233	return htonl(NFS4ERR_RESOURCE);
	234	*p++ = htonl(2);
	235	*p++ = bm[0];
	236	*p++ = bm[1];
	237	} else if (bm[0] != 0) {
	238	p = xdr_reserve_space(xdr, 12);
	239	if (unlikely(p == NULL))
	240	return htonl(NFS4ERR_RESOURCE);
	241	*p++ = htonl(1);
	242	*p++ = bm[0];
	243	} else {
	244	p = xdr_reserve_space(xdr, 8);
	245	if (unlikely(p == NULL))
	246	return htonl(NFS4ERR_RESOURCE);
	247	*p++ = htonl(0);
	248	}
	249	*savep = p;
	250	return 0;
	251	}
	252
e6f684f6	253	static __be32 encode_attr_change(struct xdr_stream xdr, const uint32_t bitmap, uint64_t change)
1da177e4	254	{
5704fdeb	255	__be32 *p;
1da177e4 LT	256
	257	if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
	258	return 0;
	259	p = xdr_reserve_space(xdr, 8);
90dc7d27	260	if (unlikely(!p))
1da177e4 LT	261	return htonl(NFS4ERR_RESOURCE);
	262	p = xdr_encode_hyper(p, change);
	263	return 0;
	264	}
	265
e6f684f6	266	static __be32 encode_attr_size(struct xdr_stream xdr, const uint32_t bitmap, uint64_t size)
1da177e4	267	{
5704fdeb	268	__be32 *p;
1da177e4 LT	269
	270	if (!(bitmap[0] & FATTR4_WORD0_SIZE))
	271	return 0;
	272	p = xdr_reserve_space(xdr, 8);
90dc7d27	273	if (unlikely(!p))
1da177e4 LT	274	return htonl(NFS4ERR_RESOURCE);
	275	p = xdr_encode_hyper(p, size);
	276	return 0;
	277	}
	278
e6f684f6	279	static __be32 encode_attr_time(struct xdr_stream xdr, const struct timespec time)
1da177e4	280	{
5704fdeb	281	__be32 *p;
1da177e4 LT	282
1da177e4 LT	283	p = xdr_reserve_space(xdr, 12);
90dc7d27	284	if (unlikely(!p))
1da177e4 LT	285	return htonl(NFS4ERR_RESOURCE);
	286	p = xdr_encode_hyper(p, time->tv_sec);
	287	*p = htonl(time->tv_nsec);
	288	return 0;
	289	}
	290
e6f684f6	291	static __be32 encode_attr_ctime(struct xdr_stream xdr, const uint32_t bitmap, const struct timespec *time)
1da177e4 LT	292	{
	293	if (!(bitmap[1] & FATTR4_WORD1_TIME_METADATA))
	294	return 0;
	295	return encode_attr_time(xdr,time);
	296	}
	297
e6f684f6	298	static __be32 encode_attr_mtime(struct xdr_stream xdr, const uint32_t bitmap, const struct timespec *time)
1da177e4 LT	299	{
	300	if (!(bitmap[1] & FATTR4_WORD1_TIME_MODIFY))
	301	return 0;
	302	return encode_attr_time(xdr,time);
	303	}
	304
e6f684f6	305	static __be32 encode_compound_hdr_res(struct xdr_stream xdr, struct cb_compound_hdr_res hdr)
1da177e4	306	{
e6f684f6	307	__be32 status;
1da177e4 LT	308
	309	hdr->status = xdr_reserve_space(xdr, 4);
	310	if (unlikely(hdr->status == NULL))
	311	return htonl(NFS4ERR_RESOURCE);
	312	status = encode_string(xdr, hdr->taglen, hdr->tag);
	313	if (unlikely(status != 0))
	314	return status;
	315	hdr->nops = xdr_reserve_space(xdr, 4);
	316	if (unlikely(hdr->nops == NULL))
	317	return htonl(NFS4ERR_RESOURCE);
	318	return 0;
	319	}
	320
e6f684f6	321	static __be32 encode_op_hdr(struct xdr_stream *xdr, uint32_t op, __be32 res)
1da177e4	322	{
5704fdeb	323	__be32 *p;
1da177e4 LT	324
	325	p = xdr_reserve_space(xdr, 8);
	326	if (unlikely(p == NULL))
	327	return htonl(NFS4ERR_RESOURCE);
	328	*p++ = htonl(op);
	329	*p = res;
	330	return 0;
	331	}
	332
e6f684f6	333	static __be32 encode_getattr_res(struct svc_rqst rqstp, struct xdr_stream xdr, const struct cb_getattrres *res)
1da177e4	334	{
5704fdeb	335	__be32 *savep = NULL;
e6f684f6	336	__be32 status = res->status;
1da177e4 LT	337
	338	if (unlikely(status != 0))
	339	goto out;
	340	status = encode_attr_bitmap(xdr, res->bitmap, &savep);
	341	if (unlikely(status != 0))
	342	goto out;
	343	status = encode_attr_change(xdr, res->bitmap, res->change_attr);
	344	if (unlikely(status != 0))
	345	goto out;
	346	status = encode_attr_size(xdr, res->bitmap, res->size);
	347	if (unlikely(status != 0))
	348	goto out;
	349	status = encode_attr_ctime(xdr, res->bitmap, &res->ctime);
	350	if (unlikely(status != 0))
	351	goto out;
	352	status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
	353	savep = htonl((unsigned int)((char )xdr->p - (char *)(savep+1)));
	354	out:
3110ff80	355	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
1da177e4 LT	356	return status;
	357	}
	358
e6f684f6	359	static __be32 process_op(struct svc_rqst *rqstp,
1da177e4 LT	360	struct xdr_stream xdr_in, void argp,
	361	struct xdr_stream xdr_out, void resp)
	362	{
a162a6b8 TM	363	struct callback_op *op = &callback_ops[0];
a162a6b8 TM	364	unsigned int op_nr = OP_CB_ILLEGAL;
e6f684f6	365	__be32 status = 0;
1da177e4	366	long maxlen;
e6f684f6	367	__be32 res;
1da177e4	368
3110ff80	369	dprintk("%s: start\n", __func__);
1da177e4	370	status = decode_op_hdr(xdr_in, &op_nr);
a162a6b8 TM	371	if (likely(status == 0)) {
	372	switch (op_nr) {
	373	case OP_CB_GETATTR:
	374	case OP_CB_RECALL:
	375	op = &callback_ops[op_nr];
	376	break;
	377	default:
	378	op_nr = OP_CB_ILLEGAL;
	379	op = &callback_ops[0];
	380	status = htonl(NFS4ERR_OP_ILLEGAL);
	381	}
	382	}
1da177e4 LT	383
	384	maxlen = xdr_out->end - xdr_out->p;
	385	if (maxlen > 0 && maxlen < PAGE_SIZE) {
	386	if (likely(status == 0 && op->decode_args != NULL))
	387	status = op->decode_args(rqstp, xdr_in, argp);
	388	if (likely(status == 0 && op->process_op != NULL))
	389	status = op->process_op(argp, resp);
	390	} else
	391	status = htonl(NFS4ERR_RESOURCE);
	392
	393	res = encode_op_hdr(xdr_out, op_nr, status);
	394	if (status == 0)
	395	status = res;
	396	if (op->encode_res != NULL && status == 0)
	397	status = op->encode_res(rqstp, xdr_out, resp);
3110ff80	398	dprintk("%s: done, status = %d\n", __func__, ntohl(status));
1da177e4 LT	399	return status;
	400	}
	401
	402	/*
	403	* Decode, process and encode a COMPOUND
	404	*/
7111c66e	405	static __be32 nfs4_callback_compound(struct svc_rqst rqstp, void argp, void *resp)
1da177e4	406	{
3a6258e1 TM	407	struct cb_compound_hdr_arg hdr_arg = { 0 };
3a6258e1 TM	408	struct cb_compound_hdr_res hdr_res = { NULL };
1da177e4	409	struct xdr_stream xdr_in, xdr_out;
5704fdeb	410	__be32 *p;
e6f684f6	411	__be32 status;
3a6258e1	412	unsigned int nops = 0;
1da177e4	413
3110ff80	414	dprintk("%s: start\n", __func__);
1da177e4 LT	415
	416	xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
	417
5704fdeb	418	p = (__be32)((char )rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
1da177e4 LT	419	xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
1da177e4 LT	420
3a6258e1 TM	421	status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
	422	if (status == __constant_htonl(NFS4ERR_RESOURCE))
	423	return rpc_garbage_args;
	424
1da177e4 LT	425	hdr_res.taglen = hdr_arg.taglen;
1da177e4 LT	426	hdr_res.tag = hdr_arg.tag;
3a6258e1 TM	427	if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
3a6258e1 TM	428	return rpc_system_err;
1da177e4	429
3a6258e1	430	while (status == 0 && nops != hdr_arg.nops) {
1da177e4	431	status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp);
1da177e4 LT	432	nops++;
1da177e4 LT	433	}
3a6258e1	434
1da177e4 LT	435	*hdr_res.status = status;
1da177e4 LT	436	*hdr_res.nops = htonl(nops);
3110ff80	437	dprintk("%s: done, status = %u\n", __func__, ntohl(status));
1da177e4 LT	438	return rpc_success;
	439	}
	440
	441	/*
	442	* Define NFS4 callback COMPOUND ops.
	443	*/
	444	static struct callback_op callback_ops[] = {
	445	[0] = {
	446	.res_maxsize = CB_OP_HDR_RES_MAXSZ,
	447	},
	448	[OP_CB_GETATTR] = {
	449	.process_op = (callback_process_op_t)nfs4_callback_getattr,
	450	.decode_args = (callback_decode_arg_t)decode_getattr_args,
	451	.encode_res = (callback_encode_res_t)encode_getattr_res,
	452	.res_maxsize = CB_OP_GETATTR_RES_MAXSZ,
	453	},
	454	[OP_CB_RECALL] = {
	455	.process_op = (callback_process_op_t)nfs4_callback_recall,
	456	.decode_args = (callback_decode_arg_t)decode_recall_args,
	457	.res_maxsize = CB_OP_RECALL_RES_MAXSZ,
	458	}
	459	};
	460
	461	/*
	462	* Define NFS4 callback procedures
	463	*/
	464	static struct svc_procedure nfs4_callback_procedures1[] = {
	465	[CB_NULL] = {
	466	.pc_func = nfs4_callback_null,
	467	.pc_decode = (kxdrproc_t)nfs4_decode_void,
	468	.pc_encode = (kxdrproc_t)nfs4_encode_void,
	469	.pc_xdrressize = 1,
	470	},
	471	[CB_COMPOUND] = {
	472	.pc_func = nfs4_callback_compound,
	473	.pc_encode = (kxdrproc_t)nfs4_encode_void,
	474	.pc_argsize = 256,
	475	.pc_ressize = 256,
	476	.pc_xdrressize = NFS4_CALLBACK_BUFSIZE,
	477	}
	478	};
	479
	480	struct svc_version nfs4_callback_version1 = {
	481	.vs_vers = 1,
	482	.vs_nproc = ARRAY_SIZE(nfs4_callback_procedures1),
	483	.vs_proc = nfs4_callback_procedures1,
	484	.vs_xdrsize = NFS4_CALLBACK_XDRSIZE,
	485	.vs_dispatch = NULL,
	486	};
	487