[PATCH v3 00/12] lowmem mode fixes

[PATCH v3 00/12] lowmem mode fixes

[Qu Wenruo]

Patches can be fetch from github:
https://github.com/adam900710/btrfs-progs/tree/lowmem_fixes

Thanks for reports from Chris Murphy and Christoph Anton Mitterer,
several new bugs are exposed for lowmem mode fsck.

Special thank to Christoph, who did rounds of test during the patch
development.

The following bugs are fixed in lowmem mode:

1) Block group used space false alert
   If a BLOCK_GROUP_ITEM or its first EXTENT/METADATA_ITEM is located at
   the first slot of a leaf, search_slot() used by lowmem mode can
   point to previous leaf, with path->slots[0] beyond valid leaf slots.

   This makes us to read out uninitialized data, and can abort block
   group used space check loop, causing a false alert.

   Fix it with a test case image inside fsck-tests/020/extent-ref-cases
   Also fix all possible backward search.
   Reported by Christoph.

2) Partly written prealloc extent false alert
   If a prealloc extent gets partily written, lowmem mode will report
   prealloc extent shouldn't have csum.

   Lowmem mode passed wrong variable to csum checking code, causing it
   to check the whole range of the prealloc extent, making the bug
   happens.

   Fix it with a test case inside fsck-tests/020/extent-ref-cases.
   Reported by Chirs Murphy And Christoph.

3) Extent item size false alert.
   Under certain case, btrfs lowmem mode check reports data backref
   lost.
   It's because newly introduced extent item size check aborts normal
   check routine.

   It can happen if a data/metadata extent item has no inline ref.

   Fix it, test case already submitted before and merged, but due to
   fsck-tests framework bugs, it never get called for lowmem mode.

4) Compressed inline data extent
   The extra check on inline data extent length doesn't take compression
   into consideration and will cause false alert without outputting any
   error message.

   Fix it and add correct error message output for it.
   Also fix all possible silent error.
   Reported by Christoph.

5) fsck-tests Lowmem mode override fixes
   Allow lowmem mode override to get called for all tests, and allow
   them all to pass lowmem mode except fsck-tests/006, which is a
   original repair mode bug.


changelog:
  v2:
    More generic forward search bug fix, not restricted to block group
    item.
    Compressed inline extent false alert fix.
    Lowmem fsck-test enhance, to allow it really work.
    Fix walk_down_tree_v2() to continue after non-fatal errors detected
  v3:
    Update the last patch to make it works better for incoming lowmem
    mode repair patchset.

Lu Fengqi (1):
  btrfs-progs: fsck: Fix lowmem mode override to allow it skip repair
    work

Qu Wenruo (10):
  btrfs-progs: lowmem check: Fix several bugs related to afterward
    search
  btrfs-progs: check: Output verbose error when fsck found a bug in any
    tree
  btrfs-progs: lowmem check: Fix false alert in checking data extent
    csums
  btrfs-progs: lowmem check: Fix extent item size false alert
  btrfs-progs: lowmem check: Fix false alert on inline compressed extent
  btrfs-progs: lowmem check: Fix silent error if first inode item
    missing
  btrfs-progs: tests: Move fsck-tests/015 to fuzz tests
  btrfs-progs: fsck-test: Add test image for lowmem mode block group
    false alert
  btrfs-progs: fsck-test: Make 013 compatible with lowmem mode
  btrfs-progs: fsck-test: Add new test case for file extent false alerts

Su Yue (1):
  btrfs-progs: cmds-check.c: walk_down_tree_v2 break cause of leaf
    process

 cmds-check.c                                       | 175 +++++++++++++++------
 tests/common                                       |   8 +-
 tests/common.local                                 |   2 +-
 tests/fsck-tests/013-extent-tree-rebuild/test.sh   |   2 +-
 .../block_group_item_false_alert.raw.xz            | Bin 0 -> 47792 bytes
 tests/fsck-tests/020-extent-ref-cases/test.sh      |  15 +-
 tests/fsck-tests/025-file-extents/test.sh          |  42 +++++
 .../images}/bko-97171-btrfs-image.raw.txt          |   0
 .../images}/bko-97171-btrfs-image.raw.xz           | Bin
 9 files changed, 190 insertions(+), 54 deletions(-)
 create mode 100644 tests/fsck-tests/020-extent-ref-cases/block_group_item_false_alert.raw.xz
 create mode 100755 tests/fsck-tests/025-file-extents/test.sh
 rename tests/{fsck-tests/015-check-bad-memory-access => fuzz-tests/images}/bko-97171-btrfs-image.raw.txt (100%)
 rename tests/{fsck-tests/015-check-bad-memory-access => fuzz-tests/images}/bko-97171-btrfs-image.raw.xz (100%)

-- 
2.11.1

[PATCH v3 01/12] btrfs-progs: lowmem check: Fix several bugs related to afterward search

[Qu Wenruo]

