Merge tag 'for-5.1/block-20190302' of git://git.kernel.dk/linux-block

Pull block layer updates from Jens Axboe:
 "Not a huge amount of changes in this round, the biggest one is that we
  finally have Mings multi-page bvec support merged. Apart from that,
  this pull request contains:

   - Small series that avoids quiescing the queue for sysfs changes that
     match what we currently have (Aleksei)

   - Series of bcache fixes (via Coly)

   - Series of lightnvm fixes (via Mathias)

   - NVMe pull request from Christoph. Nothing major, just SPDX/license
     cleanups, RR mp policy (Hannes), and little fixes (Bart,
     Chaitanya).

   - BFQ series (Paolo)

   - Save blk-mq cpu -> hw queue mapping, removing a pointer indirection
     for the fast path (Jianchao)

   - fops->iopoll() added for async IO polling, this is a feature that
     the upcoming io_uring interface will use (Christoph, me)

   - Partition scan loop fixes (Dongli)

   - mtip32xx conversion from managed resource API (Christoph)

   - cdrom registration race fix (Guenter)

   - MD pull from Song, two minor fixes.

   - Various documentation fixes (Marcos)

   - Multi-page bvec feature. This brings a lot of nice improvements
     with it, like more efficient splitting, larger IOs can be supported
     without growing the bvec table size, and so on. (Ming)

   - Various little fixes to core and drivers"

* tag 'for-5.1/block-20190302' of git://git.kernel.dk/linux-block: (117 commits)
  block: fix updating bio's front segment size
  block: Replace function name in string with __func__
  nbd: propagate genlmsg_reply return code
  floppy: remove set but not used variable 'q'
  null_blk: fix checking for REQ_FUA
  block: fix NULL pointer dereference in register_disk
  fs: fix guard_bio_eod to check for real EOD errors
  blk-mq: use HCTX_TYPE_DEFAULT but not 0 to index blk_mq_tag_set->map
  block: optimize bvec iteration in bvec_iter_advance
  block: introduce mp_bvec_for_each_page() for iterating over page
  block: optimize blk_bio_segment_split for single-page bvec
  block: optimize __blk_segment_map_sg() for single-page bvec
  block: introduce bvec_nth_page()
  iomap: wire up the iopoll method
  block: add bio_set_polled() helper
  block: wire up block device iopoll method
  fs: add an iopoll method to struct file_operations
  loop: set GENHD_FL_NO_PART_SCAN after blkdev_reread_part()
  loop: do not print warn message if partition scan is successful
  block: bounce: make sure that bvec table is updated
  ...

8 files changed, 52 insertions, 49 deletions

diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 55481b40df9a..95f608d1a098 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -2230,7 +2230,6 @@ static void floppy_end_request(struct request *req, blk_status_t error)
 static void request_done(int uptodate)
 {
         struct request *req = current_req;
-        struct request_queue *q;
         int block;
         char msg[sizeof("request done ") + sizeof(int) * 3];
 
@@ -2243,8 +2242,6 @@ static void request_done(int uptodate)
                 return;
         }
 
