1 files changed, 52 insertions, 116 deletions

diff --git a/libbcachefs/io.c b/libbcachefs/io.c
index d95e23d8..4fcc2c71 100644
--- a/libbcachefs/io.c
+++ b/libbcachefs/io.c
@@ -1635,8 +1635,8 @@ static void bch2_read_retry_nodecode(struct bch_fs *c, struct bch_read_bio *rbio
 	bch2_bkey_buf_init(&sk);
 	bch2_trans_init(&trans, c, 0, 0);
 
-	iter = bch2_trans_get_iter(&trans, BTREE_ID_extents,
-				   rbio->pos, BTREE_ITER_SLOTS);
+	iter = bch2_trans_get_iter(&trans, rbio->data_btree,
+				   rbio->read_pos, BTREE_ITER_SLOTS);
 retry:
 	rbio->bio.bi_status = 0;
 
@@ -1650,14 +1650,17 @@ retry:
 
 	if (!bch2_bkey_matches_ptr(c, k,
 				   rbio->pick.ptr,
-				   rbio->pos.offset -
+				   rbio->data_pos.offset -
 				   rbio->pick.crc.offset)) {
 		/* extent we wanted to read no longer exists: */
 		rbio->hole = true;
 		goto out;
 	}
 
-	ret = __bch2_read_extent(&trans, rbio, bvec_iter, k, 0, failed, flags);
+	ret = __bch2_read_extent(&trans, rbio, bvec_iter,
+				 rbio->read_pos,
+				 rbio->data_btree,
+				 k, 0, failed, flags);
 	if (ret == READ_RETRY)
 		goto retry;
 	if (ret)
@@ -1672,82 +1675,6 @@ err:
 	goto out;
 }
 
