Merge branch 'sysctl-next' of https://git.kernel.org/pub/scm/linux/kernel/git/sysctl/sysctl.git

1 files changed, 558 insertions, 876 deletions

diff --git a/tools/testing/selftests/sysctl/sysctl.sh b/tools/testing/selftests/sysctl/sysctl.sh
index b2d8bd9026a7..ad1ee0fccd7c 100755
--- a/tools/testing/selftests/sysctl/sysctl.sh
+++ b/tools/testing/selftests/sysctl/sysctl.sh
@@ -2,345 +2,239 @@
 # SPDX-License-Identifier: GPL-2.0-or-later OR copyleft-next-0.3.1
 # Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
 
-# This performs a series tests against the proc sysctl interface.
-
-# Kselftest framework requirement - SKIP code is 4.
-ksft_skip=4
-
-TEST_NAME="sysctl"
-TEST_DRIVER="test_${TEST_NAME}"
-TEST_DIR=$(dirname $0)
-TEST_FILE=$(mktemp)
-
-# This represents
-#
-# TEST_ID:TEST_COUNT:ENABLED:TARGET:SKIP_NO_TARGET
-#
-# TEST_ID: is the test id number
-# TEST_COUNT: number of times we should run the test
-# ENABLED: 1 if enabled, 0 otherwise
-# TARGET: test target file required on the test_sysctl module
-# SKIP_NO_TARGET: 1 skip if TARGET not there
-#                 0 run even though TARGET not there
-#
-# Once these are enabled please leave them as-is. Write your own test,
-# we have tons of space.
-ALL_TESTS="0001:1:1:int_0001:1"
-ALL_TESTS="$ALL_TESTS 0002:1:1:string_0001:1"
-ALL_TESTS="$ALL_TESTS 0003:1:1:int_0002:1"
-ALL_TESTS="$ALL_TESTS 0004:1:1:uint_0001:1"
-ALL_TESTS="$ALL_TESTS 0005:3:1:int_0003:1"
-ALL_TESTS="$ALL_TESTS 0006:50:1:bitmap_0001:1"
-ALL_TESTS="$ALL_TESTS 0007:1:1:boot_int:1"
-ALL_TESTS="$ALL_TESTS 0008:1:1:match_int:1"
-ALL_TESTS="$ALL_TESTS 0009:1:1:unregister_error:0"
-ALL_TESTS="$ALL_TESTS 0010:1:1:mnt/mnt_error:0"
-ALL_TESTS="$ALL_TESTS 0011:1:1:empty_add:0"
-ALL_TESTS="$ALL_TESTS 0012:1:1:u8_valid:0"
-
-function allow_user_defaults()
+# Reduce noise by disabling "unreachable" check.
+# shellcheck disable=SC2317
+
+# This performs a series of tests against the proc sysctl interface.
+
+DIR="$(dirname "$(readlink -f "$0")")"
+source "${DIR}"/../kselftest/ktap_helpers.sh
+
+TEST_DRIVER="test_sysctl"
+
+assert_write_rejected() # <file> <value>
 {
-	if [ -z $DIR ]; then
-		DIR="/sys/module/test_sysctl/"
-	fi
-	if [ -z $DEFAULT_NUM_TESTS ]; then
-		DEFAULT_NUM_TESTS=50
-	fi
-	if [ -z $SYSCTL ]; then
-		SYSCTL="/proc/sys/debug/test_sysctl"
-	fi
-	if [ -z $PROD_SYSCTL ]; then
-		PROD_SYSCTL="/proc/sys"
-	fi
-	if [ -z $WRITES_STRICT ]; then
-		WRITES_STRICT="${PROD_SYSCTL}/kernel/sysctl_writes_strict"
+	local file=$1 val=$2
+	if printf '%s' "$val" > "$file" 2>/dev/null; then
+		ktap_print_msg "$file: write of '$val' succeeded, expected rejection"
+		return 1
 	fi
+	return 0
 }
 
-function check_production_sysctl_writes_strict()
+assert_content() # <file> <want-file>
 {
-	echo -n "Checking production write strict setting ... "
-	if [ ! -e ${WRITES_STRICT} ]; then
-		echo "FAIL, but skip in case of old kernel" >&2
-	else
-		old_strict=$(cat ${WRITES_STRICT})
-		if [ "$old_strict" = "1" ]; then
-			echo "OK"
-		else
-			echo "FAIL, strict value is 0 but force to 1 to continue" >&2
-			echo "1" > ${WRITES_STRICT}
-		fi
-	fi
-
-	if [ -z $PAGE_SIZE ]; then
-		PAGE_SIZE=$(getconf PAGESIZE)
-	fi
-	if [ -z $MAX_DIGITS ]; then
-		MAX_DIGITS=$(($PAGE_SIZE/8))
-	fi
-	if [ -z $INT_MAX ]; then
-		INT_MAX=$(getconf INT_MAX)
-	fi
-	if [ -z $UINT_MAX ]; then
-		UINT_MAX=$(getconf UINT_MAX)
+	local file=$1 want_file=$2 got
+	got=$(cat "$file")
+	if [ "$got" == "$want_file" ]; then
+		return 0
 	fi
+	ktap_print_msg "$file: got '$got', want '$want_file'"
+	return 1
 }
 
-test_reqs()
+# compare ignoring whitespaces
+assert_content_loose() # <file> <want-file>
 {
-	uid=$(id -u)
-	if [ $uid -ne 0 ]; then
-		echo $msg must be run as root >&2
-		exit $ksft_skip
+	local file=$1 want_file=$2
+	if echo "$want_file" | diff -q -w -u - "$file" > /dev/null; then
+		return 0
 	fi
+	ktap_print_msg "$file: content does not match '$want_file' (whitespace-insensitive)"
+	return 1
+}
 
-	if ! which perl 2> /dev/null > /dev/null; then
-		echo "$0: You need perl installed"
-		exit $ksft_skip
-	fi
-	if ! which getconf 2> /dev/null > /dev/null; then
-		echo "$0: You need getconf installed"
-		exit $ksft_skip
-	fi
-	if ! which diff 2> /dev/null > /dev/null; then
-		echo "$0: You need diff installed"
-		exit $ksft_skip
+# For checks where writes must NOT take effect
+assert_content_rejected() # <file> <bad>
+{
+	local file=$1 bad=$2
+	if echo "$bad" | diff -q -w -u - "$file" > /dev/null; then
+		ktap_print_msg "$file: unexpectedly now holds rejected value '$bad'"
+		return 1
 	fi
+	return 0
 }
 
