btrfs: rename btrfs_put_fs_root and btrfs_grab_fs_root

We are now using these for all roots, rename them to btrfs_put_root()
and btrfs_grab_root();

Signed-off-by: Josef Bacik <josef@toxicpanda.com>

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index b69154d7252990efb10e5b8dd6c9bfbcbf56875c..ded46efac27de426758880bd093aba2e22a5a50d 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -577,7 +577,7 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info,
        ret = add_all_parents(root, path, parents, ref, level, time_seq,
                              extent_item_pos, total_refs, ignore_offset);
 out:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 out_free:
        path->lowest_level = 0;
        btrfs_release_path(path);

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index c8335ef31e091afd6f754b312262b8087d998ea3..8b8137f2a069dfb938a5bd53dbbc436efaa5056a 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1313,7 +1313,7 @@ fail:
                free_extent_buffer(root->commit_root);
                free_extent_buffer(leaf);
        }
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 
        return ERR_PTR(ret);
 }
@@ -1344,7 +1344,7 @@ static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
        leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
                        NULL, 0, 0, 0);
        if (IS_ERR(leaf)) {
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                return ERR_CAST(leaf);
        }
 
@@ -1448,7 +1448,7 @@ out:
        return root;
 
 find_fail:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 alloc_fail:
        root = ERR_PTR(ret);
        goto out;
@@ -1514,7 +1514,7 @@ static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
        root = radix_tree_lookup(&fs_info->fs_roots_radix,
                                 (unsigned long)root_id);
        if (root)
-               root = btrfs_grab_fs_root(root);
+               root = btrfs_grab_root(root);
        spin_unlock(&fs_info->fs_roots_radix_lock);
        return root;
 }
@@ -1533,7 +1533,7 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
                                (unsigned long)root->root_key.objectid,
                                root);
        if (ret == 0) {
-               btrfs_grab_fs_root(root);
+               btrfs_grab_root(root);
                set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
        }
        spin_unlock(&fs_info->fs_roots_radix_lock);
@@ -1561,8 +1561,8 @@ static void btrfs_check_leaked_roots(struct btrfs_fs_info *fs_info)
                          root->root_key.objectid, root->root_key.offset,
                          refcount_read(&root->refs));
                while (refcount_read(&root->refs) > 1)
-                       btrfs_put_fs_root(root);
-               btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
+               btrfs_put_root(root);
        }
 #endif
 }
@@ -1578,15 +1578,15 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
        btrfs_free_ref_cache(fs_info);
        kfree(fs_info->balance_ctl);
        kfree(fs_info->delayed_root);
-       btrfs_put_fs_root(fs_info->extent_root);
-       btrfs_put_fs_root(fs_info->tree_root);
-       btrfs_put_fs_root(fs_info->chunk_root);
-       btrfs_put_fs_root(fs_info->dev_root);
-       btrfs_put_fs_root(fs_info->csum_root);
-       btrfs_put_fs_root(fs_info->quota_root);
-       btrfs_put_fs_root(fs_info->uuid_root);
-       btrfs_put_fs_root(fs_info->free_space_root);
-       btrfs_put_fs_root(fs_info->fs_root);
+       btrfs_put_root(fs_info->extent_root);
+       btrfs_put_root(fs_info->tree_root);
+       btrfs_put_root(fs_info->chunk_root);
+       btrfs_put_root(fs_info->dev_root);
+       btrfs_put_root(fs_info->csum_root);
+       btrfs_put_root(fs_info->quota_root);
+       btrfs_put_root(fs_info->uuid_root);
+       btrfs_put_root(fs_info->free_space_root);
+       btrfs_put_root(fs_info->fs_root);
        btrfs_check_leaked_roots(fs_info);
        kfree(fs_info->super_copy);
        kfree(fs_info->super_for_commit);
@@ -1604,29 +1604,29 @@ struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
        int ret;
 
        if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->tree_root);
+               return btrfs_grab_root(fs_info->tree_root);
        if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->extent_root);
+               return btrfs_grab_root(fs_info->extent_root);
        if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->chunk_root);
