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>

24 files changed, 187 insertions, 205 deletions

diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index ce7dec88f4b8..541fbfaed276 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -343,7 +343,7 @@ static int btrfsic_process_written_superblock(
                 struct btrfsic_state *state,
                 struct btrfsic_block *const block,
                 struct btrfs_super_block *const super_hdr);
-static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status);
+static void btrfsic_bio_end_io(struct bio *bp);
 static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate);
 static int btrfsic_is_block_ref_by_superblock(const struct btrfsic_state *state,
                                               const struct btrfsic_block *block,
@@ -2207,7 +2207,7 @@ continue_loop:
         goto again;
 }
 
-static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status)
+static void btrfsic_bio_end_io(struct bio *bp)
 {
         struct btrfsic_block *block = (struct btrfsic_block *)bp->bi_private;
         int iodone_w_error;
@@ -2215,7 +2215,7 @@ static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status)
         /* mutex is not held! This is not save if IO is not yet completed
          * on umount */
         iodone_w_error = 0;
-        if (bio_error_status)
+        if (bp->bi_error)
                 iodone_w_error = 1;
 
         BUG_ON(NULL == block);
@@ -2230,7 +2230,7 @@ static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status)
                      BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
                         printk(KERN_INFO
                                "bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n",
-                               bio_error_status,
+                               bp->bi_error,
                                btrfsic_get_block_type(dev_state->state, block),
                                block->logical_bytenr, dev_state->name,
                                block->dev_bytenr, block->mirror_num);
@@ -2252,7 +2252,7 @@ static void btrfsic_bio_end_io(struct bio *bp, int bio_error_status)
                 block = next_block;
         } while (NULL != block);
 
-        bp->bi_end_io(bp, bio_error_status);
+        bp->bi_end_io(bp);
 }
 
 static void btrfsic_bh_end_io(struct buffer_head *bh, int uptodate)
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index ce62324c78e7..302266ec2cdb 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -152,7 +152,7 @@ fail:
  * The compressed pages are freed here, and it must be run
  * in process context
  */
-static void end_compressed_bio_read(struct bio *bio, int err)
+static void end_compressed_bio_read(struct bio *bio)
 {
         struct compressed_bio *cb = bio->bi_private;
         struct inode *inode;
@@ -160,7 +160,7 @@ static void end_compressed_bio_read(struct bio *bio, int err)
         unsigned long index;
         int ret;
 
-        if (err)
+        if (bio->bi_error)
                 cb->errors = 1;
 
         /* if there are more bios still pending for this compressed
@@ -210,7 +210,7 @@ csum_failed:
                 bio_for_each_segment_all(bvec, cb->orig_bio, i)
                         SetPageChecked(bvec->bv_page);
 
-                bio_endio(cb->orig_bio, 0);
+                bio_endio(cb->orig_bio);
         }
 
         /* finally free the cb struct */
@@ -266,7 +266,7 @@ static noinline void end_compressed_writeback(struct inode *inode,
  * This also calls the writeback end hooks for the file pages so that
  * metadata and checksums can be updated in the file.
  */
-static void end_compressed_bio_write(struct bio *bio, int err)
+static void end_compressed_bio_write(struct bio *bio)
 {
         struct extent_io_tree *tree;
         struct compressed_bio *cb = bio->bi_private;
@@ -274,7 +274,7 @@ static void end_compressed_bio_write(struct bio *bio, int err)
         struct page *page;
         unsigned long index;
 
-        if (err)
+        if (bio->bi_error)
                 cb->errors = 1;
 
         /* if there are more bios still pending for this compressed
@@ -293,7 +293,7 @@ static void end_compressed_bio_write(struct bio *bio, int err)
                                          cb->start,
                                          cb->start + cb->len - 1,
                                          NULL,
-                                         err ? 0 : 1);
+                                         bio->bi_error ? 0 : 1);
         cb->compressed_pages[0]->mapping = NULL;
 
         end_compressed_writeback(inode, cb);
@@ -697,8 +697,10 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 
                         ret = btrfs_map_bio(root, READ, comp_bio,
                                             mirror_num, 0);
-                        if (ret)
-                                bio_endio(comp_bio, ret);
+                        if (ret) {
+                                bio->bi_error = ret;
+                                bio_endio(comp_bio);
+                        }
 
                         bio_put(comp_bio);
 
@@ -724,8 +726,10 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         }
 
         ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
-        if (ret)
-                bio_endio(comp_bio, ret);
+        if (ret) {
+                bio->bi_error = ret;
+                bio_endio(comp_bio);
+        }
 
         bio_put(comp_bio);
         return 0;
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index a9aadb2ad525..a8c0de888a9d 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -703,7 +703,7 @@ static int btree_io_failed_hook(struct page *page, int failed_mirror)
         return -EIO;    /* we fixed nothing */
 }
 
-static void end_workqueue_bio(struct bio *bio, int err)
+static void end_workqueue_bio(struct bio *bio)
 {
         struct btrfs_end_io_wq *end_io_wq = bio->bi_private;
         struct btrfs_fs_info *fs_info;
@@ -711,7 +711,7 @@ static void end_workqueue_bio(struct bio *bio, int err)
         btrfs_work_func_t func;
 
         fs_info = end_io_wq->info;
-        end_io_wq->error = err;
+        end_io_wq->error = bio->bi_error;
 
         if (bio->bi_rw & REQ_WRITE) {
                 if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
@@ -808,7 +808,8 @@ static void run_one_async_done(struct btrfs_work *work)
 
         /* If an error occured we just want to clean up the bio and move on */
         if (async->error) {
-                bio_endio(async->bio, async->error);
+                async->bio->bi_error = async->error;
+                bio_endio(async->bio);
                 return;
         }
 
@@ -908,8 +909,10 @@ static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
          * submission context.  Just jump into btrfs_map_bio
          */
         ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
-        if (ret)
-                bio_endio(bio, ret);
+        if (ret) {
+                bio->bi_error = ret;
+                bio_endio(bio);
+        }
         return ret;
 }
 
@@ -960,10 +963,13 @@ static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
                                           __btree_submit_bio_done);
         }
 
-        if (ret) {
+        if (ret)
+                goto out_w_error;
+        return 0;
+
 out_w_error:
-                bio_endio(bio, ret);
-        }
+        bio->bi_error = ret;
+        bio_endio(bio);
         return ret;
 }
 
@@ -1735,16 +1741,15 @@ static void end_workqueue_fn(struct btrfs_work *work)
 {
         struct bio *bio;
         struct btrfs_end_io_wq *end_io_wq;
-        int error;
 
         end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
         bio = end_io_wq->bio;
 
-        error = end_io_wq->error;
+        bio->bi_error = end_io_wq->error;
         bio->bi_private = end_io_wq->private;
         bio->bi_end_io = end_io_wq->end_io;
         kmem_cache_free(btrfs_end_io_wq_cache, end_io_wq);
-        bio_endio(bio, error);
+        bio_endio(bio);
 }
 
 static int cleaner_kthread(void *arg)
@@ -3323,10 +3328,8 @@ static int write_dev_supers(struct btrfs_device *device,
  * endio for the write_dev_flush, this will wake anyone waiting
  * for the barrier when it is done
  */
-static void btrfs_end_empty_barrier(struct bio *bio, int err)
+static void btrfs_end_empty_barrier(struct bio *bio)
 {
-        if (err)
-                clear_bit(BIO_UPTODATE, &bio->bi_flags);
         if (bio->bi_private)
                 complete(bio->bi_private);
         bio_put(bio);
@@ -3354,8 +3357,8 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
 
                 wait_for_completion(&device->flush_wait);
 
-                if (!bio_flagged(bio, BIO_UPTODATE)) {
-                        ret = -EIO;
+                if (bio->bi_error) {
+                        ret = bio->bi_error;
                         btrfs_dev_stat_inc_and_print(device,
                                 BTRFS_DEV_STAT_FLUSH_ERRS);
                 }
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 02d05817cbdf..c22f175ed024 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2486,7 +2486,7 @@ int end_extent_writepage(struct page *page, int err, u64 start, u64 end)
  * Scheduling is not allowed, so the extent state tree is expected
  * to have one and only one object corresponding to this IO.
  */
-static void end_bio_extent_writepage(struct bio *bio, int err)
+static void end_bio_extent_writepage(struct bio *bio)
 {
         struct bio_vec *bvec;
         u64 start;
@@ -2516,7 +2516,7 @@ static void end_bio_extent_writepage(struct bio *bio, int err)
                 start = page_offset(page);
                 end = start + bvec->bv_offset + bvec->bv_len - 1;
 
-                if (end_extent_writepage(page, err, start, end))
+                if (end_extent_writepage(page, bio->bi_error, start, end))
                         continue;
 
                 end_page_writeback(page);
@@ -2548,10 +2548,10 @@ endio_readpage_release_extent(struct extent_io_tree *tree, u64 start, u64 len,
  * Scheduling is not allowed, so the extent state tree is expected
  * to have one and only one object corresponding to this IO.
  */
-static void end_bio_extent_readpage(struct bio *bio, int err)
+static void end_bio_extent_readpage(struct bio *bio)
 {
         struct bio_vec *bvec;
-        int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
+        int uptodate = !bio->bi_error;
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
         struct extent_io_tree *tree;
         u64 offset = 0;
@@ -2564,16 +2564,13 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
         int ret;
         int i;
 
-        if (err)
-                uptodate = 0;
-
         bio_for_each_segment_all(bvec, bio, i) {
                 struct page *page = bvec->bv_page;
                 struct inode *inode = page->mapping->host;
 
                 pr_debug("end_bio_extent_readpage: bi_sector=%llu, err=%d, "
-                         "mirror=%u\n", (u64)bio->bi_iter.bi_sector, err,
-                         io_bio->mirror_num);
+                         "mirror=%u\n", (u64)bio->bi_iter.bi_sector,
+                         bio->bi_error, io_bio->mirror_num);
                 tree = &BTRFS_I(inode)->io_tree;
 
                 /* We always issue full-page reads, but if some block
@@ -2614,8 +2611,7 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
 
                 if (tree->ops && tree->ops->readpage_io_failed_hook) {
                         ret = tree->ops->readpage_io_failed_hook(page, mirror);
-                        if (!ret && !err &&
-                            test_bit(BIO_UPTODATE, &bio->bi_flags))
+                        if (!ret && !bio->bi_error)
                                 uptodate = 1;
                 } else {
                         /*
@@ -2631,10 +2627,7 @@ static void end_bio_extent_readpage(struct bio *bio, int err)
                         ret = bio_readpage_error(bio, offset, page, start, end,
                                                  mirror);
                         if (ret == 0) {
-                                uptodate =
-                                        test_bit(BIO_UPTODATE, &bio->bi_flags);
-                                if (err)
-                                        uptodate = 0;
+                                uptodate = !bio->bi_error;
                                 offset += len;
                                 continue;
                         }
@@ -2684,7 +2677,7 @@ readpage_ok:
                 endio_readpage_release_extent(tree, extent_start, extent_len,
                                               uptodate);
         if (io_bio->end_io)
-                io_bio->end_io(io_bio, err);
+                io_bio->end_io(io_bio, bio->bi_error);
         bio_put(bio);
 }
 
@@ -3696,7 +3689,7 @@ static void set_btree_ioerr(struct page *page)
         }
 }
 
-static void end_bio_extent_buffer_writepage(struct bio *bio, int err)
+static void end_bio_extent_buffer_writepage(struct bio *bio)
 {
         struct bio_vec *bvec;
         struct extent_buffer *eb;
@@ -3709,7 +3702,8 @@ static void end_bio_extent_buffer_writepage(struct bio *bio, int err)
                 BUG_ON(!eb);
                 done = atomic_dec_and_test(&eb->io_pages);
 
-                if (err || test_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags)) {
+                if (bio->bi_error ||
+                    test_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags)) {
                         ClearPageUptodate(page);
                         set_btree_ioerr(page);
                 }
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index b33c0cf02668..6b8becfe2057 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1845,8 +1845,10 @@ static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
         int ret;
 
         ret = btrfs_map_bio(root, rw, bio, mirror_num, 1);
-        if (ret)
-                bio_endio(bio, ret);
+        if (ret) {
+                bio->bi_error = ret;
+                bio_endio(bio);
+        }
         return ret;
 }
 
@@ -1906,8 +1908,10 @@ mapit:
         ret = btrfs_map_bio(root, rw, bio, mirror_num, 0);
 
 out:
-        if (ret < 0)
-                bio_endio(bio, ret);
+        if (ret < 0) {
+                bio->bi_error = ret;
+                bio_endio(bio);
+        }
         return ret;
 }
 
@@ -7689,13 +7693,13 @@ struct btrfs_retry_complete {
         int uptodate;
 };
 
-static void btrfs_retry_endio_nocsum(struct bio *bio, int err)
+static void btrfs_retry_endio_nocsum(struct bio *bio)
 {
         struct btrfs_retry_complete *done = bio->bi_private;
         struct bio_vec *bvec;
         int i;
 
-        if (err)
+        if (bio->bi_error)
                 goto end;
 
         done->uptodate = 1;
@@ -7744,7 +7748,7 @@ try_again:
         return 0;
 }
 
-static void btrfs_retry_endio(struct bio *bio, int err)
+static void btrfs_retry_endio(struct bio *bio)
 {
         struct btrfs_retry_complete *done = bio->bi_private;
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
@@ -7753,7 +7757,7 @@ static void btrfs_retry_endio(struct bio *bio, int err)
         int ret;
         int i;
 
-        if (err)
+        if (bio->bi_error)
                 goto end;
 
         uptodate = 1;
@@ -7836,12 +7840,13 @@ static int btrfs_subio_endio_read(struct inode *inode,
         }
 }
 
-static void btrfs_endio_direct_read(struct bio *bio, int err)
+static void btrfs_endio_direct_read(struct bio *bio)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
         struct inode *inode = dip->inode;
         struct bio *dio_bio;
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
+        int err = bio->bi_error;
 
         if (dip->flags & BTRFS_DIO_ORIG_BIO_SUBMITTED)
                 err = btrfs_subio_endio_read(inode, io_bio, err);
@@ -7852,17 +7857,14 @@ static void btrfs_endio_direct_read(struct bio *bio, int err)
 
         kfree(dip);
 
-        /* If we had a csum failure make sure to clear the uptodate flag */
-        if (err)
-                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
-        dio_end_io(dio_bio, err);
+        dio_end_io(dio_bio, bio->bi_error);
 
         if (io_bio->end_io)
                 io_bio->end_io(io_bio, err);
         bio_put(bio);
 }
 
-static void btrfs_endio_direct_write(struct bio *bio, int err)
+static void btrfs_endio_direct_write(struct bio *bio)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
         struct inode *inode = dip->inode;
@@ -7876,7 +7878,8 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
 again:
         ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
                                                    &ordered_offset,
-                                                   ordered_bytes, !err);
+                                                   ordered_bytes,
+                                                   !bio->bi_error);
         if (!ret)
                 goto out_test;
 
@@ -7899,10 +7902,7 @@ out_test:
 
         kfree(dip);
 
-        /* If we had an error make sure to clear the uptodate flag */
-        if (err)
-                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
-        dio_end_io(dio_bio, err);
+        dio_end_io(dio_bio, bio->bi_error);
         bio_put(bio);
 }
 
@@ -7917,9 +7917,10 @@ static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw,
         return 0;
 }
 
-static void btrfs_end_dio_bio(struct bio *bio, int err)
+static void btrfs_end_dio_bio(struct bio *bio)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
+        int err = bio->bi_error;
 
         if (err)
                 btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
@@ -7948,8 +7949,8 @@ static void btrfs_end_dio_bio(struct bio *bio, int err)
         if (dip->errors) {
                 bio_io_error(dip->orig_bio);
         } else {
-                set_bit(BIO_UPTODATE, &dip->dio_bio->bi_flags);
-                bio_endio(dip->orig_bio, 0);
+                dip->dio_bio->bi_error = 0;
+                bio_endio(dip->orig_bio);
         }
 out:
         bio_put(bio);
@@ -8220,7 +8221,8 @@ free_ordered:
          * callbacks - they require an allocated dip and a clone of dio_bio.
          */
         if (io_bio && dip) {
-                bio_endio(io_bio, ret);
+                io_bio->bi_error = -EIO;
+                bio_endio(io_bio);
                 /*
                  * The end io callbacks free our dip, do the final put on io_bio
                  * and all the cleanup and final put for dio_bio (through
@@ -8247,7 +8249,7 @@ free_ordered:
                         unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
                               file_offset + dio_bio->bi_iter.bi_size - 1);
                 }
-                clear_bit(BIO_UPTODATE, &dio_bio->bi_flags);
+                dio_bio->bi_error = -EIO;
                 /*
                  * Releases and cleans up our dio_bio, no need to bio_put()
                  * nor bio_endio()/bio_io_error() against dio_bio.
diff --git a/fs/btrfs/raid56.c b/fs/btrfs/raid56.c
index fa72068bd256..0a02e24900aa 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -851,7 +851,7 @@ static void free_raid_bio(struct btrfs_raid_bio *rbio)
  * this frees the rbio and runs through all the bios in the
  * bio_list and calls end_io on them
  */
-static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err, int uptodate)
+static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err)
 {
         struct bio *cur = bio_list_get(&rbio->bio_list);
         struct bio *next;
@@ -864,9 +864,8 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err, int uptodate)
         while (cur) {
                 next = cur->bi_next;
                 cur->bi_next = NULL;
-                if (uptodate)
-                        set_bit(BIO_UPTODATE, &cur->bi_flags);
-                bio_endio(cur, err);
+                cur->bi_error = err;
+                bio_endio(cur);
                 cur = next;
         }
 }
@@ -875,9 +874,10 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err, int uptodate)
  * end io function used by finish_rmw.  When we finally
  * get here, we've written a full stripe
  */
-static void raid_write_end_io(struct bio *bio, int err)
+static void raid_write_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
+        int err = bio->bi_error;
 
         if (err)
                 fail_bio_stripe(rbio, bio);
@@ -893,7 +893,7 @@ static void raid_write_end_io(struct bio *bio, int err)
         if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
                 err = -EIO;
 
-        rbio_orig_end_io(rbio, err, 0);
+        rbio_orig_end_io(rbio, err);
         return;
 }
 
@@ -1071,7 +1071,7 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
                  * devices or if they are not contiguous
                  */
                 if (last_end == disk_start && stripe->dev->bdev &&
-                    test_bit(BIO_UPTODATE, &last->bi_flags) &&
+                    !last->bi_error &&
                     last->bi_bdev == stripe->dev->bdev) {
                         ret = bio_add_page(last, page, PAGE_CACHE_SIZE, 0);
                         if (ret == PAGE_CACHE_SIZE)
@@ -1087,7 +1087,6 @@ static int rbio_add_io_page(struct btrfs_raid_bio *rbio,
         bio->bi_iter.bi_size = 0;
         bio->bi_bdev = stripe->dev->bdev;
         bio->bi_iter.bi_sector = disk_start >> 9;
-        set_bit(BIO_UPTODATE, &bio->bi_flags);
 
         bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);
         bio_list_add(bio_list, bio);
@@ -1312,13 +1311,12 @@ write_data:
 
                 bio->bi_private = rbio;
                 bio->bi_end_io = raid_write_end_io;
-                BUG_ON(!test_bit(BIO_UPTODATE, &bio->bi_flags));
                 submit_bio(WRITE, bio);
         }
         return;
 
 cleanup:
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
 }
 
 /*
@@ -1441,11 +1439,11 @@ static void set_bio_pages_uptodate(struct bio *bio)
  * This will usually kick off finish_rmw once all the bios are read in, but it
  * may trigger parity reconstruction if we had any errors along the way
  */
-static void raid_rmw_end_io(struct bio *bio, int err)
+static void raid_rmw_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
 
-        if (err)
+        if (bio->bi_error)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
@@ -1455,7 +1453,6 @@ static void raid_rmw_end_io(struct bio *bio, int err)
         if (!atomic_dec_and_test(&rbio->stripes_pending))
                 return;
 
-        err = 0;
         if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
                 goto cleanup;
 
@@ -1469,7 +1466,7 @@ static void raid_rmw_end_io(struct bio *bio, int err)
 
 cleanup:
 
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
 }
 
 static void async_rmw_stripe(struct btrfs_raid_bio *rbio)
@@ -1572,14 +1569,13 @@ static int raid56_rmw_stripe(struct btrfs_raid_bio *rbio)
                 btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                     BTRFS_WQ_ENDIO_RAID56);
 
-                BUG_ON(!test_bit(BIO_UPTODATE, &bio->bi_flags));
                 submit_bio(READ, bio);
         }
         /* the actual write will happen once the reads are done */
         return 0;
 
 cleanup:
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
         return -EIO;
 
 finish:
@@ -1964,7 +1960,7 @@ cleanup_io:
                 else
                         clear_bit(RBIO_CACHE_READY_BIT, &rbio->flags);
 
-                rbio_orig_end_io(rbio, err, err == 0);
+                rbio_orig_end_io(rbio, err);
         } else if (err == 0) {
                 rbio->faila = -1;
                 rbio->failb = -1;
@@ -1976,7 +1972,7 @@ cleanup_io:
                 else
                         BUG();
         } else {
-                rbio_orig_end_io(rbio, err, 0);
+                rbio_orig_end_io(rbio, err);
         }
 }
 
@@ -1984,7 +1980,7 @@ cleanup_io:
  * This is called only for stripes we've read from disk to
  * reconstruct the parity.
  */
-static void raid_recover_end_io(struct bio *bio, int err)
+static void raid_recover_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
 
@@ -1992,7 +1988,7 @@ static void raid_recover_end_io(struct bio *bio, int err)
          * we only read stripe pages off the disk, set them
          * up to date if there were no errors
          */
-        if (err)
+        if (bio->bi_error)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
@@ -2002,7 +1998,7 @@ static void raid_recover_end_io(struct bio *bio, int err)
                 return;
 
         if (atomic_read(&rbio->error) > rbio->bbio->max_errors)
-                rbio_orig_end_io(rbio, -EIO, 0);
+                rbio_orig_end_io(rbio, -EIO);
         else
                 __raid_recover_end_io(rbio);
 }
@@ -2094,7 +2090,6 @@ static int __raid56_parity_recover(struct btrfs_raid_bio *rbio)
                 btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                     BTRFS_WQ_ENDIO_RAID56);
 
-                BUG_ON(!test_bit(BIO_UPTODATE, &bio->bi_flags));
                 submit_bio(READ, bio);
         }
 out:
@@ -2102,7 +2097,7 @@ out:
 
 cleanup:
         if (rbio->operation == BTRFS_RBIO_READ_REBUILD)
-                rbio_orig_end_io(rbio, -EIO, 0);
+                rbio_orig_end_io(rbio, -EIO);
         return -EIO;
 }
 
@@ -2277,11 +2272,12 @@ static int alloc_rbio_essential_pages(struct btrfs_raid_bio *rbio)
  * end io function used by finish_rmw.  When we finally
  * get here, we've written a full stripe
  */
-static void raid_write_parity_end_io(struct bio *bio, int err)
+static void raid_write_parity_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
+        int err = bio->bi_error;
 
-        if (err)
+        if (bio->bi_error)
                 fail_bio_stripe(rbio, bio);
 
         bio_put(bio);
@@ -2294,7 +2290,7 @@ static void raid_write_parity_end_io(struct bio *bio, int err)
         if (atomic_read(&rbio->error))
                 err = -EIO;
 
-        rbio_orig_end_io(rbio, err, 0);
+        rbio_orig_end_io(rbio, err);
 }
 
 static noinline void finish_parity_scrub(struct btrfs_raid_bio *rbio,
@@ -2437,7 +2433,7 @@ submit_write:
         nr_data = bio_list_size(&bio_list);
         if (!nr_data) {
                 /* Every parity is right */
-                rbio_orig_end_io(rbio, 0, 0);
+                rbio_orig_end_io(rbio, 0);
                 return;
         }
 
@@ -2450,13 +2446,12 @@ submit_write:
 
                 bio->bi_private = rbio;
                 bio->bi_end_io = raid_write_parity_end_io;
-                BUG_ON(!test_bit(BIO_UPTODATE, &bio->bi_flags));
                 submit_bio(WRITE, bio);
         }
         return;
 
 cleanup:
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
 }
 
 static inline int is_data_stripe(struct btrfs_raid_bio *rbio, int stripe)
@@ -2524,7 +2519,7 @@ static void validate_rbio_for_parity_scrub(struct btrfs_raid_bio *rbio)
         return;
 
 cleanup:
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
 }
 
 /*
@@ -2535,11 +2530,11 @@ cleanup:
  * This will usually kick off finish_rmw once all the bios are read in, but it
  * may trigger parity reconstruction if we had any errors along the way
  */
-static void raid56_parity_scrub_end_io(struct bio *bio, int err)
+static void raid56_parity_scrub_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
 
-        if (err)
+        if (bio->bi_error)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
@@ -2632,14 +2627,13 @@ static void raid56_parity_scrub_stripe(struct btrfs_raid_bio *rbio)
                 btrfs_bio_wq_end_io(rbio->fs_info, bio,
                                     BTRFS_WQ_ENDIO_RAID56);
 
-                BUG_ON(!test_bit(BIO_UPTODATE, &bio->bi_flags));
                 submit_bio(READ, bio);
         }
         /* the actual write will happen once the reads are done */
         return;
 
 cleanup:
-        rbio_orig_end_io(rbio, -EIO, 0);
+        rbio_orig_end_io(rbio, -EIO);
         return;
 
 finish:
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 94db0fa5225a..ebb8260186fe 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -278,7 +278,7 @@ static int scrub_pages(struct scrub_ctx *sctx, u64 logical, u64 len,
                        u64 physical, struct btrfs_device *dev, u64 flags,
                        u64 gen, int mirror_num, u8 *csum, int force,
                        u64 physical_for_dev_replace);
-static void scrub_bio_end_io(struct bio *bio, int err);
+static void scrub_bio_end_io(struct bio *bio);
 static void scrub_bio_end_io_worker(struct btrfs_work *work);
 static void scrub_block_complete(struct scrub_block *sblock);
 static void scrub_remap_extent(struct btrfs_fs_info *fs_info,
@@ -295,7 +295,7 @@ static void scrub_free_wr_ctx(struct scrub_wr_ctx *wr_ctx);
 static int scrub_add_page_to_wr_bio(struct scrub_ctx *sctx,
                                     struct scrub_page *spage);
 static void scrub_wr_submit(struct scrub_ctx *sctx);
-static void scrub_wr_bio_end_io(struct bio *bio, int err);
+static void scrub_wr_bio_end_io(struct bio *bio);
 static void scrub_wr_bio_end_io_worker(struct btrfs_work *work);
 static int write_page_nocow(struct scrub_ctx *sctx,
                             u64 physical_for_dev_replace, struct page *page);
@@ -1429,11 +1429,11 @@ struct scrub_bio_ret {
         int error;
 };
 
-static void scrub_bio_wait_endio(struct bio *bio, int error)
+static void scrub_bio_wait_endio(struct bio *bio)
 {
         struct scrub_bio_ret *ret = bio->bi_private;
 
-        ret->error = error;
+        ret->error = bio->bi_error;
         complete(&ret->event);
 }
 
@@ -1790,12 +1790,12 @@ static void scrub_wr_submit(struct scrub_ctx *sctx)
         btrfsic_submit_bio(WRITE, sbio->bio);
 }
 
-static void scrub_wr_bio_end_io(struct bio *bio, int err)
+static void scrub_wr_bio_end_io(struct bio *bio)
 {
         struct scrub_bio *sbio = bio->bi_private;
         struct btrfs_fs_info *fs_info = sbio->dev->dev_root->fs_info;
 
-        sbio->err = err;
+        sbio->err = bio->bi_error;
         sbio->bio = bio;
 
         btrfs_init_work(&sbio->work, btrfs_scrubwrc_helper,
@@ -2098,7 +2098,7 @@ static void scrub_submit(struct scrub_ctx *sctx)
                  */
                 printk_ratelimited(KERN_WARNING
                         "BTRFS: scrub_submit(bio bdev == NULL) is unexpected!\n");
-                bio_endio(sbio->bio, -EIO);
+                bio_io_error(sbio->bio);
         } else {
                 btrfsic_submit_bio(READ, sbio->bio);
         }
@@ -2260,12 +2260,12 @@ leave_nomem:
         return 0;
 }
 
-static void scrub_bio_end_io(struct bio *bio, int err)
+static void scrub_bio_end_io(struct bio *bio)
 {
         struct scrub_bio *sbio = bio->bi_private;
         struct btrfs_fs_info *fs_info = sbio->dev->dev_root->fs_info;
 
-        sbio->err = err;
+        sbio->err = bio->bi_error;
         sbio->bio = bio;
 
         btrfs_queue_work(fs_info->scrub_workers, &sbio->work);
@@ -2672,11 +2672,11 @@ static void scrub_parity_bio_endio_worker(struct btrfs_work *work)
         scrub_pending_bio_dec(sctx);
 }
 
-static void scrub_parity_bio_endio(struct bio *bio, int error)
+static void scrub_parity_bio_endio(struct bio *bio)
 {
         struct scrub_parity *sparity = (struct scrub_parity *)bio->bi_private;
 
-        if (error)
+        if (bio->bi_error)
                 bitmap_or(sparity->ebitmap, sparity->ebitmap, sparity->dbitmap,
                           sparity->nsectors);
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index fbe7c104531c..8f2ca18c71f4 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5741,23 +5741,23 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree,
         return 0;
 }
 
-static inline void btrfs_end_bbio(struct btrfs_bio *bbio, struct bio *bio, int err)
+static inline void btrfs_end_bbio(struct btrfs_bio *bbio, struct bio *bio)
 {
         bio->bi_private = bbio->private;
         bio->bi_end_io = bbio->end_io;
-        bio_endio(bio, err);
+        bio_endio(bio);
 
         btrfs_put_bbio(bbio);
 }
 
