block: switch bios to blk_status_t

Replace bi_error with a new bi_status to allow for a clear conversion.
Note that device mapper overloaded bi_error with a private value, which
we'll have to keep arround at least for now and thus propagate to a
proper blk_status_t value.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@fb.com>

1 files changed, 18 insertions, 18 deletions

diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index af5056d56878..94b87c4d0f7b 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -277,7 +277,7 @@ static void call_bio_endio(struct r1bio *r1_bio)
         struct r1conf *conf = r1_bio->mddev->private;
 
         if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
-                bio->bi_error = -EIO;
+                bio->bi_status = BLK_STS_IOERR;
 
         bio_endio(bio);
         /*
@@ -335,7 +335,7 @@ static int find_bio_disk(struct r1bio *r1_bio, struct bio *bio)
 
 static void raid1_end_read_request(struct bio *bio)
 {
-        int uptodate = !bio->bi_error;
+        int uptodate = !bio->bi_status;
         struct r1bio *r1_bio = bio->bi_private;
         struct r1conf *conf = r1_bio->mddev->private;
         struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;
@@ -426,12 +426,12 @@ static void raid1_end_write_request(struct bio *bio)
         struct md_rdev *rdev = conf->mirrors[mirror].rdev;
         bool discard_error;
 
-        discard_error = bio->bi_error && bio_op(bio) == REQ_OP_DISCARD;
+        discard_error = bio->bi_status && bio_op(bio) == REQ_OP_DISCARD;
 
         /*
          * 'one mirror IO has finished' event handler:
          */
-        if (bio->bi_error && !discard_error) {
+        if (bio->bi_status && !discard_error) {
                 set_bit(WriteErrorSeen, &rdev->flags);
                 if (!test_and_set_bit(WantReplacement, &rdev->flags))
                         set_bit(MD_RECOVERY_NEEDED, &
@@ -802,7 +802,7 @@ static void flush_bio_list(struct r1conf *conf, struct bio *bio)
                 bio->bi_next = NULL;
                 bio->bi_bdev = rdev->bdev;
                 if (test_bit(Faulty, &rdev->flags)) {
-                        bio->bi_error = -EIO;
+                        bio->bi_status = BLK_STS_IOERR;
                         bio_endio(bio);
                 } else if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
                                     !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
@@ -1856,7 +1856,7 @@ static void end_sync_read(struct bio *bio)
          * or re-read if the read failed.
          * We don't do much here, just schedule handling by raid1d
          */
-        if (!bio->bi_error)
+        if (!bio->bi_status)
                 set_bit(R1BIO_Uptodate, &r1_bio->state);
 
         if (atomic_dec_and_test(&r1_bio->remaining))
@@ -1865,7 +1865,7 @@ static void end_sync_read(struct bio *bio)
 
 static void end_sync_write(struct bio *bio)
 {
-        int uptodate = !bio->bi_error;
+        int uptodate = !bio->bi_status;
         struct r1bio *r1_bio = get_resync_r1bio(bio);
         struct mddev *mddev = r1_bio->mddev;
         struct r1conf *conf = mddev->private;
@@ -2058,7 +2058,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio)
                 idx ++;
         }
         set_bit(R1BIO_Uptodate, &r1_bio->state);
-        bio->bi_error = 0;
+        bio->bi_status = 0;
         return 1;
 }
 
@@ -2082,16 +2082,16 @@ static void process_checks(struct r1bio *r1_bio)
         for (i = 0; i < conf->raid_disks * 2; i++) {
                 int j;
                 int size;
-                int error;
+                blk_status_t status;
                 struct bio_vec *bi;
                 struct bio *b = r1_bio->bios[i];
                 struct resync_pages *rp = get_resync_pages(b);
                 if (b->bi_end_io != end_sync_read)
                         continue;
                 /* fixup the bio for reuse, but preserve errno */
-                error = b->bi_error;
+                status = b->bi_status;
                 bio_reset(b);
-                b->bi_error = error;
+                b->bi_status = status;
                 b->bi_vcnt = vcnt;
                 b->bi_iter.bi_size = r1_bio->sectors << 9;
                 b->bi_iter.bi_sector = r1_bio->sector +
@@ -2113,7 +2113,7 @@ static void process_checks(struct r1bio *r1_bio)
         }
         for (primary = 0; primary < conf->raid_disks * 2; primary++)
                 if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
-                    !r1_bio->bios[primary]->bi_error) {
+                    !r1_bio->bios[primary]->bi_status) {
                         r1_bio->bios[primary]->bi_end_io = NULL;
                         rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
                         break;
@@ -2123,7 +2123,7 @@ static void process_checks(struct r1bio *r1_bio)
                 int j;
                 struct bio *pbio = r1_bio->bios[primary];
                 struct bio *sbio = r1_bio->bios[i];
-                int error = sbio->bi_error;
+                blk_status_t status = sbio->bi_status;
                 struct page **ppages = get_resync_pages(pbio)->pages;
                 struct page **spages = get_resync_pages(sbio)->pages;
                 struct bio_vec *bi;
@@ -2132,12 +2132,12 @@ static void process_checks(struct r1bio *r1_bio)
                 if (sbio->bi_end_io != end_sync_read)
                         continue;
                 /* Now we can 'fixup' the error value */
-                sbio->bi_error = 0;
+                sbio->bi_status = 0;
 
                 bio_for_each_segment_all(bi, sbio, j)
                         page_len[j] = bi->bv_len;
 
-                if (!error) {
+                if (!status) {
                         for (j = vcnt; j-- ; ) {
                                 if (memcmp(page_address(ppages[j]),
                                            page_address(spages[j]),
@@ -2149,7 +2149,7 @@ static void process_checks(struct r1bio *r1_bio)
                 if (j >= 0)
                         atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);
                 if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
-                              && !error)) {
+                              && !status)) {
                         /* No need to write to this device. */
                         sbio->bi_end_io = NULL;
                         rdev_dec_pending(conf->mirrors[i].rdev, mddev);
@@ -2400,11 +2400,11 @@ static void handle_sync_write_finished(struct r1conf *conf, struct r1bio *r1_bio
                 struct bio *bio = r1_bio->bios[m];
                 if (bio->bi_end_io == NULL)
                         continue;
-                if (!bio->bi_error &&
+                if (!bio->bi_status &&
                     test_bit(R1BIO_MadeGood, &r1_bio->state)) {
                         rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);
                 }
-                if (bio->bi_error &&
+                if (bio->bi_status &&
                     test_bit(R1BIO_WriteError, &r1_bio->state)) {
                         if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))
                                 md_error(conf->mddev, rdev);