[mirror_ubuntu-artful-kernel.git] / tools / testing / selftests / sysctl / sysctl.sh

#!/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.

TEST_NAME="sysctl"
TEST_DRIVER="test_${TEST_NAME}"
TEST_DIR=$(dirname $0)
TEST_FILE=$(mktemp)

# This represents
#
# TEST_ID:TEST_COUNT:ENABLED
#
# TEST_ID: is the test id number
# TEST_COUNT: number of times we should run the test
# ENABLED: 1 if enabled, 0 otherwise
#
# Once these are enabled please leave them as-is. Write your own test,
# we have tons of space.
ALL_TESTS="0001:1:1"
ALL_TESTS="$ALL_TESTS 0002:1:1"
ALL_TESTS="$ALL_TESTS 0003:1:1"
ALL_TESTS="$ALL_TESTS 0004:1:1"
ALL_TESTS="$ALL_TESTS 0005:3:1"

test_modprobe()
{
       if [ ! -d $DIR ]; then
               echo "$0: $DIR not present" >&2
               echo "You must have the following enabled in your kernel:" >&2
               cat $TEST_DIR/config >&2
               exit 1
       fi
}

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 0
	fi

	if ! which perl 2> /dev/null > /dev/null; then
		echo "$0: You need perl installed"
		exit 1
	fi
	if ! which getconf 2> /dev/null > /dev/null; then
		echo "$0: You need getconf installed"
		exit 1
	fi
	if ! which diff 2> /dev/null > /dev/null; then
		echo "$0: You need diff installed"
		exit 1
	fi
}

function load_req_mod()
{
	trap "test_modprobe" EXIT

	if [ ! -d $DIR ]; then
		modprobe $TEST_DRIVER
		if [ $? -ne 0 ]; then
			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)"
			;;
		*)
			;;
	esac
	echo -n $VAL > $TARGET
}

set_orig()
{
	if [ ! -z $TARGET ]; then
		echo "${ORIG}" > "${TARGET}"
	fi
}

set_test()
{
	echo "${TEST_STR}" > "${TARGET}"
}

verify()
{
	local seen
	seen=$(cat "$1")
	if [ "${seen}" != "${TEST_STR}" ]; then
		return 1
	fi
	return 0
}

verify_diff_w()
{
	echo "$TEST_STR" | diff -q -w -u - $1
	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
}

# 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
}

sysctl_test_0001()
{
	TARGET="${SYSCTL}/int_0001"
	reset_vals
	ORIG=$(cat "${TARGET}")
	TEST_STR=$(( $ORIG + 1 ))

	run_numerictests
	run_limit_digit
}

sysctl_test_0002()
{
	TARGET="${SYSCTL}/string_0001"
	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}/int_0002"
	reset_vals
	ORIG=$(cat "${TARGET}")
	TEST_STR=$(( $ORIG + 1 ))

	run_numerictests
	run_limit_digit
	run_limit_digit_int
}

sysctl_test_0004()
{
	TARGET="${SYSCTL}/uint_0001"
	reset_vals
	ORIG=$(cat "${TARGET}")
	TEST_STR=$(( $ORIG + 1 ))

	run_numerictests
	run_limit_digit
	run_limit_digit_uint
}

sysctl_test_0005()
{
	TARGET="${SYSCTL}/int_0003"
	reset_vals
	ORIG=$(cat "${TARGET}")

	run_limit_digit_int_array
}

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"
}

test_reqs

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'}')
	LAST_TWO=${TEST_DATA#*:*}
	echo ${LAST_TWO%:*}
}

function get_test_enabled()
{
	test_num $1
	TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
	echo ${TEST_DATA#*:*:}
}

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)
		if [[ $ENABLED -eq "1" ]]; then
			test_case $TEST_ID $TEST_COUNT
		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=$DEFAULT_NUM_TESTS
	if [ $# -eq 2 ]; then
		NUM_TESTS=$2
	fi

	i=0
	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)
		elif [[ "$1" = "-c" ]]; then
			shift
			test_num $1
			test_num $2
			test_case $1 $2
		elif [[ "$1" = "-s" ]]; then
			shift
			test_case $1 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
