[deliverable/linux.git] / fs / nfs / nfs42xdr.c

/*
 * Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
 */
#ifndef __LINUX_FS_NFS_NFS4_2XDR_H
#define __LINUX_FS_NFS_NFS4_2XDR_H

#include "nfs42.h"

#define encode_fallocate_maxsz		(encode_stateid_maxsz + \
					 2 /* offset */ + \
					 2 /* length */)
#define encode_allocate_maxsz		(op_encode_hdr_maxsz + \
					 encode_fallocate_maxsz)
#define decode_allocate_maxsz		(op_decode_hdr_maxsz)
#define encode_deallocate_maxsz		(op_encode_hdr_maxsz + \
					 encode_fallocate_maxsz)
#define decode_deallocate_maxsz		(op_decode_hdr_maxsz)
#define encode_seek_maxsz		(op_encode_hdr_maxsz + \
					 encode_stateid_maxsz + \
					 2 /* offset */ + \
					 1 /* whence */)
#define decode_seek_maxsz		(op_decode_hdr_maxsz + \
					 1 /* eof */ + \
					 1 /* whence */ + \
					 2 /* offset */ + \
					 2 /* length */)
#define encode_io_info_maxsz		4
#define encode_layoutstats_maxsz	(op_decode_hdr_maxsz + \
					2 /* offset */ + \
					2 /* length */ + \
					encode_stateid_maxsz + \
					encode_io_info_maxsz + \
					encode_io_info_maxsz + \
					1 /* opaque devaddr4 length */ + \
					XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
#define decode_layoutstats_maxsz	(op_decode_hdr_maxsz)

#define NFS4_enc_allocate_sz		(compound_encode_hdr_maxsz + \
					 encode_putfh_maxsz + \
					 encode_allocate_maxsz + \
					 encode_getattr_maxsz)
#define NFS4_dec_allocate_sz		(compound_decode_hdr_maxsz + \
					 decode_putfh_maxsz + \
					 decode_allocate_maxsz + \
					 decode_getattr_maxsz)
#define NFS4_enc_deallocate_sz		(compound_encode_hdr_maxsz + \
					 encode_putfh_maxsz + \
					 encode_deallocate_maxsz + \
					 encode_getattr_maxsz)
#define NFS4_dec_deallocate_sz		(compound_decode_hdr_maxsz + \
					 decode_putfh_maxsz + \
					 decode_deallocate_maxsz + \
					 decode_getattr_maxsz)
#define NFS4_enc_seek_sz		(compound_encode_hdr_maxsz + \
					 encode_putfh_maxsz + \
					 encode_seek_maxsz)
#define NFS4_dec_seek_sz		(compound_decode_hdr_maxsz + \
					 decode_putfh_maxsz + \
					 decode_seek_maxsz)
#define NFS4_enc_layoutstats_sz		(compound_encode_hdr_maxsz + \
					 encode_sequence_maxsz + \
					 encode_putfh_maxsz + \
					 PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
#define NFS4_dec_layoutstats_sz		(compound_decode_hdr_maxsz + \
					 decode_sequence_maxsz + \
					 decode_putfh_maxsz + \
					 PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)


static void encode_fallocate(struct xdr_stream *xdr,
			     struct nfs42_falloc_args *args)
{
	encode_nfs4_stateid(xdr, &args->falloc_stateid);
	encode_uint64(xdr, args->falloc_offset);
	encode_uint64(xdr, args->falloc_length);
}

static void encode_allocate(struct xdr_stream *xdr,
			    struct nfs42_falloc_args *args,
			    struct compound_hdr *hdr)
{
	encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
	encode_fallocate(xdr, args);
}

static void encode_deallocate(struct xdr_stream *xdr,
			      struct nfs42_falloc_args *args,
			      struct compound_hdr *hdr)
{
	encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
	encode_fallocate(xdr, args);
}

static void encode_seek(struct xdr_stream *xdr,
			struct nfs42_seek_args *args,
			struct compound_hdr *hdr)
{
	encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
	encode_nfs4_stateid(xdr, &args->sa_stateid);
	encode_uint64(xdr, args->sa_offset);
	encode_uint32(xdr, args->sa_what);
}

static void encode_layoutstats(struct xdr_stream *xdr,
			       struct nfs42_layoutstat_args *args,
			       struct nfs42_layoutstat_devinfo *devinfo,
			       struct compound_hdr *hdr)
{
	__be32 *p;

	encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
	p = reserve_space(xdr, 8 + 8);
	p = xdr_encode_hyper(p, devinfo->offset);
	p = xdr_encode_hyper(p, devinfo->length);
	encode_nfs4_stateid(xdr, &args->stateid);
	p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
	p = xdr_encode_hyper(p, devinfo->read_count);
	p = xdr_encode_hyper(p, devinfo->read_bytes);
	p = xdr_encode_hyper(p, devinfo->write_count);
	p = xdr_encode_hyper(p, devinfo->write_bytes);
	p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
			NFS4_DEVICEID4_SIZE);
	/* Encode layoutupdate4 */
	*p++ = cpu_to_be32(devinfo->layout_type);
	if (devinfo->layoutstats_encode != NULL)
		devinfo->layoutstats_encode(xdr, args, devinfo);
	else
		encode_uint32(xdr, 0);
}

/*
 * Encode ALLOCATE request
 */
static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
				  struct xdr_stream *xdr,
				  struct nfs42_falloc_args *args)
{
	struct compound_hdr hdr = {
		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	};

	encode_compound_hdr(xdr, req, &hdr);
	encode_sequence(xdr, &args->seq_args, &hdr);
	encode_putfh(xdr, args->falloc_fh, &hdr);
	encode_allocate(xdr, args, &hdr);
	encode_getfattr(xdr, args->falloc_bitmask, &hdr);
	encode_nops(&hdr);
}

/*
 * Encode DEALLOCATE request
 */
static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
				    struct xdr_stream *xdr,
				    struct nfs42_falloc_args *args)
{
	struct compound_hdr hdr = {
		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	};

	encode_compound_hdr(xdr, req, &hdr);
	encode_sequence(xdr, &args->seq_args, &hdr);
	encode_putfh(xdr, args->falloc_fh, &hdr);
	encode_deallocate(xdr, args, &hdr);
	encode_getfattr(xdr, args->falloc_bitmask, &hdr);
	encode_nops(&hdr);
}

/*
 * Encode SEEK request
 */
static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
			      struct xdr_stream *xdr,
			      struct nfs42_seek_args *args)
{
	struct compound_hdr hdr = {
		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	};

	encode_compound_hdr(xdr, req, &hdr);
	encode_sequence(xdr, &args->seq_args, &hdr);
	encode_putfh(xdr, args->sa_fh, &hdr);
	encode_seek(xdr, args, &hdr);
	encode_nops(&hdr);
}

/*
 * Encode LAYOUTSTATS request
 */
static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
				     struct xdr_stream *xdr,
				     struct nfs42_layoutstat_args *args)
{
	int i;

	struct compound_hdr hdr = {
		.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	};

	encode_compound_hdr(xdr, req, &hdr);
	encode_sequence(xdr, &args->seq_args, &hdr);
	encode_putfh(xdr, args->fh, &hdr);
	WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
	for (i = 0; i < args->num_dev; i++)
		encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
	encode_nops(&hdr);
}

static int decode_allocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
{
	return decode_op_hdr(xdr, OP_ALLOCATE);
}

static int decode_deallocate(struct xdr_stream *xdr, struct nfs42_falloc_res *res)
{
	return decode_op_hdr(xdr, OP_DEALLOCATE);
}

static int decode_seek(struct xdr_stream *xdr, struct nfs42_seek_res *res)
{
	int status;
	__be32 *p;

	status = decode_op_hdr(xdr, OP_SEEK);
	if (status)
		return status;

	p = xdr_inline_decode(xdr, 4 + 8);
	if (unlikely(!p))
		goto out_overflow;

	res->sr_eof = be32_to_cpup(p++);
	p = xdr_decode_hyper(p, &res->sr_offset);
	return 0;

out_overflow:
	print_overflow_msg(__func__, xdr);
	return -EIO;
}

static int decode_layoutstats(struct xdr_stream *xdr)
{
	return decode_op_hdr(xdr, OP_LAYOUTSTATS);
}

/*
 * Decode ALLOCATE request
 */
static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
				 struct xdr_stream *xdr,
				 struct nfs42_falloc_res *res)
{
	struct compound_hdr hdr;
	int status;

	status = decode_compound_hdr(xdr, &hdr);
	if (status)
		goto out;
	status = decode_sequence(xdr, &res->seq_res, rqstp);
	if (status)
		goto out;
	status = decode_putfh(xdr);
	if (status)
		goto out;
	status = decode_allocate(xdr, res);
	if (status)
		goto out;
	decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
out:
	return status;
}

