Commit c46effa6 authored by Liu Bo's avatar Liu Bo Committed by Chris Mason
Browse files

Btrfs: introduce a head ref rbtree 



The way how we process delayed refs is
1) get a bunch of head refs,
2) pick up one head ref,
3) go one node back for any delayed ref updates.

The head ref is also linked in the same rbtree as the delayed ref is,
so in 1) stage, we have to walk one by one including not only head refs, but
delayed refs.

When we have a great number of delayed refs pending to process,
this'll cost time a lot.

Here we introduce a head ref specific rbtree, it only has head refs, so troubles
go away.

Signed-off-by: default avatarLiu Bo <bo.li.liu@oracle.com>
Signed-off-by: default avatarJosef Bacik <jbacik@fusionio.com>
Signed-off-by: default avatarChris Mason <clm@fb.com>
parent e20d6c5b

fs/btrfs/delayed-ref.c

+74 −52
Original line number Diff line number Diff line
@@ -161,35 +161,61 @@ static struct btrfs_delayed_ref_node *tree_insert(struct rb_root *root, 
	return NULL;

}



/* insert a new ref to head ref rbtree */

static struct btrfs_delayed_ref_head *htree_insert(struct rb_root *root,

						   struct rb_node *node)

{

	struct rb_node **p = &root->rb_node;

	struct rb_node *parent_node = NULL;

	struct btrfs_delayed_ref_head *entry;

	struct btrfs_delayed_ref_head *ins;

	u64 bytenr;



	ins = rb_entry(node, struct btrfs_delayed_ref_head, href_node);

	bytenr = ins->node.bytenr;

	while (*p) {

		parent_node = *p;

		entry = rb_entry(parent_node, struct btrfs_delayed_ref_head,

				 href_node);



		if (bytenr < entry->node.bytenr)

			p = &(*p)->rb_left;

		else if (bytenr > entry->node.bytenr)

			p = &(*p)->rb_right;

		else

			return entry;

	}



	rb_link_node(node, parent_node, p);

	rb_insert_color(node, root);

	return NULL;

}



/*

 * find an head entry based on bytenr. This returns the delayed ref

 * head if it was able to find one, or NULL if nothing was in that spot.

 * If return_bigger is given, the next bigger entry is returned if no exact

 * match is found.

 */

static struct btrfs_delayed_ref_node *find_ref_head(struct rb_root *root,

				  u64 bytenr,

				  struct btrfs_delayed_ref_node **last,

				  int return_bigger)

static struct btrfs_delayed_ref_head *

find_ref_head(struct rb_root *root, u64 bytenr,

	      struct btrfs_delayed_ref_head **last, int return_bigger)

{

	struct rb_node *n;

	struct btrfs_delayed_ref_node *entry;

	struct btrfs_delayed_ref_head *entry;

	int cmp = 0;



again:

	n = root->rb_node;

	entry = NULL;

	while (n) {

		entry = rb_entry(n, struct btrfs_delayed_ref_node, rb_node);

		WARN_ON(!entry->in_tree);

		entry = rb_entry(n, struct btrfs_delayed_ref_head, href_node);

		if (last)

			*last = entry;



		if (bytenr < entry->bytenr)

		if (bytenr < entry->node.bytenr)

			cmp = -1;

		else if (bytenr > entry->bytenr)

			cmp = 1;

		else if (!btrfs_delayed_ref_is_head(entry))

		else if (bytenr > entry->node.bytenr)

			cmp = 1;

		else

			cmp = 0;
@@ -203,12 +229,12 @@ again: 
	}

