btrfs: rename remaining exported extent map functions

Rename all the exported functions from extent_map.h that don't have a
'btrfs_' prefix in their names, so that they are consistent with all the
other functions, to make it clear they are btrfs specific functions and
to avoid potential name collisions in the future with functions defined
elsewhere in the kernel.

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/compression.c b/fs/btrfs/compression.c
index 00cda793cec5ff6270193c8180bd543a7e311f39..d0ed078e533467937d9a4416312cb44c2fbf45b6 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -501,7 +501,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                page_end = (pg_index << PAGE_SHIFT) + folio_size(folio) - 1;
                btrfs_lock_extent(tree, cur, page_end, NULL);
                read_lock(&em_tree->lock);
-               em = lookup_extent_mapping(em_tree, cur, page_end + 1 - cur);
+               em = btrfs_lookup_extent_mapping(em_tree, cur, page_end + 1 - cur);
                read_unlock(&em_tree->lock);
 
                /*
@@ -581,7 +581,7 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio)
 
        /* we need the actual starting offset of this extent in the file */
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, file_offset, fs_info->sectorsize);
+       em = btrfs_lookup_extent_mapping(em_tree, file_offset, fs_info->sectorsize);
        read_unlock(&em_tree->lock);
        if (!em) {
                ret = BLK_STS_IOERR;

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index 837598c82c9f85de75e31979f352b704485c132c..9dfdf29f54a08ccfbb9c2074b4403ffb9dcb0bf2 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -753,7 +753,7 @@ static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start,
         * full extent lock.
         */
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, start, sectorsize);
+       em = btrfs_lookup_extent_mapping(em_tree, start, sectorsize);
        read_unlock(&em_tree->lock);
 
        /*

diff --git a/fs/btrfs/direct-io.c b/fs/btrfs/direct-io.c
index 3793d9d1c5743001ea3873b2c93a2c58ff885516..3a03142dee099b86f7eb78e9f50d67c0b3d10f35 100644 (file)
--- a/fs/btrfs/direct-io.c
+++ b/fs/btrfs/direct-io.c
@@ -692,9 +692,9 @@ static int btrfs_extract_ordered_extent(struct btrfs_bio *bbio,
         * a pre-existing one.
         */
        if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
-               ret = split_extent_map(bbio->inode, bbio->file_offset,
-                                      ordered->num_bytes, len,
-                                      ordered->disk_bytenr);
+               ret = btrfs_split_extent_map(bbio->inode, bbio->file_offset,
+                                            ordered->num_bytes, len,
+                                            ordered->disk_bytenr);
                if (ret)
                        return ret;
        }

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5ee05955d004f16a4a90e3be9aaa6cb5cab689f3..59da809b7d57ab6138cd3babfac1b2beb1b1d5bd 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1922,7 +1922,7 @@ static int btrfs_init_btree_inode(struct super_block *sb)
 
        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_extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
 
        BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
        set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index f3148ebcd39a96a607a567dac695f2bb784b507f..6c434d6766d6762d0e4f08c6c014b5d37f31ac15 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2668,7 +2668,7 @@ bool try_release_extent_mapping(struct folio *folio, gfp_t mask)
                struct extent_map *em;
 
                write_lock(&extent_tree->lock);
