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