md/raid1: split out two sub-functions from sync_request_write

sync_request_write is too big and too deep. So split out two self-contains bits of functionality into separate function. Signed-off-by: NeilBrown <neilb@suse.de>
author: NeilBrown <neilb@suse.de> 2011-05-11 00:40:44 -0400
committer: NeilBrown <neilb@suse.de> 2011-05-11 00:40:44 -0400
commit: a68e58703575b9c03d610a818e0241564fc17f68 (patch)
tree: f60a433b20a4e297d010a23775e78493687c160b
parent: 6f8d0c77cef5849433dd7beb0bd97e573cc4a6a3 (diff)
1 files changed, 192 insertions, 173 deletions
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index f0b0c79b3899..7fd7a4d6f5c7 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -1181,194 +1181,213 @@ static void end_sync_write(struct bio *bio, int error)
        }
 }
-static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
+static int fix_sync_read_error(r1bio_t *r1_bio)
 {
+        /* Try some synchronous reads of other devices to get
+         * good data, much like with normal read errors.  Only
+         * read into the pages we already have so we don't
+         * need to re-issue the read request.
+         * We don't need to freeze the array, because being in an
+         * active sync request, there is no normal IO, and
+         * no overlapping syncs.
+         */
+        mddev_t *mddev = r1_bio->mddev;
        conf_t *conf = mddev->private;
-        int i;
+        struct bio *bio = r1_bio->bios[r1_bio->read_disk];
-        int disks = conf->raid_disks;
+        sector_t sect = r1_bio->sector;
-        struct bio *bio, *wbio;
+        int sectors = r1_bio->sectors;
+        int idx = 0;
-        bio = r1_bio->bios[r1_bio->read_disk];
+        while(sectors) {
+                int s = sectors;
+                int d = r1_bio->read_disk;
-        if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
+                int success = 0;
-                /* We have read all readable devices.  If we haven't
+                mdk_rdev_t *rdev;
-                 * got the block, then there is no hope left.
-                 * If we have, then we want to do a comparison
-                 * and skip the write if everything is the same.
-                 * If any blocks failed to read, then we need to
-                 * attempt an over-write
-                 */
-                int primary;
-                if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
-                        for (i=0; i<mddev->raid_disks; i++)
-                                if (r1_bio->bios[i]->bi_end_io == end_sync_read)
-                                        md_error(mddev, conf->mirrors[i].rdev);
-                        md_done_sync(mddev, r1_bio->sectors, 1);
+                if (s > (PAGE_SIZE>>9))
+                        s = PAGE_SIZE >> 9;
+                do {
+                        if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
+                                /* No rcu protection needed here devices
+                                 * can only be removed when no resync is
+                                 * active, and resync is currently active
+                                 */
+                                rdev = conf->mirrors[d].rdev;
+                                if (sync_page_io(rdev,
+                                                 sect,
+                                                 s<<9,
+                                                 bio->bi_io_vec[idx].bv_page,
+                                                 READ, false)) {
+                                        success = 1;
+                                        break;
+                                }
+                        }
+                        d++;
+                        if (d == conf->raid_disks)
+                                d = 0;
+                } while (!success && d != r1_bio->read_disk);
+                if (success) {
+                        int start = d;
+                        /* write it back and re-read */
+                        set_bit(R1BIO_Uptodate, &r1_bio->state);
+                        while (d != r1_bio->read_disk) {
+                                if (d == 0)
+                                        d = conf->raid_disks;
+                                d--;
+                                if (r1_bio->bios[d]->bi_end_io != end_sync_read)
+                                        continue;
+                                rdev = conf->mirrors[d].rdev;
+                                atomic_add(s, &rdev->corrected_errors);
+                                if (sync_page_io(rdev,
+                                                 sect,
+                                                 s<<9,
+                                                 bio->bi_io_vec[idx].bv_page,
+                                                 WRITE, false) == 0)
+                                        md_error(mddev, rdev);
+                        }
+                        d = start;
+                        while (d != r1_bio->read_disk) {
+                                if (d == 0)
+                                        d = conf->raid_disks;
+                                d--;
+                                if (r1_bio->bios[d]->bi_end_io != end_sync_read)
+                                        continue;
+                                rdev = conf->mirrors[d].rdev;
+                                if (sync_page_io(rdev,
+                                                 sect,
+                                                 s<<9,
+                                                 bio->bi_io_vec[idx].bv_page,
+                                                 READ, false) == 0)
+                                        md_error(mddev, rdev);
+                        }
+                } else {
+                        char b[BDEVNAME_SIZE];
+                        /* Cannot read from anywhere, array is toast */
+                        md_error(mddev, conf->mirrors[r1_bio->read_disk].rdev);
+                        printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O read error"
+                               " for block %llu\n",
+                               mdname(mddev),
+                               bdevname(bio->bi_bdev, b),
+                               (unsigned long long)r1_bio->sector);
+                        md_done_sync(mddev, r1_bio->sectors, 0);
                        put_buf(r1_bio);
-                        return;
+                        return 0;
                }