+               return btrfs_grab_root(fs_info->chunk_root);
        if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->dev_root);
+               return btrfs_grab_root(fs_info->dev_root);
        if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->csum_root);
+               return btrfs_grab_root(fs_info->csum_root);
        if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->quota_root) ?
+               return btrfs_grab_root(fs_info->quota_root) ?
                        fs_info->quota_root : ERR_PTR(-ENOENT);
        if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->uuid_root) ?
+               return btrfs_grab_root(fs_info->uuid_root) ?
                        fs_info->uuid_root : ERR_PTR(-ENOENT);
        if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
-               return btrfs_grab_fs_root(fs_info->free_space_root) ?
+               return btrfs_grab_root(fs_info->free_space_root) ?
                        fs_info->free_space_root : ERR_PTR(-ENOENT);
 again:
        root = btrfs_lookup_fs_root(fs_info, location->objectid);
        if (root) {
                if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
-                       btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
                        return ERR_PTR(-ENOENT);
                }
                return root;
@@ -1669,10 +1669,10 @@ again:
         * we have the third for returning it, and the caller will put it when
         * it's done with the root.
         */
-       btrfs_grab_fs_root(root);
+       btrfs_grab_root(root);
        ret = btrfs_insert_fs_root(fs_info, root);
        if (ret) {
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                if (ret == -EEXIST) {
                        btrfs_free_fs_root(root);
                        goto again;
@@ -2072,7 +2072,7 @@ void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
                } else {
                        free_extent_buffer(gang[0]->node);
                        free_extent_buffer(gang[0]->commit_root);
-                       btrfs_put_fs_root(gang[0]);
+                       btrfs_put_root(gang[0]);
                }
        }
 
@@ -2277,12 +2277,12 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
        if (IS_ERR(log_tree_root->node)) {
                btrfs_warn(fs_info, "failed to read log tree");
                ret = PTR_ERR(log_tree_root->node);
-               btrfs_put_fs_root(log_tree_root);
+               btrfs_put_root(log_tree_root);
                return ret;
        } else if (!extent_buffer_uptodate(log_tree_root->node)) {
                btrfs_err(fs_info, "failed to read log tree");
                free_extent_buffer(log_tree_root->node);
-               btrfs_put_fs_root(log_tree_root);
+               btrfs_put_root(log_tree_root);
                return -EIO;
        }
        /* returns with log_tree_root freed on success */
@@ -2291,7 +2291,7 @@ static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
                btrfs_handle_fs_error(fs_info, ret,
                                      "Failed to recover log tree");
                free_extent_buffer(log_tree_root->node);
-               btrfs_put_fs_root(log_tree_root);
+               btrfs_put_root(log_tree_root);
                return ret;
        }
 
@@ -3889,7 +3889,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
        radix_tree_delete(&fs_info->fs_roots_radix,
                          (unsigned long)root->root_key.objectid);
        if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
        spin_unlock(&fs_info->fs_roots_radix_lock);
 
        if (btrfs_root_refs(&root->root_item) == 0)
@@ -3900,7 +3900,7 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
                if (root->reloc_root) {
                        free_extent_buffer(root->reloc_root->node);
                        free_extent_buffer(root->reloc_root->commit_root);
-                       btrfs_put_fs_root(root->reloc_root);
+                       btrfs_put_root(root->reloc_root);
                        root->reloc_root = NULL;
                }
        }
@@ -3924,7 +3924,7 @@ void btrfs_free_fs_root(struct btrfs_root *root)
        free_extent_buffer(root->commit_root);
        kfree(root->free_ino_ctl);
        kfree(root->free_ino_pinned);
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 }
 
 int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
@@ -3954,7 +3954,7 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
                                continue;
                        }
                        /* grab all the search result for later use */
-                       gang[i] = btrfs_grab_fs_root(gang[i]);
+                       gang[i] = btrfs_grab_root(gang[i]);
                }
                srcu_read_unlock(&fs_info->subvol_srcu, index);
 
@@ -3965,7 +3965,7 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
                        err = btrfs_orphan_cleanup(gang[i]);
                        if (err)
                                break;