-static void btrfs_end_bio(struct bio *bio, int err)
+static void btrfs_end_bio(struct bio *bio)
 {
         struct btrfs_bio *bbio = bio->bi_private;
         int is_orig_bio = 0;
 
-        if (err) {
+        if (bio->bi_error) {
                 atomic_inc(&bbio->error);
-                if (err == -EIO || err == -EREMOTEIO) {
+                if (bio->bi_error == -EIO || bio->bi_error == -EREMOTEIO) {
                         unsigned int stripe_index =
                                 btrfs_io_bio(bio)->stripe_index;
                         struct btrfs_device *dev;
@@ -5795,17 +5795,16 @@ static void btrfs_end_bio(struct bio *bio, int err)
                  * beyond the tolerance of the btrfs bio
                  */
                 if (atomic_read(&bbio->error) > bbio->max_errors) {
-                        err = -EIO;
+                        bio->bi_error = -EIO;
                 } else {
                         /*
                          * this bio is actually up to date, we didn't
                          * go over the max number of errors
                          */
-                        set_bit(BIO_UPTODATE, &bio->bi_flags);
-                        err = 0;
+                        bio->bi_error = 0;
                 }
 
-                btrfs_end_bbio(bbio, bio, err);
+                btrfs_end_bbio(bbio, bio);
         } else if (!is_orig_bio) {
                 bio_put(bio);
         }
@@ -5826,7 +5825,7 @@ static noinline void btrfs_schedule_bio(struct btrfs_root *root,
         struct btrfs_pending_bios *pending_bios;
 
         if (device->missing || !device->bdev) {
-                bio_endio(bio, -EIO);
+                bio_io_error(bio);
                 return;
         }
 
@@ -5973,8 +5972,8 @@ static void bbio_error(struct btrfs_bio *bbio, struct bio *bio, u64 logical)
 
                 btrfs_io_bio(bio)->mirror_num = bbio->mirror_num;
                 bio->bi_iter.bi_sector = logical >> 9;
-
-                btrfs_end_bbio(bbio, bio, -EIO);
+                bio->bi_error = -EIO;
+                btrfs_end_bbio(bbio, bio);
         }
 }
 
diff --git a/fs/buffer.c b/fs/buffer.c
index 1cf7a53a0277..7a49bb84ecb5 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -2957,14 +2957,14 @@ sector_t generic_block_bmap(struct address_space *mapping, sector_t block,
 }
 EXPORT_SYMBOL(generic_block_bmap);
 
-static void end_bio_bh_io_sync(struct bio *bio, int err)
+static void end_bio_bh_io_sync(struct bio *bio)
 {
         struct buffer_head *bh = bio->bi_private;
 
         if (unlikely (test_bit(BIO_QUIET,&bio->bi_flags)))
                 set_bit(BH_Quiet, &bh->b_state);
 
-        bh->b_end_io(bh, test_bit(BIO_UPTODATE, &bio->bi_flags));
+        bh->b_end_io(bh, !bio->bi_error);
         bio_put(bio);
 }
 
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 745d2342651a..e1639c8c14d5 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -285,7 +285,7 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio);
 /*
  * Asynchronous IO callback. 
  */
-static void dio_bio_end_aio(struct bio *bio, int error)
+static void dio_bio_end_aio(struct bio *bio)
 {
         struct dio *dio = bio->bi_private;
         unsigned long remaining;
@@ -318,7 +318,7 @@ static void dio_bio_end_aio(struct bio *bio, int error)
  * During I/O bi_private points at the dio.  After I/O, bi_private is used to
  * implement a singly-linked list of completed BIOs, at dio->bio_list.
  */
-static void dio_bio_end_io(struct bio *bio, int error)
+static void dio_bio_end_io(struct bio *bio)
 {
         struct dio *dio = bio->bi_private;
         unsigned long flags;
@@ -345,9 +345,9 @@ void dio_end_io(struct bio *bio, int error)
         struct dio *dio = bio->bi_private;
 
         if (dio->is_async)
-                dio_bio_end_aio(bio, error);
+                dio_bio_end_aio(bio);
         else
-                dio_bio_end_io(bio, error);
+                dio_bio_end_io(bio);
 }
 EXPORT_SYMBOL_GPL(dio_end_io);
 
@@ -457,11 +457,10 @@ static struct bio *dio_await_one(struct dio *dio)
  */
 static int dio_bio_complete(struct dio *dio, struct bio *bio)
 {
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct bio_vec *bvec;
         unsigned i;
 
-        if (!uptodate)
+        if (bio->bi_error)
                 dio->io_error = -EIO;
 
         if (dio->is_async && dio->rw == READ) {
@@ -476,7 +475,7 @@ static int dio_bio_complete(struct dio *dio, struct bio *bio)
                 }
                 bio_put(bio);
         }
-        return uptodate ? 0 : -EIO;
+        return bio->bi_error;
 }
 
 /*
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 5602450f03f6..aa95566f14be 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -61,7 +61,6 @@ static void buffer_io_error(struct buffer_head *bh)
 static void ext4_finish_bio(struct bio *bio)
 {
         int i;
-        int error = !test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct bio_vec *bvec;
 
         bio_for_each_segment_all(bvec, bio, i) {
@@ -88,7 +87,7 @@ static void ext4_finish_bio(struct bio *bio)
                 }
 #endif
 
-                if (error) {
+                if (bio->bi_error) {
                         SetPageError(page);
                         set_bit(AS_EIO, &page->mapping->flags);
                 }
@@ -107,7 +106,7 @@ static void ext4_finish_bio(struct bio *bio)
                                 continue;
                         }
                         clear_buffer_async_write(bh);
-                        if (error)
+                        if (bio->bi_error)
                                 buffer_io_error(bh);
                 } while ((bh = bh->b_this_page) != head);
                 bit_spin_unlock(BH_Uptodate_Lock, &head->b_state);
@@ -310,27 +309,25 @@ ext4_io_end_t *ext4_get_io_end(ext4_io_end_t *io_end)
 }
 
 /* BIO completion function for page writeback */
-static void ext4_end_bio(struct bio *bio, int error)
+static void ext4_end_bio(struct bio *bio)
 {
         ext4_io_end_t *io_end = bio->bi_private;
         sector_t bi_sector = bio->bi_iter.bi_sector;
 
         BUG_ON(!io_end);
         bio->bi_end_io = NULL;
-        if (test_bit(BIO_UPTODATE, &bio->bi_flags))
-                error = 0;
 
-        if (error) {
+        if (bio->bi_error) {
                 struct inode *inode = io_end->inode;
 
                 ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu "
                              "(offset %llu size %ld starting block %llu)",
-                             error, inode->i_ino,
+                             bio->bi_error, inode->i_ino,
                              (unsigned long long) io_end->offset,
                              (long) io_end->size,
                              (unsigned long long)
                              bi_sector >> (inode->i_blkbits - 9));
-                mapping_set_error(inode->i_mapping, error);
+                mapping_set_error(inode->i_mapping, bio->bi_error);
         }
 
         if (io_end->flag & EXT4_IO_END_UNWRITTEN) {
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index ec3ef93a52db..5de5b871c178 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -98,7 +98,7 @@ static inline bool ext4_bio_encrypted(struct bio *bio)
  * status of that page is hard.  See end_buffer_async_read() for the details.
  * There is no point in duplicating all that complexity.
  */
-static void mpage_end_io(struct bio *bio, int err)
+static void mpage_end_io(struct bio *bio)
 {
         struct bio_vec *bv;
         int i;
@@ -106,7 +106,7 @@ static void mpage_end_io(struct bio *bio, int err)
         if (ext4_bio_encrypted(bio)) {
                 struct ext4_crypto_ctx *ctx = bio->bi_private;
 
-                if (err) {
+                if (bio->bi_error) {
                         ext4_release_crypto_ctx(ctx);
                 } else {
                         INIT_WORK(&ctx->r.work, completion_pages);
@@ -118,7 +118,7 @@ static void mpage_end_io(struct bio *bio, int err)
         bio_for_each_segment_all(bv, bio, i) {
                 struct page *page = bv->bv_page;
 
-                if (!err) {
+                if (!bio->bi_error) {
                         SetPageUptodate(page);
                 } else {
                         ClearPageUptodate(page);
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 9bedfa8dd3a5..8f0baa7ffb50 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -29,13 +29,13 @@
 static struct kmem_cache *extent_tree_slab;
 static struct kmem_cache *extent_node_slab;
 
-static void f2fs_read_end_io(struct bio *bio, int err)
+static void f2fs_read_end_io(struct bio *bio)
 {
         struct bio_vec *bvec;
         int i;
 
         if (f2fs_bio_encrypted(bio)) {
-                if (err) {
+                if (bio->bi_error) {
                         f2fs_release_crypto_ctx(bio->bi_private);
                 } else {
                         f2fs_end_io_crypto_work(bio->bi_private, bio);
@@ -46,7 +46,7 @@ static void f2fs_read_end_io(struct bio *bio, int err)
         bio_for_each_segment_all(bvec, bio, i) {
                 struct page *page = bvec->bv_page;
 
-                if (!err) {
+                if (!bio->bi_error) {
                         SetPageUptodate(page);
                 } else {
                         ClearPageUptodate(page);
@@ -57,7 +57,7 @@ static void f2fs_read_end_io(struct bio *bio, int err)
         bio_put(bio);
 }
 
-static void f2fs_write_end_io(struct bio *bio, int err)
+static void f2fs_write_end_io(struct bio *bio)
 {
         struct f2fs_sb_info *sbi = bio->bi_private;
         struct bio_vec *bvec;
@@ -68,7 +68,7 @@ static void f2fs_write_end_io(struct bio *bio, int err)
 
                 f2fs_restore_and_release_control_page(&page);
 
-                if (unlikely(err)) {
+                if (unlikely(bio->bi_error)) {
                         set_page_dirty(page);
                         set_bit(AS_EIO, &page->mapping->flags);
                         f2fs_stop_checkpoint(sbi);
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 2c1ae861dc94..c0a1b967deba 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -202,22 +202,22 @@ static void gfs2_end_log_write_bh(struct gfs2_sbd *sdp, struct bio_vec *bvec,
  *
  */
 
-static void gfs2_end_log_write(struct bio *bio, int error)
+static void gfs2_end_log_write(struct bio *bio)
 {
         struct gfs2_sbd *sdp = bio->bi_private;
         struct bio_vec *bvec;
         struct page *page;
         int i;
 
-        if (error) {
-                sdp->sd_log_error = error;
-                fs_err(sdp, "Error %d writing to log\n", error);
+        if (bio->bi_error) {
+                sdp->sd_log_error = bio->bi_error;
+                fs_err(sdp, "Error %d writing to log\n", bio->bi_error);
         }
 
         bio_for_each_segment_all(bvec, bio, i) {
                 page = bvec->bv_page;
                 if (page_has_buffers(page))
-                        gfs2_end_log_write_bh(sdp, bvec, error);
+                        gfs2_end_log_write_bh(sdp, bvec, bio->bi_error);
                 else
                         mempool_free(page, gfs2_page_pool);
         }
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index 1e3a93f2f71d..02586e7eb964 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -171,14 +171,14 @@ static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)
         return -EINVAL;
 }
 
-static void end_bio_io_page(struct bio *bio, int error)
+static void end_bio_io_page(struct bio *bio)
 {
         struct page *page = bio->bi_private;
 
-        if (!error)
+        if (!bio->bi_error)
                 SetPageUptodate(page);
         else
-                pr_warn("error %d reading superblock\n", error);
+                pr_warn("error %d reading superblock\n", bio->bi_error);
         unlock_page(page);
 }
 
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index bc462dcd7a40..d301acfdb80d 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -2011,7 +2011,7 @@ static int lbmRead(struct jfs_log * log, int pn, struct lbuf ** bpp)
         /*check if journaling to disk has been disabled*/
         if (log->no_integrity) {
                 bio->bi_iter.bi_size = 0;
-                lbmIODone(bio, 0);
+                lbmIODone(bio);
         } else {
                 submit_bio(READ_SYNC, bio);
         }
@@ -2158,7 +2158,7 @@ static void lbmStartIO(struct lbuf * bp)
         /* check if journaling to disk has been disabled */
         if (log->no_integrity) {
                 bio->bi_iter.bi_size = 0;
-                lbmIODone(bio, 0);
+                lbmIODone(bio);
         } else {
                 submit_bio(WRITE_SYNC, bio);
                 INCREMENT(lmStat.submitted);
@@ -2196,7 +2196,7 @@ static int lbmIOWait(struct lbuf * bp, int flag)
  *
  * executed at INTIODONE level
  */
-static void lbmIODone(struct bio *bio, int error)
+static void lbmIODone(struct bio *bio)
 {
         struct lbuf *bp = bio->bi_private;
         struct lbuf *nextbp, *tail;
@@ -2212,7 +2212,7 @@ static void lbmIODone(struct bio *bio, int error)
 
         bp->l_flag |= lbmDONE;
 
-        if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
+        if (bio->bi_error) {
                 bp->l_flag |= lbmERROR;
 
                 jfs_err("lbmIODone: I/O error in JFS log");
diff --git a/fs/jfs/jfs_metapage.c b/fs/jfs/jfs_metapage.c
index 16a0922beb59..a3eb316b1ac3 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -276,11 +276,11 @@ static void last_read_complete(struct page *page)
         unlock_page(page);
 }
 
-static void metapage_read_end_io(struct bio *bio, int err)
+static void metapage_read_end_io(struct bio *bio)
 {
         struct page *page = bio->bi_private;
 
-        if (!test_bit(BIO_UPTODATE, &bio->bi_flags)) {
+        if (bio->bi_error) {
                 printk(KERN_ERR "metapage_read_end_io: I/O error\n");
                 SetPageError(page);
         }
@@ -331,13 +331,13 @@ static void last_write_complete(struct page *page)
         end_page_writeback(page);
 }
 
-static void metapage_write_end_io(struct bio *bio, int err)
+static void metapage_write_end_io(struct bio *bio)
 {
         struct page *page = bio->bi_private;
 
         BUG_ON(!PagePrivate(page));
 
-        if (! test_bit(BIO_UPTODATE, &bio->bi_flags)) {
+        if (bio->bi_error) {
                 printk(KERN_ERR "metapage_write_end_io: I/O error\n");
                 SetPageError(page);
         }
diff --git a/fs/logfs/dev_bdev.c b/fs/logfs/dev_bdev.c
index 76279e11982d..cea0cc9878b7 100644
--- a/fs/logfs/dev_bdev.c
+++ b/fs/logfs/dev_bdev.c
@@ -53,16 +53,14 @@ static int bdev_readpage(void *_sb, struct page *page)
 
 static DECLARE_WAIT_QUEUE_HEAD(wq);
 
-static void writeseg_end_io(struct bio *bio, int err)
+static void writeseg_end_io(struct bio *bio)
 {
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct bio_vec *bvec;
         int i;
         struct super_block *sb = bio->bi_private;
         struct logfs_super *super = logfs_super(sb);
 
-        BUG_ON(!uptodate); /* FIXME: Retry io or write elsewhere */
-        BUG_ON(err);
+        BUG_ON(bio->bi_error); /* FIXME: Retry io or write elsewhere */
 
         bio_for_each_segment_all(bvec, bio, i) {
                 end_page_writeback(bvec->bv_page);
@@ -153,14 +151,12 @@ static void bdev_writeseg(struct super_block *sb, u64 ofs, size_t len)
 }
 
 
-static void erase_end_io(struct bio *bio, int err) 
+static void erase_end_io(struct bio *bio)
 { 
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags); 
         struct super_block *sb = bio->bi_private; 
         struct logfs_super *super = logfs_super(sb); 
 
-        BUG_ON(!uptodate); /* FIXME: Retry io or write elsewhere */ 
-        BUG_ON(err); 
+        BUG_ON(bio->bi_error); /* FIXME: Retry io or write elsewhere */ 
         BUG_ON(bio->bi_vcnt == 0); 
         bio_put(bio); 
         if (atomic_dec_and_test(&super->s_pending_writes))
diff --git a/fs/mpage.c b/fs/mpage.c
index ca0244b69de8..abac9361b3f1 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -42,14 +42,14 @@
  * status of that page is hard.  See end_buffer_async_read() for the details.
  * There is no point in duplicating all that complexity.
  */
-static void mpage_end_io(struct bio *bio, int err)
+static void mpage_end_io(struct bio *bio)
 {
         struct bio_vec *bv;
         int i;
 
         bio_for_each_segment_all(bv, bio, i) {
                 struct page *page = bv->bv_page;
-                page_endio(page, bio_data_dir(bio), err);
+                page_endio(page, bio_data_dir(bio), bio->bi_error);
         }
 
         bio_put(bio);
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index d2554fe140a3..9cd4eb3a1e22 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -116,7 +116,7 @@ bl_submit_bio(int rw, struct bio *bio)
 
 static struct bio *
 bl_alloc_init_bio(int npg, struct block_device *bdev, sector_t disk_sector,
-                void (*end_io)(struct bio *, int err), struct parallel_io *par)
+                bio_end_io_t end_io, struct parallel_io *par)
 {
         struct bio *bio;
 
@@ -139,8 +139,7 @@ bl_alloc_init_bio(int npg, struct block_device *bdev, sector_t disk_sector,
 static struct bio *
 do_add_page_to_bio(struct bio *bio, int npg, int rw, sector_t isect,
                 struct page *page, struct pnfs_block_dev_map *map,
-                struct pnfs_block_extent *be,
-                void (*end_io)(struct bio *, int err),
+                struct pnfs_block_extent *be, bio_end_io_t end_io,
                 struct parallel_io *par, unsigned int offset, int *len)
 {
         struct pnfs_block_dev *dev =
@@ -183,11 +182,11 @@ retry:
         return bio;
 }
 
-static void bl_end_io_read(struct bio *bio, int err)
+static void bl_end_io_read(struct bio *bio)
 {
         struct parallel_io *par = bio->bi_private;
 
-        if (err) {
+        if (bio->bi_error) {
                 struct nfs_pgio_header *header = par->data;
 
                 if (!header->pnfs_error)
@@ -316,13 +315,12 @@ out:
         return PNFS_ATTEMPTED;
 }
 
-static void bl_end_io_write(struct bio *bio, int err)
+static void bl_end_io_write(struct bio *bio)
 {
         struct parallel_io *par = bio->bi_private;
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct nfs_pgio_header *header = par->data;
 
-        if (!uptodate) {
+        if (bio->bi_error) {
                 if (!header->pnfs_error)
                         header->pnfs_error = -EIO;
                 pnfs_set_lo_fail(header->lseg);
diff --git a/fs/nilfs2/segbuf.c b/fs/nilfs2/segbuf.c
index 42468e5ab3e7..550b10efb14e 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -338,12 +338,11 @@ void nilfs_add_checksums_on_logs(struct list_head *logs, u32 seed)
 /*
  * BIO operations
  */
-static void nilfs_end_bio_write(struct bio *bio, int err)
+static void nilfs_end_bio_write(struct bio *bio)
 {
-        const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
         struct nilfs_segment_buffer *segbuf = bio->bi_private;
 
-        if (!uptodate)
+        if (bio->bi_error)
                 atomic_inc(&segbuf->sb_err);
 
         bio_put(bio);
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 16eff45727ee..140de3c93d2e 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -372,14 +372,13 @@ static void o2hb_wait_on_io(struct o2hb_region *reg,
         wait_for_completion(&wc->wc_io_complete);
 }
 
-static void o2hb_bio_end_io(struct bio *bio,
-                           int error)
+static void o2hb_bio_end_io(struct bio *bio)
 {
         struct o2hb_bio_wait_ctxt *wc = bio->bi_private;
 
-        if (error) {
-                mlog(ML_ERROR, "IO Error %d\n", error);
-                wc->wc_error = error;
+        if (bio->bi_error) {
+                mlog(ML_ERROR, "IO Error %d\n", bio->bi_error);
+                wc->wc_error = bio->bi_error;
         }
 
         o2hb_bio_wait_dec(wc, 1);
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 3859f5e27a4d..3714844a81d8 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -351,12 +351,11 @@ xfs_imap_valid(
  */
 STATIC void
 xfs_end_bio(
-        struct bio              *bio,
-        int                     error)
+        struct bio              *bio)
 {
         xfs_ioend_t             *ioend = bio->bi_private;
 
-        ioend->io_error = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : error;
+        ioend->io_error = bio->bi_error;
 
         /* Toss bio and pass work off to an xfsdatad thread */
         bio->bi_private = NULL;
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index a4b7d92e946c..01bd6781974e 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1096,8 +1096,7 @@ xfs_bwrite(
 
 STATIC void
 xfs_buf_bio_end_io(
-        struct bio              *bio,
-        int                     error)
+        struct bio              *bio)
 {
         xfs_buf_t               *bp = (xfs_buf_t *)bio->bi_private;
 
@@ -1105,10 +1104,10 @@ xfs_buf_bio_end_io(
          * don't overwrite existing errors - otherwise we can lose errors on
          * buffers that require multiple bios to complete.
          */
-        if (error) {
+        if (bio->bi_error) {
                 spin_lock(&bp->b_lock);
                 if (!bp->b_io_error)
-                        bp->b_io_error = error;
+                        bp->b_io_error = bio->bi_error;
                 spin_unlock(&bp->b_lock);
         }