Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2015 Intel Corporation. All rights reserved.
3 : : * Copyright (c) 2020 Mellanox Technologies LTD. All rights reserved.
4 : : */
5 : :
6 : : #include "spdk_internal/cunit.h"
7 : :
8 : : #include "spdk/env.h"
9 : :
10 : : #include "nvme/nvme.c"
11 : :
12 : : #include "spdk_internal/mock.h"
13 : :
14 : : #include "common/lib/test_env.c"
15 : :
16 : 48 : DEFINE_STUB_V(nvme_ctrlr_proc_get_ref, (struct spdk_nvme_ctrlr *ctrlr));
17 : 66 : DEFINE_STUB_V(nvme_ctrlr_proc_put_ref, (struct spdk_nvme_ctrlr *ctrlr));
18 : 6 : DEFINE_STUB_V(nvme_ctrlr_fail, (struct spdk_nvme_ctrlr *ctrlr, bool hotremove));
19 [ - + - + ]: 78 : DEFINE_STUB(spdk_nvme_transport_available_by_name, bool,
20 : : (const char *transport_name), true);
21 : : /* return anything non-NULL, this won't be dereferenced anywhere in this test */
22 [ - + ]: 36 : DEFINE_STUB(nvme_ctrlr_get_current_process, struct spdk_nvme_ctrlr_process *,
23 : : (struct spdk_nvme_ctrlr *ctrlr), (struct spdk_nvme_ctrlr_process *)(uintptr_t)0x1);
24 [ - + ]: 18 : DEFINE_STUB(nvme_ctrlr_process_init, int,
25 : : (struct spdk_nvme_ctrlr *ctrlr), 0);
26 [ - + ]: 66 : DEFINE_STUB(nvme_ctrlr_get_ref_count, int,
27 : : (struct spdk_nvme_ctrlr *ctrlr), 0);
28 [ - + - + ]: 30 : DEFINE_STUB(dummy_probe_cb, bool,
29 : : (void *cb_ctx, const struct spdk_nvme_transport_id *trid,
30 : : struct spdk_nvme_ctrlr_opts *opts), false);
31 [ - + ]: 24 : DEFINE_STUB(nvme_transport_ctrlr_construct, struct spdk_nvme_ctrlr *,
32 : : (const struct spdk_nvme_transport_id *trid,
33 : : const struct spdk_nvme_ctrlr_opts *opts,
34 : : void *devhandle), NULL);
35 : 60 : DEFINE_STUB_V(nvme_io_msg_ctrlr_detach, (struct spdk_nvme_ctrlr *ctrlr));
36 [ # # # # ]: 0 : DEFINE_STUB(spdk_nvme_transport_available, bool,
37 : : (enum spdk_nvme_transport_type trtype), true);
38 [ - + ]: 18 : DEFINE_STUB(spdk_pci_event_listen, int, (void), 0);
39 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_poll_group_process_completions, int64_t, (struct spdk_nvme_poll_group *group,
40 : : uint32_t completions_per_qpair, spdk_nvme_disconnected_qpair_cb disconnected_qpair_cb), 0);
41 : :
42 : : static bool ut_destruct_called = false;
43 : : void
44 : 6 : nvme_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
45 : : {
46 : 6 : ut_destruct_called = true;
47 : 6 : }
48 : :
49 : : void
50 : 60 : nvme_ctrlr_destruct_async(struct spdk_nvme_ctrlr *ctrlr, struct nvme_ctrlr_detach_ctx *ctx)
51 : : {
52 : 60 : ut_destruct_called = true;
53 : 60 : ctrlr->is_destructed = true;
54 : :
55 : 60 : ctx->shutdown_complete = true;
56 : 60 : }
57 : :
58 : : int
59 : 66 : nvme_ctrlr_destruct_poll_async(struct spdk_nvme_ctrlr *ctrlr,
60 : : struct nvme_ctrlr_detach_ctx *ctx)
61 : : {
62 [ + + + + ]: 66 : if (!ctx->shutdown_complete) {
63 : 6 : return -EAGAIN;
64 : : }
65 : :
66 [ + - ]: 60 : if (ctx->cb_fn) {
67 : 60 : ctx->cb_fn(ctrlr);
68 : : }
69 : :
70 : 60 : return 0;
71 : : }
72 : :
73 : : union spdk_nvme_csts_register
74 : 24 : spdk_nvme_ctrlr_get_regs_csts(struct spdk_nvme_ctrlr *ctrlr)
75 : : {
76 : 24 : union spdk_nvme_csts_register csts = {};
77 : 24 : return csts;
78 : : }
79 : :
80 : : void
81 : 72 : spdk_nvme_ctrlr_get_default_ctrlr_opts(struct spdk_nvme_ctrlr_opts *opts, size_t opts_size)
82 : : {
83 [ - + ]: 72 : memset(opts, 0, opts_size);
84 : 72 : nvme_get_default_hostnqn(opts->hostnqn, sizeof(opts->hostnqn));
85 : 72 : opts->opts_size = opts_size;
86 : 72 : }
87 : :
88 : : static void
89 : 66 : memset_trid(struct spdk_nvme_transport_id *trid1, struct spdk_nvme_transport_id *trid2)
90 : : {
91 [ - + ]: 66 : memset(trid1, 0, sizeof(struct spdk_nvme_transport_id));
92 [ - + ]: 66 : memset(trid2, 0, sizeof(struct spdk_nvme_transport_id));
93 : 66 : }
94 : :
95 : : static bool ut_check_trtype = false;
96 : : static bool ut_test_probe_internal = false;
97 : :
98 : : static int
99 : 6 : ut_nvme_pcie_ctrlr_scan(struct spdk_nvme_probe_ctx *probe_ctx,
100 : : bool direct_connect)
101 : : {
102 : : struct spdk_nvme_ctrlr *ctrlr;
103 : 6 : struct spdk_nvme_qpair qpair = {};
104 : : int rc;
105 : :
106 [ - + ]: 6 : if (probe_ctx->trid.trtype != SPDK_NVME_TRANSPORT_PCIE) {
107 : 0 : return -1;
108 : : }
109 : :
110 : 6 : ctrlr = calloc(1, sizeof(*ctrlr));
111 : 6 : CU_ASSERT(ctrlr != NULL);
112 : 6 : ctrlr->adminq = &qpair;
113 : :
114 : : /* happy path with first controller */
115 : 6 : MOCK_SET(nvme_transport_ctrlr_construct, ctrlr);
116 : 6 : rc = nvme_ctrlr_probe(&probe_ctx->trid, probe_ctx, NULL);
117 : 6 : CU_ASSERT(rc == 0);
118 : :
119 : : /* failed with the second controller */
120 : 6 : MOCK_SET(nvme_transport_ctrlr_construct, NULL);
121 : 6 : rc = nvme_ctrlr_probe(&probe_ctx->trid, probe_ctx, NULL);
122 : 6 : CU_ASSERT(rc != 0);
123 [ - - - + ]: 6 : MOCK_CLEAR_P(nvme_transport_ctrlr_construct);
124 : :
125 : 6 : return -1;
126 : : }
127 : :
128 : : int
129 : 6 : nvme_transport_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
130 : : {
131 : 6 : free(ctrlr);
132 : 6 : return 0;
133 : : }
134 : :
135 : : int
136 : 72 : nvme_transport_ctrlr_scan(struct spdk_nvme_probe_ctx *probe_ctx,
137 : : bool direct_connect)
138 : : {
139 : 72 : struct spdk_nvme_ctrlr *ctrlr = NULL;
140 : :
141 [ + + + + ]: 72 : if (ut_check_trtype == true) {
142 : 12 : CU_ASSERT(probe_ctx->trid.trtype == SPDK_NVME_TRANSPORT_PCIE);
143 : : }
144 : :
145 [ + + + + ]: 72 : if (ut_test_probe_internal) {
146 : 6 : return ut_nvme_pcie_ctrlr_scan(probe_ctx, direct_connect);
147 : : }
148 : :
149 [ + + + + ]: 66 : if (direct_connect == true && probe_ctx->probe_cb) {
150 : 24 : nvme_robust_mutex_unlock(&g_spdk_nvme_driver->lock);
151 : 24 : ctrlr = nvme_get_ctrlr_by_trid(&probe_ctx->trid, NULL);
152 : 24 : nvme_robust_mutex_lock(&g_spdk_nvme_driver->lock);
153 : 24 : probe_ctx->probe_cb(probe_ctx->cb_ctx, &probe_ctx->trid, &ctrlr->opts);
154 : : }
155 : 66 : return 0;
156 : : }
157 : :
158 : : static bool ut_attach_cb_called = false;
159 : : static void
160 : 6 : dummy_attach_cb(void *cb_ctx, const struct spdk_nvme_transport_id *trid,
161 : : struct spdk_nvme_ctrlr *ctrlr, const struct spdk_nvme_ctrlr_opts *opts)
162 : : {
163 : 6 : ut_attach_cb_called = true;
164 : 6 : }
165 : :
166 : : static void
167 : 6 : test_spdk_nvme_probe(void)
168 : : {
169 : 6 : int rc = 0;
170 : 6 : const struct spdk_nvme_transport_id *trid = NULL;
171 : 6 : void *cb_ctx = NULL;
172 : 6 : spdk_nvme_probe_cb probe_cb = NULL;
173 : 6 : spdk_nvme_attach_cb attach_cb = dummy_attach_cb;
174 : 6 : spdk_nvme_remove_cb remove_cb = NULL;
175 : 5 : struct spdk_nvme_ctrlr ctrlr;
176 : 5 : pthread_mutexattr_t attr;
177 : 6 : struct nvme_driver dummy = {};
178 : 6 : g_spdk_nvme_driver = &dummy;
179 : :
180 : : /* driver init fails */
181 : 6 : MOCK_SET(spdk_process_is_primary, false);
182 : 6 : MOCK_SET(spdk_memzone_lookup, NULL);
183 : 6 : rc = spdk_nvme_probe(trid, cb_ctx, probe_cb, attach_cb, remove_cb);
184 : 6 : CU_ASSERT(rc == -1);
185 : :
186 : : /*
187 : : * For secondary processes, the attach_cb should automatically get
188 : : * called for any controllers already initialized by the primary
189 : : * process.
190 : : */
191 : 6 : MOCK_SET(spdk_nvme_transport_available_by_name, false);
192 : 6 : MOCK_SET(spdk_process_is_primary, true);
193 : 6 : dummy.initialized = true;
194 : 6 : g_spdk_nvme_driver = &dummy;
195 : 6 : rc = spdk_nvme_probe(trid, cb_ctx, probe_cb, attach_cb, remove_cb);
196 : 6 : CU_ASSERT(rc == -1);
197 : :
198 : : /* driver init passes, transport available, secondary call attach_cb */
199 : 6 : MOCK_SET(spdk_nvme_transport_available_by_name, true);
200 : 6 : MOCK_SET(spdk_process_is_primary, false);
201 : 6 : MOCK_SET(spdk_memzone_lookup, g_spdk_nvme_driver);
202 : 6 : dummy.initialized = true;
203 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(struct spdk_nvme_ctrlr));
204 [ - + ]: 6 : CU_ASSERT(pthread_mutexattr_init(&attr) == 0);
205 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&dummy.lock, &attr) == 0);
206 : 6 : TAILQ_INIT(&dummy.shared_attached_ctrlrs);
207 : 6 : TAILQ_INSERT_TAIL(&dummy.shared_attached_ctrlrs, &ctrlr, tailq);
208 : 6 : ut_attach_cb_called = false;
209 : : /* setup nvme_transport_ctrlr_scan() stub to also check the trype */
210 : 6 : ut_check_trtype = true;
211 : 6 : rc = spdk_nvme_probe(trid, cb_ctx, probe_cb, attach_cb, remove_cb);
212 : 6 : CU_ASSERT(rc == 0);
213 [ - + ]: 6 : CU_ASSERT(ut_attach_cb_called == true);
214 : :
215 : : /* driver init passes, transport available, we are primary */
216 : 6 : MOCK_SET(spdk_process_is_primary, true);
217 : 6 : rc = spdk_nvme_probe(trid, cb_ctx, probe_cb, attach_cb, remove_cb);
218 : 6 : CU_ASSERT(rc == 0);
219 : :
220 : 6 : g_spdk_nvme_driver = NULL;
221 : : /* reset to pre-test values */
222 [ - - - + ]: 6 : MOCK_CLEAR(spdk_memzone_lookup);
223 : 6 : ut_check_trtype = false;
224 : :
225 [ - + ]: 6 : pthread_mutex_destroy(&dummy.lock);
226 [ - + ]: 6 : pthread_mutexattr_destroy(&attr);
227 : 6 : }
228 : :
229 : : static void
230 : 6 : test_spdk_nvme_connect(void)
231 : : {
232 : 6 : struct spdk_nvme_ctrlr *ret_ctrlr = NULL;
233 : 6 : struct spdk_nvme_transport_id trid = {};
234 : 6 : struct spdk_nvme_ctrlr_opts opts = {};
235 : 5 : struct spdk_nvme_ctrlr ctrlr;
236 : 5 : pthread_mutexattr_t attr;
237 : 6 : struct nvme_driver dummy = {};
238 : :
239 : : /* initialize the variable to prepare the test */
240 : 6 : dummy.initialized = true;
241 : 6 : TAILQ_INIT(&dummy.shared_attached_ctrlrs);
242 : 6 : g_spdk_nvme_driver = &dummy;
243 [ - + ]: 6 : CU_ASSERT(pthread_mutexattr_init(&attr) == 0);
244 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&g_spdk_nvme_driver->lock, &attr) == 0);
245 : :
246 : : /* set NULL trid pointer to test immediate return */
247 : 6 : ret_ctrlr = spdk_nvme_connect(NULL, NULL, 0);
248 : 6 : CU_ASSERT(ret_ctrlr == NULL);
249 : :
250 : : /* driver init passes, transport available, secondary process connects ctrlr */
251 : 6 : MOCK_SET(spdk_process_is_primary, false);
252 : 6 : MOCK_SET(spdk_memzone_lookup, g_spdk_nvme_driver);
253 : 6 : MOCK_SET(spdk_nvme_transport_available_by_name, true);
254 [ - + ]: 6 : memset(&trid, 0, sizeof(trid));
255 : 6 : trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
256 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
257 : 6 : CU_ASSERT(ret_ctrlr == NULL);
258 : :
259 : : /* driver init passes, setup one ctrlr on the attached_list */
260 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(struct spdk_nvme_ctrlr));
261 : 6 : spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctrlr.opts, sizeof(ctrlr.opts));
262 [ - + ]: 6 : snprintf(ctrlr.trid.traddr, sizeof(ctrlr.trid.traddr), "0000:01:00.0");
263 : 6 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
264 : 6 : TAILQ_INSERT_TAIL(&g_spdk_nvme_driver->shared_attached_ctrlrs, &ctrlr, tailq);
265 : : /* get the ctrlr from the attached list */
266 [ - + ]: 6 : snprintf(trid.traddr, sizeof(trid.traddr), "0000:01:00.0");
267 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
268 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
269 : : /* get the ctrlr from the attached list with default ctrlr opts */
270 : 6 : ctrlr.opts.num_io_queues = DEFAULT_MAX_IO_QUEUES;
271 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
272 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
273 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.num_io_queues, DEFAULT_MAX_IO_QUEUES);
274 : : /* get the ctrlr from the attached list with default ctrlr opts and consistent opts_size */
275 : 6 : spdk_nvme_ctrlr_get_default_ctrlr_opts(&opts, sizeof(opts));
276 : 6 : opts.num_io_queues = 1;
277 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, &opts, sizeof(opts));
278 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
279 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.num_io_queues, 1);
280 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.opts_size, sizeof(opts));
281 : :
282 : : /* opts_size is 0 */
283 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, &opts, 0);
284 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
285 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.opts_size, 0);
286 : :
287 : : /* opts_size is less than sizeof(*opts) if opts != NULL */
288 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, &opts, 4);
289 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
290 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.num_io_queues, 1);
291 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.opts_size, 4);
292 : : /* remove the attached ctrlr on the attached_list */
293 : 6 : MOCK_SET(nvme_ctrlr_get_ref_count, 1);
294 : 6 : CU_ASSERT(spdk_nvme_detach(&ctrlr) == 0);
295 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_nvme_driver->shared_attached_ctrlrs));
296 : :
297 : : /* driver init passes, transport available, primary process connects ctrlr */
298 : 6 : MOCK_SET(spdk_process_is_primary, true);
299 : : /* setup one ctrlr on the attached_list */
300 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(struct spdk_nvme_ctrlr));
301 [ - + ]: 6 : snprintf(ctrlr.trid.traddr, sizeof(ctrlr.trid.traddr), "0000:02:00.0");
302 : 6 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
303 : 6 : spdk_nvme_ctrlr_get_default_ctrlr_opts(&ctrlr.opts, sizeof(ctrlr.opts));
304 : 6 : TAILQ_INSERT_TAIL(&g_spdk_nvme_driver->shared_attached_ctrlrs, &ctrlr, tailq);
305 : : /* get the ctrlr from the attached list */
306 [ - + ]: 6 : snprintf(trid.traddr, sizeof(trid.traddr), "0000:02:00.0");
307 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
308 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
309 : : /* get the ctrlr from the attached list with default ctrlr opts */
310 : 6 : ctrlr.opts.num_io_queues = DEFAULT_MAX_IO_QUEUES;
311 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
312 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
313 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.num_io_queues, DEFAULT_MAX_IO_QUEUES);
314 : : /* get the ctrlr from the attached list with default ctrlr opts and consistent opts_size */
315 : 6 : opts.num_io_queues = 2;
316 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, &opts, sizeof(opts));
317 : 6 : CU_ASSERT(ret_ctrlr == &ctrlr);
318 : 6 : CU_ASSERT_EQUAL(ret_ctrlr->opts.num_io_queues, 2);
319 : : /* remove the attached ctrlr on the attached_list */
320 : 6 : CU_ASSERT(spdk_nvme_detach(ret_ctrlr) == 0);
321 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_nvme_driver->shared_attached_ctrlrs));
322 : :
323 : : /* test driver init failure return */
324 : 6 : MOCK_SET(spdk_process_is_primary, false);
325 : 6 : MOCK_SET(spdk_memzone_lookup, NULL);
326 : 6 : ret_ctrlr = spdk_nvme_connect(&trid, NULL, 0);
327 : 6 : CU_ASSERT(ret_ctrlr == NULL);
328 : 6 : }
329 : :
330 : : static struct spdk_nvme_probe_ctx *
331 : 18 : test_nvme_init_get_probe_ctx(void)
332 : : {
333 : : struct spdk_nvme_probe_ctx *probe_ctx;
334 : :
335 : 18 : probe_ctx = calloc(1, sizeof(*probe_ctx));
336 [ - + ]: 18 : SPDK_CU_ASSERT_FATAL(probe_ctx != NULL);
337 : 18 : TAILQ_INIT(&probe_ctx->init_ctrlrs);
338 : :
339 : 18 : return probe_ctx;
340 : : }
341 : :
342 : : static void
343 : 6 : test_nvme_init_controllers(void)
344 : : {
345 : 6 : int rc = 0;
346 : 6 : struct nvme_driver test_driver = {};
347 : 6 : void *cb_ctx = NULL;
348 : 6 : spdk_nvme_attach_cb attach_cb = dummy_attach_cb;
349 : : struct spdk_nvme_probe_ctx *probe_ctx;
350 : : struct spdk_nvme_ctrlr *ctrlr;
351 : 5 : pthread_mutexattr_t attr;
352 : :
353 : 6 : g_spdk_nvme_driver = &test_driver;
354 : 6 : ctrlr = calloc(1, sizeof(*ctrlr));
355 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(ctrlr != NULL);
356 : 6 : ctrlr->trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
357 [ - + ]: 6 : CU_ASSERT(pthread_mutexattr_init(&attr) == 0);
358 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&ctrlr->ctrlr_lock, &attr) == 0);
359 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&test_driver.lock, &attr) == 0);
360 : 6 : TAILQ_INIT(&test_driver.shared_attached_ctrlrs);
361 : :
362 : : /*
363 : : * Try to initialize, but nvme_ctrlr_process_init will fail.
364 : : * Verify correct behavior when it does.
365 : : */
366 : 6 : MOCK_SET(nvme_ctrlr_process_init, 1);
367 : 6 : MOCK_SET(spdk_process_is_primary, 1);
368 : 6 : g_spdk_nvme_driver->initialized = false;
369 : 6 : ut_destruct_called = false;
370 : 6 : probe_ctx = test_nvme_init_get_probe_ctx();
371 : 6 : TAILQ_INSERT_TAIL(&probe_ctx->init_ctrlrs, ctrlr, tailq);
372 : 6 : probe_ctx->cb_ctx = cb_ctx;
373 : 6 : probe_ctx->attach_cb = attach_cb;
374 : 6 : probe_ctx->trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
375 : 6 : rc = nvme_init_controllers(probe_ctx);
376 : 6 : CU_ASSERT(rc == 0);
377 [ - + ]: 6 : CU_ASSERT(g_spdk_nvme_driver->initialized == true);
378 [ - + ]: 6 : CU_ASSERT(ut_destruct_called == true);
379 : :
380 : : /*
381 : : * Controller init OK, need to move the controller state machine
382 : : * forward by setting the ctrl state so that it can be moved
383 : : * the shared_attached_ctrlrs list.
384 : : */
385 : 6 : probe_ctx = test_nvme_init_get_probe_ctx();
386 : 6 : TAILQ_INSERT_TAIL(&probe_ctx->init_ctrlrs, ctrlr, tailq);
387 : 6 : ctrlr->state = NVME_CTRLR_STATE_READY;
388 : 6 : MOCK_SET(nvme_ctrlr_process_init, 0);
389 : 6 : rc = nvme_init_controllers(probe_ctx);
390 : 6 : CU_ASSERT(rc == 0);
391 [ - + ]: 6 : CU_ASSERT(ut_attach_cb_called == true);
392 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_nvme_attached_ctrlrs));
393 : 6 : CU_ASSERT(TAILQ_FIRST(&g_spdk_nvme_driver->shared_attached_ctrlrs) == ctrlr);
394 [ - + ]: 6 : TAILQ_REMOVE(&g_spdk_nvme_driver->shared_attached_ctrlrs, ctrlr, tailq);
395 : :
396 : : /*
397 : : * Reset to initial state
398 : : */
399 [ - + ]: 6 : CU_ASSERT(pthread_mutex_destroy(&ctrlr->ctrlr_lock) == 0);
400 [ - + ]: 6 : memset(ctrlr, 0, sizeof(struct spdk_nvme_ctrlr));
401 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&ctrlr->ctrlr_lock, &attr) == 0);
402 : :
403 : : /*
404 : : * Non-PCIe controllers should be added to the per-process list, not the shared list.
405 : : */
406 : 6 : ctrlr->trid.trtype = SPDK_NVME_TRANSPORT_RDMA;
407 : 6 : probe_ctx = test_nvme_init_get_probe_ctx();
408 : 6 : TAILQ_INSERT_TAIL(&probe_ctx->init_ctrlrs, ctrlr, tailq);
409 : 6 : ctrlr->state = NVME_CTRLR_STATE_READY;
410 : 6 : MOCK_SET(nvme_ctrlr_process_init, 0);
411 : 6 : rc = nvme_init_controllers(probe_ctx);
412 : 6 : CU_ASSERT(rc == 0);
413 [ - + ]: 6 : CU_ASSERT(ut_attach_cb_called == true);
414 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_nvme_driver->shared_attached_ctrlrs));
415 : 6 : CU_ASSERT(TAILQ_FIRST(&g_nvme_attached_ctrlrs) == ctrlr);
416 [ - + ]: 6 : TAILQ_REMOVE(&g_nvme_attached_ctrlrs, ctrlr, tailq);
417 [ - + ]: 6 : CU_ASSERT(pthread_mutex_destroy(&ctrlr->ctrlr_lock) == 0);
418 : 6 : free(ctrlr);
419 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_nvme_attached_ctrlrs));
420 : :
421 : 6 : g_spdk_nvme_driver = NULL;
422 [ - + ]: 6 : pthread_mutexattr_destroy(&attr);
423 [ - + ]: 6 : pthread_mutex_destroy(&test_driver.lock);
424 : 6 : }
425 : :
426 : : static void
427 : 6 : test_nvme_driver_init(void)
428 : : {
429 : : int rc;
430 : 6 : struct nvme_driver dummy = {};
431 : 6 : g_spdk_nvme_driver = &dummy;
432 : :
433 : : /* adjust this so testing doesn't take so long */
434 : 6 : g_nvme_driver_timeout_ms = 100;
435 : :
436 : : /* process is primary and mem already reserved */
437 : 6 : MOCK_SET(spdk_process_is_primary, true);
438 : 6 : dummy.initialized = true;
439 : 6 : rc = nvme_driver_init();
440 : 6 : CU_ASSERT(rc == 0);
441 : :
442 : : /*
443 : : * Process is primary and mem not yet reserved but the call
444 : : * to spdk_memzone_reserve() returns NULL.
445 : : */
446 : 6 : g_spdk_nvme_driver = NULL;
447 : 6 : MOCK_SET(spdk_process_is_primary, true);
448 : 6 : MOCK_SET(spdk_memzone_reserve, NULL);
449 : 6 : rc = nvme_driver_init();
450 : 6 : CU_ASSERT(rc == -1);
451 : :
452 : : /* process is not primary, no mem already reserved */
453 : 6 : MOCK_SET(spdk_process_is_primary, false);
454 : 6 : MOCK_SET(spdk_memzone_lookup, NULL);
455 : 6 : g_spdk_nvme_driver = NULL;
456 : 6 : rc = nvme_driver_init();
457 : 6 : CU_ASSERT(rc == -1);
458 : :
459 : : /* process is not primary, mem is already reserved & init'd */
460 : 6 : MOCK_SET(spdk_process_is_primary, false);
461 : 6 : MOCK_SET(spdk_memzone_lookup, (void *)&dummy);
462 : 6 : dummy.initialized = true;
463 : 6 : rc = nvme_driver_init();
464 : 6 : CU_ASSERT(rc == 0);
465 : :
466 : : /* process is not primary, mem is reserved but not initialized */
467 : : /* and times out */
468 : 6 : MOCK_SET(spdk_process_is_primary, false);
469 : 6 : MOCK_SET(spdk_memzone_reserve, (void *)&dummy);
470 : 6 : dummy.initialized = false;
471 : 6 : rc = nvme_driver_init();
472 : 6 : CU_ASSERT(rc == -1);
473 : :
474 : : /* process is primary, got mem but mutex won't init */
475 : 6 : MOCK_SET(spdk_process_is_primary, true);
476 : 6 : MOCK_SET(spdk_memzone_reserve, (void *)&dummy);
477 : 6 : MOCK_SET(pthread_mutexattr_init, -1);
478 : 6 : g_spdk_nvme_driver = NULL;
479 : 6 : dummy.initialized = true;
480 : 6 : rc = nvme_driver_init();
481 : : /* for FreeBSD we can't can't effectively mock this path */
482 : : #ifndef __FreeBSD__
483 : 6 : CU_ASSERT(rc != 0);
484 : : #else
485 : : CU_ASSERT(rc == 0);
486 : : #endif
487 : :
488 : : /* process is primary, got mem, mutex OK */
489 : 6 : MOCK_SET(spdk_process_is_primary, true);
490 [ - - - + ]: 6 : MOCK_CLEAR(pthread_mutexattr_init);
491 : 6 : g_spdk_nvme_driver = NULL;
492 : 6 : rc = nvme_driver_init();
493 [ - + ]: 6 : CU_ASSERT(g_spdk_nvme_driver->initialized == false);
494 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_spdk_nvme_driver->shared_attached_ctrlrs));
495 : 6 : CU_ASSERT(rc == 0);
496 : :
497 : 6 : g_spdk_nvme_driver = NULL;
498 [ - - - + ]: 6 : MOCK_CLEAR(spdk_memzone_reserve);
499 [ - - - + ]: 6 : MOCK_CLEAR(spdk_memzone_lookup);
500 : 6 : }
501 : :
502 : : static void
503 : 6 : test_spdk_nvme_detach(void)
504 : : {
505 : 6 : int rc = 1;
506 : 5 : struct spdk_nvme_ctrlr ctrlr;
507 : : struct spdk_nvme_ctrlr *ret_ctrlr;
508 : 6 : struct nvme_driver test_driver = {};
509 : :
510 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(ctrlr));
511 : 6 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
512 : :
513 : 6 : g_spdk_nvme_driver = &test_driver;
514 : 6 : TAILQ_INIT(&test_driver.shared_attached_ctrlrs);
515 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr, tailq);
516 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&test_driver.lock, NULL) == 0);
517 : :
518 : : /*
519 : : * Controllers are ref counted so mock the function that returns
520 : : * the ref count so that detach will actually call the destruct
521 : : * function which we've mocked simply to verify that it gets
522 : : * called (we aren't testing what the real destruct function does
523 : : * here.)
524 : : */
525 : 6 : MOCK_SET(nvme_ctrlr_get_ref_count, 1);
526 : 6 : rc = spdk_nvme_detach(&ctrlr);
527 : 6 : ret_ctrlr = TAILQ_FIRST(&test_driver.shared_attached_ctrlrs);
528 : 6 : CU_ASSERT(ret_ctrlr == NULL);
529 [ - + ]: 6 : CU_ASSERT(ut_destruct_called == true);
530 : 6 : CU_ASSERT(rc == 0);
531 : :
532 : : /*
533 : : * Mock the ref count to 1 so we confirm that the destruct
534 : : * function is not called and that attached ctrl list is
535 : : * not empty.
536 : : */
537 : 6 : MOCK_SET(nvme_ctrlr_get_ref_count, 2);
538 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr, tailq);
539 : 6 : ut_destruct_called = false;
540 : 6 : rc = spdk_nvme_detach(&ctrlr);
541 : 6 : ret_ctrlr = TAILQ_FIRST(&test_driver.shared_attached_ctrlrs);
542 : 6 : CU_ASSERT(ret_ctrlr != NULL);
543 [ - + ]: 6 : CU_ASSERT(ut_destruct_called == false);
544 : 6 : CU_ASSERT(rc == 0);
545 : :
546 : : /*
547 : : * Non-PCIe controllers should be on the per-process attached_ctrlrs list, not the
548 : : * shared_attached_ctrlrs list. Test an RDMA controller and ensure it is removed
549 : : * from the correct list.
550 : : */
551 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(ctrlr));
552 : 6 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_RDMA;
553 : 6 : TAILQ_INIT(&g_nvme_attached_ctrlrs);
554 : 6 : TAILQ_INSERT_TAIL(&g_nvme_attached_ctrlrs, &ctrlr, tailq);
555 : 6 : MOCK_SET(nvme_ctrlr_get_ref_count, 1);
556 : 6 : rc = spdk_nvme_detach(&ctrlr);
557 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_nvme_attached_ctrlrs));
558 [ - + ]: 6 : CU_ASSERT(ut_destruct_called == true);
559 : 6 : CU_ASSERT(rc == 0);
560 : :
561 : 6 : g_spdk_nvme_driver = NULL;
562 [ - + ]: 6 : pthread_mutex_destroy(&test_driver.lock);
563 : 6 : }
564 : :
565 : : static void
566 : 6 : test_nvme_completion_poll_cb(void)
567 : : {
568 : : struct nvme_completion_poll_status *status;
569 : 5 : struct spdk_nvme_cpl cpl;
570 : :
571 : 6 : status = calloc(1, sizeof(*status));
572 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(status != NULL);
573 : :
574 : 6 : memset(&cpl, 0xff, sizeof(cpl));
575 : :
576 : 6 : nvme_completion_poll_cb(status, &cpl);
577 [ - + ]: 6 : CU_ASSERT(status->done == true);
578 [ - + ]: 6 : CU_ASSERT(memcmp(&cpl, &status->cpl,
579 : : sizeof(struct spdk_nvme_cpl)) == 0);
580 : :
581 : 6 : free(status);
582 : 6 : }
583 : :
584 : : /* stub callback used by test_nvme_user_copy_cmd_complete() */
585 : : static struct spdk_nvme_cpl ut_spdk_nvme_cpl = {0};
586 : : static void
587 : 18 : dummy_cb(void *user_cb_arg, const struct spdk_nvme_cpl *cpl)
588 : : {
589 : 18 : ut_spdk_nvme_cpl = *cpl;
590 : 18 : }
591 : :
592 : : static void
593 : 6 : test_nvme_user_copy_cmd_complete(void)
594 : : {
595 : 5 : struct nvme_request req;
596 : 6 : int test_data = 0xdeadbeef;
597 : 6 : int buff_size = sizeof(int);
598 : : void *user_buffer, *buff;
599 : 6 : int user_cb_arg = 0x123;
600 : : static struct spdk_nvme_cpl cpl;
601 : :
602 : 6 : memset(&req, 0, sizeof(req));
603 : 6 : memset(&cpl, 0x5a, sizeof(cpl));
604 : :
605 : : /* test without a user buffer provided */
606 : 6 : req.user_cb_fn = (void *)dummy_cb;
607 : 6 : req.user_cb_arg = (void *)&user_cb_arg;
608 : 6 : nvme_user_copy_cmd_complete(&req, &cpl);
609 : 6 : CU_ASSERT(memcmp(&ut_spdk_nvme_cpl, &cpl, sizeof(cpl)) == 0);
610 : 6 : CU_ASSERT(req.user_cb_fn == NULL);
611 : 6 : CU_ASSERT(req.user_cb_arg == NULL);
612 : 6 : CU_ASSERT(req.user_buffer == NULL);
613 : :
614 : : /* test with a user buffer provided */
615 : 6 : user_buffer = malloc(buff_size);
616 : 6 : req.user_cb_fn = (void *)dummy_cb;
617 : 6 : req.user_cb_arg = (void *)&user_cb_arg;
618 : 6 : req.user_buffer = user_buffer;
619 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(req.user_buffer != NULL);
620 [ - + ]: 6 : memset(req.user_buffer, 0, buff_size);
621 : 6 : req.payload_size = buff_size;
622 : 6 : buff = spdk_zmalloc(buff_size, 0x100, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
623 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(buff != NULL);
624 : 6 : req.payload = NVME_PAYLOAD_CONTIG(buff, NULL);
625 [ - + ]: 6 : memcpy(buff, &test_data, buff_size);
626 : 6 : req.cmd.opc = SPDK_NVME_OPC_GET_LOG_PAGE;
627 : 6 : req.pid = getpid();
628 : :
629 : : /* zero out the test value set in the callback */
630 : 6 : memset(&ut_spdk_nvme_cpl, 0, sizeof(ut_spdk_nvme_cpl));
631 : :
632 : 6 : nvme_user_copy_cmd_complete(&req, &cpl);
633 [ - + ]: 6 : CU_ASSERT(memcmp(user_buffer, &test_data, buff_size) == 0);
634 : 6 : CU_ASSERT(memcmp(&ut_spdk_nvme_cpl, &cpl, sizeof(cpl)) == 0);
635 : 6 : CU_ASSERT(req.user_cb_fn == NULL);
636 : 6 : CU_ASSERT(req.user_cb_arg == NULL);
637 : 6 : CU_ASSERT(req.user_buffer == NULL);
638 : :
639 : : /*
640 : : * Now test the same path as above but this time choose an opc
641 : : * that results in a different data transfer type.
642 : : */
643 : 6 : memset(&ut_spdk_nvme_cpl, 0, sizeof(ut_spdk_nvme_cpl));
644 : 6 : req.user_cb_fn = (void *)dummy_cb;
645 : 6 : req.user_cb_arg = (void *)&user_cb_arg;
646 : 6 : req.user_buffer = user_buffer;
647 [ - + ]: 6 : memset(req.user_buffer, 0, buff_size);
648 : 6 : buff = spdk_zmalloc(buff_size, 0x100, NULL, SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
649 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(buff != NULL);
650 : 6 : req.payload = NVME_PAYLOAD_CONTIG(buff, NULL);
651 [ - + ]: 6 : memcpy(buff, &test_data, buff_size);
652 : 6 : req.cmd.opc = SPDK_NVME_OPC_SET_FEATURES;
653 : 6 : nvme_user_copy_cmd_complete(&req, &cpl);
654 [ - + ]: 6 : CU_ASSERT(memcmp(user_buffer, &test_data, buff_size) != 0);
655 : 6 : CU_ASSERT(memcmp(&ut_spdk_nvme_cpl, &cpl, sizeof(cpl)) == 0);
656 : 6 : CU_ASSERT(req.user_cb_fn == NULL);
657 : 6 : CU_ASSERT(req.user_cb_arg == NULL);
658 : 6 : CU_ASSERT(req.user_buffer == NULL);
659 : :
660 : : /* clean up */
661 : 6 : free(user_buffer);
662 : 6 : }
663 : :
664 : : static void
665 : 6 : test_nvme_allocate_request_null(void)
666 : : {
667 : 6 : struct spdk_nvme_qpair qpair = {};
668 : 6 : spdk_nvme_cmd_cb cb_fn = (spdk_nvme_cmd_cb)0x1234;
669 : 6 : void *cb_arg = (void *)0x5678;
670 : 6 : struct nvme_request *req = NULL;
671 : 5 : struct nvme_request dummy_req;
672 : :
673 : 6 : STAILQ_INIT(&qpair.free_req);
674 : 6 : STAILQ_INIT(&qpair.queued_req);
675 : :
676 : : /*
677 : : * Put a dummy on the queue so we can make a request
678 : : * and confirm that what comes back is what we expect.
679 : : */
680 [ + - ]: 6 : STAILQ_INSERT_HEAD(&qpair.free_req, &dummy_req, stailq);
681 : :
682 : 6 : req = nvme_allocate_request_null(&qpair, cb_fn, cb_arg);
683 : :
684 : : /*
685 : : * Compare the req with the parameters that we passed in
686 : : * as well as what the function is supposed to update.
687 : : */
688 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(req != NULL);
689 : 6 : CU_ASSERT(req->cb_fn == cb_fn);
690 : 6 : CU_ASSERT(req->cb_arg == cb_arg);
691 : 6 : CU_ASSERT(req->pid == getpid());
692 : 6 : CU_ASSERT(nvme_payload_type(&req->payload) == NVME_PAYLOAD_TYPE_CONTIG);
693 : 6 : CU_ASSERT(req->payload.md == NULL);
694 : 6 : CU_ASSERT(req->payload.contig_or_cb_arg == NULL);
695 : 6 : }
696 : :
697 : : static void
698 : 6 : test_nvme_allocate_request(void)
699 : : {
700 : 5 : struct spdk_nvme_qpair qpair;
701 : 5 : struct nvme_payload payload;
702 : 6 : uint32_t payload_struct_size = sizeof(payload);
703 : 6 : spdk_nvme_cmd_cb cb_fn = (spdk_nvme_cmd_cb)0x1234;
704 : 6 : void *cb_arg = (void *)0x6789;
705 : 6 : struct nvme_request *req = NULL;
706 : 5 : struct nvme_request dummy_req;
707 : :
708 : : /* Fill the whole payload struct with a known pattern */
709 : 6 : memset(&payload, 0x5a, payload_struct_size);
710 : 6 : STAILQ_INIT(&qpair.free_req);
711 : 6 : STAILQ_INIT(&qpair.queued_req);
712 : 6 : qpair.num_outstanding_reqs = 0;
713 : :
714 : : /* Test trying to allocate a request when no requests are available */
715 : 6 : req = nvme_allocate_request(&qpair, &payload, payload_struct_size, 0,
716 : : cb_fn, cb_arg);
717 : 6 : CU_ASSERT(req == NULL);
718 : 6 : CU_ASSERT(qpair.num_outstanding_reqs == 0);
719 : :
720 : : /* put a dummy on the queue, and then allocate one */
721 [ + - ]: 6 : STAILQ_INSERT_HEAD(&qpair.free_req, &dummy_req, stailq);
722 : 6 : req = nvme_allocate_request(&qpair, &payload, payload_struct_size, 0,
723 : : cb_fn, cb_arg);
724 : :
725 : : /* all the req elements should now match the passed in parameters */
726 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(req != NULL);
727 : 6 : CU_ASSERT(qpair.num_outstanding_reqs == 1);
728 : 6 : CU_ASSERT(req->cb_fn == cb_fn);
729 : 6 : CU_ASSERT(req->cb_arg == cb_arg);
730 [ - + ]: 6 : CU_ASSERT(memcmp(&req->payload, &payload, payload_struct_size) == 0);
731 : 6 : CU_ASSERT(req->payload_size == payload_struct_size);
732 : 6 : CU_ASSERT(req->pid == getpid());
733 : 6 : }
734 : :
735 : : static void
736 : 6 : test_nvme_free_request(void)
737 : : {
738 : 5 : struct nvme_request match_req;
739 : 6 : struct spdk_nvme_qpair qpair = {0};
740 : : struct nvme_request *req;
741 : :
742 : : /* put a req on the Q, take it off and compare */
743 [ - + ]: 6 : memset(&match_req.cmd, 0x5a, sizeof(struct spdk_nvme_cmd));
744 : 6 : match_req.qpair = &qpair;
745 : 6 : qpair.num_outstanding_reqs = 1;
746 : : /* the code under tests asserts this condition */
747 : 6 : match_req.num_children = 0;
748 : 6 : STAILQ_INIT(&qpair.free_req);
749 : 6 : match_req.qpair->reserved_req = NULL;
750 : :
751 : 6 : nvme_free_request(&match_req);
752 : 6 : req = STAILQ_FIRST(&match_req.qpair->free_req);
753 : 6 : CU_ASSERT(req == &match_req);
754 : 6 : CU_ASSERT(qpair.num_outstanding_reqs == 0);
755 : 6 : }
756 : :
757 : : static void
758 : 6 : test_nvme_allocate_request_user_copy(void)
759 : : {
760 : 5 : struct spdk_nvme_qpair qpair;
761 : 6 : spdk_nvme_cmd_cb cb_fn = (spdk_nvme_cmd_cb)0x12345;
762 : 6 : void *cb_arg = (void *)0x12345;
763 : 6 : bool host_to_controller = true;
764 : : struct nvme_request *req;
765 : 5 : struct nvme_request dummy_req;
766 : 6 : int test_data = 0xdeadbeef;
767 : 6 : void *buffer = NULL;
768 : 6 : uint32_t payload_size = sizeof(int);
769 : :
770 : 6 : STAILQ_INIT(&qpair.free_req);
771 : 6 : STAILQ_INIT(&qpair.queued_req);
772 : :
773 : : /* no buffer or valid payload size, early NULL return */
774 : 6 : req = nvme_allocate_request_user_copy(&qpair, buffer, payload_size, cb_fn,
775 : : cb_arg, host_to_controller);
776 : 6 : CU_ASSERT(req == NULL);
777 : :
778 : : /* good buffer and valid payload size */
779 : 6 : buffer = malloc(payload_size);
780 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
781 [ - + ]: 6 : memcpy(buffer, &test_data, payload_size);
782 : :
783 : : /* put a dummy on the queue */
784 [ + - ]: 6 : STAILQ_INSERT_HEAD(&qpair.free_req, &dummy_req, stailq);
785 : :
786 [ - - - + ]: 6 : MOCK_CLEAR(spdk_malloc);
787 [ - - - + ]: 6 : MOCK_CLEAR(spdk_zmalloc);
788 : 6 : req = nvme_allocate_request_user_copy(&qpair, buffer, payload_size, cb_fn,
789 : : cb_arg, host_to_controller);
790 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(req != NULL);
791 : 6 : CU_ASSERT(req->user_cb_fn == cb_fn);
792 : 6 : CU_ASSERT(req->user_cb_arg == cb_arg);
793 : 6 : CU_ASSERT(req->user_buffer == buffer);
794 : 6 : CU_ASSERT(req->cb_arg == req);
795 [ - + - + ]: 6 : CU_ASSERT(memcmp(req->payload.contig_or_cb_arg, buffer, payload_size) == 0);
796 : 6 : spdk_free(req->payload.contig_or_cb_arg);
797 : :
798 : : /* same thing but additional path coverage, no copy */
799 : 6 : host_to_controller = false;
800 [ + - ]: 6 : STAILQ_INSERT_HEAD(&qpair.free_req, &dummy_req, stailq);
801 : :
802 : 6 : req = nvme_allocate_request_user_copy(&qpair, buffer, payload_size, cb_fn,
803 : : cb_arg, host_to_controller);
804 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(req != NULL);
805 : 6 : CU_ASSERT(req->user_cb_fn == cb_fn);
806 : 6 : CU_ASSERT(req->user_cb_arg == cb_arg);
807 : 6 : CU_ASSERT(req->user_buffer == buffer);
808 : 6 : CU_ASSERT(req->cb_arg == req);
809 [ - + - + ]: 6 : CU_ASSERT(memcmp(req->payload.contig_or_cb_arg, buffer, payload_size) != 0);
810 : 6 : spdk_free(req->payload.contig_or_cb_arg);
811 : :
812 : : /* good buffer and valid payload size but make spdk_zmalloc fail */
813 : : /* set the mock pointer to NULL for spdk_zmalloc */
814 : 6 : MOCK_SET(spdk_zmalloc, NULL);
815 : 6 : req = nvme_allocate_request_user_copy(&qpair, buffer, payload_size, cb_fn,
816 : : cb_arg, host_to_controller);
817 : 6 : CU_ASSERT(req == NULL);
818 : 6 : free(buffer);
819 [ - - - + ]: 6 : MOCK_CLEAR(spdk_zmalloc);
820 : 6 : }
821 : :
822 : : static void
823 : 6 : test_nvme_ctrlr_probe(void)
824 : : {
825 : 6 : int rc = 0;
826 : 6 : struct spdk_nvme_ctrlr ctrlr = {};
827 : 6 : struct spdk_nvme_qpair qpair = {};
828 : 6 : const struct spdk_nvme_transport_id trid = {};
829 : 6 : struct spdk_nvme_probe_ctx probe_ctx = {};
830 : 6 : void *devhandle = NULL;
831 : 6 : void *cb_ctx = NULL;
832 : 6 : struct spdk_nvme_ctrlr *dummy = NULL;
833 : :
834 : 6 : ctrlr.adminq = &qpair;
835 : :
836 : 6 : TAILQ_INIT(&probe_ctx.init_ctrlrs);
837 : 6 : nvme_driver_init();
838 : :
839 : : /* test when probe_cb returns false */
840 : :
841 : 6 : MOCK_SET(dummy_probe_cb, false);
842 : 6 : nvme_probe_ctx_init(&probe_ctx, &trid, NULL, cb_ctx, dummy_probe_cb, NULL, NULL);
843 : 6 : rc = nvme_ctrlr_probe(&trid, &probe_ctx, devhandle);
844 : 6 : CU_ASSERT(rc == 1);
845 : :
846 : : /* probe_cb returns true but we can't construct a ctrl */
847 : 6 : MOCK_SET(dummy_probe_cb, true);
848 : 6 : MOCK_SET(nvme_transport_ctrlr_construct, NULL);
849 : 6 : nvme_probe_ctx_init(&probe_ctx, &trid, NULL, cb_ctx, dummy_probe_cb, NULL, NULL);
850 : 6 : rc = nvme_ctrlr_probe(&trid, &probe_ctx, devhandle);
851 : 6 : CU_ASSERT(rc == -1);
852 : :
853 : : /* happy path */
854 : 6 : MOCK_SET(dummy_probe_cb, true);
855 : 6 : MOCK_SET(nvme_transport_ctrlr_construct, &ctrlr);
856 : 6 : nvme_probe_ctx_init(&probe_ctx, &trid, NULL, cb_ctx, dummy_probe_cb, NULL, NULL);
857 : 6 : rc = nvme_ctrlr_probe(&trid, &probe_ctx, devhandle);
858 : 6 : CU_ASSERT(rc == 0);
859 : 6 : dummy = TAILQ_FIRST(&probe_ctx.init_ctrlrs);
860 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(dummy != NULL);
861 : 6 : CU_ASSERT(dummy == ut_nvme_transport_ctrlr_construct);
862 [ - + ]: 6 : TAILQ_REMOVE(&probe_ctx.init_ctrlrs, dummy, tailq);
863 [ - - - + ]: 6 : MOCK_CLEAR_P(nvme_transport_ctrlr_construct);
864 : :
865 : 6 : free(g_spdk_nvme_driver);
866 : 6 : }
867 : :
868 : : static void
869 : 6 : test_nvme_robust_mutex_init_shared(void)
870 : : {
871 : 5 : pthread_mutex_t mtx;
872 : 6 : int rc = 0;
873 : :
874 : : /* test where both pthread calls succeed */
875 : 6 : MOCK_SET(pthread_mutexattr_init, 0);
876 : 6 : MOCK_SET(pthread_mutex_init, 0);
877 : 6 : rc = nvme_robust_mutex_init_shared(&mtx);
878 : 6 : CU_ASSERT(rc == 0);
879 : :
880 : : /* test where we can't init attr's but init mutex works */
881 : 6 : MOCK_SET(pthread_mutexattr_init, -1);
882 : 6 : MOCK_SET(pthread_mutex_init, 0);
883 : 6 : rc = nvme_robust_mutex_init_shared(&mtx);
884 : : /* for FreeBSD the only possible return value is 0 */
885 : : #ifndef __FreeBSD__
886 : 6 : CU_ASSERT(rc != 0);
887 : : #else
888 : : CU_ASSERT(rc == 0);
889 : : #endif
890 : :
891 : : /* test where we can init attr's but the mutex init fails */
892 : 6 : MOCK_SET(pthread_mutexattr_init, 0);
893 : 6 : MOCK_SET(pthread_mutex_init, -1);
894 : 6 : rc = nvme_robust_mutex_init_shared(&mtx);
895 : : /* for FreeBSD the only possible return value is 0 */
896 : : #ifndef __FreeBSD__
897 : 6 : CU_ASSERT(rc != 0);
898 : : #else
899 : : CU_ASSERT(rc == 0);
900 : : #endif
901 [ - - - + ]: 6 : MOCK_CLEAR(pthread_mutex_init);
902 : 6 : }
903 : :
904 : : static void
905 : 6 : test_opc_data_transfer(void)
906 : : {
907 : : enum spdk_nvme_data_transfer xfer;
908 : :
909 : 6 : xfer = spdk_nvme_opc_get_data_transfer(SPDK_NVME_OPC_FLUSH);
910 : 6 : CU_ASSERT(xfer == SPDK_NVME_DATA_NONE);
911 : :
912 : 6 : xfer = spdk_nvme_opc_get_data_transfer(SPDK_NVME_OPC_WRITE);
913 : 6 : CU_ASSERT(xfer == SPDK_NVME_DATA_HOST_TO_CONTROLLER);
914 : :
915 : 6 : xfer = spdk_nvme_opc_get_data_transfer(SPDK_NVME_OPC_READ);
916 : 6 : CU_ASSERT(xfer == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
917 : :
918 : 6 : xfer = spdk_nvme_opc_get_data_transfer(SPDK_NVME_OPC_GET_LOG_PAGE);
919 : 6 : CU_ASSERT(xfer == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
920 : 6 : }
921 : :
922 : : static void
923 : 6 : test_trid_parse_and_compare(void)
924 : : {
925 : 5 : struct spdk_nvme_transport_id trid1, trid2;
926 : : int ret;
927 : :
928 : : /* set trid1 trid2 value to id parse */
929 : 6 : ret = spdk_nvme_transport_id_parse(NULL, "trtype:PCIe traddr:0000:04:00.0");
930 : 6 : CU_ASSERT(ret == -EINVAL);
931 : 6 : memset(&trid1, 0, sizeof(trid1));
932 : 6 : ret = spdk_nvme_transport_id_parse(&trid1, NULL);
933 : 6 : CU_ASSERT(ret == -EINVAL);
934 : 6 : ret = spdk_nvme_transport_id_parse(NULL, NULL);
935 : 6 : CU_ASSERT(ret == -EINVAL);
936 : 6 : memset(&trid1, 0, sizeof(trid1));
937 : 6 : ret = spdk_nvme_transport_id_parse(&trid1, "trtype-PCIe traddr-0000-04-00.0");
938 : 6 : CU_ASSERT(ret == -EINVAL);
939 : 6 : memset(&trid1, 0, sizeof(trid1));
940 : 6 : ret = spdk_nvme_transport_id_parse(&trid1, "trtype-PCIe traddr-0000-04-00.0-:");
941 : 6 : CU_ASSERT(ret == -EINVAL);
942 : 6 : memset(&trid1, 0, sizeof(trid1));
943 : 6 : ret = spdk_nvme_transport_id_parse(&trid1, " \t\n:");
944 : 6 : CU_ASSERT(ret == -EINVAL);
945 : 6 : memset(&trid1, 0, sizeof(trid1));
946 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1,
947 : : "trtype:rdma\n"
948 : : "adrfam:ipv4\n"
949 : : "traddr:192.168.100.8\n"
950 : : "trsvcid:4420\n"
951 : : "subnqn:nqn.2014-08.org.nvmexpress.discovery") == 0);
952 : 6 : CU_ASSERT(trid1.trtype == SPDK_NVME_TRANSPORT_RDMA);
953 : 6 : CU_ASSERT(trid1.adrfam == SPDK_NVMF_ADRFAM_IPV4);
954 : 6 : CU_ASSERT(strcmp(trid1.traddr, "192.168.100.8") == 0);
955 : 6 : CU_ASSERT(strcmp(trid1.trsvcid, "4420") == 0);
956 : 6 : CU_ASSERT(strcmp(trid1.subnqn, "nqn.2014-08.org.nvmexpress.discovery") == 0);
957 : :
958 : 6 : memset(&trid2, 0, sizeof(trid2));
959 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid2, "trtype:PCIe traddr:0000:04:00.0") == 0);
960 : 6 : CU_ASSERT(trid2.trtype == SPDK_NVME_TRANSPORT_PCIE);
961 : 6 : CU_ASSERT(strcmp(trid2.traddr, "0000:04:00.0") == 0);
962 : :
963 : 6 : CU_ASSERT(spdk_nvme_transport_id_compare(&trid1, &trid2) != 0);
964 : :
965 : : /* set trid1 trid2 and test id_compare */
966 : 6 : memset_trid(&trid1, &trid2);
967 : 6 : trid1.adrfam = SPDK_NVMF_ADRFAM_IPV6;
968 : 6 : trid2.adrfam = SPDK_NVMF_ADRFAM_IPV4;
969 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
970 : 6 : CU_ASSERT(ret > 0);
971 : :
972 : 6 : memset_trid(&trid1, &trid2);
973 : 6 : snprintf(trid1.traddr, sizeof(trid1.traddr), "192.168.100.8");
974 : 6 : snprintf(trid2.traddr, sizeof(trid2.traddr), "192.168.100.9");
975 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
976 : 6 : CU_ASSERT(ret < 0);
977 : :
978 : 6 : memset_trid(&trid1, &trid2);
979 : 6 : snprintf(trid1.trsvcid, sizeof(trid1.trsvcid), "4420");
980 : 6 : snprintf(trid2.trsvcid, sizeof(trid2.trsvcid), "4421");
981 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
982 : 6 : CU_ASSERT(ret < 0);
983 : :
984 : 6 : memset_trid(&trid1, &trid2);
985 : 6 : snprintf(trid1.subnqn, sizeof(trid1.subnqn), "subnqn:nqn.2016-08.org.nvmexpress.discovery");
986 : 6 : snprintf(trid2.subnqn, sizeof(trid2.subnqn), "subnqn:nqn.2017-08.org.nvmexpress.discovery");
987 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
988 : 6 : CU_ASSERT(ret < 0);
989 : :
990 : 6 : memset_trid(&trid1, &trid2);
991 : 6 : snprintf(trid1.subnqn, sizeof(trid1.subnqn), "subnqn:nqn.2016-08.org.nvmexpress.discovery");
992 : 6 : snprintf(trid2.subnqn, sizeof(trid2.subnqn), "subnqn:nqn.2016-08.org.nvmexpress.discovery");
993 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
994 : 6 : CU_ASSERT(ret == 0);
995 : :
996 : 6 : memset_trid(&trid1, &trid2);
997 : 6 : snprintf(trid1.subnqn, sizeof(trid1.subnqn), "subnqn:nqn.2016-08.org.nvmexpress.discovery");
998 : 6 : snprintf(trid2.subnqn, sizeof(trid2.subnqn), "subnqn:nqn.2016-08.org.Nvmexpress.discovery");
999 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
1000 : 6 : CU_ASSERT(ret > 0);
1001 : :
1002 : 6 : memset_trid(&trid1, &trid2);
1003 : 6 : ret = spdk_nvme_transport_id_compare(&trid1, &trid2);
1004 : 6 : CU_ASSERT(ret == 0);
1005 : :
1006 : : /* Compare PCI addresses via spdk_pci_addr_compare (rather than as strings) */
1007 : 6 : memset_trid(&trid1, &trid2);
1008 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1, "trtype:PCIe traddr:0000:04:00.0") == 0);
1009 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid2, "trtype:PCIe traddr:04:00.0") == 0);
1010 : 6 : CU_ASSERT(spdk_nvme_transport_id_compare(&trid1, &trid2) == 0);
1011 : :
1012 : 6 : memset_trid(&trid1, &trid2);
1013 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1, "trtype:PCIe traddr:0000:05:00.0") == 0);
1014 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid2, "trtype:PCIe traddr:04:00.0") == 0);
1015 : 6 : CU_ASSERT(spdk_nvme_transport_id_compare(&trid1, &trid2) > 0);
1016 : :
1017 : 6 : memset_trid(&trid1, &trid2);
1018 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1, "trtype:PCIe traddr:0000:04:00.0") == 0);
1019 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid2, "trtype:PCIe traddr:05:00.0") == 0);
1020 : 6 : CU_ASSERT(spdk_nvme_transport_id_compare(&trid1, &trid2) < 0);
1021 : :
1022 : 6 : memset_trid(&trid1, &trid2);
1023 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1, "trtype=PCIe traddr=0000:04:00.0") == 0);
1024 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid2, "trtype=PCIe traddr=05:00.0") == 0);
1025 : 6 : CU_ASSERT(spdk_nvme_transport_id_compare(&trid1, &trid2) < 0);
1026 : :
1027 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse(&trid1,
1028 : : "trtype:tcp\n"
1029 : : "adrfam:ipv4\n"
1030 : : "traddr:192.168.100.8\n"
1031 : : "trsvcid:4420\n"
1032 : : "priority:2\n"
1033 : : "subnqn:nqn.2014-08.org.nvmexpress.discovery") == 0);
1034 : 6 : CU_ASSERT(trid1.priority == 2);
1035 : 6 : }
1036 : :
1037 : : static void
1038 : 6 : test_spdk_nvme_transport_id_parse_trtype(void)
1039 : : {
1040 : :
1041 : : enum spdk_nvme_transport_type *trtype;
1042 : 5 : enum spdk_nvme_transport_type sct;
1043 : : char *str;
1044 : :
1045 : 6 : trtype = NULL;
1046 : 6 : str = "unit_test";
1047 : :
1048 : : /* test function returned value when trtype is NULL but str not NULL */
1049 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_trtype(trtype, str) == (-EINVAL));
1050 : :
1051 : : /* test function returned value when str is NULL but trtype not NULL */
1052 : 6 : trtype = &sct;
1053 : 6 : str = NULL;
1054 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_trtype(trtype, str) == (-EINVAL));
1055 : :
1056 : : /* test function returned value when str and strtype not NULL, but str value
1057 : : * not "PCIe" or "RDMA" */
1058 : 6 : str = "unit_test";
1059 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_trtype(trtype, str) == 0);
1060 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_CUSTOM);
1061 : :
1062 : : /* test trtype value when use function "strcasecmp" to compare str and "PCIe",not case-sensitive */
1063 : 6 : str = "PCIe";
1064 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1065 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_PCIE);
1066 : :
1067 : 6 : str = "pciE";
1068 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1069 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_PCIE);
1070 : :
1071 : : /* test trtype value when use function "strcasecmp" to compare str and "RDMA",not case-sensitive */
1072 : 6 : str = "RDMA";
1073 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1074 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_RDMA);
1075 : :
1076 : 6 : str = "rdma";
1077 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1078 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_RDMA);
1079 : :
1080 : : /* test trtype value when use function "strcasecmp" to compare str and "FC",not case-sensitive */
1081 : 6 : str = "FC";
1082 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1083 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_FC);
1084 : :
1085 : 6 : str = "fc";
1086 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1087 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_FC);
1088 : :
1089 : : /* test trtype value when use function "strcasecmp" to compare str and "TCP",not case-sensitive */
1090 : 6 : str = "TCP";
1091 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1092 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_TCP);
1093 : :
1094 : 6 : str = "tcp";
1095 : 6 : spdk_nvme_transport_id_parse_trtype(trtype, str);
1096 : 6 : CU_ASSERT((*trtype) == SPDK_NVME_TRANSPORT_TCP);
1097 : 6 : }
1098 : :
1099 : : static void
1100 : 6 : test_spdk_nvme_transport_id_parse_adrfam(void)
1101 : : {
1102 : :
1103 : : enum spdk_nvmf_adrfam *adrfam;
1104 : 5 : enum spdk_nvmf_adrfam sct;
1105 : : char *str;
1106 : :
1107 : 6 : adrfam = NULL;
1108 : 6 : str = "unit_test";
1109 : :
1110 : : /* test function returned value when adrfam is NULL but str not NULL */
1111 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_adrfam(adrfam, str) == (-EINVAL));
1112 : :
1113 : : /* test function returned value when str is NULL but adrfam not NULL */
1114 : 6 : adrfam = &sct;
1115 : 6 : str = NULL;
1116 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_adrfam(adrfam, str) == (-EINVAL));
1117 : :
1118 : : /* test function returned value when str and adrfam not NULL, but str value
1119 : : * not "IPv4" or "IPv6" or "IB" or "FC" */
1120 : 6 : str = "unit_test";
1121 : 6 : CU_ASSERT(spdk_nvme_transport_id_parse_adrfam(adrfam, str) == (-ENOENT));
1122 : :
1123 : : /* test adrfam value when use function "strcasecmp" to compare str and "IPv4",not case-sensitive */
1124 : 6 : str = "IPv4";
1125 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1126 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IPV4);
1127 : :
1128 : 6 : str = "ipV4";
1129 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1130 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IPV4);
1131 : :
1132 : : /* test adrfam value when use function "strcasecmp" to compare str and "IPv6",not case-sensitive */
1133 : 6 : str = "IPv6";
1134 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1135 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IPV6);
1136 : :
1137 : 6 : str = "ipV6";
1138 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1139 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IPV6);
1140 : :
1141 : : /* test adrfam value when use function "strcasecmp" to compare str and "IB",not case-sensitive */
1142 : 6 : str = "IB";
1143 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1144 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IB);
1145 : :
1146 : 6 : str = "ib";
1147 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1148 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_IB);
1149 : :
1150 : : /* test adrfam value when use function "strcasecmp" to compare str and "FC",not case-sensitive */
1151 : 6 : str = "FC";
1152 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1153 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_FC);
1154 : :
1155 : 6 : str = "fc";
1156 : 6 : spdk_nvme_transport_id_parse_adrfam(adrfam, str);
1157 : 6 : CU_ASSERT((*adrfam) == SPDK_NVMF_ADRFAM_FC);
1158 : :
1159 : 6 : }
1160 : :
1161 : : static void
1162 : 6 : test_trid_trtype_str(void)
1163 : : {
1164 : : const char *s;
1165 : :
1166 : 6 : s = spdk_nvme_transport_id_trtype_str(-5);
1167 : 6 : CU_ASSERT(s == NULL);
1168 : :
1169 : 6 : s = spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_PCIE);
1170 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1171 [ - + ]: 6 : CU_ASSERT(strcmp(s, "PCIe") == 0);
1172 : :
1173 : 6 : s = spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_RDMA);
1174 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1175 [ - + ]: 6 : CU_ASSERT(strcmp(s, "RDMA") == 0);
1176 : :
1177 : 6 : s = spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_FC);
1178 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1179 [ - + ]: 6 : CU_ASSERT(strcmp(s, "FC") == 0);
1180 : :
1181 : 6 : s = spdk_nvme_transport_id_trtype_str(SPDK_NVME_TRANSPORT_TCP);
1182 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1183 [ - + ]: 6 : CU_ASSERT(strcmp(s, "TCP") == 0);
1184 : 6 : }
1185 : :
1186 : : static void
1187 : 6 : test_trid_adrfam_str(void)
1188 : : {
1189 : : const char *s;
1190 : :
1191 : 6 : s = spdk_nvme_transport_id_adrfam_str(-5);
1192 : 6 : CU_ASSERT(s == NULL);
1193 : :
1194 : 6 : s = spdk_nvme_transport_id_adrfam_str(SPDK_NVMF_ADRFAM_IPV4);
1195 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1196 [ - + ]: 6 : CU_ASSERT(strcmp(s, "IPv4") == 0);
1197 : :
1198 : 6 : s = spdk_nvme_transport_id_adrfam_str(SPDK_NVMF_ADRFAM_IPV6);
1199 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1200 [ - + ]: 6 : CU_ASSERT(strcmp(s, "IPv6") == 0);
1201 : :
1202 : 6 : s = spdk_nvme_transport_id_adrfam_str(SPDK_NVMF_ADRFAM_IB);
1203 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1204 [ - + ]: 6 : CU_ASSERT(strcmp(s, "IB") == 0);
1205 : :
1206 : 6 : s = spdk_nvme_transport_id_adrfam_str(SPDK_NVMF_ADRFAM_FC);
1207 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(s != NULL);
1208 [ - + ]: 6 : CU_ASSERT(strcmp(s, "FC") == 0);
1209 : 6 : }
1210 : :
1211 : : /* stub callback used by the test_nvme_request_check_timeout */
1212 : : static bool ut_timeout_cb_call = false;
1213 : : static void
1214 : 6 : dummy_timeout_cb(void *cb_arg, struct spdk_nvme_ctrlr *ctrlr,
1215 : : struct spdk_nvme_qpair *qpair, uint16_t cid)
1216 : : {
1217 : 6 : ut_timeout_cb_call = true;
1218 : 6 : }
1219 : :
1220 : : static void
1221 : 6 : test_nvme_request_check_timeout(void)
1222 : : {
1223 : : int rc;
1224 : 5 : struct spdk_nvme_qpair qpair;
1225 : 5 : struct nvme_request req;
1226 : 5 : struct spdk_nvme_ctrlr_process active_proc;
1227 : 6 : uint16_t cid = 0;
1228 : 6 : uint64_t now_tick = 0;
1229 : :
1230 [ - + ]: 6 : memset(&qpair, 0x0, sizeof(qpair));
1231 [ - + ]: 6 : memset(&req, 0x0, sizeof(req));
1232 [ - + ]: 6 : memset(&active_proc, 0x0, sizeof(active_proc));
1233 : 6 : req.qpair = &qpair;
1234 : 6 : active_proc.timeout_cb_fn = dummy_timeout_cb;
1235 : :
1236 : : /* if have called timeout_cb_fn then return directly */
1237 : 6 : req.timed_out = true;
1238 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1239 : 6 : CU_ASSERT(rc == 0);
1240 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == false);
1241 : :
1242 : : /* if timeout isn't enabled then return directly */
1243 : 6 : req.timed_out = false;
1244 : 6 : req.submit_tick = 0;
1245 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1246 : 6 : CU_ASSERT(rc == 0);
1247 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == false);
1248 : :
1249 : : /* req->pid isn't right then return directly */
1250 : 6 : req.submit_tick = 1;
1251 : 6 : req.pid = g_spdk_nvme_pid + 1;
1252 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1253 : 6 : CU_ASSERT(rc == 0);
1254 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == false);
1255 : :
1256 : : /* AER command has no timeout */
1257 : 6 : req.pid = g_spdk_nvme_pid;
1258 : 6 : req.cmd.opc = SPDK_NVME_OPC_ASYNC_EVENT_REQUEST;
1259 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1260 : 6 : CU_ASSERT(rc == 0);
1261 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == false);
1262 : :
1263 : : /* time isn't out */
1264 : 6 : qpair.id = 1;
1265 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1266 : 6 : CU_ASSERT(rc == 1);
1267 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == false);
1268 : :
1269 : 6 : now_tick = 2;
1270 : 6 : rc = nvme_request_check_timeout(&req, cid, &active_proc, now_tick);
1271 : 6 : CU_ASSERT(req.timed_out == true);
1272 [ - + ]: 6 : CU_ASSERT(ut_timeout_cb_call == true);
1273 : 6 : CU_ASSERT(rc == 0);
1274 : 6 : }
1275 : :
1276 : : struct nvme_completion_poll_status g_status;
1277 : : uint64_t completion_delay_us, timeout_in_usecs;
1278 : : int g_process_comp_result;
1279 : : pthread_mutex_t g_robust_lock = PTHREAD_MUTEX_INITIALIZER;
1280 : :
1281 : : int
1282 : 60 : spdk_nvme_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions)
1283 : : {
1284 : 60 : spdk_delay_us(completion_delay_us);
1285 : :
1286 [ + + + + ]: 60 : g_status.done = completion_delay_us < timeout_in_usecs && g_process_comp_result == 0 ? true : false;
1287 : :
1288 : 60 : return g_process_comp_result;
1289 : : }
1290 : :
1291 : : static void
1292 : 6 : test_nvme_wait_for_completion(void)
1293 : : {
1294 : 5 : struct spdk_nvme_qpair qpair;
1295 : 5 : struct spdk_nvme_ctrlr ctrlr;
1296 : 6 : int rc = 0;
1297 : :
1298 [ - + ]: 6 : memset(&ctrlr, 0, sizeof(ctrlr));
1299 : 6 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1300 [ - + ]: 6 : memset(&qpair, 0, sizeof(qpair));
1301 : 6 : qpair.ctrlr = &ctrlr;
1302 : :
1303 : : /* completion timeout */
1304 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1305 : 6 : completion_delay_us = 2000000;
1306 : 6 : timeout_in_usecs = 1000000;
1307 : 6 : rc = nvme_wait_for_completion_timeout(&qpair, &g_status, timeout_in_usecs);
1308 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1309 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1310 : 6 : CU_ASSERT(rc == -ECANCELED);
1311 : :
1312 : : /* spdk_nvme_qpair_process_completions returns error */
1313 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1314 : 6 : g_process_comp_result = -1;
1315 : 6 : completion_delay_us = 1000000;
1316 : 6 : timeout_in_usecs = 2000000;
1317 : 6 : rc = nvme_wait_for_completion_timeout(&qpair, &g_status, timeout_in_usecs);
1318 : 6 : CU_ASSERT(rc == -ECANCELED);
1319 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1320 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1321 : 6 : CU_ASSERT(g_status.cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1322 : 6 : CU_ASSERT(g_status.cpl.status.sc == SPDK_NVME_SC_ABORTED_SQ_DELETION);
1323 : :
1324 : 6 : g_process_comp_result = 0;
1325 : :
1326 : : /* complete in time */
1327 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1328 : 6 : completion_delay_us = 1000000;
1329 : 6 : timeout_in_usecs = 2000000;
1330 : 6 : rc = nvme_wait_for_completion_timeout(&qpair, &g_status, timeout_in_usecs);
1331 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == false);
1332 [ - + ]: 6 : CU_ASSERT(g_status.done == true);
1333 : 6 : CU_ASSERT(rc == 0);
1334 : :
1335 : : /* nvme_wait_for_completion */
1336 : : /* spdk_nvme_qpair_process_completions returns error */
1337 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1338 : 6 : g_process_comp_result = -1;
1339 : 6 : rc = nvme_wait_for_completion(&qpair, &g_status);
1340 : 6 : CU_ASSERT(rc == -ECANCELED);
1341 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1342 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1343 : 6 : CU_ASSERT(g_status.cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1344 : 6 : CU_ASSERT(g_status.cpl.status.sc == SPDK_NVME_SC_ABORTED_SQ_DELETION);
1345 : :
1346 : : /* successful completion */
1347 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1348 : 6 : g_process_comp_result = 0;
1349 : 6 : rc = nvme_wait_for_completion(&qpair, &g_status);
1350 : 6 : CU_ASSERT(rc == 0);
1351 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == false);
1352 [ - + ]: 6 : CU_ASSERT(g_status.done == true);
1353 : :
1354 : : /* completion timeout */
1355 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1356 : 6 : completion_delay_us = 2000000;
1357 : 6 : timeout_in_usecs = 1000000;
1358 : 6 : rc = nvme_wait_for_completion_robust_lock_timeout(&qpair, &g_status, &g_robust_lock,
1359 : : timeout_in_usecs);
1360 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1361 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1362 : 6 : CU_ASSERT(rc == -ECANCELED);
1363 : :
1364 : : /* spdk_nvme_qpair_process_completions returns error */
1365 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1366 : 6 : g_process_comp_result = -1;
1367 : 6 : completion_delay_us = 1000000;
1368 : 6 : timeout_in_usecs = 2000000;
1369 : 6 : rc = nvme_wait_for_completion_robust_lock_timeout(&qpair, &g_status, &g_robust_lock,
1370 : : timeout_in_usecs);
1371 : 6 : CU_ASSERT(rc == -ECANCELED);
1372 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1373 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1374 : 6 : CU_ASSERT(g_status.cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1375 : 6 : CU_ASSERT(g_status.cpl.status.sc == SPDK_NVME_SC_ABORTED_SQ_DELETION);
1376 : :
1377 : 6 : g_process_comp_result = 0;
1378 : :
1379 : : /* complete in time */
1380 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1381 : 6 : completion_delay_us = 1000000;
1382 : 6 : timeout_in_usecs = 2000000;
1383 : 6 : rc = nvme_wait_for_completion_robust_lock_timeout(&qpair, &g_status, &g_robust_lock,
1384 : : timeout_in_usecs);
1385 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == false);
1386 [ - + ]: 6 : CU_ASSERT(g_status.done == true);
1387 : 6 : CU_ASSERT(rc == 0);
1388 : :
1389 : : /* nvme_wait_for_completion */
1390 : : /* spdk_nvme_qpair_process_completions returns error */
1391 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1392 : 6 : g_process_comp_result = -1;
1393 : 6 : rc = nvme_wait_for_completion_robust_lock(&qpair, &g_status, &g_robust_lock);
1394 : 6 : CU_ASSERT(rc == -ECANCELED);
1395 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == true);
1396 [ - + ]: 6 : CU_ASSERT(g_status.done == false);
1397 : 6 : CU_ASSERT(g_status.cpl.status.sct == SPDK_NVME_SCT_GENERIC);
1398 : 6 : CU_ASSERT(g_status.cpl.status.sc == SPDK_NVME_SC_ABORTED_SQ_DELETION);
1399 : :
1400 : : /* successful completion */
1401 [ - + ]: 6 : memset(&g_status, 0, sizeof(g_status));
1402 : 6 : g_process_comp_result = 0;
1403 : 6 : rc = nvme_wait_for_completion_robust_lock(&qpair, &g_status, &g_robust_lock);
1404 : 6 : CU_ASSERT(rc == 0);
1405 [ - + ]: 6 : CU_ASSERT(g_status.timed_out == false);
1406 [ - + ]: 6 : CU_ASSERT(g_status.done == true);
1407 : 6 : }
1408 : :
1409 : : static void
1410 : 6 : test_nvme_ctrlr_probe_internal(void)
1411 : : {
1412 : : struct spdk_nvme_probe_ctx *probe_ctx;
1413 : 6 : struct spdk_nvme_transport_id trid = {};
1414 : 6 : struct nvme_driver dummy = {};
1415 : : int rc;
1416 : :
1417 : 6 : probe_ctx = calloc(1, sizeof(*probe_ctx));
1418 : 6 : CU_ASSERT(probe_ctx != NULL);
1419 : :
1420 : 6 : MOCK_SET(spdk_process_is_primary, true);
1421 : 6 : MOCK_SET(spdk_memzone_reserve, (void *)&dummy);
1422 : 6 : g_spdk_nvme_driver = NULL;
1423 : 6 : rc = nvme_driver_init();
1424 : 6 : CU_ASSERT(rc == 0);
1425 : :
1426 : 6 : ut_test_probe_internal = true;
1427 : 6 : MOCK_SET(dummy_probe_cb, true);
1428 : 6 : trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1429 : 6 : nvme_probe_ctx_init(probe_ctx, &trid, NULL, NULL, dummy_probe_cb, NULL, NULL);
1430 : 6 : rc = nvme_probe_internal(probe_ctx, false);
1431 : 6 : CU_ASSERT(rc < 0);
1432 : 6 : CU_ASSERT(TAILQ_EMPTY(&probe_ctx->init_ctrlrs));
1433 : :
1434 : 6 : free(probe_ctx);
1435 : 6 : ut_test_probe_internal = false;
1436 : 6 : }
1437 : :
1438 : : static void
1439 : 6 : test_spdk_nvme_parse_func(void)
1440 : : {
1441 : 6 : struct spdk_nvme_host_id hostid = {};
1442 : 6 : char str[64] = {};
1443 : 6 : const char *rt_str = NULL;
1444 : 5 : uint32_t prchk_flags;
1445 : : int rc;
1446 : :
1447 : : /* Parse prchk flags. */
1448 : 6 : prchk_flags = 0;
1449 : 6 : rt_str = spdk_nvme_prchk_flags_str(SPDK_NVME_IO_FLAGS_PRCHK_REFTAG);
1450 [ - + - + ]: 6 : memcpy(str, rt_str, strlen(rt_str));
1451 : :
1452 : 6 : rc = spdk_nvme_prchk_flags_parse(&prchk_flags, str);
1453 : 6 : CU_ASSERT(rc == 0);
1454 : 6 : CU_ASSERT(prchk_flags & SPDK_NVME_IO_FLAGS_PRCHK_REFTAG);
1455 : :
1456 : 6 : prchk_flags = 0;
1457 : 6 : rt_str = spdk_nvme_prchk_flags_str(SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
1458 [ - + - + ]: 6 : memcpy(str, rt_str, strlen(rt_str));
1459 : :
1460 : 6 : rc = spdk_nvme_prchk_flags_parse(&prchk_flags, str);
1461 : 6 : CU_ASSERT(prchk_flags & SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
1462 : 6 : CU_ASSERT(rc == 0);
1463 : :
1464 : 6 : prchk_flags = 0;
1465 : 6 : rt_str = spdk_nvme_prchk_flags_str(SPDK_NVME_IO_FLAGS_PRCHK_REFTAG |
1466 : : SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
1467 [ - + - + ]: 6 : memcpy(str, rt_str, strlen(rt_str));
1468 : :
1469 : 6 : rc = spdk_nvme_prchk_flags_parse(&prchk_flags, str);
1470 : 6 : CU_ASSERT(rc == 0);
1471 : 6 : CU_ASSERT(prchk_flags & SPDK_NVME_IO_FLAGS_PRCHK_REFTAG);
1472 : 6 : CU_ASSERT(prchk_flags & SPDK_NVME_IO_FLAGS_PRCHK_GUARD);
1473 : :
1474 : 6 : rc = spdk_nvme_prchk_flags_parse(NULL, NULL);
1475 : 6 : CU_ASSERT(rc == -EINVAL);
1476 : :
1477 : : /* Parse host id. */
1478 : 6 : memcpy(str, "hostaddr:192.168.1.1", sizeof("hostaddr:192.168.1.1"));
1479 : 6 : rc = spdk_nvme_host_id_parse(&hostid, str);
1480 : 6 : CU_ASSERT(rc == 0);
1481 : 6 : CU_ASSERT(!strncmp(hostid.hostaddr, "192.168.1.1", sizeof("192.168.1.1")));
1482 : :
1483 : 6 : memset(&hostid, 0, sizeof(hostid));
1484 : 6 : memcpy(str, "hostsvcid:192.168.1.2", sizeof("hostsvcid:192.168.1.2"));
1485 : 6 : rc = spdk_nvme_host_id_parse(&hostid, str);
1486 : 6 : CU_ASSERT(rc == 0);
1487 : 6 : CU_ASSERT(!strncmp(hostid.hostsvcid, "192.168.1.2", sizeof("192.168.1.2")));
1488 : :
1489 : : /* Unknown transport ID key */
1490 : 6 : memset(&hostid, 0, sizeof(hostid));
1491 : 6 : memcpy(str, "trtype:xxx", sizeof("trtype:xxx"));
1492 : 6 : rc = spdk_nvme_host_id_parse(&hostid, str);
1493 : 6 : CU_ASSERT(rc == 0);
1494 [ + - + - ]: 6 : CU_ASSERT(hostid.hostaddr[0] == '\0' && hostid.hostsvcid[0] == '\0');
1495 : 6 : }
1496 : :
1497 : : static void
1498 : 6 : test_spdk_nvme_detach_async(void)
1499 : : {
1500 : 6 : int rc = 1;
1501 : 5 : struct spdk_nvme_ctrlr ctrlr1, ctrlr2;
1502 : 6 : struct nvme_driver test_driver = {};
1503 : 5 : struct spdk_nvme_detach_ctx *detach_ctx;
1504 : : struct nvme_ctrlr_detach_ctx *ctx;
1505 : :
1506 : 6 : detach_ctx = NULL;
1507 [ - + ]: 6 : memset(&ctrlr1, 0, sizeof(ctrlr1));
1508 : 6 : ctrlr1.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1509 [ - + ]: 6 : memset(&ctrlr2, 0, sizeof(ctrlr2));
1510 : 6 : ctrlr2.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1511 : :
1512 : 6 : g_spdk_nvme_driver = &test_driver;
1513 : 6 : TAILQ_INIT(&test_driver.shared_attached_ctrlrs);
1514 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr1, tailq);
1515 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr2, tailq);
1516 [ - + ]: 6 : CU_ASSERT(pthread_mutex_init(&test_driver.lock, NULL) == 0);
1517 : 6 : MOCK_SET(nvme_ctrlr_get_ref_count, 1);
1518 : :
1519 : 6 : rc = spdk_nvme_detach_async(&ctrlr1, &detach_ctx);
1520 : 6 : CU_ASSERT(rc == 0);
1521 [ - + ]: 6 : CU_ASSERT(ctrlr1.is_destructed == true);
1522 : 6 : CU_ASSERT(detach_ctx != NULL);
1523 : :
1524 : 6 : rc = spdk_nvme_detach_async(&ctrlr2, &detach_ctx);
1525 : 6 : CU_ASSERT(rc == 0);
1526 [ - + ]: 6 : CU_ASSERT(ctrlr2.is_destructed == true);
1527 : 6 : CU_ASSERT(detach_ctx != NULL);
1528 : :
1529 : 6 : CU_ASSERT(TAILQ_EMPTY(&test_driver.shared_attached_ctrlrs) == false);
1530 : :
1531 : 6 : rc = spdk_nvme_detach_poll_async(detach_ctx);
1532 : 6 : CU_ASSERT(rc == 0);
1533 : 6 : CU_ASSERT(TAILQ_EMPTY(&test_driver.shared_attached_ctrlrs) == true);
1534 : :
1535 : : /* ctrlr1 is a PCIe controller but ctrlr2 is an non-PCIe controller.
1536 : : * Even for this case, detachment should complete successfully.
1537 : : */
1538 : 6 : detach_ctx = NULL;
1539 [ - + ]: 6 : memset(&ctrlr1, 0, sizeof(ctrlr1));
1540 : 6 : ctrlr1.trid.trtype = SPDK_NVME_TRANSPORT_RDMA;
1541 [ - + ]: 6 : memset(&ctrlr2, 0, sizeof(ctrlr2));
1542 : 6 : ctrlr2.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1543 : 6 : TAILQ_INIT(&g_nvme_attached_ctrlrs);
1544 : 6 : TAILQ_INSERT_TAIL(&g_nvme_attached_ctrlrs, &ctrlr1, tailq);
1545 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr2, tailq);
1546 : :
1547 : 6 : rc = spdk_nvme_detach_async(&ctrlr1, &detach_ctx);
1548 : 6 : CU_ASSERT(rc == 0);
1549 [ - + ]: 6 : CU_ASSERT(ctrlr1.is_destructed == true);
1550 : 6 : CU_ASSERT(detach_ctx != NULL);
1551 : :
1552 : 6 : rc = spdk_nvme_detach_async(&ctrlr2, &detach_ctx);
1553 : 6 : CU_ASSERT(rc == 0);
1554 [ - + ]: 6 : CU_ASSERT(ctrlr2.is_destructed == true);
1555 : 6 : CU_ASSERT(detach_ctx != NULL);
1556 : :
1557 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_nvme_attached_ctrlrs) == false);
1558 : 6 : CU_ASSERT(TAILQ_EMPTY(&test_driver.shared_attached_ctrlrs) == false);
1559 : :
1560 : 6 : rc = spdk_nvme_detach_poll_async(detach_ctx);
1561 : 6 : CU_ASSERT(rc == 0);
1562 : 6 : CU_ASSERT(TAILQ_EMPTY(&g_nvme_attached_ctrlrs) == true);
1563 : 6 : CU_ASSERT(TAILQ_EMPTY(&test_driver.shared_attached_ctrlrs) == true);
1564 : :
1565 : : /* Test if ctrlr2 can be detached by using the same context that
1566 : : * ctrlr1 uses while ctrlr1 is being detached.
1567 : : */
1568 : 6 : detach_ctx = NULL;
1569 [ - + ]: 6 : memset(&ctrlr1, 0, sizeof(ctrlr1));
1570 : 6 : ctrlr1.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1571 [ - + ]: 6 : memset(&ctrlr2, 0, sizeof(ctrlr2));
1572 : 6 : ctrlr2.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
1573 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr1, tailq);
1574 : 6 : TAILQ_INSERT_TAIL(&test_driver.shared_attached_ctrlrs, &ctrlr2, tailq);
1575 : :
1576 : 6 : rc = spdk_nvme_detach_async(&ctrlr1, &detach_ctx);
1577 : 6 : CU_ASSERT(rc == 0);
1578 [ - + ]: 6 : CU_ASSERT(ctrlr1.is_destructed == true);
1579 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(detach_ctx != NULL);
1580 : :
1581 : 6 : ctx = TAILQ_FIRST(&detach_ctx->head);
1582 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(ctx != NULL);
1583 : 6 : CU_ASSERT(ctx->ctrlr == &ctrlr1);
1584 [ - + ]: 6 : CU_ASSERT(ctx->shutdown_complete == true);
1585 : :
1586 : : /* Set ctx->shutdown_complete for ctrlr1 to false to allow ctrlr2 to
1587 : : * add to detach_ctx while spdk_nvme_detach_poll_async() is being
1588 : : * executed.
1589 : : */
1590 : 6 : ctx->shutdown_complete = false;
1591 : :
1592 : 6 : rc = spdk_nvme_detach_poll_async(detach_ctx);
1593 : 6 : CU_ASSERT(rc == -EAGAIN);
1594 : :
1595 : 6 : rc = spdk_nvme_detach_async(&ctrlr2, &detach_ctx);
1596 : 6 : CU_ASSERT(rc == 0);
1597 [ - + ]: 6 : CU_ASSERT(ctrlr2.is_destructed == true);
1598 : :
1599 : : /* After ctrlr2 is added to detach_ctx, set ctx->shutdown_complete for
1600 : : * ctrlr1 to true to complete spdk_nvme_detach_poll_async().
1601 : : */
1602 : 6 : ctx->shutdown_complete = true;
1603 : :
1604 : 6 : rc = spdk_nvme_detach_poll_async(detach_ctx);
1605 : 6 : CU_ASSERT(rc == 0);
1606 : 6 : CU_ASSERT(TAILQ_EMPTY(&test_driver.shared_attached_ctrlrs) == true);
1607 : :
1608 : 6 : g_spdk_nvme_driver = NULL;
1609 [ - + ]: 6 : pthread_mutex_destroy(&test_driver.lock);
1610 [ - - - + ]: 6 : MOCK_CLEAR(nvme_ctrlr_get_ref_count);
1611 : 6 : }
1612 : :
1613 : : static void
1614 : 6 : test_nvme_parse_addr(void)
1615 : : {
1616 : 5 : struct sockaddr_storage dst_addr;
1617 : 6 : int rc = 0;
1618 : 5 : long int port;
1619 : :
1620 [ - + ]: 6 : memset(&dst_addr, 0, sizeof(dst_addr));
1621 : : /* case1: getaddrinfo failed */
1622 : 6 : rc = nvme_parse_addr(&dst_addr, AF_INET, NULL, NULL, &port);
1623 : 6 : CU_ASSERT(rc != 0);
1624 : :
1625 : : /* case2: res->ai_addrlen < sizeof(*sa). Expect: Pass. */
1626 : 6 : rc = nvme_parse_addr(&dst_addr, AF_INET, "12.34.56.78", "23", &port);
1627 : 6 : CU_ASSERT(rc == 0);
1628 : 6 : CU_ASSERT(port == 23);
1629 : 6 : CU_ASSERT(dst_addr.ss_family == AF_INET);
1630 : 6 : }
1631 : :
1632 : : int
1633 : 6 : main(int argc, char **argv)
1634 : : {
1635 : 6 : CU_pSuite suite = NULL;
1636 : : unsigned int num_failures;
1637 : :
1638 : 6 : CU_initialize_registry();
1639 : :
1640 : 6 : suite = CU_add_suite("nvme", NULL, NULL);
1641 : :
1642 : 6 : CU_ADD_TEST(suite, test_opc_data_transfer);
1643 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_transport_id_parse_trtype);
1644 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_transport_id_parse_adrfam);
1645 : 6 : CU_ADD_TEST(suite, test_trid_parse_and_compare);
1646 : 6 : CU_ADD_TEST(suite, test_trid_trtype_str);
1647 : 6 : CU_ADD_TEST(suite, test_trid_adrfam_str);
1648 : 6 : CU_ADD_TEST(suite, test_nvme_ctrlr_probe);
1649 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_probe);
1650 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_connect);
1651 : 6 : CU_ADD_TEST(suite, test_nvme_ctrlr_probe_internal);
1652 : 6 : CU_ADD_TEST(suite, test_nvme_init_controllers);
1653 : 6 : CU_ADD_TEST(suite, test_nvme_driver_init);
1654 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_detach);
1655 : 6 : CU_ADD_TEST(suite, test_nvme_completion_poll_cb);
1656 : 6 : CU_ADD_TEST(suite, test_nvme_user_copy_cmd_complete);
1657 : 6 : CU_ADD_TEST(suite, test_nvme_allocate_request_null);
1658 : 6 : CU_ADD_TEST(suite, test_nvme_allocate_request);
1659 : 6 : CU_ADD_TEST(suite, test_nvme_free_request);
1660 : 6 : CU_ADD_TEST(suite, test_nvme_allocate_request_user_copy);
1661 : 6 : CU_ADD_TEST(suite, test_nvme_robust_mutex_init_shared);
1662 : 6 : CU_ADD_TEST(suite, test_nvme_request_check_timeout);
1663 : 6 : CU_ADD_TEST(suite, test_nvme_wait_for_completion);
1664 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_parse_func);
1665 : 6 : CU_ADD_TEST(suite, test_spdk_nvme_detach_async);
1666 : 6 : CU_ADD_TEST(suite, test_nvme_parse_addr);
1667 : :
1668 : 6 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1669 : 6 : CU_cleanup_registry();
1670 : 6 : return num_failures;
1671 : : }
|