[thirdparty/linux.git] / include / linux / sunrpc / xdr.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * XDR standard data types and function declarations
 *
 * Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
 *
 * Based on:
 *   RFC 4506 "XDR: External Data Representation Standard", May 2006
 */

#ifndef _SUNRPC_XDR_H_
#define _SUNRPC_XDR_H_

#include <linux/uio.h>
#include <asm/byteorder.h>
#include <asm/unaligned.h>
#include <linux/scatterlist.h>

struct bio_vec;
struct rpc_rqst;

/*
 * Buffer adjustment
 */
#define XDR_QUADLEN(l)		(((l) + 3) >> 2)

/*
 * Generic opaque `network object.' At the kernel level, this type
 * is used only by lockd.
 */
#define XDR_MAX_NETOBJ		1024
struct xdr_netobj {
	unsigned int		len;
	u8 *			data;
};

/*
 * Basic structure for transmission/reception of a client XDR message.
 * Features a header (for a linear buffer containing RPC headers
 * and the data payload for short messages), and then an array of
 * pages.
 * The tail iovec allows you to append data after the page array. Its
 * main interest is for appending padding to the pages in order to
 * satisfy the int_32-alignment requirements in RFC1832.
 *
 * For the future, we might want to string several of these together
 * in a list if anybody wants to make use of NFSv4 COMPOUND
 * operations and/or has a need for scatter/gather involving pages.
 */
struct xdr_buf {
	struct kvec	head[1],	/* RPC header + non-page data */
			tail[1];	/* Appended after page data */

	struct bio_vec	*bvec;
	struct page **	pages;		/* Array of pages */
	unsigned int	page_base,	/* Start of page data */
			page_len,	/* Length of page data */
			flags;		/* Flags for data disposition */
#define XDRBUF_READ		0x01		/* target of file read */
#define XDRBUF_WRITE		0x02		/* source of file write */
#define XDRBUF_SPARSE_PAGES	0x04		/* Page array is sparse */

	unsigned int	buflen,		/* Total length of storage buffer */
			len;		/* Length of XDR encoded message */
};

static inline void
xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
{
	buf->head[0].iov_base = start;
	buf->head[0].iov_len = len;
	buf->tail[0].iov_len = 0;
	buf->pages = NULL;
	buf->page_len = 0;
	buf->flags = 0;
	buf->len = 0;
	buf->buflen = len;
}

/*
 * pre-xdr'ed macros.
 */

#define	xdr_zero	cpu_to_be32(0)
#define	xdr_one		cpu_to_be32(1)
#define	xdr_two		cpu_to_be32(2)

#define	rpc_auth_null	cpu_to_be32(RPC_AUTH_NULL)
#define	rpc_auth_unix	cpu_to_be32(RPC_AUTH_UNIX)
#define	rpc_auth_short	cpu_to_be32(RPC_AUTH_SHORT)
#define	rpc_auth_gss	cpu_to_be32(RPC_AUTH_GSS)

#define	rpc_call	cpu_to_be32(RPC_CALL)
#define	rpc_reply	cpu_to_be32(RPC_REPLY)

#define	rpc_msg_accepted	cpu_to_be32(RPC_MSG_ACCEPTED)

#define	rpc_success		cpu_to_be32(RPC_SUCCESS)
#define	rpc_prog_unavail	cpu_to_be32(RPC_PROG_UNAVAIL)
#define	rpc_prog_mismatch	cpu_to_be32(RPC_PROG_MISMATCH)
#define	rpc_proc_unavail	cpu_to_be32(RPC_PROC_UNAVAIL)
#define	rpc_garbage_args	cpu_to_be32(RPC_GARBAGE_ARGS)
#define	rpc_system_err		cpu_to_be32(RPC_SYSTEM_ERR)
#define	rpc_drop_reply		cpu_to_be32(RPC_DROP_REPLY)

#define	rpc_mismatch		cpu_to_be32(RPC_MISMATCH)
#define	rpc_auth_error		cpu_to_be32(RPC_AUTH_ERROR)

#define	rpc_auth_ok		cpu_to_be32(RPC_AUTH_OK)
#define	rpc_autherr_badcred	cpu_to_be32(RPC_AUTH_BADCRED)
#define	rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
#define	rpc_autherr_badverf	cpu_to_be32(RPC_AUTH_BADVERF)
#define	rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
#define	rpc_autherr_tooweak	cpu_to_be32(RPC_AUTH_TOOWEAK)
#define	rpcsec_gsserr_credproblem	cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
#define	rpcsec_gsserr_ctxproblem	cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)

/*
 * Miscellaneous XDR helper functions
 */
__be32 *xdr_encode_opaque_fixed(__be32 *p, const void *ptr, unsigned int len);
__be32 *xdr_encode_opaque(__be32 *p, const void *ptr, unsigned int len);
__be32 *xdr_encode_string(__be32 *p, const char *s);
__be32 *xdr_decode_string_inplace(__be32 *p, char **sp, unsigned int *lenp,
			unsigned int maxlen);
__be32 *xdr_encode_netobj(__be32 *p, const struct xdr_netobj *);
__be32 *xdr_decode_netobj(__be32 *p, struct xdr_netobj *);

void	xdr_inline_pages(struct xdr_buf *, unsigned int,
			 struct page **, unsigned int, unsigned int);
void	xdr_terminate_string(struct xdr_buf *, const u32);
size_t	xdr_buf_pagecount(struct xdr_buf *buf);
int	xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp);
void	xdr_free_bvec(struct xdr_buf *buf);

static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
{
	return xdr_encode_opaque(p, s, len);
}

/*
 * Decode 64bit quantities (NFSv3 support)
 */
static inline __be32 *
xdr_encode_hyper(__be32 *p, __u64 val)
{
	put_unaligned_be64(val, p);
	return p + 2;
}

static inline __be32 *
xdr_decode_hyper(__be32 *p, __u64 *valp)
{
	*valp = get_unaligned_be64(p);
	return p + 2;
}

