Update libnv to the latest head @ r293361

23 files changed, 1996 insertions, 5612 deletions

diff --git a/external/libnv/Makefile b/external/libnv/Makefile
index c8179d9e..38ec0098 100644
--- a/external/libnv/Makefile
+++ b/external/libnv/Makefile
@@ -1,4 +1,4 @@
-# $FreeBSD: head/lib/libnv/Makefile 279439 2015-03-01 00:34:27Z rstone $
+# $FreeBSD$
 
 SHLIBDIR?= /lib
 
@@ -7,162 +7,13 @@ SHLIBDIR?= /lib
 LIB=	nv
 SHLIB_MAJOR= 0
 
-.PATH: ${.CURDIR}/../../sys/kern ${.CURDIR}/../../sys/sys
+.PATH: ${.CURDIR}/../../sys/contrib/libnv ${.CURDIR}/../../sys/sys
 CFLAGS+=-I${.CURDIR}/../../sys -I${.CURDIR}
 
-SRCS=	subr_dnvlist.c
+SRCS=	dnvlist.c
 SRCS+=	msgio.c
-SRCS+=	subr_nvlist.c
-SRCS+=	subr_nvpair.c
-
-INCS=	dnv.h
-INCS+=	nv.h
-
-MAN+=	nv.3
-
-MLINKS+=nv.3 libnv.3 \
-	nv.3 nvlist.3
-MLINKS+=nv.3 nvlist_create.3 \
-	nv.3 nvlist_destroy.3 \
-	nv.3 nvlist_error.3 \
-	nv.3 nvlist_set_error.3 \
-	nv.3 nvlist_empty.3 \
-	nv.3 nvlist_clone.3 \
-	nv.3 nvlist_dump.3 \
-	nv.3 nvlist_fdump.3 \
-	nv.3 nvlist_size.3 \
-	nv.3 nvlist_pack.3 \
-	nv.3 nvlist_unpack.3 \
-	nv.3 nvlist_send.3 \
-	nv.3 nvlist_recv.3 \
-	nv.3 nvlist_xfer.3 \
-	nv.3 nvlist_next.3 \
-	nv.3 nvlist_exists.3 \
-	nv.3 nvlist_exists_type.3 \
-	nv.3 nvlist_exists_null.3 \
-	nv.3 nvlist_exists_bool.3 \
-	nv.3 nvlist_exists_number.3 \
-	nv.3 nvlist_exists_string.3 \
-	nv.3 nvlist_exists_nvlist.3 \
-	nv.3 nvlist_exists_descriptor.3 \
-	nv.3 nvlist_exists_binary.3 \
-	nv.3 nvlist_add_null.3 \
-	nv.3 nvlist_add_bool.3 \
-	nv.3 nvlist_add_number.3 \
-	nv.3 nvlist_add_string.3 \
-	nv.3 nvlist_add_stringf.3 \
-	nv.3 nvlist_add_stringv.3 \
-	nv.3 nvlist_add_nvlist.3 \
-	nv.3 nvlist_add_descriptor.3 \
-	nv.3 nvlist_add_binary.3 \
-	nv.3 nvlist_move_string.3 \
-	nv.3 nvlist_move_nvlist.3 \
-	nv.3 nvlist_move_descriptor.3 \
-	nv.3 nvlist_move_binary.3 \
-	nv.3 nvlist_get_bool.3 \
-	nv.3 nvlist_get_number.3 \
-	nv.3 nvlist_get_string.3 \
-	nv.3 nvlist_get_nvlist.3 \
-	nv.3 nvlist_get_descriptor.3 \
-	nv.3 nvlist_get_binary.3 \
-	nv.3 nvlist_get_parent.3 \
-	nv.3 nvlist_take_bool.3 \
-	nv.3 nvlist_take_number.3 \
-	nv.3 nvlist_take_string.3 \
-	nv.3 nvlist_take_nvlist.3 \
-	nv.3 nvlist_take_descriptor.3 \
-	nv.3 nvlist_take_binary.3 \
-	nv.3 nvlist_free.3 \
-	nv.3 nvlist_free_type.3 \
-	nv.3 nvlist_free_null.3 \
-	nv.3 nvlist_free_bool.3 \
-	nv.3 nvlist_free_number.3 \
-	nv.3 nvlist_free_string.3 \
-	nv.3 nvlist_free_nvlist.3 \
-	nv.3 nvlist_free_descriptor.3 \
-	nv.3 nvlist_free_binary.3
-MLINKS+=nv.3 nvlist_existsf.3 \
-	nv.3 nvlist_existsf_type.3 \
-	nv.3 nvlist_existsf_null.3 \
-	nv.3 nvlist_existsf_bool.3 \
-	nv.3 nvlist_existsf_number.3 \
-	nv.3 nvlist_existsf_string.3 \
-	nv.3 nvlist_existsf_nvlist.3 \
-	nv.3 nvlist_existsf_descriptor.3 \
-	nv.3 nvlist_existsf_binary.3 \
-	nv.3 nvlist_addf_null.3 \
-	nv.3 nvlist_addf_bool.3 \
-	nv.3 nvlist_addf_number.3 \
-	nv.3 nvlist_addf_string.3 \
-	nv.3 nvlist_addf_nvlist.3 \
-	nv.3 nvlist_addf_descriptor.3 \
-	nv.3 nvlist_addf_binary.3 \
-	nv.3 nvlist_movef_string.3 \
-	nv.3 nvlist_movef_nvlist.3 \
-	nv.3 nvlist_movef_descriptor.3 \
-	nv.3 nvlist_movef_binary.3 \
-	nv.3 nvlist_getf_bool.3 \
-	nv.3 nvlist_getf_number.3 \
-	nv.3 nvlist_getf_string.3 \
-	nv.3 nvlist_getf_nvlist.3 \
-	nv.3 nvlist_getf_descriptor.3 \
-	nv.3 nvlist_getf_binary.3 \
-	nv.3 nvlist_takef_bool.3 \
-	nv.3 nvlist_takef_number.3 \
-	nv.3 nvlist_takef_string.3 \
-	nv.3 nvlist_takef_nvlist.3 \
-	nv.3 nvlist_takef_descriptor.3 \
-	nv.3 nvlist_takef_binary.3 \
-	nv.3 nvlist_freef.3 \
-	nv.3 nvlist_freef_type.3 \
-	nv.3 nvlist_freef_null.3 \
-	nv.3 nvlist_freef_bool.3 \
-	nv.3 nvlist_freef_number.3 \
-	nv.3 nvlist_freef_string.3 \
-	nv.3 nvlist_freef_nvlist.3 \
-	nv.3 nvlist_freef_descriptor.3 \
-	nv.3 nvlist_freef_binary.3
-MLINKS+=nv.3 nvlist_existsv.3 \
-	nv.3 nvlist_existsv_type.3 \
-	nv.3 nvlist_existsv_null.3 \
-	nv.3 nvlist_existsv_bool.3 \
-	nv.3 nvlist_existsv_number.3 \
-	nv.3 nvlist_existsv_string.3 \
-	nv.3 nvlist_existsv_nvlist.3 \
-	nv.3 nvlist_existsv_descriptor.3 \
-	nv.3 nvlist_existsv_binary.3 \
-	nv.3 nvlist_addv_null.3 \
-	nv.3 nvlist_addv_bool.3 \
-	nv.3 nvlist_addv_number.3 \
-	nv.3 nvlist_addv_string.3 \
-	nv.3 nvlist_addv_nvlist.3 \
-	nv.3 nvlist_addv_descriptor.3 \
-	nv.3 nvlist_addv_binary.3 \
-	nv.3 nvlist_movev_string.3 \
-	nv.3 nvlist_movev_nvlist.3 \
-	nv.3 nvlist_movev_descriptor.3 \
-	nv.3 nvlist_movev_binary.3 \
-	nv.3 nvlist_getv_bool.3 \
-	nv.3 nvlist_getv_number.3 \
-	nv.3 nvlist_getv_string.3 \
-	nv.3 nvlist_getv_nvlist.3 \
-	nv.3 nvlist_getv_descriptor.3 \
-	nv.3 nvlist_getv_binary.3 \
-	nv.3 nvlist_takev_bool.3 \
-	nv.3 nvlist_takev_number.3 \
-	nv.3 nvlist_takev_string.3 \
-	nv.3 nvlist_takev_nvlist.3 \
-	nv.3 nvlist_takev_descriptor.3 \
-	nv.3 nvlist_takev_binary.3 \
-	nv.3 nvlist_freev.3 \
-	nv.3 nvlist_freev_type.3 \
-	nv.3 nvlist_freev_null.3 \
-	nv.3 nvlist_freev_bool.3 \
-	nv.3 nvlist_freev_number.3 \
-	nv.3 nvlist_freev_string.3 \
-	nv.3 nvlist_freev_nvlist.3 \
-	nv.3 nvlist_freev_descriptor.3 \
-	nv.3 nvlist_freev_binary.3
+SRCS+=	nvlist.c
+SRCS+=	nvpair.c
 
 WARNS?=	6
 
diff --git a/external/libnv/Makefile.depend b/external/libnv/Makefile.depend
new file mode 100644
index 00000000..3646e2e2
--- /dev/null
+++ b/external/libnv/Makefile.depend
@@ -0,0 +1,18 @@
+# $FreeBSD$
+# Autogenerated - do NOT edit!
+
+DIRDEPS = \
+	gnu/lib/csu \
+	gnu/lib/libgcc \
+	include \
+	include/xlocale \
+	lib/${CSU_DIR} \
+	lib/libc \
+	lib/libcompiler_rt \
+
+
+.include <dirdeps.mk>
+
+.if ${DEP_RELDIR} == ${_DEP_RELDIR}
+# local dependencies - needed for -jN in clean tree
+.endif
diff --git a/external/libnv/common_impl.h b/external/libnv/common_impl.h
index 04bd4533..5af4db2b 100644
--- a/external/libnv/common_impl.h
+++ b/external/libnv/common_impl.h
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/lib/libnv/common_impl.h 258065 2013-11-12 19:39:14Z pjd $
+ * $FreeBSD$
  */
 
 #ifndef	_COMMON_IMPL_H_
diff --git a/external/libnv/msgio.c b/external/libnv/msgio.c
index 93c736ed..27620a18 100644
--- a/external/libnv/msgio.c
+++ b/external/libnv/msgio.c
@@ -29,7 +29,7 @@
  */
 
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: head/lib/libnv/msgio.c 271578 2014-09-14 09:27:12Z pjd $");
+__FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/socket.h>
diff --git a/external/libnv/msgio.h b/external/libnv/msgio.h
index 8d888d47..fd5e462a 100644
--- a/external/libnv/msgio.h
+++ b/external/libnv/msgio.h
@@ -28,7 +28,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/lib/libnv/msgio.h 259430 2013-12-15 22:58:09Z pjd $
+ * $FreeBSD$
  */
 
 #ifndef	_MSGIO_H_
diff --git a/external/libnv/nv.3 b/external/libnv/nv.3
deleted file mode 100644
index dd9a661a..00000000
--- a/external/libnv/nv.3
+++ /dev/null
@@ -1,644 +0,0 @@
-.\"
-.\" Copyright (c) 2013 The FreeBSD Foundation
-.\" All rights reserved.
-.\"
-.\" This documentation was written by Pawel Jakub Dawidek under sponsorship
-.\" 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 AUTHOR 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 AUTHOR 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.
-.\"
-.\" $FreeBSD: head/lib/libnv/nv.3 279434 2015-03-01 00:22:23Z rstone $
-.\"
-.Dd January 30, 2015
-.Dt NV 3
-.Os
-.Sh NAME
-.Nm nvlist_create ,
-.Nm nvlist_destroy ,
-.Nm nvlist_error ,
-.Nm nvlist_set_error ,
-.Nm nvlist_empty ,
-.Nm nvlist_exists ,
-.Nm nvlist_free ,
-.Nm nvlist_clone ,
-.Nm nvlist_dump ,
-.Nm nvlist_fdump ,
-.Nm nvlist_size ,
-.Nm nvlist_pack ,
-.Nm nvlist_unpack ,
-.Nm nvlist_send ,
-.Nm nvlist_recv ,
-.Nm nvlist_xfer ,
-.Nm nvlist_next ,
-.Nm nvlist_add ,
-.Nm nvlist_move ,
-.Nm nvlist_get ,
-.Nm nvlist_take
-.Nd "library for name/value pairs"
-.Sh LIBRARY
-.Lb libnv
-.Sh SYNOPSIS
-.In nv.h
-.Ft "nvlist_t *"
-.Fn nvlist_create "int flags"
-.Ft void
-.Fn nvlist_destroy "nvlist_t *nvl"
-.Ft int
-.Fn nvlist_error "const nvlist_t *nvl"
-.Ft void
-.Fn nvlist_set_error "nvlist_t *nvl, int error"
-.Ft bool
-.Fn nvlist_empty "const nvlist_t *nvl"
-.\"
-.Ft "nvlist_t *"
-.Fn nvlist_clone "const nvlist_t *nvl"
-.\"
-.Ft void
-.Fn nvlist_dump "const nvlist_t *nvl, int fd"
-.Ft void
-.Fn nvlist_fdump "const nvlist_t *nvl, FILE *fp"
-.\"
-.Ft size_t
-.Fn nvlist_size "const nvlist_t *nvl"
-.Ft "void *"
-.Fn nvlist_pack "const nvlist_t *nvl" "size_t *sizep"
-.Ft "nvlist_t *"
-.Fn nvlist_unpack "const void *buf" "size_t size"
-.\"
-.Ft int
-.Fn nvlist_send "int sock" "const nvlist_t *nvl"
-.Ft "nvlist_t *"
-.Fn nvlist_recv "int sock"
-.Ft "nvlist_t *"
-.Fn nvlist_xfer "int sock" "nvlist_t *nvl"
-.\"
-.Ft "const char *"
-.Fn nvlist_next "const nvlist_t *nvl" "int *typep" "void **cookiep"
-.\"
-.Ft bool
-.Fn nvlist_exists "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_type "const nvlist_t *nvl" "const char *name" "int type"
-.Ft bool
-.Fn nvlist_exists_null "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_bool "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_number "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_string "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_nvlist "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_descriptor "const nvlist_t *nvl" "const char *name"
-.Ft bool
-.Fn nvlist_exists_binary "const nvlist_t *nvl" "const char *name"
-.\"
-.Ft void
-.Fn nvlist_add_null "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_add_bool "nvlist_t *nvl" "const char *name" "bool value"
-.Ft void
-.Fn nvlist_add_number "nvlist_t *nvl" "const char *name" "uint64_t value"
-.Ft void
-.Fn nvlist_add_string "nvlist_t *nvl" "const char *name" "const char *value"
-.Ft void
-.Fn nvlist_add_stringf "nvlist_t *nvl" "const char *name" "const char *valuefmt" "..."
-.Ft void
-.Fn nvlist_add_stringv "nvlist_t *nvl" "const char *name" "const char *valuefmt" "va_list valueap"
-.Ft void
-.Fn nvlist_add_nvlist "nvlist_t *nvl" "const char *name" "const nvlist_t *value"
-.Ft void
-.Fn nvlist_add_descriptor "nvlist_t *nvl" "const char *name" "int value"
-.Ft void
-.Fn nvlist_add_binary "nvlist_t *nvl" "const char *name" "const void *value" "size_t size"
-.\"
-.Ft void
-.Fn nvlist_move_string "nvlist_t *nvl" "const char *name" "char *value"
-.Ft void
-.Fn nvlist_move_nvlist "nvlist_t *nvl" "const char *name" "nvlist_t *value"
-.Ft void
-.Fn nvlist_move_descriptor "nvlist_t *nvl" "const char *name" "int value"
-.Ft void
-.Fn nvlist_move_binary "nvlist_t *nvl" "const char *name" "void *value" "size_t size"
-.\"
-.Ft bool
-.Fn nvlist_get_bool "const nvlist_t *nvl" "const char *name"
-.Ft uint64_t
-.Fn nvlist_get_number "const nvlist_t *nvl" "const char *name"
-.Ft "const char *"
-.Fn nvlist_get_string "const nvlist_t *nvl" "const char *name"
-.Ft "const nvlist_t *"
-.Fn nvlist_get_nvlist "const nvlist_t *nvl" "const char *name"
-.Ft int
-.Fn nvlist_get_descriptor "const nvlist_t *nvl" "const char *name"
-.Ft "const void *"
-.Fn nvlist_get_binary "const nvlist_t *nvl" "const char *name" "size_t *sizep"
-.Ft "const nvlist_t *"
-.Fn nvlist_get_parent "const nvlist_t *nvl" "void **cookiep"
-.\"
-.Ft bool
-.Fn nvlist_take_bool "nvlist_t *nvl" "const char *name"
-.Ft uint64_t
-.Fn nvlist_take_number "nvlist_t *nvl" "const char *name"
-.Ft "char *"
-.Fn nvlist_take_string "nvlist_t *nvl" "const char *name"
-.Ft "nvlist_t *"
-.Fn nvlist_take_nvlist "nvlist_t *nvl" "const char *name"
-.Ft int
-.Fn nvlist_take_descriptor "nvlist_t *nvl" "const char *name"
-.Ft "void *"
-.Fn nvlist_take_binary "nvlist_t *nvl" "const char *name" "size_t *sizep"
-.\"
-.Ft void
-.Fn nvlist_free "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_type "nvlist_t *nvl" "const char *name" "int type"
-.\"
-.Ft void
-.Fn nvlist_free_null "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_bool "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_number "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_string "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_nvlist "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_descriptor "nvlist_t *nvl" "const char *name"
-.Ft void
-.Fn nvlist_free_binary "nvlist_t *nvl" "const char *name"
-.Sh DESCRIPTION
-The
-.Nm libnv
-library allows to easily manage name value pairs as well as send and receive
-them over sockets.
-A group (list) of name value pairs is called an
-.Nm nvlist .
-The API supports the following data types:
-.Bl -ohang -offset indent
-.It Sy null ( NV_TYPE_NULL )
-There is no data associated with the name.
-.It Sy bool ( NV_TYPE_BOOL )
-The value can be either
-.Dv true
-or
-.Dv false .
-.It Sy number ( NV_TYPE_NUMBER )
-The value is a number stored as
-.Vt uint64_t .
-.It Sy string ( NV_TYPE_STRING )
-The value is a C string.
-.It Sy nvlist ( NV_TYPE_NVLIST )
-The value is a nested nvlist.
-.It Sy descriptor ( NV_TYPE_DESCRIPTOR )
-The value is a file descriptor.
-Note that file descriptors can be sent only over
-.Xr unix 4
-domain sockets.
-.It Sy binary ( NV_TYPE_BINARY )
-The value is a binary buffer.
-.El
-.Pp
-The
-.Fn nvlist_create
-function allocates memory and initializes an nvlist.
-.Pp
-The following flag can be provided:
-.Pp
-.Bl -tag -width "NV_FLAG_IGNORE_CASE" -compact -offset indent
-.It Dv NV_FLAG_IGNORE_CASE
-Perform case-insensitive lookups of provided names.
-.El
-.Pp
-The
-.Fn nvlist_destroy
-function destroys the given nvlist.
-Function does nothing if
-.Dv NULL
-nvlist is provided.
-Function never modifies the
-.Va errno
-global variable.
-.Pp
-The
-.Fn nvlist_error
-function returns any error value that the nvlist accumulated.
-If the given nvlist is
-.Dv NULL
-the
-.Er ENOMEM
-error will be returned.
-.Pp
-The
-.Fn nvlist_set_error
-function sets an nvlist to be in the error state.
-Subsequent calls to
-.Fn nvlist_error
-will return the given error value.
-This function cannot be used to clear the error state from an nvlist.
-This function does nothing if the nvlist is already in the error state.
-.Pp
-The
-.Fn nvlist_empty
-function returns
-.Dv true
-if the given nvlist is empty and
-.Dv false
-otherwise.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_clone
-functions clones the given nvlist.
-The clone shares no resources with its origin.
-This also means that all file descriptors that are part of the nvlist will be
-duplicated with the
-.Xr dup 2
-system call before placing them in the clone.
-.Pp
-The
-.Fn nvlist_dump
-dumps nvlist content for debugging purposes to the given file descriptor
-.Fa fd .
-.Pp
-The
-.Fn nvlist_fdump
-dumps nvlist content for debugging purposes to the given file stream
-.Fa fp .
-.Pp
-The
-.Fn nvlist_size
-function returns the size of the given nvlist after converting it to binary
-buffer with the
-.Fn nvlist_pack
-function.
-.Pp
-The
-.Fn nvlist_pack
-function converts the given nvlist to a binary buffer.
-The function allocates memory for the buffer, which should be freed with the
-.Xr free 3
-function.
-If the
-.Fa sizep
-argument is not
-.Dv NULL ,
-the size of the buffer will be stored there.
-The function returns
-.Dv NULL
-in case of an error (allocation failure).
-If the nvlist contains any file descriptors
-.Dv NULL
-will be returned.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_unpack
-function converts the given buffer to the nvlist.
-The function returns
-.Dv NULL
-in case of an error.
-.Pp
-The
-.Fn nvlist_send
-function sends the given nvlist over the socket given by the
-.Fa sock
-argument.
-Note that nvlist that contains file descriptors can only be send over
-.Xr unix 4
-domain sockets.
-.Pp
-The
-.Fn nvlist_recv
-function receives nvlist over the socket given by the
-.Fa sock
-argument.
-.Pp
-The
-.Fn nvlist_xfer
-function sends the given nvlist over the socket given by the
-.Fa sock
-argument and receives nvlist over the same socket.
-The given nvlist is always destroyed.
-.Pp
-The
-.Fn nvlist_next
-function iterates over the given nvlist returning names and types of subsequent
-elements.
-The
-.Fa cookiep
-argument allows the function to figure out which element should be returned
-next.
-The
-.Va *cookiep
-should be set to
-.Dv NULL
-for the first call and should not be changed later.
-Returning
-.Dv NULL
-means there are no more elements on the nvlist.
-The
-.Fa typep
-argument can be NULL.
-Elements may not be removed from the nvlist while traversing it.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_exists
-function returns
-.Dv true
-if element of the given name exists (besides of its type) or
-.Dv false
-otherwise.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_exists_type
-function returns
-.Dv true
-if element of the given name and the given type exists or
-.Dv false
-otherwise.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_exists_null ,
-.Fn nvlist_exists_bool ,
-.Fn nvlist_exists_number ,
-.Fn nvlist_exists_string ,
-.Fn nvlist_exists_nvlist ,
-.Fn nvlist_exists_descriptor ,
-.Fn nvlist_exists_binary
-functions return
-.Dv true
-if element of the given name and the given type determined by the function name
-exists or
-.Dv false
-otherwise.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_add_null ,
-.Fn nvlist_add_bool ,
-.Fn nvlist_add_number ,
-.Fn nvlist_add_string ,
-.Fn nvlist_add_stringf ,
-.Fn nvlist_add_stringv ,
-.Fn nvlist_add_nvlist ,
-.Fn nvlist_add_descriptor ,
-.Fn nvlist_add_binary
-functions add element to the given nvlist.
-When adding string or binary buffor the functions will allocate memory
-and copy the data over.
-When adding nvlist, the nvlist will be cloned and clone will be added.
-When adding descriptor, the descriptor will be duplicated using the
-.Xr dup 2
-system call and the new descriptor will be added.
-If an error occurs while adding new element, internal error is set which can be
-examined using the
-.Fn nvlist_error
-function.
-.Pp
-The
-.Fn nvlist_move_string ,
-.Fn nvlist_move_nvlist ,
-.Fn nvlist_move_descriptor ,
-.Fn nvlist_move_binary
-functions add new element to the given nvlist, but unlike
-.Fn nvlist_add_<type>
-functions they will consume the given resource.
-If an error occurs while adding new element, the resource is destroyed and
-internal error is set which can be examined using the
-.Fn nvlist_error
-function.
-.Pp
-The
-.Fn nvlist_get_bool ,
-.Fn nvlist_get_number ,
-.Fn nvlist_get_string ,
-.Fn nvlist_get_nvlist ,
-.Fn nvlist_get_descriptor ,
-.Fn nvlist_get_binary
-functions allow to obtain value of the given name.
-In case of string, nvlist, descriptor or binary, returned resource should
-not be modified - it still belongs to the nvlist.
-If element of the given name does not exist, the program will be aborted.
-To avoid that the caller should check for existence before trying to obtain
-the value or use
-.Xr dnvlist 3
-extension, which allows to provide default value for a missing element.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_get_parent
-function allows to obtain the parent nvlist from the nested nvlist.
-.Pp
-The
-.Fn nvlist_take_bool ,
-.Fn nvlist_take_number ,
-.Fn nvlist_take_string ,
-.Fn nvlist_take_nvlist ,
-.Fn nvlist_take_descriptor ,
-.Fn nvlist_take_binary
-functions return value associated with the given name and remove the element
-from the nvlist.
-In case of string and binary values, the caller is responsible for free returned
-memory using the
-.Xr free 3
-function.
-In case of nvlist, the caller is responsible for destroying returned nvlist
-using the
-.Fn nvlist_destroy
-function.
-In case of descriptor, the caller is responsible for closing returned descriptor
-using the
-.Fn close 2
-system call.
-If element of the given name does not exist, the program will be aborted.
-To avoid that the caller should check for existence before trying to obtain
-the value or use
-.Xr dnvlist 3
-extension, which allows to provide default value for a missing element.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_free
-function removes element of the given name from the nvlist (besides of its type)
-and frees all resources associated with it.
-If element of the given name does not exist, the program will be aborted.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_free_type
-function removes element of the given name and the given type from the nvlist
-and frees all resources associated with it.
-If element of the given name and the given type does not exist, the program
-will be aborted.
-The nvlist must not be in error state.
-.Pp
-The
-.Fn nvlist_free_null ,
-.Fn nvlist_free_bool ,
-.Fn nvlist_free_number ,
-.Fn nvlist_free_string ,
-.Fn nvlist_free_nvlist ,
-.Fn nvlist_free_descriptor ,
-.Fn nvlist_free_binary
-functions remove element of the given name and the given type determined by the
-function name from the nvlist and free all resources associated with it.
-If element of the given name and the given type does not exist, the program
-will be aborted.
-The nvlist must not be in error state.
-.Sh EXAMPLES
-The following example demonstrates how to prepare an nvlist and send it over
-.Xr unix 4
-domain socket.
-.Bd -literal
-nvlist_t *nvl;
-int fd;
-
-fd = open("/tmp/foo", O_RDONLY);
-if (fd < 0)
-        err(1, "open(\\"/tmp/foo\\") failed");
-
-nvl = nvlist_create(0);
-/*
- * There is no need to check if nvlist_create() succeeded,
- * as the nvlist_add_<type>() functions can cope.
- * If it failed, nvlist_send() will fail.
- */
-nvlist_add_string(nvl, "filename", "/tmp/foo");
-nvlist_add_number(nvl, "flags", O_RDONLY);
-/*
- * We just want to send the descriptor, so we can give it
- * for the nvlist to consume (that's why we use nvlist_move
- * not nvlist_add).
- */
-nvlist_move_descriptor(nvl, "fd", fd);
-if (nvlist_send(sock, nvl) < 0) {
-	nvlist_destroy(nvl);
-	err(1, "nvlist_send() failed");
-}
-nvlist_destroy(nvl);
-.Ed
-.Pp
-Receiving nvlist and getting data:
-.Bd -literal
-nvlist_t *nvl;
-const char *command;
-char *filename;
-int fd;
-
-nvl = nvlist_recv(sock);
-if (nvl == NULL)
-	err(1, "nvlist_recv() failed");
-
-/* For command we take pointer to nvlist's buffer. */
-command = nvlist_get_string(nvl, "command");
-/*
- * For filename we remove it from the nvlist and take
- * ownership of the buffer.
- */
-filename = nvlist_take_string(nvl, "filename");
-/* The same for the descriptor. */
-fd = nvlist_take_descriptor(nvl, "fd");
-
-printf("command=%s filename=%s fd=%d\n", command, filename, fd);
-
-nvlist_destroy(nvl);
-free(filename);
-close(fd);
-/* command was freed by nvlist_destroy() */
-.Ed
-.Pp
-Iterating over nvlist:
-.Bd -literal
-nvlist_t *nvl;
-const char *name;
-void *cookie;
-int type;
-
-nvl = nvlist_recv(sock);
-if (nvl == NULL)
-	err(1, "nvlist_recv() failed");
-
-cookie = NULL;
-while ((name = nvlist_next(nvl, &type, &cookie)) != NULL) {
-	printf("%s=", name);
-	switch (type) {
-	case NV_TYPE_NUMBER:
-		printf("%ju", (uintmax_t)nvlist_get_number(nvl, name));
-		break;
-	case NV_TYPE_STRING:
-		printf("%s", nvlist_get_string(nvl, name));
-		break;
-	default:
-		printf("N/A");
-		break;
-	}
-	printf("\\n");
-}
-.Ed
-.Pp
-Iterating over every nested nvlist:
-.Bd -literal
-nvlist_t *nvl;
-const char *name;
-void *cookie;
-int type;
-
-nvl = nvlist_recv(sock);
-if (nvl == NULL)
-	err(1, "nvlist_recv() failed");
-
-cookie = NULL;
-do {
-	while ((name = nvlist_next(nvl, &type, &cookie)) != NULL) {
-		if (type == NV_TYPE_NVLIST) {
-			nvl = nvlist_get_nvlist(nvl, name);
-			cookie = NULL;
-		}
-	}
-} while ((nvl = nvlist_get_parent(nvl, &cookie)) != NULL);
-.Ed
-.Sh SEE ALSO
-.Xr close 2 ,
-.Xr dup 2 ,
-.Xr open 2 ,
-.Xr err 3 ,
-.Xr free 3 ,
-.Xr printf 3 ,
-.Xr unix 4
-.Sh HISTORY
-The
-.Nm libnv
-library appeared in
-.Fx 11.0 .
-.Sh AUTHORS
-.An -nosplit
-The
-.Nm libnv
-library was implemented by
-.An Pawel Jakub Dawidek Aq Mt pawel@dawidek.net
-under sponsorship from the FreeBSD Foundation.
diff --git a/external/libnv/subr_dnvlist.c b/external/libnv/subr_dnvlist.c
deleted file mode 100644
index 01618a04..00000000
--- a/external/libnv/subr_dnvlist.c
+++ /dev/null
@@ -1,294 +0,0 @@
-/*-
- * 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: head/sys/kern/subr_dnvlist.c 279439 2015-03-01 00:34:27Z rstone $");
-
-#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);
-}
-
-#ifndef _KERNEL
-#define	DNVLIST_GETF(ftype, type)					\
-ftype									\
-dnvlist_getf_##type(const nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, ...)						\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = dnvlist_getv_##type(nvl, defval, namefmt, nameap);	\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-DNVLIST_GETF(bool, bool)
-DNVLIST_GETF(uint64_t, number)
-DNVLIST_GETF(const char *, string)
-DNVLIST_GETF(const nvlist_t *, nvlist)
-DNVLIST_GETF(int, descriptor)
-
-#undef	DNVLIST_GETF
-
-const void *
-dnvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const void *defval,
-    size_t defsize, const char *namefmt, ...)
-{
-	va_list nameap;
-	const void *value;
-
-	va_start(nameap, namefmt);
-	value = dnvlist_getv_binary(nvl, sizep, defval, defsize, namefmt,
-	    nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	DNVLIST_GETV(ftype, type)					\
-ftype									\
-dnvlist_getv_##type(const nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, va_list nameap)				\
-{									\
-	char *name;							\
-	ftype value;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		return (defval);					\
-	value = dnvlist_get_##type(nvl, name, defval);			\
-	free(name);							\
-	return (value);							\
-}
-
-DNVLIST_GETV(bool, bool)
-DNVLIST_GETV(uint64_t, number)
-DNVLIST_GETV(const char *, string)
-DNVLIST_GETV(const nvlist_t *, nvlist)
-DNVLIST_GETV(int, descriptor)
-
-#undef	DNVLIST_GETV
-
-const void *
-dnvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const void *defval,
-    size_t defsize, const char *namefmt, va_list nameap)
-{
-	char *name;
-	const void *value;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name != NULL) {
-		value = dnvlist_get_binary(nvl, name, sizep, defval, defsize);
-		nv_free(name);
-	} else {
-		if (sizep != NULL)
-			*sizep = defsize;
-		value = defval;
-	}
-	return (value);
-}
-#endif
-
-#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);
-}
-
-#ifndef _KERNEL
-#define	DNVLIST_TAKEF(ftype, type)					\
-ftype									\
-dnvlist_takef_##type(nvlist_t *nvl, ftype defval,			\
-    const char *namefmt, ...)						\
-{									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = dnvlist_takev_##type(nvl, defval, namefmt, nameap);	\
-	va_end(nameap);							\
-									\
-	return (value);							\
-}
-
-DNVLIST_TAKEF(bool, bool)
-DNVLIST_TAKEF(uint64_t, number)
-DNVLIST_TAKEF(char *, string)
-DNVLIST_TAKEF(nvlist_t *, nvlist)
-DNVLIST_TAKEF(int, descriptor)
-
-#undef	DNVLIST_TAKEF
-
-void *
-dnvlist_takef_binary(nvlist_t *nvl, size_t *sizep, void *defval,
-    size_t defsize, const char *namefmt, ...)
-{
-	va_list nameap;
-	void *value;
-
-	va_start(nameap, namefmt);
-	value = dnvlist_takev_binary(nvl, sizep, defval, defsize, namefmt,
-	    nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	DNVLIST_TAKEV(ftype, type)					\
-ftype									\
-dnvlist_takev_##type(nvlist_t *nvl, ftype defval, const char *namefmt,	\
-    va_list nameap)							\
-{									\
-	char *name;							\
-	ftype value;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		return (defval);					\
-	value = dnvlist_take_##type(nvl, name, defval);			\
-	free(name);							\
-	return (value);							\
-}
-
-DNVLIST_TAKEV(bool, bool)
-DNVLIST_TAKEV(uint64_t, number)
-DNVLIST_TAKEV(char *, string)
-DNVLIST_TAKEV(nvlist_t *, nvlist)
-DNVLIST_TAKEV(int, descriptor)
-
-#undef	DNVLIST_TAKEV
-
-void *
-dnvlist_takev_binary(nvlist_t *nvl, size_t *sizep, void *defval,
-    size_t defsize, const char *namefmt, va_list nameap)
-{
-	char *name;
-	void *value;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name != NULL) {
-		value = dnvlist_take_binary(nvl, name, sizep, defval, defsize);
-		nv_free(name);
-	} else {
-		if (sizep != NULL)
-			*sizep = defsize;
-		value = defval;
-	}
-
-	return (value);
-}
-#endif
diff --git a/external/libnv/sys/dnv.h b/external/libnv/sys/dnv.h
index fcf0512f..679a51f8 100644
--- a/external/libnv/sys/dnv.h
+++ b/external/libnv/sys/dnv.h
@@ -26,7 +26,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/sys/sys/dnv.h 279439 2015-03-01 00:34:27Z rstone $
+ * $FreeBSD$
  */
 
 #ifndef	_DNV_H_