Since btrfs_search_slot() can points to the slot which is beyond the
leaves' capacity, we should pay extra attention when doing afterward
search.

While for lowmem check, several places uses afterward search:
1) Block group item used space check
2) Device item used space check
3) Data extent backref check.

In the following case for block group item check, btrfs lowmem mode
check will skip the block group and report false alert:

leaf 29405184 items 37 free space 1273 generation 11 owner 2
...
        item 36 key (77594624 EXTENT_ITEM 2097152)
                extent refs 1 gen 8 flags DATA
                extent data backref root 5 objectid 265 offset 0 count 1
leaf 29409280 items 43 free space 670 generation 11 owner 2
        item 0 key (96468992 EXTENT_ITEM 2097152)
                extent refs 1 gen 8 flags DATA
                extent data backref root 5 objectid 274 offset 0 count 1
        item 1 key (96468992 BLOCK_GROUP_ITEM 33554432)
                block group used 2265088 chunk_objectid 256 flags DATA

When checking block group item, we will search key(96468992 0 0) to
start from the first item in the block group.

While search_slot() will point to leaf 29405184, slot 37 which is beyond
leaf capacity.

And when reading key from slot 37, uninitialized data can be read out
and cause us to exit block group item check, leading to false alert.

Fix it by checking path.slot[0] before reading out the key.

Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Reported-by: Chris Murphy <chris@colorremedies.com>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/cmds-check.c b/cmds-check.c
index 37e5ff18..699753fb 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -10591,6 +10591,8 @@ static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
 		leaf = path.nodes[0];
 		slot = path.slots[0];
 
+		if (slot >= btrfs_header_nritems(leaf))
+			goto next;
 		btrfs_item_key_to_cpu(leaf, &key, slot);
 		if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
 			break;
@@ -10606,6 +10608,7 @@ static int check_extent_data_backref(struct btrfs_fs_info *fs_info,
 		    offset)
 			found_count++;
 
+next:
 		ret = btrfs_next_item(root, &path);
 		if (ret)
 			break;
