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

Pull block layer driver updates from Jens Axboe:

 - NVMe updates:
        - The blk-mq conversion from Matias (and others)

        - A stack of NVMe bug fixes from the nvme tree, mostly from Keith.

        - Various bug fixes from me, fixing issues in both the blk-mq
          conversion and generic bugs.

        - Abort and CPU online fix from Sam.

        - Hot add/remove fix from Indraneel.

 - A couple of drbd fixes from the drbd team (Andreas, Lars, Philipp)

 - With the generic IO stat accounting from 3.19/core, converting md,
   bcache, and rsxx to use those.  From Gu Zheng.

 - Boundary check for queue/irq mode for null_blk from Matias.  Fixes
   cases where invalid values could be given, causing the device to hang.

 - The xen blkfront pull request, with two bug fixes from Vitaly.

* 'for-3.19/drivers' of git://git.kernel.dk/linux-block: (56 commits)
  NVMe: fix race condition in nvme_submit_sync_cmd()
  NVMe: fix retry/error logic in nvme_queue_rq()
  NVMe: Fix FS mount issue (hot-remove followed by hot-add)
  NVMe: fix error return checking from blk_mq_alloc_request()
  NVMe: fix freeing of wrong request in abort path
  xen/blkfront: remove redundant flush_op
  xen/blkfront: improve protection against issuing unsupported REQ_FUA
  NVMe: Fix command setup on IO retry
  null_blk: boundary check queue_mode and irqmode
  block/rsxx: use generic io stats accounting functions to simplify io stat accounting
  md: use generic io stats accounting functions to simplify io stat accounting
  drbd: use generic io stats accounting functions to simplify io stat accounting
  md/bcache: use generic io stats accounting functions to simplify io stat accounting
  NVMe: Update module version major number
  NVMe: fail pci initialization if the device doesn't have any BARs
  NVMe: add ->exit_hctx() hook
  NVMe: make setup work for devices that don't do INTx
  NVMe: enable IO stats by default
  NVMe: nvme_submit_async_admin_req() must use atomic rq allocation
  NVMe: replace blk_put_request() with blk_mq_free_request()
  ...

1 files changed, 12 insertions, 150 deletions

