btrfs-progs: check/lowmem: fix a false alert when counting the refs

[BUG]

For a btrfs which is under metadata balance and interrupted (powerloss
etc), we can have the following extent backref item for a data extent:

        item 22 key (13631488 EXTENT_ITEM 524288) itemoff 3161 itemsize 108
                refs 180 gen 9 flags DATA
                (178 0xdfb591fbbf5f519) extent data backref root FS_TREE objectid 258 offset 0 count 77
                (178 0xdfb591fa80d95ea) extent data backref root FS_TREE objectid 257 offset 0 count 1
                (184 0x151e000) shared data backref parent 22142976 count 51
                (184 0x512000) shared data backref parent 5316608 count 51

Then lowmem mode will cause the following false alert:

[3/8] checking extents
ERROR: extent[13631488, 524288] referencer count mismatch (root: 5, owner: 258, offset: 0) wanted: 77, have: 128
ERROR: errors found in extent allocation tree or chunk allocation

[CAUSE]
When shared and keyed backref items are found, we must follow the
following rules to avoid incorrect refs count:

- If the leaf belongs to the shared backref parent
  Then any found EXTENT_DATA inside the leaf will be contributed to the
  shared backref values.

- Otherwise any found EXTENT_DATA can contributed to the keyed backref

In above case, if our leaf is 5316608 or 22142976, then we should not
contribute the number of found EXTENT_DATA to the keyed backref.

Unfortunately the original fix d53d42f ("btrfs-progs: lowmem: fix
false alerts of referencer count mismatch for blocks relocated") is not
following the above strict rule, but relying on the flag of the leaf.

However that RELOC flag is not a correct indicator, e.g in above case
the leaf at 5316608 is not yet being relocated, thus no RELOC flag.

[FIX]
Instead of check the unreliable RELOC flag, follow the correct rule when
checking the leaf.

Before we start checking the content of a leaf for EXTENT_DATA items,
make sure the leaf's bytenr is not in any shared backref item.
If so skip to the next leaf.

Fixes: d53d42f ("btrfs-progs: lowmem: fix false alerts of referencer count mismatch for blocks relocated")
Signed-off-by: Qu Wenruo <[email protected]>

Author: adam900710

check/mode-lowmem.c

@@ -3977,6 +3977,139 @@ static int check_shared_block_backref(u64 parent, u64 bytenr, int level)
 	return 0;
 }
 