Commit	Line	Data
64b67120 LR	1	#!/bin/bash
	2	# Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
	3	#
	4	# This program is free software; you can redistribute it and/or modify it
	5	# under the terms of the GNU General Public License as published by the Free
	6	# Software Foundation; either version 2 of the License, or at your option any
	7	# later version; or, when distributed separately from the Linux kernel or
	8	# when incorporated into other software packages, subject to the following
	9	# license:
	10	#
	11	# This program is free software; you can redistribute it and/or modify it
	12	# under the terms of copyleft-next (version 0.3.1 or later) as published
	13	# at http://copyleft-next.org/.
	14
	15	# This performs a series tests against the proc sysctl interface.
	16
	17	TEST_NAME="sysctl"
	18	TEST_DRIVER="test_${TEST_NAME}"
	19	TEST_DIR=$(dirname $0)
	20	TEST_FILE=$(mktemp)
	21
	22	# This represents
	23	#
	24	# TEST_ID:TEST_COUNT:ENABLED
	25	#
	26	# TEST_ID: is the test id number
	27	# TEST_COUNT: number of times we should run the test
	28	# ENABLED: 1 if enabled, 0 otherwise
	29	#
	30	# Once these are enabled please leave them as-is. Write your own test,
	31	# we have tons of space.
	32	ALL_TESTS="0001:1:1"
	33	ALL_TESTS="$ALL_TESTS 0002:1:1"
eb965eda	34	ALL_TESTS="$ALL_TESTS 0003:1:1"
2920fad3	35	ALL_TESTS="$ALL_TESTS 0004:1:1"
7c43a657	36	ALL_TESTS="$ALL_TESTS 0005:3:1"
64b67120 LR	37
	38	test_modprobe()
	39	{
	40	if [ ! -d $DIR ]; then
	41	echo "$0: $DIR not present" >&2
	42	echo "You must have the following enabled in your kernel:" >&2
	43	cat $TEST_DIR/config >&2
	44	exit 1
	45	fi
	46	}
	47
	48	function allow_user_defaults()
	49	{
	50	if [ -z $DIR ]; then
	51	DIR="/sys/module/test_sysctl/"
	52	fi
	53	if [ -z $DEFAULT_NUM_TESTS ]; then
	54	DEFAULT_NUM_TESTS=50
	55	fi
	56	if [ -z $SYSCTL ]; then
	57	SYSCTL="/proc/sys/debug/test_sysctl"
	58	fi
	59	if [ -z $PROD_SYSCTL ]; then
	60	PROD_SYSCTL="/proc/sys"
	61	fi
	62	if [ -z $WRITES_STRICT ]; then
	63	WRITES_STRICT="${PROD_SYSCTL}/kernel/sysctl_writes_strict"
	64	fi
	65	}
	66
	67	function check_production_sysctl_writes_strict()
	68	{
	69	echo -n "Checking production write strict setting ... "
	70	if [ ! -e ${WRITES_STRICT} ]; then
	71	echo "FAIL, but skip in case of old kernel" >&2
	72	else
	73	old_strict=$(cat ${WRITES_STRICT})
	74	if [ "$old_strict" = "1" ]; then
	75	echo "ok"
	76	else
	77	echo "FAIL, strict value is 0 but force to 1 to continue" >&2
	78	echo "1" > ${WRITES_STRICT}
	79	fi
	80	fi
1c0357c8 LR	81
	82	if [ -z $PAGE_SIZE ]; then
	83	PAGE_SIZE=$(getconf PAGESIZE)
	84	fi
	85	if [ -z $MAX_DIGITS ]; then
	86	MAX_DIGITS=$(($PAGE_SIZE/8))
	87	fi
eb965eda LR	88	if [ -z $INT_MAX ]; then
	89	INT_MAX=$(getconf INT_MAX)
	90	fi
2920fad3 LR	91	if [ -z $UINT_MAX ]; then
	92	UINT_MAX=$(getconf UINT_MAX)
	93	fi
64b67120 LR	94	}
	95
	96	test_reqs()
	97	{
	98	uid=$(id -u)
	99	if [ $uid -ne 0 ]; then
	100	echo $msg must be run as root >&2
	101	exit 0
	102	fi
	103
	104	if ! which perl 2> /dev/null > /dev/null; then
	105	echo "$0: You need perl installed"
	106	exit 1
	107	fi
1c0357c8 LR	108	if ! which getconf 2> /dev/null > /dev/null; then
	109	echo "$0: You need getconf installed"
	110	exit 1
	111	fi
7c43a657 LR	112	if ! which diff 2> /dev/null > /dev/null; then
	113	echo "$0: You need diff installed"
	114	exit 1
	115	fi
64b67120 LR	116	}
	117
	118	function load_req_mod()
	119	{
	120	trap "test_modprobe" EXIT
	121
	122	if [ ! -d $DIR ]; then
	123	modprobe $TEST_DRIVER
	124	if [ $? -ne 0 ]; then
	125	exit
	126	fi
	127	fi
	128	}
	129
