btrfs: extent-map: use disk_bytenr/offset to replace block_start/block_len/orig_start
Subsystems (2)
cover btrfs: extent-map: use disk_bytenr/offset to replace block_start/block_len/orig_start
[CHANGELOG]
v1:
- Rebased to the latest for-next
To resolve the conflicts with the recently introduced extent map shrinker
- A new cleanup patch to remove the recursive header inclusion
- Use a new structure to pass the file extent item related members around
- Add a new comment on why we're intentionally passing incorrect numbers for NOCOW/PREALLOC ordered extents inside btrfs_create_dio_extent()
[REPO]
https://github.com/adam900710/linux/tree/em_cleanup
This series introduce two new members (disk_bytenr/offset) to extent_map, and removes three old members (block_start/block_len/offset), finally rename one member (orig_block_len -> disk_num_bytes).
This should save us one u64 for extent_map, although with the recent extent map shrinker, the saving is not that useful.
But to make things safe to migrate, I introduce extra sanity checks for extent_map, and do cross check for both old and new members.
The extra sanity checks already exposed one bug (thankfully harmless) causing em::block_start to be incorrect.
But so far, the patchset is fine for default fstests run.
Furthermore, since we're already having too long parameter lists for extent_map/ordered_extent/can_nocow_extent, here is a new structure, btrfs_file_extent, a memory-access-friendly structure to represent a btrfs_file_extent_item.
With the help of that structure, we can use that to represent a file extent item without a super long parameter list.
The patchset would do one cleanup first, then rename orig_block_len to disk_num_bytes.
Then introduce the new member, the extra sanity checks. Finally introduce the new btrfs_file_extent structure and use that to remove the older 3 members from extent_map.
Qu Wenruo (9):
btrfs: remove the recursive include of btrfs_inode.h from itself
btrfs: rename extent_map::orig_block_len to disk_num_bytes
btrfs: export the expected file extent through can_nocow_extent()
btrfs: introduce new members for extent_map
btrfs: introduce extra sanity checks for extent maps
btrfs: remove extent_map::orig_start member
btrfs: remove extent_map::block_len member
btrfs: remove extent_map::block_start member
btrfs: remove parameters duplicated from btrfs_file_extent
fs/btrfs/btrfs_inode.h | 6 +- fs/btrfs/compression.c | 7 +- fs/btrfs/defrag.c | 14 +- fs/btrfs/extent_io.c | 10 +- fs/btrfs/extent_map.c | 187 +++++++++++------ fs/btrfs/extent_map.h | 51 +++-- fs/btrfs/file-item.c | 23 +-- fs/btrfs/file.c | 18 +- fs/btrfs/inode.c | 333 +++++++++++++++--------------- fs/btrfs/ordered-data.c | 20 +- fs/btrfs/ordered-data.h | 22 +- fs/btrfs/relocation.c | 5 +- fs/btrfs/tests/extent-map-tests.c | 114 +++++----- fs/btrfs/tests/inode-tests.c | 177 ++++++++-------- fs/btrfs/tree-log.c | 25 ++- fs/btrfs/zoned.c | 4 +- include/trace/events/btrfs.h | 26 +-- 17 files changed, 560 insertions(+), 482 deletions(-)
Signature · 1 line
2.44.0
PATCH 1/9 btrfs: remove the recursive include of btrfs_inode.h from itself
Inside btrfs_inode.h we include itself, although it's not causing any problem, it's still being reported by clangd, and is really unnecessary.
Just remove the recursive include.
--- fs/btrfs/btrfs_inode.h | 1 - 1 file changed, 1 deletion(-)
fs/btrfs/btrfs_inode.h +0 -1
@@ -19,7 +19,6 @@#include <uapi/linux/btrfs_tree.h> #include <trace/events/btrfs.h> #include "block-rsv.h" -#include "btrfs_inode.h" #include "extent_map.h" #include "extent_io.h" #include "extent-io-tree.h"
Signature · 1 line
2.44.0
PATCH 2/9 btrfs: rename extent_map::orig_block_len to disk_num_bytes
In reply to Qu WenruoThis would make it very obvious that the member just matches btrfs_file_extent_item::disk_num_bytes.
--- fs/btrfs/extent_map.c | 16 ++++++++-------- fs/btrfs/extent_map.h | 2 +- fs/btrfs/file-item.c | 4 ++-- fs/btrfs/file.c | 2 +- fs/btrfs/inode.c | 10 +++++----- fs/btrfs/tree-log.c | 6 +++--- 6 files changed, 20 insertions(+), 20 deletions(-)
fs/btrfs/extent_map.c +8 -8
@@ -783,14 +783,14 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->block_len = em->block_len; else split->block_len = split->len; - split->orig_block_len =max (split->block_len, - em->orig_block_len); + split->disk_num_bytes =max (split->block_len, + em->disk_num_bytes); split->ram_bytes = em->ram_bytes; }else { split->orig_start = split->start; split->block_len =0 ; split->block_start = em->block_start; - split->orig_block_len =0 ; + split->disk_num_bytes =0 ; split->ram_bytes = split->len; }
@@ -815,8 +815,8 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->generation = gen;if (em->block_start <EXTENT_MAP_LAST_BYTE ) { - split->orig_block_len =max (em->block_len, - em->orig_block_len); + split->disk_num_bytes =max (em->block_len, + em->disk_num_bytes); split->ram_bytes = em->ram_bytes;if (compressed) {
@@ -833,7 +833,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->ram_bytes = split->len; split->orig_start = split->start; split->block_len =0 ; - split->orig_block_len =0 ; + split->disk_num_bytes =0 ; }if (extent_map_in_tree (em)) {
@@ -990,7 +990,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_pre->orig_start = split_pre->start; split_pre->block_start = new_logical; split_pre->block_len = split_pre->len; - split_pre->orig_block_len = split_pre->block_len; + split_pre->disk_num_bytes = split_pre->block_len; split_pre->ram_bytes = split_pre->len; split_pre->flags = flags; split_pre->generation = em->generation;
@@ -1008,7 +1008,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_mid->orig_start = split_mid->start; split_mid->block_start = em->block_start + pre; split_mid->block_len = split_mid->len; - split_mid->orig_block_len = split_mid->block_len; + split_mid->disk_num_bytes = split_mid->block_len; split_mid->ram_bytes = split_mid->len; split_mid->flags = flags; split_mid->generation = em->generation;
fs/btrfs/extent_map.h +1 -1
@@ -75,7 +75,7 @@ struct extent_map {* The full on-disk extent length, matching * btrfs_file_extent_item::disk_num_bytes. */ -u64 orig_block_len; +u64 disk_num_bytes;/* * The decompressed size of the whole on-disk extent, matching
fs/btrfs/file-item.c +2 -2
@@ -1294,7 +1294,7 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->len =btrfs_file_extent_end (path) - extent_start; em->orig_start = extent_start -btrfs_file_extent_offset (leaf, fi); - em->orig_block_len =btrfs_file_extent_disk_num_bytes (leaf, fi); + em->disk_num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); bytenr =btrfs_file_extent_disk_bytenr (leaf, fi);if (bytenr ==0 ) { em->block_start =EXTENT_MAP_HOLE ;
@@ -1303,7 +1303,7 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,if (compress_type !=BTRFS_COMPRESS_NONE ) {extent_map_set_compression (em, compress_type); em->block_start = bytenr; - em->block_len = em->orig_block_len; + em->block_len = em->disk_num_bytes; }else { bytenr +=btrfs_file_extent_offset (leaf, fi); em->block_start = bytenr;
fs/btrfs/file.c +1 -1
@@ -2338,7 +2338,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->block_len =0 ; - hole_em->orig_block_len =0 ; + hole_em->disk_num_bytes =0 ; hole_em->generation = trans->transid; ret =btrfs_replace_extent_map_range (inode, hole_em, true);
fs/btrfs/inode.c +5 -5
@@ -4930,7 +4930,7 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size) hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->block_len =0 ; - hole_em->orig_block_len =0 ; + hole_em->disk_num_bytes =0 ; hole_em->ram_bytes = hole_size; hole_em->generation =btrfs_get_fs_generation (fs_info);
@@ -7251,7 +7251,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,/* The callers of this must take lock_extent() */ static struct extent_map *create_io_em (struct btrfs_inode *inode,u64 start,u64 len,u64 orig_start,u64 block_start, -u64 block_len,u64 orig_block_len, +u64 block_len,u64 disk_num_bytes,u64 ram_bytes,int compress_type,int type) {
@@ -7283,7 +7283,7 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,ASSERT (block_len == len);/* COW results a new extent matching our file extent size. */ -ASSERT (orig_block_len == len); +ASSERT (disk_num_bytes == len);ASSERT (ram_bytes == len);/* Since it's a new extent, we should not have any offset. */
@@ -7310,7 +7310,7 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start, em->len = len; em->block_len = block_len; em->block_start = block_start; - em->orig_block_len = orig_block_len; + em->disk_num_bytes = disk_num_bytes; em->ram_bytes = ram_bytes; em->generation =-1 ; em->flags |=EXTENT_FLAG_PINNED ;
@@ -9546,7 +9546,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, em->len = ins.offset; em->block_start = ins.objectid; em->block_len = ins.offset; - em->orig_block_len = ins.offset; + em->disk_num_bytes = ins.offset; em->ram_bytes = ins.offset; em->flags |=EXTENT_FLAG_PREALLOC ; em->generation = trans->transid;
fs/btrfs/tree-log.c +3 -3
@@ -2874,7 +2874,7 @@ static inline void btrfs_remove_log_ctx(struct btrfs_root *root,mutex_unlock (&root->log_mutex); } -/* +/* * Invoked in log mutex context, or be sure there is no other task which * can access the list. */
@@ -4648,7 +4648,7 @@ static int log_extent_csums(struct btrfs_trans_handle *trans,/* If we're compressed we have to save the entire range of csums. */ if (extent_map_is_compressed (em)) { csum_offset =0 ; - csum_len =max (em->block_len, em->orig_block_len); + csum_len =max (em->block_len, em->disk_num_bytes); }else { csum_offset = mod_start - em->start; csum_len = mod_len;
@@ -4698,7 +4698,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,else btrfs_set_stack_file_extent_type (&fi,BTRFS_FILE_EXTENT_REG ); - block_len =max (em->block_len, em->orig_block_len); + block_len =max (em->block_len, em->disk_num_bytes); compress_type =extent_map_compression (em);if (compress_type !=BTRFS_COMPRESS_NONE ) {btrfs_set_stack_file_extent_disk_bytenr (&fi, em->block_start);
Signature · 1 line
2.44.0
PATCH 3/9 btrfs: export the expected file extent through can_nocow_extent()
In reply to Qu WenruoCurrently function can_nocow_extent() only returns members needed for extent_map.
However since we will soon change the extent_map structure to be more like btrfs_file_extent_item, we want to expose the expected file extent caused by the NOCOW write for future usage.
This would introduce a new structure, btrfs_file_extent, to be a more memory-access-friendly representation of btrfs_file_extent_item. And use that structure to expose the expected file extent caused by the NOCOW write.
For now there is no user of the new structure yet.
--- fs/btrfs/btrfs_inode.h | 20 +++++++++++++++++++- fs/btrfs/file.c | 2 +- fs/btrfs/inode.c | 22 +++++++++++++++++++--- 3 files changed, 39 insertions(+), 5 deletions(-)
fs/btrfs/btrfs_inode.h +19 -1
@@ -443,9 +443,27 @@ int btrfs_check_sector_csum(struct btrfs_fs_info *fs_info, struct page *page, u32 pgoff, u8 *csum, const u8 * const csum_expected);bool btrfs_data_csum_ok (struct btrfs_bio *bbio,struct btrfs_device *dev,u32 bio_offset,struct bio_vec *bv); + +/* +* A more access-friendly representation of btrfs_file_extent_item. +* +* Unused members are excluded. +*/ +struct btrfs_file_extent { +u64 disk_bytenr; +u64 disk_num_bytes; + +u64 num_bytes; +u64 ram_bytes; +u64 offset; + +u8 compression; +}; + noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,u64 *orig_start,u64 *orig_block_len, -u64 *ram_bytes,bool nowait,bool strict); +u64 *ram_bytes,struct btrfs_file_extent *file_extent, +bool nowait,bool strict);void btrfs_del_delalloc_inode (struct btrfs_inode *inode);struct inode *btrfs_lookup_dentry (struct inode *dir,struct dentry *dentry);
fs/btrfs/file.c +1 -1
@@ -1104,7 +1104,7 @@ int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos, &cached_state); } ret =can_nocow_extent (&inode->vfs_inode, lockstart, &num_bytes, -NULL ,NULL ,NULL , nowait, false); +NULL ,NULL ,NULL ,NULL , nowait, false);if (ret <=0 )btrfs_drew_write_unlock (&root->snapshot_lock);else
fs/btrfs/inode.c +19 -3
@@ -1830,6 +1830,9 @@ struct can_nocow_file_extent_args {u64 extent_offset;/* Number of bytes that can be written to in NOCOW mode. */ u64 num_bytes; + +/* The expected file extent for the NOCOW write. */ +struct btrfs_file_extent file_extent; };/*
@@ -1894,6 +1897,12 @@ static int can_nocow_file_extent(struct btrfs_path *path, 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); +/* * The following checks can be expensive, as they need to take other * locks and do btree or rbtree searches, so release the path to avoid
@@ -1928,6 +1937,9 @@ static int can_nocow_file_extent(struct btrfs_path *path, args->disk_bytenr += args->start - key->offset; args->num_bytes =min (args->end +1 , extent_end) - args->start; + args->file_extent.num_bytes = args->num_bytes; + args->file_extent.offset += args->start - key->offset; +/* * Force COW if csums exist in the range. This ensures that csums for a * given extent are either valid or do not exist.
@@ -7058,7 +7070,8 @@ static bool btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr)*/ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,u64 *orig_start,u64 *orig_block_len, -u64 *ram_bytes,bool nowait,bool strict) +u64 *ram_bytes,struct btrfs_file_extent *file_extent, +bool nowait,bool strict) {struct btrfs_fs_info *fs_info =inode_to_fs_info (inode);struct can_nocow_file_extent_args nocow_args = {0 };
@@ -7147,6 +7160,9 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, *orig_start = key.offset - nocow_args.extent_offset;if (orig_block_len) *orig_block_len = nocow_args.disk_num_bytes; +if (file_extent) +memcpy (file_extent, &nocow_args.file_extent, +sizeof (struct btrfs_file_extent )); *len = nocow_args.num_bytes; ret =1 ;
@@ -7366,7 +7382,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, block_start = em->block_start + (start - em->start);if (can_nocow_extent (inode, start, &len, &orig_start, - &orig_block_len, &ram_bytes, false, false) ==1 ) { + &orig_block_len, &ram_bytes,NULL , false, false) ==1 ) { bg =btrfs_inc_nocow_writers (fs_info, block_start);if (bg) can_nocow = true;
@@ -10617,7 +10633,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,free_extent_map (em); em =NULL ; - ret =can_nocow_extent (inode, start, &len,NULL ,NULL ,NULL , false, true); + ret =can_nocow_extent (inode, start, &len,NULL ,NULL ,NULL ,NULL , false, true);if (ret <0 ) { goto out; }else if (ret) {
Signature · 1 line
2.44.0
PATCH 4/9 btrfs: introduce new members for extent_map
In reply to Qu WenruoIntroduce two new members for extent_map:
- disk_bytenr
- offset
Both are matching the members with the same name inside btrfs_file_extent_items.
For now this patch only touches those members when:
- Reading btrfs_file_extent_items from disk
- Inserting new holes
- Merging two extent maps
With the new disk_bytenr and disk_num_bytes, doing merging would be a little complex, as we have 3 different cases:
* Both extent maps are referring to the same data extent
* Both extent maps are referring to different data extents, but those data extents are adjacent, and extent maps are at head/tail of each data extents
* One of the extent map is referring to an merged and larger data extent that covers both extent maps
The 3rd case seems only valid in selftest (test_case_3()), but a new helper merge_ondisk_extents() should be able to handle all of them.
To properly assign values for those new members, a new btrfs_file_extent parameter is introduced to all the involved call sites.
- For NOCOW writes the btrfs_file_extent would be exposed from can_nocow_file_extent().
- For other writes, the members can be easily calculated
As most of them have 0 offset and utilizing the whole on-disk data extent.
The exception is encoded write, but thankfully that interface provided offset directly and all other needed info.
For now, both the old members (block_start/block_len/orig_start) are co-existing with the new members (disk_bytenr/offset), meanwhile all the critical code is still using the old members only.
The cleanup would happen later after all the older and newer members are properly validated.
--- fs/btrfs/defrag.c | 4 +++ fs/btrfs/extent_map.c | 75 +++++++++++++++++++++++++++++++++++++++++-- fs/btrfs/extent_map.h | 17 ++++++++++ fs/btrfs/file-item.c | 9 +++++- fs/btrfs/file.c | 1 + fs/btrfs/inode.c | 60 ++++++++++++++++++++++++++++++---- 6 files changed, 155 insertions(+), 11 deletions(-)
fs/btrfs/defrag.c +4 -0
@@ -709,6 +709,10 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode, em->start = start; em->orig_start = start; em->block_start =EXTENT_MAP_HOLE ; + em->disk_bytenr =EXTENT_MAP_HOLE ; + em->disk_num_bytes =0 ; + em->ram_bytes =0 ; + em->offset =0 ; em->len = key.offset - start;break ; }
fs/btrfs/extent_map.c +72 -3
149 lines not on this page · raw message
fs/btrfs/extent_map.h +17 -0
@@ -71,12 +71,29 @@ struct extent_map {*/ u64 orig_start; +/* +* The bytenr for of the full on-disk extent. +* +* For regular extents it's btrfs_file_extent_item::disk_bytenr. +* For holes it's EXTENT_MAP_HOLE and for inline extents it's +* EXTENT_MAP_INLINE. +*/ +u64 disk_bytenr; +/* * The full on-disk extent length, matching * btrfs_file_extent_item::disk_num_bytes. */ u64 disk_num_bytes; +/* +* Offset inside the decompressed extent. +* +* For regular extents it's btrfs_file_extent_item::offset. +* For holes and inline extents it's 0. +*/ +u64 offset; +/* * The decompressed size of the whole on-disk extent, matching * btrfs_file_extent_item::ram_bytes.
fs/btrfs/file-item.c +8 -1
@@ -1294,12 +1294,17 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->len =btrfs_file_extent_end (path) - extent_start; em->orig_start = extent_start -btrfs_file_extent_offset (leaf, fi); - em->disk_num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); bytenr =btrfs_file_extent_disk_bytenr (leaf, fi);if (bytenr ==0 ) { em->block_start =EXTENT_MAP_HOLE ; + em->disk_bytenr =EXTENT_MAP_HOLE ; + em->disk_num_bytes =0 ; + em->offset =0 ;return ; } + em->disk_bytenr =btrfs_file_extent_disk_bytenr (leaf, fi); + em->disk_num_bytes =btrfs_file_extent_disk_num_bytes (leaf, fi); + em->offset =btrfs_file_extent_offset (leaf, fi);if (compress_type !=BTRFS_COMPRESS_NONE ) {extent_map_set_compression (em, compress_type); em->block_start = bytenr;
@@ -1316,8 +1321,10 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,ASSERT (extent_start ==0 ); em->block_start =EXTENT_MAP_INLINE ; + em->disk_bytenr =EXTENT_MAP_INLINE ; em->start =0 ; em->len = fs_info->sectorsize; + em->offset =0 ;/* * Initialize orig_start and block_len with the same values * as in inode.c:btrfs_get_extent().
fs/btrfs/file.c +1 -0
@@ -2337,6 +2337,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, hole_em->orig_start = offset; hole_em->block_start =EXTENT_MAP_HOLE ; + hole_em->disk_bytenr =EXTENT_MAP_HOLE ; hole_em->block_len =0 ; hole_em->disk_num_bytes =0 ; hole_em->generation = trans->transid;
fs/btrfs/inode.c +53 -7
207 lines not on this page · raw message
Signature · 1 line
2.44.0
PATCH 5/9 btrfs: introduce extra sanity checks for extent maps
In reply to Qu WenruoSince extent_map structure has the all the needed members to represent a file extent directly, we can apply all the file extent sanity checks to an extent map.
The new sanity checks would cross check both the old members (block_start/block_len/orig_start) and the new members (disk_bytenr/disk_num_bytes/offset).
There is a special case for offset/orig_start/start cross check, we only do such sanity check for compressed extent:
- Only compressed read/encoded write really utilize orig_start This can be proved by the cleanup patch of orig_start.
- Merged data extents can lead to false alerts
The problem is, with disk_bytenr/disk_num_bytes, if we're merging two extent maps like this:
|<- data extent A -->|<-- data extent B -->|
|<- em 1 ->|<- em 2 ->| Let's assume em2 has orig_offset of 0 and start of 0, and obvisouly offset 0.
But after merging, the merged em would have offset of em1, screwing up whatever the @orig_start cross check against @start.
The checks happens at the following timing:
- add_extent_mapping()
This is for newly added extent map
- replace_extent_mapping()
This is for btrfs_drop_extent_map_range() and split_extent_map()
- try_merge_map()
Since the check is way more strict than before, the following code has to be modified to pass the check:
- extent-map-tests
Previously the test case never populate ram_bytes, not to mention the newly introduced disk_bytenr/disk_num_bytes.
Populate the involved numbers mostly to follow the existing block_start/block_len values.
There are two special cases worth mentioning:
- test_case_3()
The test case is already way too invalid that tree-checker will reject almost all extents.
And there is a special unaligned regular extent which has mismatch disk_num_bytes (4096) and ram_bytes (4096 - 1).
Fix it by all assigned the disk_num_bytes and ram_bytes to 4096 - 1.
- test_case_7()
An extent is inserted with 16K length, but on-disk extent size is only 4K.
This means it must be a compressed extent, so set the compressed flag for it.
- setup_relocation_extent_mapping()
This is mostly utilized by relocation code to read the chunk like an inode.
So populate the extent map using a regular non-compressed extent.
In fact, the new cross checks already exposed a bug in btrfs_drop_extent_map_range(), and caught tons of bugs in the new members assignment.
--- fs/btrfs/extent_map.c | 66 +++++++++++++++++++++++++++++++ fs/btrfs/relocation.c | 4 ++ fs/btrfs/tests/extent-map-tests.c | 56 +++++++++++++++++++++++++- fs/btrfs/tests/inode-tests.c | 2 +- 4 files changed, 126 insertions(+), 2 deletions(-)
fs/btrfs/extent_map.c +66 -0
@@ -284,6 +284,66 @@ static void merge_ondisk_extents(struct extent_map *prev, struct extent_map *nex next->offset = new_offset; } +static void dump_extent_map (const char *prefix,struct extent_map *em) +{ +if (!IS_ENABLED (CONFIG_BTRFS_DEBUG )) +return ; +pr_crit ("%s, start=%llu len=%llu disk_bytenr=%llu disk_num_bytes=%llu ram_bytes=%llu offset=%llu orig_start=%llu block_start=%llu block_len=%llu flags=0x%x\n" , + prefix, em->start, em->len, em->disk_bytenr, em->disk_num_bytes, + em->ram_bytes, em->offset, em->orig_start, em->block_start, + em->block_len, em->flags); +ASSERT (0 ); +} + +/* Internal sanity checks for btrfs debug builds. */ +static void validate_extent_map (struct extent_map *em) +{ +if (!IS_ENABLED (CONFIG_BTRFS_DEBUG )) +return ; +if (em->disk_bytenr <EXTENT_MAP_LAST_BYTE ) { +if (em->disk_num_bytes ==0 ) +dump_extent_map ("zero disk_num_bytes" , em); +if (em->offset + em->len > em->ram_bytes) +dump_extent_map ("ram_bytes too small" , em); +if (em->offset + em->len > em->disk_num_bytes && + !extent_map_is_compressed (em)) +dump_extent_map ("disk_num_bytes too small" , em); + +if (extent_map_is_compressed (em)) { +if (em->block_start != em->disk_bytenr) +dump_extent_map ( +"mismatch block_start/disk_bytenr/offset" , em); +if (em->disk_num_bytes != em->block_len) +dump_extent_map ( +"mismatch disk_num_bytes/block_len" , em); +/* +* Here we only check the start/orig_start/offset for +* compressed extents. +* This is because em::offset is always based on the +* referred data extent, which can be merged. +* +* In that case, @offset would no longer match +* em::start - em::orig_start, and cause false alert. +* +* Thankfully only compressed extent read/encoded write +* really bothers @orig_start, so we can skip +* the check for non-compressed extents. +*/ +if (em->orig_start != em->start - em->offset) +dump_extent_map ( +"mismatch orig_start/offset/start" , em); + + }else { +if (em->block_start != em->disk_bytenr + em->offset) +dump_extent_map ( +"mismatch block_start/disk_bytenr/offset" , em); + } + }else { +if (em->offset) +dump_extent_map ("non-zero offset for hole/inline" , em); + } +} +static void try_merge_map (struct btrfs_inode *inode,struct extent_map *em) {struct extent_map_tree *tree = &inode->extent_tree;
@@ -320,6 +380,7 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em)merge_ondisk_extents (merge, em); em->flags |=EXTENT_FLAG_MERGED ; +validate_extent_map (em);rb_erase_cached (&merge->rb_node, &tree->map);RB_CLEAR_NODE (&merge->rb_node);free_extent_map (merge);
@@ -335,6 +396,7 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em) em->block_len += merge->block_len;if (em->disk_bytenr <EXTENT_MAP_LAST_BYTE )merge_ondisk_extents (em, merge); +validate_extent_map (em);rb_erase_cached (&merge->rb_node, &tree->map);RB_CLEAR_NODE (&merge->rb_node); em->generation =max (em->generation, merge->generation);
@@ -446,6 +508,7 @@ static int add_extent_mapping(struct btrfs_inode *inode,lockdep_assert_held_write (&tree->lock); +validate_extent_map (em); ret =tree_insert (&tree->map, em);if (ret)return ret;
@@ -553,6 +616,9 @@ static void replace_extent_mapping(struct btrfs_inode *inode,lockdep_assert_held_write (&tree->lock); +validate_extent_map (cur); +validate_extent_map (new); +WARN_ON (cur->flags &EXTENT_FLAG_PINNED );ASSERT (extent_map_in_tree (cur));if (!(cur->flags &EXTENT_FLAG_LOGGING ))
fs/btrfs/relocation.c +4 -0
@@ -2911,9 +2911,13 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inodreturn -ENOMEM ; em->start = start; + em->orig_start = start; em->len = end +1 - start; em->block_len = em->len; em->block_start = block_start; + em->disk_bytenr = block_start; + em->disk_num_bytes = em->len; + em->ram_bytes = em->len; em->flags |=EXTENT_FLAG_PINNED ;lock_extent (&BTRFS_I (inode)->io_tree, start, end, &cached_state);
fs/btrfs/tests/extent-map-tests.c +55 -1
173 lines not on this page · raw message
fs/btrfs/tests/inode-tests.c +1 -1
@@ -117,7 +117,7 @@ static void setup_file_extents(struct btrfs_root *root, u32 sectorsize)/* Now for a regular extent */ insert_extent (root, offset, sectorsize -1 , sectorsize -1 ,0 , - disk_bytenr, sectorsize,BTRFS_FILE_EXTENT_REG ,0 , slot); + disk_bytenr, sectorsize -1 ,BTRFS_FILE_EXTENT_REG ,0 , slot); slot++; disk_bytenr += sectorsize; offset += sectorsize -1 ;
Signature · 1 line
2.44.0
PATCH 6/9 btrfs: remove extent_map::orig_start member
In reply to Qu WenruoSince we have extent_map::offset, the old extent_map::orig_start is just extent_map::start - extent_map::offset for non-hole/inline extents.
And since the new extent_map::offset would be verified by validate_extent_map() already meanwhile the old orig_start is not, let's just remove the old member from all call sites.
--- fs/btrfs/btrfs_inode.h | 2 +- fs/btrfs/compression.c | 2 +- fs/btrfs/defrag.c | 1 - fs/btrfs/extent_map.c | 29 +---------- fs/btrfs/extent_map.h | 9 ---- fs/btrfs/file-item.c | 5 +- fs/btrfs/file.c | 3 +- fs/btrfs/inode.c | 37 +++++--------- fs/btrfs/relocation.c | 1 - fs/btrfs/tests/extent-map-tests.c | 9 ---- fs/btrfs/tests/inode-tests.c | 84 +++++++++++++------------------ fs/btrfs/tree-log.c | 2 +- include/trace/events/btrfs.h | 14 ++---- 13 files changed, 60 insertions(+), 138 deletions(-)
fs/btrfs/btrfs_inode.h +1 -1
@@ -461,7 +461,7 @@ struct btrfs_file_extent { }; noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, -u64 *orig_start,u64 *orig_block_len, +u64 *orig_block_len,u64 *ram_bytes,struct btrfs_file_extent *file_extent,bool nowait,bool strict);
fs/btrfs/compression.c +1 -1
@@ -590,7 +590,7 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio) cb =alloc_compressed_bio (inode, file_offset,REQ_OP_READ , end_bbio_comprssed_read); - cb->start = em->orig_start; + cb->start = em->start - em->offset; em_len = em->len; em_start = em->start;
fs/btrfs/defrag.c +0 -1
@@ -707,7 +707,6 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,*/ if (key.offset > start) { em->start = start; - em->orig_start = start; em->block_start =EXTENT_MAP_HOLE ; em->disk_bytenr =EXTENT_MAP_HOLE ; em->disk_num_bytes =0 ;
fs/btrfs/extent_map.c +2 -27
@@ -288,9 +288,9 @@ static void dump_extent_map(const char *prefix, struct extent_map *em) {if (!IS_ENABLED (CONFIG_BTRFS_DEBUG ))return ; -pr_crit ("%s, start=%llu len=%llu disk_bytenr=%llu disk_num_bytes=%llu ram_bytes=%llu offset=%llu orig_start=%llu block_start=%llu block_len=%llu flags=0x%x\n" , +pr_crit ("%s, start=%llu len=%llu disk_bytenr=%llu disk_num_bytes=%llu ram_bytes=%llu offset=%llu block_start=%llu block_len=%llu flags=0x%x\n" , prefix, em->start, em->len, em->disk_bytenr, em->disk_num_bytes, - em->ram_bytes, em->offset, em->orig_start, em->block_start, + em->ram_bytes, em->offset, em->block_start, em->block_len, em->flags);ASSERT (0 ); }
@@ -316,23 +316,6 @@ static void validate_extent_map(struct extent_map *em)if (em->disk_num_bytes != em->block_len)dump_extent_map ("mismatch disk_num_bytes/block_len" , em); -/* -* Here we only check the start/orig_start/offset for -* compressed extents. -* This is because em::offset is always based on the -* referred data extent, which can be merged. -* -* In that case, @offset would no longer match -* em::start - em::orig_start, and cause false alert. -* -* Thankfully only compressed extent read/encoded write -* really bothers @orig_start, so we can skip -* the check for non-compressed extents. -*/ -if (em->orig_start != em->start - em->offset) -dump_extent_map ( -"mismatch orig_start/offset/start" , em); - }else {if (em->block_start != em->disk_bytenr + em->offset) dump_extent_map(
@@ -370,7 +353,6 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em) merge = rb_entry(rb, struct extent_map, rb_node);if (rb &&can_merge_extent_map (merge) &&mergeable_maps (merge, em)) { em->start = merge->start; - em->orig_start = merge->orig_start; em->len += merge->len; em->block_len += merge->block_len; em->block_start = merge->block_start;
@@ -900,7 +882,6 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->len = start - em->start;if (em->block_start <EXTENT_MAP_LAST_BYTE ) { - split->orig_start = em->orig_start; split->block_start = em->block_start;if (compressed)
@@ -913,7 +894,6 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->offset = em->offset; split->ram_bytes = em->ram_bytes; }else { - split->orig_start = split->start; split->block_len =0 ; split->block_start = em->block_start; split->disk_bytenr = em->disk_bytenr;
@@ -950,19 +930,16 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end, split->ram_bytes = em->ram_bytes;if (compressed) { split->block_len = em->block_len; - split->orig_start = em->orig_start; }else {const u64 diff = end - em->start; split->block_len = split->len; split->block_start += diff; - split->orig_start = em->orig_start; } }else { split->disk_num_bytes =0 ; split->offset =0 ; split->ram_bytes = split->len; - split->orig_start = split->start; split->block_len =0 ; }
@@ -1120,7 +1097,6 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_pre->disk_bytenr = new_logical; split_pre->disk_num_bytes = split_pre->len; split_pre->offset =0 ; - split_pre->orig_start = split_pre->start; split_pre->block_start = new_logical; split_pre->block_len = split_pre->len; split_pre->disk_num_bytes = split_pre->block_len;
@@ -1141,7 +1117,6 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, split_mid->disk_bytenr = em->block_start + pre; split_mid->disk_num_bytes = split_mid->len; split_mid->offset =0 ; - split_mid->orig_start = split_mid->start; split_mid->block_start = em->block_start + pre; split_mid->block_len = split_mid->len; split_mid->ram_bytes = split_mid->len;
fs/btrfs/extent_map.h +0 -9
@@ -62,15 +62,6 @@ struct extent_map {*/ u64 len; -/* -* The file offset of the original file extent before splitting. -* -* This is an in-memory only member, matching -* extent_map::start - btrfs_file_extent_item::offset for -* regular/preallocated extents. EXTENT_MAP_HOLE otherwise. -*/ -u64 orig_start; -/* * The bytenr for of the full on-disk extent. *
fs/btrfs/file-item.c +1 -4
@@ -1292,8 +1292,6 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, type == BTRFS_FILE_EXTENT_PREALLOC) { em->start = extent_start; em->len =btrfs_file_extent_end (path) - extent_start; - em->orig_start = extent_start - -btrfs_file_extent_offset (leaf, fi); bytenr =btrfs_file_extent_disk_bytenr (leaf, fi);if (bytenr ==0 ) { em->block_start =EXTENT_MAP_HOLE ;
@@ -1326,10 +1324,9 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->len = fs_info->sectorsize; em->offset =0 ;/* -* Initialize orig_start and block_len with the same values +* Initialize block_len with the same values * as in inode.c:btrfs_get_extent(). */ - em->orig_start =EXTENT_MAP_HOLE ; em->block_len = (u64)-1 ;extent_map_set_compression (em, compress_type); }else {
fs/btrfs/file.c +1 -2
@@ -1104,7 +1104,7 @@ int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos, &cached_state); } ret =can_nocow_extent (&inode->vfs_inode, lockstart, &num_bytes, -NULL ,NULL ,NULL ,NULL , nowait, false); +NULL ,NULL ,NULL , nowait, false);if (ret <=0 )btrfs_drew_write_unlock (&root->snapshot_lock);else
@@ -2334,7 +2334,6 @@ static int fill_holes(struct btrfs_trans_handle *trans, hole_em->start = offset; hole_em->len = end - offset; hole_em->ram_bytes = hole_em->len; - hole_em->orig_start = offset; hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->disk_bytenr =EXTENT_MAP_HOLE ;
fs/btrfs/inode.c +12 -25
@@ -138,7 +138,7 @@ static noinline int run_delalloc_cow(struct btrfs_inode *inode, u64 end, struct writeback_control *wbc, bool pages_dirty); static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start, - u64 len, u64 orig_start, u64 block_start, + u64 len, u64 block_start, u64 block_len, u64 disk_num_bytes, u64 ram_bytes, int compress_type, struct btrfs_file_extent *file_extent,
@@ -1169,7 +1169,6 @@ static void submit_one_async_extent(struct async_chunk *async_chunk, em = create_io_em(inode, start, async_extent->ram_size, /* len */ - start, /* orig_start */ ins.objectid, /* block_start */ ins.offset, /* block_len */ ins.offset, /* orig_block_len */
@@ -1439,7 +1438,6 @@ static noinline int cow_file_range(struct btrfs_inode *inode, file_extent.offset =0 ; file_extent.compression =BTRFS_COMPRESS_NONE ; em = create_io_em(inode, start, ins.offset, /* len */ - start, /* orig_start */ ins.objectid, /* block_start */ ins.offset, /* block_len */ ins.offset, /* orig_block_len */
@@ -2162,11 +2160,9 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode, nocow_end = cur_offset + nocow_args.num_bytes -1 ; is_prealloc = extent_type ==BTRFS_FILE_EXTENT_PREALLOC ;if (is_prealloc) { -u64 orig_start = found_key.offset - nocow_args.extent_offset;struct extent_map *em; em = create_io_em(inode, cur_offset, nocow_args.num_bytes, - orig_start, nocow_args.disk_bytenr, /* block_start */ nocow_args.num_bytes, /* block_len */ nocow_args.disk_num_bytes, /* orig_block_len */
@@ -4958,7 +4954,6 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size) } hole_em->start = cur_offset; hole_em->len = hole_size; - hole_em->orig_start = cur_offset; hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->disk_bytenr =EXTENT_MAP_HOLE ;
@@ -6821,7 +6816,6 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, goto out; } em->start =EXTENT_MAP_HOLE ; - em->orig_start =EXTENT_MAP_HOLE ; em->disk_bytenr =EXTENT_MAP_HOLE ; em->len = (u64)-1 ; em->block_len = (u64)-1 ;
@@ -6914,7 +6908,6 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,/* New extent overlaps with existing one */ em->start = start; - em->orig_start = start; em->len = found_key.offset - start; em->block_start =EXTENT_MAP_HOLE ; goto insert;
@@ -6950,7 +6943,6 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, } not_found: em->start = start; - em->orig_start = start; em->len = len; em->block_start =EXTENT_MAP_HOLE ; insert:
@@ -6983,7 +6975,6 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,struct btrfs_dio_data *dio_data, const u64 start, const u64 len, - const u64 orig_start, const u64 block_start, const u64 block_len, const u64 orig_block_len,
@@ -6995,7 +6986,7 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,struct btrfs_ordered_extent *ordered;if (type !=BTRFS_ORDERED_NOCOW ) { - em =create_io_em (inode, start, len, orig_start, block_start, + em =create_io_em (inode, start, len, block_start, block_len, orig_block_len, ram_bytes,BTRFS_COMPRESS_NONE ,/* compress_type */ file_extent, type);
@@ -7054,7 +7045,7 @@ static struct extent_map *btrfs_new_extent_direct(struct btrfs_inode *inode, file_extent.ram_bytes = ins.offset; file_extent.offset =0 ; file_extent.compression =BTRFS_COMPRESS_NONE ; - em =btrfs_create_dio_extent (inode, dio_data, start, ins.offset, start, + em =btrfs_create_dio_extent (inode, dio_data, start, ins.offset, ins.objectid, ins.offset, ins.offset, ins.offset,BTRFS_ORDERED_REGULAR , &file_extent);
@@ -7100,7 +7091,7 @@ static bool btrfs_extent_readonly(struct btrfs_fs_info *fs_info, u64 bytenr)* any ordered extents. */ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, -u64 *orig_start,u64 *orig_block_len, +u64 *orig_block_len,u64 *ram_bytes,struct btrfs_file_extent *file_extent,bool nowait,bool strict) {
@@ -7187,8 +7178,6 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, } } -if (orig_start) - *orig_start = key.offset - nocow_args.extent_offset;if (orig_block_len) *orig_block_len = nocow_args.disk_num_bytes;if (file_extent)
@@ -7297,7 +7286,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,/* The callers of this must take lock_extent() */ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start, - u64 len, u64 orig_start, u64 block_start, + u64 len, u64 block_start, u64 block_len, u64 disk_num_bytes, u64 ram_bytes, int compress_type, struct btrfs_file_extent *file_extent,
@@ -7335,7 +7324,7 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,ASSERT (ram_bytes == len);/* Since it's a new extent, we should not have any offset. */ -ASSERT (orig_start == start); +ASSERT (file_extent->offset ==0 );break ;case BTRFS_ORDERED_COMPRESSED :/* Must be compressed. */
@@ -7354,7 +7343,6 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,return ERR_PTR (-ENOMEM ); em->start = start; - em->orig_start = orig_start; em->len = len; em->block_len = block_len; em->block_start = block_start;
@@ -7389,7 +7377,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,struct btrfs_file_extent file_extent = {0 };struct extent_map *em = *map;int type; -u64 block_start, orig_start, orig_block_len, ram_bytes; +u64 block_start, orig_block_len, ram_bytes;struct btrfs_block_group *bg;bool can_nocow = false;bool space_reserved = false;
@@ -7416,7 +7404,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, len =min (len, em->len - (start - em->start)); block_start = em->block_start + (start - em->start); -if (can_nocow_extent (inode, start, &len, &orig_start, +if (can_nocow_extent (inode, start, &len, &orig_block_len, &ram_bytes, &file_extent, false, false) ==1 ) { bg =btrfs_inc_nocow_writers (fs_info, block_start);
@@ -7444,7 +7432,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, space_reserved = true; em2 =btrfs_create_dio_extent (BTRFS_I (inode), dio_data, start, len, - orig_start, block_start, + block_start, len, orig_block_len, ram_bytes, type, &file_extent);
@@ -9595,7 +9583,6 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, } em->start = cur_offset; - em->orig_start = cur_offset; em->len = ins.offset; em->block_start = ins.objectid; em->disk_bytenr = ins.objectid;
@@ -10104,7 +10091,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter, disk_io_size = em->block_len; count = em->block_len; encoded->unencoded_len = em->ram_bytes; - encoded->unencoded_offset = iocb->ki_pos - em->orig_start; + encoded->unencoded_offset = iocb->ki_pos - em->start + em->offset; ret =btrfs_encoded_io_compression_from_extent (fs_info,extent_map_compression (em));if (ret <0 )
@@ -10347,7 +10334,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, file_extent.offset = encoded->unencoded_offset; file_extent.compression = compression; em =create_io_em (inode, start, num_bytes, - start - encoded->unencoded_offset, ins.objectid, + ins.objectid, ins.offset, ins.offset, ram_bytes, compression, &file_extent,BTRFS_ORDERED_COMPRESSED );if (IS_ERR (em)) {
@@ -10679,7 +10666,7 @@ static int btrfs_swap_activate(struct swap_info_struct *sis, struct file *file,free_extent_map (em); em =NULL ; - ret =can_nocow_extent (inode, start, &len,NULL ,NULL ,NULL ,NULL , false, true); + ret =can_nocow_extent (inode, start, &len,NULL ,NULL ,NULL , false, true);if (ret <0 ) { goto out; }else if (ret) {
fs/btrfs/relocation.c +0 -1
@@ -2911,7 +2911,6 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inodreturn -ENOMEM ; em->start = start; - em->orig_start = start; em->len = end +1 - start; em->block_len = em->len; em->block_start = block_start;
fs/btrfs/tests/extent-map-tests.c +0 -9
@@ -99,7 +99,6 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode) } em->start =SZ_16K ; - em->orig_start =SZ_16K ; em->len =SZ_4K ; em->block_start =SZ_32K ;/* avoid merging */ em->block_len =SZ_4K ;
@@ -124,7 +123,6 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)/* Add [0, 8K), should return [0, 16K) instead. */ em->start = start; - em->orig_start = start; em->len = len; em->block_start = start; em->block_len = len;
@@ -206,7 +204,6 @@ static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode) } em->start =SZ_4K ; - em->orig_start =SZ_4K ; em->len =SZ_4K ; em->block_start =SZ_4K ; em->block_len =SZ_4K ;
@@ -283,7 +280,6 @@ static int __test_case_3(struct btrfs_fs_info *fs_info,/* Add [4K, 8K) */ em->start =SZ_4K ; - em->orig_start =SZ_4K ; em->len =SZ_4K ; em->block_start =SZ_4K ; em->block_len =SZ_4K ;
@@ -421,7 +417,6 @@ static int __test_case_4(struct btrfs_fs_info *fs_info,/* Add [8K, 32K) */ em->start =SZ_8K ; - em->orig_start =SZ_8K ; em->len =24 *SZ_1K ; em->block_start =SZ_16K ;/* avoid merging */ em->block_len =24 *SZ_1K ;
@@ -445,7 +440,6 @@ static int __test_case_4(struct btrfs_fs_info *fs_info, }/* Add [0K, 32K) */ em->start =0 ; - em->orig_start =0 ; em->len =SZ_32K ; em->block_start =0 ; em->block_len =SZ_32K ;
@@ -533,7 +527,6 @@ static int add_compressed_extent(struct btrfs_inode *inode, } em->start = start; - em->orig_start = start; em->len = len; em->block_start = block_start; em->block_len =SZ_4K ;
@@ -758,7 +751,6 @@ static int test_case_6(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode) } em->start =SZ_4K ; - em->orig_start =SZ_4K ; em->len =SZ_4K ; em->block_start =SZ_16K ; em->block_len =SZ_16K ;
@@ -840,7 +832,6 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)/* [32K, 48K), not pinned */ em->start =SZ_32K ; - em->orig_start =SZ_32K ; em->len =SZ_16K ; em->block_start =SZ_32K ; em->block_len =SZ_16K ;
fs/btrfs/tests/inode-tests.c +36 -48
174 lines not on this page · raw message
fs/btrfs/tree-log.c +1 -1
@@ -4688,7 +4688,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,struct extent_buffer *leaf;struct btrfs_key key;enum btrfs_compression_type compress_type; -u64 extent_offset = em->start - em->orig_start; +u64 extent_offset = em->offset;u64 block_len;int ret;
include/trace/events/btrfs.h +5 -9
@@ -291,7 +291,6 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __field( u64, ino ) __field( u64, start ) __field( u64, len ) - __field( u64, orig_start ) __field( u64, block_start ) __field( u64, block_len )__field ( u32, flags )
@@ -303,7 +302,6 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __entry->ino =btrfs_ino (inode); __entry->start = map->start; __entry->len = map->len; - __entry->orig_start = map->orig_start; __entry->block_start = map->block_start; __entry->block_len = map->block_len; __entry->flags = map->flags;
@@ -311,13 +309,11 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, ), TP_printk_btrfs("root=%llu(%s) ino=%llu start=%llu len=%llu " - "orig_start=%llu block_start=%llu(%s) " - "block_len=%llu flags=%s refs=%u", + "block_start=%llu(%s) block_len=%llu flags=%s refs=%u", show_root_type(__entry->root_objectid), __entry->ino, __entry->start, __entry->len, - __entry->orig_start, show_map_type(__entry->block_start), __entry->block_len, show_map_flags(__entry->flags),
@@ -861,7 +857,7 @@ TRACE_EVENT(btrfs_add_block_group, { BTRFS_DROP_DELAYED_REF, "DROP_DELAYED_REF" }, \ { BTRFS_ADD_DELAYED_EXTENT, "ADD_DELAYED_EXTENT" }, \ { BTRFS_UPDATE_DELAYED_HEAD, "UPDATE_DELAYED_HEAD" }) - + DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,
@@ -873,7 +869,7 @@ DECLARE_EVENT_CLASS(btrfs_delayed_tree_ref,TP_STRUCT__entry_btrfs (__field (u64 ,bytenr )__field ( u64, num_bytes ) -__field ( int, action ) +__field ( int, action )__field ( u64, parent )__field ( u64, ref_root ) __field( int, level )
@@ -930,7 +926,7 @@ DECLARE_EVENT_CLASS(btrfs_delayed_data_ref,TP_STRUCT__entry_btrfs (__field (u64 ,bytenr )__field ( u64, num_bytes ) -__field ( int, action ) +__field ( int, action )__field ( u64, parent )__field ( u64, ref_root ) __field( u64, owner )
@@ -992,7 +988,7 @@ DECLARE_EVENT_CLASS(btrfs_delayed_ref_head,TP_STRUCT__entry_btrfs (__field (u64 ,bytenr )__field ( u64, num_bytes ) -__field ( int, action ) +__field ( int, action )__field ( int, is_data ) ),
Signature · 1 line
2.44.0
PATCH 7/9 btrfs: remove extent_map::block_len member
In reply to Qu WenruoThe extent_map::block_len is either extent_map::len (non-compressed extent) or extent_map::disk_num_bytes (compressed extent).
Since we already have sanity checks to do the cross-check between the new and old members, we can drop the old extent_map::block_len now.
For most call sites, they can manually select extent_map::len or extent_map::disk_num_bytes, since most if not all of them have checked if the extent is compressed.
--- fs/btrfs/compression.c | 2 +- fs/btrfs/extent_map.c | 41 +++++++++++-------------------- fs/btrfs/extent_map.h | 9 ------- fs/btrfs/file-item.c | 7 ------ fs/btrfs/file.c | 1 - fs/btrfs/inode.c | 36 +++++++++------------------ fs/btrfs/relocation.c | 1 - fs/btrfs/tests/extent-map-tests.c | 41 ++++++++++--------------------- fs/btrfs/tree-log.c | 4 +-- include/trace/events/btrfs.h | 5 +--- 10 files changed, 42 insertions(+), 105 deletions(-)
fs/btrfs/compression.c +1 -1
@@ -585,7 +585,7 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio) }ASSERT (extent_map_is_compressed (em)); - compressed_len = em->block_len; + compressed_len = em->disk_num_bytes; cb =alloc_compressed_bio (inode, file_offset,REQ_OP_READ , end_bbio_comprssed_read);
fs/btrfs/extent_map.c +14 -27
120 lines not on this page · raw message
fs/btrfs/extent_map.h +0 -9
@@ -103,15 +103,6 @@ struct extent_map {*/ u64 block_start; -/* -* The on-disk length for the file extent. -* -* For compressed extents it matches btrfs_file_extent_item::disk_num_bytes. -* For uncompressed extents it matches extent_map::len. -* For holes and inline extents it's -1 and shouldn't be used. -*/ -u64 block_len; -/* * Generation of the extent map, for merged em it's the highest * generation of all merged ems.
fs/btrfs/file-item.c +0 -7
@@ -1306,11 +1306,9 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,if (compress_type !=BTRFS_COMPRESS_NONE ) {extent_map_set_compression (em, compress_type); em->block_start = bytenr; - em->block_len = em->disk_num_bytes; }else { bytenr +=btrfs_file_extent_offset (leaf, fi); em->block_start = bytenr; - em->block_len = em->len;if (type ==BTRFS_FILE_EXTENT_PREALLOC ) em->flags |=EXTENT_FLAG_PREALLOC ; }
@@ -1323,11 +1321,6 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->start =0 ; em->len = fs_info->sectorsize; em->offset =0 ; -/* -* Initialize block_len with the same values -* as in inode.c:btrfs_get_extent(). -*/ - em->block_len = (u64)-1 ;extent_map_set_compression (em, compress_type); }else { btrfs_err(fs_info,
fs/btrfs/file.c +0 -1
@@ -2337,7 +2337,6 @@ static int fill_holes(struct btrfs_trans_handle *trans, hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->disk_bytenr =EXTENT_MAP_HOLE ; - hole_em->block_len =0 ; hole_em->disk_num_bytes =0 ; hole_em->generation = trans->transid;
fs/btrfs/inode.c +11 -25
@@ -139,7 +139,7 @@ static noinline int run_delalloc_cow(struct btrfs_inode *inode, bool pages_dirty);static struct extent_map *create_io_em (struct btrfs_inode *inode,u64 start,u64 len,u64 block_start, -u64 block_len,u64 disk_num_bytes, +u64 disk_num_bytes,u64 ram_bytes,int compress_type,struct btrfs_file_extent *file_extent,int type);
@@ -1170,7 +1170,6 @@ static void submit_one_async_extent(struct async_chunk *async_chunk, em = create_io_em(inode, start, async_extent->ram_size, /* len */ ins.objectid, /* block_start */ - ins.offset, /* block_len */ ins.offset, /* orig_block_len */ async_extent->ram_size, /* ram_bytes */ async_extent->compress_type,
@@ -1439,7 +1438,6 @@ static noinline int cow_file_range(struct btrfs_inode *inode, file_extent.compression =BTRFS_COMPRESS_NONE ; em = create_io_em(inode, start, ins.offset, /* len */ ins.objectid, /* block_start */ - ins.offset, /* block_len */ ins.offset, /* orig_block_len */ ram_size, /* ram_bytes */ BTRFS_COMPRESS_NONE, /* compress_type */
@@ -2164,7 +2162,6 @@ static noinline int run_delalloc_nocow(struct btrfs_inode *inode, em = create_io_em(inode, cur_offset, nocow_args.num_bytes, nocow_args.disk_bytenr, /* block_start */ - nocow_args.num_bytes, /* block_len */ nocow_args.disk_num_bytes, /* orig_block_len */ ram_bytes, BTRFS_COMPRESS_NONE, &nocow_args.file_extent,
@@ -4957,7 +4954,6 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size) hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->disk_bytenr =EXTENT_MAP_HOLE ; - hole_em->block_len =0 ; hole_em->disk_num_bytes =0 ; hole_em->ram_bytes = hole_size; hole_em->generation =btrfs_get_fs_generation (fs_info);
@@ -6818,7 +6814,6 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, em->start =EXTENT_MAP_HOLE ; em->disk_bytenr =EXTENT_MAP_HOLE ; em->len = (u64)-1 ; - em->block_len = (u64)-1 ; path =btrfs_alloc_path ();if (!path) {
@@ -6976,7 +6971,6 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,const u64 start, const u64 len, const u64 block_start, - const u64 block_len, const u64 orig_block_len, const u64 ram_bytes, const int type,
@@ -6987,14 +6981,14 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,if (type !=BTRFS_ORDERED_NOCOW ) { em =create_io_em (inode, start, len, block_start, - block_len, orig_block_len, ram_bytes, + orig_block_len, ram_bytes,BTRFS_COMPRESS_NONE ,/* compress_type */ file_extent, type);if (IS_ERR (em)) goto out; } ordered =btrfs_alloc_ordered_extent (inode, start, len, len, - block_start, block_len,0 , + block_start, len,0 , (1 << type) | (1 <<BTRFS_ORDERED_DIRECT ),BTRFS_COMPRESS_NONE );
@@ -7046,7 +7040,7 @@ static struct extent_map *btrfs_new_extent_direct(struct btrfs_inode *inode, file_extent.offset =0 ; file_extent.compression =BTRFS_COMPRESS_NONE ; em =btrfs_create_dio_extent (inode, dio_data, start, ins.offset, - ins.objectid, ins.offset, ins.offset, + ins.objectid, ins.offset, ins.offset,BTRFS_ORDERED_REGULAR , &file_extent);btrfs_dec_block_group_reservations (fs_info, ins.objectid);
@@ -7287,7 +7281,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,/* The callers of this must take lock_extent() */ static struct extent_map *create_io_em (struct btrfs_inode *inode,u64 start,u64 len,u64 block_start, -u64 block_len,u64 disk_num_bytes, +u64 disk_num_bytes,u64 ram_bytes,int compress_type,struct btrfs_file_extent *file_extent,int type)
@@ -7309,16 +7303,10 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start,switch (type) {case BTRFS_ORDERED_PREALLOC : -/* Uncompressed extents. */ -ASSERT (block_len == len); -/* We're only referring part of a larger preallocated extent. */ -ASSERT (block_len <= ram_bytes); +ASSERT (len <= ram_bytes);break ;case BTRFS_ORDERED_REGULAR : -/* Uncompressed extents. */ -ASSERT (block_len == len); -/* COW results a new extent matching our file extent size. */ ASSERT (disk_num_bytes == len);ASSERT (ram_bytes == len);
@@ -7344,7 +7332,6 @@ static struct extent_map *create_io_em(struct btrfs_inode *inode, u64 start, em->start = start; em->len = len; - em->block_len = block_len; em->block_start = block_start; em->disk_bytenr = file_extent->disk_bytenr; em->disk_num_bytes = disk_num_bytes;
@@ -7433,7 +7420,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map, em2 =btrfs_create_dio_extent (BTRFS_I (inode), dio_data, start, len, block_start, - len, orig_block_len, + orig_block_len, ram_bytes, type, &file_extent);btrfs_dec_nocow_writers (bg);
@@ -9587,7 +9574,6 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, em->block_start = ins.objectid; em->disk_bytenr = ins.objectid; em->offset =0 ; - em->block_len = ins.offset; em->disk_num_bytes = ins.offset; em->ram_bytes = ins.offset; em->flags |=EXTENT_FLAG_PREALLOC ;
@@ -10084,12 +10070,12 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,* Bail if the buffer isn't large enough to return the whole * compressed extent. */ -if (em->block_len > count) { +if (em->disk_num_bytes > count) { ret = -ENOBUFS ; goto out_em; } - disk_io_size = em->block_len; - count = em->block_len; + disk_io_size = em->disk_num_bytes; + count = em->disk_num_bytes; encoded->unencoded_len = em->ram_bytes; encoded->unencoded_offset = iocb->ki_pos - em->start + em->offset; ret = btrfs_encoded_io_compression_from_extent(fs_info,
@@ -10335,7 +10321,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from, file_extent.compression = compression; em =create_io_em (inode, start, num_bytes, ins.objectid, - ins.offset, ins.offset, ram_bytes, compression, + ins.offset, ram_bytes, compression, &file_extent,BTRFS_ORDERED_COMPRESSED );if (IS_ERR (em)) { ret =PTR_ERR (em);
fs/btrfs/relocation.c +0 -1
@@ -2912,7 +2912,6 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inod em->start = start; em->len = end +1 - start; - em->block_len = em->len; em->block_start = block_start; em->disk_bytenr = block_start; em->disk_num_bytes = em->len;
fs/btrfs/tests/extent-map-tests.c +13 -28
169 lines not on this page · raw message
fs/btrfs/tree-log.c +2 -2
@@ -4648,7 +4648,7 @@ static int log_extent_csums(struct btrfs_trans_handle *trans,/* If we're compressed we have to save the entire range of csums. */ if (extent_map_is_compressed (em)) { csum_offset =0 ; - csum_len =max (em->block_len, em->disk_num_bytes); + csum_len = em->disk_num_bytes; }else { csum_offset = mod_start - em->start; csum_len = mod_len;
@@ -4698,7 +4698,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,else btrfs_set_stack_file_extent_type (&fi,BTRFS_FILE_EXTENT_REG ); - block_len =max (em->block_len, em->disk_num_bytes); + block_len = em->disk_num_bytes; compress_type =extent_map_compression (em);if (compress_type !=BTRFS_COMPRESS_NONE ) {btrfs_set_stack_file_extent_disk_bytenr (&fi, em->block_start);
include/trace/events/btrfs.h +1 -4
@@ -292,7 +292,6 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __field( u64, start ) __field( u64, len ) __field( u64, block_start ) - __field( u64, block_len ) __field( u32, flags )__field ( int, refs ) ),
@@ -303,19 +302,17 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __entry->start = map->start; __entry->len = map->len; __entry->block_start = map->block_start; - __entry->block_len = map->block_len; __entry->flags = map->flags; __entry->refs =refcount_read (&map->refs); ),TP_printk_btrfs ("root=%llu(%s) ino=%llu start=%llu len=%llu " -"block_start=%llu(%s) block_len=%llu flags=%s refs=%u" , +"block_start=%llu(%s) flags=%s refs=%u" ,show_root_type (__entry->root_objectid), __entry->ino, __entry->start, __entry->len,show_map_type (__entry->block_start), - __entry->block_len,show_map_flags (__entry->flags), __entry->refs) );
Signature · 1 line
2.44.0
PATCH 8/9 btrfs: remove extent_map::block_start member
In reply to Qu WenruoThe member extent_map::block_start can be calculated from extent_map::disk_bytenr + extent_map::offset for regular extents. And otherwise just extent_map::disk_bytenr.
And this is already validated by the validate_extent_map(). Now we can remove the member.
However there is a special case in btrfs_alloc_ordered_extent(), where we intentionally pass a pseudo ordered extent, exploiting the fact that for NOCOW/PREALLOC writes we do not rely on ordered extent members to update the file extent items.
And that's the only way to pass btrfs_extract_ordered_extent(), as it doesn't accept any ordered extent with an offset.
For now we will keep the old pseudo ordered extent members, and leave the cleanup of it for the future.
--- fs/btrfs/compression.c | 3 +- fs/btrfs/defrag.c | 9 ++- fs/btrfs/extent_io.c | 10 ++-- fs/btrfs/extent_map.c | 56 +++++------------ fs/btrfs/extent_map.h | 22 ++++--- fs/btrfs/file-item.c | 4 -- fs/btrfs/file.c | 11 ++-- fs/btrfs/inode.c | 84 +++++++++++++++----------- fs/btrfs/relocation.c | 1 - fs/btrfs/tests/extent-map-tests.c | 48 ++++++--------- fs/btrfs/tests/inode-tests.c | 99 ++++++++++++++++--------------- fs/btrfs/tree-log.c | 17 +++--- fs/btrfs/zoned.c | 4 +- include/trace/events/btrfs.h | 11 +--- 14 files changed, 172 insertions(+), 207 deletions(-)
fs/btrfs/compression.c +2 -1
@@ -507,7 +507,8 @@ static noinline int add_ra_bio_pages(struct inode *inode,*/ if (!em || cur < em->start || (cur + fs_info->sectorsize >extent_map_end (em)) || - (em->block_start >>SECTOR_SHIFT ) != orig_bio->bi_iter.bi_sector) { + (extent_map_block_start (em) >>SECTOR_SHIFT ) != + orig_bio->bi_iter.bi_sector) {free_extent_map (em);unlock_extent (tree, cur, page_end,NULL );unlock_page (page);
fs/btrfs/defrag.c +4 -5
@@ -707,7 +707,6 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,*/ if (key.offset > start) { em->start = start; - em->block_start =EXTENT_MAP_HOLE ; em->disk_bytenr =EXTENT_MAP_HOLE ; em->disk_num_bytes =0 ; em->ram_bytes =0 ;
@@ -828,7 +827,7 @@ static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em,*/ next =defrag_lookup_extent (inode, em->start + em->len, newer_than, locked);/* No more em or hole */ -if (!next || next->block_start >=EXTENT_MAP_LAST_BYTE ) +if (!next || next->disk_bytenr >=EXTENT_MAP_LAST_BYTE ) goto out;if (next->flags &EXTENT_FLAG_PREALLOC ) goto out;
@@ -995,12 +994,12 @@ static int defrag_collect_targets(struct btrfs_inode *inode,* This is for users who want to convert inline extents to * regular ones through max_inline= mount option. */ -if (em->block_start ==EXTENT_MAP_INLINE && +if (em->disk_bytenr ==EXTENT_MAP_INLINE && em->len <= inode->root->fs_info->max_inline) goto next;/* Skip holes and preallocated extents. */ -if (em->block_start ==EXTENT_MAP_HOLE || +if (em->disk_bytenr ==EXTENT_MAP_HOLE || (em->flags &EXTENT_FLAG_PREALLOC )) goto next;
@@ -1065,7 +1064,7 @@ static int defrag_collect_targets(struct btrfs_inode *inode,* So if an inline extent passed all above checks, just add it * for defrag, and be converted to regular extents. */ -if (em->block_start ==EXTENT_MAP_INLINE ) +if (em->disk_bytenr ==EXTENT_MAP_INLINE ) goto add; next_mergeable = defrag_check_next_extent(&inode->vfs_inode, em,
fs/btrfs/extent_io.c +5 -5
@@ -1083,10 +1083,10 @@ static int btrfs_do_readpage(struct page *page, struct extent_map **em_cached, iosize =min (extent_map_end (em) - cur, end - cur +1 ); iosize =ALIGN (iosize, blocksize);if (compress_type !=BTRFS_COMPRESS_NONE ) - disk_bytenr = em->block_start; + disk_bytenr = em->disk_bytenr;else - disk_bytenr = em->block_start + extent_offset; - block_start = em->block_start; + disk_bytenr =extent_map_block_start (em) + extent_offset; + block_start =extent_map_block_start (em);if (em->flags &EXTENT_FLAG_PREALLOC ) block_start =EXTENT_MAP_HOLE ;
@@ -1405,8 +1405,8 @@ static noinline_for_stack int __extent_writepage_io(struct btrfs_inode *inode,ASSERT (IS_ALIGNED (em->start, fs_info->sectorsize));ASSERT (IS_ALIGNED (em->len, fs_info->sectorsize)); - block_start = em->block_start; - disk_bytenr = em->block_start + extent_offset; + block_start =extent_map_block_start (em); + disk_bytenr =extent_map_block_start (em) + extent_offset;ASSERT (!extent_map_is_compressed (em));ASSERT (block_start !=EXTENT_MAP_HOLE );
fs/btrfs/extent_map.c +15 -41
159 lines not on this page · raw message
fs/btrfs/extent_map.h +10 -12
@@ -91,18 +91,6 @@ struct extent_map {*/ u64 ram_bytes; -/* -* The on-disk logical bytenr for the file extent. -* -* For compressed extents it matches btrfs_file_extent_item::disk_bytenr. -* For uncompressed extents it matches -* btrfs_file_extent_item::disk_bytenr + btrfs_file_extent_item::offset -* -* For holes it is EXTENT_MAP_HOLE and for inline extents it is -* EXTENT_MAP_INLINE. -*/ -u64 block_start; -/* * Generation of the extent map, for merged em it's the highest * generation of all merged ems.
@@ -163,6 +151,16 @@ static inline int extent_map_in_tree(const struct extent_map *em)return !RB_EMPTY_NODE (&em->rb_node); } +static inline u64 extent_map_block_start (const struct extent_map *em) +{ +if (em->disk_bytenr <EXTENT_MAP_LAST_BYTE ) { +if (extent_map_is_compressed (em)) +return em->disk_bytenr; +return em->disk_bytenr + em->offset; + } +return em->disk_bytenr; +} +static inline u64 extent_map_end (const struct extent_map *em) {if (em->start + em->len < em->start)
fs/btrfs/file-item.c +0 -4
@@ -1294,7 +1294,6 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->len =btrfs_file_extent_end (path) - extent_start; bytenr =btrfs_file_extent_disk_bytenr (leaf, fi);if (bytenr ==0 ) { - em->block_start =EXTENT_MAP_HOLE ; em->disk_bytenr =EXTENT_MAP_HOLE ; em->disk_num_bytes =0 ; em->offset =0 ;
@@ -1305,10 +1304,8 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, em->offset =btrfs_file_extent_offset (leaf, fi);if (compress_type !=BTRFS_COMPRESS_NONE ) {extent_map_set_compression (em, compress_type); - em->block_start = bytenr; }else { bytenr +=btrfs_file_extent_offset (leaf, fi); - em->block_start = bytenr;if (type ==BTRFS_FILE_EXTENT_PREALLOC ) em->flags |=EXTENT_FLAG_PREALLOC ; }
@@ -1316,7 +1313,6 @@ void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,/* Tree-checker has ensured this. */ ASSERT (extent_start ==0 ); - em->block_start =EXTENT_MAP_INLINE ; em->disk_bytenr =EXTENT_MAP_INLINE ; em->start =0 ; em->len = fs_info->sectorsize;
fs/btrfs/file.c +5 -6
@@ -2335,7 +2335,6 @@ static int fill_holes(struct btrfs_trans_handle *trans, hole_em->len = end - offset; hole_em->ram_bytes = hole_em->len; - hole_em->block_start =EXTENT_MAP_HOLE ; hole_em->disk_bytenr =EXTENT_MAP_HOLE ; hole_em->disk_num_bytes =0 ; hole_em->generation = trans->transid;
@@ -2368,7 +2367,7 @@ static int find_first_non_hole(struct btrfs_inode *inode, u64 *start, u64 *len)return PTR_ERR (em);/* Hole or vacuum extent(only exists in no-hole mode) */ -if (em->block_start ==EXTENT_MAP_HOLE ) { +if (em->disk_bytenr ==EXTENT_MAP_HOLE ) { ret =1 ; *len = em->start + em->len > *start + *len ?0 : *start + *len - em->start - em->len;
@@ -3025,7 +3024,7 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,if (IS_ERR (em))return PTR_ERR (em); -if (em->block_start ==EXTENT_MAP_HOLE ) +if (em->disk_bytenr ==EXTENT_MAP_HOLE ) ret =RANGE_BOUNDARY_HOLE ;else if (em->flags &EXTENT_FLAG_PREALLOC ) ret =RANGE_BOUNDARY_PREALLOC_EXTENT ;
@@ -3089,7 +3088,7 @@ static int btrfs_zero_range(struct inode *inode,ASSERT (IS_ALIGNED (alloc_start, sectorsize)); len = offset + len - alloc_start; offset = alloc_start; - alloc_hint = em->block_start + em->len; + alloc_hint =extent_map_block_start (em) + em->len; }free_extent_map (em);
@@ -3107,7 +3106,7 @@ static int btrfs_zero_range(struct inode *inode, mode); goto out; } -if (len < sectorsize && em->block_start !=EXTENT_MAP_HOLE ) { +if (len < sectorsize && em->disk_bytenr !=EXTENT_MAP_HOLE ) {free_extent_map (em); ret =btrfs_truncate_block (BTRFS_I (inode), offset, len,0 );
@@ -3320,7 +3319,7 @@ static long btrfs_fallocate(struct file *file, int mode, last_byte =min (extent_map_end (em), alloc_end); actual_end =min_t (u64,extent_map_end (em), offset + len); last_byte =ALIGN (last_byte, blocksize); -if (em->block_start ==EXTENT_MAP_HOLE || +if (em->disk_bytenr ==EXTENT_MAP_HOLE || (cur_offset >= inode->i_size && !(em->flags &EXTENT_FLAG_PREALLOC ))) {const u64 range_len = last_byte - cur_offset;
fs/btrfs/inode.c +49 -35
277 lines not on this page · raw message
fs/btrfs/relocation.c +0 -1
@@ -2912,7 +2912,6 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct inode *inod em->start = start; em->len = end +1 - start; - em->block_start = block_start; em->disk_bytenr = block_start; em->disk_num_bytes = em->len; em->ram_bytes = em->len;
fs/btrfs/tests/extent-map-tests.c +17 -31
179 lines not on this page · raw message
fs/btrfs/tests/inode-tests.c +50 -49
259 lines not on this page · raw message
fs/btrfs/tree-log.c +10 -7
@@ -4575,6 +4575,7 @@ static int log_extent_csums(struct btrfs_trans_handle *trans, {struct btrfs_ordered_extent *ordered;struct btrfs_root *csum_root; +u64 block_start;u64 csum_offset;u64 csum_len;u64 mod_start = em->start;
@@ -4584,7 +4585,7 @@ static int log_extent_csums(struct btrfs_trans_handle *trans,if (inode->flags &BTRFS_INODE_NODATASUM || (em->flags &EXTENT_FLAG_PREALLOC ) || - em->block_start ==EXTENT_MAP_HOLE ) + em->disk_bytenr ==EXTENT_MAP_HOLE )return 0 ;list_for_each_entry (ordered, &ctx->ordered_extents, log_list) {
@@ -4655,9 +4656,10 @@ static int log_extent_csums(struct btrfs_trans_handle *trans, }/* block start is already adjusted for the file extent offset. */ - csum_root =btrfs_csum_root (trans->fs_info, em->block_start); - ret =btrfs_lookup_csums_list (csum_root, em->block_start + csum_offset, - em->block_start + csum_offset + + block_start =extent_map_block_start (em); + csum_root =btrfs_csum_root (trans->fs_info, block_start); + ret =btrfs_lookup_csums_list (csum_root, block_start + csum_offset, + block_start + csum_offset + csum_len -1 , &ordered_sums, false);if (ret <0 )return ret;
@@ -4689,6 +4691,7 @@ static int log_one_extent(struct btrfs_trans_handle *trans,struct btrfs_key key;enum btrfs_compression_type compress_type;u64 extent_offset = em->offset; +u64 block_start =extent_map_block_start (em);u64 block_len;int ret;
@@ -4701,10 +4704,10 @@ static int log_one_extent(struct btrfs_trans_handle *trans, block_len = em->disk_num_bytes; compress_type =extent_map_compression (em);if (compress_type !=BTRFS_COMPRESS_NONE ) { -btrfs_set_stack_file_extent_disk_bytenr (&fi, em->block_start); +btrfs_set_stack_file_extent_disk_bytenr (&fi, block_start);btrfs_set_stack_file_extent_disk_num_bytes (&fi, block_len); - }else if (em->block_start <EXTENT_MAP_LAST_BYTE ) { -btrfs_set_stack_file_extent_disk_bytenr (&fi, em->block_start - + }else if (em->disk_bytenr <EXTENT_MAP_LAST_BYTE ) { +btrfs_set_stack_file_extent_disk_bytenr (&fi, block_start - extent_offset);btrfs_set_stack_file_extent_disk_num_bytes (&fi, block_len); }
fs/btrfs/zoned.c +3 -1
@@ -1769,7 +1769,9 @@ static void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered,write_lock (&em_tree->lock); em =search_extent_mapping (em_tree, ordered->file_offset, ordered->num_bytes); - em->block_start = logical; +/* The em should be a new COW extent, thus it should not has offset. */ +ASSERT (em->offset ==0 ); + em->disk_bytenr = logical;free_extent_map (em);write_unlock (&em_tree->lock); }
include/trace/events/btrfs.h +2 -9
@@ -291,7 +291,6 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __field( u64, ino ) __field( u64, start ) __field( u64, len ) - __field( u64, block_start ) __field( u32, flags )__field ( int, refs ) ),
@@ -301,18 +300,16 @@ TRACE_EVENT_CONDITION(btrfs_get_extent, __entry->ino =btrfs_ino (inode); __entry->start = map->start; __entry->len = map->len; - __entry->block_start = map->block_start; __entry->flags = map->flags; __entry->refs =refcount_read (&map->refs); ),TP_printk_btrfs ("root=%llu(%s) ino=%llu start=%llu len=%llu " -"block_start=%llu(%s) flags=%s refs=%u" , +"flags=%s refs=%u" ,show_root_type (__entry->root_objectid), __entry->ino, __entry->start, __entry->len, -show_map_type (__entry->block_start),show_map_flags (__entry->flags), __entry->refs) );
@@ -2608,7 +2605,6 @@ TRACE_EVENT(btrfs_extent_map_shrinker_remove_em, __field( u64, root_id ) __field( u64, start ) __field( u64, len ) - __field( u64, block_start )__field ( u32, flags ) ),
@@ -2617,15 +2613,12 @@ TRACE_EVENT(btrfs_extent_map_shrinker_remove_em, __entry->root_id = inode->root->root_key.objectid; __entry->start = em->start; __entry->len = em->len; - __entry->block_start = em->block_start; __entry->flags = em->flags; ), -TP_printk_btrfs ( -"ino=%llu root=%llu(%s) start=%llu len=%llu block_start=%llu(%s) flags=%s" , +TP_printk_btrfs ("ino=%llu root=%llu(%s) start=%llu len=%llu flags=%s" , __entry->ino,show_root_type (__entry->root_id), __entry->start, __entry->len, -show_map_type (__entry->block_start),show_map_flags (__entry->flags)) );
Signature · 1 line
2.44.0
PATCH 9/9 btrfs: remove parameters duplicated from btrfs_file_extent
In reply to Qu WenruoThe following functions are using parameters which can fetch from structure btrfs_file_extent:
- create_io_em()
- btrfs_create_dio_extent()
- can_nocow_extent()
- btrfs_alloc_ordered_extent()
- struct can_nocow_file_extent_args
Also to do the cleanup, the function btrfs_alloc_ordered_extent() from ordered-data.[ch] needs to have the btrfs_file_extent declaration.
Thankfully btrfs_inode.h would include ordered-data.h, so move the declaration of btrfs_file_extent to ordered-data.h.
--- fs/btrfs/btrfs_inode.h | 19 +---- fs/btrfs/file.c | 2 +- fs/btrfs/inode.c | 174 ++++++++++++++-------------------------- fs/btrfs/ordered-data.c | 20 +++-- fs/btrfs/ordered-data.h | 22 ++++- 5 files changed, 95 insertions(+), 142 deletions(-)
fs/btrfs/btrfs_inode.h +1 -18
@@ -444,25 +444,8 @@ int btrfs_check_sector_csum(struct btrfs_fs_info *fs_info, struct page *page,bool btrfs_data_csum_ok (struct btrfs_bio *bbio,struct btrfs_device *dev,u32 bio_offset,struct bio_vec *bv); -/* -* A more access-friendly representation of btrfs_file_extent_item. -* -* Unused members are excluded. -*/ -struct btrfs_file_extent { -u64 disk_bytenr; -u64 disk_num_bytes; - -u64 num_bytes; -u64 ram_bytes; -u64 offset; - -u8 compression; -}; - noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len, -u64 *orig_block_len, -u64 *ram_bytes,struct btrfs_file_extent *file_extent, +struct btrfs_file_extent *file_extent,bool nowait,bool strict);void btrfs_del_delalloc_inode (struct btrfs_inode *inode);
fs/btrfs/file.c +1 -1
@@ -1104,7 +1104,7 @@ int btrfs_check_nocow_lock(struct btrfs_inode *inode, loff_t pos, &cached_state); } ret =can_nocow_extent (&inode->vfs_inode, lockstart, &num_bytes, -NULL ,NULL ,NULL , nowait, false); +NULL , nowait, false);if (ret <=0 )btrfs_drew_write_unlock (&root->snapshot_lock);else
fs/btrfs/inode.c +61 -113
415 lines not on this page · raw message
fs/btrfs/ordered-data.c +13 -7
@@ -247,12 +247,15 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)* * @inode: Inode that this extent is for. * @file_offset: Logical offset in file where the extent starts. +* @flags: Flags specifying type of extent (1 << BTRFS_ORDERED_*). +* +* The following members are from @file_extent: +* * @num_bytes: Logical length of extent in file. * @ram_bytes: Full length of unencoded data. * @disk_bytenr: Offset of extent on disk. * @disk_num_bytes: Size of extent on disk. * @offset: Offset into unencoded data where file data starts. -* @flags: Flags specifying type of extent (1 << BTRFS_ORDERED_*). * @compress_type: Compression algorithm used for data. * * Most of these parameters correspond to &struct btrfs_file_extent_item. The
@@ -263,17 +266,20 @@ static void insert_ordered_extent(struct btrfs_ordered_extent *entry)*/ struct btrfs_ordered_extent *btrfs_alloc_ordered_extent (struct btrfs_inode *inode,u64 file_offset, -u64 num_bytes,u64 ram_bytes,u64 disk_bytenr, -u64 disk_num_bytes,u64 offset,unsigned long flags, -int compress_type) +struct btrfs_file_extent *file_extent, +unsigned long flags) {struct btrfs_ordered_extent *entry;ASSERT ((flags & ~BTRFS_ORDERED_TYPE_FLAGS ) ==0 ); - entry =alloc_ordered_extent (inode, file_offset, num_bytes, ram_bytes, - disk_bytenr, disk_num_bytes, offset, flags, - compress_type); + entry =alloc_ordered_extent (inode, file_offset, + file_extent->num_bytes, + file_extent->ram_bytes, + file_extent->disk_bytenr, + file_extent->disk_num_bytes, + file_extent->offset, flags, + file_extent->compression);if (!IS_ERR (entry))insert_ordered_extent (entry);return entry;
fs/btrfs/ordered-data.h +19 -3
@@ -171,11 +171,27 @@ void btrfs_mark_ordered_io_finished(struct btrfs_inode *inode,bool btrfs_dec_test_ordered_pending (struct btrfs_inode *inode,struct btrfs_ordered_extent **cached,u64 file_offset,u64 io_size); + +/* +* A more access-friendly representation of btrfs_file_extent_item. +* +* Unused members are excluded. +*/ +struct btrfs_file_extent { +u64 disk_bytenr; +u64 disk_num_bytes; + +u64 num_bytes; +u64 ram_bytes; +u64 offset; + +u8 compression; +}; +struct btrfs_ordered_extent *btrfs_alloc_ordered_extent (struct btrfs_inode *inode,u64 file_offset, -u64 num_bytes,u64 ram_bytes,u64 disk_bytenr, -u64 disk_num_bytes,u64 offset,unsigned long flags, -int compress_type); +struct btrfs_file_extent *file_extent, +unsigned long flags);void btrfs_add_ordered_sum (struct btrfs_ordered_extent *entry,struct btrfs_ordered_sum *sum); struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct btrfs_inode *inode,
Signature · 1 line
2.44.0