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, 20 insertions, 20 deletions

diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 7a7047211c64..f38f9dd5cbdd 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -63,7 +63,7 @@ static struct workqueue_struct *deferred_remove_workqueue;
  */
 struct dm_io {
         struct mapped_device *md;
-        int error;
+        blk_status_t status;
         atomic_t io_count;
         struct bio *bio;
         unsigned long start_time;
@@ -768,23 +768,24 @@ static int __noflush_suspending(struct mapped_device *md)
  * Decrements the number of outstanding ios that a bio has been
  * cloned into, completing the original io if necc.
  */
-static void dec_pending(struct dm_io *io, int error)
+static void dec_pending(struct dm_io *io, blk_status_t error)
 {
         unsigned long flags;
-        int io_error;
+        blk_status_t io_error;
         struct bio *bio;
         struct mapped_device *md = io->md;
 
         /* Push-back supersedes any I/O errors */
         if (unlikely(error)) {
                 spin_lock_irqsave(&io->endio_lock, flags);
-                if (!(io->error > 0 && __noflush_suspending(md)))
-                        io->error = error;
+                if (!(io->status == BLK_STS_DM_REQUEUE &&
+                                __noflush_suspending(md)))
+                        io->status = error;
                 spin_unlock_irqrestore(&io->endio_lock, flags);
         }
 
         if (atomic_dec_and_test(&io->io_count)) {
-                if (io->error == DM_ENDIO_REQUEUE) {
+                if (io->status == BLK_STS_DM_REQUEUE) {
                         /*
                          * Target requested pushing back the I/O.
                          */
@@ -793,16 +794,16 @@ static void dec_pending(struct dm_io *io, int error)
                                 bio_list_add_head(&md->deferred, io->bio);
                         else
                                 /* noflush suspend was interrupted. */
-                                io->error = -EIO;
+                                io->status = BLK_STS_IOERR;
                         spin_unlock_irqrestore(&md->deferred_lock, flags);
                 }
 
-                io_error = io->error;
+                io_error = io->status;
                 bio = io->bio;
                 end_io_acct(io);
                 free_io(md, io);
 
-                if (io_error == DM_ENDIO_REQUEUE)
+                if (io_error == BLK_STS_DM_REQUEUE)
                         return;
 
                 if ((bio->bi_opf & REQ_PREFLUSH) && bio->bi_iter.bi_size) {
@@ -814,7 +815,7 @@ static void dec_pending(struct dm_io *io, int error)
                         queue_io(md, bio);
                 } else {
                         /* done with normal IO or empty flush */
-                        bio->bi_error = io_error;
+                        bio->bi_status = io_error;
                         bio_endio(bio);
                 }
         }
@@ -838,14 +839,13 @@ void disable_write_zeroes(struct mapped_device *md)
 
 static void clone_endio(struct bio *bio)
 {
-        int error = bio->bi_error;
-        int r = error;
+        blk_status_t error = bio->bi_status;
         struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
         struct dm_io *io = tio->io;
         struct mapped_device *md = tio->io->md;
         dm_endio_fn endio = tio->ti->type->end_io;
 
-        if (unlikely(error == -EREMOTEIO)) {
+        if (unlikely(error == BLK_STS_TARGET)) {
                 if (bio_op(bio) == REQ_OP_WRITE_SAME &&
                     !bdev_get_queue(bio->bi_bdev)->limits.max_write_same_sectors)
                         disable_write_same(md);
@@ -855,10 +855,10 @@ static void clone_endio(struct bio *bio)
         }
 
         if (endio) {
-                r = endio(tio->ti, bio, &error);
+                int r = endio(tio->ti, bio, &error);
                 switch (r) {
                 case DM_ENDIO_REQUEUE:
-                        error = DM_ENDIO_REQUEUE;
+                        error = BLK_STS_DM_REQUEUE;
                         /*FALLTHRU*/
                 case DM_ENDIO_DONE:
                         break;
@@ -1094,11 +1094,11 @@ static void __map_bio(struct dm_target_io *tio)
                 generic_make_request(clone);
                 break;
         case DM_MAPIO_KILL:
-                r = -EIO;
-                /*FALLTHRU*/
+                dec_pending(tio->io, BLK_STS_IOERR);
+                free_tio(tio);
+                break;
         case DM_MAPIO_REQUEUE:
-                /* error the io and bail out, or requeue it if needed */
-                dec_pending(tio->io, r);
+                dec_pending(tio->io, BLK_STS_DM_REQUEUE);
                 free_tio(tio);
                 break;
         default:
@@ -1366,7 +1366,7 @@ static void __split_and_process_bio(struct mapped_device *md,
         ci.map = map;
         ci.md = md;
         ci.io = alloc_io(md);
-        ci.io->error = 0;
+        ci.io->status = 0;
         atomic_set(&ci.io->io_count, 1);
         ci.io->bio = bio;
         ci.io->md = md;