2019-05-19 12:08:55 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-12-08 10:39:43 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/random.h>
|
2009-10-07 13:09:06 +00:00
|
|
|
#include <linux/sched.h>
|
2006-12-08 10:39:43 +00:00
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/fs.h>
|
2011-11-17 02:29:17 +00:00
|
|
|
#include <linux/export.h>
|
2006-12-08 10:39:47 +00:00
|
|
|
#include <linux/interrupt.h>
|
2006-12-08 10:39:48 +00:00
|
|
|
#include <linux/stacktrace.h>
|
2006-12-08 10:39:43 +00:00
|
|
|
#include <linux/fault-inject.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* setup_fault_attr() is a helper function for various __setup handlers, so it
|
|
|
|
* returns 0 on error, because that is what __setup handlers do.
|
|
|
|
*/
|
2011-09-13 21:03:28 +00:00
|
|
|
int setup_fault_attr(struct fault_attr *attr, char *str)
|
2006-12-08 10:39:43 +00:00
|
|
|
{
|
|
|
|
unsigned long probability;
|
|
|
|
unsigned long interval;
|
|
|
|
int times;
|
|
|
|
int space;
|
|
|
|
|
|
|
|
/* "<interval>,<probability>,<space>,<times>" */
|
|
|
|
if (sscanf(str, "%lu,%lu,%d,%d",
|
|
|
|
&interval, &probability, &space, ×) < 4) {
|
|
|
|
printk(KERN_WARNING
|
|
|
|
"FAULT_INJECTION: failed to parse arguments\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
attr->probability = probability;
|
|
|
|
attr->interval = interval;
|
|
|
|
atomic_set(&attr->times, times);
|
|
|
|
atomic_set(&attr->space, space);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
2011-09-13 21:03:28 +00:00
|
|
|
EXPORT_SYMBOL_GPL(setup_fault_attr);
|
2006-12-08 10:39:43 +00:00
|
|
|
|
|
|
|
static void fail_dump(struct fault_attr *attr)
|
|
|
|
{
|
2014-12-13 00:58:00 +00:00
|
|
|
if (attr->verbose > 0 && __ratelimit(&attr->ratelimit_state)) {
|
|
|
|
printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure.\n"
|
|
|
|
"name %pd, interval %lu, probability %lu, "
|
|
|
|
"space %d, times %d\n", attr->dname,
|
2015-10-22 20:32:27 +00:00
|
|
|
attr->interval, attr->probability,
|
2014-12-13 00:58:00 +00:00
|
|
|
atomic_read(&attr->space),
|
|
|
|
atomic_read(&attr->times));
|
|
|
|
if (attr->verbose > 1)
|
|
|
|
dump_stack();
|
|
|
|
}
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define atomic_dec_not_zero(v) atomic_add_unless((v), -1, 0)
|
|
|
|
|
2006-12-08 10:39:51 +00:00
|
|
|
static bool fail_task(struct fault_attr *attr, struct task_struct *task)
|
2006-12-08 10:39:47 +00:00
|
|
|
{
|
2017-05-08 22:56:51 +00:00
|
|
|
return in_task() && task->make_it_fail;
|
2006-12-08 10:39:47 +00:00
|
|
|
}
|
|
|
|
|
2006-12-08 10:39:52 +00:00
|
|
|
#define MAX_STACK_TRACE_DEPTH 32
|
|
|
|
|
2007-02-20 21:57:56 +00:00
|
|
|
#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
|
2006-12-08 10:39:48 +00:00
|
|
|
|
2006-12-08 10:39:51 +00:00
|
|
|
static bool fail_stacktrace(struct fault_attr *attr)
|
2006-12-08 10:39:48 +00:00
|
|
|
{
|
|
|
|
int depth = attr->stacktrace_depth;
|
|
|
|
unsigned long entries[MAX_STACK_TRACE_DEPTH];
|
2019-04-25 09:45:04 +00:00
|
|
|
int n, nr_entries;
|
2006-12-08 10:39:48 +00:00
|
|
|
bool found = (attr->require_start == 0 && attr->require_end == ULONG_MAX);
|
|
|
|
|
|
|
|
if (depth == 0)
|
|
|
|
return found;
|
|
|
|
|
2019-04-25 09:45:04 +00:00
|
|
|
nr_entries = stack_trace_save(entries, depth, 1);
|
|
|
|
for (n = 0; n < nr_entries; n++) {
|
2006-12-08 10:39:48 +00:00
|
|
|
if (attr->reject_start <= entries[n] &&
|
|
|
|
entries[n] < attr->reject_end)
|
2006-12-08 10:39:51 +00:00
|
|
|
return false;
|
2006-12-08 10:39:48 +00:00
|
|
|
if (attr->require_start <= entries[n] &&
|
|
|
|
entries[n] < attr->require_end)
|
2006-12-08 10:39:51 +00:00
|
|
|
found = true;
|
2006-12-08 10:39:48 +00:00
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2006-12-08 10:39:51 +00:00
|
|
|
static inline bool fail_stacktrace(struct fault_attr *attr)
|
2006-12-08 10:39:48 +00:00
|
|
|
{
|
2007-02-20 21:57:56 +00:00
|
|
|
return true;
|
2006-12-08 10:39:48 +00:00
|
|
|
}
|
|
|
|
|
2007-02-20 21:57:56 +00:00
|
|
|
#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
|
2006-12-08 10:39:48 +00:00
|
|
|
|
2006-12-08 10:39:43 +00:00
|
|
|
/*
|
|
|
|
* This code is stolen from failmalloc-1.0
|
|
|
|
* http://www.nongnu.org/failmalloc/
|
|
|
|
*/
|
|
|
|
|
2006-12-08 10:39:51 +00:00
|
|
|
bool should_fail(struct fault_attr *attr, ssize_t size)
|
2006-12-08 10:39:43 +00:00
|
|
|
{
|
2017-07-14 21:49:57 +00:00
|
|
|
if (in_task()) {
|
|
|
|
unsigned int fail_nth = READ_ONCE(current->fail_nth);
|
|
|
|
|
2017-08-10 22:23:53 +00:00
|
|
|
if (fail_nth) {
|
|
|
|
if (!WRITE_ONCE(current->fail_nth, fail_nth - 1))
|
|
|
|
goto fail;
|
2017-07-14 21:49:57 +00:00
|
|
|
|
2017-08-10 22:23:53 +00:00
|
|
|
return false;
|
|
|
|
}
|
fault-inject: support systematic fault injection
Add /proc/self/task/<current-tid>/fail-nth file that allows failing
0-th, 1-st, 2-nd and so on calls systematically.
Excerpt from the added documentation:
"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.
Note that this file enables all types of faults (slab, futex, etc).
This setting takes precedence over all other generic settings like
probability, interval, times, etc. But per-capability settings (e.g.
fail_futex/ignore-private) take precedence over it. This feature is
intended for systematic testing of faults in a single system call. See
an example below"
Why add a new setting:
1. Existing settings are global rather than per-task.
So parallel testing is not possible.
2. attr->interval is close but it depends on attr->count
which is non reset to 0, so interval does not work as expected.
3. Trying to model this with existing settings requires manipulations
of all of probability, interval, times, space, task-filter and
unexposed count and per-task make-it-fail files.
4. Existing settings are per-failure-type, and the set of failure
types is potentially expanding.
5. make-it-fail can't be changed by unprivileged user and aggressive
stress testing better be done from an unprivileged user.
Similarly, this would require opening the debugfs files to the
unprivileged user, as he would need to reopen at least times file
(not possible to pre-open before dropping privs).
The proposed interface solves all of the above (see the example).
We want to integrate this into syzkaller fuzzer. A prototype has found
10 bugs in kernel in first day of usage:
https://groups.google.com/forum/#!searchin/syzkaller/%22FAULT_INJECTION%22%7Csort:relevance
I've made the current interface work with all types of our sandboxes.
For setuid the secret sauce was prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) to
make /proc entries non-root owned. So I am fine with the current
version of the code.
[akpm@linux-foundation.org: fix build]
Link: http://lkml.kernel.org/r/20170328130128.101773-1-dvyukov@google.com
Signed-off-by: Dmitry Vyukov <dvyukov@google.com>
Cc: Akinobu Mita <akinobu.mita@gmail.com>
Cc: Michal Hocko <mhocko@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-07-12 21:34:35 +00:00
|
|
|
}
|
|
|
|
|
2012-06-20 19:53:03 +00:00
|
|
|
/* No need to check any other properties if the probability is 0 */
|
|
|
|
if (attr->probability == 0)
|
|
|
|
return false;
|
|
|
|
|
2006-12-08 10:39:47 +00:00
|
|
|
if (attr->task_filter && !fail_task(attr, current))
|
2006-12-08 10:39:51 +00:00
|
|
|
return false;
|
2006-12-08 10:39:47 +00:00
|
|
|
|
2006-12-08 10:39:43 +00:00
|
|
|
if (atomic_read(&attr->times) == 0)
|
2006-12-08 10:39:51 +00:00
|
|
|
return false;
|
2006-12-08 10:39:43 +00:00
|
|
|
|
|
|
|
if (atomic_read(&attr->space) > size) {
|
|
|
|
atomic_sub(size, &attr->space);
|
2006-12-08 10:39:51 +00:00
|
|
|
return false;
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (attr->interval > 1) {
|
|
|
|
attr->count++;
|
|
|
|
if (attr->count % attr->interval)
|
2006-12-08 10:39:51 +00:00
|
|
|
return false;
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
|
|
|
|
2013-04-29 23:21:28 +00:00
|
|
|
if (attr->probability <= prandom_u32() % 100)
|
2006-12-08 10:39:53 +00:00
|
|
|
return false;
|
2006-12-08 10:39:43 +00:00
|
|
|
|
2006-12-08 10:39:53 +00:00
|
|
|
if (!fail_stacktrace(attr))
|
|
|
|
return false;
|
2006-12-08 10:39:43 +00:00
|
|
|
|
fault-inject: support systematic fault injection
Add /proc/self/task/<current-tid>/fail-nth file that allows failing
0-th, 1-st, 2-nd and so on calls systematically.
Excerpt from the added documentation:
"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.
Note that this file enables all types of faults (slab, futex, etc).
This setting takes precedence over all other generic settings like
probability, interval, times, etc. But per-capability settings (e.g.
fail_futex/ignore-private) take precedence over it. This feature is
intended for systematic testing of faults in a single system call. See
an example below"
Why add a new setting:
1. Existing settings are global rather than per-task.
So parallel testing is not possible.
2. attr->interval is close but it depends on attr->count
which is non reset to 0, so interval does not work as expected.
3. Trying to model this with existing settings requires manipulations
of all of probability, interval, times, space, task-filter and
unexposed count and per-task make-it-fail files.
4. Existing settings are per-failure-type, and the set of failure
types is potentially expanding.
5. make-it-fail can't be changed by unprivileged user and aggressive
stress testing better be done from an unprivileged user.
Similarly, this would require opening the debugfs files to the
unprivileged user, as he would need to reopen at least times file
(not possible to pre-open before dropping privs).
The proposed interface solves all of the above (see the example).
We want to integrate this into syzkaller fuzzer. A prototype has found
10 bugs in kernel in first day of usage:
https://groups.google.com/forum/#!searchin/syzkaller/%22FAULT_INJECTION%22%7Csort:relevance
I've made the current interface work with all types of our sandboxes.
For setuid the secret sauce was prctl(PR_SET_DUMPABLE, 1, 0, 0, 0) to
make /proc entries non-root owned. So I am fine with the current
version of the code.
[akpm@linux-foundation.org: fix build]
Link: http://lkml.kernel.org/r/20170328130128.101773-1-dvyukov@google.com
Signed-off-by: Dmitry Vyukov <dvyukov@google.com>
Cc: Akinobu Mita <akinobu.mita@gmail.com>
Cc: Michal Hocko <mhocko@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2017-07-12 21:34:35 +00:00
|
|
|
fail:
|
2006-12-08 10:39:43 +00:00
|
|
|
fail_dump(attr);
|
|
|
|
|
|
|
|
if (atomic_read(&attr->times) != -1)
|
|
|
|
atomic_dec_not_zero(&attr->times);
|
|
|
|
|
2006-12-08 10:39:51 +00:00
|
|
|
return true;
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
2011-08-19 12:52:36 +00:00
|
|
|
EXPORT_SYMBOL_GPL(should_fail);
|
2006-12-08 10:39:43 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
|
|
|
|
|
2008-02-08 12:20:26 +00:00
|
|
|
static int debugfs_ul_set(void *data, u64 val)
|
2006-12-08 10:39:43 +00:00
|
|
|
{
|
|
|
|
*(unsigned long *)data = val;
|
2008-02-08 12:20:26 +00:00
|
|
|
return 0;
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
|
|
|
|
2008-02-08 12:20:26 +00:00
|
|
|
static int debugfs_ul_get(void *data, u64 *val)
|
2006-12-08 10:39:43 +00:00
|
|
|
{
|
2008-02-08 12:20:26 +00:00
|
|
|
*val = *(unsigned long *)data;
|
|
|
|
return 0;
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(fops_ul, debugfs_ul_get, debugfs_ul_set, "%llu\n");
|
|
|
|
|
2011-07-24 08:33:43 +00:00
|
|
|
static struct dentry *debugfs_create_ul(const char *name, umode_t mode,
|
2006-12-08 10:39:43 +00:00
|
|
|
struct dentry *parent, unsigned long *value)
|
|
|
|
{
|
|
|
|
return debugfs_create_file(name, mode, parent, value, &fops_ul);
|
|
|
|
}
|
|
|
|
|
2007-07-24 01:43:55 +00:00
|
|
|
#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
|
2006-12-08 10:39:52 +00:00
|
|
|
|
2011-07-26 23:09:01 +00:00
|
|
|
static int debugfs_stacktrace_depth_set(void *data, u64 val)
|
|
|
|
{
|
|
|
|
*(unsigned long *)data =
|
|
|
|
min_t(unsigned long, val, MAX_STACK_TRACE_DEPTH);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFINE_SIMPLE_ATTRIBUTE(fops_stacktrace_depth, debugfs_ul_get,
|
|
|
|
debugfs_stacktrace_depth_set, "%llu\n");
|
|
|
|
|
|
|
|
static struct dentry *debugfs_create_stacktrace_depth(
|
2011-07-24 08:33:43 +00:00
|
|
|
const char *name, umode_t mode,
|
2006-12-08 10:39:52 +00:00
|
|
|
struct dentry *parent, unsigned long *value)
|
|
|
|
{
|
|
|
|
return debugfs_create_file(name, mode, parent, value,
|
2011-07-26 23:09:01 +00:00
|
|
|
&fops_stacktrace_depth);
|
2006-12-08 10:39:52 +00:00
|
|
|
}
|
2011-07-26 23:09:01 +00:00
|
|
|
|
2007-07-24 01:43:55 +00:00
|
|
|
#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
|
2006-12-08 10:39:52 +00:00
|
|
|
|
2011-08-03 23:21:01 +00:00
|
|
|
struct dentry *fault_create_debugfs_attr(const char *name,
|
|
|
|
struct dentry *parent, struct fault_attr *attr)
|
2006-12-08 10:39:43 +00:00
|
|
|
{
|
2011-07-24 08:33:43 +00:00
|
|
|
umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
|
2006-12-08 10:39:43 +00:00
|
|
|
struct dentry *dir;
|
|
|
|
|
2011-08-03 23:21:01 +00:00
|
|
|
dir = debugfs_create_dir(name, parent);
|
2006-12-08 10:39:43 +00:00
|
|
|
if (!dir)
|
2011-08-03 23:21:01 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2006-12-08 10:39:43 +00:00
|
|
|
|
2011-07-26 23:09:02 +00:00
|
|
|
if (!debugfs_create_ul("probability", mode, dir, &attr->probability))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("interval", mode, dir, &attr->interval))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_atomic_t("times", mode, dir, &attr->times))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_atomic_t("space", mode, dir, &attr->space))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("verbose", mode, dir, &attr->verbose))
|
|
|
|
goto fail;
|
2014-12-13 00:58:00 +00:00
|
|
|
if (!debugfs_create_u32("verbose_ratelimit_interval_ms", mode, dir,
|
|
|
|
&attr->ratelimit_state.interval))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_u32("verbose_ratelimit_burst", mode, dir,
|
|
|
|
&attr->ratelimit_state.burst))
|
|
|
|
goto fail;
|
2011-07-26 23:09:02 +00:00
|
|
|
if (!debugfs_create_bool("task-filter", mode, dir, &attr->task_filter))
|
2007-02-20 21:57:56 +00:00
|
|
|
goto fail;
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
|
|
|
|
|
2011-07-26 23:09:02 +00:00
|
|
|
if (!debugfs_create_stacktrace_depth("stacktrace-depth", mode, dir,
|
|
|
|
&attr->stacktrace_depth))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("require-start", mode, dir,
|
|
|
|
&attr->require_start))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("require-end", mode, dir, &attr->require_end))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("reject-start", mode, dir, &attr->reject_start))
|
|
|
|
goto fail;
|
|
|
|
if (!debugfs_create_ul("reject-end", mode, dir, &attr->reject_end))
|
2006-12-08 10:39:43 +00:00
|
|
|
goto fail;
|
|
|
|
|
2007-02-20 21:57:56 +00:00
|
|
|
#endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
|
|
|
|
|
2014-12-13 00:58:00 +00:00
|
|
|
attr->dname = dget(dir);
|
2011-08-03 23:21:01 +00:00
|
|
|
return dir;
|
2006-12-08 10:39:43 +00:00
|
|
|
fail:
|
2011-08-03 23:21:01 +00:00
|
|
|
debugfs_remove_recursive(dir);
|
2011-07-26 23:09:02 +00:00
|
|
|
|
2011-08-03 23:21:01 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2006-12-08 10:39:43 +00:00
|
|
|
}
|
2011-08-19 12:52:36 +00:00
|
|
|
EXPORT_SYMBOL_GPL(fault_create_debugfs_attr);
|
2006-12-08 10:39:43 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
|