-               em = lookup_extent_mapping(extent_tree, start, len);
+               em = btrfs_lookup_extent_mapping(extent_tree, start, len);
                if (!em) {
                        write_unlock(&extent_tree->lock);
                        break;
@@ -2707,7 +2707,7 @@ remove_em:
                 * fsync performance for workloads with a data size that exceeds
                 * or is close to the system's memory).
                 */
-               remove_extent_mapping(inode, em);
+               btrfs_remove_extent_mapping(inode, em);
                /* Once for the inode's extent map tree. */
                btrfs_free_extent_map(em);
 next:

diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index 458215cafbb42e525a02c2882dd86e80da8435eb..042b8b2e8b5253b81cf603d875f7eae5e6205898 100644 (file)
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -13,7 +13,7 @@
 
 static struct kmem_cache *extent_map_cache;
 
-int __init extent_map_init(void)
+int __init btrfs_extent_map_init(void)
 {
        extent_map_cache = kmem_cache_create("btrfs_extent_map",
                                             sizeof(struct extent_map), 0, 0, NULL);
@@ -22,7 +22,7 @@ int __init extent_map_init(void)
        return 0;
 }
 
-void __cold extent_map_exit(void)
+void __cold btrfs_extent_map_exit(void)
 {
        kmem_cache_destroy(extent_map_cache);
 }
@@ -31,7 +31,7 @@ void __cold extent_map_exit(void)
  * Initialize the extent tree @tree.  Should be called for each new inode or
  * other user of the extent_map interface.
  */
-void extent_map_tree_init(struct extent_map_tree *tree)
+void btrfs_extent_map_tree_init(struct extent_map_tree *tree)
 {
        tree->root = RB_ROOT;
        INIT_LIST_HEAD(&tree->modified_extents);
@@ -409,7 +409,7 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em)
  *         -ENOENT  when the extent is not found in the tree
  *         -EUCLEAN if the found extent does not match the expected start
  */
-int unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen)
+int btrfs_unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen)
 {
        struct btrfs_fs_info *fs_info = inode->root->fs_info;
        struct extent_map_tree *tree = &inode->extent_tree;
@@ -417,7 +417,7 @@ int unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen)
        struct extent_map *em;
 
        write_lock(&tree->lock);
-       em = lookup_extent_mapping(tree, start, len);
+       em = btrfs_lookup_extent_mapping(tree, start, len);
 
        if (WARN_ON(!em)) {
                btrfs_warn(fs_info,
@@ -449,7 +449,7 @@ out:
 
 }
 
-void clear_em_logging(struct btrfs_inode *inode, struct extent_map *em)
+void btrfs_clear_em_logging(struct btrfs_inode *inode, struct extent_map *em)
 {
        lockdep_assert_held_write(&inode->extent_tree.lock);
 
@@ -546,8 +546,8 @@ __lookup_extent_mapping(struct extent_map_tree *tree,
  * intersect, so check the object returned carefully to make sure that no
  * additional lookups are needed.
  */
-struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
-                                        u64 start, u64 len)
+struct extent_map *btrfs_lookup_extent_mapping(struct extent_map_tree *tree,
+                                              u64 start, u64 len)
 {
        return __lookup_extent_mapping(tree, start, len, 1);
 }
@@ -564,8 +564,8 @@ struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
  *
  * If one can't be found, any nearby extent may be returned
  */
-struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
-                                        u64 start, u64 len)
+struct extent_map *btrfs_search_extent_mapping(struct extent_map_tree *tree,
+                                              u64 start, u64 len)
 {
        return __lookup_extent_mapping(tree, start, len, 0);
 }
@@ -579,7 +579,7 @@ struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
  * Remove @em from the extent tree of @inode.  No reference counts are dropped,
  * and no checks are done to see if the range is in use.
  */
-void remove_extent_mapping(struct btrfs_inode *inode, struct extent_map *em)
+void btrfs_remove_extent_mapping(struct btrfs_inode *inode, struct extent_map *em)
 {
        struct extent_map_tree *tree = &inode->extent_tree;
 
@@ -716,7 +716,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode,
        if (ret == -EEXIST) {
                struct extent_map *existing;
 
-               existing = search_extent_mapping(&inode->extent_tree, start, len);
+               existing = btrfs_search_extent_mapping(&inode->extent_tree, start, len);
 
                trace_btrfs_handle_em_exist(fs_info, existing, em, start, len);
 
@@ -772,7 +772,7 @@ static void drop_all_extent_maps_fast(struct btrfs_inode *inode)
 
                em = rb_entry(node, struct extent_map, rb_node);
                em->flags &= ~(EXTENT_FLAG_PINNED | EXTENT_FLAG_LOGGING);
-               remove_extent_mapping(inode, em);
+               btrfs_remove_extent_mapping(inode, em);
                btrfs_free_extent_map(em);
 
                if (cond_resched_rwlock_write(&tree->lock))
@@ -830,7 +830,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,
        split2 = btrfs_alloc_extent_map();
 
        write_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, start, len);
+       em = btrfs_lookup_extent_mapping(em_tree, start, len);
 
        while (em) {
                /* extent_map_end() returns exclusive value (last byte + 1). */
@@ -965,7 +965,7 @@ remove_em:
                                ASSERT(!split);
                                btrfs_set_inode_full_sync(inode);
                        }
-                       remove_extent_mapping(inode, em);
+                       btrfs_remove_extent_mapping(inode, em);
                }
 
                /*
@@ -1033,8 +1033,8 @@ int btrfs_replace_extent_map_range(struct btrfs_inode *inode,
  *
  * This function is used when an ordered_extent needs to be split.
  */
-int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
-                    u64 new_logical)
+int btrfs_split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
+                          u64 new_logical)
 {
        struct extent_map_tree *em_tree = &inode->extent_tree;
        struct extent_map *em;
@@ -1057,7 +1057,7 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
 
        btrfs_lock_extent(&inode->io_tree, start, start + len - 1, NULL);
        write_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, start, len);
