Commit d49187e9 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

nvme: introduce struct nvme_request 



This adds a shared per-request structure for all NVMe I/O.  This structure
is embedded as the first member in all NVMe transport drivers request
private data and allows to implement common functionality between the
drivers.

The first use is to replace the current abuse of the SCSI command
passthrough fields in struct request for the NVMe command passthrough,
but it will grow a field more fields to allow implementing things
like common abort handlers in the future.

The passthrough commands are handled by having a pointer to the SQE
(struct nvme_command) in struct nvme_request, and the union of the
possible result fields, which had to be turned from an anonymous
into a named union for that purpose.  This avoids having to pass
a reference to a full CQE around and thus makes checking the result
a lot more lightweight.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarKeith Busch <keith.busch@intel.com>
Signed-off-by: default avatarJens Axboe <axboe@fb.com>
parent 41c9499b

drivers/nvme/host/core.c

+13 −15
Original line number Diff line number Diff line
@@ -221,8 +221,7 @@ struct request *nvme_alloc_request(struct request_queue *q, 


	req->cmd_type = REQ_TYPE_DRV_PRIV;

	req->cmd_flags |= REQ_FAILFAST_DRIVER;

	req->cmd = (unsigned char *)cmd;

	req->cmd_len = sizeof(struct nvme_command);

	nvme_req(req)->cmd = cmd;



	return req;

}
@@ -321,7 +320,7 @@ int nvme_setup_cmd(struct nvme_ns *ns, struct request *req, 
	int ret = 0;



	if (req->cmd_type == REQ_TYPE_DRV_PRIV)

		memcpy(cmd, req->cmd, sizeof(*cmd));

		memcpy(cmd, nvme_req(req)->cmd, sizeof(*cmd));

	else if (req_op(req) == REQ_OP_FLUSH)

		nvme_setup_flush(ns, cmd);

	else if (req_op(req) == REQ_OP_DISCARD)
@@ -338,7 +337,7 @@ EXPORT_SYMBOL_GPL(nvme_setup_cmd); 
 * if the result is positive, it's an NVM Express status code

 */

int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,

		struct nvme_completion *cqe, void *buffer, unsigned bufflen,

		union nvme_result *result, void *buffer, unsigned bufflen,

		unsigned timeout, int qid, int at_head, int flags)

{

	struct request *req;
@@ -349,7 +348,6 @@ int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, 
		return PTR_ERR(req);



	req->timeout = timeout ? timeout : ADMIN_TIMEOUT;

	req->special = cqe;



	if (buffer && bufflen) {

		ret = blk_rq_map_kern(q, req, buffer, bufflen, GFP_KERNEL);
@@ -358,6 +356,8 @@ int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd, 
	}



	blk_execute_rq(req->q, NULL, req, at_head);

	if (result)

		*result = nvme_req(req)->result;

	ret = req->errors;

 out:

	blk_mq_free_request(req);
@@ -379,7 +379,6 @@ int __nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd, 
		u32 *result, unsigned timeout)

