dm-raid1.c (8c57a5e7b2820f349c95b8c8393fec1e0f4070d2) dm-raid1.c (70246286e94c335b5bea0cbc68a17a96dd620281)
1/*
2 * Copyright (C) 2003 Sistina Software Limited.
3 * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm-bio-record.h"

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

255{
256 struct mirror_set *ms = ti->private;
257 unsigned long error_bits;
258
259 unsigned int i;
260 struct dm_io_region io[ms->nr_mirrors];
261 struct mirror *m;
262 struct dm_io_request io_req = {
1/*
2 * Copyright (C) 2003 Sistina Software Limited.
3 * Copyright (C) 2005-2008 Red Hat, Inc. All rights reserved.
4 *
5 * This file is released under the GPL.
6 */
7
8#include "dm-bio-record.h"

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

255{
256 struct mirror_set *ms = ti->private;
257 unsigned long error_bits;
258
259 unsigned int i;
260 struct dm_io_region io[ms->nr_mirrors];
261 struct mirror *m;
262 struct dm_io_request io_req = {
263 .bi_rw = WRITE_FLUSH,
263 .bi_op = REQ_OP_WRITE,
264 .bi_op_flags = WRITE_FLUSH,
264 .mem.type = DM_IO_KMEM,
265 .mem.ptr.addr = NULL,
266 .client = ms->io_client,
267 };
268
269 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++) {
270 io[i].bdev = m->dev->bdev;
271 io[i].sector = 0;

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

522 }
523
524 fail_mirror(m, DM_RAID1_READ_ERROR);
525
526 if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
527 DMWARN_LIMIT("Read failure on mirror device %s. "
528 "Trying alternative device.",
529 m->dev->name);
265 .mem.type = DM_IO_KMEM,
266 .mem.ptr.addr = NULL,
267 .client = ms->io_client,
268 };
269
270 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++) {
271 io[i].bdev = m->dev->bdev;
272 io[i].sector = 0;

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

523 }
524
525 fail_mirror(m, DM_RAID1_READ_ERROR);
526
527 if (likely(default_ok(m)) || mirror_available(m->ms, bio)) {
528 DMWARN_LIMIT("Read failure on mirror device %s. "
529 "Trying alternative device.",
530 m->dev->name);
530 queue_bio(m->ms, bio, bio_rw(bio));
531 queue_bio(m->ms, bio, bio_data_dir(bio));
531 return;
532 }
533
534 DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
535 m->dev->name);
536 bio_io_error(bio);
537}
538
539/* Asynchronous read. */
540static void read_async_bio(struct mirror *m, struct bio *bio)
541{
542 struct dm_io_region io;
543 struct dm_io_request io_req = {
532 return;
533 }
534
535 DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
536 m->dev->name);
537 bio_io_error(bio);
538}
539
540/* Asynchronous read. */
541static void read_async_bio(struct mirror *m, struct bio *bio)
542{
543 struct dm_io_region io;
544 struct dm_io_request io_req = {
544 .bi_rw = READ,
545 .bi_op = REQ_OP_READ,
546 .bi_op_flags = 0,
545 .mem.type = DM_IO_BIO,
546 .mem.ptr.bio = bio,
547 .notify.fn = read_callback,
548 .notify.context = bio,
549 .client = m->ms->io_client,
550 };
551
552 map_region(&io, m, bio);

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

619 bio_endio(bio);
620 return;
621 }
622
623 /*
624 * If the bio is discard, return an error, but do not
625 * degrade the array.
626 */
547 .mem.type = DM_IO_BIO,
548 .mem.ptr.bio = bio,
549 .notify.fn = read_callback,
550 .notify.context = bio,
551 .client = m->ms->io_client,
552 };
553
554 map_region(&io, m, bio);

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