/*
 * Decode DEALLOCATE request
 */
static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
				   struct xdr_stream *xdr,
				   struct nfs42_falloc_res *res)
{
	struct compound_hdr hdr;
	int status;

	status = decode_compound_hdr(xdr, &hdr);
	if (status)
		goto out;
	status = decode_sequence(xdr, &res->seq_res, rqstp);
	if (status)
		goto out;
	status = decode_putfh(xdr);
	if (status)
		goto out;
	status = decode_deallocate(xdr, res);
	if (status)
		goto out;
	decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
out:
	return status;
}

/*
 * Decode SEEK request
 */
static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
			     struct xdr_stream *xdr,
			     struct nfs42_seek_res *res)
{
	struct compound_hdr hdr;
	int status;

	status = decode_compound_hdr(xdr, &hdr);
	if (status)
		goto out;
	status = decode_sequence(xdr, &res->seq_res, rqstp);
	if (status)
		goto out;
	status = decode_putfh(xdr);
	if (status)
		goto out;
	status = decode_seek(xdr, res);
out:
	return status;
}

/*
 * Decode LAYOUTSTATS request
 */
static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
				    struct xdr_stream *xdr,
				    struct nfs42_layoutstat_res *res)
{
	struct compound_hdr hdr;
	int status, i;

	status = decode_compound_hdr(xdr, &hdr);
	if (status)
		goto out;
	status = decode_sequence(xdr, &res->seq_res, rqstp);
	if (status)
		goto out;
	status = decode_putfh(xdr);
	if (status)
		goto out;
	WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
	for (i = 0; i < res->num_dev; i++) {
		status = decode_layoutstats(xdr);
		if (status)
			goto out;
	}
out:
	res->rpc_status = status;
	return status;
}

#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
Commit	Line	Data
1c6dcbe5 AS	1	/*
	2	* Copyright (c) 2014 Anna Schumaker <Anna.Schumaker@Netapp.com>
	3	*/
	4	#ifndef __LINUX_FS_NFS_NFS4_2XDR_H
	5	#define __LINUX_FS_NFS_NFS4_2XDR_H
	6
be3a5d23 TM	7	#include "nfs42.h"
be3a5d23 TM	8
f4ac1674 AS	9	#define encode_fallocate_maxsz (encode_stateid_maxsz + \
	10	2 /* offset */ + \
	11	2 /* length */)
	12	#define encode_allocate_maxsz (op_encode_hdr_maxsz + \
	13	encode_fallocate_maxsz)
	14	#define decode_allocate_maxsz (op_decode_hdr_maxsz)
624bd5b7 AS	15	#define encode_deallocate_maxsz (op_encode_hdr_maxsz + \
	16	encode_fallocate_maxsz)
	17	#define decode_deallocate_maxsz (op_decode_hdr_maxsz)
1c6dcbe5 AS	18	#define encode_seek_maxsz (op_encode_hdr_maxsz + \
	19	encode_stateid_maxsz + \
	20	2 /* offset */ + \
	21	1 /* whence */)
	22	#define decode_seek_maxsz (op_decode_hdr_maxsz + \
	23	1 /* eof */ + \
	24	1 /* whence */ + \
	25	2 /* offset */ + \
	26	2 /* length */)
be3a5d23 TM	27	#define encode_io_info_maxsz 4
	28	#define encode_layoutstats_maxsz (op_decode_hdr_maxsz + \
	29	2 /* offset */ + \
	30	2 /* length */ + \
	31	encode_stateid_maxsz + \
	32	encode_io_info_maxsz + \
	33	encode_io_info_maxsz + \
	34	1 /* opaque devaddr4 length */ + \
	35	XDR_QUADLEN(PNFS_LAYOUTSTATS_MAXSIZE))
	36	#define decode_layoutstats_maxsz (op_decode_hdr_maxsz)