-                       btrfs_put_fs_root(gang[i]);
+                       btrfs_put_root(gang[i]);
                }
                root_objectid++;
        }
@@ -3973,7 +3973,7 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
        /* release the uncleaned roots due to error */
        for (; i < ret; i++) {
                if (gang[i])
-                       btrfs_put_fs_root(gang[i]);
+                       btrfs_put_root(gang[i]);
        }
        return err;
 }
@@ -4362,12 +4362,12 @@ static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
        while (!list_empty(&splice)) {
                root = list_first_entry(&splice, struct btrfs_root,
                                         delalloc_root);
-               root = btrfs_grab_fs_root(root);
+               root = btrfs_grab_root(root);
                BUG_ON(!root);
                spin_unlock(&fs_info->delalloc_root_lock);
 
                btrfs_destroy_delalloc_inodes(root);
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
 
                spin_lock(&fs_info->delalloc_root_lock);
        }

diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index d2022c41d8d98b0dd1f6f34eaf005a31ad6e159d..e4d23a03929917b0b6f1dc103ffcf524d2edf403 100644 (file)
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -87,7 +87,7 @@ struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info);
  * If you want to ensure the whole tree is safe, you should use
  *     fs_info->subvol_srcu
  */
-static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)
+static inline struct btrfs_root *btrfs_grab_root(struct btrfs_root *root)
 {
        if (!root)
                return NULL;
@@ -96,7 +96,7 @@ static inline struct btrfs_root *btrfs_grab_fs_root(struct btrfs_root *root)
        return NULL;
 }
 
-static inline void btrfs_put_fs_root(struct btrfs_root *root)
+static inline void btrfs_put_root(struct btrfs_root *root)
 {
        if (!root)
                return;

diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index f07c2300ade223e9d56ae5d235ef77e7106851af..657fd6ad6e1860bea09b9fc73d00f803c27a4724 100644 (file)
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -88,7 +88,7 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
        key.offset = 0;
 
        inode = btrfs_iget(sb, &key, root);
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                goto fail;

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 18df434bfe52f265aaf6800d63a0aafb810e5a66..04ad2100ecc17fc84b1e13d85630243916cd940d 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -5415,7 +5415,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
        } else {
                free_extent_buffer(root->node);
                free_extent_buffer(root->commit_root);
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
        }
        root_dropped = true;
 out_end_trans:

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 062580a1721f3b74ae30705b052dd8a093b9bab4..254fa3cc1ba7770154a6e638df947bb6ce7bb759 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -297,7 +297,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
        key.type = BTRFS_INODE_ITEM_KEY;
        key.offset = 0;
        inode = btrfs_iget(fs_info->sb, &key, inode_root);
