Commit ac5887c8 authored by Josef Bacik's avatar Josef Bacik Committed by David Sterba
Browse files

btrfs: locking: remove all the blocking helpers 



Now that we're using a rw_semaphore we no longer need to indicate if a
lock is blocking or not, nor do we need to flip the entire path from
blocking to spinning.  Remove these helpers and all the places they are
called.

Signed-off-by: default avatarJosef Bacik <josef@toxicpanda.com>
Reviewed-by: default avatarDavid Sterba <dsterba@suse.com>
Signed-off-by: default avatarDavid Sterba <dsterba@suse.com>
parent 2ae0c2d8

fs/btrfs/backref.c

+3 −7
Original line number Diff line number Diff line
@@ -1341,14 +1341,12 @@ static int find_parent_nodes(struct btrfs_trans_handle *trans, 
					goto out;

				}



				if (!path->skip_locking) {

				if (!path->skip_locking)

					btrfs_tree_read_lock(eb);

					btrfs_set_lock_blocking_read(eb);

				}

				ret = find_extent_in_eb(eb, bytenr,

							*extent_item_pos, &eie, ignore_offset);

				if (!path->skip_locking)

					btrfs_tree_read_unlock_blocking(eb);

					btrfs_tree_read_unlock(eb);

				free_extent_buffer(eb);

				if (ret < 0)

					goto out;
