Debian Codegraph @

test/ioctl/zns.c

raw
1 // SPDX-License-Identifier: LGPL-2.1-or-later
2
3 #include <libnvme.h>
4
5 #include "mock.h"
6 #include "util.h"
7 #include <nvme/api-types.h>
8 #include <nvme/ioctl.h>
9 #include <nvme/types.h>
10
11 #define TEST_FD 0xFD
12 #define TEST_NSID 0x12345678
13 #define TEST_SLBA 0xffffffff12345678
14
15 static void test_zns_append(void)
16 {
17 __u8 expected_data[8], data[8] = {};
18 __u64 result = 0;
19 struct nvme_zns_append_args args = {
20 .zslba = TEST_SLBA,
21 .result = &result,
22 .data = &data,
23 .args_size = sizeof(args),
24 .fd = TEST_FD,
25 .nsid = TEST_NSID,
26 .data_len = sizeof(data),
27 .nlb = 0xab,
28 .control = 0xcd,
29 .lbat = 0xef,
30 .lbatm = 0x98,
31 .ilbrt_u64 = 0x76,
32 };
33
34 struct mock_cmd mock_io_cmd = {
35 .opcode = nvme_zns_cmd_append,
36 .nsid = TEST_NSID,
37 .cdw3 = (args.ilbrt_u64 >> 32) & 0xffffffff,
38 .cdw10 = args.zslba & 0xffffffff,
39 .cdw11 = args.zslba >> 32,
40 .cdw12 = args.nlb | (args.control << 16),
41 .cdw14 = args.ilbrt_u64 & 0xffffffff,
42 .cdw15 = args.lbat | (args.lbatm << 16),
43 .data_len = sizeof(expected_data),
44 .out_data = &expected_data,
45 };
46
47 int err;
48
49 arbitrary(&expected_data, sizeof(expected_data));
50 set_mock_io_cmds(&mock_io_cmd, 1);
51 err = nvme_zns_append(&args);
52 end_mock_cmds();
53 check(err == 0, "returned error %d, errno %m", err);
54 check(result == 0, "wrong result");
55 cmp(&data, &expected_data, sizeof(data), "incorrect data");
56 }
57
58 static void test_zns_report_zones(void)
59 {
60 __u8 expected_data[8], data[8] = {};
61 __u32 result = 0;
62 uint32_t timeout = 1234;
63 bool extended = true;
64 bool partial = true;
65 enum nvme_zns_report_options opts = NVME_ZNS_ZRAS_REPORT_CLOSED;
66
67 struct mock_cmd mock_io_cmd = {
68 .opcode = nvme_zns_cmd_mgmt_recv,
69 .nsid = TEST_NSID,
70 .cdw10 = TEST_SLBA & 0xffffffff,
71 .cdw11 = TEST_SLBA >> 32,
72 .cdw12 = (sizeof(expected_data) >> 2) - 1,
73 .cdw13 = (!!extended << 0) | ((__u16)opts << 8) |
74 (!!partial << 16),
75 .data_len = sizeof(expected_data),
76 .out_data = &expected_data,
77 .timeout_ms = timeout,
78 };
79
80 int err;
81
82 arbitrary(&expected_data, sizeof(expected_data));
83 set_mock_io_cmds(&mock_io_cmd, 1);
84 err = nvme_zns_report_zones(TEST_FD, TEST_NSID, TEST_SLBA, opts,
85 extended, partial, sizeof(data), &data,
86 timeout, &result);
87 end_mock_cmds();
88 check(err == 0, "returned error %d, errno %m", err);
89 check(result == 0, "returned result %u", result);
90 cmp(&data, &expected_data, sizeof(data), "incorrect data");
91 }
92
93 static void test_zns_mgmt_send(void)
94 {
95 __u8 expected_data[8], data[8] = {};
96 __u32 result = 0;
97 uint32_t timeout = 1234;
98
99 struct nvme_zns_mgmt_send_args args = {
100 .slba = TEST_SLBA,
101 .result = &result,
102 .data = data,
103 .args_size = sizeof(args),
104 .fd = TEST_FD,
105 .timeout = timeout,
106 .nsid = TEST_NSID,
107 .zsa = NVME_ZNS_ZSA_OPEN,
108 .data_len = sizeof(data),
109 .select_all = true,
110 .zsaso = !!true,
111 };
112
113 struct mock_cmd mock_io_cmd = {
114 .opcode = nvme_zns_cmd_mgmt_send,
115 .nsid = TEST_NSID,
116 .cdw10 = args.slba & 0xffffffff,
117 .cdw11 = args.slba >> 32,
118 .cdw13 = (args.zsaso << 9) | (!!args.select_all << 8) |
119 (args.zsa << 0),
120 .data_len = sizeof(expected_data),
121 .out_data = &expected_data,
122 .timeout_ms = timeout,
123 };
124
125 int err;
126
127 arbitrary(&expected_data, sizeof(expected_data));
128 set_mock_io_cmds(&mock_io_cmd, 1);
129 err = nvme_zns_mgmt_send(&args);
130 end_mock_cmds();
131 check(err == 0, "returned error %d, errno %m", err);
132 check(result == 0, "returned result %u", result);
133 cmp(&data, &expected_data, sizeof(data), "incorrect data");
134 }
135
136 static void test_zns_mgmt_recv(void)
137 {
138 __u8 expected_data[8], data[8] = {};
139 __u32 result = 0;
140 uint32_t timeout = 1234;
141 bool partial = false;
142
143 struct nvme_zns_mgmt_recv_args args = {
144 .slba = 0,
145 .result = &result,
146 .data = data,
147 .args_size = sizeof(args),
148 .fd = TEST_FD,
149 .timeout = timeout,
150 .nsid = TEST_NSID,
151 .zra = NVME_ZNS_ZRA_REPORT_ZONES,
152 .data_len = sizeof(data),
153 .zrasf = (__u16)NVME_ZNS_ZRAS_REPORT_ALL,
154 .zras_feat = partial,
155 };
156
157 struct mock_cmd mock_io_cmd = {
158 .opcode = nvme_zns_cmd_mgmt_recv,
159 .nsid = TEST_NSID,
160 .cdw12 = (sizeof(expected_data) >> 2) - 1,
161 .cdw13 = (!!args.zra << 0) | ((__u16)args.zrasf << 8) |
162 (!!args.zras_feat << 16),
163 .data_len = sizeof(expected_data),
164 .out_data = &expected_data,
165 .timeout_ms = timeout,
166 };
167
168 int err;
169
170 arbitrary(&expected_data, sizeof(expected_data));
171 set_mock_io_cmds(&mock_io_cmd, 1);
172 err = nvme_zns_mgmt_recv(&args);
173 end_mock_cmds();
174 check(err == 0, "returned error %d, errno %m", err);
175 check(result == 0, "returned result %u", result);
176 cmp(&data, &expected_data, sizeof(data), "incorrect data");
177 }
178
179 static void run_test(const char *test_name, void (*test_fn)(void))
180 {
181 printf("Running test %s...", test_name);
182 fflush(stdout);
183 test_fn();
184 puts(" OK");
185 }
186
187 #define RUN_TEST(name) run_test(#name, test_##name)
188
189 int main(void)
190 {
191 set_mock_fd(TEST_FD);
192 RUN_TEST(zns_append);
193 RUN_TEST(zns_report_zones);
194 RUN_TEST(zns_mgmt_send);
195 RUN_TEST(zns_mgmt_recv);
196 }