btrfs: rename functions to allocate and free extent maps

These functions are exported and don't have a 'btrfs_' prefix in their
names, which goes against coding style conventions. Rename them to have
such prefix, making it clear they are from btrfs and avoiding potential
collisions in the future with functions defined elsewhere outside btrfs.

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 fb112b2abc1d756bb39c7e47ace9f476b3bb8740..00cda793cec5ff6270193c8180bd543a7e311f39 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -513,14 +513,14 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                    (cur + fs_info->sectorsize > btrfs_extent_map_end(em)) ||
                    (btrfs_extent_map_block_start(em) >> SECTOR_SHIFT) !=
                    orig_bio->bi_iter.bi_sector) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        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);
+               btrfs_free_extent_map(em);
                btrfs_unlock_extent(tree, cur, page_end, NULL);
 
                if (folio_contains(folio, end_index)) {
@@ -603,7 +603,7 @@ void btrfs_submit_compressed_read(struct btrfs_bio *bbio)
        cb->compress_type = btrfs_extent_map_compression(em);
        cb->orig_bbio = bbio;
 
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        cb->nr_folios = DIV_ROUND_UP(compressed_len, PAGE_SIZE);
        cb->compressed_folios = kcalloc(cb->nr_folios, sizeof(struct folio *), GFP_NOFS);

diff --git a/fs/btrfs/defrag.c b/fs/btrfs/defrag.c
index 8cb225ab1c17a9276f451ede92114b142c6b3e8f..837598c82c9f85de75e31979f352b704485c132c 100644 (file)
--- a/fs/btrfs/defrag.c
+++ b/fs/btrfs/defrag.c
@@ -621,7 +621,7 @@ static struct extent_map *defrag_get_extent(struct btrfs_inode *inode,
        u64 ino = btrfs_ino(inode);
        int ret;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                ret = -ENOMEM;
                goto err;
@@ -731,12 +731,12 @@ next:
 
 not_found:
        btrfs_release_path(&path);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        return NULL;
 
 err:
        btrfs_release_path(&path);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        return ERR_PTR(ret);
 }
 
@@ -766,7 +766,7 @@ static struct extent_map *defrag_lookup_extent(struct inode *inode, u64 start,
         * file extent items in the inode's subvolume tree).
         */
        if (em && (em->flags & EXTENT_FLAG_MERGED)) {
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                em = NULL;
        }
 
@@ -834,7 +834,7 @@ static bool defrag_check_next_extent(struct inode *inode, struct extent_map *em,
 
        ret = true;
 out:
-       free_extent_map(next);
+       btrfs_free_extent_map(next);
        return ret;
 }
 
@@ -1096,7 +1096,7 @@ add:
                /* Allocate new defrag_target_range */
                new = kmalloc(sizeof(*new), GFP_NOFS);
                if (!new) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        ret = -ENOMEM;
                        break;
                }
@@ -1106,7 +1106,7 @@ add:
 
 next:
                cur = btrfs_extent_map_end(em);
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        }
        if (ret < 0) {
                struct defrag_target_range *entry;

diff --git a/fs/btrfs/direct-io.c b/fs/btrfs/direct-io.c
index 2daf0c524500fe485a9c3a52202115c6e7080e0a..3793d9d1c5743001ea3873b2c93a2c58ff885516 100644 (file)
--- a/fs/btrfs/direct-io.c
+++ b/fs/btrfs/direct-io.c
@@ -155,7 +155,7 @@ static struct extent_map *btrfs_create_dio_extent(struct btrfs_inode *inode,
                                             (1 << BTRFS_ORDERED_DIRECT));
        if (IS_ERR(ordered)) {
                if (em) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        btrfs_drop_extent_map_range(inode, start,
                                        start + file_extent->num_bytes - 1, false);
                }
@@ -265,7 +265,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
                                                      nowait);
                if (ret < 0) {
                        /* Our caller expects us to free the input extent map. */
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        *map = NULL;
                        btrfs_dec_nocow_writers(bg);
                        if (nowait && (ret == -ENOSPC || ret == -EDQUOT))
@@ -278,7 +278,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
                                              &file_extent, type);
                btrfs_dec_nocow_writers(bg);
                if (type == BTRFS_ORDERED_PREALLOC) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        *map = em2;
                        em = em2;
                }
