#!/bin/bash
|
# Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
|
#
|
# This program is free software; you can redistribute it and/or modify it
|
# under the terms of the GNU General Public License as published by the Free
|
# Software Foundation; either version 2 of the License, or at your option any
|
# later version; or, when distributed separately from the Linux kernel or
|
# when incorporated into other software packages, subject to the following
|
# license:
|
#
|
# This program is free software; you can redistribute it and/or modify it
|
# under the terms of copyleft-next (version 0.3.1 or later) as published
|
# at http://copyleft-next.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
|
#
|
# 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
|
#
|
# 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"
|
ALL_TESTS="$ALL_TESTS 0002:1:1:string_0001"
|
ALL_TESTS="$ALL_TESTS 0003:1:1:int_0002"
|
ALL_TESTS="$ALL_TESTS 0004:1:1:uint_0001"
|
ALL_TESTS="$ALL_TESTS 0005:3:1:int_0003"
|
ALL_TESTS="$ALL_TESTS 0006:50:1:bitmap_0001"
|
ALL_TESTS="$ALL_TESTS 0007:1:1:boot_int"
|
|
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 this
|
run_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 int
|
run_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 array
|
run_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 int
|
run_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
|
echo "Target for test $TEST_ID: $TARGET not exist, skipping test ..."
|
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}/bitmap_0001"
|
reset_vals
|
ORIG=""
|
run_bitmaptest
|
}
|
|
sysctl_test_0007()
|
{
|
TARGET="${SYSCTL}/boot_int"
|
if [ ! -f $TARGET ]; then
|
echo "Skipping test for $TARGET as it is not present ..."
|
return $ksft_skip
|
fi
|
|
if [ -d $DIR ]; then
|
echo "Boot param test only possible sysctl_test is built-in, not module:"
|
cat $TEST_DIR/config >&2
|
return $ksft_skip
|
fi
|
|
echo -n "Testing if $TARGET is set to 1 ..."
|
ORIG=$(cat "${TARGET}")
|
|
if [ x$ORIG = "x1" ]; then
|
echo "ok"
|
return 0
|
fi
|
echo "FAIL"
|
echo "Checking if /proc/cmdline contains setting of the expected parameter ..."
|
if [ ! -f /proc/cmdline ]; then
|
echo "/proc/cmdline does not exist, test inconclusive"
|
return 0
|
fi
|
|
FOUND=$(grep -c "sysctl[./]debug[./]test_sysctl[./]boot_int=1" /proc/cmdline)
|
if [ $FOUND = "1" ]; then
|
echo "Kernel param found but $TARGET is not 1, TEST FAILED"
|
rc=1
|
test_rc
|
fi
|
|
echo "Skipping test, expected kernel parameter missing."
|
echo "To perform this test, make sure kernel is booted with parameter: sysctl.debug.test_sysctl.boot_int=1"
|
return $ksft_skip
|
}
|
|
list_tests()
|
{
|
echo "Test ID list:"
|
echo
|
echo "TEST_ID x NUM_TEST"
|
echo "TEST_ID: Test ID"
|
echo "NUM_TESTS: Number of recommended 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"
|
}
|
|
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 number amount of times is recommended"
|
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 number of times is recomended"
|
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 get_test_count()
|
{
|
test_num $1
|
TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
|
echo ${TEST_DATA} | awk -F":" '{print $2}'
|
}
|
|
function get_test_enabled()
|
{
|
test_num $1
|
TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
|
echo ${TEST_DATA} | awk -F":" '{print $3}'
|
}
|
|
function get_test_target()
|
{
|
test_num $1
|
TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
|
echo ${TEST_DATA} | awk -F":" '{print $4}'
|
}
|
|
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 target_exists $TEST_TARGET $TEST_ID; then
|
continue
|
fi
|
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()
|
{
|
NUM_TESTS=$2
|
|
i=0
|
|
if target_exists $3 $1; then
|
continue
|
fi
|
|
while [ $i -lt $NUM_TESTS ]; do
|
test_num $1
|
watch_log $i ${TEST_NAME}_test_$1 noclear
|
RUN_TEST=${TEST_NAME}_test_$1
|
$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_reqs
|
allow_user_defaults
|
check_production_sysctl_writes_strict
|
load_req_mod
|
|
trap "test_finish" EXIT
|
|
parse_args $@
|
|
exit 0
|