1c6dcbe5	37
f4ac1674 AS	38	#define NFS4_enc_allocate_sz (compound_encode_hdr_maxsz + \
f4ac1674 AS	39	encode_putfh_maxsz + \
9a51940b AS	40	encode_allocate_maxsz + \
9a51940b AS	41	encode_getattr_maxsz)
f4ac1674 AS	42	#define NFS4_dec_allocate_sz (compound_decode_hdr_maxsz + \
f4ac1674 AS	43	decode_putfh_maxsz + \
9a51940b AS	44	decode_allocate_maxsz + \
9a51940b AS	45	decode_getattr_maxsz)
624bd5b7 AS	46	#define NFS4_enc_deallocate_sz (compound_encode_hdr_maxsz + \
624bd5b7 AS	47	encode_putfh_maxsz + \
9a51940b AS	48	encode_deallocate_maxsz + \
9a51940b AS	49	encode_getattr_maxsz)
624bd5b7 AS	50	#define NFS4_dec_deallocate_sz (compound_decode_hdr_maxsz + \
624bd5b7 AS	51	decode_putfh_maxsz + \
9a51940b AS	52	decode_deallocate_maxsz + \
9a51940b AS	53	decode_getattr_maxsz)
1c6dcbe5 AS	54	#define NFS4_enc_seek_sz (compound_encode_hdr_maxsz + \
	55	encode_putfh_maxsz + \
	56	encode_seek_maxsz)
	57	#define NFS4_dec_seek_sz (compound_decode_hdr_maxsz + \
	58	decode_putfh_maxsz + \
	59	decode_seek_maxsz)
be3a5d23 TM	60	#define NFS4_enc_layoutstats_sz (compound_encode_hdr_maxsz + \
	61	encode_sequence_maxsz + \
	62	encode_putfh_maxsz + \
	63	PNFS_LAYOUTSTATS_MAXDEV * encode_layoutstats_maxsz)
	64	#define NFS4_dec_layoutstats_sz (compound_decode_hdr_maxsz + \
	65	decode_sequence_maxsz + \
	66	decode_putfh_maxsz + \
	67	PNFS_LAYOUTSTATS_MAXDEV * decode_layoutstats_maxsz)
1c6dcbe5 AS	68
1c6dcbe5 AS	69
f4ac1674 AS	70	static void encode_fallocate(struct xdr_stream *xdr,
	71	struct nfs42_falloc_args *args)
	72	{
	73	encode_nfs4_stateid(xdr, &args->falloc_stateid);
	74	encode_uint64(xdr, args->falloc_offset);
	75	encode_uint64(xdr, args->falloc_length);
	76	}
	77
	78	static void encode_allocate(struct xdr_stream *xdr,
	79	struct nfs42_falloc_args *args,
	80	struct compound_hdr *hdr)
	81	{
	82	encode_op_hdr(xdr, OP_ALLOCATE, decode_allocate_maxsz, hdr);
	83	encode_fallocate(xdr, args);
	84	}
	85
624bd5b7 AS	86	static void encode_deallocate(struct xdr_stream *xdr,
	87	struct nfs42_falloc_args *args,
	88	struct compound_hdr *hdr)
	89	{
	90	encode_op_hdr(xdr, OP_DEALLOCATE, decode_deallocate_maxsz, hdr);
	91	encode_fallocate(xdr, args);
	92	}
	93
1c6dcbe5 AS	94	static void encode_seek(struct xdr_stream *xdr,
	95	struct nfs42_seek_args *args,
	96	struct compound_hdr *hdr)
	97	{
	98	encode_op_hdr(xdr, OP_SEEK, decode_seek_maxsz, hdr);
	99	encode_nfs4_stateid(xdr, &args->sa_stateid);
	100	encode_uint64(xdr, args->sa_offset);
	101	encode_uint32(xdr, args->sa_what);
	102	}
	103
be3a5d23 TM	104	static void encode_layoutstats(struct xdr_stream *xdr,
	105	struct nfs42_layoutstat_args *args,
	106	struct nfs42_layoutstat_devinfo *devinfo,
	107	struct compound_hdr *hdr)
	108	{
	109	__be32 *p;
	110
	111	encode_op_hdr(xdr, OP_LAYOUTSTATS, decode_layoutstats_maxsz, hdr);
	112	p = reserve_space(xdr, 8 + 8);
	113	p = xdr_encode_hyper(p, devinfo->offset);
	114	p = xdr_encode_hyper(p, devinfo->length);
	115	encode_nfs4_stateid(xdr, &args->stateid);
	116	p = reserve_space(xdr, 4*8 + NFS4_DEVICEID4_SIZE + 4);
	117	p = xdr_encode_hyper(p, devinfo->read_count);
	118	p = xdr_encode_hyper(p, devinfo->read_bytes);
	119	p = xdr_encode_hyper(p, devinfo->write_count);
	120	p = xdr_encode_hyper(p, devinfo->write_bytes);
	121	p = xdr_encode_opaque_fixed(p, devinfo->dev_id.data,
	122	NFS4_DEVICEID4_SIZE);
	123	/* Encode layoutupdate4 */
	124	*p++ = cpu_to_be32(devinfo->layout_type);
	125	if (devinfo->layoutstats_encode != NULL)
	126	devinfo->layoutstats_encode(xdr, args, devinfo);
	127	else
	128	encode_uint32(xdr, 0);
	129	}
	130