1c0357c8 LR	130	reset_vals()
	131	{
	132	VAL=""
	133	TRIGGER=$(basename ${TARGET})
	134	case "$TRIGGER" in
	135	int_0001)
	136	VAL="60"
	137	;;
eb965eda LR	138	int_0002)
	139	VAL="1"
	140	;;
2920fad3 LR	141	uint_0001)
	142	VAL="314"
	143	;;
1c0357c8 LR	144	string_0001)
	145	VAL="(none)"
	146	;;
	147	*)
	148	;;
	149	esac
	150	echo -n $VAL > $TARGET
	151	}
	152
64b67120 LR	153	set_orig()
	154	{
	155	if [ ! -z $TARGET ]; then
	156	echo "${ORIG}" > "${TARGET}"
	157	fi
	158	}
	159
	160	set_test()
	161	{
	162	echo "${TEST_STR}" > "${TARGET}"
	163	}
	164
	165	verify()
	166	{
	167	local seen
	168	seen=$(cat "$1")
	169	if [ "${seen}" != "${TEST_STR}" ]; then
	170	return 1
	171	fi
	172	return 0
	173	}
	174
7c43a657 LR	175	verify_diff_w()
	176	{
	177	echo "$TEST_STR" \| diff -q -w -u - $1
	178	return $?
	179	}
	180
64b67120 LR	181	test_rc()
	182	{
	183	if [[ $rc != 0 ]]; then
	184	echo "Failed test, return value: $rc" >&2
	185	exit $rc
	186	fi
	187	}
	188
	189	test_finish()
	190	{
	191	set_orig
	192	rm -f "${TEST_FILE}"
	193
	194	if [ ! -z ${old_strict} ]; then
	195	echo ${old_strict} > ${WRITES_STRICT}
	196	fi
	197	exit $rc
	198	}
	199
	200	run_numerictests()
	201	{
	202	echo "== Testing sysctl behavior against ${TARGET} =="
	203
	204	rc=0
	205
	206	echo -n "Writing test file ... "
	207	echo "${TEST_STR}" > "${TEST_FILE}"
	208	if ! verify "${TEST_FILE}"; then
	209	echo "FAIL" >&2
	210	exit 1
	211	else
	212	echo "ok"
	213	fi
	214
	215	echo -n "Checking sysctl is not set to test value ... "
	216	if verify "${TARGET}"; then
	217	echo "FAIL" >&2
	218	exit 1
	219	else
	220	echo "ok"
	221	fi
	222
	223	echo -n "Writing sysctl from shell ... "
	224	set_test
	225	if ! verify "${TARGET}"; then
	226	echo "FAIL" >&2
	227	exit 1
	228	else
	229	echo "ok"
	230	fi
	231
	232	echo -n "Resetting sysctl to original value ... "
	233	set_orig
	234	if verify "${TARGET}"; then
	235	echo "FAIL" >&2
	236	exit 1
	237	else
	238	echo "ok"
	239	fi
	240
	241	# Now that we've validated the sanity of "set_test" and "set_orig",
	242	# we can use those functions to set starting states before running
	243	# specific behavioral tests.
	244
245	echo -n "Writing entire sysctl in single write ... "
246	set_orig
247	dd if="${TEST_FILE}" of="${TARGET}" bs=4096 2>/dev/null
248	if ! verify "${TARGET}"; then
249	echo "FAIL" >&2
250	rc=1
251	else
252	echo "ok"
253	fi
254
255	echo -n "Writing middle of sysctl after synchronized seek ... "
256	set_test
257	dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 skip=1 2>/dev/null
258	if ! verify "${TARGET}"; then
259	echo "FAIL" >&2
260	rc=1
261	else
262	echo "ok"
263	fi
264
265	echo -n "Writing beyond end of sysctl ... "
266	set_orig
267	dd if="${TEST_FILE}" of="${TARGET}" bs=20 seek=2 2>/dev/null
268	if verify "${TARGET}"; then
269	echo "FAIL" >&2
270	rc=1
271	else
272	echo "ok"
273	fi
274
275	echo -n "Writing sysctl with multiple long writes ... "
276	set_orig
277	(perl -e 'print "A" x 50;'; echo "${TEST_STR}") \| \
278	dd of="${TARGET}" bs=50 2>/dev/null
279	if verify "${TARGET}"; then
280	echo "FAIL" >&2
281	rc=1
282	else
283	echo "ok"
284	fi
1c0357c8 LR	285	test_rc
	286	}
	287
	288	# Your test must accept digits 3 and 4 to use this
	289	run_limit_digit()
	290	{
	291	echo -n "Checking ignoring spaces up to PAGE_SIZE works on write ..."
	292	reset_vals
64b67120	293
1c0357c8 LR	294	LIMIT=$((MAX_DIGITS -1))
	295	TEST_STR="3"
	296	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") \| \
	297	dd of="${TARGET}" 2>/dev/null
	298
	299	if ! verify "${TARGET}"; then
	300	echo "FAIL" >&2
	301	rc=1
	302	else
	303	echo "ok"
	304	fi
	305	test_rc
	306
	307	echo -n "Checking passing PAGE_SIZE of spaces fails on write ..."
	308	reset_vals
	309
	310	LIMIT=$((MAX_DIGITS))
	311	TEST_STR="4"
	312	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") \| \
	313	dd of="${TARGET}" 2>/dev/null
	314
	315	if verify "${TARGET}"; then
	316	echo "FAIL" >&2
	317	rc=1
	318	else
	319	echo "ok"
	320	fi
64b67120 LR	321	test_rc
	322	}
	323
