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

Commit c43d160f authored by Qu Wenruo's avatar Qu Wenruo Committed by Chris Mason
Browse files

btrfs: delayed-ref: Cleanup the unneeded functions. 



Cleanup the rb_tree merge/insert/update functions, since now we use list
instead of rb_tree now.

Signed-off-by: default avatarQu Wenruo <quwenruo@cn.fujitsu.com>
Signed-off-by: default avatarChris Mason <clm@fb.com>
parent c6fc2454

fs/btrfs/delayed-ref.c

+0 −174
Original line number Diff line number Diff line
@@ -84,87 +84,6 @@ static int comp_data_refs(struct btrfs_delayed_data_ref *ref2, 
	return 0;

}



/*

 * entries in the rb tree are ordered by the byte number of the extent,

 * type of the delayed backrefs and content of delayed backrefs.

 */

static int comp_entry(struct btrfs_delayed_ref_node *ref2,

		      struct btrfs_delayed_ref_node *ref1,

		      bool compare_seq)

{

	if (ref1->bytenr < ref2->bytenr)

		return -1;

	if (ref1->bytenr > ref2->bytenr)

		return 1;

	if (ref1->is_head && ref2->is_head)

		return 0;

	if (ref2->is_head)

		return -1;

	if (ref1->is_head)

		return 1;

	if (ref1->type < ref2->type)

		return -1;

	if (ref1->type > ref2->type)

		return 1;

	if (ref1->no_quota > ref2->no_quota)

		return 1;

	if (ref1->no_quota < ref2->no_quota)

		return -1;

	/* merging of sequenced refs is not allowed */

	if (compare_seq) {

		if (ref1->seq < ref2->seq)

			return -1;

		if (ref1->seq > ref2->seq)

			return 1;

	}

	if (ref1->type == BTRFS_TREE_BLOCK_REF_KEY ||

	    ref1->type == BTRFS_SHARED_BLOCK_REF_KEY) {

		return comp_tree_refs(btrfs_delayed_node_to_tree_ref(ref2),

				      btrfs_delayed_node_to_tree_ref(ref1),

				      ref1->type);

	} else if (ref1->type == BTRFS_EXTENT_DATA_REF_KEY ||

		   ref1->type == BTRFS_SHARED_DATA_REF_KEY) {

		return comp_data_refs(btrfs_delayed_node_to_data_ref(ref2),

				      btrfs_delayed_node_to_data_ref(ref1));

	}

	BUG();

	return 0;

}



/*

 * insert a new ref into the rbtree.  This returns any existing refs

 * for the same (bytenr,parent) tuple, or NULL if the new node was properly

 * inserted.

 */

static struct btrfs_delayed_ref_node *tree_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_node *entry;

	struct btrfs_delayed_ref_node *ins;

	int cmp;



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

	while (*p) {

		parent_node = *p;

		entry = rb_entry(parent_node, struct btrfs_delayed_ref_node,

				 rb_node);



		cmp = comp_entry(entry, ins, 1);

		if (cmp < 0)

			p = &(*p)->rb_left;

		else if (cmp > 0)

			p = &(*p)->rb_right;

		else

			return entry;

	}



	rb_link_node(node, parent_node, p);

	rb_insert_color(node, 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)
@@ -277,57 +196,6 @@ static inline void drop_delayed_ref(struct btrfs_trans_handle *trans, 
		trans->delayed_ref_updates--;

}



static int merge_ref(struct btrfs_trans_handle *trans,

		     struct btrfs_delayed_ref_root *delayed_refs,

		     struct btrfs_delayed_ref_head *head,

		     struct btrfs_delayed_ref_node *ref, u64 seq)

{

	struct rb_node *node;

	int mod = 0;

	int done = 0;



	node = rb_next(&ref->rb_node);

	while (!done && node) {

		struct btrfs_delayed_ref_node *next;



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

		node = rb_next(node);

		if (seq && next->seq >= seq)

			break;

		if (comp_entry(ref, next, 0))

			continue;



		if (ref->action == next->action) {

			mod = next->ref_mod;

		} else {

			if (ref->ref_mod < next->ref_mod) {

				struct btrfs_delayed_ref_node *tmp;



				tmp = ref;

				ref = next;

				next = tmp;

				done = 1;

			}

			mod = -next->ref_mod;

		}



		drop_delayed_ref(trans, delayed_refs, head, next);

		ref->ref_mod += mod;

		if (ref->ref_mod == 0) {

			drop_delayed_ref(trans, delayed_refs, head, ref);

			done = 1;

		} else {

			/*

			 * You can't have multiples of the same ref on a tree

			 * block.

			 */

			WARN_ON(ref->type == BTRFS_TREE_BLOCK_REF_KEY ||

				ref->type == BTRFS_SHARED_BLOCK_REF_KEY);

		}

	}

	return done;

}



int btrfs_check_delayed_seq(struct btrfs_fs_info *fs_info,

			    struct btrfs_delayed_ref_root *delayed_refs,

			    u64 seq)
@@ -400,48 +268,6 @@ btrfs_select_ref_head(struct btrfs_trans_handle *trans) 
	return head;

}



/*

 * helper function to update an extent delayed ref in the

 * rbtree.  existing and update must both have the same

 * bytenr and parent

 *

 * This may free existing if the update cancels out whatever

 * operation it was doing.

 */

static noinline void

update_existing_ref(struct btrfs_trans_handle *trans,

		    struct btrfs_delayed_ref_root *delayed_refs,

		    struct btrfs_delayed_ref_head *head,

		    struct btrfs_delayed_ref_node *existing,

		    struct btrfs_delayed_ref_node *update)

{

	if (update->action != existing->action) {

		/*

		 * this is effectively undoing either an add or a

		 * drop.  We decrement the ref_mod, and if it goes

		 * down to zero we just delete the entry without

		 * every changing the extent allocation tree.

		 */

		existing->ref_mod--;

		if (existing->ref_mod == 0)

			drop_delayed_ref(trans, delayed_refs, head, existing);

		else

			WARN_ON(existing->type == BTRFS_TREE_BLOCK_REF_KEY ||

				existing->type == BTRFS_SHARED_BLOCK_REF_KEY);

	} else {

		WARN_ON(existing->type == BTRFS_TREE_BLOCK_REF_KEY ||

			existing->type == BTRFS_SHARED_BLOCK_REF_KEY);

		/*

		 * the action on the existing ref matches

		 * the action on the ref we're trying to add.

		 * Bump the ref_mod by one so the backref that

		 * is eventually added/removed has the correct

		 * reference count

		 */

		existing->ref_mod += update->ref_mod;

	}

}



/*

 * Helper to insert the ref_node to the tail or merge with tail.

 *