f4ac1674 AS	131	/*
	132	* Encode ALLOCATE request
	133	*/
	134	static void nfs4_xdr_enc_allocate(struct rpc_rqst *req,
	135	struct xdr_stream *xdr,
	136	struct nfs42_falloc_args *args)
	137	{
	138	struct compound_hdr hdr = {
	139	.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	140	};
	141
	142	encode_compound_hdr(xdr, req, &hdr);
	143	encode_sequence(xdr, &args->seq_args, &hdr);
	144	encode_putfh(xdr, args->falloc_fh, &hdr);
	145	encode_allocate(xdr, args, &hdr);
9a51940b	146	encode_getfattr(xdr, args->falloc_bitmask, &hdr);
f4ac1674 AS	147	encode_nops(&hdr);
	148	}
	149
624bd5b7 AS	150	/*
	151	* Encode DEALLOCATE request
	152	*/
	153	static void nfs4_xdr_enc_deallocate(struct rpc_rqst *req,
	154	struct xdr_stream *xdr,
	155	struct nfs42_falloc_args *args)
	156	{
	157	struct compound_hdr hdr = {
	158	.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	159	};
	160
	161	encode_compound_hdr(xdr, req, &hdr);
	162	encode_sequence(xdr, &args->seq_args, &hdr);
	163	encode_putfh(xdr, args->falloc_fh, &hdr);
	164	encode_deallocate(xdr, args, &hdr);
9a51940b	165	encode_getfattr(xdr, args->falloc_bitmask, &hdr);
624bd5b7 AS	166	encode_nops(&hdr);
	167	}
	168
1c6dcbe5 AS	169	/*
	170	* Encode SEEK request
	171	*/
	172	static void nfs4_xdr_enc_seek(struct rpc_rqst *req,
	173	struct xdr_stream *xdr,
	174	struct nfs42_seek_args *args)
	175	{
	176	struct compound_hdr hdr = {
	177	.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	178	};
	179
	180	encode_compound_hdr(xdr, req, &hdr);
	181	encode_sequence(xdr, &args->seq_args, &hdr);
	182	encode_putfh(xdr, args->sa_fh, &hdr);
	183	encode_seek(xdr, args, &hdr);
	184	encode_nops(&hdr);
	185	}
	186
