Merge tag 'scsi-misc' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi

[platform/kernel/linux-starfive.git] / drivers / md / raid1.c

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 203ec58..800a17a 100644 (file)
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -824,7 +824,6 @@ static void flush_pending_writes(struct r1conf *conf)
                struct bio *bio;
 
                bio = bio_list_get(&conf->pending_bio_list);
-               conf->pending_count = 0;
                spin_unlock_irq(&conf->device_lock);
 
                /*
@@ -1126,7 +1125,8 @@ static void alloc_behind_master_bio(struct r1bio *r1_bio,
        int i = 0;
        struct bio *behind_bio = NULL;
 
-       behind_bio = bio_alloc_bioset(GFP_NOIO, vcnt, &r1_bio->mddev->bio_set);
+       behind_bio = bio_alloc_bioset(NULL, vcnt, 0, GFP_NOIO,
+                                     &r1_bio->mddev->bio_set);
        if (!behind_bio)
                return;
 
@@ -1166,12 +1166,6 @@ free_pages:
        bio_put(behind_bio);
 }
 
-struct raid1_plug_cb {
-       struct blk_plug_cb      cb;
-       struct bio_list         pending;
-       int                     pending_cnt;
-};
-
 static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule)
 {
        struct raid1_plug_cb *plug = container_of(cb, struct raid1_plug_cb,
@@ -1183,7 +1177,6 @@ static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule)
        if (from_schedule || current->bio_list) {
                spin_lock_irq(&conf->device_lock);
                bio_list_merge(&conf->pending_bio_list, &plug->pending);
-               conf->pending_count += plug->pending_cnt;
                spin_unlock_irq(&conf->device_lock);
                wake_up(&conf->wait_barrier);
                md_wakeup_thread(mddev->thread);
@@ -1319,13 +1312,13 @@ static void raid1_read_request(struct mddev *mddev, struct bio *bio,
        if (!r1bio_existed && blk_queue_io_stat(bio->bi_bdev->bd_disk->queue))
                r1_bio->start_time = bio_start_io_acct(bio);
 
-       read_bio = bio_clone_fast(bio, gfp, &mddev->bio_set);
+       read_bio = bio_alloc_clone(mirror->rdev->bdev, bio, gfp,
+                                  &mddev->bio_set);
 
        r1_bio->bios[rdisk] = read_bio;
 
        read_bio->bi_iter.bi_sector = r1_bio->sector +
                mirror->rdev->data_offset;
-       bio_set_dev(read_bio, mirror->rdev->bdev);
        read_bio->bi_end_io = raid1_end_read_request;
        bio_set_op_attrs(read_bio, op, do_sync);
        if (test_bit(FailFast, &mirror->rdev->flags) &&
@@ -1545,24 +1538,25 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
                        first_clone = 0;
                }
 
-               if (r1_bio->behind_master_bio)
-                       mbio = bio_clone_fast(r1_bio->behind_master_bio,
-                                             GFP_NOIO, &mddev->bio_set);
-               else
-                       mbio = bio_clone_fast(bio, GFP_NOIO, &mddev->bio_set);
-
                if (r1_bio->behind_master_bio) {
+                       mbio = bio_alloc_clone(rdev->bdev,
+                                              r1_bio->behind_master_bio,
+                                              GFP_NOIO, &mddev->bio_set);
                        if (test_bit(CollisionCheck, &rdev->flags))
                                wait_for_serialization(rdev, r1_bio);
                        if (test_bit(WriteMostly, &rdev->flags))
                                atomic_inc(&r1_bio->behind_remaining);
-               } else if (mddev->serialize_policy)
-                       wait_for_serialization(rdev, r1_bio);
+               } else {
+                       mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO,
+                                              &mddev->bio_set);
+
+                       if (mddev->serialize_policy)
+                               wait_for_serialization(rdev, r1_bio);
+               }
 
                r1_bio->bios[i] = mbio;
 
                mbio->bi_iter.bi_sector = (r1_bio->sector + rdev->data_offset);
-               bio_set_dev(mbio, rdev->bdev);
                mbio->bi_end_io = raid1_end_write_request;
                mbio->bi_opf = bio_op(bio) | (bio->bi_opf & (REQ_SYNC | REQ_FUA));
                if (test_bit(FailFast, &rdev->flags) &&
@@ -1586,11 +1580,9 @@ static void raid1_write_request(struct mddev *mddev, struct bio *bio,
                        plug = NULL;
                if (plug) {
                        bio_list_add(&plug->pending, mbio);
-                       plug->pending_cnt++;
                } else {
                        spin_lock_irqsave(&conf->device_lock, flags);
                        bio_list_add(&conf->pending_bio_list, mbio);
-                       conf->pending_count++;
                        spin_unlock_irqrestore(&conf->device_lock, flags);
                        md_wakeup_thread(mddev->thread);
                }
@@ -2070,15 +2062,14 @@ static int fix_sync_read_error(struct r1bio *r1_bio)
                } while (!success && d != r1_bio->read_disk);
 
                if (!success) {
-                       char b[BDEVNAME_SIZE];
                        int abort = 0;
                        /* Cannot read from anywhere, this block is lost.
                         * Record a bad block on each device.  If that doesn't
                         * work just disable and interrupt the recovery.
                         * Don't fail devices as that won't really help.
                         */
