7 files changed, 629 insertions, 48 deletions

diff --git a/lib/Kconfig b/lib/Kconfig
index 734ce95a93d1..47b172df3e31 100644
--- a/lib/Kconfig
+++ b/lib/Kconfig
@@ -4,6 +4,9 @@
 
 menu "Library routines"
 
+config BITREVERSE
+        tristate
+
 config CRC_CCITT
         tristate "CRC-CCITT functions"
         help
@@ -23,6 +26,7 @@ config CRC16
 config CRC32
         tristate "CRC32 functions"
         default y
+        select BITREVERSE
         help
           This option is provided for the case where no in-kernel-tree
           modules require CRC32 functions, but a module built outside the
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index b75fed737f25..0701ddda1df8 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -47,6 +47,30 @@ config UNUSED_SYMBOLS
           you really need it, and what the merge plan to the mainline kernel for
           your module is.
 
+config DEBUG_FS
+        bool "Debug Filesystem"
+        depends on SYSFS
+        help
+          debugfs is a virtual file system that kernel developers use to put
+          debugging files into.  Enable this option to be able to read and
+          write to these files.
+
+          If unsure, say N.
+
+config HEADERS_CHECK
+        bool "Run 'make headers_check' when building vmlinux"
+        depends on !UML
+        help
+          This option will extract the user-visible kernel headers whenever
+          building the kernel, and will run basic sanity checks on them to
+          ensure that exported files do not attempt to include files which
+          were not exported, etc.
+
+          If you're making modifications to header files which are
+          relevant for userspace, say 'Y', and check the headers
+          exported to $(INSTALL_HDR_PATH) (usually 'usr/include' in
+          your build tree), to make sure they're suitable.
+
 config DEBUG_KERNEL
         bool "Kernel debugging"
         help
@@ -285,7 +309,7 @@ config DEBUG_HIGHMEM
 config DEBUG_BUGVERBOSE
         bool "Verbose BUG() reporting (adds 70K)" if DEBUG_KERNEL && EMBEDDED
         depends on BUG
-        depends on ARM || ARM26 || AVR32 || M32R || M68K || SPARC32 || SPARC64 || X86_32 || FRV || SUPERH
+        depends on ARM || ARM26 || AVR32 || M32R || M68K || SPARC32 || SPARC64 || FRV || SUPERH || GENERIC_BUG
         default !EMBEDDED
         help
           Say Y here to make BUG() panics output the file name and line number
@@ -302,16 +326,6 @@ config DEBUG_INFO
 
           If unsure, say N.
 
-config DEBUG_FS
-        bool "Debug Filesystem"
-        depends on SYSFS
-        help
-          debugfs is a virtual file system that kernel developers use to put
-          debugging files into.  Enable this option to be able to read and
-          write to these files.
-
-          If unsure, say N.
-
 config DEBUG_VM
         bool "Debug VM"
         depends on DEBUG_KERNEL
@@ -372,20 +386,6 @@ config FORCED_INLINING
           become the default in the future, until then this option is there to
           test gcc for this.
 
-config HEADERS_CHECK
-        bool "Run 'make headers_check' when building vmlinux"
-        depends on !UML
-        help
-          This option will extract the user-visible kernel headers whenever
-          building the kernel, and will run basic sanity checks on them to
-          ensure that exported files do not attempt to include files which
-          were not exported, etc.
-
-          If you're making modifications to header files which are
-          relevant for userspace, say 'Y', and check the headers
-          exported to $(INSTALL_HDR_PATH) (usually 'usr/include' in
-          your build tree), to make sure they're suitable.
-
 config RCU_TORTURE_TEST
         tristate "torture tests for RCU"
         depends on DEBUG_KERNEL
@@ -402,6 +402,7 @@ config RCU_TORTURE_TEST
 
 config LKDTM
         tristate "Linux Kernel Dump Test Tool Module"
+        depends on DEBUG_KERNEL
         depends on KPROBES
         default n
         help
@@ -413,3 +414,36 @@ config LKDTM
 
         Documentation on how to use the module can be found in
         drivers/misc/lkdtm.c