-function load_req_mod()
+# proc files get read a page at a time, which can confuse diff resulting in
+# incorrect results. Use a temp file to diff.
+assert_diff_proc_file() # <file> <want-file>
 {
-	if [ ! -d $SYSCTL ]; then
-		if ! modprobe -q -n $TEST_DRIVER; then
-			echo "$0: module $TEST_DRIVER not found [SKIP]"
-			echo "You must set CONFIG_TEST_SYSCTL=m in your kernel" >&2
-			exit $ksft_skip
-		fi
-		modprobe $TEST_DRIVER
-		if [ $? -ne 0 ]; then
-			echo "$0: modprobe $TEST_DRIVER failed."
-			exit
-		fi
+	local file=$1 want_file=$2 tmp
+	tmp=$(mktemp)
+	cat "$file" > "$tmp"
+
+	if diff -w -q "$tmp" "$want_file" > /dev/null; then
+		rm -f "$tmp"
+		return 0
 	fi
+	ktap_print_msg "$file: content does not match expected file $want_file"
+	rm -f "$tmp"
+	return 1
 }
 
-reset_vals()
+# Verify that an erroneous update fails and does not change the baseline.
+assert_no_partial_update() # <file> <baseline> <bad-value>
 {
-	VAL=""
-	TRIGGER=$(basename ${TARGET})
-	case "$TRIGGER" in
-		int_0001)
-			VAL="60"
-			;;
-		int_0002)
-			VAL="1"
-			;;
-		uint_0001)
-			VAL="314"
-			;;
-		string_0001)
-			VAL="(none)"
-			;;
-		bitmap_0001)
-			VAL=""
-			;;
-		*)
-			;;
-	esac
-	echo -n $VAL > $TARGET
+	local file=$1 baseline=$2 bad=$3
+
+	printf '%s' "$baseline" > "$file"
+	assert_write_rejected "$file" "$bad" || return 1
+	assert_content_loose "$file" "$baseline"
 }
 
-set_orig()
+assert_grep() # <file> <pattern> - <pattern> must appear in <file>
 {
-	if [ ! -z $TARGET ] && [ ! -z $ORIG ]; then
-		if [ -f ${TARGET} ]; then
-			echo "${ORIG}" > "${TARGET}"
-		fi
+	local file=$1 pattern=$2
+	if grep -q "$pattern" "$file"; then
+		return 0
 	fi
+	ktap_print_msg "$file: pattern '$pattern' not found"
+	return 1
 }
 
-set_test()
+assert_grep_absent() # <file> <pattern> - <pattern> must NOT appear
 {
-	echo "${TEST_STR}" > "${TARGET}"
+	local file=$1 pattern=$2
+	if ! grep -q "$pattern" "$file"; then
+		return 0
+	fi
+	ktap_print_msg "$file: pattern '$pattern' unexpectedly found"
+	return 1
 }
 
-verify()
+assert_dmesg_count() # <pattern> <want-count>
 {
-	local seen
-	seen=$(cat "$1")
-	if [ "${seen}" != "${TEST_STR}" ]; then
-		return 1
+	local pattern=$1 want=$2 got
+	got=$(dmesg | grep -c "$pattern")
+	if [ "$got" -eq "$want" ]; then
+		return 0
 	fi
-	return 0
+	ktap_print_msg "dmesg: pattern '$pattern' seen $got times, want $want"
+	return 1
 }
 
-# proc files get read a page at a time, which can confuse diff,
-# and get you incorrect results on proc files with long data. To use
-# diff against them you must first extract the output to a file, and
-# then compare against that file.
-verify_diff_proc_file()
+# write <str> through dd in <bs>-sized chunks
+write_in_chunks()  # <file> <str> <bs>
 {
-	TMP_DUMP_FILE=$(mktemp)
-	cat $1 > $TMP_DUMP_FILE
+	local file=$1 str=$2 bs=$3
+	printf '%s' "$str" | dd of="$file" bs="$bs" 2>/dev/null
+}
 
-	if ! diff -w -q $TMP_DUMP_FILE $2; then
-		return 1
+# write <str> through dd in <bs>-sized chunks. seeking <seek> blocks of size
+# <bs> into the output. skipping <skip> blocks of size <bs> from the input.
+# Unsyncrhonized when skip is not passed.
+write_at_offset()  # <file> <str> <bs> <seek> [skip]
+{
+	local file=$1 str=$2 bs=$3 seek=$4 skip=${5:-}
+	if [ -n "$skip" ]; then
+		printf '%s' "$str" | dd of="$file" bs="$bs" seek="$seek" skip="$skip" 2>/dev/null
 	else
-		return 0
+		printf '%s' "$str" | dd of="$file" bs="$bs" seek="$seek" 2>/dev/null
 	fi
 }
 
-verify_diff_w()
+# pad (prefix) <str> with <pad> 'A' characters, then write it all to <file>
+# with dd block size <bs> (defaults to <pad>).
+write_overlong()  # <file> <pad> <str> [bs]
 {
-	echo "$TEST_STR" | diff -q -w -u - $1 > /dev/null
-	return $?
+	local file=$1 pad=$2 str=$3 bs=$4 p
+	: "${bs:=$pad}"
+
+	# save a string with $pad spaces in $p
+	printf -v p '%*s' "$pad" ''
+	# replace " " with "A"
+	printf '%s%s' "${p// /A}" "$str" | dd of="$file" bs="$bs" 2>/dev/null
 }
 
-test_rc()
+# pad (prefix) <str> with <pad> ASCII spaces, then write with default block size.
+write_padded_digits()  # <file> <pad> <val>
 {
-	if [[ $rc != 0 ]]; then
-		echo "Failed test, return value: $rc" >&2
-		exit $rc
-	fi
+	local file=$1 pad=$2 val=$3 p
+	printf -v p '%*s' "$pad" ''
+	printf '%s%s' "$p" "$val" | dd of="$file" 2>/dev/null
 }
 
-test_finish()
+test_int_array_writes()
 {
-	set_orig
-	rm -f "${TEST_FILE}"
+	local t="${SYSCTL}/int_0003"
+	local limit
 
-	if [ ! -z ${old_strict} ]; then
-		echo ${old_strict} > ${WRITES_STRICT}
-	fi
-	exit $rc
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
+
+	printf '%s' "4 3 2 1" > "$t"
+	assert_content_loose "$t" "4 3 2 1" || RET=$KSFT_FAIL
+
+	# Skipping trailing elements leaves them intact
+	printf '%s' "100 101" > "$t"
+	assert_content_loose "$t" "100 101 2 1" || RET=$KSFT_FAIL
+
+	# Even for an int array, a single write is still capped at MAX_DIGITS
+	# (PAGE_SIZE/8) bytes; check right at, and just past, that boundary.
+	# Carries on the state from the writes above.
+	limit=$((MAX_DIGITS - 1))
+	write_padded_digits "$t" "$limit" "9"
+	assert_content_loose "$t" "9 101 2 1" || RET=$KSFT_FAIL
+
+	limit=$((MAX_DIGITS))
+	write_padded_digits "$t" "$limit" "7"
+	assert_content_rejected "$t" "7 101 2 1" || RET=$KSFT_FAIL
 }
 
