d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

unittest/nvme_tcp: increase code coverage for nvme_tcp.c

Browse Source 
some functions code comprehensive coverage.

Signed-off-by: ChengqiangMeng <chengqiangx.meng@intel.com>
Change-Id: Iec707b2706cc873311eb2701f4f8c936de6e6b5a
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/8166
Community-CI: Mellanox Build Bot
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Aleksey Marchuk <alexeymar@mellanox.com>
This commit is contained in:
ChengqiangMeng 2021-06-03 08:28:07 +08:00 committed by Tomasz Zawadzki
parent 6564bd94ba
commit 621d9d3f63
3 changed files with 159 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
test/common/lib/nvme/common_stubs.h
View File

@ -77,10 +77,6 @@ DEFINE_STUB(nvme_ctrlr_get_vs, int, (struct spdk_nvme_ctrlr *ctrlr,
union spdk_nvme_vs_register *vs), 0);
DEFINE_STUB(nvme_ctrlr_get_cap, int, (struct spdk_nvme_ctrlr *ctrlr,
union spdk_nvme_cap_register *cap), 0);
DEFINE_STUB(nvme_qpair_init, int, (struct spdk_nvme_qpair *qpair, uint16_t id,
struct spdk_nvme_ctrlr *ctrlr,
enum spdk_nvme_qprio qprio,
uint32_t num_requests), 0);
DEFINE_STUB_V(nvme_qpair_deinit, (struct spdk_nvme_qpair *qpair));
DEFINE_STUB_V(spdk_nvme_transport_register, (const struct spdk_nvme_transport_ops *ops));
DEFINE_STUB(nvme_transport_ctrlr_connect_qpair, int, (struct spdk_nvme_ctrlr *ctrlr,
@ -112,3 +108,18 @@ DEFINE_STUB(nvme_fabric_qpair_connect, int, (struct spdk_nvme_qpair *qpair, uint
DEFINE_STUB_V(nvme_transport_ctrlr_disconnect_qpair, (struct spdk_nvme_ctrlr *ctrlr,
struct spdk_nvme_qpair *qpair));
DEFINE_STUB(nvme_poll_group_disconnect_qpair, int, (struct spdk_nvme_qpair *qpair), 0);
int
nvme_qpair_init(struct spdk_nvme_qpair *qpair, uint16_t id,
struct spdk_nvme_ctrlr *ctrlr,
enum spdk_nvme_qprio qprio,
uint32_t num_requests)
{
qpair->ctrlr = ctrlr;
qpair->id = id;
qpair->qprio = qprio;
qpair->trtype = SPDK_NVME_TRANSPORT_TCP;
qpair->poll_group = (void *)0xDEADBEEF;
return 0;
}

2
test/common/lib/test_sock.c
View File

@ -47,7 +47,7 @@ DEFINE_STUB(spdk_sock_listen_ext, struct spdk_sock *, (const char *ip, int port,
DEFINE_STUB_V(spdk_sock_get_default_opts, (struct spdk_sock_opts *opts));
DEFINE_STUB(spdk_sock_accept, struct spdk_sock *, (struct spdk_sock *sock), NULL);
DEFINE_STUB(spdk_sock_close, int, (struct spdk_sock **sock), 0);
DEFINE_STUB(spdk_sock_recv, ssize_t, (struct spdk_sock *sock, void *buf, size_t len), 0);
DEFINE_STUB(spdk_sock_recv, ssize_t, (struct spdk_sock *sock, void *buf, size_t len), 1);
DEFINE_STUB(spdk_sock_writev, ssize_t, (struct spdk_sock *sock, struct iovec *iov, int iovcnt), 0);
DEFINE_STUB(spdk_sock_readv, ssize_t, (struct spdk_sock *sock, struct iovec *iov, int iovcnt), 0);
DEFINE_STUB(spdk_sock_set_recvlowat, int, (struct spdk_sock *sock, int nbytes), 0);

143
test/unit/lib/nvme/nvme_tcp.c/nvme_tcp_ut.c
View File

@ -1383,6 +1383,145 @@ test_nvme_tcp_capsule_resp_hdr_handle(void)
nvme_tcp_free_reqs(&tqpair);
}
static void
test_nvme_tcp_ctrlr_connect_qpair(void)
{
struct spdk_nvme_ctrlr ctrlr = {};
struct spdk_nvme_qpair *qpair;
struct nvme_tcp_qpair tqpair = {};
struct nvme_tcp_pdu pdu = {};
struct nvme_tcp_pdu recv_pdu = {};
struct spdk_nvme_tcp_ic_req *ic_req = NULL;
int rc;
tqpair.qpair.trtype = SPDK_NVME_TRANSPORT_TCP;
tqpair.recv_pdu = &recv_pdu;
qpair = &tqpair.qpair;
tqpair.sock = (struct spdk_sock *)0xDEADBEEF;
tqpair.send_pdu = &pdu;
tqpair.qpair.ctrlr = &ctrlr;
ic_req = &pdu.hdr.ic_req;
tqpair.recv_pdu->hdr.common.pdu_type = SPDK_NVME_TCP_PDU_TYPE_IC_RESP;
tqpair.recv_pdu->hdr.common.plen = sizeof(struct spdk_nvme_tcp_ic_resp);
tqpair.recv_pdu->hdr.common.hlen = sizeof(struct spdk_nvme_tcp_ic_resp);
tqpair.recv_pdu->ch_valid_bytes = 8;
tqpair.recv_pdu->psh_valid_bytes = tqpair.recv_pdu->hdr.common.hlen;
tqpair.recv_pdu->hdr.ic_resp.maxh2cdata = 4096;
tqpair.recv_pdu->hdr.ic_resp.cpda = 1;
tqpair.flags.icreq_send_ack = 1;
tqpair.qpair.ctrlr->opts.header_digest = true;
tqpair.qpair.ctrlr->opts.data_digest = true;
TAILQ_INIT(&tqpair.send_queue);
rc = nvme_tcp_ctrlr_connect_qpair(&ctrlr, qpair);
CU_ASSERT(rc == 0);
CU_ASSERT(tqpair.maxr2t == NVME_TCP_MAX_R2T_DEFAULT);
CU_ASSERT(tqpair.state == NVME_TCP_QPAIR_STATE_RUNNING);
CU_ASSERT(tqpair.recv_state == NVME_TCP_PDU_RECV_STATE_AWAIT_PDU_CH);
CU_ASSERT(ic_req->common.hlen == sizeof(*ic_req));
CU_ASSERT(ic_req->common.plen == sizeof(*ic_req));
CU_ASSERT(ic_req->common.pdu_type == SPDK_NVME_TCP_PDU_TYPE_IC_REQ);
CU_ASSERT(ic_req->pfv == 0);
CU_ASSERT(ic_req->maxr2t == NVME_TCP_MAX_R2T_DEFAULT - 1);
CU_ASSERT(ic_req->hpda == NVME_TCP_HPDA_DEFAULT);
CU_ASSERT(ic_req->dgst.bits.hdgst_enable == true);
CU_ASSERT(ic_req->dgst.bits.ddgst_enable == true);
}
static void
test_nvme_tcp_ctrlr_disconnect_qpair(void)
{
struct spdk_nvme_ctrlr ctrlr = {};
struct spdk_nvme_qpair *qpair;
struct nvme_tcp_qpair tqpair = {
.qpair.trtype = SPDK_NVME_TRANSPORT_TCP,
};
struct nvme_tcp_poll_group tgroup = {};
struct nvme_tcp_pdu pdu = {};
qpair = &tqpair.qpair;
qpair->poll_group = &tgroup.group;
tqpair.sock = (struct spdk_sock *)0xDEADBEEF;
tqpair.needs_poll = true;
TAILQ_INIT(&tgroup.needs_poll);
TAILQ_INIT(&tqpair.send_queue);
TAILQ_INSERT_TAIL(&tgroup.needs_poll, &tqpair, link);
TAILQ_INSERT_TAIL(&tqpair.send_queue, &pdu, tailq);
nvme_tcp_ctrlr_disconnect_qpair(&ctrlr, qpair);
CU_ASSERT(tqpair.needs_poll == false);
CU_ASSERT(tqpair.sock == NULL);
CU_ASSERT(TAILQ_EMPTY(&tqpair.send_queue) == true);
}
static void
test_nvme_tcp_ctrlr_create_io_qpair(void)
{
struct spdk_nvme_qpair *qpair = NULL;
struct spdk_nvme_ctrlr ctrlr = {};
uint16_t qid = 1;
const struct spdk_nvme_io_qpair_opts opts = {
.io_queue_size = 1,
.qprio = SPDK_NVME_QPRIO_URGENT,
.io_queue_requests = 1,
};
struct nvme_tcp_qpair *tqpair;
ctrlr.trid.priority = 1;
ctrlr.trid.adrfam = SPDK_NVMF_ADRFAM_IPV4;
memcpy(ctrlr.trid.traddr, "192.168.1.78", sizeof("192.168.1.78"));
memcpy(ctrlr.trid.trsvcid, "23", sizeof("23"));
memcpy(ctrlr.opts.src_addr, "192.168.1.77", sizeof("192.168.1.77"));
memcpy(ctrlr.opts.src_svcid, "23", sizeof("23"));
qpair = nvme_tcp_ctrlr_create_io_qpair(&ctrlr, qid, &opts);
tqpair = nvme_tcp_qpair(qpair);
CU_ASSERT(qpair != NULL);
CU_ASSERT(qpair->id == 1);
CU_ASSERT(qpair->ctrlr == &ctrlr);
CU_ASSERT(qpair->qprio == SPDK_NVME_QPRIO_URGENT);
CU_ASSERT(qpair->trtype == SPDK_NVME_TRANSPORT_TCP);
CU_ASSERT(qpair->poll_group == (void *)0xDEADBEEF);
CU_ASSERT(tqpair->num_entries = 1);
free(tqpair->tcp_reqs);
spdk_free(tqpair->send_pdus);
free(tqpair);
}
static void
test_nvme_tcp_ctrlr_delete_io_qpair(void)
{
struct spdk_nvme_ctrlr *ctrlr = (struct spdk_nvme_ctrlr *)0xdeadbeef;
struct spdk_nvme_qpair *qpair;
struct nvme_tcp_qpair *tqpair;
struct nvme_tcp_req tcp_req = {};
struct nvme_request req = {};
int rc;
tqpair = calloc(1, sizeof(struct nvme_tcp_qpair));
tqpair->tcp_reqs = calloc(1, sizeof(struct nvme_tcp_req));
tqpair->send_pdus = calloc(1, sizeof(struct nvme_tcp_pdu));
tqpair->qpair.trtype = SPDK_NVME_TRANSPORT_TCP;
qpair = &tqpair->qpair;
tcp_req.req = &req;
tcp_req.req->qpair = &tqpair->qpair;
tcp_req.req->cb_fn = ut_nvme_complete_request;
tcp_req.tqpair = tqpair;
tcp_req.state = NVME_TCP_REQ_ACTIVE;
TAILQ_INIT(&tqpair->outstanding_reqs);
TAILQ_INSERT_TAIL(&tcp_req.tqpair->outstanding_reqs, &tcp_req, link);
rc = nvme_tcp_ctrlr_delete_io_qpair(ctrlr, qpair);
CU_ASSERT(rc == 0);
}
int main(int argc, char **argv)
{
CU_pSuite suite = NULL;
@ -1413,6 +1552,10 @@ int main(int argc, char **argv)
CU_ADD_TEST(suite, test_nvme_tcp_icresp_handle);
CU_ADD_TEST(suite, test_nvme_tcp_pdu_payload_handle);
CU_ADD_TEST(suite, test_nvme_tcp_capsule_resp_hdr_handle);
CU_ADD_TEST(suite, test_nvme_tcp_ctrlr_connect_qpair);
CU_ADD_TEST(suite, test_nvme_tcp_ctrlr_disconnect_qpair);
CU_ADD_TEST(suite, test_nvme_tcp_ctrlr_create_io_qpair);
CU_ADD_TEST(suite, test_nvme_tcp_ctrlr_delete_io_qpair);
CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();