Skip to contentSkip to conversation

btrfs: introduce seperate structure to avoid

PATCH In review Qu Wenruo 1 participant 9 messages Dec 26, 2025 – Jan 18

Subsystems (2)
lore
Share & tools
lore

Qu Wenruo

author
#0 lore raw

cover btrfs: introduce seperate structure to avoid

The structure btrfs_file_extent_item is defined that if one file extent is inlined, the data starts after btrfs_file_extent_item::type, aka, overlapping with btrfs_file_extent_item::disk_bytenr and other members.

This makes it harder to understand btrfs on-disk format.

This also requires every user of btrfs_file_extent_item::disk_bytenr and other non-inline members to check btrfs_file_extent_item::type first.

But not all callers are strictly following that, and when access-beyond-boundary happens, we have no built-in checks to catch them.

This series address the problem by:

- Introduce btrfs_file_header structure to define the shared part Initially I'm planning to use ms-extension to define an unnamed structure inside btrfs_file_extent_item, to avoid duplicated definition, but it doesn't work for arm64.

So have to do duplicated definition.

- Introduce btrfs_file_header_*() helpers for the shared members

- Introduce btrfs_file_header_disk_bytenr() for btrfs_file_extent_item This allows using the same btrfs_file_header pointer to access the btrfs_file_extent_item exclusive members, with built-in ASSERT() to catch incorrect types.

- Convert existing btrfs_file_extent_item pointer users to btrfs_file_header
This also reduce the lifespan of those pointers to minimal, e.g. only define them in the minimal scope, even if it means to define such pointer again and again in different scopes.

There are some exceptions:

* On-stack ones are still using btrfs_file_extent_item

* Certain write paths are still using btrfs_file_extent_item pointer Those sites are known to handling non-inlined extents, thus can still use the old pointer, but not recommended anymore.

Qu Wenruo (7):
btrfs: introduce btrfs_file_header structure
btrfs: use btrfs_file_header structure for tree-checker
btrfs: use btrfs_file_header structure for trace events
btrfs: use btrfs_file_header structure for inode.c
btrfs: use btrfs_file_header structure for simple usages
btrfs: use btrfs_file_header structure for file.c
btrfs: use btrfs_file_header structure for send.c and tree-log.c

 fs/btrfs/accessors.h            |  79 +++++++++++++
 fs/btrfs/backref.c              |  36 +++---
 fs/btrfs/ctree.c                |  33 +++---
 fs/btrfs/defrag.c               |   8 +-
 fs/btrfs/extent-tree.c          |  26 ++--
 fs/btrfs/fiemap.c               |  30 ++---
 fs/btrfs/file-item.c            |  26 ++--
 fs/btrfs/file-item.h            |  23 ++--
 fs/btrfs/file.c                 | 204 ++++++++++++++++----------------
 fs/btrfs/inode-item.c           |  47 ++++----
 fs/btrfs/inode.c                | 151 ++++++++++++-----------
 fs/btrfs/print-tree.c           |  28 ++---
 fs/btrfs/qgroup.c               |  11 +-
 fs/btrfs/reflink.c              |  34 +++---
 fs/btrfs/relocation.c           |  42 +++----
 fs/btrfs/send.c                 | 145 +++++++++++------------
 fs/btrfs/tree-checker.c         |  82 ++++++-------
 fs/btrfs/tree-log.c             |  70 +++++------
 include/trace/events/btrfs.h    |  58 ++++-----
 include/uapi/linux/btrfs_tree.h |  61 ++++++----
 20 files changed, 643 insertions(+), 551 deletions(-)
Signature · 1 line
2.52.0
author
#1 lore raw

PATCH 1/7 btrfs: introduce btrfs_file_header structure

Currently we have two major types of btrfs_file_extent_item:

- Inline ones
btrfs_file_extent_item::type is BTRFS_FILE_EXTENT_INLINE, and the inline data starts at btrfs_file_extent_item::disk_bytenr.

- Regular ones
Utilize the full btrfs_file_extent_item structure.

This means we need to use things like
"offsetof(struct btrfs_file_extent_item, disk_bytenr)" to calculate the size of the header part, and always need to check btrfs_file_extent_item::type before utilizing the remaining members.

This increases the possibility of accessing member beyond the item boundary for inlined file extents.

Here introduce a new btrfs_file_header structure to cover the shared part. Originally I'm planning to utilize ms-extension to define an unnamed structure inside btrfs_file_extent_item, but unfortunately that only compiles on x86_64, not on arm64.

Thus this patch goes the safer way by manually define a structure with duplicated members.

---
 fs/btrfs/accessors.h            |  4 +++
 fs/btrfs/ctree.c                |  2 +-
 fs/btrfs/file-item.h            | 11 +++---
 fs/btrfs/tree-checker.c         |  8 ++---
 include/uapi/linux/btrfs_tree.h | 61 +++++++++++++++++++++------------
 5 files changed, 52 insertions(+), 34 deletions(-)
fs/btrfs/accessors.h +4 -0
index 78721412951c..1568fd00e7d4 100644
@@ -903,6 +903,10 @@ BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item,
 BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item,
 		   other_encoding, 16);
 
+/* Members before @disk_bytenr must match btrfs_file_header. */
+static_assert(sizeof(struct btrfs_file_header) ==
+	      offsetof(struct btrfs_file_extent_item, disk_bytenr));
+
 /* btrfs_qgroup_status_item */
 BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item,
 		   generation, 64);
fs/btrfs/ctree.c +1 -1
index 7267b2502665..e859c4355f92 100644
@@ -4075,7 +4075,7 @@ void btrfs_truncate_item(struct btrfs_trans_handle *trans,
 				ptr = btrfs_item_ptr_offset(leaf, slot);
 				memmove_extent_buffer(leaf, ptr,
 				      (unsigned long)fi,
-				      BTRFS_FILE_EXTENT_INLINE_DATA_START);
+				      sizeof(struct btrfs_file_header));
 			}
 		}
 
fs/btrfs/file-item.h +4 -7
index 5645c5e3abdb..1394ae33fc6d 100644
@@ -20,12 +20,9 @@ struct btrfs_ordered_sum;
 struct btrfs_path;
 struct btrfs_inode;
 
-#define BTRFS_FILE_EXTENT_INLINE_DATA_START		\
-		(offsetof(struct btrfs_file_extent_item, disk_bytenr))
-
 static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
 {
-	return BTRFS_MAX_ITEM_SIZE(info) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
+	return BTRFS_MAX_ITEM_SIZE(info) - sizeof(struct btrfs_file_header);
 }
 
 /*
@@ -37,18 +34,18 @@ static inline u32 btrfs_file_extent_inline_item_len(
 						const struct extent_buffer *eb,
 						int nr)
 {
-	return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START;
+	return btrfs_item_size(eb, nr) - sizeof(struct btrfs_file_header);
 }
 
 static inline unsigned long btrfs_file_extent_inline_start(
 				const struct btrfs_file_extent_item *e)
 {
-	return (unsigned long)e + BTRFS_FILE_EXTENT_INLINE_DATA_START;
+	return (unsigned long)e + sizeof(struct btrfs_file_header);
 }
 
 static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
 {
-	return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize;
+	return sizeof(struct btrfs_file_header) + datasize;
 }
 
 int btrfs_del_csums(struct btrfs_trans_handle *trans,
fs/btrfs/tree-checker.c +4 -4
index c21c21adf61e..7bd2f543fec9 100644
@@ -236,10 +236,10 @@ static int check_extent_data_item(struct extent_buffer *leaf,
 	 * Make sure the item contains at least inline header, so the file
 	 * extent type is not some garbage.
 	 */
-	if (unlikely(item_size < BTRFS_FILE_EXTENT_INLINE_DATA_START)) {
+	if (unlikely(item_size < sizeof(struct btrfs_file_header))) {
 		file_extent_err(leaf, slot,
 				"invalid item size, have %u expect [%zu, %u)",
-				item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START,
+				item_size, sizeof(struct btrfs_file_header),
 				SZ_4K);
 		return -EUCLEAN;
 	}
@@ -285,11 +285,11 @@ static int check_extent_data_item(struct extent_buffer *leaf,
 			return 0;
 
 		/* Uncompressed inline extent size must match item size */
-		if (unlikely(item_size != BTRFS_FILE_EXTENT_INLINE_DATA_START +
+		if (unlikely(item_size != sizeof(struct btrfs_file_header) +
 					  btrfs_file_extent_ram_bytes(leaf, fi))) {
 			file_extent_err(leaf, slot,
 	"invalid ram_bytes for uncompressed inline extent, have %u expect %llu",
-				item_size, BTRFS_FILE_EXTENT_INLINE_DATA_START +
+				item_size, sizeof(struct btrfs_file_header) +
 				btrfs_file_extent_ram_bytes(leaf, fi));
 			return -EUCLEAN;
 		}
include/uapi/linux/btrfs_tree.h +39 -22

85 lines not on this page · raw message

Signature · 1 line
2.52.0
author
#2 lore raw

PATCH 2/7 btrfs: use btrfs_file_header structure for tree-checker

In reply to Qu Wenruo

This introduces the following accessors:

- btrfs_file_header members accessors
The usual eb and on-stack versions.

- btrfs_file_extent_item exclusive members accessors through btrfs_file_header
This will do the extra type casting with proper type checks to make sure (by ASSERT()) that the type is not BTRFS_FILE_EXTENT_INLINE.

This should help us to catch unsafe file extent item access.

In short, there should only be two ways to access btrfs_file_extent_item exclusive members:

- Use btrfs_file_header_*() helpers
This should be the most common ones.

- Use btrfs_file_header_to_item() helper, then the usual btrfs_file_extent_*() helpers
This is less recommended.

Tree-checker is the first one to migrate to the btrfs_file_header structure, and most call sites are migrated to use btrfs_file_header_*() helpers.

---
 fs/btrfs/accessors.h    | 75 +++++++++++++++++++++++++++++++++++++++++
 fs/btrfs/tree-checker.c | 74 ++++++++++++++++++++--------------------
 2 files changed, 113 insertions(+), 36 deletions(-)
fs/btrfs/accessors.h +75 -0
index 1568fd00e7d4..672425e3f10a 100644
@@ -864,6 +864,81 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block,
 BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block,
 			 nr_global_roots, 64);
 
+/* struct btrfs_file_header */
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_generation,
+			 struct btrfs_file_header, generation, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_ram_bytes,
+			 struct btrfs_file_header, ram_bytes, 64);
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_compression,
+			 struct btrfs_file_header, compression, 8);
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_encryption,
+			 struct btrfs_file_header, encryption, 8);
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_other_encoding,
+			 struct btrfs_file_header, other_encoding, 16);
+BTRFS_SETGET_STACK_FUNCS(stack_file_header_type,
+			 struct btrfs_file_header, type, 8);
+BTRFS_SETGET_FUNCS(file_header_generation, struct btrfs_file_header,
+		   generation, 64);
+BTRFS_SETGET_FUNCS(file_header_ram_bytes, struct btrfs_file_header,
+		   ram_bytes, 64);
+BTRFS_SETGET_FUNCS(file_header_compression, struct btrfs_file_header,
+		   compression, 8);
+BTRFS_SETGET_FUNCS(file_header_encryption, struct btrfs_file_header,
+		   encryption, 8);
+BTRFS_SETGET_FUNCS(file_header_other_encoding, struct btrfs_file_header,
+		   other_encoding, 16);
+BTRFS_SETGET_FUNCS(file_header_type, struct btrfs_file_header,
+		   type, 8);
+
+/*
+ * Safely convert a file_header pointer to a file_extent_item one, with
+ * extra type checks.
+ */
+static inline struct btrfs_file_extent_item*
+btrfs_file_header_to_item(const struct extent_buffer *leaf,
+			  const struct btrfs_file_header *header)
+{
+	ASSERT(btrfs_file_header_type(leaf, header) != BTRFS_FILE_EXTENT_INLINE);
+	return (struct btrfs_file_extent_item *)header;
+}
+
+/*
+ * The extra ones are to access btrfs_file_extent_item exclusive members, which
+ * needs to check btrfs_file_header::type first to make sure it's not an
+ * inlined one.
+ * Or such access can lead to out-of-boundary access.
+ *
+ * The input pointer should always be a btrfs_file_header pointer, and the type
+ * casting is done internally with proper type ASSERT().
+ */
+#define BTRFS_SETGET_FILE_ITEM_FUNCS(name, member, bits)		\
+static inline u##bits btrfs_##name(const struct extent_buffer *eb,	\
+				const struct btrfs_file_header *header) \
+{									\
+	struct btrfs_file_extent_item *item =				\
+		btrfs_file_header_to_item(eb, header);			\
+									\
+	return btrfs_get_##bits(eb, item,				\
+				offsetof(struct btrfs_file_extent_item, \
+					member));			\
+}									\
+static inline void btrfs_set_##name(const struct extent_buffer *eb,	\
+				const struct btrfs_file_header *header,	\
+				u##bits val)				\
+{									\
+	struct btrfs_file_extent_item *item =				\
+		btrfs_file_header_to_item(eb, header);			\
+									\
+	return btrfs_set_##bits(eb, item,				\
+				offsetof(struct btrfs_file_extent_item, \
+					member), val);			\
+}
+
+BTRFS_SETGET_FILE_ITEM_FUNCS(file_header_disk_bytenr, disk_bytenr, 64);
+BTRFS_SETGET_FILE_ITEM_FUNCS(file_header_disk_num_bytes, disk_num_bytes, 64);
+BTRFS_SETGET_FILE_ITEM_FUNCS(file_header_offset, offset, 64);
+BTRFS_SETGET_FILE_ITEM_FUNCS(file_header_num_bytes, num_bytes, 64);
+
 /* struct btrfs_file_extent_item */
 BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item,
 			 type, 8);
