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