superblock: move pin_sb_for_writeback() to fs/super.c

The per-sb shrinker has the same requirement as the writeback
threads of ensuring that the superblock is usable and pinned for the
time it takes to run the work. Both need to take a passive reference
to the sb, take a read lock on the s_umount lock and then only
continue if an unmount is not in progress.

pin_sb_for_writeback() does this exactly, so move it to fs/super.c
and rename it to grab_super_passive() and exporting it via
fs/internal.h for all the VFS code to be able to use.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 0f015a0468de53e7c4b27a9a5efdfeb9fa4cd67b..b8c507ca42f76141c31fc8405f7d2274966adb9a 100644 (file)
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -460,32 +460,6 @@ writeback_single_inode(struct inode *inode, struct writeback_control *wbc)
        return ret;
 }
 
-/*
- * For background writeback the caller does not have the sb pinned
- * before calling writeback. So make sure that we do pin it, so it doesn't
- * go away while we are writing inodes from it.
- */
-static bool pin_sb_for_writeback(struct super_block *sb)
-{
-       spin_lock(&sb_lock);
-       if (list_empty(&sb->s_instances)) {
-               spin_unlock(&sb_lock);
-               return false;
-       }
-
-       sb->s_count++;
-       spin_unlock(&sb_lock);
-
-       if (down_read_trylock(&sb->s_umount)) {
-               if (sb->s_root)
-                       return true;
-               up_read(&sb->s_umount);
-       }
-
-       put_super(sb);
-       return false;
-}
-
 /*
  * Write a portion of b_io inodes which belong to @sb.
  *
@@ -585,7 +559,7 @@ void writeback_inodes_wb(struct bdi_writeback *wb,
                struct inode *inode = wb_inode(wb->b_io.prev);
                struct super_block *sb = inode->i_sb;
 
-               if (!pin_sb_for_writeback(sb)) {
+               if (!grab_super_passive(sb)) {
                        requeue_io(inode);
                        continue;
                }

diff --git a/fs/internal.h b/fs/internal.h
index ae47c48bedde066eccd273a575b1b9f7c17c3086..fe327c20af8372b4f3ce5c7e42e369b81ab440ba 100644 (file)
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -97,6 +97,7 @@ extern struct file *get_empty_filp(void);
  * super.c
  */
 extern int do_remount_sb(struct super_block *, int, void *, int);
+extern bool grab_super_passive(struct super_block *sb);
 extern void __put_super(struct super_block *sb);
 extern void put_super(struct super_block *sb);
 extern struct dentry *mount_fs(struct file_system_type *,

diff --git a/fs/super.c b/fs/super.c
index 73ab9f9b35716c7d20bb896de267b866054bbfec..e63c754447ce05431655b0026195c3ec33e00c3a 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -242,6 +242,39 @@ static int grab_super(struct super_block *s) __releases(sb_lock)
        return 0;
 }
 
+/*
+ *     grab_super_passive - acquire a passive reference
+ *     @s: reference we are trying to grab
+ *
+ *     Tries to acquire a passive reference. This is used in places where we
+ *     cannot take an active reference but we need to ensure that the
+ *     superblock does not go away while we are working on it. It returns
+ *     false if a reference was not gained, and returns true with the s_umount
+ *     lock held in read mode if a reference is gained. On successful return,
+ *     the caller must drop the s_umount lock and the passive reference when
+ *     done.
+ */
+bool grab_super_passive(struct super_block *sb)
+{
+       spin_lock(&sb_lock);
+       if (list_empty(&sb->s_instances)) {
+               spin_unlock(&sb_lock);
+               return false;
+       }
+
+       sb->s_count++;
+       spin_unlock(&sb_lock);
+
+       if (down_read_trylock(&sb->s_umount)) {
+               if (sb->s_root)
+                       return true;
+               up_read(&sb->s_umount);
+       }
+
+       put_super(sb);
+       return false;
+}
+
 /*
  * Superblock locking.  We really ought to get rid of these two.
  */