@@ -10878,8 +10881,10 @@ static int check_dev_item(struct btrfs_fs_info *fs_info,
 
 	/* Iterate dev_extents to calculate the used space of a device */
 	while (1) {
-		btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
+		if (path.slots[0] >= btrfs_header_nritems(path.nodes[0]))
+			goto next;
 
+		btrfs_item_key_to_cpu(path.nodes[0], &key, path.slots[0]);
 		if (key.objectid > dev_id)
 			break;
 		if (key.type != BTRFS_DEV_EXTENT_KEY || key.objectid != dev_id)
@@ -10976,6 +10981,11 @@ static int check_block_group_item(struct btrfs_fs_info *fs_info,
 	/* Iterate extent tree to account used space */
 	while (1) {
 		leaf = path.nodes[0];
+
+		/* Search slot can point to the last item beyond leaf nritems */
+		if (path.slots[0] >= btrfs_header_nritems(leaf))
+			goto next;
+
 		btrfs_item_key_to_cpu(leaf, &extent_key, path.slots[0]);
 		if (extent_key.objectid >= bg_key.objectid + bg_key.offset)
 			break;
-- 
2.11.1

[PATCH v3 02/12] btrfs-progs: check: Output verbose error when fsck found a bug in any tree

[Qu Wenruo]

Although we output error like "errors found in extent allocation tree or
chunk allocation", but we lacks such output for other trees, but leaving
the final "found error is %d" to catch the last return value(and
sometime it's cleared)

This patch adds extra error message for top level error path, and modify
the last "found error is %d" to "error(s) found" or "no error found".

Cc: Christoph Anton Mitterer <calestyo@scientia.net>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 43 +++++++++++++++++++++++++++++++++----------
 1 file changed, 33 insertions(+), 10 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index 699753fb..107359f8 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -12933,8 +12933,10 @@ int cmd_check(int argc, char **argv)
 
 	ret = repair_root_items(info);
 	err |= !!ret;
-	if (ret < 0)
+	if (ret < 0) {
+		error("failed to repair root items: %s", strerror(-ret));
 		goto close_out;
+	}
 	if (repair) {
 		fprintf(stderr, "Fixed %d roots.\n", ret);
 		ret = 0;
@@ -12957,8 +12959,13 @@ int cmd_check(int argc, char **argv)
 	}
 	ret = check_space_cache(root);
 	err |= !!ret;
-	if (ret)
+	if (ret) {
+		if (btrfs_fs_compat_ro(info, FREE_SPACE_TREE))
+			error("errors found in free space tree");
+		else
+			error("errors found in free space cache");
 		goto out;
+	}
 
 	/*
 	 * We used to have to have these hole extents in between our real
@@ -12974,22 +12981,28 @@ int cmd_check(int argc, char **argv)
 	else
 		ret = check_fs_roots(root, &root_cache);
 	err |= !!ret;
-	if (ret)
+	if (ret) {
+		error("errors found in fs roots");
 		goto out;
+	}
 
 	fprintf(stderr, "checking csums\n");
 	ret = check_csums(root);
 	err |= !!ret;
-	if (ret)
+	if (ret) {
+		error("errors found in csum tree");
 		goto out;
+	}
 
 	fprintf(stderr, "checking root refs\n");
 	/* For low memory mode, check_fs_roots_v2 handles root refs */
 	if (check_mode != CHECK_MODE_LOWMEM) {
 		ret = check_root_refs(root, &root_cache);
 		err |= !!ret;
-		if (ret)
+		if (ret) {
+			error("errors found in root refs");
 			goto out;
+		}
 	}
 
 	while (repair && !list_empty(&root->fs_info->recow_ebs)) {
@@ -13000,8 +13013,10 @@ int cmd_check(int argc, char **argv)
 		list_del_init(&eb->recow);
 		ret = recow_extent_buffer(root, eb);
 		err |= !!ret;
-		if (ret)
+		if (ret) {
+			error("fails to fix transid errors");
 			break;
+		}
 	}
 
 	while (!list_empty(&delete_items)) {
@@ -13020,13 +13035,17 @@ int cmd_check(int argc, char **argv)
 		fprintf(stderr, "checking quota groups\n");
 		ret = qgroup_verify_all(info);
 		err |= !!ret;
-		if (ret)
+		if (ret) {
+			error("failed to check quota groups");
 			goto out;
+		}
 		report_qgroups(0);
 		ret = repair_qgroups(info, &qgroups_repaired);
 		err |= !!ret;
-		if (err)
+		if (err) {
+			error("failed to repair quota groups");
 			goto out;
+		}
 		ret = 0;
 	}
 
@@ -13047,8 +13066,12 @@ out:
 		       "backup data and re-format the FS. *\n\n");
 		err |= 1;
 	}
-	printf("found %llu bytes used err is %d\n",
-	       (unsigned long long)bytes_used, ret);
+	printf("found %llu bytes used, ",
+	       (unsigned long long)bytes_used);
+	if (err)
+		printf("error(s) found\n");
+	else
+		printf("no error found\n");
 	printf("total csum bytes: %llu\n",(unsigned long long)total_csum_bytes);
 	printf("total tree bytes: %llu\n",
 	       (unsigned long long)total_btree_bytes);
-- 
2.11.1

[PATCH v3 03/12] btrfs-progs: lowmem check: Fix false alert in checking data extent csums

[Qu Wenruo]

Btrfs lowmem check can report false csum error like:
ERROR: root 5 EXTENT_DATA[257 0] datasum missing
ERROR: root 5 EXTENT_DATA[257 4096] prealloc shouldn't have datasum

This is because lowmem check code always compare the found csum size
with the whole extent which data extents points to.

Normally it's OK, but when prealloc extent is written, or reflink is
done, data extent can points to part of a larger extent, making the csum
check wrong.

To fix it, the csum check part is modified to handle plain and
compressed extents in different ways:

1) Plain extent
   Only search csums for the range it refers to.
   So the search range is from (disk_bytenr + extent_offset) and search
   length is (extent_num_bytes)

2) Compressed extent
   Search the whole extent.
   Search range is from (disk_bytner) and search length is
   (disk_num_bytes)

Reported-by: Chris Murphy <chris@colorremedies.com>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 47 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 36 insertions(+), 11 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index 107359f8..e99e3c36 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -4703,9 +4703,13 @@ static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
 	u64 disk_bytenr;
 	u64 disk_num_bytes;
 	u64 extent_num_bytes;
-	u64 found;
+	u64 extent_offset;
+	u64 csum_found;		/* In byte size, sectorsize aligned */
+	u64 search_start;	/* Logical range start we search for csum */
+	u64 search_len;		/* Logical range len we search for csum */
 	unsigned int extent_type;
 	unsigned int is_hole;
+	int compressed = 0;
 	int ret;
 	int err = 0;
 
@@ -4739,24 +4743,45 @@ static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
 	disk_bytenr = btrfs_file_extent_disk_bytenr(node, fi);
 	disk_num_bytes = btrfs_file_extent_disk_num_bytes(node, fi);
 	extent_num_bytes = btrfs_file_extent_num_bytes(node, fi);
+	extent_offset = btrfs_file_extent_offset(node, fi);
+	compressed = btrfs_file_extent_compression(node, fi);
 	is_hole = (disk_bytenr == 0) && (disk_num_bytes == 0);
 
-	/* Check EXTENT_DATA datasum */
-	ret = count_csum_range(root, disk_bytenr, disk_num_bytes, &found);
-	if (found > 0 && nodatasum) {
+	/*
+	 * Check EXTENT_DATA datasum
+	 *
+	 * For plain(uncompressed) extent, we should only check the range
+	 * we're referring to, as it's possible that part of prealloc extent
+	 * has been written, and has csum:
+	 *
+	 * |<-----Original large preallocate extent A ---->|
+	 * |<- Prealloc File Extent ->|<- Regular Extent ->|
+	 *	No csum				Has csum
+	 *
+	 * For compressed extent, we should check the whole range.
+	 */
+	if (!compressed) {
+		search_start = disk_bytenr + extent_offset;
+		search_len = extent_num_bytes;
+	} else {
+		search_start = disk_bytenr;
+		search_len = disk_num_bytes;
+	}
+	ret = count_csum_range(root, search_start, search_len, &csum_found);
+	if (csum_found > 0 && nodatasum) {
 		err |= ODD_CSUM_ITEM;
 		error("root %llu EXTENT_DATA[%llu %llu] nodatasum shouldn't have datasum",
 		      root->objectid, fkey->objectid, fkey->offset);
 	} else if (extent_type == BTRFS_FILE_EXTENT_REG && !nodatasum &&
-		   !is_hole &&
-		   (ret < 0 || found == 0 || found < disk_num_bytes)) {
+		   !is_hole && (ret < 0 || csum_found < search_len)) {
 		err |= CSUM_ITEM_MISSING;
-		error("root %llu EXTENT_DATA[%llu %llu] datasum missing",
-		      root->objectid, fkey->objectid, fkey->offset);
-	} else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && found > 0) {
+		error("root %llu EXTENT_DATA[%llu %llu] datasum missing, have: %llu, expect: %llu",
+		      root->objectid, fkey->objectid, fkey->offset,
+		      csum_found, search_len);
+	} else if (extent_type == BTRFS_FILE_EXTENT_PREALLOC && csum_found > 0) {
 		err |= ODD_CSUM_ITEM;
-		error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have datasum",
-		      root->objectid, fkey->objectid, fkey->offset);
+		error("root %llu EXTENT_DATA[%llu %llu] prealloc shouldn't have datasum, but have: %llu",
+		      root->objectid, fkey->objectid, fkey->offset, csum_found);
 	}
 
 	/* Check EXTENT_DATA hole */