-run_numerictests()
+test_int_array_no_partial_update()
 {
-	echo "== Testing sysctl behavior against ${TARGET} =="
+	local t="${SYSCTL}/int_0003"
 
-	rc=0
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-	echo -n "Writing test file ... "
-	echo "${TEST_STR}" > "${TEST_FILE}"
-	if ! verify "${TEST_FILE}"; then
-		echo "FAIL" >&2
-		exit 1
-	else
-		echo "OK"
-	fi
+	# bad 3rd element (not a number)
+	assert_no_partial_update "$t" "1 2 3 4" "10 20 abc 40" || RET=$KSFT_FAIL
 
-	echo -n "Checking sysctl is not set to test value ... "
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		exit 1
-	else
-		echo "OK"
-	fi
+	# bad 3rd element (overflows int)
+	assert_no_partial_update "$t" "1 2 3 4" "10 20 $((INT_MAX + 1)) 40" || RET=$KSFT_FAIL
 
-	echo -n "Writing sysctl from shell ... "
-	set_test
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		exit 1
-	else
-		echo "OK"
-	fi
+	# bad 1st element
+	assert_no_partial_update "$t" "1 2 3 4" "abc 20 30 40" || RET=$KSFT_FAIL
+}
 
-	echo -n "Resetting sysctl to original value ... "
-	set_orig
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		exit 1
-	else
-		echo "OK"
-	fi
+# Exercise the write patterns
+assert_write_patterns()  # <file> <baseline> <val>
+{
+	local file=$1 baseline=$2 val=$3 status=0
 
-	# Now that we've validated the sanity of "set_test" and "set_orig",
-	# we can use those functions to set starting states before running
-	# specific behavioral tests.
+	printf '%s' "$val" > "$file"
+	assert_content "$file" "$val" || status=1
+	printf '%s' "$baseline" > "$file"
+	assert_content "$file" "$baseline" || status=1
 
-	echo -n "Writing entire sysctl in single write ... "
-	set_orig
-	dd if="${TEST_FILE}" of="${TARGET}" bs=4096 2>/dev/null
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	printf '%s' "$baseline" > "$file"
+	write_in_chunks "$file" "$val" 4096
+	assert_content "$file" "$val" || status=1
 
-	echo -n "Writing middle of sysctl after synchronized seek ... "
-	set_test
-	dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 skip=1 2>/dev/null
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	printf '%s' "$val" > "$file"
+	write_at_offset "$file" "$val" 1 1 1
+	assert_content "$file" "$val" || status=1
 
-	echo -n "Writing beyond end of sysctl ... "
-	set_orig
-	dd if="${TEST_FILE}" of="${TARGET}" bs=20 seek=2 2>/dev/null
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	printf '%s' "$baseline" > "$file"
+	write_at_offset "$file" "$val" 20 2
+	assert_content_rejected "$file" "$val" || status=1
 
-	echo -n "Writing sysctl with multiple long writes ... "
-	set_orig
-	(perl -e 'print "A" x 50;'; echo "${TEST_STR}") | \
-		dd of="${TARGET}" bs=50 2>/dev/null
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-}
+	printf '%s' "$baseline" > "$file"
+	write_overlong "$file" 50 "$val"
+	assert_content_rejected "$file" "$val" || status=1
 
-check_failure()
-{
-	echo -n "Testing that $1 fails as expected ... "
-	reset_vals
-	TEST_STR="$1"
-	orig="$(cat $TARGET)"
-	echo -n "$TEST_STR" > $TARGET 2> /dev/null
-
-	# write should fail and $TARGET should retain its original value
-	if [ $? = 0 ] || [ "$(cat $TARGET)" != "$orig" ]; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	return "$status"
 }
 
