Merge tag 'driver-core-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core

Pull driver core updates from Greg KH:
 "Here's the "big" driver core update for 4.7-rc1.

  Mostly just debugfs changes, the long-known and messy races with
  removing debugfs files should be fixed thanks to the great work of
  Nicolai Stange.  We also have some isa updates in here (the x86
  maintainers told me to take it through this tree), a new warning when
  we run out of dynamic char major numbers, and a few other assorted
  changes, details in the shortlog.

  All have been in linux-next for some time with no reported issues"

* tag 'driver-core-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/driver-core: (32 commits)
  Revert "base: dd: don't remove driver_data in -EPROBE_DEFER case"
  gpio: ws16c48: Utilize the ISA bus driver
  gpio: 104-idio-16: Utilize the ISA bus driver
  gpio: 104-idi-48: Utilize the ISA bus driver
  gpio: 104-dio-48e: Utilize the ISA bus driver
  watchdog: ebc-c384_wdt: Utilize the ISA bus driver
  iio: stx104: Utilize the module_isa_driver and max_num_isa_dev macros
  iio: stx104: Add X86 dependency to STX104 Kconfig option
  Documentation: Add ISA bus driver documentation
  isa: Implement the max_num_isa_dev macro
  isa: Implement the module_isa_driver macro
  pnp: pnpbios: Add explicit X86_32 dependency to PNPBIOS
  isa: Decouple X86_32 dependency from the ISA Kconfig option
  driver-core: use 'dev' argument in dev_dbg_ratelimited stub
  base: dd: don't remove driver_data in -EPROBE_DEFER case
  kernfs: Move faulting copy_user operations outside of the mutex
  devcoredump: add scatterlist support
  debugfs: unproxify files created through debugfs_create_u32_array()
  debugfs: unproxify files created through debugfs_create_blob()
  debugfs: unproxify files created through debugfs_create_bool()
  ...

1 files changed, 370 insertions, 66 deletions

diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index d2ba12e23ed9..9c1c9a01b7e5 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -22,6 +22,12 @@
 #include <linux/slab.h>
 #include <linux/atomic.h>
 #include <linux/device.h>
+#include <linux/srcu.h>
+#include <asm/poll.h>
+
+#include "internal.h"
+
+struct poll_table_struct;
 
 static ssize_t default_read_file(struct file *file, char __user *buf,
                                  size_t count, loff_t *ppos)
@@ -35,27 +41,293 @@ static ssize_t default_write_file(struct file *file, const char __user *buf,
         return count;
 }
 
