[mirror_zfs.git] / module / nvpair / fnvpair.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or https://opensource.org/licenses/CDDL-1.0.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2012, 2018 by Delphix. All rights reserved.
 */

#include <sys/nvpair.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/param.h>
#ifndef _KERNEL
#include <stdlib.h>
#endif

/*
 * "Force" nvlist wrapper.
 *
 * These functions wrap the nvlist_* functions with assertions that assume
 * the operation is successful.  This allows the caller's code to be much
 * more readable, especially for the fnvlist_lookup_* and fnvpair_value_*
 * functions, which can return the requested value (rather than filling in
 * a pointer).
 *
 * These functions use NV_UNIQUE_NAME, encoding NV_ENCODE_NATIVE, and allocate
 * with KM_SLEEP.
 *
 * More wrappers should be added as needed -- for example
 * nvlist_lookup_*_array and nvpair_value_*_array.
 */

nvlist_t *
fnvlist_alloc(void)
{
	nvlist_t *nvl;
	VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
	return (nvl);
}

void
fnvlist_free(nvlist_t *nvl)
{
	nvlist_free(nvl);
}

size_t
fnvlist_size(nvlist_t *nvl)
{
	size_t size;
	VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
	return (size);
}

/*
 * Returns allocated buffer of size *sizep.  Caller must free the buffer with
 * fnvlist_pack_free().
 */
char *
fnvlist_pack(nvlist_t *nvl, size_t *sizep)
{
	char *packed = 0;
	VERIFY3U(nvlist_pack(nvl, &packed, sizep, NV_ENCODE_NATIVE,
	    KM_SLEEP), ==, 0);
	return (packed);
}

void
fnvlist_pack_free(char *pack, size_t size)
{
#ifdef _KERNEL
	kmem_free(pack, size);
#else
	(void) size;
	free(pack);
#endif
}

nvlist_t *
fnvlist_unpack(char *buf, size_t buflen)
{
	nvlist_t *rv;
	VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP));
	return (rv);
}

nvlist_t *
fnvlist_dup(const nvlist_t *nvl)
{
	nvlist_t *rv;
	VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
	return (rv);
}

void
fnvlist_merge(nvlist_t *dst, nvlist_t *src)
{
	VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
}

size_t
fnvlist_num_pairs(nvlist_t *nvl)
{
	size_t count = 0;
	nvpair_t *pair;

	for (pair = nvlist_next_nvpair(nvl, 0); pair != NULL;
	    pair = nvlist_next_nvpair(nvl, pair))
		count++;
	return (count);
}

void
fnvlist_add_boolean(nvlist_t *nvl, const char *name)
{
	VERIFY0(nvlist_add_boolean(nvl, name));
}

void
fnvlist_add_boolean_value(nvlist_t *nvl, const char *name, boolean_t val)
{
	VERIFY0(nvlist_add_boolean_value(nvl, name, val));
}

void
fnvlist_add_byte(nvlist_t *nvl, const char *name, uchar_t val)
{
	VERIFY0(nvlist_add_byte(nvl, name, val));
}

void
fnvlist_add_int8(nvlist_t *nvl, const char *name, int8_t val)
{
	VERIFY0(nvlist_add_int8(nvl, name, val));
}

void
fnvlist_add_uint8(nvlist_t *nvl, const char *name, uint8_t val)
{
	VERIFY0(nvlist_add_uint8(nvl, name, val));
}

void
fnvlist_add_int16(nvlist_t *nvl, const char *name, int16_t val)
{
	VERIFY0(nvlist_add_int16(nvl, name, val));
}

void
fnvlist_add_uint16(nvlist_t *nvl, const char *name, uint16_t val)
{
	VERIFY0(nvlist_add_uint16(nvl, name, val));
}

void
fnvlist_add_int32(nvlist_t *nvl, const char *name, int32_t val)
{
	VERIFY0(nvlist_add_int32(nvl, name, val));
}

void
fnvlist_add_uint32(nvlist_t *nvl, const char *name, uint32_t val)
{
	VERIFY0(nvlist_add_uint32(nvl, name, val));
}

void
fnvlist_add_int64(nvlist_t *nvl, const char *name, int64_t val)
{
	VERIFY0(nvlist_add_int64(nvl, name, val));
}

void
fnvlist_add_uint64(nvlist_t *nvl, const char *name, uint64_t val)
{
	VERIFY0(nvlist_add_uint64(nvl, name, val));
}

void
fnvlist_add_string(nvlist_t *nvl, const char *name, const char *val)
{
	VERIFY0(nvlist_add_string(nvl, name, val));
}

void
fnvlist_add_nvlist(nvlist_t *nvl, const char *name, nvlist_t *val)
{
	VERIFY0(nvlist_add_nvlist(nvl, name, val));
}

void
fnvlist_add_nvpair(nvlist_t *nvl, nvpair_t *pair)
{
	VERIFY0(nvlist_add_nvpair(nvl, pair));
}

void
fnvlist_add_boolean_array(nvlist_t *nvl, const char *name,
    const boolean_t *val, uint_t n)
{
	VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
}

void
fnvlist_add_byte_array(nvlist_t *nvl, const char *name, const uchar_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
}

void
fnvlist_add_int8_array(nvlist_t *nvl, const char *name, const int8_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
}

void
fnvlist_add_uint8_array(nvlist_t *nvl, const char *name, const uint8_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
}

void
fnvlist_add_int16_array(nvlist_t *nvl, const char *name, const int16_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
}

void
fnvlist_add_uint16_array(nvlist_t *nvl, const char *name,
    const uint16_t *val, uint_t n)
{
	VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
}

void
fnvlist_add_int32_array(nvlist_t *nvl, const char *name, const int32_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
}

void
fnvlist_add_uint32_array(nvlist_t *nvl, const char *name,
    const uint32_t *val, uint_t n)
{
	VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
}

