Commit 2405252a authored by Christoph Hellwig's avatar Christoph Hellwig
Browse files

nvme: move the ioctl code to a separate file 



Split out the ioctl code from core.c into a new file.  Also update
copyrights while we're at it.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarKeith Busch <kbusch@kernel.org>
Reviewed-by: default avatarJavier González <javier.gonz@samsung.com>
Reviewed-by: default avatarChaitanya Kulkarni <chaitanya.kulkarni@wdc.com>
parent 3557a440

drivers/nvme/host/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -9,7 +9,7 @@ obj-$(CONFIG_NVME_RDMA) += nvme-rdma.o 
obj-$(CONFIG_NVME_FC)			+= nvme-fc.o

obj-$(CONFIG_NVME_TCP)			+= nvme-tcp.o



nvme-core-y				:= core.o

nvme-core-y				:= core.o ioctl.o

nvme-core-$(CONFIG_TRACING)		+= trace.o

nvme-core-$(CONFIG_NVME_MULTIPATH)	+= multipath.o

nvme-core-$(CONFIG_NVM)			+= lightnvm.o

drivers/nvme/host/core.c

+3 −447
Original line number Diff line number Diff line
@@ -112,7 +112,7 @@ static void nvme_set_queue_dying(struct nvme_ns *ns) 
	set_capacity_and_notify(ns->disk, 0);

}



static void nvme_queue_scan(struct nvme_ctrl *ctrl)

void nvme_queue_scan(struct nvme_ctrl *ctrl)

{

	/*

	 * Only new queue scan work when admin and IO queues are both alive
@@ -179,7 +179,7 @@ int nvme_reset_ctrl(struct nvme_ctrl *ctrl) 
}

EXPORT_SYMBOL_GPL(nvme_reset_ctrl);



static int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl)

int nvme_reset_ctrl_sync(struct nvme_ctrl *ctrl)

{

	int ret;
@@ -1016,40 +1016,6 @@ int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, 
}

EXPORT_SYMBOL_GPL(nvme_submit_sync_cmd);



static void *nvme_add_user_metadata(struct bio *bio, void __user *ubuf,

		unsigned len, u32 seed, bool write)

{

	struct bio_integrity_payload *bip;

	int ret = -ENOMEM;

	void *buf;



	buf = kmalloc(len, GFP_KERNEL);

	if (!buf)

		goto out;



	ret = -EFAULT;

	if (write && copy_from_user(buf, ubuf, len))

		goto out_free_meta;



	bip = bio_integrity_alloc(bio, GFP_KERNEL, 1);

	if (IS_ERR(bip)) {

		ret = PTR_ERR(bip);

		goto out_free_meta;

	}



	bip->bip_iter.bi_size = len;

	bip->bip_iter.bi_sector = seed;

	ret = bio_integrity_add_page(bio, virt_to_page(buf), len,

			offset_in_page(buf));

	if (ret == len)

		return buf;

	ret = -ENOMEM;

out_free_meta:

	kfree(buf);

out:

	return ERR_PTR(ret);

}



static u32 nvme_known_admin_effects(u8 opcode)

{

	switch (opcode) {
@@ -1138,66 +1104,6 @@ void nvme_execute_passthru_rq(struct request *rq) 
}

EXPORT_SYMBOL_NS_GPL(nvme_execute_passthru_rq, NVME_TARGET_PASSTHRU);



static int nvme_submit_user_cmd(struct request_queue *q,

		struct nvme_command *cmd, void __user *ubuffer,

		unsigned bufflen, void __user *meta_buffer, unsigned meta_len,

		u32 meta_seed, u64 *result, unsigned timeout)

{

	bool write = nvme_is_write(cmd);

	struct nvme_ns *ns = q->queuedata;

	struct block_device *bdev = ns ? ns->disk->part0 : NULL;

	struct request *req;

	struct bio *bio = NULL;

	void *meta = NULL;

	int ret;



	req = nvme_alloc_request(q, cmd, 0);

	if (IS_ERR(req))

		return PTR_ERR(req);



	if (timeout)

		req->timeout = timeout;

	nvme_req(req)->flags |= NVME_REQ_USERCMD;



	if (ubuffer && bufflen) {

		ret = blk_rq_map_user(q, req, NULL, ubuffer, bufflen,

				GFP_KERNEL);

		if (ret)

			goto out;

		bio = req->bio;

		if (bdev)

			bio_set_dev(bio, bdev);

		if (bdev && meta_buffer && meta_len) {

			meta = nvme_add_user_metadata(bio, meta_buffer, meta_len,

					meta_seed, write);

			if (IS_ERR(meta)) {

				ret = PTR_ERR(meta);

				goto out_unmap;

			}

			req->cmd_flags |= REQ_INTEGRITY;

		}

	}



	nvme_execute_passthru_rq(req);

	if (nvme_req(req)->flags & NVME_REQ_CANCELLED)

		ret = -EINTR;

	else

		ret = nvme_req(req)->status;

	if (result)

		*result = le64_to_cpu(nvme_req(req)->result.u64);

	if (meta && !ret && !write) {

		if (copy_to_user(meta_buffer, meta, meta_len))

			ret = -EFAULT;

	}

	kfree(meta);

 out_unmap:

	if (bio)

		blk_rq_unmap_user(bio);

 out:

	blk_mq_free_request(req);

	return ret;

}



static void nvme_keep_alive_end_io(struct request *rq, blk_status_t status)

{

	struct nvme_ctrl *ctrl = rq->end_io_data;
@@ -1542,182 +1448,6 @@ static void nvme_enable_aen(struct nvme_ctrl *ctrl) 
	queue_work(nvme_wq, &ctrl->async_event_work);

}



/*

 * Convert integer values from ioctl structures to user pointers, silently

 * ignoring the upper bits in the compat case to match behaviour of 32-bit

 * kernels.

 */

static void __user *nvme_to_user_ptr(uintptr_t ptrval)

{

	if (in_compat_syscall())

		ptrval = (compat_uptr_t)ptrval;

	return (void __user *)ptrval;

}



static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)

