Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright (C) 2015 Intel Corporation. All rights reserved.
4 : : * Copyright (c) 2021 Mellanox Technologies LTD. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk_internal/cunit.h"
8 : :
9 : : #include "nvme/nvme_ctrlr_cmd.c"
10 : :
11 : : #include "spdk_internal/mock.h"
12 : :
13 : : #define CTRLR_CDATA_ELPE 5
14 : :
15 : : pid_t g_spdk_nvme_pid;
16 : :
17 : : struct nvme_request g_req;
18 : :
19 : : uint32_t error_num_entries;
20 : : uint32_t health_log_nsid = 1;
21 : : uint8_t feature = 1;
22 : : uint32_t feature_cdw11 = 1;
23 : : uint32_t feature_cdw12 = 1;
24 : : uint8_t get_feature = 1;
25 : : uint32_t get_feature_cdw11 = 1;
26 : : uint32_t fw_img_size = 1024;
27 : : uint32_t fw_img_offset = 0;
28 : : uint16_t abort_cid = 1;
29 : : uint16_t abort_sqid = 1;
30 : : uint32_t namespace_management_nsid = 1;
31 : : uint64_t PRP_ENTRY_1 = 4096;
32 : : uint64_t PRP_ENTRY_2 = 4096;
33 : : uint32_t format_nvme_nsid = 1;
34 : : uint32_t sanitize_nvme_nsid = 1;
35 : : uint32_t expected_host_id_size = 0xFF;
36 : : uint32_t directive_nsid = 1;
37 : :
38 : : uint32_t expected_feature_ns = 2;
39 : : uint32_t expected_feature_cdw10 = SPDK_NVME_FEAT_LBA_RANGE_TYPE;
40 : : uint32_t expected_feature_cdw11 = 1;
41 : : uint32_t expected_feature_cdw12 = 1;
42 : :
43 : : typedef void (*verify_request_fn_t)(struct nvme_request *req);
44 : : verify_request_fn_t verify_fn;
45 : :
46 [ # # ]: 0 : DEFINE_STUB(nvme_transport_qpair_iterate_requests, int,
47 : : (struct spdk_nvme_qpair *qpair,
48 : : int (*iter_fn)(struct nvme_request *req, void *arg),
49 : : void *arg), 0);
50 : :
51 [ # # ]: 0 : DEFINE_STUB(nvme_qpair_abort_queued_reqs_with_cbarg, uint32_t,
52 : : (struct spdk_nvme_qpair *qpair, void *cmd_cb_arg), 0);
53 : :
54 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_ctrlr_get_admin_qp_failure_reason, spdk_nvme_qp_failure_reason,
55 : : (struct spdk_nvme_ctrlr *ctrlr), 0);
56 : :
57 : : static int
58 : 0 : nvme_ns_cmp(struct spdk_nvme_ns *ns1, struct spdk_nvme_ns *ns2)
59 : : {
60 : 0 : return ns1->id - ns2->id;
61 : : }
62 : :
63 [ # # # # : 0 : RB_GENERATE_STATIC(nvme_ns_tree, spdk_nvme_ns, node, nvme_ns_cmp);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
64 : :
65 : : static void
66 : 5 : verify_firmware_log_page(struct nvme_request *req)
67 : : {
68 : : uint32_t temp_cdw10;
69 : :
70 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
71 : 5 : CU_ASSERT(req->cmd.nsid == SPDK_NVME_GLOBAL_NS_TAG);
72 : :
73 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_firmware_page) / sizeof(uint32_t) - 1) << 16) |
74 : : SPDK_NVME_LOG_FIRMWARE_SLOT;
75 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
76 : 5 : }
77 : :
78 : : static void
79 : 5 : verify_health_log_page(struct nvme_request *req)
80 : : {
81 : : uint32_t temp_cdw10;
82 : :
83 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
84 : 5 : CU_ASSERT(req->cmd.nsid == health_log_nsid);
85 : :
86 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_health_information_page) / sizeof(uint32_t) - 1) << 16) |
87 : : SPDK_NVME_LOG_HEALTH_INFORMATION;
88 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
89 : 5 : }
90 : :
91 : : static void
92 : 5 : verify_error_log_page(struct nvme_request *req)
93 : : {
94 : : uint32_t temp_cdw10;
95 : :
96 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
97 : 5 : CU_ASSERT(req->cmd.nsid == SPDK_NVME_GLOBAL_NS_TAG);
98 : :
99 : 5 : temp_cdw10 = (((sizeof(struct spdk_nvme_error_information_entry) * error_num_entries) /
100 : 5 : sizeof(uint32_t) - 1) << 16) | SPDK_NVME_LOG_ERROR;
101 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
102 : 5 : }
103 : :
104 : : static void
105 : 5 : verify_set_feature_cmd(struct nvme_request *req)
106 : : {
107 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SET_FEATURES);
108 : 5 : CU_ASSERT(req->cmd.cdw10 == feature);
109 : 5 : CU_ASSERT(req->cmd.cdw11 == feature_cdw11);
110 : 5 : CU_ASSERT(req->cmd.cdw12 == feature_cdw12);
111 : 5 : }
112 : :
113 : : static void
114 : 5 : verify_set_feature_ns_cmd(struct nvme_request *req)
115 : : {
116 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SET_FEATURES);
117 : 5 : CU_ASSERT(req->cmd.cdw10 == expected_feature_cdw10);
118 : 5 : CU_ASSERT(req->cmd.cdw11 == expected_feature_cdw11);
119 : 5 : CU_ASSERT(req->cmd.cdw12 == expected_feature_cdw12);
120 : 5 : CU_ASSERT(req->cmd.nsid == expected_feature_ns);
121 : 5 : }
122 : :
123 : : static void
124 : 5 : verify_get_feature_cmd(struct nvme_request *req)
125 : : {
126 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_FEATURES);
127 : 5 : CU_ASSERT(req->cmd.cdw10 == get_feature);
128 : 5 : CU_ASSERT(req->cmd.cdw11 == get_feature_cdw11);
129 : 5 : }
130 : :
131 : : static void
132 : 5 : verify_get_feature_ns_cmd(struct nvme_request *req)
133 : : {
134 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_FEATURES);
135 : 5 : CU_ASSERT(req->cmd.cdw10 == expected_feature_cdw10);
136 : 5 : CU_ASSERT(req->cmd.cdw11 == expected_feature_cdw11);
137 : 5 : CU_ASSERT(req->cmd.nsid == expected_feature_ns);
138 : 5 : }
139 : :
140 : : static void
141 : 5 : verify_abort_cmd(struct nvme_request *req)
142 : : {
143 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_ABORT);
144 : 5 : CU_ASSERT(req->cmd.cdw10 == (((uint32_t)abort_cid << 16) | abort_sqid));
145 : 5 : }
146 : :
147 : : static void
148 : 0 : verify_io_cmd_raw_no_payload_build(struct nvme_request *req)
149 : : {
150 : 0 : struct spdk_nvme_cmd command = {};
151 : 0 : struct nvme_payload payload = {};
152 : :
153 [ # # ]: 0 : CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
154 [ # # ]: 0 : CU_ASSERT(memcmp(&req->payload, &payload, sizeof(req->payload)) == 0);
155 : 0 : }
156 : :
157 : : static void
158 : 0 : verify_io_raw_cmd(struct nvme_request *req)
159 : : {
160 : 0 : struct spdk_nvme_cmd command = {};
161 : :
162 [ # # ]: 0 : CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
163 : 0 : }
164 : :
165 : : static void
166 : 0 : verify_io_raw_cmd_with_md(struct nvme_request *req)
167 : : {
168 : 0 : struct spdk_nvme_cmd command = {};
169 : :
170 [ # # ]: 0 : CU_ASSERT(memcmp(&req->cmd, &command, sizeof(req->cmd)) == 0);
171 : 0 : }
172 : :
173 : : static void
174 : 10 : verify_set_host_id_cmd(struct nvme_request *req)
175 : : {
176 [ + + - ]: 10 : switch (expected_host_id_size) {
177 : 5 : case 8:
178 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_FEAT_HOST_IDENTIFIER);
179 : 5 : CU_ASSERT(req->cmd.cdw11 == 0);
180 : 5 : CU_ASSERT(req->cmd.cdw12 == 0);
181 : 5 : break;
182 : 5 : case 16:
183 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_FEAT_HOST_IDENTIFIER);
184 : 5 : CU_ASSERT(req->cmd.cdw11 == 1);
185 : 5 : CU_ASSERT(req->cmd.cdw12 == 0);
186 : 5 : break;
187 : 0 : default:
188 : 0 : CU_ASSERT(0);
189 : : }
190 : 10 : }
191 : :
192 : : static void
193 : 5 : verify_intel_smart_log_page(struct nvme_request *req)
194 : : {
195 : : uint32_t temp_cdw10;
196 : :
197 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
198 : 5 : CU_ASSERT(req->cmd.nsid == health_log_nsid);
199 : :
200 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_smart_information_page) /
201 : : sizeof(uint32_t) - 1) << 16) |
202 : : SPDK_NVME_INTEL_LOG_SMART;
203 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
204 : 5 : }
205 : :
206 : : static void
207 : 5 : verify_intel_temperature_log_page(struct nvme_request *req)
208 : : {
209 : : uint32_t temp_cdw10;
210 : :
211 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
212 : :
213 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_temperature_page) / sizeof(uint32_t) - 1) << 16) |
214 : : SPDK_NVME_INTEL_LOG_TEMPERATURE;
215 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
216 : 5 : }
217 : :
218 : : static void
219 : 5 : verify_intel_read_latency_log_page(struct nvme_request *req)
220 : : {
221 : : uint32_t temp_cdw10;
222 : :
223 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
224 : :
225 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_rw_latency_page) / sizeof(uint32_t) - 1) << 16) |
226 : : SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY;
227 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
228 : 5 : }
229 : :
230 : : static void
231 : 5 : verify_intel_write_latency_log_page(struct nvme_request *req)
232 : : {
233 : : uint32_t temp_cdw10;
234 : :
235 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
236 : :
237 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_rw_latency_page) / sizeof(uint32_t) - 1) << 16) |
238 : : SPDK_NVME_INTEL_LOG_WRITE_CMD_LATENCY;
239 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
240 : 5 : }
241 : :
242 : : static void
243 : 5 : verify_intel_get_log_page_directory(struct nvme_request *req)
244 : : {
245 : : uint32_t temp_cdw10;
246 : :
247 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
248 : :
249 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_log_page_directory) / sizeof(uint32_t) - 1) << 16) |
250 : : SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY;
251 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
252 : 5 : }
253 : :
254 : : static void
255 : 5 : verify_intel_marketing_description_log_page(struct nvme_request *req)
256 : : {
257 : : uint32_t temp_cdw10;
258 : :
259 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_GET_LOG_PAGE);
260 : :
261 : 5 : temp_cdw10 = ((sizeof(struct spdk_nvme_intel_marketing_description_page) / sizeof(
262 : : uint32_t) - 1) << 16) |
263 : : SPDK_NVME_INTEL_MARKETING_DESCRIPTION;
264 : 5 : CU_ASSERT(req->cmd.cdw10 == temp_cdw10);
265 : 5 : }
266 : :
267 : : static void
268 : 5 : verify_namespace_attach(struct nvme_request *req)
269 : : {
270 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_ATTACHMENT);
271 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_CTRLR_ATTACH);
272 : 5 : CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
273 : 5 : }
274 : :
275 : : static void
276 : 5 : verify_namespace_detach(struct nvme_request *req)
277 : : {
278 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_ATTACHMENT);
279 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_CTRLR_DETACH);
280 : 5 : CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
281 : 5 : }
282 : :
283 : : static void
284 : 5 : verify_namespace_create(struct nvme_request *req)
285 : : {
286 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_MANAGEMENT);
287 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_MANAGEMENT_CREATE);
288 : 5 : CU_ASSERT(req->cmd.nsid == 0);
289 : 5 : }
290 : :
291 : : static void
292 : 5 : verify_namespace_delete(struct nvme_request *req)
293 : : {
294 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_NS_MANAGEMENT);
295 : 5 : CU_ASSERT(req->cmd.cdw10 == SPDK_NVME_NS_MANAGEMENT_DELETE);
296 : 5 : CU_ASSERT(req->cmd.nsid == namespace_management_nsid);
297 : 5 : }
298 : :
299 : : static void
300 : 5 : verify_doorbell_buffer_config(struct nvme_request *req)
301 : : {
302 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DOORBELL_BUFFER_CONFIG);
303 : 5 : CU_ASSERT(req->cmd.dptr.prp.prp1 == PRP_ENTRY_1);
304 : 5 : CU_ASSERT(req->cmd.dptr.prp.prp2 == PRP_ENTRY_2);
305 : 5 : }
306 : :
307 : : static void
308 : 5 : verify_format_nvme(struct nvme_request *req)
309 : : {
310 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FORMAT_NVM);
311 : 5 : CU_ASSERT(req->cmd.cdw10 == 0);
312 : 5 : CU_ASSERT(req->cmd.nsid == format_nvme_nsid);
313 : 5 : }
314 : :
315 : : static void
316 : 5 : verify_fw_commit(struct nvme_request *req)
317 : : {
318 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FIRMWARE_COMMIT);
319 : 5 : CU_ASSERT(req->cmd.cdw10 == 0x09);
320 : 5 : }
321 : :
322 : : static void
323 : 5 : verify_fw_image_download(struct nvme_request *req)
324 : : {
325 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_FIRMWARE_IMAGE_DOWNLOAD);
326 : 5 : CU_ASSERT(req->cmd.cdw10 == spdk_nvme_bytes_to_numd(fw_img_size));
327 : 5 : CU_ASSERT(req->cmd.cdw11 == fw_img_offset >> 2);
328 : 5 : }
329 : :
330 : : static void
331 : 5 : verify_nvme_sanitize(struct nvme_request *req)
332 : : {
333 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_SANITIZE);
334 : 5 : CU_ASSERT(req->cmd.cdw10 == 0x309);
335 : 5 : CU_ASSERT(req->cmd.cdw11 == 0);
336 : 5 : CU_ASSERT(req->cmd.nsid == sanitize_nvme_nsid);
337 : 5 : }
338 : :
339 : : static void
340 : 5 : verify_directive_receive(struct nvme_request *req)
341 : : {
342 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DIRECTIVE_RECEIVE);
343 : 5 : CU_ASSERT(req->cmd.nsid == directive_nsid);
344 : 5 : }
345 : :
346 : : static void
347 : 5 : verify_directive_send(struct nvme_request *req)
348 : : {
349 : 5 : CU_ASSERT(req->cmd.opc == SPDK_NVME_OPC_DIRECTIVE_SEND);
350 : 5 : CU_ASSERT(req->cmd.nsid == directive_nsid);
351 : 5 : }
352 : :
353 : : struct nvme_request *
354 : 130 : nvme_allocate_request_user_copy(struct spdk_nvme_qpair *qpair, void *buffer, uint32_t payload_size,
355 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg, bool host_to_controller)
356 : : {
357 : : /* For the unit test, we don't actually need to copy the buffer */
358 : 130 : return nvme_allocate_request_contig(qpair, buffer, payload_size, cb_fn, cb_arg);
359 : : }
360 : :
361 : : int
362 : 0 : nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req)
363 : : {
364 : 0 : verify_fn(req);
365 : : /* stop analyzer from thinking stack variable addresses are stored in a global */
366 [ # # ]: 0 : memset(req, 0, sizeof(*req));
367 : :
368 : 0 : return 0;
369 : : }
370 : :
371 [ # # ]: 0 : DEFINE_RETURN_MOCK(nvme_ctrlr_submit_admin_request, int);
372 : : int
373 : 155 : nvme_ctrlr_submit_admin_request(struct spdk_nvme_ctrlr *ctrlr, struct nvme_request *req)
374 : : {
375 [ - + + + : 155 : HANDLE_RETURN_MOCK(nvme_ctrlr_submit_admin_request);
+ + ]
376 : 135 : verify_fn(req);
377 : : /* stop analyzer from thinking stack variable addresses are stored in a global */
378 [ - + ]: 135 : memset(req, 0, sizeof(*req));
379 : :
380 : 135 : return 0;
381 : : }
382 : :
383 : : static struct spdk_nvme_ns g_inactive_ns = {};
384 : :
385 : : struct spdk_nvme_ns *
386 : 0 : spdk_nvme_ctrlr_get_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
387 : : {
388 : 0 : struct spdk_nvme_ns tmp;
389 : : struct spdk_nvme_ns *ns;
390 : :
391 [ # # # # ]: 0 : if (nsid < 1 || nsid > ctrlr->cdata.nn) {
392 : 0 : return NULL;
393 : : }
394 : :
395 : 0 : tmp.id = nsid;
396 : 0 : ns = RB_FIND(nvme_ns_tree, &ctrlr->ns, &tmp);
397 : :
398 [ # # ]: 0 : if (ns == NULL) {
399 : 0 : return &g_inactive_ns;
400 : : }
401 : :
402 : 0 : return ns;
403 : : }
404 : :
405 : : #define DECLARE_AND_CONSTRUCT_CTRLR() \
406 : : struct spdk_nvme_ctrlr ctrlr = {}; \
407 : : struct spdk_nvme_qpair adminq = {}; \
408 : : struct nvme_request req; \
409 : : \
410 : : STAILQ_INIT(&adminq.free_req); \
411 : : STAILQ_INSERT_HEAD(&adminq.free_req, &req, stailq); \
412 : : ctrlr.adminq = &adminq; \
413 : : CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
414 : :
415 : : #define DECONSTRUCT_CTRLR() \
416 : : CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0);
417 : :
418 : : static void
419 : 5 : test_firmware_get_log_page(void)
420 : : {
421 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
422 : 5 : struct spdk_nvme_firmware_page payload = {};
423 : :
424 : 5 : verify_fn = verify_firmware_log_page;
425 : :
426 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_FIRMWARE_SLOT, SPDK_NVME_GLOBAL_NS_TAG,
427 : : &payload,
428 : : sizeof(payload), 0, NULL, NULL);
429 : :
430 [ - + ]: 5 : DECONSTRUCT_CTRLR();
431 : 5 : }
432 : :
433 : : static void
434 : 5 : test_health_get_log_page(void)
435 : : {
436 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
437 : 5 : struct spdk_nvme_health_information_page payload = {};
438 : :
439 : 5 : verify_fn = verify_health_log_page;
440 : :
441 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_HEALTH_INFORMATION, health_log_nsid,
442 : : &payload,
443 : : sizeof(payload), 0, NULL, NULL);
444 : :
445 [ - + ]: 5 : DECONSTRUCT_CTRLR();
446 : 5 : }
447 : :
448 : : static void
449 : 5 : test_error_get_log_page(void)
450 : : {
451 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
452 : 5 : struct spdk_nvme_error_information_entry payload = {};
453 : :
454 : 5 : ctrlr.cdata.elpe = CTRLR_CDATA_ELPE;
455 : :
456 : 5 : verify_fn = verify_error_log_page;
457 : :
458 : : /* valid page */
459 : 5 : error_num_entries = 1;
460 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_LOG_ERROR, SPDK_NVME_GLOBAL_NS_TAG, &payload,
461 : : sizeof(payload), 0, NULL, NULL);
462 : :
463 [ - + ]: 5 : DECONSTRUCT_CTRLR();
464 : 5 : }
465 : :
466 : : static void
467 : 5 : test_intel_smart_get_log_page(void)
468 : : {
469 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
470 : 5 : struct spdk_nvme_intel_smart_information_page payload = {};
471 : :
472 : 5 : verify_fn = verify_intel_smart_log_page;
473 : :
474 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_SMART, health_log_nsid, &payload,
475 : : sizeof(payload), 0, NULL, NULL);
476 : :
477 [ - + ]: 5 : DECONSTRUCT_CTRLR();
478 : 5 : }
479 : :
480 : : static void
481 : 5 : test_intel_temperature_get_log_page(void)
482 : : {
483 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
484 : 5 : struct spdk_nvme_intel_temperature_page payload = {};
485 : :
486 : 5 : verify_fn = verify_intel_temperature_log_page;
487 : :
488 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_TEMPERATURE, SPDK_NVME_GLOBAL_NS_TAG,
489 : : &payload, sizeof(payload), 0, NULL, NULL);
490 : :
491 [ - + ]: 5 : DECONSTRUCT_CTRLR();
492 : 5 : }
493 : :
494 : : static void
495 : 5 : test_intel_read_latency_get_log_page(void)
496 : : {
497 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
498 : 5 : struct spdk_nvme_intel_rw_latency_page payload = {};
499 : :
500 : 5 : verify_fn = verify_intel_read_latency_log_page;
501 : :
502 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_READ_CMD_LATENCY,
503 : : SPDK_NVME_GLOBAL_NS_TAG,
504 : : &payload, sizeof(payload), 0, NULL, NULL);
505 : :
506 [ - + ]: 5 : DECONSTRUCT_CTRLR();
507 : 5 : }
508 : :
509 : : static void
510 : 5 : test_intel_write_latency_get_log_page(void)
511 : : {
512 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
513 : 5 : struct spdk_nvme_intel_rw_latency_page payload = {};
514 : :
515 : 5 : verify_fn = verify_intel_write_latency_log_page;
516 : :
517 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_WRITE_CMD_LATENCY,
518 : : SPDK_NVME_GLOBAL_NS_TAG,
519 : : &payload, sizeof(payload), 0, NULL, NULL);
520 : :
521 [ - + ]: 5 : DECONSTRUCT_CTRLR();
522 : 5 : }
523 : :
524 : : static void
525 : 5 : test_intel_get_log_page_directory(void)
526 : : {
527 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
528 : 5 : struct spdk_nvme_intel_log_page_directory payload = {};
529 : :
530 : 5 : verify_fn = verify_intel_get_log_page_directory;
531 : :
532 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_LOG_PAGE_DIRECTORY,
533 : : SPDK_NVME_GLOBAL_NS_TAG,
534 : : &payload, sizeof(payload), 0, NULL, NULL);
535 : :
536 [ - + ]: 5 : DECONSTRUCT_CTRLR();
537 : 5 : }
538 : :
539 : : static void
540 : 5 : test_intel_marketing_description_get_log_page(void)
541 : : {
542 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
543 : 5 : struct spdk_nvme_intel_marketing_description_page payload = {};
544 : :
545 : 5 : verify_fn = verify_intel_marketing_description_log_page;
546 : :
547 : 5 : spdk_nvme_ctrlr_cmd_get_log_page(&ctrlr, SPDK_NVME_INTEL_MARKETING_DESCRIPTION,
548 : : SPDK_NVME_GLOBAL_NS_TAG,
549 : : &payload, sizeof(payload), 0, NULL, NULL);
550 : :
551 [ - + ]: 5 : DECONSTRUCT_CTRLR();
552 : 5 : }
553 : :
554 : : static void
555 : 5 : test_generic_get_log_pages(void)
556 : : {
557 : 5 : test_error_get_log_page();
558 : 5 : test_health_get_log_page();
559 : 5 : test_firmware_get_log_page();
560 : 5 : }
561 : :
562 : : static void
563 : 5 : test_intel_get_log_pages(void)
564 : : {
565 : 5 : test_intel_get_log_page_directory();
566 : 5 : test_intel_smart_get_log_page();
567 : 5 : test_intel_temperature_get_log_page();
568 : 5 : test_intel_read_latency_get_log_page();
569 : 5 : test_intel_write_latency_get_log_page();
570 : 5 : test_intel_marketing_description_get_log_page();
571 : 5 : }
572 : :
573 : : static void
574 : 5 : test_set_feature_cmd(void)
575 : : {
576 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
577 : :
578 : 5 : verify_fn = verify_set_feature_cmd;
579 : :
580 : 5 : spdk_nvme_ctrlr_cmd_set_feature(&ctrlr, feature, feature_cdw11, feature_cdw12, NULL, 0, NULL, NULL);
581 : :
582 [ - + ]: 5 : DECONSTRUCT_CTRLR();
583 : 5 : }
584 : :
585 : : static void
586 : 5 : test_get_feature_ns_cmd(void)
587 : : {
588 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
589 : :
590 : 5 : verify_fn = verify_get_feature_ns_cmd;
591 : :
592 : 5 : spdk_nvme_ctrlr_cmd_get_feature_ns(&ctrlr, expected_feature_cdw10,
593 : : expected_feature_cdw11, NULL, 0,
594 : : NULL, NULL, expected_feature_ns);
595 : :
596 [ - + ]: 5 : DECONSTRUCT_CTRLR();
597 : 5 : }
598 : :
599 : : static void
600 : 5 : test_set_feature_ns_cmd(void)
601 : : {
602 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
603 : :
604 : 5 : verify_fn = verify_set_feature_ns_cmd;
605 : :
606 : 5 : spdk_nvme_ctrlr_cmd_set_feature_ns(&ctrlr, expected_feature_cdw10,
607 : : expected_feature_cdw11, expected_feature_cdw12,
608 : : NULL, 0, NULL, NULL, expected_feature_ns);
609 : :
610 [ - + ]: 5 : DECONSTRUCT_CTRLR();
611 : 5 : }
612 : :
613 : : static void
614 : 5 : test_get_feature_cmd(void)
615 : : {
616 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
617 : :
618 : 5 : verify_fn = verify_get_feature_cmd;
619 : :
620 : 5 : spdk_nvme_ctrlr_cmd_get_feature(&ctrlr, get_feature, get_feature_cdw11, NULL, 0, NULL, NULL);
621 : :
622 [ - + ]: 5 : DECONSTRUCT_CTRLR();
623 : 5 : }
624 : :
625 : : static void
626 : 5 : test_abort_cmd(void)
627 : : {
628 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
629 : 5 : struct spdk_nvme_qpair qpair = {};
630 : :
631 : 5 : STAILQ_INIT(&ctrlr.queued_aborts);
632 : :
633 : 5 : verify_fn = verify_abort_cmd;
634 : :
635 : 5 : qpair.id = abort_sqid;
636 : 5 : spdk_nvme_ctrlr_cmd_abort(&ctrlr, &qpair, abort_cid, NULL, NULL);
637 : :
638 [ - + ]: 5 : DECONSTRUCT_CTRLR();
639 : 5 : }
640 : :
641 : : static void
642 : 5 : test_io_cmd_raw_no_payload_build(void)
643 : : {
644 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
645 : 5 : struct spdk_nvme_qpair qpair = {};
646 : 5 : struct spdk_nvme_cmd cmd = {};
647 : :
648 : 5 : verify_fn = verify_io_cmd_raw_no_payload_build;
649 : :
650 : 5 : spdk_nvme_ctrlr_io_cmd_raw_no_payload_build(&ctrlr, &qpair, &cmd, NULL, NULL);
651 : :
652 [ - + ]: 5 : DECONSTRUCT_CTRLR();
653 : 5 : }
654 : :
655 : : static void
656 : 5 : test_io_raw_cmd(void)
657 : : {
658 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
659 : 5 : struct spdk_nvme_qpair qpair = {};
660 : 5 : struct spdk_nvme_cmd cmd = {};
661 : :
662 : 5 : verify_fn = verify_io_raw_cmd;
663 : :
664 : 5 : spdk_nvme_ctrlr_cmd_io_raw(&ctrlr, &qpair, &cmd, NULL, 1, NULL, NULL);
665 : :
666 [ - + ]: 5 : DECONSTRUCT_CTRLR();
667 : 5 : }
668 : :
669 : : static void
670 : 5 : test_io_raw_cmd_with_md(void)
671 : : {
672 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
673 : 5 : struct spdk_nvme_qpair qpair = {};
674 : 5 : struct spdk_nvme_cmd cmd = {};
675 : :
676 : 5 : verify_fn = verify_io_raw_cmd_with_md;
677 : :
678 : 5 : spdk_nvme_ctrlr_cmd_io_raw_with_md(&ctrlr, &qpair, &cmd, NULL, 1, NULL, NULL, NULL);
679 : :
680 [ - + ]: 5 : DECONSTRUCT_CTRLR();
681 : 5 : }
682 : :
683 : : static int
684 : 15 : test_set_host_id_by_case(uint32_t host_id_size)
685 : : {
686 [ + - - + ]: 15 : DECLARE_AND_CONSTRUCT_CTRLR();
687 : 15 : int rc = 0;
688 : :
689 : 15 : expected_host_id_size = host_id_size;
690 : 15 : verify_fn = verify_set_host_id_cmd;
691 : :
692 : 15 : rc = nvme_ctrlr_cmd_set_host_id(&ctrlr, NULL, expected_host_id_size, NULL, NULL);
693 : :
694 [ - + ]: 15 : DECONSTRUCT_CTRLR();
695 : 15 : return rc;
696 : : }
697 : :
698 : : static void
699 : 5 : test_set_host_id_cmds(void)
700 : : {
701 : 5 : int rc = 0;
702 : :
703 : 5 : rc = test_set_host_id_by_case(8);
704 : 5 : CU_ASSERT(rc == 0);
705 : 5 : rc = test_set_host_id_by_case(16);
706 : 5 : CU_ASSERT(rc == 0);
707 : 5 : rc = test_set_host_id_by_case(1024);
708 : 5 : CU_ASSERT(rc == -EINVAL);
709 : 5 : }
710 : :
711 : : static void
712 : 5 : test_get_log_pages(void)
713 : : {
714 : 5 : test_generic_get_log_pages();
715 : 5 : test_intel_get_log_pages();
716 : 5 : }
717 : :
718 : : static void
719 : 5 : test_namespace_attach(void)
720 : : {
721 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
722 : 5 : struct spdk_nvme_ctrlr_list payload = {};
723 : :
724 : 5 : verify_fn = verify_namespace_attach;
725 : :
726 : 5 : nvme_ctrlr_cmd_attach_ns(&ctrlr, namespace_management_nsid, &payload, NULL, NULL);
727 : :
728 [ - + ]: 5 : DECONSTRUCT_CTRLR();
729 : 5 : }
730 : :
731 : : static void
732 : 5 : test_namespace_detach(void)
733 : : {
734 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
735 : 5 : struct spdk_nvme_ctrlr_list payload = {};
736 : :
737 : 5 : verify_fn = verify_namespace_detach;
738 : :
739 : 5 : nvme_ctrlr_cmd_detach_ns(&ctrlr, namespace_management_nsid, &payload, NULL, NULL);
740 : :
741 [ - + ]: 5 : DECONSTRUCT_CTRLR();
742 : 5 : }
743 : :
744 : : static void
745 : 5 : test_namespace_create(void)
746 : : {
747 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
748 : 5 : struct spdk_nvme_ns_data payload = {};
749 : :
750 : 5 : verify_fn = verify_namespace_create;
751 : 5 : nvme_ctrlr_cmd_create_ns(&ctrlr, &payload, NULL, NULL);
752 : :
753 [ - + ]: 5 : DECONSTRUCT_CTRLR();
754 : 5 : }
755 : :
756 : : static void
757 : 5 : test_namespace_delete(void)
758 : : {
759 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
760 : :
761 : 5 : verify_fn = verify_namespace_delete;
762 : 5 : nvme_ctrlr_cmd_delete_ns(&ctrlr, namespace_management_nsid, NULL, NULL);
763 : :
764 [ - + ]: 5 : DECONSTRUCT_CTRLR();
765 : 5 : }
766 : :
767 : : static void
768 : 5 : test_doorbell_buffer_config(void)
769 : : {
770 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
771 : :
772 : 5 : verify_fn = verify_doorbell_buffer_config;
773 : :
774 : 5 : nvme_ctrlr_cmd_doorbell_buffer_config(&ctrlr, PRP_ENTRY_1, PRP_ENTRY_2, NULL, NULL);
775 : :
776 [ - + ]: 5 : DECONSTRUCT_CTRLR();
777 : 5 : }
778 : :
779 : : static void
780 : 5 : test_format_nvme(void)
781 : : {
782 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
783 : 5 : struct spdk_nvme_format format = {};
784 : :
785 : 5 : verify_fn = verify_format_nvme;
786 : :
787 : 5 : nvme_ctrlr_cmd_format(&ctrlr, format_nvme_nsid, &format, NULL, NULL);
788 : :
789 [ - + ]: 5 : DECONSTRUCT_CTRLR();
790 : 5 : }
791 : :
792 : : static void
793 : 5 : test_fw_commit(void)
794 : : {
795 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
796 : 5 : struct spdk_nvme_fw_commit fw_commit = {};
797 : :
798 : 5 : fw_commit.ca = SPDK_NVME_FW_COMMIT_REPLACE_AND_ENABLE_IMG;
799 : 5 : fw_commit.fs = 1;
800 : :
801 : 5 : verify_fn = verify_fw_commit;
802 : :
803 : 5 : nvme_ctrlr_cmd_fw_commit(&ctrlr, &fw_commit, NULL, NULL);
804 : :
805 [ - + ]: 5 : DECONSTRUCT_CTRLR();
806 : 5 : }
807 : :
808 : : static void
809 : 5 : test_fw_image_download(void)
810 : : {
811 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
812 : :
813 : 5 : verify_fn = verify_fw_image_download;
814 : :
815 : 5 : nvme_ctrlr_cmd_fw_image_download(&ctrlr, fw_img_size, fw_img_offset, NULL,
816 : : NULL, NULL);
817 : :
818 [ - + ]: 5 : DECONSTRUCT_CTRLR();
819 : 5 : }
820 : :
821 : : static void
822 : 5 : test_sanitize(void)
823 : : {
824 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
825 : 5 : struct spdk_nvme_sanitize sanitize = {};
826 : :
827 : 5 : sanitize.sanact = 1;
828 : 5 : sanitize.ause = 1;
829 : 5 : sanitize.oipbp = 1;
830 : 5 : sanitize.ndas = 1;
831 : :
832 : 5 : verify_fn = verify_nvme_sanitize;
833 : :
834 : 5 : nvme_ctrlr_cmd_sanitize(&ctrlr, sanitize_nvme_nsid, &sanitize, 0, NULL, NULL);
835 : :
836 [ - + ]: 5 : DECONSTRUCT_CTRLR();
837 : 5 : }
838 : :
839 : : static void
840 : 5 : test_directive_receive(void)
841 : : {
842 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
843 : 5 : verify_fn = verify_directive_receive;
844 : :
845 : 5 : spdk_nvme_ctrlr_cmd_directive_receive(&ctrlr, directive_nsid, 0, 0, 0, NULL, 0,
846 : : 0, 0, NULL, NULL);
847 : :
848 [ - + ]: 5 : DECONSTRUCT_CTRLR();
849 : 5 : }
850 : :
851 : : static void
852 : 5 : test_directive_send(void)
853 : : {
854 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
855 : 5 : verify_fn = verify_directive_send;
856 : :
857 : 5 : spdk_nvme_ctrlr_cmd_directive_send(&ctrlr, directive_nsid, 0, 0, 0, NULL, 0,
858 : : 0, 0, NULL, NULL);
859 : :
860 [ - + ]: 5 : DECONSTRUCT_CTRLR();
861 : 5 : }
862 : :
863 : : static void
864 : 5 : test_directive(void)
865 : : {
866 : 5 : test_directive_receive();
867 : 5 : test_directive_send();
868 : 5 : }
869 : :
870 : : static void
871 : 5 : test_nvme_request_add_abort(void)
872 : : {
873 : : int rc;
874 : 5 : struct nvme_request req = {};
875 : 5 : struct nvme_request parent = {};
876 : 5 : struct nvme_request child = {};
877 : 5 : struct spdk_nvme_qpair qpair = {};
878 : 5 : struct spdk_nvme_qpair admin_qpair = {};
879 : 5 : struct spdk_nvme_ctrlr ctrlr = {};
880 : :
881 : 5 : parent.qpair = &qpair;
882 : 5 : qpair.ctrlr = &ctrlr;
883 : 5 : ctrlr.adminq = &admin_qpair;
884 : :
885 : 5 : parent.user_cb_arg = req.cb_arg;
886 : 5 : parent.cmd.cdw10_bits.abort.sqid = 1;
887 : 5 : req.cmd.cid = 2;
888 : :
889 : : /* For allocating request */
890 : 5 : TAILQ_INIT(&parent.children);
891 : 5 : STAILQ_INIT(&admin_qpair.free_req);
892 [ + - ]: 5 : STAILQ_INSERT_HEAD(&admin_qpair.free_req, &child, stailq);
893 : :
894 : 5 : rc = nvme_request_add_abort(&req, &parent);
895 : 5 : CU_ASSERT(rc == 0);
896 [ - + ]: 5 : SPDK_CU_ASSERT_FATAL(&child == TAILQ_FIRST(&parent.children));
897 : 5 : CU_ASSERT(child.cb_arg == &child);
898 : 5 : CU_ASSERT(child.cmd.opc == SPDK_NVME_OPC_ABORT);
899 : 5 : CU_ASSERT(child.parent == &parent);
900 : 5 : CU_ASSERT(child.cmd.cdw10_bits.abort.sqid == 1);
901 : 5 : CU_ASSERT(child.cmd.cdw10_bits.abort.cid == 2);
902 : 5 : CU_ASSERT(parent.num_children == 1);
903 : :
904 : 5 : nvme_request_remove_child(&parent, &child);
905 : 5 : CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
906 : 5 : CU_ASSERT(TAILQ_EMPTY(&parent.children));
907 : 5 : CU_ASSERT(parent.num_children == 0);
908 : 5 : CU_ASSERT(child.parent == NULL);
909 : :
910 : : /* Parent invalid */
911 : 5 : req.cb_arg = (void *)0xDEADBEEF;
912 : 5 : req.parent = NULL;
913 : 5 : parent.user_cb_arg = (void *)0xDDADBEEF;
914 [ + - ]: 5 : STAILQ_INSERT_HEAD(&admin_qpair.free_req, &child, stailq);
915 : :
916 : 5 : rc = nvme_request_add_abort(&req, &parent);
917 : 5 : CU_ASSERT(rc == 0);
918 : 5 : CU_ASSERT(!STAILQ_EMPTY(&admin_qpair.free_req));
919 [ + - ]: 5 : STAILQ_REMOVE_HEAD(&admin_qpair.free_req, stailq);
920 : 5 : CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
921 : :
922 : : /* Child request empty */
923 : 5 : parent.user_cb_arg = req.cb_arg;
924 : :
925 : 5 : rc = nvme_request_add_abort(&req, &parent);
926 : 5 : CU_ASSERT(rc == -ENOMEM);
927 : 5 : }
928 : :
929 : : static void
930 : 5 : test_spdk_nvme_ctrlr_cmd_abort(void)
931 : : {
932 : : int rc;
933 : 5 : struct spdk_nvme_ctrlr ctrlr = {};
934 : 5 : struct spdk_nvme_qpair admin_qpair = {};
935 : 5 : struct spdk_nvme_qpair *qpair = NULL;
936 : 5 : struct nvme_request req = {};
937 : :
938 : : /* For allocating request */
939 : 5 : STAILQ_INIT(&admin_qpair.free_req);
940 [ + - ]: 5 : STAILQ_INSERT_HEAD(&admin_qpair.free_req, &req, stailq);
941 : 5 : ctrlr.adminq = &admin_qpair;
942 : 5 : admin_qpair.id = 0;
943 : 5 : MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
944 [ - + ]: 5 : CU_ASSERT(pthread_mutex_init(&ctrlr.ctrlr_lock, NULL) == 0);
945 : :
946 : 5 : rc = spdk_nvme_ctrlr_cmd_abort(&ctrlr, qpair, 2, (void *)0xDEADBEEF, (void *)0xDCADBEEF);
947 : 5 : CU_ASSERT(rc == 0);
948 : 5 : CU_ASSERT(req.cb_arg == &req);
949 : 5 : CU_ASSERT(req.user_cb_fn == (void *)0xDEADBEEF);
950 : 5 : CU_ASSERT(req.user_cb_arg == (void *)0xDCADBEEF);
951 : 5 : CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_ABORT);
952 : 5 : CU_ASSERT(req.cmd.cdw10_bits.abort.sqid == 0);
953 : 5 : CU_ASSERT(req.cmd.cdw10_bits.abort.cid == 2);
954 : 5 : CU_ASSERT(STAILQ_EMPTY(&admin_qpair.free_req));
955 : :
956 : : /* Request empty */
957 : 5 : rc = spdk_nvme_ctrlr_cmd_abort(&ctrlr, qpair, 2, (void *)0xDEADBEEF, (void *)0xDCADBEEF);
958 : 5 : CU_ASSERT(rc == -ENOMEM);
959 [ - - - + ]: 5 : MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
960 [ - + ]: 5 : CU_ASSERT(pthread_mutex_destroy(&ctrlr.ctrlr_lock) == 0);
961 : 5 : }
962 : :
963 : : static void
964 : 5 : test_nvme_ctrlr_cmd_identify(void)
965 : : {
966 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
967 : 5 : struct nvme_payload payload = {};
968 : : int rc;
969 : 5 : MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
970 : :
971 : 5 : rc = nvme_ctrlr_cmd_identify(&ctrlr, SPDK_NVME_IDENTIFY_NS, 2, 1, 0, &payload,
972 : : SPDK_NVME_IDENTIFY_BUFLEN, NULL, NULL);
973 : 5 : CU_ASSERT(rc == 0);
974 : 5 : CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_IDENTIFY);
975 : 5 : CU_ASSERT(req.cmd.cdw10_bits.identify.cns == SPDK_NVME_IDENTIFY_NS);
976 : 5 : CU_ASSERT(req.cmd.cdw10_bits.identify.cntid == 2);
977 : 5 : CU_ASSERT(req.cmd.cdw11_bits.identify.csi == 0);
978 : 5 : CU_ASSERT(req.cmd.nsid == 1);
979 : 5 : CU_ASSERT(STAILQ_EMPTY(&ctrlr.adminq->free_req));
980 [ - + ]: 5 : DECONSTRUCT_CTRLR();
981 [ - - - + ]: 5 : MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
982 : 5 : }
983 : :
984 : : static void
985 : 5 : test_spdk_nvme_ctrlr_cmd_security_receive_send(void)
986 : : {
987 [ + - - + ]: 5 : DECLARE_AND_CONSTRUCT_CTRLR();
988 : 5 : struct nvme_payload payload = {};
989 : : int rc;
990 : 5 : MOCK_SET(nvme_ctrlr_submit_admin_request, 0);
991 : :
992 : 5 : rc = spdk_nvme_ctrlr_cmd_security_send(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
993 : 5 : CU_ASSERT(rc == 0);
994 : 5 : CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_SECURITY_SEND);
995 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.nssf == 0xcc);
996 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp0 == 0xbb);
997 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp1 == 0xaa);
998 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.secp == 0xea);
999 : 5 : CU_ASSERT(req.cmd.cdw11 == 4096);
1000 [ - + ]: 5 : SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&ctrlr.adminq->free_req));
1001 : :
1002 [ - + ]: 5 : memset(&req, 0, sizeof(req));
1003 [ + - ]: 5 : STAILQ_INSERT_HEAD(&ctrlr.adminq->free_req, &req, stailq);
1004 : 5 : rc = spdk_nvme_ctrlr_cmd_security_receive(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
1005 : 5 : CU_ASSERT(rc == 0);
1006 : 5 : CU_ASSERT(req.cmd.opc == SPDK_NVME_OPC_SECURITY_RECEIVE);
1007 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.nssf == 0xcc);
1008 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp0 == 0xbb);
1009 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.spsp1 == 0xaa);
1010 : 5 : CU_ASSERT(req.cmd.cdw10_bits.sec_send_recv.secp == 0xea);
1011 : 5 : CU_ASSERT(req.cmd.cdw11 == 4096);
1012 [ - + ]: 5 : SPDK_CU_ASSERT_FATAL(STAILQ_EMPTY(&ctrlr.adminq->free_req));
1013 [ - - - + ]: 5 : MOCK_CLEAR(nvme_ctrlr_submit_admin_request);
1014 : :
1015 : : /* Without request valid. */
1016 : 5 : rc = spdk_nvme_ctrlr_cmd_security_send(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
1017 : 5 : CU_ASSERT(rc == -ENOMEM);
1018 : :
1019 : 5 : rc = spdk_nvme_ctrlr_cmd_security_receive(&ctrlr, 0xea, 0xaabb, 0xcc, &payload, 4096, NULL, NULL);
1020 : 5 : CU_ASSERT(rc == -ENOMEM);
1021 [ - + ]: 5 : DECONSTRUCT_CTRLR();
1022 : 5 : }
1023 : :
1024 : : int
1025 : 5 : main(int argc, char **argv)
1026 : : {
1027 : 5 : CU_pSuite suite = NULL;
1028 : : unsigned int num_failures;
1029 : :
1030 : 5 : CU_initialize_registry();
1031 : :
1032 : 5 : suite = CU_add_suite("nvme_ctrlr_cmd", NULL, NULL);
1033 : :
1034 : 5 : CU_ADD_TEST(suite, test_get_log_pages);
1035 : 5 : CU_ADD_TEST(suite, test_set_feature_cmd);
1036 : 5 : CU_ADD_TEST(suite, test_set_feature_ns_cmd);
1037 : 5 : CU_ADD_TEST(suite, test_get_feature_cmd);
1038 : 5 : CU_ADD_TEST(suite, test_get_feature_ns_cmd);
1039 : 5 : CU_ADD_TEST(suite, test_abort_cmd);
1040 : 5 : CU_ADD_TEST(suite, test_set_host_id_cmds);
1041 : 5 : CU_ADD_TEST(suite, test_io_cmd_raw_no_payload_build);
1042 : 5 : CU_ADD_TEST(suite, test_io_raw_cmd);
1043 : 5 : CU_ADD_TEST(suite, test_io_raw_cmd_with_md);
1044 : 5 : CU_ADD_TEST(suite, test_namespace_attach);
1045 : 5 : CU_ADD_TEST(suite, test_namespace_detach);
1046 : 5 : CU_ADD_TEST(suite, test_namespace_create);
1047 : 5 : CU_ADD_TEST(suite, test_namespace_delete);
1048 : 5 : CU_ADD_TEST(suite, test_doorbell_buffer_config);
1049 : 5 : CU_ADD_TEST(suite, test_format_nvme);
1050 : 5 : CU_ADD_TEST(suite, test_fw_commit);
1051 : 5 : CU_ADD_TEST(suite, test_fw_image_download);
1052 : 5 : CU_ADD_TEST(suite, test_sanitize);
1053 : 5 : CU_ADD_TEST(suite, test_directive);
1054 : 5 : CU_ADD_TEST(suite, test_nvme_request_add_abort);
1055 : 5 : CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_cmd_abort);
1056 : 5 : CU_ADD_TEST(suite, test_nvme_ctrlr_cmd_identify);
1057 : 5 : CU_ADD_TEST(suite, test_spdk_nvme_ctrlr_cmd_security_receive_send);
1058 : :
1059 : 5 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1060 : 5 : CU_cleanup_registry();
1061 : 5 : return num_failures;
1062 : : }
|