Commit df8129fb authored by Daniel Verkamp's avatar Daniel Verkamp
Browse files

nvme: move num_entries to transport-specific qpairs 



The spdk_nvme_qpair::num_entries value is never used in the common code,
so move it to the individual transport qpairs to make it clear that it
is a transport-specific implementation detail.

Change-Id: I5c8f0de4fcd808912ba6d248cf5cee816079fd32
Signed-off-by: default avatarDaniel Verkamp <daniel.verkamp@intel.com>
parent 7ac9a4ec

lib/nvme/nvme_internal.h

+0 −3
Original line number Diff line number Diff line
@@ -247,8 +247,6 @@ struct spdk_nvme_qpair { 


	uint16_t			id;



	uint16_t			num_entries;



	uint8_t				qprio;



	struct spdk_nvme_ctrlr		*ctrlr;
@@ -531,7 +529,6 @@ int nvme_ctrlr_submit_admin_request(struct spdk_nvme_ctrlr *ctrlr, 
int	nvme_ctrlr_get_cap(struct spdk_nvme_ctrlr *ctrlr, union spdk_nvme_cap_register *cap);

void	nvme_ctrlr_init_cap(struct spdk_nvme_ctrlr *ctrlr, const union spdk_nvme_cap_register *cap);

int	nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,

			uint16_t num_entries,

			struct spdk_nvme_ctrlr *ctrlr,

			enum spdk_nvme_qprio qprio);

void	nvme_qpair_enable(struct spdk_nvme_qpair *qpair);

lib/nvme/nvme_pcie.c

+21 −16
Original line number Diff line number Diff line
@@ -157,6 +157,8 @@ struct nvme_pcie_qpair { 
	/* Array of trackers indexed by command ID. */

	struct nvme_tracker *tr;



	uint16_t num_entries;



	uint16_t sq_tail;

	uint16_t cq_head;
@@ -568,11 +570,12 @@ nvme_pcie_ctrlr_construct_admin_qpair(struct spdk_nvme_ctrlr *ctrlr) 
		return -ENOMEM;

	}



	pqpair->num_entries = NVME_ADMIN_ENTRIES;



	ctrlr->adminq = &pqpair->qpair;



	rc = nvme_qpair_init(ctrlr->adminq,

			     0, /* qpair ID */

			     NVME_ADMIN_ENTRIES,

			     ctrlr,

			     SPDK_NVME_QPRIO_URGENT);

	if (rc != 0) {
@@ -747,8 +750,8 @@ nvme_pcie_ctrlr_enable(struct spdk_nvme_ctrlr *ctrlr) 


	aqa.raw = 0;

	/* acqs and asqs are 0-based. */

	aqa.bits.acqs = ctrlr->adminq->num_entries - 1;

	aqa.bits.asqs = ctrlr->adminq->num_entries - 1;

	aqa.bits.acqs = nvme_pcie_qpair(ctrlr->adminq)->num_entries - 1;

	aqa.bits.asqs = nvme_pcie_qpair(ctrlr->adminq)->num_entries - 1;



	if (nvme_pcie_ctrlr_set_aqa(pctrlr, &aqa)) {

		SPDK_ERRLOG("set_aqa() failed\n");
@@ -801,9 +804,9 @@ nvme_pcie_qpair_reset(struct spdk_nvme_qpair *qpair) 
	pqpair->phase = 1;



	memset(pqpair->cmd, 0,

	       qpair->num_entries * sizeof(struct spdk_nvme_cmd));

	       pqpair->num_entries * sizeof(struct spdk_nvme_cmd));

	memset(pqpair->cpl, 0,

	       qpair->num_entries * sizeof(struct spdk_nvme_cpl));

	       pqpair->num_entries * sizeof(struct spdk_nvme_cpl));



	return 0;

}
@@ -829,7 +832,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair) 
		 *  Note also that for a queue size of N, we can only have (N-1)

		 *  commands outstanding, hence the "-1" here.

		 */

		num_trackers = nvme_min(NVME_IO_TRACKERS, qpair->num_entries - 1);

		num_trackers = nvme_min(NVME_IO_TRACKERS, pqpair->num_entries - 1);

	}



	assert(num_trackers != 0);
@@ -838,7 +841,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair) 


	/* cmd and cpl rings must be aligned on 4KB boundaries. */

	if (ctrlr->opts.use_cmb_sqs) {

		if (nvme_pcie_ctrlr_alloc_cmb(ctrlr, qpair->num_entries * sizeof(struct spdk_nvme_cmd),

		if (nvme_pcie_ctrlr_alloc_cmb(ctrlr, pqpair->num_entries * sizeof(struct spdk_nvme_cmd),

					      0x1000, &offset) == 0) {

			pqpair->cmd = pctrlr->cmb_bar_virt_addr + offset;

			pqpair->cmd_bus_addr = pctrlr->cmb_bar_phys_addr + offset;
@@ -846,7 +849,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair) 
		}

	}

	if (pqpair->sq_in_cmb == false) {

		pqpair->cmd = spdk_zmalloc(qpair->num_entries * sizeof(struct spdk_nvme_cmd),

		pqpair->cmd = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cmd),

					   0x1000,

					   &pqpair->cmd_bus_addr);

		if (pqpair->cmd == NULL) {
@@ -855,7 +858,7 @@ nvme_pcie_qpair_construct(struct spdk_nvme_qpair *qpair) 
		}

	}



	pqpair->cpl = spdk_zmalloc(qpair->num_entries * sizeof(struct spdk_nvme_cpl),

	pqpair->cpl = spdk_zmalloc(pqpair->num_entries * sizeof(struct spdk_nvme_cpl),

				   0x1000,

				   &pqpair->cpl_bus_addr);

	if (pqpair->cpl == NULL) {
@@ -1014,7 +1017,7 @@ nvme_pcie_qpair_submit_tracker(struct spdk_nvme_qpair *qpair, struct nvme_tracke 
	/* Copy the command from the tracker to the submission queue. */

	nvme_pcie_copy_command(&pqpair->cmd[pqpair->sq_tail], &req->cmd);



	if (++pqpair->sq_tail == qpair->num_entries) {

	if (++pqpair->sq_tail == pqpair->num_entries) {

		pqpair->sq_tail = 0;

	}
@@ -1258,7 +1261,7 @@ nvme_pcie_ctrlr_cmd_create_io_cq(struct spdk_nvme_ctrlr *ctrlr, 
	 * TODO: create a create io completion queue command data

	 *  structure.

	 */

	cmd->cdw10 = ((io_que->num_entries - 1) << 16) | io_que->id;

	cmd->cdw10 = ((pqpair->num_entries - 1) << 16) | io_que->id;

	/*

	 * 0x2 = interrupts enabled

	 * 0x1 = physically contiguous
@@ -1289,7 +1292,7 @@ nvme_pcie_ctrlr_cmd_create_io_sq(struct spdk_nvme_ctrlr *ctrlr, 
	 * TODO: create a create io submission queue command data

	 *  structure.

	 */

	cmd->cdw10 = ((io_que->num_entries - 1) << 16) | io_que->id;

	cmd->cdw10 = ((pqpair->num_entries - 1) << 16) | io_que->id;

	/* 0x1 = physically contiguous */

	cmd->cdw11 = (io_que->id << 16) | (io_que->qprio << 1) | 0x1;

	cmd->dptr.prp.prp1 = pqpair->cmd_bus_addr;
@@ -1399,9 +1402,11 @@ nvme_pcie_ctrlr_create_io_qpair(struct spdk_nvme_ctrlr *ctrlr, uint16_t qid, 
		return NULL;

	}



	pqpair->num_entries = ctrlr->opts.io_queue_size;



	qpair = &pqpair->qpair;



	rc = nvme_qpair_init(qpair, qid, ctrlr->opts.io_queue_size, ctrlr, qprio);

	rc = nvme_qpair_init(qpair, qid, ctrlr, qprio);

	if (rc != 0) {

		nvme_pcie_qpair_destroy(qpair);

		return NULL;
@@ -1857,14 +1862,14 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_ 
		nvme_robust_mutex_lock(&ctrlr->ctrlr_lock);

	}



	if (max_completions == 0 || (max_completions > (qpair->num_entries - 1U))) {

	if (max_completions == 0 || (max_completions > (pqpair->num_entries - 1U))) {



		/*

		 * max_completions == 0 means unlimited, but complete at most one

		 * queue depth batch of I/O at a time so that the completion

		 * queue doorbells don't wrap around.

		 */

		max_completions = qpair->num_entries - 1;

		max_completions = pqpair->num_entries - 1;

	}



	while (1) {
@@ -1883,7 +1888,7 @@ nvme_pcie_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_ 
			assert(0);

		}



		if (++pqpair->cq_head == qpair->num_entries) {

		if (++pqpair->cq_head == pqpair->num_entries) {

			pqpair->cq_head = 0;

			pqpair->phase = !pqpair->phase;

		}

lib/nvme/nvme_qpair.c

+0 −4
Original line number Diff line number Diff line
@@ -341,14 +341,10 @@ spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_ 


int

nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,

		uint16_t num_entries,

		struct spdk_nvme_ctrlr *ctrlr,

		enum spdk_nvme_qprio qprio)

{

	assert(num_entries != 0);



	qpair->id = id;

	qpair->num_entries = num_entries;

	qpair->qprio = qprio;



	qpair->ctrlr = ctrlr;

lib/nvme/nvme_rdma.c

+27 −23
Original line number Diff line number Diff line
@@ -87,7 +87,9 @@ struct nvme_rdma_qpair { 


	struct	spdk_nvme_rdma_req		*rdma_reqs;



	/* Parallel arrays of response buffers + response SGLs of size qpair.num_entries */

	uint16_t				num_entries;



	/* Parallel arrays of response buffers + response SGLs of size num_entries */

	struct ibv_sge				*rsp_sgls;

	struct spdk_nvme_cpl			*rsps;
@@ -97,7 +99,7 @@ struct nvme_rdma_qpair { 
	struct ibv_mr				*rsp_mr;



	/*

	 * Array of qpair.num_entries NVMe commands registered as RDMA message buffers.

	 * Array of num_entries NVMe commands registered as RDMA message buffers.

	 * Indexed by rdma_req->id.

	 */

	struct spdk_nvme_cmd			*cmds;
@@ -203,8 +205,8 @@ nvme_rdma_qpair_init(struct nvme_rdma_qpair *rqpair) 


	memset(&attr, 0, sizeof(struct ibv_qp_init_attr));

	attr.qp_type		= IBV_QPT_RC;

	attr.cap.max_send_wr	= rqpair->qpair.num_entries; /* SEND operations */

	attr.cap.max_recv_wr	= rqpair->qpair.num_entries; /* RECV operations */

	attr.cap.max_send_wr	= rqpair->num_entries; /* SEND operations */

	attr.cap.max_recv_wr	= rqpair->num_entries; /* RECV operations */

	attr.cap.max_send_sge	= NVME_RDMA_DEFAULT_TX_SGE;

	attr.cap.max_recv_sge	= NVME_RDMA_DEFAULT_RX_SGE;
@@ -330,33 +332,33 @@ nvme_rdma_alloc_rsps(struct nvme_rdma_qpair *rqpair) 
	rqpair->rsps = NULL;

	rqpair->rsp_recv_wrs = NULL;



	rqpair->rsp_sgls = calloc(rqpair->qpair.num_entries, sizeof(*rqpair->rsp_sgls));

	rqpair->rsp_sgls = calloc(rqpair->num_entries, sizeof(*rqpair->rsp_sgls));

	if (!rqpair->rsp_sgls) {

		SPDK_ERRLOG("Failed to allocate rsp_sgls\n");

		goto fail;

	}



	rqpair->rsp_recv_wrs = calloc(rqpair->qpair.num_entries,

	rqpair->rsp_recv_wrs = calloc(rqpair->num_entries,

				      sizeof(*rqpair->rsp_recv_wrs));

	if (!rqpair->rsp_recv_wrs) {

		SPDK_ERRLOG("Failed to allocate rsp_recv_wrs\n");

		goto fail;

	}



	rqpair->rsps = calloc(rqpair->qpair.num_entries, sizeof(*rqpair->rsps));

	rqpair->rsps = calloc(rqpair->num_entries, sizeof(*rqpair->rsps));

	if (!rqpair->rsps) {

		SPDK_ERRLOG("can not allocate rdma rsps\n");

		goto fail;

	}



	rqpair->rsp_mr = rdma_reg_msgs(rqpair->cm_id, rqpair->rsps,

				       rqpair->qpair.num_entries * sizeof(*rqpair->rsps));

				       rqpair->num_entries * sizeof(*rqpair->rsps));

	if (rqpair->rsp_mr == NULL) {

		SPDK_ERRLOG("Unable to register rsp_mr\n");

		goto fail;

	}



	for (i = 0; i < rqpair->qpair.num_entries; i++) {

	for (i = 0; i < rqpair->num_entries; i++) {

		struct ibv_sge *rsp_sgl = &rqpair->rsp_sgls[i];



		rsp_sgl->addr = (uint64_t)&rqpair->rsps[i];
@@ -386,7 +388,7 @@ nvme_rdma_free_reqs(struct nvme_rdma_qpair *rqpair) 
		return;

	}



	for (i = 0; i < rqpair->qpair.num_entries; i++) {

	for (i = 0; i < rqpair->num_entries; i++) {

		rdma_req = &rqpair->rdma_reqs[i];



		if (rdma_req->bb_mr && ibv_dereg_mr(rdma_req->bb_mr)) {
@@ -415,27 +417,27 @@ nvme_rdma_alloc_reqs(struct nvme_rdma_qpair *rqpair) 
{

	int i;



	rqpair->rdma_reqs = calloc(rqpair->qpair.num_entries, sizeof(struct spdk_nvme_rdma_req));

	rqpair->rdma_reqs = calloc(rqpair->num_entries, sizeof(struct spdk_nvme_rdma_req));

	if (rqpair->rdma_reqs == NULL) {

		SPDK_ERRLOG("Failed to allocate rdma_reqs\n");

		goto fail;

	}



	rqpair->cmds = calloc(rqpair->qpair.num_entries, sizeof(*rqpair->cmds));

	rqpair->cmds = calloc(rqpair->num_entries, sizeof(*rqpair->cmds));

	if (!rqpair->cmds) {

		SPDK_ERRLOG("Failed to allocate RDMA cmds\n");

		goto fail;

	}



	rqpair->cmd_mr = rdma_reg_msgs(rqpair->cm_id, rqpair->cmds,

				       rqpair->qpair.num_entries * sizeof(*rqpair->cmds));

				       rqpair->num_entries * sizeof(*rqpair->cmds));

	if (!rqpair->cmd_mr) {

		SPDK_ERRLOG("Unable to register cmd_mr\n");

		goto fail;

	}



	STAILQ_INIT(&rqpair->free_reqs);

	for (i = 0; i < rqpair->qpair.num_entries; i++) {

	for (i = 0; i < rqpair->num_entries; i++) {

		struct spdk_nvme_rdma_req	*rdma_req;

		struct spdk_nvme_cmd		*cmd;
@@ -483,7 +485,7 @@ nvme_rdma_recv(struct nvme_rdma_qpair *rqpair, uint64_t rsp_idx) 
	struct spdk_nvme_cpl *rsp;

	struct nvme_request *req;



	assert(rsp_idx < rqpair->qpair.num_entries);

	assert(rsp_idx < rqpair->num_entries);

	rsp = &rqpair->rsps[rsp_idx];

	rdma_req = &rqpair->rdma_reqs[rsp->cid];
@@ -560,11 +562,11 @@ nvme_rdma_connect(struct nvme_rdma_qpair *rqpair) 
		return ret;

	}



	param.responder_resources = nvme_min(rqpair->qpair.num_entries, attr.max_qp_rd_atom);

	param.responder_resources = nvme_min(rqpair->num_entries, attr.max_qp_rd_atom);



	request_data.qid = rqpair->qpair.id;

	request_data.hrqsize = rqpair->qpair.num_entries;

	request_data.hsqsize = rqpair->qpair.num_entries - 1;

	request_data.hrqsize = rqpair->num_entries;

	request_data.hsqsize = rqpair->num_entries - 1;



	param.private_data = &request_data;

	param.private_data_len = sizeof(request_data);
@@ -588,9 +590,9 @@ nvme_rdma_connect(struct nvme_rdma_qpair *rqpair) 
	}



	SPDK_TRACELOG(SPDK_TRACE_NVME, "Requested queue depth %d. Actually got queue depth %d.\n",

		      rqpair->qpair.num_entries, accept_data->crqsize);

		      rqpair->num_entries, accept_data->crqsize);



	rqpair->qpair.num_entries  = nvme_min(rqpair->qpair.num_entries , accept_data->crqsize);

	rqpair->num_entries  = nvme_min(rqpair->num_entries , accept_data->crqsize);



	rdma_ack_cm_event(event);
@@ -656,7 +658,7 @@ nvme_rdma_qpair_fabric_connect(struct nvme_rdma_qpair *rqpair) 
	cmd.opcode = SPDK_NVME_OPC_FABRIC;

	cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT;

	cmd.qid = rqpair->qpair.id;

	cmd.sqsize = rqpair->qpair.num_entries - 1;

	cmd.sqsize = rqpair->num_entries - 1;

	cmd.kato = ctrlr->opts.keep_alive_timeout_ms;



	if (nvme_qpair_is_admin_queue(&rqpair->qpair)) {
@@ -914,9 +916,11 @@ nvme_rdma_ctrlr_create_qpair(struct spdk_nvme_ctrlr *ctrlr, 
		return NULL;

	}



	rqpair->num_entries = qsize;



	qpair = &rqpair->qpair;



	rc = nvme_qpair_init(qpair, qid, qsize, ctrlr, qprio);

	rc = nvme_qpair_init(qpair, qid, ctrlr, qprio);

	if (rc != 0) {

		return NULL;

	}
@@ -1320,7 +1324,7 @@ nvme_rdma_qpair_process_completions(struct spdk_nvme_qpair *qpair, 
	uint32_t io_completed = 0;



	rqpair = nvme_rdma_qpair(qpair);

	size = qpair->num_entries - 1U;

	size = rqpair->num_entries - 1U;

	if (!max_completions || max_completions > size) {

		max_completions = size;

	}

test/lib/nvme/unit/nvme_ctrlr_c/nvme_ctrlr_ut.c

+0 −2
Original line number Diff line number Diff line
@@ -165,12 +165,10 @@ nvme_transport_qpair_reset(struct spdk_nvme_qpair *qpair) 
}



int nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,

		    uint16_t num_entries,

		    struct spdk_nvme_ctrlr *ctrlr,

		    enum spdk_nvme_qprio qprio)

{

	qpair->id = id;

	qpair->num_entries = num_entries;

	qpair->qprio = qprio;

	qpair->ctrlr = ctrlr;