redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

btrfs: simplify root lookup by id 

The main function to lookup a root by its id btrfs_get_fs_root takes the
whole key, while only using the objectid. The value of offset is preset
to (u64)-1 but not actually used until btrfs_find_root that does the
actual search.

Switch btrfs_get_fs_root to use only objectid and remove all local
variables that existed just for the lookup. The actual key for search is
set up in btrfs_get_fs_root, reusing another key variable.

Signed-off-by: David Sterba <dsterba@suse.com>
alistair/sunxi64-5.8
David Sterba 2020-05-15 19:35:55 +02:00
parent 1dae7e0e58
commit 56e9357a1e
15 changed files with 46 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
fs/btrfs/backref.c
View File

@ -538,18 +538,13 @@ static int resolve_indirect_ref(struct btrfs_fs_info *fs_info,
const u64 *extent_item_pos, bool ignore_offset) const u64 *extent_item_pos, bool ignore_offset)
{ {
struct btrfs_root *root; struct btrfs_root *root;
struct btrfs_key root_key;
struct extent_buffer *eb; struct extent_buffer *eb;
int ret = 0; int ret = 0;
int root_level; int root_level;
int level = ref->level; int level = ref->level;
struct btrfs_key search_key = ref->key_for_search; struct btrfs_key search_key = ref->key_for_search;
root_key.objectid = ref->root_id; root = btrfs_get_fs_root(fs_info, ref->root_id, false);
root_key.type = BTRFS_ROOT_ITEM_KEY;
root_key.offset = (u64)-1;
root = btrfs_get_fs_root(fs_info, &root_key, false);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto out_free; goto out_free;
@ -2690,16 +2685,12 @@ static int handle_indirect_tree_backref(struct btrfs_backref_cache *cache,
struct btrfs_backref_edge *edge; struct btrfs_backref_edge *edge;
struct extent_buffer *eb; struct extent_buffer *eb;
struct btrfs_root *root; struct btrfs_root *root;
struct btrfs_key root_key;
struct rb_node *rb_node; struct rb_node *rb_node;
int level; int level;
bool need_check = true; bool need_check = true;
int ret; int ret;
root_key.objectid = ref_key->offset; root = btrfs_get_fs_root(fs_info, ref_key->offset, false);
root_key.type = BTRFS_ROOT_ITEM_KEY;
root_key.offset = (u64)-1;
root = btrfs_get_fs_root(fs_info, &root_key, false);
if (IS_ERR(root)) if (IS_ERR(root))
return PTR_ERR(root); return PTR_ERR(root);
if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state))

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

@ -1534,35 +1534,34 @@ void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
struct btrfs_key *location, u64 objectid, bool check_ref)
bool check_ref)
{ {
struct btrfs_root *root; struct btrfs_root *root;
struct btrfs_path *path; struct btrfs_path *path;
struct btrfs_key key; struct btrfs_key key;
int ret; int ret;
if (location->objectid == BTRFS_ROOT_TREE_OBJECTID) if (objectid == BTRFS_ROOT_TREE_OBJECTID)
return btrfs_grab_root(fs_info->tree_root); return btrfs_grab_root(fs_info->tree_root);
if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID) if (objectid == BTRFS_EXTENT_TREE_OBJECTID)
return btrfs_grab_root(fs_info->extent_root); return btrfs_grab_root(fs_info->extent_root);
if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID) if (objectid == BTRFS_CHUNK_TREE_OBJECTID)
return btrfs_grab_root(fs_info->chunk_root); return btrfs_grab_root(fs_info->chunk_root);
if (location->objectid == BTRFS_DEV_TREE_OBJECTID) if (objectid == BTRFS_DEV_TREE_OBJECTID)
return btrfs_grab_root(fs_info->dev_root); return btrfs_grab_root(fs_info->dev_root);
if (location->objectid == BTRFS_CSUM_TREE_OBJECTID) if (objectid == BTRFS_CSUM_TREE_OBJECTID)
return btrfs_grab_root(fs_info->csum_root); return btrfs_grab_root(fs_info->csum_root);
if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID) if (objectid == BTRFS_QUOTA_TREE_OBJECTID)
return btrfs_grab_root(fs_info->quota_root) ? return btrfs_grab_root(fs_info->quota_root) ?
fs_info->quota_root : ERR_PTR(-ENOENT); fs_info->quota_root : ERR_PTR(-ENOENT);
if (location->objectid == BTRFS_UUID_TREE_OBJECTID) if (objectid == BTRFS_UUID_TREE_OBJECTID)
return btrfs_grab_root(fs_info->uuid_root) ? return btrfs_grab_root(fs_info->uuid_root) ?
fs_info->uuid_root : ERR_PTR(-ENOENT); fs_info->uuid_root : ERR_PTR(-ENOENT);
if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID) if (objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
return btrfs_grab_root(fs_info->free_space_root) ? return btrfs_grab_root(fs_info->free_space_root) ?
fs_info->free_space_root : ERR_PTR(-ENOENT); fs_info->free_space_root : ERR_PTR(-ENOENT);
again: again:
root = btrfs_lookup_fs_root(fs_info, location->objectid); root = btrfs_lookup_fs_root(fs_info, objectid);
if (root) { if (root) {
if (check_ref && btrfs_root_refs(&root->root_item) == 0) { if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
btrfs_put_root(root); btrfs_put_root(root);
@ -1571,7 +1570,10 @@ again:
return root; return root;
} }
root = btrfs_read_tree_root(fs_info->tree_root, location); key.objectid = objectid;
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
root = btrfs_read_tree_root(fs_info->tree_root, &key);
if (IS_ERR(root)) if (IS_ERR(root))
return root; return root;
@ -1591,7 +1593,7 @@ again:
} }
key.objectid = BTRFS_ORPHAN_OBJECTID; key.objectid = BTRFS_ORPHAN_OBJECTID;
key.type = BTRFS_ORPHAN_ITEM_KEY; key.type = BTRFS_ORPHAN_ITEM_KEY;
key.offset = location->objectid; key.offset = objectid;
ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0); ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
btrfs_free_path(path); btrfs_free_path(path);
@ -2293,8 +2295,8 @@ static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
* This tree can share blocks with some other fs tree during relocation * This tree can share blocks with some other fs tree during relocation
* and we need a proper setup by btrfs_get_fs_root * and we need a proper setup by btrfs_get_fs_root
*/ */
location.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID; root = btrfs_get_fs_root(tree_root->fs_info,
root = btrfs_get_fs_root(tree_root->fs_info, &location, true); BTRFS_DATA_RELOC_TREE_OBJECTID, true);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto out; goto out;
@ -2839,7 +2841,6 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device
u64 generation; u64 generation;
u64 features; u64 features;
u16 csum_type; u16 csum_type;
struct btrfs_key location;
struct btrfs_super_block *disk_super; struct btrfs_super_block *disk_super;
struct btrfs_fs_info *fs_info = btrfs_sb(sb); struct btrfs_fs_info *fs_info = btrfs_sb(sb);
struct btrfs_root *tree_root; struct btrfs_root *tree_root;
@ -3253,11 +3254,7 @@ int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_device
} }
} }
location.objectid = BTRFS_FS_TREE_OBJECTID; fs_info->fs_root = btrfs_get_fs_root(fs_info, BTRFS_FS_TREE_OBJECTID, true);
location.type = BTRFS_ROOT_ITEM_KEY;
location.offset = 0;
fs_info->fs_root = btrfs_get_fs_root(fs_info, &location, true);
if (IS_ERR(fs_info->fs_root)) { if (IS_ERR(fs_info->fs_root)) {
err = PTR_ERR(fs_info->fs_root); err = PTR_ERR(fs_info->fs_root);
btrfs_warn(fs_info, "failed to read fs tree: %d", err); btrfs_warn(fs_info, "failed to read fs tree: %d", err);

3
fs/btrfs/disk-io.h
View File

@ -66,8 +66,7 @@ int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info); void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info);
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
struct btrfs_key *key, u64 objectid, bool check_ref);
bool check_ref);
void btrfs_free_fs_info(struct btrfs_fs_info *fs_info); void btrfs_free_fs_info(struct btrfs_fs_info *fs_info);
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info); int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info);