void
fnvlist_add_int64_array(nvlist_t *nvl, const char *name, const int64_t *val,
    uint_t n)
{
	VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
}

void
fnvlist_add_uint64_array(nvlist_t *nvl, const char *name,
    const uint64_t *val, uint_t n)
{
	VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
}

void
fnvlist_add_string_array(nvlist_t *nvl, const char *name,
    const char * const *val, uint_t n)
{
	VERIFY0(nvlist_add_string_array(nvl, name, val, n));
}

void
fnvlist_add_nvlist_array(nvlist_t *nvl, const char *name,
    const nvlist_t * const *val, uint_t n)
{
	VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
}

void
fnvlist_remove(nvlist_t *nvl, const char *name)
{
	VERIFY0(nvlist_remove_all(nvl, name));
}

void
fnvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *pair)
{
	VERIFY0(nvlist_remove_nvpair(nvl, pair));
}

nvpair_t *
fnvlist_lookup_nvpair(nvlist_t *nvl, const char *name)
{
	nvpair_t *rv;
	VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
	return (rv);
}

/* returns B_TRUE if the entry exists */
boolean_t
fnvlist_lookup_boolean(const nvlist_t *nvl, const char *name)
{
	return (nvlist_lookup_boolean(nvl, name) == 0);
}

boolean_t
fnvlist_lookup_boolean_value(const nvlist_t *nvl, const char *name)
{
	boolean_t rv;
	VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
	return (rv);
}

uchar_t
fnvlist_lookup_byte(const nvlist_t *nvl, const char *name)
{
	uchar_t rv;
	VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
	return (rv);
}

int8_t
fnvlist_lookup_int8(const nvlist_t *nvl, const char *name)
{
	int8_t rv;
	VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
	return (rv);
}

int16_t
fnvlist_lookup_int16(const nvlist_t *nvl, const char *name)
{
	int16_t rv;
	VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
	return (rv);
}

int32_t
fnvlist_lookup_int32(const nvlist_t *nvl, const char *name)
{
	int32_t rv;
	VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
	return (rv);
}

int64_t
fnvlist_lookup_int64(const nvlist_t *nvl, const char *name)
{
	int64_t rv;
	VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
	return (rv);
}

uint8_t
fnvlist_lookup_uint8(const nvlist_t *nvl, const char *name)
{
	uint8_t rv;
	VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
	return (rv);
}

uint16_t
fnvlist_lookup_uint16(const nvlist_t *nvl, const char *name)
{
	uint16_t rv;
	VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
	return (rv);
}

uint32_t
fnvlist_lookup_uint32(const nvlist_t *nvl, const char *name)
{
	uint32_t rv;
	VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
	return (rv);
}

uint64_t
fnvlist_lookup_uint64(const nvlist_t *nvl, const char *name)
{
	uint64_t rv;
	VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
	return (rv);
}

const char *
fnvlist_lookup_string(const nvlist_t *nvl, const char *name)
{
	const char *rv;
	VERIFY0(nvlist_lookup_string(nvl, name, &rv));
	return (rv);
}

nvlist_t *
fnvlist_lookup_nvlist(nvlist_t *nvl, const char *name)
{
	nvlist_t *rv;
	VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
	return (rv);
}
boolean_t *
fnvlist_lookup_boolean_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	boolean_t *rv;
	VERIFY0(nvlist_lookup_boolean_array(nvl, name, &rv, n));
	return (rv);
}

uchar_t *
fnvlist_lookup_byte_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	uchar_t *rv;
	VERIFY0(nvlist_lookup_byte_array(nvl, name, &rv, n));
	return (rv);
}

int8_t *
fnvlist_lookup_int8_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	int8_t *rv;
	VERIFY0(nvlist_lookup_int8_array(nvl, name, &rv, n));
	return (rv);
}

uint8_t *
fnvlist_lookup_uint8_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	uint8_t *rv;
	VERIFY0(nvlist_lookup_uint8_array(nvl, name, &rv, n));
	return (rv);
}

int16_t *
fnvlist_lookup_int16_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	int16_t *rv;
	VERIFY0(nvlist_lookup_int16_array(nvl, name, &rv, n));
	return (rv);
}

uint16_t *
fnvlist_lookup_uint16_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	uint16_t *rv;
	VERIFY0(nvlist_lookup_uint16_array(nvl, name, &rv, n));
	return (rv);
}

int32_t *
fnvlist_lookup_int32_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	int32_t *rv;
	VERIFY0(nvlist_lookup_int32_array(nvl, name, &rv, n));
	return (rv);
}

uint32_t *
fnvlist_lookup_uint32_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	uint32_t *rv;
	VERIFY0(nvlist_lookup_uint32_array(nvl, name, &rv, n));
	return (rv);
}

int64_t *
fnvlist_lookup_int64_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	int64_t *rv;
	VERIFY0(nvlist_lookup_int64_array(nvl, name, &rv, n));
	return (rv);
}

uint64_t *
fnvlist_lookup_uint64_array(nvlist_t *nvl, const char *name, uint_t *n)
{
	uint64_t *rv;
	VERIFY0(nvlist_lookup_uint64_array(nvl, name, &rv, n));
	return (rv);
}

boolean_t
fnvpair_value_boolean_value(const nvpair_t *nvp)
{
	boolean_t rv;
	VERIFY0(nvpair_value_boolean_value(nvp, &rv));
	return (rv);
}

uchar_t
fnvpair_value_byte(const nvpair_t *nvp)
{
	uchar_t rv;
	VERIFY0(nvpair_value_byte(nvp, &rv));
	return (rv);
}

int8_t
fnvpair_value_int8(const nvpair_t *nvp)
{
	int8_t rv;
	VERIFY0(nvpair_value_int8(nvp, &rv));
	return (rv);
}