621 bio_endio(bio);
622 return;
623 }
624
625 /*
626 * If the bio is discard, return an error, but do not
627 * degrade the array.
628 */
627 if (bio->bi_rw & REQ_DISCARD) {
629 if (bio_op(bio) == REQ_OP_DISCARD) {
628 bio->bi_error = -EOPNOTSUPP;
629 bio_endio(bio);
630 return;
631 }
632
633 for (i = 0; i < ms->nr_mirrors; i++)
634 if (test_bit(i, &error))
635 fail_mirror(ms->mirror + i, DM_RAID1_WRITE_ERROR);

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

649}
650
651static void do_write(struct mirror_set *ms, struct bio *bio)
652{
653 unsigned int i;
654 struct dm_io_region io[ms->nr_mirrors], *dest = io;
655 struct mirror *m;
656 struct dm_io_request io_req = {
630 bio->bi_error = -EOPNOTSUPP;
631 bio_endio(bio);
632 return;
633 }
634
635 for (i = 0; i < ms->nr_mirrors; i++)
636 if (test_bit(i, &error))
637 fail_mirror(ms->mirror + i, DM_RAID1_WRITE_ERROR);

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

651}
652
653static void do_write(struct mirror_set *ms, struct bio *bio)
654{
655 unsigned int i;
656 struct dm_io_region io[ms->nr_mirrors], *dest = io;
657 struct mirror *m;
658 struct dm_io_request io_req = {
657 .bi_rw = WRITE | (bio->bi_rw & WRITE_FLUSH_FUA),
659 .bi_op = REQ_OP_WRITE,
660 .bi_op_flags = bio->bi_rw & WRITE_FLUSH_FUA,
658 .mem.type = DM_IO_BIO,
659 .mem.ptr.bio = bio,
660 .notify.fn = write_callback,
661 .notify.context = bio,
662 .client = ms->io_client,
663 };
664
661 .mem.type = DM_IO_BIO,
662 .mem.ptr.bio = bio,
663 .notify.fn = write_callback,
664 .notify.context = bio,
665 .client = ms->io_client,
666 };
667
665 if (bio->bi_rw & REQ_DISCARD) {
666 io_req.bi_rw |= REQ_DISCARD;
668 if (bio_op(bio) == REQ_OP_DISCARD) {
669 io_req.bi_op = REQ_OP_DISCARD;
667 io_req.mem.type = DM_IO_KMEM;
668 io_req.mem.ptr.addr = NULL;
669 }
670
671 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++)
672 map_region(dest++, m, bio);
673
674 /*

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

696 * Classify each write.
697 */
698 bio_list_init(&sync);
699 bio_list_init(&nosync);
700 bio_list_init(&recover);
701 bio_list_init(&requeue);
702
703 while ((bio = bio_list_pop(writes))) {
670 io_req.mem.type = DM_IO_KMEM;
671 io_req.mem.ptr.addr = NULL;
672 }
673
674 for (i = 0, m = ms->mirror; i < ms->nr_mirrors; i++, m++)
675 map_region(dest++, m, bio);
676
677 /*

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

699 * Classify each write.
700 */
701 bio_list_init(&sync);
702 bio_list_init(&nosync);
703 bio_list_init(&recover);
704 bio_list_init(&requeue);
705
706 while ((bio = bio_list_pop(writes))) {
704 if ((bio->bi_rw & REQ_FLUSH) ||
705 (bio->bi_rw & REQ_DISCARD)) {
707 if ((bio->bi_rw & REQ_PREFLUSH) ||
708 (bio_op(bio) == REQ_OP_DISCARD)) {
706 bio_list_add(&sync, bio);
707 continue;
708 }
709
710 region = dm_rh_bio_to_region(ms->rh, bio);
711
712 if (log->type->is_remote_recovering &&
713 log->type->is_remote_recovering(log, region)) {

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

1185 free_context(ms, ti, ms->nr_mirrors);
1186}
1187
1188/*
1189 * Mirror mapping function
1190 */
1191static int mirror_map(struct dm_target *ti, struct bio *bio)
1192{
709 bio_list_add(&sync, bio);
710 continue;
711 }
712
713 region = dm_rh_bio_to_region(ms->rh, bio);
714
715 if (log->type->is_remote_recovering &&
716 log->type->is_remote_recovering(log, region)) {

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

1188 free_context(ms, ti, ms->nr_mirrors);
1189}
1190
1191/*
1192 * Mirror mapping function
1193 */
1194static int mirror_map(struct dm_target *ti, struct bio *bio)
1195{
1193 int r, rw = bio_rw(bio);
1196 int r, rw = bio_data_dir(bio);
1194 struct mirror *m;
1195 struct mirror_set *ms = ti->private;
1196 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1197 struct dm_raid1_bio_record *bio_record =
1198 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1199
1200 bio_record->details.bi_bdev = NULL;
1201

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

1209 r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
1210 if (r < 0 && r != -EWOULDBLOCK)
1211 return r;
1212
1213 /*
1214 * If region is not in-sync queue the bio.
1215 */
1216 if (!r || (r == -EWOULDBLOCK)) {
1197 struct mirror *m;
1198 struct mirror_set *ms = ti->private;
1199 struct dm_dirty_log *log = dm_rh_dirty_log(ms->rh);
1200 struct dm_raid1_bio_record *bio_record =
1201 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1202
1203 bio_record->details.bi_bdev = NULL;
1204

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

1212 r = log->type->in_sync(log, dm_rh_bio_to_region(ms->rh, bio), 0);
1213 if (r < 0 && r != -EWOULDBLOCK)
1214 return r;
1215
1216 /*
1217 * If region is not in-sync queue the bio.
1218 */
1219 if (!r || (r == -EWOULDBLOCK)) {
1217 if (rw == READA)
1220 if (bio->bi_rw & REQ_RAHEAD)
1218 return -EWOULDBLOCK;
1219
1220 queue_bio(ms, bio, rw);
1221 return DM_MAPIO_SUBMITTED;
1222 }
1223
1224 /*
1225 * The region is in-sync and we can perform reads directly.

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

1234
1235 map_bio(m, bio);
1236
1237 return DM_MAPIO_REMAPPED;
1238}
1239
1240static int mirror_end_io(struct dm_target *ti, struct bio *bio, int error)
1241{
1221 return -EWOULDBLOCK;
1222
1223 queue_bio(ms, bio, rw);
1224 return DM_MAPIO_SUBMITTED;
1225 }
1226
1227 /*
1228 * The region is in-sync and we can perform reads directly.

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

1237
1238 map_bio(m, bio);
1239
1240 return DM_MAPIO_REMAPPED;
1241}
1242
1243static int mirror_end_io(struct dm_target *ti, struct bio *bio, int error)
1244{
1242 int rw = bio_rw(bio);
1245 int rw = bio_data_dir(bio);
1243 struct mirror_set *ms = (struct mirror_set *) ti->private;
1244 struct mirror *m = NULL;
1245 struct dm_bio_details *bd = NULL;
1246 struct dm_raid1_bio_record *bio_record =
1247 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1248
1249 /*
1250 * We need to dec pending if this was a write.
1251 */
1252 if (rw == WRITE) {
1246 struct mirror_set *ms = (struct mirror_set *) ti->private;
1247 struct mirror *m = NULL;
1248 struct dm_bio_details *bd = NULL;
1249 struct dm_raid1_bio_record *bio_record =
1250 dm_per_bio_data(bio, sizeof(struct dm_raid1_bio_record));
1251
1252 /*
1253 * We need to dec pending if this was a write.
1254 */
1255 if (rw == WRITE) {
1253 if (!(bio->bi_rw & (REQ_FLUSH | REQ_DISCARD)))
1256 if (!(bio->bi_rw & REQ_PREFLUSH) &&
1257 bio_op(bio) != REQ_OP_DISCARD)
1254 dm_rh_dec(ms->rh, bio_record->write_region);
1255 return error;
1256 }
1257
1258 if (error == -EOPNOTSUPP)
1259 goto out;
1260
1261 if ((error == -EWOULDBLOCK) && (bio->bi_rw & REQ_RAHEAD))

--- 240 unchanged lines hidden --- 		1258 dm_rh_dec(ms->rh, bio_record->write_region);
1259 return error;
1260 }
1261
1262 if (error == -EOPNOTSUPP)
1263 goto out;
1264
1265 if ((error == -EWOULDBLOCK) && (bio->bi_rw & REQ_RAHEAD))

--- 240 unchanged lines hidden ---