diff options
Diffstat (limited to 'src/spdk/test/unit/lib/nvmf')
25 files changed, 7740 insertions, 0 deletions
diff --git a/src/spdk/test/unit/lib/nvmf/Makefile b/src/spdk/test/unit/lib/nvmf/Makefile new file mode 100644 index 000000000..94d5dde63 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/Makefile @@ -0,0 +1,48 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../..) +include $(SPDK_ROOT_DIR)/mk/spdk.common.mk + +DIRS-y = tcp.c ctrlr.c subsystem.c ctrlr_discovery.c ctrlr_bdev.c + +DIRS-$(CONFIG_RDMA) += rdma.c + +DIRS-$(CONFIG_FC) += fc.c fc_ls.c + +.PHONY: all clean $(DIRS-y) + +all: $(DIRS-y) +clean: $(DIRS-y) + +include $(SPDK_ROOT_DIR)/mk/spdk.subdirs.mk diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr.c/.gitignore b/src/spdk/test/unit/lib/nvmf/ctrlr.c/.gitignore new file mode 100644 index 000000000..65e849431 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr.c/.gitignore @@ -0,0 +1 @@ +ctrlr_ut diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr.c/Makefile b/src/spdk/test/unit/lib/nvmf/ctrlr.c/Makefile new file mode 100644 index 000000000..c68c589ab --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr.c/Makefile @@ -0,0 +1,38 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +TEST_FILE = ctrlr_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c b/src/spdk/test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c new file mode 100644 index 000000000..1da8f9d54 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr.c/ctrlr_ut.c @@ -0,0 +1,1711 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. All rights reserved. + * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" + +#include "spdk_cunit.h" +#include "spdk_internal/mock.h" +#include "spdk_internal/thread.h" + +#include "common/lib/ut_multithread.c" +#include "nvmf/ctrlr.c" + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) + +struct spdk_bdev { + int ut_mock; + uint64_t blockcnt; +}; + +const char subsystem_default_sn[SPDK_NVME_CTRLR_SN_LEN + 1] = "subsys_default_sn"; +const char subsystem_default_mn[SPDK_NVME_CTRLR_MN_LEN + 1] = "subsys_default_mn"; + +DEFINE_STUB(spdk_nvmf_tgt_find_subsystem, + struct spdk_nvmf_subsystem *, + (struct spdk_nvmf_tgt *tgt, const char *subnqn), + NULL); + +DEFINE_STUB(spdk_nvmf_poll_group_create, + struct spdk_nvmf_poll_group *, + (struct spdk_nvmf_tgt *tgt), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_get_sn, + const char *, + (const struct spdk_nvmf_subsystem *subsystem), + subsystem_default_sn); + +DEFINE_STUB(spdk_nvmf_subsystem_get_mn, + const char *, + (const struct spdk_nvmf_subsystem *subsystem), + subsystem_default_mn); + +DEFINE_STUB(spdk_nvmf_subsystem_get_first_ns, + struct spdk_nvmf_ns *, + (struct spdk_nvmf_subsystem *subsystem), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_get_next_ns, + struct spdk_nvmf_ns *, + (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_host_allowed, + bool, + (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn), + true); + +DEFINE_STUB(nvmf_subsystem_add_ctrlr, + int, + (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr), + 0); + +DEFINE_STUB(nvmf_subsystem_get_ctrlr, + struct spdk_nvmf_ctrlr *, + (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid), + NULL); + +DEFINE_STUB(nvmf_ctrlr_dsm_supported, + bool, + (struct spdk_nvmf_ctrlr *ctrlr), + false); + +DEFINE_STUB(nvmf_ctrlr_write_zeroes_supported, + bool, + (struct spdk_nvmf_ctrlr *ctrlr), + false); + +DEFINE_STUB_V(nvmf_get_discovery_log_page, + (struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov, + uint32_t iovcnt, uint64_t offset, uint32_t length)); + +DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid, + int, + (struct spdk_nvmf_qpair *qpair, struct spdk_nvme_transport_id *trid), + 0); + +DEFINE_STUB(spdk_nvmf_subsystem_listener_allowed, + bool, + (struct spdk_nvmf_subsystem *subsystem, const struct spdk_nvme_transport_id *trid), + true); + +DEFINE_STUB(nvmf_bdev_ctrlr_read_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_write_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_compare_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_compare_and_write_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *cmp_req, struct spdk_nvmf_request *write_req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_write_zeroes_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_flush_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_dsm_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_nvme_passthru_io, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_transport_req_complete, + int, + (struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB_V(nvmf_ns_reservation_request, (void *ctx)); + +DEFINE_STUB(nvmf_bdev_ctrlr_get_dif_ctx, bool, + (struct spdk_bdev *bdev, struct spdk_nvme_cmd *cmd, + struct spdk_dif_ctx *dif_ctx), + true); + +DEFINE_STUB_V(nvmf_transport_qpair_abort_request, + (struct spdk_nvmf_qpair *qpair, struct spdk_nvmf_request *req)); + +DEFINE_STUB_V(spdk_nvme_print_command, (uint16_t qid, struct spdk_nvme_cmd *cmd)); +DEFINE_STUB_V(spdk_nvme_print_completion, (uint16_t qid, struct spdk_nvme_cpl *cpl)); + +int +spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) +{ + return 0; +} + +void +nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata, + bool dif_insert_or_strip) +{ + uint64_t num_blocks; + + SPDK_CU_ASSERT_FATAL(ns->bdev != NULL); + num_blocks = ns->bdev->blockcnt; + nsdata->nsze = num_blocks; + nsdata->ncap = num_blocks; + nsdata->nuse = num_blocks; + nsdata->nlbaf = 0; + nsdata->flbas.format = 0; + nsdata->lbaf[0].lbads = spdk_u32log2(512); +} + +static void +test_get_log_page(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_request req = {}; + struct spdk_nvmf_qpair qpair = {}; + struct spdk_nvmf_ctrlr ctrlr = {}; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + char data[4096]; + + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + + ctrlr.subsys = &subsystem; + + qpair.ctrlr = &ctrlr; + + req.qpair = &qpair; + req.cmd = &cmd; + req.rsp = &rsp; + req.data = &data; + req.length = sizeof(data); + + /* Get Log Page - all valid */ + memset(&cmd, 0, sizeof(cmd)); + memset(&rsp, 0, sizeof(rsp)); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; + cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR; + cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = (req.length / 4 - 1); + CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + + /* Get Log Page with invalid log ID */ + memset(&cmd, 0, sizeof(cmd)); + memset(&rsp, 0, sizeof(rsp)); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; + cmd.nvme_cmd.cdw10 = 0; + CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* Get Log Page with invalid offset (not dword aligned) */ + memset(&cmd, 0, sizeof(cmd)); + memset(&rsp, 0, sizeof(rsp)); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; + cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR; + cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = (req.length / 4 - 1); + cmd.nvme_cmd.cdw12 = 2; + CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* Get Log Page without data buffer */ + memset(&cmd, 0, sizeof(cmd)); + memset(&rsp, 0, sizeof(rsp)); + req.data = NULL; + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE; + cmd.nvme_cmd.cdw10_bits.get_log_page.lid = SPDK_NVME_LOG_ERROR; + cmd.nvme_cmd.cdw10_bits.get_log_page.numdl = (req.length / 4 - 1); + CU_ASSERT(nvmf_ctrlr_get_log_page(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(req.rsp->nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(req.rsp->nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + req.data = data; +} + +static void +test_process_fabrics_cmd(void) +{ + struct spdk_nvmf_request req = {}; + int ret; + struct spdk_nvmf_qpair req_qpair = {}; + union nvmf_h2c_msg req_cmd = {}; + union nvmf_c2h_msg req_rsp = {}; + + req.qpair = &req_qpair; + req.cmd = &req_cmd; + req.rsp = &req_rsp; + req.qpair->ctrlr = NULL; + + /* No ctrlr and invalid command check */ + req.cmd->nvmf_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET; + ret = nvmf_ctrlr_process_fabrics_cmd(&req); + CU_ASSERT_EQUAL(req.rsp->nvme_cpl.status.sc, SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR); + CU_ASSERT_EQUAL(ret, SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); +} + +static bool +nvme_status_success(const struct spdk_nvme_status *status) +{ + return status->sct == SPDK_NVME_SCT_GENERIC && status->sc == SPDK_NVME_SC_SUCCESS; +} + +static void +test_connect(void) +{ + struct spdk_nvmf_fabric_connect_data connect_data; + struct spdk_nvmf_poll_group group; + struct spdk_nvmf_subsystem_poll_group *sgroups; + struct spdk_nvmf_transport transport; + struct spdk_nvmf_transport_ops tops = {}; + struct spdk_nvmf_subsystem subsystem; + struct spdk_nvmf_request req; + struct spdk_nvmf_qpair admin_qpair; + struct spdk_nvmf_qpair qpair; + struct spdk_nvmf_qpair qpair2; + struct spdk_nvmf_ctrlr ctrlr; + struct spdk_nvmf_tgt tgt; + union nvmf_h2c_msg cmd; + union nvmf_c2h_msg rsp; + const uint8_t hostid[16] = { + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F + }; + const char subnqn[] = "nqn.2016-06.io.spdk:subsystem1"; + const char hostnqn[] = "nqn.2016-06.io.spdk:host1"; + int rc; + + memset(&group, 0, sizeof(group)); + group.thread = spdk_get_thread(); + + memset(&ctrlr, 0, sizeof(ctrlr)); + ctrlr.subsys = &subsystem; + ctrlr.qpair_mask = spdk_bit_array_create(3); + SPDK_CU_ASSERT_FATAL(ctrlr.qpair_mask != NULL); + ctrlr.vcprop.cc.bits.en = 1; + ctrlr.vcprop.cc.bits.iosqes = 6; + ctrlr.vcprop.cc.bits.iocqes = 4; + + memset(&admin_qpair, 0, sizeof(admin_qpair)); + admin_qpair.group = &group; + + memset(&tgt, 0, sizeof(tgt)); + memset(&transport, 0, sizeof(transport)); + transport.ops = &tops; + transport.opts.max_aq_depth = 32; + transport.opts.max_queue_depth = 64; + transport.opts.max_qpairs_per_ctrlr = 3; + transport.tgt = &tgt; + + memset(&qpair, 0, sizeof(qpair)); + qpair.transport = &transport; + qpair.group = &group; + qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + TAILQ_INIT(&qpair.outstanding); + + memset(&connect_data, 0, sizeof(connect_data)); + memcpy(connect_data.hostid, hostid, sizeof(hostid)); + connect_data.cntlid = 0xFFFF; + snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn); + snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); + + memset(&subsystem, 0, sizeof(subsystem)); + subsystem.thread = spdk_get_thread(); + subsystem.id = 1; + TAILQ_INIT(&subsystem.ctrlrs); + subsystem.tgt = &tgt; + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn); + + sgroups = calloc(subsystem.id + 1, sizeof(struct spdk_nvmf_subsystem_poll_group)); + group.sgroups = sgroups; + + memset(&cmd, 0, sizeof(cmd)); + cmd.connect_cmd.opcode = SPDK_NVME_OPC_FABRIC; + cmd.connect_cmd.cid = 1; + cmd.connect_cmd.fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT; + cmd.connect_cmd.recfmt = 0; + cmd.connect_cmd.qid = 0; + cmd.connect_cmd.sqsize = 31; + cmd.connect_cmd.cattr = 0; + cmd.connect_cmd.kato = 120000; + + memset(&req, 0, sizeof(req)); + req.qpair = &qpair; + req.length = sizeof(connect_data); + req.xfer = SPDK_NVME_DATA_HOST_TO_CONTROLLER; + req.data = &connect_data; + req.cmd = &cmd; + req.rsp = &rsp; + + MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); + MOCK_SET(spdk_nvmf_poll_group_create, &group); + + /* Valid admin connect command */ + memset(&rsp, 0, sizeof(rsp)); + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.ctrlr != NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr); + spdk_bit_array_free(&qpair.ctrlr->qpair_mask); + free(qpair.ctrlr); + qpair.ctrlr = NULL; + + /* Valid admin connect command with kato = 0 */ + cmd.connect_cmd.kato = 0; + memset(&rsp, 0, sizeof(rsp)); + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.ctrlr != NULL && qpair.ctrlr->keep_alive_poller == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + spdk_bit_array_free(&qpair.ctrlr->qpair_mask); + free(qpair.ctrlr); + qpair.ctrlr = NULL; + cmd.connect_cmd.kato = 120000; + + /* Invalid data length */ + memset(&rsp, 0, sizeof(rsp)); + req.length = sizeof(connect_data) - 1; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + CU_ASSERT(qpair.ctrlr == NULL); + req.length = sizeof(connect_data); + + /* Invalid recfmt */ + memset(&rsp, 0, sizeof(rsp)); + cmd.connect_cmd.recfmt = 1234; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INCOMPATIBLE_FORMAT); + CU_ASSERT(qpair.ctrlr == NULL); + cmd.connect_cmd.recfmt = 0; + + /* Subsystem not found */ + memset(&rsp, 0, sizeof(rsp)); + MOCK_SET(spdk_nvmf_tgt_find_subsystem, NULL); + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 256); + CU_ASSERT(qpair.ctrlr == NULL); + MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem); + + /* Unterminated hostnqn */ + memset(&rsp, 0, sizeof(rsp)); + memset(connect_data.hostnqn, 'b', sizeof(connect_data.hostnqn)); + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 512); + CU_ASSERT(qpair.ctrlr == NULL); + snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn); + + /* Host not allowed */ + memset(&rsp, 0, sizeof(rsp)); + MOCK_SET(spdk_nvmf_subsystem_host_allowed, false); + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_HOST); + CU_ASSERT(qpair.ctrlr == NULL); + MOCK_SET(spdk_nvmf_subsystem_host_allowed, true); + + /* Invalid sqsize == 0 */ + memset(&rsp, 0, sizeof(rsp)); + cmd.connect_cmd.sqsize = 0; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); + CU_ASSERT(qpair.ctrlr == NULL); + cmd.connect_cmd.sqsize = 31; + + /* Invalid admin sqsize > max_aq_depth */ + memset(&rsp, 0, sizeof(rsp)); + cmd.connect_cmd.sqsize = 32; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); + CU_ASSERT(qpair.ctrlr == NULL); + cmd.connect_cmd.sqsize = 31; + + /* Invalid I/O sqsize > max_queue_depth */ + memset(&rsp, 0, sizeof(rsp)); + cmd.connect_cmd.qid = 1; + cmd.connect_cmd.sqsize = 64; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 44); + CU_ASSERT(qpair.ctrlr == NULL); + cmd.connect_cmd.qid = 0; + cmd.connect_cmd.sqsize = 31; + + /* Invalid cntlid for admin queue */ + memset(&rsp, 0, sizeof(rsp)); + connect_data.cntlid = 0x1234; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); + CU_ASSERT(qpair.ctrlr == NULL); + connect_data.cntlid = 0xFFFF; + + ctrlr.admin_qpair = &admin_qpair; + ctrlr.subsys = &subsystem; + + /* Valid I/O queue connect command */ + memset(&rsp, 0, sizeof(rsp)); + MOCK_SET(nvmf_subsystem_get_ctrlr, &ctrlr); + cmd.connect_cmd.qid = 1; + cmd.connect_cmd.sqsize = 63; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.ctrlr == &ctrlr); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + qpair.ctrlr = NULL; + cmd.connect_cmd.sqsize = 31; + + /* Non-existent controller */ + memset(&rsp, 0, sizeof(rsp)); + MOCK_SET(nvmf_subsystem_get_ctrlr, NULL); + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 1); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 16); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + MOCK_SET(nvmf_subsystem_get_ctrlr, &ctrlr); + + /* I/O connect to discovery controller */ + memset(&rsp, 0, sizeof(rsp)); + subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + + /* I/O connect to discovery controller with keep-alive-timeout != 0 */ + cmd.connect_cmd.qid = 0; + cmd.connect_cmd.kato = 120000; + memset(&rsp, 0, sizeof(rsp)); + subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.ctrlr != NULL); + CU_ASSERT(qpair.ctrlr->keep_alive_poller != NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr); + spdk_bit_array_free(&qpair.ctrlr->qpair_mask); + free(qpair.ctrlr); + qpair.ctrlr = NULL; + + /* I/O connect to discovery controller with keep-alive-timeout == 0. + * Then, a fixed timeout value is set to keep-alive-timeout. + */ + cmd.connect_cmd.kato = 0; + memset(&rsp, 0, sizeof(rsp)); + subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY; + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.ctrlr != NULL); + CU_ASSERT(qpair.ctrlr->keep_alive_poller != NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr); + spdk_bit_array_free(&qpair.ctrlr->qpair_mask); + free(qpair.ctrlr); + qpair.ctrlr = NULL; + cmd.connect_cmd.qid = 1; + cmd.connect_cmd.kato = 120000; + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + + /* I/O connect to disabled controller */ + memset(&rsp, 0, sizeof(rsp)); + ctrlr.vcprop.cc.bits.en = 0; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + ctrlr.vcprop.cc.bits.en = 1; + + /* I/O connect with invalid IOSQES */ + memset(&rsp, 0, sizeof(rsp)); + ctrlr.vcprop.cc.bits.iosqes = 3; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + ctrlr.vcprop.cc.bits.iosqes = 6; + + /* I/O connect with invalid IOCQES */ + memset(&rsp, 0, sizeof(rsp)); + ctrlr.vcprop.cc.bits.iocqes = 3; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVMF_FABRIC_SC_INVALID_PARAM); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.iattr == 0); + CU_ASSERT(rsp.connect_rsp.status_code_specific.invalid.ipo == 42); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + ctrlr.vcprop.cc.bits.iocqes = 4; + + /* I/O connect with too many existing qpairs */ + memset(&rsp, 0, sizeof(rsp)); + spdk_bit_array_set(ctrlr.qpair_mask, 0); + spdk_bit_array_set(ctrlr.qpair_mask, 1); + spdk_bit_array_set(ctrlr.qpair_mask, 2); + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + spdk_bit_array_clear(ctrlr.qpair_mask, 0); + spdk_bit_array_clear(ctrlr.qpair_mask, 1); + spdk_bit_array_clear(ctrlr.qpair_mask, 2); + + /* I/O connect with duplicate queue ID */ + memset(&rsp, 0, sizeof(rsp)); + memset(&qpair2, 0, sizeof(qpair2)); + qpair2.group = &group; + qpair2.qid = 1; + spdk_bit_array_set(ctrlr.qpair_mask, 1); + cmd.connect_cmd.qid = 1; + sgroups[subsystem.id].io_outstanding++; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + rc = nvmf_ctrlr_cmd_connect(&req); + poll_threads(); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER); + CU_ASSERT(qpair.ctrlr == NULL); + CU_ASSERT(sgroups[subsystem.id].io_outstanding == 0); + + /* Clean up globals */ + MOCK_CLEAR(spdk_nvmf_tgt_find_subsystem); + MOCK_CLEAR(spdk_nvmf_poll_group_create); + + spdk_bit_array_free(&ctrlr.qpair_mask); + free(sgroups); +} + +static void +test_get_ns_id_desc_list(void) +{ + struct spdk_nvmf_subsystem subsystem; + struct spdk_nvmf_qpair qpair; + struct spdk_nvmf_ctrlr ctrlr; + struct spdk_nvmf_request req; + struct spdk_nvmf_ns *ns_ptrs[1]; + struct spdk_nvmf_ns ns; + union nvmf_h2c_msg cmd; + union nvmf_c2h_msg rsp; + struct spdk_bdev bdev; + uint8_t buf[4096]; + + memset(&subsystem, 0, sizeof(subsystem)); + ns_ptrs[0] = &ns; + subsystem.ns = ns_ptrs; + subsystem.max_nsid = 1; + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + + memset(&ns, 0, sizeof(ns)); + ns.opts.nsid = 1; + ns.bdev = &bdev; + + memset(&qpair, 0, sizeof(qpair)); + qpair.ctrlr = &ctrlr; + + memset(&ctrlr, 0, sizeof(ctrlr)); + ctrlr.subsys = &subsystem; + ctrlr.vcprop.cc.bits.en = 1; + + memset(&req, 0, sizeof(req)); + req.qpair = &qpair; + req.cmd = &cmd; + req.rsp = &rsp; + req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; + req.data = buf; + req.length = sizeof(buf); + + memset(&cmd, 0, sizeof(cmd)); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_IDENTIFY; + cmd.nvme_cmd.cdw10_bits.identify.cns = SPDK_NVME_IDENTIFY_NS_ID_DESCRIPTOR_LIST; + + /* Invalid NSID */ + cmd.nvme_cmd.nsid = 0; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); + + /* Valid NSID, but ns has no IDs defined */ + cmd.nvme_cmd.nsid = 1; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(spdk_mem_all_zero(buf, sizeof(buf))); + + /* Valid NSID, only EUI64 defined */ + ns.opts.eui64[0] = 0x11; + ns.opts.eui64[7] = 0xFF; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); + CU_ASSERT(buf[1] == 8); + CU_ASSERT(buf[4] == 0x11); + CU_ASSERT(buf[11] == 0xFF); + CU_ASSERT(buf[13] == 0); + + /* Valid NSID, only NGUID defined */ + memset(ns.opts.eui64, 0, sizeof(ns.opts.eui64)); + ns.opts.nguid[0] = 0x22; + ns.opts.nguid[15] = 0xEE; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(buf[0] == SPDK_NVME_NIDT_NGUID); + CU_ASSERT(buf[1] == 16); + CU_ASSERT(buf[4] == 0x22); + CU_ASSERT(buf[19] == 0xEE); + CU_ASSERT(buf[21] == 0); + + /* Valid NSID, both EUI64 and NGUID defined */ + ns.opts.eui64[0] = 0x11; + ns.opts.eui64[7] = 0xFF; + ns.opts.nguid[0] = 0x22; + ns.opts.nguid[15] = 0xEE; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); + CU_ASSERT(buf[1] == 8); + CU_ASSERT(buf[4] == 0x11); + CU_ASSERT(buf[11] == 0xFF); + CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); + CU_ASSERT(buf[13] == 16); + CU_ASSERT(buf[16] == 0x22); + CU_ASSERT(buf[31] == 0xEE); + CU_ASSERT(buf[33] == 0); + + /* Valid NSID, EUI64, NGUID, and UUID defined */ + ns.opts.eui64[0] = 0x11; + ns.opts.eui64[7] = 0xFF; + ns.opts.nguid[0] = 0x22; + ns.opts.nguid[15] = 0xEE; + ns.opts.uuid.u.raw[0] = 0x33; + ns.opts.uuid.u.raw[15] = 0xDD; + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(buf[0] == SPDK_NVME_NIDT_EUI64); + CU_ASSERT(buf[1] == 8); + CU_ASSERT(buf[4] == 0x11); + CU_ASSERT(buf[11] == 0xFF); + CU_ASSERT(buf[12] == SPDK_NVME_NIDT_NGUID); + CU_ASSERT(buf[13] == 16); + CU_ASSERT(buf[16] == 0x22); + CU_ASSERT(buf[31] == 0xEE); + CU_ASSERT(buf[32] == SPDK_NVME_NIDT_UUID); + CU_ASSERT(buf[33] == 16); + CU_ASSERT(buf[36] == 0x33); + CU_ASSERT(buf[51] == 0xDD); + CU_ASSERT(buf[53] == 0); +} + +static void +test_identify_ns(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_transport transport = {}; + struct spdk_nvmf_qpair admin_qpair = { .transport = &transport}; + struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair }; + struct spdk_nvme_cmd cmd = {}; + struct spdk_nvme_cpl rsp = {}; + struct spdk_nvme_ns_data nsdata = {}; + struct spdk_bdev bdev[3] = {{.blockcnt = 1234}, {.blockcnt = 0}, {.blockcnt = 5678}}; + struct spdk_nvmf_ns ns[3] = {{.bdev = &bdev[0]}, {.bdev = NULL}, {.bdev = &bdev[2]}}; + struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]}; + + subsystem.ns = ns_arr; + subsystem.max_nsid = SPDK_COUNTOF(ns_arr); + + /* Invalid NSID 0 */ + cmd.nsid = 0; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); + CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); + + /* Valid NSID 1 */ + cmd.nsid = 1; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(nsdata.nsze == 1234); + + /* Valid but inactive NSID 2 */ + cmd.nsid = 2; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); + + /* Valid NSID 3 */ + cmd.nsid = 3; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(nsdata.nsze == 5678); + + /* Invalid NSID 4 */ + cmd.nsid = 4; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); + CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); + + /* Invalid NSID 0xFFFFFFFF (NS management not supported) */ + cmd.nsid = 0xFFFFFFFF; + memset(&nsdata, 0, sizeof(nsdata)); + memset(&rsp, 0, sizeof(rsp)); + CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp, + &nsdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.status.sc == SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT); + CU_ASSERT(spdk_mem_all_zero(&nsdata, sizeof(nsdata))); +} + +static void +test_set_get_features(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_qpair admin_qpair = {}; + struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair }; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + struct spdk_nvmf_ns ns[3]; + struct spdk_nvmf_ns *ns_arr[3] = {&ns[0], NULL, &ns[2]};; + struct spdk_nvmf_request req; + int rc; + + subsystem.ns = ns_arr; + subsystem.max_nsid = SPDK_COUNTOF(ns_arr); + admin_qpair.ctrlr = &ctrlr; + req.qpair = &admin_qpair; + cmd.nvme_cmd.nsid = 1; + req.cmd = &cmd; + req.rsp = &rsp; + + /* Set SPDK_NVME_FEAT_HOST_RESERVE_PERSIST feature */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11_bits.feat_rsv_persistence.bits.ptpl = 1; + ns[0].ptpl_file = "testcfg"; + rc = nvmf_ctrlr_set_features_reservation_persistence(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_FEATURE_ID_NOT_SAVEABLE); + CU_ASSERT(ns[0].ptpl_activated == true); + + /* Get SPDK_NVME_FEAT_HOST_RESERVE_PERSIST feature */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES; + cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_HOST_RESERVE_PERSIST; + rc = nvmf_ctrlr_get_features_reservation_persistence(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); + CU_ASSERT(rsp.nvme_cpl.cdw0 == 1); + + + /* Get SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - valid TMPSEL */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42; + cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD; + + rc = nvmf_ctrlr_get_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + + /* Get SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid TMPSEL */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_GET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42 | 1 << 16 | 1 << 19; /* Set reserved value */ + cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD; + + rc = nvmf_ctrlr_get_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - valid TMPSEL */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42; + cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD; + + rc = nvmf_ctrlr_set_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + + /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid TMPSEL */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42 | 1 << 16 | 1 << 19; /* Set reserved value */ + cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD; + + rc = nvmf_ctrlr_set_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* Set SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD - invalid THSEL */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42; + cmd.nvme_cmd.cdw11_bits.feat_temp_threshold.bits.thsel = 0x3; /* Set reserved value */ + cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_TEMPERATURE_THRESHOLD; + + rc = nvmf_ctrlr_set_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + + /* get SPDK_NVME_FEAT_ERROR_RECOVERY - generic */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw10_bits.get_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY; + + rc = nvmf_ctrlr_get_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + + /* Set SPDK_NVME_FEAT_ERROR_RECOVERY - DULBE set */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42; + cmd.nvme_cmd.cdw11_bits.feat_error_recovery.bits.dulbe = 0x1; + cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY; + + rc = nvmf_ctrlr_set_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* Set SPDK_NVME_FEAT_ERROR_RECOVERY - DULBE cleared */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_SET_FEATURES; + cmd.nvme_cmd.cdw11 = 0x42; + cmd.nvme_cmd.cdw11_bits.feat_error_recovery.bits.dulbe = 0x0; + cmd.nvme_cmd.cdw10_bits.set_features.fid = SPDK_NVME_FEAT_ERROR_RECOVERY; + + rc = nvmf_ctrlr_set_features(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); +} + +/* + * Reservation Unit Test Configuration + * -------- -------- -------- + * | Host A | | Host B | | Host C | + * -------- -------- -------- + * / \ | | + * -------- -------- ------- ------- + * |Ctrlr1_A| |Ctrlr2_A| |Ctrlr_B| |Ctrlr_C| + * -------- -------- ------- ------- + * \ \ / / + * \ \ / / + * \ \ / / + * -------------------------------------- + * | NAMESPACE 1 | + * -------------------------------------- + */ + +static struct spdk_nvmf_ctrlr g_ctrlr1_A, g_ctrlr2_A, g_ctrlr_B, g_ctrlr_C; +struct spdk_nvmf_subsystem_pg_ns_info g_ns_info; + +static void +ut_reservation_init(enum spdk_nvme_reservation_type rtype) +{ + /* Host A has two controllers */ + spdk_uuid_generate(&g_ctrlr1_A.hostid); + spdk_uuid_copy(&g_ctrlr2_A.hostid, &g_ctrlr1_A.hostid); + + /* Host B has 1 controller */ + spdk_uuid_generate(&g_ctrlr_B.hostid); + + /* Host C has 1 controller */ + spdk_uuid_generate(&g_ctrlr_C.hostid); + + memset(&g_ns_info, 0, sizeof(g_ns_info)); + g_ns_info.rtype = rtype; + g_ns_info.reg_hostid[0] = g_ctrlr1_A.hostid; + g_ns_info.reg_hostid[1] = g_ctrlr_B.hostid; + g_ns_info.reg_hostid[2] = g_ctrlr_C.hostid; +} + +static void +test_reservation_write_exclusive(void) +{ + struct spdk_nvmf_request req = {}; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + int rc; + + req.cmd = &cmd; + req.rsp = &rsp; + + /* Host A holds reservation with type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE */ + ut_reservation_init(SPDK_NVME_RESERVE_WRITE_EXCLUSIVE); + g_ns_info.holder_id = g_ctrlr1_A.hostid; + + /* Test Case: Issue a Read command from Host A and Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + + /* Test Case: Issue a DSM Write command from Host A and Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + + /* Test Case: Issue a Write command from Host C */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + + /* Test Case: Issue a Read command from Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + + /* Unregister Host C */ + memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); + + /* Test Case: Read and Write commands from non-registrant Host C */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); +} + +static void +test_reservation_exclusive_access(void) +{ + struct spdk_nvmf_request req = {}; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + int rc; + + req.cmd = &cmd; + req.rsp = &rsp; + + /* Host A holds reservation with type SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS */ + ut_reservation_init(SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS); + g_ns_info.holder_id = g_ctrlr1_A.hostid; + + /* Test Case: Issue a Read command from Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + + /* Test Case: Issue a Reservation Release command from a valid Registrant */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_RESERVATION_RELEASE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); +} + +static void +_test_reservation_write_exclusive_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) +{ + struct spdk_nvmf_request req = {}; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + int rc; + + req.cmd = &cmd; + req.rsp = &rsp; + + /* SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY and SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS */ + ut_reservation_init(rtype); + g_ns_info.holder_id = g_ctrlr1_A.hostid; + + /* Test Case: Issue a Read command from Host A and Host C */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + + /* Test Case: Issue a DSM Write command from Host A and Host C */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_DATASET_MANAGEMENT; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr1_A, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + + /* Unregister Host C */ + memset(&g_ns_info.reg_hostid[2], 0, sizeof(struct spdk_uuid)); + + /* Test Case: Read and Write commands from non-registrant Host C */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_C, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); +} + +static void +test_reservation_write_exclusive_regs_only_and_all_regs(void) +{ + _test_reservation_write_exclusive_regs_only_and_all_regs( + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + _test_reservation_write_exclusive_regs_only_and_all_regs( + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); +} + +static void +_test_reservation_exclusive_access_regs_only_and_all_regs(enum spdk_nvme_reservation_type rtype) +{ + struct spdk_nvmf_request req = {}; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + int rc; + + req.cmd = &cmd; + req.rsp = &rsp; + + /* SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY and SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS */ + ut_reservation_init(rtype); + g_ns_info.holder_id = g_ctrlr1_A.hostid; + + /* Test Case: Issue a Write command from Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc == 0); + + /* Unregister Host B */ + memset(&g_ns_info.reg_hostid[1], 0, sizeof(struct spdk_uuid)); + + /* Test Case: Issue a Read command from Host B */ + cmd.nvme_cmd.opc = SPDK_NVME_OPC_READ; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + cmd.nvme_cmd.opc = SPDK_NVME_OPC_WRITE; + rc = nvmf_ns_reservation_request_check(&g_ns_info, &g_ctrlr_B, &req); + SPDK_CU_ASSERT_FATAL(rc < 0); + SPDK_CU_ASSERT_FATAL(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); +} + +static void +test_reservation_exclusive_access_regs_only_and_all_regs(void) +{ + _test_reservation_exclusive_access_regs_only_and_all_regs( + SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY); + _test_reservation_exclusive_access_regs_only_and_all_regs( + SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_ALL_REGS); +} + +static void +test_reservation_notification_log_page(void) +{ + struct spdk_nvmf_ctrlr ctrlr; + struct spdk_nvmf_qpair qpair; + struct spdk_nvmf_ns ns; + struct spdk_nvmf_request req; + union nvmf_h2c_msg cmd = {}; + union nvmf_c2h_msg rsp = {}; + union spdk_nvme_async_event_completion event = {}; + struct spdk_nvme_reservation_notification_log logs[3]; + + memset(&ctrlr, 0, sizeof(ctrlr)); + ctrlr.thread = spdk_get_thread(); + TAILQ_INIT(&ctrlr.log_head); + ns.nsid = 1; + + /* Test Case: Mask all the reservation notifications */ + ns.mask = SPDK_NVME_REGISTRATION_PREEMPTED_MASK | + SPDK_NVME_RESERVATION_RELEASED_MASK | + SPDK_NVME_RESERVATION_PREEMPTED_MASK; + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_REGISTRATION_PREEMPTED); + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_RESERVATION_RELEASED); + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_RESERVATION_PREEMPTED); + poll_threads(); + SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&ctrlr.log_head)); + + /* Test Case: Unmask all the reservation notifications, + * 3 log pages are generated, and AER was triggered. + */ + ns.mask = 0; + ctrlr.num_avail_log_pages = 0; + req.cmd = &cmd; + req.rsp = &rsp; + ctrlr.aer_req[0] = &req; + ctrlr.nr_aer_reqs = 1; + req.qpair = &qpair; + TAILQ_INIT(&qpair.outstanding); + qpair.ctrlr = NULL; + qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link); + + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_REGISTRATION_PREEMPTED); + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_RESERVATION_RELEASED); + nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns, + SPDK_NVME_RESERVATION_PREEMPTED); + poll_threads(); + event.raw = rsp.nvme_cpl.cdw0; + SPDK_CU_ASSERT_FATAL(event.bits.async_event_type == SPDK_NVME_ASYNC_EVENT_TYPE_IO); + SPDK_CU_ASSERT_FATAL(event.bits.async_event_info == SPDK_NVME_ASYNC_EVENT_RESERVATION_LOG_AVAIL); + SPDK_CU_ASSERT_FATAL(event.bits.log_page_identifier == SPDK_NVME_LOG_RESERVATION_NOTIFICATION); + SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 3); + + /* Test Case: Get Log Page to clear the log pages */ + nvmf_get_reservation_notification_log_page(&ctrlr, (void *)logs, 0, sizeof(logs)); + SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 0); +} + +static void +test_get_dif_ctx(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_request req = {}; + struct spdk_nvmf_qpair qpair = {}; + struct spdk_nvmf_ctrlr ctrlr = {}; + struct spdk_nvmf_ns ns = {}; + struct spdk_nvmf_ns *_ns = NULL; + struct spdk_bdev bdev = {}; + union nvmf_h2c_msg cmd = {}; + struct spdk_dif_ctx dif_ctx = {}; + bool ret; + + ctrlr.subsys = &subsystem; + + qpair.ctrlr = &ctrlr; + + req.qpair = &qpair; + req.cmd = &cmd; + + ns.bdev = &bdev; + + ctrlr.dif_insert_or_strip = false; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + ctrlr.dif_insert_or_strip = true; + qpair.state = SPDK_NVMF_QPAIR_UNINITIALIZED; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FABRIC; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_FLUSH; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + qpair.qid = 1; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + cmd.nvme_cmd.nsid = 1; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + subsystem.max_nsid = 1; + subsystem.ns = &_ns; + subsystem.ns[0] = &ns; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == false); + + cmd.nvmf_cmd.opcode = SPDK_NVME_OPC_WRITE; + + ret = spdk_nvmf_request_get_dif_ctx(&req, &dif_ctx); + CU_ASSERT(ret == true); +} + +static void +test_identify_ctrlr(void) +{ + struct spdk_nvmf_subsystem subsystem = { + .subtype = SPDK_NVMF_SUBTYPE_NVME + }; + struct spdk_nvmf_transport_ops tops = {}; + struct spdk_nvmf_transport transport = { + .ops = &tops, + .opts = { + .in_capsule_data_size = 4096, + }, + }; + struct spdk_nvmf_qpair admin_qpair = { .transport = &transport}; + struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair }; + struct spdk_nvme_ctrlr_data cdata = {}; + uint32_t expected_ioccsz; + + nvmf_ctrlr_cdata_init(&transport, &subsystem, &ctrlr.cdata); + + /* Check ioccsz, TCP transport */ + tops.type = SPDK_NVME_TRANSPORT_TCP; + expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16; + CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz); + + /* Check ioccsz, RDMA transport */ + tops.type = SPDK_NVME_TRANSPORT_RDMA; + expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16; + CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz); + + /* Check ioccsz, TCP transport with dif_insert_or_strip */ + tops.type = SPDK_NVME_TRANSPORT_TCP; + ctrlr.dif_insert_or_strip = true; + expected_ioccsz = sizeof(struct spdk_nvme_cmd) / 16 + transport.opts.in_capsule_data_size / 16; + CU_ASSERT(spdk_nvmf_ctrlr_identify_ctrlr(&ctrlr, &cdata) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cdata.nvmf_specific.ioccsz == expected_ioccsz); +} + +static int +custom_admin_cmd_hdlr(struct spdk_nvmf_request *req) +{ + req->rsp->nvme_cpl.status.sc = SPDK_NVME_SC_SUCCESS; + + return SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE; +}; + +static void +test_custom_admin_cmd(void) +{ + struct spdk_nvmf_subsystem subsystem; + struct spdk_nvmf_qpair qpair; + struct spdk_nvmf_ctrlr ctrlr; + struct spdk_nvmf_request req; + struct spdk_nvmf_ns *ns_ptrs[1]; + struct spdk_nvmf_ns ns; + union nvmf_h2c_msg cmd; + union nvmf_c2h_msg rsp; + struct spdk_bdev bdev; + uint8_t buf[4096]; + int rc; + + memset(&subsystem, 0, sizeof(subsystem)); + ns_ptrs[0] = &ns; + subsystem.ns = ns_ptrs; + subsystem.max_nsid = 1; + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + + memset(&ns, 0, sizeof(ns)); + ns.opts.nsid = 1; + ns.bdev = &bdev; + + memset(&qpair, 0, sizeof(qpair)); + qpair.ctrlr = &ctrlr; + + memset(&ctrlr, 0, sizeof(ctrlr)); + ctrlr.subsys = &subsystem; + ctrlr.vcprop.cc.bits.en = 1; + + memset(&req, 0, sizeof(req)); + req.qpair = &qpair; + req.cmd = &cmd; + req.rsp = &rsp; + req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; + req.data = buf; + req.length = sizeof(buf); + + memset(&cmd, 0, sizeof(cmd)); + cmd.nvme_cmd.opc = 0xc1; + cmd.nvme_cmd.nsid = 0; + memset(&rsp, 0, sizeof(rsp)); + + spdk_nvmf_set_custom_admin_cmd_hdlr(cmd.nvme_cmd.opc, custom_admin_cmd_hdlr); + + /* Ensure that our hdlr is being called */ + rc = nvmf_ctrlr_process_admin_cmd(&req); + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_SUCCESS); +} + +static void +test_fused_compare_and_write(void) +{ + struct spdk_nvmf_request req = {}; + struct spdk_nvmf_qpair qpair = {}; + struct spdk_nvme_cmd cmd = {}; + union nvmf_c2h_msg rsp = {}; + struct spdk_nvmf_ctrlr ctrlr = {}; + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_ns ns = {}; + struct spdk_nvmf_ns *subsys_ns[1] = {}; + struct spdk_bdev bdev = {}; + + struct spdk_nvmf_poll_group group = {}; + struct spdk_nvmf_subsystem_poll_group sgroups = {}; + struct spdk_nvmf_subsystem_pg_ns_info ns_info = {}; + + ns.bdev = &bdev; + + subsystem.id = 0; + subsystem.max_nsid = 1; + subsys_ns[0] = &ns; + subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns; + + /* Enable controller */ + ctrlr.vcprop.cc.bits.en = 1; + ctrlr.subsys = (struct spdk_nvmf_subsystem *)&subsystem; + + group.num_sgroups = 1; + sgroups.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + sgroups.num_ns = 1; + sgroups.ns_info = &ns_info; + TAILQ_INIT(&sgroups.queued); + group.sgroups = &sgroups; + TAILQ_INIT(&qpair.outstanding); + + qpair.ctrlr = &ctrlr; + qpair.group = &group; + qpair.qid = 1; + qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + + cmd.nsid = 1; + + req.qpair = &qpair; + req.cmd = (union nvmf_h2c_msg *)&cmd; + req.rsp = &rsp; + + /* SUCCESS/SUCCESS */ + cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST; + cmd.opc = SPDK_NVME_OPC_COMPARE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(qpair.first_fused_req != NULL); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + + cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND; + cmd.opc = SPDK_NVME_OPC_WRITE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(qpair.first_fused_req == NULL); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + + /* Wrong sequence */ + cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND; + cmd.opc = SPDK_NVME_OPC_WRITE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(!nvme_status_success(&rsp.nvme_cpl.status)); + CU_ASSERT(qpair.first_fused_req == NULL); + + /* Write as FUSE_FIRST (Wrong op code) */ + cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST; + cmd.opc = SPDK_NVME_OPC_WRITE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE); + CU_ASSERT(qpair.first_fused_req == NULL); + + /* Compare as FUSE_SECOND (Wrong op code) */ + cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST; + cmd.opc = SPDK_NVME_OPC_COMPARE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(qpair.first_fused_req != NULL); + CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status)); + + cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND; + cmd.opc = SPDK_NVME_OPC_COMPARE; + + spdk_nvmf_request_exec(&req); + CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_OPCODE); + CU_ASSERT(qpair.first_fused_req == NULL); +} + +static void +test_multi_async_event_reqs(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_qpair qpair = {}; + struct spdk_nvmf_ctrlr ctrlr = {}; + struct spdk_nvmf_request req[5] = {}; + struct spdk_nvmf_ns *ns_ptrs[1] = {}; + struct spdk_nvmf_ns ns = {}; + union nvmf_h2c_msg cmd[5] = {}; + union nvmf_c2h_msg rsp[5] = {}; + + struct spdk_nvmf_poll_group group = {}; + struct spdk_nvmf_subsystem_poll_group sgroups = {}; + + int i; + + ns_ptrs[0] = &ns; + subsystem.ns = ns_ptrs; + subsystem.max_nsid = 1; + subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME; + + ns.opts.nsid = 1; + group.sgroups = &sgroups; + + qpair.ctrlr = &ctrlr; + qpair.group = &group; + TAILQ_INIT(&qpair.outstanding); + + ctrlr.subsys = &subsystem; + ctrlr.vcprop.cc.bits.en = 1; + + for (i = 0; i < 5; i++) { + cmd[i].nvme_cmd.opc = SPDK_NVME_OPC_ASYNC_EVENT_REQUEST; + cmd[i].nvme_cmd.nsid = 1; + cmd[i].nvme_cmd.cid = i; + + req[i].qpair = &qpair; + req[i].cmd = &cmd[i]; + req[i].rsp = &rsp[i]; + TAILQ_INSERT_TAIL(&qpair.outstanding, &req[i], link); + } + + /* Target can store NVMF_MAX_ASYNC_EVENTS reqs */ + sgroups.io_outstanding = NVMF_MAX_ASYNC_EVENTS; + for (i = 0; i < NVMF_MAX_ASYNC_EVENTS; i++) { + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[i]) == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(ctrlr.nr_aer_reqs == i + 1); + } + CU_ASSERT(sgroups.io_outstanding == 0); + + /* Exceeding the NVMF_MAX_ASYNC_EVENTS reports error */ + CU_ASSERT(nvmf_ctrlr_process_admin_cmd(&req[4]) == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(ctrlr.nr_aer_reqs == NVMF_MAX_ASYNC_EVENTS); + CU_ASSERT(rsp[4].nvme_cpl.status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC); + CU_ASSERT(rsp[4].nvme_cpl.status.sc = SPDK_NVME_SC_ASYNC_EVENT_REQUEST_LIMIT_EXCEEDED); + + /* Test if the aer_reqs keep continuous when abort a req in the middle */ + CU_ASSERT(nvmf_qpair_abort_aer(&qpair, 2) == true); + CU_ASSERT(ctrlr.aer_req[0] == &req[0]); + CU_ASSERT(ctrlr.aer_req[1] == &req[1]); + CU_ASSERT(ctrlr.aer_req[2] == &req[3]); + + CU_ASSERT(nvmf_qpair_abort_aer(&qpair, 3) == true); + CU_ASSERT(ctrlr.aer_req[0] == &req[0]); + CU_ASSERT(ctrlr.aer_req[1] == &req[1]); + CU_ASSERT(ctrlr.aer_req[2] == NULL); + CU_ASSERT(ctrlr.nr_aer_reqs == 2); + + TAILQ_REMOVE(&qpair.outstanding, &req[0], link); + TAILQ_REMOVE(&qpair.outstanding, &req[1], link); +} + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + CU_ADD_TEST(suite, test_get_log_page); + CU_ADD_TEST(suite, test_process_fabrics_cmd); + CU_ADD_TEST(suite, test_connect); + CU_ADD_TEST(suite, test_get_ns_id_desc_list); + CU_ADD_TEST(suite, test_identify_ns); + CU_ADD_TEST(suite, test_reservation_write_exclusive); + CU_ADD_TEST(suite, test_reservation_exclusive_access); + CU_ADD_TEST(suite, test_reservation_write_exclusive_regs_only_and_all_regs); + CU_ADD_TEST(suite, test_reservation_exclusive_access_regs_only_and_all_regs); + CU_ADD_TEST(suite, test_reservation_notification_log_page); + CU_ADD_TEST(suite, test_get_dif_ctx); + CU_ADD_TEST(suite, test_set_get_features); + CU_ADD_TEST(suite, test_identify_ctrlr); + CU_ADD_TEST(suite, test_custom_admin_cmd); + CU_ADD_TEST(suite, test_fused_compare_and_write); + CU_ADD_TEST(suite, test_multi_async_event_reqs); + + allocate_threads(1); + set_thread(0); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + + free_threads(); + + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/.gitignore b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/.gitignore new file mode 100644 index 000000000..78fca1017 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/.gitignore @@ -0,0 +1 @@ +ctrlr_bdev_ut diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/Makefile b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/Makefile new file mode 100644 index 000000000..1d22f14be --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/Makefile @@ -0,0 +1,38 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +TEST_FILE = ctrlr_bdev_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c new file mode 100644 index 000000000..0df9c983b --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_bdev.c/ctrlr_bdev_ut.c @@ -0,0 +1,415 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" + +#include "spdk_cunit.h" + +#include "spdk_internal/mock.h" + +#include "nvmf/ctrlr_bdev.c" + + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) + +DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), -1); + +DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "test"); + +struct spdk_bdev { + uint32_t blocklen; + uint64_t num_blocks; + uint32_t md_len; +}; + +uint32_t +spdk_bdev_get_block_size(const struct spdk_bdev *bdev) +{ + return bdev->blocklen; +} + +uint64_t +spdk_bdev_get_num_blocks(const struct spdk_bdev *bdev) +{ + return bdev->num_blocks; +} + +uint32_t +spdk_bdev_get_optimal_io_boundary(const struct spdk_bdev *bdev) +{ + abort(); + return 0; +} + +uint32_t +spdk_bdev_get_md_size(const struct spdk_bdev *bdev) +{ + return bdev->md_len; +} + +DEFINE_STUB(spdk_bdev_comparev_and_writev_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct iovec *compare_iov, int compare_iovcnt, + struct iovec *write_iov, int write_iovcnt, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(nvmf_ctrlr_process_io_cmd, int, (struct spdk_nvmf_request *req), 0); + +DEFINE_STUB_V(spdk_bdev_io_get_nvme_fused_status, (const struct spdk_bdev_io *bdev_io, + uint32_t *cdw0, int *cmp_sct, int *cmp_sc, int *wr_sct, int *wr_sc)); + +DEFINE_STUB(spdk_bdev_is_md_interleaved, bool, (const struct spdk_bdev *bdev), false); + +DEFINE_STUB(spdk_bdev_get_dif_type, enum spdk_dif_type, + (const struct spdk_bdev *bdev), SPDK_DIF_DISABLE); + +DEFINE_STUB(spdk_bdev_is_dif_head_of_md, bool, (const struct spdk_bdev *bdev), false); + +DEFINE_STUB(spdk_bdev_is_dif_check_enabled, bool, + (const struct spdk_bdev *bdev, enum spdk_dif_check_type check_type), false); + +DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, + (struct spdk_bdev_desc *desc), NULL); + +DEFINE_STUB(spdk_bdev_flush_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_unmap_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_io_type_supported, bool, + (struct spdk_bdev *bdev, enum spdk_bdev_io_type io_type), false); + +DEFINE_STUB(spdk_bdev_queue_io_wait, int, + (struct spdk_bdev *bdev, struct spdk_io_channel *ch, + struct spdk_bdev_io_wait_entry *entry), + 0); + +DEFINE_STUB(spdk_bdev_write_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, void *buf, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_writev_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_read_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, void *buf, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_readv_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct iovec *iov, int iovcnt, uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_write_zeroes_blocks, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + uint64_t offset_blocks, uint64_t num_blocks, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB(spdk_bdev_nvme_io_passthru, int, + (struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + const struct spdk_nvme_cmd *cmd, void *buf, size_t nbytes, + spdk_bdev_io_completion_cb cb, void *cb_arg), + 0); + +DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *bdev_io)); + +DEFINE_STUB(spdk_nvmf_subsystem_get_nqn, const char *, + (const struct spdk_nvmf_subsystem *subsystem), NULL); + +struct spdk_nvmf_ns * +spdk_nvmf_subsystem_get_ns(struct spdk_nvmf_subsystem *subsystem, uint32_t nsid) +{ + abort(); + return NULL; +} + +struct spdk_nvmf_ns * +spdk_nvmf_subsystem_get_first_ns(struct spdk_nvmf_subsystem *subsystem) +{ + abort(); + return NULL; +} + +struct spdk_nvmf_ns * +spdk_nvmf_subsystem_get_next_ns(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns) +{ + abort(); + return NULL; +} + +DEFINE_STUB_V(spdk_bdev_io_get_nvme_status, + (const struct spdk_bdev_io *bdev_io, uint32_t *cdw0, int *sct, int *sc)); + +int +spdk_dif_ctx_init(struct spdk_dif_ctx *ctx, uint32_t block_size, uint32_t md_size, + bool md_interleave, bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags, + uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag, + uint32_t data_offset, uint16_t guard_seed) +{ + ctx->block_size = block_size; + ctx->md_size = md_size; + ctx->init_ref_tag = init_ref_tag; + + return 0; +} + +static void +test_get_rw_params(void) +{ + struct spdk_nvme_cmd cmd = {0}; + uint64_t lba; + uint64_t count; + + lba = 0; + count = 0; + to_le64(&cmd.cdw10, 0x1234567890ABCDEF); + to_le32(&cmd.cdw12, 0x9875 | SPDK_NVME_IO_FLAGS_FORCE_UNIT_ACCESS); + nvmf_bdev_ctrlr_get_rw_params(&cmd, &lba, &count); + CU_ASSERT(lba == 0x1234567890ABCDEF); + CU_ASSERT(count == 0x9875 + 1); /* NOTE: this field is 0's based, hence the +1 */ +} + +static void +test_lba_in_range(void) +{ + /* Trivial cases (no overflow) */ + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1000) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 0, 1001) == false); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1, 999) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1, 1000) == false); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 999, 1) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1000, 1) == false); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(1000, 1001, 1) == false); + + /* Overflow edge cases */ + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, 0, UINT64_MAX) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, 1, UINT64_MAX) == false); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, UINT64_MAX - 1, 1) == true); + CU_ASSERT(nvmf_bdev_ctrlr_lba_in_range(UINT64_MAX, UINT64_MAX, 1) == false); +} + +static void +test_get_dif_ctx(void) +{ + struct spdk_bdev bdev = {}; + struct spdk_nvme_cmd cmd = {}; + struct spdk_dif_ctx dif_ctx = {}; + bool ret; + + bdev.md_len = 0; + + ret = nvmf_bdev_ctrlr_get_dif_ctx(&bdev, &cmd, &dif_ctx); + CU_ASSERT(ret == false); + + to_le64(&cmd.cdw10, 0x1234567890ABCDEF); + bdev.blocklen = 520; + bdev.md_len = 8; + + ret = nvmf_bdev_ctrlr_get_dif_ctx(&bdev, &cmd, &dif_ctx); + CU_ASSERT(ret == true); + CU_ASSERT(dif_ctx.block_size = 520); + CU_ASSERT(dif_ctx.md_size == 8); + CU_ASSERT(dif_ctx.init_ref_tag == 0x90ABCDEF); +} + +static void +test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd(void) +{ + int rc; + struct spdk_bdev bdev = {}; + struct spdk_bdev_desc *desc = NULL; + struct spdk_io_channel ch = {}; + + struct spdk_nvmf_request cmp_req = {}; + union nvmf_c2h_msg cmp_rsp = {}; + + struct spdk_nvmf_request write_req = {}; + union nvmf_c2h_msg write_rsp = {}; + + struct spdk_nvmf_qpair qpair = {}; + + struct spdk_nvme_cmd cmp_cmd = {}; + struct spdk_nvme_cmd write_cmd = {}; + + struct spdk_nvmf_ctrlr ctrlr = {}; + struct spdk_nvmf_subsystem subsystem = {}; + struct spdk_nvmf_ns ns = {}; + struct spdk_nvmf_ns *subsys_ns[1] = {}; + + struct spdk_nvmf_poll_group group = {}; + struct spdk_nvmf_subsystem_poll_group sgroups = {}; + struct spdk_nvmf_subsystem_pg_ns_info ns_info = {}; + + bdev.blocklen = 512; + bdev.num_blocks = 10; + ns.bdev = &bdev; + + subsystem.id = 0; + subsystem.max_nsid = 1; + subsys_ns[0] = &ns; + subsystem.ns = (struct spdk_nvmf_ns **)&subsys_ns; + + /* Enable controller */ + ctrlr.vcprop.cc.bits.en = 1; + ctrlr.subsys = &subsystem; + + group.num_sgroups = 1; + sgroups.num_ns = 1; + sgroups.ns_info = &ns_info; + group.sgroups = &sgroups; + + qpair.ctrlr = &ctrlr; + qpair.group = &group; + + cmp_req.qpair = &qpair; + cmp_req.cmd = (union nvmf_h2c_msg *)&cmp_cmd; + cmp_req.rsp = &cmp_rsp; + + cmp_cmd.nsid = 1; + cmp_cmd.fuse = SPDK_NVME_CMD_FUSE_FIRST; + cmp_cmd.opc = SPDK_NVME_OPC_COMPARE; + + write_req.qpair = &qpair; + write_req.cmd = (union nvmf_h2c_msg *)&write_cmd; + write_req.rsp = &write_rsp; + + write_cmd.nsid = 1; + write_cmd.fuse = SPDK_NVME_CMD_FUSE_SECOND; + write_cmd.opc = SPDK_NVME_OPC_WRITE; + + /* 1. SUCCESS */ + cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + cmp_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */ + + write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */ + write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen; + + rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, desc, &ch, &cmp_req, &write_req); + + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0); + CU_ASSERT(write_rsp.nvme_cpl.status.sct == 0); + CU_ASSERT(write_rsp.nvme_cpl.status.sc == 0); + + /* 2. Fused command start lba / num blocks mismatch */ + cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + cmp_cmd.cdw12 = 2; /* NLB: CDW12 bits 15:00, 0's based */ + + write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */ + write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen; + + rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, desc, &ch, &cmp_req, &write_req); + + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0); + CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_FIELD); + + /* 3. SPDK_NVME_SC_LBA_OUT_OF_RANGE */ + cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + cmp_cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */ + + write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + write_cmd.cdw12 = 100; /* NLB: CDW12 bits 15:00, 0's based */ + write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen; + + rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, desc, &ch, &cmp_req, &write_req); + + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0); + CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_LBA_OUT_OF_RANGE); + + /* 4. SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID */ + cmp_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + cmp_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */ + + write_cmd.cdw10 = 1; /* SLBA: CDW10 and CDW11 */ + write_cmd.cdw12 = 1; /* NLB: CDW12 bits 15:00, 0's based */ + write_req.length = (write_cmd.cdw12 + 1) * bdev.blocklen - 1; + + rc = nvmf_bdev_ctrlr_compare_and_write_cmd(&bdev, desc, &ch, &cmp_req, &write_req); + + CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_COMPLETE); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sct == 0); + CU_ASSERT(cmp_rsp.nvme_cpl.status.sc == 0); + CU_ASSERT(write_rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_GENERIC); + CU_ASSERT(write_rsp.nvme_cpl.status.sc == SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID); +} + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + + CU_ADD_TEST(suite, test_get_rw_params); + CU_ADD_TEST(suite, test_lba_in_range); + CU_ADD_TEST(suite, test_get_dif_ctx); + + CU_ADD_TEST(suite, test_spdk_nvmf_bdev_ctrlr_compare_and_write_cmd); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/.gitignore b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/.gitignore new file mode 100644 index 000000000..a975a97ec --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/.gitignore @@ -0,0 +1 @@ +ctrlr_discovery_ut diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/Makefile b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/Makefile new file mode 100644 index 000000000..d289bc3e8 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/Makefile @@ -0,0 +1,39 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +SPDK_LIB_LIST = json +TEST_FILE = ctrlr_discovery_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c new file mode 100644 index 000000000..29e923de8 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/ctrlr_discovery.c/ctrlr_discovery_ut.c @@ -0,0 +1,303 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" + +#include "spdk_cunit.h" +#include "spdk_internal/mock.h" + +#include "common/lib/test_env.c" +#include "nvmf/ctrlr_discovery.c" +#include "nvmf/subsystem.c" + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) + +DEFINE_STUB_V(spdk_bdev_module_release_bdev, + (struct spdk_bdev *bdev)); + +DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, + (const struct spdk_bdev *bdev), 512); + +DEFINE_STUB(spdk_nvmf_transport_stop_listen, + int, + (struct spdk_nvmf_transport *transport, + const struct spdk_nvme_transport_id *trid), 0); + +int +spdk_bdev_open(struct spdk_bdev *bdev, bool write, spdk_bdev_remove_cb_t remove_cb, + void *remove_ctx, struct spdk_bdev_desc **desc) +{ + return 0; +} + +void +spdk_bdev_close(struct spdk_bdev_desc *desc) +{ +} + +const char * +spdk_bdev_get_name(const struct spdk_bdev *bdev) +{ + return "test"; +} + +const struct spdk_uuid * +spdk_bdev_get_uuid(const struct spdk_bdev *bdev) +{ + return &bdev->uuid; +} + +int +spdk_nvmf_transport_listen(struct spdk_nvmf_transport *transport, + const struct spdk_nvme_transport_id *trid) +{ + return 0; +} + +static struct spdk_nvmf_listener g_listener = {}; + +struct spdk_nvmf_listener * +nvmf_transport_find_listener(struct spdk_nvmf_transport *transport, + const struct spdk_nvme_transport_id *trid) +{ + return &g_listener; +} + +void +nvmf_transport_listener_discover(struct spdk_nvmf_transport *transport, + struct spdk_nvme_transport_id *trid, + struct spdk_nvmf_discovery_log_page_entry *entry) +{ + entry->trtype = 42; +} + +struct spdk_nvmf_transport_ops g_transport_ops = {}; + +static struct spdk_nvmf_transport g_transport = { + .ops = &g_transport_ops +}; + +struct spdk_nvmf_transport * +spdk_nvmf_transport_create(const char *transport_name, + struct spdk_nvmf_transport_opts *tprt_opts) +{ + if (strcasecmp(transport_name, spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_RDMA))) { + return &g_transport; + } + + return NULL; +} + +struct spdk_nvmf_subsystem * +spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) +{ + return NULL; +} + +struct spdk_nvmf_transport * +spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) +{ + return &g_transport; +} + +int +spdk_nvme_transport_id_parse_trtype(enum spdk_nvme_transport_type *trtype, const char *str) +{ + if (trtype == NULL || str == NULL) { + return -EINVAL; + } + + if (strcasecmp(str, "PCIe") == 0) { + *trtype = SPDK_NVME_TRANSPORT_PCIE; + } else if (strcasecmp(str, "RDMA") == 0) { + *trtype = SPDK_NVME_TRANSPORT_RDMA; + } else { + return -ENOENT; + } + return 0; +} + +int +spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, + const struct spdk_nvme_transport_id *trid2) +{ + return 0; +} + +void +nvmf_ctrlr_ns_changed(struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid) +{ +} + +void +nvmf_ctrlr_destruct(struct spdk_nvmf_ctrlr *ctrlr) +{ +} + +int +nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem) +{ + return 0; +} + +int +nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ + return 0; +} + +void +nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +void +nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +void +nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +static void +_subsystem_add_listen_done(void *cb_arg, int status) +{ + SPDK_CU_ASSERT_FATAL(status == 0); +} + +static void +test_discovery_log(void) +{ + struct spdk_nvmf_tgt tgt = {}; + struct spdk_nvmf_subsystem *subsystem; + uint8_t buffer[8192]; + struct iovec iov; + struct spdk_nvmf_discovery_log_page *disc_log; + struct spdk_nvmf_discovery_log_page_entry *entry; + struct spdk_nvme_transport_id trid = {}; + + iov.iov_base = buffer; + iov.iov_len = 8192; + + tgt.max_subsystems = 1024; + tgt.subsystems = calloc(tgt.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); + SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); + + /* Add one subsystem and verify that the discovery log contains it */ + subsystem = spdk_nvmf_subsystem_create(&tgt, "nqn.2016-06.io.spdk:subsystem1", + SPDK_NVMF_SUBTYPE_NVME, 0); + subsystem->allow_any_host = true; + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + + trid.trtype = SPDK_NVME_TRANSPORT_RDMA; + trid.adrfam = SPDK_NVMF_ADRFAM_IPV4; + snprintf(trid.traddr, sizeof(trid.traddr), "1234"); + snprintf(trid.trsvcid, sizeof(trid.trsvcid), "5678"); + spdk_nvmf_subsystem_add_listener(subsystem, &trid, _subsystem_add_listen_done, NULL); + subsystem->state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + + /* Get only genctr (first field in the header) */ + memset(buffer, 0xCC, sizeof(buffer)); + disc_log = (struct spdk_nvmf_discovery_log_page *)buffer; + nvmf_get_discovery_log_page(&tgt, "nqn.2016-06.io.spdk:host1", &iov, 1, 0, + sizeof(disc_log->genctr)); + CU_ASSERT(disc_log->genctr == 2); /* one added subsystem and listener */ + + /* Get only the header, no entries */ + memset(buffer, 0xCC, sizeof(buffer)); + disc_log = (struct spdk_nvmf_discovery_log_page *)buffer; + nvmf_get_discovery_log_page(&tgt, "nqn.2016-06.io.spdk:host1", &iov, 1, 0, sizeof(*disc_log)); + CU_ASSERT(disc_log->genctr == 2); + CU_ASSERT(disc_log->numrec == 1); + + /* Offset 0, exact size match */ + memset(buffer, 0xCC, sizeof(buffer)); + disc_log = (struct spdk_nvmf_discovery_log_page *)buffer; + nvmf_get_discovery_log_page(&tgt, "nqn.2016-06.io.spdk:host1", &iov, 1, 0, + sizeof(*disc_log) + sizeof(disc_log->entries[0])); + CU_ASSERT(disc_log->genctr != 0); + CU_ASSERT(disc_log->numrec == 1); + CU_ASSERT(disc_log->entries[0].trtype == 42); + + /* Offset 0, oversize buffer */ + memset(buffer, 0xCC, sizeof(buffer)); + disc_log = (struct spdk_nvmf_discovery_log_page *)buffer; + nvmf_get_discovery_log_page(&tgt, "nqn.2016-06.io.spdk:host1", &iov, 1, 0, sizeof(buffer)); + CU_ASSERT(disc_log->genctr != 0); + CU_ASSERT(disc_log->numrec == 1); + CU_ASSERT(disc_log->entries[0].trtype == 42); + CU_ASSERT(spdk_mem_all_zero(buffer + sizeof(*disc_log) + sizeof(disc_log->entries[0]), + sizeof(buffer) - (sizeof(*disc_log) + sizeof(disc_log->entries[0])))); + + /* Get just the first entry, no header */ + memset(buffer, 0xCC, sizeof(buffer)); + entry = (struct spdk_nvmf_discovery_log_page_entry *)buffer; + nvmf_get_discovery_log_page(&tgt, "nqn.2016-06.io.spdk:host1", &iov, + 1, + offsetof(struct spdk_nvmf_discovery_log_page, entries[0]), + sizeof(*entry)); + CU_ASSERT(entry->trtype == 42); + subsystem->state = SPDK_NVMF_SUBSYSTEM_INACTIVE; + spdk_nvmf_subsystem_destroy(subsystem); + free(tgt.subsystems); +} + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + + CU_ADD_TEST(suite, test_discovery_log); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/fc.c/.gitignore b/src/spdk/test/unit/lib/nvmf/fc.c/.gitignore new file mode 100644 index 000000000..3895b84ab --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc.c/.gitignore @@ -0,0 +1 @@ +fc_ut diff --git a/src/spdk/test/unit/lib/nvmf/fc.c/Makefile b/src/spdk/test/unit/lib/nvmf/fc.c/Makefile new file mode 100644 index 000000000..7f54f1520 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc.c/Makefile @@ -0,0 +1,58 @@ +# +# BSD LICENSE +# +# Copyright (c) 2018 Broadcom. All Rights Reserved. +# The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../../) +include $(SPDK_ROOT_DIR)/mk/config.mk + +CFLAGS += -I$(SPDK_ROOT_DIR)/test/common/lib -I$(SPDK_ROOT_DIR)/lib \ +-I$(SPDK_ROOT_DIR)/lib/nvmf + +ifneq ($(strip $(CONFIG_FC_PATH)),) +CFLAGS += -I$(CONFIG_FC_PATH) +endif + +TEST_FILE = fc_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk + +# Disable clang warning: taking address of packed member of class or structure may result in an unaligned pointer value [-Werror,-Waddress-of-packed-member] +ifeq ($(CC),clang) + CLANG_VERSION := $(shell $(CC) -v 2>&1 | \ + sed -n "s/.*version \([0-9]*\.[0-9]*\).*/\1/p") + +CLANG_MAJOR_VERSION := $(shell echo $(CLANG_VERSION) | cut -f1 -d.) + +ifeq ($(shell test $(CLANG_MAJOR_VERSION) -ge 4 && echo 1), 1) + CFLAGS += -Wno-address-of-packed-member +endif +endif diff --git a/src/spdk/test/unit/lib/nvmf/fc.c/fc_ut.c b/src/spdk/test/unit/lib/nvmf/fc.c/fc_ut.c new file mode 100644 index 000000000..a8d4b3b96 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc.c/fc_ut.c @@ -0,0 +1,505 @@ +/* + * BSD LICENSE + * + * Copyright (c) 2018-2019 Broadcom. All Rights Reserved. + * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* NVMF FC Transport Unit Test */ + +#include "spdk/env.h" +#include "spdk_cunit.h" +#include "spdk/nvmf.h" +#include "spdk/endian.h" +#include "spdk/trace.h" +#include "spdk_internal/log.h" + +#include "ut_multithread.c" + +#include "transport.h" +#include "nvmf_internal.h" + +#include "nvmf_fc.h" + +#include "json/json_util.c" +#include "json/json_write.c" +#include "nvmf/nvmf.c" +#include "nvmf/transport.c" +#include "nvmf/subsystem.c" +#include "nvmf/fc.c" +#include "nvmf/fc_ls.c" + +/* + * SPDK Stuff + */ + +#ifdef SPDK_CONFIG_RDMA +const struct spdk_nvmf_transport_ops spdk_nvmf_transport_rdma = { + .type = SPDK_NVME_TRANSPORT_RDMA, + .opts_init = NULL, + .create = NULL, + .destroy = NULL, + + .listen = NULL, + .stop_listen = NULL, + .accept = NULL, + + .listener_discover = NULL, + + .poll_group_create = NULL, + .poll_group_destroy = NULL, + .poll_group_add = NULL, + .poll_group_poll = NULL, + + .req_free = NULL, + .req_complete = NULL, + + .qpair_fini = NULL, + .qpair_get_peer_trid = NULL, + .qpair_get_local_trid = NULL, + .qpair_get_listen_trid = NULL, +}; +#endif + +const struct spdk_nvmf_transport_ops spdk_nvmf_transport_tcp = { + .type = SPDK_NVME_TRANSPORT_TCP, +}; + +struct spdk_trace_histories *g_trace_histories; + +DEFINE_STUB_V(_spdk_trace_record, (uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id, + uint32_t size, uint64_t object_id, uint64_t arg1)); +DEFINE_STUB(spdk_nvme_transport_id_compare, int, + (const struct spdk_nvme_transport_id *trid1, + const struct spdk_nvme_transport_id *trid2), 0); +DEFINE_STUB_V(spdk_trace_register_object, (uint8_t type, char id_prefix)); +DEFINE_STUB_V(spdk_trace_register_description, + (const char *name, uint16_t tpoint_id, uint8_t owner_type, + uint8_t object_type, uint8_t new_object, uint8_t arg1_type, + const char *arg1_name)); +DEFINE_STUB_V(spdk_trace_add_register_fn, (struct spdk_trace_register_fn *reg_fn)); +DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), "fc_ut_test"); +DEFINE_STUB_V(nvmf_ctrlr_destruct, (struct spdk_nvmf_ctrlr *ctrlr)); +DEFINE_STUB_V(nvmf_qpair_free_aer, (struct spdk_nvmf_qpair *qpair)); +DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc), + NULL); +DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req)); +DEFINE_STUB_V(nvmf_ctrlr_ns_changed, (struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid)); +DEFINE_STUB(spdk_bdev_open, int, (struct spdk_bdev *bdev, bool write, + spdk_bdev_remove_cb_t remove_cb, + void *remove_ctx, struct spdk_bdev_desc **desc), 0); +DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); +DEFINE_STUB(spdk_bdev_module_claim_bdev, int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, + struct spdk_bdev_module *module), 0); +DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); +DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, (const struct spdk_bdev *bdev), 512); +DEFINE_STUB(spdk_bdev_get_num_blocks, uint64_t, (const struct spdk_bdev *bdev), 1024); + +DEFINE_STUB(nvmf_ctrlr_async_event_ns_notice, int, (struct spdk_nvmf_ctrlr *ctrlr), 0); +DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, + enum spdk_nvme_transport_type trtype)); +DEFINE_STUB_V(spdk_nvmf_ctrlr_data_init, (struct spdk_nvmf_transport_opts *opts, + struct spdk_nvmf_ctrlr_data *cdata)); +DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), + -ENOSPC); + +const char * +spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype) +{ + switch (trtype) { + case SPDK_NVME_TRANSPORT_PCIE: + return "PCIe"; + case SPDK_NVME_TRANSPORT_RDMA: + return "RDMA"; + case SPDK_NVME_TRANSPORT_FC: + return "FC"; + default: + return NULL; + } +} + +const char * +spdk_nvme_transport_id_adrfam_str(enum spdk_nvmf_adrfam adrfam) +{ + switch (adrfam) { + case SPDK_NVMF_ADRFAM_IPV4: + return "IPv4"; + case SPDK_NVMF_ADRFAM_IPV6: + return "IPv6"; + case SPDK_NVMF_ADRFAM_IB: + return "IB"; + case SPDK_NVMF_ADRFAM_FC: + return "FC"; + default: + return NULL; + } +} + +const struct spdk_uuid * +spdk_bdev_get_uuid(const struct spdk_bdev *bdev) +{ + return &bdev->uuid; +} + +static bool g_lld_init_called = false; + +int +nvmf_fc_lld_init(void) +{ + g_lld_init_called = true; + return 0; +} + +static bool g_lld_fini_called = false; + +void +nvmf_fc_lld_fini(void) +{ + g_lld_fini_called = true; +} + +DEFINE_STUB_V(nvmf_fc_lld_start, (void)); +DEFINE_STUB(nvmf_fc_init_q, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0); +DEFINE_STUB_V(nvmf_fc_reinit_q, (void *queues_prev, void *queues_curr)); +DEFINE_STUB(nvmf_fc_init_rqpair_buffers, int, (struct spdk_nvmf_fc_hwqp *hwqp), 0); +DEFINE_STUB(nvmf_fc_set_q_online_state, int, (struct spdk_nvmf_fc_hwqp *hwqp, bool online), 0); +DEFINE_STUB(nvmf_fc_put_xchg, int, (struct spdk_nvmf_fc_hwqp *hwqp, struct spdk_nvmf_fc_xchg *xri), + 0); +DEFINE_STUB(nvmf_fc_recv_data, int, (struct spdk_nvmf_fc_request *fc_req), 0); +DEFINE_STUB(nvmf_fc_send_data, int, (struct spdk_nvmf_fc_request *fc_req), 0); +DEFINE_STUB_V(nvmf_fc_rqpair_buffer_release, (struct spdk_nvmf_fc_hwqp *hwqp, uint16_t buff_idx)); +DEFINE_STUB(nvmf_fc_xmt_rsp, int, (struct spdk_nvmf_fc_request *fc_req, uint8_t *ersp_buf, + uint32_t ersp_len), 0); +DEFINE_STUB(nvmf_fc_xmt_ls_rsp, int, (struct spdk_nvmf_fc_nport *tgtport, + struct spdk_nvmf_fc_ls_rqst *ls_rqst), 0); +DEFINE_STUB(nvmf_fc_issue_abort, int, (struct spdk_nvmf_fc_hwqp *hwqp, + struct spdk_nvmf_fc_xchg *xri, + spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); +DEFINE_STUB(nvmf_fc_xmt_bls_rsp, int, (struct spdk_nvmf_fc_hwqp *hwqp, + uint16_t ox_id, uint16_t rx_id, + uint16_t rpi, bool rjt, uint8_t rjt_exp, + spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); +DEFINE_STUB(nvmf_fc_alloc_srsr_bufs, struct spdk_nvmf_fc_srsr_bufs *, (size_t rqst_len, + size_t rsp_len), NULL); +DEFINE_STUB_V(nvmf_fc_free_srsr_bufs, (struct spdk_nvmf_fc_srsr_bufs *srsr_bufs)); +DEFINE_STUB(nvmf_fc_xmt_srsr_req, int, (struct spdk_nvmf_fc_hwqp *hwqp, + struct spdk_nvmf_fc_srsr_bufs *xmt_srsr_bufs, + spdk_nvmf_fc_caller_cb cb, void *cb_args), 0); +DEFINE_STUB(nvmf_fc_q_sync_available, bool, (void), true); +DEFINE_STUB(nvmf_fc_issue_q_sync, int, (struct spdk_nvmf_fc_hwqp *hwqp, uint64_t u_id, + uint16_t skip_rq), 0); +DEFINE_STUB(nvmf_fc_assign_conn_to_hwqp, bool, (struct spdk_nvmf_fc_hwqp *hwqp, + uint64_t *conn_id, uint32_t sq_size), true); +DEFINE_STUB(nvmf_fc_get_hwqp_from_conn_id, struct spdk_nvmf_fc_hwqp *, + (struct spdk_nvmf_fc_hwqp *queues, + uint32_t num_queues, uint64_t conn_id), NULL); +DEFINE_STUB_V(nvmf_fc_release_conn, (struct spdk_nvmf_fc_hwqp *hwqp, uint64_t conn_id, + uint32_t sq_size)); +DEFINE_STUB_V(nvmf_fc_dump_all_queues, (struct spdk_nvmf_fc_hwqp *ls_queue, + struct spdk_nvmf_fc_hwqp *io_queues, + uint32_t num_io_queues, + struct spdk_nvmf_fc_queue_dump_info *dump_info)); +DEFINE_STUB_V(nvmf_fc_get_xri_info, (struct spdk_nvmf_fc_hwqp *hwqp, + struct spdk_nvmf_fc_xchg_info *info)); +DEFINE_STUB(nvmf_fc_get_rsvd_thread, struct spdk_thread *, (void), NULL); + +uint32_t +nvmf_fc_process_queue(struct spdk_nvmf_fc_hwqp *hwqp) +{ + hwqp->lcore_id++; + return 0; /* always return 0 or else it will poll forever */ +} + +struct spdk_nvmf_fc_xchg * +nvmf_fc_get_xri(struct spdk_nvmf_fc_hwqp *hwqp) +{ + static struct spdk_nvmf_fc_xchg xchg; + + xchg.xchg_id = 1; + return &xchg; +} + +#define MAX_FC_UT_POLL_THREADS 8 +static struct spdk_nvmf_poll_group *g_poll_groups[MAX_FC_UT_POLL_THREADS] = {0}; +#define MAX_FC_UT_HWQPS MAX_FC_UT_POLL_THREADS +static struct spdk_nvmf_tgt *g_nvmf_tgt = NULL; +static struct spdk_nvmf_transport *g_nvmf_tprt = NULL; +uint8_t g_fc_port_handle = 0xff; +struct spdk_nvmf_fc_hwqp lld_q[MAX_FC_UT_HWQPS]; + +static void +_add_transport_done(void *arg, int status) +{ + CU_ASSERT(status == 0); +} + +static void +_add_transport_done_dup_err(void *arg, int status) +{ + CU_ASSERT(status == -EEXIST); +} + +static void +create_transport_test(void) +{ + const struct spdk_nvmf_transport_ops *ops = NULL; + struct spdk_nvmf_transport_opts opts = { 0 }; + struct spdk_nvmf_target_opts tgt_opts = { + .name = "nvmf_test_tgt", + .max_subsystems = 0 + }; + + allocate_threads(8); + set_thread(0); + + g_nvmf_tgt = spdk_nvmf_tgt_create(&tgt_opts); + SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL); + + ops = nvmf_get_transport_ops(SPDK_NVME_TRANSPORT_NAME_FC); + SPDK_CU_ASSERT_FATAL(ops != NULL); + + ops->opts_init(&opts); + + g_lld_init_called = false; + g_nvmf_tprt = spdk_nvmf_transport_create("FC", &opts); + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + CU_ASSERT(g_lld_init_called == true); + CU_ASSERT(opts.max_queue_depth == g_nvmf_tprt->opts.max_queue_depth); + CU_ASSERT(opts.max_qpairs_per_ctrlr == g_nvmf_tprt->opts.max_qpairs_per_ctrlr); + CU_ASSERT(opts.in_capsule_data_size == g_nvmf_tprt->opts.in_capsule_data_size); + CU_ASSERT(opts.max_io_size == g_nvmf_tprt->opts.max_io_size); + CU_ASSERT(opts.io_unit_size == g_nvmf_tprt->opts.io_unit_size); + CU_ASSERT(opts.max_aq_depth == g_nvmf_tprt->opts.max_aq_depth); + + set_thread(0); + + spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt, + _add_transport_done, 0); + poll_thread(0); + + /* Add transport again - should get error */ + spdk_nvmf_tgt_add_transport(g_nvmf_tgt, g_nvmf_tprt, + _add_transport_done_dup_err, 0); + poll_thread(0); + + /* create transport with bad args/options */ +#ifndef SPDK_CONFIG_RDMA + CU_ASSERT(spdk_nvmf_transport_create("RDMA", &opts) == NULL); +#endif + CU_ASSERT(spdk_nvmf_transport_create("Bogus Transport", &opts) == NULL); + opts.max_io_size = 1024 ^ 3; + CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL); + opts.max_io_size = 999; + opts.io_unit_size = 1024; + CU_ASSERT(spdk_nvmf_transport_create("FC", &opts) == NULL); +} + +static void +port_init_cb(uint8_t port_handle, enum spdk_fc_event event_type, void *arg, int err) +{ + CU_ASSERT(err == 0); + CU_ASSERT(port_handle == 2); + g_fc_port_handle = port_handle; +} + +static void +create_fc_port_test(void) +{ + struct spdk_nvmf_fc_hw_port_init_args init_args = { 0 }; + struct spdk_nvmf_fc_port *fc_port = NULL; + int err; + + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + init_args.port_handle = 2; + init_args.io_queue_cnt = spdk_min(MAX_FC_UT_HWQPS, spdk_env_get_core_count()); + init_args.ls_queue_size = 100; + init_args.io_queue_size = 100; + init_args.io_queues = (void *)lld_q; + + set_thread(0); + err = nvmf_fc_master_enqueue_event(SPDK_FC_HW_PORT_INIT, (void *)&init_args, port_init_cb); + CU_ASSERT(err == 0); + poll_thread(0); + + fc_port = nvmf_fc_port_lookup(g_fc_port_handle); + CU_ASSERT(fc_port != NULL); +} + +static void +online_fc_port_test(void) +{ + struct spdk_nvmf_fc_port *fc_port; + struct spdk_nvmf_fc_hw_port_online_args args; + int err; + + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + fc_port = nvmf_fc_port_lookup(g_fc_port_handle); + SPDK_CU_ASSERT_FATAL(fc_port != NULL); + + set_thread(0); + args.port_handle = g_fc_port_handle; + err = nvmf_fc_master_enqueue_event(SPDK_FC_HW_PORT_ONLINE, (void *)&args, port_init_cb); + CU_ASSERT(err == 0); + poll_threads(); + set_thread(0); + if (err == 0) { + uint32_t i; + for (i = 0; i < fc_port->num_io_queues; i++) { + CU_ASSERT(fc_port->io_queues[i].fgroup != 0); + CU_ASSERT(fc_port->io_queues[i].fgroup != 0); + CU_ASSERT(fc_port->io_queues[i].fgroup->hwqp_count != 0); + } + } +} + +static void +create_poll_groups_test(void) +{ + unsigned i; + + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) { + set_thread(i); + g_poll_groups[i] = spdk_nvmf_poll_group_create(g_nvmf_tgt); + poll_thread(i); + CU_ASSERT(g_poll_groups[i] != NULL); + } + set_thread(0); +} + +static void +poll_group_poll_test(void) +{ + unsigned i; + unsigned poll_cnt = 10; + struct spdk_nvmf_fc_port *fc_port = NULL; + + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + set_thread(0); + fc_port = nvmf_fc_port_lookup(g_fc_port_handle); + SPDK_CU_ASSERT_FATAL(fc_port != NULL); + + for (i = 0; i < fc_port->num_io_queues; i++) { + fc_port->io_queues[i].lcore_id = 0; + } + + for (i = 0; i < poll_cnt; i++) { + /* this should cause spdk_nvmf_fc_poll_group_poll to be called() */ + poll_threads(); + } + + /* check if hwqp's lcore_id has been updated */ + for (i = 0; i < fc_port->num_io_queues; i++) { + CU_ASSERT(fc_port->io_queues[i].lcore_id == poll_cnt); + } +} + +static void +remove_hwqps_from_poll_groups_test(void) +{ + unsigned i; + struct spdk_nvmf_fc_port *fc_port = NULL; + + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + fc_port = nvmf_fc_port_lookup(g_fc_port_handle); + SPDK_CU_ASSERT_FATAL(fc_port != NULL); + + for (i = 0; i < fc_port->num_io_queues; i++) { + nvmf_fc_poll_group_remove_hwqp(&fc_port->io_queues[i]); + poll_threads(); + CU_ASSERT(fc_port->io_queues[i].fgroup == 0); + } +} + +static void +destroy_transport_test(void) +{ + unsigned i; + + set_thread(0); + SPDK_CU_ASSERT_FATAL(g_nvmf_tprt != NULL); + + for (i = 0; i < MAX_FC_UT_POLL_THREADS; i++) { + set_thread(i); + spdk_nvmf_poll_group_destroy(g_poll_groups[i], NULL, NULL); + poll_thread(0); + } + + SPDK_CU_ASSERT_FATAL(g_nvmf_tgt != NULL); + g_lld_fini_called = false; + spdk_nvmf_tgt_destroy(g_nvmf_tgt, NULL, NULL); + poll_threads(); + CU_ASSERT(g_lld_fini_called == true); +} + +static int +nvmf_fc_tests_init(void) +{ + return 0; +} + +static int +nvmf_fc_tests_fini(void) +{ + free_threads(); + return 0; +} + +int main(int argc, char **argv) +{ + unsigned int num_failures = 0; + CU_pSuite suite = NULL; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("NVMf-FC", nvmf_fc_tests_init, nvmf_fc_tests_fini); + + CU_ADD_TEST(suite, create_transport_test); + CU_ADD_TEST(suite, create_poll_groups_test); + CU_ADD_TEST(suite, create_fc_port_test); + CU_ADD_TEST(suite, online_fc_port_test); + CU_ADD_TEST(suite, poll_group_poll_test); + CU_ADD_TEST(suite, remove_hwqps_from_poll_groups_test); + CU_ADD_TEST(suite, destroy_transport_test); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/fc_ls.c/.gitignore b/src/spdk/test/unit/lib/nvmf/fc_ls.c/.gitignore new file mode 100644 index 000000000..ac5b0c40e --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc_ls.c/.gitignore @@ -0,0 +1 @@ +fc_ls_ut diff --git a/src/spdk/test/unit/lib/nvmf/fc_ls.c/Makefile b/src/spdk/test/unit/lib/nvmf/fc_ls.c/Makefile new file mode 100644 index 000000000..d9143e627 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc_ls.c/Makefile @@ -0,0 +1,45 @@ +# +# BSD LICENSE +# +# Copyright (c) 2018 Broadcom. All Rights Reserved. +# The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../../) +include $(SPDK_ROOT_DIR)/mk/config.mk + +CFLAGS += -I$(SPDK_ROOT_DIR)/test/common/lib -I$(SPDK_ROOT_DIR)/lib/nvmf + +ifneq ($(strip $(CONFIG_FC_PATH)),) +CFLAGS += -I$(CONFIG_FC_PATH) +endif + +TEST_FILE = fc_ls_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/fc_ls.c/fc_ls_ut.c b/src/spdk/test/unit/lib/nvmf/fc_ls.c/fc_ls_ut.c new file mode 100644 index 000000000..68eb81960 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/fc_ls.c/fc_ls_ut.c @@ -0,0 +1,1070 @@ +/* + * BSD LICENSE + * + * Copyright (c) 2018-2019 Broadcom. All Rights Reserved. + * The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/* NVMF FC LS Command Processor Unit Test */ + +#include "spdk/env.h" +#include "spdk_cunit.h" +#include "spdk/nvmf.h" +#include "spdk/endian.h" +#include "spdk/trace.h" +#include "spdk_internal/log.h" + +#include "ut_multithread.c" + +#include "transport.h" +#include "nvmf_internal.h" +#include "nvmf_fc.h" + +#include "fc_ls.c" + +#define LAST_RSLT_STOP_TEST 999 + +void spdk_set_thread(struct spdk_thread *thread); + +/* + * SPDK Stuff + */ + +DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), -ENOSPC); +DEFINE_STUB(spdk_nvmf_subsystem_host_allowed, bool, + (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn), true); +DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, + enum spdk_nvme_transport_type trtype)); + +static const char *fc_ut_subsystem_nqn = + "nqn.2017-11.io.spdk:sn.390c0dc7c87011e786b300a0989adc53:subsystem.good"; +static struct spdk_nvmf_host fc_ut_initiator = { + .nqn = "nqn.2017-11.fc_host", +}; +static struct spdk_nvmf_host *fc_ut_host = &fc_ut_initiator; +static struct spdk_nvmf_tgt g_nvmf_tgt; +static struct spdk_nvmf_transport_opts g_nvmf_transport_opts = { + .max_queue_depth = 128, + .max_qpairs_per_ctrlr = 4, + .max_aq_depth = 32, +}; +static uint32_t g_hw_queue_depth = 1024; +static struct spdk_nvmf_subsystem g_nvmf_subsystem; + +void nvmf_fc_request_abort(struct spdk_nvmf_fc_request *fc_req, bool send_abts, + spdk_nvmf_fc_caller_cb cb, void *cb_args); +void spdk_bdev_io_abort(struct spdk_bdev_io *bdev_io, void *ctx); +void nvmf_fc_request_abort_complete(void *arg1); +bool nvmf_fc_req_in_xfer(struct spdk_nvmf_fc_request *fc_req); + +struct spdk_nvmf_subsystem * +spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) +{ + if (!strcmp(subnqn, g_nvmf_subsystem.subnqn)) { + return &g_nvmf_subsystem; + } + return NULL; +} + +int +spdk_nvmf_poll_group_add(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_qpair *qpair) +{ + qpair->state = SPDK_NVMF_QPAIR_ACTIVE; + return 0; +} + +const struct spdk_nvmf_transport_ops spdk_nvmf_transport_fc = { + .type = (enum spdk_nvme_transport_type) SPDK_NVMF_TRTYPE_FC, + .create = NULL, + .destroy = NULL, + + .listen = NULL, + .stop_listen = NULL, + .accept = NULL, + + .listener_discover = NULL, + + .poll_group_create = NULL, + .poll_group_destroy = NULL, + .poll_group_add = NULL, + .poll_group_poll = NULL, + + .req_complete = NULL, + + .qpair_fini = NULL, + +}; + +struct spdk_nvmf_transport g_nvmf_transport = { + .ops = &spdk_nvmf_transport_fc, + .tgt = &g_nvmf_tgt, +}; + +struct spdk_nvmf_transport * +spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) +{ + return &g_nvmf_transport; +} + +int +spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) +{ + cb_fn(ctx); + return 0; +} + +void +spdk_nvmf_tgt_new_qpair(struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair) +{ + uint32_t i; + struct spdk_nvmf_fc_conn *fc_conn; + struct spdk_nvmf_fc_hwqp *hwqp = NULL, *sel_hwqp = NULL; + struct spdk_nvmf_fc_ls_add_conn_api_data *api_data = NULL; + struct spdk_nvmf_fc_port *fc_port; + + fc_conn = SPDK_CONTAINEROF(qpair, struct spdk_nvmf_fc_conn, qpair); + api_data = &fc_conn->create_opd->u.add_conn; + + /* Pick a hwqp with least load */ + fc_port = fc_conn->fc_assoc->tgtport->fc_port; + for (i = 0; i < fc_port->num_io_queues; i ++) { + hwqp = &fc_port->io_queues[i]; + if (!sel_hwqp || (hwqp->rq_size > sel_hwqp->rq_size)) { + sel_hwqp = hwqp; + } + } + + if (!nvmf_fc_assign_conn_to_hwqp(sel_hwqp, + &fc_conn->conn_id, + fc_conn->max_queue_depth)) { + goto err; + } + + fc_conn->hwqp = sel_hwqp; + + /* If this is for ADMIN connection, then update assoc ID. */ + if (fc_conn->qpair.qid == 0) { + fc_conn->fc_assoc->assoc_id = fc_conn->conn_id; + } + + nvmf_fc_poller_api_func(sel_hwqp, SPDK_NVMF_FC_POLLER_API_ADD_CONNECTION, &api_data->args); + + return; +err: + nvmf_fc_ls_add_conn_failure(api_data->assoc, api_data->ls_rqst, + api_data->args.fc_conn, api_data->aq_conn); +} + +struct spdk_nvmf_fc_conn * +nvmf_fc_hwqp_find_fc_conn(struct spdk_nvmf_fc_hwqp *hwqp, uint64_t conn_id) +{ + struct spdk_nvmf_fc_conn *fc_conn; + + TAILQ_FOREACH(fc_conn, &hwqp->connection_list, link) { + if (fc_conn->conn_id == conn_id) { + return fc_conn; + } + } + + return NULL; +} + +/* + * LLD functions + */ + +static inline uint64_t +nvmf_fc_gen_conn_id(uint32_t qnum, struct spdk_nvmf_fc_hwqp *hwqp) +{ + static uint16_t conn_cnt = 0; + return ((uint64_t) qnum | (conn_cnt++ << 8)); +} + +bool +nvmf_fc_assign_conn_to_hwqp(struct spdk_nvmf_fc_hwqp *hwqp, + uint64_t *conn_id, uint32_t sq_size) +{ + SPDK_DEBUGLOG(SPDK_LOG_NVMF_FC_LS, "Assign connection to HWQP\n"); + + + if (hwqp->rq_size < sq_size) { + return false; /* queue has no space for this connection */ + } + + hwqp->rq_size -= sq_size; + hwqp->num_conns++; + + /* create connection ID */ + *conn_id = nvmf_fc_gen_conn_id(hwqp->hwqp_id, hwqp); + + SPDK_DEBUGLOG(SPDK_LOG_NVMF_FC_LS, + "New connection assigned to HWQP%d (free %d), conn_id 0x%lx\n", + hwqp->hwqp_id, hwqp->rq_size, *conn_id); + return true; +} + +struct spdk_nvmf_fc_hwqp * +nvmf_fc_get_hwqp_from_conn_id(struct spdk_nvmf_fc_hwqp *queues, + uint32_t num_queues, uint64_t conn_id) +{ + return &queues[(conn_id & 0xff) % num_queues]; +} + +void +nvmf_fc_release_conn(struct spdk_nvmf_fc_hwqp *hwqp, uint64_t conn_id, + uint32_t sq_size) +{ + hwqp->rq_size += sq_size; +} + +struct spdk_nvmf_fc_srsr_bufs * +nvmf_fc_alloc_srsr_bufs(size_t rqst_len, size_t rsp_len) +{ + struct spdk_nvmf_fc_srsr_bufs *srsr_bufs; + + srsr_bufs = calloc(1, sizeof(struct spdk_nvmf_fc_srsr_bufs)); + if (!srsr_bufs) { + return NULL; + } + + srsr_bufs->rqst = calloc(1, rqst_len + rsp_len); + if (srsr_bufs->rqst) { + srsr_bufs->rqst_len = rqst_len; + srsr_bufs->rsp = srsr_bufs->rqst + rqst_len; + srsr_bufs->rsp_len = rsp_len; + } else { + free(srsr_bufs); + srsr_bufs = NULL; + } + + return srsr_bufs; +} + +void +nvmf_fc_free_srsr_bufs(struct spdk_nvmf_fc_srsr_bufs *srsr_bufs) +{ + if (srsr_bufs) { + free(srsr_bufs->rqst); + free(srsr_bufs); + } +} + +/* + * The Tests + */ + +enum _test_run_type { + TEST_RUN_TYPE_CREATE_ASSOC = 1, + TEST_RUN_TYPE_CREATE_CONN, + TEST_RUN_TYPE_DISCONNECT, + TEST_RUN_TYPE_CONN_BAD_ASSOC, + TEST_RUN_TYPE_FAIL_LS_RSP, + TEST_RUN_TYPE_DISCONNECT_BAD_ASSOC, + TEST_RUN_TYPE_CREATE_MAX_ASSOC, +}; + +static uint32_t g_test_run_type = 0; +static uint64_t g_curr_assoc_id = 0; +static uint16_t g_create_conn_test_cnt = 0; +static uint16_t g_max_assoc_conn_test = 0; +static int g_last_rslt = 0; +static bool g_spdk_nvmf_fc_xmt_srsr_req = false; +static struct spdk_nvmf_fc_remote_port_info g_rem_port; + +static void +run_create_assoc_test(const char *subnqn, + struct spdk_nvmf_host *host, + struct spdk_nvmf_fc_nport *tgt_port) +{ + struct spdk_nvmf_fc_ls_rqst ls_rqst; + struct spdk_nvmf_fc_ls_cr_assoc_rqst ca_rqst; + uint8_t respbuf[128]; + + memset(&ca_rqst, 0, sizeof(struct spdk_nvmf_fc_ls_cr_assoc_rqst)); + + ca_rqst.w0.ls_cmd = FCNVME_LS_CREATE_ASSOCIATION; + to_be32(&ca_rqst.desc_list_len, + sizeof(struct spdk_nvmf_fc_ls_cr_assoc_rqst) - + (2 * sizeof(uint32_t))); + to_be32(&ca_rqst.assoc_cmd.desc_tag, FCNVME_LSDESC_CREATE_ASSOC_CMD); + to_be32(&ca_rqst.assoc_cmd.desc_len, + sizeof(struct spdk_nvmf_fc_lsdesc_cr_assoc_cmd) - + (2 * sizeof(uint32_t))); + to_be16(&ca_rqst.assoc_cmd.ersp_ratio, (g_nvmf_transport.opts.max_aq_depth / 2)); + to_be16(&ca_rqst.assoc_cmd.sqsize, g_nvmf_transport.opts.max_aq_depth - 1); + snprintf(&ca_rqst.assoc_cmd.subnqn[0], strlen(subnqn) + 1, "%s", subnqn); + snprintf(&ca_rqst.assoc_cmd.hostnqn[0], strlen(host->nqn) + 1, "%s", host->nqn); + ls_rqst.rqstbuf.virt = &ca_rqst; + ls_rqst.rspbuf.virt = respbuf; + ls_rqst.rqst_len = sizeof(struct spdk_nvmf_fc_ls_cr_assoc_rqst); + ls_rqst.rsp_len = 0; + ls_rqst.rpi = 5000; + ls_rqst.private_data = NULL; + ls_rqst.s_id = 0; + ls_rqst.nport = tgt_port; + ls_rqst.rport = &g_rem_port; + ls_rqst.nvmf_tgt = &g_nvmf_tgt; + + nvmf_fc_handle_ls_rqst(&ls_rqst); + poll_thread(0); +} + +static void +run_create_conn_test(struct spdk_nvmf_host *host, + struct spdk_nvmf_fc_nport *tgt_port, + uint64_t assoc_id, + uint16_t qid) +{ + struct spdk_nvmf_fc_ls_rqst ls_rqst; + struct spdk_nvmf_fc_ls_cr_conn_rqst cc_rqst; + uint8_t respbuf[128]; + + memset(&cc_rqst, 0, sizeof(struct spdk_nvmf_fc_ls_cr_conn_rqst)); + + /* fill in request descriptor */ + cc_rqst.w0.ls_cmd = FCNVME_LS_CREATE_CONNECTION; + to_be32(&cc_rqst.desc_list_len, + sizeof(struct spdk_nvmf_fc_ls_cr_conn_rqst) - + (2 * sizeof(uint32_t))); + + /* fill in connect command descriptor */ + to_be32(&cc_rqst.connect_cmd.desc_tag, FCNVME_LSDESC_CREATE_CONN_CMD); + to_be32(&cc_rqst.connect_cmd.desc_len, + sizeof(struct spdk_nvmf_fc_lsdesc_cr_conn_cmd) - + (2 * sizeof(uint32_t))); + + to_be16(&cc_rqst.connect_cmd.ersp_ratio, (g_nvmf_transport.opts.max_queue_depth / 2)); + to_be16(&cc_rqst.connect_cmd.sqsize, g_nvmf_transport.opts.max_queue_depth - 1); + to_be16(&cc_rqst.connect_cmd.qid, qid); + + /* fill in association id descriptor */ + to_be32(&cc_rqst.assoc_id.desc_tag, FCNVME_LSDESC_ASSOC_ID), + to_be32(&cc_rqst.assoc_id.desc_len, + sizeof(struct spdk_nvmf_fc_lsdesc_assoc_id) - + (2 * sizeof(uint32_t))); + cc_rqst.assoc_id.association_id = assoc_id; /* alreday be64 */ + + ls_rqst.rqstbuf.virt = &cc_rqst; + ls_rqst.rspbuf.virt = respbuf; + ls_rqst.rqst_len = sizeof(struct spdk_nvmf_fc_ls_cr_conn_rqst); + ls_rqst.rsp_len = 0; + ls_rqst.rpi = 5000; + ls_rqst.private_data = NULL; + ls_rqst.s_id = 0; + ls_rqst.nport = tgt_port; + ls_rqst.rport = &g_rem_port; + ls_rqst.nvmf_tgt = &g_nvmf_tgt; + + nvmf_fc_handle_ls_rqst(&ls_rqst); + poll_thread(0); +} + +static void +run_disconn_test(struct spdk_nvmf_fc_nport *tgt_port, + uint64_t assoc_id) +{ + struct spdk_nvmf_fc_ls_rqst ls_rqst; + struct spdk_nvmf_fc_ls_disconnect_rqst dc_rqst; + uint8_t respbuf[128]; + + memset(&dc_rqst, 0, sizeof(struct spdk_nvmf_fc_ls_disconnect_rqst)); + + /* fill in request descriptor */ + dc_rqst.w0.ls_cmd = FCNVME_LS_DISCONNECT; + to_be32(&dc_rqst.desc_list_len, + sizeof(struct spdk_nvmf_fc_ls_disconnect_rqst) - + (2 * sizeof(uint32_t))); + + /* fill in disconnect command descriptor */ + to_be32(&dc_rqst.disconn_cmd.desc_tag, FCNVME_LSDESC_DISCONN_CMD); + to_be32(&dc_rqst.disconn_cmd.desc_len, + sizeof(struct spdk_nvmf_fc_lsdesc_disconn_cmd) - + (2 * sizeof(uint32_t))); + + /* fill in association id descriptor */ + to_be32(&dc_rqst.assoc_id.desc_tag, FCNVME_LSDESC_ASSOC_ID), + to_be32(&dc_rqst.assoc_id.desc_len, + sizeof(struct spdk_nvmf_fc_lsdesc_assoc_id) - + (2 * sizeof(uint32_t))); + dc_rqst.assoc_id.association_id = assoc_id; /* alreday be64 */ + + ls_rqst.rqstbuf.virt = &dc_rqst; + ls_rqst.rspbuf.virt = respbuf; + ls_rqst.rqst_len = sizeof(struct spdk_nvmf_fc_ls_disconnect_rqst); + ls_rqst.rsp_len = 0; + ls_rqst.rpi = 5000; + ls_rqst.private_data = NULL; + ls_rqst.s_id = 0; + ls_rqst.nport = tgt_port; + ls_rqst.rport = &g_rem_port; + ls_rqst.nvmf_tgt = &g_nvmf_tgt; + + nvmf_fc_handle_ls_rqst(&ls_rqst); + poll_thread(0); +} + +static void +disconnect_assoc_cb(void *cb_data, uint32_t err) +{ + CU_ASSERT(err == 0); +} + +static int +handle_ca_rsp(struct spdk_nvmf_fc_ls_rqst *ls_rqst, bool max_assoc_test) +{ + struct spdk_nvmf_fc_ls_acc_hdr *acc_hdr = + (struct spdk_nvmf_fc_ls_acc_hdr *) ls_rqst->rspbuf.virt; + + + if (acc_hdr->rqst.w0.ls_cmd == FCNVME_LS_CREATE_ASSOCIATION) { + if (acc_hdr->w0.ls_cmd == FCNVME_LS_ACC) { + struct spdk_nvmf_fc_ls_cr_assoc_acc *acc = + (struct spdk_nvmf_fc_ls_cr_assoc_acc *)ls_rqst->rspbuf.virt; + + CU_ASSERT(from_be32(&acc_hdr->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_cr_assoc_acc) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_rqst) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_tag) == + FCNVME_LSDESC_RQST); + CU_ASSERT(from_be32(&acc->assoc_id.desc_tag) == + FCNVME_LSDESC_ASSOC_ID); + CU_ASSERT(from_be32(&acc->assoc_id.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_assoc_id) - 8); + CU_ASSERT(from_be32(&acc->conn_id.desc_tag) == + FCNVME_LSDESC_CONN_ID); + CU_ASSERT(from_be32(&acc->conn_id.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_conn_id) - 8); + + g_curr_assoc_id = acc->assoc_id.association_id; + g_create_conn_test_cnt++; + return 0; + } else if (max_assoc_test) { + /* reject reason code should be insufficient resources */ + struct spdk_nvmf_fc_ls_rjt *rjt = + (struct spdk_nvmf_fc_ls_rjt *)ls_rqst->rspbuf.virt; + if (rjt->rjt.reason_code == FCNVME_RJT_RC_INSUFF_RES) { + return LAST_RSLT_STOP_TEST; + } + } + CU_FAIL("Unexpected reject response for create association"); + } else { + CU_FAIL("Response not for create association"); + } + + return -EINVAL; +} + +static int +handle_cc_rsp(struct spdk_nvmf_fc_ls_rqst *ls_rqst) +{ + struct spdk_nvmf_fc_ls_acc_hdr *acc_hdr = + (struct spdk_nvmf_fc_ls_acc_hdr *) ls_rqst->rspbuf.virt; + + if (acc_hdr->rqst.w0.ls_cmd == FCNVME_LS_CREATE_CONNECTION) { + if (acc_hdr->w0.ls_cmd == FCNVME_LS_ACC) { + struct spdk_nvmf_fc_ls_cr_conn_acc *acc = + (struct spdk_nvmf_fc_ls_cr_conn_acc *)ls_rqst->rspbuf.virt; + + CU_ASSERT(from_be32(&acc_hdr->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_cr_conn_acc) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_rqst) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_tag) == + FCNVME_LSDESC_RQST); + CU_ASSERT(from_be32(&acc->conn_id.desc_tag) == + FCNVME_LSDESC_CONN_ID); + CU_ASSERT(from_be32(&acc->conn_id.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_conn_id) - 8); + g_create_conn_test_cnt++; + return 0; + } + + if (acc_hdr->w0.ls_cmd == FCNVME_LS_RJT) { + struct spdk_nvmf_fc_ls_rjt *rjt = + (struct spdk_nvmf_fc_ls_rjt *)ls_rqst->rspbuf.virt; + if (g_create_conn_test_cnt == g_nvmf_transport.opts.max_qpairs_per_ctrlr) { + /* expected to get reject for too many connections */ + CU_ASSERT(rjt->rjt.reason_code == + FCNVME_RJT_RC_INV_PARAM); + CU_ASSERT(rjt->rjt.reason_explanation == + FCNVME_RJT_EXP_INV_Q_ID); + } else if (!g_max_assoc_conn_test) { + CU_FAIL("Unexpected reject response create connection"); + } + } else { + CU_FAIL("Unexpected response code for create connection"); + } + } else { + CU_FAIL("Response not for create connection"); + } + + return -EINVAL; +} + +static int +handle_disconn_rsp(struct spdk_nvmf_fc_ls_rqst *ls_rqst) +{ + struct spdk_nvmf_fc_ls_acc_hdr *acc_hdr = + (struct spdk_nvmf_fc_ls_acc_hdr *) ls_rqst->rspbuf.virt; + + if (acc_hdr->rqst.w0.ls_cmd == FCNVME_LS_DISCONNECT) { + if (acc_hdr->w0.ls_cmd == FCNVME_LS_ACC) { + CU_ASSERT(from_be32(&acc_hdr->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_disconnect_acc) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_rqst) - 8); + CU_ASSERT(from_be32(&acc_hdr->rqst.desc_tag) == + FCNVME_LSDESC_RQST); + return 0; + } else { + CU_FAIL("Unexpected reject response for disconnect"); + } + } else { + CU_FAIL("Response not for create connection"); + } + + return -EINVAL; +} + +static int +handle_conn_bad_assoc_rsp(struct spdk_nvmf_fc_ls_rqst *ls_rqst) +{ + struct spdk_nvmf_fc_ls_acc_hdr *acc_hdr = + (struct spdk_nvmf_fc_ls_acc_hdr *) ls_rqst->rspbuf.virt; + + if (acc_hdr->rqst.w0.ls_cmd == FCNVME_LS_CREATE_CONNECTION) { + if (acc_hdr->w0.ls_cmd == FCNVME_LS_RJT) { + struct spdk_nvmf_fc_ls_rjt *rjt = + (struct spdk_nvmf_fc_ls_rjt *)ls_rqst->rspbuf.virt; + + CU_ASSERT(from_be32(&rjt->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_rjt) - 8); + CU_ASSERT(from_be32(&rjt->rqst.desc_tag) == + FCNVME_LSDESC_RQST); + CU_ASSERT(from_be32(&rjt->rjt.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_rjt) - 8); + CU_ASSERT(from_be32(&rjt->rjt.desc_tag) == + FCNVME_LSDESC_RJT); + CU_ASSERT(rjt->rjt.reason_code == + FCNVME_RJT_RC_INV_ASSOC); + CU_ASSERT(rjt->rjt.reason_explanation == + FCNVME_RJT_EXP_NONE); + /* make sure reserved fields are 0 */ + CU_ASSERT(rjt->rjt.rsvd8 == 0); + CU_ASSERT(rjt->rjt.rsvd12 == 0); + return 0; + } else { + CU_FAIL("Unexpected accept response for create conn. on bad assoc_id"); + } + } else { + CU_FAIL("Response not for create connection on bad assoc_id"); + } + + return -EINVAL; +} + +static int +handle_disconn_bad_assoc_rsp(struct spdk_nvmf_fc_ls_rqst *ls_rqst) +{ + struct spdk_nvmf_fc_ls_acc_hdr *acc_hdr = + (struct spdk_nvmf_fc_ls_acc_hdr *) ls_rqst->rspbuf.virt; + + if (acc_hdr->rqst.w0.ls_cmd == FCNVME_LS_DISCONNECT) { + if (acc_hdr->w0.ls_cmd == FCNVME_LS_RJT) { + struct spdk_nvmf_fc_ls_rjt *rjt = + (struct spdk_nvmf_fc_ls_rjt *)ls_rqst->rspbuf.virt; + + CU_ASSERT(from_be32(&rjt->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_rjt) - 8); + CU_ASSERT(from_be32(&rjt->rqst.desc_tag) == + FCNVME_LSDESC_RQST); + CU_ASSERT(from_be32(&rjt->rjt.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_rjt) - 8); + CU_ASSERT(from_be32(&rjt->rjt.desc_tag) == + FCNVME_LSDESC_RJT); + CU_ASSERT(rjt->rjt.reason_code == + FCNVME_RJT_RC_INV_ASSOC); + CU_ASSERT(rjt->rjt.reason_explanation == + FCNVME_RJT_EXP_NONE); + return 0; + } else { + CU_FAIL("Unexpected accept response for disconnect on bad assoc_id"); + } + } else { + CU_FAIL("Response not for dsconnect on bad assoc_id"); + } + + return -EINVAL; +} + + +static struct spdk_nvmf_fc_port g_fc_port = { + .num_io_queues = 16, +}; + +static struct spdk_nvmf_fc_nport g_tgt_port; + +static uint64_t assoc_id[1024]; + +#define FC_LS_UT_MAX_IO_QUEUES 16 +struct spdk_nvmf_fc_hwqp g_fc_hwqp[FC_LS_UT_MAX_IO_QUEUES]; +struct spdk_nvmf_fc_poll_group g_fgroup[FC_LS_UT_MAX_IO_QUEUES]; +struct spdk_nvmf_poll_group g_poll_group[FC_LS_UT_MAX_IO_QUEUES]; +static bool threads_allocated = false; + +static void +ls_assign_hwqp_threads(void) +{ + uint32_t i; + + for (i = 0; i < g_fc_port.num_io_queues; i++) { + struct spdk_nvmf_fc_hwqp *hwqp = &g_fc_port.io_queues[i]; + if (hwqp->thread == NULL) { + hwqp->thread = spdk_get_thread(); + } + } +} + +static void +ls_prepare_threads(void) +{ + if (threads_allocated == false) { + allocate_threads(8); + set_thread(0); + } + threads_allocated = true; +} + +static void +setup_polling_threads(void) +{ + ls_prepare_threads(); + set_thread(0); + ls_assign_hwqp_threads(); +} + +static int +ls_tests_init(void) +{ + uint16_t i; + + bzero(&g_nvmf_tgt, sizeof(g_nvmf_tgt)); + + g_nvmf_transport.opts = g_nvmf_transport_opts; + + snprintf(g_nvmf_subsystem.subnqn, sizeof(g_nvmf_subsystem.subnqn), "%s", fc_ut_subsystem_nqn); + g_fc_port.hw_port_status = SPDK_FC_PORT_ONLINE; + g_fc_port.io_queues = g_fc_hwqp; + for (i = 0; i < g_fc_port.num_io_queues; i++) { + struct spdk_nvmf_fc_hwqp *hwqp = &g_fc_port.io_queues[i]; + hwqp->lcore_id = i; + hwqp->hwqp_id = i; + hwqp->thread = NULL; + hwqp->fc_port = &g_fc_port; + hwqp->num_conns = 0; + hwqp->rq_size = g_hw_queue_depth; + TAILQ_INIT(&hwqp->connection_list); + TAILQ_INIT(&hwqp->in_use_reqs); + + bzero(&g_poll_group[i], sizeof(struct spdk_nvmf_poll_group)); + bzero(&g_fgroup[i], sizeof(struct spdk_nvmf_fc_poll_group)); + TAILQ_INIT(&g_poll_group[i].tgroups); + TAILQ_INIT(&g_poll_group[i].qpairs); + g_fgroup[i].group.transport = &g_nvmf_transport; + g_fgroup[i].group.group = &g_poll_group[i]; + hwqp->fgroup = &g_fgroup[i]; + } + + nvmf_fc_ls_init(&g_fc_port); + bzero(&g_tgt_port, sizeof(struct spdk_nvmf_fc_nport)); + g_tgt_port.fc_port = &g_fc_port; + TAILQ_INIT(&g_tgt_port.rem_port_list); + TAILQ_INIT(&g_tgt_port.fc_associations); + + bzero(&g_rem_port, sizeof(struct spdk_nvmf_fc_remote_port_info)); + TAILQ_INSERT_TAIL(&g_tgt_port.rem_port_list, &g_rem_port, link); + + return 0; +} + +static int +ls_tests_fini(void) +{ + nvmf_fc_ls_fini(&g_fc_port); + free_threads(); + return 0; +} + +static void +create_single_assoc_test(void) +{ + setup_polling_threads(); + /* main test driver */ + g_test_run_type = TEST_RUN_TYPE_CREATE_ASSOC; + run_create_assoc_test(fc_ut_subsystem_nqn, fc_ut_host, &g_tgt_port); + + if (g_last_rslt == 0) { + /* disconnect the association */ + g_test_run_type = TEST_RUN_TYPE_DISCONNECT; + run_disconn_test(&g_tgt_port, g_curr_assoc_id); + g_create_conn_test_cnt = 0; + } +} + +static void +create_max_conns_test(void) +{ + uint16_t qid = 1; + + setup_polling_threads(); + /* main test driver */ + g_test_run_type = TEST_RUN_TYPE_CREATE_ASSOC; + run_create_assoc_test(fc_ut_subsystem_nqn, fc_ut_host, &g_tgt_port); + + if (g_last_rslt == 0) { + g_test_run_type = TEST_RUN_TYPE_CREATE_CONN; + /* create connections until we get too many connections error */ + while (g_last_rslt == 0) { + if (g_create_conn_test_cnt > g_nvmf_transport.opts.max_qpairs_per_ctrlr) { + CU_FAIL("Did not get CIOC failure for too many connections"); + break; + } + run_create_conn_test(fc_ut_host, &g_tgt_port, g_curr_assoc_id, qid++); + } + + /* disconnect the association */ + g_last_rslt = 0; + g_test_run_type = TEST_RUN_TYPE_DISCONNECT; + run_disconn_test(&g_tgt_port, g_curr_assoc_id); + g_create_conn_test_cnt = 0; + } +} + +static void +invalid_connection_test(void) +{ + setup_polling_threads(); + /* run test to create connection to invalid association */ + g_test_run_type = TEST_RUN_TYPE_CONN_BAD_ASSOC; + run_create_conn_test(fc_ut_host, &g_tgt_port, g_curr_assoc_id, 1); +} + +static void +create_max_aq_conns_test(void) +{ + /* run test to create max. associations with max. connections */ + uint32_t i, j; + uint32_t create_assoc_test_cnt = 0; + + setup_polling_threads(); + g_max_assoc_conn_test = 1; + g_last_rslt = 0; + while (1) { + g_test_run_type = TEST_RUN_TYPE_CREATE_MAX_ASSOC; + run_create_assoc_test(fc_ut_subsystem_nqn, fc_ut_host, &g_tgt_port); + if (g_last_rslt == 0) { + assoc_id[create_assoc_test_cnt++] = g_curr_assoc_id; + g_test_run_type = TEST_RUN_TYPE_CREATE_CONN; + for (j = 1; j < g_nvmf_transport.opts.max_qpairs_per_ctrlr; j++) { + if (g_last_rslt == 0) { + run_create_conn_test(fc_ut_host, &g_tgt_port, g_curr_assoc_id, (uint16_t) j); + } + } + } else { + break; + } + } + + if (g_last_rslt == LAST_RSLT_STOP_TEST) { + uint32_t ma = (((g_hw_queue_depth / g_nvmf_transport.opts.max_queue_depth) * + (g_fc_port.num_io_queues - 1))) / + (g_nvmf_transport.opts.max_qpairs_per_ctrlr - 1); + if (create_assoc_test_cnt < ma) { + printf("(%d assocs - should be %d) ", create_assoc_test_cnt, ma); + CU_FAIL("Didn't create max. associations"); + } else { + printf("(%d assocs.) ", create_assoc_test_cnt); + } + g_last_rslt = 0; + } + + for (i = 0; i < create_assoc_test_cnt; i++) { + int ret; + g_spdk_nvmf_fc_xmt_srsr_req = false; + ret = nvmf_fc_delete_association(&g_tgt_port, from_be64(&assoc_id[i]), true, false, + disconnect_assoc_cb, 0); + CU_ASSERT(ret == 0); + poll_thread(0); + +#if (NVMF_FC_LS_SEND_LS_DISCONNECT == 1) + if (ret == 0) { + /* check that LS disconnect was sent */ + CU_ASSERT(g_spdk_nvmf_fc_xmt_srsr_req); + } +#endif + } + g_max_assoc_conn_test = 0; +} + +static void +xmt_ls_rsp_failure_test(void) +{ + setup_polling_threads(); + g_test_run_type = TEST_RUN_TYPE_FAIL_LS_RSP; + run_create_assoc_test(fc_ut_subsystem_nqn, fc_ut_host, &g_tgt_port); + if (g_last_rslt == 0) { + /* check target port for associations */ + CU_ASSERT(g_tgt_port.assoc_count == 0); + } +} + +static void +disconnect_bad_assoc_test(void) +{ + setup_polling_threads(); + g_test_run_type = TEST_RUN_TYPE_DISCONNECT_BAD_ASSOC; + run_disconn_test(&g_tgt_port, 0xffff); +} + +/* + * SPDK functions that are called by LS processing + */ + +int +nvmf_fc_xmt_ls_rsp(struct spdk_nvmf_fc_nport *g_tgt_port, + struct spdk_nvmf_fc_ls_rqst *ls_rqst) +{ + switch (g_test_run_type) { + case TEST_RUN_TYPE_CREATE_ASSOC: + g_last_rslt = handle_ca_rsp(ls_rqst, false); + break; + case TEST_RUN_TYPE_CREATE_CONN: + g_last_rslt = handle_cc_rsp(ls_rqst); + break; + case TEST_RUN_TYPE_DISCONNECT: + g_last_rslt = handle_disconn_rsp(ls_rqst); + break; + case TEST_RUN_TYPE_CONN_BAD_ASSOC: + g_last_rslt = handle_conn_bad_assoc_rsp(ls_rqst); + break; + case TEST_RUN_TYPE_FAIL_LS_RSP: + g_last_rslt = handle_ca_rsp(ls_rqst, false); + return 1; + case TEST_RUN_TYPE_DISCONNECT_BAD_ASSOC: + g_last_rslt = handle_disconn_bad_assoc_rsp(ls_rqst); + break; + case TEST_RUN_TYPE_CREATE_MAX_ASSOC: + g_last_rslt = handle_ca_rsp(ls_rqst, true); + break; + + default: + CU_FAIL("LS Response for Invalid Test Type"); + g_last_rslt = 1; + } + + return 0; +} + +int +nvmf_fc_xmt_srsr_req(struct spdk_nvmf_fc_hwqp *hwqp, + struct spdk_nvmf_fc_srsr_bufs *srsr_bufs, + spdk_nvmf_fc_caller_cb cb, void *cb_args) +{ + struct spdk_nvmf_fc_ls_disconnect_rqst *dc_rqst = + (struct spdk_nvmf_fc_ls_disconnect_rqst *) + srsr_bufs->rqst; + + CU_ASSERT(dc_rqst->w0.ls_cmd == FCNVME_LS_DISCONNECT); + CU_ASSERT(from_be32(&dc_rqst->desc_list_len) == + sizeof(struct spdk_nvmf_fc_ls_disconnect_rqst) - + (2 * sizeof(uint32_t))); + CU_ASSERT(from_be32(&dc_rqst->assoc_id.desc_tag) == + FCNVME_LSDESC_ASSOC_ID); + CU_ASSERT(from_be32(&dc_rqst->assoc_id.desc_len) == + sizeof(struct spdk_nvmf_fc_lsdesc_assoc_id) - + (2 * sizeof(uint32_t))); + + g_spdk_nvmf_fc_xmt_srsr_req = true; + + if (cb) { + cb(hwqp, 0, cb_args); + } + + return 0; +} + +DEFINE_STUB_V(nvmf_fc_request_abort, (struct spdk_nvmf_fc_request *fc_req, + bool send_abts, spdk_nvmf_fc_caller_cb cb, void *cb_args)); +DEFINE_STUB_V(spdk_bdev_io_abort, (struct spdk_bdev_io *bdev_io, void *ctx)); +DEFINE_STUB_V(nvmf_fc_request_abort_complete, (void *arg1)); + +static void +usage(const char *program_name) +{ + printf("%s [options]\n", program_name); + printf("options:\n"); + spdk_log_usage(stdout, "-t"); + printf(" -i value - Number of IO Queues (default: %u)\n", + g_fc_port.num_io_queues); + printf(" -d value - HW queue depth (default: %u)\n", + g_hw_queue_depth); + printf(" -q value - SQ size (default: %u)\n", + g_nvmf_transport_opts.max_queue_depth); + printf(" -c value - Connection count (default: %u)\n", + g_nvmf_transport_opts.max_qpairs_per_ctrlr); + printf(" -u test# - Unit test# to run\n"); + printf(" 0 : Run all tests (default)\n"); + printf(" 1 : CASS/DISC create single assoc test\n"); + printf(" 2 : Max. conns. test\n"); + printf(" 3 : CIOC to invalid assoc_id connection test\n"); + printf(" 4 : Create/delete max assoc conns test\n"); + printf(" 5 : LS response failure test\n"); + printf(" 6 : Disconnect bad assoc_id test\n"); +} + +int main(int argc, char **argv) +{ + unsigned int num_failures = 0; + CU_pSuite suite = NULL; + int test = 0; + long int val; + int op; + + while ((op = getopt(argc, argv, "a:q:c:t:u:d:i:")) != -1) { + switch (op) { + case 'q': + val = spdk_strtol(optarg, 10); + if (val < 16) { + fprintf(stderr, "SQ size must be at least 16\n"); + return -EINVAL; + } + g_nvmf_transport_opts.max_queue_depth = (uint16_t)val; + break; + case 'c': + val = spdk_strtol(optarg, 10); + if (val < 2) { + fprintf(stderr, "Connection count must be at least 2\n"); + return -EINVAL; + } + g_nvmf_transport_opts.max_qpairs_per_ctrlr = (uint16_t)val; + break; + case 't': + if (spdk_log_set_flag(optarg) < 0) { + fprintf(stderr, "Unknown trace flag '%s'\n", optarg); + usage(argv[0]); + return -EINVAL; + } + break; + case 'u': + test = (int)spdk_strtol(optarg, 10); + break; + case 'd': + val = spdk_strtol(optarg, 10); + if (val < 16) { + fprintf(stderr, "HW queue depth must be at least 16\n"); + return -EINVAL; + } + g_hw_queue_depth = (uint32_t)val; + break; + case 'i': + val = spdk_strtol(optarg, 10); + if (val < 2) { + fprintf(stderr, "Number of io queues must be at least 2\n"); + return -EINVAL; + } + if (val > FC_LS_UT_MAX_IO_QUEUES) { + fprintf(stderr, "Number of io queues can't be greater than %d\n", + FC_LS_UT_MAX_IO_QUEUES); + return -EINVAL; + } + g_fc_port.num_io_queues = (uint32_t)val; + break; + + + default: + usage(argv[0]); + return -EINVAL; + } + } + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("FC-NVMe LS", ls_tests_init, ls_tests_fini); + + if (test == 0) { + + CU_ADD_TEST(suite, create_single_assoc_test); + + CU_ADD_TEST(suite, create_max_conns_test); + CU_ADD_TEST(suite, invalid_connection_test); + CU_ADD_TEST(suite, disconnect_bad_assoc_test); + + CU_ADD_TEST(suite, create_max_aq_conns_test); + CU_ADD_TEST(suite, xmt_ls_rsp_failure_test); + + } else { + + switch (test) { + case 1: + CU_ADD_TEST(suite, create_single_assoc_test); + break; + case 2: + CU_ADD_TEST(suite, create_max_conns_test); + break; + case 3: + CU_ADD_TEST(suite, invalid_connection_test); + break; + case 4: + CU_ADD_TEST(suite, create_max_aq_conns_test); + break; + case 5: + CU_ADD_TEST(suite, xmt_ls_rsp_failure_test); + break; + case 6: + CU_ADD_TEST(suite, disconnect_bad_assoc_test); + break; + + default: + fprintf(stderr, "Invalid test number\n"); + usage(argv[0]); + CU_cleanup_registry(); + return -EINVAL; + } + } + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/rdma.c/.gitignore b/src/spdk/test/unit/lib/nvmf/rdma.c/.gitignore new file mode 100644 index 000000000..0adb59d10 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/rdma.c/.gitignore @@ -0,0 +1 @@ +rdma_ut diff --git a/src/spdk/test/unit/lib/nvmf/rdma.c/Makefile b/src/spdk/test/unit/lib/nvmf/rdma.c/Makefile new file mode 100644 index 000000000..ad4998663 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/rdma.c/Makefile @@ -0,0 +1,38 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +TEST_FILE = rdma_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/rdma.c/rdma_ut.c b/src/spdk/test/unit/lib/nvmf/rdma.c/rdma_ut.c new file mode 100644 index 000000000..b0af58d18 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/rdma.c/rdma_ut.c @@ -0,0 +1,1283 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. All rights reserved. + * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" +#include "spdk_cunit.h" +#include "common/lib/test_env.c" +#include "common/lib/test_rdma.c" +#include "nvmf/rdma.c" +#include "nvmf/transport.c" + +uint64_t g_mr_size; +uint64_t g_mr_next_size; +struct ibv_mr g_rdma_mr; + +#define RDMA_UT_UNITS_IN_MAX_IO 16 + +struct spdk_nvmf_transport_opts g_rdma_ut_transport_opts = { + .max_queue_depth = SPDK_NVMF_RDMA_DEFAULT_MAX_QUEUE_DEPTH, + .max_qpairs_per_ctrlr = SPDK_NVMF_RDMA_DEFAULT_MAX_QPAIRS_PER_CTRLR, + .in_capsule_data_size = SPDK_NVMF_RDMA_DEFAULT_IN_CAPSULE_DATA_SIZE, + .max_io_size = (SPDK_NVMF_RDMA_MIN_IO_BUFFER_SIZE * RDMA_UT_UNITS_IN_MAX_IO), + .io_unit_size = SPDK_NVMF_RDMA_MIN_IO_BUFFER_SIZE, + .max_aq_depth = SPDK_NVMF_RDMA_DEFAULT_AQ_DEPTH, + .num_shared_buffers = SPDK_NVMF_RDMA_DEFAULT_NUM_SHARED_BUFFERS, +}; + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) +DEFINE_STUB(spdk_mem_map_set_translation, int, (struct spdk_mem_map *map, uint64_t vaddr, + uint64_t size, uint64_t translation), 0); +DEFINE_STUB(spdk_mem_map_clear_translation, int, (struct spdk_mem_map *map, uint64_t vaddr, + uint64_t size), 0); +DEFINE_STUB(spdk_mem_map_alloc, struct spdk_mem_map *, (uint64_t default_translation, + const struct spdk_mem_map_ops *ops, void *cb_ctx), NULL); +DEFINE_STUB(spdk_nvmf_qpair_disconnect, int, (struct spdk_nvmf_qpair *qpair, + nvmf_qpair_disconnect_cb cb_fn, void *ctx), 0); +DEFINE_STUB_V(spdk_mem_map_free, (struct spdk_mem_map **pmap)); + +struct spdk_trace_histories *g_trace_histories; +DEFINE_STUB_V(spdk_trace_add_register_fn, (struct spdk_trace_register_fn *reg_fn)); +DEFINE_STUB_V(spdk_trace_register_object, (uint8_t type, char id_prefix)); +DEFINE_STUB_V(spdk_trace_register_description, (const char *name, + uint16_t tpoint_id, uint8_t owner_type, uint8_t object_type, uint8_t new_object, + uint8_t arg1_type, const char *arg1_name)); +DEFINE_STUB_V(_spdk_trace_record, (uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id, + uint32_t size, uint64_t object_id, uint64_t arg1)); + +DEFINE_STUB_V(spdk_nvmf_ctrlr_data_init, (struct spdk_nvmf_transport_opts *opts, + struct spdk_nvmf_ctrlr_data *cdata)); +DEFINE_STUB_V(spdk_nvmf_request_exec, (struct spdk_nvmf_request *req)); +DEFINE_STUB(spdk_nvmf_request_complete, int, (struct spdk_nvmf_request *req), 0); +DEFINE_STUB(spdk_nvme_transport_id_compare, int, (const struct spdk_nvme_transport_id *trid1, + const struct spdk_nvme_transport_id *trid2), 0); +DEFINE_STUB_V(nvmf_ctrlr_abort_aer, (struct spdk_nvmf_ctrlr *ctrlr)); +DEFINE_STUB(spdk_nvmf_request_get_dif_ctx, bool, (struct spdk_nvmf_request *req, + struct spdk_dif_ctx *dif_ctx), false); +DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, + enum spdk_nvme_transport_type trtype)); +DEFINE_STUB_V(spdk_nvmf_tgt_new_qpair, (struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair)); +DEFINE_STUB(nvmf_ctrlr_abort_request, int, (struct spdk_nvmf_request *req), 0); + +const char * +spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype) +{ + switch (trtype) { + case SPDK_NVME_TRANSPORT_PCIE: + return "PCIe"; + case SPDK_NVME_TRANSPORT_RDMA: + return "RDMA"; + case SPDK_NVME_TRANSPORT_FC: + return "FC"; + default: + return NULL; + } +} + +int +spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring) +{ + int len, i; + + if (trstring == NULL) { + return -EINVAL; + } + + len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN); + if (len == SPDK_NVMF_TRSTRING_MAX_LEN) { + return -EINVAL; + } + + /* cast official trstring to uppercase version of input. */ + for (i = 0; i < len; i++) { + trid->trstring[i] = toupper(trstring[i]); + } + return 0; +} + +uint64_t +spdk_mem_map_translate(const struct spdk_mem_map *map, uint64_t vaddr, uint64_t *size) +{ + if (g_mr_size != 0) { + *(uint32_t *)size = g_mr_size; + if (g_mr_next_size != 0) { + g_mr_size = g_mr_next_size; + } + } + + return (uint64_t)&g_rdma_mr; +} + +static void reset_nvmf_rdma_request(struct spdk_nvmf_rdma_request *rdma_req) +{ + int i; + + rdma_req->req.length = 0; + rdma_req->req.data_from_pool = false; + rdma_req->req.data = NULL; + rdma_req->data.wr.num_sge = 0; + rdma_req->data.wr.wr.rdma.remote_addr = 0; + rdma_req->data.wr.wr.rdma.rkey = 0; + memset(&rdma_req->req.dif, 0, sizeof(rdma_req->req.dif)); + + for (i = 0; i < SPDK_NVMF_MAX_SGL_ENTRIES; i++) { + rdma_req->req.iov[i].iov_base = 0; + rdma_req->req.iov[i].iov_len = 0; + rdma_req->req.buffers[i] = 0; + rdma_req->data.wr.sg_list[i].addr = 0; + rdma_req->data.wr.sg_list[i].length = 0; + rdma_req->data.wr.sg_list[i].lkey = 0; + } + rdma_req->req.iovcnt = 0; +} + +static void +test_spdk_nvmf_rdma_request_parse_sgl(void) +{ + struct spdk_nvmf_rdma_transport rtransport; + struct spdk_nvmf_rdma_device device; + struct spdk_nvmf_rdma_request rdma_req = {}; + struct spdk_nvmf_rdma_recv recv; + struct spdk_nvmf_rdma_poll_group group; + struct spdk_nvmf_rdma_qpair rqpair; + struct spdk_nvmf_rdma_poller poller; + union nvmf_c2h_msg cpl; + union nvmf_h2c_msg cmd; + struct spdk_nvme_sgl_descriptor *sgl; + struct spdk_nvmf_transport_pg_cache_buf bufs[4]; + struct spdk_nvme_sgl_descriptor sgl_desc[SPDK_NVMF_MAX_SGL_ENTRIES] = {{0}}; + struct spdk_nvmf_rdma_request_data data; + struct spdk_nvmf_transport_pg_cache_buf buffer; + struct spdk_nvmf_transport_pg_cache_buf *buffer_ptr; + int rc, i; + + data.wr.sg_list = data.sgl; + STAILQ_INIT(&group.group.buf_cache); + group.group.buf_cache_size = 0; + group.group.buf_cache_count = 0; + group.group.transport = &rtransport.transport; + STAILQ_INIT(&group.retired_bufs); + poller.group = &group; + rqpair.poller = &poller; + rqpair.max_send_sge = SPDK_NVMF_MAX_SGL_ENTRIES; + + sgl = &cmd.nvme_cmd.dptr.sgl1; + rdma_req.recv = &recv; + rdma_req.req.cmd = &cmd; + rdma_req.req.rsp = &cpl; + rdma_req.data.wr.sg_list = rdma_req.data.sgl; + rdma_req.req.qpair = &rqpair.qpair; + rdma_req.req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; + + rtransport.transport.opts = g_rdma_ut_transport_opts; + rtransport.data_wr_pool = NULL; + rtransport.transport.data_buf_pool = NULL; + + device.attr.device_cap_flags = 0; + g_rdma_mr.lkey = 0xABCD; + sgl->keyed.key = 0xEEEE; + sgl->address = 0xFFFF; + rdma_req.recv->buf = (void *)0xDDDD; + + /* Test 1: sgl type: keyed data block subtype: address */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + + /* Part 1: simple I/O, one SGL smaller than the transport io unit size */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + sgl->keyed.length = rtransport.transport.opts.io_unit_size / 2; + + device.map = (void *)0x0; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 1); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[0].length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == g_rdma_mr.lkey); + + /* Part 2: simple I/O, one SGL larger than the transport io unit size (equal to the max io size) */ + reset_nvmf_rdma_request(&rdma_req); + sgl->keyed.length = rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO); + CU_ASSERT(rdma_req.data.wr.num_sge == RDMA_UT_UNITS_IN_MAX_IO); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + for (i = 0; i < RDMA_UT_UNITS_IN_MAX_IO; i++) { + CU_ASSERT((uint64_t)rdma_req.req.buffers[i] == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + + /* Part 3: simple I/O one SGL larger than the transport max io size */ + reset_nvmf_rdma_request(&rdma_req); + sgl->keyed.length = rtransport.transport.opts.max_io_size * 2; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == -1); + + /* Part 4: Pretend there are no buffer pools */ + MOCK_SET(spdk_mempool_get, NULL); + reset_nvmf_rdma_request(&rdma_req); + sgl->keyed.length = rtransport.transport.opts.io_unit_size * RDMA_UT_UNITS_IN_MAX_IO; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == false); + CU_ASSERT(rdma_req.req.data == NULL); + CU_ASSERT(rdma_req.data.wr.num_sge == 0); + CU_ASSERT(rdma_req.req.buffers[0] == NULL); + CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0); + CU_ASSERT(rdma_req.data.wr.sg_list[0].length == 0); + CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == 0); + + rdma_req.recv->buf = (void *)0xDDDD; + /* Test 2: sgl type: keyed data block subtype: offset (in capsule data) */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK; + sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_OFFSET; + + /* Part 1: Normal I/O smaller than in capsule data size no offset */ + reset_nvmf_rdma_request(&rdma_req); + sgl->address = 0; + sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data == (void *)0xDDDD); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.in_capsule_data_size); + CU_ASSERT(rdma_req.req.data_from_pool == false); + + /* Part 2: I/O offset + length too large */ + reset_nvmf_rdma_request(&rdma_req); + sgl->address = rtransport.transport.opts.in_capsule_data_size; + sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == -1); + + /* Part 3: I/O too large */ + reset_nvmf_rdma_request(&rdma_req); + sgl->address = 0; + sgl->unkeyed.length = rtransport.transport.opts.in_capsule_data_size * 2; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == -1); + + /* Test 3: Multi SGL */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_LAST_SEGMENT; + sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_OFFSET; + sgl->address = 0; + rdma_req.recv->buf = (void *)&sgl_desc; + MOCK_SET(spdk_mempool_get, &data); + + /* part 1: 2 segments each with 1 wr. */ + reset_nvmf_rdma_request(&rdma_req); + sgl->unkeyed.length = 2 * sizeof(struct spdk_nvme_sgl_descriptor); + for (i = 0; i < 2; i++) { + sgl_desc[i].keyed.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl_desc[i].keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl_desc[i].keyed.length = rtransport.transport.opts.io_unit_size; + sgl_desc[i].address = 0x4000 + i * rtransport.transport.opts.io_unit_size; + sgl_desc[i].keyed.key = 0x44; + } + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 2); + CU_ASSERT(rdma_req.data.wr.num_sge == 1); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0x4000); + CU_ASSERT(rdma_req.data.wr.next == &data.wr); + CU_ASSERT(data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(data.wr.wr.rdma.remote_addr == 0x4000 + rtransport.transport.opts.io_unit_size); + CU_ASSERT(data.wr.num_sge == 1); + CU_ASSERT(data.wr.next == &rdma_req.rsp.wr); + + /* part 2: 2 segments, each with 1 wr containing 8 sge_elements */ + reset_nvmf_rdma_request(&rdma_req); + sgl->unkeyed.length = 2 * sizeof(struct spdk_nvme_sgl_descriptor); + for (i = 0; i < 2; i++) { + sgl_desc[i].keyed.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl_desc[i].keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl_desc[i].keyed.length = rtransport.transport.opts.io_unit_size * 8; + sgl_desc[i].address = 0x4000 + i * 8 * rtransport.transport.opts.io_unit_size; + sgl_desc[i].keyed.key = 0x44; + } + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 16); + CU_ASSERT(rdma_req.req.iovcnt == 16); + CU_ASSERT(rdma_req.data.wr.num_sge == 8); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0x4000); + CU_ASSERT(rdma_req.data.wr.next == &data.wr); + CU_ASSERT(data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(data.wr.wr.rdma.remote_addr == 0x4000 + rtransport.transport.opts.io_unit_size * 8); + CU_ASSERT(data.wr.num_sge == 8); + CU_ASSERT(data.wr.next == &rdma_req.rsp.wr); + + /* part 3: 2 segments, one very large, one very small */ + reset_nvmf_rdma_request(&rdma_req); + for (i = 0; i < 2; i++) { + sgl_desc[i].keyed.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl_desc[i].keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl_desc[i].keyed.key = 0x44; + } + + sgl_desc[0].keyed.length = rtransport.transport.opts.io_unit_size * 15 + + rtransport.transport.opts.io_unit_size / 2; + sgl_desc[0].address = 0x4000; + sgl_desc[1].keyed.length = rtransport.transport.opts.io_unit_size / 2; + sgl_desc[1].address = 0x4000 + rtransport.transport.opts.io_unit_size * 15 + + rtransport.transport.opts.io_unit_size / 2; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 16); + CU_ASSERT(rdma_req.req.iovcnt == 17); + CU_ASSERT(rdma_req.data.wr.num_sge == 16); + for (i = 0; i < 15; i++) { + CU_ASSERT(rdma_req.data.sgl[i].length == rtransport.transport.opts.io_unit_size); + } + CU_ASSERT(rdma_req.data.sgl[15].length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0x4000); + CU_ASSERT(rdma_req.data.wr.next == &data.wr); + CU_ASSERT(data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(data.wr.wr.rdma.remote_addr == 0x4000 + rtransport.transport.opts.io_unit_size * 15 + + rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT(data.sgl[0].length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT(data.wr.num_sge == 1); + CU_ASSERT(data.wr.next == &rdma_req.rsp.wr); + + /* Test 4: use PG buffer cache */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl->address = 0xFFFF; + rdma_req.recv->buf = (void *)0xDDDD; + g_rdma_mr.lkey = 0xABCD; + sgl->keyed.key = 0xEEEE; + + for (i = 0; i < 4; i++) { + STAILQ_INSERT_TAIL(&group.group.buf_cache, &bufs[i], link); + } + + /* part 1: use the four buffers from the pg cache */ + group.group.buf_cache_size = 4; + group.group.buf_cache_count = 4; + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + sgl->keyed.length = rtransport.transport.opts.io_unit_size * 4; + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + SPDK_CU_ASSERT_FATAL(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == (((uint64_t)&bufs[0] + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT(group.group.buf_cache_count == 0); + CU_ASSERT(STAILQ_EMPTY(&group.group.buf_cache)); + for (i = 0; i < 4; i++) { + CU_ASSERT((uint64_t)rdma_req.req.buffers[i] == (uint64_t)&bufs[i]); + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == (((uint64_t)&bufs[i] + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); + } + + /* part 2: now that we have used the buffers from the cache, try again. We should get mempool buffers. */ + reset_nvmf_rdma_request(&rdma_req); + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + SPDK_CU_ASSERT_FATAL(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT(group.group.buf_cache_count == 0); + CU_ASSERT(STAILQ_EMPTY(&group.group.buf_cache)); + for (i = 0; i < 4; i++) { + CU_ASSERT((uint64_t)rdma_req.req.buffers[i] == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); + CU_ASSERT(group.group.buf_cache_count == 0); + } + + /* part 3: half and half */ + group.group.buf_cache_count = 2; + + for (i = 0; i < 2; i++) { + STAILQ_INSERT_TAIL(&group.group.buf_cache, &bufs[i], link); + } + reset_nvmf_rdma_request(&rdma_req); + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + SPDK_CU_ASSERT_FATAL(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == (((uint64_t)&bufs[0] + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT(group.group.buf_cache_count == 0); + for (i = 0; i < 2; i++) { + CU_ASSERT((uint64_t)rdma_req.req.buffers[i] == (uint64_t)&bufs[i]); + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == (((uint64_t)&bufs[i] + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); + } + for (i = 2; i < 4; i++) { + CU_ASSERT((uint64_t)rdma_req.req.buffers[i] == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == rtransport.transport.opts.io_unit_size); + } + + reset_nvmf_rdma_request(&rdma_req); + /* Test 5 dealing with a buffer split over two Memory Regions */ + MOCK_SET(spdk_mempool_get, (void *)&buffer); + sgl->generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl->keyed.length = rtransport.transport.opts.io_unit_size / 2; + g_mr_size = rtransport.transport.opts.io_unit_size / 4; + g_mr_next_size = rtransport.transport.opts.io_unit_size / 2; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + SPDK_CU_ASSERT_FATAL(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT((uint64_t)rdma_req.req.data == (((uint64_t)&buffer + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.num_sge == 1); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT(rdma_req.req.buffers[0] == &buffer); + CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == (((uint64_t)&buffer + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.sg_list[0].length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == g_rdma_mr.lkey); + buffer_ptr = STAILQ_FIRST(&group.retired_bufs); + CU_ASSERT(buffer_ptr == &buffer); + STAILQ_REMOVE(&group.retired_bufs, buffer_ptr, spdk_nvmf_transport_pg_cache_buf, link); + CU_ASSERT(STAILQ_EMPTY(&group.retired_bufs)); + g_mr_size = 0; + g_mr_next_size = 0; + + reset_nvmf_rdma_request(&rdma_req); +} + +static struct spdk_nvmf_rdma_recv * +create_recv(struct spdk_nvmf_rdma_qpair *rqpair, enum spdk_nvme_nvm_opcode opc) +{ + struct spdk_nvmf_rdma_recv *rdma_recv; + union nvmf_h2c_msg *cmd; + struct spdk_nvme_sgl_descriptor *sgl; + + rdma_recv = calloc(1, sizeof(*rdma_recv)); + rdma_recv->qpair = rqpair; + cmd = calloc(1, sizeof(*cmd)); + rdma_recv->sgl[0].addr = (uintptr_t)cmd; + cmd->nvme_cmd.opc = opc; + sgl = &cmd->nvme_cmd.dptr.sgl1; + sgl->keyed.key = 0xEEEE; + sgl->address = 0xFFFF; + sgl->keyed.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl->keyed.length = 1; + + return rdma_recv; +} + +static void +free_recv(struct spdk_nvmf_rdma_recv *rdma_recv) +{ + free((void *)rdma_recv->sgl[0].addr); + free(rdma_recv); +} + +static struct spdk_nvmf_rdma_request * +create_req(struct spdk_nvmf_rdma_qpair *rqpair, + struct spdk_nvmf_rdma_recv *rdma_recv) +{ + struct spdk_nvmf_rdma_request *rdma_req; + union nvmf_c2h_msg *cpl; + + rdma_req = calloc(1, sizeof(*rdma_req)); + rdma_req->recv = rdma_recv; + rdma_req->req.qpair = &rqpair->qpair; + rdma_req->state = RDMA_REQUEST_STATE_NEW; + rdma_req->data.wr.wr_id = (uintptr_t)&rdma_req->data.rdma_wr; + rdma_req->data.wr.sg_list = rdma_req->data.sgl; + cpl = calloc(1, sizeof(*cpl)); + rdma_req->rsp.sgl[0].addr = (uintptr_t)cpl; + rdma_req->req.rsp = cpl; + + return rdma_req; +} + +static void +free_req(struct spdk_nvmf_rdma_request *rdma_req) +{ + free((void *)rdma_req->rsp.sgl[0].addr); + free(rdma_req); +} + +static void +qpair_reset(struct spdk_nvmf_rdma_qpair *rqpair, + struct spdk_nvmf_rdma_poller *poller, + struct spdk_nvmf_rdma_device *device, + struct spdk_nvmf_rdma_resources *resources) +{ + memset(rqpair, 0, sizeof(*rqpair)); + STAILQ_INIT(&rqpair->pending_rdma_write_queue); + STAILQ_INIT(&rqpair->pending_rdma_read_queue); + rqpair->poller = poller; + rqpair->device = device; + rqpair->resources = resources; + rqpair->qpair.qid = 1; + rqpair->ibv_state = IBV_QPS_RTS; + rqpair->qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + rqpair->max_send_sge = SPDK_NVMF_MAX_SGL_ENTRIES; + rqpair->max_send_depth = 16; + rqpair->max_read_depth = 16; + resources->recvs_to_post.first = resources->recvs_to_post.last = NULL; +} + +static void +poller_reset(struct spdk_nvmf_rdma_poller *poller, + struct spdk_nvmf_rdma_poll_group *group) +{ + memset(poller, 0, sizeof(*poller)); + STAILQ_INIT(&poller->qpairs_pending_recv); + STAILQ_INIT(&poller->qpairs_pending_send); + poller->group = group; +} + +static void +test_spdk_nvmf_rdma_request_process(void) +{ + struct spdk_nvmf_rdma_transport rtransport = {}; + struct spdk_nvmf_rdma_poll_group group = {}; + struct spdk_nvmf_rdma_poller poller = {}; + struct spdk_nvmf_rdma_device device = {}; + struct spdk_nvmf_rdma_resources resources = {}; + struct spdk_nvmf_rdma_qpair rqpair = {}; + struct spdk_nvmf_rdma_recv *rdma_recv; + struct spdk_nvmf_rdma_request *rdma_req; + bool progress; + + STAILQ_INIT(&group.group.buf_cache); + STAILQ_INIT(&group.group.pending_buf_queue); + group.group.buf_cache_size = 0; + group.group.buf_cache_count = 0; + poller_reset(&poller, &group); + qpair_reset(&rqpair, &poller, &device, &resources); + + rtransport.transport.opts = g_rdma_ut_transport_opts; + rtransport.transport.data_buf_pool = spdk_mempool_create("test_data_pool", 16, 128, 0, 0); + rtransport.data_wr_pool = spdk_mempool_create("test_wr_pool", 128, + sizeof(struct spdk_nvmf_rdma_request_data), + 0, 0); + MOCK_CLEAR(spdk_mempool_get); + + device.attr.device_cap_flags = 0; + device.map = (void *)0x0; + g_rdma_mr.lkey = 0xABCD; + + /* Test 1: single SGL READ request */ + rdma_recv = create_recv(&rqpair, SPDK_NVME_OPC_READ); + rdma_req = create_req(&rqpair, rdma_recv); + rqpair.current_recv_depth = 1; + /* NEW -> EXECUTING */ + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_EXECUTING); + CU_ASSERT(rdma_req->req.xfer == SPDK_NVME_DATA_CONTROLLER_TO_HOST); + /* EXECUTED -> TRANSFERRING_C2H */ + rdma_req->state = RDMA_REQUEST_STATE_EXECUTED; + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_TRANSFERRING_CONTROLLER_TO_HOST); + CU_ASSERT(rdma_req->recv == NULL); + CU_ASSERT(resources.recvs_to_post.first == &rdma_recv->wr); + CU_ASSERT(resources.recvs_to_post.last == &rdma_recv->wr); + /* COMPLETED -> FREE */ + rdma_req->state = RDMA_REQUEST_STATE_COMPLETED; + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_FREE); + + free_recv(rdma_recv); + free_req(rdma_req); + poller_reset(&poller, &group); + qpair_reset(&rqpair, &poller, &device, &resources); + + /* Test 2: single SGL WRITE request */ + rdma_recv = create_recv(&rqpair, SPDK_NVME_OPC_WRITE); + rdma_req = create_req(&rqpair, rdma_recv); + rqpair.current_recv_depth = 1; + /* NEW -> TRANSFERRING_H2C */ + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER); + CU_ASSERT(rdma_req->req.xfer == SPDK_NVME_DATA_HOST_TO_CONTROLLER); + STAILQ_INIT(&poller.qpairs_pending_send); + /* READY_TO_EXECUTE -> EXECUTING */ + rdma_req->state = RDMA_REQUEST_STATE_READY_TO_EXECUTE; + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_EXECUTING); + /* EXECUTED -> COMPLETING */ + rdma_req->state = RDMA_REQUEST_STATE_EXECUTED; + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_COMPLETING); + CU_ASSERT(rdma_req->recv == NULL); + CU_ASSERT(resources.recvs_to_post.first == &rdma_recv->wr); + CU_ASSERT(resources.recvs_to_post.last == &rdma_recv->wr); + /* COMPLETED -> FREE */ + rdma_req->state = RDMA_REQUEST_STATE_COMPLETED; + progress = nvmf_rdma_request_process(&rtransport, rdma_req); + CU_ASSERT(progress == true); + CU_ASSERT(rdma_req->state == RDMA_REQUEST_STATE_FREE); + + free_recv(rdma_recv); + free_req(rdma_req); + poller_reset(&poller, &group); + qpair_reset(&rqpair, &poller, &device, &resources); + + /* Test 3: WRITE+WRITE ibv_send batching */ + { + struct spdk_nvmf_rdma_recv *recv1, *recv2; + struct spdk_nvmf_rdma_request *req1, *req2; + recv1 = create_recv(&rqpair, SPDK_NVME_OPC_WRITE); + req1 = create_req(&rqpair, recv1); + recv2 = create_recv(&rqpair, SPDK_NVME_OPC_WRITE); + req2 = create_req(&rqpair, recv2); + + /* WRITE 1: NEW -> TRANSFERRING_H2C */ + rqpair.current_recv_depth = 1; + nvmf_rdma_request_process(&rtransport, req1); + CU_ASSERT(req1->state == RDMA_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER); + + /* WRITE 2: NEW -> TRANSFERRING_H2C */ + rqpair.current_recv_depth = 2; + nvmf_rdma_request_process(&rtransport, req2); + CU_ASSERT(req2->state == RDMA_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER); + + STAILQ_INIT(&poller.qpairs_pending_send); + + /* WRITE 1 completes before WRITE 2 has finished RDMA reading */ + /* WRITE 1: READY_TO_EXECUTE -> EXECUTING */ + req1->state = RDMA_REQUEST_STATE_READY_TO_EXECUTE; + nvmf_rdma_request_process(&rtransport, req1); + CU_ASSERT(req1->state == RDMA_REQUEST_STATE_EXECUTING); + /* WRITE 1: EXECUTED -> COMPLETING */ + req1->state = RDMA_REQUEST_STATE_EXECUTED; + nvmf_rdma_request_process(&rtransport, req1); + CU_ASSERT(req1->state == RDMA_REQUEST_STATE_COMPLETING); + STAILQ_INIT(&poller.qpairs_pending_send); + /* WRITE 1: COMPLETED -> FREE */ + req1->state = RDMA_REQUEST_STATE_COMPLETED; + nvmf_rdma_request_process(&rtransport, req1); + CU_ASSERT(req1->state == RDMA_REQUEST_STATE_FREE); + + /* Now WRITE 2 has finished reading and completes */ + /* WRITE 2: COMPLETED -> FREE */ + /* WRITE 2: READY_TO_EXECUTE -> EXECUTING */ + req2->state = RDMA_REQUEST_STATE_READY_TO_EXECUTE; + nvmf_rdma_request_process(&rtransport, req2); + CU_ASSERT(req2->state == RDMA_REQUEST_STATE_EXECUTING); + /* WRITE 1: EXECUTED -> COMPLETING */ + req2->state = RDMA_REQUEST_STATE_EXECUTED; + nvmf_rdma_request_process(&rtransport, req2); + CU_ASSERT(req2->state == RDMA_REQUEST_STATE_COMPLETING); + STAILQ_INIT(&poller.qpairs_pending_send); + /* WRITE 1: COMPLETED -> FREE */ + req2->state = RDMA_REQUEST_STATE_COMPLETED; + nvmf_rdma_request_process(&rtransport, req2); + CU_ASSERT(req2->state == RDMA_REQUEST_STATE_FREE); + + free_recv(recv1); + free_req(req1); + free_recv(recv2); + free_req(req2); + poller_reset(&poller, &group); + qpair_reset(&rqpair, &poller, &device, &resources); + } + + spdk_mempool_free(rtransport.transport.data_buf_pool); + spdk_mempool_free(rtransport.data_wr_pool); +} + +#define TEST_GROUPS_COUNT 5 +static void +test_nvmf_rdma_get_optimal_poll_group(void) +{ + struct spdk_nvmf_rdma_transport rtransport = {}; + struct spdk_nvmf_transport *transport = &rtransport.transport; + struct spdk_nvmf_rdma_qpair rqpair = {}; + struct spdk_nvmf_transport_poll_group *groups[TEST_GROUPS_COUNT]; + struct spdk_nvmf_rdma_poll_group *rgroups[TEST_GROUPS_COUNT]; + struct spdk_nvmf_transport_poll_group *result; + uint32_t i; + + rqpair.qpair.transport = transport; + pthread_mutex_init(&rtransport.lock, NULL); + TAILQ_INIT(&rtransport.poll_groups); + + for (i = 0; i < TEST_GROUPS_COUNT; i++) { + groups[i] = nvmf_rdma_poll_group_create(transport); + CU_ASSERT(groups[i] != NULL); + rgroups[i] = SPDK_CONTAINEROF(groups[i], struct spdk_nvmf_rdma_poll_group, group); + groups[i]->transport = transport; + } + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[0]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[0]); + + /* Emulate connection of %TEST_GROUPS_COUNT% initiators - each creates 1 admin and 1 io qp */ + for (i = 0; i < TEST_GROUPS_COUNT; i++) { + rqpair.qpair.qid = 0; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == groups[i]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[(i + 1) % TEST_GROUPS_COUNT]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[i]); + + rqpair.qpair.qid = 1; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == groups[i]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[(i + 1) % TEST_GROUPS_COUNT]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[(i + 1) % TEST_GROUPS_COUNT]); + } + /* wrap around, admin/io pg point to the first pg + Destroy all poll groups except of the last one */ + for (i = 0; i < TEST_GROUPS_COUNT - 1; i++) { + nvmf_rdma_poll_group_destroy(groups[i]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[i + 1]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[i + 1]); + } + + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[TEST_GROUPS_COUNT - 1]); + + /* Check that pointers to the next admin/io poll groups are not changed */ + rqpair.qpair.qid = 0; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == groups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[TEST_GROUPS_COUNT - 1]); + + rqpair.qpair.qid = 1; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == groups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == rgroups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_io_pg == rgroups[TEST_GROUPS_COUNT - 1]); + + /* Remove the last poll group, check that pointers are NULL */ + nvmf_rdma_poll_group_destroy(groups[TEST_GROUPS_COUNT - 1]); + CU_ASSERT(rtransport.conn_sched.next_admin_pg == NULL); + CU_ASSERT(rtransport.conn_sched.next_io_pg == NULL); + + /* Request optimal poll group, result must be NULL */ + rqpair.qpair.qid = 0; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == NULL); + + rqpair.qpair.qid = 1; + result = nvmf_rdma_get_optimal_poll_group(&rqpair.qpair); + CU_ASSERT(result == NULL); + + pthread_mutex_destroy(&rtransport.lock); +} +#undef TEST_GROUPS_COUNT + +static void +test_spdk_nvmf_rdma_request_parse_sgl_with_md(void) +{ + struct spdk_nvmf_rdma_transport rtransport; + struct spdk_nvmf_rdma_device device; + struct spdk_nvmf_rdma_request rdma_req = {}; + struct spdk_nvmf_rdma_recv recv; + struct spdk_nvmf_rdma_poll_group group; + struct spdk_nvmf_rdma_qpair rqpair; + struct spdk_nvmf_rdma_poller poller; + union nvmf_c2h_msg cpl; + union nvmf_h2c_msg cmd; + struct spdk_nvme_sgl_descriptor *sgl; + struct spdk_nvme_sgl_descriptor sgl_desc[SPDK_NVMF_MAX_SGL_ENTRIES] = {{0}}; + struct spdk_nvmf_rdma_request_data data; + struct spdk_nvmf_transport_pg_cache_buf buffer; + struct spdk_nvmf_transport_pg_cache_buf *buffer_ptr; + const uint32_t data_bs = 512; + const uint32_t md_size = 8; + int rc, i; + void *aligned_buffer; + + data.wr.sg_list = data.sgl; + STAILQ_INIT(&group.group.buf_cache); + group.group.buf_cache_size = 0; + group.group.buf_cache_count = 0; + group.group.transport = &rtransport.transport; + STAILQ_INIT(&group.retired_bufs); + poller.group = &group; + rqpair.poller = &poller; + rqpair.max_send_sge = SPDK_NVMF_MAX_SGL_ENTRIES; + + sgl = &cmd.nvme_cmd.dptr.sgl1; + rdma_req.recv = &recv; + rdma_req.req.cmd = &cmd; + rdma_req.req.rsp = &cpl; + rdma_req.data.wr.sg_list = rdma_req.data.sgl; + rdma_req.req.qpair = &rqpair.qpair; + rdma_req.req.xfer = SPDK_NVME_DATA_CONTROLLER_TO_HOST; + + rtransport.transport.opts = g_rdma_ut_transport_opts; + rtransport.data_wr_pool = NULL; + rtransport.transport.data_buf_pool = NULL; + + device.attr.device_cap_flags = 0; + device.map = NULL; + g_rdma_mr.lkey = 0xABCD; + sgl->keyed.key = 0xEEEE; + sgl->address = 0xFFFF; + rdma_req.recv->buf = (void *)0xDDDD; + + /* Test 1: sgl type: keyed data block subtype: address */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl->keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + + /* Part 1: simple I/O, one SGL smaller than the transport io unit size, block size 512 */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs * 8; + sgl->keyed.length = data_bs * 4; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 4); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + for (i = 0; i < 4; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + + /* Part 2: simple I/O, one SGL equal to io unit size, io_unit_size is not aligned with md_size, + block size 512 */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs * 4; + sgl->keyed.length = data_bs * 4; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 4); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 5); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + for (i = 0; i < 3; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + CU_ASSERT(rdma_req.data.wr.sg_list[3].addr == 0x2000 + 3 * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[3].length == 488); + CU_ASSERT(rdma_req.data.wr.sg_list[3].lkey == g_rdma_mr.lkey); + + /* 2nd buffer consumed */ + CU_ASSERT(rdma_req.data.wr.sg_list[4].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[4].length == 24); + CU_ASSERT(rdma_req.data.wr.sg_list[4].lkey == g_rdma_mr.lkey); + + /* Part 3: simple I/O, one SGL equal io unit size, io_unit_size is equal to block size 512 bytes */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs; + sgl->keyed.length = data_bs; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == data_bs + md_size); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 1); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[0].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == g_rdma_mr.lkey); + + CU_ASSERT(rdma_req.req.iovcnt == 2); + CU_ASSERT(rdma_req.req.iov[0].iov_base == (void *)((unsigned long)0x2000)); + CU_ASSERT(rdma_req.req.iov[0].iov_len == data_bs); + /* 2nd buffer consumed for metadata */ + CU_ASSERT(rdma_req.req.iov[1].iov_base == (void *)((unsigned long)0x2000)); + CU_ASSERT(rdma_req.req.iov[1].iov_len == md_size); + + /* Part 4: simple I/O, one SGL equal io unit size, io_unit_size is aligned with md_size, + block size 512 */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = (data_bs + md_size) * 4; + sgl->keyed.length = data_bs * 4; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 4); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + for (i = 0; i < 4; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + + /* Part 5: simple I/O, one SGL equal to 2x io unit size, io_unit_size is aligned with md_size, + block size 512 */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = (data_bs + md_size) * 2; + sgl->keyed.length = data_bs * 4; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 4); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 4); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + for (i = 0; i < 2; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + } + for (i = 0; i < 2; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i + 2].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i + 2].length == data_bs); + } + + /* Part 6: simple I/O, one SGL larger than the transport io unit size, io_unit_size is not aligned to md_size, + block size 512 */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs * 4; + sgl->keyed.length = data_bs * 6; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 6); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 6); + CU_ASSERT((uint64_t)rdma_req.req.data == 0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 7); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT((uint64_t)rdma_req.req.buffers[0] == 0x2000); + + for (i = 0; i < 3; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == 0x2000 + i * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + CU_ASSERT(rdma_req.data.wr.sg_list[3].addr == 0x2000 + 3 * (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[3].length == 488); + CU_ASSERT(rdma_req.data.wr.sg_list[3].lkey == g_rdma_mr.lkey); + + /* 2nd IO buffer consumed */ + CU_ASSERT(rdma_req.data.wr.sg_list[4].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[4].length == 24); + CU_ASSERT(rdma_req.data.wr.sg_list[4].lkey == g_rdma_mr.lkey); + + CU_ASSERT(rdma_req.data.wr.sg_list[5].addr == 0x2000 + 24 + md_size); + CU_ASSERT(rdma_req.data.wr.sg_list[5].length == 512); + CU_ASSERT(rdma_req.data.wr.sg_list[5].lkey == g_rdma_mr.lkey); + + CU_ASSERT(rdma_req.data.wr.sg_list[6].addr == 0x2000 + 24 + 512 + md_size * 2); + CU_ASSERT(rdma_req.data.wr.sg_list[6].length == 512); + CU_ASSERT(rdma_req.data.wr.sg_list[6].lkey == g_rdma_mr.lkey); + + /* Part 7: simple I/O, number of SGL entries exceeds the number of entries + one WR can hold. Additional WR is chained */ + MOCK_SET(spdk_mempool_get, &data); + aligned_buffer = (void *)((uintptr_t)((char *)&data + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs * 16; + sgl->keyed.length = data_bs * 16; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 16); + CU_ASSERT(rdma_req.req.iovcnt == 2); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 16); + CU_ASSERT(rdma_req.req.data == aligned_buffer); + CU_ASSERT(rdma_req.data.wr.num_sge == 16); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + /* additional wr from pool */ + CU_ASSERT(rdma_req.data.wr.next == (void *)&data.wr); + CU_ASSERT(rdma_req.data.wr.next->num_sge == 1); + CU_ASSERT(rdma_req.data.wr.next->next == &rdma_req.rsp.wr); + + /* Part 8: simple I/O, data with metadata do not fit to 1 io_buffer */ + MOCK_SET(spdk_mempool_get, (void *)0x2000); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = 516; + sgl->keyed.length = data_bs * 2; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 2); + CU_ASSERT(rdma_req.req.iovcnt == 3); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 2); + CU_ASSERT(rdma_req.req.data == (void *)0x2000); + CU_ASSERT(rdma_req.data.wr.num_sge == 2); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + + CU_ASSERT(rdma_req.data.wr.sg_list[0].addr == 0x2000); + CU_ASSERT(rdma_req.data.wr.sg_list[0].length == 512); + CU_ASSERT(rdma_req.data.wr.sg_list[0].lkey == g_rdma_mr.lkey); + + /* 2nd IO buffer consumed, offset 4 bytes due to part of the metadata + is located at the beginning of that buffer */ + CU_ASSERT(rdma_req.data.wr.sg_list[1].addr == 0x2000 + 4); + CU_ASSERT(rdma_req.data.wr.sg_list[1].length == 512); + CU_ASSERT(rdma_req.data.wr.sg_list[1].lkey == g_rdma_mr.lkey); + + /* Test 9 dealing with a buffer split over two Memory Regions */ + MOCK_SET(spdk_mempool_get, (void *)&buffer); + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, + 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = data_bs * 4; + sgl->keyed.length = data_bs * 2; + g_mr_size = data_bs; + g_mr_next_size = rtransport.transport.opts.io_unit_size; + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + SPDK_CU_ASSERT_FATAL(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == rtransport.transport.opts.io_unit_size / 2); + CU_ASSERT((uint64_t)rdma_req.req.data == (((uint64_t)&buffer + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK)); + CU_ASSERT(rdma_req.data.wr.num_sge == 2); + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0xEEEE); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0xFFFF); + CU_ASSERT(rdma_req.req.buffers[0] == &buffer); + for (i = 0; i < 2; i++) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == (uint64_t)rdma_req.req.data + i * + (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + CU_ASSERT(rdma_req.data.wr.sg_list[i].lkey == g_rdma_mr.lkey); + } + buffer_ptr = STAILQ_FIRST(&group.retired_bufs); + CU_ASSERT(buffer_ptr == &buffer); + STAILQ_REMOVE(&group.retired_bufs, buffer_ptr, spdk_nvmf_transport_pg_cache_buf, link); + CU_ASSERT(STAILQ_EMPTY(&group.retired_bufs)); + g_mr_size = 0; + g_mr_next_size = 0; + + /* Test 2: Multi SGL */ + sgl->generic.type = SPDK_NVME_SGL_TYPE_LAST_SEGMENT; + sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_OFFSET; + sgl->address = 0; + rdma_req.recv->buf = (void *)&sgl_desc; + MOCK_SET(spdk_mempool_get, &data); + aligned_buffer = (void *)((uintptr_t)((char *)&data + NVMF_DATA_BUFFER_MASK) & + ~NVMF_DATA_BUFFER_MASK); + + /* part 1: 2 segments each with 1 wr. io_unit_size is aligned with data_bs + md_size */ + reset_nvmf_rdma_request(&rdma_req); + spdk_dif_ctx_init(&rdma_req.req.dif.dif_ctx, data_bs + md_size, md_size, true, false, + SPDK_DIF_TYPE1, + SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK, 0, 0, 0, 0, 0); + rdma_req.req.dif.dif_insert_or_strip = true; + rtransport.transport.opts.io_unit_size = (data_bs + md_size) * 4; + sgl->unkeyed.length = 2 * sizeof(struct spdk_nvme_sgl_descriptor); + + for (i = 0; i < 2; i++) { + sgl_desc[i].keyed.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK; + sgl_desc[i].keyed.subtype = SPDK_NVME_SGL_SUBTYPE_ADDRESS; + sgl_desc[i].keyed.length = data_bs * 4; + sgl_desc[i].address = 0x4000 + i * data_bs * 4; + sgl_desc[i].keyed.key = 0x44; + } + + rc = nvmf_rdma_request_parse_sgl(&rtransport, &device, &rdma_req); + + CU_ASSERT(rc == 0); + CU_ASSERT(rdma_req.req.data_from_pool == true); + CU_ASSERT(rdma_req.req.length == data_bs * 4 * 2); + CU_ASSERT(rdma_req.req.dif.orig_length == rdma_req.req.length); + CU_ASSERT(rdma_req.req.dif.elba_length == (data_bs + md_size) * 4 * 2); + CU_ASSERT(rdma_req.data.wr.num_sge == 4); + for (i = 0; i < 4; ++i) { + CU_ASSERT(rdma_req.data.wr.sg_list[i].addr == (uintptr_t)((unsigned char *)aligned_buffer) + i * + (data_bs + md_size)); + CU_ASSERT(rdma_req.data.wr.sg_list[i].length == data_bs); + } + + CU_ASSERT(rdma_req.data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(rdma_req.data.wr.wr.rdma.remote_addr == 0x4000); + CU_ASSERT(rdma_req.data.wr.next == &data.wr); + CU_ASSERT(data.wr.wr.rdma.rkey == 0x44); + CU_ASSERT(data.wr.wr.rdma.remote_addr == 0x4000 + data_bs * 4); + CU_ASSERT(data.wr.num_sge == 4); + for (i = 0; i < 4; ++i) { + CU_ASSERT(data.wr.sg_list[i].addr == (uintptr_t)((unsigned char *)aligned_buffer) + i * + (data_bs + md_size)); + CU_ASSERT(data.wr.sg_list[i].length == data_bs); + } + + CU_ASSERT(data.wr.next == &rdma_req.rsp.wr); +} + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + + CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_parse_sgl); + CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_process); + CU_ADD_TEST(suite, test_nvmf_rdma_get_optimal_poll_group); + CU_ADD_TEST(suite, test_spdk_nvmf_rdma_request_parse_sgl_with_md); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/subsystem.c/.gitignore b/src/spdk/test/unit/lib/nvmf/subsystem.c/.gitignore new file mode 100644 index 000000000..76ca0d330 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/subsystem.c/.gitignore @@ -0,0 +1 @@ +subsystem_ut diff --git a/src/spdk/test/unit/lib/nvmf/subsystem.c/Makefile b/src/spdk/test/unit/lib/nvmf/subsystem.c/Makefile new file mode 100644 index 000000000..3d5fa6c8e --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/subsystem.c/Makefile @@ -0,0 +1,39 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +SPDK_LIB_LIST = json +TEST_FILE = subsystem_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/subsystem.c/subsystem_ut.c b/src/spdk/test/unit/lib/nvmf/subsystem.c/subsystem_ut.c new file mode 100644 index 000000000..149c22da1 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/subsystem.c/subsystem_ut.c @@ -0,0 +1,1342 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. All rights reserved. + * Copyright (c) 2019 Mellanox Technologies LTD. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" + +#include "common/lib/ut_multithread.c" +#include "spdk_cunit.h" +#include "spdk_internal/mock.h" +#include "spdk_internal/thread.h" + +#include "nvmf/subsystem.c" + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) + +DEFINE_STUB(spdk_bdev_module_claim_bdev, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, + struct spdk_bdev_module *module), 0); + +DEFINE_STUB_V(spdk_bdev_module_release_bdev, + (struct spdk_bdev *bdev)); + +DEFINE_STUB(spdk_bdev_get_block_size, uint32_t, + (const struct spdk_bdev *bdev), 512); + +DEFINE_STUB(spdk_bdev_get_md_size, uint32_t, + (const struct spdk_bdev *bdev), 0); + +DEFINE_STUB(spdk_bdev_is_md_interleaved, bool, + (const struct spdk_bdev *bdev), false); + +DEFINE_STUB(spdk_nvmf_transport_stop_listen, + int, + (struct spdk_nvmf_transport *transport, + const struct spdk_nvme_transport_id *trid), 0); + +int +spdk_nvmf_transport_listen(struct spdk_nvmf_transport *transport, + const struct spdk_nvme_transport_id *trid) +{ + return 0; +} + +void +nvmf_transport_listener_discover(struct spdk_nvmf_transport *transport, + struct spdk_nvme_transport_id *trid, + struct spdk_nvmf_discovery_log_page_entry *entry) +{ + entry->trtype = 42; +} + +static struct spdk_nvmf_transport g_transport = {}; + +struct spdk_nvmf_transport * +spdk_nvmf_transport_create(const char *transport_name, + struct spdk_nvmf_transport_opts *tprt_opts) +{ + if (strcasecmp(transport_name, spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_RDMA))) { + return &g_transport; + } + + return NULL; +} + +struct spdk_nvmf_subsystem * +spdk_nvmf_tgt_find_subsystem(struct spdk_nvmf_tgt *tgt, const char *subnqn) +{ + return NULL; +} + +struct spdk_nvmf_transport * +spdk_nvmf_tgt_get_transport(struct spdk_nvmf_tgt *tgt, const char *transport_name) +{ + if (strncmp(transport_name, SPDK_NVME_TRANSPORT_NAME_RDMA, SPDK_NVMF_TRSTRING_MAX_LEN)) { + return &g_transport; + } + + return NULL; +} + +int +nvmf_poll_group_update_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem) +{ + return 0; +} + +int +nvmf_poll_group_add_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ + return 0; +} + +void +nvmf_poll_group_remove_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +void +nvmf_poll_group_pause_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +void +nvmf_poll_group_resume_subsystem(struct spdk_nvmf_poll_group *group, + struct spdk_nvmf_subsystem *subsystem, + spdk_nvmf_poll_group_mod_done cb_fn, void *cb_arg) +{ +} + +int +spdk_nvme_transport_id_parse_trtype(enum spdk_nvme_transport_type *trtype, const char *str) +{ + if (trtype == NULL || str == NULL) { + return -EINVAL; + } + + if (strcasecmp(str, "PCIe") == 0) { + *trtype = SPDK_NVME_TRANSPORT_PCIE; + } else if (strcasecmp(str, "RDMA") == 0) { + *trtype = SPDK_NVME_TRANSPORT_RDMA; + } else { + return -ENOENT; + } + return 0; +} + +int +spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, + const struct spdk_nvme_transport_id *trid2) +{ + return 0; +} + +int32_t +spdk_nvme_ctrlr_process_admin_completions(struct spdk_nvme_ctrlr *ctrlr) +{ + return -1; +} + +int32_t +spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions) +{ + return -1; +} + +int +spdk_nvme_detach(struct spdk_nvme_ctrlr *ctrlr) +{ + return -1; +} + +void +nvmf_ctrlr_destruct(struct spdk_nvmf_ctrlr *ctrlr) +{ +} + +static struct spdk_nvmf_ctrlr *g_ns_changed_ctrlr = NULL; +static uint32_t g_ns_changed_nsid = 0; +void +nvmf_ctrlr_ns_changed(struct spdk_nvmf_ctrlr *ctrlr, uint32_t nsid) +{ + g_ns_changed_ctrlr = ctrlr; + g_ns_changed_nsid = nsid; +} + +int +spdk_bdev_open_ext(const char *bdev_name, bool write, spdk_bdev_event_cb_t event_cb, + void *event_ctx, struct spdk_bdev_desc **_desc) +{ + return 0; +} + +void +spdk_bdev_close(struct spdk_bdev_desc *desc) +{ +} + +const char * +spdk_bdev_get_name(const struct spdk_bdev *bdev) +{ + return "test"; +} + +const struct spdk_uuid * +spdk_bdev_get_uuid(const struct spdk_bdev *bdev) +{ + return &bdev->uuid; +} + +static void +test_spdk_nvmf_subsystem_add_ns(void) +{ + struct spdk_nvmf_tgt tgt = {}; + struct spdk_nvmf_subsystem subsystem = { + .max_nsid = 0, + .ns = NULL, + .tgt = &tgt + }; + struct spdk_bdev bdev1 = {}, bdev2 = {}; + struct spdk_nvmf_ns_opts ns_opts; + uint32_t nsid; + int rc; + + tgt.max_subsystems = 1024; + tgt.subsystems = calloc(tgt.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); + SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); + + /* Allow NSID to be assigned automatically */ + spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); + nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev1, &ns_opts, sizeof(ns_opts), NULL); + /* NSID 1 is the first unused ID */ + CU_ASSERT(nsid == 1); + CU_ASSERT(subsystem.max_nsid == 1); + SPDK_CU_ASSERT_FATAL(subsystem.ns != NULL); + SPDK_CU_ASSERT_FATAL(subsystem.ns[nsid - 1] != NULL); + CU_ASSERT(subsystem.ns[nsid - 1]->bdev == &bdev1); + + /* Request a specific NSID */ + spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); + ns_opts.nsid = 5; + nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts), NULL); + CU_ASSERT(nsid == 5); + CU_ASSERT(subsystem.max_nsid == 5); + SPDK_CU_ASSERT_FATAL(subsystem.ns[nsid - 1] != NULL); + CU_ASSERT(subsystem.ns[nsid - 1]->bdev == &bdev2); + + /* Request an NSID that is already in use */ + spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); + ns_opts.nsid = 5; + nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts), NULL); + CU_ASSERT(nsid == 0); + CU_ASSERT(subsystem.max_nsid == 5); + + /* Request 0xFFFFFFFF (invalid NSID, reserved for broadcast) */ + spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); + ns_opts.nsid = 0xFFFFFFFF; + nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev2, &ns_opts, sizeof(ns_opts), NULL); + CU_ASSERT(nsid == 0); + CU_ASSERT(subsystem.max_nsid == 5); + + rc = spdk_nvmf_subsystem_remove_ns(&subsystem, 1); + CU_ASSERT(rc == 0); + rc = spdk_nvmf_subsystem_remove_ns(&subsystem, 5); + CU_ASSERT(rc == 0); + + free(subsystem.ns); + free(tgt.subsystems); +} + +static void +nvmf_test_create_subsystem(void) +{ + struct spdk_nvmf_tgt tgt = {}; + char nqn[256]; + struct spdk_nvmf_subsystem *subsystem; + + tgt.max_subsystems = 1024; + tgt.subsystems = calloc(tgt.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); + SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); + + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* valid name with complex reverse domain */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk-full--rev-domain.name:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* Valid name discovery controller */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + + /* Invalid name, no user supplied string */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Valid name, only contains top-level domain name */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* Invalid name, domain label > 63 characters */ + snprintf(nqn, sizeof(nqn), + "nqn.2016-06.io.abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz:sub"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid name, domain label starts with digit */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.3spdk:sub"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid name, domain label starts with - */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.-spdk:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid name, domain label ends with - */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk-:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid name, domain label with multiple consecutive periods */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io..spdk:subsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Longest valid name */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); + memset(nqn + strlen(nqn), 'a', 223 - strlen(nqn)); + nqn[223] = '\0'; + CU_ASSERT(strlen(nqn) == 223); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* Invalid name, too long */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:"); + memset(nqn + strlen(nqn), 'a', 224 - strlen(nqn)); + nqn[224] = '\0'; + CU_ASSERT(strlen(nqn) == 224); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + CU_ASSERT(subsystem == NULL); + + /* Valid name using uuid format */ + snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:11111111-aaaa-bbdd-FFEE-123456789abc"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* Invalid name user string contains an invalid utf-8 character */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:\xFFsubsystem1"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Valid name with non-ascii but valid utf-8 characters */ + snprintf(nqn, sizeof(nqn), "nqn.2016-06.io.spdk:\xe1\x8a\x88subsystem1\xca\x80"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem != NULL); + CU_ASSERT_STRING_EQUAL(subsystem->subnqn, nqn); + spdk_nvmf_subsystem_destroy(subsystem); + + /* Invalid uuid (too long) */ + snprintf(nqn, sizeof(nqn), + "nqn.2014-08.org.nvmexpress:uuid:11111111-aaaa-bbdd-FFEE-123456789abcdef"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid uuid (dashes placed incorrectly) */ + snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:111111-11aaaa-bbdd-FFEE-123456789abc"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + /* Invalid uuid (invalid characters in uuid) */ + snprintf(nqn, sizeof(nqn), "nqn.2014-08.org.nvmexpress:uuid:111hg111-aaaa-bbdd-FFEE-123456789abc"); + subsystem = spdk_nvmf_subsystem_create(&tgt, nqn, SPDK_NVMF_SUBTYPE_NVME, 0); + SPDK_CU_ASSERT_FATAL(subsystem == NULL); + + free(tgt.subsystems); +} + +static void +test_spdk_nvmf_subsystem_set_sn(void) +{ + struct spdk_nvmf_subsystem subsystem = {}; + + /* Basic valid serial number */ + CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "abcd xyz") == 0); + CU_ASSERT(strcmp(subsystem.sn, "abcd xyz") == 0); + + /* Exactly 20 characters (valid) */ + CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "12345678901234567890") == 0); + CU_ASSERT(strcmp(subsystem.sn, "12345678901234567890") == 0); + + /* 21 characters (too long, invalid) */ + CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "123456789012345678901") < 0); + + /* Non-ASCII characters (invalid) */ + CU_ASSERT(spdk_nvmf_subsystem_set_sn(&subsystem, "abcd\txyz") < 0); +} + +/* + * Reservation Unit Test Configuration + * -------- -------- -------- + * | Host A | | Host B | | Host C | + * -------- -------- -------- + * / \ | | + * -------- -------- ------- ------- + * |Ctrlr1_A| |Ctrlr2_A| |Ctrlr_B| |Ctrlr_C| + * -------- -------- ------- ------- + * \ \ / / + * \ \ / / + * \ \ / / + * -------------------------------------- + * | NAMESPACE 1 | + * -------------------------------------- + */ +static struct spdk_nvmf_subsystem g_subsystem; +static struct spdk_nvmf_ctrlr g_ctrlr1_A, g_ctrlr2_A, g_ctrlr_B, g_ctrlr_C; +static struct spdk_nvmf_ns g_ns; +static struct spdk_bdev g_bdev; +struct spdk_nvmf_subsystem_pg_ns_info g_ns_info; + +void +nvmf_ctrlr_async_event_reservation_notification(struct spdk_nvmf_ctrlr *ctrlr) +{ +} + +static void +ut_reservation_init(void) +{ + + TAILQ_INIT(&g_subsystem.ctrlrs); + + memset(&g_ns, 0, sizeof(g_ns)); + TAILQ_INIT(&g_ns.registrants); + g_ns.subsystem = &g_subsystem; + g_ns.ptpl_file = NULL; + g_ns.ptpl_activated = false; + spdk_uuid_generate(&g_bdev.uuid); + g_ns.bdev = &g_bdev; + + /* Host A has two controllers */ + spdk_uuid_generate(&g_ctrlr1_A.hostid); + TAILQ_INIT(&g_ctrlr1_A.log_head); + g_ctrlr1_A.subsys = &g_subsystem; + g_ctrlr1_A.num_avail_log_pages = 0; + TAILQ_INSERT_TAIL(&g_subsystem.ctrlrs, &g_ctrlr1_A, link); + spdk_uuid_copy(&g_ctrlr2_A.hostid, &g_ctrlr1_A.hostid); + TAILQ_INIT(&g_ctrlr2_A.log_head); + g_ctrlr2_A.subsys = &g_subsystem; + g_ctrlr2_A.num_avail_log_pages = 0; + TAILQ_INSERT_TAIL(&g_subsystem.ctrlrs, &g_ctrlr2_A, link); + + /* Host B has 1 controller */ + spdk_uuid_generate(&g_ctrlr_B.hostid); + TAILQ_INIT(&g_ctrlr_B.log_head); + g_ctrlr_B.subsys = &g_subsystem; + g_ctrlr_B.num_avail_log_pages = 0; + TAILQ_INSERT_TAIL(&g_subsystem.ctrlrs, &g_ctrlr_B, link); + + /* Host C has 1 controller */ + spdk_uuid_generate(&g_ctrlr_C.hostid); + TAILQ_INIT(&g_ctrlr_C.log_head); + g_ctrlr_C.subsys = &g_subsystem; + g_ctrlr_C.num_avail_log_pages = 0; + TAILQ_INSERT_TAIL(&g_subsystem.ctrlrs, &g_ctrlr_C, link); +} + +static void +ut_reservation_deinit(void) +{ + struct spdk_nvmf_registrant *reg, *tmp; + struct spdk_nvmf_reservation_log *log, *log_tmp; + struct spdk_nvmf_ctrlr *ctrlr, *ctrlr_tmp; + + TAILQ_FOREACH_SAFE(reg, &g_ns.registrants, link, tmp) { + TAILQ_REMOVE(&g_ns.registrants, reg, link); + free(reg); + } + TAILQ_FOREACH_SAFE(log, &g_ctrlr1_A.log_head, link, log_tmp) { + TAILQ_REMOVE(&g_ctrlr1_A.log_head, log, link); + free(log); + } + g_ctrlr1_A.num_avail_log_pages = 0; + TAILQ_FOREACH_SAFE(log, &g_ctrlr2_A.log_head, link, log_tmp) { + TAILQ_REMOVE(&g_ctrlr2_A.log_head, log, link); + free(log); + } + g_ctrlr2_A.num_avail_log_pages = 0; + TAILQ_FOREACH_SAFE(log, &g_ctrlr_B.log_head, link, log_tmp) { + TAILQ_REMOVE(&g_ctrlr_B.log_head, log, link); + free(log); + } + g_ctrlr_B.num_avail_log_pages = 0; + TAILQ_FOREACH_SAFE(log, &g_ctrlr_C.log_head, link, log_tmp) { + TAILQ_REMOVE(&g_ctrlr_C.log_head, log, link); + free(log); + } + g_ctrlr_C.num_avail_log_pages = 0; + + TAILQ_FOREACH_SAFE(ctrlr, &g_subsystem.ctrlrs, link, ctrlr_tmp) { + TAILQ_REMOVE(&g_subsystem.ctrlrs, ctrlr, link); + } +} + +static struct spdk_nvmf_request * +ut_reservation_build_req(uint32_t length) +{ + struct spdk_nvmf_request *req; + + req = calloc(1, sizeof(*req)); + assert(req != NULL); + + req->data = calloc(1, length); + assert(req->data != NULL); + req->length = length; + + req->cmd = (union nvmf_h2c_msg *)calloc(1, sizeof(union nvmf_h2c_msg)); + assert(req->cmd != NULL); + + req->rsp = (union nvmf_c2h_msg *)calloc(1, sizeof(union nvmf_c2h_msg)); + assert(req->rsp != NULL); + + return req; +} + +static void +ut_reservation_free_req(struct spdk_nvmf_request *req) +{ + free(req->cmd); + free(req->rsp); + free(req->data); + free(req); +} + +static void +ut_reservation_build_register_request(struct spdk_nvmf_request *req, + uint8_t rrega, uint8_t iekey, + uint8_t cptpl, uint64_t crkey, + uint64_t nrkey) +{ + struct spdk_nvme_reservation_register_data key; + struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; + + key.crkey = crkey; + key.nrkey = nrkey; + cmd->cdw10 = 0; + cmd->cdw10_bits.resv_register.rrega = rrega; + cmd->cdw10_bits.resv_register.iekey = iekey; + cmd->cdw10_bits.resv_register.cptpl = cptpl; + memcpy(req->data, &key, sizeof(key)); +} + +static void +ut_reservation_build_acquire_request(struct spdk_nvmf_request *req, + uint8_t racqa, uint8_t iekey, + uint8_t rtype, uint64_t crkey, + uint64_t prkey) +{ + struct spdk_nvme_reservation_acquire_data key; + struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; + + key.crkey = crkey; + key.prkey = prkey; + cmd->cdw10 = 0; + cmd->cdw10_bits.resv_acquire.racqa = racqa; + cmd->cdw10_bits.resv_acquire.iekey = iekey; + cmd->cdw10_bits.resv_acquire.rtype = rtype; + memcpy(req->data, &key, sizeof(key)); +} + +static void +ut_reservation_build_release_request(struct spdk_nvmf_request *req, + uint8_t rrela, uint8_t iekey, + uint8_t rtype, uint64_t crkey) +{ + struct spdk_nvme_cmd *cmd = &req->cmd->nvme_cmd; + + cmd->cdw10 = 0; + cmd->cdw10_bits.resv_release.rrela = rrela; + cmd->cdw10_bits.resv_release.iekey = iekey; + cmd->cdw10_bits.resv_release.rtype = rtype; + memcpy(req->data, &crkey, sizeof(crkey)); +} + +/* + * Construct four registrants for other test cases. + * + * g_ctrlr1_A register with key 0xa1. + * g_ctrlr2_A register with key 0xa1. + * g_ctrlr_B register with key 0xb1. + * g_ctrlr_C register with key 0xc1. + * */ +static void +ut_reservation_build_registrants(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + uint32_t gen; + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + gen = g_ns.gen; + + /* TEST CASE: g_ctrlr1_A register with a new key */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, + 0, 0, 0, 0xa1); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa1); + SPDK_CU_ASSERT_FATAL(g_ns.gen == gen + 1); + + /* TEST CASE: g_ctrlr2_A register with a new key, because it has same + * Host Identifier with g_ctrlr1_A, so the register key should same. + */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, + 0, 0, 0, 0xa2); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr2_A, req); + /* Reservation conflict for other key than 0xa1 */ + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_RESERVATION_CONFLICT); + + /* g_ctrlr_B register with a new key */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, + 0, 0, 0, 0xb1); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_B.hostid); + SPDK_CU_ASSERT_FATAL(reg->rkey == 0xb1); + SPDK_CU_ASSERT_FATAL(g_ns.gen == gen + 2); + + /* g_ctrlr_C register with a new key */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, + 0, 0, 0, 0xc1); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr_C, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_C.hostid); + SPDK_CU_ASSERT_FATAL(reg->rkey == 0xc1); + SPDK_CU_ASSERT_FATAL(g_ns.gen == gen + 3); + + ut_reservation_free_req(req); +} + +static void +test_reservation_register(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + uint32_t gen; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + + ut_reservation_build_registrants(); + + /* TEST CASE: Replace g_ctrlr1_A with a new key */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REPLACE_KEY, + 0, 0, 0xa1, 0xa11); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa11); + + /* TEST CASE: Host A with g_ctrlr1_A get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE + */ + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE, 0xa11, 0x0); + gen = g_ns.gen; + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE); + SPDK_CU_ASSERT_FATAL(g_ns.crkey == 0xa11); + SPDK_CU_ASSERT_FATAL(g_ns.holder == reg); + SPDK_CU_ASSERT_FATAL(g_ns.gen == gen); + + /* TEST CASE: g_ctrlr_C unregister with IEKEY enabled */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_UNREGISTER_KEY, + 1, 0, 0, 0); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr_C, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_C.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + + /* TEST CASE: g_ctrlr_B unregister with correct key */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_UNREGISTER_KEY, + 0, 0, 0xb1, 0); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_B.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + + /* TEST CASE: g_ctrlr1_A unregister with correct key, + * reservation should be removed as well. + */ + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_UNREGISTER_KEY, + 0, 0, 0xa11, 0); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(g_ns.crkey == 0); + SPDK_CU_ASSERT_FATAL(g_ns.holder == NULL); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_register_with_ptpl(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + bool update_sgroup = false; + int rc; + struct spdk_nvmf_reservation_info info; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + + /* TEST CASE: No persistent file, register with PTPL enabled will fail */ + g_ns.ptpl_file = NULL; + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, 0, + SPDK_NVME_RESERVE_PTPL_PERSIST_POWER_LOSS, 0, 0xa1); + update_sgroup = nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == false); + SPDK_CU_ASSERT_FATAL(rsp->status.sc != SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + + /* TEST CASE: Enable PTPL */ + g_ns.ptpl_file = "/tmp/Ns1PR.cfg"; + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, 0, + SPDK_NVME_RESERVE_PTPL_PERSIST_POWER_LOSS, 0, 0xa1); + update_sgroup = nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == true); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.ptpl_activated == true); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg != NULL); + SPDK_CU_ASSERT_FATAL(!spdk_uuid_compare(&g_ctrlr1_A.hostid, ®->hostid)); + /* Load reservation information from configuration file */ + memset(&info, 0, sizeof(info)); + rc = nvmf_ns_load_reservation(g_ns.ptpl_file, &info); + SPDK_CU_ASSERT_FATAL(rc == 0); + SPDK_CU_ASSERT_FATAL(info.ptpl_activated == true); + + /* TEST CASE: Disable PTPL */ + rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD; + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, 0, + SPDK_NVME_RESERVE_PTPL_CLEAR_POWER_ON, 0, 0xa1); + update_sgroup = nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == true); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.ptpl_activated == false); + rc = nvmf_ns_load_reservation(g_ns.ptpl_file, &info); + SPDK_CU_ASSERT_FATAL(rc < 0); + unlink(g_ns.ptpl_file); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_acquire_preempt_1(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + uint32_t gen; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + + ut_reservation_build_registrants(); + + gen = g_ns.gen; + /* ACQUIRE: Host A with g_ctrlr1_A acquire reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE. + */ + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xa1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + SPDK_CU_ASSERT_FATAL(g_ns.crkey == 0xa1); + SPDK_CU_ASSERT_FATAL(g_ns.holder == reg); + SPDK_CU_ASSERT_FATAL(g_ns.gen == gen); + + /* TEST CASE: g_ctrlr1_A holds the reservation, g_ctrlr_B preempt g_ctrl1_A, + * g_ctrl1_A registrant is unregistred. + */ + gen = g_ns.gen; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_PREEMPT, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS, 0xb1, 0xa1); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_B.hostid); + SPDK_CU_ASSERT_FATAL(reg != NULL); + SPDK_CU_ASSERT_FATAL(g_ns.holder == reg); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_C.hostid); + SPDK_CU_ASSERT_FATAL(reg != NULL); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); + SPDK_CU_ASSERT_FATAL(g_ns.gen > gen); + + /* TEST CASE: g_ctrlr_B holds the reservation, g_ctrlr_C preempt g_ctrlr_B + * with valid key and PRKEY set to 0, all registrants other the host that issued + * the command are unregistered. + */ + gen = g_ns.gen; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_PREEMPT, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS, 0xc1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_C, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr2_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_B.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_C.hostid); + SPDK_CU_ASSERT_FATAL(reg != NULL); + SPDK_CU_ASSERT_FATAL(g_ns.holder == reg); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); + SPDK_CU_ASSERT_FATAL(g_ns.gen > gen); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_acquire_release_with_ptpl(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + bool update_sgroup = false; + struct spdk_uuid holder_uuid; + int rc; + struct spdk_nvmf_reservation_info info; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + + /* TEST CASE: Enable PTPL */ + g_ns.ptpl_file = "/tmp/Ns1PR.cfg"; + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_REGISTER_KEY, 0, + SPDK_NVME_RESERVE_PTPL_PERSIST_POWER_LOSS, 0, 0xa1); + update_sgroup = nvmf_ns_reservation_register(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == true); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.ptpl_activated == true); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg != NULL); + SPDK_CU_ASSERT_FATAL(!spdk_uuid_compare(&g_ctrlr1_A.hostid, ®->hostid)); + /* Load reservation information from configuration file */ + memset(&info, 0, sizeof(info)); + rc = nvmf_ns_load_reservation(g_ns.ptpl_file, &info); + SPDK_CU_ASSERT_FATAL(rc == 0); + SPDK_CU_ASSERT_FATAL(info.ptpl_activated == true); + + /* TEST CASE: Acquire the reservation */ + rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xa1, 0x0); + update_sgroup = nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == true); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + memset(&info, 0, sizeof(info)); + rc = nvmf_ns_load_reservation(g_ns.ptpl_file, &info); + SPDK_CU_ASSERT_FATAL(rc == 0); + SPDK_CU_ASSERT_FATAL(info.ptpl_activated == true); + SPDK_CU_ASSERT_FATAL(info.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + SPDK_CU_ASSERT_FATAL(info.crkey == 0xa1); + spdk_uuid_parse(&holder_uuid, info.holder_uuid); + SPDK_CU_ASSERT_FATAL(!spdk_uuid_compare(&g_ctrlr1_A.hostid, &holder_uuid)); + + /* TEST CASE: Release the reservation */ + rsp->status.sc = SPDK_NVME_SC_INVALID_FIELD; + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_RELEASE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xa1); + update_sgroup = nvmf_ns_reservation_release(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(update_sgroup == true); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + memset(&info, 0, sizeof(info)); + rc = nvmf_ns_load_reservation(g_ns.ptpl_file, &info); + SPDK_CU_ASSERT_FATAL(rc == 0); + SPDK_CU_ASSERT_FATAL(info.rtype == 0); + SPDK_CU_ASSERT_FATAL(info.crkey == 0); + SPDK_CU_ASSERT_FATAL(info.ptpl_activated == true); + unlink(g_ns.ptpl_file); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_release(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + struct spdk_nvmf_registrant *reg; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + rsp = &req->rsp->nvme_cpl; + SPDK_CU_ASSERT_FATAL(req != NULL); + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host A with g_ctrlr1_A get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS + */ + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS, 0xa1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr1_A, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); + SPDK_CU_ASSERT_FATAL(g_ns.holder == reg); + + /* Test Case: Host B release the reservation */ + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_RELEASE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS, 0xb1); + nvmf_ns_reservation_release(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(g_ns.crkey == 0); + SPDK_CU_ASSERT_FATAL(g_ns.holder == NULL); + + /* Test Case: Host C clear the registrants */ + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_CLEAR, 0, + 0, 0xc1); + nvmf_ns_reservation_release(&g_ns, &g_ctrlr_C, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr1_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr2_A.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_B.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + reg = nvmf_ns_reservation_get_registrant(&g_ns, &g_ctrlr_C.hostid); + SPDK_CU_ASSERT_FATAL(reg == NULL); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +void +nvmf_ctrlr_reservation_notice_log(struct spdk_nvmf_ctrlr *ctrlr, + struct spdk_nvmf_ns *ns, + enum spdk_nvme_reservation_notification_log_page_type type) +{ + ctrlr->num_avail_log_pages++; +} + +static void +test_reservation_unregister_notification(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + SPDK_CU_ASSERT_FATAL(req != NULL); + rsp = &req->rsp->nvme_cpl; + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host B with g_ctrlr_B get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY + */ + rsp->status.sc = 0xff; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xb1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + + /* Test Case : g_ctrlr_B holds the reservation, g_ctrlr_B unregister the registration. + * Reservation release notification sends to g_ctrlr1_A/g_ctrlr2_A/g_ctrlr_C only for + * SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY or SPDK_NVME_RESERVE_EXCLUSIVE_ACCESS_REG_ONLY + * type. + */ + rsp->status.sc = 0xff; + g_ctrlr1_A.num_avail_log_pages = 0; + g_ctrlr2_A.num_avail_log_pages = 0; + g_ctrlr_B.num_avail_log_pages = 5; + g_ctrlr_C.num_avail_log_pages = 0; + ut_reservation_build_register_request(req, SPDK_NVME_RESERVE_UNREGISTER_KEY, + 0, 0, 0xb1, 0); + nvmf_ns_reservation_register(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr1_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr2_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_B.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr_C.num_avail_log_pages); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_release_notification(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + SPDK_CU_ASSERT_FATAL(req != NULL); + rsp = &req->rsp->nvme_cpl; + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host B with g_ctrlr_B get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY + */ + rsp->status.sc = 0xff; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xb1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + + /* Test Case : g_ctrlr_B holds the reservation, g_ctrlr_B release the reservation. + * Reservation release notification sends to g_ctrlr1_A/g_ctrlr2_A/g_ctrlr_C. + */ + rsp->status.sc = 0xff; + g_ctrlr1_A.num_avail_log_pages = 0; + g_ctrlr2_A.num_avail_log_pages = 0; + g_ctrlr_B.num_avail_log_pages = 5; + g_ctrlr_C.num_avail_log_pages = 0; + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_RELEASE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xb1); + nvmf_ns_reservation_release(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr1_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr2_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_B.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr_C.num_avail_log_pages); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_release_notification_write_exclusive(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + SPDK_CU_ASSERT_FATAL(req != NULL); + rsp = &req->rsp->nvme_cpl; + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host B with g_ctrlr_B get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE + */ + rsp->status.sc = 0xff; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE, 0xb1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE); + + /* Test Case : g_ctrlr_B holds the reservation, g_ctrlr_B release the reservation. + * Because the reservation type is SPDK_NVME_RESERVE_WRITE_EXCLUSIVE, + * no reservation notification occurs. + */ + rsp->status.sc = 0xff; + g_ctrlr1_A.num_avail_log_pages = 5; + g_ctrlr2_A.num_avail_log_pages = 5; + g_ctrlr_B.num_avail_log_pages = 5; + g_ctrlr_C.num_avail_log_pages = 5; + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_RELEASE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE, 0xb1); + nvmf_ns_reservation_release(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr1_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr2_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_B.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_C.num_avail_log_pages); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_clear_notification(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + SPDK_CU_ASSERT_FATAL(req != NULL); + rsp = &req->rsp->nvme_cpl; + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host B with g_ctrlr_B get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY + */ + rsp->status.sc = 0xff; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xb1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + + /* Test Case : g_ctrlr_B holds the reservation, g_ctrlr_B clear the reservation. + * Reservation Preempted notification sends to g_ctrlr1_A/g_ctrlr2_A/g_ctrlr_C. + */ + rsp->status.sc = 0xff; + g_ctrlr1_A.num_avail_log_pages = 0; + g_ctrlr2_A.num_avail_log_pages = 0; + g_ctrlr_B.num_avail_log_pages = 5; + g_ctrlr_C.num_avail_log_pages = 0; + ut_reservation_build_release_request(req, SPDK_NVME_RESERVE_CLEAR, 0, + 0, 0xb1); + nvmf_ns_reservation_release(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == 0); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr1_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr2_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_B.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr_C.num_avail_log_pages); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_reservation_preempt_notification(void) +{ + struct spdk_nvmf_request *req; + struct spdk_nvme_cpl *rsp; + + ut_reservation_init(); + + req = ut_reservation_build_req(16); + SPDK_CU_ASSERT_FATAL(req != NULL); + rsp = &req->rsp->nvme_cpl; + + ut_reservation_build_registrants(); + + /* ACQUIRE: Host B with g_ctrlr_B get reservation with + * type SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY + */ + rsp->status.sc = 0xff; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_ACQUIRE, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY, 0xb1, 0x0); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_B, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_REG_ONLY); + + /* Test Case : g_ctrlr_B holds the reservation, g_ctrlr_C preempt g_ctrlr_B, + * g_ctrlr_B registrant is unregistred, and reservation is preempted. + * Registration Preempted notification sends to g_ctrlr_B. + * Reservation Preempted notification sends to g_ctrlr1_A/g_ctrlr2_A. + */ + rsp->status.sc = 0xff; + g_ctrlr1_A.num_avail_log_pages = 0; + g_ctrlr2_A.num_avail_log_pages = 0; + g_ctrlr_B.num_avail_log_pages = 0; + g_ctrlr_C.num_avail_log_pages = 5; + ut_reservation_build_acquire_request(req, SPDK_NVME_RESERVE_PREEMPT, 0, + SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS, 0xc1, 0xb1); + nvmf_ns_reservation_acquire(&g_ns, &g_ctrlr_C, req); + SPDK_CU_ASSERT_FATAL(rsp->status.sc == SPDK_NVME_SC_SUCCESS); + SPDK_CU_ASSERT_FATAL(g_ns.rtype == SPDK_NVME_RESERVE_WRITE_EXCLUSIVE_ALL_REGS); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr1_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr2_A.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(1 == g_ctrlr_B.num_avail_log_pages); + SPDK_CU_ASSERT_FATAL(5 == g_ctrlr_C.num_avail_log_pages); + + ut_reservation_free_req(req); + ut_reservation_deinit(); +} + +static void +test_spdk_nvmf_ns_event(void) +{ + struct spdk_nvmf_tgt tgt = {}; + struct spdk_nvmf_subsystem subsystem = { + .max_nsid = 0, + .ns = NULL, + .tgt = &tgt + }; + struct spdk_nvmf_ctrlr ctrlr = { + .subsys = &subsystem + }; + struct spdk_bdev bdev1 = {}; + struct spdk_nvmf_ns_opts ns_opts; + uint32_t nsid; + + tgt.max_subsystems = 1024; + tgt.subsystems = calloc(tgt.max_subsystems, sizeof(struct spdk_nvmf_subsystem *)); + SPDK_CU_ASSERT_FATAL(tgt.subsystems != NULL); + + /* Add one namespace */ + spdk_nvmf_ns_opts_get_defaults(&ns_opts, sizeof(ns_opts)); + nsid = spdk_nvmf_subsystem_add_ns(&subsystem, &bdev1, &ns_opts, sizeof(ns_opts), NULL); + CU_ASSERT(nsid == 1); + CU_ASSERT(NULL != subsystem.ns[0]); + + /* Add one controller */ + TAILQ_INIT(&subsystem.ctrlrs); + TAILQ_INSERT_TAIL(&subsystem.ctrlrs, &ctrlr, link); + + /* Namespace resize event */ + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + g_ns_changed_nsid = 0xFFFFFFFF; + g_ns_changed_ctrlr = NULL; + nvmf_ns_event(SPDK_BDEV_EVENT_RESIZE, &bdev1, subsystem.ns[0]); + CU_ASSERT(SPDK_NVMF_SUBSYSTEM_PAUSING == subsystem.state); + + poll_threads(); + CU_ASSERT(1 == g_ns_changed_nsid); + CU_ASSERT(&ctrlr == g_ns_changed_ctrlr); + CU_ASSERT(SPDK_NVMF_SUBSYSTEM_ACTIVE == subsystem.state); + + /* Namespace remove event */ + subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE; + g_ns_changed_nsid = 0xFFFFFFFF; + g_ns_changed_ctrlr = NULL; + nvmf_ns_event(SPDK_BDEV_EVENT_REMOVE, &bdev1, subsystem.ns[0]); + CU_ASSERT(SPDK_NVMF_SUBSYSTEM_PAUSING == subsystem.state); + CU_ASSERT(0xFFFFFFFF == g_ns_changed_nsid); + CU_ASSERT(NULL == g_ns_changed_ctrlr); + + poll_threads(); + CU_ASSERT(1 == g_ns_changed_nsid); + CU_ASSERT(&ctrlr == g_ns_changed_ctrlr); + CU_ASSERT(NULL == subsystem.ns[0]); + CU_ASSERT(SPDK_NVMF_SUBSYSTEM_ACTIVE == subsystem.state); + + free(subsystem.ns); + free(tgt.subsystems); +} + + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + + CU_ADD_TEST(suite, nvmf_test_create_subsystem); + CU_ADD_TEST(suite, test_spdk_nvmf_subsystem_add_ns); + CU_ADD_TEST(suite, test_spdk_nvmf_subsystem_set_sn); + CU_ADD_TEST(suite, test_reservation_register); + CU_ADD_TEST(suite, test_reservation_register_with_ptpl); + CU_ADD_TEST(suite, test_reservation_acquire_preempt_1); + CU_ADD_TEST(suite, test_reservation_acquire_release_with_ptpl); + CU_ADD_TEST(suite, test_reservation_release); + CU_ADD_TEST(suite, test_reservation_unregister_notification); + CU_ADD_TEST(suite, test_reservation_release_notification); + CU_ADD_TEST(suite, test_reservation_release_notification_write_exclusive); + CU_ADD_TEST(suite, test_reservation_clear_notification); + CU_ADD_TEST(suite, test_reservation_preempt_notification); + CU_ADD_TEST(suite, test_spdk_nvmf_ns_event); + + allocate_threads(1); + set_thread(0); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + + free_threads(); + + return num_failures; +} diff --git a/src/spdk/test/unit/lib/nvmf/tcp.c/.gitignore b/src/spdk/test/unit/lib/nvmf/tcp.c/.gitignore new file mode 100644 index 000000000..ea821fbfa --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/tcp.c/.gitignore @@ -0,0 +1 @@ +tcp_ut diff --git a/src/spdk/test/unit/lib/nvmf/tcp.c/Makefile b/src/spdk/test/unit/lib/nvmf/tcp.c/Makefile new file mode 100644 index 000000000..2f6dc9b85 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/tcp.c/Makefile @@ -0,0 +1,38 @@ +# +# BSD LICENSE +# +# Copyright (c) Intel Corporation. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in +# the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Intel Corporation nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +# + +SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../../../..) + +TEST_FILE = tcp_ut.c + +include $(SPDK_ROOT_DIR)/mk/spdk.unittest.mk diff --git a/src/spdk/test/unit/lib/nvmf/tcp.c/tcp_ut.c b/src/spdk/test/unit/lib/nvmf/tcp.c/tcp_ut.c new file mode 100644 index 000000000..a6d6d9da3 --- /dev/null +++ b/src/spdk/test/unit/lib/nvmf/tcp.c/tcp_ut.c @@ -0,0 +1,722 @@ +/*- + * BSD LICENSE + * + * Copyright (c) Intel Corporation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "spdk/stdinc.h" +#include "spdk/nvmf_spec.h" +#include "spdk_cunit.h" + +#include "spdk_internal/mock.h" +#include "spdk_internal/thread.h" + +#include "common/lib/test_env.c" +#include "common/lib/test_sock.c" + +#include "nvmf/ctrlr.c" +#include "nvmf/tcp.c" + +#define UT_IPV4_ADDR "192.168.0.1" +#define UT_PORT "4420" +#define UT_NVMF_ADRFAM_INVALID 0xf +#define UT_MAX_QUEUE_DEPTH 128 +#define UT_MAX_QPAIRS_PER_CTRLR 128 +#define UT_IN_CAPSULE_DATA_SIZE 1024 +#define UT_MAX_IO_SIZE 4096 +#define UT_IO_UNIT_SIZE 1024 +#define UT_MAX_AQ_DEPTH 64 +#define UT_SQ_HEAD_MAX 128 +#define UT_NUM_SHARED_BUFFERS 128 + +SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF) + +DEFINE_STUB(spdk_nvmf_qpair_get_listen_trid, + int, + (struct spdk_nvmf_qpair *qpair, struct spdk_nvme_transport_id *trid), + 0); + +DEFINE_STUB(nvmf_subsystem_add_ctrlr, + int, + (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr), + 0); + +DEFINE_STUB(nvmf_subsystem_get_ctrlr, + struct spdk_nvmf_ctrlr *, + (struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid), + NULL); + +DEFINE_STUB(spdk_nvmf_tgt_find_subsystem, + struct spdk_nvmf_subsystem *, + (struct spdk_nvmf_tgt *tgt, const char *subnqn), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_listener_allowed, + bool, + (struct spdk_nvmf_subsystem *subsystem, const struct spdk_nvme_transport_id *trid), + true); + +DEFINE_STUB_V(nvmf_get_discovery_log_page, + (struct spdk_nvmf_tgt *tgt, const char *hostnqn, struct iovec *iov, + uint32_t iovcnt, uint64_t offset, uint32_t length)); + +DEFINE_STUB_V(nvmf_subsystem_remove_ctrlr, + (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr)); + +DEFINE_STUB(spdk_nvmf_subsystem_get_first_ns, + struct spdk_nvmf_ns *, + (struct spdk_nvmf_subsystem *subsystem), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_get_next_ns, + struct spdk_nvmf_ns *, + (struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns), + NULL); + +DEFINE_STUB(spdk_nvmf_subsystem_host_allowed, + bool, + (struct spdk_nvmf_subsystem *subsystem, const char *hostnqn), + true); + +DEFINE_STUB(nvmf_ctrlr_dsm_supported, + bool, + (struct spdk_nvmf_ctrlr *ctrlr), + false); + +DEFINE_STUB(nvmf_ctrlr_write_zeroes_supported, + bool, + (struct spdk_nvmf_ctrlr *ctrlr), + false); + +DEFINE_STUB(nvmf_bdev_ctrlr_read_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_write_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_compare_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_compare_and_write_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *cmp_req, struct spdk_nvmf_request *write_req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_write_zeroes_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_flush_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_dsm_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_nvme_passthru_io, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB(spdk_nvmf_bdev_ctrlr_abort_cmd, + int, + (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, + struct spdk_nvmf_request *req, struct spdk_nvmf_request *req_to_abort), + 0); + +DEFINE_STUB(nvmf_bdev_ctrlr_get_dif_ctx, + bool, + (struct spdk_bdev *bdev, struct spdk_nvme_cmd *cmd, struct spdk_dif_ctx *dif_ctx), + false); + +DEFINE_STUB(nvmf_transport_req_complete, + int, + (struct spdk_nvmf_request *req), + 0); + +DEFINE_STUB_V(spdk_nvmf_request_free_buffers, + (struct spdk_nvmf_request *req, struct spdk_nvmf_transport_poll_group *group, + struct spdk_nvmf_transport *transport)); + +DEFINE_STUB(spdk_sock_get_optimal_sock_group, + int, + (struct spdk_sock *sock, struct spdk_sock_group **group), + 0); + +DEFINE_STUB(spdk_sock_group_get_ctx, + void *, + (struct spdk_sock_group *group), + NULL); + +DEFINE_STUB(spdk_sock_set_priority, + int, + (struct spdk_sock *sock, int priority), + 0); + +DEFINE_STUB_V(nvmf_ns_reservation_request, (void *ctx)); + +DEFINE_STUB_V(spdk_nvme_trid_populate_transport, (struct spdk_nvme_transport_id *trid, + enum spdk_nvme_transport_type trtype)); +DEFINE_STUB_V(spdk_nvmf_transport_register, (const struct spdk_nvmf_transport_ops *ops)); + +DEFINE_STUB_V(spdk_nvmf_tgt_new_qpair, (struct spdk_nvmf_tgt *tgt, struct spdk_nvmf_qpair *qpair)); + +DEFINE_STUB_V(nvmf_transport_qpair_abort_request, + (struct spdk_nvmf_qpair *qpair, struct spdk_nvmf_request *req)); + +DEFINE_STUB_V(spdk_nvme_print_command, (uint16_t qid, struct spdk_nvme_cmd *cmd)); +DEFINE_STUB_V(spdk_nvme_print_completion, (uint16_t qid, struct spdk_nvme_cpl *cpl)); + +struct spdk_trace_histories *g_trace_histories; + +struct spdk_bdev { + int ut_mock; + uint64_t blockcnt; +}; + +int +spdk_nvme_transport_id_compare(const struct spdk_nvme_transport_id *trid1, + const struct spdk_nvme_transport_id *trid2) +{ + return 0; +} + +void +spdk_trace_register_object(uint8_t type, char id_prefix) +{ +} + +void +spdk_trace_register_description(const char *name, + uint16_t tpoint_id, uint8_t owner_type, + uint8_t object_type, uint8_t new_object, + uint8_t arg1_type, const char *arg1_name) +{ +} + +void +_spdk_trace_record(uint64_t tsc, uint16_t tpoint_id, uint16_t poller_id, + uint32_t size, uint64_t object_id, uint64_t arg1) +{ +} + +const char * +spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype) +{ + switch (trtype) { + case SPDK_NVME_TRANSPORT_PCIE: + return "PCIe"; + case SPDK_NVME_TRANSPORT_RDMA: + return "RDMA"; + case SPDK_NVME_TRANSPORT_FC: + return "FC"; + default: + return NULL; + } +} + +int +spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring) +{ + int len, i; + + if (trstring == NULL) { + return -EINVAL; + } + + len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN); + if (len == SPDK_NVMF_TRSTRING_MAX_LEN) { + return -EINVAL; + } + + /* cast official trstring to uppercase version of input. */ + for (i = 0; i < len; i++) { + trid->trstring[i] = toupper(trstring[i]); + } + return 0; +} + +int +spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx) +{ + return 0; +} + +int +spdk_nvmf_request_get_buffers(struct spdk_nvmf_request *req, + struct spdk_nvmf_transport_poll_group *group, + struct spdk_nvmf_transport *transport, + uint32_t length) +{ + /* length more than 1 io unit length will fail. */ + if (length >= transport->opts.io_unit_size) { + return -EINVAL; + } + + req->iovcnt = 1; + req->iov[0].iov_base = (void *)0xDEADBEEF; + + return 0; +} + + +void +nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata, + bool dif_insert_or_strip) +{ + uint64_t num_blocks; + + SPDK_CU_ASSERT_FATAL(ns->bdev != NULL); + num_blocks = ns->bdev->blockcnt; + nsdata->nsze = num_blocks; + nsdata->ncap = num_blocks; + nsdata->nuse = num_blocks; + nsdata->nlbaf = 0; + nsdata->flbas.format = 0; + nsdata->lbaf[0].lbads = spdk_u32log2(512); +} + +const char * +spdk_nvmf_subsystem_get_sn(const struct spdk_nvmf_subsystem *subsystem) +{ + return subsystem->sn; +} + +const char * +spdk_nvmf_subsystem_get_mn(const struct spdk_nvmf_subsystem *subsystem) +{ + return subsystem->mn; +} + +void +spdk_trace_add_register_fn(struct spdk_trace_register_fn *reg_fn) +{ +} + +static void +test_nvmf_tcp_create(void) +{ + struct spdk_thread *thread; + struct spdk_nvmf_transport *transport; + struct spdk_nvmf_tcp_transport *ttransport; + struct spdk_nvmf_transport_opts opts; + + thread = spdk_thread_create(NULL, NULL); + SPDK_CU_ASSERT_FATAL(thread != NULL); + spdk_set_thread(thread); + + /* case 1 */ + memset(&opts, 0, sizeof(opts)); + opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; + opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; + opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; + opts.max_io_size = UT_MAX_IO_SIZE; + opts.io_unit_size = UT_IO_UNIT_SIZE; + opts.max_aq_depth = UT_MAX_AQ_DEPTH; + opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; + /* expect success */ + transport = nvmf_tcp_create(&opts); + CU_ASSERT_PTR_NOT_NULL(transport); + ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); + SPDK_CU_ASSERT_FATAL(ttransport != NULL); + transport->opts = opts; + CU_ASSERT(transport->opts.max_queue_depth == UT_MAX_QUEUE_DEPTH); + CU_ASSERT(transport->opts.max_io_size == UT_MAX_IO_SIZE); + CU_ASSERT(transport->opts.in_capsule_data_size == UT_IN_CAPSULE_DATA_SIZE); + CU_ASSERT(transport->opts.io_unit_size == UT_IO_UNIT_SIZE); + /* destroy transport */ + spdk_mempool_free(ttransport->transport.data_buf_pool); + free(ttransport); + + /* case 2 */ + memset(&opts, 0, sizeof(opts)); + opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; + opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; + opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; + opts.max_io_size = UT_MAX_IO_SIZE; + opts.io_unit_size = UT_MAX_IO_SIZE + 1; + opts.max_aq_depth = UT_MAX_AQ_DEPTH; + opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; + /* expect success */ + transport = nvmf_tcp_create(&opts); + CU_ASSERT_PTR_NOT_NULL(transport); + ttransport = SPDK_CONTAINEROF(transport, struct spdk_nvmf_tcp_transport, transport); + SPDK_CU_ASSERT_FATAL(ttransport != NULL); + transport->opts = opts; + CU_ASSERT(transport->opts.max_queue_depth == UT_MAX_QUEUE_DEPTH); + CU_ASSERT(transport->opts.max_io_size == UT_MAX_IO_SIZE); + CU_ASSERT(transport->opts.in_capsule_data_size == UT_IN_CAPSULE_DATA_SIZE); + CU_ASSERT(transport->opts.io_unit_size == UT_MAX_IO_SIZE); + /* destroy transport */ + spdk_mempool_free(ttransport->transport.data_buf_pool); + free(ttransport); + + /* case 3 */ + memset(&opts, 0, sizeof(opts)); + opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; + opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; + opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; + opts.max_io_size = UT_MAX_IO_SIZE; + opts.io_unit_size = 16; + opts.max_aq_depth = UT_MAX_AQ_DEPTH; + /* expect failse */ + transport = nvmf_tcp_create(&opts); + CU_ASSERT_PTR_NULL(transport); + + spdk_thread_exit(thread); + while (!spdk_thread_is_exited(thread)) { + spdk_thread_poll(thread, 0, 0); + } + spdk_thread_destroy(thread); +} + +static void +test_nvmf_tcp_destroy(void) +{ + struct spdk_thread *thread; + struct spdk_nvmf_transport *transport; + struct spdk_nvmf_transport_opts opts; + + thread = spdk_thread_create(NULL, NULL); + SPDK_CU_ASSERT_FATAL(thread != NULL); + spdk_set_thread(thread); + + /* case 1 */ + memset(&opts, 0, sizeof(opts)); + opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; + opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; + opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; + opts.max_io_size = UT_MAX_IO_SIZE; + opts.io_unit_size = UT_IO_UNIT_SIZE; + opts.max_aq_depth = UT_MAX_AQ_DEPTH; + opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; + transport = nvmf_tcp_create(&opts); + CU_ASSERT_PTR_NOT_NULL(transport); + transport->opts = opts; + /* destroy transport */ + CU_ASSERT(nvmf_tcp_destroy(transport) == 0); + + spdk_thread_exit(thread); + while (!spdk_thread_is_exited(thread)) { + spdk_thread_poll(thread, 0, 0); + } + spdk_thread_destroy(thread); +} + +static void +test_nvmf_tcp_poll_group_create(void) +{ + struct spdk_nvmf_transport *transport; + struct spdk_nvmf_transport_poll_group *group; + struct spdk_thread *thread; + struct spdk_nvmf_transport_opts opts; + struct spdk_sock_group grp = {}; + + thread = spdk_thread_create(NULL, NULL); + SPDK_CU_ASSERT_FATAL(thread != NULL); + spdk_set_thread(thread); + + memset(&opts, 0, sizeof(opts)); + opts.max_queue_depth = UT_MAX_QUEUE_DEPTH; + opts.max_qpairs_per_ctrlr = UT_MAX_QPAIRS_PER_CTRLR; + opts.in_capsule_data_size = UT_IN_CAPSULE_DATA_SIZE; + opts.max_io_size = UT_MAX_IO_SIZE; + opts.io_unit_size = UT_IO_UNIT_SIZE; + opts.max_aq_depth = UT_MAX_AQ_DEPTH; + opts.num_shared_buffers = UT_NUM_SHARED_BUFFERS; + transport = nvmf_tcp_create(&opts); + CU_ASSERT_PTR_NOT_NULL(transport); + transport->opts = opts; + MOCK_SET(spdk_sock_group_create, &grp); + group = nvmf_tcp_poll_group_create(transport); + MOCK_CLEAR_P(spdk_sock_group_create); + SPDK_CU_ASSERT_FATAL(group); + group->transport = transport; + nvmf_tcp_poll_group_destroy(group); + nvmf_tcp_destroy(transport); + + spdk_thread_exit(thread); + while (!spdk_thread_is_exited(thread)) { + spdk_thread_poll(thread, 0, 0); + } + spdk_thread_destroy(thread); +} + +static void +test_nvmf_tcp_send_c2h_data(void) +{ + struct spdk_thread *thread; + struct spdk_nvmf_tcp_transport ttransport = {}; + struct spdk_nvmf_tcp_qpair tqpair = {}; + struct spdk_nvmf_tcp_req tcp_req = {}; + struct nvme_tcp_pdu pdu = {}; + struct spdk_nvme_tcp_c2h_data_hdr *c2h_data; + + thread = spdk_thread_create(NULL, NULL); + SPDK_CU_ASSERT_FATAL(thread != NULL); + spdk_set_thread(thread); + + tcp_req.pdu = &pdu; + tcp_req.req.length = 300; + + tqpair.qpair.transport = &ttransport.transport; + TAILQ_INIT(&tqpair.send_queue); + + /* Set qpair state to make unrelated operations NOP */ + tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; + tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_ERROR; + + tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; + + tcp_req.req.iov[0].iov_base = (void *)0xDEADBEEF; + tcp_req.req.iov[0].iov_len = 101; + tcp_req.req.iov[1].iov_base = (void *)0xFEEDBEEF; + tcp_req.req.iov[1].iov_len = 100; + tcp_req.req.iov[2].iov_base = (void *)0xC0FFEE; + tcp_req.req.iov[2].iov_len = 99; + tcp_req.req.iovcnt = 3; + tcp_req.req.length = 300; + + nvmf_tcp_send_c2h_data(&tqpair, &tcp_req); + + CU_ASSERT(TAILQ_FIRST(&tqpair.send_queue) == &pdu); + TAILQ_REMOVE(&tqpair.send_queue, &pdu, tailq); + + c2h_data = &pdu.hdr.c2h_data; + CU_ASSERT(c2h_data->datao == 0); + CU_ASSERT(c2h_data->datal = 300); + CU_ASSERT(c2h_data->common.plen == sizeof(*c2h_data) + 300); + CU_ASSERT(c2h_data->common.flags & SPDK_NVME_TCP_C2H_DATA_FLAGS_LAST_PDU); + + CU_ASSERT(pdu.data_iovcnt == 3); + CU_ASSERT((uint64_t)pdu.data_iov[0].iov_base == 0xDEADBEEF); + CU_ASSERT(pdu.data_iov[0].iov_len == 101); + CU_ASSERT((uint64_t)pdu.data_iov[1].iov_base == 0xFEEDBEEF); + CU_ASSERT(pdu.data_iov[1].iov_len == 100); + CU_ASSERT((uint64_t)pdu.data_iov[2].iov_base == 0xC0FFEE); + CU_ASSERT(pdu.data_iov[2].iov_len == 99); + + spdk_thread_exit(thread); + while (!spdk_thread_is_exited(thread)) { + spdk_thread_poll(thread, 0, 0); + } + spdk_thread_destroy(thread); +} + +#define NVMF_TCP_PDU_MAX_H2C_DATA_SIZE (128 * 1024) + +static void +test_nvmf_tcp_h2c_data_hdr_handle(void) +{ + struct spdk_nvmf_tcp_transport ttransport = {}; + struct spdk_nvmf_tcp_qpair tqpair = {}; + struct nvme_tcp_pdu pdu = {}; + struct spdk_nvmf_tcp_req tcp_req = {}; + struct spdk_nvme_tcp_h2c_data_hdr *h2c_data; + + TAILQ_INIT(&tqpair.state_queue[TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER]); + + /* Set qpair state to make unrelated operations NOP */ + tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; + tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_ERROR; + + tcp_req.req.iov[0].iov_base = (void *)0xDEADBEEF; + tcp_req.req.iov[0].iov_len = 101; + tcp_req.req.iov[1].iov_base = (void *)0xFEEDBEEF; + tcp_req.req.iov[1].iov_len = 99; + tcp_req.req.iovcnt = 2; + tcp_req.req.length = 200; + + tcp_req.req.cmd = (union nvmf_h2c_msg *)&tcp_req.cmd; + tcp_req.req.cmd->nvme_cmd.cid = 1; + tcp_req.ttag = 2; + + TAILQ_INSERT_TAIL(&tqpair.state_queue[TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER], + &tcp_req, state_link); + + h2c_data = &pdu.hdr.h2c_data; + h2c_data->cccid = 1; + h2c_data->ttag = 2; + h2c_data->datao = 0; + h2c_data->datal = 200; + + nvmf_tcp_h2c_data_hdr_handle(&ttransport, &tqpair, &pdu); + + CU_ASSERT(pdu.data_iovcnt == 2); + CU_ASSERT((uint64_t)pdu.data_iov[0].iov_base == 0xDEADBEEF); + CU_ASSERT(pdu.data_iov[0].iov_len == 101); + CU_ASSERT((uint64_t)pdu.data_iov[1].iov_base == 0xFEEDBEEF); + CU_ASSERT(pdu.data_iov[1].iov_len == 99); + + CU_ASSERT(TAILQ_FIRST(&tqpair.state_queue[TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER]) == + &tcp_req); + TAILQ_REMOVE(&tqpair.state_queue[TCP_REQUEST_STATE_TRANSFERRING_HOST_TO_CONTROLLER], + &tcp_req, state_link); +} + + +static void +test_nvmf_tcp_incapsule_data_handle(void) +{ + struct spdk_nvmf_tcp_transport ttransport = {}; + struct spdk_nvmf_tcp_qpair tqpair = {}; + struct nvme_tcp_pdu *pdu; + union nvmf_c2h_msg rsp0 = {}; + union nvmf_c2h_msg rsp = {}; + + struct spdk_nvmf_request *req_temp = NULL; + struct spdk_nvmf_tcp_req tcp_req2 = {}; + struct spdk_nvmf_tcp_req tcp_req1 = {}; + + struct spdk_nvme_tcp_cmd *capsule_data; + struct spdk_nvmf_capsule_cmd *nvmf_capsule_data; + struct spdk_nvme_sgl_descriptor *sgl; + + struct spdk_nvmf_transport_poll_group *group; + struct spdk_nvmf_tcp_poll_group tcp_group = {}; + struct spdk_sock_group grp = {}; + int i = 0; + + ttransport.transport.opts.max_io_size = UT_MAX_IO_SIZE; + ttransport.transport.opts.io_unit_size = UT_IO_UNIT_SIZE; + + tcp_group.sock_group = &grp; + TAILQ_INIT(&tcp_group.qpairs); + group = &tcp_group.group; + group->transport = &ttransport.transport; + STAILQ_INIT(&group->pending_buf_queue); + tqpair.group = &tcp_group; + + /* init tqpair, add pdu to pdu_in_progress and wait for the buff */ + for (i = TCP_REQUEST_STATE_FREE; i < TCP_REQUEST_NUM_STATES; i++) { + TAILQ_INIT(&tqpair.state_queue[i]); + } + + TAILQ_INIT(&tqpair.send_queue); + + TAILQ_INSERT_TAIL(&tqpair.state_queue[TCP_REQUEST_STATE_FREE], &tcp_req2, state_link); + tqpair.state_cntr[TCP_REQUEST_STATE_FREE]++; + tqpair.qpair.transport = &ttransport.transport; + tqpair.state = NVME_TCP_QPAIR_STATE_RUNNING; + tqpair.recv_state = NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PSH; + tqpair.qpair.state = SPDK_NVMF_QPAIR_ACTIVE; + + /* init a null tcp_req into tqpair TCP_REQUEST_STATE_FREE queue */ + tcp_req2.req.qpair = &tqpair.qpair; + tcp_req2.req.cmd = (union nvmf_h2c_msg *)&tcp_req2.cmd; + tcp_req2.req.rsp = &rsp; + + /* init tcp_req1 */ + tcp_req1.req.qpair = &tqpair.qpair; + tcp_req1.req.cmd = (union nvmf_h2c_msg *)&tcp_req1.cmd; + tcp_req1.req.rsp = &rsp0; + tcp_req1.state = TCP_REQUEST_STATE_NEW; + + TAILQ_INSERT_TAIL(&tqpair.state_queue[TCP_REQUEST_STATE_NEW], &tcp_req1, state_link); + tqpair.state_cntr[TCP_REQUEST_STATE_NEW]++; + + /* init pdu, make pdu need sgl buff */ + pdu = &tqpair.pdu_in_progress; + capsule_data = &pdu->hdr.capsule_cmd; + nvmf_capsule_data = (struct spdk_nvmf_capsule_cmd *)&pdu->hdr.capsule_cmd.ccsqe; + sgl = &capsule_data->ccsqe.dptr.sgl1; + + capsule_data->common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_CAPSULE_CMD; + capsule_data->common.hlen = sizeof(*capsule_data); + capsule_data->common.plen = 1096; + capsule_data->ccsqe.opc = SPDK_NVME_OPC_FABRIC; + + sgl->unkeyed.subtype = SPDK_NVME_SGL_SUBTYPE_TRANSPORT; + sgl->generic.type = SPDK_NVME_SGL_TYPE_TRANSPORT_DATA_BLOCK; + sgl->unkeyed.length = UT_IO_UNIT_SIZE; + + nvmf_capsule_data->fctype = SPDK_NVMF_FABRIC_COMMAND_CONNECT; + + /* insert tcp_req1 to pending_buf_queue, And this req takes precedence over the next req. */ + nvmf_tcp_req_process(&ttransport, &tcp_req1); + CU_ASSERT(STAILQ_FIRST(&group->pending_buf_queue) == &tcp_req1.req); + + sgl->unkeyed.length = UT_IO_UNIT_SIZE - 1; + + /* process tqpair capsule req. but we still remain req in pending_buff. */ + nvmf_tcp_capsule_cmd_hdr_handle(&ttransport, &tqpair, &tqpair.pdu_in_progress); + CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_PAYLOAD); + CU_ASSERT(STAILQ_FIRST(&group->pending_buf_queue) == &tcp_req1.req); + STAILQ_FOREACH(req_temp, &group->pending_buf_queue, buf_link) { + if (req_temp == &tcp_req2.req) { + break; + } + } + CU_ASSERT(req_temp == NULL); + CU_ASSERT(tqpair.pdu_in_progress.req == (void *)&tcp_req2); +} + + +int main(int argc, char **argv) +{ + CU_pSuite suite = NULL; + unsigned int num_failures; + + CU_set_error_action(CUEA_ABORT); + CU_initialize_registry(); + + suite = CU_add_suite("nvmf", NULL, NULL); + + CU_ADD_TEST(suite, test_nvmf_tcp_create); + CU_ADD_TEST(suite, test_nvmf_tcp_destroy); + CU_ADD_TEST(suite, test_nvmf_tcp_poll_group_create); + CU_ADD_TEST(suite, test_nvmf_tcp_send_c2h_data); + CU_ADD_TEST(suite, test_nvmf_tcp_h2c_data_hdr_handle); + CU_ADD_TEST(suite, test_nvmf_tcp_incapsule_data_handle); + + CU_basic_set_mode(CU_BRM_VERBOSE); + CU_basic_run_tests(); + num_failures = CU_get_number_of_failures(); + CU_cleanup_registry(); + return num_failures; +} |