int16_t
fnvpair_value_int16(const nvpair_t *nvp)
{
	int16_t rv;
	VERIFY0(nvpair_value_int16(nvp, &rv));
	return (rv);
}

int32_t
fnvpair_value_int32(const nvpair_t *nvp)
{
	int32_t rv;
	VERIFY0(nvpair_value_int32(nvp, &rv));
	return (rv);
}

int64_t
fnvpair_value_int64(const nvpair_t *nvp)
{
	int64_t rv;
	VERIFY0(nvpair_value_int64(nvp, &rv));
	return (rv);
}

uint8_t
fnvpair_value_uint8(const nvpair_t *nvp)
{
	uint8_t rv;
	VERIFY0(nvpair_value_uint8(nvp, &rv));
	return (rv);
}

uint16_t
fnvpair_value_uint16(const nvpair_t *nvp)
{
	uint16_t rv;
	VERIFY0(nvpair_value_uint16(nvp, &rv));
	return (rv);
}

uint32_t
fnvpair_value_uint32(const nvpair_t *nvp)
{
	uint32_t rv;
	VERIFY0(nvpair_value_uint32(nvp, &rv));
	return (rv);
}

uint64_t
fnvpair_value_uint64(const nvpair_t *nvp)
{
	uint64_t rv;
	VERIFY0(nvpair_value_uint64(nvp, &rv));
	return (rv);
}

const char *
fnvpair_value_string(const nvpair_t *nvp)
{
	const char *rv;
	VERIFY0(nvpair_value_string(nvp, &rv));
	return (rv);
}

nvlist_t *
fnvpair_value_nvlist(nvpair_t *nvp)
{
	nvlist_t *rv;
	VERIFY0(nvpair_value_nvlist(nvp, &rv));
	return (rv);
}

#if defined(_KERNEL)

EXPORT_SYMBOL(fnvlist_alloc);
EXPORT_SYMBOL(fnvlist_free);
EXPORT_SYMBOL(fnvlist_size);
EXPORT_SYMBOL(fnvlist_pack);
EXPORT_SYMBOL(fnvlist_pack_free);
EXPORT_SYMBOL(fnvlist_unpack);
EXPORT_SYMBOL(fnvlist_dup);
EXPORT_SYMBOL(fnvlist_merge);

EXPORT_SYMBOL(fnvlist_add_nvpair);
EXPORT_SYMBOL(fnvlist_add_boolean);
EXPORT_SYMBOL(fnvlist_add_boolean_value);
EXPORT_SYMBOL(fnvlist_add_byte);
EXPORT_SYMBOL(fnvlist_add_int8);
EXPORT_SYMBOL(fnvlist_add_uint8);
EXPORT_SYMBOL(fnvlist_add_int16);
EXPORT_SYMBOL(fnvlist_add_uint16);
EXPORT_SYMBOL(fnvlist_add_int32);
EXPORT_SYMBOL(fnvlist_add_uint32);
EXPORT_SYMBOL(fnvlist_add_int64);
EXPORT_SYMBOL(fnvlist_add_uint64);
EXPORT_SYMBOL(fnvlist_add_string);
EXPORT_SYMBOL(fnvlist_add_nvlist);
EXPORT_SYMBOL(fnvlist_add_boolean_array);
EXPORT_SYMBOL(fnvlist_add_byte_array);
EXPORT_SYMBOL(fnvlist_add_int8_array);
EXPORT_SYMBOL(fnvlist_add_uint8_array);
EXPORT_SYMBOL(fnvlist_add_int16_array);
EXPORT_SYMBOL(fnvlist_add_uint16_array);
EXPORT_SYMBOL(fnvlist_add_int32_array);
EXPORT_SYMBOL(fnvlist_add_uint32_array);
EXPORT_SYMBOL(fnvlist_add_int64_array);
EXPORT_SYMBOL(fnvlist_add_uint64_array);
EXPORT_SYMBOL(fnvlist_add_string_array);
EXPORT_SYMBOL(fnvlist_add_nvlist_array);

EXPORT_SYMBOL(fnvlist_remove);
EXPORT_SYMBOL(fnvlist_remove_nvpair);

EXPORT_SYMBOL(fnvlist_lookup_nvpair);
EXPORT_SYMBOL(fnvlist_lookup_boolean);
EXPORT_SYMBOL(fnvlist_lookup_boolean_value);
EXPORT_SYMBOL(fnvlist_lookup_byte);
EXPORT_SYMBOL(fnvlist_lookup_int8);
EXPORT_SYMBOL(fnvlist_lookup_uint8);
EXPORT_SYMBOL(fnvlist_lookup_int16);
EXPORT_SYMBOL(fnvlist_lookup_uint16);
EXPORT_SYMBOL(fnvlist_lookup_int32);
EXPORT_SYMBOL(fnvlist_lookup_uint32);
EXPORT_SYMBOL(fnvlist_lookup_int64);
EXPORT_SYMBOL(fnvlist_lookup_uint64);
EXPORT_SYMBOL(fnvlist_lookup_string);
EXPORT_SYMBOL(fnvlist_lookup_nvlist);

EXPORT_SYMBOL(fnvpair_value_boolean_value);
EXPORT_SYMBOL(fnvpair_value_byte);
EXPORT_SYMBOL(fnvpair_value_int8);
EXPORT_SYMBOL(fnvpair_value_uint8);
EXPORT_SYMBOL(fnvpair_value_int16);
EXPORT_SYMBOL(fnvpair_value_uint16);
EXPORT_SYMBOL(fnvpair_value_int32);
EXPORT_SYMBOL(fnvpair_value_uint32);
EXPORT_SYMBOL(fnvpair_value_int64);
EXPORT_SYMBOL(fnvpair_value_uint64);
EXPORT_SYMBOL(fnvpair_value_string);
EXPORT_SYMBOL(fnvpair_value_nvlist);
EXPORT_SYMBOL(fnvlist_num_pairs);

