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>

1 files changed, 23 insertions, 18 deletions

diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index c33f61a4cc28..2ade2c46dca9 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -614,8 +614,10 @@ static void error_bio_list(struct bio_list *bios, int error)
 {
         struct bio *bio;
 
-        while ((bio = bio_list_pop(bios)))
-                bio_endio(bio, error);
+        while ((bio = bio_list_pop(bios))) {
+                bio->bi_error = error;
+                bio_endio(bio);
+        }
 }
 
 static void error_thin_bio_list(struct thin_c *tc, struct bio_list *master, int error)
@@ -864,14 +866,14 @@ static void copy_complete(int read_err, unsigned long write_err, void *context)
         complete_mapping_preparation(m);
 }
 
-static void overwrite_endio(struct bio *bio, int err)
+static void overwrite_endio(struct bio *bio)
 {
         struct dm_thin_endio_hook *h = dm_per_bio_data(bio, sizeof(struct dm_thin_endio_hook));
         struct dm_thin_new_mapping *m = h->overwrite_mapping;
 
         bio->bi_end_io = m->saved_bi_end_io;
 
-        m->err = err;
+        m->err = bio->bi_error;
         complete_mapping_preparation(m);
 }
 
@@ -996,7 +998,7 @@ static void process_prepared_mapping(struct dm_thin_new_mapping *m)
          */
         if (bio) {
                 inc_remap_and_issue_cell(tc, m->cell, m->data_block);
-                bio_endio(bio, 0);
+                bio_endio(bio);
         } else {
                 inc_all_io_entry(tc->pool, m->cell->holder);
                 remap_and_issue(tc, m->cell->holder, m->data_block);
@@ -1026,7 +1028,7 @@ static void process_prepared_discard_fail(struct dm_thin_new_mapping *m)
 
 static void process_prepared_discard_success(struct dm_thin_new_mapping *m)
 {
-        bio_endio(m->bio, 0);
+        bio_endio(m->bio);
         free_discard_mapping(m);
 }
 
@@ -1040,7 +1042,7 @@ static void process_prepared_discard_no_passdown(struct dm_thin_new_mapping *m)
                 metadata_operation_failed(tc->pool, "dm_thin_remove_range", r);
                 bio_io_error(m->bio);
         } else
-                bio_endio(m->bio, 0);
+                bio_endio(m->bio);
 
         cell_defer_no_holder(tc, m->cell);
         mempool_free(m, tc->pool->mapping_pool);
@@ -1111,7 +1113,8 @@ static void process_prepared_discard_passdown(struct dm_thin_new_mapping *m)
          * Even if r is set, there could be sub discards in flight that we
          * need to wait for.
          */
-        bio_endio(m->bio, r);
+        m->bio->bi_error = r;
+        bio_endio(m->bio);
         cell_defer_no_holder(tc, m->cell);
         mempool_free(m, pool->mapping_pool);
 }
@@ -1487,9 +1490,10 @@ static void handle_unserviceable_bio(struct pool *pool, struct bio *bio)
 {
         int error = should_error_unserviceable_bio(pool);
 
-        if (error)
-                bio_endio(bio, error);
-        else
+        if (error) {
+                bio->bi_error = error;
+                bio_endio(bio);
+        } else
                 retry_on_resume(bio);
 }
 
@@ -1625,7 +1629,7 @@ static void process_discard_cell_passdown(struct thin_c *tc, struct dm_bio_priso
          * will prevent completion until the sub range discards have
          * completed.
          */
-        bio_endio(bio, 0);
+        bio_endio(bio);
 }
 
 static void process_discard_bio(struct thin_c *tc, struct bio *bio)
@@ -1639,7 +1643,7 @@ static void process_discard_bio(struct thin_c *tc, struct bio *bio)
                 /*
                  * The discard covers less than a block.
                  */
-                bio_endio(bio, 0);
+                bio_endio(bio);
                 return;
         }
 
@@ -1784,7 +1788,7 @@ static void provision_block(struct thin_c *tc, struct bio *bio, dm_block_t block
         if (bio_data_dir(bio) == READ) {
                 zero_fill_bio(bio);
                 cell_defer_no_holder(tc, cell);
-                bio_endio(bio, 0);
+                bio_endio(bio);
                 return;
         }
 
@@ -1849,7 +1853,7 @@ static void process_cell(struct thin_c *tc, struct dm_bio_prison_cell *cell)
 
                         } else {
                                 zero_fill_bio(bio);
-                                bio_endio(bio, 0);
+                                bio_endio(bio);
                         }
                 } else
                         provision_block(tc, bio, block, cell);
@@ -1920,7 +1924,7 @@ static void __process_bio_read_only(struct thin_c *tc, struct bio *bio,
                 }
 
                 zero_fill_bio(bio);
-                bio_endio(bio, 0);
+                bio_endio(bio);
                 break;
 
         default:
@@ -1945,7 +1949,7 @@ static void process_cell_read_only(struct thin_c *tc, struct dm_bio_prison_cell
 
 static void process_bio_success(struct thin_c *tc, struct bio *bio)
 {
-        bio_endio(bio, 0);
+        bio_endio(bio);
 }
 
 static void process_bio_fail(struct thin_c *tc, struct bio *bio)
@@ -2581,7 +2585,8 @@ static int thin_bio_map(struct dm_target *ti, struct bio *bio)
         thin_hook_bio(tc, bio);
 
         if (tc->requeue_mode) {
-                bio_endio(bio, DM_ENDIO_REQUEUE);
+                bio->bi_error = DM_ENDIO_REQUEUE;
+                bio_endio(bio);
                 return DM_MAPIO_SUBMITTED;
         }