bcachefs: Fix initialization of bch_write_op.nonce

If an extent ends up with a replica that is encrypted an a replica that
isn't encrypted (due the user changing options), and then
copygc/rebalance moves one of the replicas by reading from the
unencrypted replica, we had a bug where we wouldn't correctly initialize
op->nonce - for each crc field in an extent, crc.offset + crc.nonce must
be equal.

This patch fixes that by moving op.nonce initialization to
bch2_migrate_write_init.

Signed-off-by: Kent Overstreet <kent.overstreet@gmail.com>

1 files changed, 64 insertions, 71 deletions

diff --git a/fs/bcachefs/btree_key_cache.c b/fs/bcachefs/btree_key_cache.c
index 924b67e79805..2dfa5040d045 100644
--- a/fs/bcachefs/btree_key_cache.c
+++ b/fs/bcachefs/btree_key_cache.c
@@ -196,23 +196,23 @@ btree_key_cache_create(struct btree_key_cache *c,
 }
 
 static int btree_key_cache_fill(struct btree_trans *trans,
-				struct btree_iter *ck_iter,
+				struct btree_path *ck_path,
 				struct bkey_cached *ck)
 {
-	struct btree_iter *iter;
+	struct btree_iter iter;
 	struct bkey_s_c k;
 	unsigned new_u64s = 0;
 	struct bkey_i *new_k = NULL;
 	int ret;
 
-	iter = bch2_trans_get_iter(trans, ck->key.btree_id,
-				   ck->key.pos, BTREE_ITER_SLOTS);
-	k = bch2_btree_iter_peek_slot(iter);
+	bch2_trans_iter_init(trans, &iter, ck->key.btree_id,
+			     ck->key.pos, BTREE_ITER_SLOTS);
+	k = bch2_btree_iter_peek_slot(&iter);
 	ret = bkey_err(k);
 	if (ret)
 		goto err;
 
-	if (!bch2_btree_node_relock(trans, ck_iter, 0)) {
+	if (!bch2_btree_node_relock(trans, ck_path, 0)) {
 		trace_transaction_restart_ip(trans->ip, _THIS_IP_);
 		ret = btree_trans_restart(trans);
 		goto err;
@@ -237,7 +237,7 @@ static int btree_key_cache_fill(struct btree_trans *trans,
 	 * XXX: not allowed to be holding read locks when we take a write lock,
 	 * currently
 	 */
-	bch2_btree_node_lock_write(trans, ck_iter, ck_iter->l[0].b);
+	bch2_btree_node_lock_write(trans, ck_path, ck_path->l[0].b);
 	if (new_k) {
 		kfree(ck->k);
 		ck->u64s = new_u64s;
@@ -246,62 +246,64 @@ static int btree_key_cache_fill(struct btree_trans *trans,
 
 	bkey_reassemble(ck->k, k);
 	ck->valid = true;
-	bch2_btree_node_unlock_write(trans, ck_iter, ck_iter->l[0].b);
+	bch2_btree_node_unlock_write(trans, ck_path, ck_path->l[0].b);
 
 	/* We're not likely to need this iterator again: */
-	set_btree_iter_dontneed(trans, iter);
+	set_btree_iter_dontneed(&iter);
 err:
-	bch2_trans_iter_put(trans, iter);
+	bch2_trans_iter_exit(trans, &iter);
 	return ret;
 }
 
 static int bkey_cached_check_fn(struct six_lock *lock, void *p)
 {
 	struct bkey_cached *ck = container_of(lock, struct bkey_cached, c.lock);
-	const struct btree_iter *iter = p;
+	const struct btree_path *path = p;
 
-	return ck->key.btree_id == iter->btree_id &&
-		!bpos_cmp(ck->key.pos, iter->pos) ? 0 : -1;
+	return ck->key.btree_id == path->btree_id &&
+		!bpos_cmp(ck->key.pos, path->pos) ? 0 : -1;
 }
 
 __flatten
-int bch2_btree_iter_traverse_cached(struct btree_trans *trans, struct btree_iter *iter)
+int bch2_btree_path_traverse_cached(struct btree_trans *trans, struct btree_path *path,
+				    unsigned flags)
 {
 	struct bch_fs *c = trans->c;
 	struct bkey_cached *ck;
 	int ret = 0;
 
-	BUG_ON(iter->level);
+	BUG_ON(path->level);
 
-	iter->l[1].b = NULL;
+	path->l[1].b = NULL;
 
-	if (bch2_btree_node_relock(trans, iter, 0)) {
-		ck = (void *) iter->l[0].b;
+	if (bch2_btree_node_relock(trans, path, 0)) {
+		ck = (void *) path->l[0].b;
 		goto fill;
 	}
 retry:
-	ck = bch2_btree_key_cache_find(c, iter->btree_id, iter->pos);
+	ck = bch2_btree_key_cache_find(c, path->btree_id, path->pos);
 	if (!ck) {
-		if (iter->flags & BTREE_ITER_CACHED_NOCREATE) {
-			iter->l[0].b = NULL;
+		if (flags & BTREE_ITER_CACHED_NOCREATE) {
+			path->l[0].b = NULL;
 			return 0;
 		}
 
 		ck = btree_key_cache_create(&c->btree_key_cache,
-					    iter->btree_id, iter->pos);
+					    path->btree_id, path->pos);
 		ret = PTR_ERR_OR_ZERO(ck);
 		if (ret)
 			goto err;
 		if (!ck)
 			goto retry;
 
-		mark_btree_node_locked(iter, 0, SIX_LOCK_intent);
-		iter->locks_want = 1;
+		mark_btree_node_locked(path, 0, SIX_LOCK_intent);
+		path->locks_want = 1;
 	} else {
-		enum six_lock_type lock_want = __btree_lock_want(iter, 0);
+		enum six_lock_type lock_want = __btree_lock_want(path, 0);
 
-		if (!btree_node_lock(trans, iter, (void *) ck, iter->pos, 0, lock_want,
-				     bkey_cached_check_fn, iter, _THIS_IP_)) {
+		if (!btree_node_lock(trans, path, (void *) ck, path->pos, 0,
+				     lock_want,
+				     bkey_cached_check_fn, path, _THIS_IP_)) {
 			if (!trans->restarted)
 				goto retry;
 
@@ -310,28 +312,27 @@ retry:
 			goto err;
 		}
 
-		if (ck->key.btree_id != iter->btree_id ||
-		    bpos_cmp(ck->key.pos, iter->pos)) {
+		if (ck->key.btree_id != path->btree_id ||
+		    bpos_cmp(ck->key.pos, path->pos)) {
 			six_unlock_type(&ck->c.lock, lock_want);
 			goto retry;
 		}
 
-		mark_btree_node_locked(iter, 0, lock_want);
+		mark_btree_node_locked(path, 0, lock_want);
 	}
 
-	iter->l[0].lock_seq	= ck->c.lock.state.seq;
-	iter->l[0].b		= (void *) ck;
+	path->l[0].lock_seq	= ck->c.lock.state.seq;
+	path->l[0].b		= (void *) ck;
 fill:
-	if (!ck->valid && !(iter->flags & BTREE_ITER_CACHED_NOFILL)) {
-		if (!iter->locks_want &&
-		    !!__bch2_btree_iter_upgrade(trans, iter, 1)) {
+	if (!ck->valid && !(flags & BTREE_ITER_CACHED_NOFILL)) {
+		if (!path->locks_want &&
+		    !__bch2_btree_path_upgrade(trans, path, 1)) {
 			trace_transaction_restart_ip(trans->ip, _THIS_IP_);
-			BUG_ON(!trans->restarted);
-			ret = -EINTR;
+			ret = btree_trans_restart(trans);
 			goto err;
 		}
 
-		ret = btree_key_cache_fill(trans, iter, ck);
+		ret = btree_key_cache_fill(trans, path, ck);
 		if (ret)
 			goto err;
 	}
@@ -339,22 +340,14 @@ fill:
 	if (!test_bit(BKEY_CACHED_ACCESSED, &ck->flags))
 		set_bit(BKEY_CACHED_ACCESSED, &ck->flags);
 
-	iter->uptodate = BTREE_ITER_UPTODATE;
-
-	if ((iter->flags & BTREE_ITER_INTENT) &&
-	    !bch2_btree_iter_upgrade(trans, iter, 1)) {
-		BUG_ON(!trans->restarted);
-		ret = -EINTR;
-	}
-
-	BUG_ON(!ret && !btree_node_locked(iter, 0));
+	path->uptodate = BTREE_ITER_UPTODATE;
+	BUG_ON(btree_node_locked_type(path, 0) != btree_lock_want(path, 0));
 
 	return ret;
 err:
 	if (ret != -EINTR) {
-		btree_node_unlock(iter, 0);
-		iter->flags |= BTREE_ITER_ERROR;
-		iter->l[0].b = BTREE_ITER_NO_NODE_ERROR;
+		btree_node_unlock(path, 0);
+		path->l[0].b = BTREE_ITER_NO_NODE_ERROR;
 	}
 	return ret;
 }
@@ -367,23 +360,23 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans,
 {
 	struct bch_fs *c = trans->c;
 	struct journal *j = &c->journal;
-	struct btree_iter *c_iter = NULL, *b_iter = NULL;
+	struct btree_iter c_iter, b_iter;
 	struct bkey_cached *ck = NULL;
 	int ret;
 
-	b_iter = bch2_trans_get_iter(trans, key.btree_id, key.pos,
-				     BTREE_ITER_SLOTS|
-				     BTREE_ITER_INTENT);
-	c_iter = bch2_trans_get_iter(trans, key.btree_id, key.pos,
-				     BTREE_ITER_CACHED|
-				     BTREE_ITER_CACHED_NOFILL|
-				     BTREE_ITER_CACHED_NOCREATE|
-				     BTREE_ITER_INTENT);
-	ret = bch2_btree_iter_traverse(c_iter);
+	bch2_trans_iter_init(trans, &b_iter, key.btree_id, key.pos,
+			     BTREE_ITER_SLOTS|
+			     BTREE_ITER_INTENT);
+	bch2_trans_iter_init(trans, &c_iter, key.btree_id, key.pos,
+			     BTREE_ITER_CACHED|
+			     BTREE_ITER_CACHED_NOFILL|
+			     BTREE_ITER_CACHED_NOCREATE|
+			     BTREE_ITER_INTENT);
+	ret = bch2_btree_iter_traverse(&c_iter);
 	if (ret)
 		goto out;
 
-	ck = (void *) c_iter->l[0].b;
+	ck = (void *) c_iter.path->l[0].b;
 	if (!ck ||
 	    (journal_seq && ck->journal.seq != journal_seq))
 		goto out;
@@ -399,8 +392,8 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans,
 	 * allocator/copygc depend on journal reclaim making progress, we need
 	 * to be using alloc reserves:
 	 * */
-	ret   = bch2_btree_iter_traverse(b_iter) ?:
-		bch2_trans_update(trans, b_iter, ck->k,
+	ret   = bch2_btree_iter_traverse(&b_iter) ?:
+		bch2_trans_update(trans, &b_iter, ck->k,
 				  BTREE_UPDATE_INTERNAL_SNAPSHOT_NODE|
 				  BTREE_TRIGGER_NORUN) ?:
 		bch2_trans_commit(trans, NULL, NULL,
@@ -422,7 +415,7 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans,
 	bch2_journal_pin_drop(j, &ck->journal);
 	bch2_journal_preres_put(j, &ck->res);
 
-	BUG_ON(!btree_node_locked(c_iter, 0));
+	BUG_ON(!btree_node_locked(c_iter.path, 0));
 
 	if (!evict) {
 		if (test_bit(BKEY_CACHED_DIRTY, &ck->flags)) {
@@ -431,10 +424,10 @@ static int btree_key_cache_flush_pos(struct btree_trans *trans,
 		}
 	} else {
 evict:
-		BUG_ON(!btree_node_intent_locked(c_iter, 0));
+		BUG_ON(!btree_node_intent_locked(c_iter.path, 0));
 
-		mark_btree_node_unlocked(c_iter, 0);
-		c_iter->l[0].b = NULL;
+		mark_btree_node_unlocked(c_iter.path, 0);
+		c_iter.path->l[0].b = NULL;
 
 		six_lock_write(&ck->c.lock, NULL, NULL);
 
@@ -450,8 +443,8 @@ evict:
 		mutex_unlock(&c->btree_key_cache.lock);
 	}
 out:
-	bch2_trans_iter_put(trans, b_iter);
-	bch2_trans_iter_put(trans, c_iter);
+	bch2_trans_iter_exit(trans, &b_iter);
+	bch2_trans_iter_exit(trans, &c_iter);
 	return ret;
 }
 
@@ -502,11 +495,11 @@ int bch2_btree_key_cache_flush(struct btree_trans *trans,
 }
 
 bool bch2_btree_insert_key_cached(struct btree_trans *trans,
-				  struct btree_iter *iter,
+				  struct btree_path *path,
 				  struct bkey_i *insert)
 {
 	struct bch_fs *c = trans->c;
-	struct bkey_cached *ck = (void *) iter->l[0].b;
+	struct bkey_cached *ck = (void *) path->l[0].b;
 	bool kick_reclaim = false;
 
 	BUG_ON(insert->u64s > ck->u64s);