@@ -37,6 +37,7 @@
 #ifndef _KERNEL
 #include <stdarg.h>
 #include <stdbool.h>
+#include <stddef.h>
 #include <stdint.h>
 #endif
 
@@ -64,22 +65,6 @@ const nvlist_t *dnvlist_get_nvlist(const nvlist_t *nvl, const char *name, const
 int dnvlist_get_descriptor(const nvlist_t *nvl, const char *name, int defval);
 const void *dnvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep, const void *defval, size_t defsize);
 
-#ifndef _KERNEL
-bool dnvlist_getf_bool(const nvlist_t *nvl, bool defval, const char *namefmt, ...) __printflike(3, 4);
-uint64_t dnvlist_getf_number(const nvlist_t *nvl, uint64_t defval, const char *namefmt, ...) __printflike(3, 4);
-const char *dnvlist_getf_string(const nvlist_t *nvl, const char *defval, const char *namefmt, ...) __printflike(3, 4);
-const nvlist_t *dnvlist_getf_nvlist(const nvlist_t *nvl, const nvlist_t *defval, const char *namefmt, ...) __printflike(3, 4);
-int dnvlist_getf_descriptor(const nvlist_t *nvl, int defval, const char *namefmt, ...) __printflike(3, 4);
-const void *dnvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const void *defval, size_t defsize, const char *namefmt, ...) __printflike(5, 6);
-
-bool dnvlist_getv_bool(const nvlist_t *nvl, bool defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-uint64_t dnvlist_getv_number(const nvlist_t *nvl, uint64_t defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const char *dnvlist_getv_string(const nvlist_t *nvl, const char *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const nvlist_t *dnvlist_getv_nvlist(const nvlist_t *nvl, const nvlist_t *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-int dnvlist_getv_descriptor(const nvlist_t *nvl, int defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-const void *dnvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const void *defval, size_t defsize, const char *namefmt, va_list nameap) __printflike(5, 0);
-#endif
-
 /*
  * The dnvlist_take functions returns value associated with the given name and
  * remove corresponding nvpair.
@@ -95,22 +80,6 @@ nvlist_t *dnvlist_take_nvlist(nvlist_t *nvl, const char *name, nvlist_t *defval)
 int dnvlist_take_descriptor(nvlist_t *nvl, const char *name, int defval);
 void *dnvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep, void *defval, size_t defsize);
 
-#ifndef _KERNEL
-bool dnvlist_takef_bool(nvlist_t *nvl, bool defval, const char *namefmt, ...) __printflike(3, 4);
-uint64_t dnvlist_takef_number(nvlist_t *nvl, uint64_t defval, const char *namefmt, ...) __printflike(3, 4);
-char *dnvlist_takef_string(nvlist_t *nvl, char *defval, const char *namefmt, ...) __printflike(3, 4);
-nvlist_t *dnvlist_takef_nvlist(nvlist_t *nvl, nvlist_t *defval, const char *namefmt, ...) __printflike(3, 4);
-int dnvlist_takef_descriptor(nvlist_t *nvl, int defval, const char *namefmt, ...) __printflike(3, 4);
-void *dnvlist_takef_binary(nvlist_t *nvl, size_t *sizep, void *defval, size_t defsize, const char *namefmt, ...) __printflike(5, 6);
-
-bool dnvlist_takev_bool(nvlist_t *nvl, bool defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-uint64_t dnvlist_takev_number(nvlist_t *nvl, uint64_t defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-char *dnvlist_takev_string(nvlist_t *nvl, char *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-nvlist_t *dnvlist_takev_nvlist(nvlist_t *nvl, nvlist_t *defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-int dnvlist_takev_descriptor(nvlist_t *nvl, int defval, const char *namefmt, va_list nameap) __printflike(3, 0);
-void *dnvlist_takev_binary(nvlist_t *nvl, size_t *sizep, void *defval, size_t defsize, const char *namefmt, va_list nameap) __printflike(5, 0);
-#endif
-
 __END_DECLS
 
 #endif	/* !_DNV_H_ */
diff --git a/external/libnv/sys/dnvlist.c b/external/libnv/sys/dnvlist.c
new file mode 100644
index 00000000..c2106c5a
--- /dev/null
+++ b/external/libnv/sys/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/dnv.h>
+#include <sys/nv.h>
+
+#include "nv_impl.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/external/libnv/sys/nv.h b/external/libnv/sys/nv.h
index fd4e3725..fcea2b3e 100644
--- a/external/libnv/sys/nv.h
+++ b/external/libnv/sys/nv.h
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -26,7 +27,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/sys/sys/nv.h 279439 2015-03-01 00:34:27Z rstone $
+ * $FreeBSD$
  */
 
 #ifndef	_NV_H_
@@ -59,11 +60,20 @@ typedef struct nvlist nvlist_t;
 #define	NV_TYPE_NVLIST			5
 #define	NV_TYPE_DESCRIPTOR		6
 #define	NV_TYPE_BINARY			7
+#define	NV_TYPE_BOOL_ARRAY		8
+#define	NV_TYPE_NUMBER_ARRAY		9
+#define	NV_TYPE_STRING_ARRAY		10
+#define	NV_TYPE_NVLIST_ARRAY		11
+#define	NV_TYPE_DESCRIPTOR_ARRAY	12
 
 /*
  * Perform case-insensitive lookups of provided names.
  */
 #define	NV_FLAG_IGNORE_CASE		0x01
+/*
+ * Names don't have to be unique.
+ */
+#define	NV_FLAG_NO_UNIQUE		0x02
 
 #if defined(_KERNEL) && defined(MALLOC_DECLARE)
 MALLOC_DECLARE(M_NVLIST);
@@ -75,6 +85,7 @@ nvlist_t	*nvlist_create(int flags);
 void		 nvlist_destroy(nvlist_t *nvl);
 int		 nvlist_error(const nvlist_t *nvl);
 bool		 nvlist_empty(const nvlist_t *nvl);
+int		 nvlist_flags(const nvlist_t *nvl);
 void		 nvlist_set_error(nvlist_t *nvl, int error);
 
 nvlist_t *nvlist_clone(const nvlist_t *nvl);
@@ -86,16 +97,21 @@ void nvlist_fdump(const nvlist_t *nvl, FILE *fp);
 
 size_t		 nvlist_size(const nvlist_t *nvl);
 void		*nvlist_pack(const nvlist_t *nvl, size_t *sizep);
-nvlist_t	*nvlist_unpack(const void *buf, size_t size);
+nvlist_t	*nvlist_unpack(const void *buf, size_t size, int flags);
 
 int nvlist_send(int sock, const nvlist_t *nvl);
-nvlist_t *nvlist_recv(int sock);
-nvlist_t *nvlist_xfer(int sock, nvlist_t *nvl);
+nvlist_t *nvlist_recv(int sock, int flags);
+nvlist_t *nvlist_xfer(int sock, nvlist_t *nvl, int flags);
 
 const char *nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep);
 
 const nvlist_t *nvlist_get_parent(const nvlist_t *nvl, void **cookiep);
 
+const nvlist_t *nvlist_get_array_next(const nvlist_t *nvl);
+bool nvlist_in_array(const nvlist_t *nvl);
+
+const nvlist_t *nvlist_get_pararr(const nvlist_t *nvl, void **cookiep);
+
 /*
  * The nvlist_exists functions check if the given name (optionally of the given
  * type) exists on nvlist.
@@ -109,10 +125,15 @@ bool nvlist_exists_bool(const nvlist_t *nvl, const char *name);
 bool nvlist_exists_number(const nvlist_t *nvl, const char *name);
 bool nvlist_exists_string(const nvlist_t *nvl, const char *name);
 bool nvlist_exists_nvlist(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_binary(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_bool_array(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_number_array(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_string_array(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_nvlist_array(const nvlist_t *nvl, const char *name);
 #ifndef _KERNEL
 bool nvlist_exists_descriptor(const nvlist_t *nvl, const char *name);
+bool nvlist_exists_descriptor_array(const nvlist_t *nvl, const char *name);
 #endif
-bool nvlist_exists_binary(const nvlist_t *nvl, const char *name);
 
 /*
  * The nvlist_add functions add the given name/value pair.
@@ -125,14 +146,19 @@ void nvlist_add_bool(nvlist_t *nvl, const char *name, bool value);
 void nvlist_add_number(nvlist_t *nvl, const char *name, uint64_t value);
 void nvlist_add_string(nvlist_t *nvl, const char *name, const char *value);
 void nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...) __printflike(3, 4);
-#ifdef _VA_LIST_DECLARED
+#if !defined(_KERNEL) || defined(_VA_LIST_DECLARED)
 void nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt, va_list valueap) __printflike(3, 0);
 #endif
 void nvlist_add_nvlist(nvlist_t *nvl, const char *name, const nvlist_t *value);
+void nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value, size_t size);
+void nvlist_add_bool_array(nvlist_t *nvl, const char *name, const bool *value, size_t nitems);
+void nvlist_add_number_array(nvlist_t *nvl, const char *name, const uint64_t *value, size_t nitems);
+void nvlist_add_string_array(nvlist_t *nvl, const char *name, const char * const *value, size_t nitems);
+void nvlist_add_nvlist_array(nvlist_t *nvl, const char *name, const nvlist_t * const *value, size_t nitems);
 #ifndef _KERNEL
 void nvlist_add_descriptor(nvlist_t *nvl, const char *name, int value);
+void nvlist_add_descriptor_array(nvlist_t *nvl, const char *name, const int *value, size_t nitems);
 #endif
-void nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value, size_t size);
 
 /*
  * The nvlist_move functions add the given name/value pair.
@@ -141,10 +167,15 @@ void nvlist_add_binary(nvlist_t *nvl, const char *name, const void *value, size_
 
 void nvlist_move_string(nvlist_t *nvl, const char *name, char *value);
 void nvlist_move_nvlist(nvlist_t *nvl, const char *name, nvlist_t *value);
+void nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size);
+void nvlist_move_bool_array(nvlist_t *nvl, const char *name, bool *value, size_t nitems);
+void nvlist_move_string_array(nvlist_t *nvl, const char *name, char **value, size_t nitems);
+void nvlist_move_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **value, size_t nitems);
+void nvlist_move_number_array(nvlist_t *nvl, const char *name, uint64_t *value, size_t nitems);
 #ifndef _KERNEL
 void nvlist_move_descriptor(nvlist_t *nvl, const char *name, int value);
+void nvlist_move_descriptor_array(nvlist_t *nvl, const char *name, int *value, size_t nitems);
 #endif
-void nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size);
 
 /*
  * The nvlist_get functions returns value associated with the given name.
@@ -152,14 +183,19 @@ void nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t siz
  * not be freed by the caller.
  */
 
-bool		 nvlist_get_bool(const nvlist_t *nvl, const char *name);
-uint64_t	 nvlist_get_number(const nvlist_t *nvl, const char *name);
-const char	*nvlist_get_string(const nvlist_t *nvl, const char *name);
-const nvlist_t	*nvlist_get_nvlist(const nvlist_t *nvl, const char *name);
+bool			 nvlist_get_bool(const nvlist_t *nvl, const char *name);
+uint64_t		 nvlist_get_number(const nvlist_t *nvl, const char *name);
+const char		*nvlist_get_string(const nvlist_t *nvl, const char *name);
+const nvlist_t		*nvlist_get_nvlist(const nvlist_t *nvl, const char *name);
+const void		*nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep);
+const bool		*nvlist_get_bool_array(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const uint64_t		*nvlist_get_number_array(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const char * const	*nvlist_get_string_array(const nvlist_t *nvl, const char *name, size_t *nitemsp);
+const nvlist_t * const	*nvlist_get_nvlist_array(const nvlist_t *nvl, const char *name, size_t *nitemsp);
 #ifndef _KERNEL
-int		 nvlist_get_descriptor(const nvlist_t *nvl, const char *name);
+int			 nvlist_get_descriptor(const nvlist_t *nvl, const char *name);
+const int		*nvlist_get_descriptor_array(const nvlist_t *nvl, const char *name, size_t *nitemsp);
 #endif
-const void	*nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep);
 
 /*
  * The nvlist_take functions returns value associated with the given name and
@@ -167,14 +203,19 @@ const void	*nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *siz
  * The caller is responsible for freeing received data.
  */
 
-bool		 nvlist_take_bool(nvlist_t *nvl, const char *name);
-uint64_t	 nvlist_take_number(nvlist_t *nvl, const char *name);
-char		*nvlist_take_string(nvlist_t *nvl, const char *name);
-nvlist_t	*nvlist_take_nvlist(nvlist_t *nvl, const char *name);
+bool		  nvlist_take_bool(nvlist_t *nvl, const char *name);
+uint64_t	  nvlist_take_number(nvlist_t *nvl, const char *name);
+char		 *nvlist_take_string(nvlist_t *nvl, const char *name);
+nvlist_t	 *nvlist_take_nvlist(nvlist_t *nvl, const char *name);
+void		 *nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep);
+bool		 *nvlist_take_bool_array(nvlist_t *nvl, const char *name, size_t *nitemsp);
+uint64_t	 *nvlist_take_number_array(nvlist_t *nvl, const char *name, size_t *nitemsp);
+char		**nvlist_take_string_array(nvlist_t *nvl, const char *name, size_t *nitemsp);
+nvlist_t	**nvlist_take_nvlist_array(nvlist_t *nvl, const char *name, size_t *nitemsp);
 #ifndef _KERNEL
 int		 nvlist_take_descriptor(nvlist_t *nvl, const char *name);
+int		 *nvlist_take_descriptor_array(nvlist_t *nvl, const char *name, size_t *nitemsp);
 #endif
-void		*nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep);
 
 /*
  * The nvlist_free functions removes the given name/value pair from the nvlist
@@ -189,134 +230,17 @@ void nvlist_free_bool(nvlist_t *nvl, const char *name);
 void nvlist_free_number(nvlist_t *nvl, const char *name);
 void nvlist_free_string(nvlist_t *nvl, const char *name);
 void nvlist_free_nvlist(nvlist_t *nvl, const char *name);
-#ifndef _KERNEL
-void nvlist_free_descriptor(nvlist_t *nvl, const char *name);
-#endif
 void nvlist_free_binary(nvlist_t *nvl, const char *name);
-
-/*
- * Below are the same functions, but which operate on format strings and
- * variable argument lists.
- *
- * Functions that are not inserting a new pair into the nvlist cannot handle
- * a failure to allocate the memory to hold the new name.  Therefore these
- * functions are not provided in the kernel.
- */
-
+void nvlist_free_bool_array(nvlist_t *nvl, const char *name);
+void nvlist_free_number_array(nvlist_t *nvl, const char *name);
+void nvlist_free_string_array(nvlist_t *nvl, const char *name);
+void nvlist_free_nvlist_array(nvlist_t *nvl, const char *name);
+void nvlist_free_binary_array(nvlist_t *nvl, const char *name);
 #ifndef _KERNEL
-bool nvlist_existsf(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_type(const nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
-
-bool nvlist_existsf_null(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_bool(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_number(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_string(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_nvlist(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_descriptor(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-bool nvlist_existsf_binary(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-bool nvlist_existsv(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_type(const nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-bool nvlist_existsv_null(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_bool(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_number(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_string(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_nvlist(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_descriptor(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-bool nvlist_existsv_binary(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-#endif
-
-void nvlist_addf_null(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_addf_bool(nvlist_t *nvl, bool value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_number(nvlist_t *nvl, uint64_t value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_string(nvlist_t *nvl, const char *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_addf_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt, ...) __printflike(3, 4);
-#ifndef _KERNEL
-void nvlist_addf_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...) __printflike(3, 4);
-#endif
-void nvlist_addf_binary(nvlist_t *nvl, const void *value, size_t size, const char *namefmt, ...) __printflike(4, 5);
-
-#if !defined(_KERNEL) || defined(_VA_LIST_DECLARED)
-void nvlist_addv_null(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_addv_bool(nvlist_t *nvl, bool value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_number(nvlist_t *nvl, uint64_t value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_string(nvlist_t *nvl, const char *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_addv_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-#ifndef _KERNEL
-void nvlist_addv_descriptor(nvlist_t *nvl, int value, const char *namefmt, va_list nameap) __printflike(3, 0);
-#endif
-void nvlist_addv_binary(nvlist_t *nvl, const void *value, size_t size, const char *namefmt, va_list nameap) __printflike(4, 0);
-#endif
-
-void nvlist_movef_string(nvlist_t *nvl, char *value, const char *namefmt, ...) __printflike(3, 4);
-void nvlist_movef_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt, ...) __printflike(3, 4);
-#ifndef _KERNEL
-void nvlist_movef_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...) __printflike(3, 4);
-#endif
-void nvlist_movef_binary(nvlist_t *nvl, void *value, size_t size, const char *namefmt, ...) __printflike(4, 5);
-
-#if !defined(_KERNEL) || defined(_VA_LIST_DECLARED)
-void nvlist_movev_string(nvlist_t *nvl, char *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-void nvlist_movev_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt, va_list nameap) __printflike(3, 0);
-#ifndef _KERNEL
-void nvlist_movev_descriptor(nvlist_t *nvl, int value, const char *namefmt, va_list nameap) __printflike(3, 0);
-#endif
-void nvlist_movev_binary(nvlist_t *nvl, void *value, size_t size, const char *namefmt, va_list nameap) __printflike(4, 0);
+void nvlist_free_descriptor(nvlist_t *nvl, const char *name);
+void nvlist_free_descriptor_array(nvlist_t *nvl, const char *name);
 #endif
 
-#ifndef _KERNEL
-bool		 nvlist_getf_bool(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-uint64_t	 nvlist_getf_number(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const char	*nvlist_getf_string(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const nvlist_t	*nvlist_getf_nvlist(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-int		 nvlist_getf_descriptor(const nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-const void	*nvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, ...) __printflike(3, 4);
-
-bool		 nvlist_getv_bool(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-uint64_t	 nvlist_getv_number(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const char	*nvlist_getv_string(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const nvlist_t	*nvlist_getv_nvlist(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-int		 nvlist_getv_descriptor(const nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-const void	*nvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-bool		 nvlist_takef_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-uint64_t	 nvlist_takef_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-char		*nvlist_takef_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-nvlist_t	*nvlist_takef_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-int		 nvlist_takef_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void		*nvlist_takef_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, ...) __printflike(3, 4);
-
-bool		 nvlist_takev_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-uint64_t	 nvlist_takev_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-char		*nvlist_takev_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvlist_t	*nvlist_takev_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-int		 nvlist_takev_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void		*nvlist_takev_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-void nvlist_freef(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_type(nvlist_t *nvl, int type, const char *namefmt, ...) __printflike(3, 4);
-
-void nvlist_freef_null(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_bool(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_number(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_string(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_nvlist(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_descriptor(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-void nvlist_freef_binary(nvlist_t *nvl, const char *namefmt, ...) __printflike(2, 3);
-
-void nvlist_freev(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_type(nvlist_t *nvl, int type, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-void nvlist_freev_null(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_bool(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_number(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_string(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_nvlist(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_descriptor(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-void nvlist_freev_binary(nvlist_t *nvl, const char *namefmt, va_list nameap) __printflike(2, 0);
-#endif /* _KERNEL */
-
 __END_DECLS
 
 #endif	/* !_NV_H_ */
diff --git a/external/libnv/sys/nv_impl.h b/external/libnv/sys/nv_impl.h
index 944ba147..b50bdf72 100644
--- a/external/libnv/sys/nv_impl.h
+++ b/external/libnv/sys/nv_impl.h
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -26,7 +27,7 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/sys/sys/nv_impl.h 279439 2015-03-01 00:34:27Z rstone $
+ * $FreeBSD$
  */
 
 #ifndef	_NV_IMPL_H_
@@ -39,25 +40,28 @@ struct nvpair;
 typedef struct nvpair nvpair_t;
 #endif
 
+#define	NV_TYPE_NVLIST_ARRAY_NEXT	254
 #define	NV_TYPE_NVLIST_UP		255
 
-#define	NV_TYPE_FIRST		NV_TYPE_NULL
-#define	NV_TYPE_LAST		NV_TYPE_BINARY
+#define	NV_TYPE_FIRST			NV_TYPE_NULL
+#define	NV_TYPE_LAST			NV_TYPE_DESCRIPTOR_ARRAY
 
-#define	NV_FLAG_BIG_ENDIAN		0x80
+#define	NV_FLAG_BIG_ENDIAN		0x080
+#define	NV_FLAG_IN_ARRAY		0x100
 
 #ifdef _KERNEL
-#define	nv_malloc(size)			malloc((size), M_NVLIST, M_NOWAIT)
+#define	nv_malloc(size)			malloc((size), M_NVLIST, M_WAITOK)
 #define	nv_calloc(n, size)		malloc((n) * (size), M_NVLIST, \
-					    M_NOWAIT | M_ZERO)
+					    M_WAITOK | M_ZERO)
 #define	nv_realloc(buf, size)		realloc((buf), (size), M_NVLIST, \
-					    M_NOWAIT)
+					    M_WAITOK)
 #define	nv_free(buf)			free((buf), M_NVLIST)
 #define	nv_strdup(buf)			strdup((buf), M_NVLIST)
 #define	nv_vasprintf(ptr, ...)		vasprintf(ptr, M_NVLIST, __VA_ARGS__)
 
-#define	SAVE_ERRNO(var)			((void)(var))
-#define	RESTORE_ERRNO(var)		((void)(var))
+#define	ERRNO_SET(var)			do { } while (0)
+#define	ERRNO_SAVE()			do { do { } while(0)
+#define	ERRNO_RESTORE()			} while (0)
 
 #define	ERRNO_OR_DEFAULT(default)	(default)
 
@@ -70,8 +74,14 @@ typedef struct nvpair nvpair_t;
 #define	nv_strdup(buf)			strdup((buf))
 #define	nv_vasprintf(ptr, ...)		vasprintf(ptr, __VA_ARGS__)
 
-#define	SAVE_ERRNO(var) 		(var) = errno
-#define	RESTORE_ERRNO(var) 		errno = (var)
+#define	ERRNO_SET(var)			do { errno = (var); } while (0)
+#define	ERRNO_SAVE()			do {				\
+						int _serrno;		\
+									\
+						_serrno = errno
+
+#define	ERRNO_RESTORE()				errno = _serrno;	\
+					} while (0)
 
 #define	ERRNO_OR_DEFAULT(default)	(errno == 0 ? (default) : errno)
 
@@ -79,6 +89,7 @@ typedef struct nvpair nvpair_t;
 
 int	*nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp);
 size_t	 nvlist_ndescriptors(const nvlist_t *nvl);
+void	 nvlist_set_flags(nvlist_t *nvl, int flags);
 
 nvpair_t *nvlist_first_nvpair(const nvlist_t *nvl);
 nvpair_t *nvlist_next_nvpair(const nvlist_t *nvl, const nvpair_t *nvp);
@@ -86,9 +97,10 @@ nvpair_t *nvlist_prev_nvpair(const nvlist_t *nvl, const nvpair_t *nvp);
 
 void nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp);
 
-void nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp);
+bool nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp);
 
 void nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent);
+void nvlist_set_array_next(nvlist_t *nvl, nvpair_t *ele);
 
 const nvpair_t *nvlist_get_nvpair(const nvlist_t *nvl, const char *name);
 
@@ -113,45 +125,34 @@ nvpair_t *nvpair_create_stringv(const char *name, const char *valuefmt, va_list
 nvpair_t *nvpair_create_nvlist(const char *name, const nvlist_t *value);
 nvpair_t *nvpair_create_descriptor(const char *name, int value);
 nvpair_t *nvpair_create_binary(const char *name, const void *value, size_t size);
+nvpair_t *nvpair_create_bool_array(const char *name, const bool *value, size_t nitems);
+nvpair_t *nvpair_create_number_array(const char *name, const uint64_t *value, size_t nitems);
+nvpair_t *nvpair_create_string_array(const char *name, const char * const *value, size_t nitems);
+nvpair_t *nvpair_create_nvlist_array(const char *name, const nvlist_t * const *value, size_t nitems);
+nvpair_t *nvpair_create_descriptor_array(const char *name, const int *value, size_t nitems);
 
 nvpair_t *nvpair_move_string(const char *name, char *value);
 nvpair_t *nvpair_move_nvlist(const char *name, nvlist_t *value);
 nvpair_t *nvpair_move_descriptor(const char *name, int value);
 nvpair_t *nvpair_move_binary(const char *name, void *value, size_t size);
-
-bool		 nvpair_get_bool(const nvpair_t *nvp);
-uint64_t	 nvpair_get_number(const nvpair_t *nvp);
-const char	*nvpair_get_string(const nvpair_t *nvp);
-const nvlist_t	*nvpair_get_nvlist(const nvpair_t *nvp);
-int		 nvpair_get_descriptor(const nvpair_t *nvp);
-const void	*nvpair_get_binary(const nvpair_t *nvp, size_t *sizep);
+nvpair_t *nvpair_move_bool_array(const char *name, bool *value, size_t nitems);
+nvpair_t *nvpair_move_nvlist_array(const char *name, nvlist_t **value, size_t nitems);
+nvpair_t *nvpair_move_descriptor_array(const char *name, int *value, size_t nitems);
+nvpair_t *nvpair_move_number_array(const char *name, uint64_t *value, size_t nitems);
+nvpair_t *nvpair_move_string_array(const char *name, char **value, size_t nitems);
+
+bool			 nvpair_get_bool(const nvpair_t *nvp);
+uint64_t		 nvpair_get_number(const nvpair_t *nvp);
+const char		*nvpair_get_string(const nvpair_t *nvp);
+const nvlist_t		*nvpair_get_nvlist(const nvpair_t *nvp);
+int			 nvpair_get_descriptor(const nvpair_t *nvp);
+const void		*nvpair_get_binary(const nvpair_t *nvp, size_t *sizep);
+const bool		*nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitemsp);
+const uint64_t		*nvpair_get_number_array(const nvpair_t *nvp, size_t *nitemsp);
+const char * const	*nvpair_get_string_array(const nvpair_t *nvp, size_t *nitemsp);
+const nvlist_t * const	*nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitemsp);
+const int		*nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitemsp);
 
 void nvpair_free(nvpair_t *nvp);
 
-nvpair_t *nvpair_createf_null(const char *namefmt, ...) __printflike(1, 2);
-nvpair_t *nvpair_createf_bool(bool value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_number(uint64_t value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_string(const char *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_nvlist(const nvlist_t *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_descriptor(int value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_createf_binary(const void *value, size_t size, const char *namefmt, ...) __printflike(3, 4);
-
-nvpair_t *nvpair_createv_null(const char *namefmt, va_list nameap) __printflike(1, 0);
-nvpair_t *nvpair_createv_bool(bool value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_number(uint64_t value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_string(const char *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_createv_binary(const void *value, size_t size, const char *namefmt, va_list nameap) __printflike(3, 0);
-
-nvpair_t *nvpair_movef_string(char *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_nvlist(nvlist_t *value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_descriptor(int value, const char *namefmt, ...) __printflike(2, 3);
-nvpair_t *nvpair_movef_binary(void *value, size_t size, const char *namefmt, ...) __printflike(3, 4);
-
-nvpair_t *nvpair_movev_string(char *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap) __printflike(2, 0);
-nvpair_t *nvpair_movev_binary(void *value, size_t size, const char *namefmt, va_list nameap) __printflike(3, 0);
-
 #endif	/* !_NV_IMPL_H_ */
diff --git a/external/libnv/subr_nvlist.c b/external/libnv/sys/nvlist.c
index d42f8357..cf8281e7 100644
--- a/external/libnv/subr_nvlist.c
+++ b/external/libnv/sys/nvlist.c
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -28,7 +29,7 @@
  */
 
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: head/sys/kern/subr_nvlist.c 279439 2015-03-01 00:34:27Z rstone $");
+__FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/endian.h>
@@ -65,9 +66,10 @@ __FBSDID("$FreeBSD: head/sys/kern/subr_nvlist.c 279439 2015-03-01 00:34:27Z rsto
 #endif
 
 #include <sys/nv.h>
-#include <sys/nv_impl.h>
-#include <sys/nvlist_impl.h>
-#include <sys/nvpair_impl.h>
+
+#include "nv_impl.h"
+#include "nvlist_impl.h"
+#include "nvpair_impl.h"
 
 #ifndef	HAVE_PJDLOG
 #ifdef _KERNEL
@@ -87,8 +89,8 @@ __FBSDID("$FreeBSD: head/sys/kern/subr_nvlist.c 279439 2015-03-01 00:34:27Z rsto
 #endif
 #endif
 
-#define	NV_FLAG_PRIVATE_MASK	(NV_FLAG_BIG_ENDIAN)
-#define	NV_FLAG_PUBLIC_MASK	(NV_FLAG_IGNORE_CASE)
+#define	NV_FLAG_PRIVATE_MASK	(NV_FLAG_BIG_ENDIAN | NV_FLAG_IN_ARRAY)
+#define	NV_FLAG_PUBLIC_MASK	(NV_FLAG_IGNORE_CASE | NV_FLAG_NO_UNIQUE)
 #define	NV_FLAG_ALL_MASK	(NV_FLAG_PRIVATE_MASK | NV_FLAG_PUBLIC_MASK)
 
 #define	NVLIST_MAGIC	0x6e766c	/* "nvl" */
@@ -97,6 +99,7 @@ struct nvlist {
 	int		 nvl_error;
 	int		 nvl_flags;
 	nvpair_t	*nvl_parent;
+	nvpair_t	*nvl_array_next;
 	struct nvl_head	 nvl_head;
 };
 
@@ -129,9 +132,12 @@ nvlist_create(int flags)
 	PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
 
 	nvl = nv_malloc(sizeof(*nvl));
+	if (nvl == NULL)
+		return (NULL);
 	nvl->nvl_error = 0;
 	nvl->nvl_flags = flags;
 	nvl->nvl_parent = NULL;
+	nvl->nvl_array_next = NULL;
 	TAILQ_INIT(&nvl->nvl_head);
 	nvl->nvl_magic = NVLIST_MAGIC;
 
@@ -142,12 +148,11 @@ void
 nvlist_destroy(nvlist_t *nvl)
 {
 	nvpair_t *nvp;
-	int serrno;
 
 	if (nvl == NULL)
 		return;
 
-	SAVE_ERRNO(serrno);
+	ERRNO_SAVE();
 
 	NVLIST_ASSERT(nvl);
 
@@ -155,10 +160,14 @@ nvlist_destroy(nvlist_t *nvl)
 		nvlist_remove_nvpair(nvl, nvp);
 		nvpair_free(nvp);
 	}
+	if (nvl->nvl_array_next != NULL)
+		nvpair_free_structure(nvl->nvl_array_next);
+	nvl->nvl_array_next = NULL;
+	nvl->nvl_parent = NULL;
 	nvl->nvl_magic = 0;
 	nv_free(nvl);
 
-	RESTORE_ERRNO(serrno);
+	ERRNO_RESTORE();
 }
 
 void
@@ -221,6 +230,59 @@ nvlist_set_parent(nvlist_t *nvl, nvpair_t *parent)
 	nvl->nvl_parent = parent;
 }
 
+void
+nvlist_set_array_next(nvlist_t *nvl, nvpair_t *ele)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	if (ele != NULL)
+		nvl->nvl_flags |= NV_FLAG_IN_ARRAY;
+	else
+		nvl->nvl_flags &= ~NV_FLAG_IN_ARRAY;
+
+	nvl->nvl_array_next = ele;
+}
+
+bool
+nvlist_in_array(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+
+	return ((nvl->nvl_flags & NV_FLAG_IN_ARRAY) != 0);
+}
+
+const nvlist_t *
+nvlist_get_array_next(const nvlist_t *nvl)
+{
+	nvpair_t *nvp;
+
+	NVLIST_ASSERT(nvl);
+
+	nvp = nvl->nvl_array_next;
+	if (nvp == NULL)
+		return (NULL);
+
+	return (nvpair_get_nvlist(nvp));
+}
+
+const nvlist_t *
+nvlist_get_pararr(const nvlist_t *nvl, void **cookiep)
+{
+	const nvlist_t *ret;
+
+	ret = nvlist_get_array_next(nvl);
+	if (ret != NULL) {
+		if (cookiep != NULL)
+			*cookiep = NULL;
+		return (ret);
+	}
+
+	ret = nvlist_get_parent(nvl, cookiep);
+	return (ret);
+}
+
 bool
 nvlist_empty(const nvlist_t *nvl)
 {
@@ -231,6 +293,26 @@ nvlist_empty(const nvlist_t *nvl)
 	return (nvlist_first_nvpair(nvl) == NULL);
 }
 
+int
+nvlist_flags(const nvlist_t *nvl)
+{
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+
+	return (nvl->nvl_flags & NV_FLAG_PUBLIC_MASK);
+}
+
+void
+nvlist_set_flags(nvlist_t *nvl, int flags)
+{
+
+	NVLIST_ASSERT(nvl);
+	PJDLOG_ASSERT(nvl->nvl_error == 0);
+
+	nvl->nvl_flags = flags;
+}
+
 static void
 nvlist_report_missing(int type, const char *name)
 {
@@ -264,7 +346,7 @@ nvlist_find(const nvlist_t *nvl, int type, const char *name)
 	}
 
 	if (nvp == NULL)
-		RESTORE_ERRNO(ENOENT);
+		ERRNO_SET(ENOENT);
 
 	return (nvp);
 }
@@ -281,37 +363,6 @@ nvlist_exists_type(const nvlist_t *nvl, const char *name, int type)
 	return (nvlist_find(nvl, type, name) != NULL);
 }
 
-#ifndef _KERNEL
-bool
-nvlist_existsf_type(const nvlist_t *nvl, int type, const char *namefmt, ...)
-{
-	va_list nameap;
-	bool ret;
-
-	va_start(nameap, namefmt);
-	ret = nvlist_existsv_type(nvl, type, namefmt, nameap);
-	va_end(nameap);
-
-	return (ret);
-}
-
-bool
-nvlist_existsv_type(const nvlist_t *nvl, int type, const char *namefmt,
-    va_list nameap)
-{
-	char *name;
-	bool exists;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name == NULL)
-		return (false);
-
-	exists = nvlist_exists_type(nvl, name, type);
-	nv_free(name);
-	return (exists);
-}
-#endif
-
 void
 nvlist_free_type(nvlist_t *nvl, const char *name, int type)
 {
@@ -329,30 +380,6 @@ nvlist_free_type(nvlist_t *nvl, const char *name, int type)
 		nvlist_report_missing(type, name);
 }
 
-#ifndef _KERNEL
-void
-nvlist_freef_type(nvlist_t *nvl, int type, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_freev_type(nvl, type, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_freev_type(nvlist_t *nvl, int type, const char *namefmt, va_list nameap)
-{
-	char *name;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name == NULL)
-		nvlist_report_missing(type, "<unknown>");
-	nvlist_free_type(nvl, name, type);
-	nv_free(name);
-}
-#endif
-
 nvlist_t *
 nvlist_clone(const nvlist_t *nvl)
 {
@@ -362,7 +389,7 @@ nvlist_clone(const nvlist_t *nvl)
 	NVLIST_ASSERT(nvl);
 
 	if (nvl->nvl_error != 0) {
-		RESTORE_ERRNO(nvl->nvl_error);
+		ERRNO_SET(nvl->nvl_error);
 		return (NULL);
 	}
 
@@ -372,7 +399,7 @@ nvlist_clone(const nvlist_t *nvl)
 		newnvp = nvpair_clone(nvp);
 		if (newnvp == NULL)
 			break;
-		nvlist_move_nvpair(newnvl, newnvp);
+		(void)nvlist_move_nvpair(newnvl, newnvp);
 	}
 	if (nvp != NULL) {
 		nvlist_destroy(newnvl);
@@ -460,17 +487,129 @@ nvlist_dump(const nvlist_t *nvl, int fd)
 			dprintf(fd, "\n");
 			break;
 		    }
+		case NV_TYPE_BOOL_ARRAY:
+		    {
+			const bool *value;
+			unsigned int ii;
+			size_t nitems;
+
+			value = nvpair_get_bool_array(nvp, &nitems);
+			dprintf(fd, " [ ");
+			for (ii = 0; ii < nitems; ii++) {
+				dprintf(fd, "%s", value[ii] ? "TRUE" : "FALSE");
+				if (ii != nitems - 1)
+					dprintf(fd, ", ");
+			}
+			dprintf(fd, " ]\n");
+			break;
+		    }
+		case NV_TYPE_STRING_ARRAY:
+		    {
+			const char * const *value;
+			unsigned int ii;
+			size_t nitems;
+
+			value = nvpair_get_string_array(nvp, &nitems);
+			dprintf(fd, " [ ");
+			for (ii = 0; ii < nitems; ii++) {
+				if (value[ii] == NULL)
+					dprintf(fd, "NULL");
+				else
+					dprintf(fd, "\"%s\"", value[ii]);
+				if (ii != nitems - 1)
+					dprintf(fd, ", ");
+			}
+			dprintf(fd, " ]\n");
+			break;
+		    }
+		case NV_TYPE_NUMBER_ARRAY:
+		    {
+			const uint64_t *value;
+			unsigned int ii;
+			size_t nitems;
+
+			value = nvpair_get_number_array(nvp, &nitems);
+			dprintf(fd, " [ ");
+			for (ii = 0; ii < nitems; ii++) {
+				dprintf(fd, "%ju (%jd) (0x%jx)",
+				    value[ii], value[ii], value[ii]);
+				if (ii != nitems - 1)
+					dprintf(fd, ", ");
+			}
+			dprintf(fd, " ]\n");
+			break;
+		    }
+		case NV_TYPE_DESCRIPTOR_ARRAY:
+		    {
+			const int *value;
+			unsigned int ii;
+			size_t nitems;
+
+			value = nvpair_get_descriptor_array(nvp, &nitems);
+			dprintf(fd, " [ ");
+			for (ii = 0; ii < nitems; ii++) {
+				dprintf(fd, "%d", value[ii]);
+				if (ii != nitems - 1)
+					dprintf(fd, ", ");
+			}
+			dprintf(fd, " ]\n");
+			break;
+		    }
+		case NV_TYPE_NVLIST_ARRAY:
+		    {
+			const nvlist_t * const *value;
+			unsigned int ii;
+			size_t nitems;
+
+			value = nvpair_get_nvlist_array(nvp, &nitems);
+			dprintf(fd, " %zu\n", nitems);
+			tmpnvl = NULL;
+			tmpnvp = NULL;
+			for (ii = 0; ii < nitems; ii++) {
+				if (nvlist_dump_error_check(value[ii], fd,
+				    level + 1)) {
+					break;
+				}
+
+				if (tmpnvl == NULL) {
+					tmpnvp = nvlist_first_nvpair(value[ii]);
+					if (tmpnvp != NULL) {
+						tmpnvl = value[ii];
+					} else {
+						dprintf(fd, "%*s,\n",
+						    (level + 1) * 4, "");
+					}
+				}
+			}
+			if (tmpnvp != NULL) {
+				nvl = tmpnvl;
+				nvp = tmpnvp;
+				level++;
+				continue;
+			}
+			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--;
+			do {
+				cookie = NULL;
+				if (nvlist_in_array(nvl))
+					dprintf(fd, "%*s,\n", level * 4, "");
+				nvl = nvlist_get_pararr(nvl, &cookie);
+				if (nvl == NULL)
+					return;
+				if (nvlist_in_array(nvl) && cookie == NULL) {
+					nvp = nvlist_first_nvpair(nvl);
+				} else {
+					nvp = cookie;
+					level--;
+				}
+			} while (nvp == NULL);
+			if (nvlist_in_array(nvl) && cookie == NULL)
+				break;
 		}
 	}
 }
@@ -491,9 +630,11 @@ size_t
 nvlist_size(const nvlist_t *nvl)
 {
 	const nvlist_t *tmpnvl;
+	const nvlist_t * const *nvlarray;
 	const nvpair_t *nvp, *tmpnvp;
 	void *cookie;
-	size_t size;
+	size_t size, nitems;
+	unsigned int ii;
 
 	NVLIST_ASSERT(nvl);
 	PJDLOG_ASSERT(nvl->nvl_error == 0);
@@ -514,16 +655,47 @@ nvlist_size(const nvlist_t *nvl)
 				nvp = tmpnvp;
 				continue;
 			}
+		} else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY) {
+			nvlarray = nvpair_get_nvlist_array(nvp, &nitems);
+			PJDLOG_ASSERT(nitems > 0);
+
+			size += (nvpair_header_size() + 1) * nitems;
+			size += sizeof(struct nvlist_header) * nitems;
+
+			tmpnvl = NULL;
+			tmpnvp = NULL;
+			for (ii = 0; ii < nitems; ii++) {
+				PJDLOG_ASSERT(nvlarray[ii]->nvl_error == 0);
+				tmpnvp = nvlist_first_nvpair(nvlarray[ii]);
+				if (tmpnvp != NULL) {
+					tmpnvl = nvlarray[ii];
+					break;
+				}
+			}
+			if (tmpnvp != NULL) {
+				nvp = tmpnvp;
+				nvl = tmpnvl;
+				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;
+			do {
+				cookie = NULL;
+				nvl = nvlist_get_pararr(nvl, &cookie);
+				if (nvl == NULL)
+					goto out;
+				if (nvlist_in_array(nvl) && cookie == NULL) {
+					nvp = nvlist_first_nvpair(nvl);
+				} else {
+					nvp = cookie;
+				}
+			} while (nvp == NULL);
+			if (nvlist_in_array(nvl) && cookie == NULL)
+				break;
 		}
 	}
 
@@ -533,27 +705,57 @@ out:
 
 #ifndef _KERNEL
 static int *
-nvlist_xdescriptors(const nvlist_t *nvl, int *descs, int level)
+nvlist_xdescriptors(const nvlist_t *nvl, int *descs)
 {
-	const nvpair_t *nvp;
+	nvpair_t *nvp;
+	const char *name;
+	int type;
 
 	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;
+	nvp = NULL;
+	do {
+		while ((name = nvlist_next(nvl, &type, (void**)&nvp)) != NULL) {
+			switch (type) {
+			case NV_TYPE_DESCRIPTOR:
+				*descs = nvpair_get_descriptor(nvp);
+				descs++;
+				break;
+			case NV_TYPE_DESCRIPTOR_ARRAY:
+			    {
+				const int *value;
+				size_t nitems;
+				unsigned int ii;
+
+				value = nvpair_get_descriptor_array(nvp,
+				    &nitems);
+				for (ii = 0; ii < nitems; ii++) {
+					*descs = value[ii];
+					descs++;
+				}
+				break;
+			    }
+			case NV_TYPE_NVLIST:
+				nvl = nvpair_get_nvlist(nvp);
+				nvp = NULL;
+				break;
+			case NV_TYPE_NVLIST_ARRAY:
+			    {
+				const nvlist_t * const *value;
+				size_t nitems;
+
+				value = nvpair_get_nvlist_array(nvp, &nitems);
+				PJDLOG_ASSERT(value != NULL);
+				PJDLOG_ASSERT(nitems > 0);
+
+				nvl = value[0];
+				nvp = NULL;
+				break;
+			    }
+			}
 		}
-	}
+	} while ((nvl = nvlist_get_pararr(nvl, (void**)&nvp)) != NULL);
 
 	return (descs);
 }
@@ -571,7 +773,7 @@ nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
 	if (fds == NULL)
 		return (NULL);
 	if (nitems > 0)
-		nvlist_xdescriptors(nvl, fds, 0);
+		nvlist_xdescriptors(nvl, fds);
 	fds[nitems] = -1;
 	if (nitemsp != NULL)
 		*nitemsp = nitems;
@@ -579,30 +781,55 @@ nvlist_descriptors(const nvlist_t *nvl, size_t *nitemsp)
 }
 #endif
 
-static size_t
-nvlist_xndescriptors(const nvlist_t *nvl, int level)
+size_t
+nvlist_ndescriptors(const nvlist_t *nvl)
 {
 #ifndef _KERNEL
-	const nvpair_t *nvp;
+	nvpair_t *nvp;
+	const char *name;
 	size_t ndescs;
+	int type;
 
 	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;
+	nvp = NULL;
+	do {
+		while ((name = nvlist_next(nvl, &type, (void**)&nvp)) != NULL) {
+			switch (type) {
+			case NV_TYPE_DESCRIPTOR:
+				ndescs++;
+				break;
+			case NV_TYPE_NVLIST:
+				nvl = nvpair_get_nvlist(nvp);
+				nvp = NULL;
+				break;
+			case NV_TYPE_NVLIST_ARRAY:
+			    {
+				const nvlist_t * const *value;
+				size_t nitems;
+
+				value = nvpair_get_nvlist_array(nvp, &nitems);
+				PJDLOG_ASSERT(value != NULL);
+				PJDLOG_ASSERT(nitems > 0);
+
+				nvl = value[0];
+				nvp = NULL;
+				break;
+			    }
+			case NV_TYPE_DESCRIPTOR_ARRAY:
+			    {
+				size_t nitems;
+
+				(void)nvpair_get_descriptor_array(nvp,
+				    &nitems);
+				ndescs += nitems;
+				break;
+			    }
+			}
 		}
-	}
+	} while ((nvl = nvlist_get_pararr(nvl, (void**)&nvp)) != NULL);
 
 	return (ndescs);
 #else
@@ -610,13 +837,6 @@ nvlist_xndescriptors(const nvlist_t *nvl, int level)
 #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)
 {
@@ -640,7 +860,7 @@ nvlist_pack_header(const nvlist_t *nvl, unsigned char *ptr, size_t *leftp)
 	return (ptr);
 }
 
-void *
+static void *
 nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 {
 	unsigned char *buf, *ptr;
@@ -652,7 +872,7 @@ nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 	NVLIST_ASSERT(nvl);
 
 	if (nvl->nvl_error != 0) {
-		RESTORE_ERRNO(nvl->nvl_error);
+		ERRNO_SET(nvl->nvl_error);
 		return (NULL);
 	}
 
@@ -672,10 +892,8 @@ nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 
 		nvpair_init_datasize(nvp);
 		ptr = nvpair_pack_header(nvp, ptr, &left);
-		if (ptr == NULL) {
-			nv_free(buf);
-			return (NULL);
-		}
+		if (ptr == NULL)
+			goto fail;
 		switch (nvpair_type(nvp)) {
 		case NV_TYPE_NULL:
 			ptr = nvpair_pack_null(nvp, ptr, &left);
@@ -693,7 +911,7 @@ nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 			tmpnvl = nvpair_get_nvlist(nvp);
 			ptr = nvlist_pack_header(tmpnvl, ptr, &left);
 			if (ptr == NULL)
-				goto out;
+				goto fail;
 			tmpnvp = nvlist_first_nvpair(tmpnvl);
 			if (tmpnvp != NULL) {
 				nvl = tmpnvl;
@@ -706,26 +924,86 @@ nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep)
 		case NV_TYPE_DESCRIPTOR:
 			ptr = nvpair_pack_descriptor(nvp, ptr, fdidxp, &left);
 			break;
+		case NV_TYPE_DESCRIPTOR_ARRAY:
+			ptr = nvpair_pack_descriptor_array(nvp, ptr, fdidxp,
+			    &left);
+			break;
 #endif
 		case NV_TYPE_BINARY:
 			ptr = nvpair_pack_binary(nvp, ptr, &left);
 			break;
+		case NV_TYPE_BOOL_ARRAY:
+			ptr = nvpair_pack_bool_array(nvp, ptr, &left);
+			break;
+		case NV_TYPE_NUMBER_ARRAY:
+			ptr = nvpair_pack_number_array(nvp, ptr, &left);
+			break;
+		case NV_TYPE_STRING_ARRAY:
+			ptr = nvpair_pack_string_array(nvp, ptr, &left);
+			break;
+		case NV_TYPE_NVLIST_ARRAY:
+		    {
+			const nvlist_t * const * value;
+			size_t nitems;
+			unsigned int ii;
+
+			tmpnvl = NULL;
+			value = nvpair_get_nvlist_array(nvp, &nitems);
+			for (ii = 0; ii < nitems; ii++) {
+				ptr = nvlist_pack_header(value[ii], ptr, &left);
+				if (ptr == NULL)
+					goto out;
+				tmpnvp = nvlist_first_nvpair(value[ii]);
+				if (tmpnvp != NULL) {
+					tmpnvl = value[ii];
+					break;
+				}
+				ptr = nvpair_pack_nvlist_array_next(ptr, &left);
+				if (ptr == NULL)
+					goto out;
+			}
+			if (tmpnvl != NULL) {
+				nvl = tmpnvl;
+				nvp = tmpnvp;
+				continue;
+			}
+			break;
+		    }
 		default:
 			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
 		}
-		if (ptr == NULL) {
-			nv_free(buf);
-			return (NULL);
-		}
+		if (ptr == NULL)
+			goto fail;
 		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;
+			do {
+				cookie = NULL;
+				if (nvlist_in_array(nvl)) {
+					ptr = nvpair_pack_nvlist_array_next(ptr,
+					    &left);
+					if (ptr == NULL)
+						goto fail;
+				}
+				nvl = nvlist_get_pararr(nvl, &cookie);
+				if (nvl == NULL)
+					goto out;
+				if (nvlist_in_array(nvl) && cookie == NULL) {
+					nvp = nvlist_first_nvpair(nvl);
+					ptr = nvlist_pack_header(nvl, ptr,
+					    &left);
+					if (ptr == NULL)
+						goto fail;
+				} else if (nvpair_type((nvpair_t *)cookie) !=
+				    NV_TYPE_NVLIST_ARRAY) {
+					ptr = nvpair_pack_nvlist_up(ptr, &left);
+					if (ptr == NULL)
+						goto fail;
+					nvp = cookie;
+				} else {
+					nvp = cookie;
+				}
+			} while (nvp == NULL);
+			if (nvlist_in_array(nvl) && cookie == NULL)
+				break;
 		}
 	}
 
@@ -733,6 +1011,9 @@ out:
 	if (sizep != NULL)
 		*sizep = size;
 	return (buf);
+fail:
+	nv_free(buf);
+	return (NULL);
 }
 
 void *
@@ -742,12 +1023,12 @@ nvlist_pack(const nvlist_t *nvl, size_t *sizep)
 	NVLIST_ASSERT(nvl);
 
 	if (nvl->nvl_error != 0) {
-		RESTORE_ERRNO(nvl->nvl_error);
+		ERRNO_SET(nvl->nvl_error);
 		return (NULL);
 	}
 
 	if (nvlist_ndescriptors(nvl) > 0) {
-		RESTORE_ERRNO(EOPNOTSUPP);
+		ERRNO_SET(EOPNOTSUPP);
 		return (NULL);
 	}
 
@@ -759,11 +1040,11 @@ nvlist_check_header(struct nvlist_header *nvlhdrp)
 {
 
 	if (nvlhdrp->nvlh_magic != NVLIST_HEADER_MAGIC) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (false);
 	}
 	if ((nvlhdrp->nvlh_flags & ~NV_FLAG_ALL_MASK) != 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (false);
 	}
 #if BYTE_ORDER == BIG_ENDIAN
@@ -785,6 +1066,7 @@ nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
     bool *isbep, size_t *leftp)
 {
 	struct nvlist_header nvlhdr;
+	int inarrayf;
 
 	if (*leftp < sizeof(nvlhdr))
 		goto failed;
@@ -806,7 +1088,8 @@ nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
 	if ((nvlhdr.nvlh_flags & ~NV_FLAG_ALL_MASK) != 0)
 		goto failed;
 
-	nvl->nvl_flags = (nvlhdr.nvlh_flags & NV_FLAG_PUBLIC_MASK);
+	inarrayf = (nvl->nvl_flags & NV_FLAG_IN_ARRAY);
+	nvl->nvl_flags = (nvlhdr.nvlh_flags & NV_FLAG_PUBLIC_MASK) | inarrayf;
 
 	ptr += sizeof(nvlhdr);
 	if (isbep != NULL)
@@ -815,23 +1098,26 @@ nvlist_unpack_header(nvlist_t *nvl, const unsigned char *ptr, size_t nfds,
 
 	return (ptr);
 failed:
-	RESTORE_ERRNO(EINVAL);
+	ERRNO_SET(EINVAL);
 	return (NULL);
 }
 
-nvlist_t *
-nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
+static nvlist_t *
+nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds,
+    int flags)
 {
 	const unsigned char *ptr;
-	nvlist_t *nvl, *retnvl, *tmpnvl;
+	nvlist_t *nvl, *retnvl, *tmpnvl, *array;
 	nvpair_t *nvp;
 	size_t left;
 	bool isbe;
 
+	PJDLOG_ASSERT((flags & ~(NV_FLAG_PUBLIC_MASK)) == 0);
+
 	left = size;
 	ptr = buf;
 
-	tmpnvl = NULL;
+	tmpnvl = array = NULL;
 	nvl = retnvl = nvlist_create(0);
 	if (nvl == NULL)
 		goto failed;
@@ -839,6 +1125,10 @@ nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
 	ptr = nvlist_unpack_header(nvl, ptr, nfds, &isbe, &left);
 	if (ptr == NULL)
 		goto failed;
+	if (nvl->nvl_flags != flags) {
+		ERRNO_SET(EILSEQ);
+		goto failed;
+	}
 
 	while (left > 0) {
 		ptr = nvpair_unpack(isbe, ptr, &left, &nvp);
@@ -860,6 +1150,8 @@ nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
 		case NV_TYPE_NVLIST:
 			ptr = nvpair_unpack_nvlist(isbe, nvp, ptr, &left, nfds,
 			    &tmpnvl);
+			if (tmpnvl == NULL || ptr == NULL)
+				goto failed;
 			nvlist_set_parent(tmpnvl, nvp);
 			break;
 #ifndef _KERNEL
@@ -867,6 +1159,10 @@ nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
 			ptr = nvpair_unpack_descriptor(isbe, nvp, ptr, &left,
 			    fds, nfds);
 			break;
+		case NV_TYPE_DESCRIPTOR_ARRAY:
+			ptr = nvpair_unpack_descriptor_array(isbe, nvp, ptr,
+			    &left, fds, nfds);
+			break;
 #endif
 		case NV_TYPE_BINARY:
 			ptr = nvpair_unpack_binary(isbe, nvp, ptr, &left);
@@ -875,13 +1171,53 @@ nvlist_xunpack(const void *buf, size_t size, const int *fds, size_t nfds)
 			if (nvl->nvl_parent == NULL)
 				goto failed;
 			nvl = nvpair_nvlist(nvl->nvl_parent);
+			nvpair_free_structure(nvp);
 			continue;
+		case NV_TYPE_NVLIST_ARRAY_NEXT:
+			if (nvl->nvl_array_next == NULL) {
+				if (nvl->nvl_parent == NULL)
+					goto failed;
+				nvl = nvpair_nvlist(nvl->nvl_parent);
+			} else {
+				nvl = __DECONST(nvlist_t *,
+				    nvlist_get_array_next(nvl));
+				ptr = nvlist_unpack_header(nvl, ptr, nfds,
+				    &isbe, &left);
+				if (ptr == NULL)
+					goto failed;
+			}
+			nvpair_free_structure(nvp);
+			continue;
+		case NV_TYPE_BOOL_ARRAY:
+			ptr = nvpair_unpack_bool_array(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_NUMBER_ARRAY:
+			ptr = nvpair_unpack_number_array(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_STRING_ARRAY:
+			ptr = nvpair_unpack_string_array(isbe, nvp, ptr, &left);
+			break;
+		case NV_TYPE_NVLIST_ARRAY:
+			ptr = nvpair_unpack_nvlist_array(isbe, nvp, ptr, &left,
+			    &array);
+			if (ptr == NULL)
+				goto failed;
+			tmpnvl = array;
+			while (array != NULL) {
+				nvlist_set_parent(array, nvp);
+				array = __DECONST(nvlist_t *,
+				    nvlist_get_array_next(array));
+			}
+			ptr = nvlist_unpack_header(tmpnvl, ptr, nfds, &isbe,
+			    &left);
+			break;
 		default:
 			PJDLOG_ABORT("Invalid type (%d).", nvpair_type(nvp));
 		}
 		if (ptr == NULL)
 			goto failed;
-		nvlist_move_nvpair(nvl, nvp);
+		if (!nvlist_move_nvpair(nvl, nvp))
+			goto failed;
 		if (tmpnvl != NULL) {
 			nvl = tmpnvl;
 			tmpnvl = NULL;
@@ -895,10 +1231,10 @@ failed:
 }
 
 nvlist_t *
-nvlist_unpack(const void *buf, size_t size)
+nvlist_unpack(const void *buf, size_t size, int flags)
 {
 
-	return (nvlist_xunpack(buf, size, NULL, 0));
+	return (nvlist_xunpack(buf, size, NULL, 0, flags));
 }
 
 #ifndef _KERNEL
@@ -909,10 +1245,10 @@ nvlist_send(int sock, const nvlist_t *nvl)
 	int *fds;
 	void *data;
 	int64_t fdidx;
-	int serrno, ret;
+	int ret;
 
 	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
+		ERRNO_SET(nvlist_error(nvl));
 		return (-1);
 	}
 
@@ -938,21 +1274,21 @@ nvlist_send(int sock, const nvlist_t *nvl)
 
 	ret = 0;
 out:
-	serrno = errno;
-	free(fds);
-	free(data);
-	errno = serrno;
+	ERRNO_SAVE();
+	nv_free(fds);
+	nv_free(data);
+	ERRNO_RESTORE();
 	return (ret);
 }
 
 nvlist_t *
-nvlist_recv(int sock)
+nvlist_recv(int sock, int flags)
 {
 	struct nvlist_header nvlhdr;
 	nvlist_t *nvl, *ret;
 	unsigned char *buf;
 	size_t nfds, size, i;
-	int serrno, *fds;
+	int *fds;
 
 	if (buf_recv(sock, &nvlhdr, sizeof(nvlhdr)) == -1)
 		return (NULL);
@@ -963,7 +1299,7 @@ nvlist_recv(int sock)
 	nfds = (size_t)nvlhdr.nvlh_descriptors;
 	size = sizeof(nvlhdr) + (size_t)nvlhdr.nvlh_size;
 
-	buf = malloc(size);
+	buf = nv_malloc(size);
 	if (buf == NULL)
 		return (NULL);
 
@@ -976,32 +1312,34 @@ nvlist_recv(int sock)
 		goto out;
 
 	if (nfds > 0) {
-		fds = malloc(nfds * sizeof(fds[0]));
+		fds = nv_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);
+	nvl = nvlist_xunpack(buf, size, fds, nfds, flags);
 	if (nvl == NULL) {
+		ERRNO_SAVE();
 		for (i = 0; i < nfds; i++)
 			close(fds[i]);
+		ERRNO_RESTORE();
 		goto out;
 	}
 
 	ret = nvl;
 out:
-	serrno = errno;
-	free(buf);
-	free(fds);
-	errno = serrno;
+	ERRNO_SAVE();
+	nv_free(buf);
+	nv_free(fds);
+	ERRNO_RESTORE();
 
 	return (ret);
 }
 
 nvlist_t *
-nvlist_xfer(int sock, nvlist_t *nvl)
+nvlist_xfer(int sock, nvlist_t *nvl, int flags)
 {
 
 	if (nvlist_send(sock, nvl) < 0) {
@@ -1009,7 +1347,7 @@ nvlist_xfer(int sock, nvlist_t *nvl)
 		return (NULL);
 	}
 	nvlist_destroy(nvl);
-	return (nvlist_recv(sock));
+	return (nvlist_recv(sock, flags));
 }
 #endif
 
@@ -1059,9 +1397,8 @@ nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep)
 	nvpair_t *nvp;
 
 	NVLIST_ASSERT(nvl);
-	PJDLOG_ASSERT(cookiep != NULL);
 
-	if (*cookiep == NULL)
+	if (cookiep == NULL || *cookiep == NULL)
 		nvp = nvlist_first_nvpair(nvl);
 	else
 		nvp = nvlist_next_nvpair(nvl, *cookiep);
@@ -1069,7 +1406,8 @@ nvlist_next(const nvlist_t *nvl, int *typep, void **cookiep)
 		return (NULL);
 	if (typep != NULL)
 		*typep = nvpair_type(nvp);
-	*cookiep = nvp;
+	if (cookiep != NULL)
+		*cookiep = nvp;
 	return (nvpair_name(nvp));
 }
 
@@ -1093,93 +1431,18 @@ NVLIST_EXISTS(bool, BOOL)
 NVLIST_EXISTS(number, NUMBER)
 NVLIST_EXISTS(string, STRING)
 NVLIST_EXISTS(nvlist, NVLIST)
+NVLIST_EXISTS(binary, BINARY)
+NVLIST_EXISTS(bool_array, BOOL_ARRAY)
+NVLIST_EXISTS(number_array, NUMBER_ARRAY)
+NVLIST_EXISTS(string_array, STRING_ARRAY)
+NVLIST_EXISTS(nvlist_array, NVLIST_ARRAY)
 #ifndef _KERNEL
 NVLIST_EXISTS(descriptor, DESCRIPTOR)
+NVLIST_EXISTS(descriptor_array, DESCRIPTOR_ARRAY)
 #endif
-NVLIST_EXISTS(binary, BINARY)
 
 #undef	NVLIST_EXISTS
 
-#ifndef _KERNEL
-bool
-nvlist_existsf(const nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-	bool ret;
-
-	va_start(nameap, namefmt);
-	ret = nvlist_existsv(nvl, namefmt, nameap);
-	va_end(nameap);
-	return (ret);
-}
-
-#define	NVLIST_EXISTSF(type)						\
-bool									\
-nvlist_existsf_##type(const nvlist_t *nvl, const char *namefmt, ...)	\
-{									\
-	va_list nameap;							\
-	bool ret;							\
-									\
-	va_start(nameap, namefmt);					\
-	ret = nvlist_existsv_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
-	return (ret);							\
-}
-
-NVLIST_EXISTSF(null)
-NVLIST_EXISTSF(bool)
-NVLIST_EXISTSF(number)
-NVLIST_EXISTSF(string)
-NVLIST_EXISTSF(nvlist)
-#ifndef _KERNEL
-NVLIST_EXISTSF(descriptor)
-#endif
-NVLIST_EXISTSF(binary)
-
-#undef	NVLIST_EXISTSF
-
-bool
-nvlist_existsv(const nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-	char *name;
-	bool exists;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name == NULL)
-		return (false);
-
-	exists = nvlist_exists(nvl, name);
-	nv_free(name);
-	return (exists);
-}
-
-#define	NVLIST_EXISTSV(type)						\
-bool									\
-nvlist_existsv_##type(const nvlist_t *nvl, const char *namefmt,		\
-    va_list nameap)							\
-{									\
-	char *name;							\
-	bool exists;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		return (false);						\
-	exists = nvlist_exists_##type(nvl, name);			\
-	free(name);							\
-	return (exists);						\
-}
-
-NVLIST_EXISTSV(null)
-NVLIST_EXISTSV(bool)
-NVLIST_EXISTSV(number)
-NVLIST_EXISTSV(string)
-NVLIST_EXISTSV(nvlist)
-NVLIST_EXISTSV(descriptor)
-NVLIST_EXISTSV(binary)
-
-#undef	NVLIST_EXISTSV
-#endif
-
 void
 nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
 {
@@ -1188,19 +1451,21 @@ nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
 	NVPAIR_ASSERT(nvp);
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
-	if (nvlist_exists(nvl, nvpair_name(nvp))) {
-		nvl->nvl_error = EEXIST;
-		RESTORE_ERRNO(nvlist_error(nvl));
-		return;
+	if ((nvl->nvl_flags & NV_FLAG_NO_UNIQUE) == 0) {
+		if (nvlist_exists(nvl, nvpair_name(nvp))) {
+			nvl->nvl_error = EEXIST;
+			ERRNO_SET(nvlist_error(nvl));
+			return;
+		}
 	}
 
 	newnvp = nvpair_clone(nvp);
 	if (newnvp == NULL) {
 		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvlist_error(nvl));
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
@@ -1208,34 +1473,6 @@ nvlist_add_nvpair(nvlist_t *nvl, const nvpair_t *nvp)
 }
 
 void
-nvlist_add_null(nvlist_t *nvl, const char *name)
-{
-
-	nvlist_addf_null(nvl, "%s", name);
-}
-
-void
-nvlist_add_bool(nvlist_t *nvl, const char *name, bool value)
-{
-
-	nvlist_addf_bool(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_number(nvlist_t *nvl, const char *name, uint64_t value)
-{
-
-	nvlist_addf_number(nvl, value, "%s", name);
-}
-
-void
-nvlist_add_string(nvlist_t *nvl, const char *name, const char *value)
-{
-
-	nvlist_addf_string(nvl, value, "%s", name);
-}
-
-void
 nvlist_add_stringf(nvlist_t *nvl, const char *name, const char *valuefmt, ...)
 {
 	va_list valueap;
@@ -1252,405 +1489,352 @@ nvlist_add_stringv(nvlist_t *nvl, const char *name, const char *valuefmt,
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		ERRNO_SET(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);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
 void
-nvlist_add_nvlist(nvlist_t *nvl, const char *name, const nvlist_t *value)
+nvlist_add_null(nvlist_t *nvl, const char *name)
 {
+	nvpair_t *nvp;
 
-	nvlist_addf_nvlist(nvl, value, "%s", name);
-}
-
-#ifndef _KERNEL
-void
-nvlist_add_descriptor(nvlist_t *nvl, const char *name, int value)
-{
+	if (nvlist_error(nvl) != 0) {
+		ERRNO_SET(nvlist_error(nvl));
+		return;
+	}
 
-	nvlist_addf_descriptor(nvl, value, "%s", name);
+	nvp = nvpair_create_null(name);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)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;
 
-	nvlist_addf_binary(nvl, value, size, "%s", name);
-}
-
-void
-nvlist_addf_null(nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_null(nvl, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_bool(nvlist_t *nvl, bool value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_bool(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_addf_number(nvlist_t *nvl, uint64_t value, const char *namefmt, ...)
-{
-	va_list nameap;
+	if (nvlist_error(nvl) != 0) {
+		ERRNO_SET(nvlist_error(nvl));
+		return;
+	}
 
-	va_start(nameap, namefmt);
-	nvlist_addv_number(nvl, value, namefmt, nameap);
-	va_end(nameap);
+	nvp = nvpair_create_binary(name, value, size);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
-void
-nvlist_addf_string(nvlist_t *nvl, const char *value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_string(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
 
-void
-nvlist_addf_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt,
-    ...)
-{
-	va_list nameap;
+#define	NVLIST_ADD(vtype, type)						\
+void									\
+nvlist_add_##type(nvlist_t *nvl, const char *name, vtype value)		\
+{									\
+	nvpair_t *nvp;							\
+									\
+	if (nvlist_error(nvl) != 0) {					\
+		ERRNO_SET(nvlist_error(nvl));				\
+		return;							\
+	}								\
+									\
+	nvp = nvpair_create_##type(name, value);			\
+	if (nvp == NULL) {						\
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);		\
+		ERRNO_SET(nvl->nvl_error);				\
+	} else {							\
+		(void)nvlist_move_nvpair(nvl, nvp);			\
+	}								\
+}
+
+NVLIST_ADD(bool, bool)
+NVLIST_ADD(uint64_t, number)
+NVLIST_ADD(const char *, string)
+NVLIST_ADD(const nvlist_t *, nvlist)
+#ifndef _KERNEL
+NVLIST_ADD(int, descriptor);
+#endif
 
-	va_start(nameap, namefmt);
-	nvlist_addv_nvlist(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
+#undef	NVLIST_ADD
 
+#define	NVLIST_ADD_ARRAY(vtype, type)					\
+void									\
+nvlist_add_##type##_array(nvlist_t *nvl, const char *name, vtype value,	\
+    size_t nitems)							\
+{									\
+	nvpair_t *nvp;							\
+									\
+	if (nvlist_error(nvl) != 0) {					\
+		ERRNO_SET(nvlist_error(nvl));				\
+		return;							\
+	}								\
+									\
+	nvp = nvpair_create_##type##_array(name, value, nitems);	\
+	if (nvp == NULL) {						\
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);		\
+		ERRNO_SET(nvl->nvl_error);				\
+	} else {							\
+		(void)nvlist_move_nvpair(nvl, nvp);			\
+	}								\
+}
+
+NVLIST_ADD_ARRAY(const bool *, bool)
+NVLIST_ADD_ARRAY(const uint64_t *, number)
+NVLIST_ADD_ARRAY(const char * const *, string)
+NVLIST_ADD_ARRAY(const nvlist_t * const *, nvlist)
 #ifndef _KERNEL
-void
-nvlist_addf_descriptor(nvlist_t *nvl, int value, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_descriptor(nvl, value, namefmt, nameap);
-	va_end(nameap);
-}
+NVLIST_ADD_ARRAY(const int *, descriptor)
 #endif
 
-void
-nvlist_addf_binary(nvlist_t *nvl, const void *value, size_t size,
-    const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_addv_binary(nvl, value, size, namefmt, nameap);
-	va_end(nameap);
-}
+#undef	NVLIST_ADD_ARRAY
 
-void
-nvlist_addv_null(nvlist_t *nvl, const char *namefmt, va_list nameap)
+bool
+nvlist_move_nvpair(nvlist_t *nvl, nvpair_t *nvp)
 {
-	nvpair_t *nvp;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvpair_nvlist(nvp) == NULL);
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
-		return;
+		nvpair_free(nvp);
+		ERRNO_SET(nvlist_error(nvl));
+		return (false);
+	}
+	if ((nvl->nvl_flags & NV_FLAG_NO_UNIQUE) == 0) {
+		if (nvlist_exists(nvl, nvpair_name(nvp))) {
+			nvpair_free(nvp);
+			nvl->nvl_error = EEXIST;
+			ERRNO_SET(nvl->nvl_error);
+			return (false);
+		}
 	}
 
-	nvp = nvpair_createv_null(namefmt, nameap);
-	if (nvp == NULL) {
-		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvl->nvl_error);
-	} else
-		nvlist_move_nvpair(nvl, nvp);
+	nvpair_insert(&nvl->nvl_head, nvp, nvl);
+	return (true);
 }
 
 void
-nvlist_addv_bool(nvlist_t *nvl, bool value, const char *namefmt, va_list nameap)
+nvlist_move_string(nvlist_t *nvl, const char *name, char *value)
 {
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		nv_free(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_bool(value, namefmt, nameap);
+	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);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
 void
-nvlist_addv_number(nvlist_t *nvl, uint64_t value, const char *namefmt,
-    va_list nameap)
+nvlist_move_nvlist(nvlist_t *nvl, const char *name, nvlist_t *value)
 {
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		if (value != NULL && nvlist_get_nvpair_parent(value) != NULL)
+			nvlist_destroy(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_number(value, namefmt, nameap);
+	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);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
+#ifndef _KERNEL
 void
-nvlist_addv_string(nvlist_t *nvl, const char *value, const char *namefmt,
-    va_list nameap)
+nvlist_move_descriptor(nvlist_t *nvl, const char *name, int value)
 {
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		close(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_string(value, namefmt, nameap);
+	nvp = nvpair_move_descriptor(name, value);
 	if (nvp == NULL) {
 		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvl->nvl_error);
-	} else
-		nvlist_move_nvpair(nvl, nvp);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
+#endif
 
 void
-nvlist_addv_nvlist(nvlist_t *nvl, const nvlist_t *value, const char *namefmt,
-    va_list nameap)
+nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size)
 {
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		nv_free(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_nvlist(value, namefmt, nameap);
+	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);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
-#ifndef _KERNEL
 void
-nvlist_addv_descriptor(nvlist_t *nvl, int value, const char *namefmt,
-    va_list nameap)
+nvlist_move_bool_array(nvlist_t *nvl, const char *name, bool *value,
+    size_t nitems)
 {
 	nvpair_t *nvp;
 
 	if (nvlist_error(nvl) != 0) {
-		errno = nvlist_error(nvl);
+		nv_free(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_descriptor(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
+	nvp = nvpair_move_bool_array(name, value, nitems);
+	if (nvp == NULL) {
+		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
-#endif
 
 void
-nvlist_addv_binary(nvlist_t *nvl, const void *value, size_t size,
-    const char *namefmt, va_list nameap)
+nvlist_move_string_array(nvlist_t *nvl, const char *name, char **value,
+    size_t nitems)
 {
 	nvpair_t *nvp;
+	size_t i;
 
 	if (nvlist_error(nvl) != 0) {
-		RESTORE_ERRNO(nvlist_error(nvl));
+		if (value != NULL) {
+			for (i = 0; i < nitems; i++)
+				nv_free(value[i]);
+			nv_free(value);
+		}
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_createv_binary(value, size, namefmt, nameap);
+	nvp = nvpair_move_string_array(name, value, nitems);
 	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;
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
 	}
-
-	nvpair_insert(&nvl->nvl_head, nvp, nvl);
 }
 
-#define	NVLIST_MOVE(vtype, type)					\
-void									\
-nvlist_move_##type(nvlist_t *nvl, const char *name, vtype value)	\
-{									\
-									\
-	nvlist_movef_##type(nvl, value, "%s", name);			\
-}
-
-NVLIST_MOVE(char *, string)
-NVLIST_MOVE(nvlist_t *, nvlist)
-#ifndef _KERNEL
-NVLIST_MOVE(int, descriptor)
-#endif
-
-#undef	NVLIST_MOVE
-
 void
-nvlist_move_binary(nvlist_t *nvl, const char *name, void *value, size_t size)
-{
-
-	nvlist_movef_binary(nvl, value, size, "%s", name);
-}
-
-#define	NVLIST_MOVEF(vtype, type)					\
-void									\
-nvlist_movef_##type(nvlist_t *nvl, vtype value, const char *namefmt,	\
-    ...)								\
-{									\
-	va_list nameap;							\
-									\
-	va_start(nameap, namefmt);					\
-	nvlist_movev_##type(nvl, value, namefmt, nameap);		\
-	va_end(nameap);							\
-}
-
-NVLIST_MOVEF(char *, string)
-NVLIST_MOVEF(nvlist_t *, nvlist)
-#ifndef _KERNEL
-NVLIST_MOVEF(int, descriptor)
-#endif
-
-#undef	NVLIST_MOVEF
-
-void
-nvlist_movef_binary(nvlist_t *nvl, void *value, size_t size,
-    const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_movev_binary(nvl, value, size, namefmt, nameap);
-	va_end(nameap);
-}
-
-void
-nvlist_movev_string(nvlist_t *nvl, char *value, const char *namefmt,
-    va_list nameap)
+nvlist_move_nvlist_array(nvlist_t *nvl, const char *name, nvlist_t **value,
+    size_t nitems)
 {
 	nvpair_t *nvp;
+	size_t i;
 
 	if (nvlist_error(nvl) != 0) {
+		if (value != NULL) {
+			for (i = 0; i < nitems; i++) {
+				if (nvlist_get_pararr(value[i], NULL) == NULL)
+					nvlist_destroy(value[i]);
+			}
+		}
 		nv_free(value);
-		RESTORE_ERRNO(nvlist_error(nvl));
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_movev_string(value, namefmt, nameap);
+	nvp = nvpair_move_nvlist_array(name, value, nitems);
 	if (nvp == NULL) {
 		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvl->nvl_error);
-	} else
-		nvlist_move_nvpair(nvl, nvp);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
 void
-nvlist_movev_nvlist(nvlist_t *nvl, nvlist_t *value, const char *namefmt,
-    va_list nameap)
+nvlist_move_number_array(nvlist_t *nvl, const char *name, uint64_t *value,
+    size_t nitems)
 {
 	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));
+		nv_free(value);
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_movev_nvlist(value, namefmt, nameap);
+	nvp = nvpair_move_number_array(name, value, nitems);
 	if (nvp == NULL) {
 		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvl->nvl_error);
-	} else
-		nvlist_move_nvpair(nvl, nvp);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
 
 #ifndef _KERNEL
 void
-nvlist_movev_descriptor(nvlist_t *nvl, int value, const char *namefmt,
-    va_list nameap)
+nvlist_move_descriptor_array(nvlist_t *nvl, const char *name, int *value,
+    size_t nitems)
 {
 	nvpair_t *nvp;
+	size_t i;
 
 	if (nvlist_error(nvl) != 0) {
-		close(value);
-		errno = nvlist_error(nvl);
-		return;
-	}
-
-	nvp = nvpair_movev_descriptor(value, namefmt, nameap);
-	if (nvp == NULL)
-		nvl->nvl_error = errno = (errno != 0 ? errno : ENOMEM);
-	else
-		nvlist_move_nvpair(nvl, nvp);
-}
-#endif
-
-void
-nvlist_movev_binary(nvlist_t *nvl, void *value, size_t size,
-    const char *namefmt, va_list nameap)
-{
-	nvpair_t *nvp;
+		if (value != 0) {
+			for (i = 0; i < nitems; i++)
+				close(value[i]);
+			nv_free(value);
+		}
 
-	if (nvlist_error(nvl) != 0) {
-		nv_free(value);
-		RESTORE_ERRNO(nvlist_error(nvl));
+		ERRNO_SET(nvlist_error(nvl));
 		return;
 	}
 
-	nvp = nvpair_movev_binary(value, size, namefmt, nameap);
+	nvp = nvpair_move_descriptor_array(name, value, nitems);
 	if (nvp == NULL) {
 		nvl->nvl_error = ERRNO_OR_DEFAULT(ENOMEM);
-		RESTORE_ERRNO(nvl->nvl_error);
-	} else
-		nvlist_move_nvpair(nvl, nvp);
+		ERRNO_SET(nvl->nvl_error);
+	} else {
+		(void)nvlist_move_nvpair(nvl, nvp);
+	}
 }
+#endif
 
 const nvpair_t *
 nvlist_get_nvpair(const nvlist_t *nvl, const char *name)
@@ -1693,84 +1877,29 @@ nvlist_get_binary(const nvlist_t *nvl, const char *name, size_t *sizep)
 	return (nvpair_get_binary(nvp, sizep));
 }
 
-#define	NVLIST_GETF(ftype, type)					\
+#define	NVLIST_GET_ARRAY(ftype, type, TYPE)				\
 ftype									\
-nvlist_getf_##type(const nvlist_t *nvl, const char *namefmt, ...)	\
+nvlist_get_##type##_array(const nvlist_t *nvl, const char *name,	\
+    size_t *nitems)							\
 {									\
-	va_list nameap;							\
-	ftype value;							\
-									\
-	va_start(nameap, namefmt);					\
-	value = nvlist_getv_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
+	const nvpair_t *nvp;						\
 									\
-	return (value);							\
+	nvp = nvlist_find(nvl, NV_TYPE_##TYPE##_ARRAY, name);		\
+	if (nvp == NULL)						\
+		nvlist_report_missing(NV_TYPE_##TYPE##_ARRAY, name);	\
+	return (nvpair_get_##type##_array(nvp, nitems));		\
 }
 
+NVLIST_GET_ARRAY(const bool *, bool, BOOL)
+NVLIST_GET_ARRAY(const uint64_t *, number, NUMBER)
+NVLIST_GET_ARRAY(const char * const *, string, STRING)
+NVLIST_GET_ARRAY(const nvlist_t * const *, nvlist, NVLIST)
 #ifndef _KERNEL
-NVLIST_GETF(bool, bool)
-NVLIST_GETF(uint64_t, number)
-NVLIST_GETF(const char *, string)
-NVLIST_GETF(const nvlist_t *, nvlist)
-NVLIST_GETF(int, descriptor)
-
-#undef	NVLIST_GETF
-
-const void *
-nvlist_getf_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt, ...)
-{
-	va_list nameap;
-	const void *value;
-
-	va_start(nameap, namefmt);
-	value = nvlist_getv_binary(nvl, sizep, namefmt, nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	NVLIST_GETV(ftype, type, TYPE)					\
-ftype									\
-nvlist_getv_##type(const nvlist_t *nvl, const char *namefmt,		\
-    va_list nameap)							\
-{									\
-	char *name;							\
-	ftype value;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>");	\
-	value = nvlist_get_##type(nvl, name);				\
-	free(name);							\
-									\
-	return (value);							\
-}
-
-NVLIST_GETV(bool, bool, BOOL)
-NVLIST_GETV(uint64_t, number, NUMBER)
-NVLIST_GETV(const char *, string, STRING)
-NVLIST_GETV(const nvlist_t *, nvlist, NVLIST)
-NVLIST_GETV(int, descriptor, DESCRIPTOR)
-
-#undef	NVLIST_GETV
-
-const void *
-nvlist_getv_binary(const nvlist_t *nvl, size_t *sizep, const char *namefmt,
-    va_list nameap)
-{
-	char *name;
-	const void *binary;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name == NULL)
-		nvlist_report_missing(NV_TYPE_BINARY, "<unknown>");
-
-	binary = nvlist_get_binary(nvl, name, sizep);
-	nv_free(name);
-	return (binary);
-}
+NVLIST_GET_ARRAY(const int *, descriptor, DESCRIPTOR)
 #endif
 
+#undef	NVLIST_GET_ARRAY
+
 #define	NVLIST_TAKE(ftype, type, TYPE)					\
 ftype									\
 nvlist_take_##type(nvlist_t *nvl, const char *name)			\
@@ -1813,80 +1942,29 @@ nvlist_take_binary(nvlist_t *nvl, const char *name, size_t *sizep)
 	return (value);
 }
 
-#define	NVLIST_TAKEF(ftype, type)					\
+#define	NVLIST_TAKE_ARRAY(ftype, type, TYPE)				\
 ftype									\
-nvlist_takef_##type(nvlist_t *nvl, const char *namefmt, ...)		\
+nvlist_take_##type##_array(nvlist_t *nvl, const char *name,		\
+    size_t *nitems)							\
 {									\
-	va_list nameap;							\
+	nvpair_t *nvp;							\
 	ftype value;							\
 									\
-	va_start(nameap, namefmt);					\
-	value = nvlist_takev_##type(nvl, namefmt, nameap);		\
-	va_end(nameap);							\
-									\
+	nvp = nvlist_find(nvl, NV_TYPE_##TYPE##_ARRAY, name);		\
+	if (nvp == NULL)						\
+		nvlist_report_missing(NV_TYPE_##TYPE##_ARRAY, name);	\
+	value = (ftype)(intptr_t)nvpair_get_##type##_array(nvp, nitems);\
+	nvlist_remove_nvpair(nvl, nvp);					\
+	nvpair_free_structure(nvp);					\
 	return (value);							\
 }
 
+NVLIST_TAKE_ARRAY(bool *, bool, BOOL)
+NVLIST_TAKE_ARRAY(uint64_t *, number, NUMBER)
+NVLIST_TAKE_ARRAY(char **, string, STRING)
+NVLIST_TAKE_ARRAY(nvlist_t **, nvlist, NVLIST)
 #ifndef _KERNEL
-NVLIST_TAKEF(bool, bool)
-NVLIST_TAKEF(uint64_t, number)
-NVLIST_TAKEF(char *, string)
-NVLIST_TAKEF(nvlist_t *, nvlist)
-NVLIST_TAKEF(int, descriptor)
-
-#undef	NVLIST_TAKEF
-
-void *
-nvlist_takef_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt, ...)
-{
-	va_list nameap;
-	void *value;
-
-	va_start(nameap, namefmt);
-	value = nvlist_takev_binary(nvl, sizep, namefmt, nameap);
-	va_end(nameap);
-
-	return (value);
-}
-
-#define	NVLIST_TAKEV(ftype, type, TYPE)					\
-ftype									\
-nvlist_takev_##type(nvlist_t *nvl, const char *namefmt, va_list nameap)	\
-{									\
-	char *name;							\
-	ftype value;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>");	\
-	value = nvlist_take_##type(nvl, name);				\
-	free(name);							\
-	return (value);							\
-}
-
-NVLIST_TAKEV(bool, bool, BOOL)
-NVLIST_TAKEV(uint64_t, number, NUMBER)
-NVLIST_TAKEV(char *, string, STRING)
-NVLIST_TAKEV(nvlist_t *, nvlist, NVLIST)
-NVLIST_TAKEV(int, descriptor, DESCRIPTOR)
-
-#undef	NVLIST_TAKEV
-
-void *
-nvlist_takev_binary(nvlist_t *nvl, size_t *sizep, const char *namefmt,
-    va_list nameap)
-{
-	char *name;
-	void *binary;
-
-	nv_vasprintf(&name, namefmt, nameap);
-	if (name == NULL)
-		nvlist_report_missing(NV_TYPE_BINARY, "<unknown>");
-
-	binary = nvlist_take_binary(nvl, name, sizep);
-	nv_free(name);
-	return (binary);
-}
+NVLIST_TAKE_ARRAY(int *, descriptor, DESCRIPTOR)
 #endif
 
 void
@@ -1920,75 +1998,18 @@ NVLIST_FREE(bool, BOOL)
 NVLIST_FREE(number, NUMBER)
 NVLIST_FREE(string, STRING)
 NVLIST_FREE(nvlist, NVLIST)
+NVLIST_FREE(binary, BINARY)
+NVLIST_FREE(bool_array, BOOL_ARRAY)
+NVLIST_FREE(number_array, NUMBER_ARRAY)
+NVLIST_FREE(string_array, STRING_ARRAY)
+NVLIST_FREE(nvlist_array, NVLIST_ARRAY)
 #ifndef _KERNEL
 NVLIST_FREE(descriptor, DESCRIPTOR)
+NVLIST_FREE(descriptor_array, DESCRIPTOR_ARRAY)
 #endif
-NVLIST_FREE(binary, BINARY)
 
 #undef	NVLIST_FREE
 
-#ifndef _KERNEL
-void
-nvlist_freef(nvlist_t *nvl, const char *namefmt, ...)
-{
-	va_list nameap;
-
-	va_start(nameap, namefmt);
-	nvlist_freev(nvl, namefmt, nameap);
-	va_end(nameap);
-}
-
-#define	NVLIST_FREEF(type)						\
-void									\
-nvlist_freef_##type(nvlist_t *nvl, const char *namefmt, ...)		\
-{									\
-	va_list nameap;							\
-									\
-	va_start(nameap, namefmt);					\
-	nvlist_freev_##type(nvl, namefmt, nameap);			\
-	va_end(nameap);							\
-}
-
-NVLIST_FREEF(null)
-NVLIST_FREEF(bool)
-NVLIST_FREEF(number)
-NVLIST_FREEF(string)
-NVLIST_FREEF(nvlist)
-NVLIST_FREEF(descriptor)
-NVLIST_FREEF(binary)
-
-#undef	NVLIST_FREEF
-
-void
-nvlist_freev(nvlist_t *nvl, const char *namefmt, va_list nameap)
-{
-
-	nvlist_freev_type(nvl, NV_TYPE_NONE, namefmt, nameap);
-}
-
-#define	NVLIST_FREEV(type, TYPE)					\
-void									\
-nvlist_freev_##type(nvlist_t *nvl, const char *namefmt, va_list nameap)	\
-{									\
-	char *name;							\
-									\
-	vasprintf(&name, namefmt, nameap);				\
-	if (name == NULL)						\
-		nvlist_report_missing(NV_TYPE_##TYPE, "<unknown>");	\
-	nvlist_free_##type(nvl, name);					\
-	free(name);							\
-}
-
-NVLIST_FREEV(null, NULL)
-NVLIST_FREEV(bool, BOOL)
-NVLIST_FREEV(number, NUMBER)
-NVLIST_FREEV(string, STRING)
-NVLIST_FREEV(nvlist, NVLIST)
-NVLIST_FREEV(descriptor, DESCRIPTOR)
-NVLIST_FREEV(binary, BINARY)
-#undef	NVLIST_FREEV
-#endif
-
 void
 nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp)
 {
@@ -2000,3 +2021,4 @@ nvlist_free_nvpair(nvlist_t *nvl, nvpair_t *nvp)
 	nvlist_remove_nvpair(nvl, nvp);
 	nvpair_free(nvp);
 }
+
diff --git a/external/libnv/sys/nvlist_impl.h b/external/libnv/sys/nvlist_impl.h
index 1576afd5..9952db8f 100644
--- a/external/libnv/sys/nvlist_impl.h
+++ b/external/libnv/sys/nvlist_impl.h
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -26,22 +27,18 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/sys/sys/nvlist_impl.h 279439 2015-03-01 00:34:27Z rstone $
+ * $FreeBSD$
  */
 
 #ifndef	_NVLIST_IMPL_H_
 #define	_NVLIST_IMPL_H_
 
+#include <sys/nv.h>
+
 #ifndef _KERNEL
 #include <stdint.h>
 #endif
 
-#include "nv.h"
-
-void *nvlist_xpack(const nvlist_t *nvl, int64_t *fdidxp, size_t *sizep);
-nvlist_t *nvlist_xunpack(const void *buf, size_t size, const int *fds,
-    size_t nfds);
-
 nvpair_t *nvlist_get_nvpair_parent(const nvlist_t *nvl);
 const unsigned char *nvlist_unpack_header(nvlist_t *nvl,
     const unsigned char *ptr, size_t nfds, bool *isbep, size_t *leftp);
diff --git a/external/libnv/subr_nvpair.c b/external/libnv/sys/nvpair.c
index f887e547..1e3bd0ea 100644
--- a/external/libnv/subr_nvpair.c
+++ b/external/libnv/sys/nvpair.c
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -28,7 +29,7 @@
  */
 
 #include <sys/cdefs.h>
-__FBSDID("$FreeBSD: head/sys/kern/subr_nvpair.c 279439 2015-03-01 00:34:27Z rstone $");
+__FBSDID("$FreeBSD$");
 
 #include <sys/param.h>
 #include <sys/endian.h>
@@ -61,9 +62,10 @@ __FBSDID("$FreeBSD: head/sys/kern/subr_nvpair.c 279439 2015-03-01 00:34:27Z rsto
 #endif
 
 #include <sys/nv.h>
-#include <sys/nv_impl.h>
-#include <sys/nvlist_impl.h>
-#include <sys/nvpair_impl.h>
+
+#include "nv_impl.h"
+#include "nvlist_impl.h"
+#include "nvpair_impl.h"
 
 #ifndef	HAVE_PJDLOG
 #ifdef _KERNEL
@@ -85,6 +87,7 @@ struct nvpair {
 	int		 nvp_type;
 	uint64_t	 nvp_data;
 	size_t		 nvp_datasize;
+	size_t		 nvp_nitems;	/* Used only for array types. */
 	nvlist_t	*nvp_list;
 	TAILQ_ENTRY(nvpair) nvp_next;
 };
@@ -98,6 +101,7 @@ struct nvpair_header {
 	uint8_t		nvph_type;
 	uint16_t	nvph_namesize;
 	uint64_t	nvph_datasize;
+	uint64_t	nvph_nitems;
 } __packed;
 
 
@@ -108,6 +112,36 @@ nvpair_assert(const nvpair_t *nvp)
 	NVPAIR_ASSERT(nvp);
 }
 
+static nvpair_t *
+nvpair_allocv(const char *name, int type, uint64_t data, size_t datasize,
+    size_t nitems)
+{
+	nvpair_t *nvp;
+	size_t namelen;
+
+	PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
+
+	namelen = strlen(name);
+	if (namelen >= NV_NAME_MAX) {
+		ERRNO_SET(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] = '\0';
+		nvp->nvp_type = type;
+		nvp->nvp_data = data;
+		nvp->nvp_datasize = datasize;
+		nvp->nvp_nitems = nitems;
+		nvp->nvp_magic = NVPAIR_MAGIC;
+	}
+
+	return (nvp);
+}
+
 nvlist_t *
 nvpair_nvlist(const nvpair_t *nvp)
 {
@@ -143,7 +177,8 @@ 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)));
+	PJDLOG_ASSERT((nvlist_flags(nvl) & NV_FLAG_NO_UNIQUE) != 0 ||
+	    !nvlist_exists(nvl, nvpair_name(nvp)));
 
 	TAILQ_INSERT_TAIL(head, nvp, nvp_next);
 	nvp->nvp_list = nvl;
@@ -160,6 +195,19 @@ nvpair_remove_nvlist(nvpair_t *nvp)
 	nvlist_set_parent(nvl, NULL);
 }
 
+static void
+nvpair_remove_nvlist_array(nvpair_t *nvp)
+{
+	nvlist_t **nvlarray;
+	size_t count, i;
+
+	/* XXX: DECONST is bad, mkay? */
+	nvlarray = __DECONST(nvlist_t **,
+	    nvpair_get_nvlist_array(nvp, &count));
+	for (i = 0; i < count; i++)
+		nvlist_set_array_next(nvlarray[i], NULL);
+}
+
 void
 nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
 {
@@ -169,6 +217,8 @@ nvpair_remove(struct nvl_head *head, nvpair_t *nvp, const nvlist_t *nvl)
 
 	if (nvpair_type(nvp) == NV_TYPE_NVLIST)
 		nvpair_remove_nvlist(nvp);
+	else if (nvpair_type(nvp) == NV_TYPE_NVLIST_ARRAY)
+		nvpair_remove_nvlist_array(nvp);
 
 	TAILQ_REMOVE(head, nvp, nvp_next);
 	nvp->nvp_list = NULL;
@@ -202,16 +252,36 @@ nvpair_clone(const nvpair_t *nvp)
 	case NV_TYPE_NVLIST:
 		newnvp = nvpair_create_nvlist(name, nvpair_get_nvlist(nvp));
 		break;
+	case NV_TYPE_BINARY:
+		data = nvpair_get_binary(nvp, &datasize);
+		newnvp = nvpair_create_binary(name, data, datasize);
+		break;
+	case NV_TYPE_BOOL_ARRAY:
+		data = nvpair_get_bool_array(nvp, &datasize);
+		newnvp = nvpair_create_bool_array(name, data, datasize);
+		break;
+	case NV_TYPE_NUMBER_ARRAY:
+		data = nvpair_get_number_array(nvp, &datasize);
+		newnvp = nvpair_create_number_array(name, data, datasize);
+		break;
+	case NV_TYPE_STRING_ARRAY:
+		data = nvpair_get_string_array(nvp, &datasize);
+		newnvp = nvpair_create_string_array(name, data, datasize);
+		break;
+	case NV_TYPE_NVLIST_ARRAY:
+		data = nvpair_get_nvlist_array(nvp, &datasize);
+		newnvp = nvpair_create_nvlist_array(name, data, datasize);
+		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);
+	case NV_TYPE_DESCRIPTOR_ARRAY:
+		data = nvpair_get_descriptor_array(nvp, &datasize);
+		newnvp = nvpair_create_descriptor_array(name, data, datasize);
 		break;
+#endif
 	default:
 		PJDLOG_ABORT("Unknown type: %d.", nvpair_type(nvp));
 	}
@@ -248,6 +318,7 @@ nvpair_pack_header(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
 	PJDLOG_ASSERT(namesize > 0 && namesize <= UINT16_MAX);
 	nvphdr.nvph_namesize = namesize;
 	nvphdr.nvph_datasize = nvp->nvp_datasize;
+	nvphdr.nvph_nitems = nvp->nvp_nitems;
 	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
 	memcpy(ptr, &nvphdr, sizeof(nvphdr));
 	ptr += sizeof(nvphdr);
@@ -334,6 +405,32 @@ nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp)
 	nvphdr.nvph_type = NV_TYPE_NVLIST_UP;
 	nvphdr.nvph_namesize = namesize;
 	nvphdr.nvph_datasize = 0;
+	nvphdr.nvph_nitems = 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);
+}
+
+unsigned char *
+nvpair_pack_nvlist_array_next(unsigned char *ptr, size_t *leftp)
+{
+	struct nvpair_header nvphdr;
+	size_t namesize;
+	const char *name = "";
+
+	namesize = 1;
+	nvphdr.nvph_type = NV_TYPE_NVLIST_ARRAY_NEXT;
+	nvphdr.nvph_namesize = namesize;
+	nvphdr.nvph_datasize = 0;
+	nvphdr.nvph_nitems = 0;
 	PJDLOG_ASSERT(*leftp >= sizeof(nvphdr));
 	memcpy(ptr, &nvphdr, sizeof(nvphdr));
 	ptr += sizeof(nvphdr);
@@ -394,6 +491,106 @@ nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
 	return (ptr);
 }
 
+unsigned char *
+nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
+	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_number_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
+	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_string_array(const nvpair_t *nvp, unsigned char *ptr, size_t *leftp)
+{
+	unsigned int ii;
+	size_t size, len;
+	const char * const *array;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
+	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
+
+	size = 0;
+	array = nvpair_get_string_array(nvp, NULL);
+	PJDLOG_ASSERT(array != NULL);
+
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		len = strlen(array[ii]) + 1;
+		PJDLOG_ASSERT(*leftp >= len);
+
+		memcpy(ptr, (const void *)array[ii], len);
+		size += len;
+		ptr += len;
+		*leftp -= len;
+	}
+
+	PJDLOG_ASSERT(size == nvp->nvp_datasize);
+
+	return (ptr);
+}
+
+#ifndef _KERNEL
+unsigned char *
+nvpair_pack_descriptor_array(const nvpair_t *nvp, unsigned char *ptr,
+    int64_t *fdidxp, size_t *leftp)
+{
+	int64_t value;
+	const int *array;
+	unsigned int ii;
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
+	PJDLOG_ASSERT(*leftp >= nvp->nvp_datasize);
+
+	array = nvpair_get_descriptor_array(nvp, NULL);
+	PJDLOG_ASSERT(array != NULL);
+
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		PJDLOG_ASSERT(*leftp >= sizeof(value));
+
+		value = array[ii];
+		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)++;
+		}
+		memcpy(ptr, &value, sizeof(value));
+		ptr += sizeof(value);
+		*leftp -= sizeof(value);
+	}
+
+	return (ptr);
+}
+#endif
+
 void
 nvpair_init_datasize(nvpair_t *nvp)
 {
@@ -428,7 +625,8 @@ nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 		goto failed;
 #endif
 	if (nvphdr.nvph_type > NV_TYPE_LAST &&
-	    nvphdr.nvph_type != NV_TYPE_NVLIST_UP) {
+	    nvphdr.nvph_type != NV_TYPE_NVLIST_UP &&
+	    nvphdr.nvph_type != NV_TYPE_NVLIST_ARRAY_NEXT) {
 		goto failed;
 	}
 
@@ -465,10 +663,11 @@ nvpair_unpack_header(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 	nvp->nvp_type = nvphdr.nvph_type;
 	nvp->nvp_data = 0;
 	nvp->nvp_datasize = nvphdr.nvph_datasize;
+	nvp->nvp_nitems = nvphdr.nvph_nitems;
 
 	return (ptr);
 failed:
-	RESTORE_ERRNO(EINVAL);
+	ERRNO_SET(EINVAL);
 	return (NULL);
 }
 
@@ -480,7 +679,7 @@ nvpair_unpack_null(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NULL);
 
 	if (nvp->nvp_datasize != 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -496,11 +695,11 @@ nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL);
 
 	if (nvp->nvp_datasize != sizeof(value)) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 	if (*leftp < sizeof(value)) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -509,7 +708,7 @@ nvpair_unpack_bool(bool isbe __unused, nvpair_t *nvp, const unsigned char *ptr,
 	*leftp -= sizeof(value);
 
 	if (value != 0 && value != 1) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -526,11 +725,11 @@ nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER);
 
 	if (nvp->nvp_datasize != sizeof(uint64_t)) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 	if (*leftp < sizeof(uint64_t)) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -538,6 +737,7 @@ nvpair_unpack_number(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 		nvp->nvp_data = be64dec(ptr);
 	else
 		nvp->nvp_data = le64dec(ptr);
+
 	ptr += sizeof(uint64_t);
 	*leftp -= sizeof(uint64_t);
 
@@ -552,13 +752,13 @@ nvpair_unpack_string(bool isbe __unused, nvpair_t *nvp,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING);
 
 	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
 	if (strnlen((const char *)ptr, nvp->nvp_datasize) !=
 	    nvp->nvp_datasize - 1) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -581,7 +781,7 @@ nvpair_unpack_nvlist(bool isbe __unused, nvpair_t *nvp,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST);
 
 	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -609,11 +809,11 @@ nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR);
 
 	if (nvp->nvp_datasize != sizeof(idx)) {
-		errno = EINVAL;
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 	if (*leftp < sizeof(idx)) {
-		errno = EINVAL;
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -623,12 +823,12 @@ nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
 		idx = le64dec(ptr);
 
 	if (idx < 0) {
-		errno = EINVAL;
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
 	if ((size_t)idx >= nfds) {
-		errno = EINVAL;
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -650,7 +850,7 @@ nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
 	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BINARY);
 
 	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -668,293 +868,341 @@ nvpair_unpack_binary(bool isbe __unused, nvpair_t *nvp,
 }
 
 const unsigned char *
-nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
-    nvpair_t **nvpp)
+nvpair_unpack_bool_array(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp)
 {
-	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;
+	uint8_t *value;
+	size_t size;
+	unsigned int i;
 
-	/* 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);
-}
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
 
-int
-nvpair_type(const nvpair_t *nvp)
-{
+	size = sizeof(*value) * nvp->nvp_nitems;
+	if (nvp->nvp_datasize != size || *leftp < size ||
+	    nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-	NVPAIR_ASSERT(nvp);
+	value = nv_malloc(size);
+	if (value == NULL)
+		return (NULL);
 
-	return (nvp->nvp_type);
-}
+	for (i = 0; i < nvp->nvp_nitems; i++) {
+		value[i] = *(const uint8_t *)ptr;
 
-const char *
-nvpair_name(const nvpair_t *nvp)
-{
+		ptr += sizeof(*value);
+		*leftp -= sizeof(*value);
+	}
 
-	NVPAIR_ASSERT(nvp);
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
 
-	return (nvp->nvp_name);
+	return (ptr);
 }
 
-static nvpair_t *
-nvpair_allocv(int type, uint64_t data, size_t datasize, const char *namefmt,
-    va_list nameap)
+const unsigned char *
+nvpair_unpack_number_array(bool isbe, nvpair_t *nvp, const unsigned char *ptr,
+     size_t *leftp)
 {
-	nvpair_t *nvp;
-	char *name;
-	int namelen;
+	uint64_t *value;
+	size_t size;
+	unsigned int i;
 
-	PJDLOG_ASSERT(type >= NV_TYPE_FIRST && type <= NV_TYPE_LAST);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
 
-	namelen = nv_vasprintf(&name, namefmt, nameap);
-	if (namelen < 0)
+	size = sizeof(*value) * nvp->nvp_nitems;
+	if (nvp->nvp_datasize != size || *leftp < size ||
+	    nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
+		ERRNO_SET(EINVAL);
 		return (NULL);
+	}
 
-	PJDLOG_ASSERT(namelen > 0);
-	if (namelen >= NV_NAME_MAX) {
-		nv_free(name);
-		RESTORE_ERRNO(ENAMETOOLONG);
+	value = nv_malloc(size);
+	if (value == NULL)
 		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 + 1);
-		nvp->nvp_type = type;
-		nvp->nvp_data = data;
-		nvp->nvp_datasize = datasize;
-		nvp->nvp_magic = NVPAIR_MAGIC;
-	}
-	nv_free(name);
+	for (i = 0; i < nvp->nvp_nitems; i++) {
+		if (isbe)
+			value[i] = be64dec(ptr);
+		else
+			value[i] = le64dec(ptr);
 
-	return (nvp);
-};
+		ptr += sizeof(*value);
+		*leftp -= sizeof(*value);
+	}
 
-nvpair_t *
-nvpair_create_null(const char *name)
-{
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
 
-	return (nvpair_createf_null("%s", name));
+	return (ptr);
 }
 
-nvpair_t *
-nvpair_create_bool(const char *name, bool value)
+const unsigned char *
+nvpair_unpack_string_array(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp)
 {
+	ssize_t size;
+	size_t len;
+	const char *tmp;
+	char **value;
+	unsigned int ii, j;
 
-	return (nvpair_createf_bool(value, "%s", name));
-}
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
 
-nvpair_t *
-nvpair_create_number(const char *name, uint64_t value)
-{
+	if (*leftp < nvp->nvp_datasize || nvp->nvp_datasize == 0 ||
+	    nvp->nvp_nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-	return (nvpair_createf_number(value, "%s", name));
-}
+	size = nvp->nvp_datasize;
+	tmp = (const char *)ptr;
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		len = strnlen(tmp, size - 1) + 1;
+		size -= len;
+		if (size < 0) {
+			ERRNO_SET(EINVAL);
+			return (NULL);
+		}
+		tmp += len;
+	}
+	if (size != 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-nvpair_t *
-nvpair_create_string(const char *name, const char *value)
-{
+	value = nv_malloc(sizeof(*value) * nvp->nvp_nitems);
+	if (value == NULL)
+		return (NULL);
+
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		value[ii] = nv_strdup((const char *)ptr);
+		if (value[ii] == NULL)
+			goto out;
+		len = strlen(value[ii]) + 1;
+		ptr += len;
+		*leftp -= len;
+	}
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
 
-	return (nvpair_createf_string(value, "%s", name));
+	return (ptr);
+out:
+	for (j = 0; j < ii; j++)
+		nv_free(value[j]);
+	nv_free(value);
+	return (NULL);
 }
 
-nvpair_t *
-nvpair_create_stringf(const char *name, const char *valuefmt, ...)
+#ifndef _KERNEL
+const unsigned char *
+nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds)
 {
-	va_list valueap;
-	nvpair_t *nvp;
-
-	va_start(valueap, valuefmt);
-	nvp = nvpair_create_stringv(name, valuefmt, valueap);
-	va_end(valueap);
+	int64_t idx;
+	size_t size;
+	unsigned int ii;
+	int *array;
 
-	return (nvp);
-}
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
 
-nvpair_t *
-nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap)
-{
-	nvpair_t *nvp;
-	char *str;
-	int len;
+	size = sizeof(idx) * nvp->nvp_nitems;
+	if (nvp->nvp_datasize != size || *leftp < size ||
+	    nvp->nvp_nitems == 0 || size < nvp->nvp_nitems) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-	len = nv_vasprintf(&str, valuefmt, valueap);
-	if (len < 0)
+	array = (int *)nv_malloc(size);
+	if (array == NULL)
 		return (NULL);
-	nvp = nvpair_create_string(name, str);
-	if (nvp == NULL)
-		nv_free(str);
-	return (nvp);
-}
 
-nvpair_t *
-nvpair_create_nvlist(const char *name, const nvlist_t *value)
-{
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		if (isbe)
+			idx = be64dec(ptr);
+		else
+			idx = le64dec(ptr);
 
-	return (nvpair_createf_nvlist(value, "%s", name));
-}
+		if (idx < 0) {
+			ERRNO_SET(EINVAL);
+			nv_free(array);
+			return (NULL);
+		}
 
-#ifndef _KERNEL
-nvpair_t *
-nvpair_create_descriptor(const char *name, int value)
-{
+		if ((size_t)idx >= nfds) {
+			ERRNO_SET(EINVAL);
+			nv_free(array);
+			return (NULL);
+		}
+
+		array[ii] = (uint64_t)fds[idx];
+
+		ptr += sizeof(idx);
+		*leftp -= sizeof(idx);
+	}
+
+	nvp->nvp_data = (uint64_t)(uintptr_t)array;
 
-	return (nvpair_createf_descriptor(value, "%s", name));
+	return (ptr);
 }
 #endif
 
-nvpair_t *
-nvpair_create_binary(const char *name, const void *value, size_t size)
+const unsigned char *
+nvpair_unpack_nvlist_array(bool isbe __unused, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp, nvlist_t **firstel)
 {
+	nvlist_t **value;
+	nvpair_t *tmpnvp;
+	unsigned int ii, j;
+	size_t sizeup;
 
-	return (nvpair_createf_binary(value, size, "%s", name));
-}
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
 
-nvpair_t *
-nvpair_createf_null(const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
+	sizeup = sizeof(struct nvpair_header) * nvp->nvp_nitems;
+	if (nvp->nvp_nitems == 0 || sizeup < nvp->nvp_nitems ||
+	    sizeup > *leftp) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_null(namefmt, nameap);
-	va_end(nameap);
+	value = nv_malloc(nvp->nvp_nitems * sizeof(*value));
+	if (value == NULL)
+		return (NULL);
 
-	return (nvp);
-}
+	for (ii = 0; ii < nvp->nvp_nitems; ii++) {
+		value[ii] = nvlist_create(0);
+		if (value[ii] == NULL)
+			goto fail;
+		if (ii > 0) {
+			tmpnvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
+			    (uint64_t)(uintptr_t)value[ii], 0, 0);
+			if (tmpnvp == NULL)
+				goto fail;
+			nvlist_set_array_next(value[ii - 1], tmpnvp);
+		}
+	}
+	nvlist_set_flags(value[nvp->nvp_nitems - 1], NV_FLAG_IN_ARRAY);
 
-nvpair_t *
-nvpair_createf_bool(bool value, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
+	nvp->nvp_data = (uint64_t)(uintptr_t)value;
+	*firstel = value[0];
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_bool(value, namefmt, nameap);
-	va_end(nameap);
+	return (ptr);
+fail:
+	ERRNO_SAVE();
+	for (j = 0; j < ii; j++)
+		nvlist_destroy(value[j]);
+	nv_free(value);
+	ERRNO_RESTORE();
 
-	return (nvp);
+	return (NULL);
 }
 
-nvpair_t *
-nvpair_createf_number(uint64_t value, const char *namefmt, ...)
+const unsigned char *
+nvpair_unpack(bool isbe, const unsigned char *ptr, size_t *leftp,
+    nvpair_t **nvpp)
 {
-	va_list nameap;
-	nvpair_t *nvp;
+	nvpair_t *nvp, *tmp;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_number(value, namefmt, nameap);
-	va_end(nameap);
+	nvp = nv_calloc(1, sizeof(*nvp) + NV_NAME_MAX);
+	if (nvp == NULL)
+		return (NULL);
+	nvp->nvp_name = (char *)(nvp + 1);
 
-	return (nvp);
+	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);
 }
 
-nvpair_t *
-nvpair_createf_string(const char *value, const char *namefmt, ...)
+int
+nvpair_type(const nvpair_t *nvp)
 {
-	va_list nameap;
-	nvpair_t *nvp;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_string(value, namefmt, nameap);
-	va_end(nameap);
+	NVPAIR_ASSERT(nvp);
 
-	return (nvp);
+	return (nvp->nvp_type);
 }
 
-nvpair_t *
-nvpair_createf_nvlist(const nvlist_t *value, const char *namefmt, ...)
+const char *
+nvpair_name(const nvpair_t *nvp)
 {
-	va_list nameap;
-	nvpair_t *nvp;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_nvlist(value, namefmt, nameap);
-	va_end(nameap);
+	NVPAIR_ASSERT(nvp);
 
-	return (nvp);
+	return (nvp->nvp_name);
 }
 
-#ifndef _KERNEL
 nvpair_t *
-nvpair_createf_descriptor(int value, const char *namefmt, ...)
+nvpair_create_stringf(const char *name, const char *valuefmt, ...)
 {
-	va_list nameap;
+	va_list valueap;
 	nvpair_t *nvp;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_descriptor(value, namefmt, nameap);
-	va_end(nameap);
+	va_start(valueap, valuefmt);
+	nvp = nvpair_create_stringv(name, valuefmt, valueap);
+	va_end(valueap);
 
 	return (nvp);
 }
-#endif
 
 nvpair_t *
-nvpair_createf_binary(const void *value, size_t size, const char *namefmt, ...)
+nvpair_create_stringv(const char *name, const char *valuefmt, va_list valueap)
 {
-	va_list nameap;
 	nvpair_t *nvp;
+	char *str;
+	int len;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_createv_binary(value, size, namefmt, nameap);
-	va_end(nameap);
-
+	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_createv_null(const char *namefmt, va_list nameap)
+nvpair_create_null(const char *name)
 {
 
-	return (nvpair_allocv(NV_TYPE_NULL, 0, 0, namefmt, nameap));
+	return (nvpair_allocv(name, NV_TYPE_NULL, 0, 0, 0));
 }
 
 nvpair_t *
-nvpair_createv_bool(bool value, const char *namefmt, va_list nameap)
+nvpair_create_bool(const char *name, bool value)
 {
 
-	return (nvpair_allocv(NV_TYPE_BOOL, value ? 1 : 0, sizeof(uint8_t),
-	    namefmt, nameap));
+	return (nvpair_allocv(name, NV_TYPE_BOOL, value ? 1 : 0,
+	    sizeof(uint8_t), 0));
 }
 
 nvpair_t *
-nvpair_createv_number(uint64_t value, const char *namefmt, va_list nameap)
+nvpair_create_number(const char *name, uint64_t value)
 {
 
-	return (nvpair_allocv(NV_TYPE_NUMBER, value, sizeof(value), namefmt,
-	    nameap));
+	return (nvpair_allocv(name, NV_TYPE_NUMBER, value, sizeof(value), 0));
 }
 
 nvpair_t *
-nvpair_createv_string(const char *value, const char *namefmt, va_list nameap)
+nvpair_create_string(const char *name, const char *value)
 {
 	nvpair_t *nvp;
 	size_t size;
 	char *data;
 
 	if (value == NULL) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -963,8 +1211,8 @@ nvpair_createv_string(const char *value, const char *namefmt, va_list nameap)
 		return (NULL);
 	size = strlen(value) + 1;
 
-	nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)data, size,
-	    namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)data,
+	    size, 0);
 	if (nvp == NULL)
 		nv_free(data);
 
@@ -972,14 +1220,13 @@ nvpair_createv_string(const char *value, const char *namefmt, va_list nameap)
 }
 
 nvpair_t *
-nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt,
-    va_list nameap)
+nvpair_create_nvlist(const char *name, const nvlist_t *value)
 {
 	nvlist_t *nvl;
 	nvpair_t *nvp;
 
 	if (value == NULL) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -987,8 +1234,8 @@ nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt,
 	if (nvl == NULL)
 		return (NULL);
 
-	nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
-	    namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)nvl, 0,
+	    0);
 	if (nvp == NULL)
 		nvlist_destroy(nvl);
 	else
@@ -999,12 +1246,12 @@ nvpair_createv_nvlist(const nvlist_t *value, const char *namefmt,
 
 #ifndef _KERNEL
 nvpair_t *
-nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap)
+nvpair_create_descriptor(const char *name, int value)
 {
 	nvpair_t *nvp;
 
 	if (value < 0 || !fd_is_valid(value)) {
-		errno = EBADF;
+		ERRNO_SET(EBADF);
 		return (NULL);
 	}
 
@@ -1012,24 +1259,26 @@ nvpair_createv_descriptor(int value, const char *namefmt, va_list nameap)
 	if (value < 0)
 		return (NULL);
 
-	nvp = nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value,
-	    sizeof(int64_t), namefmt, nameap);
-	if (nvp == NULL)
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
+	    sizeof(int64_t), 0);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
 		close(value);
+		ERRNO_RESTORE();
+	}
 
 	return (nvp);
 }
 #endif
 
 nvpair_t *
-nvpair_createv_binary(const void *value, size_t size, const char *namefmt,
-    va_list nameap)
+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);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
@@ -1038,8 +1287,8 @@ nvpair_createv_binary(const void *value, size_t size, const char *namefmt,
 		return (NULL);
 	memcpy(data, value, size);
 
-	nvp = nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)data, size,
-	    namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)data,
+	    size, 0);
 	if (nvp == NULL)
 		nv_free(data);
 
@@ -1047,129 +1296,264 @@ nvpair_createv_binary(const void *value, size_t size, const char *namefmt,
 }
 
 nvpair_t *
-nvpair_move_string(const char *name, char *value)
+nvpair_create_bool_array(const char *name, const bool *value, size_t nitems)
 {
+	nvpair_t *nvp;
+	size_t size;
+	void *data;
 
-	return (nvpair_movef_string(value, "%s", name));
-}
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-nvpair_t *
-nvpair_move_nvlist(const char *name, nvlist_t *value)
-{
+	size = sizeof(value[0]) * nitems;
+	data = nv_malloc(size);
+	if (data == NULL)
+		return (NULL);
+
+	memcpy(data, value, size);
+	nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY, (uint64_t)(uintptr_t)data,
+	    size, nitems);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		nv_free(data);
+		ERRNO_RESTORE();
+	}
 
-	return (nvpair_movef_nvlist(value, "%s", name));
+	return (nvp);
 }
 
-#ifndef _KERNEL
 nvpair_t *
-nvpair_move_descriptor(const char *name, int value)
+nvpair_create_number_array(const char *name, const uint64_t *value,
+    size_t nitems)
 {
+	nvpair_t *nvp;
+	size_t size;
+	void *data;
 
-	return (nvpair_movef_descriptor(value, "%s", name));
-}
-#endif
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-nvpair_t *
-nvpair_move_binary(const char *name, void *value, size_t size)
-{
+	size = sizeof(value[0]) * nitems;
+	data = nv_malloc(size);
+	if (data == NULL)
+		return (NULL);
 
-	return (nvpair_movef_binary(value, size, "%s", name));
+	memcpy(data, value, size);
+	nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
+	    (uint64_t)(uintptr_t)data, size, nitems);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		nv_free(data);
+		ERRNO_RESTORE();
+	}
+
+	return (nvp);
 }
 
 nvpair_t *
-nvpair_movef_string(char *value, const char *namefmt, ...)
+nvpair_create_string_array(const char *name, const char * const *value,
+    size_t nitems)
 {
-	va_list nameap;
 	nvpair_t *nvp;
+	unsigned int ii;
+	size_t datasize, size;
+	char **data;
+
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	nvp = NULL;
+	datasize = 0;
+	data = nv_malloc(sizeof(value[0]) * nitems);
+	if (data == NULL)
+		return (NULL);
+
+	for (ii = 0; ii < nitems; ii++) {
+		if (value[ii] == NULL) {
+			ERRNO_SET(EINVAL);
+			goto fail;
+		}
+
+		size = strlen(value[ii]) + 1;
+		datasize += size;
+		data[ii] = nv_strdup(value[ii]);
+		if (data[ii] == NULL)
+			goto fail;
+	}
+	nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
+	    (uint64_t)(uintptr_t)data, datasize, nitems);
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_string(value, namefmt, nameap);
-	va_end(nameap);
+fail:
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (; ii > 0; ii--)
+			nv_free(data[ii - 1]);
+		nv_free(data);
+		ERRNO_RESTORE();
+	}
 
 	return (nvp);
 }
 
 nvpair_t *
-nvpair_movef_nvlist(nvlist_t *value, const char *namefmt, ...)
+nvpair_create_nvlist_array(const char *name, const nvlist_t * const *value,
+    size_t nitems)
 {
-	va_list nameap;
+	unsigned int ii;
+	nvlist_t **nvls;
 	nvpair_t *nvp;
+	int flags;
+
+	nvp = NULL;
+	nvls = NULL;
+	ii = 0;
+
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	nvls = nv_malloc(sizeof(value[0]) * nitems);
+	if (nvls == NULL)
+		return (NULL);
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_nvlist(value, namefmt, nameap);
-	va_end(nameap);
+	for (ii = 0; ii < nitems; ii++) {
+		if (value[ii] == NULL) {
+			ERRNO_SET(EINVAL);
+			goto fail;
+		}
+
+		nvls[ii] = nvlist_clone(value[ii]);
+		if (nvls[ii] == NULL)
+			goto fail;
+
+		if (ii > 0) {
+			nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
+			    (uint64_t)(uintptr_t)nvls[ii], 0, 0);
+			if (nvp == NULL)
+				goto fail;
+			nvlist_set_array_next(nvls[ii - 1], nvp);
+		}
+	}
+	flags = nvlist_flags(nvls[nitems - 1]) | NV_FLAG_IN_ARRAY;
+	nvlist_set_flags(nvls[nitems - 1], flags);
+
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
+	    (uint64_t)(uintptr_t)nvls, 0, nitems);
+
+fail:
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (; ii > 0; ii--)
+			nvlist_destroy(nvls[ii - 1]);
+
+		nv_free(nvls);
+		ERRNO_RESTORE();
+	} else {
+		for (ii = 0; ii < nitems; ii++)
+			nvlist_set_parent(nvls[ii], nvp);
+	}
 
 	return (nvp);
 }
 
 #ifndef _KERNEL
 nvpair_t *
-nvpair_movef_descriptor(int value, const char *namefmt, ...)
+nvpair_create_descriptor_array(const char *name, const int *value,
+    size_t nitems)
 {
-	va_list nameap;
+	unsigned int ii;
 	nvpair_t *nvp;
+	int *fds;
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_descriptor(value, namefmt, nameap);
-	va_end(nameap);
+	if (value == NULL) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
 
-	return (nvp);
-}
-#endif
+	nvp = NULL;
 
-nvpair_t *
-nvpair_movef_binary(void *value, size_t size, const char *namefmt, ...)
-{
-	va_list nameap;
-	nvpair_t *nvp;
+	fds = nv_malloc(sizeof(value[0]) * nitems);
+	if (fds == NULL)
+		return (NULL);
+	for (ii = 0; ii < nitems; ii++) {
+		if (value[ii] == -1) {
+			fds[ii] = -1;
+		} else {
+			if (!fd_is_valid(value[ii])) {
+				ERRNO_SET(EBADF);
+				goto fail;
+			}
+
+			fds[ii] = fcntl(value[ii], F_DUPFD_CLOEXEC, 0);
+			if (fds[ii] == -1)
+				goto fail;
+		}
+	}
 
-	va_start(nameap, namefmt);
-	nvp = nvpair_movev_binary(value, size, namefmt, nameap);
-	va_end(nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
+	    (uint64_t)(uintptr_t)fds, sizeof(int64_t) * nitems, nitems);
+
+fail:
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (; ii > 0; ii--) {
+			if (fds[ii - 1] != -1)
+				close(fds[ii - 1]);
+		}
+		nv_free(fds);
+		ERRNO_RESTORE();
+	}
 
 	return (nvp);
 }
+#endif
 
 nvpair_t *
-nvpair_movev_string(char *value, const char *namefmt, va_list nameap)
+nvpair_move_string(const char *name, char *value)
 {
 	nvpair_t *nvp;
-	int serrno;
 
 	if (value == NULL) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
-	nvp = nvpair_allocv(NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
-	    strlen(value) + 1, namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_STRING, (uint64_t)(uintptr_t)value,
+	    strlen(value) + 1, 0);
 	if (nvp == NULL) {
-		SAVE_ERRNO(serrno);
+		ERRNO_SAVE();
 		nv_free(value);
-		RESTORE_ERRNO(serrno);
+		ERRNO_RESTORE();
 	}
 
 	return (nvp);
 }
 
 nvpair_t *
-nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap)
+nvpair_move_nvlist(const char *name, nvlist_t *value)
 {
 	nvpair_t *nvp;
 
 	if (value == NULL || nvlist_get_nvpair_parent(value) != NULL) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
 	if (nvlist_error(value) != 0) {
-		RESTORE_ERRNO(nvlist_error(value));
+		ERRNO_SET(nvlist_error(value));
 		nvlist_destroy(value);
 		return (NULL);
 	}
 
-	nvp = nvpair_allocv(NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value, 0,
-	    namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST, (uint64_t)(uintptr_t)value,
+	    0, 0);
 	if (nvp == NULL)
 		nvlist_destroy(value);
 	else
@@ -1180,22 +1564,21 @@ nvpair_movev_nvlist(nvlist_t *value, const char *namefmt, va_list nameap)
 
 #ifndef _KERNEL
 nvpair_t *
-nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap)
+nvpair_move_descriptor(const char *name, int value)
 {
 	nvpair_t *nvp;
-	int serrno;
 
 	if (value < 0 || !fd_is_valid(value)) {
-		errno = EBADF;
+		ERRNO_SET(EBADF);
 		return (NULL);
 	}
 
-	nvp = nvpair_allocv(NV_TYPE_DESCRIPTOR, (uint64_t)value,
-	    sizeof(int64_t), namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR, (uint64_t)value,
+	    sizeof(int64_t), 0);
 	if (nvp == NULL) {
-		serrno = errno;
+		ERRNO_SAVE();
 		close(value);
-		errno = serrno;
+		ERRNO_RESTORE();
 	}
 
 	return (nvp);
@@ -1203,28 +1586,191 @@ nvpair_movev_descriptor(int value, const char *namefmt, va_list nameap)
 #endif
 
 nvpair_t *
-nvpair_movev_binary(void *value, size_t size, const char *namefmt,
-    va_list nameap)
+nvpair_move_binary(const char *name, void *value, size_t size)
 {
 	nvpair_t *nvp;
-	int serrno;
 
 	if (value == NULL || size == 0) {
-		RESTORE_ERRNO(EINVAL);
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_BINARY, (uint64_t)(uintptr_t)value,
+	    size, 0);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		nv_free(value);
+		ERRNO_RESTORE();
+	}
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_move_bool_array(const char *name, bool *value, size_t nitems)
+{
+	nvpair_t *nvp;
+
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_BOOL_ARRAY,
+	    (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		nv_free(value);
+		ERRNO_RESTORE();
+	}
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_move_string_array(const char *name, char **value, size_t nitems)
+{
+	nvpair_t *nvp;
+	size_t i, size;
+
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	size = 0;
+	for (i = 0; i < nitems; i++) {
+		if (value[i] == NULL) {
+			ERRNO_SET(EINVAL);
+			return (NULL);
+		}
+
+		size += strlen(value[i]) + 1;
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_STRING_ARRAY,
+	    (uint64_t)(uintptr_t)value, size, nitems);
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (i = 0; i < nitems; i++)
+			nv_free(value[i]);
+		nv_free(value);
+		ERRNO_RESTORE();
+	}
+
+	return (nvp);
+}
+
+nvpair_t *
+nvpair_move_number_array(const char *name, uint64_t *value, size_t nitems)
+{
+	nvpair_t *nvp;
+
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
 		return (NULL);
 	}
 
-	nvp = nvpair_allocv(NV_TYPE_BINARY, (uint64_t)(uintptr_t)value, size,
-	    namefmt, nameap);
+	nvp = nvpair_allocv(name, NV_TYPE_NUMBER_ARRAY,
+	    (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
 	if (nvp == NULL) {
-		SAVE_ERRNO(serrno);
+		ERRNO_SAVE();
 		nv_free(value);
-		RESTORE_ERRNO(serrno);
+		ERRNO_RESTORE();
 	}
 
 	return (nvp);
 }
 
+nvpair_t *
+nvpair_move_nvlist_array(const char *name, nvlist_t **value, size_t nitems)
+{
+	unsigned int ii;
+	nvpair_t *nvp;
+	int flags;
+
+	nvp = NULL;
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	for (ii = 0; ii < nitems; ii++) {
+		if (value == NULL || nvlist_error(value[ii]) != 0 ||
+		    nvlist_get_pararr(value[ii], NULL) != NULL) {
+			ERRNO_SET(EINVAL);
+			goto fail;
+		}
+		if (ii > 0) {
+			nvp = nvpair_allocv(" ", NV_TYPE_NVLIST,
+			    (uint64_t)(uintptr_t)value[ii], 0, 0);
+			if (nvp == NULL)
+				goto fail;
+			nvlist_set_array_next(value[ii - 1], nvp);
+		}
+	}
+	flags = nvlist_flags(value[nitems - 1]) | NV_FLAG_IN_ARRAY;
+	nvlist_set_flags(value[nitems - 1], flags);
+
+	nvp = nvpair_allocv(name, NV_TYPE_NVLIST_ARRAY,
+	    (uint64_t)(uintptr_t)value, 0, nitems);
+fail:
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (ii = 0; ii < nitems; ii++) {
+			if (value[ii] != NULL &&
+			    nvlist_get_pararr(value[ii], NULL) != NULL) {
+				nvlist_destroy(value[ii]);
+			}
+			nv_free(value);
+		}
+		ERRNO_RESTORE();
+	} else {
+		for (ii = 0; ii < nitems; ii++)
+			nvlist_set_parent(value[ii], nvp);
+	}
+
+	return (nvp);
+}
+
+#ifndef _KERNEL
+nvpair_t *
+nvpair_move_descriptor_array(const char *name, int *value, size_t nitems)
+{
+	nvpair_t *nvp;
+	size_t i;
+
+	nvp = NULL;
+	if (value == NULL || nitems == 0) {
+		ERRNO_SET(EINVAL);
+		return (NULL);
+	}
+
+	for (i = 0; i < nitems; i++) {
+		if (value[i] != -1 && !fd_is_valid(value[i])) {
+			ERRNO_SET(EBADF);
+			goto fail;
+		}
+	}
+
+	nvp = nvpair_allocv(name, NV_TYPE_DESCRIPTOR_ARRAY,
+	    (uint64_t)(uintptr_t)value, sizeof(value[0]) * nitems, nitems);
+
+fail:
+	if (nvp == NULL) {
+		ERRNO_SAVE();
+		for (i = 0; i < nitems; i++) {
+			if (fd_is_valid(value[i]))
+				close(value[i]);
+		}
+		nv_free(value);
+		ERRNO_RESTORE();
+	}
+
+	return (nvp);
+}
+#endif
+
 bool
 nvpair_get_bool(const nvpair_t *nvp)
 {
@@ -1284,12 +1830,81 @@ nvpair_get_binary(const nvpair_t *nvp, size_t *sizep)
 
 	if (sizep != NULL)
 		*sizep = nvp->nvp_datasize;
+
 	return ((const void *)(intptr_t)nvp->nvp_data);
 }
 
+const bool *
+nvpair_get_bool_array(const nvpair_t *nvp, size_t *nitems)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_BOOL_ARRAY);
+
+	if (nitems != NULL)
+		*nitems = nvp->nvp_nitems;
+
+	return ((const bool *)(intptr_t)nvp->nvp_data);
+}
+
+const uint64_t *
+nvpair_get_number_array(const nvpair_t *nvp, size_t *nitems)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NUMBER_ARRAY);
+
+	if (nitems != NULL)
+		*nitems = nvp->nvp_nitems;
+
+	return ((const uint64_t *)(intptr_t)nvp->nvp_data);
+}
+
+const char * const *
+nvpair_get_string_array(const nvpair_t *nvp, size_t *nitems)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_STRING_ARRAY);
+
+	if (nitems != NULL)
+		*nitems = nvp->nvp_nitems;
+
+	return ((const char * const *)(intptr_t)nvp->nvp_data);
+}
+
+const nvlist_t * const *
+nvpair_get_nvlist_array(const nvpair_t *nvp, size_t *nitems)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_NVLIST_ARRAY);
+
+	if (nitems != NULL)
+		*nitems = nvp->nvp_nitems;
+
+	return ((const nvlist_t * const *)((intptr_t)nvp->nvp_data));
+}
+
+#ifndef _KERNEL
+const int *
+nvpair_get_descriptor_array(const nvpair_t *nvp, size_t *nitems)
+{
+
+	NVPAIR_ASSERT(nvp);
+	PJDLOG_ASSERT(nvp->nvp_type == NV_TYPE_DESCRIPTOR_ARRAY);
+
+	if (nitems != NULL)
+		*nitems = nvp->nvp_nitems;
+
+	return ((const int *)(intptr_t)nvp->nvp_data);
+}
+#endif
+
 void
 nvpair_free(nvpair_t *nvp)
 {
+	size_t i;
 
 	NVPAIR_ASSERT(nvp);
 	PJDLOG_ASSERT(nvp->nvp_list == NULL);
@@ -1300,6 +1915,10 @@ nvpair_free(nvpair_t *nvp)
 	case NV_TYPE_DESCRIPTOR:
 		close((int)nvp->nvp_data);
 		break;
+	case NV_TYPE_DESCRIPTOR_ARRAY:
+		for (i = 0; i < nvp->nvp_nitems; i++)
+			close(((int *)(intptr_t)nvp->nvp_data)[i]);
+		break;
 #endif
 	case NV_TYPE_NVLIST:
 		nvlist_destroy((nvlist_t *)(intptr_t)nvp->nvp_data);
@@ -1310,6 +1929,23 @@ nvpair_free(nvpair_t *nvp)
 	case NV_TYPE_BINARY:
 		nv_free((void *)(intptr_t)nvp->nvp_data);
 		break;
+	case NV_TYPE_NVLIST_ARRAY:
+		for (i = 0; i < nvp->nvp_nitems; i++) {
+			nvlist_destroy(
+			    ((nvlist_t **)(intptr_t)nvp->nvp_data)[i]);
+		}
+		nv_free(((nvlist_t **)(intptr_t)nvp->nvp_data));
+		break;
+	case NV_TYPE_NUMBER_ARRAY:
+		nv_free((uint64_t *)(intptr_t)nvp->nvp_data);
+		break;
+	case NV_TYPE_BOOL_ARRAY:
+		nv_free((bool *)(intptr_t)nvp->nvp_data);
+		break;
+	case NV_TYPE_STRING_ARRAY:
+		for (i = 0; i < nvp->nvp_nitems; i++)
+			nv_free(((char **)(intptr_t)nvp->nvp_data)[i]);
+		break;
 	}
 	nv_free(nvp);
 }
@@ -1344,7 +1980,18 @@ nvpair_type_string(int type)
 		return ("DESCRIPTOR");
 	case NV_TYPE_BINARY:
 		return ("BINARY");
+	case NV_TYPE_BOOL_ARRAY:
+		return ("BOOL ARRAY");
+	case NV_TYPE_NUMBER_ARRAY:
+		return ("NUMBER ARRAY");
+	case NV_TYPE_STRING_ARRAY:
+		return ("STRING ARRAY");
+	case NV_TYPE_NVLIST_ARRAY:
+		return ("NVLIST ARRAY");
+	case NV_TYPE_DESCRIPTOR_ARRAY:
+		return ("DESCRIPTOR ARRAY");
 	default:
 		return ("<UNKNOWN>");
 	}
 }
+
diff --git a/external/libnv/sys/nvpair_impl.h b/external/libnv/sys/nvpair_impl.h
index fbcd28ed..0350b1c1 100644
--- a/external/libnv/sys/nvpair_impl.h
+++ b/external/libnv/sys/nvpair_impl.h
@@ -1,5 +1,6 @@
 /*-
  * Copyright (c) 2009-2013 The FreeBSD Foundation
+ * Copyright (c) 2013-2015 Mariusz Zaborski <oshogbo@FreeBSD.org>
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
@@ -26,20 +27,19 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
- * $FreeBSD: head/sys/sys/nvpair_impl.h 279439 2015-03-01 00:34:27Z rstone $
+ * $FreeBSD$
  */
 
 #ifndef	_NVPAIR_IMPL_H_
 #define	_NVPAIR_IMPL_H_
 
+#include <sys/nv.h>
 #include <sys/queue.h>
 
 #ifndef _KERNEL
 #include <stdint.h>
 #endif
 
-#include "nv.h"
-
 TAILQ_HEAD(nvl_head, nvpair);
 
 void nvpair_assert(const nvpair_t *nvp);
@@ -72,6 +72,15 @@ unsigned char *nvpair_pack_descriptor(const nvpair_t *nvp, unsigned char *ptr,
 unsigned char *nvpair_pack_binary(const nvpair_t *nvp, unsigned char *ptr,
     size_t *leftp);
 unsigned char *nvpair_pack_nvlist_up(unsigned char *ptr, size_t *leftp);
+unsigned char *nvpair_pack_bool_array(const nvpair_t *nvp, unsigned char *ptr,
+    size_t *leftp);
+unsigned char *nvpair_pack_number_array(const nvpair_t *nvp, unsigned char *ptr,
+    size_t *leftp);
+unsigned char *nvpair_pack_string_array(const nvpair_t *nvp, unsigned char *ptr,
+    size_t *leftp);
+unsigned char *nvpair_pack_descriptor_array(const nvpair_t *nvp,
+    unsigned char *ptr, int64_t *fdidxp, size_t *leftp);
+unsigned char *nvpair_pack_nvlist_array_next(unsigned char *ptr, size_t *leftp);
 
 /* Unpack data functions. */
 const unsigned char *nvpair_unpack_header(bool isbe, nvpair_t *nvp,
@@ -85,10 +94,20 @@ const unsigned char *nvpair_unpack_number(bool isbe, nvpair_t *nvp,
 const unsigned char *nvpair_unpack_string(bool isbe, nvpair_t *nvp,
     const unsigned char *ptr, size_t *leftp);
 const unsigned char *nvpair_unpack_nvlist(bool isbe, nvpair_t *nvp,
-    const unsigned char *ptr, size_t *leftp, size_t nvlist, nvlist_t **child);
+    const unsigned char *ptr, size_t *leftp, size_t nfds, nvlist_t **child);
 const unsigned char *nvpair_unpack_descriptor(bool isbe, nvpair_t *nvp,
     const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds);
 const unsigned char *nvpair_unpack_binary(bool isbe, nvpair_t *nvp,
     const unsigned char *ptr, size_t *leftp);
+const unsigned char *nvpair_unpack_bool_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp);
+const unsigned char *nvpair_unpack_number_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp);
+const unsigned char *nvpair_unpack_string_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp);
+const unsigned char *nvpair_unpack_descriptor_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp, const int *fds, size_t nfds);
+const unsigned char *nvpair_unpack_nvlist_array(bool isbe, nvpair_t *nvp,
+    const unsigned char *ptr, size_t *leftp, nvlist_t **firstel);
 
 #endif	/* !_NVPAIR_IMPL_H_ */
diff --git a/external/libnv/tests/dnv_tests.cc b/external/libnv/tests/dnv_tests.cc
deleted file mode 100644
index 8f46f9c1..00000000
--- a/external/libnv/tests/dnv_tests.cc
+++ /dev/null
@@ -1,577 +0,0 @@
-/*-
- * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
- * All rights reserved.
- *
- * 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 AUTHOR 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 AUTHOR 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: head/lib/libnv/tests/dnv_tests.cc 279760 2015-03-08 00:30:52Z dim $");
-
-#include <atf-c++.hpp>
-#include <dnv.h>
-#include <nv.h>
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__present);
-ATF_TEST_CASE_BODY(dnvlist_get_bool__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	bool value;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	value = true;
-	nvlist_add_bool(nvl, key, value);
-
-	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), value);
-	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, false, "%c%s", 'n', "ame"), value);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_bool__default_value);
-ATF_TEST_CASE_BODY(dnvlist_get_bool__default_value)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	key = "123";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, key, false), false);
-	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, true, "%d", 123), true);
-
-	nvlist_add_bool(nvl, key, true);
-
-	ATF_REQUIRE_EQ(dnvlist_get_bool(nvl, "otherkey", true), true);
-	ATF_REQUIRE_EQ(dnvlist_getf_bool(nvl, false, "%d%c", 12, 'c'), false);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__present);
-ATF_TEST_CASE_BODY(dnvlist_get_number__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	uint64_t value;
-
-	nvl = nvlist_create(0);
-
-	key = "key";
-	value = 48952;
-	nvlist_add_number(nvl, key, value);
-
-	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 19), value);
-	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 65, "key"), value);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_number__default_value);
-ATF_TEST_CASE_BODY(dnvlist_get_number__default_value)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	key = "123";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, key, 5), 5);
-	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 12, "%s", key), 12);
-
-	nvlist_add_number(nvl, key, 24841);
-
-	ATF_REQUIRE_EQ(dnvlist_get_number(nvl, "hthth", 184), 184);
-	ATF_REQUIRE_EQ(dnvlist_getf_number(nvl, 5641, "%d", 1234), 5641);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__present);
-ATF_TEST_CASE_BODY(dnvlist_get_string__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	const char *value, *actual_value;
-
-	nvl = nvlist_create(0);
-
-	key = "string";
-	value = "fjdojfdi";
-	nvlist_add_string(nvl, key, value);
-
-	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "g"), value), 0);
-
-	actual_value = dnvlist_getf_string(nvl, "rs", "%s", key);
-	ATF_REQUIRE_EQ(strcmp(actual_value, value), 0);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_string__default_value);
-ATF_TEST_CASE_BODY(dnvlist_get_string__default_value)
-{
-	nvlist_t *nvl;
-	const char *key;
-	const char *actual_value;
-
-	key = "123";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, key, "bar"), "bar"), 0);
-
-	actual_value = dnvlist_getf_string(nvl, "d", "%s", key);
-	ATF_REQUIRE_EQ(strcmp(actual_value, "d"), 0);
-
-	nvlist_add_string(nvl, key, "cxhweh");
-
-	ATF_REQUIRE_EQ(strcmp(dnvlist_get_string(nvl, "hthth", "fd"), "fd"), 0);
-	actual_value = dnvlist_getf_string(nvl, "5", "%s", "5");
-	ATF_REQUIRE_EQ(strcmp("5", "5"), 0);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__present);
-ATF_TEST_CASE_BODY(dnvlist_get_nvlist__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	nvlist_t *value;
-	const nvlist_t *actual_value;
-
-	nvl = nvlist_create(0);
-
-	key = "nvlist";
-	value = nvlist_create(0);
-	nvlist_move_nvlist(nvl, key, value);
-
-	actual_value = dnvlist_get_nvlist(nvl, key, NULL);
-	ATF_REQUIRE(actual_value != NULL);
-	ATF_REQUIRE(nvlist_empty(actual_value));
-
-	actual_value = dnvlist_getf_nvlist(nvl, NULL, "%s", key);
-	ATF_REQUIRE(actual_value != NULL);
-	ATF_REQUIRE(nvlist_empty(actual_value));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_nvlist__default_value);
-ATF_TEST_CASE_BODY(dnvlist_get_nvlist__default_value)
-{
-	nvlist_t *nvl;
-	const char *key;
-	nvlist_t *dummy;
-
-	key = "123";
-	nvl = nvlist_create(0);
-	dummy = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, key, dummy), dummy);
-	ATF_REQUIRE_EQ(dnvlist_getf_nvlist(nvl, dummy, "%s", key), dummy);
-
-	nvlist_move_nvlist(nvl, key, nvlist_create(0));
-	ATF_REQUIRE_EQ(dnvlist_get_nvlist(nvl, "456", dummy), dummy);
-	ATF_REQUIRE_EQ(dnvlist_getf_nvlist(nvl, dummy, "%s", "gh"), dummy);
-
-	nvlist_destroy(nvl);
-}
-
-static void
-set_const_binary_value(const void *&value, size_t &size, const char *str)
-{
-
-	value = str;
-	size = strlen(str) + 1; /* +1 to include '\0' */
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__present);
-ATF_TEST_CASE_BODY(dnvlist_get_binary__present)
-{
-	nvlist_t *nvl;
-	const char *k;
-	const void *value, *actual_value;
-	size_t value_size, actual_size;
-
-	nvl = nvlist_create(0);
-
-	k = "binary";
-	set_const_binary_value(value, value_size, "fjdojfdi");
-	nvlist_add_binary(nvl, k, value, value_size);
-
-	actual_value = dnvlist_get_binary(nvl, k, &actual_size, "g", 1);
-	ATF_REQUIRE_EQ(value_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, value, actual_size), 0);
-
-	actual_value = dnvlist_getf_binary(nvl, &actual_size, "g", 1, "%s", k);
-	ATF_REQUIRE_EQ(value_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, value, actual_size), 0);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_get_binary__default_value);
-ATF_TEST_CASE_BODY(dnvlist_get_binary__default_value)
-{
-	nvlist_t *nvl;
-	const char *key;
-	const void *default_value, *actual_value;
-	size_t default_size, actual_size;
-
-	key = "123";
-	nvl = nvlist_create(0);
-
-	set_const_binary_value(default_value, default_size, "bar");
-	actual_value = dnvlist_get_binary(nvl, key, &actual_size, default_value,
-	    default_size);
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
-
-	set_const_binary_value(default_value, default_size, "atf");
-	actual_value = dnvlist_getf_binary(nvl, &actual_size, default_value,
-	    default_size, "%s", key);
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
-
-	nvlist_add_binary(nvl, key, "test", 4);
-
-	set_const_binary_value(default_value, default_size, "bthrg");
-	actual_value = dnvlist_get_binary(nvl, "k", &actual_size, default_value,
-	    default_size);
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
-
-	set_const_binary_value(default_value, default_size,
-	     "rrhgrythtyrtgbrhgrtdsvdfbtjlkul");
-	actual_value = dnvlist_getf_binary(nvl, &actual_size, default_value,
-	    default_size, "s");
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, default_value, actual_size), 0);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__present);
-ATF_TEST_CASE_BODY(dnvlist_take_bool__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	bool value;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	value = true;
-	nvlist_add_bool(nvl, key, value);
-
-	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, key, false), value);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__empty);
-ATF_TEST_CASE_BODY(dnvlist_take_bool__empty)
-{
-	nvlist_t *nvl;
-
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "123", false), false);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_bool__default_value);
-ATF_TEST_CASE_BODY(dnvlist_take_bool__default_value)
-{
-	nvlist_t *nvl;
-
-	nvl = nvlist_create(0);
-	nvlist_add_bool(nvl, "key", true);
-
-	ATF_REQUIRE_EQ(dnvlist_take_bool(nvl, "otherkey", true), true);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__present);
-ATF_TEST_CASE_BODY(dnvlist_take_number__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	uint64_t value;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	value = 194154;
-	nvlist_add_number(nvl, key, value);
-
-	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, key, 2), value);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__empty);
-ATF_TEST_CASE_BODY(dnvlist_take_number__empty)
-{
-	nvlist_t *nvl;
-
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "123", 126484), 126484);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_number__default_value);
-ATF_TEST_CASE_BODY(dnvlist_take_number__default_value)
-{
-	nvlist_t *nvl;
-
-	nvl = nvlist_create(0);
-	nvlist_add_number(nvl, "key", 12);
-
-	ATF_REQUIRE_EQ(dnvlist_take_number(nvl, "otherkey", 13), 13);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__present);
-ATF_TEST_CASE_BODY(dnvlist_take_string__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	const char *value;
-	char *default_val, *actual_val;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	value = "wrowm";
-	default_val = strdup("default");
-	nvlist_add_string(nvl, key, value);
-
-	actual_val = dnvlist_take_string(nvl, key, default_val);
-	ATF_REQUIRE_EQ(strcmp(actual_val, value), 0);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	free(actual_val);
-	free(default_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__empty);
-ATF_TEST_CASE_BODY(dnvlist_take_string__empty)
-{
-	nvlist_t *nvl;
-	char *default_val, *actual_val;
-
-	nvl = nvlist_create(0);
-	default_val = strdup("");
-
-	actual_val = dnvlist_take_string(nvl, "123", default_val);
-	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_string__default_value);
-ATF_TEST_CASE_BODY(dnvlist_take_string__default_value)
-{
-	nvlist_t *nvl;
-	char *default_val, *actual_val;
-
-	nvl = nvlist_create(0);
-	nvlist_add_string(nvl, "key", "foobar");
-	default_val = strdup("other");
-
-	actual_val = dnvlist_take_string(nvl, "otherkey", default_val);
-	ATF_REQUIRE_EQ(strcmp(actual_val, default_val), 0);
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__present);
-ATF_TEST_CASE_BODY(dnvlist_take_nvlist__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	nvlist_t *value, *default_val, *actual_val;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	value = nvlist_create(0);
-	default_val = nvlist_create(0);
-	nvlist_move_nvlist(nvl, key, value);
-
-	actual_val = dnvlist_take_nvlist(nvl, key, default_val);
-	ATF_REQUIRE_EQ(actual_val, value);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	free(actual_val);
-	free(default_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__empty);
-ATF_TEST_CASE_BODY(dnvlist_take_nvlist__empty)
-{
-	nvlist_t *nvl, *actual_val;
-
-	nvl = nvlist_create(0);
-
-	actual_val = dnvlist_take_nvlist(nvl, "123", NULL);
-	ATF_REQUIRE_EQ(actual_val, static_cast<nvlist_t *>(NULL));
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_nvlist__default_value);
-ATF_TEST_CASE_BODY(dnvlist_take_nvlist__default_value)
-{
-	nvlist_t *nvl;
-	nvlist_t *default_val, *actual_val;
-
-	nvl = nvlist_create(0);
-	nvlist_move_nvlist(nvl, "key", nvlist_create(0));
-	default_val = nvlist_create(0);
-
-	actual_val = dnvlist_take_nvlist(nvl, "otherkey", default_val);
-	ATF_REQUIRE_EQ(actual_val, default_val);
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-static void
-set_binary_value(void *&value, size_t &size, const char *str)
-{
-
-	value = strdup(str);
-	size = strlen(str) + 1; /* +1 to include '\0' */
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__present);
-ATF_TEST_CASE_BODY(dnvlist_take_binary__present)
-{
-	nvlist_t *nvl;
-	const char *key;
-	void *value, *default_val, *actual_val;
-	size_t value_size, default_size, actual_size;
-
-	nvl = nvlist_create(0);
-
-	key = "name";
-	set_binary_value(value, value_size, "fkdojvmo908");
-	set_binary_value(default_val, default_size, "16546");
-	nvlist_add_binary(nvl, key, value, value_size);
-
-	actual_val = dnvlist_take_binary(nvl, key, &actual_size, default_val,
-	    default_size);
-	ATF_REQUIRE_EQ(value_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_val, value, value_size), 0);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	free(actual_val);
-	free(default_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__empty);
-ATF_TEST_CASE_BODY(dnvlist_take_binary__empty)
-{
-	nvlist_t *nvl;
-	void *default_val, *actual_val;
-	size_t default_size, actual_size;
-
-	nvl = nvlist_create(0);
-	set_binary_value(default_val, default_size, "\xa8\x89\x49\xff\xe2\x08");
-
-	actual_val = dnvlist_take_binary(nvl, "123", &actual_size, default_val,
-	    default_size);
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, actual_size), 0);
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(dnvlist_take_binary__default_value);
-ATF_TEST_CASE_BODY(dnvlist_take_binary__default_value)
-{
-	nvlist_t *nvl;
-	void *default_val, *actual_val;
-	size_t default_size, actual_size;
-
-	nvl = nvlist_create(0);
-	nvlist_add_binary(nvl, "key", "foobar", 6);
-	set_binary_value(default_val, default_size, "vbhag");
-
-	actual_val = dnvlist_take_binary(nvl, "otherkey", &actual_size,
-	    default_val, default_size);
-	ATF_REQUIRE_EQ(default_size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_val, default_val, default_size), 0);
-
-	free(actual_val);
-	nvlist_destroy(nvl);
-}
-
-ATF_INIT_TEST_CASES(tp)
-{
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_bool__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_number__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_string__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_nvlist__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_get_binary__default_value);
-
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__empty);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_bool__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__empty);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_number__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__empty);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_string__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__empty);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_nvlist__default_value);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__present);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__empty);
-	ATF_ADD_TEST_CASE(tp, dnvlist_take_binary__default_value);
-}
diff --git a/external/libnv/tests/nv_tests.cc b/external/libnv/tests/nv_tests.cc
deleted file mode 100644
index fcdc8683..00000000
--- a/external/libnv/tests/nv_tests.cc
+++ /dev/null
@@ -1,1254 +0,0 @@
-/*-
- * Copyright (c) 2014-2015 Sandvine Inc.  All rights reserved.
- * All rights reserved.
- *
- * 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 AUTHOR 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 AUTHOR 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: head/lib/libnv/tests/nv_tests.cc 279760 2015-03-08 00:30:52Z dim $");
-
-#include <atf-c++.hpp>
-#include <nv.h>
-
-#include <errno.h>
-#include <limits>
-#include <set>
-#include <sstream>
-#include <string>
-
-/*
- * Test that a newly created nvlist has no errors, and is empty.
- */
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_create__is_empty);
-ATF_TEST_CASE_BODY(nvlist_create__is_empty)
-{
-	nvlist_t *nvl;
-	int type;
-	void *it;
-
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-
-	ATF_REQUIRE_EQ(nvlist_error(nvl), 0);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	it = NULL;
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_null__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_null__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key;
-	int type;
-
-	key = "key";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_null(nvl, key);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
-	ATF_REQUIRE(nvlist_exists_null(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_null(nvl, "key"));
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_bool__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_bool__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key;
-	int type;
-
-	key = "name";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_bool(nvl, key, true);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s%s", "na", "me"));
-	ATF_REQUIRE(nvlist_exists_bool(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_bool(nvl, "%s%c", "nam", 'e'));
-	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, key), true);
-	ATF_REQUIRE_EQ(nvlist_getf_bool(nvl, "%c%s", 'n', "ame"), true);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_BOOL);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_number__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_number__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key;
-	uint64_t value;
-	int type;
-
-	key = "foo123";
-	value = 71965;
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_number(nvl, key, value);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s%d", "foo", 123));
-	ATF_REQUIRE(nvlist_exists_number(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_number(nvl, "%s", key));
-	ATF_REQUIRE_EQ(nvlist_get_number(nvl, key), value);
-	ATF_REQUIRE_EQ(nvlist_getf_number(nvl, "%s", key), value);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_string__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_string__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key;
-	const char *value;
-	int type;
-
-	key = "test";
-	value = "fgjdkgjdk";
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_string(nvl, key, value);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
-	ATF_REQUIRE(nvlist_exists_string(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_string(nvl, "%s", key));
-	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, key), value), 0);
-	ATF_REQUIRE_EQ(strcmp(nvlist_getf_string(nvl, "%s", key), value), 0);
-
-	/* nvlist_add_* is required to clone the value, so check for that. */
-	ATF_REQUIRE(nvlist_get_string(nvl, key) != value);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_nvlist__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key, *subkey;
-	nvlist_t *sublist;
-	const nvlist_t *value;
-	int type;
-
-	key = "test";
-	subkey = "subkey";
-	sublist = nvlist_create(0);
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_null(sublist, subkey);
-	nvlist_add_nvlist(nvl, key, sublist);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
-	ATF_REQUIRE(nvlist_exists_nvlist(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_nvlist(nvl, "%s", key));
-
-	value = nvlist_get_nvlist(nvl, key);
-	ATF_REQUIRE(nvlist_exists_null(value, subkey));
-
-	/* nvlist_add_* is required to clone the value, so check for that. */
-	ATF_REQUIRE(sublist != value);
-
-	value = nvlist_getf_nvlist(nvl, "%s", key);
-	ATF_REQUIRE(nvlist_exists_null(value, subkey));
-	ATF_REQUIRE(sublist != value);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(sublist);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_nvlist__child_with_error);
-ATF_TEST_CASE_BODY(nvlist_add_nvlist__child_with_error)
-{
-	nvlist_t *nvl, *parent;
-
-	nvl = nvlist_create(0);
-	parent = nvlist_create(0);
-
-	nvlist_set_error(nvl, EBADF);
-	nvlist_add_nvlist(parent, "test", nvl);
-	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
-
-	nvlist_destroy(nvl);
-	nvlist_destroy(parent);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_add_binary__single_insert);
-ATF_TEST_CASE_BODY(nvlist_add_binary__single_insert)
-{
-	nvlist_t *nvl;
-	void *it;
-	const char *key;
-	void *value;
-	const void *ret_value;
-	size_t value_size, ret_size;
-	int type;
-
-	key = "binary";
-	value_size = 13;
-	value = malloc(value_size);
-	memset(value, 0xa5, value_size);
-	nvl = nvlist_create(0);
-
-	ATF_REQUIRE(nvl != NULL);
-	ATF_REQUIRE(!nvlist_exists(nvl, key));
-
-	nvlist_add_binary(nvl, key, value, value_size);
-
-	ATF_REQUIRE(!nvlist_empty(nvl));
-	ATF_REQUIRE(nvlist_exists(nvl, key));
-	ATF_REQUIRE(nvlist_existsf(nvl, "%s", key));
-	ATF_REQUIRE(nvlist_exists_binary(nvl, key));
-	ATF_REQUIRE(nvlist_existsf_binary(nvl, "%s", key));
-
-	ret_value = nvlist_get_binary(nvl, key, &ret_size);
-	ATF_REQUIRE_EQ(value_size, ret_size);
-	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
-
-	/* nvlist_add_* is required to clone the value, so check for that. */
-	ATF_REQUIRE(value != ret_value);
-
-	ret_value = nvlist_getf_binary(nvl, &ret_size, "%s", key);
-	ATF_REQUIRE_EQ(value_size, ret_size);
-	ATF_REQUIRE_EQ(memcmp(value, ret_value, ret_size), 0);
-	ATF_REQUIRE(value != ret_value);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type,&it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(nvl);
-	free(value);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__empty_nvlist);
-ATF_TEST_CASE_BODY(nvlist_clone__empty_nvlist)
-{
-	nvlist_t *nvl, *clone;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	clone = nvlist_clone(nvl);
-	ATF_REQUIRE(clone != NULL);
-	ATF_REQUIRE(clone != nvl);
-	ATF_REQUIRE(nvlist_empty(clone));
-
-	nvlist_destroy(clone);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nonempty_nvlist);
-ATF_TEST_CASE_BODY(nvlist_clone__nonempty_nvlist)
-{
-	nvlist_t *nvl, *clone;
-	const char *key;
-	void *it;
-	uint64_t value;
-	int type;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	key = "testkey";
-	value = 684874;
-	nvlist_add_number(nvl, key, value);
-
-	clone = nvlist_clone(nvl);
-	ATF_REQUIRE(clone != NULL);
-	ATF_REQUIRE(clone != nvl);
-	ATF_REQUIRE(nvlist_exists_number(clone, key));
-	ATF_REQUIRE_EQ(nvlist_get_number(clone, key), value);
-
-	/* Iterate over the nvlist; ensure that it has only our one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(clone, &type, &it), key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
-	ATF_REQUIRE_EQ(nvlist_next(clone, &type, &it), static_cast<const char *>(NULL));
-
-	nvlist_destroy(clone);
-	nvlist_destroy(nvl);
-}
-
-static const char * const test_subnvlist_key = "nvlist";
-
-static const char * const test_string_key = "string";
-static const char * const test_string_val = "59525";
-
-static nvlist_t*
-create_test_nvlist(void)
-{
-	nvlist_t *nvl, *sublist;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	sublist = nvlist_create(0);
-	ATF_REQUIRE(sublist != NULL);
-
-	nvlist_add_string(sublist, test_string_key, test_string_val);
-	nvlist_move_nvlist(nvl, test_subnvlist_key, sublist);
-
-	return (nvl);
-}
-
-static void
-verify_test_nvlist(const nvlist_t *nvl)
-{
-	void *it;
-	const nvlist_t *value;
-	int type;
-
-	ATF_REQUIRE(nvlist_exists_nvlist(nvl, test_subnvlist_key));
-
-	value = nvlist_get_nvlist(nvl, test_subnvlist_key);
-
-	ATF_REQUIRE(nvlist_exists_string(value, test_string_key));
-	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(value, test_string_key), test_string_val), 0);
-	ATF_REQUIRE(nvlist_get_string(value, test_string_key) != test_string_val);
-
-	/* Iterate over both nvlists; ensure that each has only the one key. */
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(value, &type, &it),
-	    test_string_key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
-	ATF_REQUIRE_EQ(nvlist_next(value, &type, &it), static_cast<const char *>(NULL));
-
-	it = NULL;
-	ATF_REQUIRE_EQ(strcmp(nvlist_next(nvl, &type, &it),
-	    test_subnvlist_key), 0);
-	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
-	ATF_REQUIRE_EQ(nvlist_next(nvl, &type, &it), static_cast<const char *>(NULL));
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__nested_nvlist);
-ATF_TEST_CASE_BODY(nvlist_clone__nested_nvlist)
-{
-	nvlist_t *nvl, *clone;
-
-	nvl = create_test_nvlist();
-	clone = nvlist_clone(nvl);
-
-	ATF_REQUIRE(clone != NULL);
-	ATF_REQUIRE(clone != nvl);
-	verify_test_nvlist(clone);
-
-	nvlist_destroy(clone);
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_clone__error_nvlist);
-ATF_TEST_CASE_BODY(nvlist_clone__error_nvlist)
-{
-	nvlist_t *nvl, *clone;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	nvlist_set_error(nvl, ENOMEM);
-
-	clone = nvlist_clone(nvl);
-	ATF_REQUIRE(clone == NULL);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__empty_nvlist);
-ATF_TEST_CASE_BODY(nvlist_pack__empty_nvlist)
-{
-	nvlist_t *nvl, *unpacked;
-	void *packed;
-	size_t packed_size;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	packed = nvlist_pack(nvl, &packed_size);
-	ATF_REQUIRE(packed != NULL);
-
-	unpacked = nvlist_unpack(packed, packed_size);
-	ATF_REQUIRE(unpacked != NULL);
-	ATF_REQUIRE(unpacked != nvl);
-	ATF_REQUIRE(nvlist_empty(unpacked));
-
-	nvlist_destroy(unpacked);
-	nvlist_destroy(nvl);
-	free(packed);
-}
-
-static void
-verify_null(const nvlist_t *nvl, int type)
-{
-
-	ATF_REQUIRE_EQ(type, NV_TYPE_NULL);
-}
-
-static void
-verify_number(const nvlist_t *nvl, const char *name, int type, uint64_t value)
-{
-
-	ATF_REQUIRE_EQ(type, NV_TYPE_NUMBER);
-	ATF_REQUIRE_EQ(nvlist_get_number(nvl, name), value);
-}
-
-static void
-verify_string(const nvlist_t *nvl, const char *name, int type,
-    const char * value)
-{
-
-	ATF_REQUIRE_EQ(type, NV_TYPE_STRING);
-	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, name), value), 0);
-}
-
-static void
-verify_nvlist(const nvlist_t *nvl, const char *name, int type)
-{
-
-	ATF_REQUIRE_EQ(type, NV_TYPE_NVLIST);
-	verify_test_nvlist(nvlist_get_nvlist(nvl, name));
-}
-
-static void
-verify_binary(const nvlist_t *nvl, const char *name, int type,
-    const void * value, size_t size)
-{
-	const void *actual_value;
-	size_t actual_size;
-
-	ATF_REQUIRE_EQ(type, NV_TYPE_BINARY);
-	actual_value = nvlist_get_binary(nvl, name, &actual_size);
-	ATF_REQUIRE_EQ(size, actual_size);
-	ATF_REQUIRE_EQ(memcmp(value, actual_value, size), 0);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__multiple_values);
-ATF_TEST_CASE_BODY(nvlist_pack__multiple_values)
-{
-	std::ostringstream msg;
-	std::set<std::string> keys_seen;
-	nvlist_t *nvl, *unpacked, *nvvalue;
-	const char *nullkey, *numkey, *strkey, *nvkey, *binkey, *name;
-	int numvalue;
-	const char * strvalue;
-	void *binvalue, *packed, *it;
-	size_t binsize, packed_size;
-	int type;
-
-	nvl = nvlist_create(0);
-
-	nullkey = "null";
-	nvlist_add_null(nvl, nullkey);
-
-	numkey = "number";
-	numvalue = 939853984;
-	nvlist_add_number(nvl, numkey, numvalue);
-
-	strkey = "string";
-	strvalue = "jfieutijf";
-	nvlist_add_string(nvl, strkey, strvalue);
-
-	nvkey = "nvlist";
-	nvvalue = create_test_nvlist();
-	nvlist_move_nvlist(nvl, nvkey, nvvalue);
-
-	binkey = "binary";
-	binsize = 4;
-	binvalue = malloc(binsize);
-	memset(binvalue, 'b', binsize);
-	nvlist_move_binary(nvl, binkey, binvalue, binsize);
-
-	packed = nvlist_pack(nvl, &packed_size);
-	ATF_REQUIRE(packed != NULL);
-
-	unpacked = nvlist_unpack(packed, packed_size);
-	ATF_REQUIRE(unpacked != 0);
-
-	it = NULL;
-	while ((name = nvlist_next(unpacked, &type, &it)) != NULL) {
-		/* Ensure that we see every key only once. */
-		ATF_REQUIRE_EQ(keys_seen.count(name), 0);
-
-		if (strcmp(name, nullkey) == 0)
-			verify_null(unpacked, type);
-		else if (strcmp(name, numkey) == 0)
-			verify_number(unpacked, name, type, numvalue);
-		else if (strcmp(name, strkey) == 0)
-			verify_string(unpacked, name, type, strvalue);
-		else if (strcmp(name, nvkey) == 0)
-			verify_nvlist(unpacked, name, type);
-		else if (strcmp(name, binkey) == 0)
-			verify_binary(unpacked, name, type, binvalue, binsize);
-		else {
-			msg << "Unexpected key :'" << name << "'";
-			ATF_FAIL(msg.str().c_str());
-		}
-
-		keys_seen.insert(name);
-	}
-
-	/* Ensure that we saw every key. */
-	ATF_REQUIRE_EQ(keys_seen.size(), 5);
-
-	nvlist_destroy(nvl);
-	nvlist_destroy(unpacked);
-	free(packed);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_pack__error_nvlist);
-ATF_TEST_CASE_BODY(nvlist_pack__error_nvlist)
-{
-	nvlist_t *nvl;
-	void *packed;
-	size_t size;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	nvlist_set_error(nvl, ENOMEM);
-
-	packed = nvlist_pack(nvl, &size);
-	ATF_REQUIRE(packed == NULL);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_unpack__duplicate_key);
-ATF_TEST_CASE_BODY(nvlist_unpack__duplicate_key)
-{
-	nvlist_t *nvl, *unpacked;
-	const char *key1, *key2;
-	void *packed, *keypos;
-	size_t size, keylen;
-
-	nvl = nvlist_create(0);
-
-	key1 = "key1";
-	keylen = strlen(key1);
-	nvlist_add_number(nvl, key1, 5);
-
-	key2 = "key2";
-	ATF_REQUIRE_EQ(keylen, strlen(key2));
-	nvlist_add_number(nvl, key2, 10);
-
-	packed = nvlist_pack(nvl, &size);
-
-	/*
-	 * Mangle the packed nvlist by replacing key1 with key2, creating a
-	 * packed nvlist with a duplicate key.
-	 */
-	keypos = memmem(packed, size, key1, keylen);
-	ATF_REQUIRE(keypos != NULL);
-	memcpy(keypos, key2, keylen);
-
-	unpacked = nvlist_unpack(packed, size);
-	ATF_REQUIRE(nvlist_error(unpacked) != 0);
-
-	free(packed);
-	nvlist_destroy(nvl);
-	nvlist_destroy(unpacked);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_string__single_insert);
-ATF_TEST_CASE_BODY(nvlist_move_string__single_insert)
-{
-	nvlist_t *nvl;
-	const char *key;
-	char *value;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	key = "testkey";
-	value = strdup("testval");
-	ATF_REQUIRE(value != NULL);
-
-	nvlist_move_string(nvl, key, value);
-	ATF_REQUIRE_EQ(nvlist_get_string(nvl, key), value);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__null_child);
-ATF_TEST_CASE_BODY(nvlist_move_nvlist__null_child)
-{
-	nvlist_t *parent;
-
-	parent = nvlist_create(0);
-
-	nvlist_move_nvlist(parent, "test", NULL);
-
-	ATF_REQUIRE(nvlist_error(parent) != 0);
-
-	nvlist_destroy(parent);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__child_with_error);
-ATF_TEST_CASE_BODY(nvlist_move_nvlist__child_with_error)
-{
-	nvlist_t *nvl, *parent;
-
-	nvl = nvlist_create(0);
-	parent = nvlist_create(0);
-
-	nvlist_set_error(nvl, EBADF);
-	nvlist_move_nvlist(parent, "test", nvl);
-	ATF_REQUIRE_EQ(nvlist_error(parent), EBADF);
-
-	nvlist_destroy(parent);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_nvlist__single_insert);
-ATF_TEST_CASE_BODY(nvlist_move_nvlist__single_insert)
-{
-	nvlist_t *nvl;
-	const char *key;
-	nvlist_t *value;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	key = "testkey";
-	value = nvlist_create(0);
-	ATF_REQUIRE(value != NULL);
-
-	nvlist_move_nvlist(nvl, key, value);
-	ATF_REQUIRE_EQ(nvlist_get_nvlist(nvl, key), value);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_move_binary__single_insert);
-ATF_TEST_CASE_BODY(nvlist_move_binary__single_insert)
-{
-	nvlist_t *nvl;
-	const char *key;
-	void *value;
-	size_t size, actual_size;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	key = "testkey";
-	size = 73;
-	value = malloc(size);
-	ATF_REQUIRE(value != NULL);
-
-	nvlist_move_binary(nvl, key, value, size);
-	ATF_REQUIRE_EQ(nvlist_get_binary(nvl, key, &actual_size), value);
-	ATF_REQUIRE_EQ(size, actual_size);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__single_remove);
-ATF_TEST_CASE_BODY(nvlist_take_bool__single_remove)
-{
-	nvlist_t *nvl;
-	const char *testkey;
-	bool testval;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "boolkey";
-	testval = false;
-	nvlist_add_bool(nvl, testkey, testval);
-
-	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_bool__other_keys_unchanged);
-ATF_TEST_CASE_BODY(nvlist_take_bool__other_keys_unchanged)
-{
-	nvlist_t *nvl;
-	const char *testkey, *otherkey1, *otherkey2;
-	bool testval, otherval1;
-	nvlist_t *otherval2;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "boolkey";
-	testval = true;
-	nvlist_add_bool(nvl, testkey, testval);
-
-	otherkey1 = "key1";
-	otherval1 = false;
-	nvlist_add_bool(nvl, otherkey1, otherval1);
-
-	otherkey2 = "key2";
-	otherval2 = create_test_nvlist();
-	nvlist_move_nvlist(nvl, otherkey2, otherval2);
-
-	ATF_REQUIRE_EQ(nvlist_take_bool(nvl, testkey), testval);
-
-	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey1));
-	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey1), otherval1);
-
-	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey2));
-	verify_test_nvlist(nvlist_get_nvlist(nvl, otherkey2));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__single_remove);
-ATF_TEST_CASE_BODY(nvlist_take_number__single_remove)
-{
-	nvlist_t *nvl;
-	const char *testkey;
-	uint64_t testval;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "numkey";
-	testval = std::numeric_limits<uint64_t>::max();
-	nvlist_add_number(nvl, testkey, testval);
-
-	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_number__other_keys_unchanged);
-ATF_TEST_CASE_BODY(nvlist_take_number__other_keys_unchanged)
-{
-	nvlist_t *nvl;
-	const char *testkey, *otherkey1, *otherkey2;
-	uint64_t testval, otherval1;
-	const char *otherval2;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	otherkey1 = "key1";
-	otherval1 = 5;
-	nvlist_add_number(nvl, otherkey1, otherval1);
-
-	testkey = "numkey";
-	testval = 1654;
-	nvlist_add_number(nvl, testkey, testval);
-
-	otherkey2 = "key2";
-	otherval2 = "string";
-	nvlist_add_string(nvl, otherkey2, otherval2);
-
-	ATF_REQUIRE_EQ(nvlist_take_number(nvl, testkey), testval);
-
-	ATF_REQUIRE(nvlist_exists_number(nvl, otherkey1));
-	ATF_REQUIRE_EQ(nvlist_get_number(nvl, otherkey1), otherval1);
-
-	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey2));
-	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey2), otherval2), 0);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__single_remove);
-ATF_TEST_CASE_BODY(nvlist_take_string__single_remove)
-{
-	nvlist_t *nvl;
-	const char *testkey;
-	const char *testval;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "numkey";
-	testval = "nvlist";
-	nvlist_add_string(nvl, testkey, testval);
-
-	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_string__other_keys_unchanged);
-ATF_TEST_CASE_BODY(nvlist_take_string__other_keys_unchanged)
-{
-	nvlist_t *nvl;
-	const char *testkey, *otherkey1, *otherkey2;
-	const char *testval, *otherval1;
-	bool otherval2;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	otherkey1 = "key1";
-	otherval1 = "fjdifjdk";
-	nvlist_add_string(nvl, otherkey1, otherval1);
-
-	otherkey2 = "key2";
-	otherval2 = true;
-	nvlist_add_bool(nvl, otherkey2, otherval2);
-
-	testkey = "strkey";
-	testval = "1654";
-	nvlist_add_string(nvl, testkey, testval);
-
-	ATF_REQUIRE_EQ(strcmp(nvlist_take_string(nvl, testkey), testval), 0);
-
-	ATF_REQUIRE(nvlist_exists_string(nvl, otherkey1));
-	ATF_REQUIRE_EQ(strcmp(nvlist_get_string(nvl, otherkey1), otherval1), 0);
-
-	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
-	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__single_remove);
-ATF_TEST_CASE_BODY(nvlist_take_nvlist__single_remove)
-{
-	nvlist_t *nvl;
-	const char *testkey;
-	nvlist_t *testval;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "numkey";
-	testval = create_test_nvlist();
-	nvlist_move_nvlist(nvl, testkey, testval);
-
-	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_nvlist__other_keys_unchanged);
-ATF_TEST_CASE_BODY(nvlist_take_nvlist__other_keys_unchanged)
-{
-	nvlist_t *nvl;
-	const char *testkey, *otherkey1, *otherkey2;
-	nvlist_t *testval, *otherval1;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "strkey";
-	testval = create_test_nvlist();
-	nvlist_move_nvlist(nvl, testkey, testval);
-
-	otherkey1 = "key1";
-	otherval1 = nvlist_create(0);
-	nvlist_move_nvlist(nvl, otherkey1, otherval1);
-
-	otherkey2 = "key2";
-	nvlist_add_null(nvl, otherkey2);
-
-	verify_test_nvlist(nvlist_take_nvlist(nvl, testkey));
-
-	ATF_REQUIRE(nvlist_exists_nvlist(nvl, otherkey1));
-	ATF_REQUIRE(nvlist_empty(nvlist_get_nvlist(nvl, otherkey1)));
-
-	ATF_REQUIRE(nvlist_exists_null(nvl, otherkey2));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__single_remove);
-ATF_TEST_CASE_BODY(nvlist_take_binary__single_remove)
-{
-	nvlist_t *nvl;
-	const char *testkey;
-	void *testval;
-	const void *actual_val;
-	size_t testsize, actual_size;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	testkey = "numkey";
-	testsize = 457;
-	testval = malloc(testsize);
-	memset(testval, '5', testsize);
-	nvlist_move_binary(nvl, testkey, testval, testsize);
-
-	actual_val = nvlist_take_binary(nvl, testkey, &actual_size);
-	ATF_REQUIRE_EQ(testsize, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_val, testval, testsize), 0);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_take_binary__other_keys_unchanged);
-ATF_TEST_CASE_BODY(nvlist_take_binary__other_keys_unchanged)
-{
-	nvlist_t *nvl;
-	const char *testkey, *otherkey1, *otherkey2;
-	const void *actual_value;
-	char testval[] = "gjiertj";
-	char otherval1[] = "fdreg";
-	size_t testsize, othersize, actual_size;
-	bool otherval2;
-
-	nvl = nvlist_create(0);
-	ATF_REQUIRE(nvl != NULL);
-
-	otherkey1 = "key1";
-	othersize = sizeof(otherval1);
-	nvlist_add_binary(nvl, otherkey1, otherval1, othersize);
-
-	otherkey2 = "key2";
-	otherval2 = true;
-	nvlist_add_bool(nvl, otherkey2, otherval2);
-
-	testkey = "strkey";
-	testsize = sizeof(testval);
-	nvlist_add_binary(nvl, testkey, testval, testsize);
-
-	actual_value = nvlist_take_binary(nvl, testkey, &actual_size);
-	ATF_REQUIRE_EQ(testsize, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, testval, testsize), 0);
-
-	ATF_REQUIRE(nvlist_exists_binary(nvl, otherkey1));
-	actual_value = nvlist_get_binary(nvl, otherkey1, &actual_size);
-	ATF_REQUIRE_EQ(othersize, actual_size);
-	ATF_REQUIRE_EQ(memcmp(actual_value, otherval1, othersize), 0);
-
-	ATF_REQUIRE(nvlist_exists_bool(nvl, otherkey2));
-	ATF_REQUIRE_EQ(nvlist_get_bool(nvl, otherkey2), otherval2);
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_null);
-ATF_TEST_CASE_BODY(nvlist_free__single_null)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_null(nvl, key);
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_bool);
-ATF_TEST_CASE_BODY(nvlist_free__single_bool)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_bool(nvl, key, true);
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_number);
-ATF_TEST_CASE_BODY(nvlist_free__single_number)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_number(nvl, key, 584);
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_string);
-ATF_TEST_CASE_BODY(nvlist_free__single_string)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_string(nvl, key, "gjkfkjd");
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_nvlist);
-ATF_TEST_CASE_BODY(nvlist_free__single_nvlist)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_nvlist(nvl, key, nvlist_create(0));
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free__single_binary);
-ATF_TEST_CASE_BODY(nvlist_free__single_binary)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_binary(nvl, key, "jgjgfd", 6);
-
-	nvlist_free(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_null__single_null);
-ATF_TEST_CASE_BODY(nvlist_free_null__single_null)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_null(nvl, key);
-
-	nvlist_free_null(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_bool__single_bool);
-ATF_TEST_CASE_BODY(nvlist_free_bool__single_bool)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_bool(nvl, key, true);
-
-	nvlist_free_bool(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_number__single_number);
-ATF_TEST_CASE_BODY(nvlist_free_number__single_number)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_number(nvl, key, 584);
-
-	nvlist_free_number(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_string__single_string);
-ATF_TEST_CASE_BODY(nvlist_free_string__single_string)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_string(nvl, key, "gjkfkjd");
-
-	nvlist_free_string(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_nvlist__single_nvlist);
-ATF_TEST_CASE_BODY(nvlist_free_nvlist__single_nvlist)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_nvlist(nvl, key, nvlist_create(0));
-
-	nvlist_free_nvlist(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_TEST_CASE_WITHOUT_HEAD(nvlist_free_binary__single_binary);
-ATF_TEST_CASE_BODY(nvlist_free_binary__single_binary)
-{
-	nvlist_t *nvl;
-	const char *key;
-
-	nvl = nvlist_create(0);
-	key = "test";
-	nvlist_add_binary(nvl, key, "jgjgfd", 6);
-
-	nvlist_free_binary(nvl, key);
-	ATF_REQUIRE(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-}
-
-ATF_INIT_TEST_CASES(tp)
-{
-	ATF_ADD_TEST_CASE(tp, nvlist_create__is_empty);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_null__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_bool__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_number__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_string__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_nvlist__child_with_error);
-	ATF_ADD_TEST_CASE(tp, nvlist_add_binary__single_insert);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_clone__empty_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_clone__nonempty_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_clone__nested_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_clone__error_nvlist);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_pack__empty_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_pack__multiple_values);
-	ATF_ADD_TEST_CASE(tp, nvlist_pack__error_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_unpack__duplicate_key);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_move_string__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__single_insert);
-	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__null_child);
-	ATF_ADD_TEST_CASE(tp, nvlist_move_nvlist__child_with_error);
-	ATF_ADD_TEST_CASE(tp, nvlist_move_binary__single_insert);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__single_remove);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_bool__other_keys_unchanged);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_number__single_remove);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_number__other_keys_unchanged);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_string__single_remove);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_string__other_keys_unchanged);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__single_remove);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_nvlist__other_keys_unchanged);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__single_remove);
-	ATF_ADD_TEST_CASE(tp, nvlist_take_binary__other_keys_unchanged);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_null);
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_bool);
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_number);
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_string);
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_free__single_binary);
-
-	ATF_ADD_TEST_CASE(tp, nvlist_free_null__single_null);
-	ATF_ADD_TEST_CASE(tp, nvlist_free_bool__single_bool);
-	ATF_ADD_TEST_CASE(tp, nvlist_free_number__single_number);
-	ATF_ADD_TEST_CASE(tp, nvlist_free_string__single_string);
-	ATF_ADD_TEST_CASE(tp, nvlist_free_nvlist__single_nvlist);
-	ATF_ADD_TEST_CASE(tp, nvlist_free_binary__single_binary);
-}
diff --git a/external/libnv/tests/nvlist_add_test.c b/external/libnv/tests/nvlist_add_test.c
deleted file mode 100644
index 1847146d..00000000
--- a/external/libnv/tests/nvlist_add_test.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_add_test.c 269603 2014-08-05 18:41:27Z ngie $
- */
-
-#include <errno.h>
-#include <stdio.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-int
-main(void)
-{
-	const nvlist_t *cnvl;
-	nvlist_t *nvl;
-
-	printf("1..94\n");
-
-	nvl = nvlist_create(0);
-
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	nvlist_add_null(nvl, "nvlist/null");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/true"));
-	nvlist_add_bool(nvl, "nvlist/bool/true", true);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool/true"));
-
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/false"));
-	nvlist_add_bool(nvl, "nvlist/bool/false", false);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool/false"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/0"));
-	nvlist_add_number(nvl, "nvlist/number/0", 0);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/0"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/1"));
-	nvlist_add_number(nvl, "nvlist/number/1", 1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/1"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/-1"));
-	nvlist_add_number(nvl, "nvlist/number/-1", -1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/-1"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
-	nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
-	nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
-	nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/"));
-	nvlist_add_string(nvl, "nvlist/string/", "");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/x"));
-	nvlist_add_string(nvl, "nvlist/string/x", "x");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/"));
-	nvlist_add_stringf(nvl, "nvlist/stringf/", "%s", "");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/x"));
-	nvlist_add_stringf(nvl, "nvlist/stringf/x", "%s", "x");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/x"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
-	nvlist_add_stringf(nvl, "nvlist/stringf/666Xabc", "%d%c%s", 666, 'X', "abc");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
-
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-	nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
-
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool/true"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool/false"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/0"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/1"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/-1"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/x"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/stringf/666Xabc"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-
-	cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist");
-	CHECK(nvlist_exists_null(cnvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(cnvl, "nvlist/bool/true"));
-	CHECK(nvlist_exists_bool(cnvl, "nvlist/bool/false"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/0"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/1"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/-1"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/UINT64_MAX"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/INT64_MIN"));
-	CHECK(nvlist_exists_number(cnvl, "nvlist/number/INT64_MAX"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/string/"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/string/x"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/x"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/stringf/666Xabc"));
-	CHECK(nvlist_exists_descriptor(cnvl, "nvlist/descriptor/STDERR_FILENO"));
-	CHECK(nvlist_exists_binary(cnvl, "nvlist/binary/x"));
-	CHECK(nvlist_exists_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-
-	nvlist_destroy(nvl);
-
-	return (0);
-}
diff --git a/external/libnv/tests/nvlist_exists_test.c b/external/libnv/tests/nvlist_exists_test.c
deleted file mode 100644
index cd8fc363..00000000
--- a/external/libnv/tests/nvlist_exists_test.c
+++ /dev/null
@@ -1,321 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_exists_test.c 269603 2014-08-05 18:41:27Z ngie $
- */
-
-#include <stdio.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-int
-main(void)
-{
-	nvlist_t *nvl;
-
-	printf("1..232\n");
-
-	nvl = nvlist_create(0);
-
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/null"));
-	nvlist_add_null(nvl, "nvlist/null");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/null"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/bool"));
-	nvlist_add_bool(nvl, "nvlist/bool", true);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/bool"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/number"));
-	nvlist_add_number(nvl, "nvlist/number", 0);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/number"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/string"));
-	nvlist_add_string(nvl, "nvlist/string", "test");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/string"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/nvlist"));
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/nvlist"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/descriptor"));
-	nvlist_add_descriptor(nvl, "nvlist/descriptor", STDERR_FILENO);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/descriptor"));
-
-	CHECK(!nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
-	nvlist_add_binary(nvl, "nvlist/binary", "test", 4);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/binary"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	CHECK(nvlist_exists(nvl, "nvlist/null"));
-	CHECK(nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists(nvl, "nvlist/number"));
-	CHECK(nvlist_exists(nvl, "nvlist/string"));
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_null(nvl, "nvlist/null");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists(nvl, "nvlist/number"));
-	CHECK(nvlist_exists(nvl, "nvlist/string"));
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_bool(nvl, "nvlist/bool");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists(nvl, "nvlist/number"));
-	CHECK(nvlist_exists(nvl, "nvlist/string"));
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_number(nvl, "nvlist/number");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(nvlist_exists(nvl, "nvlist/string"));
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_string(nvl, "nvlist/string");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists(nvl, "nvlist/string"));
-	CHECK(nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_nvlist(nvl, "nvlist/nvlist");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_descriptor(nvl, "nvlist/descriptor");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_binary(nvl, "nvlist/binary");
-	CHECK(!nvlist_exists(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists(nvl, "nvlist/binary"));
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	CHECK(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-
-	return (0);
-}
diff --git a/external/libnv/tests/nvlist_free_test.c b/external/libnv/tests/nvlist_free_test.c
deleted file mode 100644
index fe6ff9c4..00000000
--- a/external/libnv/tests/nvlist_free_test.c
+++ /dev/null
@@ -1,221 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_free_test.c 269603 2014-08-05 18:41:27Z ngie $
- */
-
-#include <stdio.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-int
-main(void)
-{
-	nvlist_t *nvl;
-
-	printf("1..114\n");
-
-	nvl = nvlist_create(0);
-
-	nvlist_add_null(nvl, "nvlist/null");
-	nvlist_add_bool(nvl, "nvlist/bool", true);
-	nvlist_add_number(nvl, "nvlist/number", 0);
-	nvlist_add_string(nvl, "nvlist/string", "test");
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-	nvlist_add_descriptor(nvl, "nvlist/descriptor", STDERR_FILENO);
-	nvlist_add_binary(nvl, "nvlist/binary", "test", 4);
-
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_null(nvl, "nvlist/null");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_bool(nvl, "nvlist/bool");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_number(nvl, "nvlist/number");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_string(nvl, "nvlist/string");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_nvlist(nvl, "nvlist/nvlist");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_descriptor(nvl, "nvlist/descriptor");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free_binary(nvl, "nvlist/binary");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	CHECK(nvlist_empty(nvl));
-
-	nvlist_add_null(nvl, "nvlist/null");
-	nvlist_add_bool(nvl, "nvlist/bool", true);
-	nvlist_add_number(nvl, "nvlist/number", 0);
-	nvlist_add_string(nvl, "nvlist/string", "test");
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-	nvlist_add_descriptor(nvl, "nvlist/descriptor", STDERR_FILENO);
-	nvlist_add_binary(nvl, "nvlist/binary", "test", 4);
-
-	CHECK(nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/null");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/bool");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/number");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/string");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/nvlist");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/descriptor");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	nvlist_free(nvl, "nvlist/binary");
-	CHECK(!nvlist_exists_null(nvl, "nvlist/null"));
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool"));
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number"));
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string"));
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor"));
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary"));
-
-	CHECK(nvlist_empty(nvl));
-
-	nvlist_destroy(nvl);
-
-	return (0);
-}
diff --git a/external/libnv/tests/nvlist_get_test.c b/external/libnv/tests/nvlist_get_test.c
deleted file mode 100644
index ebea8261..00000000
--- a/external/libnv/tests/nvlist_get_test.c
+++ /dev/null
@@ -1,182 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_get_test.c 269603 2014-08-05 18:41:27Z ngie $
- */
-
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-#define	fd_is_valid(fd)	(fcntl((fd), F_GETFL) != -1 || errno != EBADF)
-
-int
-main(void)
-{
-	const nvlist_t *cnvl;
-	nvlist_t *nvl;
-	size_t size;
-
-	printf("1..83\n");
-
-	nvl = nvlist_create(0);
-
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/true"));
-	nvlist_add_bool(nvl, "nvlist/bool/true", true);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true);
-
-	CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/false"));
-	nvlist_add_bool(nvl, "nvlist/bool/false", false);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/0"));
-	nvlist_add_number(nvl, "nvlist/number/0", 0);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/1"));
-	nvlist_add_number(nvl, "nvlist/number/1", 1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/-1"));
-	nvlist_add_number(nvl, "nvlist/number/-1", -1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -1);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX"));
-	nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/UINT64_MAX") == UINT64_MAX);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MIN"));
-	nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == INT64_MIN);
-
-	CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MAX"));
-	nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX);
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/"));
-	nvlist_add_string(nvl, "nvlist/string/", "");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0);
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/x"));
-	nvlist_add_string(nvl, "nvlist/string/x", "x");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0);
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
-
-	CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-	nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(fd_is_valid(nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO")));
-
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0);
-	CHECK(size == 1);
-
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-	CHECK(nvlist_error(nvl) == 0);
-	cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist");
-	CHECK(nvlist_get_bool(cnvl, "nvlist/bool/true") == true);
-	CHECK(nvlist_get_bool(cnvl, "nvlist/bool/false") == false);
-	CHECK(nvlist_get_number(cnvl, "nvlist/number/0") == 0);
-	CHECK(nvlist_get_number(cnvl, "nvlist/number/1") == 1);
-	CHECK((int)nvlist_get_number(cnvl, "nvlist/number/-1") == -1);
-	CHECK(nvlist_get_number(cnvl, "nvlist/number/UINT64_MAX") == UINT64_MAX);
-	CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MIN") == INT64_MIN);
-	CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MAX") == INT64_MAX);
-	CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/"), "") == 0);
-	CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/x"), "x") == 0);
-	CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
-	/* TODO */
-	CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", NULL), "x", 1) == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", &size), "x", 1) == 0);
-	CHECK(size == 1);
-	CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true);
-	CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1);
-	CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -1);
-	CHECK(nvlist_get_number(nvl, "nvlist/number/UINT64_MAX") == UINT64_MAX);
-	CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == INT64_MIN);
-	CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0);
-	CHECK(fd_is_valid(nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO")));
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0);
-	CHECK(size == 1);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	nvlist_destroy(nvl);
-
-	return (0);
-}
diff --git a/external/libnv/tests/nvlist_move_test.c b/external/libnv/tests/nvlist_move_test.c
deleted file mode 100644
index e6208585..00000000
--- a/external/libnv/tests/nvlist_move_test.c
+++ /dev/null
@@ -1,161 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_move_test.c 269603 2014-08-05 18:41:27Z ngie $
- */
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-int
-main(void)
-{
-	const nvlist_t *cnvl;
-	nvlist_t *nvl;
-	void *ptr;
-	size_t size;
-	int fd;
-
-	printf("1..52\n");
-
-	nvl = nvlist_create(0);
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/"));
-	ptr = strdup("");
-	CHECK(ptr != NULL);
-	nvlist_move_string(nvl, "nvlist/string/", ptr);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
-	CHECK(ptr == nvlist_get_string(nvl, "nvlist/string/"));
-
-	CHECK(!nvlist_exists_string(nvl, "nvlist/string/x"));
-	ptr = strdup("x");
-	CHECK(ptr != NULL);
-	nvlist_move_string(nvl, "nvlist/string/x", ptr);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
-	CHECK(ptr == nvlist_get_string(nvl, "nvlist/string/x"));
-
-	CHECK(!nvlist_exists_string(nvl,
-	    "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	ptr = strdup("abcdefghijklmnopqrstuvwxyz");
-	CHECK(ptr != NULL);
-	nvlist_move_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz",
-	    ptr);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_string(nvl,
-	    "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(ptr ==
-	    nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(!nvlist_exists_descriptor(nvl,
-	    "nvlist/descriptor/STDERR_FILENO"));
-	fd = dup(STDERR_FILENO);
-	CHECK(fd >= 0);
-	nvlist_move_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", fd);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-	CHECK(fd ==
-	    nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-
-	CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	ptr = malloc(1);
-	CHECK(ptr != NULL);
-	memcpy(ptr, "x", 1);
-	nvlist_move_binary(nvl, "nvlist/binary/x", ptr, 1);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	CHECK(ptr == nvlist_get_binary(nvl, "nvlist/binary/x", NULL));
-	CHECK(ptr == nvlist_get_binary(nvl, "nvlist/binary/x", &size));
-	CHECK(size == 1);
-
-	CHECK(!nvlist_exists_binary(nvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	ptr = malloc(sizeof("abcdefghijklmnopqrstuvwxyz"));
-	CHECK(ptr != NULL);
-	memcpy(ptr, "abcdefghijklmnopqrstuvwxyz",
-	    sizeof("abcdefghijklmnopqrstuvwxyz"));
-	nvlist_move_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz",
-	    ptr, sizeof("abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_binary(nvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(ptr == nvlist_get_binary(nvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL));
-	CHECK(ptr == nvlist_get_binary(nvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size));
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	ptr = nvlist_clone(nvl);
-	CHECK(ptr != NULL);
-	nvlist_move_nvlist(nvl, "nvlist/nvlist", ptr);
-	CHECK(nvlist_error(nvl) == 0);
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-	CHECK(ptr == nvlist_get_nvlist(nvl, "nvlist/nvlist"));
-
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/"));
-	CHECK(nvlist_exists_string(nvl, "nvlist/string/x"));
-	CHECK(nvlist_exists_string(nvl,
-	    "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"));
-	CHECK(nvlist_exists_binary(nvl, "nvlist/binary/x"));
-	CHECK(nvlist_exists_binary(nvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_nvlist(nvl, "nvlist/nvlist"));
-
-	cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist");
-	CHECK(nvlist_exists_string(cnvl, "nvlist/string/"));
-	CHECK(nvlist_exists_string(cnvl, "nvlist/string/x"));
-	CHECK(nvlist_exists_string(cnvl,
-	    "nvlist/string/abcdefghijklmnopqrstuvwxyz"));
-	CHECK(nvlist_exists_descriptor(cnvl,
-	    "nvlist/descriptor/STDERR_FILENO"));
-	CHECK(nvlist_exists_binary(cnvl, "nvlist/binary/x"));
-	CHECK(nvlist_exists_binary(cnvl,
-	    "nvlist/binary/abcdefghijklmnopqrstuvwxyz"));
-
-	nvlist_destroy(nvl);
-
-	return (0);
-}
diff --git a/external/libnv/tests/nvlist_send_recv_test.c b/external/libnv/tests/nvlist_send_recv_test.c
deleted file mode 100644
index b6a9f75c..00000000
--- a/external/libnv/tests/nvlist_send_recv_test.c
+++ /dev/null
@@ -1,342 +0,0 @@
-/*-
- * 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.
- *
- * $FreeBSD: head/lib/libnv/tests/nvlist_send_recv_test.c 279432 2015-03-01 00:22:09Z rstone $
- */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-
-#include <err.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <nv.h>
-
-static int ntest = 1;
-
-#define	CHECK(expr)	do {						\
-	if ((expr))							\
-		printf("ok # %d %s:%u\n", ntest, __FILE__, __LINE__);	\
-	else								\
-		printf("not ok # %d %s:%u\n", ntest, __FILE__, __LINE__);\
-	ntest++;							\
-} while (0)
-
-#define	fd_is_valid(fd)	(fcntl((fd), F_GETFL) != -1 || errno != EBADF)
-
-static void
-child(int sock)
-{
-	nvlist_t *nvl;
-	nvlist_t *empty;
-
-	nvl = nvlist_create(0);
-	empty = nvlist_create(0);
-
-	nvlist_add_bool(nvl, "nvlist/bool/true", true);
-	nvlist_add_bool(nvl, "nvlist/bool/false", false);
-	nvlist_add_number(nvl, "nvlist/number/0", 0);
-	nvlist_add_number(nvl, "nvlist/number/1", 1);
-	nvlist_add_number(nvl, "nvlist/number/-1", -1);
-	nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX);
-	nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN);
-	nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX);
-	nvlist_add_string(nvl, "nvlist/string/", "");
-	nvlist_add_string(nvl, "nvlist/string/x", "x");
-	nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz");
-	nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO);
-	nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1);
-	nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz"));
-	nvlist_move_nvlist(nvl, "nvlist/nvlist/empty", empty);
-	nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl);
-
-	nvlist_send(sock, nvl);
-
-	nvlist_destroy(nvl);
-}
-
-static void
-parent(int sock)
-{
-	nvlist_t *nvl;
-	const nvlist_t *cnvl, *empty;
-	const char *name, *cname;
-	void *cookie, *ccookie;
-	int type, ctype;
-	size_t size;
-
-	nvl = nvlist_recv(sock);
-	CHECK(nvlist_error(nvl) == 0);
-	if (nvlist_error(nvl) != 0)
-		err(1, "nvlist_recv() failed");
-
-	cookie = NULL;
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_BOOL);
-	CHECK(strcmp(name, "nvlist/bool/true") == 0);
-	CHECK(nvlist_get_bool(nvl, name) == true);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_BOOL);
-	CHECK(strcmp(name, "nvlist/bool/false") == 0);
-	CHECK(nvlist_get_bool(nvl, name) == false);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/0") == 0);
-	CHECK(nvlist_get_number(nvl, name) == 0);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/1") == 0);
-	CHECK(nvlist_get_number(nvl, name) == 1);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/-1") == 0);
-	CHECK((int)nvlist_get_number(nvl, name) == -1);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/UINT64_MAX") == 0);
-	CHECK(nvlist_get_number(nvl, name) == UINT64_MAX);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/INT64_MIN") == 0);
-	CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MIN);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NUMBER);
-	CHECK(strcmp(name, "nvlist/number/INT64_MAX") == 0);
-	CHECK((int64_t)nvlist_get_number(nvl, name) == INT64_MAX);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_STRING);
-	CHECK(strcmp(name, "nvlist/string/") == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, name), "") == 0);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_STRING);
-	CHECK(strcmp(name, "nvlist/string/x") == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, name), "x") == 0);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_STRING);
-	CHECK(strcmp(name, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
-	CHECK(strcmp(nvlist_get_string(nvl, name), "abcdefghijklmnopqrstuvwxyz") == 0);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_DESCRIPTOR);
-	CHECK(strcmp(name, "nvlist/descriptor/STDERR_FILENO") == 0);
-	CHECK(fd_is_valid(nvlist_get_descriptor(nvl, name)));
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_BINARY);
-	CHECK(strcmp(name, "nvlist/binary/x") == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "x", 1) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "x", 1) == 0);
-	CHECK(size == 1);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_BINARY);
-	CHECK(strcmp(name, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, name, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(memcmp(nvlist_get_binary(nvl, name, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NVLIST);
-	CHECK(strcmp(name, "nvlist/nvlist/empty") == 0);
-	cnvl = nvlist_get_nvlist(nvl, name);
-	CHECK(nvlist_empty(cnvl));
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name != NULL);
-	CHECK(type == NV_TYPE_NVLIST);
-	CHECK(strcmp(name, "nvlist/nvlist") == 0);
-	cnvl = nvlist_get_nvlist(nvl, name);
-
-	ccookie = NULL;
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_BOOL);
-	CHECK(strcmp(cname, "nvlist/bool/true") == 0);
-	CHECK(nvlist_get_bool(cnvl, cname) == true);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_BOOL);
-	CHECK(strcmp(cname, "nvlist/bool/false") == 0);
-	CHECK(nvlist_get_bool(cnvl, cname) == false);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/0") == 0);
-	CHECK(nvlist_get_number(cnvl, cname) == 0);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/1") == 0);
-	CHECK(nvlist_get_number(cnvl, cname) == 1);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/-1") == 0);
-	CHECK((int)nvlist_get_number(cnvl, cname) == -1);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/UINT64_MAX") == 0);
-	CHECK(nvlist_get_number(cnvl, cname) == UINT64_MAX);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/INT64_MIN") == 0);
-	CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MIN);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NUMBER);
-	CHECK(strcmp(cname, "nvlist/number/INT64_MAX") == 0);
-	CHECK((int64_t)nvlist_get_number(cnvl, cname) == INT64_MAX);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_STRING);
-	CHECK(strcmp(cname, "nvlist/string/") == 0);
-	CHECK(strcmp(nvlist_get_string(cnvl, cname), "") == 0);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_STRING);
-	CHECK(strcmp(cname, "nvlist/string/x") == 0);
-	CHECK(strcmp(nvlist_get_string(cnvl, cname), "x") == 0);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_STRING);
-	CHECK(strcmp(cname, "nvlist/string/abcdefghijklmnopqrstuvwxyz") == 0);
-	CHECK(strcmp(nvlist_get_string(cnvl, cname), "abcdefghijklmnopqrstuvwxyz") == 0);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_DESCRIPTOR);
-	CHECK(strcmp(cname, "nvlist/descriptor/STDERR_FILENO") == 0);
-	CHECK(fd_is_valid(nvlist_get_descriptor(cnvl, cname)));
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_BINARY);
-	CHECK(strcmp(cname, "nvlist/binary/x") == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "x", 1) == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "x", 1) == 0);
-	CHECK(size == 1);
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_BINARY);
-	CHECK(strcmp(cname, "nvlist/binary/abcdefghijklmnopqrstuvwxyz") == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, cname, NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(memcmp(nvlist_get_binary(cnvl, cname, &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0);
-	CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz"));
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname != NULL);
-	CHECK(ctype == NV_TYPE_NVLIST);
-	CHECK(strcmp(cname, "nvlist/nvlist/empty") == 0);
-	empty = nvlist_get_nvlist(cnvl, cname);
-	CHECK(nvlist_empty(empty));
-
-	cname = nvlist_next(cnvl, &ctype, &ccookie);
-	CHECK(cname == NULL);
-
-	name = nvlist_next(nvl, &type, &cookie);
-	CHECK(name == NULL);
-}
-
-int
-main(void)
-{
-	int status, socks[2];
-	pid_t pid;
-
-	printf("1..134\n");
-	fflush(stdout);
-
-	if (socketpair(PF_UNIX, SOCK_STREAM, 0, socks) < 0)
-		err(1, "socketpair() failed");
-	pid = fork();
-	switch (pid) {
-	case -1:
-		/* Failure. */
-		err(1, "unable to fork");
-	case 0:
-		/* Child. */
-		close(socks[0]);
-		child(socks[1]);
-		return (0);
-	default:
-		/* Parent. */
-		close(socks[1]);
-		parent(socks[0]);
-		break;
-	}
-
-	if (waitpid(pid, &status, 0) < 0)
-		err(1, "waitpid() failed");
-
-	return (0);
-}