34 files changed, 220 insertions, 209 deletions

diff --git a/fs/block_dev.c b/fs/block_dev.c
index c1dc393ad6b9..bcd8e16a34e1 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -262,8 +262,8 @@ __blkdev_direct_IO_simple(struct kiocb *iocb, struct iov_iter *iter,
         if (vecs != inline_vecs)
                 kfree(vecs);
 
-        if (unlikely(bio.bi_error))
-                return bio.bi_error;
+        if (unlikely(bio.bi_status))
+                return blk_status_to_errno(bio.bi_status);
         return ret;
 }
 
@@ -288,16 +288,18 @@ static void blkdev_bio_end_io(struct bio *bio)
         bool should_dirty = dio->should_dirty;
 
         if (dio->multi_bio && !atomic_dec_and_test(&dio->ref)) {
-                if (bio->bi_error && !dio->bio.bi_error)
-                        dio->bio.bi_error = bio->bi_error;
+                if (bio->bi_status && !dio->bio.bi_status)
+                        dio->bio.bi_status = bio->bi_status;
         } else {
                 if (!dio->is_sync) {
                         struct kiocb *iocb = dio->iocb;
-                        ssize_t ret = dio->bio.bi_error;
+                        ssize_t ret;
 
-                        if (likely(!ret)) {
+                        if (likely(!dio->bio.bi_status)) {
                                 ret = dio->size;
                                 iocb->ki_pos += ret;
+                        } else {
+                                ret = blk_status_to_errno(dio->bio.bi_status);
                         }
 
                         dio->iocb->ki_complete(iocb, ret, 0);
@@ -363,7 +365,7 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)
 
                 ret = bio_iov_iter_get_pages(bio, iter);
                 if (unlikely(ret)) {
-                        bio->bi_error = -EIO;
+                        bio->bi_status = BLK_STS_IOERR;
                         bio_endio(bio);
                         break;
                 }
@@ -413,7 +415,7 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)
         __set_current_state(TASK_RUNNING);
 
         if (!ret)
-                ret = dio->bio.bi_error;
+                ret = blk_status_to_errno(dio->bio.bi_status);
         if (likely(!ret))
                 ret = dio->size;
 
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index b8622e4d1744..d87ac27a5f2b 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -310,7 +310,8 @@ struct btrfs_dio_private {
          * The original bio may be split to several sub-bios, this is
          * done during endio of sub-bios
          */
-        int (*subio_endio)(struct inode *, struct btrfs_io_bio *, int);
+        blk_status_t (*subio_endio)(struct inode *, struct btrfs_io_bio *,
+                        blk_status_t);
 };
 
 /*
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index ab14c2e635ca..4ded1c3f92b8 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -2129,7 +2129,7 @@ static void btrfsic_bio_end_io(struct bio *bp)
         /* mutex is not held! This is not save if IO is not yet completed
          * on umount */
         iodone_w_error = 0;
-        if (bp->bi_error)
+        if (bp->bi_status)
                 iodone_w_error = 1;
 
         BUG_ON(NULL == block);
@@ -2143,7 +2143,7 @@ static void btrfsic_bio_end_io(struct bio *bp)
                 if ((dev_state->state->print_mask &
                      BTRFSIC_PRINT_MASK_END_IO_BIO_BH))
                         pr_info("bio_end_io(err=%d) for %c @%llu (%s/%llu/%d)\n",
-                               bp->bi_error,
+                               bp->bi_status,
                                btrfsic_get_block_type(dev_state->state, block),
                                block->logical_bytenr, dev_state->name,
                                block->dev_bytenr, block->mirror_num);
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 10e6b282d09d..9ac55b266e78 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -155,7 +155,7 @@ static void end_compressed_bio_read(struct bio *bio)
         unsigned long index;
         int ret;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 cb->errors = 1;
 
         /* if there are more bios still pending for this compressed
@@ -268,7 +268,7 @@ static void end_compressed_bio_write(struct bio *bio)
         struct page *page;
         unsigned long index;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 cb->errors = 1;
 
         /* if there are more bios still pending for this compressed
@@ -287,7 +287,7 @@ static void end_compressed_bio_write(struct bio *bio)
                                          cb->start,
                                          cb->start + cb->len - 1,
                                          NULL,
-                                         bio->bi_error ? 0 : 1);
+                                         bio->bi_status ? 0 : 1);
         cb->compressed_pages[0]->mapping = NULL;
 
         end_compressed_writeback(inode, cb);
@@ -320,7 +320,7 @@ out:
  * This also checksums the file bytes and gets things ready for
  * the end io hooks.
  */
-int btrfs_submit_compressed_write(struct inode *inode, u64 start,
+blk_status_t btrfs_submit_compressed_write(struct inode *inode, u64 start,
                                  unsigned long len, u64 disk_start,
                                  unsigned long compressed_len,
                                  struct page **compressed_pages,
@@ -335,13 +335,13 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         struct page *page;
         u64 first_byte = disk_start;
         struct block_device *bdev;
-        int ret;
+        blk_status_t ret;
         int skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
         WARN_ON(start & ((u64)PAGE_SIZE - 1));
         cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
         if (!cb)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
         refcount_set(&cb->pending_bios, 0);
         cb->errors = 0;
         cb->inode = inode;
@@ -358,7 +358,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
         if (!bio) {
                 kfree(cb);
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
         }
         bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
         bio->bi_private = cb;
@@ -368,17 +368,17 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         /* create and submit bios for the compressed pages */
         bytes_left = compressed_len;
         for (pg_index = 0; pg_index < cb->nr_pages; pg_index++) {
+                int submit = 0;
+
                 page = compressed_pages[pg_index];
                 page->mapping = inode->i_mapping;
                 if (bio->bi_iter.bi_size)
-                        ret = io_tree->ops->merge_bio_hook(page, 0,
+                        submit = io_tree->ops->merge_bio_hook(page, 0,
                                                            PAGE_SIZE,
                                                            bio, 0);
-                else
-                        ret = 0;
 
                 page->mapping = NULL;
-                if (ret || bio_add_page(bio, page, PAGE_SIZE, 0) <
+                if (submit || bio_add_page(bio, page, PAGE_SIZE, 0) <
                     PAGE_SIZE) {
                         bio_get(bio);
 
@@ -400,7 +400,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 
                         ret = btrfs_map_bio(fs_info, bio, 0, 1);
                         if (ret) {
-                                bio->bi_error = ret;
+                                bio->bi_status = ret;
                                 bio_endio(bio);
                         }
 
@@ -434,7 +434,7 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
 
         ret = btrfs_map_bio(fs_info, bio, 0, 1);
         if (ret) {
-                bio->bi_error = ret;
+                bio->bi_status = ret;
                 bio_endio(bio);
         }
 
@@ -569,7 +569,7 @@ next:
  * After the compressed pages are read, we copy the bytes into the
  * bio we were passed and then call the bio end_io calls
  */
-int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -586,7 +586,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         u64 em_len;
         u64 em_start;
         struct extent_map *em;
-        int ret = -ENOMEM;
+        blk_status_t ret = BLK_STS_RESOURCE;
         int faili = 0;
         u32 *sums;
 
@@ -600,7 +600,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                    PAGE_SIZE);
         read_unlock(&em_tree->lock);
         if (!em)
-                return -EIO;
+                return BLK_STS_IOERR;
 
         compressed_len = em->block_len;
         cb = kmalloc(compressed_bio_size(fs_info, compressed_len), GFP_NOFS);
@@ -659,19 +659,19 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         refcount_set(&cb->pending_bios, 1);
 
         for (pg_index = 0; pg_index < nr_pages; pg_index++) {
+                int submit = 0;
+
                 page = cb->compressed_pages[pg_index];
                 page->mapping = inode->i_mapping;
                 page->index = em_start >> PAGE_SHIFT;
 
                 if (comp_bio->bi_iter.bi_size)
-                        ret = tree->ops->merge_bio_hook(page, 0,
+                        submit = tree->ops->merge_bio_hook(page, 0,
                                                         PAGE_SIZE,
                                                         comp_bio, 0);
-                else
-                        ret = 0;
 
                 page->mapping = NULL;
-                if (ret || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <
+                if (submit || bio_add_page(comp_bio, page, PAGE_SIZE, 0) <
                     PAGE_SIZE) {
                         bio_get(comp_bio);
 
@@ -697,7 +697,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 
                         ret = btrfs_map_bio(fs_info, comp_bio, mirror_num, 0);
                         if (ret) {
-                                comp_bio->bi_error = ret;
+                                comp_bio->bi_status = ret;
                                 bio_endio(comp_bio);
                         }
 
@@ -726,7 +726,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
 
         ret = btrfs_map_bio(fs_info, comp_bio, mirror_num, 0);
         if (ret) {
-                comp_bio->bi_error = ret;
+                comp_bio->bi_status = ret;
                 bio_endio(comp_bio);
         }
 
diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h
index 39ec43ab8df1..680d4265d601 100644
--- a/fs/btrfs/compression.h
+++ b/fs/btrfs/compression.h
@@ -48,12 +48,12 @@ int btrfs_decompress_buf2page(const char *buf, unsigned long buf_start,
                               unsigned long total_out, u64 disk_start,
                               struct bio *bio);
 
-int btrfs_submit_compressed_write(struct inode *inode, u64 start,
+blk_status_t btrfs_submit_compressed_write(struct inode *inode, u64 start,
                                   unsigned long len, u64 disk_start,
                                   unsigned long compressed_len,
                                   struct page **compressed_pages,
                                   unsigned long nr_pages);
-int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags);
 
 enum btrfs_compression_type {
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 643c70d2b2e6..d2da0a52d560 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3078,8 +3078,8 @@ int btrfs_find_name_in_ext_backref(struct btrfs_path *path,
 struct btrfs_dio_private;
 int btrfs_del_csums(struct btrfs_trans_handle *trans,
                     struct btrfs_fs_info *fs_info, u64 bytenr, u64 len);
-int btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst);
-int btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst);
+blk_status_t btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio,
                               u64 logical_offset);
 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
@@ -3094,7 +3094,7 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root,
                            struct btrfs_ordered_sum *sums);
-int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
                        u64 file_start, int contig);
 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
                              struct list_head *list, int search_commit);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 8685d67185d0..46accc75ad5a 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -87,7 +87,7 @@ struct btrfs_end_io_wq {
         bio_end_io_t *end_io;
         void *private;
         struct btrfs_fs_info *info;
-        int error;
+        blk_status_t status;
         enum btrfs_wq_endio_type metadata;
         struct list_head list;
         struct btrfs_work work;
@@ -131,7 +131,7 @@ struct async_submit_bio {
          */
         u64 bio_offset;
         struct btrfs_work work;
-        int error;
+        blk_status_t status;
 };
 
 /*
@@ -799,7 +799,7 @@ static void end_workqueue_bio(struct bio *bio)
         btrfs_work_func_t func;
 
         fs_info = end_io_wq->info;
-        end_io_wq->error = bio->bi_error;
+        end_io_wq->status = bio->bi_status;
 
         if (bio_op(bio) == REQ_OP_WRITE) {
                 if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
@@ -836,19 +836,19 @@ static void end_workqueue_bio(struct bio *bio)
         btrfs_queue_work(wq, &end_io_wq->work);
 }
 
-int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
+blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
                         enum btrfs_wq_endio_type metadata)
 {
         struct btrfs_end_io_wq *end_io_wq;
 
         end_io_wq = kmem_cache_alloc(btrfs_end_io_wq_cache, GFP_NOFS);
         if (!end_io_wq)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
 
         end_io_wq->private = bio->bi_private;
         end_io_wq->end_io = bio->bi_end_io;
         end_io_wq->info = info;
-        end_io_wq->error = 0;
+        end_io_wq->status = 0;
         end_io_wq->bio = bio;
         end_io_wq->metadata = metadata;
 
@@ -868,14 +868,14 @@ unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
 static void run_one_async_start(struct btrfs_work *work)
 {
         struct async_submit_bio *async;
-        int ret;
+        blk_status_t ret;
 
         async = container_of(work, struct  async_submit_bio, work);
         ret = async->submit_bio_start(async->inode, async->bio,
                                       async->mirror_num, async->bio_flags,
                                       async->bio_offset);
         if (ret)
-                async->error = ret;
+                async->status = ret;
 }
 
 static void run_one_async_done(struct btrfs_work *work)
@@ -898,8 +898,8 @@ static void run_one_async_done(struct btrfs_work *work)
                 wake_up(&fs_info->async_submit_wait);
 
         /* If an error occurred we just want to clean up the bio and move on */
-        if (async->error) {
-                async->bio->bi_error = async->error;
+        if (async->status) {
+                async->bio->bi_status = async->status;
                 bio_endio(async->bio);
                 return;
         }
@@ -916,18 +916,17 @@ static void run_one_async_free(struct btrfs_work *work)
         kfree(async);
 }
 
-int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
-                        struct bio *bio, int mirror_num,
-                        unsigned long bio_flags,
-                        u64 bio_offset,
-                        extent_submit_bio_hook_t *submit_bio_start,
-                        extent_submit_bio_hook_t *submit_bio_done)
+blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info,
+                struct inode *inode, struct bio *bio, int mirror_num,
+                unsigned long bio_flags, u64 bio_offset,
+                extent_submit_bio_hook_t *submit_bio_start,
+                extent_submit_bio_hook_t *submit_bio_done)
 {
         struct async_submit_bio *async;
 
         async = kmalloc(sizeof(*async), GFP_NOFS);
         if (!async)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
 
         async->inode = inode;
         async->bio = bio;
@@ -941,7 +940,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
         async->bio_flags = bio_flags;
         async->bio_offset = bio_offset;
 
-        async->error = 0;
+        async->status = 0;
 
         atomic_inc(&fs_info->nr_async_submits);
 
@@ -959,7 +958,7 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
         return 0;
 }
 
-static int btree_csum_one_bio(struct bio *bio)
+static blk_status_t btree_csum_one_bio(struct bio *bio)
 {
         struct bio_vec *bvec;
         struct btrfs_root *root;
@@ -972,12 +971,12 @@ static int btree_csum_one_bio(struct bio *bio)
                         break;
         }
 
-        return ret;
+        return errno_to_blk_status(ret);
 }
 
-static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,
-                                    int mirror_num, unsigned long bio_flags,
-                                    u64 bio_offset)
+static blk_status_t __btree_submit_bio_start(struct inode *inode,
+                struct bio *bio, int mirror_num, unsigned long bio_flags,
+                u64 bio_offset)
 {
         /*
          * when we're called for a write, we're already in the async
@@ -986,11 +985,11 @@ static int __btree_submit_bio_start(struct inode *inode, struct bio *bio,
         return btree_csum_one_bio(bio);
 }
 
-static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,
-                                 int mirror_num, unsigned long bio_flags,
-                                 u64 bio_offset)
+static blk_status_t __btree_submit_bio_done(struct inode *inode,
+                struct bio *bio, int mirror_num, unsigned long bio_flags,
+                u64 bio_offset)
 {
-        int ret;
+        blk_status_t ret;
 
         /*
          * when we're called for a write, we're already in the async
@@ -998,7 +997,7 @@ static int __btree_submit_bio_done(struct inode *inode, struct bio *bio,
          */
         ret = btrfs_map_bio(btrfs_sb(inode->i_sb), bio, mirror_num, 1);
         if (ret) {
-                bio->bi_error = ret;
+                bio->bi_status = ret;
                 bio_endio(bio);
         }
         return ret;
@@ -1015,13 +1014,13 @@ static int check_async_write(unsigned long bio_flags)
         return 1;
 }
 
-static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,
+static blk_status_t btree_submit_bio_hook(struct inode *inode, struct bio *bio,
                                  int mirror_num, unsigned long bio_flags,
                                  u64 bio_offset)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
         int async = check_async_write(bio_flags);
-        int ret;
+        blk_status_t ret;
 
         if (bio_op(bio) != REQ_OP_WRITE) {
                 /*
@@ -1054,7 +1053,7 @@ static int btree_submit_bio_hook(struct inode *inode, struct bio *bio,
         return 0;
 
 out_w_error:
-        bio->bi_error = ret;
+        bio->bi_status = ret;
         bio_endio(bio);
         return ret;
 }
@@ -1820,7 +1819,7 @@ static void end_workqueue_fn(struct btrfs_work *work)
         end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
         bio = end_io_wq->bio;
 
-        bio->bi_error = end_io_wq->error;
+        bio->bi_status = end_io_wq->status;
         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);
@@ -3495,11 +3494,11 @@ static void btrfs_end_empty_barrier(struct bio *bio)
  * any device where the flush fails with eopnotsupp are flagged as not-barrier
  * capable
  */
-static int write_dev_flush(struct btrfs_device *device, int wait)
+static blk_status_t write_dev_flush(struct btrfs_device *device, int wait)
 {
         struct request_queue *q = bdev_get_queue(device->bdev);
         struct bio *bio;
-        int ret = 0;
+        blk_status_t ret = 0;
 
         if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags))
                 return 0;
@@ -3511,8 +3510,8 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
 
                 wait_for_completion(&device->flush_wait);
 
-                if (bio->bi_error) {
-                        ret = bio->bi_error;
+                if (bio->bi_status) {
+                        ret = bio->bi_status;
                         btrfs_dev_stat_inc_and_print(device,
                                 BTRFS_DEV_STAT_FLUSH_ERRS);
                 }
@@ -3531,7 +3530,7 @@ static int write_dev_flush(struct btrfs_device *device, int wait)
         device->flush_bio = NULL;
         bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
         if (!bio)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
 
         bio->bi_end_io = btrfs_end_empty_barrier;
         bio->bi_bdev = device->bdev;
@@ -3556,7 +3555,7 @@ static int barrier_all_devices(struct btrfs_fs_info *info)
         struct btrfs_device *dev;
         int errors_send = 0;
         int errors_wait = 0;
-        int ret;
+        blk_status_t ret;
 
         /* send down all the barriers */
         head = &info->fs_devices->devices;
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h
index 21f1ceb85b76..c581927555f3 100644
--- a/fs/btrfs/disk-io.h
+++ b/fs/btrfs/disk-io.h
@@ -118,13 +118,13 @@ int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
 int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid);
 u32 btrfs_csum_data(const char *data, u32 seed, size_t len);
 void btrfs_csum_final(u32 crc, u8 *result);
-int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
+blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
                         enum btrfs_wq_endio_type metadata);
-int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
-                        struct bio *bio, int mirror_num,
-                        unsigned long bio_flags, u64 bio_offset,
-                        extent_submit_bio_hook_t *submit_bio_start,
-                        extent_submit_bio_hook_t *submit_bio_done);
+blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info,
+                struct inode *inode, struct bio *bio, int mirror_num,
+                unsigned long bio_flags, u64 bio_offset,
+                extent_submit_bio_hook_t *submit_bio_start,
+                extent_submit_bio_hook_t *submit_bio_done);
 unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info);
 int btrfs_write_tree_block(struct extent_buffer *buf);
 int btrfs_wait_tree_block_writeback(struct extent_buffer *buf);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index d8da3edf2ac3..35cbb6ceb70d 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -2399,6 +2399,7 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
         struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
         struct bio *bio;
         int read_mode = 0;
+        blk_status_t status;
         int ret;
 
         BUG_ON(bio_op(failed_bio) == REQ_OP_WRITE);
@@ -2431,11 +2432,12 @@ static int bio_readpage_error(struct bio *failed_bio, u64 phy_offset,
                 "Repair Read Error: submitting new read[%#x] to this_mirror=%d, in_validation=%d",
                 read_mode, failrec->this_mirror, failrec->in_validation);
 
-        ret = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,
+        status = tree->ops->submit_bio_hook(inode, bio, failrec->this_mirror,
                                          failrec->bio_flags, 0);
-        if (ret) {
+        if (status) {
                 free_io_failure(BTRFS_I(inode), failrec);
                 bio_put(bio);
+                ret = blk_status_to_errno(status);
         }
 
         return ret;
@@ -2474,6 +2476,7 @@ void end_extent_writepage(struct page *page, int err, u64 start, u64 end)
  */
 static void end_bio_extent_writepage(struct bio *bio)
 {
+        int error = blk_status_to_errno(bio->bi_status);
         struct bio_vec *bvec;
         u64 start;
         u64 end;
@@ -2503,7 +2506,7 @@ static void end_bio_extent_writepage(struct bio *bio)
                 start = page_offset(page);
                 end = start + bvec->bv_offset + bvec->bv_len - 1;
 
-                end_extent_writepage(page, bio->bi_error, start, end);
+                end_extent_writepage(page, error, start, end);
                 end_page_writeback(page);
         }
 
@@ -2536,7 +2539,7 @@ endio_readpage_release_extent(struct extent_io_tree *tree, u64 start, u64 len,
 static void end_bio_extent_readpage(struct bio *bio)
 {
         struct bio_vec *bvec;
-        int uptodate = !bio->bi_error;
+        int uptodate = !bio->bi_status;
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
         struct extent_io_tree *tree;
         u64 offset = 0;
@@ -2556,7 +2559,7 @@ static void end_bio_extent_readpage(struct bio *bio)
 
                 btrfs_debug(fs_info,
                         "end_bio_extent_readpage: bi_sector=%llu, err=%d, mirror=%u",
-                        (u64)bio->bi_iter.bi_sector, bio->bi_error,
+                        (u64)bio->bi_iter.bi_sector, bio->bi_status,
                         io_bio->mirror_num);
                 tree = &BTRFS_I(inode)->io_tree;
 
@@ -2615,7 +2618,7 @@ static void end_bio_extent_readpage(struct bio *bio)
                                 ret = bio_readpage_error(bio, offset, page,
                                                          start, end, mirror);
                                 if (ret == 0) {
-                                        uptodate = !bio->bi_error;
+                                        uptodate = !bio->bi_status;
                                         offset += len;
                                         continue;
                                 }
@@ -2673,7 +2676,7 @@ readpage_ok:
                 endio_readpage_release_extent(tree, extent_start, extent_len,
                                               uptodate);
         if (io_bio->end_io)
-                io_bio->end_io(io_bio, bio->bi_error);
+                io_bio->end_io(io_bio, blk_status_to_errno(bio->bi_status));
         bio_put(bio);
 }
 
@@ -2743,7 +2746,7 @@ struct bio *btrfs_io_bio_alloc(gfp_t gfp_mask, unsigned int nr_iovecs)
 static int __must_check submit_one_bio(struct bio *bio, int mirror_num,
                                        unsigned long bio_flags)
 {
-        int ret = 0;
+        blk_status_t ret = 0;
         struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
         struct page *page = bvec->bv_page;
         struct extent_io_tree *tree = bio->bi_private;
@@ -2761,7 +2764,7 @@ static int __must_check submit_one_bio(struct bio *bio, int mirror_num,
                 btrfsic_submit_bio(bio);
 
         bio_put(bio);
-        return ret;
+        return blk_status_to_errno(ret);
 }
 
 static int merge_bio(struct extent_io_tree *tree, struct page *page,
@@ -3707,7 +3710,7 @@ static void end_bio_extent_buffer_writepage(struct bio *bio)
                 BUG_ON(!eb);
                 done = atomic_dec_and_test(&eb->io_pages);
 
-                if (bio->bi_error ||
+                if (bio->bi_status ||
                     test_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags)) {
                         ClearPageUptodate(page);
                         set_btree_ioerr(page);
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 1eafa2f0ede3..487ca0207cb6 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -92,9 +92,9 @@ struct btrfs_inode;
 struct btrfs_io_bio;
 struct io_failure_record;
 
-typedef int (extent_submit_bio_hook_t)(struct inode *inode, struct bio *bio,
-                                       int mirror_num, unsigned long bio_flags,
-                                       u64 bio_offset);
+typedef blk_status_t (extent_submit_bio_hook_t)(struct inode *inode,
+                struct bio *bio, int mirror_num, unsigned long bio_flags,
+                u64 bio_offset);
 struct extent_io_ops {
         /*
          * The following callbacks must be allways defined, the function
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 64fcb31d7163..5b1c7090e546 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -160,7 +160,7 @@ static void btrfs_io_bio_endio_readpage(struct btrfs_io_bio *bio, int err)
         kfree(bio->csum_allocated);
 }
 
-static int __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
+static blk_status_t __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
                                    u64 logical_offset, u32 *dst, int dio)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -182,7 +182,7 @@ static int __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
 
         path = btrfs_alloc_path();
         if (!path)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
 
         nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
         if (!dst) {
@@ -191,7 +191,7 @@ static int __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
                                         csum_size, GFP_NOFS);
                         if (!btrfs_bio->csum_allocated) {
                                 btrfs_free_path(path);
-                                return -ENOMEM;
+                                return BLK_STS_RESOURCE;
                         }
                         btrfs_bio->csum = btrfs_bio->csum_allocated;
                         btrfs_bio->end_io = btrfs_io_bio_endio_readpage;
@@ -303,12 +303,12 @@ next:
         return 0;
 }
 
-int btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst)
+blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u32 *dst)
 {
         return __btrfs_lookup_bio_sums(inode, bio, 0, dst, 0);
 }
 
-int btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio, u64 offset)
+blk_status_t btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio, u64 offset)
 {
         return __btrfs_lookup_bio_sums(inode, bio, offset, NULL, 1);
 }
@@ -433,7 +433,7 @@ fail:
         return ret;
 }
 
-int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
+blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
                        u64 file_start, int contig)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
@@ -452,7 +452,7 @@ int btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
         sums = kzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
                        GFP_NOFS);
         if (!sums)
-                return -ENOMEM;
+                return BLK_STS_RESOURCE;
 
         sums->len = bio->bi_iter.bi_size;
         INIT_LIST_HEAD(&sums->list);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 758b2666885e..ea7cae1003eb 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -842,13 +842,12 @@ retry:
                                 NULL, EXTENT_LOCKED | EXTENT_DELALLOC,
                                 PAGE_UNLOCK | PAGE_CLEAR_DIRTY |
                                 PAGE_SET_WRITEBACK);
-                ret = btrfs_submit_compressed_write(inode,
+                if (btrfs_submit_compressed_write(inode,
                                     async_extent->start,
                                     async_extent->ram_size,
                                     ins.objectid,
                                     ins.offset, async_extent->pages,
-                                    async_extent->nr_pages);
-                if (ret) {
+                                    async_extent->nr_pages)) {
                         struct extent_io_tree *tree = &BTRFS_I(inode)->io_tree;
                         struct page *p = async_extent->pages[0];
                         const u64 start = async_extent->start;
@@ -1901,11 +1900,11 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
  * At IO completion time the cums attached on the ordered extent record
  * are inserted into the btree
  */
-static int __btrfs_submit_bio_start(struct inode *inode, struct bio *bio,
-                                    int mirror_num, unsigned long bio_flags,
-                                    u64 bio_offset)
+static blk_status_t __btrfs_submit_bio_start(struct inode *inode,
+                struct bio *bio, int mirror_num, unsigned long bio_flags,
+                u64 bio_offset)
 {
-        int ret = 0;
+        blk_status_t ret = 0;
 
         ret = btrfs_csum_one_bio(inode, bio, 0, 0);
         BUG_ON(ret); /* -ENOMEM */
@@ -1920,16 +1919,16 @@ static int __btrfs_submit_bio_start(struct inode *inode, struct bio *bio,
  * At IO completion time the cums attached on the ordered extent record
  * are inserted into the btree
  */
-static int __btrfs_submit_bio_done(struct inode *inode, struct bio *bio,
-                          int mirror_num, unsigned long bio_flags,
-                          u64 bio_offset)
+static blk_status_t __btrfs_submit_bio_done(struct inode *inode,
+                struct bio *bio, int mirror_num, unsigned long bio_flags,
+                u64 bio_offset)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-        int ret;
+        blk_status_t ret;
 
         ret = btrfs_map_bio(fs_info, bio, mirror_num, 1);
         if (ret) {
-                bio->bi_error = ret;
+                bio->bi_status = ret;
                 bio_endio(bio);
         }
         return ret;
@@ -1939,14 +1938,14 @@ static int __btrfs_submit_bio_done(struct inode *inode, struct bio *bio,
  * extent_io.c submission hook. This does the right thing for csum calculation
  * on write, or reading the csums from the tree before a read
  */
-static int btrfs_submit_bio_hook(struct inode *inode, struct bio *bio,
+static blk_status_t btrfs_submit_bio_hook(struct inode *inode, struct bio *bio,
                           int mirror_num, unsigned long bio_flags,
                           u64 bio_offset)
 {
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
         struct btrfs_root *root = BTRFS_I(inode)->root;
         enum btrfs_wq_endio_type metadata = BTRFS_WQ_ENDIO_DATA;
-        int ret = 0;
+        blk_status_t ret = 0;
         int skip_sum;
         int async = !atomic_read(&BTRFS_I(inode)->sync_writers);
 
@@ -1991,8 +1990,8 @@ mapit:
         ret = btrfs_map_bio(fs_info, bio, mirror_num, 0);
 
 out:
-        if (ret < 0) {
-                bio->bi_error = ret;
+        if (ret) {
+                bio->bi_status = ret;
                 bio_endio(bio);
         }
         return ret;
@@ -8037,7 +8036,7 @@ static void btrfs_retry_endio_nocsum(struct bio *bio)
         struct bio_vec *bvec;
         int i;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 goto end;
 
         ASSERT(bio->bi_vcnt == 1);
@@ -8116,7 +8115,7 @@ static void btrfs_retry_endio(struct bio *bio)
         int ret;
         int i;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 goto end;
 
         uptodate = 1;
@@ -8141,8 +8140,8 @@ end:
         bio_put(bio);
 }
 
-static int __btrfs_subio_endio_read(struct inode *inode,
-                                    struct btrfs_io_bio *io_bio, int err)
+static blk_status_t __btrfs_subio_endio_read(struct inode *inode,
+                struct btrfs_io_bio *io_bio, blk_status_t err)
 {
         struct btrfs_fs_info *fs_info;
         struct bio_vec *bvec;
@@ -8184,7 +8183,7 @@ try_again:
                                 io_bio->mirror_num,
                                 btrfs_retry_endio, &done);
                 if (ret) {
-                        err = ret;
+                        err = errno_to_blk_status(ret);
                         goto next;
                 }
 
@@ -8211,8 +8210,8 @@ next:
         return err;
 }
 
-static int btrfs_subio_endio_read(struct inode *inode,
-                                  struct btrfs_io_bio *io_bio, int err)
+static blk_status_t btrfs_subio_endio_read(struct inode *inode,
+                struct btrfs_io_bio *io_bio, blk_status_t err)
 {
         bool skip_csum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;
 
@@ -8232,7 +8231,7 @@ static void btrfs_endio_direct_read(struct bio *bio)
         struct inode *inode = dip->inode;
         struct bio *dio_bio;
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
-        int err = bio->bi_error;
+        blk_status_t err = bio->bi_status;
 
         if (dip->flags & BTRFS_DIO_ORIG_BIO_SUBMITTED)
                 err = btrfs_subio_endio_read(inode, io_bio, err);
@@ -8243,11 +8242,11 @@ static void btrfs_endio_direct_read(struct bio *bio)
 
         kfree(dip);
 
-        dio_bio->bi_error = bio->bi_error;
+        dio_bio->bi_status = bio->bi_status;
         dio_end_io(dio_bio);
 
         if (io_bio->end_io)
-                io_bio->end_io(io_bio, err);
+                io_bio->end_io(io_bio, blk_status_to_errno(err));
         bio_put(bio);
 }
 
@@ -8299,20 +8298,20 @@ static void btrfs_endio_direct_write(struct bio *bio)
         struct bio *dio_bio = dip->dio_bio;
 
         __endio_write_update_ordered(dip->inode, dip->logical_offset,
-                                     dip->bytes, !bio->bi_error);
+                                     dip->bytes, !bio->bi_status);
 
         kfree(dip);
 
-        dio_bio->bi_error = bio->bi_error;
+        dio_bio->bi_status = bio->bi_status;
         dio_end_io(dio_bio);
         bio_put(bio);
 }
 
-static int __btrfs_submit_bio_start_direct_io(struct inode *inode,
+static blk_status_t __btrfs_submit_bio_start_direct_io(struct inode *inode,
                                     struct bio *bio, int mirror_num,
                                     unsigned long bio_flags, u64 offset)
 {
-        int ret;
+        blk_status_t ret;
         ret = btrfs_csum_one_bio(inode, bio, offset, 1);
         BUG_ON(ret); /* -ENOMEM */
         return 0;
@@ -8321,7 +8320,7 @@ static int __btrfs_submit_bio_start_direct_io(struct inode *inode,
 static void btrfs_end_dio_bio(struct bio *bio)
 {
         struct btrfs_dio_private *dip = bio->bi_private;
-        int err = bio->bi_error;
+        blk_status_t err = bio->bi_status;
 
         if (err)
                 btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
@@ -8351,7 +8350,7 @@ static void btrfs_end_dio_bio(struct bio *bio)
         if (dip->errors) {
                 bio_io_error(dip->orig_bio);
         } else {
-                dip->dio_bio->bi_error = 0;
+                dip->dio_bio->bi_status = 0;
                 bio_endio(dip->orig_bio);
         }
 out:
@@ -8368,14 +8367,14 @@ static struct bio *btrfs_dio_bio_alloc(struct block_device *bdev,
         return bio;
 }
 
-static inline int btrfs_lookup_and_bind_dio_csum(struct inode *inode,
+static inline blk_status_t btrfs_lookup_and_bind_dio_csum(struct inode *inode,
                                                  struct btrfs_dio_private *dip,
                                                  struct bio *bio,
                                                  u64 file_offset)
 {
         struct btrfs_io_bio *io_bio = btrfs_io_bio(bio);
         struct btrfs_io_bio *orig_io_bio = btrfs_io_bio(dip->orig_bio);
-        int ret;
+        blk_status_t ret;
 
         /*
          * We load all the csum data we need when we submit
@@ -8406,7 +8405,7 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
         struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
         struct btrfs_dio_private *dip = bio->bi_private;
         bool write = bio_op(bio) == REQ_OP_WRITE;
-        int ret;
+        blk_status_t ret;
 
         if (async_submit)
                 async_submit = !atomic_read(&BTRFS_I(inode)->sync_writers);
@@ -8649,7 +8648,7 @@ free_ordered:
          * callbacks - they require an allocated dip and a clone of dio_bio.
          */
         if (io_bio && dip) {
-                io_bio->bi_error = -EIO;
+                io_bio->bi_status = BLK_STS_IOERR;
                 bio_endio(io_bio);
                 /*
                  * The end io callbacks free our dip, do the final put on io_bio
@@ -8668,7 +8667,7 @@ free_ordered:
                         unlock_extent(&BTRFS_I(inode)->io_tree, file_offset,
                               file_offset + dio_bio->bi_iter.bi_size - 1);
 
-                dio_bio->bi_error = -EIO;
+                dio_bio->bi_status = BLK_STS_IOERR;
                 /*
                  * 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 d8ea0eb76325..f3d30d9ea8f9 100644
--- a/fs/btrfs/raid56.c
+++ b/fs/btrfs/raid56.c
@@ -871,7 +871,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)
+static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, blk_status_t err)
 {
         struct bio *cur = bio_list_get(&rbio->bio_list);
         struct bio *next;
@@ -884,7 +884,7 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err)
         while (cur) {
                 next = cur->bi_next;
                 cur->bi_next = NULL;
-                cur->bi_error = err;
+                cur->bi_status = err;
                 bio_endio(cur);
                 cur = next;
         }
@@ -897,7 +897,7 @@ static void rbio_orig_end_io(struct btrfs_raid_bio *rbio, int err)
 static void raid_write_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
-        int err = bio->bi_error;
+        blk_status_t err = bio->bi_status;
         int max_errors;
 
         if (err)
@@ -914,7 +914,7 @@ static void raid_write_end_io(struct bio *bio)
         max_errors = (rbio->operation == BTRFS_RBIO_PARITY_SCRUB) ?
                      0 : rbio->bbio->max_errors;
         if (atomic_read(&rbio->error) > max_errors)
-                err = -EIO;
+                err = BLK_STS_IOERR;
 
         rbio_orig_end_io(rbio, err);
 }
@@ -1092,7 +1092,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 &&
-                    !last->bi_error &&
+                    !last->bi_status &&
                     last->bi_bdev == stripe->dev->bdev) {
                         ret = bio_add_page(last, page, PAGE_SIZE, 0);
                         if (ret == PAGE_SIZE)
@@ -1448,7 +1448,7 @@ static void raid_rmw_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
@@ -1991,7 +1991,7 @@ static void raid_recover_end_io(struct bio *bio)
          * we only read stripe pages off the disk, set them
          * up to date if there were no errors
          */
-        if (bio->bi_error)
+        if (bio->bi_status)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
@@ -2530,7 +2530,7 @@ static void raid56_parity_scrub_end_io(struct bio *bio)
 {
         struct btrfs_raid_bio *rbio = bio->bi_private;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 fail_bio_stripe(rbio, bio);
         else
                 set_bio_pages_uptodate(bio);
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index c7b45eb2403d..ba5595d19de1 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -95,7 +95,7 @@ struct scrub_bio {
         struct scrub_ctx        *sctx;
         struct btrfs_device     *dev;
         struct bio              *bio;
-        int                     err;
+        blk_status_t            status;
         u64                     logical;
         u64                     physical;
 #if SCRUB_PAGES_PER_WR_BIO >= SCRUB_PAGES_PER_RD_BIO
@@ -1668,14 +1668,14 @@ leave_nomem:
 
 struct scrub_bio_ret {
         struct completion event;
-        int error;
+        blk_status_t status;
 };
 
 static void scrub_bio_wait_endio(struct bio *bio)
 {
         struct scrub_bio_ret *ret = bio->bi_private;
 
-        ret->error = bio->bi_error;
+        ret->status = bio->bi_status;
         complete(&ret->event);
 }
 
@@ -1693,7 +1693,7 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info,
         int ret;
 
         init_completion(&done.event);
-        done.error = 0;
+        done.status = 0;
         bio->bi_iter.bi_sector = page->logical >> 9;
         bio->bi_private = &done;
         bio->bi_end_io = scrub_bio_wait_endio;
@@ -1705,7 +1705,7 @@ static int scrub_submit_raid56_bio_wait(struct btrfs_fs_info *fs_info,
                 return ret;
 
         wait_for_completion(&done.event);
-        if (done.error)
+        if (done.status)
                 return -EIO;
 
         return 0;
@@ -1937,7 +1937,7 @@ again:
                 bio->bi_bdev = sbio->dev->bdev;
                 bio->bi_iter.bi_sector = sbio->physical >> 9;
                 bio_set_op_attrs(bio, REQ_OP_WRITE, 0);
-                sbio->err = 0;
+                sbio->status = 0;
         } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                    spage->physical_for_dev_replace ||
                    sbio->logical + sbio->page_count * PAGE_SIZE !=
@@ -1992,7 +1992,7 @@ 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->fs_info;
 
-        sbio->err = bio->bi_error;
+        sbio->status = bio->bi_status;
         sbio->bio = bio;
 
         btrfs_init_work(&sbio->work, btrfs_scrubwrc_helper,
@@ -2007,7 +2007,7 @@ static void scrub_wr_bio_end_io_worker(struct btrfs_work *work)
         int i;
 
         WARN_ON(sbio->page_count > SCRUB_PAGES_PER_WR_BIO);
-        if (sbio->err) {
+        if (sbio->status) {
                 struct btrfs_dev_replace *dev_replace =
                         &sbio->sctx->fs_info->dev_replace;
 
@@ -2341,7 +2341,7 @@ again:
                 bio->bi_bdev = sbio->dev->bdev;
                 bio->bi_iter.bi_sector = sbio->physical >> 9;
                 bio_set_op_attrs(bio, REQ_OP_READ, 0);
-                sbio->err = 0;
+                sbio->status = 0;
         } else if (sbio->physical + sbio->page_count * PAGE_SIZE !=
                    spage->physical ||
                    sbio->logical + sbio->page_count * PAGE_SIZE !=
@@ -2377,7 +2377,7 @@ static void scrub_missing_raid56_end_io(struct bio *bio)
         struct scrub_block *sblock = bio->bi_private;
         struct btrfs_fs_info *fs_info = sblock->sctx->fs_info;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 sblock->no_io_error_seen = 0;
 
         bio_put(bio);
@@ -2588,7 +2588,7 @@ static void scrub_bio_end_io(struct bio *bio)
         struct scrub_bio *sbio = bio->bi_private;
         struct btrfs_fs_info *fs_info = sbio->dev->fs_info;
 
-        sbio->err = bio->bi_error;
+        sbio->status = bio->bi_status;
         sbio->bio = bio;
 
         btrfs_queue_work(fs_info->scrub_workers, &sbio->work);
@@ -2601,7 +2601,7 @@ static void scrub_bio_end_io_worker(struct btrfs_work *work)
         int i;
 
         BUG_ON(sbio->page_count > SCRUB_PAGES_PER_RD_BIO);
-        if (sbio->err) {
+        if (sbio->status) {
                 for (i = 0; i < sbio->page_count; i++) {
                         struct scrub_page *spage = sbio->pagev[i];
 
@@ -3004,7 +3004,7 @@ static void scrub_parity_bio_endio(struct bio *bio)
         struct scrub_parity *sparity = (struct scrub_parity *)bio->bi_private;
         struct btrfs_fs_info *fs_info = sparity->sctx->fs_info;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 bitmap_or(sparity->ebitmap, sparity->ebitmap, sparity->dbitmap,
                           sparity->nsectors);
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 017b67daa3bb..84a495967e0a 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -6042,9 +6042,10 @@ static void btrfs_end_bio(struct bio *bio)
         struct btrfs_bio *bbio = bio->bi_private;
         int is_orig_bio = 0;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 atomic_inc(&bbio->error);
-                if (bio->bi_error == -EIO || bio->bi_error == -EREMOTEIO) {
+                if (bio->bi_status == BLK_STS_IOERR ||
+                    bio->bi_status == BLK_STS_TARGET) {
                         unsigned int stripe_index =
                                 btrfs_io_bio(bio)->stripe_index;
                         struct btrfs_device *dev;
@@ -6082,13 +6083,13 @@ static void btrfs_end_bio(struct bio *bio)
                  * beyond the tolerance of the btrfs bio
                  */
                 if (atomic_read(&bbio->error) > bbio->max_errors) {
-                        bio->bi_error = -EIO;
+                        bio->bi_status = BLK_STS_IOERR;
                 } else {
                         /*
                          * this bio is actually up to date, we didn't
                          * go over the max number of errors
                          */
-                        bio->bi_error = 0;
+                        bio->bi_status = 0;
                 }
 
                 btrfs_end_bbio(bbio, bio);
@@ -6199,7 +6200,7 @@ 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;
-                bio->bi_error = -EIO;
+                bio->bi_status = BLK_STS_IOERR;
                 btrfs_end_bbio(bbio, bio);
         }
 }
diff --git a/fs/buffer.c b/fs/buffer.c
index 161be58c5cb0..306b720f7383 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -3038,7 +3038,7 @@ static void end_bio_bh_io_sync(struct bio *bio)
         if (unlikely(bio_flagged(bio, BIO_QUIET)))
                 set_bit(BH_Quiet, &bh->b_state);
 
-        bh->b_end_io(bh, !bio->bi_error);
+        bh->b_end_io(bh, !bio->bi_status);
         bio_put(bio);
 }
 
diff --git a/fs/crypto/bio.c b/fs/crypto/bio.c
index a409a84f1bca..6181e9526860 100644
--- a/fs/crypto/bio.c
+++ b/fs/crypto/bio.c
@@ -129,7 +129,7 @@ int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
                         goto errout;
                 }
                 err = submit_bio_wait(bio);
-                if ((err == 0) && bio->bi_error)
+                if (err == 0 && bio->bi_status)
                         err = -EIO;
                 bio_put(bio);
                 if (err)
diff --git a/fs/direct-io.c b/fs/direct-io.c
index bb711e4b86c2..e8baaabebf13 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -294,7 +294,7 @@ static void dio_aio_complete_work(struct work_struct *work)
         dio_complete(dio, 0, true);
 }
 
-static int dio_bio_complete(struct dio *dio, struct bio *bio);
+static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio);
 
 /*
  * Asynchronous IO callback. 
@@ -473,11 +473,11 @@ static struct bio *dio_await_one(struct dio *dio)
 /*
  * Process one completed BIO.  No locks are held.
  */
-static int dio_bio_complete(struct dio *dio, struct bio *bio)
+static blk_status_t dio_bio_complete(struct dio *dio, struct bio *bio)
 {
         struct bio_vec *bvec;
         unsigned i;
-        int err = bio->bi_error;
+        blk_status_t err = bio->bi_status;
 
         if (err)
                 dio->io_error = -EIO;
@@ -536,7 +536,7 @@ static inline int dio_bio_reap(struct dio *dio, struct dio_submit *sdio)
                         bio = dio->bio_list;
                         dio->bio_list = bio->bi_private;
                         spin_unlock_irqrestore(&dio->bio_lock, flags);
-                        ret2 = dio_bio_complete(dio, bio);
+                        ret2 = blk_status_to_errno(dio_bio_complete(dio, bio));
                         if (ret == 0)
                                 ret = ret2;
                 }
diff --git a/fs/ext4/page-io.c b/fs/ext4/page-io.c
index 1a82138ba739..930ca0fc9a0f 100644
--- a/fs/ext4/page-io.c
+++ b/fs/ext4/page-io.c
@@ -85,7 +85,7 @@ static void ext4_finish_bio(struct bio *bio)
                 }
 #endif
 
-                if (bio->bi_error) {
+                if (bio->bi_status) {
                         SetPageError(page);
                         mapping_set_error(page->mapping, -EIO);
                 }
@@ -104,7 +104,7 @@ static void ext4_finish_bio(struct bio *bio)
                                 continue;
                         }
                         clear_buffer_async_write(bh);
-                        if (bio->bi_error)
+                        if (bio->bi_status)
                                 buffer_io_error(bh);
                 } while ((bh = bh->b_this_page) != head);
                 bit_spin_unlock(BH_Uptodate_Lock, &head->b_state);
@@ -303,24 +303,25 @@ static void ext4_end_bio(struct bio *bio)
                       bdevname(bio->bi_bdev, b),
                       (long long) bio->bi_iter.bi_sector,
                       (unsigned) bio_sectors(bio),
-                      bio->bi_error)) {
+                      bio->bi_status)) {
                 ext4_finish_bio(bio);
                 bio_put(bio);
                 return;
         }
         bio->bi_end_io = NULL;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 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)",
-                             bio->bi_error, inode->i_ino,
+                             bio->bi_status, 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, bio->bi_error);
+                mapping_set_error(inode->i_mapping,
+                                blk_status_to_errno(bio->bi_status));
         }
 
         if (io_end->flag & EXT4_IO_END_UNWRITTEN) {
diff --git a/fs/ext4/readpage.c b/fs/ext4/readpage.c
index a81b829d56de..40a5497b0f60 100644
--- a/fs/ext4/readpage.c
+++ b/fs/ext4/readpage.c
@@ -73,7 +73,7 @@ static void mpage_end_io(struct bio *bio)
         int i;
 
         if (ext4_bio_encrypted(bio)) {
-                if (bio->bi_error) {
+                if (bio->bi_status) {
                         fscrypt_release_ctx(bio->bi_private);
                 } else {
                         fscrypt_decrypt_bio_pages(bio->bi_private, bio);
@@ -83,7 +83,7 @@ static void mpage_end_io(struct bio *bio)
         bio_for_each_segment_all(bv, bio, i) {
                 struct page *page = bv->bv_page;
 
-                if (!bio->bi_error) {
+                if (!bio->bi_status) {
                         SetPageUptodate(page);
                 } else {
                         ClearPageUptodate(page);
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 7c0f6bdf817d..36fe82012a33 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -58,12 +58,12 @@ static void f2fs_read_end_io(struct bio *bio)
 #ifdef CONFIG_F2FS_FAULT_INJECTION
         if (time_to_inject(F2FS_P_SB(bio->bi_io_vec->bv_page), FAULT_IO)) {
                 f2fs_show_injection_info(FAULT_IO);
-                bio->bi_error = -EIO;
+                bio->bi_status = BLK_STS_IOERR;
         }
 #endif
 
         if (f2fs_bio_encrypted(bio)) {
-                if (bio->bi_error) {
+                if (bio->bi_status) {
                         fscrypt_release_ctx(bio->bi_private);
                 } else {
                         fscrypt_decrypt_bio_pages(bio->bi_private, bio);
@@ -74,7 +74,7 @@ static void f2fs_read_end_io(struct bio *bio)
         bio_for_each_segment_all(bvec, bio, i) {
                 struct page *page = bvec->bv_page;
 
-                if (!bio->bi_error) {
+                if (!bio->bi_status) {
                         if (!PageUptodate(page))
                                 SetPageUptodate(page);
                 } else {
@@ -102,14 +102,14 @@ static void f2fs_write_end_io(struct bio *bio)
                         unlock_page(page);
                         mempool_free(page, sbi->write_io_dummy);
 
-                        if (unlikely(bio->bi_error))
+                        if (unlikely(bio->bi_status))
                                 f2fs_stop_checkpoint(sbi, true);
                         continue;
                 }
 
                 fscrypt_pullback_bio_page(&page, true);
 
-                if (unlikely(bio->bi_error)) {
+                if (unlikely(bio->bi_status)) {
                         mapping_set_error(page->mapping, -EIO);
                         f2fs_stop_checkpoint(sbi, true);
                 }
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 96845854e7ee..ea9f455d94ba 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -749,7 +749,7 @@ static void f2fs_submit_discard_endio(struct bio *bio)
 {
         struct discard_cmd *dc = (struct discard_cmd *)bio->bi_private;
 
-        dc->error = bio->bi_error;
+        dc->error = blk_status_to_errno(bio->bi_status);
         dc->state = D_DONE;
         complete(&dc->wait);
         bio_put(bio);
diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index 13ebf15a4db0..885d36e7a29f 100644
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -170,7 +170,7 @@ static u64 gfs2_log_bmap(struct gfs2_sbd *sdp)
  */
 
 static void gfs2_end_log_write_bh(struct gfs2_sbd *sdp, struct bio_vec *bvec,
-                                  int error)
+                                  blk_status_t error)
 {
         struct buffer_head *bh, *next;
         struct page *page = bvec->bv_page;
@@ -209,13 +209,13 @@ static void gfs2_end_log_write(struct bio *bio)
         struct page *page;
         int i;
 
-        if (bio->bi_error)
-                fs_err(sdp, "Error %d writing to log\n", bio->bi_error);
+        if (bio->bi_status)
+                fs_err(sdp, "Error %d writing to log\n", bio->bi_status);
 
         bio_for_each_segment_all(bvec, bio, i) {
                 page = bvec->bv_page;
                 if (page_has_buffers(page))
-                        gfs2_end_log_write_bh(sdp, bvec, bio->bi_error);
+                        gfs2_end_log_write_bh(sdp, bvec, bio->bi_status);
                 else
                         mempool_free(page, gfs2_page_pool);
         }
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 663ffc135ef3..fabe1614f879 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -201,7 +201,7 @@ static void gfs2_meta_read_endio(struct bio *bio)
                 do {
                         struct buffer_head *next = bh->b_this_page;
                         len -= bh->b_size;
-                        bh->b_end_io(bh, !bio->bi_error);
+                        bh->b_end_io(bh, !bio->bi_status);
                         bh = next;
                 } while (bh && len);
         }
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index ed67548b286c..83953cdbbc6c 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -176,10 +176,10 @@ static void end_bio_io_page(struct bio *bio)
 {
         struct page *page = bio->bi_private;
 
-        if (!bio->bi_error)
+        if (!bio->bi_status)
                 SetPageUptodate(page);
         else
-                pr_warn("error %d reading superblock\n", bio->bi_error);
+                pr_warn("error %d reading superblock\n", bio->bi_status);
         unlock_page(page);
 }
 
diff --git a/fs/iomap.c b/fs/iomap.c
index 4b10892967a5..18f2f2b8ba2c 100644
--- a/fs/iomap.c
+++ b/fs/iomap.c
@@ -672,8 +672,8 @@ static void iomap_dio_bio_end_io(struct bio *bio)
         struct iomap_dio *dio = bio->bi_private;
         bool should_dirty = (dio->flags & IOMAP_DIO_DIRTY);
 
-        if (bio->bi_error)
-                iomap_dio_set_error(dio, bio->bi_error);
+        if (bio->bi_status)
+                iomap_dio_set_error(dio, blk_status_to_errno(bio->bi_status));
 
         if (atomic_dec_and_test(&dio->ref)) {
                 if (is_sync_kiocb(dio->iocb)) {
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index bb1da1feafeb..a21f0e9eecd4 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -2205,7 +2205,7 @@ static void lbmIODone(struct bio *bio)
 
         bp->l_flag |= lbmDONE;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 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 489aaa1403e5..ce93db3aef3c 100644
--- a/fs/jfs/jfs_metapage.c
+++ b/fs/jfs/jfs_metapage.c
@@ -280,7 +280,7 @@ static void metapage_read_end_io(struct bio *bio)
 {
         struct page *page = bio->bi_private;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 printk(KERN_ERR "metapage_read_end_io: I/O error\n");
                 SetPageError(page);
         }
@@ -337,7 +337,7 @@ static void metapage_write_end_io(struct bio *bio)
 
         BUG_ON(!PagePrivate(page));
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 printk(KERN_ERR "metapage_write_end_io: I/O error\n");
                 SetPageError(page);
         }
diff --git a/fs/mpage.c b/fs/mpage.c
index baff8f820c29..9524fdde00c2 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -50,7 +50,8 @@ static void mpage_end_io(struct bio *bio)
 
         bio_for_each_segment_all(bv, bio, i) {
                 struct page *page = bv->bv_page;
-                page_endio(page, op_is_write(bio_op(bio)), bio->bi_error);
+                page_endio(page, op_is_write(bio_op(bio)),
+                                blk_status_to_errno(bio->bi_status));
         }
 
         bio_put(bio);
diff --git a/fs/nfs/blocklayout/blocklayout.c b/fs/nfs/blocklayout/blocklayout.c
index 0ca370d23ddb..d8863a804b15 100644
--- a/fs/nfs/blocklayout/blocklayout.c
+++ b/fs/nfs/blocklayout/blocklayout.c
@@ -188,7 +188,7 @@ static void bl_end_io_read(struct bio *bio)
 {
         struct parallel_io *par = bio->bi_private;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 struct nfs_pgio_header *header = par->data;
 
                 if (!header->pnfs_error)
@@ -319,7 +319,7 @@ static void bl_end_io_write(struct bio *bio)
         struct parallel_io *par = bio->bi_private;
         struct nfs_pgio_header *header = par->data;
 
-        if (bio->bi_error) {
+        if (bio->bi_status) {
                 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 6f87b2ac1aeb..e73c86d9855c 100644
--- a/fs/nilfs2/segbuf.c
+++ b/fs/nilfs2/segbuf.c
@@ -338,7 +338,7 @@ static void nilfs_end_bio_write(struct bio *bio)
 {
         struct nilfs_segment_buffer *segbuf = bio->bi_private;
 
-        if (bio->bi_error)
+        if (bio->bi_status)
                 atomic_inc(&segbuf->sb_err);
 
         bio_put(bio);
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 0da0332725aa..ffe003982d95 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -516,9 +516,9 @@ static void o2hb_bio_end_io(struct bio *bio)
 {
         struct o2hb_bio_wait_ctxt *wc = bio->bi_private;
 
-        if (bio->bi_error) {
-                mlog(ML_ERROR, "IO Error %d\n", bio->bi_error);
-                wc->wc_error = bio->bi_error;
+        if (bio->bi_status) {
+                mlog(ML_ERROR, "IO Error %d\n", bio->bi_status);
+                wc->wc_error = blk_status_to_errno(bio->bi_status);
         }
 
         o2hb_bio_wait_dec(wc, 1);
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 09af0f7cd55e..76b6f988e2fa 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -276,7 +276,7 @@ xfs_end_io(
         struct xfs_inode        *ip = XFS_I(ioend->io_inode);
         xfs_off_t               offset = ioend->io_offset;
         size_t                  size = ioend->io_size;
-        int                     error = ioend->io_bio->bi_error;
+        int                     error;
 
         /*
          * Just clean up the in-memory strutures if the fs has been shut down.
@@ -289,6 +289,7 @@ xfs_end_io(
         /*
          * Clean up any COW blocks on an I/O error.
          */
+        error = blk_status_to_errno(ioend->io_bio->bi_status);
         if (unlikely(error)) {
                 switch (ioend->io_type) {
                 case XFS_IO_COW:
@@ -332,7 +333,7 @@ xfs_end_bio(
         else if (ioend->io_append_trans)
                 queue_work(mp->m_data_workqueue, &ioend->io_work);
         else
-                xfs_destroy_ioend(ioend, bio->bi_error);
+                xfs_destroy_ioend(ioend, blk_status_to_errno(bio->bi_status));
 }
 
 STATIC int
@@ -500,7 +501,7 @@ xfs_submit_ioend(
          * time.
          */
         if (status) {
-                ioend->io_bio->bi_error = status;
+                ioend->io_bio->bi_status = errno_to_blk_status(status);
                 bio_endio(ioend->io_bio);
                 return status;
         }
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 62fa39276a24..15c7a484a5d2 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -1213,8 +1213,11 @@ xfs_buf_bio_end_io(
          * don't overwrite existing errors - otherwise we can lose errors on
          * buffers that require multiple bios to complete.
          */
-        if (bio->bi_error)
-                cmpxchg(&bp->b_io_error, 0, bio->bi_error);
+        if (bio->bi_status) {
+                int error = blk_status_to_errno(bio->bi_status);
+
+                cmpxchg(&bp->b_io_error, 0, error);
+        }
 
         if (!bp->b_error && xfs_buf_is_vmapped(bp) && (bp->b_flags & XBF_READ))
                 invalidate_kernel_vmap_range(bp->b_addr, xfs_buf_vmap_len(bp));