Debian Codegraph @

test/ioctl/misc.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2
3 #include <libnvme.h>
4
5 #include "mock.h"
6 #include "util.h"
7 #include <nvme/api-types.h>
8 #include <nvme/ioctl.h>
9 #include <nvme/types.h>
10 #include <string.h>
11
12 #define TEST_FD 0xFD
13 #define TEST_NSID 0x12345678
14 #define TEST_CSI NVME_CSI_KV
15
16 static void test_format_nvm(void)
17 {
18 __u32 result = 0;
19 struct nvme_format_nvm_args args = {
20 .result = &result,
21 .args_size = sizeof(args),
22 .fd = TEST_FD,
23 .nsid = TEST_NSID,
24 .mset = NVME_FORMAT_MSET_EXTENDED,
25 .pi = NVME_FORMAT_PI_TYPE2,
26 .pil = NVME_FORMAT_PIL_FIRST,
27 .ses = NVME_FORMAT_SES_USER_DATA_ERASE,
28 .lbaf = 0xF,
29 .lbafu = 0x1,
30 };
31
32 struct mock_cmd mock_admin_cmd = {
33 .opcode = nvme_admin_format_nvm,
34 .nsid = TEST_NSID,
35 .cdw10 = args.lbaf | (args.mset << 4) | (args.pi << 5) |
36 (args.pil << 8) | (args.ses << 9) | (args.lbafu << 12),
37 .result = 0,
38 };
39
40 int err;
41
42 set_mock_admin_cmds(&mock_admin_cmd, 1);
43 err = nvme_format_nvm(&args);
44 end_mock_cmds();
45 check(err == 0, "returned error %d, errno %m", err);
46 check(result == 0, "returned result %u", result);
47 }
48
49 static void test_ns_mgmt(void)
50 {
51 struct nvme_ns_mgmt_host_sw_specified expected_data, data = {};
52 __u32 result = 0;
53 struct nvme_ns_mgmt_args args = {
54 .result = &result,
55 .ns = NULL,
56 .args_size = sizeof(args),
57 .fd = TEST_FD,
58 .nsid = TEST_NSID,
59 .sel = NVME_NS_MGMT_SEL_CREATE,
60 .csi = TEST_CSI,
61 .data = &data,
62 };
63
64 struct mock_cmd mock_admin_cmd = {
65 .opcode = nvme_admin_ns_mgmt,
66 .nsid = TEST_NSID,
67 .cdw10 = args.sel,
68 .cdw11 = args.csi << 24,
69 .result = 0,
70 .data_len = sizeof(expected_data),
71 .out_data = &expected_data,
72 };
73
74 int err;
75
76 arbitrary(&expected_data, sizeof(expected_data));
77 set_mock_admin_cmds(&mock_admin_cmd, 1);
78 err = nvme_ns_mgmt(&args);
79 end_mock_cmds();
80 check(err == 0, "returned error %d, errno %m", err);
81 check(result == 0, "returned result %u", result);
82 cmp(&data, &expected_data, sizeof(data), "incorrect data");
83 }
84
85 static void test_ns_mgmt_create(void)
86 {
87 struct nvme_ns_mgmt_host_sw_specified expected_data, data = {};
88 __u32 result = 0;
89 struct mock_cmd mock_admin_cmd = {
90 .opcode = nvme_admin_ns_mgmt,
91 .nsid = NVME_NSID_NONE,
92 .cdw10 = NVME_NS_MGMT_SEL_CREATE,
93 .cdw11 = NVME_CSI_ZNS << 24,
94 .result = TEST_NSID,
95 .data_len = sizeof(expected_data),
96 .out_data = &expected_data,
97 };
98
99 int err;
100
101 arbitrary(&expected_data, sizeof(expected_data));
102 set_mock_admin_cmds(&mock_admin_cmd, 1);
103 err = nvme_ns_mgmt_create(TEST_FD, NULL, &result, 0, NVME_CSI_ZNS,
104 &data);
105 end_mock_cmds();
106 check(err == 0, "returned error %d, errno %m", err);
107 check(result == TEST_NSID, "returned result %u", result);
108 cmp(&data, &expected_data, sizeof(data), "incorrect data");
109 }
110
111 static void test_ns_mgmt_delete(void)
112 {
113 struct mock_cmd mock_admin_cmd = {
114 .opcode = nvme_admin_ns_mgmt,
115 .nsid = TEST_NSID,
116 .cdw10 = NVME_NS_MGMT_SEL_DELETE,
117 };
118
119 int err;
120
121 set_mock_admin_cmds(&mock_admin_cmd, 1);
122 err = nvme_ns_mgmt_delete(TEST_FD, TEST_NSID);
123 end_mock_cmds();
124 check(err == 0, "returned error %d, errno %m", err);
125 }
126
127 static void test_get_property(void)
128 {
129 __u64 expected_result, result;
130 struct nvme_get_property_args args = {
131 .value = &result,
132 .args_size = sizeof(args),
133 .fd = TEST_FD,
134 .offset = NVME_REG_ACQ,
135 };
136
137 arbitrary(&expected_result, sizeof(expected_result));
138
139 struct mock_cmd mock_admin_cmd = {
140 .opcode = nvme_admin_fabrics,
141 .nsid = nvme_fabrics_type_property_get,
142 .cdw10 = !!true,
143 .cdw11 = NVME_REG_ACQ,
144 .result = expected_result,
145 };
146
147 int err;
148
149 set_mock_admin_cmds(&mock_admin_cmd, 1);
150 err = nvme_get_property(&args);
151 end_mock_cmds();
152 check(err == 0, "returned error %d, errno %m", err);
153 check(result == expected_result, "returned wrong result");
154 }
155
156 static void test_set_property(void)
157 {
158 __u64 value = 0xffffffff;
159 __u32 result;
160 struct nvme_set_property_args args = {
161 .value = value,
162 .result = &result,
163 .args_size = sizeof(args),
164 .fd = TEST_FD,
165 .offset = NVME_REG_BPMBL,
166 };
167
168 struct mock_cmd mock_admin_cmd = {
169 .opcode = nvme_admin_fabrics,
170 .nsid = nvme_fabrics_type_property_set,
171 .cdw10 = !!true,
172 .cdw11 = NVME_REG_BPMBL,
173 .cdw12 = value & 0xffffffff,
174 .cdw13 = value >> 32,
175 };
176
177 int err;
178
179 set_mock_admin_cmds(&mock_admin_cmd, 1);
180 err = nvme_set_property(&args);
181 end_mock_cmds();
182 check(err == 0, "returned error %d, errno %m", err);
183 check(result == 0, "returned result %u", result);
184 }
185
186 static void test_ns_attach(void)
187 {
188 __u32 result;
189 struct nvme_ctrl_list expected_ctrlist, ctrlist;
190 struct nvme_ns_attach_args args = {
191 .result = &result,
192 .ctrlist = &ctrlist,
193 .args_size = sizeof(args),
194 .fd = TEST_FD,
195 .nsid = TEST_NSID,
196 .sel = NVME_NS_ATTACH_SEL_CTRL_DEATTACH,
197 };
198
199 struct mock_cmd mock_admin_cmd = {
200 .opcode = nvme_admin_ns_attach,
201 .nsid = TEST_NSID,
202 .cdw10 = NVME_NS_ATTACH_SEL_CTRL_DEATTACH,
203 .data_len = sizeof(expected_ctrlist),
204 .out_data = &expected_ctrlist,
205 };
206
207 int err;
208
209 arbitrary(&expected_ctrlist, sizeof(expected_ctrlist));
210 set_mock_admin_cmds(&mock_admin_cmd, 1);
211 err = nvme_ns_attach(&args);
212 end_mock_cmds();
213 check(err == 0, "returned error %d, errno %m", err);
214 check(result == 0, "returned result %u", result);
215 cmp(&expected_ctrlist, &ctrlist, sizeof(expected_ctrlist),
216 "incorrect data");
217 }
218
219 static void test_ns_attach_ctrls(void)
220 {
221 struct nvme_ctrl_list ctrlist;
222
223 struct mock_cmd mock_admin_cmd = {
224 .opcode = nvme_admin_ns_attach,
225 .nsid = TEST_NSID,
226 .cdw10 = NVME_NS_ATTACH_SEL_CTRL_ATTACH,
227 .data_len = sizeof(ctrlist),
228 .out_data = &ctrlist,
229 };
230
231 int err;
232
233 arbitrary(&ctrlist, sizeof(ctrlist));
234 set_mock_admin_cmds(&mock_admin_cmd, 1);
235 err = nvme_ns_attach_ctrls(TEST_FD, TEST_NSID, &ctrlist);
236 end_mock_cmds();
237 check(err == 0, "returned error %d, errno %m", err);
238 }
239
240 static void test_ns_detach_ctrls(void)
241 {
242 struct nvme_ctrl_list ctrlist;
243
244 struct mock_cmd mock_admin_cmd = {
245 .opcode = nvme_admin_ns_attach,
246 .nsid = TEST_NSID,
247 .cdw10 = NVME_NS_ATTACH_SEL_CTRL_DEATTACH,
248 .data_len = sizeof(ctrlist),
249 .out_data = &ctrlist,
250 };
251
252 int err;
253
254 arbitrary(&ctrlist, sizeof(ctrlist));
255 set_mock_admin_cmds(&mock_admin_cmd, 1);
256 err = nvme_ns_detach_ctrls(TEST_FD, TEST_NSID, &ctrlist);
257 end_mock_cmds();
258 check(err == 0, "returned error %d, errno %m", err);
259 }
260
261 static void test_fw_download(void)
262 {
263 __u32 result = 0;
264 __u8 expected_data[8], data[8];
265
266 struct nvme_fw_download_args args = {
267 .result = &result,
268 .data = &expected_data,
269 .args_size = sizeof(args),
270 .fd = TEST_FD,
271 .offset = 123,
272 .data_len = sizeof(expected_data),
273 };
274
275 struct mock_cmd mock_admin_cmd = {
276 .opcode = nvme_admin_fw_download,
277 .cdw10 = (args.data_len >> 2) - 1,
278 .cdw11 = args.offset >> 2,
279 .data_len = args.data_len,
280 .in_data = &data,
281 };
282
283 int err;
284
285 arbitrary(&expected_data, sizeof(expected_data));
286 memcpy(&data, &expected_data, sizeof(expected_data));
287 set_mock_admin_cmds(&mock_admin_cmd, 1);
288 err = nvme_fw_download(&args);
289 end_mock_cmds();
290 check(err == 0, "returned error %d, errno %m", err);
291 check(result == 0, "returned result %u", result);
292 }
293
294 static void test_fw_commit(void)
295 {
296 __u32 result = 0;
297
298 struct nvme_fw_commit_args args = {
299 .result = &result,
300 .args_size = sizeof(args),
301 .fd = TEST_FD,
302 .action = NVME_FW_COMMIT_CA_REPLACE_AND_ACTIVATE_IMMEDIATE,
303 .slot = 0xf,
304 .bpid = true,
305 };
306
307 struct mock_cmd mock_admin_cmd = {
308 .opcode = nvme_admin_fw_commit,
309 .cdw10 = (!!args.bpid << 31) | (args.action << 3) | args.slot,
310 };
311
312 int err;
313
314 set_mock_admin_cmds(&mock_admin_cmd, 1);
315 err = nvme_fw_commit(&args);
316 end_mock_cmds();
317 check(err == 0, "returned error %d, errno %m", err);
318 check(result == 0, "returned result %u", result);
319 }
320
321 static void test_security_send(void)
322 {
323 __u8 expected_data[8], data[8];
324 __u32 result = 0;
325
326 struct nvme_security_send_args args = {
327 .result = &result,
328 .data = &expected_data,
329 .args_size = sizeof(args),
330 .fd = TEST_FD,
331 .nsid = TEST_NSID,
332 .tl = 0xffff,
333 .data_len = sizeof(expected_data),
334 .nssf = 0x1,
335 .spsp0 = 0x1,
336 .spsp1 = 0x1,
337 .secp = 0xE9,
338 };
339
340 struct mock_cmd mock_admin_cmd = {
341 .opcode = nvme_admin_security_send,
342 .nsid = TEST_NSID,
343 .cdw10 = args.nssf | (args.spsp0 << 8) | (args.spsp1 << 16) |
344 (args.secp << 24),
345 .cdw11 = args.tl,
346 .data_len = args.data_len,
347 .in_data = &data,
348 };
349
350 int err;
351
352 arbitrary(&expected_data, sizeof(expected_data));
353 memcpy(&data, &expected_data, sizeof(expected_data));
354 set_mock_admin_cmds(&mock_admin_cmd, 1);
355 err = nvme_security_send(&args);
356 end_mock_cmds();
357 check(err == 0, "returned error %d, errno %m", err);
358 check(result == 0, "returned result %u", result);
359 cmp(&data, &expected_data, sizeof(data), "incorrect data");
360 }
361
362 static void test_security_receive(void)
363 {
364 __u8 expected_data[8], data[8];
365 __u32 result = 0;
366
367 struct nvme_security_receive_args args = {
368 .result = &result,
369 .data = &data,
370 .args_size = sizeof(args),
371 .fd = TEST_FD,
372 .nsid = TEST_NSID,
373 .al = 0xffff,
374 .data_len = sizeof(data),
375 .nssf = 0x1,
376 .spsp0 = 0x1,
377 .spsp1 = 0x1,
378 .secp = 0xE9,
379 };
380
381 struct mock_cmd mock_admin_cmd = {
382 .opcode = nvme_admin_security_recv,
383 .nsid = TEST_NSID,
384 .cdw10 = args.nssf | (args.spsp0 << 8) | (args.spsp1 << 16) |
385 (args.secp << 24),
386 .cdw11 = args.al,
387 .data_len = args.data_len,
388 .out_data = &expected_data,
389 };
390
391 int err;
392
393 arbitrary(&expected_data, sizeof(expected_data));
394 set_mock_admin_cmds(&mock_admin_cmd, 1);
395 err = nvme_security_receive(&args);
396 end_mock_cmds();
397 check(err == 0, "returned error %d, errno %m", err);
398 check(result == 0, "returned result %u", result);
399 cmp(&data, &expected_data, sizeof(data), "incorrect data");
400 }
401
402 static void test_get_lba_status(void)
403 {
404 __u32 result = 0;
405 __u8 nlsd = 3;
406 int lba_status_size = sizeof(struct nvme_lba_status) +
407 nlsd * sizeof(struct nvme_lba_status_desc);
408
409 _cleanup_free_ struct nvme_lba_status *lbas = NULL;
410 _cleanup_free_ struct nvme_lba_status *expected_lbas = NULL;
411
412 lbas = malloc(lba_status_size);
413 check(lbas, "lbas: ENOMEM");
414 expected_lbas = malloc(lba_status_size);
415 check(expected_lbas, "expected_lbas: ENOMEM");
416
417 struct nvme_get_lba_status_args args = {
418 .slba = 0x123456789,
419 .result = &result,
420 .lbas = lbas,
421 .args_size = sizeof(args),
422 .fd = TEST_FD,
423 .nsid = TEST_NSID,
424 .mndw = ((lba_status_size - 1) >> 2),
425 .atype = 0x11,
426 .rl = 0x42,
427 };
428
429 struct mock_cmd mock_admin_cmd = {
430 .opcode = nvme_admin_get_lba_status,
431 .nsid = TEST_NSID,
432 .cdw10 = args.slba & 0xffffffff,
433 .cdw11 = args.slba >> 32,
434 .cdw12 = args.mndw,
435 .cdw13 = args.rl | (args.atype << 24),
436 .data_len = (args.mndw + 1) << 2,
437 .out_data = expected_lbas,
438 };
439
440 int err;
441
442 arbitrary(expected_lbas, lba_status_size);
443 set_mock_admin_cmds(&mock_admin_cmd, 1);
444 err = nvme_get_lba_status(&args);
445 end_mock_cmds();
446 check(err == 0, "returned error %d, errno %m", err);
447 check(result == 0, "returned wrong result");
448 cmp(lbas, expected_lbas, lba_status_size, "incorrect lbas");
449 }
450
451 static void test_directive_send(void)
452 {
453 __u8 expected_data[8], data[8];
454 __u32 result = 0;
455
456 struct nvme_directive_send_args args = {
457 .result = &result,
458 .data = &expected_data,
459 .args_size = sizeof(args),
460 .fd = TEST_FD,
461 .nsid = TEST_NSID,
462 .doper = NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE,
463 .dtype = NVME_DIRECTIVE_DTYPE_STREAMS,
464 .cdw12 = 0xffff,
465 .data_len = sizeof(expected_data),
466 .dspec = 0x0,
467 };
468
469 struct mock_cmd mock_admin_cmd = {
470 .opcode = nvme_admin_directive_send,
471 .nsid = TEST_NSID,
472 .cdw10 = args.data_len ? (args.data_len >> 2) - 1 : 0,
473 .cdw11 = args.doper | (args.dtype << 8) | (args.dspec << 16),
474 .cdw12 = args.cdw12,
475 .data_len = args.data_len,
476 .in_data = &data,
477 };
478
479 int err;
480
481 arbitrary(&expected_data, sizeof(expected_data));
482 memcpy(&data, &expected_data, sizeof(expected_data));
483 set_mock_admin_cmds(&mock_admin_cmd, 1);
484 err = nvme_directive_send(&args);
485 end_mock_cmds();
486 check(err == 0, "returned error %d, errno %m", err);
487 check(result == 0, "returned wrong result");
488 cmp(&data, &expected_data, sizeof(data), "incorrect data");
489 }
490
491 static void test_directive_send_id_endir(void)
492 {
493 struct nvme_id_directives expected_id, id;
494
495 struct mock_cmd mock_admin_cmd = {
496 .opcode = nvme_admin_directive_send,
497 .nsid = TEST_NSID,
498 .cdw10 = (sizeof(expected_id) >> 2) - 1,
499 .cdw11 = NVME_DIRECTIVE_SEND_IDENTIFY_DOPER_ENDIR |
500 (NVME_DIRECTIVE_DTYPE_IDENTIFY << 8),
501 .cdw12 = (!!true) | (NVME_DIRECTIVE_DTYPE_STREAMS << 1),
502 .data_len = sizeof(id),
503 .in_data = &id,
504 };
505
506 int err;
507
508 arbitrary(&expected_id, sizeof(expected_id));
509 memcpy(&id, &expected_id, sizeof(expected_id));
510 set_mock_admin_cmds(&mock_admin_cmd, 1);
511 err = nvme_directive_send_id_endir(TEST_FD, TEST_NSID, true,
512 NVME_DIRECTIVE_DTYPE_STREAMS, &id);
513 end_mock_cmds();
514 check(err == 0, "returned error %d, errno %m", err);
515 cmp(&id, &expected_id, sizeof(id), "incorrect id");
516 }
517
518 static void test_directive_send_stream_release_identifier(void)
519 {
520 __u16 stream_id = 0x1234;
521 struct mock_cmd mock_admin_cmd = {
522 .opcode = nvme_admin_directive_send,
523 .nsid = TEST_NSID,
524 .cdw11 = NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_IDENTIFIER |
525 (NVME_DIRECTIVE_DTYPE_STREAMS << 8) |
526 (stream_id << 16),
527 };
528
529 int err;
530
531 set_mock_admin_cmds(&mock_admin_cmd, 1);
532 err = nvme_directive_send_stream_release_identifier(TEST_FD, TEST_NSID,
533 stream_id);
534 end_mock_cmds();
535 check(err == 0, "returned error %d, errno %m", err);
536 }
537
538 static void test_directive_send_stream_release_resource(void)
539 {
540 struct mock_cmd mock_admin_cmd = {
541 .opcode = nvme_admin_directive_send,
542 .nsid = TEST_NSID,
543 .cdw11 = NVME_DIRECTIVE_SEND_STREAMS_DOPER_RELEASE_RESOURCE |
544 (NVME_DIRECTIVE_DTYPE_STREAMS << 8),
545 };
546
547 int err;
548
549 set_mock_admin_cmds(&mock_admin_cmd, 1);
550 err = nvme_directive_send_stream_release_resource(TEST_FD, TEST_NSID);
551 end_mock_cmds();
552 check(err == 0, "returned error %d, errno %m", err);
553 }
554
555 static void test_directive_recv(void)
556 {
557 __u8 expected_data[8], data[8];
558 __u32 result = 0;
559
560 struct nvme_directive_recv_args args = {
561 .result = &result,
562 .data = &data,
563 .args_size = sizeof(args),
564 .fd = TEST_FD,
565 .nsid = TEST_NSID,
566 .doper = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM,
567 .dtype = NVME_DIRECTIVE_DTYPE_STREAMS,
568 .cdw12 = 0xffff,
569 .data_len = sizeof(data),
570 .dspec = 0x0,
571 };
572
573 struct mock_cmd mock_admin_cmd = {
574 .opcode = nvme_admin_directive_recv,
575 .nsid = TEST_NSID,
576 .cdw10 = args.data_len ? (args.data_len >> 2) - 1 : 0,
577 .cdw11 = args.doper | (args.dtype << 8) | (args.dspec << 16),
578 .cdw12 = args.cdw12,
579 .data_len = sizeof(expected_data),
580 .out_data = &expected_data,
581 };
582
583 int err;
584
585 arbitrary(&expected_data, sizeof(expected_data));
586 set_mock_admin_cmds(&mock_admin_cmd, 1);
587 err = nvme_directive_recv(&args);
588 end_mock_cmds();
589 check(err == 0, "returned error %d, errno %m", err);
590 check(result == 0, "returned wrong result");
591 cmp(&data, &expected_data, sizeof(data), "incorrect data");
592 }
593
594 static void test_directive_recv_identify_parameters(void)
595 {
596 struct nvme_id_directives expected_id, id;
597
598 struct mock_cmd mock_admin_cmd = {
599 .opcode = nvme_admin_directive_recv,
600 .nsid = TEST_NSID,
601 .cdw10 = (sizeof(expected_id) >> 2) - 1,
602 .cdw11 = NVME_DIRECTIVE_RECEIVE_IDENTIFY_DOPER_PARAM |
603 (NVME_DIRECTIVE_DTYPE_IDENTIFY << 8),
604 .data_len = sizeof(expected_id),
605 .out_data = &expected_id,
606 };
607
608 int err;
609
610 arbitrary(&expected_id, sizeof(expected_id));
611 set_mock_admin_cmds(&mock_admin_cmd, 1);
612 err = nvme_directive_recv_identify_parameters(TEST_FD, TEST_NSID, &id);
613 end_mock_cmds();
614 check(err == 0, "returned error %d, errno %m", err);
615 cmp(&id, &expected_id, sizeof(id), "incorrect id");
616 }
617
618 static void test_directive_recv_stream_parameters(void)
619 {
620 struct nvme_streams_directive_params expected_params, params;
621
622 struct mock_cmd mock_admin_cmd = {
623 .opcode = nvme_admin_directive_recv,
624 .nsid = TEST_NSID,
625 .cdw10 = (sizeof(expected_params) >> 2) - 1,
626 .cdw11 = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_PARAM |
627 (NVME_DIRECTIVE_DTYPE_STREAMS << 8),
628 .data_len = sizeof(expected_params),
629 .out_data = &expected_params,
630 };
631
632 int err;
633
634 arbitrary(&expected_params, sizeof(expected_params));
635 set_mock_admin_cmds(&mock_admin_cmd, 1);
636 err = nvme_directive_recv_stream_parameters(TEST_FD, TEST_NSID,
637 &params);
638 end_mock_cmds();
639 check(err == 0, "returned error %d, errno %m", err);
640 cmp(&params, &expected_params, sizeof(params), "incorrect params");
641 }
642
643 static void test_directive_recv_stream_status(void)
644 {
645 __u8 nr_entries = 3;
646 uint32_t stream_status_size =
647 sizeof(struct nvme_streams_directive_status) +
648 nr_entries * sizeof(__le16);
649
650 _cleanup_free_ struct nvme_streams_directive_status *expected_status =
651 NULL;
652 _cleanup_free_ struct nvme_streams_directive_status *status = NULL;
653
654 status = malloc(stream_status_size);
655 check(status, "status: ENOMEM");
656 expected_status = malloc(stream_status_size);
657 check(expected_status, "expected_status: ENOMEM");
658
659 struct mock_cmd mock_admin_cmd = {
660 .opcode = nvme_admin_directive_recv,
661 .nsid = TEST_NSID,
662 .cdw10 = (stream_status_size >> 2) - 1,
663 .cdw11 = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_STATUS |
664 (NVME_DIRECTIVE_DTYPE_STREAMS << 8),
665 .data_len = stream_status_size,
666 .out_data = expected_status,
667 };
668
669 int err;
670
671 arbitrary(expected_status, stream_status_size);
672 set_mock_admin_cmds(&mock_admin_cmd, 1);
673 err = nvme_directive_recv_stream_status(TEST_FD, TEST_NSID, nr_entries,
674 status);
675 end_mock_cmds();
676 check(err == 0, "returned error %d, errno %m", err);
677 cmp(status, expected_status, stream_status_size, "incorrect status");
678 }
679
680 static void test_directive_recv_stream_allocate(void)
681 {
682 __u32 expected_result = 0x45, result = 0;
683 __u16 nsr = 0x67;
684
685 struct mock_cmd mock_admin_cmd = {
686 .opcode = nvme_admin_directive_recv,
687 .nsid = TEST_NSID,
688 .cdw11 = NVME_DIRECTIVE_RECEIVE_STREAMS_DOPER_RESOURCE |
689 (NVME_DIRECTIVE_DTYPE_STREAMS << 8),
690 .cdw12 = nsr,
691 .result = expected_result,
692 };
693
694 int err;
695
696 set_mock_admin_cmds(&mock_admin_cmd, 1);
697 err = nvme_directive_recv_stream_allocate(TEST_FD, TEST_NSID, nsr,
698 &result);
699 end_mock_cmds();
700 check(err == 0, "returned error %d, errno %m", err);
701 check(result == expected_result, "wrong result");
702 }
703
704 static void test_capacity_mgmt(void)
705 {
706 __u32 expected_result = 0x45, result = 0;
707
708 struct nvme_capacity_mgmt_args args = {
709 .result = &result,
710 .args_size = sizeof(args),
711 .fd = TEST_FD,
712 .cdw11 = 0x1234,
713 .cdw12 = 0x5678,
714 .element_id = 0x12,
715 .op = 0x3,
716 };
717
718 struct mock_cmd mock_admin_cmd = {
719 .opcode = nvme_admin_capacity_mgmt,
720 .nsid = NVME_NSID_NONE,
721 .cdw10 = args.op | args.element_id << 16,
722 .cdw11 = args.cdw11,
723 .cdw12 = args.cdw12,
724 .result = expected_result,
725 };
726
727 int err;
728
729 set_mock_admin_cmds(&mock_admin_cmd, 1);
730 err = nvme_capacity_mgmt(&args);
731 end_mock_cmds();
732 check(err == 0, "returned error %d, errno %m", err);
733 check(result == expected_result, "wrong result");
734 }
735
736 static void test_lockdown(void)
737 {
738 __u32 expected_result = 0x45, result = 0;
739
740 struct nvme_lockdown_args args = {
741 .result = &result,
742 .args_size = sizeof(args),
743 .fd = TEST_FD,
744 .scp = 0x2,
745 .prhbt = !!true,
746 .ifc = 0x1,
747 .ofi = 0x12,
748 .uuidx = 0x34,
749 };
750
751 struct mock_cmd mock_admin_cmd = {
752 .opcode = nvme_admin_lockdown,
753 .cdw10 = args.ofi << 8 | (args.ifc & 0x3) << 5 |
754 (args.prhbt & 0x1) << 4 | (args.scp & 0xF),
755 .cdw14 = args.uuidx & 0x3F,
756 .result = expected_result,
757 };
758
759 int err;
760
761 set_mock_admin_cmds(&mock_admin_cmd, 1);
762 err = nvme_lockdown(&args);
763 end_mock_cmds();
764 check(err == 0, "returned error %d, errno %m", err);
765 check(result == expected_result, "wrong result");
766 }
767
768 static void test_sanitize_nvm(void)
769 {
770 __u32 expected_result = 0x45, result = 0;
771
772 struct nvme_sanitize_nvm_args args = {
773 .result = &result,
774 .args_size = sizeof(args),
775 .fd = TEST_FD,
776 .sanact = NVME_SANITIZE_SANACT_START_CRYPTO_ERASE,
777 .ovrpat = 0x101010,
778 .ause = true,
779 .owpass = 0x2,
780 .oipbp = false,
781 .nodas = true,
782 .emvs = false,
783 };
784
785 struct mock_cmd mock_admin_cmd = {
786 .opcode = nvme_admin_sanitize_nvm,
787 .cdw10 = args.sanact | (!!args.ause << 3) | (args.owpass << 4) |
788 (!!args.oipbp << 8) | (!!args.nodas << 9),
789 .cdw11 = args.ovrpat,
790 .result = expected_result,
791 };
792
793 int err;
794
795 set_mock_admin_cmds(&mock_admin_cmd, 1);
796 err = nvme_sanitize_nvm(&args);
797 end_mock_cmds();
798 check(err == 0, "returned error %d, errno %m", err);
799 check(result == expected_result, "wrong result");
800 }
801
802 static void test_dev_self_test(void)
803 {
804 __u32 expected_result = 0x45, result = 0;
805
806 struct nvme_dev_self_test_args args = {
807 .result = &result,
808 .args_size = sizeof(args),
809 .fd = TEST_FD,
810 .nsid = TEST_NSID,
811 .stc = NVME_DST_STC_ABORT,
812 };
813
814 struct mock_cmd mock_admin_cmd = {
815 .opcode = nvme_admin_dev_self_test,
816 .nsid = args.nsid,
817 .cdw10 = args.stc,
818 .result = expected_result,
819 };
820
821 int err;
822
823 set_mock_admin_cmds(&mock_admin_cmd, 1);
824 err = nvme_dev_self_test(&args);
825 end_mock_cmds();
826 check(err == 0, "returned error %d, errno %m", err);
827 check(result == expected_result, "wrong result");
828 }
829
830 static void test_virtual_mgmt(void)
831 {
832 __u32 expected_result = 0x45, result = 0;
833
834 struct nvme_virtual_mgmt_args args = {
835 .result = &result,
836 .args_size = sizeof(args),
837 .fd = TEST_FD,
838 .act = NVME_VIRT_MGMT_ACT_ASSIGN_SEC_CTRL,
839 .rt = NVME_VIRT_MGMT_RT_VI_RESOURCE,
840 .cntlid = 0x0,
841 .nr = 0xff,
842 };
843
844 struct mock_cmd mock_admin_cmd = {
845 .opcode = nvme_admin_virtual_mgmt,
846 .cdw10 = args.act | (args.rt << 8) | (args.cntlid << 16),
847 .cdw11 = args.nr,
848 .result = expected_result,
849 };
850
851 int err;
852
853 set_mock_admin_cmds(&mock_admin_cmd, 1);
854 err = nvme_virtual_mgmt(&args);
855 end_mock_cmds();
856 check(err == 0, "returned error %d, errno %m", err);
857 check(result == expected_result, "wrong result");
858 }
859
860 static void test_flush(void)
861 {
862 struct mock_cmd mock_io_cmd = {
863 .opcode = nvme_cmd_flush,
864 .nsid = TEST_NSID,
865 };
866
867 int err;
868
869 set_mock_io_cmds(&mock_io_cmd, 1);
870 err = nvme_flush(TEST_FD, TEST_NSID);
871 end_mock_cmds();
872 check(err == 0, "returned error %d, errno %m", err);
873 }
874
875 static void test_read(void)
876 {
877 __u8 expected_data[512], data[512] = {};
878 __u32 result = 0;
879
880 struct nvme_io_args args = {
881 .slba = 0xffffffffff,
882 .storage_tag = 0xef,
883 .result = &result,
884 .data = &data,
885 .args_size = sizeof(args),
886 .fd = TEST_FD,
887 .nsid = TEST_NSID,
888 .reftag = 0xab,
889 .data_len = sizeof(data),
890 .nlb = 0x3,
891 .control = NVME_IO_FUA,
892 .apptag = 0x12,
893 .appmask = 0x34,
894 .dspec = 0x0,
895 .dsm = NVME_IO_DSM_LATENCY_LOW,
896 };
897
898 struct mock_cmd mock_io_cmd = {
899 .opcode = nvme_cmd_read,
900 .nsid = TEST_NSID,
901 .cdw10 = args.slba & 0xffffffff,
902 .cdw11 = args.slba >> 32,
903 .cdw12 = args.nlb | (args.control << 16),
904 .cdw13 = args.dsm | (args.dspec << 16),
905 .cdw15 = args.apptag | (args.appmask << 16),
906 .data_len = sizeof(expected_data),
907 .out_data = &expected_data,
908 };
909
910 int err;
911
912 arbitrary(&expected_data, sizeof(expected_data));
913 set_mock_io_cmds(&mock_io_cmd, 1);
914 err = nvme_read(&args);
915 end_mock_cmds();
916 check(err == 0, "returned error %d, errno %m", err);
917 check(result == 0, "returned result %u", result);
918 }
919
920 static void test_write(void)
921 {
922 __u8 expected_data[512], data[512] = {};
923 __u32 result = 0;
924
925 struct nvme_io_args args = {
926 .slba = 0xfffffffabcde,
927 .storage_tag = 0xab,
928 .result = &result,
929 .data = &expected_data,
930 .args_size = sizeof(args),
931 .fd = TEST_FD,
932 .nsid = TEST_NSID,
933 .reftag = 0xef,
934 .data_len = sizeof(expected_data),
935 .nlb = 0x5,
936 .control = NVME_IO_FUA,
937 .apptag = 0x59,
938 .appmask = 0x94,
939 .dspec = 0xa,
940 .dsm = NVME_IO_DSM_COMPRESSED,
941 };
942
943 struct mock_cmd mock_io_cmd = {
944 .opcode = nvme_cmd_write,
945 .nsid = TEST_NSID,
946 .cdw10 = args.slba & 0xffffffff,
947 .cdw11 = args.slba >> 32,
948 .cdw12 = args.nlb | (args.control << 16),
949 .cdw13 = args.dsm | (args.dspec << 16),
950 .cdw15 = args.apptag | (args.appmask << 16),
951 .data_len = sizeof(data),
952 .in_data = &data,
953 };
954
955 int err;
956
957 arbitrary(&expected_data, sizeof(expected_data));
958 memcpy(&data, &expected_data, sizeof(expected_data));
959 set_mock_io_cmds(&mock_io_cmd, 1);
960 err = nvme_write(&args);
961 end_mock_cmds();
962 check(err == 0, "returned error %d, errno %m", err);
963 check(result == 0, "returned result %u", result);
964 }
965
966 static void test_compare(void)
967 {
968 __u8 expected_data[512], data[512] = {};
969 __u32 result = 0;
970
971 struct nvme_io_args args = {
972 .slba = 0xabcde,
973 .storage_tag = 0xab,
974 .result = &result,
975 .data = &expected_data,
976 .args_size = sizeof(args),
977 .fd = TEST_FD,
978 .nsid = TEST_NSID,
979 .reftag = 0xff,
980 .data_len = sizeof(expected_data),
981 .nlb = 0x0,
982 .control = NVME_IO_LR,
983 .apptag = 0x59,
984 .appmask = 0x94,
985 .dspec = 0xa,
986 .dsm = NVME_IO_DSM_COMPRESSED,
987 };
988
989 struct mock_cmd mock_io_cmd = {
990 .opcode = nvme_cmd_compare,
991 .nsid = TEST_NSID,
992 .cdw10 = args.slba & 0xffffffff,
993 .cdw11 = args.slba >> 32,
994 .cdw12 = args.nlb | (args.control << 16),
995 .cdw13 = args.dsm | (args.dspec << 16),
996 .cdw15 = args.apptag | (args.appmask << 16),
997 .data_len = sizeof(data),
998 .in_data = &data,
999 };
1000
1001 int err;
1002
1003 arbitrary(&expected_data, sizeof(expected_data));
1004 memcpy(&data, &expected_data, sizeof(expected_data));
1005 set_mock_io_cmds(&mock_io_cmd, 1);
1006 err = nvme_compare(&args);
1007 end_mock_cmds();
1008 check(err == 0, "returned error %d, errno %m", err);
1009 check(result == 0, "returned result %u", result);
1010 }
1011
1012 static void test_write_zeros(void)
1013 {
1014 __u8 expected_data[512], data[512] = {};
1015 __u32 result = 0;
1016
1017 struct nvme_io_args args = {
1018 .slba = 0x0,
1019 .storage_tag = 0xab,
1020 .result = &result,
1021 .data = &expected_data,
1022 .args_size = sizeof(args),
1023 .fd = TEST_FD,
1024 .nsid = TEST_NSID,
1025 .reftag = 0xff,
1026 .data_len = sizeof(expected_data),
1027 .nlb = 0xffff,
1028 .control = NVME_IO_LR,
1029 .apptag = 0xfa,
1030 .appmask = 0x72,
1031 .dspec = 0xbb,
1032 .dsm = NVME_IO_DSM_FREQ_ONCE,
1033 };
1034
1035 struct mock_cmd mock_io_cmd = {
1036 .opcode = nvme_cmd_write_zeroes,
1037 .nsid = TEST_NSID,
1038 .cdw10 = args.slba & 0xffffffff,
1039 .cdw11 = args.slba >> 32,
1040 .cdw12 = args.nlb | (args.control << 16),
1041 .cdw13 = args.dsm | (args.dspec << 16),
1042 .cdw15 = args.apptag | (args.appmask << 16),
1043 .data_len = sizeof(data),
1044 .in_data = &data,
1045 };
1046
1047 int err;
1048
1049 arbitrary(&expected_data, sizeof(expected_data));
1050 memcpy(&data, &expected_data, sizeof(expected_data));
1051 set_mock_io_cmds(&mock_io_cmd, 1);
1052 err = nvme_write_zeros(&args);
1053 end_mock_cmds();
1054 check(err == 0, "returned error %d, errno %m", err);
1055 check(result == 0, "returned result %u", result);
1056 }
1057
1058 static void test_write_uncorrectable(void)
1059 {
1060 __u8 expected_data[512], data[512] = {};
1061 __u32 result = 0;
1062
1063 struct nvme_io_args args = {
1064 .slba = 0x0,
1065 .storage_tag = 0x0,
1066 .result = &result,
1067 .data = &expected_data,
1068 .args_size = sizeof(args),
1069 .fd = TEST_FD,
1070 .nsid = TEST_NSID,
1071 .reftag = 0x0,
1072 .data_len = sizeof(expected_data),
1073 .nlb = 0x0,
1074 .control = 0x0,
1075 .apptag = 0x0,
1076 .appmask = 0x0,
1077 .dspec = 0x0,
1078 .dsm = 0x0,
1079 };
1080
1081 struct mock_cmd mock_io_cmd = {
1082 .opcode = nvme_cmd_write_uncor,
1083 .nsid = TEST_NSID,
1084 .cdw10 = args.slba & 0xffffffff,
1085 .cdw11 = args.slba >> 32,
1086 .cdw12 = args.nlb | (args.control << 16),
1087 .cdw13 = args.dsm | (args.dspec << 16),
1088 .cdw15 = args.apptag | (args.appmask << 16),
1089 .data_len = sizeof(data),
1090 .in_data = &data,
1091 };
1092
1093 int err;
1094
1095 arbitrary(&expected_data, sizeof(expected_data));
1096 memcpy(&data, &expected_data, sizeof(expected_data));
1097 set_mock_io_cmds(&mock_io_cmd, 1);
1098 err = nvme_write_uncorrectable(&args);
1099 end_mock_cmds();
1100 check(err == 0, "returned error %d, errno %m", err);
1101 check(result == 0, "returned result %u", result);
1102 }
1103
1104 static void test_verify(void)
1105 {
1106 __u8 expected_data[512], data[512] = {};
1107 __u32 result = 0;
1108
1109 struct nvme_io_args args = {
1110 .slba = 0xffffffffffffffff,
1111 .storage_tag = 0xffffffffffffffff,
1112 .result = &result,
1113 .data = &expected_data,
1114 .args_size = sizeof(args),
1115 .fd = TEST_FD,
1116 .nsid = TEST_NSID,
1117 .reftag = 0xffffffff,
1118 .data_len = sizeof(expected_data),
1119 .nlb = 0xffff,
1120 .control = 0xffff,
1121 .apptag = 0xffff,
1122 .appmask = 0xffff,
1123 .dspec = 0xffff,
1124 .dsm = 0xff,
1125 };
1126
1127 struct mock_cmd mock_io_cmd = {
1128 .opcode = nvme_cmd_verify,
1129 .nsid = TEST_NSID,
1130 .cdw10 = args.slba & 0xffffffff,
1131 .cdw11 = args.slba >> 32,
1132 .cdw12 = args.nlb | (args.control << 16),
1133 .cdw13 = args.dsm | (args.dspec << 16),
1134 .cdw15 = args.apptag | (args.appmask << 16),
1135 .data_len = sizeof(data),
1136 .in_data = &data,
1137 };
1138
1139 int err;
1140
1141 arbitrary(&expected_data, sizeof(expected_data));
1142 memcpy(&data, &expected_data, sizeof(expected_data));
1143 set_mock_io_cmds(&mock_io_cmd, 1);
1144 err = nvme_verify(&args);
1145 end_mock_cmds();
1146 check(err == 0, "returned error %d, errno %m", err);
1147 check(result == 0, "returned result %u", result);
1148 }
1149
1150 static void test_dsm(void)
1151 {
1152 __u32 result = 0;
1153 __u16 nr_ranges = 0xab;
1154 int dsm_size = sizeof(struct nvme_dsm_range) * nr_ranges;
1155
1156 _cleanup_free_ struct nvme_dsm_range *dsm = NULL;
1157
1158 dsm = malloc(dsm_size);
1159 check(dsm, "dsm: ENOMEM");
1160
1161 struct nvme_dsm_args args = {
1162 .result = &result,
1163 .dsm = dsm,
1164 .args_size = sizeof(args),
1165 .fd = TEST_FD,
1166 .nsid = TEST_NSID,
1167 .attrs = NVME_DSMGMT_AD,
1168 .nr_ranges = nr_ranges,
1169 };
1170
1171 struct mock_cmd mock_io_cmd = {
1172 .opcode = nvme_cmd_dsm,
1173 .nsid = TEST_NSID,
1174 .cdw10 = args.nr_ranges - 1,
1175 .cdw11 = args.attrs,
1176 .data_len = dsm_size,
1177 .in_data = args.dsm,
1178 };
1179
1180 int err;
1181
1182 arbitrary(dsm, dsm_size);
1183 set_mock_io_cmds(&mock_io_cmd, 1);
1184 err = nvme_dsm(&args);
1185 end_mock_cmds();
1186 check(err == 0, "returned error %d, errno %m", err);
1187 check(result == 0, "returned result %u", result);
1188 }
1189
1190 static void test_copy(void)
1191 {
1192 __u32 result = 0;
1193 __u16 nr = 0x12;
1194 int copy_size = sizeof(struct nvme_copy_range) * nr;
1195
1196 _cleanup_free_ struct nvme_copy_range *copy = NULL;
1197
1198 copy = malloc(copy_size);
1199 check(copy, "copy: ENOMEM");
1200
1201 struct nvme_copy_args args = {
1202 .sdlba = 0xfffff,
1203 .result = &result,
1204 .copy = copy,
1205 .args_size = sizeof(args),
1206 .fd = TEST_FD,
1207 .nsid = TEST_NSID,
1208 .nr = nr,
1209 .format = 0xf,
1210 };
1211
1212 struct mock_cmd mock_io_cmd = {
1213 .opcode = nvme_cmd_copy,
1214 .nsid = TEST_NSID,
1215 .cdw10 = args.sdlba & 0xffffffff,
1216 .cdw11 = args.sdlba >> 32,
1217 .cdw12 = ((args.nr - 1) & 0xff) | ((args.format & 0xf) << 8) |
1218 ((args.prinfor & 0xf) << 12) |
1219 ((args.dtype & 0xf) << 20) |
1220 ((args.prinfow & 0xf) << 26) |
1221 ((args.fua & 0x1) << 30) | ((args.lr & 0x1) << 31),
1222 .data_len = args.nr * sizeof(struct nvme_copy_range),
1223 .in_data = args.copy,
1224 };
1225
1226 int err;
1227
1228 set_mock_io_cmds(&mock_io_cmd, 1);
1229 err = nvme_copy(&args);
1230 end_mock_cmds();
1231 check(err == 0, "returned error %d, errno %m", err);
1232 check(result == 0, "returned result %u", result);
1233 }
1234
1235 static void test_resv_acquire(void)
1236 {
1237 __u32 result = 0;
1238
1239 struct nvme_resv_acquire_args args = {
1240 .crkey = 0,
1241 .nrkey = 0,
1242 .result = &result,
1243 .args_size = sizeof(args),
1244 .fd = TEST_FD,
1245 .nsid = TEST_NSID,
1246 .rtype = NVME_RESERVATION_RTYPE_EAAR,
1247 .racqa = NVME_RESERVATION_RACQA_PREEMPT,
1248 .iekey = true,
1249 };
1250
1251 __le64 payload[2] = { 0 };
1252
1253 struct mock_cmd mock_io_cmd = {
1254 .opcode = nvme_cmd_resv_acquire,
1255 .nsid = TEST_NSID,
1256 .cdw10 = (args.racqa & 0x7) | (args.iekey ? 1 << 3 : 0) |
1257 (args.rtype << 8),
1258 .data_len = sizeof(payload),
1259 .in_data = payload,
1260 };
1261
1262 int err;
1263
1264 set_mock_io_cmds(&mock_io_cmd, 1);
1265 err = nvme_resv_acquire(&args);
1266 end_mock_cmds();
1267 check(err == 0, "returned error %d, errno %m", err);
1268 check(result == 0, "returned result %u", result);
1269 }
1270
1271 static void test_resv_register(void)
1272 {
1273 __u32 result = 0;
1274
1275 struct nvme_resv_register_args args = {
1276 .crkey = 0xffffffffffffffff,
1277 .nrkey = 0,
1278 .result = &result,
1279 .args_size = sizeof(args),
1280 .fd = TEST_FD,
1281 .nsid = TEST_NSID,
1282 .rrega = NVME_RESERVATION_RREGA_UNREGISTER_KEY,
1283 .cptpl = NVME_RESERVATION_CPTPL_PERSIST,
1284 .iekey = true,
1285 };
1286
1287 __le64 payload[2] = { 0xffffffffffffffff, 0 };
1288
1289 struct mock_cmd mock_io_cmd = {
1290 .opcode = nvme_cmd_resv_register,
1291 .nsid = TEST_NSID,
1292 .cdw10 = (args.rrega & 0x7) | (args.iekey ? 1 << 3 : 0) |
1293 (args.cptpl << 30),
1294 .data_len = sizeof(payload),
1295 .in_data = payload,
1296 };
1297
1298 int err;
1299
1300 set_mock_io_cmds(&mock_io_cmd, 1);
1301 err = nvme_resv_register(&args);
1302 end_mock_cmds();
1303 check(err == 0, "returned error %d, errno %m", err);
1304 check(result == 0, "returned result %u", result);
1305 }
1306
1307 static void test_resv_release(void)
1308 {
1309 __u32 result = 0;
1310
1311 struct nvme_resv_release_args args = {
1312 .crkey = 0xffffffffffffffff,
1313 .result = &result,
1314 .args_size = sizeof(args),
1315 .fd = TEST_FD,
1316 .nsid = TEST_NSID,
1317 .rtype = NVME_RESERVATION_RTYPE_WE,
1318 .rrela = NVME_RESERVATION_RRELA_RELEASE,
1319 .iekey = true,
1320 };
1321
1322 __le64 payload[1] = { 0xffffffffffffffff };
1323
1324 struct mock_cmd mock_io_cmd = {
1325 .opcode = nvme_cmd_resv_release,
1326 .nsid = TEST_NSID,
1327 .cdw10 = (args.rrela & 0x7) | (args.iekey ? 1 << 3 : 0) |
1328 (args.rtype << 8),
1329 .data_len = sizeof(payload),
1330 .in_data = payload,
1331 };
1332
1333 int err;
1334
1335 set_mock_io_cmds(&mock_io_cmd, 1);
1336 err = nvme_resv_release(&args);
1337 end_mock_cmds();
1338 check(err == 0, "returned error %d, errno %m", err);
1339 check(result == 0, "returned result %u", result);
1340 }
1341
1342 static void test_resv_report(void)
1343 {
1344 __u32 result = 0;
1345
1346 struct nvme_resv_status expected_status, status = {};
1347
1348 struct nvme_resv_report_args args = {
1349 .result = &result,
1350 .report = &status,
1351 .args_size = sizeof(args),
1352 .fd = TEST_FD,
1353 .nsid = TEST_NSID,
1354 .len = sizeof(status),
1355 .eds = false,
1356 };
1357
1358 struct mock_cmd mock_io_cmd = {
1359 .opcode = nvme_cmd_resv_report,
1360 .nsid = TEST_NSID,
1361 .cdw10 = (args.len >> 2) - 1,
1362 .cdw11 = args.eds ? 1 : 0,
1363 .data_len = args.len,
1364 .out_data = &expected_status,
1365 };
1366
1367 int err;
1368
1369 arbitrary(&expected_status, sizeof(expected_status));
1370 set_mock_io_cmds(&mock_io_cmd, 1);
1371 err = nvme_resv_report(&args);
1372 end_mock_cmds();
1373 check(err == 0, "returned error %d, errno %m", err);
1374 check(result == 0, "returned result %u", result);
1375 cmp(&status, &expected_status, sizeof(status), "incorrect status");
1376 }
1377
1378 static void test_io_mgmt_recv(void)
1379 {
1380 __u8 expected_data[8], data[8] = {};
1381 struct nvme_io_mgmt_recv_args args = {
1382 .data = &data,
1383 .args_size = sizeof(args),
1384 .fd = TEST_FD,
1385 .nsid = TEST_NSID,
1386 .data_len = sizeof(data),
1387 .mos = 0x1,
1388 .mo = 0x2,
1389 };
1390
1391 struct mock_cmd mock_io_cmd = {
1392 .opcode = nvme_cmd_io_mgmt_recv,
1393 .nsid = TEST_NSID,
1394 .cdw10 = args.mo | (args.mos << 16),
1395 .cdw11 = (args.data_len >> 2) - 1,
1396 .data_len = args.data_len,
1397 .out_data = &expected_data,
1398 };
1399
1400 int err;
1401
1402 arbitrary(&expected_data, sizeof(expected_data));
1403 set_mock_io_cmds(&mock_io_cmd, 1);
1404 err = nvme_io_mgmt_recv(&args);
1405 end_mock_cmds();
1406 check(err == 0, "returned error %d, errno %m", err);
1407 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1408 }
1409
1410 static void test_io_mgmt_send(void)
1411 {
1412 __u8 expected_data[8], data[8] = {};
1413 struct nvme_io_mgmt_send_args args = {
1414 .data = &expected_data,
1415 .args_size = sizeof(args),
1416 .fd = TEST_FD,
1417 .nsid = TEST_NSID,
1418 .data_len = sizeof(expected_data),
1419 .mos = 0x1,
1420 .mo = 0x2,
1421 };
1422
1423 struct mock_cmd mock_io_cmd = {
1424 .opcode = nvme_cmd_io_mgmt_send,
1425 .nsid = TEST_NSID,
1426 .cdw10 = args.mo | (args.mos << 16),
1427 .data_len = args.data_len,
1428 .in_data = &data,
1429 };
1430
1431 int err;
1432
1433 arbitrary(&expected_data, sizeof(expected_data));
1434 memcpy(&data, &expected_data, sizeof(expected_data));
1435 set_mock_io_cmds(&mock_io_cmd, 1);
1436 err = nvme_io_mgmt_send(&args);
1437 end_mock_cmds();
1438 check(err == 0, "returned error %d, errno %m", err);
1439 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1440 }
1441
1442 static void test_fdp_reclaim_unit_handle_status(void)
1443 {
1444 __u8 expected_data[8], data[8] = {};
1445 __u32 data_len = sizeof(data);
1446 struct mock_cmd mock_io_cmd = {
1447 .opcode = nvme_cmd_io_mgmt_recv,
1448 .nsid = TEST_NSID,
1449 .cdw10 = NVME_IO_MGMT_RECV_RUH_STATUS,
1450 .cdw11 = (data_len >> 2) - 1,
1451 .data_len = data_len,
1452 .out_data = &expected_data,
1453 };
1454
1455 int err;
1456
1457 arbitrary(&expected_data, sizeof(expected_data));
1458 set_mock_io_cmds(&mock_io_cmd, 1);
1459 err = nvme_fdp_reclaim_unit_handle_status(TEST_FD, TEST_NSID, data_len,
1460 &data);
1461 end_mock_cmds();
1462 check(err == 0, "returned error %d, errno %m", err);
1463 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1464 }
1465
1466 static void test_fdp_reclaim_unit_handle_update(void)
1467 {
1468 __u16 pids;
1469 unsigned int npids = 1;
1470 struct mock_cmd mock_io_cmd = {
1471 .opcode = nvme_cmd_io_mgmt_send,
1472 .nsid = TEST_NSID,
1473 .cdw10 = NVME_IO_MGMT_SEND_RUH_UPDATE | ((npids - 1) << 16),
1474 .data_len = npids * sizeof(__u16),
1475 .in_data = &pids,
1476 };
1477
1478 int err;
1479
1480 arbitrary(&pids, sizeof(pids));
1481 set_mock_io_cmds(&mock_io_cmd, 1);
1482 err = nvme_fdp_reclaim_unit_handle_update(TEST_FD, TEST_NSID, npids,
1483 &pids);
1484 end_mock_cmds();
1485 check(err == 0, "returned error %d, errno %m", err);
1486 }
1487
1488 static void test_dim_send(void)
1489 {
1490 __u32 result = 0;
1491 __u8 expected_data[8], data[8] = {};
1492 struct nvme_dim_args args = {
1493 .result = 0,
1494 .data = &data,
1495 .args_size = sizeof(args),
1496 .fd = TEST_FD,
1497 .data_len = sizeof(data),
1498 .tas = 0xf,
1499 };
1500
1501 struct mock_cmd mock_admin_cmd = {
1502 .opcode = nvme_admin_discovery_info_mgmt,
1503 .cdw10 = args.tas,
1504 .data_len = args.data_len,
1505 .in_data = &expected_data,
1506 };
1507
1508 int err;
1509
1510 arbitrary(&expected_data, sizeof(expected_data));
1511 memcpy(&data, &expected_data, sizeof(expected_data));
1512 set_mock_admin_cmds(&mock_admin_cmd, 1);
1513 err = nvme_dim_send(&args);
1514 end_mock_cmds();
1515 check(err == 0, "returned error %d, errno %m", err);
1516 check(result == 0, "returned result %u", result);
1517 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1518 }
1519
1520 static void test_lm_cdq(void)
1521 {
1522 __u32 result = 0;
1523 __u8 expected_data[8], data[8] = {};
1524 struct nvme_lm_cdq_args args = {
1525 .result = 0,
1526 .data = &data,
1527 .args_size = sizeof(args),
1528 .fd = TEST_FD,
1529 .mos = 0x1,
1530 .cntlid = 0x2,
1531 .cdqid = 0x3,
1532 .sel = NVME_LM_SEL_DELETE_CDQ,
1533 .sz = 0x4,
1534 };
1535
1536 struct mock_cmd mock_admin_cmd = {
1537 .opcode = nvme_admin_ctrl_data_queue,
1538 .cdw10 = args.sel | (args.mos << 16),
1539 .cdw11 = args.cdqid,
1540 .cdw12 = args.sz,
1541 .data_len = 0,
1542 .in_data = &expected_data,
1543 };
1544
1545 int err;
1546
1547 arbitrary(&expected_data, sizeof(expected_data));
1548 memcpy(&data, &expected_data, sizeof(expected_data));
1549 set_mock_admin_cmds(&mock_admin_cmd, 1);
1550 err = nvme_lm_cdq(&args);
1551 end_mock_cmds();
1552 check(err == 0, "returned error %d, errno %m", err);
1553 check(result == 0, "returned result %u", result);
1554 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1555 }
1556
1557 static void test_lm_track_send(void)
1558 {
1559 __u32 result = 0;
1560 struct nvme_lm_track_send_args args = {
1561 .result = 0,
1562 .args_size = sizeof(args),
1563 .fd = TEST_FD,
1564 .mos = 0x1,
1565 .cdqid = 0x3,
1566 .sel = NVME_LM_SEL_DELETE_CDQ,
1567 };
1568
1569 struct mock_cmd mock_admin_cmd = {
1570 .opcode = nvme_admin_track_send,
1571 .cdw10 = args.sel | (args.mos << 16),
1572 .cdw11 = args.cdqid,
1573 };
1574
1575 int err;
1576
1577 set_mock_admin_cmds(&mock_admin_cmd, 1);
1578 err = nvme_lm_track_send(&args);
1579 end_mock_cmds();
1580 check(err == 0, "returned error %d, errno %m", err);
1581 check(result == 0, "returned result %u", result);
1582 }
1583
1584 static void test_lm_migration_send(void)
1585 {
1586 __u32 result = 0;
1587 __u32 expected_data[8], data[8] = {};
1588 struct nvme_lm_migration_send_args args = {
1589 .offset = 0xffffffffff,
1590 .result = 0,
1591 .data = &expected_data,
1592 .args_size = sizeof(args),
1593 .fd = TEST_FD,
1594 .numd = 8 - 1,
1595 .mos = 0x1,
1596 .cntlid = 0x2,
1597 .csuuidi = 0x3,
1598 .sel = NVME_LM_SEL_RESUME,
1599 .uidx = 0x4,
1600 .stype = 0x5,
1601 .seqind = 0x6,
1602 .csvi = 0x7,
1603 .dudmq = true,
1604 };
1605
1606 struct mock_cmd mock_admin_cmd = {
1607 .opcode = nvme_admin_migration_send,
1608 .cdw10 = args.sel | (args.mos << 16),
1609 .cdw11 = args.cntlid,
1610 .cdw12 = (__u32)args.offset,
1611 .cdw13 = (__u32)(args.offset >> 32),
1612 .cdw14 = args.uidx,
1613 .cdw15 = args.numd,
1614 .data_len = args.numd << 2,
1615 .in_data = &data,
1616 };
1617
1618 int err;
1619
1620 arbitrary(&expected_data, sizeof(expected_data));
1621 memcpy(&data, &expected_data, sizeof(expected_data));
1622 set_mock_admin_cmds(&mock_admin_cmd, 1);
1623 err = nvme_lm_migration_send(&args);
1624 end_mock_cmds();
1625 check(err == 0, "returned error %d, errno %m", err);
1626 check(result == 0, "returned result %u", result);
1627 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1628 }
1629
1630 static void test_lm_migration_recv(void)
1631 {
1632 __u32 result = 0;
1633 __u32 expected_data[8], data[8] = {};
1634 struct nvme_lm_migration_recv_args args = {
1635 .offset = 0xffffffffff,
1636 .result = 0,
1637 .data = &data,
1638 .args_size = sizeof(args),
1639 .fd = TEST_FD,
1640 .numd = 8 - 1,
1641 .mos = 0x1,
1642 .cntlid = 0x2,
1643 .csuuidi = 0x3,
1644 .sel = NVME_LM_SEL_GET_CONTROLLER_STATE,
1645 .uidx = 0x4,
1646 .csuidxp = 0x5,
1647 };
1648
1649 struct mock_cmd mock_admin_cmd = {
1650 .opcode = nvme_admin_migration_receive,
1651 .cdw10 = args.sel | (args.mos << 16),
1652 .cdw11 = args.cntlid | (args.csuuidi << 16) |
1653 (args.csuidxp << 24),
1654 .cdw12 = (__u32)args.offset,
1655 .cdw13 = (__u32)(args.offset >> 32),
1656 .cdw14 = args.uidx,
1657 .cdw15 = args.numd,
1658 .data_len = (args.numd + 1) << 2,
1659 .out_data = &expected_data,
1660 };
1661
1662 int err;
1663
1664 arbitrary(&expected_data, sizeof(expected_data));
1665 set_mock_admin_cmds(&mock_admin_cmd, 1);
1666 err = nvme_lm_migration_recv(&args);
1667 end_mock_cmds();
1668 check(err == 0, "returned error %d, errno %m", err);
1669 check(result == 0, "returned result %u", result);
1670 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1671 }
1672
1673 static void run_test(const char *test_name, void (*test_fn)(void))
1674 {
1675 printf("Running test %s...", test_name);
1676 fflush(stdout);
1677 test_fn();
1678 puts(" OK");
1679 }
1680
1681 #define RUN_TEST(name) run_test(#name, test_##name)
1682
1683 int main(void)
1684 {
1685 set_mock_fd(TEST_FD);
1686 RUN_TEST(format_nvm);
1687 RUN_TEST(ns_mgmt);
1688 RUN_TEST(ns_mgmt_create);
1689 RUN_TEST(ns_mgmt_delete);
1690 RUN_TEST(get_property);
1691 RUN_TEST(set_property);
1692 RUN_TEST(ns_attach);
1693 RUN_TEST(ns_attach_ctrls);
1694 RUN_TEST(ns_detach_ctrls);
1695 RUN_TEST(fw_download);
1696 RUN_TEST(fw_commit);
1697 RUN_TEST(security_send);
1698 RUN_TEST(security_receive);
1699 RUN_TEST(get_lba_status);
1700 RUN_TEST(directive_send);
1701 RUN_TEST(directive_send_id_endir);
1702 RUN_TEST(directive_send_stream_release_identifier);
1703 RUN_TEST(directive_send_stream_release_resource);
1704 RUN_TEST(directive_recv);
1705 RUN_TEST(directive_recv_identify_parameters);
1706 RUN_TEST(directive_recv_stream_parameters);
1707 RUN_TEST(directive_recv_stream_status);
1708 RUN_TEST(directive_recv_stream_allocate);
1709 RUN_TEST(capacity_mgmt);
1710 RUN_TEST(lockdown);
1711 RUN_TEST(sanitize_nvm);
1712 RUN_TEST(dev_self_test);
1713 RUN_TEST(virtual_mgmt);
1714 RUN_TEST(flush);
1715 RUN_TEST(read);
1716 RUN_TEST(write);
1717 RUN_TEST(compare);
1718 RUN_TEST(write_zeros);
1719 RUN_TEST(write_uncorrectable);
1720 RUN_TEST(verify);
1721 RUN_TEST(dsm);
1722 RUN_TEST(copy);
1723 RUN_TEST(resv_acquire);
1724 RUN_TEST(resv_register);
1725 RUN_TEST(resv_release);
1726 RUN_TEST(resv_report);
1727 RUN_TEST(io_mgmt_recv);
1728 RUN_TEST(io_mgmt_send);
1729 RUN_TEST(fdp_reclaim_unit_handle_status);
1730 RUN_TEST(fdp_reclaim_unit_handle_update);
1731 RUN_TEST(dim_send);
1732 RUN_TEST(lm_cdq);
1733 RUN_TEST(lm_track_send);
1734 RUN_TEST(lm_migration_send);
1735 RUN_TEST(lm_migration_recv);
1736 }