md/raid1: add failfast handling for writes.

When writing to a fastfail device we use MD_FASTFAIL unless
it is the only device being written to.

For resync/recovery, assume there was a working device to
read from so always use REQ_FASTFAIL_DEV.

If a write for resync/recovery fails, we just fail the
device - there is not much else to do.

If a normal failfast write fails, but the device cannot be
failed (must be only one left), we queue for write error
handling.  This will call narrow_write_error() to retry the
write synchronously and without any FAILFAST flags.

Signed-off-by: NeilBrown <neilb@suse.com>
Signed-off-by: Shaohua Li <shli@fb.com>

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 1f22df0e5f3d782fbd8545d4317d3a54e9b65263..94e0afce6d4cc92e7dab48641d36c32b1c32a03a 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -422,7 +422,24 @@ static void raid1_end_write_request(struct bio *bio)
                        set_bit(MD_RECOVERY_NEEDED, &
                                conf->mddev->recovery);
 
-               set_bit(R1BIO_WriteError, &r1_bio->state);
+               if (test_bit(FailFast, &rdev->flags) &&
+                   (bio->bi_opf & MD_FAILFAST) &&
+                   /* We never try FailFast to WriteMostly devices */
+                   !test_bit(WriteMostly, &rdev->flags)) {
+                       md_error(r1_bio->mddev, rdev);
+                       if (!test_bit(Faulty, &rdev->flags))
+                               /* This is the only remaining device,
+                                * We need to retry the write without
+                                * FailFast
+                                */
+                               set_bit(R1BIO_WriteError, &r1_bio->state);
+                       else {
+                               /* Finished with this branch */
+                               r1_bio->bios[mirror] = NULL;
+                               to_put = bio;
+                       }
+               } else
+                       set_bit(R1BIO_WriteError, &r1_bio->state);
        } else {
                /*
                 * Set R1BIO_Uptodate in our master bio, so that we
@@ -1392,6 +1409,10 @@ read_again:
                mbio->bi_bdev = conf->mirrors[i].rdev->bdev;
                mbio->bi_end_io = raid1_end_write_request;
                bio_set_op_attrs(mbio, op, do_flush_fua | do_sync);
+               if (test_bit(FailFast, &conf->mirrors[i].rdev->flags) &&
+                   !test_bit(WriteMostly, &conf->mirrors[i].rdev->flags) &&
+                   conf->raid_disks - mddev->degraded > 1)
+                       mbio->bi_opf |= MD_FAILFAST;
                mbio->bi_private = r1_bio;
 
                atomic_inc(&r1_bio->remaining);
@@ -2060,6 +2081,9 @@ static void sync_request_write(struct mddev *mddev, struct r1bio *r1_bio)
                        continue;
 
                bio_set_op_attrs(wbio, REQ_OP_WRITE, 0);
+               if (test_bit(FailFast, &conf->mirrors[i].rdev->flags))
+                       wbio->bi_opf |= MD_FAILFAST;
+
                wbio->bi_end_io = end_sync_write;
                atomic_inc(&r1_bio->remaining);
                md_sync_acct(conf->mirrors[i].rdev->bdev, bio_sectors(wbio));