diff --git a/drivers/block/nvme-scsi.c b/drivers/block/nvme-scsi.c
index 0b4b2775600e..5e78568026c3 100644
--- a/drivers/block/nvme-scsi.c
+++ b/drivers/block/nvme-scsi.c
@@ -2105,7 +2105,7 @@ static int nvme_trans_do_nvme_io(struct nvme_ns *ns, struct sg_io_hdr *hdr,
 
                 nvme_offset += unit_num_blocks;
 
-                nvme_sc = nvme_submit_io_cmd(dev, &c, NULL);
+                nvme_sc = nvme_submit_io_cmd(dev, ns, &c, NULL);
                 if (nvme_sc != NVME_SC_SUCCESS) {
                         nvme_unmap_user_pages(dev,
                                 (is_write) ? DMA_TO_DEVICE : DMA_FROM_DEVICE,
@@ -2658,7 +2658,7 @@ static int nvme_trans_start_stop(struct nvme_ns *ns, struct sg_io_hdr *hdr,
                         c.common.opcode = nvme_cmd_flush;
                         c.common.nsid = cpu_to_le32(ns->ns_id);
 
-                        nvme_sc = nvme_submit_io_cmd(ns->dev, &c, NULL);
+                        nvme_sc = nvme_submit_io_cmd(ns->dev, ns, &c, NULL);
                         res = nvme_trans_status_code(hdr, nvme_sc);
                         if (res)
                                 goto out;
@@ -2686,7 +2686,7 @@ static int nvme_trans_synchronize_cache(struct nvme_ns *ns,
         c.common.opcode = nvme_cmd_flush;
         c.common.nsid = cpu_to_le32(ns->ns_id);
 
-        nvme_sc = nvme_submit_io_cmd(ns->dev, &c, NULL);
+        nvme_sc = nvme_submit_io_cmd(ns->dev, ns, &c, NULL);
 
         res = nvme_trans_status_code(hdr, nvme_sc);
         if (res)
@@ -2894,7 +2894,7 @@ static int nvme_trans_unmap(struct nvme_ns *ns, struct sg_io_hdr *hdr,
         c.dsm.nr = cpu_to_le32(ndesc - 1);
         c.dsm.attributes = cpu_to_le32(NVME_DSMGMT_AD);
 
-        nvme_sc = nvme_submit_io_cmd(dev, &c, NULL);
+        nvme_sc = nvme_submit_io_cmd(dev, ns, &c, NULL);
         res = nvme_trans_status_code(hdr, nvme_sc);
 
         dma_free_coherent(&dev->pci_dev->dev, ndesc * sizeof(*range),
@@ -2915,6 +2915,14 @@ static int nvme_scsi_translate(struct nvme_ns *ns, struct sg_io_hdr *hdr)
         if (copy_from_user(cmd, hdr->cmdp, hdr->cmd_len))
                 return -EFAULT;
 
+        /*
+         * Prime the hdr with good status for scsi commands that don't require
+         * an nvme command for translation.
+         */
+        retcode = nvme_trans_status_code(hdr, NVME_SC_SUCCESS);
+        if (retcode)
+                return retcode;
+
         opcode = cmd[0];
 
         switch (opcode) {
@@ -3016,152 +3024,6 @@ int nvme_sg_io(struct nvme_ns *ns, struct sg_io_hdr __user *u_hdr)
         return retcode;
 }
 
-#ifdef CONFIG_COMPAT
-typedef struct sg_io_hdr32 {
-        compat_int_t interface_id;      /* [i] 'S' for SCSI generic (required) */
-        compat_int_t dxfer_direction;   /* [i] data transfer direction  */
-        unsigned char cmd_len;          /* [i] SCSI command length ( <= 16 bytes) */
-        unsigned char mx_sb_len;                /* [i] max length to write to sbp */
-        unsigned short iovec_count;     /* [i] 0 implies no scatter gather */
-        compat_uint_t dxfer_len;                /* [i] byte count of data transfer */
-        compat_uint_t dxferp;           /* [i], [*io] points to data transfer memory
-                                              or scatter gather list */
-        compat_uptr_t cmdp;             /* [i], [*i] points to command to perform */
-        compat_uptr_t sbp;              /* [i], [*o] points to sense_buffer memory */
-        compat_uint_t timeout;          /* [i] MAX_UINT->no timeout (unit: millisec) */
-        compat_uint_t flags;            /* [i] 0 -> default, see SG_FLAG... */
-        compat_int_t pack_id;           /* [i->o] unused internally (normally) */
-        compat_uptr_t usr_ptr;          /* [i->o] unused internally */
-        unsigned char status;           /* [o] scsi status */
-        unsigned char masked_status;    /* [o] shifted, masked scsi status */
-        unsigned char msg_status;               /* [o] messaging level data (optional) */
-        unsigned char sb_len_wr;                /* [o] byte count actually written to sbp */
-        unsigned short host_status;     /* [o] errors from host adapter */
-        unsigned short driver_status;   /* [o] errors from software driver */
-        compat_int_t resid;             /* [o] dxfer_len - actual_transferred */
-        compat_uint_t duration;         /* [o] time taken by cmd (unit: millisec) */
-        compat_uint_t info;             /* [o] auxiliary information */
-} sg_io_hdr32_t;  /* 64 bytes long (on sparc32) */
-
-typedef struct sg_iovec32 {
-        compat_uint_t iov_base;
-        compat_uint_t iov_len;
-} sg_iovec32_t;
-
-static int sg_build_iovec(sg_io_hdr_t __user *sgio, void __user *dxferp, u16 iovec_count)
-{
-        sg_iovec_t __user *iov = (sg_iovec_t __user *) (sgio + 1);
-        sg_iovec32_t __user *iov32 = dxferp;
-        int i;
-
-        for (i = 0; i < iovec_count; i++) {
-                u32 base, len;
-
-                if (get_user(base, &iov32[i].iov_base) ||
-                    get_user(len, &iov32[i].iov_len) ||
-                    put_user(compat_ptr(base), &iov[i].iov_base) ||
-                    put_user(len, &iov[i].iov_len))
-                        return -EFAULT;
-        }
-
-        if (put_user(iov, &sgio->dxferp))
-                return -EFAULT;
-        return 0;
-}
-
-int nvme_sg_io32(struct nvme_ns *ns, unsigned long arg)
-{
-        sg_io_hdr32_t __user *sgio32 = (sg_io_hdr32_t __user *)arg;
-        sg_io_hdr_t __user *sgio;
-        u16 iovec_count;
-        u32 data;
-        void __user *dxferp;
-        int err;
-        int interface_id;
-
-        if (get_user(interface_id, &sgio32->interface_id))
-                return -EFAULT;
-        if (interface_id != 'S')
-                return -EINVAL;
-
-        if (get_user(iovec_count, &sgio32->iovec_count))
-                return -EFAULT;
-
-        {
-                void __user *top = compat_alloc_user_space(0);
-                void __user *new = compat_alloc_user_space(sizeof(sg_io_hdr_t) +
-                                       (iovec_count * sizeof(sg_iovec_t)));
-                if (new > top)
-                        return -EINVAL;
-
-                sgio = new;
-        }
-
-        /* Ok, now construct.  */
-        if (copy_in_user(&sgio->interface_id, &sgio32->interface_id,
-                         (2 * sizeof(int)) +
-                         (2 * sizeof(unsigned char)) +
-                         (1 * sizeof(unsigned short)) +
-                         (1 * sizeof(unsigned int))))
-                return -EFAULT;
-
-        if (get_user(data, &sgio32->dxferp))
-                return -EFAULT;
-        dxferp = compat_ptr(data);
-        if (iovec_count) {
-                if (sg_build_iovec(sgio, dxferp, iovec_count))
-                        return -EFAULT;
-        } else {
-                if (put_user(dxferp, &sgio->dxferp))
-                        return -EFAULT;
-        }
-
-        {
-                unsigned char __user *cmdp;
-                unsigned char __user *sbp;
-
-                if (get_user(data, &sgio32->cmdp))
-                        return -EFAULT;
-                cmdp = compat_ptr(data);
-
-                if (get_user(data, &sgio32->sbp))
-                        return -EFAULT;
-                sbp = compat_ptr(data);
-
-                if (put_user(cmdp, &sgio->cmdp) ||
-                    put_user(sbp, &sgio->sbp))
-                        return -EFAULT;
-        }
-
-        if (copy_in_user(&sgio->timeout, &sgio32->timeout,
-                         3 * sizeof(int)))
-                return -EFAULT;
-
-        if (get_user(data, &sgio32->usr_ptr))
-                return -EFAULT;
-        if (put_user(compat_ptr(data), &sgio->usr_ptr))
-                return -EFAULT;
-
-        err = nvme_sg_io(ns, sgio);
-        if (err >= 0) {
-                void __user *datap;
-
-                if (copy_in_user(&sgio32->pack_id, &sgio->pack_id,
-                                 sizeof(int)) ||
-                    get_user(datap, &sgio->usr_ptr) ||
-                    put_user((u32)(unsigned long)datap,
-                             &sgio32->usr_ptr) ||
-                    copy_in_user(&sgio32->status, &sgio->status,
-                                 (4 * sizeof(unsigned char)) +
-                                 (2 * sizeof(unsigned short)) +
-                                 (3 * sizeof(int))))
-                        err = -EFAULT;
-        }
-
-        return err;
-}
-#endif
-
 int nvme_sg_get_version_num(int __user *ip)
 {
         return put_user(sg_version_num, ip);