btrfs: some cleanups for extent-io-tree (mostly renames)
Subsystems (2)
cover btrfs: some cleanups for extent-io-tree (mostly renames)
From: Filipe Manana <[email protected]>
These are mostly to rename exported functions so that they have a 'btrfs_' prefix and follow coding style, to avoid potential clashes in the future with other kernel functions defined elsewhere outside btrfs. As more functions are added to extent-io-tree.h, there's a tendency to follow the existing style and not add a 'btrfs_' prefix for consistency with the other function names, so as time passes we get more exported functions that don't follow the coding style by missing a 'btrfs_' prefix. I'm in the process of adding another new exported function to extent-io-tree.h and found my self unconfortable adding a 'btrfs_' prefix to it while the other exported functions don't have one.
I tried to split the rename into several and more reasonably sized patches to make it easier to review and also because a few do a bit more than simply renaming, but with notes in the change logs.
Filipe Manana (16):
btrfs: remove extent_io_tree_to_inode() and is_inode_io_tree()
btrfs: add btrfs prefix to trace events for extent state alloc and free
btrfs: add btrfs prefix to main lock, try lock and unlock extent functions
btrfs: add btrfs prefix to dio lock and unlock extent functions
btrfs: rename __lock_extent() and __try_lock_extent()
btrfs: rename the functions to clear bits for an extent range
btrfs: rename set_extent_bit() to include a btrfs prefix
btrfs: rename the functions to search for bits in extent ranges
btrfs: rename the functions to get inode and fs_info from an extent io tree
btrfs: directly grab inode at __btrfs_debug_check_extent_io_range()
btrfs: rename the functions to init and release an extent io tree
btrfs: rename the functions to count, test and get bit ranges in io trees
btrfs: rename free_extent_state() to include a btrfs prefix
btrfs: rename remaining exported functions from extent-io-tree.h
btrfs: remove double underscore prefix from __set_extent_bit()
btrfs: make btrfs_find_contiguous_extent_bit() return bool instead of int
fs/btrfs/block-group.c | 34 ++--- fs/btrfs/compression.c | 6 +- fs/btrfs/defrag.c | 36 ++--- fs/btrfs/dev-replace.c | 12 +- fs/btrfs/direct-io.c | 38 +++--- fs/btrfs/disk-io.c | 35 ++--- fs/btrfs/extent-io-tree.c | 218 ++++++++++++++----------------- fs/btrfs/extent-io-tree.h | 155 +++++++++++----------- fs/btrfs/extent-tree.c | 38 +++--- fs/btrfs/extent_io.c | 40 +++--- fs/btrfs/extent_map.c | 4 +- fs/btrfs/fiemap.c | 6 +- fs/btrfs/file-item.c | 22 ++-- fs/btrfs/file.c | 87 ++++++------ fs/btrfs/free-space-cache.c | 36 ++--- fs/btrfs/inode.c | 167 +++++++++++------------ fs/btrfs/ioctl.c | 8 +- fs/btrfs/ordered-data.c | 8 +- fs/btrfs/qgroup.c | 30 +++-- fs/btrfs/reflink.c | 12 +- fs/btrfs/relocation.c | 61 ++++----- fs/btrfs/super.c | 4 +- fs/btrfs/tests/btrfs-tests.c | 4 +- fs/btrfs/tests/extent-io-tests.c | 54 ++++---- fs/btrfs/tests/inode-tests.c | 24 ++-- fs/btrfs/transaction.c | 34 ++--- fs/btrfs/tree-log.c | 12 +- fs/btrfs/volumes.c | 28 ++-- include/trace/events/btrfs.h | 16 +-- 29 files changed, 607 insertions(+), 622 deletions(-)
Signature · 1 line
2.45.2
PATCH 1/16 btrfs: remove extent_io_tree_to_inode() and is_inode_io_tree()
From: Filipe Manana <[email protected]>
These functions aren't used outside extent-io-tree.c, but yet one of them (extent_io_tree_to_inode()) is unnecessarily exported in the header.
Furthermore their single use is in a pattern like this:
if (is_inode_io_tree(tree))
foo(extent_io_tree_to_inode(tree), ...);So we're effectively unnecessarily adding more indirection, checking twice if tree->owner == IO_TREE_INODE_IO before getting the inode and doing a non-inline function call to get tree->inode.
Simplify this by removing these helper functions and instead doing thing like this:
if (tree->owner == IO_TREE_INODE_IO)
foo(tree->inode, ...);--- fs/btrfs/extent-io-tree.c | 55 ++++++++++++--------------------------- fs/btrfs/extent-io-tree.h | 1 - 2 files changed, 16 insertions(+), 40 deletions(-)
fs/btrfs/extent-io-tree.c +16 -39
@@ -80,23 +80,6 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,#define btrfs_debug_check_extent_io_range (c, s, e) do {} while (0)#endif - -/* -* The only tree allowed to set the inode is IO_TREE_INODE_IO. -*/ -static bool is_inode_io_tree (const struct extent_io_tree *tree) -{ -return tree->owner ==IO_TREE_INODE_IO ; -} - -/* Return the inode if it's valid for the given tree, otherwise NULL. */ -struct btrfs_inode *extent_io_tree_to_inode (struct extent_io_tree *tree) -{ -if (tree->owner ==IO_TREE_INODE_IO ) -return tree->inode; -return NULL ; -} -/* Read-only access to the inode. */ const struct btrfs_inode *extent_io_tree_to_inode_const (const struct extent_io_tree *tree) {
@@ -362,9 +345,8 @@ static void merge_prev_state(struct extent_io_tree *tree, struct extent_state *s prev =prev_state (state);if (prev && prev->end == state->start -1 && prev->state == state->state) { -if (is_inode_io_tree (tree)) -btrfs_merge_delalloc_extent (extent_io_tree_to_inode (tree), - state, prev); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_merge_delalloc_extent (tree->inode, state, prev); state->start = prev->start;rb_erase (&prev->rb_node, &tree->state);RB_CLEAR_NODE (&prev->rb_node);
@@ -378,9 +360,8 @@ static void merge_next_state(struct extent_io_tree *tree, struct extent_state *s next =next_state (state);if (next && next->start == state->end +1 && next->state == state->state) { -if (is_inode_io_tree (tree)) -btrfs_merge_delalloc_extent (extent_io_tree_to_inode (tree), - state, next); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_merge_delalloc_extent (tree->inode, state, next); state->end = next->end;rb_erase (&next->rb_node, &tree->state);RB_CLEAR_NODE (&next->rb_node);
@@ -413,8 +394,8 @@ static void set_state_bits(struct extent_io_tree *tree,u32 bits_to_set = bits & ~EXTENT_CTLBITS ;int ret; -if (is_inode_io_tree (tree)) -btrfs_set_delalloc_extent (extent_io_tree_to_inode (tree), state, bits); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_set_delalloc_extent (tree->inode, state, bits); ret =add_extent_changeset (state, bits_to_set, changeset,1 );BUG_ON (ret <0 );
@@ -459,10 +440,9 @@ static struct extent_state *insert_state(struct extent_io_tree *tree,if (state->end < entry->start) {if (try_merge && end == entry->start && state->state == entry->state) { -if (is_inode_io_tree (tree)) -btrfs_merge_delalloc_extent ( -extent_io_tree_to_inode (tree), - state, entry); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_merge_delalloc_extent (tree->inode, + state, entry); entry->start = state->start;merge_prev_state (tree, entry); state->state =0 ;
@@ -472,10 +452,9 @@ static struct extent_state *insert_state(struct extent_io_tree *tree, }else if (state->end > entry->end) {if (try_merge && entry->end == start && state->state == entry->state) { -if (is_inode_io_tree (tree)) -btrfs_merge_delalloc_extent ( -extent_io_tree_to_inode (tree), - state, entry); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_merge_delalloc_extent (tree->inode, + state, entry); entry->end = state->end;merge_next_state (tree, entry); state->state =0 ;
@@ -527,9 +506,8 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig,struct rb_node *parent =NULL ;struct rb_node **node; -if (is_inode_io_tree (tree)) -btrfs_split_delalloc_extent (extent_io_tree_to_inode (tree), orig, - split); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_split_delalloc_extent (tree->inode, orig, split); prealloc->start = orig->start; prealloc->end = split -1 ;
@@ -576,9 +554,8 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree,u32 bits_to_clear = bits & ~EXTENT_CTLBITS ;int ret; -if (is_inode_io_tree (tree)) -btrfs_clear_delalloc_extent (extent_io_tree_to_inode (tree), state, - bits); +if (tree->owner ==IO_TREE_INODE_IO ) +btrfs_clear_delalloc_extent (tree->inode, state, bits); ret =add_extent_changeset (state, bits_to_clear, changeset,0 );BUG_ON (ret <0 );
fs/btrfs/extent-io-tree.h +0 -1
@@ -134,7 +134,6 @@ struct extent_state {#endif }; -struct btrfs_inode *extent_io_tree_to_inode (struct extent_io_tree *tree);const struct btrfs_inode *extent_io_tree_to_inode_const (const struct extent_io_tree *tree);const struct btrfs_fs_info *extent_io_tree_to_fs_info (const struct extent_io_tree *tree);
Signature · 1 line
2.45.2
Re: [PATCH 01/16] btrfs: remove extent_io_tree_to_inode() and is_inode_io_tree()
Quoted 5 lines · On Mon, Apr 07, 2025 at 06:36:08PM +0100, [email protected] wrote:
From: Filipe Manana <[email protected]>
These functions aren't used outside
extent-io-tree.c, but yet one of them (extent_io_tree_to_inode()) is unnecessarily exported in the header.
Quoted 8 lines
Furthermore their single use is in a pattern like this:
if (is_inode_io_tree(tree)) foo(extent_io_tree_to_inode(tree), ...);So we're effectively unnecessarily adding more indirection, checking twice if
tree->owner==IO_TREE_INODE_IObefore getting the inode and doing a non-inline function call to gettree->inode.
I did like that to document the special case and the conditional values of inode depending on the tree owner. The duplicated check of tree owner will be unduplicated by compiler as it sees both functions.
Quoted 18 lines
Simplify this by removing these helper functions and instead doing thing like this:
if (tree->owner == IO_TREE_INODE_IO) foo(tree->inode, ...);Signed-off-by Filipe Manana <[email protected]>--- fs/btrfs/extent-io-tree.c | 55 ++++++++++++--------------------------- fs/btrfs/extent-io-tree.h | 1 - 2 files changed, 16 insertions(+), 40 deletions(-)fs/btrfs/extent-io-tree.c +0
-0@@ -80,23 +80,6 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,#define btrfs_debug_check_extent_io_range (c, s, e) do {} while (0)
fs/btrfs/extent-io-tree.c static inline void __btrfs_debug_check_extent_io_range(const char *caller, · line 90
Quoted 10 lines
fs/btrfs/extent-io-tree.c +0
-8#endif - -/* -* The only tree allowed to set the inode is IO_TREE_INODE_IO. -*/ -static bool is_inode_io_tree (const struct extent_io_tree *tree) -{ -return tree->owner ==IO_TREE_INODE_IO ; -}
This was added to be clear about the semantics, which somehow still is from the test condition itself though.
fs/btrfs/extent-io-tree.c static inline void __btrfs_debug_check_extent_io_range(const char *caller, · line 97
Quoted 7 lines
fs/btrfs/extent-io-tree.c +0
-7- -/* Return the inode if it's valid for the given tree, otherwise NULL. */ -struct btrfs_inode *extent_io_tree_to_inode (struct extent_io_tree *tree) -{ -if (tree->owner ==IO_TREE_INODE_IO ) -return tree->inode; -return NULL ;
The two helpers can be used independently, this was meant to prevent accidental use of fs_info in place of inode.
It's perhaps personal preference of code readability to use or not use the trivial helpers, as this is fairly static code I don't care if it gets simplified like that.
PATCH 2/16 btrfs: add btrfs prefix to trace events for extent state alloc and free
In reply to [email protected]From: Filipe Manana <[email protected]>
These trace events don't have the 'btrfs_' prefix in their name, unlike the other trace events from extent-io-tree.c. So add the prefix to make them consistent and follow coding style conventions too.
--- fs/btrfs/extent-io-tree.c | 4 ++-- include/trace/events/btrfs.h | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-)
fs/btrfs/extent-io-tree.c +2 -2
@@ -159,7 +159,7 @@ static struct extent_state *alloc_extent_state(gfp_t mask)btrfs_leak_debug_add_state (state);refcount_set (&state->refs,1 );init_waitqueue_head (&state->wq); -trace_alloc_extent_state (state, mask, _RET_IP_); +trace_btrfs_alloc_extent_state (state, mask, _RET_IP_);return state; }
@@ -178,7 +178,7 @@ void free_extent_state(struct extent_state *state)if (refcount_dec_and_test (&state->refs)) {WARN_ON (extent_state_in_tree (state));btrfs_leak_debug_del_state (state); -trace_free_extent_state (state, _RET_IP_); +trace_btrfs_free_extent_state (state, _RET_IP_);kmem_cache_free (extent_state_cache, state); } }
include/trace/events/btrfs.h +2 -2
@@ -1476,7 +1476,7 @@ TRACE_EVENT(btrfs_setup_cluster, );struct extent_state ; -TRACE_EVENT(alloc_extent_state, +TRACE_EVENT(btrfs_alloc_extent_state, TP_PROTO(const struct extent_state *state, gfp_t mask, unsigned long IP),
@@ -1499,7 +1499,7 @@ TRACE_EVENT(alloc_extent_state, show_gfp_flags(__entry->mask), __entry->ip) ); -TRACE_EVENT(free_extent_state, +TRACE_EVENT(btrfs_free_extent_state, TP_PROTO(const struct extent_state *state, unsigned long IP),
Signature · 1 line
2.45.2
PATCH 3/16 btrfs: add btrfs prefix to main lock, try lock and unlock extent functions
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel. So add a prefix to their name.
--- fs/btrfs/compression.c | 6 +-- fs/btrfs/defrag.c | 22 ++++---- fs/btrfs/direct-io.c | 8 +-- fs/btrfs/extent-io-tree.h | 12 ++--- fs/btrfs/extent_io.c | 20 ++++---- fs/btrfs/extent_map.c | 4 +- fs/btrfs/fiemap.c | 4 +- fs/btrfs/file.c | 61 +++++++++++----------- fs/btrfs/free-space-cache.c | 16 +++--- fs/btrfs/inode.c | 86 ++++++++++++++++---------------- fs/btrfs/ioctl.c | 8 +-- fs/btrfs/ordered-data.c | 8 +-- fs/btrfs/reflink.c | 8 +-- fs/btrfs/relocation.c | 28 +++++------ fs/btrfs/tests/extent-io-tests.c | 6 +-- fs/btrfs/tree-log.c | 8 +-- 16 files changed, 152 insertions(+), 153 deletions(-)
fs/btrfs/compression.c +3 -3
@@ -499,7 +499,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, } page_end = (pg_index <<PAGE_SHIFT ) +folio_size (folio) -1 ; -lock_extent (tree, cur, page_end,NULL ); +btrfs_lock_extent (tree, cur, page_end,NULL );read_lock (&em_tree->lock); em =lookup_extent_mapping (em_tree, cur, page_end +1 - cur);read_unlock (&em_tree->lock);
@@ -514,14 +514,14 @@ static noinline int add_ra_bio_pages(struct inode *inode, (extent_map_block_start(em) >> SECTOR_SHIFT) != orig_bio->bi_iter.bi_sector) {free_extent_map (em); -unlock_extent (tree, cur, page_end,NULL ); +btrfs_unlock_extent (tree, cur, page_end,NULL );folio_unlock (folio);folio_put (folio);break ; } add_size =min (em->start + em->len, page_end +1 ) - cur;free_extent_map (em); -unlock_extent (tree, cur, page_end,NULL ); +btrfs_unlock_extent (tree, cur, page_end,NULL );if (folio_contains (folio, end_index)) {size_t zero_offset =offset_in_folio (folio, isize);
fs/btrfs/defrag.c +11 -11
@@ -776,10 +776,10 @@ static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start,/* Get the big lock and read metadata off disk. */ if (!locked) -lock_extent (io_tree, start, end, &cached); +btrfs_lock_extent (io_tree, start, end, &cached); em =defrag_get_extent (BTRFS_I (inode), start, newer_than);if (!locked) -unlock_extent (io_tree, start, end, &cached); +btrfs_unlock_extent (io_tree, start, end, &cached);if (IS_ERR (em))return NULL ;
@@ -891,10 +891,10 @@ static struct folio *defrag_prepare_one_folio(struct btrfs_inode *inode, pgoff_twhile (1 ) {struct btrfs_ordered_extent *ordered; -lock_extent (&inode->io_tree, page_start, page_end, &cached_state); +btrfs_lock_extent (&inode->io_tree, page_start, page_end, &cached_state); ordered =btrfs_lookup_ordered_range (inode, page_start,PAGE_SIZE ); -unlock_extent (&inode->io_tree, page_start, page_end, - &cached_state); +btrfs_unlock_extent (&inode->io_tree, page_start, page_end, + &cached_state);if (!ordered)break ;
@@ -1223,9 +1223,9 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,folio_wait_writeback (folios[i]);/* Lock the pages range */ -lock_extent (&inode->io_tree, start_index <<PAGE_SHIFT , - (last_index <<PAGE_SHIFT ) +PAGE_SIZE -1 , - &cached_state); +btrfs_lock_extent (&inode->io_tree, start_index <<PAGE_SHIFT , + (last_index <<PAGE_SHIFT ) +PAGE_SIZE -1 , + &cached_state);/* * Now we have a consistent view about the extent map, re-check * which range really needs to be defragged.
@@ -1251,9 +1251,9 @@ static int defrag_one_range(struct btrfs_inode *inode, u64 start, u32 len,kfree (entry); } unlock_extent: -unlock_extent (&inode->io_tree, start_index <<PAGE_SHIFT , - (last_index <<PAGE_SHIFT ) +PAGE_SIZE -1 , - &cached_state); +btrfs_unlock_extent (&inode->io_tree, start_index <<PAGE_SHIFT , + (last_index <<PAGE_SHIFT ) +PAGE_SIZE -1 , + &cached_state); free_folios:for (i =0 ; i < nr_pages; i++) {folio_unlock (folios[i]);
fs/btrfs/direct-io.c +4 -4
@@ -50,13 +50,13 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,while (1 ) {if (nowait) { -if (!try_lock_extent (io_tree, lockstart, lockend, - cached_state)) { +if (!btrfs_try_lock_extent (io_tree, lockstart, lockend, + cached_state)) { ret = -EAGAIN ;break ; } }else { -lock_extent (io_tree, lockstart, lockend, cached_state); +btrfs_lock_extent (io_tree, lockstart, lockend, cached_state); }/* * We're concerned with the entire range that we're going to be
@@ -78,7 +78,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend, lockstart, lockend)))break ; -unlock_extent (io_tree, lockstart, lockend, cached_state); +btrfs_unlock_extent (io_tree, lockstart, lockend, cached_state);if (ordered) {if (nowait) {
fs/btrfs/extent-io-tree.h +6 -6
@@ -145,14 +145,14 @@ int __lock_extent(struct extent_io_tree *tree, u64 start, u64 end, u32 bits,bool __try_lock_extent (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached); -static inline int lock_extent (struct extent_io_tree *tree,u64 start,u64 end, -struct extent_state **cached) +static inline int btrfs_lock_extent (struct extent_io_tree *tree,u64 start,u64 end, +struct extent_state **cached) {return __lock_extent (tree, start, end,EXTENT_LOCKED , cached); } -static inline bool try_lock_extent (struct extent_io_tree *tree,u64 start, -u64 end,struct extent_state **cached) +static inline bool btrfs_try_lock_extent (struct extent_io_tree *tree,u64 start, +u64 end,struct extent_state **cached) {return __try_lock_extent (tree, start, end,EXTENT_LOCKED , cached); }
@@ -184,8 +184,8 @@ static inline int clear_extent_bit(struct extent_io_tree *tree, u64 start,return __clear_extent_bit (tree, start, end, bits, cached,NULL ); } -static inline int unlock_extent (struct extent_io_tree *tree,u64 start,u64 end, -struct extent_state **cached) +static inline int btrfs_unlock_extent (struct extent_io_tree *tree,u64 start,u64 end, +struct extent_state **cached) {return __clear_extent_bit (tree, start, end,EXTENT_LOCKED , cached,NULL ); }
fs/btrfs/extent_io.c +10 -10
@@ -369,13 +369,13 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode, }/* step three, lock the state bits for the whole range */ -lock_extent (tree, delalloc_start, delalloc_end, &cached_state); +btrfs_lock_extent (tree, delalloc_start, delalloc_end, &cached_state);/* then test to make sure it is all still delalloc */ ret =test_range_bit (tree, delalloc_start, delalloc_end,EXTENT_DELALLOC , cached_state); -unlock_extent (tree, delalloc_start, delalloc_end, &cached_state); +btrfs_unlock_extent (tree, delalloc_start, delalloc_end, &cached_state);if (!ret) {unlock_delalloc_folio (inode, locked_folio, delalloc_start, delalloc_end);
@@ -1202,7 +1202,7 @@ static void lock_extents_for_read(struct btrfs_inode *inode, u64 start, u64 end,ASSERT (IS_ALIGNED (end +1 ,PAGE_SIZE )); again: -lock_extent (&inode->io_tree, start, end, cached_state); +btrfs_lock_extent (&inode->io_tree, start, end, cached_state); cur_pos = start;while (cur_pos < end) {struct btrfs_ordered_extent *ordered;
@@ -1226,7 +1226,7 @@ static void lock_extents_for_read(struct btrfs_inode *inode, u64 start, u64 end, }/* Now wait for the OE to finish. */ -unlock_extent (&inode->io_tree, start, end, cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, cached_state);btrfs_start_ordered_extent_nowriteback (ordered, start, end +1 - start);btrfs_put_ordered_extent (ordered);/* We have unlocked the whole range, restart from the beginning. */
@@ -1246,7 +1246,7 @@ int btrfs_read_folio(struct file *file, struct folio *folio)lock_extents_for_read (inode, start, end, &cached_state); ret =btrfs_do_readpage (folio, &em_cached, &bio_ctrl,NULL ); -unlock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, &cached_state);free_extent_map (em_cached);
@@ -1434,8 +1434,8 @@ static noinline_for_stack int writepage_delalloc(struct btrfs_inode *inode,* We've hit an error during previous delalloc range, * have to cleanup the remaining locked ranges. */ -unlock_extent (&inode->io_tree, found_start, - found_start + found_len -1 ,NULL ); +btrfs_unlock_extent (&inode->io_tree, found_start, + found_start + found_len -1 ,NULL );unlock_delalloc_folio (&inode->vfs_inode, folio, found_start, found_start + found_len -1 );
@@ -2565,7 +2565,7 @@ void btrfs_readahead(struct readahead_control *rac)while ((folio =readahead_folio (rac)) !=NULL )btrfs_do_readpage (folio, &em_cached, &bio_ctrl, &prev_em_start); -unlock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, &cached_state);if (em_cached)free_extent_map (em_cached);
@@ -2592,7 +2592,7 @@ int extent_invalidate_folio(struct extent_io_tree *tree,if (start > end)return 0 ; -lock_extent (tree, start, end, &cached_state); +btrfs_lock_extent (tree, start, end, &cached_state);folio_wait_writeback (folio);/*
@@ -2600,7 +2600,7 @@ int extent_invalidate_folio(struct extent_io_tree *tree,* so here we only need to unlock the extent range to free any * existing extent state. */ -unlock_extent (tree, start, end, &cached_state); +btrfs_unlock_extent (tree, start, end, &cached_state);return 0 ; }
fs/btrfs/extent_map.c +2 -2
@@ -1055,7 +1055,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, goto out_free_pre; } -lock_extent (&inode->io_tree, start, start + len -1 ,NULL ); +btrfs_lock_extent (&inode->io_tree, start, start + len -1 ,NULL );write_lock (&em_tree->lock); em =lookup_extent_mapping (em_tree, start, len);if (!em) {
@@ -1108,7 +1108,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre, out_unlock:write_unlock (&em_tree->lock); -unlock_extent (&inode->io_tree, start, start + len -1 ,NULL ); +btrfs_unlock_extent (&inode->io_tree, start, start + len -1 ,NULL );free_extent_map (split_mid); out_free_pre:free_extent_map (split_pre);
fs/btrfs/fiemap.c +2 -2
@@ -661,7 +661,7 @@ static int extent_fiemap(struct btrfs_inode *inode, range_end =round_up (start + len, sectorsize); prev_extent_end = range_start; -lock_extent (&inode->io_tree, range_start, range_end, &cached_state); +btrfs_lock_extent (&inode->io_tree, range_start, range_end, &cached_state); ret =fiemap_find_last_extent_offset (inode, path, &last_extent_end);if (ret <0 )
@@ -841,7 +841,7 @@ static int extent_fiemap(struct btrfs_inode *inode, } out_unlock: -unlock_extent (&inode->io_tree, range_start, range_end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, range_start, range_end, &cached_state);if (ret ==BTRFS_FIEMAP_FLUSH_CACHE ) {btrfs_release_path (path);
fs/btrfs/file.c +31 -30
177 lines not on this page · raw message
fs/btrfs/free-space-cache.c +8 -8
@@ -336,7 +336,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans,btrfs_i_size_write (inode,0 );truncate_pagecache (vfs_inode,0 ); -lock_extent (&inode->io_tree,0 , (u64)-1 , &cached_state); +btrfs_lock_extent (&inode->io_tree,0 , (u64)-1 , &cached_state);btrfs_drop_extent_map_range (inode,0 , (u64)-1 , false);/*
@@ -348,7 +348,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans,inode_sub_bytes (&inode->vfs_inode, control.sub_bytes);btrfs_inode_safe_disk_i_size_write (inode, control.last_size); -unlock_extent (&inode->io_tree,0 , (u64)-1 , &cached_state); +btrfs_unlock_extent (&inode->io_tree,0 , (u64)-1 , &cached_state);if (ret) goto fail;
@@ -1288,8 +1288,8 @@ cleanup_write_cache_enospc(struct inode *inode, struct extent_state **cached_state) {io_ctl_drop_pages (io_ctl); -unlock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , - cached_state); +btrfs_unlock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , + cached_state); } static int __btrfs_wait_cache_io(struct btrfs_root *root,
@@ -1414,8 +1414,8 @@ static int __btrfs_write_out_cache(struct inode *inode,if (ret) goto out_unlock; -lock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , - &cached_state); +btrfs_lock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , + &cached_state);io_ctl_set_generation (io_ctl, trans->transid);
@@ -1475,8 +1475,8 @@ static int __btrfs_write_out_cache(struct inode *inode,io_ctl_drop_pages (io_ctl);io_ctl_free (io_ctl); -unlock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , - &cached_state); +btrfs_unlock_extent (&BTRFS_I (inode)->io_tree,0 ,i_size_read (inode) -1 , + &cached_state);/* * at this point the pages are under IO and we're happy,
fs/btrfs/inode.c +42 -44
306 lines not on this page · raw message
fs/btrfs/ioctl.c +4 -4
@@ -4510,7 +4510,7 @@ static int btrfs_ioctl_encoded_read(struct file *file, void __user *argp, args.compression, &unlocked);if (!unlocked) { -unlock_extent (io_tree, start, lockend, &cached_state); +btrfs_unlock_extent (io_tree, start, lockend, &cached_state);btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED ); } }
@@ -4699,7 +4699,7 @@ static void btrfs_uring_read_finished(struct io_uring_cmd *cmd, unsigned int iss ret = priv->count; out: -unlock_extent (io_tree, priv->start, priv->lockend, &priv->cached_state); +btrfs_unlock_extent (io_tree, priv->start, priv->lockend, &priv->cached_state);btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED );io_uring_cmd_done (cmd, ret,0 , issue_flags);
@@ -4788,7 +4788,7 @@ static int btrfs_uring_read_extent(struct kiocb *iocb, struct iov_iter *iter,return -EIOCBQUEUED ; out_fail: -unlock_extent (io_tree, start, lockend, &cached_state); +btrfs_unlock_extent (io_tree, start, lockend, &cached_state);btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED );kfree (priv);return ret;
@@ -4913,7 +4913,7 @@ static int btrfs_uring_encoded_read(struct io_uring_cmd *cmd, unsigned int issue (const char *)&data->args + copy_end_kernel, sizeof(data->args) - copy_end_kernel)) {if (ret == -EIOCBQUEUED ) { -unlock_extent (io_tree, start, lockend, &cached_state); +btrfs_unlock_extent (io_tree, start, lockend, &cached_state);btrfs_inode_unlock (inode,BTRFS_ILOCK_SHARED ); } ret = -EFAULT ;
fs/btrfs/ordered-data.c +4 -4
@@ -1173,7 +1173,7 @@ void btrfs_lock_and_flush_ordered_range(struct btrfs_inode *inode, u64 start, cachedp = cached_state;while (1 ) { -lock_extent (&inode->io_tree, start, end, cachedp); +btrfs_lock_extent (&inode->io_tree, start, end, cachedp); ordered =btrfs_lookup_ordered_range (inode, start, end - start +1 );if (!ordered) {
@@ -1186,7 +1186,7 @@ void btrfs_lock_and_flush_ordered_range(struct btrfs_inode *inode, u64 start,refcount_dec (&cache->refs);break ; } -unlock_extent (&inode->io_tree, start, end, cachedp); +btrfs_unlock_extent (&inode->io_tree, start, end, cachedp);btrfs_start_ordered_extent (ordered);btrfs_put_ordered_extent (ordered); }
@@ -1204,7 +1204,7 @@ bool btrfs_try_lock_ordered_range(struct btrfs_inode *inode, u64 start, u64 end, {struct btrfs_ordered_extent *ordered; -if (!try_lock_extent (&inode->io_tree, start, end, cached_state)) +if (!btrfs_try_lock_extent (&inode->io_tree, start, end, cached_state))return false; ordered =btrfs_lookup_ordered_range (inode, start, end - start +1 );
@@ -1212,7 +1212,7 @@ bool btrfs_try_lock_ordered_range(struct btrfs_inode *inode, u64 start, u64 end,return true;btrfs_put_ordered_extent (ordered); -unlock_extent (&inode->io_tree, start, end, cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, cached_state);return false; }
fs/btrfs/reflink.c +4 -4
@@ -645,10 +645,10 @@ static int btrfs_extent_same_range(struct btrfs_inode *src, u64 loff, u64 len,* because we have already locked the inode's i_mmap_lock in exclusive * mode. */ -lock_extent (&dst->io_tree, dst_loff, end, &cached_state); +btrfs_lock_extent (&dst->io_tree, dst_loff, end, &cached_state); ret =btrfs_clone (&src->vfs_inode, &dst->vfs_inode, loff, len,ALIGN (len, bs), dst_loff,1 ); -unlock_extent (&dst->io_tree, dst_loff, end, &cached_state); +btrfs_unlock_extent (&dst->io_tree, dst_loff, end, &cached_state);btrfs_btree_balance_dirty (fs_info);
@@ -748,9 +748,9 @@ static noinline int btrfs_clone_files(struct file *file, struct file *file_src,* mode. */ end = destoff + len -1 ; -lock_extent (&BTRFS_I (inode)->io_tree, destoff, end, &cached_state); +btrfs_lock_extent (&BTRFS_I (inode)->io_tree, destoff, end, &cached_state); ret =btrfs_clone (src, inode, off, olen, len, destoff,0 ); -unlock_extent (&BTRFS_I (inode)->io_tree, destoff, end, &cached_state); +btrfs_unlock_extent (&BTRFS_I (inode)->io_tree, destoff, end, &cached_state);/* * We may have copied an inline extent into a page of the destination
fs/btrfs/relocation.c +14 -14
@@ -910,16 +910,16 @@ int replace_file_extents(struct btrfs_trans_handle *trans,/* Take mmap lock to serialize with reflinks. */ if (!down_read_trylock (&inode->i_mmap_lock))continue ; - ret =try_lock_extent (&inode->io_tree, key.offset, - end, &cached_state); + ret =btrfs_try_lock_extent (&inode->io_tree, key.offset, + end, &cached_state);if (!ret) {up_read (&inode->i_mmap_lock);continue ; }btrfs_drop_extent_map_range (inode, key.offset, end, true); -unlock_extent (&inode->io_tree, key.offset, end, - &cached_state); +btrfs_unlock_extent (&inode->io_tree, key.offset, end, + &cached_state);up_read (&inode->i_mmap_lock); } }
@@ -1378,9 +1378,9 @@ static int invalidate_extent_cache(struct btrfs_root *root, }/* the lock_extent waits for read_folio to complete */ -lock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_lock_extent (&inode->io_tree, start, end, &cached_state);btrfs_drop_extent_map_range (inode, start, end, true); -unlock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, &cached_state); }return 0 ; }
@@ -2735,13 +2735,13 @@ static noinline_for_stack int prealloc_file_extent_cluster(struct reloc_controlelse end = cluster->end - offset; -lock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_lock_extent (&inode->io_tree, start, end, &cached_state); num_bytes = end +1 - start; ret =btrfs_prealloc_file_range (&inode->vfs_inode,0 , start, num_bytes, num_bytes, end +1 , &alloc_hint); cur_offset = end +1 ; -unlock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, &cached_state);if (ret)break ; }
@@ -2774,9 +2774,9 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct reloc_contr em->ram_bytes = em->len; em->flags |=EXTENT_FLAG_PINNED ; -lock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_lock_extent (&inode->io_tree, start, end, &cached_state); ret =btrfs_replace_extent_map_range (inode, em, false); -unlock_extent (&inode->io_tree, start, end, &cached_state); +btrfs_unlock_extent (&inode->io_tree, start, end, &cached_state);free_extent_map (em);return ret;
@@ -2899,8 +2899,8 @@ static int relocate_one_folio(struct reloc_control *rc, goto release_folio;/* Mark the range delalloc and dirty for later writeback */ -lock_extent (&BTRFS_I (inode)->io_tree, clamped_start, clamped_end, - &cached_state); +btrfs_lock_extent (&BTRFS_I (inode)->io_tree, clamped_start, + clamped_end, &cached_state); ret =btrfs_set_extent_delalloc (BTRFS_I (inode), clamped_start, clamped_end,0 , &cached_state);if (ret) {
@@ -2933,8 +2933,8 @@ static int relocate_one_folio(struct reloc_control *rc, boundary_start, boundary_end, EXTENT_BOUNDARY, NULL); } -unlock_extent (&BTRFS_I (inode)->io_tree, clamped_start, clamped_end, - &cached_state); +btrfs_unlock_extent (&BTRFS_I (inode)->io_tree, clamped_start, clamped_end, + &cached_state);btrfs_delalloc_release_extents (BTRFS_I (inode), clamped_len); cur += clamped_len;
fs/btrfs/tests/extent-io-tests.c +3 -3
@@ -189,7 +189,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize) sectorsize - 1, start, end); goto out_bits; } -unlock_extent (tmp, start, end,NULL ); +btrfs_unlock_extent (tmp, start, end,NULL );unlock_page (locked_page);put_page (locked_page);
@@ -225,7 +225,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)test_err ("there were unlocked pages in the range" ); goto out_bits; } -unlock_extent (tmp, start, end,NULL ); +btrfs_unlock_extent (tmp, start, end,NULL );/* locked_page was unlocked above */ put_page (locked_page);
@@ -280,7 +280,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)test_err ("pages in range were not all locked" ); goto out_bits; } -unlock_extent (tmp, start, end,NULL ); +btrfs_unlock_extent (tmp, start, end,NULL );/* * Now to test where we run into a page that is no longer dirty in the
fs/btrfs/tree-log.c +4 -4
@@ -4300,8 +4300,8 @@ static int log_csums(struct btrfs_trans_handle *trans,* file which happens to refer to the same extent as well. Such races * can leave checksum items in the log with overlapping ranges. */ - ret =lock_extent (&log_root->log_csum_range, sums->logical, lock_end, - &cached_state); + ret =btrfs_lock_extent (&log_root->log_csum_range, sums->logical, lock_end, + &cached_state);if (ret)return ret;/*
@@ -4317,8 +4317,8 @@ static int log_csums(struct btrfs_trans_handle *trans,if (!ret) ret =btrfs_csum_file_blocks (trans, log_root, sums); -unlock_extent (&log_root->log_csum_range, sums->logical, lock_end, - &cached_state); +btrfs_unlock_extent (&log_root->log_csum_range, sums->logical, lock_end, + &cached_state);return ret; }
Signature · 1 line
2.45.2
PATCH 4/16 btrfs: add btrfs prefix to dio lock and unlock extent functions
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel. So add a prefix to their name.
--- fs/btrfs/direct-io.c | 22 +++++++++++----------- fs/btrfs/extent-io-tree.h | 12 ++++++------ 2 files changed, 17 insertions(+), 17 deletions(-)
fs/btrfs/direct-io.c +11 -11
@@ -42,10 +42,10 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend,/* Direct lock must be taken before the extent lock. */ if (nowait) { -if (!try_lock_dio_extent (io_tree, lockstart, lockend, cached_state)) +if (!btrfs_try_lock_dio_extent (io_tree, lockstart, lockend, cached_state))return -EAGAIN ; }else { -lock_dio_extent (io_tree, lockstart, lockend, cached_state); +btrfs_lock_dio_extent (io_tree, lockstart, lockend, cached_state); }while (1 ) {
@@ -131,7 +131,7 @@ static int lock_extent_direct(struct inode *inode, u64 lockstart, u64 lockend, }if (ret) -unlock_dio_extent (io_tree, lockstart, lockend, cached_state); +btrfs_unlock_dio_extent (io_tree, lockstart, lockend, cached_state);return ret; }
@@ -580,8 +580,8 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,/* We didn't use everything, unlock the dio extent for the remainder. */ if (!write && (start + len) < lockend) -unlock_dio_extent (&BTRFS_I (inode)->io_tree, start + len, - lockend,NULL ); +btrfs_unlock_dio_extent (&BTRFS_I (inode)->io_tree, start + len, + lockend,NULL );return 0 ;
@@ -615,8 +615,8 @@ static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length,if (!write && (iomap->type ==IOMAP_HOLE )) {/* If reading from a hole, unlock and return */ -unlock_dio_extent (&BTRFS_I (inode)->io_tree, pos, - pos + length -1 ,NULL ); +btrfs_unlock_dio_extent (&BTRFS_I (inode)->io_tree, pos, + pos + length -1 ,NULL );return 0 ; }
@@ -627,8 +627,8 @@ static int btrfs_dio_iomap_end(struct inode *inode, loff_t pos, loff_t length,btrfs_finish_ordered_extent (dio_data->ordered,NULL , pos, length, false); else - unlock_dio_extent(&BTRFS_I(inode)->io_tree, pos, - pos + length - 1, NULL); + btrfs_unlock_dio_extent(&BTRFS_I(inode)->io_tree, pos, + pos + length - 1, NULL); ret = -ENOTBLK ; }if (write) {
@@ -660,8 +660,8 @@ static void btrfs_dio_end_io(struct btrfs_bio *bbio) dip->file_offset, dip->bytes, !bio->bi_status); }else { -unlock_dio_extent (&inode->io_tree, dip->file_offset, - dip->file_offset + dip->bytes -1 ,NULL ); +btrfs_unlock_dio_extent (&inode->io_tree, dip->file_offset, + dip->file_offset + dip->bytes -1 ,NULL ); } bbio->bio.bi_private = bbio->private;
fs/btrfs/extent-io-tree.h +6 -6
@@ -223,20 +223,20 @@ int find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start,bool btrfs_find_delalloc_range (struct extent_io_tree *tree,u64 *start,u64 *end,u64 max_bytes,struct extent_state **cached_state); -static inline int lock_dio_extent (struct extent_io_tree *tree,u64 start, -u64 end,struct extent_state **cached) +static inline int btrfs_lock_dio_extent (struct extent_io_tree *tree,u64 start, +u64 end,struct extent_state **cached) {return __lock_extent (tree, start, end,EXTENT_DIO_LOCKED , cached); } -static inline bool try_lock_dio_extent (struct extent_io_tree *tree,u64 start, -u64 end,struct extent_state **cached) +static inline bool btrfs_try_lock_dio_extent (struct extent_io_tree *tree,u64 start, +u64 end,struct extent_state **cached) {return __try_lock_extent (tree, start, end,EXTENT_DIO_LOCKED , cached); } -static inline int unlock_dio_extent (struct extent_io_tree *tree,u64 start, -u64 end,struct extent_state **cached) +static inline int btrfs_unlock_dio_extent (struct extent_io_tree *tree,u64 start, +u64 end,struct extent_state **cached) {return __clear_extent_bit (tree, start, end,EXTENT_DIO_LOCKED , cached,NULL ); }
Signature · 1 line
2.45.2
PATCH 5/16 btrfs: rename __lock_extent() and __try_lock_extent()
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel. Their double underscore prefix is also discouraged.
So remove their double underscore prefix, add a 'btrfs_' prefix to their name to make it clear they are from btrfs and a '_bits' suffix to avoid collision with btrfs_lock_extent() and btrfs_try_lock_extent().
--- fs/btrfs/extent-io-tree.c | 8 ++++---- fs/btrfs/extent-io-tree.h | 16 ++++++++-------- fs/btrfs/inode.c | 6 +++--- 3 files changed, 15 insertions(+), 15 deletions(-)
fs/btrfs/extent-io-tree.c +4 -4
@@ -1831,8 +1831,8 @@ int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,return __clear_extent_bit (tree, start, end, bits,NULL , changeset); } -bool __try_lock_extent (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, -struct extent_state **cached) +bool btrfs_try_lock_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached) {int err;u64 failed_start;
@@ -1851,8 +1851,8 @@ bool __try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end, u32 bits* Either insert or lock state struct between start and end use mask to tell * us if waiting is desired. */ -int __lock_extent (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, -struct extent_state **cached_state) +int btrfs_lock_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, +struct extent_state **cached_state) {struct extent_state *failed_state =NULL ;int err;
fs/btrfs/extent-io-tree.h +8 -8
@@ -140,21 +140,21 @@ const struct btrfs_fs_info *extent_io_tree_to_fs_info(const struct extent_io_trevoid extent_io_tree_init (struct btrfs_fs_info *fs_info,struct extent_io_tree *tree,unsigned int owner);void extent_io_tree_release (struct extent_io_tree *tree); -int __lock_extent (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, -struct extent_state **cached); -bool __try_lock_extent (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, -struct extent_state **cached); +int btrfs_lock_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits, +struct extent_state **cached); +bool btrfs_try_lock_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached);static inline int btrfs_lock_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __lock_extent (tree, start, end,EXTENT_LOCKED , cached); +return btrfs_lock_extent_bits (tree, start, end,EXTENT_LOCKED , cached); }static inline bool btrfs_try_lock_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __try_lock_extent (tree, start, end,EXTENT_LOCKED , cached); +return btrfs_try_lock_extent_bits (tree, start, end,EXTENT_LOCKED , cached); }int __init extent_state_init_cachep (void );
@@ -226,13 +226,13 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start,static inline int btrfs_lock_dio_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __lock_extent (tree, start, end,EXTENT_DIO_LOCKED , cached); +return btrfs_lock_extent_bits (tree, start, end,EXTENT_DIO_LOCKED , cached); }static inline bool btrfs_try_lock_dio_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __try_lock_extent (tree, start, end,EXTENT_DIO_LOCKED , cached); +return btrfs_try_lock_extent_bits (tree, start, end,EXTENT_DIO_LOCKED , cached); } static inline int btrfs_unlock_dio_extent(struct extent_io_tree *tree, u64 start,
fs/btrfs/inode.c +3 -3
@@ -3128,9 +3128,9 @@ int btrfs_finish_one_ordered(struct btrfs_ordered_extent *ordered_extent)*/ if (!test_bit (BTRFS_ORDERED_NOCOW , &ordered_extent->flags)) { clear_bits |=EXTENT_LOCKED |EXTENT_FINISHING_ORDERED ; -__lock_extent (io_tree, start, end, -EXTENT_LOCKED |EXTENT_FINISHING_ORDERED , - &cached_state); +btrfs_lock_extent_bits (io_tree, start, end, +EXTENT_LOCKED |EXTENT_FINISHING_ORDERED , + &cached_state); }if (freespace_inode)
Signature · 1 line
2.45.2
PATCH 6/16 btrfs: rename the functions to clear bits for an extent range
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel. One of them has a double underscore prefix which is also discouraged.
So remove double underscore prefix where applicable and add a 'btrfs_' prefix to their name to make it clear they are from btrfs.
--- fs/btrfs/block-group.c | 12 ++++----- fs/btrfs/defrag.c | 6 ++--- fs/btrfs/direct-io.c | 8 +++--- fs/btrfs/disk-io.c | 4 +-- fs/btrfs/extent-io-tree.c | 15 +++++------ fs/btrfs/extent-io-tree.h | 36 +++++++++++++------------- fs/btrfs/extent-tree.c | 2 +- fs/btrfs/extent_io.c | 4 +-- fs/btrfs/file-item.c | 4 +-- fs/btrfs/file.c | 12 ++++----- fs/btrfs/free-space-cache.c | 14 +++++------ fs/btrfs/inode.c | 43 ++++++++++++++++---------------- fs/btrfs/qgroup.c | 4 +-- fs/btrfs/reflink.c | 4 +-- fs/btrfs/relocation.c | 10 ++++---- fs/btrfs/tests/extent-io-tests.c | 4 +-- fs/btrfs/tests/inode-tests.c | 24 +++++++++--------- fs/btrfs/transaction.c | 4 +-- fs/btrfs/volumes.c | 10 ++++---- 19 files changed, 112 insertions(+), 108 deletions(-)
fs/btrfs/block-group.c +6 -6
@@ -832,8 +832,8 @@ static int load_extent_tree_free(struct btrfs_caching_control *caching_ctl)static inline void btrfs_free_excluded_extents (const struct btrfs_block_group *bg) { -clear_extent_bits (&bg->fs_info->excluded_extents, bg->start, - bg->start + bg->length -1 ,EXTENT_DIRTY ); +btrfs_clear_extent_bits (&bg->fs_info->excluded_extents, bg->start, + bg->start + bg->length -1 ,EXTENT_DIRTY ); } static noinline void caching_thread(struct btrfs_work *work)
@@ -1437,14 +1437,14 @@ static bool clean_pinned_extents(struct btrfs_trans_handle *trans,*/ mutex_lock (&fs_info->unused_bg_unpin_mutex);if (prev_trans) { - ret =clear_extent_bits (&prev_trans->pinned_extents, start, end, -EXTENT_DIRTY ); + ret =btrfs_clear_extent_bits (&prev_trans->pinned_extents, start, end, +EXTENT_DIRTY );if (ret) goto out; } - ret =clear_extent_bits (&trans->transaction->pinned_extents, start, end, -EXTENT_DIRTY ); + ret =btrfs_clear_extent_bits (&trans->transaction->pinned_extents, start, end, +EXTENT_DIRTY ); out:mutex_unlock (&fs_info->unused_bg_unpin_mutex);if (prev_trans)
fs/btrfs/defrag.c +3 -3
@@ -1170,9 +1170,9 @@ static int defrag_one_locked_target(struct btrfs_inode *inode, ret =btrfs_delalloc_reserve_space (inode, &data_reserved, start, len);if (ret <0 )return ret; -clear_extent_bit (&inode->io_tree, start, start + len -1 , -EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING | -EXTENT_DEFRAG , cached_state); +btrfs_clear_extent_bit (&inode->io_tree, start, start + len -1 , +EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING | +EXTENT_DEFRAG , cached_state);set_extent_bit (&inode->io_tree, start, start + len -1 ,EXTENT_DELALLOC |EXTENT_DEFRAG , cached_state);
fs/btrfs/direct-io.c +4 -4
@@ -575,8 +575,8 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,if (write) unlock_bits |=EXTENT_DIO_LOCKED ; -clear_extent_bit (&BTRFS_I (inode)->io_tree, lockstart, lockend, - unlock_bits, &cached_state); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree, lockstart, lockend, + unlock_bits, &cached_state);/* We didn't use everything, unlock the dio extent for the remainder. */ if (!write && (start + len) < lockend)
@@ -591,8 +591,8 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,* to update this, be explicit that we expect EXTENT_LOCKED and * EXTENT_DIO_LOCKED to be set here, and so that's what we're clearing. */ -clear_extent_bit (&BTRFS_I (inode)->io_tree, lockstart, lockend, -EXTENT_LOCKED |EXTENT_DIO_LOCKED , &cached_state); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree, lockstart, lockend, +EXTENT_LOCKED |EXTENT_DIO_LOCKED , &cached_state); err:if (dio_data->data_space_reserved) { btrfs_free_reserved_data_space(BTRFS_I(inode),
fs/btrfs/disk-io.c +2 -2
@@ -4693,7 +4693,7 @@ static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,while (find_first_extent_bit (dirty_pages, start, &start, &end, mark,NULL )) { -clear_extent_bits (dirty_pages, start, end, mark); +btrfs_clear_extent_bits (dirty_pages, start, end, mark);while (start <= end) { eb =find_extent_buffer (fs_info, start); start += fs_info->nodesize;
@@ -4732,7 +4732,7 @@ static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,break ; } -clear_extent_dirty (unpin, start, end, &cached_state); +btrfs_clear_extent_dirty (unpin, start, end, &cached_state);free_extent_state (cached_state);btrfs_error_unpin_extent_range (fs_info, start, end);mutex_unlock (&fs_info->unused_bg_unpin_mutex);
fs/btrfs/extent-io-tree.c +8 -7
@@ -597,9 +597,9 @@ static void set_gfp_mask_from_bits(u32 *bits, gfp_t *mask)* * This takes the tree lock, and returns 0 on success and < 0 on error. */ -int __clear_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_state **cached_state, -struct extent_changeset *changeset) +int btrfs_clear_extent_bit_changeset (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached_state, +struct extent_changeset *changeset) {struct extent_state *state;struct extent_state *cached;
@@ -1828,7 +1828,7 @@ int clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,*/ ASSERT (!(bits &EXTENT_LOCK_BITS )); -return __clear_extent_bit (tree, start, end, bits,NULL , changeset); +return btrfs_clear_extent_bit_changeset (tree, start, end, bits,NULL , changeset); } bool btrfs_try_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
@@ -1841,7 +1841,8 @@ bool btrfs_try_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, NULL, cached, NULL);if (err == -EEXIST ) {if (failed_start > start) -clear_extent_bit (tree, start, failed_start -1 , bits, cached); +btrfs_clear_extent_bit (tree, start, failed_start -1 , + bits, cached);return 0 ; }return 1 ;
@@ -1862,8 +1863,8 @@ int btrfs_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 &failed_state, cached_state, NULL);while (err == -EEXIST ) {if (failed_start != start) -clear_extent_bit (tree, start, failed_start -1 , - bits, cached_state); +btrfs_clear_extent_bit (tree, start, failed_start -1 , + bits, cached_state);wait_extent_bit (tree, failed_start, end, bits, &failed_state); err = __set_extent_bit(tree, start, end, bits,
fs/btrfs/extent-io-tree.h +19 -17
@@ -173,27 +173,28 @@ void get_range_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 *bits, struct extent_state **cached_state);int clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_changeset *changeset); -int __clear_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_state **cached, -struct extent_changeset *changeset); +int btrfs_clear_extent_bit_changeset (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached, +struct extent_changeset *changeset); -static inline int clear_extent_bit (struct extent_io_tree *tree,u64 start, -u64 end,u32 bits, -struct extent_state **cached) +static inline int btrfs_clear_extent_bit (struct extent_io_tree *tree,u64 start, +u64 end,u32 bits, +struct extent_state **cached) { -return __clear_extent_bit (tree, start, end, bits, cached,NULL ); +return btrfs_clear_extent_bit_changeset (tree, start, end, bits, cached,NULL ); }static inline int btrfs_unlock_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __clear_extent_bit (tree, start, end,EXTENT_LOCKED , cached,NULL ); +return btrfs_clear_extent_bit_changeset (tree, start, end,EXTENT_LOCKED , + cached,NULL ); } -static inline int clear_extent_bits (struct extent_io_tree *tree,u64 start, -u64 end,u32 bits) +static inline int btrfs_clear_extent_bits (struct extent_io_tree *tree,u64 start, +u64 end,u32 bits) { -return clear_extent_bit (tree, start, end, bits,NULL ); +return btrfs_clear_extent_bit (tree, start, end, bits,NULL ); } int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
@@ -201,12 +202,12 @@ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,int set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached_state); -static inline int clear_extent_dirty (struct extent_io_tree *tree,u64 start, -u64 end,struct extent_state **cached) +static inline int btrfs_clear_extent_dirty (struct extent_io_tree *tree,u64 start, +u64 end,struct extent_state **cached) { -return clear_extent_bit (tree, start, end, -EXTENT_DIRTY |EXTENT_DELALLOC | -EXTENT_DO_ACCOUNTING , cached); +return btrfs_clear_extent_bit (tree, start, end, +EXTENT_DIRTY |EXTENT_DELALLOC | +EXTENT_DO_ACCOUNTING , cached); } int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,
@@ -238,7 +239,8 @@ static inline bool btrfs_try_lock_dio_extent(struct extent_io_tree *tree, u64 ststatic inline int btrfs_unlock_dio_extent (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached) { -return __clear_extent_bit (tree, start, end,EXTENT_DIO_LOCKED , cached,NULL ); +return btrfs_clear_extent_bit_changeset (tree, start, end,EXTENT_DIO_LOCKED , + cached,NULL ); }#endif /* BTRFS_EXTENT_IO_TREE_H */
fs/btrfs/extent-tree.c +1 -1
@@ -2839,7 +2839,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans) ret =btrfs_discard_extent (fs_info, start, end +1 - start,NULL ); -clear_extent_dirty (unpin, start, end, &cached_state); +btrfs_clear_extent_dirty (unpin, start, end, &cached_state); ret =unpin_extent_range (fs_info, start, end, true);BUG_ON (ret);mutex_unlock (&fs_info->unused_bg_unpin_mutex);
fs/btrfs/extent_io.c +2 -2
@@ -393,7 +393,7 @@ void extent_clear_unlock_delalloc(struct btrfs_inode *inode, u64 start, u64 end,struct extent_state **cached, u32 clear_bits, unsigned long page_ops) { - clear_extent_bit(&inode->io_tree, start, end, clear_bits, cached); + btrfs_clear_extent_bit(&inode->io_tree, start, end, clear_bits, cached);__process_folios_contig (inode->vfs_inode.i_mapping, locked_folio, start, end, page_ops);
@@ -2638,7 +2638,7 @@ static bool try_release_extent_state(struct extent_io_tree *tree,* nodatasum, delalloc new and finishing ordered bits. The delalloc new * bit will be cleared by ordered extent completion. */ - ret2 =clear_extent_bit (tree, start, end, clear_bits, &cached_state); + ret2 =btrfs_clear_extent_bit (tree, start, end, clear_bits, &cached_state);/* * If clear_extent_bit failed for enomem reasons, we can't allow the * release to continue.
fs/btrfs/file-item.c +2 -2
@@ -121,8 +121,8 @@ int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,ASSERT (IS_ALIGNED (start + len, inode->root->fs_info->sectorsize) || len == (u64)-1 ); -return clear_extent_bit (inode->file_extent_tree, start, - start + len -1 ,EXTENT_DIRTY ,NULL ); +return btrfs_clear_extent_bit (inode->file_extent_tree, start, + start + len -1 ,EXTENT_DIRTY ,NULL ); }static size_t bytes_to_csum_size (const struct btrfs_fs_info *fs_info,u32 bytes)
fs/btrfs/file.c +6 -6
@@ -98,9 +98,9 @@ int btrfs_dirty_folio(struct btrfs_inode *inode, struct folio *folio, loff_t pos* The pages may have already been dirty, clear out old accounting so * we can set things up properly */ -clear_extent_bit (&inode->io_tree, start_pos, end_of_last_block, -EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG , - cached); +btrfs_clear_extent_bit (&inode->io_tree, start_pos, end_of_last_block, +EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG , + cached); ret =btrfs_set_extent_delalloc (inode, start_pos, end_of_last_block, extra_bits, cached);
@@ -1937,9 +1937,9 @@ static vm_fault_t btrfs_page_mkwrite(struct vm_fault *vmf)* clear any delalloc bits within this page range since we have to * reserve data&meta space before lock_page() (see above comments). */ -clear_extent_bit (&BTRFS_I (inode)->io_tree, page_start, end, -EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING | -EXTENT_DEFRAG , &cached_state); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree, page_start, end, +EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING | +EXTENT_DEFRAG , &cached_state); ret2 =btrfs_set_extent_delalloc (BTRFS_I (inode), page_start, end,0 , &cached_state);
fs/btrfs/free-space-cache.c +7 -7
@@ -1160,8 +1160,8 @@ update_cache_item(struct btrfs_trans_handle *trans, ret =btrfs_search_slot (trans, root, &key, path,0 ,1 );if (ret <0 ) { -clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , inode->i_size -1 , -EXTENT_DELALLOC ,NULL ); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , inode->i_size -1 , +EXTENT_DELALLOC ,NULL ); goto fail; } leaf = path->nodes[0 ];
@@ -1172,9 +1172,9 @@ update_cache_item(struct btrfs_trans_handle *trans,btrfs_item_key_to_cpu (leaf, &found_key, path->slots[0 ]);if (found_key.objectid !=BTRFS_FREE_SPACE_OBJECTID || found_key.offset != offset) { -clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , - inode->i_size -1 ,EXTENT_DELALLOC , -NULL ); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , + inode->i_size -1 ,EXTENT_DELALLOC , +NULL );btrfs_release_path (path); goto fail; }
@@ -1267,8 +1267,8 @@ static int flush_dirty_cache(struct inode *inode) ret =btrfs_wait_ordered_range (BTRFS_I (inode),0 , (u64)-1 );if (ret) -clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , inode->i_size -1 , -EXTENT_DELALLOC ,NULL ); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree,0 , inode->i_size -1 , +EXTENT_DELALLOC ,NULL );return ret; }
fs/btrfs/inode.c +22 -21
91 lines not on this page · raw message
fs/btrfs/qgroup.c +2 -2
@@ -4129,8 +4129,8 @@ static int qgroup_unreserve_range(struct btrfs_inode *inode,* Now the entry is in [start, start + len), revert the * EXTENT_QGROUP_RESERVED bit. */ - clear_ret =clear_extent_bits (&inode->io_tree, entry_start, - entry_end,EXTENT_QGROUP_RESERVED ); + clear_ret =btrfs_clear_extent_bits (&inode->io_tree, entry_start, + entry_end,EXTENT_QGROUP_RESERVED );if (!ret && clear_ret <0 ) ret = clear_ret;
fs/btrfs/reflink.c +2 -2
@@ -95,8 +95,8 @@ static int copy_inline_to_page(struct btrfs_inode *inode,if (ret <0 ) goto out_unlock; -clear_extent_bits (&inode->io_tree, file_offset, range_end, -EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ); +btrfs_clear_extent_bits (&inode->io_tree, file_offset, range_end, +EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG ); ret =btrfs_set_extent_delalloc (inode, file_offset, range_end,0 ,NULL );if (ret) goto out_unlock;
fs/btrfs/relocation.c +5 -5
@@ -2904,10 +2904,10 @@ static int relocate_one_folio(struct reloc_control *rc, ret =btrfs_set_extent_delalloc (BTRFS_I (inode), clamped_start, clamped_end,0 , &cached_state);if (ret) { -clear_extent_bit (&BTRFS_I (inode)->io_tree, - clamped_start, clamped_end, -EXTENT_LOCKED |EXTENT_BOUNDARY , - &cached_state); +btrfs_clear_extent_bit (&BTRFS_I (inode)->io_tree, + clamped_start, clamped_end, +EXTENT_LOCKED |EXTENT_BOUNDARY , + &cached_state);btrfs_delalloc_release_metadata (BTRFS_I (inode), clamped_len, true); btrfs_delalloc_release_extents(BTRFS_I(inode),
@@ -3643,7 +3643,7 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc) }btrfs_release_path (path); -clear_extent_bits (&rc->processed_blocks,0 , (u64)-1 ,EXTENT_DIRTY ); +btrfs_clear_extent_bits (&rc->processed_blocks,0 , (u64)-1 ,EXTENT_DIRTY );if (trans) {btrfs_end_transaction_throttle (trans);
fs/btrfs/tests/extent-io-tests.c +2 -2
@@ -325,7 +325,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize) out_bits:if (ret)dump_extent_io_tree (tmp); -clear_extent_bits (tmp,0 , total_dirty -1 , (unsigned )-1 ); +btrfs_clear_extent_bits (tmp,0 , total_dirty -1 , (unsigned )-1 ); out:if (locked_page)put_page (locked_page);
@@ -661,7 +661,7 @@ static int test_find_first_clear_extent_bit(void) out:if (ret)dump_extent_io_tree (&tree); -clear_extent_bits (&tree,0 , (u64)-1 ,CHUNK_TRIMMED |CHUNK_ALLOCATED ); +btrfs_clear_extent_bits (&tree,0 , (u64)-1 ,CHUNK_TRIMMED |CHUNK_ALLOCATED );return ret; }
fs/btrfs/tests/inode-tests.c +12 -12
@@ -949,10 +949,10 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) }/* [BTRFS_MAX_EXTENT_SIZE/2][sectorsize HOLE][the rest] */ - ret =clear_extent_bits (&BTRFS_I (inode)->io_tree, -BTRFS_MAX_EXTENT_SIZE >>1 , - (BTRFS_MAX_EXTENT_SIZE >>1 ) + sectorsize -1 , -EXTENT_DELALLOC |EXTENT_DELALLOC_NEW ); + ret =btrfs_clear_extent_bits (&BTRFS_I (inode)->io_tree, +BTRFS_MAX_EXTENT_SIZE >>1 , + (BTRFS_MAX_EXTENT_SIZE >>1 ) + sectorsize -1 , +EXTENT_DELALLOC |EXTENT_DELALLOC_NEW );if (ret) {test_err ("clear_extent_bit returned %d" , ret); goto out;
@@ -1016,10 +1016,10 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) }/* [BTRFS_MAX_EXTENT_SIZE+4k][4K HOLE][BTRFS_MAX_EXTENT_SIZE+4k] */ - ret =clear_extent_bits (&BTRFS_I (inode)->io_tree, -BTRFS_MAX_EXTENT_SIZE + sectorsize, -BTRFS_MAX_EXTENT_SIZE +2 * sectorsize -1 , -EXTENT_DELALLOC |EXTENT_DELALLOC_NEW ); + ret =btrfs_clear_extent_bits (&BTRFS_I (inode)->io_tree, +BTRFS_MAX_EXTENT_SIZE + sectorsize, +BTRFS_MAX_EXTENT_SIZE +2 * sectorsize -1 , +EXTENT_DELALLOC |EXTENT_DELALLOC_NEW );if (ret) {test_err ("clear_extent_bit returned %d" , ret); goto out;
@@ -1050,8 +1050,8 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) }/* Empty */ - ret =clear_extent_bits (&BTRFS_I (inode)->io_tree,0 , (u64)-1 , -EXTENT_DELALLOC |EXTENT_DELALLOC_NEW ); + ret =btrfs_clear_extent_bits (&BTRFS_I (inode)->io_tree,0 , (u64)-1 , +EXTENT_DELALLOC |EXTENT_DELALLOC_NEW );if (ret) {test_err ("clear_extent_bit returned %d" , ret); goto out;
@@ -1065,8 +1065,8 @@ static int test_extent_accounting(u32 sectorsize, u32 nodesize) ret =0 ; out:if (ret) -clear_extent_bits (&BTRFS_I (inode)->io_tree,0 , (u64)-1 , -EXTENT_DELALLOC |EXTENT_DELALLOC_NEW ); +btrfs_clear_extent_bits (&BTRFS_I (inode)->io_tree,0 , (u64)-1 , +EXTENT_DELALLOC |EXTENT_DELALLOC_NEW );iput (inode);btrfs_free_dummy_root (root);btrfs_free_dummy_fs_info (fs_info);
fs/btrfs/transaction.c +2 -2
@@ -1191,8 +1191,8 @@ static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,* concurrently - we do it only at transaction commit time when * it's safe to do it (through extent_io_tree_release()). */ - ret =clear_extent_bit (dirty_pages, start, end, -EXTENT_NEED_WAIT , &cached_state); + ret =btrfs_clear_extent_bit (dirty_pages, start, end, +EXTENT_NEED_WAIT , &cached_state);if (ret == -ENOMEM ) ret =0 ;if (!ret)
fs/btrfs/volumes.c +5 -5
@@ -5088,8 +5088,8 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)mutex_lock (&fs_info->chunk_mutex);/* Clear all state bits beyond the shrunk device size */ -clear_extent_bits (&device->alloc_state, new_size, (u64)-1 , -CHUNK_STATE_MASK ); +btrfs_clear_extent_bits (&device->alloc_state, new_size, (u64)-1 , +CHUNK_STATE_MASK );btrfs_device_set_disk_total_bytes (device, new_size);if (list_empty (&device->post_commit_list))
@@ -5508,9 +5508,9 @@ static void chunk_map_device_clear_bits(struct btrfs_chunk_map *map, unsigned instruct btrfs_io_stripe *stripe = &map->stripes[i];struct btrfs_device *device = stripe->dev; -clear_extent_bits (&device->alloc_state, stripe->physical, - stripe->physical + map->stripe_size -1 , - bits |EXTENT_NOWAIT ); +btrfs_clear_extent_bits (&device->alloc_state, stripe->physical, + stripe->physical + map->stripe_size -1 , + bits |EXTENT_NOWAIT ); } }
Signature · 1 line
2.45.2
PATCH 7/16 btrfs: rename set_extent_bit() to include a btrfs prefix
In reply to [email protected]From: Filipe Manana <[email protected]>
This is an exported function so it should have a 'btrfs_' prefix by convention, to make it clear it's btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
So rename it to btrfs_set_extent_bit().
--- fs/btrfs/block-group.c | 16 ++++++++-------- fs/btrfs/defrag.c | 4 ++-- fs/btrfs/dev-replace.c | 4 ++-- fs/btrfs/extent-io-tree.c | 4 ++-- fs/btrfs/extent-io-tree.h | 4 ++-- fs/btrfs/extent-tree.c | 24 ++++++++++++------------ fs/btrfs/file-item.c | 10 +++++----- fs/btrfs/inode.c | 14 +++++++------- fs/btrfs/relocation.c | 11 ++++++----- fs/btrfs/tests/extent-io-tests.c | 16 ++++++++-------- fs/btrfs/volumes.c | 6 +++--- 11 files changed, 57 insertions(+), 56 deletions(-)
fs/btrfs/block-group.c +8 -8
@@ -2216,9 +2216,9 @@ static int exclude_super_stripes(struct btrfs_block_group *cache)if (cache->start <BTRFS_SUPER_INFO_OFFSET ) { stripe_len =BTRFS_SUPER_INFO_OFFSET - cache->start; cache->bytes_super += stripe_len; - ret =set_extent_bit (&fs_info->excluded_extents, cache->start, - cache->start + stripe_len -1 , -EXTENT_DIRTY ,NULL ); + ret =btrfs_set_extent_bit (&fs_info->excluded_extents, cache->start, + cache->start + stripe_len -1 , +EXTENT_DIRTY ,NULL );if (ret)return ret; }
@@ -2244,9 +2244,9 @@ static int exclude_super_stripes(struct btrfs_block_group *cache) cache->start + cache->length - logical[nr]); cache->bytes_super += len; - ret =set_extent_bit (&fs_info->excluded_extents, logical[nr], - logical[nr] + len -1 , -EXTENT_DIRTY ,NULL ); + ret =btrfs_set_extent_bit (&fs_info->excluded_extents, + logical[nr], logical[nr] + len -1 , +EXTENT_DIRTY ,NULL );if (ret) {kfree (logical);return ret;
@@ -3736,8 +3736,8 @@ int btrfs_update_block_group(struct btrfs_trans_handle *trans,spin_unlock (&cache->lock);spin_unlock (&space_info->lock); -set_extent_bit (&trans->transaction->pinned_extents, bytenr, - bytenr + num_bytes -1 ,EXTENT_DIRTY ,NULL ); +btrfs_set_extent_bit (&trans->transaction->pinned_extents, bytenr, + bytenr + num_bytes -1 ,EXTENT_DIRTY ,NULL ); }spin_lock (&trans->transaction->dirty_bgs_lock);
fs/btrfs/defrag.c +2 -2
@@ -1173,8 +1173,8 @@ static int defrag_one_locked_target(struct btrfs_inode *inode,btrfs_clear_extent_bit (&inode->io_tree, start, start + len -1 ,EXTENT_DELALLOC |EXTENT_DO_ACCOUNTING |EXTENT_DEFRAG , cached_state); -set_extent_bit (&inode->io_tree, start, start + len -1 , -EXTENT_DELALLOC |EXTENT_DEFRAG , cached_state); +btrfs_set_extent_bit (&inode->io_tree, start, start + len -1 , +EXTENT_DELALLOC |EXTENT_DEFRAG , cached_state);/* Update the page status */ for (i = start_index - first_index; i <= last_index - first_index; i++) {
fs/btrfs/dev-replace.c +2 -2
@@ -797,8 +797,8 @@ static int btrfs_set_target_alloc_state(struct btrfs_device *srcdev,while (find_first_extent_bit (&srcdev->alloc_state, start, &found_start, &found_end,CHUNK_ALLOCATED , &cached_state)) { - ret =set_extent_bit (&tgtdev->alloc_state, found_start, - found_end,CHUNK_ALLOCATED ,NULL ); + ret =btrfs_set_extent_bit (&tgtdev->alloc_state, found_start, + found_end,CHUNK_ALLOCATED ,NULL );if (ret)break ; start = found_end +1 ;
fs/btrfs/extent-io-tree.c +2 -2
@@ -1256,8 +1256,8 @@ static int __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, } -int set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_state **cached_state) +int btrfs_set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached_state) {return __set_extent_bit (tree, start, end, bits,NULL ,NULL , cached_state,NULL );
fs/btrfs/extent-io-tree.h +2 -2
@@ -199,8 +199,8 @@ static inline int btrfs_clear_extent_bits(struct extent_io_tree *tree, u64 startint set_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_changeset *changeset); -int set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_state **cached_state); +int btrfs_set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_state **cached_state);static inline int btrfs_clear_extent_dirty (struct extent_io_tree *tree,u64 start,u64 end,struct extent_state **cached)
fs/btrfs/extent-tree.c +12 -12
@@ -2598,8 +2598,8 @@ static int pin_down_extent(struct btrfs_trans_handle *trans,spin_unlock (&cache->lock);spin_unlock (&cache->space_info->lock); -set_extent_bit (&trans->transaction->pinned_extents, bytenr, - bytenr + num_bytes -1 ,EXTENT_DIRTY ,NULL ); +btrfs_set_extent_bit (&trans->transaction->pinned_extents, bytenr, + bytenr + num_bytes -1 ,EXTENT_DIRTY ,NULL );return 0 ; }
@@ -5065,17 +5065,17 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root,* EXTENT bit to differentiate dirty pages. */ if (buf->log_index ==0 ) -set_extent_bit (&root->dirty_log_pages, buf->start, - buf->start + buf->len -1 , -EXTENT_DIRTY ,NULL ); +btrfs_set_extent_bit (&root->dirty_log_pages, buf->start, + buf->start + buf->len -1 , +EXTENT_DIRTY ,NULL );else -set_extent_bit (&root->dirty_log_pages, buf->start, - buf->start + buf->len -1 , -EXTENT_NEW ,NULL ); +btrfs_set_extent_bit (&root->dirty_log_pages, buf->start, + buf->start + buf->len -1 , +EXTENT_NEW ,NULL ); }else { buf->log_index =-1 ; -set_extent_bit (&trans->transaction->dirty_pages, buf->start, - buf->start + buf->len -1 ,EXTENT_DIRTY ,NULL ); +btrfs_set_extent_bit (&trans->transaction->dirty_pages, buf->start, + buf->start + buf->len -1 ,EXTENT_DIRTY ,NULL ); }/* this returns a buffer locked for blocking */ return buf;
@@ -6430,8 +6430,8 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed) ret =btrfs_issue_discard (device->bdev, start, len, &bytes);if (!ret) -set_extent_bit (&device->alloc_state, start, - start + bytes -1 ,CHUNK_TRIMMED ,NULL ); +btrfs_set_extent_bit (&device->alloc_state, start, + start + bytes -1 ,CHUNK_TRIMMED ,NULL );mutex_unlock (&fs_info->chunk_mutex);if (ret)
fs/btrfs/file-item.c +5 -5
@@ -91,8 +91,8 @@ int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,ASSERT (IS_ALIGNED (start + len, inode->root->fs_info->sectorsize)); -return set_extent_bit (inode->file_extent_tree, start, start + len -1 , -EXTENT_DIRTY ,NULL ); +return btrfs_set_extent_bit (inode->file_extent_tree, start, start + len -1 , +EXTENT_DIRTY ,NULL ); }/*
@@ -430,9 +430,9 @@ blk_status_t btrfs_lookup_bio_sums(struct btrfs_bio *bbio)if (btrfs_root_id (inode->root) ==BTRFS_DATA_RELOC_TREE_OBJECTID ) {u64 file_offset = bbio->file_offset + bio_offset; -set_extent_bit (&inode->io_tree, file_offset, - file_offset + sectorsize -1 , -EXTENT_NODATASUM ,NULL ); +btrfs_set_extent_bit (&inode->io_tree, file_offset, + file_offset + sectorsize -1 , +EXTENT_NODATASUM ,NULL ); }else { btrfs_warn_rl(fs_info, "csum hole found for disk bytenr range [%llu, %llu)",
fs/btrfs/inode.c +7 -7
@@ -2683,9 +2683,9 @@ static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode,if (em_len > search_len) em_len = search_len; - ret =set_extent_bit (&inode->io_tree, search_start, - search_start + em_len -1 , -EXTENT_DELALLOC_NEW , cached_state); + ret =btrfs_set_extent_bit (&inode->io_tree, search_start, + search_start + em_len -1 , +EXTENT_DELALLOC_NEW , cached_state); next: search_start =extent_map_end (em);free_extent_map (em);
@@ -2718,8 +2718,8 @@ int btrfs_set_extent_delalloc(struct btrfs_inode *inode, u64 start, u64 end,return ret; } -return set_extent_bit (&inode->io_tree, start, end, -EXTENT_DELALLOC | extra_bits, cached_state); +return btrfs_set_extent_bit (&inode->io_tree, start, end, +EXTENT_DELALLOC | extra_bits, cached_state); }/* see btrfs_writepage_start_hook for details on why this is required */
@@ -4902,8 +4902,8 @@ int btrfs_truncate_block(struct btrfs_inode *inode, loff_t from, loff_t len,btrfs_unlock_extent (io_tree, block_start, block_end, &cached_state);if (only_release_metadata) -set_extent_bit (&inode->io_tree, block_start, block_end, -EXTENT_NORESERVE ,NULL ); +btrfs_set_extent_bit (&inode->io_tree, block_start, block_end, +EXTENT_NORESERVE ,NULL ); out_unlock:if (ret) {
fs/btrfs/relocation.c +6 -5
@@ -178,8 +178,9 @@ static void mark_block_processed(struct reloc_control *rc, in_range(node->bytenr, rc->block_group->start, rc->block_group->length)) { blocksize = rc->extent_root->fs_info->nodesize; -set_extent_bit (&rc->processed_blocks, node->bytenr, - node->bytenr + blocksize -1 ,EXTENT_DIRTY ,NULL ); +btrfs_set_extent_bit (&rc->processed_blocks, node->bytenr, + node->bytenr + blocksize -1 ,EXTENT_DIRTY , +NULL ); } node->processed =1 ; }
@@ -2929,9 +2930,9 @@ static int relocate_one_folio(struct reloc_control *rc,u64 boundary_end = boundary_start + fs_info->sectorsize -1 ; -set_extent_bit (&BTRFS_I (inode)->io_tree, - boundary_start, boundary_end, -EXTENT_BOUNDARY ,NULL ); +btrfs_set_extent_bit (&BTRFS_I (inode)->io_tree, + boundary_start, boundary_end, +EXTENT_BOUNDARY ,NULL ); }btrfs_unlock_extent (&BTRFS_I (inode)->io_tree, clamped_start, clamped_end, &cached_state);
fs/btrfs/tests/extent-io-tests.c +8 -8
@@ -175,7 +175,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)* |--- delalloc ---| * |--- search ---| */ -set_extent_bit (tmp,0 , sectorsize -1 ,EXTENT_DELALLOC ,NULL ); +btrfs_set_extent_bit (tmp,0 , sectorsize -1 ,EXTENT_DELALLOC ,NULL ); start =0 ; end = start +PAGE_SIZE -1 ; found = find_lock_delalloc_range(inode, page_folio(locked_page), &start,
@@ -206,7 +206,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)test_err ("couldn't find the locked page" ); goto out_bits; } -set_extent_bit (tmp, sectorsize, max_bytes -1 ,EXTENT_DELALLOC ,NULL ); +btrfs_set_extent_bit (tmp, sectorsize, max_bytes -1 ,EXTENT_DELALLOC ,NULL ); start = test_start; end = start +PAGE_SIZE -1 ; found = find_lock_delalloc_range(inode, page_folio(locked_page), &start,
@@ -261,7 +261,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)* * We are re-using our test_start from above since it works out well. */ -set_extent_bit (tmp, max_bytes, total_dirty -1 ,EXTENT_DELALLOC ,NULL ); +btrfs_set_extent_bit (tmp, max_bytes, total_dirty -1 ,EXTENT_DELALLOC ,NULL ); start = test_start; end = start +PAGE_SIZE -1 ; found = find_lock_delalloc_range(inode, page_folio(locked_page), &start,
@@ -577,8 +577,8 @@ static int test_find_first_clear_extent_bit(void)* Set 1M-4M alloc/discard and 32M-64M thus leaving a hole between * 4M-32M */ -set_extent_bit (&tree,SZ_1M ,SZ_4M -1 , -CHUNK_TRIMMED |CHUNK_ALLOCATED ,NULL ); +btrfs_set_extent_bit (&tree,SZ_1M ,SZ_4M -1 , +CHUNK_TRIMMED |CHUNK_ALLOCATED ,NULL );find_first_clear_extent_bit (&tree,SZ_512K , &start, &end,CHUNK_TRIMMED |CHUNK_ALLOCATED );
@@ -590,8 +590,8 @@ static int test_find_first_clear_extent_bit(void) }/* Now add 32M-64M so that we have a hole between 4M-32M */ -set_extent_bit (&tree,SZ_32M ,SZ_64M -1 , -CHUNK_TRIMMED |CHUNK_ALLOCATED ,NULL ); +btrfs_set_extent_bit (&tree,SZ_32M ,SZ_64M -1 , +CHUNK_TRIMMED |CHUNK_ALLOCATED ,NULL );/* * Request first hole starting at 12M, we should get 4M-32M
@@ -622,7 +622,7 @@ static int test_find_first_clear_extent_bit(void)* Set 64M-72M with CHUNK_ALLOC flag, then search for CHUNK_TRIMMED flag * being unset in this range, we should get the entry in range 64M-72M */ -set_extent_bit (&tree,SZ_64M ,SZ_64M +SZ_8M -1 ,CHUNK_ALLOCATED ,NULL ); +btrfs_set_extent_bit (&tree,SZ_64M ,SZ_64M +SZ_8M -1 ,CHUNK_ALLOCATED ,NULL );find_first_clear_extent_bit (&tree,SZ_64M +SZ_1M , &start, &end,CHUNK_TRIMMED );
fs/btrfs/volumes.c +3 -3
@@ -5496,9 +5496,9 @@ static void chunk_map_device_set_bits(struct btrfs_chunk_map *map, unsigned intstruct btrfs_io_stripe *stripe = &map->stripes[i];struct btrfs_device *device = stripe->dev; -set_extent_bit (&device->alloc_state, stripe->physical, - stripe->physical + map->stripe_size -1 , - bits |EXTENT_NOWAIT ,NULL ); +btrfs_set_extent_bit (&device->alloc_state, stripe->physical, + stripe->physical + map->stripe_size -1 , + bits |EXTENT_NOWAIT ,NULL ); } }
Signature · 1 line
2.45.2
PATCH 8/16 btrfs: rename the functions to search for bits in extent ranges
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
So add a 'btrfs_' prefix to their name to make it clear they are from btrfs.
--- fs/btrfs/block-group.c | 6 +++--- fs/btrfs/dev-replace.c | 6 +++--- fs/btrfs/disk-io.c | 13 +++++++------ fs/btrfs/extent-io-tree.c | 14 +++++++------- fs/btrfs/extent-io-tree.h | 14 +++++++------- fs/btrfs/extent-tree.c | 10 +++++----- fs/btrfs/file-item.c | 4 ++-- fs/btrfs/free-space-cache.c | 6 +++--- fs/btrfs/relocation.c | 6 +++--- fs/btrfs/tests/extent-io-tests.c | 24 ++++++++++++------------ fs/btrfs/transaction.c | 8 ++++---- fs/btrfs/volumes.c | 6 +++--- 12 files changed, 59 insertions(+), 58 deletions(-)
fs/btrfs/block-group.c +3 -3
@@ -525,9 +525,9 @@ int btrfs_add_new_free_space(struct btrfs_block_group *block_group, u64 start, *total_added_ret =0 ;while (start < end) { -if (!find_first_extent_bit (&info->excluded_extents, start, - &extent_start, &extent_end, -EXTENT_DIRTY ,NULL )) +if (!btrfs_find_first_extent_bit (&info->excluded_extents, start, + &extent_start, &extent_end, +EXTENT_DIRTY ,NULL ))break ;if (extent_start <= start) {
fs/btrfs/dev-replace.c +3 -3
@@ -794,9 +794,9 @@ static int btrfs_set_target_alloc_state(struct btrfs_device *srcdev,lockdep_assert_held (&srcdev->fs_info->chunk_mutex); -while (find_first_extent_bit (&srcdev->alloc_state, start, - &found_start, &found_end, -CHUNK_ALLOCATED , &cached_state)) { +while (btrfs_find_first_extent_bit (&srcdev->alloc_state, start, + &found_start, &found_end, +CHUNK_ALLOCATED , &cached_state)) { ret =btrfs_set_extent_bit (&tgtdev->alloc_state, found_start, found_end,CHUNK_ALLOCATED ,NULL );if (ret)
fs/btrfs/disk-io.c +7 -6
@@ -4237,8 +4237,9 @@ static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)u64 found_end; found = true; -while (find_first_extent_bit (&trans->dirty_pages, cur, - &found_start, &found_end,EXTENT_DIRTY , &cached)) { +while (btrfs_find_first_extent_bit (&trans->dirty_pages, cur, + &found_start, &found_end, +EXTENT_DIRTY , &cached)) { dirty_bytes += found_end +1 - found_start; cur = found_end +1 ; }
@@ -4691,8 +4692,8 @@ static void btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,u64 start =0 ;u64 end; -while (find_first_extent_bit (dirty_pages, start, &start, &end, - mark,NULL )) { +while (btrfs_find_first_extent_bit (dirty_pages, start, &start, &end, + mark,NULL )) {btrfs_clear_extent_bits (dirty_pages, start, end, mark);while (start <= end) { eb =find_extent_buffer (fs_info, start);
@@ -4726,8 +4727,8 @@ static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,* the same extent range. */ mutex_lock (&fs_info->unused_bg_unpin_mutex); -if (!find_first_extent_bit (unpin,0 , &start, &end, -EXTENT_DIRTY , &cached_state)) { +if (!btrfs_find_first_extent_bit (unpin,0 , &start, &end, +EXTENT_DIRTY , &cached_state)) {mutex_unlock (&fs_info->unused_bg_unpin_mutex);break ; }
fs/btrfs/extent-io-tree.c +7 -7
@@ -869,9 +869,9 @@ static struct extent_state *find_first_extent_bit_state(struct extent_io_tree *t* Return true if we find something, and update @start_ret and @end_ret. * Return false if we found nothing. */ -bool find_first_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits, -struct extent_state **cached_state) +bool btrfs_find_first_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits, +struct extent_state **cached_state) {struct extent_state *state;bool ret = false;
@@ -930,8 +930,8 @@ bool find_first_extent_bit(struct extent_io_tree *tree, u64 start,* then walk down the tree until we find a non-contiguous area. The area * returned will be the full contiguous area with the bits set. */ -int find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits) +int btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits) {struct extent_state *state;int ret =1 ;
@@ -1495,8 +1495,8 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,* spans (last_range_end, end of device]. In this case it's up to the caller to * trim @end_ret to the appropriate size. */ -void find_first_clear_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits) +void btrfs_find_first_clear_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits) {struct extent_state *state;struct extent_state *prev =NULL , *next =NULL ;
fs/btrfs/extent-io-tree.h +7 -7
@@ -214,13 +214,13 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bits, u32 clear_bits, struct extent_state **cached_state); -bool find_first_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits, -struct extent_state **cached_state); -void find_first_clear_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits); -int find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits); +bool btrfs_find_first_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits, +struct extent_state **cached_state); +void btrfs_find_first_clear_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits); +int btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits);bool btrfs_find_delalloc_range (struct extent_io_tree *tree,u64 *start,u64 *end,u64 max_bytes,struct extent_state **cached_state);
fs/btrfs/extent-tree.c +5 -5
@@ -2829,8 +2829,8 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans)struct extent_state *cached_state =NULL ;mutex_lock (&fs_info->unused_bg_unpin_mutex); -if (!find_first_extent_bit (unpin,0 , &start, &end, -EXTENT_DIRTY , &cached_state)) { +if (!btrfs_find_first_extent_bit (unpin,0 , &start, &end, +EXTENT_DIRTY , &cached_state)) {mutex_unlock (&fs_info->unused_bg_unpin_mutex);break ; }
@@ -6391,9 +6391,9 @@ static int btrfs_trim_free_extents(struct btrfs_device *device, u64 *trimmed)if (ret)break ; -find_first_clear_extent_bit (&device->alloc_state, start, - &start, &end, -CHUNK_TRIMMED |CHUNK_ALLOCATED ); +btrfs_find_first_clear_extent_bit (&device->alloc_state, start, + &start, &end, +CHUNK_TRIMMED |CHUNK_ALLOCATED );/* Check if there are any CHUNK_* bits left */ if (start > device->total_bytes) {
fs/btrfs/file-item.c +2 -2
@@ -55,8 +55,8 @@ void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_siz goto out_unlock; } - ret =find_contiguous_extent_bit (inode->file_extent_tree,0 , &start, - &end,EXTENT_DIRTY ); + ret =btrfs_find_contiguous_extent_bit (inode->file_extent_tree,0 , &start, + &end,EXTENT_DIRTY );if (!ret && start ==0 ) i_size =min (i_size, end +1 );else
fs/btrfs/free-space-cache.c +3 -3
@@ -1219,9 +1219,9 @@ static noinline_for_stack int write_pinned_extent_entries( start = block_group->start;while (start < block_group->start + block_group->length) { -if (!find_first_extent_bit (unpin, start, - &extent_start, &extent_end, -EXTENT_DIRTY ,NULL )) +if (!btrfs_find_first_extent_bit (unpin, start, + &extent_start, &extent_end, +EXTENT_DIRTY ,NULL ))return 0 ;/* This pinned extent is out of our range */
fs/btrfs/relocation.c +3 -3
@@ -3433,9 +3433,9 @@ int find_next_extent(struct reloc_control *rc, struct btrfs_path *path, goto next; } - block_found =find_first_extent_bit (&rc->processed_blocks, - key.objectid, &start, &end, -EXTENT_DIRTY ,NULL ); + block_found =btrfs_find_first_extent_bit (&rc->processed_blocks, + key.objectid, &start, &end, +EXTENT_DIRTY ,NULL );if (block_found && start <= key.objectid) {btrfs_release_path (path);
fs/btrfs/tests/extent-io-tests.c +12 -12
@@ -566,7 +566,7 @@ static int test_find_first_clear_extent_bit(void)extent_io_tree_init (NULL , &tree,IO_TREE_SELFTEST );/* Test correct handling of empty tree */ -find_first_clear_extent_bit (&tree,0 , &start, &end,CHUNK_TRIMMED ); +btrfs_find_first_clear_extent_bit (&tree,0 , &start, &end,CHUNK_TRIMMED );if (start !=0 || end !=-1 ) { test_err( "error getting a range from completely empty tree: start %llu end %llu",
@@ -580,8 +580,8 @@ static int test_find_first_clear_extent_bit(void)btrfs_set_extent_bit (&tree,SZ_1M ,SZ_4M -1 ,CHUNK_TRIMMED |CHUNK_ALLOCATED ,NULL ); -find_first_clear_extent_bit (&tree,SZ_512K , &start, &end, -CHUNK_TRIMMED |CHUNK_ALLOCATED ); +btrfs_find_first_clear_extent_bit (&tree,SZ_512K , &start, &end, +CHUNK_TRIMMED |CHUNK_ALLOCATED );if (start !=0 || end !=SZ_1M -1 ) { test_err("error finding beginning range: start %llu end %llu",
@@ -596,8 +596,8 @@ static int test_find_first_clear_extent_bit(void)/* * Request first hole starting at 12M, we should get 4M-32M */ -find_first_clear_extent_bit (&tree,12 *SZ_1M , &start, &end, -CHUNK_TRIMMED |CHUNK_ALLOCATED ); +btrfs_find_first_clear_extent_bit (&tree,12 *SZ_1M , &start, &end, +CHUNK_TRIMMED |CHUNK_ALLOCATED );if (start !=SZ_4M || end !=SZ_32M -1 ) { test_err("error finding trimmed range: start %llu end %llu",
@@ -609,8 +609,8 @@ static int test_find_first_clear_extent_bit(void)* Search in the middle of allocated range, should get the next one * available, which happens to be unallocated -> 4M-32M */ -find_first_clear_extent_bit (&tree,SZ_2M , &start, &end, -CHUNK_TRIMMED |CHUNK_ALLOCATED ); +btrfs_find_first_clear_extent_bit (&tree,SZ_2M , &start, &end, +CHUNK_TRIMMED |CHUNK_ALLOCATED );if (start !=SZ_4M || end !=SZ_32M -1 ) { test_err("error finding next unalloc range: start %llu end %llu",
@@ -623,8 +623,8 @@ static int test_find_first_clear_extent_bit(void)* being unset in this range, we should get the entry in range 64M-72M */ btrfs_set_extent_bit (&tree,SZ_64M ,SZ_64M +SZ_8M -1 ,CHUNK_ALLOCATED ,NULL ); -find_first_clear_extent_bit (&tree,SZ_64M +SZ_1M , &start, &end, -CHUNK_TRIMMED ); +btrfs_find_first_clear_extent_bit (&tree,SZ_64M +SZ_1M , &start, &end, +CHUNK_TRIMMED );if (start !=SZ_64M || end !=SZ_64M +SZ_8M -1 ) { test_err("error finding exact range: start %llu end %llu",
@@ -632,8 +632,8 @@ static int test_find_first_clear_extent_bit(void) goto out; } -find_first_clear_extent_bit (&tree,SZ_64M -SZ_8M , &start, &end, -CHUNK_TRIMMED ); +btrfs_find_first_clear_extent_bit (&tree,SZ_64M -SZ_8M , &start, &end, +CHUNK_TRIMMED );/* * Search in the middle of set range whose immediate neighbour doesn't
@@ -649,7 +649,7 @@ static int test_find_first_clear_extent_bit(void)* Search beyond any known range, shall return after last known range * and end should be -1 */ -find_first_clear_extent_bit (&tree,-1 , &start, &end,CHUNK_TRIMMED ); +btrfs_find_first_clear_extent_bit (&tree,-1 , &start, &end,CHUNK_TRIMMED );if (start !=SZ_64M +SZ_8M || end !=-1 ) { test_err( "error handling beyond end of range search: start %llu end %llu",
fs/btrfs/transaction.c +4 -4
@@ -1128,8 +1128,8 @@ int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info,u64 start =0 ;u64 end; -while (find_first_extent_bit (dirty_pages, start, &start, &end, - mark, &cached_state)) { +while (btrfs_find_first_extent_bit (dirty_pages, start, &start, &end, + mark, &cached_state)) {bool wait_writeback = false; ret = convert_extent_bit(dirty_pages, start, end,
@@ -1181,8 +1181,8 @@ static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info,u64 end;int ret =0 ; -while (find_first_extent_bit (dirty_pages, start, &start, &end, -EXTENT_NEED_WAIT , &cached_state)) { +while (btrfs_find_first_extent_bit (dirty_pages, start, &start, &end, +EXTENT_NEED_WAIT , &cached_state)) {/* * Ignore -ENOMEM errors returned by clear_extent_bit(). * When committing the transaction, we'll remove any entries
fs/btrfs/volumes.c +3 -3
@@ -1600,9 +1600,9 @@ static bool contains_pending_extent(struct btrfs_device *device, u64 *start,lockdep_assert_held (&device->fs_info->chunk_mutex); - if (find_first_extent_bit(&device->alloc_state, *start, - &physical_start, &physical_end, - CHUNK_ALLOCATED, NULL)) { + if (btrfs_find_first_extent_bit(&device->alloc_state, *start, + &physical_start, &physical_end, + CHUNK_ALLOCATED, NULL)) { if (in_range(physical_start, *start, len) || in_range(*start, physical_start,
Signature · 1 line
2.45.2
PATCH 9/16 btrfs: rename the functions to get inode and fs_info from an extent io tree
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
So add a 'btrfs_' prefix to their name to make it clear they are from btrfs. Also remove the 'const' suffix from extent_io_tree_to_inode_const() since there's no non-const variant anymore and makes the naming consistent with extent_io_tree_to_fs_info() (no 'const' suffix and returns a const pointer).
--- fs/btrfs/extent-io-tree.c | 10 +++++----- fs/btrfs/extent-io-tree.h | 4 ++-- include/trace/events/btrfs.h | 12 ++++++------ 3 files changed, 13 insertions(+), 13 deletions(-)
fs/btrfs/extent-io-tree.c +5 -5
@@ -65,7 +65,7 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,if (tree->owner !=IO_TREE_INODE_IO )return ; - inode =extent_io_tree_to_inode_const (tree); + inode =btrfs_extent_io_tree_to_inode (tree); isize =i_size_read (&inode->vfs_inode);if (end >=PAGE_SIZE && (end %2 ) ==0 && end != isize -1 ) { btrfs_debug_rl(inode->root->fs_info,
@@ -81,7 +81,7 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,#endif /* Read-only access to the inode. */ -const struct btrfs_inode *extent_io_tree_to_inode_const (const struct extent_io_tree *tree) +const struct btrfs_inode *btrfs_extent_io_tree_to_inode (const struct extent_io_tree *tree) {if (tree->owner ==IO_TREE_INODE_IO )return tree->inode;
@@ -89,7 +89,7 @@ const struct btrfs_inode *extent_io_tree_to_inode_const(const struct extent_io_t }/* For read-only access to fs_info. */ -const struct btrfs_fs_info *extent_io_tree_to_fs_info (const struct extent_io_tree *tree) +const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info (const struct extent_io_tree *tree) {if (tree->owner ==IO_TREE_INODE_IO )return tree->inode->root->fs_info;
@@ -334,7 +334,7 @@ static void __cold extent_io_tree_panic(const struct extent_io_tree *tree, const char *opname, int err) { - btrfs_panic(extent_io_tree_to_fs_info(tree), err, + btrfs_panic(btrfs_extent_io_tree_to_fs_info(tree), err,"extent io tree error on %s state start %llu end %llu" , opname, state->start, state->end); }
@@ -936,7 +936,7 @@ int btrfs_find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start,struct extent_state *state;int ret =1 ; -ASSERT (!btrfs_fs_incompat (extent_io_tree_to_fs_info (tree),NO_HOLES )); +ASSERT (!btrfs_fs_incompat (btrfs_extent_io_tree_to_fs_info (tree),NO_HOLES ));spin_lock (&tree->lock); state =find_first_extent_bit_state (tree, start, bits);
fs/btrfs/extent-io-tree.h +2 -2
@@ -134,8 +134,8 @@ struct extent_state {#endif }; -const struct btrfs_inode *extent_io_tree_to_inode_const (const struct extent_io_tree *tree); -const struct btrfs_fs_info *extent_io_tree_to_fs_info (const struct extent_io_tree *tree); +const struct btrfs_inode *btrfs_extent_io_tree_to_inode (const struct extent_io_tree *tree); +const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info (const struct extent_io_tree *tree);void extent_io_tree_init (struct btrfs_fs_info *fs_info,struct extent_io_tree *tree,unsigned int owner);
include/trace/events/btrfs.h +6 -6
@@ -2069,8 +2069,8 @@ TRACE_EVENT(btrfs_set_extent_bit,__field ( unsigned, set_bits) ), -TP_fast_assign_btrfs (extent_io_tree_to_fs_info (tree), - const struct btrfs_inode *inode = extent_io_tree_to_inode_const(tree); +TP_fast_assign_btrfs (btrfs_extent_io_tree_to_fs_info (tree), + const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); __entry->owner = tree->owner; __entry->ino = inode ? btrfs_ino(inode) : 0;
@@ -2102,8 +2102,8 @@ TRACE_EVENT(btrfs_clear_extent_bit,__field ( unsigned, clear_bits) ), -TP_fast_assign_btrfs (extent_io_tree_to_fs_info (tree), - const struct btrfs_inode *inode = extent_io_tree_to_inode_const(tree); +TP_fast_assign_btrfs (btrfs_extent_io_tree_to_fs_info (tree), + const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); __entry->owner = tree->owner; __entry->ino = inode ? btrfs_ino(inode) : 0;
@@ -2136,8 +2136,8 @@ TRACE_EVENT(btrfs_convert_extent_bit,__field ( unsigned, clear_bits) ), -TP_fast_assign_btrfs (extent_io_tree_to_fs_info (tree), - const struct btrfs_inode *inode = extent_io_tree_to_inode_const(tree); +TP_fast_assign_btrfs (btrfs_extent_io_tree_to_fs_info (tree), + const struct btrfs_inode *inode = btrfs_extent_io_tree_to_inode(tree); __entry->owner = tree->owner; __entry->ino = inode ? btrfs_ino(inode) : 0;
Signature · 1 line
2.45.2
PATCH 10/16 btrfs: directly grab inode at __btrfs_debug_check_extent_io_range()
In reply to [email protected]From: Filipe Manana <[email protected]>
We've tested that we are dealing with io tree that is associated to an inode (its owner is IO_TREE_INODE_IO), so there's no need to call btrfs_extent_io_tree_to_inode() in a separate line and we just assign tree->inode to the local inode variable when we declare it.
--- fs/btrfs/extent-io-tree.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
fs/btrfs/extent-io-tree.c +1 -2
@@ -59,13 +59,12 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,struct extent_io_tree *tree, u64 start, u64 end) { - const struct btrfs_inode *inode; + const struct btrfs_inode *inode = tree->inode;u64 isize;if (tree->owner !=IO_TREE_INODE_IO )return ; - inode =btrfs_extent_io_tree_to_inode (tree); isize =i_size_read (&inode->vfs_inode);if (end >=PAGE_SIZE && (end %2 ) ==0 && end != isize -1 ) { btrfs_debug_rl(inode->root->fs_info,
Signature · 1 line
2.45.2
PATCH 11/16 btrfs: rename the functions to init and release an extent io tree
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
So add a 'btrfs_' prefix to their name to make it clear they are from btrfs.
--- fs/btrfs/disk-io.c | 16 ++++++++-------- fs/btrfs/extent-io-tree.c | 6 +++--- fs/btrfs/extent-io-tree.h | 6 +++--- fs/btrfs/inode.c | 5 +++-- fs/btrfs/relocation.c | 2 +- fs/btrfs/tests/btrfs-tests.c | 4 ++-- fs/btrfs/tests/extent-io-tests.c | 4 ++-- fs/btrfs/transaction.c | 12 ++++++------ fs/btrfs/tree-log.c | 4 ++-- fs/btrfs/volumes.c | 6 +++--- 10 files changed, 33 insertions(+), 32 deletions(-)
fs/btrfs/disk-io.c +8 -8
@@ -691,10 +691,10 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,btrfs_set_root_last_log_commit (root,0 ); root->anon_dev =0 ;if (!dummy) { -extent_io_tree_init (fs_info, &root->dirty_log_pages, -IO_TREE_ROOT_DIRTY_LOG_PAGES ); -extent_io_tree_init (fs_info, &root->log_csum_range, -IO_TREE_LOG_CSUM_RANGE ); +btrfs_extent_io_tree_init (fs_info, &root->dirty_log_pages, +IO_TREE_ROOT_DIRTY_LOG_PAGES ); +btrfs_extent_io_tree_init (fs_info, &root->log_csum_range, +IO_TREE_LOG_CSUM_RANGE ); }spin_lock_init (&root->root_item_lock);
@@ -1920,8 +1920,8 @@ static int btrfs_init_btree_inode(struct super_block *sb) inode->i_mapping->a_ops = &btree_aops;mapping_set_gfp_mask (inode->i_mapping,GFP_NOFS ); -extent_io_tree_init (fs_info, &BTRFS_I (inode)->io_tree, -IO_TREE_BTREE_INODE_IO ); +btrfs_extent_io_tree_init (fs_info, &BTRFS_I (inode)->io_tree, +IO_TREE_BTREE_INODE_IO );extent_map_tree_init (&BTRFS_I (inode)->extent_tree);BTRFS_I (inode)->root =btrfs_grab_root (fs_info->tree_root);
@@ -2855,8 +2855,8 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)rwlock_init (&fs_info->block_group_cache_lock); fs_info->block_group_cache_tree =RB_ROOT_CACHED ; -extent_io_tree_init (fs_info, &fs_info->excluded_extents, -IO_TREE_FS_EXCLUDED_EXTENTS ); +btrfs_extent_io_tree_init (fs_info, &fs_info->excluded_extents, +IO_TREE_FS_EXCLUDED_EXTENTS );mutex_init (&fs_info->ordered_operations_mutex);mutex_init (&fs_info->tree_log_mutex);
fs/btrfs/extent-io-tree.c +3 -3
@@ -95,8 +95,8 @@ const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info(const struct extent_return tree->fs_info; } -void extent_io_tree_init (struct btrfs_fs_info *fs_info, -struct extent_io_tree *tree,unsigned int owner) +void btrfs_extent_io_tree_init (struct btrfs_fs_info *fs_info, +struct extent_io_tree *tree,unsigned int owner) { tree->state =RB_ROOT ;spin_lock_init (&tree->lock);
@@ -111,7 +111,7 @@ void extent_io_tree_init(struct btrfs_fs_info *fs_info,* aren't any waiters on any extent state record (EXTENT_LOCK_BITS are never * set on any extent state when calling this function). */ -void extent_io_tree_release (struct extent_io_tree *tree) +void btrfs_extent_io_tree_release (struct extent_io_tree *tree) {struct rb_root root;struct extent_state *state;
fs/btrfs/extent-io-tree.h +3 -3
@@ -137,9 +137,9 @@ struct extent_state {const struct btrfs_inode *btrfs_extent_io_tree_to_inode (const struct extent_io_tree *tree);const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info (const struct extent_io_tree *tree); -void extent_io_tree_init (struct btrfs_fs_info *fs_info, -struct extent_io_tree *tree,unsigned int owner); -void extent_io_tree_release (struct extent_io_tree *tree); +void btrfs_extent_io_tree_init (struct btrfs_fs_info *fs_info, +struct extent_io_tree *tree,unsigned int owner); +void btrfs_extent_io_tree_release (struct extent_io_tree *tree);int btrfs_lock_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached); bool btrfs_try_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
fs/btrfs/inode.c +3 -2
@@ -3816,7 +3816,8 @@ static int btrfs_init_file_extent_tree(struct btrfs_inode *inode)if (!inode->file_extent_tree)return -ENOMEM ; -extent_io_tree_init (fs_info, inode->file_extent_tree,IO_TREE_INODE_FILE_EXTENT ); +btrfs_extent_io_tree_init (fs_info, inode->file_extent_tree, +IO_TREE_INODE_FILE_EXTENT );/* Lockdep class is set only for the file extent tree. */ lockdep_set_class (&inode->file_extent_tree->lock, &file_extent_tree_class);
@@ -7742,7 +7743,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)extent_map_tree_init (&ei->extent_tree);/* This io tree sets the valid inode. */ -extent_io_tree_init (fs_info, &ei->io_tree,IO_TREE_INODE_IO ); +btrfs_extent_io_tree_init (fs_info, &ei->io_tree,IO_TREE_INODE_IO ); ei->io_tree.inode = ei; ei->file_extent_tree =NULL ;
fs/btrfs/relocation.c +1 -1
@@ -3860,7 +3860,7 @@ static struct reloc_control *alloc_reloc_control(struct btrfs_fs_info *fs_info)btrfs_backref_init_cache (fs_info, &rc->backref_cache, true); rc->reloc_root_tree.rb_root =RB_ROOT ;spin_lock_init (&rc->reloc_root_tree.lock); -extent_io_tree_init (fs_info, &rc->processed_blocks,IO_TREE_RELOC_BLOCKS ); +btrfs_extent_io_tree_init (fs_info, &rc->processed_blocks,IO_TREE_RELOC_BLOCKS );return rc; }
fs/btrfs/tests/btrfs-tests.c +2 -2
@@ -102,7 +102,7 @@ struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)if (!dev)return ERR_PTR (-ENOMEM ); -extent_io_tree_init (fs_info, &dev->alloc_state,0 ); +btrfs_extent_io_tree_init (fs_info, &dev->alloc_state,0 );INIT_LIST_HEAD (&dev->dev_list);list_add (&dev->dev_list, &fs_info->fs_devices->devices);
@@ -111,7 +111,7 @@ struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)static void btrfs_free_dummy_device (struct btrfs_device *dev) { -extent_io_tree_release (&dev->alloc_state); +btrfs_extent_io_tree_release (&dev->alloc_state);kfree (dev); }
fs/btrfs/tests/extent-io-tests.c +2 -2
@@ -148,7 +148,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)* Passing NULL as we don't have fs_info but tracepoints are not used * at this point */ -extent_io_tree_init (NULL , tmp,IO_TREE_SELFTEST ); +btrfs_extent_io_tree_init (NULL , tmp,IO_TREE_SELFTEST );/* * First go through and create and mark all of our pages dirty, we pin
@@ -563,7 +563,7 @@ static int test_find_first_clear_extent_bit(void)test_msg ("running find_first_clear_extent_bit test" ); -extent_io_tree_init (NULL , &tree,IO_TREE_SELFTEST ); +btrfs_extent_io_tree_init (NULL , &tree,IO_TREE_SELFTEST );/* Test correct handling of empty tree */ btrfs_find_first_clear_extent_bit (&tree,0 , &start, &end,CHUNK_TRIMMED );
fs/btrfs/transaction.c +6 -6
@@ -197,7 +197,7 @@ static noinline void switch_commit_roots(struct btrfs_trans_handle *trans)list_del_init (&root->dirty_list);free_extent_buffer (root->commit_root); root->commit_root =btrfs_root_node (root); -extent_io_tree_release (&root->dirty_log_pages); +btrfs_extent_io_tree_release (&root->dirty_log_pages);btrfs_qgroup_clean_swapped_blocks (root); }
@@ -383,10 +383,10 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,INIT_LIST_HEAD (&cur_trans->deleted_bgs);spin_lock_init (&cur_trans->dropped_roots_lock);list_add_tail (&cur_trans->list, &fs_info->trans_list); -extent_io_tree_init (fs_info, &cur_trans->dirty_pages, -IO_TREE_TRANS_DIRTY_PAGES ); -extent_io_tree_init (fs_info, &cur_trans->pinned_extents, -IO_TREE_FS_PINNED_EXTENTS ); +btrfs_extent_io_tree_init (fs_info, &cur_trans->dirty_pages, +IO_TREE_TRANS_DIRTY_PAGES ); +btrfs_extent_io_tree_init (fs_info, &cur_trans->pinned_extents, +IO_TREE_FS_PINNED_EXTENTS );btrfs_set_fs_generation (fs_info, fs_info->generation +1 ); cur_trans->transid = fs_info->generation; fs_info->running_transaction = cur_trans;
@@ -1265,7 +1265,7 @@ static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans)blk_finish_plug (&plug); ret2 =btrfs_wait_extents (fs_info, dirty_pages); -extent_io_tree_release (&trans->transaction->dirty_pages); +btrfs_extent_io_tree_release (&trans->transaction->dirty_pages);if (ret)return ret;
fs/btrfs/tree-log.c +2 -2
@@ -3251,8 +3251,8 @@ static void free_log_tree(struct btrfs_trans_handle *trans, } } -extent_io_tree_release (&log->dirty_log_pages); -extent_io_tree_release (&log->log_csum_range); +btrfs_extent_io_tree_release (&log->dirty_log_pages); +btrfs_extent_io_tree_release (&log->log_csum_range);btrfs_put_root (log); }
fs/btrfs/volumes.c +3 -3
@@ -404,7 +404,7 @@ static void btrfs_free_device(struct btrfs_device *device) {WARN_ON (!list_empty (&device->post_commit_list));rcu_string_free (device->name); -extent_io_tree_release (&device->alloc_state); +btrfs_extent_io_tree_release (&device->alloc_state);btrfs_destroy_dev_zone_info (device);kfree (device); }
@@ -1225,7 +1225,7 @@ static void btrfs_close_one_device(struct btrfs_device *device) device->fs_info =NULL ;atomic_set (&device->dev_stats_ccnt,0 ); -extent_io_tree_release (&device->alloc_state); +btrfs_extent_io_tree_release (&device->alloc_state);/* * Reset the flush error record. We might have a transient flush error
@@ -6952,7 +6952,7 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,atomic_set (&dev->dev_stats_ccnt,0 );btrfs_device_data_ordered_init (dev); -extent_io_tree_init (fs_info, &dev->alloc_state,IO_TREE_DEVICE_ALLOC_STATE ); +btrfs_extent_io_tree_init (fs_info, &dev->alloc_state,IO_TREE_DEVICE_ALLOC_STATE );if (devid) tmp = *devid;
Signature · 1 line
2.45.2
PATCH 12/16 btrfs: rename the functions to count, test and get bit ranges in io trees
In reply to [email protected]From: Filipe Manana <[email protected]>
These functions are exported so they should have a 'btrfs_' prefix by convention, to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
So add a 'btrfs_' prefix to their names to make it clear they are from btrfs.
--- fs/btrfs/defrag.c | 4 ++-- fs/btrfs/extent-io-tree.c | 18 +++++++++--------- fs/btrfs/extent-io-tree.h | 18 +++++++++--------- fs/btrfs/extent_io.c | 10 +++++----- fs/btrfs/file.c | 8 ++++---- fs/btrfs/inode.c | 13 +++++++------ fs/btrfs/relocation.c | 4 ++-- 7 files changed, 38 insertions(+), 37 deletions(-)
fs/btrfs/defrag.c +2 -2
@@ -1024,8 +1024,8 @@ static int defrag_collect_targets(struct btrfs_inode *inode,* very likely resulting in a larger extent after writeback is * triggered (except in a case of free space fragmentation). */ -if (test_range_bit_exists (&inode->io_tree, cur, cur + range_len -1 , -EXTENT_DELALLOC )) +if (btrfs_test_range_bit_exists (&inode->io_tree, cur, cur + range_len -1 , +EXTENT_DELALLOC )) goto next;/*
fs/btrfs/extent-io-tree.c +9 -9
@@ -1612,10 +1612,10 @@ void btrfs_find_first_clear_extent_bit(struct extent_io_tree *tree, u64 start,* all given bits set. If the returned number of bytes is greater than zero * then @start is updated with the offset of the first byte with the bits set. */ -u64 count_range_bits (struct extent_io_tree *tree, -u64 *start,u64 search_end,u64 max_bytes, -u32 bits,int contig, -struct extent_state **cached_state) +u64 btrfs_count_range_bits (struct extent_io_tree *tree, +u64 *start,u64 search_end,u64 max_bytes, +u32 bits,int contig, +struct extent_state **cached_state) {struct extent_state *state =NULL ;struct extent_state *cached;
@@ -1700,7 +1700,7 @@ u64 count_range_bits(struct extent_io_tree *tree,/* * Check if the single @bit exists in the given range. */ -bool test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit) +bool btrfs_test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit) {struct extent_state *state;bool bitset = false;
@@ -1726,8 +1726,8 @@ bool test_range_bit_exists(struct extent_io_tree *tree, u64 start, u64 end, u32return bitset; } -void get_range_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 *bits, -struct extent_state **cached_state) +void btrfs_get_range_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 *bits, +struct extent_state **cached_state) {struct extent_state *state;
@@ -1763,8 +1763,8 @@ void get_range_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 *bits,/* * Check if the whole range [@start,@end) contains the single @bit set. */ -bool test_range_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bit, -struct extent_state *cached) +bool btrfs_test_range_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bit, +struct extent_state *cached) {struct extent_state *state;bool bitset = true;
fs/btrfs/extent-io-tree.h +9 -9
@@ -160,17 +160,17 @@ static inline bool btrfs_try_lock_extent(struct extent_io_tree *tree, u64 start,int __init extent_state_init_cachep (void );void __cold extent_state_free_cachep (void ); -u64 count_range_bits (struct extent_io_tree *tree, -u64 *start,u64 search_end, -u64 max_bytes,u32 bits,int contig, -struct extent_state **cached_state); +u64 btrfs_count_range_bits (struct extent_io_tree *tree, +u64 *start,u64 search_end, +u64 max_bytes,u32 bits,int contig, +struct extent_state **cached_state);void free_extent_state (struct extent_state *state); -bool test_range_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bit, -struct extent_state *cached_state); -bool test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit); -void get_range_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 *bits, -struct extent_state **cached_state); +bool btrfs_test_range_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bit, +struct extent_state *cached_state); +bool btrfs_test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit); +void btrfs_get_range_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 *bits, +struct extent_state **cached_state);int clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_changeset *changeset); int btrfs_clear_extent_bit_changeset(struct extent_io_tree *tree, u64 start, u64 end,
fs/btrfs/extent_io.c +5 -5
@@ -372,8 +372,8 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,btrfs_lock_extent (tree, delalloc_start, delalloc_end, &cached_state);/* then test to make sure it is all still delalloc */ - ret =test_range_bit (tree, delalloc_start, delalloc_end, -EXTENT_DELALLOC , cached_state); + ret =btrfs_test_range_bit (tree, delalloc_start, delalloc_end, +EXTENT_DELALLOC , cached_state);btrfs_unlock_extent (tree, delalloc_start, delalloc_end, &cached_state);if (!ret) {
@@ -2620,7 +2620,7 @@ static bool try_release_extent_state(struct extent_io_tree *tree,bool ret = false;int ret2; -get_range_bits (tree, start, end, &range_bits, &cached_state); +btrfs_get_range_bits (tree, start, end, &range_bits, &cached_state);/* * We can release the folio if it's locked only for ordered extent
@@ -2680,8 +2680,8 @@ bool try_release_extent_mapping(struct folio *folio, gfp_t mask)free_extent_map (em);break ; } -if (test_range_bit_exists (io_tree, em->start, -extent_map_end (em) -1 ,EXTENT_LOCKED )) +if (btrfs_test_range_bit_exists (io_tree, em->start, +extent_map_end (em) -1 ,EXTENT_LOCKED )) goto next;/* * If it's not in the list of modified extents, used by a fast
fs/btrfs/file.c +4 -4
@@ -3254,10 +3254,10 @@ static bool find_delalloc_subrange(struct btrfs_inode *inode, u64 start, u64 endif (inode->delalloc_bytes >0 ) {spin_unlock (&inode->lock); *delalloc_start_ret = start; - delalloc_len =count_range_bits (&inode->io_tree, - delalloc_start_ret, end, - len,EXTENT_DELALLOC ,1 , - cached_state); + delalloc_len =btrfs_count_range_bits (&inode->io_tree, + delalloc_start_ret, end, + len,EXTENT_DELALLOC ,1 , + cached_state); }else {spin_unlock (&inode->lock); }
fs/btrfs/inode.c +7 -6
@@ -1738,8 +1738,8 @@ static int fallback_to_cow(struct btrfs_inode *inode,* when starting writeback. */ btrfs_lock_extent (io_tree, start, end, &cached_state); - count =count_range_bits (io_tree, &range_start, end, range_bytes, -EXTENT_NORESERVE ,0 ,NULL ); + count =btrfs_count_range_bits (io_tree, &range_start, end, range_bytes, +EXTENT_NORESERVE ,0 ,NULL );if (count >0 || is_space_ino || is_reloc_ino) {u64 bytes = count;struct btrfs_fs_info *fs_info = inode->root->fs_info;
@@ -2310,7 +2310,7 @@ static bool should_nocow(struct btrfs_inode *inode, u64 start, u64 end) {if (inode->flags & (BTRFS_INODE_NODATACOW |BTRFS_INODE_PREALLOC )) {if (inode->defrag_bytes && -test_range_bit_exists (&inode->io_tree, start, end,EXTENT_DEFRAG )) +btrfs_test_range_bit_exists (&inode->io_tree, start, end,EXTENT_DEFRAG ))return false;return true; }
@@ -3378,8 +3378,8 @@ bool btrfs_data_csum_ok(struct btrfs_bio *bbio, struct btrfs_device *dev,return true;if (btrfs_is_data_reloc_root (inode->root) && -test_range_bit (&inode->io_tree, file_offset, end,EXTENT_NODATASUM , -NULL )) { +btrfs_test_range_bit (&inode->io_tree, file_offset, end,EXTENT_NODATASUM , +NULL )) {/* Skip the range without csum for data reloc inode */ btrfs_clear_extent_bits (&inode->io_tree, file_offset, end,EXTENT_NODATASUM );
@@ -7154,7 +7154,8 @@ noinline int can_nocow_extent(struct btrfs_inode *inode, u64 offset, u64 *len, range_end =round_up (offset + nocow_args.file_extent.num_bytes, root->fs_info->sectorsize) -1 ; - ret =test_range_bit_exists (io_tree, offset, range_end,EXTENT_DELALLOC ); + ret =btrfs_test_range_bit_exists (io_tree, offset, range_end, +EXTENT_DELALLOC );if (ret)return -EAGAIN ; }
fs/btrfs/relocation.c +2 -2
@@ -2409,8 +2409,8 @@ static int tree_block_processed(u64 bytenr, struct reloc_control *rc) {u32 blocksize = rc->extent_root->fs_info->nodesize; -if (test_range_bit (&rc->processed_blocks, bytenr, - bytenr + blocksize -1 ,EXTENT_DIRTY ,NULL )) +if (btrfs_test_range_bit (&rc->processed_blocks, bytenr, + bytenr + blocksize -1 ,EXTENT_DIRTY ,NULL ))return 1 ;return 0 ; }
Signature · 1 line
2.45.2
PATCH 13/16 btrfs: rename free_extent_state() to include a btrfs prefix
In reply to [email protected]From: Filipe Manana <[email protected]>
This is an exported function so it should have a 'btrfs_' prefix by convention, to make it clear it's btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
Rename the function to add 'btrfs_' prefix to it.
--- fs/btrfs/dev-replace.c | 2 +- fs/btrfs/disk-io.c | 2 +- fs/btrfs/extent-io-tree.c | 30 +++++++++++++++--------------- fs/btrfs/extent-io-tree.h | 2 +- fs/btrfs/extent-tree.c | 2 +- fs/btrfs/extent_io.c | 6 +++--- fs/btrfs/fiemap.c | 2 +- fs/btrfs/file.c | 6 +++--- fs/btrfs/transaction.c | 4 ++-- 9 files changed, 28 insertions(+), 28 deletions(-)
fs/btrfs/dev-replace.c +1 -1
@@ -804,7 +804,7 @@ static int btrfs_set_target_alloc_state(struct btrfs_device *srcdev, start = found_end +1 ; } -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);return ret; }
fs/btrfs/disk-io.c +1 -1
@@ -4734,7 +4734,7 @@ static void btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info, }btrfs_clear_extent_dirty (unpin, start, end, &cached_state); -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);btrfs_error_unpin_extent_range (fs_info, start, end);mutex_unlock (&fs_info->unused_bg_unpin_mutex);cond_resched ();
fs/btrfs/extent-io-tree.c +15 -15
@@ -130,7 +130,7 @@ void btrfs_extent_io_tree_release(struct extent_io_tree *tree)* (see wait_extent_bit()). */ ASSERT (!waitqueue_active (&state->wq)); -free_extent_state (state); +btrfs_free_extent_state (state);cond_resched_lock (&tree->lock); }/*
@@ -170,7 +170,7 @@ static struct extent_state *alloc_extent_state_atomic(struct extent_state *prealreturn prealloc; } -void free_extent_state (struct extent_state *state) +void btrfs_free_extent_state (struct extent_state *state) {if (!state)return ;
@@ -349,7 +349,7 @@ static void merge_prev_state(struct extent_io_tree *tree, struct extent_state *s state->start = prev->start;rb_erase (&prev->rb_node, &tree->state);RB_CLEAR_NODE (&prev->rb_node); -free_extent_state (prev); +btrfs_free_extent_state (prev); } }
@@ -364,7 +364,7 @@ static void merge_next_state(struct extent_io_tree *tree, struct extent_state *s state->end = next->end;rb_erase (&next->rb_node, &tree->state);RB_CLEAR_NODE (&next->rb_node); -free_extent_state (next); +btrfs_free_extent_state (next); } }
@@ -526,7 +526,7 @@ static int split_state(struct extent_io_tree *tree, struct extent_state *orig, }else if (prealloc->end > entry->end) { node = &(*node)->rb_right; }else { -free_extent_state (prealloc); +btrfs_free_extent_state (prealloc);return -EEXIST ; } }
@@ -566,7 +566,7 @@ static struct extent_state *clear_state_bit(struct extent_io_tree *tree,if (extent_state_in_tree (state)) {rb_erase (&state->rb_node, &tree->state);RB_CLEAR_NODE (&state->rb_node); -free_extent_state (state); +btrfs_free_extent_state (state); }else {WARN_ON (1 ); }
@@ -652,7 +652,7 @@ int btrfs_clear_extent_bit_changeset(struct extent_io_tree *tree, u64 start, u64 goto hit_next; }if (clear) -free_extent_state (cached); +btrfs_free_extent_state (cached); }/* This search will find the extents that end after our range starts. */
@@ -744,7 +744,7 @@ int btrfs_clear_extent_bit_changeset(struct extent_io_tree *tree, u64 start, u64 out:spin_unlock (&tree->lock);if (prealloc) -free_extent_state (prealloc); +btrfs_free_extent_state (prealloc);return 0 ;
@@ -796,7 +796,7 @@ static void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,schedule ();spin_lock (&tree->lock);finish_wait (&state->wq, &wait); -free_extent_state (state); +btrfs_free_extent_state (state); goto again; } start = state->end +1 ;
@@ -814,7 +814,7 @@ static void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,if (cached_state && *cached_state) { state = *cached_state; *cached_state =NULL ; -free_extent_state (state); +btrfs_free_extent_state (state); }spin_unlock (&tree->lock); }
@@ -890,13 +890,13 @@ bool btrfs_find_first_extent_bit(struct extent_io_tree *tree, u64 start,* again. If we haven't found any, clear as well since * it's now useless. */ -free_extent_state (*cached_state); +btrfs_free_extent_state (*cached_state); *cached_state =NULL ;if (state) goto got_it; goto out; } -free_extent_state (*cached_state); +btrfs_free_extent_state (*cached_state); *cached_state =NULL ; }
@@ -1249,7 +1249,7 @@ static int __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, out:spin_unlock (&tree->lock);if (prealloc) -free_extent_state (prealloc); +btrfs_free_extent_state (prealloc);return ret;
@@ -1474,7 +1474,7 @@ int convert_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, out:spin_unlock (&tree->lock);if (prealloc) -free_extent_state (prealloc); +btrfs_free_extent_state (prealloc);return ret; }
@@ -1686,7 +1686,7 @@ u64 btrfs_count_range_bits(struct extent_io_tree *tree, }if (cached_state) { -free_extent_state (*cached_state); +btrfs_free_extent_state (*cached_state); *cached_state = state;if (state)refcount_inc (&state->refs);
fs/btrfs/extent-io-tree.h +1 -1
@@ -165,7 +165,7 @@ u64 btrfs_count_range_bits(struct extent_io_tree *tree, u64 max_bytes, u32 bits, int contig, struct extent_state **cached_state); -void free_extent_state (struct extent_state *state); +void btrfs_free_extent_state (struct extent_state *state);bool btrfs_test_range_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bit,struct extent_state *cached_state);bool btrfs_test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit);
fs/btrfs/extent-tree.c +1 -1
@@ -2843,7 +2843,7 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans) ret =unpin_extent_range (fs_info, start, end, true);BUG_ON (ret);mutex_unlock (&fs_info->unused_bg_unpin_mutex); -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);cond_resched (); }
fs/btrfs/extent_io.c +3 -3
@@ -330,7 +330,7 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,/* @delalloc_end can be -1, never go beyond @orig_end */ *end =min (delalloc_end, orig_end); -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);return false; }
@@ -356,7 +356,7 @@ noinline_for_stack bool find_lock_delalloc_range(struct inode *inode,/* some of the folios are gone, lets avoid looping by * shortening the size of the delalloc range we're searching */ -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state); cached_state =NULL ;if (!loops) { max_bytes =PAGE_SIZE ;
@@ -2646,7 +2646,7 @@ static bool try_release_extent_state(struct extent_io_tree *tree,if (ret2 ==0 ) ret = true; out: -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);return ret; }
fs/btrfs/fiemap.c +1 -1
@@ -871,7 +871,7 @@ static int extent_fiemap(struct btrfs_inode *inode, ret =emit_last_fiemap_cache (fieinfo, &cache); out: -free_extent_state (delalloc_cached_state); +btrfs_free_extent_state (delalloc_cached_state);kfree (cache.entries);btrfs_free_backref_share_ctx (backref_ctx);return ret;
fs/btrfs/file.c +3 -3
@@ -1290,7 +1290,7 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,btrfs_unlock_extent (&inode->io_tree, lockstart, lockend, &cached_state); else -free_extent_state (cached_state ); +btrfs_free_extent_state (cached_state );btrfs_delalloc_release_extents (inode, reserved_len);release_space (inode, *data_reserved, reserved_start, reserved_len, only_release_metadata);
@@ -1319,7 +1319,7 @@ static int copy_one_range(struct btrfs_inode *inode, struct iov_iter *iter,if (extents_locked)btrfs_unlock_extent (&inode->io_tree, lockstart, lockend, &cached_state);else -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);btrfs_delalloc_release_extents (inode, reserved_len);if (ret) {
@@ -1471,7 +1471,7 @@ int btrfs_release_file(struct inode *inode, struct file *filp)if (private) {kfree (private->filldir_buf); -free_extent_state (private->llseek_cached_state); +btrfs_free_extent_state (private->llseek_cached_state);kfree (private); filp->private_data =NULL ; }
fs/btrfs/transaction.c +2 -2
@@ -1156,7 +1156,7 @@ int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, ret =filemap_fdatawrite_range (mapping, start, end);if (!ret && wait_writeback) ret =filemap_fdatawait_range (mapping, start, end); -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);if (ret)break ; cached_state =NULL ;
@@ -1197,7 +1197,7 @@ static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, ret =0 ;if (!ret) ret =filemap_fdatawait_range (mapping, start, end); -free_extent_state (cached_state); +btrfs_free_extent_state (cached_state);if (ret)break ; cached_state =NULL ;
Signature · 1 line
2.45.2
PATCH 14/16 btrfs: rename remaining exported functions from extent-io-tree.h
In reply to [email protected]From: Filipe Manana <[email protected]>
Rename the remaning exported functions that don't have a 'btrfs_' prefix. By convention exported functions should have such prefix to make it clear they are btrfs specific and to avoid collisions with functions from elsewhere in the kernel.
--- fs/btrfs/extent-io-tree.c | 18 +++++++++--------- fs/btrfs/extent-io-tree.h | 18 +++++++++--------- fs/btrfs/qgroup.c | 26 ++++++++++++++------------ fs/btrfs/super.c | 4 ++-- fs/btrfs/transaction.c | 6 +++--- 5 files changed, 37 insertions(+), 35 deletions(-)
fs/btrfs/extent-io-tree.c +9 -9
@@ -1280,9 +1280,9 @@ int btrfs_set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,* * All allocations are done with GFP_NOFS. */ -int convert_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,u32 clear_bits, -struct extent_state **cached_state) +int btrfs_convert_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,u32 clear_bits, +struct extent_state **cached_state) {struct extent_state *state;struct extent_state *prealloc =NULL ;
@@ -1805,8 +1805,8 @@ bool btrfs_test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 b }/* Wrappers around set/clear extent bit */ -int set_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_changeset *changeset) +int btrfs_set_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_changeset *changeset) {/* * We don't support EXTENT_LOCK_BITS yet, as current changeset will
@@ -1818,8 +1818,8 @@ int set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,return __set_extent_bit (tree, start, end, bits,NULL ,NULL ,NULL , changeset); } -int clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_changeset *changeset) +int btrfs_clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_changeset *changeset) {/* * Don't support EXTENT_LOCK_BITS case, same reason as
@@ -1873,13 +1873,13 @@ int btrfs_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32return err; } -void __cold extent_state_free_cachep (void ) +void __cold btrfs_extent_state_free_cachep (void ) {btrfs_extent_state_leak_debug_check ();kmem_cache_destroy (extent_state_cache); } -int __init extent_state_init_cachep (void ) +int __init btrfs_extent_state_init_cachep (void ) { extent_state_cache = kmem_cache_create("btrfs_extent_state", sizeof(struct extent_state), 0, 0,
fs/btrfs/extent-io-tree.h +9 -9
@@ -157,8 +157,8 @@ static inline bool btrfs_try_lock_extent(struct extent_io_tree *tree, u64 start,return btrfs_try_lock_extent_bits (tree, start, end,EXTENT_LOCKED , cached); } -int __init extent_state_init_cachep (void ); -void __cold extent_state_free_cachep (void ); +int __init btrfs_extent_state_init_cachep (void ); +void __cold btrfs_extent_state_free_cachep (void ); u64 btrfs_count_range_bits(struct extent_io_tree *tree, u64 *start, u64 search_end,
@@ -171,8 +171,8 @@ bool btrfs_test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, u32 bbool btrfs_test_range_bit_exists (struct extent_io_tree *tree,u64 start,u64 end,u32 bit);void btrfs_get_range_bits (struct extent_io_tree *tree,u64 start,u64 end,u32 *bits,struct extent_state **cached_state); -int clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_changeset *changeset); +int btrfs_clear_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_changeset *changeset);int btrfs_clear_extent_bit_changeset (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached,struct extent_changeset *changeset);
@@ -197,8 +197,8 @@ static inline int btrfs_clear_extent_bits(struct extent_io_tree *tree, u64 startreturn btrfs_clear_extent_bit (tree, start, end, bits,NULL ); } -int set_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,struct extent_changeset *changeset); +int btrfs_set_record_extent_bits (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,struct extent_changeset *changeset);int btrfs_set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached_state);
@@ -210,9 +210,9 @@ static inline int btrfs_clear_extent_dirty(struct extent_io_tree *tree, u64 star EXTENT_DO_ACCOUNTING, cached); } -int convert_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,u32 clear_bits, -struct extent_state **cached_state); +int btrfs_convert_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,u32 clear_bits, +struct extent_state **cached_state); bool btrfs_find_first_extent_bit(struct extent_io_tree *tree, u64 start, u64 *start_ret, u64 *end_ret, u32 bits,
fs/btrfs/qgroup.c +14 -12
@@ -4232,8 +4232,9 @@ static int qgroup_reserve_data(struct btrfs_inode *inode, reserved = *reserved_ret;/* Record already reserved space */ orig_reserved = reserved->bytes_changed; - ret =set_record_extent_bits (&inode->io_tree, start, - start + len -1 ,EXTENT_QGROUP_RESERVED , reserved); + ret =btrfs_set_record_extent_bits (&inode->io_tree, start, + start + len -1 ,EXTENT_QGROUP_RESERVED , + reserved);/* Newly reserved space */ to_reserve = reserved->bytes_changed - orig_reserved;
@@ -4326,9 +4327,10 @@ static int qgroup_free_reserved_data(struct btrfs_inode *inode,* EXTENT_QGROUP_RESERVED, we won't double free. * So not need to rush. */ - ret =clear_record_extent_bits (&inode->io_tree, free_start, - free_start + free_len -1 , -EXTENT_QGROUP_RESERVED , &changeset); + ret =btrfs_clear_record_extent_bits (&inode->io_tree, free_start, + free_start + free_len -1 , +EXTENT_QGROUP_RESERVED , + &changeset);if (ret <0 ) goto out; freed += changeset.bytes_changed;
@@ -4352,9 +4354,9 @@ static int __btrfs_qgroup_release_data(struct btrfs_inode *inode,int ret;if (btrfs_qgroup_mode (inode->root->fs_info) ==BTRFS_QGROUP_MODE_DISABLED ) { -return clear_record_extent_bits (&inode->io_tree, start, - start + len -1 , -EXTENT_QGROUP_RESERVED ,NULL ); +return btrfs_clear_record_extent_bits (&inode->io_tree, start, + start + len -1 , +EXTENT_QGROUP_RESERVED ,NULL ); }/* In release case, we shouldn't have @reserved */
@@ -4362,8 +4364,8 @@ static int __btrfs_qgroup_release_data(struct btrfs_inode *inode,if (free && reserved)return qgroup_free_reserved_data (inode, reserved, start, len, released);extent_changeset_init (&changeset); - ret =clear_record_extent_bits (&inode->io_tree, start, start + len -1 , -EXTENT_QGROUP_RESERVED , &changeset); + ret =btrfs_clear_record_extent_bits (&inode->io_tree, start, start + len -1 , +EXTENT_QGROUP_RESERVED , &changeset);if (ret <0 ) goto out;
@@ -4611,8 +4613,8 @@ void btrfs_qgroup_check_reserved_leak(struct btrfs_inode *inode)int ret;extent_changeset_init (&changeset); - ret =clear_record_extent_bits (&inode->io_tree,0 , (u64)-1 , -EXTENT_QGROUP_RESERVED , &changeset); + ret =btrfs_clear_record_extent_bits (&inode->io_tree,0 , (u64)-1 , +EXTENT_QGROUP_RESERVED , &changeset);WARN_ON (ret <0 );if (WARN_ON (changeset.bytes_changed)) {
fs/btrfs/super.c +2 -2
@@ -2525,8 +2525,8 @@ static const struct init_sequence mod_init_seq[] = { .init_func = btrfs_free_space_init, .exit_func = btrfs_free_space_exit, }, { - .init_func = extent_state_init_cachep, - .exit_func = extent_state_free_cachep, + .init_func = btrfs_extent_state_init_cachep, + .exit_func = btrfs_extent_state_free_cachep, }, { .init_func = extent_buffer_init_cachep, .exit_func = extent_buffer_free_cachep,
fs/btrfs/transaction.c +3 -3
@@ -1132,9 +1132,9 @@ int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, mark, &cached_state)) {bool wait_writeback = false; - ret =convert_extent_bit (dirty_pages, start, end, -EXTENT_NEED_WAIT , - mark, &cached_state); + ret =btrfs_convert_extent_bit (dirty_pages, start, end, +EXTENT_NEED_WAIT , + mark, &cached_state);/* * convert_extent_bit can return -ENOMEM, which is most of the * time a temporary error. So when it happens, ignore the error
Signature · 1 line
2.45.2
PATCH 15/16 btrfs: remove double underscore prefix from __set_extent_bit()
In reply to [email protected]From: Filipe Manana <[email protected]>
Now that set_extent_bit() was renamed to btrfs_set_extent_bit(), there's no need to have a __set_extent_bit() function, we can just remove the double underscore prefix, which we try to avoid according to the coding style conventions.
--- fs/btrfs/extent-io-tree.c | 28 +++++++++++++--------------- 1 file changed, 13 insertions(+), 15 deletions(-)
fs/btrfs/extent-io-tree.c +13 -15
@@ -1022,11 +1022,11 @@ bool btrfs_find_delalloc_range(struct extent_io_tree *tree, u64 *start,* * [start, end] is inclusive This takes the tree lock. */ -static int __set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, -u32 bits,u64 *failed_start, -struct extent_state **failed_state, -struct extent_state **cached_state, -struct extent_changeset *changeset) +static int set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end, +u32 bits,u64 *failed_start, +struct extent_state **failed_state, +struct extent_state **cached_state, +struct extent_changeset *changeset) {struct extent_state *state;struct extent_state *prealloc =NULL ;
@@ -1258,8 +1258,7 @@ static int __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end,int btrfs_set_extent_bit (struct extent_io_tree *tree,u64 start,u64 end,u32 bits,struct extent_state **cached_state) { -return __set_extent_bit (tree, start, end, bits,NULL ,NULL , - cached_state,NULL ); +return set_extent_bit (tree, start, end, bits,NULL ,NULL , cached_state,NULL ); }/*
@@ -1815,7 +1814,7 @@ int btrfs_set_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end*/ ASSERT (!(bits &EXTENT_LOCK_BITS )); -return __set_extent_bit (tree, start, end, bits,NULL ,NULL ,NULL , changeset); +return set_extent_bit (tree, start, end, bits,NULL ,NULL ,NULL , changeset); } int btrfs_clear_record_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,
@@ -1836,8 +1835,8 @@ bool btrfs_try_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,int err;u64 failed_start; - err =__set_extent_bit (tree, start, end, bits, &failed_start, -NULL , cached,NULL ); + err =set_extent_bit (tree, start, end, bits, &failed_start,NULL , + cached,NULL );if (err == -EEXIST ) {if (failed_start > start) btrfs_clear_extent_bit(tree, start, failed_start - 1,
@@ -1858,17 +1857,16 @@ int btrfs_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32int err;u64 failed_start; - err =__set_extent_bit (tree, start, end, bits, &failed_start, - &failed_state, cached_state,NULL ); + err =set_extent_bit (tree, start, end, bits, &failed_start, + &failed_state, cached_state,NULL );while (err == -EEXIST ) {if (failed_start != start)btrfs_clear_extent_bit (tree, start, failed_start -1 , bits, cached_state);wait_extent_bit (tree, failed_start, end, bits, &failed_state); - err =__set_extent_bit (tree, start, end, bits, - &failed_start, &failed_state, - cached_state,NULL ); + err =set_extent_bit (tree, start, end, bits, &failed_start, + &failed_state, cached_state,NULL ); }return err; }
Signature · 1 line
2.45.2
PATCH 16/16 btrfs: make btrfs_find_contiguous_extent_bit() return bool instead of int
In reply to [email protected]From: Filipe Manana <[email protected]>
The function needs only to return true or false, so there's no need to return an integer. Currently it returns 0 when a range with the given bits is set and 1 when not found, which is a bit counter intuitive too. So change the function to return a bool instead, returning true when a range is found and false otherwise. Update the function's documentation to mention the return value too.
--- fs/btrfs/extent-io-tree.c | 11 +++++++---- fs/btrfs/extent-io-tree.h | 4 ++-- fs/btrfs/file-item.c | 8 ++++---- 3 files changed, 13 insertions(+), 10 deletions(-)
fs/btrfs/extent-io-tree.c +7 -4
@@ -928,12 +928,15 @@ bool btrfs_find_first_extent_bit(struct extent_io_tree *tree, u64 start,* contiguous area for given bits. We will search to the first bit we find, and * then walk down the tree until we find a non-contiguous area. The area * returned will be the full contiguous area with the bits set. +* +* Returns true if we found a range with the given bits set, in which case +* @start_ret and @end_ret are updated, or false if no range was found. */ -int btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits) +bool btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits) {struct extent_state *state; -int ret =1 ; +bool ret = false;ASSERT (!btrfs_fs_incompat (btrfs_extent_io_tree_to_fs_info (tree),NO_HOLES ));
@@ -947,7 +950,7 @@ int btrfs_find_contiguous_extent_bit(struct extent_io_tree *tree, u64 start,break ; *end_ret = state->end; } - ret =0 ; + ret = true; }spin_unlock (&tree->lock);return ret;
fs/btrfs/extent-io-tree.h +2 -2
@@ -219,8 +219,8 @@ bool btrfs_find_first_extent_bit(struct extent_io_tree *tree, u64 start, struct extent_state **cached_state);void btrfs_find_first_clear_extent_bit (struct extent_io_tree *tree,u64 start,u64 *start_ret,u64 *end_ret,u32 bits); -int btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, -u64 *start_ret,u64 *end_ret,u32 bits); +bool btrfs_find_contiguous_extent_bit (struct extent_io_tree *tree,u64 start, +u64 *start_ret,u64 *end_ret,u32 bits);bool btrfs_find_delalloc_range (struct extent_io_tree *tree,u64 *start,u64 *end,u64 max_bytes,struct extent_state **cached_state);
fs/btrfs/file-item.c +4 -4
@@ -46,7 +46,7 @@void btrfs_inode_safe_disk_i_size_write (struct btrfs_inode *inode,u64 new_i_size) {u64 start, end, i_size; -int ret; +bool found;spin_lock (&inode->lock); i_size = new_i_size ?:i_size_read (&inode->vfs_inode);
@@ -55,9 +55,9 @@ void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_siz goto out_unlock; } - ret =btrfs_find_contiguous_extent_bit (inode->file_extent_tree,0 , &start, - &end,EXTENT_DIRTY ); -if (!ret && start ==0 ) + found =btrfs_find_contiguous_extent_bit (inode->file_extent_tree,0 , &start, + &end,EXTENT_DIRTY ); +if (found && start ==0 ) i_size =min (i_size, end +1 );else i_size =0 ;
Signature · 1 line
2.45.2
Quoted 26 lines · On Mon, Apr 07, 2025 at 06:36:07PM +0100, [email protected] wrote:
From: Filipe Manana <[email protected]>
These are mostly to rename exported functions so that they have a '
btrfs_' prefix and follow coding style, to avoid potential clashes in the future with other kernel functions defined elsewhere outside btrfs. As more functions are added toextent-io-tree.h, there's a tendency to follow the existing style and not add a 'btrfs_' prefix for consistency with the other function names, so as time passes we get more exported functions that don't follow the coding style by missing a 'btrfs_' prefix. I'm in the process of adding another new exported function toextent-io-tree.hand found my self unconfortable adding a 'btrfs_' prefix to it while the other exported functions don't have one.I tried to split the rename into several and more reasonably sized patches to make it easier to review and also because a few do a bit more than simply renaming, but with notes in the change logs.
Filipe Manana (16):
btrfs: removeextent_io_tree_to_inode()andis_inode_io_tree()
btrfs: add btrfs prefix to trace events for extent state alloc and free
btrfs: add btrfs prefix to main lock, try lock and unlock extent functions
btrfs: add btrfs prefix to dio lock and unlock extent functions
btrfs: rename__lock_extent()and__try_lock_extent()
btrfs: rename the functions to clear bits for an extent range
btrfs: renameset_extent_bit()to include a btrfs prefix
btrfs: rename the functions to search for bits in extent ranges
Quoted 8 lines
btrfs: rename the functions to get inode and
fs_infofrom an extent io tree
btrfs: directly grab inode at__btrfs_debug_check_extent_io_range()
btrfs: rename the functions to init and release an extent io tree
btrfs: rename the functions to count, test and get bit ranges in io trees
btrfs: renamefree_extent_state()to include a btrfs prefix
btrfs: rename remaining exported functions fromextent-io-tree.h
btrfs: remove double underscore prefix from__set_extent_bit()
btrfs: makebtrfs_find_contiguous_extent_bit()return bool instead of int
Fairbly big number of changes so stable backports may not apply cleanly, but it's a change that should have been done long time ago.
Looks good,