diff --git a/tools/testing/selftests/sysctl/sysctl.sh b/tools/testing/selftests/sysctl/sysctl.sh index 95e93709088a..ceb5cfa0cfd4 100755 --- a/tools/testing/selftests/sysctl/sysctl.sh +++ b/tools/testing/selftests/sysctl/sysctl.sh @@ -2,362 +2,239 @@ # SPDX-License-Identifier: GPL-2.0-or-later OR copyleft-next-0.3.1 # Copyright (C) 2017 Luis R. Rodriguez -# This performs a series tests against the proc sysctl interface. - +# Reduce noise by disabling "unreachable" check. # shellcheck disable=SC2317 -# 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 performs a series of tests against the proc sysctl interface. -# initialize for individual tests -rc=0 +DIR="$(dirname "$(readlink -f "$0")")" +source "${DIR}"/../kselftest/ktap_helpers.sh -# 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" -ALL_TESTS="$ALL_TESTS 0013:1:1:int_0003:1" +TEST_DRIVER="test_sysctl" -function allow_user_defaults() +assert_write_rejected() # { - 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" - fi -} - -function check_production_sysctl_writes_strict() -{ - 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) - fi -} - -test_reqs() -{ - uid=$(id -u) - if [ $uid -ne 0 ]; then - echo $msg must be run as root >&2 - exit $ksft_skip - fi - - 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 - fi -} - -function load_req_mod() -{ - 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 - fi -} - -reset_vals() -{ - 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 -} - -set_orig() -{ - if [ ! -z $TARGET ] && [ ! -z $ORIG ]; then - if [ -f ${TARGET} ]; then - echo "${ORIG}" > "${TARGET}" - fi - fi -} - -set_test() -{ - echo "${TEST_STR}" > "${TARGET}" -} - -verify() -{ - local seen - seen=$(cat "$1") - if [ "${seen}" != "${TEST_STR}" ]; then + 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 } -# 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() +assert_content() # { - TMP_DUMP_FILE=$(mktemp) - cat $1 > $TMP_DUMP_FILE - - if ! diff -w -q $TMP_DUMP_FILE $2; then - return 1 - else + 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 } -verify_diff_w() +# compare ignoring whitespaces +assert_content_loose() # { - echo "$TEST_STR" | diff -q -w -u - $1 > /dev/null - return $? + 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 } -# Verify that an erroneous ($2) update fails and does not change TARGET -verify_no_partial_update() +# For checks where writes must NOT take effect +assert_content_rejected() # { - TEST_STR="$1" - echo -n "$TEST_STR" > "$TARGET" - - if echo -n "$2" > "$TARGET" 2> /dev/null; then + 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 - verify_diff_w "${TARGET}" + return 0 } -test_rc() +# 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() # { - if [[ $rc != 0 ]]; then - echo "Failed test, return value: $rc" >&2 - exit $rc + 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 +} + +# Verify that an erroneous update fails and does not change the baseline. +assert_no_partial_update() # +{ + local file=$1 baseline=$2 bad=$3 + + printf '%s' "$baseline" > "$file" + assert_write_rejected "$file" "$bad" || return 1 + assert_content_loose "$file" "$baseline" +} + +assert_grep() # - must appear in +{ + local file=$1 pattern=$2 + if grep -q "$pattern" "$file"; then + return 0 + fi + ktap_print_msg "$file: pattern '$pattern' not found" + return 1 +} + +assert_grep_absent() # - must NOT appear +{ + local file=$1 pattern=$2 + if ! grep -q "$pattern" "$file"; then + return 0 + fi + ktap_print_msg "$file: pattern '$pattern' unexpectedly found" + return 1 +} + +assert_dmesg_count() # +{ + local pattern=$1 want=$2 got + got=$(dmesg | grep -c "$pattern") + if [ "$got" -eq "$want" ]; then + return 0 + fi + ktap_print_msg "dmesg: pattern '$pattern' seen $got times, want $want" + return 1 +} + +# write through dd in -sized chunks +write_in_chunks() # +{ + local file=$1 str=$2 bs=$3 + printf '%s' "$str" | dd of="$file" bs="$bs" 2>/dev/null +} + +# write through dd in -sized chunks. seeking blocks of size +# into the output. skipping blocks of size from the input. +# Unsyncrhonized when skip is not passed. +write_at_offset() # [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 + printf '%s' "$str" | dd of="$file" bs="$bs" seek="$seek" 2>/dev/null fi } -test_finish() +# pad (prefix) with 'A' characters, then write it all to +# with dd block size (defaults to ). +write_overlong() # [bs] { - set_orig - rm -f "${TEST_FILE}" + local file=$1 pad=$2 str=$3 bs=$4 p + : "${bs:=$pad}" - if [ ! -z ${old_strict} ]; then - echo ${old_strict} > ${WRITES_STRICT} - fi - exit $rc + # 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 } -run_numerictests() +# pad (prefix) with ASCII spaces, then write with default block size. +write_padded_digits() # { - echo "== Testing sysctl behavior against ${TARGET} ==" - - rc=0 - - echo -n "Writing test file ... " - echo "${TEST_STR}" > "${TEST_FILE}" - if ! verify "${TEST_FILE}"; then - echo "FAIL" >&2 - exit 1 - else - echo "OK" - fi - - echo -n "Checking sysctl is not set to test value ... " - if verify "${TARGET}"; then - echo "FAIL" >&2 - exit 1 - else - echo "OK" - fi - - echo -n "Writing sysctl from shell ... " - set_test - if ! verify "${TARGET}"; then - echo "FAIL" >&2 - exit 1 - else - echo "OK" - fi - - echo -n "Resetting sysctl to original value ... " - set_orig - if verify "${TARGET}"; then - echo "FAIL" >&2 - exit 1 - else - echo "OK" - fi - - # 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. - - 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 - - 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 - - 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 - - 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 + local file=$1 pad=$2 val=$3 p + printf -v p '%*s' "$pad" '' + printf '%s%s' "$p" "$val" | dd of="$file" 2>/dev/null } -check_failure() +test_int_array_writes() { - echo -n "Testing that $1 fails as expected ... " - reset_vals - TEST_STR="$1" - orig="$(cat $TARGET)" - echo -n "$TEST_STR" > $TARGET 2> /dev/null + local t="${SYSCTL}/int_0003" + local limit - # 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 + [[ -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_wideint_tests() +test_int_array_no_partial_update() { - # 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 t="${SYSCTL}/int_0003" + + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } + + # bad 3rd element (not a number) + assert_no_partial_update "$t" "1 2 3 4" "10 20 abc 40" || RET=$KSFT_FAIL + + # bad 3rd element (overflows int) + assert_no_partial_update "$t" "1 2 3 4" "10 20 $((INT_MAX + 1)) 40" || RET=$KSFT_FAIL + + # bad 1st element + assert_no_partial_update "$t" "1 2 3 4" "abc 20 30 40" || RET=$KSFT_FAIL +} + +# Exercise the write patterns +assert_write_patterns() # +{ + local file=$1 baseline=$2 val=$3 status=0 + + printf '%s' "$val" > "$file" + assert_content "$file" "$val" || status=1 + printf '%s' "$baseline" > "$file" + assert_content "$file" "$baseline" || status=1 + + printf '%s' "$baseline" > "$file" + write_in_chunks "$file" "$val" 4096 + assert_content "$file" "$val" || status=1 + + printf '%s' "$val" > "$file" + write_at_offset "$file" "$val" 1 1 1 + assert_content "$file" "$val" || status=1 + + printf '%s' "$baseline" > "$file" + write_at_offset "$file" "$val" 20 2 + assert_content_rejected "$file" "$val" || status=1 + + printf '%s' "$baseline" > "$file" + write_overlong "$file" 50 "$val" + assert_content_rejected "$file" "$val" || status=1 + + return "$status" +} + +# None of these fit in 32 bits, so writing them to an int/uint sysctl must fail +assert_wideint_writes_rejected() # +{ + 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 @@ -367,793 +244,515 @@ 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() # { - 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 + printf '%s' "$baseline" > "$file" + write_padded_digits "$file" "$MAX_DIGITS" "4" + assert_content_rejected "$file" "4" || status=1 - 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 - - 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() # { - echo -n "Testing INT_MAX works ... " - reset_vals - TEST_STR="$INT_MAX" - echo -n $TEST_STR > $TARGET + local file=$1 baseline=$2 status=0 - if ! verify "${TARGET}"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + printf '%s' "$baseline" > "$file" + printf '%s' "$INT_MAX" > "$file" + assert_content "$file" "$INT_MAX" || status=1 - 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 + assert_no_partial_update "$file" "$baseline" "$((INT_MAX + 1))" || status=1 - if verify "${TARGET}"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + printf '%s' "$baseline" > "$file" + printf '%s' "-3" > "$file" 2>/dev/null + assert_content "$file" "-3" || status=1 - 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 + return "$status" } -# You used an int array -run_limit_digit_int_array() +# 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() # { - echo -n "Testing array works as expected ... " - TEST_STR="4 3 2 1" - echo -n $TEST_STR > $TARGET + local file=$1 baseline=$2 status=0 - if ! verify_diff_w "${TARGET}"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + printf '%s' "$baseline" > "$file" + printf '%s' "$UINT_MAX" > "$file" + assert_content "$file" "$UINT_MAX" || status=1 - 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" + assert_no_partial_update "$file" "$baseline" "$((UINT_MAX + 1))" || status=1 + assert_no_partial_update "$file" "$baseline" "-3" || status=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 used an int array and one of the elements is not acceptable -run_int_array_no_partial_update() +test_int_minmax() { - echo -n "Testing invalid array element does not partially update ... " - # Expect failure because of 3rd element (abc). - if ! verify_no_partial_update "1 2 3 4" "10 20 abc 40"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + local t="${SYSCTL}/int_0001" + local baseline="60" val="61" - echo -n "Testing out of range array element does not partially update ... " - # Expect failure because of 3rd element (greater than int) - if ! verify_no_partial_update "1 2 3 4" "10 20 $((INT_MAX + 1)) 40"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } - echo -n "Testing invalid first array element does not update ... " - # Expect failure of 1st element - if ! verify_no_partial_update "1 2 3 4" "abc 20 30 40"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + 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 } -# You are using an unsigned int -run_limit_digit_uint() +test_int_plain() { - echo -n "Testing UINT_MAX works ... " - reset_vals - TEST_STR="$UINT_MAX" - echo -n $TEST_STR > $TARGET + local t="${SYSCTL}/int_0002" + local baseline="1" val="2" - if ! verify "${TARGET}"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } - 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 - - if verify "${TARGET}"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - fi - test_rc - - echo -n "Testing negative values will not 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_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 } -run_stringtests() +test_uint_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}/uint_0001" + local baseline="314" val="315" - 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 - - 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 - - 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 - - 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 - - test_rc + 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 } -target_exists() +# proc_dostring()-specific write patterns +assert_string_write_patterns() # { - TARGET="${SYSCTL}/$1" - TEST_ID="$2" + local file=$1 baseline=$2 val=$3 maxlen=$4 status=0 - if [ ! -f ${TARGET} ] ; then - return 0 - fi - return 1 + printf '%s' "$baseline" > "$file" + write_in_chunks "$file" "$val" 1 + assert_content "$file" "$val" || status=1 + + printf '%s' "$val" > "$file" + write_at_offset "$file" "$val" 1 1 + assert_content_rejected "$file" "$val" || status=1 + + # sysctl maxlen is at least $maxlen + printf '%s' "$baseline" > "$file" + write_overlong "$file" "$((maxlen - 2))" "B" "$maxlen" + assert_grep "$file" "B" || status=1 + + # 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 + + # sysctl stays NULL terminated on write + printf '%s' "$baseline" > "$file" + write_overlong "$file" "$((maxlen - 1))" "B" "$maxlen" + assert_grep_absent "$file" "B" || status=1 + + # 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 + + return "$status" } -run_bitmaptest() { - # Total length of bitmaps string to use, a bit under - # the maximum input size of the test node - LENGTH=$((RANDOM % 65000)) +test_string_dostring() +{ + local t="${SYSCTL}/string_0001" + local baseline="(none)" val="Testing sysctl" maxlen=65 - # First bit to set - BIT=$((RANDOM % 1024)) + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } - # String containing our list of bits to set - TEST_STR=$BIT + assert_write_patterns "$t" "$baseline" "$val" || RET=$KSFT_FAIL + assert_string_write_patterns "$t" "$baseline" "$val" "$maxlen" || RET=$KSFT_FAIL +} - # 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)))) +# Emit a random sysctl bit map +random_bitmap_spec() +{ + local length=$((RANDOM % 65000)) + local bit=$((RANDOM % 1024)) + local spec=$bit + local range_end - # Add new bit to the list - TEST_STR="${TEST_STR},${BIT}" + while [ "${#spec}" -le "$length" ]; do + # Keep entries discontiguous, skip ahead by at least 2. + bit=$((bit + 2 + RANDOM % 10)) + spec="${spec},${bit}" - # 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 + if [ "$((RANDOM % 2))" -eq 1 ]; then + range_end=$((bit + 1 + RANDOM % 10)) + spec="${spec}-${range_end}" + bit=$range_end fi done - echo -n "Checking bitmap handler ... " - TEST_FILE=$(mktemp) - echo -n "$TEST_STR" > $TEST_FILE - - cat $TEST_FILE > $TARGET 2> /dev/null - if [ $? -ne 0 ]; then - echo "FAIL" >&2 - rc=1 - test_rc - fi - - if ! verify_diff_proc_file "$TARGET" "$TEST_FILE"; then - echo "FAIL" >&2 - rc=1 - else - echo "OK" - rc=0 - fi - test_rc + echo -n "$spec" } -sysctl_test_0001() +# Do *not* prefix with "test_". All autogenerate bitmap tests call this helper +bitmap_range_check_once() # { - TARGET="${SYSCTL}/$(get_test_target 0001)" - reset_vals - ORIG=$(cat "${TARGET}") - TEST_STR=$(( $ORIG + 1 )) + local t="${SYSCTL}/bitmap_0001" + local spec_file seed - run_numerictests - run_wideint_tests - run_limit_digit + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } + + seed=$((BITMAP_SEED + $1)) + RANDOM=$seed + + spec_file=$(mktemp) + random_bitmap_spec > "$spec_file" + + 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 + + rm -f "$spec_file" } -sysctl_test_0002() +test_unregister_removes_dir() { - TARGET="${SYSCTL}/$(get_test_target 0002)" - reset_vals - ORIG=$(cat "${TARGET}") - TEST_STR="Testing sysctl" - # Only string sysctls support seeking/appending. - MAXLEN=65 + local t="${SYSCTL}/unregister_error" - run_numerictests - run_stringtests + if [[ -d "$t" ]]; then + ktap_print_msg "$t: directory still exists, expected it to be unregistered" + RET=$KSFT_FAIL + fi } -sysctl_test_0003() +test_mount_point_error() { - TARGET="${SYSCTL}/$(get_test_target 0003)" - reset_vals - ORIG=$(cat "${TARGET}") - TEST_STR=$(( $ORIG + 1 )) + local t="${SYSCTL}/mnt/mnt_error" - run_numerictests - run_wideint_tests - run_limit_digit - run_limit_digit_int + if [[ -d "$t" ]]; then + ktap_print_msg "$t: directory unexpectedly created" + RET=$KSFT_FAIL + fi } -sysctl_test_0004() +test_empty_dir_registration() { - TARGET="${SYSCTL}/$(get_test_target 0004)" - reset_vals - ORIG=$(cat "${TARGET}") - TEST_STR=$(( $ORIG + 1 )) + local t="${SYSCTL}/empty_add" - run_numerictests - run_wideint_tests - run_limit_digit - run_limit_digit_uint + 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_0005() +test_u8_range_check() { - TARGET="${SYSCTL}/$(get_test_target 0005)" - reset_vals - ORIG=$(cat "${TARGET}") + local t="${SYSCTL}/u8_valid" - run_limit_digit_int_array + if [[ ! -f "$t" ]]; then + ktap_print_msg "$t: file was not created" + RET=$KSFT_FAIL + return + fi + + assert_dmesg_count "u8_over range value" 1 || RET=$KSFT_FAIL + assert_dmesg_count "u8_under range value" 1 || RET=$KSFT_FAIL } -sysctl_test_0006() +test_boot_param_int() { - TARGET="${SYSCTL}/$(get_test_target 0006)" - reset_vals - ORIG="" - run_bitmaptest + local t="${SYSCTL}/boot_int" + local orig found + + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } + + # 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 + + orig=$(cat "$t") + if [[ "$orig" == "1" ]]; then + return + fi + + if [[ ! -f /proc/cmdline ]]; then + ktap_print_msg "$t: no /proc/cmdline to check for the boot parameter" + RET=$KSFT_SKIP + return + fi + + 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 + + ktap_print_msg "$t: kernel not booted with sysctl.debug.test_sysctl.boot_int=1" + RET=$KSFT_SKIP } -sysctl_test_0007() +test_sysctl_macro_match() { - TARGET="${SYSCTL}/$(get_test_target 0007)" - echo -n "Testing if $TARGET is set to 1 ... " + local t="${SYSCTL}/match_int" - if [ ! -f $TARGET ]; then - echo -e "SKIPPING\n$TARGET is not present" - return $ksft_skip - fi + [[ -f "$t" ]] || { RET=$KSFT_SKIP; return; } - 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 - - ORIG=$(cat "${TARGET}") - - if [ x$ORIG = "x1" ]; then - echo "OK" - return 0 - fi - - if [ ! -f /proc/cmdline ]; then - echo -e "SKIPPING\nThere is no /proc/cmdline to check for parameter" - return $ksft_skip - fi - - 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 - 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 + assert_content "$t" "1" || RET=$KSFT_FAIL } -sysctl_test_0008() +run_one() { - TARGET="${SYSCTL}/$(get_test_target 0008)" - echo -n "Testing if $TARGET is matched in kernel ... " + local name=$1 - if [ ! -f $TARGET ]; then - echo -e "SKIPPING\n$TARGET is not present" - return $ksft_skip - fi + # 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 ) - ORIG_VALUE=$(cat "${TARGET}") - - if [ $ORIG_VALUE -ne 1 ]; then - echo "FAIL" >&2 - rc=1 - test_rc - fi - - echo "OK" - return 0 -} - -sysctl_test_0009() -{ - 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 - - echo "OK" - return 0 -} - -sysctl_test_0010() -{ - 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 - fi - - echo "OK" - return 0 -} - -sysctl_test_0011() -{ - 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 - - TARGET2="${TARGET}/empty" - if [ ! -d ${TARGET2} ]; then - echo -e "FAIL\nCould not create ${TARGET2}" >&2 - rc=1 - test_rc - fi - - echo "OK" - return 0 -} - -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 - 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 - 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 - fi - - echo "OK" - return 0 -} - -sysctl_test_0013() -{ - TARGET="${SYSCTL}/$(get_test_target 0013)" - reset_vals - - run_int_array_no_partial_update -} - -list_tests() -{ - 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" - echo "0013 x $(get_test_count 0013) - tests partially update vectors on error" + case $? in + "$KSFT_PASS") ktap_test_pass "$name" ;; + "$KSFT_SKIP") ktap_test_skip "$name" ;; + *) ktap_test_fail "$name" ;; + esac } 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> " - 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 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 + 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 test_num() +list_tests() { - re='^[0-9]+$' - if ! [[ $1 =~ $re ]]; then - usage + echo "Discovered tests:" + local t + for t in $ALL_TESTS; do + echo " $t" + done +} + +check_reqs() +{ + 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 } -function remove_leading_zeros() -{ - echo $1 | sed 's/^0*//' -} -function get_test_count() +check_args() # { - 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 repeat_arg="$1" + local selected_arg="$2" + local seed_arg="$3" + local t -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}' -} - -function get_test_target() -{ - 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}' -} - -function get_test_skip_no_target() -{ - 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}' -} - -function skip_test() -{ - 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 + if [ -z "$selected_arg" ]; then + ktap_exit_fail_msg "no test selected" fi - return 1 -} -function run_all_tests() -{ - 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 ! [[ "$repeat_arg" =~ ^[0-9]+$ ]]; then + ktap_exit_fail_msg "repeat argument '$repeat_arg' is not a number" + fi - if [[ $ENABLED -eq "1" ]]; then - test_case $TEST_ID $TEST_COUNT $TEST_TARGET + 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 - date - echo "Running test: $2 - run #$1" -} - -function watch_case() -{ - 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 - fi - let i=$i+1 - done -} - -function test_case() -{ - TEST_ID=$1 - NUM_TESTS=$2 - TARGET=$3 - - if skip_test $TEST_ID $TARGET; then - return + 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 - - 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() +check_production_sysctl_writes_strict() { - if [ $# -eq 0 ]; then - run_all_tests + if [ ! -e "${WRITES_STRICT}" ]; then + ktap_print_msg "${WRITES_STRICT} missing, skipping strict write check (old kernel?)" 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 + 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 + 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 +} + +load_req_mod() +{ + 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 } -test_reqs +# Cleanup only! Do not call exit here or it will silently override KTAP exit status +restore_sysctl_writes_strict() +{ + if [ -n "${old_strict}" ]; then + echo "${old_strict}" > "${WRITES_STRICT}" + fi +} + 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 ))" -exit 0 +for ((i = 0; i < REPEAT; i++)); do + for t in $SELECTED; do + run_one "$t" + done +done + +ktap_finished