-                for (primary=0; primary<mddev->raid_disks; primary++)
+                sectors -= s;
-                        if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
+                sect += s;
-                            test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
+                idx ++;
-                                r1_bio->bios[primary]->bi_end_io = NULL;
+        }
-                                rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
+        return 1;
-                                break;
+}
-                        }
-                r1_bio->read_disk = primary;
+static int process_checks(r1bio_t *r1_bio)
+{
+        /* We have read all readable devices.  If we haven't
+         * got the block, then there is no hope left.
+         * If we have, then we want to do a comparison
+         * and skip the write if everything is the same.
+         * If any blocks failed to read, then we need to
+         * attempt an over-write
+         */
+        mddev_t *mddev = r1_bio->mddev;
+        conf_t *conf = mddev->private;
+        int primary;
+        int i;
+        if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
                for (i=0; i<mddev->raid_disks; i++)
-                        if (r1_bio->bios[i]->bi_end_io == end_sync_read) {
+                        if (r1_bio->bios[i]->bi_end_io == end_sync_read)
-                                int j;
+                                md_error(mddev, conf->mirrors[i].rdev);
-                                int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
-                                struct bio *pbio = r1_bio->bios[primary];
-                                struct bio *sbio = r1_bio->bios[i];
-                                if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
-                                        for (j = vcnt; j-- ; ) {
-                                                struct page *p, *s;
-                                                p = pbio->bi_io_vec[j].bv_page;
-                                                s = sbio->bi_io_vec[j].bv_page;
-                                                if (memcmp(page_address(p),
-                                                           page_address(s),
-                                                           PAGE_SIZE))
-                                                        break;
-                                        }
-                                } else
-                                        j = 0;
-                                if (j >= 0)
-                                        mddev->resync_mismatches += r1_bio->sectors;
-                                if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
-                                              && test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
-                                        sbio->bi_end_io = NULL;
-                                        rdev_dec_pending(conf->mirrors[i].rdev, mddev);
-                                } else {
-                                        /* fixup the bio for reuse */
-                                        int size;
-                                        sbio->bi_vcnt = vcnt;
-                                        sbio->bi_size = r1_bio->sectors << 9;
-                                        sbio->bi_idx = 0;
-                                        sbio->bi_phys_segments = 0;
-                                        sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                                        sbio->bi_flags |= 1 << BIO_UPTODATE;
-                                        sbio->bi_next = NULL;
-                                        sbio->bi_sector = r1_bio->sector +
-                                                conf->mirrors[i].rdev->data_offset;
-                                        sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
-                                        size = sbio->bi_size;
-                                        for (j = 0; j < vcnt ; j++) {
-                                                struct bio_vec *bi;
-                                                bi = &sbio->bi_io_vec[j];
-                                                bi->bv_offset = 0;
-                                                if (size > PAGE_SIZE)
-                                                        bi->bv_len = PAGE_SIZE;
-                                                else
-                                                        bi->bv_len = size;
-                                                size -= PAGE_SIZE;
-                                                memcpy(page_address(bi->bv_page),
-                                                       page_address(pbio->bi_io_vec[j].bv_page),
-                                                       PAGE_SIZE);
-                                        }
-                                }
+                md_done_sync(mddev, r1_bio->sectors, 1);
-                        }
+                put_buf(r1_bio);
+                return -1;
        }
