Debian Codegraph @

test/ioctl/logs.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/ioctl.h>
8 #include <nvme/types.h>
9
10 #define TEST_FD 0xFD
11 #define TEST_NSID 0x12345678
12 #define TEST_NVMSETID 0xABCD
13 #define TEST_CSI NVME_CSI_KV
14 #define TEST_CNTID 0x4321
15 #define TEST_DOMID 0xFEDC
16 #define TEST_ENDGID 0x0123
17 #define TEST_RAE true
18 #define TEST_MCDA NVME_TELEMETRY_DA_3
19 #define TEST_OFFSET 0xFFFFFFFF1
20 #define TEST_OFFSET_32 0xFFFFFFFF
21 #define TEST_EVENTS true
22 #define TEST_ANA_LSP NVME_LOG_ANA_LSP_RGO_NAMESPACES
23 #define TEST_LSP NVME_LOG_CDW10_LSP_MASK
24 #define TEST_PEVENT NVME_PEVENT_LOG_RELEASE_CTX
25
26 static void test_get_log_sanitize(void)
27 {
28 struct nvme_sanitize_log_page expected_log, log = {};
29 struct mock_cmd mock_admin_cmd = {
30 .opcode = nvme_admin_get_log_page,
31 .nsid = NVME_NSID_ALL,
32 .data_len = sizeof(expected_log),
33 .cdw10 = (NVME_LOG_LID_SANITIZE << 0) | (!!TEST_RAE << 15) |
34 (((sizeof(expected_log) >> 2) - 1) << 16),
35 .out_data = &expected_log,
36 };
37 int err;
38
39 arbitrary(&expected_log, sizeof(expected_log));
40 set_mock_admin_cmds(&mock_admin_cmd, 1);
41 err = nvme_get_log_sanitize(TEST_FD, true, &log);
42 end_mock_cmds();
43 check(err == 0, "get log returned error %d, errno %m", err);
44 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
45 }
46
47 static void test_get_log_mgmt_addr_list(void)
48 {
49 struct nvme_mgmt_addr_list_log expected_log, log = {};
50 struct mock_cmd mock_admin_cmd = {
51 .opcode = nvme_admin_get_log_page,
52 .nsid = NVME_NSID_ALL,
53 .data_len = sizeof(expected_log),
54 .cdw10 = (NVME_LOG_LID_MGMT_ADDR_LIST << 0) |
55 (((sizeof(expected_log) >> 2) - 1) << 16),
56 .out_data = &expected_log,
57 };
58 int err;
59
60 arbitrary(&expected_log, sizeof(expected_log));
61 set_mock_admin_cmds(&mock_admin_cmd, 1);
62 err = nvme_get_log_mgmt_addr_list(TEST_FD, sizeof(log), &log);
63 end_mock_cmds();
64 check(err == 0, "get log returned error %d, errno %m", err);
65 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
66 }
67
68 static void test_get_log_supported_log_pages(void)
69 {
70 struct nvme_supported_log_pages expected_log, log = {};
71 struct mock_cmd mock_admin_cmd = {
72 .opcode = nvme_admin_get_log_page,
73 .nsid = NVME_NSID_ALL,
74 .data_len = sizeof(expected_log),
75 .cdw10 = (NVME_LOG_LID_SUPPORTED_LOG_PAGES << 0) |
76 (!TEST_RAE << 15) |
77 (((sizeof(expected_log) >> 2) - 1) << 16),
78 .out_data = &expected_log,
79 };
80 int err;
81
82 arbitrary(&expected_log, sizeof(expected_log));
83 set_mock_admin_cmds(&mock_admin_cmd, 1);
84 err = nvme_get_log_supported_log_pages(TEST_FD, !TEST_RAE, &log);
85 end_mock_cmds();
86 check(err == 0, "get log returned error %d, errno %m", err);
87 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
88 }
89
90 static void test_get_log_error(void)
91 {
92 struct nvme_error_log_page expected_log, log = {};
93 struct mock_cmd mock_admin_cmd = {
94 .opcode = nvme_admin_get_log_page,
95 .nsid = NVME_NSID_ALL,
96 .data_len = sizeof(expected_log),
97 .cdw10 = (NVME_LOG_LID_ERROR << 0) | (!!TEST_RAE << 15) |
98 (((sizeof(expected_log) >> 2) - 1) << 16),
99 .out_data = &expected_log,
100 };
101 int err;
102
103 arbitrary(&expected_log, sizeof(expected_log));
104 set_mock_admin_cmds(&mock_admin_cmd, 1);
105 err = nvme_get_log_error(TEST_FD, 1, TEST_RAE, &log);
106 end_mock_cmds();
107 check(err == 0, "get log returned error %d, errno %m", err);
108 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
109 }
110
111 static void test_get_log_smart(void)
112 {
113 struct nvme_smart_log expected_log, log = {};
114 struct mock_cmd mock_admin_cmd = {
115 .opcode = nvme_admin_get_log_page,
116 .nsid = TEST_NSID,
117 .data_len = sizeof(expected_log),
118 .cdw10 = (NVME_LOG_LID_SMART << 0) | (!!TEST_RAE << 15) |
119 (((sizeof(expected_log) >> 2) - 1) << 16),
120 .out_data = &expected_log,
121 };
122 int err;
123
124 arbitrary(&expected_log, sizeof(expected_log));
125 set_mock_admin_cmds(&mock_admin_cmd, 1);
126 err = nvme_get_log_smart(TEST_FD, TEST_NSID, TEST_RAE, &log);
127 end_mock_cmds();
128 check(err == 0, "get log returned error %d, errno %m", err);
129 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
130 }
131
132 static void test_get_log_fw_slot(void)
133 {
134 struct nvme_firmware_slot expected_log, log = {};
135 struct mock_cmd mock_admin_cmd = {
136 .opcode = nvme_admin_get_log_page,
137 .nsid = NVME_NSID_ALL,
138 .data_len = sizeof(expected_log),
139 .cdw10 = (NVME_LOG_LID_FW_SLOT << 0) | (!!TEST_RAE << 15) |
140 (((sizeof(expected_log) >> 2) - 1) << 16),
141 .out_data = &expected_log,
142 };
143 int err;
144
145 arbitrary(&expected_log, sizeof(expected_log));
146 set_mock_admin_cmds(&mock_admin_cmd, 1);
147 err = nvme_get_log_fw_slot(TEST_FD, TEST_RAE, &log);
148 end_mock_cmds();
149 check(err == 0, "get log returned error %d, errno %m", err);
150 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
151 }
152
153 static void test_get_log_changed_ns_list(void)
154 {
155 struct nvme_ns_list expected_log, log = {};
156 struct mock_cmd mock_admin_cmd = {
157 .opcode = nvme_admin_get_log_page,
158 .nsid = NVME_NSID_ALL,
159 .data_len = sizeof(expected_log),
160 .cdw10 = (NVME_LOG_LID_CHANGED_NS << 0) | (!!TEST_RAE << 15) |
161 (((sizeof(expected_log) >> 2) - 1) << 16),
162 .out_data = &expected_log,
163 };
164 int err;
165
166 arbitrary(&expected_log, sizeof(expected_log));
167 set_mock_admin_cmds(&mock_admin_cmd, 1);
168 err = nvme_get_log_changed_ns_list(TEST_FD, TEST_RAE, &log);
169 end_mock_cmds();
170 check(err == 0, "get log returned error %d, errno %m", err);
171 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
172 }
173
174 static void test_get_log_cmd_effects(void)
175 {
176 struct nvme_cmd_effects_log expected_log, log = {};
177 struct mock_cmd mock_admin_cmd = {
178 .opcode = nvme_admin_get_log_page,
179 .nsid = NVME_NSID_ALL,
180 .data_len = sizeof(expected_log),
181 .cdw10 = (NVME_LOG_LID_CMD_EFFECTS << 0) |
182 (((sizeof(expected_log) >> 2) - 1) << 16),
183 .cdw14 = (TEST_CSI << 24),
184 .out_data = &expected_log,
185 };
186 int err;
187
188 arbitrary(&expected_log, sizeof(expected_log));
189 set_mock_admin_cmds(&mock_admin_cmd, 1);
190 err = nvme_get_log_cmd_effects(TEST_FD, TEST_CSI, &log);
191 end_mock_cmds();
192 check(err == 0, "get log returned error %d, errno %m", err);
193 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
194 }
195
196 static void test_get_log_device_self_test(void)
197 {
198 struct nvme_self_test_log expected_log, log = {};
199 struct mock_cmd mock_admin_cmd = {
200 .opcode = nvme_admin_get_log_page,
201 .nsid = NVME_NSID_ALL,
202 .data_len = sizeof(expected_log),
203 .cdw10 = (NVME_LOG_LID_DEVICE_SELF_TEST << 0) |
204 (((sizeof(expected_log) >> 2) - 1) << 16),
205 .out_data = &expected_log,
206 };
207 int err;
208
209 arbitrary(&expected_log, sizeof(expected_log));
210 set_mock_admin_cmds(&mock_admin_cmd, 1);
211 err = nvme_get_log_device_self_test(TEST_FD, &log);
212 end_mock_cmds();
213 check(err == 0, "get log returned error %d, errno %m", err);
214 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
215 }
216
217 static void test_get_log_create_telemetry_host_mcda(void)
218 {
219 struct nvme_telemetry_log expected_log, log = {};
220 struct mock_cmd mock_admin_cmd = {
221 .opcode = nvme_admin_get_log_page,
222 .nsid = NVME_NSID_NONE,
223 .data_len = sizeof(expected_log),
224 .cdw10 = (NVME_LOG_LID_TELEMETRY_HOST << 0) |
225 (((TEST_MCDA << 1) | NVME_LOG_TELEM_HOST_LSP_CREATE)
226 << 8) |
227 (((sizeof(expected_log) >> 2) - 1) << 16),
228 .out_data = &expected_log,
229 };
230 int err;
231
232 arbitrary(&expected_log, sizeof(expected_log));
233 set_mock_admin_cmds(&mock_admin_cmd, 1);
234 err = nvme_get_log_create_telemetry_host_mcda(TEST_FD, TEST_MCDA, &log);
235 end_mock_cmds();
236 check(err == 0, "get log returned error %d, errno %m", err);
237 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
238 }
239
240 static void test_get_log_create_telemetry_host(void)
241 {
242 struct nvme_telemetry_log expected_log, log = {};
243 struct mock_cmd mock_admin_cmd = {
244 .opcode = nvme_admin_get_log_page,
245 .nsid = NVME_NSID_NONE,
246 .data_len = sizeof(expected_log),
247 .cdw10 = (NVME_LOG_LID_TELEMETRY_HOST << 0) |
248 (((NVME_TELEMETRY_DA_CTRL_DETERMINE << 1) |
249 NVME_LOG_TELEM_HOST_LSP_CREATE)
250 << 8) |
251 (((sizeof(expected_log) >> 2) - 1) << 16),
252 .out_data = &expected_log,
253 };
254 int err;
255
256 arbitrary(&expected_log, sizeof(expected_log));
257 set_mock_admin_cmds(&mock_admin_cmd, 1);
258 err = nvme_get_log_create_telemetry_host(TEST_FD, &log);
259 end_mock_cmds();
260 check(err == 0, "get log returned error %d, errno %m", err);
261 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
262 }
263
264 static void test_get_log_telemetry_host(void)
265 {
266 struct nvme_telemetry_log expected_log, log = {};
267 struct mock_cmd mock_admin_cmd = {
268 .opcode = nvme_admin_get_log_page,
269 .nsid = NVME_NSID_NONE,
270 .data_len = sizeof(expected_log),
271 .cdw10 = (NVME_LOG_LID_TELEMETRY_HOST << 0) |
272 (((NVME_TELEMETRY_DA_CTRL_DETERMINE << 1) |
273 NVME_LOG_TELEM_HOST_LSP_RETAIN)
274 << 8) |
275 (((sizeof(expected_log) >> 2) - 1) << 16),
276 .cdw12 = TEST_OFFSET & 0xffffffff,
277 .cdw13 = TEST_OFFSET >> 32,
278 .out_data = &expected_log,
279 };
280 int err;
281
282 arbitrary(&expected_log, sizeof(expected_log));
283 set_mock_admin_cmds(&mock_admin_cmd, 1);
284 err = nvme_get_log_telemetry_host(TEST_FD, TEST_OFFSET, sizeof(log),
285 &log);
286 end_mock_cmds();
287 check(err == 0, "get log returned error %d, errno %m", err);
288 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
289 }
290
291 static void test_get_log_telemetry_ctrl(void)
292 {
293 struct nvme_telemetry_log expected_log, log = {};
294 struct mock_cmd mock_admin_cmd = {
295 .opcode = nvme_admin_get_log_page,
296 .nsid = NVME_NSID_NONE,
297 .data_len = sizeof(expected_log),
298 .cdw10 = (NVME_LOG_LID_TELEMETRY_CTRL << 0) |
299 (((NVME_TELEMETRY_DA_CTRL_DETERMINE << 1) |
300 NVME_LOG_TELEM_HOST_LSP_RETAIN)
301 << 8) |
302 (!!TEST_RAE << 15) |
303 (((sizeof(expected_log) >> 2) - 1) << 16),
304 .cdw12 = TEST_OFFSET & 0xffffffff,
305 .cdw13 = TEST_OFFSET >> 32,
306 .out_data = &expected_log,
307 };
308 int err;
309
310 arbitrary(&expected_log, sizeof(expected_log));
311 set_mock_admin_cmds(&mock_admin_cmd, 1);
312 err = nvme_get_log_telemetry_ctrl(TEST_FD, TEST_RAE, TEST_OFFSET,
313 sizeof(log), &log);
314 end_mock_cmds();
315 check(err == 0, "get log returned error %d, errno %m", err);
316 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
317 }
318
319 static void test_get_log_endurance_group(void)
320 {
321 struct nvme_endurance_group_log expected_log, log = {};
322 struct mock_cmd mock_admin_cmd = {
323 .opcode = nvme_admin_get_log_page,
324 .nsid = NVME_NSID_NONE,
325 .data_len = sizeof(expected_log),
326 .cdw10 = (NVME_LOG_LID_ENDURANCE_GROUP << 0) |
327 (((sizeof(expected_log) >> 2) - 1) << 16),
328 .cdw11 = (TEST_ENDGID << 16),
329 .out_data = &expected_log,
330 };
331 int err;
332
333 arbitrary(&expected_log, sizeof(expected_log));
334 set_mock_admin_cmds(&mock_admin_cmd, 1);
335 err = nvme_get_log_endurance_group(TEST_FD, TEST_ENDGID, &log);
336 end_mock_cmds();
337 check(err == 0, "get log returned error %d, errno %m", err);
338 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
339 }
340
341 static void test_get_log_predictable_lat_nvmset(void)
342 {
343 struct nvme_nvmset_predictable_lat_log expected_log, log = {};
344 struct mock_cmd mock_admin_cmd = {
345 .opcode = nvme_admin_get_log_page,
346 .nsid = NVME_NSID_NONE,
347 .data_len = sizeof(expected_log),
348 .cdw10 = (NVME_LOG_LID_PREDICTABLE_LAT_NVMSET << 0) |
349 (((sizeof(expected_log) >> 2) - 1) << 16),
350 .cdw11 = (TEST_NVMSETID << 16),
351 .out_data = &expected_log,
352 };
353 int err;
354
355 arbitrary(&expected_log, sizeof(expected_log));
356 set_mock_admin_cmds(&mock_admin_cmd, 1);
357 err = nvme_get_log_predictable_lat_nvmset(TEST_FD, TEST_NVMSETID, &log);
358 end_mock_cmds();
359 check(err == 0, "get log returned error %d, errno %m", err);
360 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
361 }
362
363 static void test_get_log_predictable_lat_event(void)
364 {
365 __u8 expected_log[32], log[32] = {};
366 struct mock_cmd mock_admin_cmd = {
367 .opcode = nvme_admin_get_log_page,
368 .nsid = NVME_NSID_NONE,
369 .data_len = sizeof(expected_log),
370 .cdw10 = (NVME_LOG_LID_PREDICTABLE_LAT_AGG << 0) |
371 (!!TEST_RAE << 15) |
372 (((sizeof(expected_log) >> 2) - 1) << 16),
373 .cdw12 = TEST_OFFSET_32,
374 .out_data = &expected_log,
375 };
376 int err;
377
378 arbitrary(&expected_log, sizeof(expected_log));
379 set_mock_admin_cmds(&mock_admin_cmd, 1);
380 err = nvme_get_log_predictable_lat_event(
381 TEST_FD, TEST_RAE, TEST_OFFSET_32, sizeof(log), &log);
382 end_mock_cmds();
383 check(err == 0, "get log returned error %d, errno %m", err);
384 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
385 }
386
387 static void test_get_log_fdp_configurations(void)
388 {
389 __u8 expected_log[32], log[32] = {};
390 struct mock_cmd mock_admin_cmd = {
391 .opcode = nvme_admin_get_log_page,
392 .nsid = NVME_NSID_NONE,
393 .data_len = sizeof(expected_log),
394 .cdw10 = (NVME_LOG_LID_FDP_CONFIGS << 0) |
395 (((sizeof(expected_log) >> 2) - 1) << 16),
396 .cdw11 = (TEST_ENDGID << 16),
397 .cdw12 = TEST_OFFSET_32,
398 .out_data = &expected_log,
399 };
400 int err;
401
402 arbitrary(&expected_log, sizeof(expected_log));
403 set_mock_admin_cmds(&mock_admin_cmd, 1);
404 err = nvme_get_log_fdp_configurations(
405 TEST_FD, TEST_ENDGID, TEST_OFFSET_32, sizeof(log), &log);
406 end_mock_cmds();
407 check(err == 0, "get log returned error %d, errno %m", err);
408 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
409 }
410
411 static void test_get_log_reclaim_unit_handle_usage(void)
412 {
413 __u8 expected_log[32], log[32] = {};
414 struct mock_cmd mock_admin_cmd = {
415 .opcode = nvme_admin_get_log_page,
416 .nsid = NVME_NSID_NONE,
417 .data_len = sizeof(expected_log),
418 .cdw10 = (NVME_LOG_LID_FDP_RUH_USAGE << 0) |
419 (((sizeof(expected_log) >> 2) - 1) << 16),
420 .cdw11 = (TEST_ENDGID << 16),
421 .cdw12 = TEST_OFFSET_32,
422 .out_data = &expected_log,
423 };
424 int err;
425
426 arbitrary(&expected_log, sizeof(expected_log));
427 set_mock_admin_cmds(&mock_admin_cmd, 1);
428 err = nvme_get_log_reclaim_unit_handle_usage(
429 TEST_FD, TEST_ENDGID, TEST_OFFSET_32, sizeof(log), &log);
430 end_mock_cmds();
431 check(err == 0, "get log returned error %d, errno %m", err);
432 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
433 }
434
435 static void test_get_log_fdp_stats(void)
436 {
437 __u8 expected_log[32], log[32] = {};
438 struct mock_cmd mock_admin_cmd = {
439 .opcode = nvme_admin_get_log_page,
440 .nsid = NVME_NSID_NONE,
441 .data_len = sizeof(expected_log),
442 .cdw10 = (NVME_LOG_LID_FDP_STATS << 0) |
443 (((sizeof(expected_log) >> 2) - 1) << 16),
444 .cdw11 = (TEST_ENDGID << 16),
445 .cdw12 = TEST_OFFSET_32,
446 .out_data = &expected_log,
447 };
448 int err;
449
450 arbitrary(&expected_log, sizeof(expected_log));
451 set_mock_admin_cmds(&mock_admin_cmd, 1);
452 err = nvme_get_log_fdp_stats(TEST_FD, TEST_ENDGID, TEST_OFFSET_32,
453 sizeof(log), &log);
454 end_mock_cmds();
455 check(err == 0, "get log returned error %d, errno %m", err);
456 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
457 }
458
459 static void test_get_log_fdp_events(void)
460 {
461 __u8 expected_log[32], log[32] = {};
462 struct mock_cmd mock_admin_cmd = {
463 .opcode = nvme_admin_get_log_page,
464 .nsid = NVME_NSID_NONE,
465 .data_len = sizeof(expected_log),
466 .cdw10 = (NVME_LOG_LID_FDP_EVENTS << 0) |
467 (TEST_EVENTS ? 0x1 : 0x0) << 8 |
468 (((sizeof(expected_log) >> 2) - 1) << 16),
469 .cdw11 = (TEST_ENDGID << 16),
470 .cdw12 = TEST_OFFSET_32,
471 .out_data = &expected_log,
472 };
473 int err;
474
475 arbitrary(&expected_log, sizeof(expected_log));
476 set_mock_admin_cmds(&mock_admin_cmd, 1);
477 err = nvme_get_log_fdp_events(TEST_FD, TEST_ENDGID, TEST_EVENTS,
478 TEST_OFFSET_32, sizeof(log), &log);
479 end_mock_cmds();
480 check(err == 0, "get log returned error %d, errno %m", err);
481 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
482 }
483
484 static void test_get_log_ana(void)
485 {
486 struct nvme_ana_log expected_log, log = {};
487 struct mock_cmd mock_admin_cmd = {
488 .opcode = nvme_admin_get_log_page,
489 .nsid = NVME_NSID_NONE,
490 .data_len = sizeof(expected_log),
491 .cdw10 = (NVME_LOG_LID_ANA << 0) | (TEST_ANA_LSP << 8) |
492 (!!TEST_RAE << 15) |
493 (((sizeof(expected_log) >> 2) - 1) << 16),
494 .cdw12 = TEST_OFFSET & 0xffffffff,
495 .cdw13 = TEST_OFFSET >> 32,
496 .out_data = &expected_log,
497 };
498 int err;
499
500 arbitrary(&expected_log, sizeof(expected_log));
501 set_mock_admin_cmds(&mock_admin_cmd, 1);
502 err = nvme_get_log_ana(TEST_FD, TEST_ANA_LSP, TEST_RAE, TEST_OFFSET,
503 sizeof(log), &log);
504 end_mock_cmds();
505 check(err == 0, "get log returned error %d, errno %m", err);
506 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
507 }
508
509 static void test_get_log_ana_groups(void)
510 {
511 struct nvme_ana_log expected_log, log = {};
512 struct mock_cmd mock_admin_cmd = {
513 .opcode = nvme_admin_get_log_page,
514 .nsid = NVME_NSID_NONE,
515 .data_len = sizeof(expected_log),
516 .cdw10 = (NVME_LOG_LID_ANA << 0) |
517 (NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8) |
518 (!!TEST_RAE << 15) |
519 (((sizeof(expected_log) >> 2) - 1) << 16),
520 .out_data = &expected_log,
521 };
522 int err;
523
524 arbitrary(&expected_log, sizeof(expected_log));
525 set_mock_admin_cmds(&mock_admin_cmd, 1);
526 err = nvme_get_log_ana_groups(TEST_FD, TEST_RAE, sizeof(log), &log);
527 end_mock_cmds();
528 check(err == 0, "get log returned error %d, errno %m", err);
529 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
530 }
531
532 static void test_get_log_lba_status(void)
533 {
534 __u8 expected_log[32], log[32] = {};
535 struct mock_cmd mock_admin_cmd = {
536 .opcode = nvme_admin_get_log_page,
537 .nsid = NVME_NSID_NONE,
538 .data_len = sizeof(expected_log),
539 .cdw10 = (NVME_LOG_LID_LBA_STATUS << 0) | (!!TEST_RAE << 15) |
540 (((sizeof(expected_log) >> 2) - 1) << 16),
541 .cdw12 = TEST_OFFSET & 0xffffffff,
542 .cdw13 = TEST_OFFSET >> 32,
543 .out_data = &expected_log,
544 };
545 int err;
546
547 arbitrary(&expected_log, sizeof(expected_log));
548 set_mock_admin_cmds(&mock_admin_cmd, 1);
549 err = nvme_get_log_lba_status(TEST_FD, TEST_RAE, TEST_OFFSET,
550 sizeof(log), &log);
551 end_mock_cmds();
552 check(err == 0, "get log returned error %d, errno %m", err);
553 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
554 }
555
556 static void test_get_log_endurance_grp_evt(void)
557 {
558 __u8 expected_log[32], log[32] = {};
559 struct mock_cmd mock_admin_cmd = {
560 .opcode = nvme_admin_get_log_page,
561 .nsid = NVME_NSID_NONE,
562 .data_len = sizeof(expected_log),
563 .cdw10 = (NVME_LOG_LID_ENDURANCE_GRP_EVT << 0) |
564 (!!TEST_RAE << 15) |
565 (((sizeof(expected_log) >> 2) - 1) << 16),
566 .cdw12 = TEST_OFFSET_32,
567 .out_data = &expected_log,
568 };
569 int err;
570
571 arbitrary(&expected_log, sizeof(expected_log));
572 set_mock_admin_cmds(&mock_admin_cmd, 1);
573 err = nvme_get_log_endurance_grp_evt(TEST_FD, TEST_RAE, TEST_OFFSET_32,
574 sizeof(log), &log);
575 end_mock_cmds();
576 check(err == 0, "get log returned error %d, errno %m", err);
577 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
578 }
579
580 static void test_get_log_fid_supported_effects(void)
581 {
582 struct nvme_fid_supported_effects_log expected_log, log = {};
583 struct mock_cmd mock_admin_cmd = {
584 .opcode = nvme_admin_get_log_page,
585 .nsid = NVME_NSID_NONE,
586 .data_len = sizeof(expected_log),
587 .cdw10 = (NVME_LOG_LID_FID_SUPPORTED_EFFECTS << 0) |
588 (!!TEST_RAE << 15) |
589 (((sizeof(expected_log) >> 2) - 1) << 16),
590 .out_data = &expected_log,
591 };
592 int err;
593
594 arbitrary(&expected_log, sizeof(expected_log));
595 set_mock_admin_cmds(&mock_admin_cmd, 1);
596 err = nvme_get_log_fid_supported_effects(TEST_FD, TEST_RAE, &log);
597 end_mock_cmds();
598 check(err == 0, "get log returned error %d, errno %m", err);
599 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
600 }
601
602 static void test_get_log_mi_cmd_supported_effects(void)
603 {
604 struct nvme_mi_cmd_supported_effects_log expected_log, log = {};
605 struct mock_cmd mock_admin_cmd = {
606 .opcode = nvme_admin_get_log_page,
607 .nsid = NVME_NSID_NONE,
608 .data_len = sizeof(expected_log),
609 .cdw10 = (NVME_LOG_LID_MI_CMD_SUPPORTED_EFFECTS << 0) |
610 (!!TEST_RAE << 15) |
611 (((sizeof(expected_log) >> 2) - 1) << 16),
612 .out_data = &expected_log,
613 };
614 int err;
615
616 arbitrary(&expected_log, sizeof(expected_log));
617 set_mock_admin_cmds(&mock_admin_cmd, 1);
618 err = nvme_get_log_mi_cmd_supported_effects(TEST_FD, TEST_RAE, &log);
619 end_mock_cmds();
620 check(err == 0, "get log returned error %d, errno %m", err);
621 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
622 }
623
624 static void test_get_log_boot_partition(void)
625 {
626 struct nvme_boot_partition expected_log, log = {};
627 struct mock_cmd mock_admin_cmd = {
628 .opcode = nvme_admin_get_log_page,
629 .nsid = NVME_NSID_NONE,
630 .data_len = sizeof(expected_log),
631 .cdw10 = (NVME_LOG_LID_BOOT_PARTITION << 0) | (TEST_LSP << 8) |
632 (!!TEST_RAE << 15) |
633 (((sizeof(expected_log) >> 2) - 1) << 16),
634 .out_data = &expected_log,
635 };
636 int err;
637
638 arbitrary(&expected_log, sizeof(expected_log));
639 set_mock_admin_cmds(&mock_admin_cmd, 1);
640 err = nvme_get_log_boot_partition(TEST_FD, TEST_RAE, TEST_LSP,
641 sizeof(log), &log);
642 end_mock_cmds();
643 check(err == 0, "get log returned error %d, errno %m", err);
644 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
645 }
646
647 static void test_get_log_rotational_media_info(void)
648 {
649 struct nvme_rotational_media_info_log expected_log, log = {};
650 struct mock_cmd mock_admin_cmd = {
651 .opcode = nvme_admin_get_log_page,
652 .nsid = NVME_NSID_NONE,
653 .data_len = sizeof(expected_log),
654 .cdw10 = (NVME_LOG_LID_ROTATIONAL_MEDIA_INFO << 0) |
655 (((sizeof(expected_log) >> 2) - 1) << 16),
656 .cdw11 = (TEST_ENDGID << 16),
657 .out_data = &expected_log,
658 };
659 int err;
660
661 arbitrary(&expected_log, sizeof(expected_log));
662 set_mock_admin_cmds(&mock_admin_cmd, 1);
663 err = nvme_get_log_rotational_media_info(TEST_FD, TEST_ENDGID,
664 sizeof(log), &log);
665 end_mock_cmds();
666 check(err == 0, "get log returned error %d, errno %m", err);
667 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
668 }
669
670 static void test_get_log_dispersed_ns_participating_nss(void)
671 {
672 struct nvme_dispersed_ns_participating_nss_log expected_log, log = {};
673 struct mock_cmd mock_admin_cmd = {
674 .opcode = nvme_admin_get_log_page,
675 .nsid = TEST_NSID,
676 .data_len = sizeof(expected_log),
677 .cdw10 = (NVME_LOG_LID_DISPERSED_NS_PARTICIPATING_NSS << 0) |
678 (((sizeof(expected_log) >> 2) - 1) << 16),
679 .out_data = &expected_log,
680 };
681 int err;
682
683 arbitrary(&expected_log, sizeof(expected_log));
684 set_mock_admin_cmds(&mock_admin_cmd, 1);
685 err = nvme_get_log_dispersed_ns_participating_nss(TEST_FD, TEST_NSID,
686 sizeof(log), &log);
687 end_mock_cmds();
688 check(err == 0, "get log returned error %d, errno %m", err);
689 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
690 }
691
692 static void test_get_log_phy_rx_eom(void)
693 {
694 struct nvme_phy_rx_eom_log expected_log, log = {};
695 struct mock_cmd mock_admin_cmd = {
696 .opcode = nvme_admin_get_log_page,
697 .nsid = NVME_NSID_NONE,
698 .data_len = sizeof(expected_log),
699 .cdw10 = (NVME_LOG_LID_PHY_RX_EOM << 0) | (TEST_LSP << 8) |
700 (((sizeof(expected_log) >> 2) - 1) << 16),
701 .cdw11 = (TEST_CNTID << 16),
702 .out_data = &expected_log,
703 };
704 int err;
705
706 arbitrary(&expected_log, sizeof(expected_log));
707 set_mock_admin_cmds(&mock_admin_cmd, 1);
708 err = nvme_get_log_phy_rx_eom(TEST_FD, TEST_LSP, TEST_CNTID,
709 sizeof(log), &log);
710 end_mock_cmds();
711 check(err == 0, "get log returned error %d, errno %m", err);
712 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
713 }
714
715 static void test_get_log_reachability_groups(void)
716 {
717 struct nvme_reachability_groups_log expected_log, log = {};
718 struct mock_cmd mock_admin_cmd = {
719 .opcode = nvme_admin_get_log_page,
720 .nsid = NVME_NSID_ALL,
721 .data_len = sizeof(expected_log),
722 .cdw10 = (NVME_LOG_LID_REACHABILITY_GROUPS << 0) |
723 (!!TEST_LSP << 8) | (!!TEST_RAE << 15) |
724 (((sizeof(expected_log) >> 2) - 1) << 16),
725 .out_data = &expected_log,
726 };
727 int err;
728
729 arbitrary(&expected_log, sizeof(expected_log));
730 set_mock_admin_cmds(&mock_admin_cmd, 1);
731 err = nvme_get_log_reachability_groups(TEST_FD, !!TEST_LSP, TEST_RAE,
732 sizeof(log), &log);
733 end_mock_cmds();
734 check(err == 0, "get log returned error %d, errno %m", err);
735 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
736 }
737
738 static void test_get_log_reachability_associations(void)
739 {
740 struct nvme_reachability_associations_log expected_log, log = {};
741 struct mock_cmd mock_admin_cmd = {
742 .opcode = nvme_admin_get_log_page,
743 .nsid = NVME_NSID_ALL,
744 .data_len = sizeof(expected_log),
745 .cdw10 = (NVME_LOG_LID_REACHABILITY_ASSOCIATIONS << 0) |
746 (!!TEST_LSP << 8) | (!!TEST_RAE << 15) |
747 (((sizeof(expected_log) >> 2) - 1) << 16),
748 .out_data = &expected_log,
749 };
750 int err;
751
752 arbitrary(&expected_log, sizeof(expected_log));
753 set_mock_admin_cmds(&mock_admin_cmd, 1);
754 err = nvme_get_log_reachability_associations(
755 TEST_FD, !!TEST_LSP, TEST_RAE, sizeof(log), &log);
756 end_mock_cmds();
757 check(err == 0, "get log returned error %d, errno %m", err);
758 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
759 }
760
761 static void test_get_log_changed_alloc_ns_list(void)
762 {
763 struct nvme_ns_list expected_log, log = {};
764 struct mock_cmd mock_admin_cmd = {
765 .opcode = nvme_admin_get_log_page,
766 .nsid = NVME_NSID_ALL,
767 .data_len = sizeof(expected_log),
768 .cdw10 = (NVME_LOG_LID_CHANGED_ALLOC_NS_LIST << 0) |
769 (!!TEST_RAE << 15) |
770 (((sizeof(expected_log) >> 2) - 1) << 16),
771 .out_data = &expected_log,
772 };
773 int err;
774
775 arbitrary(&expected_log, sizeof(expected_log));
776 set_mock_admin_cmds(&mock_admin_cmd, 1);
777 err = nvme_get_log_changed_alloc_ns_list(TEST_FD, TEST_RAE, sizeof(log),
778 &log);
779 end_mock_cmds();
780 check(err == 0, "get log returned error %d, errno %m", err);
781 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
782 }
783
784 static void test_get_log_discovery(void)
785 {
786 __u8 expected_log[32], log[32] = {};
787 struct mock_cmd mock_admin_cmd = {
788 .opcode = nvme_admin_get_log_page,
789 .nsid = NVME_NSID_NONE,
790 .data_len = sizeof(expected_log),
791 .cdw10 = (NVME_LOG_LID_DISCOVER << 0) | (!!TEST_RAE << 15) |
792 (((sizeof(expected_log) >> 2) - 1) << 16),
793 .cdw12 = TEST_OFFSET_32,
794 .out_data = &expected_log,
795 };
796 int err;
797
798 arbitrary(&expected_log, sizeof(expected_log));
799 set_mock_admin_cmds(&mock_admin_cmd, 1);
800 err = nvme_get_log_discovery(TEST_FD, TEST_RAE, TEST_OFFSET_32,
801 sizeof(log), &log);
802 end_mock_cmds();
803 check(err == 0, "get log returned error %d, errno %m", err);
804 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
805 }
806
807 static void test_get_log_host_discover(void)
808 {
809 struct nvme_host_discover_log expected_log, log = {};
810 struct mock_cmd mock_admin_cmd = {
811 .opcode = nvme_admin_get_log_page,
812 .nsid = NVME_NSID_ALL,
813 .data_len = sizeof(expected_log),
814 .cdw10 = (NVME_LOG_LID_HOST_DISCOVER << 0) | (!!TEST_LSP << 8) |
815 (!!TEST_RAE << 15) |
816 (((sizeof(expected_log) >> 2) - 1) << 16),
817 .out_data = &expected_log,
818 };
819 int err;
820
821 arbitrary(&expected_log, sizeof(expected_log));
822 set_mock_admin_cmds(&mock_admin_cmd, 1);
823 err = nvme_get_log_host_discover(TEST_FD, !!TEST_LSP, TEST_RAE,
824 sizeof(log), &log);
825 end_mock_cmds();
826 check(err == 0, "get log returned error %d, errno %m", err);
827 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
828 }
829
830 static void test_get_log_ave_discover(void)
831 {
832 struct nvme_ave_discover_log expected_log, log = {};
833 struct mock_cmd mock_admin_cmd = {
834 .opcode = nvme_admin_get_log_page,
835 .nsid = NVME_NSID_ALL,
836 .data_len = sizeof(expected_log),
837 .cdw10 = (NVME_LOG_LID_AVE_DISCOVER << 0) | (!!TEST_RAE << 15) |
838 (((sizeof(expected_log) >> 2) - 1) << 16),
839 .out_data = &expected_log,
840 };
841 int err;
842
843 arbitrary(&expected_log, sizeof(expected_log));
844 set_mock_admin_cmds(&mock_admin_cmd, 1);
845 err = nvme_get_log_ave_discover(TEST_FD, TEST_RAE, sizeof(log), &log);
846 end_mock_cmds();
847 check(err == 0, "get log returned error %d, errno %m", err);
848 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
849 }
850
851 static void test_get_log_pull_model_ddc_req(void)
852 {
853 struct nvme_pull_model_ddc_req_log expected_log, log = {};
854 struct mock_cmd mock_admin_cmd = {
855 .opcode = nvme_admin_get_log_page,
856 .nsid = NVME_NSID_ALL,
857 .data_len = sizeof(expected_log),
858 .cdw10 = (NVME_LOG_LID_PULL_MODEL_DDC_REQ << 0) |
859 (!!TEST_RAE << 15) |
860 (((sizeof(expected_log) >> 2) - 1) << 16),
861 .out_data = &expected_log,
862 };
863 int err;
864
865 arbitrary(&expected_log, sizeof(expected_log));
866 set_mock_admin_cmds(&mock_admin_cmd, 1);
867 err = nvme_get_log_pull_model_ddc_req(TEST_FD, TEST_RAE, sizeof(log),
868 &log);
869 end_mock_cmds();
870 check(err == 0, "get log returned error %d, errno %m", err);
871 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
872 }
873
874 static void test_get_log_media_unit_stat(void)
875 {
876 struct nvme_media_unit_stat_log expected_log, log = {};
877 struct mock_cmd mock_admin_cmd = {
878 .opcode = nvme_admin_get_log_page,
879 .nsid = NVME_NSID_NONE,
880 .data_len = sizeof(expected_log),
881 .cdw10 = (NVME_LOG_LID_MEDIA_UNIT_STATUS << 0) |
882 (((sizeof(expected_log) >> 2) - 1) << 16),
883 .cdw11 = (TEST_DOMID << 16),
884 .out_data = &expected_log,
885 };
886 int err;
887
888 arbitrary(&expected_log, sizeof(expected_log));
889 set_mock_admin_cmds(&mock_admin_cmd, 1);
890 err = nvme_get_log_media_unit_stat(TEST_FD, TEST_DOMID, &log);
891 end_mock_cmds();
892 check(err == 0, "get log returned error %d, errno %m", err);
893 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
894 }
895
896 static void test_get_log_support_cap_config_list(void)
897 {
898 struct nvme_supported_cap_config_list_log expected_log, log = {};
899 struct mock_cmd mock_admin_cmd = {
900 .opcode = nvme_admin_get_log_page,
901 .nsid = NVME_NSID_NONE,
902 .data_len = sizeof(expected_log),
903 .cdw10 = (NVME_LOG_LID_SUPPORTED_CAP_CONFIG_LIST << 0) |
904 (((sizeof(expected_log) >> 2) - 1) << 16),
905 .cdw11 = (TEST_DOMID << 16),
906 .out_data = &expected_log,
907 };
908 int err;
909
910 arbitrary(&expected_log, sizeof(expected_log));
911 set_mock_admin_cmds(&mock_admin_cmd, 1);
912 err = nvme_get_log_support_cap_config_list(TEST_FD, TEST_DOMID, &log);
913 end_mock_cmds();
914 check(err == 0, "get log returned error %d, errno %m", err);
915 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
916 }
917
918 static void test_get_log_reservation(void)
919 {
920 struct nvme_resv_notification_log expected_log, log = {};
921 struct mock_cmd mock_admin_cmd = {
922 .opcode = nvme_admin_get_log_page,
923 .nsid = NVME_NSID_ALL,
924 .data_len = sizeof(expected_log),
925 .cdw10 = (NVME_LOG_LID_RESERVATION << 0) | (!!TEST_RAE << 15) |
926 (((sizeof(expected_log) >> 2) - 1) << 16),
927 .out_data = &expected_log,
928 };
929 int err;
930
931 arbitrary(&expected_log, sizeof(expected_log));
932 set_mock_admin_cmds(&mock_admin_cmd, 1);
933 err = nvme_get_log_reservation(TEST_FD, TEST_RAE, &log);
934 end_mock_cmds();
935 check(err == 0, "get log returned error %d, errno %m", err);
936 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
937 }
938
939 static void test_get_log_zns_changed_zones(void)
940 {
941 struct nvme_zns_changed_zone_log expected_log, log = {};
942 struct mock_cmd mock_admin_cmd = {
943 .opcode = nvme_admin_get_log_page,
944 .nsid = TEST_NSID,
945 .data_len = sizeof(expected_log),
946 .cdw10 = (NVME_LOG_LID_ZNS_CHANGED_ZONES << 0) |
947 (!!TEST_RAE << 15) |
948 (((sizeof(expected_log) >> 2) - 1) << 16),
949 .cdw14 = NVME_CSI_ZNS << 24,
950 .out_data = &expected_log,
951 };
952 int err;
953
954 arbitrary(&expected_log, sizeof(expected_log));
955 set_mock_admin_cmds(&mock_admin_cmd, 1);
956 err = nvme_get_log_zns_changed_zones(TEST_FD, TEST_NSID, TEST_RAE,
957 &log);
958 end_mock_cmds();
959 check(err == 0, "get log returned error %d, errno %m", err);
960 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
961 }
962
963 static void test_get_log_persistent_event(void)
964 {
965 __u8 expected_log[32], log[32] = {};
966 struct mock_cmd mock_admin_cmd = {
967 .opcode = nvme_admin_get_log_page,
968 .nsid = NVME_NSID_ALL,
969 .data_len = sizeof(expected_log),
970 .cdw10 = (NVME_LOG_LID_PERSISTENT_EVENT << 0) |
971 (TEST_PEVENT << 8) |
972 (((sizeof(expected_log) >> 2) - 1) << 16),
973 .out_data = &expected_log,
974 };
975 int err;
976
977 arbitrary(&expected_log, sizeof(expected_log));
978 set_mock_admin_cmds(&mock_admin_cmd, 1);
979 err = nvme_get_log_persistent_event(TEST_FD, TEST_PEVENT, sizeof(log),
980 &log);
981 end_mock_cmds();
982 check(err == 0, "get log returned error %d, errno %m", err);
983 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
984 }
985
986 static void test_get_log_lockdown(void)
987 {
988 struct nvme_lockdown_log expected_log, log = {};
989 struct mock_cmd mock_admin_cmd = {
990 .opcode = nvme_admin_get_log_page,
991 .nsid = NVME_NSID_ALL,
992 .data_len = sizeof(expected_log),
993 .cdw10 = (NVME_LOG_LID_CMD_AND_FEAT_LOCKDOWN << 0) |
994 (TEST_LSP << 8) |
995 (((sizeof(expected_log) >> 2) - 1) << 16),
996 .out_data = &expected_log,
997 };
998 int err;
999
1000 arbitrary(&expected_log, sizeof(expected_log));
1001 set_mock_admin_cmds(&mock_admin_cmd, 1);
1002 err = nvme_get_log_lockdown(TEST_FD, TEST_LSP, &log);
1003 end_mock_cmds();
1004 check(err == 0, "get log returned error %d, errno %m", err);
1005 cmp(&log, &expected_log, sizeof(log), "incorrect log data");
1006 }
1007
1008 static void run_test(const char *test_name, void (*test_fn)(void))
1009 {
1010 printf("Running test %s...", test_name);
1011 fflush(stdout);
1012 test_fn();
1013 puts(" OK");
1014 }
1015
1016 #define RUN_TEST(name) run_test(#name, test_##name)
1017
1018 int main(void)
1019 {
1020 set_mock_fd(TEST_FD);
1021 RUN_TEST(get_log_sanitize);
1022 RUN_TEST(get_log_mgmt_addr_list);
1023 RUN_TEST(get_log_supported_log_pages);
1024 RUN_TEST(get_log_error);
1025 RUN_TEST(get_log_smart);
1026 RUN_TEST(get_log_fw_slot);
1027 RUN_TEST(get_log_changed_ns_list);
1028 RUN_TEST(get_log_cmd_effects);
1029 RUN_TEST(get_log_device_self_test);
1030 RUN_TEST(get_log_create_telemetry_host_mcda);
1031 RUN_TEST(get_log_create_telemetry_host);
1032 RUN_TEST(get_log_telemetry_host);
1033 RUN_TEST(get_log_telemetry_ctrl);
1034 RUN_TEST(get_log_endurance_group);
1035 RUN_TEST(get_log_predictable_lat_nvmset);
1036 RUN_TEST(get_log_predictable_lat_event);
1037 RUN_TEST(get_log_fdp_configurations);
1038 RUN_TEST(get_log_reclaim_unit_handle_usage);
1039 RUN_TEST(get_log_fdp_stats);
1040 RUN_TEST(get_log_fdp_events);
1041 RUN_TEST(get_log_ana);
1042 RUN_TEST(get_log_ana_groups);
1043 RUN_TEST(get_log_lba_status);
1044 RUN_TEST(get_log_endurance_grp_evt);
1045 RUN_TEST(get_log_fid_supported_effects);
1046 RUN_TEST(get_log_mi_cmd_supported_effects);
1047 RUN_TEST(get_log_boot_partition);
1048 RUN_TEST(get_log_rotational_media_info);
1049 RUN_TEST(get_log_dispersed_ns_participating_nss);
1050 RUN_TEST(get_log_phy_rx_eom);
1051 RUN_TEST(get_log_reachability_groups);
1052 RUN_TEST(get_log_reachability_associations);
1053 RUN_TEST(get_log_changed_alloc_ns_list);
1054 RUN_TEST(get_log_discovery);
1055 RUN_TEST(get_log_host_discover);
1056 RUN_TEST(get_log_ave_discover);
1057 RUN_TEST(get_log_pull_model_ddc_req);
1058 RUN_TEST(get_log_media_unit_stat);
1059 RUN_TEST(get_log_support_cap_config_list);
1060 RUN_TEST(get_log_reservation);
1061 RUN_TEST(get_log_zns_changed_zones);
1062 RUN_TEST(get_log_persistent_event);
1063 RUN_TEST(get_log_lockdown);
1064 }