* [PATCH 0/2] btrfs-progs: Intelligent item offset/size bit flip detector for dump-tree
@ 2019-04-12 9:05 Qu Wenruo
2019-04-12 9:05 ` [PATCH 1/2] btrfs-progs: dump-tree: Do simple bit flip check and continue if we can handle it Qu Wenruo
2019-04-12 9:05 ` [PATCH 2/2] btrfs-progs: misc-tests: Test if dump-tree can handle obviously flipped bit in btrfs item Qu Wenruo
0 siblings, 2 replies; 3+ messages in thread
From: Qu Wenruo @ 2019-04-12 9:05 UTC (permalink / raw)
To: linux-btrfs
This will make dump-tree less dumb when it gets some item offset/size
bit flip.
The output example can be found in the first patch, and the 2nd patch is
the test case to ensure it works as expected.
The design goal is to make debugging a little easier, I don't think
bit flip handler should be fixed in btrfs-progs directly, as the
complexity isn't worthy.
We should ensure it's not btrfs or some other strange kernel module
modifying eb memory in the first place.
So only dump-tree supports item size/offset bit flip detection, just to
make debugging a little easier.
Qu Wenruo (2):
btrfs-progs: dump-tree: Do simple bit flip check and continue if we
can handle it
btrfs-progs: misc-tests: Test if dump-tree can handle obviously
flipped bit in btrfs item
print-tree.c | 100 ++++++++++++++----
.../misc-tests/036-dump-tree-bit-flip/test.sh | 21 ++++
.../two_corrupted_items.raw.xz | Bin 0 -> 22024 bytes
3 files changed, 102 insertions(+), 19 deletions(-)
create mode 100755 tests/misc-tests/036-dump-tree-bit-flip/test.sh
create mode 100644 tests/misc-tests/036-dump-tree-bit-flip/two_corrupted_items.raw.xz
--
2.21.0
^ permalink raw reply [flat|nested] 3+ messages in thread* [PATCH 1/2] btrfs-progs: dump-tree: Do simple bit flip check and continue if we can handle it 2019-04-12 9:05 [PATCH 0/2] btrfs-progs: Intelligent item offset/size bit flip detector for dump-tree Qu Wenruo @ 2019-04-12 9:05 ` Qu Wenruo 2019-04-12 9:05 ` [PATCH 2/2] btrfs-progs: misc-tests: Test if dump-tree can handle obviously flipped bit in btrfs item Qu Wenruo 1 sibling, 0 replies; 3+ messages in thread From: Qu Wenruo @ 2019-04-12 9:05 UTC (permalink / raw) To: linux-btrfs We have quite some users reporting bit flips, despite the cause, we still need to figure out if it's a bit flip manually. Let's make dump-tree clever enough to handle at least item offset/size bit flip by itself. This is done by manually checking if there is single bit out of the node size range. If there is a bit flipped and after fix it passes regular item size/offset check, then we manually use the corrected item offset/size in the printing routine. Before this patch, dump-tree will just skip all remaining items like: fs tree key (FS_TREE ROOT_ITEM 0) leaf 30572544 items 11 free space 15293 generation 6 owner FS_TREE leaf 30572544 flags 0x1(WRITTEN) backref revision 1 fs uuid d547b94d-7372-4739-a2bb-076906aa1d12 chunk uuid aceea146-a2fc-450c-9aa9-e0e82323641a item 0 key (256 INODE_ITEM 0) itemoff 16123 itemsize 160 generation 3 transid 6 size 20 nbytes 16384 block group 0 mode 40755 links 1 uid 0 gid 0 rdev 0 sequence 2 flags 0x0(none) atime 1555057503.953957270 (2019-04-12 16:25:03) ctime 1555057509.900560077 (2019-04-12 16:25:09) mtime 1555057509.900560077 (2019-04-12 16:25:09) otime 1555057483.0 (2019-04-12 16:24:43) item 1 key (256 INODE_REF 256) itemoff 16111 itemsize 12 index 0 namelen 2 name: .. ERROR: leaf 30572544 slot 2 pointer invalid, offset 48844 size 35 leaf data limit 16283 ERROR: skip remaining slots While after this patch, it will mark the corrupted item and still output the correct content, although with some stderr output: incorrect offsets 16111 48879 incorrect offsets 16111 48879 incorrect offsets 16111 48879 fs tree key (FS_TREE ROOT_ITEM 0) leaf 30572544 items 11 free space 15293 generation 6 owner FS_TREE leaf 30572544 flags 0x1(WRITTEN) backref revision 1 fs uuid d547b94d-7372-4739-a2bb-076906aa1d12 chunk uuid aceea146-a2fc-450c-9aa9-e0e82323641a item 0 key (256 INODE_ITEM 0) itemoff 16123 itemsize 160 generation 3 transid 6 size 20 nbytes 16384 block group 0 mode 40755 links 1 uid 0 gid 0 rdev 0 sequence 2 flags 0x0(none) atime 1555057503.953957270 (2019-04-12 16:25:03) ctime 1555057509.900560077 (2019-04-12 16:25:09) mtime 1555057509.900560077 (2019-04-12 16:25:09) otime 1555057483.0 (2019-04-12 16:24:43) item 1 key (256 INODE_REF 256) itemoff 16111 itemsize 12 index 0 namelen 2 name: .. !!! item 2 key (256 DIR_ITEM 3846364860) itemoff 16076 (original: 48844) itemsize 35 (original: 35) location key (258 INODE_ITEM 0) type FILE transid 6 data_len 0 name_len 5 name: file2 item 3 key (256 DIR_ITEM 4128386376) itemoff 16041 itemsize 35 location key (257 INODE_ITEM 0) type FILE transid 6 data_len 0 name_len 5 name: file1 !!! item 4 key (256 DIR_INDEX 2) itemoff 16006 (original: 16006) itemsize 35 (original: 65571) location key (257 INODE_ITEM 0) type FILE transid 6 data_len 0 name_len 5 name: file1 <snip> item 10 key (258 INODE_REF 256) itemoff 15568 itemsize 15 index 3 namelen 5 name: file2 The "!!!" is used to indicate the problem, and both original and corrected item offset size will be outputted. Signed-off-by: Qu Wenruo <wqu@suse.com> --- print-tree.c | 100 +++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 81 insertions(+), 19 deletions(-) diff --git a/print-tree.c b/print-tree.c index ab77463706c1..e88b3934dcf9 100644 --- a/print-tree.c +++ b/print-tree.c @@ -417,7 +417,8 @@ void print_extent_item(struct extent_buffer *eb, int slot, int metadata) unsigned long end; unsigned long ptr; int type; - u32 item_size = btrfs_item_size_nr(eb, slot); + u32 item_size = btrfs_item_size_nr(eb, slot) & + (eb->fs_info->nodesize - 1); u64 flags; u64 offset; char flags_str[32] = {0}; @@ -583,7 +584,7 @@ static void print_root_item(struct extent_buffer *leaf, int slot) struct btrfs_key drop_key; ri = btrfs_item_ptr(leaf, slot, struct btrfs_root_item); - len = btrfs_item_size_nr(leaf, slot); + len = btrfs_item_size_nr(leaf, slot) & (leaf->fs_info->nodesize - 1); memset(&root_item, 0, sizeof(root_item)); read_extent_buffer(leaf, &root_item, (unsigned long)ri, len); @@ -1184,6 +1185,51 @@ static void header_flags_to_str(u64 flags, char *ret) } } +static bool __is_valid_item_ptr(struct btrfs_fs_info *fs_info, u32 item_offset, + u32 item_size) +{ + u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info); + + /* Item pointer must be inside the leaf */ + return !(item_offset > leaf_data_size || item_offset + item_size + > leaf_data_size); +} + +static bool is_valid_item(struct extent_buffer *leaf, int slot) +{ + return __is_valid_item_ptr(leaf->fs_info, + btrfs_item_offset_nr(leaf, slot), + btrfs_item_size_nr(leaf, slot)); +} + +static bool is_bit_flipped(struct extent_buffer *leaf, int slot) +{ + u32 nodesize_mask = leaf->fs_info->nodesize - 1; + u32 item_offset = btrfs_item_offset_nr(leaf, slot); + u32 item_size = btrfs_item_size_nr(leaf, slot); + + ASSERT(is_power_of_2(leaf->fs_info->nodesize)); + /* Bit flip should only happen once */ + if (is_power_of_2(item_offset & ~nodesize_mask) && + (item_size & ~nodesize_mask) == 0 && + __is_valid_item_ptr(leaf->fs_info, item_offset & nodesize_mask, + item_size)) + return true; + if (is_power_of_2(item_size & ~nodesize_mask) && + (item_offset & ~nodesize_mask) == 0 && + __is_valid_item_ptr(leaf->fs_info, item_offset, + item_size & nodesize_mask)) + return true; + return false; +} + +static void *btrfs_item_safe_ptr(struct extent_buffer *leaf, int slot) +{ + return (void *)(btrfs_leaf_data(leaf) + + (btrfs_item_offset_nr(leaf, slot) & + (leaf->fs_info->nodesize - 1))); +} + void btrfs_print_leaf(struct extent_buffer *eb) { struct btrfs_fs_info *fs_info = eb->fs_info; @@ -1193,6 +1239,7 @@ void btrfs_print_leaf(struct extent_buffer *eb) u32 leaf_data_size = BTRFS_LEAF_DATA_SIZE(fs_info); u32 i; u32 nr; + u32 nodesize_mask = fs_info->nodesize - 1; u64 flags; u8 backref_rev; @@ -1213,6 +1260,7 @@ void btrfs_print_leaf(struct extent_buffer *eb) fflush(stdout); for (i = 0; i < nr; i++) { + bool bit_flip = false; u32 item_size; void *ptr; u64 objectid; @@ -1225,32 +1273,46 @@ void btrfs_print_leaf(struct extent_buffer *eb) * Only need to ensure all pointers are pointing range inside * the leaf, thus no segfault. */ - if (btrfs_item_offset_nr(eb, i) > leaf_data_size || - btrfs_item_size_nr(eb, i) + btrfs_item_offset_nr(eb, i) > - leaf_data_size) { - error( + if (!is_valid_item(eb, i)) { + if (is_bit_flipped(eb, i)) { + bit_flip = true; + } else { + error( "leaf %llu slot %u pointer invalid, offset %u size %u leaf data limit %u", - btrfs_header_bytenr(eb), i, - btrfs_item_offset_nr(eb, i), - btrfs_item_size_nr(eb, i), leaf_data_size); - error("skip remaining slots"); - break; + btrfs_header_bytenr(eb), i, + btrfs_item_offset_nr(eb, i), + btrfs_item_size_nr(eb, i), + leaf_data_size); + error("skip remaining slots"); + break; + } } item = btrfs_item_nr(i); - item_size = btrfs_item_size(eb, item); + item_size = btrfs_item_size(eb, item) & nodesize_mask; /* Untyped extraction of slot from btrfs_item_ptr */ - ptr = btrfs_item_ptr(eb, i, void*); + ptr = btrfs_item_safe_ptr(eb, i); btrfs_item_key(eb, &disk_key, i); objectid = btrfs_disk_key_objectid(&disk_key); type = btrfs_disk_key_type(&disk_key); offset = btrfs_disk_key_offset(&disk_key); - printf("\titem %d ", i); + if (bit_flip) + printf("!!!\titem %d ", i); + else + printf("\titem %d ", i); btrfs_print_key(&disk_key); - printf(" itemoff %d itemsize %d\n", - btrfs_item_offset(eb, item), - btrfs_item_size(eb, item)); + if (bit_flip) + printf( + " itemoff %d (original: %d) itemsize %d (original: %d)\n", + btrfs_item_offset(eb, item) & nodesize_mask, + btrfs_item_offset(eb, item), + btrfs_item_size(eb, item) & nodesize_mask, + btrfs_item_size(eb, item)); + else + printf(" itemoff %d itemsize %d\n", + btrfs_item_offset(eb, item), + btrfs_item_size(eb, item)); if (type == 0 && objectid == BTRFS_FREE_SPACE_OBJECTID) print_free_space_header(eb, i); @@ -1360,8 +1422,8 @@ void btrfs_print_leaf(struct extent_buffer *eb) break; case BTRFS_UUID_KEY_SUBVOL: case BTRFS_UUID_KEY_RECEIVED_SUBVOL: - print_uuid_item(eb, btrfs_item_ptr_offset(eb, i), - btrfs_item_size_nr(eb, i)); + print_uuid_item(eb, btrfs_item_ptr_offset(eb, i) & + nodesize_mask, item_size); break; case BTRFS_STRING_ITEM_KEY: { const char *str = eb->data + btrfs_item_ptr_offset(eb, i); -- 2.21.0 ^ permalink raw reply related [flat|nested] 3+ messages in thread
* [PATCH 2/2] btrfs-progs: misc-tests: Test if dump-tree can handle obviously flipped bit in btrfs item 2019-04-12 9:05 [PATCH 0/2] btrfs-progs: Intelligent item offset/size bit flip detector for dump-tree Qu Wenruo 2019-04-12 9:05 ` [PATCH 1/2] btrfs-progs: dump-tree: Do simple bit flip check and continue if we can handle it Qu Wenruo @ 2019-04-12 9:05 ` Qu Wenruo 1 sibling, 0 replies; 3+ messages in thread From: Qu Wenruo @ 2019-04-12 9:05 UTC (permalink / raw) To: linux-btrfs The crafted image has one bit flipped for one item offset and one item size. The test will check if dump-tree can handle it by: - Detect the bit flip - Output the correct content for the remaining items Signed-off-by: Qu Wenruo <wqu@suse.com> --- .../misc-tests/036-dump-tree-bit-flip/test.sh | 21 ++++++++++++++++++ .../two_corrupted_items.raw.xz | Bin 0 -> 22024 bytes 2 files changed, 21 insertions(+) create mode 100755 tests/misc-tests/036-dump-tree-bit-flip/test.sh create mode 100644 tests/misc-tests/036-dump-tree-bit-flip/two_corrupted_items.raw.xz diff --git a/tests/misc-tests/036-dump-tree-bit-flip/test.sh b/tests/misc-tests/036-dump-tree-bit-flip/test.sh new file mode 100755 index 000000000000..f3f65c435e58 --- /dev/null +++ b/tests/misc-tests/036-dump-tree-bit-flip/test.sh @@ -0,0 +1,21 @@ +#!/bin/bash +# Test if btrfs ins dump-tree can handle certain bit flip case and output +# enough info for both the good and bad items + +source "$TEST_TOP/common" + +check_prereq btrfs + +tmp_output=$(mktemp --tmpdir btrfs-progs-test-dump-tree-output.XXXXXX) + +check_image() { + run_check_stdout "$TOP/btrfs" ins dump-tree -t 5 "$1" \ + 2>&1 > "$tmp_output" + if [ $(grep '\!\!\!' "$tmp_output" | wc -l ) -ne 2 ]; then + rm "$tmp_output" -rf + _fail "bit flipped item not detected" + fi + rm "$tmp_output" -rf +} + +check_all_images diff --git a/tests/misc-tests/036-dump-tree-bit-flip/two_corrupted_items.raw.xz b/tests/misc-tests/036-dump-tree-bit-flip/two_corrupted_items.raw.xz new file mode 100644 index 0000000000000000000000000000000000000000..6487657f81f3c3d4dca002372011f1cc1cc26f57 GIT binary patch literal 22024 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 H*xce@+_+3p literal 0 HcmV?d00001 -- 2.21.0 ^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2019-04-12 9:05 UTC | newest] Thread overview: 3+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2019-04-12 9:05 [PATCH 0/2] btrfs-progs: Intelligent item offset/size bit flip detector for dump-tree Qu Wenruo 2019-04-12 9:05 ` [PATCH 1/2] btrfs-progs: dump-tree: Do simple bit flip check and continue if we can handle it Qu Wenruo 2019-04-12 9:05 ` [PATCH 2/2] btrfs-progs: misc-tests: Test if dump-tree can handle obviously flipped bit in btrfs item Qu Wenruo
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox; as well as URLs for NNTP newsgroup(s).