-        if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
+        for (primary=0; primary<mddev->raid_disks; primary++)
-                /* ouch - failed to read all of that.
+                if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
-                 * Try some synchronous reads of other devices to get
+                    test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
-                 * good data, much like with normal read errors.  Only
+                        r1_bio->bios[primary]->bi_end_io = NULL;
-                 * read into the pages we already have so we don't
+                        rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
-                 * need to re-issue the read request.
+                        break;
-                 * We don't need to freeze the array, because being in an
+                }
-                 * active sync request, there is no normal IO, and
+        r1_bio->read_disk = primary;
-                 * no overlapping syncs.
+        for (i=0; i<mddev->raid_disks; i++)
-                 */
+                if (r1_bio->bios[i]->bi_end_io == end_sync_read) {
-                sector_t sect = r1_bio->sector;
+                        int j;
-                int sectors = r1_bio->sectors;
+                        int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
-                int idx = 0;
+                        struct bio *pbio = r1_bio->bios[primary];
+                        struct bio *sbio = r1_bio->bios[i];
-                while(sectors) {
-                        int s = sectors;
+                        if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
-                        int d = r1_bio->read_disk;
+                                for (j = vcnt; j-- ; ) {
-                        int success = 0;
+                                        struct page *p, *s;
-                        mdk_rdev_t *rdev;
+                                        p = pbio->bi_io_vec[j].bv_page;
+                                        s = sbio->bi_io_vec[j].bv_page;
-                        if (s > (PAGE_SIZE>>9))
+                                        if (memcmp(page_address(p),
-                                s = PAGE_SIZE >> 9;
+                                                   page_address(s),
-                        do {
+                                                   PAGE_SIZE))
-                                if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
-                                        /* No rcu protection needed here devices
-                                         * can only be removed when no resync is
-                                         * active, and resync is currently active
-                                         */
-                                        rdev = conf->mirrors[d].rdev;
-                                        if (sync_page_io(rdev,
-                                                         sect,
-                                                         s<<9,
-                                                         bio->bi_io_vec[idx].bv_page,
-                                                         READ, false)) {
-                                                success = 1;
                                                break;
-                                        }
-                                }
-                                d++;
-                                if (d == conf->raid_disks)
-                                        d = 0;
-                        } while (!success && d != r1_bio->read_disk);
-                        if (success) {
-                                int start = d;
-                                /* write it back and re-read */
-                                set_bit(R1BIO_Uptodate, &r1_bio->state);
-                                while (d != r1_bio->read_disk) {
-                                        if (d == 0)
-                                                d = conf->raid_disks;
-                                        d--;
-                                        if (r1_bio->bios[d]->bi_end_io != end_sync_read)
-                                                continue;
-                                        rdev = conf->mirrors[d].rdev;
-                                        atomic_add(s, &rdev->corrected_errors);
-                                        if (sync_page_io(rdev,
-                                                         sect,
-                                                         s<<9,
-                                                         bio->bi_io_vec[idx].bv_page,
-                                                         WRITE, false) == 0)
-                                                md_error(mddev, rdev);
-                                }
-                                d = start;
-                                while (d != r1_bio->read_disk) {
-                                        if (d == 0)
-                                                d = conf->raid_disks;
-                                        d--;
-                                        if (r1_bio->bios[d]->bi_end_io != end_sync_read)
-                                                continue;
-                                        rdev = conf->mirrors[d].rdev;
-                                        if (sync_page_io(rdev,
-                                                         sect,
-                                                         s<<9,
-                                                         bio->bi_io_vec[idx].bv_page,
-                                                         READ, false) == 0)
-                                                md_error(mddev, rdev);
                                }
+                        } else
+                                j = 0;
+                        if (j >= 0)
+                                mddev->resync_mismatches += r1_bio->sectors;
+                        if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
+                                      && test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
+                                sbio->bi_end_io = NULL;
+                                rdev_dec_pending(conf->mirrors[i].rdev, mddev);
                        } else {
-                                char b[BDEVNAME_SIZE];
+                                /* fixup the bio for reuse */
-                                /* Cannot read from anywhere, array is toast */
+                                int size;
-                                md_error(mddev, conf->mirrors[r1_bio->read_disk].rdev);
+                                sbio->bi_vcnt = vcnt;
-                                printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O read error"
+                                sbio->bi_size = r1_bio->sectors << 9;
-                                       " for block %llu\n",
+                                sbio->bi_idx = 0;
-                                       mdname(mddev),
+                                sbio->bi_phys_segments = 0;
-                                       bdevname(bio->bi_bdev, b),
+                                sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
-                                       (unsigned long long)r1_bio->sector);
+                                sbio->bi_flags |= 1 << BIO_UPTODATE;
-                                md_done_sync(mddev, r1_bio->sectors, 0);
+                                sbio->bi_next = NULL;
-                                put_buf(r1_bio);
+                                sbio->bi_sector = r1_bio->sector +
-                                return;
+                                        conf->mirrors[i].rdev->data_offset;
+                                sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
+                                size = sbio->bi_size;
+                                for (j = 0; j < vcnt ; j++) {
+                                        struct bio_vec *bi;
+                                        bi = &sbio->bi_io_vec[j];
+                                        bi->bv_offset = 0;
+                                        if (size > PAGE_SIZE)
+                                                bi->bv_len = PAGE_SIZE;
+                                        else
+                                                bi->bv_len = size;
+                                        size -= PAGE_SIZE;
+                                        memcpy(page_address(bi->bv_page),
+                                               page_address(pbio->bi_io_vec[j].bv_page),
+                                               PAGE_SIZE);
+                                }
                        }
