bdev: rename freeze and thaw helpers

We have bdev_mark_dead() etc and we're going to move block device
freezing to holder ops in the next patch. Make the naming consistent:

* freeze_bdev() -> bdev_freeze()
* thaw_bdev()   -> bdev_thaw()

Also document the return code.

Link: https://lore.kernel.org/r/20231024-vfs-super-freeze-v2-2-599c19f4faac@kernel.org
Reviewed-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/block/bdev.c b/block/bdev.c
index e4cfb7adb64581d0630d61dc0f5a287245da7d38..a890da1b3adfe8c7edad27428f497dd74e0b85a0 100644 (file)
--- a/block/bdev.c
+++ b/block/bdev.c
@@ -207,18 +207,20 @@ int sync_blockdev_range(struct block_device *bdev, loff_t lstart, loff_t lend)
 EXPORT_SYMBOL(sync_blockdev_range);
 
 /**
- * freeze_bdev - lock a filesystem and force it into a consistent state
+ * bdev_freeze - lock a filesystem and force it into a consistent state
  * @bdev:      blockdevice to lock
  *
  * If a superblock is found on this device, we take the s_umount semaphore
  * on it to make sure nobody unmounts until the snapshot creation is done.
  * The reference counter (bd_fsfreeze_count) guarantees that only the last
  * unfreeze process can unfreeze the frozen filesystem actually when multiple
- * freeze requests arrive simultaneously. It counts up in freeze_bdev() and
- * count down in thaw_bdev(). When it becomes 0, thaw_bdev() will unfreeze
+ * freeze requests arrive simultaneously. It counts up in bdev_freeze() and
+ * count down in bdev_thaw(). When it becomes 0, thaw_bdev() will unfreeze
  * actually.
+ *
+ * Return: On success zero is returned, negative error code on failure.
  */
-int freeze_bdev(struct block_device *bdev)
+int bdev_freeze(struct block_device *bdev)
 {
        struct super_block *sb;
        int error = 0;
@@ -248,15 +250,17 @@ done:
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        return error;
 }
-EXPORT_SYMBOL(freeze_bdev);
+EXPORT_SYMBOL(bdev_freeze);
 
 /**
- * thaw_bdev - unlock filesystem
+ * bdev_thaw - unlock filesystem
  * @bdev:      blockdevice to unlock
  *
- * Unlocks the filesystem and marks it writeable again after freeze_bdev().
+ * Unlocks the filesystem and marks it writeable again after bdev_freeze().
+ *
+ * Return: On success zero is returned, negative error code on failure.
  */
-int thaw_bdev(struct block_device *bdev)
+int bdev_thaw(struct block_device *bdev)
 {
        struct super_block *sb;
        int error = -EINVAL;
@@ -285,7 +289,7 @@ out:
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
        return error;
 }