-static void bch2_read_retry(struct bch_fs *c, struct bch_read_bio *rbio,
-			    struct bvec_iter bvec_iter, u64 inode,
-			    struct bch_io_failures *failed, unsigned flags)
-{
-	struct btree_trans trans;
-	struct btree_iter *iter;
-	struct bkey_buf sk;
-	struct bkey_s_c k;
-	int ret;
-
-	flags &= ~BCH_READ_LAST_FRAGMENT;
-	flags |= BCH_READ_MUST_CLONE;
-
-	bch2_bkey_buf_init(&sk);
-	bch2_trans_init(&trans, c, 0, 0);
-retry:
-	bch2_trans_begin(&trans);
-
-	for_each_btree_key(&trans, iter, BTREE_ID_extents,
-			   POS(inode, bvec_iter.bi_sector),
-			   BTREE_ITER_SLOTS, k, ret) {
-		unsigned bytes, sectors, offset_into_extent;
-
-		bch2_bkey_buf_reassemble(&sk, c, k);
-
-		offset_into_extent = iter->pos.offset -
-			bkey_start_offset(k.k);
-		sectors = k.k->size - offset_into_extent;
-
-		ret = bch2_read_indirect_extent(&trans,
-					&offset_into_extent, &sk);
-		if (ret)
-			break;
-
-		k = bkey_i_to_s_c(sk.k);
-
-		sectors = min(sectors, k.k->size - offset_into_extent);
-
-		bch2_trans_unlock(&trans);
-
-		bytes = min(sectors, bvec_iter_sectors(bvec_iter)) << 9;
-		swap(bvec_iter.bi_size, bytes);
-
-		ret = __bch2_read_extent(&trans, rbio, bvec_iter, k,
-				offset_into_extent, failed, flags);
-		switch (ret) {
-		case READ_RETRY:
-			goto retry;
-		case READ_ERR:
-			goto err;
-		};
-
-		if (bytes == bvec_iter.bi_size)
-			goto out;
-
-		swap(bvec_iter.bi_size, bytes);
-		bio_advance_iter(&rbio->bio, &bvec_iter, bytes);
-	}
-
-	if (ret == -EINTR)
-		goto retry;
-	/*
-	 * If we get here, it better have been because there was an error
-	 * reading a btree node
-	 */
-	BUG_ON(!ret);
-	bch_err_inum_ratelimited(c, inode,
-			"read error %i from btree lookup", ret);
-err:
-	rbio->bio.bi_status = BLK_STS_IOERR;
-out:
-	bch2_trans_exit(&trans);
-	bch2_bkey_buf_exit(&sk, c);
-	bch2_rbio_done(rbio);
-}
-
 static void bch2_rbio_retry(struct work_struct *work)
 {
 	struct bch_read_bio *rbio =
@@ -1755,7 +1682,7 @@ static void bch2_rbio_retry(struct work_struct *work)
 	struct bch_fs *c	= rbio->c;
 	struct bvec_iter iter	= rbio->bvec_iter;
 	unsigned flags		= rbio->flags;
-	u64 inode		= rbio->pos.inode;
+	u64 inode		= rbio->read_pos.inode;
 	struct bch_io_failures failed = { .nr = 0 };
 
 	trace_read_retry(&rbio->bio);
@@ -1770,10 +1697,14 @@ static void bch2_rbio_retry(struct work_struct *work)
 	flags |= BCH_READ_IN_RETRY;
 	flags &= ~BCH_READ_MAY_PROMOTE;
 
-	if (flags & BCH_READ_NODECODE)
+	if (flags & BCH_READ_NODECODE) {
 		bch2_read_retry_nodecode(c, rbio, iter, inode, &failed, flags);
-	else
-		bch2_read_retry(c, rbio, iter, inode, &failed, flags);
+	} else {
+		flags &= ~BCH_READ_LAST_FRAGMENT;
+		flags |= BCH_READ_MUST_CLONE;
+
+		__bch2_read(c, rbio, iter, inode, &failed, flags);
+	}
 }
 
 static void bch2_rbio_error(struct bch_read_bio *rbio, int retry,
@@ -1799,7 +1730,7 @@ static int __bch2_rbio_narrow_crcs(struct btree_trans *trans,
 				   struct bch_read_bio *rbio)
 {
 	struct bch_fs *c = rbio->c;
-	u64 data_offset = rbio->pos.offset - rbio->pick.crc.offset;
+	u64 data_offset = rbio->data_pos.offset - rbio->pick.crc.offset;
 	struct bch_extent_crc_unpacked new_crc;
 	struct btree_iter *iter = NULL;
 	struct bkey_i *new;
@@ -1809,7 +1740,7 @@ static int __bch2_rbio_narrow_crcs(struct btree_trans *trans,
 	if (crc_is_compressed(rbio->pick.crc))
 		return 0;
 
-	iter = bch2_trans_get_iter(trans, BTREE_ID_extents, rbio->pos,
+	iter = bch2_trans_get_iter(trans, rbio->data_btree, rbio->data_pos,
 				   BTREE_ITER_SLOTS|BTREE_ITER_INTENT);
 	k = bch2_btree_iter_peek_slot(iter);
 	if ((ret = bkey_err(k)))
@@ -1942,14 +1873,14 @@ csum_err:
 		return;
 	}
 
-	bch2_dev_inum_io_error(ca, rbio->pos.inode, (u64) rbio->bvec_iter.bi_sector,
+	bch2_dev_inum_io_error(ca, rbio->read_pos.inode, (u64) rbio->bvec_iter.bi_sector,
 		"data checksum error: expected %0llx:%0llx got %0llx:%0llx (type %u)",
 		rbio->pick.crc.csum.hi, rbio->pick.crc.csum.lo,
 		csum.hi, csum.lo, crc.csum_type);
 	bch2_rbio_error(rbio, READ_RETRY_AVOID, BLK_STS_IOERR);
 	return;
 decompression_err:
-	bch_err_inum_ratelimited(c, rbio->pos.inode,
+	bch_err_inum_ratelimited(c, rbio->read_pos.inode,
 				 "decompression error");
 	bch2_rbio_error(rbio, READ_ERR, BLK_STS_IOERR);
 	return;
@@ -1972,13 +1903,9 @@ static void bch2_read_endio(struct bio *bio)
 	if (!rbio->split)
 		rbio->bio.bi_end_io = rbio->end_io;
 
-	/*
-	 * XXX: rbio->pos is not what we want here when reading from indirect
-	 * extents
-	 */
 	if (bch2_dev_inum_io_err_on(bio->bi_status, ca,
-				    rbio->pos.inode,
-				    rbio->pos.offset,
+				    rbio->read_pos.inode,
+				    rbio->read_pos.offset,
 				    "data read error: %s",
 			       bch2_blk_status_to_str(bio->bi_status))) {
 		bch2_rbio_error(rbio, READ_RETRY_AVOID, bio->bi_status);
@@ -2043,7 +1970,8 @@ err:
 }
 
 int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,
-		       struct bvec_iter iter, struct bkey_s_c k,
+		       struct bvec_iter iter, struct bpos read_pos,
+		       enum btree_id data_btree, struct bkey_s_c k,
 		       unsigned offset_into_extent,
 		       struct bch_io_failures *failed, unsigned flags)
 {
@@ -2053,7 +1981,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,
 	struct bch_dev *ca;
 	struct promote_op *promote = NULL;
 	bool bounce = false, read_full = false, narrow_crcs = false;
-	struct bpos pos = bkey_start_pos(k.k);
+	struct bpos data_pos = bkey_start_pos(k.k);
 	int pick_ret;
 
 	if (bkey_extent_is_inline_data(k.k)) {
@@ -2129,7 +2057,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,
 			 pick.crc.offset ||
 			 offset_into_extent));
 
-		pos.offset += offset_into_extent;
+		data_pos.offset += offset_into_extent;
 		pick.ptr.offset += pick.crc.offset +
 			offset_into_extent;
 		offset_into_extent		= 0;
@@ -2201,7 +2129,9 @@ get_bio:
 	/* XXX: only initialize this if needed */
 	rbio->devs_have		= bch2_bkey_devs(k);
 	rbio->pick		= pick;
-	rbio->pos		= pos;
+	rbio->read_pos		= read_pos;
+	rbio->data_btree	= data_btree;
+	rbio->data_pos		= data_pos;
 	rbio->version		= k.k->version;
 	rbio->promote		= promote;
 	INIT_WORK(&rbio->work, NULL);
@@ -2271,6 +2201,9 @@ out:
 			ret = READ_RETRY;
 		}
 
+		if (!ret)
+			goto out_read_done;
+
 		return ret;
 	}
 
@@ -2297,23 +2230,17 @@ out_read_done:
 	return 0;
 }
 
-void bch2_read(struct bch_fs *c, struct bch_read_bio *rbio, u64 inode)
+void __bch2_read(struct bch_fs *c, struct bch_read_bio *rbio,
+		 struct bvec_iter bvec_iter, u64 inode,
+		 struct bch_io_failures *failed, unsigned flags)
 {
 	struct btree_trans trans;
 	struct btree_iter *iter;
 	struct bkey_buf sk;
 	struct bkey_s_c k;
-	unsigned flags = BCH_READ_RETRY_IF_STALE|
-		BCH_READ_MAY_PROMOTE|
-		BCH_READ_USER_MAPPED;
 	int ret;
 
-	BUG_ON(rbio->_state);
 	BUG_ON(flags & BCH_READ_NODECODE);
-	BUG_ON(flags & BCH_READ_IN_RETRY);
-
-	rbio->c = c;
-	rbio->start_time = local_clock();
 
 	bch2_bkey_buf_init(&sk);
 	bch2_trans_init(&trans, c, 0, 0);
@@ -2321,13 +2248,14 @@ retry:
 	bch2_trans_begin(&trans);
 
 	iter = bch2_trans_get_iter(&trans, BTREE_ID_extents,
-				   POS(inode, rbio->bio.bi_iter.bi_sector),
+				   POS(inode, bvec_iter.bi_sector),
 				   BTREE_ITER_SLOTS);
 	while (1) {
 		unsigned bytes, sectors, offset_into_extent;
+		enum btree_id data_btree = BTREE_ID_extents;
 
 		bch2_btree_iter_set_pos(iter,
-				POS(inode, rbio->bio.bi_iter.bi_sector));
+				POS(inode, bvec_iter.bi_sector));
 
 		k = bch2_btree_iter_peek_slot(iter);
 		ret = bkey_err(k);
@@ -2340,7 +2268,7 @@ retry:
 
 		bch2_bkey_buf_reassemble(&sk, c, k);
 
-		ret = bch2_read_indirect_extent(&trans,
+		ret = bch2_read_indirect_extent(&trans, &data_btree,
 					&offset_into_extent, &sk);
 		if (ret)
 			goto err;
@@ -2359,19 +2287,27 @@ retry:
 		 */
 		bch2_trans_unlock(&trans);
 
-		bytes = min(sectors, bio_sectors(&rbio->bio)) << 9;
-		swap(rbio->bio.bi_iter.bi_size, bytes);
+		bytes = min(sectors, bvec_iter_sectors(bvec_iter)) << 9;
+		swap(bvec_iter.bi_size, bytes);
 
-		if (rbio->bio.bi_iter.bi_size == bytes)
+		if (bvec_iter.bi_size == bytes)
 			flags |= BCH_READ_LAST_FRAGMENT;
 
-		bch2_read_extent(&trans, rbio, k, offset_into_extent, flags);
+		ret = __bch2_read_extent(&trans, rbio, bvec_iter, iter->pos,
+					 data_btree, k,
+					 offset_into_extent, failed, flags);
+		switch (ret) {
+		case READ_RETRY:
+			goto retry;
+		case READ_ERR:
+			goto err;
+		};
 
 		if (flags & BCH_READ_LAST_FRAGMENT)
 			break;
 
-		swap(rbio->bio.bi_iter.bi_size, bytes);
-		bio_advance(&rbio->bio, bytes);
+		swap(bvec_iter.bi_size, bytes);
+		bio_advance_iter(&rbio->bio, &bvec_iter, bytes);
 	}
 out:
 	bch2_trans_exit(&trans);