@@ -291,7 +291,7 @@ static int btrfs_get_blocks_direct_write(struct extent_map **map,
                dio_data->nocow_done = true;
        } else {
                /* Our caller expects us to free the input extent map. */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                *map = NULL;
 
                if (nowait) {
@@ -475,7 +475,7 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,
         * the generic code.
         */
        if (btrfs_extent_map_is_compressed(em) || em->disk_bytenr == EXTENT_MAP_INLINE) {
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                /*
                 * If we are in a NOWAIT context, return -EAGAIN in order to
                 * fallback to buffered IO. This is not only because we can
@@ -516,7 +516,7 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,
         * after we have submitted bios for all the extents in the range.
         */
        if ((flags & IOMAP_NOWAIT) && len < length) {
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                ret = -EAGAIN;
                goto unlock_err;
        }
@@ -564,7 +564,7 @@ static int btrfs_dio_iomap_begin(struct inode *inode, loff_t start,
        iomap->offset = start;
        iomap->bdev = fs_info->fs_devices->latest_dev->bdev;
        iomap->length = len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /*
         * Reads will hold the EXTENT_DIO_LOCKED bit until the io is completed,

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 16d4454bbc8ba8ee60bdf1c78f335072bcb78282..f3148ebcd39a96a607a567dac695f2bb784b507f 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -898,7 +898,7 @@ static struct extent_map *get_extent_map(struct btrfs_inode *inode,
                        return em;
                }
 
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                *em_cached = NULL;
        }
 
@@ -1026,7 +1026,7 @@ static int btrfs_do_readpage(struct folio *folio, struct extent_map **em_cached,
                if (prev_em_start)
                        *prev_em_start = em->start;
 
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                em = NULL;
 
                /* we've found a hole, just zero and go on */
@@ -1246,7 +1246,7 @@ int btrfs_read_folio(struct file *file, struct folio *folio)
        ret = btrfs_do_readpage(folio, &em_cached, &bio_ctrl, NULL);
        btrfs_unlock_extent(&inode->io_tree, start, end, &cached_state);
 
-       free_extent_map(em_cached);
+       btrfs_free_extent_map(em_cached);
 
        /*
         * If btrfs_do_readpage() failed we will want to submit the assembled
@@ -1551,7 +1551,7 @@ static int submit_one_sector(struct btrfs_inode *inode,
        ASSERT(block_start != EXTENT_MAP_HOLE);
        ASSERT(block_start != EXTENT_MAP_INLINE);
 
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        em = NULL;
 
        /*
@@ -2566,7 +2566,7 @@ void btrfs_readahead(struct readahead_control *rac)
        btrfs_unlock_extent(&inode->io_tree, start, end, &cached_state);
 
        if (em_cached)
-               free_extent_map(em_cached);
+               btrfs_free_extent_map(em_cached);
        submit_one_bio(&bio_ctrl);
 }
 
@@ -2675,7 +2675,7 @@ bool try_release_extent_mapping(struct folio *folio, gfp_t mask)
                }
                if ((em->flags & EXTENT_FLAG_PINNED) || em->start != start) {
                        write_unlock(&extent_tree->lock);
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        break;
                }
                if (btrfs_test_range_bit_exists(io_tree, em->start,
@@ -2709,13 +2709,13 @@ remove_em:
                 */
                remove_extent_mapping(inode, em);
                /* Once for the inode's extent map tree. */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 next:
                start = btrfs_extent_map_end(em);
                write_unlock(&extent_tree->lock);
 
                /* Once for us, for the lookup_extent_mapping() reference. */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 
                if (need_resched()) {
                        /*

diff --git a/fs/btrfs/extent_map.c b/fs/btrfs/extent_map.c
index e91ce14024736f9b912cfe4be7081fda88d370ef..458215cafbb42e525a02c2882dd86e80da8435eb 100644 (file)
--- a/fs/btrfs/extent_map.c
+++ b/fs/btrfs/extent_map.c
@@ -42,7 +42,7 @@ void extent_map_tree_init(struct extent_map_tree *tree)
  * Allocate a new extent_map structure.  The new structure is returned with a
  * reference count of one and needs to be freed using free_extent_map()
  */
-struct extent_map *alloc_extent_map(void)
+struct extent_map *btrfs_alloc_extent_map(void)
 {
        struct extent_map *em;
        em = kmem_cache_zalloc(extent_map_cache, GFP_NOFS);
@@ -58,7 +58,7 @@ struct extent_map *alloc_extent_map(void)
  * Drop the reference out on @em by one and free the structure if the reference
  * count hits zero.
  */
-void free_extent_map(struct extent_map *em)
+void btrfs_free_extent_map(struct extent_map *em)
 {
        if (!em)
                return;
@@ -374,7 +374,7 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em)
 
                        validate_extent_map(fs_info, em);
                        remove_em(inode, merge);
-                       free_extent_map(merge);
+                       btrfs_free_extent_map(merge);
                }
        }
 
@@ -389,7 +389,7 @@ static void try_merge_map(struct btrfs_inode *inode, struct extent_map *em)
                em->generation = max(em->generation, merge->generation);
                em->flags |= EXTENT_FLAG_MERGED;
                remove_em(inode, merge);
-               free_extent_map(merge);
+               btrfs_free_extent_map(merge);
        }
 }
 
@@ -444,7 +444,7 @@ int unpin_extent_cache(struct btrfs_inode *inode, u64 start, u64 len, u64 gen)
 
 out:
        write_unlock(&tree->lock);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        return ret;
 
 }
@@ -726,7 +726,7 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode,
                 */
                if (start >= existing->start &&
                    start < btrfs_extent_map_end(existing)) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        *em_in = existing;
                        ret = 0;
                } else {
@@ -739,14 +739,14 @@ int btrfs_add_extent_mapping(struct btrfs_inode *inode,
                         */
                        ret = merge_extent_mapping(inode, existing, em, start);
                        if (WARN_ON(ret)) {
-                               free_extent_map(em);
+                               btrfs_free_extent_map(em);
                                *em_in = NULL;
                                btrfs_warn(fs_info,
 "extent map merge error existing [%llu, %llu) with em [%llu, %llu) start %llu",
                                           existing->start, btrfs_extent_map_end(existing),
                                           orig_start, orig_start + orig_len, start);
                        }
-                       free_extent_map(existing);
+                       btrfs_free_extent_map(existing);
                }
        }
 