+/*
+ * A read-only version of lookup_inline_extent_backref().
+ * We can not reuse that function as it always assume COW.
+ */
+static int has_inline_shared_backref(u64 data_bytenr, u64 data_len, u64 parent)
+{
+	struct btrfs_root *extent_root = btrfs_extent_root(gfs_info, data_bytenr);
+	struct btrfs_extent_inline_ref *iref;
+	struct btrfs_extent_item *ei;
+	struct btrfs_path path = { 0 };
+	struct extent_buffer *leaf;
+	struct btrfs_key key;
+	unsigned long ptr;
+	unsigned long end;
+	bool found = false;
+	u32 item_size;
+	u64 flags;
+	int ret;
+
+	key.objectid = data_bytenr;
+	key.type = BTRFS_EXTENT_ITEM_KEY;
+	key.offset = data_len;
+	ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
+	if (ret > 0)
+		ret = -ENOENT;
+	if (ret < 0)
+		goto out;
+
+	leaf = path.nodes[0];
+	item_size = btrfs_item_size(leaf, path.slots[0]);
+	if (item_size < sizeof(*ei)) {
+		error("extent item size %u < %zu, leaf %llu slot %u",
+		      item_size, sizeof(*ei), leaf->start, path.slots[0]);
+		ret = -EUCLEAN;
+		goto out;
+	}
+	ei = btrfs_item_ptr(leaf, path.slots[0], struct btrfs_extent_item);
+	flags = btrfs_extent_flags(leaf, ei);
+
+	if (!(flags & BTRFS_EXTENT_FLAG_DATA)) {
+		error("backref item flag for bytenr %llu is not data",
+			data_bytenr);
+		ret = -EUCLEAN;
+		goto out;
+	}
+
+	ptr = (unsigned long)(ei + 1);
+	end = (unsigned long)ei + item_size;
+
+	while (true) {
+		u64 ref_parent;
+		u8 type;
+
+		if (ptr >= end) {
+			if (ptr > end) {
+				error("inline extent item for %llu is not properly ended",
+				      data_bytenr);
+				ret = -EUCLEAN;
+				goto out;
+			}
+			break;
+		}
+		iref = (struct btrfs_extent_inline_ref *)ptr;
+		type = btrfs_extent_inline_ref_type(leaf, iref);
+		if (type != BTRFS_SHARED_DATA_REF_KEY)
+			goto next;
+
+		ref_parent = btrfs_extent_inline_ref_offset(leaf, iref);
+		if (ref_parent == parent) {
+			found = true;
+			goto out;
+		}
+next:
+		ptr += btrfs_extent_inline_ref_size(type);
+	}
+
+out:
+	btrfs_release_path(&path);
+	if (ret < 0)
+		return ret;
+	return found;
+}
+
+static int has_keyed_shared_backref(u64 data_bytenr, u64 parent)
+{
+	struct btrfs_root *extent_root = btrfs_extent_root(gfs_info, data_bytenr);
+	struct btrfs_path path = { 0 };
+	struct btrfs_key key;
+	int ret;
+
+	key.objectid = data_bytenr;
+	key.type = BTRFS_SHARED_DATA_REF_KEY;
+	key.offset = parent;
+	ret = btrfs_search_slot(NULL, extent_root, &key, &path, 0, 0);
+	btrfs_release_path(&path);
+	if (ret < 0)
+		return ret;
+	/* No keyed ref found, return 0. */
+	if (ret > 0)
+		return 0;
+	return 1;
+}
+
+/*
+ * A helper to determine if the @leaf already belongs to a shared data backref item.
+ * (with parent bytenr)
+ *
+ * Return >0 if the @leaf belongs to a shared data backref.
+ * Return 0 if not.
+ * Return <0 for critical error.
+ */
+static int is_leaf_shared(struct extent_buffer *leaf, u64 data_bytenr, u64 data_len)
+{
+	int ret;
+
+	ret = has_inline_shared_backref(data_bytenr, data_len, leaf->start);
+	if (ret < 0) {
+		errno = -ret;
+		error("failed to search inlined shared backref for logical %llu len %llu, %m",
+			data_bytenr, data_len);
+		return ret;
+	}
+	if (ret > 0)
+		return ret;
+	ret = has_keyed_shared_backref(data_bytenr, leaf->start);
+	if (ret < 0) {
+		errno = -ret;
+		error("failed to search keyed shared backref for logical %llu len %llu, %m",
+			data_bytenr, data_len);
+	}
+	return ret;
+}
+
 /*
  * Check referencer for normal (inlined) data ref
  * If len == 0, it will be resolved by searching in extent tree
@@ -4049,13 +4182,13 @@ static int check_extent_data_backref(u64 root_id, u64 objectid, u64 offset,
 		    btrfs_header_owner(leaf) != root_id)
 			goto next;
 		/*
-		 * For tree blocks have been relocated, data backref are
-		 * shared instead of keyed. Do not account it.
+		 * If the node belongs to a shared backref item, we should not
+		 * account the number.
 		 */
-		if (btrfs_header_flag(leaf, BTRFS_HEADER_FLAG_RELOC)) {
-			/*
-			 * skip the leaf to speed up.
-			 */
+		ret = is_leaf_shared(leaf, bytenr, len);
+		if (ret < 0)
+			break;
+		if (ret > 0) {
 			slot = btrfs_header_nritems(leaf);
 			goto next;
 		}