Merge tag 'for-4.18/block-20180603' of git://git.kernel.dk/linux-block

Pull block updates from Jens Axboe:

 - clean up how we pass around gfp_t and
   blk_mq_req_flags_t (Christoph)

 - prepare us to defer scheduler attach (Christoph)

 - clean up drivers handling of bounce buffers (Christoph)

 - fix timeout handling corner cases (Christoph/Bart/Keith)

 - bcache fixes (Coly)

 - prep work for bcachefs and some block layer optimizations (Kent).

 - convert users of bio_sets to using embedded structs (Kent).

 - fixes for the BFQ io scheduler (Paolo/Davide/Filippo)

 - lightnvm fixes and improvements (Matias, with contributions from Hans
   and Javier)

 - adding discard throttling to blk-wbt (me)

 - sbitmap blk-mq-tag handling (me/Omar/Ming).

 - remove the sparc jsflash block driver, acked by DaveM.

 - Kyber scheduler improvement from Jianchao, making it more friendly
   wrt merging.

 - conversion of symbolic proc permissions to octal, from Joe Perches.
   Previously the block parts were a mix of both.

 - nbd fixes (Josef and Kevin Vigor)

 - unify how we handle the various kinds of timestamps that the block
   core and utility code uses (Omar)

 - three NVMe pull requests from Keith and Christoph, bringing AEN to
   feature completeness, file backed namespaces, cq/sq lock split, and
   various fixes

 - various little fixes and improvements all over the map

* tag 'for-4.18/block-20180603' of git://git.kernel.dk/linux-block: (196 commits)
  blk-mq: update nr_requests when switching to 'none' scheduler
  block: don't use blocking queue entered for recursive bio submits
  dm-crypt: fix warning in shutdown path
  lightnvm: pblk: take bitmap alloc. out of critical section
  lightnvm: pblk: kick writer on new flush points
  lightnvm: pblk: only try to recover lines with written smeta
  lightnvm: pblk: remove unnecessary bio_get/put
  lightnvm: pblk: add possibility to set write buffer size manually
  lightnvm: fix partial read error path
  lightnvm: proper error handling for pblk_bio_add_pages
  lightnvm: pblk: fix smeta write error path
  lightnvm: pblk: garbage collect lines with failed writes
  lightnvm: pblk: rework write error recovery path
  lightnvm: pblk: remove dead function
  lightnvm: pass flag on graceful teardown to targets
  lightnvm: pblk: check for chunk size before allocating it
  lightnvm: pblk: remove unnecessary argument
  lightnvm: pblk: remove unnecessary indirection
  lightnvm: pblk: return NVM_ error on failed submission
  lightnvm: pblk: warn in case of corrupted write buffer
  ...

9 files changed, 39 insertions, 43 deletions

diff --git a/fs/block_dev.c b/fs/block_dev.c
index 7ec920e27065..bef6934b6189 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -272,7 +272,7 @@ struct blkdev_dio {
         struct bio              bio;
 };
 
-static struct bio_set *blkdev_dio_pool __read_mostly;
+static struct bio_set blkdev_dio_pool;
 
 static void blkdev_bio_end_io(struct bio *bio)
 {
@@ -334,7 +334,7 @@ __blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter, int nr_pages)
             (bdev_logical_block_size(bdev) - 1))
                 return -EINVAL;
 
-        bio = bio_alloc_bioset(GFP_KERNEL, nr_pages, blkdev_dio_pool);
+        bio = bio_alloc_bioset(GFP_KERNEL, nr_pages, &blkdev_dio_pool);
         bio_get(bio); /* extra ref for the completion handler */
 
         dio = container_of(bio, struct blkdev_dio, bio);
@@ -432,10 +432,7 @@ blkdev_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
 
 static __init int blkdev_init(void)
 {
-        blkdev_dio_pool = bioset_create(4, offsetof(struct blkdev_dio, bio), BIOSET_NEED_BVECS);
-        if (!blkdev_dio_pool)
-                return -ENOMEM;
-        return 0;
+        return bioset_init(&blkdev_dio_pool, 4, offsetof(struct blkdev_dio, bio), BIOSET_NEED_BVECS);
 }
 module_init(blkdev_init);
 
@@ -1322,27 +1319,30 @@ static void flush_disk(struct block_device *bdev, bool kill_dirty)
  * check_disk_size_change - checks for disk size change and adjusts bdev size.
  * @disk: struct gendisk to check
  * @bdev: struct bdev to adjust.
+ * @verbose: if %true log a message about a size change if there is any
  *
  * This routine checks to see if the bdev size does not match the disk size
  * and adjusts it if it differs. When shrinking the bdev size, its all caches
  * are freed.
  */
-void check_disk_size_change(struct gendisk *disk, struct block_device *bdev)
+void check_disk_size_change(struct gendisk *disk, struct block_device *bdev,
+                bool verbose)
 {
         loff_t disk_size, bdev_size;
 
         disk_size = (loff_t)get_capacity(disk) << 9;
         bdev_size = i_size_read(bdev->bd_inode);
         if (disk_size != bdev_size) {
-                printk(KERN_INFO
-                       "%s: detected capacity change from %lld to %lld\n",
-                       disk->disk_name, bdev_size, disk_size);
+                if (verbose) {
+                        printk(KERN_INFO
+                               "%s: detected capacity change from %lld to %lld\n",
+                               disk->disk_name, bdev_size, disk_size);
+                }
                 i_size_write(bdev->bd_inode, disk_size);
                 if (bdev_size > disk_size)
                         flush_disk(bdev, false);
         }
 }
-EXPORT_SYMBOL(check_disk_size_change);
 
 /**
  * revalidate_disk - wrapper for lower-level driver's revalidate_disk call-back
@@ -1364,7 +1364,7 @@ int revalidate_disk(struct gendisk *disk)
                 return ret;
 
         mutex_lock(&bdev->bd_mutex);
-        check_disk_size_change(disk, bdev);
+        check_disk_size_change(disk, bdev, ret == 0);
         bdev->bd_invalidated = 0;
         mutex_unlock(&bdev->bd_mutex);
         bdput(bdev);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index e99b329002cf..56d32bb462f9 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -26,7 +26,7 @@
 
 static struct kmem_cache *extent_state_cache;
 static struct kmem_cache *extent_buffer_cache;
-static struct bio_set *btrfs_bioset;
+static struct bio_set btrfs_bioset;
 
 static inline bool extent_state_in_tree(const struct extent_state *state)
 {
@@ -162,20 +162,18 @@ int __init extent_io_init(void)
         if (!extent_buffer_cache)
                 goto free_state_cache;
 
-        btrfs_bioset = bioset_create(BIO_POOL_SIZE,
-                                     offsetof(struct btrfs_io_bio, bio),
-                                     BIOSET_NEED_BVECS);
-        if (!btrfs_bioset)
+        if (bioset_init(&btrfs_bioset, BIO_POOL_SIZE,
+                        offsetof(struct btrfs_io_bio, bio),
+                        BIOSET_NEED_BVECS))
                 goto free_buffer_cache;
 
-        if (bioset_integrity_create(btrfs_bioset, BIO_POOL_SIZE))
+        if (bioset_integrity_create(&btrfs_bioset, BIO_POOL_SIZE))
                 goto free_bioset;
 
         return 0;
 
 free_bioset:
-        bioset_free(btrfs_bioset);
-        btrfs_bioset = NULL;
+        bioset_exit(&btrfs_bioset);
 
 free_buffer_cache:
         kmem_cache_destroy(extent_buffer_cache);
@@ -198,8 +196,7 @@ void __cold extent_io_exit(void)
         rcu_barrier();
         kmem_cache_destroy(extent_state_cache);
         kmem_cache_destroy(extent_buffer_cache);
-        if (btrfs_bioset)
-                bioset_free(btrfs_bioset);
+        bioset_exit(&btrfs_bioset);
 }
 
 void extent_io_tree_init(struct extent_io_tree *tree,
@@ -2679,7 +2676,7 @@ struct bio *btrfs_bio_alloc(struct block_device *bdev, u64 first_byte)
 {
         struct bio *bio;
 
-        bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, btrfs_bioset);
+        bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &btrfs_bioset);
         bio_set_dev(bio, bdev);
         bio->bi_iter.bi_sector = first_byte >> 9;
         btrfs_io_bio_init(btrfs_io_bio(bio));
@@ -2692,7 +2689,7 @@ struct bio *btrfs_bio_clone(struct bio *bio)
         struct bio *new;
 
         /* Bio allocation backed by a bioset does not fail */