@@ -773,7 +773,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);
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 
                if (cond_resched_rwlock_write(&tree->lock))
                        node = rb_first(&tree->root);
@@ -826,8 +826,8 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,
         * range ends after our range (and they might be the same extent map),
         * because we need to split those two extent maps at the boundaries.
         */
-       split = alloc_extent_map();
-       split2 = alloc_extent_map();
+       split = btrfs_alloc_extent_map();
+       split2 = btrfs_alloc_extent_map();
 
        write_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, start, len);
@@ -898,7 +898,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,
                        split->generation = gen;
                        split->flags = flags;
                        replace_extent_mapping(inode, em, split, modified);
-                       free_extent_map(split);
+                       btrfs_free_extent_map(split);
                        split = split2;
                        split2 = NULL;
                }
@@ -936,7 +936,7 @@ void btrfs_drop_extent_map_range(struct btrfs_inode *inode, u64 start, u64 end,
                                if (WARN_ON(ret != 0) && modified)
                                        btrfs_set_inode_full_sync(inode);
                        }
-                       free_extent_map(split);
+                       btrfs_free_extent_map(split);
                        split = NULL;
                }
 remove_em:
@@ -972,18 +972,18 @@ remove_em:
                 * Once for the tree reference (we replaced or removed the
                 * extent map from the tree).
                 */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 next:
                /* Once for us (for our lookup reference). */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 
                em = next_em;
        }
 
        write_unlock(&em_tree->lock);
 
-       free_extent_map(split);
-       free_extent_map(split2);
+       btrfs_free_extent_map(split);
+       btrfs_free_extent_map(split2);
 }
 
 /*
@@ -1046,10 +1046,10 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
        ASSERT(pre != 0);
        ASSERT(pre < len);
 
-       split_pre = alloc_extent_map();
+       split_pre = btrfs_alloc_extent_map();
        if (!split_pre)
                return -ENOMEM;
-       split_mid = alloc_extent_map();
+       split_mid = btrfs_alloc_extent_map();
        if (!split_mid) {
                ret = -ENOMEM;
                goto out_free_pre;
@@ -1102,16 +1102,16 @@ int split_extent_map(struct btrfs_inode *inode, u64 start, u64 len, u64 pre,
        add_extent_mapping(inode, split_mid, 1);
 
        /* Once for us */
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        /* Once for the tree */
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
 out_unlock:
        write_unlock(&em_tree->lock);
        btrfs_unlock_extent(&inode->io_tree, start, start + len - 1, NULL);