-- 
2.11.1

[PATCH v3 04/12] btrfs-progs: lowmem check: Fix extent item size false alert

[Qu Wenruo]

If one extent item has no inline ref, btrfs lowmem mode check can give
false alert without outputting any error message.

The problem is lowmem mode always assume that extent item has inline
refs, and when it encounters such case it flags the extent item has
wrong size, but doesn't output the error message.

Although we already have such image submitted, at the commit time due to
another bug in cmds-check return value, it doesn't detect it until that
bug is fixed.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index e99e3c36..eb146432 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -10761,13 +10761,20 @@ static int check_extent_item(struct btrfs_fs_info *fs_info,
 	}
 	end = (unsigned long)ei + item_size;
 
-	if (ptr >= end) {
+next:
+	/* Reached extent item end normally */
+	if (ptr == end)
+		goto out;
+
+	/* Beyond extent item end, wrong item size */
+	if (ptr > end) {
 		err |= ITEM_SIZE_MISMATCH;
+		error("extent item at bytenr %llu slot %d has wrong size",
+			eb->start, slot);
 		goto out;
 	}
 
 	/* Now check every backref in this extent item */
-next:
 	iref = (struct btrfs_extent_inline_ref *)ptr;
 	type = btrfs_extent_inline_ref_type(eb, iref);
 	offset = btrfs_extent_inline_ref_offset(eb, iref);
@@ -10804,8 +10811,7 @@ next:
 	}
 
 	ptr += btrfs_extent_inline_ref_size(type);
-	if (ptr < end)
-		goto next;
+	goto next;
 
 out:
 	return err;
-- 
2.11.1

[PATCH v3 05/12] btrfs-progs: lowmem check: Fix false alert on inline compressed extent

[Qu Wenruo]

Old lowmem check doesn't check if the inline extent is compressed and
always check extent numbytes against inline item size.

And when it finds the extent numbytes mismatch with inline item size it
doesn't output any error message, just return error silently, making it
quite hard to debug.

Fix it by only checking extent numbytes against inline item size when
the extent is not compressed, and output error message.

Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index eb146432..cf5a08ce 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -4715,17 +4715,28 @@ static int check_file_extent(struct btrfs_root *root, struct btrfs_key *fkey,
 
 	fi = btrfs_item_ptr(node, slot, struct btrfs_file_extent_item);
 
+	/* Check inline extent */
 	extent_type = btrfs_file_extent_type(node, fi);
-	/* Skip if file extent is inline */
 	if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
 		struct btrfs_item *e = btrfs_item_nr(slot);
 		u32 item_inline_len;
 
 		item_inline_len = btrfs_file_extent_inline_item_len(node, e);
 		extent_num_bytes = btrfs_file_extent_inline_len(node, slot, fi);
-		if (extent_num_bytes == 0 ||
-		    extent_num_bytes != item_inline_len)
+		compressed = btrfs_file_extent_compression(node, fi);
+		if (extent_num_bytes == 0) {
+			error(
+		"root %llu EXTENT_DATA[%llu %llu] has empty inline extent",
+				root->objectid, fkey->objectid, fkey->offset);
 			err |= FILE_EXTENT_ERROR;
+		}
+		if (!compressed && extent_num_bytes != item_inline_len) {
+			error(
+		"root %llu EXTENT_DATA[%llu %llu] wrong inline size, have: %llu, expect: %u",
+				root->objectid, fkey->objectid, fkey->offset,
+				extent_num_bytes, item_inline_len);
+			err |= FILE_EXTENT_ERROR;
+		}
 		*size += extent_num_bytes;
 		return err;
 	}