static inline __be32 *
xdr_decode_opaque_fixed(__be32 *p, void *ptr, unsigned int len)
{
	memcpy(ptr, p, len);
	return p + XDR_QUADLEN(len);
}

static inline void xdr_netobj_dup(struct xdr_netobj *dst,
				  struct xdr_netobj *src, gfp_t gfp_mask)
{
	dst->data = kmemdup(src->data, src->len, gfp_mask);
	dst->len = src->len;
}

/*
 * Adjust kvec to reflect end of xdr'ed data (RPC client XDR)
 */
static inline int
xdr_adjust_iovec(struct kvec *iov, __be32 *p)
{
	return iov->iov_len = ((u8 *) p - (u8 *) iov->iov_base);
}

/*
 * XDR buffer helper functions
 */
extern void xdr_shift_buf(struct xdr_buf *, size_t);
extern void xdr_buf_from_iov(struct kvec *, struct xdr_buf *);
extern int xdr_buf_subsegment(struct xdr_buf *, struct xdr_buf *, unsigned int, unsigned int);
extern void xdr_buf_trim(struct xdr_buf *, unsigned int);
extern int read_bytes_from_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);
extern int write_bytes_to_xdr_buf(struct xdr_buf *, unsigned int, void *, unsigned int);

extern int xdr_encode_word(struct xdr_buf *, unsigned int, u32);
extern int xdr_decode_word(struct xdr_buf *, unsigned int, u32 *);

struct xdr_array2_desc;
typedef int (*xdr_xcode_elem_t)(struct xdr_array2_desc *desc, void *elem);
struct xdr_array2_desc {
	unsigned int elem_size;
	unsigned int array_len;
	unsigned int array_maxlen;
	xdr_xcode_elem_t xcode;
};

extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
			     struct xdr_array2_desc *desc);
extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
			     struct xdr_array2_desc *desc);
extern void _copy_from_pages(char *p, struct page **pages, size_t pgbase,
			     size_t len);

/*
 * Provide some simple tools for XDR buffer overflow-checking etc.
 */
struct xdr_stream {
	__be32 *p;		/* start of available buffer */
	struct xdr_buf *buf;	/* XDR buffer to read/write */

	__be32 *end;		/* end of available buffer space */
	struct kvec *iov;	/* pointer to the current kvec */
	struct kvec scratch;	/* Scratch buffer */
	struct page **page_ptr;	/* pointer to the current page */
	unsigned int nwords;	/* Remaining decode buffer length */

	struct rpc_rqst *rqst;	/* For debugging */
};

/*
 * These are the xdr_stream style generic XDR encode and decode functions.
 */
typedef void	(*kxdreproc_t)(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
		const void *obj);
typedef int	(*kxdrdproc_t)(struct rpc_rqst *rqstp, struct xdr_stream *xdr,
		void *obj);

extern void xdr_init_encode(struct xdr_stream *xdr, struct xdr_buf *buf,
			    __be32 *p, struct rpc_rqst *rqst);
extern __be32 *xdr_reserve_space(struct xdr_stream *xdr, size_t nbytes);
extern void xdr_commit_encode(struct xdr_stream *xdr);
extern void xdr_truncate_encode(struct xdr_stream *xdr, size_t len);
extern int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen);
extern void xdr_write_pages(struct xdr_stream *xdr, struct page **pages,
		unsigned int base, unsigned int len);
extern unsigned int xdr_stream_pos(const struct xdr_stream *xdr);
extern void xdr_init_decode(struct xdr_stream *xdr, struct xdr_buf *buf,
			    __be32 *p, struct rpc_rqst *rqst);
extern void xdr_init_decode_pages(struct xdr_stream *xdr, struct xdr_buf *buf,
		struct page **pages, unsigned int len);
extern void xdr_set_scratch_buffer(struct xdr_stream *xdr, void *buf, size_t buflen);
extern __be32 *xdr_inline_decode(struct xdr_stream *xdr, size_t nbytes);
extern unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
extern void xdr_enter_page(struct xdr_stream *xdr, unsigned int len);
extern int xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len, int (*actor)(struct scatterlist *, void *), void *data);

/**
 * xdr_stream_remaining - Return the number of bytes remaining in the stream
 * @xdr: pointer to struct xdr_stream
 *
 * Return value:
 *   Number of bytes remaining in @xdr before xdr->end
 */
static inline size_t
xdr_stream_remaining(const struct xdr_stream *xdr)
{
	return xdr->nwords << 2;
}

ssize_t xdr_stream_decode_opaque(struct xdr_stream *xdr, void *ptr,
		size_t size);
ssize_t xdr_stream_decode_opaque_dup(struct xdr_stream *xdr, void **ptr,
		size_t maxlen, gfp_t gfp_flags);
ssize_t xdr_stream_decode_string(struct xdr_stream *xdr, char *str,
		size_t size);
ssize_t xdr_stream_decode_string_dup(struct xdr_stream *xdr, char **str,
		size_t maxlen, gfp_t gfp_flags);
/**
 * xdr_align_size - Calculate padded size of an object
 * @n: Size of an object being XDR encoded (in bytes)
 *
 * Return value:
 *   Size (in bytes) of the object including xdr padding
 */
static inline size_t
xdr_align_size(size_t n)
{
	const size_t mask = sizeof(__u32) - 1;

	return (n + mask) & ~mask;
}

/**
 * xdr_pad_size - Calculate size of an object's pad
 * @n: Size of an object being XDR encoded (in bytes)
 *
 * This implementation avoids the need for conditional
 * branches or modulo division.
 *
 * Return value:
 *   Size (in bytes) of the needed XDR pad
 */
static inline size_t xdr_pad_size(size_t n)
{
	return xdr_align_size(n) - n;
}

/**
 * xdr_stream_encode_item_present - Encode a "present" list item
 * @xdr: pointer to xdr_stream
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t xdr_stream_encode_item_present(struct xdr_stream *xdr)
{
	const size_t len = sizeof(__be32);
	__be32 *p = xdr_reserve_space(xdr, len);

	if (unlikely(!p))
		return -EMSGSIZE;
	*p = xdr_one;
	return len;
}

/**
 * xdr_stream_encode_item_absent - Encode a "not present" list item
 * @xdr: pointer to xdr_stream
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline int xdr_stream_encode_item_absent(struct xdr_stream *xdr)
{
	const size_t len = sizeof(__be32);
	__be32 *p = xdr_reserve_space(xdr, len);

	if (unlikely(!p))
		return -EMSGSIZE;
	*p = xdr_zero;
	return len;
}

/**
 * xdr_stream_encode_u32 - Encode a 32-bit integer
 * @xdr: pointer to xdr_stream
 * @n: integer to encode
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_u32(struct xdr_stream *xdr, __u32 n)
{
	const size_t len = sizeof(n);
	__be32 *p = xdr_reserve_space(xdr, len);

	if (unlikely(!p))
		return -EMSGSIZE;
	*p = cpu_to_be32(n);
	return len;
}

/**
 * xdr_stream_encode_u64 - Encode a 64-bit integer
 * @xdr: pointer to xdr_stream
 * @n: 64-bit integer to encode
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_u64(struct xdr_stream *xdr, __u64 n)
{
	const size_t len = sizeof(n);
	__be32 *p = xdr_reserve_space(xdr, len);

	if (unlikely(!p))
		return -EMSGSIZE;
	xdr_encode_hyper(p, n);
	return len;
}

/**
 * xdr_stream_encode_opaque_inline - Encode opaque xdr data
 * @xdr: pointer to xdr_stream
 * @ptr: pointer to void pointer
 * @len: size of object
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_opaque_inline(struct xdr_stream *xdr, void **ptr, size_t len)
{
	size_t count = sizeof(__u32) + xdr_align_size(len);
	__be32 *p = xdr_reserve_space(xdr, count);

	if (unlikely(!p)) {
		*ptr = NULL;
		return -EMSGSIZE;
	}
	xdr_encode_opaque(p, NULL, len);
	*ptr = ++p;
	return count;
}

/**
 * xdr_stream_encode_opaque_fixed - Encode fixed length opaque xdr data
 * @xdr: pointer to xdr_stream
 * @ptr: pointer to opaque data object
 * @len: size of object pointed to by @ptr
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_opaque_fixed(struct xdr_stream *xdr, const void *ptr, size_t len)
{
	__be32 *p = xdr_reserve_space(xdr, len);

	if (unlikely(!p))
		return -EMSGSIZE;
	xdr_encode_opaque_fixed(p, ptr, len);
	return xdr_align_size(len);
}

/**
 * xdr_stream_encode_opaque - Encode variable length opaque xdr data
 * @xdr: pointer to xdr_stream
 * @ptr: pointer to opaque data object
 * @len: size of object pointed to by @ptr
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_opaque(struct xdr_stream *xdr, const void *ptr, size_t len)
{
	size_t count = sizeof(__u32) + xdr_align_size(len);
	__be32 *p = xdr_reserve_space(xdr, count);

	if (unlikely(!p))
		return -EMSGSIZE;
	xdr_encode_opaque(p, ptr, len);
	return count;
}

/**
 * xdr_stream_encode_uint32_array - Encode variable length array of integers
 * @xdr: pointer to xdr_stream
 * @array: array of integers
 * @array_size: number of elements in @array
 *
 * Return values:
 *   On success, returns length in bytes of XDR buffer consumed
 *   %-EMSGSIZE on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_encode_uint32_array(struct xdr_stream *xdr,
		const __u32 *array, size_t array_size)
{
	ssize_t ret = (array_size+1) * sizeof(__u32);
	__be32 *p = xdr_reserve_space(xdr, ret);

	if (unlikely(!p))
		return -EMSGSIZE;
	*p++ = cpu_to_be32(array_size);
	for (; array_size > 0; p++, array++, array_size--)
		*p = cpu_to_be32p(array);
	return ret;
}

/**
 * xdr_stream_decode_u32 - Decode a 32-bit integer
 * @xdr: pointer to xdr_stream
 * @ptr: location to store integer
 *
 * Return values:
 *   %0 on success
 *   %-EBADMSG on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_decode_u32(struct xdr_stream *xdr, __u32 *ptr)
{
	const size_t count = sizeof(*ptr);
	__be32 *p = xdr_inline_decode(xdr, count);

	if (unlikely(!p))
		return -EBADMSG;
	*ptr = be32_to_cpup(p);
	return 0;
}

/**
 * xdr_stream_decode_opaque_fixed - Decode fixed length opaque xdr data
 * @xdr: pointer to xdr_stream
 * @ptr: location to store data
 * @len: size of buffer pointed to by @ptr
 *
 * Return values:
 *   On success, returns size of object stored in @ptr
 *   %-EBADMSG on XDR buffer overflow
 */
static inline ssize_t
xdr_stream_decode_opaque_fixed(struct xdr_stream *xdr, void *ptr, size_t len)
{
	__be32 *p = xdr_inline_decode(xdr, len);

	if (unlikely(!p))
		return -EBADMSG;
	xdr_decode_opaque_fixed(p, ptr, len);
	return len;
}

/**
 * xdr_stream_decode_opaque_inline - Decode variable length opaque xdr data
 * @xdr: pointer to xdr_stream
 * @ptr: location to store pointer to opaque data
 * @maxlen: maximum acceptable object size
 *
 * Note: the pointer stored in @ptr cannot be assumed valid after the XDR
 * buffer has been destroyed, or even after calling xdr_inline_decode()
 * on @xdr. It is therefore expected that the object it points to should
 * be processed immediately.
 *
 * Return values:
 *   On success, returns size of object stored in *@ptr
 *   %-EBADMSG on XDR buffer overflow
 *   %-EMSGSIZE if the size of the object would exceed @maxlen
 */