{

	struct nvme_user_io io;

	struct nvme_command c;

	unsigned length, meta_len;

	void __user *metadata;



	if (copy_from_user(&io, uio, sizeof(io)))

		return -EFAULT;

	if (io.flags)

		return -EINVAL;



	switch (io.opcode) {

	case nvme_cmd_write:

	case nvme_cmd_read:

	case nvme_cmd_compare:

		break;

	default:

		return -EINVAL;

	}



	length = (io.nblocks + 1) << ns->lba_shift;



	if ((io.control & NVME_RW_PRINFO_PRACT) &&

	    ns->ms == sizeof(struct t10_pi_tuple)) {

		/*

		 * Protection information is stripped/inserted by the

		 * controller.

		 */

		if (nvme_to_user_ptr(io.metadata))

			return -EINVAL;

		meta_len = 0;

		metadata = NULL;

	} else {

		meta_len = (io.nblocks + 1) * ns->ms;

		metadata = nvme_to_user_ptr(io.metadata);

	}



	if (ns->features & NVME_NS_EXT_LBAS) {

		length += meta_len;

		meta_len = 0;

	} else if (meta_len) {

		if ((io.metadata & 3) || !io.metadata)

			return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	c.rw.opcode = io.opcode;

	c.rw.flags = io.flags;

	c.rw.nsid = cpu_to_le32(ns->head->ns_id);

	c.rw.slba = cpu_to_le64(io.slba);

	c.rw.length = cpu_to_le16(io.nblocks);

	c.rw.control = cpu_to_le16(io.control);

	c.rw.dsmgmt = cpu_to_le32(io.dsmgmt);

	c.rw.reftag = cpu_to_le32(io.reftag);

	c.rw.apptag = cpu_to_le16(io.apptag);

	c.rw.appmask = cpu_to_le16(io.appmask);



	return nvme_submit_user_cmd(ns->queue, &c,

			nvme_to_user_ptr(io.addr), length,

			metadata, meta_len, lower_32_bits(io.slba), NULL, 0);

}



static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns,

			struct nvme_passthru_cmd __user *ucmd)

{

	struct nvme_passthru_cmd cmd;

	struct nvme_command c;

	unsigned timeout = 0;

	u64 result;

	int status;



	if (!capable(CAP_SYS_ADMIN))

		return -EACCES;

	if (copy_from_user(&cmd, ucmd, sizeof(cmd)))

		return -EFAULT;

	if (cmd.flags)

		return -EINVAL;

