btrfs: rename the functions to init and release an extent io tree

These functions are exported so they should have a 'btrfs_' prefix by
convention, to make it clear they are btrfs specific and to avoid
collisions with functions from elsewhere in the kernel.

So add a 'btrfs_' prefix to their name to make it clear they are from
btrfs.

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/disk-io.c b/fs/btrfs/disk-io.c
index 2586dd05483a177501693f34725d31e20d3581f9..1464e36eceac2d093efb30add5d6ed501ba56f5c 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -691,10 +691,10 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
        btrfs_set_root_last_log_commit(root, 0);
        root->anon_dev = 0;
        if (!dummy) {
-               extent_io_tree_init(fs_info, &root->dirty_log_pages,
-                                   IO_TREE_ROOT_DIRTY_LOG_PAGES);
-               extent_io_tree_init(fs_info, &root->log_csum_range,
-                                   IO_TREE_LOG_CSUM_RANGE);
+               btrfs_extent_io_tree_init(fs_info, &root->dirty_log_pages,
+                                         IO_TREE_ROOT_DIRTY_LOG_PAGES);
+               btrfs_extent_io_tree_init(fs_info, &root->log_csum_range,
+                                         IO_TREE_LOG_CSUM_RANGE);
        }
 
        spin_lock_init(&root->root_item_lock);
@@ -1920,8 +1920,8 @@ static int btrfs_init_btree_inode(struct super_block *sb)
        inode->i_mapping->a_ops = &btree_aops;
        mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 
-       extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
-                           IO_TREE_BTREE_INODE_IO);
+       btrfs_extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
+                                 IO_TREE_BTREE_INODE_IO);
        extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
 
        BTRFS_I(inode)->root = btrfs_grab_root(fs_info->tree_root);
@@ -2855,8 +2855,8 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
        rwlock_init(&fs_info->block_group_cache_lock);
        fs_info->block_group_cache_tree = RB_ROOT_CACHED;
 
-       extent_io_tree_init(fs_info, &fs_info->excluded_extents,
-                           IO_TREE_FS_EXCLUDED_EXTENTS);
+       btrfs_extent_io_tree_init(fs_info, &fs_info->excluded_extents,
+                                 IO_TREE_FS_EXCLUDED_EXTENTS);
 
        mutex_init(&fs_info->ordered_operations_mutex);
        mutex_init(&fs_info->tree_log_mutex);

diff --git a/fs/btrfs/extent-io-tree.c b/fs/btrfs/extent-io-tree.c
index 6330071cc73f92afc612f821b945c900cdaaffeb..4b9f18a121542b07f664caff332d6b6a8e345524 100644 (file)
--- a/fs/btrfs/extent-io-tree.c
+++ b/fs/btrfs/extent-io-tree.c
@@ -95,8 +95,8 @@ const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info(const struct extent_
        return tree->fs_info;
 }
 