-run_wideint_tests()
+# None of these fit in 32 bits, so writing them to an int/uint sysctl must fail
+assert_wideint_writes_rejected()  # <file> <baseline>
 {
-	# sysctl conversion functions receive a boolean sign and ulong
-	# magnitude; here we list the magnitudes we want to test (each of
-	# which will be tested in both positive and negative forms).  Since
-	# none of these values fit in 32 bits, writing them to an int- or
-	# uint-typed sysctl should fail.
+	local file=$1 baseline=$2 sign mag status=0
 	local magnitudes=(
-		# common boundary-condition values (zero, +1, -1, INT_MIN,
-		# and INT_MAX respectively) if truncated to lower 32 bits
-		# (potential for being falsely deemed in range)
 		0x0000000100000000
 		0x0000000100000001
 		0x00000001ffffffff
 		0x0000000180000000
 		0x000000017fffffff
-
-		# these look like negatives, but without a leading '-' are
-		# actually large positives (should be rejected as above
-		# despite being zero/+1/-1/INT_MIN/INT_MAX in the lower 32)
 		0xffffffff00000000
 		0xffffffff00000001
 		0xffffffffffffffff
@@ -350,750 +244,538 @@ run_wideint_tests()
 
 	for sign in '' '-'; do
 		for mag in "${magnitudes[@]}"; do
-			check_failure "${sign}${mag}"
+			assert_no_partial_update "$file" "$baseline" "${sign}${mag}" || status=1
 		done
 	done
+	return "$status"
 }
 
-# Your test must accept digits 3 and 4 to use this
-run_limit_digit()
+# A single write is capped at MAX_DIGITS (PAGE_SIZE/8) bytes; check that
+# leading whitespace up to that limit is ignored, and that PAGE_SIZE of
+# leading whitespace pushes the value past the limit and fails.
+assert_digit_limit()  # <file> <baseline>
 {
-	echo -n "Checking ignoring spaces up to PAGE_SIZE works on write ... "
-	reset_vals
+	local file=$1 baseline=$2 status=0
 
-	LIMIT=$((MAX_DIGITS -1))
-	TEST_STR="3"
-	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
-		dd of="${TARGET}" 2>/dev/null
+	printf '%s' "$baseline" > "$file"
+	write_padded_digits "$file" "$((MAX_DIGITS - 1))" "3"
+	assert_content "$file" "3" || status=1
 
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-
-	echo -n "Checking passing PAGE_SIZE of spaces fails on write ... "
-	reset_vals
-
-	LIMIT=$((MAX_DIGITS))
-	TEST_STR="4"
-	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
-		dd of="${TARGET}" 2>/dev/null
+	printf '%s' "$baseline" > "$file"
+	write_padded_digits "$file" "$MAX_DIGITS" "4"
+	assert_content_rejected "$file" "4" || status=1
 
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	return "$status"
 }
 
-# You are using an int
-run_limit_digit_int()
+# proc_dointvec()-specific range checks: INT_MAX must be accepted, INT_MAX+1
+# must be rejected, and negative values must be accepted.
+assert_int_range()  # <file> <baseline>
 {
-	echo -n "Testing INT_MAX works ... "
-	reset_vals
-	TEST_STR="$INT_MAX"
-	echo -n $TEST_STR > $TARGET
-
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	local file=$1 baseline=$2 status=0
 
-	echo -n "Testing INT_MAX + 1 will fail as expected ... "
-	reset_vals
-	let TEST_STR=$INT_MAX+1
-	echo -n $TEST_STR > $TARGET 2> /dev/null
+	printf '%s' "$baseline" > "$file"
+	printf '%s' "$INT_MAX" > "$file"
+	assert_content "$file" "$INT_MAX" || status=1
 
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-
-	echo -n "Testing negative values will work as expected ... "
-	reset_vals
-	TEST_STR="-3"
-	echo -n $TEST_STR > $TARGET 2> /dev/null
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-}
+	assert_no_partial_update "$file" "$baseline" "$((INT_MAX + 1))" || status=1
 
-# You used an int array
-run_limit_digit_int_array()
-{
-	echo -n "Testing array works as expected ... "
-	TEST_STR="4 3 2 1"
-	echo -n $TEST_STR > $TARGET
+	printf '%s' "$baseline" > "$file"
+	printf '%s' "-3" > "$file" 2>/dev/null
+	assert_content "$file" "-3" || status=1
 
-	if ! verify_diff_w "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-
-	echo -n "Testing skipping trailing array elements works ... "
-	# Do not reset_vals, carry on the values from the last test.
-	# If we only echo in two digits the last two are left intact
-	TEST_STR="100 101"
-	echo -n $TEST_STR > $TARGET
-	# After we echo in, to help diff we need to set on TEST_STR what
-	# we expect the result to be.
-	TEST_STR="100 101 2 1"
-
-	if ! verify_diff_w "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-
-	echo -n "Testing PAGE_SIZE limit on array works ... "
-	# Do not reset_vals, carry on the values from the last test.
-	# Even if you use an int array, you are still restricted to
-	# MAX_DIGITS, this is a known limitation. Test limit works.
-	LIMIT=$((MAX_DIGITS -1))
-	TEST_STR="9"
-	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
-		dd of="${TARGET}" 2>/dev/null
-
-	TEST_STR="9 101 2 1"
-	if ! verify_diff_w "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
-
-	echo -n "Testing exceeding PAGE_SIZE limit fails as expected ... "
-	# Do not reset_vals, carry on the values from the last test.
-	# Now go over limit.
-	LIMIT=$((MAX_DIGITS))
-	TEST_STR="7"
-	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
-		dd of="${TARGET}" 2>/dev/null
-
-	TEST_STR="7 101 2 1"
-	if verify_diff_w "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	return "$status"
 }
 
-# You are using an unsigned int
-run_limit_digit_uint()
+# proc_douintvec()-specific range checks: UINT_MAX must be accepted,
+# UINT_MAX+1 must be rejected, and negative values must be rejected too.
+assert_uint_range()  # <file> <baseline>
 {
-	echo -n "Testing UINT_MAX works ... "
-	reset_vals
-	TEST_STR="$UINT_MAX"
-	echo -n $TEST_STR > $TARGET
-
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	local file=$1 baseline=$2 status=0
 
-	echo -n "Testing UINT_MAX + 1 will fail as expected ... "
-	reset_vals
-	TEST_STR=$(($UINT_MAX+1))
-	echo -n $TEST_STR > $TARGET 2> /dev/null
+	printf '%s' "$baseline" > "$file"
+	printf '%s' "$UINT_MAX" > "$file"
+	assert_content "$file" "$UINT_MAX" || status=1
 
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+	assert_no_partial_update "$file" "$baseline" "$((UINT_MAX + 1))" || status=1
+	assert_no_partial_update "$file" "$baseline" "-3" || status=1
 
-	echo -n "Testing negative values will not work as expected ... "
-	reset_vals
-	TEST_STR="-3"
-	echo -n $TEST_STR > $TARGET 2> /dev/null
+	return "$status"
+}
 
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
-	test_rc
+test_int_minmax()
+{
+	local t="${SYSCTL}/int_0001"
+	local baseline="60" val="61"
+
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
+
+	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
+	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
+	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
 }
 
-run_stringtests()
+test_int_plain()
 {
-	echo -n "Writing entire sysctl in short writes ... "
-	set_orig
-	dd if="${TEST_FILE}" of="${TARGET}" bs=1 2>/dev/null
-	if ! verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	local t="${SYSCTL}/int_0002"
+	local baseline="1" val="2"
 
-	echo -n "Writing middle of sysctl after unsynchronized seek ... "
-	set_test
-	dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 2>/dev/null
-	if verify "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-	echo -n "Checking sysctl maxlen is at least $MAXLEN ... "
-	set_orig
-	perl -e 'print "A" x ('"${MAXLEN}"'-2), "B";' | \
-		dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
-	if ! grep -q B "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
+	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
+	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
+	assert_int_range "$t" "$baseline" || RET=$KSFT_FAIL
+}
 
-	echo -n "Checking sysctl keeps original string on overflow append ... "
-	set_orig
-	perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
-		dd of="${TARGET}" bs=$(( MAXLEN - 1 )) 2>/dev/null
-	if grep -q B "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+# The jiffies converters report the sign separately from the magnitude, so a
+# negative value must survive the round trip through the converter.  Each
+# value below is chosen to convert exactly at every CONFIG_HZ.
+test_int_jiffies_negative()
+{
+	local t="${SYSCTL}/int_jiffies"
+	local m="${SYSCTL}/int_ms_jiffies"
+	local u="${SYSCTL}/int_userhz_jiffies"
 
-	echo -n "Checking sysctl stays NULL terminated on write ... "
-	set_orig
-	perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
-		dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
-	if grep -q B "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	[[ -f "$t" && -f "$m" && -f "$u" ]] || { RET=$KSFT_SKIP; return; }
 
-	echo -n "Checking sysctl stays NULL terminated on overwrite ... "
-	set_orig
-	perl -e 'print "A" x ('"${MAXLEN}"'-1), "BB";' | \
-		dd of="${TARGET}" bs=$(( $MAXLEN + 1 )) 2>/dev/null
-	if grep -q B "${TARGET}"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-	fi
+	printf '%s' "-1" > "$t"
+	assert_content "$t" "-1" || RET=$KSFT_FAIL
+	printf '%s' "-1000" > "$m"
+	assert_content "$m" "-1000" || RET=$KSFT_FAIL
+	printf '%s' "-100" > "$u"
+	assert_content "$u" "-100" || RET=$KSFT_FAIL
 
-	test_rc
+	# The positive path was never broken; keep it covered.
+	printf '%s' "1" > "$t"
+	assert_content "$t" "1" || RET=$KSFT_FAIL
 }
 
-target_exists()
+test_uint_plain()
 {
-	TARGET="${SYSCTL}/$1"
-	TEST_ID="$2"
+	local t="${SYSCTL}/uint_0001"
+	local baseline="314" val="315"
 
-	if [ ! -f ${TARGET} ] ; then
-		return 0
-	fi
-	return 1
-}
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-run_bitmaptest() {
-	# Total length of bitmaps string to use, a bit under
-	# the maximum input size of the test node
-	LENGTH=$((RANDOM % 65000))
+	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
+	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
+	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
+	assert_uint_range "$t" "$baseline" || RET=$KSFT_FAIL
+}
 
-	# First bit to set
-	BIT=$((RANDOM % 1024))
+# proc_dostring()-specific write patterns
+assert_string_write_patterns()  # <file> <baseline> <val> <maxlen>
+{
+	local file=$1 baseline=$2 val=$3 maxlen=$4 status=0
 
-	# String containing our list of bits to set
-	TEST_STR=$BIT
+	printf '%s' "$baseline" > "$file"
+	write_in_chunks "$file" "$val" 1
+	assert_content "$file" "$val" || status=1
 
-	# build up the string
-	while [ "${#TEST_STR}" -le "$LENGTH" ]; do
-		# Make sure next entry is discontiguous,
-		# skip ahead at least 2
-		BIT=$((BIT + $((2 + RANDOM % 10))))
+	printf '%s' "$val" > "$file"
+	write_at_offset "$file" "$val" 1 1
+	assert_content_rejected "$file" "$val" || status=1
 
-		# Add new bit to the list
-		TEST_STR="${TEST_STR},${BIT}"
+	# sysctl maxlen is at least $maxlen
+	printf '%s' "$baseline" > "$file"
+	write_overlong "$file" "$((maxlen - 2))" "B" "$maxlen"
+	assert_grep "$file" "B" || status=1
 
-		# Randomly make it a range
-		if [ "$((RANDOM % 2))" -eq "1" ]; then
-			RANGE_END=$((BIT + $((1 + RANDOM % 10))))
-			TEST_STR="${TEST_STR}-${RANGE_END}"
-			BIT=$RANGE_END
-		fi
-	done
+	# keep original string on overflow append
+	printf '%s' "$baseline" > "$file"
+	write_overlong "$file" "$((maxlen - 1))" "B" "$((maxlen - 1))"
+	assert_grep_absent "$file" "B" || status=1
 
-	echo -n "Checking bitmap handler ... "
-	TEST_FILE=$(mktemp)
-	echo -n "$TEST_STR" > $TEST_FILE
+	# sysctl stays NULL terminated on write
+	printf '%s' "$baseline" > "$file"
+	write_overlong "$file" "$((maxlen - 1))" "B" "$maxlen"
+	assert_grep_absent "$file" "B" || status=1
 
-	cat $TEST_FILE > $TARGET 2> /dev/null
-	if [ $? -ne 0 ]; then
-		echo "FAIL" >&2
-		rc=1
-		test_rc
-	fi
+	# sysctl stays NULL terminated on overwrite
+	printf '%s' "$baseline" > "$file"
+	write_overlong "$file" "$((maxlen - 1))" "BB" "$((maxlen + 1))"
+	assert_grep_absent "$file" "B" || status=1
 
-	if ! verify_diff_proc_file "$TARGET" "$TEST_FILE"; then
-		echo "FAIL" >&2
-		rc=1
-	else
-		echo "OK"
-		rc=0
-	fi
-	test_rc
+	return "$status"
 }
 
-sysctl_test_0001()
+test_string_dostring()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0001)"
-	reset_vals
-	ORIG=$(cat "${TARGET}")
-	TEST_STR=$(( $ORIG + 1 ))
-
-	run_numerictests
-	run_wideint_tests
-	run_limit_digit
-}
+	local t="${SYSCTL}/string_0001"
+	local baseline="(none)" val="Testing sysctl" maxlen=65
 
