raid10.c (8e8c668927b029f6ccc350eb1aa936864cc4eb6f) raid10.c (288dab8a35a0bde426a09870943c8d3ee3a50dab)
1/*
2 * raid10.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 2000-2004 Neil Brown
5 *
6 * RAID-10 support for md.
7 *
8 * Base on code in raid1.c. See raid1.c for further copyright information.

--- 851 unchanged lines hidden (view full) ---

860 /* flush any pending bitmap writes to disk
861 * before proceeding w/ I/O */
862 bitmap_unplug(conf->mddev->bitmap);
863 wake_up(&conf->wait_barrier);
864
865 while (bio) { /* submit pending writes */
866 struct bio *next = bio->bi_next;
867 bio->bi_next = NULL;
1/*
2 * raid10.c : Multiple Devices driver for Linux
3 *
4 * Copyright (C) 2000-2004 Neil Brown
5 *
6 * RAID-10 support for md.
7 *
8 * Base on code in raid1.c. See raid1.c for further copyright information.

--- 851 unchanged lines hidden (view full) ---

860 /* flush any pending bitmap writes to disk
861 * before proceeding w/ I/O */
862 bitmap_unplug(conf->mddev->bitmap);
863 wake_up(&conf->wait_barrier);
864
865 while (bio) { /* submit pending writes */
866 struct bio *next = bio->bi_next;
867 bio->bi_next = NULL;
868 if (unlikely((bio->bi_rw & REQ_DISCARD) &&
868 if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
869 !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
870 /* Just ignore it */
871 bio_endio(bio);
872 else
873 generic_make_request(bio);
874 bio = next;
875 }
876 } else

--- 159 unchanged lines hidden (view full) ---

1036 /* we aren't scheduling, so we can do the write-out directly. */
1037 bio = bio_list_get(&plug->pending);
1038 bitmap_unplug(mddev->bitmap);
1039 wake_up(&conf->wait_barrier);
1040
1041 while (bio) { /* submit pending writes */
1042 struct bio *next = bio->bi_next;
1043 bio->bi_next = NULL;
869 !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
870 /* Just ignore it */
871 bio_endio(bio);
872 else
873 generic_make_request(bio);
874 bio = next;
875 }
876 } else

--- 159 unchanged lines hidden (view full) ---

1036 /* we aren't scheduling, so we can do the write-out directly. */
1037 bio = bio_list_get(&plug->pending);
1038 bitmap_unplug(mddev->bitmap);
1039 wake_up(&conf->wait_barrier);
1040
1041 while (bio) { /* submit pending writes */
1042 struct bio *next = bio->bi_next;
1043 bio->bi_next = NULL;
1044 if (unlikely((bio->bi_rw & REQ_DISCARD) &&
1044 if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
1045 !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
1046 /* Just ignore it */
1047 bio_endio(bio);
1048 else
1049 generic_make_request(bio);
1050 bio = next;
1051 }
1052 kfree(plug);
1053}
1054
1055static void __make_request(struct mddev *mddev, struct bio *bio)
1056{
1057 struct r10conf *conf = mddev->private;
1058 struct r10bio *r10_bio;
1059 struct bio *read_bio;
1060 int i;
1045 !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
1046 /* Just ignore it */
1047 bio_endio(bio);
1048 else
1049 generic_make_request(bio);
1050 bio = next;
1051 }
1052 kfree(plug);
1053}
1054
1055static void __make_request(struct mddev *mddev, struct bio *bio)
1056{
1057 struct r10conf *conf = mddev->private;
1058 struct r10bio *r10_bio;
1059 struct bio *read_bio;
1060 int i;
1061 const int op = bio_op(bio);
1061 const int rw = bio_data_dir(bio);
1062 const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
1063 const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
1062 const int rw = bio_data_dir(bio);
1063 const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
1064 const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
1064 const unsigned long do_discard = (bio->bi_rw
1065 & (REQ_DISCARD | REQ_SECURE));
1066 const unsigned long do_same = (bio->bi_rw & REQ_WRITE_SAME);
1067 unsigned long flags;
1068 struct md_rdev *blocked_rdev;
1069 struct blk_plug_cb *cb;
1070 struct raid10_plug_cb *plug = NULL;
1071 int sectors_handled;
1072 int max_sectors;
1073 int sectors;
1074

--- 76 unchanged lines hidden (view full) ---

1151
1152 r10_bio->devs[slot].bio = read_bio;
1153 r10_bio->devs[slot].rdev = rdev;
1154
1155 read_bio->bi_iter.bi_sector = r10_bio->devs[slot].addr +
1156 choose_data_offset(r10_bio, rdev);
1157 read_bio->bi_bdev = rdev->bdev;
1158 read_bio->bi_end_io = raid10_end_read_request;
1065 unsigned long flags;
1066 struct md_rdev *blocked_rdev;
1067 struct blk_plug_cb *cb;
1068 struct raid10_plug_cb *plug = NULL;
1069 int sectors_handled;
1070 int max_sectors;
1071 int sectors;
1072

--- 76 unchanged lines hidden (view full) ---

1149
1150 r10_bio->devs[slot].bio = read_bio;
1151 r10_bio->devs[slot].rdev = rdev;
1152
1153 read_bio->bi_iter.bi_sector = r10_bio->devs[slot].addr +
1154 choose_data_offset(r10_bio, rdev);
1155 read_bio->bi_bdev = rdev->bdev;
1156 read_bio->bi_end_io = raid10_end_read_request;
1159 read_bio->bi_rw = READ | do_sync;
1157 bio_set_op_attrs(read_bio, op, do_sync);
1160 read_bio->bi_private = r10_bio;
1161
1162 if (max_sectors < r10_bio->sectors) {
1163 /* Could not read all from this device, so we will
1164 * need another r10_bio.
1165 */
1166 sectors_handled = (r10_bio->sector + max_sectors
1167 - bio->bi_iter.bi_sector);

--- 190 unchanged lines hidden (view full) ---

1358 max_sectors);
1359 r10_bio->devs[i].bio = mbio;
1360
1361 mbio->bi_iter.bi_sector = (r10_bio->devs[i].addr+
1362 choose_data_offset(r10_bio,
1363 rdev));
1364 mbio->bi_bdev = rdev->bdev;
1365 mbio->bi_end_io = raid10_end_write_request;
1158 read_bio->bi_private = r10_bio;
1159
1160 if (max_sectors < r10_bio->sectors) {
1161 /* Could not read all from this device, so we will
1162 * need another r10_bio.
1163 */
1164 sectors_handled = (r10_bio->sector + max_sectors
1165 - bio->bi_iter.bi_sector);

--- 190 unchanged lines hidden (view full) ---

1356 max_sectors);
1357 r10_bio->devs[i].bio = mbio;
1358
1359 mbio->bi_iter.bi_sector = (r10_bio->devs[i].addr+
1360 choose_data_offset(r10_bio,
1361 rdev));
1362 mbio->bi_bdev = rdev->bdev;
1363 mbio->bi_end_io = raid10_end_write_request;
1366 mbio->bi_rw =
1367 WRITE | do_sync | do_fua | do_discard | do_same;
1364 bio_set_op_attrs(mbio, op, do_sync | do_fua);
1368 mbio->bi_private = r10_bio;
1369
1370 atomic_inc(&r10_bio->remaining);
1371
1372 cb = blk_check_plugged(raid10_unplug, mddev,
1373 sizeof(*plug));
1374 if (cb)
1375 plug = container_of(cb, struct raid10_plug_cb,

--- 25 unchanged lines hidden (view full) ---

1401 max_sectors);
1402 r10_bio->devs[i].repl_bio = mbio;
1403
1404 mbio->bi_iter.bi_sector = (r10_bio->devs[i].addr +
1405 choose_data_offset(
1406 r10_bio, rdev));
1407 mbio->bi_bdev = rdev->bdev;
1408 mbio->bi_end_io = raid10_end_write_request;
1365 mbio->bi_private = r10_bio;
1366
1367 atomic_inc(&r10_bio->remaining);
1368
1369 cb = blk_check_plugged(raid10_unplug, mddev,
1370 sizeof(*plug));
1371 if (cb)
1372 plug = container_of(cb, struct raid10_plug_cb,

--- 25 unchanged lines hidden (view full) ---

1398 max_sectors);
1399 r10_bio->devs[i].repl_bio = mbio;
1400
1401 mbio->bi_iter.bi_sector = (r10_bio->devs[i].addr +
1402 choose_data_offset(
1403 r10_bio, rdev));
1404 mbio->bi_bdev = rdev->bdev;
1405 mbio->bi_end_io = raid10_end_write_request;
1409 mbio->bi_rw =
1410 WRITE | do_sync | do_fua | do_discard | do_same;
1406 bio_set_op_attrs(mbio, op, do_sync | do_fua);
1411 mbio->bi_private = r10_bio;
1412
1413 atomic_inc(&r10_bio->remaining);
1414 spin_lock_irqsave(&conf->device_lock, flags);
1415 bio_list_add(&conf->pending_bio_list, mbio);
1416 conf->pending_count++;
1417 spin_unlock_irqrestore(&conf->device_lock, flags);
1418 if (!mddev_check_plugged(mddev))

--- 26 unchanged lines hidden (view full) ---

1445static void raid10_make_request(struct mddev *mddev, struct bio *bio)
1446{
1447 struct r10conf *conf = mddev->private;
1448 sector_t chunk_mask = (conf->geo.chunk_mask & conf->prev.chunk_mask);
1449 int chunk_sects = chunk_mask + 1;
1450
1451 struct bio *split;
1452
1407 mbio->bi_private = r10_bio;
1408
1409 atomic_inc(&r10_bio->remaining);
1410 spin_lock_irqsave(&conf->device_lock, flags);
1411 bio_list_add(&conf->pending_bio_list, mbio);
1412 conf->pending_count++;
1413 spin_unlock_irqrestore(&conf->device_lock, flags);
1414 if (!mddev_check_plugged(mddev))

--- 26 unchanged lines hidden (view full) ---

1441static void raid10_make_request(struct mddev *mddev, struct bio *bio)
1442{
1443 struct r10conf *conf = mddev->private;
1444 sector_t chunk_mask = (conf->geo.chunk_mask & conf->prev.chunk_mask);
1445 int chunk_sects = chunk_mask + 1;
1446
1447 struct bio *split;
1448
1453 if (unlikely(bio->bi_rw & REQ_FLUSH)) {
1449 if (unlikely(bio->bi_rw & REQ_PREFLUSH)) {
1454 md_flush_request(mddev, bio);
1455 return;
1456 }
1457
1458 md_write_start(mddev, bio);
1459
1460 do {
1461

--- 525 unchanged lines hidden (view full) ---

1987 * inconsistency or to correct an unreadable block.
1988 * First we need to fixup bv_offset, bv_len and
1989 * bi_vecs, as the read request might have corrupted these
1990 */
1991 bio_reset(tbio);
1992
1993 tbio->bi_vcnt = vcnt;
1994 tbio->bi_iter.bi_size = fbio->bi_iter.bi_size;
1450 md_flush_request(mddev, bio);
1451 return;
1452 }
1453
1454 md_write_start(mddev, bio);
1455
1456 do {
1457

--- 525 unchanged lines hidden (view full) ---

1983 * inconsistency or to correct an unreadable block.
1984 * First we need to fixup bv_offset, bv_len and
1985 * bi_vecs, as the read request might have corrupted these
1986 */
1987 bio_reset(tbio);
1988
1989 tbio->bi_vcnt = vcnt;
1990 tbio->bi_iter.bi_size = fbio->bi_iter.bi_size;
1995 tbio->bi_rw = WRITE;
1996 tbio->bi_private = r10_bio;
1997 tbio->bi_iter.bi_sector = r10_bio->devs[i].addr;
1998 tbio->bi_end_io = end_sync_write;
1991 tbio->bi_private = r10_bio;
1992 tbio->bi_iter.bi_sector = r10_bio->devs[i].addr;
1993 tbio->bi_end_io = end_sync_write;
1994 bio_set_op_attrs(tbio, REQ_OP_WRITE, 0);
1999
2000 bio_copy_data(tbio, fbio);
2001
2002 d = r10_bio->devs[i].devnum;
2003 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
2004 atomic_inc(&r10_bio->remaining);
2005 md_sync_acct(conf->mirrors[d].rdev->bdev, bio_sectors(tbio));
2006

--- 66 unchanged lines hidden (view full) ---

2073 s = PAGE_SIZE >> 9;
2074
2075 rdev = conf->mirrors[dr].rdev;
2076 addr = r10_bio->devs[0].addr + sect,
2077 ok = sync_page_io(rdev,
2078 addr,
2079 s << 9,
2080 bio->bi_io_vec[idx].bv_page,
1995
1996 bio_copy_data(tbio, fbio);
1997
1998 d = r10_bio->devs[i].devnum;
1999 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
2000 atomic_inc(&r10_bio->remaining);
2001 md_sync_acct(conf->mirrors[d].rdev->bdev, bio_sectors(tbio));
2002

--- 66 unchanged lines hidden (view full) ---

2069 s = PAGE_SIZE >> 9;
2070
2071 rdev = conf->mirrors[dr].rdev;
2072 addr = r10_bio->devs[0].addr + sect,
2073 ok = sync_page_io(rdev,
2074 addr,
2075 s << 9,
2076 bio->bi_io_vec[idx].bv_page,
2081 READ, false);
2077 REQ_OP_READ, 0, false);
2082 if (ok) {
2083 rdev = conf->mirrors[dw].rdev;
2084 addr = r10_bio->devs[1].addr + sect;
2085 ok = sync_page_io(rdev,
2086 addr,
2087 s << 9,
2088 bio->bi_io_vec[idx].bv_page,
2078 if (ok) {
2079 rdev = conf->mirrors[dw].rdev;
2080 addr = r10_bio->devs[1].addr + sect;
2081 ok = sync_page_io(rdev,
2082 addr,
2083 s << 9,
2084 bio->bi_io_vec[idx].bv_page,
2089 WRITE, false);
2085 REQ_OP_WRITE, 0, false);
2090 if (!ok) {
2091 set_bit(WriteErrorSeen, &rdev->flags);
2092 if (!test_and_set_bit(WantReplacement,
2093 &rdev->flags))
2094 set_bit(MD_RECOVERY_NEEDED,
2095 &rdev->mddev->recovery);
2096 }
2097 }

--- 110 unchanged lines hidden (view full) ---

2208 int sectors, struct page *page, int rw)
2209{
2210 sector_t first_bad;
2211 int bad_sectors;
2212
2213 if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
2214 && (rw == READ || test_bit(WriteErrorSeen, &rdev->flags)))
2215 return -1;
2086 if (!ok) {
2087 set_bit(WriteErrorSeen, &rdev->flags);
2088 if (!test_and_set_bit(WantReplacement,
2089 &rdev->flags))
2090 set_bit(MD_RECOVERY_NEEDED,
2091 &rdev->mddev->recovery);
2092 }
2093 }

--- 110 unchanged lines hidden (view full) ---

2204 int sectors, struct page *page, int rw)
2205{
2206 sector_t first_bad;
2207 int bad_sectors;
2208
2209 if (is_badblock(rdev, sector, sectors, &first_bad, &bad_sectors)
2210 && (rw == READ || test_bit(WriteErrorSeen, &rdev->flags)))
2211 return -1;
2216 if (sync_page_io(rdev, sector, sectors << 9, page, rw, false))
2212 if (sync_page_io(rdev, sector, sectors << 9, page, rw, 0, false))
2217 /* success */
2218 return 1;
2219 if (rw == WRITE) {
2220 set_bit(WriteErrorSeen, &rdev->flags);
2221 if (!test_and_set_bit(WantReplacement, &rdev->flags))
2222 set_bit(MD_RECOVERY_NEEDED,
2223 &rdev->mddev->recovery);
2224 }

--- 69 unchanged lines hidden (view full) ---

2294 is_badblock(rdev, r10_bio->devs[sl].addr + sect, s,
2295 &first_bad, &bad_sectors) == 0) {
2296 atomic_inc(&rdev->nr_pending);
2297 rcu_read_unlock();
2298 success = sync_page_io(rdev,
2299 r10_bio->devs[sl].addr +
2300 sect,
2301 s<<9,
2213 /* success */
2214 return 1;
2215 if (rw == WRITE) {
2216 set_bit(WriteErrorSeen, &rdev->flags);
2217 if (!test_and_set_bit(WantReplacement, &rdev->flags))
2218 set_bit(MD_RECOVERY_NEEDED,
2219 &rdev->mddev->recovery);
2220 }

--- 69 unchanged lines hidden (view full) ---

2290 is_badblock(rdev, r10_bio->devs[sl].addr + sect, s,
2291 &first_bad, &bad_sectors) == 0) {
2292 atomic_inc(&rdev->nr_pending);
2293 rcu_read_unlock();
2294 success = sync_page_io(rdev,
2295 r10_bio->devs[sl].addr +
2296 sect,
2297 s<<9,
2302 conf->tmppage, READ, false);
2298 conf->tmppage,
2299 REQ_OP_READ, 0, false);
2303 rdev_dec_pending(rdev, mddev);
2304 rcu_read_lock();
2305 if (success)
2306 break;
2307 }
2308 sl++;
2309 if (sl == conf->copies)
2310 sl = 0;

--- 158 unchanged lines hidden (view full) ---

2469 sectors = sect_to_write;
2470 /* Write at 'sector' for 'sectors' */
2471 wbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
2472 bio_trim(wbio, sector - bio->bi_iter.bi_sector, sectors);
2473 wbio->bi_iter.bi_sector = (r10_bio->devs[i].addr+
2474 choose_data_offset(r10_bio, rdev) +
2475 (sector - r10_bio->sector));
2476 wbio->bi_bdev = rdev->bdev;
2300 rdev_dec_pending(rdev, mddev);
2301 rcu_read_lock();
2302 if (success)
2303 break;
2304 }
2305 sl++;
2306 if (sl == conf->copies)
2307 sl = 0;

--- 158 unchanged lines hidden (view full) ---

2466 sectors = sect_to_write;
2467 /* Write at 'sector' for 'sectors' */
2468 wbio = bio_clone_mddev(bio, GFP_NOIO, mddev);
2469 bio_trim(wbio, sector - bio->bi_iter.bi_sector, sectors);
2470 wbio->bi_iter.bi_sector = (r10_bio->devs[i].addr+
2471 choose_data_offset(r10_bio, rdev) +
2472 (sector - r10_bio->sector));
2473 wbio->bi_bdev = rdev->bdev;
2477 if (submit_bio_wait(WRITE, wbio) < 0)
2474 bio_set_op_attrs(wbio, REQ_OP_WRITE, 0);
2475
2476 if (submit_bio_wait(wbio) < 0)
2478 /* Failure! */
2479 ok = rdev_set_badblocks(rdev, sector,
2480 sectors, 0)
2481 && ok;
2482
2483 bio_put(wbio);
2484 sect_to_write -= sectors;
2485 sector += sectors;

--- 57 unchanged lines hidden (view full) ---

2543 bio = bio_clone_mddev(r10_bio->master_bio,
2544 GFP_NOIO, mddev);
2545 bio_trim(bio, r10_bio->sector - bio->bi_iter.bi_sector, max_sectors);
2546 r10_bio->devs[slot].bio = bio;
2547 r10_bio->devs[slot].rdev = rdev;
2548 bio->bi_iter.bi_sector = r10_bio->devs[slot].addr
2549 + choose_data_offset(r10_bio, rdev);
2550 bio->bi_bdev = rdev->bdev;
2477 /* Failure! */
2478 ok = rdev_set_badblocks(rdev, sector,
2479 sectors, 0)
2480 && ok;
2481
2482 bio_put(wbio);
2483 sect_to_write -= sectors;
2484 sector += sectors;

--- 57 unchanged lines hidden (view full) ---

2542 bio = bio_clone_mddev(r10_bio->master_bio,
2543 GFP_NOIO, mddev);
2544 bio_trim(bio, r10_bio->sector - bio->bi_iter.bi_sector, max_sectors);
2545 r10_bio->devs[slot].bio = bio;
2546 r10_bio->devs[slot].rdev = rdev;
2547 bio->bi_iter.bi_sector = r10_bio->devs[slot].addr
2548 + choose_data_offset(r10_bio, rdev);
2549 bio->bi_bdev = rdev->bdev;
2551 bio->bi_rw = READ | do_sync;
2550 bio_set_op_attrs(bio, REQ_OP_READ, do_sync);
2552 bio->bi_private = r10_bio;
2553 bio->bi_end_io = raid10_end_read_request;
2554 if (max_sectors < r10_bio->sectors) {
2555 /* Drat - have to split this up more */
2556 struct bio *mbio = r10_bio->master_bio;
2557 int sectors_handled =
2558 r10_bio->sector + max_sectors
2559 - mbio->bi_iter.bi_sector;

--- 473 unchanged lines hidden (view full) ---

3033 }
3034 }
3035 bio = r10_bio->devs[0].bio;
3036 bio_reset(bio);
3037 bio->bi_next = biolist;
3038 biolist = bio;
3039 bio->bi_private = r10_bio;
3040 bio->bi_end_io = end_sync_read;
2551 bio->bi_private = r10_bio;
2552 bio->bi_end_io = raid10_end_read_request;
2553 if (max_sectors < r10_bio->sectors) {
2554 /* Drat - have to split this up more */
2555 struct bio *mbio = r10_bio->master_bio;
2556 int sectors_handled =
2557 r10_bio->sector + max_sectors
2558 - mbio->bi_iter.bi_sector;

--- 473 unchanged lines hidden (view full) ---

3032 }
3033 }
3034 bio = r10_bio->devs[0].bio;
3035 bio_reset(bio);
3036 bio->bi_next = biolist;
3037 biolist = bio;
3038 bio->bi_private = r10_bio;
3039 bio->bi_end_io = end_sync_read;
3041 bio->bi_rw = READ;
3040 bio_set_op_attrs(bio, REQ_OP_READ, 0);
3042 from_addr = r10_bio->devs[j].addr;
3043 bio->bi_iter.bi_sector = from_addr +
3044 rdev->data_offset;
3045 bio->bi_bdev = rdev->bdev;
3046 atomic_inc(&rdev->nr_pending);
3047 /* and we write to 'i' (if not in_sync) */
3048
3049 for (k=0; k<conf->copies; k++)

--- 9 unchanged lines hidden (view full) ---

3059 rdev = mirror->rdev;
3060 if (!test_bit(In_sync, &rdev->flags)) {
3061 bio = r10_bio->devs[1].bio;
3062 bio_reset(bio);
3063 bio->bi_next = biolist;
3064 biolist = bio;
3065 bio->bi_private = r10_bio;
3066 bio->bi_end_io = end_sync_write;
3041 from_addr = r10_bio->devs[j].addr;
3042 bio->bi_iter.bi_sector = from_addr +
3043 rdev->data_offset;
3044 bio->bi_bdev = rdev->bdev;
3045 atomic_inc(&rdev->nr_pending);
3046 /* and we write to 'i' (if not in_sync) */
3047
3048 for (k=0; k<conf->copies; k++)

--- 9 unchanged lines hidden (view full) ---

3058 rdev = mirror->rdev;
3059 if (!test_bit(In_sync, &rdev->flags)) {
3060 bio = r10_bio->devs[1].bio;
3061 bio_reset(bio);
3062 bio->bi_next = biolist;
3063 biolist = bio;
3064 bio->bi_private = r10_bio;
3065 bio->bi_end_io = end_sync_write;
3067 bio->bi_rw = WRITE;
3066 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3068 bio->bi_iter.bi_sector = to_addr
3069 + rdev->data_offset;
3070 bio->bi_bdev = rdev->bdev;
3071 atomic_inc(&r10_bio->remaining);
3072 } else
3073 r10_bio->devs[1].bio->bi_end_io = NULL;
3074
3075 /* and maybe write to replacement */

--- 12 unchanged lines hidden (view full) ---

3088 if (rdev == NULL || bio == NULL ||
3089 test_bit(Faulty, &rdev->flags))
3090 break;
3091 bio_reset(bio);
3092 bio->bi_next = biolist;
3093 biolist = bio;
3094 bio->bi_private = r10_bio;
3095 bio->bi_end_io = end_sync_write;
3067 bio->bi_iter.bi_sector = to_addr
3068 + rdev->data_offset;
3069 bio->bi_bdev = rdev->bdev;
3070 atomic_inc(&r10_bio->remaining);
3071 } else
3072 r10_bio->devs[1].bio->bi_end_io = NULL;
3073
3074 /* and maybe write to replacement */

--- 12 unchanged lines hidden (view full) ---

3087 if (rdev == NULL || bio == NULL ||
3088 test_bit(Faulty, &rdev->flags))
3089 break;
3090 bio_reset(bio);
3091 bio->bi_next = biolist;
3092 biolist = bio;
3093 bio->bi_private = r10_bio;
3094 bio->bi_end_io = end_sync_write;
3096 bio->bi_rw = WRITE;
3095 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3097 bio->bi_iter.bi_sector = to_addr +
3098 rdev->data_offset;
3099 bio->bi_bdev = rdev->bdev;
3100 atomic_inc(&r10_bio->remaining);
3101 break;
3102 }
3103 if (j == conf->copies) {
3104 /* Cannot recover, so abort the recovery or

--- 103 unchanged lines hidden (view full) ---

3208 }
3209 }
3210 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3211 atomic_inc(&r10_bio->remaining);
3212 bio->bi_next = biolist;
3213 biolist = bio;
3214 bio->bi_private = r10_bio;
3215 bio->bi_end_io = end_sync_read;
3096 bio->bi_iter.bi_sector = to_addr +
3097 rdev->data_offset;
3098 bio->bi_bdev = rdev->bdev;
3099 atomic_inc(&r10_bio->remaining);
3100 break;
3101 }
3102 if (j == conf->copies) {
3103 /* Cannot recover, so abort the recovery or

--- 103 unchanged lines hidden (view full) ---

3207 }
3208 }
3209 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3210 atomic_inc(&r10_bio->remaining);
3211 bio->bi_next = biolist;
3212 biolist = bio;
3213 bio->bi_private = r10_bio;
3214 bio->bi_end_io = end_sync_read;
3216 bio->bi_rw = READ;
3215 bio_set_op_attrs(bio, REQ_OP_READ, 0);
3217 bio->bi_iter.bi_sector = sector +
3218 conf->mirrors[d].rdev->data_offset;
3219 bio->bi_bdev = conf->mirrors[d].rdev->bdev;
3220 count++;
3221
3222 if (conf->mirrors[d].replacement == NULL ||
3223 test_bit(Faulty,
3224 &conf->mirrors[d].replacement->flags))

--- 5 unchanged lines hidden (view full) ---

3230 bio->bi_error = -EIO;
3231
3232 sector = r10_bio->devs[i].addr;
3233 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3234 bio->bi_next = biolist;
3235 biolist = bio;
3236 bio->bi_private = r10_bio;
3237 bio->bi_end_io = end_sync_write;
3216 bio->bi_iter.bi_sector = sector +
3217 conf->mirrors[d].rdev->data_offset;
3218 bio->bi_bdev = conf->mirrors[d].rdev->bdev;
3219 count++;
3220
3221 if (conf->mirrors[d].replacement == NULL ||
3222 test_bit(Faulty,
3223 &conf->mirrors[d].replacement->flags))

--- 5 unchanged lines hidden (view full) ---

3229 bio->bi_error = -EIO;
3230
3231 sector = r10_bio->devs[i].addr;
3232 atomic_inc(&conf->mirrors[d].rdev->nr_pending);
3233 bio->bi_next = biolist;
3234 biolist = bio;
3235 bio->bi_private = r10_bio;
3236 bio->bi_end_io = end_sync_write;
3238 bio->bi_rw = WRITE;
3237 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
3239 bio->bi_iter.bi_sector = sector +
3240 conf->mirrors[d].replacement->data_offset;
3241 bio->bi_bdev = conf->mirrors[d].replacement->bdev;
3242 count++;
3243 }
3244
3245 if (count < 2) {
3246 for (i=0; i<conf->copies; i++) {

--- 1068 unchanged lines hidden (view full) ---

4315
4316 read_bio = bio_alloc_mddev(GFP_KERNEL, RESYNC_PAGES, mddev);
4317
4318 read_bio->bi_bdev = rdev->bdev;
4319 read_bio->bi_iter.bi_sector = (r10_bio->devs[r10_bio->read_slot].addr
4320 + rdev->data_offset);
4321 read_bio->bi_private = r10_bio;
4322 read_bio->bi_end_io = end_sync_read;
3238 bio->bi_iter.bi_sector = sector +
3239 conf->mirrors[d].replacement->data_offset;
3240 bio->bi_bdev = conf->mirrors[d].replacement->bdev;
3241 count++;
3242 }
3243
3244 if (count < 2) {
3245 for (i=0; i<conf->copies; i++) {

--- 1068 unchanged lines hidden (view full) ---

4314
4315 read_bio = bio_alloc_mddev(GFP_KERNEL, RESYNC_PAGES, mddev);
4316
4317 read_bio->bi_bdev = rdev->bdev;
4318 read_bio->bi_iter.bi_sector = (r10_bio->devs[r10_bio->read_slot].addr
4319 + rdev->data_offset);
4320 read_bio->bi_private = r10_bio;
4321 read_bio->bi_end_io = end_sync_read;
4323 read_bio->bi_rw = READ;
4322 bio_set_op_attrs(read_bio, REQ_OP_READ, 0);
4324 read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
4325 read_bio->bi_error = 0;
4326 read_bio->bi_vcnt = 0;
4327 read_bio->bi_iter.bi_size = 0;
4328 r10_bio->master_bio = read_bio;
4329 r10_bio->read_slot = r10_bio->devs[r10_bio->read_slot].devnum;
4330
4331 /* Now find the locations in the new layout */

--- 17 unchanged lines hidden (view full) ---

4349 continue;
4350
4351 bio_reset(b);
4352 b->bi_bdev = rdev2->bdev;
4353 b->bi_iter.bi_sector = r10_bio->devs[s/2].addr +
4354 rdev2->new_data_offset;
4355 b->bi_private = r10_bio;
4356 b->bi_end_io = end_reshape_write;
4323 read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
4324 read_bio->bi_error = 0;
4325 read_bio->bi_vcnt = 0;
4326 read_bio->bi_iter.bi_size = 0;
4327 r10_bio->master_bio = read_bio;
4328 r10_bio->read_slot = r10_bio->devs[r10_bio->read_slot].devnum;
4329
4330 /* Now find the locations in the new layout */

--- 17 unchanged lines hidden (view full) ---

4348 continue;
4349
4350 bio_reset(b);
4351 b->bi_bdev = rdev2->bdev;
4352 b->bi_iter.bi_sector = r10_bio->devs[s/2].addr +
4353 rdev2->new_data_offset;
4354 b->bi_private = r10_bio;
4355 b->bi_end_io = end_reshape_write;
4357 b->bi_rw = WRITE;
4356 bio_set_op_attrs(b, REQ_OP_WRITE, 0);
4358 b->bi_next = blist;
4359 blist = b;
4360 }
4361
4362 /* Now add as many pages as possible to all of these bios. */
4363
4364 nr_sectors = 0;
4365 for (s = 0 ; s < max_sectors; s += PAGE_SIZE >> 9) {

--- 151 unchanged lines hidden (view full) ---

4517 !test_bit(In_sync, &rdev->flags))
4518 goto failed;
4519
4520 addr = r10b->devs[slot].addr + idx * PAGE_SIZE;
4521 success = sync_page_io(rdev,
4522 addr,
4523 s << 9,
4524 bvec[idx].bv_page,
4357 b->bi_next = blist;
4358 blist = b;
4359 }
4360
4361 /* Now add as many pages as possible to all of these bios. */
4362
4363 nr_sectors = 0;
4364 for (s = 0 ; s < max_sectors; s += PAGE_SIZE >> 9) {

--- 151 unchanged lines hidden (view full) ---

4516 !test_bit(In_sync, &rdev->flags))
4517 goto failed;
4518
4519 addr = r10b->devs[slot].addr + idx * PAGE_SIZE;
4520 success = sync_page_io(rdev,
4521 addr,
4522 s << 9,
4523 bvec[idx].bv_page,
4525 READ, false);
4524 REQ_OP_READ, 0, false);
4526 if (success)
4527 break;
4528 failed:
4529 slot++;
4530 if (slot >= conf->copies)
4531 slot = 0;
4532 if (slot == first_slot)
4533 break;

--- 131 unchanged lines hidden --- 		4525 if (success)
4526 break;
4527 failed:
4528 slot++;
4529 if (slot >= conf->copies)
4530 slot = 0;
4531 if (slot == first_slot)
4532 break;

--- 131 unchanged lines hidden ---