-void extent_io_tree_init(struct btrfs_fs_info *fs_info,
-                        struct extent_io_tree *tree, unsigned int owner)
+void btrfs_extent_io_tree_init(struct btrfs_fs_info *fs_info,
+                              struct extent_io_tree *tree, unsigned int owner)
 {
        tree->state = RB_ROOT;
        spin_lock_init(&tree->lock);
@@ -111,7 +111,7 @@ void extent_io_tree_init(struct btrfs_fs_info *fs_info,
  * aren't any waiters on any extent state record (EXTENT_LOCK_BITS are never
  * set on any extent state when calling this function).
  */
-void extent_io_tree_release(struct extent_io_tree *tree)
+void btrfs_extent_io_tree_release(struct extent_io_tree *tree)
 {
        struct rb_root root;
        struct extent_state *state;

diff --git a/fs/btrfs/extent-io-tree.h b/fs/btrfs/extent-io-tree.h
index 361d27c6b294f25e871f71122c5e496e8d721a93..85eeee4ac613def7f85037667ffd39f046257739 100644 (file)
--- a/fs/btrfs/extent-io-tree.h
+++ b/fs/btrfs/extent-io-tree.h
@@ -137,9 +137,9 @@ struct extent_state {
 const struct btrfs_inode *btrfs_extent_io_tree_to_inode(const struct extent_io_tree *tree);
 const struct btrfs_fs_info *btrfs_extent_io_tree_to_fs_info(const struct extent_io_tree *tree);
 
-void extent_io_tree_init(struct btrfs_fs_info *fs_info,
-                        struct extent_io_tree *tree, unsigned int owner);
-void extent_io_tree_release(struct extent_io_tree *tree);
+void btrfs_extent_io_tree_init(struct btrfs_fs_info *fs_info,
+                              struct extent_io_tree *tree, unsigned int owner);
+void btrfs_extent_io_tree_release(struct extent_io_tree *tree);
 int btrfs_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, u32 bits,
                           struct extent_state **cached);
 bool btrfs_try_lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end,

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index b65e17dfaf177af583e094a285c967dbeaad7018..ea16571ea8fc19bb582cc9d0a4ff691cff9946db 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -3815,7 +3815,8 @@ static int btrfs_init_file_extent_tree(struct btrfs_inode *inode)
        if (!inode->file_extent_tree)
                return -ENOMEM;
 
-       extent_io_tree_init(fs_info, inode->file_extent_tree, IO_TREE_INODE_FILE_EXTENT);
+       btrfs_extent_io_tree_init(fs_info, inode->file_extent_tree,
+                                 IO_TREE_INODE_FILE_EXTENT);
        /* Lockdep class is set only for the file extent tree. */
        lockdep_set_class(&inode->file_extent_tree->lock, &file_extent_tree_class);
 
@@ -7743,7 +7744,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
        extent_map_tree_init(&ei->extent_tree);
 
        /* This io tree sets the valid inode. */
-       extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);
+       btrfs_extent_io_tree_init(fs_info, &ei->io_tree, IO_TREE_INODE_IO);
        ei->io_tree.inode = ei;
 
        ei->file_extent_tree = NULL;

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index b996fb0ee374d572b2a1d352e4ee3f573d23a92e..0a5a48aa58cc8ff85058188489eef5c55287f805 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3860,7 +3860,7 @@ static struct reloc_control *alloc_reloc_control(struct btrfs_fs_info *fs_info)
        btrfs_backref_init_cache(fs_info, &rc->backref_cache, true);
        rc->reloc_root_tree.rb_root = RB_ROOT;
        spin_lock_init(&rc->reloc_root_tree.lock);
-       extent_io_tree_init(fs_info, &rc->processed_blocks, IO_TREE_RELOC_BLOCKS);
+       btrfs_extent_io_tree_init(fs_info, &rc->processed_blocks, IO_TREE_RELOC_BLOCKS);
        return rc;
 }
 

diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c
index 5eff8d7d236053b08fd6fd1a9365b761e56c012a..02a915eb51fb316b4a34d5dbc73da88f0f7914ea 100644 (file)
--- a/fs/btrfs/tests/btrfs-tests.c
+++ b/fs/btrfs/tests/btrfs-tests.c
@@ -102,7 +102,7 @@ struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)
        if (!dev)
                return ERR_PTR(-ENOMEM);
 
-       extent_io_tree_init(fs_info, &dev->alloc_state, 0);
+       btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, 0);
        INIT_LIST_HEAD(&dev->dev_list);
        list_add(&dev->dev_list, &fs_info->fs_devices->devices);
 
@@ -111,7 +111,7 @@ struct btrfs_device *btrfs_alloc_dummy_device(struct btrfs_fs_info *fs_info)
 
 static void btrfs_free_dummy_device(struct btrfs_device *dev)
 {
-       extent_io_tree_release(&dev->alloc_state);
+       btrfs_extent_io_tree_release(&dev->alloc_state);
        kfree(dev);
 }
 

diff --git a/fs/btrfs/tests/extent-io-tests.c b/fs/btrfs/tests/extent-io-tests.c
index 3d59e002c161b1d694b92f2952621f52582a44b7..6d1f8d62c5a08ad597afd07fd20d4c5124eb68d5 100644 (file)
--- a/fs/btrfs/tests/extent-io-tests.c
+++ b/fs/btrfs/tests/extent-io-tests.c
@@ -149,7 +149,7 @@ static int test_find_delalloc(u32 sectorsize, u32 nodesize)
         * Passing NULL as we don't have fs_info but tracepoints are not used
         * at this point
         */
