Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-25 05:32:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

block: call into the file system for bdev_mark_dead

Browse Source 
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>
This commit is contained in:
Christoph Hellwig 2023-08-11 12:08:25 +02:00 committed by Christian Brauner
parent 560e20e4bf
commit d8530de5a6
4 changed files with 40 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
block/bdev.c
View File

@ -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

44
block/genhd.c
View File

@ -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.

8
fs/super.c
View File

@ -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);

2
include/linux/blkdev.h
View File

@ -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;