-sysctl_test_0002()
-{
-	TARGET="${SYSCTL}/$(get_test_target 0002)"
-	reset_vals
-	ORIG=$(cat "${TARGET}")
-	TEST_STR="Testing sysctl"
-	# Only string sysctls support seeking/appending.
-	MAXLEN=65
-
-	run_numerictests
-	run_stringtests
-}
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-sysctl_test_0003()
-{
-	TARGET="${SYSCTL}/$(get_test_target 0003)"
-	reset_vals
-	ORIG=$(cat "${TARGET}")
-	TEST_STR=$(( $ORIG + 1 ))
-
-	run_numerictests
-	run_wideint_tests
-	run_limit_digit
-	run_limit_digit_int
+	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
+	assert_string_write_patterns "$t" "$baseline" "$val" "$maxlen" || RET=$KSFT_FAIL
 }
 
-sysctl_test_0004()
+# Emit a random sysctl bit map
+random_bitmap_spec()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0004)"
-	reset_vals
-	ORIG=$(cat "${TARGET}")
-	TEST_STR=$(( $ORIG + 1 ))
-
-	run_numerictests
-	run_wideint_tests
-	run_limit_digit
-	run_limit_digit_uint
-}
+	local length=$((RANDOM % 65000))
+	local bit=$((RANDOM % 1024))
+	local spec=$bit
+	local range_end
 
-sysctl_test_0005()
-{
-	TARGET="${SYSCTL}/$(get_test_target 0005)"
-	reset_vals
-	ORIG=$(cat "${TARGET}")
+	while [ "${#spec}" -le "$length" ]; do
+		# Keep entries discontiguous, skip ahead by at least 2.
+		bit=$((bit + 2 + RANDOM % 10))
+		spec="${spec},${bit}"
 
-	run_limit_digit_int_array
-}
+		if [ "$((RANDOM % 2))" -eq 1 ]; then
+			range_end=$((bit + 1 + RANDOM % 10))
+			spec="${spec}-${range_end}"
+			bit=$range_end
+		fi
+	done
 
-sysctl_test_0006()
-{
-	TARGET="${SYSCTL}/$(get_test_target 0006)"
-	reset_vals
-	ORIG=""
-	run_bitmaptest
+	echo -n "$spec"
 }
 
