debugfs: per-file removal protection
Subsystems (4)
v2 cover debugfs: per-file removal protection
Hello Greg,
this is the second attempt to implement debugfs file removal protection at file granularity. The first one can be found at [1].
Note that I left out the IB/hfi1 people from the get_maintainer list and thus, sent this in RFC mode only because the following still needs to get sorted out:
1. It's still not clear whether something like [9/9] ("debugfs: free debugfs_fsdata instances") is actually wanted. Your advice welcome!
2. The kernel test robot complained about [2/9] ("debugfs: defer debugfs_fsdata allocation to first usage") in v1. Despite Xiaolong's support, I wasn't able to reproduce this, but I hope that the changes mentioned below resolve it now. We'll see.
Thanks,
Nicolai
[1] http://lkml.kernel.org/r/[email protected]
Changes to v1:
[2/9] ("debugfs: implement per-file removal protection")
- In an attempt to resolve the issue reported by the kernel test robot for v1, restrict the "extended removal logic" to regular files in __debugfs_remove().
[8/9] ("debugfs: defer debugfs_fsdata allocation to first usage")
- Following review from Johannes Berg, replace the WARN_ON in debugfs_real_fops() by a WARN + 'return NULL'. The return NULL is expected to crash current soon and serves as an alternative for a BUG_ON here.
- Mention the change in debugfs_real_fops() in the commit message.
[9/9] ("debugfs: free debugfs_fsdata instances")
- Following advice from Paul E. McKenney, make debugfs_file_get() release the RCU read section inbetween retry loop iterations.
- Fix a race in debugfs_file_get()'s path handling a concurrent debugfs_file_put(): the former must not "help out resetting ->d_fsdata" because this can wipe out another debugfs_file_get()'s achievements.
Nicolai Stange (9):
debugfs: add support for more elaborate ->d_fsdata
debugfs: implement per-file removal protection
debugfs: debugfs_real_fops(): drop __must_hold sparse annotation
debugfs: convert to debugfs_file_get() and -put() IB/hfi1: convert to debugfs_file_get() and -put()
debugfs: purge obsolete SRCU based removal protection
debugfs: call debugfs_real_fops() only after debugfs_file_get()
debugfs: defer debugfs_fsdata allocation to first usage
debugfs: free debugfs_fsdata instances
drivers/infiniband/hw/hfi1/debugfs.c | 20 +-- fs/debugfs/file.c | 278 ++++++++++++++++++++++++----------- fs/debugfs/inode.c | 60 ++++++-- fs/debugfs/internal.h | 15 ++ include/linux/debugfs.h | 33 +---- lib/Kconfig.debug | 1 - 6 files changed, 266 insertions(+), 141 deletions(-)
Signature · 1 line
2.12.2
RFC PATCH v2 1/9 debugfs: add support for more elaborate ->d_fsdata
Currently, the user provided fops, "real_fops", are stored directly into ->d_fsdata.
In order to be able to store more per-file state and thus prepare for more granular file removal protection, wrap the real_fops into a dynamically allocated container struct, debugfs_fsdata.
A struct debugfs_fsdata gets allocated at file creation and freed from the newly intoduced ->d_release().
Finally, move the implementation of debugfs_real_fops() out of the public debugfs header such that struct debugfs_fsdata's declaration can be kept private.
--- fs/debugfs/file.c | 12 ++++++++++++ fs/debugfs/inode.c | 22 +++++++++++++++++++--- fs/debugfs/internal.h | 4 ++++ include/linux/debugfs.h | 20 +++----------------- 4 files changed, 38 insertions(+), 20 deletions(-)
fs/debugfs/file.c +12 -0
@@ -97,6 +97,18 @@ EXPORT_SYMBOL_GPL(debugfs_use_file_finish);#define F_DENTRY (filp) ((filp)->f_path.dentry) +const struct file_operations *debugfs_real_fops (const struct file *filp) + __must_hold(&debugfs_srcu) +{ +struct debugfs_fsdata *fsd =F_DENTRY (filp)->d_fsdata; +/* +* Neither the pointer to the struct file_operations, nor its +* contents ever change -- srcu_dereference() is not needed here. +*/ +return fsd->real_fops; +} +EXPORT_SYMBOL_GPL (debugfs_real_fops); +static int open_proxy_open (struct inode *inode,struct file *filp) {const struct dentry *dentry =F_DENTRY (filp);
fs/debugfs/inode.c +19 -3
@@ -185,6 +185,11 @@ static const struct super_operations debugfs_super_operations = { .evict_inode = debugfs_evict_inode, }; +static void debugfs_release_dentry (struct dentry *dentry) +{ +kfree (dentry->d_fsdata); +} +static struct vfsmount *debugfs_automount (struct path *path) {debugfs_automount_t f;
@@ -194,6 +199,7 @@ static struct vfsmount *debugfs_automount(struct path *path)static const struct dentry_operations debugfs_dops = { .d_delete = always_delete_dentry, + .d_release = debugfs_release_dentry, .d_automount = debugfs_automount, };
@@ -343,24 +349,34 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode, {struct dentry *dentry;struct inode *inode; +struct debugfs_fsdata *fsd; + + fsd =kmalloc (sizeof (*fsd),GFP_KERNEL ); +if (!fsd) +return NULL ;if (!(mode &S_IFMT )) mode |=S_IFREG ;BUG_ON (!S_ISREG (mode)); dentry =start_creating (name, parent); -if (IS_ERR (dentry)) +if (IS_ERR (dentry)) { +kfree (fsd);return NULL ; + } inode =debugfs_get_inode (dentry->d_sb); -if (unlikely (!inode)) +if (unlikely (!inode)) { +kfree (fsd);return failed_creating (dentry); + } inode->i_mode = mode; inode->i_private = data; inode->i_fop = proxy_fops; - dentry->d_fsdata = (void *)real_fops; + fsd->real_fops = real_fops; + dentry->d_fsdata = fsd;d_instantiate (dentry, inode);fsnotify_create (d_inode (dentry->d_parent), dentry);
fs/debugfs/internal.h +4 -0
@@ -19,4 +19,8 @@ extern const struct file_operations debugfs_noop_file_operations;extern const struct file_operations debugfs_open_proxy_file_operations;extern const struct file_operations debugfs_full_proxy_file_operations; +struct debugfs_fsdata { +const struct file_operations *real_fops; +}; +#endif /* _DEBUGFS_INTERNAL_H_ */
include/linux/debugfs.h +3 -17
@@ -45,23 +45,6 @@ extern struct dentry *arch_debugfs_dir;extern struct srcu_struct debugfs_srcu; -/** -* debugfs_real_fops - getter for the real file operation -* @filp: a pointer to a struct file -* -* Must only be called under the protection established by -* debugfs_use_file_start(). -*/ -static inline const struct file_operations *debugfs_real_fops (const struct file *filp) - __must_hold(&debugfs_srcu) -{ -/* -* Neither the pointer to the struct file_operations, nor its -* contents ever change -- srcu_dereference() is not needed here. -*/ -return filp->f_path.dentry->d_fsdata; -} -#define DEFINE_DEBUGFS_ATTRIBUTE (__fops, __get, __set, __fmt) \ static int __fops ## _open(struct inode *inode, struct file *file) \ { \
@@ -112,6 +95,9 @@ int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx) void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu); +const struct file_operations *debugfs_real_fops (const struct file *filp) + __must_hold(&debugfs_srcu); +ssize_t debugfs_attr_read (struct file *file,char __user *buf,size_t len,loff_t *ppos); ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
Signature · 1 line
2.12.2
RFC PATCH v2 2/9 debugfs: implement per-file removal protection
In reply to Nicolai StangeSince commit 49d200deaa68 ("debugfs: prevent access to removed files' private data"), accesses to a file's private data are protected from concurrent removal by covering all file_operations with a SRCU read section and sychronizing with those before returning from debugfs_remove() by means of synchronize_srcu().
As pointed out by Johannes Berg, there are debugfs files with forever blocking file_operations. Their corresponding SRCU read side sections would block any debugfs_remove() forever as well, even unrelated ones. This results in a livelock. Because a remover can't cancel any indefinite blocking within foreign files, this is a problem.
Resolve this by introducing support for more granular protection on a per-file basis.
This is implemented by introducing an 'active_users' refcount_t to the per-file struct debugfs_fsdata state. At file creation time, it is set to one and a debugfs_remove() will drop that initial reference. The new debugfs_file_get() and debugfs_file_put(), intended to be used in place of former debugfs_use_file_start() and debugfs_use_file_finish(), increment and decrement it respectively. Once the count drops to zero, debugfs_file_put() will signal a completion which is possibly being waited for from debugfs_remove().
Thus, as long as there is a debugfs_file_get() not yet matched by a corresponding debugfs_file_put() around, debugfs_remove() will block.
Actual users of debugfs_use_file_start() and -finish() will get converted to the new debugfs_file_get() and debugfs_file_put() by followup patches.
data")
--- fs/debugfs/file.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ fs/debugfs/inode.c | 29 +++++++++++++++++++++++------ fs/debugfs/internal.h | 2 ++ include/linux/debugfs.h | 11 +++++++++++ 4 files changed, 84 insertions(+), 6 deletions(-)
fs/debugfs/file.c +48 -0
@@ -109,6 +109,54 @@ const struct file_operations *debugfs_real_fops(const struct file *filp) }EXPORT_SYMBOL_GPL (debugfs_real_fops); +/** +* debugfs_file_get - mark the beginning of file data access +* @dentry: the dentry object whose data is being accessed. +* +* Up to a matching call to debugfs_file_put(), 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_file_get() 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. +*/ +int debugfs_file_get (struct dentry *dentry) +{ +struct debugfs_fsdata *fsd = dentry->d_fsdata; + +/* Avoid starvation of removers. */ +if (d_unlinked (dentry)) +return -EIO ; + +if (!refcount_inc_not_zero (&fsd->active_users)) +return -EIO ; + +return 0 ; +} +EXPORT_SYMBOL_GPL (debugfs_file_get); + +/** +* debugfs_file_put - mark the end of file data access +* @dentry: the dentry object formerly passed to +* debugfs_file_get(). +* +* Allow any ongoing concurrent call into debugfs_remove() or +* debugfs_remove_recursive() blocked by a former call to +* debugfs_file_get() to proceed and return to its caller. +*/ +void debugfs_file_put (struct dentry *dentry) +{ +struct debugfs_fsdata *fsd = dentry->d_fsdata; + +if (refcount_dec_and_test (&fsd->active_users)) +complete (&fsd->active_users_drained); +} +EXPORT_SYMBOL_GPL (debugfs_file_put); +static int open_proxy_open (struct inode *inode,struct file *filp) {const struct dentry *dentry =F_DENTRY (filp);
fs/debugfs/inode.c +23 -6
@@ -376,6 +376,7 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode, inode->i_fop = proxy_fops; fsd->real_fops = real_fops; +refcount_set (&fsd->active_users,1 ); dentry->d_fsdata = fsd;d_instantiate (dentry, inode);
@@ -633,18 +634,34 @@ struct dentry *debugfs_create_symlink(const char *name, struct dentry *parent, }EXPORT_SYMBOL_GPL (debugfs_create_symlink); +static void __debugfs_remove_file (struct dentry *dentry,struct dentry *parent) +{ +struct debugfs_fsdata *fsd; + +simple_unlink (d_inode (parent), dentry); +d_delete (dentry); + fsd = dentry->d_fsdata; +init_completion (&fsd->active_users_drained); +if (!refcount_dec_and_test (&fsd->active_users)) +wait_for_completion (&fsd->active_users_drained); +} +static int __debugfs_remove (struct dentry *dentry,struct dentry *parent) {int ret =0 ;if (simple_positive (dentry)) {dget (dentry); -if (d_is_dir (dentry)) - ret =simple_rmdir (d_inode (parent), dentry); -else -simple_unlink (d_inode (parent), dentry); -if (!ret) -d_delete (dentry); +if (!d_is_reg (dentry)) { +if (d_is_dir (dentry)) + ret =simple_rmdir (d_inode (parent), dentry); +else +simple_unlink (d_inode (parent), dentry); +if (!ret) +d_delete (dentry); + }else { +__debugfs_remove_file (dentry, parent); + }dput (dentry); }return ret;
fs/debugfs/internal.h +2 -0
@@ -21,6 +21,8 @@ extern const struct file_operations debugfs_full_proxy_file_operations;struct debugfs_fsdata {const struct file_operations *real_fops; +refcount_t active_users; +struct completion active_users_drained; };#endif /* _DEBUGFS_INTERNAL_H_ */
include/linux/debugfs.h +11 -0
@@ -98,6 +98,9 @@ void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu);const struct file_operations *debugfs_real_fops (const struct file *filp) __must_hold(&debugfs_srcu); +int debugfs_file_get (struct dentry *dentry); +void debugfs_file_put (struct dentry *dentry); +ssize_t debugfs_attr_read (struct file *file,char __user *buf,size_t len,loff_t *ppos); ssize_t debugfs_attr_write(struct file *file, const char __user *buf,
@@ -228,6 +231,14 @@ static inline void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu) { } +static inline int debugfs_file_get (struct dentry *dentry) +{ +return 0 ; +} + +static inline void debugfs_file_put (struct dentry *dentry) +{ } +static inline ssize_t debugfs_attr_read (struct file *file,char __user *buf,size_t len,loff_t *ppos) {
Signature · 1 line
2.12.2
RFC PATCH v2 3/9 debugfs: debugfs_real_fops(): drop __must_hold sparse annotation
In reply to Nicolai StangeCurrently, debugfs_real_fops() is annotated with a __must_hold(&debugfs_srcu) sparse annotation.
With the conversion of the SRCU based protection of users against concurrent file removals to a per-file refcount based scheme, this becomes wrong.
Drop this annotation.
--- fs/debugfs/file.c | 6 +----- include/linux/debugfs.h | 3 +-- 2 files changed, 2 insertions(+), 7 deletions(-)
fs/debugfs/file.c +1 -5
@@ -98,13 +98,9 @@ EXPORT_SYMBOL_GPL(debugfs_use_file_finish);#define F_DENTRY (filp) ((filp)->f_path.dentry)const struct file_operations *debugfs_real_fops (const struct file *filp) - __must_hold(&debugfs_srcu) {struct debugfs_fsdata *fsd =F_DENTRY (filp)->d_fsdata; -/* -* Neither the pointer to the struct file_operations, nor its -* contents ever change -- srcu_dereference() is not needed here. -*/ +return fsd->real_fops; }EXPORT_SYMBOL_GPL (debugfs_real_fops);
include/linux/debugfs.h +1 -2
@@ -95,8 +95,7 @@ int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx) void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu); -const struct file_operations *debugfs_real_fops (const struct file *filp) - __must_hold(&debugfs_srcu); +const struct file_operations *debugfs_real_fops (const struct file *filp);int debugfs_file_get (struct dentry *dentry);void debugfs_file_put (struct dentry *dentry);
Signature · 1 line
2.12.2
RFC PATCH v2 4/9 debugfs: convert to debugfs_file_get() and -put()
In reply to Nicolai StangeConvert all calls to the now obsolete debugfs_use_file_start() and debugfs_use_file_finish() from the debugfs core itself to the new debugfs_file_get() and debugfs_file_put() API.
data")
--- fs/debugfs/file.c | 106 ++++++++++++++++++++++++++---------------------------- 1 file changed, 50 insertions(+), 56 deletions(-)
fs/debugfs/file.c +50 -56
@@ -155,15 +155,12 @@ EXPORT_SYMBOL_GPL(debugfs_file_put);static int open_proxy_open (struct inode *inode,struct file *filp) { -const struct dentry *dentry =F_DENTRY (filp); +struct dentry *dentry =F_DENTRY (filp);const struct file_operations *real_fops =NULL ; -int srcu_idx, r; +int r =0 ; - r =debugfs_use_file_start (dentry, &srcu_idx); -if (r) { - r = -ENOENT ; - goto out; - } +if (debugfs_file_get (dentry)) +return -ENOENT ; real_fops =debugfs_real_fops (filp); real_fops =fops_get (real_fops);
@@ -180,7 +177,7 @@ static int open_proxy_open(struct inode *inode, struct file *filp) r = real_fops->open (inode, filp); out: -debugfs_use_file_finish (srcu_idx); +debugfs_file_put (dentry);return r; }
@@ -194,16 +191,16 @@ const struct file_operations debugfs_open_proxy_file_operations = {#define FULL_PROXY_FUNC (name, ret_type, filp, proto, args) \ static ret_type full_proxy_ ## name(proto) \ { \ - const struct dentry *dentry = F_DENTRY(filp); \ + struct dentry *dentry = F_DENTRY(filp); \ const struct file_operations *real_fops = \ debugfs_real_fops(filp); \ - 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); \ + r = debugfs_file_get(dentry); \ + if (unlikely(r)) \ + return r; \ + r = real_fops->name(args); \ + debugfs_file_put(dentry); \ return r; \ }
@@ -228,18 +225,15 @@ FULL_PROXY_FUNC(unlocked_ioctl, long, filp,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 =debugfs_real_fops (filp); -int srcu_idx; +struct dentry *dentry =F_DENTRY (filp);unsigned int r =0 ; -if (debugfs_use_file_start (dentry, &srcu_idx)) { -debugfs_use_file_finish (srcu_idx); +if (debugfs_file_get (dentry))return POLLHUP ; - } r = real_fops->poll (filp, wait); -debugfs_use_file_finish (srcu_idx); +debugfs_file_put (dentry);return r; }
@@ -283,16 +277,13 @@ static void __full_proxy_fops_init(struct file_operations *proxy_fops,static int full_proxy_open (struct inode *inode,struct file *filp) { -const struct dentry *dentry =F_DENTRY (filp); +struct dentry *dentry =F_DENTRY (filp);const struct file_operations *real_fops =NULL ;struct file_operations *proxy_fops =NULL ; -int srcu_idx, r; +int r =0 ; - r =debugfs_use_file_start (dentry, &srcu_idx); -if (r) { - r = -ENOENT ; - goto out; - } +if (debugfs_file_get (dentry)) +return -ENOENT ; real_fops =debugfs_real_fops (filp); real_fops =fops_get (real_fops);
@@ -330,7 +321,7 @@ static int full_proxy_open(struct inode *inode, struct file *filp)kfree (proxy_fops);fops_put (real_fops); out: -debugfs_use_file_finish (srcu_idx); +debugfs_file_put (dentry);return r; }
@@ -341,13 +332,14 @@ const struct file_operations debugfs_full_proxy_file_operations = {ssize_t debugfs_attr_read (struct file *file,char __user *buf,size_t len,loff_t *ppos) { +struct dentry *dentry =F_DENTRY (file);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); + ret =debugfs_file_get (dentry); +if (unlikely (ret)) +return ret; + ret =simple_attr_read (file, buf, len, ppos); +debugfs_file_put (dentry);return ret; }EXPORT_SYMBOL_GPL (debugfs_attr_read);
@@ -355,13 +347,14 @@ EXPORT_SYMBOL_GPL(debugfs_attr_read);ssize_t debugfs_attr_write (struct file *file,const char __user *buf,size_t len,loff_t *ppos) { +struct dentry *dentry =F_DENTRY (file);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); + ret =debugfs_file_get (dentry); +if (unlikely (ret)) +return ret; + ret =simple_attr_write (file, buf, len, ppos); +debugfs_file_put (dentry);return ret; }EXPORT_SYMBOL_GPL (debugfs_attr_write);
@@ -795,14 +788,14 @@ ssize_t debugfs_read_file_bool(struct file *file, char __user *user_buf, {char buf[3 ];bool val; -int r, srcu_idx; +int r; +struct dentry *dentry =F_DENTRY (file); - 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) + r =debugfs_file_get (dentry); +if (unlikely (r))return r; + val = *(bool *)file->private_data; +debugfs_file_put (dentry);if (val) buf[0 ] ='Y' ;
@@ -820,8 +813,9 @@ 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; +int r;bool *val = file->private_data; +struct dentry *dentry =F_DENTRY (file); buf_size =min (count, (sizeof (buf)-1 ));if (copy_from_user (buf, user_buf, buf_size))
@@ -829,12 +823,11 @@ ssize_t debugfs_write_file_bool(struct file *file, const char __user *user_buf, buf[buf_size] ='\0' ;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) + r =debugfs_file_get (dentry); +if (unlikely (r))return r; + *val = bv; +debugfs_file_put (dentry); }return count;
@@ -896,14 +889,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; +struct dentry *dentry =F_DENTRY (file);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); + r =debugfs_file_get (dentry); +if (unlikely (r)) +return r; + r =simple_read_from_buffer (user_buf, count, ppos, blob->data, + blob->size); +debugfs_file_put (dentry);return r; }
Signature · 1 line
2.12.2
RFC PATCH v2 5/9 IB/hfi1: convert to debugfs_file_get() and -put()
In reply to Nicolai StangeConvert all calls to the now obsolete debugfs_use_file_start() and debugfs_use_file_finish() to the new debugfs_file_get() and debugfs_file_put() API.
data")
--- drivers/infiniband/hw/hfi1/debugfs.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
drivers/infiniband/hw/hfi1/debugfs.c +10 -10
@@ -72,13 +72,13 @@ static ssize_t hfi1_seq_read( loff_t *ppos) {struct dentry *d = file->f_path.dentry; -int srcu_idx;ssize_t r; - r =debugfs_use_file_start (d, &srcu_idx); -if (likely (!r)) - r =seq_read (file, buf, size, ppos); -debugfs_use_file_finish (srcu_idx); + r =debugfs_file_get (d); +if (unlikely (r)) +return r; + r =seq_read (file, buf, size, ppos); +debugfs_file_put (d);return r; }
@@ -88,13 +88,13 @@ static loff_t hfi1_seq_lseek( int whence) {struct dentry *d = file->f_path.dentry; -int srcu_idx;loff_t r; - r =debugfs_use_file_start (d, &srcu_idx); -if (likely (!r)) - r =seq_lseek (file, offset, whence); -debugfs_use_file_finish (srcu_idx); + r =debugfs_file_get (d); +if (unlikely (r)) +return r; + r =seq_lseek (file, offset, whence); +debugfs_file_put (d);return r; }
Signature · 1 line
2.12.2
RFC PATCH v2 6/9 debugfs: purge obsolete SRCU based removal protection
In reply to Nicolai StangePurge the SRCU based file removal race protection in favour of the new, refcount based debugfs_file_get()/debugfs_file_put() API.
data")
--- fs/debugfs/file.c | 48 ------------------------------------------------ fs/debugfs/inode.c | 7 ------- include/linux/debugfs.h | 19 ------------------- lib/Kconfig.debug | 1 - 4 files changed, 75 deletions(-)
fs/debugfs/file.c +0 -48
@@ -22,7 +22,6 @@#include <linux/slab.h> #include <linux/atomic.h> #include <linux/device.h> -#include <linux/srcu.h> #include <asm/poll.h> #include "internal.h"
@@ -48,53 +47,6 @@ const struct file_operations debugfs_noop_file_operations = { .llseek = noop_llseek, }; -/** -* 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)const struct file_operations *debugfs_real_fops (const struct file *filp)
fs/debugfs/inode.c +0 -7
@@ -27,14 +27,11 @@#include <linux/parser.h> #include <linux/magic.h> #include <linux/slab.h> -#include <linux/srcu.h> #include "internal.h" #define DEBUGFS_DEFAULT_MODE 0700 -DEFINE_SRCU (debugfs_srcu); -static struct vfsmount *debugfs_mount;static int debugfs_mount_count;static bool debugfs_registered;
@@ -695,8 +692,6 @@ void debugfs_remove(struct dentry *dentry)inode_unlock (d_inode (parent));if (!ret)simple_release_fs (&debugfs_mount, &debugfs_mount_count); - -synchronize_srcu (&debugfs_srcu); }EXPORT_SYMBOL_GPL (debugfs_remove);
@@ -770,8 +765,6 @@ void debugfs_remove_recursive(struct dentry *dentry)if (!__debugfs_remove (child, parent))simple_release_fs (&debugfs_mount, &debugfs_mount_count);inode_unlock (d_inode (parent)); - -synchronize_srcu (&debugfs_srcu); }EXPORT_SYMBOL_GPL (debugfs_remove_recursive);
include/linux/debugfs.h +0 -19
@@ -23,7 +23,6 @@struct device ;struct file_operations ; -struct srcu_struct ;struct debugfs_blob_wrapper {void *data;
@@ -43,8 +42,6 @@ struct debugfs_regset32 {extern struct dentry *arch_debugfs_dir; -extern struct srcu_struct debugfs_srcu; -#define DEFINE_DEBUGFS_ATTRIBUTE (__fops, __get, __set, __fmt) \ static int __fops ## _open(struct inode *inode, struct file *file) \ { \
@@ -90,11 +87,6 @@ struct dentry *debugfs_create_automount(const char *name,void debugfs_remove (struct dentry *dentry);void debugfs_remove_recursive (struct dentry *dentry); -int debugfs_use_file_start(const struct dentry *dentry, int *srcu_idx) - __acquires(&debugfs_srcu); - -void debugfs_use_file_finish(int srcu_idx) __releases(&debugfs_srcu); -const struct file_operations *debugfs_real_fops (const struct file *filp);int debugfs_file_get (struct dentry *dentry);
@@ -219,17 +211,6 @@ static inline void debugfs_remove(struct dentry *dentry)static inline void debugfs_remove_recursive (struct dentry *dentry) { } -static inline int debugfs_use_file_start (const struct dentry *dentry, -int *srcu_idx) - __acquires(&debugfs_srcu) -{ -return 0 ; -} - -static inline void debugfs_use_file_finish (int srcu_idx) - __releases(&debugfs_srcu) -{ } -static inline int debugfs_file_get (struct dentry *dentry) {return 0 ;
lib/Kconfig.debug +0 -1
@@ -279,7 +279,6 @@ config PAGE_OWNER config DEBUG_FS bool "Debug Filesystem" - select SRCU 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
Signature · 1 line
2.12.2
RFC PATCH v2 7/9 debugfs: call debugfs_real_fops() only after debugfs_file_get()
In reply to Nicolai StangeThe current implementation of debugfs_real_fops() relies on a debugfs_fsdata instance to be installed at ->d_fsdata.
With future patches introducing lazy allocation of these, this requirement will be guaranteed to be fullfilled only inbetween a debugfs_file_get()/debugfs_file_put() pair.
The full proxies' fops implemented by debugfs happen to be the only offenders. Fix them up by moving their debugfs_real_fops() calls past those to debugfs_file_get().
full_proxy_release() is special as it doesn't invoke debugfs_file_get() at all. Leave it alone for now.
--- fs/debugfs/file.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
fs/debugfs/file.c +4 -3
@@ -144,13 +144,13 @@ const struct file_operations debugfs_open_proxy_file_operations = { static ret_type full_proxy_ ## name(proto) \ { \struct dentry *dentry =F_DENTRY (filp); \ -const struct file_operations *real_fops = \ -debugfs_real_fops (filp); \ +const struct file_operations *real_fops; \ret_type r; \ \ r =debugfs_file_get (dentry); \if (unlikely (r)) \return r; \ + real_fops =debugfs_real_fops (filp); \ r = real_fops->name (args); \debugfs_file_put (dentry); \return r; \
@@ -177,13 +177,14 @@ FULL_PROXY_FUNC(unlocked_ioctl, long, filp,static unsigned int full_proxy_poll (struct file *filp,struct poll_table_struct *wait) { -const struct file_operations *real_fops =debugfs_real_fops (filp);struct dentry *dentry =F_DENTRY (filp);unsigned int r =0 ; +const struct file_operations *real_fops;if (debugfs_file_get (dentry))return POLLHUP ; + real_fops =debugfs_real_fops (filp); r = real_fops->poll (filp, wait);debugfs_file_put (dentry);return r;
Signature · 1 line
2.12.2
RFC PATCH v2 8/9 debugfs: defer debugfs_fsdata allocation to first usage
In reply to Nicolai StangeCurrently, __debugfs_create_file allocates one struct debugfs_fsdata instance for every file created. However, there are potentially many debugfs file around, most of which are never touched by userspace.
Thus, defer the allocations to the first usage, i.e. to the first debugfs_file_get().
A dentry's ->d_fsdata starts out to point to the "real", user provided fops. After a debugfs_fsdata instance has been allocated (and the real fops pointer has been moved over into its ->real_fops member), ->d_fsdata is changed to point to it from then on. The two cases are distinguished by setting BIT(0) for the real fops case.
struct debugfs_fsdata's foremost purpose is to track active users and to make debugfs_remove() block until they are done. Since no debugfs_fsdata instance means no active users, make debugfs_remove() return immediately in this case.
Take care of possible races between debugfs_file_get() and debugfs_remove(): either debugfs_remove() must see a debugfs_fsdata instance and thus wait for possible active users or debugfs_file_get() must see a dead dentry and return immediately.
Make a dentry's ->d_release(), i.e. debugfs_release_dentry(), check whether ->d_fsdata is actually a debugfs_fsdata instance before kfree()ing it.
Similarly, make debugfs_real_fops() check whether ->d_fsdata is actually a debugfs_fsdata instance before returning it, otherwise emit a warning.
The set of possible error codes returned from debugfs_file_get() has grown from -EIO to -EIO and -ENOMEM. Make open_proxy_open() and full_proxy_open() pass the -ENOMEM onwards to their callers.
--- fs/debugfs/file.c | 55 ++++++++++++++++++++++++++++++++++++++++++--------- fs/debugfs/inode.c | 36 +++++++++++++++++---------------- fs/debugfs/internal.h | 8 ++++++++ 3 files changed, 73 insertions(+), 26 deletions(-)
fs/debugfs/file.c +46 -9
@@ -53,6 +53,15 @@ const struct file_operations *debugfs_real_fops(const struct file *filp) {struct debugfs_fsdata *fsd =F_DENTRY (filp)->d_fsdata; +if ((unsigned long )fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ) { +/* +* Urgh, we've been called w/o a protecting +* debugfs_file_get(). +*/ +WARN_ON (1 ); +return NULL ; + } +return fsd->real_fops; }EXPORT_SYMBOL_GPL (debugfs_real_fops);
@@ -74,9 +83,35 @@ EXPORT_SYMBOL_GPL(debugfs_real_fops);*/ int debugfs_file_get (struct dentry *dentry) { -struct debugfs_fsdata *fsd = dentry->d_fsdata; +struct debugfs_fsdata *fsd; +void *d_fsd; + + d_fsd =READ_ONCE (dentry->d_fsdata); +if (!((unsigned long )d_fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT )) { + fsd = d_fsd; + }else { + fsd =kmalloc (sizeof (*fsd),GFP_KERNEL ); +if (!fsd) +return -ENOMEM ; + + fsd->real_fops = (void *)((unsigned long )d_fsd & + ~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ); +refcount_set (&fsd->active_users,1 ); +init_completion (&fsd->active_users_drained); +if (cmpxchg (&dentry->d_fsdata, d_fsd, fsd) != d_fsd) { +kfree (fsd); + fsd =READ_ONCE (dentry->d_fsdata); + } + } -/* Avoid starvation of removers. */ +/* +* In case of a successful cmpxchg() above, this check is +* strictly necessary and must follow it, see the comment in +* __debugfs_remove_file(). +* OTOH, if the cmpxchg() hasn't been executed or wasn't +* successful, this serves the purpose of not starving +* removers. +*/ if (d_unlinked (dentry))return -EIO ;
@@ -98,7 +133,7 @@ EXPORT_SYMBOL_GPL(debugfs_file_get);*/ void debugfs_file_put (struct dentry *dentry) { -struct debugfs_fsdata *fsd = dentry->d_fsdata; +struct debugfs_fsdata *fsd =READ_ONCE (dentry->d_fsdata);if (refcount_dec_and_test (&fsd->active_users))complete (&fsd->active_users_drained);
@@ -109,10 +144,11 @@ static int open_proxy_open(struct inode *inode, struct file *filp) {struct dentry *dentry =F_DENTRY (filp);const struct file_operations *real_fops =NULL ; -int r =0 ; +int r; -if (debugfs_file_get (dentry)) -return -ENOENT ; + r =debugfs_file_get (dentry); +if (r) +return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); real_fops =fops_get (real_fops);
@@ -233,10 +269,11 @@ static int full_proxy_open(struct inode *inode, struct file *filp)struct dentry *dentry =F_DENTRY (filp);const struct file_operations *real_fops =NULL ;struct file_operations *proxy_fops =NULL ; -int r =0 ; +int r; -if (debugfs_file_get (dentry)) -return -ENOENT ; + r =debugfs_file_get (dentry); +if (r) +return r == -EIO ? -ENOENT : r; real_fops =debugfs_real_fops (filp); real_fops =fops_get (real_fops);
fs/debugfs/inode.c +19 -17
@@ -184,7 +184,10 @@ static const struct super_operations debugfs_super_operations = {static void debugfs_release_dentry (struct dentry *dentry) { -kfree (dentry->d_fsdata); +void *fsd = dentry->d_fsdata; + +if (!((unsigned long )fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT )) +kfree (dentry->d_fsdata); }static struct vfsmount *debugfs_automount (struct path *path)
@@ -346,35 +349,25 @@ static struct dentry *__debugfs_create_file(const char *name, umode_t mode, {struct dentry *dentry;struct inode *inode; -struct debugfs_fsdata *fsd; - - fsd =kmalloc (sizeof (*fsd),GFP_KERNEL ); -if (!fsd) -return NULL ;if (!(mode &S_IFMT )) mode |=S_IFREG ;BUG_ON (!S_ISREG (mode)); dentry =start_creating (name, parent); -if (IS_ERR (dentry)) { -kfree (fsd); +if (IS_ERR (dentry))return NULL ; - } inode =debugfs_get_inode (dentry->d_sb); -if (unlikely (!inode)) { -kfree (fsd); +if (unlikely (!inode))return failed_creating (dentry); - } inode->i_mode = mode; inode->i_private = data; inode->i_fop = proxy_fops; - fsd->real_fops = real_fops; -refcount_set (&fsd->active_users,1 ); - dentry->d_fsdata = fsd; + dentry->d_fsdata = (void *)((unsigned long )real_fops | +DEBUGFS_FSDATA_IS_REAL_FOPS_BIT );d_instantiate (dentry, inode);fsnotify_create (d_inode (dentry->d_parent), dentry);
@@ -637,8 +630,17 @@ static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)simple_unlink (d_inode (parent), dentry);d_delete (dentry); - fsd = dentry->d_fsdata; -init_completion (&fsd->active_users_drained); + +/* +* Paired with the closing smp_mb() implied by a successful +* cmpxchg() in debugfs_file_get(): either +* debugfs_file_get() must see a dead dentry or we must see a +* debugfs_fsdata instance at ->d_fsdata here (or both). +*/ +smp_mb (); + fsd =READ_ONCE (dentry->d_fsdata); +if ((unsigned long )fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ) +return ;if (!refcount_dec_and_test (&fsd->active_users))wait_for_completion (&fsd->active_users_drained); }
fs/debugfs/internal.h +8 -0
@@ -25,4 +25,12 @@ struct debugfs_fsdata { struct completion active_users_drained; }; +/* +* A dentry's ->d_fsdata either points to the real fops or to a +* dynamically allocated debugfs_fsdata instance. +* In order to distinguish between these two cases, a real fops +* pointer gets its lowest bit set. +*/ +#define DEBUGFS_FSDATA_IS_REAL_FOPS_BIT BIT(0) +#endif /* _DEBUGFS_INTERNAL_H_ */
Signature · 1 line
2.12.2
RFC PATCH v2 9/9 debugfs: free debugfs_fsdata instances
In reply to Nicolai StangeCurrently, a dentry's debugfs_fsdata instance is allocated from debugfs_file_get() at first usage, i.e. at first file opening.
It won't ever get freed though.
Ideally, these instances would get freed after the last open file handle gets closed again, that is from the fops' ->release().
Unfortunately, we can't hook easily into those ->release()ers of files created through debugfs_create_file_unsafe(), i.e. of those proxied through debugfs_open_proxy_file_operations rather than through the "full" debugfs_full_proxy_file_operations proxy.
Hence, free unreferenced debugfs_fsdata instances from debugfs_file_put(), with the drawback of a potential allocation + deallocation per debugfs_file_get() + debugfs_file_put() pair, that is per fops invocation.
In addition to its former role of tracking pending fops, use the ->active_users for reference counting on the debugfs_fsdata instance itself. In particular, don't keep a dummy reference to be dropped from __debugfs_remove_file(): a d_delete()ed dentry and thus, request for completion notification, is now signaled by the d_unlinked() dentry itself.
Once ->active_users drops to zero (and the dentry is still intact), free the debugfs_fsdata instance from debugfs_file_put(). RCU protects any concurrent debugfs_file_get() attempts to get a hold of the instance here. Likewise for full_proxy_release() which lacks a call to debugfs_file_get().
Note that due to non-atomic updates to the d_unlinked() + ->d_fsdata pair, care must be taken in order to avoid races between debugfs_file_put() and debugfs_file_get() as well as __debugfs_remove_file(). Rather than introducing a global lock, exploit the fact that there will ever be only a single !d_unlinked() -> d_unlinked() transition and add memory barriers where needed. Given the lack of proper benchmarking, that debugfs fops aren't performance critical and that we've already got a potential allocation/deallocation pair anyway, the added code complexity might be highly questionable though.
--- fs/debugfs/file.c | 100 ++++++++++++++++++++++++++++++++++++++++---------- fs/debugfs/inode.c | 8 +++- fs/debugfs/internal.h | 1 + 3 files changed, 88 insertions(+), 21 deletions(-)
fs/debugfs/file.c +81 -19
@@ -22,7 +22,9 @@#include <linux/slab.h> #include <linux/atomic.h> #include <linux/device.h> +#include <linux/rcupdate.h> #include <asm/poll.h> +#include <asm/processor.h> #include "internal.h"
@@ -86,10 +88,37 @@ int debugfs_file_get(struct dentry *dentry)struct debugfs_fsdata *fsd;void *d_fsd; - d_fsd =READ_ONCE (dentry->d_fsdata); +retry: +rcu_read_lock (); + d_fsd =rcu_dereference (dentry->d_fsdata);if (!((unsigned long )d_fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT )) { +/* +* Paired with the control dependency in +* debugfs_file_put(): if we saw the debugfs_fsdata +* instance "restored" there but not the dead dentry, +* we'd erroneously instantiate a fresh debugfs_fsdata +* instance below. +*/ +smp_rmb (); +if (d_unlinked (dentry)) { +rcu_read_unlock (); +return -EIO ; + } + fsd = d_fsd; +if (!refcount_inc_not_zero (&fsd->active_users)) { +/* +* A concurrent debugfs_file_put() dropped the +* count to zero and is about to free the +* debugfs_fsdata. +*/ +rcu_read_unlock (); +cpu_relax (); + goto retry; + } +rcu_read_unlock (); }else { +rcu_read_unlock (); fsd =kmalloc (sizeof (*fsd),GFP_KERNEL );if (!fsd)return -ENOMEM ;
@@ -99,25 +128,27 @@ int debugfs_file_get(struct dentry *dentry)refcount_set (&fsd->active_users,1 );init_completion (&fsd->active_users_drained);if (cmpxchg (&dentry->d_fsdata, d_fsd, fsd) != d_fsd) { +/* +* Another debugfs_file_get() has installed a +* debugfs_fsdata instance concurrently. +* Free ours and retry to grab a reference on +* the installed one. +*/ kfree (fsd); - fsd =READ_ONCE (dentry->d_fsdata); + goto retry; + } +/* +* In case of a successful cmpxchg() above, this check is +* strictly necessary and must follow it, see the comment in +* __debugfs_remove_file(). +*/ +if (d_unlinked (dentry)) { +if (refcount_dec_and_test (&fsd->active_users)) +complete (&fsd->active_users_drained); +return -EIO ; } } -/* -* In case of a successful cmpxchg() above, this check is -* strictly necessary and must follow it, see the comment in -* __debugfs_remove_file(). -* OTOH, if the cmpxchg() hasn't been executed or wasn't -* successful, this serves the purpose of not starving -* removers. -*/ -if (d_unlinked (dentry)) -return -EIO ; - -if (!refcount_inc_not_zero (&fsd->active_users)) -return -EIO ; -return 0 ; }EXPORT_SYMBOL_GPL (debugfs_file_get);
@@ -134,9 +165,29 @@ EXPORT_SYMBOL_GPL(debugfs_file_get);void debugfs_file_put (struct dentry *dentry) {struct debugfs_fsdata *fsd =READ_ONCE (dentry->d_fsdata); +void *d_fsd; -if (refcount_dec_and_test (&fsd->active_users)) -complete (&fsd->active_users_drained); +if (refcount_dec_and_test (&fsd->active_users)) { + d_fsd = (void *)((unsigned long )fsd->real_fops | +DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ); +RCU_INIT_POINTER (dentry->d_fsdata, d_fsd); +/* Paired with smp_mb() in __debugfs_remove_file(). */ +smp_mb (); +if (d_unlinked (dentry)) { +/* +* We have a control dependency paired with the +* smp_rmb() in debugfs_file_get() here. +* +* Restore the debugfs_fsdata instance into +* ->d_fsdata s.t. ->d_release() can free +* it. +*/ +WRITE_ONCE (dentry->d_fsdata, fsd); +complete (&fsd->active_users_drained); + }else { +kfree_rcu (fsd, rcu_head); + } + } }EXPORT_SYMBOL_GPL (debugfs_file_put);
@@ -229,9 +280,20 @@ static unsigned int full_proxy_poll(struct file *filp,static int full_proxy_release (struct inode *inode,struct file *filp) {const struct dentry *dentry =F_DENTRY (filp); -const struct file_operations *real_fops =debugfs_real_fops (filp);const struct file_operations *proxy_fops = filp->f_op;int r =0 ; +void *d_fsd; +const struct file_operations *real_fops; + +rcu_read_lock (); + d_fsd =rcu_dereference (F_DENTRY (filp)->d_fsdata); +if ((unsigned long )d_fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ) { + real_fops = (void *)((unsigned long )d_fsd & + ~DEBUGFS_FSDATA_IS_REAL_FOPS_BIT ); + }else { + real_fops = ((struct debugfs_fsdata *)d_fsd)->real_fops; + } +rcu_read_unlock ();/* * We must not protect this against removal races here: the
fs/debugfs/inode.c +6 -2
@@ -27,6 +27,7 @@#include <linux/parser.h> #include <linux/magic.h> #include <linux/slab.h> +#include <linux/rcupdate.h> #include "internal.h"
@@ -636,13 +637,16 @@ static void __debugfs_remove_file(struct dentry *dentry, struct dentry *parent)* cmpxchg() in debugfs_file_get(): either * debugfs_file_get() must see a dead dentry or we must see a * debugfs_fsdata instance at ->d_fsdata here (or both). +* +* Also paired with the smp_mb() in debugfs_file_put(): if we +* see a debugfs_fsdata instance here, then debugfs_file_put() +* must see a dead dentry. */ smp_mb (); fsd =READ_ONCE (dentry->d_fsdata);if ((unsigned long )fsd &DEBUGFS_FSDATA_IS_REAL_FOPS_BIT )return ; -if (!refcount_dec_and_test (&fsd->active_users)) -wait_for_completion (&fsd->active_users_drained); +wait_for_completion (&fsd->active_users_drained); }static int __debugfs_remove (struct dentry *dentry,struct dentry *parent)
fs/debugfs/internal.h +1 -0
@@ -23,6 +23,7 @@ struct debugfs_fsdata {const struct file_operations *real_fops;refcount_t active_users;struct completion active_users_drained; +struct rcu_head rcu_head; };/*
Signature · 1 line
2.12.2