Debian Codegraph @

test/ioctl/ana.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2
3 #include <errno.h>
4 #include <inttypes.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #include <ccan/array_size/array_size.h>
9 #include <ccan/endian/endian.h>
10
11 #include <libnvme.h>
12
13 #include "mock.h"
14 #include "util.h"
15
16 #define TEST_FD 0xFD
17 #define PDU_SIZE NVME_LOG_PAGE_PDU_SIZE
18
19 static void test_no_retries(void)
20 {
21 struct nvme_ana_log log;
22 __u32 len = sizeof(log);
23
24 /* max_retries = 0 is nonsensical */
25 check(nvme_get_ana_log_atomic(TEST_FD, false, false, 0, &log, &len),
26 "get log page succeeded");
27 check(errno == EINVAL, "unexpected error: %m");
28 }
29
30 static void test_len_too_short(void)
31 {
32 struct nvme_ana_log log;
33 __u32 len = sizeof(log) - 1;
34
35 /* Provided buffer doesn't have enough space to read the header */
36 check(nvme_get_ana_log_atomic(TEST_FD, false, false, 1, &log, &len),
37 "get log page succeeded");
38 check(errno == ENOSPC, "unexpected error: %m");
39 }
40
41 static void test_no_groups(void)
42 {
43 struct nvme_ana_log header;
44 /* The header reports no ANA groups. No additional commands needed. */
45 struct mock_cmd mock_admin_cmd = {
46 .opcode = nvme_admin_get_log_page,
47 .data_len = sizeof(header),
48 .cdw10 = (sizeof(header) / 4 - 1) << 16 /* NUMDL */
49 | NVME_LOG_LID_ANA, /* LID */
50 .out_data = &header,
51 };
52 struct nvme_ana_log log;
53 __u32 len = sizeof(log);
54
55 arbitrary(&log, sizeof(log));
56 arbitrary(&header, sizeof(header));
57 header.ngrps = cpu_to_le16(0);
58 set_mock_admin_cmds(&mock_admin_cmd, 1);
59 check(!nvme_get_ana_log_atomic(TEST_FD, false, false, 1, &log, &len),
60 "get log page failed: %m");
61 end_mock_cmds();
62 cmp(&log, &header, sizeof(header), "incorrect header");
63 check(len == sizeof(header),
64 "got len %" PRIu32 ", expected %zu", len, sizeof(header));
65 }
66
67 static void test_one_group_rgo(void)
68 {
69 struct nvme_ana_log header;
70 struct nvme_ana_group_desc group;
71 __u8 log_page[sizeof(header) + sizeof(group)];
72 __u32 len = 123;
73 size_t len_dwords = len / 4;
74 /*
75 * Header and group fetched in a single Get Log Page command.
76 * Since only one command was issued, chgcnt doesn't need to be checked.
77 */
78 struct mock_cmd mock_admin_cmd = {
79 .opcode = nvme_admin_get_log_page,
80 .data_len = len_dwords * 4,
81 .cdw10 = (len_dwords - 1) << 16 /* NUMDL */
82 | NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8 /* LSP */
83 | NVME_LOG_LID_ANA, /* LID */
84 .out_data = log_page,
85 .out_data_len = sizeof(log_page),
86 };
87 struct nvme_ana_log *log = malloc(len);
88
89 arbitrary(log, len);
90 arbitrary(&header, sizeof(header));
91 header.ngrps = cpu_to_le16(1);
92 arbitrary(&group, sizeof(group));
93 group.nnsids = cpu_to_le32(0);
94 memcpy(log_page, &header, sizeof(header));
95 memcpy(log_page + sizeof(header), &group, sizeof(group));
96 set_mock_admin_cmds(&mock_admin_cmd, 1);
97 check(!nvme_get_ana_log_atomic(TEST_FD, true, false, 1, log, &len),
98 "get log page failed: %m");
99 end_mock_cmds();
100 cmp(log, log_page, sizeof(log_page), "incorrect log page");
101 check(len == sizeof(log_page),
102 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page));
103 free(log);
104 }
105
106 static void test_one_group_nsids(void)
107 {
108 struct nvme_ana_log header;
109 struct nvme_ana_group_desc group;
110 __le32 nsids[3];
111 __u8 log_page[sizeof(header) + sizeof(group) + sizeof(nsids)];
112 __u32 len = 124;
113 size_t len_dwords = len / 4;
114 /*
115 * Header, group, and NSIDs fetched in a single Get Log Page command.
116 * Since only one command was issued, chgcnt doesn't need to be checked.
117 */
118 struct mock_cmd mock_admin_cmd = {
119 .opcode = nvme_admin_get_log_page,
120 .data_len = len_dwords * 4,
121 .cdw10 = (len_dwords - 1) << 16 /* NUMDL */
122 | NVME_LOG_LID_ANA, /* LID */
123 .out_data = log_page,
124 .out_data_len = sizeof(log_page),
125 };
126 struct nvme_ana_log *log = malloc(len);
127
128 arbitrary(log, len);
129 arbitrary(&header, sizeof(header));
130 header.ngrps = cpu_to_le16(1);
131 arbitrary(&group, sizeof(group));
132 group.nnsids = cpu_to_le32(ARRAY_SIZE(nsids));
133 arbitrary(nsids, sizeof(nsids));
134 memcpy(log_page, &header, sizeof(header));
135 memcpy(log_page + sizeof(header), &group, sizeof(group));
136 memcpy(log_page + sizeof(header) + sizeof(group), nsids, sizeof(nsids));
137 set_mock_admin_cmds(&mock_admin_cmd, 1);
138 check(!nvme_get_ana_log_atomic(TEST_FD, false, false, 1, log, &len),
139 "get log page failed: %m");
140 end_mock_cmds();
141 cmp(log, log_page, sizeof(log_page), "incorrect log page");
142 check(len == sizeof(log_page),
143 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page));
144 free(log);
145 }
146
147 static void test_multiple_groups_rgo(void)
148 {
149 struct nvme_ana_log header;
150 struct nvme_ana_group_desc groups[3];
151 __u8 log_page[sizeof(header) + sizeof(groups)];
152 __u32 len = 125;
153 size_t len_dwords = len / 4;
154 /*
155 * Header and groups fetched in a single Get Log Page command.
156 * Since only one command was issued, chgcnt doesn't need to be checked.
157 */
158 struct mock_cmd mock_admin_cmd = {
159 .opcode = nvme_admin_get_log_page,
160 .data_len = len_dwords * 4,
161 .cdw10 = (len_dwords - 1) << 16 /* NUMDL */
162 | 1 << 15 /* RAE */
163 | NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8 /* LSP */
164 | NVME_LOG_LID_ANA, /* LID */
165 .out_data = log_page,
166 .out_data_len = sizeof(log_page),
167 };
168 struct nvme_ana_log *log = malloc(len);
169
170 arbitrary(log, len);
171 arbitrary(&header, sizeof(header));
172 header.ngrps = cpu_to_le16(ARRAY_SIZE(groups));
173 arbitrary(groups, sizeof(groups));
174 for (size_t i = 0; i < ARRAY_SIZE(groups); i++)
175 groups[i].nnsids = cpu_to_le32(0);
176 memcpy(log_page, &header, sizeof(header));
177 memcpy(log_page + sizeof(header), groups, sizeof(groups));
178 set_mock_admin_cmds(&mock_admin_cmd, 1);
179 check(!nvme_get_ana_log_atomic(TEST_FD, true, true, 1, log, &len),
180 "get log page failed: %m");
181 end_mock_cmds();
182 cmp(log, log_page, sizeof(log_page), "incorrect log page");
183 check(len == sizeof(log_page),
184 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page));
185 free(log);
186 }
187
188 static void test_multiple_groups_nsids(void)
189 {
190 struct nvme_ana_log header;
191 struct nvme_ana_group_desc group1;
192 __le32 nsids1[3];
193 struct nvme_ana_group_desc group2;
194 __le32 nsids2[2];
195 struct nvme_ana_group_desc group3;
196 __le32 nsids3[1];
197 __u8 log_page[sizeof(header) +
198 sizeof(group1) + sizeof(nsids1) +
199 sizeof(group2) + sizeof(nsids2) +
200 sizeof(group3) + sizeof(nsids3)];
201 __u32 len = 456;
202 size_t len_dwords = len / 4;
203 /*
204 * Header, group, and NSIDs fetched in a single Get Log Page command.
205 * Since only one command was issued, chgcnt doesn't need to be checked.
206 */
207 struct mock_cmd mock_admin_cmd = {
208 .opcode = nvme_admin_get_log_page,
209 .data_len = len_dwords * 4,
210 .cdw10 = (len_dwords - 1) << 16 /* NUMDL */
211 | NVME_LOG_LID_ANA, /* LID */
212 .out_data = log_page,
213 .out_data_len = sizeof(log_page),
214 };
215 struct nvme_ana_log *log = malloc(len);
216
217 arbitrary(log, len);
218 arbitrary(&header, sizeof(header));
219 header.ngrps = cpu_to_le16(3);
220 arbitrary(&group1, sizeof(group1));
221 group1.nnsids = cpu_to_le32(ARRAY_SIZE(nsids1));
222 arbitrary(nsids1, sizeof(nsids1));
223 arbitrary(&group2, sizeof(group2));
224 group2.nnsids = cpu_to_le32(ARRAY_SIZE(nsids2));
225 arbitrary(nsids2, sizeof(nsids2));
226 arbitrary(&group3, sizeof(group3));
227 group3.nnsids = cpu_to_le32(ARRAY_SIZE(nsids3));
228 arbitrary(nsids3, sizeof(nsids3));
229 memcpy(log_page, &header, sizeof(header));
230 memcpy(log_page + sizeof(header), &group1, sizeof(group1));
231 memcpy(log_page + sizeof(header) + sizeof(group1),
232 nsids1, sizeof(nsids1));
233 memcpy(log_page + sizeof(header) + sizeof(group1) + sizeof(nsids1),
234 &group2, sizeof(group2));
235 memcpy(log_page + sizeof(header) + sizeof(group1) + sizeof(nsids1) +
236 sizeof(group2),
237 nsids2, sizeof(nsids2));
238 memcpy(log_page + sizeof(header) + sizeof(group1) + sizeof(nsids1) +
239 sizeof(group2) + sizeof(nsids2),
240 &group3, sizeof(group3));
241 memcpy(log_page + sizeof(header) + sizeof(group1) + sizeof(nsids1) +
242 sizeof(group2) + sizeof(nsids2) + sizeof(group3),
243 nsids3, sizeof(nsids3));
244 set_mock_admin_cmds(&mock_admin_cmd, 1);
245 check(!nvme_get_ana_log_atomic(TEST_FD, false, false, 1, log, &len),
246 "get log page failed: %m");
247 end_mock_cmds();
248 cmp(log, log_page, sizeof(log_page), "incorrect log page");
249 check(len == sizeof(log_page),
250 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page));
251 free(log);
252 }
253
254 static void test_long_log(void)
255 {
256 struct nvme_ana_log header;
257 struct nvme_ana_group_desc group;
258 __le32 nsids[PDU_SIZE * 2 / sizeof(*group.nsids)];
259 __u8 log_page[sizeof(header) + sizeof(group) + sizeof(nsids)];
260 __u32 len = PDU_SIZE * 4;
261 /*
262 * Get Log Page is issued for 4 KB, returning the header (with 1 group),
263 * the group (with 2048 NSIDs) and the start of its NSIDs.
264 * Another Get Log page command is issued for the next 1024 NSIDs.
265 * Another Get Log page command is issued for the last NSIDs.
266 * Header is fetched again to verify chgcnt hasn't changed.
267 */
268 struct mock_cmd mock_admin_cmds[] = {
269 {
270 .opcode = nvme_admin_get_log_page,
271 .data_len = PDU_SIZE,
272 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
273 | 1 << 15 /* RAE */
274 | NVME_LOG_LID_ANA, /* LID */
275 .out_data = log_page,
276 },
277 {
278 .opcode = nvme_admin_get_log_page,
279 .data_len = PDU_SIZE,
280 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
281 | 1 << 15 /* RAE */
282 | NVME_LOG_LID_ANA, /* LID */
283 .cdw12 = PDU_SIZE, /* LPOL */
284 .out_data = log_page + PDU_SIZE,
285 },
286 {
287 .opcode = nvme_admin_get_log_page,
288 .data_len = PDU_SIZE,
289 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
290 | 1 << 15 /* RAE */
291 | NVME_LOG_LID_ANA, /* LID */
292 .cdw12 = PDU_SIZE * 2, /* LPOL */
293 .out_data = log_page + PDU_SIZE * 2,
294 .out_data_len = sizeof(log_page) - PDU_SIZE * 2,
295 },
296 {
297 .opcode = nvme_admin_get_log_page,
298 .data_len = PDU_SIZE,
299 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
300 | 1 << 15 /* RAE */
301 | NVME_LOG_LID_ANA, /* LID */
302 .out_data = log_page,
303 },
304 };
305 struct nvme_ana_log *log = malloc(len);
306
307 arbitrary(log, len);
308 arbitrary(&header, sizeof(header));
309 header.ngrps = cpu_to_le16(1);
310 arbitrary(&group, sizeof(group));
311 group.nnsids = cpu_to_le32(ARRAY_SIZE(nsids));
312 arbitrary(nsids, sizeof(nsids));
313 memcpy(log_page, &header, sizeof(header));
314 memcpy(log_page + sizeof(header), &group, sizeof(group));
315 memcpy(log_page + sizeof(header) + sizeof(group), nsids, sizeof(nsids));
316 set_mock_admin_cmds(mock_admin_cmds, ARRAY_SIZE(mock_admin_cmds));
317 check(!nvme_get_ana_log_atomic(TEST_FD, false, true, 1, log, &len),
318 "get log page failed: %m");
319 end_mock_cmds();
320 cmp(log, log_page, sizeof(log_page), "incorrect log page");
321 check(len == sizeof(log_page),
322 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page));
323 free(log);
324 }
325
326 static void test_chgcnt_change(void)
327 {
328 struct nvme_ana_log header1;
329 struct nvme_ana_group_desc groups1[PDU_SIZE / sizeof(*header1.descs)];
330 __u8 log_page1[sizeof(header1) + sizeof(groups1)];
331 struct nvme_ana_log header2;
332 struct nvme_ana_group_desc group2;
333 __u8 log_page2[sizeof(header2) + sizeof(group2)];
334 __u32 len = PDU_SIZE + 126;
335 size_t remainder_len_dwords = (len - PDU_SIZE) / 4;
336 /*
337 * Get Log Page is issued for 4 KB,
338 * returning the header (with 128 groups), and the start of the groups.
339 * Get Log Page is issued for the rest of the groups.
340 * Get Log Page is issued for the first 4 KB again to check chgcnt.
341 * chgcnt has changed, but there is only 1 group now,
342 * which was already fetched with the header.
343 */
344 struct mock_cmd mock_admin_cmds[] = {
345 {
346 .opcode = nvme_admin_get_log_page,
347 .data_len = PDU_SIZE,
348 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
349 | 1 << 15 /* RAE */
350 | NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8 /* LSP */
351 | NVME_LOG_LID_ANA, /* LID */
352 .out_data = log_page1,
353 },
354 {
355 .opcode = nvme_admin_get_log_page,
356 .data_len = remainder_len_dwords * 4,
357 .cdw10 = (remainder_len_dwords - 1) << 16 /* NUMDL */
358 | 1 << 15 /* RAE */
359 | NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8 /* LSP */
360 | NVME_LOG_LID_ANA, /* LID */
361 .cdw12 = PDU_SIZE, /* LPOL */
362 .out_data = log_page1 + PDU_SIZE,
363 .out_data_len = sizeof(log_page1) - PDU_SIZE,
364 },
365 {
366 .opcode = nvme_admin_get_log_page,
367 .data_len = PDU_SIZE,
368 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
369 | 1 << 15 /* RAE */
370 | NVME_LOG_ANA_LSP_RGO_GROUPS_ONLY << 8 /* LSP */
371 | NVME_LOG_LID_ANA, /* LID */
372 .out_data = log_page2,
373 .out_data_len = sizeof(log_page2),
374 },
375 };
376 struct nvme_ana_log *log = malloc(len);
377
378 arbitrary(log, len);
379 arbitrary(&header1, sizeof(header1));
380 header1.ngrps = cpu_to_le16(ARRAY_SIZE(groups1));
381 arbitrary(&groups1, sizeof(groups1));
382 for (size_t i = 0; i < ARRAY_SIZE(groups1); i++)
383 groups1[i].nnsids = cpu_to_le32(0);
384 memcpy(log_page1, &header1, sizeof(header1));
385 memcpy(log_page1 + sizeof(header1), groups1, sizeof(groups1));
386 arbitrary(&header2, sizeof(header2));
387 header2.ngrps = cpu_to_le16(1);
388 arbitrary(&group2, sizeof(group2));
389 group2.nnsids = cpu_to_le32(0);
390 memcpy(log_page2, &header2, sizeof(header2));
391 memcpy(log_page2 + sizeof(header2), &group2, sizeof(group2));
392 set_mock_admin_cmds(mock_admin_cmds, ARRAY_SIZE(mock_admin_cmds));
393 check(!nvme_get_ana_log_atomic(TEST_FD, true, true, 2, log, &len),
394 "get log page failed: %m");
395 end_mock_cmds();
396 cmp(log, log_page2, sizeof(log_page2), "incorrect log page");
397 check(len == sizeof(log_page2),
398 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page2));
399 free(log);
400 }
401
402 static void test_buffer_too_short_chgcnt_change(void)
403 {
404 struct nvme_ana_log header1;
405 struct nvme_ana_group_desc group1_1;
406 __le32 nsids1[PDU_SIZE / sizeof(*group1_1.nsids)];
407 struct nvme_ana_group_desc group1_2;
408 __u8 log_page1[sizeof(header1) +
409 sizeof(group1_1) + sizeof(nsids1) + sizeof(group1_2)];
410 struct nvme_ana_log header2;
411 struct nvme_ana_group_desc group2;
412 __le32 nsid2;
413 uint8_t log_page2[sizeof(header2) + sizeof(group2) + sizeof(nsid2)];
414 __u32 len = PDU_SIZE + 123;
415 size_t remainder_len_dwords = (len - PDU_SIZE) / 4;
416 /*
417 * Get Log Page issued for 4 KB, returning the header (with 2 groups),
418 * the first group (with 1024 NSIDs), and the start of the NSIDs.
419 * Get Log Page is issued for the rest of the NSIDs and the second group.
420 * The second group contains garbage, making the log exceed the buffer.
421 * The first 4 KB is fetched again, returning a header with a new chgcnt
422 * and a group with one NSID.
423 */
424 struct mock_cmd mock_admin_cmds[] = {
425 {
426 .opcode = nvme_admin_get_log_page,
427 .data_len = PDU_SIZE,
428 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
429 | NVME_LOG_LID_ANA, /* LID */
430 .out_data = log_page1,
431 },
432 {
433 .opcode = nvme_admin_get_log_page,
434 .data_len = remainder_len_dwords * 4,
435 .cdw10 = (remainder_len_dwords - 1) << 16 /* NUMDL */
436 | NVME_LOG_LID_ANA, /* LID */
437 .cdw12 = PDU_SIZE, /* LPOL */
438 .out_data = log_page1 + PDU_SIZE,
439 .out_data_len = sizeof(log_page1) - PDU_SIZE,
440 },
441 {
442 .opcode = nvme_admin_get_log_page,
443 .data_len = PDU_SIZE,
444 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
445 | NVME_LOG_LID_ANA, /* LID */
446 .out_data = log_page2,
447 .out_data_len = sizeof(log_page2),
448 },
449 };
450 struct nvme_ana_log *log = malloc(len);
451
452 arbitrary(log, len);
453 arbitrary(&header1, sizeof(header1));
454 header1.ngrps = cpu_to_le16(2);
455 arbitrary(&group1_1, sizeof(group1_1));
456 group1_1.nnsids = cpu_to_le32(ARRAY_SIZE(nsids1));
457 arbitrary(nsids1, sizeof(nsids1));
458 memset(&group1_2, -1, sizeof(group1_2));
459 memcpy(log_page1, &header1, sizeof(header1));
460 memcpy(log_page1 + sizeof(header1), &group1_1, sizeof(group1_1));
461 memcpy(log_page1 + sizeof(header1) + sizeof(group1_1),
462 nsids1, sizeof(nsids1));
463 memcpy(log_page1 + sizeof(header1) + sizeof(group1_1) + sizeof(nsids1),
464 &group1_2, sizeof(group1_2));
465 arbitrary(&header2, sizeof(header2));
466 header2.ngrps = cpu_to_le16(1);
467 arbitrary(&group2, sizeof(group2));
468 group2.nnsids = cpu_to_le32(1);
469 arbitrary(&nsid2, sizeof(nsid2));
470 memcpy(log_page2, &header2, sizeof(header2));
471 memcpy(log_page2 + sizeof(header2), &group2, sizeof(group2));
472 memcpy(log_page2 + sizeof(header2) + sizeof(group2),
473 &nsid2, sizeof(nsid2));
474 set_mock_admin_cmds(mock_admin_cmds, ARRAY_SIZE(mock_admin_cmds));
475 check(!nvme_get_ana_log_atomic(TEST_FD, false, false, 2, log, &len),
476 "get log page failed: %m");
477 end_mock_cmds();
478 cmp(log, log_page2, sizeof(log_page2), "incorrect log page");
479 check(len == sizeof(log_page2),
480 "got len %" PRIu32 ", expected %zu", len, sizeof(log_page2));
481 free(log);
482 }
483
484 static void test_chgcnt_max_retries(void)
485 {
486 struct nvme_ana_log header1, header2, header3;
487 struct nvme_ana_group_desc group;
488 __le32 nsids[PDU_SIZE / sizeof(*group.nsids)];
489 __u8 log_page1[sizeof(header1) + sizeof(group) + sizeof(nsids)],
490 log_page2[sizeof(header2) + sizeof(group) + sizeof(nsids)];
491 __u32 len = PDU_SIZE * 2;
492 /*
493 * Get Log Page is issued for 4 KB, returning the header (with 1 group),
494 * the group (with 1024 NSIDs), and the start of the NSIDs.
495 * Get Log Page is issued for the rest of the NSIDs.
496 * Get Log Page is issued for the first 4 KB again to check chgcnt.
497 * chgcnt has changed and there is still 1 group with 1024 NSIDs.
498 * Get Log Page is issued for the rest of the NSIDs.
499 * Get Log Page is issued for the first 4 KB again to check chgcnt.
500 * chgcnt has changed again.
501 * This exceeds max_retries = 2 so nvme_get_ana_log() exits with EAGAIN.
502 */
503 struct mock_cmd mock_admin_cmds[] = {
504 {
505 .opcode = nvme_admin_get_log_page,
506 .data_len = PDU_SIZE,
507 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
508 | 1 << 15 /* RAE */
509 | NVME_LOG_LID_ANA, /* LID */
510 .out_data = log_page1,
511 },
512 {
513 .opcode = nvme_admin_get_log_page,
514 .data_len = PDU_SIZE,
515 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
516 | 1 << 15 /* RAE */
517 | NVME_LOG_LID_ANA, /* LID */
518 .cdw12 = PDU_SIZE, /* LPOL */
519 .out_data = log_page1 + PDU_SIZE,
520 .out_data_len = sizeof(log_page1) - PDU_SIZE,
521 },
522 {
523 .opcode = nvme_admin_get_log_page,
524 .data_len = PDU_SIZE,
525 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
526 | 1 << 15 /* RAE */
527 | NVME_LOG_LID_ANA, /* LID */
528 .out_data = log_page2,
529 },
530 {
531 .opcode = nvme_admin_get_log_page,
532 .data_len = PDU_SIZE,
533 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
534 | 1 << 15 /* RAE */
535 | NVME_LOG_LID_ANA, /* LID */
536 .cdw12 = PDU_SIZE, /* LPOL */
537 .out_data = log_page2 + PDU_SIZE,
538 .out_data_len = sizeof(log_page2) - PDU_SIZE,
539 },
540 {
541 .opcode = nvme_admin_get_log_page,
542 .data_len = PDU_SIZE,
543 .cdw10 = (PDU_SIZE / 4 - 1) << 16 /* NUMDL */
544 | 1 << 15 /* RAE */
545 | NVME_LOG_LID_ANA, /* LID */
546 .out_data = &header3,
547 .out_data_len = sizeof(header3),
548 },
549 };
550 struct nvme_ana_log *log = malloc(len);
551
552 arbitrary(log, len);
553 arbitrary(&header1, sizeof(header1));
554 header1.ngrps = cpu_to_le16(1);
555 arbitrary(&header2, sizeof(header2));
556 header2.ngrps = cpu_to_le16(1);
557 arbitrary(&header3, sizeof(header3));
558 header3.ngrps = cpu_to_le16(0);
559 arbitrary(&group, sizeof(group));
560 group.nnsids = cpu_to_le32(ARRAY_SIZE(nsids));
561 arbitrary(nsids, sizeof(nsids));
562 memcpy(log_page1, &header1, sizeof(header1));
563 memcpy(log_page1 + sizeof(header1), &group, sizeof(group));
564 memcpy(log_page1 + sizeof(header1) + sizeof(group),
565 nsids, sizeof(nsids));
566 memcpy(log_page2, &header2, sizeof(header2));
567 memcpy(log_page2 + sizeof(header2), &group, sizeof(group));
568 memcpy(log_page2 + sizeof(header2) + sizeof(group),
569 nsids, sizeof(nsids));
570 set_mock_admin_cmds(mock_admin_cmds, ARRAY_SIZE(mock_admin_cmds));
571 check(nvme_get_ana_log_atomic(TEST_FD, false, true, 2, log, &len) == -1,
572 "get log page succeeded");
573 end_mock_cmds();
574 check(errno == EAGAIN, "unexpected error: %m");
575 free(log);
576 }
577
578 static void test_buffer_too_short(void)
579 {
580 struct nvme_ana_log header;
581 struct nvme_ana_group_desc group;
582 __le32 nsids[20];
583 __u8 log_page[sizeof(header) + sizeof(group) + sizeof(nsids)];
584 __u32 len = 123;
585 __u32 len_dwords = len / 4;
586 /*
587 * Header, group, and NSIDs fetched in a single Get Log Page command.
588 * This length exceeds the provided buffer.
589 * Only one command was issued, so the log page couldn't have changed.
590 * nvme_get_ana_log() returns ENOSPC because the buffer is too small.
591 */
592 struct mock_cmd mock_admin_cmd = {
593 .opcode = nvme_admin_get_log_page,
594 .data_len = len_dwords * 4,
595 .cdw10 = (len_dwords - 1) << 16 /* NUMDL */
596 | 1 << 15 /* RAE */
597 | NVME_LOG_LID_ANA, /* LID */
598 .out_data = log_page,
599 };
600 struct nvme_ana_log *log = malloc(len);
601
602 arbitrary(log, len);
603 arbitrary(&header, sizeof(header));
604 header.ngrps = cpu_to_le16(1);
605 arbitrary(&group, sizeof(group));
606 group.nnsids = cpu_to_le32(ARRAY_SIZE(nsids));
607 arbitrary(nsids, sizeof(nsids));
608 memcpy(log_page, &header, sizeof(header));
609 memcpy(log_page + sizeof(header), &group, sizeof(group));
610 memcpy(log_page + sizeof(header) + sizeof(group), nsids, sizeof(nsids));
611 set_mock_admin_cmds(&mock_admin_cmd, 1);
612 check(nvme_get_ana_log_atomic(TEST_FD, false, true, 2, log, &len) == -1,
613 "get log page succeeded");
614 end_mock_cmds();
615 check(errno == ENOSPC, "unexpected error: %m");
616 free(log);
617 }
618
619 static void run_test(const char *test_name, void (*test_fn)(void))
620 {
621 printf("Running test %s...", test_name);
622 fflush(stdout);
623 test_fn();
624 puts(" OK");
625 }
626
627 #define RUN_TEST(name) run_test(#name, test_ ## name)
628
629 int main(void)
630 {
631 set_mock_fd(TEST_FD);
632 RUN_TEST(no_retries);
633 RUN_TEST(len_too_short);
634 RUN_TEST(no_groups);
635 RUN_TEST(one_group_rgo);
636 RUN_TEST(one_group_nsids);
637 RUN_TEST(multiple_groups_rgo);
638 RUN_TEST(multiple_groups_nsids);
639 RUN_TEST(long_log);
640 RUN_TEST(chgcnt_change);
641 RUN_TEST(buffer_too_short_chgcnt_change);
642 RUN_TEST(chgcnt_max_retries);
643 RUN_TEST(buffer_too_short);
644 }