Commit 5dd8c60e authored by Kent Overstreet's avatar Kent Overstreet
Browse files

bcachefs: iter/update/trigger/str_hash flag cleanup 



Combine iter/update/trigger/str_hash flags into a single enum, and
x-macroize them for a to_text() function later.

These flags are all for a specific iter/key/update context, so it makes
sense to group them together - iter/update/trigger flags were already
given distinct bits, this cleans up and unifies that handling.

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

fs/bcachefs/acl.c

+2 −2
Original line number Diff line number Diff line
@@ -360,7 +360,7 @@ int bch2_set_acl(struct mnt_idmap *idmap, 


	ret   = bch2_subvol_is_ro_trans(trans, inode->ei_subvol) ?:

		bch2_inode_peek(trans, &inode_iter, &inode_u, inode_inum(inode),

			      BTREE_ITER_INTENT);

			      BTREE_ITER_intent);

	if (ret)

		goto btree_err;
@@ -411,7 +411,7 @@ int bch2_acl_chmod(struct btree_trans *trans, subvol_inum inum, 
	struct posix_acl *acl = NULL;



	struct bkey_s_c k = bch2_hash_lookup(trans, &iter, bch2_xattr_hash_desc,

			       &hash_info, inum, &search, BTREE_ITER_INTENT);

			       &hash_info, inum, &search, BTREE_ITER_intent);

	int ret = bkey_err(k);

	if (ret)

		return bch2_err_matches(ret, ENOENT) ? 0 : ret;

fs/bcachefs/alloc_background.c

+30 −30
Original line number Diff line number Diff line
@@ -437,9 +437,9 @@ bch2_trans_start_alloc_update(struct btree_trans *trans, struct btree_iter *iter 
	int ret;



	k = bch2_bkey_get_iter(trans, iter, BTREE_ID_alloc, pos,

			     BTREE_ITER_WITH_UPDATES|

			     BTREE_ITER_CACHED|

			     BTREE_ITER_INTENT);

			     BTREE_ITER_with_updates|

			     BTREE_ITER_cached|

			     BTREE_ITER_intent);

	ret = bkey_err(k);

	if (unlikely(ret))

		return ERR_PTR(ret);