static inline ssize_t
xdr_stream_decode_opaque_inline(struct xdr_stream *xdr, void **ptr, size_t maxlen)
{
	__be32 *p;
	__u32 len;

	*ptr = NULL;
	if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
		return -EBADMSG;
	if (len != 0) {
		p = xdr_inline_decode(xdr, len);
		if (unlikely(!p))
			return -EBADMSG;
		if (unlikely(len > maxlen))
			return -EMSGSIZE;
		*ptr = p;
	}
	return len;
}

/**
 * xdr_stream_decode_uint32_array - Decode variable length array of integers
 * @xdr: pointer to xdr_stream
 * @array: location to store the integer array or NULL
 * @array_size: number of elements to store
 *
 * Return values:
 *   On success, returns number of elements stored in @array
 *   %-EBADMSG on XDR buffer overflow
 *   %-EMSGSIZE if the size of the array exceeds @array_size
 */
static inline ssize_t
xdr_stream_decode_uint32_array(struct xdr_stream *xdr,
		__u32 *array, size_t array_size)
{
	__be32 *p;
	__u32 len;
	ssize_t retval;

	if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
		return -EBADMSG;
	p = xdr_inline_decode(xdr, len * sizeof(*p));
	if (unlikely(!p))
		return -EBADMSG;
	if (array == NULL)
		return len;
	if (len <= array_size) {
		if (len < array_size)
			memset(array+len, 0, (array_size-len)*sizeof(*array));
		array_size = len;
		retval = len;
	} else
		retval = -EMSGSIZE;
	for (; array_size > 0; p++, array++, array_size--)
		*array = be32_to_cpup(p);
	return retval;
}

#endif /* _SUNRPC_XDR_H_ */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
1da177e4	2	/*
9605a069	3	* XDR standard data types and function declarations
1da177e4 LT	4	*
1da177e4 LT	5	* Copyright (C) 1995-1997 Olaf Kirch <okir@monad.swb.de>
9605a069 CL	6	*
	7	* Based on:
	8	* RFC 4506 "XDR: External Data Representation Standard", May 2006
1da177e4 LT	9	*/
	10
	11	#ifndef _SUNRPC_XDR_H_
	12	#define _SUNRPC_XDR_H_
	13
1da177e4 LT	14	#include <linux/uio.h>
1da177e4 LT	15	#include <asm/byteorder.h>
97363c6a	16	#include <asm/unaligned.h>
37a4e6cb	17	#include <linux/scatterlist.h>
1da177e4	18
9d96acbc	19	struct bio_vec;
c512f36b CH	20	struct rpc_rqst;
c512f36b CH	21
1da177e4 LT	22	/*
	23	* Buffer adjustment
	24	*/
	25	#define XDR_QUADLEN(l) (((l) + 3) >> 2)
	26
	27	/*
	28	* Generic opaque `network object.' At the kernel level, this type
	29	* is used only by lockd.
	30	*/
	31	#define XDR_MAX_NETOBJ 1024
	32	struct xdr_netobj {
	33	unsigned int len;
	34	u8 * data;
	35	};
	36
1da177e4 LT	37	/*
	38	* Basic structure for transmission/reception of a client XDR message.
	39	* Features a header (for a linear buffer containing RPC headers
	40	* and the data payload for short messages), and then an array of
	41	* pages.
	42	* The tail iovec allows you to append data after the page array. Its
	43	* main interest is for appending padding to the pages in order to
	44	* satisfy the int_32-alignment requirements in RFC1832.
	45	*
	46	* For the future, we might want to string several of these together
	47	* in a list if anybody wants to make use of NFSv4 COMPOUND
	48	* operations and/or has a need for scatter/gather involving pages.
	49	*/
	50	struct xdr_buf {
	51	struct kvec head[1], /* RPC header + non-page data */
	52	tail[1]; /* Appended after page data */
	53
9d96acbc	54	struct bio_vec *bvec;
de0b65ca	55	struct page ** pages; /* Array of pages */
1da177e4	56	unsigned int page_base, /* Start of page data */
4f22ccc3 TT	57	page_len, /* Length of page data */
	58	flags; /* Flags for data disposition */
	59	#define XDRBUF_READ 0x01 /* target of file read */
	60	#define XDRBUF_WRITE 0x02 /* source of file write */
431f6eb3	61	#define XDRBUF_SPARSE_PAGES 0x04 /* Page array is sparse */
1da177e4 LT	62
	63	unsigned int buflen, /* Total length of storage buffer */
	64	len; /* Length of XDR encoded message */
1da177e4 LT	65	};
1da177e4 LT	66
b9c5bc03 CL	67	static inline void
	68	xdr_buf_init(struct xdr_buf buf, void start, size_t len)
	69	{
	70	buf->head[0].iov_base = start;
	71	buf->head[0].iov_len = len;
	72	buf->tail[0].iov_len = 0;
9d96acbc	73	buf->pages = NULL;
b9c5bc03 CL	74	buf->page_len = 0;
	75	buf->flags = 0;
	76	buf->len = 0;
	77	buf->buflen = len;
	78	}
	79
1da177e4 LT	80	/*
	81	* pre-xdr'ed macros.
	82	*/
	83
77f18f5e HH	84	#define xdr_zero cpu_to_be32(0)
	85	#define xdr_one cpu_to_be32(1)
	86	#define xdr_two cpu_to_be32(2)
	87
e8680a24 CL	88	#define rpc_auth_null cpu_to_be32(RPC_AUTH_NULL)
e8680a24 CL	89	#define rpc_auth_unix cpu_to_be32(RPC_AUTH_UNIX)
a0584ee9	90	#define rpc_auth_short cpu_to_be32(RPC_AUTH_SHORT)
e8680a24 CL	91	#define rpc_auth_gss cpu_to_be32(RPC_AUTH_GSS)
	92
	93	#define rpc_call cpu_to_be32(RPC_CALL)
