Commit 8e808490 authored by John Barnard's avatar John Barnard Committed by Jim Harris
Browse files

nvmf: Move target opts to transport opts (part 1) 



  - Move most of the target opts from nvmf_tgt to nvmf_transport.
  - Update transport create functions to pass in transport opts.
  - When transport opts are NULL in transport create function, use
    target opts. (for backward compatiblity)
  - Part 1 of 2 patches. Part 2 (to follow after part 1 accepted)
    will allow independent creation of transport with specific opts
    while maintaining backward compatibility with current apps and
    rpc configuration that still use the add listener method to
    create a transport.

Change-Id: I0e27447c4a98e0b6a6c590541404b4e4be879b47
Signed-off-by: default avatarJohn Barnard <john.barnard@broadcom.com>
Reviewed-on: https://review.gerrithub.io/423329


Chandler-Test-Pool: SPDK Automated Test System <sys_sgsw@intel.com>
Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
parent d393983d

include/spdk/nvmf.h

+11 −0
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ struct spdk_nvmf_host; 
struct spdk_nvmf_listener;

struct spdk_nvmf_poll_group;

struct spdk_json_write_ctx;

struct spdk_nvmf_transport;



struct spdk_nvmf_tgt_opts {

	uint16_t max_queue_depth;
@@ -70,6 +71,16 @@ struct spdk_nvmf_tgt_opts { 
	uint32_t max_subsystems;

	uint32_t io_unit_size;

};



struct spdk_nvmf_transport_opts {

	uint16_t max_queue_depth;

	uint16_t max_qpairs_per_ctrlr;

	uint32_t in_capsule_data_size;

	uint32_t max_io_size;

	uint32_t io_unit_size;

	uint32_t max_aq_depth;

};



/**

 * Initialize the default value of opts.

 *

lib/nvmf/ctrlr.c

+16 −14
Original line number Diff line number Diff line
@@ -152,9 +152,7 @@ spdk_nvmf_ctrlr_create(struct spdk_nvmf_subsystem *subsystem, 
		       struct spdk_nvmf_fabric_connect_data *connect_data)

{

	struct spdk_nvmf_ctrlr	*ctrlr;

	struct spdk_nvmf_tgt	*tgt;



	tgt = subsystem->tgt;

	struct spdk_nvmf_transport *transport;



	ctrlr = calloc(1, sizeof(*ctrlr));

	if (ctrlr == NULL) {
@@ -166,7 +164,8 @@ spdk_nvmf_ctrlr_create(struct spdk_nvmf_subsystem *subsystem, 
	ctrlr->subsys = subsystem;

	ctrlr->thread = req->qpair->group->thread;



	ctrlr->qpair_mask = spdk_bit_array_create(tgt->opts.max_qpairs_per_ctrlr);

	transport = req->qpair->transport;

	ctrlr->qpair_mask = spdk_bit_array_create(transport->opts.max_qpairs_per_ctrlr);

	if (!ctrlr->qpair_mask) {

		SPDK_ERRLOG("Failed to allocate controller qpair mask\n");

		free(ctrlr);
@@ -178,14 +177,17 @@ spdk_nvmf_ctrlr_create(struct spdk_nvmf_subsystem *subsystem, 
	ctrlr->feat.volatile_write_cache.bits.wce = 1;



	/* Subtract 1 for admin queue, 1 for 0's based */

	ctrlr->feat.number_of_queues.bits.ncqr = tgt->opts.max_qpairs_per_ctrlr - 1 - 1;

	ctrlr->feat.number_of_queues.bits.nsqr = tgt->opts.max_qpairs_per_ctrlr - 1 - 1;

	ctrlr->feat.number_of_queues.bits.ncqr = transport->opts.max_qpairs_per_ctrlr - 1 -

			1;

	ctrlr->feat.number_of_queues.bits.nsqr = transport->opts.max_qpairs_per_ctrlr - 1 -

			1;



