block: call into the file system for bdev_mark_dead

Combine the newly merged bdev_mark_dead helper with the existing
mark_dead holder operation so that all operations that invalidate
a device that is dead or being removed now go through the holder
ops.  This allows file systems to explicitly shutdown either ASAP
(for a surprise removal) or after writing back data (for an orderly
removal), and do so not only for the main device.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Message-Id: <20230811100828.1897174-15-hch@lst.de>
Signed-off-by: Christian Brauner <brauner@kernel.org>

diff --git a/block/bdev.c b/block/bdev.c
index 074a9ff..4d58008 100644 (file)
--- a/block/bdev.c
+++ b/block/bdev.c
@@ -968,31 +968,19 @@ EXPORT_SYMBOL(lookup_bdev);
  * to %true the device or media is already gone, if not we are preparing for an
  * orderly removal.
  *
- * This syncs out all dirty data and writes back inodes and then invalidates any
- * cached data in the inodes on the file system, the inodes themselves and the
- * block device mapping.
+ * This calls into the file system, which then typicall syncs out all dirty data
+ * and writes back inodes and then invalidates any cached data in the inodes on
+ * the file system.  In addition we also invalidate the block device mapping.
  */
 void bdev_mark_dead(struct block_device *bdev, bool surprise)
 {
-       struct super_block *sb = get_super(bdev);
-       int res = 0;
+       mutex_lock(&bdev->bd_holder_lock);
+       if (bdev->bd_holder_ops && bdev->bd_holder_ops->mark_dead)
+               bdev->bd_holder_ops->mark_dead(bdev, surprise);
+       else
+               sync_blockdev(bdev);
+       mutex_unlock(&bdev->bd_holder_lock);
 
-       if (sb) {
-               if (!surprise)
-                       sync_filesystem(sb);
-               /*
-                * no need to lock the super, get_super holds the
-                * read mutex so the filesystem cannot go away
-                * under us (->put_super runs with the write lock
-                * hold).
-                */
-               shrink_dcache_sb(sb);
-               res = invalidate_inodes(sb, true);
-               drop_super(sb);
-       } else {
-               if (!surprise)
-                       sync_blockdev(bdev);
-       }
        invalidate_bdev(bdev);
 }
 #ifdef CONFIG_DASD_MODULE

diff --git a/block/genhd.c b/block/genhd.c
index afc2cb0..cc32a0c 100644 (file)
--- a/block/genhd.c
+++ b/block/genhd.c
@@ -554,7 +554,7 @@ out_exit_elevator:
 }
 EXPORT_SYMBOL(device_add_disk);
 
-static void blk_report_disk_dead(struct gendisk *disk)
+static void blk_report_disk_dead(struct gendisk *disk, bool surprise)
 {
        struct block_device *bdev;
        unsigned long idx;
@@ -565,10 +565,7 @@ static void blk_report_disk_dead(struct gendisk *disk)
                        continue;
                rcu_read_unlock();
 
-               mutex_lock(&bdev->bd_holder_lock);
-               if (bdev->bd_holder_ops && bdev->bd_holder_ops->mark_dead)
-                       bdev->bd_holder_ops->mark_dead(bdev);
-               mutex_unlock(&bdev->bd_holder_lock);
+               bdev_mark_dead(bdev, surprise);
 
                put_device(&bdev->bd_device);
                rcu_read_lock();
@@ -576,14 +573,7 @@ static void blk_report_disk_dead(struct gendisk *disk)
        rcu_read_unlock();
 }
 
-/**
- * blk_mark_disk_dead - mark a disk as dead
- * @disk: disk to mark as dead
- *
- * Mark as disk as dead (e.g. surprise removed) and don't accept any new I/O
- * to this disk.
- */
-void blk_mark_disk_dead(struct gendisk *disk)
+static void __blk_mark_disk_dead(struct gendisk *disk)
 {
        /*
         * Fail any new I/O.
@@ -603,8 +593,19 @@ void blk_mark_disk_dead(struct gendisk *disk)
         * Prevent new I/O from crossing bio_queue_enter().
         */
        blk_queue_start_drain(disk->queue);
+}
 
-       blk_report_disk_dead(disk);
+/**
+ * blk_mark_disk_dead - mark a disk as dead
+ * @disk: disk to mark as dead
+ *
+ * Mark as disk as dead (e.g. surprise removed) and don't accept any new I/O
+ * to this disk.
+ */
+void blk_mark_disk_dead(struct gendisk *disk)
+{
+       __blk_mark_disk_dead(disk);
+       blk_report_disk_dead(disk, true);
 }
 EXPORT_SYMBOL_GPL(blk_mark_disk_dead);
 
@@ -641,17 +642,20 @@ void del_gendisk(struct gendisk *disk)
        disk_del_events(disk);
 
        /*
-        * Prevent new openers by unlinked the bdev inode, and write out
-        * dirty data before marking the disk dead and stopping all I/O.
+        * Prevent new openers by unlinked the bdev inode.
         */
        mutex_lock(&disk->open_mutex);
-       xa_for_each(&disk->part_tbl, idx, part) {
+       xa_for_each(&disk->part_tbl, idx, part)
                remove_inode_hash(part->bd_inode);
-               bdev_mark_dead(part, false);
-       }
        mutex_unlock(&disk->open_mutex);
 
-       blk_mark_disk_dead(disk);
+       /*
+        * Tell the file system to write back all dirty data and shut down if
+        * it hasn't been notified earlier.
+        */
+       if (!test_bit(GD_DEAD, &disk->state))
+               blk_report_disk_dead(disk, false);
+       __blk_mark_disk_dead(disk);
 
        /*
         * Drop all partitions now that the disk is marked dead.

diff --git a/fs/super.c b/fs/super.c
index 9b2188e..11fa21d 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -1228,7 +1228,7 @@ static bool lock_active_super(struct super_block *sb)
        return true;
 }
 
-static void fs_mark_dead(struct block_device *bdev)
+static void fs_bdev_mark_dead(struct block_device *bdev, bool surprise)
 {
        struct super_block *sb = bdev->bd_holder;
 
@@ -1238,6 +1238,10 @@ static void fs_mark_dead(struct block_device *bdev)
        if (!lock_active_super(sb))
                return;
 
+       if (!surprise)
+               sync_filesystem(sb);
+       shrink_dcache_sb(sb);
+       invalidate_inodes(sb, true);
        if (sb->s_op->shutdown)
                sb->s_op->shutdown(sb);
 
@@ -1245,7 +1249,7 @@ static void fs_mark_dead(struct block_device *bdev)
 }
 
 const struct blk_holder_ops fs_holder_ops = {
-       .mark_dead              = fs_mark_dead,
+       .mark_dead              = fs_bdev_mark_dead,
 };
 EXPORT_SYMBOL_GPL(fs_holder_ops);
 

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 6721595..cdd03c6 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1461,7 +1461,7 @@ void blkdev_show(struct seq_file *seqf, off_t offset);
 #endif
 
 struct blk_holder_ops {
-       void (*mark_dead)(struct block_device *bdev);
+       void (*mark_dead)(struct block_device *bdev, bool surprise);
 };
 
 extern const struct blk_holder_ops fs_holder_ops;