7f5667a5 CL	94	#define rpc_reply cpu_to_be32(RPC_REPLY)
	95
	96	#define rpc_msg_accepted cpu_to_be32(RPC_MSG_ACCEPTED)
e8680a24	97
77f18f5e HH	98	#define rpc_success cpu_to_be32(RPC_SUCCESS)
	99	#define rpc_prog_unavail cpu_to_be32(RPC_PROG_UNAVAIL)
	100	#define rpc_prog_mismatch cpu_to_be32(RPC_PROG_MISMATCH)
	101	#define rpc_proc_unavail cpu_to_be32(RPC_PROC_UNAVAIL)
	102	#define rpc_garbage_args cpu_to_be32(RPC_GARBAGE_ARGS)
	103	#define rpc_system_err cpu_to_be32(RPC_SYSTEM_ERR)
	104	#define rpc_drop_reply cpu_to_be32(RPC_DROP_REPLY)
	105
7f5667a5 CL	106	#define rpc_mismatch cpu_to_be32(RPC_MISMATCH)
	107	#define rpc_auth_error cpu_to_be32(RPC_AUTH_ERROR)
	108
77f18f5e HH	109	#define rpc_auth_ok cpu_to_be32(RPC_AUTH_OK)
	110	#define rpc_autherr_badcred cpu_to_be32(RPC_AUTH_BADCRED)
	111	#define rpc_autherr_rejectedcred cpu_to_be32(RPC_AUTH_REJECTEDCRED)
	112	#define rpc_autherr_badverf cpu_to_be32(RPC_AUTH_BADVERF)
	113	#define rpc_autherr_rejectedverf cpu_to_be32(RPC_AUTH_REJECTEDVERF)
	114	#define rpc_autherr_tooweak cpu_to_be32(RPC_AUTH_TOOWEAK)
	115	#define rpcsec_gsserr_credproblem cpu_to_be32(RPCSEC_GSS_CREDPROBLEM)
	116	#define rpcsec_gsserr_ctxproblem cpu_to_be32(RPCSEC_GSS_CTXPROBLEM)
1da177e4 LT	117
	118	/*
	119	* Miscellaneous XDR helper functions
	120	*/
d8ed029d AD	121	__be32 xdr_encode_opaque_fixed(__be32 p, const void *ptr, unsigned int len);
	122	__be32 xdr_encode_opaque(__be32 p, const void *ptr, unsigned int len);
	123	__be32 xdr_encode_string(__be32 p, const char *s);
e5cff482 CL	124	__be32 xdr_decode_string_inplace(__be32 p, char *sp, unsigned int lenp,
e5cff482 CL	125	unsigned int maxlen);
d8ed029d AD	126	__be32 xdr_encode_netobj(__be32 p, const struct xdr_netobj *);
d8ed029d AD	127	__be32 xdr_decode_netobj(__be32 p, struct xdr_netobj *);
1da177e4	128
1da177e4 LT	129	void xdr_inline_pages(struct xdr_buf *, unsigned int,
1da177e4 LT	130	struct page **, unsigned int, unsigned int);
b4687da7	131	void xdr_terminate_string(struct xdr_buf *, const u32);
9d96acbc TM	132	size_t xdr_buf_pagecount(struct xdr_buf *buf);
	133	int xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp);
	134	void xdr_free_bvec(struct xdr_buf *buf);
1da177e4	135
d8ed029d	136	static inline __be32 xdr_encode_array(__be32 p, const void *s, unsigned int len)
1da177e4 LT	137	{
	138	return xdr_encode_opaque(p, s, len);
	139	}
	140
	141	/*
	142	* Decode 64bit quantities (NFSv3 support)
	143	*/
d8ed029d AD	144	static inline __be32 *
d8ed029d AD	145	xdr_encode_hyper(__be32 *p, __u64 val)
1da177e4	146	{
97363c6a	147	put_unaligned_be64(val, p);
9f162d2a	148	return p + 2;
1da177e4 LT	149	}
1da177e4 LT	150
d8ed029d AD	151	static inline __be32 *
d8ed029d AD	152	xdr_decode_hyper(__be32 p, __u64 valp)
1da177e4	153	{
97363c6a	154	*valp = get_unaligned_be64(p);
98866b5a	155	return p + 2;
1da177e4 LT	156	}
1da177e4 LT	157
35b61e63 BH	158	static inline __be32 *
	159	xdr_decode_opaque_fixed(__be32 p, void ptr, unsigned int len)
	160	{
	161	memcpy(ptr, p, len);
	162	return p + XDR_QUADLEN(len);
	163	}
	164
6f4859b8 BF	165	static inline void xdr_netobj_dup(struct xdr_netobj *dst,
	166	struct xdr_netobj *src, gfp_t gfp_mask)
	167	{
	168	dst->data = kmemdup(src->data, src->len, gfp_mask);
	169	dst->len = src->len;
	170	}
	171
1da177e4 LT	172	/*
	173	* Adjust kvec to reflect end of xdr'ed data (RPC client XDR)
	174	*/
	175	static inline int
d8ed029d	176	xdr_adjust_iovec(struct kvec iov, __be32 p)
1da177e4 LT	177	{
	178	return iov->iov_len = ((u8 ) p - (u8 ) iov->iov_base);
	179	}
	180
1da177e4 LT	181	/*
	182	* XDR buffer helper functions
	183	*/
	184	extern void xdr_shift_buf(struct xdr_buf *, size_t);
	185	extern void xdr_buf_from_iov(struct kvec , struct xdr_buf );