+
+config FAULT_INJECTION
+        bool "Fault-injection framework"
+        depends on DEBUG_KERNEL
+        depends on STACKTRACE
+        select FRAME_POINTER
+        help
+          Provide fault-injection framework.
+          For more details, see Documentation/fault-injection/.
+
+config FAILSLAB
+        bool "Fault-injection capability for kmalloc"
+        depends on FAULT_INJECTION
+        help
+          Provide fault-injection capability for kmalloc.
+
+config FAIL_PAGE_ALLOC
+        bool "Fault-injection capabilitiy for alloc_pages()"
+        depends on FAULT_INJECTION
+        help
+          Provide fault-injection capability for alloc_pages().
+
+config FAIL_MAKE_REQUEST
+        bool "Fault-injection capabilitiy for disk IO"
+        depends on FAULT_INJECTION
+        help
+          Provide fault-injection capability for disk IO.
+
+config FAULT_INJECTION_DEBUG_FS
+        bool "Debugfs entries for fault-injection capabilities"
+        depends on FAULT_INJECTION && SYSFS && DEBUG_FS
+        help
+          Enable configuration of fault-injection capabilities via debugfs.
diff --git a/lib/Makefile b/lib/Makefile
index fea8f9035f07..2d6106af53cd 100644
--- a/lib/Makefile
+++ b/lib/Makefile
@@ -35,6 +35,7 @@ ifneq ($(CONFIG_HAVE_DEC_LOCK),y)
   lib-y += dec_and_lock.o
 endif
 
+obj-$(CONFIG_BITREVERSE) += bitrev.o
 obj-$(CONFIG_CRC_CCITT) += crc-ccitt.o
 obj-$(CONFIG_CRC16)     += crc16.o
 obj-$(CONFIG_CRC32)     += crc32.o
@@ -54,6 +55,9 @@ obj-$(CONFIG_SMP) += percpu_counter.o
 obj-$(CONFIG_AUDIT_GENERIC) += audit.o
 
 obj-$(CONFIG_SWIOTLB) += swiotlb.o
+obj-$(CONFIG_FAULT_INJECTION) += fault-inject.o
+
+lib-$(CONFIG_GENERIC_BUG) += bug.o
 
 hostprogs-y     := gen_crc32table
 clean-files     := crc32table.h
