projects/linux·blob master · refs

1099 lines · 22.1 KiB

1#!/usr/bin/env bash
2# SPDX-License-Identifier: GPL-2.0-or-later OR copyleft-next-0.3.1
3# Copyright (C) 2017 Luis R. Rodriguez <[email protected]>
4
5# This performs a series tests against the proc sysctl interface.
6
7# Kselftest framework requirement - SKIP code is 4.
8ksft_skip=4
9
10TEST_NAME="sysctl"
11TEST_DRIVER="test_${TEST_NAME}"
12TEST_DIR=$(dirname $0)
13TEST_FILE=$(mktemp)
14
15# This represents
16#
17# TEST_ID:TEST_COUNT:ENABLED:TARGET:SKIP_NO_TARGET
18#
19# TEST_ID: is the test id number
20# TEST_COUNT: number of times we should run the test
21# ENABLED: 1 if enabled, 0 otherwise
22# TARGET: test target file required on the test_sysctl module
23# SKIP_NO_TARGET: 1 skip if TARGET not there
24# 0 run even though TARGET not there
25#
26# Once these are enabled please leave them as-is. Write your own test,
27# we have tons of space.
28ALL_TESTS="0001:1:1:int_0001:1"
29ALL_TESTS="$ALL_TESTS 0002:1:1:string_0001:1"
30ALL_TESTS="$ALL_TESTS 0003:1:1:int_0002:1"
31ALL_TESTS="$ALL_TESTS 0004:1:1:uint_0001:1"
32ALL_TESTS="$ALL_TESTS 0005:3:1:int_0003:1"
33ALL_TESTS="$ALL_TESTS 0006:50:1:bitmap_0001:1"
34ALL_TESTS="$ALL_TESTS 0007:1:1:boot_int:1"
35ALL_TESTS="$ALL_TESTS 0008:1:1:match_int:1"
36ALL_TESTS="$ALL_TESTS 0009:1:1:unregister_error:0"
37ALL_TESTS="$ALL_TESTS 0010:1:1:mnt/mnt_error:0"
38ALL_TESTS="$ALL_TESTS 0011:1:1:empty_add:0"
39ALL_TESTS="$ALL_TESTS 0012:1:1:u8_valid:0"
40
41function allow_user_defaults()
42{
43 if [ -z $DIR ]; then
44 DIR="/sys/module/test_sysctl/"
45 fi
46 if [ -z $DEFAULT_NUM_TESTS ]; then
47 DEFAULT_NUM_TESTS=50
48 fi
49 if [ -z $SYSCTL ]; then
50 SYSCTL="/proc/sys/debug/test_sysctl"
51 fi
52 if [ -z $PROD_SYSCTL ]; then
53 PROD_SYSCTL="/proc/sys"
54 fi
55 if [ -z $WRITES_STRICT ]; then
56 WRITES_STRICT="${PROD_SYSCTL}/kernel/sysctl_writes_strict"
57 fi
58}
59
60function check_production_sysctl_writes_strict()
61{
62 echo -n "Checking production write strict setting ... "
63 if [ ! -e ${WRITES_STRICT} ]; then
64 echo "FAIL, but skip in case of old kernel" >&2
65 else
66 old_strict=$(cat ${WRITES_STRICT})
67 if [ "$old_strict" = "1" ]; then
68 echo "OK"
69 else
70 echo "FAIL, strict value is 0 but force to 1 to continue" >&2
71 echo "1" > ${WRITES_STRICT}
72 fi
73 fi
74
75 if [ -z $PAGE_SIZE ]; then
76 PAGE_SIZE=$(getconf PAGESIZE)
77 fi
78 if [ -z $MAX_DIGITS ]; then
79 MAX_DIGITS=$(($PAGE_SIZE/8))
80 fi
81 if [ -z $INT_MAX ]; then
82 INT_MAX=$(getconf INT_MAX)
83 fi
84 if [ -z $UINT_MAX ]; then
85 UINT_MAX=$(getconf UINT_MAX)
86 fi
87}
88
89test_reqs()
90{
91 uid=$(id -u)
92 if [ $uid -ne 0 ]; then
93 echo $msg must be run as root >&2
94 exit $ksft_skip
95 fi
96
97 if ! which perl 2> /dev/null > /dev/null; then
98 echo "$0: You need perl installed"
99 exit $ksft_skip
100 fi
101 if ! which getconf 2> /dev/null > /dev/null; then
102 echo "$0: You need getconf installed"
103 exit $ksft_skip
104 fi
105 if ! which diff 2> /dev/null > /dev/null; then
106 echo "$0: You need diff installed"
107 exit $ksft_skip
108 fi
109}
110
111function load_req_mod()
112{
113 if [ ! -d $SYSCTL ]; then
114 if ! modprobe -q -n $TEST_DRIVER; then
115 echo "$0: module $TEST_DRIVER not found [SKIP]"
116 echo "You must set CONFIG_TEST_SYSCTL=m in your kernel" >&2
117 exit $ksft_skip
118 fi
119 modprobe $TEST_DRIVER
120 if [ $? -ne 0 ]; then
121 echo "$0: modprobe $TEST_DRIVER failed."
122 exit
123 fi
124 fi
125}
126
127reset_vals()
128{
129 VAL=""
130 TRIGGER=$(basename ${TARGET})
131 case "$TRIGGER" in
132 int_0001)
133 VAL="60"
134 ;;
135 int_0002)
136 VAL="1"
137 ;;
138 uint_0001)
139 VAL="314"
140 ;;
141 string_0001)
142 VAL="(none)"
143 ;;
144 bitmap_0001)
145 VAL=""
146 ;;
147 *)
148 ;;
149 esac
150 echo -n $VAL > $TARGET
151}
152
153set_orig()
154{
155 if [ ! -z $TARGET ] && [ ! -z $ORIG ]; then
156 if [ -f ${TARGET} ]; then
157 echo "${ORIG}" > "${TARGET}"
158 fi
159 fi
160}
161
162set_test()
163{
164 echo "${TEST_STR}" > "${TARGET}"
165}
166
167verify()
168{
169 local seen
170 seen=$(cat "$1")
171 if [ "${seen}" != "${TEST_STR}" ]; then
172 return 1
173 fi
174 return 0
175}
176
177# proc files get read a page at a time, which can confuse diff,
178# and get you incorrect results on proc files with long data. To use
179# diff against them you must first extract the output to a file, and
180# then compare against that file.
181verify_diff_proc_file()
182{
183 TMP_DUMP_FILE=$(mktemp)
184 cat $1 > $TMP_DUMP_FILE
185
186 if ! diff -w -q $TMP_DUMP_FILE $2; then
187 return 1
188 else
189 return 0
190 fi
191}
192
193verify_diff_w()
194{
195 echo "$TEST_STR" | diff -q -w -u - $1 > /dev/null
196 return $?
197}
198
199test_rc()
200{
201 if [[ $rc != 0 ]]; then
202 echo "Failed test, return value: $rc" >&2
203 exit $rc
204 fi
205}
206
207test_finish()
208{
209 set_orig
210 rm -f "${TEST_FILE}"
211
212 if [ ! -z ${old_strict} ]; then
213 echo ${old_strict} > ${WRITES_STRICT}
214 fi
215 exit $rc
216}
217
218run_numerictests()
219{
220 echo "== Testing sysctl behavior against ${TARGET} =="
221
222 rc=0
223
224 echo -n "Writing test file ... "
225 echo "${TEST_STR}" > "${TEST_FILE}"
226 if ! verify "${TEST_FILE}"; then
227 echo "FAIL" >&2
228 exit 1
229 else
230 echo "OK"
231 fi
232
233 echo -n "Checking sysctl is not set to test value ... "
234 if verify "${TARGET}"; then
235 echo "FAIL" >&2
236 exit 1
237 else
238 echo "OK"
239 fi
240
241 echo -n "Writing sysctl from shell ... "
242 set_test
243 if ! verify "${TARGET}"; then
244 echo "FAIL" >&2
245 exit 1
246 else
247 echo "OK"
248 fi
249
250 echo -n "Resetting sysctl to original value ... "
251 set_orig
252 if verify "${TARGET}"; then
253 echo "FAIL" >&2
254 exit 1
255 else
256 echo "OK"
257 fi
258
259 # Now that we've validated the sanity of "set_test" and "set_orig",
260 # we can use those functions to set starting states before running
261 # specific behavioral tests.
262
263 echo -n "Writing entire sysctl in single write ... "
264 set_orig
265 dd if="${TEST_FILE}" of="${TARGET}" bs=4096 2>/dev/null
266 if ! verify "${TARGET}"; then
267 echo "FAIL" >&2
268 rc=1
269 else
270 echo "OK"
271 fi
272
273 echo -n "Writing middle of sysctl after synchronized seek ... "
274 set_test
275 dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 skip=1 2>/dev/null
276 if ! verify "${TARGET}"; then
277 echo "FAIL" >&2
278 rc=1
279 else
280 echo "OK"
281 fi
282
283 echo -n "Writing beyond end of sysctl ... "
284 set_orig
285 dd if="${TEST_FILE}" of="${TARGET}" bs=20 seek=2 2>/dev/null
286 if verify "${TARGET}"; then
287 echo "FAIL" >&2
288 rc=1
289 else
290 echo "OK"
291 fi
292
293 echo -n "Writing sysctl with multiple long writes ... "
294 set_orig
295 (perl -e 'print "A" x 50;'; echo "${TEST_STR}") | \
296 dd of="${TARGET}" bs=50 2>/dev/null
297 if verify "${TARGET}"; then
298 echo "FAIL" >&2
299 rc=1
300 else
301 echo "OK"
302 fi
303 test_rc
304}
305
306check_failure()
307{
308 echo -n "Testing that $1 fails as expected ... "
309 reset_vals
310 TEST_STR="$1"
311 orig="$(cat $TARGET)"
312 echo -n "$TEST_STR" > $TARGET 2> /dev/null
313
314 # write should fail and $TARGET should retain its original value
315 if [ $? = 0 ] || [ "$(cat $TARGET)" != "$orig" ]; then
316 echo "FAIL" >&2
317 rc=1
318 else
319 echo "OK"
320 fi
321 test_rc
322}
323
324run_wideint_tests()
325{
326 # sysctl conversion functions receive a boolean sign and ulong
327 # magnitude; here we list the magnitudes we want to test (each of
328 # which will be tested in both positive and negative forms). Since
329 # none of these values fit in 32 bits, writing them to an int- or
330 # uint-typed sysctl should fail.
331 local magnitudes=(
332 # common boundary-condition values (zero, +1, -1, INT_MIN,
333 # and INT_MAX respectively) if truncated to lower 32 bits
334 # (potential for being falsely deemed in range)
335 0x0000000100000000
336 0x0000000100000001
337 0x00000001ffffffff
338 0x0000000180000000
339 0x000000017fffffff
340
341 # these look like negatives, but without a leading '-' are
342 # actually large positives (should be rejected as above
343 # despite being zero/+1/-1/INT_MIN/INT_MAX in the lower 32)
344 0xffffffff00000000
345 0xffffffff00000001
346 0xffffffffffffffff
347 0xffffffff80000000
348 0xffffffff7fffffff
349 )
350
351 for sign in '' '-'; do
352 for mag in "${magnitudes[@]}"; do
353 check_failure "${sign}${mag}"
354 done
355 done
356}
357
358# Your test must accept digits 3 and 4 to use this
359run_limit_digit()
360{
361 echo -n "Checking ignoring spaces up to PAGE_SIZE works on write ... "
362 reset_vals
363
364 LIMIT=$((MAX_DIGITS -1))
365 TEST_STR="3"
366 (perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
367 dd of="${TARGET}" 2>/dev/null
368
369 if ! verify "${TARGET}"; then
370 echo "FAIL" >&2
371 rc=1
372 else
373 echo "OK"
374 fi
375 test_rc
376
377 echo -n "Checking passing PAGE_SIZE of spaces fails on write ... "
378 reset_vals
379
380 LIMIT=$((MAX_DIGITS))
381 TEST_STR="4"
382 (perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
383 dd of="${TARGET}" 2>/dev/null
384
385 if verify "${TARGET}"; then
386 echo "FAIL" >&2
387 rc=1
388 else
389 echo "OK"
390 fi
391 test_rc
392}
393
394# You are using an int
395run_limit_digit_int()
396{
397 echo -n "Testing INT_MAX works ... "
398 reset_vals
399 TEST_STR="$INT_MAX"
400 echo -n $TEST_STR > $TARGET
401
402 if ! verify "${TARGET}"; then
403 echo "FAIL" >&2
404 rc=1
405 else
406 echo "OK"
407 fi
408 test_rc
409
410 echo -n "Testing INT_MAX + 1 will fail as expected ... "
411 reset_vals
412 let TEST_STR=$INT_MAX+1
413 echo -n $TEST_STR > $TARGET 2> /dev/null
414
415 if verify "${TARGET}"; then
416 echo "FAIL" >&2
417 rc=1
418 else
419 echo "OK"
420 fi
421 test_rc
422
423 echo -n "Testing negative values will work as expected ... "
424 reset_vals
425 TEST_STR="-3"
426 echo -n $TEST_STR > $TARGET 2> /dev/null
427 if ! verify "${TARGET}"; then
428 echo "FAIL" >&2
429 rc=1
430 else
431 echo "OK"
432 fi
433 test_rc
434}
435
436# You used an int array
437run_limit_digit_int_array()
438{
439 echo -n "Testing array works as expected ... "
440 TEST_STR="4 3 2 1"
441 echo -n $TEST_STR > $TARGET
442
443 if ! verify_diff_w "${TARGET}"; then
444 echo "FAIL" >&2
445 rc=1
446 else
447 echo "OK"
448 fi
449 test_rc
450
451 echo -n "Testing skipping trailing array elements works ... "
452 # Do not reset_vals, carry on the values from the last test.
453 # If we only echo in two digits the last two are left intact
454 TEST_STR="100 101"
455 echo -n $TEST_STR > $TARGET
456 # After we echo in, to help diff we need to set on TEST_STR what
457 # we expect the result to be.
458 TEST_STR="100 101 2 1"
459
460 if ! verify_diff_w "${TARGET}"; then
461 echo "FAIL" >&2
462 rc=1
463 else
464 echo "OK"
465 fi
466 test_rc
467
468 echo -n "Testing PAGE_SIZE limit on array works ... "
469 # Do not reset_vals, carry on the values from the last test.
470 # Even if you use an int array, you are still restricted to
471 # MAX_DIGITS, this is a known limitation. Test limit works.
472 LIMIT=$((MAX_DIGITS -1))
473 TEST_STR="9"
474 (perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
475 dd of="${TARGET}" 2>/dev/null
476
477 TEST_STR="9 101 2 1"
478 if ! verify_diff_w "${TARGET}"; then
479 echo "FAIL" >&2
480 rc=1
481 else
482 echo "OK"
483 fi
484 test_rc
485
486 echo -n "Testing exceeding PAGE_SIZE limit fails as expected ... "
487 # Do not reset_vals, carry on the values from the last test.
488 # Now go over limit.
489 LIMIT=$((MAX_DIGITS))
490 TEST_STR="7"
491 (perl -e 'print " " x '$LIMIT';'; echo "${TEST_STR}") | \
492 dd of="${TARGET}" 2>/dev/null
493
494 TEST_STR="7 101 2 1"
495 if verify_diff_w "${TARGET}"; then
496 echo "FAIL" >&2
497 rc=1
498 else
499 echo "OK"
500 fi
501 test_rc
502}
503
504# You are using an unsigned int
505run_limit_digit_uint()
506{
507 echo -n "Testing UINT_MAX works ... "
508 reset_vals
509 TEST_STR="$UINT_MAX"
510 echo -n $TEST_STR > $TARGET
511
512 if ! verify "${TARGET}"; then
513 echo "FAIL" >&2
514 rc=1
515 else
516 echo "OK"
517 fi
518 test_rc
519
520 echo -n "Testing UINT_MAX + 1 will fail as expected ... "
521 reset_vals
522 TEST_STR=$(($UINT_MAX+1))
523 echo -n $TEST_STR > $TARGET 2> /dev/null
524
525 if verify "${TARGET}"; then
526 echo "FAIL" >&2
527 rc=1
528 else
529 echo "OK"
530 fi
531 test_rc
532
533 echo -n "Testing negative values will not work as expected ... "
534 reset_vals
535 TEST_STR="-3"
536 echo -n $TEST_STR > $TARGET 2> /dev/null
537
538 if verify "${TARGET}"; then
539 echo "FAIL" >&2
540 rc=1
541 else
542 echo "OK"
543 fi
544 test_rc
545}
546
547run_stringtests()
548{
549 echo -n "Writing entire sysctl in short writes ... "
550 set_orig
551 dd if="${TEST_FILE}" of="${TARGET}" bs=1 2>/dev/null
552 if ! verify "${TARGET}"; then
553 echo "FAIL" >&2
554 rc=1
555 else
556 echo "OK"
557 fi
558
559 echo -n "Writing middle of sysctl after unsynchronized seek ... "
560 set_test
561 dd if="${TEST_FILE}" of="${TARGET}" bs=1 seek=1 2>/dev/null
562 if verify "${TARGET}"; then
563 echo "FAIL" >&2
564 rc=1
565 else
566 echo "OK"
567 fi
568
569 echo -n "Checking sysctl maxlen is at least $MAXLEN ... "
570 set_orig
571 perl -e 'print "A" x ('"${MAXLEN}"'-2), "B";' | \
572 dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
573 if ! grep -q B "${TARGET}"; then
574 echo "FAIL" >&2
575 rc=1
576 else
577 echo "OK"
578 fi
579
580 echo -n "Checking sysctl keeps original string on overflow append ... "
581 set_orig
582 perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
583 dd of="${TARGET}" bs=$(( MAXLEN - 1 )) 2>/dev/null
584 if grep -q B "${TARGET}"; then
585 echo "FAIL" >&2
586 rc=1
587 else
588 echo "OK"
589 fi
590
591 echo -n "Checking sysctl stays NULL terminated on write ... "
592 set_orig
593 perl -e 'print "A" x ('"${MAXLEN}"'-1), "B";' | \
594 dd of="${TARGET}" bs="${MAXLEN}" 2>/dev/null
595 if grep -q B "${TARGET}"; then
596 echo "FAIL" >&2
597 rc=1
598 else
599 echo "OK"
600 fi
601
602 echo -n "Checking sysctl stays NULL terminated on overwrite ... "
603 set_orig
604 perl -e 'print "A" x ('"${MAXLEN}"'-1), "BB";' | \
605 dd of="${TARGET}" bs=$(( $MAXLEN + 1 )) 2>/dev/null
606 if grep -q B "${TARGET}"; then
607 echo "FAIL" >&2
608 rc=1
609 else
610 echo "OK"
611 fi
612
613 test_rc
614}
615
616target_exists()
617{
618 TARGET="${SYSCTL}/$1"
619 TEST_ID="$2"
620
621 if [ ! -f ${TARGET} ] ; then
622 return 0
623 fi
624 return 1
625}
626
627run_bitmaptest() {
628 # Total length of bitmaps string to use, a bit under
629 # the maximum input size of the test node
630 LENGTH=$((RANDOM % 65000))
631
632 # First bit to set
633 BIT=$((RANDOM % 1024))
634
635 # String containing our list of bits to set
636 TEST_STR=$BIT
637
638 # build up the string
639 while [ "${#TEST_STR}" -le "$LENGTH" ]; do
640 # Make sure next entry is discontiguous,
641 # skip ahead at least 2
642 BIT=$((BIT + $((2 + RANDOM % 10))))
643
644 # Add new bit to the list
645 TEST_STR="${TEST_STR},${BIT}"
646
647 # Randomly make it a range
648 if [ "$((RANDOM % 2))" -eq "1" ]; then
649 RANGE_END=$((BIT + $((1 + RANDOM % 10))))
650 TEST_STR="${TEST_STR}-${RANGE_END}"
651 BIT=$RANGE_END
652 fi
653 done
654
655 echo -n "Checking bitmap handler ... "
656 TEST_FILE=$(mktemp)
657 echo -n "$TEST_STR" > $TEST_FILE
658
659 cat $TEST_FILE > $TARGET 2> /dev/null
660 if [ $? -ne 0 ]; then
661 echo "FAIL" >&2
662 rc=1
663 test_rc
664 fi
665
666 if ! verify_diff_proc_file "$TARGET" "$TEST_FILE"; then
667 echo "FAIL" >&2
668 rc=1
669 else
670 echo "OK"
671 rc=0
672 fi
673 test_rc
674}
675
676sysctl_test_0001()
677{
678 TARGET="${SYSCTL}/$(get_test_target 0001)"
679 reset_vals
680 ORIG=$(cat "${TARGET}")
681 TEST_STR=$(( $ORIG + 1 ))
682
683 run_numerictests
684 run_wideint_tests
685 run_limit_digit
686}
687
688sysctl_test_0002()
689{
690 TARGET="${SYSCTL}/$(get_test_target 0002)"
691 reset_vals
692 ORIG=$(cat "${TARGET}")
693 TEST_STR="Testing sysctl"
694 # Only string sysctls support seeking/appending.
695 MAXLEN=65
696
697 run_numerictests
698 run_stringtests
699}
700
701sysctl_test_0003()
702{
703 TARGET="${SYSCTL}/$(get_test_target 0003)"
704 reset_vals
705 ORIG=$(cat "${TARGET}")
706 TEST_STR=$(( $ORIG + 1 ))
707
708 run_numerictests
709 run_wideint_tests
710 run_limit_digit
711 run_limit_digit_int
712}
713
714sysctl_test_0004()
715{
716 TARGET="${SYSCTL}/$(get_test_target 0004)"
717 reset_vals
718 ORIG=$(cat "${TARGET}")
719 TEST_STR=$(( $ORIG + 1 ))
720
721 run_numerictests
722 run_wideint_tests
723 run_limit_digit
724 run_limit_digit_uint
725}
726
727sysctl_test_0005()
728{
729 TARGET="${SYSCTL}/$(get_test_target 0005)"
730 reset_vals
731 ORIG=$(cat "${TARGET}")
732
733 run_limit_digit_int_array
734}
735
736sysctl_test_0006()
737{
738 TARGET="${SYSCTL}/$(get_test_target 0006)"
739 reset_vals
740 ORIG=""
741 run_bitmaptest
742}
743
744sysctl_test_0007()
745{
746 TARGET="${SYSCTL}/$(get_test_target 0007)"
747 echo -n "Testing if $TARGET is set to 1 ... "
748
749 if [ ! -f $TARGET ]; then
750 echo -e "SKIPPING\n$TARGET is not present"
751 return $ksft_skip
752 fi
753
754 if [ -d $DIR ]; then
755 echo -e "SKIPPING\nTest only possible if sysctl_test is built-in, not module:"
756 cat $TEST_DIR/config >&2
757 return $ksft_skip
758 fi
759
760 ORIG=$(cat "${TARGET}")
761
762 if [ x$ORIG = "x1" ]; then
763 echo "OK"
764 return 0
765 fi
766
767 if [ ! -f /proc/cmdline ]; then
768 echo -e "SKIPPING\nThere is no /proc/cmdline to check for parameter"
769 return $ksft_skip
770 fi
771
772 FOUND=$(grep -c "sysctl[./]debug[./]test_sysctl[./]boot_int=1" /proc/cmdline)
773 if [ $FOUND = "1" ]; then
774 echo -e "FAIL\nKernel param found but $TARGET is not 1." >&2
775 rc=1
776 test_rc
777 fi
778
779 echo -e "SKIPPING\nExpected kernel parameter missing."
780 echo "Kernel must be booted with parameter: sysctl.debug.test_sysctl.boot_int=1"
781 return $ksft_skip
782}
783
784sysctl_test_0008()
785{
786 TARGET="${SYSCTL}/$(get_test_target 0008)"
787 echo -n "Testing if $TARGET is matched in kernel ... "
788
789 if [ ! -f $TARGET ]; then
790 echo -e "SKIPPING\n$TARGET is not present"
791 return $ksft_skip
792 fi
793
794 ORIG_VALUE=$(cat "${TARGET}")
795
796 if [ $ORIG_VALUE -ne 1 ]; then
797 echo "FAIL" >&2
798 rc=1
799 test_rc
800 fi
801
802 echo "OK"
803 return 0
804}
805
806sysctl_test_0009()
807{
808 TARGET="${SYSCTL}/$(get_test_target 0009)"
809 echo -n "Testing if $TARGET unregistered correctly ... "
810 if [ -d $TARGET ]; then
811 echo "FAIL" >&2
812 rc=1
813 test_rc
814 fi
815
816 echo "OK"
817 return 0
818}
819
820sysctl_test_0010()
821{
822 TARGET="${SYSCTL}/$(get_test_target 0010)"
823 echo -n "Testing that $TARGET was not created ... "
824 if [ -d $TARGET ]; then
825 echo "FAIL" >&2
826 rc=1
827 test_rc
828 fi
829
830 echo "OK"
831 return 0
832}
833
834sysctl_test_0011()
835{
836 TARGET="${SYSCTL}/$(get_test_target 0011)"
837 echo -n "Testing empty dir handling in ${TARGET} ... "
838 if [ ! -d ${TARGET} ]; then
839 echo -e "FAIL\nCould not create ${TARGET}" >&2
840 rc=1
841 test_rc
842 fi
843
844 TARGET2="${TARGET}/empty"
845 if [ ! -d ${TARGET2} ]; then
846 echo -e "FAIL\nCould not create ${TARGET2}" >&2
847 rc=1
848 test_rc
849 fi
850
851 echo "OK"
852 return 0
853}
854
855sysctl_test_0012()
856{
857 TARGET="${SYSCTL}/$(get_test_target 0012)"
858 echo -n "Testing u8 range check in sysctl table check in ${TARGET} ... "
859 if [ ! -f ${TARGET} ]; then
860 echo -e "FAIL\nCould not create ${TARGET}" >&2
861 rc=1
862 test_rc
863 fi
864
865 local u8over_msg=$(dmesg | grep "u8_over range value" | wc -l)
866 if [ ! ${u8over_msg} -eq 1 ]; then
867 echo -e "FAIL\nu8 overflow not detected" >&2
868 rc=1
869 test_rc
870 fi
871
872 local u8under_msg=$(dmesg | grep "u8_under range value" | wc -l)
873 if [ ! ${u8under_msg} -eq 1 ]; then
874 echo -e "FAIL\nu8 underflow not detected" >&2
875 rc=1
876 test_rc
877 fi
878
879 echo "OK"
880 return 0
881}
882
883list_tests()
884{
885 echo "Test ID list:"
886 echo
887 echo "TEST_ID x NUM_TEST"
888 echo "TEST_ID: Test ID"
889 echo "NUM_TESTS: Recommended number of times to run the test"
890 echo
891 echo "0001 x $(get_test_count 0001) - tests proc_dointvec_minmax()"
892 echo "0002 x $(get_test_count 0002) - tests proc_dostring()"
893 echo "0003 x $(get_test_count 0003) - tests proc_dointvec()"
894 echo "0004 x $(get_test_count 0004) - tests proc_douintvec()"
895 echo "0005 x $(get_test_count 0005) - tests proc_douintvec() array"
896 echo "0006 x $(get_test_count 0006) - tests proc_do_large_bitmap()"
897 echo "0007 x $(get_test_count 0007) - tests setting sysctl from kernel boot param"
898 echo "0008 x $(get_test_count 0008) - tests sysctl macro values match"
899 echo "0009 x $(get_test_count 0009) - tests sysct unregister"
900 echo "0010 x $(get_test_count 0010) - tests sysct mount point"
901 echo "0011 x $(get_test_count 0011) - tests empty directories"
902 echo "0012 x $(get_test_count 0012) - tests range check for u8 proc_handler"
903}
904
905usage()
906{
907 NUM_TESTS=$(grep -o ' ' <<<"$ALL_TESTS" | grep -c .)
908 let NUM_TESTS=$NUM_TESTS+1
909 MAX_TEST=$(printf "%04d\n" $NUM_TESTS)
910 echo "Usage: $0 [ -t <4-number-digit> ] | [ -w <4-number-digit> ] |"
911 echo " [ -s <4-number-digit> ] | [ -c <4-number-digit> <test- count>"
912 echo " [ all ] [ -h | --help ] [ -l ]"
913 echo ""
914 echo "Valid tests: 0001-$MAX_TEST"
915 echo ""
916 echo " all Runs all tests (default)"
917 echo " -t Run test ID the recommended number of times"
918 echo " -w Watch test ID run until it runs into an error"
919 echo " -c Run test ID once"
920 echo " -s Run test ID x test-count number of times"
921 echo " -l List all test ID list"
922 echo " -h|--help Help"
923 echo
924 echo "If an error every occurs execution will immediately terminate."
925 echo "If you are adding a new test try using -w <test-ID> first to"
926 echo "make sure the test passes a series of tests."
927 echo
928 echo Example uses:
929 echo
930 echo "$TEST_NAME.sh -- executes all tests"
931 echo "$TEST_NAME.sh -t 0002 -- Executes test ID 0002 the recommended number of times"
932 echo "$TEST_NAME.sh -w 0002 -- Watch test ID 0002 run until an error occurs"
933 echo "$TEST_NAME.sh -s 0002 -- Run test ID 0002 once"
934 echo "$TEST_NAME.sh -c 0002 3 -- Run test ID 0002 three times"
935 echo
936 list_tests
937 exit 1
938}
939
940function test_num()
941{
942 re='^[0-9]+$'
943 if ! [[ $1 =~ $re ]]; then
944 usage
945 fi
946}
947function remove_leading_zeros()
948{
949 echo $1 | sed 's/^0*//'
950}
951
952function get_test_count()
953{
954 test_num $1
955 awk_field=$(remove_leading_zeros $1)
956 TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
957 echo ${TEST_DATA} | awk -F":" '{print $2}'
958}
959
960function get_test_enabled()
961{
962 test_num $1
963 awk_field=$(remove_leading_zeros $1)
964 TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
965 echo ${TEST_DATA} | awk -F":" '{print $3}'
966}
967
968function get_test_target()
969{
970 test_num $1
971 awk_field=$(remove_leading_zeros $1)
972 TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
973 echo ${TEST_DATA} | awk -F":" '{print $4}'
974}
975
976function get_test_skip_no_target()
977{
978 test_num $1
979 awk_field=$(remove_leading_zeros $1)
980 TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$awk_field'}')
981 echo ${TEST_DATA} | awk -F":" '{print $5}'
982}
983
984function skip_test()
985{
986 TEST_ID=$1
987 TEST_TARGET=$2
988 if target_exists $TEST_TARGET $TEST_ID; then
989 TEST_SKIP=$(get_test_skip_no_target $TEST_ID)
990 if [[ $TEST_SKIP -eq "1" ]]; then
991 echo "Target $TEST_TARGET for test $TEST_ID does not exist ... SKIPPING"
992 return 0
993 fi
994 fi
995 return 1
996}
997
998function run_all_tests()
999{
1000 for i in $ALL_TESTS ; do
1001 TEST_ID=${i%:*:*:*:*}
1002 ENABLED=$(get_test_enabled $TEST_ID)
1003 TEST_COUNT=$(get_test_count $TEST_ID)
1004 TEST_TARGET=$(get_test_target $TEST_ID)
1005
1006 if [[ $ENABLED -eq "1" ]]; then
1007 test_case $TEST_ID $TEST_COUNT $TEST_TARGET
1008 fi
1009 done
1010}
1011
1012function watch_log()
1013{
1014 if [ $# -ne 3 ]; then
1015 clear
1016 fi
1017 date
1018 echo "Running test: $2 - run #$1"
1019}
1020
1021function watch_case()
1022{
1023 i=0
1024 while [ 1 ]; do
1025
1026 if [ $# -eq 1 ]; then
1027 test_num $1
1028 watch_log $i ${TEST_NAME}_test_$1
1029 ${TEST_NAME}_test_$1
1030 else
1031 watch_log $i all
1032 run_all_tests
1033 fi
1034 let i=$i+1
1035 done
1036}
1037
1038function test_case()
1039{
1040 TEST_ID=$1
1041 NUM_TESTS=$2
1042 TARGET=$3
1043
1044 if skip_test $TEST_ID $TARGET; then
1045 return
1046 fi
1047
1048 i=0
1049 while [ $i -lt $NUM_TESTS ]; do
1050 test_num $TEST_ID
1051 watch_log $i ${TEST_NAME}_test_${TEST_ID} noclear
1052 RUN_TEST=${TEST_NAME}_test_${TEST_ID}
1053 $RUN_TEST
1054 let i=$i+1
1055 done
1056}
1057
1058function parse_args()
1059{
1060 if [ $# -eq 0 ]; then
1061 run_all_tests
1062 else
1063 if [[ "$1" = "all" ]]; then
1064 run_all_tests
1065 elif [[ "$1" = "-w" ]]; then
1066 shift
1067 watch_case $@
1068 elif [[ "$1" = "-t" ]]; then
1069 shift
1070 test_num $1
1071 test_case $1 $(get_test_count $1) $(get_test_target $1)
1072 elif [[ "$1" = "-c" ]]; then
1073 shift
1074 test_num $1
1075 test_num $2
1076 test_case $1 $2 $(get_test_target $1)
1077 elif [[ "$1" = "-s" ]]; then
1078 shift
1079 test_case $1 1 $(get_test_target $1)
1080 elif [[ "$1" = "-l" ]]; then
1081 list_tests
1082 elif [[ "$1" = "-h" || "$1" = "--help" ]]; then
1083 usage
1084 else
1085 usage
1086 fi
1087 fi
1088}
1089
1090test_reqs
1091allow_user_defaults
1092check_production_sysctl_writes_strict
1093load_req_mod
1094
1095trap "test_finish" EXIT
1096
1097parse_args $@
1098
1099exit 0