1e78957e	186	extern int xdr_buf_subsegment(struct xdr_buf , struct xdr_buf , unsigned int, unsigned int);
0a8e7b7d	187	extern void xdr_buf_trim(struct xdr_buf *, unsigned int);
1e78957e TM	188	extern int read_bytes_from_xdr_buf(struct xdr_buf , unsigned int, void , unsigned int);
1e78957e TM	189	extern int write_bytes_to_xdr_buf(struct xdr_buf , unsigned int, void , unsigned int);
1da177e4	190
1e78957e TM	191	extern int xdr_encode_word(struct xdr_buf *, unsigned int, u32);
1e78957e TM	192	extern int xdr_decode_word(struct xdr_buf , unsigned int, u32 );
bd8100e7 AG	193
	194	struct xdr_array2_desc;
	195	typedef int (xdr_xcode_elem_t)(struct xdr_array2_desc desc, void *elem);
	196	struct xdr_array2_desc {
	197	unsigned int elem_size;
	198	unsigned int array_len;
58fcb8df	199	unsigned int array_maxlen;
bd8100e7 AG	200	xdr_xcode_elem_t xcode;
	201	};
	202
	203	extern int xdr_decode_array2(struct xdr_buf *buf, unsigned int base,
9605a069	204	struct xdr_array2_desc *desc);
bd8100e7 AG	205	extern int xdr_encode_array2(struct xdr_buf *buf, unsigned int base,
bd8100e7 AG	206	struct xdr_array2_desc *desc);
bf118a34 AA	207	extern void _copy_from_pages(char p, struct page *pages, size_t pgbase,
bf118a34 AA	208	size_t len);
bd8100e7	209
1da177e4 LT	210	/*
	211	* Provide some simple tools for XDR buffer overflow-checking etc.
	212	*/
	213	struct xdr_stream {
d8ed029d	214	__be32 p; / start of available buffer */
1da177e4 LT	215	struct xdr_buf buf; / XDR buffer to read/write */
1da177e4 LT	216
d8ed029d	217	__be32 end; / end of available buffer space */
1da177e4	218	struct kvec iov; / pointer to the current kvec */
6650239a TM	219	struct kvec scratch; /* Scratch buffer */
6650239a TM	220	struct page *page_ptr; / pointer to the current page */
bfeea1dc	221	unsigned int nwords; /* Remaining decode buffer length */
0ccc61b1 CL	222
0ccc61b1 CL	223	struct rpc_rqst rqst; / For debugging */
1da177e4 LT	224	};
1da177e4 LT	225
9f06c719	226	/*
bf269551	227	* These are the xdr_stream style generic XDR encode and decode functions.
9f06c719	228	*/
c512f36b CH	229	typedef void (kxdreproc_t)(struct rpc_rqst rqstp, struct xdr_stream *xdr,
c512f36b CH	230	const void *obj);
73c8dc13 CH	231	typedef int (kxdrdproc_t)(struct rpc_rqst rqstp, struct xdr_stream *xdr,
73c8dc13 CH	232	void *obj);
9f06c719	233
0ccc61b1 CL	234	extern void xdr_init_encode(struct xdr_stream xdr, struct xdr_buf buf,
0ccc61b1 CL	235	__be32 p, struct rpc_rqst rqst);
d8ed029d	236	extern __be32 xdr_reserve_space(struct xdr_stream xdr, size_t nbytes);
2825a7f9	237	extern void xdr_commit_encode(struct xdr_stream *xdr);
3e19ce76	238	extern void xdr_truncate_encode(struct xdr_stream *xdr, size_t len);
db3f58a9	239	extern int xdr_restrict_buflen(struct xdr_stream *xdr, int newbuflen);
1da177e4 LT	240	extern void xdr_write_pages(struct xdr_stream xdr, struct page *pages,
1da177e4 LT	241	unsigned int base, unsigned int len);
4517d526	242	extern unsigned int xdr_stream_pos(const struct xdr_stream *xdr);
0ccc61b1 CL	243	extern void xdr_init_decode(struct xdr_stream xdr, struct xdr_buf buf,
0ccc61b1 CL	244	__be32 p, struct rpc_rqst rqst);
f7da7a12 BH	245	extern void xdr_init_decode_pages(struct xdr_stream xdr, struct xdr_buf buf,
f7da7a12 BH	246	struct page **pages, unsigned int len);
6650239a	247	extern void xdr_set_scratch_buffer(struct xdr_stream xdr, void buf, size_t buflen);
d8ed029d	248	extern __be32 xdr_inline_decode(struct xdr_stream xdr, size_t nbytes);
c337d365	249	extern unsigned int xdr_read_pages(struct xdr_stream *xdr, unsigned int len);
8b23ea7b	250	extern void xdr_enter_page(struct xdr_stream *xdr, unsigned int len);
37a4e6cb	251	extern int xdr_process_buf(struct xdr_buf buf, unsigned int offset, unsigned int len, int (actor)(struct scatterlist , void ), void *data);
1da177e4	252
41c8f70f CL	253	/**
	254	* xdr_stream_remaining - Return the number of bytes remaining in the stream
	255	* @xdr: pointer to struct xdr_stream
	256	*
	257	* Return value:
	258	* Number of bytes remaining in @xdr before xdr->end
	259	*/
	260	static inline size_t
	261	xdr_stream_remaining(const struct xdr_stream *xdr)
	262	{
	263	return xdr->nwords << 2;
	264	}
	265
0e779aa7 TM	266	ssize_t xdr_stream_decode_opaque(struct xdr_stream xdr, void ptr,
	267	size_t size);
	268	ssize_t xdr_stream_decode_opaque_dup(struct xdr_stream xdr, void *ptr,
	269	size_t maxlen, gfp_t gfp_flags);
	270	ssize_t xdr_stream_decode_string(struct xdr_stream xdr, char str,
	271	size_t size);
5c741d4f TM	272	ssize_t xdr_stream_decode_string_dup(struct xdr_stream xdr, char *str,
5c741d4f TM	273	size_t maxlen, gfp_t gfp_flags);
0ae060ca TM	274	/**
	275	* xdr_align_size - Calculate padded size of an object
	276	* @n: Size of an object being XDR encoded (in bytes)
	277	*
	278	* Return value:
	279	* Size (in bytes) of the object including xdr padding
	280	*/
	281	static inline size_t
	282	xdr_align_size(size_t n)
	283	{
	284	const size_t mask = sizeof(__u32) - 1;
	285
	286	return (n + mask) & ~mask;
	287	}
	288
