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