MFC nv(3) and part of nv(9) to stable/10

This includes the following revisions from head:

r258065,r258594,r259430,r260222,r261407,r261408,r263479,r264021,r266351,
r269603,r271026,r271027,r271028,r271241,r271578,r271579,r271847,r272102,
r272843,r273752,r277920,r277921,r277925,r277926,r277927,r279421,r279422,
r279423,r279424,r279425,r279426,r279427,r279428,r279429,r279430,r279431,
r279432,r279434,r279435,r279436,r279438,r279439,r279440,r279760,r282122,
r282254,r282257,r282304,r282312,r285339,r288340

This change reverts stable/10@r282122 and stable/10@r288340, and re-MFCs the
series again (r282122, r285339, and r288340).

More changes are pending to nv(9)/pci(4) after further review/work. Please see
the Phabricator review for more details (both https://reviews.freebsd.org/D4232
and https://reviews.freebsd.org/D4249 ).

- Tested with:
-- Booting VMware Fusion 8.1.0 running on a Haswell Apple Macbook Pro
-- Booting a Haswell machine with zfs and running some stress workloads with
   VirtualBox guests
-- make tinderbox
-- kyua test -k /usr/tests/lib/libnv

Differential Revision: https://reviews.freebsd.org/D4249 (part of a larger diff)
Relnotes: yes
Reviewed by: oshogbo (implicit), sbruno (implicit)
Submitted by: Kevin Bowling <kevin.bowling@kev009.com>
Sponsored by: EMC / Isilon Storage Division

3 files changed, 2714 insertions, 0 deletions

diff --git a/sys/kern/subr_dnvlist.c b/sys/kern/subr_dnvlist.c
new file mode 100644
index 0000000..9058520
--- /dev/null
+++ b/sys/kern/subr_dnvlist.c
@@ -0,0 +1,128 @@
+/*-
+ * Copyright (c) 2013 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * This software was developed by Pawel Jakub Dawidek under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#ifdef _KERNEL
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+
+#include <machine/stdarg.h>
+
+#else
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#endif
+
+#include <sys/nv.h>
+#include <sys/nv_impl.h>
+
+#include <sys/dnv.h>
+
+#define	DNVLIST_GET(ftype, type)					\
+ftype									\
+dnvlist_get_##type(const nvlist_t *nvl, const char *name, ftype defval)	\
+{									\
+									\
+	if (nvlist_exists_##type(nvl, name))				\
+		return (nvlist_get_##type(nvl, name));			\
+	else								\
+		return (defval);					\
+}
+
+DNVLIST_GET(bool, bool)
+DNVLIST_GET(uint64_t, number)
+DNVLIST_GET(const char *, string)
+DNVLIST_GET(const nvlist_t *, nvlist)
+#ifndef _KERNEL
+DNVLIST_GET(int, descriptor)
+#endif
+
+#undef	DNVLIST_GET
+
+const void *
+dnvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep,
+    const void *defval, size_t defsize)
+{
+	const void *value;
+
+	if (nvlist_exists_binary(nvl, name))
+		value = nvlist_get_binary(nvl, name, sizep);
+	else {
+		if (sizep != NULL)
+			*sizep = defsize;
+		value = defval;
+	}
+	return (value);
+}
+
+#define	DNVLIST_TAKE(ftype, type)					\
+ftype									\
+dnvlist_take_##type(nvlist_t *nvl, const char *name, ftype defval)	\
+{									\
+									\
+	if (nvlist_exists_##type(nvl, name))				\
+		return (nvlist_take_##type(nvl, name));			\
+	else								\
+		return (defval);					\
+}
+
+DNVLIST_TAKE(bool, bool)
+DNVLIST_TAKE(uint64_t, number)
+DNVLIST_TAKE(char *, string)
+DNVLIST_TAKE(nvlist_t *, nvlist)
+#ifndef _KERNEL
+DNVLIST_TAKE(int, descriptor)
+#endif
+
+#undef	DNVLIST_TAKE
+
+void *
+dnvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep,
+    void *defval, size_t defsize)
+{
+	void *value;
+
+	if (nvlist_exists_binary(nvl, name))
+		value = nvlist_take_binary(nvl, name, sizep);
+	else {
+		if (sizep != NULL)
+			*sizep = defsize;
+		value = defval;
+	}
+	return (value);
+}
+
diff --git a/sys/kern/subr_nvlist.c b/sys/kern/subr_nvlist.c
new file mode 100644
index 0000000..bc51018
--- /dev/null
+++ b/sys/kern/subr_nvlist.c
@@ -0,0 +1,1475 @@
+/*-
+ * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * This software was developed by Pawel Jakub Dawidek under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/endian.h>
+#include <sys/queue.h>
+
+#ifdef _KERNEL
+
+#include <sys/errno.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/systm.h>
+
+#include <machine/stdarg.h>
+
+#else
+#include <sys/socket.h>
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#define	_WITH_DPRINTF
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "msgio.h"
+#endif
+
+#ifdef HAVE_PJDLOG
+#include <pjdlog.h>
+#endif
+
+#include <sys/nv.h>
+#include <sys/nv_impl.h>
+#include <sys/nvlist_impl.h>
+#include <sys/nvpair_impl.h>
+
+#ifndef	HAVE_PJDLOG
+#ifdef _KERNEL
+#define	PJDLOG_ASSERT(...)		MPASS(__VA_ARGS__)
+#define	PJDLOG_RASSERT(expr, ...)	KASSERT(expr, (__VA_ARGS__))
+#define	PJDLOG_ABORT(...)		panic(__VA_ARGS__)
+#else
+#include <assert.h>
+#define	PJDLOG_ASSERT(...)		assert(__VA_ARGS__)
+#define	PJDLOG_RASSERT(expr, ...)	assert(expr)
+#define	PJDLOG_ABORT(...)		do {				\
+	fprintf(stderr, "%s:%u: ", __FILE__, __LINE__);			\
+	fprintf(stderr, __VA_ARGS__);					\
+	fprintf(stderr, "\n");						\
+	abort();							\
+} while (0)
+#endif
+#endif
+
+#define	NV_FLAG_PRIVATE_MASK	(NV_FLAG_BIG_ENDIAN)
+#define	NV_FLAG_PUBLIC_MASK	(NV_FLAG_IGNORE_CASE)
+#define	NV_FLAG_ALL_MASK	(NV_FLAG_PRIVATE_MASK | NV_FLAG_PUBLIC_MASK)
+
+#define	NVLIST_MAGIC	0x6e766c	/* "nvl" */
+struct nvlist {
+	int		 nvl_magic;
+	int		 nvl_error;
+	int		 nvl_flags;
+	nvpair_t	*nvl_parent;
+	struct nvl_head	 nvl_head;
+};
+
+#define	NVLIST_ASSERT(nvl)	do {					\
+	PJDLOG_ASSERT((nvl) != NULL);					\
+	PJDLOG_ASSERT((nvl)->nvl_magic == NVLIST_MAGIC);		\
+} while (0)
+
+#ifdef _KERNEL
+MALLOC_DEFINE(M_NVLIST, "nvlist", "kernel nvlist");
+#endif
+
+#define	NVPAIR_ASSERT(nvp)	nvpair_assert(nvp)
+
+#define	NVLIST_HEADER_MAGIC	0x6c
+#define	NVLIST_HEADER_VERSION	0x00
+struct nvlist_header {
+	uint8_t		nvlh_magic;
+	uint8_t		nvlh_version;
+	uint8_t		nvlh_flags;
+	uint64_t	nvlh_descriptors;
+	uint64_t	nvlh_size;
+} __packed;
+
+nvlist_t *
+nvlist_create(int flags)
+{
+	nvlist_t *nvl;
+
+	PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
+
+	nvl = nv_malloc(sizeof(*nvl));
+	nvl->nvl_error = 0;
+	nvl->nvl_flags = flags;
+	nvl->nvl_parent = NULL;
+	TAILQ_INIT(&nvl->nvl_head);
+	nvl->nvl_magic = NVLIST_MAGIC;
+
+	return (nvl);
+}
+
+void
+nvlist_destroy(nvlist_t *nvl)
+{
+	nvpair_t *nvp;
+	int serrno;
+
+	if (nvl == NULL)
+		return;
+
+	SAVE_ERRNO(serrno);
+
+	NVLIST_ASSERT(nvl);
+
+	while ((nvp = nvlist_first_nvpair(nvl)) != NULL) {
+		nvlist_remove_nvpair(nvl, nvp);
+		nvpair_free(nvp);
+	}
+	nvl->nvl_magic = 0;
+	nv_free(nvl);
+
+	RESTORE_ERRNO(serrno);
+}
+
+void
+nvlist_set_error(nvlist_t *nvl, int error)
+{
+
+	PJDLOG_ASSERT(error != 0);
+
+	/*
+	 * Check for error != 0 so that we don't do the wrong thing if somebody
+	 * tries to abuse this API when asserts are disabled.
+	 */
+	if (nvl != NULL && error != 0 && nvl->nvl_error == 0)
+		nvl->nvl_error = error;
+}
+
+int
+nvlist_error(const nvlist_t *nvl)
+{
+
+	if (nvl == NULL)
+		return (ENOMEM);
+
+	NVLIST_ASSERT(nvl);
+
+	return (nvl->nvl_error);
+}
+
+nvpair_t *
+nvlist_get_nvpair_parent(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	return (nvl->nvl_parent);
+}
+
+const nvlist_t *
+nvlist_get_parent(const nvlist_t *nvl, void **cookiep)
+{
+	nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+
+	nvp = nvl->nvl_parent;
+	if (cookiep != NULL)
+		*cookiep = nvp;
+	if (nvp == NULL)
+		return (NULL);
+
+	return (nvpair_nvlist(nvp));
+}
+
+void
+nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	nvl->nvl_parent = parent;
+}
+
+bool
+nvlist_empty(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+
+	return (nvlist_first_nvpair(nvl) == NULL);
+}
+
+int
+nvlist_flags(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT((nvl->nvl_flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
+
+	return (nvl->nvl_flags);
+}
+
+static void
+nvlist_report_missing(int type, const char *name)
+{
+
+	PJDLOG_ABORT("Element '%s' of type %s doesn't exist.",
+	    name, nvpair_type_string(type));
+}
+
+static nvpair_t *
+nvlist_find(const nvlist_t *nvl, int type, const char *name)
+{
+	nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
+	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
+
+	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
+	    nvp = nvlist_next_nvpair(nvl, nvp)) {
+		if (type != NV_TYPE_NONE && nvpair_type(nvp) != type)
+			continue;
+		if ((nvl->nvl_flags & NV_FLAG_IGNORE_CASE) != 0) {
+			if (strcasecmp(nvpair_name(nvp), name) != 0)
+				continue;
+		} else {
+			if (strcmp(nvpair_name(nvp), name) != 0)
+				continue;
+		}
+		break;
+	}
+
+	if (nvp == NULL)
+		RESTORE_ERRNO(ENOENT);
+
+	return (nvp);
+}
+
+bool
+nvlist_exists_type(const nvlist_t *nvl, const char *name, int type)
+{
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
+	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
+
+	return (nvlist_find(nvl, type, name) != NULL);
+}
+
+void
+nvlist_free_type(nvlist_t *nvl, const char *name, int type)
+{
+	nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT(type == NV_TYPE_NONE ||
+	    (type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST));
+
+	nvp = nvlist_find(nvl, type, name);
+	if (nvp != NULL)
+		nvlist_free_nvpair(nvl, nvp);
+	else
+		nvlist_report_missing(type, name);
+}
+
+nvlist_t *
+nvlist_clone(const nvlist_t *nvl)
+{
+	nvlist_t *newnvl;
+	nvpair_t *nvp, *newnvp;
+
+	NVLIST_ASSERT(nvl);
+
+	if (nvl->nvl_error != 0) {
+		RESTORE_ERRNO(nvl->nvl_error);
+		return (NULL);
+	}
+
+	newnvl = nvlist_create(nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
+	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
+	    nvp = nvlist_next_nvpair(nvl, nvp)) {
+		newnvp = nvpair_clone(nvp);
+		if (newnvp == NULL)
+			break;
+		nvlist_move_nvpair(newnvl, newnvp);
+	}
+	if (nvp != NULL) {
+		nvlist_destroy(newnvl);
+		return (NULL);
+	}
+	return (newnvl);
+}
+
+#ifndef _KERNEL
+static bool
+nvlist_dump_error_check(const nvlist_t *nvl, int fd, int level)
+{
+
+	if (nvlist_error(nvl) != 0) {
+		dprintf(fd, "%*serror: %d\n", level * 4, "",
+		    nvlist_error(nvl));
+		return (true);
+	}
+
+	return (false);
+}
+
+/*
+ * Dump content of nvlist.
+ */
+void
+nvlist_dump(const nvlist_t *nvl, int fd)
+{
+	const nvlist_t *tmpnvl;
+	nvpair_t *nvp, *tmpnvp;
+	void *cookie;
+	int level;
+
+	level = 0;
+	if (nvlist_dump_error_check(nvl, fd, level))
+		return;
+
+	nvp = nvlist_first_nvpair(nvl);
+	while (nvp != NULL) {
+		dprintf(fd, "%*s%s (%s):", level * 4, "", nvpair_name(nvp),
+		    nvpair_type_string(nvpair_type(nvp)));
+		switch (nvpair_type(nvp)) {
+		case NV_TYPE_NULL:
+			dprintf(fd, " null\n");
+			break;
+		case NV_TYPE_BOOL:
+			dprintf(fd, " %s\n", nvpair_get_bool(nvp) ?
+			    "TRUE" : "FALSE");
+			break;
+		case NV_TYPE_NUMBER:
+			dprintf(fd, " %ju (%jd) (0x%jx)\n",
+			    (uintmax_t)nvpair_get_number(nvp),
+			    (intmax_t)nvpair_get_number(nvp),
+			    (uintmax_t)nvpair_get_number(nvp));
+			break;
+		case NV_TYPE_STRING:
+			dprintf(fd, " [%s]\n", nvpair_get_string(nvp));
+			break;
+		case NV_TYPE_NVLIST:
+			dprintf(fd, "\n");
+			tmpnvl = nvpair_get_nvlist(nvp);
+			if (nvlist_dump_error_check(tmpnvl, fd, level + 1))
+				break;
+			tmpnvp = nvlist_first_nvpair(tmpnvl);
+			if (tmpnvp != NULL) {
+				nvl = tmpnvl;
+				nvp = tmpnvp;
+				level++;
+				continue;
+			}
+			break;
+		case NV_TYPE_DESCRIPTOR:
+			dprintf(fd, " %d\n", nvpair_get_descriptor(nvp));
+			break;
+		case NV_TYPE_BINARY:
+		    {
+			const unsigned char *binary;
+			unsigned int ii;
+			size_t size;
+
+			binary = nvpair_get_binary(nvp, &size);
+			dprintf(fd, " %zu ", size);
+			for (ii = 0; ii < size; ii++)
+				dprintf(fd, "%02hhx", binary[ii]);
+			dprintf(fd, "\n");
+			break;
+		    }
+		default:
+			PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
+		}
+
+		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
+			cookie = NULL;
+			nvl = nvlist_get_parent(nvl, &cookie);
+			if (nvl == NULL)
+				return;
+			nvp = cookie;
+			level--;
+		}
+	}
+}
+
+void
+nvlist_fdump(const nvlist_t *nvl, FILE *fp)
+{
+
+	fflush(fp);
+	nvlist_dump(nvl, fileno(fp));
+}
+#endif
+
+/*
+ * The function obtains size of the nvlist after nvlist_pack().
+ */
+size_t
+nvlist_size(const nvlist_t *nvl)
+{
+	const nvlist_t *tmpnvl;
+	const nvpair_t *nvp, *tmpnvp;
+	void *cookie;
+	size_t size;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+
+	size = sizeof(struct nvlist_header);
+	nvp = nvlist_first_nvpair(nvl);
+	while (nvp != NULL) {
+		size += nvpair_header_size();
+		size += strlen(nvpair_name(nvp)) + 1;
+		if (nvpair_type(nvp) == NV_TYPE_NVLIST) {
+			size += sizeof(struct nvlist_header);
+			size += nvpair_header_size() + 1;
+			tmpnvl = nvpair_get_nvlist(nvp);
+			PJDLOG_ASSERT(tmpnvl->nvl_error == 0);
+			tmpnvp = nvlist_first_nvpair(tmpnvl);
+			if (tmpnvp != NULL) {
+				nvl = tmpnvl;
+				nvp = tmpnvp;
+				continue;
+			}
+		} else {
+			size += nvpair_size(nvp);
+		}
+
+		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
+			cookie = NULL;
+			nvl = nvlist_get_parent(nvl, &cookie);
+			if (nvl == NULL)
+				goto out;
+			nvp = cookie;
+		}
+	}
+
+out:
+	return (size);
+}
+
+#ifndef _KERNEL
+static int *
+nvlist_xdescriptors(const nvlist_t *nvl, int *descs, int level)
+{
+	const nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT(level < 3);
+
+	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
+	    nvp = nvlist_next_nvpair(nvl, nvp)) {
+		switch (nvpair_type(nvp)) {
+		case NV_TYPE_DESCRIPTOR:
+			*descs = nvpair_get_descriptor(nvp);
+			descs++;
+			break;
+		case NV_TYPE_NVLIST:
+			descs = nvlist_xdescriptors(nvpair_get_nvlist(nvp),
+			    descs, level + 1);
+			break;
+		}
+	}
+
+	return (descs);
+}
+#endif
+
+#ifndef _KERNEL
+int *
+nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
+{
+	size_t nitems;
+	int *fds;
+
+	nitems = nvlist_ndescriptors(nvl);
+	fds = nv_malloc(sizeof(fds[0]) * (nitems + 1));
+	if (fds == NULL)
+		return (NULL);
+	if (nitems > 0)
+		nvlist_xdescriptors(nvl, fds, 0);
+	fds[nitems] = -1;
+	if (nitemsp != NULL)
+		*nitemsp = nitems;
+	return (fds);
+}
+#endif
+
+static size_t
+nvlist_xndescriptors(const nvlist_t *nvl, int level)
+{
+#ifndef _KERNEL
+	const nvpair_t *nvp;
+	size_t ndescs;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+	PJDLOG_ASSERT(level < 3);
+
+	ndescs = 0;
+	for (nvp = nvlist_first_nvpair(nvl); nvp != NULL;
+	    nvp = nvlist_next_nvpair(nvl, nvp)) {
+		switch (nvpair_type(nvp)) {
+		case NV_TYPE_DESCRIPTOR:
+			ndescs++;
+			break;
+		case NV_TYPE_NVLIST:
+			ndescs += nvlist_xndescriptors(nvpair_get_nvlist(nvp),
+			    level + 1);
+			break;
+		}
+	}
+
+	return (ndescs);
+#else
+	return (0);
+#endif
+}
+
+size_t
+nvlist_ndescriptors(const nvlist_t *nvl)
+{
+
+	return (nvlist_xndescriptors(nvl, 0));
+}
+
+static unsigned char *
+nvlist_pack_header(const nvlist_t *nvl, unsigned char *ptr, size_t *leftp)
+{
+	struct nvlist_header nvlhdr;
+
+	NVLIST_ASSERT(nvl);
+
+	nvlhdr.nvlh_magic = NVLIST_HEADER_MAGIC;
+	nvlhdr.nvlh_version = NVLIST_HEADER_VERSION;
+	nvlhdr.nvlh_flags = nvl->nvl_flags;
+#if BYTE_ORDER == BIG_ENDIAN
+	nvlhdr.nvlh_flags |= NV_FLAG_BIG_ENDIAN;
+#endif
+	nvlhdr.nvlh_descriptors = nvlist_ndescriptors(nvl);
+	nvlhdr.nvlh_size = *leftp - sizeof(nvlhdr);
+	PJDLOG_ASSERT(*leftp >= sizeof(nvlhdr));
+	memcpy(ptr, &nvlhdr, sizeof(nvlhdr));
+	ptr += sizeof(nvlhdr);
+	*leftp -= sizeof(nvlhdr);
+
+	return (ptr);
+}
+
+void *
+nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
+{
+	unsigned char *buf, *ptr;
+	size_t left, size;
+	const nvlist_t *tmpnvl;
+	nvpair_t *nvp, *tmpnvp;
+	void *cookie;
+
+	NVLIST_ASSERT(nvl);
+
+	if (nvl->nvl_error != 0) {
+		RESTORE_ERRNO(nvl->nvl_error);
+		return (NULL);
+	}
+
+	size = nvlist_size(nvl);
+	buf = nv_malloc(size);
+	if (buf == NULL)
+		return (NULL);
+
+	ptr = buf;
+	left = size;
+
+	ptr = nvlist_pack_header(nvl, ptr, &left);
+
+	nvp = nvlist_first_nvpair(nvl);
+	while (nvp != NULL) {
+		NVPAIR_ASSERT(nvp);
+
+		nvpair_init_datasize(nvp);
+		ptr = nvpair_pack_header(nvp, ptr, &left);
+		if (ptr == NULL) {
+			nv_free(buf);
+			return (NULL);
+		}
+		switch (nvpair_type(nvp)) {
+		case NV_TYPE_NULL:
+			ptr = nvpair_pack_null(nvp, ptr, &left);
+			break;
+		case NV_TYPE_BOOL:
+			ptr = nvpair_pack_bool(nvp, ptr, &left);
+			break;
+		case NV_TYPE_NUMBER:
+			ptr = nvpair_pack_number(nvp, ptr, &left);
+			break;
+		case NV_TYPE_STRING:
+			ptr = nvpair_pack_string(nvp, ptr, &left);
+			break;
+		case NV_TYPE_NVLIST:
+			tmpnvl = nvpair_get_nvlist(nvp);
+			ptr = nvlist_pack_header(tmpnvl, ptr, &left);
+			if (ptr == NULL)
+				goto out;
+			tmpnvp = nvlist_first_nvpair(tmpnvl);
+			if (tmpnvp != NULL) {
+				nvl = tmpnvl;
+				nvp = tmpnvp;
+				continue;
+			}
+			ptr = nvpair_pack_nvlist_up(ptr, &left);
+			break;
+#ifndef _KERNEL
+		case NV_TYPE_DESCRIPTOR:
+			ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
+			break;
+#endif
+		case NV_TYPE_BINARY:
+			ptr = nvpair_pack_binary(nvp, ptr, &left);
+			break;
+		default:
+			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
+		}
+		if (ptr == NULL) {
+			nv_free(buf);
+			return (NULL);
+		}
+		while ((nvp = nvlist_next_nvpair(nvl, nvp)) == NULL) {
+			cookie = NULL;
+			nvl = nvlist_get_parent(nvl, &cookie);
+			if (nvl == NULL)
+				goto out;
+			nvp = cookie;
+			ptr = nvpair_pack_nvlist_up(ptr, &left);
+			if (ptr == NULL)
+				goto out;
+		}
+	}
+
+out:
+	if (sizep != NULL)
+		*sizep = size;
+	return (buf);
+}
+
+void *
+nvlist_pack(const nvlist_t *nvl, size_t *sizep)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	if (nvl->nvl_error != 0) {
+		RESTORE_ERRNO(nvl->nvl_error);
+		return (NULL);
+	}
+
+	if (nvlist_ndescriptors(nvl) > 0) {
+		RESTORE_ERRNO(EOPNOTSUPP);
+		return (NULL);
+	}
+
+	return (nvlist_xpack(nvl, NULL, sizep));
+}
+
+static bool
+nvlist_check_header(struct nvlist_header *nvlhdrp)
+{
+
+	if (nvlhdrp->nvlh_magic != NVLIST_HEADER_MAGIC) {
+		RESTORE_ERRNO(EINVAL);
+		return (false);
+	}
+	if ((nvlhdrp->nvlh_flags & ~NV_FLAG_ALL_MASK) != 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (false);
+	}
+#if BYTE_ORDER == BIG_ENDIAN
+	if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) == 0) {
+		nvlhdrp->nvlh_size = le64toh(nvlhdrp->nvlh_size);
+		nvlhdrp->nvlh_descriptors = le64toh(nvlhdrp->nvlh_descriptors);
+	}
+#else
+	if ((nvlhdrp->nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0) {
+		nvlhdrp->nvlh_size = be64toh(nvlhdrp->nvlh_size);
+		nvlhdrp->nvlh_descriptors = be64toh(nvlhdrp->nvlh_descriptors);
+	}
+#endif
+	return (true);
+}
+
+const unsigned char *
+nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
+    bool *isbep, size_t *leftp)
+{
+	struct nvlist_header nvlhdr;
+
+	if (*leftp < sizeof(nvlhdr))
+		goto failed;
+
+	memcpy(&nvlhdr, ptr, sizeof(nvlhdr));
+
+	if (!nvlist_check_header(&nvlhdr))
+		goto failed;
+
+	if (nvlhdr.nvlh_size != *leftp - sizeof(nvlhdr))
+		goto failed;
+
+	/*
+	 * nvlh_descriptors might be smaller than nfds in embedded nvlists.
+	 */
+	if (nvlhdr.nvlh_descriptors > nfds)
+		goto failed;
+
+	if ((nvlhdr.nvlh_flags & ~NV_FLAG_ALL_MASK) != 0)
+		goto failed;
+
+	nvl->nvl_flags = (nvlhdr.nvlh_flags & NV_FLAG_PUBLIC_MASK);
+
+	ptr += sizeof(nvlhdr);
+	if (isbep != NULL)
+		*isbep = (((int)nvlhdr.nvlh_flags & NV_FLAG_BIG_ENDIAN) != 0);
+	*leftp -= sizeof(nvlhdr);
+
+	return (ptr);
+failed:
+	RESTORE_ERRNO(EINVAL);
+	return (NULL);
+}
+
+nvlist_t *
+nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
+{
+	const unsigned char *ptr;
+	nvlist_t *nvl, *retnvl, *tmpnvl;
+	nvpair_t *nvp;
+	size_t left;
+	bool isbe;
+
+	left = size;
+	ptr = buf;
+
+	tmpnvl = NULL;
+	nvl = retnvl = nvlist_create(0);
+	if (nvl == NULL)
+		goto failed;
+
+	ptr = nvlist_unpack_header(nvl, ptr, nfds, &isbe, &left);
+	if (ptr == NULL)
+		goto failed;
+
+	while (left > 0) {
+		ptr = nvpair_unpack(isbe, ptr, &left, &nvp);
+		if (ptr == NULL)
+			goto failed;
+		switch (nvpair_type(nvp)) {
+		case NV_TYPE_NULL:
+			ptr = nvpair_unpack_null(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_BOOL:
+			ptr = nvpair_unpack_bool(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_NUMBER:
+			ptr = nvpair_unpack_number(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_STRING:
+			ptr = nvpair_unpack_string(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_NVLIST:
+			ptr = nvpair_unpack_nvlist(isbe, nvp, ptr, &left, nfds,
+			    &tmpnvl);
+			nvlist_set_parent(tmpnvl, nvp);
+			break;
+#ifndef _KERNEL
+		case NV_TYPE_DESCRIPTOR:
+			ptr = nvpair_unpack_descriptor(isbe, nvp, ptr, &left,
+			    fds, nfds);
+			break;
+#endif
+		case NV_TYPE_BINARY:
+			ptr = nvpair_unpack_binary(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_NVLIST_UP:
+			if (nvl->nvl_parent == NULL)
+				goto failed;
+			nvl = nvpair_nvlist(nvl->nvl_parent);
+			continue;
+		default:
+			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
+		}
+		if (ptr == NULL)
+			goto failed;
+		nvlist_move_nvpair(nvl, nvp);
+		if (tmpnvl != NULL) {
+			nvl = tmpnvl;
+			tmpnvl = NULL;
+		}
+	}
+
+	return (retnvl);
+failed:
+	nvlist_destroy(retnvl);
+	return (NULL);
+}
+
+nvlist_t *
+nvlist_unpack(const void *buf, size_t size)
+{
+
+	return (nvlist_xunpack(buf, size, NULL, 0));
+}
+
+#ifndef _KERNEL
+int
+nvlist_send(int sock, const nvlist_t *nvl)
+{
+	size_t datasize, nfds;
+	int *fds;
+	void *data;
+	int64_t fdidx;
+	int serrno, ret;
+
+	if (nvlist_error(nvl) != 0) {
+		errno = nvlist_error(nvl);
+		return (-1);
+	}
+
+	fds = nvlist_descriptors(nvl, &nfds);
+	if (fds == NULL)
+		return (-1);
+
+	ret = -1;
+	data = NULL;
+	fdidx = 0;
+
+	data = nvlist_xpack(nvl, &fdidx, &datasize);
+	if (data == NULL)
+		goto out;
+
+	if (buf_send(sock, data, datasize) == -1)
+		goto out;
+
+	if (nfds > 0) {
+		if (fd_send(sock, fds, nfds) == -1)
+			goto out;
+	}
+
+	ret = 0;
+out:
+	serrno = errno;
+	free(fds);
+	free(data);
+	errno = serrno;
+	return (ret);
+}
+
+nvlist_t *
+nvlist_recv(int sock)
+{
+	struct nvlist_header nvlhdr;
+	nvlist_t *nvl, *ret;
+	unsigned char *buf;
+	size_t nfds, size, i;
+	int serrno, *fds;
+
+	if (buf_recv(sock, &nvlhdr, sizeof(nvlhdr)) == -1)
+		return (NULL);
+
+	if (!nvlist_check_header(&nvlhdr))
+		return (NULL);
+
+	nfds = (size_t)nvlhdr.nvlh_descriptors;
+	size = sizeof(nvlhdr) + (size_t)nvlhdr.nvlh_size;
+
+	buf = malloc(size);
+	if (buf == NULL)
+		return (NULL);
+
+	memcpy(buf, &nvlhdr, sizeof(nvlhdr));
+
+	ret = NULL;
+	fds = NULL;
+
+	if (buf_recv(sock, buf + sizeof(nvlhdr), size - sizeof(nvlhdr)) == -1)
+		goto out;
+
+	if (nfds > 0) {
+		fds = malloc(nfds * sizeof(fds[0]));
+		if (fds == NULL)
+			goto out;
+		if (fd_recv(sock, fds, nfds) == -1)
+			goto out;
+	}
+
+	nvl = nvlist_xunpack(buf, size, fds, nfds);
+	if (nvl == NULL) {
+		for (i = 0; i < nfds; i++)
+			close(fds[i]);
+		goto out;
+	}
+
+	ret = nvl;
+out:
+	serrno = errno;
+	free(buf);
+	free(fds);
+	errno = serrno;
+
+	return (ret);
+}
+
+nvlist_t *
+nvlist_xfer(int sock, nvlist_t *nvl)
+{
+
+	if (nvlist_send(sock, nvl) < 0) {
+		nvlist_destroy(nvl);
+		return (NULL);
+	}
+	nvlist_destroy(nvl);
+	return (nvlist_recv(sock));
+}
+#endif
+
+nvpair_t *
+nvlist_first_nvpair(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	return (TAILQ_FIRST(&nvl->nvl_head));
+}
+
+nvpair_t *
+nvlist_next_nvpair(const nvlist_t *nvl, const nvpair_t *nvp)
+{
+	nvpair_t *retnvp;
+
+	NVLIST_ASSERT(nvl);
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
+
+	retnvp = nvpair_next(nvp);
+	PJDLOG_ASSERT(retnvp == NULL || nvpair_nvlist(retnvp) == nvl);
+
+	return (retnvp);
+
+}
+
+nvpair_t *
+nvlist_prev_nvpair(const nvlist_t *nvl, const nvpair_t *nvp)
+{
+	nvpair_t *retnvp;
+
+	NVLIST_ASSERT(nvl);
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
+
+	retnvp = nvpair_prev(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(retnvp) == nvl);
+
+	return (retnvp);
+}
+
+const char *
+nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep)
+{
+	nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(cookiep != NULL);
+
+	if (*cookiep == NULL)
+		nvp = nvlist_first_nvpair(nvl);
+	else
+		nvp = nvlist_next_nvpair(nvl, *cookiep);
+	if (nvp == NULL)
+		return (NULL);
+	if (typep != NULL)
+		*typep = nvpair_type(nvp);
+	*cookiep = nvp;
+	return (nvpair_name(nvp));
+}
+
+bool
+nvlist_exists(const nvlist_t *nvl, const char *name)
+{
+
+	return (nvlist_find(nvl, NV_TYPE_NONE, name) != NULL);
+}
+
+#define	NVLIST_EXISTS(type, TYPE)					\
+bool									\
+nvlist_exists_##type(const nvlist_t *nvl, const char *name)		\
+{									\
+									\
+	return (nvlist_find(nvl, NV_TYPE_##TYPE, name) != NULL);	\
+}
+
+NVLIST_EXISTS(null, NULL)
+NVLIST_EXISTS(bool, BOOL)
+NVLIST_EXISTS(number, NUMBER)
+NVLIST_EXISTS(string, STRING)
+NVLIST_EXISTS(nvlist, NVLIST)
+#ifndef _KERNEL
+NVLIST_EXISTS(descriptor, DESCRIPTOR)
+#endif
+NVLIST_EXISTS(binary, BINARY)
+
+#undef	NVLIST_EXISTS
+
+void
+nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
+{
+	nvpair_t *newnvp;
+
+	NVPAIR_ASSERT(nvp);
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+	if (nvlist_exists(nvl, nvpair_name(nvp))) {
+		nvl->nvl_error = EEXIST;
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	newnvp = nvpair_clone(nvp);
+	if (newnvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvpair_insert(&nvl->nvl_head, newnvp, nvl);
+}
+
+void
+nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...)
+{
+	va_list valueap;
+
+	va_start(valueap, valuefmt);
+	nvlist_add_stringv(nvl, name, valuefmt, valueap);
+	va_end(valueap);
+}
+
+void
+nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt,
+    va_list valueap)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_stringv(name, valuefmt, valueap);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_add_null(nvlist_t *nvl, const char *name)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_null(name);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_add_bool(nvlist_t *nvl, const char *name, bool value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_bool(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_add_number(nvlist_t *nvl, const char *name, uint64_t value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_number(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_add_string(nvlist_t *nvl, const char *name, const char *value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_string(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_add_nvlist(nvlist_t *nvl, const char *name, const nvlist_t *value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_nvlist(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+#ifndef _KERNEL
+void
+nvlist_add_descriptor(nvlist_t *nvl, const char *name, int value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		errno = nvlist_error(nvl);
+		return;
+	}
+
+	nvp = nvpair_create_descriptor(name, value);
+	if (nvp == NULL)
+		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
+	else
+		nvlist_move_nvpair(nvl, nvp);
+}
+#endif
+
+void
+nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value,
+    size_t size)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_create_binary(name, value, size);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == NULL);
+
+	if (nvlist_error(nvl) != 0) {
+		nvpair_free(nvp);
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+	if (nvlist_exists(nvl, nvpair_name(nvp))) {
+		nvpair_free(nvp);
+		nvl->nvl_error = EEXIST;
+		RESTORE_ERRNO(nvl->nvl_error);
+		return;
+	}
+
+	nvpair_insert(&nvl->nvl_head, nvp, nvl);
+}
+
+void
+nvlist_move_string(nvlist_t *nvl, const char *name, char *value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		nv_free(value);
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_move_string(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+void
+nvlist_move_nvlist(nvlist_t *nvl, const char *name, nvlist_t *value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		if (value != NULL && nvlist_get_nvpair_parent(value) != NULL)
+			nvlist_destroy(value);
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_move_nvlist(name, value);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+#ifndef _KERNEL
+void
+nvlist_move_descriptor(nvlist_t *nvl, const char *name, int value)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		close(value);
+		errno = nvlist_error(nvl);
+		return;
+	}
+
+	nvp = nvpair_move_descriptor(name, value);
+	if (nvp == NULL)
+		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
+	else
+		nvlist_move_nvpair(nvl, nvp);
+}
+#endif
+
+void
+nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size)
+{
+	nvpair_t *nvp;
+
+	if (nvlist_error(nvl) != 0) {
+		nv_free(value);
+		RESTORE_ERRNO(nvlist_error(nvl));
+		return;
+	}
+
+	nvp = nvpair_move_binary(name, value, size);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		RESTORE_ERRNO(nvl->nvl_error);
+	} else
+		nvlist_move_nvpair(nvl, nvp);
+}
+
+const nvpair_t *
+nvlist_get_nvpair(const nvlist_t *nvl, const char *name)
+{
+
+	return (nvlist_find(nvl, NV_TYPE_NONE, name));
+}
+
+#define	NVLIST_GET(ftype, type, TYPE)					\
+ftype									\
+nvlist_get_##type(const nvlist_t *nvl, const char *name)		\
+{									\
+	const nvpair_t *nvp;						\
+									\
+	nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name);			\
+	if (nvp == NULL)						\
+		nvlist_report_missing(NV_TYPE_##TYPE, name);		\
+	return (nvpair_get_##type(nvp));				\
+}
+
+NVLIST_GET(bool, bool, BOOL)
+NVLIST_GET(uint64_t, number, NUMBER)
+NVLIST_GET(const char *, string, STRING)
+NVLIST_GET(const nvlist_t *, nvlist, NVLIST)
+#ifndef _KERNEL
+NVLIST_GET(int, descriptor, DESCRIPTOR)
+#endif
+
+#undef	NVLIST_GET
+
+const void *
+nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep)
+{
+	nvpair_t *nvp;
+
+	nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
+	if (nvp == NULL)
+		nvlist_report_missing(NV_TYPE_BINARY, name);
+
+	return (nvpair_get_binary(nvp, sizep));
+}
+
+#define	NVLIST_TAKE(ftype, type, TYPE)					\
+ftype									\
+nvlist_take_##type(nvlist_t *nvl, const char *name)			\
+{									\
+	nvpair_t *nvp;							\
+	ftype value;							\
+									\
+	nvp = nvlist_find(nvl, NV_TYPE_##TYPE, name);			\
+	if (nvp == NULL)						\
+		nvlist_report_missing(NV_TYPE_##TYPE, name);		\
+	value = (ftype)(intptr_t)nvpair_get_##type(nvp);		\
+	nvlist_remove_nvpair(nvl, nvp);					\
+	nvpair_free_structure(nvp);					\
+	return (value);							\
+}
+
+NVLIST_TAKE(bool, bool, BOOL)
+NVLIST_TAKE(uint64_t, number, NUMBER)
+NVLIST_TAKE(char *, string, STRING)
+NVLIST_TAKE(nvlist_t *, nvlist, NVLIST)
+#ifndef _KERNEL
+NVLIST_TAKE(int, descriptor, DESCRIPTOR)
+#endif
+
+#undef	NVLIST_TAKE
+
+void *
+nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep)
+{
+	nvpair_t *nvp;
+	void *value;
+
+	nvp = nvlist_find(nvl, NV_TYPE_BINARY, name);
+	if (nvp == NULL)
+		nvlist_report_missing(NV_TYPE_BINARY, name);
+
+	value = (void *)(intptr_t)nvpair_get_binary(nvp, sizep);
+	nvlist_remove_nvpair(nvl, nvp);
+	nvpair_free_structure(nvp);
+	return (value);
+}
+
+void
+nvlist_remove_nvpair(nvlist_t *nvl, nvpair_t *nvp)
+{
+
+	NVLIST_ASSERT(nvl);
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
+
+	nvpair_remove(&nvl->nvl_head, nvp, nvl);
+}
+
+void
+nvlist_free(nvlist_t *nvl, const char *name)
+{
+
+	nvlist_free_type(nvl, name, NV_TYPE_NONE);
+}
+
+#define	NVLIST_FREE(type, TYPE)						\
+void									\
+nvlist_free_##type(nvlist_t *nvl, const char *name)			\
+{									\
+									\
+	nvlist_free_type(nvl, name, NV_TYPE_##TYPE);			\
+}
+
+NVLIST_FREE(null, NULL)
+NVLIST_FREE(bool, BOOL)
+NVLIST_FREE(number, NUMBER)
+NVLIST_FREE(string, STRING)
+NVLIST_FREE(nvlist, NVLIST)
+#ifndef _KERNEL
+NVLIST_FREE(descriptor, DESCRIPTOR)
+#endif
+NVLIST_FREE(binary, BINARY)
+
+#undef	NVLIST_FREE
+
+void
+nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp)
+{
+
+	NVLIST_ASSERT(nvl);
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == nvl);
+
+	nvlist_remove_nvpair(nvl, nvp);
+	nvpair_free(nvp);
+}
+
diff --git a/sys/kern/subr_nvpair.c b/sys/kern/subr_nvpair.c
new file mode 100644
index 0000000..2e11d799
--- /dev/null
+++ b/sys/kern/subr_nvpair.c
@@ -0,0 +1,1111 @@
+/*-
+ * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * All rights reserved.
+ *
+ * This software was developed by Pawel Jakub Dawidek under sponsorship from
+ * the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/endian.h>
+#include <sys/queue.h>
+
+#ifdef _KERNEL
+
+#include <sys/errno.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/systm.h>
+
+#include <machine/stdarg.h>
+
+#else
+#include <errno.h>
+#include <fcntl.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "common_impl.h"
+#endif
+
+#ifdef HAVE_PJDLOG
+#include <pjdlog.h>
+#endif
+
+#include <sys/nv.h>
+#include <sys/nv_impl.h>
+#include <sys/nvlist_impl.h>
+#include <sys/nvpair_impl.h>
+
+#ifndef	HAVE_PJDLOG
+#ifdef _KERNEL
+#define	PJDLOG_ASSERT(...)		MPASS(__VA_ARGS__)
+#define	PJDLOG_RASSERT(expr, ...)	KASSERT(expr, (__VA_ARGS__))
+#define	PJDLOG_ABORT(...)		panic(__VA_ARGS__)
+#else
+#include <assert.h>
+#define	PJDLOG_ASSERT(...)		assert(__VA_ARGS__)
+#define	PJDLOG_RASSERT(expr, ...)	assert(expr)
+#define	PJDLOG_ABORT(...)		abort()
+#endif
+#endif
+
+#define	NVPAIR_MAGIC	0x6e7670	/* "nvp" */
+struct nvpair {
+	int		 nvp_magic;
+	char		*nvp_name;
+	int		 nvp_type;
+	uint64_t	 nvp_data;
+	size_t		 nvp_datasize;
+	nvlist_t	*nvp_list;
+	TAILQ_ENTRY(nvpair) nvp_next;
+};
+
+#define	NVPAIR_ASSERT(nvp)	do {					\
+	PJDLOG_ASSERT((nvp) != NULL);					\
+	PJDLOG_ASSERT((nvp)->nvp_magic == NVPAIR_MAGIC);		\
+} while (0)
+
+struct nvpair_header {
+	uint8_t		nvph_type;
+	uint16_t	nvph_namesize;
+	uint64_t	nvph_datasize;
+} __packed;
+
+
+void
+nvpair_assert(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+}
+
+nvlist_t *
+nvpair_nvlist(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_list);
+}
+
+nvpair_t *
+nvpair_next(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list != NULL);
+
+	return (TAILQ_NEXT(nvp, nvp_next));
+}
+
+nvpair_t *
+nvpair_prev(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list != NULL);
+
+	return (TAILQ_PREV(nvp, nvl_head, nvp_next));
+}
+
+void
+nvpair_insert(struct nvl_head *head, nvpair_t *nvp, nvlist_t *nvl)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list == NULL);
+	PJDLOG_ASSERT(!nvlist_exists(nvl, nvpair_name(nvp)));
+
+	TAILQ_INSERT_TAIL(head, nvp, nvp_next);
+	nvp->nvp_list = nvl;
+}
+
+static void
+nvpair_remove_nvlist(nvpair_t *nvp)
+{
+	nvlist_t *nvl;
+
+	/* XXX: DECONST is bad, mkay? */
+	nvl = __DECONST(nvlist_t *, nvpair_get_nvlist(nvp));
+	PJDLOG_ASSERT(nvl != NULL);
+	nvlist_set_parent(nvl, NULL);
+}
+
+void
+nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list == nvl);
+
+	if (nvpair_type(nvp) == NV_TYPE_NVLIST)
+		nvpair_remove_nvlist(nvp);
+
+	TAILQ_REMOVE(head, nvp, nvp_next);
+	nvp->nvp_list = NULL;
+}
+
+nvpair_t *
+nvpair_clone(const nvpair_t *nvp)
+{
+	nvpair_t *newnvp;
+	const char *name;
+	const void *data;
+	size_t datasize;
+
+	NVPAIR_ASSERT(nvp);
+
+	name = nvpair_name(nvp);
+
+	switch (nvpair_type(nvp)) {
+	case NV_TYPE_NULL:
+		newnvp = nvpair_create_null(name);
+		break;
+	case NV_TYPE_BOOL:
+		newnvp = nvpair_create_bool(name, nvpair_get_bool(nvp));
+		break;
+	case NV_TYPE_NUMBER:
+		newnvp = nvpair_create_number(name, nvpair_get_number(nvp));
+		break;
+	case NV_TYPE_STRING:
+		newnvp = nvpair_create_string(name, nvpair_get_string(nvp));
+		break;
+	case NV_TYPE_NVLIST:
+		newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
+		break;
+#ifndef _KERNEL
+	case NV_TYPE_DESCRIPTOR:
+		newnvp = nvpair_create_descriptor(name,
+		    nvpair_get_descriptor(nvp));
+		break;
+#endif
+	case NV_TYPE_BINARY:
+		data = nvpair_get_binary(nvp, &datasize);
+		newnvp = nvpair_create_binary(name, data, datasize);
+		break;
+	default:
+		PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
+	}
+
+	return (newnvp);
+}
+
+size_t
+nvpair_header_size(void)
+{
+
+	return (sizeof(struct nvpair_header));
+}
+
+size_t
+nvpair_size(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_datasize);
+}
+
+unsigned char *
+nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+	struct nvpair_header nvphdr;
+	size_t namesize;
+
+	NVPAIR_ASSERT(nvp);
+
+	nvphdr.nvph_type = nvp->nvp_type;
+	namesize = strlen(nvp->nvp_name) + 1;
+	PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
+	nvphdr.nvph_namesize = namesize;
+	nvphdr.nvph_datasize = nvp->nvp_datasize;
+	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
+	memcpy(ptr, &nvphdr, sizeof(nvphdr));
+	ptr += sizeof(nvphdr);
+	*leftp -= sizeof(nvphdr);
+
+	PJDLOG_ASSERT(*leftp >= namesize);
+	memcpy(ptr, nvp->nvp_name, namesize);
+	ptr += namesize;
+	*leftp -= namesize;
+
+	return (ptr);
+}
+
+unsigned char *
+nvpair_pack_null(const nvpair_t *nvp, unsigned char *ptr,
+    size_t *leftp __unused)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
+
+	return (ptr);
+}
+
+unsigned char *
+nvpair_pack_bool(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+	uint8_t value;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
+
+	value = (uint8_t)nvp->nvp_data;
+
+	PJDLOG_ASSERT(*leftp >= sizeof(value));
+	memcpy(ptr, &value, sizeof(value));
+	ptr += sizeof(value);
+	*leftp -= sizeof(value);
+
+	return (ptr);
+}
+
+unsigned char *
+nvpair_pack_number(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+	uint64_t value;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
+
+	value = (uint64_t)nvp->nvp_data;
+
+	PJDLOG_ASSERT(*leftp >= sizeof(value));
+	memcpy(ptr, &value, sizeof(value));
+	ptr += sizeof(value);
+	*leftp -= sizeof(value);
+
+	return (ptr);
+}
+
+unsigned char *
+nvpair_pack_string(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
+
+	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
+	memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
+	ptr += nvp->nvp_datasize;
+	*leftp -= nvp->nvp_datasize;
+
+	return (ptr);
+}
+
+unsigned char *
+nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp)
+{
+	struct nvpair_header nvphdr;
+	size_t namesize;
+	const char *name = "";
+
+	namesize = 1;
+	nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
+	nvphdr.nvph_namesize = namesize;
+	nvphdr.nvph_datasize = 0;
+	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
+	memcpy(ptr, &nvphdr, sizeof(nvphdr));
+	ptr += sizeof(nvphdr);
+	*leftp -= sizeof(nvphdr);
+
+	PJDLOG_ASSERT(*leftp >= namesize);
+	memcpy(ptr, name, namesize);
+	ptr += namesize;
+	*leftp -= namesize;
+
+	return (ptr);
+}
+
+#ifndef _KERNEL
+unsigned char *
+nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr, int64_t *fdidxp,
+    size_t *leftp)
+{
+	int64_t value;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
+
+	value = (int64_t)nvp->nvp_data;
+	if (value != -1) {
+		/*
+		 * If there is a real descriptor here, we change its number
+		 * to position in the array of descriptors send via control
+		 * message.
+		 */
+		PJDLOG_ASSERT(fdidxp != NULL);
+
+		value = *fdidxp;
+		(*fdidxp)++;
+	}
+
+	PJDLOG_ASSERT(*leftp >= sizeof(value));
+	memcpy(ptr, &value, sizeof(value));
+	ptr += sizeof(value);
+	*leftp -= sizeof(value);
+
+	return (ptr);
+}
+#endif
+
+unsigned char *
+nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
+
+	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
+	memcpy(ptr, (const void *)(intptr_t)nvp->nvp_data, nvp->nvp_datasize);
+	ptr += nvp->nvp_datasize;
+	*leftp -= nvp->nvp_datasize;
+
+	return (ptr);
+}
+
+void
+nvpair_init_datasize(nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	if (nvp->nvp_type == NV_TYPE_NVLIST) {
+		if (nvp->nvp_data == 0) {
+			nvp->nvp_datasize = 0;
+		} else {
+			nvp->nvp_datasize =
+			    nvlist_size((const nvlist_t *)(intptr_t)nvp->nvp_data);
+		}
+	}
+}
+
+const unsigned char *
+nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
+    size_t *leftp)
+{
+	struct nvpair_header nvphdr;
+
+	if (*leftp < sizeof(nvphdr))
+		goto failed;
+
+	memcpy(&nvphdr, ptr, sizeof(nvphdr));
+	ptr += sizeof(nvphdr);
+	*leftp -= sizeof(nvphdr);
+
+#if NV_TYPE_FIRST > 0
+	if (nvphdr.nvph_type < NV_TYPE_FIRST)
+		goto failed;
+#endif
+	if (nvphdr.nvph_type > NV_TYPE_LAST &&
+	    nvphdr.nvph_type != NV_TYPE_NVLIST_UP) {
+		goto failed;
+	}
+
+#if BYTE_ORDER == BIG_ENDIAN
+	if (!isbe) {
+		nvphdr.nvph_namesize = le16toh(nvphdr.nvph_namesize);
+		nvphdr.nvph_datasize = le64toh(nvphdr.nvph_datasize);
+	}
+#else
+	if (isbe) {
+		nvphdr.nvph_namesize = be16toh(nvphdr.nvph_namesize);
+		nvphdr.nvph_datasize = be64toh(nvphdr.nvph_datasize);
+	}
+#endif
+
+	if (nvphdr.nvph_namesize > NV_NAME_MAX)
+		goto failed;
+	if (*leftp < nvphdr.nvph_namesize)
+		goto failed;
+	if (nvphdr.nvph_namesize < 1)
+		goto failed;
+	if (strnlen((const char *)ptr, nvphdr.nvph_namesize) !=
+	    (size_t)(nvphdr.nvph_namesize - 1)) {
+		goto failed;
+	}
+
+	memcpy(nvp->nvp_name, ptr, nvphdr.nvph_namesize);
+	ptr += nvphdr.nvph_namesize;
+	*leftp -= nvphdr.nvph_namesize;
+
+	if (*leftp < nvphdr.nvph_datasize)
+		goto failed;
+
+	nvp->nvp_type = nvphdr.nvph_type;
+	nvp->nvp_data = 0;
+	nvp->nvp_datasize = nvphdr.nvph_datasize;
+
+	return (ptr);
+failed:
+	RESTORE_ERRNO(EINVAL);
+	return (NULL);
+}
+
+const unsigned char *
+nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
+    size_t *leftp __unused)
+{
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
+
+	if (nvp->nvp_datasize != 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	return (ptr);
+}
+
+const unsigned char *
+nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
+    size_t *leftp)
+{
+	uint8_t value;
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
+
+	if (nvp->nvp_datasize != sizeof(value)) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+	if (*leftp < sizeof(value)) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	memcpy(&value, ptr, sizeof(value));
+	ptr += sizeof(value);
+	*leftp -= sizeof(value);
+
+	if (value != 0 && value != 1) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	nvp->nvp_data = (uint64_t)value;
+
+	return (ptr);
+}
+
+const unsigned char *
+nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
+     size_t *leftp)
+{
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
+
+	if (nvp->nvp_datasize != sizeof(uint64_t)) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+	if (*leftp < sizeof(uint64_t)) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	if (isbe)
+		nvp->nvp_data = be64dec(ptr);
+	else
+		nvp->nvp_data = le64dec(ptr);
+	ptr += sizeof(uint64_t);
+	*leftp -= sizeof(uint64_t);
+
+	return (ptr);
+}
+
+const unsigned char *
+nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp)
+{
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
+
+	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
+	    nvp->nvp_datasize - 1) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	nvp->nvp_data = (uint64_t)(uintptr_t)nv_strdup((const char *)ptr);
+	if (nvp->nvp_data == 0)
+		return (NULL);
+
+	ptr += nvp->nvp_datasize;
+	*leftp -= nvp->nvp_datasize;
+
+	return (ptr);
+}
+
+const unsigned char *
+nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp, size_t nfds, nvlist_t **child)
+{
+	nvlist_t *value;
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
+
+	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	value = nvlist_create(0);
+	if (value == NULL)
+		return (NULL);
+
+	ptr = nvlist_unpack_header(value, ptr, nfds, NULL, leftp);
+	if (ptr == NULL)
+		return (NULL);
+
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
+	*child = value;
+
+	return (ptr);
+}
+
+#ifndef _KERNEL
+const unsigned char *
+nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
+    size_t *leftp, const int *fds, size_t nfds)
+{
+	int64_t idx;
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
+
+	if (nvp->nvp_datasize != sizeof(idx)) {
+		errno = EINVAL;
+		return (NULL);
+	}
+	if (*leftp < sizeof(idx)) {
+		errno = EINVAL;
+		return (NULL);
+	}
+
+	if (isbe)
+		idx = be64dec(ptr);
+	else
+		idx = le64dec(ptr);
+
+	if (idx < 0) {
+		errno = EINVAL;
+		return (NULL);
+	}
+
+	if ((size_t)idx >= nfds) {
+		errno = EINVAL;
+		return (NULL);
+	}
+
+	nvp->nvp_data = (uint64_t)fds[idx];
+
+	ptr += sizeof(idx);
+	*leftp -= sizeof(idx);
+
+	return (ptr);
+}
+#endif
+
+const unsigned char *
+nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp)
+{
+	void *value;
+
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
+
+	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	value = nv_malloc(nvp->nvp_datasize);
+	if (value == NULL)
+		return (NULL);
+
+	memcpy(value, ptr, nvp->nvp_datasize);
+	ptr += nvp->nvp_datasize;
+	*leftp -= nvp->nvp_datasize;
+
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
+
+	return (ptr);
+}
+
+const unsigned char *
+nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
+    nvpair_t **nvpp)
+{
+	nvpair_t *nvp, *tmp;
+
+	nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
+	if (nvp == NULL)
+		return (NULL);
+	nvp->nvp_name = (char *)(nvp + 1);
+
+	ptr = nvpair_unpack_header(isbe, nvp, ptr, leftp);
+	if (ptr == NULL)
+		goto failed;
+	tmp = nv_realloc(nvp, sizeof(*nvp) + strlen(nvp->nvp_name) + 1);
+	if (tmp == NULL)
+		goto failed;
+	nvp = tmp;
+
+	/* Update nvp_name after realloc(). */
+	nvp->nvp_name = (char *)(nvp + 1);
+	nvp->nvp_data = 0x00;
+	nvp->nvp_magic = NVPAIR_MAGIC;
+	*nvpp = nvp;
+	return (ptr);
+failed:
+	nv_free(nvp);
+	return (NULL);
+}
+
+int
+nvpair_type(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_type);
+}
+
+const char *
+nvpair_name(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_name);
+}
+
+static nvpair_t *
+nvpair_allocv(const char *name, int type, uint64_t data, size_t datasize)
+{
+	nvpair_t *nvp;
+	size_t namelen;
+
+	PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
+
+	namelen = strlen(name);
+	if (namelen >= NV_NAME_MAX) {
+		RESTORE_ERRNO(ENAMETOOLONG);
+		return (NULL);
+	}
+
+	nvp = nv_calloc(1, sizeof(*nvp) + namelen + 1);
+	if (nvp != NULL) {
+		nvp->nvp_name = (char *)(nvp + 1);
+		memcpy(nvp->nvp_name, name, namelen);
+		nvp->nvp_name[namelen + 1] = '\0';
+		nvp->nvp_type = type;
+		nvp->nvp_data = data;
+		nvp->nvp_datasize = datasize;
+		nvp->nvp_magic = NVPAIR_MAGIC;
+	}
+
+	return (nvp);
+};
+
+nvpair_t *
+nvpair_create_stringf(const char *name, const char *valuefmt, ...)
+{
+	va_list valueap;
+	nvpair_t *nvp;
+
+	va_start(valueap, valuefmt);
+	nvp = nvpair_create_stringv(name, valuefmt, valueap);
+	va_end(valueap);
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap)
+{
+	nvpair_t *nvp;
+	char *str;
+	int len;
+
+	len = nv_vasprintf(&str, valuefmt, valueap);
+	if (len < 0)
+		return (NULL);
+	nvp = nvpair_create_string(name, str);
+	if (nvp == NULL)
+		nv_free(str);
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_create_null(const char *name)
+{
+
+	return (nvpair_allocv(name, NV_TYPE_NULL, 0, 0));
+}
+
+nvpair_t *
+nvpair_create_bool(const char *name, bool value)
+{
+
+	return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
+	    sizeof(uint8_t)));
+}
+
+nvpair_t *
+nvpair_create_number(const char *name, uint64_t value)
+{
+
+	return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value)));
+}
+
+nvpair_t *
+nvpair_create_string(const char *name, const char *value)
+{
+	nvpair_t *nvp;
+	size_t size;
+	char *data;
+
+	if (value == NULL) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	data = nv_strdup(value);
+	if (data == NULL)
+		return (NULL);
+	size = strlen(value) + 1;
+
+	nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
+	    size);
+	if (nvp == NULL)
+		nv_free(data);
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_create_nvlist(const char *name, const nvlist_t *value)
+{
+	nvlist_t *nvl;
+	nvpair_t *nvp;
+
+	if (value == NULL) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	nvl = nvlist_clone(value);
+	if (nvl == NULL)
+		return (NULL);
+
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0);
+	if (nvp == NULL)
+		nvlist_destroy(nvl);
+	else
+		nvlist_set_parent(nvl, nvp);
+
+	return (nvp);
+}
+
+#ifndef _KERNEL
+nvpair_t *
+nvpair_create_descriptor(const char *name, int value)
+{
+	nvpair_t *nvp;
+
+	if (value < 0 || !fd_is_valid(value)) {
+		errno = EBADF;
+		return (NULL);
+	}
+
+	value = fcntl(value, F_DUPFD_CLOEXEC, 0);
+	if (value < 0)
+		return (NULL);
+
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
+	    sizeof(int64_t));
+	if (nvp == NULL)
+		close(value);
+
+	return (nvp);
+}
+#endif
+
+nvpair_t *
+nvpair_create_binary(const char *name, const void *value, size_t size)
+{
+	nvpair_t *nvp;
+	void *data;
+
+	if (value == NULL || size == 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	data = nv_malloc(size);
+	if (data == NULL)
+		return (NULL);
+	memcpy(data, value, size);
+
+	nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
+	    size);
+	if (nvp == NULL)
+		nv_free(data);
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_move_string(const char *name, char *value)
+{
+	nvpair_t *nvp;
+	int serrno;
+
+	if (value == NULL) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
+	    strlen(value) + 1);
+	if (nvp == NULL) {
+		SAVE_ERRNO(serrno);
+		nv_free(value);
+		RESTORE_ERRNO(serrno);
+	}
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_move_nvlist(const char *name, nvlist_t *value)
+{
+	nvpair_t *nvp;
+
+	if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	if (nvlist_error(value) != 0) {
+		RESTORE_ERRNO(nvlist_error(value));
+		nvlist_destroy(value);
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
+	    0);
+	if (nvp == NULL)
+		nvlist_destroy(value);
+	else
+		nvlist_set_parent(value, nvp);
+
+	return (nvp);
+}
+
+#ifndef _KERNEL
+nvpair_t *
+nvpair_move_descriptor(const char *name, int value)
+{
+	nvpair_t *nvp;
+	int serrno;
+
+	if (value < 0 || !fd_is_valid(value)) {
+		errno = EBADF;
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
+	    sizeof(int64_t));
+	if (nvp == NULL) {
+		serrno = errno;
+		close(value);
+		errno = serrno;
+	}
+
+	return (nvp);
+}
+#endif
+
+nvpair_t *
+nvpair_move_binary(const char *name, void *value, size_t size)
+{
+	nvpair_t *nvp;
+	int serrno;
+
+	if (value == NULL || size == 0) {
+		RESTORE_ERRNO(EINVAL);
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
+	    size);
+	if (nvp == NULL) {
+		SAVE_ERRNO(serrno);
+		nv_free(value);
+		RESTORE_ERRNO(serrno);
+	}
+
+	return (nvp);
+}
+
+bool
+nvpair_get_bool(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_data == 1);
+}
+
+uint64_t
+nvpair_get_number(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+
+	return (nvp->nvp_data);
+}
+
+const char *
+nvpair_get_string(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
+
+	return ((const char *)(intptr_t)nvp->nvp_data);
+}
+
+const nvlist_t *
+nvpair_get_nvlist(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
+
+	return ((const nvlist_t *)(intptr_t)nvp->nvp_data);
+}
+
+#ifndef _KERNEL
+int
+nvpair_get_descriptor(const nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
+
+	return ((int)nvp->nvp_data);
+}
+#endif
+
+const void *
+nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
+
+	if (sizep != NULL)
+		*sizep = nvp->nvp_datasize;
+	return ((const void *)(intptr_t)nvp->nvp_data);
+}
+
+void
+nvpair_free(nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list == NULL);
+
+	nvp->nvp_magic = 0;
+	switch (nvp->nvp_type) {
+#ifndef _KERNEL
+	case NV_TYPE_DESCRIPTOR:
+		close((int)nvp->nvp_data);
+		break;
+#endif
+	case NV_TYPE_NVLIST:
+		nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
+		break;
+	case NV_TYPE_STRING:
+		nv_free((char *)(intptr_t)nvp->nvp_data);
+		break;
+	case NV_TYPE_BINARY:
+		nv_free((void *)(intptr_t)nvp->nvp_data);
+		break;
+	}
+	nv_free(nvp);
+}
+
+void
+nvpair_free_structure(nvpair_t *nvp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_list == NULL);
+
+	nvp->nvp_magic = 0;
+	nv_free(nvp);
+}
+
+const char *
+nvpair_type_string(int type)
+{
+
+	switch (type) {
+	case NV_TYPE_NULL:
+		return ("NULL");
+	case NV_TYPE_BOOL:
+		return ("BOOL");
+	case NV_TYPE_NUMBER:
+		return ("NUMBER");
+	case NV_TYPE_STRING:
+		return ("STRING");
+	case NV_TYPE_NVLIST:
+		return ("NVLIST");
+	case NV_TYPE_DESCRIPTOR:
+		return ("DESCRIPTOR");
+	case NV_TYPE_BINARY:
+		return ("BINARY");
+	default:
+		return ("<UNKNOWN>");
+	}
+}
+