1 files changed, 33 insertions, 28 deletions

diff --git a/libbcachefs/btree_cache.c b/libbcachefs/btree_cache.c
index cd0c5009..5f9ab818 100644
--- a/libbcachefs/btree_cache.c
+++ b/libbcachefs/btree_cache.c
@@ -128,7 +128,8 @@ struct btree *__bch2_btree_node_mem_alloc(struct bch_fs *c)
 
 void bch2_btree_node_hash_remove(struct btree_cache *bc, struct btree *b)
 {
-	rhashtable_remove_fast(&bc->table, &b->hash, bch_btree_cache_params);
+	int ret = rhashtable_remove_fast(&bc->table, &b->hash, bch_btree_cache_params);
+	BUG_ON(ret);
 
 	/* Cause future lookups for this node to fail: */
 	b->hash_val = 0;
@@ -632,7 +633,8 @@ err:
 
 /* Slowpath, don't want it inlined into btree_iter_traverse() */
 static noinline struct btree *bch2_btree_node_fill(struct bch_fs *c,
-				struct btree_iter *iter,
+				struct btree_trans *trans,
+				struct btree_path *path,
 				const struct bkey_i *k,
 				enum btree_id btree_id,
 				unsigned level,
@@ -648,8 +650,8 @@ static noinline struct btree *bch2_btree_node_fill(struct bch_fs *c,
 	 * Parent node must be locked, else we could read in a btree node that's
 	 * been freed:
 	 */
-	if (iter && !bch2_btree_node_relock(iter, level + 1)) {
-		btree_trans_restart(iter->trans);
+	if (trans && !bch2_btree_node_relock(trans, path, level + 1)) {
+		btree_trans_restart(trans);
 		return ERR_PTR(-EINTR);
 	}
 
@@ -680,23 +682,23 @@ static noinline struct btree *bch2_btree_node_fill(struct bch_fs *c,
 	six_unlock_intent(&b->c.lock);
 
 	/* Unlock before doing IO: */
-	if (iter && sync)
-		bch2_trans_unlock(iter->trans);
+	if (trans && sync)
+		bch2_trans_unlock(trans);
 
 	bch2_btree_node_read(c, b, sync);
 
 	if (!sync)
 		return NULL;
 
-	if (iter &&
-	    (!bch2_trans_relock(iter->trans) ||
-	     !bch2_btree_iter_relock_intent(iter))) {
-		BUG_ON(!iter->trans->restarted);
+	if (trans &&
+	    (!bch2_trans_relock(trans) ||
+	     !bch2_btree_path_relock_intent(trans, path))) {
+		BUG_ON(!trans->restarted);
 		return ERR_PTR(-EINTR);
 	}
 
 	if (!six_relock_type(&b->c.lock, lock_type, seq)) {
-		btree_trans_restart(iter->trans);
+		btree_trans_restart(trans);
 		return ERR_PTR(-EINTR);
 	}
 
@@ -754,7 +756,7 @@ static inline void btree_check_header(struct bch_fs *c, struct btree *b)
  * The btree node will have either a read or a write lock held, depending on
  * the @write parameter.
  */
-struct btree *bch2_btree_node_get(struct btree_trans *trans, struct btree_iter *iter,
+struct btree *bch2_btree_node_get(struct btree_trans *trans, struct btree_path *path,
 				  const struct bkey_i *k, unsigned level,
 				  enum six_lock_type lock_type,
 				  unsigned long trace_ip)
@@ -779,7 +781,7 @@ retry:
 		 * else we could read in a btree node from disk that's been
 		 * freed:
 		 */
-		b = bch2_btree_node_fill(c, iter, k, iter->btree_id,
+		b = bch2_btree_node_fill(c, trans, path, k, path->btree_id,
 					 level, lock_type, true);
 
 		/* We raced and found the btree node in the cache */
@@ -818,10 +820,10 @@ lock_node:
 		 * the parent was modified, when the pointer to the node we want
 		 * was removed - and we'll bail out:
 		 */
-		if (btree_node_read_locked(iter, level + 1))
-			btree_node_unlock(iter, level + 1);
+		if (btree_node_read_locked(path, level + 1))
+			btree_node_unlock(path, level + 1);
 
-		if (!btree_node_lock(b, k->k.p, level, iter, lock_type,
+		if (!btree_node_lock(trans, path, b, k->k.p, level, lock_type,
 				     lock_node_check_fn, (void *) k, trace_ip)) {
 			if (!trans->restarted)
 				goto retry;
@@ -832,13 +834,13 @@ lock_node:
 			     b->c.level != level ||
 			     race_fault())) {
 			six_unlock_type(&b->c.lock, lock_type);
-			if (bch2_btree_node_relock(iter, level + 1))
+			if (bch2_btree_node_relock(trans, path, level + 1))
 				goto retry;
 
 			trace_trans_restart_btree_node_reused(trans->ip,
 							      trace_ip,
-							      iter->btree_id,
-							      &iter->real_pos);
+							      path->btree_id,
+							      &path->pos);
 			btree_trans_restart(trans);
 			return ERR_PTR(-EINTR);
 		}
@@ -853,12 +855,12 @@ lock_node:
 		bch2_btree_node_wait_on_read(b);
 
 		/*
-		 * should_be_locked is not set on this iterator yet, so we need
-		 * to relock it specifically:
+		 * should_be_locked is not set on this path yet, so we need to
+		 * relock it specifically:
 		 */
-		if (iter &&
+		if (trans &&
 		    (!bch2_trans_relock(trans) ||
-		     !bch2_btree_iter_relock_intent(iter))) {
+		     !bch2_btree_path_relock_intent(trans, path))) {
 			BUG_ON(!trans->restarted);
 			return ERR_PTR(-EINTR);
 		}
@@ -886,7 +888,7 @@ lock_node:
 		return ERR_PTR(-EIO);
 	}
 
-	EBUG_ON(b->c.btree_id != iter->btree_id);
+	EBUG_ON(b->c.btree_id != path->btree_id);
 	EBUG_ON(BTREE_NODE_LEVEL(b->data) != level);
 	btree_check_header(c, b);
 
@@ -917,7 +919,7 @@ retry:
 		if (nofill)
 			goto out;
 
-		b = bch2_btree_node_fill(c, NULL, k, btree_id,
+		b = bch2_btree_node_fill(c, NULL, NULL, k, btree_id,
 					 level, SIX_LOCK_read, true);
 
 		/* We raced and found the btree node in the cache */
@@ -975,21 +977,24 @@ out:
 	return b;
 }
 
-int bch2_btree_node_prefetch(struct bch_fs *c, struct btree_iter *iter,
+int bch2_btree_node_prefetch(struct bch_fs *c,
+			     struct btree_trans *trans,
+			     struct btree_path *path,
 			     const struct bkey_i *k,
 			     enum btree_id btree_id, unsigned level)
 {
 	struct btree_cache *bc = &c->btree_cache;
 	struct btree *b;
 
-	BUG_ON(iter && !btree_node_locked(iter, level + 1));
+	BUG_ON(trans && !btree_node_locked(path, level + 1));
 	BUG_ON(level >= BTREE_MAX_DEPTH);
 
 	b = btree_cache_find(bc, k);
 	if (b)
 		return 0;
 
-	b = bch2_btree_node_fill(c, iter, k, btree_id, level, SIX_LOCK_read, false);
+	b = bch2_btree_node_fill(c, trans, path, k, btree_id,
+				 level, SIX_LOCK_read, false);
 	return PTR_ERR_OR_ZERO(b);
 }