fs/btrfs/tree-checker.c +38 -36

177 lines not on this page · raw message

Signature · 1 line
2.52.0
author
#3 lore raw

PATCH 3/7 btrfs: use btrfs_file_header structure for trace events

In reply to Qu Wenruo

The trace event class btrfs__file_extent_item_* can benefit from the extra strict checks from btrfs_file_header structure.

This change involves the following call sites:

- defrag_get_extent()
Move the btrfs_file_header pointer to the nearest scope of usage. This reduces the lifespan of such variable.

- Rename btrfs_extent_item_to_extent_map()
To btrfs_file_header_to_extent_map(), and accept a btrfs_file_header pointer instead.

- Make btrfs_trace_truncate() to accept a btrfs_file_header pointer And do the proper type casting for non-inline extents.

- btrfs_truncate_inode_items()
This is a little tricky related to scope change of btrfs_file_header.

The original loop always initialize @fi to NULL for each loop, and assign it when hitting a BTRFS_EXTENT_DATA_KEY.

But if we didn't hit an BTRFS_EXTENT_DATA_KEY then we exit the loop. So we do not need to define @fi inside the function, can move it into the while (1) loop, and only initialize it after we hitting an BTRFS_EXTENT_DATA_KEY.

- btrfs_get_extent()
Pretty straightforward.

---
 fs/btrfs/defrag.c            |  8 ++---
 fs/btrfs/file-item.c         | 18 +++++------
 fs/btrfs/file-item.h         |  4 +--
 fs/btrfs/inode-item.c        | 45 +++++++++++++---------------
 fs/btrfs/inode.c             | 13 ++++----
 include/trace/events/btrfs.h | 58 ++++++++++++++++++------------------
 6 files changed, 71 insertions(+), 75 deletions(-)
fs/btrfs/defrag.c +4 -4
index bcc6656ad034..37516d2937fa 100644
@@ -608,7 +608,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,
 					    u64 start, u64 newer_than)
 {
 	struct btrfs_root *root = inode->root;
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	BTRFS_PATH_AUTO_RELEASE(path);
 	struct extent_map *em;
 	struct btrfs_key key;
@@ -697,8 +697,8 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,
 			break;
 		}
 
-		fi = btrfs_item_ptr(path.nodes[0], path.slots[0],
-				    struct btrfs_file_extent_item);
+		fh = btrfs_item_ptr(path.nodes[0], path.slots[0],
+				    struct btrfs_file_header);
 		extent_end = btrfs_file_extent_end(&path);
 
 		/*
@@ -711,7 +711,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,
 			goto next;
 
 		/* Now this extent covers @start, convert it to em */
-		btrfs_extent_item_to_extent_map(inode, &path, fi, em);
+		btrfs_file_header_to_extent_map(inode, &path, fh, em);
 		break;
 next:
 		ret = btrfs_next_item(root, &path);
fs/btrfs/file-item.c +9 -9
index 568f0e0ebdf6..843fbf245ae8 100644
@@ -1311,9 +1311,9 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
 	return ret;
 }
 
-void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
+void btrfs_file_header_to_extent_map(struct btrfs_inode *inode,
 				     const struct btrfs_path *path,
-				     const struct btrfs_file_extent_item *fi,
+				     const struct btrfs_file_header *fh,
 				     struct extent_map *em)
 {
 	struct btrfs_fs_info *fs_info = inode->root->fs_info;
@@ -1322,16 +1322,16 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
 	const int slot = path->slots[0];
 	struct btrfs_key key;
 	u64 extent_start;
-	u8 type = btrfs_file_extent_type(leaf, fi);
-	int compress_type = btrfs_file_extent_compression(leaf, fi);
+	u8 type = btrfs_file_header_type(leaf, fh);
+	int compress_type = btrfs_file_header_compression(leaf, fh);
 
 	btrfs_item_key_to_cpu(leaf, &key, slot);
 	extent_start = key.offset;
-	em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
-	em->generation = btrfs_file_extent_generation(leaf, fi);
+	em->ram_bytes = btrfs_file_header_ram_bytes(leaf, fh);
+	em->generation = btrfs_file_header_generation(leaf, fh);
 	if (type == BTRFS_FILE_EXTENT_REG ||
 	    type == BTRFS_FILE_EXTENT_PREALLOC) {
-		const u64 disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
+		const u64 disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
 
 		em->start = extent_start;
 		em->len = btrfs_file_extent_end(path) - extent_start;
@@ -1342,8 +1342,8 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
 			return;
 		}
 		em->disk_bytenr = disk_bytenr;
-		em->disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
-		em->offset = btrfs_file_extent_offset(leaf, fi);
+		em->disk_num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
+		em->offset = btrfs_file_header_offset(leaf, fh);
 		if (compress_type != BTRFS_COMPRESS_NONE) {
 			btrfs_extent_map_set_compression(em, compress_type);
 		} else {
fs/btrfs/file-item.h +2 -2
index 1394ae33fc6d..548d02595a6c 100644
@@ -71,9 +71,9 @@ int btrfs_lookup_csums_list(struct btrfs_root *root, u64 start, u64 end,
 int btrfs_lookup_csums_bitmap(struct btrfs_root *root, struct btrfs_path *path,
 			      u64 start, u64 end, u8 *csum_buf,
 			      unsigned long *csum_bitmap);
-void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
+void btrfs_file_header_to_extent_map(struct btrfs_inode *inode,
 				     const struct btrfs_path *path,
-				     const struct btrfs_file_extent_item *fi,
+				     const struct btrfs_file_header *fh,
 				     struct extent_map *em);
 int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
 					u64 len);
fs/btrfs/inode-item.c +21 -24

110 lines not on this page · raw message

fs/btrfs/inode.c +6 -7
index e12a1daf3474..127f9e7ef453 100644
@@ -7147,7 +7147,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 	int extent_type = -1;
 	struct btrfs_path *path = NULL;
 	struct btrfs_root *root = inode->root;
-	struct btrfs_file_extent_item *item;
+	struct btrfs_file_header *header;
 	struct extent_buffer *leaf;
 	struct btrfs_key found_key;
 	struct extent_map *em = NULL;
@@ -7204,8 +7204,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 	}
 
 	leaf = path->nodes[0];
-	item = btrfs_item_ptr(leaf, path->slots[0],
-			      struct btrfs_file_extent_item);
+	header = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
 	btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 	if (found_key.objectid != objectid ||
 	    found_key.type != BTRFS_EXTENT_DATA_KEY) {
@@ -7219,7 +7218,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 		goto next;
 	}
 
-	extent_type = btrfs_file_extent_type(leaf, item);
+	extent_type = btrfs_file_header_type(leaf, header);
 	extent_start = found_key.offset;
 	extent_end = btrfs_file_extent_end(path);
 	if (extent_type == BTRFS_FILE_EXTENT_REG ||
@@ -7232,10 +7231,10 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 				   btrfs_ino(inode));
 			goto out;
 		}
-		trace_btrfs_get_extent_show_fi_regular(inode, leaf, item,
+		trace_btrfs_get_extent_show_fi_regular(inode, leaf, header,
 						       extent_start);
 	} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
-		trace_btrfs_get_extent_show_fi_inline(inode, leaf, item,
+		trace_btrfs_get_extent_show_fi_inline(inode, leaf, header,
 						      path->slots[0],
 						      extent_start);
 	}
@@ -7267,7 +7266,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 		goto insert;
 	}
 
