Commit a850bde6 authored by Kent Overstreet's avatar Kent Overstreet
Browse files

bcachefs: fsck_err() may now take a btree_trans 



fsck_err() now optionally takes a btree_trans; if the current thread has
one, it is required that it be passed.

The next patch will use this to unlock when waiting for user input.

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

fs/bcachefs/alloc_background.c

+19 −21
Original line number Diff line number Diff line
@@ -1114,7 +1114,7 @@ int bch2_check_alloc_key(struct btree_trans *trans, 


	struct bch_dev *ca = bch2_dev_bucket_tryget_noerror(c, alloc_k.k->p);

	if (fsck_err_on(!ca,

			c, alloc_key_to_missing_dev_bucket,

			trans, alloc_key_to_missing_dev_bucket,

			"alloc key for invalid device:bucket %llu:%llu",

			alloc_k.k->p.inode, alloc_k.k->p.offset))

		ret = bch2_btree_delete_at(trans, alloc_iter, 0);
@@ -1134,7 +1134,7 @@ int bch2_check_alloc_key(struct btree_trans *trans, 
		goto err;



	if (fsck_err_on(k.k->type != discard_key_type,

			c, need_discard_key_wrong,

			trans, need_discard_key_wrong,

			"incorrect key in need_discard btree (got %s should be %s)\n"

			"  %s",

			bch2_bkey_types[k.k->type],
@@ -1164,7 +1164,7 @@ int bch2_check_alloc_key(struct btree_trans *trans, 
		goto err;



	if (fsck_err_on(k.k->type != freespace_key_type,

			c, freespace_key_wrong,

			trans, freespace_key_wrong,

			"incorrect key in freespace btree (got %s should be %s)\n"

			"  %s",

			bch2_bkey_types[k.k->type],
@@ -1195,7 +1195,7 @@ int bch2_check_alloc_key(struct btree_trans *trans, 
		goto err;



	if (fsck_err_on(a->gen != alloc_gen(k, gens_offset),

			c, bucket_gens_key_wrong,

			trans, bucket_gens_key_wrong,

			"incorrect gen in bucket_gens btree (got %u should be %u)\n"

			"  %s",

			alloc_gen(k, gens_offset), a->gen,
@@ -1236,7 +1236,6 @@ int bch2_check_alloc_hole_freespace(struct btree_trans *trans, 
				    struct bpos *end,

				    struct btree_iter *freespace_iter)

{

	struct bch_fs *c = trans->c;

	struct bkey_s_c k;

	struct printbuf buf = PRINTBUF;

	int ret;
@@ -1254,7 +1253,7 @@ int bch2_check_alloc_hole_freespace(struct btree_trans *trans, 
	*end = bkey_min(k.k->p, *end);



	if (fsck_err_on(k.k->type != KEY_TYPE_set,

			c, freespace_hole_missing,

			trans, freespace_hole_missing,

			"hole in alloc btree missing in freespace btree\n"

			"  device %llu buckets %llu-%llu",

			freespace_iter->pos.inode,
@@ -1290,7 +1289,6 @@ int bch2_check_alloc_hole_bucket_gens(struct btree_trans *trans, 
				      struct bpos *end,

				      struct btree_iter *bucket_gens_iter)

{

	struct bch_fs *c = trans->c;

	struct bkey_s_c k;

	struct printbuf buf = PRINTBUF;

	unsigned i, gens_offset, gens_end_offset;
@@ -1314,7 +1312,7 @@ int bch2_check_alloc_hole_bucket_gens(struct btree_trans *trans, 
		bkey_reassemble(&g.k_i, k);



		for (i = gens_offset; i < gens_end_offset; i++) {

			if (fsck_err_on(g.v.gens[i], c,

			if (fsck_err_on(g.v.gens[i], trans,

					bucket_gens_hole_wrong,

					"hole in alloc btree at %llu:%llu with nonzero gen in bucket_gens btree (%u)",

					bucket_gens_pos_to_alloc(k.k->p, i).inode,
@@ -1372,8 +1370,8 @@ static noinline_for_stack int bch2_check_discard_freespace_key(struct btree_tran 
	if (ret)

		return ret;



	if (fsck_err_on(!bch2_dev_bucket_exists(c, pos), c,

			need_discard_freespace_key_to_invalid_dev_bucket,

	if (fsck_err_on(!bch2_dev_bucket_exists(c, pos),

			trans, need_discard_freespace_key_to_invalid_dev_bucket,

			"entry in %s btree for nonexistant dev:bucket %llu:%llu",

			bch2_btree_id_str(iter->btree_id), pos.inode, pos.offset))

		goto delete;
@@ -1382,8 +1380,8 @@ static noinline_for_stack int bch2_check_discard_freespace_key(struct btree_tran 


	if (fsck_err_on(a->data_type != state ||

			(state == BCH_DATA_free &&

			 genbits != alloc_freespace_genbits(*a)), c,

			need_discard_freespace_key_bad,

			 genbits != alloc_freespace_genbits(*a)),

			trans, need_discard_freespace_key_bad,

			"%s\n  incorrectly set at %s:%llu:%llu:0 (free %u, genbits %llu should be %llu)",

			(bch2_bkey_val_to_text(&buf, c, alloc_k), buf.buf),

			bch2_btree_id_str(iter->btree_id),
@@ -1430,7 +1428,7 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans, 


	struct bch_dev *ca = bch2_dev_tryget_noerror(c, k.k->p.inode);

	if (!ca) {

		if (fsck_err(c, bucket_gens_to_invalid_dev,

		if (fsck_err(trans, bucket_gens_to_invalid_dev,

			     "bucket_gens key for invalid device:\n  %s",

			     (bch2_bkey_val_to_text(&buf, c, k), buf.buf)))

			ret = bch2_btree_delete_at(trans, iter, 0);
@@ -1438,8 +1436,8 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans, 
	}



	if (fsck_err_on(end <= ca->mi.first_bucket ||

			start >= ca->mi.nbuckets, c,

			bucket_gens_to_invalid_buckets,

			start >= ca->mi.nbuckets,

			trans, bucket_gens_to_invalid_buckets,

			"bucket_gens key for invalid buckets:\n  %s",

			(bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {

		ret = bch2_btree_delete_at(trans, iter, 0);
@@ -1447,16 +1445,16 @@ int bch2_check_bucket_gens_key(struct btree_trans *trans, 
	}



	for (b = start; b < ca->mi.first_bucket; b++)

		if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK], c,

				bucket_gens_nonzero_for_invalid_buckets,

		if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK],

				trans, bucket_gens_nonzero_for_invalid_buckets,

				"bucket_gens key has nonzero gen for invalid bucket")) {

			g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK] = 0;

			need_update = true;

		}



	for (b = ca->mi.nbuckets; b < end; b++)

		if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK], c,

				bucket_gens_nonzero_for_invalid_buckets,

		if (fsck_err_on(g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK],

				trans, bucket_gens_nonzero_for_invalid_buckets,

				"bucket_gens key has nonzero gen for invalid bucket")) {

			g.v.gens[b & KEY_TYPE_BUCKET_GENS_MASK] = 0;

			need_update = true;
@@ -1636,8 +1634,8 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans, 
	if (a->data_type != BCH_DATA_cached)

		return 0;



	if (fsck_err_on(!a->io_time[READ], c,

			alloc_key_cached_but_read_time_zero,

	if (fsck_err_on(!a->io_time[READ],

			trans, alloc_key_cached_but_read_time_zero,

			"cached bucket with read_time 0\n"

			"  %s",

		(printbuf_reset(&buf),

fs/bcachefs/backpointers.c

+6 −6
Original line number Diff line number Diff line
@@ -395,7 +395,7 @@ static int bch2_check_btree_backpointer(struct btree_trans *trans, struct btree_ 


	struct bpos bucket;

	if (!bp_pos_to_bucket_nodev_noerror(c, k.k->p, &bucket)) {

		if (fsck_err(c, backpointer_to_missing_device,

		if (fsck_err(trans, backpointer_to_missing_device,

			     "backpointer for missing device:\n%s",

			     (bch2_bkey_val_to_text(&buf, c, k), buf.buf)))

			ret = bch2_btree_delete_at(trans, bp_iter, 0);
@@ -407,8 +407,8 @@ static int bch2_check_btree_backpointer(struct btree_trans *trans, struct btree_ 
	if (ret)

		goto out;



	if (fsck_err_on(alloc_k.k->type != KEY_TYPE_alloc_v4, c,

			backpointer_to_missing_alloc,

	if (fsck_err_on(alloc_k.k->type != KEY_TYPE_alloc_v4,

			trans, backpointer_to_missing_alloc,

			"backpointer for nonexistent alloc key: %llu:%llu:0\n%s",

			alloc_iter.pos.inode, alloc_iter.pos.offset,

			(bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
@@ -505,7 +505,7 @@ static int check_extent_checksum(struct btree_trans *trans, 
	struct nonce nonce = extent_nonce(extent.k->version, p.crc);

	struct bch_csum csum = bch2_checksum(c, p.crc.csum_type, nonce, data_buf, bytes);

	if (fsck_err_on(bch2_crc_cmp(csum, p.crc.csum),

			c, dup_backpointer_to_bad_csum_extent,

			trans, dup_backpointer_to_bad_csum_extent,

			"%s", buf.buf))

		ret = drop_dev_and_update(trans, btree, extent, dev) ?: 1;

fsck_err:
@@ -647,7 +647,7 @@ static int check_bp_exists(struct btree_trans *trans, 
	prt_printf(&buf, "\n  want:  ");

	bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&n_bp_k.k_i));



	if (fsck_err(c, ptr_to_missing_backpointer, "%s", buf.buf))

	if (fsck_err(trans, ptr_to_missing_backpointer, "%s", buf.buf))

		ret = bch2_bucket_backpointer_mod(trans, ca, bucket, bp, orig_k, true);



	goto out;
@@ -908,7 +908,7 @@ static int check_one_backpointer(struct btree_trans *trans, 
		if (ret)

			goto out;



		if (fsck_err(c, backpointer_to_missing_ptr,

		if (fsck_err(trans, backpointer_to_missing_ptr,

			     "backpointer for missing %s\n  %s",

			     bp.v->level ? "btree node" : "extent",

			     (bch2_bkey_val_to_text(&buf, c, bp.s_c), buf.buf))) {

fs/bcachefs/btree_gc.c

+29 −25
Original line number Diff line number Diff line
@@ -175,10 +175,11 @@ static int set_node_max(struct bch_fs *c, struct btree *b, struct bpos new_max) 
	return 0;

}



static int btree_check_node_boundaries(struct bch_fs *c, struct btree *b,

static int btree_check_node_boundaries(struct btree_trans *trans, struct btree *b,

				       struct btree *prev, struct btree *cur,

				       struct bpos *pulled_from_scan)

{

	struct bch_fs *c = trans->c;

	struct bpos expected_start = !prev

		? b->data->min_key

		: bpos_successor(prev->key.k.p);
@@ -216,29 +217,29 @@ static int btree_check_node_boundaries(struct bch_fs *c, struct btree *b, 
			*pulled_from_scan = cur->data->min_key;

			ret = DID_FILL_FROM_SCAN;

		} else {

			if (mustfix_fsck_err(c, btree_node_topology_bad_min_key,

			if (mustfix_fsck_err(trans, btree_node_topology_bad_min_key,

					     "btree node with incorrect min_key%s", buf.buf))

				ret = set_node_min(c, cur, expected_start);

		}

	} else {									/* overlap */

		if (prev && BTREE_NODE_SEQ(cur->data) > BTREE_NODE_SEQ(prev->data)) {	/* cur overwrites prev */

			if (bpos_ge(prev->data->min_key, cur->data->min_key)) {		/* fully? */

				if (mustfix_fsck_err(c, btree_node_topology_overwritten_by_next_node,

				if (mustfix_fsck_err(trans, btree_node_topology_overwritten_by_next_node,

						     "btree node overwritten by next node%s", buf.buf))

					ret = DROP_PREV_NODE;

			} else {

				if (mustfix_fsck_err(c, btree_node_topology_bad_max_key,

				if (mustfix_fsck_err(trans, btree_node_topology_bad_max_key,

						     "btree node with incorrect max_key%s", buf.buf))

					ret = set_node_max(c, prev,

							   bpos_predecessor(cur->data->min_key));

			}

		} else {

			if (bpos_ge(expected_start, cur->data->max_key)) {		/* fully? */

				if (mustfix_fsck_err(c, btree_node_topology_overwritten_by_prev_node,

				if (mustfix_fsck_err(trans, btree_node_topology_overwritten_by_prev_node,

						     "btree node overwritten by prev node%s", buf.buf))

					ret = DROP_THIS_NODE;

			} else {

				if (mustfix_fsck_err(c, btree_node_topology_bad_min_key,

				if (mustfix_fsck_err(trans, btree_node_topology_bad_min_key,

						     "btree node with incorrect min_key%s", buf.buf))

					ret = set_node_min(c, cur, expected_start);

			}
@@ -250,9 +251,10 @@ static int btree_check_node_boundaries(struct bch_fs *c, struct btree *b, 
	return ret;

}



static int btree_repair_node_end(struct bch_fs *c, struct btree *b,

static int btree_repair_node_end(struct btree_trans *trans, struct btree *b,

				 struct btree *child, struct bpos *pulled_from_scan)

{

	struct bch_fs *c = trans->c;

	struct printbuf buf = PRINTBUF;

	int ret = 0;
@@ -266,7 +268,7 @@ static int btree_repair_node_end(struct bch_fs *c, struct btree *b, 
	prt_str(&buf, "\n  child: ");

	bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&child->key));



	if (mustfix_fsck_err(c, btree_node_topology_bad_max_key,

	if (mustfix_fsck_err(trans, btree_node_topology_bad_max_key,

			     "btree node with incorrect max_key%s", buf.buf)) {

		if (b->c.level == 1 &&

		    bpos_lt(*pulled_from_scan, b->key.k.p)) {
@@ -325,8 +327,8 @@ static int bch2_btree_repair_topology_recurse(struct btree_trans *trans, struct 
		printbuf_reset(&buf);

		bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(cur_k.k));



		if (mustfix_fsck_err_on(bch2_err_matches(ret, EIO), c,

				btree_node_unreadable,

		if (mustfix_fsck_err_on(bch2_err_matches(ret, EIO),

				trans, btree_node_unreadable,

				"Topology repair: unreadable btree node at btree %s level %u:\n"

				"  %s",

				bch2_btree_id_str(b->c.btree_id),
@@ -363,7 +365,7 @@ static int bch2_btree_repair_topology_recurse(struct btree_trans *trans, struct 
			continue;

		}



		ret = btree_check_node_boundaries(c, b, prev, cur, pulled_from_scan);

		ret = btree_check_node_boundaries(trans, b, prev, cur, pulled_from_scan);

		if (ret == DID_FILL_FROM_SCAN) {

			new_pass = true;

			ret = 0;
@@ -404,7 +406,7 @@ static int bch2_btree_repair_topology_recurse(struct btree_trans *trans, struct 


	if (!ret && !IS_ERR_OR_NULL(prev)) {

		BUG_ON(cur);

		ret = btree_repair_node_end(c, b, prev, pulled_from_scan);

		ret = btree_repair_node_end(trans, b, prev, pulled_from_scan);

		if (ret == DID_FILL_FROM_SCAN) {

			new_pass = true;

			ret = 0;
@@ -462,8 +464,8 @@ static int bch2_btree_repair_topology_recurse(struct btree_trans *trans, struct 
	printbuf_reset(&buf);

	bch2_bkey_val_to_text(&buf, c, bkey_i_to_s_c(&b->key));



	if (mustfix_fsck_err_on(!have_child, c,

			btree_node_topology_interior_node_empty,

	if (mustfix_fsck_err_on(!have_child,

			trans, btree_node_topology_interior_node_empty,

			"empty interior btree node at btree %s level %u\n"

			"  %s",

			bch2_btree_id_str(b->c.btree_id),
@@ -510,7 +512,7 @@ int bch2_check_topology(struct bch_fs *c) 
			r->error = 0;



			if (!bch2_btree_has_scanned_nodes(c, i)) {

				mustfix_fsck_err(c, btree_root_unreadable_and_scan_found_nothing,

				mustfix_fsck_err(trans, btree_root_unreadable_and_scan_found_nothing,

						 "no nodes found for btree %s, continue?", bch2_btree_id_str(i));

				bch2_btree_root_alloc_fake_trans(trans, i, 0);

			} else {
@@ -585,8 +587,8 @@ static int bch2_gc_mark_key(struct btree_trans *trans, enum btree_id btree_id, 
		       k.k->version.lo > atomic64_read(&c->journal.seq));



		if (fsck_err_on(btree_id != BTREE_ID_accounting &&

				k.k->version.lo > atomic64_read(&c->key_version), c,

				bkey_version_in_future,

				k.k->version.lo > atomic64_read(&c->key_version),

				trans, bkey_version_in_future,

				"key version number higher than recorded %llu\n  %s",

				atomic64_read(&c->key_version),

				(bch2_bkey_val_to_text(&buf, c, k), buf.buf)))
@@ -594,7 +596,7 @@ static int bch2_gc_mark_key(struct btree_trans *trans, enum btree_id btree_id, 
	}



	if (mustfix_fsck_err_on(level && !bch2_dev_btree_bitmap_marked(c, k),

				c, btree_bitmap_not_marked,

				trans, btree_bitmap_not_marked,

				"btree ptr not marked in member info btree allocated bitmap\n  %s",

				(printbuf_reset(&buf),

				 bch2_bkey_val_to_text(&buf, c, k),
@@ -710,7 +712,7 @@ static int bch2_gc_btrees(struct bch_fs *c) 
		ret = bch2_gc_btree(trans, btree, true);



		if (mustfix_fsck_err_on(bch2_err_matches(ret, EIO),

					c, btree_node_read_error,

					trans, btree_node_read_error,

			       "btree node read error for %s",

			       bch2_btree_id_str(btree)))

			ret = bch2_run_explicit_recovery_pass(c, BCH_RECOVERY_PASS_check_topology);
@@ -816,8 +818,8 @@ static int bch2_alloc_write_key(struct btree_trans *trans, 


	gc.fragmentation_lru = alloc_lru_idx_fragmentation(gc, ca);



	if (fsck_err_on(new.data_type != gc.data_type, c,

			alloc_key_data_type_wrong,

	if (fsck_err_on(new.data_type != gc.data_type,

			trans, alloc_key_data_type_wrong,

			"bucket %llu:%llu gen %u has wrong data_type"

			": got %s, should be %s",

			iter->pos.inode, iter->pos.offset,
@@ -827,7 +829,8 @@ static int bch2_alloc_write_key(struct btree_trans *trans, 
		new.data_type = gc.data_type;



#define copy_bucket_field(_errtype, _f)					\

	if (fsck_err_on(new._f != gc._f, c, _errtype,			\

	if (fsck_err_on(new._f != gc._f,				\

			trans, _errtype,				\

			"bucket %llu:%llu gen %u data type %s has wrong " #_f	\

			": got %llu, should be %llu",			\

			iter->pos.inode, iter->pos.offset,		\
@@ -939,8 +942,8 @@ static int bch2_gc_write_reflink_key(struct btree_trans *trans, 
		return -EINVAL;

	}



	if (fsck_err_on(r->refcount != le64_to_cpu(*refcount), c,

			reflink_v_refcount_wrong,

	if (fsck_err_on(r->refcount != le64_to_cpu(*refcount),

			trans, reflink_v_refcount_wrong,

			"reflink key has wrong refcount:\n"

			"  %s\n"

			"  should be %u",
@@ -1038,7 +1041,8 @@ static int bch2_gc_write_stripes_key(struct btree_trans *trans, 
	if (bad)

		bch2_bkey_val_to_text(&buf, c, k);



	if (fsck_err_on(bad, c, stripe_sector_count_wrong,

	if (fsck_err_on(bad,

			trans, stripe_sector_count_wrong,

			"%s", buf.buf)) {

		struct bkey_i_stripe *new;

fs/bcachefs/btree_io.c

+1 −1
Original line number Diff line number Diff line
@@ -585,7 +585,7 @@ static int __btree_err(int ret, 
	switch (ret) {

	case -BCH_ERR_btree_node_read_err_fixable:

		ret = !silent

			? bch2_fsck_err(c, FSCK_CAN_FIX, err_type, "%s", out.buf)

			? __bch2_fsck_err(c, NULL, FSCK_CAN_FIX, err_type, "%s", out.buf)

			: -BCH_ERR_fsck_fix;

		if (ret != -BCH_ERR_fsck_fix &&

		    ret != -BCH_ERR_fsck_ignore)

fs/bcachefs/btree_iter.c

+14 −0
Original line number Diff line number Diff line
@@ -3275,6 +3275,20 @@ void bch2_trans_put(struct btree_trans *trans) 
	}

}



bool bch2_current_has_btree_trans(struct bch_fs *c)

{

	seqmutex_lock(&c->btree_trans_lock);

	struct btree_trans *trans;

	bool ret = false;

	list_for_each_entry(trans, &c->btree_trans_list, list)

		if (trans->locking_wait.task == current) {

			ret = true;

			break;

		}

	seqmutex_unlock(&c->btree_trans_lock);

	return ret;

}



static void __maybe_unused

bch2_btree_bkey_cached_common_to_text(struct printbuf *out,

				      struct btree_bkey_cached_common *b)