96f194b7 CL	289	/**
	290	* xdr_pad_size - Calculate size of an object's pad
	291	* @n: Size of an object being XDR encoded (in bytes)
	292	*
	293	* This implementation avoids the need for conditional
	294	* branches or modulo division.
	295	*
	296	* Return value:
	297	* Size (in bytes) of the needed XDR pad
	298	*/
	299	static inline size_t xdr_pad_size(size_t n)
	300	{
	301	return xdr_align_size(n) - n;
	302	}
	303
5c266df5 CL	304	/**
	305	* xdr_stream_encode_item_present - Encode a "present" list item
	306	* @xdr: pointer to xdr_stream
	307	*
	308	* Return values:
	309	* On success, returns length in bytes of XDR buffer consumed
	310	* %-EMSGSIZE on XDR buffer overflow
	311	*/
	312	static inline ssize_t xdr_stream_encode_item_present(struct xdr_stream *xdr)
	313	{
	314	const size_t len = sizeof(__be32);
	315	__be32 *p = xdr_reserve_space(xdr, len);
	316
	317	if (unlikely(!p))
	318	return -EMSGSIZE;
	319	*p = xdr_one;
	320	return len;
	321	}
	322
	323	/**
	324	* xdr_stream_encode_item_absent - Encode a "not present" list item
	325	* @xdr: pointer to xdr_stream
	326	*
	327	* Return values:
	328	* On success, returns length in bytes of XDR buffer consumed
	329	* %-EMSGSIZE on XDR buffer overflow
	330	*/
	331	static inline int xdr_stream_encode_item_absent(struct xdr_stream *xdr)
	332	{
	333	const size_t len = sizeof(__be32);
	334	__be32 *p = xdr_reserve_space(xdr, len);
	335
	336	if (unlikely(!p))
	337	return -EMSGSIZE;
	338	*p = xdr_zero;
	339	return len;
	340	}
	341
0ae060ca TM	342	/**
	343	* xdr_stream_encode_u32 - Encode a 32-bit integer
	344	* @xdr: pointer to xdr_stream
	345	* @n: integer to encode
	346	*
	347	* Return values:
	348	* On success, returns length in bytes of XDR buffer consumed
	349	* %-EMSGSIZE on XDR buffer overflow
	350	*/
	351	static inline ssize_t
	352	xdr_stream_encode_u32(struct xdr_stream *xdr, __u32 n)
	353	{
	354	const size_t len = sizeof(n);
	355	__be32 *p = xdr_reserve_space(xdr, len);
	356
	357	if (unlikely(!p))
	358	return -EMSGSIZE;
	359	*p = cpu_to_be32(n);
	360	return len;
	361	}
	362
	363	/**
	364	* xdr_stream_encode_u64 - Encode a 64-bit integer
	365	* @xdr: pointer to xdr_stream
	366	* @n: 64-bit integer to encode
	367	*
	368	* Return values:
	369	* On success, returns length in bytes of XDR buffer consumed
	370	* %-EMSGSIZE on XDR buffer overflow
	371	*/
	372	static inline ssize_t
	373	xdr_stream_encode_u64(struct xdr_stream *xdr, __u64 n)
	374	{
	375	const size_t len = sizeof(n);
	376	__be32 *p = xdr_reserve_space(xdr, len);
	377
	378	if (unlikely(!p))
	379	return -EMSGSIZE;
	380	xdr_encode_hyper(p, n);
	381	return len;
	382	}
	383
85e3dd44 TM	384	/**
	385	* xdr_stream_encode_opaque_inline - Encode opaque xdr data
	386	* @xdr: pointer to xdr_stream
	387	* @ptr: pointer to void pointer
	388	* @len: size of object
	389	*
	390	* Return values:
	391	* On success, returns length in bytes of XDR buffer consumed
	392	* %-EMSGSIZE on XDR buffer overflow
	393	*/
	394	static inline ssize_t
	395	xdr_stream_encode_opaque_inline(struct xdr_stream xdr, void *ptr, size_t len)
	396	{
	397	size_t count = sizeof(__u32) + xdr_align_size(len);
	398	__be32 *p = xdr_reserve_space(xdr, count);
	399
	400	if (unlikely(!p)) {
	401	*ptr = NULL;
	402	return -EMSGSIZE;
	403	}
	404	xdr_encode_opaque(p, NULL, len);
	405	*ptr = ++p;
	406	return count;
	407	}
	408
0ae060ca TM	409	/**
	410	* xdr_stream_encode_opaque_fixed - Encode fixed length opaque xdr data
	411	* @xdr: pointer to xdr_stream
	412	* @ptr: pointer to opaque data object
	413	* @len: size of object pointed to by @ptr
	414	*
	415	* Return values:
	416	* On success, returns length in bytes of XDR buffer consumed
	417	* %-EMSGSIZE on XDR buffer overflow
	418	*/
	419	static inline ssize_t
	420	xdr_stream_encode_opaque_fixed(struct xdr_stream xdr, const void ptr, size_t len)
	421	{
	422	__be32 *p = xdr_reserve_space(xdr, len);
	423
	424	if (unlikely(!p))
	425	return -EMSGSIZE;
	426	xdr_encode_opaque_fixed(p, ptr, len);
	427	return xdr_align_size(len);
	428	}
	429
	430	/**
	431	* xdr_stream_encode_opaque - Encode variable length opaque xdr data
	432	* @xdr: pointer to xdr_stream
	433	* @ptr: pointer to opaque data object
	434	* @len: size of object pointed to by @ptr
	435	*
	436	* Return values:
	437	* On success, returns length in bytes of XDR buffer consumed
	438	* %-EMSGSIZE on XDR buffer overflow
	439	*/
	440	static inline ssize_t
	441	xdr_stream_encode_opaque(struct xdr_stream xdr, const void ptr, size_t len)
	442	{
	443	size_t count = sizeof(__u32) + xdr_align_size(len);
	444	__be32 *p = xdr_reserve_space(xdr, count);
	445
	446	if (unlikely(!p))
	447	return -EMSGSIZE;
	448	xdr_encode_opaque(p, ptr, len);
	449	return count;
	450	}
	451