-const struct file_operations debugfs_file_operations = {
+const struct file_operations debugfs_noop_file_operations = {
         .read =         default_read_file,
         .write =        default_write_file,
         .open =         simple_open,
         .llseek =       noop_llseek,
 };
 
-static struct dentry *debugfs_create_mode(const char *name, umode_t mode,
-                                          struct dentry *parent, void *value,
-                                          const struct file_operations *fops,
-                                          const struct file_operations *fops_ro,
-                                          const struct file_operations *fops_wo)
+/**
+ * debugfs_use_file_start - mark the beginning of file data access
+ * @dentry: the dentry object whose data is being accessed.
+ * @srcu_idx: a pointer to some memory to store a SRCU index in.
+ *
+ * Up to a matching call to debugfs_use_file_finish(), any
+ * successive call into the file removing functions debugfs_remove()
+ * and debugfs_remove_recursive() will block. Since associated private
+ * file data may only get freed after a successful return of any of
+ * the removal functions, you may safely access it after a successful
+ * call to debugfs_use_file_start() without worrying about
+ * lifetime issues.
+ *
+ * If -%EIO is returned, the file has already been removed and thus,
+ * it is not safe to access any of its data. If, on the other hand,
+ * it is allowed to access the file data, zero is returned.
+ *
+ * Regardless of the return code, any call to
+ * debugfs_use_file_start() must be followed by a matching call
+ * to debugfs_use_file_finish().
+ */
+int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx)
+        __acquires(&debugfs_srcu)
+{
+        *srcu_idx = srcu_read_lock(&debugfs_srcu);
+        barrier();
+        if (d_unlinked(dentry))
+                return -EIO;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(debugfs_use_file_start);
+
+/**
+ * debugfs_use_file_finish - mark the end of file data access
+ * @srcu_idx: the SRCU index "created" by a former call to
+ *            debugfs_use_file_start().
+ *
+ * Allow any ongoing concurrent call into debugfs_remove() or
+ * debugfs_remove_recursive() blocked by a former call to
+ * debugfs_use_file_start() to proceed and return to its caller.
+ */
+void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu)
+{
+        srcu_read_unlock(&debugfs_srcu, srcu_idx);
+}
+EXPORT_SYMBOL_GPL(debugfs_use_file_finish);
+
+#define F_DENTRY(filp) ((filp)->f_path.dentry)
+
+#define REAL_FOPS_DEREF(dentry)                                 \
+        ((const struct file_operations *)(dentry)->d_fsdata)
+
+static int open_proxy_open(struct inode *inode, struct file *filp)
+{
+        const struct dentry *dentry = F_DENTRY(filp);
+        const struct file_operations *real_fops = NULL;
+        int srcu_idx, r;
+
+        r = debugfs_use_file_start(dentry, &srcu_idx);
+        if (r) {
+                r = -ENOENT;
+                goto out;
+        }
+
+        real_fops = REAL_FOPS_DEREF(dentry);
+        real_fops = fops_get(real_fops);
+        if (!real_fops) {
+                /* Huh? Module did not clean up after itself at exit? */
+                WARN(1, "debugfs file owner did not clean up at exit: %pd",
+                        dentry);
+                r = -ENXIO;
+                goto out;
+        }
+        replace_fops(filp, real_fops);
+
+        if (real_fops->open)
+                r = real_fops->open(inode, filp);
+
+out:
+        fops_put(real_fops);
+        debugfs_use_file_finish(srcu_idx);
+        return r;
+}
+
+const struct file_operations debugfs_open_proxy_file_operations = {
+        .open = open_proxy_open,
+};
+
+#define PROTO(args...) args
+#define ARGS(args...) args
+
+#define FULL_PROXY_FUNC(name, ret_type, filp, proto, args)              \
+static ret_type full_proxy_ ## name(proto)                              \
+{                                                                       \
+        const struct dentry *dentry = F_DENTRY(filp);                   \
+        const struct file_operations *real_fops =                       \
+                REAL_FOPS_DEREF(dentry);                                \
+        int srcu_idx;                                                   \
+        ret_type r;                                                     \
+                                                                        \
+        r = debugfs_use_file_start(dentry, &srcu_idx);                  \
+        if (likely(!r))                                         \
+                r = real_fops->name(args);                              \
+        debugfs_use_file_finish(srcu_idx);                              \
+        return r;                                                       \
+}
+
+FULL_PROXY_FUNC(llseek, loff_t, filp,
+                PROTO(struct file *filp, loff_t offset, int whence),
+                ARGS(filp, offset, whence));
+
+FULL_PROXY_FUNC(read, ssize_t, filp,
+                PROTO(struct file *filp, char __user *buf, size_t size,
+                        loff_t *ppos),
+                ARGS(filp, buf, size, ppos));
+
+FULL_PROXY_FUNC(write, ssize_t, filp,
+                PROTO(struct file *filp, const char __user *buf, size_t size,
+                        loff_t *ppos),
+                ARGS(filp, buf, size, ppos));
+
+FULL_PROXY_FUNC(unlocked_ioctl, long, filp,
+                PROTO(struct file *filp, unsigned int cmd, unsigned long arg),
+                ARGS(filp, cmd, arg));
+
+static unsigned int full_proxy_poll(struct file *filp,
+                                struct poll_table_struct *wait)
+{
+        const struct dentry *dentry = F_DENTRY(filp);
+        const struct file_operations *real_fops = REAL_FOPS_DEREF(dentry);
+        int srcu_idx;
+        unsigned int r = 0;
+
+        if (debugfs_use_file_start(dentry, &srcu_idx)) {
+                debugfs_use_file_finish(srcu_idx);
+                return POLLHUP;
+        }
+
+        r = real_fops->poll(filp, wait);
+        debugfs_use_file_finish(srcu_idx);
+        return r;
+}
+
+static int full_proxy_release(struct inode *inode, struct file *filp)
+{
+        const struct dentry *dentry = F_DENTRY(filp);
+        const struct file_operations *real_fops = REAL_FOPS_DEREF(dentry);
+        const struct file_operations *proxy_fops = filp->f_op;
+        int r = 0;
+
+        /*
+         * We must not protect this against removal races here: the
+         * original releaser should be called unconditionally in order
+         * not to leak any resources. Releasers must not assume that
+         * ->i_private is still being meaningful here.
+         */
+        if (real_fops->release)
+                r = real_fops->release(inode, filp);
+
+        replace_fops(filp, d_inode(dentry)->i_fop);
+        kfree((void *)proxy_fops);
+        fops_put(real_fops);
+        return 0;
+}
+
+static void __full_proxy_fops_init(struct file_operations *proxy_fops,
+                                const struct file_operations *real_fops)
+{
+        proxy_fops->release = full_proxy_release;
+        if (real_fops->llseek)
+                proxy_fops->llseek = full_proxy_llseek;
+        if (real_fops->read)
+                proxy_fops->read = full_proxy_read;
+        if (real_fops->write)
+                proxy_fops->write = full_proxy_write;
+        if (real_fops->poll)
+                proxy_fops->poll = full_proxy_poll;
+        if (real_fops->unlocked_ioctl)
+                proxy_fops->unlocked_ioctl = full_proxy_unlocked_ioctl;
+}
+
+static int full_proxy_open(struct inode *inode, struct file *filp)
+{
+        const struct dentry *dentry = F_DENTRY(filp);
+        const struct file_operations *real_fops = NULL;
+        struct file_operations *proxy_fops = NULL;
+        int srcu_idx, r;
+
+        r = debugfs_use_file_start(dentry, &srcu_idx);
+        if (r) {
+                r = -ENOENT;
+                goto out;
+        }
+
+        real_fops = REAL_FOPS_DEREF(dentry);
+        real_fops = fops_get(real_fops);
+        if (!real_fops) {
+                /* Huh? Module did not cleanup after itself at exit? */
+                WARN(1, "debugfs file owner did not clean up at exit: %pd",
+                        dentry);
+                r = -ENXIO;
+                goto out;
+        }
+
+        proxy_fops = kzalloc(sizeof(*proxy_fops), GFP_KERNEL);
+        if (!proxy_fops) {
+                r = -ENOMEM;
+                goto free_proxy;
+        }
+        __full_proxy_fops_init(proxy_fops, real_fops);
+        replace_fops(filp, proxy_fops);
+
+        if (real_fops->open) {
+                r = real_fops->open(inode, filp);
+
+                if (filp->f_op != proxy_fops) {
+                        /* No protection against file removal anymore. */
+                        WARN(1, "debugfs file owner replaced proxy fops: %pd",
+                                dentry);
+                        goto free_proxy;
+                }
+        }
+
+        goto out;
+free_proxy:
+        kfree(proxy_fops);
+        fops_put(real_fops);
+out:
+        debugfs_use_file_finish(srcu_idx);
+        return r;
+}
+
+const struct file_operations debugfs_full_proxy_file_operations = {
+        .open = full_proxy_open,
+};
+
+ssize_t debugfs_attr_read(struct file *file, char __user *buf,
+                        size_t len, loff_t *ppos)
+{
+        ssize_t ret;
+        int srcu_idx;
+
+        ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
+        if (likely(!ret))
+                ret = simple_attr_read(file, buf, len, ppos);
+        debugfs_use_file_finish(srcu_idx);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(debugfs_attr_read);
+
+ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
+                         size_t len, loff_t *ppos)
+{
+        ssize_t ret;
+        int srcu_idx;
+
+        ret = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
+        if (likely(!ret))
+                ret = simple_attr_write(file, buf, len, ppos);
+        debugfs_use_file_finish(srcu_idx);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(debugfs_attr_write);
+
+static struct dentry *debugfs_create_mode_unsafe(const char *name, umode_t mode,
+                                        struct dentry *parent, void *value,
+                                        const struct file_operations *fops,
+                                        const struct file_operations *fops_ro,
+                                        const struct file_operations *fops_wo)
 {
         /* if there are no write bits set, make read only */
         if (!(mode & S_IWUGO))
-                return debugfs_create_file(name, mode, parent, value, fops_ro);
+                return debugfs_create_file_unsafe(name, mode, parent, value,
+                                                fops_ro);
         /* if there are no read bits set, make write only */
         if (!(mode & S_IRUGO))
-                return debugfs_create_file(name, mode, parent, value, fops_wo);
+                return debugfs_create_file_unsafe(name, mode, parent, value,
+                                                fops_wo);
 
-        return debugfs_create_file(name, mode, parent, value, fops);
+        return debugfs_create_file_unsafe(name, mode, parent, value, fops);
 }
 
 static int debugfs_u8_set(void *data, u64 val)
@@ -68,9 +340,9 @@ static int debugfs_u8_get(void *data, u64 *val)
         *val = *(u8 *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_ro, debugfs_u8_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 
 /**
  * debugfs_create_u8 - create a debugfs file that is used to read and write an unsigned 8-bit value
@@ -99,7 +371,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u8_wo, NULL, debugfs_u8_set, "%llu\n");
 struct dentry *debugfs_create_u8(const char *name, umode_t mode,
                                  struct dentry *parent, u8 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_u8,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u8,
                                    &fops_u8_ro, &fops_u8_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u8);
@@ -114,9 +386,9 @@ static int debugfs_u16_get(void *data, u64 *val)
         *val = *(u16 *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_ro, debugfs_u16_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 
 /**
  * debugfs_create_u16 - create a debugfs file that is used to read and write an unsigned 16-bit value
@@ -145,7 +417,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u16_wo, NULL, debugfs_u16_set, "%llu\n");
 struct dentry *debugfs_create_u16(const char *name, umode_t mode,
                                   struct dentry *parent, u16 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_u16,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u16,
                                    &fops_u16_ro, &fops_u16_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u16);
@@ -160,9 +432,9 @@ static int debugfs_u32_get(void *data, u64 *val)
         *val = *(u32 *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_ro, debugfs_u32_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 
 /**
  * debugfs_create_u32 - create a debugfs file that is used to read and write an unsigned 32-bit value
@@ -191,7 +463,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u32_wo, NULL, debugfs_u32_set, "%llu\n");
 struct dentry *debugfs_create_u32(const char *name, umode_t mode,
                                  struct dentry *parent, u32 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_u32,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u32,
                                    &fops_u32_ro, &fops_u32_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u32);
@@ -207,9 +479,9 @@ static int debugfs_u64_get(void *data, u64 *val)
         *val = *(u64 *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_ro, debugfs_u64_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 
 /**
  * debugfs_create_u64 - create a debugfs file that is used to read and write an unsigned 64-bit value
@@ -238,7 +510,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_u64_wo, NULL, debugfs_u64_set, "%llu\n");
 struct dentry *debugfs_create_u64(const char *name, umode_t mode,
                                  struct dentry *parent, u64 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_u64,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_u64,
                                    &fops_u64_ro, &fops_u64_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u64);
@@ -254,9 +526,10 @@ static int debugfs_ulong_get(void *data, u64 *val)
         *val = *(unsigned long *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong, debugfs_ulong_get, debugfs_ulong_set,
+                        "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_ro, debugfs_ulong_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 
 /**
  * debugfs_create_ulong - create a debugfs file that is used to read and write
@@ -286,26 +559,30 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_ulong_wo, NULL, debugfs_ulong_set, "%llu\n");
 struct dentry *debugfs_create_ulong(const char *name, umode_t mode,
                                     struct dentry *parent, unsigned long *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_ulong,
-                                   &fops_ulong_ro, &fops_ulong_wo);
+        return debugfs_create_mode_unsafe(name, mode, parent, value,
+                                        &fops_ulong, &fops_ulong_ro,
+                                        &fops_ulong_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_ulong);
 
-DEFINE_SIMPLE_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x8, debugfs_u8_get, debugfs_u8_set, "0x%02llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_ro, debugfs_u8_get, NULL, "0x%02llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x8_wo, NULL, debugfs_u8_set, "0x%02llx\n");
 
-DEFINE_SIMPLE_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set, "0x%04llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x16, debugfs_u16_get, debugfs_u16_set,
+                        "0x%04llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_ro, debugfs_u16_get, NULL, "0x%04llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x16_wo, NULL, debugfs_u16_set, "0x%04llx\n");
 
-DEFINE_SIMPLE_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set, "0x%08llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x32, debugfs_u32_get, debugfs_u32_set,
+                        "0x%08llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_ro, debugfs_u32_get, NULL, "0x%08llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x32_wo, NULL, debugfs_u32_set, "0x%08llx\n");
 
-DEFINE_SIMPLE_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set, "0x%016llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x64, debugfs_u64_get, debugfs_u64_set,
+                        "0x%016llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_ro, debugfs_u64_get, NULL, "0x%016llx\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 
 /*
  * debugfs_create_x{8,16,32,64} - create a debugfs file that is used to read and write an unsigned {8,16,32,64}-bit value
@@ -328,7 +605,7 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_x64_wo, NULL, debugfs_u64_set, "0x%016llx\n");
 struct dentry *debugfs_create_x8(const char *name, umode_t mode,
                                  struct dentry *parent, u8 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_x8,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x8,
                                    &fops_x8_ro, &fops_x8_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_x8);
@@ -346,7 +623,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x8);
 struct dentry *debugfs_create_x16(const char *name, umode_t mode,
                                  struct dentry *parent, u16 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_x16,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x16,
                                    &fops_x16_ro, &fops_x16_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_x16);
@@ -364,7 +641,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x16);
 struct dentry *debugfs_create_x32(const char *name, umode_t mode,
                                  struct dentry *parent, u32 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_x32,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x32,
                                    &fops_x32_ro, &fops_x32_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_x32);
@@ -382,7 +659,7 @@ EXPORT_SYMBOL_GPL(debugfs_create_x32);
 struct dentry *debugfs_create_x64(const char *name, umode_t mode,
                                  struct dentry *parent, u64 *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_x64,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_x64,
                                    &fops_x64_ro, &fops_x64_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_x64);
@@ -398,10 +675,10 @@ static int debugfs_size_t_get(void *data, u64 *val)
         *val = *(size_t *)data;
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
-                        "%llu\n");      /* %llu and %zu are more or less the same */
-DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t, debugfs_size_t_get, debugfs_size_t_set,
+                        "%llu\n"); /* %llu and %zu are more or less the same */
+DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_ro, debugfs_size_t_get, NULL, "%llu\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 
 /**
  * debugfs_create_size_t - create a debugfs file that is used to read and write an size_t value
@@ -416,8 +693,9 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_size_t_wo, NULL, debugfs_size_t_set, "%llu\n");
 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
                                      struct dentry *parent, size_t *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_size_t,
-                                   &fops_size_t_ro, &fops_size_t_wo);
+        return debugfs_create_mode_unsafe(name, mode, parent, value,
+                                        &fops_size_t, &fops_size_t_ro,
+                                        &fops_size_t_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_size_t);
 
@@ -431,10 +709,12 @@ static int debugfs_atomic_t_get(void *data, u64 *val)
         *val = atomic_read((atomic_t *)data);
         return 0;
 }
-DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
+DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
                         debugfs_atomic_t_set, "%lld\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL, "%lld\n");
-DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_ro, debugfs_atomic_t_get, NULL,
+                        "%lld\n");
+DEFINE_DEBUGFS_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set,
+                        "%lld\n");
 
 /**
  * debugfs_create_atomic_t - create a debugfs file that is used to read and
@@ -450,8 +730,9 @@ DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t_wo, NULL, debugfs_atomic_t_set, "%lld\n");
 struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
                                  struct dentry *parent, atomic_t *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_atomic_t,
-                                   &fops_atomic_t_ro, &fops_atomic_t_wo);
+        return debugfs_create_mode_unsafe(name, mode, parent, value,
+                                        &fops_atomic_t, &fops_atomic_t_ro,
+                                        &fops_atomic_t_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_atomic_t);
 
@@ -459,9 +740,17 @@ ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf,
                                size_t count, loff_t *ppos)
 {
         char buf[3];
-        bool *val = file->private_data;
+        bool val;
+        int r, srcu_idx;
 
-        if (*val)
+        r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
+        if (likely(!r))
+                val = *(bool *)file->private_data;
+        debugfs_use_file_finish(srcu_idx);
+        if (r)
+                return r;
+
+        if (val)
                 buf[0] = 'Y';
         else
                 buf[0] = 'N';
@@ -477,6 +766,7 @@ ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
         char buf[32];
         size_t buf_size;
         bool bv;
+        int r, srcu_idx;
         bool *val = file->private_data;
 
         buf_size = min(count, (sizeof(buf)-1));
@@ -484,8 +774,14 @@ ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf,
                 return -EFAULT;
 
         buf[buf_size] = '\0';
-        if (strtobool(buf, &bv) == 0)
-                *val = bv;
+        if (strtobool(buf, &bv) == 0) {
+                r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
+                if (likely(!r))
+                        *val = bv;
+                debugfs_use_file_finish(srcu_idx);
+                if (r)
+                        return r;
+        }
 
         return count;
 }
@@ -537,7 +833,7 @@ static const struct file_operations fops_bool_wo = {
 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
                                    struct dentry *parent, bool *value)
 {
-        return debugfs_create_mode(name, mode, parent, value, &fops_bool,
+        return debugfs_create_mode_unsafe(name, mode, parent, value, &fops_bool,
                                    &fops_bool_ro, &fops_bool_wo);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_bool);
@@ -546,8 +842,15 @@ static ssize_t read_file_blob(struct file *file, char __user *user_buf,
                               size_t count, loff_t *ppos)
 {
         struct debugfs_blob_wrapper *blob = file->private_data;
-        return simple_read_from_buffer(user_buf, count, ppos, blob->data,
-                        blob->size);
+        ssize_t r;
+        int srcu_idx;
+
+        r = debugfs_use_file_start(F_DENTRY(file), &srcu_idx);
+        if (likely(!r))
+                r = simple_read_from_buffer(user_buf, count, ppos, blob->data,
+                                        blob->size);
+        debugfs_use_file_finish(srcu_idx);
+        return r;
 }
 
 static const struct file_operations fops_blob = {
@@ -584,7 +887,7 @@ struct dentry *debugfs_create_blob(const char *name, umode_t mode,
                                    struct dentry *parent,
                                    struct debugfs_blob_wrapper *blob)
 {
-        return debugfs_create_file(name, mode, parent, blob, &fops_blob);
+        return debugfs_create_file_unsafe(name, mode, parent, blob, &fops_blob);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_blob);
 
@@ -689,7 +992,8 @@ struct dentry *debugfs_create_u32_array(const char *name, umode_t mode,
         data->array = array;
         data->elements = elements;
 
-        return debugfs_create_file(name, mode, parent, data, &u32_array_fops);
+        return debugfs_create_file_unsafe(name, mode, parent, data,
+                                        &u32_array_fops);
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u32_array);