#endif
Commit	Line	Data
9ae529ec CS	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License (the "License").
	6	* You may not use this file except in compliance with the License.
	7	*
	8	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
1d3ba0bf	9	* or https://opensource.org/licenses/CDDL-1.0.
9ae529ec CS	10	* See the License for the specific language governing permissions
	11	* and limitations under the License.
	12	*
	13	* When distributing Covered Code, include this CDDL HEADER in each
	14	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	15	* If applicable, add the following below this CDDL HEADER, with the
	16	* fields enclosed by brackets "[]" replaced with your own identifying
	17	* information: Portions Copyright [yyyy] [name of copyright owner]
	18	*
	19	* CDDL HEADER END
	20	*/
	21
	22	/*
95542372	23	* Copyright (c) 2012, 2018 by Delphix. All rights reserved.
9ae529ec CS	24	*/
	25
	26	#include <sys/nvpair.h>
	27	#include <sys/kmem.h>
	28	#include <sys/debug.h>
13fe0198	29	#include <sys/param.h>
9ae529ec CS	30	#ifndef _KERNEL
	31	#include <stdlib.h>
	32	#endif
	33
	34	/*
	35	* "Force" nvlist wrapper.
	36	*
	37	* These functions wrap the nvlist_* functions with assertions that assume
	38	* the operation is successful. This allows the caller's code to be much
	39	* more readable, especially for the fnvlist_lookup_* and fnvpair_value_*
	40	* functions, which can return the requested value (rather than filling in
	41	* a pointer).
	42	*
	43	* These functions use NV_UNIQUE_NAME, encoding NV_ENCODE_NATIVE, and allocate
	44	* with KM_SLEEP.
	45	*
	46	* More wrappers should be added as needed -- for example
	47	* nvlist_lookup__array and nvpair_value__array.
	48	*/
	49
	50	nvlist_t *
	51	fnvlist_alloc(void)
	52	{
	53	nvlist_t *nvl;
c99c9001	54	VERIFY0(nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP));
9ae529ec CS	55	return (nvl);
	56	}
	57
	58	void
	59	fnvlist_free(nvlist_t *nvl)
	60	{
	61	nvlist_free(nvl);
	62	}
	63
	64	size_t
	65	fnvlist_size(nvlist_t *nvl)
	66	{
	67	size_t size;
c99c9001	68	VERIFY0(nvlist_size(nvl, &size, NV_ENCODE_NATIVE));
9ae529ec CS	69	return (size);
	70	}
	71
	72	/*
	73	* Returns allocated buffer of size *sizep. Caller must free the buffer with
	74	* fnvlist_pack_free().
	75	*/
	76	char *
	77	fnvlist_pack(nvlist_t nvl, size_t sizep)
	78	{
	79	char *packed = 0;
	80	VERIFY3U(nvlist_pack(nvl, &packed, sizep, NV_ENCODE_NATIVE,
	81	KM_SLEEP), ==, 0);
	82	return (packed);
	83	}
	84
9ae529ec CS	85	void
	86	fnvlist_pack_free(char *pack, size_t size)
	87	{
	88	#ifdef _KERNEL
	89	kmem_free(pack, size);
	90	#else
0cad373e	91	(void) size;
9ae529ec CS	92	free(pack);
	93	#endif
	94	}
	95
	96	nvlist_t *
	97	fnvlist_unpack(char *buf, size_t buflen)
	98	{
	99	nvlist_t *rv;
c99c9001	100	VERIFY0(nvlist_unpack(buf, buflen, &rv, KM_SLEEP));
9ae529ec CS	101	return (rv);
	102	}
	103
	104	nvlist_t *
795075e6	105	fnvlist_dup(const nvlist_t *nvl)
9ae529ec CS	106	{
9ae529ec CS	107	nvlist_t *rv;
c99c9001	108	VERIFY0(nvlist_dup(nvl, &rv, KM_SLEEP));
9ae529ec CS	109	return (rv);
	110	}
	111
	112	void
	113	fnvlist_merge(nvlist_t dst, nvlist_t src)
	114	{
c99c9001	115	VERIFY0(nvlist_merge(dst, src, KM_SLEEP));
9ae529ec CS	116	}
9ae529ec CS	117
13fe0198 MA	118	size_t
	119	fnvlist_num_pairs(nvlist_t *nvl)
	120	{
	121	size_t count = 0;
	122	nvpair_t *pair;
	123
	124	for (pair = nvlist_next_nvpair(nvl, 0); pair != NULL;
	125	pair = nvlist_next_nvpair(nvl, pair))
	126	count++;
	127	return (count);
	128	}
	129
9ae529ec CS	130	void
	131	fnvlist_add_boolean(nvlist_t nvl, const char name)
	132	{
c99c9001	133	VERIFY0(nvlist_add_boolean(nvl, name));
9ae529ec CS	134	}
	135
	136	void
	137	fnvlist_add_boolean_value(nvlist_t nvl, const char name, boolean_t val)
	138	{
c99c9001	139	VERIFY0(nvlist_add_boolean_value(nvl, name, val));
9ae529ec CS	140	}
	141
	142	void
	143	fnvlist_add_byte(nvlist_t nvl, const char name, uchar_t val)
	144	{
c99c9001	145	VERIFY0(nvlist_add_byte(nvl, name, val));
9ae529ec CS	146	}
	147
	148	void
	149	fnvlist_add_int8(nvlist_t nvl, const char name, int8_t val)
	150	{
c99c9001	151	VERIFY0(nvlist_add_int8(nvl, name, val));
9ae529ec CS	152	}
	153
	154	void
	155	fnvlist_add_uint8(nvlist_t nvl, const char name, uint8_t val)
	156	{
c99c9001	157	VERIFY0(nvlist_add_uint8(nvl, name, val));
9ae529ec CS	158	}
	159
	160	void
	161	fnvlist_add_int16(nvlist_t nvl, const char name, int16_t val)
	162	{
c99c9001	163	VERIFY0(nvlist_add_int16(nvl, name, val));
9ae529ec CS	164	}
	165
	166	void
	167	fnvlist_add_uint16(nvlist_t nvl, const char name, uint16_t val)
	168	{
c99c9001	169	VERIFY0(nvlist_add_uint16(nvl, name, val));
9ae529ec CS	170	}
	171
	172	void
	173	fnvlist_add_int32(nvlist_t nvl, const char name, int32_t val)
	174	{
c99c9001	175	VERIFY0(nvlist_add_int32(nvl, name, val));
9ae529ec CS	176	}
	177
	178	void
	179	fnvlist_add_uint32(nvlist_t nvl, const char name, uint32_t val)
	180	{
c99c9001	181	VERIFY0(nvlist_add_uint32(nvl, name, val));
9ae529ec CS	182	}
	183
	184	void
	185	fnvlist_add_int64(nvlist_t nvl, const char name, int64_t val)
	186	{
c99c9001	187	VERIFY0(nvlist_add_int64(nvl, name, val));
9ae529ec CS	188	}
	189
	190	void
	191	fnvlist_add_uint64(nvlist_t nvl, const char name, uint64_t val)
	192	{
c99c9001	193	VERIFY0(nvlist_add_uint64(nvl, name, val));
9ae529ec CS	194	}
	195
	196	void
	197	fnvlist_add_string(nvlist_t nvl, const char name, const char *val)
	198	{
c99c9001	199	VERIFY0(nvlist_add_string(nvl, name, val));
9ae529ec CS	200	}
	201
	202	void
	203	fnvlist_add_nvlist(nvlist_t nvl, const char name, nvlist_t *val)
	204	{
c99c9001	205	VERIFY0(nvlist_add_nvlist(nvl, name, val));
9ae529ec CS	206	}
	207
	208	void
	209	fnvlist_add_nvpair(nvlist_t nvl, nvpair_t pair)
	210	{
c99c9001	211	VERIFY0(nvlist_add_nvpair(nvl, pair));
9ae529ec CS	212	}
	213
	214	void
	215	fnvlist_add_boolean_array(nvlist_t nvl, const char name,
795075e6	216	const boolean_t *val, uint_t n)
9ae529ec	217	{
c99c9001	218	VERIFY0(nvlist_add_boolean_array(nvl, name, val, n));
9ae529ec CS	219	}
	220
	221	void
795075e6 PD	222	fnvlist_add_byte_array(nvlist_t nvl, const char name, const uchar_t *val,
795075e6 PD	223	uint_t n)
9ae529ec	224	{
c99c9001	225	VERIFY0(nvlist_add_byte_array(nvl, name, val, n));
9ae529ec CS	226	}
	227
	228	void
795075e6 PD	229	fnvlist_add_int8_array(nvlist_t nvl, const char name, const int8_t *val,
795075e6 PD	230	uint_t n)
9ae529ec	231	{
c99c9001	232	VERIFY0(nvlist_add_int8_array(nvl, name, val, n));
9ae529ec CS	233	}
	234
	235	void
795075e6 PD	236	fnvlist_add_uint8_array(nvlist_t nvl, const char name, const uint8_t *val,
795075e6 PD	237	uint_t n)
9ae529ec	238	{
c99c9001	239	VERIFY0(nvlist_add_uint8_array(nvl, name, val, n));
9ae529ec CS	240	}
	241
	242	void
795075e6 PD	243	fnvlist_add_int16_array(nvlist_t nvl, const char name, const int16_t *val,
795075e6 PD	244	uint_t n)
9ae529ec	245	{
c99c9001	246	VERIFY0(nvlist_add_int16_array(nvl, name, val, n));
9ae529ec CS	247	}
	248
	249	void
	250	fnvlist_add_uint16_array(nvlist_t nvl, const char name,
795075e6	251	const uint16_t *val, uint_t n)
9ae529ec	252	{
c99c9001	253	VERIFY0(nvlist_add_uint16_array(nvl, name, val, n));
9ae529ec CS	254	}
	255
	256	void
795075e6 PD	257	fnvlist_add_int32_array(nvlist_t nvl, const char name, const int32_t *val,
795075e6 PD	258	uint_t n)
9ae529ec	259	{
c99c9001	260	VERIFY0(nvlist_add_int32_array(nvl, name, val, n));
9ae529ec CS	261	}
	262
	263	void
	264	fnvlist_add_uint32_array(nvlist_t nvl, const char name,
795075e6	265	const uint32_t *val, uint_t n)
9ae529ec	266	{
c99c9001	267	VERIFY0(nvlist_add_uint32_array(nvl, name, val, n));
9ae529ec CS	268	}
	269
	270	void