-- 
2.11.1

[PATCH v3 06/12] btrfs-progs: lowmem check: Fix silent error if first inode item missing

[Qu Wenruo]

If first inode item is missing, lowmem check will detect it but not
output any error message.

Add error message for it.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 cmds-check.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/cmds-check.c b/cmds-check.c
index cf5a08ce..7d273623 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -5001,6 +5001,8 @@ static int check_fs_first_inode(struct btrfs_root *root, unsigned int ext_ref)
 	if (ret > 0) {
 		ret = 0;
 		err |= INODE_ITEM_MISSING;
+		error("first inode item of root %llu is missing",
+		      root->objectid);
 	}
 
 	err |= check_inode_item(root, &path, ext_ref);
-- 
2.11.1

[PATCH v3 07/12] btrfs-progs: tests: Move fsck-tests/015 to fuzz tests

[Qu Wenruo]

The test case fsck-tests/015-check-bad-memory-access can't be repair by
btrfs check, and it's a fortunate bug makes original mode to forget the
error code from extent tree, making original mode pass it.

So fuzz-tests is more suitable for it.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 .../images}/bko-97171-btrfs-image.raw.txt                   |   0
 .../images}/bko-97171-btrfs-image.raw.xz                    | Bin
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename tests/{fsck-tests/015-check-bad-memory-access => fuzz-tests/images}/bko-97171-btrfs-image.raw.txt (100%)
 rename tests/{fsck-tests/015-check-bad-memory-access => fuzz-tests/images}/bko-97171-btrfs-image.raw.xz (100%)

diff --git a/tests/fsck-tests/015-check-bad-memory-access/bko-97171-btrfs-image.raw.txt b/tests/fuzz-tests/images/bko-97171-btrfs-image.raw.txt
similarity index 100%
rename from tests/fsck-tests/015-check-bad-memory-access/bko-97171-btrfs-image.raw.txt
rename to tests/fuzz-tests/images/bko-97171-btrfs-image.raw.txt
diff --git a/tests/fsck-tests/015-check-bad-memory-access/bko-97171-btrfs-image.raw.xz b/tests/fuzz-tests/images/bko-97171-btrfs-image.raw.xz
similarity index 100%
rename from tests/fsck-tests/015-check-bad-memory-access/bko-97171-btrfs-image.raw.xz
rename to tests/fuzz-tests/images/bko-97171-btrfs-image.raw.xz
-- 
2.11.1

[PATCH v3 08/12] btrfs-progs: fsck-test: Add test image for lowmem mode block group false alert

[Qu Wenruo]

Add a minimal image which can reproduce the block group used space
false alert for lowmem mode fsck.

Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 .../block_group_item_false_alert.raw.xz                 | Bin 0 -> 47792 bytes
 tests/fsck-tests/020-extent-ref-cases/test.sh           |  15 +++++++++++----
 2 files changed, 11 insertions(+), 4 deletions(-)
 create mode 100644 tests/fsck-tests/020-extent-ref-cases/block_group_item_false_alert.raw.xz

diff --git a/tests/fsck-tests/020-extent-ref-cases/block_group_item_false_alert.raw.xz b/tests/fsck-tests/020-extent-ref-cases/block_group_item_false_alert.raw.xz
new file mode 100644
index 0000000000000000000000000000000000000000..559c3fa9e8491f3ce1f424d1baef29853e8fb889
GIT binary patch
literal 47792
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

literal 0
HcmV?d00001

diff --git a/tests/fsck-tests/020-extent-ref-cases/test.sh b/tests/fsck-tests/020-extent-ref-cases/test.sh
index c2b6a006..5dc5e55d 100755
--- a/tests/fsck-tests/020-extent-ref-cases/test.sh
+++ b/tests/fsck-tests/020-extent-ref-cases/test.sh
@@ -8,16 +8,23 @@
 # * shared_data_ref
 # * no_inline_ref (a extent item without inline ref)
 # * no_skinny_ref
+#
+# Special check for lowmem regression
+# * block_group_item_false_alert
+#   Containing a block group and its first extent at
+#   the beginning of leaf.
+#   Which caused false alert for lowmem mode.
 
 source $TOP/tests/common
 
 check_prereq btrfs
 
-for img in *.img
+for img in *.img *.raw.xz
 do
 	image=$(extract_image $img)
