btrfs: push btrfs_grab_fs_root into btrfs_get_fs_root

Now that all callers of btrfs_get_fs_root are subsequently calling
btrfs_grab_fs_root and handling dropping the ref when they are done
appropriately, go ahead and push btrfs_grab_fs_root up into
btrfs_get_fs_root.

Signed-off-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 193747b6e1f92d4be9d39d7d2e4add40447383a5..b69154d7252990efb10e5b8dd6c9bfbcbf56875c 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -527,12 +527,6 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info,
                goto out_free;
        }
 
-       if (!btrfs_grab_fs_root(root)) {
-               srcu_read_unlock(&fs_info->subvol_srcu, index);
-               ret = -ENOENT;
-               goto out_free;
-       }
-
        if (btrfs_is_testing(fs_info)) {
                srcu_read_unlock(&fs_info->subvol_srcu, index);
                ret = -ENOENT;

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5be61619c71b8a8f5bfce4cdf37da5ef6a31be5c..a0c67200fb2a72db83b9dd0d31212db45267c18a 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1496,6 +1496,8 @@ static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
        spin_lock(&fs_info->fs_roots_radix_lock);
        root = radix_tree_lookup(&fs_info->fs_roots_radix,
                                 (unsigned long)root_id);
+       if (root)
+               root = btrfs_grab_fs_root(root);
        spin_unlock(&fs_info->fs_roots_radix_lock);
        return root;
 }
@@ -1552,29 +1554,31 @@ struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
        int ret;
 
        if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
-               return fs_info->tree_root;
+               return btrfs_grab_fs_root(fs_info->tree_root);
        if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
-               return fs_info->extent_root;
+               return btrfs_grab_fs_root(fs_info->extent_root);
        if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
-               return fs_info->chunk_root;
+               return btrfs_grab_fs_root(fs_info->chunk_root);
        if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
-               return fs_info->dev_root;
+               return btrfs_grab_fs_root(fs_info->dev_root);
        if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
-               return fs_info->csum_root;
+               return btrfs_grab_fs_root(fs_info->csum_root);
        if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
-               return fs_info->quota_root ? fs_info->quota_root :
-                                            ERR_PTR(-ENOENT);
+               return btrfs_grab_fs_root(fs_info->quota_root) ?
+                       fs_info->quota_root : ERR_PTR(-ENOENT);
        if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
-               return fs_info->uuid_root ? fs_info->uuid_root :
-                                           ERR_PTR(-ENOENT);
+               return btrfs_grab_fs_root(fs_info->uuid_root) ?
+                       fs_info->uuid_root : ERR_PTR(-ENOENT);
        if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
-               return fs_info->free_space_root ? fs_info->free_space_root :
-                                                 ERR_PTR(-ENOENT);
+               return btrfs_grab_fs_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)
+               if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
+                       btrfs_put_fs_root(root);
                        return ERR_PTR(-ENOENT);
+               }
                return root;
        }
 
@@ -1607,8 +1611,18 @@ again:
        if (ret == 0)
                set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
 
