Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2021 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : : #include "spdk_internal/cunit.h"
8 : : #include "nvme/nvme_cuse.c"
9 : : #include "common/lib/nvme/common_stubs.h"
10 : :
11 : 4 : SPDK_LOG_REGISTER_COMPONENT(nvme)
12 : :
13 : 0 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_admin_raw, int, (struct spdk_nvme_ctrlr *ctrlr,
14 : : struct spdk_nvme_cmd *cmd, void *buf, uint32_t len,
15 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
16 : :
17 : 0 : DEFINE_STUB(spdk_nvme_ctrlr_cmd_io_raw_with_md, int, (struct spdk_nvme_ctrlr *ctrlr,
18 : : struct spdk_nvme_qpair *qpair, struct spdk_nvme_cmd *cmd, void *buf, uint32_t len, void *md_buf,
19 : : spdk_nvme_cmd_cb cb_fn, void *cb_arg), 0);
20 : :
21 : 0 : DEFINE_STUB(spdk_nvme_ctrlr_reset, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
22 : :
23 : 0 : DEFINE_STUB(spdk_nvme_ctrlr_reset_subsystem, int, (struct spdk_nvme_ctrlr *ctrlr), 0);
24 : :
25 : 0 : DEFINE_STUB(spdk_nvme_ns_cmd_read_with_md, int, (struct spdk_nvme_ns *ns,
26 : : struct spdk_nvme_qpair *qpair,
27 : : void *payload, void *metadata,
28 : : uint64_t lba, uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
29 : : uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag), 0);
30 : :
31 : 0 : DEFINE_STUB(spdk_nvme_ns_cmd_write_with_md, int, (struct spdk_nvme_ns *ns,
32 : : struct spdk_nvme_qpair *qpair,
33 : : void *payload, void *metadata,
34 : : uint64_t lba, uint32_t lba_count, spdk_nvme_cmd_cb cb_fn, void *cb_arg,
35 : : uint32_t io_flags, uint16_t apptag_mask, uint16_t apptag), 0);
36 : :
37 : 0 : DEFINE_STUB(spdk_nvme_ns_get_num_sectors, uint64_t,
38 : : (struct spdk_nvme_ns *ns), 0);
39 : :
40 : 12 : DEFINE_STUB(spdk_nvme_ns_get_md_size, uint32_t, (struct spdk_nvme_ns *ns), 0);
41 : :
42 : 0 : DEFINE_STUB_V(spdk_unaffinitize_thread, (void));
43 : :
44 : 0 : DEFINE_STUB(nvme_io_msg_ctrlr_register, int,
45 : : (struct spdk_nvme_ctrlr *ctrlr,
46 : : struct nvme_io_msg_producer *io_msg_producer), 0);
47 : :
48 : 0 : DEFINE_STUB_V(nvme_io_msg_ctrlr_unregister,
49 : : (struct spdk_nvme_ctrlr *ctrlr,
50 : : struct nvme_io_msg_producer *io_msg_producer));
51 : :
52 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_ctrlr_is_active_ns, bool,
53 : : (struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid), true);
54 : :
55 : 8 : DEFINE_STUB(fuse_reply_err, int, (fuse_req_t req, int err), 0);
56 : 4 : DEFINE_STUB_V(fuse_session_exit, (struct fuse_session *se));
57 : 12 : DEFINE_STUB(pthread_join, int, (pthread_t tid, void **val), 0);
58 : :
59 : 0 : DEFINE_STUB_V(nvme_ctrlr_update_namespaces, (struct spdk_nvme_ctrlr *ctrlr));
60 : :
61 : : static int
62 : 12 : nvme_ns_cmp(struct spdk_nvme_ns *ns1, struct spdk_nvme_ns *ns2)
63 : : {
64 : 12 : return ns1->id - ns2->id;
65 : : }
66 : :
67 [ - + - + : 20 : RB_GENERATE_STATIC(nvme_ns_tree, spdk_nvme_ns, node, nvme_ns_cmp);
+ + + - -
- + - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - + #
# # # # #
# # # # #
# # # ]
68 : :
69 : : struct cuse_io_ctx *g_ut_ctx;
70 : : struct spdk_nvme_ctrlr *g_ut_ctrlr;
71 : : uint32_t g_ut_nsid;
72 : :
73 : : uint32_t
74 : 0 : spdk_nvme_ctrlr_get_num_ns(struct spdk_nvme_ctrlr *ctrlr)
75 : : {
76 : 0 : return ctrlr->cdata.nn;
77 : : }
78 : :
79 : : uint32_t
80 : 0 : spdk_nvme_ctrlr_get_first_active_ns(struct spdk_nvme_ctrlr *ctrlr)
81 : : {
82 : 0 : return 1;
83 : : }
84 : :
85 : : uint32_t
86 : 0 : spdk_nvme_ctrlr_get_next_active_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
87 : : {
88 [ # # ]: 0 : if (nsid > ctrlr->cdata.nn) {
89 : 0 : return 0;
90 : : }
91 : :
92 : 0 : return nsid + 1;
93 : : }
94 : :
95 : : DEFINE_RETURN_MOCK(nvme_io_msg_send, int);
96 : : int
97 : 36 : nvme_io_msg_send(struct spdk_nvme_ctrlr *ctrlr,
98 : : uint32_t nsid, spdk_nvme_io_msg_fn fn, void *arg)
99 : : {
100 : 36 : g_ut_ctx = arg;
101 : 36 : g_ut_nsid = nsid;
102 : 36 : g_ut_ctrlr = ctrlr;
103 : :
104 [ - + - + ]: 36 : HANDLE_RETURN_MOCK(nvme_io_msg_send);
105 : 36 : return 0;
106 : : }
107 : :
108 : : uint32_t
109 : 12 : spdk_nvme_ns_get_sector_size(struct spdk_nvme_ns *ns)
110 : : {
111 : 12 : return ns->sector_size;
112 : : }
113 : :
114 : : static struct spdk_nvme_ns g_inactive_ns = {};
115 : :
116 : : struct spdk_nvme_ns *
117 : 12 : spdk_nvme_ctrlr_get_ns(struct spdk_nvme_ctrlr *ctrlr, uint32_t nsid)
118 : : {
119 : 12 : struct spdk_nvme_ns tmp;
120 : : struct spdk_nvme_ns *ns;
121 : :
122 [ + - - + ]: 12 : if (nsid < 1 || nsid > ctrlr->cdata.nn) {
123 : 0 : return NULL;
124 : : }
125 : :
126 : 12 : tmp.id = nsid;
127 : 12 : ns = RB_FIND(nvme_ns_tree, &ctrlr->ns, &tmp);
128 : :
129 [ - + ]: 12 : if (ns == NULL) {
130 : 0 : return &g_inactive_ns;
131 : : }
132 : :
133 : 12 : return ns;
134 : : }
135 : :
136 : : struct cuse_device *g_cuse_device;
137 : : DEFINE_RETURN_MOCK(fuse_req_userdata, void *);
138 : : void *
139 : : fuse_req_userdata(fuse_req_t req)
140 : : {
141 : 28 : return g_cuse_device;
142 : : }
143 : :
144 : : static void
145 : 4 : test_cuse_nvme_submit_io_read_write(void)
146 : : {
147 : 4 : struct cuse_device cuse_device = {};
148 : 4 : struct fuse_file_info fi = {};
149 : 4 : struct nvme_user_io *user_io = NULL;
150 : 4 : char arg[1024] = {};
151 : 4 : fuse_req_t req = (void *)0xDEEACDFF;
152 : 4 : unsigned flags = FUSE_IOCTL_DIR;
153 : 4 : uint32_t block_size = 4096;
154 : 4 : uint32_t md_size = 0;
155 : 4 : size_t in_bufsz = 4096;
156 : 4 : size_t out_bufsz = 4096;
157 : :
158 : : /* Allocate memory to avoid stack buffer overflow */
159 : 4 : user_io = calloc(3, 4096);
160 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(user_io != NULL);
161 : 4 : cuse_device.ctrlr = (void *)0xDEADBEEF;
162 : 4 : cuse_device.nsid = 1;
163 : 4 : user_io->slba = 1024;
164 : 4 : user_io->nblocks = 1;
165 : 4 : g_ut_ctx = NULL;
166 : :
167 : : /* Submit IO read */
168 : 4 : cuse_nvme_submit_io_read(&cuse_device, req, 0, arg, &fi, flags,
169 : : block_size, md_size, user_io, in_bufsz, out_bufsz);
170 : 4 : CU_ASSERT(g_ut_ctx != NULL);
171 : 4 : CU_ASSERT(g_ut_ctx->req == req);
172 : 4 : CU_ASSERT(g_ut_ctx->lba = user_io->slba);
173 : 4 : CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
174 : 4 : CU_ASSERT(g_ut_ctx->data_len ==
175 : : (int)((user_io->nblocks + 1) * block_size));
176 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
177 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 0);
178 : 4 : CU_ASSERT(g_ut_ctx->metadata == NULL);
179 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0);
180 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0);
181 : 4 : cuse_io_ctx_free(g_ut_ctx);
182 : :
183 : : /* Submit IO write */
184 : 4 : g_ut_ctx = NULL;
185 : :
186 : 4 : cuse_nvme_submit_io_write(&cuse_device, req, 0, arg, &fi, flags,
187 : : block_size, md_size, user_io, in_bufsz, out_bufsz);
188 : 4 : CU_ASSERT(g_ut_ctx != NULL);
189 : 4 : CU_ASSERT(g_ut_ctx->req == req);
190 : 4 : CU_ASSERT(g_ut_ctx->lba = user_io->slba);
191 : 4 : CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
192 : 4 : CU_ASSERT(g_ut_ctx->data_len ==
193 : : (int)((user_io->nblocks + 1) * block_size));
194 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
195 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 0);
196 : 4 : CU_ASSERT(g_ut_ctx->metadata == NULL);
197 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0);
198 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0);
199 : 4 : cuse_io_ctx_free(g_ut_ctx);
200 : 4 : free(user_io);
201 : 4 : }
202 : :
203 : : static void
204 : 4 : test_cuse_nvme_submit_io_read_write_with_md(void)
205 : : {
206 : 4 : struct cuse_device cuse_device = {};
207 : 4 : struct fuse_file_info fi = {};
208 : 4 : struct nvme_user_io *user_io = NULL;
209 : 4 : char arg[1024] = {};
210 : 4 : fuse_req_t req = (void *)0xDEEACDFF;
211 : 4 : unsigned flags = FUSE_IOCTL_DIR;
212 : 4 : uint32_t block_size = 4096;
213 : 4 : uint32_t md_size = 8;
214 : 4 : size_t in_bufsz = 4096;
215 : 4 : size_t out_bufsz = 4096;
216 : :
217 : : /* Allocate memory to avoid stack buffer overflow */
218 : 4 : user_io = calloc(4, 4096);
219 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(user_io != NULL);
220 : 4 : cuse_device.ctrlr = (void *)0xDEADBEEF;
221 : 4 : cuse_device.nsid = 1;
222 : 4 : user_io->slba = 1024;
223 : 4 : user_io->nblocks = 1;
224 : 4 : user_io->appmask = 0xF00D;
225 : 4 : user_io->apptag = 0xC0DE;
226 : 4 : user_io->metadata = 0xDEADDEAD;
227 : 4 : g_ut_ctx = NULL;
228 : :
229 : : /* Submit IO read */
230 : 4 : cuse_nvme_submit_io_read(&cuse_device, req, 0, arg, &fi, flags,
231 : : block_size, md_size, user_io, in_bufsz, out_bufsz);
232 : 4 : CU_ASSERT(g_ut_ctx != NULL);
233 : 4 : CU_ASSERT(g_ut_ctx->req == req);
234 : 4 : CU_ASSERT(g_ut_ctx->lba = user_io->slba);
235 : 4 : CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
236 : 4 : CU_ASSERT(g_ut_ctx->data_len ==
237 : : (int)((user_io->nblocks + 1) * block_size));
238 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
239 : 4 : CU_ASSERT(g_ut_ctx->metadata_len ==
240 : : (int)((user_io->nblocks + 1) * md_size));
241 : 4 : CU_ASSERT(g_ut_ctx->metadata != NULL);
242 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0xF00D);
243 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0xC0DE);
244 : 4 : cuse_io_ctx_free(g_ut_ctx);
245 : :
246 : : /* Submit IO write */
247 : 4 : g_ut_ctx = NULL;
248 : :
249 : 4 : cuse_nvme_submit_io_write(&cuse_device, req, 0, arg, &fi, flags,
250 : : block_size, md_size, user_io, in_bufsz, out_bufsz);
251 : 4 : CU_ASSERT(g_ut_ctx != NULL);
252 : 4 : CU_ASSERT(g_ut_ctx->req == req);
253 : 4 : CU_ASSERT(g_ut_ctx->lba = user_io->slba);
254 : 4 : CU_ASSERT(g_ut_ctx->lba_count == (uint32_t)(user_io->nblocks + 1));
255 : 4 : CU_ASSERT(g_ut_ctx->data_len ==
256 : : (int)((user_io->nblocks + 1) * block_size));
257 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
258 : 4 : CU_ASSERT(g_ut_ctx->metadata_len ==
259 : : (int)((user_io->nblocks + 1) * md_size));
260 : 4 : CU_ASSERT(g_ut_ctx->metadata != NULL);
261 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0xF00D);
262 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0xC0DE);
263 : 4 : cuse_io_ctx_free(g_ut_ctx);
264 : 4 : free(user_io);
265 : 4 : }
266 : :
267 : : static void
268 : 4 : test_cuse_nvme_submit_passthru_cmd(void)
269 : : {
270 : 4 : struct nvme_passthru_cmd *passthru_cmd = NULL;
271 : 4 : fuse_req_t req = (void *)0xDEEACDFF;
272 : :
273 : 4 : passthru_cmd = calloc(1, sizeof(struct nvme_passthru_cmd));
274 : 4 : g_cuse_device = calloc(1, sizeof(struct cuse_device));
275 : :
276 : : /* Use fatal or we'll segfault if we didn't get memory */
277 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(passthru_cmd != NULL);
278 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_cuse_device != NULL);
279 : 4 : g_cuse_device->ctrlr = (void *)0xDEADBEEF;
280 : :
281 : 4 : g_ut_ctx = NULL;
282 : : /* Passthrough command */
283 : 4 : passthru_cmd->opcode = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
284 : 4 : passthru_cmd->nsid = 1;
285 : 4 : passthru_cmd->data_len = 512;
286 : 4 : passthru_cmd->metadata_len = 0;
287 : 4 : passthru_cmd->cdw10 = 0xc0de1010;
288 : 4 : passthru_cmd->cdw11 = 0xc0de1111;
289 : 4 : passthru_cmd->cdw12 = 0xc0de1212;
290 : 4 : passthru_cmd->cdw13 = 0xc0de1313;
291 : 4 : passthru_cmd->cdw14 = 0xc0de1414;
292 : 4 : passthru_cmd->cdw15 = 0xc0de1515;
293 : :
294 : : /* Send IO Command IOCTL */
295 : 4 : cuse_nvme_passthru_cmd_send(req, passthru_cmd, NULL, NULL, NVME_IOCTL_IO_CMD);
296 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
297 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
298 : 4 : CU_ASSERT(g_ut_ctx->metadata == NULL);
299 : 4 : CU_ASSERT(g_ut_ctx->req == req);
300 : 4 : CU_ASSERT(g_ut_ctx->data_len == 512);
301 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 0);
302 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.opc == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
303 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.nsid == 1);
304 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw10 == 0xc0de1010);
305 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw11 == 0xc0de1111);
306 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw12 == 0xc0de1212);
307 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw13 == 0xc0de1313);
308 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw14 == 0xc0de1414);
309 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw15 == 0xc0de1515);
310 : :
311 : 4 : cuse_io_ctx_free(g_ut_ctx);
312 : 4 : free(passthru_cmd);
313 : 4 : free(g_cuse_device);
314 : 4 : }
315 : :
316 : : static void
317 : 4 : test_cuse_nvme_submit_passthru_cmd_with_md(void)
318 : : {
319 : 4 : struct nvme_passthru_cmd *passthru_cmd = NULL;
320 : 4 : fuse_req_t req = (void *)0xDEEACDFF;
321 : :
322 : 4 : passthru_cmd = calloc(1, sizeof(struct nvme_passthru_cmd));
323 : 4 : g_cuse_device = calloc(1, sizeof(struct cuse_device));
324 : :
325 : : /* Use fatal or we'll segfault if we didn't get memory */
326 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(passthru_cmd != NULL);
327 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_cuse_device != NULL);
328 : 4 : g_cuse_device->ctrlr = (void *)0xDEADBEEF;
329 : :
330 : 4 : g_ut_ctx = NULL;
331 : : /* Passthrough command */
332 : 4 : passthru_cmd->opcode = SPDK_NVME_DATA_CONTROLLER_TO_HOST;
333 : 4 : passthru_cmd->nsid = 1;
334 : 4 : passthru_cmd->data_len = 512;
335 : 4 : passthru_cmd->metadata_len = 8;
336 : 4 : passthru_cmd->cdw10 = 0xc0de1010;
337 : 4 : passthru_cmd->cdw11 = 0xc0de1111;
338 : 4 : passthru_cmd->cdw12 = 0xc0de1212;
339 : 4 : passthru_cmd->cdw13 = 0xc0de1313;
340 : 4 : passthru_cmd->cdw14 = 0xc0de1414;
341 : 4 : passthru_cmd->cdw15 = 0xc0de1515;
342 : :
343 : : /* Send IO Command IOCTL */
344 : 4 : cuse_nvme_passthru_cmd_send(req, passthru_cmd, NULL, NULL, NVME_IOCTL_IO_CMD);
345 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
346 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
347 : 4 : CU_ASSERT(g_ut_ctx->metadata != NULL);
348 : 4 : CU_ASSERT(g_ut_ctx->req == req);
349 : 4 : CU_ASSERT(g_ut_ctx->data_len == 512);
350 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 8);
351 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.opc == SPDK_NVME_DATA_CONTROLLER_TO_HOST);
352 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.nsid == 1);
353 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw10 == 0xc0de1010);
354 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw11 == 0xc0de1111);
355 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw12 == 0xc0de1212);
356 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw13 == 0xc0de1313);
357 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw14 == 0xc0de1414);
358 : 4 : CU_ASSERT(g_ut_ctx->nvme_cmd.cdw15 == 0xc0de1515);
359 : :
360 : 4 : cuse_io_ctx_free(g_ut_ctx);
361 : 4 : free(passthru_cmd);
362 : 4 : free(g_cuse_device);
363 : 4 : }
364 : :
365 : : static void
366 : 4 : test_nvme_cuse_get_cuse_ns_device(void)
367 : : {
368 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
369 : 4 : struct cuse_device ctrlr_device = {};
370 : 4 : struct cuse_device ns_device = { .nsid = 1 };
371 : 4 : struct cuse_device *cuse_dev = NULL;
372 : :
373 : 4 : ctrlr.cdata.nn = 3;
374 : 4 : ctrlr_device.ctrlr = &ctrlr;
375 : 4 : TAILQ_INIT(&ctrlr_device.ns_devices);
376 : 4 : TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_device, tailq);
377 : :
378 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&g_ctrlr_ctx_head));
379 : 4 : TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
380 : :
381 : 4 : cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 1);
382 : 4 : CU_ASSERT(cuse_dev == &ns_device);
383 : :
384 : : /* nsid 2 was not started */
385 : 4 : cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 2);
386 : 4 : CU_ASSERT(cuse_dev == NULL);
387 : :
388 : : /* nsid invalid */
389 : 4 : cuse_dev = nvme_cuse_get_cuse_ns_device(&ctrlr, 0);
390 : 4 : CU_ASSERT(cuse_dev == NULL);
391 : :
392 [ - + ]: 4 : TAILQ_REMOVE(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
393 : 4 : }
394 : :
395 : : static void
396 : 4 : test_cuse_nvme_submit_io(void)
397 : : {
398 : 4 : struct cuse_device cuse_device = {};
399 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
400 : 4 : struct fuse_file_info fi = {};
401 : 4 : struct spdk_nvme_ns ns = {};
402 : 4 : struct nvme_user_io *user_io = NULL;
403 : 4 : char arg[1024] = {};
404 : 4 : fuse_req_t req = (void *)0xDEEACDFF;
405 : :
406 : : /* Allocate memory to avoid stack buffer overflow */
407 : 4 : user_io = calloc(3, 4096);
408 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(user_io != NULL);
409 : :
410 : 4 : RB_INIT(&ctrlr.ns);
411 : 4 : ns.id = 1;
412 : 4 : RB_INSERT(nvme_ns_tree, &ctrlr.ns, &ns);
413 : :
414 : 4 : cuse_device.ctrlr = &ctrlr;
415 : 4 : ctrlr.cdata.nn = 1;
416 : 4 : ns.sector_size = 4096;
417 : 4 : ns.id = 1;
418 : 4 : user_io->slba = 1024;
419 : 4 : user_io->nblocks = 1;
420 : 4 : cuse_device.nsid = 1;
421 : 4 : g_cuse_device = &cuse_device;
422 : :
423 : : /* Read */
424 : 4 : user_io->opcode = SPDK_NVME_OPC_READ;
425 : 4 : g_ut_ctx = NULL;
426 : :
427 : 4 : cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
428 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
429 : 4 : CU_ASSERT(g_ut_nsid == 1);
430 : 4 : CU_ASSERT(g_ut_ctx->req == (void *)0xDEEACDFF);
431 : 4 : CU_ASSERT(g_ut_ctx->lba = 1024);
432 : 4 : CU_ASSERT(g_ut_ctx->lba_count == 2);
433 : 4 : CU_ASSERT(g_ut_ctx->data_len == 2 * 4096);
434 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
435 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 0);
436 : 4 : CU_ASSERT(g_ut_ctx->metadata == NULL);
437 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0);
438 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0);
439 : :
440 : 4 : cuse_io_ctx_free(g_ut_ctx);
441 : :
442 : : /* Write */
443 : 4 : user_io->opcode = SPDK_NVME_OPC_WRITE;
444 : 4 : g_ut_ctx = NULL;
445 : :
446 : 4 : cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
447 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ut_ctx != NULL);
448 : 4 : CU_ASSERT(g_ut_nsid == 1);
449 : 4 : CU_ASSERT(g_ut_ctx->req == req);
450 : 4 : CU_ASSERT(g_ut_ctx->lba = 1024);
451 : 4 : CU_ASSERT(g_ut_ctx->lba_count == 2);
452 : 4 : CU_ASSERT(g_ut_ctx->data_len == 2 * 4096);
453 : 4 : CU_ASSERT(g_ut_ctx->data != NULL);
454 : 4 : CU_ASSERT(g_ut_ctx->metadata_len == 0);
455 : 4 : CU_ASSERT(g_ut_ctx->metadata == NULL);
456 : 4 : CU_ASSERT(g_ut_ctx->appmask == 0);
457 : 4 : CU_ASSERT(g_ut_ctx->apptag == 0);
458 : 4 : cuse_io_ctx_free(g_ut_ctx);
459 : :
460 : : /* Invalid */
461 : 4 : g_ut_ctx = NULL;
462 : 4 : user_io->opcode = SPDK_NVME_OPC_FLUSH;
463 : :
464 : 4 : cuse_nvme_submit_io(req, 0, arg, &fi, FUSE_IOCTL_DIR, user_io, 4096, 4096);
465 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ut_ctx == NULL);
466 : :
467 : 4 : free(user_io);
468 : 4 : }
469 : :
470 : : static void
471 : 4 : test_cuse_nvme_reset(void)
472 : : {
473 : 4 : struct cuse_device cuse_device = {};
474 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
475 : 4 : fuse_req_t req = (void *)0xDEADBEEF;
476 : :
477 : 4 : cuse_device.ctrlr = &ctrlr;
478 : 4 : g_cuse_device = &cuse_device;
479 : :
480 : : /* Invalid nsid */
481 : 4 : cuse_device.nsid = 1;
482 : 4 : g_ut_ctx = NULL;
483 : :
484 : 4 : cuse_nvme_reset(req, 0, NULL, NULL, 0, NULL, 4096, 4096);
485 : 4 : CU_ASSERT(g_ut_ctx == NULL);
486 : :
487 : : /* Valid nsid, check IO message sent value */
488 : 4 : cuse_device.nsid = 0;
489 : :
490 : 4 : cuse_nvme_reset(req, 0, NULL, NULL, 0, NULL, 4096, 4096);
491 : 4 : CU_ASSERT(g_ut_ctx == (void *)0xDEADBEEF);
492 : 4 : CU_ASSERT(g_ut_ctrlr == &ctrlr);
493 : 4 : CU_ASSERT(g_ut_nsid == 0);
494 : 4 : }
495 : :
496 : : static void
497 : 4 : test_nvme_cuse_stop(void)
498 : : {
499 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
500 : 4 : struct cuse_device *ctrlr_device = NULL;
501 : : struct cuse_device *ns_dev1, *ns_dev2;
502 : :
503 : : /* Allocate memory for nvme_cuse_stop() to free. */
504 : 4 : ctrlr_device = calloc(1, sizeof(struct cuse_device));
505 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(ctrlr_device != NULL);
506 : :
507 : 4 : TAILQ_INIT(&ctrlr_device->ns_devices);
508 : 4 : ns_dev1 = calloc(1, sizeof(struct cuse_device));
509 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(ns_dev1 != NULL);
510 : 4 : ns_dev2 = calloc(1, sizeof(struct cuse_device));
511 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(ns_dev2 != NULL);
512 : :
513 : 4 : g_ctrlr_started = spdk_bit_array_create(128);
514 [ - + ]: 4 : SPDK_CU_ASSERT_FATAL(g_ctrlr_started != NULL);
515 : :
516 : 4 : TAILQ_INSERT_TAIL(&ctrlr_device->ns_devices, ns_dev1, tailq);
517 : 4 : TAILQ_INSERT_TAIL(&ctrlr_device->ns_devices, ns_dev2, tailq);
518 : 4 : ctrlr.cdata.nn = 2;
519 : 4 : ctrlr_device->ctrlr = &ctrlr;
520 : 4 : pthread_mutex_init(&g_cuse_mtx, NULL);
521 : 4 : TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, ctrlr_device, tailq);
522 : :
523 : 4 : nvme_cuse_stop(&ctrlr);
524 : 4 : CU_ASSERT(g_ctrlr_started == NULL);
525 : 4 : CU_ASSERT(TAILQ_EMPTY(&g_ctrlr_ctx_head));
526 : 4 : }
527 : :
528 : : static void
529 : 4 : test_spdk_nvme_cuse_get_ctrlr_name(void)
530 : : {
531 : 4 : int rc_ctrlr = 0;
532 : 4 : int rc_ns = 0;
533 : 4 : uint32_t nsid = 0;
534 : 4 : const uint32_t NSID1 = 12;
535 : 4 : const uint32_t NSID2 = 22;
536 : 4 : size_t name_size = 0;
537 : :
538 : 4 : char name_ctrlr[128] = "unit_test_ctrlr_dev_name";
539 : 4 : char name_ns_1[128] = "unit_test_ns_dev_name_1";
540 : 4 : char name_ns_2[128] = "unit_test_ns_dev_name_2";
541 : :
542 : 4 : char rt_name_ctrlr[128];
543 : 4 : char rt_name_ns[128];
544 : :
545 : 4 : struct spdk_nvme_ctrlr ctrlr = {};
546 : 4 : struct cuse_device ctrlr_device = {};
547 : 4 : struct cuse_device ns_dev1 = {};
548 : 4 : struct cuse_device ns_dev2 = {};
549 : :
550 : 4 : ctrlr_device.ctrlr = &ctrlr;
551 : 4 : memcpy(ctrlr_device.dev_name, name_ctrlr, sizeof(ctrlr_device.dev_name));
552 : :
553 : 4 : TAILQ_INIT(&ctrlr_device.ns_devices);
554 : 4 : ns_dev1.nsid = NSID1;
555 : 4 : ns_dev2.nsid = NSID2;
556 : :
557 : 4 : memcpy(ns_dev1.dev_name, name_ns_1, sizeof(ns_dev1.dev_name));
558 : 4 : memcpy(ns_dev2.dev_name, name_ns_2, sizeof(ns_dev2.dev_name));
559 : 4 : TAILQ_INIT(&g_ctrlr_ctx_head);
560 : 4 : TAILQ_INIT(&ctrlr_device.ns_devices);
561 : 4 : TAILQ_INSERT_TAIL(&g_ctrlr_ctx_head, &ctrlr_device, tailq);
562 : 4 : TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_dev1, tailq);
563 : 4 : TAILQ_INSERT_TAIL(&ctrlr_device.ns_devices, &ns_dev2, tailq);
564 : :
565 : : /* Test case: Give a null spdk_nvme_ctrlr to find cuse_device. Expect: Return -ENODEV failed */
566 : 4 : rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(NULL, rt_name_ctrlr, &name_size);
567 : 4 : CU_ASSERT(rc_ctrlr == -ENODEV);
568 : 4 : rc_ns = spdk_nvme_cuse_get_ns_name(NULL, nsid, rt_name_ctrlr, &name_size);
569 : 4 : CU_ASSERT(rc_ns == -ENODEV);
570 : :
571 : : /* Test case: Give a wrong nsid to find cuse_device. Expect: Return -ENODEV failed */
572 : 4 : rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, nsid, rt_name_ns, &name_size);
573 : 4 : CU_ASSERT(rc_ns == -ENODEV);
574 : :
575 : : /* Test case: Let parameter size<sizeof(dev_name). Expect: Return -ENOSPC failed */
576 : 4 : name_size = 0;
577 : 4 : rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(&ctrlr, rt_name_ctrlr, &name_size);
578 : 4 : CU_ASSERT(rc_ctrlr == -ENOSPC);
579 : 4 : name_size = 0;
580 : 4 : rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, NSID1, rt_name_ns, &name_size);
581 : 4 : CU_ASSERT(rc_ns == -ENOSPC);
582 : :
583 : : /* Test case: All parameters is conformed to function. Expect: Success */
584 : 4 : name_size = 128;
585 : 4 : rc_ctrlr = spdk_nvme_cuse_get_ctrlr_name(&ctrlr, rt_name_ctrlr, &name_size);
586 : 4 : CU_ASSERT(rc_ctrlr == 0);
587 : 4 : rc_ns = spdk_nvme_cuse_get_ns_name(&ctrlr, NSID1, rt_name_ns, &name_size);
588 : 4 : CU_ASSERT(rc_ns == 0);
589 : 4 : CU_ASSERT(strncmp(rt_name_ctrlr, name_ctrlr, sizeof(name_ctrlr)) == 0);
590 : 4 : CU_ASSERT(strncmp(rt_name_ns, name_ns_1, sizeof(name_ns_1)) == 0);
591 : 4 : }
592 : :
593 : : int
594 : 4 : main(int argc, char **argv)
595 : : {
596 : 4 : CU_pSuite suite = NULL;
597 : : unsigned int num_failures;
598 : :
599 : 4 : CU_initialize_registry();
600 : :
601 : 4 : suite = CU_add_suite("nvme_cuse", NULL, NULL);
602 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_submit_io_read_write);
603 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_submit_io_read_write_with_md);
604 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_submit_passthru_cmd);
605 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_submit_passthru_cmd_with_md);
606 : 4 : CU_ADD_TEST(suite, test_nvme_cuse_get_cuse_ns_device);
607 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_submit_io);
608 : 4 : CU_ADD_TEST(suite, test_cuse_nvme_reset);
609 : 4 : CU_ADD_TEST(suite, test_nvme_cuse_stop);
610 : 4 : CU_ADD_TEST(suite, test_spdk_nvme_cuse_get_ctrlr_name);
611 : :
612 : 4 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
613 : 4 : CU_cleanup_registry();
614 : 4 : return num_failures;
615 : : }
|