* [PATCH 0/7] btrfs: introduce seperate structure to avoid
@ 2025-12-26 5:12 Qu Wenruo
2025-12-26 5:12 ` [PATCH 1/7] btrfs: introduce btrfs_file_header structure Qu Wenruo
` (7 more replies)
0 siblings, 8 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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(-)
--
2.52.0
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 1/7] btrfs: introduce btrfs_file_header structure
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 2/7] btrfs: use btrfs_file_header structure for tree-checker Qu Wenruo
` (6 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
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(-)
diff --git a/fs/btrfs/accessors.h b/fs/btrfs/accessors.h
index 78721412951c..1568fd00e7d4 100644
--- a/fs/btrfs/accessors.h
+++ b/fs/btrfs/accessors.h
@@ -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);
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 7267b2502665..e859c4355f92 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -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));
}
}
diff --git a/fs/btrfs/file-item.h b/fs/btrfs/file-item.h
index 5645c5e3abdb..1394ae33fc6d 100644
--- a/fs/btrfs/file-item.h
+++ b/fs/btrfs/file-item.h
@@ -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,
diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c
index c21c21adf61e..7bd2f543fec9 100644
--- a/fs/btrfs/tree-checker.c
+++ b/fs/btrfs/tree-checker.c
@@ -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;
}
diff --git a/include/uapi/linux/btrfs_tree.h b/include/uapi/linux/btrfs_tree.h
index fc29d273845d..4363b55293eb 100644
--- a/include/uapi/linux/btrfs_tree.h
+++ b/include/uapi/linux/btrfs_tree.h
@@ -1065,17 +1065,19 @@ enum {
BTRFS_NR_FILE_EXTENT_TYPES = 3,
};
-struct btrfs_file_extent_item {
- /*
- * transaction id that created this extent
- */
+/*
+ * This is the header part of btrfs_file_extent_item.
+ *
+ * The members are shared by this and btrfs_file_extent_item structure.
+ * @type determines which structure to be utilized.
+ */
+struct btrfs_file_header {
+ /* Transaction id that created this extent. */
__le64 generation;
+
/*
- * max number of bytes to hold this extent in ram
- * when we split a compressed extent we can't know how big
- * each of the resulting pieces will be. So, this is
- * an upper limit on the size of the extent in ram instead of
- * an exact limit.
+ * Number of bytes of the final content (after decompress/
+ * decrypt/decoded).
*/
__le64 ram_bytes;
@@ -1090,29 +1092,44 @@ struct btrfs_file_extent_item {
__u8 encryption;
__le16 other_encoding; /* spare for later use */
- /* are we inline data or a real extent? */
+ /*
+ * Type of the above BTRFS_FILE_EXTENT_* value.
+ *
+ * For INLINE type, the data starts immediately after this structure.
+ */
+ __u8 type;
+
+} __attribute__ ((__packed__));
+
+struct btrfs_file_extent_item {
+ /* The following ones must match btrfs_file_header. */
+ __le64 generation;
+ __le64 ram_bytes;
+ __u8 compression;
+ __u8 encryption;
+ __le16 other_encoding;
__u8 type;
/*
- * disk space consumed by the extent, checksum blocks are included
- * in these numbers
+ * The logical address and length of the file extent, are in byte unit.
+ * Which is after compression/encryption/encoding.
*
- * At this offset in the structure, the inline extent data start.
+ * Doesn't include any checksum (which is stored separately inside csum
+ * tree).
*/
__le64 disk_bytenr;
__le64 disk_num_bytes;
+
/*
- * the logical offset in file blocks (no csums)
- * this extent record is for. This allows a file extent to point
- * into the middle of an existing extent on disk, sharing it
- * between two snapshots (useful if some bytes in the middle of the
- * extent have changed
+ * @offset and @num_bytes are the range inside the final content
+ * (after decompress/decrypt/decoded), and are in byte unit.
+ * This range must be inside btrfs_file_extent_header::ram_bytes.
+ *
+ * This allows a file extent to point into the middle of an existing
+ * extent on disk, sharing it between two snapshots (useful if some
+ * bytes in the middle of the extent have changed).
*/
__le64 offset;
- /*
- * the logical number of file blocks (no csums included). This
- * always reflects the size uncompressed and without encoding.
- */
__le64 num_bytes;
} __attribute__ ((__packed__));
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 2/7] btrfs: use btrfs_file_header structure for tree-checker
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
2025-12-26 5:12 ` [PATCH 1/7] btrfs: introduce btrfs_file_header structure Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 3/7] btrfs: use btrfs_file_header structure for trace events Qu Wenruo
` (5 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
fs/btrfs/accessors.h | 75 +++++++++++++++++++++++++++++++++++++++++
fs/btrfs/tree-checker.c | 74 ++++++++++++++++++++--------------------
2 files changed, 113 insertions(+), 36 deletions(-)
diff --git a/fs/btrfs/accessors.h b/fs/btrfs/accessors.h
index 1568fd00e7d4..672425e3f10a 100644
--- a/fs/btrfs/accessors.h
+++ b/fs/btrfs/accessors.h
@@ -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);
diff --git a/fs/btrfs/tree-checker.c b/fs/btrfs/tree-checker.c
index 7bd2f543fec9..2d8c7587623c 100644
--- a/fs/btrfs/tree-checker.c
+++ b/fs/btrfs/tree-checker.c
@@ -106,8 +106,10 @@ static void file_extent_err(const struct extent_buffer *eb, int slot,
* Return 0 if the btrfs_file_extent_##name is aligned to @alignment
* Else return 1
*/
-#define CHECK_FE_ALIGNED(leaf, slot, fi, name, alignment) \
+#define CHECK_FE_ALIGNED(leaf, slot, fh, name, alignment) \
({ \
+ struct btrfs_file_extent_item *fi = btrfs_file_header_to_item(leaf, fh); \
+ \
if (unlikely(!IS_ALIGNED(btrfs_file_extent_##name((leaf), (fi)), \
(alignment)))) \
file_extent_err((leaf), (slot), \
@@ -119,16 +121,16 @@ static void file_extent_err(const struct extent_buffer *eb, int slot,
static u64 file_extent_end(struct extent_buffer *leaf,
struct btrfs_key *key,
- struct btrfs_file_extent_item *extent)
+ struct btrfs_file_header *header)
{
u64 end;
u64 len;
- if (btrfs_file_extent_type(leaf, extent) == BTRFS_FILE_EXTENT_INLINE) {
- len = btrfs_file_extent_ram_bytes(leaf, extent);
+ if (btrfs_file_header_type(leaf, header) == BTRFS_FILE_EXTENT_INLINE) {
+ len = btrfs_file_header_ram_bytes(leaf, header);
end = ALIGN(key->offset + len, leaf->fs_info->sectorsize);
} else {
- len = btrfs_file_extent_num_bytes(leaf, extent);
+ len = btrfs_file_header_num_bytes(leaf, header);
end = key->offset + len;
}
return end;
@@ -209,7 +211,7 @@ static int check_extent_data_item(struct extent_buffer *leaf,
struct btrfs_key *prev_key)
{
struct btrfs_fs_info *fs_info = leaf->fs_info;
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
u32 sectorsize = fs_info->sectorsize;
u32 item_size = btrfs_item_size(leaf, slot);
u64 extent_end;
@@ -230,7 +232,7 @@ static int check_extent_data_item(struct extent_buffer *leaf,
if (unlikely(!check_prev_ino(leaf, key, slot, prev_key)))
return -EUCLEAN;
- fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
+ fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header);
/*
* Make sure the item contains at least inline header, so the file
@@ -243,11 +245,11 @@ static int check_extent_data_item(struct extent_buffer *leaf,
SZ_4K);
return -EUCLEAN;
}
- if (unlikely(btrfs_file_extent_type(leaf, fi) >=
+ if (unlikely(btrfs_file_header_type(leaf, fh) >=
BTRFS_NR_FILE_EXTENT_TYPES)) {
file_extent_err(leaf, slot,
"invalid type for file extent, have %u expect range [0, %u]",
- btrfs_file_extent_type(leaf, fi),
+ btrfs_file_header_type(leaf, fh),
BTRFS_NR_FILE_EXTENT_TYPES - 1);
return -EUCLEAN;
}
@@ -256,21 +258,21 @@ static int check_extent_data_item(struct extent_buffer *leaf,
* Support for new compression/encryption must introduce incompat flag,
* and must be caught in open_ctree().
*/
- if (unlikely(btrfs_file_extent_compression(leaf, fi) >=
+ if (unlikely(btrfs_file_header_compression(leaf, fh) >=
BTRFS_NR_COMPRESS_TYPES)) {
file_extent_err(leaf, slot,
"invalid compression for file extent, have %u expect range [0, %u]",
- btrfs_file_extent_compression(leaf, fi),
+ btrfs_file_header_compression(leaf, fh),
BTRFS_NR_COMPRESS_TYPES - 1);
return -EUCLEAN;
}
- if (unlikely(btrfs_file_extent_encryption(leaf, fi))) {
+ if (unlikely(btrfs_file_header_encryption(leaf, fh))) {
file_extent_err(leaf, slot,
"invalid encryption for file extent, have %u expect 0",
- btrfs_file_extent_encryption(leaf, fi));
+ btrfs_file_header_encryption(leaf, fh));
return -EUCLEAN;
}
- if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
+ if (btrfs_file_header_type(leaf, fh) == BTRFS_FILE_EXTENT_INLINE) {
/* Inline extent must have 0 as key offset */
if (unlikely(key->offset)) {
file_extent_err(leaf, slot,
@@ -280,43 +282,43 @@ static int check_extent_data_item(struct extent_buffer *leaf,
}
/* Compressed inline extent has no on-disk size, skip it */
- if (btrfs_file_extent_compression(leaf, fi) !=
+ if (btrfs_file_header_compression(leaf, fh) !=
BTRFS_COMPRESS_NONE)
return 0;
/* Uncompressed inline extent size must match item size */
if (unlikely(item_size != sizeof(struct btrfs_file_header) +
- btrfs_file_extent_ram_bytes(leaf, fi))) {
+ btrfs_file_header_ram_bytes(leaf, fh))) {
file_extent_err(leaf, slot,
"invalid ram_bytes for uncompressed inline extent, have %u expect %llu",
item_size, sizeof(struct btrfs_file_header) +
- btrfs_file_extent_ram_bytes(leaf, fi));
+ btrfs_file_header_ram_bytes(leaf, fh));
return -EUCLEAN;
}
return 0;
}
/* Regular or preallocated extent has fixed item size */
- if (unlikely(item_size != sizeof(*fi))) {
+ if (unlikely(item_size != sizeof(struct btrfs_file_extent_item))) {
file_extent_err(leaf, slot,
"invalid item size for reg/prealloc file extent, have %u expect %zu",
- item_size, sizeof(*fi));
+ item_size, sizeof(struct btrfs_file_extent_item));
return -EUCLEAN;
}
- if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fi, ram_bytes, sectorsize) ||
- CHECK_FE_ALIGNED(leaf, slot, fi, disk_bytenr, sectorsize) ||
- CHECK_FE_ALIGNED(leaf, slot, fi, disk_num_bytes, sectorsize) ||
- CHECK_FE_ALIGNED(leaf, slot, fi, offset, sectorsize) ||
- CHECK_FE_ALIGNED(leaf, slot, fi, num_bytes, sectorsize)))
+ if (unlikely(CHECK_FE_ALIGNED(leaf, slot, fh, ram_bytes, sectorsize) ||
+ CHECK_FE_ALIGNED(leaf, slot, fh, disk_bytenr, sectorsize) ||
+ CHECK_FE_ALIGNED(leaf, slot, fh, disk_num_bytes, sectorsize) ||
+ CHECK_FE_ALIGNED(leaf, slot, fh, offset, sectorsize) ||
+ CHECK_FE_ALIGNED(leaf, slot, fh, num_bytes, sectorsize)))
return -EUCLEAN;
/* Catch extent end overflow */
- if (unlikely(check_add_overflow(btrfs_file_extent_num_bytes(leaf, fi),
+ if (unlikely(check_add_overflow(btrfs_file_header_num_bytes(leaf, fh),
key->offset, &extent_end))) {
file_extent_err(leaf, slot,
"extent end overflow, have file offset %llu extent num bytes %llu",
key->offset,
- btrfs_file_extent_num_bytes(leaf, fi));
+ btrfs_file_header_num_bytes(leaf, fh));
return -EUCLEAN;
}
@@ -327,12 +329,12 @@ static int check_extent_data_item(struct extent_buffer *leaf,
if (slot > 0 &&
prev_key->objectid == key->objectid &&
prev_key->type == BTRFS_EXTENT_DATA_KEY) {
- struct btrfs_file_extent_item *prev_fi;
+ struct btrfs_file_header *prev_fh;
u64 prev_end;
- prev_fi = btrfs_item_ptr(leaf, slot - 1,
- struct btrfs_file_extent_item);
- prev_end = file_extent_end(leaf, prev_key, prev_fi);
+ prev_fh = btrfs_item_ptr(leaf, slot - 1,
+ struct btrfs_file_header);
+ prev_end = file_extent_end(leaf, prev_key, prev_fh);
if (unlikely(prev_end > key->offset)) {
file_extent_err(leaf, slot - 1,
"file extent end range (%llu) goes beyond start offset (%llu) of the next file extent",
@@ -349,14 +351,14 @@ static int check_extent_data_item(struct extent_buffer *leaf,
* unexpected behaviors.
*/
if (IS_ENABLED(CONFIG_BTRFS_DEBUG) &&
- btrfs_file_extent_compression(leaf, fi) == BTRFS_COMPRESS_NONE &&
- btrfs_file_extent_disk_bytenr(leaf, fi)) {
- if (WARN_ON(btrfs_file_extent_ram_bytes(leaf, fi) !=
- btrfs_file_extent_disk_num_bytes(leaf, fi)))
+ btrfs_file_header_compression(leaf, fh) == BTRFS_COMPRESS_NONE &&
+ btrfs_file_header_disk_bytenr(leaf, fh)) {
+ if (WARN_ON(btrfs_file_header_ram_bytes(leaf, fh) !=
+ btrfs_file_header_disk_num_bytes(leaf, fh)))
file_extent_err(leaf, slot,
"mismatch ram_bytes (%llu) and disk_num_bytes (%llu) for non-compressed extent",
- btrfs_file_extent_ram_bytes(leaf, fi),
- btrfs_file_extent_disk_num_bytes(leaf, fi));
+ btrfs_file_header_ram_bytes(leaf, fh),
+ btrfs_file_header_disk_num_bytes(leaf, fh));
}
return 0;
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 3/7] btrfs: use btrfs_file_header structure for trace events
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
2025-12-26 5:12 ` [PATCH 1/7] btrfs: introduce btrfs_file_header structure Qu Wenruo
2025-12-26 5:12 ` [PATCH 2/7] btrfs: use btrfs_file_header structure for tree-checker Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 4/7] btrfs: use btrfs_file_header structure for inode.c Qu Wenruo
` (4 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
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(-)
diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index bcc6656ad034..37516d2937fa 100644
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -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);
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 568f0e0ebdf6..843fbf245ae8 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -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 {
diff --git a/fs/btrfs/file-item.h b/fs/btrfs/file-item.h
index 1394ae33fc6d..548d02595a6c 100644
--- a/fs/btrfs/file-item.h
+++ b/fs/btrfs/file-item.h
@@ -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);
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index a864f8c99729..19a00104dc6f 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -408,16 +408,16 @@ int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root
static inline void btrfs_trace_truncate(const struct btrfs_inode *inode,
const struct extent_buffer *leaf,
- const struct btrfs_file_extent_item *fi,
+ const struct btrfs_file_header *fh,
u64 offset, int extent_type, int slot)
{
if (!inode)
return;
if (extent_type == BTRFS_FILE_EXTENT_INLINE)
- trace_btrfs_truncate_show_fi_inline(inode, leaf, fi, slot,
+ trace_btrfs_truncate_show_fi_inline(inode, leaf, fh, slot,
offset);
else
- trace_btrfs_truncate_show_fi_regular(inode, leaf, fi, offset);
+ trace_btrfs_truncate_show_fi_regular(inode, leaf, fh, offset);
}
/*
@@ -445,7 +445,6 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
struct btrfs_fs_info *fs_info = root->fs_info;
BTRFS_PATH_AUTO_FREE(path);
struct extent_buffer *leaf;
- struct btrfs_file_extent_item *fi;
struct btrfs_key key;
struct btrfs_key found_key;
u64 new_size = control->new_size;
@@ -508,10 +507,10 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
}
while (1) {
+ struct btrfs_file_header *fh;
u64 clear_start = 0, clear_len = 0, extent_start = 0;
bool refill_delayed_refs_rsv = false;
- fi = NULL;
leaf = path->nodes[0];
btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
found_type = found_key.type;
@@ -524,16 +523,15 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
item_end = found_key.offset;
if (found_type == BTRFS_EXTENT_DATA_KEY) {
- 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_INLINE)
- item_end +=
- btrfs_file_extent_num_bytes(leaf, fi);
+ item_end += btrfs_file_header_num_bytes(leaf, fh);
else if (extent_type == BTRFS_FILE_EXTENT_INLINE)
- item_end += btrfs_file_extent_ram_bytes(leaf, fi);
+ item_end += btrfs_file_header_ram_bytes(leaf, fh);
- btrfs_trace_truncate(control->inode, leaf, fi,
+ btrfs_trace_truncate(control->inode, leaf, fh,
found_key.offset, extent_type,
path->slots[0]);
item_end--;
@@ -559,28 +557,27 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
u64 num_dec;
clear_start = found_key.offset;
- extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
+ extent_start = btrfs_file_header_disk_bytenr(leaf, fh);
if (!del_item) {
u64 orig_num_bytes =
- btrfs_file_extent_num_bytes(leaf, fi);
+ btrfs_file_header_num_bytes(leaf, fh);
extent_num_bytes = ALIGN(new_size -
found_key.offset,
fs_info->sectorsize);
clear_start = ALIGN(new_size, fs_info->sectorsize);
- btrfs_set_file_extent_num_bytes(leaf, fi,
- extent_num_bytes);
+ btrfs_set_file_header_num_bytes(leaf, fh,
+ extent_num_bytes);
num_dec = (orig_num_bytes - extent_num_bytes);
if (extent_start != 0)
control->sub_bytes += num_dec;
} else {
extent_num_bytes =
- btrfs_file_extent_disk_num_bytes(leaf, fi);
+ btrfs_file_header_disk_num_bytes(leaf, fh);
extent_offset = found_key.offset -
- btrfs_file_extent_offset(leaf, fi);
+ btrfs_file_header_offset(leaf, fh);
- /* FIXME blocksize != 4096 */
- num_dec = btrfs_file_extent_num_bytes(leaf, fi);
+ num_dec = btrfs_file_header_num_bytes(leaf, fh);
if (extent_start != 0)
control->sub_bytes += num_dec;
}
@@ -591,12 +588,12 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
* special encodings
*/
if (!del_item &&
- btrfs_file_extent_encryption(leaf, fi) == 0 &&
- btrfs_file_extent_other_encoding(leaf, fi) == 0 &&
- btrfs_file_extent_compression(leaf, fi) == 0) {
+ btrfs_file_header_encryption(leaf, fh) == 0 &&
+ btrfs_file_header_other_encoding(leaf, fh) == 0 &&
+ btrfs_file_header_compression(leaf, fh) == 0) {
u32 size = (u32)(new_size - found_key.offset);
- btrfs_set_file_extent_ram_bytes(leaf, fi, size);
+ btrfs_set_file_header_ram_bytes(leaf, fh, size);
size = btrfs_file_extent_calc_inline_size(size);
btrfs_truncate_item(trans, path, size, 1);
} else if (!del_item) {
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index e12a1daf3474..127f9e7ef453 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -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) {
diff --git a/include/trace/events/btrfs.h b/include/trace/events/btrfs.h
index 125bdc166bfe..75166fb6738b 100644
--- a/include/trace/events/btrfs.h
+++ b/include/trace/events/btrfs.h
@@ -13,7 +13,7 @@ struct btrfs_root;
struct btrfs_fs_info;
struct btrfs_inode;
struct extent_map;
-struct btrfs_file_extent_item;
+struct btrfs_file_header;
struct btrfs_ordered_extent;
struct btrfs_delayed_ref_node;
struct btrfs_delayed_ref_head;
@@ -352,12 +352,12 @@ TRACE_EVENT(btrfs_handle_em_exist,
);
/* file extent item */
-DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular,
+DECLARE_EVENT_CLASS(btrfs__file_header_regular,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, u64 start),
+ const struct btrfs_file_header *fh, u64 start),
- TP_ARGS(bi, l, fi, start),
+ TP_ARGS(bi, l, fh, start),
TP_STRUCT__entry_btrfs(
__field( u64, root_obj )
@@ -380,13 +380,13 @@ DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular,
__entry->ino = btrfs_ino(bi);
__entry->isize = bi->vfs_inode.i_size;
__entry->disk_isize = bi->disk_i_size;
- __entry->num_bytes = btrfs_file_extent_num_bytes(l, fi);
- __entry->ram_bytes = btrfs_file_extent_ram_bytes(l, fi);
- __entry->disk_bytenr = btrfs_file_extent_disk_bytenr(l, fi);
- __entry->disk_num_bytes = btrfs_file_extent_disk_num_bytes(l, fi);
- __entry->extent_offset = btrfs_file_extent_offset(l, fi);
- __entry->extent_type = btrfs_file_extent_type(l, fi);
- __entry->compression = btrfs_file_extent_compression(l, fi);
+ __entry->num_bytes = btrfs_file_header_num_bytes(l, fh);
+ __entry->ram_bytes = btrfs_file_header_ram_bytes(l, fh);
+ __entry->disk_bytenr = btrfs_file_header_disk_bytenr(l, fh);
+ __entry->disk_num_bytes = btrfs_file_header_disk_num_bytes(l, fh);
+ __entry->extent_offset = btrfs_file_header_offset(l, fh);
+ __entry->extent_type = btrfs_file_header_type(l, fh);
+ __entry->compression = btrfs_file_header_compression(l, fh);
__entry->extent_start = start;
__entry->extent_end = (start + __entry->num_bytes);
),
@@ -407,12 +407,12 @@ DECLARE_EVENT_CLASS(btrfs__file_extent_item_regular,
);
DECLARE_EVENT_CLASS(
- btrfs__file_extent_item_inline,
+ btrfs__file_header_inline,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, int slot, u64 start),
+ const struct btrfs_file_header *fh, int slot, u64 start),
- TP_ARGS(bi, l, fi, slot, start),
+ TP_ARGS(bi, l, fh, slot, start),
TP_STRUCT__entry_btrfs(
__field( u64, root_obj )
@@ -431,10 +431,10 @@ DECLARE_EVENT_CLASS(
__entry->ino = btrfs_ino(bi);
__entry->isize = bi->vfs_inode.i_size;
__entry->disk_isize = bi->disk_i_size;
- __entry->extent_type = btrfs_file_extent_type(l, fi);
- __entry->compression = btrfs_file_extent_compression(l, fi);
+ __entry->extent_type = btrfs_file_header_type(l, fh);
+ __entry->compression = btrfs_file_header_compression(l, fh);
__entry->extent_start = start;
- __entry->extent_end = (start + btrfs_file_extent_ram_bytes(l, fi));
+ __entry->extent_end = (start + btrfs_file_header_ram_bytes(l, fh));
),
TP_printk_btrfs(
@@ -448,39 +448,39 @@ DECLARE_EVENT_CLASS(
);
DEFINE_EVENT(
- btrfs__file_extent_item_regular, btrfs_get_extent_show_fi_regular,
+ btrfs__file_header_regular, btrfs_get_extent_show_fi_regular,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, u64 start),
+ const struct btrfs_file_header *fh, u64 start),
- TP_ARGS(bi, l, fi, start)
+ TP_ARGS(bi, l, fh, start)
);
DEFINE_EVENT(
- btrfs__file_extent_item_regular, btrfs_truncate_show_fi_regular,
+ btrfs__file_header_regular, btrfs_truncate_show_fi_regular,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, u64 start),
+ const struct btrfs_file_header *fh, u64 start),
- TP_ARGS(bi, l, fi, start)
+ TP_ARGS(bi, l, fh, start)
);
DEFINE_EVENT(
- btrfs__file_extent_item_inline, btrfs_get_extent_show_fi_inline,
+ btrfs__file_header_inline, btrfs_get_extent_show_fi_inline,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, int slot, u64 start),
+ const struct btrfs_file_header *fh, int slot, u64 start),
- TP_ARGS(bi, l, fi, slot, start)
+ TP_ARGS(bi, l, fh, slot, start)
);
DEFINE_EVENT(
- btrfs__file_extent_item_inline, btrfs_truncate_show_fi_inline,
+ btrfs__file_header_inline, btrfs_truncate_show_fi_inline,
TP_PROTO(const struct btrfs_inode *bi, const struct extent_buffer *l,
- const struct btrfs_file_extent_item *fi, int slot, u64 start),
+ const struct btrfs_file_header *fh, int slot, u64 start),
- TP_ARGS(bi, l, fi, slot, start)
+ TP_ARGS(bi, l, fh, slot, start)
);
#define show_ordered_flags(flags) \
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 4/7] btrfs: use btrfs_file_header structure for inode.c
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
` (2 preceding siblings ...)
2025-12-26 5:12 ` [PATCH 3/7] btrfs: use btrfs_file_header structure for trace events Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 5/7] btrfs: use btrfs_file_header structure for simple usages Qu Wenruo
` (3 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
This also involves btrfs_file_extent_inline*() helpers inside
file-item.h, thus the changes are covering other files.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
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(-)
diff --git a/fs/btrfs/file-item.h b/fs/btrfs/file-item.h
index 548d02595a6c..da7e756a13f6 100644
--- a/fs/btrfs/file-item.h
+++ b/fs/btrfs/file-item.h
@@ -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;
}
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c
index 19a00104dc6f..45c3fbf6d299 100644
--- a/fs/btrfs/inode-item.c
+++ b/fs/btrfs/inode-item.c
@@ -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) {
/*
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 127f9e7ef453..aa9ce054ab1f 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -469,7 +469,7 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
const u32 sectorsize = trans->fs_info->sectorsize;
char *kaddr;
unsigned long ptr;
- struct btrfs_file_extent_item *ei;
+ struct btrfs_file_header *fh;
int ret;
size_t cur_size = size;
u64 i_size;
@@ -503,35 +503,34 @@ static int insert_inline_extent(struct btrfs_trans_handle *trans,
key.type = BTRFS_EXTENT_DATA_KEY;
key.offset = 0;
- datasize = btrfs_file_extent_calc_inline_size(cur_size);
+ datasize = btrfs_file_header_calc_inline_size(cur_size);
ret = btrfs_insert_empty_item(trans, root, path, &key,
datasize);
if (ret)
goto fail;
}
leaf = path->nodes[0];
- ei = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_file_extent_item);
- btrfs_set_file_extent_generation(leaf, ei, trans->transid);
- btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
- btrfs_set_file_extent_encryption(leaf, ei, 0);
- btrfs_set_file_extent_other_encoding(leaf, ei, 0);
- btrfs_set_file_extent_ram_bytes(leaf, ei, size);
- ptr = btrfs_file_extent_inline_start(ei);
+ fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+ btrfs_set_file_header_generation(leaf, fh, trans->transid);
+ btrfs_set_file_header_type(leaf, fh, BTRFS_FILE_EXTENT_INLINE);
+ btrfs_set_file_header_encryption(leaf, fh, 0);
+ btrfs_set_file_header_other_encoding(leaf, fh, 0);
+ btrfs_set_file_header_ram_bytes(leaf, fh, size);
+ ptr = btrfs_file_header_inline_start(fh);
if (compress_type != BTRFS_COMPRESS_NONE) {
kaddr = kmap_local_folio(compressed_folio, 0);
write_extent_buffer(leaf, kaddr, ptr, compressed_size);
kunmap_local(kaddr);
- btrfs_set_file_extent_compression(leaf, ei,
+ btrfs_set_file_header_compression(leaf, fh,
compress_type);
} else {
struct folio *folio;
folio = filemap_get_folio(inode->vfs_inode.i_mapping, 0);
ASSERT(!IS_ERR(folio));
- btrfs_set_file_extent_compression(leaf, ei, 0);
+ btrfs_set_file_header_compression(leaf, fh, 0);
kaddr = kmap_local_folio(folio, 0);
write_extent_buffer(leaf, kaddr, ptr, size);
kunmap_local(kaddr);
@@ -657,7 +656,7 @@ static noinline int __cow_file_range_inline(struct btrfs_inode *inode,
drop_args.end = fs_info->sectorsize;
drop_args.drop_cache = true;
drop_args.replace_extent = true;
- drop_args.extent_item_size = btrfs_file_extent_calc_inline_size(data_len);
+ drop_args.extent_item_size = btrfs_file_header_calc_inline_size(data_len);
ret = btrfs_drop_extents(trans, root, inode, &drop_args);
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
@@ -1904,7 +1903,7 @@ static int can_nocow_file_extent(struct btrfs_path *path,
const bool is_freespace_inode = btrfs_is_free_space_inode(inode);
struct extent_buffer *leaf = path->nodes[0];
struct btrfs_root *root = inode->root;
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
struct btrfs_root *csum_root;
u64 io_start;
u64 extent_end;
@@ -1913,8 +1912,8 @@ static int can_nocow_file_extent(struct btrfs_path *path,
int ret = 0;
bool nowait = path->nowait;
- 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_INLINE)
goto out;
@@ -1928,27 +1927,27 @@ static int can_nocow_file_extent(struct btrfs_path *path,
* for its subvolume was created, then this implies the extent is shared,
* hence we must COW.
*/
- if (btrfs_file_extent_generation(leaf, fi) <=
+ if (btrfs_file_header_generation(leaf, fh) <=
btrfs_root_last_snapshot(&root->root_item))
goto out;
/* An explicit hole, must COW. */
- if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
+ if (btrfs_file_header_disk_bytenr(leaf, fh) == 0)
goto out;
/* Compressed/encrypted/encoded extents must be COWed. */
- if (btrfs_file_extent_compression(leaf, fi) ||
- btrfs_file_extent_encryption(leaf, fi) ||
- btrfs_file_extent_other_encoding(leaf, fi))
+ if (btrfs_file_header_compression(leaf, fh) ||
+ btrfs_file_header_encryption(leaf, fh) ||
+ btrfs_file_header_other_encoding(leaf, fh))
goto out;
extent_end = btrfs_file_extent_end(path);
- args->file_extent.disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
- args->file_extent.disk_num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
- args->file_extent.ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
- args->file_extent.offset = btrfs_file_extent_offset(leaf, fi);
- args->file_extent.compression = btrfs_file_extent_compression(leaf, fi);
+ args->file_extent.disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
+ args->file_extent.disk_num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
+ args->file_extent.ram_bytes = btrfs_file_header_ram_bytes(leaf, fh);
+ args->file_extent.offset = btrfs_file_header_offset(leaf, fh);
+ args->file_extent.compression = btrfs_file_header_compression(leaf, fh);
/*
* The following checks can be expensive, as they need to take other
@@ -2129,7 +2128,7 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,
while (cur_offset <= end) {
struct btrfs_block_group *nocow_bg = NULL;
struct btrfs_key found_key;
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
struct extent_buffer *leaf;
struct extent_state *cached_state = NULL;
u64 extent_end;
@@ -2201,9 +2200,8 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode,
* Found extent which begins before our range and potentially
* intersect it
*/
- 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 this is triggered then we have a memory corruption. */
ASSERT(extent_type < BTRFS_NR_FILE_EXTENT_TYPES);
if (WARN_ON(extent_type >= BTRFS_NR_FILE_EXTENT_TYPES)) {
@@ -7052,7 +7050,7 @@ static struct dentry *btrfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,
static noinline int uncompress_inline(struct btrfs_path *path,
struct folio *folio,
- struct btrfs_file_extent_item *item)
+ struct btrfs_file_header *header)
{
int ret;
struct extent_buffer *leaf = path->nodes[0];
@@ -7063,13 +7061,13 @@ static noinline int uncompress_inline(struct btrfs_path *path,
unsigned long ptr;
int compress_type;
- compress_type = btrfs_file_extent_compression(leaf, item);
- max_size = btrfs_file_extent_ram_bytes(leaf, item);
- inline_size = btrfs_file_extent_inline_item_len(leaf, path->slots[0]);
+ compress_type = btrfs_file_header_compression(leaf, header);
+ max_size = btrfs_file_header_ram_bytes(leaf, header);
+ inline_size = btrfs_file_header_inline_item_len(leaf, path->slots[0]);
tmp = kmalloc(inline_size, GFP_NOFS);
if (!tmp)
return -ENOMEM;
- ptr = btrfs_file_extent_inline_start(item);
+ ptr = btrfs_file_header_inline_start(header);
read_extent_buffer(leaf, tmp, ptr, inline_size);
@@ -7094,7 +7092,7 @@ static noinline int uncompress_inline(struct btrfs_path *path,
static int read_inline_extent(struct btrfs_path *path, struct folio *folio)
{
const u32 blocksize = path->nodes[0]->fs_info->sectorsize;
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
void *kaddr;
size_t copy_size;
@@ -7103,16 +7101,16 @@ static int read_inline_extent(struct btrfs_path *path, struct folio *folio)
ASSERT(folio_pos(folio) == 0);
- fi = btrfs_item_ptr(path->nodes[0], path->slots[0],
- struct btrfs_file_extent_item);
- if (btrfs_file_extent_compression(path->nodes[0], fi) != BTRFS_COMPRESS_NONE)
- return uncompress_inline(path, folio, fi);
+ fh = btrfs_item_ptr(path->nodes[0], path->slots[0],
+ struct btrfs_file_header);
+ if (btrfs_file_header_compression(path->nodes[0], fh) != BTRFS_COMPRESS_NONE)
+ return uncompress_inline(path, folio, fh);
copy_size = min_t(u64, blocksize,
- btrfs_file_extent_ram_bytes(path->nodes[0], fi));
+ btrfs_file_header_ram_bytes(path->nodes[0], fh));
kaddr = kmap_local_folio(folio, 0);
read_extent_buffer(path->nodes[0], kaddr,
- btrfs_file_extent_inline_start(fi), copy_size);
+ btrfs_file_header_inline_start(fh), copy_size);
kunmap_local(kaddr);
if (copy_size < blocksize)
folio_zero_range(folio, copy_size, blocksize - copy_size);
@@ -7366,7 +7364,7 @@ noinline int can_nocow_extent(struct btrfs_inode *inode, u64 offset, u64 *len,
int ret;
struct extent_buffer *leaf;
struct extent_io_tree *io_tree = &inode->io_tree;
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
struct btrfs_key key;
int found_type;
@@ -7404,8 +7402,8 @@ noinline int can_nocow_extent(struct btrfs_inode *inode, u64 offset, u64 *len,
if (btrfs_file_extent_end(path) <= offset)
return 0;
- fi = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item);
- found_type = btrfs_file_extent_type(leaf, fi);
+ fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);
+ found_type = btrfs_file_header_type(leaf, fh);
nocow_args.start = offset;
nocow_args.end = offset + *len - 1;
@@ -8970,7 +8968,7 @@ static int btrfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
int name_len;
int datasize;
unsigned long ptr;
- struct btrfs_file_extent_item *ei;
+ struct btrfs_file_header *fh;
struct extent_buffer *leaf;
name_len = strlen(symname);
@@ -9020,7 +9018,7 @@ static int btrfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
key.objectid = btrfs_ino(BTRFS_I(inode));
key.type = BTRFS_EXTENT_DATA_KEY;
key.offset = 0;
- datasize = btrfs_file_extent_calc_inline_size(name_len);
+ datasize = btrfs_file_header_calc_inline_size(name_len);
ret = btrfs_insert_empty_item(trans, root, path, &key, datasize);
if (unlikely(ret)) {
btrfs_abort_transaction(trans, ret);
@@ -9030,17 +9028,17 @@ static int btrfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
goto out;
}
leaf = path->nodes[0];
- ei = btrfs_item_ptr(leaf, path->slots[0],
- struct btrfs_file_extent_item);
- btrfs_set_file_extent_generation(leaf, ei, trans->transid);
- btrfs_set_file_extent_type(leaf, ei,
+ fh = btrfs_item_ptr(leaf, path->slots[0],
+ struct btrfs_file_header);
+ btrfs_set_file_header_generation(leaf, fh, trans->transid);
+ btrfs_set_file_header_type(leaf, fh,
BTRFS_FILE_EXTENT_INLINE);
- btrfs_set_file_extent_encryption(leaf, ei, 0);
- btrfs_set_file_extent_compression(leaf, ei, 0);
- btrfs_set_file_extent_other_encoding(leaf, ei, 0);
- btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
+ btrfs_set_file_header_encryption(leaf, fh, 0);
+ btrfs_set_file_header_compression(leaf, fh, 0);
+ btrfs_set_file_header_other_encoding(leaf, fh, 0);
+ btrfs_set_file_header_ram_bytes(leaf, fh, name_len);
- ptr = btrfs_file_extent_inline_start(ei);
+ ptr = btrfs_file_header_inline_start(fh);
write_extent_buffer(leaf, symname, ptr, name_len);
btrfs_free_path(path);
@@ -9392,7 +9390,7 @@ static ssize_t btrfs_encoded_read_inline(
struct extent_io_tree *io_tree = &inode->io_tree;
BTRFS_PATH_AUTO_FREE(path);
struct extent_buffer *leaf;
- struct btrfs_file_extent_item *item;
+ struct btrfs_file_header *header;
u64 ram_bytes;
unsigned long ptr;
void *tmp;
@@ -9415,22 +9413,22 @@ static ssize_t btrfs_encoded_read_inline(
return ret;
}
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);
- ram_bytes = btrfs_file_extent_ram_bytes(leaf, item);
- ptr = btrfs_file_extent_inline_start(item);
+ ram_bytes = btrfs_file_header_ram_bytes(leaf, header);
+ ptr = btrfs_file_header_inline_start(header);
encoded->len = min_t(u64, extent_start + ram_bytes,
inode->vfs_inode.i_size) - iocb->ki_pos;
ret = btrfs_encoded_io_compression_from_extent(fs_info,
- btrfs_file_extent_compression(leaf, item));
+ btrfs_file_header_compression(leaf, header));
if (ret < 0)
return ret;
encoded->compression = ret;
if (encoded->compression) {
size_t inline_size;
- inline_size = btrfs_file_extent_inline_item_len(leaf,
+ inline_size = btrfs_file_header_inline_item_len(leaf,
path->slots[0]);
if (inline_size > count)
return -ENOBUFS;
@@ -10303,7 +10301,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,
while (prev_extent_end < isize) {
struct btrfs_key key;
struct extent_buffer *leaf;
- struct btrfs_file_extent_item *ei;
+ struct btrfs_file_header *fh;
struct btrfs_block_group *bg;
u64 logical_block_start;
u64 physical_block_start;
@@ -10330,9 +10328,9 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,
}
leaf = path->nodes[0];
- 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 (btrfs_file_extent_type(leaf, ei) == BTRFS_FILE_EXTENT_INLINE) {
+ if (btrfs_file_header_type(leaf, fh) == BTRFS_FILE_EXTENT_INLINE) {
/*
* It's unlikely we'll ever actually find ourselves
* here, as a file small enough to fit inline won't be
@@ -10345,27 +10343,27 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,
goto out;
}
- if (btrfs_file_extent_compression(leaf, ei) != BTRFS_COMPRESS_NONE) {
+ if (btrfs_file_header_compression(leaf, fh) != BTRFS_COMPRESS_NONE) {
btrfs_warn(fs_info, "swapfile must not be compressed");
ret = -EINVAL;
goto out;
}
- disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, ei);
+ disk_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
if (disk_bytenr == 0) {
btrfs_warn(fs_info, "swapfile must not have holes");
ret = -EINVAL;
goto out;
}
- logical_block_start = disk_bytenr + btrfs_file_extent_offset(leaf, ei);
- extent_gen = btrfs_file_extent_generation(leaf, ei);
+ logical_block_start = disk_bytenr + btrfs_file_header_offset(leaf, fh);
+ extent_gen = btrfs_file_header_generation(leaf, fh);
prev_extent_end = btrfs_file_extent_end(path);
if (prev_extent_end > isize)
len = isize - key.offset;
else
- len = btrfs_file_extent_num_bytes(leaf, ei);
+ len = btrfs_file_header_num_bytes(leaf, fh);
backref_ctx->curr_leaf_bytenr = leaf->start;
diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
index f189bf09ce6a..6b683580d09a 100644
--- a/fs/btrfs/print-tree.c
+++ b/fs/btrfs/print-tree.c
@@ -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)
diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c
index b5fe95baf92e..9f74d4ac920b 100644
--- a/fs/btrfs/reflink.c
+++ b/fs/btrfs/reflink.c
@@ -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;
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index d8127a7120c2..95b8722cb76e 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -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);
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 5/7] btrfs: use btrfs_file_header structure for simple usages
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
` (3 preceding siblings ...)
2025-12-26 5:12 ` [PATCH 4/7] btrfs: use btrfs_file_header structure for inode.c Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 6/7] btrfs: use btrfs_file_header structure for file.c Qu Wenruo
` (2 subsequent siblings)
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
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(-)
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 78da47a3d00e..068e0c8b8663 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -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;
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index e859c4355f92..bd65f12b3766 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -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));
}
}
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 1dcd69fe97ed..fbb98f5e48a6 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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;
diff --git a/fs/btrfs/fiemap.c b/fs/btrfs/fiemap.c
index f2eaaef8422b..973ee6a89940 100644
--- a/fs/btrfs/fiemap.c
+++ b/fs/btrfs/fiemap.c
@@ -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)
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 843fbf245ae8..7c5eb59b1e2e 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -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;
}
diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 14d393a5853d..57bbe2f67916 100644
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -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)
diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c
index 9f74d4ac920b..c755671b25c7 100644
--- a/fs/btrfs/reflink.c
+++ b/fs/btrfs/reflink.c
@@ -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);
}
/*
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 310b7d817a27..46c6d74e2e2a 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -814,7 +814,7 @@ static int get_new_location(struct inode *reloc_inode, u64 *new_bytenr,
{
struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
BTRFS_PATH_AUTO_FREE(path);
- struct btrfs_file_extent_item *fi;
+ struct btrfs_file_header *fh;
struct extent_buffer *leaf;
int ret;
@@ -831,18 +831,18 @@ static int get_new_location(struct inode *reloc_inode, u64 *new_bytenr,
return -ENOENT;
leaf = path->nodes[0];
- 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);
- BUG_ON(btrfs_file_extent_offset(leaf, fi) ||
- btrfs_file_extent_compression(leaf, fi) ||
- btrfs_file_extent_encryption(leaf, fi) ||
- btrfs_file_extent_other_encoding(leaf, fi));
+ BUG_ON(btrfs_file_header_offset(leaf, fh) ||
+ btrfs_file_header_compression(leaf, fh) ||
+ btrfs_file_header_encryption(leaf, fh) ||
+ btrfs_file_header_other_encoding(leaf, fh));
- if (num_bytes != btrfs_file_extent_disk_num_bytes(leaf, fi))
+ if (num_bytes != btrfs_file_header_disk_num_bytes(leaf, fh))
return -EINVAL;
- *new_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
+ *new_bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
return 0;
}
@@ -858,7 +858,6 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
{
struct btrfs_fs_info *fs_info = root->fs_info;
struct btrfs_key key;
- struct btrfs_file_extent_item *fi;
struct btrfs_inode *inode = NULL;
u64 parent;
u64 bytenr;
@@ -881,18 +880,19 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
nritems = btrfs_header_nritems(leaf);
for (i = 0; i < nritems; i++) {
+ struct btrfs_file_header *fh;
struct btrfs_ref ref = { 0 };
cond_resched();
btrfs_item_key_to_cpu(leaf, &key, i);
if (key.type != BTRFS_EXTENT_DATA_KEY)
continue;
- fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
- if (btrfs_file_extent_type(leaf, fi) ==
+ fh = btrfs_item_ptr(leaf, i, struct btrfs_file_header);
+ if (btrfs_file_header_type(leaf, fh) ==
BTRFS_FILE_EXTENT_INLINE)
continue;
- bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
- num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
+ bytenr = btrfs_file_header_disk_bytenr(leaf, fh);
+ num_bytes = btrfs_file_header_disk_num_bytes(leaf, fh);
if (bytenr == 0)
continue;
if (!in_range(bytenr, rc->block_group->start,
@@ -915,7 +915,7 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
struct extent_state *cached_state = NULL;
end = key.offset +
- btrfs_file_extent_num_bytes(leaf, fi);
+ btrfs_file_header_num_bytes(leaf, fh);
WARN_ON(!IS_ALIGNED(key.offset,
fs_info->sectorsize));
WARN_ON(!IS_ALIGNED(end, fs_info->sectorsize));
@@ -947,9 +947,9 @@ int replace_file_extents(struct btrfs_trans_handle *trans,
break;
}
- btrfs_set_file_extent_disk_bytenr(leaf, fi, new_bytenr);
+ btrfs_set_file_header_disk_bytenr(leaf, fh, new_bytenr);
- key.offset -= btrfs_file_extent_offset(leaf, fi);
+ key.offset -= btrfs_file_header_offset(leaf, fh);
ref.action = BTRFS_ADD_DELAYED_REF;
ref.bytenr = new_bytenr;
ref.num_bytes = num_bytes;
@@ -3250,7 +3250,6 @@ static int delete_v1_space_cache(struct extent_buffer *leaf,
u64 data_bytenr)
{
u64 space_cache_ino;
- struct btrfs_file_extent_item *ei;
struct btrfs_key key;
bool found = false;
int i;
@@ -3259,17 +3258,18 @@ static int delete_v1_space_cache(struct extent_buffer *leaf,
return 0;
for (i = 0; i < btrfs_header_nritems(leaf); i++) {
+ struct btrfs_file_header *fh;
u8 type;
btrfs_item_key_to_cpu(leaf, &key, i);
if (key.type != BTRFS_EXTENT_DATA_KEY)
continue;
- ei = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
- type = btrfs_file_extent_type(leaf, ei);
+ fh = btrfs_item_ptr(leaf, i, struct btrfs_file_header);
+ type = btrfs_file_header_type(leaf, fh);
if ((type == BTRFS_FILE_EXTENT_REG ||
type == BTRFS_FILE_EXTENT_PREALLOC) &&
- btrfs_file_extent_disk_bytenr(leaf, ei) == data_bytenr) {
+ btrfs_file_header_disk_bytenr(leaf, fh) == data_bytenr) {
found = true;
space_cache_ino = key.objectid;
break;
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 6/7] btrfs: use btrfs_file_header structure for file.c
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
` (4 preceding siblings ...)
2025-12-26 5:12 ` [PATCH 5/7] btrfs: use btrfs_file_header structure for simple usages Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2025-12-26 5:12 ` [PATCH 7/7] btrfs: use btrfs_file_header structure for send.c and tree-log.c Qu Wenruo
2026-01-18 2:37 ` [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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.
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
fs/btrfs/file.c | 204 ++++++++++++++++++++++++------------------------
1 file changed, 101 insertions(+), 103 deletions(-)
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 69edf5f44bda..a9ac9ae6532d 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -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.
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* [PATCH 7/7] btrfs: use btrfs_file_header structure for send.c and tree-log.c
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
` (5 preceding siblings ...)
2025-12-26 5:12 ` [PATCH 6/7] btrfs: use btrfs_file_header structure for file.c Qu Wenruo
@ 2025-12-26 5:12 ` Qu Wenruo
2026-01-18 2:37 ` [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2025-12-26 5:12 UTC (permalink / raw)
To: linux-btrfs
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).
Signed-off-by: Qu Wenruo <wqu@suse.com>
---
fs/btrfs/send.c | 117 ++++++++++++++++++++++----------------------
fs/btrfs/tree-log.c | 70 +++++++++++++-------------
2 files changed, 93 insertions(+), 94 deletions(-)
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 95b8722cb76e..4f8888cb4f35 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -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;
}
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 5831754bb01c..f8e70cf94cd1 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -730,21 +730,21 @@ static noinline int replay_one_extent(struct walk_control *wc)
u64 offset;
unsigned long dest_offset;
struct btrfs_key ins;
- struct btrfs_file_extent_item *item;
+ struct btrfs_file_header *header;
struct btrfs_inode *inode = NULL;
int ret = 0;
- item = btrfs_item_ptr(wc->log_leaf, wc->log_slot, struct btrfs_file_extent_item);
- found_type = btrfs_file_extent_type(wc->log_leaf, item);
+ header = btrfs_item_ptr(wc->log_leaf, wc->log_slot, struct btrfs_file_header);
+ found_type = btrfs_file_header_type(wc->log_leaf, header);
if (found_type == BTRFS_FILE_EXTENT_REG ||
found_type == BTRFS_FILE_EXTENT_PREALLOC) {
- extent_end = start + btrfs_file_extent_num_bytes(wc->log_leaf, item);
+ extent_end = start + btrfs_file_header_num_bytes(wc->log_leaf, header);
/* Holes don't take up space. */
- if (btrfs_file_extent_disk_bytenr(wc->log_leaf, item) != 0)
- nbytes = btrfs_file_extent_num_bytes(wc->log_leaf, item);
+ if (btrfs_file_header_disk_bytenr(wc->log_leaf, header) != 0)
+ nbytes = btrfs_file_header_num_bytes(wc->log_leaf, header);
} else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
- nbytes = btrfs_file_extent_ram_bytes(wc->log_leaf, item);
+ nbytes = btrfs_file_header_ram_bytes(wc->log_leaf, header);
extent_end = ALIGN(start + nbytes, fs_info->sectorsize);
} else {
btrfs_abort_log_replay(wc, -EUCLEAN,
@@ -785,7 +785,7 @@ static noinline int replay_one_extent(struct walk_control *wc)
* we already have a pointer to this exact extent,
* we don't have to do anything
*/
- if (memcmp_extent_buffer(wc->log_leaf, &existing, (unsigned long)item,
+ if (memcmp_extent_buffer(wc->log_leaf, &existing, (unsigned long)header,
sizeof(existing)) == 0) {
btrfs_release_path(wc->subvol_path);
goto out;
@@ -821,12 +821,12 @@ static noinline int replay_one_extent(struct walk_control *wc)
*/
/* A hole and NO_HOLES feature enabled, nothing else to do. */
- if (btrfs_file_extent_disk_bytenr(wc->log_leaf, item) == 0 &&
+ if (btrfs_file_header_disk_bytenr(wc->log_leaf, header) == 0 &&
btrfs_fs_incompat(fs_info, NO_HOLES))
goto update_inode;
ret = btrfs_insert_empty_item(trans, root, wc->subvol_path,
- &wc->log_key, sizeof(*item));
+ &wc->log_key, sizeof(struct btrfs_file_extent_item));
if (ret) {
btrfs_abort_log_replay(wc, ret,
"failed to insert item with key " BTRFS_KEY_FMT " root %llu",
@@ -837,7 +837,7 @@ static noinline int replay_one_extent(struct walk_control *wc)
dest_offset = btrfs_item_ptr_offset(wc->subvol_path->nodes[0],
wc->subvol_path->slots[0]);
copy_extent_buffer(wc->subvol_path->nodes[0], wc->log_leaf, dest_offset,
- (unsigned long)item, sizeof(*item));
+ (unsigned long)header, sizeof(struct btrfs_file_extent_item));
/*
* We have an explicit hole and NO_HOLES is not enabled. We have added
@@ -845,15 +845,15 @@ static noinline int replay_one_extent(struct walk_control *wc)
* anything else to do other than update the file extent item range and
* update the inode item.
*/
- if (btrfs_file_extent_disk_bytenr(wc->log_leaf, item) == 0) {
+ if (btrfs_file_header_disk_bytenr(wc->log_leaf, header) == 0) {
btrfs_release_path(wc->subvol_path);
goto update_inode;
}
- ins.objectid = btrfs_file_extent_disk_bytenr(wc->log_leaf, item);
+ ins.objectid = btrfs_file_header_disk_bytenr(wc->log_leaf, header);
ins.type = BTRFS_EXTENT_ITEM_KEY;
- ins.offset = btrfs_file_extent_disk_num_bytes(wc->log_leaf, item);
- offset = wc->log_key.offset - btrfs_file_extent_offset(wc->log_leaf, item);
+ ins.offset = btrfs_file_header_disk_num_bytes(wc->log_leaf, header);
+ offset = wc->log_key.offset - btrfs_file_header_offset(wc->log_leaf, header);
/*
* Manually record dirty extent, as here we did a shallow file extent
@@ -916,12 +916,12 @@ static noinline int replay_one_extent(struct walk_control *wc)
btrfs_release_path(wc->subvol_path);
- if (btrfs_file_extent_compression(wc->log_leaf, item)) {
+ if (btrfs_file_header_compression(wc->log_leaf, header)) {
csum_start = ins.objectid;
csum_end = csum_start + ins.offset;
} else {
- csum_start = ins.objectid + btrfs_file_extent_offset(wc->log_leaf, item);
- csum_end = csum_start + btrfs_file_extent_num_bytes(wc->log_leaf, item);
+ csum_start = ins.objectid + btrfs_file_header_offset(wc->log_leaf, header);
+ csum_end = csum_start + btrfs_file_header_num_bytes(wc->log_leaf, header);
}
ret = btrfs_lookup_csums_list(root->log_root, csum_start, csum_end - 1,
@@ -4761,7 +4761,6 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
u64 logged_isize, struct btrfs_log_ctx *ctx)
{
struct btrfs_root *log = inode->root->log_root;
- struct btrfs_file_extent_item *extent;
struct extent_buffer *src;
int ret;
struct btrfs_key *ins_keys;
@@ -4819,6 +4818,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
dst_index = 0;
for (int i = 0; i < nr; i++) {
+ struct btrfs_file_header *header;
const int src_slot = start_slot + i;
struct btrfs_root *csum_root;
struct btrfs_ordered_sum *sums;
@@ -4835,10 +4835,9 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
if (ins_keys[dst_index].type != BTRFS_EXTENT_DATA_KEY)
goto add_to_batch;
- extent = btrfs_item_ptr(src, src_slot,
- struct btrfs_file_extent_item);
+ header = btrfs_item_ptr(src, src_slot, struct btrfs_file_header);
- is_old_extent = (btrfs_file_extent_generation(src, extent) <
+ is_old_extent = (btrfs_file_header_generation(src, header) <
trans->transid);
/*
@@ -4863,7 +4862,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
goto add_to_batch;
/* Only regular extents have checksums. */
- if (btrfs_file_extent_type(src, extent) != BTRFS_FILE_EXTENT_REG)
+ if (btrfs_file_header_type(src, header) != BTRFS_FILE_EXTENT_REG)
goto add_to_batch;
/*
@@ -4874,19 +4873,19 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
if (is_old_extent)
goto add_to_batch;
- disk_bytenr = btrfs_file_extent_disk_bytenr(src, extent);
+ disk_bytenr = btrfs_file_header_disk_bytenr(src, header);
/* If it's an explicit hole, there are no checksums. */
if (disk_bytenr == 0)
goto add_to_batch;
- disk_num_bytes = btrfs_file_extent_disk_num_bytes(src, extent);
+ disk_num_bytes = btrfs_file_header_disk_num_bytes(src, header);
- if (btrfs_file_extent_compression(src, extent)) {
+ if (btrfs_file_header_compression(src, header)) {
extent_offset = 0;
extent_num_bytes = disk_num_bytes;
} else {
- extent_offset = btrfs_file_extent_offset(src, extent);
- extent_num_bytes = btrfs_file_extent_num_bytes(src, extent);
+ extent_offset = btrfs_file_header_offset(src, header);
+ extent_num_bytes = btrfs_file_header_num_bytes(src, header);
}
csum_root = btrfs_csum_root(trans->fs_info, disk_bytenr);
@@ -4927,6 +4926,7 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
dst_index = 0;
for (int i = 0; i < nr; i++) {
+ struct btrfs_file_header *header;
const int src_slot = start_slot + i;
const int dst_slot = dst_path->slots[0] + dst_index;
struct btrfs_key key;
@@ -4945,11 +4945,11 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
if (key.type != BTRFS_EXTENT_DATA_KEY)
goto copy_item;
- extent = btrfs_item_ptr(src, src_slot,
- struct btrfs_file_extent_item);
+ header = btrfs_item_ptr(src, src_slot,
+ struct btrfs_file_header);
/* See the comment in the previous loop, same logic. */
- if (btrfs_file_extent_generation(src, extent) < trans->transid &&
+ if (btrfs_file_header_generation(src, header) < trans->transid &&
key.offset < i_size &&
inode->last_reflink_trans < trans->transid)
continue;
@@ -5237,19 +5237,19 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
goto out;
if (ret == 0) {
- struct btrfs_file_extent_item *ei;
+ struct btrfs_file_header *fh;
leaf = path->nodes[0];
slot = path->slots[0];
- ei = 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, ei) ==
+ if (btrfs_file_header_type(leaf, fh) ==
BTRFS_FILE_EXTENT_PREALLOC) {
u64 extent_end;
btrfs_item_key_to_cpu(leaf, &key, slot);
extent_end = key.offset +
- btrfs_file_extent_num_bytes(leaf, ei);
+ btrfs_file_header_num_bytes(leaf, fh);
if (extent_end > i_size)
truncate_offset = extent_end;
--
2.52.0
^ permalink raw reply related [flat|nested] 9+ messages in thread
* Re: [PATCH 0/7] btrfs: introduce seperate structure to avoid
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
` (6 preceding siblings ...)
2025-12-26 5:12 ` [PATCH 7/7] btrfs: use btrfs_file_header structure for send.c and tree-log.c Qu Wenruo
@ 2026-01-18 2:37 ` Qu Wenruo
7 siblings, 0 replies; 9+ messages in thread
From: Qu Wenruo @ 2026-01-18 2:37 UTC (permalink / raw)
To: linux-btrfs
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
在 2025/12/26 15:42, 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(-)
>
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2026-01-18 2:37 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2025-12-26 5:12 [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
2025-12-26 5:12 ` [PATCH 1/7] btrfs: introduce btrfs_file_header structure Qu Wenruo
2025-12-26 5:12 ` [PATCH 2/7] btrfs: use btrfs_file_header structure for tree-checker Qu Wenruo
2025-12-26 5:12 ` [PATCH 3/7] btrfs: use btrfs_file_header structure for trace events Qu Wenruo
2025-12-26 5:12 ` [PATCH 4/7] btrfs: use btrfs_file_header structure for inode.c Qu Wenruo
2025-12-26 5:12 ` [PATCH 5/7] btrfs: use btrfs_file_header structure for simple usages Qu Wenruo
2025-12-26 5:12 ` [PATCH 6/7] btrfs: use btrfs_file_header structure for file.c Qu Wenruo
2025-12-26 5:12 ` [PATCH 7/7] btrfs: use btrfs_file_header structure for send.c and tree-log.c Qu Wenruo
2026-01-18 2:37 ` [PATCH 0/7] btrfs: introduce seperate structure to avoid Qu Wenruo
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox