btrfs: qgroup: Introduce function to trace two swaped extents

	return 0;

}

/*

 * Helper function to trace a subtree tree block swap.

 *

 * The swap will happen in highest tree block, but there may be a lot of

 * tree blocks involved.

 *

 * For example:

 *  OO = Old tree blocks

 *  NN = New tree blocks allocated during balance

 *

 *           File tree (257)                  Reloc tree for 257

 * L2              OO                                NN

 *               /    \                            /    \

 * L1          OO      OO (a)                    OO      NN (a)

 *            / \     / \                       / \     / \

 * L0       OO   OO OO   OO                   OO   OO NN   NN

 *                  (b)  (c)                          (b)  (c)

 *

 * When calling qgroup_trace_extent_swap(), we will pass:

 * @src_eb = OO(a)

 * @dst_path = [ nodes[1] = NN(a), nodes[0] = NN(c) ]

 * @dst_level = 0

 * @root_level = 1

 *

 * In that case, qgroup_trace_extent_swap() will search from OO(a) to

 * reach OO(c), then mark both OO(c) and NN(c) as qgroup dirty.

 *

 * The main work of qgroup_trace_extent_swap() can be split into 3 parts:

 *

 * 1) Tree search from @src_eb

 *    It should acts as a simplified btrfs_search_slot().

 *    The key for search can be extracted from @dst_path->nodes[dst_level]

 *    (first key).

 *

 * 2) Mark the final tree blocks in @src_path and @dst_path qgroup dirty

 *    NOTE: In above case, OO(a) and NN(a) won't be marked qgroup dirty.

 *    They should be marked during preivous (@dst_level = 1) iteration.

 *

 * 3) Mark file extents in leaves dirty

 *    We don't have good way to pick out new file extents only.

 *    So we still follow the old method by scanning all file extents in

 *    the leave.

 *

 * This function can free us from keeping two pathes, thus later we only need

 * to care about how to iterate all new tree blocks in reloc tree.

 */

static int qgroup_trace_extent_swap(struct btrfs_trans_handle* trans,

				    struct extent_buffer *src_eb,

				    struct btrfs_path *dst_path,

				    int dst_level, int root_level)

{

	struct btrfs_key key;

	struct btrfs_path *src_path;

	struct btrfs_fs_info *fs_info = trans->fs_info;

	u32 nodesize = fs_info->nodesize;

	int cur_level = root_level;

	int ret;

	BUG_ON(dst_level > root_level);

	/* Level mismatch */

	if (btrfs_header_level(src_eb) != root_level)

		return -EINVAL;

	src_path = btrfs_alloc_path();

	if (!src_path) {

		ret = -ENOMEM;

		goto out;

	}

	if (dst_level)

		btrfs_node_key_to_cpu(dst_path->nodes[dst_level], &key, 0);

	else

		btrfs_item_key_to_cpu(dst_path->nodes[dst_level], &key, 0);

	/* For src_path */

	extent_buffer_get(src_eb);

	src_path->nodes[root_level] = src_eb;

	src_path->slots[root_level] = dst_path->slots[root_level];

	src_path->locks[root_level] = 0;

	/* A simplified version of btrfs_search_slot() */

	while (cur_level >= dst_level) {

		struct btrfs_key src_key;

		struct btrfs_key dst_key;

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

			struct btrfs_key first_key;

			struct extent_buffer *eb;

			int parent_slot;

			u64 child_gen;

			u64 child_bytenr;

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

			parent_slot = src_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);

			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;

			}

			src_path->nodes[cur_level] = eb;

			btrfs_tree_read_lock(eb);

			btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);

			src_path->locks[cur_level] = BTRFS_READ_LOCK_BLOCKING;

		}

		src_path->slots[cur_level] = dst_path->slots[cur_level];

		if (cur_level) {

			btrfs_node_key_to_cpu(dst_path->nodes[cur_level],

					&dst_key, dst_path->slots[cur_level]);

			btrfs_node_key_to_cpu(src_path->nodes[cur_level],

					&src_key, src_path->slots[cur_level]);

		} else {

			btrfs_item_key_to_cpu(dst_path->nodes[cur_level],

					&dst_key, dst_path->slots[cur_level]);

			btrfs_item_key_to_cpu(src_path->nodes[cur_level],

					&src_key, src_path->slots[cur_level]);

		}

		/* Content mismatch, something went wrong */

		if (btrfs_comp_cpu_keys(&dst_key, &src_key)) {

			ret = -ENOENT;

			goto out;

		}

		cur_level--;

	}

	/*

	 * Now both @dst_path and @src_path have been populated, record the tree

	 * blocks for qgroup accounting.

	 */

	ret = btrfs_qgroup_trace_extent(trans, src_path->nodes[dst_level]->start,

			nodesize, GFP_NOFS);

	if (ret < 0)

		goto out;

	ret = btrfs_qgroup_trace_extent(trans,

			dst_path->nodes[dst_level]->start,

			nodesize, GFP_NOFS);

	if (ret < 0)

		goto out;

	/* Record leaf file extents */

	if (dst_level == 0) {

		ret = btrfs_qgroup_trace_leaf_items(trans, src_path->nodes[0]);

		if (ret < 0)

			goto out;

		ret = btrfs_qgroup_trace_leaf_items(trans, dst_path->nodes[0]);

	}

out:

	btrfs_free_path(src_path);

	return ret;

}

int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,

			       struct extent_buffer *root_eb,

			       u64 root_gen, int root_level)