-sysctl_test_0007()
+# Do *not* prefix with "test_". All autogenerate bitmap tests call this helper
+bitmap_range_check_once()  # <iter>
 {
-	TARGET="${SYSCTL}/$(get_test_target 0007)"
-	echo -n "Testing if $TARGET is set to 1 ... "
-
-	if [ ! -f $TARGET ]; then
-		echo -e "SKIPPING\n$TARGET is not present"
-		return $ksft_skip
-	fi
-
-	if [ -d $DIR ]; then
-		echo -e "SKIPPING\nTest only possible if sysctl_test is built-in, not module:"
-		cat $TEST_DIR/config >&2
-		return $ksft_skip
-	fi
+	local t="${SYSCTL}/bitmap_0001"
+	local spec_file seed
 
-	ORIG=$(cat "${TARGET}")
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-	if [ x$ORIG = "x1" ]; then
-		echo "OK"
-		return 0
-	fi
+	seed=$((BITMAP_SEED + $1))
+	RANDOM=$seed
 
-	if [ ! -f /proc/cmdline ]; then
-		echo -e "SKIPPING\nThere is no /proc/cmdline to check for parameter"
-		return $ksft_skip
-	fi
+	spec_file=$(mktemp)
+	random_bitmap_spec > "$spec_file"
 
-	FOUND=$(grep -c "sysctl[./]debug[./]test_sysctl[./]boot_int=1" /proc/cmdline)
-	if [ $FOUND = "1" ]; then
-		echo -e "FAIL\nKernel param found but $TARGET is not 1." >&2
-		rc=1
-		test_rc
+	if ! cat "$spec_file" > "$t" 2>/dev/null; then
+		ktap_print_msg "$t: write of random bitmap spec rejected (seed $seed)"
+		RET=$KSFT_FAIL
+	elif ! assert_diff_proc_file "$t" "$spec_file"; then
+		ktap_print_msg "$t: readback mismatch (seed $seed)"
+		RET=$KSFT_FAIL
 	fi
 
-	echo -e "SKIPPING\nExpected kernel parameter missing."
-	echo "Kernel must be booted with parameter: sysctl.debug.test_sysctl.boot_int=1"
-	return $ksft_skip
+	rm -f "$spec_file"
 }
 
-sysctl_test_0008()
+test_unregister_removes_dir()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0008)"
-	echo -n "Testing if $TARGET is matched in kernel ... "
+	local t="${SYSCTL}/unregister_error"
 
-	if [ ! -f $TARGET ]; then
-		echo -e "SKIPPING\n$TARGET is not present"
-		return $ksft_skip
+	if [[ -d "$t" ]]; then
+		ktap_print_msg "$t: directory still exists, expected it to be unregistered"
+		RET=$KSFT_FAIL
 	fi
+}
 
-	ORIG_VALUE=$(cat "${TARGET}")
+test_mount_point_error()
+{
+	local t="${SYSCTL}/mnt/mnt_error"
 
-	if [ $ORIG_VALUE -ne 1 ]; then
-		echo "FAIL" >&2
-		rc=1
-		test_rc
+	if [[ -d "$t" ]]; then
+		ktap_print_msg "$t: directory unexpectedly created"
+		RET=$KSFT_FAIL
 	fi
-
-	echo "OK"
-	return 0
 }
 
-sysctl_test_0009()
+test_empty_dir_registration()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0009)"
-	echo -n "Testing if $TARGET unregistered correctly ... "
-	if [ -d $TARGET ]; then
-		echo "FAIL" >&2
-		rc=1
-		test_rc
-	fi
+	local t="${SYSCTL}/empty_add"
 
-	echo "OK"
-	return 0
+	if [[ ! -d "$t" ]]; then
+		ktap_print_msg "$t: directory was not created"
+		RET=$KSFT_FAIL
+		return
+	fi
+	if [[ ! -d "$t/empty" ]]; then
+		ktap_print_msg "$t/empty: directory was not created"
+		RET=$KSFT_FAIL
+	fi
 }
 
-sysctl_test_0010()
+test_u8_range_check()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0010)"
-	echo -n "Testing that $TARGET was not created ... "
-	if [ -d $TARGET ]; then
-		echo "FAIL" >&2
-		rc=1
-		test_rc
+	local t="${SYSCTL}/u8_valid"
+
+	if [[ ! -f "$t" ]]; then
+		ktap_print_msg "$t: file was not created"
+		RET=$KSFT_FAIL
+		return
 	fi
 
-	echo "OK"
-	return 0
+	assert_dmesg_count "u8_over range value" 1 || RET=$KSFT_FAIL
+	assert_dmesg_count "u8_under range value" 1 || RET=$KSFT_FAIL
 }
 
-sysctl_test_0011()
+test_boot_param_int()
 {
-	TARGET="${SYSCTL}/$(get_test_target 0011)"
-	echo -n "Testing empty dir handling in ${TARGET} ... "
-	if [ ! -d ${TARGET} ]; then
-		echo -e "FAIL\nCould not create ${TARGET}" >&2
-		rc=1
-		test_rc
-	fi
+	local t="${SYSCTL}/boot_int"
+	local orig found
 
-	TARGET2="${TARGET}/empty"
-	if [ ! -d ${TARGET2} ]; then
-		echo -e "FAIL\nCould not create ${TARGET2}" >&2
-		rc=1
-		test_rc
-	fi
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-	echo "OK"
-	return 0
-}
+	# Boot cmdline params only apply when test_sysctl is built in, not
+	# loaded as a module.
+	if [[ -d "$MODULE_DIR" ]]; then
+		ktap_print_msg "$t: test only possible if test_sysctl is built-in, not a module"
+		RET=$KSFT_SKIP
+		return
+	fi
 
-sysctl_test_0012()
-{
-	TARGET="${SYSCTL}/$(get_test_target 0012)"
-	echo -n "Testing u8 range check in sysctl table check in ${TARGET} ... "
-	if [ ! -f ${TARGET} ]; then
-		echo -e "FAIL\nCould not create ${TARGET}" >&2
-		rc=1
-		test_rc
+	orig=$(cat "$t")
+	if [[ "$orig" == "1" ]]; then
+		return
 	fi
 
-	local u8over_msg=$(dmesg | grep "u8_over range value" | wc -l)
-	if [ ! ${u8over_msg} -eq 1 ]; then
-		echo -e "FAIL\nu8 overflow not detected" >&2
-		rc=1
-		test_rc
+	if [[ ! -f /proc/cmdline ]]; then
+		ktap_print_msg "$t: no /proc/cmdline to check for the boot parameter"
+		RET=$KSFT_SKIP
+		return
 	fi
 
-	local u8under_msg=$(dmesg | grep "u8_under range value" | wc -l)
-	if [ ! ${u8under_msg} -eq 1 ]; then
-		echo -e "FAIL\nu8 underflow not detected" >&2
-		rc=1
-		test_rc
+	found=$(grep -c "sysctl[./]debug[./]test_sysctl[./]boot_int=1" /proc/cmdline)
+	if [[ "$found" == "1" ]]; then
+		ktap_print_msg "$t: kernel param found on cmdline but value is not 1"
+		RET=$KSFT_FAIL
+		return
 	fi
 
-	echo "OK"
-	return 0
+	ktap_print_msg "$t: kernel not booted with sysctl.debug.test_sysctl.boot_int=1"
+	RET=$KSFT_SKIP
 }
 