	memcpy(ctrlr->hostid, connect_data->hostid, sizeof(ctrlr->hostid));



	ctrlr->vcprop.cap.raw = 0;

	ctrlr->vcprop.cap.bits.cqr = 1; /* NVMe-oF specification required */

	ctrlr->vcprop.cap.bits.mqes = tgt->opts.max_queue_depth - 1; /* max queue depth */

	ctrlr->vcprop.cap.bits.mqes = transport->opts.max_queue_depth -

				      1; /* max queue depth */

	ctrlr->vcprop.cap.bits.ams = 0; /* optional arb mechanisms */

	ctrlr->vcprop.cap.bits.to = 1; /* ready timeout - 500 msec units */

	ctrlr->vcprop.cap.bits.dstrd = 0; /* fixed to 0 for NVMe-oF */
@@ -376,9 +378,9 @@ spdk_nvmf_ctrlr_connect(struct spdk_nvmf_request *req) 
	 * SQSIZE is a 0-based value, so it must be at least 1 (minimum queue depth is 2) and

	 *  strictly less than max_queue_depth.

	 */

	if (cmd->sqsize == 0 || cmd->sqsize >= tgt->opts.max_queue_depth) {

	if (cmd->sqsize == 0 || cmd->sqsize >= qpair->transport->opts.max_queue_depth) {

		SPDK_ERRLOG("Invalid SQSIZE %u (min 1, max %u)\n",

			    cmd->sqsize, tgt->opts.max_queue_depth - 1);

			    cmd->sqsize, qpair->transport->opts.max_queue_depth - 1);

		SPDK_NVMF_INVALID_CONNECT_CMD(rsp, sqsize);

		return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE;

	}
@@ -1151,19 +1153,19 @@ static int 
spdk_nvmf_ctrlr_identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_ctrlr_data *cdata)