{

	bool write = nvme_is_write(cmd);

	struct nvme_completion cqe;

	struct nvme_ns *ns = q->queuedata;

	struct gendisk *disk = ns ? ns->disk : NULL;

	struct request *req;
@@ -392,7 +391,6 @@ int __nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd, 
		return PTR_ERR(req);



	req->timeout = timeout ? timeout : ADMIN_TIMEOUT;

	req->special = &cqe;



	if (ubuffer && bufflen) {

		ret = blk_rq_map_user(q, req, NULL, ubuffer, bufflen,
@@ -447,7 +445,7 @@ int __nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd, 
	blk_execute_rq(req->q, disk, req, 0);

	ret = req->errors;

	if (result)

		*result = le32_to_cpu(cqe.result);

		*result = le32_to_cpu(nvme_req(req)->result.u32);

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

		if (copy_to_user(meta_buffer, meta, meta_len))

			ret = -EFAULT;
@@ -596,7 +594,7 @@ int nvme_get_features(struct nvme_ctrl *dev, unsigned fid, unsigned nsid, 
		      void *buffer, size_t buflen, u32 *result)

{

	struct nvme_command c;

	struct nvme_completion cqe;

	union nvme_result res;

	int ret;



	memset(&c, 0, sizeof(c));
@@ -604,10 +602,10 @@ int nvme_get_features(struct nvme_ctrl *dev, unsigned fid, unsigned nsid, 
	c.features.nsid = cpu_to_le32(nsid);

	c.features.fid = cpu_to_le32(fid);



	ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &cqe, buffer, buflen, 0,

	ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &res, buffer, buflen, 0,

			NVME_QID_ANY, 0, 0);

	if (ret >= 0 && result)

		*result = le32_to_cpu(cqe.result);

		*result = le32_to_cpu(res.u32);

	return ret;

}
@@ -615,7 +613,7 @@ int nvme_set_features(struct nvme_ctrl *dev, unsigned fid, unsigned dword11, 
		      void *buffer, size_t buflen, u32 *result)

{

	struct nvme_command c;

	struct nvme_completion cqe;

	union nvme_result res;

	int ret;



	memset(&c, 0, sizeof(c));
@@ -623,10 +621,10 @@ int nvme_set_features(struct nvme_ctrl *dev, unsigned fid, unsigned dword11, 
	c.features.fid = cpu_to_le32(fid);

	c.features.dword11 = cpu_to_le32(dword11);



	ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &cqe,

	ret = __nvme_submit_sync_cmd(dev->admin_q, &c, &res,

			buffer, buflen, 0, NVME_QID_ANY, 0, 0);

	if (ret >= 0 && result)

		*result = le32_to_cpu(cqe.result);

		*result = le32_to_cpu(res.u32);

	return ret;

}
@@ -1901,7 +1899,7 @@ void nvme_complete_async_event(struct nvme_ctrl *ctrl, 
		struct nvme_completion *cqe)

{

	u16 status = le16_to_cpu(cqe->status) >> 1;

	u32 result = le32_to_cpu(cqe->result);

	u32 result = le32_to_cpu(cqe->result.u32);



	if (status == NVME_SC_SUCCESS || status == NVME_SC_ABORT_REQ) {

		++ctrl->event_limit;

drivers/nvme/host/fabrics.c

+13 −13
Original line number Diff line number Diff line
@@ -161,7 +161,7 @@ EXPORT_SYMBOL_GPL(nvmf_get_subsysnqn); 
int nvmf_reg_read32(struct nvme_ctrl *ctrl, u32 off, u32 *val)

{

	struct nvme_command cmd;

	struct nvme_completion cqe;

	union nvme_result res;

	int ret;



	memset(&cmd, 0, sizeof(cmd));
@@ -169,11 +169,11 @@ int nvmf_reg_read32(struct nvme_ctrl *ctrl, u32 off, u32 *val) 
	cmd.prop_get.fctype = nvme_fabrics_type_property_get;

	cmd.prop_get.offset = cpu_to_le32(off);



	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &cqe, NULL, 0, 0,

	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res, NULL, 0, 0,

			NVME_QID_ANY, 0, 0);



	if (ret >= 0)

		*val = le64_to_cpu(cqe.result64);

		*val = le64_to_cpu(res.u64);

	if (unlikely(ret != 0))

		dev_err(ctrl->device,

			"Property Get error: %d, offset %#x\n",
@@ -207,7 +207,7 @@ EXPORT_SYMBOL_GPL(nvmf_reg_read32); 
int nvmf_reg_read64(struct nvme_ctrl *ctrl, u32 off, u64 *val)

{

	struct nvme_command cmd;

	struct nvme_completion cqe;

	union nvme_result res;

	int ret;



	memset(&cmd, 0, sizeof(cmd));
@@ -216,11 +216,11 @@ int nvmf_reg_read64(struct nvme_ctrl *ctrl, u32 off, u64 *val) 
	cmd.prop_get.attrib = 1;

	cmd.prop_get.offset = cpu_to_le32(off);



	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &cqe, NULL, 0, 0,

	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res, NULL, 0, 0,

			NVME_QID_ANY, 0, 0);



	if (ret >= 0)

		*val = le64_to_cpu(cqe.result64);

		*val = le64_to_cpu(res.u64);

	if (unlikely(ret != 0))

		dev_err(ctrl->device,

			"Property Get error: %d, offset %#x\n",
@@ -368,7 +368,7 @@ static void nvmf_log_connect_error(struct nvme_ctrl *ctrl, 
int nvmf_connect_admin_queue(struct nvme_ctrl *ctrl)

{

	struct nvme_command cmd;

	struct nvme_completion cqe;

	union nvme_result res;

	struct nvmf_connect_data *data;

	int ret;
@@ -400,16 +400,16 @@ int nvmf_connect_admin_queue(struct nvme_ctrl *ctrl) 
	strncpy(data->subsysnqn, ctrl->opts->subsysnqn, NVMF_NQN_SIZE);

	strncpy(data->hostnqn, ctrl->opts->host->nqn, NVMF_NQN_SIZE);



	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &cqe,

	ret = __nvme_submit_sync_cmd(ctrl->admin_q, &cmd, &res,

			data, sizeof(*data), 0, NVME_QID_ANY, 1,

			BLK_MQ_REQ_RESERVED | BLK_MQ_REQ_NOWAIT);

	if (ret) {

		nvmf_log_connect_error(ctrl, ret, le32_to_cpu(cqe.result),

		nvmf_log_connect_error(ctrl, ret, le32_to_cpu(res.u32),

				       &cmd, data);

		goto out_free_data;

	}



	ctrl->cntlid = le16_to_cpu(cqe.result16);

	ctrl->cntlid = le16_to_cpu(res.u16);



out_free_data:

	kfree(data);
@@ -441,7 +441,7 @@ int nvmf_connect_io_queue(struct nvme_ctrl *ctrl, u16 qid) 
{

	struct nvme_command cmd;

	struct nvmf_connect_data *data;

	struct nvme_completion cqe;

	union nvme_result res;

	int ret;



	memset(&cmd, 0, sizeof(cmd));
@@ -459,11 +459,11 @@ int nvmf_connect_io_queue(struct nvme_ctrl *ctrl, u16 qid) 
	strncpy(data->subsysnqn, ctrl->opts->subsysnqn, NVMF_NQN_SIZE);

	strncpy(data->hostnqn, ctrl->opts->host->nqn, NVMF_NQN_SIZE);



	ret = __nvme_submit_sync_cmd(ctrl->connect_q, &cmd, &cqe,

	ret = __nvme_submit_sync_cmd(ctrl->connect_q, &cmd, &res,

			data, sizeof(*data), 0, qid, 1,

			BLK_MQ_REQ_RESERVED | BLK_MQ_REQ_NOWAIT);

	if (ret) {

		nvmf_log_connect_error(ctrl, ret, le32_to_cpu(cqe.result),

		nvmf_log_connect_error(ctrl, ret, le32_to_cpu(res.u32),

				       &cmd, data);

	}

	kfree(data);

drivers/nvme/host/lightnvm.c

+7 −24
Original line number Diff line number Diff line
@@ -146,14 +146,6 @@ struct nvme_nvm_command { 
	};

};



struct nvme_nvm_completion {

	__le64	result;		/* Used by LightNVM to return ppa completions */

	__le16	sq_head;	/* how much of this queue may be reclaimed */

	__le16	sq_id;		/* submission queue that generated this entry */

	__u16	command_id;	/* of the command which completed */

	__le16	status;		/* did the command fail, and if so, why? */

};



#define NVME_NVM_LP_MLC_PAIRS 886

struct nvme_nvm_lp_mlc {

	__le16			num_pairs;
@@ -481,11 +473,8 @@ static inline void nvme_nvm_rqtocmd(struct request *rq, struct nvm_rq *rqd, 
static void nvme_nvm_end_io(struct request *rq, int error)

{

	struct nvm_rq *rqd = rq->end_io_data;

	struct nvme_nvm_completion *cqe = rq->special;



	if (cqe)

		rqd->ppa_status = le64_to_cpu(cqe->result);



	rqd->ppa_status = nvme_req(rq)->result.u64;

	nvm_end_io(rqd, error);



	kfree(rq->cmd);
@@ -500,20 +489,18 @@ static int nvme_nvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd) 
	struct bio *bio = rqd->bio;

	struct nvme_nvm_command *cmd;



	rq = blk_mq_alloc_request(q, bio_data_dir(bio), 0);

	if (IS_ERR(rq))

	cmd = kzalloc(sizeof(struct nvme_nvm_command), GFP_KERNEL);

	if (!cmd)

		return -ENOMEM;



	cmd = kzalloc(sizeof(struct nvme_nvm_command) +

				sizeof(struct nvme_nvm_completion), GFP_KERNEL);

	if (!cmd) {

		blk_mq_free_request(rq);

	rq = nvme_alloc_request(q, (struct nvme_command *)cmd, 0, NVME_QID_ANY);

	if (IS_ERR(rq)) {

		kfree(cmd);

		return -ENOMEM;

	}

	rq->cmd_flags &= ~REQ_FAILFAST_DRIVER;



	rq->cmd_type = REQ_TYPE_DRV_PRIV;

	rq->ioprio = bio_prio(bio);



	if (bio_has_data(bio))

		rq->nr_phys_segments = bio_phys_segments(q, bio);
@@ -522,10 +509,6 @@ static int nvme_nvm_submit_io(struct nvm_dev *dev, struct nvm_rq *rqd) 


	nvme_nvm_rqtocmd(rq, rqd, ns, cmd);



	rq->cmd = (unsigned char *)cmd;

	rq->cmd_len = sizeof(struct nvme_nvm_command);

	rq->special = cmd + 1;



	rq->end_io_data = rqd;



	blk_execute_rq_nowait(q, NULL, rq, 0, nvme_nvm_end_io);

drivers/nvme/host/nvme.h

+15 −1
Original line number Diff line number Diff line
@@ -79,6 +79,20 @@ enum nvme_quirks { 
	NVME_QUIRK_DELAY_BEFORE_CHK_RDY		= (1 << 3),

};



/*

 * Common request structure for NVMe passthrough.  All drivers must have

 * this structure as the first member of their request-private data.

 */

struct nvme_request {

	struct nvme_command	*cmd;

	union nvme_result	result;

};



static inline struct nvme_request *nvme_req(struct request *req)

{

	return blk_mq_rq_to_pdu(req);

}



/* The below value is the specific amount of delay needed before checking

 * readiness in case of the PCI_DEVICE(0x1c58, 0x0003), which needs the

 * NVME_QUIRK_DELAY_BEFORE_CHK_RDY quirk enabled. The value (in ms) was
@@ -278,7 +292,7 @@ int nvme_setup_cmd(struct nvme_ns *ns, struct request *req, 
int nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,

		void *buf, unsigned bufflen);

int __nvme_submit_sync_cmd(struct request_queue *q, struct nvme_command *cmd,

		struct nvme_completion *cqe, void *buffer, unsigned bufflen,

		union nvme_result *result, void *buffer, unsigned bufflen,

		unsigned timeout, int qid, int at_head, int flags);

int nvme_submit_user_cmd(struct request_queue *q, struct nvme_command *cmd,

		void __user *ubuffer, unsigned bufflen, u32 *result,

drivers/nvme/host/pci.c

+2 −2
Original line number Diff line number Diff line
@@ -140,6 +140,7 @@ struct nvme_queue { 
 * allocated to store the PRP list.

 */

struct nvme_iod {

	struct nvme_request req;

	struct nvme_queue *nvmeq;

	int aborted;

	int npages;		/* In the PRP list. 0 means small pool in use */
@@ -707,8 +708,7 @@ static void __nvme_process_cq(struct nvme_queue *nvmeq, unsigned int *tag) 
		}



		req = blk_mq_tag_to_rq(*nvmeq->tags, cqe.command_id);

		if (req->cmd_type == REQ_TYPE_DRV_PRIV && req->special)

			memcpy(req->special, &cqe, sizeof(cqe));

		nvme_req(req)->result = cqe.result;

		blk_mq_complete_request(req, le16_to_cpu(cqe.status) >> 1);



	}

CRA Git | Maintained and supported by SUSTech CRA and CCSE