p71924506
/
linux_old1
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

btrfs: ref-verify: Use btrfs_ref to refactor btrfs_ref_tree_mod() 

It's a perfect match for btrfs_ref_tree_mod() to use btrfs_ref, as
btrfs_ref describes a metadata/data reference update comprehensively.

Now we have one less function use confusing owner/level trick.

Signed-off-by: Qu Wenruo <wqu@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>
This commit is contained in:
Qu Wenruo 2019-04-04 14:45:33 +08:00 committed by David Sterba
parent 76675593b6
commit 8a5040f7d9
3 changed files with 42 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
fs/btrfs/extent-tree.c
View File

@ -2054,9 +2054,6 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID && BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
root_objectid == BTRFS_TREE_LOG_OBJECTID); root_objectid == BTRFS_TREE_LOG_OBJECTID);
btrfs_ref_tree_mod(root, bytenr, num_bytes, parent, root_objectid,
owner, offset, BTRFS_ADD_DELAYED_REF);
btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_REF, bytenr, btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_REF, bytenr,
num_bytes, parent); num_bytes, parent);
generic_ref.real_root = root->root_key.objectid; generic_ref.real_root = root->root_key.objectid;
@ -2070,6 +2067,8 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
&old_ref_mod, &new_ref_mod); &old_ref_mod, &new_ref_mod);
} }
btrfs_ref_tree_mod(fs_info, &generic_ref);
if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0) { if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0) {
bool metadata = owner < BTRFS_FIRST_FREE_OBJECTID; bool metadata = owner < BTRFS_FIRST_FREE_OBJECTID;
@ -7188,10 +7187,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) { if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
int old_ref_mod, new_ref_mod; int old_ref_mod, new_ref_mod;
btrfs_ref_tree_mod(root, buf->start, buf->len, parent, btrfs_ref_tree_mod(fs_info, &generic_ref);
root->root_key.objectid,
btrfs_header_level(buf), 0,
BTRFS_DROP_DELAYED_REF);
ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, NULL, ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, NULL,
&old_ref_mod, &new_ref_mod); &old_ref_mod, &new_ref_mod);
BUG_ON(ret); /* -ENOMEM */ BUG_ON(ret); /* -ENOMEM */
@ -7251,11 +7247,6 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans,
if (btrfs_is_testing(fs_info)) if (btrfs_is_testing(fs_info))
return 0; return 0;
if (root_objectid != BTRFS_TREE_LOG_OBJECTID)
btrfs_ref_tree_mod(root, bytenr, num_bytes, parent,
root_objectid, owner, offset,
BTRFS_DROP_DELAYED_REF);
btrfs_init_generic_ref(&generic_ref, BTRFS_DROP_DELAYED_REF, bytenr, btrfs_init_generic_ref(&generic_ref, BTRFS_DROP_DELAYED_REF, bytenr,
num_bytes, parent); num_bytes, parent);
generic_ref.real_root = root->root_key.objectid; generic_ref.real_root = root->root_key.objectid;
@ -7279,6 +7270,9 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans,
&old_ref_mod, &new_ref_mod); &old_ref_mod, &new_ref_mod);
} }
if (root_objectid != BTRFS_TREE_LOG_OBJECTID)
btrfs_ref_tree_mod(fs_info, &generic_ref);
if (ret == 0 && old_ref_mod >= 0 && new_ref_mod < 0) { if (ret == 0 && old_ref_mod >= 0 && new_ref_mod < 0) {
bool metadata = owner < BTRFS_FIRST_FREE_OBJECTID; bool metadata = owner < BTRFS_FIRST_FREE_OBJECTID;
@ -8386,13 +8380,10 @@ int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
BUG_ON(root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); BUG_ON(root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
btrfs_ref_tree_mod(root, ins->objectid, ins->offset, 0,
root->root_key.objectid, owner, offset,
BTRFS_ADD_DELAYED_EXTENT);
btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT, btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT,
ins->objectid, ins->offset, 0); ins->objectid, ins->offset, 0);
btrfs_init_data_ref(&generic_ref, root->root_key.objectid, owner, offset); btrfs_init_data_ref(&generic_ref, root->root_key.objectid, owner, offset);
btrfs_ref_tree_mod(root->fs_info, &generic_ref);
ret = btrfs_add_delayed_data_ref(trans, &generic_ref, ret = btrfs_add_delayed_data_ref(trans, &generic_ref,
ram_bytes, NULL, NULL); ram_bytes, NULL, NULL);
return ret; return ret;
@ -8641,13 +8632,11 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans,
extent_op->is_data = false; extent_op->is_data = false;
extent_op->level = level; extent_op->level = level;
btrfs_ref_tree_mod(root, ins.objectid, ins.offset, parent,
root_objectid, level, 0,
BTRFS_ADD_DELAYED_EXTENT);
btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT, btrfs_init_generic_ref(&generic_ref, BTRFS_ADD_DELAYED_EXTENT,
ins.objectid, ins.offset, parent); ins.objectid, ins.offset, parent);
generic_ref.real_root = root->root_key.objectid; generic_ref.real_root = root->root_key.objectid;
btrfs_init_tree_ref(&generic_ref, level, root_objectid); btrfs_init_tree_ref(&generic_ref, level, root_objectid);
btrfs_ref_tree_mod(fs_info, &generic_ref);
ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, ret = btrfs_add_delayed_tree_ref(trans, &generic_ref,
extent_op, NULL, NULL); extent_op, NULL, NULL);
if (ret) if (ret)

53
fs/btrfs/ref-verify.c
View File

@ -670,36 +670,43 @@ static void dump_block_entry(struct btrfs_fs_info *fs_info,
/* /*
* btrfs_ref_tree_mod: called when we modify a ref for a bytenr * btrfs_ref_tree_mod: called when we modify a ref for a bytenr
* @root: the root we are making this modification from.
* @bytenr: the bytenr we are modifying.
* @num_bytes: number of bytes.
* @parent: the parent bytenr.
* @ref_root: the original root owner of the bytenr.
* @owner: level in the case of metadata, inode in the case of data.
* @offset: 0 for metadata, file offset for data.
* @action: the action that we are doing, this is the same as the delayed ref
* action.
* *
* This will add an action item to the given bytenr and do sanity checks to make * This will add an action item to the given bytenr and do sanity checks to make
* sure we haven't messed something up. If we are making a new allocation and * sure we haven't messed something up. If we are making a new allocation and
* this block entry has history we will delete all previous actions as long as * this block entry has history we will delete all previous actions as long as
* our sanity checks pass as they are no longer needed. * our sanity checks pass as they are no longer needed.
*/ */
int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes, int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,
u64 parent, u64 ref_root, u64 owner, u64 offset, struct btrfs_ref *generic_ref)
int action)
{ {
struct btrfs_fs_info *fs_info = root->fs_info;
struct ref_entry *ref = NULL, *exist; struct ref_entry *ref = NULL, *exist;
struct ref_action *ra = NULL; struct ref_action *ra = NULL;
struct block_entry *be = NULL; struct block_entry *be = NULL;
struct root_entry *re = NULL; struct root_entry *re = NULL;
int action = generic_ref->action;
int ret = 0; int ret = 0;
bool metadata = owner < BTRFS_FIRST_FREE_OBJECTID; bool metadata;
u64 bytenr = generic_ref->bytenr;
u64 num_bytes = generic_ref->len;
u64 parent = generic_ref->parent;
u64 ref_root;
u64 owner;
u64 offset;
if (!btrfs_test_opt(root->fs_info, REF_VERIFY)) if (!btrfs_test_opt(fs_info, REF_VERIFY))
return 0; return 0;
if (generic_ref->type == BTRFS_REF_METADATA) {
ref_root = generic_ref->tree_ref.root;
owner = generic_ref->tree_ref.level;
offset = 0;
} else {
ref_root = generic_ref->data_ref.ref_root;
owner = generic_ref->data_ref.ino;
offset = generic_ref->data_ref.offset;
}
metadata = owner < BTRFS_FIRST_FREE_OBJECTID;
ref = kzalloc(sizeof(struct ref_entry), GFP_NOFS); ref = kzalloc(sizeof(struct ref_entry), GFP_NOFS);
ra = kmalloc(sizeof(struct ref_action), GFP_NOFS); ra = kmalloc(sizeof(struct ref_action), GFP_NOFS);
if (!ra || !ref) { if (!ra || !ref) {
@ -732,7 +739,7 @@ int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,
INIT_LIST_HEAD(&ra->list); INIT_LIST_HEAD(&ra->list);
ra->action = action; ra->action = action;
ra->root = root->root_key.objectid; ra->root = generic_ref->real_root;
/* /*
* This is an allocation, preallocate the block_entry in case we haven't * This is an allocation, preallocate the block_entry in case we haven't
@ -745,7 +752,7 @@ int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,
* is and the new root objectid, so let's not treat the passed * is and the new root objectid, so let's not treat the passed
* in root as if it really has a ref for this bytenr. * in root as if it really has a ref for this bytenr.
*/ */
be = add_block_entry(root->fs_info, bytenr, num_bytes, ref_root); be = add_block_entry(fs_info, bytenr, num_bytes, ref_root);
if (IS_ERR(be)) { if (IS_ERR(be)) {
kfree(ra); kfree(ra);
ret = PTR_ERR(be); ret = PTR_ERR(be);
@ -787,13 +794,13 @@ int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,
* one we want to lookup below when we modify the * one we want to lookup below when we modify the
* re->num_refs. * re->num_refs.
*/ */
ref_root = root->root_key.objectid; ref_root = generic_ref->real_root;
re->root_objectid = root->root_key.objectid; re->root_objectid = generic_ref->real_root;
re->num_refs = 0; re->num_refs = 0;
} }
spin_lock(&root->fs_info->ref_verify_lock); spin_lock(&fs_info->ref_verify_lock);
be = lookup_block_entry(&root->fs_info->block_tree, bytenr); be = lookup_block_entry(&fs_info->block_tree, bytenr);
if (!be) { if (!be) {
btrfs_err(fs_info, btrfs_err(fs_info,
"trying to do action %d to bytenr %llu num_bytes %llu but there is no existing entry!", "trying to do action %d to bytenr %llu num_bytes %llu but there is no existing entry!",
@ -862,7 +869,7 @@ int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,
* didn't think of some other corner case. * didn't think of some other corner case.
*/ */
btrfs_err(fs_info, "failed to find root %llu for %llu", btrfs_err(fs_info, "failed to find root %llu for %llu",
root->root_key.objectid, be->bytenr); generic_ref->real_root, be->bytenr);
dump_block_entry(fs_info, be); dump_block_entry(fs_info, be);
dump_ref_action(fs_info, ra); dump_ref_action(fs_info, ra);
kfree(ra); kfree(ra);
@ -881,7 +888,7 @@ int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,
list_add_tail(&ra->list, &be->actions); list_add_tail(&ra->list, &be->actions);
ret = 0; ret = 0;
out_unlock: out_unlock:
spin_unlock(&root->fs_info->ref_verify_lock); spin_unlock(&fs_info->ref_verify_lock);
out: out:
if (ret) if (ret)
btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY); btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);

10
fs/btrfs/ref-verify.h
View File

@ -9,9 +9,8 @@
#ifdef CONFIG_BTRFS_FS_REF_VERIFY #ifdef CONFIG_BTRFS_FS_REF_VERIFY
int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info); int btrfs_build_ref_tree(struct btrfs_fs_info *fs_info);
void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info); void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info);
int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes, int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,
u64 parent, u64 ref_root, u64 owner, u64 offset, struct btrfs_ref *generic_ref);
int action);
void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info, u64 start, void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info, u64 start,
u64 len); u64 len);
@ -30,9 +29,8 @@ static inline void btrfs_free_ref_cache(struct btrfs_fs_info *fs_info)
{ {
} }
static inline int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, static inline int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,
u64 num_bytes, u64 parent, u64 ref_root, struct btrfs_ref *generic_ref)
u64 owner, u64 offset, int action)
{ {
return 0; return 0;
} }