Debian Codegraph @

test/ioctl/features.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2
3 #include <errno.h>
4 #include <inttypes.h>
5
6 #include <libnvme.h>
7
8 #include "mock.h"
9 #include "util.h"
10
11 #define TEST_FD 0xFD
12 #define TEST_TIMEOUT 1234
13 #define TEST_NSID 0x89ABCDEF
14 #define TEST_CDW11 0x11111111
15 #define TEST_CDW12 0x12121212
16 #define TEST_CDW13 0x13131313
17 #define TEST_CDW15 0x15151515
18 #define TEST_CDQID 0x8765
19 #define TEST_UUIDX 0b1001110
20 #define TEST_FID 0xFE
21 #define TEST_RESULT 0x12345678
22 #define TEST_SEL NVME_GET_FEATURES_SEL_SAVED
23 #define TEST_SC NVME_SC_INVALID_FIELD
24
25 static void test_set_features(void)
26 {
27 uint32_t result = 0;
28 uint8_t data[256];
29 struct nvme_set_features_args args = {
30 .result = &result,
31 .data = data,
32 .args_size = sizeof(args),
33 .fd = TEST_FD,
34 .timeout = TEST_TIMEOUT,
35 .nsid = TEST_NSID,
36 .cdw11 = TEST_CDW11,
37 .cdw12 = TEST_CDW12,
38 .cdw13 = TEST_CDW13,
39 .cdw15 = TEST_CDW15,
40 .data_len = sizeof(data),
41 .save = true,
42 .uuidx = TEST_UUIDX,
43 .fid = TEST_FID,
44 };
45 struct mock_cmd mock_admin_cmd = {
46 .opcode = nvme_admin_set_features,
47 .nsid = TEST_NSID,
48 .in_data = data,
49 .data_len = sizeof(data),
50 .cdw10 = (uint32_t)1 << 31 /* SAVE */
51 | TEST_FID,
52 .cdw11 = TEST_CDW11,
53 .cdw12 = TEST_CDW12,
54 .cdw13 = TEST_CDW13,
55 .cdw14 = TEST_UUIDX,
56 .cdw15 = TEST_CDW15,
57 .timeout_ms = TEST_TIMEOUT,
58 .result = TEST_RESULT,
59 };
60 int err;
61
62 arbitrary(data, sizeof(data));
63 set_mock_admin_cmds(&mock_admin_cmd, 1);
64 err = nvme_set_features(&args);
65 end_mock_cmds();
66 check(err == 0, "set features returned error %d, errno %m", err);
67 check(result == TEST_RESULT,
68 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
69 }
70
71 static void test_get_features(void)
72 {
73 uint32_t result = 0;
74 uint8_t data[256], get_data[sizeof(data)] = {};
75 struct nvme_get_features_args args = {
76 .result = &result,
77 .data = get_data,
78 .args_size = sizeof(args),
79 .fd = TEST_FD,
80 .timeout = TEST_TIMEOUT,
81 .nsid = TEST_NSID,
82 .sel = TEST_SEL,
83 .cdw11 = TEST_CDW11,
84 .data_len = sizeof(data),
85 .fid = TEST_FID,
86 .uuidx = TEST_UUIDX,
87 };
88 struct mock_cmd mock_admin_cmd = {
89 .opcode = nvme_admin_get_features,
90 .nsid = TEST_NSID,
91 .data_len = sizeof(data),
92 .cdw10 = TEST_SEL << 8 | TEST_FID,
93 .cdw11 = TEST_CDW11,
94 .cdw14 = TEST_UUIDX,
95 .timeout_ms = TEST_TIMEOUT,
96 .out_data = data,
97 .result = TEST_RESULT,
98 };
99 int err;
100
101 arbitrary(data, sizeof(data));
102 set_mock_admin_cmds(&mock_admin_cmd, 1);
103 err = nvme_get_features(&args);
104 end_mock_cmds();
105 check(err == 0, "get features returned error %d, errno %m", err);
106 check(result == TEST_RESULT,
107 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
108 cmp(get_data, data, sizeof(data), "incorrect data");
109 }
110
111 static void test_set_features_data(void)
112 {
113 uint8_t data[128];
114 struct mock_cmd mock_admin_cmd = {
115 .opcode = nvme_admin_set_features,
116 .nsid = TEST_NSID,
117 .in_data = data,
118 .data_len = sizeof(data),
119 .cdw10 = TEST_FID,
120 .cdw11 = TEST_CDW11,
121 .result = TEST_RESULT,
122 };
123 uint32_t result = 0;
124 int err;
125
126 arbitrary(data, sizeof(data));
127 set_mock_admin_cmds(&mock_admin_cmd, 1);
128 err = nvme_set_features_data(
129 TEST_FD, TEST_FID, TEST_NSID, TEST_CDW11, false,
130 sizeof(data), data, &result);
131 end_mock_cmds();
132 check(err == 0, "set features returned error %d, errno %m", err);
133 check(result == TEST_RESULT,
134 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
135 }
136
137 static void test_get_features_data(void)
138 {
139 uint8_t data[128], get_data[sizeof(data)] = {};
140 struct mock_cmd mock_admin_cmd = {
141 .opcode = nvme_admin_get_features,
142 .nsid = TEST_NSID,
143 .data_len = sizeof(data),
144 .cdw10 = NVME_GET_FEATURES_SEL_CURRENT << 8 | TEST_FID,
145 .out_data = data,
146 .result = TEST_RESULT,
147 };
148 uint32_t result = 0;
149 int err;
150
151 arbitrary(data, sizeof(data));
152 set_mock_admin_cmds(&mock_admin_cmd, 1);
153 err = nvme_get_features_data(
154 TEST_FD, TEST_FID, TEST_NSID, sizeof(data), get_data, &result);
155 end_mock_cmds();
156 check(err == 0, "set features returned error %d, errno %m", err);
157 check(result == TEST_RESULT,
158 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
159 cmp(get_data, data, sizeof(data), "incorrect data");
160 }
161
162 static void test_set_features_simple(void)
163 {
164 struct mock_cmd mock_admin_cmd = {
165 .opcode = nvme_admin_set_features,
166 .nsid = TEST_NSID,
167 .cdw10 = (uint32_t)1 << 31 /* SAVE */
168 | TEST_FID,
169 .cdw11 = TEST_CDW11,
170 .result = TEST_RESULT,
171 };
172 uint32_t result = 0;
173 int err;
174
175 set_mock_admin_cmds(&mock_admin_cmd, 1);
176 err = nvme_set_features_simple(
177 TEST_FD, TEST_FID, TEST_NSID, TEST_CDW11, true, &result);
178 end_mock_cmds();
179 check(err == 0, "set features returned error %d, errno %m", err);
180 check(result == TEST_RESULT,
181 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
182 }
183
184 static void test_get_features_simple(void)
185 {
186 struct mock_cmd mock_admin_cmd = {
187 .opcode = nvme_admin_get_features,
188 .nsid = TEST_NSID,
189 .cdw10 = NVME_GET_FEATURES_SEL_CURRENT << 8 | TEST_FID,
190 .result = TEST_RESULT,
191 };
192 uint32_t result = 0;
193 int err;
194
195 set_mock_admin_cmds(&mock_admin_cmd, 1);
196 err = nvme_get_features_simple(TEST_FD, TEST_FID, TEST_NSID, &result);
197 end_mock_cmds();
198 check(err == 0, "set features returned error %d, errno %m", err);
199 check(result == TEST_RESULT,
200 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
201 }
202
203 static void test_set_arbitration(void)
204 {
205 uint8_t HPW = 0xAA, MPW = 0xBB, LPW = 0xCC, AB = 0b111;
206 struct mock_cmd mock_admin_cmd = {
207 .opcode = nvme_admin_set_features,
208 .cdw10 = NVME_FEAT_FID_ARBITRATION,
209 .cdw11 = (uint32_t)HPW << 24 | MPW << 16 | LPW << 8 | AB,
210 .result = TEST_RESULT,
211 };
212 uint32_t result = 0;
213 int err;
214
215 set_mock_admin_cmds(&mock_admin_cmd, 1);
216 err = nvme_set_features_arbitration(
217 TEST_FD, AB, LPW, MPW, HPW, false, &result);
218 end_mock_cmds();
219 check(err == 0, "set features returned error %d, errno %m", err);
220 check(result == TEST_RESULT,
221 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
222 }
223
224 static void test_get_arbitration(void)
225 {
226 struct mock_cmd mock_admin_cmd = {
227 .opcode = nvme_admin_get_features,
228 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_ARBITRATION,
229 .result = TEST_RESULT,
230 };
231 uint32_t result = 0;
232 int err;
233
234 set_mock_admin_cmds(&mock_admin_cmd, 1);
235 err = nvme_get_features_arbitration(TEST_FD, TEST_SEL, &result);
236 end_mock_cmds();
237 check(err == 0, "get features returned error %d, errno %m", err);
238 check(result == TEST_RESULT,
239 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
240 }
241
242 static void test_set_power_mgmt(void)
243 {
244 uint8_t PS = 0b10101, WH = 0b101;
245 struct mock_cmd mock_admin_cmd = {
246 .opcode = nvme_admin_set_features,
247 .cdw10 = (uint32_t)1 << 31 /* SAVE */
248 | NVME_FEAT_FID_POWER_MGMT,
249 .cdw11 = WH << 5 | PS,
250 .result = TEST_RESULT,
251 };
252 uint32_t result = 0;
253 int err;
254
255 set_mock_admin_cmds(&mock_admin_cmd, 1);
256 err = nvme_set_features_power_mgmt(TEST_FD, PS, WH, true, &result);
257 end_mock_cmds();
258 check(err == 0, "set features returned error %d, errno %m", err);
259 check(result == TEST_RESULT,
260 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
261 }
262
263 static void test_get_power_mgmt(void)
264 {
265 struct mock_cmd mock_admin_cmd = {
266 .opcode = nvme_admin_get_features,
267 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_POWER_MGMT,
268 .result = TEST_RESULT,
269 };
270 uint32_t result = 0;
271 int err;
272
273 set_mock_admin_cmds(&mock_admin_cmd, 1);
274 err = nvme_get_features_power_mgmt(TEST_FD, TEST_SEL, &result);
275 end_mock_cmds();
276 check(err == 0, "get features returned error %d, errno %m", err);
277 check(result == TEST_RESULT,
278 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
279 }
280
281 static void test_set_lba_range(void)
282 {
283 uint8_t NUM = 64;
284 struct nvme_lba_range_type range_types;
285 struct mock_cmd mock_admin_cmd = {
286 .opcode = nvme_admin_set_features,
287 .nsid = TEST_NSID,
288 .in_data = &range_types,
289 .data_len = sizeof(range_types),
290 .cdw10 = NVME_FEAT_FID_LBA_RANGE,
291 .cdw11 = NUM - 1,
292 .result = TEST_RESULT,
293 };
294 uint32_t result = 0;
295 int err;
296
297 arbitrary(&range_types, sizeof(range_types));
298 set_mock_admin_cmds(&mock_admin_cmd, 1);
299 err = nvme_set_features_lba_range(
300 TEST_FD, TEST_NSID, NUM, false, &range_types, &result);
301 end_mock_cmds();
302 check(err == 0, "set features returned error %d, errno %m", err);
303 check(result == TEST_RESULT,
304 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
305 }
306
307 static void test_get_lba_range(void)
308 {
309 struct nvme_lba_range_type range_types, get_range_types = {};
310 struct mock_cmd mock_admin_cmd = {
311 .opcode = nvme_admin_get_features,
312 .nsid = TEST_NSID,
313 .data_len = sizeof(range_types),
314 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_LBA_RANGE,
315 .out_data = &range_types,
316 .result = TEST_RESULT,
317 };
318 uint32_t result = 0;
319 int err;
320
321 arbitrary(&range_types, sizeof(range_types));
322 set_mock_admin_cmds(&mock_admin_cmd, 1);
323 err = nvme_get_features_lba_range2(
324 TEST_FD, TEST_SEL, TEST_NSID, &get_range_types, &result);
325 end_mock_cmds();
326 check(err == 0, "get features returned error %d, errno %m", err);
327 check(result == TEST_RESULT,
328 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
329 cmp(&get_range_types, &range_types, sizeof(range_types),
330 "incorrect LBA range types");
331 }
332
333 static void test_set_temp_thresh(void)
334 {
335 uint16_t TMPTH = 0xFEDC;
336 uint8_t TMPSEL = 0x8;
337 enum nvme_feat_tmpthresh_thsel THSEL =
338 NVME_FEATURE_TEMPTHRESH_THSEL_UNDER;
339 struct mock_cmd mock_admin_cmd = {
340 .opcode = nvme_admin_set_features,
341 .cdw10 = (uint32_t)1 << 31 /* SAVE */
342 | NVME_FEAT_FID_TEMP_THRESH,
343 .cdw11 = THSEL << 20 | TMPSEL << 16 | TMPTH,
344 .result = TEST_RESULT,
345 };
346 uint32_t result = 0;
347 int err;
348
349 set_mock_admin_cmds(&mock_admin_cmd, 1);
350 err = nvme_set_features_temp_thresh(
351 TEST_FD, TMPTH, TMPSEL, THSEL, true, &result);
352 end_mock_cmds();
353 check(err == 0, "set features returned error %d, errno %m", err);
354 check(result == TEST_RESULT,
355 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
356 }
357
358 static void test_get_temp_thresh(void)
359 {
360 /*
361 * nvme_get_features_temp_thresh() doesn't support
362 * specifying TMPSEL and THSEL
363 */
364 struct mock_cmd mock_admin_cmd = {
365 .opcode = nvme_admin_get_features,
366 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_TEMP_THRESH,
367 .cdw11 = NVME_FEATURE_TEMPTHRESH_THSEL_OVER << 20,
368 .result = TEST_RESULT,
369 };
370 uint32_t result = 0;
371 int err;
372
373 set_mock_admin_cmds(&mock_admin_cmd, 1);
374 err = nvme_get_features_temp_thresh(TEST_FD, TEST_SEL, &result);
375 end_mock_cmds();
376 check(err == 0, "get features returned error %d, errno %m", err);
377 check(result == TEST_RESULT,
378 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
379 }
380
381 static void test_set_err_recovery(void)
382 {
383 uint16_t TLER = 0xCDEF;
384 struct mock_cmd mock_admin_cmd = {
385 .opcode = nvme_admin_set_features,
386 .nsid = TEST_NSID,
387 .cdw10 = NVME_FEAT_FID_ERR_RECOVERY,
388 .cdw11 = 1 << 16 /* DULBE */
389 | TLER,
390 .result = TEST_RESULT,
391 };
392 uint32_t result = 0;
393 int err;
394
395 set_mock_admin_cmds(&mock_admin_cmd, 1);
396 err = nvme_set_features_err_recovery(
397 TEST_FD, TEST_NSID, TLER, true, false, &result);
398 end_mock_cmds();
399 check(err == 0, "set features returned error %d, errno %m", err);
400 check(result == TEST_RESULT,
401 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
402 }
403
404 static void test_get_err_recovery(void)
405 {
406 struct mock_cmd mock_admin_cmd = {
407 .opcode = nvme_admin_get_features,
408 .nsid = TEST_NSID,
409 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_ERR_RECOVERY,
410 .result = TEST_RESULT,
411 };
412 uint32_t result = 0;
413 int err;
414
415 set_mock_admin_cmds(&mock_admin_cmd, 1);
416 err = nvme_get_features_err_recovery2(
417 TEST_FD, TEST_SEL, TEST_NSID, &result);
418 end_mock_cmds();
419 check(err == 0, "get features returned error %d, errno %m", err);
420 check(result == TEST_RESULT,
421 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
422 }
423
424 static void test_set_volatile_wc(void)
425 {
426 struct mock_cmd mock_admin_cmd = {
427 .opcode = nvme_admin_set_features,
428 .cdw10 = (uint32_t)1 << 31 /* SAVE */
429 | NVME_FEAT_FID_VOLATILE_WC,
430 .cdw11 = 1 << 0, /* WCE */
431 .result = TEST_RESULT,
432 };
433 uint32_t result = 0;
434 int err;
435
436 set_mock_admin_cmds(&mock_admin_cmd, 1);
437 err = nvme_set_features_volatile_wc(TEST_FD, true, true, &result);
438 end_mock_cmds();
439 check(err == 0, "set features returned error %d, errno %m", err);
440 check(result == TEST_RESULT,
441 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
442 }
443
444 static void test_get_volatile_wc(void)
445 {
446 struct mock_cmd mock_admin_cmd = {
447 .opcode = nvme_admin_get_features,
448 .cdw10 = TEST_SEL << 8
449 | NVME_FEAT_FID_VOLATILE_WC,
450 .result = TEST_RESULT,
451 };
452 uint32_t result = 0;
453 int err;
454
455 set_mock_admin_cmds(&mock_admin_cmd, 1);
456 err = nvme_get_features_volatile_wc(TEST_FD, TEST_SEL, &result);
457 end_mock_cmds();
458 check(err == 0, "get features returned error %d, errno %m", err);
459 check(result == TEST_RESULT,
460 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
461 }
462
463 static void test_get_num_queues(void)
464 {
465 struct mock_cmd mock_admin_cmd = {
466 .opcode = nvme_admin_get_features,
467 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_NUM_QUEUES,
468 .result = TEST_RESULT,
469 };
470 uint32_t result = 0;
471 int err;
472
473 set_mock_admin_cmds(&mock_admin_cmd, 1);
474 err = nvme_get_features_num_queues(TEST_FD, TEST_SEL, &result);
475 end_mock_cmds();
476 check(err == 0, "get features returned error %d, errno %m", err);
477 check(result == TEST_RESULT,
478 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
479 }
480
481 static void test_set_irq_coalesce(void)
482 {
483 uint8_t THR = 0xAB, TIME = 0xCD;
484 struct mock_cmd mock_admin_cmd = {
485 .opcode = nvme_admin_set_features,
486 .cdw10 = NVME_FEAT_FID_IRQ_COALESCE,
487 .cdw11 = TIME << 8 | THR,
488 .result = TEST_RESULT,
489 };
490 uint32_t result = 0;
491 int err;
492
493 set_mock_admin_cmds(&mock_admin_cmd, 1);
494 err = nvme_set_features_irq_coalesce(
495 TEST_FD, THR, TIME, false, &result);
496 end_mock_cmds();
497 check(err == 0, "set features returned error %d, errno %m", err);
498 check(result == TEST_RESULT,
499 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
500 }
501
502 static void test_get_irq_coalesce(void)
503 {
504 struct mock_cmd mock_admin_cmd = {
505 .opcode = nvme_admin_get_features,
506 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_IRQ_COALESCE,
507 .result = TEST_RESULT,
508 };
509 uint32_t result = 0;
510 int err;
511
512 set_mock_admin_cmds(&mock_admin_cmd, 1);
513 err = nvme_get_features_irq_coalesce(TEST_FD, TEST_SEL, &result);
514 end_mock_cmds();
515 check(err == 0, "get features returned error %d, errno %m", err);
516 check(result == TEST_RESULT,
517 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
518 }
519
520 static void test_set_irq_config(void)
521 {
522 uint16_t IV = 0x1234;
523 struct mock_cmd mock_admin_cmd = {
524 .opcode = nvme_admin_set_features,
525 .cdw10 = (uint32_t)1 << 31 /* SAVE */
526 | NVME_FEAT_FID_IRQ_CONFIG,
527 .cdw11 = 1 << 16 /* CD */
528 | IV,
529 .result = TEST_RESULT,
530 };
531 uint32_t result = 0;
532 int err;
533
534 set_mock_admin_cmds(&mock_admin_cmd, 1);
535 err = nvme_set_features_irq_config(TEST_FD, IV, true, true, &result);
536 end_mock_cmds();
537 check(err == 0, "set features returned error %d, errno %m", err);
538 check(result == TEST_RESULT,
539 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
540 }
541
542 static void test_get_irq_config(void)
543 {
544 uint16_t IV = 0x5678;
545 struct mock_cmd mock_admin_cmd = {
546 .opcode = nvme_admin_get_features,
547 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_IRQ_CONFIG,
548 .cdw11 = IV,
549 .result = TEST_RESULT,
550 };
551 uint32_t result = 0;
552 int err;
553
554 set_mock_admin_cmds(&mock_admin_cmd, 1);
555 err = nvme_get_features_irq_config(TEST_FD, TEST_SEL, IV, &result);
556 end_mock_cmds();
557 check(err == 0, "get features returned error %d, errno %m", err);
558 check(result == TEST_RESULT,
559 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
560 }
561
562 static void test_set_write_atomic(void)
563 {
564 struct mock_cmd mock_admin_cmd = {
565 .opcode = nvme_admin_set_features,
566 .cdw10 = NVME_FEAT_FID_WRITE_ATOMIC,
567 .cdw11 = 1 << 0, /* DN */
568 .result = TEST_RESULT,
569 };
570 uint32_t result = 0;
571 int err;
572
573 set_mock_admin_cmds(&mock_admin_cmd, 1);
574 err = nvme_set_features_write_atomic(TEST_FD, true, false, &result);
575 end_mock_cmds();
576 check(err == 0, "set features returned error %d, errno %m", err);
577 check(result == TEST_RESULT,
578 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
579 }
580
581 static void test_get_write_atomic(void)
582 {
583 struct mock_cmd mock_admin_cmd = {
584 .opcode = nvme_admin_get_features,
585 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_WRITE_ATOMIC,
586 .result = TEST_RESULT,
587 };
588 uint32_t result = 0;
589 int err;
590
591 set_mock_admin_cmds(&mock_admin_cmd, 1);
592 err = nvme_get_features_write_atomic(TEST_FD, TEST_SEL, &result);
593 end_mock_cmds();
594 check(err == 0, "get features returned error %d, errno %m", err);
595 check(result == TEST_RESULT,
596 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
597 }
598
599 static void test_set_async_event(void)
600 {
601 uint32_t EVENTS = 0x87654321;
602 struct mock_cmd mock_admin_cmd = {
603 .opcode = nvme_admin_set_features,
604 .cdw10 = (uint32_t)1 << 31 /* SAVE */
605 | NVME_FEAT_FID_ASYNC_EVENT,
606 .cdw11 = EVENTS,
607 .result = TEST_RESULT,
608 };
609 uint32_t result = 0;
610 int err;
611
612 set_mock_admin_cmds(&mock_admin_cmd, 1);
613 err = nvme_set_features_async_event(TEST_FD, EVENTS, true, &result);
614 end_mock_cmds();
615 check(err == 0, "set features returned error %d, errno %m", err);
616 check(result == TEST_RESULT,
617 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
618 }
619
620 static void test_get_async_event(void)
621 {
622 struct mock_cmd mock_admin_cmd = {
623 .opcode = nvme_admin_get_features,
624 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_ASYNC_EVENT,
625 .result = TEST_RESULT,
626 };
627 uint32_t result = 0;
628 int err;
629
630 set_mock_admin_cmds(&mock_admin_cmd, 1);
631 err = nvme_get_features_async_event(TEST_FD, TEST_SEL, &result);
632 end_mock_cmds();
633 check(err == 0, "get features returned error %d, errno %m", err);
634 check(result == TEST_RESULT,
635 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
636 }
637
638 static void test_set_auto_pst(void)
639 {
640 struct nvme_feat_auto_pst apst;
641 struct mock_cmd mock_admin_cmd = {
642 .opcode = nvme_admin_set_features,
643 .in_data = &apst,
644 .data_len = sizeof(apst),
645 .cdw10 = NVME_FEAT_FID_AUTO_PST,
646 .cdw11 = 1 << 0, /* APSTE */
647 .result = TEST_RESULT,
648 };
649 uint32_t result = 0;
650 int err;
651
652 arbitrary(&apst, sizeof(apst));
653 set_mock_admin_cmds(&mock_admin_cmd, 1);
654 err = nvme_set_features_auto_pst(TEST_FD, true, false, &apst, &result);
655 end_mock_cmds();
656 check(err == 0, "set features returned error %d, errno %m", err);
657 check(result == TEST_RESULT,
658 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
659 }
660
661 static void test_get_auto_pst(void)
662 {
663 struct nvme_feat_auto_pst apst, get_apst = {};
664 struct mock_cmd mock_admin_cmd = {
665 .opcode = nvme_admin_get_features,
666 .data_len = sizeof(apst),
667 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_AUTO_PST,
668 .out_data = &apst,
669 .result = TEST_RESULT,
670 };
671 uint32_t result = 0;
672 int err;
673
674 arbitrary(&apst, sizeof(apst));
675 set_mock_admin_cmds(&mock_admin_cmd, 1);
676 err = nvme_get_features_auto_pst(TEST_FD, TEST_SEL, &get_apst, &result);
677 end_mock_cmds();
678 check(err == 0, "get features returned error %d, errno %m", err);
679 check(result == TEST_RESULT,
680 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
681 cmp(&get_apst, &apst, sizeof(apst), "incorrect apst");
682 }
683
684 static void test_get_host_mem_buf(void)
685 {
686 struct nvme_host_mem_buf_attrs attrs, get_attrs = {};
687 struct mock_cmd mock_admin_cmd = {
688 .opcode = nvme_admin_get_features,
689 .data_len = sizeof(attrs),
690 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_HOST_MEM_BUF,
691 .out_data = &attrs,
692 .result = TEST_RESULT,
693 };
694 uint32_t result = 0;
695 int err;
696
697 arbitrary(&attrs, sizeof(attrs));
698 set_mock_admin_cmds(&mock_admin_cmd, 1);
699 err = nvme_get_features_host_mem_buf2(
700 TEST_FD, TEST_SEL, &get_attrs, &result);
701 end_mock_cmds();
702 check(err == 0, "get features returned error %d, errno %m", err);
703 check(result == TEST_RESULT,
704 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
705 cmp(&get_attrs, &attrs, sizeof(attrs), "incorrect attrs");
706 }
707
708 static void test_set_timestamp(void)
709 {
710 struct nvme_timestamp ts = {.timestamp = {1, 2, 3, 4, 5, 6}};
711 uint64_t timestamp = ts.timestamp[0]
712 | (uint64_t) ts.timestamp[1] << 8
713 | (uint64_t) ts.timestamp[2] << 16
714 | (uint64_t) ts.timestamp[3] << 24
715 | (uint64_t) ts.timestamp[4] << 32
716 | (uint64_t) ts.timestamp[5] << 40;
717 struct mock_cmd mock_admin_cmd = {
718 .opcode = nvme_admin_set_features,
719 .in_data = &ts,
720 .data_len = sizeof(ts),
721 .cdw10 = (uint32_t)1 << 31 /* SAVE */
722 | NVME_FEAT_FID_TIMESTAMP,
723 };
724 int err;
725
726 set_mock_admin_cmds(&mock_admin_cmd, 1);
727 err = nvme_set_features_timestamp(TEST_FD, true, timestamp);
728 end_mock_cmds();
729 check(err == 0, "set features returned error %d, errno %m", err);
730 }
731
732 static void test_get_timestamp(void)
733 {
734 struct nvme_timestamp ts, get_ts = {};
735 struct mock_cmd mock_admin_cmd = {
736 .opcode = nvme_admin_get_features,
737 .data_len = sizeof(ts),
738 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_TIMESTAMP,
739 .out_data = &ts,
740 };
741 int err;
742
743 arbitrary(&ts, sizeof(ts));
744 set_mock_admin_cmds(&mock_admin_cmd, 1);
745 err = nvme_get_features_timestamp(TEST_FD, TEST_SEL, &get_ts);
746 end_mock_cmds();
747 check(err == 0, "get features returned error %d, errno %m", err);
748 cmp(&get_ts, &ts, sizeof(ts), "incorrect timestamp");
749 }
750
751 static void test_get_kato(void)
752 {
753 struct mock_cmd mock_admin_cmd = {
754 .opcode = nvme_admin_get_features,
755 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_KATO,
756 .result = TEST_RESULT,
757 };
758 uint32_t result = 0;
759 int err;
760
761 set_mock_admin_cmds(&mock_admin_cmd, 1);
762 err = nvme_get_features_kato(TEST_FD, TEST_SEL, &result);
763 end_mock_cmds();
764 check(err == 0, "get features returned error %d, errno %m", err);
765 check(result == TEST_RESULT,
766 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
767 }
768
769 static void test_set_hctm(void)
770 {
771 uint16_t TMT2 = 0x4321, TMT1 = 0x8765;
772 struct mock_cmd mock_admin_cmd = {
773 .opcode = nvme_admin_set_features,
774 .cdw10 = NVME_FEAT_FID_HCTM,
775 .cdw11 = (uint32_t)TMT1 << 16 | TMT2,
776 .result = TEST_RESULT,
777 };
778 uint32_t result = 0;
779 int err;
780
781 set_mock_admin_cmds(&mock_admin_cmd, 1);
782 err = nvme_set_features_hctm(TEST_FD, TMT2, TMT1, false, &result);
783 end_mock_cmds();
784 check(err == 0, "set features returned error %d, errno %m", err);
785 check(result == TEST_RESULT,
786 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
787 }
788
789 static void test_get_hctm(void)
790 {
791 struct mock_cmd mock_admin_cmd = {
792 .opcode = nvme_admin_get_features,
793 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_HCTM,
794 .result = TEST_RESULT,
795 };
796 uint32_t result = 0;
797 int err;
798
799 set_mock_admin_cmds(&mock_admin_cmd, 1);
800 err = nvme_get_features_hctm(TEST_FD, TEST_SEL, &result);
801 end_mock_cmds();
802 check(err == 0, "get features returned error %d, errno %m", err);
803 check(result == TEST_RESULT,
804 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
805 }
806
807 static void test_set_nopsc(void)
808 {
809 struct mock_cmd mock_admin_cmd = {
810 .opcode = nvme_admin_set_features,
811 .cdw10 = (uint32_t)1 << 31 /* SAVE */
812 | NVME_FEAT_FID_NOPSC,
813 .cdw11 = 1 << 0 /* NOPPME */,
814 .result = TEST_RESULT,
815 };
816 uint32_t result = 0;
817 int err;
818
819 set_mock_admin_cmds(&mock_admin_cmd, 1);
820 err = nvme_set_features_nopsc(TEST_FD, true, true, &result);
821 end_mock_cmds();
822 check(err == 0, "set features returned error %d, errno %m", err);
823 check(result == TEST_RESULT,
824 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
825 }
826
827 static void test_get_nopsc(void)
828 {
829 struct mock_cmd mock_admin_cmd = {
830 .opcode = nvme_admin_get_features,
831 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_NOPSC,
832 .result = TEST_RESULT,
833 };
834 uint32_t result = 0;
835 int err;
836
837 set_mock_admin_cmds(&mock_admin_cmd, 1);
838 err = nvme_get_features_nopsc(TEST_FD, TEST_SEL, &result);
839 end_mock_cmds();
840 check(err == 0, "get features returned error %d, errno %m", err);
841 check(result == TEST_RESULT,
842 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
843 }
844
845 static void test_set_rrl(void)
846 {
847 uint8_t RRL = 0xA;
848 uint16_t NVMSETID = 0x1234;
849 struct mock_cmd mock_admin_cmd = {
850 .opcode = nvme_admin_set_features,
851 .cdw10 = NVME_FEAT_FID_RRL,
852 .cdw11 = NVMSETID,
853 .cdw12 = RRL,
854 .result = TEST_RESULT,
855 };
856 uint32_t result = 0;
857 int err;
858
859 set_mock_admin_cmds(&mock_admin_cmd, 1);
860 err = nvme_set_features_rrl(TEST_FD, RRL, NVMSETID, false, &result);
861 end_mock_cmds();
862 check(err == 0, "set features returned error %d, errno %m", err);
863 check(result == TEST_RESULT,
864 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
865 }
866
867 static void test_get_rrl(void)
868 {
869 /* nvme_get_features_rrl() doesn't support specifying the NVMSETID */
870 struct mock_cmd mock_admin_cmd = {
871 .opcode = nvme_admin_get_features,
872 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_RRL,
873 .result = TEST_RESULT,
874 };
875 uint32_t result = 0;
876 int err;
877
878 set_mock_admin_cmds(&mock_admin_cmd, 1);
879 err = nvme_get_features_rrl(TEST_FD, TEST_SEL, &result);
880 end_mock_cmds();
881 check(err == 0, "get features returned error %d, errno %m", err);
882 check(result == TEST_RESULT,
883 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
884 }
885
886 static void test_set_plm_config(void)
887 {
888 uint16_t NVMSETID = 0xFEDC;
889 struct nvme_plm_config config;
890 struct mock_cmd mock_admin_cmd = {
891 .opcode = nvme_admin_set_features,
892 .in_data = &config,
893 .data_len = sizeof(config),
894 .cdw10 = (uint32_t)1 << 31 /* SAVE */
895 | NVME_FEAT_FID_PLM_CONFIG,
896 .cdw11 = NVMSETID,
897 .cdw12 = 1 << 0 /* Predictable Latency Enable */,
898 .result = TEST_RESULT,
899 };
900 uint32_t result = 0;
901 int err;
902
903 arbitrary(&config, sizeof(config));
904 set_mock_admin_cmds(&mock_admin_cmd, 1);
905 err = nvme_set_features_plm_config(
906 TEST_FD, true, NVMSETID, true, &config, &result);
907 end_mock_cmds();
908 check(err == 0, "set features returned error %d, errno %m", err);
909 check(result == TEST_RESULT,
910 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
911 }
912
913 static void test_get_plm_config(void)
914 {
915 uint16_t NVMSETID = 0xABCD;
916 struct nvme_plm_config config, get_config = {};
917 struct mock_cmd mock_admin_cmd = {
918 .opcode = nvme_admin_get_features,
919 .data_len = sizeof(config),
920 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_PLM_CONFIG,
921 .cdw11 = NVMSETID,
922 .out_data = &config,
923 .result = TEST_RESULT,
924 };
925 uint32_t result = 0;
926 int err;
927
928 arbitrary(&config, sizeof(config));
929 set_mock_admin_cmds(&mock_admin_cmd, 1);
930 err = nvme_get_features_plm_config(
931 TEST_FD, TEST_SEL, NVMSETID, &get_config, &result);
932 end_mock_cmds();
933 check(err == 0, "get features returned error %d, errno %m", err);
934 check(result == TEST_RESULT,
935 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
936 cmp(&get_config, &config, sizeof(config), "incorrect PLM config");
937 }
938
939 static void test_set_plm_window(void)
940 {
941 enum nvme_feat_plm_window_select SEL = NVME_FEATURE_PLM_NDWIN;
942 uint16_t NVMSETID = 0x4321;
943 struct mock_cmd mock_admin_cmd = {
944 .opcode = nvme_admin_set_features,
945 .cdw10 = NVME_FEAT_FID_PLM_WINDOW,
946 .cdw11 = NVMSETID,
947 .cdw12 = SEL,
948 .result = TEST_RESULT,
949 };
950 uint32_t result = 0;
951 int err;
952
953 set_mock_admin_cmds(&mock_admin_cmd, 1);
954 err = nvme_set_features_plm_window(
955 TEST_FD, SEL, NVMSETID, false, &result);
956 end_mock_cmds();
957 check(err == 0, "set features returned error %d, errno %m", err);
958 check(result == TEST_RESULT,
959 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
960 }
961
962 static void test_get_plm_window(void)
963 {
964 uint16_t NVMSETID = 0x8765;
965 struct mock_cmd mock_admin_cmd = {
966 .opcode = nvme_admin_get_features,
967 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_PLM_WINDOW,
968 .cdw11 = NVMSETID,
969 .result = TEST_RESULT,
970 };
971 uint32_t result = 0;
972 int err;
973
974 set_mock_admin_cmds(&mock_admin_cmd, 1);
975 err = nvme_get_features_plm_window(
976 TEST_FD, TEST_SEL, NVMSETID, &result);
977 end_mock_cmds();
978 check(err == 0, "get features returned error %d, errno %m", err);
979 check(result == TEST_RESULT,
980 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
981 }
982
983 static void test_set_lba_sts_interval(void)
984 {
985 uint16_t LSIRI = 0x1234, LSIPI = 0x5678;
986 struct mock_cmd mock_admin_cmd = {
987 .opcode = nvme_admin_set_features,
988 .cdw10 = (uint32_t)1 << 31 /* SAVE */
989 | NVME_FEAT_FID_LBA_STS_INTERVAL,
990 .cdw11 = LSIPI << 16 | LSIRI,
991 .result = TEST_RESULT,
992 };
993 uint32_t result = 0;
994 int err;
995
996 set_mock_admin_cmds(&mock_admin_cmd, 1);
997 err = nvme_set_features_lba_sts_interval(
998 TEST_FD, LSIRI, LSIPI, true, &result);
999 end_mock_cmds();
1000 check(err == 0, "set features returned error %d, errno %m", err);
1001 check(result == TEST_RESULT,
1002 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1003 }
1004
1005 static void test_get_lba_sts_interval(void)
1006 {
1007 struct mock_cmd mock_admin_cmd = {
1008 .opcode = nvme_admin_get_features,
1009 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_LBA_STS_INTERVAL,
1010 .result = TEST_RESULT,
1011 };
1012 uint32_t result = 0;
1013 int err;
1014
1015 set_mock_admin_cmds(&mock_admin_cmd, 1);
1016 err = nvme_get_features_lba_sts_interval(TEST_FD, TEST_SEL, &result);
1017 end_mock_cmds();
1018 check(err == 0, "get features returned error %d, errno %m", err);
1019 check(result == TEST_RESULT,
1020 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1021 }
1022
1023 static void test_set_host_behavior(void)
1024 {
1025 /* nvme_set_features_host_behavior() ignores SAVE */
1026 struct nvme_feat_host_behavior behavior;
1027 struct mock_cmd mock_admin_cmd = {
1028 .opcode = nvme_admin_set_features,
1029 .in_data = &behavior,
1030 .data_len = sizeof(behavior),
1031 .cdw10 = NVME_FEAT_FID_HOST_BEHAVIOR,
1032 };
1033 int err;
1034
1035 arbitrary(&behavior, sizeof(behavior));
1036 set_mock_admin_cmds(&mock_admin_cmd, 1);
1037 err = nvme_set_features_host_behavior(TEST_FD, true, &behavior);
1038 end_mock_cmds();
1039 check(err == 0, "set features returned error %d, errno %m", err);
1040 }
1041
1042 static void test_get_host_behavior(void)
1043 {
1044 struct nvme_feat_host_behavior behavior, get_behavior = {};
1045 struct mock_cmd mock_admin_cmd = {
1046 .opcode = nvme_admin_get_features,
1047 .data_len = sizeof(behavior),
1048 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_HOST_BEHAVIOR,
1049 .out_data = &behavior,
1050 .result = TEST_RESULT,
1051 };
1052 uint32_t result = 0;
1053 int err;
1054
1055 arbitrary(&behavior, sizeof(behavior));
1056 set_mock_admin_cmds(&mock_admin_cmd, 1);
1057 err = nvme_get_features_host_behavior(
1058 TEST_FD, TEST_SEL, &get_behavior, &result);
1059 end_mock_cmds();
1060 check(err == 0, "get features returned error %d, errno %m", err);
1061 check(result == TEST_RESULT,
1062 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1063 cmp(&get_behavior, &behavior, sizeof(behavior), "incorrect behavior");
1064 }
1065
1066 static void test_set_sanitize(void)
1067 {
1068 struct mock_cmd mock_admin_cmd = {
1069 .opcode = nvme_admin_set_features,
1070 .cdw10 = NVME_FEAT_FID_SANITIZE,
1071 .cdw11 = 1 << 0, /* NODRM */
1072 .result = TEST_RESULT,
1073 };
1074 uint32_t result = 0;
1075 int err;
1076
1077 set_mock_admin_cmds(&mock_admin_cmd, 1);
1078 err = nvme_set_features_sanitize(TEST_FD, true, false, &result);
1079 end_mock_cmds();
1080 check(err == 0, "set features returned error %d, errno %m", err);
1081 check(result == TEST_RESULT,
1082 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1083 }
1084
1085 static void test_get_sanitize(void)
1086 {
1087 struct mock_cmd mock_admin_cmd = {
1088 .opcode = nvme_admin_get_features,
1089 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_SANITIZE,
1090 .result = TEST_RESULT,
1091 };
1092 uint32_t result = 0;
1093 int err;
1094
1095 set_mock_admin_cmds(&mock_admin_cmd, 1);
1096 err = nvme_get_features_sanitize(TEST_FD, TEST_SEL, &result);
1097 end_mock_cmds();
1098 check(err == 0, "get features returned error %d, errno %m", err);
1099 check(result == TEST_RESULT,
1100 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1101 }
1102
1103 static void test_set_endurance_evt_cfg(void)
1104 {
1105 uint16_t ENDGID = 0x9876;
1106 uint8_t EGWARN = 0xCD;
1107 struct mock_cmd mock_admin_cmd = {
1108 .opcode = nvme_admin_set_features,
1109 .cdw10 = (uint32_t)1 << 31 /* SAVE */
1110 | NVME_FEAT_FID_ENDURANCE_EVT_CFG,
1111 .cdw11 = EGWARN << 16 | ENDGID,
1112 .result = TEST_RESULT,
1113 };
1114 uint32_t result = 0;
1115 int err;
1116
1117 set_mock_admin_cmds(&mock_admin_cmd, 1);
1118 err = nvme_set_features_endurance_evt_cfg(
1119 TEST_FD, ENDGID, EGWARN, true, &result);
1120 end_mock_cmds();
1121 check(err == 0, "set features returned error %d, errno %m", err);
1122 check(result == TEST_RESULT,
1123 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1124 }
1125
1126 static void test_get_endurance_event_cfg(void)
1127 {
1128 uint16_t ENDGID = 0x6789;
1129 struct mock_cmd mock_admin_cmd = {
1130 .opcode = nvme_admin_get_features,
1131 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_ENDURANCE_EVT_CFG,
1132 .cdw11 = ENDGID,
1133 .result = TEST_RESULT,
1134 };
1135 uint32_t result = 0;
1136 int err;
1137
1138 set_mock_admin_cmds(&mock_admin_cmd, 1);
1139 err = nvme_get_features_endurance_event_cfg(
1140 TEST_FD, TEST_SEL, ENDGID, &result);
1141 end_mock_cmds();
1142 check(err == 0, "get features returned error %d, errno %m", err);
1143 check(result == TEST_RESULT,
1144 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1145 }
1146
1147 static void test_set_iocs_profile(void)
1148 {
1149 uint16_t IOCSI = 0b101100111;
1150 struct mock_cmd mock_admin_cmd = {
1151 .opcode = nvme_admin_set_features,
1152 .cdw10 = NVME_FEAT_FID_IOCS_PROFILE,
1153 .cdw11 = IOCSI,
1154 };
1155 int err;
1156
1157 set_mock_admin_cmds(&mock_admin_cmd, 1);
1158 err = nvme_set_features_iocs_profile(TEST_FD, IOCSI, false);
1159 end_mock_cmds();
1160 check(err == 0, "set features returned error %d, errno %m", err);
1161 }
1162
1163 static void test_get_iocs_profile(void)
1164 {
1165 struct mock_cmd mock_admin_cmd = {
1166 .opcode = nvme_admin_get_features,
1167 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_IOCS_PROFILE,
1168 .result = TEST_RESULT,
1169 };
1170 uint32_t result = 0;
1171 int err;
1172
1173 set_mock_admin_cmds(&mock_admin_cmd, 1);
1174 err = nvme_get_features_iocs_profile(TEST_FD, TEST_SEL, &result);
1175 end_mock_cmds();
1176 check(err == 0, "get features returned error %d, errno %m", err);
1177 check(result == TEST_RESULT,
1178 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1179 }
1180
1181 static void test_set_sw_progress(void)
1182 {
1183 uint8_t PBSLC = 0xBA;
1184 struct mock_cmd mock_admin_cmd = {
1185 .opcode = nvme_admin_set_features,
1186 .cdw10 = (uint32_t)1 << 31 /* SAVE */
1187 | NVME_FEAT_FID_SW_PROGRESS,
1188 .cdw11 = PBSLC,
1189 .result = TEST_RESULT,
1190 };
1191 uint32_t result = 0;
1192 int err;
1193
1194 set_mock_admin_cmds(&mock_admin_cmd, 1);
1195 err = nvme_set_features_sw_progress(TEST_FD, PBSLC, true, &result);
1196 end_mock_cmds();
1197 check(err == 0, "set features returned error %d, errno %m", err);
1198 check(result == TEST_RESULT,
1199 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1200 }
1201
1202 static void test_get_sw_progress(void)
1203 {
1204 struct mock_cmd mock_admin_cmd = {
1205 .opcode = nvme_admin_get_features,
1206 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_SW_PROGRESS,
1207 .result = TEST_RESULT,
1208 };
1209 uint32_t result = 0;
1210 int err;
1211
1212 set_mock_admin_cmds(&mock_admin_cmd, 1);
1213 err = nvme_get_features_sw_progress(TEST_FD, TEST_SEL, &result);
1214 end_mock_cmds();
1215 check(err == 0, "get features returned error %d, errno %m", err);
1216 check(result == TEST_RESULT,
1217 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1218 }
1219
1220 static void test_set_host_id(void)
1221 {
1222 uint8_t hostid[8];
1223 struct mock_cmd mock_admin_cmd = {
1224 .opcode = nvme_admin_set_features,
1225 .in_data = hostid,
1226 .data_len = sizeof(hostid),
1227 .cdw10 = (uint32_t)1 << 31 /* SAVE */
1228 | NVME_FEAT_FID_HOST_ID,
1229 .result = TEST_RESULT,
1230 };
1231 int err;
1232
1233 arbitrary(hostid, sizeof(hostid));
1234 set_mock_admin_cmds(&mock_admin_cmd, 1);
1235 err = nvme_set_features_host_id(TEST_FD, false, true, hostid);
1236 end_mock_cmds();
1237 check(err == 0, "set features returned error %d, errno %m", err);
1238 }
1239
1240 static void test_set_host_id_extended(void)
1241 {
1242 uint8_t hostid[16];
1243 struct mock_cmd mock_admin_cmd = {
1244 .opcode = nvme_admin_set_features,
1245 .in_data = hostid,
1246 .data_len = sizeof(hostid),
1247 .cdw10 = NVME_FEAT_FID_HOST_ID,
1248 .cdw11 = 1 << 0, /* EXHID */
1249 .result = TEST_RESULT,
1250 };
1251 int err;
1252
1253 arbitrary(hostid, sizeof(hostid));
1254 set_mock_admin_cmds(&mock_admin_cmd, 1);
1255 err = nvme_set_features_host_id(TEST_FD, true, false, hostid);
1256 end_mock_cmds();
1257 check(err == 0, "set features returned error %d, errno %m", err);
1258 }
1259
1260 static void test_get_host_id(void)
1261 {
1262 uint8_t hostid[8], get_hostid[sizeof(hostid)] = {};
1263 struct mock_cmd mock_admin_cmd = {
1264 .opcode = nvme_admin_get_features,
1265 .data_len = sizeof(hostid),
1266 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_HOST_ID,
1267 .out_data = hostid,
1268 .result = TEST_RESULT,
1269 };
1270 int err;
1271
1272 arbitrary(hostid, sizeof(hostid));
1273 set_mock_admin_cmds(&mock_admin_cmd, 1);
1274 err = nvme_get_features_host_id(
1275 TEST_FD, TEST_SEL, false, sizeof(hostid), get_hostid);
1276 end_mock_cmds();
1277 check(err == 0, "get features returned error %d, errno %m", err);
1278 cmp(get_hostid, hostid, sizeof(hostid), "incorrect host identifier");
1279 }
1280
1281 static void test_get_host_id_extended(void)
1282 {
1283 uint8_t hostid[16], get_hostid[sizeof(hostid)] = {};
1284 struct mock_cmd mock_admin_cmd = {
1285 .opcode = nvme_admin_get_features,
1286 .data_len = sizeof(hostid),
1287 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_HOST_ID,
1288 .cdw11 = 1 << 0, /* EXHID */
1289 .out_data = hostid,
1290 .result = TEST_RESULT,
1291 };
1292 int err;
1293
1294 arbitrary(hostid, sizeof(hostid));
1295 set_mock_admin_cmds(&mock_admin_cmd, 1);
1296 err = nvme_get_features_host_id(
1297 TEST_FD, TEST_SEL, true, sizeof(hostid), get_hostid);
1298 end_mock_cmds();
1299 check(err == 0, "get features returned error %d, errno %m", err);
1300 cmp(get_hostid, hostid, sizeof(hostid), "incorrect host identifier");
1301 }
1302
1303 static void test_set_resv_mask(void)
1304 {
1305 uint32_t MASK = 0x23456789;
1306 struct mock_cmd mock_admin_cmd = {
1307 .opcode = nvme_admin_set_features,
1308 .nsid = TEST_NSID,
1309 .cdw10 = (uint32_t)1 << 31 /* SAVE */
1310 | NVME_FEAT_FID_RESV_MASK,
1311 .cdw11 = MASK,
1312 .result = TEST_RESULT,
1313 };
1314 uint32_t result = 0;
1315 int err;
1316
1317 set_mock_admin_cmds(&mock_admin_cmd, 1);
1318 err = nvme_set_features_resv_mask2(
1319 TEST_FD, TEST_NSID, MASK, true, &result);
1320 end_mock_cmds();
1321 check(err == 0, "set features returned error %d, errno %m", err);
1322 check(result == TEST_RESULT,
1323 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1324 }
1325
1326 static void test_get_resv_mask(void)
1327 {
1328 struct mock_cmd mock_admin_cmd = {
1329 .opcode = nvme_admin_get_features,
1330 .nsid = TEST_NSID,
1331 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_RESV_MASK,
1332 .result = TEST_RESULT,
1333 };
1334 uint32_t result = 0;
1335 int err;
1336
1337 set_mock_admin_cmds(&mock_admin_cmd, 1);
1338 err = nvme_get_features_resv_mask2(
1339 TEST_FD, TEST_SEL, TEST_NSID, &result);
1340 end_mock_cmds();
1341 check(err == 0, "get features returned error %d, errno %m", err);
1342 check(result == TEST_RESULT,
1343 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1344 }
1345
1346 static void test_set_resv_persist(void)
1347 {
1348 struct mock_cmd mock_admin_cmd = {
1349 .opcode = nvme_admin_set_features,
1350 .nsid = TEST_NSID,
1351 .cdw10 = NVME_FEAT_FID_RESV_PERSIST,
1352 .cdw11 = 1 << 0, /* PTPL */
1353 .result = TEST_RESULT,
1354 };
1355 uint32_t result = 0;
1356 int err;
1357
1358 set_mock_admin_cmds(&mock_admin_cmd, 1);
1359 err = nvme_set_features_resv_persist2(
1360 TEST_FD, TEST_NSID, true, false, &result);
1361 end_mock_cmds();
1362 check(err == 0, "set features returned error %d, errno %m", err);
1363 check(result == TEST_RESULT,
1364 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1365 }
1366
1367 static void test_get_resv_persist(void)
1368 {
1369 struct mock_cmd mock_admin_cmd = {
1370 .opcode = nvme_admin_get_features,
1371 .nsid = TEST_NSID,
1372 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_RESV_PERSIST,
1373 .result = TEST_RESULT,
1374 };
1375 uint32_t result = 0;
1376 int err;
1377
1378 set_mock_admin_cmds(&mock_admin_cmd, 1);
1379 err = nvme_get_features_resv_persist2(
1380 TEST_FD, TEST_SEL, TEST_NSID, &result);
1381 end_mock_cmds();
1382 check(err == 0, "get features returned error %d, errno %m", err);
1383 check(result == TEST_RESULT,
1384 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1385 }
1386
1387 static void test_set_write_protect(void)
1388 {
1389 /* nvme_set_features_write_protect() ignores SAVE */
1390 enum nvme_feat_nswpcfg_state STATE =
1391 NVME_FEAT_NS_WRITE_PROTECT_PERMANENT;
1392 struct mock_cmd mock_admin_cmd = {
1393 .opcode = nvme_admin_set_features,
1394 .nsid = TEST_NSID,
1395 .cdw10 = NVME_FEAT_FID_WRITE_PROTECT,
1396 .cdw11 = STATE,
1397 .result = TEST_RESULT,
1398 };
1399 uint32_t result = 0;
1400 int err;
1401
1402 set_mock_admin_cmds(&mock_admin_cmd, 1);
1403 err = nvme_set_features_write_protect2(
1404 TEST_FD, TEST_NSID, STATE, true, &result);
1405 end_mock_cmds();
1406 check(err == 0, "set features returned error %d, errno %m", err);
1407 check(result == TEST_RESULT,
1408 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1409 }
1410
1411 static void test_get_write_protect(void)
1412 {
1413 struct mock_cmd mock_admin_cmd = {
1414 .opcode = nvme_admin_get_features,
1415 .nsid = TEST_NSID,
1416 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_WRITE_PROTECT,
1417 .result = TEST_RESULT,
1418 };
1419 uint32_t result = 0;
1420 int err;
1421
1422 set_mock_admin_cmds(&mock_admin_cmd, 1);
1423 err = nvme_get_features_write_protect(
1424 TEST_FD, TEST_NSID, TEST_SEL, &result);
1425 end_mock_cmds();
1426 check(err == 0, "get features returned error %d, errno %m", err);
1427 check(result == TEST_RESULT,
1428 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1429 }
1430
1431 /*
1432 * All set_features functions tail-call nvme_set_features(),
1433 * so testing errors in any of them will do
1434 */
1435
1436 static void test_set_status_code_error(void)
1437 {
1438 uint32_t EVENTS = 0x12345678;
1439 struct mock_cmd mock_admin_cmd = {
1440 .opcode = nvme_admin_set_features,
1441 .cdw10 = NVME_FEAT_FID_ASYNC_EVENT,
1442 .cdw11 = EVENTS,
1443 .result = TEST_RESULT,
1444 .err = TEST_SC,
1445 };
1446 uint32_t result = 0;
1447 int err;
1448
1449 set_mock_admin_cmds(&mock_admin_cmd, 1);
1450 err = nvme_set_features_async_event(TEST_FD, EVENTS, false, &result);
1451 end_mock_cmds();
1452 check(err == TEST_SC, "got error %d, expected %d", err, TEST_SC);
1453 check(result == TEST_RESULT,
1454 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1455 }
1456
1457 static void test_set_kernel_error(void)
1458 {
1459 uint32_t MASK = 0x87654321;
1460 struct mock_cmd mock_admin_cmd = {
1461 .opcode = nvme_admin_set_features,
1462 .nsid = TEST_NSID,
1463 .cdw10 = NVME_FEAT_FID_RESV_MASK,
1464 .cdw11 = MASK,
1465 .result = TEST_RESULT,
1466 .err = -EIO,
1467 };
1468 uint32_t result = 0;
1469 int err;
1470
1471 set_mock_admin_cmds(&mock_admin_cmd, 1);
1472 err = nvme_set_features_resv_mask2(
1473 TEST_FD, TEST_NSID, MASK, false, &result);
1474 end_mock_cmds();
1475 check(err == -1, "got error %d, expected -1", err);
1476 check(errno == EIO, "unexpected error %m");
1477 check(!result, "result unexpectedly set to %" PRIu32, result);
1478 }
1479
1480 /*
1481 * All get_features functions tail-call nvme_get_features(),
1482 * so testing errors in any of them will do
1483 */
1484
1485 static void test_get_status_code_error(void)
1486 {
1487 struct mock_cmd mock_admin_cmd = {
1488 .opcode = nvme_admin_get_features,
1489 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_KATO,
1490 .result = TEST_RESULT,
1491 .err = TEST_SC,
1492 };
1493 uint32_t result = 0;
1494 int err;
1495
1496 set_mock_admin_cmds(&mock_admin_cmd, 1);
1497 err = nvme_get_features_kato(TEST_FD, TEST_SEL, &result);
1498 end_mock_cmds();
1499 check(err == TEST_SC, "got error %d, expected %d", err, TEST_SC);
1500 check(result == TEST_RESULT,
1501 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1502 }
1503
1504 static void test_get_kernel_error(void)
1505 {
1506 struct mock_cmd mock_admin_cmd = {
1507 .opcode = nvme_admin_get_features,
1508 .cdw10 = TEST_SEL << 8 | NVME_FEAT_FID_NUM_QUEUES,
1509 .result = TEST_RESULT,
1510 .err = -EBUSY,
1511 };
1512 uint32_t result = 0;
1513 int err;
1514
1515 set_mock_admin_cmds(&mock_admin_cmd, 1);
1516 err = nvme_get_features_num_queues(TEST_FD, TEST_SEL, &result);
1517 end_mock_cmds();
1518 check(err == -1, "got error %d, expected -1", err);
1519 check(errno == EBUSY, "unexpected error %m");
1520 check(!result, "result unexpectedly set to %" PRIu32, result);
1521 }
1522
1523 static void test_lm_set_features_ctrl_data_queue(void)
1524 {
1525 __u32 hp = 0x12, tpt = 0x34;
1526 bool etpt = true;
1527 struct mock_cmd mock_admin_cmd = {
1528 .opcode = nvme_admin_set_features,
1529 .nsid = NVME_NSID_NONE,
1530 .cdw10 = NVME_FEAT_FID_CTRL_DATA_QUEUE,
1531 .cdw11 = TEST_CDQID | etpt << 31,
1532 .cdw12 = hp,
1533 .cdw13 = tpt,
1534 .result = TEST_RESULT,
1535 };
1536 uint32_t result = 0;
1537 int err;
1538
1539 set_mock_admin_cmds(&mock_admin_cmd, 1);
1540 err = nvme_lm_set_features_ctrl_data_queue(TEST_FD, TEST_CDQID, hp, tpt,
1541 etpt, &result);
1542 end_mock_cmds();
1543 check(err == 0, "set features returned error %d, errno %m", err);
1544 check(result == TEST_RESULT,
1545 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1546 }
1547
1548 static void test_lm_get_features_ctrl_data_queue(void)
1549 {
1550 struct nvme_lm_ctrl_data_queue_fid_data expected_data, data = {};
1551 struct mock_cmd mock_admin_cmd = {
1552 .opcode = nvme_admin_get_features,
1553 .nsid = NVME_NSID_NONE,
1554 .cdw10 = NVME_FEAT_FID_CTRL_DATA_QUEUE,
1555 .cdw11 = TEST_CDQID,
1556 .data_len = sizeof(expected_data),
1557 .out_data = &expected_data,
1558 .result = TEST_RESULT,
1559 };
1560 uint32_t result = 0;
1561 int err;
1562
1563 arbitrary(&expected_data, sizeof(expected_data));
1564 set_mock_admin_cmds(&mock_admin_cmd, 1);
1565 err = nvme_lm_get_features_ctrl_data_queue(TEST_FD, TEST_CDQID, &data,
1566 &result);
1567 end_mock_cmds();
1568 check(err == 0, "get features returned error %d, errno %m", err);
1569 check(result == TEST_RESULT,
1570 "got result %" PRIu32 ", expected %" PRIu32, result, TEST_RESULT);
1571 cmp(&data, &expected_data, sizeof(data), "incorrect data");
1572 }
1573
1574 static void run_test(const char *test_name, void (*test_fn)(void))
1575 {
1576 printf("Running test %s...", test_name);
1577 fflush(stdout);
1578 test_fn();
1579 puts(" OK");
1580 }
1581
1582 #define RUN_TEST(name) run_test(#name, test_ ## name)
1583
1584 int main(void)
1585 {
1586 set_mock_fd(TEST_FD);
1587 RUN_TEST(set_features);
1588 RUN_TEST(get_features);
1589 RUN_TEST(set_features_data);
1590 RUN_TEST(get_features_data);
1591 RUN_TEST(set_features_simple);
1592 RUN_TEST(get_features_simple);
1593 RUN_TEST(set_arbitration);
1594 RUN_TEST(get_arbitration);
1595 RUN_TEST(set_power_mgmt);
1596 RUN_TEST(get_power_mgmt);
1597 RUN_TEST(set_lba_range);
1598 RUN_TEST(get_lba_range);
1599 RUN_TEST(set_temp_thresh);
1600 RUN_TEST(get_temp_thresh);
1601 RUN_TEST(set_err_recovery);
1602 RUN_TEST(get_err_recovery);
1603 RUN_TEST(set_volatile_wc);
1604 RUN_TEST(get_volatile_wc);
1605 RUN_TEST(get_num_queues);
1606 RUN_TEST(set_irq_coalesce);
1607 RUN_TEST(get_irq_coalesce);
1608 RUN_TEST(set_irq_config);
1609 RUN_TEST(get_irq_config);
1610 RUN_TEST(set_write_atomic);
1611 RUN_TEST(get_write_atomic);
1612 RUN_TEST(set_async_event);
1613 RUN_TEST(get_async_event);
1614 RUN_TEST(set_auto_pst);
1615 RUN_TEST(get_auto_pst);
1616 RUN_TEST(get_host_mem_buf);
1617 RUN_TEST(set_timestamp);
1618 RUN_TEST(get_timestamp);
1619 RUN_TEST(get_kato);
1620 RUN_TEST(set_hctm);
1621 RUN_TEST(get_hctm);
1622 RUN_TEST(set_nopsc);
1623 RUN_TEST(get_nopsc);
1624 RUN_TEST(set_rrl);
1625 RUN_TEST(get_rrl);
1626 RUN_TEST(set_plm_config);
1627 RUN_TEST(get_plm_config);
1628 RUN_TEST(set_plm_window);
1629 RUN_TEST(get_plm_window);
1630 RUN_TEST(set_lba_sts_interval);
1631 RUN_TEST(get_lba_sts_interval);
1632 RUN_TEST(set_host_behavior);
1633 RUN_TEST(get_host_behavior);
1634 RUN_TEST(set_sanitize);
1635 RUN_TEST(get_sanitize);
1636 RUN_TEST(set_endurance_evt_cfg);
1637 RUN_TEST(get_endurance_event_cfg);
1638 RUN_TEST(set_iocs_profile);
1639 RUN_TEST(get_iocs_profile);
1640 RUN_TEST(set_sw_progress);
1641 RUN_TEST(get_sw_progress);
1642 RUN_TEST(set_host_id);
1643 RUN_TEST(set_host_id_extended);
1644 RUN_TEST(get_host_id);
1645 RUN_TEST(get_host_id_extended);
1646 RUN_TEST(set_resv_mask);
1647 RUN_TEST(get_resv_mask);
1648 RUN_TEST(set_resv_persist);
1649 RUN_TEST(get_resv_persist);
1650 RUN_TEST(set_write_protect);
1651 RUN_TEST(get_write_protect);
1652 RUN_TEST(set_status_code_error);
1653 RUN_TEST(set_kernel_error);
1654 RUN_TEST(get_status_code_error);
1655 RUN_TEST(get_kernel_error);
1656 RUN_TEST(lm_set_features_ctrl_data_queue);
1657 RUN_TEST(lm_get_features_ctrl_data_queue);
1658 }