-        q = req->q;
-
         if (uptodate) {
                 /* maintain values for invalidation on geometry
                  * change */
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index cf5538942834..1e6edd568214 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -511,21 +511,22 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
                      loff_t pos, bool rw)
 {
         struct iov_iter iter;
+        struct req_iterator rq_iter;
         struct bio_vec *bvec;
         struct request *rq = blk_mq_rq_from_pdu(cmd);
         struct bio *bio = rq->bio;
         struct file *file = lo->lo_backing_file;
+        struct bio_vec tmp;
         unsigned int offset;
-        int segments = 0;
+        int nr_bvec = 0;
         int ret;
 
+        rq_for_each_bvec(tmp, rq, rq_iter)
+                nr_bvec++;
+
         if (rq->bio != rq->biotail) {
-                struct req_iterator iter;
-                struct bio_vec tmp;
 
-                __rq_for_each_bio(bio, rq)
-                        segments += bio_segments(bio);
-                bvec = kmalloc_array(segments, sizeof(struct bio_vec),
+                bvec = kmalloc_array(nr_bvec, sizeof(struct bio_vec),
                                      GFP_NOIO);
                 if (!bvec)
                         return -EIO;
@@ -534,10 +535,10 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
                 /*
                  * The bios of the request may be started from the middle of
                  * the 'bvec' because of bio splitting, so we can't directly
-                 * copy bio->bi_iov_vec to new bvec. The rq_for_each_segment
+                 * copy bio->bi_iov_vec to new bvec. The rq_for_each_bvec
                  * API will take care of all details for us.
                  */
-                rq_for_each_segment(tmp, rq, iter) {
+                rq_for_each_bvec(tmp, rq, rq_iter) {
                         *bvec = tmp;
                         bvec++;
                 }
@@ -551,11 +552,10 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
                  */
                 offset = bio->bi_iter.bi_bvec_done;
                 bvec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
-                segments = bio_segments(bio);
         }
         atomic_set(&cmd->ref, 2);
 
-        iov_iter_bvec(&iter, rw, bvec, segments, blk_rq_bytes(rq));
+        iov_iter_bvec(&iter, rw, bvec, nr_bvec, blk_rq_bytes(rq));
         iter.iov_offset = offset;
 
         cmd->iocb.ki_pos = pos;
@@ -1089,16 +1089,12 @@ static int __loop_clr_fd(struct loop_device *lo, bool release)
                 kobject_uevent(&disk_to_dev(bdev->bd_disk)->kobj, KOBJ_CHANGE);
         }
         mapping_set_gfp_mask(filp->f_mapping, gfp);
-        lo->lo_state = Lo_unbound;
         /* This is safe: open() is still holding a reference. */
         module_put(THIS_MODULE);
         blk_mq_unfreeze_queue(lo->lo_queue);
 
         partscan = lo->lo_flags & LO_FLAGS_PARTSCAN && bdev;
         lo_number = lo->lo_number;
-        lo->lo_flags = 0;
-        if (!part_shift)
-                lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN;
         loop_unprepare_queue(lo);
 out_unlock:
         mutex_unlock(&loop_ctl_mutex);
@@ -1115,11 +1111,29 @@ out_unlock:
                         err = __blkdev_reread_part(bdev);
                 else
                         err = blkdev_reread_part(bdev);
-                pr_warn("%s: partition scan of loop%d failed (rc=%d)\n",
-                        __func__, lo_number, err);
+                if (err)
+                        pr_warn("%s: partition scan of loop%d failed (rc=%d)\n",
+                                __func__, lo_number, err);
                 /* Device is gone, no point in returning error */
                 err = 0;
         }
+
+        /*
+         * lo->lo_state is set to Lo_unbound here after above partscan has
+         * finished.
+         *
+         * There cannot be anybody else entering __loop_clr_fd() as
+         * lo->lo_backing_file is already cleared and Lo_rundown state
+         * protects us from all the other places trying to change the 'lo'
+         * device.
+         */
+        mutex_lock(&loop_ctl_mutex);
+        lo->lo_flags = 0;
+        if (!part_shift)
+                lo->lo_disk->flags |= GENHD_FL_NO_PART_SCAN;
+        lo->lo_state = Lo_unbound;
+        mutex_unlock(&loop_ctl_mutex);
+
         /*
          * Need not hold loop_ctl_mutex to fput backing file.
          * Calling fput holding loop_ctl_mutex triggers a circular
@@ -1937,7 +1951,7 @@ static int loop_add(struct loop_device **l, int i)
         lo->tag_set.queue_depth = 128;
         lo->tag_set.numa_node = NUMA_NO_NODE;
         lo->tag_set.cmd_size = sizeof(struct loop_cmd);
-        lo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
+        lo->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
         lo->tag_set.driver_data = lo;
 
         err = blk_mq_alloc_tag_set(&lo->tag_set);
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 2f3ee4d6af82..83302ecdc8db 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -1416,7 +1416,7 @@ static blk_status_t mtip_send_trim(struct driver_data *dd, unsigned int lba,
         WARN_ON(sizeof(struct mtip_trim) > ATA_SECT_SIZE);
 
         /* Allocate a DMA buffer for the trim structure */
-        buf = dmam_alloc_coherent(&dd->pdev->dev, ATA_SECT_SIZE, &dma_addr,
+        buf = dma_alloc_coherent(&dd->pdev->dev, ATA_SECT_SIZE, &dma_addr,
                                                                 GFP_KERNEL);
         if (!buf)
                 return BLK_STS_RESOURCE;
@@ -1453,7 +1453,7 @@ static blk_status_t mtip_send_trim(struct driver_data *dd, unsigned int lba,
                                         MTIP_TRIM_TIMEOUT_MS) < 0)
                 ret = BLK_STS_IOERR;
 
-        dmam_free_coherent(&dd->pdev->dev, ATA_SECT_SIZE, buf, dma_addr);
+        dma_free_coherent(&dd->pdev->dev, ATA_SECT_SIZE, buf, dma_addr);
         return ret;
 }
 
