leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

btrfs: push btrfs_grab_fs_root into btrfs_get_fs_root

Browse Source 
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>
This commit is contained in:
Josef Bacik 2020-01-24 09:32:56 -05:00 committed by David Sterba
parent 81f096edf0
commit bc44d7c4b2
14 changed files with 27 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
fs/btrfs/backref.c
View File

@ -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;

45
fs/btrfs/disk-io.c
View File

@ -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;

4
fs/btrfs/export.c
View File

@ -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;

4
fs/btrfs/file.c
View File

@ -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;

4
fs/btrfs/inode.c
View File

@ -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);

26
fs/btrfs/ioctl.c
View File

@ -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;

8
fs/btrfs/relocation.c
View File

@ -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

2
fs/btrfs/root-tree.c
View File

@ -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) {

4
fs/btrfs/scrub.c
View File

@ -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)

11
fs/btrfs/send.c
View File

@ -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++;

5
fs/btrfs/super.c
View File

@ -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

6
fs/btrfs/transaction.c
View File

@ -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) {

4
fs/btrfs/tree-log.c
View File

@ -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);

4
fs/btrfs/volumes.c
View File

@ -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: