Commit 9180ad2e authored by Kent Overstreet's avatar Kent Overstreet
Browse files

bcachefs: Kill btree_iter.trans 



This was planned to be done ages ago, now finally completed; there are
places where we have quite a few btree_trans objects on the stack, so
this reduces stack usage somewhat.

Signed-off-by: default avatarKent Overstreet <kent.overstreet@linux.dev>
parent 1c8f4587

fs/bcachefs/acl.c

+2 −2
Original line number Diff line number Diff line
@@ -273,7 +273,7 @@ struct posix_acl *bch2_get_acl(struct inode *vinode, int type, bool rcu) 
	struct bch_fs *c = inode->v.i_sb->s_fs_info;

	struct bch_hash_info hash = bch2_hash_info_init(c, &inode->ei_inode);

	struct xattr_search_key search = X_SEARCH(acl_to_xattr_type(type), "", 0);

	struct btree_iter iter = { NULL };

	struct btree_iter iter = {};

	struct posix_acl *acl = NULL;



	if (rcu)
@@ -344,7 +344,7 @@ int bch2_set_acl(struct mnt_idmap *idmap, 
{

	struct bch_inode_info *inode = to_bch_ei(dentry->d_inode);

	struct bch_fs *c = inode->v.i_sb->s_fs_info;

	struct btree_iter inode_iter = { NULL };

	struct btree_iter inode_iter = {};

	struct bch_inode_unpacked inode_u;

	struct posix_acl *acl;

	umode_t mode;

fs/bcachefs/alloc_background.c

+40 −38
Original line number Diff line number Diff line
@@ -610,7 +610,7 @@ int bch2_alloc_read(struct bch_fs *c) 
			 * bch2_check_alloc_key() which runs later:

			 */

			if (!ca) {

				bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode + 1, 0));

				bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode + 1, 0));

				continue;

			}
@@ -631,17 +631,17 @@ int bch2_alloc_read(struct bch_fs *c) 
			 * bch2_check_alloc_key() which runs later:

			 */

			if (!ca) {

				bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode + 1, 0));

				bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode + 1, 0));

				continue;

			}



			if (k.k->p.offset < ca->mi.first_bucket) {

				bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode, ca->mi.first_bucket));

				bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode, ca->mi.first_bucket));

				continue;

			}



			if (k.k->p.offset >= ca->mi.nbuckets) {

				bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode + 1, 0));

				bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode + 1, 0));

				continue;

			}
@@ -1039,9 +1039,10 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
 * This synthesizes deleted extents for holes, similar to BTREE_ITER_slots for

 * extents style btrees, but works on non-extents btrees:

 */

static struct bkey_s_c bch2_get_key_or_hole(struct btree_iter *iter, struct bpos end, struct bkey *hole)

static struct bkey_s_c bch2_get_key_or_hole(struct btree_trans *trans, struct btree_iter *iter,

					    struct bpos end, struct bkey *hole)

{

	struct bkey_s_c k = bch2_btree_iter_peek_slot(iter);

	struct bkey_s_c k = bch2_btree_iter_peek_slot(trans, iter);



	if (bkey_err(k))

