NVMe: Rework ioctls

Remove the special-purpose IDENTIFY, GET_RANGE_TYPE, DOWNLOAD_FIRMWARE
and ACTIVATE_FIRMWARE commands.  Replace them with a generic ADMIN_CMD
ioctl that can submit any admin command.

Add a new ID ioctl that returns the namespace ID of the queried device.
It corresponds to the SCSI Idlun ioctl.

Signed-off-by: Matthew Wilcox <matthew.r.wilcox@intel.com>

diff --git a/drivers/block/nvme.c b/drivers/block/nvme.c
index f5e51a6116e3c8fe340a7d362059d28641d1e95f..9e3c724b95c30833921b6ba015826c25ddaa27f1 100644 (file)
--- a/drivers/block/nvme.c
+++ b/drivers/block/nvme.c
@@ -1033,51 +1033,6 @@ static void nvme_unmap_user_pages(struct nvme_dev *dev, int write,
                put_page(sg_page(&sg[i]));
 }
 
-static int nvme_submit_user_admin_command(struct nvme_dev *dev,
-                                       unsigned long addr, unsigned length,
-                                       struct nvme_command *cmd)
-{
-       int err, nents, tmplen = length;
-       struct scatterlist *sg;
-       struct nvme_prps *prps;
-
-       nents = nvme_map_user_pages(dev, 0, addr, length, &sg);
-       if (nents < 0)
-               return nents;
-       prps = nvme_setup_prps(dev, &cmd->common, sg, &tmplen, GFP_KERNEL);
-       if (tmplen != length)
-               err = -ENOMEM;
-       else
-               err = nvme_submit_admin_cmd(dev, cmd, NULL);
-       nvme_unmap_user_pages(dev, 0, addr, length, sg, nents);
-       nvme_free_prps(dev, prps);
-       return err ? -EIO : 0;
-}
-
-static int nvme_identify(struct nvme_ns *ns, unsigned long addr, int cns)
-{
-       struct nvme_command c;
-
-       memset(&c, 0, sizeof(c));
-       c.identify.opcode = nvme_admin_identify;
-       c.identify.nsid = cns ? 0 : cpu_to_le32(ns->ns_id);
-       c.identify.cns = cpu_to_le32(cns);
-
-       return nvme_submit_user_admin_command(ns->dev, addr, 4096, &c);
-}
-
-static int nvme_get_range_type(struct nvme_ns *ns, unsigned long addr)
-{
-       struct nvme_command c;
-
-       memset(&c, 0, sizeof(c));
-       c.features.opcode = nvme_admin_get_features;
-       c.features.nsid = cpu_to_le32(ns->ns_id);
-       c.features.fid = cpu_to_le32(NVME_FEAT_LBA_RANGE);
-
-       return nvme_submit_user_admin_command(ns->dev, addr, 4096, &c);
-}
-
 static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
 {
        struct nvme_dev *dev = ns->dev;
@@ -1096,10 +1051,11 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
        switch (io.opcode) {
        case nvme_cmd_write:
        case nvme_cmd_read:
+       case nvme_cmd_compare:
                nents = nvme_map_user_pages(dev, io.opcode & 1, io.addr,
                                                                length, &sg);
        default:
-               return -EFAULT;
+               return -EINVAL;
        }
 
        if (nents < 0)
@@ -1137,70 +1093,66 @@ static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)
        return status;
 }
 
-static int nvme_download_firmware(struct nvme_ns *ns,
-                                               struct nvme_dlfw __user *udlfw)
+static int nvme_user_admin_cmd(struct nvme_ns *ns,
+                                       struct nvme_admin_cmd __user *ucmd)
 {
        struct nvme_dev *dev = ns->dev;
-       struct nvme_dlfw dlfw;
+       struct nvme_admin_cmd cmd;
        struct nvme_command c;
-       int nents, status, length;
+       int status, length, nents = 0;
        struct scatterlist *sg;
-       struct nvme_prps *prps;
+       struct nvme_prps *prps = NULL;
 
-       if (copy_from_user(&dlfw, udlfw, sizeof(dlfw)))
+       if (!capable(CAP_SYS_ADMIN))
+               return -EACCES;
+       if (copy_from_user(&cmd, ucmd, sizeof(cmd)))
                return -EFAULT;
-       if (dlfw.length >= (1 << 30))
-               return -EINVAL;
-       length = dlfw.length * 4;
-
-       nents = nvme_map_user_pages(dev, 1, dlfw.addr, length, &sg);
-       if (nents < 0)
-               return nents;
 
        memset(&c, 0, sizeof(c));
-       c.dlfw.opcode = nvme_admin_download_fw;
-       c.dlfw.numd = cpu_to_le32(dlfw.length);
-       c.dlfw.offset = cpu_to_le32(dlfw.offset);
-       prps = nvme_setup_prps(dev, &c.common, sg, &length, GFP_KERNEL);
-       if (length != dlfw.length * 4)
+       c.common.opcode = cmd.opcode;
+       c.common.flags = cmd.flags;
+       c.common.nsid = cpu_to_le32(cmd.nsid);
+       c.common.cdw2[0] = cpu_to_le32(cmd.cdw2);
+       c.common.cdw2[1] = cpu_to_le32(cmd.cdw3);
+       c.common.cdw10[0] = cpu_to_le32(cmd.cdw10);
+       c.common.cdw10[1] = cpu_to_le32(cmd.cdw11);
+       c.common.cdw10[2] = cpu_to_le32(cmd.cdw12);
+       c.common.cdw10[3] = cpu_to_le32(cmd.cdw13);
+       c.common.cdw10[4] = cpu_to_le32(cmd.cdw14);
+       c.common.cdw10[5] = cpu_to_le32(cmd.cdw15);
+
+       length = cmd.data_len;
+       if (cmd.data_len) {
+               nents = nvme_map_user_pages(dev, 1, cmd.addr, length, &sg);
+               if (nents < 0)
+                       return nents;
+               prps = nvme_setup_prps(dev, &c.common, sg, &length, GFP_KERNEL);
+       }
+
+       if (length != cmd.data_len)
                status = -ENOMEM;
        else
                status = nvme_submit_admin_cmd(dev, &c, NULL);
-       nvme_unmap_user_pages(dev, 0, dlfw.addr, dlfw.length * 4, sg, nents);
-       nvme_free_prps(dev, prps);
+       if (cmd.data_len) {
+               nvme_unmap_user_pages(dev, 0, cmd.addr, cmd.data_len, sg,
+                                                                       nents);
+               nvme_free_prps(dev, prps);
+       }
        return status;
 }
 
