<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">From: Milan Broz &lt;mbroz@redhat.com&gt;

Remove clone_info struct and replace it with direct references to the bio.

It's no longer needed now that we never split into more than two parts.

Signed-off-by: Milan Broz &lt;mbroz@redhat.com&gt;
---
 drivers/md/dm.c |  103 +++++++++++++++++++++-----------------------------------
 1 files changed, 40 insertions(+), 63 deletions(-)

Index: current-quilt/drivers/md/dm.c
===================================================================
--- current-quilt.orig/drivers/md/dm.c	2007-07-25 21:04:52.000000000 +0100
+++ current-quilt/drivers/md/dm.c	2007-07-25 21:04:53.000000000 +0100
@@ -618,16 +618,6 @@ static void __map_bio(struct dm_target *
 	}
 }
 
-struct clone_info {
-	struct mapped_device *md;
-	struct dm_table *map;
-	struct bio *bio;
-	struct dm_io *io;
-	sector_t sector;
-	sector_t sector_count;
-	unsigned short idx;
-};
-
 static void dm_bio_destructor(struct bio *bio)
 {
 	struct mapped_device *md = bio-&gt;bi_private;
@@ -694,46 +684,36 @@ static struct bio *clone2_bio(struct bio
 	return clone;
 }
 
-static void __clone_and_map(struct clone_info *ci)
+static void __clone_and_map(struct bio *bio, struct dm_io *io,
+			    struct dm_target_io *tio)
 {
-	struct bio *clone, *bio = ci-&gt;bio;
-	struct bio *clone2 = NULL;
-	struct dm_target *ti = dm_table_find_target(ci-&gt;map, ci-&gt;sector);
-	sector_t len = 0, max = max_io_len(ci-&gt;md, ci-&gt;sector, ti);
-	struct dm_target_io *tio;
-
-	/*
-	 * Allocate a target io object.
-	 */
-	tio = alloc_tio(ci-&gt;md);
-	tio-&gt;io = ci-&gt;io;
-	tio-&gt;ti = ti;
-	memset(&amp;tio-&gt;info, 0, sizeof(tio-&gt;info));
+	struct bio *clone, *clone2 = NULL;
+	sector_t max = max_io_len(io-&gt;md, bio-&gt;bi_sector, tio-&gt;ti);
 
 	/* Merge page function should prevent split and in ideal
 	 * situation do not allow splitting at all.
 	 * Only very inefficient mapping should cause split to more
 	 * than 2 pieces, no need to extra optimize this case.
 	 */
-	if (ci-&gt;sector_count &lt;= max) {
+	if (bio_sectors(bio) &lt;= max) {
 		/*
 		 * Optimise for the simple case where we can do all of
 		 * the remaining io with a single clone.
 		 */
-		clone = clone_bio(bio, ci-&gt;sector, ci-&gt;idx,
-				  bio-&gt;bi_vcnt - ci-&gt;idx,
-				  ci-&gt;sector_count, ci-&gt;md-&gt;bs);
+		clone = clone_bio(bio, bio-&gt;bi_sector, bio-&gt;bi_idx,
+				  bio-&gt;bi_vcnt - bio-&gt;bi_idx,
+				  bio_sectors(bio), io-&gt;md-&gt;bs);
 
-	} else if (to_sector(bio-&gt;bi_io_vec[ci-&gt;idx].bv_len) &lt;= max) {
+	} else if (bio_cur_sectors(bio) &lt;= max) {
 		/*
 		 * There are some bvecs that don't span targets.
 		 * Do as many of these as possible.
 		 */
 		int i;
 		sector_t remaining = max;
-		sector_t bv_len;
+		sector_t bv_len, len = 0;
 
-		for (i = ci-&gt;idx; remaining &amp;&amp; (i &lt; bio-&gt;bi_vcnt); i++) {
+		for (i = bio-&gt;bi_idx; remaining &amp;&amp; (i &lt; bio-&gt;bi_vcnt); i++) {
 			bv_len = to_sector(bio-&gt;bi_io_vec[i].bv_len);
 
 			if (bv_len &gt; remaining)
@@ -743,29 +723,24 @@ static void __clone_and_map(struct clone
 			len += bv_len;
 		}
 
-		clone = clone_bio(bio, ci-&gt;sector, ci-&gt;idx, i - ci-&gt;idx, len,
-				  ci-&gt;md-&gt;bs);
-
-		ci-&gt;sector += len;
-		ci-&gt;sector_count -= len;
-		ci-&gt;idx = i;
+		clone = clone_bio(bio, bio-&gt;bi_sector, bio-&gt;bi_idx,
+				  i - bio-&gt;bi_idx, len, io-&gt;md-&gt;bs);
 
 		/* Clone second part of bio */
-		clone2 = clone2_bio(bio, ci-&gt;sector, ci-&gt;idx, ci-&gt;sector_count, ci-&gt;md);
+		clone2 = clone2_bio(bio, bio-&gt;bi_sector + len, i,
+				    bio_sectors(bio) - len, io-&gt;md);
 	} else {
 		/*
 		 * Handle a bvec that must be split between two or more targets.
 		 */
-		struct bio_vec *bv = bio-&gt;bi_io_vec + ci-&gt;idx;
-
-		clone = split_bvec(bio, ci-&gt;sector, ci-&gt;idx, bv-&gt;bv_offset, max,
-				   ci-&gt;md-&gt;bs);
+		struct bio_vec *bv = bio-&gt;bi_io_vec + bio-&gt;bi_idx;
 
-		ci-&gt;sector += max;
-		ci-&gt;sector_count -= max;
+		clone = split_bvec(bio, bio-&gt;bi_sector, bio-&gt;bi_idx,
+				   bv-&gt;bv_offset, max, io-&gt;md-&gt;bs);
 
 		/* Clone second part of bio */
-		clone2 = clone2_bio(bio, ci-&gt;sector, ci-&gt;idx, ci-&gt;sector_count, ci-&gt;md);
+		clone2 = clone2_bio(bio, bio-&gt;bi_sector + max, bio-&gt;bi_idx,
+				    bio_sectors(bio) - max, io-&gt;md);
 		bv = clone2-&gt;bi_io_vec + clone2-&gt;bi_idx;
 		bv-&gt;bv_len -= to_bytes(max);
 		bv-&gt;bv_offset += to_bytes(max);
@@ -775,7 +750,7 @@ static void __clone_and_map(struct clone
 	 * Fire off both parts of bio, the first will be remmaped and
 	 * the second is queued for new dm_request to the same device.
 	 */
-	__map_bio(ti, clone, tio);
+	__map_bio(tio-&gt;ti, clone, tio);
 	if (clone2)
 		generic_make_request(clone2);
 }
@@ -785,32 +760,34 @@ static void __clone_and_map(struct clone
  */
 static int __split_bio(struct mapped_device *md, struct bio *bio)
 {
-	struct clone_info ci;
+	struct dm_table *map = dm_get_table(md);
+	struct dm_io *io;
+	struct dm_target_io *tio;
 
-	ci.map = dm_get_table(md);
-	if (unlikely(!ci.map))
+	if (unlikely(!map))
 		return -EIO;
 
-	ci.md = md;
-	ci.bio = bio;
-	ci.io = alloc_io(md);
-	ci.io-&gt;error = 0;
-	atomic_set(&amp;ci.io-&gt;io_count, 1);
-	ci.io-&gt;bio = bio;
-	ci.io-&gt;md = md;
-	ci.sector = bio-&gt;bi_sector;
-	ci.sector_count = bio_sectors(bio);
-	ci.idx = bio-&gt;bi_idx;
+	io = alloc_io(md);
+	io-&gt;error = 0;
+	atomic_set(&amp;io-&gt;io_count, 1);
+	io-&gt;bio = bio;
+	io-&gt;md = md;
+
+	tio = alloc_tio(md);
+	tio-&gt;io = io;
+	tio-&gt;ti = dm_table_find_target(map, bio-&gt;bi_sector);
+	memset(&amp;tio-&gt;info, 0, sizeof(tio-&gt;info));
 
-	start_io_acct(ci.io);
-	__clone_and_map(&amp;ci);
+	start_io_acct(io);
+	__clone_and_map(bio, io, tio);
 
 	/* drop the extra reference count */
-	dec_pending(ci.io, 0);
-	dm_table_put(ci.map);
+	dec_pending(io, 0);
+	dm_table_put(map);
 
 	return 0;
 }
+
 /*-----------------------------------------------------------------
  * CRUD END
  *---------------------------------------------------------------*/
</pre></body></html>