-                        sectors -= s;
-                        sect += s;
-                        idx ++;
                }
-        }
+        return 0;
+}
+static void sync_request_write(mddev_t *mddev, r1bio_t *r1_bio)
+{
+        conf_t *conf = mddev->private;
+        int i;
+        int disks = conf->raid_disks;
+        struct bio *bio, *wbio;
+        bio = r1_bio->bios[r1_bio->read_disk];
+        if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
+                if (process_checks(r1_bio) < 0)
+                        return;
+        if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
+                /* ouch - failed to read all of that. */
+                if (!fix_sync_read_error(r1_bio))
+                        return;
        /*
         * schedule writes
         */
author	NeilBrown <neilb@suse.de>	2011-05-11 00:40:44 -0400
committer	NeilBrown <neilb@suse.de>	2011-05-11 00:40:44 -0400
commit	a68e58703575b9c03d610a818e0241564fc17f68 (patch)
tree	f60a433b20a4e297d010a23775e78493687c160b
parent	6f8d0c77cef5849433dd7beb0bd97e573cc4a6a3 (diff)

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c index f0b0c79b3899..7fd7a4d6f5c7 100644 --- a/drivers/md/raid1.c +++ b/drivers/md/raid1.c
@@ -1181,194 +1181,213 @@ static void end_sync_write(struct bio *bio, int error)
1181	}	1181	}
1182	}	1182	}
1183		1183
1184	static void sync_request_write(mddev_t mddev, r1bio_t r1_bio)	1184	static int fix_sync_read_error(r1bio_t *r1_bio)
1185	{	1185	{
		1186	/* Try some synchronous reads of other devices to get
		1187	* good data, much like with normal read errors. Only
		1188	* read into the pages we already have so we don't
		1189	* need to re-issue the read request.
		1190	* We don't need to freeze the array, because being in an
		1191	* active sync request, there is no normal IO, and
		1192	* no overlapping syncs.
		1193	*/
		1194	mddev_t *mddev = r1_bio->mddev;
1186	conf_t *conf = mddev->private;	1195	conf_t *conf = mddev->private;
1187	int i;	1196	struct bio *bio = r1_bio->bios[r1_bio->read_disk];
1188	int disks = conf->raid_disks;	1197	sector_t sect = r1_bio->sector;
1189	struct bio bio, wbio;	1198	int sectors = r1_bio->sectors;
		1199	int idx = 0;
1190		1200
1191	bio = r1_bio->bios[r1_bio->read_disk];	1201	while(sectors) {
1192		1202	int s = sectors;
1193		1203	int d = r1_bio->read_disk;
1194	if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {	1204	int success = 0;
1195	/* We have read all readable devices. If we haven't	1205	mdk_rdev_t *rdev;
1196	* got the block, then there is no hope left.
1197	* If we have, then we want to do a comparison
1198	* and skip the write if everything is the same.
1199	* If any blocks failed to read, then we need to
1200	* attempt an over-write
1201	*/
1202	int primary;
1203	if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
1204	for (i=0; i<mddev->raid_disks; i++)
1205	if (r1_bio->bios[i]->bi_end_io == end_sync_read)
1206	md_error(mddev, conf->mirrors[i].rdev);
1207		1206
1208	md_done_sync(mddev, r1_bio->sectors, 1);	1207	if (s > (PAGE_SIZE>>9))
		1208	s = PAGE_SIZE >> 9;
		1209	do {
		1210	if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
		1211	/* No rcu protection needed here devices
		1212	* can only be removed when no resync is
		1213	* active, and resync is currently active
		1214	*/
		1215	rdev = conf->mirrors[d].rdev;
		1216	if (sync_page_io(rdev,
		1217	sect,
		1218	s<<9,
		1219	bio->bi_io_vec[idx].bv_page,
		1220	READ, false)) {
		1221	success = 1;
		1222	break;
		1223	}
		1224	}
		1225	d++;
		1226	if (d == conf->raid_disks)
		1227	d = 0;
		1228	} while (!success && d != r1_bio->read_disk);
		1229
		1230	if (success) {
		1231	int start = d;
		1232	/* write it back and re-read */
		1233	set_bit(R1BIO_Uptodate, &r1_bio->state);
		1234	while (d != r1_bio->read_disk) {
		1235	if (d == 0)
		1236	d = conf->raid_disks;
		1237	d--;
		1238	if (r1_bio->bios[d]->bi_end_io != end_sync_read)
		1239	continue;
		1240	rdev = conf->mirrors[d].rdev;
		1241	atomic_add(s, &rdev->corrected_errors);
		1242	if (sync_page_io(rdev,
		1243	sect,
		1244	s<<9,
		1245	bio->bi_io_vec[idx].bv_page,
		1246	WRITE, false) == 0)
		1247	md_error(mddev, rdev);
		1248	}
		1249	d = start;
		1250	while (d != r1_bio->read_disk) {
		1251	if (d == 0)
		1252	d = conf->raid_disks;
		1253	d--;
		1254	if (r1_bio->bios[d]->bi_end_io != end_sync_read)
		1255	continue;
		1256	rdev = conf->mirrors[d].rdev;
		1257	if (sync_page_io(rdev,
		1258	sect,
		1259	s<<9,
		1260	bio->bi_io_vec[idx].bv_page,
		1261	READ, false) == 0)
		1262	md_error(mddev, rdev);
		1263	}
		1264	} else {
		1265	char b[BDEVNAME_SIZE];
		1266	/* Cannot read from anywhere, array is toast */
		1267	md_error(mddev, conf->mirrors[r1_bio->read_disk].rdev);
		1268	printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O read error"
		1269	" for block %llu\n",
		1270	mdname(mddev),
		1271	bdevname(bio->bi_bdev, b),
		1272	(unsigned long long)r1_bio->sector);
		1273	md_done_sync(mddev, r1_bio->sectors, 0);
1209	put_buf(r1_bio);	1274	put_buf(r1_bio);
1210	return;	1275	return 0;
1211	}	1276	}
1212	for (primary=0; primary<mddev->raid_disks; primary++)	1277	sectors -= s;
1213	if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&	1278	sect += s;
1214	test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {	1279	idx ++;
1215	r1_bio->bios[primary]->bi_end_io = NULL;	1280	}
1216	rdev_dec_pending(conf->mirrors[primary].rdev, mddev);	1281	return 1;
1217	break;	1282	}
1218	}	1283
1219	r1_bio->read_disk = primary;	1284	static int process_checks(r1bio_t *r1_bio)
		1285	{
		1286	/* We have read all readable devices. If we haven't
		1287	* got the block, then there is no hope left.
		1288	* If we have, then we want to do a comparison
		1289	* and skip the write if everything is the same.
		1290	* If any blocks failed to read, then we need to
		1291	* attempt an over-write
		1292	*/
		1293	mddev_t *mddev = r1_bio->mddev;
		1294	conf_t *conf = mddev->private;
		1295	int primary;
		1296	int i;
		1297
		1298	if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {
1220	for (i=0; i<mddev->raid_disks; i++)	1299	for (i=0; i<mddev->raid_disks; i++)
1221	if (r1_bio->bios[i]->bi_end_io == end_sync_read) {	1300	if (r1_bio->bios[i]->bi_end_io == end_sync_read)
1222	int j;	1301	md_error(mddev, conf->mirrors[i].rdev);
1223	int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
1224	struct bio *pbio = r1_bio->bios[primary];
1225	struct bio *sbio = r1_bio->bios[i];
1226
1227	if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
1228	for (j = vcnt; j-- ; ) {
1229	struct page p, s;
1230	p = pbio->bi_io_vec[j].bv_page;
1231	s = sbio->bi_io_vec[j].bv_page;
1232	if (memcmp(page_address(p),
1233	page_address(s),
1234	PAGE_SIZE))
1235	break;
1236	}
1237	} else
1238	j = 0;
1239	if (j >= 0)
1240	mddev->resync_mismatches += r1_bio->sectors;
1241	if (j < 0 \|\| (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
1242	&& test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
1243	sbio->bi_end_io = NULL;
1244	rdev_dec_pending(conf->mirrors[i].rdev, mddev);
1245	} else {
1246	/* fixup the bio for reuse */
1247	int size;
1248	sbio->bi_vcnt = vcnt;
1249	sbio->bi_size = r1_bio->sectors << 9;
1250	sbio->bi_idx = 0;
1251	sbio->bi_phys_segments = 0;
1252	sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
1253	sbio->bi_flags \|= 1 << BIO_UPTODATE;
1254	sbio->bi_next = NULL;
1255	sbio->bi_sector = r1_bio->sector +
1256	conf->mirrors[i].rdev->data_offset;
1257	sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
1258	size = sbio->bi_size;
1259	for (j = 0; j < vcnt ; j++) {
1260	struct bio_vec *bi;
1261	bi = &sbio->bi_io_vec[j];
1262	bi->bv_offset = 0;
1263	if (size > PAGE_SIZE)
1264	bi->bv_len = PAGE_SIZE;
1265	else
1266	bi->bv_len = size;
1267	size -= PAGE_SIZE;
1268	memcpy(page_address(bi->bv_page),
1269	page_address(pbio->bi_io_vec[j].bv_page),
1270	PAGE_SIZE);
1271	}
1272		1302
1273	}	1303	md_done_sync(mddev, r1_bio->sectors, 1);
1274	}	1304	put_buf(r1_bio);
		1305	return -1;
1275	}	1306	}
1276	if (!test_bit(R1BIO_Uptodate, &r1_bio->state)) {	1307	for (primary=0; primary<mddev->raid_disks; primary++)
1277	/* ouch - failed to read all of that.	1308	if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
1278	* Try some synchronous reads of other devices to get	1309	test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
1279	* good data, much like with normal read errors. Only	1310	r1_bio->bios[primary]->bi_end_io = NULL;
1280	* read into the pages we already have so we don't	1311	rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
1281	* need to re-issue the read request.	1312	break;
1282	* We don't need to freeze the array, because being in an	1313	}
1283	* active sync request, there is no normal IO, and	1314	r1_bio->read_disk = primary;
1284	* no overlapping syncs.	1315	for (i=0; i<mddev->raid_disks; i++)
1285	*/	1316	if (r1_bio->bios[i]->bi_end_io == end_sync_read) {
1286	sector_t sect = r1_bio->sector;	1317	int j;
1287	int sectors = r1_bio->sectors;	1318	int vcnt = r1_bio->sectors >> (PAGE_SHIFT- 9);
1288	int idx = 0;	1319	struct bio *pbio = r1_bio->bios[primary];
1289		1320	struct bio *sbio = r1_bio->bios[i];
1290	while(sectors) {	1321
1291	int s = sectors;	1322	if (test_bit(BIO_UPTODATE, &sbio->bi_flags)) {
1292	int d = r1_bio->read_disk;	1323	for (j = vcnt; j-- ; ) {
1293	int success = 0;	1324	struct page p, s;
1294	mdk_rdev_t *rdev;	1325	p = pbio->bi_io_vec[j].bv_page;
1295		1326	s = sbio->bi_io_vec[j].bv_page;
1296	if (s > (PAGE_SIZE>>9))	1327	if (memcmp(page_address(p),
1297	s = PAGE_SIZE >> 9;	1328	page_address(s),
1298	do {	1329	PAGE_SIZE))
1299	if (r1_bio->bios[d]->bi_end_io == end_sync_read) {
1300	/* No rcu protection needed here devices
1301	* can only be removed when no resync is
1302	* active, and resync is currently active
1303	*/
1304	rdev = conf->mirrors[d].rdev;
1305	if (sync_page_io(rdev,
1306	sect,
1307	s<<9,
1308	bio->bi_io_vec[idx].bv_page,
1309	READ, false)) {
1310	success = 1;
1311	break;	1330	break;
1312	}
1313	}
1314	d++;
1315	if (d == conf->raid_disks)
1316	d = 0;
1317	} while (!success && d != r1_bio->read_disk);
1318
1319	if (success) {
1320	int start = d;
1321	/* write it back and re-read */
1322	set_bit(R1BIO_Uptodate, &r1_bio->state);
1323	while (d != r1_bio->read_disk) {
1324	if (d == 0)
1325	d = conf->raid_disks;
1326	d--;
1327	if (r1_bio->bios[d]->bi_end_io != end_sync_read)
1328	continue;
1329	rdev = conf->mirrors[d].rdev;
1330	atomic_add(s, &rdev->corrected_errors);
1331	if (sync_page_io(rdev,
1332	sect,
1333	s<<9,
1334	bio->bi_io_vec[idx].bv_page,
1335	WRITE, false) == 0)
1336	md_error(mddev, rdev);
1337	}
1338	d = start;
1339	while (d != r1_bio->read_disk) {
1340	if (d == 0)
1341	d = conf->raid_disks;
1342	d--;
1343	if (r1_bio->bios[d]->bi_end_io != end_sync_read)
1344	continue;
1345	rdev = conf->mirrors[d].rdev;
1346	if (sync_page_io(rdev,
1347	sect,
1348	s<<9,
1349	bio->bi_io_vec[idx].bv_page,
1350	READ, false) == 0)
1351	md_error(mddev, rdev);
1352	}	1331	}
		1332	} else
		1333	j = 0;
		1334	if (j >= 0)
		1335	mddev->resync_mismatches += r1_bio->sectors;
		1336	if (j < 0 \|\| (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
		1337	&& test_bit(BIO_UPTODATE, &sbio->bi_flags))) {
		1338	sbio->bi_end_io = NULL;
		1339	rdev_dec_pending(conf->mirrors[i].rdev, mddev);
1353	} else {	1340	} else {
1354	char b[BDEVNAME_SIZE];	1341	/* fixup the bio for reuse */
1355	/* Cannot read from anywhere, array is toast */	1342	int size;
1356	md_error(mddev, conf->mirrors[r1_bio->read_disk].rdev);	1343	sbio->bi_vcnt = vcnt;
1357	printk(KERN_ALERT "md/raid1:%s: %s: unrecoverable I/O read error"	1344	sbio->bi_size = r1_bio->sectors << 9;
1358	" for block %llu\n",	1345	sbio->bi_idx = 0;
1359	mdname(mddev),	1346	sbio->bi_phys_segments = 0;
1360	bdevname(bio->bi_bdev, b),	1347	sbio->bi_flags &= ~(BIO_POOL_MASK - 1);
1361	(unsigned long long)r1_bio->sector);	1348	sbio->bi_flags \|= 1 << BIO_UPTODATE;
1362	md_done_sync(mddev, r1_bio->sectors, 0);	1349	sbio->bi_next = NULL;
1363	put_buf(r1_bio);	1350	sbio->bi_sector = r1_bio->sector +
1364	return;	1351	conf->mirrors[i].rdev->data_offset;
		1352	sbio->bi_bdev = conf->mirrors[i].rdev->bdev;
		1353	size = sbio->bi_size;
		1354	for (j = 0; j < vcnt ; j++) {
		1355	struct bio_vec *bi;
		1356	bi = &sbio->bi_io_vec[j];
		1357	bi->bv_offset = 0;
		1358	if (size > PAGE_SIZE)
		1359	bi->bv_len = PAGE_SIZE;
		1360	else
		1361	bi->bv_len = size;
		1362	size -= PAGE_SIZE;
		1363	memcpy(page_address(bi->bv_page),
		1364	page_address(pbio->bi_io_vec[j].bv_page),
		1365	PAGE_SIZE);
		1366	}
		1367
1365	}	1368	}
1366	sectors -= s;
1367	sect += s;
1368	idx ++;
1369	}	1369	}
1370	}	1370	return 0;
		1371	}
		1372
		1373	static void sync_request_write(mddev_t mddev, r1bio_t r1_bio)
		1374	{
		1375	conf_t *conf = mddev->private;
		1376	int i;
		1377	int disks = conf->raid_disks;
		1378	struct bio bio, wbio;
		1379
		1380	bio = r1_bio->bios[r1_bio->read_disk];
		1381
1371		1382
		1383	if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery))
		1384	if (process_checks(r1_bio) < 0)
		1385	return;
		1386
		1387	if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
		1388	/* ouch - failed to read all of that. */
		1389	if (!fix_sync_read_error(r1_bio))
		1390	return;
1372	/*	1391	/*
1373	* schedule writes	1392	* schedule writes
1374	*/	1393	*/