-	btrfs_extent_item_to_extent_map(inode, path, item, em);
+	btrfs_file_header_to_extent_map(inode, path, header, em);
 
 	if (extent_type == BTRFS_FILE_EXTENT_REG ||
 	    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
include/trace/events/btrfs.h +29 -29

122 lines not on this page · raw message

Signature · 1 line
2.52.0
author
#4 lore raw

PATCH 4/7 btrfs: use btrfs_file_header structure for inode.c

In reply to Qu Wenruo

This also involves btrfs_file_extent_inline*() helpers inside file-item.h, thus the changes are covering other files.

---
 fs/btrfs/file-item.h  |   8 +--
 fs/btrfs/inode-item.c |   2 +-
 fs/btrfs/inode.c      | 138 +++++++++++++++++++++---------------------
 fs/btrfs/print-tree.c |  28 ++++-----
 fs/btrfs/reflink.c    |   4 +-
 fs/btrfs/send.c       |  28 ++++-----
 6 files changed, 103 insertions(+), 105 deletions(-)
fs/btrfs/file-item.h +4 -4
index 548d02595a6c..da7e756a13f6 100644
@@ -30,20 +30,20 @@ static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)
  * extent headers.  If a file is compressed on disk, this is the compressed
  * size.
  */
-static inline u32 btrfs_file_extent_inline_item_len(
+static inline u32 btrfs_file_header_inline_item_len(
 						const struct extent_buffer *eb,
 						int nr)
 {
 	return btrfs_item_size(eb, nr) - sizeof(struct btrfs_file_header);
 }
 
-static inline unsigned long btrfs_file_extent_inline_start(
-				const struct btrfs_file_extent_item *e)
+static inline unsigned long btrfs_file_header_inline_start(
+				const struct btrfs_file_header *e)
 {
 	return (unsigned long)e + sizeof(struct btrfs_file_header);
 }
 
-static inline u32 btrfs_file_extent_calc_inline_size(u32 datasize)
+static inline u32 btrfs_file_header_calc_inline_size(u32 datasize)
 {
 	return sizeof(struct btrfs_file_header) + datasize;
 }
fs/btrfs/inode-item.c +1 -1
index 19a00104dc6f..45c3fbf6d299 100644
@@ -594,7 +594,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
 				u32 size = (u32)(new_size - found_key.offset);
 
 				btrfs_set_file_header_ram_bytes(leaf, fh, size);
-				size = btrfs_file_extent_calc_inline_size(size);
+				size = btrfs_file_header_calc_inline_size(size);
 				btrfs_truncate_item(trans, path, size, 1);
 			} else if (!del_item) {
 				/*
fs/btrfs/inode.c +68 -70

336 lines not on this page · raw message

fs/btrfs/print-tree.c +14 -14
index f189bf09ce6a..6b683580d09a 100644
@@ -345,30 +345,30 @@ static void print_extent_csum(const struct extent_buffer *eb, int i)
 
 static void print_file_extent_item(const struct extent_buffer *eb, int i)
 {
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 
-	fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
+	fh = btrfs_item_ptr(eb, i, struct btrfs_file_header);
 	pr_info("\t\tgeneration %llu type %hhu\n",
-		btrfs_file_extent_generation(eb, fi),
-		btrfs_file_extent_type(eb, fi));
+		btrfs_file_header_generation(eb, fh),
+		btrfs_file_header_type(eb, fh));
 
-	if (btrfs_file_extent_type(eb, fi) == BTRFS_FILE_EXTENT_INLINE) {
+	if (btrfs_file_header_type(eb, fh) == BTRFS_FILE_EXTENT_INLINE) {
 		pr_info("\t\tinline extent data size %u ram_bytes %llu compression %hhu\n",
-			btrfs_file_extent_inline_item_len(eb, i),
-			btrfs_file_extent_ram_bytes(eb, fi),
-			btrfs_file_extent_compression(eb, fi));
+			btrfs_file_header_inline_item_len(eb, i),
+			btrfs_file_header_ram_bytes(eb, fh),
+			btrfs_file_header_compression(eb, fh));
 		return;
 	}
 
 	pr_info("\t\textent data disk bytenr %llu nr %llu\n",
-		btrfs_file_extent_disk_bytenr(eb, fi),
-		btrfs_file_extent_disk_num_bytes(eb, fi));
+		btrfs_file_header_disk_bytenr(eb, fh),
+		btrfs_file_header_disk_num_bytes(eb, fh));
 	pr_info("\t\textent data offset %llu nr %llu ram %llu\n",
-		btrfs_file_extent_offset(eb, fi),
-		btrfs_file_extent_num_bytes(eb, fi),
-		btrfs_file_extent_ram_bytes(eb, fi));
+		btrfs_file_header_offset(eb, fh),
+		btrfs_file_header_num_bytes(eb, fh),
+		btrfs_file_header_ram_bytes(eb, fh));
 	pr_info("\t\textent compression %hhu\n",
-		btrfs_file_extent_compression(eb, fi));
+		btrfs_file_header_compression(eb, fh));
 }
 
 static void key_type_string(const struct btrfs_key *key, char *buf, int buf_size)
fs/btrfs/reflink.c +2 -2
index b5fe95baf92e..9f74d4ac920b 100644
@@ -62,8 +62,8 @@ static int copy_inline_to_page(struct btrfs_inode *inode,
 	struct btrfs_fs_info *fs_info = inode->root->fs_info;
 	const u32 block_size = fs_info->sectorsize;
 	const u64 range_end = file_offset + block_size - 1;
-	const size_t inline_size = size - btrfs_file_extent_calc_inline_size(0);
-	char *data_start = inline_data + btrfs_file_extent_calc_inline_size(0);
+	const size_t inline_size = size - btrfs_file_header_calc_inline_size(0);
+	char *data_start = inline_data + btrfs_file_header_calc_inline_size(0);
 	struct extent_changeset *data_reserved = NULL;
 	struct folio *folio = NULL;
 	struct address_space *mapping = inode->vfs_inode.i_mapping;
fs/btrfs/send.c +14 -14
index d8127a7120c2..95b8722cb76e 100644
@@ -1708,7 +1708,7 @@ static int read_symlink(struct btrfs_root *root,
 	int ret;
 	BTRFS_PATH_AUTO_FREE(path);
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u8 type;
 	u8 compression;
 	unsigned long off;
@@ -1739,9 +1739,9 @@ static int read_symlink(struct btrfs_root *root,
 		return -EIO;
 	}
 
-	ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
-			struct btrfs_file_extent_item);
-	type = btrfs_file_extent_type(path->nodes[0], ei);
+	fh = btrfs_item_ptr(path->nodes[0], path->slots[0],
+			struct btrfs_file_header);
+	type = btrfs_file_header_type(path->nodes[0], fh);
 	if (unlikely(type != BTRFS_FILE_EXTENT_INLINE)) {
 		ret = -EUCLEAN;
 		btrfs_crit(root->fs_info,
@@ -1749,7 +1749,7 @@ static int read_symlink(struct btrfs_root *root,
 			   ino, btrfs_root_id(root), type);
 		return ret;
 	}
-	compression = btrfs_file_extent_compression(path->nodes[0], ei);
+	compression = btrfs_file_header_compression(path->nodes[0], fh);
 	if (unlikely(compression != BTRFS_COMPRESS_NONE)) {
 		ret = -EUCLEAN;
 		btrfs_crit(root->fs_info,
@@ -1758,8 +1758,8 @@ static int read_symlink(struct btrfs_root *root,
 		return ret;
 	}
 
-	off = btrfs_file_extent_inline_start(ei);
-	len = btrfs_file_extent_ram_bytes(path->nodes[0], ei);
+	off = btrfs_file_header_inline_start(fh);
+	len = btrfs_file_header_ram_bytes(path->nodes[0], fh);
 
 	return fs_path_add_from_extent_buffer(dest, path->nodes[0], off, len);
 }
@@ -5481,7 +5481,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
 	struct fs_path *fspath;
 	struct extent_buffer *leaf = path->nodes[0];
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u64 ram_bytes;
 	size_t inline_size;
 	int ret;
@@ -5495,9 +5495,9 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
 		return ret;
 
 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
-	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
-	ram_bytes = btrfs_file_extent_ram_bytes(leaf, ei);
-	inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);
+	fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+	ram_bytes = btrfs_file_header_ram_bytes(leaf, fh);
+	inline_size = btrfs_file_header_inline_item_len(leaf, path->slots[0]);
 
 	TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, fspath);
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
@@ -5506,7 +5506,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_UNENCODED_LEN, ram_bytes);
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_UNENCODED_OFFSET, offset - key.offset);
 	ret = btrfs_encoded_io_compression_from_extent(fs_info,
-				btrfs_file_extent_compression(leaf, ei));
+				btrfs_file_header_compression(leaf, fh));
 	if (ret < 0)
 		return ret;
 	TLV_PUT_U32(sctx, BTRFS_SEND_A_COMPRESSION, ret);
@@ -5515,7 +5515,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,
 	if (ret < 0)
 		return ret;
 	read_extent_buffer(leaf, sctx->send_buf + sctx->send_size,
-			   btrfs_file_extent_inline_start(ei), inline_size);
+			   btrfs_file_header_inline_start(fh), inline_size);
 	sctx->send_size += inline_size;
 
 	ret = send_cmd(sctx);
@@ -5652,7 +5652,7 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path,
 		 * the extent that we couldn't clone in clone_range().
 		 */
 		if (is_inline &&
-		    btrfs_file_extent_inline_item_len(leaf,
+		    btrfs_file_header_inline_item_len(leaf,
 						      path->slots[0]) <= len) {
 			return send_encoded_inline_extent(sctx, path, offset,
 							  len);
Signature · 1 line
2.52.0
author
#6 lore raw

PATCH 6/7 btrfs: use btrfs_file_header structure for file.c

In reply to Qu Wenruo

That file is a heavy user of btrfs_file_extent_item structure.

Most call sites are straightforward, some can benefit from a reduced lifespan, e.g. the btrfs_file_extent_item variable inside btrfs_drop_extents() is defined at the function level, but inside the while (1) loop, every time we hit a BTRFS_EXTENT_DATA key the pointer is updated to the corresponding item.

Thus it's safe to move the new btrfs_file_header pointer definition inside the while loop.

---
 fs/btrfs/file.c | 204 ++++++++++++++++++++++++------------------------
 1 file changed, 101 insertions(+), 103 deletions(-)
fs/btrfs/file.c +101 -103
index 69edf5f44bda..a9ac9ae6532d 100644
@@ -140,7 +140,6 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 {
 	struct btrfs_fs_info *fs_info = root->fs_info;
 	struct extent_buffer *leaf;
-	struct btrfs_file_extent_item *fi;
 	struct btrfs_key key;
 	struct btrfs_key new_key;
 	u64 ino = btrfs_ino(inode);
@@ -182,6 +181,8 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 
 	update_refs = (btrfs_root_id(root) != BTRFS_TREE_LOG_OBJECTID);
 	while (1) {
+		struct btrfs_file_header *fh;
+
 		recow = 0;
 		ret = btrfs_lookup_file_extent(trans, root, path, ino,
 					       search_start, modify_tree);
@@ -227,20 +228,20 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 		if (key.type > BTRFS_EXTENT_DATA_KEY || key.offset >= args->end)
 			break;
 
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		extent_type = btrfs_file_extent_type(leaf, fi);
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		extent_type = btrfs_file_header_type(leaf, fh);
 
 		if (extent_type == BTRFS_FILE_EXTENT_REG ||
 		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
-			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
-			num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
-			extent_offset = btrfs_file_extent_offset(leaf, fi);
+			disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
+			num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
+			extent_offset = btrfs_file_header_offset(leaf, fh);
 			extent_end = key.offset +
-				btrfs_file_extent_num_bytes(leaf, fi);
+				btrfs_file_header_num_bytes(leaf, fh);
 		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
 			extent_end = key.offset +
-				btrfs_file_extent_ram_bytes(leaf, fi);
+				btrfs_file_header_ram_bytes(leaf, fh);
 		} else {
 			/* can't happen */
 			BUG();
@@ -300,17 +301,17 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 				break;
 
 			leaf = path->nodes[0];
-			fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
-					    struct btrfs_file_extent_item);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			fh = btrfs_item_ptr(leaf, path->slots[0] - 1,
+					    struct btrfs_file_header);
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							args->start - key.offset);
 
-			fi = btrfs_item_ptr(leaf, path->slots[0],
-					    struct btrfs_file_extent_item);
+			fh = btrfs_item_ptr(leaf, path->slots[0],
+					    struct btrfs_file_header);
 
 			extent_offset += args->start - key.offset;
-			btrfs_set_file_extent_offset(leaf, fi, extent_offset);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_offset(leaf, fh, extent_offset);
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							extent_end - args->start);
 
 			if (update_refs && disk_bytenr > 0) {
@@ -354,8 +355,8 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 			btrfs_set_item_key_safe(trans, path, &new_key);
 
 			extent_offset += args->end - key.offset;
-			btrfs_set_file_extent_offset(leaf, fi, extent_offset);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_offset(leaf, fh, extent_offset);
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							extent_end - args->end);
 			if (update_refs && disk_bytenr > 0)
 				args->bytes_found += args->end - key.offset;
@@ -378,7 +379,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 				break;
 			}
 
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							args->start - key.offset);
 			if (update_refs && disk_bytenr > 0)
 				args->bytes_found += extent_end - args->start;
@@ -509,7 +510,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,
 static bool extent_mergeable(struct extent_buffer *leaf, int slot, u64 objectid,
 			     u64 bytenr, u64 orig_offset, u64 *start, u64 *end)
 {
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	struct btrfs_key key;
 	u64 extent_end;
 
@@ -520,16 +521,16 @@ static bool extent_mergeable(struct extent_buffer *leaf, int slot, u64 objectid,
 	if (key.objectid != objectid || key.type != BTRFS_EXTENT_DATA_KEY)
 		return false;
 
-	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
-	if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG ||
-	    btrfs_file_extent_disk_bytenr(leaf, fi) != bytenr ||
-	    btrfs_file_extent_offset(leaf, fi) != key.offset - orig_offset ||
-	    btrfs_file_extent_compression(leaf, fi) ||
-	    btrfs_file_extent_encryption(leaf, fi) ||
-	    btrfs_file_extent_other_encoding(leaf, fi))
+	fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
+	if (btrfs_file_header_type(leaf, fh) != BTRFS_FILE_EXTENT_REG ||
+	    btrfs_file_header_disk_bytenr(leaf, fh) != bytenr ||
+	    btrfs_file_header_offset(leaf, fh) != key.offset - orig_offset ||
+	    btrfs_file_header_compression(leaf, fh) ||
+	    btrfs_file_header_encryption(leaf, fh) ||
+	    btrfs_file_header_other_encoding(leaf, fh))
 		return false;
 
-	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
+	extent_end = key.offset + btrfs_file_header_num_bytes(leaf, fh);
 	if ((*start && *start != key.offset) || (*end && *end != extent_end))
 		return false;
 
@@ -551,7 +552,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 	struct btrfs_root *root = inode->root;
 	struct extent_buffer *leaf;
 	BTRFS_PATH_AUTO_FREE(path);
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	struct btrfs_ref ref = { 0 };
 	struct btrfs_key key;
 	struct btrfs_key new_key;
@@ -591,23 +592,23 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 		btrfs_abort_transaction(trans, ret);
 		goto out;
 	}
-	fi = btrfs_item_ptr(leaf, path->slots[0],
-			    struct btrfs_file_extent_item);
-	if (unlikely(btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_PREALLOC)) {
+	fh = btrfs_item_ptr(leaf, path->slots[0],
+			    struct btrfs_file_header);
+	if (unlikely(btrfs_file_header_type(leaf, fh) != BTRFS_FILE_EXTENT_PREALLOC)) {
 		ret = -EINVAL;
 		btrfs_abort_transaction(trans, ret);
 		goto out;
 	}
-	extent_end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
+	extent_end = key.offset + btrfs_file_header_num_bytes(leaf, fh);
 	if (unlikely(key.offset > start || extent_end < end)) {
 		ret = -EINVAL;
 		btrfs_abort_transaction(trans, ret);
 		goto out;
 	}
 
-	bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
-	num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
-	orig_offset = key.offset - btrfs_file_extent_offset(leaf, fi);
+	bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
+	num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
+	orig_offset = key.offset - btrfs_file_header_offset(leaf, fh);
 	memcpy(&new_key, &key, sizeof(new_key));
 
 	if (start == key.offset && end < extent_end) {
@@ -618,19 +619,19 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 				     &other_start, &other_end)) {
 			new_key.offset = end;
 			btrfs_set_item_key_safe(trans, path, &new_key);
-			fi = btrfs_item_ptr(leaf, path->slots[0],
-					    struct btrfs_file_extent_item);
-			btrfs_set_file_extent_generation(leaf, fi,
+			fh = btrfs_item_ptr(leaf, path->slots[0],
+					    struct btrfs_file_header);
+			btrfs_set_file_header_generation(leaf, fh,
 							 trans->transid);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							extent_end - end);
-			btrfs_set_file_extent_offset(leaf, fi,
+			btrfs_set_file_header_offset(leaf, fh,
 						     end - orig_offset);
-			fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
-					    struct btrfs_file_extent_item);
-			btrfs_set_file_extent_generation(leaf, fi,
+			fh = btrfs_item_ptr(leaf, path->slots[0] - 1,
+					    struct btrfs_file_header);
+			btrfs_set_file_header_generation(leaf, fh,
 							 trans->transid);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							end - other_start);
 			goto out;
 		}
@@ -642,23 +643,23 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 		if (extent_mergeable(leaf, path->slots[0] + 1,
 				     ino, bytenr, orig_offset,
 				     &other_start, &other_end)) {
-			fi = btrfs_item_ptr(leaf, path->slots[0],
-					    struct btrfs_file_extent_item);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			fh = btrfs_item_ptr(leaf, path->slots[0],
+					    struct btrfs_file_header);
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							start - key.offset);
-			btrfs_set_file_extent_generation(leaf, fi,
+			btrfs_set_file_header_generation(leaf, fh,
 							 trans->transid);
 			path->slots[0]++;
 			new_key.offset = start;
 			btrfs_set_item_key_safe(trans, path, &new_key);
 
-			fi = btrfs_item_ptr(leaf, path->slots[0],
-					    struct btrfs_file_extent_item);
-			btrfs_set_file_extent_generation(leaf, fi,
+			fh = btrfs_item_ptr(leaf, path->slots[0],
+					    struct btrfs_file_header);
+			btrfs_set_file_header_generation(leaf, fh,
 							 trans->transid);
-			btrfs_set_file_extent_num_bytes(leaf, fi,
+			btrfs_set_file_header_num_bytes(leaf, fh,
 							other_end - start);
-			btrfs_set_file_extent_offset(leaf, fi,
+			btrfs_set_file_header_offset(leaf, fh,
 						     start - orig_offset);
 			goto out;
 		}
@@ -680,18 +681,16 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 		}
 
 		leaf = path->nodes[0];
-		fi = btrfs_item_ptr(leaf, path->slots[0] - 1,
-				    struct btrfs_file_extent_item);
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
-		btrfs_set_file_extent_num_bytes(leaf, fi,
+		fh = btrfs_item_ptr(leaf, path->slots[0] - 1, struct btrfs_file_header);
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
+		btrfs_set_file_header_num_bytes(leaf, fh,
 						split - key.offset);
 
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
+		fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
 
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
-		btrfs_set_file_extent_offset(leaf, fi, split - orig_offset);
-		btrfs_set_file_extent_num_bytes(leaf, fi,
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
+		btrfs_set_file_header_offset(leaf, fh, split - orig_offset);
+		btrfs_set_file_header_num_bytes(leaf, fh,
 						extent_end - split);
 
 		ref.action = BTRFS_ADD_DELAYED_REF;
@@ -766,18 +765,16 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,
 		}
 	}
 	if (del_nr == 0) {
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-			   struct btrfs_file_extent_item);
-		btrfs_set_file_extent_type(leaf, fi,
+		fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+		btrfs_set_file_header_type(leaf, fh,
 					   BTRFS_FILE_EXTENT_REG);
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
 	} else {
-		fi = btrfs_item_ptr(leaf, del_slot - 1,
-			   struct btrfs_file_extent_item);
-		btrfs_set_file_extent_type(leaf, fi,
+		fh = btrfs_item_ptr(leaf, del_slot - 1, struct btrfs_file_header);
+		btrfs_set_file_header_type(leaf, fh,
 					   BTRFS_FILE_EXTENT_REG);
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
-		btrfs_set_file_extent_num_bytes(leaf, fi,
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
+		btrfs_set_file_header_num_bytes(leaf, fh,
 						extent_end - key.offset);
 
 		ret = btrfs_del_items(trans, root, path, del_slot, del_nr);
@@ -2056,7 +2053,7 @@ static int btrfs_file_mmap_prepare(struct vm_area_desc *desc)
 static bool hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf,
 			   int slot, u64 start, u64 end)
 {
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	struct btrfs_key key;
 
 	if (slot < 0 || slot >= btrfs_header_nritems(leaf))
@@ -2067,17 +2064,17 @@ static bool hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf
 	    key.type != BTRFS_EXTENT_DATA_KEY)
 		return false;
 
-	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+	fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
 
-	if (btrfs_file_extent_type(leaf, fi) != BTRFS_FILE_EXTENT_REG)
+	if (btrfs_file_header_type(leaf, fh) != BTRFS_FILE_EXTENT_REG)
 		return false;
 
-	if (btrfs_file_extent_disk_bytenr(leaf, fi))
+	if (btrfs_file_header_disk_bytenr(leaf, fh))
 		return false;
 
 	if (key.offset == end)
 		return true;
-	if (key.offset + btrfs_file_extent_num_bytes(leaf, fi) == start)
+	if (key.offset + btrfs_file_header_num_bytes(leaf, fh) == start)
 		return true;
 	return false;
 }
@@ -2089,7 +2086,6 @@ static int fill_holes(struct btrfs_trans_handle *trans,
 	struct btrfs_fs_info *fs_info = trans->fs_info;
 	struct btrfs_root *root = inode->root;
 	struct extent_buffer *leaf;
-	struct btrfs_file_extent_item *fi;
 	struct extent_map *hole_em;
 	struct btrfs_key key;
 	int ret;
@@ -2114,33 +2110,35 @@ static int fill_holes(struct btrfs_trans_handle *trans,
 
 	leaf = path->nodes[0];
 	if (hole_mergeable(inode, leaf, path->slots[0] - 1, offset, end)) {
+		struct btrfs_file_header *fh;
 		u64 num_bytes;
 
 		path->slots[0]--;
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		num_bytes = btrfs_file_extent_num_bytes(leaf, fi) +
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		num_bytes = btrfs_file_header_num_bytes(leaf, fh) +
 			end - offset;
-		btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
-		btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
-		btrfs_set_file_extent_offset(leaf, fi, 0);
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
+		btrfs_set_file_header_num_bytes(leaf, fh, num_bytes);
+		btrfs_set_file_header_ram_bytes(leaf, fh, num_bytes);
+		btrfs_set_file_header_offset(leaf, fh, 0);
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
 		goto out;
 	}
 
 	if (hole_mergeable(inode, leaf, path->slots[0], offset, end)) {
+		struct btrfs_file_header *fh;
 		u64 num_bytes;
 
 		key.offset = offset;
 		btrfs_set_item_key_safe(trans, path, &key);
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		num_bytes = btrfs_file_header_num_bytes(leaf, fh) + end -
 			offset;
-		btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
-		btrfs_set_file_extent_ram_bytes(leaf, fi, num_bytes);
-		btrfs_set_file_extent_offset(leaf, fi, 0);
-		btrfs_set_file_extent_generation(leaf, fi, trans->transid);
+		btrfs_set_file_header_num_bytes(leaf, fh, num_bytes);
+		btrfs_set_file_header_ram_bytes(leaf, fh, num_bytes);
+		btrfs_set_file_header_offset(leaf, fh, 0);
+		btrfs_set_file_header_generation(leaf, fh, trans->transid);
 		goto out;
 	}
 	btrfs_release_path(path);
@@ -2305,7 +2303,7 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,
 {
 	struct btrfs_fs_info *fs_info = trans->fs_info;
 	struct btrfs_root *root = inode->root;
-	struct btrfs_file_extent_item *extent;
+	struct btrfs_file_header *header;
 	struct extent_buffer *leaf;
 	struct btrfs_key key;
 	int slot;
@@ -2332,12 +2330,12 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,
 	write_extent_buffer(leaf, extent_info->extent_buf,
 			    btrfs_item_ptr_offset(leaf, slot),
 			    sizeof(struct btrfs_file_extent_item));
-	extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
-	ASSERT(btrfs_file_extent_type(leaf, extent) != BTRFS_FILE_EXTENT_INLINE);
-	btrfs_set_file_extent_offset(leaf, extent, extent_info->data_offset);
-	btrfs_set_file_extent_num_bytes(leaf, extent, replace_len);
+	header = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
+	ASSERT(btrfs_file_header_type(leaf, header) != BTRFS_FILE_EXTENT_INLINE);
+	btrfs_set_file_header_offset(leaf, header, extent_info->data_offset);
+	btrfs_set_file_header_num_bytes(leaf, header, replace_len);
 	if (extent_info->is_new_extent)
-		btrfs_set_file_extent_generation(leaf, extent, trans->transid);
+		btrfs_set_file_header_generation(leaf, header, trans->transid);
 	btrfs_release_path(path);
 
 	ret = btrfs_inode_set_file_extent_range(inode, extent_info->file_offset,
@@ -3637,7 +3635,7 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)
 
 	while (start < i_size) {
 		struct extent_buffer *leaf = path->nodes[0];
-		struct btrfs_file_extent_item *extent;
+		struct btrfs_file_header *header;
 		u64 extent_end;
 		u8 type;
 
@@ -3693,9 +3691,9 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)
 			 */
 		}
 
-		extent = btrfs_item_ptr(leaf, path->slots[0],
-					struct btrfs_file_extent_item);
-		type = btrfs_file_extent_type(leaf, extent);
+		header = btrfs_item_ptr(leaf, path->slots[0],
+					struct btrfs_file_header);
+		type = btrfs_file_header_type(leaf, header);
 
 		/*
 		 * Can't access the extent's disk_bytenr field if this is an
@@ -3704,7 +3702,7 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)
 		 */
 		if (type == BTRFS_FILE_EXTENT_PREALLOC ||
 		    (type == BTRFS_FILE_EXTENT_REG &&
-		     btrfs_file_extent_disk_bytenr(leaf, extent) == 0)) {
+		     btrfs_file_header_disk_bytenr(leaf, header) == 0)) {
 			/*
 			 * Explicit hole or prealloc extent, search for delalloc.
 			 * A prealloc extent is treated like a hole.
Signature · 1 line
2.52.0
author
#5 lore raw

PATCH 5/7 btrfs: use btrfs_file_header structure for simple usages

In reply to Qu Wenruo

Those usage are pretty straightforward, they are checking the type first, then grabbing values according to the types.

There are only minor changes to btrfs_file_header pointer lifespan, now they are only defined at the minimal scope when possible.

---
 fs/btrfs/backref.c     | 36 +++++++++++++++++++-----------------
 fs/btrfs/ctree.c       | 31 +++++++++++++++++--------------
 fs/btrfs/extent-tree.c | 26 +++++++++++++-------------
 fs/btrfs/fiemap.c      | 30 +++++++++++++++---------------
 fs/btrfs/file-item.c   |  8 ++++----
 fs/btrfs/qgroup.c      | 11 ++++++-----
 fs/btrfs/reflink.c     | 30 +++++++++++++++---------------
 fs/btrfs/relocation.c  | 42 +++++++++++++++++++++---------------------
 8 files changed, 110 insertions(+), 104 deletions(-)
fs/btrfs/backref.c +19 -17
index 78da47a3d00e..068e0c8b8663 100644
@@ -35,10 +35,10 @@ struct extent_inode_elem {
 static int check_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,
 			      const struct btrfs_key *key,
 			      const struct extent_buffer *eb,
-			      const struct btrfs_file_extent_item *fi,
+			      const struct btrfs_file_header *fh,
 			      struct extent_inode_elem **eie)
 {
-	const u64 data_len = btrfs_file_extent_num_bytes(eb, fi);
+	const u64 data_len = btrfs_file_header_num_bytes(eb, fh);
 	u64 offset = key->offset;
 	struct extent_inode_elem *e;
 	const u64 *root_ids;
@@ -46,12 +46,12 @@ static int check_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,
 	bool cached;
 
 	if (!ctx->ignore_extent_item_pos &&
-	    !btrfs_file_extent_compression(eb, fi) &&
-	    !btrfs_file_extent_encryption(eb, fi) &&
-	    !btrfs_file_extent_other_encoding(eb, fi)) {
+	    !btrfs_file_header_compression(eb, fh) &&
+	    !btrfs_file_header_encryption(eb, fh) &&
+	    !btrfs_file_header_other_encoding(eb, fh)) {
 		u64 data_offset;
 
-		data_offset = btrfs_file_extent_offset(eb, fi);
+		data_offset = btrfs_file_header_offset(eb, fh);
 
 		if (ctx->extent_item_pos < data_offset ||
 		    ctx->extent_item_pos >= data_offset + data_len)
@@ -107,7 +107,6 @@ static int find_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,
 {
 	u64 disk_byte;
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *fi;
 	int slot;
 	int nritems;
 	int extent_type;
@@ -120,19 +119,21 @@ static int find_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,
 	 */
 	nritems = btrfs_header_nritems(eb);
 	for (slot = 0; slot < nritems; ++slot) {
+		struct btrfs_file_header *fh;
+
 		btrfs_item_key_to_cpu(eb, &key, slot);
 		if (key.type != BTRFS_EXTENT_DATA_KEY)
 			continue;
-		fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-		extent_type = btrfs_file_extent_type(eb, fi);
+		fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header);
+		extent_type = btrfs_file_header_type(eb, fh);
 		if (extent_type == BTRFS_FILE_EXTENT_INLINE)
 			continue;
 		/* don't skip BTRFS_FILE_EXTENT_PREALLOC, we can handle that */
-		disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+		disk_byte = btrfs_file_header_disk_bytenr(eb, fh);
 		if (disk_byte != ctx->bytenr)
 			continue;
 
-		ret = check_extent_in_eb(ctx, &key, eb, fi, eie);
+		ret = check_extent_in_eb(ctx, &key, eb, fh, eie);
 		if (ret == BTRFS_ITERATE_EXTENT_INODES_STOP || ret < 0)
 			return ret;
 	}
@@ -475,7 +476,6 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,
 	struct extent_buffer *eb;
 	struct btrfs_key key;
 	struct btrfs_key *key_for_search = &ref->key_for_search;
-	struct btrfs_file_extent_item *fi;
 	struct extent_inode_elem *eie = NULL, *old = NULL;
 	u64 disk_byte;
 	u64 wanted_disk_byte = ref->wanted_disk_byte;
@@ -512,6 +512,8 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,
 	}
 
 	while (!ret && count < ref->count) {
+		struct btrfs_file_header *fh;
+
 		eb = path->nodes[0];
 		slot = path->slots[0];
 
@@ -535,12 +537,12 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,
 				ret = btrfs_next_old_leaf(root, path, ctx->time_seq);
 			continue;
 		}
-		fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-		type = btrfs_file_extent_type(eb, fi);
+		fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header);
+		type = btrfs_file_header_type(eb, fh);
 		if (type == BTRFS_FILE_EXTENT_INLINE)
 			goto next;
-		disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
-		data_offset = btrfs_file_extent_offset(eb, fi);
+		disk_byte = btrfs_file_header_disk_bytenr(eb, fh);
+		data_offset = btrfs_file_header_offset(eb, fh);
 
 		if (disk_byte == wanted_disk_byte) {
 			eie = NULL;
@@ -550,7 +552,7 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,
 			else
 				goto next;
 			if (!ctx->skip_inode_ref_list) {
-				ret = check_extent_in_eb(ctx, &key, eb, fi, &eie);
+				ret = check_extent_in_eb(ctx, &key, eb, fh, &eie);
 				if (ret == BTRFS_ITERATE_EXTENT_INODES_STOP ||
 				    ret < 0)
 					break;
fs/btrfs/ctree.c +17 -14
index e859c4355f92..bd65f12b3766 100644
@@ -3847,7 +3847,6 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
 {
 	struct btrfs_key key;
 	struct extent_buffer *leaf;
-	struct btrfs_file_extent_item *fi;
 	u64 extent_len = 0;
 	u32 item_size;
 	int ret;
@@ -3864,9 +3863,11 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
 
 	item_size = btrfs_item_size(leaf, path->slots[0]);
 	if (key.type == BTRFS_EXTENT_DATA_KEY) {
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		extent_len = btrfs_file_extent_num_bytes(leaf, fi);
+		struct btrfs_file_header *fh;
+
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		extent_len = btrfs_file_header_num_bytes(leaf, fh);
 	}
 	btrfs_release_path(path);
 
@@ -3890,9 +3891,11 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans,
 		goto err;
 
 	if (key.type == BTRFS_EXTENT_DATA_KEY) {
-		fi = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		if (extent_len != btrfs_file_extent_num_bytes(leaf, fi))
+		struct btrfs_file_header *fh;
+
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		if (extent_len != btrfs_file_header_num_bytes(leaf, fh))
 			goto err;
 	}
 
@@ -4063,18 +4066,18 @@ void btrfs_truncate_item(struct btrfs_trans_handle *trans,
 
 		if (btrfs_disk_key_type(&disk_key) == BTRFS_EXTENT_DATA_KEY) {
 			unsigned long ptr;
-			struct btrfs_file_extent_item *fi;
+			struct btrfs_file_header *fh;
 
-			fi = btrfs_item_ptr(leaf, slot,
-					    struct btrfs_file_extent_item);
-			fi = (struct btrfs_file_extent_item *)(
-			     (unsigned long)fi - size_diff);
+			fh = btrfs_item_ptr(leaf, slot,
+					    struct btrfs_file_header);
+			fh = (struct btrfs_file_header *)(
+			     (unsigned long)fh - size_diff);
 
-			if (btrfs_file_extent_type(leaf, fi) ==
+			if (btrfs_file_header_type(leaf, fh) ==
 			    BTRFS_FILE_EXTENT_INLINE) {
 				ptr = btrfs_item_ptr_offset(leaf, slot);
 				memmove_extent_buffer(leaf, ptr,
-				      (unsigned long)fi,
+				      (unsigned long)fh,
 				      sizeof(struct btrfs_file_header));
 			}
 		}
fs/btrfs/extent-tree.c +13 -13
index 1dcd69fe97ed..fbb98f5e48a6 100644
@@ -2465,7 +2465,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
 	u64 ref_root;
 	u32 nritems;
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	bool for_reloc = btrfs_header_flag(buf, BTRFS_HEADER_FLAG_RELOC);
 	int i;
 	int action;
@@ -2502,19 +2502,19 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
 			btrfs_item_key_to_cpu(buf, &key, i);
 			if (key.type != BTRFS_EXTENT_DATA_KEY)
 				continue;
-			fi = btrfs_item_ptr(buf, i,
-					    struct btrfs_file_extent_item);
-			if (btrfs_file_extent_type(buf, fi) ==
+			fh = btrfs_item_ptr(buf, i,
+					    struct btrfs_file_header);
+			if (btrfs_file_header_type(buf, fh) ==
 			    BTRFS_FILE_EXTENT_INLINE)
 				continue;
-			ref.bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
+			ref.bytenr = btrfs_file_header_disk_bytenr(buf, fh);
 			if (ref.bytenr == 0)
 				continue;
 
-			ref.num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
+			ref.num_bytes = btrfs_file_header_disk_num_bytes(buf, fh);
 			ref.owning_root = ref_root;
 
-			key.offset -= btrfs_file_extent_offset(buf, fi);
+			key.offset -= btrfs_file_header_offset(buf, fh);
 			btrfs_init_data_ref(&ref, key.objectid, key.offset,
 					    btrfs_root_id(root), for_reloc);
 			if (inc)
@@ -2673,7 +2673,7 @@ static int __exclude_logged_extent(struct btrfs_fs_info *fs_info,
 int btrfs_exclude_logged_extents(struct extent_buffer *eb)
 {
 	struct btrfs_fs_info *fs_info = eb->fs_info;
-	struct btrfs_file_extent_item *item;
+	struct btrfs_file_header *header;
 	struct btrfs_key key;
 	int found_type;
 	int i;
@@ -2686,14 +2686,14 @@ int btrfs_exclude_logged_extents(struct extent_buffer *eb)
 		btrfs_item_key_to_cpu(eb, &key, i);
 		if (key.type != BTRFS_EXTENT_DATA_KEY)
 			continue;
-		item = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
-		found_type = btrfs_file_extent_type(eb, item);
+		header = btrfs_item_ptr(eb, i, struct btrfs_file_header);
+		found_type = btrfs_file_header_type(eb, header);
 		if (found_type == BTRFS_FILE_EXTENT_INLINE)
 			continue;
-		if (btrfs_file_extent_disk_bytenr(eb, item) == 0)
+		if (btrfs_file_header_disk_bytenr(eb, header) == 0)
 			continue;
-		key.objectid = btrfs_file_extent_disk_bytenr(eb, item);
-		key.offset = btrfs_file_extent_disk_num_bytes(eb, item);
+		key.objectid = btrfs_file_header_disk_bytenr(eb, header);
+		key.offset = btrfs_file_header_disk_num_bytes(eb, header);
 		ret = __exclude_logged_extent(fs_info, key.objectid, key.offset);
 		if (ret)
 			break;
fs/btrfs/fiemap.c +15 -15
index f2eaaef8422b..973ee6a89940 100644
@@ -558,7 +558,7 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,
 	const u64 ino = btrfs_ino(inode);
 	struct btrfs_root *root = inode->root;
 	struct extent_buffer *leaf;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	struct btrfs_key key;
 	u64 disk_bytenr;
 	int ret;
@@ -594,8 +594,8 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,
 	 * so first check if we have an inline extent item before checking if we
 	 * have an implicit hole (disk_bytenr == 0).
 	 */
-	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
-	if (btrfs_file_extent_type(leaf, ei) == BTRFS_FILE_EXTENT_INLINE) {
+	fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+	if (btrfs_file_header_type(leaf, fh) == BTRFS_FILE_EXTENT_INLINE) {
 		*last_extent_end_ret = btrfs_file_extent_end(path);
 		return 0;
 	}
@@ -607,7 +607,7 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,
 	 * another hole file extent item as the last item in the previous leaf.
 	 * This is because we merge file extent items that represent holes.
 	 */
-	disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
+	disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
 	while (disk_bytenr == 0) {
 		ret = btrfs_previous_item(root, path, ino, BTRFS_EXTENT_DATA_KEY);
 		if (ret < 0) {
@@ -618,9 +618,9 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,
 			return 0;
 		}
 		leaf = path->nodes[0];
-		ei = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
 	}
 
 	*last_extent_end_ret = btrfs_file_extent_end(path);
@@ -683,7 +683,7 @@ static int extent_fiemap(struct btrfs_inode *inode,
 
 	while (prev_extent_end < range_end) {
 		struct extent_buffer *leaf = path->nodes[0];
-		struct btrfs_file_extent_item *ei;
+		struct btrfs_file_header *fh;
 		struct btrfs_key key;
 		u64 extent_end;
 		u64 extent_len;
@@ -733,16 +733,16 @@ static int extent_fiemap(struct btrfs_inode *inode,
 		}
 
 		extent_len = extent_end - key.offset;
-		ei = btrfs_item_ptr(leaf, path->slots[0],
-				    struct btrfs_file_extent_item);
-		compression = btrfs_file_extent_compression(leaf, ei);
-		extent_type = btrfs_file_extent_type(leaf, ei);
-		extent_gen = btrfs_file_extent_generation(leaf, ei);
+		fh = btrfs_item_ptr(leaf, path->slots[0],
+				    struct btrfs_file_header);
+		compression = btrfs_file_header_compression(leaf, fh);
+		extent_type = btrfs_file_header_type(leaf, fh);
+		extent_gen = btrfs_file_header_generation(leaf, fh);
 
 		if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
-			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
+			disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
 			if (compression == BTRFS_COMPRESS_NONE)
-				extent_offset = btrfs_file_extent_offset(leaf, ei);
+				extent_offset = btrfs_file_header_offset(leaf, fh);
 		}
 
 		if (compression != BTRFS_COMPRESS_NONE)
fs/btrfs/file-item.c +4 -4
index 843fbf245ae8..7c5eb59b1e2e 100644
@@ -1383,18 +1383,18 @@ u64 btrfs_file_extent_end(const struct btrfs_path *path)
 {
 	const struct extent_buffer *leaf = path->nodes[0];
 	const int slot = path->slots[0];
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	struct btrfs_key key;
 	u64 end;
 
 	btrfs_item_key_to_cpu(leaf, &key, slot);
 	ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
-	fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+	fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
 
-	if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE)
+	if (btrfs_file_header_type(leaf, fh) == BTRFS_FILE_EXTENT_INLINE)
 		end = leaf->fs_info->sectorsize;
 	else
-		end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
+		end = key.offset + btrfs_file_header_num_bytes(leaf, fh);
 
 	return end;
 }
fs/btrfs/qgroup.c +6 -5
index 14d393a5853d..57bbe2f67916 100644
@@ -2180,7 +2180,6 @@ int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,
 	int nr = btrfs_header_nritems(eb);
 	int i, extent_type, ret;
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *fi;
 	u64 bytenr, num_bytes;
 
 	/* We can be called directly from walk_up_proc() */
@@ -2188,23 +2187,25 @@ int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,
 		return 0;
 
 	for (i = 0; i < nr; i++) {
+		struct btrfs_file_header *fh;
+
 		btrfs_item_key_to_cpu(eb, &key, i);
 
 		if (key.type != BTRFS_EXTENT_DATA_KEY)
 			continue;
 
-		fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item);
+		fh = btrfs_item_ptr(eb, i, struct btrfs_file_header);
 		/* filter out non qgroup-accountable extents  */
-		extent_type = btrfs_file_extent_type(eb, fi);
+		extent_type = btrfs_file_header_type(eb, fh);
 
 		if (extent_type == BTRFS_FILE_EXTENT_INLINE)
 			continue;
 
-		bytenr = btrfs_file_extent_disk_bytenr(eb, fi);
+		bytenr = btrfs_file_header_disk_bytenr(eb, fh);
 		if (!bytenr)
 			continue;
 
-		num_bytes = btrfs_file_extent_disk_num_bytes(eb, fi);
+		num_bytes = btrfs_file_header_disk_num_bytes(eb, fh);
 
 		ret = btrfs_qgroup_trace_extent(trans, bytenr, num_bytes);
 		if (ret)
fs/btrfs/reflink.c +15 -15
index 9f74d4ac920b..c755671b25c7 100644
@@ -213,16 +213,16 @@ static int clone_copy_inline_extent(struct btrfs_inode *inode,
 			goto copy_to_page;
 		}
 	} else if (i_size_read(&inode->vfs_inode) <= datal) {
-		struct btrfs_file_extent_item *ei;
+		struct btrfs_file_header *fh;
 
-		ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
-				    struct btrfs_file_extent_item);
+		fh = btrfs_item_ptr(path->nodes[0], path->slots[0],
+				    struct btrfs_file_header);
 		/*
 		 * If it's an inline extent replace it with the source inline
 		 * extent, otherwise copy the source inline extent data into
 		 * the respective page at the destination inode.
 		 */
-		if (btrfs_file_extent_type(path->nodes[0], ei) ==
+		if (btrfs_file_header_type(path->nodes[0], fh) ==
 		    BTRFS_FILE_EXTENT_INLINE)
 			goto copy_inline_extent;
 
@@ -369,7 +369,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
 	key.offset = off;
 
 	while (1) {
-		struct btrfs_file_extent_item *extent;
+		struct btrfs_file_header *header;
 		u64 extent_gen;
 		int type;
 		u32 size;
@@ -416,20 +416,20 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
 
 		ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
 
-		extent = btrfs_item_ptr(leaf, slot,
-					struct btrfs_file_extent_item);
-		extent_gen = btrfs_file_extent_generation(leaf, extent);
-		comp = btrfs_file_extent_compression(leaf, extent);
-		type = btrfs_file_extent_type(leaf, extent);
+		header = btrfs_item_ptr(leaf, slot,
+					struct btrfs_file_header);
+		extent_gen = btrfs_file_header_generation(leaf, header);
+		comp = btrfs_file_header_compression(leaf, header);
+		type = btrfs_file_header_type(leaf, header);
 		if (type == BTRFS_FILE_EXTENT_REG ||
 		    type == BTRFS_FILE_EXTENT_PREALLOC) {
-			disko = btrfs_file_extent_disk_bytenr(leaf, extent);
-			diskl = btrfs_file_extent_disk_num_bytes(leaf, extent);
-			datao = btrfs_file_extent_offset(leaf, extent);
-			datal = btrfs_file_extent_num_bytes(leaf, extent);
+			disko = btrfs_file_header_disk_bytenr(leaf, header);
+			diskl = btrfs_file_header_disk_num_bytes(leaf, header);
+			datao = btrfs_file_header_offset(leaf, header);
+			datal = btrfs_file_header_num_bytes(leaf, header);
 		} else if (type == BTRFS_FILE_EXTENT_INLINE) {
 			/* Take upper bound, may be compressed */
-			datal = btrfs_file_extent_ram_bytes(leaf, extent);
+			datal = btrfs_file_header_ram_bytes(leaf, header);
 		}
 
 		/*
fs/btrfs/relocation.c +21 -21

111 lines not on this page · raw message

Signature · 1 line
2.52.0
author
#7 lore raw

PATCH 7/7 btrfs: use btrfs_file_header structure for send.c and tree-log.c

In reply to Qu Wenruo

Mostly a straightforward conversion, some minor notes:

- Some hidden existing btrfs_file_extent_item::type checks There are some call sites that are grabbing @disk_bytenr without checking the @type.

That's because it's already done by the caller.

- Some sizeof(*item) usage
For those call sites inside replay_one_extent(), we have already checked the type is not INLINE, thus it's the full btrfs_file_extent_item structure.

We must keep the old size, not using the sizeof(*header).

---
 fs/btrfs/send.c     | 117 ++++++++++++++++++++++----------------------
 fs/btrfs/tree-log.c |  70 +++++++++++++-------------
 2 files changed, 93 insertions(+), 94 deletions(-)
fs/btrfs/send.c +58 -59
index 95b8722cb76e..4f8888cb4f35 100644
@@ -1554,7 +1554,7 @@ static int find_extent_clone(struct send_ctx *sctx,
 	int extent_type;
 	u64 disk_byte;
 	u64 num_bytes;
-	struct btrfs_file_extent_item *fi;
+	struct btrfs_file_header *fh;
 	struct extent_buffer *eb = path->nodes[0];
 	struct backref_ctx backref_ctx = { 0 };
 	struct btrfs_backref_walk_ctx backref_walk_ctx = { 0 };
@@ -1571,17 +1571,17 @@ static int find_extent_clone(struct send_ctx *sctx,
 	if (data_offset >= ino_size)
 		return 0;
 
-	fi = btrfs_item_ptr(eb, path->slots[0], struct btrfs_file_extent_item);
-	extent_type = btrfs_file_extent_type(eb, fi);
+	fh = btrfs_item_ptr(eb, path->slots[0], struct btrfs_file_header);
+	extent_type = btrfs_file_header_type(eb, fh);
 	if (extent_type == BTRFS_FILE_EXTENT_INLINE)
 		return -ENOENT;
 
-	disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+	disk_byte = btrfs_file_header_disk_bytenr(eb, fh);
 	if (disk_byte == 0)
 		return -ENOENT;
 
-	compressed = btrfs_file_extent_compression(eb, fi);
-	num_bytes = btrfs_file_extent_num_bytes(eb, fi);
+	compressed = btrfs_file_header_compression(eb, fh);
+	num_bytes = btrfs_file_header_num_bytes(eb, fh);
 
 	/*
 	 * Setup the clone roots.
@@ -1603,7 +1603,7 @@ static int find_extent_clone(struct send_ctx *sctx,
 	 * snapshot we can have shared subtrees.
 	 */
 	backref_ctx.backref_owner = btrfs_header_owner(eb);
-	backref_ctx.backref_offset = data_offset - btrfs_file_extent_offset(eb, fi);
+	backref_ctx.backref_offset = data_offset - btrfs_file_header_offset(eb, fh);
 
 	/*
 	 * The last extent of a file may be too large due to page alignment.
@@ -1620,7 +1620,7 @@ static int find_extent_clone(struct send_ctx *sctx,
 	 */
 	backref_walk_ctx.bytenr = disk_byte;
 	if (compressed == BTRFS_COMPRESS_NONE)
-		backref_walk_ctx.extent_item_pos = btrfs_file_extent_offset(eb, fi);
+		backref_walk_ctx.extent_item_pos = btrfs_file_header_offset(eb, fh);
 	backref_walk_ctx.fs_info = fs_info;
 	backref_walk_ctx.cache_lookup = lookup_backref_cache;
 	backref_walk_ctx.cache_store = store_backref_cache;
@@ -5533,7 +5533,7 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,
 	struct fs_path *fspath;
 	struct extent_buffer *leaf = path->nodes[0];
 	struct btrfs_key key;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u64 disk_bytenr, disk_num_bytes;
 	u32 data_offset;
 	struct btrfs_cmd_header *hdr;
@@ -5555,21 +5555,21 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,
 		goto out;
 
 	btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
-	ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
-	disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
-	disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, ei);
+	fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+	disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
+	disk_num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
 
 	TLV_PUT_PATH(sctx, BTRFS_SEND_A_PATH, fspath);
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_FILE_OFFSET, offset);
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_UNENCODED_FILE_LEN,
-		    min(key.offset + btrfs_file_extent_num_bytes(leaf, ei) - offset,
+		    min(key.offset + btrfs_file_header_num_bytes(leaf, fh) - offset,
 			len));
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_UNENCODED_LEN,
-		    btrfs_file_extent_ram_bytes(leaf, ei));
+		    btrfs_file_header_ram_bytes(leaf, fh));
 	TLV_PUT_U64(sctx, BTRFS_SEND_A_UNENCODED_OFFSET,
-		    offset - key.offset + btrfs_file_extent_offset(leaf, ei));
+		    offset - key.offset + btrfs_file_header_offset(leaf, fh));
 	ret = btrfs_encoded_io_compression_from_extent(fs_info,
-				btrfs_file_extent_compression(leaf, ei));
+				btrfs_file_header_compression(leaf, fh));
 	if (ret < 0)
 		goto out;
 	TLV_PUT_U32(sctx, BTRFS_SEND_A_COMPRESSION, ret);
@@ -5630,18 +5630,18 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path,
 {
 	const u64 end = offset + len;
 	struct extent_buffer *leaf = path->nodes[0];
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u64 read_size = max_send_read_size(sctx);
 	u64 sent = 0;
 
 	if (sctx->flags & BTRFS_SEND_FLAG_NO_FILE_DATA)
 		return send_update_extent(sctx, offset, len);
 
-	ei = btrfs_item_ptr(leaf, path->slots[0],
-			    struct btrfs_file_extent_item);
+	fh = btrfs_item_ptr(leaf, path->slots[0],
+			    struct btrfs_file_header);
 	if ((sctx->flags & BTRFS_SEND_FLAG_COMPRESSED) &&
-	    btrfs_file_extent_compression(leaf, ei) != BTRFS_COMPRESS_NONE) {
-		bool is_inline = (btrfs_file_extent_type(leaf, ei) ==
+	    btrfs_file_header_compression(leaf, fh) != BTRFS_COMPRESS_NONE) {
+		bool is_inline = (btrfs_file_header_type(leaf, fh) ==
 				  BTRFS_FILE_EXTENT_INLINE);
 
 		/*
@@ -5657,7 +5657,7 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path,
 			return send_encoded_inline_extent(sctx, path, offset,
 							  len);
 		} else if (!is_inline &&
-			   btrfs_file_extent_disk_num_bytes(leaf, ei) <= len) {
+			   btrfs_file_header_disk_num_bytes(leaf, fh) <= len) {
 			return send_encoded_extent(sctx, path, offset, len);
 		}
 	}
@@ -5866,7 +5866,7 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path,
 	while (true) {
 		struct extent_buffer *leaf = path->nodes[0];
 		int slot = path->slots[0];
-		struct btrfs_file_extent_item *ei;
+		struct btrfs_file_header *fh;
 		u8 type;
 		u64 ext_len;
 		u64 clone_len;
@@ -5892,13 +5892,13 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path,
 		    key.type != BTRFS_EXTENT_DATA_KEY)
 			break;
 
-		ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
-		type = btrfs_file_extent_type(leaf, ei);
+		fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
+		type = btrfs_file_header_type(leaf, fh);
 		if (type == BTRFS_FILE_EXTENT_INLINE) {
-			ext_len = btrfs_file_extent_ram_bytes(leaf, ei);
+			ext_len = btrfs_file_header_ram_bytes(leaf, fh);
 			ext_len = PAGE_ALIGN(ext_len);
 		} else {
-			ext_len = btrfs_file_extent_num_bytes(leaf, ei);
+			ext_len = btrfs_file_header_num_bytes(leaf, fh);
 		}
 
 		if (key.offset + ext_len <= clone_root->offset)
@@ -5934,8 +5934,8 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path,
 			crossed_src_i_size = true;
 		}
 
-		clone_data_offset = btrfs_file_extent_offset(leaf, ei);
-		if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte) {
+		clone_data_offset = btrfs_file_header_offset(leaf, fh);
+		if (btrfs_file_header_disk_bytenr(leaf, fh) == disk_byte) {
 			clone_root->offset = key.offset;
 			if (clone_data_offset < data_offset &&
 				clone_data_offset + ext_len > data_offset) {
@@ -5950,7 +5950,7 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path,
 
 		clone_len = min_t(u64, ext_len, len);
 
-		if (btrfs_file_extent_disk_bytenr(leaf, ei) == disk_byte &&
+		if (btrfs_file_header_disk_bytenr(leaf, fh) == disk_byte &&
 		    clone_data_offset == data_offset) {
 			const u64 src_end = clone_root->offset + clone_len;
 			const u64 sectorsize = SZ_64K;
@@ -6061,7 +6061,7 @@ static int send_write_or_clone(struct send_ctx *sctx,
 	u64 offset = key->offset;
 	u64 end;
 	u64 bs = sctx->send_root->fs_info->sectorsize;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u64 disk_byte;
 	u64 data_offset;
 	u64 num_bytes;
@@ -6121,10 +6121,10 @@ static int send_write_or_clone(struct send_ctx *sctx,
 	return ret;
 
 clone_data:
-	ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
-			    struct btrfs_file_extent_item);
-	disk_byte = btrfs_file_extent_disk_bytenr(path->nodes[0], ei);
-	data_offset = btrfs_file_extent_offset(path->nodes[0], ei);
+	fh = btrfs_item_ptr(path->nodes[0], path->slots[0],
+			    struct btrfs_file_header);
+	disk_byte = btrfs_file_header_disk_bytenr(path->nodes[0], fh);
+	data_offset = btrfs_file_header_offset(path->nodes[0], fh);
 	ret = clone_range(sctx, path, clone_root, disk_byte, data_offset, offset,
 			  num_bytes);
 	sctx->cur_inode_next_write_offset = end;
@@ -6141,7 +6141,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 	struct extent_buffer *eb;
 	int slot;
 	struct btrfs_key found_key;
-	struct btrfs_file_extent_item *ei;
+	struct btrfs_file_header *fh;
 	u64 left_disknr;
 	u64 right_disknr;
 	u64 left_offset;
@@ -6160,16 +6160,15 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 
 	eb = left_path->nodes[0];
 	slot = left_path->slots[0];
-	ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-	left_type = btrfs_file_extent_type(eb, ei);
-
+	fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header);
+	left_type = btrfs_file_header_type(eb, fh);
 	if (left_type != BTRFS_FILE_EXTENT_REG)
 		return 0;
 
-	left_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
-	left_len = btrfs_file_extent_num_bytes(eb, ei);
-	left_offset = btrfs_file_extent_offset(eb, ei);
-	left_gen = btrfs_file_extent_generation(eb, ei);
+	left_disknr = btrfs_file_header_disk_bytenr(eb, fh);
+	left_len = btrfs_file_header_num_bytes(eb, fh);
+	left_offset = btrfs_file_header_offset(eb, fh);
+	left_gen = btrfs_file_header_generation(eb, fh);
 
 	/*
 	 * Following comments will refer to these graphics. L is the left
@@ -6217,17 +6216,17 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 	 */
 	key = found_key;
 	while (key.offset < ekey->offset + left_len) {
-		ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-		right_type = btrfs_file_extent_type(eb, ei);
+		fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header);
+		right_type = btrfs_file_header_type(eb, fh);
 		if (right_type != BTRFS_FILE_EXTENT_REG &&
 		    right_type != BTRFS_FILE_EXTENT_INLINE)
 			return 0;
 
 		if (right_type == BTRFS_FILE_EXTENT_INLINE) {
-			right_len = btrfs_file_extent_ram_bytes(eb, ei);
+			right_len = btrfs_file_header_ram_bytes(eb, fh);
 			right_len = PAGE_ALIGN(right_len);
 		} else {
-			right_len = btrfs_file_extent_num_bytes(eb, ei);
+			right_len = btrfs_file_header_num_bytes(eb, fh);
 		}
 
 		/*
@@ -6249,9 +6248,9 @@ static int is_extent_unchanged(struct send_ctx *sctx,
 		if (right_type == BTRFS_FILE_EXTENT_INLINE)
 			return 0;
 
-		right_disknr = btrfs_file_extent_disk_bytenr(eb, ei);
-		right_offset = btrfs_file_extent_offset(eb, ei);
-		right_gen = btrfs_file_extent_generation(eb, ei);
+		right_disknr = btrfs_file_header_disk_bytenr(eb, fh);
+		right_offset = btrfs_file_header_offset(eb, fh);
+		right_gen = btrfs_file_header_generation(eb, fh);
 
 		left_offset_fixed = left_offset;
 		if (key.offset < ekey->offset) {
@@ -6358,7 +6357,7 @@ static int range_is_hole_in_parent(struct send_ctx *sctx,
 	while (search_start < end) {
 		struct extent_buffer *leaf = path->nodes[0];
 		int slot = path->slots[0];
-		struct btrfs_file_extent_item *fi;
+		struct btrfs_file_header *fh;
 		u64 extent_end;
 
 		if (slot >= btrfs_header_nritems(leaf)) {
@@ -6379,13 +6378,13 @@ static int range_is_hole_in_parent(struct send_ctx *sctx,
 		    key.offset >= end)
 			break;
 
-		fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+		fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
 		extent_end = btrfs_file_extent_end(path);
 		if (extent_end <= start)
 			goto next;
-		if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE)
+		if (btrfs_file_header_type(leaf, fh) == BTRFS_FILE_EXTENT_INLINE)
 			return 0;
-		if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0) {
+		if (btrfs_file_header_disk_bytenr(leaf, fh) == 0) {
 			search_start = extent_end;
 			goto next;
 		}
@@ -6455,12 +6454,12 @@ static int process_extent(struct send_ctx *sctx,
 			goto out_hole;
 		}
 	} else {
-		struct btrfs_file_extent_item *ei;
+		struct btrfs_file_header *fh;
 		u8 type;
 
-		ei = btrfs_item_ptr(path->nodes[0], path->slots[0],
-				    struct btrfs_file_extent_item);
-		type = btrfs_file_extent_type(path->nodes[0], ei);
+		fh = btrfs_item_ptr(path->nodes[0], path->slots[0],
+				    struct btrfs_file_header);
+		type = btrfs_file_header_type(path->nodes[0], fh);
 		if (type == BTRFS_FILE_EXTENT_PREALLOC ||
 		    type == BTRFS_FILE_EXTENT_REG) {
 			/*
@@ -6475,7 +6474,7 @@ static int process_extent(struct send_ctx *sctx,
 			}
 
 			/* Have a hole, just skip it. */
-			if (btrfs_file_extent_disk_bytenr(path->nodes[0], ei) == 0) {
+			if (btrfs_file_header_disk_bytenr(path->nodes[0], fh) == 0) {
 				ret = 0;
 				goto out;
 			}
fs/btrfs/tree-log.c +35 -35

194 lines not on this page · raw message

Signature · 1 line
2.52.0
author
#8 lore raw
In reply to Qu Wenruo

Gentle ping.

I guess the series is too invasive by introducing a new structure just to do the type checks, and require every caller to convert to the new type thus resulting a huge amount of code change.

If that's the concern, I can enhance the existing accessors to do a proper type check for those exclusive members to regular extents.

Thanks,
Qu

Quoted 74 lines · Qu Wenruo

The structure btrfs_file_extent_item is defined that if one file extent is inlined, the data starts after btrfs_file_extent_item::type, aka, overlapping with btrfs_file_extent_item::disk_bytenr and other members.

This makes it harder to understand btrfs on-disk format.

This also requires every user of btrfs_file_extent_item::disk_bytenr and other non-inline members to check btrfs_file_extent_item::type first.

But not all callers are strictly following that, and when access-beyond-boundary happens, we have no built-in checks to catch them.

This series address the problem by:

- Introduce btrfs_file_header structure to define the shared part Initially I'm planning to use ms-extension to define an unnamed structure inside btrfs_file_extent_item, to avoid duplicated definition, but it doesn't work for arm64.

So have to do duplicated definition.

- Introduce btrfs_file_header_*() helpers for the shared members

- Introduce btrfs_file_header_disk_bytenr() for btrfs_file_extent_item This allows using the same btrfs_file_header pointer to access the btrfs_file_extent_item exclusive members, with built-in ASSERT() to catch incorrect types.

- Convert existing btrfs_file_extent_item pointer users to btrfs_file_header
This also reduce the lifespan of those pointers to minimal, e.g. only define them in the minimal scope, even if it means to define such pointer again and again in different scopes.

There are some exceptions:

* On-stack ones are still using btrfs_file_extent_item

* Certain write paths are still using btrfs_file_extent_item pointer Those sites are known to handling non-inlined extents, thus can still use the old pointer, but not recommended anymore.

Qu Wenruo (7):
btrfs: introduce btrfs_file_header structure
btrfs: use btrfs_file_header structure for tree-checker
btrfs: use btrfs_file_header structure for trace events
btrfs: use btrfs_file_header structure for inode.c
btrfs: use btrfs_file_header structure for simple usages
btrfs: use btrfs_file_header structure for file.c
btrfs: use btrfs_file_header structure for send.c and tree-log.c

  fs/btrfs/accessors.h            |  79 +++++++++++++
  fs/btrfs/backref.c              |  36 +++---
  fs/btrfs/ctree.c                |  33 +++---
  fs/btrfs/defrag.c               |   8 +-
  fs/btrfs/extent-tree.c          |  26 ++--
  fs/btrfs/fiemap.c               |  30 ++---
  fs/btrfs/file-item.c            |  26 ++--
  fs/btrfs/file-item.h            |  23 ++--
  fs/btrfs/file.c                 | 204 ++++++++++++++++----------------
  fs/btrfs/inode-item.c           |  47 ++++----
  fs/btrfs/inode.c                | 151 ++++++++++++-----------
  fs/btrfs/print-tree.c           |  28 ++---
  fs/btrfs/qgroup.c               |  11 +-
  fs/btrfs/reflink.c              |  34 +++---
  fs/btrfs/relocation.c           |  42 +++----
  fs/btrfs/send.c                 | 145 +++++++++++------------
  fs/btrfs/tree-checker.c         |  82 ++++++-------
  fs/btrfs/tree-log.c             |  70 +++++------
  include/trace/events/btrfs.h    |  58 ++++-----
  include/uapi/linux/btrfs_tree.h |  61 ++++++----
  20 files changed, 643 insertions(+), 551 deletions(-)