be3a5d23 TM	187	/*
	188	* Encode LAYOUTSTATS request
	189	*/
	190	static void nfs4_xdr_enc_layoutstats(struct rpc_rqst *req,
	191	struct xdr_stream *xdr,
	192	struct nfs42_layoutstat_args *args)
	193	{
	194	int i;
	195
	196	struct compound_hdr hdr = {
	197	.minorversion = nfs4_xdr_minorversion(&args->seq_args),
	198	};
	199
	200	encode_compound_hdr(xdr, req, &hdr);
	201	encode_sequence(xdr, &args->seq_args, &hdr);
	202	encode_putfh(xdr, args->fh, &hdr);
	203	WARN_ON(args->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
	204	for (i = 0; i < args->num_dev; i++)
	205	encode_layoutstats(xdr, args, &args->devinfo[i], &hdr);
	206	encode_nops(&hdr);
	207	}
	208
f4ac1674 AS	209	static int decode_allocate(struct xdr_stream xdr, struct nfs42_falloc_res res)
	210	{
	211	return decode_op_hdr(xdr, OP_ALLOCATE);
	212	}
	213
624bd5b7 AS	214	static int decode_deallocate(struct xdr_stream xdr, struct nfs42_falloc_res res)
	215	{
	216	return decode_op_hdr(xdr, OP_DEALLOCATE);
	217	}
	218
1c6dcbe5 AS	219	static int decode_seek(struct xdr_stream xdr, struct nfs42_seek_res res)
	220	{
	221	int status;
	222	__be32 *p;
	223
	224	status = decode_op_hdr(xdr, OP_SEEK);
	225	if (status)
	226	return status;
	227
	228	p = xdr_inline_decode(xdr, 4 + 8);
	229	if (unlikely(!p))
	230	goto out_overflow;
	231
	232	res->sr_eof = be32_to_cpup(p++);
	233	p = xdr_decode_hyper(p, &res->sr_offset);
	234	return 0;
	235
	236	out_overflow:
	237	print_overflow_msg(__func__, xdr);
	238	return -EIO;
	239	}
	240
19cf6335	241	static int decode_layoutstats(struct xdr_stream *xdr)
be3a5d23	242	{
da2e8127	243	return decode_op_hdr(xdr, OP_LAYOUTSTATS);
be3a5d23 TM	244	}
be3a5d23 TM	245
f4ac1674 AS	246	/*
	247	* Decode ALLOCATE request
	248	*/
	249	static int nfs4_xdr_dec_allocate(struct rpc_rqst *rqstp,
	250	struct xdr_stream *xdr,
	251	struct nfs42_falloc_res *res)
	252	{
	253	struct compound_hdr hdr;
	254	int status;
	255
	256	status = decode_compound_hdr(xdr, &hdr);
	257	if (status)
	258	goto out;
	259	status = decode_sequence(xdr, &res->seq_res, rqstp);
	260	if (status)
	261	goto out;
	262	status = decode_putfh(xdr);
	263	if (status)
	264	goto out;
	265	status = decode_allocate(xdr, res);
9a51940b AS	266	if (status)
	267	goto out;
	268	decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
f4ac1674 AS	269	out:
	270	return status;
	271	}
	272
624bd5b7 AS	273	/*
	274	* Decode DEALLOCATE request
	275	*/
	276	static int nfs4_xdr_dec_deallocate(struct rpc_rqst *rqstp,
	277	struct xdr_stream *xdr,
	278	struct nfs42_falloc_res *res)
	279	{
	280	struct compound_hdr hdr;
	281	int status;
	282
	283	status = decode_compound_hdr(xdr, &hdr);
	284	if (status)
	285	goto out;
	286	status = decode_sequence(xdr, &res->seq_res, rqstp);
	287	if (status)
	288	goto out;
	289	status = decode_putfh(xdr);
	290	if (status)
	291	goto out;
	292	status = decode_deallocate(xdr, res);
9a51940b AS	293	if (status)
	294	goto out;
	295	decode_getfattr(xdr, res->falloc_fattr, res->falloc_server);
624bd5b7 AS	296	out:
	297	return status;
	298	}
	299
1c6dcbe5 AS	300	/*
	301	* Decode SEEK request
	302	*/
	303	static int nfs4_xdr_dec_seek(struct rpc_rqst *rqstp,
	304	struct xdr_stream *xdr,
	305	struct nfs42_seek_res *res)
	306	{
	307	struct compound_hdr hdr;
	308	int status;
	309
	310	status = decode_compound_hdr(xdr, &hdr);
	311	if (status)
	312	goto out;
	313	status = decode_sequence(xdr, &res->seq_res, rqstp);
	314	if (status)
	315	goto out;
	316	status = decode_putfh(xdr);
	317	if (status)
	318	goto out;
	319	status = decode_seek(xdr, res);
	320	out:
	321	return status;
	322	}
be3a5d23 TM	323
	324	/*
	325	* Decode LAYOUTSTATS request
	326	*/
	327	static int nfs4_xdr_dec_layoutstats(struct rpc_rqst *rqstp,
	328	struct xdr_stream *xdr,
	329	struct nfs42_layoutstat_res *res)
	330	{
	331	struct compound_hdr hdr;
	332	int status, i;
	333
	334	status = decode_compound_hdr(xdr, &hdr);
	335	if (status)
	336	goto out;
	337	status = decode_sequence(xdr, &res->seq_res, rqstp);
	338	if (status)
	339	goto out;
	340	status = decode_putfh(xdr);
	341	if (status)
	342	goto out;
	343	WARN_ON(res->num_dev > PNFS_LAYOUTSTATS_MAXDEV);
	344	for (i = 0; i < res->num_dev; i++) {
19cf6335	345	status = decode_layoutstats(xdr);
be3a5d23 TM	346	if (status)
	347	goto out;
	348	}
	349	out:
	350	res->rpc_status = status;
	351	return status;
	352	}
	353
1c6dcbe5	354	#endif /* __LINUX_FS_NFS_NFS4_2XDR_H */