Two patches for fs/super.c
Subsystems (3)
cover Two patches for fs/super.c
Two patches.
The second removes S_BIAS which is unnecessary and so potentially confusing.
The first I found the need for while preparing the second patch. It seems that get_active_super doesn't follow the pattern of all other code that walks the super_blocks list.
NeilBrown
---
NeilBrown (2):
VFS: use __put_super_and_need_restart in get_active_super. fs/super: remove S_BIAS
fs/notify/inotify/inotify.c | 33 ++++++++++++++------------------- fs/super.c | 20 ++++++++------------ include/linux/fs.h | 1 - 3 files changed, 22 insertions(+), 32 deletions(-)
PATCH 1/2 VFS: use __put_super_and_need_restart in get_active_super.
The recently-added get_active_super() walks the super_blocks list but unlike all other code that walks this list it does not use __put_super_and_need_restart().
I believe this is an omission that should be fixed.
--- fs/super.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-)
fs/super.c +3 -1
@@ -482,6 +482,7 @@ struct super_block *get_active_super(struct block_device *bdev)return NULL ;spin_lock (&sb_lock); +restart:list_for_each_entry (sb, &super_blocks, s_list) {if (sb->s_bdev != bdev)continue ;
@@ -500,9 +501,10 @@ struct super_block *get_active_super(struct block_device *bdev)spin_unlock (&sb_lock); }up_write (&sb->s_umount); -put_super (sb);yield ();spin_lock (&sb_lock); +if (__put_super_and_need_restart (sb)) + goto restart; }spin_unlock (&sb_lock);return NULL ;
PATCH 2/2 fs/super: remove S_BIAS
In reply to NeilBrownThe fact that S_BIAS is very large is only used four times, all(*) with:
if (s->s_count > S_BIAS) {
atomic_inc(&s->s_active);The statement "s->s_count > S_BIAS" is exactly equivalent to "atomic_read(&s->s_active) != 0", as the bias is subtracted as soon as s_active becomes zero.
So the above test can more simply become:
if (atomic_inc_not_zero(&s->s_active)) {With this in place, S_BIAS does not need to be large, and a value of '1' will suit. This simplifies code in a number of places and removes the need to take a spinlock in several cases.
(*) full disclosure: in two cases (inotify) it is
if (s->s_count >= S_BIAS {however the logic still holds - that can only be true if s_active is not zero.
--- fs/notify/inotify/inotify.c | 33 ++++++++++++++------------------- fs/super.c | 16 +++++----------- include/linux/fs.h | 1 - 3 files changed, 19 insertions(+), 31 deletions(-)
fs/notify/inotify/inotify.c +14 -19
@@ -110,14 +110,10 @@ EXPORT_SYMBOL_GPL(get_inotify_watch);int pin_inotify_watch (struct inotify_watch *watch) {struct super_block *sb = watch->inode->i_sb; -spin_lock (&sb_lock); -if (sb->s_count >=S_BIAS ) { -atomic_inc (&sb->s_active); -spin_unlock (&sb_lock); +if (atomic_inc_not_zero (&sb->s_active)) {atomic_inc (&watch->count);return 1 ; } -spin_unlock (&sb_lock);return 0 ; }
@@ -518,16 +514,17 @@ EXPORT_SYMBOL_GPL(inotify_init_watch);* ->s_umount, which will almost certainly wait until the superblock is shut * down and the watch in question is pining for fjords. That's fine, but * there is a problem - we might have hit the window between ->s_active -* getting to 0 / ->s_count - below S_BIAS (i.e. the moment when superblock -* is past the point of no return and is heading for shutdown) and the -* moment when deactivate_super() acquires ->s_umount. We could just do -* drop_super() yield() and retry, but that's rather antisocial and this -* stuff is luser-triggerable. OTOH, having grabbed ->s_umount and having -* found that we'd got there first (i.e. that ->s_root is non-NULL) we know -* that we won't race with inotify_umount_inodes(). So we could grab a -* reference to watch and do the rest as above, just with drop_super() instead -* of deactivate_super(), right? Wrong. We had to drop ih->mutex before we -* could grab ->s_umount. So the watch could've been gone already. +* getting to 0 (i.e. the moment when superblock is past the point of no +* return and is heading for shutdown) and the moment when +* deactivate_super() acquires ->s_umount. We could just do drop_super() +* yield() and retry, but that's rather antisocial and this stuff is +* luser-triggerable. OTOH, having grabbed ->s_umount and having found +* that we'd got there first (i.e. that ->s_root is non-NULL) we know that +* we won't race with inotify_umount_inodes(). So we could grab a +* reference to watch and do the rest as above, just with drop_super() +* instead of deactivate_super(), right? Wrong. We had to drop ih->mutex +* before we could grab ->s_umount. So the watch could've been gone +* already. * * That still can be dealt with - we need to save watch->wd, do idr_find() * and compare its result with our pointer. If they match, we either have
@@ -565,14 +562,12 @@ static int pin_to_kill(struct inotify_handle *ih, struct inotify_watch *watch)struct super_block *sb = watch->inode->i_sb;s32 wd = watch->wd; -spin_lock (&sb_lock); -if (sb->s_count >=S_BIAS ) { -atomic_inc (&sb->s_active); -spin_unlock (&sb_lock); +if (atomic_inc_not_zero (&sb->s_active)) {get_inotify_watch (watch);mutex_unlock (&ih->mutex);return 1 ;/* the best outcome */ } +spin_lock (&sb_lock); sb->s_count++;spin_unlock (&sb_lock);mutex_unlock (&ih->mutex);/* can't grab ->s_umount under it */
fs/super.c +5 -11
@@ -92,7 +92,7 @@ static struct super_block *alloc_super(struct file_system_type *type)* subclass. */ down_write_nested (&s->s_umount,SINGLE_DEPTH_NESTING ); - s->s_count =S_BIAS ; + s->s_count =1 ;atomic_set (&s->s_active,1 );mutex_init (&s->s_vfs_rename_mutex);mutex_init (&s->s_dquot.dqio_mutex);
@@ -188,9 +188,7 @@ void put_super(struct super_block *sb)void deactivate_super (struct super_block *s) {struct file_system_type *fs = s->s_type; -if (atomic_dec_and_lock (&s->s_active, &sb_lock)) { - s->s_count -=S_BIAS -1 ; -spin_unlock (&sb_lock); +if (atomic_dec_and_test (&s->s_active)) {vfs_dq_off (s,0 );down_write (&s->s_umount); fs->kill_sb (s);
@@ -215,9 +213,7 @@ EXPORT_SYMBOL(deactivate_super);void deactivate_locked_super (struct super_block *s) {struct file_system_type *fs = s->s_type; -if (atomic_dec_and_lock (&s->s_active, &sb_lock)) { - s->s_count -=S_BIAS -1 ; -spin_unlock (&sb_lock); +if (atomic_dec_and_test (&s->s_active)) {vfs_dq_off (s,0 ); fs->kill_sb (s);put_filesystem (fs);
@@ -247,8 +243,7 @@ static int grab_super(struct super_block *s) __releases(sb_lock)down_write (&s->s_umount);if (s->s_root) {spin_lock (&sb_lock); -if (s->s_count >S_BIAS ) { -atomic_inc (&s->s_active); +if (atomic_inc_not_zero (&s->s_active)) { s->s_count--;spin_unlock (&sb_lock);return 1 ;
@@ -492,8 +487,7 @@ restart:down_write (&sb->s_umount);if (sb->s_root) {spin_lock (&sb_lock); -if (sb->s_count >S_BIAS ) { -atomic_inc (&sb->s_active); +if (atomic_inc_not_zero (&sb->s_active)) { sb->s_count--;spin_unlock (&sb_lock);return sb;
include/linux/fs.h +0 -1
@@ -1315,7 +1315,6 @@ extern struct list_head super_blocks;extern spinlock_t sb_lock;#define sb_entry (list) list_entry((list), struct super_block, s_list) -#define S_BIAS (1<<30)struct super_block {struct list_head s_list;/* Keep this first */ dev_t s_dev;/* search index; _not_ kdev_t */
Al Viro
maintainerQuoted 9 lines · NeilBrown
Two patches.
The second removes
S_BIASwhich is unnecessary and so potentially confusing.The first I found the need for while preparing the second patch. It seems that
get_active_superdoesn't follow the pattern of all other code that walks thesuper_blockslist.
See #untested in vfs tree...
Quoted 4 lines · On Wed, 24 Mar 2010 09:20:11 +0000 Al Viro <[email protected]> wrote:
Quoted 3 lines · NeilBrown
Two patches.
Quoted 9 lines
Quoted 6 lines
The second removes
S_BIASwhich is unnecessary and so potentially confusing.The first I found the need for while preparing the second patch. It seems that
get_active_superdoesn't follow the pattern of all other code that walks thesuper_blockslist.See #untested in vfs tree...
Ahhh, I see I've been beaten to it by 2 days... I should have posted that patch months ago :-)
Thanks anyway.
NeilBrown