-                       pr_crit_ratelimited("md/raid1:%s: %s: unrecoverable I/O read error for block %llu\n",
-                                           mdname(mddev), bio_devname(bio, b),
+                       pr_crit_ratelimited("md/raid1:%s: %pg: unrecoverable I/O read error for block %llu\n",
+                                           mdname(mddev), bio->bi_bdev,
                                            (unsigned long long)r1_bio->sector);
                        for (d = 0; d < conf->raid_disks * 2; d++) {
                                rdev = conf->mirrors[d].rdev;
@@ -2165,11 +2156,10 @@ static void process_checks(struct r1bio *r1_bio)
                        continue;
                /* fixup the bio for reuse, but preserve errno */
                status = b->bi_status;
-               bio_reset(b);
+               bio_reset(b, conf->mirrors[i].rdev->bdev, REQ_OP_READ);
                b->bi_status = status;
                b->bi_iter.bi_sector = r1_bio->sector +
                        conf->mirrors[i].rdev->data_offset;
-               bio_set_dev(b, conf->mirrors[i].rdev->bdev);
                b->bi_end_io = end_sync_read;
                rp->raid_bio = r1_bio;
                b->bi_private = rp;
@@ -2416,12 +2406,12 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
                /* Write at 'sector' for 'sectors'*/
 
                if (test_bit(R1BIO_BehindIO, &r1_bio->state)) {
-                       wbio = bio_clone_fast(r1_bio->behind_master_bio,
-                                             GFP_NOIO,
-                                             &mddev->bio_set);
+                       wbio = bio_alloc_clone(rdev->bdev,
+                                              r1_bio->behind_master_bio,
+                                              GFP_NOIO, &mddev->bio_set);
                } else {
-                       wbio = bio_clone_fast(r1_bio->master_bio, GFP_NOIO,
-                                             &mddev->bio_set);
+                       wbio = bio_alloc_clone(rdev->bdev, r1_bio->master_bio,
+                                              GFP_NOIO, &mddev->bio_set);
                }
 
                bio_set_op_attrs(wbio, REQ_OP_WRITE, 0);
@@ -2430,7 +2420,6 @@ static int narrow_write_error(struct r1bio *r1_bio, int i)
 
                bio_trim(wbio, sector - r1_bio->sector, sectors);
                wbio->bi_iter.bi_sector += rdev->data_offset;
-               bio_set_dev(wbio, rdev->bdev);
 
                if (submit_bio_wait(wbio) < 0)
                        /* failure! */
@@ -2650,7 +2639,7 @@ static struct r1bio *raid1_alloc_init_r1buf(struct r1conf *conf)
        for (i = conf->poolinfo->raid_disks; i--; ) {
                bio = r1bio->bios[i];
                rps = bio->bi_private;
-               bio_reset(bio);
+               bio_reset(bio, NULL, 0);
                bio->bi_private = rps;
        }
        r1bio->master_bio = NULL;
@@ -3058,7 +3047,6 @@ static struct r1conf *setup_conf(struct mddev *mddev)
        init_waitqueue_head(&conf->wait_barrier);
 
        bio_list_init(&conf->pending_bio_list);
-       conf->pending_count = 0;
        conf->recovery_disabled = mddev->recovery_disabled - 1;
 
        err = -EIO;