-list_tests()
+test_sysctl_macro_match()
 {
-	echo "Test ID list:"
-	echo
-	echo "TEST_ID x NUM_TEST"
-	echo "TEST_ID:   Test ID"
-	echo "NUM_TESTS: Recommended number of times to run the test"
-	echo
-	echo "0001 x $(get_test_count 0001) - tests proc_dointvec_minmax()"
-	echo "0002 x $(get_test_count 0002) - tests proc_dostring()"
-	echo "0003 x $(get_test_count 0003) - tests proc_dointvec()"
-	echo "0004 x $(get_test_count 0004) - tests proc_douintvec()"
-	echo "0005 x $(get_test_count 0005) - tests proc_douintvec() array"
-	echo "0006 x $(get_test_count 0006) - tests proc_do_large_bitmap()"
-	echo "0007 x $(get_test_count 0007) - tests setting sysctl from kernel boot param"
-	echo "0008 x $(get_test_count 0008) - tests sysctl macro values match"
-	echo "0009 x $(get_test_count 0009) - tests sysct unregister"
-	echo "0010 x $(get_test_count 0010) - tests sysct mount point"
-	echo "0011 x $(get_test_count 0011) - tests empty directories"
-	echo "0012 x $(get_test_count 0012) - tests range check for u8 proc_handler"
-}
+	local t="${SYSCTL}/match_int"
 
-usage()
-{
-	NUM_TESTS=$(grep -o ' ' <<<"$ALL_TESTS" | grep -c .)
-	let NUM_TESTS=$NUM_TESTS+1
-	MAX_TEST=$(printf "%04d\n" $NUM_TESTS)
-	echo "Usage: $0 [ -t <4-number-digit> ] | [ -w <4-number-digit> ] |"
-	echo "		 [ -s <4-number-digit> ] | [ -c <4-number-digit> <test- count>"
-	echo "           [ all ] [ -h | --help ] [ -l ]"
-	echo ""
-	echo "Valid tests: 0001-$MAX_TEST"
-	echo ""
-	echo "    all     Runs all tests (default)"
-	echo "    -t      Run test ID the recommended number of times"
-	echo "    -w      Watch test ID run until it runs into an error"
-	echo "    -c      Run test ID once"
-	echo "    -s      Run test ID x test-count number of times"
-	echo "    -l      List all test ID list"
-	echo " -h|--help  Help"
-	echo
-	echo "If an error every occurs execution will immediately terminate."
-	echo "If you are adding a new test try using -w <test-ID> first to"
-	echo "make sure the test passes a series of tests."
-	echo
-	echo Example uses:
-	echo
-	echo "$TEST_NAME.sh            -- executes all tests"
-	echo "$TEST_NAME.sh -t 0002    -- Executes test ID 0002 the recommended number of times"
-	echo "$TEST_NAME.sh -w 0002    -- Watch test ID 0002 run until an error occurs"
-	echo "$TEST_NAME.sh -s 0002    -- Run test ID 0002 once"
-	echo "$TEST_NAME.sh -c 0002 3  -- Run test ID 0002 three times"
-	echo
-	list_tests
-	exit 1
-}
+	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
 
-function test_num()
-{
-	re='^[0-9]+$'
-	if ! [[ $1 =~ $re ]]; then
-		usage
-	fi
-}
-function remove_leading_zeros()
-{
-	echo $1 | sed 's/^0*//'
+	assert_content "$t" "1" || RET=$KSFT_FAIL
 }
 
-function get_test_count()
+run_one()
 {
-	test_num $1
-	awk_field=$(remove_leading_zeros $1)
-	TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
-	echo ${TEST_DATA} | awk -F":" '{print $2}'
-}
+	local name=$1
 
-function get_test_enabled()
-{
-	test_num $1
-	awk_field=$(remove_leading_zeros $1)
-	TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
-	echo ${TEST_DATA} | awk -F":" '{print $3}'
+	# Subshell: a test cannot leak vars/cwd/traps into the next one, and an
+	# accidental `exit` inside a test kills only its own subshell.
+	( RET=$KSFT_PASS; "$name"; exit $RET )
+
+	case $? in
+	"$KSFT_PASS") ktap_test_pass "$name" ;;
+	"$KSFT_SKIP") ktap_test_skip "$name" ;;
+	*)          ktap_test_fail "$name" ;;
+	esac
 }
 
-function get_test_target()
+usage()
 {
-	test_num $1
-	awk_field=$(remove_leading_zeros $1)
-	TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
-	echo ${TEST_DATA} | awk -F":" '{print $4}'
+	cat <<-EOF
+	Usage: $0 [-r N] [-l] [-t T] [-s N] [-h|--help]
+
+	Runs every auto-discovered test_* function. Setting SYSCTL_TESTS will
+	override the default and passing -t will override both env var and the
+	default.
+
+	    -r N          repeat selected tests N times (default 1)
+	    -l            list discovered tests
+	    -t T          space separated tests list. For example "test_1 test_2"
+	    -s N          base seed for the randomized bitmap iterations.
+	    -h, --help    help
+
+	    SYSCTL_TESTS='test_1 test_2' $0  run only the named tests
+	EOF
 }
 
-function get_test_skip_no_target()
+list_tests()
 {
-	test_num $1
-	awk_field=$(remove_leading_zeros $1)
-	TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
-	echo ${TEST_DATA} | awk -F":" '{print $5}'
+	echo "Discovered tests:"
+	local t
+	for t in $ALL_TESTS; do
+		echo "  $t"
+	done
 }
 
-function skip_test()
+check_reqs()
 {
-	TEST_ID=$1
-	TEST_TARGET=$2
-	if target_exists $TEST_TARGET $TEST_ID; then
-		TEST_SKIP=$(get_test_skip_no_target $TEST_ID)
-		if [[ $TEST_SKIP -eq "1" ]]; then
-			echo "Target $TEST_TARGET for test $TEST_ID does not exist ... SKIPPING"
-			return 0
-		fi
+	local uid
+	uid=$(id -u)
+
+	if [ "$uid" -ne 0 ]; then
+		ktap_skip_all "must be run as root"
+		exit "$KSFT_SKIP"
+	fi
+
+	if ! which getconf > /dev/null 2>&1; then
+		ktap_skip_all "$0: You need getconf installed"
+		exit "$KSFT_SKIP"
+	fi
+
+	if ! which diff > /dev/null 2>&1; then
+		ktap_skip_all "$0: You need diff installed"
+		exit "$KSFT_SKIP"
 	fi
-	return 1
 }
 
-function run_all_tests()
+check_args()  # <repeat> <selected> <seed>
 {
-	for i in $ALL_TESTS ; do
-		TEST_ID=${i%:*:*:*:*}
-		ENABLED=$(get_test_enabled $TEST_ID)
-		TEST_COUNT=$(get_test_count $TEST_ID)
-		TEST_TARGET=$(get_test_target $TEST_ID)
-
-		if [[ $ENABLED -eq "1" ]]; then
-			test_case $TEST_ID $TEST_COUNT $TEST_TARGET
+	local repeat_arg="$1"
+	local selected_arg="$2"
+	local seed_arg="$3"
+	local t
+
+	if [ -z "$selected_arg" ]; then
+		ktap_exit_fail_msg "no test selected"
+	fi
+
+	if ! [[ "$repeat_arg" =~ ^[0-9]+$ ]]; then
+		ktap_exit_fail_msg "repeat argument '$repeat_arg' is not a number"
+	fi
+
+	if ! [[ "$seed_arg" =~ ^[0-9]+$ ]]; then
+		ktap_exit_fail_msg "seed argument '$seed_arg' is not a number"
+	fi
+
+	for t in $selected_arg; do
+		if ! declare -F "$t" > /dev/null; then
+			ktap_exit_fail_msg "unknown selected test '$t'"
 		fi
 	done
 }
 