+       em = btrfs_lookup_extent_mapping(em_tree, start, len);
        if (!em) {
                ret = -EIO;
                goto out_unlock;
@@ -1168,7 +1168,7 @@ static long btrfs_scan_inode(struct btrfs_inode *inode, struct btrfs_em_shrink_c
                if (!list_empty(&em->list) && em->generation >= cur_fs_gen)
                        btrfs_set_inode_full_sync(inode);
 
-               remove_extent_mapping(inode, em);
+               btrfs_remove_extent_mapping(inode, em);
                trace_btrfs_extent_map_shrinker_remove_em(inode, em);
                /* Drop the reference for the tree. */
                btrfs_free_extent_map(em);

diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index 890ea53a92d21a7c121a669e8472e19aa3488126..d4b81ee4d97bdb459a89fe1627a2c045f307fdd5 100644 (file)
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -167,21 +167,21 @@ static inline u64 btrfs_extent_map_end(const struct extent_map *em)
        return em->start + em->len;
 }
 
-void extent_map_tree_init(struct extent_map_tree *tree);
-struct extent_map *lookup_extent_mapping(struct extent_map_tree *tree,
-                                        u64 start, u64 len);
-void remove_extent_mapping(struct btrfs_inode *inode, struct extent_map *em);
-int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
-                    u64 new_logical);
+void btrfs_extent_map_tree_init(struct extent_map_tree *tree);
+struct extent_map *btrfs_lookup_extent_mapping(struct extent_map_tree *tree,
+                                              u64 start, u64 len);
+void btrfs_remove_extent_mapping(struct btrfs_inode *inode, struct extent_map *em);
+int btrfs_split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
+                          u64 new_logical);
 
 struct extent_map *btrfs_alloc_extent_map(void);
 void btrfs_free_extent_map(struct extent_map *em);
-int __init extent_map_init(void);
-void __cold extent_map_exit(void);
-int unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen);
-void clear_em_logging(struct btrfs_inode *inode, struct extent_map *em);
-struct extent_map *search_extent_mapping(struct extent_map_tree *tree,
-                                        u64 start, u64 len);
+int __init btrfs_extent_map_init(void);
+void __cold btrfs_extent_map_exit(void);
+int btrfs_unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen);
+void btrfs_clear_em_logging(struct btrfs_inode *inode, struct extent_map *em);
+struct extent_map *btrfs_search_extent_mapping(struct extent_map_tree *tree,
+                                              u64 start, u64 len);
 int btrfs_add_extent_mapping(struct btrfs_inode *inode,
                             struct extent_map **em_in, u64 start, u64 len);
 void btrfs_drop_extent_map_range(struct btrfs_inode *inode,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 388c17f1facc5a63603e26fef186356ff14d66f3..71ae3cfcc9bed6d39badfa5a4a753567a567e925 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1210,7 +1210,7 @@ u64 btrfs_get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,
        u64 alloc_hint = 0;
 
        read_lock(&em_tree->lock);
-       em = search_extent_mapping(em_tree, start, num_bytes);
+       em = btrfs_search_extent_mapping(em_tree, start, num_bytes);
        if (em) {
                /*
                 * if block start isn't an actual block number then find the
@@ -1219,7 +1219,7 @@ u64 btrfs_get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,
                 */
                if (em->disk_bytenr >= EXTENT_MAP_LAST_BYTE) {
                        btrfs_free_extent_map(em);
-                       em = search_extent_mapping(em_tree, 0, 0);
+                       em = btrfs_search_extent_mapping(em_tree, 0, 0);
                        if (em && em->disk_bytenr < EXTENT_MAP_LAST_BYTE)
                                alloc_hint = btrfs_extent_map_block_start(em);
                        if (em)
@@ -3193,8 +3193,8 @@ int btrfs_finish_one_ordered(struct btrfs_ordered_extent *ordered_extent)
                goto out;
        }
 
-       ret = unpin_extent_cache(inode, ordered_extent->file_offset,
-                                ordered_extent->num_bytes, trans->transid);
+       ret = btrfs_unpin_extent_cache(inode, ordered_extent->file_offset,
+                                      ordered_extent->num_bytes, trans->transid);
        if (ret < 0) {
                btrfs_abort_transaction(trans, ret);
                goto out;
@@ -6877,7 +6877,7 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
        struct extent_map_tree *em_tree = &inode->extent_tree;
 
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, start, len);
+       em = btrfs_lookup_extent_mapping(em_tree, start, len);
        read_unlock(&em_tree->lock);
 
        if (em) {
@@ -7742,7 +7742,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
        ei->i_otime_nsec = 0;
 
        inode = &ei->vfs_inode;
-       extent_map_tree_init(&ei->extent_tree);
+       btrfs_extent_map_tree_init(&ei->extent_tree);
 
        /* This io tree sets the valid inode. */
        btrfs_extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 7d48e8d91e27a0d1aedf0f29d7d7139d9f7478ac..7d7001ad952930185b213d5ba740a3259e24302c 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -2538,8 +2538,8 @@ static const struct init_sequence mod_init_seq[] = {
                .init_func = btrfs_bioset_init,
                .exit_func = btrfs_bioset_exit,
        }, {
-               .init_func = extent_map_init,
-               .exit_func = extent_map_exit,
+               .init_func = btrfs_extent_map_init,
+               .exit_func = btrfs_extent_map_exit,
 #ifdef CONFIG_BTRFS_EXPERIMENTAL
        }, {
                .init_func = btrfs_read_policy_init,

diff --git a/fs/btrfs/tests/extent-map-tests.c b/fs/btrfs/tests/extent-map-tests.c
index 3b7487c032d49996aac328a958207fe6805ca6bb..3a86534c116f2f4985652277444e99f26edbc03d 100644 (file)
--- a/fs/btrfs/tests/extent-map-tests.c
+++ b/fs/btrfs/tests/extent-map-tests.c
@@ -22,7 +22,7 @@ static int free_extent_map_tree(struct btrfs_inode *inode)
        while (!RB_EMPTY_ROOT(&em_tree->root)) {
                node = rb_first(&em_tree->root);
                em = rb_entry(node, struct extent_map, rb_node);
-               remove_extent_mapping(inode, em);
+               btrfs_remove_extent_mapping(inode, em);
 
 #ifdef CONFIG_BTRFS_DEBUG
                if (refcount_read(&em->refs) != 1) {
@@ -826,7 +826,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        /* Make sure our extent maps look sane. */
        ret = -EINVAL;
 
-       em = lookup_extent_mapping(em_tree, 0, SZ_16K);
+       em = btrfs_lookup_extent_mapping(em_tree, 0, SZ_16K);
        if (!em) {
                test_err("didn't find an em at 0 as expected");
                goto out;
@@ -845,7 +845,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        btrfs_free_extent_map(em);
 
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, SZ_16K, SZ_16K);
+       em = btrfs_lookup_extent_mapping(em_tree, SZ_16K, SZ_16K);
        read_unlock(&em_tree->lock);
        if (em) {
                test_err("found an em when we weren't expecting one");
@@ -853,7 +853,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        }
 
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, SZ_32K, SZ_16K);
+       em = btrfs_lookup_extent_mapping(em_tree, SZ_32K, SZ_16K);
        read_unlock(&em_tree->lock);
        if (!em) {
                test_err("didn't find an em at 32K as expected");
@@ -879,7 +879,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        btrfs_free_extent_map(em);
 
        read_lock(&em_tree->lock);
-       em = lookup_extent_mapping(em_tree, 48 * SZ_1K, (u64)-1);
+       em = btrfs_lookup_extent_mapping(em_tree, 48 * SZ_1K, (u64)-1);
        read_unlock(&em_tree->lock);
        if (em) {
                test_err("found an unexpected em above 48K");
@@ -890,7 +890,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
 out:
        btrfs_free_extent_map(em);
        /* Unpin our extent to prevent warning when removing it below. */
-       ret2 = unpin_extent_cache(inode, 0, SZ_16K, 0);
+       ret2 = btrfs_unpin_extent_cache(inode, 0, SZ_16K, 0);
        if (ret == 0)
                ret = ret2;
        ret2 = free_extent_map_tree(inode);

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 3d20473a4bc3c1753855d8fd90c5b12b521094cb..411dad8860a8f8428ace9bf5fc4481d7e4e0357f 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4956,7 +4956,7 @@ process:
                 * private list.
                 */
                if (ret) {
-                       clear_em_logging(inode, em);
+                       btrfs_clear_em_logging(inode, em);
                        btrfs_free_extent_map(em);
                        continue;
                }
@@ -4965,7 +4965,7 @@ process:
 
                ret = log_one_extent(trans, inode, em, path, ctx);
                write_lock(&tree->lock);
-               clear_em_logging(inode, em);
+               btrfs_clear_em_logging(inode, em);
                btrfs_free_extent_map(em);
        }
        WARN_ON(!list_empty(&extents));

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index 49a74f2b06b633af6df36cc9ee8d3926ed8c2d8d..7b30700ec9304fb8027bc7e752e5a7c0f7bcbfae 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -1797,8 +1797,8 @@ static void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered,
        ordered->disk_bytenr = logical;
 
        write_lock(&em_tree->lock);
-       em = search_extent_mapping(em_tree, ordered->file_offset,
-                                  ordered->num_bytes);
+       em = btrfs_search_extent_mapping(em_tree, ordered->file_offset,
+                                        ordered->num_bytes);
        /* The em should be a new COW extent, thus it should not have an offset. */
        ASSERT(em->offset == 0);
        em->disk_bytenr = logical;
@@ -1812,8 +1812,8 @@ static bool btrfs_zoned_split_ordered(struct btrfs_ordered_extent *ordered,
        struct btrfs_ordered_extent *new;
 
        if (!test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags) &&
-           split_extent_map(ordered->inode, ordered->file_offset,
-                            ordered->num_bytes, len, logical))
+           btrfs_split_extent_map(ordered->inode, ordered->file_offset,
+                                  ordered->num_bytes, len, logical))
                return false;
 
        new = btrfs_split_ordered_extent(ordered, len);