	if (ns && cmd.nsid != ns->head->ns_id) {

		dev_err(ctrl->device,

			"%s: nsid (%u) in cmd does not match nsid (%u) of namespace\n",

			current->comm, cmd.nsid, ns->head->ns_id);

		return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	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 = cpu_to_le32(cmd.cdw10);

	c.common.cdw11 = cpu_to_le32(cmd.cdw11);

	c.common.cdw12 = cpu_to_le32(cmd.cdw12);

	c.common.cdw13 = cpu_to_le32(cmd.cdw13);

	c.common.cdw14 = cpu_to_le32(cmd.cdw14);

	c.common.cdw15 = cpu_to_le32(cmd.cdw15);



	if (cmd.timeout_ms)

		timeout = msecs_to_jiffies(cmd.timeout_ms);



	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &result, timeout);



	if (status >= 0) {

		if (put_user(result, &ucmd->result))

			return -EFAULT;

	}



	return status;

}



static int nvme_user_cmd64(struct nvme_ctrl *ctrl, struct nvme_ns *ns,

			struct nvme_passthru_cmd64 __user *ucmd)

{

	struct nvme_passthru_cmd64 cmd;

	struct nvme_command c;

	unsigned timeout = 0;

	int status;



	if (!capable(CAP_SYS_ADMIN))

		return -EACCES;

	if (copy_from_user(&cmd, ucmd, sizeof(cmd)))

		return -EFAULT;

	if (cmd.flags)

		return -EINVAL;

	if (ns && cmd.nsid != ns->head->ns_id) {

		dev_err(ctrl->device,

			"%s: nsid (%u) in cmd does not match nsid (%u) of namespace\n",

			current->comm, cmd.nsid, ns->head->ns_id);

		return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	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 = cpu_to_le32(cmd.cdw10);

	c.common.cdw11 = cpu_to_le32(cmd.cdw11);

	c.common.cdw12 = cpu_to_le32(cmd.cdw12);

	c.common.cdw13 = cpu_to_le32(cmd.cdw13);

	c.common.cdw14 = cpu_to_le32(cmd.cdw14);

	c.common.cdw15 = cpu_to_le32(cmd.cdw15);



	if (cmd.timeout_ms)

		timeout = msecs_to_jiffies(cmd.timeout_ms);



	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &cmd.result, timeout);



	if (status >= 0) {

		if (put_user(cmd.result, &ucmd->result))

			return -EFAULT;

	}



	return status;

}



/*

 * Issue ioctl requests on the first available path.  Note that unlike normal

 * block layer requests we will not retry failed request on another controller.
@@ -1748,85 +1478,6 @@ void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx) 
		srcu_read_unlock(&head->srcu, idx);

}



static bool is_ctrl_ioctl(unsigned int cmd)

{

	if (cmd == NVME_IOCTL_ADMIN_CMD || cmd == NVME_IOCTL_ADMIN64_CMD)

		return true;

	if (is_sed_ioctl(cmd))

		return true;

	return false;

}



static int nvme_ctrl_ioctl(struct nvme_ctrl *ctrl, unsigned int cmd,

		void __user *argp)

{

	switch (cmd) {

	case NVME_IOCTL_ADMIN_CMD:

		return nvme_user_cmd(ctrl, NULL, argp);

	case NVME_IOCTL_ADMIN64_CMD:

		return nvme_user_cmd64(ctrl, NULL, argp);

	default:

		return sed_ioctl(ctrl->opal_dev, cmd, argp);

	}

}



#ifdef COMPAT_FOR_U64_ALIGNMENT

struct nvme_user_io32 {

	__u8	opcode;

	__u8	flags;

	__u16	control;

	__u16	nblocks;

	__u16	rsvd;

	__u64	metadata;

	__u64	addr;

	__u64	slba;

	__u32	dsmgmt;

	__u32	reftag;

	__u16	apptag;

	__u16	appmask;

} __attribute__((__packed__));

#define NVME_IOCTL_SUBMIT_IO32	_IOW('N', 0x42, struct nvme_user_io32)

#endif /* COMPAT_FOR_U64_ALIGNMENT */



static int nvme_ns_ioctl(struct nvme_ns *ns, unsigned int cmd,

		void __user *argp)

