Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8a5040f7 authored by Qu Wenruo's avatar Qu Wenruo Committed by David Sterba
Browse files

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: default avatarQu Wenruo <wqu@suse.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 76675593

fs/btrfs/extent-tree.c

+8 −19
Original line number Diff line number Diff line
@@ -2054,9 +2054,6 @@ int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, 
	BUG_ON(owner < BTRFS_FIRST_FREE_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,

			       num_bytes, parent);

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

	}



	btrfs_ref_tree_mod(fs_info, &generic_ref);



	if (ret == 0 && old_ref_mod < 0 && new_ref_mod >= 0) {

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

		int old_ref_mod, new_ref_mod;



		btrfs_ref_tree_mod(root, buf->start, buf->len, parent,

				   root->root_key.objectid,

				   btrfs_header_level(buf), 0,

				   BTRFS_DROP_DELAYED_REF);

		btrfs_ref_tree_mod(fs_info, &generic_ref);

		ret = btrfs_add_delayed_tree_ref(trans, &generic_ref, NULL,

						 &old_ref_mod, &new_ref_mod);

		BUG_ON(ret); /* -ENOMEM */
@@ -7251,11 +7247,6 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, 
	if (btrfs_is_testing(fs_info))

		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,

			       num_bytes, parent);

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

	}



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

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



	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,

			       ins->objectid, ins->offset, 0);

	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,

					 ram_bytes, NULL, NULL);

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

				       ins.objectid, ins.offset, parent);

		generic_ref.real_root = root->root_key.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,

						 extent_op, NULL, NULL);

		if (ret)

fs/btrfs/ref-verify.c

+30 −23
Original line number Diff line number Diff line
@@ -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

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

 * 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

 * our sanity checks pass as they are no longer needed.

 */

int btrfs_ref_tree_mod(struct btrfs_root *root, u64 bytenr, u64 num_bytes,

		       u64 parent, u64 ref_root, u64 owner, u64 offset,

		       int action)

int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

		       struct btrfs_ref *generic_ref)

{

	struct btrfs_fs_info *fs_info = root->fs_info;

	struct ref_entry *ref = NULL, *exist;

	struct ref_action *ra = NULL;

	struct block_entry *be = NULL;

	struct root_entry *re = NULL;

	int action = generic_ref->action;

	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;



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

	ra = kmalloc(sizeof(struct ref_action), GFP_NOFS);

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

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

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

			kfree(ra);

			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

			 * re->num_refs.

			 */

			ref_root = root->root_key.objectid;

			re->root_objectid = root->root_key.objectid;

			ref_root = generic_ref->real_root;

			re->root_objectid = generic_ref->real_root;

			re->num_refs = 0;

		}



		spin_lock(&root->fs_info->ref_verify_lock);

		be = lookup_block_entry(&root->fs_info->block_tree, bytenr);

		spin_lock(&fs_info->ref_verify_lock);

		be = lookup_block_entry(&fs_info->block_tree, bytenr);

		if (!be) {

			btrfs_err(fs_info,

"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.

			 */

			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_ref_action(fs_info, 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);

	ret = 0;

out_unlock:

	spin_unlock(&root->fs_info->ref_verify_lock);

	spin_unlock(&fs_info->ref_verify_lock);

out:

	if (ret)

		btrfs_clear_opt(fs_info->mount_opt, REF_VERIFY);

fs/btrfs/ref-verify.h

+4 −6
Original line number Diff line number Diff line
@@ -9,9 +9,8 @@ 
#ifdef CONFIG_BTRFS_FS_REF_VERIFY

int btrfs_build_ref_tree(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,

		       u64 parent, u64 ref_root, u64 owner, u64 offset,

		       int action);

int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

		       struct btrfs_ref *generic_ref);

void btrfs_free_ref_tree_range(struct btrfs_fs_info *fs_info, u64 start,

			       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,

				     u64 num_bytes, u64 parent, u64 ref_root,

				     u64 owner, u64 offset, int action)

static inline int btrfs_ref_tree_mod(struct btrfs_fs_info *fs_info,

		       struct btrfs_ref *generic_ref)

{

	return 0;

}