block: add a bi_error field to struct bio

Currently we have two different ways to signal an I/O error on a BIO:

 (1) by clearing the BIO_UPTODATE flag
 (2) by returning a Linux errno value to the bi_end_io callback

The first one has the drawback of only communicating a single possible
error (-EIO), and the second one has the drawback of not beeing persistent
when bios are queued up, and are not passed along from child to parent
bio in the ever more popular chaining scenario.  Having both mechanisms
available has the additional drawback of utterly confusing driver authors
and introducing bugs where various I/O submitters only deal with one of
them, and the others have to add boilerplate code to deal with both kinds
of error returns.

So add a new bi_error field to store an errno value directly in struct
bio and remove the existing mechanisms to clean all this up.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: NeilBrown <neilb@suse.com>
Signed-off-by: Jens Axboe <axboe@fb.com>

7 files changed, 62 insertions, 72 deletions

diff --git a/block/bio-integrity.c b/block/bio-integrity.c
index 719b7152aed1..4aecca79374a 100644
--- a/block/bio-integrity.c
+++ b/block/bio-integrity.c
@@ -355,13 +355,12 @@ static void bio_integrity_verify_fn(struct work_struct *work)
                 container_of(work, struct bio_integrity_payload, bip_work);
         struct bio *bio = bip->bip_bio;
         struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
-        int error;
 
-        error = bio_integrity_process(bio, bi->verify_fn);
+        bio->bi_error = bio_integrity_process(bio, bi->verify_fn);
 
         /* Restore original bio completion handler */
         bio->bi_end_io = bip->bip_end_io;
-        bio_endio(bio, error);
+        bio_endio(bio);
 }
 
 /**
@@ -376,7 +375,7 @@ static void bio_integrity_verify_fn(struct work_struct *work)
  * in process context.  This function postpones completion
  * accordingly.
  */
-void bio_integrity_endio(struct bio *bio, int error)
+void bio_integrity_endio(struct bio *bio)
 {
         struct bio_integrity_payload *bip = bio_integrity(bio);
 
@@ -386,9 +385,9 @@ void bio_integrity_endio(struct bio *bio, int error)
          * integrity metadata.  Restore original bio end_io handler
          * and run it.
          */
-        if (error) {
+        if (bio->bi_error) {
                 bio->bi_end_io = bip->bip_end_io;
-                bio_endio(bio, error);
+                bio_endio(bio);
 
                 return;
         }
diff --git a/block/bio.c b/block/bio.c
index 2a00d349cd68..a23f489f398f 100644
--- a/block/bio.c
+++ b/block/bio.c
@@ -269,7 +269,6 @@ static void bio_free(struct bio *bio)
 void bio_init(struct bio *bio)
 {
         memset(bio, 0, sizeof(*bio));
-        bio->bi_flags = 1 << BIO_UPTODATE;
         atomic_set(&bio->__bi_remaining, 1);
         atomic_set(&bio->__bi_cnt, 1);
 }
@@ -292,14 +291,17 @@ void bio_reset(struct bio *bio)
         __bio_free(bio);
 
         memset(bio, 0, BIO_RESET_BYTES);
-        bio->bi_flags = flags | (1 << BIO_UPTODATE);
+        bio->bi_flags = flags;
         atomic_set(&bio->__bi_remaining, 1);
 }
 EXPORT_SYMBOL(bio_reset);
 
-static void bio_chain_endio(struct bio *bio, int error)
+static void bio_chain_endio(struct bio *bio)
 {
-        bio_endio(bio->bi_private, error);
+        struct bio *parent = bio->bi_private;
+
+        parent->bi_error = bio->bi_error;
+        bio_endio(parent);
         bio_put(bio);
 }
 
@@ -896,11 +898,11 @@ struct submit_bio_ret {
         int error;
 };
 
-static void submit_bio_wait_endio(struct bio *bio, int error)
+static void submit_bio_wait_endio(struct bio *bio)
 {
         struct submit_bio_ret *ret = bio->bi_private;
 
-        ret->error = error;
+        ret->error = bio->bi_error;
         complete(&ret->event);
 }
 
@@ -1445,7 +1447,7 @@ void bio_unmap_user(struct bio *bio)
 }
 EXPORT_SYMBOL(bio_unmap_user);
 
-static void bio_map_kern_endio(struct bio *bio, int err)
+static void bio_map_kern_endio(struct bio *bio)
 {
         bio_put(bio);
 }
@@ -1501,13 +1503,13 @@ struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
 }
 EXPORT_SYMBOL(bio_map_kern);
 
-static void bio_copy_kern_endio(struct bio *bio, int err)
+static void bio_copy_kern_endio(struct bio *bio)
 {
         bio_free_pages(bio);
         bio_put(bio);
 }
 
-static void bio_copy_kern_endio_read(struct bio *bio, int err)
+static void bio_copy_kern_endio_read(struct bio *bio)
 {
         char *p = bio->bi_private;
         struct bio_vec *bvec;
@@ -1518,7 +1520,7 @@ static void bio_copy_kern_endio_read(struct bio *bio, int err)
                 p += bvec->bv_len;
         }
 
-        bio_copy_kern_endio(bio, err);
+        bio_copy_kern_endio(bio);
 }
 
 /**
@@ -1778,25 +1780,15 @@ static inline bool bio_remaining_done(struct bio *bio)
 /**
  * bio_endio - end I/O on a bio
  * @bio:        bio
- * @error:      error, if any
  *
  * Description:
- *   bio_endio() will end I/O on the whole bio. bio_endio() is the
- *   preferred way to end I/O on a bio, it takes care of clearing
- *   BIO_UPTODATE on error. @error is 0 on success, and and one of the
- *   established -Exxxx (-EIO, for instance) error values in case
- *   something went wrong. No one should call bi_end_io() directly on a
- *   bio unless they own it and thus know that it has an end_io
- *   function.
+ *   bio_endio() will end I/O on the whole bio. bio_endio() is the preferred
+ *   way to end I/O on a bio. No one should call bi_end_io() directly on a
+ *   bio unless they own it and thus know that it has an end_io function.
  **/
-void bio_endio(struct bio *bio, int error)
+void bio_endio(struct bio *bio)
 {
         while (bio) {
-                if (error)
-                        clear_bit(BIO_UPTODATE, &bio->bi_flags);
-                else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
-                        error = -EIO;
-
                 if (unlikely(!bio_remaining_done(bio)))
                         break;
 
@@ -1810,11 +1802,12 @@ void bio_endio(struct bio *bio, int error)
                  */
                 if (bio->bi_end_io == bio_chain_endio) {
                         struct bio *parent = bio->bi_private;
+                        parent->bi_error = bio->bi_error;
                         bio_put(bio);
                         bio = parent;
                 } else {
                         if (bio->bi_end_io)
-                                bio->bi_end_io(bio, error);
+                                bio->bi_end_io(bio);
                         bio = NULL;
                 }
         }
diff --git a/block/blk-core.c b/block/blk-core.c
index 627ed0c593fb..7ef15b947b91 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -143,9 +143,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
                           unsigned int nbytes, int error)
 {
         if (error)
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
-        else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
-                error = -EIO;
+                bio->bi_error = error;
 
         if (unlikely(rq->cmd_flags & REQ_QUIET))
                 set_bit(BIO_QUIET, &bio->bi_flags);
@@ -154,7 +152,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
 
         /* don't actually finish bio if it's part of flush sequence */
         if (bio->bi_iter.bi_size == 0 && !(rq->cmd_flags & REQ_FLUSH_SEQ))
-                bio_endio(bio, error);
+                bio_endio(bio);
 }
 
 void blk_dump_rq_flags(struct request *rq, char *msg)
@@ -1620,7 +1618,8 @@ static void blk_queue_bio(struct request_queue *q, struct bio *bio)
         blk_queue_bounce(q, &bio);
 
         if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
-                bio_endio(bio, -EIO);
+                bio->bi_error = -EIO;
+                bio_endio(bio);
                 return;
         }
 
@@ -1673,7 +1672,8 @@ get_rq:
          */
         req = get_request(q, rw_flags, bio, GFP_NOIO);
         if (IS_ERR(req)) {
-                bio_endio(bio, PTR_ERR(req));   /* @q is dead */
+                bio->bi_error = PTR_ERR(req);
+                bio_endio(bio);
                 goto out_unlock;
         }
 
@@ -1896,7 +1896,8 @@ generic_make_request_checks(struct bio *bio)
         return true;
 
 end_io:
-        bio_endio(bio, err);
+        bio->bi_error = err;
+        bio_endio(bio);
         return false;
 }
 
diff --git a/block/blk-lib.c b/block/blk-lib.c
index 7688ee3f5d72..6dee17443f14 100644
--- a/block/blk-lib.c
+++ b/block/blk-lib.c
@@ -11,16 +11,16 @@
 
 struct bio_batch {
         atomic_t                done;
-        unsigned long           flags;
+        int                     error;
         struct completion       *wait;
 };
 
-static void bio_batch_end_io(struct bio *bio, int err)
+static void bio_batch_end_io(struct bio *bio)
 {
         struct bio_batch *bb = bio->bi_private;
 
-        if (err && (err != -EOPNOTSUPP))
-                clear_bit(BIO_UPTODATE, &bb->flags);
+        if (bio->bi_error && bio->bi_error != -EOPNOTSUPP)
+                bb->error = bio->bi_error;
         if (atomic_dec_and_test(&bb->done))
                 complete(bb->wait);
         bio_put(bio);
@@ -78,7 +78,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
         }
 
         atomic_set(&bb.done, 1);
-        bb.flags = 1 << BIO_UPTODATE;
+        bb.error = 0;
         bb.wait = &wait;
 
         blk_start_plug(&plug);
@@ -134,9 +134,8 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
         if (!atomic_dec_and_test(&bb.done))
                 wait_for_completion_io(&wait);
 
-        if (!test_bit(BIO_UPTODATE, &bb.flags))
-                ret = -EIO;
-
+        if (bb.error)
+                return bb.error;
         return ret;
 }
 EXPORT_SYMBOL(blkdev_issue_discard);
@@ -172,7 +171,7 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
                 return -EOPNOTSUPP;
 
         atomic_set(&bb.done, 1);
-        bb.flags = 1 << BIO_UPTODATE;
+        bb.error = 0;
         bb.wait = &wait;
 
         while (nr_sects) {
@@ -208,9 +207,8 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
         if (!atomic_dec_and_test(&bb.done))
                 wait_for_completion_io(&wait);
 
-        if (!test_bit(BIO_UPTODATE, &bb.flags))
-                ret = -ENOTSUPP;
-
+        if (bb.error)
+                return bb.error;
         return ret;
 }
 EXPORT_SYMBOL(blkdev_issue_write_same);
@@ -236,7 +234,7 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
         DECLARE_COMPLETION_ONSTACK(wait);
 
         atomic_set(&bb.done, 1);
-        bb.flags = 1 << BIO_UPTODATE;
+        bb.error = 0;
         bb.wait = &wait;
 
         ret = 0;
@@ -270,10 +268,8 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
         if (!atomic_dec_and_test(&bb.done))
                 wait_for_completion_io(&wait);
 
-        if (!test_bit(BIO_UPTODATE, &bb.flags))
-                /* One of bios in the batch was completed with error.*/
-                ret = -EIO;
-
+        if (bb.error)
+                return bb.error;
         return ret;
 }
 
diff --git a/block/blk-map.c b/block/blk-map.c
index da310a105429..5fe1c30bfba7 100644
--- a/block/blk-map.c
+++ b/block/blk-map.c
@@ -103,7 +103,7 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
                  * normal IO completion path
                  */
                 bio_get(bio);
-                bio_endio(bio, 0);
+                bio_endio(bio);
                 __blk_rq_unmap_user(bio);
                 return -EINVAL;
         }
diff --git a/block/blk-mq.c b/block/blk-mq.c
index 7d842db59699..94559025c5e6 100644
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -1199,7 +1199,7 @@ static struct request *blk_mq_map_request(struct request_queue *q,
         struct blk_mq_alloc_data alloc_data;
 
         if (unlikely(blk_mq_queue_enter(q, GFP_KERNEL))) {
-                bio_endio(bio, -EIO);
+                bio_io_error(bio);
                 return NULL;
         }
 
@@ -1283,7 +1283,7 @@ static void blk_mq_make_request(struct request_queue *q, struct bio *bio)
         blk_queue_bounce(q, &bio);
 
         if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
-                bio_endio(bio, -EIO);
+                bio_io_error(bio);
                 return;
         }
 
@@ -1368,7 +1368,7 @@ static void blk_sq_make_request(struct request_queue *q, struct bio *bio)
         blk_queue_bounce(q, &bio);
 
         if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
-                bio_endio(bio, -EIO);
+                bio_io_error(bio);
                 return;
         }
 
diff --git a/block/bounce.c b/block/bounce.c
index b17311227c12..f4db245b9f3a 100644
--- a/block/bounce.c
+++ b/block/bounce.c
@@ -123,7 +123,7 @@ static void copy_to_high_bio_irq(struct bio *to, struct bio *from)
         }
 }
 
-static void bounce_end_io(struct bio *bio, mempool_t *pool, int err)
+static void bounce_end_io(struct bio *bio, mempool_t *pool)
 {
         struct bio *bio_orig = bio->bi_private;
         struct bio_vec *bvec, *org_vec;
@@ -141,39 +141,40 @@ static void bounce_end_io(struct bio *bio, mempool_t *pool, int err)
                 mempool_free(bvec->bv_page, pool);
         }
 
-        bio_endio(bio_orig, err);
+        bio_orig->bi_error = bio->bi_error;
+        bio_endio(bio_orig);
         bio_put(bio);
 }
 
-static void bounce_end_io_write(struct bio *bio, int err)
+static void bounce_end_io_write(struct bio *bio)
 {
-        bounce_end_io(bio, page_pool, err);
+        bounce_end_io(bio, page_pool);
 }
 
-static void bounce_end_io_write_isa(struct bio *bio, int err)
+static void bounce_end_io_write_isa(struct bio *bio)
 {
 
-        bounce_end_io(bio, isa_page_pool, err);
+        bounce_end_io(bio, isa_page_pool);
 }
 
-static void __bounce_end_io_read(struct bio *bio, mempool_t *pool, int err)
+static void __bounce_end_io_read(struct bio *bio, mempool_t *pool)
 {
         struct bio *bio_orig = bio->bi_private;
 
-        if (test_bit(BIO_UPTODATE, &bio->bi_flags))
+        if (!bio->bi_error)
                 copy_to_high_bio_irq(bio_orig, bio);
 
-        bounce_end_io(bio, pool, err);
+        bounce_end_io(bio, pool);
 }
 
-static void bounce_end_io_read(struct bio *bio, int err)
+static void bounce_end_io_read(struct bio *bio)
 {
-        __bounce_end_io_read(bio, page_pool, err);
+        __bounce_end_io_read(bio, page_pool);
 }
 
-static void bounce_end_io_read_isa(struct bio *bio, int err)
+static void bounce_end_io_read_isa(struct bio *bio)
 {
-        __bounce_end_io_read(bio, isa_page_pool, err);
+        __bounce_end_io_read(bio, isa_page_pool);
 }
 
 #ifdef CONFIG_NEED_BOUNCE_POOL