lib/nvme: add opts_size to spdk_nvme_io_qpair_opts (f43b7650) · Commits · Public Repositories / spdk

CHANGELOG.md

+2 −0

Original line number	Diff line number	Diff line
		@@ -33,6 +33,8 @@ descriptor for an I/O and the admin queue pair of a given NVMe controller respec
		These APIs accept `spdk_event_handler_opts` structure, and if specified the transport layer will
		fill it out which can be used by the application to register interrupts on the queue pairs.

		Added `opts_size` in `spdk_nvme_io_qpair_opts` structure to align it with other opts structures.

		### nvmf

		Added public API `spdk_nvmf_send_discovery_log_notice` to send discovery log page

include/spdk/nvme.h

+9 −1

Original line number	Diff line number	Diff line
		@@ -1813,8 +1813,16 @@ struct spdk_nvme_io_qpair_opts {

		/* Hole at bytes 67-71. */
		uint8_t reserved67[5];

		/**
		* The size of spdk_nvme_io_qpair_opts according to the caller of this library is used for
		* ABI compatibility. The library uses this field to know how many fields in this structure
		* are valid. And the library will populate any remaining fields with default values.
		* New added fields should be put at the end of the struct.
		*/
		size_t opts_size;
		};
		SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_io_qpair_opts) == 72, "Incorrect size");
		SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_io_qpair_opts) == 80, "Incorrect size");

		/**
		* Get the default options for I/O qpair creation for a specific NVMe controller.

lib/nvme/nvme_ctrlr.c

+58 −44

Original line number	Diff line number	Diff line
		@@ -284,59 +284,73 @@ spdk_nvme_ctrlr_get_default_io_qpair_opts(struct spdk_nvme_ctrlr *ctrlr,
		assert(opts);

		memset(opts, 0, opts_size);
		opts->opts_size = opts_size;

		#define FIELD_OK(field) \
		offsetof(struct spdk_nvme_io_qpair_opts, field) + sizeof(opts->field) <= opts_size

		if (FIELD_OK(qprio)) {
		opts->qprio = SPDK_NVME_QPRIO_URGENT;
		}

		if (FIELD_OK(io_queue_size)) {
		opts->io_queue_size = ctrlr->opts.io_queue_size;
		}

		if (FIELD_OK(io_queue_requests)) {
		opts->io_queue_requests = ctrlr->opts.io_queue_requests;
		}

		if (FIELD_OK(delay_cmd_submit)) {
		opts->delay_cmd_submit = false;
		}

		if (FIELD_OK(sq.vaddr)) {
		opts->sq.vaddr = NULL;
		}

		if (FIELD_OK(sq.paddr)) {
		opts->sq.paddr = 0;
		}
		#define SET_FIELD(field, value) \
		if (FIELD_OK(field)) { \
		opts->field = value; \
		} \

		if (FIELD_OK(sq.buffer_size)) {
		opts->sq.buffer_size = 0;
		}
		SET_FIELD(qprio, SPDK_NVME_QPRIO_URGENT);
		SET_FIELD(io_queue_size, ctrlr->opts.io_queue_size);
		SET_FIELD(io_queue_requests, ctrlr->opts.io_queue_requests);
		SET_FIELD(delay_cmd_submit, false);
		SET_FIELD(sq.vaddr, NULL);
		SET_FIELD(sq.paddr, 0);
		SET_FIELD(sq.buffer_size, 0);
		SET_FIELD(cq.vaddr, NULL);
		SET_FIELD(cq.paddr, 0);
		SET_FIELD(cq.buffer_size, 0);
		SET_FIELD(create_only, false);
		SET_FIELD(async_mode, false);
		SET_FIELD(disable_pcie_sgl_merge, false);

		if (FIELD_OK(cq.vaddr)) {
		opts->cq.vaddr = NULL;
		#undef FIELD_OK
		#undef SET_FIELD
		}

		if (FIELD_OK(cq.paddr)) {
		opts->cq.paddr = 0;
		static void
		nvme_ctrlr_io_qpair_opts_copy(struct spdk_nvme_io_qpair_opts *dst,
		const struct spdk_nvme_io_qpair_opts *src, size_t opts_size_src)
		{
		if (!opts_size_src) {
		SPDK_ERRLOG("opts_size_src should not be zero value\n");
		assert(false);
		}

		if (FIELD_OK(cq.buffer_size)) {
		opts->cq.buffer_size = 0;
		}
		#define FIELD_OK(field) \
		offsetof(struct spdk_nvme_io_qpair_opts, field) + sizeof(src->field) <= opts_size_src

		if (FIELD_OK(create_only)) {
		opts->create_only = false;
		}
		#define SET_FIELD(field) \
		if (FIELD_OK(field)) { \
		dst->field = src->field; \
		} \

		if (FIELD_OK(async_mode)) {
		opts->async_mode = false;
		}
		SET_FIELD(qprio);
		SET_FIELD(io_queue_size);
		SET_FIELD(io_queue_requests);
		SET_FIELD(delay_cmd_submit);
		SET_FIELD(sq.vaddr);
		SET_FIELD(sq.paddr);
		SET_FIELD(sq.buffer_size);
		SET_FIELD(cq.vaddr);
		SET_FIELD(cq.paddr);
		SET_FIELD(cq.buffer_size);
		SET_FIELD(create_only);
		SET_FIELD(async_mode);
		SET_FIELD(disable_pcie_sgl_merge);

		dst->opts_size = opts_size_src;

		/* You should not remove this statement, but need to update the assert statement
		* if you add a new field, and also add a corresponding SET_FIELD statement */
		SPDK_STATIC_ASSERT(sizeof(struct spdk_nvme_io_qpair_opts) == 80, "Incorrect size");

		#undef FIELD_OK
		#undef SET_FIELD
		}

		static struct spdk_nvme_qpair *
		@@ -456,7 +470,7 @@ spdk_nvme_ctrlr_alloc_io_qpair(struct spdk_nvme_ctrlr *ctrlr,
		*/
		spdk_nvme_ctrlr_get_default_io_qpair_opts(ctrlr, &opts, sizeof(opts));
		if (user_opts) {
		memcpy(&opts, user_opts, spdk_min(sizeof(opts), opts_size));
		nvme_ctrlr_io_qpair_opts_copy(&opts, user_opts, spdk_min(opts.opts_size, opts_size));

		/* If user passes buffers, make sure they're big enough for the requested queue size */
		if (opts.sq.vaddr) {

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

+11 −0

Original line number	Diff line number	Diff line
		@@ -2029,6 +2029,17 @@ test_ctrlr_get_default_io_qpair_opts(void)
		CU_ASSERT_EQUAL(opts.qprio, SPDK_NVME_QPRIO_URGENT);
		CU_ASSERT_EQUAL(opts.io_queue_size, DEFAULT_IO_QUEUE_SIZE);
		CU_ASSERT_EQUAL(opts.io_queue_requests, DEFAULT_IO_QUEUE_REQUESTS);
		CU_ASSERT_EQUAL(opts.delay_cmd_submit, false);
		CU_ASSERT_EQUAL(opts.sq.vaddr, NULL);
		CU_ASSERT_EQUAL(opts.sq.paddr, 0);
		CU_ASSERT_EQUAL(opts.sq.buffer_size, 0);
		CU_ASSERT_EQUAL(opts.cq.vaddr, NULL);
		CU_ASSERT_EQUAL(opts.cq.paddr, 0);
		CU_ASSERT_EQUAL(opts.cq.buffer_size, 0);
		CU_ASSERT_EQUAL(opts.create_only, false);
		CU_ASSERT_EQUAL(opts.async_mode, false);
		CU_ASSERT_EQUAL(opts.disable_pcie_sgl_merge, false);
		CU_ASSERT_EQUAL(opts.opts_size, sizeof(opts));
		}

		#if 0 /* TODO: move to PCIe-specific unit test */