tools/testing/selftests/sysctl/sysctl.sh

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