-       extent_io_tree_init(NULL, tmp, IO_TREE_SELFTEST);
+       btrfs_extent_io_tree_init(NULL, tmp, IO_TREE_SELFTEST);
 
        /*
         * First go through and create and mark all of our pages dirty, we pin
@@ -564,7 +564,7 @@ static int test_find_first_clear_extent_bit(void)
 
        test_msg("running find_first_clear_extent_bit test");
 
-       extent_io_tree_init(NULL, &tree, IO_TREE_SELFTEST);
+       btrfs_extent_io_tree_init(NULL, &tree, IO_TREE_SELFTEST);
 
        /* Test correct handling of empty tree */
        btrfs_find_first_clear_extent_bit(&tree, 0, &start, &end, CHUNK_TRIMMED);

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 8fa9af18e4833fd874902bfc3cebb1b4385bfd92..c640e80d2a20b95dd6eb90316280b423c5baa790 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -197,7 +197,7 @@ static noinline void switch_commit_roots(struct btrfs_trans_handle *trans)
                list_del_init(&root->dirty_list);
                free_extent_buffer(root->commit_root);
                root->commit_root = btrfs_root_node(root);
-               extent_io_tree_release(&root->dirty_log_pages);
+               btrfs_extent_io_tree_release(&root->dirty_log_pages);
                btrfs_qgroup_clean_swapped_blocks(root);
        }
 
@@ -383,10 +383,10 @@ loop:
        INIT_LIST_HEAD(&cur_trans->deleted_bgs);
        spin_lock_init(&cur_trans->dropped_roots_lock);
        list_add_tail(&cur_trans->list, &fs_info->trans_list);
-       extent_io_tree_init(fs_info, &cur_trans->dirty_pages,
-                       IO_TREE_TRANS_DIRTY_PAGES);
-       extent_io_tree_init(fs_info, &cur_trans->pinned_extents,
-                       IO_TREE_FS_PINNED_EXTENTS);
+       btrfs_extent_io_tree_init(fs_info, &cur_trans->dirty_pages,
+                                 IO_TREE_TRANS_DIRTY_PAGES);
+       btrfs_extent_io_tree_init(fs_info, &cur_trans->pinned_extents,
+                                 IO_TREE_FS_PINNED_EXTENTS);
        btrfs_set_fs_generation(fs_info, fs_info->generation + 1);
        cur_trans->transid = fs_info->generation;
        fs_info->running_transaction = cur_trans;
@@ -1265,7 +1265,7 @@ static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans)
        blk_finish_plug(&plug);
        ret2 = btrfs_wait_extents(fs_info, dirty_pages);
 
-       extent_io_tree_release(&trans->transaction->dirty_pages);
+       btrfs_extent_io_tree_release(&trans->transaction->dirty_pages);
 
        if (ret)
                return ret;

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 31087b69d68f391ae58029dbae2b60f211e153e2..856ec4431ce28354c0fd6b3fdff83f0264d8db66 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -3251,8 +3251,8 @@ static void free_log_tree(struct btrfs_trans_handle *trans,
                }
        }
 
-       extent_io_tree_release(&log->dirty_log_pages);
-       extent_io_tree_release(&log->log_csum_range);
+       btrfs_extent_io_tree_release(&log->dirty_log_pages);
+       btrfs_extent_io_tree_release(&log->log_csum_range);
 
        btrfs_put_root(log);
 }

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 8eb20fba052e79efd2a080deb9da65d7e376d94d..af9bbfe7d4ea48275550cfaa814249e3a2ce2a7d 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -404,7 +404,7 @@ static void btrfs_free_device(struct btrfs_device *device)
 {
        WARN_ON(!list_empty(&device->post_commit_list));
        rcu_string_free(device->name);
-       extent_io_tree_release(&device->alloc_state);
+       btrfs_extent_io_tree_release(&device->alloc_state);
        btrfs_destroy_dev_zone_info(device);
        kfree(device);
 }
@@ -1149,7 +1149,7 @@ static void btrfs_close_one_device(struct btrfs_device *device)
 
        device->fs_info = NULL;
        atomic_set(&device->dev_stats_ccnt, 0);
-       extent_io_tree_release(&device->alloc_state);
+       btrfs_extent_io_tree_release(&device->alloc_state);
 
        /*
         * Reset the flush error record. We might have a transient flush error
@@ -6863,7 +6863,7 @@ struct btrfs_device *btrfs_alloc_device(struct btrfs_fs_info *fs_info,
 
        atomic_set(&dev->dev_stats_ccnt, 0);
        btrfs_device_data_ordered_init(dev);
-       extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE);
+       btrfs_extent_io_tree_init(fs_info, &dev->alloc_state, IO_TREE_DEVICE_ALLOC_STATE);
 
        if (devid)
                tmp = *devid;