btrfs: introduce seperate structure to avoid
Subsystems (2)
cover btrfs: introduce seperate structure to avoid
The structure btrfs_file_extent_item is defined that if one file extent is inlined, the data starts after btrfs_file_extent_item::type, aka, overlapping with btrfs_file_extent_item::disk_bytenr and other members.
This makes it harder to understand btrfs on-disk format.
This also requires every user of btrfs_file_extent_item::disk_bytenr and other non-inline members to check btrfs_file_extent_item::type first.
But not all callers are strictly following that, and when access-beyond-boundary happens, we have no built-in checks to catch them.
This series address the problem by:
- Introduce btrfs_file_header structure to define the shared part Initially I'm planning to use ms-extension to define an unnamed structure inside btrfs_file_extent_item, to avoid duplicated definition, but it doesn't work for arm64.
So have to do duplicated definition.
- Introduce btrfs_file_header_*() helpers for the shared members
- Introduce btrfs_file_header_disk_bytenr() for btrfs_file_extent_item This allows using the same btrfs_file_header pointer to access the btrfs_file_extent_item exclusive members, with built-in ASSERT() to catch incorrect types.
- Convert existing btrfs_file_extent_item pointer users to btrfs_file_header
This also reduce the lifespan of those pointers to minimal, e.g. only define them in the minimal scope, even if it means to define such pointer again and again in different scopes.
There are some exceptions:
* On-stack ones are still using btrfs_file_extent_item
* Certain write paths are still using btrfs_file_extent_item pointer Those sites are known to handling non-inlined extents, thus can still use the old pointer, but not recommended anymore.
Qu Wenruo (7):
btrfs: introduce btrfs_file_header structure
btrfs: use btrfs_file_header structure for tree-checker
btrfs: use btrfs_file_header structure for trace events
btrfs: use btrfs_file_header structure for inode.c
btrfs: use btrfs_file_header structure for simple usages
btrfs: use btrfs_file_header structure for file.c
btrfs: use btrfs_file_header structure for send.c and tree-log.c
fs/btrfs/accessors.h | 79 +++++++++++++ fs/btrfs/backref.c | 36 +++--- fs/btrfs/ctree.c | 33 +++--- fs/btrfs/defrag.c | 8 +- fs/btrfs/extent-tree.c | 26 ++-- fs/btrfs/fiemap.c | 30 ++--- fs/btrfs/file-item.c | 26 ++-- fs/btrfs/file-item.h | 23 ++-- fs/btrfs/file.c | 204 ++++++++++++++++---------------- fs/btrfs/inode-item.c | 47 ++++---- fs/btrfs/inode.c | 151 ++++++++++++----------- fs/btrfs/print-tree.c | 28 ++--- fs/btrfs/qgroup.c | 11 +- fs/btrfs/reflink.c | 34 +++--- fs/btrfs/relocation.c | 42 +++---- fs/btrfs/send.c | 145 +++++++++++------------ fs/btrfs/tree-checker.c | 82 ++++++------- fs/btrfs/tree-log.c | 70 +++++------ include/trace/events/btrfs.h | 58 ++++----- include/uapi/linux/btrfs_tree.h | 61 ++++++---- 20 files changed, 643 insertions(+), 551 deletions(-)
Signature · 1 line
2.52.0
PATCH 1/7 btrfs: introduce btrfs_file_header structure
Currently we have two major types of btrfs_file_extent_item:
- Inline ones
btrfs_file_extent_item::type is BTRFS_FILE_EXTENT_INLINE, and the inline data starts at btrfs_file_extent_item::disk_bytenr.
- Regular ones
Utilize the full btrfs_file_extent_item structure.
This means we need to use things like
"offsetof(struct btrfs_file_extent_item, disk_bytenr)" to calculate the size of the header part, and always need to check btrfs_file_extent_item::type before utilizing the remaining members.
This increases the possibility of accessing member beyond the item boundary for inlined file extents.
Here introduce a new btrfs_file_header structure to cover the shared part. Originally I'm planning to utilize ms-extension to define an unnamed structure inside btrfs_file_extent_item, but unfortunately that only compiles on x86_64, not on arm64.
Thus this patch goes the safer way by manually define a structure with duplicated members.
--- fs/btrfs/accessors.h | 4 +++ fs/btrfs/ctree.c | 2 +- fs/btrfs/file-item.h | 11 +++--- fs/btrfs/tree-checker.c | 8 ++--- include/uapi/linux/btrfs_tree.h | 61 +++++++++++++++++++++------------ 5 files changed, 52 insertions(+), 34 deletions(-)
fs/btrfs/accessors.h +4 -0
@@ -903,6 +903,10 @@ BTRFS_SETGET_FUNCS(file_extent_encryption, struct btrfs_file_extent_item, BTRFS_SETGET_FUNCS(file_extent_other_encoding, struct btrfs_file_extent_item, other_encoding,16 ); +/* Members before @disk_bytenr must match btrfs_file_header. */ +static_assert (sizeof (struct btrfs_file_header ) == + offsetof(struct btrfs_file_extent_item , disk_bytenr)); +/* btrfs_qgroup_status_item */ BTRFS_SETGET_FUNCS(qgroup_status_generation, struct btrfs_qgroup_status_item, generation,64 );
fs/btrfs/ctree.c +1 -1
@@ -4075,7 +4075,7 @@ void btrfs_truncate_item(struct btrfs_trans_handle *trans, ptr =btrfs_item_ptr_offset (leaf, slot);memmove_extent_buffer (leaf, ptr, (unsigned long )fi, -BTRFS_FILE_EXTENT_INLINE_DATA_START ); +sizeof (struct btrfs_file_header )); } }
fs/btrfs/file-item.h +4 -7
@@ -20,12 +20,9 @@ struct btrfs_ordered_sum;struct btrfs_path ;struct btrfs_inode ; -#define BTRFS_FILE_EXTENT_INLINE_DATA_START \ - (offsetof(struct btrfs_file_extent_item, disk_bytenr)) -static inline u32 BTRFS_MAX_INLINE_DATA_SIZE (const struct btrfs_fs_info *info) { -return BTRFS_MAX_ITEM_SIZE (info) -BTRFS_FILE_EXTENT_INLINE_DATA_START ; +return BTRFS_MAX_ITEM_SIZE (info) -sizeof (struct btrfs_file_header ); }/*
@@ -37,18 +34,18 @@ static inline u32 btrfs_file_extent_inline_item_len(const struct extent_buffer *eb, int nr) { - return btrfs_item_size(eb, nr) - BTRFS_FILE_EXTENT_INLINE_DATA_START; + return btrfs_item_size(eb, nr) - sizeof(struct btrfs_file_header); }static inline unsigned long btrfs_file_extent_inline_start (const struct btrfs_file_extent_item *e) { -return (unsigned long )e +BTRFS_FILE_EXTENT_INLINE_DATA_START ; +return (unsigned long )e +sizeof (struct btrfs_file_header ); }static inline u32 btrfs_file_extent_calc_inline_size (u32 datasize) { -return BTRFS_FILE_EXTENT_INLINE_DATA_START + datasize; +return sizeof (struct btrfs_file_header ) + datasize; } int btrfs_del_csums(struct btrfs_trans_handle *trans,
fs/btrfs/tree-checker.c +4 -4
@@ -236,10 +236,10 @@ static int check_extent_data_item(struct extent_buffer *leaf,* Make sure the item contains at least inline header, so the file * extent type is not some garbage. */ -if (unlikely (item_size <BTRFS_FILE_EXTENT_INLINE_DATA_START )) { +if (unlikely (item_size <sizeof (struct btrfs_file_header ))) {file_extent_err (leaf, slot,"invalid item size, have %u expect [%zu, %u)" , - item_size,BTRFS_FILE_EXTENT_INLINE_DATA_START , + item_size,sizeof (struct btrfs_file_header ),SZ_4K );return -EUCLEAN ; }
@@ -285,11 +285,11 @@ static int check_extent_data_item(struct extent_buffer *leaf,return 0 ;/* Uncompressed inline extent size must match item size */ -if (unlikely (item_size !=BTRFS_FILE_EXTENT_INLINE_DATA_START + +if (unlikely (item_size !=sizeof (struct btrfs_file_header ) +btrfs_file_extent_ram_bytes (leaf, fi))) {file_extent_err (leaf, slot,"invalid ram_bytes for uncompressed inline extent, have %u expect %llu" , - item_size,BTRFS_FILE_EXTENT_INLINE_DATA_START + + item_size,sizeof (struct btrfs_file_header ) +btrfs_file_extent_ram_bytes (leaf, fi));return -EUCLEAN ; }
include/uapi/linux/btrfs_tree.h +39 -22
85 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH 2/7 btrfs: use btrfs_file_header structure for tree-checker
In reply to Qu WenruoThis introduces the following accessors:
- btrfs_file_header members accessors
The usual eb and on-stack versions.
- btrfs_file_extent_item exclusive members accessors through btrfs_file_header
This will do the extra type casting with proper type checks to make sure (by ASSERT()) that the type is not BTRFS_FILE_EXTENT_INLINE.
This should help us to catch unsafe file extent item access.
In short, there should only be two ways to access btrfs_file_extent_item exclusive members:
- Use btrfs_file_header_*() helpers
This should be the most common ones.
- Use btrfs_file_header_to_item() helper, then the usual btrfs_file_extent_*() helpers
This is less recommended.
Tree-checker is the first one to migrate to the btrfs_file_header structure, and most call sites are migrated to use btrfs_file_header_*() helpers.
--- fs/btrfs/accessors.h | 75 +++++++++++++++++++++++++++++++++++++++++ fs/btrfs/tree-checker.c | 74 ++++++++++++++++++++-------------------- 2 files changed, 113 insertions(+), 36 deletions(-)
fs/btrfs/accessors.h +75 -0
@@ -864,6 +864,81 @@ BTRFS_SETGET_STACK_FUNCS(super_uuid_tree_generation, struct btrfs_super_block, BTRFS_SETGET_STACK_FUNCS(super_nr_global_roots, struct btrfs_super_block, nr_global_roots,64 ); +/* struct btrfs_file_header */ +BTRFS_SETGET_STACK_FUNCS (stack_file_header_generation, + struct btrfs_file_header, generation, 64); +BTRFS_SETGET_STACK_FUNCS (stack_file_header_ram_bytes, + struct btrfs_file_header, ram_bytes, 64); +BTRFS_SETGET_STACK_FUNCS (stack_file_header_compression, + struct btrfs_file_header, compression, 8); +BTRFS_SETGET_STACK_FUNCS (stack_file_header_encryption, + struct btrfs_file_header, encryption, 8); +BTRFS_SETGET_STACK_FUNCS (stack_file_header_other_encoding, + struct btrfs_file_header, other_encoding, 16); +BTRFS_SETGET_STACK_FUNCS (stack_file_header_type, + struct btrfs_file_header, type, 8); +BTRFS_SETGET_FUNCS(file_header_generation, struct btrfs_file_header, + generation,64 ); +BTRFS_SETGET_FUNCS(file_header_ram_bytes, struct btrfs_file_header, + ram_bytes,64 ); +BTRFS_SETGET_FUNCS(file_header_compression, struct btrfs_file_header, + compression,8 ); +BTRFS_SETGET_FUNCS(file_header_encryption, struct btrfs_file_header, + encryption,8 ); +BTRFS_SETGET_FUNCS(file_header_other_encoding, struct btrfs_file_header, + other_encoding,16 ); +BTRFS_SETGET_FUNCS(file_header_type, struct btrfs_file_header, + type,8 ); + +/* +* Safely convert a file_header pointer to a file_extent_item one, with +* extra type checks. +*/ +static inline struct btrfs_file_extent_item * +btrfs_file_header_to_item (const struct extent_buffer *leaf, +const struct btrfs_file_header *header) +{ +ASSERT (btrfs_file_header_type (leaf, header) !=BTRFS_FILE_EXTENT_INLINE ); +return (struct btrfs_file_extent_item *)header; +} + +/* +* The extra ones are to access btrfs_file_extent_item exclusive members, which +* needs to check btrfs_file_header::type first to make sure it's not an +* inlined one. +* Or such access can lead to out-of-boundary access. +* +* The input pointer should always be a btrfs_file_header pointer, and the type +* casting is done internally with proper type ASSERT(). +*/ +#define BTRFS_SETGET_FILE_ITEM_FUNCS (name, member, bits) \ +static inline u##bits btrfs_##name(const struct extent_buffer *eb, \ + const struct btrfs_file_header *header) \ +{ \ + struct btrfs_file_extent_item *item = \ + btrfs_file_header_to_item(eb, header); \ + \ + return btrfs_get_##bits(eb, item, \ + offsetof(struct btrfs_file_extent_item, \ + member)); \ +} \ +static inline void btrfs_set_##name(const struct extent_buffer *eb, \ + const struct btrfs_file_header *header, \ + u##bits val) \ +{ \ + struct btrfs_file_extent_item *item = \ + btrfs_file_header_to_item(eb, header); \ + \ + return btrfs_set_##bits(eb, item, \ + offsetof(struct btrfs_file_extent_item, \ + member), val); \ +} + +BTRFS_SETGET_FILE_ITEM_FUNCS (file_header_disk_bytenr, disk_bytenr,64 ); +BTRFS_SETGET_FILE_ITEM_FUNCS (file_header_disk_num_bytes, disk_num_bytes,64 ); +BTRFS_SETGET_FILE_ITEM_FUNCS (file_header_offset, offset,64 ); +BTRFS_SETGET_FILE_ITEM_FUNCS (file_header_num_bytes, num_bytes,64 ); +/* struct btrfs_file_extent_item */ BTRFS_SETGET_STACK_FUNCS(stack_file_extent_type, struct btrfs_file_extent_item, type,8 );
fs/btrfs/tree-checker.c +38 -36
177 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH 3/7 btrfs: use btrfs_file_header structure for trace events
In reply to Qu WenruoThe trace event class btrfs__file_extent_item_* can benefit from the extra strict checks from btrfs_file_header structure.
This change involves the following call sites:
- defrag_get_extent()
Move the btrfs_file_header pointer to the nearest scope of usage. This reduces the lifespan of such variable.
- Rename btrfs_extent_item_to_extent_map()
To btrfs_file_header_to_extent_map(), and accept a btrfs_file_header pointer instead.
- Make btrfs_trace_truncate() to accept a btrfs_file_header pointer And do the proper type casting for non-inline extents.
- btrfs_truncate_inode_items()
This is a little tricky related to scope change of btrfs_file_header.
The original loop always initialize @fi to NULL for each loop, and assign it when hitting a BTRFS_EXTENT_DATA_KEY.
But if we didn't hit an BTRFS_EXTENT_DATA_KEY then we exit the loop. So we do not need to define @fi inside the function, can move it into the while (1) loop, and only initialize it after we hitting an BTRFS_EXTENT_DATA_KEY.
- btrfs_get_extent()
Pretty straightforward.
--- fs/btrfs/defrag.c | 8 ++--- fs/btrfs/file-item.c | 18 +++++------ fs/btrfs/file-item.h | 4 +-- fs/btrfs/inode-item.c | 45 +++++++++++++--------------- fs/btrfs/inode.c | 13 ++++---- include/trace/events/btrfs.h | 58 ++++++++++++++++++------------------ 6 files changed, 71 insertions(+), 75 deletions(-)
fs/btrfs/defrag.c +4 -4
@@ -608,7 +608,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, u64 start, u64 newer_than) {struct btrfs_root *root = inode->root; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;BTRFS_PATH_AUTO_RELEASE (path);struct extent_map *em;struct btrfs_key key;
@@ -697,8 +697,8 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,break ; } - fi =btrfs_item_ptr (path.nodes[0 ], path.slots[0 ], - struct btrfs_file_extent_item); + fh =btrfs_item_ptr (path.nodes[0 ], path.slots[0 ], + struct btrfs_file_header); extent_end =btrfs_file_extent_end (&path);/*
@@ -711,7 +711,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, goto next;/* Now this extent covers @start, convert it to em */ -btrfs_extent_item_to_extent_map (inode, &path, fi, em); +btrfs_file_header_to_extent_map (inode, &path, fh, em);break ; next: ret =btrfs_next_item (root, &path);
fs/btrfs/file-item.c +9 -9
@@ -1311,9 +1311,9 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,return ret; } -void btrfs_extent_item_to_extent_map (struct btrfs_inode *inode, +void btrfs_file_header_to_extent_map (struct btrfs_inode *inode,const struct btrfs_path *path, -const struct btrfs_file_extent_item *fi, +const struct btrfs_file_header *fh,struct extent_map *em) {struct btrfs_fs_info *fs_info = inode->root->fs_info;
@@ -1322,16 +1322,16 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,const int slot = path->slots[0 ];struct btrfs_key key;u64 extent_start; -u8 type =btrfs_file_extent_type (leaf, fi); -int compress_type =btrfs_file_extent_compression (leaf, fi); +u8 type =btrfs_file_header_type (leaf, fh); +int compress_type =btrfs_file_header_compression (leaf, fh);btrfs_item_key_to_cpu (leaf, &key, slot); extent_start = key.offset; - em->ram_bytes =btrfs_file_extent_ram_bytes (leaf, fi); - em->generation =btrfs_file_extent_generation (leaf, fi); + em->ram_bytes =btrfs_file_header_ram_bytes (leaf, fh); + em->generation =btrfs_file_header_generation (leaf, fh);if (type ==BTRFS_FILE_EXTENT_REG || type ==BTRFS_FILE_EXTENT_PREALLOC ) { -const u64 disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, fi); +const u64 disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh); em->start = extent_start; em->len =btrfs_file_extent_end (path) - extent_start;
@@ -1342,8 +1342,8 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,return ; } em->disk_bytenr = disk_bytenr; - em->disk_num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); - em->offset =btrfs_file_extent_offset (leaf, fi); + em->disk_num_bytes =btrfs_file_header_disk_num_bytes (leaf, fh); + em->offset =btrfs_file_header_offset (leaf, fh);if (compress_type !=BTRFS_COMPRESS_NONE ) {btrfs_extent_map_set_compression (em, compress_type); }else {
fs/btrfs/file-item.h +2 -2
@@ -71,9 +71,9 @@ int btrfs_lookup_csums_list(struct btrfs_root *root, u64 start, u64 end,int btrfs_lookup_csums_bitmap (struct btrfs_root *root,struct btrfs_path *path,u64 start,u64 end,u8 *csum_buf,unsigned long *csum_bitmap); -void btrfs_extent_item_to_extent_map (struct btrfs_inode *inode, +void btrfs_file_header_to_extent_map (struct btrfs_inode *inode,const struct btrfs_path *path, -const struct btrfs_file_extent_item *fi, +const struct btrfs_file_header *fh,struct extent_map *em);int btrfs_inode_clear_file_extent_range (struct btrfs_inode *inode,u64 start,u64 len);
fs/btrfs/inode-item.c +21 -24
110 lines not on this page · raw message
fs/btrfs/inode.c +6 -7
@@ -7147,7 +7147,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,int extent_type =-1 ;struct btrfs_path *path =NULL ;struct btrfs_root *root = inode->root; -struct btrfs_file_extent_item *item; +struct btrfs_file_header *header;struct extent_buffer *leaf;struct btrfs_key found_key;struct extent_map *em =NULL ;
@@ -7204,8 +7204,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, } leaf = path->nodes[0 ]; - item =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); + header = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header);btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]);if (found_key.objectid != objectid || found_key.type !=BTRFS_EXTENT_DATA_KEY ) {
@@ -7219,7 +7218,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, goto next; } - extent_type =btrfs_file_extent_type (leaf, item); + extent_type =btrfs_file_header_type (leaf, header); extent_start = found_key.offset; extent_end =btrfs_file_extent_end (path); if (extent_type == BTRFS_FILE_EXTENT_REG ||
@@ -7232,10 +7231,10 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, btrfs_ino(inode)); goto out; } -trace_btrfs_get_extent_show_fi_regular (inode, leaf, item, +trace_btrfs_get_extent_show_fi_regular (inode, leaf, header, extent_start); }else if (extent_type ==BTRFS_FILE_EXTENT_INLINE ) { -trace_btrfs_get_extent_show_fi_inline (inode, leaf, item, +trace_btrfs_get_extent_show_fi_inline (inode, leaf, header, path->slots[0 ], extent_start); }
@@ -7267,7 +7266,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, goto insert; } -btrfs_extent_item_to_extent_map (inode, path, item, em); +btrfs_file_header_to_extent_map (inode, path, header, em);if (extent_type ==BTRFS_FILE_EXTENT_REG || extent_type ==BTRFS_FILE_EXTENT_PREALLOC ) {
include/trace/events/btrfs.h +29 -29
122 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH 4/7 btrfs: use btrfs_file_header structure for inode.c
In reply to Qu WenruoThis also involves btrfs_file_extent_inline*() helpers inside file-item.h, thus the changes are covering other files.
--- fs/btrfs/file-item.h | 8 +-- fs/btrfs/inode-item.c | 2 +- fs/btrfs/inode.c | 138 +++++++++++++++++++++--------------------- fs/btrfs/print-tree.c | 28 ++++----- fs/btrfs/reflink.c | 4 +- fs/btrfs/send.c | 28 ++++----- 6 files changed, 103 insertions(+), 105 deletions(-)
fs/btrfs/file-item.h +4 -4
@@ -30,20 +30,20 @@ static inline u32 BTRFS_MAX_INLINE_DATA_SIZE(const struct btrfs_fs_info *info)* extent headers. If a file is compressed on disk, this is the compressed * size. */ -static inline u32 btrfs_file_extent_inline_item_len ( +static inline u32 btrfs_file_header_inline_item_len (const struct extent_buffer *eb,int nr) {return btrfs_item_size (eb, nr) -sizeof (struct btrfs_file_header ); } -static inline unsigned long btrfs_file_extent_inline_start ( -const struct btrfs_file_extent_item *e) +static inline unsigned long btrfs_file_header_inline_start ( +const struct btrfs_file_header *e) {return (unsigned long )e +sizeof (struct btrfs_file_header ); } -static inline u32 btrfs_file_extent_calc_inline_size (u32 datasize) +static inline u32 btrfs_file_header_calc_inline_size (u32 datasize) {return sizeof (struct btrfs_file_header ) + datasize; }
fs/btrfs/inode-item.c +1 -1
@@ -594,7 +594,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,u32 size = (u32)(new_size - found_key.offset);btrfs_set_file_header_ram_bytes (leaf, fh, size); - size =btrfs_file_extent_calc_inline_size (size); + size =btrfs_file_header_calc_inline_size (size);btrfs_truncate_item (trans, path, size,1 ); }else if (!del_item) {/*
fs/btrfs/inode.c +68 -70
336 lines not on this page · raw message
fs/btrfs/print-tree.c +14 -14
@@ -345,30 +345,30 @@ static void print_extent_csum(const struct extent_buffer *eb, int i)static void print_file_extent_item (const struct extent_buffer *eb,int i) { -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh; - fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item); + fh = btrfs_item_ptr(eb, i, struct btrfs_file_header);pr_info ("\t\tgeneration %llu type %hhu\n" , -btrfs_file_extent_generation (eb, fi), -btrfs_file_extent_type (eb, fi)); +btrfs_file_header_generation (eb, fh), +btrfs_file_header_type (eb, fh)); -if (btrfs_file_extent_type (eb, fi) ==BTRFS_FILE_EXTENT_INLINE ) { +if (btrfs_file_header_type (eb, fh) ==BTRFS_FILE_EXTENT_INLINE ) {pr_info ("\t\tinline extent data size %u ram_bytes %llu compression %hhu\n" , -btrfs_file_extent_inline_item_len (eb, i), -btrfs_file_extent_ram_bytes (eb, fi), -btrfs_file_extent_compression (eb, fi)); +btrfs_file_header_inline_item_len (eb, i), +btrfs_file_header_ram_bytes (eb, fh), +btrfs_file_header_compression (eb, fh));return ; }pr_info ("\t\textent data disk bytenr %llu nr %llu\n" , -btrfs_file_extent_disk_bytenr (eb, fi), -btrfs_file_extent_disk_num_bytes (eb, fi)); +btrfs_file_header_disk_bytenr (eb, fh), +btrfs_file_header_disk_num_bytes (eb, fh));pr_info ("\t\textent data offset %llu nr %llu ram %llu\n" , -btrfs_file_extent_offset (eb, fi), -btrfs_file_extent_num_bytes (eb, fi), -btrfs_file_extent_ram_bytes (eb, fi)); +btrfs_file_header_offset (eb, fh), +btrfs_file_header_num_bytes (eb, fh), +btrfs_file_header_ram_bytes (eb, fh));pr_info ("\t\textent compression %hhu\n" , -btrfs_file_extent_compression (eb, fi)); +btrfs_file_header_compression (eb, fh)); }static void key_type_string (const struct btrfs_key *key,char *buf,int buf_size)
fs/btrfs/reflink.c +2 -2
@@ -62,8 +62,8 @@ static int copy_inline_to_page(struct btrfs_inode *inode,struct btrfs_fs_info *fs_info = inode->root->fs_info;const u32 block_size = fs_info->sectorsize;const u64 range_end = file_offset + block_size -1 ; -const size_t inline_size = size -btrfs_file_extent_calc_inline_size (0 ); -char *data_start = inline_data +btrfs_file_extent_calc_inline_size (0 ); +const size_t inline_size = size -btrfs_file_header_calc_inline_size (0 ); +char *data_start = inline_data +btrfs_file_header_calc_inline_size (0 );struct extent_changeset *data_reserved =NULL ;struct folio *folio =NULL ;struct address_space *mapping = inode->vfs_inode.i_mapping;
fs/btrfs/send.c +14 -14
@@ -1708,7 +1708,7 @@ static int read_symlink(struct btrfs_root *root,int ret;BTRFS_PATH_AUTO_FREE (path);struct btrfs_key key; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u8 type;u8 compression;unsigned long off;
@@ -1739,9 +1739,9 @@ static int read_symlink(struct btrfs_root *root,return -EIO ; } - ei =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], - struct btrfs_file_extent_item); - type =btrfs_file_extent_type (path->nodes[0 ], ei); + fh =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_file_header); + type =btrfs_file_header_type (path->nodes[0 ], fh);if (unlikely (type !=BTRFS_FILE_EXTENT_INLINE )) { ret = -EUCLEAN ; btrfs_crit(root->fs_info,
@@ -1749,7 +1749,7 @@ static int read_symlink(struct btrfs_root *root, ino, btrfs_root_id(root), type);return ret; } - compression =btrfs_file_extent_compression (path->nodes[0 ], ei); + compression =btrfs_file_header_compression (path->nodes[0 ], fh);if (unlikely (compression !=BTRFS_COMPRESS_NONE )) { ret = -EUCLEAN ; btrfs_crit(root->fs_info,
@@ -1758,8 +1758,8 @@ static int read_symlink(struct btrfs_root *root,return ret; } - off =btrfs_file_extent_inline_start (ei); - len =btrfs_file_extent_ram_bytes (path->nodes[0 ], ei); + off =btrfs_file_header_inline_start (fh); + len =btrfs_file_header_ram_bytes (path->nodes[0 ], fh);return fs_path_add_from_extent_buffer (dest, path->nodes[0 ], off, len); }
@@ -5481,7 +5481,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,struct fs_path *fspath;struct extent_buffer *leaf = path->nodes[0 ];struct btrfs_key key; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u64 ram_bytes;size_t inline_size;int ret;
@@ -5495,9 +5495,9 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,return ret;btrfs_item_key_to_cpu (leaf, &key, path->slots[0 ]); - ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); - ram_bytes =btrfs_file_extent_ram_bytes (leaf, ei); - inline_size =btrfs_file_extent_inline_item_len (leaf, path->slots[0 ]); + fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header); + ram_bytes =btrfs_file_header_ram_bytes (leaf, fh); + inline_size =btrfs_file_header_inline_item_len (leaf, path->slots[0 ]);TLV_PUT_PATH (sctx,BTRFS_SEND_A_PATH , fspath);TLV_PUT_U64 (sctx,BTRFS_SEND_A_FILE_OFFSET , offset);
@@ -5506,7 +5506,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,TLV_PUT_U64 (sctx,BTRFS_SEND_A_UNENCODED_LEN , ram_bytes);TLV_PUT_U64 (sctx,BTRFS_SEND_A_UNENCODED_OFFSET , offset - key.offset); ret =btrfs_encoded_io_compression_from_extent (fs_info, -btrfs_file_extent_compression (leaf, ei)); +btrfs_file_header_compression (leaf, fh));if (ret <0 )return ret;TLV_PUT_U32 (sctx,BTRFS_SEND_A_COMPRESSION , ret);
@@ -5515,7 +5515,7 @@ static int send_encoded_inline_extent(struct send_ctx *sctx,if (ret <0 )return ret;read_extent_buffer (leaf, sctx->send_buf + sctx->send_size, -btrfs_file_extent_inline_start (ei), inline_size); +btrfs_file_header_inline_start (fh), inline_size); sctx->send_size += inline_size; ret =send_cmd (sctx);
@@ -5652,7 +5652,7 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path,* the extent that we couldn't clone in clone_range(). */ if (is_inline && -btrfs_file_extent_inline_item_len (leaf, +btrfs_file_header_inline_item_len (leaf, path->slots[0 ]) <= len) {return send_encoded_inline_extent (sctx, path, offset, len);
Signature · 1 line
2.52.0
PATCH 6/7 btrfs: use btrfs_file_header structure for file.c
In reply to Qu WenruoThat file is a heavy user of btrfs_file_extent_item structure.
Most call sites are straightforward, some can benefit from a reduced lifespan, e.g. the btrfs_file_extent_item variable inside btrfs_drop_extents() is defined at the function level, but inside the while (1) loop, every time we hit a BTRFS_EXTENT_DATA key the pointer is updated to the corresponding item.
Thus it's safe to move the new btrfs_file_header pointer definition inside the while loop.
--- fs/btrfs/file.c | 204 ++++++++++++++++++++++++------------------------ 1 file changed, 101 insertions(+), 103 deletions(-)
fs/btrfs/file.c +101 -103
@@ -140,7 +140,6 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = root->fs_info;struct extent_buffer *leaf; -struct btrfs_file_extent_item *fi;struct btrfs_key key;struct btrfs_key new_key;u64 ino =btrfs_ino (inode);
@@ -182,6 +181,8 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, update_refs = (btrfs_root_id (root) !=BTRFS_TREE_LOG_OBJECTID );while (1 ) { +struct btrfs_file_header *fh; + recow =0 ; ret =btrfs_lookup_file_extent (trans, root, path, ino, search_start, modify_tree);
@@ -227,20 +228,20 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,if (key.type >BTRFS_EXTENT_DATA_KEY || key.offset >= args->end)break ; - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - extent_type =btrfs_file_extent_type (leaf, fi); + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + extent_type =btrfs_file_header_type (leaf, fh);if (extent_type ==BTRFS_FILE_EXTENT_REG || extent_type ==BTRFS_FILE_EXTENT_PREALLOC ) { - disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, fi); - num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); - extent_offset =btrfs_file_extent_offset (leaf, fi); + disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh); + num_bytes =btrfs_file_header_disk_num_bytes (leaf, fh); + extent_offset =btrfs_file_header_offset (leaf, fh); extent_end = key.offset + -btrfs_file_extent_num_bytes (leaf, fi); +btrfs_file_header_num_bytes (leaf, fh); }else if (extent_type ==BTRFS_FILE_EXTENT_INLINE ) { extent_end = key.offset + -btrfs_file_extent_ram_bytes (leaf, fi); +btrfs_file_header_ram_bytes (leaf, fh); }else {/* can't happen */ BUG ();
@@ -300,17 +301,17 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,break ; leaf = path->nodes[0 ]; - fi =btrfs_item_ptr (leaf, path->slots[0 ] -1 , - struct btrfs_file_extent_item); -btrfs_set_file_extent_num_bytes (leaf, fi, + fh =btrfs_item_ptr (leaf, path->slots[0 ] -1 , + struct btrfs_file_header); +btrfs_set_file_header_num_bytes (leaf, fh, args->start - key.offset); - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); extent_offset += args->start - key.offset; -btrfs_set_file_extent_offset (leaf, fi, extent_offset); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_offset (leaf, fh, extent_offset); +btrfs_set_file_header_num_bytes (leaf, fh, extent_end - args->start);if (update_refs && disk_bytenr >0 ) {
@@ -354,8 +355,8 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,btrfs_set_item_key_safe (trans, path, &new_key); extent_offset += args->end - key.offset; -btrfs_set_file_extent_offset (leaf, fi, extent_offset); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_offset (leaf, fh, extent_offset); +btrfs_set_file_header_num_bytes (leaf, fh, extent_end - args->end);if (update_refs && disk_bytenr >0 ) args->bytes_found += args->end - key.offset;
@@ -378,7 +379,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,break ; } -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_num_bytes (leaf, fh, args->start - key.offset);if (update_refs && disk_bytenr >0 ) args->bytes_found += extent_end - args->start;
@@ -509,7 +510,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans,static bool extent_mergeable (struct extent_buffer *leaf,int slot,u64 objectid,u64 bytenr,u64 orig_offset,u64 *start,u64 *end) { -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;struct btrfs_key key;u64 extent_end;
@@ -520,16 +521,16 @@ static bool extent_mergeable(struct extent_buffer *leaf, int slot, u64 objectid,if (key.objectid != objectid || key.type !=BTRFS_EXTENT_DATA_KEY )return false; - fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); -if (btrfs_file_extent_type (leaf, fi) !=BTRFS_FILE_EXTENT_REG || -btrfs_file_extent_disk_bytenr (leaf, fi) != bytenr || -btrfs_file_extent_offset (leaf, fi) != key.offset - orig_offset || -btrfs_file_extent_compression (leaf, fi) || -btrfs_file_extent_encryption (leaf, fi) || -btrfs_file_extent_other_encoding (leaf, fi)) + fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); +if (btrfs_file_header_type (leaf, fh) !=BTRFS_FILE_EXTENT_REG || +btrfs_file_header_disk_bytenr (leaf, fh) != bytenr || +btrfs_file_header_offset (leaf, fh) != key.offset - orig_offset || +btrfs_file_header_compression (leaf, fh) || +btrfs_file_header_encryption (leaf, fh) || +btrfs_file_header_other_encoding (leaf, fh))return false; - extent_end = key.offset +btrfs_file_extent_num_bytes (leaf, fi); + extent_end = key.offset +btrfs_file_header_num_bytes (leaf, fh);if ((*start && *start != key.offset) || (*end && *end != extent_end))return false;
@@ -551,7 +552,7 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,struct btrfs_root *root = inode->root;struct extent_buffer *leaf;BTRFS_PATH_AUTO_FREE (path); -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;struct btrfs_ref ref = {0 };struct btrfs_key key;struct btrfs_key new_key;
@@ -591,23 +592,23 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,btrfs_abort_transaction (trans, ret); goto out; } - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -if (unlikely (btrfs_file_extent_type (leaf, fi) !=BTRFS_FILE_EXTENT_PREALLOC )) { + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); +if (unlikely (btrfs_file_header_type (leaf, fh) !=BTRFS_FILE_EXTENT_PREALLOC )) { ret = -EINVAL ;btrfs_abort_transaction (trans, ret); goto out; } - extent_end = key.offset +btrfs_file_extent_num_bytes (leaf, fi); + extent_end = key.offset +btrfs_file_header_num_bytes (leaf, fh);if (unlikely (key.offset > start || extent_end < end)) { ret = -EINVAL ;btrfs_abort_transaction (trans, ret); goto out; } - bytenr =btrfs_file_extent_disk_bytenr (leaf, fi); - num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); - orig_offset = key.offset -btrfs_file_extent_offset (leaf, fi); + bytenr =btrfs_file_header_disk_bytenr (leaf, fh); + num_bytes =btrfs_file_header_disk_num_bytes (leaf, fh); + orig_offset = key.offset -btrfs_file_header_offset (leaf, fh);memcpy (&new_key, &key,sizeof (new_key));if (start == key.offset && end < extent_end) {
@@ -618,19 +619,19 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, &other_start, &other_end)) { new_key.offset = end;btrfs_set_item_key_safe (trans, path, &new_key); - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -btrfs_set_file_extent_generation (leaf, fi, + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); +btrfs_set_file_header_generation (leaf, fh, trans->transid); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_num_bytes (leaf, fh, extent_end - end); -btrfs_set_file_extent_offset (leaf, fi, +btrfs_set_file_header_offset (leaf, fh, end - orig_offset); - fi =btrfs_item_ptr (leaf, path->slots[0 ] -1 , - struct btrfs_file_extent_item); -btrfs_set_file_extent_generation (leaf, fi, + fh =btrfs_item_ptr (leaf, path->slots[0 ] -1 , + struct btrfs_file_header); +btrfs_set_file_header_generation (leaf, fh, trans->transid); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_num_bytes (leaf, fh, end - other_start); goto out; }
@@ -642,23 +643,23 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans,if (extent_mergeable (leaf, path->slots[0 ] +1 , ino, bytenr, orig_offset, &other_start, &other_end)) { - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -btrfs_set_file_extent_num_bytes (leaf, fi, + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); +btrfs_set_file_header_num_bytes (leaf, fh, start - key.offset); -btrfs_set_file_extent_generation (leaf, fi, +btrfs_set_file_header_generation (leaf, fh, trans->transid); path->slots[0 ]++; new_key.offset = start;btrfs_set_item_key_safe (trans, path, &new_key); - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -btrfs_set_file_extent_generation (leaf, fi, + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); +btrfs_set_file_header_generation (leaf, fh, trans->transid); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_num_bytes (leaf, fh, other_end - start); -btrfs_set_file_extent_offset (leaf, fi, +btrfs_set_file_header_offset (leaf, fh, start - orig_offset); goto out; }
@@ -680,18 +681,16 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, } leaf = path->nodes[0 ]; - fi =btrfs_item_ptr (leaf, path->slots[0 ] -1 , - struct btrfs_file_extent_item); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); -btrfs_set_file_extent_num_bytes (leaf, fi, + fh = btrfs_item_ptr(leaf, path->slots[0] - 1, struct btrfs_file_header); +btrfs_set_file_header_generation (leaf, fh, trans->transid); +btrfs_set_file_header_num_bytes (leaf, fh, split - key.offset); - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); + fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); -btrfs_set_file_extent_offset (leaf, fi, split - orig_offset); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_generation (leaf, fh, trans->transid); +btrfs_set_file_header_offset (leaf, fh, split - orig_offset); +btrfs_set_file_header_num_bytes (leaf, fh, extent_end - split); ref.action =BTRFS_ADD_DELAYED_REF ;
@@ -766,18 +765,16 @@ int btrfs_mark_extent_written(struct btrfs_trans_handle *trans, } }if (del_nr ==0 ) { - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -btrfs_set_file_extent_type (leaf, fi, + fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header); +btrfs_set_file_header_type (leaf, fh,BTRFS_FILE_EXTENT_REG ); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); +btrfs_set_file_header_generation (leaf, fh, trans->transid); }else { - fi =btrfs_item_ptr (leaf, del_slot -1 , - struct btrfs_file_extent_item); -btrfs_set_file_extent_type (leaf, fi, + fh = btrfs_item_ptr(leaf, del_slot - 1, struct btrfs_file_header); +btrfs_set_file_header_type (leaf, fh,BTRFS_FILE_EXTENT_REG ); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); -btrfs_set_file_extent_num_bytes (leaf, fi, +btrfs_set_file_header_generation (leaf, fh, trans->transid); +btrfs_set_file_header_num_bytes (leaf, fh, extent_end - key.offset); ret =btrfs_del_items (trans, root, path, del_slot, del_nr);
@@ -2056,7 +2053,7 @@ static int btrfs_file_mmap_prepare(struct vm_area_desc *desc)static bool hole_mergeable (struct btrfs_inode *inode,struct extent_buffer *leaf,int slot,u64 start,u64 end) { -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;struct btrfs_key key;if (slot <0 || slot >=btrfs_header_nritems (leaf))
@@ -2067,17 +2064,17 @@ static bool hole_mergeable(struct btrfs_inode *inode, struct extent_buffer *leaf key.type != BTRFS_EXTENT_DATA_KEY)return false; - fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); + fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); -if (btrfs_file_extent_type (leaf, fi) !=BTRFS_FILE_EXTENT_REG ) +if (btrfs_file_header_type (leaf, fh) !=BTRFS_FILE_EXTENT_REG )return false; -if (btrfs_file_extent_disk_bytenr (leaf, fi)) +if (btrfs_file_header_disk_bytenr (leaf, fh))return false;if (key.offset == end)return true; -if (key.offset +btrfs_file_extent_num_bytes (leaf, fi) == start) +if (key.offset +btrfs_file_header_num_bytes (leaf, fh) == start)return true;return false; }
@@ -2089,7 +2086,6 @@ static int fill_holes(struct btrfs_trans_handle *trans,struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_root *root = inode->root;struct extent_buffer *leaf; -struct btrfs_file_extent_item *fi;struct extent_map *hole_em;struct btrfs_key key;int ret;
@@ -2114,33 +2110,35 @@ static int fill_holes(struct btrfs_trans_handle *trans, leaf = path->nodes[0 ];if (hole_mergeable (inode, leaf, path->slots[0 ] -1 , offset, end)) { +struct btrfs_file_header *fh;u64 num_bytes; path->slots[0 ]--; - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - num_bytes =btrfs_file_extent_num_bytes (leaf, fi) + + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + num_bytes =btrfs_file_header_num_bytes (leaf, fh) + end - offset; -btrfs_set_file_extent_num_bytes (leaf, fi, num_bytes); -btrfs_set_file_extent_ram_bytes (leaf, fi, num_bytes); -btrfs_set_file_extent_offset (leaf, fi,0 ); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); +btrfs_set_file_header_num_bytes (leaf, fh, num_bytes); +btrfs_set_file_header_ram_bytes (leaf, fh, num_bytes); +btrfs_set_file_header_offset (leaf, fh,0 ); +btrfs_set_file_header_generation (leaf, fh, trans->transid); goto out; }if (hole_mergeable (inode, leaf, path->slots[0 ], offset, end)) { +struct btrfs_file_header *fh;u64 num_bytes; key.offset = offset;btrfs_set_item_key_safe (trans, path, &key); - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - num_bytes =btrfs_file_extent_num_bytes (leaf, fi) + end - + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + num_bytes =btrfs_file_header_num_bytes (leaf, fh) + end - offset; -btrfs_set_file_extent_num_bytes (leaf, fi, num_bytes); -btrfs_set_file_extent_ram_bytes (leaf, fi, num_bytes); -btrfs_set_file_extent_offset (leaf, fi,0 ); -btrfs_set_file_extent_generation (leaf, fi, trans->transid); +btrfs_set_file_header_num_bytes (leaf, fh, num_bytes); +btrfs_set_file_header_ram_bytes (leaf, fh, num_bytes); +btrfs_set_file_header_offset (leaf, fh,0 ); +btrfs_set_file_header_generation (leaf, fh, trans->transid); goto out; }btrfs_release_path (path);
@@ -2305,7 +2303,7 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans, {struct btrfs_fs_info *fs_info = trans->fs_info;struct btrfs_root *root = inode->root; -struct btrfs_file_extent_item *extent; +struct btrfs_file_header *header;struct extent_buffer *leaf;struct btrfs_key key;int slot;
@@ -2332,12 +2330,12 @@ static int btrfs_insert_replace_extent(struct btrfs_trans_handle *trans,write_extent_buffer (leaf, extent_info->extent_buf,btrfs_item_ptr_offset (leaf, slot),sizeof (struct btrfs_file_extent_item )); - extent = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); -ASSERT (btrfs_file_extent_type (leaf, extent) !=BTRFS_FILE_EXTENT_INLINE ); -btrfs_set_file_extent_offset (leaf, extent, extent_info->data_offset); -btrfs_set_file_extent_num_bytes (leaf, extent, replace_len); + header = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); +ASSERT (btrfs_file_header_type (leaf, header) !=BTRFS_FILE_EXTENT_INLINE ); +btrfs_set_file_header_offset (leaf, header, extent_info->data_offset); +btrfs_set_file_header_num_bytes (leaf, header, replace_len);if (extent_info->is_new_extent) -btrfs_set_file_extent_generation (leaf, extent, trans->transid); +btrfs_set_file_header_generation (leaf, header, trans->transid);btrfs_release_path (path); ret = btrfs_inode_set_file_extent_range(inode, extent_info->file_offset,
@@ -3637,7 +3635,7 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)while (start < i_size) {struct extent_buffer *leaf = path->nodes[0 ]; -struct btrfs_file_extent_item *extent; +struct btrfs_file_header *header;u64 extent_end;u8 type;
@@ -3693,9 +3691,9 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)*/ } - extent =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - type =btrfs_file_extent_type (leaf, extent); + header =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + type =btrfs_file_header_type (leaf, header);/* * Can't access the extent's disk_bytenr field if this is an
@@ -3704,7 +3702,7 @@ static loff_t find_desired_extent(struct file *file, loff_t offset, int whence)*/ if (type ==BTRFS_FILE_EXTENT_PREALLOC || (type ==BTRFS_FILE_EXTENT_REG && -btrfs_file_extent_disk_bytenr (leaf, extent) ==0 )) { +btrfs_file_header_disk_bytenr (leaf, header) ==0 )) {/* * Explicit hole or prealloc extent, search for delalloc. * A prealloc extent is treated like a hole.
Signature · 1 line
2.52.0
PATCH 5/7 btrfs: use btrfs_file_header structure for simple usages
In reply to Qu WenruoThose usage are pretty straightforward, they are checking the type first, then grabbing values according to the types.
There are only minor changes to btrfs_file_header pointer lifespan, now they are only defined at the minimal scope when possible.
--- fs/btrfs/backref.c | 36 +++++++++++++++++++----------------- fs/btrfs/ctree.c | 31 +++++++++++++++++-------------- fs/btrfs/extent-tree.c | 26 +++++++++++++------------- fs/btrfs/fiemap.c | 30 +++++++++++++++--------------- fs/btrfs/file-item.c | 8 ++++---- fs/btrfs/qgroup.c | 11 ++++++----- fs/btrfs/reflink.c | 30 +++++++++++++++--------------- fs/btrfs/relocation.c | 42 +++++++++++++++++++++--------------------- 8 files changed, 110 insertions(+), 104 deletions(-)
fs/btrfs/backref.c +19 -17
@@ -35,10 +35,10 @@ struct extent_inode_elem {static int check_extent_in_eb (struct btrfs_backref_walk_ctx *ctx,const struct btrfs_key *key,const struct extent_buffer *eb, -const struct btrfs_file_extent_item *fi, +const struct btrfs_file_header *fh,struct extent_inode_elem **eie) { -const u64 data_len =btrfs_file_extent_num_bytes (eb, fi); +const u64 data_len =btrfs_file_header_num_bytes (eb, fh);u64 offset = key->offset;struct extent_inode_elem *e;const u64 *root_ids;
@@ -46,12 +46,12 @@ static int check_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,bool cached;if (!ctx->ignore_extent_item_pos && - !btrfs_file_extent_compression (eb, fi) && - !btrfs_file_extent_encryption (eb, fi) && - !btrfs_file_extent_other_encoding (eb, fi)) { + !btrfs_file_header_compression (eb, fh) && + !btrfs_file_header_encryption (eb, fh) && + !btrfs_file_header_other_encoding (eb, fh)) {u64 data_offset; - data_offset =btrfs_file_extent_offset (eb, fi); + data_offset =btrfs_file_header_offset (eb, fh);if (ctx->extent_item_pos < data_offset || ctx->extent_item_pos >= data_offset + data_len)
@@ -107,7 +107,6 @@ static int find_extent_in_eb(struct btrfs_backref_walk_ctx *ctx, {u64 disk_byte;struct btrfs_key key; -struct btrfs_file_extent_item *fi;int slot;int nritems;int extent_type;
@@ -120,19 +119,21 @@ static int find_extent_in_eb(struct btrfs_backref_walk_ctx *ctx,*/ nritems =btrfs_header_nritems (eb);for (slot =0 ; slot < nritems; ++slot) { +struct btrfs_file_header *fh; +btrfs_item_key_to_cpu (eb, &key, slot);if (key.type !=BTRFS_EXTENT_DATA_KEY )continue ; - fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); - extent_type =btrfs_file_extent_type (eb, fi); + fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header); + extent_type =btrfs_file_header_type (eb, fh);if (extent_type ==BTRFS_FILE_EXTENT_INLINE )continue ;/* don't skip BTRFS_FILE_EXTENT_PREALLOC, we can handle that */ - disk_byte =btrfs_file_extent_disk_bytenr (eb, fi); + disk_byte =btrfs_file_header_disk_bytenr (eb, fh);if (disk_byte != ctx->bytenr)continue ; - ret =check_extent_in_eb (ctx, &key, eb, fi, eie); + ret =check_extent_in_eb (ctx, &key, eb, fh, eie);if (ret ==BTRFS_ITERATE_EXTENT_INODES_STOP || ret <0 )return ret; }
@@ -475,7 +476,6 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,struct extent_buffer *eb;struct btrfs_key key;struct btrfs_key *key_for_search = &ref->key_for_search; -struct btrfs_file_extent_item *fi;struct extent_inode_elem *eie =NULL , *old =NULL ;u64 disk_byte;u64 wanted_disk_byte = ref->wanted_disk_byte;
@@ -512,6 +512,8 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx, }while (!ret && count < ref->count) { +struct btrfs_file_header *fh; + eb = path->nodes[0 ]; slot = path->slots[0 ];
@@ -535,12 +537,12 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx, ret =btrfs_next_old_leaf (root, path, ctx->time_seq);continue ; } - fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); - type =btrfs_file_extent_type (eb, fi); + fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header); + type =btrfs_file_header_type (eb, fh);if (type ==BTRFS_FILE_EXTENT_INLINE ) goto next; - disk_byte =btrfs_file_extent_disk_bytenr (eb, fi); - data_offset =btrfs_file_extent_offset (eb, fi); + disk_byte =btrfs_file_header_disk_bytenr (eb, fh); + data_offset =btrfs_file_header_offset (eb, fh);if (disk_byte == wanted_disk_byte) { eie =NULL ;
@@ -550,7 +552,7 @@ static int add_all_parents(struct btrfs_backref_walk_ctx *ctx,else goto next;if (!ctx->skip_inode_ref_list) { - ret =check_extent_in_eb (ctx, &key, eb, fi, &eie); + ret =check_extent_in_eb (ctx, &key, eb, fh, &eie);if (ret ==BTRFS_ITERATE_EXTENT_INODES_STOP || ret <0 )break ;
fs/btrfs/ctree.c +17 -14
@@ -3847,7 +3847,6 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, {struct btrfs_key key;struct extent_buffer *leaf; -struct btrfs_file_extent_item *fi;u64 extent_len =0 ;u32 item_size;int ret;
@@ -3864,9 +3863,11 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, item_size =btrfs_item_size (leaf, path->slots[0 ]);if (key.type ==BTRFS_EXTENT_DATA_KEY ) { - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - extent_len =btrfs_file_extent_num_bytes (leaf, fi); +struct btrfs_file_header *fh; + + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + extent_len =btrfs_file_header_num_bytes (leaf, fh); }btrfs_release_path (path);
@@ -3890,9 +3891,11 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, goto err;if (key.type ==BTRFS_EXTENT_DATA_KEY ) { - fi =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); -if (extent_len !=btrfs_file_extent_num_bytes (leaf, fi)) +struct btrfs_file_header *fh; + + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); +if (extent_len !=btrfs_file_header_num_bytes (leaf, fh)) goto err; }
@@ -4063,18 +4066,18 @@ void btrfs_truncate_item(struct btrfs_trans_handle *trans,if (btrfs_disk_key_type (&disk_key) ==BTRFS_EXTENT_DATA_KEY ) {unsigned long ptr; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh; - fi =btrfs_item_ptr (leaf, slot, - struct btrfs_file_extent_item); - fi = (struct btrfs_file_extent_item *)( - (unsigned long )fi - size_diff); + fh =btrfs_item_ptr (leaf, slot, + struct btrfs_file_header); + fh = (struct btrfs_file_header *)( + (unsigned long )fh - size_diff); -if (btrfs_file_extent_type (leaf, fi) == +if (btrfs_file_header_type (leaf, fh) ==BTRFS_FILE_EXTENT_INLINE ) { ptr =btrfs_item_ptr_offset (leaf, slot);memmove_extent_buffer (leaf, ptr, - (unsigned long )fi, + (unsigned long )fh,sizeof (struct btrfs_file_header )); } }
fs/btrfs/extent-tree.c +13 -13
@@ -2465,7 +2465,7 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,u64 ref_root;u32 nritems;struct btrfs_key key; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;bool for_reloc =btrfs_header_flag (buf,BTRFS_HEADER_FLAG_RELOC );int i;int action;
@@ -2502,19 +2502,19 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,btrfs_item_key_to_cpu (buf, &key, i);if (key.type !=BTRFS_EXTENT_DATA_KEY )continue ; - fi =btrfs_item_ptr (buf, i, - struct btrfs_file_extent_item); -if (btrfs_file_extent_type (buf, fi) == + fh =btrfs_item_ptr (buf, i, + struct btrfs_file_header); +if (btrfs_file_header_type (buf, fh) ==BTRFS_FILE_EXTENT_INLINE )continue ; - ref.bytenr =btrfs_file_extent_disk_bytenr (buf, fi); + ref.bytenr =btrfs_file_header_disk_bytenr (buf, fh);if (ref.bytenr ==0 )continue ; - ref.num_bytes =btrfs_file_extent_disk_num_bytes (buf, fi); + ref.num_bytes =btrfs_file_header_disk_num_bytes (buf, fh); ref.owning_root = ref_root; - key.offset -=btrfs_file_extent_offset (buf, fi); + key.offset -=btrfs_file_header_offset (buf, fh);btrfs_init_data_ref (&ref, key.objectid, key.offset,btrfs_root_id (root), for_reloc);if (inc)
@@ -2673,7 +2673,7 @@ static int __exclude_logged_extent(struct btrfs_fs_info *fs_info,int btrfs_exclude_logged_extents (struct extent_buffer *eb) {struct btrfs_fs_info *fs_info = eb->fs_info; -struct btrfs_file_extent_item *item; +struct btrfs_file_header *header;struct btrfs_key key;int found_type;int i;
@@ -2686,14 +2686,14 @@ int btrfs_exclude_logged_extents(struct extent_buffer *eb)btrfs_item_key_to_cpu (eb, &key, i);if (key.type !=BTRFS_EXTENT_DATA_KEY )continue ; - item = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item); - found_type =btrfs_file_extent_type (eb, item); + header = btrfs_item_ptr(eb, i, struct btrfs_file_header); + found_type =btrfs_file_header_type (eb, header);if (found_type ==BTRFS_FILE_EXTENT_INLINE )continue ; -if (btrfs_file_extent_disk_bytenr (eb, item) ==0 ) +if (btrfs_file_header_disk_bytenr (eb, header) ==0 )continue ; - key.objectid =btrfs_file_extent_disk_bytenr (eb, item); - key.offset =btrfs_file_extent_disk_num_bytes (eb, item); + key.objectid =btrfs_file_header_disk_bytenr (eb, header); + key.offset =btrfs_file_header_disk_num_bytes (eb, header); ret =__exclude_logged_extent (fs_info, key.objectid, key.offset);if (ret)break ;
fs/btrfs/fiemap.c +15 -15
@@ -558,7 +558,7 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,const u64 ino =btrfs_ino (inode);struct btrfs_root *root = inode->root;struct extent_buffer *leaf; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;struct btrfs_key key;u64 disk_bytenr;int ret;
@@ -594,8 +594,8 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,* so first check if we have an inline extent item before checking if we * have an implicit hole (disk_bytenr == 0). */ - ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); -if (btrfs_file_extent_type (leaf, ei) ==BTRFS_FILE_EXTENT_INLINE ) { + fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header); +if (btrfs_file_header_type (leaf, fh) ==BTRFS_FILE_EXTENT_INLINE ) { *last_extent_end_ret =btrfs_file_extent_end (path);return 0 ; }
@@ -607,7 +607,7 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,* another hole file extent item as the last item in the previous leaf. * This is because we merge file extent items that represent holes. */ - disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, ei); + disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh);while (disk_bytenr ==0 ) { ret =btrfs_previous_item (root, path, ino,BTRFS_EXTENT_DATA_KEY );if (ret <0 ) {
@@ -618,9 +618,9 @@ static int fiemap_find_last_extent_offset(struct btrfs_inode *inode,return 0 ; } leaf = path->nodes[0 ]; - ei =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, ei); + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh); } *last_extent_end_ret =btrfs_file_extent_end (path);
@@ -683,7 +683,7 @@ static int extent_fiemap(struct btrfs_inode *inode,while (prev_extent_end < range_end) {struct extent_buffer *leaf = path->nodes[0 ]; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;struct btrfs_key key;u64 extent_end;u64 extent_len;
@@ -733,16 +733,16 @@ static int extent_fiemap(struct btrfs_inode *inode, } extent_len = extent_end - key.offset; - ei =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); - compression =btrfs_file_extent_compression (leaf, ei); - extent_type =btrfs_file_extent_type (leaf, ei); - extent_gen =btrfs_file_extent_generation (leaf, ei); + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header); + compression =btrfs_file_header_compression (leaf, fh); + extent_type =btrfs_file_header_type (leaf, fh); + extent_gen =btrfs_file_header_generation (leaf, fh);if (extent_type !=BTRFS_FILE_EXTENT_INLINE ) { - disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, ei); + disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh);if (compression ==BTRFS_COMPRESS_NONE ) - extent_offset =btrfs_file_extent_offset (leaf, ei); + extent_offset =btrfs_file_header_offset (leaf, fh); }if (compression !=BTRFS_COMPRESS_NONE )
fs/btrfs/file-item.c +4 -4
@@ -1383,18 +1383,18 @@ u64 btrfs_file_extent_end(const struct btrfs_path *path) {const struct extent_buffer *leaf = path->nodes[0 ];const int slot = path->slots[0 ]; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;struct btrfs_key key;u64 end;btrfs_item_key_to_cpu (leaf, &key, slot);ASSERT (key.type ==BTRFS_EXTENT_DATA_KEY ); - fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); + fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); -if (btrfs_file_extent_type (leaf, fi) ==BTRFS_FILE_EXTENT_INLINE ) +if (btrfs_file_header_type (leaf, fh) ==BTRFS_FILE_EXTENT_INLINE ) end = leaf->fs_info->sectorsize;else - end = key.offset +btrfs_file_extent_num_bytes (leaf, fi); + end = key.offset +btrfs_file_header_num_bytes (leaf, fh);return end; }
fs/btrfs/qgroup.c +6 -5
@@ -2180,7 +2180,6 @@ int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,int nr =btrfs_header_nritems (eb);int i, extent_type, ret;struct btrfs_key key; -struct btrfs_file_extent_item *fi;u64 bytenr, num_bytes;/* We can be called directly from walk_up_proc() */
@@ -2188,23 +2187,25 @@ int btrfs_qgroup_trace_leaf_items(struct btrfs_trans_handle *trans,return 0 ;for (i =0 ; i < nr; i++) { +struct btrfs_file_header *fh; +btrfs_item_key_to_cpu (eb, &key, i);if (key.type !=BTRFS_EXTENT_DATA_KEY )continue ; - fi = btrfs_item_ptr(eb, i, struct btrfs_file_extent_item); + fh = btrfs_item_ptr(eb, i, struct btrfs_file_header);/* filter out non qgroup-accountable extents */ - extent_type =btrfs_file_extent_type (eb, fi); + extent_type =btrfs_file_header_type (eb, fh);if (extent_type ==BTRFS_FILE_EXTENT_INLINE )continue ; - bytenr =btrfs_file_extent_disk_bytenr (eb, fi); + bytenr =btrfs_file_header_disk_bytenr (eb, fh);if (!bytenr)continue ; - num_bytes =btrfs_file_extent_disk_num_bytes (eb, fi); + num_bytes =btrfs_file_header_disk_num_bytes (eb, fh); ret =btrfs_qgroup_trace_extent (trans, bytenr, num_bytes);if (ret)
fs/btrfs/reflink.c +15 -15
@@ -213,16 +213,16 @@ static int clone_copy_inline_extent(struct btrfs_inode *inode, goto copy_to_page; } }else if (i_size_read (&inode->vfs_inode) <= datal) { -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh; - ei =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], - struct btrfs_file_extent_item); + fh =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_file_header);/* * If it's an inline extent replace it with the source inline * extent, otherwise copy the source inline extent data into * the respective page at the destination inode. */ -if (btrfs_file_extent_type (path->nodes[0 ], ei) == +if (btrfs_file_header_type (path->nodes[0 ], fh) ==BTRFS_FILE_EXTENT_INLINE ) goto copy_inline_extent;
@@ -369,7 +369,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode, key.offset = off;while (1 ) { -struct btrfs_file_extent_item *extent; +struct btrfs_file_header *header;u64 extent_gen;int type;u32 size;
@@ -416,20 +416,20 @@ static int btrfs_clone(struct inode *src, struct inode *inode,ASSERT (key.type ==BTRFS_EXTENT_DATA_KEY ); - extent =btrfs_item_ptr (leaf, slot, - struct btrfs_file_extent_item); - extent_gen =btrfs_file_extent_generation (leaf, extent); - comp =btrfs_file_extent_compression (leaf, extent); - type =btrfs_file_extent_type (leaf, extent); + header =btrfs_item_ptr (leaf, slot, + struct btrfs_file_header); + extent_gen =btrfs_file_header_generation (leaf, header); + comp =btrfs_file_header_compression (leaf, header); + type =btrfs_file_header_type (leaf, header);if (type ==BTRFS_FILE_EXTENT_REG || type ==BTRFS_FILE_EXTENT_PREALLOC ) { - disko =btrfs_file_extent_disk_bytenr (leaf, extent); - diskl =btrfs_file_extent_disk_num_bytes (leaf, extent); - datao =btrfs_file_extent_offset (leaf, extent); - datal =btrfs_file_extent_num_bytes (leaf, extent); + disko =btrfs_file_header_disk_bytenr (leaf, header); + diskl =btrfs_file_header_disk_num_bytes (leaf, header); + datao =btrfs_file_header_offset (leaf, header); + datal =btrfs_file_header_num_bytes (leaf, header); }else if (type ==BTRFS_FILE_EXTENT_INLINE ) {/* Take upper bound, may be compressed */ - datal =btrfs_file_extent_ram_bytes (leaf, extent); + datal =btrfs_file_header_ram_bytes (leaf, header); }/*
fs/btrfs/relocation.c +21 -21
111 lines not on this page · raw message
Signature · 1 line
2.52.0
PATCH 7/7 btrfs: use btrfs_file_header structure for send.c and tree-log.c
In reply to Qu WenruoMostly a straightforward conversion, some minor notes:
- Some hidden existing btrfs_file_extent_item::type checks There are some call sites that are grabbing @disk_bytenr without checking the @type.
That's because it's already done by the caller.
- Some sizeof(*item) usage
For those call sites inside replay_one_extent(), we have already checked the type is not INLINE, thus it's the full btrfs_file_extent_item structure.
We must keep the old size, not using the sizeof(*header).
--- fs/btrfs/send.c | 117 ++++++++++++++++++++++---------------------- fs/btrfs/tree-log.c | 70 +++++++++++++------------- 2 files changed, 93 insertions(+), 94 deletions(-)
fs/btrfs/send.c +58 -59
@@ -1554,7 +1554,7 @@ static int find_extent_clone(struct send_ctx *sctx,int extent_type;u64 disk_byte;u64 num_bytes; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;struct extent_buffer *eb = path->nodes[0 ];struct backref_ctx backref_ctx = {0 };struct btrfs_backref_walk_ctx backref_walk_ctx = {0 };
@@ -1571,17 +1571,17 @@ static int find_extent_clone(struct send_ctx *sctx,if (data_offset >= ino_size)return 0 ; - fi = btrfs_item_ptr(eb, path->slots[0], struct btrfs_file_extent_item); - extent_type =btrfs_file_extent_type (eb, fi); + fh = btrfs_item_ptr(eb, path->slots[0], struct btrfs_file_header); + extent_type =btrfs_file_header_type (eb, fh);if (extent_type ==BTRFS_FILE_EXTENT_INLINE )return -ENOENT ; - disk_byte =btrfs_file_extent_disk_bytenr (eb, fi); + disk_byte =btrfs_file_header_disk_bytenr (eb, fh);if (disk_byte ==0 )return -ENOENT ; - compressed =btrfs_file_extent_compression (eb, fi); - num_bytes =btrfs_file_extent_num_bytes (eb, fi); + compressed =btrfs_file_header_compression (eb, fh); + num_bytes =btrfs_file_header_num_bytes (eb, fh);/* * Setup the clone roots.
@@ -1603,7 +1603,7 @@ static int find_extent_clone(struct send_ctx *sctx,* snapshot we can have shared subtrees. */ backref_ctx.backref_owner =btrfs_header_owner (eb); - backref_ctx.backref_offset = data_offset -btrfs_file_extent_offset (eb, fi); + backref_ctx.backref_offset = data_offset -btrfs_file_header_offset (eb, fh);/* * The last extent of a file may be too large due to page alignment.
@@ -1620,7 +1620,7 @@ static int find_extent_clone(struct send_ctx *sctx,*/ backref_walk_ctx.bytenr = disk_byte;if (compressed ==BTRFS_COMPRESS_NONE ) - backref_walk_ctx.extent_item_pos =btrfs_file_extent_offset (eb, fi); + backref_walk_ctx.extent_item_pos =btrfs_file_header_offset (eb, fh); backref_walk_ctx.fs_info = fs_info; backref_walk_ctx.cache_lookup = lookup_backref_cache; backref_walk_ctx.cache_store = store_backref_cache;
@@ -5533,7 +5533,7 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path,struct fs_path *fspath;struct extent_buffer *leaf = path->nodes[0 ];struct btrfs_key key; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u64 disk_bytenr, disk_num_bytes;u32 data_offset;struct btrfs_cmd_header *hdr;
@@ -5555,21 +5555,21 @@ static int send_encoded_extent(struct send_ctx *sctx, struct btrfs_path *path, goto out;btrfs_item_key_to_cpu (leaf, &key, path->slots[0 ]); - ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_extent_item); - disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, ei); - disk_num_bytes =btrfs_file_extent_disk_num_bytes (leaf, ei); + fh = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_file_header); + disk_bytenr =btrfs_file_header_disk_bytenr (leaf, fh); + disk_num_bytes =btrfs_file_header_disk_num_bytes (leaf, fh);TLV_PUT_PATH (sctx,BTRFS_SEND_A_PATH , fspath);TLV_PUT_U64 (sctx,BTRFS_SEND_A_FILE_OFFSET , offset);TLV_PUT_U64 (sctx,BTRFS_SEND_A_UNENCODED_FILE_LEN , -min (key.offset +btrfs_file_extent_num_bytes (leaf, ei) - offset, +min (key.offset +btrfs_file_header_num_bytes (leaf, fh) - offset, len));TLV_PUT_U64 (sctx,BTRFS_SEND_A_UNENCODED_LEN , -btrfs_file_extent_ram_bytes (leaf, ei)); +btrfs_file_header_ram_bytes (leaf, fh));TLV_PUT_U64 (sctx,BTRFS_SEND_A_UNENCODED_OFFSET , - offset - key.offset +btrfs_file_extent_offset (leaf, ei)); + offset - key.offset +btrfs_file_header_offset (leaf, fh)); ret =btrfs_encoded_io_compression_from_extent (fs_info, -btrfs_file_extent_compression (leaf, ei)); +btrfs_file_header_compression (leaf, fh));if (ret <0 ) goto out;TLV_PUT_U32 (sctx,BTRFS_SEND_A_COMPRESSION , ret);
@@ -5630,18 +5630,18 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path, {const u64 end = offset + len;struct extent_buffer *leaf = path->nodes[0 ]; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u64 read_size =max_send_read_size (sctx);u64 sent =0 ;if (sctx->flags &BTRFS_SEND_FLAG_NO_FILE_DATA )return send_update_extent (sctx, offset, len); - ei =btrfs_item_ptr (leaf, path->slots[0 ], - struct btrfs_file_extent_item); + fh =btrfs_item_ptr (leaf, path->slots[0 ], + struct btrfs_file_header);if ((sctx->flags &BTRFS_SEND_FLAG_COMPRESSED ) && -btrfs_file_extent_compression (leaf, ei) !=BTRFS_COMPRESS_NONE ) { -bool is_inline = (btrfs_file_extent_type (leaf, ei) == +btrfs_file_header_compression (leaf, fh) !=BTRFS_COMPRESS_NONE ) { +bool is_inline = (btrfs_file_header_type (leaf, fh) ==BTRFS_FILE_EXTENT_INLINE );/*
@@ -5657,7 +5657,7 @@ static int send_extent_data(struct send_ctx *sctx, struct btrfs_path *path,return send_encoded_inline_extent (sctx, path, offset, len); }else if (!is_inline && -btrfs_file_extent_disk_num_bytes (leaf, ei) <= len) { +btrfs_file_header_disk_num_bytes (leaf, fh) <= len) {return send_encoded_extent (sctx, path, offset, len); } }
@@ -5866,7 +5866,7 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path,while (true) {struct extent_buffer *leaf = path->nodes[0 ];int slot = path->slots[0 ]; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u8 type;u64 ext_len;u64 clone_len;
@@ -5892,13 +5892,13 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path, key.type != BTRFS_EXTENT_DATA_KEY)break ; - ei = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); - type =btrfs_file_extent_type (leaf, ei); + fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); + type =btrfs_file_header_type (leaf, fh);if (type ==BTRFS_FILE_EXTENT_INLINE ) { - ext_len =btrfs_file_extent_ram_bytes (leaf, ei); + ext_len =btrfs_file_header_ram_bytes (leaf, fh); ext_len =PAGE_ALIGN (ext_len); }else { - ext_len =btrfs_file_extent_num_bytes (leaf, ei); + ext_len =btrfs_file_header_num_bytes (leaf, fh); }if (key.offset + ext_len <= clone_root->offset)
@@ -5934,8 +5934,8 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path, crossed_src_i_size = true; } - clone_data_offset =btrfs_file_extent_offset (leaf, ei); -if (btrfs_file_extent_disk_bytenr (leaf, ei) == disk_byte) { + clone_data_offset =btrfs_file_header_offset (leaf, fh); +if (btrfs_file_header_disk_bytenr (leaf, fh) == disk_byte) { clone_root->offset = key.offset;if (clone_data_offset < data_offset && clone_data_offset + ext_len > data_offset) {
@@ -5950,7 +5950,7 @@ static int clone_range(struct send_ctx *sctx, struct btrfs_path *dst_path, clone_len =min_t (u64, ext_len, len); -if (btrfs_file_extent_disk_bytenr (leaf, ei) == disk_byte && +if (btrfs_file_header_disk_bytenr (leaf, fh) == disk_byte && clone_data_offset == data_offset) {const u64 src_end = clone_root->offset + clone_len;const u64 sectorsize =SZ_64K ;
@@ -6061,7 +6061,7 @@ static int send_write_or_clone(struct send_ctx *sctx,u64 offset = key->offset;u64 end;u64 bs = sctx->send_root->fs_info->sectorsize; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u64 disk_byte;u64 data_offset;u64 num_bytes;
@@ -6121,10 +6121,10 @@ static int send_write_or_clone(struct send_ctx *sctx,return ret; clone_data: - ei =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], - struct btrfs_file_extent_item); - disk_byte =btrfs_file_extent_disk_bytenr (path->nodes[0 ], ei); - data_offset =btrfs_file_extent_offset (path->nodes[0 ], ei); + fh =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_file_header); + disk_byte =btrfs_file_header_disk_bytenr (path->nodes[0 ], fh); + data_offset =btrfs_file_header_offset (path->nodes[0 ], fh); ret =clone_range (sctx, path, clone_root, disk_byte, data_offset, offset, num_bytes); sctx->cur_inode_next_write_offset = end;
@@ -6141,7 +6141,7 @@ static int is_extent_unchanged(struct send_ctx *sctx,struct extent_buffer *eb;int slot;struct btrfs_key found_key; -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u64 left_disknr;u64 right_disknr;u64 left_offset;
@@ -6160,16 +6160,15 @@ static int is_extent_unchanged(struct send_ctx *sctx, eb = left_path->nodes[0 ]; slot = left_path->slots[0 ]; - ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); - left_type =btrfs_file_extent_type (eb, ei); - + fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header); + left_type =btrfs_file_header_type (eb, fh);if (left_type !=BTRFS_FILE_EXTENT_REG )return 0 ; - left_disknr =btrfs_file_extent_disk_bytenr (eb, ei); - left_len =btrfs_file_extent_num_bytes (eb, ei); - left_offset =btrfs_file_extent_offset (eb, ei); - left_gen =btrfs_file_extent_generation (eb, ei); + left_disknr =btrfs_file_header_disk_bytenr (eb, fh); + left_len =btrfs_file_header_num_bytes (eb, fh); + left_offset =btrfs_file_header_offset (eb, fh); + left_gen =btrfs_file_header_generation (eb, fh);/* * Following comments will refer to these graphics. L is the left
@@ -6217,17 +6216,17 @@ static int is_extent_unchanged(struct send_ctx *sctx,*/ key = found_key;while (key.offset < ekey->offset + left_len) { - ei = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item); - right_type =btrfs_file_extent_type (eb, ei); + fh = btrfs_item_ptr(eb, slot, struct btrfs_file_header); + right_type =btrfs_file_header_type (eb, fh);if (right_type !=BTRFS_FILE_EXTENT_REG && right_type !=BTRFS_FILE_EXTENT_INLINE )return 0 ;if (right_type ==BTRFS_FILE_EXTENT_INLINE ) { - right_len =btrfs_file_extent_ram_bytes (eb, ei); + right_len =btrfs_file_header_ram_bytes (eb, fh); right_len =PAGE_ALIGN (right_len); }else { - right_len =btrfs_file_extent_num_bytes (eb, ei); + right_len =btrfs_file_header_num_bytes (eb, fh); }/*
@@ -6249,9 +6248,9 @@ static int is_extent_unchanged(struct send_ctx *sctx,if (right_type ==BTRFS_FILE_EXTENT_INLINE )return 0 ; - right_disknr =btrfs_file_extent_disk_bytenr (eb, ei); - right_offset =btrfs_file_extent_offset (eb, ei); - right_gen =btrfs_file_extent_generation (eb, ei); + right_disknr =btrfs_file_header_disk_bytenr (eb, fh); + right_offset =btrfs_file_header_offset (eb, fh); + right_gen =btrfs_file_header_generation (eb, fh); left_offset_fixed = left_offset;if (key.offset < ekey->offset) {
@@ -6358,7 +6357,7 @@ static int range_is_hole_in_parent(struct send_ctx *sctx,while (search_start < end) {struct extent_buffer *leaf = path->nodes[0 ];int slot = path->slots[0 ]; -struct btrfs_file_extent_item *fi; +struct btrfs_file_header *fh;u64 extent_end;if (slot >=btrfs_header_nritems (leaf)) {
@@ -6379,13 +6378,13 @@ static int range_is_hole_in_parent(struct send_ctx *sctx, key.offset >= end)break ; - fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); + fh = btrfs_item_ptr(leaf, slot, struct btrfs_file_header); extent_end =btrfs_file_extent_end (path);if (extent_end <= start) goto next; -if (btrfs_file_extent_type (leaf, fi) ==BTRFS_FILE_EXTENT_INLINE ) +if (btrfs_file_header_type (leaf, fh) ==BTRFS_FILE_EXTENT_INLINE )return 0 ; -if (btrfs_file_extent_disk_bytenr (leaf, fi) ==0 ) { +if (btrfs_file_header_disk_bytenr (leaf, fh) ==0 ) { search_start = extent_end; goto next; }
@@ -6455,12 +6454,12 @@ static int process_extent(struct send_ctx *sctx, goto out_hole; } }else { -struct btrfs_file_extent_item *ei; +struct btrfs_file_header *fh;u8 type; - ei =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], - struct btrfs_file_extent_item); - type =btrfs_file_extent_type (path->nodes[0 ], ei); + fh =btrfs_item_ptr (path->nodes[0 ], path->slots[0 ], + struct btrfs_file_header); + type =btrfs_file_header_type (path->nodes[0 ], fh);if (type ==BTRFS_FILE_EXTENT_PREALLOC || type ==BTRFS_FILE_EXTENT_REG ) {/*
@@ -6475,7 +6474,7 @@ static int process_extent(struct send_ctx *sctx, }/* Have a hole, just skip it. */ -if (btrfs_file_extent_disk_bytenr (path->nodes[0 ], ei) ==0 ) { +if (btrfs_file_header_disk_bytenr (path->nodes[0 ], fh) ==0 ) { ret =0 ; goto out; }
fs/btrfs/tree-log.c +35 -35
194 lines not on this page · raw message
Signature · 1 line
2.52.0
Gentle ping.
I guess the series is too invasive by introducing a new structure just to do the type checks, and require every caller to convert to the new type thus resulting a huge amount of code change.
If that's the concern, I can enhance the existing accessors to do a proper type check for those exclusive members to regular extents.
Thanks,
Qu
Quoted 74 lines · Qu Wenruo
The structure
btrfs_file_extent_itemis defined that if one file extent is inlined, the data starts afterbtrfs_file_extent_item::type, aka, overlapping withbtrfs_file_extent_item::disk_bytenrand other members.This makes it harder to understand btrfs on-disk format.
This also requires every user of
btrfs_file_extent_item::disk_bytenrand other non-inline members to checkbtrfs_file_extent_item::typefirst.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_headerstructure to define the shared part Initially I'm planning to use ms-extension to define an unnamed structure insidebtrfs_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()forbtrfs_file_extent_itemThis allows using the samebtrfs_file_headerpointer to access thebtrfs_file_extent_itemexclusive members, with built-inASSERT()to catch incorrect types.- Convert existing
btrfs_file_extent_itempointer users tobtrfs_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_itempointer Those sites are known to handling non-inlined extents, thus can still use the old pointer, but not recommended anymore.Qu Wenruo (7):
btrfs: introducebtrfs_file_headerstructure
btrfs: usebtrfs_file_headerstructure for tree-checker
btrfs: usebtrfs_file_headerstructure for trace events
btrfs: usebtrfs_file_headerstructure forinode.c
btrfs: usebtrfs_file_headerstructure for simple usages
btrfs: usebtrfs_file_headerstructure forfile.c
btrfs: usebtrfs_file_headerstructure forsend.candtree-log.cfs/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(-)