* [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