{

	struct spdk_nvmf_subsystem *subsystem = ctrlr->subsys;

	struct spdk_nvmf_tgt *tgt = subsystem->tgt;

	struct spdk_nvmf_transport *transport = ctrlr->admin_qpair->transport;



	/*

	 * Common fields for discovery and NVM subsystems

	 */

	spdk_strcpy_pad(cdata->fr, FW_VERSION, sizeof(cdata->fr), ' ');

	assert((tgt->opts.max_io_size % 4096) == 0);

	cdata->mdts = spdk_u32log2(tgt->opts.max_io_size / 4096);

	assert((transport->opts.max_io_size % 4096) == 0);

	cdata->mdts = spdk_u32log2(transport->opts.max_io_size / 4096);

	cdata->cntlid = ctrlr->cntlid;

	cdata->ver = ctrlr->vcprop.vs;

	cdata->lpa.edlp = 1;

	cdata->elpe = 127;

	cdata->maxcmd = tgt->opts.max_queue_depth;

	cdata->maxcmd = transport->opts.max_queue_depth;

	cdata->sgls.supported = 1;

	cdata->sgls.keyed_sgl = 1;

	cdata->sgls.sgl_offset = 1;
@@ -1206,7 +1208,7 @@ spdk_nvmf_ctrlr_identify_ctrlr(struct spdk_nvmf_ctrlr *ctrlr, struct spdk_nvme_c 
		cdata->nvmf_specific.msdbd = 1; /* target supports single SGL in capsule */



		/* TODO: this should be set by the transport */

		cdata->nvmf_specific.ioccsz += tgt->opts.in_capsule_data_size / 16;

		cdata->nvmf_specific.ioccsz += transport->opts.in_capsule_data_size / 16;



		cdata->oncs.dsm = spdk_nvmf_ctrlr_dsm_supported(ctrlr);

		cdata->oncs.write_zeroes = spdk_nvmf_ctrlr_write_zeroes_supported(ctrlr);

lib/nvmf/ctrlr_discovery.c

+1 −1
Original line number Diff line number Diff line
@@ -96,7 +96,7 @@ nvmf_update_discovery_log(struct spdk_nvmf_tgt *tgt) 
			memset(entry, 0, sizeof(*entry));

			entry->portid = numrec;

			entry->cntlid = 0xffff;

			entry->asqsz = tgt->opts.max_queue_depth;

			entry->asqsz = listener->transport->opts.max_aq_depth;

			entry->subtype = subsystem->subtype;

			snprintf(entry->subnqn, sizeof(entry->subnqn), "%s", subsystem->subnqn);

lib/nvmf/nvmf.c

+1 −17
Original line number Diff line number Diff line
@@ -234,14 +234,6 @@ spdk_nvmf_tgt_create(struct spdk_nvmf_tgt_opts *opts) 
		tgt->opts = *opts;

	}



	if ((tgt->opts.max_io_size % tgt->opts.io_unit_size != 0) ||

	    (tgt->opts.max_io_size / tgt->opts.io_unit_size > SPDK_NVMF_MAX_SGL_ENTRIES)) {

		SPDK_ERRLOG("Unsupported IO size, MaxIO:%d, UnitIO:%d\n", tgt->opts.max_io_size,

			    tgt->opts.io_unit_size);

		free(tgt);

		return NULL;

	}



	tgt->discovery_genctr = 0;

	tgt->discovery_log_page = NULL;

	tgt->discovery_log_page_size = 0;
@@ -258,14 +250,6 @@ spdk_nvmf_tgt_create(struct spdk_nvmf_tgt_opts *opts) 
				spdk_nvmf_tgt_destroy_poll_group,

				sizeof(struct spdk_nvmf_poll_group));



	SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max Queue Pairs Per Controller: %d\n",

		      tgt->opts.max_qpairs_per_ctrlr);

	SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max Queue Depth: %d\n", tgt->opts.max_queue_depth);

	SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max In Capsule Data: %d bytes\n",

		      tgt->opts.in_capsule_data_size);

	SPDK_DEBUGLOG(SPDK_LOG_NVMF, "Max I/O Size: %d bytes\n", tgt->opts.max_io_size);

	SPDK_DEBUGLOG(SPDK_LOG_NVMF, "I/O Unit Size: %d bytes\n", tgt->opts.io_unit_size);



	return tgt;

}
@@ -493,7 +477,7 @@ spdk_nvmf_tgt_listen(struct spdk_nvmf_tgt *tgt, 


	transport = spdk_nvmf_tgt_get_transport(tgt, trid->trtype);

	if (!transport) {

		transport = spdk_nvmf_transport_create(tgt, trid->trtype);

		transport = spdk_nvmf_transport_create(tgt, trid->trtype, NULL);

		if (!transport) {

			SPDK_ERRLOG("Transport initialization failed\n");

			cb_fn(cb_arg, -EINVAL);

lib/nvmf/rdma.c

+49 −41
Original line number Diff line number Diff line
@@ -316,11 +316,6 @@ struct spdk_nvmf_rdma_transport { 


	pthread_mutex_t			lock;



	uint16_t			max_queue_depth;

	uint32_t			max_io_size;

	uint32_t			io_unit_size;

	uint32_t			in_capsule_data_size;



	/* fields used to poll RDMA/IB events */

	nfds_t			npoll_fds;

	struct pollfd		*poll_fds;
@@ -551,9 +546,11 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 
	int				rc, i;

	struct spdk_nvmf_rdma_recv	*rdma_recv;

	struct spdk_nvmf_rdma_request	*rdma_req;

	struct spdk_nvmf_transport      *transport;



	rqpair = SPDK_CONTAINEROF(qpair, struct spdk_nvmf_rdma_qpair, qpair);

	rtransport = SPDK_CONTAINEROF(qpair->transport, struct spdk_nvmf_rdma_transport, transport);

	transport = &rtransport->transport;



	memset(&rqpair->ibv_init_attr, 0, sizeof(struct ibv_qp_init_attr));

	rqpair->ibv_init_attr.qp_context	= rqpair;
@@ -584,13 +581,15 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 
	rqpair->cpls = spdk_dma_zmalloc(rqpair->max_queue_depth * sizeof(*rqpair->cpls),

					0x1000, NULL);



	if (rtransport->in_capsule_data_size) {

		rqpair->bufs = spdk_dma_zmalloc(rqpair->max_queue_depth * rtransport->in_capsule_data_size,



	if (transport->opts.in_capsule_data_size > 0) {

		rqpair->bufs = spdk_dma_zmalloc(rqpair->max_queue_depth *

						transport->opts.in_capsule_data_size,

						0x1000, NULL);

	}



	if (!rqpair->reqs || !rqpair->recvs || !rqpair->cmds ||

	    !rqpair->cpls || (rtransport->in_capsule_data_size && !rqpair->bufs)) {

	    !rqpair->cpls || (transport->opts.in_capsule_data_size && !rqpair->bufs)) {

		SPDK_ERRLOG("Unable to allocate sufficient memory for RDMA queue.\n");

		spdk_nvmf_rdma_qpair_destroy(rqpair);

		return -1;
@@ -603,14 +602,14 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 
				     rqpair->max_queue_depth * sizeof(*rqpair->cpls),

				     0);



	if (rtransport->in_capsule_data_size) {

	if (transport->opts.in_capsule_data_size) {

		rqpair->bufs_mr = ibv_reg_mr(rqpair->cm_id->pd, rqpair->bufs,

					     rqpair->max_queue_depth * rtransport->in_capsule_data_size,

					     IBV_ACCESS_LOCAL_WRITE |

					     IBV_ACCESS_REMOTE_WRITE);

					     rqpair->max_queue_depth *

					     transport->opts.in_capsule_data_size,

					     IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE);

	}



	if (!rqpair->cmds_mr || !rqpair->cpls_mr || (rtransport->in_capsule_data_size &&

	if (!rqpair->cmds_mr || !rqpair->cpls_mr || (transport->opts.in_capsule_data_size &&

			!rqpair->bufs_mr)) {

		SPDK_ERRLOG("Unable to register required memory for RDMA queue.\n");

		spdk_nvmf_rdma_qpair_destroy(rqpair);
@@ -622,7 +621,8 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 
		      rqpair->cpls, rqpair->max_queue_depth * sizeof(*rqpair->cpls), rqpair->cpls_mr->lkey);

	if (rqpair->bufs && rqpair->bufs_mr) {

		SPDK_DEBUGLOG(SPDK_LOG_RDMA, "In Capsule Data Array: %p Length: %x LKey: %x\n",

			      rqpair->bufs, rqpair->max_queue_depth * rtransport->in_capsule_data_size, rqpair->bufs_mr->lkey);

			      rqpair->bufs, rqpair->max_queue_depth *

			      transport->opts.in_capsule_data_size, rqpair->bufs_mr->lkey);

	}



	/* Initialise request state queues and counters of the queue pair */
@@ -639,7 +639,8 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 


		/* Set up memory to receive commands */

		if (rqpair->bufs) {

			rdma_recv->buf = (void *)((uintptr_t)rqpair->bufs + (i * rtransport->in_capsule_data_size));

			rdma_recv->buf = (void *)((uintptr_t)rqpair->bufs + (i *

						  transport->opts.in_capsule_data_size));

		}



		rdma_recv->sgl[0].addr = (uintptr_t)&rqpair->cmds[i];
@@ -649,7 +650,7 @@ spdk_nvmf_rdma_qpair_initialize(struct spdk_nvmf_qpair *qpair) 


		if (rdma_recv->buf && rqpair->bufs_mr) {

			rdma_recv->sgl[1].addr = (uintptr_t)rdma_recv->buf;

			rdma_recv->sgl[1].length = rtransport->in_capsule_data_size;

			rdma_recv->sgl[1].length = transport->opts.in_capsule_data_size;

			rdma_recv->sgl[1].lkey = rqpair->bufs_mr->lkey;

			rdma_recv->wr.num_sge++;

		}
@@ -876,9 +877,10 @@ nvmf_rdma_connect(struct spdk_nvmf_transport *transport, struct rdma_cm_event *e 
	SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Calculating Queue Depth\n");



	/* Start with the maximum queue depth allowed by the target */

	max_queue_depth = rtransport->max_queue_depth;

	max_rw_depth = rtransport->max_queue_depth;

	SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Target Max Queue Depth: %d\n", rtransport->max_queue_depth);

	max_queue_depth = rtransport->transport.opts.max_queue_depth;

	max_rw_depth = rtransport->transport.opts.max_queue_depth;

	SPDK_DEBUGLOG(SPDK_LOG_RDMA, "Target Max Queue Depth: %d\n",

		      rtransport->transport.opts.max_queue_depth);



	/* Next check the local NIC's hardware limitations */

	SPDK_DEBUGLOG(SPDK_LOG_RDMA,
@@ -1091,7 +1093,7 @@ spdk_nvmf_rdma_request_fill_iovs(struct spdk_nvmf_rdma_transport *rtransport, 


		rdma_req->req.iov[i].iov_base = (void *)((uintptr_t)(buf + NVMF_DATA_BUFFER_MASK) &

						~NVMF_DATA_BUFFER_MASK);

		rdma_req->req.iov[i].iov_len  = spdk_min(length, rtransport->io_unit_size);

		rdma_req->req.iov[i].iov_len  = spdk_min(length, rtransport->transport.opts.io_unit_size);

		rdma_req->req.iovcnt++;

		rdma_req->data.buffers[i] = buf;

		rdma_req->data.wr.sg_list[i].addr = (uintptr_t)(rdma_req->req.iov[i].iov_base);
@@ -1138,9 +1140,9 @@ spdk_nvmf_rdma_request_parse_sgl(struct spdk_nvmf_rdma_transport *rtransport, 
	if (sgl->generic.type == SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK &&

	    (sgl->keyed.subtype == SPDK_NVME_SGL_SUBTYPE_ADDRESS ||

	     sgl->keyed.subtype == SPDK_NVME_SGL_SUBTYPE_INVALIDATE_KEY)) {

		if (sgl->keyed.length > rtransport->max_io_size) {

		if (sgl->keyed.length > rtransport->transport.opts.max_io_size) {

			SPDK_ERRLOG("SGL length 0x%x exceeds max io size 0x%x\n",

				    sgl->keyed.length, rtransport->max_io_size);

				    sgl->keyed.length, rtransport->transport.opts.max_io_size);

			rsp->status.sc = SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID;

			return -1;

		}
@@ -1185,7 +1187,7 @@ spdk_nvmf_rdma_request_parse_sgl(struct spdk_nvmf_rdma_transport *rtransport, 
	} else if (sgl->generic.type == SPDK_NVME_SGL_TYPE_DATA_BLOCK &&

		   sgl->unkeyed.subtype == SPDK_NVME_SGL_SUBTYPE_OFFSET) {

		uint64_t offset = sgl->address;

		uint32_t max_len = rtransport->in_capsule_data_size;

		uint32_t max_len = rtransport->transport.opts.in_capsule_data_size;



		SPDK_DEBUGLOG(SPDK_LOG_NVMF, "In-capsule data: offset 0x%" PRIx64 ", length 0x%x\n",

			      offset, sgl->unkeyed.length);
@@ -1438,7 +1440,7 @@ spdk_nvmf_rdma_request_process(struct spdk_nvmf_rdma_transport *rtransport, 
static int spdk_nvmf_rdma_destroy(struct spdk_nvmf_transport *transport);



static struct spdk_nvmf_transport *

spdk_nvmf_rdma_create(struct spdk_nvmf_tgt *tgt)

spdk_nvmf_rdma_create(struct spdk_nvmf_transport_opts *opts)

{

	int rc;

	struct spdk_nvmf_rdma_transport *rtransport;
@@ -1466,24 +1468,27 @@ spdk_nvmf_rdma_create(struct spdk_nvmf_tgt *tgt) 
	TAILQ_INIT(&rtransport->devices);

	TAILQ_INIT(&rtransport->ports);



	rtransport->transport.tgt = tgt;

	rtransport->transport.ops = &spdk_nvmf_transport_rdma;



	SPDK_INFOLOG(SPDK_LOG_RDMA, "*** RDMA Transport Init ***\n");



	rtransport->max_queue_depth = tgt->opts.max_queue_depth;

	rtransport->max_io_size = tgt->opts.max_io_size;

	rtransport->io_unit_size = tgt->opts.io_unit_size;

	rtransport->in_capsule_data_size = tgt->opts.in_capsule_data_size;

	SPDK_INFOLOG(SPDK_LOG_RDMA, "*** RDMA Transport Init ***\n"

		     "  Transport opts:  max_ioq_depth=%d, max_io_size=%d,\n"

		     "  max_qpairs_per_ctrlr=%d, io_unit_size=%d,\n"

		     "  in_capsule_data_size=%d, max_aq_depth=%d\n",

		     opts->max_queue_depth,

		     opts->max_io_size,

		     opts->max_qpairs_per_ctrlr,

		     opts->io_unit_size,

		     opts->in_capsule_data_size,

		     opts->max_aq_depth);



	/* I/O unit size cannot be larger than max I/O size */

	if (rtransport->io_unit_size > rtransport->max_io_size) {

		rtransport->io_unit_size = rtransport->max_io_size;

	if (opts->io_unit_size > opts->max_io_size) {

		opts->io_unit_size = opts->max_io_size;

	}



	sge_count = rtransport->max_io_size / rtransport->io_unit_size;

	sge_count = opts->max_io_size / opts->io_unit_size;

	if (sge_count > SPDK_NVMF_MAX_SGL_ENTRIES) {

		SPDK_ERRLOG("Unsupported IO Unit size specified, %d bytes\n", rtransport->io_unit_size);

		SPDK_ERRLOG("Unsupported IO Unit size specified, %d bytes\n", opts->io_unit_size);

		spdk_nvmf_rdma_destroy(&rtransport->transport);

		return NULL;

	}
@@ -1504,8 +1509,8 @@ spdk_nvmf_rdma_create(struct spdk_nvmf_tgt *tgt) 
	}



	rtransport->data_buf_pool = spdk_mempool_create("spdk_nvmf_rdma",

				    rtransport->max_queue_depth * 4, /* The 4 is arbitrarily chosen. Needs to be configurable. */

				    rtransport->io_unit_size + NVMF_DATA_BUFFER_ALIGNMENT,

				    opts->max_queue_depth * 4, /* The 4 is arbitrarily chosen. Needs to be configurable. */

				    opts->max_io_size + NVMF_DATA_BUFFER_ALIGNMENT,

				    SPDK_MEMPOOL_DEFAULT_CACHE_SIZE,

				    SPDK_ENV_SOCKET_ID_ANY);

	if (!rtransport->data_buf_pool) {
@@ -1631,10 +1636,13 @@ spdk_nvmf_rdma_destroy(struct spdk_nvmf_transport *transport) 
		free(device);

	}



	if (spdk_mempool_count(rtransport->data_buf_pool) != (rtransport->max_queue_depth * 4)) {

	if (rtransport->data_buf_pool != NULL) {

		if (spdk_mempool_count(rtransport->data_buf_pool) !=

		    (transport->opts.max_queue_depth * 4)) {

			SPDK_ERRLOG("transport buffer pool count is %zu but should be %u\n",

				    spdk_mempool_count(rtransport->data_buf_pool),

			    rtransport->max_queue_depth * 4);

				    transport->opts.max_queue_depth * 4);

		}

	}



	spdk_mempool_free(rtransport->data_buf_pool);