diff --git a/lib/bitrev.c b/lib/bitrev.c
new file mode 100644
index 000000000000..989aff73f881
--- /dev/null
+++ b/lib/bitrev.c
@@ -0,0 +1,58 @@
+#include <linux/types.h>
+#include <linux/module.h>
+#include <linux/bitrev.h>
+
+MODULE_AUTHOR("Akinobu Mita <akinobu.mita@gmail.com>");
+MODULE_DESCRIPTION("Bit ordering reversal functions");
+MODULE_LICENSE("GPL");
+
+const u8 byte_rev_table[256] = {
+        0x00, 0x80, 0x40, 0xc0, 0x20, 0xa0, 0x60, 0xe0,
+        0x10, 0x90, 0x50, 0xd0, 0x30, 0xb0, 0x70, 0xf0,
+        0x08, 0x88, 0x48, 0xc8, 0x28, 0xa8, 0x68, 0xe8,
+        0x18, 0x98, 0x58, 0xd8, 0x38, 0xb8, 0x78, 0xf8,
+        0x04, 0x84, 0x44, 0xc4, 0x24, 0xa4, 0x64, 0xe4,
+        0x14, 0x94, 0x54, 0xd4, 0x34, 0xb4, 0x74, 0xf4,
+        0x0c, 0x8c, 0x4c, 0xcc, 0x2c, 0xac, 0x6c, 0xec,
+        0x1c, 0x9c, 0x5c, 0xdc, 0x3c, 0xbc, 0x7c, 0xfc,
+        0x02, 0x82, 0x42, 0xc2, 0x22, 0xa2, 0x62, 0xe2,
+        0x12, 0x92, 0x52, 0xd2, 0x32, 0xb2, 0x72, 0xf2,
+        0x0a, 0x8a, 0x4a, 0xca, 0x2a, 0xaa, 0x6a, 0xea,
+        0x1a, 0x9a, 0x5a, 0xda, 0x3a, 0xba, 0x7a, 0xfa,
+        0x06, 0x86, 0x46, 0xc6, 0x26, 0xa6, 0x66, 0xe6,
+        0x16, 0x96, 0x56, 0xd6, 0x36, 0xb6, 0x76, 0xf6,
+        0x0e, 0x8e, 0x4e, 0xce, 0x2e, 0xae, 0x6e, 0xee,
+        0x1e, 0x9e, 0x5e, 0xde, 0x3e, 0xbe, 0x7e, 0xfe,
+        0x01, 0x81, 0x41, 0xc1, 0x21, 0xa1, 0x61, 0xe1,
+        0x11, 0x91, 0x51, 0xd1, 0x31, 0xb1, 0x71, 0xf1,
+        0x09, 0x89, 0x49, 0xc9, 0x29, 0xa9, 0x69, 0xe9,
+        0x19, 0x99, 0x59, 0xd9, 0x39, 0xb9, 0x79, 0xf9,
+        0x05, 0x85, 0x45, 0xc5, 0x25, 0xa5, 0x65, 0xe5,
+        0x15, 0x95, 0x55, 0xd5, 0x35, 0xb5, 0x75, 0xf5,
+        0x0d, 0x8d, 0x4d, 0xcd, 0x2d, 0xad, 0x6d, 0xed,
+        0x1d, 0x9d, 0x5d, 0xdd, 0x3d, 0xbd, 0x7d, 0xfd,
+        0x03, 0x83, 0x43, 0xc3, 0x23, 0xa3, 0x63, 0xe3,
+        0x13, 0x93, 0x53, 0xd3, 0x33, 0xb3, 0x73, 0xf3,
+        0x0b, 0x8b, 0x4b, 0xcb, 0x2b, 0xab, 0x6b, 0xeb,
+        0x1b, 0x9b, 0x5b, 0xdb, 0x3b, 0xbb, 0x7b, 0xfb,
+        0x07, 0x87, 0x47, 0xc7, 0x27, 0xa7, 0x67, 0xe7,
+        0x17, 0x97, 0x57, 0xd7, 0x37, 0xb7, 0x77, 0xf7,
+        0x0f, 0x8f, 0x4f, 0xcf, 0x2f, 0xaf, 0x6f, 0xef,
+        0x1f, 0x9f, 0x5f, 0xdf, 0x3f, 0xbf, 0x7f, 0xff,
+};
+EXPORT_SYMBOL_GPL(byte_rev_table);
+
+static __always_inline u16 bitrev16(u16 x)
+{
+        return (bitrev8(x & 0xff) << 8) | bitrev8(x >> 8);
+}
+
+/**
+ * bitrev32 - reverse the order of bits in a u32 value
+ * @x: value to be bit-reversed
+ */
+u32 bitrev32(u32 x)
+{
+        return (bitrev16(x & 0xffff) << 16) | bitrev16(x >> 16);
+}
+EXPORT_SYMBOL(bitrev32);
diff --git a/lib/bug.c b/lib/bug.c
new file mode 100644
index 000000000000..014b582c5c4b
--- /dev/null
+++ b/lib/bug.c
@@ -0,0 +1,163 @@
+/*
+  Generic support for BUG()
+
+  This respects the following config options:
+
+  CONFIG_BUG - emit BUG traps.  Nothing happens without this.
+  CONFIG_GENERIC_BUG - enable this code.
+  CONFIG_DEBUG_BUGVERBOSE - emit full file+line information for each BUG
+
+  CONFIG_BUG and CONFIG_DEBUG_BUGVERBOSE are potentially user-settable
+  (though they're generally always on).
+
+  CONFIG_GENERIC_BUG is set by each architecture using this code.
+
+  To use this, your architecture must:
+
+  1. Set up the config options:
+     - Enable CONFIG_GENERIC_BUG if CONFIG_BUG
+
+  2. Implement BUG (and optionally BUG_ON, WARN, WARN_ON)
+     - Define HAVE_ARCH_BUG
+     - Implement BUG() to generate a faulting instruction
+     - NOTE: struct bug_entry does not have "file" or "line" entries
+       when CONFIG_DEBUG_BUGVERBOSE is not enabled, so you must generate
+       the values accordingly.
+
+  3. Implement the trap
+     - In the illegal instruction trap handler (typically), verify
+       that the fault was in kernel mode, and call report_bug()
+     - report_bug() will return whether it was a false alarm, a warning,
+       or an actual bug.
+     - You must implement the is_valid_bugaddr(bugaddr) callback which
+       returns true if the eip is a real kernel address, and it points
+       to the expected BUG trap instruction.
+
+    Jeremy Fitzhardinge <jeremy@goop.org> 2006
+ */
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/bug.h>
+
+extern const struct bug_entry __start___bug_table[], __stop___bug_table[];
+
+#ifdef CONFIG_MODULES
+static LIST_HEAD(module_bug_list);
+
+static const struct bug_entry *module_find_bug(unsigned long bugaddr)
+{
+        struct module *mod;
+
+        list_for_each_entry(mod, &module_bug_list, bug_list) {
+                const struct bug_entry *bug = mod->bug_table;
+                unsigned i;
+
+                for (i = 0; i < mod->num_bugs; ++i, ++bug)
+                        if (bugaddr == bug->bug_addr)
+                                return bug;
+        }
+        return NULL;
+}
+
+int module_bug_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs,
+                        struct module *mod)
+{
+        char *secstrings;
+        unsigned int i;
+
+        mod->bug_table = NULL;
+        mod->num_bugs = 0;
+
+        /* Find the __bug_table section, if present */
+        secstrings = (char *)hdr + sechdrs[hdr->e_shstrndx].sh_offset;
+        for (i = 1; i < hdr->e_shnum; i++) {
+                if (strcmp(secstrings+sechdrs[i].sh_name, "__bug_table"))
+                        continue;
+                mod->bug_table = (void *) sechdrs[i].sh_addr;
+                mod->num_bugs = sechdrs[i].sh_size / sizeof(struct bug_entry);
+                break;
+        }
+
+        /*
+         * Strictly speaking this should have a spinlock to protect against
+         * traversals, but since we only traverse on BUG()s, a spinlock
+         * could potentially lead to deadlock and thus be counter-productive.
+         */
+        list_add(&mod->bug_list, &module_bug_list);
+
+        return 0;
+}
+
+void module_bug_cleanup(struct module *mod)
+{
+        list_del(&mod->bug_list);
+}
+
+#else
+
+static inline const struct bug_entry *module_find_bug(unsigned long bugaddr)
+{
+        return NULL;
+}
+#endif
+
+const struct bug_entry *find_bug(unsigned long bugaddr)
+{
+        const struct bug_entry *bug;
+
+        for (bug = __start___bug_table; bug < __stop___bug_table; ++bug)
+                if (bugaddr == bug->bug_addr)
+                        return bug;
+
+        return module_find_bug(bugaddr);
+}
+
+enum bug_trap_type report_bug(unsigned long bugaddr)
+{
+        const struct bug_entry *bug;
+        const char *file;
+        unsigned line, warning;
+
+        if (!is_valid_bugaddr(bugaddr))
+                return BUG_TRAP_TYPE_NONE;
+
+        bug = find_bug(bugaddr);
+
+        printk(KERN_EMERG "------------[ cut here ]------------\n");
+
+        file = NULL;
+        line = 0;
+        warning = 0;
+
+        if (bug) {
+#ifdef CONFIG_DEBUG_BUGVERBOSE
+                file = bug->file;
+                line = bug->line;
+#endif
+                warning = (bug->flags & BUGFLAG_WARNING) != 0;
+        }
+
+        if (warning) {
+                /* this is a WARN_ON rather than BUG/BUG_ON */
+                if (file)
+                        printk(KERN_ERR "Badness at %s:%u\n",
+                               file, line);
+                else
+                        printk(KERN_ERR "Badness at %p "
+                               "[verbose debug info unavailable]\n",
+                               (void *)bugaddr);
+
+                dump_stack();
+                return BUG_TRAP_TYPE_WARN;
+        }
+
+        if (file)
+                printk(KERN_CRIT "kernel BUG at %s:%u!\n",
+                       file, line);
+        else
+                printk(KERN_CRIT "Kernel BUG at %p "
+                       "[verbose debug info unavailable]\n",
+                       (void *)bugaddr);
+
+        return BUG_TRAP_TYPE_BUG;
+}
diff --git a/lib/crc32.c b/lib/crc32.c
index 285fd9bc61be..bfc33314c720 100644
--- a/lib/crc32.c
+++ b/lib/crc32.c
@@ -235,23 +235,8 @@ u32 __attribute_pure__ crc32_be(u32 crc, unsigned char const *p, size_t len)
 }
 #endif
 