@@ -510,7 +510,7 @@ int bch2_bucket_gens_init(struct bch_fs *c) 
	int ret;



	ret = for_each_btree_key(trans, iter, BTREE_ID_alloc, POS_MIN,

				 BTREE_ITER_PREFETCH, k, ({

				 BTREE_ITER_prefetch, k, ({

		/*

		 * Not a fsck error because this is checked/repaired by

		 * bch2_check_alloc_key() which runs later:
@@ -563,7 +563,7 @@ int bch2_alloc_read(struct bch_fs *c) 


	if (c->sb.version_upgrade_complete >= bcachefs_metadata_version_bucket_gens) {

		ret = for_each_btree_key(trans, iter, BTREE_ID_bucket_gens, POS_MIN,

					 BTREE_ITER_PREFETCH, k, ({

					 BTREE_ITER_prefetch, k, ({

			u64 start = bucket_gens_pos_to_alloc(k.k->p, 0).offset;

			u64 end = bucket_gens_pos_to_alloc(bpos_nosnap_successor(k.k->p), 0).offset;
@@ -589,7 +589,7 @@ int bch2_alloc_read(struct bch_fs *c) 
		}));

	} else {

		ret = for_each_btree_key(trans, iter, BTREE_ID_alloc, POS_MIN,

					 BTREE_ITER_PREFETCH, k, ({

					 BTREE_ITER_prefetch, k, ({

			/*

			 * Not a fsck error because this is checked/repaired by

			 * bch2_check_alloc_key() which runs later:
@@ -657,7 +657,7 @@ static int bch2_bucket_do_index(struct btree_trans *trans, 


	old = bch2_bkey_get_iter(trans, &iter, btree,

			     bkey_start_pos(&k->k),

			     BTREE_ITER_INTENT);

			     BTREE_ITER_intent);

	ret = bkey_err(old);

	if (ret)

		return ret;
@@ -701,8 +701,8 @@ static noinline int bch2_bucket_gen_update(struct btree_trans *trans, 
		return ret;



	k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_bucket_gens, pos,

			       BTREE_ITER_INTENT|

			       BTREE_ITER_WITH_UPDATES);

			       BTREE_ITER_intent|

			       BTREE_ITER_with_updates);

	ret = bkey_err(k);

	if (ret)

		return ret;
@@ -738,7 +738,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
	struct bch_alloc_v4 old_a_convert;

	const struct bch_alloc_v4 *old_a = bch2_alloc_to_v4(old, &old_a_convert);



	if (flags & BTREE_TRIGGER_TRANSACTIONAL) {

	if (flags & BTREE_TRIGGER_transactional) {

		struct bch_alloc_v4 *new_a = bkey_s_to_alloc_v4(new).v;



		new_a->data_type = alloc_data_type(*new_a, new_a->data_type);
@@ -802,7 +802,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
		 * not:

		 */



		if ((flags & BTREE_TRIGGER_BUCKET_INVALIDATE) &&

		if ((flags & BTREE_TRIGGER_bucket_invalidate) &&

		    old_a->cached_sectors) {

			ret = bch2_update_cached_sectors_list(trans, new.k->p.inode,

							      -((s64) old_a->cached_sectors));
@@ -811,12 +811,12 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
		}

	}



	if ((flags & BTREE_TRIGGER_ATOMIC) && (flags & BTREE_TRIGGER_INSERT)) {

	if ((flags & BTREE_TRIGGER_atomic) && (flags & BTREE_TRIGGER_insert)) {

		struct bch_alloc_v4 *new_a = bkey_s_to_alloc_v4(new).v;

		u64 journal_seq = trans->journal_res.seq;

		u64 bucket_journal_seq = new_a->journal_seq;



		if ((flags & BTREE_TRIGGER_INSERT) &&

		if ((flags & BTREE_TRIGGER_insert) &&

		    data_type_is_empty(old_a->data_type) !=

		    data_type_is_empty(new_a->data_type) &&

		    new.k->type == KEY_TYPE_alloc_v4) {
@@ -877,8 +877,8 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
			bch2_do_gc_gens(c);

	}



	if ((flags & BTREE_TRIGGER_GC) &&

	    (flags & BTREE_TRIGGER_BUCKET_INVALIDATE)) {

	if ((flags & BTREE_TRIGGER_gc) &&

	    (flags & BTREE_TRIGGER_bucket_invalidate)) {

		struct bch_alloc_v4 new_a_convert;

		const struct bch_alloc_v4 *new_a = bch2_alloc_to_v4(new.s_c, &new_a_convert);
@@ -903,7 +903,7 @@ int bch2_trigger_alloc(struct btree_trans *trans, 
}



/*

 * This synthesizes deleted extents for holes, similar to BTREE_ITER_SLOTS for

 * 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)
@@ -1401,13 +1401,13 @@ int bch2_check_alloc_info(struct bch_fs *c) 
	int ret = 0;



	bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc, POS_MIN,

			     BTREE_ITER_PREFETCH);

			     BTREE_ITER_prefetch);

	bch2_trans_iter_init(trans, &discard_iter, BTREE_ID_need_discard, POS_MIN,

			     BTREE_ITER_PREFETCH);

			     BTREE_ITER_prefetch);

	bch2_trans_iter_init(trans, &freespace_iter, BTREE_ID_freespace, POS_MIN,

			     BTREE_ITER_PREFETCH);

			     BTREE_ITER_prefetch);

	bch2_trans_iter_init(trans, &bucket_gens_iter, BTREE_ID_bucket_gens, POS_MIN,

			     BTREE_ITER_PREFETCH);

			     BTREE_ITER_prefetch);



	while (1) {

		struct bpos next;
@@ -1469,13 +1469,13 @@ int bch2_check_alloc_info(struct bch_fs *c) 


	ret = for_each_btree_key(trans, iter,

			BTREE_ID_need_discard, POS_MIN,

			BTREE_ITER_PREFETCH, k,

			BTREE_ITER_prefetch, k,

		bch2_check_discard_freespace_key(trans, &iter));

	if (ret)

		goto err;



	bch2_trans_iter_init(trans, &iter, BTREE_ID_freespace, POS_MIN,

			     BTREE_ITER_PREFETCH);

			     BTREE_ITER_prefetch);

	while (1) {

		bch2_trans_begin(trans);

		k = bch2_btree_iter_peek(&iter);
@@ -1505,7 +1505,7 @@ int bch2_check_alloc_info(struct bch_fs *c) 


	ret = for_each_btree_key_commit(trans, iter,

			BTREE_ID_bucket_gens, POS_MIN,

			BTREE_ITER_PREFETCH, k,

			BTREE_ITER_prefetch, k,

			NULL, NULL, BCH_TRANS_COMMIT_no_enospc,

		bch2_check_bucket_gens_key(trans, &iter, k));

err:
@@ -1552,7 +1552,7 @@ static int bch2_check_alloc_to_lru_ref(struct btree_trans *trans, 


		a_mut->v.io_time[READ] = atomic64_read(&c->io_clock[READ].now);

		ret = bch2_trans_update(trans, alloc_iter,

					&a_mut->k_i, BTREE_TRIGGER_NORUN);

					&a_mut->k_i, BTREE_TRIGGER_norun);

		if (ret)

			goto err;
@@ -1591,7 +1591,7 @@ int bch2_check_alloc_to_lru_refs(struct bch_fs *c) 
{

	int ret = bch2_trans_run(c,

		for_each_btree_key_commit(trans, iter, BTREE_ID_alloc,

				POS_MIN, BTREE_ITER_PREFETCH, k,

				POS_MIN, BTREE_ITER_prefetch, k,

				NULL, NULL, BCH_TRANS_COMMIT_no_enospc,

			bch2_check_alloc_to_lru_ref(trans, &iter)));

	bch_err_fn(c, ret);
@@ -1693,7 +1693,7 @@ static int bch2_discard_one_bucket(struct btree_trans *trans, 


	k = bch2_bkey_get_iter(trans, &iter, BTREE_ID_alloc,

			       need_discard_iter->pos,

			       BTREE_ITER_CACHED);

			       BTREE_ITER_cached);

	ret = bkey_err(k);

	if (ret)

		goto out;
@@ -1817,7 +1817,7 @@ void bch2_do_discards(struct bch_fs *c) 
static int bch2_clear_bucket_needs_discard(struct btree_trans *trans, struct bpos bucket)

{

	struct btree_iter iter;

	bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc, bucket, BTREE_ITER_INTENT);

	bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc, bucket, BTREE_ITER_intent);

	struct bkey_s_c k = bch2_btree_iter_peek_slot(&iter);

	int ret = bkey_err(k);

	if (ret)
@@ -1952,7 +1952,7 @@ static int invalidate_one_bucket(struct btree_trans *trans, 
	a->v.io_time[WRITE]	= atomic64_read(&c->io_clock[WRITE].now);



	ret =   bch2_trans_update(trans, &alloc_iter, &a->k_i,

				BTREE_TRIGGER_BUCKET_INVALIDATE) ?:

				BTREE_TRIGGER_bucket_invalidate) ?:

		bch2_trans_commit(trans, NULL, NULL,

				  BCH_WATERMARK_btree|

				  BCH_TRANS_COMMIT_no_enospc);
@@ -2004,7 +2004,7 @@ static void bch2_do_invalidates_work(struct work_struct *work) 
		ret = for_each_btree_key_upto(trans, iter, BTREE_ID_lru,

				lru_pos(ca->dev_idx, 0, 0),

				lru_pos(ca->dev_idx, U64_MAX, LRU_TIME_MAX),

				BTREE_ITER_INTENT, k,

				BTREE_ITER_intent, k,

			invalidate_one_bucket(trans, &iter, k, &nr_to_invalidate));



		if (ret < 0) {
@@ -2041,7 +2041,7 @@ int bch2_dev_freespace_init(struct bch_fs *c, struct bch_dev *ca, 


	bch2_trans_iter_init(trans, &iter, BTREE_ID_alloc,

		POS(ca->dev_idx, max_t(u64, ca->mi.first_bucket, bucket_start)),

		BTREE_ITER_PREFETCH);

		BTREE_ITER_prefetch);

	/*

	 * Scan the alloc btree for every bucket on @ca, and add buckets to the

	 * freespace/need_discard/need_gc_gens btrees as needed:

fs/bcachefs/alloc_foreground.c

+4 −4
Original line number Diff line number Diff line
@@ -300,7 +300,7 @@ static struct open_bucket *try_alloc_bucket(struct btree_trans *trans, struct bc 


	k = bch2_bkey_get_iter(trans, &iter,

			       BTREE_ID_alloc, POS(ca->dev_idx, b),

			       BTREE_ITER_CACHED);

			       BTREE_ITER_cached);

	ret = bkey_err(k);

	if (ret) {

		ob = ERR_PTR(ret);
@@ -344,7 +344,7 @@ static struct open_bucket *try_alloc_bucket(struct btree_trans *trans, struct bc 


		ret = bch2_get_next_backpointer(trans, POS(ca->dev_idx, b), -1,

						&bp_pos, &bp,

						BTREE_ITER_NOPRESERVE);

						BTREE_ITER_nopreserve);

		if (ret) {

			ob = ERR_PTR(ret);

			goto err;
@@ -404,7 +404,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, 
	 */

again:

	for_each_btree_key_norestart(trans, iter, BTREE_ID_alloc, POS(ca->dev_idx, alloc_cursor),

			   BTREE_ITER_SLOTS, k, ret) {

			   BTREE_ITER_slots, k, ret) {

		struct bch_alloc_v4 a_convert;

		const struct bch_alloc_v4 *a;
@@ -420,7 +420,7 @@ bch2_bucket_alloc_early(struct btree_trans *trans, 
			continue;



		/* now check the cached key to serialize concurrent allocs of the bucket */

		ck = bch2_bkey_get_iter(trans, &citer, BTREE_ID_alloc, k.k->p, BTREE_ITER_CACHED);

		ck = bch2_bkey_get_iter(trans, &citer, BTREE_ID_alloc, k.k->p, BTREE_ITER_cached);

		ret = bkey_err(ck);

		if (ret)

			break;

fs/bcachefs/backpointers.c

+7 −7
Original line number Diff line number Diff line
@@ -170,9 +170,9 @@ int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *trans, 


	k = bch2_bkey_get_iter(trans, &bp_iter, BTREE_ID_backpointers,

			       bp_k->k.p,

			       BTREE_ITER_INTENT|

			       BTREE_ITER_SLOTS|

			       BTREE_ITER_WITH_UPDATES);

			       BTREE_ITER_intent|

			       BTREE_ITER_slots|

			       BTREE_ITER_with_updates);

	ret = bkey_err(k);

	if (ret)

		goto err;
@@ -212,7 +212,7 @@ int bch2_get_next_backpointer(struct btree_trans *trans, 


	if (gen >= 0) {

		k = bch2_bkey_get_iter(trans, &alloc_iter, BTREE_ID_alloc,

				       bucket, BTREE_ITER_CACHED|iter_flags);

				       bucket, BTREE_ITER_cached|iter_flags);

		ret = bkey_err(k);

		if (ret)

			goto out;
@@ -759,7 +759,7 @@ static int bch2_get_btree_in_memory_pos(struct btree_trans *trans, 


		__for_each_btree_node(trans, iter, btree,

				      btree == start.btree ? start.pos : POS_MIN,

				      0, depth, BTREE_ITER_PREFETCH, b, ret) {

				      0, depth, BTREE_ITER_prefetch, b, ret) {

			mem_may_pin -= btree_buf_bytes(b);

			if (mem_may_pin <= 0) {

				c->btree_cache.pinned_nodes_end = *end =
@@ -794,7 +794,7 @@ static int bch2_check_extents_to_backpointers_pass(struct btree_trans *trans, 
		while (level >= depth) {

			struct btree_iter iter;

			bch2_trans_node_iter_init(trans, &iter, btree_id, POS_MIN, 0, level,

						  BTREE_ITER_PREFETCH);

						  BTREE_ITER_prefetch);



			ret = for_each_btree_key_continue(trans, iter, 0, k, ({

				check_extent_to_backpointers(trans, s, btree_id, level, k) ?:
@@ -917,7 +917,7 @@ static int bch2_check_backpointers_to_extents_pass(struct btree_trans *trans, 
	struct bpos last_flushed_pos = SPOS_MAX;



	return for_each_btree_key_commit(trans, iter, BTREE_ID_backpointers,

				  POS_MIN, BTREE_ITER_PREFETCH, k,

				  POS_MIN, BTREE_ITER_prefetch, k,

				  NULL, NULL, BCH_TRANS_COMMIT_no_enospc,

		check_one_backpointer(trans, start, end,

				      bkey_s_c_to_backpointer(k),

fs/bcachefs/bkey_methods.h

+11 −54
Original line number Diff line number Diff line
@@ -29,7 +29,8 @@ struct bkey_ops { 
	bool		(*key_normalize)(struct bch_fs *, struct bkey_s);

	bool		(*key_merge)(struct bch_fs *, struct bkey_s, struct bkey_s_c);

	int		(*trigger)(struct btree_trans *, enum btree_id, unsigned,

				   struct bkey_s_c, struct bkey_s, unsigned);

				   struct bkey_s_c, struct bkey_s,

				   enum btree_iter_update_trigger_flags);

	void		(*compat)(enum btree_id id, unsigned version,

				  unsigned big_endian, int write,

				  struct bkey_s);
@@ -76,56 +77,10 @@ static inline bool bch2_bkey_maybe_mergable(const struct bkey *l, const struct b 


bool bch2_bkey_merge(struct bch_fs *, struct bkey_s, struct bkey_s_c);



enum btree_update_flags {

	__BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE = __BTREE_ITER_FLAGS_END,

	__BTREE_UPDATE_NOJOURNAL,

	__BTREE_UPDATE_KEY_CACHE_RECLAIM,



	__BTREE_TRIGGER_NORUN,

	__BTREE_TRIGGER_TRANSACTIONAL,

	__BTREE_TRIGGER_ATOMIC,

	__BTREE_TRIGGER_GC,

	__BTREE_TRIGGER_INSERT,

	__BTREE_TRIGGER_OVERWRITE,

	__BTREE_TRIGGER_BUCKET_INVALIDATE,

};



#define BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE (1U << __BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE)

#define BTREE_UPDATE_NOJOURNAL		(1U << __BTREE_UPDATE_NOJOURNAL)

#define BTREE_UPDATE_KEY_CACHE_RECLAIM	(1U << __BTREE_UPDATE_KEY_CACHE_RECLAIM)



/* Don't run triggers at all */

#define BTREE_TRIGGER_NORUN		(1U << __BTREE_TRIGGER_NORUN)



/*

 * If set, we're running transactional triggers as part of a transaction commit:

 * triggers may generate new updates

 *

 * If cleared, and either BTREE_TRIGGER_INSERT|BTREE_TRIGGER_OVERWRITE are set,

 * we're running atomic triggers during a transaction commit: we have our

 * journal reservation, we're holding btree node write locks, and we know the

 * transaction is going to commit (returning an error here is a fatal error,

 * causing us to go emergency read-only)

 */

#define BTREE_TRIGGER_TRANSACTIONAL	(1U << __BTREE_TRIGGER_TRANSACTIONAL)

#define BTREE_TRIGGER_ATOMIC		(1U << __BTREE_TRIGGER_ATOMIC)



/* We're in gc/fsck: running triggers to recalculate e.g. disk usage */

#define BTREE_TRIGGER_GC		(1U << __BTREE_TRIGGER_GC)



/* @new is entering the btree */

#define BTREE_TRIGGER_INSERT		(1U << __BTREE_TRIGGER_INSERT)



/* @old is leaving the btree */

#define BTREE_TRIGGER_OVERWRITE		(1U << __BTREE_TRIGGER_OVERWRITE)



/* signal from bucket invalidate path to alloc trigger */

#define BTREE_TRIGGER_BUCKET_INVALIDATE	(1U << __BTREE_TRIGGER_BUCKET_INVALIDATE)



static inline int bch2_key_trigger(struct btree_trans *trans,

		enum btree_id btree, unsigned level,

		struct bkey_s_c old, struct bkey_s new,

		unsigned flags)

		enum btree_iter_update_trigger_flags flags)

{

	const struct bkey_ops *ops = bch2_bkey_type_ops(old.k->type ?: new.k->type);
@@ -136,7 +91,8 @@ static inline int bch2_key_trigger(struct btree_trans *trans, 


static inline int bch2_key_trigger_old(struct btree_trans *trans,

			enum btree_id btree_id, unsigned level,

				       struct bkey_s_c old, unsigned flags)

			struct bkey_s_c old,

			enum btree_iter_update_trigger_flags flags)

{

	struct bkey_i deleted;
@@ -144,12 +100,13 @@ static inline int bch2_key_trigger_old(struct btree_trans *trans, 
	deleted.k.p = old.k->p;



	return bch2_key_trigger(trans, btree_id, level, old, bkey_i_to_s(&deleted),

				BTREE_TRIGGER_OVERWRITE|flags);

				BTREE_TRIGGER_overwrite|flags);

}



static inline int bch2_key_trigger_new(struct btree_trans *trans,

			enum btree_id btree_id, unsigned level,

				       struct bkey_s new, unsigned flags)

			struct bkey_s new,

			enum btree_iter_update_trigger_flags flags)

{

	struct bkey_i deleted;
@@ -157,7 +114,7 @@ static inline int bch2_key_trigger_new(struct btree_trans *trans, 
	deleted.k.p = new.k->p;



	return bch2_key_trigger(trans, btree_id, level, bkey_i_to_s_c(&deleted), new,

				BTREE_TRIGGER_INSERT|flags);

				BTREE_TRIGGER_insert|flags);

}



void bch2_bkey_renumber(enum btree_node_type, struct bkey_packed *, int);