37c88763 TM	452	/**
	453	* xdr_stream_encode_uint32_array - Encode variable length array of integers
	454	* @xdr: pointer to xdr_stream
	455	* @array: array of integers
	456	* @array_size: number of elements in @array
	457	*
	458	* Return values:
	459	* On success, returns length in bytes of XDR buffer consumed
	460	* %-EMSGSIZE on XDR buffer overflow
	461	*/
	462	static inline ssize_t
	463	xdr_stream_encode_uint32_array(struct xdr_stream *xdr,
	464	const __u32 *array, size_t array_size)
	465	{
	466	ssize_t ret = (array_size+1) * sizeof(__u32);
	467	__be32 *p = xdr_reserve_space(xdr, ret);
	468
	469	if (unlikely(!p))
	470	return -EMSGSIZE;
	471	*p++ = cpu_to_be32(array_size);
	472	for (; array_size > 0; p++, array++, array_size--)
	473	*p = cpu_to_be32p(array);
	474	return ret;
	475	}
	476
0ae060ca TM	477	/**
	478	* xdr_stream_decode_u32 - Decode a 32-bit integer
	479	* @xdr: pointer to xdr_stream
	480	* @ptr: location to store integer
	481	*
	482	* Return values:
	483	* %0 on success
	484	* %-EBADMSG on XDR buffer overflow
	485	*/
	486	static inline ssize_t
	487	xdr_stream_decode_u32(struct xdr_stream xdr, __u32 ptr)
	488	{
	489	const size_t count = sizeof(*ptr);
	490	__be32 *p = xdr_inline_decode(xdr, count);
	491
	492	if (unlikely(!p))
	493	return -EBADMSG;
	494	*ptr = be32_to_cpup(p);
	495	return 0;
	496	}
	497
	498	/**
	499	* xdr_stream_decode_opaque_fixed - Decode fixed length opaque xdr data
	500	* @xdr: pointer to xdr_stream
	501	* @ptr: location to store data
	502	* @len: size of buffer pointed to by @ptr
	503	*
	504	* Return values:
	505	* On success, returns size of object stored in @ptr
	506	* %-EBADMSG on XDR buffer overflow
	507	*/
	508	static inline ssize_t
	509	xdr_stream_decode_opaque_fixed(struct xdr_stream xdr, void ptr, size_t len)
	510	{
	511	__be32 *p = xdr_inline_decode(xdr, len);
	512
	513	if (unlikely(!p))
	514	return -EBADMSG;
	515	xdr_decode_opaque_fixed(p, ptr, len);
	516	return len;
	517	}
	518
	519	/**
	520	* xdr_stream_decode_opaque_inline - Decode variable length opaque xdr data
	521	* @xdr: pointer to xdr_stream
	522	* @ptr: location to store pointer to opaque data
	523	* @maxlen: maximum acceptable object size
	524	*
	525	* Note: the pointer stored in @ptr cannot be assumed valid after the XDR
	526	* buffer has been destroyed, or even after calling xdr_inline_decode()
	527	* on @xdr. It is therefore expected that the object it points to should
	528	* be processed immediately.
	529	*
	530	* Return values:
	531	* On success, returns size of object stored in *@ptr
	532	* %-EBADMSG on XDR buffer overflow
	533	* %-EMSGSIZE if the size of the object would exceed @maxlen
	534	*/
	535	static inline ssize_t
	536	xdr_stream_decode_opaque_inline(struct xdr_stream xdr, void *ptr, size_t maxlen)
	537	{
	538	__be32 *p;
	539	__u32 len;
	540
541	*ptr = NULL;
542	if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
543	return -EBADMSG;
544	if (len != 0) {
545	p = xdr_inline_decode(xdr, len);
546	if (unlikely(!p))
547	return -EBADMSG;
548	if (unlikely(len > maxlen))
549	return -EMSGSIZE;
550	*ptr = p;
551	}
552	return len;
553	}
37c88763 TM	554
	555	/**
	556	* xdr_stream_decode_uint32_array - Decode variable length array of integers
	557	* @xdr: pointer to xdr_stream
	558	* @array: location to store the integer array or NULL
	559	* @array_size: number of elements to store
	560	*
	561	* Return values:
	562	* On success, returns number of elements stored in @array
	563	* %-EBADMSG on XDR buffer overflow
	564	* %-EMSGSIZE if the size of the array exceeds @array_size
	565	*/
	566	static inline ssize_t
	567	xdr_stream_decode_uint32_array(struct xdr_stream *xdr,
	568	__u32 *array, size_t array_size)
	569	{
	570	__be32 *p;
	571	__u32 len;
	572	ssize_t retval;
	573
	574	if (unlikely(xdr_stream_decode_u32(xdr, &len) < 0))
	575	return -EBADMSG;
	576	p = xdr_inline_decode(xdr, len * sizeof(*p));
	577	if (unlikely(!p))
	578	return -EBADMSG;
	579	if (array == NULL)
	580	return len;
	581	if (len <= array_size) {
	582	if (len < array_size)
	583	memset(array+len, 0, (array_size-len)sizeof(array));
	584	array_size = len;
	585	retval = len;
	586	} else
	587	retval = -EMSGSIZE;
	588	for (; array_size > 0; p++, array++, array_size--)
	589	*array = be32_to_cpup(p);
	590	return retval;
	591	}
1da177e4 LT	592
1da177e4 LT	593	#endif /* _SUNRPC_XDR_H_ */