	if (entry && return_bigger) {

		if (cmp > 0) {

			n = rb_next(&entry->rb_node);

			n = rb_next(&entry->href_node);

			if (!n)

				n = rb_first(root);

			entry = rb_entry(n, struct btrfs_delayed_ref_node,

					 rb_node);

			bytenr = entry->bytenr;

			entry = rb_entry(n, struct btrfs_delayed_ref_head,

					 href_node);

			bytenr = entry->node.bytenr;

			return_bigger = 0;

			goto again;

		}
@@ -246,6 +272,12 @@ static inline void drop_delayed_ref(struct btrfs_trans_handle *trans, 
				    struct btrfs_delayed_ref_node *ref)

{

	rb_erase(&ref->rb_node, &delayed_refs->root);

	if (btrfs_delayed_ref_is_head(ref)) {

		struct btrfs_delayed_ref_head *head;



		head = btrfs_delayed_node_to_head(ref);

		rb_erase(&head->href_node, &delayed_refs->href_root);

	}

	ref->in_tree = 0;

	btrfs_put_delayed_ref(ref);

	delayed_refs->num_entries--;
@@ -379,25 +411,19 @@ int btrfs_find_ref_cluster(struct btrfs_trans_handle *trans, 
	int count = 0;

	struct btrfs_delayed_ref_root *delayed_refs;

	struct rb_node *node;

	struct btrfs_delayed_ref_node *ref;

	struct btrfs_delayed_ref_head *head;

	struct btrfs_delayed_ref_head *head = NULL;



	delayed_refs = &trans->transaction->delayed_refs;

	if (start == 0) {

		node = rb_first(&delayed_refs->root);

	} else {

		ref = NULL;

		find_ref_head(&delayed_refs->root, start + 1, &ref, 1);

		if (ref) {

			node = &ref->rb_node;

		} else

			node = rb_first(&delayed_refs->root);

	node = rb_first(&delayed_refs->href_root);



	if (start) {

		find_ref_head(&delayed_refs->href_root, start + 1, &head, 1);

		if (head)

			node = &head->href_node;

	}

again:

	while (node && count < 32) {

		ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);

		if (btrfs_delayed_ref_is_head(ref)) {

			head = btrfs_delayed_node_to_head(ref);

		head = rb_entry(node, struct btrfs_delayed_ref_head, href_node);

		if (list_empty(&head->cluster)) {

			list_add_tail(&head->cluster, cluster);

			delayed_refs->run_delayed_start =
@@ -415,7 +441,6 @@ again: 
			 */

			break;

		}

		}

		node = rb_next(node);

	}

	if (count) {
@@ -426,7 +451,7 @@ again: 
		 * clusters.  start from the beginning and try again

		 */

		start = 0;

		node = rb_first(&delayed_refs->root);

		node = rb_first(&delayed_refs->href_root);

		goto again;

	}

	return 1;
@@ -612,6 +637,7 @@ static noinline void add_delayed_ref_head(struct btrfs_fs_info *fs_info, 
		 */

		kmem_cache_free(btrfs_delayed_ref_head_cachep, head_ref);

	} else {

		htree_insert(&delayed_refs->href_root, &head_ref->href_node);

		delayed_refs->num_heads++;

		delayed_refs->num_heads_ready++;

		delayed_refs->num_entries++;
@@ -869,14 +895,10 @@ int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, 
struct btrfs_delayed_ref_head *

btrfs_find_delayed_ref_head(struct btrfs_trans_handle *trans, u64 bytenr)

{

	struct btrfs_delayed_ref_node *ref;

	struct btrfs_delayed_ref_root *delayed_refs;



	delayed_refs = &trans->transaction->delayed_refs;

	ref = find_ref_head(&delayed_refs->root, bytenr, NULL, 0);

	if (ref)

		return btrfs_delayed_node_to_head(ref);

	return NULL;

	return find_ref_head(&delayed_refs->href_root, bytenr, NULL, 0);

}



void btrfs_delayed_ref_exit(void)

fs/btrfs/delayed-ref.h

+5 −0
Original line number Diff line number Diff line
@@ -83,6 +83,8 @@ struct btrfs_delayed_ref_head { 


	struct list_head cluster;



	struct rb_node href_node;



	struct btrfs_delayed_extent_op *extent_op;

	/*

	 * when a new extent is allocated, it is just reserved in memory
@@ -118,6 +120,9 @@ struct btrfs_delayed_data_ref { 
struct btrfs_delayed_ref_root {

	struct rb_root root;



	/* head ref rbtree */

	struct rb_root href_root;



	/* this spin lock protects the rbtree and the entries inside */

	spinlock_t lock;

fs/btrfs/disk-io.c

+3 −0
Original line number Diff line number Diff line
@@ -3842,6 +3842,9 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, 


		ref->in_tree = 0;

		rb_erase(&ref->rb_node, &delayed_refs->root);

		if (head)

			rb_erase(&head->href_node, &delayed_refs->href_root);



		delayed_refs->num_entries--;

		spin_unlock(&delayed_refs->lock);

		if (head) {

fs/btrfs/extent-tree.c

+14 −7
Original line number Diff line number Diff line
@@ -2438,6 +2438,10 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, 


		ref->in_tree = 0;

		rb_erase(&ref->rb_node, &delayed_refs->root);

		if (btrfs_delayed_ref_is_head(ref)) {

			rb_erase(&locked_ref->href_node,

				 &delayed_refs->href_root);

		}

		delayed_refs->num_entries--;

		if (!btrfs_delayed_ref_is_head(ref)) {

			/*
@@ -2640,7 +2644,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, 
{

	struct rb_node *node;

	struct btrfs_delayed_ref_root *delayed_refs;

	struct btrfs_delayed_ref_node *ref;

	struct btrfs_delayed_ref_head *head;

	struct list_head cluster;

	int ret;

	u64 delayed_start;
@@ -2770,18 +2774,18 @@ again: 
			spin_lock(&delayed_refs->lock);

		}



		node = rb_first(&delayed_refs->root);

		node = rb_first(&delayed_refs->href_root);

		if (!node)

			goto out;

		count = (unsigned long)-1;



		while (node) {

			ref = rb_entry(node, struct btrfs_delayed_ref_node,

				       rb_node);

			if (btrfs_delayed_ref_is_head(ref)) {

				struct btrfs_delayed_ref_head *head;

			head = rb_entry(node, struct btrfs_delayed_ref_head,

					href_node);

			if (btrfs_delayed_ref_is_head(&head->node)) {

				struct btrfs_delayed_ref_node *ref;



				head = btrfs_delayed_node_to_head(ref);

				ref = &head->node;

				atomic_inc(&ref->refs);



				spin_unlock(&delayed_refs->lock);
@@ -2795,6 +2799,8 @@ again: 
				btrfs_put_delayed_ref(ref);

				cond_resched();

				goto again;

			} else {

				WARN_ON(1);

			}

			node = rb_next(node);

		}
@@ -5956,6 +5962,7 @@ static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans, 
	 */

	head->node.in_tree = 0;

	rb_erase(&head->node.rb_node, &delayed_refs->root);

	rb_erase(&head->href_node, &delayed_refs->href_root);



	delayed_refs->num_entries--;

fs/btrfs/transaction.c

+3 −1
Original line number Diff line number Diff line
@@ -62,7 +62,8 @@ void btrfs_put_transaction(struct btrfs_transaction *transaction) 
	WARN_ON(atomic_read(&transaction->use_count) == 0);

	if (atomic_dec_and_test(&transaction->use_count)) {

		BUG_ON(!list_empty(&transaction->list));

		WARN_ON(transaction->delayed_refs.root.rb_node);

		WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.root));

		WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root));

		while (!list_empty(&transaction->pending_chunks)) {

			struct extent_map *em;
@@ -184,6 +185,7 @@ loop: 
	cur_trans->start_time = get_seconds();



	cur_trans->delayed_refs.root = RB_ROOT;

	cur_trans->delayed_refs.href_root = RB_ROOT;

	cur_trans->delayed_refs.num_entries = 0;

	cur_trans->delayed_refs.num_heads_ready = 0;

	cur_trans->delayed_refs.num_heads = 0;

CRA Git | Maintained and supported by SUSTech CRA and CCSE