1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2021 Intel Corporation.
3 * All rights reserved.
4 * Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 */
6
7 #include "spdk/stdinc.h"
8 #include "spdk_internal/cunit.h"
9 #include "nvme/nvme_fabric.c"
10 #include "common/lib/test_env.c"
11
SPDK_LOG_REGISTER_COMPONENT(nvme)12 SPDK_LOG_REGISTER_COMPONENT(nvme)
13
14 pid_t g_spdk_nvme_pid;
15 struct spdk_nvmf_fabric_prop_set_cmd g_ut_cmd = {};
16 struct spdk_nvmf_fabric_prop_get_rsp g_ut_response = {};
17
18 DEFINE_STUB_V(spdk_nvme_ctrlr_get_default_ctrlr_opts,
19 (struct spdk_nvme_ctrlr_opts *opts, size_t opts_size));
20
21 DEFINE_STUB(nvme_transport_ctrlr_set_reg_4, int,
22 (struct spdk_nvme_ctrlr *ctrlr,
23 uint32_t offset, uint32_t value), 0);
24
25 DEFINE_STUB_V(nvme_ctrlr_destruct, (struct spdk_nvme_ctrlr *ctrlr));
26
27 DEFINE_STUB(nvme_ctrlr_cmd_identify, int,
28 (struct spdk_nvme_ctrlr *ctrlr, uint8_t cns, uint16_t cntid,
29 uint32_t nsid, uint8_t csi, void *payload, size_t payload_size,
30 spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
31
32 DEFINE_STUB_V(nvme_ctrlr_connected, (struct spdk_nvme_probe_ctx *probe_ctx,
33 struct spdk_nvme_ctrlr *ctrlr));
34 DEFINE_STUB(nvme_ctrlr_add_process, int,
35 (struct spdk_nvme_ctrlr *ctrlr, void *devhandle), 0);
36
37 DEFINE_STUB(spdk_nvme_ctrlr_cmd_get_log_page, int,
38 (struct spdk_nvme_ctrlr *ctrlr, uint8_t log_page,
39 uint32_t nsid, void *payload, uint32_t payload_size,
40 uint64_t offset, spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
41
42 DEFINE_STUB(spdk_nvme_transport_available_by_name, bool,
43 (const char *transport_name), true);
44
45 DEFINE_STUB(nvme_transport_ctrlr_construct, struct spdk_nvme_ctrlr *,
46 (const struct spdk_nvme_transport_id *trid,
47 const struct spdk_nvme_ctrlr_opts *opts,
48 void *devhandle), NULL);
49
50 DEFINE_STUB(spdk_nvme_transport_id_adrfam_str, const char *,
51 (enum spdk_nvmf_adrfam adrfam), NULL);
52
53 DEFINE_STUB(nvme_ctrlr_process_init, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
54 DEFINE_STUB(nvme_fabric_qpair_authenticate_async, int, (struct spdk_nvme_qpair *qpair), 0);
55 DEFINE_STUB(nvme_fabric_qpair_authenticate_poll, int, (struct spdk_nvme_qpair *qpair), 0);
56
57 static struct spdk_nvmf_fabric_connect_data g_nvmf_data;
58 static struct nvme_request *g_request;
59
60 int
nvme_qpair_submit_request(struct spdk_nvme_qpair * qpair,struct nvme_request * req)61 nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req)
62 {
63 CU_ASSERT(nvme_payload_type(&req->payload) == NVME_PAYLOAD_TYPE_CONTIG);
64
65 g_request = req;
66 memcpy(&g_nvmf_data, req->payload.contig_or_cb_arg, sizeof(g_nvmf_data));
67
68 return 0;
69 }
70
71 void
nvme_completion_poll_cb(void * arg,const struct spdk_nvme_cpl * cpl)72 nvme_completion_poll_cb(void *arg, const struct spdk_nvme_cpl *cpl)
73 {
74 struct nvme_completion_poll_status *status = arg;
75
76 if (status->timed_out) {
77 spdk_free(status->dma_data);
78 free(status);
79 }
80
81 g_request = NULL;
82 }
83
84 static bool g_nvme_wait_for_completion_timeout;
85
86 int
nvme_wait_for_completion_robust_lock_timeout_poll(struct spdk_nvme_qpair * qpair,struct nvme_completion_poll_status * status,pthread_mutex_t * robust_mutex)87 nvme_wait_for_completion_robust_lock_timeout_poll(struct spdk_nvme_qpair *qpair,
88 struct nvme_completion_poll_status *status,
89 pthread_mutex_t *robust_mutex)
90 {
91 struct spdk_nvmf_fabric_connect_rsp *rsp = (void *)&status->cpl;
92
93 if (nvme_qpair_is_admin_queue(qpair)) {
94 rsp->status_code_specific.success.cntlid = 1;
95 }
96
97 status->timed_out = g_nvme_wait_for_completion_timeout;
98
99 return 0;
100 }
101
102 int
spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id * trid,const char * trstring)103 spdk_nvme_transport_id_populate_trstring(struct spdk_nvme_transport_id *trid, const char *trstring)
104 {
105 int len, i, rc;
106
107 if (trstring == NULL) {
108 return -EINVAL;
109 }
110
111 len = strnlen(trstring, SPDK_NVMF_TRSTRING_MAX_LEN);
112 if (len == SPDK_NVMF_TRSTRING_MAX_LEN) {
113 return -EINVAL;
114 }
115
116 rc = snprintf(trid->trstring, SPDK_NVMF_TRSTRING_MAX_LEN, "%s", trstring);
117 if (rc < 0) {
118 return rc;
119 }
120
121 /* cast official trstring to uppercase version of input. */
122 for (i = 0; i < len; i++) {
123 trid->trstring[i] = toupper(trid->trstring[i]);
124 }
125 return 0;
126 }
127
128 static struct spdk_nvme_transport_id g_ut_trid;
129 static bool g_ut_ctrlr_is_probed;
130
131 int
nvme_ctrlr_probe(const struct spdk_nvme_transport_id * trid,struct spdk_nvme_probe_ctx * probe_ctx,void * devhandle)132 nvme_ctrlr_probe(const struct spdk_nvme_transport_id *trid,
133 struct spdk_nvme_probe_ctx *probe_ctx, void *devhandle)
134 {
135 g_ut_trid = *trid;
136 g_ut_ctrlr_is_probed = true;
137
138 return 0;
139 }
140
141 const char *
spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype)142 spdk_nvme_transport_id_trtype_str(enum spdk_nvme_transport_type trtype)
143 {
144 switch (trtype) {
145 case SPDK_NVME_TRANSPORT_PCIE:
146 return "PCIe";
147 case SPDK_NVME_TRANSPORT_RDMA:
148 return "RDMA";
149 case SPDK_NVME_TRANSPORT_FC:
150 return "FC";
151 case SPDK_NVME_TRANSPORT_TCP:
152 return "TCP";
153 case SPDK_NVME_TRANSPORT_VFIOUSER:
154 return "VFIOUSER";
155 case SPDK_NVME_TRANSPORT_CUSTOM:
156 return "CUSTOM";
157 default:
158 return NULL;
159 }
160 }
161
162 DEFINE_RETURN_MOCK(nvme_wait_for_completion, int);
163 int
nvme_wait_for_completion(struct spdk_nvme_qpair * qpair,struct nvme_completion_poll_status * status)164 nvme_wait_for_completion(struct spdk_nvme_qpair *qpair,
165 struct nvme_completion_poll_status *status)
166 {
167 status->timed_out = false;
168 HANDLE_RETURN_MOCK(nvme_wait_for_completion);
169 return 0;
170 }
171
172 DEFINE_RETURN_MOCK(nvme_wait_for_completion_robust_lock, int);
173 int
nvme_wait_for_completion_robust_lock(struct spdk_nvme_qpair * qpair,struct nvme_completion_poll_status * status,pthread_mutex_t * robust_mutex)174 nvme_wait_for_completion_robust_lock(struct spdk_nvme_qpair *qpair,
175 struct nvme_completion_poll_status *status,
176 pthread_mutex_t *robust_mutex)
177 {
178 status->timed_out = false;
179 HANDLE_RETURN_MOCK(nvme_wait_for_completion_robust_lock);
180 return 0;
181 }
182
183 DEFINE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw, int);
184 int
spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr * ctrlr,struct spdk_nvme_cmd * cmd,void * buf,uint32_t len,spdk_nvme_cmd_cb cb_fn,void * cb_arg)185 spdk_nvme_ctrlr_cmd_admin_raw(struct spdk_nvme_ctrlr *ctrlr,
186 struct spdk_nvme_cmd *cmd,
187 void *buf, uint32_t len,
188 spdk_nvme_cmd_cb cb_fn, void *cb_arg)
189 {
190 struct spdk_nvmf_fabric_prop_set_cmd *cmd_tmp = (void *)cmd;
191 struct nvme_completion_poll_status *status = cb_arg;
192 struct spdk_nvmf_fabric_prop_get_rsp *response = (void *)&status->cpl;
193
194 g_ut_cmd.opcode = cmd_tmp->opcode;
195 g_ut_cmd.fctype = cmd_tmp->fctype;
196 g_ut_cmd.ofst = cmd_tmp->ofst;
197 g_ut_cmd.attrib.size = cmd_tmp->attrib.size;
198
199 if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET) {
200 g_ut_cmd.value.u64 = cmd_tmp->value.u64;
201 } else if (cmd_tmp->fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET) {
202 memcpy(&g_ut_response, response, sizeof(g_ut_response));
203 }
204
205 HANDLE_RETURN_MOCK(spdk_nvme_ctrlr_cmd_admin_raw);
206 return 0;
207 }
208
209 static void
abort_request(struct nvme_request * request)210 abort_request(struct nvme_request *request)
211 {
212 struct spdk_nvme_cpl cpl = {
213 .status = {
214 .sct = SPDK_NVME_SCT_GENERIC,
215 .sc = SPDK_NVME_SC_ABORTED_SQ_DELETION,
216 }
217 };
218
219 request->cb_fn(request->cb_arg, &cpl);
220 }
221
222 static void
test_nvme_fabric_prop_set_cmd(void)223 test_nvme_fabric_prop_set_cmd(void)
224 {
225 int rc;
226 struct spdk_nvme_ctrlr ctrlr = {};
227
228 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
229
230 rc = nvme_fabric_prop_set_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, 4096);
231 CU_ASSERT(rc == 0);
232 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
233 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_SET);
234 CU_ASSERT(g_ut_cmd.ofst == 1024);
235 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8);
236 CU_ASSERT(g_ut_cmd.value.u64 == 4096);
237 }
238
239 static void
test_nvme_fabric_prop_get_cmd(void)240 test_nvme_fabric_prop_get_cmd(void)
241 {
242 int rc;
243 uint64_t value;
244 struct spdk_nvme_ctrlr ctrlr = {};
245
246 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
247 memset(&g_ut_response, 0, sizeof(g_ut_response));
248 value = 0xFFDEADBEEF;
249
250 /* Case 1: size is SPDK_NVMF_PROP_SIZE_4 */
251 rc = nvme_fabric_prop_get_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_4, &value);
252 CU_ASSERT(rc == 0);
253 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
254 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET);
255 CU_ASSERT(g_ut_cmd.ofst == 1024);
256 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_4);
257 CU_ASSERT(g_ut_response.value.u32.low == (value & 0xFFFFFFFF));
258
259 /* Case 2: size is SPDK_NVMF_PROP_SIZE_8 */
260 memset(&g_ut_cmd, 0, sizeof(g_ut_cmd));
261 memset(&g_ut_response, 0, sizeof(g_ut_response));
262
263 rc = nvme_fabric_prop_get_cmd_sync(&ctrlr, 1024, SPDK_NVMF_PROP_SIZE_8, &value);
264 CU_ASSERT(rc == 0);
265 CU_ASSERT(g_ut_cmd.opcode == SPDK_NVME_OPC_FABRIC);
266 CU_ASSERT(g_ut_cmd.fctype == SPDK_NVMF_FABRIC_COMMAND_PROPERTY_GET);
267 CU_ASSERT(g_ut_cmd.ofst == 1024);
268 CU_ASSERT(g_ut_cmd.attrib.size == SPDK_NVMF_PROP_SIZE_8);
269 CU_ASSERT(g_ut_response.value.u64 == value);
270 }
271
272 static void
test_nvme_fabric_get_discovery_log_page(void)273 test_nvme_fabric_get_discovery_log_page(void)
274 {
275 struct spdk_nvme_ctrlr ctrlr = {};
276 char buffer[4096] = {};
277 uint64_t offset = 0;
278 int rc;
279
280 rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
281 CU_ASSERT(rc == 0);
282
283 /* Get log page fail */
284 MOCK_SET(spdk_nvme_ctrlr_cmd_get_log_page, -EINVAL);
285
286 rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
287 CU_ASSERT(rc == -1);
288 MOCK_CLEAR(spdk_nvme_ctrlr_cmd_get_log_page);
289
290 /* Completion time out */
291 MOCK_SET(nvme_wait_for_completion, -1);
292
293 rc = nvme_fabric_get_discovery_log_page(&ctrlr, buffer, sizeof(buffer), offset);
294 CU_ASSERT(rc == -1);
295 MOCK_CLEAR(nvme_wait_for_completion);
296 }
297
298 static void
test_nvme_fabric_discover_probe(void)299 test_nvme_fabric_discover_probe(void)
300 {
301 struct spdk_nvmf_discovery_log_page_entry entry = {};
302 struct spdk_nvme_probe_ctx probe_ctx = {};
303 char hostnqn[256] = "nqn.2016-06.io.spdk:cnode1";
304 char traddr[SPDK_NVMF_TRADDR_MAX_LEN] = "192.168.100.8";
305 char trsvcid[SPDK_NVMF_TRSVCID_MAX_LEN] = "4420";
306 char trstring[SPDK_NVMF_TRSTRING_MAX_LEN + 1] = "RDMA";
307
308 entry.trtype = SPDK_NVME_TRANSPORT_RDMA;
309 entry.subtype = SPDK_NVMF_SUBTYPE_NVME;
310 entry.adrfam = SPDK_NVMF_ADRFAM_IPV4;
311
312 memcpy(entry.subnqn, hostnqn, 256);
313 memcpy(entry.traddr, traddr, SPDK_NVMF_TRADDR_MAX_LEN);
314 memcpy(entry.trsvcid, trsvcid, SPDK_NVMF_TRSVCID_MAX_LEN);
315 memcpy(probe_ctx.trid.trstring, trstring, sizeof(probe_ctx.trid.trstring));
316
317 nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
318 CU_ASSERT(g_ut_ctrlr_is_probed == true);
319 CU_ASSERT(g_ut_trid.trtype == SPDK_NVME_TRANSPORT_RDMA);
320 CU_ASSERT(g_ut_trid.adrfam == SPDK_NVMF_ADRFAM_IPV4);
321 CU_ASSERT(!strncmp(g_ut_trid.trstring, trstring, sizeof(trstring)));
322 CU_ASSERT(!strncmp(g_ut_trid.subnqn, hostnqn, sizeof(hostnqn)));
323 CU_ASSERT(!strncmp(g_ut_trid.traddr, traddr, sizeof(traddr)));
324 CU_ASSERT(!strncmp(g_ut_trid.trsvcid, trsvcid, sizeof(trsvcid)));
325
326 g_ut_ctrlr_is_probed = false;
327 memset(&g_ut_trid, 0, sizeof(g_ut_trid));
328
329 /* Entry type unsupported */
330 entry.subtype = SPDK_NVMF_SUBTYPE_DISCOVERY_CURRENT;
331
332 nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
333 CU_ASSERT(g_ut_ctrlr_is_probed == false);
334
335 /* Entry type invalid */
336 entry.subtype = 3;
337
338 nvme_fabric_discover_probe(&entry, &probe_ctx, 1);
339 CU_ASSERT(g_ut_ctrlr_is_probed == false);
340 }
341
342 static void
test_nvme_fabric_qpair_connect(void)343 test_nvme_fabric_qpair_connect(void)
344 {
345 struct spdk_nvme_qpair qpair = {};
346 struct nvme_request reserved_req = {};
347 struct nvme_request req = {};
348 struct spdk_nvme_ctrlr ctrlr = {};
349 struct spdk_nvmf_fabric_connect_cmd *cmd = NULL;
350 int rc;
351 char hostnqn[SPDK_NVMF_NQN_MAX_LEN + 1] = "nqn.2016-06.io.spdk:host1";
352 char subnqn[SPDK_NVMF_NQN_MAX_LEN + 1] = "nqn.2016-06.io.spdk:subsystem1";
353 const uint8_t hostid[16] = {
354 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
355 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
356 };
357
358 cmd = (void *)&reserved_req.cmd;
359 qpair.ctrlr = &ctrlr;
360 req.qpair = &qpair;
361 reserved_req.qpair = &qpair;
362 STAILQ_INIT(&qpair.free_req);
363 STAILQ_INSERT_HEAD(&qpair.free_req, &req, stailq);
364 qpair.reserved_req = &reserved_req;
365 memset(&g_nvmf_data, 0, sizeof(g_nvmf_data));
366
367 qpair.id = 1;
368 ctrlr.opts.keep_alive_timeout_ms = 100;
369 ctrlr.cntlid = 2;
370 memcpy(ctrlr.opts.extended_host_id, hostid, sizeof(hostid));
371 memcpy(ctrlr.opts.hostnqn, hostnqn, sizeof(hostnqn));
372 memcpy(ctrlr.trid.subnqn, subnqn, sizeof(subnqn));
373
374 rc = nvme_fabric_qpair_connect(&qpair, 1);
375 CU_ASSERT(rc == 0);
376 CU_ASSERT(cmd->opcode == SPDK_NVME_OPC_FABRIC);
377 CU_ASSERT(cmd->fctype == SPDK_NVMF_FABRIC_COMMAND_CONNECT);
378 CU_ASSERT(cmd->qid == 1);
379 CU_ASSERT(cmd->sqsize == 0);
380 CU_ASSERT(cmd->kato == 100);
381 CU_ASSERT(g_nvmf_data.cntlid == 2);
382 CU_ASSERT(!strncmp(g_nvmf_data.hostid, ctrlr.opts.extended_host_id, sizeof(g_nvmf_data.hostid)));
383 CU_ASSERT(!strncmp(g_nvmf_data.hostnqn, ctrlr.opts.hostnqn, sizeof(ctrlr.opts.hostnqn)));
384 CU_ASSERT(!strncmp(g_nvmf_data.subnqn, ctrlr.trid.subnqn, sizeof(ctrlr.trid.subnqn)));
385 /* Make sure we used the qpair's reserved_req, and not one from the STAILQ */
386 CU_ASSERT(g_request == qpair.reserved_req);
387 CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
388
389 /* qid is adminq */
390 memset(&g_nvmf_data, 0, sizeof(g_nvmf_data));
391 memset(&reserved_req, 0, sizeof(reserved_req));
392 qpair.id = 0;
393 ctrlr.cntlid = 0;
394
395 rc = nvme_fabric_qpair_connect(&qpair, 1);
396 CU_ASSERT(rc == 0);
397 CU_ASSERT(cmd->opcode == SPDK_NVME_OPC_FABRIC);
398 CU_ASSERT(cmd->fctype == SPDK_NVMF_FABRIC_COMMAND_CONNECT);
399 CU_ASSERT(cmd->qid == 0);
400 CU_ASSERT(cmd->sqsize == 0);
401 CU_ASSERT(cmd->kato == 100);
402 CU_ASSERT(ctrlr.cntlid == 1);
403 CU_ASSERT(g_nvmf_data.cntlid == 0xffff);
404 CU_ASSERT(!strncmp(g_nvmf_data.hostid, ctrlr.opts.extended_host_id, sizeof(g_nvmf_data.hostid)));
405 CU_ASSERT(!strncmp(g_nvmf_data.hostnqn, ctrlr.opts.hostnqn, sizeof(ctrlr.opts.hostnqn)));
406 CU_ASSERT(!strncmp(g_nvmf_data.subnqn, ctrlr.trid.subnqn, sizeof(ctrlr.trid.subnqn)));
407 /* Make sure we used the qpair's reserved_req, and not one from the STAILQ */
408 CU_ASSERT(g_request == qpair.reserved_req);
409 CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
410
411 /* Wait_for completion timeout */
412 g_nvme_wait_for_completion_timeout = true;
413
414 rc = nvme_fabric_qpair_connect(&qpair, 1);
415 CU_ASSERT(rc == -ECANCELED);
416 g_nvme_wait_for_completion_timeout = false;
417 abort_request(g_request);
418
419 /* Input parameters invalid */
420 rc = nvme_fabric_qpair_connect(&qpair, 0);
421 CU_ASSERT(rc == -EINVAL);
422 }
423
424 int
main(int argc,char ** argv)425 main(int argc, char **argv)
426 {
427 CU_pSuite suite = NULL;
428 unsigned int num_failures;
429
430 CU_initialize_registry();
431
432 suite = CU_add_suite("nvme_fabric", NULL, NULL);
433 CU_ADD_TEST(suite, test_nvme_fabric_prop_set_cmd);
434 CU_ADD_TEST(suite, test_nvme_fabric_prop_get_cmd);
435 CU_ADD_TEST(suite, test_nvme_fabric_get_discovery_log_page);
436 CU_ADD_TEST(suite, test_nvme_fabric_discover_probe);
437 CU_ADD_TEST(suite, test_nvme_fabric_qpair_connect);
438
439 num_failures = spdk_ut_run_tests(argc, argv, NULL);
440 CU_cleanup_registry();
441 return num_failures;
442 }
443