6
fs/btrfs/export.c
View File

@ -69,11 +69,7 @@ struct dentry *btrfs_get_dentry(struct super_block *sb, u64 objectid,
if (objectid < BTRFS_FIRST_FREE_OBJECTID) if (objectid < BTRFS_FIRST_FREE_OBJECTID)
return ERR_PTR(-ESTALE); return ERR_PTR(-ESTALE);
key.objectid = root_objectid; root = btrfs_get_fs_root(fs_info, root_objectid, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(root)) if (IS_ERR(root))
return ERR_CAST(root); return ERR_CAST(root);

6
fs/btrfs/file.c
View File

@ -281,11 +281,7 @@ static int __btrfs_run_defrag_inode(struct btrfs_fs_info *fs_info,
int ret; int ret;
/* get the inode */ /* get the inode */
key.objectid = defrag->root; inode_root = btrfs_get_fs_root(fs_info, defrag->root, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
inode_root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(inode_root)) { if (IS_ERR(inode_root)) {
ret = PTR_ERR(inode_root); ret = PTR_ERR(inode_root);
goto cleanup; goto cleanup;

2
fs/btrfs/inode.c
View File

@ -5145,7 +5145,7 @@ static int fixup_tree_root_location(struct btrfs_fs_info *fs_info,
btrfs_release_path(path); btrfs_release_path(path);
new_root = btrfs_get_fs_root(fs_info, location, true); new_root = btrfs_get_fs_root(fs_info, location->objectid, true);
if (IS_ERR(new_root)) { if (IS_ERR(new_root)) {
err = PTR_ERR(new_root); err = PTR_ERR(new_root);
goto out; goto out;

28
fs/btrfs/ioctl.c
View File

@ -660,7 +660,7 @@ static noinline int create_subvol(struct inode *dir,
goto fail; goto fail;
key.offset = (u64)-1; key.offset = (u64)-1;
new_root = btrfs_get_fs_root(fs_info, &key, true); new_root = btrfs_get_fs_root(fs_info, objectid, true);
if (IS_ERR(new_root)) { if (IS_ERR(new_root)) {
ret = PTR_ERR(new_root); ret = PTR_ERR(new_root);
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);
@ -2139,10 +2139,7 @@ static noinline int search_ioctl(struct inode *inode,
/* search the root of the inode that was passed */ /* search the root of the inode that was passed */
root = btrfs_grab_root(BTRFS_I(inode)->root); root = btrfs_grab_root(BTRFS_I(inode)->root);
} else { } else {
key.objectid = sk->tree_id; root = btrfs_get_fs_root(info, sk->tree_id, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
root = btrfs_get_fs_root(info, &key, true);
if (IS_ERR(root)) { if (IS_ERR(root)) {
btrfs_free_path(path); btrfs_free_path(path);
return PTR_ERR(root); return PTR_ERR(root);
@ -2275,10 +2272,7 @@ static noinline int btrfs_search_path_in_tree(struct btrfs_fs_info *info,
ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1]; ptr = &name[BTRFS_INO_LOOKUP_PATH_MAX - 1];
key.objectid = tree_id; root = btrfs_get_fs_root(info, tree_id, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
root = btrfs_get_fs_root(info, &key, true);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
root = NULL; root = NULL;
@ -2371,10 +2365,7 @@ static int btrfs_search_path_in_tree_user(struct inode *inode,
if (dirid != upper_limit.objectid) { if (dirid != upper_limit.objectid) {
ptr = &args->path[BTRFS_INO_LOOKUP_USER_PATH_MAX - 1]; ptr = &args->path[BTRFS_INO_LOOKUP_USER_PATH_MAX - 1];
key.objectid = treeid; root = btrfs_get_fs_root(fs_info, treeid, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto out; goto out;
@ -2620,9 +2611,7 @@ static int btrfs_ioctl_get_subvol_info(struct file *file, void __user *argp)
/* Get root_item of inode's subvolume */ /* Get root_item of inode's subvolume */
key.objectid = BTRFS_I(inode)->root->root_key.objectid; key.objectid = BTRFS_I(inode)->root->root_key.objectid;
key.type = BTRFS_ROOT_ITEM_KEY; root = btrfs_get_fs_root(fs_info, key.objectid, true);
key.offset = (u64)-1;
root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(root)) { if (IS_ERR(root)) {
ret = PTR_ERR(root); ret = PTR_ERR(root);
goto out_free; goto out_free;
@ -3290,7 +3279,6 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
struct btrfs_dir_item *di; struct btrfs_dir_item *di;
struct btrfs_trans_handle *trans; struct btrfs_trans_handle *trans;
struct btrfs_path *path = NULL; struct btrfs_path *path = NULL;
struct btrfs_key location;
struct btrfs_disk_key disk_key; struct btrfs_disk_key disk_key;
u64 objectid = 0; u64 objectid = 0;
u64 dir_id; u64 dir_id;
@ -3311,11 +3299,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
if (!objectid) if (!objectid)
objectid = BTRFS_FS_TREE_OBJECTID; objectid = BTRFS_FS_TREE_OBJECTID;
location.objectid = objectid; new_root = btrfs_get_fs_root(fs_info, objectid, true);
location.type = BTRFS_ROOT_ITEM_KEY;
location.offset = (u64)-1;
new_root = btrfs_get_fs_root(fs_info, &location, true);
if (IS_ERR(new_root)) { if (IS_ERR(new_root)) {
ret = PTR_ERR(new_root); ret = PTR_ERR(new_root);
goto out; goto out;

8
fs/btrfs/relocation.c
View File

@ -368,13 +368,7 @@ struct btrfs_root *find_reloc_root(struct btrfs_fs_info *fs_info, u64 bytenr)
static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info, static struct btrfs_root *read_fs_root(struct btrfs_fs_info *fs_info,
u64 root_objectid) u64 root_objectid)
{ {
struct btrfs_key key; return btrfs_get_fs_root(fs_info, root_objectid, false);
key.objectid = root_objectid;
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
return btrfs_get_fs_root(fs_info, &key, false);
} }
/* /*

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

@ -210,7 +210,6 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
struct extent_buffer *leaf; struct extent_buffer *leaf;
struct btrfs_path *path; struct btrfs_path *path;
struct btrfs_key key; struct btrfs_key key;
struct btrfs_key root_key;
struct btrfs_root *root; struct btrfs_root *root;
int err = 0; int err = 0;
int ret; int ret;
@ -223,10 +222,9 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
key.type = BTRFS_ORPHAN_ITEM_KEY; key.type = BTRFS_ORPHAN_ITEM_KEY;
key.offset = 0; key.offset = 0;
root_key.type = BTRFS_ROOT_ITEM_KEY;
root_key.offset = (u64)-1;
while (1) { while (1) {
u64 root_objectid;
ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0); ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
if (ret < 0) { if (ret < 0) {
err = ret; err = ret;
@ -250,10 +248,10 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
key.type != BTRFS_ORPHAN_ITEM_KEY) key.type != BTRFS_ORPHAN_ITEM_KEY)
break; break;
root_key.objectid = key.offset; root_objectid = key.offset;
key.offset++; key.offset++;
root = btrfs_get_fs_root(fs_info, &root_key, false); root = btrfs_get_fs_root(fs_info, root_objectid, false);
err = PTR_ERR_OR_ZERO(root); err = PTR_ERR_OR_ZERO(root);
if (err && err != -ENOENT) { if (err && err != -ENOENT) {
break; break;
@ -270,7 +268,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
break; break;
} }
err = btrfs_del_orphan_item(trans, tree_root, err = btrfs_del_orphan_item(trans, tree_root,
root_key.objectid); root_objectid);
btrfs_end_transaction(trans); btrfs_end_transaction(trans);
if (err) { if (err) {
btrfs_handle_fs_error(fs_info, err, btrfs_handle_fs_error(fs_info, err,

6
fs/btrfs/scrub.c
View File

@ -647,13 +647,9 @@ static int scrub_print_warning_inode(u64 inum, u64 offset, u64 root,
struct btrfs_fs_info *fs_info = swarn->dev->fs_info; struct btrfs_fs_info *fs_info = swarn->dev->fs_info;
struct inode_fs_paths *ipath = NULL; struct inode_fs_paths *ipath = NULL;
struct btrfs_root *local_root; struct btrfs_root *local_root;
struct btrfs_key root_key;
struct btrfs_key key; struct btrfs_key key;
root_key.objectid = root; local_root = btrfs_get_fs_root(fs_info, root, true);
root_key.type = BTRFS_ROOT_ITEM_KEY;
root_key.offset = (u64)-1;
local_root = btrfs_get_fs_root(fs_info, &root_key, true);
if (IS_ERR(local_root)) { if (IS_ERR(local_root)) {
ret = PTR_ERR(local_root); ret = PTR_ERR(local_root);
goto err; goto err;

15
fs/btrfs/send.c
View File

@ -7088,7 +7088,6 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
struct btrfs_root *send_root = BTRFS_I(file_inode(mnt_file))->root; struct btrfs_root *send_root = BTRFS_I(file_inode(mnt_file))->root;
struct btrfs_fs_info *fs_info = send_root->fs_info; struct btrfs_fs_info *fs_info = send_root->fs_info;
struct btrfs_root *clone_root; struct btrfs_root *clone_root;
struct btrfs_key key;
struct send_ctx *sctx = NULL; struct send_ctx *sctx = NULL;
u32 i; u32 i;
u64 *clone_sources_tmp = NULL; u64 *clone_sources_tmp = NULL;
@ -7217,11 +7216,8 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
} }
for (i = 0; i < arg->clone_sources_count; i++) { for (i = 0; i < arg->clone_sources_count; i++) {
key.objectid = clone_sources_tmp[i]; clone_root = btrfs_get_fs_root(fs_info,
key.type = BTRFS_ROOT_ITEM_KEY; clone_sources_tmp[i], true);
key.offset = (u64)-1;
clone_root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(clone_root)) { if (IS_ERR(clone_root)) {
ret = PTR_ERR(clone_root); ret = PTR_ERR(clone_root);
goto out; goto out;
@ -7252,11 +7248,8 @@ long btrfs_ioctl_send(struct file *mnt_file, struct btrfs_ioctl_send_args *arg)
} }
if (arg->parent_root) { if (arg->parent_root) {
key.objectid = arg->parent_root; sctx->parent_root = btrfs_get_fs_root(fs_info, arg->parent_root,
key.type = BTRFS_ROOT_ITEM_KEY; true);
key.offset = (u64)-1;
sctx->parent_root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(sctx->parent_root)) { if (IS_ERR(sctx->parent_root)) {
ret = PTR_ERR(sctx->parent_root); ret = PTR_ERR(sctx->parent_root);
goto out; goto out;

5
fs/btrfs/super.c
View File

@ -1102,10 +1102,7 @@ char *btrfs_get_subvol_name_from_objectid(struct btrfs_fs_info *fs_info,
dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref); dirid = btrfs_root_ref_dirid(path->nodes[0], root_ref);
btrfs_release_path(path); btrfs_release_path(path);
key.objectid = subvol_objectid; fs_root = btrfs_get_fs_root(fs_info, subvol_objectid, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
fs_root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(fs_root)) { if (IS_ERR(fs_root)) {
ret = PTR_ERR(fs_root); ret = PTR_ERR(fs_root);
fs_root = NULL; fs_root = NULL;

2
fs/btrfs/transaction.c
View File

@ -1630,7 +1630,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
} }
key.offset = (u64)-1; key.offset = (u64)-1;
pending->snap = btrfs_get_fs_root(fs_info, &key, true); pending->snap = btrfs_get_fs_root(fs_info, objectid, true);
if (IS_ERR(pending->snap)) { if (IS_ERR(pending->snap)) {
ret = PTR_ERR(pending->snap); ret = PTR_ERR(pending->snap);
btrfs_abort_transaction(trans, ret); btrfs_abort_transaction(trans, ret);

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

@ -6112,7 +6112,6 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
struct btrfs_trans_handle *trans; struct btrfs_trans_handle *trans;
struct btrfs_key key; struct btrfs_key key;
struct btrfs_key found_key; struct btrfs_key found_key;
struct btrfs_key tmp_key;
struct btrfs_root *log; struct btrfs_root *log;
struct btrfs_fs_info *fs_info = log_root_tree->fs_info; struct btrfs_fs_info *fs_info = log_root_tree->fs_info;
struct walk_control wc = { struct walk_control wc = {
@ -6174,11 +6173,8 @@ again:
goto error; goto error;
} }
tmp_key.objectid = found_key.offset; wc.replay_dest = btrfs_get_fs_root(fs_info, found_key.offset,
tmp_key.type = BTRFS_ROOT_ITEM_KEY; true);
tmp_key.offset = (u64)-1;
wc.replay_dest = btrfs_get_fs_root(fs_info, &tmp_key, true);
if (IS_ERR(wc.replay_dest)) { if (IS_ERR(wc.replay_dest)) {
ret = PTR_ERR(wc.replay_dest); ret = PTR_ERR(wc.replay_dest);

6
fs/btrfs/uuid-tree.c
View File

@ -257,7 +257,6 @@ out:
static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info, static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
u8 *uuid, u8 type, u64 subvolid) u8 *uuid, u8 type, u64 subvolid)
{ {
struct btrfs_key key;
int ret = 0; int ret = 0;
struct btrfs_root *subvol_root; struct btrfs_root *subvol_root;
@ -265,10 +264,7 @@ static int btrfs_check_uuid_tree_entry(struct btrfs_fs_info *fs_info,
type != BTRFS_UUID_KEY_RECEIVED_SUBVOL) type != BTRFS_UUID_KEY_RECEIVED_SUBVOL)
goto out; goto out;
key.objectid = subvolid; subvol_root = btrfs_get_fs_root(fs_info, subvolid, true);
key.type = BTRFS_ROOT_ITEM_KEY;
key.offset = (u64)-1;
subvol_root = btrfs_get_fs_root(fs_info, &key, true);
if (IS_ERR(subvol_root)) { if (IS_ERR(subvol_root)) {
ret = PTR_ERR(subvol_root); ret = PTR_ERR(subvol_root);
if (ret == -ENOENT) if (ret == -ENOENT)