-       free_extent_map(split_mid);
+       btrfs_free_extent_map(split_mid);
 out_free_pre:
-       free_extent_map(split_pre);
+       btrfs_free_extent_map(split_pre);
        return ret;
 }
 
@@ -1171,7 +1171,7 @@ static long btrfs_scan_inode(struct btrfs_inode *inode, struct btrfs_em_shrink_c
                remove_extent_mapping(inode, em);
                trace_btrfs_extent_map_shrinker_remove_em(inode, em);
                /* Drop the reference for the tree. */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                nr_dropped++;
 next:
                if (ctx->scanned >= ctx->nr_to_scan)

diff --git a/fs/btrfs/extent_map.h b/fs/btrfs/extent_map.h
index de7d14fbaee2f9e03ca900d46afb800cc882ae6b..890ea53a92d21a7c121a669e8472e19aa3488126 100644 (file)
--- a/fs/btrfs/extent_map.h
+++ b/fs/btrfs/extent_map.h
@@ -174,8 +174,8 @@ 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);
 
-struct extent_map *alloc_extent_map(void);
-void free_extent_map(struct extent_map *em);
+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);

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 9837460e7319137fe86fd01b4011489871dd1362..93a995999e1df07d68d939e21ebae6dbe06b79a9 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2102,7 +2102,7 @@ static int fill_holes(struct btrfs_trans_handle *trans,
 out:
        btrfs_release_path(path);
 
-       hole_em = alloc_extent_map();
+       hole_em = btrfs_alloc_extent_map();
        if (!hole_em) {
                btrfs_drop_extent_map_range(inode, offset, end - 1, false);
                btrfs_set_inode_full_sync(inode);
@@ -2116,7 +2116,7 @@ out:
                hole_em->generation = trans->transid;
 
                ret = btrfs_replace_extent_map_range(inode, hole_em, true);
-               free_extent_map(hole_em);
+               btrfs_free_extent_map(hole_em);
                if (ret)
                        btrfs_set_inode_full_sync(inode);
        }
@@ -2149,7 +2149,7 @@ static int find_first_non_hole(struct btrfs_inode *inode, u64 *start, u64 *len)
                       0 : *start + *len - em->start - em->len;
                *start = em->start + em->len;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        return ret;
 }
 
@@ -2856,7 +2856,7 @@ static int btrfs_zero_range_check_range_boundary(struct btrfs_inode *inode,
        else
                ret = RANGE_BOUNDARY_WRITTEN_EXTENT;
 
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        return ret;
 }
 
@@ -2900,7 +2900,7 @@ static int btrfs_zero_range(struct inode *inode,
                         * do nothing except updating the inode's i_size if
                         * needed.
                         */
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        ret = btrfs_fallocate_update_isize(inode, offset + len,
                                                           mode);
                        goto out;
@@ -2915,7 +2915,7 @@ static int btrfs_zero_range(struct inode *inode,
                offset = alloc_start;
                alloc_hint = btrfs_extent_map_block_start(em) + em->len;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        if (BTRFS_BYTES_TO_BLKS(fs_info, offset) ==
            BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) {
@@ -2926,13 +2926,13 @@ static int btrfs_zero_range(struct inode *inode,
                }
 
                if (em->flags & EXTENT_FLAG_PREALLOC) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        ret = btrfs_fallocate_update_isize(inode, offset + len,
                                                           mode);
                        goto out;
                }
                if (len < sectorsize && em->disk_bytenr != EXTENT_MAP_HOLE) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        ret = btrfs_truncate_block(BTRFS_I(inode), offset, len,
                                                   0);
                        if (!ret)
@@ -2941,7 +2941,7 @@ static int btrfs_zero_range(struct inode *inode,
                                                                   mode);
                        return ret;
                }
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                alloc_start = round_down(offset, sectorsize);
                alloc_end = alloc_start + sectorsize;
                goto reserve_space;
@@ -3151,19 +3151,19 @@ static long btrfs_fallocate(struct file *file, int mode,
 
                        ret = add_falloc_range(&reserve_list, cur_offset, range_len);
                        if (ret < 0) {
-                               free_extent_map(em);
+                               btrfs_free_extent_map(em);
                                break;
                        }
                        ret = btrfs_qgroup_reserve_data(BTRFS_I(inode),
                                        &data_reserved, cur_offset, range_len);
                        if (ret < 0) {
-                               free_extent_map(em);
+                               btrfs_free_extent_map(em);
                                break;
                        }
                        qgroup_reserved += range_len;
                        data_space_needed += range_len;
                }
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                cur_offset = last_byte;
        }
 

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 9b4f70102d97fe7869644d460e839998443adf6f..388c17f1facc5a63603e26fef186356ff14d66f3 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1153,7 +1153,7 @@ static void submit_one_async_extent(struct async_chunk *async_chunk,
                ret = PTR_ERR(em);
                goto out_free_reserve;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
                                             1 << BTRFS_ORDERED_COMPRESSED);