-	run_check_stdout $TOP/btrfs check "$image" 2>&1 |
-		grep -q "Errors found in extent allocation tree or chunk allocation" &&
-		_fail "unexpected error occurred when checking $img"
+
+	# Since the return value bug is already fixed, we don't need
+	# the old grep hack to detect bug.
+	run_check $TOP/btrfs check "$image"
 	rm -f "$image"
 done
-- 
2.11.1

[PATCH v3 09/12] btrfs-progs: fsck-test: Make 013 compatible with lowmem mode

[Qu Wenruo]

fsck-tests/013-extent-tree-rebuild uses "--init-extent-tree", which
implies "--repair".

But the test script doesn't specify "--repair" for lowmem mode test to
detect it.

Add it so lowmem mode test can be happy with it.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 tests/fsck-tests/013-extent-tree-rebuild/test.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/fsck-tests/013-extent-tree-rebuild/test.sh b/tests/fsck-tests/013-extent-tree-rebuild/test.sh
index 37bdcd9c..08c1e50e 100755
--- a/tests/fsck-tests/013-extent-tree-rebuild/test.sh
+++ b/tests/fsck-tests/013-extent-tree-rebuild/test.sh
@@ -36,7 +36,7 @@ test_extent_tree_rebuild()
 
 	$SUDO_HELPER $TOP/btrfs check $TEST_DEV >& /dev/null && \
 			_fail "btrfs check should detect failure"
-	run_check $SUDO_HELPER $TOP/btrfs check --init-extent-tree $TEST_DEV
+	run_check $SUDO_HELPER $TOP/btrfs check --repair --init-extent-tree $TEST_DEV
 	run_check $SUDO_HELPER $TOP/btrfs check $TEST_DEV
 }
 
-- 
2.11.1

[PATCH v3 10/12] btrfs-progs: fsck-test: Add new test case for file extent false alerts

[Qu Wenruo]

Lowmem mode exposed several false alerts, all related to file extents
check.

1) Partly written prealloc extent
   Cause lowmem mode to report missing csum or prealloc extent should
   not have csum

2) Compressed inline extent
   Cause lowmem mode to find mismatch on inline len and item len.
   While no error message is output but exit silently.

Reported-by: Chris Murphy <chris@colorremedies.com>
Reported-by: Christoph Anton Mitterer <calestyo@scientia.net>
Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
---
 tests/fsck-tests/025-file-extents/test.sh | 42 +++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100755 tests/fsck-tests/025-file-extents/test.sh

diff --git a/tests/fsck-tests/025-file-extents/test.sh b/tests/fsck-tests/025-file-extents/test.sh
new file mode 100755
index 00000000..cb64c500
--- /dev/null
+++ b/tests/fsck-tests/025-file-extents/test.sh
@@ -0,0 +1,42 @@
+#!/bin/bash
+# Confirm btrfs check can check file extents without causing false alert
+
+source $TOP/tests/common
+
+check_prereq btrfs
+check_prereq mkfs.btrfs
+check_global_prereq xfs_io
+check_global_prereq fallocate
+
+setup_root_helper
+prepare_test_dev 128M
+
+# Do some write into a large prealloc range
+# Lowmem mode can report missing csum due to wrong csum range
+test_paritical_write_into_prealloc()
+{
+	run_check $SUDO_HELPER "$TOP/mkfs.btrfs" -f "$TEST_DEV"
+	run_check_mount_test_dev
+
+	run_check fallocate -l 128K "$TEST_MNT/file"
+	sync
+	run_check xfs_io -c "pwrite 0 64K" "$TEST_MNT/file"
+	run_check_umount_test_dev
+	run_check "$TOP/btrfs" check "$TEST_DEV"
+}
+
+# Inline compressed file extent
+# Lowmem mode can cause silent error without any error message
+# due to too restrict check on inline extent size
+test_compressed_inline_extent()
+{
+	run_check $SUDO_HELPER "$TOP/mkfs.btrfs" -f "$TEST_DEV"
+	run_check_mount_test_dev -o compress=lzo,max_inline=2048
+
+	run_check xfs_io -f -c "pwrite 0 1K" "$TEST_MNT/file"
+	run_check_umount_test_dev
+	run_check "$TOP/btrfs" check "$TEST_DEV"
+}
+
+test_paritical_write_into_prealloc
+test_compressed_inline_extent
-- 
2.11.1

[PATCH v3 11/12] btrfs-progs: fsck: Fix lowmem mode override to allow it skip repair work

[Qu Wenruo]

From: Lu Fengqi <lufq.fnst@cn.fujitsu.com>

Current common.local doesn't handle lowmem mode well.
It passes "--mode=lowmem" alone with "--repair", making it unable to
check lowmem mode.

It's caused by the following bugs:

1) Wrong variable in test/common.local
   We should check TEST_ARGS_CHECK, not TEST_CHECK, which is not defined
   so we never return 1.

2) Wrong parameter passed to _cmd_spec() in test/common
   This prevents us from grepping the correct parameters.

