btrfs: reloc: add btrfs_ prefix for backref_node/edge/cache

 */

/*

 * backref_node, mapping_node and tree_block start with this

 * btrfs_backref_node, mapping_node and tree_block start with this

 */

struct tree_entry {

	struct rb_node rb_node;

/*

 * present a tree block in the backref cache

 */

struct backref_node {

struct btrfs_backref_node {

	struct rb_node rb_node;

	u64 bytenr;

/*

 * present an edge connecting upper and lower backref nodes.

 */

struct backref_edge {

struct btrfs_backref_edge {

	/*

	 * list[LOWER] is linked to backref_node::upper of lower level node,

	 * and list[UPPER] is linked to backref_node::lower of upper level node.

	 * list[LOWER] is linked to btrfs_backref_node::upper of lower level

	 * node, and list[UPPER] is linked to btrfs_backref_node::lower of

	 * upper level node.

	 *

	 * Also, build_backref_tree() uses list[UPPER] for pending edges, before

	 * linking list[UPPER] to its upper level nodes.

	struct list_head list[2];

	/* Two related nodes */

	struct backref_node *node[2];

	struct btrfs_backref_node *node[2];

};

struct backref_cache {

struct btrfs_backref_cache {

	/* red black tree of all backref nodes in the cache */

	struct rb_root rb_root;

	/* for passing backref nodes to btrfs_reloc_cow_block */

	struct backref_node *path[BTRFS_MAX_LEVEL];

	struct btrfs_backref_node *path[BTRFS_MAX_LEVEL];

	/*

	 * list of blocks that have been cowed but some block

	 * pointers in upper level blocks may not reflect the

	struct btrfs_block_rsv *block_rsv;

	struct backref_cache backref_cache;

	struct btrfs_backref_cache backref_cache;

	struct file_extent_cluster cluster;

	/* tree blocks have been processed */

#define MOVE_DATA_EXTENTS	0

#define UPDATE_DATA_PTRS	1

static void remove_backref_node(struct backref_cache *cache,

				struct backref_node *node);

static void remove_backref_node(struct btrfs_backref_cache *cache,

				struct btrfs_backref_node *node);

static void mark_block_processed(struct reloc_control *rc,

				 struct backref_node *node)

				 struct btrfs_backref_node *node)

{

	u32 blocksize;

}

static void backref_cache_init(struct btrfs_fs_info *fs_info,

			       struct backref_cache *cache, int is_reloc)

			       struct btrfs_backref_cache *cache, int is_reloc)

{

	int i;

	cache->rb_root = RB_ROOT;

	cache->is_reloc = is_reloc;

}

static void backref_cache_cleanup(struct backref_cache *cache)

static void backref_cache_cleanup(struct btrfs_backref_cache *cache)

{

	struct backref_node *node;

	struct btrfs_backref_node *node;

	int i;

	while (!list_empty(&cache->detached)) {

		node = list_entry(cache->detached.next,

				  struct backref_node, list);

				  struct btrfs_backref_node, list);

		remove_backref_node(cache, node);

	}

	while (!list_empty(&cache->leaves)) {

		node = list_entry(cache->leaves.next,

				  struct backref_node, lower);

				  struct btrfs_backref_node, lower);

		remove_backref_node(cache, node);

	}

	ASSERT(!cache->nr_edges);

}

static struct backref_node *alloc_backref_node(struct backref_cache *cache,

						u64 bytenr, int level)

static struct btrfs_backref_node *alloc_backref_node(

		struct btrfs_backref_cache *cache, u64 bytenr, int level)

{

	struct backref_node *node;

	struct btrfs_backref_node *node;

	ASSERT(level >= 0 && level < BTRFS_MAX_LEVEL);

	node = kzalloc(sizeof(*node), GFP_NOFS);

	return node;

}

static void free_backref_node(struct backref_cache *cache,

			      struct backref_node *node)

static void free_backref_node(struct btrfs_backref_cache *cache,

			      struct btrfs_backref_node *node)

{