{

	switch (cmd) {

	case NVME_IOCTL_ID:

		force_successful_syscall_return();

		return ns->head->ns_id;

	case NVME_IOCTL_IO_CMD:

		return nvme_user_cmd(ns->ctrl, ns, argp);

	/*

	 * struct nvme_user_io can have different padding on some 32-bit ABIs.

	 * Just accept the compat version as all fields that are used are the

	 * same size and at the same offset.

	 */

#ifdef COMPAT_FOR_U64_ALIGNMENT

	case NVME_IOCTL_SUBMIT_IO32:

#endif

	case NVME_IOCTL_SUBMIT_IO:

		return nvme_submit_io(ns, argp);

	case NVME_IOCTL_IO64_CMD:

		return nvme_user_cmd64(ns->ctrl, ns, argp);

	default:

		if (!ns->ndev)

			return -ENOTTY;

		return nvme_nvm_ioctl(ns, cmd, argp);

	}

}



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;

	void __user *argp = (void __user *)arg;



	if (is_ctrl_ioctl(cmd))

		return nvme_ctrl_ioctl(ns->ctrl, cmd, argp);

	return nvme_ns_ioctl(ns, cmd, argp);

}



static int nvme_open(struct block_device *bdev, fmode_t mode)

{

	struct nvme_ns *ns = bdev->bd_disk->private_data;
@@ -2336,7 +1987,7 @@ static void nvme_ns_head_release(struct gendisk *disk, fmode_t mode) 
	nvme_put_ns_head(disk->private_data);

}



static struct nvme_ctrl *nvme_find_get_live_ctrl(struct nvme_subsystem *subsys)

struct nvme_ctrl *nvme_find_get_live_ctrl(struct nvme_subsystem *subsys)

{

	struct nvme_ctrl *ctrl;

	int ret;
@@ -2356,42 +2007,6 @@ static struct nvme_ctrl *nvme_find_get_live_ctrl(struct nvme_subsystem *subsys) 
	return ctrl;

}



static int nvme_ns_head_ctrl_ioctl(struct nvme_ns_head *head,

		unsigned int cmd, void __user *argp)

{

	struct nvme_ctrl *ctrl = nvme_find_get_live_ctrl(head->subsys);

	int ret;



	if (IS_ERR(ctrl))

		return PTR_ERR(ctrl);

	ret = nvme_ctrl_ioctl(ctrl, cmd, argp);

	nvme_put_ctrl(ctrl);

	return ret;

}



static int nvme_ns_head_ns_ioctl(struct nvme_ns_head *head,

		unsigned int cmd, void __user *argp)

{

	int srcu_idx = srcu_read_lock(&head->srcu);

	struct nvme_ns *ns = nvme_find_path(head);

	int ret = -EWOULDBLOCK;



	if (ns)

		ret = nvme_ns_ioctl(ns, cmd, argp);

	srcu_read_unlock(&head->srcu, srcu_idx);

	return ret;

}



static int nvme_ns_head_ioctl(struct block_device *bdev, fmode_t mode,

		unsigned int cmd, unsigned long arg)

{

	struct nvme_ns_head *head = bdev->bd_disk->private_data;



	if (is_ctrl_ioctl(cmd))

		return nvme_ns_head_ctrl_ioctl(head, cmd, (void __user *)arg);

	return nvme_ns_head_ns_ioctl(head, cmd, (void __user *)arg);

}



const struct block_device_operations nvme_ns_head_ops = {

	.owner		= THIS_MODULE,

	.submit_bio	= nvme_ns_head_submit_bio,
@@ -3354,65 +2969,6 @@ static int nvme_dev_release(struct inode *inode, struct file *file) 
	return 0;

}



static int nvme_dev_user_cmd(struct nvme_ctrl *ctrl, void __user *argp)

{

	struct nvme_ns *ns;

	int ret;



	down_read(&ctrl->namespaces_rwsem);

	if (list_empty(&ctrl->namespaces)) {

		ret = -ENOTTY;

		goto out_unlock;

	}



	ns = list_first_entry(&ctrl->namespaces, struct nvme_ns, list);

	if (ns != list_last_entry(&ctrl->namespaces, struct nvme_ns, list)) {

		dev_warn(ctrl->device,

			"NVME_IOCTL_IO_CMD not supported when multiple namespaces present!\n");

		ret = -EINVAL;

		goto out_unlock;

	}



	dev_warn(ctrl->device,

		"using deprecated NVME_IOCTL_IO_CMD ioctl on the char device!\n");

	kref_get(&ns->kref);

	up_read(&ctrl->namespaces_rwsem);



	ret = nvme_user_cmd(ctrl, ns, argp);

	nvme_put_ns(ns);

	return ret;



out_unlock:

	up_read(&ctrl->namespaces_rwsem);

	return ret;

}



