Differential D25512 Diff 76056 stand/libsa/zfs/nvlist.c

Changeset View

Standalone View

stand/libsa/zfs/nvlist.c

	Show All 21 Lines
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.			* SUCH DAMAGE.
	*/			*/

	#include <sys/cdefs.h>			#include <sys/cdefs.h>
	__FBSDID("$FreeBSD$");			__FBSDID("$FreeBSD$");

	#include <stand.h>			#include <stand.h>
				#include <stdbool.h>
	#include <sys/endian.h>			#include <sys/endian.h>
				#include <sys/stdint.h>
	#include <zfsimpl.h>			#include <zfsimpl.h>
	#include "libzfs.h"			#include "libzfs.h"

				enum xdr_op {
				XDR_OP_ENCODE = 1,
				XDR_OP_DECODE = 2
				};

	typedef struct xdr {			typedef struct xdr {
	int (xdr_getint)(const struct xdr , const void , int );			enum xdr_op xdr_op;
				int (xdr_getint)(struct xdr , int *);
				int (xdr_putint)(struct xdr , int);
				int (xdr_getuint)(struct xdr , unsigned *);
				int (xdr_putuint)(struct xdr , unsigned);
				const uint8_t *xdr_buf;
				uint8_t *xdr_idx;
				size_t xdr_buf_size;
	} xdr_t;			} xdr_t;

	static int xdr_int(const xdr_t , const void , int *);			static int nvlist_xdr_nvlist(xdr_t , nvlist_t );
	static int mem_int(const xdr_t , const void , int *);			static bool nvlist_size_xdr(xdr_t , size_t );
	static void nvlist_decode_nvlist(const xdr_t , nvlist_t );			static bool nvlist_size_native(xdr_t , size_t );
	static int nvlist_size(const xdr_t , const uint8_t );			static bool xdr_int(xdr_t , int );
				static bool xdr_u_int(xdr_t , unsigned );

	/*			typedef int (xdrproc_t)(xdr_t , void *);
	* transform data from network to host.
	*/
	xdr_t ntoh = {
	.xdr_getint = xdr_int
	};

	/*			/* Basic primitives for XDR translation operations, getint and putint. */
	* transform data from host to host.			static int
	*/			_getint(struct xdr xdr, int ip)
	xdr_t native = {			{
	.xdr_getint = mem_int			*ip = be32dec(xdr->xdr_idx);
	};			return (sizeof (int));
				}

	/*			static int
	* transform data from host to network.			_putint(struct xdr *xdr, int i)
	*/			{
	xdr_t hton = {			int ip = (int )xdr->xdr_idx;
	.xdr_getint = xdr_int
	};

				*ip = htobe32(i);
				return (sizeof (int));
				}

	static int			static int
	xdr_short(const xdr_t xdr, const uint8_t buf, short *ip)			_getuint(struct xdr xdr, unsigned ip)
	{			{
	int i, rv;			*ip = be32dec(xdr->xdr_idx);
				return (sizeof (unsigned));
				}

	rv = xdr->xdr_getint(xdr, buf, &i);			static int
				_putuint(struct xdr *xdr, unsigned i)
				{
				unsigned up = (unsigned )xdr->xdr_idx;

				*up = htobe32(i);
				return (sizeof (int));
				}

				/*
				* XDR data translations.
				*/
				static bool
				xdr_short(xdr_t xdr, short ip)
				{
				int i;
				bool rv;

				i = *ip;
				if ((rv = xdr_int(xdr, &i))) {
				if (xdr->xdr_op == XDR_OP_DECODE)
	*ip = i;			*ip = i;
				}
	return (rv);			return (rv);
	}			}

	static int			static bool
	xdr_u_short(const xdr_t xdr, const uint8_t buf, unsigned short *ip)			xdr_u_short(xdr_t xdr, unsigned short ip)
	{			{
	unsigned u;			unsigned u;
	int rv;			bool rv;

	rv = xdr->xdr_getint(xdr, buf, &u);			u = *ip;
				if ((rv = xdr_u_int(xdr, &u))) {
				if (xdr->xdr_op == XDR_OP_DECODE)
	*ip = u;			*ip = u;
				}
	return (rv);			return (rv);
	}			}

	static int			/*
	xdr_int(const xdr_t xdr __unused, const void buf, int *ip)			* translate xdr->xdr_idx, increment it by size of int.
				*/
				static bool
				xdr_int(xdr_t xdr, int ip)
	{			{
	*ip = be32dec(buf);			bool rv = false;
	return (sizeof(int));			int i = (int )xdr->xdr_idx;
	}

	static int			if (xdr->xdr_idx + sizeof (int) > xdr->xdr_buf + xdr->xdr_buf_size)
	xdr_u_int(const xdr_t xdr __unused, const void buf, unsigned *ip)			return (rv);
	{
	*ip = be32dec(buf);			switch (xdr->xdr_op) {
	return (sizeof(unsigned));			case XDR_OP_ENCODE:
				/* Encode value ip, store to buf /
				xdr->xdr_idx += xdr->xdr_putint(xdr, *ip);
				rv = true;
				break;

				case XDR_OP_DECODE:
				/* Decode buf, return value to ip /
				xdr->xdr_idx += xdr->xdr_getint(xdr, i);
				ip = i;
				rv = true;
				break;
	}			}
				return (rv);
				}

	static int			/*
	xdr_string(const xdr_t xdr, const void buf, nv_string_t *s)			* translate xdr->xdr_idx, increment it by size of unsigned int.
				*/
				static bool
				xdr_u_int(xdr_t xdr, unsigned ip)
	{			{
	int size;			bool rv = false;
				unsigned u = (unsigned )xdr->xdr_idx;

	size = xdr->xdr_getint(xdr, buf, &s->nv_size);			if (xdr->xdr_idx + sizeof (unsigned) > xdr->xdr_buf + xdr->xdr_buf_size)
	size = NV_ALIGN4(size + s->nv_size);			return (rv);
	return (size);
				switch (xdr->xdr_op) {
				case XDR_OP_ENCODE:
				/* Encode value ip, store to buf /
				xdr->xdr_idx += xdr->xdr_putuint(xdr, *ip);
				rv = true;
				break;

				case XDR_OP_DECODE:
				/* Decode buf, return value to ip /
				xdr->xdr_idx += xdr->xdr_getuint(xdr, u);
				ip = u;
				rv = true;
				break;
	}			}
				return (rv);
				}

	static int			static bool
	xdr_int64(const xdr_t xdr, const uint8_t buf, int64_t *lp)			xdr_int64(xdr_t xdr, int64_t lp)
	{			{
	int hi, rv;			int hi;
	unsigned lo;			unsigned lo;
				bool rv = false;

	rv = xdr->xdr_getint(xdr, buf, &hi);			if (xdr->xdr_idx + sizeof (int64_t) > xdr->xdr_buf + xdr->xdr_buf_size)
	rv += xdr->xdr_getint(xdr, buf + rv, &lo);			return (rv);

				switch (xdr->xdr_op) {
				case XDR_OP_ENCODE:
				/* Encode value lp, store to buf /
				hi = *lp >> 32;
				lo = *lp & UINT32_MAX;
				xdr->xdr_idx += xdr->xdr_putint(xdr, hi);
				xdr->xdr_idx += xdr->xdr_putint(xdr, lo);
				rv = true;
				break;

				case XDR_OP_DECODE:
				/* Decode buf, return value to ip /
				xdr->xdr_idx += xdr->xdr_getint(xdr, &hi);
				xdr->xdr_idx += xdr->xdr_getuint(xdr, &lo);
	*lp = (((int64_t)hi) << 32) \| lo;			*lp = (((int64_t)hi) << 32) \| lo;
				rv = true;
				}
	return (rv);			return (rv);
	}			}

	static int			static bool
	xdr_uint64(const xdr_t xdr, const uint8_t buf, uint64_t *lp)			xdr_uint64(xdr_t xdr, uint64_t lp)
	{			{
	unsigned hi, lo;			unsigned hi, lo;
	int rv;			bool rv = false;

	rv = xdr->xdr_getint(xdr, buf, &hi);			if (xdr->xdr_idx + sizeof (uint64_t) > xdr->xdr_buf + xdr->xdr_buf_size)
	rv += xdr->xdr_getint(xdr, buf + rv, &lo);
	*lp = (((int64_t)hi) << 32) \| lo;
	return (rv);			return (rv);

				switch (xdr->xdr_op) {
				case XDR_OP_ENCODE:
				/* Encode value ip, store to buf /
				hi = *lp >> 32;
				lo = *lp & UINT32_MAX;
				xdr->xdr_idx += xdr->xdr_putint(xdr, hi);
				xdr->xdr_idx += xdr->xdr_putint(xdr, lo);
				rv = true;
				break;

				case XDR_OP_DECODE:
				/* Decode buf, return value to ip /
				xdr->xdr_idx += xdr->xdr_getuint(xdr, &hi);
				xdr->xdr_idx += xdr->xdr_getuint(xdr, &lo);
				*lp = (((uint64_t)hi) << 32) \| lo;
				rv = true;
	}			}
				return (rv);
				}

	static int			static bool
	xdr_char(const xdr_t xdr, const uint8_t buf, char *cp)			xdr_char(xdr_t xdr, char cp)
	{			{
	int i, rv;			int i;
				bool rv = false;

	rv = xdr->xdr_getint(xdr, buf, &i);			i = *cp;
				if ((rv = xdr_int(xdr, &i))) {
				if (xdr->xdr_op == XDR_OP_DECODE)
	*cp = i;			*cp = i;
				}
	return (rv);			return (rv);
	}			}

	/*			static bool
	* read native data.			xdr_string(xdr_t xdr, nv_string_t s)
	*/
	static int
	mem_int(const xdr_t xdr, const void buf, int *i)
	{			{
	i = (int *)buf;			int size = 0;
	return (sizeof(int));			bool rv = false;

				switch (xdr->xdr_op) {
				case XDR_OP_ENCODE:
				size = s->nv_size;
				if (xdr->xdr_idx + sizeof (unsigned) + NV_ALIGN4(size) >
				xdr->xdr_buf + xdr->xdr_buf_size)
				break;
				xdr->xdr_idx += xdr->xdr_putuint(xdr, s->nv_size);
				xdr->xdr_idx += NV_ALIGN4(size);
				rv = true;
				break;

				case XDR_OP_DECODE:
				if (xdr->xdr_idx + sizeof (unsigned) >
				xdr->xdr_buf + xdr->xdr_buf_size)
				break;
				size = xdr->xdr_getuint(xdr, &s->nv_size);
				size = NV_ALIGN4(size + s->nv_size);
				if (xdr->xdr_idx + size > xdr->xdr_buf + xdr->xdr_buf_size)
				break;
				xdr->xdr_idx += size;
				rv = true;
				break;
	}			}
				return (rv);
				}

				static bool
				xdr_array(xdr_t *xdr, const unsigned nelem, const xdrproc_t elproc)
				{
				bool rv = true;

				for (unsigned i = 0; i < nelem; i++) {
				if (!elproc(xdr, xdr->xdr_idx))
				return (false);
				}
				return (rv);
				}

				/*
				* nvlist management functions.
				*/
	void			void
	nvlist_destroy(nvlist_t *nvl)			nvlist_destroy(nvlist_t *nvl)
	{			{
	if (nvl != NULL) {			if (nvl != NULL) {
	/* Free data if it was allocated by us. */			/* Free data if it was allocated by us. */
	if (nvl->nv_asize > 0)			if (nvl->nv_asize > 0)
	free(nvl->nv_data);			free(nvl->nv_data);
	}			}
	Show All 18 Lines
	* The nvlist is terminated by 2x zeros (8 bytes).			* The nvlist is terminated by 2x zeros (8 bytes).
	*/			*/
	nvlist_t *			nvlist_t *
	nvlist_create(int flag)			nvlist_create(int flag)
	{			{
	nvlist_t *nvl;			nvlist_t *nvl;
	nvs_data_t *nvs;			nvs_data_t *nvs;

	nvl = calloc(1, sizeof(*nvl));			nvl = calloc(1, sizeof (*nvl));
	if (nvl == NULL)			if (nvl == NULL)
	return (nvl);			return (nvl);

	nvl->nv_header.nvh_encoding = NV_ENCODE_XDR;			nvl->nv_header.nvh_encoding = NV_ENCODE_XDR;
	nvl->nv_header.nvh_endian = _BYTE_ORDER == _LITTLE_ENDIAN;			nvl->nv_header.nvh_endian = _BYTE_ORDER == _LITTLE_ENDIAN;

	nvl->nv_asize = nvl->nv_size = sizeof(*nvs);			nvl->nv_asize = nvl->nv_size = sizeof (*nvs);
	nvs = calloc(1, nvl->nv_asize);			nvs = calloc(1, nvl->nv_asize);
	if (nvs == NULL) {			if (nvs == NULL) {
	free(nvl);			free(nvl);
	return (NULL);			return (NULL);
	}			}
	/* data in nvlist is byte stream */			/* data in nvlist is byte stream */
	nvl->nv_data = (uint8_t *)nvs;			nvl->nv_data = (uint8_t *)nvs;

	nvs->nvl_version = NV_VERSION;			nvs->nvl_version = NV_VERSION;
	nvs->nvl_nvflag = flag;			nvs->nvl_nvflag = flag;
	return (nvl);			return (nvl);
	}			}

	static void			static bool
	nvlist_nvp_decode(const xdr_t xdr, nvlist_t nvl, nvp_header_t *nvph)			nvlist_xdr_nvp(xdr_t xdr, nvlist_t nvl)
	{			{
	nv_string_t *nv_string;			nv_string_t *nv_string;
	nv_pair_data_t *nvp_data;			nv_pair_data_t *nvp_data;
	nvlist_t nvlist;			nvlist_t nvlist;
				unsigned type, nelem;
				xdr_t nv_xdr;

	nv_string = (nv_string_t *)nvl->nv_idx;			nv_string = (nv_string_t *)xdr->xdr_idx;
	nvl->nv_idx += xdr_string(xdr, &nv_string->nv_size, nv_string);			if (!xdr_string(xdr, nv_string)) {
	nvp_data = (nv_pair_data_t *)nvl->nv_idx;			return (false);
				}
				nvp_data = (nv_pair_data_t *)xdr->xdr_idx;

	nvl->nv_idx += xdr_u_int(xdr, &nvp_data->nv_type, &nvp_data->nv_type);			type = nvp_data->nv_type;
	nvl->nv_idx += xdr_u_int(xdr, &nvp_data->nv_nelem, &nvp_data->nv_nelem);			nelem = nvp_data->nv_nelem;
				if (!xdr_u_int(xdr, &type) \|\| !xdr_u_int(xdr, &nelem))
				return (false);

	switch (nvp_data->nv_type) {			switch (type) {
	case DATA_TYPE_NVLIST:			case DATA_TYPE_NVLIST:
	case DATA_TYPE_NVLIST_ARRAY:			case DATA_TYPE_NVLIST_ARRAY:
	bzero(&nvlist, sizeof (nvlist));			bzero(&nvlist, sizeof (nvlist));
	nvlist.nv_data = &nvp_data->nv_data[0];			nvlist.nv_data = xdr->xdr_idx;
	nvlist.nv_idx = nvlist.nv_data;			nvlist.nv_idx = nvlist.nv_data;
	for (int i = 0; i < nvp_data->nv_nelem; i++) {
	nvlist.nv_asize =			/* Set up xdr for this nvlist. */
	nvlist_size(xdr, nvlist.nv_data);			nv_xdr = *xdr;
	nvlist_decode_nvlist(xdr, &nvlist);			nv_xdr.xdr_buf = nvlist.nv_data;
	nvl->nv_idx = nvlist.nv_idx;			nv_xdr.xdr_idx = nvlist.nv_data;
	nvlist.nv_data = nvlist.nv_idx;			nv_xdr.xdr_buf_size =
				nvl->nv_data + nvl->nv_size - nvlist.nv_data;

				for (unsigned i = 0; i < nelem; i++) {
				if (xdr->xdr_op == XDR_OP_ENCODE) {
				if (!nvlist_size_native(&nv_xdr,
				&nvlist.nv_size))
				return (false);
				} else {
				if (!nvlist_size_xdr(&nv_xdr,
				&nvlist.nv_size))
				return (false);
	}			}
				if (nvlist_xdr_nvlist(xdr, &nvlist) != 0)
				return (false);

				nvlist.nv_data = nv_xdr.xdr_idx;
				nvlist.nv_idx = nv_xdr.xdr_idx;

				nv_xdr.xdr_buf = nv_xdr.xdr_idx;
				nv_xdr.xdr_buf_size =
				nvl->nv_data + nvl->nv_size - nvlist.nv_data;
				}
	break;			break;

	case DATA_TYPE_BOOLEAN:			case DATA_TYPE_BOOLEAN:
	/* BOOLEAN does not take value space */			/* BOOLEAN does not take value space */
	break;			break;
	case DATA_TYPE_BYTE:			case DATA_TYPE_BYTE:
	case DATA_TYPE_INT8:			case DATA_TYPE_INT8:
	case DATA_TYPE_UINT8:			case DATA_TYPE_UINT8:
	nvl->nv_idx += xdr_char(xdr, &nvp_data->nv_data[0],			if (!xdr_char(xdr, (char *)&nvp_data->nv_data[0]))
	(char *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

	case DATA_TYPE_INT16:			case DATA_TYPE_INT16:
	nvl->nv_idx += xdr_short(xdr, &nvp_data->nv_data[0],			if (!xdr_short(xdr, (short *)&nvp_data->nv_data[0]))
	(short *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

	case DATA_TYPE_UINT16:			case DATA_TYPE_UINT16:
	nvl->nv_idx += xdr_u_short(xdr, &nvp_data->nv_data[0],			if (!xdr_u_short(xdr, (unsigned short *)&nvp_data->nv_data[0]))
	(unsigned short *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

	case DATA_TYPE_BOOLEAN_VALUE:			case DATA_TYPE_BOOLEAN_VALUE:
	case DATA_TYPE_INT32:			case DATA_TYPE_INT32:
	nvl->nv_idx += xdr_int(xdr, &nvp_data->nv_data[0],			if (!xdr_int(xdr, (int *)&nvp_data->nv_data[0]))
	(int *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

	case DATA_TYPE_UINT32:			case DATA_TYPE_UINT32:
	nvl->nv_idx += xdr_u_int(xdr, &nvp_data->nv_data[0],			if (!xdr_u_int(xdr, (unsigned *)&nvp_data->nv_data[0]))
	(unsigned *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

				case DATA_TYPE_HRTIME:
	case DATA_TYPE_INT64:			case DATA_TYPE_INT64:
	nvl->nv_idx += xdr_int64(xdr, &nvp_data->nv_data[0],			if (!xdr_int64(xdr, (int64_t *)&nvp_data->nv_data[0]))
	(int64_t *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

	case DATA_TYPE_UINT64:			case DATA_TYPE_UINT64:
	nvl->nv_idx += xdr_uint64(xdr, &nvp_data->nv_data[0],			if (!xdr_uint64(xdr, (uint64_t *)&nvp_data->nv_data[0]))
	(uint64_t *)&nvp_data->nv_data[0]);			return (false);
	break;			break;

				case DATA_TYPE_BYTE_ARRAY:
	case DATA_TYPE_STRING:			case DATA_TYPE_STRING:
	nv_string = (nv_string_t *)&nvp_data->nv_data[0];			nv_string = (nv_string_t *)&nvp_data->nv_data[0];
	nvl->nv_idx += xdr_string(xdr, &nvp_data->nv_data[0],			if (!xdr_string(xdr, nv_string))
	nv_string);			return (false);
				break;

				case DATA_TYPE_STRING_ARRAY:
				nv_string = (nv_string_t *)&nvp_data->nv_data[0];
				for (unsigned i = 0; i < nelem; i++) {
				if (!xdr_string(xdr, nv_string))
				return (false);
				nv_string = (nv_string_t *)xdr->xdr_idx;
				}
	break;			break;

				case DATA_TYPE_INT8_ARRAY:
				case DATA_TYPE_UINT8_ARRAY:
				case DATA_TYPE_INT16_ARRAY:
				case DATA_TYPE_UINT16_ARRAY:
				case DATA_TYPE_BOOLEAN_ARRAY:
				case DATA_TYPE_INT32_ARRAY:
				case DATA_TYPE_UINT32_ARRAY:
				if (!xdr_array(xdr, nelem, (xdrproc_t)xdr_u_int))
				return (false);
				break;

				case DATA_TYPE_INT64_ARRAY:
				case DATA_TYPE_UINT64_ARRAY:
				if (!xdr_array(xdr, nelem, (xdrproc_t)xdr_uint64))
				return (false);
				break;
	}			}
				return (true);
	}			}

	static void			static int
	nvlist_decode_nvlist(const xdr_t xdr, nvlist_t nvl)			nvlist_xdr_nvlist(xdr_t xdr, nvlist_t nvl)
	{			{
	nvp_header_t *nvph;			nvp_header_t *nvph;
	nvs_data_t nvs = (nvs_data_t )nvl->nv_data;			nvs_data_t *nvs;
				unsigned encoded_size, decoded_size;
				int rv;

	nvl->nv_idx = nvl->nv_data;			nvs = (nvs_data_t *)xdr->xdr_idx;
	nvl->nv_idx += xdr->xdr_getint(xdr, (const uint8_t *)&nvs->nvl_version,
	&nvs->nvl_version);
	nvl->nv_idx += xdr->xdr_getint(xdr, (const uint8_t *)&nvs->nvl_nvflag,
	&nvs->nvl_nvflag);

	nvph = &nvs->nvl_pair;			nvph = &nvs->nvl_pair;
	nvl->nv_idx += xdr->xdr_getint(xdr,
	(const uint8_t *)&nvph->encoded_size, &nvph->encoded_size);
	nvl->nv_idx += xdr->xdr_getint(xdr,
	(const uint8_t *)&nvph->decoded_size, &nvph->decoded_size);

	while (nvph->encoded_size && nvph->decoded_size) {			if (!xdr_u_int(xdr, &nvs->nvl_version))
	nvlist_nvp_decode(xdr, nvl, nvph);			return (EINVAL);
				if (!xdr_u_int(xdr, &nvs->nvl_nvflag))
				return (EINVAL);

	nvph = (nvp_header_t *)(nvl->nv_idx);			encoded_size = nvph->encoded_size;
	nvl->nv_idx += xdr->xdr_getint(xdr, &nvph->encoded_size,			decoded_size = nvph->decoded_size;
	&nvph->encoded_size);
	nvl->nv_idx += xdr->xdr_getint(xdr, &nvph->decoded_size,			if (xdr->xdr_op == XDR_OP_ENCODE) {
	&nvph->decoded_size);			if (!xdr_u_int(xdr, &nvph->encoded_size))
				return (EINVAL);
				if (!xdr_u_int(xdr, &nvph->decoded_size))
				return (EINVAL);
				} else {
				xdr->xdr_idx += 2 * sizeof (unsigned);
	}			}

				rv = 0;
				while (encoded_size && decoded_size) {
				if (!nvlist_xdr_nvp(xdr, nvl))
				return (EINVAL);

				nvph = (nvp_header_t *)(xdr->xdr_idx);
				encoded_size = nvph->encoded_size;
				decoded_size = nvph->decoded_size;
				if (xdr->xdr_op == XDR_OP_ENCODE) {
				if (!xdr_u_int(xdr, &nvph->encoded_size))
				return (EINVAL);
				if (!xdr_u_int(xdr, &nvph->decoded_size))
				return (EINVAL);
				} else {
				xdr->xdr_idx += 2 * sizeof (unsigned);
	}			}
				}
				return (rv);
				}

	static int			/*
	nvlist_size(const xdr_t xdr, const uint8_t stream)			* Calculate nvlist size, translating encoded_size and decoded_size.
				*/
				static bool
				nvlist_size_xdr(xdr_t xdr, size_t size)
	{			{
	const uint8_t p, pair;			uint8_t *pair;
	unsigned encoded_size, decoded_size;			unsigned encoded_size, decoded_size;

	p = stream;			xdr->xdr_idx += 2 * sizeof (unsigned);
	p += 2 * sizeof(unsigned);

	pair = p;			pair = xdr->xdr_idx;
	p += xdr->xdr_getint(xdr, p, &encoded_size);			if (!xdr_u_int(xdr, &encoded_size) \|\| !xdr_u_int(xdr, &decoded_size))
	p += xdr->xdr_getint(xdr, p, &decoded_size);			return (false);

	while (encoded_size && decoded_size) {			while (encoded_size && decoded_size) {
	p = pair + encoded_size;			xdr->xdr_idx = pair + encoded_size;
	pair = p;			pair = xdr->xdr_idx;
	p += xdr->xdr_getint(xdr, p, &encoded_size);			if (!xdr_u_int(xdr, &encoded_size) \|\|
	p += xdr->xdr_getint(xdr, p, &decoded_size);			!xdr_u_int(xdr, &decoded_size))
				return (false);
	}			}
	return (p - stream);			*size = xdr->xdr_idx - xdr->xdr_buf;

				return (true);
	}			}

				nvp_header_t *
				nvlist_next_nvpair(nvlist_t nvl, nvp_header_t nvh)
				{
				uint8_t *pair;
				unsigned encoded_size, decoded_size;
				xdr_t xdr;

				xdr.xdr_buf = nvl->nv_data;
				xdr.xdr_idx = nvl->nv_data;
				xdr.xdr_buf_size = nvl->nv_size;

				xdr.xdr_idx += 2 * sizeof (unsigned);

				/* Skip tp current pair */
				if (nvh != NULL) {
				xdr.xdr_idx = (uint8_t *)nvh;
				}

				pair = xdr.xdr_idx;
				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);

				encoded_size = (unsigned )xdr.xdr_idx;
				xdr.xdr_idx += sizeof (unsigned);
				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);

				decoded_size = (unsigned )xdr.xdr_idx;
				xdr.xdr_idx += sizeof (unsigned);
				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);

				while (encoded_size && decoded_size) {
				if (nvh == NULL)
				return ((nvp_header_t *)pair);

				xdr.xdr_idx = pair + encoded_size;
				nvh = (nvp_header_t *)xdr.xdr_idx;

				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);

				encoded_size = (unsigned )xdr.xdr_idx;
				xdr.xdr_idx += sizeof (unsigned);
				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);
				decoded_size = (unsigned )xdr.xdr_idx;
				xdr.xdr_idx += sizeof (unsigned);
				if (xdr.xdr_idx > xdr.xdr_buf + xdr.xdr_buf_size)
				return (NULL);

				if (encoded_size != 0 && decoded_size != 0) {
				return (nvh);
				}
				}
				return (NULL);
				}

	/*			/*
				* Calculate nvlist size by walking in memory data.
				*/
				static bool
				nvlist_size_native(xdr_t xdr, size_t size)
				{
				uint8_t *pair;
				unsigned encoded_size, decoded_size;

				xdr->xdr_idx += 2 * sizeof (unsigned);

				pair = xdr->xdr_idx;
				if (xdr->xdr_idx > xdr->xdr_buf + xdr->xdr_buf_size)
				return (false);

				encoded_size = (unsigned )xdr->xdr_idx;
				xdr->xdr_idx += sizeof (unsigned);
				if (xdr->xdr_idx > xdr->xdr_buf + xdr->xdr_buf_size)
				return (false);
				decoded_size = (unsigned )xdr->xdr_idx;
				xdr->xdr_idx += sizeof (unsigned);
				while (encoded_size && decoded_size) {
				xdr->xdr_idx = pair + encoded_size;
				pair = xdr->xdr_idx;
				if (xdr->xdr_idx > xdr->xdr_buf + xdr->xdr_buf_size)
				return (false);
				encoded_size = (unsigned )xdr->xdr_idx;
				xdr->xdr_idx += sizeof (unsigned);
				if (xdr->xdr_idx > xdr->xdr_buf + xdr->xdr_buf_size)
				return (false);
				decoded_size = (unsigned )xdr->xdr_idx;
				xdr->xdr_idx += sizeof (unsigned);
				}
				*size = xdr->xdr_idx - xdr->xdr_buf;

				return (true);
				}

				/*
				* Export nvlist to byte stream format.
				*/
				int
				nvlist_export(nvlist_t *nvl)
				{
				int rv;
				xdr_t xdr = {
				.xdr_op = XDR_OP_ENCODE,
				.xdr_putint = _putint,
				.xdr_putuint = _putuint,
				.xdr_buf = nvl->nv_data,
				.xdr_idx = nvl->nv_data,
				.xdr_buf_size = nvl->nv_size
				};

				if (nvl->nv_header.nvh_encoding != NV_ENCODE_XDR)
				return (ENOTSUP);

				nvl->nv_idx = nvl->nv_data;
				rv = nvlist_xdr_nvlist(&xdr, nvl);

				return (rv);
				}

				/*
	* Import nvlist from byte stream.			* Import nvlist from byte stream.
	* Determine the stream size and allocate private copy.			* Determine the stream size and allocate private copy.
	* Then translate the data.			* Then translate the data.
	*/			*/
	nvlist_t *			nvlist_t *
	nvlist_import(const uint8_t *stream, char encoding, char endian)			nvlist_import(const char *stream, size_t size)
	{			{
	nvlist_t *nvl;			nvlist_t *nvl;
				xdr_t xdr = {
				.xdr_op = XDR_OP_DECODE,
				.xdr_getint = _getint,
				.xdr_getuint = _getuint
				};

	if (encoding != NV_ENCODE_XDR)			/* Check the nvlist head. */
				if (stream[0] != NV_ENCODE_XDR \|\|
				(stream[1] != '\0' && stream[1] != '\1') \|\|
				stream[2] != '\0' \|\| stream[3] != '\0' \|\|
				be32toh((uint32_t )(stream + 4)) != NV_VERSION \|\|
				be32toh((uint32_t )(stream + 8)) != NV_UNIQUE_NAME)
	return (NULL);			return (NULL);

	nvl = malloc(sizeof(*nvl));			nvl = malloc(sizeof (*nvl));
	if (nvl == NULL)			if (nvl == NULL)
	return (nvl);			return (nvl);

	nvl->nv_asize = nvl->nv_size = nvlist_size(&ntoh, stream);			nvl->nv_header.nvh_encoding = stream[0];
				nvl->nv_header.nvh_endian = stream[1];
				nvl->nv_header.nvh_reserved1 = stream[2];
				nvl->nv_header.nvh_reserved2 = stream[3];

				xdr.xdr_buf = xdr.xdr_idx = (uint8_t *)stream + 4;
				xdr.xdr_buf_size = size - 4;

				if (!nvlist_size_xdr(&xdr, &nvl->nv_asize)) {
				free(nvl);
				return (NULL);
				}
				nvl->nv_size = nvl->nv_asize;
	nvl->nv_data = malloc(nvl->nv_asize);			nvl->nv_data = malloc(nvl->nv_asize);
	if (nvl->nv_data == NULL) {			if (nvl->nv_data == NULL) {
	free(nvl);			free(nvl);
	return (NULL);			return (NULL);
	}			}
	nvl->nv_idx = nvl->nv_data;			nvl->nv_idx = nvl->nv_data;
	bcopy(stream, nvl->nv_data, nvl->nv_asize);			bcopy(stream + 4, nvl->nv_data, nvl->nv_asize);

	nvlist_decode_nvlist(&ntoh, nvl);			xdr.xdr_buf = xdr.xdr_idx = nvl->nv_data;
	nvl->nv_idx = nvl->nv_data;			xdr.xdr_buf_size = nvl->nv_asize;

				if (nvlist_xdr_nvlist(&xdr, nvl) != 0) {
				free(nvl->nv_data);
				free(nvl);
				nvl = NULL;
				}

	return (nvl);			return (nvl);
	}			}

	/*			/*
	* remove pair from this nvlist.			* remove pair from this nvlist.
	*/			*/
	int			int
	nvlist_remove(nvlist_t nvl, const char name, data_type_t type)			nvlist_remove(nvlist_t nvl, const char name, data_type_t type)
	{			{
	uint8_t head, tail;			uint8_t head, tail;
	nvs_data_t *data;			nvs_data_t *data;
	nvp_header_t *nvp;			nvp_header_t *nvp;
	nv_string_t *nvp_name;			nv_string_t *nvp_name;
	nv_pair_data_t *nvp_data;			nv_pair_data_t *nvp_data;
	size_t size;			size_t size;
				xdr_t xdr;

	if (nvl == NULL \|\| nvl->nv_data == NULL \|\| name == NULL)			if (nvl == NULL \|\| nvl->nv_data == NULL \|\| name == NULL)
	return (EINVAL);			return (EINVAL);

	head = nvl->nv_data;			/* Make sure the nvlist size is set correct */
	data = (nvs_data_t *)head;			xdr.xdr_idx = nvl->nv_data;
				xdr.xdr_buf = xdr.xdr_idx;
				xdr.xdr_buf_size = nvl->nv_size;
				if (!nvlist_size_native(&xdr, &nvl->nv_size))
				return (EINVAL);

				data = (nvs_data_t *)nvl->nv_data;
	nvp = &data->nvl_pair; /* first pair in nvlist */			nvp = &data->nvl_pair; /* first pair in nvlist */
	head = (uint8_t *)nvp;			head = (uint8_t *)nvp;

	while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {			while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {
	nvp_name = (nv_string_t )(head + sizeof(nvp));			nvp_name = (nv_string_t *)(nvp + 1);

	nvp_data = (nv_pair_data_t *)			nvp_data = (nv_pair_data_t *)(&nvp_name->nv_data[0] +
	NV_ALIGN4((uintptr_t)&nvp_name->nv_data[0] +			NV_ALIGN4(nvp_name->nv_size));
	nvp_name->nv_size);

	if (memcmp(nvp_name->nv_data, name, nvp_name->nv_size) == 0 &&			if (strlen(name) == nvp_name->nv_size &&
	nvp_data->nv_type == type) {			memcmp(nvp_name->nv_data, name, nvp_name->nv_size) == 0 &&
				(nvp_data->nv_type == type \|\| type == DATA_TYPE_UNKNOWN)) {
	/*			/*
	* set tail to point to next nvpair and size			* set tail to point to next nvpair and size
	* is the length of the tail.			* is the length of the tail.
	*/			*/
	tail = head + nvp->encoded_size;			tail = head + nvp->encoded_size;
	size = nvl->nv_data + nvl->nv_size - tail;			size = nvl->nv_size - (tail - nvl->nv_data);

	/* adjust the size of the nvlist. */			/* adjust the size of the nvlist. */
	nvl->nv_size -= nvp->encoded_size;			nvl->nv_size -= nvp->encoded_size;
	bcopy(tail, head, size);			bcopy(tail, head, size);
	return (0);			return (0);
	}			}
	/* Not our pair, skip to next. */			/* Not our pair, skip to next. */
	head = head + nvp->encoded_size;			head = head + nvp->encoded_size;
	nvp = (nvp_header_t *)head;			nvp = (nvp_header_t *)head;
	}			}
	return (ENOENT);			return (ENOENT);
	}			}

				static int
				clone_nvlist(const nvlist_t nvl, const uint8_t ptr, unsigned size,
				nvlist_t **nvlist)
				{
				nvlist_t *nv;

				nv = calloc(1, sizeof (*nv));
				if (nv == NULL)
				return (ENOMEM);

				nv->nv_header = nvl->nv_header;
				nv->nv_asize = size;
				nv->nv_size = size;
				nv->nv_data = malloc(nv->nv_asize);
				if (nv->nv_data == NULL) {
				free(nv);
				return (ENOMEM);
				}

				bcopy(ptr, nv->nv_data, nv->nv_asize);
				*nvlist = nv;
				return (0);
				}

				/*
				* Return the next nvlist in an nvlist array.
				*/
				static uint8_t *
				nvlist_next(const uint8_t *ptr)
				{
				nvs_data_t *data;
				nvp_header_t *nvp;

				data = (nvs_data_t *)ptr;
				nvp = &data->nvl_pair; /* first pair in nvlist */

				while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {
				nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);
				}
				return ((uint8_t )nvp + sizeof (nvp));
				}

				/*
				* Note: nvlist and nvlist array must be freed by caller.
				*/
	int			int
	nvlist_find(const nvlist_t nvl, const char name, data_type_t type,			nvlist_find(const nvlist_t nvl, const char name, data_type_t type,
	int elementsp, void valuep, int *sizep)			int elementsp, void valuep, int *sizep)
	{			{
	nvs_data_t *data;			nvs_data_t *data;
	nvp_header_t *nvp;			nvp_header_t *nvp;
	nv_string_t *nvp_name;			nv_string_t *nvp_name;
	nv_pair_data_t *nvp_data;			nv_pair_data_t *nvp_data;
	nvlist_t *nvlist;			nvlist_t *nvlist, nv;
				uint8_t *ptr;
				int rv;

	if (nvl == NULL \|\| nvl->nv_data == NULL \|\| name == NULL)			if (nvl == NULL \|\| nvl->nv_data == NULL \|\| name == NULL)
	return (EINVAL);			return (EINVAL);

	data = (nvs_data_t *)nvl->nv_data;			data = (nvs_data_t *)nvl->nv_data;
	nvp = &data->nvl_pair; /* first pair in nvlist */			nvp = &data->nvl_pair; /* first pair in nvlist */

	while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {			while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {
	nvp_name = (nv_string_t )((uint8_t )nvp + sizeof(*nvp));			nvp_name = (nv_string_t )((uint8_t )nvp + sizeof (*nvp));
				if (nvl->nv_data + nvl->nv_size <
				nvp_name->nv_data + nvp_name->nv_size)
				return (EIO);

	nvp_data = (nv_pair_data_t *)			nvp_data = (nv_pair_data_t *)
	NV_ALIGN4((uintptr_t)&nvp_name->nv_data[0] +			NV_ALIGN4((uintptr_t)&nvp_name->nv_data[0] +
	nvp_name->nv_size);			nvp_name->nv_size);

	if (memcmp(nvp_name->nv_data, name, nvp_name->nv_size) == 0 &&			if (strlen(name) == nvp_name->nv_size &&
	nvp_data->nv_type == type) {			memcmp(nvp_name->nv_data, name, nvp_name->nv_size) == 0 &&
				(nvp_data->nv_type == type \|\| type == DATA_TYPE_UNKNOWN)) {
	if (elementsp != NULL)			if (elementsp != NULL)
	*elementsp = nvp_data->nv_nelem;			*elementsp = nvp_data->nv_nelem;
	switch (nvp_data->nv_type) {			switch (nvp_data->nv_type) {
	case DATA_TYPE_UINT64:			case DATA_TYPE_UINT64:
	(uint64_t )valuep =			(uint64_t )valuep =
	(uint64_t )nvp_data->nv_data;			(uint64_t )nvp_data->nv_data;
	return (0);			return (0);
	case DATA_TYPE_STRING:			case DATA_TYPE_STRING:
	nvp_name = (nv_string_t *)nvp_data->nv_data;			nvp_name = (nv_string_t *)nvp_data->nv_data;
	if (sizep != NULL) {			if (sizep != NULL) {
	*sizep = nvp_name->nv_size;			*sizep = nvp_name->nv_size;
	}			}
	(const uint8_t *)valuep =			(const uint8_t *)valuep =
	&nvp_name->nv_data[0];			&nvp_name->nv_data[0];
	return (0);			return (0);
	case DATA_TYPE_NVLIST:			case DATA_TYPE_NVLIST:
	case DATA_TYPE_NVLIST_ARRAY:			ptr = &nvp_data->nv_data[0];
	nvlist = malloc(sizeof(*nvlist));			rv = clone_nvlist(nvl, ptr,
	if (nvlist != NULL) {			nvlist_next(ptr) - ptr, &nv);
	nvlist->nv_header = nvl->nv_header;			if (rv == 0) {
	nvlist->nv_asize = 0;			(nvlist_t *)valuep = nv;
	nvlist->nv_size = 0;
	nvlist->nv_idx = NULL;
	nvlist->nv_data = &nvp_data->nv_data[0];
	(nvlist_t *)valuep = nvlist;
	return (0);
	}			}
				return (rv);

				case DATA_TYPE_NVLIST_ARRAY:
				nvlist = calloc(nvp_data->nv_nelem,
				sizeof (nvlist_t *));
				if (nvlist == NULL)
	return (ENOMEM);			return (ENOMEM);
				ptr = &nvp_data->nv_data[0];
				rv = 0;
				for (unsigned i = 0; i < nvp_data->nv_nelem;
				i++) {
				rv = clone_nvlist(nvl, ptr,
				nvlist_next(ptr) - ptr, &nvlist[i]);
				if (rv != 0)
				goto error;
				ptr = nvlist_next(ptr);
	}			}
				(nvlist_t **)valuep = nvlist;
				return (rv);
				}
	return (EIO);			return (EIO);
	}			}
	/* Not our pair, skip to next. */			/* Not our pair, skip to next. */
	nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);			nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);
				if (nvl->nv_data + nvl->nv_size < (uint8_t *)nvp)
				return (EIO);
	}			}
	return (ENOENT);			return (ENOENT);
				error:
				for (unsigned i = 0; i < nvp_data->nv_nelem; i++) {
				free(nvlist[i]->nv_data);
				free(nvlist[i]);
	}			}
				free(nvlist);
				return (rv);
				}

				static int
				get_value_size(data_type_t type, const void *data, uint32_t nelem)
				{
				uint64_t value_sz = 0;

				switch (type) {
				case DATA_TYPE_BOOLEAN:
				value_sz = 0;
				break;
				case DATA_TYPE_BOOLEAN_VALUE:
				case DATA_TYPE_BYTE:
				case DATA_TYPE_INT8:
				case DATA_TYPE_UINT8:
				case DATA_TYPE_INT16:
				case DATA_TYPE_UINT16:
				case DATA_TYPE_INT32:
				case DATA_TYPE_UINT32:
				/* Our smallest data unit is 32-bit */
				value_sz = sizeof (uint32_t);
				break;
				case DATA_TYPE_HRTIME:
				case DATA_TYPE_INT64:
				value_sz = sizeof (int64_t);
				break;
				case DATA_TYPE_UINT64:
				value_sz = sizeof (uint64_t);
				break;
				case DATA_TYPE_STRING:
				if (data == NULL)
				value_sz = 0;
				else
				value_sz = strlen(data) + 1;
				break;
				case DATA_TYPE_BYTE_ARRAY:
				value_sz = nelem * sizeof (uint8_t);
				break;
				case DATA_TYPE_BOOLEAN_ARRAY:
				case DATA_TYPE_INT8_ARRAY:
				case DATA_TYPE_UINT8_ARRAY:
				case DATA_TYPE_INT16_ARRAY:
				case DATA_TYPE_UINT16_ARRAY:
				case DATA_TYPE_INT32_ARRAY:
				case DATA_TYPE_UINT32_ARRAY:
				value_sz = (uint64_t)nelem * sizeof (uint32_t);
				break;
				case DATA_TYPE_INT64_ARRAY:
				value_sz = (uint64_t)nelem * sizeof (int64_t);
				break;
				case DATA_TYPE_UINT64_ARRAY:
				value_sz = (uint64_t)nelem * sizeof (uint64_t);
				break;
				case DATA_TYPE_STRING_ARRAY:
				value_sz = (uint64_t)nelem * sizeof (uint64_t);

				if (data != NULL) {
				char const strs = data;
				uint32_t i;

				for (i = 0; i < nelem; i++) {
				if (strs[i] == NULL)
				return (-1);
				value_sz += strlen(strs[i]) + 1;
				}
				}
				break;
				case DATA_TYPE_NVLIST:
	/*			/*
	* Return the next nvlist in an nvlist array.			* The decoded size of nvlist is constant.
	*/			*/
	int			value_sz = NV_ALIGN(6 * 4); /* sizeof nvlist_t */
	nvlist_next(nvlist_t *nvl)			break;
				case DATA_TYPE_NVLIST_ARRAY:
				value_sz = (uint64_t)nelem * sizeof (uint64_t) +
				(uint64_t)nelem * NV_ALIGN(6 * 4); /* sizeof nvlist_t */
				break;
				default:
				return (-1);
				}

				return (value_sz > INT32_MAX ? -1 : (int)value_sz);
				}

				static int
				get_nvp_data_size(data_type_t type, const void *data, uint32_t nelem)
	{			{
	nvs_data_t *data;			uint64_t value_sz = 0;
	nvp_header_t *nvp;			xdr_t xdr;
				size_t size;

	if (nvl == NULL \|\| nvl->nv_data == NULL \|\| nvl->nv_asize != 0)			switch (type) {
				case DATA_TYPE_BOOLEAN:
				value_sz = 0;
				break;
				case DATA_TYPE_BOOLEAN_VALUE:
				case DATA_TYPE_BYTE:
				case DATA_TYPE_INT8:
				case DATA_TYPE_UINT8:
				case DATA_TYPE_INT16:
				case DATA_TYPE_UINT16:
				case DATA_TYPE_INT32:
				case DATA_TYPE_UINT32:
				/* Our smallest data unit is 32-bit */
				value_sz = sizeof (uint32_t);
				break;
				case DATA_TYPE_HRTIME:
				case DATA_TYPE_INT64:
				case DATA_TYPE_UINT64:
				value_sz = sizeof (uint64_t);
				break;
				case DATA_TYPE_STRING:
				value_sz = 4 + NV_ALIGN4(strlen(data));
				break;
				case DATA_TYPE_BYTE_ARRAY:
				value_sz = NV_ALIGN4(nelem);
				break;
				case DATA_TYPE_BOOLEAN_ARRAY:
				case DATA_TYPE_INT8_ARRAY:
				case DATA_TYPE_UINT8_ARRAY:
				case DATA_TYPE_INT16_ARRAY:
				case DATA_TYPE_UINT16_ARRAY:
				case DATA_TYPE_INT32_ARRAY:
				case DATA_TYPE_UINT32_ARRAY:
				value_sz = 4 + (uint64_t)nelem * sizeof (uint32_t);
				break;
				case DATA_TYPE_INT64_ARRAY:
				case DATA_TYPE_UINT64_ARRAY:
				value_sz = 4 + (uint64_t)nelem * sizeof (uint64_t);
				break;
				case DATA_TYPE_STRING_ARRAY:
				if (data != NULL) {
				char const strs = data;
				uint32_t i;

				for (i = 0; i < nelem; i++) {
				value_sz += 4 + NV_ALIGN4(strlen(strs[i]));
				}
				}
				break;
				case DATA_TYPE_NVLIST:
				xdr.xdr_idx = ((nvlist_t *)data)->nv_data;
				xdr.xdr_buf = xdr.xdr_idx;
				xdr.xdr_buf_size = ((nvlist_t *)data)->nv_size;

				if (!nvlist_size_native(&xdr, &size))
				return (-1);

				value_sz = size;
				break;
				case DATA_TYPE_NVLIST_ARRAY:
				value_sz = 0;
				for (uint32_t i = 0; i < nelem; i++) {
				xdr.xdr_idx = ((nvlist_t **)data)[i]->nv_data;
				xdr.xdr_buf = xdr.xdr_idx;
				xdr.xdr_buf_size = ((nvlist_t **)data)[i]->nv_size;

				if (!nvlist_size_native(&xdr, &size))
				return (-1);
				value_sz += size;
				}
				break;
				default:
				return (-1);
				}

				return (value_sz > INT32_MAX ? -1 : (int)value_sz);
				}

				#define NVPE_SIZE(name_len, data_len) \
				(4 + 4 + 4 + NV_ALIGN4(name_len) + 4 + 4 + data_len)
				#define NVP_SIZE(name_len, data_len) \
				(NV_ALIGN((4 * 4) + (name_len)) + NV_ALIGN(data_len))

				static int
				nvlist_add_common(nvlist_t nvl, const char name, data_type_t type,
				uint32_t nelem, const void *data)
				{
				nvs_data_t *nvs;
				nvp_header_t head, *hp;
				uint8_t *ptr;
				size_t namelen;
				int decoded_size, encoded_size;
				xdr_t xdr;

				nvs = (nvs_data_t *)nvl->nv_data;
				if (nvs->nvl_nvflag & NV_UNIQUE_NAME)
				(void) nvlist_remove(nvl, name, type);

				xdr.xdr_buf = nvl->nv_data;
				xdr.xdr_idx = nvl->nv_data;
				xdr.xdr_buf_size = nvl->nv_size;
				if (!nvlist_size_native(&xdr, &nvl->nv_size))
	return (EINVAL);			return (EINVAL);

	data = (nvs_data_t *)nvl->nv_data;			namelen = strlen(name);
	nvp = &data->nvl_pair; /* first pair in nvlist */			if ((decoded_size = get_value_size(type, data, nelem)) < 0)
				return (EINVAL);
				if ((encoded_size = get_nvp_data_size(type, data, nelem)) < 0)
				return (EINVAL);

	while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {			/*
	nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);			* The encoded size is calculated as:
				* encode_size (4) + decode_size (4) +
				* name string size (4 + NV_ALIGN4(namelen) +
				* data type (4) + nelem size (4) + datalen
				*
				* The decoded size is calculated as:
				* Note: namelen is with terminating 0.
				* NV_ALIGN(sizeof (nvpair_t) (4 * 4) + namelen + 1) +
				* NV_ALIGN(data_len)
				*/

				head.encoded_size = NVPE_SIZE(namelen, encoded_size);
				head.decoded_size = NVP_SIZE(namelen + 1, decoded_size);

				if (nvl->nv_asize - nvl->nv_size < head.encoded_size + 8) {
				ptr = realloc(nvl->nv_data, nvl->nv_asize + head.encoded_size);
				if (ptr == NULL)
				return (ENOMEM);
				nvl->nv_data = ptr;
				nvl->nv_asize += head.encoded_size;
	}			}
	nvl->nv_data = (uint8_t )nvp + sizeof(nvp);			nvl->nv_idx = nvl->nv_data + nvl->nv_size - sizeof (*hp);
				bzero(nvl->nv_idx, head.encoded_size + 8);
				hp = (nvp_header_t *)nvl->nv_idx;
				*hp = head;
				nvl->nv_idx += sizeof (*hp);
				(unsigned )nvl->nv_idx = namelen;
				nvl->nv_idx += sizeof (unsigned);
				strlcpy((char *)nvl->nv_idx, name, namelen + 1);
				nvl->nv_idx += NV_ALIGN4(namelen);
				(unsigned )nvl->nv_idx = type;
				nvl->nv_idx += sizeof (unsigned);
				(unsigned )nvl->nv_idx = nelem;
				nvl->nv_idx += sizeof (unsigned);

				switch (type) {
				case DATA_TYPE_BOOLEAN:
				break;
				case DATA_TYPE_BYTE_ARRAY:
				(unsigned )nvl->nv_idx = encoded_size;
				nvl->nv_idx += sizeof (unsigned);
				bcopy(data, nvl->nv_idx, nelem);
				nvl->nv_idx += encoded_size;
				break;
				case DATA_TYPE_STRING:
				encoded_size = strlen(data);
				(unsigned )nvl->nv_idx = encoded_size;
				nvl->nv_idx += sizeof (unsigned);
				strlcpy((char *)nvl->nv_idx, data, encoded_size + 1);
				nvl->nv_idx += NV_ALIGN4(encoded_size);
				break;
				case DATA_TYPE_STRING_ARRAY:
				for (uint32_t i = 0; i < nelem; i++) {
				encoded_size = strlen(((char **)data)[i]);
				(unsigned )nvl->nv_idx = encoded_size;
				nvl->nv_idx += sizeof (unsigned);
				strlcpy((char )nvl->nv_idx, ((char *)data)[i],
				encoded_size + 1);
				nvl->nv_idx += NV_ALIGN4(encoded_size);
				}
				break;
				case DATA_TYPE_BYTE:
				case DATA_TYPE_INT8:
				case DATA_TYPE_UINT8:
				case DATA_TYPE_INT8_ARRAY:
				case DATA_TYPE_UINT8_ARRAY:
				for (uint32_t i = 0; i < nelem; i++) {
				(unsigned )nvl->nv_idx = ((uint8_t *)data)[i];
				nvl->nv_idx += sizeof (unsigned);
				}
				break;
				case DATA_TYPE_INT16:
				case DATA_TYPE_UINT16:
				case DATA_TYPE_INT16_ARRAY:
				case DATA_TYPE_UINT16_ARRAY:
				for (uint32_t i = 0; i < nelem; i++) {
				(unsigned )nvl->nv_idx = ((uint16_t *)data)[i];
				nvl->nv_idx += sizeof (unsigned);
				}
				break;
				case DATA_TYPE_NVLIST:
				bcopy(((nvlist_t *)data)->nv_data, nvl->nv_idx, encoded_size);
				break;
				case DATA_TYPE_NVLIST_ARRAY: {
				uint8_t *buf = nvl->nv_idx;
				size_t size;
				xdr_t xdr;

				for (uint32_t i = 0; i < nelem; i++) {
				xdr.xdr_idx = ((nvlist_t **)data)[i]->nv_data;
				xdr.xdr_buf = xdr.xdr_idx;
				xdr.xdr_buf_size = ((nvlist_t **)data)[i]->nv_size;

				if (!nvlist_size_native(&xdr, &size))
				return (EINVAL);

				bcopy(((nvlist_t **)data)[i]->nv_data, buf, size);
				buf += size;
				}
				break;
				}
				default:
				bcopy(data, nvl->nv_idx, encoded_size);
				}

				nvl->nv_size += head.encoded_size;

	return (0);			return (0);
	}			}

	void			int
	nvlist_print(nvlist_t *nvl, unsigned int indent)			nvlist_add_boolean(nvlist_t nvl, const char name)
	{			{
				return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN, 0, NULL));
				}

				int
				nvlist_add_boolean_value(nvlist_t nvl, const char name, boolean_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_VALUE, 1,
				&value));
				}

				int
				nvlist_add_byte(nvlist_t nvl, const char name, uint8_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE, 1, &value));
				}

				int
				nvlist_add_int8(nvlist_t nvl, const char name, int8_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT8, 1, &value));
				}

				int
				nvlist_add_uint8(nvlist_t nvl, const char name, uint8_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8, 1, &value));
				}

				int
				nvlist_add_int16(nvlist_t nvl, const char name, int16_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT16, 1, &value));
				}

				int
				nvlist_add_uint16(nvlist_t nvl, const char name, uint16_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16, 1, &value));
				}

				int
				nvlist_add_int32(nvlist_t nvl, const char name, int32_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT32, 1, &value));
				}

				int
				nvlist_add_uint32(nvlist_t nvl, const char name, uint32_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32, 1, &value));
				}

				int
				nvlist_add_int64(nvlist_t nvl, const char name, int64_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT64, 1, &value));
				}

				int
				nvlist_add_uint64(nvlist_t nvl, const char name, uint64_t value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64, 1, &value));
				}

				int
				nvlist_add_string(nvlist_t nvl, const char name, const char *value)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_STRING, 1, value));
				}

				int
				nvlist_add_boolean_array(nvlist_t nvl, const char name,
				boolean_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_BOOLEAN_ARRAY, n, a));
				}

				int
				nvlist_add_byte_array(nvlist_t nvl, const char name, uint8_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_BYTE_ARRAY, n, a));
				}

				int
				nvlist_add_int8_array(nvlist_t nvl, const char name, int8_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT8_ARRAY, n, a));
				}

				int
				nvlist_add_uint8_array(nvlist_t nvl, const char name, uint8_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT8_ARRAY, n, a));
				}

				int
				nvlist_add_int16_array(nvlist_t nvl, const char name, int16_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT16_ARRAY, n, a));
				}

				int
				nvlist_add_uint16_array(nvlist_t nvl, const char name, uint16_t *a,
				uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT16_ARRAY, n, a));
				}

				int
				nvlist_add_int32_array(nvlist_t nvl, const char name, int32_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT32_ARRAY, n, a));
				}

				int
				nvlist_add_uint32_array(nvlist_t nvl, const char name, uint32_t *a,
				uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT32_ARRAY, n, a));
				}

				int
				nvlist_add_int64_array(nvlist_t nvl, const char name, int64_t *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_INT64_ARRAY, n, a));
				}

				int
				nvlist_add_uint64_array(nvlist_t nvl, const char name, uint64_t *a,
				uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_UINT64_ARRAY, n, a));
				}

				int
				nvlist_add_string_array(nvlist_t nvl, const char name,
				char * const *a, uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_STRING_ARRAY, n, a));
				}

				int
				nvlist_add_nvlist(nvlist_t nvl, const char name, nvlist_t *val)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST, 1, val));
				}

				int
				nvlist_add_nvlist_array(nvlist_t nvl, const char name, nvlist_t **a,
				uint32_t n)
				{
				return (nvlist_add_common(nvl, name, DATA_TYPE_NVLIST_ARRAY, n, a));
				}

	static const char *typenames[] = {			static const char *typenames[] = {
	"DATA_TYPE_UNKNOWN",			"DATA_TYPE_UNKNOWN",
	"DATA_TYPE_BOOLEAN",			"DATA_TYPE_BOOLEAN",
	"DATA_TYPE_BYTE",			"DATA_TYPE_BYTE",
	"DATA_TYPE_INT16",			"DATA_TYPE_INT16",
	"DATA_TYPE_UINT16",			"DATA_TYPE_UINT16",
	"DATA_TYPE_INT32",			"DATA_TYPE_INT32",
	"DATA_TYPE_UINT32",			"DATA_TYPE_UINT32",
	"DATA_TYPE_INT64",			"DATA_TYPE_INT64",
	"DATA_TYPE_UINT64",			"DATA_TYPE_UINT64",
	"DATA_TYPE_STRING",			"DATA_TYPE_STRING",
	"DATA_TYPE_BYTE_ARRAY",			"DATA_TYPE_BYTE_ARRAY",
	"DATA_TYPE_INT16_ARRAY",			"DATA_TYPE_INT16_ARRAY",
	"DATA_TYPE_UINT16_ARRAY",			"DATA_TYPE_UINT16_ARRAY",
	"DATA_TYPE_INT32_ARRAY",			"DATA_TYPE_INT32_ARRAY",
	"DATA_TYPE_UINT32_ARRAY",			"DATA_TYPE_UINT32_ARRAY",
	"DATA_TYPE_INT64_ARRAY",			"DATA_TYPE_INT64_ARRAY",
	"DATA_TYPE_UINT64_ARRAY",			"DATA_TYPE_UINT64_ARRAY",
	"DATA_TYPE_STRING_ARRAY",			"DATA_TYPE_STRING_ARRAY",
	"DATA_TYPE_HRTIME",			"DATA_TYPE_HRTIME",
	"DATA_TYPE_NVLIST",			"DATA_TYPE_NVLIST",
	"DATA_TYPE_NVLIST_ARRAY",			"DATA_TYPE_NVLIST_ARRAY",
	"DATA_TYPE_BOOLEAN_VALUE",			"DATA_TYPE_BOOLEAN_VALUE",
	"DATA_TYPE_INT8",			"DATA_TYPE_INT8",
	"DATA_TYPE_UINT8",			"DATA_TYPE_UINT8",
	"DATA_TYPE_BOOLEAN_ARRAY",			"DATA_TYPE_BOOLEAN_ARRAY",
	"DATA_TYPE_INT8_ARRAY",			"DATA_TYPE_INT8_ARRAY",
	"DATA_TYPE_UINT8_ARRAY"			"DATA_TYPE_UINT8_ARRAY"
	};			};
	nvs_data_t *data;
	nvp_header_t *nvp;			void
				nvpair_print(nvp_header_t *nvp, unsigned int indent)
				{
	nv_string_t *nvp_name;			nv_string_t *nvp_name;
	nv_pair_data_t *nvp_data;			nv_pair_data_t *nvp_data;
	nvlist_t nvlist;			nvlist_t nvlist;
	int i, j;			xdr_t xdr;
				unsigned i, j;

	data = (nvs_data_t *)nvl->nv_data;
	nvp = &data->nvl_pair; /* first pair in nvlist */
	while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {
	nvp_name = (nv_string_t )((uintptr_t)nvp + sizeof(nvp));			nvp_name = (nv_string_t )((uintptr_t)nvp + sizeof (nvp));
	nvp_data = (nv_pair_data_t *)			nvp_data = (nv_pair_data_t *)
	NV_ALIGN4((uintptr_t)&nvp_name->nv_data[0] +			NV_ALIGN4((uintptr_t)&nvp_name->nv_data[0] + nvp_name->nv_size);
	nvp_name->nv_size);

	for (int i = 0; i < indent; i++)			for (i = 0; i < indent; i++)
	printf(" ");			printf(" ");

	printf("%s [%d] %.*s", typenames[nvp_data->nv_type],			printf("%s [%d] %.*s", typenames[nvp_data->nv_type],
	nvp_data->nv_nelem, nvp_name->nv_size, nvp_name->nv_data);			nvp_data->nv_nelem, nvp_name->nv_size, nvp_name->nv_data);

	switch (nvp_data->nv_type) {			switch (nvp_data->nv_type) {
	case DATA_TYPE_UINT64: {			case DATA_TYPE_UINT64: {
	uint64_t val;			uint64_t val;

	val = (uint64_t )nvp_data->nv_data;			val = (uint64_t )nvp_data->nv_data;
	printf(" = 0x%jx\n", (uintmax_t)val);			printf(" = 0x%jx\n", (uintmax_t)val);
	break;			break;
	}			}

	case DATA_TYPE_STRING: {			case DATA_TYPE_STRING:
				case DATA_TYPE_STRING_ARRAY:
	nvp_name = (nv_string_t *)&nvp_data->nv_data[0];			nvp_name = (nv_string_t *)&nvp_data->nv_data[0];
				for (i = 0; i < nvp_data->nv_nelem; i++) {
	printf(" = \"%.*s\"\n", nvp_name->nv_size,			printf(" = \"%.*s\"\n", nvp_name->nv_size,
	nvp_name->nv_data );			nvp_name->nv_data);
	break;
	}			}
				break;

	case DATA_TYPE_NVLIST:			case DATA_TYPE_NVLIST:
	printf("\n");			printf("\n");
	nvlist.nv_data = &nvp_data->nv_data[0];			nvlist.nv_data = &nvp_data->nv_data[0];
	nvlist_print(&nvlist, indent + 2);			nvlist_print(&nvlist, indent + 2);
	break;			break;

	case DATA_TYPE_NVLIST_ARRAY:			case DATA_TYPE_NVLIST_ARRAY:
	nvlist.nv_data = &nvp_data->nv_data[0];			nvlist.nv_data = &nvp_data->nv_data[0];
	for (j = 0; j < nvp_data->nv_nelem; j++) {			for (j = 0; j < nvp_data->nv_nelem; j++) {
	data = (nvs_data_t *)nvlist.nv_data;			size_t size;

	printf("[%d]\n", j);			printf("[%d]\n", j);
	nvlist_print(&nvlist, indent + 2);			nvlist_print(&nvlist, indent + 2);
	if (j != nvp_data->nv_nelem - 1) {			if (j != nvp_data->nv_nelem - 1) {
	for (i = 0; i < indent; i++)			for (i = 0; i < indent; i++)
	printf(" ");			printf(" ");
	printf("%s %.*s",			printf("%s %.*s",
	typenames[nvp_data->nv_type],			typenames[nvp_data->nv_type],
	nvp_name->nv_size,			nvp_name->nv_size,
	nvp_name->nv_data);			nvp_name->nv_data);
	}			}
	nvlist.nv_data = (uint8_t *)data +			xdr.xdr_idx = nvlist.nv_data;
	nvlist_size(&native, nvlist.nv_data);			xdr.xdr_buf = xdr.xdr_idx;
				xdr.xdr_buf_size = nvp->encoded_size -
				(xdr.xdr_idx - (uint8_t *)nvp);

				if (!nvlist_size_native(&xdr, &size))
				return;

				nvlist.nv_data += size;
	}			}
	break;			break;

	default:			default:
	printf("\n");			printf("\n");
	}			}
				}

				void
				nvlist_print(const nvlist_t *nvl, unsigned int indent)
				{
				nvs_data_t *data;
				nvp_header_t *nvp;

				data = (nvs_data_t *)nvl->nv_data;
				nvp = &data->nvl_pair; /* first pair in nvlist */
				while (nvp->encoded_size != 0 && nvp->decoded_size != 0) {
				nvpair_print(nvp, indent);
	nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);			nvp = (nvp_header_t )((uint8_t )nvp + nvp->encoded_size);
	}			}
	printf("%*s\n", indent + 13, "End of nvlist");			printf("%*s\n", indent + 13, "End of nvlist");
	}			}