Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100#!/usr/bin/env bash# 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(){ 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 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(){ TMP_DUMP_FILE=$(mktemp) cat $1 > $TMP_DUMP_FILE
if ! diff -w -q $TMP_DUMP_FILE $2; then return 1 else return 0 fi}
verify_diff_w(){ echo "$TEST_STR" | diff -q -w -u - $1 > /dev/null return $?}
test_rc(){ if [[ $rc != 0 ]]; then echo "Failed test, return value: $rc" >&2 exit $rc fi}
test_finish(){ set_orig rm -f "${TEST_FILE}"
if [ ! -z ${old_strict} ]; then echo ${old_strict} > ${WRITES_STRICT} fi exit $rc}
run_numerictests(){ 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}
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}
run_wideint_tests(){ # 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 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 0xffffffff80000000 0xffffffff7fffffff )
for sign in '' '-'; do for mag in "${magnitudes[@]}"; do check_failure "${sign}${mag}" done done}
# Your test must accept digits 3 and 4 to use thisrun_limit_digit(){ echo -n "Checking ignoring spaces up to PAGE_SIZE works on write ... " reset_vals
LIMIT=$((MAX_DIGITS -1)) TEST_STR="3" (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
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}
# You are using an intrun_limit_digit_int(){ 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
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
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}
# You used an int arrayrun_limit_digit_int_array(){ echo -n "Testing array works as expected ... " TEST_STR="4 3 2 1" echo -n $TEST_STR > $TARGET
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}
# You are using an unsigned intrun_limit_digit_uint(){ 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
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}
run_stringtests(){ 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
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
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}
target_exists(){ TARGET="${SYSCTL}/$1" TEST_ID="$2"
if [ ! -f ${TARGET} ] ; then return 0 fi return 1}
run_bitmaptest() { # Total length of bitmaps string to use, a bit under # the maximum input size of the test node LENGTH=$((RANDOM % 65000))
# First bit to set BIT=$((RANDOM % 1024))
# String containing our list of bits to set TEST_STR=$BIT
# 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))))
# Add new bit to the list TEST_STR="${TEST_STR},${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 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}
sysctl_test_0001(){ TARGET="${SYSCTL}/$(get_test_target 0001)" reset_vals ORIG=$(cat "${TARGET}") TEST_STR=$(( $ORIG + 1 ))
run_numerictests run_wideint_tests run_limit_digit}
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}
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}
sysctl_test_0004(){ 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}
sysctl_test_0005(){ TARGET="${SYSCTL}/$(get_test_target 0005)" reset_vals ORIG=$(cat "${TARGET}")
run_limit_digit_int_array}
sysctl_test_0006(){ TARGET="${SYSCTL}/$(get_test_target 0006)" reset_vals ORIG="" run_bitmaptest}
sysctl_test_0007(){ 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
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}
sysctl_test_0008(){ TARGET="${SYSCTL}/$(get_test_target 0008)" echo -n "Testing if $TARGET is matched in kernel ... "
if [ ! -f $TARGET ]; then echo -e "SKIPPING\n$TARGET is not present" return $ksft_skip fi
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}
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"}
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}
function test_num(){ re='^[0-9]+$' if ! [[ $1 =~ $re ]]; then usage fi}function remove_leading_zeros(){ echo $1 | sed 's/^0*//'}
function get_test_count(){ 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}'}
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 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 [[ $ENABLED -eq "1" ]]; then test_case $TEST_ID $TEST_COUNT $TEST_TARGET fi done}
function watch_log(){ if [ $# -ne 3 ]; then clear 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 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(){ 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 fi}
test_reqsallow_user_defaultscheck_production_sysctl_writes_strictload_req_mod
trap "test_finish" EXIT
parse_args $@
exit 0