Re: [PATCH RFC] btrfs: implement a new compat RO feature, data_io_size
Qu Wenruo <[email protected]> Wed, 22 Jul 2026 19:33:41 +0930
| Newsgroups | org.kernel.vger.linux-btrfs |
|---|---|
| Message-ID | <[email protected]> |
在 2026/7/22 19:28, Sun YangKai 写道: > On 2026/7/22 17:25, Qu Wenruo wrote: >> >> >> 在 2026/7/22 18:52, Sun YangKai 写道: >>> On 2026/6/28 14:27, Qu Wenruo wrote: >>>> To address the btrfs RAID56 write-hole problem, there is one idea to >>>> solve it: >>>> >>>> Make sure all data writes are full stripe aligned >>>> However based on that idea, we can have two different directions to >>>> implement: >>>> >>>> - Keep the sector size untouched, introduce a newer io size for data >>>> E.g. sector size is still 4K, but data io size is 16K, and RAID56 >>>> full stripe size is also set to 16K. >>> >>> Sorry, I cannot follow you here about "RAID56 full stripe size is also >>> set to 16K". >> >> Just as what it reads. >> >> Not using the fixed 64K stripe size, but per-chunk full stripe size. > > I appreciate that you'd love to explain more about this. > > But I still cannot understand how 16KiB full stripe size can fit on a 4 > disks RAID5 for example. Currently we have 3*64KiB = 192KiB as full > stripe size for this kind of setup. But if using 16KiB full stripe size, > how many data on each disk and how's the logical address mapped to those > disks? Full stripe 16K, then the new RAID5F chunks will require power-of-2 disks, and no more than 16K/4K disks. So no 4 disks RAID5F chunk in the first place. > > Thanks, > Sun YangKai > >>> >>> Currently I think we have a 64KiB chunk on each disk, and for n disks >>> RAID5, we have (n-1) * 64KiB as data's full stripe size and one more >>> 64KiB for parity if I understand it correctly. Then how can we limit the >>> full stripe size to 16K with n devices? >>> >>> 16K/(n-1) bytes on each disk is insane. Or we just limit device count >>> for RAID5 to a specific number like 3 disks so we can have 2 device for >>> data, 1 for parity and can get a 8KiB chunk on each disk? >>> >>>> This allows us to reuse the existing sector size based >>>> read-repair/scrub. >>>> >>>> And this patch is the PoC of this idea. >>>> >>>> The problems are also obvious, we need to not only introduce a >>>> dedicated compat RO flag, but also convert almost all sectorsize >>>> users >>>> to use the new data_io_size, except data checksum and read-repair >>>> related code. >>>> >>>> - Use larger block size, introduce a newer sub-block RAID56 repair >>>> E.g. sector size is 16K, and RAID56 full stripe size is also set to >>>> 16K. >>>> >>>> This allows us to reuse the existing experimental bs > ps support. >>>> >>>> The problems are that we need a completely new RAID56 sub-block >>>> rebuild handling. >>>> And the new rebuild can be very slow. Since we do not know exact >>>> which >>>> sub-block is corrupted, we have to exhaust all combinations just >>>> for a >>>> single block. >>>> >>>> And the current btrfs_map_block() also need to support sub-block >>>> splitting, which is completely new, and will also affect checksum >>>> handling. >>>> >>>> So far it looks like the new data io size is the easier solution, thus >>>> here is the RFC patch. >>>> >>>> But in reality, this RFC patch is already super huge, almost touching >>>> all call sites using fs_info->sectorsize, and there are still a lot of >>>> left-over and causing all kinds of warnings. >>>> >>>> For now I'm wondering if it would be better just to replace sectorsize >>>> with data_io_size, and introduce a dedicated member for checksum/scrub. >>>> >>>> Signed-off-by: Qu Wenruo <[email protected]> >>>> --- >>>> Reason for RFC: >>>> This patch is still very unstable, there are still a lot of sites not >>>> properly converted to use the new fs_info->data_io_size. >>>> >>>> This is only for proof-of-concept purpose. >>>> --- >>>> fs/btrfs/accessors.h | 2 + >>>> fs/btrfs/direct-io.c | 6 +-- >>>> fs/btrfs/disk-io.c | 23 ++++++++++- >>>> fs/btrfs/file.c | 68 +++++++++++++++ >>>> +----------------- >>>> fs/btrfs/fs.h | 9 ++++- >>>> fs/btrfs/inode.c | 60 ++++++++++++++--------------- >>>> fs/btrfs/lzo.c | 2 +- >>>> fs/btrfs/sysfs.c | 2 + >>>> fs/btrfs/tests/btrfs-tests.c | 1 + >>>> include/uapi/linux/btrfs.h | 7 ++++ >>>> include/uapi/linux/btrfs_tree.h | 3 +- >>>> 11 files changed, 112 insertions(+), 71 deletions(-) >>>> >>>> diff --git a/fs/btrfs/accessors.h b/fs/btrfs/accessors.h >>>> index 8938357fcb40..7a5206db2224 100644 >>>> --- a/fs/btrfs/accessors.h >>>> +++ b/fs/btrfs/accessors.h >>>> @@ -889,6 +889,8 @@ >>>> BTRFS_SETGET_STACK_FUNCS(super_remap_root_generation, struct >>>> btrfs_super_block, >>>> remap_root_generation, 64); >>>> BTRFS_SETGET_STACK_FUNCS(super_remap_root_level, struct >>>> btrfs_super_block, >>>> remap_root_level, 8); >>>> +BTRFS_SETGET_STACK_FUNCS(super_data_io_size, struct btrfs_super_block, >>>> + data_io_size, 32); >>>> /* struct btrfs_file_extent_item */ >>>> BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct >>>> btrfs_file_extent_item, >>>> diff --git a/fs/btrfs/direct-io.c b/fs/btrfs/direct-io.c >>>> index 3e227292b0ac..df1b2f2725ca 100644 >>>> --- a/fs/btrfs/direct-io.c >>>> +++ b/fs/btrfs/direct-io.c >>>> @@ -186,7 +186,7 @@ static struct extent_map >>>> *btrfs_new_extent_direct(struct btrfs_inode *inode, >>>> alloc_hint = btrfs_get_extent_allocation_hint(inode, start, len); >>>> again: >>>> - ret = btrfs_reserve_extent(root, len, len, fs_info->sectorsize, >>>> + ret = btrfs_reserve_extent(root, len, len, fs_info->data_io_size, >>>> 0, alloc_hint, &ins, true, true); >>>> if (ret == -EAGAIN) { >>>> ASSERT(btrfs_is_zoned(fs_info)); >>>> @@ -395,7 +395,7 @@ static int btrfs_dio_iomap_begin(struct inode >>>> *inode, loff_t start, >>>> * to allocate a contiguous array for the checksums. >>>> */ >>>> if (!write) >>>> - len = min_t(u64, len, fs_info->sectorsize * BIO_MAX_VECS); >>>> + len = min_t(u64, len, fs_info->data_io_size * BIO_MAX_VECS); >>>> lockstart = start; >>>> lockend = start + len - 1; >>>> @@ -829,7 +829,7 @@ static struct iomap_dio *btrfs_dio_write(struct >>>> kiocb *iocb, struct iov_iter *it >>>> static ssize_t check_direct_IO(struct btrfs_fs_info *fs_info, >>>> const struct iov_iter *iter, loff_t offset) >>>> { >>>> - const u32 blocksize_mask = fs_info->sectorsize - 1; >>>> + const u32 blocksize_mask = fs_info->data_io_size - 1; >>>> if (offset & blocksize_mask) >>>> return -EINVAL; >>>> diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c >>>> index e4ffcd49d7af..29797b767df7 100644 >>>> --- a/fs/btrfs/disk-io.c >>>> +++ b/fs/btrfs/disk-io.c >>>> @@ -2508,6 +2508,23 @@ int btrfs_validate_super(const struct >>>> btrfs_fs_info *fs_info, >>>> ret = -EINVAL; >>>> } >>>> + if (btrfs_fs_compat_ro(fs_info, DATA_IO_SIZE)) { >>>> + const u32 data_io_size = btrfs_super_data_io_size(sb); >>>> + >>>> + /* >>>> + * If data io size is set, make sure it is not smaller than >>>> + * sectorsize. >>>> + * And for now we only support data io size up to >>>> MAX_BLOCKSIZE. >>>> + */ >>>> + if (unlikely(!is_power_of_2(data_io_size) || >>>> + data_io_size < sectorsize || >>>> + data_io_size > BTRFS_MAX_BLOCKSIZE)) { >>>> + btrfs_err(fs_info, >>>> + "invalid data io size, has %u expect power of 2 number in range >>>> [%u, %u]", >>>> + data_io_size, sectorsize, BTRFS_MAX_BLOCKSIZE); >>>> + ret = -EINVAL; >>>> + } >>>> + } >>>> if (btrfs_fs_incompat(fs_info, REMAP_TREE)) { >>>> /* >>>> * Reduce test matrix for remap tree by requiring block- >>>> group-tree >>>> @@ -3472,8 +3489,12 @@ int __cold open_ctree(struct super_block *sb, >>>> struct btrfs_fs_devices *fs_device >>>> fs_info->nodesize = nodesize; >>>> fs_info->nodesize_bits = ilog2(nodesize); >>>> fs_info->sectorsize = sectorsize; >>>> + if (btrfs_fs_compat_ro(fs_info, DATA_IO_SIZE)) >>>> + fs_info->data_io_size = btrfs_super_data_io_size(disk_super); >>>> + else >>>> + fs_info->data_io_size = sectorsize; >>>> fs_info->sectorsize_bits = ilog2(sectorsize); >>>> - fs_info->block_min_order = ilog2(round_up(sectorsize, PAGE_SIZE) >>>>>> PAGE_SHIFT); >>>> + fs_info->block_min_order = ilog2(round_up(fs_info->data_io_size, >>>> PAGE_SIZE) >> PAGE_SHIFT); >>>> fs_info->block_max_order = calc_block_max_order(fs_info- >>>>> sectorsize_bits); >>>> fs_info->csums_per_leaf = BTRFS_MAX_ITEM_SIZE(fs_info) / >>>> fs_info->csum_size; >>>> fs_info->fs_devices->fs_info = fs_info; >>>> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c >>>> index df8f6f565070..8397d96a5992 100644 >>>> --- a/fs/btrfs/file.c >>>> +++ b/fs/btrfs/file.c >>>> @@ -45,8 +45,8 @@ >>>> static void btrfs_drop_folio(struct btrfs_fs_info *fs_info, struct >>>> folio *folio, >>>> u64 pos, u64 copied) >>>> { >>>> - u64 block_start = round_down(pos, fs_info->sectorsize); >>>> - u64 block_len = round_up(pos + copied, fs_info->sectorsize) - >>>> block_start; >>>> + u64 block_start = round_down(pos, fs_info->data_io_size); >>>> + u64 block_len = round_up(pos + copied, fs_info->data_io_size) - >>>> block_start; >>>> ASSERT(block_len <= U32_MAX); >>>> folio_unlock(folio); >>>> @@ -78,8 +78,8 @@ int btrfs_dirty_folio(struct btrfs_inode *inode, >>>> struct folio *folio, loff_t pos >>>> if (noreserve) >>>> extra_bits |= EXTENT_NORESERVE; >>>> - start_pos = round_down(pos, fs_info->sectorsize); >>>> - num_bytes = round_up(end_pos - start_pos, fs_info->sectorsize); >>>> + start_pos = round_down(pos, fs_info->data_io_size); >>>> + num_bytes = round_up(end_pos - start_pos, fs_info->data_io_size); >>>> ASSERT(num_bytes <= U32_MAX); >>>> ASSERT(folio_pos(folio) <= pos && folio_next_pos(folio) >= >>>> end_pos); >>>> @@ -395,7 +395,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle >>>> *trans, >>>> extent_type == BTRFS_FILE_EXTENT_INLINE) { >>>> args->bytes_found += extent_end - key.offset; >>>> extent_end = ALIGN(extent_end, >>>> - fs_info->sectorsize); >>>> + fs_info->data_io_size); >>>> } else if (update_refs && disk_bytenr > 0) { >>>> struct btrfs_ref ref = { >>>> .action = BTRFS_DROP_DELAYED_REF, >>>> @@ -788,7 +788,7 @@ static int prepare_uptodate_folio(struct inode >>>> *inode, struct folio *folio, u64 >>>> { >>>> u64 clamp_start = max_t(u64, pos, folio_pos(folio)); >>>> u64 clamp_end = min_t(u64, pos + len, folio_next_pos(folio)); >>>> - const u32 blocksize = inode_to_fs_info(inode)->sectorsize; >>>> + const u32 blocksize = inode_to_fs_info(inode)->data_io_size; >>>> int ret = 0; >>>> if (folio_test_uptodate(folio)) >>>> @@ -893,8 +893,8 @@ lock_and_cleanup_extent_if_need(struct >>>> btrfs_inode *inode, struct folio *folio, >>>> u64 last_pos; >>>> int ret = 0; >>>> - start_pos = round_down(pos, fs_info->sectorsize); >>>> - last_pos = round_up(pos + write_bytes, fs_info->sectorsize) - 1; >>>> + start_pos = round_down(pos, fs_info->data_io_size); >>>> + last_pos = round_up(pos + write_bytes, fs_info->data_io_size) - 1; >>>> if (start_pos < inode->vfs_inode.i_size) { >>>> struct btrfs_ordered_extent *ordered; >>>> @@ -978,9 +978,9 @@ int btrfs_check_nocow_lock(struct btrfs_inode >>>> *inode, loff_t pos, >>>> if (!btrfs_drew_try_write_lock(&root->snapshot_lock)) >>>> return -EAGAIN; >>>> - lockstart = round_down(pos, fs_info->sectorsize); >>>> + lockstart = round_down(pos, fs_info->data_io_size); >>>> lockend = round_up(pos + *write_bytes, >>>> - fs_info->sectorsize) - 1; >>>> + fs_info->data_io_size) - 1; >>>> if (nowait) { >>>> if (!btrfs_try_lock_ordered_range(inode, lockstart, lockend, >>>> @@ -1067,7 +1067,7 @@ int btrfs_write_check(struct kiocb *iocb, >>>> size_t count) >>>> oldsize = i_size_read(inode); >>>> if (pos > oldsize) { >>>> /* Expand hole size to cover write data, preventing empty >>>> gap */ >>>> - loff_t end_pos = round_up(pos + count, fs_info->sectorsize); >>>> + loff_t end_pos = round_up(pos + count, fs_info->data_io_size); >>>> ret = btrfs_cont_expand(BTRFS_I(inode), oldsize, end_pos); >>>> if (ret) >>>> @@ -1090,7 +1090,7 @@ static void release_space(struct btrfs_inode >>>> *inode, struct extent_changeset *da >>>> const struct btrfs_fs_info *fs_info = inode->root->fs_info; >>>> btrfs_delalloc_release_space(inode, data_reserved, >>>> - round_down(start, fs_info->sectorsize), >>>> + round_down(start, fs_info->data_io_size), >>>> len, true); >>>> } >>>> } >>>> @@ -1107,7 +1107,7 @@ static ssize_t reserve_space(struct btrfs_inode >>>> *inode, >>>> bool *only_release_metadata) >>>> { >>>> const struct btrfs_fs_info *fs_info = inode->root->fs_info; >>>> - const unsigned int block_offset = (start & (fs_info->sectorsize >>>> - 1)); >>>> + const unsigned int block_offset = (start & (fs_info- >>>>> data_io_size - 1)); >>>> size_t reserve_bytes; >>>> int ret; >>>> @@ -1132,7 +1132,7 @@ static ssize_t reserve_space(struct btrfs_inode >>>> *inode, >>>> *only_release_metadata = true; >>>> } >>>> - reserve_bytes = round_up(*len + block_offset, fs_info->sectorsize); >>>> + reserve_bytes = round_up(*len + block_offset, fs_info- >>>>> data_io_size); >>>> WARN_ON(reserve_bytes == 0); >>>> ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes, >>>> reserve_bytes, nowait); >>>> @@ -1192,7 +1192,7 @@ static int copy_one_range(struct btrfs_inode >>>> *inode, struct iov_iter *iter, >>>> struct extent_state *cached_state = NULL; >>>> size_t write_bytes = calc_write_bytes(inode, iter, start); >>>> size_t copied; >>>> - const u64 reserved_start = round_down(start, fs_info->sectorsize); >>>> + const u64 reserved_start = round_down(start, fs_info- >>>>> data_io_size); >>>> u64 reserved_len; >>>> struct folio *folio = NULL; >>>> int extents_locked; >>>> @@ -1301,7 +1301,7 @@ static int copy_one_range(struct btrfs_inode >>>> *inode, struct iov_iter *iter, >>>> } >>>> /* Release the reserved space beyond the last block. */ >>>> - last_block = round_up(start + copied, fs_info->sectorsize); >>>> + last_block = round_up(start + copied, fs_info->data_io_size); >>>> shrink_reserved_space(inode, *data_reserved, reserved_start, >>>> reserved_len, last_block - reserved_start, >>>> @@ -1938,7 +1938,7 @@ static vm_fault_t btrfs_page_mkwrite(struct >>>> vm_fault *vmf) >>>> } >>>> if (folio_contains(folio, (size - 1) >> PAGE_SHIFT)) { >>>> - reserved_space = round_up(size - page_start, fs_info- >>>>> sectorsize); >>>> + reserved_space = round_up(size - page_start, fs_info- >>>>> data_io_size); >>>> if (reserved_space < fsize) { >>>> const u64 to_free = fsize - reserved_space; >>>> @@ -2182,8 +2182,8 @@ static int find_first_non_hole(struct >>>> btrfs_inode *inode, u64 *start, u64 *len) >>>> int ret = 0; >>>> em = btrfs_get_extent(inode, NULL, >>>> - round_down(*start, fs_info->sectorsize), >>>> - round_up(*len, fs_info->sectorsize)); >>>> + round_down(*start, fs_info->data_io_size), >>>> + round_up(*len, fs_info->data_io_size)); >>>> if (IS_ERR(em)) >>>> return PTR_ERR(em); >>>> @@ -2396,7 +2396,7 @@ int btrfs_replace_file_extents(struct >>>> btrfs_inode *inode, >>>> struct btrfs_root *root = inode->root; >>>> struct btrfs_fs_info *fs_info = root->fs_info; >>>> const u64 min_size = btrfs_calc_insert_metadata_size(fs_info, 1); >>>> - u64 ino_size = round_up(inode->vfs_inode.i_size, fs_info- >>>>> sectorsize); >>>> + u64 ino_size = round_up(inode->vfs_inode.i_size, fs_info- >>>>> data_io_size); >>>> struct btrfs_trans_handle *trans = NULL; >>>> struct btrfs_block_rsv rsv; >>>> unsigned int rsv_count; >>>> @@ -2667,7 +2667,7 @@ static int btrfs_punch_hole(struct file *file, >>>> loff_t offset, loff_t len) >>>> if (ret) >>>> goto out_only_mutex; >>>> - ino_size = round_up(inode->i_size, fs_info->sectorsize); >>>> + ino_size = round_up(inode->i_size, fs_info->data_io_size); >>>> ret = find_first_non_hole(BTRFS_I(inode), &offset, &len); >>>> if (ret < 0) >>>> goto out_only_mutex; >>>> @@ -2681,15 +2681,15 @@ static int btrfs_punch_hole(struct file >>>> *file, loff_t offset, loff_t len) >>>> if (ret) >>>> goto out_only_mutex; >>>> - lockstart = round_up(offset, fs_info->sectorsize); >>>> - lockend = round_down(offset + len, fs_info->sectorsize) - 1; >>>> + lockstart = round_up(offset, fs_info->data_io_size); >>>> + lockend = round_down(offset + len, fs_info->data_io_size) - 1; >>>> same_block = (BTRFS_BYTES_TO_BLKS(fs_info, offset)) >>>> == (BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)); >>>> /* >>>> * Only do this if we are in the same block and we aren't >>>> doing the >>>> * entire block. >>>> */ >>>> - if (same_block && len < fs_info->sectorsize) { >>>> + if (same_block && len < fs_info->data_io_size) { >>>> if (offset < ino_size) { >>>> truncated_block = true; >>>> ret = btrfs_truncate_block(BTRFS_I(inode), offset + >>>> len - 1, >>>> @@ -2858,8 +2858,8 @@ static int btrfs_fallocate_update_isize(struct >>>> inode *inode, >>>> if (mode & FALLOC_FL_KEEP_SIZE || end <= i_size_read(inode)) >>>> return 0; >>>> - range_start = round_down(i_size_read(inode), root->fs_info- >>>>> sectorsize); >>>> - range_end = round_up(end, root->fs_info->sectorsize); >>>> + range_start = round_down(i_size_read(inode), root->fs_info- >>>>> data_io_size); >>>> + range_end = round_up(end, root->fs_info->data_io_size); >>>> ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), >>>> range_start, >>>> range_end - range_start); >>>> @@ -2889,7 +2889,7 @@ static int >>>> btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode, >>>> u64 offset) >>>> { >>>> struct extent_map *em; >>>> - const u32 sectorsize = inode->root->fs_info->sectorsize; >>>> + const u32 sectorsize = inode->root->fs_info->data_io_size; >>>> int ret; >>>> offset = round_down(offset, sectorsize); >>>> @@ -2916,7 +2916,7 @@ static int btrfs_zero_range(struct inode *inode, >>>> struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; >>>> struct extent_map *em; >>>> struct extent_changeset *data_reserved = NULL; >>>> - const u32 sectorsize = fs_info->sectorsize; >>>> + const u32 sectorsize = fs_info->data_io_size; >>>> int ret; >>>> u64 alloc_hint = 0; >>>> const u64 orig_start = offset; >>>> @@ -3065,7 +3065,7 @@ static int btrfs_zero_range(struct inode *inode, >>>> } >>>> ret = btrfs_prealloc_file_range(inode, mode, alloc_start, >>>> alloc_end - alloc_start, >>>> - fs_info->sectorsize, >>>> + fs_info->data_io_size, >>>> offset + len, &alloc_hint); >>>> btrfs_unlock_extent(&BTRFS_I(inode)->io_tree, lockstart, >>>> lockend, >>>> &cached_state); >>>> @@ -3105,7 +3105,7 @@ static long btrfs_fallocate(struct file *file, >>>> int mode, >>>> u64 data_space_reserved = 0; >>>> u64 qgroup_reserved = 0; >>>> struct extent_map *em; >>>> - int blocksize = BTRFS_I(inode)->root->fs_info->sectorsize; >>>> + int blocksize = BTRFS_I(inode)->root->fs_info->data_io_size; >>>> int ret; >>>> if (btrfs_is_shutdown(inode_to_fs_info(inode))) >>>> @@ -3414,7 +3414,7 @@ bool btrfs_find_delalloc_in_range(struct >>>> btrfs_inode *inode, u64 start, u64 end, >>>> struct extent_state **cached_state, >>>> u64 *delalloc_start_ret, u64 *delalloc_end_ret) >>>> { >>>> - u64 cur_offset = round_down(start, inode->root->fs_info- >>>>> sectorsize); >>>> + u64 cur_offset = round_down(start, inode->root->fs_info- >>>>> data_io_size); >>>> u64 prev_delalloc_end = 0; >>>> bool search_io_tree = true; >>>> bool ret = false; >>>> @@ -3602,10 +3602,10 @@ static loff_t find_desired_extent(struct file >>>> *file, loff_t offset, int whence) >>>> */ >>>> start = max_t(loff_t, 0, offset); >>>> - lockstart = round_down(start, fs_info->sectorsize); >>>> - lockend = round_up(i_size, fs_info->sectorsize); >>>> + lockstart = round_down(start, fs_info->data_io_size); >>>> + lockend = round_up(i_size, fs_info->data_io_size); >>>> if (lockend <= lockstart) >>>> - lockend = lockstart + fs_info->sectorsize; >>>> + lockend = lockstart + fs_info->data_io_size; >>>> lockend--; >>>> path = btrfs_alloc_path(); >>>> diff --git a/fs/btrfs/fs.h b/fs/btrfs/fs.h >>>> index ab5ed7b4f639..cee4c772cfd9 100644 >>>> --- a/fs/btrfs/fs.h >>>> +++ b/fs/btrfs/fs.h >>>> @@ -299,7 +299,7 @@ enum { >>>> #define BTRFS_FEATURE_COMPAT_SAFE_SET 0ULL >>>> #define BTRFS_FEATURE_COMPAT_SAFE_CLEAR 0ULL >>>> -#define BTRFS_FEATURE_COMPAT_RO_SUPP \ >>>> +#define BTRFS_FEATURE_COMPAT_RO_SUPP_STABLE \ >>>> (BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE | \ >>>> BTRFS_FEATURE_COMPAT_RO_FREE_SPACE_TREE_VALID | \ >>>> BTRFS_FEATURE_COMPAT_RO_VERITY | \ >>>> @@ -335,11 +335,17 @@ enum { >>>> BTRFS_FEATURE_INCOMPAT_EXTENT_TREE_V2 | \ >>>> BTRFS_FEATURE_INCOMPAT_REMAP_TREE) >>>> +#define BTRFS_FEATURE_COMPAT_RO_SUPP \ >>>> + (BTRFS_FEATURE_COMPAT_RO_SUPP_STABLE | \ >>>> + BTRFS_FEATURE_COMPAT_RO_DATA_IO_SIZE) >>>> #else >>>> #define BTRFS_FEATURE_INCOMPAT_SUPP \ >>>> (BTRFS_FEATURE_INCOMPAT_SUPP_STABLE) >>>> +#define BTRFS_FEATURE_COMPAT_RO_SUPP \ >>>> + (BTRFS_FEATURE_COMPAT_RO_SUPP_STABLE) >>>> + >>>> #endif >>>> #define BTRFS_FEATURE_INCOMPAT_SAFE_SET \ >>>> @@ -892,6 +898,7 @@ struct btrfs_fs_info { >>>> u32 csum_size; >>>> u32 csums_per_leaf; >>>> u32 csum_type; >>>> + u32 data_io_size; >>>> /* >>>> * Maximum size of an extent. BTRFS_MAX_EXTENT_SIZE on regular >>>> diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c >>>> index b696dd329fd7..de0364ce950b 100644 >>>> --- a/fs/btrfs/inode.c >>>> +++ b/fs/btrfs/inode.c >>>> @@ -190,7 +190,7 @@ static int data_reloc_print_warning_inode(u64 >>>> inum, u64 offset, u64 num_bytes, >>>> btrfs_warn(fs_info, >>>> "checksum error at logical %llu mirror %u root %llu inode %llu >>>> offset %llu length %u links %u (path: %s)", >>>> warn->logical, warn->mirror_num, root, inum, offset, >>>> - fs_info->sectorsize, nlink, >>>> + fs_info->data_io_size, nlink, >>>> (char *)(unsigned long)ipath->fspath->val[i]); >>>> } >>>> @@ -1397,7 +1397,7 @@ static noinline int cow_file_range(struct >>>> btrfs_inode *inode, >>>> if (btrfs_is_data_reloc_root(root)) >>>> min_alloc_size = num_bytes; >>>> else >>>> - min_alloc_size = fs_info->sectorsize; >>>> + min_alloc_size = fs_info->data_io_size; >>>> while (num_bytes > 0) { >>>> ret = cow_one_range(inode, locked_folio, &ins, &cached, >>>> start, >>>> @@ -2783,7 +2783,7 @@ int btrfs_set_extent_delalloc(struct >>>> btrfs_inode *inode, u64 start, u64 end, >>>> unsigned int extra_bits, >>>> struct extent_state **cached_state) >>>> { >>>> - const u32 blocksize = inode->root->fs_info->sectorsize; >>>> + const u32 blocksize = inode->root->fs_info->data_io_size; >>>> /* Basic alignment check. */ >>>> ASSERT(IS_ALIGNED(start, blocksize), "start=%llu blocksize=%u", >>>> @@ -2820,7 +2820,7 @@ int btrfs_set_extent_delalloc(struct >>>> btrfs_inode *inode, u64 start, u64 end, >>>> int btrfs_reset_extent_delalloc(struct btrfs_inode *inode, u64 >>>> start, u64 end, >>>> unsigned int extra_bits, struct extent_state >>>> **cached_state) >>>> { >>>> - const u32 blocksize = inode->root->fs_info->sectorsize; >>>> + const u32 blocksize = inode->root->fs_info->data_io_size; >>>> /* The @extra_bits can only be EXTENT_NORESERVE for now. */ >>>> ASSERT(!(extra_bits & ~EXTENT_NORESERVE), "extra_bits=0x%x", >>>> extra_bits); >>>> @@ -2874,7 +2874,7 @@ static int insert_reserved_file_extent(struct >>>> btrfs_trans_handle *trans, >>>> u64 num_bytes = btrfs_stack_file_extent_num_bytes(stack_fi); >>>> u64 ram_bytes = btrfs_stack_file_extent_ram_bytes(stack_fi); >>>> struct btrfs_drop_extents_args drop_args = { 0 }; >>>> - const u32 sectorsize = root->fs_info->sectorsize; >>>> + const u32 sectorsize = root->fs_info->data_io_size; >>>> int ret; >>>> path = btrfs_alloc_path(); >>>> @@ -4040,7 +4040,7 @@ static int btrfs_read_locked_inode(struct >>>> btrfs_inode *inode, struct btrfs_path >>>> if (ret) >>>> goto out; >>>> btrfs_inode_set_file_extent_range(inode, 0, >>>> - round_up(i_size_read(vfs_inode), fs_info->sectorsize)); >>>> + round_up(i_size_read(vfs_inode), fs_info->data_io_size)); >>>> if (!maybe_acls) >>>> cache_no_acl(vfs_inode); >>>> @@ -4879,7 +4879,7 @@ int btrfs_truncate_block(struct btrfs_inode >>>> *inode, u64 offset, u64 start, u64 e >>>> struct extent_state *cached_state = NULL; >>>> struct extent_changeset *data_reserved = NULL; >>>> bool only_release_metadata = false; >>>> - u32 blocksize = fs_info->sectorsize; >>>> + u32 blocksize = fs_info->data_io_size; >>>> pgoff_t index = (offset >> PAGE_SHIFT); >>>> struct folio *folio; >>>> gfp_t mask = btrfs_alloc_write_mask(mapping); >>>> @@ -5117,8 +5117,8 @@ int btrfs_cont_expand(struct btrfs_inode >>>> *inode, loff_t oldsize, loff_t size) >>>> struct extent_io_tree *io_tree = &inode->io_tree; >>>> struct extent_map *em = NULL; >>>> struct extent_state *cached_state = NULL; >>>> - u64 hole_start = ALIGN(oldsize, fs_info->sectorsize); >>>> - u64 block_end = ALIGN(size, fs_info->sectorsize); >>>> + u64 hole_start = ALIGN(oldsize, fs_info->data_io_size); >>>> + u64 block_end = ALIGN(size, fs_info->data_io_size); >>>> u64 last_byte; >>>> u64 cur_offset; >>>> u64 hole_size; >>>> @@ -5147,7 +5147,7 @@ int btrfs_cont_expand(struct btrfs_inode >>>> *inode, loff_t oldsize, loff_t size) >>>> break; >>>> } >>>> last_byte = min(btrfs_extent_map_end(em), block_end); >>>> - last_byte = ALIGN(last_byte, fs_info->sectorsize); >>>> + last_byte = ALIGN(last_byte, fs_info->data_io_size); >>>> hole_size = last_byte - cur_offset; >>>> if (!(em->flags & EXTENT_FLAG_PREALLOC)) { >>>> @@ -5253,7 +5253,7 @@ static int btrfs_setsize(struct inode *inode, >>>> struct iattr *attr) >>>> if (btrfs_is_zoned(fs_info)) { >>>> ret = btrfs_wait_ordered_range(BTRFS_I(inode), >>>> - ALIGN(newsize, fs_info->sectorsize), >>>> + ALIGN(newsize, fs_info->data_io_size), >>>> (u64)-1); >>>> if (ret) >>>> return ret; >>>> @@ -7323,7 +7323,7 @@ noinline int can_nocow_extent(struct >>>> btrfs_inode *inode, u64 offset, u64 *len, >>>> u64 range_end; >>>> range_end = round_up(offset + >>>> nocow_args.file_extent.num_bytes, >>>> - root->fs_info->sectorsize) - 1; >>>> + root->fs_info->data_io_size) - 1; >>>> ret = btrfs_test_range_bit_exists(io_tree, offset, range_end, >>>> EXTENT_DELALLOC); >>>> if (ret) >>>> @@ -7653,8 +7653,8 @@ static int btrfs_truncate(struct btrfs_inode >>>> *inode, bool skip_writeback) >>>> int ret; >>>> struct btrfs_trans_handle *trans; >>>> const u64 min_size = btrfs_calc_metadata_size(fs_info, 1); >>>> - const u64 lock_start = round_down(inode->vfs_inode.i_size, >>>> fs_info->sectorsize); >>>> - const u64 i_size_up = round_up(inode->vfs_inode.i_size, fs_info- >>>>> sectorsize); >>>> + const u64 lock_start = round_down(inode->vfs_inode.i_size, >>>> fs_info->data_io_size); >>>> + const u64 i_size_up = round_up(inode->vfs_inode.i_size, fs_info- >>>>> data_io_size); >>>> /* Our inode is locked and the i_size can't be changed >>>> concurrently. */ >>>> btrfs_assert_inode_locked(inode); >>>> @@ -8038,7 +8038,7 @@ static int btrfs_getattr(struct mnt_idmap *idmap, >>>> u64 delalloc_bytes; >>>> u64 inode_bytes; >>>> struct inode *inode = d_inode(path->dentry); >>>> - u32 blocksize = btrfs_sb(inode->i_sb)->sectorsize; >>>> + u32 blocksize = btrfs_sb(inode->i_sb)->data_io_size; >>>> u32 bi_flags = BTRFS_I(inode)->flags; >>>> u32 bi_ro_flags = BTRFS_I(inode)->ro_flags; >>>> @@ -9124,8 +9124,8 @@ static int __btrfs_prealloc_file_range(struct >>>> inode *inode, int mode, >>>> * to truncate disk_i_size to the start of the gap, >>>> * making the persisted size smaller than i_size. >>>> */ >>>> - range_start = round_down(inode->i_size, fs_info- >>>>> sectorsize); >>>> - range_end = round_up(i_size, fs_info->sectorsize); >>>> + range_start = round_down(inode->i_size, fs_info- >>>>> data_io_size); >>>> + range_end = round_up(i_size, fs_info->data_io_size); >>>> ret = btrfs_inode_set_file_extent_range(BTRFS_I(inode), >>>> range_start, range_end - range_start); >>>> if (ret) { >>>> @@ -9272,10 +9272,10 @@ int >>>> btrfs_encoded_io_compression_from_extent(struct btrfs_fs_info *fs_info, >>>> * The LZO format depends on the sector size. 64K is the >>>> maximum >>>> * sector size that we support. >>>> */ >>>> - if (fs_info->sectorsize < SZ_4K || fs_info->sectorsize > >>>> SZ_64K) >>>> + if (fs_info->data_io_size < SZ_4K || fs_info->data_io_size > >>>> SZ_64K) >>>> return -EINVAL; >>>> return BTRFS_ENCODED_IO_COMPRESSION_LZO_4K + >>>> - (fs_info->sectorsize_bits - 12); >>>> + (ilog2(fs_info->data_io_size) - 12); >>>> case BTRFS_COMPRESS_ZSTD: >>>> return BTRFS_ENCODED_IO_COMPRESSION_ZSTD; >>>> default: >>>> @@ -9563,7 +9563,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, >>>> struct iov_iter *iter, >>>> btrfs_inode_unlock(inode, BTRFS_ILOCK_SHARED); >>>> return 0; >>>> } >>>> - start = ALIGN_DOWN(iocb->ki_pos, fs_info->sectorsize); >>>> + start = ALIGN_DOWN(iocb->ki_pos, fs_info->data_io_size); >>>> /* >>>> * We don't know how long the extent containing iocb->ki_pos >>>> is, but if >>>> * it's compressed we know that it won't be longer than this. >>>> @@ -9676,7 +9676,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, >>>> struct iov_iter *iter, >>>> count = start + *disk_io_size - iocb->ki_pos; >>>> encoded->len = count; >>>> encoded->unencoded_len = count; >>>> - *disk_io_size = ALIGN(*disk_io_size, fs_info->sectorsize); >>>> + *disk_io_size = ALIGN(*disk_io_size, fs_info->data_io_size); >>>> } >>>> btrfs_free_extent_map(em); >>>> em = NULL; >>>> @@ -9720,7 +9720,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb >>>> *iocb, struct iov_iter *from, >>>> int compression; >>>> size_t orig_count; >>>> const u32 min_folio_size = btrfs_min_folio_size(fs_info); >>>> - const u32 blocksize = fs_info->sectorsize; >>>> + const u32 blocksize = fs_info->data_io_size; >>>> u64 start, end; >>>> u64 num_bytes, ram_bytes, disk_num_bytes; >>>> struct btrfs_key ins; >>>> @@ -9743,7 +9743,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb >>>> *iocb, struct iov_iter *from, >>>> /* The sector size must match for LZO. */ >>>> if (encoded->compression - >>>> BTRFS_ENCODED_IO_COMPRESSION_LZO_4K + 12 != >>>> - fs_info->sectorsize_bits) >>>> + ilog2(blocksize)) >>>> return -EINVAL; >>>> compression = BTRFS_COMPRESS_LZO; >>>> break; >>>> @@ -9785,7 +9785,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb >>>> *iocb, struct iov_iter *from, >>>> /* The extent must start on a sector boundary. */ >>>> start = iocb->ki_pos; >>>> - if (!IS_ALIGNED(start, fs_info->sectorsize)) >>>> + if (!IS_ALIGNED(start, fs_info->data_io_size)) >>>> return -EINVAL; >>>> /* >>>> @@ -9794,15 +9794,15 @@ ssize_t btrfs_do_encoded_write(struct kiocb >>>> *iocb, struct iov_iter *from, >>>> * up the extent size and set i_size to the unaligned end. >>>> */ >>>> if (start + encoded->len < inode->vfs_inode.i_size && >>>> - !IS_ALIGNED(start + encoded->len, fs_info->sectorsize)) >>>> + !IS_ALIGNED(start + encoded->len, fs_info->data_io_size)) >>>> return -EINVAL; >>>> /* Finally, the offset in the unencoded data must be sector- >>>> aligned. */ >>>> - if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->sectorsize)) >>>> + if (!IS_ALIGNED(encoded->unencoded_offset, fs_info->data_io_size)) >>>> return -EINVAL; >>>> - num_bytes = ALIGN(encoded->len, fs_info->sectorsize); >>>> - ram_bytes = ALIGN(encoded->unencoded_len, fs_info->sectorsize); >>>> + num_bytes = ALIGN(encoded->len, fs_info->data_io_size); >>>> + ram_bytes = ALIGN(encoded->unencoded_len, fs_info->data_io_size); >>>> end = start + num_bytes - 1; >>>> /* >>>> @@ -9810,7 +9810,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb >>>> *iocb, struct iov_iter *from, >>>> * sector-aligned. For convenience, we extend it with zeroes >>>> if it >>>> * isn't. >>>> */ >>>> - disk_num_bytes = ALIGN(orig_count, fs_info->sectorsize); >>>> + disk_num_bytes = ALIGN(orig_count, fs_info->data_io_size); >>>> cb = btrfs_alloc_compressed_write(inode, start, num_bytes); >>>> for (int i = 0; i * min_folio_size < disk_num_bytes; i++) { >>>> @@ -10222,7 +10222,7 @@ static int btrfs_swap_activate(struct >>>> swap_info_struct *sis, struct file *file, >>>> atomic_inc(&root->nr_swapfiles); >>>> spin_unlock(&root->root_item_lock); >>>> - isize = ALIGN_DOWN(inode->i_size, fs_info->sectorsize); >>>> + isize = ALIGN_DOWN(inode->i_size, fs_info->data_io_size); >>>> btrfs_lock_extent(io_tree, 0, isize - 1, &cached_state); >>>> while (prev_extent_end < isize) { >>>> diff --git a/fs/btrfs/lzo.c b/fs/btrfs/lzo.c >>>> index 1531adb117d1..0235530fd0f8 100644 >>>> --- a/fs/btrfs/lzo.c >>>> +++ b/fs/btrfs/lzo.c >>>> @@ -414,7 +414,7 @@ int lzo_decompress_bio(struct list_head *ws, >>>> struct compressed_bio *cb) >>>> { >>>> struct workspace *workspace = list_entry(ws, struct workspace, >>>> list); >>>> struct btrfs_fs_info *fs_info = cb->bbio.inode->root->fs_info; >>>> - const u32 sectorsize = fs_info->sectorsize; >>>> + const u32 sectorsize = fs_info->data_io_size; >>>> const u32 compressed_len = bio_get_size(&cb->bbio.bio); >>>> struct folio_iter fi; >>>> char *kaddr; >>>> diff --git a/fs/btrfs/sysfs.c b/fs/btrfs/sysfs.c >>>> index 0d14570c8bc2..8ca7b7e304e3 100644 >>>> --- a/fs/btrfs/sysfs.c >>>> +++ b/fs/btrfs/sysfs.c >>>> @@ -301,6 +301,7 @@ BTRFS_FEAT_ATTR_INCOMPAT(extent_tree_v2, >>>> EXTENT_TREE_V2); >>>> BTRFS_FEAT_ATTR_INCOMPAT(raid_stripe_tree, RAID_STRIPE_TREE); >>>> /* Remove once support for remap tree is feature complete. */ >>>> BTRFS_FEAT_ATTR_INCOMPAT(remap_tree, REMAP_TREE); >>>> +BTRFS_FEAT_ATTR_COMPAT_RO(data_io_size, DATA_IO_SIZE); >>>> #endif >>>> #ifdef CONFIG_FS_VERITY >>>> BTRFS_FEAT_ATTR_COMPAT_RO(verity, VERITY); >>>> @@ -334,6 +335,7 @@ static struct attribute >>>> *btrfs_supported_feature_attrs[] = { >>>> BTRFS_FEAT_ATTR_PTR(extent_tree_v2), >>>> BTRFS_FEAT_ATTR_PTR(raid_stripe_tree), >>>> BTRFS_FEAT_ATTR_PTR(remap_tree), >>>> + BTRFS_FEAT_ATTR_PTR(data_io_size), >>>> #endif >>>> #ifdef CONFIG_FS_VERITY >>>> BTRFS_FEAT_ATTR_PTR(verity), >>>> diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c >>>> index 6287d940323d..e3e7bbee7cd7 100644 >>>> --- a/fs/btrfs/tests/btrfs-tests.c >>>> +++ b/fs/btrfs/tests/btrfs-tests.c >>>> @@ -140,6 +140,7 @@ struct btrfs_fs_info >>>> *btrfs_alloc_dummy_fs_info(u32 nodesize, u32 sectorsize) >>>> fs_info->nodesize = nodesize; >>>> fs_info->sectorsize = sectorsize; >>>> fs_info->sectorsize_bits = ilog2(sectorsize); >>>> + fs_info->data_io_size = sectorsize; >>>> /* CRC32C csum size. */ >>>> fs_info->csum_size = 4; >>>> diff --git a/include/uapi/linux/btrfs.h b/include/uapi/linux/btrfs.h >>>> index 0a13baf3d8d1..858a37811586 100644 >>>> --- a/include/uapi/linux/btrfs.h >>>> +++ b/include/uapi/linux/btrfs.h >>>> @@ -314,6 +314,13 @@ struct btrfs_ioctl_fs_info_args { >>>> */ >>>> #define BTRFS_FEATURE_COMPAT_RO_BLOCK_GROUP_TREE (1ULL << 3) >>>> +/* >>>> + * Force all IOs (including buffered, direct, compressed) to be aligned >>>> + * to btrfs_super_block::data_io_size other than sectorsize. >>>> + * Meanwhile still data checksum to be calculated based on sectorsize. >>>> + */ >>>> +#define BTRFS_FEATURE_COMPAT_RO_DATA_IO_SIZE (1ULL << 4) >>>> + >>>> #define BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF (1ULL << 0) >>>> #define BTRFS_FEATURE_INCOMPAT_DEFAULT_SUBVOL (1ULL << 1) >>>> #define BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS (1ULL << 2) >>>> diff --git a/include/uapi/linux/btrfs_tree.h b/include/uapi/linux/ >>>> btrfs_tree.h >>>> index cc3b9f7dccaf..3b979ba5a3fc 100644 >>>> --- a/include/uapi/linux/btrfs_tree.h >>>> +++ b/include/uapi/linux/btrfs_tree.h >>>> @@ -724,9 +724,10 @@ struct btrfs_super_block { >>>> __le64 remap_root; >>>> __le64 remap_root_generation; >>>> __u8 remap_root_level; >>>> + __u32 data_io_size; >>>> /* Future expansion */ >>>> - __u8 reserved[199]; >>>> + __u8 reserved[195]; >>>> __u8 sys_chunk_array[BTRFS_SYSTEM_CHUNK_ARRAY_SIZE]; >>>> struct btrfs_root_backup super_roots[BTRFS_NUM_BACKUP_ROOTS]; >>