btrfs-progs: convert: proper ext4 unwritten extents handling
cover btrfs-progs: convert: proper ext4 unwritten extents handling
[REPO]
https://github.com/adam900710/btrfs-progs/tree/unwritten_extent
There is a bug report that ext4 unwritten extents (extent with EXT2_EXTENT_FLAGS_UNINIT, acts the same as BTRFS_FILE_EXTENT_PREALLOC) would result a regular btrfs file extent.
Instead of filling the range with zero, converted btrfs would read whatever from the disk, causing corruption.
Although there are some attempts trying to fix the problem, the resulted patches are not meeting our standard, so I have to come up a fix by myself.
The root cause is that, ext2fs_block_iterate2() won't report any extent info, thus it's more or less only useful for ext2 filesystems. For ext4 filesystems, inodes can have a feature called EXT4_EXTENTS_FL, allowing a proper extent based iteratioin.
So this patch would keep the old ext2fs_block_iterate2() as fallback (as for older ext2 fses, they do not support fallocate anyway), while for newer ext4 fses, go with ect2fs_extent_*() APIs to iterate the file extents.
The new APIs provides the extra extent.e_flags to indicate whether the extent is unwritten or not.
For unwritten extents, we just puch it as a hole for now, since even if we create a correct preallocated file extent, the space can not be utlized as it's shared between the file extent and ext2 image.
So just punching a hole would be the simplest workaround for now.
Qu Wenruo (3):
Revert "btrfs-progs: convert: add raid-stripe-tree to allowed
features"
btrfs-progs: convert: rework file extent iteration to handle unwritten
extents
btrfs-progs: tests/convert: add test case for ext4 unwritten extents
common/fsfeatures.h | 3 +- convert/source-ext2.c | 116 ++++++++++++++++-- tests/common.convert | 44 ++----- tests/convert-tests/001-ext2-basic/test.sh | 2 +- tests/convert-tests/003-ext4-basic/test.sh | 2 +- .../005-delete-all-rollback/test.sh | 6 +- .../convert-tests/010-reiserfs-basic/test.sh | 2 +- .../011-reiserfs-delete-all-rollback/test.sh | 6 +- tests/convert-tests/024-ntfs-basic/test.sh | 2 +- .../025-ext4-uninit-written/test.sh | 53 ++++++++ 10 files changed, 177 insertions(+), 59 deletions(-) create mode 100755 tests/convert-tests/025-ext4-uninit-written/test.sh
--
2.45.0
PATCH 1/3 Revert "btrfs-progs: convert: add raid-stripe-tree to allowed features"
This reverts commit 346a3819237b319985ad6042d6302f67b040a803.
The RST feature (at least for now) is mostly for zoned devices to support extra data profiles.
Thus btrfs-convert is never designed to handle RST, because there is no way an ext4/reiserfs can even be created on a zoned device, or it would create the correct RST tree root at all
Revert this unsupported feature to prevent false alerts.
--- common/fsfeatures.h | 3 +- tests/common.convert | 44 ++++--------------- tests/convert-tests/001-ext2-basic/test.sh | 2 +- tests/convert-tests/003-ext4-basic/test.sh | 2 +- .../005-delete-all-rollback/test.sh | 6 +-- .../convert-tests/010-reiserfs-basic/test.sh | 2 +- .../011-reiserfs-delete-all-rollback/test.sh | 6 +-- tests/convert-tests/024-ntfs-basic/test.sh | 2 +- 8 files changed, 15 insertions(+), 52 deletions(-)
common/fsfeatures.h +1 -2
@@ -68,8 +68,7 @@ static const struct btrfs_mkfs_features btrfs_convert_allowed_features = {BTRFS_FEATURE_INCOMPAT_BIG_METADATA |BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF |BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA | -BTRFS_FEATURE_INCOMPAT_NO_HOLES | - BTRFS_FEATURE_INCOMPAT_RAID_STRIPE_TREE, + BTRFS_FEATURE_INCOMPAT_NO_HOLES, .runtime_flags = BTRFS_FEATURE_RUNTIME_QUOTA, };
tests/common.convert +8 -36
62 lines not on this page · raw message
tests/convert-tests/001-ext2-basic/test.sh +1 -1
@@ -12,7 +12,7 @@ check_kernel_support_acl # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices -for feature in '' 'block-group-tree' 'raid-stripe-tree'; do +for feature in '' 'block-group-tree' ; do convert_test ext2 "$feature" "ext2 4k nodesize" 4096 mke2fs -b 4096 convert_test ext2 "$feature" "ext2 16k nodesize" 16384 mke2fs -b 4096 convert_test ext2 "$feature" "ext2 64k nodesize" 65536 mke2fs -b 4096
tests/convert-tests/003-ext4-basic/test.sh +1 -1
@@ -12,7 +12,7 @@ check_kernel_support_acl # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices -for feature in '' 'block-group-tree' 'raid-stripe-tree' ; do +for feature in '' 'block-group-tree' ; do convert_test ext4 "$feature" "ext4 4k nodesize" 4096 mke2fs -t ext4 -b 4096 convert_test ext4 "$feature" "ext4 16k nodesize" 16384 mke2fs -t ext4 -b 4096 convert_test ext4 "$feature" "ext4 64k nodesize" 65536 mke2fs -t ext4 -b 4096
tests/convert-tests/005-delete-all-rollback/test.sh +1 -5
@@ -38,10 +38,6 @@ do_test() { convert_test_do_convert "$features" "$nodesize" - if ! convert_can_mount "$features"; then - return 0 - fi - run_check_mount_test_dev convert_test_post_check_checksums "$CHECKSUMTMP"
@@ -68,7 +64,7 @@ do_test() { # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices -for feature in '' 'block-group-tree' 'raid-stripe-tree' ; do +for feature in '' 'block-group-tree' ; do do_test "$feature" "ext4 4k nodesize" 4096 mke2fs -t ext4 -b 4096 do_test "$feature" "ext4 16k nodesize" 16384 mke2fs -t ext4 -b 4096 do_test "$feature" "ext4 64k nodesize" 65536 mke2fs -t ext4 -b 4096
tests/convert-tests/010-reiserfs-basic/test.sh +1 -1
@@ -15,7 +15,7 @@ prepare_test_dev # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices -for feature in '' 'block-group-tree' 'raid-stripe-tree'; do +for feature in '' 'block-group-tree' ; do convert_test reiserfs "$feature" "reiserfs 4k nodesize" 4096 mkreiserfs -b 4096 convert_test reiserfs "$feature" "reiserfs 16k nodesize" 16384 mkreiserfs -b 4096 convert_test reiserfs "$feature" "reiserfs 64k nodesize" 65536 mkreiserfs -b 4096
tests/convert-tests/011-reiserfs-delete-all-rollback/test.sh +1 -5
@@ -40,10 +40,6 @@ do_test() { convert_test_do_convert "$features" "$nodesize" - if ! convert_can_mount "$features"; then - return 0 - fi - run_check_mount_test_dev convert_test_post_check_checksums "$CHECKSUMTMP"
@@ -70,7 +66,7 @@ do_test() { # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices -for feature in '' 'block-group-tree' 'raid-stripe-tree'; do +for feature in '' 'block-group-tree' ; do do_test "$feature" "reiserfs 4k nodesize" 4096 mkreiserfs -b 4096 do_test "$feature" "reiserfs 16k nodesize" 16384 mkreiserfs -b 4096 do_test "$feature" "reiserfs 64k nodesize" 65536 mkreiserfs -b 4096
tests/convert-tests/024-ntfs-basic/test.sh +1 -1
@@ -17,6 +17,6 @@ prepare_test_dev # Iterate over defaults and options that are not tied to hardware capabilities # or number of devices. Test only 4K block size as minimum. -for feature in '' 'block-group-tree' 'raid-stripe-tree'; do +for feature in '' 'block-group-tree' ; do convert_test ntfs "$feature" "ntfs 4k nodesize" 4096 mkfs.ntfs -s 4096 done
Signature · 1 line
2.45.0
PATCH 2/3 btrfs-progs: convert: rework file extent iteration to handle unwritten extents
In reply to Qu Wenruo[BUG]
There is a bug report that btrfs-convert can not handle unwritten extents (EXT2_EXTENT_FLAGS_UNINIT set, which is pretty much the same as BTRFS_FILE_EXTENT_PREALLOC), which can cause the converted image to have incorrect contents.
[CAUSE]
Currently we use ext2fs_block_iterate2() to go through all data extents of an ext2 inode, but it doesn't provide the info on if the range is unwritten or not.
Thus for unwritten extents, the results btrfs would just treat it as regular extents, and read the contents from disk other than setting the contents to zero.
[FIX]
Instead of the ext2fs_block_iterate2(), here we follow the debugfs' "dump_extents" command, to use ext2fs_extent_*() helpers to go through every data extent of the inode, that's if the inode support the EXT4_EXTENTS_FL flag.
Now we can properly get the info of which extents are unwritten, and use holes to replace those unwritten extents.
--- convert/source-ext2.c | 116 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 109 insertions(+), 7 deletions(-)
convert/source-ext2.c +109 -7
@@ -303,6 +303,88 @@ static int ext2_block_iterate_proc(ext2_filsys fs, blk_t *blocknr,return 0 ; } +static int iterate_one_file_extent (struct blk_iterate_data *data, +u64 filepos,u64 len,u64 disk_bytenr, +bool prealloced) +{ +const int sectorsize = data->trans->fs_info->sectorsize; +const int sectorbits =ilog2 (sectorsize); +int ret; + +UASSERT (len >0 ); +for (int i =0 ; i < len; i += sectorsize) { +/* +* Just treat preallocated extent as hole. +* +* As there is no way to utilize the preallocated space, since +* any file extent would also be shared by ext2 image. +*/ +if (prealloced) + ret =block_iterate_proc (0 , + (filepos + i) >> sectorbits, data); +else + ret =block_iterate_proc ( + (disk_bytenr + i) >> sectorbits, + (filepos + i) >> sectorbits, data); + +if (ret <0 ) +return ret; + } +return 0 ; +} + +static int iterate_file_extents (struct blk_iterate_data *data, +ext2_filsys ext2fs,ext2_ino_t ext2_ino, +u32 convert_flags) +{ +ext2_extent_handle_t handle =NULL ; +struct ext2fs_extent extent; +const int sectorsize = data->trans->fs_info->sectorsize; +const int sectorbits =ilog2 (sectorsize); +int op =EXT2_EXTENT_ROOT ; +errcode_t errcode; +int ret =0 ; + + errcode =ext2fs_extent_open (ext2fs, ext2_ino, &handle); +if (errcode) { +error ("failed to open ext2 inode %u: %s" , ext2_ino, +error_message (errcode)); +return -EIO ; + } +while (1 ) { +u64 disk_bytenr; +u64 filepos; +u64 len; + + errcode =ext2fs_extent_get (handle, op, &extent); +if (errcode ==EXT2_ET_EXTENT_NO_NEXT ) +break ; +if (errcode) { + data->errcode = errcode; + ret = -EIO ; + goto out; + } + op =EXT2_EXTENT_NEXT ; + +if (extent.e_flags &EXT2_EXTENT_FLAGS_SECOND_VISIT ) +continue ; +if (!(extent.e_flags &EXT2_EXTENT_FLAGS_LEAF )) +continue ; + + filepos = extent.e_lblk << sectorbits; + len = extent.e_len << sectorbits; + disk_bytenr = extent.e_pblk << sectorbits; + + ret =iterate_one_file_extent (data, filepos, len, disk_bytenr, + extent.e_flags &EXT2_EXTENT_FLAGS_UNINIT ); +if (ret <0 ) + goto out; + } +out: +ext2fs_extent_free (handle); +return ret; +} +/* * traverse file's data blocks, record these data blocks as file extents. */
@@ -315,6 +397,7 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,int ret;char *buffer =NULL ;errcode_t err; +struct ext2_inode ext2_inode = {0 };u32 last_block;u32 sectorsize = root->fs_info->sectorsize;u64 inode_size =btrfs_stack_inode_size (btrfs_inode);
@@ -323,10 +406,32 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans,init_blk_iterate_data (&data, trans, root, btrfs_inode, objectid, convert_flags &CONVERT_FLAG_DATACSUM ); - err =ext2fs_block_iterate2 (ext2_fs, ext2_ino,BLOCK_FLAG_DATA_ONLY , -NULL , ext2_block_iterate_proc, &data); -if (err) - goto error; + err =ext2fs_read_inode (ext2_fs, ext2_ino, &ext2_inode); +if (err) { +error ("failed to read ext2 inode %u: %s" , + ext2_ino,error_message (err)); +return -EIO ; + } +/* +* For inodes without extent block maps, go with the older +* ext2fs_block_iterate2(). +* Otherwise use ext2fs_extent_*() based solution, as that can provide +* UNINIT extent flags. +*/ +if ((ext2_inode.i_flags &EXT4_EXTENTS_FL ) ==0 ) { + err =ext2fs_block_iterate2 (ext2_fs, ext2_ino, +BLOCK_FLAG_DATA_ONLY ,NULL , + ext2_block_iterate_proc, &data); +if (err) { +error ("ext2fs_block_iterate2: %s" ,error_message (err)); +return -EIO ; + } + }else { + ret =iterate_file_extents (&data, ext2_fs, ext2_ino, + convert_flags); +if (ret <0 ) + goto fail; + } ret = data.errcode;if (ret) goto fail;
@@ -366,9 +471,6 @@ static int ext2_create_file_extents(struct btrfs_trans_handle *trans, fail:free (buffer);return ret; -error: -error ("ext2fs_block_iterate2: %s" ,error_message (err)); -return -1 ; } static int ext2_create_symlink(struct btrfs_trans_handle *trans,
Signature · 1 line
2.45.0
Re: [PATCH 2/3] btrfs-progs: convert: rework file extent iteration to handle unwritten extents
Converted both, the small and the big 24G, images properly - no failed file checksums anymore.
Thanks, Yordan.
PATCH 3/3 btrfs-progs: tests/convert: add test case for ext4 unwritten extents
In reply to Qu WenruoThe test case would verify the behaivor of ext4 unwritten extents by:
- Create a unwritten (preallocated) extent on ext4
- Fill the on-disk extent with random garbage
This is to make sure if btrfs tries to read the on-disk data, it would definitely get some garbage.
As I found sometimes mkfs.ext4 can fill the unused bg with zeros.
- Fill the preallocated file range with some data
This is to make sure btrfs-convert can handle mixed written and unwritten ranges.
- Save the checksum of the file.
- Convert the fs
- verify the checksum
For older btrfs-convert, there would be only one regular file extent, and reading the file would read out some garbage and cause checksum to mismatch.
For the fixed btrfs-convert, we punch holes for unwritten extents, thus only the written part would be read out and match the checksum.
--- .../025-ext4-uninit-written/test.sh | 53 +++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100755 tests/convert-tests/025-ext4-uninit-written/test.sh
tests/convert-tests/025-ext4-uninit-written/test.sh new file +53 -0
@@ -0,0 +1,53 @@ +#!/bin/bash +# Make sure btrfs is handling the ext4 uninit (preallocated) extent correctly + +source "$TEST_TOP/common" || exit +source "$TEST_TOP/common.convert" || exit + +setup_root_helper +prepare_test_dev 1G + +check_global_prereq mkfs.ext4 +check_global_prereq fallocate +check_global_prereq filefrag +check_global_prereq awk +check_global_prereq md5sum +check_prereq btrfs-convert +check_prereq btrfs + +convert_test_prep_fs ext4 mke2fs -t ext4 -b 4096 + +# Create a preallocated extent first. +run_check $SUDO_HELPER fallocate -l 32K "$TEST_MNT/file" +sync +# Get the real on-disk location and write some data into it. +physical=$(run_check_stdout $SUDO_HELPER filefrag -v "$TEST_MNT/file" | grep unwritten | awk '{print $4}' | grep -o "[[:digit:]]*") + +if [ -z "$physical" ]; then + _fail "unable to get the physical address of the file" +fi + +# Now fill the underlying range with non-zeros. +# For properly converted fs, we should not read the contents anyway +run_check $SUDO_HELPER dd if=/dev/urandom of=$TEST_DEV bs=4096 seek="$physical" conv=notrunc count=8 + +# Write some thing into the file range. +run_check $SUDO_HELPER dd if=/dev/zero of="$TEST_MNT/file" bs=4096 count=1 conv=notrunc +run_check $SUDO_HELPER dd if=/dev/zero of="$TEST_MNT/file" bs=4096 count=1 seek=3 conv=notrunc +sync +md5_before=$(md5sum "$TEST_MNT/file" | cut -f1 -d' ') +_log "md5sum before convert: $md5_before" +run_check_umount_test_dev + +# Btrfs-convert should handle the unwritten part correctly, either punching a hole +# or a proper preallocated extent, so that we won't read the on-disk data. +convert_test_do_convert + +run_check_mount_test_dev +md5_after=$(md5sum "$TEST_MNT/file" | cut -f1 -d' ') +_log "md5sum after convert: $md5_after" +run_check_umount_test_dev + +if [ "$md5_before" != "$md5_after" ]; then + _fail "contents mismatch" +fi
Signature · 1 line
2.45.0
Quoted 30 lines · Qu Wenruo
[REPO]
https://github.com/adam900710/btrfs-progs/tree/unwritten_extentThere is a bug report that ext4 unwritten extents (extent with
EXT2_EXTENT_FLAGS_UNINIT, acts the same asBTRFS_FILE_EXTENT_PREALLOC) would result a regular btrfs file extent.Instead of filling the range with zero, converted btrfs would read whatever from the disk, causing corruption.
Although there are some attempts trying to fix the problem, the resulted patches are not meeting our standard, so I have to come up a fix by myself.
The root cause is that,
ext2fs_block_iterate2()won't report any extent info, thus it's more or less only useful for ext2 filesystems. For ext4 filesystems, inodes can have a feature calledEXT4_EXTENTS_FL, allowing a proper extent based iteratioin.So this patch would keep the old
ext2fs_block_iterate2()as fallback (as for older ext2 fses, they do not support fallocate anyway), while for newer ext4 fses, go with ect2fs_extent_*() APIs to iterate the file extents.The new APIs provides the extra extent.e_flags to indicate whether the extent is unwritten or not.
For unwritten extents, we just puch it as a hole for now, since even if we create a correct preallocated file extent, the space can not be utlized as it's shared between the file extent and ext2 image.
Quoted 8 lines
So just punching a hole would be the simplest workaround for now.
Qu Wenruo (3):
Revert "btrfs-progs: convert: add raid-stripe-tree to allowed
features"
btrfs-progs: convert: rework file extent iteration to handle unwritten
extents
btrfs-progs: tests/convert: add test case for ext4 unwritten extents
Added to devel, thanks.