fs: simplify freeze_bdev/thaw_bdev

Store the frozen superblock in struct block_device to avoid the awkward
interface that can return a sb only used a cookie, an ERR_PTR or NULL.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Jan Kara <jack@suse.cz>
Acked-by: Chao Yu <yuchao0@huawei.com>		[f2fs]
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/drivers/md/dm-core.h b/drivers/md/dm-core.h
index d522093..aace147 100644 (file)
--- a/drivers/md/dm-core.h
+++ b/drivers/md/dm-core.h
@@ -96,11 +96,6 @@ struct mapped_device {
         */
        struct workqueue_struct *wq;
 
-       /*
-        * freeze/thaw support require holding onto a super block
-        */
-       struct super_block *frozen_sb;
-
        /* forced geometry settings */
        struct hd_geometry geometry;
 

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 54739f1..50541d3 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2392,27 +2392,19 @@ static int lock_fs(struct mapped_device *md)
 {
        int r;
 
-       WARN_ON(md->frozen_sb);
+       WARN_ON(test_bit(DMF_FROZEN, &md->flags));
 
-       md->frozen_sb = freeze_bdev(md->bdev);
-       if (IS_ERR(md->frozen_sb)) {
-               r = PTR_ERR(md->frozen_sb);
-               md->frozen_sb = NULL;
-               return r;
-       }
-
-       set_bit(DMF_FROZEN, &md->flags);
-
-       return 0;
+       r = freeze_bdev(md->bdev);
+       if (!r)
+               set_bit(DMF_FROZEN, &md->flags);
+       return r;
 }
 
 static void unlock_fs(struct mapped_device *md)
 {
        if (!test_bit(DMF_FROZEN, &md->flags))
                return;
-
-       thaw_bdev(md->bdev, md->frozen_sb);
-       md->frozen_sb = NULL;
+       thaw_bdev(md->bdev);
        clear_bit(DMF_FROZEN, &md->flags);
 }
 

diff --git a/fs/block_dev.c b/fs/block_dev.c
index d8664f5..33c2910 100644 (file)
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -548,55 +548,47 @@ EXPORT_SYMBOL(fsync_bdev);
  * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
  * actually.
  */
-struct super_block *freeze_bdev(struct block_device *bdev)
+int freeze_bdev(struct block_device *bdev)
 {
        struct super_block *sb;
        int error = 0;
 
        mutex_lock(&bdev->bd_fsfreeze_mutex);
-       if (++bdev->bd_fsfreeze_count > 1) {
-               /*
-                * We don't even need to grab a reference - the first call
-                * to freeze_bdev grab an active reference and only the last
-                * thaw_bdev drops it.
-                */
-               sb = get_super(bdev);
-               if (sb)
-                       drop_super(sb);
-               mutex_unlock(&bdev->bd_fsfreeze_mutex);
-               return sb;
-       }
+       if (++bdev->bd_fsfreeze_count > 1)
+               goto done;
 
        sb = get_active_super(bdev);
        if (!sb)
-               goto out;
+               goto sync;
        if (sb->s_op->freeze_super)
                error = sb->s_op->freeze_super(sb);
        else
                error = freeze_super(sb);
+       deactivate_super(sb);
+
        if (error) {
-               deactivate_super(sb);
                bdev->bd_fsfreeze_count--;
-               mutex_unlock(&bdev->bd_fsfreeze_mutex);
-               return ERR_PTR(error);
+               goto done;
        }
-       deactivate_super(sb);
- out:
+       bdev->bd_fsfreeze_sb = sb;
+
+sync:
        sync_blockdev(bdev);
+done:
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
-       return sb;      /* thaw_bdev releases s->s_umount */
+       return error;
 }
 EXPORT_SYMBOL(freeze_bdev);
 
 /**
  * thaw_bdev  -- unlock filesystem
  * @bdev:      blockdevice to unlock
- * @sb:                associated superblock
  *
  * Unlocks the filesystem and marks it writeable again after freeze_bdev().
  */
-int thaw_bdev(struct block_device *bdev, struct super_block *sb)
+int thaw_bdev(struct block_device *bdev)
 {
+       struct super_block *sb;
        int error = -EINVAL;
 
        mutex_lock(&bdev->bd_fsfreeze_mutex);
@@ -607,6 +599,7 @@ int thaw_bdev(struct block_device *bdev, struct super_block *sb)
        if (--bdev->bd_fsfreeze_count > 0)
                goto out;
 
+       sb = bdev->bd_fsfreeze_sb;
        if (!sb)
                goto out;
 

diff --git a/fs/buffer.c b/fs/buffer.c
index 23f6456..a7595ad 100644 (file)
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -523,7 +523,7 @@ repeat:
 
 void emergency_thaw_bdev(struct super_block *sb)
 {
-       while (sb->s_bdev && !thaw_bdev(sb->s_bdev, sb))
+       while (sb->s_bdev && !thaw_bdev(sb->s_bdev))
                printk(KERN_WARNING "Emergency Thaw on %pg\n", sb->s_bdev);
 }
 

diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index f038187..524e134 100644 (file)
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -624,7 +624,7 @@ static int ext4_shutdown(struct super_block *sb, unsigned long arg)
        case EXT4_GOING_FLAGS_DEFAULT:
                freeze_bdev(sb->s_bdev);
                set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
-               thaw_bdev(sb->s_bdev, sb);
+               thaw_bdev(sb->s_bdev);
                break;
        case EXT4_GOING_FLAGS_LOGFLUSH:
                set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index ee861c6..a9fc482 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2230,16 +2230,12 @@ static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
 
        switch (in) {
        case F2FS_GOING_DOWN_FULLSYNC:
-               sb = freeze_bdev(sb->s_bdev);
-               if (IS_ERR(sb)) {
-                       ret = PTR_ERR(sb);
+               ret = freeze_bdev(sb->s_bdev);
+               if (ret)
                        goto out;
-               }
-               if (sb) {
-                       f2fs_stop_checkpoint(sbi, false);
-                       set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
-                       thaw_bdev(sb->s_bdev, sb);
-               }
+               f2fs_stop_checkpoint(sbi, false);
+               set_sbi_flag(sbi, SBI_IS_SHUTDOWN);
+               thaw_bdev(sb->s_bdev);
                break;
        case F2FS_GOING_DOWN_METASYNC:
                /* do checkpoint only */

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index ef1d5bb..b7c5783 100644 (file)
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -433,13 +433,10 @@ xfs_fs_goingdown(
 {
        switch (inflags) {
        case XFS_FSOP_GOING_FLAGS_DEFAULT: {
-               struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
-
-               if (sb && !IS_ERR(sb)) {
+               if (!freeze_bdev(mp->m_super->s_bdev)) {
                        xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
-                       thaw_bdev(sb->s_bdev, sb);
+                       thaw_bdev(mp->m_super->s_bdev);
                }
-
                break;
        }
        case XFS_FSOP_GOING_FLAGS_LOGFLUSH:

diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index d9b69bb..ebfb4e7 100644 (file)
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -46,6 +46,7 @@ struct block_device {
        int                     bd_fsfreeze_count;
        /* Mutex for freeze */
        struct mutex            bd_fsfreeze_mutex;
+       struct super_block      *bd_fsfreeze_sb;
 } __randomize_layout;
 
 /*

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 05b346a..12810a1 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -2020,7 +2020,7 @@ static inline int sync_blockdev(struct block_device *bdev)
 #endif
 int fsync_bdev(struct block_device *bdev);
 
-struct super_block *freeze_bdev(struct block_device *bdev);
-int thaw_bdev(struct block_device *bdev, struct super_block *sb);
+int freeze_bdev(struct block_device *bdev);
+int thaw_bdev(struct block_device *bdev);
 
 #endif /* _LINUX_BLKDEV_H */