50 files changed, 1820 insertions, 1024 deletions

diff --git a/lib/atf/libatf-c/tests/Makefile b/lib/atf/libatf-c/tests/Makefile
index e811e90b7e7f1..c99b2d1159676 100644
--- a/lib/atf/libatf-c/tests/Makefile
+++ b/lib/atf/libatf-c/tests/Makefile
@@ -13,11 +13,6 @@ ATF=		${SRCTOP}/contrib/atf
 CFLAGS+=	-DATF_INCLUDEDIR='"${INCLUDEDIR}"'
 CFLAGS+=	-I${ATF}
 
-# macros_test.c contains a double 'const const' which will be gone with
-# the import of atf-0.18.
-# TODO(jmmv): Remove this workaround once we do that update.
-CFLAGS.clang+=	-Wno-duplicate-decl-specifier
-
 ${PACKAGE}FILES+=	macros_h_test.c
 ${PACKAGE}FILES+=	unused_test.c
 
diff --git a/lib/clang/libllvm/Makefile b/lib/clang/libllvm/Makefile
index 23d13ef688b97..e4804230c113e 100644
--- a/lib/clang/libllvm/Makefile
+++ b/lib/clang/libllvm/Makefile
@@ -523,7 +523,7 @@ SRCS_EXT+=	DebugInfo/PDB/PDBSymbolTypeVTableShape.cpp
 SRCS_EXT+=	DebugInfo/PDB/PDBSymbolUnknown.cpp
 SRCS_EXT+=	DebugInfo/PDB/PDBSymbolUsingNamespace.cpp
 SRCS_EXT+=	DebugInfo/PDB/UDTLayout.cpp
-SRCS_EXT+=	DebugInfo/Symbolize/DIPrinter.cpp
+SRCS_MIW+=	DebugInfo/Symbolize/DIPrinter.cpp
 SRCS_MIW+=	DebugInfo/Symbolize/SymbolizableObjectFile.cpp
 SRCS_MIW+=	DebugInfo/Symbolize/Symbolize.cpp
 SRCS_MIN+=	Demangle/ItaniumDemangle.cpp
@@ -718,8 +718,8 @@ SRCS_EXT+=	MCA/Support.cpp
 SRCS_MIN+=	Object/Archive.cpp
 SRCS_MIN+=	Object/ArchiveWriter.cpp
 SRCS_MIN+=	Object/Binary.cpp
-SRCS_EXT+=	Object/COFFImportFile.cpp
-SRCS_EXT+=	Object/COFFModuleDefinition.cpp
+SRCS_MIN+=	Object/COFFImportFile.cpp
+SRCS_MIN+=	Object/COFFModuleDefinition.cpp
 SRCS_MIN+=	Object/COFFObjectFile.cpp
 SRCS_MIN+=	Object/Decompressor.cpp
 SRCS_MIN+=	Object/ELF.cpp
@@ -779,7 +779,7 @@ SRCS_MIN+=	Support/BinaryStreamWriter.cpp
 SRCS_MIN+=	Support/BlockFrequency.cpp
 SRCS_MIN+=	Support/BranchProbability.cpp
 SRCS_MIN+=	Support/BuryPointer.cpp
-SRCS_EXT+=	Support/COM.cpp
+SRCS_MIW+=	Support/COM.cpp
 SRCS_MIN+=	Support/CachePruning.cpp
 SRCS_MIN+=	Support/Chrono.cpp
 SRCS_MIN+=	Support/CodeGenCoverage.cpp
@@ -1256,7 +1256,7 @@ SRCS_MIN+=	Target/X86/X86VZeroUpper.cpp
 SRCS_MIN+=	Target/X86/X86WinAllocaExpander.cpp
 SRCS_MIN+=	Target/X86/X86WinEHState.cpp
 .endif # MK_LLVM_TARGET_X86
-SRCS_EXT+=	ToolDrivers/llvm-dlltool/DlltoolDriver.cpp
+SRCS_MIN+=	ToolDrivers/llvm-dlltool/DlltoolDriver.cpp
 SRCS_EXL+=	ToolDrivers/llvm-lib/LibDriver.cpp
 SRCS_MIN+=	Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
 SRCS_MIN+=	Transforms/AggressiveInstCombine/TruncInstCombine.cpp
diff --git a/lib/csu/mips/crtn.S b/lib/csu/mips/crtn.S
index ad81a7b5f3c69..db03f6c65d20d 100644
--- a/lib/csu/mips/crtn.S
+++ b/lib/csu/mips/crtn.S
@@ -5,7 +5,6 @@ __FBSDID("$FreeBSD$");
 	.gnu_attribute 4, 0
 #endif
 	.section .init,"ax",%progbits
-	.align 4
 	.set noreorder
 #if defined(__ABICALLS__) && (defined(__mips_n32) || defined(__mips_n64))
 	REG_L	gp, CALLFRAME_GP(sp)
@@ -16,7 +15,6 @@ __FBSDID("$FreeBSD$");
 	.set reorder
 
 	.section .fini,"ax",%progbits
-	.align 4
 	.set noreorder
 #if defined(__ABICALLS__) && (defined(__mips_n32) || defined(__mips_n64))
 	REG_L	gp, CALLFRAME_GP(sp)
diff --git a/lib/geom/eli/geli.8 b/lib/geom/eli/geli.8
index 876f466878685..43ca9a2928c71 100644
--- a/lib/geom/eli/geli.8
+++ b/lib/geom/eli/geli.8
@@ -24,7 +24,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd April 3, 2019
+.Dd May 23, 2019
 .Dt GELI 8
 .Os
 .Sh NAME
@@ -901,6 +901,18 @@ specified in
 .El
 .Sh EXIT STATUS
 Exit status is 0 on success, and 1 if the command fails.
+.Sh DEPRECATION NOTICE
+Support for the
+.Nm Blowfish-CBC
+and
+.Nm 3DES-CBC
+cryptographic algorithms and
+.Nm HMAC/MD5
+authentication algorithm will be removed in
+.Fx 13.0 .
+New volumes cannot be created using these algorithms.
+Existing volumes should be migrated to a new volume that uses
+non-deprecated algorithms.
 .Sh EXAMPLES
 Initialize a provider which is going to be encrypted with a
 passphrase and random data from a file on the user's pen drive.
@@ -1134,7 +1146,7 @@ utility appeared in
 .Fx 6.0 .
 Support for the
 .Nm Camellia
-block cipher is implemented by Yoshisato Yanagisawa in
+block cipher was implemented by Yoshisato Yanagisawa in
 .Fx 7.0 .
 .Pp
 Highest
diff --git a/lib/geom/eli/geom_eli.c b/lib/geom/eli/geom_eli.c
index 2b08bf14a1853..33a4ddf297b46 100644
--- a/lib/geom/eli/geom_eli.c
+++ b/lib/geom/eli/geom_eli.c
@@ -805,6 +805,22 @@ eli_init(struct gctl_req *req)
 			return;
 		}
 	}
+	if (md.md_flags & G_ELI_FLAG_AUTH) {
+		switch (md.md_aalgo) {
+		case CRYPTO_MD5_HMAC:
+			gctl_error(req,
+			    "The %s authentication algorithm is deprecated.",
+			    g_eli_algo2str(md.md_aalgo));
+			return;
+		}
+	}
+	switch (md.md_ealgo) {
+	case CRYPTO_3DES_CBC:
+	case CRYPTO_BLF_CBC:
+		gctl_error(req, "The %s encryption algorithm is deprecated.",
+		    g_eli_algo2str(md.md_ealgo));
+		return;
+	}
 	val = gctl_get_intmax(req, "keylen");
 	md.md_keylen = val;
 	md.md_keylen = g_eli_keylen(md.md_ealgo, md.md_keylen);
diff --git a/lib/libarchive/Makefile b/lib/libarchive/Makefile
index 0d933c5a432ef..5c44669f6f85c 100644
--- a/lib/libarchive/Makefile
+++ b/lib/libarchive/Makefile
@@ -168,6 +168,7 @@ SRCS=	archive_acl.c					\
 MAN=	archive_entry.3					\
 	archive_entry_acl.3				\
 	archive_entry_linkify.3				\
+	archive_entry_misc.3				\
 	archive_entry_paths.3				\
 	archive_entry_perms.3				\
 	archive_entry_stat.3				\
diff --git a/lib/libarchive/tests/Makefile b/lib/libarchive/tests/Makefile
index 03c97ed077871..e9c51c97aa53c 100644
--- a/lib/libarchive/tests/Makefile
+++ b/lib/libarchive/tests/Makefile
@@ -169,6 +169,7 @@ TESTS_SRCS= \
 	test_read_format_tar_concatenated.c	\
 	test_read_format_tar_empty_filename.c	\
 	test_read_format_tar_empty_pax.c	\
+	test_read_format_tar_empty_with_gnulabel.c	\
 	test_read_format_tar_filename.c		\
 	test_read_format_tbz.c			\
 	test_read_format_tgz.c			\
@@ -179,10 +180,12 @@ TESTS_SRCS= \
 	test_read_format_warc.c			\
 	test_read_format_xar.c			\
 	test_read_format_zip.c			\
+	test_read_format_zip_7075_utf8_paths.c	\
 	test_read_format_zip_comment_stored.c	\
 	test_read_format_zip_encryption_data.c	\
 	test_read_format_zip_encryption_header.c	\
 	test_read_format_zip_encryption_partially.c	\
+	test_read_format_zip_extra_padding.c	\
 	test_read_format_zip_filename.c		\
 	test_read_format_zip_high_compression.c	\
 	test_read_format_zip_jar.c		\
@@ -486,6 +489,7 @@ ${PACKAGE}FILES+=	test_read_format_mtree_crash747.mtree.bz2.uu
 ${PACKAGE}FILES+=	test_read_format_mtree_nomagic.mtree.uu
 ${PACKAGE}FILES+=	test_read_format_mtree_nomagic2.mtree.uu
 ${PACKAGE}FILES+=	test_read_format_mtree_nomagic3.mtree.uu
+${PACKAGE}FILES+=	test_read_format_mtree_noprint.mtree.uu
 ${PACKAGE}FILES+=	test_read_format_rar.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_binary_data.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_compress_best.rar.uu
@@ -501,6 +505,7 @@ ${PACKAGE}FILES+=	test_read_format_rar_multivolume.part0003.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_multivolume.part0004.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_noeof.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_ppmd_lzss_conversion.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar_ppmd_use_after_free.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_sfx.exe.uu
 ${PACKAGE}FILES+=	test_read_format_rar_subblock.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar_unicode.rar.uu
@@ -508,6 +513,13 @@ ${PACKAGE}FILES+=	test_read_format_rar_windows.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_arm.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_blake2.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_compressed.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_distance_overflow.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_extra_field_version.rar.uu	
+${PACKAGE}FILES+=	test_read_format_rar5_fileattr.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_hardlink.rar.uu	
+${PACKAGE}FILES+=	test_read_format_rar5_invalid_dict_reference.rar.uu	
+${PACKAGE}FILES+=	test_read_format_rar5_leftshift1.rar.uu	
+${PACKAGE}FILES+=	test_read_format_rar5_leftshift2.rar.uu	
 ${PACKAGE}FILES+=	test_read_format_rar5_multiarchive.part01.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_multiarchive.part02.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_multiarchive.part03.rar.uu
@@ -522,15 +534,22 @@ ${PACKAGE}FILES+=	test_read_format_rar5_multiarchive_solid.part03.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_multiarchive_solid.part04.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_multiple_files.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_multiple_files_solid.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_nonempty_dir_stream.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_owner.rar.uu	
+${PACKAGE}FILES+=	test_read_format_rar5_readtables_overflow.rar.uu	
 ${PACKAGE}FILES+=	test_read_format_rar5_solid.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_stored.rar.uu
 ${PACKAGE}FILES+=	test_read_format_rar5_stored_manyfiles.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_symlink.rar.uu
+${PACKAGE}FILES+=	test_read_format_rar5_truncated_huff.rar.uu	
 ${PACKAGE}FILES+=	test_read_format_rar5_win32.rar.uu
 ${PACKAGE}FILES+=	test_read_format_raw.bufr.uu
 ${PACKAGE}FILES+=	test_read_format_raw.data.Z.uu
+${PACKAGE}FILES+=	test_read_format_raw.data.gz.uu
 ${PACKAGE}FILES+=	test_read_format_raw.data.uu
 ${PACKAGE}FILES+=	test_read_format_tar_concatenated.tar.uu
 ${PACKAGE}FILES+=	test_read_format_tar_empty_filename.tar.uu
+${PACKAGE}FILES+=	test_read_format_tar_empty_with_gnulabel.tar.uu
 ${PACKAGE}FILES+=	test_read_format_tar_empty_pax.tar.Z.uu
 ${PACKAGE}FILES+=	test_read_format_tar_filename_koi8r.tar.Z.uu
 ${PACKAGE}FILES+=	test_read_format_ustar_filename_cp866.tar.Z.uu
@@ -538,6 +557,7 @@ ${PACKAGE}FILES+=	test_read_format_ustar_filename_eucjp.tar.Z.uu
 ${PACKAGE}FILES+=	test_read_format_ustar_filename_koi8r.tar.Z.uu
 ${PACKAGE}FILES+=	test_read_format_warc.warc.uu
 ${PACKAGE}FILES+=	test_read_format_zip.zip.uu
+${PACKAGE}FILES+=	test_read_format_zip_7075_utf8_paths.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_bz2_hang.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_bzip2.zipx.uu
 ${PACKAGE}FILES+=	test_read_format_zip_bzip2_multi.zipx.uu