Fix it.

Signed-off-by: Lu Fengqi <lufq.fnst@cn.fujitsu.com>
---
 tests/common       | 8 ++++----
 tests/common.local | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/common b/tests/common
index 51c2e267..7ad436e3 100644
--- a/tests/common
+++ b/tests/common
@@ -106,7 +106,7 @@ run_check()
 	ins=$(_get_spec_ins "$@")
 	spec=$(($ins-1))
 	cmd=$(eval echo "\${$spec}")
-	spec=$(_cmd_spec "$cmd")
+	spec=$(_cmd_spec "${@:$spec}")
 	set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
 	echo "############### $@" >> "$RESULTS" 2>&1
 	if [[ $TEST_LOG =~ tty ]]; then echo "CMD: $@" > /dev/tty; fi
@@ -128,7 +128,7 @@ run_check_stdout()
 	ins=$(_get_spec_ins "$@")
 	spec=$(($ins-1))
 	cmd=$(eval echo "\${$spec}")
-	spec=$(_cmd_spec "$cmd")
+	spec=$(_cmd_spec "${@:$spec}")
 	set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
 	echo "############### $@" >> "$RESULTS" 2>&1
 	if [[ $TEST_LOG =~ tty ]]; then echo "CMD(stdout): $@" > /dev/tty; fi
@@ -152,7 +152,7 @@ run_mayfail()
 	ins=$(_get_spec_ins "$@")
 	spec=$(($ins-1))
 	cmd=$(eval echo "\${$spec}")
-	spec=$(_cmd_spec "$cmd")
+	spec=$(_cmd_spec "${@:$spec}")
 	set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
 	echo "############### $@" >> "$RESULTS" 2>&1
 	if [[ $TEST_LOG =~ tty ]]; then echo "CMD(mayfail): $@" > /dev/tty; fi
@@ -188,7 +188,7 @@ run_mustfail()
 	ins=$(_get_spec_ins "$@")
 	spec=$(($ins-1))
 	cmd=$(eval echo "\${$spec}")
-	spec=$(_cmd_spec "$cmd")
+	spec=$(_cmd_spec "${@:$spec}")
 	set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
 	echo "############### $@" >> "$RESULTS" 2>&1
 	if [[ $TEST_LOG =~ tty ]]; then echo "CMD(mustfail): $@" > /dev/tty; fi
diff --git a/tests/common.local b/tests/common.local
index 9f567c27..4f56bb08 100644
--- a/tests/common.local
+++ b/tests/common.local
@@ -17,7 +17,7 @@ TEST_ARGS_CHECK=--mode=lowmem
 # break tests
 _skip_spec()
 {
-	if echo "$TEST_CHECK" | grep -q 'mode=lowmem' &&
+	if echo "$TEST_ARGS_CHECK" | grep -q 'mode=lowmem' &&
 	   echo "$@" | grep -q -- '--repair'; then
 		return 0
 	fi
-- 
2.11.1

[PATCH v3 12/12] btrfs-progs: cmds-check.c: walk_down_tree_v2 break cause of leaf process

[Qu Wenruo]

From: Su Yue <suy.fnst@cn.fujitsu.com>

In lowmem mode, 'walk_down_tree_v2' returns negative values wheather
the error is fatal or not. It causes the loop where 'walk_down_tree_v2'
is to break even the error is tolerated and then subsequent nodes process
will be skipped.

Fix it by redefining meanings of values 'walk_down_tree_v2' returns.
Do a similar fix for 'process_one_leaf_v2'.

Signed-off-by: Su Yue <suy.fnst@cn.fujitsu.com>
---
 cmds-check.c | 40 +++++++++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 15 deletions(-)

diff --git a/cmds-check.c b/cmds-check.c
index 7d273623..9cc1932c 100644
--- a/cmds-check.c
+++ b/cmds-check.c
@@ -1868,6 +1868,11 @@ static int update_nodes_refs(struct btrfs_root *root, u64 bytenr,
 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
 			    unsigned int ext_ref);
 
+/*
+ * Returns >0  Found error, not fatal, should continue process
+ * Returns <0  Fata error, must exit the whole check
+ * returns 0   No error is found
+ */
 static int process_one_leaf_v2(struct btrfs_root *root, struct btrfs_path *path,
 			       struct node_refs *nrefs, int *level, int ext_ref)
 {
@@ -1937,13 +1942,8 @@ again:
 	}
 out:
 	err &= ~LAST_ITEM;
-	/*
-	 * Convert any error bitmap to -EIO, as we should avoid
-	 * mixing positive and negative return value to represent
-	 * error
-	 */
 	if (err && !ret)
-		ret = -EIO;
+		ret = err;
 	return ret;
 }
 
@@ -2213,6 +2213,11 @@ out:
 static int check_inode_item(struct btrfs_root *root, struct btrfs_path *path,
 			    unsigned int ext_ref);
 
