iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'akpm' (patches from Andrew)

Browse Source 
Merge even more updates from Andrew Morton:

 - a few leftovers

 - fault-injector rework

 - add a module loader test driver

* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
  kmod: throttle kmod thread limit
  kmod: add test driver to stress test the module loader
  MAINTAINERS: give kmod some maintainer love
  xtensa: use generic fb.h
  fault-inject: add /proc/<pid>/fail-nth
  fault-inject: simplify access check for fail-nth
  fault-inject: make fail-nth read/write interface symmetric
  fault-inject: parse as natural 1-based value for fail-nth write interface
  fault-inject: automatically detect the number base for fail-nth write interface
  kernel/watchdog.c: use better pr_fmt prefix
  MAINTAINERS: move the befs tree to kernel.org
  lib/atomic64_test.c: add a test that atomic64_inc_not_zero() returns an int
  mm: fix overflow check in expand_upwards()
This commit is contained in:
Linus Torvalds 2017-07-14 21:57:25 -07:00
commit 867eacd7fb
17 changed files with 1969 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
Documentation/fault-injection/fault-injection.txt
View File

@ -136,12 +136,13 @@ use the boot option:
o proc entries
- /proc/self/task/<current-tid>/fail-nth:
- /proc/<pid>/fail-nth:
- /proc/self/task/<tid>/fail-nth:
Write to this file of integer N makes N-th call in the current task fail
(N is 0-based). Read from this file returns a single char 'Y' or 'N'
that says if the fault setup with a previous write to this file was
injected or not, and disables the fault if it wasn't yet injected.
Write to this file of integer N makes N-th call in the task fail.
Read from this file returns a integer value. A value of '0' indicates
that the fault setup with a previous write to this file was injected.
A positive integer N indicates that the fault wasn't yet injected.
Note that this file enables all types of faults (slab, futex, etc).
This setting takes precedence over all other generic debugfs settings
like probability, interval, times, etc. But per-capability settings
@ -320,18 +321,19 @@ int main()
system("echo N > /sys/kernel/debug/failslab/ignore-gfp-wait");
sprintf(buf, "/proc/self/task/%ld/fail-nth", syscall(SYS_gettid));
fail_nth = open(buf, O_RDWR);
for (i = 0;; i++) {
for (i = 1;; i++) {
sprintf(buf, "%d", i);
write(fail_nth, buf, strlen(buf));
res = socketpair(AF_LOCAL, SOCK_STREAM, 0, fds);
err = errno;
read(fail_nth, buf, 1);
pread(fail_nth, buf, sizeof(buf), 0);
if (res == 0) {
close(fds[0]);
close(fds[1]);
}
printf("%d-th fault %c: res=%d/%d\n", i, buf[0], res, err);
if (buf[0] != 'Y')
printf("%d-th fault %c: res=%d/%d\n", i, atoi(buf) ? 'N' : 'Y',
res, err);
if (atoi(buf))
break;
}
return 0;
@ -339,7 +341,6 @@ int main()
An example output:
0-th fault Y: res=-1/23
1-th fault Y: res=-1/23
2-th fault Y: res=-1/23
3-th fault Y: res=-1/12

13
MAINTAINERS
View File

@ -2516,10 +2516,10 @@ S: Supported
F: drivers/media/platform/sti/delta
BEFS FILE SYSTEM
M: Luis de Bethencourt <luisbg@osg.samsung.com>
M: Luis de Bethencourt <luisbg@kernel.org>
M: Salah Triki <salah.triki@gmail.com>
S: Maintained
T: git git://github.com/luisbg/linux-befs.git
T: git git://git.kernel.org/pub/scm/linux/kernel/git/luisbg/linux-befs.git
F: Documentation/filesystems/befs.txt
F: fs/befs/
@ -7554,6 +7554,15 @@ F: include/linux/kmemleak.h
F: mm/kmemleak.c
F: mm/kmemleak-test.c
KMOD MODULE USERMODE HELPER
M: "Luis R. Rodriguez" <mcgrof@kernel.org>
L: linux-kernel@vger.kernel.org
S: Maintained
F: kernel/kmod.c
F: include/linux/kmod.h
F: lib/test_kmod.c
F: tools/testing/selftests/kmod/
KPROBES
M: Ananth N Mavinakayanahalli <ananth@linux.vnet.ibm.com>
M: Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>

1
arch/xtensa/include/asm/Kbuild
View File

@ -5,6 +5,7 @@ generic-y += dma-contiguous.h
generic-y += emergency-restart.h
generic-y += exec.h
generic-y += extable.h
generic-y += fb.h
generic-y += hardirq.h
generic-y += irq_regs.h
generic-y += irq_work.h

12
arch/xtensa/include/asm/fb.h
View File

@ -1,12 +0,0 @@
#ifndef _ASM_FB_H_
#define _ASM_FB_H_
#include <linux/fb.h>
#define fb_pgprotect(...) do {} while (0)
static inline int fb_is_primary_device(struct fb_info *info)
{
return 0;
}
#endif /* _ASM_FB_H_ */

41
fs/proc/base.c
View File

@ -1360,20 +1360,19 @@ static ssize_t proc_fail_nth_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct task_struct *task;
int err, n;
int err;
unsigned int n;
err = kstrtouint_from_user(buf, count, 0, &n);
if (err)
return err;
task = get_proc_task(file_inode(file));
if (!task)
return -ESRCH;
WRITE_ONCE(task->fail_nth, n);
put_task_struct(task);
if (task != current)
return -EPERM;
err = kstrtoint_from_user(buf, count, 10, &n);
if (err)
return err;
if (n < 0 || n == INT_MAX)
return -EINVAL;
current->fail_nth = n + 1;
return count;
}
@ -1381,21 +1380,18 @@ static ssize_t proc_fail_nth_read(struct file *file, char __user *buf,
size_t count, loff_t *ppos)
{
struct task_struct *task;
int err;
char numbuf[PROC_NUMBUF];
ssize_t len;
task = get_proc_task(file_inode(file));
if (!task)
return -ESRCH;
len = snprintf(numbuf, sizeof(numbuf), "%u\n",
READ_ONCE(task->fail_nth));
len = simple_read_from_buffer(buf, count, ppos, numbuf, len);
put_task_struct(task);
if (task != current)
return -EPERM;
if (count < 1)
return -EINVAL;
err = put_user((char)(current->fail_nth ? 'N' : 'Y'), buf);
if (err)
return err;
current->fail_nth = 0;
return 1;
return len;
}
static const struct file_operations proc_fail_nth_operations = {
@ -2966,6 +2962,7 @@ static const struct pid_entry tgid_base_stuff[] = {
#endif
#ifdef CONFIG_FAULT_INJECTION
REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
REG("fail-nth", 0644, proc_fail_nth_operations),
#endif
#ifdef CONFIG_ELF_CORE
REG("coredump_filter", S_IRUGO|S_IWUSR, proc_coredump_filter_operations),
@ -3358,11 +3355,7 @@ static const struct pid_entry tid_base_stuff[] = {
#endif
#ifdef CONFIG_FAULT_INJECTION
REG("make-it-fail", S_IRUGO|S_IWUSR, proc_fault_inject_operations),
/*
* Operations on the file check that the task is current,
* so we create it with 0666 to support testing under unprivileged user.
*/
REG("fail-nth", 0666, proc_fail_nth_operations),
REG("fail-nth", 0644, proc_fail_nth_operations),
#endif
#ifdef CONFIG_TASK_IO_ACCOUNTING
ONE("io", S_IRUSR, proc_tid_io_accounting),

2
include/linux/sched.h
View File

@ -974,7 +974,7 @@ struct task_struct {
#ifdef CONFIG_FAULT_INJECTION
int make_it_fail;
int fail_nth;
unsigned int fail_nth;
#endif
/*
* When (nr_dirtied >= nr_dirtied_pause), it's time to call

16
kernel/kmod.c
View File

@ -68,6 +68,7 @@ static DECLARE_RWSEM(umhelper_sem);
*/
#define MAX_KMOD_CONCURRENT 50
static atomic_t kmod_concurrent_max = ATOMIC_INIT(MAX_KMOD_CONCURRENT);
static DECLARE_WAIT_QUEUE_HEAD(kmod_wq);
/*
modprobe_path is set via /proc/sys.
@ -140,7 +141,6 @@ int __request_module(bool wait, const char *fmt, ...)
va_list args;
char module_name[MODULE_NAME_LEN];
int ret;
static int kmod_loop_msg;
/*
* We don't allow synchronous module loading from async. Module
@ -164,14 +164,11 @@ int __request_module(bool wait, const char *fmt, ...)
return ret;
if (atomic_dec_if_positive(&kmod_concurrent_max) < 0) {
/* We may be blaming an innocent here, but unlikely */
if (kmod_loop_msg < 5) {
printk(KERN_ERR
"request_module: runaway loop modprobe %s\n",
module_name);
kmod_loop_msg++;
}
return -ENOMEM;
pr_warn_ratelimited("request_module: kmod_concurrent_max (%u) close to 0 (max_modprobes: %u), for module %s, throttling...",
atomic_read(&kmod_concurrent_max),
MAX_KMOD_CONCURRENT, module_name);
wait_event_interruptible(kmod_wq,
atomic_dec_if_positive(&kmod_concurrent_max) >= 0);
}
trace_module_request(module_name, wait, _RET_IP_);
@ -179,6 +176,7 @@ int __request_module(bool wait, const char *fmt, ...)
ret = call_modprobe(module_name, wait ? UMH_WAIT_PROC : UMH_WAIT_EXEC);
atomic_inc(&kmod_concurrent_max);
wake_up(&kmod_wq);
return ret;
}

2
kernel/watchdog.c
View File

@ -9,7 +9,7 @@
* to those contributors as well.
*/
#define pr_fmt(fmt) "NMI watchdog: " fmt
#define pr_fmt(fmt) "watchdog: " fmt
#include <linux/mm.h>
#include <linux/cpu.h>

27
lib/Kconfig.debug
View File

@ -1847,6 +1847,33 @@ config BUG_ON_DATA_CORRUPTION
If unsure, say N.
config TEST_KMOD
tristate "kmod stress tester"
default n
depends on m
depends on BLOCK && (64BIT || LBDAF) # for XFS, BTRFS
depends on NETDEVICES && NET_CORE && INET # for TUN
select TEST_LKM
select XFS_FS
select TUN
select BTRFS_FS
help
Test the kernel's module loading mechanism: kmod. kmod implements
support to load modules using the Linux kernel's usermode helper.
This test provides a series of tests against kmod.
Although technically you can either build test_kmod as a module or
into the kernel we disallow building it into the kernel since
it stress tests request_module() and this will very likely cause
some issues by taking over precious threads available from other
module load requests, ultimately this could be fatal.
To run tests run:
tools/testing/selftests/kmod/kmod.sh --help
If unsure, say N.
source "samples/Kconfig"
source "lib/Kconfig.kgdb"

1
lib/Makefile
View File

@ -61,6 +61,7 @@ obj-$(CONFIG_TEST_PRINTF) += test_printf.o
obj-$(CONFIG_TEST_BITMAP) += test_bitmap.o
obj-$(CONFIG_TEST_UUID) += test_uuid.o
obj-$(CONFIG_TEST_PARMAN) += test_parman.o
obj-$(CONFIG_TEST_KMOD) += test_kmod.o
ifeq ($(CONFIG_DEBUG_KOBJECT),y)
CFLAGS_kobject.o += -DDEBUG

7
lib/atomic64_test.c
View File

@ -153,8 +153,10 @@ static __init void test_atomic64(void)
long long v0 = 0xaaa31337c001d00dLL;
long long v1 = 0xdeadbeefdeafcafeLL;
long long v2 = 0xfaceabadf00df001LL;
long long v3 = 0x8000000000000000LL;
long long onestwos = 0x1111111122222222LL;
long long one = 1LL;
int r_int;
atomic64_t v = ATOMIC64_INIT(v0);
long long r = v0;
@ -240,6 +242,11 @@ static __init void test_atomic64(void)
BUG_ON(!atomic64_inc_not_zero(&v));
r += one;
BUG_ON(v.counter != r);
/* Confirm the return value fits in an int, even if the value doesn't */
INIT(v3);
r_int = atomic64_inc_not_zero(&v);
BUG_ON(!r_int);
}
static __init int test_atomics_init(void)

7
lib/fault-inject.c
View File

@ -107,9 +107,12 @@ static inline bool fail_stacktrace(struct fault_attr *attr)
bool should_fail(struct fault_attr *attr, ssize_t size)
{
if (in_task() && current->fail_nth) {
if (--current->fail_nth == 0)
if (in_task()) {
unsigned int fail_nth = READ_ONCE(current->fail_nth);
if (fail_nth && !WRITE_ONCE(current->fail_nth, fail_nth - 1))
goto fail;
return false;
}

1246
lib/test_kmod.c Normal file
View File

File diff suppressed because it is too large Load Diff

2
mm/mmap.c
View File

@ -2231,7 +2231,7 @@ int expand_upwards(struct vm_area_struct *vma, unsigned long address)
/* Guard against exceeding limits of the address space. */
address &= PAGE_MASK;
if (address >= TASK_SIZE)
if (address >= (TASK_SIZE & PAGE_MASK))
return -ENOMEM;
address += PAGE_SIZE;

11
tools/testing/selftests/kmod/Makefile Normal file
View File

@ -0,0 +1,11 @@
# Makefile for kmod loading selftests
# No binaries, but make sure arg-less "make" doesn't trigger "run_tests"
all:
TEST_PROGS := kmod.sh
include ../lib.mk
# Nothing to clean up.
clean:

7
tools/testing/selftests/kmod/config Normal file
View File

@ -0,0 +1,7 @@
CONFIG_TEST_KMOD=m
CONFIG_TEST_LKM=m
CONFIG_XFS_FS=m
# For the module parameter force_init_test is used
CONFIG_TUN=m
CONFIG_BTRFS_FS=m

615
tools/testing/selftests/kmod/kmod.sh Normal file
View File

@ -0,0 +1,615 @@
#!/bin/bash
#
# Copyright (C) 2017 Luis R. Rodriguez <mcgrof@kernel.org>
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License as published by the Free
# Software Foundation; either version 2 of the License, or at your option any
# later version; or, when distributed separately from the Linux kernel or
# when incorporated into other software packages, subject to the following
# license:
#
# This program is free software; you can redistribute it and/or modify it
# under the terms of copyleft-next (version 0.3.1 or later) as published
# at http://copyleft-next.org/.
# This is a stress test script for kmod, the kernel module loader. It uses
# test_kmod which exposes a series of knobs for the API for us so we can
# tweak each test in userspace rather than in kernelspace.
#
# The way kmod works is it uses the kernel's usermode helper API to eventually
# call /sbin/modprobe. It has a limit of the number of concurrent calls
# possible. The kernel interface to load modules is request_module(), however
# mount uses get_fs_type(). Both behave slightly differently, but the
# differences are important enough to test each call separately. For this
# reason test_kmod starts by providing tests for both calls.
#
# The test driver test_kmod assumes a series of defaults which you can
# override by exporting to your environment prior running this script.
# For instance this script assumes you do not have xfs loaded upon boot.
# If this is false, export DEFAULT_KMOD_FS="ext4" prior to running this
# script if the filesyste module you don't have loaded upon bootup
# is ext4 instead. Refer to allow_user_defaults() for a list of user
# override variables possible.
#
# You'll want at least 4 GiB of RAM to expect to run these tests
# without running out of memory on them. For other requirements refer
# to test_reqs()
set -e
TEST_NAME="kmod"
TEST_DRIVER="test_${TEST_NAME}"
TEST_DIR=$(dirname $0)
# This represents
#
# TEST_ID:TEST_COUNT:ENABLED
#
# TEST_ID: is the test id number
# TEST_COUNT: number of times we should run the test
# ENABLED: 1 if enabled, 0 otherwise
#
# Once these are enabled please leave them as-is. Write your own test,
# we have tons of space.
ALL_TESTS="0001:3:1"
ALL_TESTS="$ALL_TESTS 0002:3:1"
ALL_TESTS="$ALL_TESTS 0003:1:1"
ALL_TESTS="$ALL_TESTS 0004:1:1"
ALL_TESTS="$ALL_TESTS 0005:10:1"
ALL_TESTS="$ALL_TESTS 0006:10:1"
ALL_TESTS="$ALL_TESTS 0007:5:1"
ALL_TESTS="$ALL_TESTS 0008:150:1"
ALL_TESTS="$ALL_TESTS 0009:150:1"
test_modprobe()
{
if [ ! -d $DIR ]; then
echo "$0: $DIR not present" >&2
echo "You must have the following enabled in your kernel:" >&2
cat $TEST_DIR/config >&2
exit 1
fi
}
function allow_user_defaults()
{
if [ -z $DEFAULT_KMOD_DRIVER ]; then
DEFAULT_KMOD_DRIVER="test_module"
fi
if [ -z $DEFAULT_KMOD_FS ]; then
DEFAULT_KMOD_FS="xfs"
fi
if [ -z $PROC_DIR ]; then
PROC_DIR="/proc/sys/kernel/"
fi
if [ -z $MODPROBE_LIMIT ]; then
MODPROBE_LIMIT=50
fi
if [ -z $DIR ]; then
DIR="/sys/devices/virtual/misc/${TEST_DRIVER}0/"
fi
if [ -z $DEFAULT_NUM_TESTS ]; then
DEFAULT_NUM_TESTS=150
fi
MODPROBE_LIMIT_FILE="${PROC_DIR}/kmod-limit"
}
test_reqs()
{
if ! which modprobe 2> /dev/null > /dev/null; then
echo "$0: You need modprobe installed" >&2
exit 1
fi
if ! which kmod 2> /dev/null > /dev/null; then
echo "$0: You need kmod installed" >&2
exit 1
fi
# kmod 19 has a bad bug where it returns 0 when modprobe
# gets called *even* if the module was not loaded due to
# some bad heuristics. For details see:
#
# A work around is possible in-kernel but its rather
# complex.
KMOD_VERSION=$(kmod --version | awk '{print $3}')
if [[ $KMOD_VERSION -le 19 ]]; then
echo "$0: You need at least kmod 20" >&2
echo "kmod <= 19 is buggy, for details see:" >&2
echo "http://git.kernel.org/cgit/utils/kernel/kmod/kmod.git/commit/libkmod/libkmod-module.c?id=fd44a98ae2eb5eb32161088954ab21e58e19dfc4" >&2
exit 1
fi
uid=$(id -u)
if [ $uid -ne 0 ]; then
echo $msg must be run as root >&2
exit 0
fi
}
function load_req_mod()
{
trap "test_modprobe" EXIT
if [ ! -d $DIR ]; then
# Alanis: "Oh isn't it ironic?"
modprobe $TEST_DRIVER
fi
}
test_finish()
{
echo "Test completed"
}
errno_name_to_val()
{
case "$1" in
# kmod calls modprobe and upon of a module not found
# modprobe returns just 1... However in the kernel we
# *sometimes* see 256...
MODULE_NOT_FOUND)
echo 256;;
SUCCESS)
echo 0;;
-EPERM)
echo -1;;
-ENOENT)
echo -2;;
-EINVAL)
echo -22;;
-ERR_ANY)
echo -123456;;
*)
echo invalid;;
esac
}
errno_val_to_name()
case "$1" in
256)
echo MODULE_NOT_FOUND;;
0)
echo SUCCESS;;
-1)
echo -EPERM;;
-2)
echo -ENOENT;;
-22)
echo -EINVAL;;
-123456)
echo -ERR_ANY;;
*)
echo invalid;;
esac
config_set_test_case_driver()
{
if ! echo -n 1 >$DIR/config_test_case; then
echo "$0: Unable to set to test case to driver" >&2
exit 1
fi
}
config_set_test_case_fs()
{
if ! echo -n 2 >$DIR/config_test_case; then
echo "$0: Unable to set to test case to fs" >&2
exit 1
fi
}
config_num_threads()
{
if ! echo -n $1 >$DIR/config_num_threads; then
echo "$0: Unable to set to number of threads" >&2
exit 1
fi
}
config_get_modprobe_limit()
{
if [[ -f ${MODPROBE_LIMIT_FILE} ]] ; then
MODPROBE_LIMIT=$(cat $MODPROBE_LIMIT_FILE)
fi
echo $MODPROBE_LIMIT
}
config_num_thread_limit_extra()
{
MODPROBE_LIMIT=$(config_get_modprobe_limit)
let EXTRA_LIMIT=$MODPROBE_LIMIT+$1
config_num_threads $EXTRA_LIMIT
}
# For special characters use printf directly,
# refer to kmod_test_0001
config_set_driver()
{
if ! echo -n $1 >$DIR/config_test_driver; then
echo "$0: Unable to set driver" >&2
exit 1
fi
}
config_set_fs()
{
if ! echo -n $1 >$DIR/config_test_fs; then
echo "$0: Unable to set driver" >&2
exit 1
fi
}
config_get_driver()
{
cat $DIR/config_test_driver
}
config_get_test_result()
{
cat $DIR/test_result
}
config_reset()
{
if ! echo -n "1" >"$DIR"/reset; then
echo "$0: reset shuld have worked" >&2
exit 1
fi
}
config_show_config()
{
echo "----------------------------------------------------"
cat "$DIR"/config
echo "----------------------------------------------------"
}
config_trigger()
{
if ! echo -n "1" >"$DIR"/trigger_config 2>/dev/null; then
echo "$1: FAIL - loading should have worked"
config_show_config
exit 1
fi
echo "$1: OK! - loading kmod test"
}
config_trigger_want_fail()
{
if echo "1" > $DIR/trigger_config 2>/dev/null; then
echo "$1: FAIL - test case was expected to fail"
config_show_config
exit 1
fi
echo "$1: OK! - kmod test case failed as expected"
}
config_expect_result()
{
RC=$(config_get_test_result)
RC_NAME=$(errno_val_to_name $RC)
ERRNO_NAME=$2
ERRNO=$(errno_name_to_val $ERRNO_NAME)
if [[ $ERRNO_NAME = "-ERR_ANY" ]]; then
if [[ $RC -ge 0 ]]; then
echo "$1: FAIL, test expects $ERRNO_NAME - got $RC_NAME ($RC)" >&2
config_show_config
exit 1
fi
elif [[ $RC != $ERRNO ]]; then
echo "$1: FAIL, test expects $ERRNO_NAME ($ERRNO) - got $RC_NAME ($RC)" >&2
config_show_config
exit 1
fi
echo "$1: OK! - Return value: $RC ($RC_NAME), expected $ERRNO_NAME"
}
kmod_defaults_driver()
{
config_reset
modprobe -r $DEFAULT_KMOD_DRIVER
config_set_driver $DEFAULT_KMOD_DRIVER
}
kmod_defaults_fs()
{
config_reset
modprobe -r $DEFAULT_KMOD_FS
config_set_fs $DEFAULT_KMOD_FS
config_set_test_case_fs
}
kmod_test_0001_driver()
{
NAME='\000'
kmod_defaults_driver
config_num_threads 1
printf '\000' >"$DIR"/config_test_driver
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} MODULE_NOT_FOUND
}
kmod_test_0001_fs()
{
NAME='\000'
kmod_defaults_fs
config_num_threads 1
printf '\000' >"$DIR"/config_test_fs
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} -EINVAL
}
kmod_test_0001()
{
kmod_test_0001_driver
kmod_test_0001_fs
}
kmod_test_0002_driver()
{
NAME="nope-$DEFAULT_KMOD_DRIVER"
kmod_defaults_driver
config_set_driver $NAME
config_num_threads 1
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} MODULE_NOT_FOUND
}
kmod_test_0002_fs()
{
NAME="nope-$DEFAULT_KMOD_FS"
kmod_defaults_fs
config_set_fs $NAME
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} -EINVAL
}
kmod_test_0002()
{
kmod_test_0002_driver
kmod_test_0002_fs
}
kmod_test_0003()
{
kmod_defaults_fs
config_num_threads 1
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
kmod_test_0004()
{
kmod_defaults_fs
config_num_threads 2
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
kmod_test_0005()
{
kmod_defaults_driver
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
kmod_test_0006()
{
kmod_defaults_fs
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
kmod_test_0007()
{
kmod_test_0005
kmod_test_0006
}
kmod_test_0008()
{
kmod_defaults_driver
MODPROBE_LIMIT=$(config_get_modprobe_limit)
let EXTRA=$MODPROBE_LIMIT/6
config_num_thread_limit_extra $EXTRA
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
kmod_test_0009()
{
kmod_defaults_fs
MODPROBE_LIMIT=$(config_get_modprobe_limit)
let EXTRA=$MODPROBE_LIMIT/4
config_num_thread_limit_extra $EXTRA
config_trigger ${FUNCNAME[0]}
config_expect_result ${FUNCNAME[0]} SUCCESS
}
list_tests()
{
echo "Test ID list:"
echo
echo "TEST_ID x NUM_TEST"
echo "TEST_ID: Test ID"
echo "NUM_TESTS: Number of recommended times to run the test"
echo
echo "0001 x $(get_test_count 0001) - Simple test - 1 thread for empty string"
echo "0002 x $(get_test_count 0002) - Simple test - 1 thread for modules/filesystems that do not exist"
echo "0003 x $(get_test_count 0003) - Simple test - 1 thread for get_fs_type() only"
echo "0004 x $(get_test_count 0004) - Simple test - 2 threads for get_fs_type() only"
echo "0005 x $(get_test_count 0005) - multithreaded tests with default setup - request_module() only"
echo "0006 x $(get_test_count 0006) - multithreaded tests with default setup - get_fs_type() only"
echo "0007 x $(get_test_count 0007) - multithreaded tests with default setup test request_module() and get_fs_type()"
echo "0008 x $(get_test_count 0008) - multithreaded - push kmod_concurrent over max_modprobes for request_module()"
echo "0009 x $(get_test_count 0009) - multithreaded - push kmod_concurrent over max_modprobes for get_fs_type()"
}
usage()
{
NUM_TESTS=$(grep -o ' ' <<<"$ALL_TESTS" | grep -c .)
let NUM_TESTS=$NUM_TESTS+1
MAX_TEST=$(printf "%04d\n" $NUM_TESTS)
echo "Usage: $0 [ -t <4-number-digit> ] | [ -w <4-number-digit> ] |"
echo " [ -s <4-number-digit> ] | [ -c <4-number-digit> <test- count>"
echo " [ all ] [ -h | --help ] [ -l ]"
echo ""
echo "Valid tests: 0001-$MAX_TEST"
echo ""
echo " all Runs all tests (default)"
echo " -t Run test ID the number amount of times is recommended"
echo " -w Watch test ID run until it runs into an error"
echo " -c Run test ID once"
echo " -s Run test ID x test-count number of times"
echo " -l List all test ID list"
echo " -h|--help Help"
echo
echo "If an error every occurs execution will immediately terminate."
echo "If you are adding a new test try using -w <test-ID> first to"
echo "make sure the test passes a series of tests."
echo
echo Example uses:
echo
echo "${TEST_NAME}.sh -- executes all tests"
echo "${TEST_NAME}.sh -t 0008 -- Executes test ID 0008 number of times is recomended"
echo "${TEST_NAME}.sh -w 0008 -- Watch test ID 0008 run until an error occurs"
echo "${TEST_NAME}.sh -s 0008 -- Run test ID 0008 once"
echo "${TEST_NAME}.sh -c 0008 3 -- Run test ID 0008 three times"
echo
list_tests
exit 1
}
function test_num()
{
re='^[0-9]+$'
if ! [[ $1 =~ $re ]]; then
usage
fi
}
function get_test_count()
{
test_num $1
TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
LAST_TWO=${TEST_DATA#*:*}
echo ${LAST_TWO%:*}
}
function get_test_enabled()
{
test_num $1
TEST_DATA=$(echo $ALL_TESTS | awk '{print $'$1'}')
echo ${TEST_DATA#*:*:}
}
function run_all_tests()
{
for i in $ALL_TESTS ; do
TEST_ID=${i%:*:*}
ENABLED=$(get_test_enabled $TEST_ID)
TEST_COUNT=$(get_test_count $TEST_ID)
if [[ $ENABLED -eq "1" ]]; then
test_case $TEST_ID $TEST_COUNT
fi
done
}
function watch_log()
{
if [ $# -ne 3 ]; then
clear
fi
date
echo "Running test: $2 - run #$1"
}
function watch_case()
{
i=0
while [ 1 ]; do
if [ $# -eq 1 ]; then
test_num $1
watch_log $i ${TEST_NAME}_test_$1
${TEST_NAME}_test_$1
else
watch_log $i all
run_all_tests
fi
let i=$i+1
done
}
function test_case()
{
NUM_TESTS=$DEFAULT_NUM_TESTS
if [ $# -eq 2 ]; then
NUM_TESTS=$2
fi
i=0
while [ $i -lt $NUM_TESTS ]; do
test_num $1
watch_log $i ${TEST_NAME}_test_$1 noclear
RUN_TEST=${TEST_NAME}_test_$1
$RUN_TEST
let i=$i+1
done
}
function parse_args()
{
if [ $# -eq 0 ]; then
run_all_tests
else
if [[ "$1" = "all" ]]; then
run_all_tests
elif [[ "$1" = "-w" ]]; then
shift
watch_case $@
elif [[ "$1" = "-t" ]]; then
shift
test_num $1
test_case $1 $(get_test_count $1)
elif [[ "$1" = "-c" ]]; then
shift
test_num $1
test_num $2
test_case $1 $2
elif [[ "$1" = "-s" ]]; then
shift
test_case $1 1
elif [[ "$1" = "-l" ]]; then
list_tests
elif [[ "$1" = "-h" || "$1" = "--help" ]]; then
usage
else
usage
fi
fi
}
test_reqs
allow_user_defaults
load_req_mod
trap "test_finish" EXIT
parse_args $@
exit 0