@@ -546,6 +566,7 @@ ${PACKAGE}FILES+=	test_read_format_zip_comment_stored_2.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_encryption_data.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_encryption_header.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_encryption_partially.zip.uu
+${PACKAGE}FILES+=	test_read_format_zip_extra_padding.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_filename_cp866.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_filename_cp932.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_filename_koi8r.zip.uu
@@ -555,6 +576,8 @@ ${PACKAGE}FILES+=	test_read_format_zip_filename_utf8_ru2.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_high_compression.zip.uu
 ${PACKAGE}FILES+=	test_read_format_zip_jar.jar.uu
 ${PACKAGE}FILES+=	test_read_format_zip_length_at_end.zip.uu
+${PACKAGE}FILES+=	test_read_format_zip_lzma_alone_leak.zipx.uu
+${PACKAGE}FILES+=	test_read_format_zip_lzma.zipx.uu
 ${PACKAGE}FILES+=	test_read_format_zip_lzma.zipx.uu
 ${PACKAGE}FILES+=	test_read_format_zip_lzma_multi.zipx.uu
 ${PACKAGE}FILES+=	test_read_format_zip_mac_metadata.zip.uu
diff --git a/lib/libbe/be_access.c b/lib/libbe/be_access.c
index 741fa925e9dd0..d3e415bdbd426 100644
--- a/lib/libbe/be_access.c
+++ b/lib/libbe/be_access.c
@@ -99,13 +99,12 @@ be_mount_iter(zfs_handle_t *zfs_hdl, void *data)
 	if (strcmp("none", zfs_mnt) == 0) {
 		/*
 		 * mountpoint=none; we'll mount it at info->mountpoint assuming
-		 * we're at the root.  If we're not at the root... that's less
-		 * than stellar and not entirely sure what to do with that.
-		 * For now, we won't treat it as an error condition -- we just
-		 * won't mount it, and we'll continue on.
+		 * we're at the root.  If we're not at the root, we're likely
+		 * at some intermediate dataset (e.g. zroot/var) that will have
+		 * children that may need to be mounted.
 		 */
 		if (info->depth > 0)
-			return (0);
+			goto skipmount;
 
 		snprintf(tmp, BE_MAXPATHLEN, "%s", info->mountpoint);
 	} else {
@@ -136,6 +135,7 @@ be_mount_iter(zfs_handle_t *zfs_hdl, void *data)
 	if (!info->deepmount)
 		return (0);
 
+skipmount:
 	++info->depth;
 	err = zfs_iter_filesystems(zfs_hdl, be_mount_iter, info);
 	--info->depth;
diff --git a/lib/libc/amd64/sys/amd64_get_fsbase.c b/lib/libc/amd64/sys/amd64_get_fsbase.c
index 65c8859681321..2de99912daf25 100644
--- a/lib/libc/amd64/sys/amd64_get_fsbase.c
+++ b/lib/libc/amd64/sys/amd64_get_fsbase.c
@@ -57,7 +57,7 @@ amd64_get_fsbase_syscall(void **addr)
 	return (sysarch(AMD64_GET_FSBASE, addr));
 }
 
