bcachefs: btree_path

This splits btree_iter into two components: btree_iter is now the
externally visible componont, and it points to a btree_path which is now
reference counted.

This means we no longer have to clone iterators up front if they might
be mutated - btree_path can be shared by multiple iterators, and cloned
if an iterator would mutate a shared btree_path. This will help us use
iterators more efficiently, as well as slimming down the main long lived
state in btree_trans, and significantly cleans up the logic for iterator
lifetimes.

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

1 files changed, 59 insertions, 58 deletions

diff --git a/fs/bcachefs/btree_locking.h b/fs/bcachefs/btree_locking.h
index b490e4808631..d05689180c63 100644
--- a/fs/bcachefs/btree_locking.h
+++ b/fs/bcachefs/btree_locking.h
@@ -20,7 +20,7 @@ enum btree_node_locked_type {
 	BTREE_NODE_INTENT_LOCKED	= SIX_LOCK_intent,
 };
 
-static inline int btree_node_locked_type(struct btree_iter *iter,
+static inline int btree_node_locked_type(struct btree_path *path,
 					 unsigned level)
 {
 	/*
@@ -29,35 +29,35 @@ static inline int btree_node_locked_type(struct btree_iter *iter,
 	 * branches:
 	 */
 	return BTREE_NODE_UNLOCKED +
-		((iter->nodes_locked >> level) & 1) +
-		((iter->nodes_intent_locked >> level) & 1);
+		((path->nodes_locked >> level) & 1) +
+		((path->nodes_intent_locked >> level) & 1);
 }
 
-static inline bool btree_node_intent_locked(struct btree_iter *iter,
+static inline bool btree_node_intent_locked(struct btree_path *path,
 					    unsigned level)
 {
-	return btree_node_locked_type(iter, level) == BTREE_NODE_INTENT_LOCKED;
+	return btree_node_locked_type(path, level) == BTREE_NODE_INTENT_LOCKED;
 }
 
-static inline bool btree_node_read_locked(struct btree_iter *iter,
+static inline bool btree_node_read_locked(struct btree_path *path,
 					  unsigned level)
 {
-	return btree_node_locked_type(iter, level) == BTREE_NODE_READ_LOCKED;
+	return btree_node_locked_type(path, level) == BTREE_NODE_READ_LOCKED;
 }
 
-static inline bool btree_node_locked(struct btree_iter *iter, unsigned level)
+static inline bool btree_node_locked(struct btree_path *path, unsigned level)
 {
-	return iter->nodes_locked & (1 << level);
+	return path->nodes_locked & (1 << level);
 }
 
-static inline void mark_btree_node_unlocked(struct btree_iter *iter,
+static inline void mark_btree_node_unlocked(struct btree_path *path,
 					    unsigned level)
 {
-	iter->nodes_locked &= ~(1 << level);
-	iter->nodes_intent_locked &= ~(1 << level);
+	path->nodes_locked &= ~(1 << level);
+	path->nodes_intent_locked &= ~(1 << level);
 }
 
-static inline void mark_btree_node_locked(struct btree_iter *iter,
+static inline void mark_btree_node_locked(struct btree_path *path,
 					  unsigned level,
 					  enum six_lock_type type)
 {
@@ -65,52 +65,52 @@ static inline void mark_btree_node_locked(struct btree_iter *iter,
 	BUILD_BUG_ON(SIX_LOCK_read   != 0);
 	BUILD_BUG_ON(SIX_LOCK_intent != 1);
 
-	iter->nodes_locked |= 1 << level;
-	iter->nodes_intent_locked |= type << level;
+	path->nodes_locked |= 1 << level;
+	path->nodes_intent_locked |= type << level;
 }
 
-static inline void mark_btree_node_intent_locked(struct btree_iter *iter,
+static inline void mark_btree_node_intent_locked(struct btree_path *path,
 						 unsigned level)
 {
-	mark_btree_node_locked(iter, level, SIX_LOCK_intent);
+	mark_btree_node_locked(path, level, SIX_LOCK_intent);
 }
 
-static inline enum six_lock_type __btree_lock_want(struct btree_iter *iter, int level)
+static inline enum six_lock_type __btree_lock_want(struct btree_path *path, int level)
 {
-	return level < iter->locks_want
+	return level < path->locks_want
 		? SIX_LOCK_intent
 		: SIX_LOCK_read;
 }
 
 static inline enum btree_node_locked_type
-btree_lock_want(struct btree_iter *iter, int level)
+btree_lock_want(struct btree_path *path, int level)
 {
-	if (level < iter->level)
+	if (level < path->level)
 		return BTREE_NODE_UNLOCKED;
-	if (level < iter->locks_want)
+	if (level < path->locks_want)
 		return BTREE_NODE_INTENT_LOCKED;
-	if (level == iter->level)
+	if (level == path->level)
 		return BTREE_NODE_READ_LOCKED;
 	return BTREE_NODE_UNLOCKED;
 }
 
-static inline void btree_node_unlock(struct btree_iter *iter, unsigned level)
+static inline void btree_node_unlock(struct btree_path *path, unsigned level)
 {
-	int lock_type = btree_node_locked_type(iter, level);
+	int lock_type = btree_node_locked_type(path, level);
 
 	EBUG_ON(level >= BTREE_MAX_DEPTH);
 
 	if (lock_type != BTREE_NODE_UNLOCKED)
-		six_unlock_type(&iter->l[level].b->c.lock, lock_type);
-	mark_btree_node_unlocked(iter, level);
+		six_unlock_type(&path->l[level].b->c.lock, lock_type);
+	mark_btree_node_unlocked(path, level);
 }
 
-static inline void __bch2_btree_iter_unlock(struct btree_iter *iter)
+static inline void __bch2_btree_path_unlock(struct btree_path *path)
 {
-	btree_iter_set_dirty(iter, BTREE_ITER_NEED_RELOCK);
+	btree_path_set_dirty(path, BTREE_ITER_NEED_RELOCK);
 
-	while (iter->nodes_locked)
-		btree_node_unlock(iter, __ffs(iter->nodes_locked));
+	while (path->nodes_locked)
+		btree_node_unlock(path, __ffs(path->nodes_locked));
 }
 
 static inline enum bch_time_stats lock_to_time_stat(enum six_lock_type type)
@@ -154,11 +154,11 @@ static inline bool btree_node_lock_increment(struct btree_trans *trans,
 					     struct btree *b, unsigned level,
 					     enum btree_node_locked_type want)
 {
-	struct btree_iter *iter;
+	struct btree_path *path;
 
-	trans_for_each_iter(trans, iter)
-		if (iter->l[level].b == b &&
-		    btree_node_locked_type(iter, level) >= want) {
+	trans_for_each_path(trans, path)
+		if (path->l[level].b == b &&
+		    btree_node_locked_type(path, level) >= want) {
 			six_lock_increment(&b->c.lock, want);
 			return true;
 		}
@@ -166,38 +166,39 @@ static inline bool btree_node_lock_increment(struct btree_trans *trans,
 	return false;
 }
 
-bool __bch2_btree_node_lock(struct btree_trans *, struct btree_iter *,
+bool __bch2_btree_node_lock(struct btree_trans *, struct btree_path *,
 			    struct btree *, struct bpos, unsigned,
-			    enum six_lock_type, six_lock_should_sleep_fn,
-			    void *, unsigned long);
+			    enum six_lock_type,
+			    six_lock_should_sleep_fn, void *,
+			    unsigned long);
 
 static inline bool btree_node_lock(struct btree_trans *trans,
-			struct btree_iter *iter,
+			struct btree_path *path,
 			struct btree *b, struct bpos pos, unsigned level,
 			enum six_lock_type type,
 			six_lock_should_sleep_fn should_sleep_fn, void *p,
 			unsigned long ip)
 {
 	EBUG_ON(level >= BTREE_MAX_DEPTH);
-	EBUG_ON(!(trans->iters_linked & (1ULL << iter->idx)));
+	EBUG_ON(!(trans->paths_allocated & (1ULL << path->idx)));
 
 	return likely(six_trylock_type(&b->c.lock, type)) ||
 		btree_node_lock_increment(trans, b, level, type) ||
-		__bch2_btree_node_lock(trans, iter, b, pos, level, type,
+		__bch2_btree_node_lock(trans, path, b, pos, level, type,
 				       should_sleep_fn, p, ip);
 }
 
-bool __bch2_btree_node_relock(struct btree_trans *, struct btree_iter *, unsigned);
+bool __bch2_btree_node_relock(struct btree_trans *, struct btree_path *, unsigned);
 
 static inline bool bch2_btree_node_relock(struct btree_trans *trans,
-					  struct btree_iter *iter, unsigned level)
+					  struct btree_path *path, unsigned level)
 {
-	EBUG_ON(btree_node_locked(iter, level) &&
-		btree_node_locked_type(iter, level) !=
-		__btree_lock_want(iter, level));
+	EBUG_ON(btree_node_locked(path, level) &&
+		btree_node_locked_type(path, level) !=
+		__btree_lock_want(path, level));
 
-	return likely(btree_node_locked(iter, level)) ||
-		__bch2_btree_node_relock(trans, iter, level);
+	return likely(btree_node_locked(path, level)) ||
+		__bch2_btree_node_relock(trans, path, level);
 }
 
 /*
@@ -205,32 +206,32 @@ static inline bool bch2_btree_node_relock(struct btree_trans *trans,
  * succeed:
  */
 static inline void
-bch2_btree_node_unlock_write_inlined(struct btree_trans *trans, struct btree_iter *iter,
+bch2_btree_node_unlock_write_inlined(struct btree_trans *trans, struct btree_path *path,
 				     struct btree *b)
 {
-	struct btree_iter *linked;
+	struct btree_path *linked;
 
-	EBUG_ON(iter->l[b->c.level].b != b);
-	EBUG_ON(iter->l[b->c.level].lock_seq + 1 != b->c.lock.state.seq);
+	EBUG_ON(path->l[b->c.level].b != b);
+	EBUG_ON(path->l[b->c.level].lock_seq + 1 != b->c.lock.state.seq);
 
-	trans_for_each_iter_with_node(trans, b, linked)
+	trans_for_each_path_with_node(trans, b, linked)
 		linked->l[b->c.level].lock_seq += 2;
 
 	six_unlock_write(&b->c.lock);
 }
 
 void bch2_btree_node_unlock_write(struct btree_trans *,
-			struct btree_iter *, struct btree *);
+			struct btree_path *, struct btree *);
 
 void __bch2_btree_node_lock_write(struct btree_trans *, struct btree *);
 
 static inline void bch2_btree_node_lock_write(struct btree_trans *trans,
-					      struct btree_iter *iter,
+					      struct btree_path *path,
 					      struct btree *b)
 {
-	EBUG_ON(iter->l[b->c.level].b != b);
-	EBUG_ON(iter->l[b->c.level].lock_seq != b->c.lock.state.seq);
-	EBUG_ON(!btree_node_intent_locked(iter, b->c.level));
+	EBUG_ON(path->l[b->c.level].b != b);
+	EBUG_ON(path->l[b->c.level].lock_seq != b->c.lock.state.seq);
+	EBUG_ON(!btree_node_intent_locked(path, b->c.level));
 
 	if (unlikely(!six_trylock_write(&b->c.lock)))
 		__bch2_btree_node_lock_write(trans, b);