Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2015 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk_internal/cunit.h"
10 : :
11 : : #include "common/lib/test_env.c"
12 : :
13 : : pid_t g_spdk_nvme_pid;
14 : :
15 : : bool trace_flag = false;
16 : : #define SPDK_LOG_NVME trace_flag
17 : :
18 : : #include "nvme/nvme_qpair.c"
19 : :
20 : 4 : SPDK_LOG_REGISTER_COMPONENT(nvme)
21 : :
22 : : struct nvme_driver _g_nvme_driver = {
23 : : .lock = PTHREAD_MUTEX_INITIALIZER,
24 : : };
25 : :
26 : 4 : DEFINE_STUB_V(nvme_transport_qpair_abort_reqs, (struct spdk_nvme_qpair *qpair));
27 [ - + ]: 16 : DEFINE_STUB(nvme_transport_qpair_submit_request, int,
28 : : (struct spdk_nvme_qpair *qpair, struct nvme_request *req), 0);
29 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_ctrlr_free_io_qpair, int, (struct spdk_nvme_qpair *qpair), 0);
30 : 0 : DEFINE_STUB_V(nvme_transport_ctrlr_disconnect_qpair, (struct spdk_nvme_ctrlr *ctrlr,
31 : : struct spdk_nvme_qpair *qpair));
32 : 0 : DEFINE_STUB_V(nvme_ctrlr_disconnect_qpair, (struct spdk_nvme_qpair *qpair));
33 : :
34 : 0 : DEFINE_STUB_V(nvme_ctrlr_abort_queued_aborts, (struct spdk_nvme_ctrlr *ctrlr));
35 [ # # ]: 0 : DEFINE_STUB(nvme_ctrlr_reinitialize_io_qpair, int,
36 : : (struct spdk_nvme_ctrlr *ctrlr, struct spdk_nvme_qpair *qpair), 0);
37 : :
38 : : void
39 : 4 : nvme_ctrlr_fail(struct spdk_nvme_ctrlr *ctrlr, bool hot_remove)
40 : : {
41 [ - + ]: 4 : if (hot_remove) {
42 : 0 : ctrlr->is_removed = true;
43 : : }
44 : 4 : ctrlr->is_failed = true;
45 : 4 : }
46 : :
47 : : static bool g_called_transport_process_completions = false;
48 : : static int32_t g_transport_process_completions_rc = 0;
49 : : int32_t
50 : 20 : nvme_transport_qpair_process_completions(struct spdk_nvme_qpair *qpair, uint32_t max_completions)
51 : : {
52 : 20 : g_called_transport_process_completions = true;
53 : 20 : return g_transport_process_completions_rc;
54 : : }
55 : :
56 : : static void
57 : 20 : prepare_submit_request_test(struct spdk_nvme_qpair *qpair,
58 : : struct spdk_nvme_ctrlr *ctrlr)
59 : : {
60 [ - + ]: 20 : memset(ctrlr, 0, sizeof(*ctrlr));
61 : 20 : ctrlr->free_io_qids = NULL;
62 : 20 : TAILQ_INIT(&ctrlr->active_io_qpairs);
63 : 20 : TAILQ_INIT(&ctrlr->active_procs);
64 [ - - - + ]: 20 : MOCK_CLEAR(spdk_zmalloc);
65 : 20 : nvme_qpair_init(qpair, 1, ctrlr, 0, 32, false);
66 : 20 : }
67 : :
68 : : static void
69 : 20 : cleanup_submit_request_test(struct spdk_nvme_qpair *qpair)
70 : : {
71 : 20 : free(qpair->req_buf);
72 : 20 : }
73 : :
74 : : static void
75 : 0 : expected_success_callback(void *arg, const struct spdk_nvme_cpl *cpl)
76 : : {
77 [ # # # # ]: 0 : CU_ASSERT(!spdk_nvme_cpl_is_error(cpl));
78 : 0 : }
79 : :
80 : : static void
81 : 0 : expected_failure_callback(void *arg, const struct spdk_nvme_cpl *cpl)
82 : : {
83 [ # # # # ]: 0 : CU_ASSERT(spdk_nvme_cpl_is_error(cpl));
84 : 0 : }
85 : :
86 : : static void
87 : 4 : test3(void)
88 : : {
89 : 4 : struct spdk_nvme_qpair qpair = {};
90 : : struct nvme_request *req;
91 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
92 : :
93 : 4 : qpair.state = NVME_QPAIR_ENABLED;
94 : 4 : prepare_submit_request_test(&qpair, &ctrlr);
95 : :
96 : 4 : req = nvme_allocate_request_null(&qpair, expected_success_callback, NULL);
97 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(req != NULL);
98 : :
99 : 4 : CU_ASSERT(nvme_qpair_submit_request(&qpair, req) == 0);
100 : :
101 : 4 : nvme_free_request(req);
102 : :
103 : 4 : cleanup_submit_request_test(&qpair);
104 : 4 : }
105 : :
106 : : static void
107 : 4 : test_ctrlr_failed(void)
108 : : {
109 : 4 : struct spdk_nvme_qpair qpair = {};
110 : : struct nvme_request *req;
111 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
112 : 4 : char payload[4096];
113 : :
114 : 4 : prepare_submit_request_test(&qpair, &ctrlr);
115 : :
116 : 4 : req = nvme_allocate_request_contig(&qpair, payload, sizeof(payload), expected_failure_callback,
117 : : NULL);
118 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(req != NULL);
119 : :
120 : : /* Set the controller to failed.
121 : : * Set the controller to resetting so that the qpair won't get re-enabled.
122 : : */
123 : 4 : ctrlr.is_failed = true;
124 : 4 : ctrlr.is_resetting = true;
125 : :
126 : 4 : CU_ASSERT(nvme_qpair_submit_request(&qpair, req) != 0);
127 : :
128 : 4 : cleanup_submit_request_test(&qpair);
129 : 4 : }
130 : :
131 : : static void
132 : 4 : struct_packing(void)
133 : : {
134 : : /* ctrlr is the first field in nvme_qpair after the fields
135 : : * that are used in the I/O path. Make sure the I/O path fields
136 : : * all fit into two cache lines.
137 : : */
138 : 4 : CU_ASSERT(offsetof(struct spdk_nvme_qpair, ctrlr) <= 128);
139 : 4 : }
140 : :
141 : : static int g_num_cb_failed = 0;
142 : : static int g_num_cb_passed = 0;
143 : :
144 : : static void
145 : 12 : dummy_cb_fn(void *cb_arg, const struct spdk_nvme_cpl *cpl)
146 : : {
147 [ - + ]: 12 : if (cpl->status.sc == SPDK_NVME_SC_SUCCESS) {
148 : 0 : g_num_cb_passed++;
149 : : } else {
150 : 12 : g_num_cb_failed++;
151 : : }
152 : 12 : }
153 : :
154 : : static void
155 : 4 : test_nvme_qpair_process_completions(void)
156 : : {
157 : 4 : struct spdk_nvme_qpair admin_qp = {0};
158 : 4 : struct spdk_nvme_qpair qpair = {0};
159 : 4 : struct spdk_nvme_ctrlr ctrlr = {{0}};
160 : 4 : struct nvme_request dummy_1 = {{0}};
161 : 4 : struct nvme_request dummy_2 = {{0}};
162 : : int rc;
163 : :
164 : 4 : dummy_1.cb_fn = dummy_cb_fn;
165 : 4 : dummy_2.cb_fn = dummy_cb_fn;
166 : 4 : dummy_1.qpair = &qpair;
167 : 4 : dummy_2.qpair = &qpair;
168 : :
169 : 4 : TAILQ_INIT(&ctrlr.active_io_qpairs);
170 : 4 : TAILQ_INIT(&ctrlr.active_procs);
171 [ - + ]: 4 : CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
172 : 4 : nvme_qpair_init(&qpair, 1, &ctrlr, 0, 32, false);
173 : 4 : nvme_qpair_init(&admin_qp, 0, &ctrlr, 0, 32, false);
174 : :
175 : 4 : ctrlr.adminq = &admin_qp;
176 : :
177 : 4 : STAILQ_INIT(&qpair.queued_req);
178 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_1, stailq);
179 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_2, stailq);
180 : 4 : qpair.num_outstanding_reqs = 2;
181 : :
182 : : /* If the controller is failed, return -ENXIO */
183 : 4 : ctrlr.is_failed = true;
184 : 4 : ctrlr.is_removed = false;
185 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
186 : 4 : CU_ASSERT(rc == -ENXIO);
187 : 4 : CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
188 : 4 : CU_ASSERT(g_num_cb_passed == 0);
189 : 4 : CU_ASSERT(g_num_cb_failed == 0);
190 : 4 : CU_ASSERT(qpair.num_outstanding_reqs == 2);
191 : :
192 : : /* Same if the qpair is failed at the transport layer. */
193 : 4 : ctrlr.is_failed = false;
194 : 4 : ctrlr.is_removed = false;
195 : 4 : qpair.state = NVME_QPAIR_DISCONNECTED;
196 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
197 : 4 : CU_ASSERT(rc == -ENXIO);
198 : 4 : CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
199 : 4 : CU_ASSERT(g_num_cb_passed == 0);
200 : 4 : CU_ASSERT(g_num_cb_failed == 0);
201 : 4 : CU_ASSERT(qpair.num_outstanding_reqs == 2);
202 : :
203 : : /* If the controller is removed, make sure we abort the requests. */
204 : 4 : ctrlr.is_failed = true;
205 : 4 : ctrlr.is_removed = true;
206 : 4 : qpair.state = NVME_QPAIR_CONNECTED;
207 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
208 : 4 : CU_ASSERT(rc == -ENXIO);
209 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
210 : 4 : CU_ASSERT(g_num_cb_passed == 0);
211 : 4 : CU_ASSERT(g_num_cb_failed == 2);
212 : 4 : CU_ASSERT(qpair.num_outstanding_reqs == 0);
213 : :
214 : : /* If we are resetting, make sure that we don't call into the transport. */
215 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_1, stailq);
216 : 4 : dummy_1.queued = true;
217 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, &dummy_2, stailq);
218 : 4 : dummy_2.queued = true;
219 : 4 : g_num_cb_failed = 0;
220 : 4 : ctrlr.is_failed = false;
221 : 4 : ctrlr.is_removed = false;
222 : 4 : ctrlr.is_resetting = true;
223 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
224 : 4 : CU_ASSERT(rc == -ENXIO);
225 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == false);
226 : : /* We also need to make sure we didn't abort the requests. */
227 : 4 : CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
228 : 4 : CU_ASSERT(g_num_cb_passed == 0);
229 : 4 : CU_ASSERT(g_num_cb_failed == 0);
230 : :
231 : : /* The case where we aren't resetting, but are enabling the qpair is the same as above. */
232 : 4 : ctrlr.is_resetting = false;
233 : 4 : qpair.state = NVME_QPAIR_ENABLING;
234 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
235 : 4 : CU_ASSERT(rc == -ENXIO);
236 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == false);
237 : 4 : CU_ASSERT(!STAILQ_EMPTY(&qpair.queued_req));
238 : 4 : CU_ASSERT(g_num_cb_passed == 0);
239 : 4 : CU_ASSERT(g_num_cb_failed == 0);
240 : :
241 : : /* For other qpair states, we want to enable the qpair. */
242 : 4 : qpair.state = NVME_QPAIR_CONNECTED;
243 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 1);
244 : 4 : CU_ASSERT(rc == 0);
245 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == true);
246 : : /* These should have been submitted to the lower layer. */
247 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
248 : 4 : CU_ASSERT(g_num_cb_passed == 0);
249 : 4 : CU_ASSERT(g_num_cb_failed == 0);
250 : 4 : CU_ASSERT(nvme_qpair_get_state(&qpair) == NVME_QPAIR_ENABLED);
251 : :
252 : 4 : g_called_transport_process_completions = false;
253 : 4 : g_transport_process_completions_rc = -ENXIO;
254 : :
255 : : /* Fail the controller if we get an error from the transport on admin qpair. */
256 : 4 : admin_qp.state = NVME_QPAIR_ENABLED;
257 : 4 : rc = spdk_nvme_qpair_process_completions(&admin_qp, 0);
258 : 4 : CU_ASSERT(rc == -ENXIO);
259 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == true);
260 [ - + ]: 4 : CU_ASSERT(ctrlr.is_failed == true);
261 : :
262 : : /* Don't fail the controller for regular qpairs. */
263 : 4 : ctrlr.is_failed = false;
264 : 4 : g_called_transport_process_completions = false;
265 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
266 : 4 : CU_ASSERT(rc == -ENXIO);
267 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == true);
268 [ - + ]: 4 : CU_ASSERT(ctrlr.is_failed == false);
269 : :
270 : : /* Make sure we don't modify the return value from the transport. */
271 : 4 : ctrlr.is_failed = false;
272 : 4 : g_called_transport_process_completions = false;
273 : 4 : g_transport_process_completions_rc = 23;
274 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, 0);
275 : 4 : CU_ASSERT(rc == 23);
276 [ - + ]: 4 : CU_ASSERT(g_called_transport_process_completions == true);
277 [ - + ]: 4 : CU_ASSERT(ctrlr.is_failed == false);
278 : :
279 : 4 : free(qpair.req_buf);
280 : 4 : free(admin_qp.req_buf);
281 : 4 : }
282 : :
283 : : static void
284 : 4 : test_nvme_completion_is_retry(void)
285 : : {
286 : 4 : struct spdk_nvme_cpl cpl = {};
287 : :
288 : 4 : cpl.status.sct = SPDK_NVME_SCT_GENERIC;
289 : 4 : cpl.status.sc = SPDK_NVME_SC_NAMESPACE_NOT_READY;
290 : 4 : cpl.status.dnr = 0;
291 : 4 : CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
292 : :
293 : 4 : cpl.status.sc = SPDK_NVME_SC_FORMAT_IN_PROGRESS;
294 : 4 : cpl.status.dnr = 1;
295 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
296 : 4 : cpl.status.dnr = 0;
297 : 4 : CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
298 : :
299 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_OPCODE;
300 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
301 : :
302 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_FIELD;
303 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
304 : :
305 : 4 : cpl.status.sc = SPDK_NVME_SC_COMMAND_ID_CONFLICT;
306 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
307 : :
308 : 4 : cpl.status.sc = SPDK_NVME_SC_DATA_TRANSFER_ERROR;
309 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
310 : :
311 : 4 : cpl.status.sc = SPDK_NVME_SC_ABORTED_POWER_LOSS;
312 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
313 : :
314 : 4 : cpl.status.sc = SPDK_NVME_SC_INTERNAL_DEVICE_ERROR;
315 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
316 : :
317 : 4 : cpl.status.sc = SPDK_NVME_SC_ABORTED_BY_REQUEST;
318 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
319 : :
320 : 4 : cpl.status.sc = SPDK_NVME_SC_ABORTED_FAILED_FUSED;
321 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
322 : :
323 : 4 : cpl.status.sc = SPDK_NVME_SC_ABORTED_MISSING_FUSED;
324 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
325 : :
326 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_NAMESPACE_OR_FORMAT;
327 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
328 : :
329 : 4 : cpl.status.sc = SPDK_NVME_SC_COMMAND_SEQUENCE_ERROR;
330 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
331 : :
332 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_SGL_SEG_DESCRIPTOR;
333 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
334 : :
335 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_NUM_SGL_DESCIRPTORS;
336 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
337 : :
338 : 4 : cpl.status.sc = SPDK_NVME_SC_DATA_SGL_LENGTH_INVALID;
339 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
340 : :
341 : 4 : cpl.status.sc = SPDK_NVME_SC_METADATA_SGL_LENGTH_INVALID;
342 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
343 : :
344 : 4 : cpl.status.sc = SPDK_NVME_SC_SGL_DESCRIPTOR_TYPE_INVALID;
345 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
346 : :
347 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_CONTROLLER_MEM_BUF;
348 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
349 : :
350 : 4 : cpl.status.sc = SPDK_NVME_SC_INVALID_PRP_OFFSET;
351 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
352 : :
353 : 4 : cpl.status.sc = SPDK_NVME_SC_ATOMIC_WRITE_UNIT_EXCEEDED;
354 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
355 : :
356 : 4 : cpl.status.sc = SPDK_NVME_SC_LBA_OUT_OF_RANGE;
357 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
358 : :
359 : 4 : cpl.status.sc = SPDK_NVME_SC_CAPACITY_EXCEEDED;
360 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
361 : :
362 : 4 : cpl.status.sc = SPDK_NVME_SC_RESERVATION_CONFLICT;
363 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
364 : :
365 : 4 : cpl.status.sc = 0x70;
366 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
367 : :
368 : 4 : cpl.status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
369 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
370 : :
371 : 4 : cpl.status.sct = SPDK_NVME_SCT_MEDIA_ERROR;
372 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
373 : :
374 : 4 : cpl.status.sct = SPDK_NVME_SCT_PATH;
375 : 4 : cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR;
376 : 4 : cpl.status.dnr = 0;
377 : 4 : CU_ASSERT_TRUE(nvme_completion_is_retry(&cpl));
378 : :
379 : 4 : cpl.status.sct = SPDK_NVME_SCT_PATH;
380 : 4 : cpl.status.sc = SPDK_NVME_SC_INTERNAL_PATH_ERROR;
381 : 4 : cpl.status.dnr = 1;
382 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
383 : :
384 : 4 : cpl.status.sct = SPDK_NVME_SCT_VENDOR_SPECIFIC;
385 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
386 : :
387 : 4 : cpl.status.sct = 0x4;
388 : 4 : CU_ASSERT_FALSE(nvme_completion_is_retry(&cpl));
389 : 4 : }
390 : :
391 : : #ifdef DEBUG
392 : : static void
393 : 4 : test_get_status_string(void)
394 : : {
395 : : const char *status_string;
396 : 4 : struct spdk_nvme_status status;
397 : :
398 : 4 : status.sct = SPDK_NVME_SCT_GENERIC;
399 : 4 : status.sc = SPDK_NVME_SC_SUCCESS;
400 : 4 : status_string = spdk_nvme_cpl_get_status_string(&status);
401 [ - + ]: 4 : CU_ASSERT(strcmp(status_string, "SUCCESS") == 0);
402 : :
403 : 4 : status.sct = SPDK_NVME_SCT_COMMAND_SPECIFIC;
404 : 4 : status.sc = SPDK_NVME_SC_COMPLETION_QUEUE_INVALID;
405 : 4 : status_string = spdk_nvme_cpl_get_status_string(&status);
406 [ - + ]: 4 : CU_ASSERT(strcmp(status_string, "INVALID COMPLETION QUEUE") == 0);
407 : :
408 : 4 : status.sct = SPDK_NVME_SCT_MEDIA_ERROR;
409 : 4 : status.sc = SPDK_NVME_SC_UNRECOVERED_READ_ERROR;
410 : 4 : status_string = spdk_nvme_cpl_get_status_string(&status);
411 [ - + ]: 4 : CU_ASSERT(strcmp(status_string, "UNRECOVERED READ ERROR") == 0);
412 : :
413 : 4 : status.sct = SPDK_NVME_SCT_VENDOR_SPECIFIC;
414 : 4 : status.sc = 0;
415 : 4 : status_string = spdk_nvme_cpl_get_status_string(&status);
416 [ - + ]: 4 : CU_ASSERT(strcmp(status_string, "VENDOR SPECIFIC") == 0);
417 : :
418 : 4 : status.sct = 0x4;
419 : 4 : status.sc = 0;
420 : 4 : status_string = spdk_nvme_cpl_get_status_string(&status);
421 [ - + ]: 4 : CU_ASSERT(strcmp(status_string, "RESERVED") == 0);
422 : 4 : }
423 : : #endif
424 : :
425 : : static void
426 : 4 : test_nvme_qpair_add_cmd_error_injection(void)
427 : : {
428 : 4 : struct spdk_nvme_qpair qpair = {};
429 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
430 : 4 : pthread_mutexattr_t attr;
431 : : int rc;
432 : :
433 : 4 : prepare_submit_request_test(&qpair, &ctrlr);
434 : 4 : ctrlr.adminq = &qpair;
435 : :
436 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(pthread_mutexattr_init(&attr) == 0);
437 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE) == 0);
438 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(pthread_mutex_init(&ctrlr.ctrlr_lock, &attr) == 0);
439 : 4 : pthread_mutexattr_destroy(&attr);
440 : :
441 : : /* Admin error injection at submission path */
442 [ - - - + ]: 4 : MOCK_CLEAR(spdk_zmalloc);
443 : 4 : rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, NULL,
444 : : SPDK_NVME_OPC_GET_FEATURES, true, 5000, 1,
445 : : SPDK_NVME_SCT_GENERIC, SPDK_NVME_SC_INVALID_FIELD);
446 : :
447 : 4 : CU_ASSERT(rc == 0);
448 : 4 : CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
449 : :
450 : : /* Remove cmd error injection */
451 : 4 : spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, NULL, SPDK_NVME_OPC_GET_FEATURES);
452 : :
453 : 4 : CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
454 : :
455 : : /* IO error injection at completion path */
456 : 4 : rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
457 : : SPDK_NVME_OPC_READ, false, 0, 1,
458 : : SPDK_NVME_SCT_MEDIA_ERROR, SPDK_NVME_SC_UNRECOVERED_READ_ERROR);
459 : :
460 : 4 : CU_ASSERT(rc == 0);
461 : 4 : CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
462 : :
463 : : /* Provide the same opc, and check whether allocate a new entry */
464 : 4 : rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
465 : : SPDK_NVME_OPC_READ, false, 0, 1,
466 : : SPDK_NVME_SCT_MEDIA_ERROR, SPDK_NVME_SC_UNRECOVERED_READ_ERROR);
467 : :
468 : 4 : CU_ASSERT(rc == 0);
469 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(!TAILQ_EMPTY(&qpair.err_cmd_head));
470 : 4 : CU_ASSERT(TAILQ_NEXT(TAILQ_FIRST(&qpair.err_cmd_head), link) == NULL);
471 : :
472 : : /* Remove cmd error injection */
473 : 4 : spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, &qpair, SPDK_NVME_OPC_READ);
474 : :
475 : 4 : CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
476 : :
477 : 4 : rc = spdk_nvme_qpair_add_cmd_error_injection(&ctrlr, &qpair,
478 : : SPDK_NVME_OPC_COMPARE, true, 0, 5,
479 : : SPDK_NVME_SCT_GENERIC, SPDK_NVME_SC_COMPARE_FAILURE);
480 : :
481 : 4 : CU_ASSERT(rc == 0);
482 : 4 : CU_ASSERT(!TAILQ_EMPTY(&qpair.err_cmd_head));
483 : :
484 : : /* Remove cmd error injection */
485 : 4 : spdk_nvme_qpair_remove_cmd_error_injection(&ctrlr, &qpair, SPDK_NVME_OPC_COMPARE);
486 : :
487 : 4 : CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
488 : :
489 : 4 : pthread_mutex_destroy(&ctrlr.ctrlr_lock);
490 : 4 : cleanup_submit_request_test(&qpair);
491 : 4 : }
492 : :
493 : : static struct nvme_request *
494 : 8 : allocate_request_tree(struct spdk_nvme_qpair *qpair)
495 : : {
496 : : struct nvme_request *req, *req1, *req2, *req3, *req2_1, *req2_2, *req2_3;
497 : :
498 : : /*
499 : : * Build a request chain like the following:
500 : : * req
501 : : * |
502 : : * ---------------
503 : : * | | |
504 : : * req1 req2 req3
505 : : * |
506 : : * ---------------
507 : : * | | |
508 : : * req2_1 req2_2 req2_3
509 : : */
510 : 8 : req = nvme_allocate_request_null(qpair, NULL, NULL);
511 : 8 : CU_ASSERT(req != NULL);
512 : 8 : TAILQ_INIT(&req->children);
513 : :
514 : 8 : req1 = nvme_allocate_request_null(qpair, NULL, NULL);
515 : 8 : CU_ASSERT(req1 != NULL);
516 : 8 : req->num_children++;
517 : 8 : TAILQ_INSERT_TAIL(&req->children, req1, child_tailq);
518 : 8 : req1->parent = req;
519 : :
520 : 8 : req2 = nvme_allocate_request_null(qpair, NULL, NULL);
521 : 8 : CU_ASSERT(req2 != NULL);
522 : 8 : TAILQ_INIT(&req2->children);
523 : 8 : req->num_children++;
524 : 8 : TAILQ_INSERT_TAIL(&req->children, req2, child_tailq);
525 : 8 : req2->parent = req;
526 : :
527 : 8 : req3 = nvme_allocate_request_null(qpair, NULL, NULL);
528 : 8 : CU_ASSERT(req3 != NULL);
529 : 8 : req->num_children++;
530 : 8 : TAILQ_INSERT_TAIL(&req->children, req3, child_tailq);
531 : 8 : req3->parent = req;
532 : :
533 : 8 : req2_1 = nvme_allocate_request_null(qpair, NULL, NULL);
534 : 8 : CU_ASSERT(req2_1 != NULL);
535 : 8 : req2->num_children++;
536 : 8 : TAILQ_INSERT_TAIL(&req2->children, req2_1, child_tailq);
537 : 8 : req2_1->parent = req2;
538 : :
539 : 8 : req2_2 = nvme_allocate_request_null(qpair, NULL, NULL);
540 : 8 : CU_ASSERT(req2_2 != NULL);
541 : 8 : req2->num_children++;
542 : 8 : TAILQ_INSERT_TAIL(&req2->children, req2_2, child_tailq);
543 : 8 : req2_2->parent = req2;
544 : :
545 : 8 : req2_3 = nvme_allocate_request_null(qpair, NULL, NULL);
546 : 8 : CU_ASSERT(req2_3 != NULL);
547 : 8 : req2->num_children++;
548 : 8 : TAILQ_INSERT_TAIL(&req2->children, req2_3, child_tailq);
549 : 8 : req2_3->parent = req2;
550 : :
551 : 8 : return req;
552 : : }
553 : :
554 : : static void
555 : 4 : test_nvme_qpair_submit_request(void)
556 : : {
557 : : int rc;
558 : 4 : struct spdk_nvme_qpair qpair = {};
559 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
560 : : struct nvme_request *req;
561 : :
562 : 4 : prepare_submit_request_test(&qpair, &ctrlr);
563 : :
564 : 4 : req = allocate_request_tree(&qpair);
565 : 4 : ctrlr.is_failed = true;
566 : 4 : rc = nvme_qpair_submit_request(&qpair, req);
567 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == -ENXIO);
568 : :
569 : 4 : req = allocate_request_tree(&qpair);
570 : 4 : ctrlr.is_failed = false;
571 : 4 : qpair.state = NVME_QPAIR_DISCONNECTING;
572 : 4 : rc = nvme_qpair_submit_request(&qpair, req);
573 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(rc == -ENXIO);
574 : :
575 : 4 : cleanup_submit_request_test(&qpair);
576 : 4 : }
577 : :
578 : : static void
579 : 4 : test_nvme_qpair_resubmit_request_with_transport_failed(void)
580 : : {
581 : : int rc;
582 : 4 : struct spdk_nvme_qpair qpair = {};
583 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
584 : : struct nvme_request *req;
585 : :
586 : 4 : prepare_submit_request_test(&qpair, &ctrlr);
587 : :
588 : 4 : req = nvme_allocate_request_null(&qpair, dummy_cb_fn, NULL);
589 : 4 : CU_ASSERT(req != NULL);
590 : 4 : TAILQ_INIT(&req->children);
591 : :
592 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, req, stailq);
593 : 4 : req->queued = true;
594 : :
595 : 4 : g_transport_process_completions_rc = 1;
596 : 4 : qpair.state = NVME_QPAIR_ENABLED;
597 : 4 : g_num_cb_failed = 0;
598 : 4 : MOCK_SET(nvme_transport_qpair_submit_request, -EINVAL);
599 : 4 : rc = spdk_nvme_qpair_process_completions(&qpair, g_transport_process_completions_rc);
600 [ - - - + ]: 4 : MOCK_CLEAR(nvme_transport_qpair_submit_request);
601 : 4 : CU_ASSERT(rc == g_transport_process_completions_rc);
602 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
603 : 4 : CU_ASSERT(g_num_cb_failed == 1);
604 : :
605 : 4 : cleanup_submit_request_test(&qpair);
606 : 4 : }
607 : :
608 : : static void
609 : 4 : ut_spdk_nvme_cmd_cb(void *cb_arg, const struct spdk_nvme_cpl *cpl)
610 : : {
611 : 4 : CU_ASSERT(cb_arg == (void *)0xDEADBEEF);
612 : 4 : CU_ASSERT(cpl->sqid == 1);
613 : 4 : CU_ASSERT(cpl->status.sct == SPDK_NVME_SCT_GENERIC);
614 : 4 : CU_ASSERT(cpl->status.sc == SPDK_NVME_SC_SUCCESS);
615 : 4 : CU_ASSERT(cpl->status.dnr == 1);
616 : 4 : }
617 : :
618 : : static void
619 : 4 : test_nvme_qpair_manual_complete_request(void)
620 : : {
621 : 4 : struct spdk_nvme_qpair qpair = {};
622 : 4 : struct nvme_request req = {};
623 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
624 : :
625 : 4 : qpair.ctrlr = &ctrlr;
626 : 4 : qpair.id = 1;
627 : 4 : req.cb_fn = ut_spdk_nvme_cmd_cb;
628 : 4 : req.cb_arg = (void *) 0xDEADBEEF;
629 : 4 : req.qpair = &qpair;
630 : 4 : req.num_children = 0;
631 : 4 : qpair.ctrlr->opts.disable_error_logging = false;
632 : 4 : STAILQ_INIT(&qpair.free_req);
633 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&qpair.free_req));
634 : 4 : qpair.num_outstanding_reqs = 1;
635 : :
636 : 4 : nvme_qpair_manual_complete_request(&qpair, &req, SPDK_NVME_SCT_GENERIC,
637 : : SPDK_NVME_SC_SUCCESS, 1, true);
638 : 4 : CU_ASSERT(!STAILQ_EMPTY(&qpair.free_req));
639 : 4 : CU_ASSERT(qpair.num_outstanding_reqs == 0);
640 : 4 : }
641 : :
642 : : static void
643 : 12 : ut_spdk_nvme_cmd_cb_empty(void *cb_arg, const struct spdk_nvme_cpl *cpl)
644 : : {
645 : :
646 : 12 : }
647 : :
648 : : static void
649 : 4 : test_nvme_qpair_init_deinit(void)
650 : : {
651 : 4 : struct spdk_nvme_qpair qpair = {};
652 : 4 : struct nvme_request *reqs[3] = {};
653 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
654 : 4 : struct nvme_error_cmd *cmd = NULL;
655 : 4 : struct nvme_request *var_req = NULL;
656 : 4 : int rc, i = 0;
657 : :
658 : 4 : ctrlr.trid.trtype = SPDK_NVME_TRANSPORT_PCIE;
659 : :
660 : 4 : rc = nvme_qpair_init(&qpair, 1, &ctrlr, SPDK_NVME_QPRIO_HIGH, 3, false);
661 : 4 : CU_ASSERT(rc == 0);
662 : 4 : CU_ASSERT(qpair.id == 1);
663 : 4 : CU_ASSERT(qpair.qprio == SPDK_NVME_QPRIO_HIGH);
664 : 4 : CU_ASSERT(qpair.in_completion_context == 0);
665 : 4 : CU_ASSERT(qpair.delete_after_completion_context == 0);
666 : 4 : CU_ASSERT(qpair.no_deletion_notification_needed == 0);
667 : 4 : CU_ASSERT(qpair.ctrlr == &ctrlr);
668 : 4 : CU_ASSERT(qpair.trtype == SPDK_NVME_TRANSPORT_PCIE);
669 : 4 : CU_ASSERT(qpair.req_buf != NULL);
670 : :
671 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(!STAILQ_EMPTY(&qpair.free_req));
672 [ + + ]: 16 : STAILQ_FOREACH(var_req, &qpair.free_req, stailq) {
673 : : /* Check requests address alignment */
674 : 12 : CU_ASSERT((uint64_t)var_req % 64 == 0);
675 : 12 : CU_ASSERT(var_req->qpair == &qpair);
676 : 12 : reqs[i++] = var_req;
677 : : }
678 : 4 : CU_ASSERT(i == 3);
679 : :
680 : : /* Allocate cmd memory for deinit using */
681 : 4 : cmd = spdk_zmalloc(sizeof(*cmd), 64, NULL, SPDK_ENV_SOCKET_ID_ANY, SPDK_MALLOC_SHARE);
682 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(cmd != NULL);
683 : 4 : TAILQ_INSERT_TAIL(&qpair.err_cmd_head, cmd, link);
684 [ + + ]: 16 : for (int i = 0; i < 3; i++) {
685 : 12 : reqs[i]->cb_fn = ut_spdk_nvme_cmd_cb_empty;
686 : 12 : reqs[i]->cb_arg = (void *) 0xDEADBEEF;
687 : 12 : reqs[i]->num_children = 0;
688 : : }
689 : :
690 : : /* Emulate requests into various type queues */
691 [ + - - + : 4 : STAILQ_REMOVE(&qpair.free_req, reqs[0], nvme_request, stailq);
- - - - ]
692 : 4 : STAILQ_INSERT_TAIL(&qpair.queued_req, reqs[0], stailq);
693 [ + - - + : 4 : STAILQ_REMOVE(&qpair.free_req, reqs[1], nvme_request, stailq);
- - - - ]
694 : 4 : STAILQ_INSERT_TAIL(&qpair.aborting_queued_req, reqs[1], stailq);
695 [ + - + - : 4 : STAILQ_REMOVE(&qpair.free_req, reqs[2], nvme_request, stailq);
- - - - ]
696 : 4 : STAILQ_INSERT_TAIL(&qpair.err_req_head, reqs[2], stailq);
697 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.free_req));
698 : 4 : qpair.num_outstanding_reqs = 3;
699 : :
700 : 4 : nvme_qpair_deinit(&qpair);
701 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.queued_req));
702 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.aborting_queued_req));
703 : 4 : CU_ASSERT(STAILQ_EMPTY(&qpair.err_req_head));
704 : 4 : CU_ASSERT(TAILQ_EMPTY(&qpair.err_cmd_head));
705 : 4 : CU_ASSERT(qpair.num_outstanding_reqs == 0);
706 : 4 : }
707 : :
708 : : static void
709 : 4 : test_nvme_get_sgl_print_info(void)
710 : : {
711 : 4 : char buf[NVME_CMD_DPTR_STR_SIZE] = {};
712 : 4 : struct spdk_nvme_cmd cmd = {};
713 : :
714 : 4 : cmd.dptr.sgl1.keyed.length = 0x1000;
715 : 4 : cmd.dptr.sgl1.keyed.key = 0xababccdd;
716 : :
717 : 4 : nvme_get_sgl_keyed(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
718 : 4 : CU_ASSERT(!strncmp(buf, " len:0x1000 key:0xababccdd", NVME_CMD_DPTR_STR_SIZE));
719 : :
720 : 4 : memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
721 : 4 : cmd.dptr.sgl1.unkeyed.length = 0x1000;
722 : :
723 : 4 : nvme_get_sgl_unkeyed(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
724 : 4 : CU_ASSERT(!strncmp(buf, " len:0x1000", NVME_CMD_DPTR_STR_SIZE));
725 : :
726 : 4 : memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
727 : 4 : cmd.dptr.sgl1.generic.type = SPDK_NVME_SGL_TYPE_DATA_BLOCK;
728 : 4 : cmd.dptr.sgl1.generic.subtype = 0;
729 : 4 : cmd.dptr.sgl1.address = 0xdeadbeef;
730 : 4 : cmd.dptr.sgl1.unkeyed.length = 0x1000;
731 : :
732 : 4 : nvme_get_sgl(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
733 : 4 : CU_ASSERT(!strncmp(buf, "SGL DATA BLOCK ADDRESS 0xdeadbeef len:0x1000",
734 : : NVME_CMD_DPTR_STR_SIZE));
735 : :
736 : 4 : memset(&cmd.dptr.sgl1, 0, sizeof(cmd.dptr.sgl1));
737 : 4 : cmd.dptr.sgl1.generic.type = SPDK_NVME_SGL_TYPE_KEYED_DATA_BLOCK;
738 : 4 : cmd.dptr.sgl1.generic.subtype = 0;
739 : 4 : cmd.dptr.sgl1.address = 0xdeadbeef;
740 : 4 : cmd.dptr.sgl1.keyed.length = 0x1000;
741 : 4 : cmd.dptr.sgl1.keyed.key = 0xababccdd;
742 : :
743 : 4 : nvme_get_sgl(buf, NVME_CMD_DPTR_STR_SIZE, &cmd);
744 : 4 : CU_ASSERT(!strncmp(buf, "SGL KEYED DATA BLOCK ADDRESS 0xdeadbeef len:0x1000 key:0xababccdd",
745 : : NVME_CMD_DPTR_STR_SIZE));
746 : 4 : }
747 : :
748 : : int
749 : 4 : main(int argc, char **argv)
750 : : {
751 : 4 : CU_pSuite suite = NULL;
752 : : unsigned int num_failures;
753 : :
754 : 4 : CU_initialize_registry();
755 : :
756 : 4 : suite = CU_add_suite("nvme_qpair", NULL, NULL);
757 : :
758 : 4 : CU_ADD_TEST(suite, test3);
759 : 4 : CU_ADD_TEST(suite, test_ctrlr_failed);
760 : 4 : CU_ADD_TEST(suite, struct_packing);
761 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_process_completions);
762 : 4 : CU_ADD_TEST(suite, test_nvme_completion_is_retry);
763 : : #ifdef DEBUG
764 : 4 : CU_ADD_TEST(suite, test_get_status_string);
765 : : #endif
766 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_add_cmd_error_injection);
767 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_submit_request);
768 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_resubmit_request_with_transport_failed);
769 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_manual_complete_request);
770 : 4 : CU_ADD_TEST(suite, test_nvme_qpair_init_deinit);
771 : 4 : CU_ADD_TEST(suite, test_nvme_get_sgl_print_info);
772 : :
773 : 4 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
774 : 4 : CU_cleanup_registry();
775 : 4 : return num_failures;
776 : : }
|