-DEFINE_UIFUNC(, int, amd64_get_fsbase, (void **), static)
+DEFINE_UIFUNC(, int, amd64_get_fsbase, (void **))
 {
 
 	if (__getosreldate() >= P_OSREL_WRFSBASE &&
diff --git a/lib/libc/amd64/sys/amd64_get_gsbase.c b/lib/libc/amd64/sys/amd64_get_gsbase.c
index 93a5b15d7448e..0deac34c90d18 100644
--- a/lib/libc/amd64/sys/amd64_get_gsbase.c
+++ b/lib/libc/amd64/sys/amd64_get_gsbase.c
@@ -57,7 +57,7 @@ amd64_get_gsbase_syscall(void **addr)
 	return (sysarch(AMD64_GET_GSBASE, addr));
 }
 
-DEFINE_UIFUNC(, int, amd64_get_gsbase, (void **), static)
+DEFINE_UIFUNC(, int, amd64_get_gsbase, (void **))
 {
 
 	if (__getosreldate() >= P_OSREL_WRFSBASE &&
diff --git a/lib/libc/amd64/sys/amd64_set_fsbase.c b/lib/libc/amd64/sys/amd64_set_fsbase.c
index 5361d81db9455..02ca9233d8555 100644
--- a/lib/libc/amd64/sys/amd64_set_fsbase.c
+++ b/lib/libc/amd64/sys/amd64_set_fsbase.c
@@ -57,7 +57,7 @@ amd64_set_fsbase_syscall(void *addr)
 	return (sysarch(AMD64_SET_FSBASE, &addr));
 }
 
-DEFINE_UIFUNC(, int, amd64_set_fsbase, (void *), static)
+DEFINE_UIFUNC(, int, amd64_set_fsbase, (void *))
 {
 
 	if (__getosreldate() >= P_OSREL_WRFSBASE &&
diff --git a/lib/libc/amd64/sys/amd64_set_gsbase.c b/lib/libc/amd64/sys/amd64_set_gsbase.c
index 039c021aae7ee..c4880c126ae9c 100644
--- a/lib/libc/amd64/sys/amd64_set_gsbase.c
+++ b/lib/libc/amd64/sys/amd64_set_gsbase.c
@@ -57,7 +57,7 @@ amd64_set_gsbase_syscall(void *addr)
 	return (sysarch(AMD64_SET_GSBASE, &addr));
 }
 
-DEFINE_UIFUNC(, int, amd64_set_gsbase, (void *), static)
+DEFINE_UIFUNC(, int, amd64_set_gsbase, (void *))
 {
 
 	if (__getosreldate() >= P_OSREL_WRFSBASE &&
diff --git a/lib/libc/gen/Makefile.inc b/lib/libc/gen/Makefile.inc
index fa292fc4984df..23dc83e969e09 100644
--- a/lib/libc/gen/Makefile.inc
+++ b/lib/libc/gen/Makefile.inc
@@ -2,9 +2,10 @@
 # $FreeBSD$
 
 # machine-independent gen sources
-.PATH: ${LIBC_SRCTOP}/${LIBC_ARCH}/gen ${LIBC_SRCTOP}/gen
+.PATH: ${LIBC_SRCTOP}/${LIBC_ARCH}/gen ${LIBC_SRCTOP}/gen ${SRCTOP}/etc
 
-CONFS=	shells
+CONFS+=	group master.passwd shells
+CONFSMODE_master.passwd=	600
 
 SRCS+=	__getosreldate.c \
 	__pthread_mutex_init_calloc_cb_stub.c \
@@ -543,3 +544,16 @@ MLINKS+=vis.3 nvis.3 \
 	vis.3 svis.3
 
 MLINKS+=wordexp.3 wordfree.3
+
+afterinstallconfig:
+.if ${MK_TCSH} == "no"
+	sed -i "" -e 's;/bin/csh;/bin/sh;' ${DESTDIR}/etc/master.passwd
+.endif
+	pwd_mkdb -i -p -d ${DESTDIR}/etc ${DESTDIR}/etc/master.passwd
+.if defined(NO_ROOT) && defined(METALOG)
+	( \
+		echo "./etc/pwd.db type=file mode=0644 uname=root gname=wheel"; \
+		echo "./etc/spwd.db type=file mode=0600 uname=root gname=wheel"; \
+		echo "./etc/passwd type=file mode=0644 uname=root gname=wheel"; \
+	) | cat -l >> ${METALOG}
+.endif
diff --git a/lib/libc/gen/shells b/lib/libc/gen/shells
deleted file mode 100644
index fe1e0294a0103..0000000000000
--- a/lib/libc/gen/shells
+++ /dev/null
@@ -1,9 +0,0 @@
-# $FreeBSD$
-#
-# List of acceptable shells for chpass(1).
-# Ftpd will not allow users to connect who are not using
-# one of these shells.
-
-/bin/sh
-/bin/csh
-/bin/tcsh
diff --git a/lib/libc/net/rthdr.c b/lib/libc/net/rthdr.c
index 5a035e9d32d0c..81f07c0e77ddd 100644
--- a/lib/libc/net/rthdr.c
+++ b/lib/libc/net/rthdr.c
@@ -282,7 +282,7 @@ inet6_rth_space(int type, int segments)
 			return (((segments * 2) + 1) << 3);
 		/* FALLTHROUGH */
 	default:
-		return (0);	/* type not suppported */
+		return (0);	/* type not supported */
 	}
 }
 
diff --git a/lib/libc/resolv/res_findzonecut.c b/lib/libc/resolv/res_findzonecut.c
index 7e326f1a135cf..d08f6dbe7dbda 100644
--- a/lib/libc/resolv/res_findzonecut.c
+++ b/lib/libc/resolv/res_findzonecut.c
@@ -629,7 +629,7 @@ save_a(res_state statp, ns_msg *msg, ns_sect sect,
 			arr->addr.sin6.sin6_len = sizeof(arr->addr.sin6);
 #endif
 			memcpy(&arr->addr.sin6.sin6_addr, ns_rr_rdata(rr), 16);
-			arr->addr.sin.sin_port = htons(NAMESERVER_PORT);
+			arr->addr.sin6.sin6_port = htons(NAMESERVER_PORT);
 			nsrr->flags |= RR_NS_HAVE_V6;
 			break;
 		default:
diff --git a/lib/libc/stdlib/bsearch.3 b/lib/libc/stdlib/bsearch.3
index 2fdf2c4842c07..87f4cc8622047 100644
--- a/lib/libc/stdlib/bsearch.3
+++ b/lib/libc/stdlib/bsearch.3
@@ -32,7 +32,7 @@
 .\"     @(#)bsearch.3	8.3 (Berkeley) 4/19/94
 .\" $FreeBSD$
 .\"
-.Dd February 22, 2013
+.Dd May 15, 2019
 .Dt BSEARCH 3
 .Os
 .Sh NAME
@@ -83,6 +83,61 @@ The
 function returns a pointer to a matching member of the array, or a null
 pointer if no match is found.
 If two members compare as equal, which member is matched is unspecified.
+.Sh EXAMPLES
+A sample program that searches people by age in a sorted array:
+.Bd -literal
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct person {
+	char name[5];
+	int age;
+};
+
+int
+compare(const void *key, const void *array_member)
+{
+	int age = (intptr_t) key;
+	struct person person = *(struct person *) array_member;
+
+	return (age - person.age);
+}
+
+int
+main()
+{
+	struct person *friend;
+
+	/* Sorted array */
+	struct person friends[6] = {
+		{ "paul", 22 },
+		{ "anne", 25 },
+		{ "fred", 25 },
+		{ "mary", 27 },
+		{ "mark", 35 },
+		{ "bill", 50 }
+	};
+
+	size_t array_size = sizeof(friends) / sizeof(struct person);
+
+	friend = bsearch((void *)22, &friends, array_size, sizeof(struct person), compare);
+	assert(strcmp(friend->name, "paul") == 0);
+	printf("name: %s\enage: %d\en", friend->name, friend->age);
+
+	friend = bsearch((void *)25, &friends, array_size, sizeof(struct person), compare);
+	assert(strcmp(friend->name, "fred") == 0 || strcmp(friend->name, "anne") == 0);
+	printf("name: %s\enage: %d\en", friend->name, friend->age);
+
+	friend = bsearch((void *)30, &friends, array_size, sizeof(struct person), compare);
+	assert(friend == NULL);
+	printf("friend aged 30 not found\en");
+
+	return (EXIT_SUCCESS);
+}
+.Ed
 .Sh SEE ALSO
 .Xr db 3 ,
 .Xr lsearch 3 ,
diff --git a/lib/libc/sys/Makefile.inc b/lib/libc/sys/Makefile.inc
index 22737fcb8949e..f8107b3bdc465 100644
--- a/lib/libc/sys/Makefile.inc
+++ b/lib/libc/sys/Makefile.inc
@@ -394,6 +394,7 @@ MLINKS+=extattr_get_file.2 extattr.2 \
 MLINKS+=ffclock.2 ffclock_getcounter.2 \
 	ffclock.2 ffclock_getestimate.2 \
 	ffclock.2 ffclock_setestimate.2
+MLINKS+=fhlink.2 fhlinkat.2
 MLINKS+=fhopen.2 fhstat.2 fhopen.2 fhstatfs.2
 MLINKS+=fsync.2 fdatasync.2
 MLINKS+=getdirentries.2 getdents.2
diff --git a/lib/libc/sys/mlock.2 b/lib/libc/sys/mlock.2
index 4a48166154206..040a8f8eaf9eb 100644
--- a/lib/libc/sys/mlock.2
+++ b/lib/libc/sys/mlock.2
@@ -28,7 +28,7 @@
 .\"	@(#)mlock.2	8.2 (Berkeley) 12/11/93
 .\" $FreeBSD$
 .\"
-.Dd March 20, 2018
+.Dd May 13, 2019
 .Dt MLOCK 2
 .Os
 .Sh NAME
@@ -97,13 +97,13 @@ resource limit and the
 system-wide
 .Dq wired pages
 limit
-.Va vm.max_wired .
-.Va vm.max_wired
+.Va vm.max_user_wired .
+.Va vm.max_user_wired
 applies to the system as a whole, so the amount available to a single
 process at any given time is the difference between
-.Va vm.max_wired
+.Va vm.max_user_wired
 and
-.Va vm.stats.vm.v_wire_count .
+.Va vm.stats.vm.v_user_wire_count .
 .Pp
 If
 .Va security.bsd.unprivileged_mlock
@@ -124,13 +124,11 @@ will fail if:
 is set to 0 and the caller is not the super-user.
 .It Bq Er EINVAL
 The address range given wraps around zero.
-.It Bq Er EAGAIN
-Locking the indicated range would exceed the system limit for locked memory.
 .It Bq Er ENOMEM
 Some portion of the indicated address range is not allocated.
 There was an error faulting/mapping a page.
-Locking the indicated range would exceed the per-process limit for locked
-memory.
+Locking the indicated range would exceed the per-process or system-wide limits
+for locked memory.
 .El
 The
 .Fn munlock
@@ -171,11 +169,11 @@ system calls first appeared in
 Allocating too much wired memory can lead to a memory-allocation deadlock
 which requires a reboot to recover from.
 .Pp
-The per-process resource limit is a limit on the amount of virtual
-memory locked, while the system-wide limit is for the number of locked
-physical pages.
-Hence a process with two distinct locked mappings of the same physical page
-counts as 2 pages against the per-process limit and as only a single page
-in the system limit.
+The per-process and system-wide resource limits of locked memory apply
+to the amount of virtual memory locked, not the amount of locked physical
+pages.
+Hence two distinct locked mappings of the same physical page counts as
+2 pages aginst the system limit, and also against the per-process limit
+if both mappings belong to the same physical map.
 .Pp
 The per-process resource limit is not currently supported.
diff --git a/lib/libc/sys/mlockall.2 b/lib/libc/sys/mlockall.2
index 23c644a8493f0..341099ee758f6 100644
--- a/lib/libc/sys/mlockall.2
+++ b/lib/libc/sys/mlockall.2
@@ -30,7 +30,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd December 25, 2012
+.Dd May 13, 2019
 .Dt MLOCKALL 2
 .Os
 .Sh NAME
@@ -69,7 +69,7 @@ limited in how much they can lock down.
 A single process can lock the minimum of a system-wide
 .Dq wired pages
 limit
-.Va vm.max_wired
+.Va vm.max_user_wired
 and the per-process
 .Dv RLIMIT_MEMLOCK
 resource limit.
@@ -138,9 +138,9 @@ and
 functions first appeared in
 .Fx 5.1 .
 .Sh BUGS
-The per-process resource limit is a limit on the amount of virtual
-memory locked, while the system-wide limit is for the number of locked
-physical pages.
-Hence a process with two distinct locked mappings of the same physical page
-counts as 2 pages against the per-process limit and as only a single page
-in the system limit.
+The per-process and system-wide resource limits of locked memory apply
+to the amount of virtual memory locked, not the amount of locked physical
+pages.
+Hence two distinct locked mappings of the same physical page counts as
+2 pages aginst the system limit, and also against the per-process limit
+if both mappings belong to the same physical map.
diff --git a/lib/libc/sys/unlink.2 b/lib/libc/sys/unlink.2
index 83823f1d78ae4..6682756b4a57e 100644
--- a/lib/libc/sys/unlink.2
+++ b/lib/libc/sys/unlink.2
@@ -28,12 +28,13 @@
 .\"     @(#)unlink.2	8.1 (Berkeley) 6/4/93
 .\" $FreeBSD$
 .\"
-.Dd April 6, 2019
+.Dd June 6, 2019
 .Dt UNLINK 2
 .Os
 .Sh NAME
 .Nm unlink ,
-.Nm unlinkat
+.Nm unlinkat ,
+.Nm funlinkat
 .Nd remove directory entry
 .Sh LIBRARY
 .Lb libc
diff --git a/lib/libc/tests/sys/mlock_helper.c b/lib/libc/tests/sys/mlock_helper.c
index 86bbf9ad4d5a5..a483207aa5d6b 100644
--- a/lib/libc/tests/sys/mlock_helper.c
+++ b/lib/libc/tests/sys/mlock_helper.c
@@ -39,16 +39,16 @@ __FBSDID("$FreeBSD$");
 #include <limits.h>
 #include <stdio.h>
 
-#define	VM_MAX_WIRED "vm.max_wired"
+#define	VM_MAX_WIRED "vm.max_user_wired"
 
 static void
-vm_max_wired_sysctl(int *old_value, int *new_value)
+vm_max_wired_sysctl(u_long *old_value, u_long *new_value)
 {
 	size_t old_len;
-	size_t new_len = (new_value == NULL ? 0 : sizeof(int));
+	size_t new_len = (new_value == NULL ? 0 : sizeof(*new_value));
 
 	if (old_value == NULL)
-		printf("Setting the new value to %d\n", *new_value);
+		printf("Setting the new value to %lu\n", *new_value);
 	else {
 		ATF_REQUIRE_MSG(sysctlbyname(VM_MAX_WIRED, NULL, &old_len,
 		    new_value, new_len) == 0,
@@ -60,14 +60,14 @@ vm_max_wired_sysctl(int *old_value, int *new_value)
 	    "sysctlbyname(%s) failed: %s", VM_MAX_WIRED, strerror(errno));
 
 	if (old_value != NULL)
-		printf("Saved the old value (%d)\n", *old_value);
+		printf("Saved the old value (%lu)\n", *old_value);
 }
 
 void
-set_vm_max_wired(int new_value)
+set_vm_max_wired(u_long new_value)
 {
 	FILE *fp;
-	int old_value;
+	u_long old_value;
 
 	fp = fopen(VM_MAX_WIRED, "w");
 	if (fp == NULL) {
@@ -78,7 +78,7 @@ set_vm_max_wired(int new_value)
 
 	vm_max_wired_sysctl(&old_value, NULL);
 
-	ATF_REQUIRE_MSG(fprintf(fp, "%d", old_value) > 0,
+	ATF_REQUIRE_MSG(fprintf(fp, "%lu", old_value) > 0,
 	    "saving %s failed", VM_MAX_WIRED);
 
 	fclose(fp);
@@ -90,7 +90,7 @@ void
 restore_vm_max_wired(void)
 {
 	FILE *fp;
-	int saved_max_wired;
+	u_long saved_max_wired;
 
 	fp = fopen(VM_MAX_WIRED, "r");
 	if (fp == NULL) {
@@ -98,14 +98,14 @@ restore_vm_max_wired(void)
 		return;
 	}
 
-	if (fscanf(fp, "%d", &saved_max_wired) != 1) {
+	if (fscanf(fp, "%lu", &saved_max_wired) != 1) {
 		perror("fscanf failed\n");
 		fclose(fp);
 		return;
 	}
 
 	fclose(fp);
-	printf("old value in %s: %d\n", VM_MAX_WIRED, saved_max_wired);
+	printf("old value in %s: %lu\n", VM_MAX_WIRED, saved_max_wired);
 
 	if (saved_max_wired == 0) /* This will cripple the test host */
 		return;
diff --git a/lib/libc/x86/gen/getcontextx.c b/lib/libc/x86/gen/getcontextx.c
index e9060bac44adc..056128a149ffa 100644
--- a/lib/libc/x86/gen/getcontextx.c
+++ b/lib/libc/x86/gen/getcontextx.c
@@ -61,7 +61,7 @@ __getcontextx_size_xfpu(void)
 	return (sizeof(ucontext_t) + xstate_sz);
 }
 
-DEFINE_UIFUNC(, int, __getcontextx_size, (void), static)
+DEFINE_UIFUNC(, int, __getcontextx_size, (void))
 {
 	u_int p[4];
 
@@ -100,7 +100,7 @@ __fillcontextx2_noxfpu(char *ctx)
 	return (0);
 }
 
-DEFINE_UIFUNC(, int, __fillcontextx2, (char *), static)
+DEFINE_UIFUNC(, int, __fillcontextx2, (char *))
 {
 
 	return ((cpu_feature2 & CPUID2_OSXSAVE) != 0 ? __fillcontextx2_xfpu : 
diff --git a/lib/libc/x86/sys/__vdso_gettc.c b/lib/libc/x86/sys/__vdso_gettc.c
index 0781e97e2ce5a..7a958ca256da9 100644
--- a/lib/libc/x86/sys/__vdso_gettc.c
+++ b/lib/libc/x86/sys/__vdso_gettc.c
@@ -72,7 +72,7 @@ rdtsc_mb_none(void)
 {
 }
 
-DEFINE_UIFUNC(static, void, rdtsc_mb, (void), static)
+DEFINE_UIFUNC(static, void, rdtsc_mb, (void))
 {
 	u_int p[4];
 	/* Not a typo, string matches our do_cpuid() registers use. */
diff --git a/lib/libc/x86/sys/pkru.c b/lib/libc/x86/sys/pkru.c
index 6aa3cbf95767e..28ce93389fd0e 100644
--- a/lib/libc/x86/sys/pkru.c
+++ b/lib/libc/x86/sys/pkru.c
@@ -71,7 +71,7 @@ x86_pkru_get_perm_hw(u_int keyidx, int *access, int *modify)
 	return (0);
 }
 
-DEFINE_UIFUNC(, int, x86_pkru_get_perm, (u_int, int *, int *), static)
+DEFINE_UIFUNC(, int, x86_pkru_get_perm, (u_int, int *, int *))
 {
 
 	return ((cpu_stdext_feature2 & CPUID_STDEXT2_OSPKE) == 0 ?
@@ -106,7 +106,7 @@ x86_pkru_set_perm_hw(u_int keyidx, int access, int modify)
 	return (0);
 }
 
-DEFINE_UIFUNC(, int, x86_pkru_set_perm, (u_int, int, int), static)
+DEFINE_UIFUNC(, int, x86_pkru_set_perm, (u_int, int, int))
 {
 
 	return ((cpu_stdext_feature2 & CPUID_STDEXT2_OSPKE) == 0 ?
diff --git a/lib/libcasper/services/cap_sysctl/Makefile b/lib/libcasper/services/cap_sysctl/Makefile
index b64b0636ad093..3b5de586675ac 100644
--- a/lib/libcasper/services/cap_sysctl/Makefile
+++ b/lib/libcasper/services/cap_sysctl/Makefile
@@ -6,7 +6,7 @@ SHLIBDIR?=	/lib/casper
 
 PACKAGE=libcasper
 
-SHLIB_MAJOR=	1
+SHLIB_MAJOR=	2
 INCSDIR?=	${INCLUDEDIR}/casper
 
 .if ${MK_CASPER} != "no"
@@ -25,8 +25,12 @@ HAS_TESTS=
 SUBDIR.${MK_TESTS}+= tests
 
 MAN+=	cap_sysctl.3
-
-MLINKS+=cap_sysctl.3 libcap_sysctl.3
-MLINKS+=cap_sysctl.3 cap_sysctlbyname.3
+MLINKS+=cap_sysctl.3 libcap_sysctl.3 \
+	cap_sysctl.3 cap_sysctlbyname.3 \
+	cap_sysctl.3 cap_nametomib.3 \
+	cap_sysctl.3 cap_sysctl_limit_init.3 \
+	cap_sysctl.3 cap_sysctl_limit_mib.3 \
+	cap_sysctl.3 cap_sysctl_limit_name.3 \
+	cap_sysctl.3 cap_sysctl_limit.3
 
 .include <bsd.lib.mk>
diff --git a/lib/libcasper/services/cap_sysctl/cap_sysctl.3 b/lib/libcasper/services/cap_sysctl/cap_sysctl.3
index 4bb96e21c5057..6ea34c42e196b 100644
--- a/lib/libcasper/services/cap_sysctl/cap_sysctl.3
+++ b/lib/libcasper/services/cap_sysctl/cap_sysctl.3
@@ -24,72 +24,113 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd March 18, 2018
+.Dd May 13, 2019
 .Dt CAP_SYSCTL 3
 .Os
 .Sh NAME
-.Nm cap_sysctlbyname
+.Nm cap_sysctl
 .Nd "library for getting or setting system information in capability mode"
 .Sh LIBRARY
 .Lb libcap_sysctl
 .Sh SYNOPSIS
-.In sys/nv.h
 .In libcasper.h
 .In casper/cap_sysctl.h
 .Ft int
-.Fn cap_sysctlbyname "cap_channel_t *chan" " const char *name" " void *oldp" " size_t *oldlenp" " const void *newp" " size_t newlen"
+.Fn cap_sysctl "cap_channel_t *chan" "const int *name" "u_int namelen" "void *oldp" "size_t *oldlenp" "const void *newp" "size_t newlen"
+.Ft int
+.Fn cap_sysctlbyname "cap_channel_t *chan" "const char *name" "void *oldp" "size_t *oldlenp" "const void *newp" "size_t newlen"
+.Ft int
+.Fn cap_sysctlnametomib "cap_channel_t *chan" "const char *name" "int *mibp" "size_t *sizep"
+.Ft void *
+.Fn cap_sysctl_limit_init "cap_channel_t *chan"
+.Ft void *
+.Fn cap_sysctl_limit_name "void *limit" "const char *name" "int flags"
+.Ft void *
+.Fn cap_sysctl_limit_mib "void *limit" "int *mibp" "u_int miblen" "int flags"
+.Ft int
+.Fn cap_sysctl_limit "void *limit"
 .Sh DESCRIPTION
-The function
+The
+.Fn cap_sysctl ,
 .Fn cap_sysctlbyname
-is equivalent to
+and
+.Fn cap_sysctlnametomib
+functions are equivalent to
+.Xr sysctl 3 ,
 .Xr sysctlbyname 3
-except that the connection to the
-.Nm system.sysctl
-service needs to be provided.
+and
+.Xr sysctlnametomib 3 ,
+except that they are implemented by the
+.Ql system.sysctl
+.Xr libcasper 3
+service and require a corresponding
+.Xr libcasper 3
+capability.
 .Sh LIMITS
-The service can be limited using
-.Xr cap_limit_set 3
-function.
+By default, the
+.Nm
+capability provides unrestricted access to the sysctl namespace.
+Applications typically only require access to a small number of sysctl
+variables; the
+.Fn cap_sysctl_limit
+interface can be used to restrict the sysctls that can be accessed using
+the
+.Nm
+capability.
+.Fn cap_sysctl_limit_init
+returns an opaque limit handle used to store a list of permitted sysctls
+and access rights.
+Rights are encoded using the following flags:
+.Pp
+.Bd -literal -offset indent -compact
+CAP_SYSCTL_READ		allow reads of the sysctl variable
+CAP_SYSCTL_WRITE        allow writes of the sysctl variable
+CAP_SYSCTL_RDWR         allow reads and writes of the sysctl variable
+CAP_RECURSIVE           permit access to any child of the sysctl variable
+.Ed
+.Pp
 The
-.Xr nvlist 9
-for that function can contain the following values and types:
-.Bl -ohang -offset indent
-.It ( NV_TYPE_NUMBER )
-The name of the element with type number will be treated as the limited sysctl.
-The value of the element will describe the access rights for given sysctl.
-There are four different rights
+.Fn cap_sysctl_limit_name
+function adds the sysctl identified by
+.Ar name
+to the limit list, and
+.Fn cap_sysctl_limit_mib
+function adds the sysctl identified by
+.Ar mibp
+to the limit list.
+The access rights for the sysctl are specified in the
+.Ar flags
+parameter; at least one of
 .Dv CAP_SYSCTL_READ ,
-.Dv CAP_SYSCTL_WRITE ,
-.Dv CAP_SYSCTL_RDWR ,
+.Dv CAP_SYSCTL_WRITE
 and
-.Dv CAP_SYSCTL_RECURSIVE .
-The
-.Dv CAP_SYSCTL_READ
-flag allows to fetch the value of a given sysctl.
-The
-.Dv CAP_SYSCTL_WIRTE
-flag allows to override the value of a given sysctl.
-The
 .Dv CAP_SYSCTL_RDWR
-is combination of the
-.Dv CAP_SYSCTL_WIRTE
-and
-.Dv CAP_SYSCTL_READ
-and allows to read and write the value of a given sysctl.
-The
-.Dv CAP_SYSCTL_RECURSIVE
-allows access to all children of a given sysctl.
-This right must be combined with at least one other right.
+must be specified.
+.Fn cap_sysctl_limit
+applies a set of sysctl limits to the capability, denying access to sysctl
+variables not belonging to the set.
+.Pp
+Once a set of limits is applied, subsequent calls to
+.Fn cap_sysctl_limit
+will fail unless the new set is a subset of the current set.
+.Pp
+.Fn cap_sysctlnametomib
+will succeed so long as the named sysctl variable is present in the limit set,
+regardless of its access rights.
+When a sysctl variable name is added to a limit set, its MIB identifier is
+automatically added to the set.
 .Sh EXAMPLES
-The following example first opens a capability to casper and then uses this
+The following example first opens a capability to casper, uses this
 capability to create the
 .Nm system.sysctl
-casper service and uses it to get the value of
+casper service, and then uses the
+.Nm
+capability to get the value of
 .Dv kern.trap_enotcap .
 .Bd -literal
 cap_channel_t *capcas, *capsysctl;
 const char *name = "kern.trap_enotcap";
-nvlist_t *limits;
+void *limit;
 int value;
 size_t size;
 
@@ -111,11 +152,11 @@ if (capsysctl == NULL)
 cap_close(capcas);
 
 /* Create limit for one MIB with read access only. */
-limits = nvlist_create(0);
-nvlist_add_number(limits, name, CAP_SYSCTL_READ);
+limit = cap_sysctl_limit_init(capsysctl);
+(void)cap_sysctl_limit_name(limit, name, CAP_SYSCTL_READ);
 
 /* Limit system.sysctl. */
-if (cap_limit_set(capsysctl, limits) < 0)
+if (cap_sysctl_limit(limit) < 0)
 	err(1, "Unable to set limits");
 
 /* Fetch value. */
@@ -129,7 +170,9 @@ cap_close(capsysctl);
 .Sh SEE ALSO
 .Xr cap_enter 2 ,
 .Xr err 3 ,
+.Xr sysctl 3 ,
 .Xr sysctlbyname 3 ,
+.Xr sysctlnametomib 3 ,
 .Xr capsicum 4 ,
 .Xr nv 9
 .Sh AUTHORS
diff --git a/lib/libcasper/services/cap_sysctl/cap_sysctl.c b/lib/libcasper/services/cap_sysctl/cap_sysctl.c
index c07e599890c93..40c4d033849d9 100644
--- a/lib/libcasper/services/cap_sysctl/cap_sysctl.c
+++ b/lib/libcasper/services/cap_sysctl/cap_sysctl.c
@@ -1,12 +1,15 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
- * Copyright (c) 2013 The FreeBSD Foundation
+ * Copyright (c) 2013, 2018 The FreeBSD Foundation
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
  * the FreeBSD Foundation.
  *
+ * Portions of this software were developed by Mark Johnston
+ * 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:
@@ -32,9 +35,11 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-#include <sys/types.h>
-#include <sys/sysctl.h>
+#include <sys/param.h>
+#include <sys/cnv.h>
+#include <sys/dnv.h>
 #include <sys/nv.h>
+#include <sys/sysctl.h>
 
 #include <assert.h>
 #include <errno.h>
@@ -46,24 +51,117 @@ __FBSDID("$FreeBSD$");
 
 #include "cap_sysctl.h"
 
+/*
+ * Limit interface.
+ */
+
+struct cap_sysctl_limit {
+	cap_channel_t *chan;
+	nvlist_t *nv;
+};
+
+cap_sysctl_limit_t *
+cap_sysctl_limit_init(cap_channel_t *chan)
+{
+	cap_sysctl_limit_t *limit;
+	int error;
+
+	limit = malloc(sizeof(*limit));
+	if (limit != NULL) {
+		limit->chan = chan;
+		limit->nv = nvlist_create(NV_FLAG_NO_UNIQUE);
+		if (limit->nv == NULL) {
+			error = errno;
+			free(limit);
+			limit = NULL;
+			errno = error;
+		}
+	}
+	return (limit);
+}
+
+cap_sysctl_limit_t *
+cap_sysctl_limit_name(cap_sysctl_limit_t *limit, const char *name, int flags)
+{
+	nvlist_t *lnv;
+	size_t mibsz;
+	int error, mib[CTL_MAXNAME];
+
+	lnv = nvlist_create(0);
+	if (lnv == NULL) {
+		error = errno;
+		if (limit->nv != NULL)
+			nvlist_destroy(limit->nv);
+		free(limit);
+		errno = error;
+		return (NULL);
+	}
+	nvlist_add_string(lnv, "name", name);
+	nvlist_add_number(lnv, "operation", flags);
+
+	mibsz = nitems(mib);
+	error = cap_sysctlnametomib(limit->chan, name, mib, &mibsz);
+	if (error == 0)
+		nvlist_add_binary(lnv, "mib", mib, mibsz * sizeof(int));
+
+	nvlist_move_nvlist(limit->nv, "limit", lnv);
+	return (limit);
+}
+
+cap_sysctl_limit_t *
+cap_sysctl_limit_mib(cap_sysctl_limit_t *limit, int *mibp, u_int miblen,
+    int flags)
+{
+	nvlist_t *lnv;
+	int error;
+
+	lnv = nvlist_create(0);
+	if (lnv == NULL) {
+		error = errno;
+		if (limit->nv != NULL)
+			nvlist_destroy(limit->nv);
+		free(limit);
+		errno = error;
+		return (NULL);
+	}
+	nvlist_add_binary(lnv, "mib", mibp, miblen * sizeof(int));
+	nvlist_add_number(lnv, "operation", flags);
+	nvlist_add_nvlist(limit->nv, "limit", lnv);
+	return (limit);
+}
+
 int
-cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
-    size_t *oldlenp, const void *newp, size_t newlen)
+cap_sysctl_limit(cap_sysctl_limit_t *limit)
+{
+	cap_channel_t *chan;
+	nvlist_t *lnv;
+
+	chan = limit->chan;
+	lnv = limit->nv;
+	free(limit);
+
+	/* cap_limit_set(3) will always free the nvlist. */
+	return (cap_limit_set(chan, lnv));
+}
+
+/*
+ * Service interface.
+ */
+
+static int
+do_sysctl(cap_channel_t *chan, nvlist_t *nvl, void *oldp, size_t *oldlenp,
+    const void *newp, size_t newlen)
 {
-	nvlist_t *nvl;
 	const uint8_t *retoldp;
-	uint8_t operation;
 	size_t oldlen;
+	int error;
+	uint8_t operation;
 
 	operation = 0;
-	if (oldp != NULL)
+	if (oldlenp != NULL)
 		operation |= CAP_SYSCTL_READ;
 	if (newp != NULL)
 		operation |= CAP_SYSCTL_WRITE;
-
-	nvl = nvlist_create(0);
-	nvlist_add_string(nvl, "cmd", "sysctl");
-	nvlist_add_string(nvl, "name", name);
 	nvlist_add_number(nvl, "operation", (uint64_t)operation);
 	if (oldp == NULL && oldlenp != NULL)
 		nvlist_add_null(nvl, "justsize");
@@ -71,12 +169,14 @@ cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
 		nvlist_add_number(nvl, "oldlen", (uint64_t)*oldlenp);
 	if (newp != NULL)
 		nvlist_add_binary(nvl, "newp", newp, newlen);
+
 	nvl = cap_xfer_nvlist(chan, nvl);
 	if (nvl == NULL)
 		return (-1);
-	if (nvlist_get_number(nvl, "error") != 0) {
-		errno = (int)nvlist_get_number(nvl, "error");
+	error = (int)dnvlist_get_number(nvl, "error", 0);
+	if (error != 0) {
 		nvlist_destroy(nvl);
+		errno = error;
 		return (-1);
 	}
 
@@ -88,21 +188,87 @@ cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
 		if (oldlenp != NULL)
 			*oldlenp = oldlen;
 	}
+
 	nvlist_destroy(nvl);
 
 	return (0);
 }
 
+int
+cap_sysctl(cap_channel_t *chan, const int *name, u_int namelen, void *oldp,
+    size_t *oldlenp, const void *newp, size_t newlen)
+{
+	nvlist_t *req;
+
+	req = nvlist_create(0);
+	nvlist_add_string(req, "cmd", "sysctl");
+	nvlist_add_binary(req, "mib", name, (size_t)namelen * sizeof(int));
+	return (do_sysctl(chan, req, oldp, oldlenp, newp, newlen));
+}
+
+int
+cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
+    size_t *oldlenp, const void *newp, size_t newlen)
+{
+	nvlist_t *req;
+
+	req = nvlist_create(0);
+	nvlist_add_string(req, "cmd", "sysctlbyname");
+	nvlist_add_string(req, "name", name);
+	return (do_sysctl(chan, req, oldp, oldlenp, newp, newlen));
+}
+
+int
+cap_sysctlnametomib(cap_channel_t *chan, const char *name, int *mibp,
+    size_t *sizep)
+{
+	nvlist_t *req;
+	const void *mib;
+	size_t mibsz;
+	int error;
+
+	req = nvlist_create(0);
+	nvlist_add_string(req, "cmd", "sysctlnametomib");
+	nvlist_add_string(req, "name", name);
+	nvlist_add_number(req, "operation", 0);
+	nvlist_add_number(req, "size", (uint64_t)*sizep);
+
+	req = cap_xfer_nvlist(chan, req);
+	if (req == NULL)
+		return (-1);
+	error = (int)dnvlist_get_number(req, "error", 0);
+	if (error != 0) {
+		nvlist_destroy(req);
+		errno = error;
+		return (-1);
+	}
+
+	mib = nvlist_get_binary(req, "mib", &mibsz);
+	*sizep = mibsz / sizeof(int);
+
+	memcpy(mibp, mib, mibsz); 
+
+	nvlist_destroy(req);
+
+	return (0);
+}
+
+/*
+ * Service implementation.
+ */
+
 /*
- * Service functions.
+ * Validate a sysctl description.  This must consist of an nvlist with either a
+ * binary "mib" field or a string "name", and an operation.
  */
 static int
-sysctl_check_one(const nvlist_t *nvl, bool islimit)
+sysctl_valid(const nvlist_t *nvl, bool limit)
 {
 	const char *name;
 	void *cookie;
 	int type;
-	unsigned int fields;
+	size_t size;
+	unsigned int field, fields;
 
 	/* NULL nvl is of course invalid. */
 	if (nvl == NULL)
@@ -111,83 +277,119 @@ sysctl_check_one(const nvlist_t *nvl, bool islimit)
 		return (nvlist_error(nvl));
 
 #define	HAS_NAME	0x01
-#define	HAS_OPERATION	0x02
+#define	HAS_MIB		0x02
+#define	HAS_ID		(HAS_NAME | HAS_MIB)
+#define	HAS_OPERATION	0x04
 
 	fields = 0;
 	cookie = NULL;
 	while ((name = nvlist_next(nvl, &type, &cookie)) != NULL) {
-		/* We accept only one 'name' and one 'operation' in nvl. */
-		if (strcmp(name, "name") == 0) {
-			if (type != NV_TYPE_STRING)
-				return (EINVAL);
-			/* Only one 'name' can be present. */
-			if ((fields & HAS_NAME) != 0)
+		if ((strcmp(name, "name") == 0 && type == NV_TYPE_STRING) ||
+		    (strcmp(name, "mib") == 0 && type == NV_TYPE_BINARY)) {
+			if (strcmp(name, "mib") == 0) {
+				/* A MIB must be an array of integers. */
+				(void)cnvlist_get_binary(cookie, &size);
+				if (size % sizeof(int) != 0)
+					return (EINVAL);
+				field = HAS_MIB;
+			} else
+				field = HAS_NAME;
+
+			/*
+			 * A limit may contain both a name and a MIB identifier.
+			 */
+			if ((fields & field) != 0 ||
+			    (!limit && (fields & HAS_ID) != 0))
 				return (EINVAL);
-			fields |= HAS_NAME;
+			fields |= field;
 		} else if (strcmp(name, "operation") == 0) {
-			uint64_t operation;
+			uint64_t mask, operation;
 
 			if (type != NV_TYPE_NUMBER)
 				return (EINVAL);
+
+			operation = cnvlist_get_number(cookie);
+
 			/*
-			 * We accept only CAP_SYSCTL_READ and
-			 * CAP_SYSCTL_WRITE flags.
+			 * Requests can only include the RDWR flags; limits may
+			 * also include the RECURSIVE flag.
 			 */
-			operation = nvlist_get_number(nvl, name);
-			if ((operation & ~(CAP_SYSCTL_RDWR)) != 0)
-				return (EINVAL);
-			/* ...but there has to be at least one of them. */
-			if ((operation & (CAP_SYSCTL_RDWR)) == 0)
+			mask = limit ? (CAP_SYSCTL_RDWR |
+			    CAP_SYSCTL_RECURSIVE) : CAP_SYSCTL_RDWR;
+			if ((operation & ~limit) != 0 ||
+			    (operation & CAP_SYSCTL_RDWR) == 0)
 				return (EINVAL);
 			/* Only one 'operation' can be present. */
 			if ((fields & HAS_OPERATION) != 0)
 				return (EINVAL);
 			fields |= HAS_OPERATION;
-		} else if (islimit) {
-			/* If this is limit, there can be no other fields. */
+		} else if (limit)
 			return (EINVAL);
-		}
 	}
 
-	/* Both fields has to be there. */
-	if (fields != (HAS_NAME | HAS_OPERATION))
+	if ((fields & HAS_OPERATION) == 0 || (fields & HAS_ID) == 0)
 		return (EINVAL);
 
-#undef	HAS_OPERATION
-#undef	HAS_NAME
+#undef HAS_OPERATION
+#undef HAS_ID
+#undef HAS_MIB
+#undef HAS_NAME
 
 	return (0);
 }
 
 static bool
-sysctl_allowed(const nvlist_t *limits, const char *chname, uint64_t choperation)
+sysctl_allowed(const nvlist_t *limits, const nvlist_t *req)
 {
-	uint64_t operation;
-	const char *name;
+	const nvlist_t *limit;
+	uint64_t op, reqop;
+	const char *lname, *name, *reqname;
 	void *cookie;
+	size_t lsize, reqsize;
+	const int *lmib, *reqmib;
 	int type;
 
 	if (limits == NULL)
 		return (true);
 
+	reqmib = dnvlist_get_binary(req, "mib", &reqsize, NULL, 0);
+	reqname = dnvlist_get_string(req, "name", NULL);
+	reqop = nvlist_get_number(req, "operation");
+
 	cookie = NULL;
 	while ((name = nvlist_next(limits, &type, &cookie)) != NULL) {
-		assert(type == NV_TYPE_NUMBER);
+		assert(type == NV_TYPE_NVLIST);
 
-		operation = nvlist_get_number(limits, name);
-		if ((operation & choperation) != choperation)
+		limit = cnvlist_get_nvlist(cookie);
+		op = nvlist_get_number(limit, "operation");
+		if ((reqop & op) != reqop)
 			continue;
 
-		if ((operation & CAP_SYSCTL_RECURSIVE) == 0) {
-			if (strcmp(name, chname) != 0)
+		if (reqname != NULL) {
+			lname = dnvlist_get_string(limit, "name", NULL);
+			if (lname == NULL)
 				continue;
-		} else {
-			size_t namelen;
+			if ((op & CAP_SYSCTL_RECURSIVE) == 0) {
+				if (strcmp(lname, reqname) != 0)
+					continue;
+			} else {
+				size_t namelen;
 
-			namelen = strlen(name);
-			if (strncmp(name, chname, namelen) != 0)
+				namelen = strlen(lname);
+				if (strncmp(lname, reqname, namelen) != 0)
+					continue;
+				if (reqname[namelen] != '.' &&
+				    reqname[namelen] != '\0')
+					continue;
+			}
+		} else {
+			lmib = dnvlist_get_binary(limit, "mib", &lsize, NULL, 0);
+			if (lmib == NULL)
 				continue;
-			if (chname[namelen] != '.' && chname[namelen] != '\0')
+			if (lsize > reqsize || ((op & CAP_SYSCTL_RECURSIVE) == 0 &&
+			    lsize < reqsize))
+				continue;
+			if (memcmp(lmib, reqmib, lsize) != 0)
 				continue;
 		}
 
@@ -200,21 +402,20 @@ sysctl_allowed(const nvlist_t *limits, const char *chname, uint64_t choperation)
 static int
 sysctl_limit(const nvlist_t *oldlimits, const nvlist_t *newlimits)
 {
+	const nvlist_t *nvl;
 	const char *name;
 	void *cookie;
-	uint64_t operation;
-	int type;
+	int error, type;
 
 	cookie = NULL;
 	while ((name = nvlist_next(newlimits, &type, &cookie)) != NULL) {
-		if (type != NV_TYPE_NUMBER)
-			return (EINVAL);
-		operation = nvlist_get_number(newlimits, name);
-		if ((operation & ~(CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE)) != 0)
+		if (strcmp(name, "limit") != 0 || type != NV_TYPE_NVLIST)
 			return (EINVAL);
-		if ((operation & (CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE)) == 0)
-			return (EINVAL);
-		if (!sysctl_allowed(oldlimits, name, operation))
+		nvl = cnvlist_get_nvlist(cookie);
+		error = sysctl_valid(nvl, true);
+		if (error != 0)
+			return (error);
+		if (!sysctl_allowed(oldlimits, nvl))
 			return (ENOTCAPABLE);
 	}
 
@@ -222,28 +423,59 @@ sysctl_limit(const nvlist_t *oldlimits, const nvlist_t *newlimits)
 }
 
 static int
+nametomib(const nvlist_t *limits, const nvlist_t *nvlin, nvlist_t *nvlout)
+{
+	const char *name;
+	size_t size;
+	int error, *mibp;
+
+	if (!sysctl_allowed(limits, nvlin))
+		return (ENOTCAPABLE);
+
+	name = nvlist_get_string(nvlin, "name");
+	size = (size_t)nvlist_get_number(nvlin, "size");
+
+	mibp = malloc(size * sizeof(*mibp));
+	if (mibp == NULL)
+		return (ENOMEM);
+
+	error = sysctlnametomib(name, mibp, &size);
+	if (error != 0) {
+		error = errno;
+		free(mibp);
+		return (error);
+	}
+
+	nvlist_add_binary(nvlout, "mib", mibp, size * sizeof(*mibp));
+
+	return (0);
+}
+
+static int
 sysctl_command(const char *cmd, const nvlist_t *limits, nvlist_t *nvlin,
     nvlist_t *nvlout)
 {
 	const char *name;
 	const void *newp;
+	const int *mibp;
 	void *oldp;
 	uint64_t operation;
-	size_t oldlen, newlen;
+	size_t oldlen, newlen, size;
 	size_t *oldlenp;
 	int error;
 
-	if (strcmp(cmd, "sysctl") != 0)
+	if (strcmp(cmd, "sysctlnametomib") == 0)
+		return (nametomib(limits, nvlin, nvlout));
+
+	if (strcmp(cmd, "sysctlbyname") != 0 && strcmp(cmd, "sysctl") != 0)
 		return (EINVAL);
-	error = sysctl_check_one(nvlin, false);
+	error = sysctl_valid(nvlin, false);
 	if (error != 0)
 		return (error);
-
-	name = nvlist_get_string(nvlin, "name");
-	operation = nvlist_get_number(nvlin, "operation");
-	if (!sysctl_allowed(limits, name, operation))
+	if (!sysctl_allowed(limits, nvlin))
 		return (ENOTCAPABLE);
 
+	operation = nvlist_get_number(nvlin, "operation");
 	if ((operation & CAP_SYSCTL_WRITE) != 0) {
 		if (!nvlist_exists_binary(nvlin, "newp"))
 			return (EINVAL);
@@ -276,7 +508,15 @@ sysctl_command(const char *cmd, const nvlist_t *limits, nvlist_t *nvlin,
 		oldlenp = NULL;
 	}
 
-	if (sysctlbyname(name, oldp, oldlenp, newp, newlen) == -1) {
+	if (strcmp(cmd, "sysctlbyname") == 0) {
+		name = nvlist_get_string(nvlin, "name");
+		error = sysctlbyname(name, oldp, oldlenp, newp, newlen);
+	} else {
+		mibp = nvlist_get_binary(nvlin, "mib", &size);
+		error = sysctl(mibp, size / sizeof(*mibp), oldp, oldlenp, newp,
+		    newlen);
+	}
+	if (error != 0) {
 		error = errno;
 		free(oldp);
 		return (error);
diff --git a/lib/libcasper/services/cap_sysctl/cap_sysctl.h b/lib/libcasper/services/cap_sysctl/cap_sysctl.h
index 6532874f2e941..65df2d083d856 100644
--- a/lib/libcasper/services/cap_sysctl/cap_sysctl.h
+++ b/lib/libcasper/services/cap_sysctl/cap_sysctl.h
@@ -29,24 +29,47 @@
  * $FreeBSD$
  */
 
-#ifndef	_CAP_SYSCTL_H_
+#ifndef _CAP_SYSCTL_H_
 #define	_CAP_SYSCTL_H_
 
 #ifdef HAVE_CASPER
-#define WITH_CASPER
+#define	WITH_CASPER
 #endif
 
+#ifdef WITH_CASPER
 #define	CAP_SYSCTL_READ		0x01
 #define	CAP_SYSCTL_WRITE	0x02
 #define	CAP_SYSCTL_RDWR		(CAP_SYSCTL_READ | CAP_SYSCTL_WRITE)
 #define	CAP_SYSCTL_RECURSIVE	0x04
 
-#ifdef WITH_CASPER
+int cap_sysctl(cap_channel_t *chan, const int *name, u_int namelen, void *oldp,
+    size_t *oldlenp, const void *newp, size_t newlen);
 int cap_sysctlbyname(cap_channel_t *chan, const char *name, void *oldp,
     size_t *oldlenp, const void *newp, size_t newlen);
-#else
-#define	cap_sysctlbyname(chan, name, oldp, oldlenp, newp, newlen)		\
-	sysctlbyname(name, oldp, oldlenp, newp, newlen)
-#endif
+int cap_sysctlnametomib(cap_channel_t *chan, const char *name, int *mibp,
+    size_t *sizep);
+
+struct cap_sysctl_limit;
+typedef struct cap_sysctl_limit cap_sysctl_limit_t;
+
+cap_sysctl_limit_t *cap_sysctl_limit_init(cap_channel_t *);
+cap_sysctl_limit_t *cap_sysctl_limit_name(cap_sysctl_limit_t *limit,
+    const char *name, int flags);
+cap_sysctl_limit_t *cap_sysctl_limit_mib(cap_sysctl_limit_t *limit, int *mibp,
+    u_int miblen, int flags);
+int cap_sysctl_limit(cap_sysctl_limit_t *limit);
+#else /* !WITH_CASPER */
+#define	cap_sysctl(chan, name, namelen, oldp, oldlenp, newp, newlen)	\
+	sysctl((name), (namelen), (oldp), (oldlenp), (newp), (newlen))
+#define	cap_sysctlbyname(chan, name, oldp, oldlenp, newp, newlen)	\
+	sysctlbyname((name), (oldp), (oldlenp), (newp), (newlen))
+#define	cap_sysctlnametomib(chan, name, mibp, sizep)			\
+	sysctlnametomib((name), (mibp), (sizep))
+
+#define	cap_sysctl_limit_init(chan)				(NULL)
+#define	cap_sysctl_limit_name(limit, name, flags)		(NULL)
+#define	cap_sysctl_limit_mib(limit, mibp, miblen, flags)	(NULL)
+#define	cap_sysctl_limit(limit)					(0)
+#endif /* WITH_CASPER */
 
-#endif	/* !_CAP_SYSCTL_H_ */
+#endif /* !_CAP_SYSCTL_H_ */
diff --git a/lib/libcasper/services/cap_sysctl/tests/Makefile b/lib/libcasper/services/cap_sysctl/tests/Makefile
index 3afd703846d30..46aa5424323dd 100644
--- a/lib/libcasper/services/cap_sysctl/tests/Makefile
+++ b/lib/libcasper/services/cap_sysctl/tests/Makefile
@@ -2,7 +2,7 @@
 
 .include <src.opts.mk>
 
-TAP_TESTS_C=	sysctl_test
+ATF_TESTS_C=	sysctl_test
 
 .if ${MK_CASPER} != "no"
 LIBADD+=	casper
diff --git a/lib/libcasper/services/cap_sysctl/tests/sysctl_test.c b/lib/libcasper/services/cap_sysctl/tests/sysctl_test.c
index 86d3f8bafae2f..cbe5c3c57724b 100644
--- a/lib/libcasper/services/cap_sysctl/tests/sysctl_test.c
+++ b/lib/libcasper/services/cap_sysctl/tests/sysctl_test.c
@@ -1,12 +1,15 @@
 /*-
  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
  *
- * Copyright (c) 2013 The FreeBSD Foundation
+ * Copyright (c) 2013, 2018 The FreeBSD Foundation
  * All rights reserved.
  *
  * This software was developed by Pawel Jakub Dawidek under sponsorship from
  * the FreeBSD Foundation.
  *
+ * Portions of this software were developed by Mark Johnston
+ * 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:
@@ -47,38 +50,20 @@ __FBSDID("$FreeBSD$");
 #include <unistd.h>
 
 #include <libcasper.h>
-
 #include <casper/cap_sysctl.h>
 
+#include <atf-c.h>
+
 /*
  * We need some sysctls to perform the tests on.
  * We remember their values and restore them afer the test is done.
  */
 #define	SYSCTL0_PARENT	"kern"
 #define	SYSCTL0_NAME	"kern.sync_on_panic"
+#define	SYSCTL0_FILE	"./sysctl0"
 #define	SYSCTL1_PARENT	"debug"
 #define	SYSCTL1_NAME	"debug.minidump"
-
-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__); \
-	fflush(stdout);							\
-	ntest++;							\
-} while (0)
-#define CHECKX(expr)     do {						\
-	if ((expr)) {							\
-		printf("ok %d # %s:%u\n", ntest, __FILE__, __LINE__);	\
-	} else {							\
-		printf("not ok %d # %s:%u\n", ntest, __FILE__, __LINE__); \
-		exit(1);						\
-	}								\
-	fflush(stdout);							\
-	ntest++;							\
-} while (0)
+#define	SYSCTL1_FILE	"./sysctl1"
 
 #define	SYSCTL0_READ0		0x0001
 #define	SYSCTL0_READ1		0x0002
@@ -91,21 +76,100 @@ static int ntest = 1;
 #define	SYSCTL1_WRITE		0x0100
 #define	SYSCTL1_READ_WRITE	0x0200
 
+static void
+save_int_sysctl(const char *name, const char *file)
+{
+	ssize_t n;
+	size_t sz;
+	int error, fd, val;
+
+	sz = sizeof(val);
+	error = sysctlbyname(name, &val, &sz, NULL, 0);
+	ATF_REQUIRE_MSG(error == 0,
+	    "sysctlbyname(%s): %s", name, strerror(errno));
+
+	fd = open(file, O_CREAT | O_WRONLY, 0600);
+	ATF_REQUIRE_MSG(fd >= 0, "open(%s): %s", file, strerror(errno));
+	n = write(fd, &val, sz);
+	ATF_REQUIRE(n >= 0 && (size_t)n == sz);
+	error = close(fd);
+	ATF_REQUIRE(error == 0);
+}
+
+static void
+restore_int_sysctl(const char *name, const char *file)
+{
+	ssize_t n;
+	size_t sz;
+	int error, fd, val;
+
+	fd = open(file, O_RDONLY);
+	ATF_REQUIRE(fd >= 0);
+	sz = sizeof(val);
+	n = read(fd, &val, sz);
+	ATF_REQUIRE(n >= 0 && (size_t)n == sz);
+	error = unlink(file);
+	ATF_REQUIRE(error == 0);
+	error = close(fd);
+	ATF_REQUIRE(error == 0);
+
+	error = sysctlbyname(name, NULL, NULL, &val, sz);
+	ATF_REQUIRE_MSG(error == 0,
+	    "sysctlbyname(%s): %s", name, strerror(errno));
+}
+
+static cap_channel_t *
+initcap(void)
+{
+	cap_channel_t *capcas, *capsysctl;
+
+	save_int_sysctl(SYSCTL0_NAME, SYSCTL0_FILE);
+	save_int_sysctl(SYSCTL1_NAME, SYSCTL1_FILE);
+
+	capcas = cap_init();
+	ATF_REQUIRE(capcas != NULL);
+
+	capsysctl = cap_service_open(capcas, "system.sysctl");
+	ATF_REQUIRE(capsysctl != NULL);
+
+	cap_close(capcas);
+
+	return (capsysctl);
+}
+
+static void
+cleanup(void)
+{
+
+	restore_int_sysctl(SYSCTL0_NAME, SYSCTL0_FILE);
+	restore_int_sysctl(SYSCTL1_NAME, SYSCTL1_FILE);
+}
+
 static unsigned int
-runtest(cap_channel_t *capsysctl)
+checkcaps(cap_channel_t *capsysctl)
 {
 	unsigned int result;
-	int oldvalue, newvalue;
-	size_t oldsize;
+	size_t len0, len1, oldsize;
+	int error, mib0[2], mib1[2], oldvalue, newvalue;
 
 	result = 0;
 
+	len0 = nitems(mib0);
+	ATF_REQUIRE(sysctlnametomib(SYSCTL0_NAME, mib0, &len0) == 0);
+	len1 = nitems(mib1);
+	ATF_REQUIRE(sysctlnametomib(SYSCTL1_NAME, mib1, &len1) == 0);
+
 	oldsize = sizeof(oldvalue);
 	if (cap_sysctlbyname(capsysctl, SYSCTL0_NAME, &oldvalue, &oldsize,
 	    NULL, 0) == 0) {
 		if (oldsize == sizeof(oldvalue))
 			result |= SYSCTL0_READ0;
 	}
+	error = cap_sysctl(capsysctl, mib0, len0, &oldvalue, &oldsize, NULL, 0);
+	if ((result & SYSCTL0_READ0) != 0)
+		ATF_REQUIRE(error == 0);
+	else
+		ATF_REQUIRE_ERRNO(ENOTCAPABLE, error != 0);
 
 	newvalue = 123;
 	if (cap_sysctlbyname(capsysctl, SYSCTL0_NAME, NULL, NULL, &newvalue,
@@ -121,6 +185,13 @@ runtest(cap_channel_t *capsysctl)
 				result |= SYSCTL0_READ1;
 		}
 	}
+	newvalue = 123;
+	error = cap_sysctl(capsysctl, mib0, len0, NULL, NULL,
+	    &newvalue, sizeof(newvalue));
+	if ((result & SYSCTL0_WRITE) != 0)
+		ATF_REQUIRE(error == 0);
+	else
+		ATF_REQUIRE_ERRNO(ENOTCAPABLE, error != 0);
 
 	oldsize = sizeof(oldvalue);
 	newvalue = 4567;
@@ -145,6 +216,11 @@ runtest(cap_channel_t *capsysctl)
 		if (oldsize == sizeof(oldvalue))
 			result |= SYSCTL1_READ0;
 	}
+	error = cap_sysctl(capsysctl, mib1, len1, &oldvalue, &oldsize, NULL, 0);
+	if ((result & SYSCTL1_READ0) != 0)
+		ATF_REQUIRE(error == 0);
+	else
+		ATF_REQUIRE_ERRNO(ENOTCAPABLE, error != 0);
 
 	newvalue = 506;
 	if (cap_sysctlbyname(capsysctl, SYSCTL1_NAME, NULL, NULL, &newvalue,
@@ -153,6 +229,10 @@ runtest(cap_channel_t *capsysctl)
 	}
 
 	if ((result & SYSCTL1_WRITE) != 0) {
+		newvalue = 506;
+		ATF_REQUIRE(cap_sysctl(capsysctl, mib1, len1, NULL, NULL,
+		    &newvalue, sizeof(newvalue)) == 0);
+
 		oldsize = sizeof(oldvalue);
 		if (cap_sysctlbyname(capsysctl, SYSCTL1_NAME, &oldvalue,
 		    &oldsize, NULL, 0) == 0) {
@@ -160,6 +240,13 @@ runtest(cap_channel_t *capsysctl)
 				result |= SYSCTL1_READ1;
 		}
 	}
+	newvalue = 506;
+	error = cap_sysctl(capsysctl, mib1, len1, NULL, NULL,
+	    &newvalue, sizeof(newvalue));
+	if ((result & SYSCTL1_WRITE) != 0)
+		ATF_REQUIRE(error == 0);
+	else
+		ATF_REQUIRE_ERRNO(ENOTCAPABLE, error != 0);
 
 	oldsize = sizeof(oldvalue);
 	newvalue = 7008;
@@ -181,11 +268,16 @@ runtest(cap_channel_t *capsysctl)
 	return (result);
 }
 
-static void
-test_operation(cap_channel_t *origcapsysctl)
+ATF_TC_WITH_CLEANUP(cap_sysctl__operation);
+ATF_TC_HEAD(cap_sysctl__operation, tc)
 {
-	cap_channel_t *capsysctl;
-	nvlist_t *limits;
+}
+ATF_TC_BODY(cap_sysctl__operation, tc)
+{
+	cap_channel_t *capsysctl, *ocapsysctl;
+	void *limit;
+
+	ocapsysctl = initcap();
 
 	/*
 	 * Allow:
@@ -193,66 +285,68 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, "foo.bar",
+	(void)cap_sysctl_limit_name(limit, "foo.bar",
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, "foo.bar",
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, "foo.bar",
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
 	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
 	    SYSCTL1_READ_WRITE));
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
 	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
 	    SYSCTL1_READ_WRITE));
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == SYSCTL0_READ0);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL0_READ0);
 
 	cap_close(capsysctl);
 
@@ -262,34 +356,35 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
 	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
 	    SYSCTL1_READ_WRITE));
@@ -302,31 +397,31 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/RDWR
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -336,31 +431,31 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/RDWR
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
 	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
 	    SYSCTL1_READ_WRITE));
@@ -373,34 +468,34 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
 	    SYSCTL1_READ2 | SYSCTL1_WRITE | SYSCTL1_READ_WRITE));
 
 	cap_close(capsysctl);
@@ -411,30 +506,30 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
 	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
 	    SYSCTL1_READ_WRITE));
@@ -447,51 +542,51 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
 
 	cap_close(capsysctl);
 
@@ -501,51 +596,51 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
 
 	cap_close(capsysctl);
 
@@ -555,59 +650,59 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/READ
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -617,59 +712,59 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/READ
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
 
 	cap_close(capsysctl);
 
@@ -679,21 +774,21 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_READ0);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_READ0);
 
 	cap_close(capsysctl);
 
@@ -703,21 +798,21 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_READ0));
 
 	cap_close(capsysctl);
 
@@ -727,51 +822,51 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -781,51 +876,51 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -835,59 +930,59 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -897,59 +992,59 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -959,21 +1054,21 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_WRITE);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_WRITE);
 
 	cap_close(capsysctl);
 
@@ -983,21 +1078,21 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_WRITE | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -1007,17 +1102,17 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -1027,17 +1122,17 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -1047,15 +1142,15 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -1065,15 +1160,15 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 
@@ -1083,16 +1178,16 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_PARENT/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_WRITE);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_WRITE);
 
 	cap_close(capsysctl);
 
@@ -1102,57 +1197,66 @@ test_operation(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL1_WRITE));
 
 	cap_close(capsysctl);
 }
+ATF_TC_CLEANUP(cap_sysctl__operation, tc)
+{
+	cleanup();
+}
 
-static void
-test_names(cap_channel_t *origcapsysctl)
+ATF_TC_WITH_CLEANUP(cap_sysctl__names);
+ATF_TC_HEAD(cap_sysctl__names, tc)
 {
-	cap_channel_t *capsysctl;
-	nvlist_t *limits;
+}
+ATF_TC_BODY(cap_sysctl__names, tc)
+{
+	cap_channel_t *capsysctl, *ocapsysctl;
+	void *limit;
+
+	ocapsysctl = initcap();
 
 	/*
 	 * Allow:
 	 * SYSCTL0_PARENT/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL0_READ0);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL0_READ0);
 
 	cap_close(capsysctl);
 
@@ -1161,32 +1265,32 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/READ/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_READ | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_READ0);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_READ0);
 
 	cap_close(capsysctl);
 
@@ -1195,32 +1299,32 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL0_PARENT/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL0_WRITE);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL0_WRITE);
 
 	cap_close(capsysctl);
 
@@ -1229,32 +1333,32 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_WRITE | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_WRITE);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_WRITE);
 
 	cap_close(capsysctl);
 
@@ -1263,32 +1367,32 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL0_PARENT/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
 	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE));
 
 	cap_close(capsysctl);
@@ -1298,32 +1402,32 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/RDWR/RECURSIVE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	nvlist_add_number(limits, SYSCTL1_NAME,
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME,
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME,
 	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
 	    SYSCTL1_READ2 | SYSCTL1_WRITE | SYSCTL1_READ_WRITE));
 
 	cap_close(capsysctl);
@@ -1333,21 +1437,21 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL0_PARENT/READ
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -1356,21 +1460,21 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/READ
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_READ);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_READ);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_READ0);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_READ0);
 
 	cap_close(capsysctl);
 
@@ -1379,21 +1483,21 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL0_PARENT/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -1402,21 +1506,21 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/WRITE
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_WRITE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == SYSCTL1_WRITE);
+	ATF_REQUIRE(checkcaps(capsysctl) == SYSCTL1_WRITE);
 
 	cap_close(capsysctl);
 
@@ -1425,21 +1529,21 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL0_PARENT/RDWR
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_PARENT, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_PARENT, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == 0);
+	ATF_REQUIRE(checkcaps(capsysctl) == 0);
 
 	cap_close(capsysctl);
 
@@ -1448,68 +1552,142 @@ test_names(cap_channel_t *origcapsysctl)
 	 * SYSCTL1_NAME/RDWR
 	 */
 
-	capsysctl = cap_clone(origcapsysctl);
-	CHECK(capsysctl != NULL);
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == 0);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	nvlist_add_number(limits, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
-	limits = nvlist_create(0);
-	nvlist_add_number(limits, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
-	CHECK(cap_limit_set(capsysctl, limits) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	(void)cap_sysctl_limit_name(limit, SYSCTL1_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, SYSCTL0_NAME, CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == -1 && errno == ENOTCAPABLE);
 
-	CHECK(runtest(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
+	ATF_REQUIRE(checkcaps(capsysctl) == (SYSCTL1_READ0 | SYSCTL1_READ1 |
 	    SYSCTL1_READ2 | SYSCTL1_WRITE | SYSCTL1_READ_WRITE));
 
 	cap_close(capsysctl);
 }
+ATF_TC_CLEANUP(cap_sysctl__names, tc)
+{
+	cleanup();
+}
 
-int
-main(void)
+ATF_TC_WITH_CLEANUP(cap_sysctl__no_limits);
+ATF_TC_HEAD(cap_sysctl__no_limits, tc)
 {
-	cap_channel_t *capcas, *capsysctl;
-	int scvalue0, scvalue1;
-	size_t scsize;
+}
+ATF_TC_BODY(cap_sysctl__no_limits, tc)
+{
+	cap_channel_t *capsysctl;
 
-	printf("1..256\n");
-	fflush(stdout);
+	capsysctl = initcap();
 
-	scsize = sizeof(scvalue0);
-	CHECKX(sysctlbyname(SYSCTL0_NAME, &scvalue0, &scsize, NULL, 0) == 0);
-	CHECKX(scsize == sizeof(scvalue0));
-	scsize = sizeof(scvalue1);
-	CHECKX(sysctlbyname(SYSCTL1_NAME, &scvalue1, &scsize, NULL, 0) == 0);
-	CHECKX(scsize == sizeof(scvalue1));
+	ATF_REQUIRE_EQ(checkcaps(capsysctl), (SYSCTL0_READ0 | SYSCTL0_READ1 |
+	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
+	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
+	    SYSCTL1_READ_WRITE));
+}
+ATF_TC_CLEANUP(cap_sysctl__no_limits, tc)
+{
+	cleanup();
+}
 
-	capcas = cap_init();
-	CHECKX(capcas != NULL);
+ATF_TC_WITH_CLEANUP(cap_sysctl__recursive_limits);
+ATF_TC_HEAD(cap_sysctl__recursive_limits, tc)
+{
+}
+ATF_TC_BODY(cap_sysctl__recursive_limits, tc)
+{
+	cap_channel_t *capsysctl, *ocapsysctl;
+	void *limit;
+	size_t len;
+	int mib[2], val = 420;
 
-	capsysctl = cap_service_open(capcas, "system.sysctl");
-	CHECKX(capsysctl != NULL);
+	len = nitems(mib);
+	ATF_REQUIRE(sysctlnametomib(SYSCTL0_NAME, mib, &len) == 0);
 
-	cap_close(capcas);
+	ocapsysctl = initcap();
 
-	/* No limits set. */
+	/*
+	 * Make sure that we match entire components.
+	 */
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	CHECK(runtest(capsysctl) == (SYSCTL0_READ0 | SYSCTL0_READ1 |
-	    SYSCTL0_READ2 | SYSCTL0_WRITE | SYSCTL0_READ_WRITE |
-	    SYSCTL1_READ0 | SYSCTL1_READ1 | SYSCTL1_READ2 | SYSCTL1_WRITE |
-	    SYSCTL1_READ_WRITE));
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, "ker",
+	    CAP_SYSCTL_RDWR | CAP_SYSCTL_RECURSIVE);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
 
-	test_operation(capsysctl);
+	ATF_REQUIRE_ERRNO(ENOTCAPABLE, cap_sysctlbyname(capsysctl, SYSCTL0_NAME,
+	    NULL, NULL, &val, sizeof(val)));
+	ATF_REQUIRE_ERRNO(ENOTCAPABLE, cap_sysctl(capsysctl, mib, len,
+	    NULL, NULL, &val, sizeof(val)));
+
+	cap_close(capsysctl);
+
+	/*
+	 * Verify that we check for CAP_SYSCTL_RECURSIVE.
+	 */
+	capsysctl = cap_clone(ocapsysctl);
+	ATF_REQUIRE(capsysctl != NULL);
 
-	test_names(capsysctl);
+	limit = cap_sysctl_limit_init(capsysctl);
+	(void)cap_sysctl_limit_name(limit, "kern", CAP_SYSCTL_RDWR);
+	ATF_REQUIRE(cap_sysctl_limit(limit) == 0);
+
+	ATF_REQUIRE_ERRNO(ENOTCAPABLE, cap_sysctlbyname(capsysctl, SYSCTL0_NAME,
+	    NULL, NULL, &val, sizeof(val)));
+	ATF_REQUIRE_ERRNO(ENOTCAPABLE, cap_sysctl(capsysctl, mib, len,
+	    NULL, NULL, &val, sizeof(val)));
 
 	cap_close(capsysctl);
+}
+ATF_TC_CLEANUP(cap_sysctl__recursive_limits, tc)
+{
+	cleanup();
+}
 
-	CHECK(sysctlbyname(SYSCTL0_NAME, NULL, NULL, &scvalue0,
-	    sizeof(scvalue0)) == 0);
-	CHECK(sysctlbyname(SYSCTL1_NAME, NULL, NULL, &scvalue1,
-	    sizeof(scvalue1)) == 0);
+ATF_TC_WITH_CLEANUP(cap_sysctl__just_size);
+ATF_TC_HEAD(cap_sysctl__just_size, tc)
+{
+}
+ATF_TC_BODY(cap_sysctl__just_size, tc)
+{
+	cap_channel_t *capsysctl;
+	size_t len;
+	int mib0[2];
+
+	capsysctl = initcap();
+
+	len = nitems(mib0);
+	ATF_REQUIRE(sysctlnametomib(SYSCTL0_NAME, mib0, &len) == 0);
+
+	ATF_REQUIRE(cap_sysctlbyname(capsysctl, SYSCTL0_NAME,
+	    NULL, &len, NULL, 0) == 0);
+	ATF_REQUIRE(len == sizeof(int));
+	ATF_REQUIRE(cap_sysctl(capsysctl, mib0, nitems(mib0),
+	    NULL, &len, NULL, 0) == 0);
+	ATF_REQUIRE(len == sizeof(int));
+
+	cap_close(capsysctl);
+}
+ATF_TC_CLEANUP(cap_sysctl__just_size, tc)
+{
+	cleanup();
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, cap_sysctl__operation);
+	ATF_TP_ADD_TC(tp, cap_sysctl__names);
+	ATF_TP_ADD_TC(tp, cap_sysctl__no_limits);
+	ATF_TP_ADD_TC(tp, cap_sysctl__recursive_limits);
+	ATF_TP_ADD_TC(tp, cap_sysctl__just_size);
 
-	exit(0);
+	return (atf_no_error());
 }
diff --git a/lib/libcrypt/crypt.3 b/lib/libcrypt/crypt.3
index bceec437691f6..a0099edf9c904 100644
--- a/lib/libcrypt/crypt.3
+++ b/lib/libcrypt/crypt.3
@@ -29,7 +29,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd August 10, 2016
+.Dd May 26, 2019
 .Dt CRYPT 3
 .Os
 .Sh NAME
@@ -222,7 +222,7 @@ This is currently
 .\" NOTICE: Also make sure to update this
 .\"
 DES
-if it is available, or MD5 if not.
+if it is available, or SHA-512 if not.
 .Pp
 How the salt is used will depend upon the algorithm for the hash.
 For
diff --git a/lib/libelftc/Makefile b/lib/libelftc/Makefile
index fa2f8c314699a..e25331cee719c 100644
--- a/lib/libelftc/Makefile
+++ b/lib/libelftc/Makefile
@@ -38,6 +38,19 @@ MAN+=	elftc.3 \
 	elftc_string_table_create.3 \
 	elftc_version.3
 
+MLINKS+= \
+	elftc_bfd_find_target.3 elftc_bfd_target_class.3 \
+	elftc_bfd_find_target.3 elftc_bfd_target_byteorder.3 \
+	elftc_bfd_find_target.3 elftc_bfd_target_flavor.3 \
+	elftc_bfd_find_target.3 elftc_bfd_target_machine.3 \
+	elftc_string_table_create.3 elftc_string_table_destroy.3 \
+	elftc_string_table_create.3 elftc_string_table_from_section.3 \
+	elftc_string_table_create.3 elftc_string_table_image.3 \
+	elftc_string_table_create.3 elftc_string_table_insert.3 \
+	elftc_string_table_create.3 elftc_string_table_lookup.3 \
+	elftc_string_table_create.3 elftc_string_table_remove.3 \
+	elftc_string_table_create.3 elftc_string_table_to_string.3
+
 # This same hack is in lib/libelf/Makefile and usr.bin/readelf/Makefile
 # We need to link against the correct version of these files. One
 # solution is to include ../../sys in the include path. This causes
diff --git a/lib/libjail/jail_getid.c b/lib/libjail/jail_getid.c
index 6ab6d9eff98a1..3700ff0d36cca 100644
--- a/lib/libjail/jail_getid.c
+++ b/lib/libjail/jail_getid.c
@@ -53,13 +53,27 @@ jail_getid(const char *name)
 	struct iovec jiov[4];
 
 	jid = strtoul(name, &ep, 10);
-	if (*name && !*ep)
-		return jid;
-	jiov[0].iov_base = __DECONST(char *, "name");
-	jiov[0].iov_len = sizeof("name");
-	jiov[1].iov_len = strlen(name) + 1;
-	jiov[1].iov_base = alloca(jiov[1].iov_len);
-	strcpy(jiov[1].iov_base, name);
+	if (*name && !*ep) {
+		/*
+		 * jid == 0 is a special case; it will not appear in the
+		 * kernel's jail list, but naturally processes will be assigned
+		 * to it because it is prison 0.  Trivially return this one
+		 * without a trip to the kernel, because it always exists but
+		 * the lookup won't succeed.
+		 */
+		if (jid == 0)
+			return jid;
+		jiov[0].iov_base = __DECONST(char *, "jid");
+		jiov[0].iov_len = sizeof("jid");
+		jiov[1].iov_base = &jid;
+		jiov[1].iov_len = sizeof(jid);
+	} else {
+		jiov[0].iov_base = __DECONST(char *, "name");
+		jiov[0].iov_len = sizeof("name");
+		jiov[1].iov_len = strlen(name) + 1;
+		jiov[1].iov_base = alloca(jiov[1].iov_len);
+		strcpy(jiov[1].iov_base, name);
+	}
 	jiov[2].iov_base = __DECONST(char *, "errmsg");
 	jiov[2].iov_len = sizeof("errmsg");
 	jiov[3].iov_base = jail_errmsg;
diff --git a/lib/libmd/mdX.3 b/lib/libmd/mdX.3
index 9440c286b212f..b5f4fc07c9b7a 100644
--- a/lib/libmd/mdX.3
+++ b/lib/libmd/mdX.3
@@ -8,7 +8,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd July 20, 2018
+.Dd May 21, 2019
 .Dt MDX 3
 .Os
 .Sh NAME
@@ -144,6 +144,26 @@ after use.
 If the
 .Fa buf
 argument is non-null it must point to at least 33 characters of buffer space.
+.Sh ERRORS
+The
+.Fn MDXEnd
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn MDXFile
+and
+.Fn MDXFileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr MDXEnd 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
@@ -188,6 +208,8 @@ This code is derived directly from these implementations by
 .Pp
 Phk ristede runen.
 .Sh BUGS
-No method is known to exist which finds two files having the same hash value,
-nor to find a file with a specific hash value.
-There is on the other hand no guarantee that such a method does not exist.
+The
+.Tn MD5
+algorithm has been proven to be vulnerable to practical collision
+attacks and should not be relied upon to produce unique outputs,
+.Em nor should they be used as part of a cryptographic signature scheme.
diff --git a/lib/libmd/ripemd.3 b/lib/libmd/ripemd.3
index e4c5fa4a41c89..54cdf73ecc8d7 100644
--- a/lib/libmd/ripemd.3
+++ b/lib/libmd/ripemd.3
@@ -124,6 +124,26 @@ after use.
 If the
 .Fa buf
 argument is non-null it must point to at least 41 characters of buffer space.
+.Sh ERRORS
+The
+.Fn RIPEMD160_End
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn RIPEMD160_File
+and
+.Fn RIPEMD160_FileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr RIPEMD160_End 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
diff --git a/lib/libmd/sha.3 b/lib/libmd/sha.3
index 90cc936624297..ac8e3ae02511d 100644
--- a/lib/libmd/sha.3
+++ b/lib/libmd/sha.3
@@ -9,7 +9,7 @@
 .\" 	From: Id: mdX.3,v 1.14 1999/02/11 20:31:49 wollman Exp
 .\" $FreeBSD$
 .\"
-.Dd July 20, 2018
+.Dd May 21, 2019
 .Dt SHA 3
 .Os
 .Sh NAME
@@ -155,6 +155,26 @@ after use.
 If the
 .Fa buf
 argument is non-null it must point to at least 41 characters of buffer space.
+.Sh ERRORS
+The
+.Fn SHA1_End
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn SHA1_File
+and
+.Fn SHA1_FileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr SHA1_End 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
@@ -171,9 +191,11 @@ published
 .Tn FIPS
 standards.
 .Sh BUGS
-No method is known to exist which finds two files having the same hash value,
-nor to find a file with a specific hash value.
-There is on the other hand no guarantee that such a method does not exist.
+The
+.Tn SHA1
+algorithm has been proven to be vulnerable to practical collision
+attacks and should not be relied upon to produce unique outputs,
+.Em nor should it be used as part of a new cryptographic signature scheme.
 .Pp
 The
 .Tn IA32
diff --git a/lib/libmd/sha256.3 b/lib/libmd/sha256.3
index eeac4041f479f..a6829a5ed2ea3 100644
--- a/lib/libmd/sha256.3
+++ b/lib/libmd/sha256.3
@@ -146,6 +146,26 @@ argument is non-null it must point to at least 65 characters of buffer space.
 .Pp
 SHA224 is identical SHA256, except it has slightly different initialization
 vectors, and is truncated to a shorter digest.
+.Sh ERRORS
+The
+.Fn SHA256_End
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn SHA256_File
+and
+.Fn SHA256_FileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr SHA256_End 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
diff --git a/lib/libmd/sha512.3 b/lib/libmd/sha512.3
index a842e9cada61e..64981e64310c7 100644
--- a/lib/libmd/sha512.3
+++ b/lib/libmd/sha512.3
@@ -9,7 +9,7 @@
 .\" 	From: Id: mdX.3,v 1.14 1999/02/11 20:31:49 wollman Exp
 .\" $FreeBSD$
 .\"
-.Dd July 20, 2018
+.Dd May 21, 2019
 .Dt SHA512 3
 .Os
 .Sh NAME
@@ -190,6 +190,26 @@ which converts the return value to a 65-character
 (including the terminating '\e0')
 .Tn ASCII
 string which represents the 256 bits in hexadecimal.
+.Sh ERRORS
+The
+.Fn SHA512_End
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn SHA512_File
+and
+.Fn SHA512_FileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr SHA512_End 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
diff --git a/lib/libmd/skein.3 b/lib/libmd/skein.3
index 2d6a9e3fd4b14..b0278028b1bce 100644
--- a/lib/libmd/skein.3
+++ b/lib/libmd/skein.3
@@ -25,7 +25,7 @@
 .\"
 .\" $FreeBSD$
 .\"
-.Dd May 28, 2016
+.Dd May 21, 2019
 .Dt SKEIN 3
 .Os
 .Sh NAME
@@ -188,6 +188,26 @@ functions are similar to the
 .Li SKEIN256_
 functions except they produce a 512-bit, 65 character,
 or 1024-bit, 129 character, output.
+.Sh ERRORS
+The
+.Fn SKEIN256_End
+function called with a null buf argument may fail and return NULL if:
+.Bl -tag -width Er
+.It Bq Er ENOMEM
+Insufficient storage space is available.
+.El
+.Pp
+The
+.Fn SKEIN256_File
+and
+.Fn SKEIN256_FileChunk
+may return NULL when underlying 
+.Xr open 2 ,
+.Xr fstat 2 ,
+.Xr lseek 2 ,
+or
+.Xr SKEIN256_End 2
+fail.
 .Sh SEE ALSO
 .Xr md4 3 ,
 .Xr md5 3 ,
diff --git a/lib/libmemstat/memstat_uma.c b/lib/libmemstat/memstat_uma.c
index 89b394c151ad9..2575fb7045211 100644
--- a/lib/libmemstat/memstat_uma.c
+++ b/lib/libmemstat/memstat_uma.c
@@ -423,6 +423,11 @@ memstat_kvm_uma(struct memory_type_list *list, void *kvm_handle)
 			mtp->mt_failures = kvm_counter_u64_fetch(kvm,
 			    (unsigned long )uz.uz_fails);
 			mtp->mt_sleeps = uz.uz_sleeps;
+
+			/* See comment above in memstat_sysctl_uma(). */
+			if (mtp->mt_numallocs < mtp->mt_numfrees)
+				mtp->mt_numallocs = mtp->mt_numfrees;
+
 			if (kz.uk_flags & UMA_ZFLAG_INTERNAL)
 				goto skip_percpu;
 			for (i = 0; i < mp_maxid + 1; i++) {
diff --git a/lib/libomp/Makefile b/lib/libomp/Makefile
index c0f1cc1c6db79..743c319599612 100644
--- a/lib/libomp/Makefile
+++ b/lib/libomp/Makefile
@@ -68,4 +68,6 @@ VERSION_MAP=	${OMPSRC}/exports_so.txt
 LIBADD+=	pthread
 LIBADD+=	m
 
+SYMLINKS+=	${SHLIB_NAME} ${LIBDIR}/libgomp.so
+
 .include <bsd.lib.mk>
diff --git a/lib/libsecureboot/h/libsecureboot.h b/lib/libsecureboot/h/libsecureboot.h
index 6599db299aefa..81984fde5f3e8 100644
--- a/lib/libsecureboot/h/libsecureboot.h
+++ b/lib/libsecureboot/h/libsecureboot.h
@@ -81,6 +81,8 @@ unsigned char *verify_asc(const char *, int); /* OpenPGP */
 void ve_pcr_init(void);
 void ve_pcr_update(unsigned char *, size_t);
 ssize_t ve_pcr_get(unsigned char *, size_t);
+int ve_pcr_updating_get(void);
+void ve_pcr_updating_set(int);
 
 /* flags for verify_{asc,sig,signed} */
 #define VEF_VERBOSE		1
diff --git a/lib/libsecureboot/openpgp/opgp_key.c b/lib/libsecureboot/openpgp/opgp_key.c
index 0a064b5a008e0..dc0d8fa2934d6 100644
--- a/lib/libsecureboot/openpgp/opgp_key.c
+++ b/lib/libsecureboot/openpgp/opgp_key.c
@@ -168,6 +168,7 @@ load_key_buf(unsigned char *buf, size_t nbytes)
 	initialize();
 
 	if (!(buf[0] & OPENPGP_TAG_ISTAG)) {
+		/* Note: we do *not* free data */
 		data = dearmor((char *)buf, nbytes, &nbytes);
 		ptr = data;
 	} else
@@ -190,7 +191,6 @@ load_key_buf(unsigned char *buf, size_t nbytes)
 			}
 		}
 	}
-	free(data);
 	return (key);
 }
 
@@ -209,8 +209,10 @@ openpgp_trust_add(OpenPGP_key *key)
 
 		LIST_INIT(&trust_list);
 	}
-	if (key)
+	if (key) {
+		DEBUG_PRINTF(2, ("openpgp_trust_add(%s)\n", key->id));
 		LIST_INSERT_HEAD(&trust_list, key, entries);
+	}
 }
 
 /**
@@ -296,6 +298,7 @@ load_key_id(const char *keyID)
 	if (!key)
 		key = load_trusted_key_id(keyID);
 #endif
+	DEBUG_PRINTF(2, ("load_key_id(%s): %s\n", keyID, key ? "found" : "nope"));
 	return (key);
 }
 
diff --git a/lib/libsecureboot/openpgp/opgp_sig.c b/lib/libsecureboot/openpgp/opgp_sig.c
index 804e2c83ce455..df4c33e6405d8 100644
--- a/lib/libsecureboot/openpgp/opgp_sig.c
+++ b/lib/libsecureboot/openpgp/opgp_sig.c
@@ -318,6 +318,7 @@ openpgp_verify(const char *filename,
 		sdata = ddata = dearmor((char *)sdata, sbytes, &sbytes);
 	ptr = sdata;
 	rc = decode_packet(2, &ptr, sbytes, (decoder_t)decode_sig, sig);
+	DEBUG_PRINTF(2, ("rc=%d keyID=%s\n", rc, sig->key_id ? sig->key_id : "?"));
 	if (rc == 0 && sig->key_id) {
 		key = load_key_id(sig->key_id);
 		if (!key) {
diff --git a/lib/libsecureboot/tests/tvo.c b/lib/libsecureboot/tests/tvo.c
index 9ad3278010162..ad3bccb0614fd 100644
--- a/lib/libsecureboot/tests/tvo.c
+++ b/lib/libsecureboot/tests/tvo.c
@@ -74,6 +74,9 @@ main(int argc, char *argv[])
 		}
 	}
 
+#ifdef VE_PCR_SUPPORT
+	ve_pcr_updating_set(1);
+#endif
 	ve_self_tests();
 
 	for ( ; optind < argc; optind++) {
@@ -176,6 +179,10 @@ main(int argc, char *argv[])
 			}
 		}
 	}
+#ifdef VE_PCR_SUPPORT
+	verify_pcr_export();
+	printf("pcr=%s\n", getenv("loader.ve.pcr"));
+#endif
 	return (0);
 }
 
diff --git a/lib/libsecureboot/vepcr.c b/lib/libsecureboot/vepcr.c
index 0a3dc1fa12eb2..a97cb7245832e 100644
--- a/lib/libsecureboot/vepcr.c
+++ b/lib/libsecureboot/vepcr.c
@@ -43,6 +43,7 @@ __FBSDID("$FreeBSD$");
 static const br_hash_class *pcr_md = NULL;
 static br_hash_compat_context pcr_ctx;
 static size_t pcr_hlen = 0;
+static int pcr_updating;
 
 /**
  * @brief initialize pcr context
@@ -53,18 +54,37 @@ static size_t pcr_hlen = 0;
 void
 ve_pcr_init(void)
 {
+	pcr_updating = 0;
 	pcr_hlen = br_sha256_SIZE;
 	pcr_md = &br_sha256_vtable;
 	pcr_md->init(&pcr_ctx.vtable);
 }
 
 /**
+ * @brief get pcr_updating state
+ */
+int
+ve_pcr_updating_get(void)
+{
+	return (pcr_updating);
+}
+
+/**
+ * @brief set pcr_updating state
+ */
+void
+ve_pcr_updating_set(int updating)
+{
+	pcr_updating = updating;
+}
+
+/**
  * @brief update pcr context
  */
 void
 ve_pcr_update(unsigned char *data, size_t dlen)
 {
-	if (pcr_md)
+	if (pcr_updating != 0 && pcr_md != NULL)
 		pcr_md->update(&pcr_ctx.vtable, data, dlen);
 }
 
diff --git a/lib/libsecureboot/verify_file.c b/lib/libsecureboot/verify_file.c
index 00822aa480d5d..e8b00451133ff 100644
--- a/lib/libsecureboot/verify_file.c
+++ b/lib/libsecureboot/verify_file.c
@@ -340,6 +340,14 @@ verify_file(int fd, const char *filename, off_t off, int severity)
 	if (rc != VE_FINGERPRINT_WRONG && loaded_manifests) {
 		if (severity <= VE_GUESS)
 			severity = severity_guess(filename);
+#ifdef VE_PCR_SUPPORT
+		/*
+		 * Only update pcr with things that must verify
+		 * these tend to be processed in a more deterministic
+		 * order, which makes our pseudo pcr more useful.
+		 */
+		ve_pcr_updating_set((severity == VE_MUST));
+#endif
 		if ((rc = verify_fd(fd, filename, off, &st)) >= 0) {
 			if (verbose || severity > VE_WANT) {
 #if defined(VE_DEBUG_LEVEL) && VE_DEBUG_LEVEL > 0
diff --git a/lib/libutil/pw_util.3 b/lib/libutil/pw_util.3
index ad5dcaaeccc30..2ebfa3915294d 100644
--- a/lib/libutil/pw_util.3
+++ b/lib/libutil/pw_util.3
@@ -58,7 +58,7 @@
 .Ft void
 .Fn pw_fini "void"
 .Ft int
-.Fn pw_init "const char *dir" const char *master"
+.Fn pw_init "const char *dir" "const char *master"
 .Ft void
 .Fn pw_initpwd "struct passwd *pw"
 .Ft "char *"
diff --git a/lib/msun/tests/cexp_test.c b/lib/msun/tests/cexp_test.c
index 5505849fab650..8e342f8e00705 100644
--- a/lib/msun/tests/cexp_test.c
+++ b/lib/msun/tests/cexp_test.c
@@ -59,13 +59,21 @@ __FBSDID("$FreeBSD$");
  * XXX The volatile here is to avoid gcc's bogus constant folding and work
  *     around the lack of support for the FENV_ACCESS pragma.
  */
-#define	test(func, z, result, exceptmask, excepts, checksign)	do {	\
+#define	test_t(type, func, z, result, exceptmask, excepts, checksign)	\
+do {									\
 	volatile long double complex _d = z;				\
+	volatile type complex _r = result;				\
 	assert(feclearexcept(FE_ALL_EXCEPT) == 0);			\
-	assert(cfpequal_cs((func)(_d), (result), (checksign)));		\
+	assert(cfpequal_cs((func)(_d), (_r), (checksign)));		\
 	assert(((void)(func), fetestexcept(exceptmask) == (excepts)));	\
 } while (0)
 
+#define	test(func, z, result, exceptmask, excepts, checksign)		\
+	test_t(double, func, z, result, exceptmask, excepts, checksign)
+
+#define	test_f(func, z, result, exceptmask, excepts, checksign)		\
+	test_t(float, func, z, result, exceptmask, excepts, checksign)
+
 /* Test within a given tolerance. */
 #define	test_tol(func, z, result, tol)				do {	\
 	volatile long double complex _d = z;				\
@@ -76,7 +84,7 @@ __FBSDID("$FreeBSD$");
 /* Test all the functions that compute cexp(x). */
 #define	testall(x, result, exceptmask, excepts, checksign)	do {	\
 	test(cexp, x, result, exceptmask, excepts, checksign);		\
-	test(cexpf, x, result, exceptmask, excepts, checksign);		\
+	test_f(cexpf, x, result, exceptmask, excepts, checksign);	\
 } while (0)
 
 /*
@@ -198,10 +206,10 @@ test_reals(void)
 		test(cexp, CMPLXL(finites[i], -0.0),
 		     CMPLXL(exp(finites[i]), -0.0),
 		     FE_INVALID | FE_DIVBYZERO, 0, 1);
-		test(cexpf, CMPLXL(finites[i], 0.0),
+		test_f(cexpf, CMPLXL(finites[i], 0.0),
 		     CMPLXL(expf(finites[i]), 0.0),
 		     FE_INVALID | FE_DIVBYZERO, 0, 1);
-		test(cexpf, CMPLXL(finites[i], -0.0),
+		test_f(cexpf, CMPLXL(finites[i], -0.0),
 		     CMPLXL(expf(finites[i]), -0.0),
 		     FE_INVALID | FE_DIVBYZERO, 0, 1);
 	}
@@ -220,10 +228,10 @@ test_imaginaries(void)
 		test(cexp, CMPLXL(-0.0, finites[i]),
 		     CMPLXL(cos(finites[i]), sin(finites[i])),
 		     ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
-		test(cexpf, CMPLXL(0.0, finites[i]),
+		test_f(cexpf, CMPLXL(0.0, finites[i]),
 		     CMPLXL(cosf(finites[i]), sinf(finites[i])),
 		     ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
-		test(cexpf, CMPLXL(-0.0, finites[i]),
+		test_f(cexpf, CMPLXL(-0.0, finites[i]),
 		     CMPLXL(cosf(finites[i]), sinf(finites[i])),
 		     ALL_STD_EXCEPT & ~FE_INEXACT, 0, 1);
 	}
@@ -302,12 +310,8 @@ main(void)
 	test_inf();
 	printf("ok 3 - cexp inf\n");
 
-#if defined(__i386__)
-	printf("not ok 4 - cexp reals # TODO: PR # 191676 fails assertion on i386\n");
-#else
 	test_reals();
 	printf("ok 4 - cexp reals\n");
-#endif
 
 	test_imaginaries();
 	printf("ok 5 - cexp imaginaries\n");