btrfs: rename the functions to clear bits for an extent range

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.

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/block-group.c b/fs/btrfs/block-group.c
index 3eba00da9fc7a5a5e73a382d391c926514099171..a5c587cf42a739d92bb4ab68fda2023ee686e751 100644 (file)
--- a/fs/btrfs/block-group.c
+++ b/fs/btrfs/block-group.c
@@ -832,8 +832,8 @@ out:
 
 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)

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index 3e2e462365d6ff0565273f1515bae62fb51ca660..ee00250776bb311fe772b15c3e63dac23da4e8ad 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -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);
 

diff --git a/fs/btrfs/direct-io.c b/fs/btrfs/direct-io.c
index 0b421a6a21820d1c4f753c3248138d8d7ad605d9..ddfa867ff1e5fa0c4172564386454bef53091a00 100644 (file)
--- a/fs/btrfs/direct-io.c
+++ b/fs/btrfs/direct-io.c
@@ -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 @@ unlock_err:
         * 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),

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 04d9805501b685146ba2a5de65bb648e7d2dba31..cd99fab7af7a8d735e6570ae9df3bd5237eeeba1 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -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);

diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c
index dad092a1f81c7eb5aad8fc622d042d5fde4be9bb..50b4d0b294688865d02f1cde93f2787b6b13ce47 100644 (file)
--- a/fs/btrfs/extent-io-tree.c
+++ b/fs/btrfs/extent-io-tree.c
@@ -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,

diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h
index 518caf666bb08db1954c83cade8d0c450a2361c2..6c2148ed0bb65f9f3a66a1221f3ea6ade61e227d 100644 (file)
--- a/fs/btrfs/extent-io-tree.h
+++ b/fs/btrfs/extent-io-tree.h
@@ -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 st
 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);
+       return btrfs_clear_extent_bit_changeset(tree, start, end, EXTENT_DIO_LOCKED,
+                                               cached, NULL);
 }
 
 #endif /* BTRFS_EXTENT_IO_TREE_H */

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 47db37b7236d38673d4d06dc131262e7f6dbc673..841f538a940ea8408cab2e6e7f6f1e8331b80826 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -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);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 31cf2189a2243712783c391ae2679cddf722a5e1..179ff6ae9dd6daf825e24c507ef8e08a778cdcb0 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -395,7 +395,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);
@@ -2636,7 +2636,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.

diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index c191be6bcefbd21ac1ce9a2617a013a9f7bd0a2b..aa840ba9463468c26db704a5fe515ac30ff6872a 100644 (file)
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -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)

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 0baee2bb110b3ebe90f76d83345388e2c864633c..3a56fc25866154ef1706035d7dd82379a5496d32 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -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);
@@ -1935,9 +1935,9 @@ again:
         * 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);

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 30263f15bdcadecdfad4e517e6e22b0a67a691a0..ba3c8ba26c434690abbbd4ead08d750edf7ff2c4 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -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;
 }

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index d5f2aaff58a75c996bc827355afc62a9bd88629e..6fd904ee67ab468397d36931035237aea90bad70 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1757,7 +1757,7 @@ static int fallback_to_cow(struct btrfs_inode *inode,
                spin_unlock(&sinfo->lock);
 
                if (count > 0)
-                       clear_extent_bits(io_tree, start, end, EXTENT_NORESERVE);
+                       btrfs_clear_extent_bits(io_tree, start, end, EXTENT_NORESERVE);
        }
        btrfs_unlock_extent(io_tree, start, end, &cached_state);
 
@@ -3213,9 +3213,9 @@ int btrfs_finish_one_ordered(struct btrfs_ordered_extent *ordered_extent)
         */
        if ((clear_bits & EXTENT_DELALLOC_NEW) &&
            !test_bit(BTRFS_ORDERED_TRUNCATED, &ordered_extent->flags))
-               clear_extent_bit(&inode->io_tree, start, end,
-                                EXTENT_DELALLOC_NEW | EXTENT_ADD_INODE_BYTES,
-                                &cached_state);
+               btrfs_clear_extent_bit(&inode->io_tree, start, end,
+                                      EXTENT_DELALLOC_NEW | EXTENT_ADD_INODE_BYTES,
+                                      &cached_state);
 
        btrfs_inode_safe_disk_i_size_write(inode, 0);
        ret = btrfs_update_inode_fallback(trans, inode);
@@ -3224,8 +3224,8 @@ int btrfs_finish_one_ordered(struct btrfs_ordered_extent *ordered_extent)
                goto out;
        }
 out:
-       clear_extent_bit(&inode->io_tree, start, end, clear_bits,
-                        &cached_state);
+       btrfs_clear_extent_bit(&inode->io_tree, start, end, clear_bits,
+                              &cached_state);
 
        if (trans)
                btrfs_end_transaction(trans);
