kmod: throttle kmod thread limit
[muen/linux.git] / tools / testing / selftests / kmod / kmod.sh
1 #!/bin/bash
2 #
3 # Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
4 #
5 # This program is free software; you can redistribute it and/or modify it
6 # under the terms of the GNU General Public License as published by the Free
7 # Software Foundation; either version 2 of the License, or at your option any
8 # later version; or, when distributed separately from the Linux kernel or
9 # when incorporated into other software packages, subject to the following
10 # license:
11 #
12 # This program is free software; you can redistribute it and/or modify it
13 # under the terms of copyleft-next (version 0.3.1 or later) as published
14 # at http://copyleft-next.org/.
15
16 # This is a stress test script for kmod, the kernel module loader. It uses
17 # test_kmod which exposes a series of knobs for the API for us so we can
18 # tweak each test in userspace rather than in kernelspace.
19 #
20 # The way kmod works is it uses the kernel's usermode helper API to eventually
21 # call /sbin/modprobe. It has a limit of the number of concurrent calls
22 # possible. The kernel interface to load modules is request_module(), however
23 # mount uses get_fs_type(). Both behave slightly differently, but the
24 # differences are important enough to test each call separately. For this
25 # reason test_kmod starts by providing tests for both calls.
26 #
27 # The test driver test_kmod assumes a series of defaults which you can
28 # override by exporting to your environment prior running this script.
29 # For instance this script assumes you do not have xfs loaded upon boot.
30 # If this is false, export DEFAULT_KMOD_FS="ext4" prior to running this
31 # script if the filesyste module you don't have loaded upon bootup
32 # is ext4 instead. Refer to allow_user_defaults() for a list of user
33 # override variables possible.
34 #
35 # You'll want at least 4 GiB of RAM to expect to run these tests
36 # without running out of memory on them. For other requirements refer
37 # to test_reqs()
38
39 set -e
40
41 TEST_NAME="kmod"
42 TEST_DRIVER="test_${TEST_NAME}"
43 TEST_DIR=$(dirname $0)
44
45 # This represents
46 #
47 # TEST_ID:TEST_COUNT:ENABLED
48 #
49 # TEST_ID: is the test id number
50 # TEST_COUNT: number of times we should run the test
51 # ENABLED: 1 if enabled, 0 otherwise
52 #
53 # Once these are enabled please leave them as-is. Write your own test,
54 # we have tons of space.
55 ALL_TESTS="0001:3:1"
56 ALL_TESTS="$ALL_TESTS 0002:3:1"
57 ALL_TESTS="$ALL_TESTS 0003:1:1"
58 ALL_TESTS="$ALL_TESTS 0004:1:1"
59 ALL_TESTS="$ALL_TESTS 0005:10:1"
60 ALL_TESTS="$ALL_TESTS 0006:10:1"
61 ALL_TESTS="$ALL_TESTS 0007:5:1"
62 ALL_TESTS="$ALL_TESTS 0008:150:1"
63 ALL_TESTS="$ALL_TESTS 0009:150:1"
64
65 test_modprobe()
66 {
67        if [ ! -d $DIR ]; then
68                echo "$0: $DIR not present" >&2
69                echo "You must have the following enabled in your kernel:" >&2
70                cat $TEST_DIR/config >&2
71                exit 1
72        fi
73 }
74
75 function allow_user_defaults()
76 {
77         if [ -z $DEFAULT_KMOD_DRIVER ]; then
78                 DEFAULT_KMOD_DRIVER="test_module"
79         fi
80
81         if [ -z $DEFAULT_KMOD_FS ]; then
82                 DEFAULT_KMOD_FS="xfs"
83         fi
84
85         if [ -z $PROC_DIR ]; then
86                 PROC_DIR="/proc/sys/kernel/"
87         fi
88
89         if [ -z $MODPROBE_LIMIT ]; then
90                 MODPROBE_LIMIT=50
91         fi
92
93         if [ -z $DIR ]; then
94                 DIR="/sys/devices/virtual/misc/${TEST_DRIVER}0/"
95         fi
96
97         if [ -z $DEFAULT_NUM_TESTS ]; then
98                 DEFAULT_NUM_TESTS=150
99         fi
100
101         MODPROBE_LIMIT_FILE="${PROC_DIR}/kmod-limit"
102 }
103
104 test_reqs()
105 {
106         if ! which modprobe 2> /dev/null > /dev/null; then
107                 echo "$0: You need modprobe installed" >&2
108                 exit 1
109         fi
110
111         if ! which kmod 2> /dev/null > /dev/null; then
112                 echo "$0: You need kmod installed" >&2
113                 exit 1
114         fi
115
116         # kmod 19 has a bad bug where it returns 0 when modprobe
117         # gets called *even* if the module was not loaded due to
118         # some bad heuristics. For details see:
119         #
120         # A work around is possible in-kernel but its rather
121         # complex.
122         KMOD_VERSION=$(kmod --version | awk '{print $3}')
123         if [[ $KMOD_VERSION  -le 19 ]]; then
124                 echo "$0: You need at least kmod 20" >&2
125                 echo "kmod <= 19 is buggy, for details see:" >&2
126                 echo "http://git.kernel.org/cgit/utils/kernel/kmod/kmod.git/commit/libkmod/libkmod-module.c?id=fd44a98ae2eb5eb32161088954ab21e58e19dfc4" >&2
127                 exit 1
128         fi
129
130         uid=$(id -u)
131         if [ $uid -ne 0 ]; then
132                 echo $msg must be run as root >&2
133                 exit 0
134         fi
135 }
136
137 function load_req_mod()
138 {
139         trap "test_modprobe" EXIT
140
141         if [ ! -d $DIR ]; then
142                 # Alanis: "Oh isn't it ironic?"
143                 modprobe $TEST_DRIVER
144         fi
145 }
146
147 test_finish()
148 {
149         echo "Test completed"
150 }
151
152 errno_name_to_val()
153 {
154         case "$1" in
155         # kmod calls modprobe and upon of a module not found
156         # modprobe returns just 1... However in the kernel we
157         # *sometimes* see 256...
158         MODULE_NOT_FOUND)
159                 echo 256;;
160         SUCCESS)
161                 echo 0;;
162         -EPERM)
163                 echo -1;;
164         -ENOENT)
165                 echo -2;;
166         -EINVAL)
167                 echo -22;;
168         -ERR_ANY)
169                 echo -123456;;
170         *)
171                 echo invalid;;
172         esac
173 }
174
175 errno_val_to_name()
176         case "$1" in
177         256)
178                 echo MODULE_NOT_FOUND;;
179         0)
180                 echo SUCCESS;;
181         -1)
182                 echo -EPERM;;
183         -2)
184                 echo -ENOENT;;
185         -22)
186                 echo -EINVAL;;
187         -123456)
188                 echo -ERR_ANY;;
189         *)
190                 echo invalid;;
191         esac
192
193 config_set_test_case_driver()
194 {
195         if ! echo -n 1 >$DIR/config_test_case; then
196                 echo "$0: Unable to set to test case to driver" >&2
197                 exit 1
198         fi
199 }
200
201 config_set_test_case_fs()
202 {
203         if ! echo -n 2 >$DIR/config_test_case; then
204                 echo "$0: Unable to set to test case to fs" >&2
205                 exit 1
206         fi
207 }
208
209 config_num_threads()
210 {
211         if ! echo -n $1 >$DIR/config_num_threads; then
212                 echo "$0: Unable to set to number of threads" >&2
213                 exit 1
214         fi
215 }
216
217 config_get_modprobe_limit()
218 {
219         if [[ -f ${MODPROBE_LIMIT_FILE} ]] ; then
220                 MODPROBE_LIMIT=$(cat $MODPROBE_LIMIT_FILE)
221         fi
222         echo $MODPROBE_LIMIT
223 }
224
225 config_num_thread_limit_extra()
226 {
227         MODPROBE_LIMIT=$(config_get_modprobe_limit)
228         let EXTRA_LIMIT=$MODPROBE_LIMIT+$1
229         config_num_threads $EXTRA_LIMIT
230 }
231
232 # For special characters use printf directly,
233 # refer to kmod_test_0001
234 config_set_driver()
235 {
236         if ! echo -n $1 >$DIR/config_test_driver; then
237                 echo "$0: Unable to set driver" >&2
238                 exit 1
239         fi
240 }
241
242 config_set_fs()
243 {
244         if ! echo -n $1 >$DIR/config_test_fs; then
245                 echo "$0: Unable to set driver" >&2
246                 exit 1
247         fi
248 }
249
250 config_get_driver()
251 {
252         cat $DIR/config_test_driver
253 }
254
255 config_get_test_result()
256 {
257         cat $DIR/test_result
258 }
259
260 config_reset()
261 {
262         if ! echo -n "1" >"$DIR"/reset; then
263                 echo "$0: reset shuld have worked" >&2
264                 exit 1
265         fi
266 }
267
268 config_show_config()
269 {
270         echo "----------------------------------------------------"
271         cat "$DIR"/config
272         echo "----------------------------------------------------"
273 }
274
275 config_trigger()
276 {
277         if ! echo -n "1" >"$DIR"/trigger_config 2>/dev/null; then
278                 echo "$1: FAIL - loading should have worked"
279                 config_show_config
280                 exit 1
281         fi
282         echo "$1: OK! - loading kmod test"
283 }
284
285 config_trigger_want_fail()
286 {
287         if echo "1" > $DIR/trigger_config 2>/dev/null; then
288                 echo "$1: FAIL - test case was expected to fail"
289                 config_show_config
290                 exit 1
291         fi
292         echo "$1: OK! - kmod test case failed as expected"
293 }
294
295 config_expect_result()
296 {
297         RC=$(config_get_test_result)
298         RC_NAME=$(errno_val_to_name $RC)
299
300         ERRNO_NAME=$2
301         ERRNO=$(errno_name_to_val $ERRNO_NAME)
302
303         if [[ $ERRNO_NAME = "-ERR_ANY" ]]; then
304                 if [[ $RC -ge 0 ]]; then
305                         echo "$1: FAIL, test expects $ERRNO_NAME - got $RC_NAME ($RC)" >&2
306                         config_show_config
307                         exit 1
308                 fi
309         elif [[ $RC != $ERRNO ]]; then
310                 echo "$1: FAIL, test expects $ERRNO_NAME ($ERRNO) - got $RC_NAME ($RC)" >&2
311                 config_show_config
312                 exit 1
313         fi
314         echo "$1: OK! - Return value: $RC ($RC_NAME), expected $ERRNO_NAME"
315 }
316
317 kmod_defaults_driver()
318 {
319         config_reset
320         modprobe -r $DEFAULT_KMOD_DRIVER
321         config_set_driver $DEFAULT_KMOD_DRIVER
322 }
323
324 kmod_defaults_fs()
325 {
326         config_reset
327         modprobe -r $DEFAULT_KMOD_FS
328         config_set_fs $DEFAULT_KMOD_FS
329         config_set_test_case_fs
330 }
331
332 kmod_test_0001_driver()
333 {
334         NAME='\000'
335
336         kmod_defaults_driver
337         config_num_threads 1
338         printf '\000' >"$DIR"/config_test_driver
339         config_trigger ${FUNCNAME[0]}
340         config_expect_result ${FUNCNAME[0]} MODULE_NOT_FOUND
341 }
342
343 kmod_test_0001_fs()
344 {
345         NAME='\000'
346
347         kmod_defaults_fs
348         config_num_threads 1
349         printf '\000' >"$DIR"/config_test_fs
350         config_trigger ${FUNCNAME[0]}
351         config_expect_result ${FUNCNAME[0]} -EINVAL
352 }
353
354 kmod_test_0001()
355 {
356         kmod_test_0001_driver
357         kmod_test_0001_fs
358 }
359
360 kmod_test_0002_driver()
361 {
362         NAME="nope-$DEFAULT_KMOD_DRIVER"
363
364         kmod_defaults_driver
365         config_set_driver $NAME
366         config_num_threads 1
367         config_trigger ${FUNCNAME[0]}
368         config_expect_result ${FUNCNAME[0]} MODULE_NOT_FOUND
369 }
370
371 kmod_test_0002_fs()
372 {
373         NAME="nope-$DEFAULT_KMOD_FS"
374
375         kmod_defaults_fs
376         config_set_fs $NAME
377         config_trigger ${FUNCNAME[0]}
378         config_expect_result ${FUNCNAME[0]} -EINVAL
379 }
380
381 kmod_test_0002()
382 {
383         kmod_test_0002_driver
384         kmod_test_0002_fs
385 }
386
387 kmod_test_0003()
388 {
389         kmod_defaults_fs
390         config_num_threads 1
391         config_trigger ${FUNCNAME[0]}
392         config_expect_result ${FUNCNAME[0]} SUCCESS
393 }
394
395 kmod_test_0004()
396 {
397         kmod_defaults_fs
398         config_num_threads 2
399         config_trigger ${FUNCNAME[0]}
400         config_expect_result ${FUNCNAME[0]} SUCCESS
401 }
402
403 kmod_test_0005()
404 {
405         kmod_defaults_driver
406         config_trigger ${FUNCNAME[0]}
407         config_expect_result ${FUNCNAME[0]} SUCCESS
408 }
409
410 kmod_test_0006()
411 {
412         kmod_defaults_fs
413         config_trigger ${FUNCNAME[0]}
414         config_expect_result ${FUNCNAME[0]} SUCCESS
415 }
416
417 kmod_test_0007()
418 {
419         kmod_test_0005
420         kmod_test_0006
421 }
422
423 kmod_test_0008()
424 {
425         kmod_defaults_driver
426         MODPROBE_LIMIT=$(config_get_modprobe_limit)
427         let EXTRA=$MODPROBE_LIMIT/6
428         config_num_thread_limit_extra $EXTRA
429         config_trigger ${FUNCNAME[0]}
430         config_expect_result ${FUNCNAME[0]} SUCCESS
431 }
432
433 kmod_test_0009()
434 {
435         kmod_defaults_fs
436         MODPROBE_LIMIT=$(config_get_modprobe_limit)
437         let EXTRA=$MODPROBE_LIMIT/4
438         config_num_thread_limit_extra $EXTRA
439         config_trigger ${FUNCNAME[0]}
440         config_expect_result ${FUNCNAME[0]} SUCCESS
441 }
442
443 list_tests()
444 {
445         echo "Test ID list:"
446         echo
447         echo "TEST_ID x NUM_TEST"
448         echo "TEST_ID:   Test ID"
449         echo "NUM_TESTS: Number of recommended times to run the test"
450         echo
451         echo "0001 x $(get_test_count 0001) - Simple test - 1 thread  for empty string"
452         echo "0002 x $(get_test_count 0002) - Simple test - 1 thread  for modules/filesystems that do not exist"
453         echo "0003 x $(get_test_count 0003) - Simple test - 1 thread  for get_fs_type() only"
454         echo "0004 x $(get_test_count 0004) - Simple test - 2 threads for get_fs_type() only"
455         echo "0005 x $(get_test_count 0005) - multithreaded tests with default setup - request_module() only"
456         echo "0006 x $(get_test_count 0006) - multithreaded tests with default setup - get_fs_type() only"
457         echo "0007 x $(get_test_count 0007) - multithreaded tests with default setup test request_module() and get_fs_type()"
458         echo "0008 x $(get_test_count 0008) - multithreaded - push kmod_concurrent over max_modprobes for request_module()"
459         echo "0009 x $(get_test_count 0009) - multithreaded - push kmod_concurrent over max_modprobes for get_fs_type()"
460 }
461
462 usage()
463 {
464         NUM_TESTS=$(grep -o ' ' <<<"$ALL_TESTS" | grep -c .)
465         let NUM_TESTS=$NUM_TESTS+1
466         MAX_TEST=$(printf "%04d\n" $NUM_TESTS)
467         echo "Usage: $0 [ -t <4-number-digit> ] | [ -w <4-number-digit> ] |"
468         echo "           [ -s <4-number-digit> ] | [ -c <4-number-digit> <test- count>"
469         echo "           [ all ] [ -h | --help ] [ -l ]"
470         echo ""
471         echo "Valid tests: 0001-$MAX_TEST"
472         echo ""
473         echo "    all     Runs all tests (default)"
474         echo "    -t      Run test ID the number amount of times is recommended"
475         echo "    -w      Watch test ID run until it runs into an error"
476         echo "    -c      Run test ID once"
477         echo "    -s      Run test ID x test-count number of times"
478         echo "    -l      List all test ID list"
479         echo " -h|--help  Help"
480         echo
481         echo "If an error every occurs execution will immediately terminate."
482         echo "If you are adding a new test try using -w <test-ID> first to"
483         echo "make sure the test passes a series of tests."
484         echo
485         echo Example uses:
486         echo
487         echo "${TEST_NAME}.sh           -- executes all tests"
488         echo "${TEST_NAME}.sh -t 0008   -- Executes test ID 0008 number of times is recomended"
489         echo "${TEST_NAME}.sh -w 0008   -- Watch test ID 0008 run until an error occurs"
490         echo "${TEST_NAME}.sh -s 0008   -- Run test ID 0008 once"
491         echo "${TEST_NAME}.sh -c 0008 3 -- Run test ID 0008 three times"
492         echo
493         list_tests
494         exit 1
495 }
496
497 function test_num()
498 {
499         re='^[0-9]+$'
500         if ! [[ $1 =~ $re ]]; then
501                 usage
502         fi
503 }
504
505 function get_test_count()
506 {
507         test_num $1
508         TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
509         LAST_TWO=${TEST_DATA#*:*}
510         echo ${LAST_TWO%:*}
511 }
512
513 function get_test_enabled()
514 {
515         test_num $1
516         TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
517         echo ${TEST_DATA#*:*:}
518 }
519
520 function run_all_tests()
521 {
522         for i in $ALL_TESTS ; do
523                 TEST_ID=${i%:*:*}
524                 ENABLED=$(get_test_enabled $TEST_ID)
525                 TEST_COUNT=$(get_test_count $TEST_ID)
526                 if [[ $ENABLED -eq "1" ]]; then
527                         test_case $TEST_ID $TEST_COUNT
528                 fi
529         done
530 }
531
532 function watch_log()
533 {
534         if [ $# -ne 3 ]; then
535                 clear
536         fi
537         date
538         echo "Running test: $2 - run #$1"
539 }
540
541 function watch_case()
542 {
543         i=0
544         while [ 1 ]; do
545
546                 if [ $# -eq 1 ]; then
547                         test_num $1
548                         watch_log $i ${TEST_NAME}_test_$1
549                         ${TEST_NAME}_test_$1
550                 else
551                         watch_log $i all
552                         run_all_tests
553                 fi
554                 let i=$i+1
555         done
556 }
557
558 function test_case()
559 {
560         NUM_TESTS=$DEFAULT_NUM_TESTS
561         if [ $# -eq 2 ]; then
562                 NUM_TESTS=$2
563         fi
564
565         i=0
566         while [ $i -lt $NUM_TESTS ]; do
567                 test_num $1
568                 watch_log $i ${TEST_NAME}_test_$1 noclear
569                 RUN_TEST=${TEST_NAME}_test_$1
570                 $RUN_TEST
571                 let i=$i+1
572         done
573 }
574
575 function parse_args()
576 {
577         if [ $# -eq 0 ]; then
578                 run_all_tests
579         else
580                 if [[ "$1" = "all" ]]; then
581                         run_all_tests
582                 elif [[ "$1" = "-w" ]]; then
583                         shift
584                         watch_case $@
585                 elif [[ "$1" = "-t" ]]; then
586                         shift
587                         test_num $1
588                         test_case $1 $(get_test_count $1)
589                 elif [[ "$1" = "-c" ]]; then
590                         shift
591                         test_num $1
592                         test_num $2
593                         test_case $1 $2
594                 elif [[ "$1" = "-s" ]]; then
595                         shift
596                         test_case $1 1
597                 elif [[ "$1" = "-l" ]]; then
598                         list_tests
599                 elif [[ "$1" = "-h" || "$1" = "--help" ]]; then
600                         usage
601                 else
602                         usage
603                 fi
604         fi
605 }
606
607 test_reqs
608 allow_user_defaults
609 load_req_mod
610
611 trap "test_finish" EXIT
612
613 parse_args $@
614
615 exit 0