1 #!/bin/bash 2 # Copyright (C) 2017 Luis R. Rodriguez <mcgrof (at] 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" 34 ALL_TESTS="$ALL_TESTS 0003:1:1" 35 ALL_TESTS="$ALL_TESTS 0004:1:1" 36 ALL_TESTS="$ALL_TESTS 0005:3:1" 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 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 88 if [ -z $INT_MAX ]; then 89 INT_MAX=$(getconf INT_MAX) 90 fi 91 if [ -z $UINT_MAX ]; then 92 UINT_MAX=$(getconf UINT_MAX) 93 fi 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 108 if ! which getconf 2> /dev/null > /dev/null; then 109 echo "$0: You need getconf installed" 110 exit 1 111 fi 112 if ! which diff 2> /dev/null > /dev/null; then 113 echo "$0: You need diff installed" 114 exit 1 115 fi 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 130 reset_vals() 131 { 132 VAL="" 133 TRIGGER=$(basename ${TARGET}) 134 case "$TRIGGER" in 135 int_0001) 136 VAL="60" 137 ;; 138 int_0002) 139 VAL="1" 140 ;; 141 uint_0001) 142 VAL="314" 143 ;; 144 string_0001) 145 VAL="(none)" 146 ;; 147 *) 148 ;; 149 esac 150 echo -n $VAL > $TARGET 151 } 152 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 175 verify_diff_w() 176 { 177 echo "$TEST_STR" | diff -q -w -u - $1 178 return $? 179 } 180 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 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 293 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 321 test_rc 322 } 323 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 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 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 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" 549 reset_vals 550 ORIG=$(cat "${TARGET}") 551 TEST_STR=$(( $ORIG + 1 )) 552 553 run_numerictests 554 run_limit_digit 555 } 556 557 sysctl_test_0002() 558 { 559 TARGET="${SYSCTL}/string_0001" 560 reset_vals 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 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 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 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 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()" 613 echo "0003 x $(get_test_count 0003) - tests proc_dointvec()" 614 echo "0004 x $(get_test_count 0004) - tests proc_douintvec()" 615 echo "0005 x $(get_test_count 0005) - tests proc_douintvec() array" 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 775