@@ -3380,8 +3380,8 @@ bool btrfs_data_csum_ok(struct btrfs_bio *bbio, struct btrfs_device *dev,
            test_range_bit(&inode->io_tree, file_offset, end, EXTENT_NODATASUM,
                           NULL)) {
                /* Skip the range without csum for data reloc inode */
-               clear_extent_bits(&inode->io_tree, file_offset, end,
-                                 EXTENT_NODATASUM);
+               btrfs_clear_extent_bits(&inode->io_tree, file_offset, end,
+                                       EXTENT_NODATASUM);
                return true;
        }
 
@@ -4872,9 +4872,9 @@ again:
                goto again;
        }
 
-       clear_extent_bit(&inode->io_tree, block_start, block_end,
-                        EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
-                        &cached_state);
+       btrfs_clear_extent_bit(&inode->io_tree, block_start, block_end,
+                              EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING | EXTENT_DEFRAG,
+                              &cached_state);
 
        ret = btrfs_set_extent_delalloc(inode, block_start, block_end, 0,
                                        &cached_state);
@@ -5258,9 +5258,9 @@ static void evict_inode_truncate_pages(struct inode *inode)
                        btrfs_qgroup_free_data(BTRFS_I(inode), NULL, start,
                                               end - start + 1, NULL);
 
-               clear_extent_bit(io_tree, start, end,
-                                EXTENT_CLEAR_ALL_BITS | EXTENT_DO_ACCOUNTING,
-                                &cached_state);
+               btrfs_clear_extent_bit(io_tree, start, end,
+                                      EXTENT_CLEAR_ALL_BITS | EXTENT_DO_ACCOUNTING,
+                                      &cached_state);
 
                cond_resched();
                spin_lock(&io_tree->lock);
@@ -7416,10 +7416,10 @@ static void btrfs_invalidate_folio(struct folio *folio, size_t offset,
                 * btrfs_finish_ordered_io().
                 */
                if (!inode_evicting)
-                       clear_extent_bit(tree, cur, range_end,
-                                        EXTENT_DELALLOC |
-                                        EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
-                                        EXTENT_DEFRAG, &cached_state);
+                       btrfs_clear_extent_bit(tree, cur, range_end,
+                                              EXTENT_DELALLOC |
+                                              EXTENT_LOCKED | EXTENT_DO_ACCOUNTING |
+                                              EXTENT_DEFRAG, &cached_state);
 
                spin_lock_irq(&inode->ordered_tree_lock);
                set_bit(BTRFS_ORDERED_TRUNCATED, &ordered->flags);
@@ -7462,9 +7462,10 @@ next:
                 */
                btrfs_qgroup_free_data(inode, NULL, cur, range_end + 1 - cur, NULL);
                if (!inode_evicting)
-                       clear_extent_bit(tree, cur, range_end, EXTENT_LOCKED |
-                                        EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
-                                        EXTENT_DEFRAG | extra_flags, &cached_state);
+                       btrfs_clear_extent_bit(tree, cur, range_end, EXTENT_LOCKED |
+                                              EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING |
+                                              EXTENT_DEFRAG | extra_flags,
+                                              &cached_state);
                cur = range_end + 1;
        }
        /*

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index d6fa36674270f78cf16e0af6db666d5a0693ff3a..a982fd64b814402390d12a2636c151f8c809854c 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -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;
 

diff --git a/fs/btrfs/reflink.c b/fs/btrfs/reflink.c
index e6c0a10c4c67bc081d7f29b1b0ff9343768cd3d5..42c268dba11deeb0f022aa0f3f33d6112801cce6 100644 (file)
--- a/fs/btrfs/reflink.c
+++ b/fs/btrfs/reflink.c
@@ -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;

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 4ac2e63cbe55706c212fbb7e1f5b2ef5105a34e7..c46b6386b5fe58ebc576db2ae87e35f9c7b2f95c 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2904,10 +2904,10 @@ again:
                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 @@ restart:
        }
 
        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);

diff --git a/fs/btrfs/tests/extent-io-tests.c b/fs/btrfs/tests/extent-io-tests.c
index 98c6e237d648026e99df28d1d8145f578d68e534..f715987c6f58f46b2ab0ca98d8f57c55a21fe44a 100644 (file)
--- a/fs/btrfs/tests/extent-io-tests.c
+++ b/fs/btrfs/tests/extent-io-tests.c
@@ -326,7 +326,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);
@@ -662,7 +662,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;
 }

diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
index 09ba6e279d245bb2a6c1a02daca8f51dfedec476..37b285896af07b438f922f6f983423b850152d0c 100644 (file)
--- a/fs/btrfs/tests/inode-tests.c
+++ b/fs/btrfs/tests/inode-tests.c
@@ -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);

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index f26a394a9ec5f0d568551c707974a7d8f413eb3b..3d272c140303ecb20e66024aeddba89da25ff9c4 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -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)

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index bc079b2f15d99cf4af971386b842719446b472b5..99856569abc9a3924fea2c25acf09d16a80349d9 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4999,8 +4999,8 @@ again:
 
        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))
@@ -5419,9 +5419,9 @@ static void chunk_map_device_clear_bits(struct btrfs_chunk_map *map, unsigned in
                struct 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);
        }
 }