-/**
- * bitreverse - reverse the order of bits in a u32 value
- * @x: value to be bit-reversed
- */
-u32 bitreverse(u32 x)
-{
-        x = (x >> 16) | (x << 16);
-        x = (x >> 8 & 0x00ff00ff) | (x << 8 & 0xff00ff00);
-        x = (x >> 4 & 0x0f0f0f0f) | (x << 4 & 0xf0f0f0f0);
-        x = (x >> 2 & 0x33333333) | (x << 2 & 0xcccccccc);
-        x = (x >> 1 & 0x55555555) | (x << 1 & 0xaaaaaaaa);
-        return x;
-}
-
 EXPORT_SYMBOL(crc32_le);
 EXPORT_SYMBOL(crc32_be);
-EXPORT_SYMBOL(bitreverse);
 
 /*
  * A brief CRC tutorial.
@@ -400,10 +385,7 @@ buf_dump(char const *prefix, unsigned char const *buf, size_t len)
 static void bytereverse(unsigned char *buf, size_t len)
 {
         while (len--) {
-                unsigned char x = *buf;
-                x = (x >> 4) | (x << 4);
-                x = (x >> 2 & 0x33) | (x << 2 & 0xcc);
-                x = (x >> 1 & 0x55) | (x << 1 & 0xaa);
+                unsigned char x = bitrev8(*buf);
                 *buf++ = x;
         }
 }
@@ -460,11 +442,11 @@ static u32 test_step(u32 init, unsigned char *buf, size_t len)
         /* Now swap it around for the other test */
 
         bytereverse(buf, len + 4);