		return k;
@@ -1052,9 +1053,9 @@ static struct bkey_s_c bch2_get_key_or_hole(struct btree_iter *iter, struct bpos 
		struct btree_iter iter2;

		struct bpos next;



		bch2_trans_copy_iter(&iter2, iter);

		bch2_trans_copy_iter(trans, &iter2, iter);



		struct btree_path *path = btree_iter_path(iter->trans, iter);

		struct btree_path *path = btree_iter_path(trans, iter);

		if (!bpos_eq(path->l[0].b->key.k.p, SPOS_MAX))

			end = bkey_min(end, bpos_nosnap_successor(path->l[0].b->key.k.p));
@@ -1064,9 +1065,9 @@ static struct bkey_s_c bch2_get_key_or_hole(struct btree_iter *iter, struct bpos 
		 * btree node min/max is a closed interval, upto takes a half

		 * open interval:

		 */

		k = bch2_btree_iter_peek_max(&iter2, end);

		k = bch2_btree_iter_peek_max(trans, &iter2, end);

		next = iter2.pos;

		bch2_trans_iter_exit(iter->trans, &iter2);

		bch2_trans_iter_exit(trans, &iter2);



		BUG_ON(next.offset >= iter->pos.offset + U32_MAX);
@@ -1107,13 +1108,14 @@ static bool next_bucket(struct bch_fs *c, struct bch_dev **ca, struct bpos *buck 
	return *ca != NULL;

}



static struct bkey_s_c bch2_get_key_or_real_bucket_hole(struct btree_iter *iter,

static struct bkey_s_c bch2_get_key_or_real_bucket_hole(struct btree_trans *trans,

							struct btree_iter *iter,

							struct bch_dev **ca, struct bkey *hole)

{

	struct bch_fs *c = iter->trans->c;

	struct bch_fs *c = trans->c;

	struct bkey_s_c k;

again:

	k = bch2_get_key_or_hole(iter, POS_MAX, hole);

	k = bch2_get_key_or_hole(trans, iter, POS_MAX, hole);

	if (bkey_err(k))

		return k;
@@ -1126,7 +1128,7 @@ static struct bkey_s_c bch2_get_key_or_real_bucket_hole(struct btree_iter *iter, 
			if (!next_bucket(c, ca, &hole_start))

				return bkey_s_c_null;



			bch2_btree_iter_set_pos(iter, hole_start);

			bch2_btree_iter_set_pos(trans, iter, hole_start);

			goto again;

		}
@@ -1167,8 +1169,8 @@ int bch2_check_alloc_key(struct btree_trans *trans, 


	a = bch2_alloc_to_v4(alloc_k, &a_convert);



	bch2_btree_iter_set_pos(discard_iter, alloc_k.k->p);

	k = bch2_btree_iter_peek_slot(discard_iter);

	bch2_btree_iter_set_pos(trans, discard_iter, alloc_k.k->p);

	k = bch2_btree_iter_peek_slot(trans, discard_iter);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -1181,8 +1183,8 @@ int bch2_check_alloc_key(struct btree_trans *trans, 
			goto err;

	}



	bch2_btree_iter_set_pos(freespace_iter, alloc_freespace_pos(alloc_k.k->p, *a));

	k = bch2_btree_iter_peek_slot(freespace_iter);

	bch2_btree_iter_set_pos(trans, freespace_iter, alloc_freespace_pos(alloc_k.k->p, *a));

	k = bch2_btree_iter_peek_slot(trans, freespace_iter);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -1195,8 +1197,8 @@ int bch2_check_alloc_key(struct btree_trans *trans, 
			goto err;

	}



	bch2_btree_iter_set_pos(bucket_gens_iter, alloc_gens_pos(alloc_k.k->p, &gens_offset));

	k = bch2_btree_iter_peek_slot(bucket_gens_iter);

	bch2_btree_iter_set_pos(trans, bucket_gens_iter, alloc_gens_pos(alloc_k.k->p, &gens_offset));

	k = bch2_btree_iter_peek_slot(trans, bucket_gens_iter);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -1249,9 +1251,9 @@ int bch2_check_alloc_hole_freespace(struct btree_trans *trans, 
	if (!ca->mi.freespace_initialized)

		return 0;



	bch2_btree_iter_set_pos(freespace_iter, start);

	bch2_btree_iter_set_pos(trans, freespace_iter, start);



	k = bch2_btree_iter_peek_slot(freespace_iter);

	k = bch2_btree_iter_peek_slot(trans, freespace_iter);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -1300,9 +1302,9 @@ int bch2_check_alloc_hole_bucket_gens(struct btree_trans *trans, 
	unsigned i, gens_offset, gens_end_offset;

	int ret;



	bch2_btree_iter_set_pos(bucket_gens_iter, alloc_gens_pos(start, &gens_offset));

	bch2_btree_iter_set_pos(trans, bucket_gens_iter, alloc_gens_pos(start, &gens_offset));



	k = bch2_btree_iter_peek_slot(bucket_gens_iter);

	k = bch2_btree_iter_peek_slot(trans, bucket_gens_iter);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -1435,7 +1437,7 @@ int bch2_check_discard_freespace_key(struct btree_trans *trans, struct btree_ite 
	*gen = a->gen;

out:

fsck_err:

	bch2_set_btree_iter_dontneed(&alloc_iter);

	bch2_set_btree_iter_dontneed(trans, &alloc_iter);

	bch2_trans_iter_exit(trans, &alloc_iter);

	printbuf_exit(&buf);

	return ret;
@@ -1572,7 +1574,7 @@ int bch2_check_alloc_info(struct bch_fs *c) 


		bch2_trans_begin(trans);



		k = bch2_get_key_or_real_bucket_hole(&iter, &ca, &hole);

		k = bch2_get_key_or_real_bucket_hole(trans, &iter, &ca, &hole);

		ret = bkey_err(k);

		if (ret)

			goto bkey_err;
@@ -1610,7 +1612,7 @@ int bch2_check_alloc_info(struct bch_fs *c) 
		if (ret)

			goto bkey_err;



		bch2_btree_iter_set_pos(&iter, next);

		bch2_btree_iter_set_pos(trans, &iter, next);

bkey_err:

		if (bch2_err_matches(ret, BCH_ERR_transaction_restart))

			continue;
@@ -1638,7 +1640,7 @@ int bch2_check_alloc_info(struct bch_fs *c) 
			     BTREE_ITER_prefetch);

	while (1) {

		bch2_trans_begin(trans);

		k = bch2_btree_iter_peek(&iter);

		k = bch2_btree_iter_peek(trans, &iter);

		if (!k.k)

			break;
@@ -1657,7 +1659,7 @@ int bch2_check_alloc_info(struct bch_fs *c) 
			break;

		}



		bch2_btree_iter_set_pos(&iter, bpos_nosnap_successor(iter.pos));

		bch2_btree_iter_set_pos(trans, &iter, bpos_nosnap_successor(iter.pos));

	}

	bch2_trans_iter_exit(trans, &iter);

	if (ret)
@@ -1685,7 +1687,7 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans, 
	struct printbuf buf = PRINTBUF;

	int ret;



	alloc_k = bch2_btree_iter_peek(alloc_iter);

	alloc_k = bch2_btree_iter_peek(trans, alloc_iter);

	if (!alloc_k.k)

		return 0;
@@ -1826,7 +1828,7 @@ static int bch2_discard_one_bucket(struct btree_trans *trans, 
{

	struct bch_fs *c = trans->c;

	struct bpos pos = need_discard_iter->pos;

	struct btree_iter iter = { NULL };

	struct btree_iter iter = {};

	struct bkey_s_c k;

	struct bkey_i_alloc_v4 *a;

	struct printbuf buf = PRINTBUF;
@@ -2199,9 +2201,9 @@ static struct bkey_s_c next_lru_key(struct btree_trans *trans, struct btree_iter 
{

	struct bkey_s_c k;

again:

	k = bch2_btree_iter_peek_max(iter, lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX));

	k = bch2_btree_iter_peek_max(trans, iter, lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX));

	if (!k.k && !*wrapped) {

		bch2_btree_iter_set_pos(iter, lru_pos(ca->dev_idx, 0, 0));

		bch2_btree_iter_set_pos(trans, iter, lru_pos(ca->dev_idx, 0, 0));

		*wrapped = true;

		goto again;

	}
@@ -2251,7 +2253,7 @@ static void bch2_do_invalidates_work(struct work_struct *work) 
		if (ret)

			break;



		bch2_btree_iter_advance(&iter);

		bch2_btree_iter_advance(trans, &iter);

	}

	bch2_trans_iter_exit(trans, &iter);

err:
@@ -2321,7 +2323,7 @@ int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca, 
			break;

		}



		k = bch2_get_key_or_hole(&iter, end, &hole);

		k = bch2_get_key_or_hole(trans, &iter, end, &hole);

		ret = bkey_err(k);

		if (ret)

			goto bkey_err;
@@ -2340,7 +2342,7 @@ int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca, 
			if (ret)

				goto bkey_err;



			bch2_btree_iter_advance(&iter);

			bch2_btree_iter_advance(trans, &iter);

		} else {

			struct bkey_i *freespace;
@@ -2360,7 +2362,7 @@ int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca, 
			if (ret)

				goto bkey_err;



			bch2_btree_iter_set_pos(&iter, k.k->p);

			bch2_btree_iter_set_pos(trans, &iter, k.k->p);

		}

bkey_err:

		if (bch2_err_matches(ret, BCH_ERR_transaction_restart))

fs/bcachefs/alloc_foreground.c

+4 −4
Original line number Diff line number Diff line
@@ -327,7 +327,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, 
			bucket = sector_to_bucket(ca,

					round_up(bucket_to_sector(ca, bucket) + 1,

						 1ULL << ca->mi.btree_bitmap_shift));

			bch2_btree_iter_set_pos(&iter, POS(ca->dev_idx, bucket));

			bch2_btree_iter_set_pos(trans, &iter, POS(ca->dev_idx, bucket));

			s->buckets_seen++;

			s->skipped_mi_btree_bitmap++;

			continue;
@@ -355,7 +355,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, 
					     watermark, s, cl)

			: NULL;

next:

		bch2_set_btree_iter_dontneed(&citer);

		bch2_set_btree_iter_dontneed(trans, &citer);

		bch2_trans_iter_exit(trans, &citer);

		if (ob)

			break;
@@ -417,7 +417,7 @@ static struct open_bucket *bch2_bucket_alloc_freelist(struct btree_trans *trans, 
							 1ULL << ca->mi.btree_bitmap_shift));

				alloc_cursor = bucket|(iter.pos.offset & (~0ULL << 56));



				bch2_btree_iter_set_pos(&iter, POS(ca->dev_idx, alloc_cursor));

				bch2_btree_iter_set_pos(trans, &iter, POS(ca->dev_idx, alloc_cursor));

				s->skipped_mi_btree_bitmap++;

				goto next;

			}
@@ -426,7 +426,7 @@ static struct open_bucket *bch2_bucket_alloc_freelist(struct btree_trans *trans, 
			if (ob) {

				if (!IS_ERR(ob))

					*dev_alloc_cursor = iter.pos.offset;

				bch2_set_btree_iter_dontneed(&iter);

				bch2_set_btree_iter_dontneed(trans, &iter);

				break;

			}

fs/bcachefs/backpointers.c

+5 −5
Original line number Diff line number Diff line
@@ -252,7 +252,7 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans, 
				  0,

				  bp.v->level,

				  iter_flags);

	struct bkey_s_c k = bch2_btree_iter_peek_slot(iter);

	struct bkey_s_c k = bch2_btree_iter_peek_slot(trans, iter);

	if (bkey_err(k)) {

		bch2_trans_iter_exit(trans, iter);

		return k;
@@ -293,7 +293,7 @@ struct btree *bch2_backpointer_get_node(struct btree_trans *trans, 
				  0,

				  bp.v->level - 1,

				  0);

	struct btree *b = bch2_btree_iter_peek_node(iter);

	struct btree *b = bch2_btree_iter_peek_node(trans, iter);

	if (IS_ERR_OR_NULL(b))

		goto err;
@@ -321,7 +321,7 @@ static int bch2_check_backpointer_has_valid_bucket(struct btree_trans *trans, st 
		return 0;



	struct bch_fs *c = trans->c;

	struct btree_iter alloc_iter = { NULL };

	struct btree_iter alloc_iter = {};

	struct bkey_s_c alloc_k;

	struct printbuf buf = PRINTBUF;

	int ret = 0;
@@ -650,7 +650,7 @@ static int check_btree_root_to_backpointers(struct btree_trans *trans, 
retry:

	bch2_trans_node_iter_init(trans, &iter, btree_id, POS_MIN,

				  0, bch2_btree_id_root(c, btree_id)->b->c.level, 0);

	b = bch2_btree_iter_peek_node(&iter);

	b = bch2_btree_iter_peek_node(trans, &iter);

	ret = PTR_ERR_OR_ZERO(b);

	if (ret)

		goto err;
@@ -934,7 +934,7 @@ static int btree_node_get_and_pin(struct btree_trans *trans, struct bkey_i *k, 
{

	struct btree_iter iter;

	bch2_trans_node_iter_init(trans, &iter, btree, k->k.p, 0, level, 0);

	struct btree *b = bch2_btree_iter_peek_node(&iter);

	struct btree *b = bch2_btree_iter_peek_node(trans, &iter);

	int ret = PTR_ERR_OR_ZERO(b);

	if (ret)

		goto err;

fs/bcachefs/btree_gc.c

+2 −2
Original line number Diff line number Diff line
@@ -691,7 +691,7 @@ static int bch2_gc_btree(struct btree_trans *trans, 
		struct btree_iter iter;

		bch2_trans_node_iter_init(trans, &iter, btree, POS_MIN,

					  0, bch2_btree_id_root(c, btree)->b->c.level, 0);

		struct btree *b = bch2_btree_iter_peek_node(&iter);

		struct btree *b = bch2_btree_iter_peek_node(trans, &iter);

		ret = PTR_ERR_OR_ZERO(b);

		if (ret)

			goto err_root;
@@ -1199,7 +1199,7 @@ int bch2_gc_gens(struct bch_fs *c) 
				BCH_TRANS_COMMIT_no_enospc, ({

			ca = bch2_dev_iterate(c, ca, k.k->p.inode);

			if (!ca) {

				bch2_btree_iter_set_pos(&iter, POS(k.k->p.inode + 1, 0));

				bch2_btree_iter_set_pos(trans, &iter, POS(k.k->p.inode + 1, 0));

				continue;

			}

			bch2_alloc_write_oldest_gen(trans, ca, &iter, k);