2016-07-21 22:08:23 +00:00
|
|
|
/*-
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2017-05-02 18:18:25 +00:00
|
|
|
#include "spdk/stdinc.h"
|
2016-07-21 22:08:23 +00:00
|
|
|
|
|
|
|
#include "spdk_cunit.h"
|
2017-12-06 18:18:25 +00:00
|
|
|
#include "spdk_internal/mock.h"
|
2018-09-17 23:18:53 +00:00
|
|
|
#include "spdk_internal/thread.h"
|
2016-07-21 22:08:23 +00:00
|
|
|
|
2018-08-15 21:00:05 +00:00
|
|
|
#include "common/lib/ut_multithread.c"
|
2018-02-13 15:24:28 +00:00
|
|
|
#include "nvmf/ctrlr.c"
|
2016-07-21 22:08:23 +00:00
|
|
|
|
2017-08-30 18:06:33 +00:00
|
|
|
SPDK_LOG_REGISTER_COMPONENT("nvmf", SPDK_LOG_NVMF)
|
2016-07-21 22:08:23 +00:00
|
|
|
|
2018-02-21 23:10:39 +00:00
|
|
|
struct spdk_bdev {
|
|
|
|
int ut_mock;
|
2018-05-29 21:33:37 +00:00
|
|
|
uint64_t blockcnt;
|
2018-02-21 23:10:39 +00:00
|
|
|
};
|
2017-08-16 21:03:42 +00:00
|
|
|
|
2017-12-06 18:18:25 +00:00
|
|
|
DEFINE_STUB(spdk_nvmf_tgt_find_subsystem,
|
|
|
|
struct spdk_nvmf_subsystem *,
|
|
|
|
(struct spdk_nvmf_tgt *tgt, const char *subnqn),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_poll_group_create,
|
|
|
|
struct spdk_nvmf_poll_group *,
|
|
|
|
(struct spdk_nvmf_tgt *tgt),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_get_sn,
|
|
|
|
const char *,
|
|
|
|
(const struct spdk_nvmf_subsystem *subsystem),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
2018-12-29 19:39:48 +00:00
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_get_mn,
|
|
|
|
const char *,
|
|
|
|
(const struct spdk_nvmf_subsystem *subsystem),
|
|
|
|
NULL);
|
|
|
|
|
2017-12-06 18:18:25 +00:00
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_get_first_ns,
|
|
|
|
struct spdk_nvmf_ns *,
|
|
|
|
(struct spdk_nvmf_subsystem *subsystem),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_get_next_ns,
|
|
|
|
struct spdk_nvmf_ns *,
|
|
|
|
(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ns *prev_ns),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_host_allowed,
|
|
|
|
bool,
|
|
|
|
(struct spdk_nvmf_subsystem *subsystem, const char *hostnqn),
|
2018-05-04 17:52:28 +00:00
|
|
|
true);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_add_ctrlr,
|
|
|
|
int,
|
|
|
|
(struct spdk_nvmf_subsystem *subsystem, struct spdk_nvmf_ctrlr *ctrlr),
|
2018-05-04 17:52:28 +00:00
|
|
|
0);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_subsystem_get_ctrlr,
|
|
|
|
struct spdk_nvmf_ctrlr *,
|
|
|
|
(struct spdk_nvmf_subsystem *subsystem, uint16_t cntlid),
|
2018-05-04 17:52:28 +00:00
|
|
|
NULL);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_ctrlr_dsm_supported,
|
|
|
|
bool,
|
|
|
|
(struct spdk_nvmf_ctrlr *ctrlr),
|
2018-05-04 17:52:28 +00:00
|
|
|
false);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB(spdk_nvmf_ctrlr_write_zeroes_supported,
|
|
|
|
bool,
|
|
|
|
(struct spdk_nvmf_ctrlr *ctrlr),
|
2018-05-04 17:52:28 +00:00
|
|
|
false);
|
2017-12-06 18:18:25 +00:00
|
|
|
|
|
|
|
DEFINE_STUB_V(spdk_nvmf_get_discovery_log_page,
|
2018-11-29 21:11:31 +00:00
|
|
|
(struct spdk_nvmf_tgt *tgt, struct iovec *iov, uint32_t iovcnt, uint64_t offset, uint32_t length));
|
2017-12-06 18:18:25 +00:00
|
|
|
|
2018-09-07 21:05:01 +00:00
|
|
|
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, struct spdk_nvme_transport_id *trid),
|
|
|
|
true);
|
|
|
|
|
2018-08-02 02:21:45 +00:00
|
|
|
DEFINE_STUB(spdk_nvmf_transport_qpair_set_sqsize,
|
|
|
|
int,
|
|
|
|
(struct spdk_nvmf_qpair *qpair),
|
|
|
|
0);
|
|
|
|
|
2019-01-15 17:47:56 +00:00
|
|
|
DEFINE_STUB(spdk_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(spdk_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(spdk_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(spdk_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(spdk_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(spdk_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);
|
|
|
|
|
2019-01-15 20:19:42 +00:00
|
|
|
DEFINE_STUB(spdk_nvmf_transport_req_complete,
|
|
|
|
int,
|
|
|
|
(struct spdk_nvmf_request *req),
|
|
|
|
0);
|
|
|
|
|
2019-02-28 02:50:03 +00:00
|
|
|
DEFINE_STUB_V(spdk_nvmf_ns_reservation_request, (void *ctx));
|
|
|
|
|
2019-01-07 10:47:29 +00:00
|
|
|
int
|
|
|
|
spdk_nvmf_qpair_disconnect(struct spdk_nvmf_qpair *qpair, nvmf_qpair_disconnect_cb cb_fn, void *ctx)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-10-15 09:23:24 +00:00
|
|
|
void
|
2018-05-29 21:33:37 +00:00
|
|
|
spdk_nvmf_bdev_ctrlr_identify_ns(struct spdk_nvmf_ns *ns, struct spdk_nvme_ns_data *nsdata)
|
|
|
|
{
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2017-08-17 01:13:49 +00:00
|
|
|
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 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16;
|
|
|
|
CU_ASSERT(spdk_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(spdk_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 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16;
|
|
|
|
cmd.nvme_cmd.cdw12 = 2;
|
|
|
|
CU_ASSERT(spdk_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 = SPDK_NVME_LOG_ERROR | (req.length / 4 - 1) << 16;
|
|
|
|
CU_ASSERT(spdk_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;
|
|
|
|
}
|
|
|
|
|
2017-09-12 01:54:56 +00:00
|
|
|
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 = spdk_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);
|
|
|
|
}
|
|
|
|
|
2017-12-06 18:19:08 +00:00
|
|
|
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_transport transport;
|
|
|
|
struct spdk_nvmf_subsystem subsystem;
|
|
|
|
struct spdk_nvmf_request req;
|
2018-02-08 03:54:59 +00:00
|
|
|
struct spdk_nvmf_qpair admin_qpair;
|
2017-12-06 18:19:08 +00:00
|
|
|
struct spdk_nvmf_qpair qpair;
|
2017-12-06 18:19:50 +00:00
|
|
|
struct spdk_nvmf_qpair qpair2;
|
2017-12-06 18:19:08 +00:00
|
|
|
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));
|
2018-11-16 21:49:20 +00:00
|
|
|
group.thread = spdk_get_thread();
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
memset(&ctrlr, 0, sizeof(ctrlr));
|
|
|
|
ctrlr.subsys = &subsystem;
|
2018-06-01 22:00:20 +00:00
|
|
|
ctrlr.qpair_mask = spdk_bit_array_create(3);
|
|
|
|
SPDK_CU_ASSERT_FATAL(ctrlr.qpair_mask != NULL);
|
2017-12-06 18:19:08 +00:00
|
|
|
ctrlr.vcprop.cc.bits.en = 1;
|
|
|
|
ctrlr.vcprop.cc.bits.iosqes = 6;
|
|
|
|
ctrlr.vcprop.cc.bits.iocqes = 4;
|
|
|
|
|
2018-02-08 03:54:59 +00:00
|
|
|
memset(&admin_qpair, 0, sizeof(admin_qpair));
|
|
|
|
admin_qpair.group = &group;
|
|
|
|
|
2017-12-06 18:19:08 +00:00
|
|
|
memset(&tgt, 0, sizeof(tgt));
|
|
|
|
memset(&transport, 0, sizeof(transport));
|
2018-08-22 23:04:16 +00:00
|
|
|
transport.opts.max_queue_depth = 64;
|
|
|
|
transport.opts.max_qpairs_per_ctrlr = 3;
|
2017-12-06 18:19:08 +00:00
|
|
|
transport.tgt = &tgt;
|
|
|
|
|
|
|
|
memset(&qpair, 0, sizeof(qpair));
|
|
|
|
qpair.transport = &transport;
|
2018-02-08 03:54:59 +00:00
|
|
|
qpair.group = &group;
|
2019-01-15 20:19:42 +00:00
|
|
|
qpair.state = SPDK_NVMF_QPAIR_ACTIVE;
|
|
|
|
TAILQ_INIT(&qpair.outstanding);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
memset(&connect_data, 0, sizeof(connect_data));
|
|
|
|
memcpy(connect_data.hostid, hostid, sizeof(hostid));
|
|
|
|
connect_data.cntlid = 0xFFFF;
|
2018-04-09 23:10:21 +00:00
|
|
|
snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn);
|
|
|
|
snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
memset(&subsystem, 0, sizeof(subsystem));
|
2018-11-16 21:49:20 +00:00
|
|
|
subsystem.thread = spdk_get_thread();
|
2017-12-06 18:19:08 +00:00
|
|
|
subsystem.id = 1;
|
|
|
|
TAILQ_INIT(&subsystem.ctrlrs);
|
|
|
|
subsystem.tgt = &tgt;
|
|
|
|
subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
|
2018-12-14 01:57:55 +00:00
|
|
|
subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
|
2017-12-06 18:19:08 +00:00
|
|
|
snprintf(subsystem.subnqn, sizeof(subsystem.subnqn), "%s", subnqn);
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem);
|
|
|
|
MOCK_SET(spdk_nvmf_poll_group_create, &group);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* Valid admin connect command */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-27 04:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
|
|
|
|
CU_ASSERT(qpair.ctrlr != NULL);
|
2019-01-07 10:47:29 +00:00
|
|
|
spdk_nvmf_ctrlr_stop_keep_alive_timer(qpair.ctrlr);
|
2018-06-01 22:00:20 +00:00
|
|
|
spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
|
2017-12-06 18:19:08 +00:00
|
|
|
free(qpair.ctrlr);
|
|
|
|
qpair.ctrlr = NULL;
|
|
|
|
|
2019-04-24 12:59:50 +00:00
|
|
|
/* Valid admin connect command with kato = 0 */
|
|
|
|
cmd.connect_cmd.kato = 0;
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
|
|
|
rc = spdk_nvmf_ctrlr_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);
|
|
|
|
spdk_bit_array_free(&qpair.ctrlr->qpair_mask);
|
|
|
|
free(qpair.ctrlr);
|
|
|
|
qpair.ctrlr = NULL;
|
|
|
|
cmd.connect_cmd.kato = 120000;
|
|
|
|
|
2017-12-06 18:19:08 +00:00
|
|
|
/* Invalid data length */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
req.length = sizeof(connect_data) - 1;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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;
|
|
|
|
|
|
|
|
/* Unterminated subnqn */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
memset(connect_data.subnqn, 'a', sizeof(connect_data.subnqn));
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2018-04-09 23:10:21 +00:00
|
|
|
snprintf(connect_data.subnqn, sizeof(connect_data.subnqn), "%s", subnqn);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* Subsystem not found */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_tgt_find_subsystem, NULL);
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_tgt_find_subsystem, &subsystem);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* Unterminated hostnqn */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
memset(connect_data.hostnqn, 'b', sizeof(connect_data.hostnqn));
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2018-04-09 23:10:21 +00:00
|
|
|
snprintf(connect_data.hostnqn, sizeof(connect_data.hostnqn), "%s", hostnqn);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* Host not allowed */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_subsystem_host_allowed, false);
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_subsystem_host_allowed, true);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* Invalid sqsize == 0 */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
cmd.connect_cmd.sqsize = 0;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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 sqsize > max_queue_depth */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
cmd.connect_cmd.sqsize = 64;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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 cntlid for admin queue */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
connect_data.cntlid = 0x1234;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2017-12-06 18:19:08 +00:00
|
|
|
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;
|
|
|
|
|
2018-02-08 03:54:59 +00:00
|
|
|
ctrlr.admin_qpair = &admin_qpair;
|
|
|
|
ctrlr.subsys = &subsystem;
|
|
|
|
|
2017-12-06 18:19:08 +00:00
|
|
|
/* Valid I/O queue connect command */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr);
|
2017-12-06 18:19:08 +00:00
|
|
|
cmd.connect_cmd.qid = 1;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
CU_ASSERT(nvme_status_success(&rsp.nvme_cpl.status));
|
|
|
|
CU_ASSERT(qpair.ctrlr == &ctrlr);
|
|
|
|
qpair.ctrlr = NULL;
|
|
|
|
|
|
|
|
/* Non-existent controller */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, NULL);
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-27 04:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_SET(spdk_nvmf_subsystem_get_ctrlr, &ctrlr);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
|
|
|
/* I/O connect to discovery controller */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY;
|
2018-12-14 01:57:55 +00:00
|
|
|
subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
2019-04-24 12:59:50 +00:00
|
|
|
|
|
|
|
/* I/O connect to discovery controller keep-alive-timeout should be 0 */
|
|
|
|
cmd.connect_cmd.qid = 0;
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
subsystem.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY;
|
|
|
|
subsystem.state = SPDK_NVMF_SUBSYSTEM_ACTIVE;
|
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
|
|
|
rc = spdk_nvmf_ctrlr_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_INTERNAL_DEVICE_ERROR);
|
|
|
|
CU_ASSERT(qpair.ctrlr == NULL);
|
|
|
|
cmd.connect_cmd.qid = 1;
|
2017-12-06 18:19:08 +00:00
|
|
|
subsystem.subtype = SPDK_NVMF_SUBTYPE_NVME;
|
|
|
|
|
|
|
|
/* I/O connect to disabled controller */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
ctrlr.vcprop.cc.bits.en = 0;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
|
|
|
ctrlr.vcprop.cc.bits.en = 1;
|
|
|
|
|
|
|
|
/* I/O connect with invalid IOSQES */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
ctrlr.vcprop.cc.bits.iosqes = 3;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
|
|
|
ctrlr.vcprop.cc.bits.iosqes = 6;
|
|
|
|
|
|
|
|
/* I/O connect with invalid IOCQES */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
ctrlr.vcprop.cc.bits.iocqes = 3;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
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);
|
|
|
|
ctrlr.vcprop.cc.bits.iocqes = 4;
|
|
|
|
|
|
|
|
/* I/O connect with too many existing qpairs */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
2018-06-04 20:45:59 +00:00
|
|
|
spdk_bit_array_set(ctrlr.qpair_mask, 0);
|
|
|
|
spdk_bit_array_set(ctrlr.qpair_mask, 1);
|
|
|
|
spdk_bit_array_set(ctrlr.qpair_mask, 2);
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:08 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2017-12-06 18:19:08 +00:00
|
|
|
CU_ASSERT(rsp.nvme_cpl.status.sct == SPDK_NVME_SCT_COMMAND_SPECIFIC);
|
2018-06-04 20:54:23 +00:00
|
|
|
CU_ASSERT(rsp.nvme_cpl.status.sc == SPDK_NVME_SC_INVALID_QUEUE_IDENTIFIER);
|
2017-12-06 18:19:08 +00:00
|
|
|
CU_ASSERT(qpair.ctrlr == NULL);
|
2018-06-04 20:45:59 +00:00
|
|
|
spdk_bit_array_clear(ctrlr.qpair_mask, 0);
|
|
|
|
spdk_bit_array_clear(ctrlr.qpair_mask, 1);
|
|
|
|
spdk_bit_array_clear(ctrlr.qpair_mask, 2);
|
2017-12-06 18:19:08 +00:00
|
|
|
|
2017-12-06 18:19:50 +00:00
|
|
|
/* I/O connect with duplicate queue ID */
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
memset(&qpair2, 0, sizeof(qpair2));
|
2018-02-08 03:54:59 +00:00
|
|
|
qpair2.group = &group;
|
2017-12-06 18:19:50 +00:00
|
|
|
qpair2.qid = 1;
|
2018-06-01 22:00:20 +00:00
|
|
|
spdk_bit_array_set(ctrlr.qpair_mask, 1);
|
2017-12-06 18:19:50 +00:00
|
|
|
cmd.connect_cmd.qid = 1;
|
2019-01-15 20:19:42 +00:00
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
2017-12-06 18:19:50 +00:00
|
|
|
rc = spdk_nvmf_ctrlr_connect(&req);
|
2018-08-15 21:00:05 +00:00
|
|
|
poll_threads();
|
2018-02-08 03:54:59 +00:00
|
|
|
CU_ASSERT(rc == SPDK_NVMF_REQUEST_EXEC_STATUS_ASYNCHRONOUS);
|
2018-06-04 20:54:23 +00:00
|
|
|
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);
|
2017-12-06 18:19:50 +00:00
|
|
|
CU_ASSERT(qpair.ctrlr == NULL);
|
|
|
|
|
2017-12-06 18:19:08 +00:00
|
|
|
/* Clean up globals */
|
2018-07-10 17:47:14 +00:00
|
|
|
MOCK_CLEAR(spdk_nvmf_tgt_find_subsystem);
|
|
|
|
MOCK_CLEAR(spdk_nvmf_poll_group_create);
|
2018-06-01 22:00:20 +00:00
|
|
|
|
|
|
|
spdk_bit_array_free(&ctrlr.qpair_mask);
|
2017-12-06 18:19:08 +00:00
|
|
|
}
|
|
|
|
|
2018-02-21 23:10:39 +00:00
|
|
|
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 = SPDK_NVME_IDENTIFY_NS_ID_DESCRIPTOR_LIST;
|
|
|
|
|
|
|
|
/* Invalid NSID */
|
|
|
|
cmd.nvme_cmd.nsid = 0;
|
|
|
|
memset(&rsp, 0, sizeof(rsp));
|
|
|
|
CU_ASSERT(spdk_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(spdk_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(spdk_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(spdk_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(spdk_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);
|
2018-02-22 00:09:56 +00:00
|
|
|
|
|
|
|
/* 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(spdk_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);
|
2018-02-21 23:10:39 +00:00
|
|
|
}
|
|
|
|
|
2018-05-29 21:33:37 +00:00
|
|
|
static void
|
|
|
|
test_identify_ns(void)
|
|
|
|
{
|
|
|
|
struct spdk_nvmf_subsystem subsystem = {};
|
2018-10-11 07:07:16 +00:00
|
|
|
struct spdk_nvmf_transport transport = {};
|
|
|
|
struct spdk_nvmf_qpair admin_qpair = { .transport = &transport};
|
|
|
|
struct spdk_nvmf_ctrlr ctrlr = { .subsys = &subsystem, .admin_qpair = &admin_qpair };
|
2018-05-29 21:33:37 +00:00
|
|
|
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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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));
|
2018-10-11 07:28:23 +00:00
|
|
|
CU_ASSERT(spdk_nvmf_ctrlr_identify_ns(&ctrlr, &cmd, &rsp,
|
2018-05-29 21:33:37 +00:00
|
|
|
&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)));
|
|
|
|
}
|
|
|
|
|
2019-03-19 10:05:38 +00:00
|
|
|
/*
|
|
|
|
* 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);
|
|
|
|
}
|
|
|
|
|
2019-04-08 06:43:10 +00:00
|
|
|
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 = {0};
|
|
|
|
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;
|
|
|
|
spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
|
|
|
|
SPDK_NVME_REGISTRATION_PREEMPTED);
|
|
|
|
spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
|
|
|
|
SPDK_NVME_RESERVATION_RELEASED);
|
|
|
|
spdk_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 = &req;
|
|
|
|
req.qpair = &qpair;
|
|
|
|
TAILQ_INIT(&qpair.outstanding);
|
|
|
|
qpair.state = SPDK_NVMF_QPAIR_ACTIVE;
|
|
|
|
TAILQ_INSERT_TAIL(&qpair.outstanding, &req, link);
|
|
|
|
|
|
|
|
spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
|
|
|
|
SPDK_NVME_REGISTRATION_PREEMPTED);
|
|
|
|
spdk_nvmf_ctrlr_reservation_notice_log(&ctrlr, &ns,
|
|
|
|
SPDK_NVME_RESERVATION_RELEASED);
|
|
|
|
spdk_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 */
|
|
|
|
spdk_nvmf_get_reservation_notification_log_page(&ctrlr, (void *)logs, 0, sizeof(logs));
|
|
|
|
SPDK_CU_ASSERT_FATAL(ctrlr.num_avail_log_pages == 0);
|
|
|
|
}
|
|
|
|
|
2016-07-21 22:08:23 +00:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
CU_pSuite suite = NULL;
|
|
|
|
unsigned int num_failures;
|
|
|
|
|
|
|
|
if (CU_initialize_registry() != CUE_SUCCESS) {
|
|
|
|
return CU_get_error();
|
|
|
|
}
|
|
|
|
|
|
|
|
suite = CU_add_suite("nvmf", NULL, NULL);
|
|
|
|
if (suite == NULL) {
|
|
|
|
CU_cleanup_registry();
|
|
|
|
return CU_get_error();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (
|
2017-09-12 01:54:56 +00:00
|
|
|
CU_add_test(suite, "get_log_page", test_get_log_page) == NULL ||
|
2017-12-06 18:19:08 +00:00
|
|
|
CU_add_test(suite, "process_fabrics_cmd", test_process_fabrics_cmd) == NULL ||
|
2018-02-21 23:10:39 +00:00
|
|
|
CU_add_test(suite, "connect", test_connect) == NULL ||
|
2018-05-29 21:33:37 +00:00
|
|
|
CU_add_test(suite, "get_ns_id_desc_list", test_get_ns_id_desc_list) == NULL ||
|
2019-03-19 10:05:38 +00:00
|
|
|
CU_add_test(suite, "identify_ns", test_identify_ns) == NULL ||
|
|
|
|
CU_add_test(suite, "reservation_write_exclusive", test_reservation_write_exclusive) == NULL ||
|
|
|
|
CU_add_test(suite, "reservation_exclusive_access", test_reservation_exclusive_access) == NULL ||
|
|
|
|
CU_add_test(suite, "reservation_write_exclusive_regs_only_and_all_regs",
|
|
|
|
test_reservation_write_exclusive_regs_only_and_all_regs) == NULL ||
|
|
|
|
CU_add_test(suite, "reservation_exclusive_access_regs_only_and_all_regs",
|
2019-04-08 06:43:10 +00:00
|
|
|
test_reservation_exclusive_access_regs_only_and_all_regs) == NULL ||
|
|
|
|
CU_add_test(suite, "reservation_notification_log_page",
|
|
|
|
test_reservation_notification_log_page) == NULL
|
2017-09-12 01:54:56 +00:00
|
|
|
) {
|
2016-07-21 22:08:23 +00:00
|
|
|
CU_cleanup_registry();
|
|
|
|
return CU_get_error();
|
|
|
|
}
|
|
|
|
|
2018-08-15 21:00:05 +00:00
|
|
|
allocate_threads(1);
|
|
|
|
set_thread(0);
|
2018-11-16 21:49:20 +00:00
|
|
|
|
2016-07-21 22:08:23 +00:00
|
|
|
CU_basic_set_mode(CU_BRM_VERBOSE);
|
|
|
|
CU_basic_run_tests();
|
|
|
|
num_failures = CU_get_number_of_failures();
|
|
|
|
CU_cleanup_registry();
|
2018-11-16 21:49:20 +00:00
|
|
|
|
2018-08-15 21:00:05 +00:00
|
|
|
free_threads();
|
2018-11-16 21:49:20 +00:00
|
|
|
|
2016-07-21 22:08:23 +00:00
|
|
|
return num_failures;
|
|
|
|
}
|