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>

8 files changed, 126 insertions, 130 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);
         }
 }