-       btrfs_put_fs_root(inode_root);
+       btrfs_put_root(inode_root);
        if (IS_ERR(inode)) {
                ret = PTR_ERR(inode);
                goto cleanup;

diff --git a/fs/btrfs/free-space-tree.c b/fs/btrfs/free-space-tree.c
index c79804c30b1738c1d6e4a528e88ca323d4a924b6..bc43950eb32f08cfe1afaec94012097804dbef4f 100644 (file)
--- a/fs/btrfs/free-space-tree.c
+++ b/fs/btrfs/free-space-tree.c
@@ -1253,7 +1253,7 @@ int btrfs_clear_free_space_tree(struct btrfs_fs_info *fs_info)
 
        free_extent_buffer(free_space_root->node);
        free_extent_buffer(free_space_root->commit_root);
-       btrfs_put_fs_root(free_space_root);
+       btrfs_put_root(free_space_root);
 
        return btrfs_commit_transaction(trans);
 

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index bc961ca6995f421f98199b90a67aef8e8e554481..bbb8a9641a6df4bc6c038588fa09b6b487a70c5b 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2533,7 +2533,7 @@ static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
 
        ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
        if (WARN_ON(ret < 0)) {
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                return ret;
        }
        ret = 0;
@@ -2605,7 +2605,7 @@ static noinline int record_one_backref(u64 inum, u64 offset, u64 root_id,
        backref_insert(&new->root, backref);
        old->count++;
 out:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        btrfs_release_path(path);
        WARN_ON(ret);
        return ret;
@@ -2720,7 +2720,7 @@ static noinline int relink_extent_backref(struct btrfs_path *path,
        key.offset = 0;
 
        inode = btrfs_iget(fs_info->sb, &key, root);
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        if (IS_ERR(inode)) {
                srcu_read_unlock(&fs_info->subvol_srcu, index);
                return 0;
@@ -5923,7 +5923,7 @@ struct inode *btrfs_lookup_dentry(struct inode *dir, struct dentry *dentry)
                inode = btrfs_iget(dir->i_sb, &location, sub_root);
        }
        if (root != sub_root)
-               btrfs_put_fs_root(sub_root);
+               btrfs_put_root(sub_root);
        srcu_read_unlock(&fs_info->subvol_srcu, index);
 
        if (!IS_ERR(inode) && root != sub_root) {
@@ -10257,14 +10257,14 @@ int btrfs_start_delalloc_roots(struct btrfs_fs_info *fs_info, int nr)
        while (!list_empty(&splice) && nr) {
                root = list_first_entry(&splice, struct btrfs_root,
                                        delalloc_root);
-               root = btrfs_grab_fs_root(root);
+               root = btrfs_grab_root(root);
                BUG_ON(!root);
                list_move_tail(&root->delalloc_root,
                               &fs_info->delalloc_roots);
                spin_unlock(&fs_info->delalloc_root_lock);
 
                ret = start_delalloc_inodes(root, nr, false);
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                if (ret < 0)
                        goto out;
 

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 7df2576aa2e348e3c7e7c4bcec6f15db326d8036..8ec61f3f02918b9ceb4dd82b0de6f1df0cf63873 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -676,7 +676,7 @@ static noinline int create_subvol(struct inode *dir,
        btrfs_record_root_in_trans(trans, new_root);
 
        ret = btrfs_create_subvol_root(trans, new_root, root, new_dirid);
-       btrfs_put_fs_root(new_root);
+       btrfs_put_root(new_root);
        if (ret) {
                /* We potentially lose an unused inode item here */
                btrfs_abort_transaction(trans, ret);
@@ -870,7 +870,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
        d_instantiate(dentry, inode);
        ret = 0;
 fail:
-       btrfs_put_fs_root(pending_snapshot->snap);
+       btrfs_put_root(pending_snapshot->snap);
        btrfs_subvolume_release_metadata(fs_info, &pending_snapshot->block_rsv);
 dec_and_free:
        if (snapshot_force_cow)
@@ -2176,7 +2176,7 @@ static noinline int search_ioctl(struct inode *inode,
 
        if (sk->tree_id == 0) {
                /* search the root of the inode that was passed */
-               root = btrfs_grab_fs_root(BTRFS_I(inode)->root);
+               root = btrfs_grab_root(BTRFS_I(inode)->root);
        } else {
                key.objectid = sk->tree_id;
                key.type = BTRFS_ROOT_ITEM_KEY;
@@ -2210,7 +2210,7 @@ static noinline int search_ioctl(struct inode *inode,
                ret = 0;
 err:
        sk->nr_items = num_found;
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        btrfs_free_path(path);
        return ret;
 }
@@ -2372,7 +2372,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
        ret = 0;
 out:
        if (root)
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
        btrfs_free_path(path);
        return ret;
 }
@@ -2500,7 +2500,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,
 
                memmove(args->path, ptr, total_len);
                args->path[total_len] = '\0';
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                btrfs_release_path(path);
        }
 
@@ -2540,7 +2540,7 @@ out:
        btrfs_free_path(path);
        return ret;
 out_put:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        goto out;
 }
 
@@ -2743,7 +2743,7 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp)
                ret = -EFAULT;
 
 out:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 out_free:
        btrfs_free_path(path);
        kzfree(subvol_info);
@@ -4041,7 +4041,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
        btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);
        btrfs_end_transaction(trans);
 out_free:
-       btrfs_put_fs_root(new_root);
+       btrfs_put_root(new_root);
        btrfs_free_path(path);
 out:
        mnt_drop_write_file(file);

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 6240a5a1f2c06e43ab2ce7f37848497a0e651228..3a3c648bb9d3152f47278f88d3b4a7fabbdcfc18 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -588,7 +588,7 @@ u64 btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,
        while (!list_empty(&splice) && nr) {
                root = list_first_entry(&splice, struct btrfs_root,
                                        ordered_root);
-               root = btrfs_grab_fs_root(root);
+               root = btrfs_grab_root(root);
                BUG_ON(!root);
                list_move_tail(&root->ordered_root,
                               &fs_info->ordered_roots);
@@ -596,7 +596,7 @@ u64 btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, u64 nr,
 
                done = btrfs_wait_ordered_extents(root, nr,
                                                  range_start, range_len);
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                total_done += done;
 
                spin_lock(&fs_info->ordered_root_lock);

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 762f254b4b38c0f1464b4979c9b98ab1a7395908..8fb576495be9f69ca4ae47532bd71ca92c1942ef 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -1040,7 +1040,7 @@ out_free_root:
        if (ret) {
                free_extent_buffer(quota_root->node);
                free_extent_buffer(quota_root->commit_root);
-               btrfs_put_fs_root(quota_root);
+               btrfs_put_root(quota_root);
        }
 out:
        if (ret) {
@@ -1106,7 +1106,7 @@ int btrfs_quota_disable(struct btrfs_fs_info *fs_info)
 
        free_extent_buffer(quota_root->node);
        free_extent_buffer(quota_root->commit_root);
-       btrfs_put_fs_root(quota_root);
+       btrfs_put_root(quota_root);
 
 end_trans:
        ret = btrfs_end_transaction(trans);

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index f6d63d6cf22d9156b60ae4eb5657061c87535600..754f18e8019baa97454b508d2b37558ef5e336e2 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -257,7 +257,7 @@ static void free_backref_node(struct backref_cache *cache,
        if (node) {
                cache->nr_nodes--;
                if (node->root)
-                       btrfs_put_fs_root(node->root);
+                       btrfs_put_root(node->root);
                kfree(node);
        }
 }
@@ -870,7 +870,7 @@ again:
                        ASSERT(btrfs_root_bytenr(&root->root_item) ==
                               cur->bytenr);
                        if (should_ignore_root(root)) {
-                               btrfs_put_fs_root(root);
+                               btrfs_put_root(root);
                                list_add(&cur->list, &useless);
                        } else {
                                cur->root = root;
@@ -887,7 +887,7 @@ again:
                ret = btrfs_search_slot(NULL, root, node_key, path2, 0, 0);
                path2->lowest_level = 0;
                if (ret < 0) {
-                       btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
                        err = ret;
                        goto out;
                }
@@ -903,7 +903,7 @@ again:
                                  root->root_key.objectid,
                                  node_key->objectid, node_key->type,
                                  node_key->offset);
-                       btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
                        err = -ENOENT;
                        goto out;
                }
@@ -916,7 +916,7 @@ again:
                                ASSERT(btrfs_root_bytenr(&root->root_item) ==
                                       lower->bytenr);
                                if (should_ignore_root(root)) {
-                                       btrfs_put_fs_root(root);
+                                       btrfs_put_root(root);
                                        list_add(&lower->list, &useless);
                                } else {
                                        lower->root = root;
@@ -926,7 +926,7 @@ again:
 
                        edge = alloc_backref_edge(cache);
                        if (!edge) {
-                               btrfs_put_fs_root(root);
+                               btrfs_put_root(root);
                                err = -ENOMEM;
                                goto out;
                        }
@@ -936,7 +936,7 @@ again:
                        if (!rb_node) {
                                upper = alloc_backref_node(cache);
                                if (!upper) {
-                                       btrfs_put_fs_root(root);
+                                       btrfs_put_root(root);
                                        free_backref_edge(cache, edge);
                                        err = -ENOMEM;
                                        goto out;
@@ -985,7 +985,7 @@ again:
                        edge->node[UPPER] = upper;
 
                        if (rb_node) {
-                               btrfs_put_fs_root(root);
+                               btrfs_put_root(root);
                                break;
                        }
                        lower = upper;
@@ -1224,7 +1224,7 @@ static int clone_backref_node(struct btrfs_trans_handle *trans,
        new_node->level = node->level;
        new_node->lowest = node->lowest;
        new_node->checked = 1;
-       new_node->root = btrfs_grab_fs_root(dest);
+       new_node->root = btrfs_grab_root(dest);
        ASSERT(new_node->root);
 
        if (!node->lowest) {
@@ -2189,7 +2189,7 @@ static void insert_dirty_subvol(struct btrfs_trans_handle *trans,
        btrfs_update_reloc_root(trans, root);
 
        if (list_empty(&root->reloc_dirty_list)) {
-               btrfs_grab_fs_root(root);
+               btrfs_grab_root(root);
                list_add_tail(&root->reloc_dirty_list, &rc->dirty_subvol_roots);
        }
 }
@@ -2216,7 +2216,7 @@ static int clean_dirty_subvols(struct reloc_control *rc)
                                        ret = ret2;
                        }
                        clear_bit(BTRFS_ROOT_DEAD_RELOC_TREE, &root->state);
-                       btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
                } else {
                        /* Orphan reloc tree, just clean it up */
                        ret2 = btrfs_drop_snapshot(root, NULL, 0, 1);
@@ -2441,7 +2441,7 @@ again:
                btrfs_update_reloc_root(trans, root);
 
                list_add(&reloc_root->root_list, &reloc_roots);
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
        }
 
        list_splice(&reloc_roots, &rc->reloc_roots);
@@ -2503,7 +2503,7 @@ again:
                        BUG_ON(root->reloc_root != reloc_root);
 
                        ret = merge_reloc_root(rc, root);
-                       btrfs_put_fs_root(root);
+                       btrfs_put_root(root);
                        if (ret) {
                                if (list_empty(&reloc_root->root_list))
                                        list_add_tail(&reloc_root->root_list,
@@ -2564,7 +2564,7 @@ static int record_reloc_root_in_trans(struct btrfs_trans_handle *trans,
        BUG_ON(IS_ERR(root));
        BUG_ON(root->reloc_root != reloc_root);
        ret = btrfs_record_root_in_trans(trans, root);
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 
        return ret;
 }
@@ -2599,8 +2599,8 @@ struct btrfs_root *select_reloc_root(struct btrfs_trans_handle *trans,
                        BUG_ON(next->new_bytenr);
                        BUG_ON(!list_empty(&next->list));
                        next->new_bytenr = root->node->start;
-                       btrfs_put_fs_root(next->root);
-                       next->root = btrfs_grab_fs_root(root);
+                       btrfs_put_root(next->root);
+                       next->root = btrfs_grab_root(root);
                        ASSERT(next->root);
                        list_add_tail(&next->list,
                                      &rc->backref_cache.changed);
@@ -3073,8 +3073,8 @@ static int relocate_tree_block(struct btrfs_trans_handle *trans,
                        btrfs_record_root_in_trans(trans, root);
                        root = root->reloc_root;
                        node->new_bytenr = root->node->start;
-                       btrfs_put_fs_root(node->root);
-                       node->root = btrfs_grab_fs_root(root);
+                       btrfs_put_root(node->root);
+                       node->root = btrfs_grab_root(root);
                        ASSERT(node->root);
                        list_add_tail(&node->list, &rc->backref_cache.changed);
                } else {
@@ -3772,7 +3772,7 @@ next:
 
        }
 out:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
 out_free:
        btrfs_free_path(path);
        return err;
@@ -4258,7 +4258,7 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
 
        trans = btrfs_start_transaction(root, 6);
        if (IS_ERR(trans)) {
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
                return ERR_CAST(trans);
        }
 
@@ -4278,7 +4278,7 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
 
        err = btrfs_orphan_add(trans, BTRFS_I(inode));
 out:
-       btrfs_put_fs_root(root);
+       btrfs_put_root(root);
        btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
        if (err) {
@@ -4538,7 +4538,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
                                        goto out;
                                }
                        } else {
-                               btrfs_put_fs_root(fs_root);
+                               btrfs_put_root(fs_root);
                        }
                }
 
@@ -4592,7 +4592,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
                err = __add_reloc_root(reloc_root);
                BUG_ON(err < 0); /* -ENOMEM or logic error */
                fs_root->reloc_root = reloc_root;
-               btrfs_put_fs_root(fs_root);
+               btrfs_put_root(fs_root);
        }
 
        err = btrfs_commit_transaction(trans);
@@ -4628,7 +4628,7 @@ out:
                        err = PTR_ERR(fs_root);
                } else {
                        err = btrfs_orphan_cleanup(fs_root);
-                       btrfs_put_fs_root(fs_root);
+                       btrfs_put_root(fs_root);
                }
        }
        return err;

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 2c94b5318b402026f820dcdd396aef4c9178c7c8..0a455f116666f5b760335247a39f95e9420dfd1e 100644 (file)
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -288,7 +288,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
                        set_bit(BTRFS_ROOT_DEAD_TREE, &root->state);
                        btrfs_add_dead_root(root);
                }
-               btrfs_put_fs_root(root);
+               btrfs_put_root(root);
        }
 
        btrfs_free_path(path);

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 0c8b60055c2e430f13d4faa9987eb78e1169973d..53261bf04c11370dd8b11e661ceabc56f0bb7693 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -667,7 +667,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
 
        ret = btrfs_search_slot(NULL, local_root, &key, swarn->path, 0, 0);
        if (ret) {
-               btrfs_put_fs_root(local_root);
+               btrfs_put_root(local_root);
                btrfs_release_path(swarn->path);
                goto err;
        }
@@ -688,7 +688,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
        ipath = init_ipath(4096, local_root, swarn->path);
        memalloc_nofs_restore(nofs_flag);
        if (IS_ERR(ipath)) {
-               btrfs_put_fs_root(local_root);
+               btrfs_put_root(local_root);
                ret = PTR_ERR(ipath);
                ipath = NULL;
                goto err;
@@ -712,7 +712,7 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
                                  min(isize - offset, (u64)PAGE_SIZE), nlink,
                                  (char *)(unsigned long)ipath->fspath->val[i]);
 
-       btrfs_put_fs_root(local_root);
+       btrfs_put_root(local_root);
        free_ipath(ipath);
        return 0;
 

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 6520ad8f4e81ee5b3f71b5c8bdfc6ed3b5770ee6..a7041f2701407c8249689429f5c48e978f0e88be 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -7211,7 +7211,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
                            btrfs_root_dead(clone_root)) {
                                spin_unlock(&clone_root->root_item_lock);
                                srcu_read_unlock(&fs_info->subvol_srcu, index);
-                               btrfs_put_fs_root(clone_root);
+                               btrfs_put_root(clone_root);
                                ret = -EPERM;
                                goto out;
                        }
@@ -7219,7 +7219,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
                                dedupe_in_progress_warn(clone_root);
                                spin_unlock(&clone_root->root_item_lock);
                                srcu_read_unlock(&fs_info->subvol_srcu, index);
-                               btrfs_put_fs_root(clone_root);
+                               btrfs_put_root(clone_root);
                                ret = -EAGAIN;
                                goto out;
                        }
@@ -7275,7 +7275,7 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
         * for possible clone sources.
         */
        sctx->clone_roots[sctx->clone_roots_cnt++].root =
-               btrfs_grab_fs_root(sctx->send_root);
+               btrfs_grab_root(sctx->send_root);
 
        /* We do a bsearch later */
        sort(sctx->clone_roots, sctx->clone_roots_cnt,
@@ -7363,20 +7363,20 @@ out:
                for (i = 0; i < sctx->clone_roots_cnt; i++) {
                        btrfs_root_dec_send_in_progress(
                                        sctx->clone_roots[i].root);
-                       btrfs_put_fs_root(sctx->clone_roots[i].root);
+                       btrfs_put_root(sctx->clone_roots[i].root);
                }
        } else {
                for (i = 0; sctx && i < clone_sources_to_rollback; i++) {
                        btrfs_root_dec_send_in_progress(
                                        sctx->clone_roots[i].root);
-                       btrfs_put_fs_root(sctx->clone_roots[i].root);
+                       btrfs_put_root(sctx->clone_roots[i].root);
                }
 
                btrfs_root_dec_send_in_progress(send_root);
        }
        if (sctx && !IS_ERR_OR_NULL(sctx->parent_root)) {
                btrfs_root_dec_send_in_progress(sctx->parent_root);
-               btrfs_put_fs_root(sctx->parent_root);
+               btrfs_put_root(sctx->parent_root);
        }
 
        kvfree(clone_sources_tmp);

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 80fea16cf34cadd08c0b6cc3757403932db77cf4..476c93a238eb747c7181bba67ce742bfeb856b66 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1094,16 +1094,16 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
 
                        ret = btrfs_search_slot(NULL, fs_root, &key, path, 0, 0);
                        if (ret < 0) {
-                               btrfs_put_fs_root(fs_root);
+                               btrfs_put_root(fs_root);
                                goto err;
                        } else if (ret > 0) {
                                ret = btrfs_previous_item(fs_root, path, dirid,
                                                          BTRFS_INODE_REF_KEY);
                                if (ret < 0) {
-                                       btrfs_put_fs_root(fs_root);
+                                       btrfs_put_root(fs_root);
                                        goto err;
                                } else if (ret > 0) {
-                                       btrfs_put_fs_root(fs_root);
+                                       btrfs_put_root(fs_root);
                                        ret = -ENOENT;
                                        goto err;
                                }
@@ -1120,7 +1120,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
                        ptr -= len + 1;
                        if (ptr < name) {
                                ret = -ENAMETOOLONG;
-                               btrfs_put_fs_root(fs_root);
+                               btrfs_put_root(fs_root);
                                goto err;
                        }
                        read_extent_buffer(path->nodes[0], ptr + 1,
@@ -1128,7 +1128,7 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
                        ptr[0] = '/';
                        btrfs_release_path(path);
                }
-               btrfs_put_fs_root(fs_root);
+               btrfs_put_root(fs_root);
        }
 
        btrfs_free_path(path);

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 32ee8698a87f6284bc02f9df1547a294dac58cfd..968605b901ed378c4ccb5eb55205398e63148b3f 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -3296,7 +3296,7 @@ static void free_log_tree(struct btrfs_trans_handle *trans,
        clear_extent_bits(&log->dirty_log_pages, 0, (u64)-1,
                          EXTENT_DIRTY | EXTENT_NEW | EXTENT_NEED_WAIT);
        free_extent_buffer(log->node);
-       btrfs_put_fs_root(log);
+       btrfs_put_root(log);
 }
 
 /*
@@ -6312,7 +6312,7 @@ again:
                                                        log->node->len);
                        free_extent_buffer(log->node);
                        free_extent_buffer(log->commit_root);
-                       btrfs_put_fs_root(log);
+                       btrfs_put_root(log);
 
                        if (!ret)
                                goto next;
@@ -6348,10 +6348,10 @@ again:
                }
 
                wc.replay_dest->log_root = NULL;
-               btrfs_put_fs_root(wc.replay_dest);
+               btrfs_put_root(wc.replay_dest);
                free_extent_buffer(log->node);
                free_extent_buffer(log->commit_root);
-               btrfs_put_fs_root(log);
+               btrfs_put_root(log);
 
                if (ret)
                        goto error;
@@ -6385,7 +6385,7 @@ next:
        free_extent_buffer(log_root_tree->node);
        log_root_tree->log_root = NULL;
        clear_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags);
-       btrfs_put_fs_root(log_root_tree);
+       btrfs_put_root(log_root_tree);
 
        return 0;
 error:

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index d261a39b7aa6b54c0cff0e333216e4ad69073e3a..7483521a928be1426636c124a6f1896dbdaba417 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4391,7 +4391,7 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
                        ret = 1;
                break;
        }
-       btrfs_put_fs_root(subvol_root);
+       btrfs_put_root(subvol_root);
 out:
        return ret;
 }