From 4c1181c05576ddb9ced924459903173f302dda9b Mon Sep 17 00:00:00 2001 From: Zach Brown Date: Fri, 23 Jul 2021 11:48:10 -0700 Subject: [PATCH] Remove first_ and last_ super blkno fields There are fields in the super block that specify the range of blocks that would be used for metadata or data. They are from the time when a single block device was carved up into regions for metadata and data. They don't make sense now that we have separate metadata and data block devices. The starting blkno is static and we go to the end of the device. This removes the fields now that they serve no purpose. The only use of them to check that freed extents fell within the correct bounds can still be performed by using the static starting number or roughly using the size of the devices. It's not perfect, but this is already only a check to see that the blknos aren't utter nonsense. We're removing the fields now to avoid having to update them while worrying about users when resizing devices. Signed-off-by: Zach Brown --- kmod/src/alloc.c | 13 +++++-------- kmod/src/format.h | 4 ---- kmod/src/super.c | 40 +++++++++++----------------------------- utils/src/mkfs.c | 4 ---- utils/src/print.c | 7 +------ 5 files changed, 17 insertions(+), 51 deletions(-) diff --git a/kmod/src/alloc.c b/kmod/src/alloc.c index ac9601b8..1adbcd37 100644 --- a/kmod/src/alloc.c +++ b/kmod/src/alloc.c @@ -261,20 +261,17 @@ static bool invalid_extent(u64 start, u64 end, u64 first, u64 last) static bool invalid_meta_blkno(struct super_block *sb, u64 blkno) { - struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super; + struct scoutfs_sb_info *sbi = SCOUTFS_SB(sb); + u64 last_meta = (i_size_read(sbi->meta_bdev->bd_inode) >> SCOUTFS_BLOCK_LG_SHIFT) - 1; - return invalid_extent(blkno, blkno, - le64_to_cpu(super->first_meta_blkno), - le64_to_cpu(super->last_meta_blkno)); + return invalid_extent(blkno, blkno, SCOUTFS_META_DEV_START_BLKNO, last_meta); } static bool invalid_data_extent(struct super_block *sb, u64 start, u64 len) { - struct scoutfs_super_block *super = &SCOUTFS_SB(sb)->super; + u64 last_data = (i_size_read(sb->s_bdev->bd_inode) >> SCOUTFS_BLOCK_SM_SHIFT) - 1; - return invalid_extent(start, start + len - 1, - le64_to_cpu(super->first_data_blkno), - le64_to_cpu(super->last_data_blkno)); + return invalid_extent(start, start + len - 1, SCOUTFS_DATA_DEV_START_BLKNO, last_data); } void scoutfs_alloc_init(struct scoutfs_alloc *alloc, diff --git a/kmod/src/format.h b/kmod/src/format.h index fb6c1f4f..39fdddd2 100644 --- a/kmod/src/format.h +++ b/kmod/src/format.h @@ -779,11 +779,7 @@ struct scoutfs_super_block { __le64 seq; __le64 next_ino; __le64 total_meta_blocks; /* both static and dynamic */ - __le64 first_meta_blkno; /* first dynamically allocated */ - __le64 last_meta_blkno; __le64 total_data_blocks; - __le64 first_data_blkno; - __le64 last_data_blkno; struct scoutfs_quorum_config qconf; struct scoutfs_alloc_root meta_alloc[2]; struct scoutfs_alloc_root data_alloc; diff --git a/kmod/src/super.c b/kmod/src/super.c index 3d2b3133..eccc6023 100644 --- a/kmod/src/super.c +++ b/kmod/src/super.c @@ -336,28 +336,16 @@ int scoutfs_write_super(struct super_block *sb, sizeof(struct scoutfs_super_block)); } -static bool invalid_blkno_limits(struct super_block *sb, char *which, - u64 start, __le64 first, __le64 last, - struct block_device *bdev, int shift) +static bool small_bdev(struct super_block *sb, char *which, u64 blocks, + struct block_device *bdev, int shift) { - u64 blkno; + u64 size = (u64)i_size_read(bdev->bd_inode); + u64 count = size >> shift; - if (le64_to_cpu(first) < start) { - scoutfs_err(sb, "super block first %s blkno %llu is within first valid blkno %llu", - which, le64_to_cpu(first), start); - return true; - } + if (blocks > count) { + scoutfs_err(sb, "super block records %llu %s blocks, but device %u:%u size %llu only allows %llu blocks", + blocks, which, MAJOR(bdev->bd_dev), MINOR(bdev->bd_dev), size, count); - if (le64_to_cpu(first) > le64_to_cpu(last)) { - scoutfs_err(sb, "super block first %s blkno %llu is greater than last %s blkno %llu", - which, le64_to_cpu(first), which, le64_to_cpu(last)); - return true; - } - - blkno = (i_size_read(bdev->bd_inode) >> shift) - 1; - if (le64_to_cpu(last) > blkno) { - scoutfs_err(sb, "super block last %s blkno %llu is beyond device size last blkno %llu", - which, le64_to_cpu(last), blkno); return true; } @@ -417,16 +405,10 @@ static int scoutfs_read_super_from_bdev(struct super_block *sb, /* XXX do we want more rigorous invalid super checking? */ - if (invalid_blkno_limits(sb, "meta", - SCOUTFS_META_DEV_START_BLKNO, - super->first_meta_blkno, - super->last_meta_blkno, sbi->meta_bdev, - SCOUTFS_BLOCK_LG_SHIFT) || - invalid_blkno_limits(sb, "data", - SCOUTFS_DATA_DEV_START_BLKNO, - super->first_data_blkno, - super->last_data_blkno, sb->s_bdev, - SCOUTFS_BLOCK_SM_SHIFT)) { + if (small_bdev(sb, "metadata", le64_to_cpu(super->total_meta_blocks), sbi->meta_bdev, + SCOUTFS_BLOCK_LG_SHIFT) || + small_bdev(sb, "data", le64_to_cpu(super->total_data_blocks), sb->s_bdev, + SCOUTFS_BLOCK_SM_SHIFT)) { ret = -EINVAL; } diff --git a/utils/src/mkfs.c b/utils/src/mkfs.c index e18d5f9b..23df0071 100644 --- a/utils/src/mkfs.c +++ b/utils/src/mkfs.c @@ -241,11 +241,7 @@ static int do_mkfs(struct mkfs_args *args) super->next_ino = cpu_to_le64(SCOUTFS_ROOT_INO + 1); super->seq = cpu_to_le64(1); super->total_meta_blocks = cpu_to_le64(last_meta + 1); - super->first_meta_blkno = cpu_to_le64(next_meta); - super->last_meta_blkno = cpu_to_le64(last_meta); super->total_data_blocks = cpu_to_le64(last_data - first_data + 1); - super->first_data_blkno = cpu_to_le64(first_data); - super->last_data_blkno = cpu_to_le64(last_data); assert(sizeof(args->slots) == member_sizeof(struct scoutfs_super_block, qconf.slots)); diff --git a/utils/src/print.c b/utils/src/print.c index 4c79a5fb..920393f3 100644 --- a/utils/src/print.c +++ b/utils/src/print.c @@ -951,8 +951,7 @@ static void print_super_block(struct scoutfs_super_block *super, u64 blkno) /* XXX these are all in a crazy order */ printf(" next_ino %llu seq %llu\n" - " total_meta_blocks %llu first_meta_blkno %llu last_meta_blkno %llu\n" - " total_data_blocks %llu first_data_blkno %llu last_data_blkno %llu\n" + " total_meta_blocks %llu total_data_blocks %llu\n" " meta_alloc[0]: "ALCROOT_F"\n" " meta_alloc[1]: "ALCROOT_F"\n" " data_alloc: "ALCROOT_F"\n" @@ -969,11 +968,7 @@ static void print_super_block(struct scoutfs_super_block *super, u64 blkno) le64_to_cpu(super->next_ino), le64_to_cpu(super->seq), le64_to_cpu(super->total_meta_blocks), - le64_to_cpu(super->first_meta_blkno), - le64_to_cpu(super->last_meta_blkno), le64_to_cpu(super->total_data_blocks), - le64_to_cpu(super->first_data_blkno), - le64_to_cpu(super->last_data_blkno), ALCROOT_A(&super->meta_alloc[0]), ALCROOT_A(&super->meta_alloc[1]), ALCROOT_A(&super->data_alloc),