diff --git a/arch/arm64/configs/openeuler_defconfig b/arch/arm64/configs/openeuler_defconfig index f130774b720c37353f052595861b23d6911fb7af..1f10bdfb6502ee20eb2a4d1999d3a079606372b6 100644 --- a/arch/arm64/configs/openeuler_defconfig +++ b/arch/arm64/configs/openeuler_defconfig @@ -901,6 +901,9 @@ CONFIG_BLK_DEBUG_FS=y CONFIG_BLK_DEBUG_FS_ZONED=y # CONFIG_BLK_SED_OPAL is not set # CONFIG_BLK_INLINE_ENCRYPTION is not set +CONFIG_BLK_DEV_WRITE_MOUNTED=y +CONFIG_BLK_DEV_DETECT_WRITING_PART0=y +CONFIG_BLK_DEV_WRITE_MOUNTED_DUMP=y # # Partition Types diff --git a/arch/x86/configs/openeuler_defconfig b/arch/x86/configs/openeuler_defconfig index c9e816e54003230a5504f29d5427055a9a9fee06..54f0d478f614194f844ce3749fe9da41d085ff37 100644 --- a/arch/x86/configs/openeuler_defconfig +++ b/arch/x86/configs/openeuler_defconfig @@ -965,6 +965,9 @@ CONFIG_BLK_DEBUG_FS=y CONFIG_BLK_DEBUG_FS_ZONED=y # CONFIG_BLK_SED_OPAL is not set # CONFIG_BLK_INLINE_ENCRYPTION is not set +CONFIG_BLK_DEV_WRITE_MOUNTED=y +CONFIG_BLK_DEV_DETECT_WRITING_PART0=y +CONFIG_BLK_DEV_WRITE_MOUNTED_DUMP=y # # Partition Types diff --git a/block/Kconfig b/block/Kconfig index 7c7187366450fa1d863c85c1890143673240e713..2e70a431d4177e0aa674e02adb0e6db982d8d906 100644 --- a/block/Kconfig +++ b/block/Kconfig @@ -249,6 +249,23 @@ config BLK_INLINE_ENCRYPTION_FALLBACK by falling back to the kernel crypto API when inline encryption hardware is not present. +config BLK_DEV_DETECT_WRITING_PART0 + bool "Detect writing to part0 when partitions mounted" + default n + help + When partitions of a block device are mounted, writing to part0's + buffer cache is likely going to cause filesystem corruption on + each partition. + As a supplement to BLK_DEV_WRITE_MOUNTED, enabling this + to detect the scenario above. + +config BLK_DEV_WRITE_MOUNTED_DUMP + bool "Dump info when detecting conflict of opening block device" + default n + help + Enabling this to dump info when opening mounted block devices + for write or trying to mount write opened block devices. + source "block/partitions/Kconfig" config BLK_MQ_PCI diff --git a/block/bdev.c b/block/bdev.c index dd39c26c44ad153484d879be859baede0dc5ab77..21cbfa166ebeeb0c7fc6a77b2112907b44d5b7ce 100644 --- a/block/bdev.c +++ b/block/bdev.c @@ -30,8 +30,20 @@ #include "../fs/internal.h" #include "blk.h" +#define OPEN_EXCLUSIVE "VFS: Open an exclusive opened block device for write" +#define OPEN_FOR_EXCLUSIVE "VFS: Open a write opened block device exclusively" +#define bdev_opt(opt) (bdev_allow_write_mounted & (1 << BLKDEV_##opt)) /* Should we allow writing to mounted block devices? */ -static bool bdev_allow_write_mounted = IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED); +#define BLKDEV_ALLOW_WRITE_MOUNTED 0 +/* Should we detect writing to part0 when partitions mounted */ +#define BLKDEV_DETECT_WRITING_PART0 1 +/* Should we dump info when opening mounted block devices for write? */ +#define BLKDEV_WRITE_MOUNTED_DUMP 2 + +static u8 bdev_allow_write_mounted = + IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED) << BLKDEV_ALLOW_WRITE_MOUNTED || + IS_ENABLED(CONFIG_BLK_DEV_DETECT_WRITING_PART0) << BLKDEV_DETECT_WRITING_PART0 || + IS_ENABLED(CONFIG_BLK_DEV_WRITE_MOUNTED_DUMP) << BLKDEV_WRITE_MOUNTED_DUMP; struct bdev_inode { struct block_device bdev; @@ -733,55 +745,119 @@ void blkdev_put_no_open(struct block_device *bdev) put_device(&bdev->bd_device); } +static void blkdev_dump_conflict_opener(struct block_device *bdev, char *msg) +{ + char name[BDEVNAME_SIZE]; + struct task_struct *p = NULL; + char comm_buf[TASK_COMM_LEN]; + pid_t p_pid; + + if (!bdev_opt(WRITE_MOUNTED_DUMP)) + return; + rcu_read_lock(); + p = rcu_dereference(current->real_parent); + task_lock(p); + strncpy(comm_buf, p->comm, TASK_COMM_LEN); + p_pid = p->pid; + task_unlock(p); + rcu_read_unlock(); + + snprintf(name, sizeof(name), "%pg", bdev); + pr_info_ratelimited("%s [%s]. current [%d %s]. parent [%d %s]\n", + msg, name, + current->pid, current->comm, p_pid, comm_buf); +} + static bool bdev_writes_blocked(struct block_device *bdev) { - return bdev->bd_writers == -1; + if (bdev->bd_mounted) + return true; + if (bdev_opt(DETECT_WRITING_PART0)) + return bdev_is_partition(bdev) ? bdev_whole(bdev)->bd_mounted : + bdev->bd_disk->part_mounters; + + return false; } static void bdev_block_writes(struct block_device *bdev) { - bdev->bd_writers = -1; + bdev->bd_mounted = true; + if (bdev_is_partition(bdev)) + bdev->bd_disk->part_mounters++; } static void bdev_unblock_writes(struct block_device *bdev) { - bdev->bd_writers = 0; + bdev->bd_mounted = false; + if (bdev_is_partition(bdev)) + bdev->bd_disk->part_mounters--; +} + +static bool bdev_mount_blocked(struct block_device *bdev) +{ + if (bdev->bd_writers) + return true; + if (bdev_opt(DETECT_WRITING_PART0)) + return bdev_is_partition(bdev) ? bdev_whole(bdev)->bd_writers : + bdev->bd_disk->part_writers; + + return false; +} + +static void bdev_block_mount(struct block_device *bdev) +{ + bdev->bd_writers++; + if (bdev_is_partition(bdev)) + bdev->bd_disk->part_writers++; +} + +static void bdev_unblock_mount(struct block_device *bdev) +{ + bdev->bd_writers--; + if (bdev_is_partition(bdev)) + bdev->bd_disk->part_writers--; +} + +static bool bdev_lower_device_writes_blocked(struct block_device *bdev) +{ + if (bdev_opt(DETECT_WRITING_PART0)) + return !!bdev->bd_holder; + else + return !!bdev->bd_holder && bdev->bd_holder != bd_may_claim; } static bool bdev_may_open(struct block_device *bdev, blk_mode_t mode) { - if (bdev_allow_write_mounted) + if (bdev_opt(ALLOW_WRITE_MOUNTED) && !bdev_opt(WRITE_MOUNTED_DUMP)) return true; /* Writes blocked? */ - if (mode & BLK_OPEN_WRITE && bdev_writes_blocked(bdev)) - return false; - if (mode & BLK_OPEN_RESTRICT_WRITES && bdev->bd_writers > 0) - return false; - return true; + if (mode & BLK_OPEN_WRITE && (bdev_writes_blocked(bdev) || + bdev_lower_device_writes_blocked(bdev))) + blkdev_dump_conflict_opener(bdev, OPEN_EXCLUSIVE); + else if (mode & BLK_OPEN_RESTRICT_WRITES && bdev_mount_blocked(bdev)) + blkdev_dump_conflict_opener(bdev, OPEN_FOR_EXCLUSIVE); + else + return true; + + return bdev_opt(ALLOW_WRITE_MOUNTED); } static void bdev_claim_write_access(struct block_device *bdev, blk_mode_t mode) { - if (bdev_allow_write_mounted) - return; - /* Claim exclusive or shared write access. */ if (mode & BLK_OPEN_RESTRICT_WRITES) bdev_block_writes(bdev); else if (mode & BLK_OPEN_WRITE) - bdev->bd_writers++; + bdev_block_mount(bdev); } static void bdev_yield_write_access(struct block_device *bdev, blk_mode_t mode) { - if (bdev_allow_write_mounted) - return; - /* Yield exclusive or shared write access. */ if (mode & BLK_OPEN_RESTRICT_WRITES) bdev_unblock_writes(bdev); else if (mode & BLK_OPEN_WRITE) - bdev->bd_writers--; + bdev_unblock_mount(bdev); } /** @@ -1135,7 +1211,7 @@ void bdev_statx_dioalign(struct inode *inode, struct kstat *stat) static int __init setup_bdev_allow_write_mounted(char *str) { - if (kstrtobool(str, &bdev_allow_write_mounted)) + if (kstrtou8(str, 0, &bdev_allow_write_mounted)) pr_warn("Invalid option string for bdev_allow_write_mounted:" " '%s'\n", str); return 1; diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h index 262ae789726b1f2a127aa4f31d147b3c68873bc4..f571b45eba19dfde9685ff031877a824929032ea 100644 --- a/include/linux/blk_types.h +++ b/include/linux/blk_types.h @@ -69,6 +69,9 @@ struct block_device { #ifdef CONFIG_FAIL_MAKE_REQUEST bool bd_make_it_fail; #endif + /* State of mounting */ + bool bd_mounted; + /* The counter of write opened */ int bd_writers; /* * keep this out-of-line as it's both big and not needed in the fast diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h index bea0b5fdac7475c5236e059e4ef082d2d3628754..993eafd830272465cff10dc1382e4ce0d398c88e 100644 --- a/include/linux/blkdev.h +++ b/include/linux/blkdev.h @@ -209,6 +209,8 @@ struct gendisk { * devices that do not have multiple independent access ranges. */ struct blk_independent_access_ranges *ia_ranges; + int part_mounters; + int part_writers; }; static inline bool disk_live(struct gendisk *disk)