@@ -1685,7 +1683,7 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
					   name_off, name_len);

		if (eb != eb_in) {

			if (!path->skip_locking)

				btrfs_tree_read_unlock_blocking(eb);

				btrfs_tree_read_unlock(eb);

			free_extent_buffer(eb);

		}

		ret = btrfs_find_item(fs_root, path, parent, 0,
@@ -1705,8 +1703,6 @@ char *btrfs_ref_to_path(struct btrfs_root *fs_root, struct btrfs_path *path, 
		eb = path->nodes[0];

		/* make sure we can use eb after releasing the path */

		if (eb != eb_in) {

			if (!path->skip_locking)

				btrfs_set_lock_blocking_read(eb);

			path->nodes[0] = NULL;

			path->locks[0] = 0;

		}

fs/btrfs/ctree.c

+12 −79
Original line number Diff line number Diff line
@@ -1278,14 +1278,11 @@ tree_mod_log_rewind(struct btrfs_fs_info *fs_info, struct btrfs_path *path, 
	if (!tm)

		return eb;



	btrfs_set_path_blocking(path);

	btrfs_set_lock_blocking_read(eb);



	if (tm->op == MOD_LOG_KEY_REMOVE_WHILE_FREEING) {

		BUG_ON(tm->slot != 0);

		eb_rewin = alloc_dummy_extent_buffer(fs_info, eb->start);

		if (!eb_rewin) {

			btrfs_tree_read_unlock_blocking(eb);

			btrfs_tree_read_unlock(eb);

			free_extent_buffer(eb);

			return NULL;

		}
@@ -1297,13 +1294,13 @@ tree_mod_log_rewind(struct btrfs_fs_info *fs_info, struct btrfs_path *path, 
	} else {

		eb_rewin = btrfs_clone_extent_buffer(eb);

		if (!eb_rewin) {

			btrfs_tree_read_unlock_blocking(eb);

			btrfs_tree_read_unlock(eb);

			free_extent_buffer(eb);

			return NULL;

		}

	}



	btrfs_tree_read_unlock_blocking(eb);

	btrfs_tree_read_unlock(eb);

	free_extent_buffer(eb);



	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb_rewin),
@@ -1373,9 +1370,8 @@ get_old_root(struct btrfs_root *root, u64 time_seq) 
		free_extent_buffer(eb_root);

		eb = alloc_dummy_extent_buffer(fs_info, logical);

	} else {

		btrfs_set_lock_blocking_read(eb_root);

		eb = btrfs_clone_extent_buffer(eb_root);

		btrfs_tree_read_unlock_blocking(eb_root);

		btrfs_tree_read_unlock(eb_root);

		free_extent_buffer(eb_root);

	}
@@ -1483,10 +1479,6 @@ noinline int btrfs_cow_block(struct btrfs_trans_handle *trans, 


	search_start = buf->start & ~((u64)SZ_1G - 1);



	if (parent)

		btrfs_set_lock_blocking_write(parent);

	btrfs_set_lock_blocking_write(buf);



	/*

	 * Before CoWing this block for later modification, check if it's

	 * the subtree root and do the delayed subtree trace if needed.
@@ -1604,8 +1596,6 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, 
	if (parent_nritems <= 1)

		return 0;



	btrfs_set_lock_blocking_write(parent);



	for (i = start_slot; i <= end_slot; i++) {

		struct btrfs_key first_key;

		int close = 1;
@@ -1663,7 +1653,6 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans, 
			search_start = last_block;



		btrfs_tree_lock(cur);

		btrfs_set_lock_blocking_write(cur);

		err = __btrfs_cow_block(trans, root, cur, parent, i,

					&cur, search_start,

					min(16 * blocksize,
@@ -1835,8 +1824,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 


	mid = path->nodes[level];



	WARN_ON(path->locks[level] != BTRFS_WRITE_LOCK &&

		path->locks[level] != BTRFS_WRITE_LOCK_BLOCKING);

	WARN_ON(path->locks[level] != BTRFS_WRITE_LOCK);

	WARN_ON(btrfs_header_generation(mid) != trans->transid);



	orig_ptr = btrfs_node_blockptr(mid, orig_slot);
@@ -1865,7 +1853,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 
		}



		btrfs_tree_lock(child);

		btrfs_set_lock_blocking_write(child);

		ret = btrfs_cow_block(trans, root, child, mid, 0, &child,

				      BTRFS_NESTING_COW);

		if (ret) {
@@ -1904,7 +1891,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 


	if (left) {

		__btrfs_tree_lock(left, BTRFS_NESTING_LEFT);

		btrfs_set_lock_blocking_write(left);

		wret = btrfs_cow_block(trans, root, left,

				       parent, pslot - 1, &left,

				       BTRFS_NESTING_LEFT_COW);
@@ -1920,7 +1906,6 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, 


	if (right) {

		__btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);

		btrfs_set_lock_blocking_write(right);

		wret = btrfs_cow_block(trans, root, right,

				       parent, pslot + 1, &right,

				       BTRFS_NESTING_RIGHT_COW);
@@ -2084,7 +2069,6 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans, 
		u32 left_nr;



		__btrfs_tree_lock(left, BTRFS_NESTING_LEFT);

		btrfs_set_lock_blocking_write(left);



		left_nr = btrfs_header_nritems(left);

		if (left_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
@@ -2139,7 +2123,6 @@ static noinline int push_nodes_for_insert(struct btrfs_trans_handle *trans, 
		u32 right_nr;



		__btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);

		btrfs_set_lock_blocking_write(right);



		right_nr = btrfs_header_nritems(right);

		if (right_nr >= BTRFS_NODEPTRS_PER_BLOCK(fs_info) - 1) {
@@ -2399,14 +2382,6 @@ read_block_for_search(struct btrfs_root *root, struct btrfs_path *p, 
			return 0;

		}



		/* the pages were up to date, but we failed

		 * the generation number check.  Do a full

		 * read for the generation number that is correct.

		 * We must do this without dropping locks so

		 * we can trust our generation number

		 */

		btrfs_set_path_blocking(p);



		/* now we're allowed to do a blocking uptodate check */

		ret = btrfs_read_buffer(tmp, gen, parent_level - 1, &first_key);

		if (!ret) {
@@ -2426,7 +2401,6 @@ read_block_for_search(struct btrfs_root *root, struct btrfs_path *p, 
	 * out which blocks to read.

	 */

	btrfs_unlock_up_safe(p, level + 1);

	btrfs_set_path_blocking(p);



	if (p->reada != READA_NONE)

		reada_for_search(fs_info, p, level, slot, key->objectid);
@@ -2480,7 +2454,6 @@ setup_nodes_for_search(struct btrfs_trans_handle *trans, 
			goto again;

		}



		btrfs_set_path_blocking(p);

		reada_for_balance(fs_info, p, level);

		sret = split_node(trans, root, p, level);
@@ -2500,7 +2473,6 @@ setup_nodes_for_search(struct btrfs_trans_handle *trans, 
			goto again;

		}



		btrfs_set_path_blocking(p);

		reada_for_balance(fs_info, p, level);

		sret = balance_level(trans, root, p, level);
@@ -2752,7 +2724,6 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
				goto again;

			}



			btrfs_set_path_blocking(p);

			if (last_level)

				err = btrfs_cow_block(trans, root, b, NULL, 0,

						      &b,
@@ -2822,7 +2793,6 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
					goto again;

				}



				btrfs_set_path_blocking(p);

				err = split_leaf(trans, root, key,

						 p, ins_len, ret == 0);
@@ -2884,17 +2854,11 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		if (!p->skip_locking) {

			level = btrfs_header_level(b);

			if (level <= write_lock_level) {

				if (!btrfs_try_tree_write_lock(b)) {

					btrfs_set_path_blocking(p);

				btrfs_tree_lock(b);

				}

				p->locks[level] = BTRFS_WRITE_LOCK;

			} else {

				if (!btrfs_tree_read_lock_atomic(b)) {

					btrfs_set_path_blocking(p);

				__btrfs_tree_read_lock(b, BTRFS_NESTING_NORMAL,

						       p->recurse);

				}

				p->locks[level] = BTRFS_READ_LOCK;

			}

			p->nodes[level] = b;
@@ -2902,12 +2866,6 @@ int btrfs_search_slot(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
	}

	ret = 1;

done:

	/*

	 * we don't really know what they plan on doing with the path

	 * from here on, so for now just mark it as blocking

	 */

	if (!p->leave_spinning)

		btrfs_set_path_blocking(p);

	if (ret < 0 && !p->skip_release_on_error)

		btrfs_release_path(p);

	return ret;
@@ -2999,10 +2957,7 @@ int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key, 
		}



		level = btrfs_header_level(b);

		if (!btrfs_tree_read_lock_atomic(b)) {

			btrfs_set_path_blocking(p);

		btrfs_tree_read_lock(b);

		}

		b = tree_mod_log_rewind(fs_info, p, b, time_seq);

		if (!b) {

			ret = -ENOMEM;
@@ -3013,8 +2968,6 @@ int btrfs_search_old_slot(struct btrfs_root *root, const struct btrfs_key *key, 
	}

	ret = 1;

done:

	if (!p->leave_spinning)

		btrfs_set_path_blocking(p);

	if (ret < 0)

		btrfs_release_path(p);
@@ -3441,7 +3394,7 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans, 
	add_root_to_dirty_list(root);

	atomic_inc(&c->refs);

	path->nodes[level] = c;

	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

	path->locks[level] = BTRFS_WRITE_LOCK;

	path->slots[level] = 0;

	return 0;

}
@@ -3814,7 +3767,6 @@ static int push_leaf_right(struct btrfs_trans_handle *trans, struct btrfs_root 
		return 1;



	__btrfs_tree_lock(right, BTRFS_NESTING_RIGHT);

	btrfs_set_lock_blocking_write(right);



	free_space = btrfs_leaf_free_space(right);

	if (free_space < data_size)
@@ -4053,7 +4005,6 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root 
		return 1;



	__btrfs_tree_lock(left, BTRFS_NESTING_LEFT);

	btrfs_set_lock_blocking_write(left);



	free_space = btrfs_leaf_free_space(left);

	if (free_space < data_size) {
@@ -4448,7 +4399,6 @@ static noinline int setup_leaf_for_split(struct btrfs_trans_handle *trans, 
			goto err;

	}



	btrfs_set_path_blocking(path);

	ret = split_leaf(trans, root, &key, path, ins_len, 1);

	if (ret)

		goto err;
@@ -4478,8 +4428,6 @@ static noinline int split_item(struct btrfs_path *path, 
	leaf = path->nodes[0];

	BUG_ON(btrfs_leaf_free_space(leaf) < sizeof(struct btrfs_item));



	btrfs_set_path_blocking(path);



	item = btrfs_item_nr(path->slots[0]);

	orig_offset = btrfs_item_offset(leaf, item);

	item_size = btrfs_item_size(leaf, item);
@@ -5055,7 +5003,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
		if (leaf == root->node) {

			btrfs_set_header_level(leaf, 0);

		} else {

			btrfs_set_path_blocking(path);

			btrfs_clean_tree_block(leaf);

			btrfs_del_leaf(trans, root, path, leaf);

		}
@@ -5077,7 +5024,6 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
			slot = path->slots[1];

			atomic_inc(&leaf->refs);



			btrfs_set_path_blocking(path);

			wret = push_leaf_left(trans, root, path, 1, 1,

					      1, (u32)-1);

			if (wret < 0 && wret != -ENOSPC)
@@ -5248,7 +5194,6 @@ int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 
		 */

		if (slot >= nritems) {

			path->slots[level] = slot;

			btrfs_set_path_blocking(path);

			sret = btrfs_find_next_key(root, path, min_key, level,

						  min_trans);

			if (sret == 0) {
@@ -5265,7 +5210,6 @@ int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 
			ret = 0;

			goto out;

		}

		btrfs_set_path_blocking(path);

		cur = btrfs_read_node_slot(cur, slot);

		if (IS_ERR(cur)) {

			ret = PTR_ERR(cur);
@@ -5282,7 +5226,6 @@ int btrfs_search_forward(struct btrfs_root *root, struct btrfs_key *min_key, 
	path->keep_locks = keep_locks;

	if (ret == 0) {

		btrfs_unlock_up_safe(path, path->lowest_level + 1);

		btrfs_set_path_blocking(path);

		memcpy(min_key, &found_key, sizeof(found_key));

	}

	return ret;
@@ -5492,7 +5435,6 @@ int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path, 
				goto again;

			}

			if (!ret) {

				btrfs_set_path_blocking(path);

				__btrfs_tree_read_lock(next,

						       BTRFS_NESTING_RIGHT,

						       path->recurse);
@@ -5527,13 +5469,8 @@ int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path, 
		}



		if (!path->skip_locking) {

			ret = btrfs_try_tree_read_lock(next);

			if (!ret) {

				btrfs_set_path_blocking(path);

				__btrfs_tree_read_lock(next,

						       BTRFS_NESTING_RIGHT,

			__btrfs_tree_read_lock(next, BTRFS_NESTING_RIGHT,

					       path->recurse);

			}

			next_rw_lock = BTRFS_READ_LOCK;

		}

	}
@@ -5541,8 +5478,6 @@ int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path, 
done:

	unlock_up(path, 0, 1, 0, NULL);

	path->leave_spinning = old_spinning;

	if (!old_spinning)

		btrfs_set_path_blocking(path);



	return ret;

}
@@ -5564,7 +5499,6 @@ int btrfs_previous_item(struct btrfs_root *root, 


	while (1) {

		if (path->slots[0] == 0) {

			btrfs_set_path_blocking(path);

			ret = btrfs_prev_leaf(root, path);

			if (ret != 0)

				return ret;
@@ -5606,7 +5540,6 @@ int btrfs_previous_extent_item(struct btrfs_root *root, 


	while (1) {

		if (path->slots[0] == 0) {

			btrfs_set_path_blocking(path);

			ret = btrfs_prev_leaf(root, path);

			if (ret != 0)

				return ret;

fs/btrfs/delayed-inode.c

+0 −7
Original line number Diff line number Diff line
@@ -740,13 +740,6 @@ static int btrfs_batch_insert_items(struct btrfs_root *root, 
		goto out;

	}



	/*

	 * we need allocate some memory space, but it might cause the task

	 * to sleep, so we set all locked nodes in the path to blocking locks

	 * first.

	 */

	btrfs_set_path_blocking(path);



	keys = kmalloc_array(nitems, sizeof(struct btrfs_key), GFP_NOFS);

	if (!keys) {

		ret = -ENOMEM;

fs/btrfs/disk-io.c

+2 −6
Original line number Diff line number Diff line
@@ -250,10 +250,8 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, 
	if (atomic)

		return -EAGAIN;



	if (need_lock) {

	if (need_lock)

		btrfs_tree_read_lock(eb);

		btrfs_set_lock_blocking_read(eb);

	}



	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,

			 &cached_state);
@@ -282,7 +280,7 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, 
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,

			     &cached_state);

	if (need_lock)

		btrfs_tree_read_unlock_blocking(eb);

		btrfs_tree_read_unlock(eb);

	return ret;

}
@@ -1013,8 +1011,6 @@ void btrfs_clean_tree_block(struct extent_buffer *buf) 
			percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,

						 -buf->len,

						 fs_info->dirty_metadata_batch);

			/* ugh, clear_extent_buffer_dirty needs to lock the page */

			btrfs_set_lock_blocking_write(buf);

			clear_extent_buffer_dirty(buf);

		}

	}

fs/btrfs/extent-tree.c

+6 −13
Original line number Diff line number Diff line
@@ -4665,7 +4665,6 @@ btrfs_init_new_buffer(struct btrfs_trans_handle *trans, struct btrfs_root *root, 
	btrfs_clean_tree_block(buf);

	clear_bit(EXTENT_BUFFER_STALE, &buf->bflags);



	btrfs_set_lock_blocking_write(buf);

	set_extent_buffer_uptodate(buf);



	memzero_extent_buffer(buf, 0, sizeof(struct btrfs_header));
@@ -5054,7 +5053,6 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, 
		reada = 1;

	}

	btrfs_tree_lock(next);

	btrfs_set_lock_blocking_write(next);



	ret = btrfs_lookup_extent_info(trans, fs_info, bytenr, level - 1, 1,

				       &wc->refs[level - 1],
@@ -5114,7 +5112,6 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, 
			return -EIO;

		}

		btrfs_tree_lock(next);

		btrfs_set_lock_blocking_write(next);

	}



	level--;
@@ -5126,7 +5123,7 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, 
	}

	path->nodes[level] = next;

	path->slots[level] = 0;

	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

	path->locks[level] = BTRFS_WRITE_LOCK;

	wc->level = level;

	if (wc->level == 1)

		wc->reada_slot = 0;
@@ -5254,8 +5251,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans, 
		if (!path->locks[level]) {

			BUG_ON(level == 0);

			btrfs_tree_lock(eb);

			btrfs_set_lock_blocking_write(eb);

			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

			path->locks[level] = BTRFS_WRITE_LOCK;



			ret = btrfs_lookup_extent_info(trans, fs_info,

						       eb->start, level, 1,
@@ -5298,8 +5294,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans, 
		if (!path->locks[level] &&

		    btrfs_header_generation(eb) == trans->transid) {

			btrfs_tree_lock(eb);

			btrfs_set_lock_blocking_write(eb);

			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

			path->locks[level] = BTRFS_WRITE_LOCK;

		}

		btrfs_clean_tree_block(eb);

	}
@@ -5467,9 +5462,8 @@ int btrfs_drop_snapshot(struct btrfs_root *root, int update_ref, int for_reloc) 
	if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {

		level = btrfs_header_level(root->node);

		path->nodes[level] = btrfs_lock_root_node(root);

		btrfs_set_lock_blocking_write(path->nodes[level]);

		path->slots[level] = 0;

		path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

		path->locks[level] = BTRFS_WRITE_LOCK;

		memset(&wc->update_progress, 0,

		       sizeof(wc->update_progress));

	} else {
@@ -5497,8 +5491,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root, int update_ref, int for_reloc) 
		level = btrfs_header_level(root->node);

		while (1) {

			btrfs_tree_lock(path->nodes[level]);

			btrfs_set_lock_blocking_write(path->nodes[level]);

			path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

			path->locks[level] = BTRFS_WRITE_LOCK;



			ret = btrfs_lookup_extent_info(trans, fs_info,

						path->nodes[level]->start,
@@ -5685,7 +5678,7 @@ int btrfs_drop_subtree(struct btrfs_trans_handle *trans, 
	level = btrfs_header_level(node);

	path->nodes[level] = node;

	path->slots[level] = 0;

	path->locks[level] = BTRFS_WRITE_LOCK_BLOCKING;

	path->locks[level] = BTRFS_WRITE_LOCK;



	wc->refs[parent_level] = 1;

	wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;