	if (node) {

		cache->nr_nodes--;

	}

}

static struct backref_edge *alloc_backref_edge(struct backref_cache *cache)

static struct btrfs_backref_edge *alloc_backref_edge(

		struct btrfs_backref_cache *cache)

{

	struct backref_edge *edge;

	struct btrfs_backref_edge *edge;

	edge = kzalloc(sizeof(*edge), GFP_NOFS);

	if (edge)

#define		LINK_LOWER	(1 << 0)

#define		LINK_UPPER	(1 << 1)

static void link_backref_edge(struct backref_edge *edge,

			      struct backref_node *lower,

			      struct backref_node *upper,

static void link_backref_edge(struct btrfs_backref_edge *edge,

			      struct btrfs_backref_node *lower,

			      struct btrfs_backref_node *upper,

			      int link_which)

{

	ASSERT(upper && lower && upper->level == lower->level + 1);

		list_add_tail(&edge->list[UPPER], &upper->lower);

}

static void free_backref_edge(struct backref_cache *cache,

			      struct backref_edge *edge)

static void free_backref_edge(struct btrfs_backref_cache *cache,

			      struct btrfs_backref_edge *edge)

{

	if (edge) {

		cache->nr_edges--;

{

	struct btrfs_fs_info *fs_info = NULL;

	struct backref_node *bnode = rb_entry(rb_node, struct backref_node,

					      rb_node);

	struct btrfs_backref_node *bnode = rb_entry(rb_node,

			struct btrfs_backref_node, rb_node);

	if (bnode->root)

		fs_info = bnode->root->fs_info;

	btrfs_panic(fs_info, errno,

/*

 * walk up backref nodes until reach node presents tree root

 */

static struct backref_node *walk_up_backref(struct backref_node *node,

					    struct backref_edge *edges[],

					    int *index)

static struct btrfs_backref_node *walk_up_backref(

		struct btrfs_backref_node *node,

		struct btrfs_backref_edge *edges[], int *index)

{

	struct backref_edge *edge;

	struct btrfs_backref_edge *edge;

	int idx = *index;

	while (!list_empty(&node->upper)) {

		edge = list_entry(node->upper.next,

				  struct backref_edge, list[LOWER]);

				  struct btrfs_backref_edge, list[LOWER]);

		edges[idx++] = edge;

		node = edge->node[UPPER];

	}

/*

 * walk down backref nodes to find start of next reference path

 */

static struct backref_node *walk_down_backref(struct backref_edge *edges[],

					      int *index)

static struct btrfs_backref_node *walk_down_backref(

		struct btrfs_backref_edge *edges[], int *index)

{

	struct backref_edge *edge;

	struct backref_node *lower;

	struct btrfs_backref_edge *edge;

	struct btrfs_backref_node *lower;

	int idx = *index;

	while (idx > 0) {

			continue;

		}

		edge = list_entry(edge->list[LOWER].next,

				  struct backref_edge, list[LOWER]);

				  struct btrfs_backref_edge, list[LOWER]);

		edges[idx - 1] = edge;

		*index = idx;

		return edge->node[UPPER];

	return NULL;

}

static void unlock_node_buffer(struct backref_node *node)

static void unlock_node_buffer(struct btrfs_backref_node *node)

{

	if (node->locked) {

		btrfs_tree_unlock(node->eb);

	}

}

static void drop_node_buffer(struct backref_node *node)

static void drop_node_buffer(struct btrfs_backref_node *node)

{

	if (node->eb) {

		unlock_node_buffer(node);

	}

}

static void drop_backref_node(struct backref_cache *tree,

			      struct backref_node *node)

static void drop_backref_node(struct btrfs_backref_cache *tree,

			      struct btrfs_backref_node *node)

{

	BUG_ON(!list_empty(&node->upper));

/*

 * remove a backref node from the backref cache

 */

static void remove_backref_node(struct backref_cache *cache,

				struct backref_node *node)

static void remove_backref_node(struct btrfs_backref_cache *cache,

				struct btrfs_backref_node *node)

{

	struct backref_node *upper;

	struct backref_edge *edge;

	struct btrfs_backref_node *upper;

	struct btrfs_backref_edge *edge;

	if (!node)

		return;

	BUG_ON(!node->lowest && !node->detached);

	while (!list_empty(&node->upper)) {

		edge = list_entry(node->upper.next, struct backref_edge,

		edge = list_entry(node->upper.next, struct btrfs_backref_edge,

				  list[LOWER]);

		upper = edge->node[UPPER];

		list_del(&edge->list[LOWER]);

	drop_backref_node(cache, node);

}

static void update_backref_node(struct backref_cache *cache,

				struct backref_node *node, u64 bytenr)

static void update_backref_node(struct btrfs_backref_cache *cache,

				struct btrfs_backref_node *node, u64 bytenr)

{

	struct rb_node *rb_node;

	rb_erase(&node->rb_node, &cache->rb_root);

 * update backref cache after a transaction commit

 */

static int update_backref_cache(struct btrfs_trans_handle *trans,

				struct backref_cache *cache)

				struct btrfs_backref_cache *cache)

{

	struct backref_node *node;

	struct btrfs_backref_node *node;

	int level = 0;

	if (cache->last_trans == 0) {

	 */

	while (!list_empty(&cache->detached)) {

		node = list_entry(cache->detached.next,

				  struct backref_node, list);

				  struct btrfs_backref_node, list);

		remove_backref_node(cache, node);

	}

	while (!list_empty(&cache->changed)) {

		node = list_entry(cache->changed.next,

				  struct backref_node, list);

				  struct btrfs_backref_node, list);

		list_del_init(&node->list);

		BUG_ON(node->pending);

		update_backref_node(cache, node, node->new_bytenr);

 *		type is btrfs_inline_ref_type, offset is

 *		btrfs_inline_ref_offset.

 */

static int handle_direct_tree_backref(struct backref_cache *cache,

static int handle_direct_tree_backref(struct btrfs_backref_cache *cache,

				      struct btrfs_key *ref_key,

				      struct backref_node *cur)

				      struct btrfs_backref_node *cur)

{

	struct backref_edge *edge;

	struct backref_node *upper;

	struct btrfs_backref_edge *edge;

	struct btrfs_backref_node *upper;

	struct rb_node *rb_node;

	ASSERT(ref_key->type == BTRFS_SHARED_BLOCK_REF_KEY);

		list_add_tail(&edge->list[UPPER], &cache->pending_edge);

	} else {

		/* Parent node already cached */

		upper = rb_entry(rb_node, struct backref_node, rb_node);

		upper = rb_entry(rb_node, struct btrfs_backref_node, rb_node);

		ASSERT(upper->checked);

		INIT_LIST_HEAD(&edge->list[UPPER]);

	}

 * @path:	A clean (released) path, to avoid allocating path everytime

 *		the function get called.

 */

static int handle_indirect_tree_backref(struct backref_cache *cache,

static int handle_indirect_tree_backref(struct btrfs_backref_cache *cache,

					struct btrfs_path *path,

					struct btrfs_key *ref_key,

					struct btrfs_key *tree_key,

					struct backref_node *cur)

					struct btrfs_backref_node *cur)

{

	struct btrfs_fs_info *fs_info = cache->fs_info;

	struct backref_node *upper;

	struct backref_node *lower;

	struct backref_edge *edge;

	struct btrfs_backref_node *upper;

	struct btrfs_backref_node *lower;

	struct btrfs_backref_edge *edge;

	struct extent_buffer *eb;

	struct btrfs_root *root;

	struct rb_node *rb_node;

				INIT_LIST_HEAD(&edge->list[UPPER]);

			}

		} else {

			upper = rb_entry(rb_node, struct backref_node, rb_node);

			upper = rb_entry(rb_node, struct btrfs_backref_node,

					 rb_node);

			ASSERT(upper->checked);

			INIT_LIST_HEAD(&edge->list[UPPER]);

			if (!upper->owner)

	return ret;

}

static int handle_one_tree_block(struct backref_cache *cache,

static int handle_one_tree_block(struct btrfs_backref_cache *cache,

				 struct btrfs_path *path,

				 struct btrfs_backref_iter *iter,

				 struct btrfs_key *node_key,

				 struct backref_node *cur)

				 struct btrfs_backref_node *cur)

{

	struct btrfs_fs_info *fs_info = cache->fs_info;

	struct backref_edge *edge;

	struct backref_node *exist;

	struct btrfs_backref_edge *edge;

	struct btrfs_backref_node *exist;

	int ret;

	ret = btrfs_backref_iter_start(iter, cur->bytenr);

		 * backref of type BTRFS_TREE_BLOCK_REF_KEY

		 */

		ASSERT(list_is_singular(&cur->upper));

		edge = list_entry(cur->upper.next, struct backref_edge,

		edge = list_entry(cur->upper.next, struct btrfs_backref_edge,

				  list[LOWER]);

		ASSERT(list_empty(&edge->list[UPPER]));

		exist = edge->node[UPPER];

/*

 * In handle_one_tree_backref(), we have only linked the lower node to the edge,

 * but the upper node hasn't been linked to the edge.

 * This means we can only iterate through backref_node::upper to reach parent

 * edges, but not through backref_node::lower to reach children edges.

 * This means we can only iterate through btrfs_backref_node::upper to reach

 * parent edges, but not through btrfs_backref_node::lower to reach children

 * edges.

 *

 * This function will finish the backref_node::lower to related edges, so that

 * backref cache can be bi-directionally iterated.

 * This function will finish the btrfs_backref_node::lower to related edges,

 * so that backref cache can be bi-directionally iterated.

 *

 * Also, this will add the nodes to backref cache for the next run.

 */

static int finish_upper_links(struct backref_cache *cache,

			      struct backref_node *start)

static int finish_upper_links(struct btrfs_backref_cache *cache,

			      struct btrfs_backref_node *start)

{

	struct list_head *useless_node = &cache->useless_node;

	struct backref_edge *edge;

	struct btrfs_backref_edge *edge;

	struct rb_node *rb_node;

	LIST_HEAD(pending_edge);

		list_add_tail(&edge->list[UPPER], &pending_edge);

	while (!list_empty(&pending_edge)) {

		struct backref_node *upper;

		struct backref_node *lower;

		struct btrfs_backref_node *upper;

		struct btrfs_backref_node *lower;

		struct rb_node *rb_node;

		edge = list_first_entry(&pending_edge, struct backref_edge,

				  list[UPPER]);

		edge = list_first_entry(&pending_edge,

				struct btrfs_backref_edge, list[UPPER]);

		list_del_init(&edge->list[UPPER]);

		upper = edge->node[UPPER];

		lower = edge->node[LOWER];

 * Return true if @node is in the @useless_nodes list.

 */

static bool handle_useless_nodes(struct reloc_control *rc,

				 struct backref_node *node)

				 struct btrfs_backref_node *node)

{

	struct backref_cache *cache = &rc->backref_cache;

	struct btrfs_backref_cache *cache = &rc->backref_cache;

	struct list_head *useless_node = &cache->useless_node;

	bool ret = false;

	while (!list_empty(useless_node)) {

		struct backref_node *cur;

		struct btrfs_backref_node *cur;

		cur = list_first_entry(useless_node, struct backref_node,

		cur = list_first_entry(useless_node, struct btrfs_backref_node,

				 list);

		list_del_init(&cur->list);

		/* Cleanup the lower edges */

		while (!list_empty(&cur->lower)) {

			struct backref_edge *edge;

			struct backref_node *lower;

			struct btrfs_backref_edge *edge;

			struct btrfs_backref_node *lower;

			edge = list_entry(cur->lower.next,

					  struct backref_edge, list[UPPER]);

					struct btrfs_backref_edge, list[UPPER]);

			list_del(&edge->list[UPPER]);

			list_del(&edge->list[LOWER]);

			lower = edge->node[LOWER];

 * all upper level blocks that directly/indirectly reference the block are also

 * cached.

 */

static noinline_for_stack struct backref_node *build_backref_tree(

static noinline_for_stack struct btrfs_backref_node *build_backref_tree(

			struct reloc_control *rc, struct btrfs_key *node_key,

			int level, u64 bytenr)

{

	struct btrfs_backref_iter *iter;

	struct backref_cache *cache = &rc->backref_cache;

	struct btrfs_backref_cache *cache = &rc->backref_cache;

	/* For searching parent of TREE_BLOCK_REF */

	struct btrfs_path *path;

	struct backref_node *cur;

	struct backref_node *upper;

	struct backref_node *lower;

	struct backref_node *node = NULL;

	struct backref_edge *edge;

	struct btrfs_backref_node *cur;

	struct btrfs_backref_node *upper;

	struct btrfs_backref_node *lower;

	struct btrfs_backref_node *node = NULL;

	struct btrfs_backref_edge *edge;

	int ret;

	int err = 0;

			goto out;

		}

		edge = list_first_entry_or_null(&cache->pending_edge,

				struct backref_edge, list[UPPER]);

				struct btrfs_backref_edge, list[UPPER]);

		/*

		 * The pending list isn't empty, take the first block to

		 * process

	if (err) {

		while (!list_empty(&cache->useless_node)) {

			lower = list_first_entry(&cache->useless_node,

					   struct backref_node, list);

					   struct btrfs_backref_node, list);

			list_del_init(&lower->list);

		}

		while (!list_empty(&cache->pending_edge)) {

			edge = list_first_entry(&cache->pending_edge,

					struct backref_edge, list[UPPER]);

					struct btrfs_backref_edge, list[UPPER]);

			list_del(&edge->list[UPPER]);

			list_del(&edge->list[LOWER]);

			lower = edge->node[LOWER];

		while (!list_empty(&cache->useless_node)) {

			lower = list_first_entry(&cache->useless_node,

					   struct backref_node, list);

					   struct btrfs_backref_node, list);

			list_del_init(&lower->list);

			if (lower == node)

				node = NULL;

			      struct btrfs_root *dest)

{

	struct btrfs_root *reloc_root = src->reloc_root;

	struct backref_cache *cache = &rc->backref_cache;

	struct backref_node *node = NULL;

	struct backref_node *new_node;

	struct backref_edge *edge;

	struct backref_edge *new_edge;

	struct btrfs_backref_cache *cache = &rc->backref_cache;

	struct btrfs_backref_node *node = NULL;

	struct btrfs_backref_node *new_node;

	struct btrfs_backref_edge *edge;

	struct btrfs_backref_edge *new_edge;

	struct rb_node *rb_node;

	if (cache->last_trans > 0)

	rb_node = tree_search(&cache->rb_root, src->commit_root->start);

	if (rb_node) {

		node = rb_entry(rb_node, struct backref_node, rb_node);

		node = rb_entry(rb_node, struct btrfs_backref_node, rb_node);

		if (node->detached)

			node = NULL;

		else

		rb_node = tree_search(&cache->rb_root,

				      reloc_root->commit_root->start);

		if (rb_node) {

			node = rb_entry(rb_node, struct backref_node,

			node = rb_entry(rb_node, struct btrfs_backref_node,

					rb_node);

			BUG_ON(node->detached);

		}

fail:

	while (!list_empty(&new_node->lower)) {

		new_edge = list_entry(new_node->lower.next,

				      struct backref_edge, list[UPPER]);

				      struct btrfs_backref_edge, list[UPPER]);

		list_del(&new_edge->list[UPPER]);

		free_backref_edge(cache, new_edge);

	}

static noinline_for_stack

struct btrfs_root *select_reloc_root(struct btrfs_trans_handle *trans,

				     struct reloc_control *rc,

				     struct backref_node *node,

				     struct backref_edge *edges[])

				     struct btrfs_backref_node *node,

				     struct btrfs_backref_edge *edges[])

{

	struct backref_node *next;

	struct btrfs_backref_node *next;

	struct btrfs_root *root;

	int index = 0;

 * counted. return -ENOENT if the block is root of reloc tree.

 */

static noinline_for_stack

struct btrfs_root *select_one_root(struct backref_node *node)

struct btrfs_root *select_one_root(struct btrfs_backref_node *node)