eb965eda LR	324	# You are using an int
	325	run_limit_digit_int()
	326	{
	327	echo -n "Testing INT_MAX works ..."
	328	reset_vals
	329	TEST_STR="$INT_MAX"
	330	echo -n $TEST_STR > $TARGET
	331
	332	if ! verify "${TARGET}"; then
	333	echo "FAIL" >&2
	334	rc=1
	335	else
	336	echo "ok"
	337	fi
	338	test_rc
	339
	340	echo -n "Testing INT_MAX + 1 will fail as expected..."
	341	reset_vals
	342	let TEST_STR=$INT_MAX+1
	343	echo -n $TEST_STR > $TARGET 2> /dev/null
	344
	345	if verify "${TARGET}"; then
	346	echo "FAIL" >&2
	347	rc=1
	348	else
	349	echo "ok"
	350	fi
	351	test_rc
	352
	353	echo -n "Testing negative values will work as expected..."
	354	reset_vals
	355	TEST_STR="-3"
	356	echo -n $TEST_STR > $TARGET 2> /dev/null
	357	if ! verify "${TARGET}"; then
	358	echo "FAIL" >&2
	359	rc=1
	360	else
	361	echo "ok"
	362	fi
	363	test_rc
	364	}
	365
7c43a657 LR	366	# You used an int array
	367	run_limit_digit_int_array()
	368	{
	369	echo -n "Testing array works as expected ... "
	370	TEST_STR="4 3 2 1"
	371	echo -n $TEST_STR > $TARGET
	372
	373	if ! verify_diff_w "${TARGET}"; then
	374	echo "FAIL" >&2
	375	rc=1
	376	else
	377	echo "ok"
	378	fi
	379	test_rc
	380
	381	echo -n "Testing skipping trailing array elements works ... "
	382	# Do not reset_vals, carry on the values from the last test.
	383	# If we only echo in two digits the last two are left intact
	384	TEST_STR="100 101"
	385	echo -n $TEST_STR > $TARGET
	386	# After we echo in, to help diff we need to set on TEST_STR what
	387	# we expect the result to be.
	388	TEST_STR="100 101 2 1"
	389
	390	if ! verify_diff_w "${TARGET}"; then
	391	echo "FAIL" >&2
	392	rc=1
	393	else
	394	echo "ok"
	395	fi
	396	test_rc
	397
	398	echo -n "Testing PAGE_SIZE limit on array works ... "
	399	# Do not reset_vals, carry on the values from the last test.
	400	# Even if you use an int array, you are still restricted to
	401	# MAX_DIGITS, this is a known limitation. Test limit works.
	402	LIMIT=$((MAX_DIGITS -1))
	403	TEST_STR="9"
	404	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") \| \
	405	dd of="${TARGET}" 2>/dev/null
	406
	407	TEST_STR="9 101 2 1"
	408	if ! verify_diff_w "${TARGET}"; then
	409	echo "FAIL" >&2
	410	rc=1
	411	else
	412	echo "ok"
	413	fi
	414	test_rc
	415
	416	echo -n "Testing exceeding PAGE_SIZE limit fails as expected ... "
	417	# Do not reset_vals, carry on the values from the last test.
	418	# Now go over limit.
	419	LIMIT=$((MAX_DIGITS))
	420	TEST_STR="7"
	421	(perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") \| \
	422	dd of="${TARGET}" 2>/dev/null
	423
	424	TEST_STR="7 101 2 1"
	425	if verify_diff_w "${TARGET}"; then
	426	echo "FAIL" >&2
	427	rc=1
	428	else
	429	echo "ok"
430	fi
431	test_rc
432	}
433
2920fad3 LR	434	# You are using an unsigned int
	435	run_limit_digit_uint()
	436	{
	437	echo -n "Testing UINT_MAX works ..."
	438	reset_vals
	439	TEST_STR="$UINT_MAX"
	440	echo -n $TEST_STR > $TARGET
	441
	442	if ! verify "${TARGET}"; then
	443	echo "FAIL" >&2
	444	rc=1
	445	else
	446	echo "ok"
	447	fi
	448	test_rc
	449
	450	echo -n "Testing UINT_MAX + 1 will fail as expected..."
	451	reset_vals
	452	TEST_STR=$(($UINT_MAX+1))
	453	echo -n $TEST_STR > $TARGET 2> /dev/null
	454
	455	if verify "${TARGET}"; then
	456	echo "FAIL" >&2
	457	rc=1
	458	else
	459	echo "ok"
	460	fi
	461	test_rc
	462
	463	echo -n "Testing negative values will not work as expected ..."
	464	reset_vals
	465	TEST_STR="-3"
	466	echo -n $TEST_STR > $TARGET 2> /dev/null
	467
	468	if verify "${TARGET}"; then
	469	echo "FAIL" >&2
	470	rc=1
	471	else
	472	echo "ok"
	473	fi
	474	test_rc
	475	}
	476
64b67120 LR	477	run_stringtests()
	478	{
	479	echo -n "Writing entire sysctl in short writes ... "
	480	set_orig
	481	dd if="${TEST_FILE}" of="${TARGET}" bs=1 2>/dev/null
	482	if ! verify "${TARGET}"; then
	483	echo "FAIL" >&2
	484	rc=1
	485	else
	486	echo "ok"
	487	fi
	488
	489	echo -n "Writing middle of sysctl after unsynchronized seek ... "
	490	set_test
	491	dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 2>/dev/null
	492	if verify "${TARGET}"; then
	493	echo "FAIL" >&2
	494	rc=1
	495	else
	496	echo "ok"
	497	fi
	498
	499	echo -n "Checking sysctl maxlen is at least $MAXLEN ... "
	500	set_orig
	501	perl -e 'print "A" x ('"${MAXLEN}"'-2), "B";' \| \
	502	dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
	503	if ! grep -q B "${TARGET}"; then
	504	echo "FAIL" >&2
	505	rc=1
	506	else
	507	echo "ok"
	508	fi
	509
	510	echo -n "Checking sysctl keeps original string on overflow append ... "
	511	set_orig
	512	perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' \| \
	513	dd of="${TARGET}" bs=$(( MAXLEN - 1 )) 2>/dev/null
	514	if grep -q B "${TARGET}"; then
	515	echo "FAIL" >&2
	516	rc=1
	517	else
	518	echo "ok"
	519	fi
	520
	521	echo -n "Checking sysctl stays NULL terminated on write ... "
	522	set_orig
	523	perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' \| \
	524	dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
	525	if grep -q B "${TARGET}"; then
	526	echo "FAIL" >&2
	527	rc=1
	528	else
	529	echo "ok"
	530	fi
	531
	532	echo -n "Checking sysctl stays NULL terminated on overwrite ... "
	533	set_orig
	534	perl -e 'print "A" x ('"${MAXLEN}"'-1), "BB";' \| \
	535	dd of="${TARGET}" bs=$(( $MAXLEN + 1 )) 2>/dev/null
	536	if grep -q B "${TARGET}"; then
	537	echo "FAIL" >&2
	538	rc=1
	539	else
	540	echo "ok"
541	fi
542
543	test_rc
544	}
545
546	sysctl_test_0001()
547	{
548	TARGET="${SYSCTL}/int_0001"
1c0357c8	549	reset_vals
64b67120 LR	550	ORIG=$(cat "${TARGET}")
	551	TEST_STR=$(( $ORIG + 1 ))
	552
	553	run_numerictests
1c0357c8	554	run_limit_digit
64b67120 LR	555	}
	556
	557	sysctl_test_0002()
	558	{
	559	TARGET="${SYSCTL}/string_0001"
1c0357c8	560	reset_vals
64b67120 LR	561	ORIG=$(cat "${TARGET}")
	562	TEST_STR="Testing sysctl"
	563	# Only string sysctls support seeking/appending.
	564	MAXLEN=65
	565
	566	run_numerictests
	567	run_stringtests
	568	}
	569
eb965eda LR	570	sysctl_test_0003()
	571	{
	572	TARGET="${SYSCTL}/int_0002"
	573	reset_vals
	574	ORIG=$(cat "${TARGET}")
	575	TEST_STR=$(( $ORIG + 1 ))
	576
	577	run_numerictests
	578	run_limit_digit
	579	run_limit_digit_int
	580	}
	581
2920fad3 LR	582	sysctl_test_0004()
	583	{
	584	TARGET="${SYSCTL}/uint_0001"
	585	reset_vals
	586	ORIG=$(cat "${TARGET}")
	587	TEST_STR=$(( $ORIG + 1 ))
	588
	589	run_numerictests
	590	run_limit_digit
	591	run_limit_digit_uint
	592	}
	593
7c43a657 LR	594	sysctl_test_0005()
	595	{
	596	TARGET="${SYSCTL}/int_0003"
	597	reset_vals
	598	ORIG=$(cat "${TARGET}")
	599
	600	run_limit_digit_int_array
	601	}
	602
64b67120 LR	603	list_tests()
	604	{
	605	echo "Test ID list:"
	606	echo
	607	echo "TEST_ID x NUM_TEST"
	608	echo "TEST_ID: Test ID"
	609	echo "NUM_TESTS: Number of recommended times to run the test"
	610	echo
	611	echo "0001 x $(get_test_count 0001) - tests proc_dointvec_minmax()"
	612	echo "0002 x $(get_test_count 0002) - tests proc_dostring()"
eb965eda	613	echo "0003 x $(get_test_count 0003) - tests proc_dointvec()"
2920fad3	614	echo "0004 x $(get_test_count 0004) - tests proc_douintvec()"
7c43a657	615	echo "0005 x $(get_test_count 0005) - tests proc_douintvec() array"
64b67120 LR	616	}
	617
	618	test_reqs
	619
	620	usage()
	621	{
	622	NUM_TESTS=$(grep -o ' ' <<<"$ALL_TESTS" \| grep -c .)
	623	let NUM_TESTS=$NUM_TESTS+1
	624	MAX_TEST=$(printf "%04d\n" $NUM_TESTS)
	625	echo "Usage: $0 [ -t <4-number-digit> ] \| [ -w <4-number-digit> ] \|"
	626	echo " [ -s <4-number-digit> ] \| [ -c <4-number-digit> <test- count>"
	627	echo " [ all ] [ -h \| --help ] [ -l ]"
	628	echo ""
	629	echo "Valid tests: 0001-$MAX_TEST"
	630	echo ""
	631	echo " all Runs all tests (default)"
	632	echo " -t Run test ID the number amount of times is recommended"
	633	echo " -w Watch test ID run until it runs into an error"
	634	echo " -c Run test ID once"
	635	echo " -s Run test ID x test-count number of times"
	636	echo " -l List all test ID list"
	637	echo " -h\|--help Help"
	638	echo
	639	echo "If an error every occurs execution will immediately terminate."
	640	echo "If you are adding a new test try using -w <test-ID> first to"
	641	echo "make sure the test passes a series of tests."
	642	echo
	643	echo Example uses:
	644	echo
	645	echo "$TEST_NAME.sh -- executes all tests"
	646	echo "$TEST_NAME.sh -t 0002 -- Executes test ID 0002 number of times is recomended"
	647	echo "$TEST_NAME.sh -w 0002 -- Watch test ID 0002 run until an error occurs"
	648	echo "$TEST_NAME.sh -s 0002 -- Run test ID 0002 once"
	649	echo "$TEST_NAME.sh -c 0002 3 -- Run test ID 0002 three times"
	650	echo
	651	list_tests
	652	exit 1
	653	}
	654
	655	function test_num()
	656	{
	657	re='^[0-9]+$'
	658	if ! [[ $1 =~ $re ]]; then
	659	usage
	660	fi
	661	}
	662
	663	function get_test_count()
	664	{
	665	test_num $1
	666	TEST_DATA=$(echo $ALL_TESTS \| awk '{print $'$1'}')
	667	LAST_TWO=${TEST_DATA#:}
	668	echo ${LAST_TWO%:*}
	669	}
	670
	671	function get_test_enabled()
	672	{
	673	test_num $1
	674	TEST_DATA=$(echo $ALL_TESTS \| awk '{print $'$1'}')
	675	echo ${TEST_DATA#::}
	676	}
	677
	678	function run_all_tests()
	679	{
680	for i in $ALL_TESTS ; do
681	TEST_ID=${i%::}
682	ENABLED=$(get_test_enabled $TEST_ID)
683	TEST_COUNT=$(get_test_count $TEST_ID)
684	if [[ $ENABLED -eq "1" ]]; then
685	test_case $TEST_ID $TEST_COUNT
686	fi
687	done
688	}
689
690	function watch_log()
691	{
692	if [ $# -ne 3 ]; then
693	clear
694	fi
695	date
696	echo "Running test: $2 - run #$1"
697	}
698
699	function watch_case()
700	{
701	i=0
702	while [ 1 ]; do
703
704	if [ $# -eq 1 ]; then
705	test_num $1
706	watch_log $i ${TEST_NAME}_test_$1
707	${TEST_NAME}_test_$1
708	else
709	watch_log $i all
710	run_all_tests
711	fi
712	let i=$i+1
713	done
714	}
715
716	function test_case()
717	{
718	NUM_TESTS=$DEFAULT_NUM_TESTS
719	if [ $# -eq 2 ]; then
720	NUM_TESTS=$2
721	fi
722
723	i=0
724	while [ $i -lt $NUM_TESTS ]; do
725	test_num $1
726	watch_log $i ${TEST_NAME}_test_$1 noclear
727	RUN_TEST=${TEST_NAME}_test_$1
728	$RUN_TEST
729	let i=$i+1
730	done
731	}
732
733	function parse_args()
734	{
735	if [ $# -eq 0 ]; then
736	run_all_tests
737	else
738	if [[ "$1" = "all" ]]; then
739	run_all_tests
740	elif [[ "$1" = "-w" ]]; then
741	shift
742	watch_case $@
743	elif [[ "$1" = "-t" ]]; then
744	shift
745	test_num $1
746	test_case $1 $(get_test_count $1)
747	elif [[ "$1" = "-c" ]]; then
748	shift
749	test_num $1
750	test_num $2
751	test_case $1 $2
752	elif [[ "$1" = "-s" ]]; then
753	shift
754	test_case $1 1
755	elif [[ "$1" = "-l" ]]; then
756	list_tests
757	elif [[ "$1" = "-h" \|\| "$1" = "--help" ]]; then
758	usage
759	else
760	usage
761	fi
762	fi
763	}
764
765	test_reqs
766	allow_user_defaults
767	check_production_sysctl_writes_strict
768	load_req_mod
769
770	trap "test_finish" EXIT
771
772	parse_args $@
773
774	exit 0