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

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

btrfs: qgroup: Introduce function to find all new tree blocks of reloc tree 



Introduce new function, qgroup_trace_new_subtree_blocks(), to iterate
all new tree blocks in a reloc tree.
So that qgroup could skip unrelated tree blocks during balance, which
should hugely speedup balance speed when quota is enabled.

The function qgroup_trace_new_subtree_blocks() itself only cares about
new tree blocks in reloc tree.

All its main works are:

1) Read out tree blocks according to parent pointers

2) Do recursive depth-first search
   Will call the same function on all its children tree blocks, with
   search level set to current level -1.
   And will also skip all children whose generation is smaller than
   @last_snapshot.

3) Call qgroup_trace_extent_swap() to trace tree blocks

So although we have parameter list related to source file tree, it's not
used at all, but only passed to qgroup_trace_extent_swap().
Thus despite the tree read code, the core should be pretty short and all
about recursive depth-first search.

Signed-off-by: default avatarQu Wenruo <wqu@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 25982561

fs/btrfs/qgroup.c

+135 −0
Original line number Diff line number Diff line
@@ -1874,6 +1874,141 @@ static int qgroup_trace_extent_swap(struct btrfs_trans_handle* trans, 
	return ret;

}



/*

 * Helper function to do recursive generation-aware depth-first search, to

 * locate all new tree blocks in a subtree of reloc tree.

 *

 * E.g. (OO = Old tree blocks, NN = New tree blocks, whose gen == last_snapshot)

 *         reloc tree

 * L2         NN (a)

 *          /    \

 * L1    OO        NN (b)

 *      /  \      /  \

 * L0  OO  OO    OO  NN

 *               (c) (d)

 * If we pass:

 * @dst_path = [ nodes[1] = NN(b), nodes[0] = NULL ],

 * @cur_level = 1

 * @root_level = 1

 *

 * We will iterate through tree blocks NN(b), NN(d) and info qgroup to trace

 * above tree blocks along with their counter parts in file tree.

 * While during search, old tree blocsk OO(c) will be skiped as tree block swap

 * won't affect OO(c).

 */

static int qgroup_trace_new_subtree_blocks(struct btrfs_trans_handle* trans,

					   struct extent_buffer *src_eb,

					   struct btrfs_path *dst_path,

					   int cur_level, int root_level,

					   u64 last_snapshot)

{

	struct btrfs_fs_info *fs_info = trans->fs_info;

	struct extent_buffer *eb;

	bool need_cleanup = false;

	int ret = 0;

	int i;



	/* Level sanity check */

	if (cur_level < 0 || cur_level >= BTRFS_MAX_LEVEL ||

	    root_level < 0 || root_level >= BTRFS_MAX_LEVEL ||

	    root_level < cur_level) {

		btrfs_err_rl(fs_info,

			"%s: bad levels, cur_level=%d root_level=%d",

			__func__, cur_level, root_level);

		return -EUCLEAN;

	}



	/* Read the tree block if needed */

	if (dst_path->nodes[cur_level] == NULL) {

		struct btrfs_key first_key;

		int parent_slot;

		u64 child_gen;

		u64 child_bytenr;



		/*

		 * dst_path->nodes[root_level] must be initialized before

		 * calling this function.

		 */

		if (cur_level == root_level) {

			btrfs_err_rl(fs_info,

	"%s: dst_path->nodes[%d] not initialized, root_level=%d cur_level=%d",

				__func__, root_level, root_level, cur_level);

			return -EUCLEAN;

		}



		/*

		 * We need to get child blockptr/gen from parent before we can

		 * read it.

		  */

		eb = dst_path->nodes[cur_level + 1];

		parent_slot = dst_path->slots[cur_level + 1];

		child_bytenr = btrfs_node_blockptr(eb, parent_slot);

		child_gen = btrfs_node_ptr_generation(eb, parent_slot);

		btrfs_node_key_to_cpu(eb, &first_key, parent_slot);



		/* This node is old, no need to trace */

		if (child_gen < last_snapshot)

			goto out;



		eb = read_tree_block(fs_info, child_bytenr, child_gen,

				     cur_level, &first_key);

		if (IS_ERR(eb)) {

			ret = PTR_ERR(eb);

			goto out;

		} else if (!extent_buffer_uptodate(eb)) {

			free_extent_buffer(eb);

			ret = -EIO;

			goto out;

		}



		dst_path->nodes[cur_level] = eb;

		dst_path->slots[cur_level] = 0;



		btrfs_tree_read_lock(eb);

		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

		dst_path->locks[cur_level] = BTRFS_READ_LOCK_BLOCKING;

		need_cleanup = true;

	}



	/* Now record this tree block and its counter part for qgroups */

	ret = qgroup_trace_extent_swap(trans, src_eb, dst_path, cur_level,

				       root_level);

	if (ret < 0)

		goto cleanup;



	eb = dst_path->nodes[cur_level];



	if (cur_level > 0) {

		/* Iterate all child tree blocks */

		for (i = 0; i < btrfs_header_nritems(eb); i++) {

			/* Skip old tree blocks as they won't be swapped */

			if (btrfs_node_ptr_generation(eb, i) < last_snapshot)

				continue;

			dst_path->slots[cur_level] = i;



			/* Recursive call (at most 7 times) */

			ret = qgroup_trace_new_subtree_blocks(trans, src_eb,

					dst_path, cur_level - 1, root_level,

					last_snapshot);

			if (ret < 0)

				goto cleanup;

		}

	}



cleanup:

	if (need_cleanup) {

		/* Clean up */

		btrfs_tree_unlock_rw(dst_path->nodes[cur_level],

				     dst_path->locks[cur_level]);

		free_extent_buffer(dst_path->nodes[cur_level]);

		dst_path->nodes[cur_level] = NULL;

		dst_path->slots[cur_level] = 0;

		dst_path->locks[cur_level] = 0;

	}

out:

	return ret;

}



int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,

			       struct extent_buffer *root_eb,

			       u64 root_gen, int root_level)