+/*
+ * Returns >0  Found error, should continue
+ * Returns 0   No error is found
+ * Returns <0  Fatal error, must exit the whole check
+ */
 static int walk_down_tree_v2(struct btrfs_root *root, struct btrfs_path *path,
 			     int *level, struct node_refs *nrefs, int ext_ref)
 {
@@ -5028,8 +5033,9 @@ static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
 	struct btrfs_path path;
 	struct node_refs nrefs;
 	struct btrfs_root_item *root_item = &root->root_item;
-	int ret, wret;
+	int ret;
 	int level;
+	int err = 0;
 
 	/*
 	 * We need to manually check the first inode item(256)
@@ -5063,17 +5069,21 @@ static int check_fs_root_v2(struct btrfs_root *root, unsigned int ext_ref)
 	}
 
 	while (1) {
-		wret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
-		if (wret < 0)
-			ret = wret;
-		if (wret != 0)
+		ret = walk_down_tree_v2(root, &path, &level, &nrefs, ext_ref);
+		err |= !!ret;
+
+		/* if ret is negative, walk shall stop */
+		if (ret < 0) {
+			ret = err;
 			break;
+		}
 
-		wret = walk_up_tree_v2(root, &path, &level);
-		if (wret < 0)
-			ret = wret;
-		if (wret != 0)
+		ret = walk_up_tree_v2(root, &path, &level);
+		if (ret != 0) {
+			/* Normal exit, reset ret to err */
+			ret = err;
 			break;
+		}
 	}
 
 out:
-- 
2.11.1

Re: [PATCH v3 10/12] btrfs-progs: fsck-test: Add new test case for file extent false alerts

[David Sterba]

On Tue, Feb 21, 2017 at 04:34:36PM +0800, Qu Wenruo wrote:
> +check_global_prereq xfs_io

> +	run_check xfs_io -c "pwrite 0 64K" "$TEST_MNT/file"

> +	run_check xfs_io -f -c "pwrite 0 1K" "$TEST_MNT/file"

I've converted this to dd as we don't want to depend on xfsprogs
installed for the tests.

Re: [PATCH v3 00/12] lowmem mode fixes

[David Sterba]

On Tue, Feb 21, 2017 at 04:34:26PM +0800, Qu Wenruo wrote:
> Patches can be fetch from github:
> https://github.com/adam900710/btrfs-progs/tree/lowmem_fixes
> 
> Thanks for reports from Chris Murphy and Christoph Anton Mitterer,
> several new bugs are exposed for lowmem mode fsck.
> 
> Special thank to Christoph, who did rounds of test during the patch
> development.
> 
> The following bugs are fixed in lowmem mode:
> 
> 1) Block group used space false alert
>    If a BLOCK_GROUP_ITEM or its first EXTENT/METADATA_ITEM is located at
>    the first slot of a leaf, search_slot() used by lowmem mode can
>    point to previous leaf, with path->slots[0] beyond valid leaf slots.
> 
>    This makes us to read out uninitialized data, and can abort block
>    group used space check loop, causing a false alert.
> 
>    Fix it with a test case image inside fsck-tests/020/extent-ref-cases
>    Also fix all possible backward search.
>    Reported by Christoph.
> 
> 2) Partly written prealloc extent false alert
>    If a prealloc extent gets partily written, lowmem mode will report
>    prealloc extent shouldn't have csum.
> 
>    Lowmem mode passed wrong variable to csum checking code, causing it
>    to check the whole range of the prealloc extent, making the bug
>    happens.
> 
>    Fix it with a test case inside fsck-tests/020/extent-ref-cases.
>    Reported by Chirs Murphy And Christoph.
> 
> 3) Extent item size false alert.
>    Under certain case, btrfs lowmem mode check reports data backref
>    lost.
>    It's because newly introduced extent item size check aborts normal
>    check routine.
> 
>    It can happen if a data/metadata extent item has no inline ref.
> 
>    Fix it, test case already submitted before and merged, but due to
>    fsck-tests framework bugs, it never get called for lowmem mode.
> 
> 4) Compressed inline data extent
>    The extra check on inline data extent length doesn't take compression
>    into consideration and will cause false alert without outputting any
>    error message.
> 
>    Fix it and add correct error message output for it.
>    Also fix all possible silent error.
>    Reported by Christoph.
> 
> 5) fsck-tests Lowmem mode override fixes
>    Allow lowmem mode override to get called for all tests, and allow
>    them all to pass lowmem mode except fsck-tests/006, which is a
>    original repair mode bug.
> 
> 
> changelog:
>   v2:
>     More generic forward search bug fix, not restricted to block group
>     item.
>     Compressed inline extent false alert fix.
>     Lowmem fsck-test enhance, to allow it really work.
>     Fix walk_down_tree_v2() to continue after non-fatal errors detected
>   v3:
>     Update the last patch to make it works better for incoming lowmem
>     mode repair patchset.

Thanks for the fixes, applied with a few minor fixups in changelogs.