-static int nvme_activate_firmware(struct nvme_ns *ns, unsigned long arg)
-{
-       struct nvme_dev *dev = ns->dev;
-       struct nvme_command c;
-
-       memset(&c, 0, sizeof(c));
-       c.common.opcode = nvme_admin_activate_fw;
-       c.common.rsvd10[0] = cpu_to_le32(arg);
-
-       return nvme_submit_admin_cmd(dev, &c, NULL);
-}
-
 static int nvme_ioctl(struct block_device *bdev, fmode_t mode, unsigned int cmd,
                                                        unsigned long arg)
 {
        struct nvme_ns *ns = bdev->bd_disk->private_data;
 
        switch (cmd) {
-       case NVME_IOCTL_IDENTIFY_NS:
-               return nvme_identify(ns, arg, 0);
-       case NVME_IOCTL_IDENTIFY_CTRL:
-               return nvme_identify(ns, arg, 1);
-       case NVME_IOCTL_GET_RANGE_TYPE:
-               return nvme_get_range_type(ns, arg);
+       case NVME_IOCTL_ID:
+               return ns->ns_id;
+       case NVME_IOCTL_ADMIN_CMD:
+               return nvme_user_admin_cmd(ns, (void __user *)arg);
        case NVME_IOCTL_SUBMIT_IO:
                return nvme_submit_io(ns, (void __user *)arg);
-       case NVME_IOCTL_DOWNLOAD_FW:
-               return nvme_download_firmware(ns, (void __user *)arg);
-       case NVME_IOCTL_ACTIVATE_FW:
-               return nvme_activate_firmware(ns, arg);
        default:
                return -ENOTTY;
        }

diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index a19304fefa7dc4f0b093df2b5ee63e14da2c242a..c96ab0f5ef6ff244431b0bd3757bd8fa7d58a764 100644 (file)
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -153,11 +153,11 @@ struct nvme_common_command {
        __u8                    flags;
        __u16                   command_id;
        __le32                  nsid;
-       __u64                   rsvd2;
+       __u32                   cdw2[2];
        __le64                  metadata;
        __le64                  prp1;
        __le64                  prp2;
-       __u32                   rsvd10[6];
+       __u32                   cdw10[6];
 };
 
 struct nvme_rw_command {
@@ -388,17 +388,29 @@ struct nvme_user_io {
        __u16   appmask;
 };
 
-struct nvme_dlfw {
+struct nvme_admin_cmd {
+       __u8    opcode;
+       __u8    flags;
+       __u16   rsvd1;
+       __u32   nsid;
+       __u32   cdw2;
+       __u32   cdw3;
+       __u64   metadata;
        __u64   addr;
-       __u32   length; /* In dwords */
-       __u32   offset; /* In dwords */
+       __u32   metadata_len;
+       __u32   data_len;
+       __u32   cdw10;
+       __u32   cdw11;
+       __u32   cdw12;
+       __u32   cdw13;
+       __u32   cdw14;
+       __u32   cdw15;
+       __u32   timeout_ms;
+       __u32   result;
 };
 
-#define NVME_IOCTL_IDENTIFY_NS _IOW('N', 0x40, struct nvme_id_ns)
-#define NVME_IOCTL_IDENTIFY_CTRL _IOW('N', 0x41, struct nvme_id_ctrl)
-#define NVME_IOCTL_GET_RANGE_TYPE _IOW('N', 0x42, struct nvme_lba_range_type)
-#define NVME_IOCTL_SUBMIT_IO   _IOW('N', 0x43, struct nvme_user_io)
-#define NVME_IOCTL_DOWNLOAD_FW _IOW('N', 0x44, struct nvme_dlfw)
-#define NVME_IOCTL_ACTIVATE_FW _IO('N', 0x45)
+#define NVME_IOCTL_ID          _IO('N', 0x40)
+#define NVME_IOCTL_ADMIN_CMD   _IOWR('N', 0x41, struct nvme_admin_cmd)
+#define NVME_IOCTL_SUBMIT_IO   _IOW('N', 0x42, struct nvme_user_io)
 
 #endif /* _LINUX_NVME_H */