-EXPORT_SYMBOL(thaw_bdev);
+EXPORT_SYMBOL(bdev_thaw);
 
 /*
  * pseudo-fs

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 23c32cd1f1d8864cf5b664cecd610aa7a91e8e36..8dcabf84d866e6d2ac863a98790b16b838475d23 100644 (file)
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2675,7 +2675,7 @@ static int lock_fs(struct mapped_device *md)
 
        WARN_ON(test_bit(DMF_FROZEN, &md->flags));
 
-       r = freeze_bdev(md->disk->part0);
+       r = bdev_freeze(md->disk->part0);
        if (!r)
                set_bit(DMF_FROZEN, &md->flags);
        return r;
@@ -2685,7 +2685,7 @@ static void unlock_fs(struct mapped_device *md)
 {
        if (!test_bit(DMF_FROZEN, &md->flags))
                return;
-       thaw_bdev(md->disk->part0);
+       bdev_thaw(md->disk->part0);
        clear_bit(DMF_FROZEN, &md->flags);
 }
 

diff --git a/fs/bcachefs/fs-ioctl.c b/fs/bcachefs/fs-ioctl.c
index 5a39bcb597a33d42826a16a98da394de3fe23660..45e663342e38b77af93fe09e61fba90a8f9e73b7 100644 (file)
--- a/fs/bcachefs/fs-ioctl.c
+++ b/fs/bcachefs/fs-ioctl.c
@@ -291,14 +291,14 @@ static int bch2_ioc_goingdown(struct bch_fs *c, u32 __user *arg)
 
        switch (flags) {
        case FSOP_GOING_FLAGS_DEFAULT:
-               ret = freeze_bdev(c->vfs_sb->s_bdev);
+               ret = bdev_freeze(c->vfs_sb->s_bdev);
                if (ret)
                        goto err;
 
                bch2_journal_flush(&c->journal);
                c->vfs_sb->s_flags |= SB_RDONLY;
                bch2_fs_emergency_read_only(c);
-               thaw_bdev(c->vfs_sb->s_bdev);
+               bdev_thaw(c->vfs_sb->s_bdev);
                break;
 
        case FSOP_GOING_FLAGS_LOGFLUSH:

diff --git a/fs/ext4/ioctl.c b/fs/ext4/ioctl.c
index 4f931f80cb34894ad85f7a788ac3773dc0c61352..aa6be510eb8f578f09faf937a3debaabb9c3b499 100644 (file)
--- a/fs/ext4/ioctl.c
+++ b/fs/ext4/ioctl.c
@@ -819,11 +819,11 @@ int ext4_force_shutdown(struct super_block *sb, u32 flags)
 
        switch (flags) {
        case EXT4_GOING_FLAGS_DEFAULT:
-               ret = freeze_bdev(sb->s_bdev);
+               ret = bdev_freeze(sb->s_bdev);
                if (ret)
                        return ret;
                set_bit(EXT4_FLAGS_SHUTDOWN, &sbi->s_ext4_flags);
-               thaw_bdev(sb->s_bdev);
+               bdev_thaw(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 e50363583f019a227ce3280ddb3ecd85760f8226..4580dfefd5e95a93bcca62a46d5f60fb4d264056 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2239,11 +2239,11 @@ static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
 
        switch (in) {
        case F2FS_GOING_DOWN_FULLSYNC:
-               ret = freeze_bdev(sb->s_bdev);
+               ret = bdev_freeze(sb->s_bdev);
                if (ret)
                        goto out;
                f2fs_stop_checkpoint(sbi, false, STOP_CP_REASON_SHUTDOWN);
-               thaw_bdev(sb->s_bdev);
+               bdev_thaw(sb->s_bdev);
                break;
        case F2FS_GOING_DOWN_METASYNC:
                /* do checkpoint only */

diff --git a/fs/super.c b/fs/super.c
index aa43090ea52d15f2262696a7eca18dc5869b6d0e..8333aaa878cf79b51a4ada8a5b7c97792781c2d6 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -1224,7 +1224,7 @@ static void do_thaw_all_callback(struct super_block *sb)
 
        if (locked && sb->s_root) {
                if (IS_ENABLED(CONFIG_BLOCK))
-                       while (sb->s_bdev && !thaw_bdev(sb->s_bdev))
+                       while (sb->s_bdev && !bdev_thaw(sb->s_bdev))
                                pr_warn("Emergency Thaw on %pg\n", sb->s_bdev);
                thaw_super_locked(sb, FREEZE_HOLDER_USERSPACE);
                return;
@@ -1532,7 +1532,7 @@ int setup_bdev_super(struct super_block *sb, int sb_flags,
        /*
         * Until SB_BORN flag is set, there can be no active superblock
         * references and thus no filesystem freezing. get_active_super() will
-        * just loop waiting for SB_BORN so even freeze_bdev() cannot proceed.
+        * just loop waiting for SB_BORN so even bdev_freeze() cannot proceed.
         *
         * It is enough to check bdev was not frozen before we set s_bdev.
         */

diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 7cb75cb6b8e9b47c4df2ab912f2851eee7b10c4d..57076a25f17d7b9b253bd3edbb35927130c962d4 100644 (file)
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -482,9 +482,9 @@ xfs_fs_goingdown(
 {
        switch (inflags) {
        case XFS_FSOP_GOING_FLAGS_DEFAULT: {
-               if (!freeze_bdev(mp->m_super->s_bdev)) {
+               if (!bdev_freeze(mp->m_super->s_bdev)) {
                        xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
-                       thaw_bdev(mp->m_super->s_bdev);
+                       bdev_thaw(mp->m_super->s_bdev);
                }
                break;
        }

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 51fa7ffdee83b434676cf4fe07e50d6507cfd1ae..7a3da7f44afb72fce2d58bd5dd7acb5468013129 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1541,8 +1541,8 @@ static inline int early_lookup_bdev(const char *pathname, dev_t *dev)
 }
 #endif /* CONFIG_BLOCK */
 
-int freeze_bdev(struct block_device *bdev);
-int thaw_bdev(struct block_device *bdev);
+int bdev_freeze(struct block_device *bdev);
+int bdev_thaw(struct block_device *bdev);
 
 struct io_comp_batch {
        struct request *req_list;