-        init = bitreverse(init);
-        crc2 = bitreverse(crc1);
-        if (crc1 != bitreverse(crc2))
+        init = bitrev32(init);
+        crc2 = bitrev32(crc1);
+        if (crc1 != bitrev32(crc2))
                 printf("\nBit reversal fail: 0x%08x -> 0x%08x -> 0x%08x\n",
-                       crc1, crc2, bitreverse(crc2));
+                       crc1, crc2, bitrev32(crc2));
         crc1 = crc32_le(init, buf, len);
         if (crc1 != crc2)
                 printf("\nCRC endianness fail: 0x%08x != 0x%08x\n", crc1,
diff --git a/lib/fault-inject.c b/lib/fault-inject.c
new file mode 100644
index 000000000000..d143c0faf248
--- /dev/null
+++ b/lib/fault-inject.c
@@ -0,0 +1,336 @@
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/random.h>
+#include <linux/stat.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/interrupt.h>
+#include <linux/unwind.h>
+#include <linux/stacktrace.h>
+#include <linux/kallsyms.h>
+#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.
+ */
+int __init setup_fault_attr(struct fault_attr *attr, char *str)
+{
+        unsigned long probability;
+        unsigned long interval;
+        int times;
+        int space;
+
+        /* "<interval>,<probability>,<space>,<times>" */
+        if (sscanf(str, "%lu,%lu,%d,%d",
+                        &interval, &probability, &space, &times) < 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;
+}
+
+static void fail_dump(struct fault_attr *attr)
+{
+        if (attr->verbose > 0)
+                printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure\n");
+        if (attr->verbose > 1)
+                dump_stack();
+}
+
+#define atomic_dec_not_zero(v)          atomic_add_unless((v), -1, 0)
+
+static bool fail_task(struct fault_attr *attr, struct task_struct *task)
+{
+        return !in_interrupt() && task->make_it_fail;
+}
+
+#define MAX_STACK_TRACE_DEPTH 32
+
+#ifdef CONFIG_STACK_UNWIND
+
+static asmlinkage int fail_stacktrace_callback(struct unwind_frame_info *info,
+                                                void *arg)
+{
+        int depth;
+        struct fault_attr *attr = arg;
+        bool found = (attr->require_start == 0 && attr->require_end == ULONG_MAX);
+
+        for (depth = 0; depth < attr->stacktrace_depth
+                        && unwind(info) == 0 && UNW_PC(info); depth++) {
+                if (arch_unw_user_mode(info))
+                        break;
+                if (attr->reject_start <= UNW_PC(info) &&
+                               UNW_PC(info) < attr->reject_end)
+                        return false;
+                if (attr->require_start <= UNW_PC(info) &&
+                               UNW_PC(info) < attr->require_end)
+                        found = true;
+        }
+        return found;
+}
+
+static bool fail_stacktrace(struct fault_attr *attr)
+{
+        struct unwind_frame_info info;
+
+        return unwind_init_running(&info, fail_stacktrace_callback, attr);
+}
+
+#elif defined(CONFIG_STACKTRACE)
+
+static bool fail_stacktrace(struct fault_attr *attr)
+{
+        struct stack_trace trace;
+        int depth = attr->stacktrace_depth;
+        unsigned long entries[MAX_STACK_TRACE_DEPTH];
+        int n;
+        bool found = (attr->require_start == 0 && attr->require_end == ULONG_MAX);
+
+        if (depth == 0)
+                return found;
+
+        trace.nr_entries = 0;
+        trace.entries = entries;
+        trace.max_entries = depth;
+        trace.skip = 1;
+        trace.all_contexts = 0;
+
+        save_stack_trace(&trace, NULL);
+        for (n = 0; n < trace.nr_entries; n++) {
+                if (attr->reject_start <= entries[n] &&
+                               entries[n] < attr->reject_end)
+                        return false;
+                if (attr->require_start <= entries[n] &&
+                               entries[n] < attr->require_end)
+                        found = true;
+        }
+        return found;
+}
+
+#else
+
+static inline bool fail_stacktrace(struct fault_attr *attr)
+{
+        static bool firsttime = true;
+
+        if (firsttime) {
+                printk(KERN_WARNING
+                "This architecture does not implement save_stack_trace()\n");
+                firsttime = false;
+        }
+        return false;
+}
+
+#endif
+
+/*
+ * This code is stolen from failmalloc-1.0
+ * http://www.nongnu.org/failmalloc/
+ */
+
+bool should_fail(struct fault_attr *attr, ssize_t size)
+{
+        if (attr->task_filter && !fail_task(attr, current))
+                return false;
+
+        if (atomic_read(&attr->times) == 0)
+                return false;
+
+        if (atomic_read(&attr->space) > size) {
+                atomic_sub(size, &attr->space);
+                return false;
+        }
+
+        if (attr->interval > 1) {
+                attr->count++;
+                if (attr->count % attr->interval)
+                        return false;
+        }
+
+        if (attr->probability <= random32() % 100)
+                return false;
+
+        if (!fail_stacktrace(attr))
+                return false;
+
+        fail_dump(attr);
+
+        if (atomic_read(&attr->times) != -1)
+                atomic_dec_not_zero(&attr->times);
+
+        return true;
+}
+
+#ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
+
+static void debugfs_ul_set(void *data, u64 val)
+{
+        *(unsigned long *)data = val;
+}
+
+static void debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data, u64 val)
+{
+        *(unsigned long *)data =
+                val < MAX_STACK_TRACE_DEPTH ?
+                val : MAX_STACK_TRACE_DEPTH;
+}
+
+static u64 debugfs_ul_get(void *data)
+{
+        return *(unsigned long *)data;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_ul, debugfs_ul_get, debugfs_ul_set, "%llu\n");
+
+static struct dentry *debugfs_create_ul(const char *name, mode_t mode,
+                                struct dentry *parent, unsigned long *value)
+{
+        return debugfs_create_file(name, mode, parent, value, &fops_ul);
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_ul_MAX_STACK_TRACE_DEPTH, debugfs_ul_get,
+                        debugfs_ul_set_MAX_STACK_TRACE_DEPTH, "%llu\n");
+
+static struct dentry *debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
+        const char *name, mode_t mode,
+        struct dentry *parent, unsigned long *value)
+{
+        return debugfs_create_file(name, mode, parent, value,
+                                   &fops_ul_MAX_STACK_TRACE_DEPTH);
+}
+
+static void debugfs_atomic_t_set(void *data, u64 val)
+{
+        atomic_set((atomic_t *)data, val);
+}
+
+static u64 debugfs_atomic_t_get(void *data)
+{
+        return atomic_read((atomic_t *)data);
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
+                        debugfs_atomic_t_set, "%lld\n");
+
+static struct dentry *debugfs_create_atomic_t(const char *name, mode_t mode,
+                                struct dentry *parent, atomic_t *value)
+{
+        return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
+}
+
+void cleanup_fault_attr_dentries(struct fault_attr *attr)
+{
+        debugfs_remove(attr->dentries.probability_file);
+        attr->dentries.probability_file = NULL;
+
+        debugfs_remove(attr->dentries.interval_file);
+        attr->dentries.interval_file = NULL;
+
+        debugfs_remove(attr->dentries.times_file);
+        attr->dentries.times_file = NULL;
+
+        debugfs_remove(attr->dentries.space_file);
+        attr->dentries.space_file = NULL;
+
+        debugfs_remove(attr->dentries.verbose_file);
+        attr->dentries.verbose_file = NULL;
+
+        debugfs_remove(attr->dentries.task_filter_file);
+        attr->dentries.task_filter_file = NULL;
+
+        debugfs_remove(attr->dentries.stacktrace_depth_file);
+        attr->dentries.stacktrace_depth_file = NULL;
+
+        debugfs_remove(attr->dentries.require_start_file);
+        attr->dentries.require_start_file = NULL;
+
+        debugfs_remove(attr->dentries.require_end_file);
+        attr->dentries.require_end_file = NULL;
+
+        debugfs_remove(attr->dentries.reject_start_file);
+        attr->dentries.reject_start_file = NULL;
+
+        debugfs_remove(attr->dentries.reject_end_file);
+        attr->dentries.reject_end_file = NULL;
+
+        if (attr->dentries.dir)
+                WARN_ON(!simple_empty(attr->dentries.dir));
+
+        debugfs_remove(attr->dentries.dir);
+        attr->dentries.dir = NULL;
+}
+
+int init_fault_attr_dentries(struct fault_attr *attr, const char *name)
+{
+        mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
+        struct dentry *dir;
+
+        memset(&attr->dentries, 0, sizeof(attr->dentries));
+
+        dir = debugfs_create_dir(name, NULL);
+        if (!dir)
+                goto fail;
+        attr->dentries.dir = dir;
+
+        attr->dentries.probability_file =
+                debugfs_create_ul("probability", mode, dir, &attr->probability);
+
+        attr->dentries.interval_file =
+                debugfs_create_ul("interval", mode, dir, &attr->interval);
+
+        attr->dentries.times_file =
+                debugfs_create_atomic_t("times", mode, dir, &attr->times);
+
+        attr->dentries.space_file =
+                debugfs_create_atomic_t("space", mode, dir, &attr->space);
+
+        attr->dentries.verbose_file =
+                debugfs_create_ul("verbose", mode, dir, &attr->verbose);
+
+        attr->dentries.task_filter_file = debugfs_create_bool("task-filter",
+                                                mode, dir, &attr->task_filter);
+
+        attr->dentries.stacktrace_depth_file =
+                debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
+                        "stacktrace-depth", mode, dir, &attr->stacktrace_depth);
+
+        attr->dentries.require_start_file =
+                debugfs_create_ul("require-start", mode, dir, &attr->require_start);
+
+        attr->dentries.require_end_file =
+                debugfs_create_ul("require-end", mode, dir, &attr->require_end);
+
+        attr->dentries.reject_start_file =
+                debugfs_create_ul("reject-start", mode, dir, &attr->reject_start);
+
+        attr->dentries.reject_end_file =
+                debugfs_create_ul("reject-end", mode, dir, &attr->reject_end);
+
+
+        if (!attr->dentries.probability_file || !attr->dentries.interval_file
+            || !attr->dentries.times_file || !attr->dentries.space_file
+            || !attr->dentries.verbose_file || !attr->dentries.task_filter_file
+            || !attr->dentries.stacktrace_depth_file
+            || !attr->dentries.require_start_file
+            || !attr->dentries.require_end_file
+            || !attr->dentries.reject_start_file
+            || !attr->dentries.reject_end_file
+            )
+                goto fail;
+
+        return 0;
+fail:
+        cleanup_fault_attr_dentries(attr);
+        return -ENOMEM;
+}
+
+#endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */