Merge branch 'for-4.13/block' of git://git.kernel.dk/linux-block

Pull core block/IO updates from Jens Axboe:
 "This is the main pull request for the block layer for 4.13. Not a huge
  round in terms of features, but there's a lot of churn related to some
  core cleanups.

  Note this depends on the UUID tree pull request, that Christoph
  already sent out.

  This pull request contains:

   - A series from Christoph, unifying the error/stats codes in the
     block layer. We now use blk_status_t everywhere, instead of using
     different schemes for different places.

   - Also from Christoph, some cleanups around request allocation and IO
     scheduler interactions in blk-mq.

   - And yet another series from Christoph, cleaning up how we handle
     and do bounce buffering in the block layer.

   - A blk-mq debugfs series from Bart, further improving on the support
     we have for exporting internal information to aid debugging IO
     hangs or stalls.

   - Also from Bart, a series that cleans up the request initialization
     differences across types of devices.

   - A series from Goldwyn Rodrigues, allowing the block layer to return
     failure if we will block and the user asked for non-blocking.

   - Patch from Hannes for supporting setting loop devices block size to
     that of the underlying device.

   - Two series of patches from Javier, fixing various issues with
     lightnvm, particular around pblk.

   - A series from me, adding support for write hints. This comes with
     NVMe support as well, so applications can help guide data placement
     on flash to improve performance, latencies, and write
     amplification.

   - A series from Ming, improving and hardening blk-mq support for
     stopping/starting and quiescing hardware queues.

   - Two pull requests for NVMe updates. Nothing major on the feature
     side, but lots of cleanups and bug fixes. From the usual crew.

   - A series from Neil Brown, greatly improving the bio rescue set
     support. Most notably, this kills the bio rescue work queues, if we
     don't really need them.

   - Lots of other little bug fixes that are all over the place"

* 'for-4.13/block' of git://git.kernel.dk/linux-block: (217 commits)
  lightnvm: pblk: set line bitmap check under debug
  lightnvm: pblk: verify that cache read is still valid
  lightnvm: pblk: add initialization check
  lightnvm: pblk: remove target using async. I/Os
  lightnvm: pblk: use vmalloc for GC data buffer
  lightnvm: pblk: use right metadata buffer for recovery
  lightnvm: pblk: schedule if data is not ready
  lightnvm: pblk: remove unused return variable
  lightnvm: pblk: fix double-free on pblk init
  lightnvm: pblk: fix bad le64 assignations
  nvme: Makefile: remove dead build rule
  blk-mq: map all HWQ also in hyperthreaded system
  nvmet-rdma: register ib_client to not deadlock in device removal
  nvme_fc: fix error recovery on link down.
  nvmet_fc: fix crashes on bad opcodes
  nvme_fc: Fix crash when nvme controller connection fails.
  nvme_fc: replace ioabort msleep loop with completion
  nvme_fc: fix double calls to nvme_cleanup_cmd()
  nvme-fabrics: verify that a controller returns the correct NQN
  nvme: simplify nvme_dev_attrs_are_visible
  ...

1 files changed, 37 insertions, 38 deletions

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 5f678dcb20e6..6036d15b47b8 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);
@@ -3497,11 +3496,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;
@@ -3513,8 +3512,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);
                 }
@@ -3533,7 +3532,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;
@@ -3558,7 +3557,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;