@@ -1218,15 +1218,15 @@ u64 btrfs_get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,
                 * block is also bogus then just don't worry about it.
                 */
                if (em->disk_bytenr >= EXTENT_MAP_LAST_BYTE) {
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        em = 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)
-                               free_extent_map(em);
+                               btrfs_free_extent_map(em);
                } else {
                        alloc_hint = btrfs_extent_map_block_start(em);
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                }
        }
        read_unlock(&em_tree->lock);
@@ -1400,7 +1400,7 @@ static noinline int cow_file_range(struct btrfs_inode *inode,
                        ret = PTR_ERR(em);
                        goto out_reserve;
                }
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 
                ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
                                                     1 << BTRFS_ORDERED_REGULAR);
@@ -1978,7 +1978,7 @@ static int nocow_one_range(struct btrfs_inode *inode, struct folio *locked_folio
                        btrfs_unlock_extent(&inode->io_tree, file_pos, end, cached);
                        return PTR_ERR(em);
                }
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        }
 
        ordered = btrfs_alloc_ordered_extent(inode, file_pos, &nocow_args->file_extent,
@@ -2687,7 +2687,7 @@ static int btrfs_find_new_delalloc_bytes(struct btrfs_inode *inode,
                                           EXTENT_DELALLOC_NEW, cached_state);
 next:
                search_start = btrfs_extent_map_end(em);
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                if (ret)
                        return ret;
        }
@@ -5029,7 +5029,7 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size)
                        if (ret)
                                break;
 
-                       hole_em = alloc_extent_map();
+                       hole_em = btrfs_alloc_extent_map();
                        if (!hole_em) {
                                btrfs_drop_extent_map_range(inode, cur_offset,
                                                    cur_offset + hole_size - 1,
@@ -5046,7 +5046,7 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size)
                        hole_em->generation = btrfs_get_fs_generation(fs_info);
 
                        ret = btrfs_replace_extent_map_range(inode, hole_em, true);
-                       free_extent_map(hole_em);
+                       btrfs_free_extent_map(hole_em);
                } else {
                        ret = btrfs_inode_set_file_extent_range(inode,
                                                        cur_offset, hole_size);
@@ -5054,13 +5054,13 @@ int btrfs_cont_expand(struct btrfs_inode *inode, loff_t oldsize, loff_t size)
                                break;
                }
 next:
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                em = NULL;
                cur_offset = last_byte;
                if (cur_offset >= block_end)
                        break;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        btrfs_unlock_extent(io_tree, hole_start, block_end - 1, &cached_state);
        return ret;
 }
@@ -6882,13 +6882,13 @@ struct extent_map *btrfs_get_extent(struct btrfs_inode *inode,
 
        if (em) {
                if (em->start > start || em->start + em->len <= start)
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                else if (em->disk_bytenr == EXTENT_MAP_INLINE && folio)
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                else
                        goto out;
        }
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                ret = -ENOMEM;
                goto out;
@@ -7042,7 +7042,7 @@ out:
        trace_btrfs_get_extent(root, inode, em);
 
        if (ret) {
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                return ERR_PTR(ret);
        }
        return em;
@@ -7214,7 +7214,7 @@ struct extent_map *btrfs_create_io_em(struct btrfs_inode *inode, u64 start,
                break;
        }
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em)
                return ERR_PTR(-ENOMEM);
 