795075e6 PD	271	fnvlist_add_int64_array(nvlist_t nvl, const char name, const int64_t *val,
795075e6 PD	272	uint_t n)
9ae529ec	273	{
c99c9001	274	VERIFY0(nvlist_add_int64_array(nvl, name, val, n));
9ae529ec CS	275	}
	276
	277	void
	278	fnvlist_add_uint64_array(nvlist_t nvl, const char name,
795075e6	279	const uint64_t *val, uint_t n)
9ae529ec	280	{
c99c9001	281	VERIFY0(nvlist_add_uint64_array(nvl, name, val, n));
9ae529ec CS	282	}
	283
	284	void
	285	fnvlist_add_string_array(nvlist_t nvl, const char name,
795075e6	286	const char * const *val, uint_t n)
9ae529ec	287	{
c99c9001	288	VERIFY0(nvlist_add_string_array(nvl, name, val, n));
9ae529ec CS	289	}
	290
	291	void
	292	fnvlist_add_nvlist_array(nvlist_t nvl, const char name,
795075e6	293	const nvlist_t * const *val, uint_t n)
9ae529ec	294	{
c99c9001	295	VERIFY0(nvlist_add_nvlist_array(nvl, name, val, n));
9ae529ec CS	296	}
	297
	298	void
	299	fnvlist_remove(nvlist_t nvl, const char name)
	300	{
c99c9001	301	VERIFY0(nvlist_remove_all(nvl, name));
9ae529ec CS	302	}
	303
	304	void
	305	fnvlist_remove_nvpair(nvlist_t nvl, nvpair_t pair)
	306	{
c99c9001	307	VERIFY0(nvlist_remove_nvpair(nvl, pair));
9ae529ec CS	308	}
	309
	310	nvpair_t *
	311	fnvlist_lookup_nvpair(nvlist_t nvl, const char name)
	312	{
	313	nvpair_t *rv;
c99c9001	314	VERIFY0(nvlist_lookup_nvpair(nvl, name, &rv));
9ae529ec CS	315	return (rv);
	316	}
	317
	318	/* returns B_TRUE if the entry exists */
	319	boolean_t
795075e6	320	fnvlist_lookup_boolean(const nvlist_t nvl, const char name)
9ae529ec CS	321	{
	322	return (nvlist_lookup_boolean(nvl, name) == 0);
	323	}
	324
	325	boolean_t
795075e6	326	fnvlist_lookup_boolean_value(const nvlist_t nvl, const char name)
9ae529ec CS	327	{
9ae529ec CS	328	boolean_t rv;
c99c9001	329	VERIFY0(nvlist_lookup_boolean_value(nvl, name, &rv));
9ae529ec CS	330	return (rv);
	331	}
	332
	333	uchar_t
795075e6	334	fnvlist_lookup_byte(const nvlist_t nvl, const char name)
9ae529ec CS	335	{
9ae529ec CS	336	uchar_t rv;
c99c9001	337	VERIFY0(nvlist_lookup_byte(nvl, name, &rv));
9ae529ec CS	338	return (rv);
	339	}
	340
	341	int8_t
795075e6	342	fnvlist_lookup_int8(const nvlist_t nvl, const char name)
9ae529ec CS	343	{
9ae529ec CS	344	int8_t rv;
c99c9001	345	VERIFY0(nvlist_lookup_int8(nvl, name, &rv));
9ae529ec CS	346	return (rv);
	347	}
	348
	349	int16_t
795075e6	350	fnvlist_lookup_int16(const nvlist_t nvl, const char name)
9ae529ec CS	351	{
9ae529ec CS	352	int16_t rv;
c99c9001	353	VERIFY0(nvlist_lookup_int16(nvl, name, &rv));
9ae529ec CS	354	return (rv);
	355	}
	356
	357	int32_t
795075e6	358	fnvlist_lookup_int32(const nvlist_t nvl, const char name)
9ae529ec CS	359	{
9ae529ec CS	360	int32_t rv;
c99c9001	361	VERIFY0(nvlist_lookup_int32(nvl, name, &rv));
9ae529ec CS	362	return (rv);
	363	}
	364
	365	int64_t
795075e6	366	fnvlist_lookup_int64(const nvlist_t nvl, const char name)
9ae529ec CS	367	{
9ae529ec CS	368	int64_t rv;
c99c9001	369	VERIFY0(nvlist_lookup_int64(nvl, name, &rv));
9ae529ec CS	370	return (rv);
	371	}
	372
	373	uint8_t
795075e6	374	fnvlist_lookup_uint8(const nvlist_t nvl, const char name)
9ae529ec CS	375	{
9ae529ec CS	376	uint8_t rv;
c99c9001	377	VERIFY0(nvlist_lookup_uint8(nvl, name, &rv));
9ae529ec CS	378	return (rv);
	379	}
	380
	381	uint16_t
795075e6	382	fnvlist_lookup_uint16(const nvlist_t nvl, const char name)
9ae529ec CS	383	{
9ae529ec CS	384	uint16_t rv;
c99c9001	385	VERIFY0(nvlist_lookup_uint16(nvl, name, &rv));
9ae529ec CS	386	return (rv);
	387	}
	388
	389	uint32_t
795075e6	390	fnvlist_lookup_uint32(const nvlist_t nvl, const char name)
9ae529ec CS	391	{
9ae529ec CS	392	uint32_t rv;
c99c9001	393	VERIFY0(nvlist_lookup_uint32(nvl, name, &rv));
9ae529ec CS	394	return (rv);
	395	}
	396
	397	uint64_t
795075e6	398	fnvlist_lookup_uint64(const nvlist_t nvl, const char name)
9ae529ec CS	399	{
9ae529ec CS	400	uint64_t rv;
c99c9001	401	VERIFY0(nvlist_lookup_uint64(nvl, name, &rv));
9ae529ec CS	402	return (rv);
	403	}
	404