-        new = bio_clone_fast(bio, GFP_NOFS, btrfs_bioset);
+        new = bio_clone_fast(bio, GFP_NOFS, &btrfs_bioset);
         btrfs_bio = btrfs_io_bio(new);
         btrfs_io_bio_init(btrfs_bio);
         btrfs_bio->iter = bio->bi_iter;
@@ -2704,7 +2701,7 @@ struct bio *btrfs_io_bio_alloc(unsigned int nr_iovecs)
         struct bio *bio;
 
         /* Bio allocation backed by a bioset does not fail */
-        bio = bio_alloc_bioset(GFP_NOFS, nr_iovecs, btrfs_bioset);
+        bio = bio_alloc_bioset(GFP_NOFS, nr_iovecs, &btrfs_bioset);
         btrfs_io_bio_init(btrfs_io_bio(bio));
         return bio;
 }
@@ -2715,7 +2712,7 @@ struct bio *btrfs_bio_clone_partial(struct bio *orig, int offset, int size)
         struct btrfs_io_bio *btrfs_bio;
 
         /* this will never fail when it's backed by a bioset */
-        bio = bio_clone_fast(orig, GFP_NOFS, btrfs_bioset);
+        bio = bio_clone_fast(orig, GFP_NOFS, &btrfs_bioset);
         ASSERT(bio);
 
         btrfs_bio = btrfs_io_bio(bio);
diff --git a/fs/direct-io.c b/fs/direct-io.c
index 874607bb6e02..093fb54cd316 100644
--- a/fs/direct-io.c
+++ b/fs/direct-io.c
@@ -432,8 +432,8 @@ dio_bio_alloc(struct dio *dio, struct dio_submit *sdio,
         struct bio *bio;
 
         /*
-         * bio_alloc() is guaranteed to return a bio when called with
-         * __GFP_RECLAIM and we request a valid number of vectors.
+         * bio_alloc() is guaranteed to return a bio when allowed to sleep and
+         * we request a valid number of vectors.
          */
         bio = bio_alloc(GFP_KERNEL, nr_vecs);
 
diff --git a/fs/exofs/ore.c b/fs/exofs/ore.c
index 3c6a9c156b7a..ddbf87246898 100644
--- a/fs/exofs/ore.c
+++ b/fs/exofs/ore.c
@@ -790,7 +790,7 @@ int ore_create(struct ore_io_state *ios)
         for (i = 0; i < ios->oc->numdevs; i++) {
                 struct osd_request *or;
 
-                or = osd_start_request(_ios_od(ios, i), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, i));
                 if (unlikely(!or)) {
                         ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
@@ -815,7 +815,7 @@ int ore_remove(struct ore_io_state *ios)
         for (i = 0; i < ios->oc->numdevs; i++) {
                 struct osd_request *or;
 
-                or = osd_start_request(_ios_od(ios, i), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, i));
                 if (unlikely(!or)) {
                         ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
@@ -847,7 +847,7 @@ static int _write_mirror(struct ore_io_state *ios, int cur_comp)
                 struct ore_per_dev_state *per_dev = &ios->per_dev[cur_comp];
                 struct osd_request *or;
 
-                or = osd_start_request(_ios_od(ios, dev), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, dev));
                 if (unlikely(!or)) {
                         ORE_ERR("%s: osd_start_request failed\n", __func__);
                         ret = -ENOMEM;
@@ -966,7 +966,7 @@ int _ore_read_mirror(struct ore_io_state *ios, unsigned cur_comp)
                 return 0; /* Just an empty slot */
 
         first_dev = per_dev->dev + first_dev % ios->layout->mirrors_p1;
-        or = osd_start_request(_ios_od(ios, first_dev), GFP_KERNEL);
+        or = osd_start_request(_ios_od(ios, first_dev));
         if (unlikely(!or)) {
                 ORE_ERR("%s: osd_start_request failed\n", __func__);
                 return -ENOMEM;
@@ -1060,7 +1060,7 @@ static int _truncate_mirrors(struct ore_io_state *ios, unsigned cur_comp,
                 struct ore_per_dev_state *per_dev = &ios->per_dev[cur_comp];
                 struct osd_request *or;
 
-                or = osd_start_request(_ios_od(ios, cur_comp), GFP_KERNEL);
+                or = osd_start_request(_ios_od(ios, cur_comp));
                 if (unlikely(!or)) {
                         ORE_ERR("%s: osd_start_request failed\n", __func__);
                         return -ENOMEM;
diff --git a/fs/exofs/super.c b/fs/exofs/super.c
index 179cd5c2f52a..719a3152da80 100644
--- a/fs/exofs/super.c
+++ b/fs/exofs/super.c
@@ -229,7 +229,7 @@ void exofs_make_credential(u8 cred_a[OSD_CAP_LEN], const struct osd_obj_id *obj)
 static int exofs_read_kern(struct osd_dev *od, u8 *cred, struct osd_obj_id *obj,
                     u64 offset, void *p, unsigned length)
 {
-        struct osd_request *or = osd_start_request(od, GFP_KERNEL);
+        struct osd_request *or = osd_start_request(od);
 /*      struct osd_sense_info osi = {.key = 0};*/
         int ret;
 
diff --git a/fs/nfsd/blocklayout.c b/fs/nfsd/blocklayout.c
index 70b8bf781fce..a43dfedd69ec 100644
--- a/fs/nfsd/blocklayout.c
+++ b/fs/nfsd/blocklayout.c
@@ -227,7 +227,7 @@ static int nfsd4_scsi_identify_device(struct block_device *bdev,
         if (!buf)
                 return -ENOMEM;
 
-        rq = blk_get_request(q, REQ_OP_SCSI_IN, GFP_KERNEL);
+        rq = blk_get_request(q, REQ_OP_SCSI_IN, 0);
         if (IS_ERR(rq)) {
                 error = -ENOMEM;
                 goto out_free_buf;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index 0ab824f574ed..102463543db3 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -594,7 +594,7 @@ xfs_alloc_ioend(
         struct xfs_ioend        *ioend;
         struct bio              *bio;
 
-        bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, xfs_ioend_bioset);
+        bio = bio_alloc_bioset(GFP_NOFS, BIO_MAX_PAGES, &xfs_ioend_bioset);
         xfs_init_bio_from_bh(bio, bh);
 
         ioend = container_of(bio, struct xfs_ioend, io_inline_bio);
diff --git a/fs/xfs/xfs_aops.h b/fs/xfs/xfs_aops.h
index 69346d460dfa..694c85b03813 100644
--- a/fs/xfs/xfs_aops.h
+++ b/fs/xfs/xfs_aops.h
@@ -18,7 +18,7 @@
 #ifndef __XFS_AOPS_H__
 #define __XFS_AOPS_H__
 
-extern struct bio_set *xfs_ioend_bioset;
+extern struct bio_set xfs_ioend_bioset;
 
 /*
  * Types of I/O for bmap clustering and I/O completion tracking.
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index d71424052917..f643d76db516 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -63,7 +63,7 @@
 #include <linux/parser.h>
 
 static const struct super_operations xfs_super_operations;
-struct bio_set *xfs_ioend_bioset;
+struct bio_set xfs_ioend_bioset;
 
 static struct kset *xfs_kset;           /* top-level xfs sysfs dir */
 #ifdef DEBUG
@@ -1845,10 +1845,9 @@ MODULE_ALIAS_FS("xfs");
 STATIC int __init
 xfs_init_zones(void)
 {
-        xfs_ioend_bioset = bioset_create(4 * MAX_BUF_PER_PAGE,
+        if (bioset_init(&xfs_ioend_bioset, 4 * MAX_BUF_PER_PAGE,
                         offsetof(struct xfs_ioend, io_inline_bio),
-                        BIOSET_NEED_BVECS);
-        if (!xfs_ioend_bioset)
+                        BIOSET_NEED_BVECS))
                 goto out;
 
         xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
@@ -1997,7 +1996,7 @@ xfs_init_zones(void)
  out_destroy_log_ticket_zone:
         kmem_zone_destroy(xfs_log_ticket_zone);
  out_free_ioend_bioset:
-        bioset_free(xfs_ioend_bioset);
+        bioset_exit(&xfs_ioend_bioset);
  out:
         return -ENOMEM;
 }
@@ -2029,7 +2028,7 @@ xfs_destroy_zones(void)
         kmem_zone_destroy(xfs_btree_cur_zone);
         kmem_zone_destroy(xfs_bmap_free_item_zone);
         kmem_zone_destroy(xfs_log_ticket_zone);
-        bioset_free(xfs_ioend_bioset);
+        bioset_exit(&xfs_ioend_bioset);
 }
 
 STATIC int __init