static long nvme_dev_ioctl(struct file *file, unsigned int cmd,

		unsigned long arg)

{

	struct nvme_ctrl *ctrl = file->private_data;

	void __user *argp = (void __user *)arg;



	switch (cmd) {

	case NVME_IOCTL_ADMIN_CMD:

		return nvme_user_cmd(ctrl, NULL, argp);

	case NVME_IOCTL_ADMIN64_CMD:

		return nvme_user_cmd64(ctrl, NULL, argp);

	case NVME_IOCTL_IO_CMD:

		return nvme_dev_user_cmd(ctrl, argp);

	case NVME_IOCTL_RESET:

		dev_warn(ctrl->device, "resetting controller\n");

		return nvme_reset_ctrl_sync(ctrl);

	case NVME_IOCTL_SUBSYS_RESET:

		return nvme_reset_subsystem(ctrl);

	case NVME_IOCTL_RESCAN:

		nvme_queue_scan(ctrl);

		return 0;

	default:

		return -ENOTTY;

	}

}



static const struct file_operations nvme_dev_fops = {

	.owner		= THIS_MODULE,

	.open		= nvme_dev_open,

drivers/nvme/host/ioctl.c

0 → 100644
+455 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (c) 2011-2014, Intel Corporation.

 * Copyright (c) 2017-2021 Christoph Hellwig.

 */

#include <linux/ptrace.h>	/* for force_successful_syscall_return */

#include <linux/nvme_ioctl.h>

#include "nvme.h"



/*

 * Convert integer values from ioctl structures to user pointers, silently

 * ignoring the upper bits in the compat case to match behaviour of 32-bit

 * kernels.

 */

static void __user *nvme_to_user_ptr(uintptr_t ptrval)

{

	if (in_compat_syscall())

		ptrval = (compat_uptr_t)ptrval;

	return (void __user *)ptrval;

}



static void *nvme_add_user_metadata(struct bio *bio, void __user *ubuf,

		unsigned len, u32 seed, bool write)

{

	struct bio_integrity_payload *bip;

	int ret = -ENOMEM;

	void *buf;



	buf = kmalloc(len, GFP_KERNEL);

	if (!buf)

		goto out;



	ret = -EFAULT;

	if (write && copy_from_user(buf, ubuf, len))

		goto out_free_meta;



	bip = bio_integrity_alloc(bio, GFP_KERNEL, 1);

	if (IS_ERR(bip)) {

		ret = PTR_ERR(bip);

		goto out_free_meta;

	}



	bip->bip_iter.bi_size = len;

	bip->bip_iter.bi_sector = seed;

	ret = bio_integrity_add_page(bio, virt_to_page(buf), len,

			offset_in_page(buf));

	if (ret == len)

		return buf;

	ret = -ENOMEM;

out_free_meta:

	kfree(buf);

out:

	return ERR_PTR(ret);

}



static int nvme_submit_user_cmd(struct request_queue *q,

		struct nvme_command *cmd, void __user *ubuffer,

		unsigned bufflen, void __user *meta_buffer, unsigned meta_len,

		u32 meta_seed, u64 *result, unsigned timeout)

{

	bool write = nvme_is_write(cmd);

	struct nvme_ns *ns = q->queuedata;

	struct block_device *bdev = ns ? ns->disk->part0 : NULL;

	struct request *req;

	struct bio *bio = NULL;

	void *meta = NULL;

	int ret;



	req = nvme_alloc_request(q, cmd, 0);

	if (IS_ERR(req))

		return PTR_ERR(req);



	if (timeout)

		req->timeout = timeout;

	nvme_req(req)->flags |= NVME_REQ_USERCMD;



	if (ubuffer && bufflen) {

		ret = blk_rq_map_user(q, req, NULL, ubuffer, bufflen,

				GFP_KERNEL);

		if (ret)

			goto out;

		bio = req->bio;

		if (bdev)

			bio_set_dev(bio, bdev);

		if (bdev && meta_buffer && meta_len) {

			meta = nvme_add_user_metadata(bio, meta_buffer, meta_len,

					meta_seed, write);

			if (IS_ERR(meta)) {

				ret = PTR_ERR(meta);

				goto out_unmap;

			}

			req->cmd_flags |= REQ_INTEGRITY;

		}

	}



	nvme_execute_passthru_rq(req);

	if (nvme_req(req)->flags & NVME_REQ_CANCELLED)

		ret = -EINTR;

	else

		ret = nvme_req(req)->status;

	if (result)

		*result = le64_to_cpu(nvme_req(req)->result.u64);

	if (meta && !ret && !write) {

		if (copy_to_user(meta_buffer, meta, meta_len))

			ret = -EFAULT;

	}

	kfree(meta);

 out_unmap:

	if (bio)

		blk_rq_unmap_user(bio);

 out:

	blk_mq_free_request(req);

	return ret;

}





static int nvme_submit_io(struct nvme_ns *ns, struct nvme_user_io __user *uio)

{

	struct nvme_user_io io;

	struct nvme_command c;

	unsigned length, meta_len;

	void __user *metadata;



	if (copy_from_user(&io, uio, sizeof(io)))

		return -EFAULT;

	if (io.flags)

		return -EINVAL;



	switch (io.opcode) {

	case nvme_cmd_write:

	case nvme_cmd_read:

	case nvme_cmd_compare:

		break;

	default:

		return -EINVAL;

	}



	length = (io.nblocks + 1) << ns->lba_shift;



	if ((io.control & NVME_RW_PRINFO_PRACT) &&

	    ns->ms == sizeof(struct t10_pi_tuple)) {

		/*

		 * Protection information is stripped/inserted by the

		 * controller.

		 */

		if (nvme_to_user_ptr(io.metadata))

			return -EINVAL;

		meta_len = 0;

		metadata = NULL;

	} else {

		meta_len = (io.nblocks + 1) * ns->ms;

		metadata = nvme_to_user_ptr(io.metadata);

	}



	if (ns->features & NVME_NS_EXT_LBAS) {

		length += meta_len;

		meta_len = 0;

	} else if (meta_len) {

		if ((io.metadata & 3) || !io.metadata)

			return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	c.rw.opcode = io.opcode;

	c.rw.flags = io.flags;

	c.rw.nsid = cpu_to_le32(ns->head->ns_id);

	c.rw.slba = cpu_to_le64(io.slba);

	c.rw.length = cpu_to_le16(io.nblocks);

	c.rw.control = cpu_to_le16(io.control);

	c.rw.dsmgmt = cpu_to_le32(io.dsmgmt);

	c.rw.reftag = cpu_to_le32(io.reftag);

	c.rw.apptag = cpu_to_le16(io.apptag);

	c.rw.appmask = cpu_to_le16(io.appmask);



	return nvme_submit_user_cmd(ns->queue, &c,

			nvme_to_user_ptr(io.addr), length,

			metadata, meta_len, lower_32_bits(io.slba), NULL, 0);

}



static int nvme_user_cmd(struct nvme_ctrl *ctrl, struct nvme_ns *ns,

			struct nvme_passthru_cmd __user *ucmd)

{

	struct nvme_passthru_cmd cmd;

	struct nvme_command c;

	unsigned timeout = 0;

	u64 result;

	int status;



	if (!capable(CAP_SYS_ADMIN))

		return -EACCES;

	if (copy_from_user(&cmd, ucmd, sizeof(cmd)))

		return -EFAULT;

	if (cmd.flags)

		return -EINVAL;

	if (ns && cmd.nsid != ns->head->ns_id) {

		dev_err(ctrl->device,

			"%s: nsid (%u) in cmd does not match nsid (%u) of namespace\n",

			current->comm, cmd.nsid, ns->head->ns_id);

		return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	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 = cpu_to_le32(cmd.cdw10);

	c.common.cdw11 = cpu_to_le32(cmd.cdw11);

	c.common.cdw12 = cpu_to_le32(cmd.cdw12);

	c.common.cdw13 = cpu_to_le32(cmd.cdw13);

	c.common.cdw14 = cpu_to_le32(cmd.cdw14);

	c.common.cdw15 = cpu_to_le32(cmd.cdw15);



	if (cmd.timeout_ms)

		timeout = msecs_to_jiffies(cmd.timeout_ms);



	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &result, timeout);



	if (status >= 0) {

		if (put_user(result, &ucmd->result))

			return -EFAULT;

	}



	return status;

}



static int nvme_user_cmd64(struct nvme_ctrl *ctrl, struct nvme_ns *ns,

			struct nvme_passthru_cmd64 __user *ucmd)

{

	struct nvme_passthru_cmd64 cmd;

	struct nvme_command c;

	unsigned timeout = 0;

	int status;



	if (!capable(CAP_SYS_ADMIN))

		return -EACCES;

	if (copy_from_user(&cmd, ucmd, sizeof(cmd)))

		return -EFAULT;

	if (cmd.flags)

		return -EINVAL;

	if (ns && cmd.nsid != ns->head->ns_id) {

		dev_err(ctrl->device,

			"%s: nsid (%u) in cmd does not match nsid (%u) of namespace\n",

			current->comm, cmd.nsid, ns->head->ns_id);

		return -EINVAL;

	}



	memset(&c, 0, sizeof(c));

	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 = cpu_to_le32(cmd.cdw10);

	c.common.cdw11 = cpu_to_le32(cmd.cdw11);

	c.common.cdw12 = cpu_to_le32(cmd.cdw12);

	c.common.cdw13 = cpu_to_le32(cmd.cdw13);

	c.common.cdw14 = cpu_to_le32(cmd.cdw14);

	c.common.cdw15 = cpu_to_le32(cmd.cdw15);



	if (cmd.timeout_ms)

		timeout = msecs_to_jiffies(cmd.timeout_ms);



	status = nvme_submit_user_cmd(ns ? ns->queue : ctrl->admin_q, &c,

			nvme_to_user_ptr(cmd.addr), cmd.data_len,

			nvme_to_user_ptr(cmd.metadata), cmd.metadata_len,

			0, &cmd.result, timeout);



	if (status >= 0) {

		if (put_user(cmd.result, &ucmd->result))

			return -EFAULT;

	}



	return status;

}



static bool is_ctrl_ioctl(unsigned int cmd)

{

	if (cmd == NVME_IOCTL_ADMIN_CMD || cmd == NVME_IOCTL_ADMIN64_CMD)

		return true;

	if (is_sed_ioctl(cmd))

		return true;

	return false;

}



static int nvme_ctrl_ioctl(struct nvme_ctrl *ctrl, unsigned int cmd,

		void __user *argp)

{

	switch (cmd) {

	case NVME_IOCTL_ADMIN_CMD:

		return nvme_user_cmd(ctrl, NULL, argp);

	case NVME_IOCTL_ADMIN64_CMD:

		return nvme_user_cmd64(ctrl, NULL, argp);

	default:

		return sed_ioctl(ctrl->opal_dev, cmd, argp);

	}

}



#ifdef COMPAT_FOR_U64_ALIGNMENT

struct nvme_user_io32 {

	__u8	opcode;

	__u8	flags;

	__u16	control;

	__u16	nblocks;

	__u16	rsvd;

	__u64	metadata;

	__u64	addr;

	__u64	slba;

	__u32	dsmgmt;

	__u32	reftag;

	__u16	apptag;

	__u16	appmask;

} __attribute__((__packed__));

#define NVME_IOCTL_SUBMIT_IO32	_IOW('N', 0x42, struct nvme_user_io32)

#endif /* COMPAT_FOR_U64_ALIGNMENT */



static int nvme_ns_ioctl(struct nvme_ns *ns, unsigned int cmd,

		void __user *argp)

{

	switch (cmd) {

	case NVME_IOCTL_ID:

		force_successful_syscall_return();

		return ns->head->ns_id;

	case NVME_IOCTL_IO_CMD:

		return nvme_user_cmd(ns->ctrl, ns, argp);

	/*

	 * struct nvme_user_io can have different padding on some 32-bit ABIs.

	 * Just accept the compat version as all fields that are used are the

	 * same size and at the same offset.

	 */

#ifdef COMPAT_FOR_U64_ALIGNMENT

	case NVME_IOCTL_SUBMIT_IO32:

#endif

	case NVME_IOCTL_SUBMIT_IO:

		return nvme_submit_io(ns, argp);

	case NVME_IOCTL_IO64_CMD:

		return nvme_user_cmd64(ns->ctrl, ns, argp);

	default:

		if (!ns->ndev)

			return -ENOTTY;

		return nvme_nvm_ioctl(ns, cmd, argp);

	}

}



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;

	void __user *argp = (void __user *)arg;



	if (is_ctrl_ioctl(cmd))

		return nvme_ctrl_ioctl(ns->ctrl, cmd, argp);

	return nvme_ns_ioctl(ns, cmd, argp);

}



#ifdef CONFIG_NVME_MULTIPATH

static int nvme_ns_head_ctrl_ioctl(struct nvme_ns_head *head,

		unsigned int cmd, void __user *argp)

{

	struct nvme_ctrl *ctrl = nvme_find_get_live_ctrl(head->subsys);

	int ret;



	if (IS_ERR(ctrl))

		return PTR_ERR(ctrl);

	ret = nvme_ctrl_ioctl(ctrl, cmd, argp);

	nvme_put_ctrl(ctrl);

	return ret;

}



static int nvme_ns_head_ns_ioctl(struct nvme_ns_head *head,

		unsigned int cmd, void __user *argp)

{

	int srcu_idx = srcu_read_lock(&head->srcu);

	struct nvme_ns *ns = nvme_find_path(head);

	int ret = -EWOULDBLOCK;



	if (ns)

		ret = nvme_ns_ioctl(ns, cmd, argp);

	srcu_read_unlock(&head->srcu, srcu_idx);

	return ret;

}



int nvme_ns_head_ioctl(struct block_device *bdev, fmode_t mode,

		unsigned int cmd, unsigned long arg)

{

	struct nvme_ns_head *head = bdev->bd_disk->private_data;



	if (is_ctrl_ioctl(cmd))

		return nvme_ns_head_ctrl_ioctl(head, cmd, (void __user *)arg);

	return nvme_ns_head_ns_ioctl(head, cmd, (void __user *)arg);

}

#endif /* CONFIG_NVME_MULTIPATH */



static int nvme_dev_user_cmd(struct nvme_ctrl *ctrl, void __user *argp)

{

	struct nvme_ns *ns;

	int ret;



	down_read(&ctrl->namespaces_rwsem);

	if (list_empty(&ctrl->namespaces)) {

		ret = -ENOTTY;

		goto out_unlock;

	}



	ns = list_first_entry(&ctrl->namespaces, struct nvme_ns, list);

	if (ns != list_last_entry(&ctrl->namespaces, struct nvme_ns, list)) {

		dev_warn(ctrl->device,

			"NVME_IOCTL_IO_CMD not supported when multiple namespaces present!\n");

		ret = -EINVAL;

		goto out_unlock;

	}



	dev_warn(ctrl->device,

		"using deprecated NVME_IOCTL_IO_CMD ioctl on the char device!\n");

	kref_get(&ns->kref);

	up_read(&ctrl->namespaces_rwsem);



	ret = nvme_user_cmd(ctrl, ns, argp);

	nvme_put_ns(ns);

	return ret;



out_unlock:

	up_read(&ctrl->namespaces_rwsem);

	return ret;

}



long nvme_dev_ioctl(struct file *file, unsigned int cmd,

		unsigned long arg)

{

	struct nvme_ctrl *ctrl = file->private_data;

	void __user *argp = (void __user *)arg;



	switch (cmd) {

	case NVME_IOCTL_ADMIN_CMD:

		return nvme_user_cmd(ctrl, NULL, argp);

	case NVME_IOCTL_ADMIN64_CMD:

		return nvme_user_cmd64(ctrl, NULL, argp);

	case NVME_IOCTL_IO_CMD:

		return nvme_dev_user_cmd(ctrl, argp);

	case NVME_IOCTL_RESET:

		dev_warn(ctrl->device, "resetting controller\n");

		return nvme_reset_ctrl_sync(ctrl);

	case NVME_IOCTL_SUBSYS_RESET:

		return nvme_reset_subsystem(ctrl);

	case NVME_IOCTL_RESCAN:

		nvme_queue_scan(ctrl);

		return 0;

	default:

		return -ENOTTY;

	}

}

drivers/nvme/host/nvme.h

+9 −1

File changed.

Preview size limit exceeded, changes collapsed.