On Mon, Jul 20, 2015 at 03:29:37PM +0200, Christoph Hellwig wrote:
> 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.
Reviewed-by: Liu Bo <bo.li.liu@xxxxxxxxxx> (btrfs)
Thanks,
-liubo
>
> Signed-off-by: Christoph Hellwig <hch@xxxxxx>
> ---
> Documentation/block/biodoc.txt | 2 +-
> arch/m68k/emu/nfblock.c | 2 +-
> arch/powerpc/sysdev/axonram.c | 2 +-
> arch/xtensa/platforms/iss/simdisk.c | 12 ++-----
> block/bio-integrity.c | 11 +++----
> block/bio.c | 43 +++++++++++--------------
> block/blk-core.c | 15 ++++-----
> block/blk-lib.c | 30 ++++++++----------
> block/blk-map.c | 2 +-
> block/blk-mq.c | 6 ++--
> block/bounce.c | 27 ++++++++--------
> drivers/block/aoe/aoecmd.c | 10 +++---
> drivers/block/aoe/aoedev.c | 2 +-
> drivers/block/brd.c | 13 +++++---
> drivers/block/drbd/drbd_actlog.c | 4 +--
> drivers/block/drbd/drbd_bitmap.c | 19 +++---------
> drivers/block/drbd/drbd_int.h | 11 ++++---
> drivers/block/drbd/drbd_req.c | 10 +++---
> drivers/block/drbd/drbd_worker.c | 44 +++++++-------------------
> drivers/block/floppy.c | 7 +++--
> drivers/block/null_blk.c | 2 +-
> drivers/block/pktcdvd.c | 32 +++++++++----------
> drivers/block/ps3vram.c | 3 +-
> drivers/block/rsxx/dev.c | 9 ++++--
> drivers/block/umem.c | 4 +--
> drivers/block/xen-blkback/blkback.c | 4 +--
> drivers/block/xen-blkfront.c | 9 ++----
> drivers/block/zram/zram_drv.c | 5 ++-
> drivers/md/bcache/btree.c | 10 +++---
> drivers/md/bcache/closure.h | 2 +-
> drivers/md/bcache/io.c | 8 ++---
> drivers/md/bcache/journal.c | 8 ++---
> drivers/md/bcache/movinggc.c | 8 ++---
> drivers/md/bcache/request.c | 27 ++++++++--------
> drivers/md/bcache/super.c | 14 ++++-----
> drivers/md/bcache/writeback.c | 10 +++---
> drivers/md/dm-bio-prison.c | 6 ++--
> drivers/md/dm-bufio.c | 26 ++++++++++------
> drivers/md/dm-cache-target.c | 24 +++++++-------
> drivers/md/dm-crypt.c | 14 ++++-----
> drivers/md/dm-flakey.c | 2 +-
> drivers/md/dm-io.c | 6 ++--
> drivers/md/dm-log-writes.c | 11 +++----
> drivers/md/dm-raid1.c | 24 +++++++-------
> drivers/md/dm-snap.c | 6 ++--
> drivers/md/dm-stripe.c | 2 +-
> drivers/md/dm-thin.c | 41 +++++++++++++-----------
> drivers/md/dm-verity.c | 9 +++---
> drivers/md/dm-zero.c | 2 +-
> drivers/md/dm.c | 15 +++++----
> drivers/md/faulty.c | 4 +--
> drivers/md/linear.c | 2 +-
> drivers/md/md.c | 18 +++++------
> drivers/md/multipath.c | 12 +++----
> drivers/md/raid0.c | 2 +-
> drivers/md/raid1.c | 53 ++++++++++++++++---------------
> drivers/md/raid10.c | 55 +++++++++++++++-----------------
> drivers/md/raid5.c | 52 +++++++++++++++----------------
> drivers/nvdimm/blk.c | 5 +--
> drivers/nvdimm/btt.c | 5 +--
> drivers/nvdimm/pmem.c | 2 +-
> drivers/s390/block/dcssblk.c | 2 +-
> drivers/s390/block/xpram.c | 3 +-
> drivers/target/target_core_iblock.c | 21 +++++--------
> drivers/target/target_core_pscsi.c | 6 ++--
> fs/btrfs/check-integrity.c | 10 +++---
> fs/btrfs/compression.c | 24 ++++++++------
> fs/btrfs/disk-io.c | 35 +++++++++++----------
> fs/btrfs/extent_io.c | 30 +++++++-----------
> fs/btrfs/inode.c | 50 ++++++++++++++++--------------
> fs/btrfs/raid56.c | 62 +++++++++++++++++--------------------
> fs/btrfs/scrub.c | 22 ++++++-------
> fs/btrfs/volumes.c | 23 +++++++-------
> fs/buffer.c | 4 +--
> fs/direct-io.c | 13 ++++----
> fs/ext4/page-io.c | 15 ++++-----
> fs/ext4/readpage.c | 6 ++--
> fs/f2fs/data.c | 10 +++---
> fs/gfs2/lops.c | 10 +++---
> fs/gfs2/ops_fstype.c | 6 ++--
> fs/jfs/jfs_logmgr.c | 8 ++---
> fs/jfs/jfs_metapage.c | 8 ++---
> fs/logfs/dev_bdev.c | 12 +++----
> fs/mpage.c | 4 +--
> fs/nfs/blocklayout/blocklayout.c | 14 ++++-----
> fs/nilfs2/segbuf.c | 5 ++-
> fs/ocfs2/cluster/heartbeat.c | 9 +++---
> fs/xfs/xfs_aops.c | 5 ++-
> fs/xfs/xfs_buf.c | 7 ++---
> include/linux/bio.h | 13 +++++---
> include/linux/blk_types.h | 4 +--
> include/linux/swap.h | 4 +--
> kernel/power/swap.c | 12 +++----
> kernel/trace/blktrace.c | 10 ++----
> mm/page_io.c | 12 +++----
> 95 files changed, 622 insertions(+), 682 deletions(-)
>
> diff --git a/Documentation/block/biodoc.txt b/Documentation/block/biodoc.txt
> index fd12c0d..5be8a7f 100644
> --- a/Documentation/block/biodoc.txt
> +++ b/Documentation/block/biodoc.txt
> @@ -1109,7 +1109,7 @@ it will loop and handle as many sectors (on a bio-segment granularity)
> as specified.
>
> Now bh->b_end_io is replaced by bio->bi_end_io, but most of the time the
> -right thing to use is bio_endio(bio, uptodate) instead.
> +right thing to use is bio_endio(bio) instead.
>
> If the driver is dropping the io_request_lock from its request_fn strategy,
> then it just needs to replace that with q->queue_lock instead.
> diff --git a/arch/m68k/emu/nfblock.c b/arch/m68k/emu/nfblock.c
> index 2d75ae2..f2a00c5 100644
> --- a/arch/m68k/emu/nfblock.c
> +++ b/arch/m68k/emu/nfblock.c
> @@ -76,7 +76,7 @@ static void nfhd_make_request(struct request_queue *queue, struct bio *bio)
> bvec_to_phys(&bvec));
> sec += len;
> }
> - bio_endio(bio, 0);
> + bio_endio(bio);
> }
>
> static int nfhd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
> diff --git a/arch/powerpc/sysdev/axonram.c b/arch/powerpc/sysdev/axonram.c
> index ee90db1..f86250c 100644
> --- a/arch/powerpc/sysdev/axonram.c
> +++ b/arch/powerpc/sysdev/axonram.c
> @@ -132,7 +132,7 @@ axon_ram_make_request(struct request_queue *queue, struct bio *bio)
> phys_mem += vec.bv_len;
> transfered += vec.bv_len;
> }
> - bio_endio(bio, 0);
> + bio_endio(bio);
> }
>
> /**
> diff --git a/arch/xtensa/platforms/iss/simdisk.c b/arch/xtensa/platforms/iss/simdisk.c
> index 48eebac..fa84ca9 100644
> --- a/arch/xtensa/platforms/iss/simdisk.c
> +++ b/arch/xtensa/platforms/iss/simdisk.c
> @@ -101,8 +101,9 @@ static void simdisk_transfer(struct simdisk *dev, unsigned long sector,
> spin_unlock(&dev->lock);
> }
>
> -static int simdisk_xfer_bio(struct simdisk *dev, struct bio *bio)
> +static void simdisk_make_request(struct request_queue *q, struct bio *bio)
> {
> + struct simdisk *dev = q->queuedata;
> struct bio_vec bvec;
> struct bvec_iter iter;
> sector_t sector = bio->bi_iter.bi_sector;
> @@ -116,17 +117,10 @@ static int simdisk_xfer_bio(struct simdisk *dev, struct bio *bio)
> sector += len;
> __bio_kunmap_atomic(buffer);
> }
> - return 0;
> -}
>
> -static void simdisk_make_request(struct request_queue *q, struct bio *bio)
> -{
> - struct simdisk *dev = q->queuedata;
> - int status = simdisk_xfer_bio(dev, bio);
> - bio_endio(bio, status);
> + bio_endio(bio);
> }
>
> -
> static int simdisk_open(struct block_device *bdev, fmode_t mode)
> {
> struct simdisk *dev = bdev->bd_disk->private_data;
> diff --git a/block/bio-integrity.c b/block/bio-integrity.c
> index 719b715..4aecca7 100644
> --- a/block/bio-integrity.c
> +++ b/block/bio-integrity.c
> @@ -355,13 +355,12 @@ static void bio_integrity_verify_fn(struct work_struct *work)
> container_of(work, struct bio_integrity_payload, bip_work);
> struct bio *bio = bip->bip_bio;
> struct blk_integrity *bi = bdev_get_integrity(bio->bi_bdev);
> - int error;
>
> - error = bio_integrity_process(bio, bi->verify_fn);
> + bio->bi_error = bio_integrity_process(bio, bi->verify_fn);
>
> /* Restore original bio completion handler */
> bio->bi_end_io = bip->bip_end_io;
> - bio_endio(bio, error);
> + bio_endio(bio);
> }
>
> /**
> @@ -376,7 +375,7 @@ static void bio_integrity_verify_fn(struct work_struct *work)
> * in process context. This function postpones completion
> * accordingly.
> */
> -void bio_integrity_endio(struct bio *bio, int error)
> +void bio_integrity_endio(struct bio *bio)
> {
> struct bio_integrity_payload *bip = bio_integrity(bio);
>
> @@ -386,9 +385,9 @@ void bio_integrity_endio(struct bio *bio, int error)
> * integrity metadata. Restore original bio end_io handler
> * and run it.
> */
> - if (error) {
> + if (bio->bi_error) {
> bio->bi_end_io = bip->bip_end_io;
> - bio_endio(bio, error);
> + bio_endio(bio);
>
> return;
> }
> diff --git a/block/bio.c b/block/bio.c
> index 2a00d34..a23f489 100644
> --- a/block/bio.c
> +++ b/block/bio.c
> @@ -269,7 +269,6 @@ static void bio_free(struct bio *bio)
> void bio_init(struct bio *bio)
> {
> memset(bio, 0, sizeof(*bio));
> - bio->bi_flags = 1 << BIO_UPTODATE;
> atomic_set(&bio->__bi_remaining, 1);
> atomic_set(&bio->__bi_cnt, 1);
> }
> @@ -292,14 +291,17 @@ void bio_reset(struct bio *bio)
> __bio_free(bio);
>
> memset(bio, 0, BIO_RESET_BYTES);
> - bio->bi_flags = flags | (1 << BIO_UPTODATE);
> + bio->bi_flags = flags;
> atomic_set(&bio->__bi_remaining, 1);
> }
> EXPORT_SYMBOL(bio_reset);
>
> -static void bio_chain_endio(struct bio *bio, int error)
> +static void bio_chain_endio(struct bio *bio)
> {
> - bio_endio(bio->bi_private, error);
> + struct bio *parent = bio->bi_private;
> +
> + parent->bi_error = bio->bi_error;
> + bio_endio(parent);
> bio_put(bio);
> }
>
> @@ -896,11 +898,11 @@ struct submit_bio_ret {
> int error;
> };
>
> -static void submit_bio_wait_endio(struct bio *bio, int error)
> +static void submit_bio_wait_endio(struct bio *bio)
> {
> struct submit_bio_ret *ret = bio->bi_private;
>
> - ret->error = error;
> + ret->error = bio->bi_error;
> complete(&ret->event);
> }
>
> @@ -1445,7 +1447,7 @@ void bio_unmap_user(struct bio *bio)
> }
> EXPORT_SYMBOL(bio_unmap_user);
>
> -static void bio_map_kern_endio(struct bio *bio, int err)
> +static void bio_map_kern_endio(struct bio *bio)
> {
> bio_put(bio);
> }
> @@ -1501,13 +1503,13 @@ struct bio *bio_map_kern(struct request_queue *q, void *data, unsigned int len,
> }
> EXPORT_SYMBOL(bio_map_kern);
>
> -static void bio_copy_kern_endio(struct bio *bio, int err)
> +static void bio_copy_kern_endio(struct bio *bio)
> {
> bio_free_pages(bio);
> bio_put(bio);
> }
>
> -static void bio_copy_kern_endio_read(struct bio *bio, int err)
> +static void bio_copy_kern_endio_read(struct bio *bio)
> {
> char *p = bio->bi_private;
> struct bio_vec *bvec;
> @@ -1518,7 +1520,7 @@ static void bio_copy_kern_endio_read(struct bio *bio, int err)
> p += bvec->bv_len;
> }
>
> - bio_copy_kern_endio(bio, err);
> + bio_copy_kern_endio(bio);
> }
>
> /**
> @@ -1778,25 +1780,15 @@ static inline bool bio_remaining_done(struct bio *bio)
> /**
> * bio_endio - end I/O on a bio
> * @bio: bio
> - * @error: error, if any
> *
> * Description:
> - * bio_endio() will end I/O on the whole bio. bio_endio() is the
> - * preferred way to end I/O on a bio, it takes care of clearing
> - * BIO_UPTODATE on error. @error is 0 on success, and and one of the
> - * established -Exxxx (-EIO, for instance) error values in case
> - * something went wrong. No one should call bi_end_io() directly on a
> - * bio unless they own it and thus know that it has an end_io
> - * function.
> + * bio_endio() will end I/O on the whole bio. bio_endio() is the preferred
> + * way to end I/O on a bio. No one should call bi_end_io() directly on a
> + * bio unless they own it and thus know that it has an end_io function.
> **/
> -void bio_endio(struct bio *bio, int error)
> +void bio_endio(struct bio *bio)
> {
> while (bio) {
> - if (error)
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> - else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
> - error = -EIO;
> -
> if (unlikely(!bio_remaining_done(bio)))
> break;
>
> @@ -1810,11 +1802,12 @@ void bio_endio(struct bio *bio, int error)
> */
> if (bio->bi_end_io == bio_chain_endio) {
> struct bio *parent = bio->bi_private;
> + parent->bi_error = bio->bi_error;
> bio_put(bio);
> bio = parent;
> } else {
> if (bio->bi_end_io)
> - bio->bi_end_io(bio, error);
> + bio->bi_end_io(bio);
> bio = NULL;
> }
> }
> diff --git a/block/blk-core.c b/block/blk-core.c
> index 627ed0c..7ef15b9 100644
> --- a/block/blk-core.c
> +++ b/block/blk-core.c
> @@ -143,9 +143,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
> unsigned int nbytes, int error)
> {
> if (error)
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> - else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
> - error = -EIO;
> + bio->bi_error = error;
>
> if (unlikely(rq->cmd_flags & REQ_QUIET))
> set_bit(BIO_QUIET, &bio->bi_flags);
> @@ -154,7 +152,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
>
> /* don't actually finish bio if it's part of flush sequence */
> if (bio->bi_iter.bi_size == 0 && !(rq->cmd_flags & REQ_FLUSH_SEQ))
> - bio_endio(bio, error);
> + bio_endio(bio);
> }
>
> void blk_dump_rq_flags(struct request *rq, char *msg)
> @@ -1620,7 +1618,8 @@ static void blk_queue_bio(struct request_queue *q, struct bio *bio)
> blk_queue_bounce(q, &bio);
>
> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
> - bio_endio(bio, -EIO);
> + bio->bi_error = -EIO;
> + bio_endio(bio);
> return;
> }
>
> @@ -1673,7 +1672,8 @@ get_rq:
> */
> req = get_request(q, rw_flags, bio, GFP_NOIO);
> if (IS_ERR(req)) {
> - bio_endio(bio, PTR_ERR(req)); /* @q is dead */
> + bio->bi_error = PTR_ERR(req);
> + bio_endio(bio);
> goto out_unlock;
> }
>
> @@ -1896,7 +1896,8 @@ generic_make_request_checks(struct bio *bio)
> return true;
>
> end_io:
> - bio_endio(bio, err);
> + bio->bi_error = err;
> + bio_endio(bio);
> return false;
> }
>
> diff --git a/block/blk-lib.c b/block/blk-lib.c
> index 7688ee3..6dee174 100644
> --- a/block/blk-lib.c
> +++ b/block/blk-lib.c
> @@ -11,16 +11,16 @@
>
> struct bio_batch {
> atomic_t done;
> - unsigned long flags;
> + int error;
> struct completion *wait;
> };
>
> -static void bio_batch_end_io(struct bio *bio, int err)
> +static void bio_batch_end_io(struct bio *bio)
> {
> struct bio_batch *bb = bio->bi_private;
>
> - if (err && (err != -EOPNOTSUPP))
> - clear_bit(BIO_UPTODATE, &bb->flags);
> + if (bio->bi_error && bio->bi_error != -EOPNOTSUPP)
> + bb->error = bio->bi_error;
> if (atomic_dec_and_test(&bb->done))
> complete(bb->wait);
> bio_put(bio);
> @@ -78,7 +78,7 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
> }
>
> atomic_set(&bb.done, 1);
> - bb.flags = 1 << BIO_UPTODATE;
> + bb.error = 0;
> bb.wait = &wait;
>
> blk_start_plug(&plug);
> @@ -134,9 +134,8 @@ int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
> if (!atomic_dec_and_test(&bb.done))
> wait_for_completion_io(&wait);
>
> - if (!test_bit(BIO_UPTODATE, &bb.flags))
> - ret = -EIO;
> -
> + if (bb.error)
> + return bb.error;
> return ret;
> }
> EXPORT_SYMBOL(blkdev_issue_discard);
> @@ -172,7 +171,7 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
> return -EOPNOTSUPP;
>
> atomic_set(&bb.done, 1);
> - bb.flags = 1 << BIO_UPTODATE;
> + bb.error = 0;
> bb.wait = &wait;
>
> while (nr_sects) {
> @@ -208,9 +207,8 @@ int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
> if (!atomic_dec_and_test(&bb.done))
> wait_for_completion_io(&wait);
>
> - if (!test_bit(BIO_UPTODATE, &bb.flags))
> - ret = -ENOTSUPP;
> -
> + if (bb.error)
> + return bb.error;
> return ret;
> }
> EXPORT_SYMBOL(blkdev_issue_write_same);
> @@ -236,7 +234,7 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
> DECLARE_COMPLETION_ONSTACK(wait);
>
> atomic_set(&bb.done, 1);
> - bb.flags = 1 << BIO_UPTODATE;
> + bb.error = 0;
> bb.wait = &wait;
>
> ret = 0;
> @@ -270,10 +268,8 @@ static int __blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
> if (!atomic_dec_and_test(&bb.done))
> wait_for_completion_io(&wait);
>
> - if (!test_bit(BIO_UPTODATE, &bb.flags))
> - /* One of bios in the batch was completed with error.*/
> - ret = -EIO;
> -
> + if (bb.error)
> + return bb.error;
> return ret;
> }
>
> diff --git a/block/blk-map.c b/block/blk-map.c
> index da310a1..5fe1c30 100644
> --- a/block/blk-map.c
> +++ b/block/blk-map.c
> @@ -103,7 +103,7 @@ int blk_rq_map_user_iov(struct request_queue *q, struct request *rq,
> * normal IO completion path
> */
> bio_get(bio);
> - bio_endio(bio, 0);
> + bio_endio(bio);
> __blk_rq_unmap_user(bio);
> return -EINVAL;
> }
> diff --git a/block/blk-mq.c b/block/blk-mq.c
> index 7d842db..9455902 100644
> --- a/block/blk-mq.c
> +++ b/block/blk-mq.c
> @@ -1199,7 +1199,7 @@ static struct request *blk_mq_map_request(struct request_queue *q,
> struct blk_mq_alloc_data alloc_data;
>
> if (unlikely(blk_mq_queue_enter(q, GFP_KERNEL))) {
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> return NULL;
> }
>
> @@ -1283,7 +1283,7 @@ static void blk_mq_make_request(struct request_queue *q, struct bio *bio)
> blk_queue_bounce(q, &bio);
>
> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> return;
> }
>
> @@ -1368,7 +1368,7 @@ static void blk_sq_make_request(struct request_queue *q, struct bio *bio)
> blk_queue_bounce(q, &bio);
>
> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> return;
> }
>
> diff --git a/block/bounce.c b/block/bounce.c
> index b173112..f4db245 100644
> --- a/block/bounce.c
> +++ b/block/bounce.c
> @@ -123,7 +123,7 @@ static void copy_to_high_bio_irq(struct bio *to, struct bio *from)
> }
> }
>
> -static void bounce_end_io(struct bio *bio, mempool_t *pool, int err)
> +static void bounce_end_io(struct bio *bio, mempool_t *pool)
> {
> struct bio *bio_orig = bio->bi_private;
> struct bio_vec *bvec, *org_vec;
> @@ -141,39 +141,40 @@ static void bounce_end_io(struct bio *bio, mempool_t *pool, int err)
> mempool_free(bvec->bv_page, pool);
> }
>
> - bio_endio(bio_orig, err);
> + bio_orig->bi_error = bio->bi_error;
> + bio_endio(bio_orig);
> bio_put(bio);
> }
>
> -static void bounce_end_io_write(struct bio *bio, int err)
> +static void bounce_end_io_write(struct bio *bio)
> {
> - bounce_end_io(bio, page_pool, err);
> + bounce_end_io(bio, page_pool);
> }
>
> -static void bounce_end_io_write_isa(struct bio *bio, int err)
> +static void bounce_end_io_write_isa(struct bio *bio)
> {
>
> - bounce_end_io(bio, isa_page_pool, err);
> + bounce_end_io(bio, isa_page_pool);
> }
>
> -static void __bounce_end_io_read(struct bio *bio, mempool_t *pool, int err)
> +static void __bounce_end_io_read(struct bio *bio, mempool_t *pool)
> {
> struct bio *bio_orig = bio->bi_private;
>
> - if (test_bit(BIO_UPTODATE, &bio->bi_flags))
> + if (!bio->bi_error)
> copy_to_high_bio_irq(bio_orig, bio);
>
> - bounce_end_io(bio, pool, err);
> + bounce_end_io(bio, pool);
> }
>
> -static void bounce_end_io_read(struct bio *bio, int err)
> +static void bounce_end_io_read(struct bio *bio)
> {
> - __bounce_end_io_read(bio, page_pool, err);
> + __bounce_end_io_read(bio, page_pool);
> }
>
> -static void bounce_end_io_read_isa(struct bio *bio, int err)
> +static void bounce_end_io_read_isa(struct bio *bio)
> {
> - __bounce_end_io_read(bio, isa_page_pool, err);
> + __bounce_end_io_read(bio, isa_page_pool);
> }
>
> #ifdef CONFIG_NEED_BOUNCE_POOL
> diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
> index 422b7d8..ad80c85 100644
> --- a/drivers/block/aoe/aoecmd.c
> +++ b/drivers/block/aoe/aoecmd.c
> @@ -1110,7 +1110,7 @@ aoe_end_request(struct aoedev *d, struct request *rq, int fastfail)
> d->ip.rq = NULL;
> do {
> bio = rq->bio;
> - bok = !fastfail && test_bit(BIO_UPTODATE, &bio->bi_flags);
> + bok = !fastfail && !bio->bi_error;
> } while (__blk_end_request(rq, bok ? 0 : -EIO, bio->bi_iter.bi_size));
>
> /* cf. http://lkml.org/lkml/2006/10/31/28 */
> @@ -1172,7 +1172,7 @@ ktiocomplete(struct frame *f)
> ahout->cmdstat, ahin->cmdstat,
> d->aoemajor, d->aoeminor);
> noskb: if (buf)
> - clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
> + buf->bio->bi_error = -EIO;
> goto out;
> }
>
> @@ -1185,7 +1185,7 @@ noskb: if (buf)
> "aoe: runt data size in read from",
> (long) d->aoemajor, d->aoeminor,
> skb->len, n);
> - clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
> + buf->bio->bi_error = -EIO;
> break;
> }
> if (n > f->iter.bi_size) {
> @@ -1193,7 +1193,7 @@ noskb: if (buf)
> "aoe: too-large data size in read from",
> (long) d->aoemajor, d->aoeminor,
> n, f->iter.bi_size);
> - clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
> + buf->bio->bi_error = -EIO;
> break;
> }
> bvcpy(skb, f->buf->bio, f->iter, n);
> @@ -1695,7 +1695,7 @@ aoe_failbuf(struct aoedev *d, struct buf *buf)
> if (buf == NULL)
> return;
> buf->iter.bi_size = 0;
> - clear_bit(BIO_UPTODATE, &buf->bio->bi_flags);
> + buf->bio->bi_error = -EIO;
> if (buf->nframesout == 0)
> aoe_end_buf(d, buf);
> }
> diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
> index e774c50..ffd1947 100644
> --- a/drivers/block/aoe/aoedev.c
> +++ b/drivers/block/aoe/aoedev.c
> @@ -170,7 +170,7 @@ aoe_failip(struct aoedev *d)
> if (rq == NULL)
> return;
> while ((bio = d->ip.nxbio)) {
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
> d->ip.nxbio = bio->bi_next;
> n = (unsigned long) rq->special;
> rq->special = (void *) --n;
> diff --git a/drivers/block/brd.c b/drivers/block/brd.c
> index e573e470b..f9ab745 100644
> --- a/drivers/block/brd.c
> +++ b/drivers/block/brd.c
> @@ -331,14 +331,12 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
> struct bio_vec bvec;
> sector_t sector;
> struct bvec_iter iter;
> - int err = -EIO;
>
> sector = bio->bi_iter.bi_sector;
> if (bio_end_sector(bio) > get_capacity(bdev->bd_disk))
> - goto out;
> + goto io_error;
>
> if (unlikely(bio->bi_rw & REQ_DISCARD)) {
> - err = 0;
> discard_from_brd(brd, sector, bio->bi_iter.bi_size);
> goto out;
> }
> @@ -349,15 +347,20 @@ static void brd_make_request(struct request_queue *q, struct bio *bio)
>
> bio_for_each_segment(bvec, bio, iter) {
> unsigned int len = bvec.bv_len;
> + int err;
> +
> err = brd_do_bvec(brd, bvec.bv_page, len,
> bvec.bv_offset, rw, sector);
> if (err)
> - break;
> + goto io_error;
> sector += len >> SECTOR_SHIFT;
> }
>
> out:
> - bio_endio(bio, err);
> + bio_endio(bio);
> + return;
> +io_error:
> + bio_io_error(bio);
> }
>
> static int brd_rw_page(struct block_device *bdev, sector_t sector,
> diff --git a/drivers/block/drbd/drbd_actlog.c b/drivers/block/drbd/drbd_actlog.c
> index 1318e32..b3868e7 100644
> --- a/drivers/block/drbd/drbd_actlog.c
> +++ b/drivers/block/drbd/drbd_actlog.c
> @@ -175,11 +175,11 @@ static int _drbd_md_sync_page_io(struct drbd_device *device,
> atomic_inc(&device->md_io.in_use); /* drbd_md_put_buffer() is in the completion handler */
> device->md_io.submit_jif = jiffies;
> if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD))
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> else
> submit_bio(rw, bio);
> wait_until_done_or_force_detached(device, bdev, &device->md_io.done);
> - if (bio_flagged(bio, BIO_UPTODATE))
> + if (!bio->bi_error)
> err = device->md_io.error;
>
> out:
> diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
> index 434c77d..e5e0f19 100644
> --- a/drivers/block/drbd/drbd_bitmap.c
> +++ b/drivers/block/drbd/drbd_bitmap.c
> @@ -941,36 +941,27 @@ static void drbd_bm_aio_ctx_destroy(struct kref *kref)
> }
>
> /* bv_page may be a copy, or may be the original */
> -static void drbd_bm_endio(struct bio *bio, int error)
> +static void drbd_bm_endio(struct bio *bio)
> {
> struct drbd_bm_aio_ctx *ctx = bio->bi_private;
> struct drbd_device *device = ctx->device;
> struct drbd_bitmap *b = device->bitmap;
> unsigned int idx = bm_page_to_idx(bio->bi_io_vec[0].bv_page);
> - int uptodate = bio_flagged(bio, BIO_UPTODATE);
> -
> -
> - /* strange behavior of some lower level drivers...
> - * fail the request by clearing the uptodate flag,
> - * but do not return any error?!
> - * do we want to WARN() on this? */
> - if (!error && !uptodate)
> - error = -EIO;
>
> if ((ctx->flags & BM_AIO_COPY_PAGES) == 0 &&
> !bm_test_page_unchanged(b->bm_pages[idx]))
> drbd_warn(device, "bitmap page idx %u changed during IO!\n", idx);
>
> - if (error) {
> + if (bio->bi_error) {
> /* ctx error will hold the completed-last non-zero error code,
> * in case error codes differ. */
> - ctx->error = error;
> + ctx->error = bio->bi_error;
> bm_set_page_io_err(b->bm_pages[idx]);
> /* Not identical to on disk version of it.
> * Is BM_PAGE_IO_ERROR enough? */
> if (__ratelimit(&drbd_ratelimit_state))
> drbd_err(device, "IO ERROR %d on bitmap page idx %u\n",
> - error, idx);
> + bio->bi_error, idx);
> } else {
> bm_clear_page_io_err(b->bm_pages[idx]);
> dynamic_drbd_dbg(device, "bitmap page idx %u completed\n", idx);
> @@ -1031,7 +1022,7 @@ static void bm_page_io_async(struct drbd_bm_aio_ctx *ctx, int page_nr) __must_ho
>
> if (drbd_insert_fault(device, (rw & WRITE) ? DRBD_FAULT_MD_WR : DRBD_FAULT_MD_RD)) {
> bio->bi_rw |= rw;
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> } else {
> submit_bio(rw, bio);
> /* this should not count as user activity and cause the
> diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
> index efd19c2..a08c4a9 100644
> --- a/drivers/block/drbd/drbd_int.h
> +++ b/drivers/block/drbd/drbd_int.h
> @@ -1481,9 +1481,9 @@ extern int drbd_khelper(struct drbd_device *device, char *cmd);
>
> /* drbd_worker.c */
> /* bi_end_io handlers */
> -extern void drbd_md_endio(struct bio *bio, int error);
> -extern void drbd_peer_request_endio(struct bio *bio, int error);
> -extern void drbd_request_endio(struct bio *bio, int error);
> +extern void drbd_md_endio(struct bio *bio);
> +extern void drbd_peer_request_endio(struct bio *bio);
> +extern void drbd_request_endio(struct bio *bio);
> extern int drbd_worker(struct drbd_thread *thi);
> enum drbd_ret_code drbd_resync_after_valid(struct drbd_device *device, int o_minor);
> void drbd_resync_after_changed(struct drbd_device *device);
> @@ -1604,12 +1604,13 @@ static inline void drbd_generic_make_request(struct drbd_device *device,
> __release(local);
> if (!bio->bi_bdev) {
> drbd_err(device, "drbd_generic_make_request: bio->bi_bdev == NULL\n");
> - bio_endio(bio, -ENODEV);
> + bio->bi_error = -ENODEV;
> + bio_endio(bio);
> return;
> }
>
> if (drbd_insert_fault(device, fault_type))
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> else
> generic_make_request(bio);
> }
> diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
> index 3907202..9cb4116 100644
> --- a/drivers/block/drbd/drbd_req.c
> +++ b/drivers/block/drbd/drbd_req.c
> @@ -201,7 +201,8 @@ void start_new_tl_epoch(struct drbd_connection *connection)
> void complete_master_bio(struct drbd_device *device,
> struct bio_and_error *m)
> {
> - bio_endio(m->bio, m->error);
> + m->bio->bi_error = m->error;
> + bio_endio(m->bio);
> dec_ap_bio(device);
> }
>
> @@ -1153,12 +1154,12 @@ drbd_submit_req_private_bio(struct drbd_request *req)
> rw == WRITE ? DRBD_FAULT_DT_WR
> : rw == READ ? DRBD_FAULT_DT_RD
> : DRBD_FAULT_DT_RA))
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> else
> generic_make_request(bio);
> put_ldev(device);
> } else
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> }
>
> static void drbd_queue_write(struct drbd_device *device, struct drbd_request *req)
> @@ -1191,7 +1192,8 @@ drbd_request_prepare(struct drbd_device *device, struct bio *bio, unsigned long
> /* only pass the error to the upper layers.
> * if user cannot handle io errors, that's not our business. */
> drbd_err(device, "could not kmalloc() req\n");
> - bio_endio(bio, -ENOMEM);
> + bio->bi_error = -ENOMEM;
> + bio_endio(bio);
> return ERR_PTR(-ENOMEM);
> }
> req->start_jif = start_jif;
> diff --git a/drivers/block/drbd/drbd_worker.c b/drivers/block/drbd/drbd_worker.c
> index d0fae55..5578c14 100644
> --- a/drivers/block/drbd/drbd_worker.c
> +++ b/drivers/block/drbd/drbd_worker.c
> @@ -65,12 +65,12 @@ rwlock_t global_state_lock;
> /* used for synchronous meta data and bitmap IO
> * submitted by drbd_md_sync_page_io()
> */
> -void drbd_md_endio(struct bio *bio, int error)
> +void drbd_md_endio(struct bio *bio)
> {
> struct drbd_device *device;
>
> device = bio->bi_private;
> - device->md_io.error = error;
> + device->md_io.error = bio->bi_error;
>
> /* We grabbed an extra reference in _drbd_md_sync_page_io() to be able
> * to timeout on the lower level device, and eventually detach from it.
> @@ -170,31 +170,20 @@ void drbd_endio_write_sec_final(struct drbd_peer_request *peer_req) __releases(l
> /* writes on behalf of the partner, or resync writes,
> * "submitted" by the receiver.
> */
> -void drbd_peer_request_endio(struct bio *bio, int error)
> +void drbd_peer_request_endio(struct bio *bio)
> {
> struct drbd_peer_request *peer_req = bio->bi_private;
> struct drbd_device *device = peer_req->peer_device->device;
> - int uptodate = bio_flagged(bio, BIO_UPTODATE);
> int is_write = bio_data_dir(bio) == WRITE;
> int is_discard = !!(bio->bi_rw & REQ_DISCARD);
>
> - if (error && __ratelimit(&drbd_ratelimit_state))
> + if (bio->bi_error && __ratelimit(&drbd_ratelimit_state))
> drbd_warn(device, "%s: error=%d s=%llus\n",
> is_write ? (is_discard ? "discard" : "write")
> - : "read", error,
> + : "read", bio->bi_error,
> (unsigned long long)peer_req->i.sector);
> - if (!error && !uptodate) {
> - if (__ratelimit(&drbd_ratelimit_state))
> - drbd_warn(device, "%s: setting error to -EIO s=%llus\n",
> - is_write ? "write" : "read",
> - (unsigned long long)peer_req->i.sector);
> - /* strange behavior of some lower level drivers...
> - * fail the request by clearing the uptodate flag,
> - * but do not return any error?! */
> - error = -EIO;
> - }
>
> - if (error)
> + if (bio->bi_error)
> set_bit(__EE_WAS_ERROR, &peer_req->flags);
>
> bio_put(bio); /* no need for the bio anymore */
> @@ -208,24 +197,13 @@ void drbd_peer_request_endio(struct bio *bio, int error)
>
> /* read, readA or write requests on R_PRIMARY coming from drbd_make_request
> */
> -void drbd_request_endio(struct bio *bio, int error)
> +void drbd_request_endio(struct bio *bio)
> {
> unsigned long flags;
> struct drbd_request *req = bio->bi_private;
> struct drbd_device *device = req->device;
> struct bio_and_error m;
> enum drbd_req_event what;
> - int uptodate = bio_flagged(bio, BIO_UPTODATE);
> -
> - if (!error && !uptodate) {
> - drbd_warn(device, "p %s: setting error to -EIO\n",
> - bio_data_dir(bio) == WRITE ? "write" : "read");
> - /* strange behavior of some lower level drivers...
> - * fail the request by clearing the uptodate flag,
> - * but do not return any error?! */
> - error = -EIO;
> - }
> -
>
> /* If this request was aborted locally before,
> * but now was completed "successfully",
> @@ -259,14 +237,14 @@ void drbd_request_endio(struct bio *bio, int error)
> if (__ratelimit(&drbd_ratelimit_state))
> drbd_emerg(device, "delayed completion of aborted local request; disk-timeout may be too aggressive\n");
>
> - if (!error)
> + if (!bio->bi_error)
> panic("possible random memory corruption caused by delayed completion of aborted local request\n");
> }
>
> /* to avoid recursion in __req_mod */
> - if (unlikely(error)) {
> + if (unlikely(bio->bi_error)) {
> if (bio->bi_rw & REQ_DISCARD)
> - what = (error == -EOPNOTSUPP)
> + what = (bio->bi_error == -EOPNOTSUPP)
> ? DISCARD_COMPLETED_NOTSUPP
> : DISCARD_COMPLETED_WITH_ERROR;
> else
> @@ -279,7 +257,7 @@ void drbd_request_endio(struct bio *bio, int error)
> what = COMPLETED_OK;
>
> bio_put(req->private_bio);
> - req->private_bio = ERR_PTR(error);
> + req->private_bio = ERR_PTR(bio->bi_error);
>
> /* not req_mod(), we need irqsave here! */
> spin_lock_irqsave(&device->resource->req_lock, flags);
> diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
> index a08cda9..331363e 100644
> --- a/drivers/block/floppy.c
> +++ b/drivers/block/floppy.c
> @@ -3771,13 +3771,14 @@ struct rb0_cbdata {
> struct completion complete;
> };
>
> -static void floppy_rb0_cb(struct bio *bio, int err)
> +static void floppy_rb0_cb(struct bio *bio)
> {
> struct rb0_cbdata *cbdata = (struct rb0_cbdata *)bio->bi_private;
> int drive = cbdata->drive;
>
> - if (err) {
> - pr_info("floppy: error %d while reading block 0\n", err);
> + if (bio->bi_error) {
> + pr_info("floppy: error %d while reading block 0\n",
> + bio->bi_error);
> set_bit(FD_OPEN_SHOULD_FAIL_BIT, &UDRS->flags);
> }
> complete(&cbdata->complete);
> diff --git a/drivers/block/null_blk.c b/drivers/block/null_blk.c
> index 69de41a..016a59a 100644
> --- a/drivers/block/null_blk.c
> +++ b/drivers/block/null_blk.c
> @@ -222,7 +222,7 @@ static void end_cmd(struct nullb_cmd *cmd)
> blk_end_request_all(cmd->rq, 0);
> break;
> case NULL_Q_BIO:
> - bio_endio(cmd->bio, 0);
> + bio_endio(cmd->bio);
> break;
> }
>
> diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
> index 4c20c22..a7a259e 100644
> --- a/drivers/block/pktcdvd.c
> +++ b/drivers/block/pktcdvd.c
> @@ -977,7 +977,7 @@ static void pkt_make_local_copy(struct packet_data *pkt, struct bio_vec *bvec)
> }
> }
>
> -static void pkt_end_io_read(struct bio *bio, int err)
> +static void pkt_end_io_read(struct bio *bio)
> {
> struct packet_data *pkt = bio->bi_private;
> struct pktcdvd_device *pd = pkt->pd;
> @@ -985,9 +985,9 @@ static void pkt_end_io_read(struct bio *bio, int err)
>
> pkt_dbg(2, pd, "bio=%p sec0=%llx sec=%llx err=%d\n",
> bio, (unsigned long long)pkt->sector,
> - (unsigned long long)bio->bi_iter.bi_sector, err);
> + (unsigned long long)bio->bi_iter.bi_sector, bio->bi_error);
>
> - if (err)
> + if (bio->bi_error)
> atomic_inc(&pkt->io_errors);
> if (atomic_dec_and_test(&pkt->io_wait)) {
> atomic_inc(&pkt->run_sm);
> @@ -996,13 +996,13 @@ static void pkt_end_io_read(struct bio *bio, int err)
> pkt_bio_finished(pd);
> }
>
> -static void pkt_end_io_packet_write(struct bio *bio, int err)
> +static void pkt_end_io_packet_write(struct bio *bio)
> {
> struct packet_data *pkt = bio->bi_private;
> struct pktcdvd_device *pd = pkt->pd;
> BUG_ON(!pd);
>
> - pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, err);
> + pkt_dbg(2, pd, "id=%d, err=%d\n", pkt->id, bio->bi_error);
>
> pd->stats.pkt_ended++;
>
> @@ -1340,22 +1340,22 @@ static void pkt_start_write(struct pktcdvd_device *pd, struct packet_data *pkt)
> pkt_queue_bio(pd, pkt->w_bio);
> }
>
> -static void pkt_finish_packet(struct packet_data *pkt, int uptodate)
> +static void pkt_finish_packet(struct packet_data *pkt, int error)
> {
> struct bio *bio;
>
> - if (!uptodate)
> + if (error)
> pkt->cache_valid = 0;
>
> /* Finish all bios corresponding to this packet */
> - while ((bio = bio_list_pop(&pkt->orig_bios)))
> - bio_endio(bio, uptodate ? 0 : -EIO);
> + while ((bio = bio_list_pop(&pkt->orig_bios))) {
> + bio->bi_error = error;
> + bio_endio(bio);
> + }
> }
>
> static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data *pkt)
> {
> - int uptodate;
> -
> pkt_dbg(2, pd, "pkt %d\n", pkt->id);
>
> for (;;) {
> @@ -1384,7 +1384,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data
> if (atomic_read(&pkt->io_wait) > 0)
> return;
>
> - if (test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags)) {
> + if (!pkt->w_bio->bi_error) {
> pkt_set_state(pkt, PACKET_FINISHED_STATE);
> } else {
> pkt_set_state(pkt, PACKET_RECOVERY_STATE);
> @@ -1401,8 +1401,7 @@ static void pkt_run_state_machine(struct pktcdvd_device *pd, struct packet_data
> break;
>
> case PACKET_FINISHED_STATE:
> - uptodate = test_bit(BIO_UPTODATE, &pkt->w_bio->bi_flags);
> - pkt_finish_packet(pkt, uptodate);
> + pkt_finish_packet(pkt, pkt->w_bio->bi_error);
> return;
>
> default:
> @@ -2332,13 +2331,14 @@ static void pkt_close(struct gendisk *disk, fmode_t mode)
> }
>
>
> -static void pkt_end_io_read_cloned(struct bio *bio, int err)
> +static void pkt_end_io_read_cloned(struct bio *bio)
> {
> struct packet_stacked_data *psd = bio->bi_private;
> struct pktcdvd_device *pd = psd->pd;
>
> + psd->bio->bi_error = bio->bi_error;
> bio_put(bio);
> - bio_endio(psd->bio, err);
> + bio_endio(psd->bio);
> mempool_free(psd, psd_pool);
> pkt_bio_finished(pd);
> }
> diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
> index b1612eb..49b4706 100644
> --- a/drivers/block/ps3vram.c
> +++ b/drivers/block/ps3vram.c
> @@ -593,7 +593,8 @@ out:
> next = bio_list_peek(&priv->list);
> spin_unlock_irq(&priv->lock);
>
> - bio_endio(bio, error);
> + bio->bi_error = error;
> + bio_endio(bio);
> return next;
> }
>
> diff --git a/drivers/block/rsxx/dev.c b/drivers/block/rsxx/dev.c
> index ac8c62c..63b9d2f 100644
> --- a/drivers/block/rsxx/dev.c
> +++ b/drivers/block/rsxx/dev.c
> @@ -137,7 +137,10 @@ static void bio_dma_done_cb(struct rsxx_cardinfo *card,
> if (!card->eeh_state && card->gendisk)
> disk_stats_complete(card, meta->bio, meta->start_time);
>
> - bio_endio(meta->bio, atomic_read(&meta->error) ? -EIO : 0);
> + if (atomic_read(&meta->error))
> + bio_io_error(meta->bio);
> + else
> + bio_endio(meta->bio);
> kmem_cache_free(bio_meta_pool, meta);
> }
> }
> @@ -199,7 +202,9 @@ static void rsxx_make_request(struct request_queue *q, struct bio *bio)
> queue_err:
> kmem_cache_free(bio_meta_pool, bio_meta);
> req_err:
> - bio_endio(bio, st);
> + if (st)
> + bio->bi_error = st;
> + bio_endio(bio);
> }
>
> /*----------------- Device Setup -------------------*/
> diff --git a/drivers/block/umem.c b/drivers/block/umem.c
> index 4cf81b5..3b3afd2 100644
> --- a/drivers/block/umem.c
> +++ b/drivers/block/umem.c
> @@ -456,7 +456,7 @@ static void process_page(unsigned long data)
> PCI_DMA_TODEVICE : PCI_DMA_FROMDEVICE);
> if (control & DMASCR_HARD_ERROR) {
> /* error */
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
> dev_printk(KERN_WARNING, &card->dev->dev,
> "I/O error on sector %d/%d\n",
> le32_to_cpu(desc->local_addr)>>9,
> @@ -505,7 +505,7 @@ static void process_page(unsigned long data)
>
> return_bio = bio->bi_next;
> bio->bi_next = NULL;
> - bio_endio(bio, 0);
> + bio_endio(bio);
> }
> }
>
> diff --git a/drivers/block/xen-blkback/blkback.c b/drivers/block/xen-blkback/blkback.c
> index ced9677..662648e 100644
> --- a/drivers/block/xen-blkback/blkback.c
> +++ b/drivers/block/xen-blkback/blkback.c
> @@ -1078,9 +1078,9 @@ static void __end_block_io_op(struct pending_req *pending_req, int error)
> /*
> * bio callback.
> */
> -static void end_block_io_op(struct bio *bio, int error)
> +static void end_block_io_op(struct bio *bio)
> {
> - __end_block_io_op(bio->bi_private, error);
> + __end_block_io_op(bio->bi_private, bio->bi_error);
> bio_put(bio);
> }
>
> diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
> index 6d89ed3..d542db7 100644
> --- a/drivers/block/xen-blkfront.c
> +++ b/drivers/block/xen-blkfront.c
> @@ -82,7 +82,6 @@ struct blk_shadow {
> struct split_bio {
> struct bio *bio;
> atomic_t pending;
> - int err;
> };
>
> static DEFINE_MUTEX(blkfront_mutex);
> @@ -1478,16 +1477,14 @@ static int blkfront_probe(struct xenbus_device *dev,
> return 0;
> }
>
> -static void split_bio_end(struct bio *bio, int error)
> +static void split_bio_end(struct bio *bio)
> {
> struct split_bio *split_bio = bio->bi_private;
>
> - if (error)
> - split_bio->err = error;
> -
> if (atomic_dec_and_test(&split_bio->pending)) {
> split_bio->bio->bi_phys_segments = 0;
> - bio_endio(split_bio->bio, split_bio->err);
> + split_bio->bio->bi_error = bio->bi_error;
> + bio_endio(split_bio->bio);
> kfree(split_bio);
> }
> bio_put(bio);
> diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
> index f439ad2..68c3d48 100644
> --- a/drivers/block/zram/zram_drv.c
> +++ b/drivers/block/zram/zram_drv.c
> @@ -850,7 +850,7 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
>
> if (unlikely(bio->bi_rw & REQ_DISCARD)) {
> zram_bio_discard(zram, index, offset, bio);
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
> }
>
> @@ -883,8 +883,7 @@ static void __zram_make_request(struct zram *zram, struct bio *bio)
> update_position(&index, &offset, &bvec);
> }
>
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
>
> out:
> diff --git a/drivers/md/bcache/btree.c b/drivers/md/bcache/btree.c
> index 00cde40..83392f8 100644
> --- a/drivers/md/bcache/btree.c
> +++ b/drivers/md/bcache/btree.c
> @@ -278,7 +278,7 @@ err:
> goto out;
> }
>
> -static void btree_node_read_endio(struct bio *bio, int error)
> +static void btree_node_read_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> closure_put(cl);
> @@ -305,7 +305,7 @@ static void bch_btree_node_read(struct btree *b)
> bch_submit_bbio(bio, b->c, &b->key, 0);
> closure_sync(&cl);
>
> - if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
> + if (bio->bi_error)
> set_btree_node_io_error(b);
>
> bch_bbio_free(bio, b->c);
> @@ -371,15 +371,15 @@ static void btree_node_write_done(struct closure *cl)
> __btree_node_write_done(cl);
> }
>
> -static void btree_node_write_endio(struct bio *bio, int error)
> +static void btree_node_write_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> struct btree *b = container_of(cl, struct btree, io);
>
> - if (error)
> + if (bio->bi_error)
> set_btree_node_io_error(b);
>
> - bch_bbio_count_io_errors(b->c, bio, error, "writing btree");
> + bch_bbio_count_io_errors(b->c, bio, bio->bi_error, "writing btree");
> closure_put(cl);
> }
>
> diff --git a/drivers/md/bcache/closure.h b/drivers/md/bcache/closure.h
> index 79a6d63..782cc2c 100644
> --- a/drivers/md/bcache/closure.h
> +++ b/drivers/md/bcache/closure.h
> @@ -38,7 +38,7 @@
> * they are running owned by the thread that is running them. Otherwise, suppose
> * you submit some bios and wish to have a function run when they all complete:
> *
> - * foo_endio(struct bio *bio, int error)
> + * foo_endio(struct bio *bio)
> * {
> * closure_put(cl);
> * }
> diff --git a/drivers/md/bcache/io.c b/drivers/md/bcache/io.c
> index bf6a9ca..9440df9 100644
> --- a/drivers/md/bcache/io.c
> +++ b/drivers/md/bcache/io.c
> @@ -55,19 +55,19 @@ static void bch_bio_submit_split_done(struct closure *cl)
>
> s->bio->bi_end_io = s->bi_end_io;
> s->bio->bi_private = s->bi_private;
> - bio_endio(s->bio, 0);
> + bio_endio(s->bio);
>
> closure_debug_destroy(&s->cl);
> mempool_free(s, s->p->bio_split_hook);
> }
>
> -static void bch_bio_submit_split_endio(struct bio *bio, int error)
> +static void bch_bio_submit_split_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> struct bio_split_hook *s = container_of(cl, struct bio_split_hook, cl);
>
> - if (error)
> - clear_bit(BIO_UPTODATE, &s->bio->bi_flags);
> + if (bio->bi_error)
> + s->bio->bi_error = bio->bi_error;
>
> bio_put(bio);
> closure_put(cl);
> diff --git a/drivers/md/bcache/journal.c b/drivers/md/bcache/journal.c
> index 418607a..d6a4e16 100644
> --- a/drivers/md/bcache/journal.c
> +++ b/drivers/md/bcache/journal.c
> @@ -24,7 +24,7 @@
> * bit.
> */
>
> -static void journal_read_endio(struct bio *bio, int error)
> +static void journal_read_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> closure_put(cl);
> @@ -401,7 +401,7 @@ retry:
>
> #define last_seq(j) ((j)->seq - fifo_used(&(j)->pin) + 1)
>
> -static void journal_discard_endio(struct bio *bio, int error)
> +static void journal_discard_endio(struct bio *bio)
> {
> struct journal_device *ja =
> container_of(bio, struct journal_device, discard_bio);
> @@ -547,11 +547,11 @@ void bch_journal_next(struct journal *j)
> pr_debug("journal_pin full (%zu)", fifo_used(&j->pin));
> }
>
> -static void journal_write_endio(struct bio *bio, int error)
> +static void journal_write_endio(struct bio *bio)
> {
> struct journal_write *w = bio->bi_private;
>
> - cache_set_err_on(error, w->c, "journal io error");
> + cache_set_err_on(bio->bi_error, w->c, "journal io error");
> closure_put(&w->c->journal.io);
> }
>
> diff --git a/drivers/md/bcache/movinggc.c b/drivers/md/bcache/movinggc.c
> index cd74903..b929fc9 100644
> --- a/drivers/md/bcache/movinggc.c
> +++ b/drivers/md/bcache/movinggc.c
> @@ -60,20 +60,20 @@ static void write_moving_finish(struct closure *cl)
> closure_return_with_destructor(cl, moving_io_destructor);
> }
>
> -static void read_moving_endio(struct bio *bio, int error)
> +static void read_moving_endio(struct bio *bio)
> {
> struct bbio *b = container_of(bio, struct bbio, bio);
> struct moving_io *io = container_of(bio->bi_private,
> struct moving_io, cl);
>
> - if (error)
> - io->op.error = error;
> + if (bio->bi_error)
> + io->op.error = bio->bi_error;
> else if (!KEY_DIRTY(&b->key) &&
> ptr_stale(io->op.c, &b->key, 0)) {
> io->op.error = -EINTR;
> }
>
> - bch_bbio_endio(io->op.c, bio, error, "reading data to move");
> + bch_bbio_endio(io->op.c, bio, bio->bi_error, "reading data to move");
> }
>
> static void moving_init(struct moving_io *io)
> diff --git a/drivers/md/bcache/request.c b/drivers/md/bcache/request.c
> index f292790..a09b946 100644
> --- a/drivers/md/bcache/request.c
> +++ b/drivers/md/bcache/request.c
> @@ -173,22 +173,22 @@ static void bch_data_insert_error(struct closure *cl)
> bch_data_insert_keys(cl);
> }
>
> -static void bch_data_insert_endio(struct bio *bio, int error)
> +static void bch_data_insert_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> struct data_insert_op *op = container_of(cl, struct data_insert_op, cl);
>
> - if (error) {
> + if (bio->bi_error) {
> /* TODO: We could try to recover from this. */
> if (op->writeback)
> - op->error = error;
> + op->error = bio->bi_error;
> else if (!op->replace)
> set_closure_fn(cl, bch_data_insert_error, op->wq);
> else
> set_closure_fn(cl, NULL, NULL);
> }
>
> - bch_bbio_endio(op->c, bio, error, "writing data to cache");
> + bch_bbio_endio(op->c, bio, bio->bi_error, "writing data to cache");
> }
>
> static void bch_data_insert_start(struct closure *cl)
> @@ -477,7 +477,7 @@ struct search {
> struct data_insert_op iop;
> };
>
> -static void bch_cache_read_endio(struct bio *bio, int error)
> +static void bch_cache_read_endio(struct bio *bio)
> {
> struct bbio *b = container_of(bio, struct bbio, bio);
> struct closure *cl = bio->bi_private;
> @@ -490,15 +490,15 @@ static void bch_cache_read_endio(struct bio *bio, int error)
> * from the backing device.
> */
>
> - if (error)
> - s->iop.error = error;
> + if (bio->bi_error)
> + s->iop.error = bio->bi_error;
> else if (!KEY_DIRTY(&b->key) &&
> ptr_stale(s->iop.c, &b->key, 0)) {
> atomic_long_inc(&s->iop.c->cache_read_races);
> s->iop.error = -EINTR;
> }
>
> - bch_bbio_endio(s->iop.c, bio, error, "reading from cache");
> + bch_bbio_endio(s->iop.c, bio, bio->bi_error, "reading from cache");
> }
>
> /*
> @@ -591,13 +591,13 @@ static void cache_lookup(struct closure *cl)
>
> /* Common code for the make_request functions */
>
> -static void request_endio(struct bio *bio, int error)
> +static void request_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
>
> - if (error) {
> + if (bio->bi_error) {
> struct search *s = container_of(cl, struct search, cl);
> - s->iop.error = error;
> + s->iop.error = bio->bi_error;
> /* Only cache read errors are recoverable */
> s->recoverable = false;
> }
> @@ -613,7 +613,8 @@ static void bio_complete(struct search *s)
> &s->d->disk->part0, s->start_time);
>
> trace_bcache_request_end(s->d, s->orig_bio);
> - bio_endio(s->orig_bio, s->iop.error);
> + s->orig_bio->bi_error = s->iop.error;
> + bio_endio(s->orig_bio);
> s->orig_bio = NULL;
> }
> }
> @@ -992,7 +993,7 @@ static void cached_dev_make_request(struct request_queue *q, struct bio *bio)
> } else {
> if ((bio->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(dc->bdev)))
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else
> bch_generic_make_request(bio, &d->bio_split_hook);
> }
> diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
> index fc8e545..be01fd3 100644
> --- a/drivers/md/bcache/super.c
> +++ b/drivers/md/bcache/super.c
> @@ -221,7 +221,7 @@ err:
> return err;
> }
>
> -static void write_bdev_super_endio(struct bio *bio, int error)
> +static void write_bdev_super_endio(struct bio *bio)
> {
> struct cached_dev *dc = bio->bi_private;
> /* XXX: error checking */
> @@ -290,11 +290,11 @@ void bch_write_bdev_super(struct cached_dev *dc, struct closure *parent)
> closure_return_with_destructor(cl, bch_write_bdev_super_unlock);
> }
>
> -static void write_super_endio(struct bio *bio, int error)
> +static void write_super_endio(struct bio *bio)
> {
> struct cache *ca = bio->bi_private;
>
> - bch_count_io_errors(ca, error, "writing superblock");
> + bch_count_io_errors(ca, bio->bi_error, "writing superblock");
> closure_put(&ca->set->sb_write);
> }
>
> @@ -339,12 +339,12 @@ void bcache_write_super(struct cache_set *c)
>
> /* UUID io */
>
> -static void uuid_endio(struct bio *bio, int error)
> +static void uuid_endio(struct bio *bio)
> {
> struct closure *cl = bio->bi_private;
> struct cache_set *c = container_of(cl, struct cache_set, uuid_write);
>
> - cache_set_err_on(error, c, "accessing uuids");
> + cache_set_err_on(bio->bi_error, c, "accessing uuids");
> bch_bbio_free(bio, c);
> closure_put(cl);
> }
> @@ -512,11 +512,11 @@ static struct uuid_entry *uuid_find_empty(struct cache_set *c)
> * disk.
> */
>
> -static void prio_endio(struct bio *bio, int error)
> +static void prio_endio(struct bio *bio)
> {
> struct cache *ca = bio->bi_private;
>
> - cache_set_err_on(error, ca->set, "accessing priorities");
> + cache_set_err_on(bio->bi_error, ca->set, "accessing priorities");
> bch_bbio_free(bio, ca->set);
> closure_put(&ca->prio);
> }
> diff --git a/drivers/md/bcache/writeback.c b/drivers/md/bcache/writeback.c
> index f1986bc..b4fc874 100644
> --- a/drivers/md/bcache/writeback.c
> +++ b/drivers/md/bcache/writeback.c
> @@ -166,12 +166,12 @@ static void write_dirty_finish(struct closure *cl)
> closure_return_with_destructor(cl, dirty_io_destructor);
> }
>
> -static void dirty_endio(struct bio *bio, int error)
> +static void dirty_endio(struct bio *bio)
> {
> struct keybuf_key *w = bio->bi_private;
> struct dirty_io *io = w->private;
>
> - if (error)
> + if (bio->bi_error)
> SET_KEY_DIRTY(&w->key, false);
>
> closure_put(&io->cl);
> @@ -193,15 +193,15 @@ static void write_dirty(struct closure *cl)
> continue_at(cl, write_dirty_finish, system_wq);
> }
>
> -static void read_dirty_endio(struct bio *bio, int error)
> +static void read_dirty_endio(struct bio *bio)
> {
> struct keybuf_key *w = bio->bi_private;
> struct dirty_io *io = w->private;
>
> bch_count_io_errors(PTR_CACHE(io->dc->disk.c, &w->key, 0),
> - error, "reading dirty data from cache");
> + bio->bi_error, "reading dirty data from cache");
>
> - dirty_endio(bio, error);
> + dirty_endio(bio);
> }
>
> static void read_dirty_submit(struct closure *cl)
> diff --git a/drivers/md/dm-bio-prison.c b/drivers/md/dm-bio-prison.c
> index cd6d1d2..03af174 100644
> --- a/drivers/md/dm-bio-prison.c
> +++ b/drivers/md/dm-bio-prison.c
> @@ -236,8 +236,10 @@ void dm_cell_error(struct dm_bio_prison *prison,
> bio_list_init(&bios);
> dm_cell_release(prison, cell, &bios);
>
> - while ((bio = bio_list_pop(&bios)))
> - bio_endio(bio, error);
> + while ((bio = bio_list_pop(&bios))) {
> + bio->bi_error = error;
> + bio_endio(bio);
> + }
> }
> EXPORT_SYMBOL_GPL(dm_cell_error);
>
> diff --git a/drivers/md/dm-bufio.c b/drivers/md/dm-bufio.c
> index 86dbbc7..83cc52e 100644
> --- a/drivers/md/dm-bufio.c
> +++ b/drivers/md/dm-bufio.c
> @@ -545,7 +545,8 @@ static void dmio_complete(unsigned long error, void *context)
> {
> struct dm_buffer *b = context;
>
> - b->bio.bi_end_io(&b->bio, error ? -EIO : 0);
> + b->bio.bi_error = error ? -EIO : 0;
> + b->bio.bi_end_io(&b->bio);
> }
>
> static void use_dmio(struct dm_buffer *b, int rw, sector_t block,
> @@ -575,13 +576,16 @@ static void use_dmio(struct dm_buffer *b, int rw, sector_t block,
> b->bio.bi_end_io = end_io;
>
> r = dm_io(&io_req, 1, ®ion, NULL);
> - if (r)
> - end_io(&b->bio, r);
> + if (r) {
> + b->bio.bi_error = r;
> + end_io(&b->bio);
> + }
> }
>
> -static void inline_endio(struct bio *bio, int error)
> +static void inline_endio(struct bio *bio)
> {
> bio_end_io_t *end_fn = bio->bi_private;
> + int error = bio->bi_error;
>
> /*
> * Reset the bio to free any attached resources
> @@ -589,7 +593,8 @@ static void inline_endio(struct bio *bio, int error)
> */
> bio_reset(bio);
>
> - end_fn(bio, error);
> + bio->bi_error = error;
> + end_fn(bio);
> }
>
> static void use_inline_bio(struct dm_buffer *b, int rw, sector_t block,
> @@ -661,13 +666,14 @@ static void submit_io(struct dm_buffer *b, int rw, sector_t block,
> * Set the error, clear B_WRITING bit and wake anyone who was waiting on
> * it.
> */
> -static void write_endio(struct bio *bio, int error)
> +static void write_endio(struct bio *bio)
> {
> struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);
>
> - b->write_error = error;
> - if (unlikely(error)) {
> + b->write_error = bio->bi_error;
> + if (unlikely(bio->bi_error)) {
> struct dm_bufio_client *c = b->c;
> + int error = bio->bi_error;
> (void)cmpxchg(&c->async_write_error, 0, error);
> }
>
> @@ -1026,11 +1032,11 @@ found_buffer:
> * The endio routine for reading: set the error, clear the bit and wake up
> * anyone waiting on the buffer.
> */
> -static void read_endio(struct bio *bio, int error)
> +static void read_endio(struct bio *bio)
> {
> struct dm_buffer *b = container_of(bio, struct dm_buffer, bio);
>
> - b->read_error = error;
> + b->read_error = bio->bi_error;
>
> BUG_ON(!test_bit(B_READING, &b->state));
>
> diff --git a/drivers/md/dm-cache-target.c b/drivers/md/dm-cache-target.c
> index 1b4e175..04d0dad 100644
> --- a/drivers/md/dm-cache-target.c
> +++ b/drivers/md/dm-cache-target.c
> @@ -919,14 +919,14 @@ static void defer_writethrough_bio(struct cache *cache, struct bio *bio)
> wake_worker(cache);
> }
>
> -static void writethrough_endio(struct bio *bio, int err)
> +static void writethrough_endio(struct bio *bio)
> {
> struct per_bio_data *pb = get_per_bio_data(bio, PB_DATA_SIZE_WT);
>
> dm_unhook_bio(&pb->hook_info, bio);
>
> - if (err) {
> - bio_endio(bio, err);
> + if (bio->bi_error) {
> + bio_endio(bio);
> return;
> }
>
> @@ -1231,7 +1231,7 @@ static void migration_success_post_commit(struct dm_cache_migration *mg)
> * The block was promoted via an overwrite, so it's dirty.
> */
> set_dirty(cache, mg->new_oblock, mg->cblock);
> - bio_endio(mg->new_ocell->holder, 0);
> + bio_endio(mg->new_ocell->holder);
> cell_defer(cache, mg->new_ocell, false);
> }
> free_io_migration(mg);
> @@ -1284,7 +1284,7 @@ static void issue_copy(struct dm_cache_migration *mg)
> }
> }
>
> -static void overwrite_endio(struct bio *bio, int err)
> +static void overwrite_endio(struct bio *bio)
> {
> struct dm_cache_migration *mg = bio->bi_private;
> struct cache *cache = mg->cache;
> @@ -1294,7 +1294,7 @@ static void overwrite_endio(struct bio *bio, int err)
>
> dm_unhook_bio(&pb->hook_info, bio);
>
> - if (err)
> + if (bio->bi_error)
> mg->err = true;
>
> mg->requeue_holder = false;
> @@ -1358,7 +1358,7 @@ static void issue_discard(struct dm_cache_migration *mg)
> b = to_dblock(from_dblock(b) + 1);
> }
>
> - bio_endio(bio, 0);
> + bio_endio(bio);
> cell_defer(mg->cache, mg->new_ocell, false);
> free_migration(mg);
> }
> @@ -1631,7 +1631,7 @@ static void process_discard_bio(struct cache *cache, struct prealloc *structs,
>
> calc_discard_block_range(cache, bio, &b, &e);
> if (b == e) {
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
> }
>
> @@ -2213,8 +2213,10 @@ static void requeue_deferred_bios(struct cache *cache)
> bio_list_merge(&bios, &cache->deferred_bios);
> bio_list_init(&cache->deferred_bios);
>
> - while ((bio = bio_list_pop(&bios)))
> - bio_endio(bio, DM_ENDIO_REQUEUE);
> + while ((bio = bio_list_pop(&bios))) {
> + bio->bi_error = DM_ENDIO_REQUEUE;
> + bio_endio(bio);
> + }
> }
>
> static int more_work(struct cache *cache)
> @@ -3119,7 +3121,7 @@ static int cache_map(struct dm_target *ti, struct bio *bio)
> * This is a duplicate writethrough io that is no
> * longer needed because the block has been demoted.
> */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> // FIXME: remap everything as a miss
> cell_defer(cache, cell, false);
> r = DM_MAPIO_SUBMITTED;
> diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
> index 0f48fed..744b80c 100644
> --- a/drivers/md/dm-crypt.c
> +++ b/drivers/md/dm-crypt.c
> @@ -1076,7 +1076,8 @@ static void crypt_dec_pending(struct dm_crypt_io *io)
> if (io->ctx.req)
> crypt_free_req(cc, io->ctx.req, base_bio);
>
> - bio_endio(base_bio, error);
> + base_bio->bi_error = error;
> + bio_endio(base_bio);
> }
>
> /*
> @@ -1096,15 +1097,12 @@ static void crypt_dec_pending(struct dm_crypt_io *io)
> * The work is done per CPU global for all dm-crypt instances.
> * They should not depend on each other and do not block.
> */
> -static void crypt_endio(struct bio *clone, int error)
> +static void crypt_endio(struct bio *clone)
> {
> struct dm_crypt_io *io = clone->bi_private;
> struct crypt_config *cc = io->cc;
> unsigned rw = bio_data_dir(clone);
>
> - if (unlikely(!bio_flagged(clone, BIO_UPTODATE) && !error))
> - error = -EIO;
> -
> /*
> * free the processed pages
> */
> @@ -1113,13 +1111,13 @@ static void crypt_endio(struct bio *clone, int error)
>
> bio_put(clone);
>
> - if (rw == READ && !error) {
> + if (rw == READ && !clone->bi_error) {
> kcryptd_queue_crypt(io);
> return;
> }
>
> - if (unlikely(error))
> - io->error = error;
> + if (unlikely(clone->bi_error))
> + io->error = clone->bi_error;
>
> crypt_dec_pending(io);
> }
> diff --git a/drivers/md/dm-flakey.c b/drivers/md/dm-flakey.c
> index b257e46..0448124 100644
> --- a/drivers/md/dm-flakey.c
> +++ b/drivers/md/dm-flakey.c
> @@ -296,7 +296,7 @@ static int flakey_map(struct dm_target *ti, struct bio *bio)
> * Drop writes?
> */
> if (test_bit(DROP_WRITES, &fc->flags)) {
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return DM_MAPIO_SUBMITTED;
> }
>
> diff --git a/drivers/md/dm-io.c b/drivers/md/dm-io.c
> index 74adcd2..efc6659 100644
> --- a/drivers/md/dm-io.c
> +++ b/drivers/md/dm-io.c
> @@ -134,12 +134,12 @@ static void dec_count(struct io *io, unsigned int region, int error)
> complete_io(io);
> }
>
> -static void endio(struct bio *bio, int error)
> +static void endio(struct bio *bio)
> {
> struct io *io;
> unsigned region;
>
> - if (error && bio_data_dir(bio) == READ)
> + if (bio->bi_error && bio_data_dir(bio) == READ)
> zero_fill_bio(bio);
>
> /*
> @@ -149,7 +149,7 @@ static void endio(struct bio *bio, int error)
>
> bio_put(bio);
>
> - dec_count(io, region, error);
> + dec_count(io, region, bio->bi_error);
> }
>
> /*-----------------------------------------------------------------
> diff --git a/drivers/md/dm-log-writes.c b/drivers/md/dm-log-writes.c
> index ad1b049..e9d1748 100644
> --- a/drivers/md/dm-log-writes.c
> +++ b/drivers/md/dm-log-writes.c
> @@ -146,16 +146,16 @@ static void put_io_block(struct log_writes_c *lc)
> }
> }
>
> -static void log_end_io(struct bio *bio, int err)
> +static void log_end_io(struct bio *bio)
> {
> struct log_writes_c *lc = bio->bi_private;
> struct bio_vec *bvec;
> int i;
>
> - if (err) {
> + if (bio->bi_error) {
> unsigned long flags;
>
> - DMERR("Error writing log block, error=%d", err);
> + DMERR("Error writing log block, error=%d", bio->bi_error);
> spin_lock_irqsave(&lc->blocks_lock, flags);
> lc->logging_enabled = false;
> spin_unlock_irqrestore(&lc->blocks_lock, flags);
> @@ -205,7 +205,6 @@ static int write_metadata(struct log_writes_c *lc, void *entry,
> bio->bi_bdev = lc->logdev->bdev;
> bio->bi_end_io = log_end_io;
> bio->bi_private = lc;
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
>
> page = alloc_page(GFP_KERNEL);
> if (!page) {
> @@ -270,7 +269,6 @@ static int log_one_block(struct log_writes_c *lc,
> bio->bi_bdev = lc->logdev->bdev;
> bio->bi_end_io = log_end_io;
> bio->bi_private = lc;
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
>
> for (i = 0; i < block->vec_cnt; i++) {
> /*
> @@ -292,7 +290,6 @@ static int log_one_block(struct log_writes_c *lc,
> bio->bi_bdev = lc->logdev->bdev;
> bio->bi_end_io = log_end_io;
> bio->bi_private = lc;
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
>
> ret = bio_add_page(bio, block->vecs[i].bv_page,
> block->vecs[i].bv_len, 0);
> @@ -606,7 +603,7 @@ static int log_writes_map(struct dm_target *ti, struct bio *bio)
> WARN_ON(flush_bio || fua_bio);
> if (lc->device_supports_discard)
> goto map_bio;
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return DM_MAPIO_SUBMITTED;
> }
>
> diff --git a/drivers/md/dm-raid1.c b/drivers/md/dm-raid1.c
> index d83696b..e1eabfb 100644
> --- a/drivers/md/dm-raid1.c
> +++ b/drivers/md/dm-raid1.c
> @@ -490,9 +490,11 @@ static void hold_bio(struct mirror_set *ms, struct bio *bio)
> * If device is suspended, complete the bio.
> */
> if (dm_noflush_suspending(ms->ti))
> - bio_endio(bio, DM_ENDIO_REQUEUE);
> + bio->bi_error = DM_ENDIO_REQUEUE;
> else
> - bio_endio(bio, -EIO);
> + bio->bi_error = -EIO;
> +
> + bio_endio(bio);
> return;
> }
>
> @@ -515,7 +517,7 @@ static void read_callback(unsigned long error, void *context)
> bio_set_m(bio, NULL);
>
> if (likely(!error)) {
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
> }
>
> @@ -531,7 +533,7 @@ static void read_callback(unsigned long error, void *context)
>
> DMERR_LIMIT("Read failure on mirror device %s. Failing I/O.",
> m->dev->name);
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> }
>
> /* Asynchronous read. */
> @@ -580,7 +582,7 @@ static void do_reads(struct mirror_set *ms, struct bio_list *reads)
> if (likely(m))
> read_async_bio(m, bio);
> else
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> }
> }
>
> @@ -598,7 +600,7 @@ static void do_reads(struct mirror_set *ms, struct bio_list *reads)
>
> static void write_callback(unsigned long error, void *context)
> {
> - unsigned i, ret = 0;
> + unsigned i;
> struct bio *bio = (struct bio *) context;
> struct mirror_set *ms;
> int should_wake = 0;
> @@ -614,7 +616,7 @@ static void write_callback(unsigned long error, void *context)
> * regions with the same code.
> */
> if (likely(!error)) {
> - bio_endio(bio, ret);
> + bio_endio(bio);
> return;
> }
>
> @@ -623,7 +625,8 @@ static void write_callback(unsigned long error, void *context)
> * degrade the array.
> */
> if (bio->bi_rw & REQ_DISCARD) {
> - bio_endio(bio, -EOPNOTSUPP);
> + bio->bi_error = -EOPNOTSUPP;
> + bio_endio(bio);
> return;
> }
>
> @@ -828,13 +831,12 @@ static void do_failures(struct mirror_set *ms, struct bio_list *failures)
> * be wrong if the failed leg returned after reboot and
> * got replicated back to the good legs.)
> */
> -
> if (unlikely(!get_valid_mirror(ms) || (keep_log(ms) && ms->log_failure)))
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> else if (errors_handled(ms) && !keep_log(ms))
> hold_bio(ms, bio);
> else
> - bio_endio(bio, 0);
> + bio_endio(bio);
> }
> }
>
> diff --git a/drivers/md/dm-snap.c b/drivers/md/dm-snap.c
> index 7c82d3c..dd8ca0b 100644
> --- a/drivers/md/dm-snap.c
> +++ b/drivers/md/dm-snap.c
> @@ -1490,7 +1490,7 @@ out:
> error_bios(snapshot_bios);
> } else {
> if (full_bio)
> - bio_endio(full_bio, 0);
> + bio_endio(full_bio);
> flush_bios(snapshot_bios);
> }
>
> @@ -1580,11 +1580,11 @@ static void start_copy(struct dm_snap_pending_exception *pe)
> dm_kcopyd_copy(s->kcopyd_client, &src, 1, &dest, 0, copy_callback, pe);
> }
>
> -static void full_bio_end_io(struct bio *bio, int error)
> +static void full_bio_end_io(struct bio *bio)
> {
> void *callback_data = bio->bi_private;
>
> - dm_kcopyd_do_callback(callback_data, 0, error ? 1 : 0);
> + dm_kcopyd_do_callback(callback_data, 0, bio->bi_error ? 1 : 0);
> }
>
> static void start_full_bio(struct dm_snap_pending_exception *pe,
> diff --git a/drivers/md/dm-stripe.c b/drivers/md/dm-stripe.c
> index a672a15..4f94c7d 100644
> --- a/drivers/md/dm-stripe.c
> +++ b/drivers/md/dm-stripe.c
> @@ -273,7 +273,7 @@ static int stripe_map_range(struct stripe_c *sc, struct bio *bio,
> return DM_MAPIO_REMAPPED;
> } else {
> /* The range doesn't map to the target stripe */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return DM_MAPIO_SUBMITTED;
> }
> }
> diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
> index c33f61a..2ade2c4 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;
> }
>
> diff --git a/drivers/md/dm-verity.c b/drivers/md/dm-verity.c
> index bb9c6a0..4b34df8 100644
> --- a/drivers/md/dm-verity.c
> +++ b/drivers/md/dm-verity.c
> @@ -458,8 +458,9 @@ static void verity_finish_io(struct dm_verity_io *io, int error)
>
> bio->bi_end_io = io->orig_bi_end_io;
> bio->bi_private = io->orig_bi_private;
> + bio->bi_error = error;
>
> - bio_endio(bio, error);
> + bio_endio(bio);
> }
>
> static void verity_work(struct work_struct *w)
> @@ -469,12 +470,12 @@ static void verity_work(struct work_struct *w)
> verity_finish_io(io, verity_verify_io(io));
> }
>
> -static void verity_end_io(struct bio *bio, int error)
> +static void verity_end_io(struct bio *bio)
> {
> struct dm_verity_io *io = bio->bi_private;
>
> - if (error) {
> - verity_finish_io(io, error);
> + if (bio->bi_error) {
> + verity_finish_io(io, bio->bi_error);
> return;
> }
>
> diff --git a/drivers/md/dm-zero.c b/drivers/md/dm-zero.c
> index b9a64bb..766bc93 100644
> --- a/drivers/md/dm-zero.c
> +++ b/drivers/md/dm-zero.c
> @@ -47,7 +47,7 @@ static int zero_map(struct dm_target *ti, struct bio *bio)
> break;
> }
>
> - bio_endio(bio, 0);
> + bio_endio(bio);
>
> /* accepted bio, don't make new request */
> return DM_MAPIO_SUBMITTED;
> diff --git a/drivers/md/dm.c b/drivers/md/dm.c
> index f331d88..7f367fc 100644
> --- a/drivers/md/dm.c
> +++ b/drivers/md/dm.c
> @@ -944,7 +944,8 @@ static void dec_pending(struct dm_io *io, int error)
> } else {
> /* done with normal IO or empty flush */
> trace_block_bio_complete(md->queue, bio, io_error);
> - bio_endio(bio, io_error);
> + bio->bi_error = io_error;
> + bio_endio(bio);
> }
> }
> }
> @@ -957,17 +958,15 @@ static void disable_write_same(struct mapped_device *md)
> limits->max_write_same_sectors = 0;
> }
>
> -static void clone_endio(struct bio *bio, int error)
> +static void clone_endio(struct bio *bio)
> {
> + int error = bio->bi_error;
> int r = error;
> struct dm_target_io *tio = container_of(bio, struct dm_target_io, clone);
> struct dm_io *io = tio->io;
> struct mapped_device *md = tio->io->md;
> dm_endio_fn endio = tio->ti->type->end_io;
>
> - if (!bio_flagged(bio, BIO_UPTODATE) && !error)
> - error = -EIO;
> -
> if (endio) {
> r = endio(tio->ti, bio, error);
> if (r < 0 || r == DM_ENDIO_REQUEUE)
> @@ -996,7 +995,7 @@ static void clone_endio(struct bio *bio, int error)
> /*
> * Partial completion handling for request-based dm
> */
> -static void end_clone_bio(struct bio *clone, int error)
> +static void end_clone_bio(struct bio *clone)
> {
> struct dm_rq_clone_bio_info *info =
> container_of(clone, struct dm_rq_clone_bio_info, clone);
> @@ -1013,13 +1012,13 @@ static void end_clone_bio(struct bio *clone, int error)
> * the remainder.
> */
> return;
> - else if (error) {
> + else if (bio->bi_error) {
> /*
> * Don't notice the error to the upper layer yet.
> * The error handling decision is made by the target driver,
> * when the request is completed.
> */
> - tio->error = error;
> + tio->error = bio->bi_error;
> return;
> }
>
> diff --git a/drivers/md/faulty.c b/drivers/md/faulty.c
> index 1277eb2..4a8e150 100644
> --- a/drivers/md/faulty.c
> +++ b/drivers/md/faulty.c
> @@ -70,7 +70,7 @@
> #include <linux/seq_file.h>
>
>
> -static void faulty_fail(struct bio *bio, int error)
> +static void faulty_fail(struct bio *bio)
> {
> struct bio *b = bio->bi_private;
>
> @@ -181,7 +181,7 @@ static void make_request(struct mddev *mddev, struct bio *bio)
> /* special case - don't decrement, don't generic_make_request,
> * just fail immediately
> */
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> return;
> }
>
> diff --git a/drivers/md/linear.c b/drivers/md/linear.c
> index fa7d577..aefd661 100644
> --- a/drivers/md/linear.c
> +++ b/drivers/md/linear.c
> @@ -297,7 +297,7 @@ static void linear_make_request(struct mddev *mddev, struct bio *bio)
> if (unlikely((split->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(split->bi_bdev)))) {
> /* Just ignore it */
> - bio_endio(split, 0);
> + bio_endio(split);
> } else
> generic_make_request(split);
> } while (split != bio);
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index d429c30..ac4381a 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -263,7 +263,9 @@ static void md_make_request(struct request_queue *q, struct bio *bio)
> return;
> }
> if (mddev->ro == 1 && unlikely(rw == WRITE)) {
> - bio_endio(bio, bio_sectors(bio) == 0 ? 0 : -EROFS);
> + if (bio_sectors(bio) != 0)
> + bio->bi_error = -EROFS;
> + bio_endio(bio);
> return;
> }
> smp_rmb(); /* Ensure implications of 'active' are visible */
> @@ -377,7 +379,7 @@ static int md_mergeable_bvec(struct request_queue *q,
> * Generic flush handling for md
> */
>
> -static void md_end_flush(struct bio *bio, int err)
> +static void md_end_flush(struct bio *bio)
> {
> struct md_rdev *rdev = bio->bi_private;
> struct mddev *mddev = rdev->mddev;
> @@ -433,7 +435,7 @@ static void md_submit_flush_data(struct work_struct *ws)
>
> if (bio->bi_iter.bi_size == 0)
> /* an empty barrier - all done */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else {
> bio->bi_rw &= ~REQ_FLUSH;
> mddev->pers->make_request(mddev, bio);
> @@ -728,15 +730,13 @@ void md_rdev_clear(struct md_rdev *rdev)
> }
> EXPORT_SYMBOL_GPL(md_rdev_clear);
>
> -static void super_written(struct bio *bio, int error)
> +static void super_written(struct bio *bio)
> {
> struct md_rdev *rdev = bio->bi_private;
> struct mddev *mddev = rdev->mddev;
>
> - if (error || !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
> - printk("md: super_written gets error=%d, uptodate=%d\n",
> - error, test_bit(BIO_UPTODATE, &bio->bi_flags));
> - WARN_ON(test_bit(BIO_UPTODATE, &bio->bi_flags));
> + if (bio->bi_error) {
> + printk("md: super_written gets error=%d\n", bio->bi_error);
> md_error(mddev, rdev);
> }
>
> @@ -791,7 +791,7 @@ int sync_page_io(struct md_rdev *rdev, sector_t sector, int size,
> bio_add_page(bio, page, size, 0);
> submit_bio_wait(rw, bio);
>
> - ret = test_bit(BIO_UPTODATE, &bio->bi_flags);
> + ret = !bio->bi_error;
> bio_put(bio);
> return ret;
> }
> diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
> index ac3ede2..082a489 100644
> --- a/drivers/md/multipath.c
> +++ b/drivers/md/multipath.c
> @@ -77,18 +77,18 @@ static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)
> struct bio *bio = mp_bh->master_bio;
> struct mpconf *conf = mp_bh->mddev->private;
>
> - bio_endio(bio, err);
> + bio->bi_error = err;
> + bio_endio(bio);
> mempool_free(mp_bh, conf->pool);
> }
>
> -static void multipath_end_request(struct bio *bio, int error)
> +static void multipath_end_request(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct multipath_bh *mp_bh = bio->bi_private;
> struct mpconf *conf = mp_bh->mddev->private;
> struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;
>
> - if (uptodate)
> + if (!bio->bi_error)
> multipath_end_bh_io(mp_bh, 0);
> else if (!(bio->bi_rw & REQ_RAHEAD)) {
> /*
> @@ -101,7 +101,7 @@ static void multipath_end_request(struct bio *bio, int error)
> (unsigned long long)bio->bi_iter.bi_sector);
> multipath_reschedule_retry(mp_bh);
> } else
> - multipath_end_bh_io(mp_bh, error);
> + multipath_end_bh_io(mp_bh, bio->bi_error);
> rdev_dec_pending(rdev, conf->mddev);
> }
>
> @@ -123,7 +123,7 @@ static void multipath_make_request(struct mddev *mddev, struct bio * bio)
>
> mp_bh->path = multipath_map(conf);
> if (mp_bh->path < 0) {
> - bio_endio(bio, -EIO);
> + bio_io_error(bio);
> mempool_free(mp_bh, conf->pool);
> return;
> }
> diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
> index efb654e..e6e0ae5 100644
> --- a/drivers/md/raid0.c
> +++ b/drivers/md/raid0.c
> @@ -543,7 +543,7 @@ static void raid0_make_request(struct mddev *mddev, struct bio *bio)
> if (unlikely((split->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(split->bi_bdev)))) {
> /* Just ignore it */
> - bio_endio(split, 0);
> + bio_endio(split);
> } else
> generic_make_request(split);
> } while (split != bio);
> diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
> index f80f1af..9aa7d1f 100644
> --- a/drivers/md/raid1.c
> +++ b/drivers/md/raid1.c
> @@ -255,9 +255,10 @@ static void call_bio_endio(struct r1bio *r1_bio)
> done = 1;
>
> if (!test_bit(R1BIO_Uptodate, &r1_bio->state))
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
> +
> if (done) {
> - bio_endio(bio, 0);
> + bio_endio(bio);
> /*
> * Wake up any possible resync thread that waits for the device
> * to go idle.
> @@ -312,9 +313,9 @@ static int find_bio_disk(struct r1bio *r1_bio, struct bio *bio)
> return mirror;
> }
>
> -static void raid1_end_read_request(struct bio *bio, int error)
> +static void raid1_end_read_request(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> + int uptodate = !bio->bi_error;
> struct r1bio *r1_bio = bio->bi_private;
> int mirror;
> struct r1conf *conf = r1_bio->mddev->private;
> @@ -397,9 +398,8 @@ static void r1_bio_write_done(struct r1bio *r1_bio)
> }
> }
>
> -static void raid1_end_write_request(struct bio *bio, int error)
> +static void raid1_end_write_request(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct r1bio *r1_bio = bio->bi_private;
> int mirror, behind = test_bit(R1BIO_BehindIO, &r1_bio->state);
> struct r1conf *conf = r1_bio->mddev->private;
> @@ -410,7 +410,7 @@ static void raid1_end_write_request(struct bio *bio, int error)
> /*
> * 'one mirror IO has finished' event handler:
> */
> - if (!uptodate) {
> + if (bio->bi_error) {
> set_bit(WriteErrorSeen,
> &conf->mirrors[mirror].rdev->flags);
> if (!test_and_set_bit(WantReplacement,
> @@ -793,7 +793,7 @@ static void flush_pending_writes(struct r1conf *conf)
> if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else
> generic_make_request(bio);
> bio = next;
> @@ -1068,7 +1068,7 @@ static void raid1_unplug(struct blk_plug_cb *cb, bool from_schedule)
> if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else
> generic_make_request(bio);
> bio = next;
> @@ -1734,7 +1734,7 @@ abort:
> return err;
> }
>
> -static void end_sync_read(struct bio *bio, int error)
> +static void end_sync_read(struct bio *bio)
> {
> struct r1bio *r1_bio = bio->bi_private;
>
> @@ -1745,16 +1745,16 @@ static void end_sync_read(struct bio *bio, int error)
> * or re-read if the read failed.
> * We don't do much here, just schedule handling by raid1d
> */
> - if (test_bit(BIO_UPTODATE, &bio->bi_flags))
> + if (!bio->bi_error)
> set_bit(R1BIO_Uptodate, &r1_bio->state);
>
> if (atomic_dec_and_test(&r1_bio->remaining))
> reschedule_retry(r1_bio);
> }
>
> -static void end_sync_write(struct bio *bio, int error)
> +static void end_sync_write(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> + int uptodate = !bio->bi_error;
> struct r1bio *r1_bio = bio->bi_private;
> struct mddev *mddev = r1_bio->mddev;
> struct r1conf *conf = mddev->private;
> @@ -1941,7 +1941,7 @@ static int fix_sync_read_error(struct r1bio *r1_bio)
> idx ++;
> }
> set_bit(R1BIO_Uptodate, &r1_bio->state);
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = 0;
> return 1;
> }
>
> @@ -1965,15 +1965,14 @@ static void process_checks(struct r1bio *r1_bio)
> for (i = 0; i < conf->raid_disks * 2; i++) {
> int j;
> int size;
> - int uptodate;
> + int error;
> struct bio *b = r1_bio->bios[i];
> if (b->bi_end_io != end_sync_read)
> continue;
> - /* fixup the bio for reuse, but preserve BIO_UPTODATE */
> - uptodate = test_bit(BIO_UPTODATE, &b->bi_flags);
> + /* fixup the bio for reuse, but preserve errno */
> + error = b->bi_error;
> bio_reset(b);
> - if (!uptodate)
> - clear_bit(BIO_UPTODATE, &b->bi_flags);
> + b->bi_error = error;
> b->bi_vcnt = vcnt;
> b->bi_iter.bi_size = r1_bio->sectors << 9;
> b->bi_iter.bi_sector = r1_bio->sector +
> @@ -1996,7 +1995,7 @@ static void process_checks(struct r1bio *r1_bio)
> }
> for (primary = 0; primary < conf->raid_disks * 2; primary++)
> if (r1_bio->bios[primary]->bi_end_io == end_sync_read &&
> - test_bit(BIO_UPTODATE, &r1_bio->bios[primary]->bi_flags)) {
> + !r1_bio->bios[primary]->bi_error) {
> r1_bio->bios[primary]->bi_end_io = NULL;
> rdev_dec_pending(conf->mirrors[primary].rdev, mddev);
> break;
> @@ -2006,14 +2005,14 @@ static void process_checks(struct r1bio *r1_bio)
> int j;
> struct bio *pbio = r1_bio->bios[primary];
> struct bio *sbio = r1_bio->bios[i];
> - int uptodate = test_bit(BIO_UPTODATE, &sbio->bi_flags);
> + int error = sbio->bi_error;
>
> if (sbio->bi_end_io != end_sync_read)
> continue;
> - /* Now we can 'fixup' the BIO_UPTODATE flag */
> - set_bit(BIO_UPTODATE, &sbio->bi_flags);
> + /* Now we can 'fixup' the error value */
> + sbio->bi_error = 0;
>
> - if (uptodate) {
> + if (!error) {
> for (j = vcnt; j-- ; ) {
> struct page *p, *s;
> p = pbio->bi_io_vec[j].bv_page;
> @@ -2028,7 +2027,7 @@ static void process_checks(struct r1bio *r1_bio)
> if (j >= 0)
> atomic64_add(r1_bio->sectors, &mddev->resync_mismatches);
> if (j < 0 || (test_bit(MD_RECOVERY_CHECK, &mddev->recovery)
> - && uptodate)) {
> + && !error)) {
> /* No need to write to this device. */
> sbio->bi_end_io = NULL;
> rdev_dec_pending(conf->mirrors[i].rdev, mddev);
> @@ -2269,11 +2268,11 @@ static void handle_sync_write_finished(struct r1conf *conf, struct r1bio *r1_bio
> struct bio *bio = r1_bio->bios[m];
> if (bio->bi_end_io == NULL)
> continue;
> - if (test_bit(BIO_UPTODATE, &bio->bi_flags) &&
> + if (!bio->bi_error &&
> test_bit(R1BIO_MadeGood, &r1_bio->state)) {
> rdev_clear_badblocks(rdev, r1_bio->sector, s, 0);
> }
> - if (!test_bit(BIO_UPTODATE, &bio->bi_flags) &&
> + if (bio->bi_error &&
> test_bit(R1BIO_WriteError, &r1_bio->state)) {
> if (!rdev_set_badblocks(rdev, r1_bio->sector, s, 0))
> md_error(conf->mddev, rdev);
> diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
> index 940f2f3..929e9a2 100644
> --- a/drivers/md/raid10.c
> +++ b/drivers/md/raid10.c
> @@ -101,7 +101,7 @@ static int _enough(struct r10conf *conf, int previous, int ignore);
> static sector_t reshape_request(struct mddev *mddev, sector_t sector_nr,
> int *skipped);
> static void reshape_request_write(struct mddev *mddev, struct r10bio *r10_bio);
> -static void end_reshape_write(struct bio *bio, int error);
> +static void end_reshape_write(struct bio *bio);
> static void end_reshape(struct r10conf *conf);
>
> static void * r10bio_pool_alloc(gfp_t gfp_flags, void *data)
> @@ -307,9 +307,9 @@ static void raid_end_bio_io(struct r10bio *r10_bio)
> } else
> done = 1;
> if (!test_bit(R10BIO_Uptodate, &r10_bio->state))
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
> if (done) {
> - bio_endio(bio, 0);
> + bio_endio(bio);
> /*
> * Wake up any possible resync thread that waits for the device
> * to go idle.
> @@ -358,9 +358,9 @@ static int find_bio_disk(struct r10conf *conf, struct r10bio *r10_bio,
> return r10_bio->devs[slot].devnum;
> }
>
> -static void raid10_end_read_request(struct bio *bio, int error)
> +static void raid10_end_read_request(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> + int uptodate = !bio->bi_error;
> struct r10bio *r10_bio = bio->bi_private;
> int slot, dev;
> struct md_rdev *rdev;
> @@ -438,9 +438,8 @@ static void one_write_done(struct r10bio *r10_bio)
> }
> }
>
> -static void raid10_end_write_request(struct bio *bio, int error)
> +static void raid10_end_write_request(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct r10bio *r10_bio = bio->bi_private;
> int dev;
> int dec_rdev = 1;
> @@ -460,7 +459,7 @@ static void raid10_end_write_request(struct bio *bio, int error)
> /*
> * this branch is our 'one mirror IO has finished' event handler:
> */
> - if (!uptodate) {
> + if (bio->bi_error) {
> if (repl)
> /* Never record new bad blocks to replacement,
> * just fail it.
> @@ -957,7 +956,7 @@ static void flush_pending_writes(struct r10conf *conf)
> if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else
> generic_make_request(bio);
> bio = next;
> @@ -1133,7 +1132,7 @@ static void raid10_unplug(struct blk_plug_cb *cb, bool from_schedule)
> if (unlikely((bio->bi_rw & REQ_DISCARD) &&
> !blk_queue_discard(bdev_get_queue(bio->bi_bdev))))
> /* Just ignore it */
> - bio_endio(bio, 0);
> + bio_endio(bio);
> else
> generic_make_request(bio);
> bio = next;
> @@ -1916,7 +1915,7 @@ abort:
> return err;
> }
>
> -static void end_sync_read(struct bio *bio, int error)
> +static void end_sync_read(struct bio *bio)
> {
> struct r10bio *r10_bio = bio->bi_private;
> struct r10conf *conf = r10_bio->mddev->private;
> @@ -1928,7 +1927,7 @@ static void end_sync_read(struct bio *bio, int error)
> } else
> d = find_bio_disk(conf, r10_bio, bio, NULL, NULL);
>
> - if (test_bit(BIO_UPTODATE, &bio->bi_flags))
> + if (!bio->bi_error)
> set_bit(R10BIO_Uptodate, &r10_bio->state);
> else
> /* The write handler will notice the lack of
> @@ -1977,9 +1976,8 @@ static void end_sync_request(struct r10bio *r10_bio)
> }
> }
>
> -static void end_sync_write(struct bio *bio, int error)
> +static void end_sync_write(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct r10bio *r10_bio = bio->bi_private;
> struct mddev *mddev = r10_bio->mddev;
> struct r10conf *conf = mddev->private;
> @@ -1996,7 +1994,7 @@ static void end_sync_write(struct bio *bio, int error)
> else
> rdev = conf->mirrors[d].rdev;
>
> - if (!uptodate) {
> + if (bio->bi_error) {
> if (repl)
> md_error(mddev, rdev);
> else {
> @@ -2044,7 +2042,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
>
> /* find the first device with a block */
> for (i=0; i<conf->copies; i++)
> - if (test_bit(BIO_UPTODATE, &r10_bio->devs[i].bio->bi_flags))
> + if (!r10_bio->devs[i].bio->bi_error)
> break;
>
> if (i == conf->copies)
> @@ -2064,7 +2062,7 @@ static void sync_request_write(struct mddev *mddev, struct r10bio *r10_bio)
> continue;
> if (i == first)
> continue;
> - if (test_bit(BIO_UPTODATE, &r10_bio->devs[i].bio->bi_flags)) {
> + if (!r10_bio->devs[i].bio->bi_error) {
> /* We know that the bi_io_vec layout is the same for
> * both 'first' and 'i', so we just compare them.
> * All vec entries are PAGE_SIZE;
> @@ -2706,8 +2704,7 @@ static void handle_write_completed(struct r10conf *conf, struct r10bio *r10_bio)
> rdev = conf->mirrors[dev].rdev;
> if (r10_bio->devs[m].bio == NULL)
> continue;
> - if (test_bit(BIO_UPTODATE,
> - &r10_bio->devs[m].bio->bi_flags)) {
> + if (!r10_bio->devs[m].bio->bi_error) {
> rdev_clear_badblocks(
> rdev,
> r10_bio->devs[m].addr,
> @@ -2722,8 +2719,8 @@ static void handle_write_completed(struct r10conf *conf, struct r10bio *r10_bio)
> rdev = conf->mirrors[dev].replacement;
> if (r10_bio->devs[m].repl_bio == NULL)
> continue;
> - if (test_bit(BIO_UPTODATE,
> - &r10_bio->devs[m].repl_bio->bi_flags)) {
> +
> + if (!r10_bio->devs[m].repl_bio->bi_error) {
> rdev_clear_badblocks(
> rdev,
> r10_bio->devs[m].addr,
> @@ -2748,8 +2745,7 @@ static void handle_write_completed(struct r10conf *conf, struct r10bio *r10_bio)
> r10_bio->devs[m].addr,
> r10_bio->sectors, 0);
> rdev_dec_pending(rdev, conf->mddev);
> - } else if (bio != NULL &&
> - !test_bit(BIO_UPTODATE, &bio->bi_flags)) {
> + } else if (bio != NULL && bio->bi_error) {
> if (!narrow_write_error(r10_bio, m)) {
> md_error(conf->mddev, rdev);
> set_bit(R10BIO_Degraded,
> @@ -3263,7 +3259,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
>
> bio = r10_bio->devs[i].bio;
> bio_reset(bio);
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
> if (conf->mirrors[d].rdev == NULL ||
> test_bit(Faulty, &conf->mirrors[d].rdev->flags))
> continue;
> @@ -3300,7 +3296,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
> /* Need to set up for writing to the replacement */
> bio = r10_bio->devs[i].repl_bio;
> bio_reset(bio);
> - clear_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = -EIO;
>
> sector = r10_bio->devs[i].addr;
> atomic_inc(&conf->mirrors[d].rdev->nr_pending);
> @@ -3377,7 +3373,7 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
>
> if (bio->bi_end_io == end_sync_read) {
> md_sync_acct(bio->bi_bdev, nr_sectors);
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
> + bio->bi_error = 0;
> generic_make_request(bio);
> }
> }
> @@ -4380,7 +4376,7 @@ read_more:
> read_bio->bi_end_io = end_sync_read;
> read_bio->bi_rw = READ;
> read_bio->bi_flags &= (~0UL << BIO_RESET_BITS);
> - __set_bit(BIO_UPTODATE, &read_bio->bi_flags);
> + read_bio->bi_error = 0;
> read_bio->bi_vcnt = 0;
> read_bio->bi_iter.bi_size = 0;
> r10_bio->master_bio = read_bio;
> @@ -4601,9 +4597,8 @@ static int handle_reshape_read_error(struct mddev *mddev,
> return 0;
> }
>
> -static void end_reshape_write(struct bio *bio, int error)
> +static void end_reshape_write(struct bio *bio)
> {
> - int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct r10bio *r10_bio = bio->bi_private;
> struct mddev *mddev = r10_bio->mddev;
> struct r10conf *conf = mddev->private;
> @@ -4620,7 +4615,7 @@ static void end_reshape_write(struct bio *bio, int error)
> rdev = conf->mirrors[d].rdev;
> }
>
> - if (!uptodate) {
> + if (bio->bi_error) {
> /* FIXME should record badblock */
> md_error(mddev, rdev);
> }
> diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
> index 59e44e9..84d6eec 100644
> --- a/drivers/md/raid5.c
> +++ b/drivers/md/raid5.c
> @@ -233,7 +233,7 @@ static void return_io(struct bio *return_bi)
> bi->bi_iter.bi_size = 0;
> trace_block_bio_complete(bdev_get_queue(bi->bi_bdev),
> bi, 0);
> - bio_endio(bi, 0);
> + bio_endio(bi);
> bi = return_bi;
> }
> }
> @@ -887,9 +887,9 @@ static int use_new_offset(struct r5conf *conf, struct stripe_head *sh)
> }
>
> static void
> -raid5_end_read_request(struct bio *bi, int error);
> +raid5_end_read_request(struct bio *bi);
> static void
> -raid5_end_write_request(struct bio *bi, int error);
> +raid5_end_write_request(struct bio *bi);
>
> static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
> {
> @@ -2277,12 +2277,11 @@ static void shrink_stripes(struct r5conf *conf)
> conf->slab_cache = NULL;
> }
>
> -static void raid5_end_read_request(struct bio * bi, int error)
> +static void raid5_end_read_request(struct bio * bi)
> {
> struct stripe_head *sh = bi->bi_private;
> struct r5conf *conf = sh->raid_conf;
> int disks = sh->disks, i;
> - int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
> char b[BDEVNAME_SIZE];
> struct md_rdev *rdev = NULL;
> sector_t s;
> @@ -2291,9 +2290,9 @@ static void raid5_end_read_request(struct bio * bi, int error)
> if (bi == &sh->dev[i].req)
> break;
>
> - pr_debug("end_read_request %llu/%d, count: %d, uptodate %d.\n",
> + pr_debug("end_read_request %llu/%d, count: %d, error %d.\n",
> (unsigned long long)sh->sector, i, atomic_read(&sh->count),
> - uptodate);
> + bi->bi_error);
> if (i == disks) {
> BUG();
> return;
> @@ -2312,7 +2311,7 @@ static void raid5_end_read_request(struct bio * bi, int error)
> s = sh->sector + rdev->new_data_offset;
> else
> s = sh->sector + rdev->data_offset;
> - if (uptodate) {
> + if (!bi->bi_error) {
> set_bit(R5_UPTODATE, &sh->dev[i].flags);
> if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
> /* Note that this cannot happen on a
> @@ -2400,13 +2399,12 @@ static void raid5_end_read_request(struct bio * bi, int error)
> release_stripe(sh);
> }
>
> -static void raid5_end_write_request(struct bio *bi, int error)
> +static void raid5_end_write_request(struct bio *bi)
> {
> struct stripe_head *sh = bi->bi_private;
> struct r5conf *conf = sh->raid_conf;
> int disks = sh->disks, i;
> struct md_rdev *uninitialized_var(rdev);
> - int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
> sector_t first_bad;
> int bad_sectors;
> int replacement = 0;
> @@ -2429,23 +2427,23 @@ static void raid5_end_write_request(struct bio *bi, int error)
> break;
> }
> }
> - pr_debug("end_write_request %llu/%d, count %d, uptodate: %d.\n",
> + pr_debug("end_write_request %llu/%d, count %d, error: %d.\n",
> (unsigned long long)sh->sector, i, atomic_read(&sh->count),
> - uptodate);
> + bi->bi_error);
> if (i == disks) {
> BUG();
> return;
> }
>
> if (replacement) {
> - if (!uptodate)
> + if (bi->bi_error)
> md_error(conf->mddev, rdev);
> else if (is_badblock(rdev, sh->sector,
> STRIPE_SECTORS,
> &first_bad, &bad_sectors))
> set_bit(R5_MadeGoodRepl, &sh->dev[i].flags);
> } else {
> - if (!uptodate) {
> + if (bi->bi_error) {
> set_bit(STRIPE_DEGRADED, &sh->state);
> set_bit(WriteErrorSeen, &rdev->flags);
> set_bit(R5_WriteError, &sh->dev[i].flags);
> @@ -2466,7 +2464,7 @@ static void raid5_end_write_request(struct bio *bi, int error)
> }
> rdev_dec_pending(rdev, conf->mddev);
>
> - if (sh->batch_head && !uptodate && !replacement)
> + if (sh->batch_head && bi->bi_error && !replacement)
> set_bit(STRIPE_BATCH_ERR, &sh->batch_head->state);
>
> if (!test_and_clear_bit(R5_DOUBLE_LOCKED, &sh->dev[i].flags))
> @@ -3107,7 +3105,8 @@ handle_failed_stripe(struct r5conf *conf, struct stripe_head *sh,
> while (bi && bi->bi_iter.bi_sector <
> sh->dev[i].sector + STRIPE_SECTORS) {
> struct bio *nextbi = r5_next_bio(bi, sh->dev[i].sector);
> - clear_bit(BIO_UPTODATE, &bi->bi_flags);
> +
> + bi->bi_error = -EIO;
> if (!raid5_dec_bi_active_stripes(bi)) {
> md_write_end(conf->mddev);
> bi->bi_next = *return_bi;
> @@ -3131,7 +3130,8 @@ handle_failed_stripe(struct r5conf *conf, struct stripe_head *sh,
> while (bi && bi->bi_iter.bi_sector <
> sh->dev[i].sector + STRIPE_SECTORS) {
> struct bio *bi2 = r5_next_bio(bi, sh->dev[i].sector);
> - clear_bit(BIO_UPTODATE, &bi->bi_flags);
> +
> + bi->bi_error = -EIO;
> if (!raid5_dec_bi_active_stripes(bi)) {
> md_write_end(conf->mddev);
> bi->bi_next = *return_bi;
> @@ -3156,7 +3156,8 @@ handle_failed_stripe(struct r5conf *conf, struct stripe_head *sh,
> sh->dev[i].sector + STRIPE_SECTORS) {
> struct bio *nextbi =
> r5_next_bio(bi, sh->dev[i].sector);
> - clear_bit(BIO_UPTODATE, &bi->bi_flags);
> +
> + bi->bi_error = -EIO;
> if (!raid5_dec_bi_active_stripes(bi)) {
> bi->bi_next = *return_bi;
> *return_bi = bi;
> @@ -4749,12 +4750,11 @@ static struct bio *remove_bio_from_retry(struct r5conf *conf)
> * first).
> * If the read failed..
> */
> -static void raid5_align_endio(struct bio *bi, int error)
> +static void raid5_align_endio(struct bio *bi)
> {
> struct bio* raid_bi = bi->bi_private;
> struct mddev *mddev;
> struct r5conf *conf;
> - int uptodate = test_bit(BIO_UPTODATE, &bi->bi_flags);
> struct md_rdev *rdev;
>
> bio_put(bi);
> @@ -4766,10 +4766,10 @@ static void raid5_align_endio(struct bio *bi, int error)
>
> rdev_dec_pending(rdev, conf->mddev);
>
> - if (!error && uptodate) {
> + if (!bi->bi_error) {
> trace_block_bio_complete(bdev_get_queue(raid_bi->bi_bdev),
> raid_bi, 0);
> - bio_endio(raid_bi, 0);
> + bio_endio(raid_bi);
> if (atomic_dec_and_test(&conf->active_aligned_reads))
> wake_up(&conf->wait_for_quiescent);
> return;
> @@ -5133,7 +5133,7 @@ static void make_discard_request(struct mddev *mddev, struct bio *bi)
> remaining = raid5_dec_bi_active_stripes(bi);
> if (remaining == 0) {
> md_write_end(mddev);
> - bio_endio(bi, 0);
> + bio_endio(bi);
> }
> }
>
> @@ -5297,7 +5297,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
> release_stripe_plug(mddev, sh);
> } else {
> /* cannot get stripe for read-ahead, just give-up */
> - clear_bit(BIO_UPTODATE, &bi->bi_flags);
> + bi->bi_error = -EIO;
> break;
> }
> }
> @@ -5311,7 +5311,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
>
> trace_block_bio_complete(bdev_get_queue(bi->bi_bdev),
> bi, 0);
> - bio_endio(bi, 0);
> + bio_endio(bi);
> }
> }
>
> @@ -5707,7 +5707,7 @@ static int retry_aligned_read(struct r5conf *conf, struct bio *raid_bio)
> if (remaining == 0) {
> trace_block_bio_complete(bdev_get_queue(raid_bio->bi_bdev),
> raid_bio, 0);
> - bio_endio(raid_bio, 0);
> + bio_endio(raid_bio);
> }
> if (atomic_dec_and_test(&conf->active_aligned_reads))
> wake_up(&conf->wait_for_quiescent);
> diff --git a/drivers/nvdimm/blk.c b/drivers/nvdimm/blk.c
> index 4f97b24..0df77cb 100644
> --- a/drivers/nvdimm/blk.c
> +++ b/drivers/nvdimm/blk.c
> @@ -180,7 +180,7 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
> * another kernel subsystem, and we just pass it through.
> */
> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
> - err = -EIO;
> + bio->bi_error = -EIO;
> goto out;
> }
>
> @@ -199,6 +199,7 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
> "io error in %s sector %lld, len %d,\n",
> (rw == READ) ? "READ" : "WRITE",
> (unsigned long long) iter.bi_sector, len);
> + bio->bi_error = err;
> break;
> }
> }
> @@ -206,7 +207,7 @@ static void nd_blk_make_request(struct request_queue *q, struct bio *bio)
> nd_iostat_end(bio, start);
>
> out:
> - bio_endio(bio, err);
> + bio_endio(bio);
> }
>
> static int nd_blk_rw_bytes(struct nd_namespace_common *ndns,
> diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
> index 411c7b2..341202e 100644
> --- a/drivers/nvdimm/btt.c
> +++ b/drivers/nvdimm/btt.c
> @@ -1189,7 +1189,7 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
> * another kernel subsystem, and we just pass it through.
> */
> if (bio_integrity_enabled(bio) && bio_integrity_prep(bio)) {
> - err = -EIO;
> + bio->bi_error = -EIO;
> goto out;
> }
>
> @@ -1211,6 +1211,7 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
> "io error in %s sector %lld, len %d,\n",
> (rw == READ) ? "READ" : "WRITE",
> (unsigned long long) iter.bi_sector, len);
> + bio->bi_error = err;
> break;
> }
> }
> @@ -1218,7 +1219,7 @@ static void btt_make_request(struct request_queue *q, struct bio *bio)
> nd_iostat_end(bio, start);
>
> out:
> - bio_endio(bio, err);
> + bio_endio(bio);
> }
>
> static int btt_rw_page(struct block_device *bdev, sector_t sector,
> diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
> index ade9eb9..4c079d5 100644
> --- a/drivers/nvdimm/pmem.c
> +++ b/drivers/nvdimm/pmem.c
> @@ -77,7 +77,7 @@ static void pmem_make_request(struct request_queue *q, struct bio *bio)
> if (bio_data_dir(bio))
> wmb_pmem();
>
> - bio_endio(bio, 0);
> + bio_endio(bio);
> }
>
> static int pmem_rw_page(struct block_device *bdev, sector_t sector,
> diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
> index da21281..8bcb822 100644
> --- a/drivers/s390/block/dcssblk.c
> +++ b/drivers/s390/block/dcssblk.c
> @@ -871,7 +871,7 @@ dcssblk_make_request(struct request_queue *q, struct bio *bio)
> }
> bytes_done += bvec.bv_len;
> }
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
> fail:
> bio_io_error(bio);
> diff --git a/drivers/s390/block/xpram.c b/drivers/s390/block/xpram.c
> index 7d4e939..93856b9 100644
> --- a/drivers/s390/block/xpram.c
> +++ b/drivers/s390/block/xpram.c
> @@ -220,8 +220,7 @@ static void xpram_make_request(struct request_queue *q, struct bio *bio)
> index++;
> }
> }
> - set_bit(BIO_UPTODATE, &bio->bi_flags);
> - bio_endio(bio, 0);
> + bio_endio(bio);
> return;
> fail:
> bio_io_error(bio);
> diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
> index 6d88d24..5a9982f 100644
> --- a/drivers/target/target_core_iblock.c
> +++ b/drivers/target/target_core_iblock.c
> @@ -306,20 +306,13 @@ static void iblock_complete_cmd(struct se_cmd *cmd)
> kfree(ibr);
> }
>
> -static void iblock_bio_done(struct bio *bio, int err)
> +static void iblock_bio_done(struct bio *bio)
> {
> struct se_cmd *cmd = bio->bi_private;
> struct iblock_req *ibr = cmd->priv;
>
> - /*
> - * Set -EIO if !BIO_UPTODATE and the passed is still err=0
> - */
> - if (!test_bit(BIO_UPTODATE, &bio->bi_flags) && !err)
> - err = -EIO;
> -
> - if (err != 0) {
> - pr_err("test_bit(BIO_UPTODATE) failed for bio: %p,"
> - " err: %d\n", bio, err);
> + if (bio->bi_error) {
> + pr_err("bio error: %p, err: %d\n", bio, bio->bi_error);
> /*
> * Bump the ib_bio_err_cnt and release bio.
> */
> @@ -370,15 +363,15 @@ static void iblock_submit_bios(struct bio_list *list, int rw)
> blk_finish_plug(&plug);
> }
>
> -static void iblock_end_io_flush(struct bio *bio, int err)
> +static void iblock_end_io_flush(struct bio *bio)
> {
> struct se_cmd *cmd = bio->bi_private;
>
> - if (err)
> - pr_err("IBLOCK: cache flush failed: %d\n", err);
> + if (bio->bi_error)
> + pr_err("IBLOCK: cache flush failed: %d\n", bio->bi_error);
>
> if (cmd) {
> - if (err)
> + if (bio->bi_error)
> target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
> else
> target_complete_cmd(cmd, SAM_STAT_GOOD);
> diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
> index 08e9084..de18790 100644
> --- a/drivers/target/target_core_pscsi.c
> +++ b/drivers/target/target_core_pscsi.c
> @@ -852,7 +852,7 @@ static ssize_t pscsi_show_configfs_dev_params(struct se_device *dev, char *b)
> return bl;
> }
>
> -static void pscsi_bi_endio(struct bio *bio, int error)
> +static void pscsi_bi_endio(struct bio *bio)
> {
> bio_put(bio);
> }
> @@ -973,7 +973,7 @@ fail:
> while (*hbio) {
> bio = *hbio;
> *hbio = (*hbio)->bi_next;
> - bio_endio(bio, 0); /* XXX: should be error */
> + bio_endio(bio);
> }
> return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
> }
> @@ -1061,7 +1061,7 @@ fail_free_bio:
> while (hbio) {
> struct bio *bio = hbio;
> hbio = hbio->bi_next;
> - bio_endio(bio, 0); /* XXX: should be error */
> + bio_endio(bio);
> }
> ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
> fail:
> diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
> index ce7dec8..541fbfa 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 ce62324..302266e 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 a9aadb2..a8c0de8 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 02d0581..c22f175 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 b33c0cf..6b8becf 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 fa72068..0a02e24 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 94db0fa..ebb8260 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 fbe7c10..8f2ca18 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 1cf7a53..7a49bb8 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 745d234..e1639c8 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 5602450..aa95566 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 ec3ef93..5de5b87 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 9bedfa8..8f0baa7 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 2c1ae86..c0a1b96 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 1e3a93f..02586e7 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 bc462dc..d301acf 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 16a0922..a3eb316 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 76279e1..cea0cc9 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 ca0244b..abac936 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 d2554fe..9cd4eb3 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 42468e5..550b10e 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 16eff45..140de3c 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 3859f5e..3714844 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 a4b7d92..01bd678 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);
> }
>
> diff --git a/include/linux/bio.h b/include/linux/bio.h
> index 5e963a6..6b91817 100644
> --- a/include/linux/bio.h
> +++ b/include/linux/bio.h
> @@ -195,8 +195,6 @@ static inline bool bvec_gap_to_prev(struct bio_vec *bprv, unsigned int offset)
> return offset || ((bprv->bv_offset + bprv->bv_len) & (PAGE_SIZE - 1));
> }
>
> -#define bio_io_error(bio) bio_endio((bio), -EIO)
> -
> /*
> * drivers should _never_ use the all version - the bio may have been split
> * before it got to the driver and the driver won't own all of it
> @@ -426,7 +424,14 @@ static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
>
> }
>
> -extern void bio_endio(struct bio *, int);
> +extern void bio_endio(struct bio *);
> +
> +static inline void bio_io_error(struct bio *bio)
> +{
> + bio->bi_error = -EIO;
> + bio_endio(bio);
> +}
> +
> struct request_queue;
> extern int bio_phys_segments(struct request_queue *, struct bio *);
>
> @@ -717,7 +722,7 @@ extern void bio_integrity_free(struct bio *);
> extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
> extern bool bio_integrity_enabled(struct bio *bio);
> extern int bio_integrity_prep(struct bio *);
> -extern void bio_integrity_endio(struct bio *, int);
> +extern void bio_integrity_endio(struct bio *);
> extern void bio_integrity_advance(struct bio *, unsigned int);
> extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
> extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
> diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
> index 7303b34..6164fb8 100644
> --- a/include/linux/blk_types.h
> +++ b/include/linux/blk_types.h
> @@ -14,7 +14,7 @@ struct page;
> struct block_device;
> struct io_context;
> struct cgroup_subsys_state;
> -typedef void (bio_end_io_t) (struct bio *, int);
> +typedef void (bio_end_io_t) (struct bio *);
> typedef void (bio_destructor_t) (struct bio *);
>
> /*
> @@ -53,6 +53,7 @@ struct bio {
>
> struct bvec_iter bi_iter;
>
> + int bi_error;
> /* Number of segments in this BIO after
> * physical address coalescing is performed.
> */
> @@ -111,7 +112,6 @@ struct bio {
> /*
> * bio flags
> */
> -#define BIO_UPTODATE 0 /* ok after I/O completion */
> #define BIO_SEG_VALID 1 /* bi_phys_segments valid */
> #define BIO_CLONED 2 /* doesn't own data */
> #define BIO_BOUNCED 3 /* bio is a bounce bio */
> diff --git a/include/linux/swap.h b/include/linux/swap.h
> index 3887472..31496d2 100644
> --- a/include/linux/swap.h
> +++ b/include/linux/swap.h
> @@ -373,9 +373,9 @@ static inline void mem_cgroup_uncharge_swap(swp_entry_t entry)
> /* linux/mm/page_io.c */
> extern int swap_readpage(struct page *);
> extern int swap_writepage(struct page *page, struct writeback_control *wbc);
> -extern void end_swap_bio_write(struct bio *bio, int err);
> +extern void end_swap_bio_write(struct bio *bio);
> extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
> - void (*end_write_func)(struct bio *, int));
> + bio_end_io_t end_write_func);
> extern int swap_set_page_dirty(struct page *page);
>
> int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
> diff --git a/kernel/power/swap.c b/kernel/power/swap.c
> index 2f30ca9..b2066fb 100644
> --- a/kernel/power/swap.c
> +++ b/kernel/power/swap.c
> @@ -227,27 +227,23 @@ static void hib_init_batch(struct hib_bio_batch *hb)
> hb->error = 0;
> }
>
> -static void hib_end_io(struct bio *bio, int error)
> +static void hib_end_io(struct bio *bio)
> {
> struct hib_bio_batch *hb = bio->bi_private;
> - const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct page *page = bio->bi_io_vec[0].bv_page;
>
> - if (!uptodate || error) {
> + if (bio->bi_error) {
> printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
> imajor(bio->bi_bdev->bd_inode),
> iminor(bio->bi_bdev->bd_inode),
> (unsigned long long)bio->bi_iter.bi_sector);
> -
> - if (!error)
> - error = -EIO;
> }
>
> if (bio_data_dir(bio) == WRITE)
> put_page(page);
>
> - if (error && !hb->error)
> - hb->error = error;
> + if (bio->bi_error && !hb->error)
> + hb->error = bio->bi_error;
> if (atomic_dec_and_test(&hb->count))
> wake_up(&hb->wait);
>
> diff --git a/kernel/trace/blktrace.c b/kernel/trace/blktrace.c
> index b3e6b39..90e72a0 100644
> --- a/kernel/trace/blktrace.c
> +++ b/kernel/trace/blktrace.c
> @@ -778,9 +778,6 @@ static void blk_add_trace_bio(struct request_queue *q, struct bio *bio,
> if (likely(!bt))
> return;
>
> - if (!error && !bio_flagged(bio, BIO_UPTODATE))
> - error = EIO;
> -
> __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
> bio->bi_rw, what, error, 0, NULL);
> }
> @@ -887,8 +884,7 @@ static void blk_add_trace_split(void *ignore,
>
> __blk_add_trace(bt, bio->bi_iter.bi_sector,
> bio->bi_iter.bi_size, bio->bi_rw, BLK_TA_SPLIT,
> - !bio_flagged(bio, BIO_UPTODATE),
> - sizeof(rpdu), &rpdu);
> + bio->bi_error, sizeof(rpdu), &rpdu);
> }
> }
>
> @@ -920,8 +916,8 @@ static void blk_add_trace_bio_remap(void *ignore,
> r.sector_from = cpu_to_be64(from);
>
> __blk_add_trace(bt, bio->bi_iter.bi_sector, bio->bi_iter.bi_size,
> - bio->bi_rw, BLK_TA_REMAP,
> - !bio_flagged(bio, BIO_UPTODATE), sizeof(r), &r);
> + bio->bi_rw, BLK_TA_REMAP, bio->bi_error,
> + sizeof(r), &r);
> }
>
> /**
> diff --git a/mm/page_io.c b/mm/page_io.c
> index 520baa4..338ce68 100644
> --- a/mm/page_io.c
> +++ b/mm/page_io.c
> @@ -43,12 +43,11 @@ static struct bio *get_swap_bio(gfp_t gfp_flags,
> return bio;
> }
>
> -void end_swap_bio_write(struct bio *bio, int err)
> +void end_swap_bio_write(struct bio *bio)
> {
> - const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct page *page = bio->bi_io_vec[0].bv_page;
>
> - if (!uptodate) {
> + if (bio->bi_error) {
> SetPageError(page);
> /*
> * We failed to write the page out to swap-space.
> @@ -69,12 +68,11 @@ void end_swap_bio_write(struct bio *bio, int err)
> bio_put(bio);
> }
>
> -static void end_swap_bio_read(struct bio *bio, int err)
> +static void end_swap_bio_read(struct bio *bio)
> {
> - const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
> struct page *page = bio->bi_io_vec[0].bv_page;
>
> - if (!uptodate) {
> + if (bio->bi_error) {
> SetPageError(page);
> ClearPageUptodate(page);
> printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
> @@ -254,7 +252,7 @@ static sector_t swap_page_sector(struct page *page)
> }
>
> int __swap_writepage(struct page *page, struct writeback_control *wbc,
> - void (*end_write_func)(struct bio *, int))
> + bio_end_io_t end_write_func)
> {
> struct bio *bio;
> int ret, rw = WRITE;
> --
> 1.9.1
>
--
dm-devel mailing list
dm-devel@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/dm-devel