-function watch_log()
+allow_user_defaults()
 {
-	if [ $# -ne 3 ]; then
-		clear
+	if [ -z "${MODULE_DIR}" ]; then
+		MODULE_DIR="/sys/module/test_sysctl/"
+	fi
+	if [ -z "${SYSCTL}" ]; then
+		SYSCTL="/proc/sys/debug/test_sysctl"
+	fi
+	if [ -z "${PROD_SYSCTL}" ]; then
+		PROD_SYSCTL="/proc/sys"
+	fi
+	if [ -z "${WRITES_STRICT}" ]; then
+		WRITES_STRICT="${PROD_SYSCTL}/kernel/sysctl_writes_strict"
+	fi
+	if [ -z "${BITMAP_ITERATIONS}" ]; then
+		BITMAP_ITERATIONS=50
+	fi
+	# Set seed for bitmap random tests
+	if [ -z "${BITMAP_SEED}" ]; then
+		BITMAP_SEED=$RANDOM
 	fi
-	date
-	echo "Running test: $2 - run #$1"
 }
 
-function watch_case()
+check_production_sysctl_writes_strict()
 {
-	i=0
-	while [ 1 ]; do
-
-		if [ $# -eq 1 ]; then
-			test_num $1
-			watch_log $i ${TEST_NAME}_test_$1
-			${TEST_NAME}_test_$1
-		else
-			watch_log $i all
-			run_all_tests
+	if [ ! -e "${WRITES_STRICT}" ]; then
+		ktap_print_msg "${WRITES_STRICT} missing, skipping strict write check (old kernel?)"
+	else
+		old_strict=$(cat "${WRITES_STRICT}")
+		if [ "$old_strict" != "1" ]; then
+			ktap_print_msg "forcing ${WRITES_STRICT} to 1 (was ${old_strict})"
+			echo "1" > "${WRITES_STRICT}"
 		fi
-		let i=$i+1
-	done
+	fi
+
+	if [ -z "${PAGE_SIZE}" ]; then
+		PAGE_SIZE=$(getconf PAGESIZE)
+	fi
+	if [ -z "${MAX_DIGITS}" ]; then
+		MAX_DIGITS=$((PAGE_SIZE / 8))
+	fi
+	if [ -z "${INT_MAX}" ]; then
+		INT_MAX=$(getconf INT_MAX)
+	fi
+	if [ -z "${UINT_MAX}" ]; then
+		UINT_MAX=$(getconf UINT_MAX)
+	fi
 }
 
-function test_case()
+load_req_mod()
 {
-	TEST_ID=$1
-	NUM_TESTS=$2
-	TARGET=$3
-
-	if skip_test $TEST_ID $TARGET; then
-		return
+	if [ ! -d "${SYSCTL}" ]; then
+		if ! modprobe -q -n "${TEST_DRIVER}"; then
+			ktap_skip_all "module ${TEST_DRIVER} not found. \
+				You must set CONFIG_TEST_SYSCTL=m in your kernel"
+			exit "$KSFT_SKIP"
+		fi
+		if ! modprobe "${TEST_DRIVER}"; then
+			ktap_exit_fail_msg "modprobe ${TEST_DRIVER} failed"
+		fi
 	fi
-
-	i=0
-	while [ $i -lt $NUM_TESTS ]; do
-		test_num $TEST_ID
-		watch_log $i ${TEST_NAME}_test_${TEST_ID} noclear
-		RUN_TEST=${TEST_NAME}_test_${TEST_ID}
-		$RUN_TEST
-		let i=$i+1
-	done
 }
 
-function parse_args()
+# Cleanup only! Do not call exit here or it will silently override KTAP exit status
+restore_sysctl_writes_strict()
 {
-	if [ $# -eq 0 ]; then
-		run_all_tests
-	else
-		if [[ "$1" = "all" ]]; then
-			run_all_tests
-		elif [[ "$1" = "-w" ]]; then
-			shift
-			watch_case $@
-		elif [[ "$1" = "-t" ]]; then
-			shift
-			test_num $1
-			test_case $1 $(get_test_count $1) $(get_test_target $1)
-		elif [[ "$1" = "-c" ]]; then
-			shift
-			test_num $1
-			test_num $2
-			test_case $1 $2 $(get_test_target $1)
-		elif [[ "$1" = "-s" ]]; then
-			shift
-			test_case $1 1 $(get_test_target $1)
-		elif [[ "$1" = "-l" ]]; then
-			list_tests
-		elif [[ "$1" = "-h" || "$1" = "--help" ]]; then
-			usage
-		else
-			usage
-		fi
+	if [ -n "${old_strict}" ]; then
+		echo "${old_strict}" > "${WRITES_STRICT}"
 	fi
 }
 
-test_reqs
 allow_user_defaults
+
+# Each bitmap iteration is one function to generate one KTAP report per iteration
+for i in $(seq 1 "$BITMAP_ITERATIONS"); do
+	eval "test_bitmap_range_check_$(printf '%02d' "$i")() \
+		{ \
+			bitmap_range_check_once $i; \
+		}"
+done
+
+# Discover test_* functions above this line
+ALL_TESTS=$(declare -F | awk '{print $3}' | grep '^test_' | sort)
+
+REPEAT=1
+while [ $# -gt 0 ]; do
+	case "$1" in
+	-r )
+		shift
+		REPEAT=$1
+		;;
+	-l )
+		list_tests
+		exit 0
+		;;
+	-h | --help )
+		usage
+		exit 0
+		;;
+	-t )
+		shift
+		SYSCTL_TESTS="$1"
+		;;
+	-s )
+		shift
+		BITMAP_SEED="$1"
+		;;
+	* )
+		usage
+		exit 1
+		;;
+	esac
+	shift
+done
+
+SELECTED=${SYSCTL_TESTS-$ALL_TESTS}
+
+ktap_print_header
+trap restore_sysctl_writes_strict EXIT
+check_args "$REPEAT" "$SELECTED" "$BITMAP_SEED"
+check_reqs
 check_production_sysctl_writes_strict
 load_req_mod
 
-trap "test_finish" EXIT
+ktap_print_msg "bitmap base seed: $BITMAP_SEED (replay with -s $BITMAP_SEED)"
 
-parse_args $@
+ktap_set_plan "$(( $(wc -w <<< "$SELECTED") * REPEAT ))"
+
+for ((i = 0; i < REPEAT; i++)); do
+	for t in $SELECTED; do
+		run_one "$t"
+	done
+done
 
-exit 0
+ktap_finished