@@ -1656,7 +1656,7 @@ static int exec_drive_command(struct mtip_port *port, u8 *command,
                 if (!user_buffer)
                         return -EFAULT;
 
-                buf = dmam_alloc_coherent(&port->dd->pdev->dev,
+                buf = dma_alloc_coherent(&port->dd->pdev->dev,
                                 ATA_SECT_SIZE * xfer_sz,
                                 &dma_addr,
                                 GFP_KERNEL);
@@ -1734,7 +1734,7 @@ static int exec_drive_command(struct mtip_port *port, u8 *command,
         }
 exit_drive_command:
         if (buf)
-                dmam_free_coherent(&port->dd->pdev->dev,
+                dma_free_coherent(&port->dd->pdev->dev,
                                 ATA_SECT_SIZE * xfer_sz, buf, dma_addr);
         return rv;
 }
@@ -2838,11 +2838,11 @@ static void mtip_dma_free(struct driver_data *dd)
         struct mtip_port *port = dd->port;
 
         if (port->block1)
-                dmam_free_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
+                dma_free_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
                                         port->block1, port->block1_dma);
 
         if (port->command_list) {
-                dmam_free_coherent(&dd->pdev->dev, AHCI_CMD_TBL_SZ,
+                dma_free_coherent(&dd->pdev->dev, AHCI_CMD_TBL_SZ,
                                 port->command_list, port->command_list_dma);
         }
 }
@@ -2861,7 +2861,7 @@ static int mtip_dma_alloc(struct driver_data *dd)
 
         /* Allocate dma memory for RX Fis, Identify, and Sector Bufffer */
         port->block1 =
-                dmam_alloc_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
+                dma_alloc_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
                                         &port->block1_dma, GFP_KERNEL);
         if (!port->block1)
                 return -ENOMEM;
@@ -2869,10 +2869,10 @@ static int mtip_dma_alloc(struct driver_data *dd)
 
         /* Allocate dma memory for command list */
         port->command_list =
-                dmam_alloc_coherent(&dd->pdev->dev, AHCI_CMD_TBL_SZ,
+                dma_alloc_coherent(&dd->pdev->dev, AHCI_CMD_TBL_SZ,
                                         &port->command_list_dma, GFP_KERNEL);
         if (!port->command_list) {
-                dmam_free_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
+                dma_free_coherent(&dd->pdev->dev, BLOCK_DMA_ALLOC_SZ,
                                         port->block1, port->block1_dma);
                 port->block1 = NULL;
                 port->block1_dma = 0;
@@ -3057,13 +3057,8 @@ static int mtip_hw_init(struct driver_data *dd)
         mtip_start_port(dd->port);
 
         /* Setup the ISR and enable interrupts. */
-        rv = devm_request_irq(&dd->pdev->dev,
-                                dd->pdev->irq,
-                                mtip_irq_handler,
-                                IRQF_SHARED,
-                                dev_driver_string(&dd->pdev->dev),
-                                dd);
-
+        rv = request_irq(dd->pdev->irq, mtip_irq_handler, IRQF_SHARED,
+                         dev_driver_string(&dd->pdev->dev), dd);
         if (rv) {
                 dev_err(&dd->pdev->dev,
                         "Unable to allocate IRQ %d\n", dd->pdev->irq);
@@ -3091,7 +3086,7 @@ out3:
 
         /* Release the IRQ. */
         irq_set_affinity_hint(dd->pdev->irq, NULL);
-        devm_free_irq(&dd->pdev->dev, dd->pdev->irq, dd);
+        free_irq(dd->pdev->irq, dd);
 
 out2:
         mtip_deinit_port(dd->port);
@@ -3146,7 +3141,7 @@ static int mtip_hw_exit(struct driver_data *dd)
 
         /* Release the IRQ. */
         irq_set_affinity_hint(dd->pdev->irq, NULL);
-        devm_free_irq(&dd->pdev->dev, dd->pdev->irq, dd);
+        free_irq(dd->pdev->irq, dd);
         msleep(1000);
 
         /* Free dma regions */
@@ -3610,8 +3605,8 @@ static void mtip_free_cmd(struct blk_mq_tag_set *set, struct request *rq,
         if (!cmd->command)
                 return;
 
-        dmam_free_coherent(&dd->pdev->dev, CMD_DMA_ALLOC_SZ,
-                                cmd->command, cmd->command_dma);
+        dma_free_coherent(&dd->pdev->dev, CMD_DMA_ALLOC_SZ, cmd->command,
+                          cmd->command_dma);
 }
 
 static int mtip_init_cmd(struct blk_mq_tag_set *set, struct request *rq,
@@ -3620,7 +3615,7 @@ static int mtip_init_cmd(struct blk_mq_tag_set *set, struct request *rq,
         struct driver_data *dd = set->driver_data;
         struct mtip_cmd *cmd = blk_mq_rq_to_pdu(rq);
 
-        cmd->command = dmam_alloc_coherent(&dd->pdev->dev, CMD_DMA_ALLOC_SZ,
+        cmd->command = dma_alloc_coherent(&dd->pdev->dev, CMD_DMA_ALLOC_SZ,
                         &cmd->command_dma, GFP_KERNEL);
         if (!cmd->command)
                 return -ENOMEM;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 7c9a949e876b..90ba9f4c03f3 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -1571,7 +1571,7 @@ static int nbd_dev_add(int index)
         nbd->tag_set.numa_node = NUMA_NO_NODE;
         nbd->tag_set.cmd_size = sizeof(struct nbd_cmd);
         nbd->tag_set.flags = BLK_MQ_F_SHOULD_MERGE |
-                BLK_MQ_F_SG_MERGE | BLK_MQ_F_BLOCKING;
+                BLK_MQ_F_BLOCKING;
         nbd->tag_set.driver_data = nbd;
 
         err = blk_mq_alloc_tag_set(&nbd->tag_set);
@@ -2118,8 +2118,7 @@ static int nbd_genl_status(struct sk_buff *skb, struct genl_info *info)
         }
         nla_nest_end(reply, dev_list);
         genlmsg_end(reply, reply_head);
-        genlmsg_reply(reply, info);
-        ret = 0;
+        ret = genlmsg_reply(reply, info);
 out:
         mutex_unlock(&nbd_index_mutex);
         return ret;
diff --git a/drivers/block/null_blk_main.c b/drivers/block/null_blk_main.c
index 62c9654b9ce8..417a9f15c116 100644
--- a/drivers/block/null_blk_main.c
+++ b/drivers/block/null_blk_main.c
@@ -1104,7 +1104,7 @@ static int null_handle_bio(struct nullb_cmd *cmd)
                 len = bvec.bv_len;
                 err = null_transfer(nullb, bvec.bv_page, len, bvec.bv_offset,
                                      op_is_write(bio_op(bio)), sector,
-                                     bio_op(bio) & REQ_FUA);
+                                     bio->bi_opf & REQ_FUA);
                 if (err) {
                         spin_unlock_irq(&nullb->lock);
                         return err;
@@ -1678,7 +1678,6 @@ static int null_add_dev(struct nullb_device *dev)
         if (dev->cache_size > 0) {
                 set_bit(NULLB_DEV_FL_CACHE, &nullb->dev->flags);
                 blk_queue_write_cache(nullb->q, true, true);
-                blk_queue_flush_queueable(nullb->q, true);
         }
 
         if (dev->zoned) {
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 282e2e82d849..74088d8dbaf3 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -3987,7 +3987,7 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
         rbd_dev->tag_set.ops = &rbd_mq_ops;
         rbd_dev->tag_set.queue_depth = rbd_dev->opts->queue_depth;
         rbd_dev->tag_set.numa_node = NUMA_NO_NODE;
-        rbd_dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
+        rbd_dev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
         rbd_dev->tag_set.nr_hw_queues = 1;
         rbd_dev->tag_set.cmd_size = sizeof(struct work_struct);
 
diff --git a/drivers/block/skd_main.c b/drivers/block/skd_main.c
index ab893a7571a2..7d3ad6c22ee5 100644
--- a/drivers/block/skd_main.c
+++ b/drivers/block/skd_main.c
@@ -2843,7 +2843,6 @@ static int skd_cons_disk(struct skd_device *skdev)
                 skdev->sgs_per_request * sizeof(struct scatterlist);
         skdev->tag_set.numa_node = NUMA_NO_NODE;
         skdev->tag_set.flags = BLK_MQ_F_SHOULD_MERGE |
-                BLK_MQ_F_SG_MERGE |
                 BLK_ALLOC_POLICY_TO_MQ_FLAG(BLK_TAG_ALLOC_FIFO);
         skdev->tag_set.driver_data = skdev;
         rc = blk_mq_alloc_tag_set(&skdev->tag_set);
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 0ed4b200fa58..d43a5677ccbc 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -977,7 +977,7 @@ static int xlvbd_init_blk_queue(struct gendisk *gd, u16 sector_size,
         } else
                 info->tag_set.queue_depth = BLK_RING_SIZE(info);
         info->tag_set.numa_node = NUMA_NO_NODE;
-        info->tag_set.flags = BLK_MQ_F_SHOULD_MERGE | BLK_MQ_F_SG_MERGE;
+        info->tag_set.flags = BLK_MQ_F_SHOULD_MERGE;
         info->tag_set.cmd_size = sizeof(struct blkif_req);
         info->tag_set.driver_data = info;