d1807f16 RY	405	const char *
d1807f16 RY	406	fnvlist_lookup_string(const nvlist_t nvl, const char name)
9ae529ec	407	{
d1807f16	408	const char *rv;
c99c9001	409	VERIFY0(nvlist_lookup_string(nvl, name, &rv));
9ae529ec CS	410	return (rv);
	411	}
	412
	413	nvlist_t *
	414	fnvlist_lookup_nvlist(nvlist_t nvl, const char name)
	415	{
	416	nvlist_t *rv;
c99c9001	417	VERIFY0(nvlist_lookup_nvlist(nvl, name, &rv));
9ae529ec CS	418	return (rv);
9ae529ec CS	419	}
95542372 PD	420	boolean_t *
	421	fnvlist_lookup_boolean_array(nvlist_t nvl, const char name, uint_t *n)
	422	{
	423	boolean_t *rv;
	424	VERIFY0(nvlist_lookup_boolean_array(nvl, name, &rv, n));
	425	return (rv);
	426	}
	427
	428	uchar_t *
	429	fnvlist_lookup_byte_array(nvlist_t nvl, const char name, uint_t *n)
	430	{
	431	uchar_t *rv;
	432	VERIFY0(nvlist_lookup_byte_array(nvl, name, &rv, n));
	433	return (rv);
	434	}
	435
	436	int8_t *
	437	fnvlist_lookup_int8_array(nvlist_t nvl, const char name, uint_t *n)
	438	{
	439	int8_t *rv;
	440	VERIFY0(nvlist_lookup_int8_array(nvl, name, &rv, n));
	441	return (rv);
	442	}
	443
	444	uint8_t *
	445	fnvlist_lookup_uint8_array(nvlist_t nvl, const char name, uint_t *n)
	446	{
	447	uint8_t *rv;
	448	VERIFY0(nvlist_lookup_uint8_array(nvl, name, &rv, n));
	449	return (rv);
	450	}
	451
	452	int16_t *
	453	fnvlist_lookup_int16_array(nvlist_t nvl, const char name, uint_t *n)
	454	{
	455	int16_t *rv;
	456	VERIFY0(nvlist_lookup_int16_array(nvl, name, &rv, n));
	457	return (rv);
	458	}
	459
	460	uint16_t *
	461	fnvlist_lookup_uint16_array(nvlist_t nvl, const char name, uint_t *n)
	462	{
	463	uint16_t *rv;
	464	VERIFY0(nvlist_lookup_uint16_array(nvl, name, &rv, n));
	465	return (rv);
	466	}
	467
	468	int32_t *
	469	fnvlist_lookup_int32_array(nvlist_t nvl, const char name, uint_t *n)
	470	{
	471	int32_t *rv;
	472	VERIFY0(nvlist_lookup_int32_array(nvl, name, &rv, n));
	473	return (rv);
	474	}
	475
	476	uint32_t *
	477	fnvlist_lookup_uint32_array(nvlist_t nvl, const char name, uint_t *n)
	478	{
	479	uint32_t *rv;
	480	VERIFY0(nvlist_lookup_uint32_array(nvl, name, &rv, n));
	481	return (rv);
	482	}
	483
484	int64_t *
485	fnvlist_lookup_int64_array(nvlist_t nvl, const char name, uint_t *n)
486	{
487	int64_t *rv;
488	VERIFY0(nvlist_lookup_int64_array(nvl, name, &rv, n));
489	return (rv);
490	}
491
492	uint64_t *
493	fnvlist_lookup_uint64_array(nvlist_t nvl, const char name, uint_t *n)
494	{
495	uint64_t *rv;
496	VERIFY0(nvlist_lookup_uint64_array(nvl, name, &rv, n));
497	return (rv);
498	}
9ae529ec CS	499
9ae529ec CS	500	boolean_t
795075e6	501	fnvpair_value_boolean_value(const nvpair_t *nvp)
9ae529ec CS	502	{
9ae529ec CS	503	boolean_t rv;
c99c9001	504	VERIFY0(nvpair_value_boolean_value(nvp, &rv));
9ae529ec CS	505	return (rv);
	506	}
	507
	508	uchar_t
795075e6	509	fnvpair_value_byte(const nvpair_t *nvp)
9ae529ec CS	510	{
9ae529ec CS	511	uchar_t rv;
c99c9001	512	VERIFY0(nvpair_value_byte(nvp, &rv));
9ae529ec CS	513	return (rv);
	514	}
	515
	516	int8_t
795075e6	517	fnvpair_value_int8(const nvpair_t *nvp)
9ae529ec CS	518	{
9ae529ec CS	519	int8_t rv;
c99c9001	520	VERIFY0(nvpair_value_int8(nvp, &rv));
9ae529ec CS	521	return (rv);
	522	}
	523
	524	int16_t
795075e6	525	fnvpair_value_int16(const nvpair_t *nvp)
9ae529ec CS	526	{
9ae529ec CS	527	int16_t rv;
c99c9001	528	VERIFY0(nvpair_value_int16(nvp, &rv));
9ae529ec CS	529	return (rv);
	530	}
	531
	532	int32_t
795075e6	533	fnvpair_value_int32(const nvpair_t *nvp)
9ae529ec CS	534	{
9ae529ec CS	535	int32_t rv;
c99c9001	536	VERIFY0(nvpair_value_int32(nvp, &rv));
9ae529ec CS	537	return (rv);
	538	}
	539
	540	int64_t
795075e6	541	fnvpair_value_int64(const nvpair_t *nvp)
9ae529ec CS	542	{
9ae529ec CS	543	int64_t rv;
c99c9001	544	VERIFY0(nvpair_value_int64(nvp, &rv));
9ae529ec CS	545	return (rv);
	546	}
	547
	548	uint8_t
795075e6	549	fnvpair_value_uint8(const nvpair_t *nvp)
9ae529ec CS	550	{
9ae529ec CS	551	uint8_t rv;
c99c9001	552	VERIFY0(nvpair_value_uint8(nvp, &rv));
9ae529ec CS	553	return (rv);
	554	}
	555
	556	uint16_t
795075e6	557	fnvpair_value_uint16(const nvpair_t *nvp)
9ae529ec CS	558	{
9ae529ec CS	559	uint16_t rv;
c99c9001	560	VERIFY0(nvpair_value_uint16(nvp, &rv));
9ae529ec CS	561	return (rv);
	562	}
	563
	564	uint32_t
795075e6	565	fnvpair_value_uint32(const nvpair_t *nvp)
9ae529ec CS	566	{
9ae529ec CS	567	uint32_t rv;
c99c9001	568	VERIFY0(nvpair_value_uint32(nvp, &rv));
9ae529ec CS	569	return (rv);
	570	}
	571
	572	uint64_t
