xref: /linux/tools/testing/selftests/sysctl/sysctl.sh (revision ccb5bf46e31cef31d0ed1957b1fd3dbf8c774243) 
1#!/usr/bin/env bash
2# SPDX-License-Identifier: GPL-2.0-or-later OR copyleft-next-0.3.1
3# Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
4
5# Reduce noise by disabling "unreachable" check.
6# shellcheck disable=SC2317
7
8# This performs a series of tests against the proc sysctl interface.
9
10DIR="$(dirname "$(readlink -f "$0")")"
11source "${DIR}"/../kselftest/ktap_helpers.sh
12
13TEST_DRIVER="test_sysctl"
14
15assert_write_rejected() # <file> <value>
16{
17	local file=$1 val=$2
18	if printf '%s' "$val" > "$file" 2>/dev/null; then
19		ktap_print_msg "$file: write of '$val' succeeded, expected rejection"
20		return 1
21	fi
22	return 0
23}
24
25assert_content() # <file> <want-file>
26{
27	local file=$1 want_file=$2 got
28	got=$(cat "$file")
29	if [ "$got" == "$want_file" ]; then
30		return 0
31	fi
32	ktap_print_msg "$file: got '$got', want '$want_file'"
33	return 1
34}
35
36# compare ignoring whitespaces
37assert_content_loose() # <file> <want-file>
38{
39	local file=$1 want_file=$2
40	if echo "$want_file" | diff -q -w -u - "$file" > /dev/null; then
41		return 0
42	fi
43	ktap_print_msg "$file: content does not match '$want_file' (whitespace-insensitive)"
44	return 1
45}
46
47# For checks where writes must NOT take effect
48assert_content_rejected() # <file> <bad>
49{
50	local file=$1 bad=$2
51	if echo "$bad" | diff -q -w -u - "$file" > /dev/null; then
52		ktap_print_msg "$file: unexpectedly now holds rejected value '$bad'"
53		return 1
54	fi
55	return 0
56}
57
58# proc files get read a page at a time, which can confuse diff resulting in
59# incorrect results. Use a temp file to diff.
60assert_diff_proc_file() # <file> <want-file>
61{
62	local file=$1 want_file=$2 tmp
63	tmp=$(mktemp)
64	cat "$file" > "$tmp"
65
66	if diff -w -q "$tmp" "$want_file" > /dev/null; then
67		rm -f "$tmp"
68		return 0
69	fi
70	ktap_print_msg "$file: content does not match expected file $want_file"
71	rm -f "$tmp"
72	return 1
73}
74
75# Verify that an erroneous update fails and does not change the baseline.
76assert_no_partial_update() # <file> <baseline> <bad-value>
77{
78	local file=$1 baseline=$2 bad=$3
79
80	printf '%s' "$baseline" > "$file"
81	assert_write_rejected "$file" "$bad" || return 1
82	assert_content_loose "$file" "$baseline"
83}
84
85assert_grep() # <file> <pattern> - <pattern> must appear in <file>
86{
87	local file=$1 pattern=$2
88	if grep -q "$pattern" "$file"; then
89		return 0
90	fi
91	ktap_print_msg "$file: pattern '$pattern' not found"
92	return 1
93}
94
95assert_grep_absent() # <file> <pattern> - <pattern> must NOT appear
96{
97	local file=$1 pattern=$2
98	if ! grep -q "$pattern" "$file"; then
99		return 0
100	fi
101	ktap_print_msg "$file: pattern '$pattern' unexpectedly found"
102	return 1
103}
104
105assert_dmesg_count() # <pattern> <want-count>
106{
107	local pattern=$1 want=$2 got
108	got=$(dmesg | grep -c "$pattern")
109	if [ "$got" -eq "$want" ]; then
110		return 0
111	fi
112	ktap_print_msg "dmesg: pattern '$pattern' seen $got times, want $want"
113	return 1
114}
115
116# write <str> through dd in <bs>-sized chunks
117write_in_chunks()  # <file> <str> <bs>
118{
119	local file=$1 str=$2 bs=$3
120	printf '%s' "$str" | dd of="$file" bs="$bs" 2>/dev/null
121}
122
123# write <str> through dd in <bs>-sized chunks. seeking <seek> blocks of size
124# <bs> into the output. skipping <skip> blocks of size <bs> from the input.
125# Unsyncrhonized when skip is not passed.
126write_at_offset()  # <file> <str> <bs> <seek> [skip]
127{
128	local file=$1 str=$2 bs=$3 seek=$4 skip=${5:-}
129	if [ -n "$skip" ]; then
130		printf '%s' "$str" | dd of="$file" bs="$bs" seek="$seek" skip="$skip" 2>/dev/null
131	else
132		printf '%s' "$str" | dd of="$file" bs="$bs" seek="$seek" 2>/dev/null
133	fi
134}
135
136# pad (prefix) <str> with <pad> 'A' characters, then write it all to <file>
137# with dd block size <bs> (defaults to <pad>).
138write_overlong()  # <file> <pad> <str> [bs]
139{
140	local file=$1 pad=$2 str=$3 bs=$4 p
141	: "${bs:=$pad}"
142
143	# save a string with $pad spaces in $p
144	printf -v p '%*s' "$pad" ''
145	# replace " " with "A"
146	printf '%s%s' "${p// /A}" "$str" | dd of="$file" bs="$bs" 2>/dev/null
147}
148
149# pad (prefix) <str> with <pad> ASCII spaces, then write with default block size.
150write_padded_digits()  # <file> <pad> <val>
151{
152	local file=$1 pad=$2 val=$3 p
153	printf -v p '%*s' "$pad" ''
154	printf '%s%s' "$p" "$val" | dd of="$file" 2>/dev/null
155}
156
157test_int_array_writes()
158{
159	local t="${SYSCTL}/int_0003"
160	local limit
161
162	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
163
164	printf '%s' "4 3 2 1" > "$t"
165	assert_content_loose "$t" "4 3 2 1" || RET=$KSFT_FAIL
166
167	# Skipping trailing elements leaves them intact
168	printf '%s' "100 101" > "$t"
169	assert_content_loose "$t" "100 101 2 1" || RET=$KSFT_FAIL
170
171	# Even for an int array, a single write is still capped at MAX_DIGITS
172	# (PAGE_SIZE/8) bytes; check right at, and just past, that boundary.
173	# Carries on the state from the writes above.
174	limit=$((MAX_DIGITS - 1))
175	write_padded_digits "$t" "$limit" "9"
176	assert_content_loose "$t" "9 101 2 1" || RET=$KSFT_FAIL
177
178	limit=$((MAX_DIGITS))
179	write_padded_digits "$t" "$limit" "7"
180	assert_content_rejected "$t" "7 101 2 1" || RET=$KSFT_FAIL
181}
182
183test_int_array_no_partial_update()
184{
185	local t="${SYSCTL}/int_0003"
186
187	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
188
189	# bad 3rd element (not a number)
190	assert_no_partial_update "$t" "1 2 3 4" "10 20 abc 40" || RET=$KSFT_FAIL
191
192	# bad 3rd element (overflows int)
193	assert_no_partial_update "$t" "1 2 3 4" "10 20 $((INT_MAX + 1)) 40" || RET=$KSFT_FAIL
194
195	# bad 1st element
196	assert_no_partial_update "$t" "1 2 3 4" "abc 20 30 40" || RET=$KSFT_FAIL
197}
198
199# Exercise the write patterns
200assert_write_patterns()  # <file> <baseline> <val>
201{
202	local file=$1 baseline=$2 val=$3 status=0
203
204	printf '%s' "$val" > "$file"
205	assert_content "$file" "$val" || status=1
206	printf '%s' "$baseline" > "$file"
207	assert_content "$file" "$baseline" || status=1
208
209	printf '%s' "$baseline" > "$file"
210	write_in_chunks "$file" "$val" 4096
211	assert_content "$file" "$val" || status=1
212
213	printf '%s' "$val" > "$file"
214	write_at_offset "$file" "$val" 1 1 1
215	assert_content "$file" "$val" || status=1
216
217	printf '%s' "$baseline" > "$file"
218	write_at_offset "$file" "$val" 20 2
219	assert_content_rejected "$file" "$val" || status=1
220
221	printf '%s' "$baseline" > "$file"
222	write_overlong "$file" 50 "$val"
223	assert_content_rejected "$file" "$val" || status=1
224
225	return "$status"
226}
227
228# None of these fit in 32 bits, so writing them to an int/uint sysctl must fail
229assert_wideint_writes_rejected()  # <file> <baseline>
230{
231	local file=$1 baseline=$2 sign mag status=0
232	local magnitudes=(
233		0x0000000100000000
234		0x0000000100000001
235		0x00000001ffffffff
236		0x0000000180000000
237		0x000000017fffffff
238		0xffffffff00000000
239		0xffffffff00000001
240		0xffffffffffffffff
241		0xffffffff80000000
242		0xffffffff7fffffff
243	)
244
245	for sign in '' '-'; do
246		for mag in "${magnitudes[@]}"; do
247			assert_no_partial_update "$file" "$baseline" "${sign}${mag}" || status=1
248		done
249	done
250	return "$status"
251}
252
253# A single write is capped at MAX_DIGITS (PAGE_SIZE/8) bytes; check that
254# leading whitespace up to that limit is ignored, and that PAGE_SIZE of
255# leading whitespace pushes the value past the limit and fails.
256assert_digit_limit()  # <file> <baseline>
257{
258	local file=$1 baseline=$2 status=0
259
260	printf '%s' "$baseline" > "$file"
261	write_padded_digits "$file" "$((MAX_DIGITS - 1))" "3"
262	assert_content "$file" "3" || status=1
263
264	printf '%s' "$baseline" > "$file"
265	write_padded_digits "$file" "$MAX_DIGITS" "4"
266	assert_content_rejected "$file" "4" || status=1
267
268	return "$status"
269}
270
271# proc_dointvec()-specific range checks: INT_MAX must be accepted, INT_MAX+1
272# must be rejected, and negative values must be accepted.
273assert_int_range()  # <file> <baseline>
274{
275	local file=$1 baseline=$2 status=0
276
277	printf '%s' "$baseline" > "$file"
278	printf '%s' "$INT_MAX" > "$file"
279	assert_content "$file" "$INT_MAX" || status=1
280
281	assert_no_partial_update "$file" "$baseline" "$((INT_MAX + 1))" || status=1
282
283	printf '%s' "$baseline" > "$file"
284	printf '%s' "-3" > "$file" 2>/dev/null
285	assert_content "$file" "-3" || status=1
286
287	return "$status"
288}
289
290# proc_douintvec()-specific range checks: UINT_MAX must be accepted,
291# UINT_MAX+1 must be rejected, and negative values must be rejected too.
292assert_uint_range()  # <file> <baseline>
293{
294	local file=$1 baseline=$2 status=0
295
296	printf '%s' "$baseline" > "$file"
297	printf '%s' "$UINT_MAX" > "$file"
298	assert_content "$file" "$UINT_MAX" || status=1
299
300	assert_no_partial_update "$file" "$baseline" "$((UINT_MAX + 1))" || status=1
301	assert_no_partial_update "$file" "$baseline" "-3" || status=1
302
303	return "$status"
304}
305
306test_int_minmax()
307{
308	local t="${SYSCTL}/int_0001"
309	local baseline="60" val="61"
310
311	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
312
313	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
314	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
315	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
316}
317
318test_int_plain()
319{
320	local t="${SYSCTL}/int_0002"
321	local baseline="1" val="2"
322
323	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
324
325	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
326	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
327	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
328	assert_int_range "$t" "$baseline" || RET=$KSFT_FAIL
329}
330
331test_uint_plain()
332{
333	local t="${SYSCTL}/uint_0001"
334	local baseline="314" val="315"
335
336	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
337
338	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
339	assert_wideint_writes_rejected "$t" "$baseline" || RET=$KSFT_FAIL
340	assert_digit_limit "$t" "$baseline" || RET=$KSFT_FAIL
341	assert_uint_range "$t" "$baseline" || RET=$KSFT_FAIL
342}
343
344# proc_dostring()-specific write patterns
345assert_string_write_patterns()  # <file> <baseline> <val> <maxlen>
346{
347	local file=$1 baseline=$2 val=$3 maxlen=$4 status=0
348
349	printf '%s' "$baseline" > "$file"
350	write_in_chunks "$file" "$val" 1
351	assert_content "$file" "$val" || status=1
352
353	printf '%s' "$val" > "$file"
354	write_at_offset "$file" "$val" 1 1
355	assert_content_rejected "$file" "$val" || status=1
356
357	# sysctl maxlen is at least $maxlen
358	printf '%s' "$baseline" > "$file"
359	write_overlong "$file" "$((maxlen - 2))" "B" "$maxlen"
360	assert_grep "$file" "B" || status=1
361
362	# keep original string on overflow append
363	printf '%s' "$baseline" > "$file"
364	write_overlong "$file" "$((maxlen - 1))" "B" "$((maxlen - 1))"
365	assert_grep_absent "$file" "B" || status=1
366
367	# sysctl stays NULL terminated on write
368	printf '%s' "$baseline" > "$file"
369	write_overlong "$file" "$((maxlen - 1))" "B" "$maxlen"
370	assert_grep_absent "$file" "B" || status=1
371
372	# sysctl stays NULL terminated on overwrite
373	printf '%s' "$baseline" > "$file"
374	write_overlong "$file" "$((maxlen - 1))" "BB" "$((maxlen + 1))"
375	assert_grep_absent "$file" "B" || status=1
376
377	return "$status"
378}
379
380test_string_dostring()
381{
382	local t="${SYSCTL}/string_0001"
383	local baseline="(none)" val="Testing sysctl" maxlen=65
384
385	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
386
387	assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL
388	assert_string_write_patterns "$t" "$baseline" "$val" "$maxlen" || RET=$KSFT_FAIL
389}
390
391# Emit a random sysctl bit map
392random_bitmap_spec()
393{
394	local length=$((RANDOM % 65000))
395	local bit=$((RANDOM % 1024))
396	local spec=$bit
397	local range_end
398
399	while [ "${#spec}" -le "$length" ]; do
400		# Keep entries discontiguous, skip ahead by at least 2.
401		bit=$((bit + 2 + RANDOM % 10))
402		spec="${spec},${bit}"
403
404		if [ "$((RANDOM % 2))" -eq 1 ]; then
405			range_end=$((bit + 1 + RANDOM % 10))
406			spec="${spec}-${range_end}"
407			bit=$range_end
408		fi
409	done
410
411	echo -n "$spec"
412}
413
414# Do *not* prefix with "test_". All autogenerate bitmap tests call this helper
415bitmap_range_check_once()  # <iter>
416{
417	local t="${SYSCTL}/bitmap_0001"
418	local spec_file seed
419
420	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
421
422	seed=$((BITMAP_SEED + $1))
423	RANDOM=$seed
424
425	spec_file=$(mktemp)
426	random_bitmap_spec > "$spec_file"
427
428	if ! cat "$spec_file" > "$t" 2>/dev/null; then
429		ktap_print_msg "$t: write of random bitmap spec rejected (seed $seed)"
430		RET=$KSFT_FAIL
431	elif ! assert_diff_proc_file "$t" "$spec_file"; then
432		ktap_print_msg "$t: readback mismatch (seed $seed)"
433		RET=$KSFT_FAIL
434	fi
435
436	rm -f "$spec_file"
437}
438
439test_unregister_removes_dir()
440{
441	local t="${SYSCTL}/unregister_error"
442
443	if [[ -d "$t" ]]; then
444		ktap_print_msg "$t: directory still exists, expected it to be unregistered"
445		RET=$KSFT_FAIL
446	fi
447}
448
449test_mount_point_error()
450{
451	local t="${SYSCTL}/mnt/mnt_error"
452
453	if [[ -d "$t" ]]; then
454		ktap_print_msg "$t: directory unexpectedly created"
455		RET=$KSFT_FAIL
456	fi
457}
458
459test_empty_dir_registration()
460{
461	local t="${SYSCTL}/empty_add"
462
463	if [[ ! -d "$t" ]]; then
464		ktap_print_msg "$t: directory was not created"
465		RET=$KSFT_FAIL
466		return
467	fi
468	if [[ ! -d "$t/empty" ]]; then
469		ktap_print_msg "$t/empty: directory was not created"
470		RET=$KSFT_FAIL
471	fi
472}
473
474test_u8_range_check()
475{
476	local t="${SYSCTL}/u8_valid"
477
478	if [[ ! -f "$t" ]]; then
479		ktap_print_msg "$t: file was not created"
480		RET=$KSFT_FAIL
481		return
482	fi
483
484	assert_dmesg_count "u8_over range value" 1 || RET=$KSFT_FAIL
485	assert_dmesg_count "u8_under range value" 1 || RET=$KSFT_FAIL
486}
487
488test_boot_param_int()
489{
490	local t="${SYSCTL}/boot_int"
491	local orig found
492
493	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
494
495	# Boot cmdline params only apply when test_sysctl is built in, not
496	# loaded as a module.
497	if [[ -d "$MODULE_DIR" ]]; then
498		ktap_print_msg "$t: test only possible if test_sysctl is built-in, not a module"
499		RET=$KSFT_SKIP
500		return
501	fi
502
503	orig=$(cat "$t")
504	if [[ "$orig" == "1" ]]; then
505		return
506	fi
507
508	if [[ ! -f /proc/cmdline ]]; then
509		ktap_print_msg "$t: no /proc/cmdline to check for the boot parameter"
510		RET=$KSFT_SKIP
511		return
512	fi
513
514	found=$(grep -c "sysctl[./]debug[./]test_sysctl[./]boot_int=1" /proc/cmdline)
515	if [[ "$found" == "1" ]]; then
516		ktap_print_msg "$t: kernel param found on cmdline but value is not 1"
517		RET=$KSFT_FAIL
518		return
519	fi
520
521	ktap_print_msg "$t: kernel not booted with sysctl.debug.test_sysctl.boot_int=1"
522	RET=$KSFT_SKIP
523}
524
525test_sysctl_macro_match()
526{
527	local t="${SYSCTL}/match_int"
528
529	[[ -f "$t" ]] || { RET=$KSFT_SKIP; return; }
530
531	assert_content "$t" "1" || RET=$KSFT_FAIL
532}
533
534run_one()
535{
536	local name=$1
537
538	# Subshell: a test cannot leak vars/cwd/traps into the next one, and an
539	# accidental `exit` inside a test kills only its own subshell.
540	( RET=$KSFT_PASS; "$name"; exit $RET )
541
542	case $? in
543	"$KSFT_PASS") ktap_test_pass "$name" ;;
544	"$KSFT_SKIP") ktap_test_skip "$name" ;;
545	*)          ktap_test_fail "$name" ;;
546	esac
547}
548
549usage()
550{
551	cat <<-EOF
552	Usage: $0 [-r N] [-l] [-t T] [-s N] [-h|--help]
553
554	Runs every auto-discovered test_* function. Setting SYSCTL_TESTS will
555	override the default and passing -t will override both env var and the
556	default.
557
558	    -r N          repeat selected tests N times (default 1)
559	    -l            list discovered tests
560	    -t T          space separated tests list. For example "test_1 test_2"
561	    -s N          base seed for the randomized bitmap iterations.
562	    -h, --help    help
563
564	    SYSCTL_TESTS='test_1 test_2' $0  run only the named tests
565	EOF
566}
567
568list_tests()
569{
570	echo "Discovered tests:"
571	local t
572	for t in $ALL_TESTS; do
573		echo "  $t"
574	done
575}
576
577check_reqs()
578{
579	local uid
580	uid=$(id -u)
581
582	if [ "$uid" -ne 0 ]; then
583		ktap_skip_all "must be run as root"
584		exit "$KSFT_SKIP"
585	fi
586
587	if ! which getconf > /dev/null 2>&1; then
588		ktap_skip_all "$0: You need getconf installed"
589		exit "$KSFT_SKIP"
590	fi
591
592	if ! which diff > /dev/null 2>&1; then
593		ktap_skip_all "$0: You need diff installed"
594		exit "$KSFT_SKIP"
595	fi
596}
597
598check_args()  # <repeat> <selected> <seed>
599{
600	local repeat_arg="$1"
601	local selected_arg="$2"
602	local seed_arg="$3"
603	local t
604
605	if [ -z "$selected_arg" ]; then
606		ktap_exit_fail_msg "no test selected"
607	fi
608
609	if ! [[ "$repeat_arg" =~ ^[0-9]+$ ]]; then
610		ktap_exit_fail_msg "repeat argument '$repeat_arg' is not a number"
611	fi
612
613	if ! [[ "$seed_arg" =~ ^[0-9]+$ ]]; then
614		ktap_exit_fail_msg "seed argument '$seed_arg' is not a number"
615	fi
616
617	for t in $selected_arg; do
618		if ! declare -F "$t" > /dev/null; then
619			ktap_exit_fail_msg "unknown selected test '$t'"
620		fi
621	done
622}
623
624allow_user_defaults()
625{
626	if [ -z "${MODULE_DIR}" ]; then
627		MODULE_DIR="/sys/module/test_sysctl/"
628	fi
629	if [ -z "${SYSCTL}" ]; then
630		SYSCTL="/proc/sys/debug/test_sysctl"
631	fi
632	if [ -z "${PROD_SYSCTL}" ]; then
633		PROD_SYSCTL="/proc/sys"
634	fi
635	if [ -z "${WRITES_STRICT}" ]; then
636		WRITES_STRICT="${PROD_SYSCTL}/kernel/sysctl_writes_strict"
637	fi
638	if [ -z "${BITMAP_ITERATIONS}" ]; then
639		BITMAP_ITERATIONS=50
640	fi
641	# Set seed for bitmap random tests
642	if [ -z "${BITMAP_SEED}" ]; then
643		BITMAP_SEED=$RANDOM
644	fi
645}
646
647check_production_sysctl_writes_strict()
648{
649	if [ ! -e "${WRITES_STRICT}" ]; then
650		ktap_print_msg "${WRITES_STRICT} missing, skipping strict write check (old kernel?)"
651	else
652		old_strict=$(cat "${WRITES_STRICT}")
653		if [ "$old_strict" != "1" ]; then
654			ktap_print_msg "forcing ${WRITES_STRICT} to 1 (was ${old_strict})"
655			echo "1" > "${WRITES_STRICT}"
656		fi
657	fi
658
659	if [ -z "${PAGE_SIZE}" ]; then
660		PAGE_SIZE=$(getconf PAGESIZE)
661	fi
662	if [ -z "${MAX_DIGITS}" ]; then
663		MAX_DIGITS=$((PAGE_SIZE / 8))
664	fi
665	if [ -z "${INT_MAX}" ]; then
666		INT_MAX=$(getconf INT_MAX)
667	fi
668	if [ -z "${UINT_MAX}" ]; then
669		UINT_MAX=$(getconf UINT_MAX)
670	fi
671}
672
673load_req_mod()
674{
675	if [ ! -d "${SYSCTL}" ]; then
676		if ! modprobe -q -n "${TEST_DRIVER}"; then
677			ktap_skip_all "module ${TEST_DRIVER} not found. \
678				You must set CONFIG_TEST_SYSCTL=m in your kernel"
679			exit "$KSFT_SKIP"
680		fi
681		if ! modprobe "${TEST_DRIVER}"; then
682			ktap_exit_fail_msg "modprobe ${TEST_DRIVER} failed"
683		fi
684	fi
685}
686
687# Cleanup only! Do not call exit here or it will silently override KTAP exit status
688restore_sysctl_writes_strict()
689{
690	if [ -n "${old_strict}" ]; then
691		echo "${old_strict}" > "${WRITES_STRICT}"
692	fi
693}
694
695allow_user_defaults
696
697# Each bitmap iteration is one function to generate one KTAP report per iteration
698for i in $(seq 1 "$BITMAP_ITERATIONS"); do
699	eval "test_bitmap_range_check_$(printf '%02d' "$i")() \
700		{ \
701			bitmap_range_check_once $i; \
702		}"
703done
704
705# Discover test_* functions above this line
706ALL_TESTS=$(declare -F | awk '{print $3}' | grep '^test_' | sort)
707
708REPEAT=1
709while [ $# -gt 0 ]; do
710	case "$1" in
711	-r )
712		shift
713		REPEAT=$1
714		;;
715	-l )
716		list_tests
717		exit 0
718		;;
719	-h | --help )
720		usage
721		exit 0
722		;;
723	-t )
724		shift
725		SYSCTL_TESTS="$1"
726		;;
727	-s )
728		shift
729		BITMAP_SEED="$1"
730		;;
731	* )
732		usage
733		exit 1
734		;;
735	esac
736	shift
737done
738
739SELECTED=${SYSCTL_TESTS-$ALL_TESTS}
740
741ktap_print_header
742trap restore_sysctl_writes_strict EXIT
743check_args "$REPEAT" "$SELECTED" "$BITMAP_SEED"
744check_reqs
745check_production_sysctl_writes_strict
746load_req_mod
747
748ktap_print_msg "bitmap base seed: $BITMAP_SEED (replay with -s $BITMAP_SEED)"
749
750ktap_set_plan "$(( $(wc -w <<< "$SELECTED") * REPEAT ))"
751
752for ((i = 0; i < REPEAT; i++)); do
753	for t in $SELECTED; do
754		run_one "$t"
755	done
756done
757
758ktap_finished
759