+       /*
+        * All roots have two refs on them at all times, one for the mounted fs,
+        * and one for being in the radix tree.  This way we only free the root
+        * when we are unmounting or deleting the subvolume.  We get one ref
+        * from __setup_root, one for inserting it into the radix tree, and then
+        * 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);
        ret = btrfs_insert_fs_root(fs_info, root);
        if (ret) {
+               btrfs_put_fs_root(root);
                if (ret == -EEXIST) {
                        btrfs_free_fs_root(root);
                        goto again;
@@ -3207,13 +3221,6 @@ int __cold open_ctree(struct super_block *sb,
                goto fail_qgroup;
        }
 
-       if (!btrfs_grab_fs_root(fs_info->fs_root)) {
-               fs_info->fs_root = NULL;
-               err = -ENOENT;
-               btrfs_warn(fs_info, "failed to grab a ref on the fs tree");
-               goto fail_qgroup;
-       }
-
        if (sb_rdonly(sb))
                return 0;
 

diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c
index eba6c6d27bade16b0a5afce5addb8d0a31312704..f07c2300ade223e9d56ae5d235ef77e7106851af 100644 (file)
--- a/fs/btrfs/export.c
+++ b/fs/btrfs/export.c
@@ -82,10 +82,6 @@ static struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
                err = PTR_ERR(root);
                goto fail;
        }
-       if (!btrfs_grab_fs_root(root)) {
-               err = -ENOENT;
-               goto fail;
-       }
 
        key.objectid = objectid;
        key.type = BTRFS_INODE_ITEM_KEY;

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 27237bbaad65451d09fe3473300f8e941e77d6a8..ba19b4debc614f1d0e2b40cf667b154185b12a63 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -292,10 +292,6 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
                ret = PTR_ERR(inode_root);
                goto cleanup;
        }
-       if (!btrfs_grab_fs_root(inode_root)) {
-               ret = -ENOENT;
-               goto cleanup;
-       }
 
        key.objectid = defrag->ino;
        key.type = BTRFS_INODE_ITEM_KEY;

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 324fc79174e64d4f2e777935a9341a810c1dcf5d..ab67862bbfd62f282de89d5f0586e9fe6d7a5921 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -5158,10 +5158,6 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info,
                err = PTR_ERR(new_root);
                goto out;
        }
-       if (!btrfs_grab_fs_root(new_root)) {
-               err = -ENOENT;
-               goto out;
-       }
 
        *sub_root = new_root;
        location->objectid = btrfs_root_dirid(&new_root->root_item);

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index f36aa0674ade080ec2fea25894d5e8192faeb6d4..bb8106f7dd26a84b3c281027677a17ee1818e4a7 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -672,11 +672,6 @@ static noinline int create_subvol(struct inode *dir,
                btrfs_abort_transaction(trans, ret);
                goto fail;
        }
-       if (!btrfs_grab_fs_root(new_root)) {
-               ret = -ENOENT;
-               btrfs_abort_transaction(trans, ret);
-               goto fail;
-       }
 
        btrfs_record_root_in_trans(trans, new_root);
 
@@ -2191,10 +2186,6 @@ static noinline int search_ioctl(struct inode *inode,
                        btrfs_free_path(path);
                        return PTR_ERR(root);
                }
-               if (!btrfs_grab_fs_root(root)) {
-                       btrfs_free_path(path);
-                       return -ENOENT;
-               }
        }
 
        key.objectid = sk->min_objectid;
@@ -2332,11 +2323,6 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
                root = NULL;
                goto out;
        }
-       if (!btrfs_grab_fs_root(root)) {
-               ret = -ENOENT;
-               root = NULL;
-               goto out;
-       }
 
        key.objectid = dirid;
        key.type = BTRFS_INODE_REF_KEY;
@@ -2432,10 +2418,6 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,
                        ret = PTR_ERR(root);
                        goto out;
                }
-               if (!btrfs_grab_fs_root(root)) {
-                       ret = -ENOENT;
-                       goto out;
-               }
 
                key.objectid = dirid;
                key.type = BTRFS_INODE_REF_KEY;
@@ -2684,10 +2666,6 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp)
                ret = PTR_ERR(root);
                goto out_free;
        }
-       if (!btrfs_grab_fs_root(root)) {
-               ret = -ENOENT;
-               goto out;
-       }
        root_item = &root->root_item;
 
        subvol_info->treeid = key.objectid;
@@ -4018,10 +3996,6 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
                ret = PTR_ERR(new_root);
                goto out;
        }
-       if (!btrfs_grab_fs_root(new_root)) {
-               ret = -ENOENT;
-               goto out;
-       }
        if (!is_fstree(new_root->root_key.objectid)) {
                ret = -ENOENT;
                goto out_free;

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 440b662c3b0b13c25ead69e7f74c590cd941f907..360f347d752426464c1ac54d52c2eacca8ba15bf 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -659,7 +659,6 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,
                                        u64 root_objectid)
 {
        struct btrfs_key key;
-       struct btrfs_root *root;
 
        key.objectid = root_objectid;
        key.type = BTRFS_ROOT_ITEM_KEY;
@@ -668,12 +667,7 @@ static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,
        else
                key.offset = (u64)-1;
 
-       root = btrfs_get_fs_root(fs_info, &key, false);
-       if (IS_ERR(root))
-               return root;
-       if (!btrfs_grab_fs_root(root))
-               return ERR_PTR(-ENOENT);
-       return root;
+       return btrfs_get_fs_root(fs_info, &key, false);
 }
 
 static noinline_for_stack

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index a32632f439870b51b92701bac4a5b7e83fb94e12..2ab2a0239b7d95b57a151f34c88d82e6a59fbecb 100644 (file)
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -257,8 +257,6 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
 
                root = btrfs_get_fs_root(fs_info, &root_key, false);
                err = PTR_ERR_OR_ZERO(root);
-               if (!err && !btrfs_grab_fs_root(root))
-                       err = -ENOENT;
                if (err && err != -ENOENT) {
                        break;
                } else if (err == -ENOENT) {

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 158a661ad2b0f32d4b6a2ec4cf52570483af7c0a..8593885e2455991e5b8d32f6f754d5b03c76d1ff 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -658,10 +658,6 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
                ret = PTR_ERR(local_root);
                goto err;
        }
-       if (!btrfs_grab_fs_root(local_root)) {
-               ret = -ENOENT;
-               goto err;
-       }
 
        /*
         * this makes the path point to (inum INODE_ITEM ioff)

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 31495cdf1877945c28f6caff7ac1ad5d3bdf431d..3e243ad4a95fe060235a96e4008db3eabbece05a 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -7201,11 +7201,6 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
                                ret = PTR_ERR(clone_root);
                                goto out;
                        }
-                       if (!btrfs_grab_fs_root(clone_root)) {
-                               srcu_read_unlock(&fs_info->subvol_srcu, index);
-                               ret = -ENOENT;
-                               goto out;
-                       }
                        spin_lock(&clone_root->root_item_lock);
                        if (!btrfs_root_readonly(clone_root) ||
                            btrfs_root_dead(clone_root)) {
@@ -7247,12 +7242,6 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
                        ret = PTR_ERR(sctx->parent_root);
                        goto out;
                }
-               if (!btrfs_grab_fs_root(sctx->parent_root)) {
-                       srcu_read_unlock(&fs_info->subvol_srcu, index);
-                       ret = -ENOENT;
-                       sctx->parent_root = ERR_PTR(ret);
-                       goto out;
-               }
 
                spin_lock(&sctx->parent_root->root_item_lock);
                sctx->parent_root->send_in_progress++;

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index a70c89b3a2235f51b086ec5459f2d5e06f17cb1d..f1ad1189c93072301afe33b624edd4a75f0ac975 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1102,11 +1102,6 @@ static char *get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
                        fs_root = NULL;
                        goto err;
                }
-               if (!btrfs_grab_fs_root(fs_root)) {
-                       ret = -ENOENT;
-                       fs_root = NULL;
-                       goto err;
-               }
 
                /*
                 * Walk up the filesystem tree by inode refs until we hit the

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 3fa2e7d52eda746c80e0c3221a3d6c699ba656cd..bcf23b06e67f07a27a6220a6d805857fcfb96c0b 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1639,12 +1639,6 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
                btrfs_abort_transaction(trans, ret);
                goto fail;
        }
-       if (!btrfs_grab_fs_root(pending->snap)) {
-               ret = -ENOENT;
-               pending->snap = NULL;
-               btrfs_abort_transaction(trans, ret);
-               goto fail;
-       }
 
        ret = btrfs_reloc_post_snapshot(trans, pending);
        if (ret) {

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 1776ac466f02ba39f18228268afef0137db0841c..54031a38906a50ed30f75281f478af587549aa3e 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -6163,10 +6163,6 @@ again:
                tmp_key.offset = (u64)-1;
 
                wc.replay_dest = btrfs_get_fs_root(fs_info, &tmp_key, true);
-               if (!IS_ERR(wc.replay_dest)) {
-                       if (!btrfs_grab_fs_root(wc.replay_dest))
-                               wc.replay_dest = ERR_PTR(-ENOENT);
-               }
                if (IS_ERR(wc.replay_dest)) {
                        ret = PTR_ERR(wc.replay_dest);
 

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 3fca9f9e3b5d863b2c78fa2544d46c4729b99ba5..089af576ad7829a4d9239551a6c646117819ee49 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4431,10 +4431,6 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
                        ret = 1;
                goto out;
        }
-       if (!btrfs_grab_fs_root(subvol_root)) {
-               ret = 1;
-               goto out;
-       }
 
        switch (type) {
        case BTRFS_UUID_KEY_SUBVOL: