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);