@@ -7231,11 +7231,11 @@ struct extent_map *btrfs_create_io_em(struct btrfs_inode *inode, u64 start,
 
        ret = btrfs_replace_extent_map_range(inode, em, true);
        if (ret) {
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                return ERR_PTR(ret);
        }
 
-       /* em got 2 refs now, callers needs to do free_extent_map once. */
+       /* em got 2 refs now, callers needs to do btrfs_free_extent_map once. */
        return em;
 }
 
@@ -8890,7 +8890,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                        break;
                }
 
-               em = alloc_extent_map();
+               em = btrfs_alloc_extent_map();
                if (!em) {
                        btrfs_drop_extent_map_range(BTRFS_I(inode), cur_offset,
                                            cur_offset + ins.offset - 1, false);
@@ -8908,7 +8908,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                em->generation = trans->transid;
 
                ret = btrfs_replace_extent_map_range(BTRFS_I(inode), em, true);
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
 next:
                num_bytes -= ins.offset;
                cur_offset += ins.offset;
@@ -9412,7 +9412,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,
                 * For inline extents we get everything we need out of the
                 * extent item.
                 */
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
                em = NULL;
                ret = btrfs_encoded_read_inline(iocb, iter, start, lockend,
                                                cached_state, extent_start,
@@ -9465,7 +9465,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,
                encoded->unencoded_len = count;
                *disk_io_size = ALIGN(*disk_io_size, fs_info->sectorsize);
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        em = NULL;
 
        if (*disk_bytenr == EXTENT_MAP_HOLE) {
@@ -9481,7 +9481,7 @@ ssize_t btrfs_encoded_read(struct kiocb *iocb, struct iov_iter *iter,
        }
 
 out_em:
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 out_unlock_extent:
        /* Leave inode and extent locked if we need to do a read. */
        if (!unlocked && ret != -EIOCBQUEUED)
@@ -9689,7 +9689,7 @@ ssize_t btrfs_do_encoded_write(struct kiocb *iocb, struct iov_iter *from,
                ret = PTR_ERR(em);
                goto out_free_reserved;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        ordered = btrfs_alloc_ordered_extent(inode, start, &file_extent,
                                       (1 << BTRFS_ORDERED_ENCODED) |

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 4bfc5403cf17ffbb8a9a513b106e68ac2c4e8300..6ba9fcb53c33c00f83c2558913bca1835c614f94 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2764,7 +2764,7 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct reloc_contr
        u64 end = rc->cluster.end - offset;
        int ret = 0;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em)
                return -ENOMEM;
 
@@ -2778,7 +2778,7 @@ static noinline_for_stack int setup_relocation_extent_mapping(struct reloc_contr
        btrfs_lock_extent(&inode->io_tree, start, end, &cached_state);
        ret = btrfs_replace_extent_map_range(inode, em, false);
        btrfs_unlock_extent(&inode->io_tree, start, end, &cached_state);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        return ret;
 }

diff --git a/fs/btrfs/tests/extent-map-tests.c b/fs/btrfs/tests/extent-map-tests.c
index 2c3cfa9479abb412f4123534a0bd0a0ee8bd13be..3b7487c032d49996aac328a958207fe6805ca6bb 100644 (file)
--- a/fs/btrfs/tests/extent-map-tests.c
+++ b/fs/btrfs/tests/extent-map-tests.c
@@ -36,7 +36,7 @@ static int free_extent_map_tree(struct btrfs_inode *inode)
                        refcount_set(&em->refs, 1);
                }
 #endif
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        }
        write_unlock(&em_tree->lock);
 
@@ -68,7 +68,7 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        int ret;
        int ret2;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -87,10 +87,10 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("cannot add extent range [0, 16K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Add [16K, 20K) following [0, 16K)  */
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -109,9 +109,9 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("cannot add extent range [16K, 20K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -145,7 +145,7 @@ static int test_case_1(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                         em->disk_bytenr, em->disk_num_bytes);
                ret = -EINVAL;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 out:
        ret2 = free_extent_map_tree(inode);
        if (ret == 0)
@@ -167,7 +167,7 @@ static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        int ret;
        int ret2;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -186,10 +186,10 @@ static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("cannot add extent range [0, 1K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Add [4K, 8K) following [0, 1K)  */
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -208,9 +208,9 @@ static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("cannot add extent range [4K, 8K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -242,7 +242,7 @@ static int test_case_2(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                         ret, em->start, em->len, em->disk_bytenr);
                ret = -EINVAL;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 out:
        ret2 = free_extent_map_tree(inode);
        if (ret == 0)
@@ -260,7 +260,7 @@ static int __test_case_3(struct btrfs_fs_info *fs_info,
        int ret;
        int ret2;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -279,9 +279,9 @@ static int __test_case_3(struct btrfs_fs_info *fs_info,
                test_err("cannot add extent range [4K, 8K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -320,7 +320,7 @@ static int __test_case_3(struct btrfs_fs_info *fs_info,
                         em->disk_bytenr, em->disk_num_bytes);
                ret = -EINVAL;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 out:
        ret2 = free_extent_map_tree(inode);
        if (ret == 0)
@@ -369,7 +369,7 @@ static int __test_case_4(struct btrfs_fs_info *fs_info,
        int ret;
        int ret2;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -388,9 +388,9 @@ static int __test_case_4(struct btrfs_fs_info *fs_info,
                test_err("cannot add extent range [0, 8K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -410,9 +410,9 @@ static int __test_case_4(struct btrfs_fs_info *fs_info,
                test_err("cannot add extent range [8K, 32K)");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -445,7 +445,7 @@ static int __test_case_4(struct btrfs_fs_info *fs_info,
                         em->disk_bytenr, em->disk_num_bytes);
                ret = -EINVAL;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 out:
        ret2 = free_extent_map_tree(inode);
        if (ret == 0)
@@ -498,7 +498,7 @@ static int add_compressed_extent(struct btrfs_inode *inode,
        struct extent_map *em;
        int ret;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -513,7 +513,7 @@ static int add_compressed_extent(struct btrfs_inode *inode,
        write_lock(&em_tree->lock);
        ret = btrfs_add_extent_mapping(inode, &em, em->start, em->len);
        write_unlock(&em_tree->lock);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        if (ret < 0) {
                test_err("cannot add extent map [%llu, %llu)", start, start + len);
                return ret;
@@ -719,7 +719,7 @@ static int test_case_6(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        if (ret)
                goto out;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -751,7 +751,7 @@ static int test_case_6(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        }
        ret = 0;
 out:
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        ret2 = free_extent_map_tree(inode);
        if (ret == 0)
                ret = ret2;
@@ -773,7 +773,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
 
        test_msg("Running btrfs_drop_extent_cache with pinned");
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -793,9 +793,9 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("couldn't add extent map");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -815,7 +815,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                test_err("couldn't add extent map");
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /*
         * Drop [0, 36K) This should skip the [0, 4K) extent and then split the
@@ -842,7 +842,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                goto out;
        }
 
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        read_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, SZ_16K, SZ_16K);
@@ -876,7 +876,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
                goto out;
        }
 
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        read_lock(&em_tree->lock);
        em = lookup_extent_mapping(em_tree, 48 * SZ_1K, (u64)-1);
@@ -888,7 +888,7 @@ static int test_case_7(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
 
        ret = 0;
 out:
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        /* Unpin our extent to prevent warning when removing it below. */
        ret2 = unpin_extent_cache(inode, 0, SZ_16K, 0);
        if (ret == 0)
@@ -913,7 +913,7 @@ static int test_case_8(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        int ret;
        int ret2;
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                return -ENOMEM;
@@ -928,13 +928,13 @@ static int test_case_8(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        write_lock(&em_tree->lock);
        ret = btrfs_add_extent_mapping(inode, &em, em->start, em->len);
        write_unlock(&em_tree->lock);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        if (ret < 0) {
                test_err("couldn't add extent map for range [120K, 128K)");
                goto out;
        }
 
-       em = alloc_extent_map();
+       em = btrfs_alloc_extent_map();
        if (!em) {
                test_std_err(TEST_ALLOC_EXTENT_MAP);
                ret = -ENOMEM;
@@ -967,7 +967,7 @@ static int test_case_8(struct btrfs_fs_info *fs_info, struct btrfs_inode *inode)
        write_lock(&em_tree->lock);
        ret = btrfs_add_extent_mapping(inode, &em, SZ_1K * 140, SZ_4K);
        write_unlock(&em_tree->lock);
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        if (ret < 0) {
                test_err("couldn't add extent map for range [108K, 144K)");
                goto out;

diff --git a/fs/btrfs/tests/inode-tests.c b/fs/btrfs/tests/inode-tests.c
index 1e2118e96ba1390567695e779334108875d13f62..a29d2c02c2c85707bb4a89d2bb8660e251d8dfad 100644 (file)
--- a/fs/btrfs/tests/inode-tests.c
+++ b/fs/btrfs/tests/inode-tests.c
@@ -268,7 +268,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                test_err("expected a hole, got %llu", em->disk_bytenr);
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        btrfs_drop_extent_map_range(BTRFS_I(inode), 0, (u64)-1, false);
 
        /*
@@ -314,7 +314,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
         * this?
         */
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -336,7 +336,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Regular extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -363,7 +363,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* The next 3 are split extents */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -392,7 +392,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
        disk_bytenr = btrfs_extent_map_block_start(em);
        orig_start = em->start;
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -414,7 +414,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -447,7 +447,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Prealloc extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -475,7 +475,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* The next 3 are a half written prealloc extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -505,7 +505,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
        disk_bytenr = btrfs_extent_map_block_start(em);
        orig_start = em->start;
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -537,7 +537,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -570,7 +570,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Now for the compressed extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -603,7 +603,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* Split compressed extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
@@ -638,7 +638,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
        disk_bytenr = btrfs_extent_map_block_start(em);
        orig_start = em->start;
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -664,7 +664,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -698,7 +698,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        /* A hole between regular extents but no hole extent */
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset + 6, sectorsize);
@@ -725,7 +725,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, SZ_4M);
        if (IS_ERR(em)) {
@@ -757,7 +757,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
                goto out;
        }
        offset = em->start + em->len;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, offset, sectorsize);
        if (IS_ERR(em)) {
@@ -785,7 +785,7 @@ static noinline int test_btrfs_get_extent(u32 sectorsize, u32 nodesize)
        ret = 0;
 out:
        if (!IS_ERR(em))
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        iput(inode);
        btrfs_free_dummy_root(root);
        btrfs_free_dummy_fs_info(fs_info);
@@ -858,7 +858,7 @@ static int test_hole_first(u32 sectorsize, u32 nodesize)
                         em->flags);
                goto out;
        }
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
 
        em = btrfs_get_extent(BTRFS_I(inode), NULL, sectorsize, 2 * sectorsize);
        if (IS_ERR(em)) {
@@ -884,7 +884,7 @@ static int test_hole_first(u32 sectorsize, u32 nodesize)
        ret = 0;
 out:
        if (!IS_ERR(em))
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        iput(inode);
        btrfs_free_dummy_root(root);
        btrfs_free_dummy_fs_info(fs_info);

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 88ef4b9c2c1f64cc8f3529ddac8a89c20fa19af5..3d20473a4bc3c1753855d8fd90c5b12b521094cb 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4957,7 +4957,7 @@ process:
                 */
                if (ret) {
                        clear_em_logging(inode, em);
-                       free_extent_map(em);
+                       btrfs_free_extent_map(em);
                        continue;
                }
 
@@ -4966,7 +4966,7 @@ process:
                ret = log_one_extent(trans, inode, em, path, ctx);
                write_lock(&tree->lock);
                clear_em_logging(inode, em);
-               free_extent_map(em);
+               btrfs_free_extent_map(em);
        }
        WARN_ON(!list_empty(&extents));
        write_unlock(&tree->lock);

diff --git a/fs/btrfs/zoned.c b/fs/btrfs/zoned.c
index 4a3e02b49f2957ed7f4cca4335d4b136801e1383..49a74f2b06b633af6df36cc9ee8d3926ed8c2d8d 100644 (file)
--- a/fs/btrfs/zoned.c
+++ b/fs/btrfs/zoned.c
@@ -1802,7 +1802,7 @@ static void btrfs_rewrite_logical_zoned(struct btrfs_ordered_extent *ordered,
        /* The em should be a new COW extent, thus it should not have an offset. */
        ASSERT(em->offset == 0);
        em->disk_bytenr = logical;
-       free_extent_map(em);
+       btrfs_free_extent_map(em);
        write_unlock(&em_tree->lock);
 }