795075e6	573	fnvpair_value_uint64(const nvpair_t *nvp)
9ae529ec CS	574	{
9ae529ec CS	575	uint64_t rv;
c99c9001	576	VERIFY0(nvpair_value_uint64(nvp, &rv));
9ae529ec CS	577	return (rv);
	578	}
	579
d1807f16 RY	580	const char *
d1807f16 RY	581	fnvpair_value_string(const nvpair_t *nvp)
9ae529ec	582	{
d1807f16	583	const char *rv;
c99c9001	584	VERIFY0(nvpair_value_string(nvp, &rv));
9ae529ec CS	585	return (rv);
	586	}
	587
	588	nvlist_t *
	589	fnvpair_value_nvlist(nvpair_t *nvp)
	590	{
	591	nvlist_t *rv;
c99c9001	592	VERIFY0(nvpair_value_nvlist(nvp, &rv));
9ae529ec CS	593	return (rv);
	594	}
	595
93ce2b4c	596	#if defined(_KERNEL)
9ae529ec CS	597
	598	EXPORT_SYMBOL(fnvlist_alloc);
	599	EXPORT_SYMBOL(fnvlist_free);
	600	EXPORT_SYMBOL(fnvlist_size);
	601	EXPORT_SYMBOL(fnvlist_pack);
6f1ffb06	602	EXPORT_SYMBOL(fnvlist_pack_free);
9ae529ec CS	603	EXPORT_SYMBOL(fnvlist_unpack);
	604	EXPORT_SYMBOL(fnvlist_dup);
	605	EXPORT_SYMBOL(fnvlist_merge);
	606
	607	EXPORT_SYMBOL(fnvlist_add_nvpair);
	608	EXPORT_SYMBOL(fnvlist_add_boolean);
	609	EXPORT_SYMBOL(fnvlist_add_boolean_value);
	610	EXPORT_SYMBOL(fnvlist_add_byte);
	611	EXPORT_SYMBOL(fnvlist_add_int8);
	612	EXPORT_SYMBOL(fnvlist_add_uint8);
	613	EXPORT_SYMBOL(fnvlist_add_int16);
	614	EXPORT_SYMBOL(fnvlist_add_uint16);
	615	EXPORT_SYMBOL(fnvlist_add_int32);
	616	EXPORT_SYMBOL(fnvlist_add_uint32);
	617	EXPORT_SYMBOL(fnvlist_add_int64);
	618	EXPORT_SYMBOL(fnvlist_add_uint64);
	619	EXPORT_SYMBOL(fnvlist_add_string);
	620	EXPORT_SYMBOL(fnvlist_add_nvlist);
	621	EXPORT_SYMBOL(fnvlist_add_boolean_array);
	622	EXPORT_SYMBOL(fnvlist_add_byte_array);
	623	EXPORT_SYMBOL(fnvlist_add_int8_array);
	624	EXPORT_SYMBOL(fnvlist_add_uint8_array);
	625	EXPORT_SYMBOL(fnvlist_add_int16_array);
	626	EXPORT_SYMBOL(fnvlist_add_uint16_array);
	627	EXPORT_SYMBOL(fnvlist_add_int32_array);
	628	EXPORT_SYMBOL(fnvlist_add_uint32_array);
	629	EXPORT_SYMBOL(fnvlist_add_int64_array);
	630	EXPORT_SYMBOL(fnvlist_add_uint64_array);
	631	EXPORT_SYMBOL(fnvlist_add_string_array);
	632	EXPORT_SYMBOL(fnvlist_add_nvlist_array);
	633
	634	EXPORT_SYMBOL(fnvlist_remove);
	635	EXPORT_SYMBOL(fnvlist_remove_nvpair);
	636
	637	EXPORT_SYMBOL(fnvlist_lookup_nvpair);
	638	EXPORT_SYMBOL(fnvlist_lookup_boolean);
	639	EXPORT_SYMBOL(fnvlist_lookup_boolean_value);
	640	EXPORT_SYMBOL(fnvlist_lookup_byte);
	641	EXPORT_SYMBOL(fnvlist_lookup_int8);
	642	EXPORT_SYMBOL(fnvlist_lookup_uint8);
	643	EXPORT_SYMBOL(fnvlist_lookup_int16);
	644	EXPORT_SYMBOL(fnvlist_lookup_uint16);
	645	EXPORT_SYMBOL(fnvlist_lookup_int32);
	646	EXPORT_SYMBOL(fnvlist_lookup_uint32);
	647	EXPORT_SYMBOL(fnvlist_lookup_int64);
	648	EXPORT_SYMBOL(fnvlist_lookup_uint64);
	649	EXPORT_SYMBOL(fnvlist_lookup_string);
	650	EXPORT_SYMBOL(fnvlist_lookup_nvlist);
	651
	652	EXPORT_SYMBOL(fnvpair_value_boolean_value);
	653	EXPORT_SYMBOL(fnvpair_value_byte);
	654	EXPORT_SYMBOL(fnvpair_value_int8);
	655	EXPORT_SYMBOL(fnvpair_value_uint8);
	656	EXPORT_SYMBOL(fnvpair_value_int16);
	657	EXPORT_SYMBOL(fnvpair_value_uint16);
	658	EXPORT_SYMBOL(fnvpair_value_int32);
	659	EXPORT_SYMBOL(fnvpair_value_uint32);
	660	EXPORT_SYMBOL(fnvpair_value_int64);
	661	EXPORT_SYMBOL(fnvpair_value_uint64);
	662	EXPORT_SYMBOL(fnvpair_value_string);
	663	EXPORT_SYMBOL(fnvpair_value_nvlist);
13fe0198	664	EXPORT_SYMBOL(fnvlist_num_pairs);
9ae529ec CS	665
9ae529ec CS	666	#endif