Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2018 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk_internal/cunit.h"
7 : :
8 : : #include "nvme/nvme_ns_ocssd_cmd.c"
9 : : #include "nvme/nvme_ns_cmd.c"
10 : : #include "nvme/nvme.c"
11 : :
12 : : #include "common/lib/test_env.c"
13 : :
14 : : #define OCSSD_SECTOR_SIZE 0x1000
15 : :
16 : : static struct nvme_driver _g_nvme_driver = {
17 : : .lock = PTHREAD_MUTEX_INITIALIZER,
18 : : };
19 : :
20 : : static struct nvme_request *g_request = NULL;
21 : :
22 : 0 : DEFINE_STUB_V(nvme_io_msg_ctrlr_detach, (struct spdk_nvme_ctrlr *ctrlr));
23 : :
24 : 0 : DEFINE_STUB_V(nvme_ctrlr_destruct_async,
25 : : (struct spdk_nvme_ctrlr *ctrlr, struct nvme_ctrlr_detach_ctx *ctx));
26 : :
27 [ # # ]: 0 : DEFINE_STUB(nvme_ctrlr_destruct_poll_async,
28 : : int,
29 : : (struct spdk_nvme_ctrlr *ctrlr, struct nvme_ctrlr_detach_ctx *ctx),
30 : : 0);
31 : :
32 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_poll_group_process_completions,
33 : : int64_t,
34 : : (struct spdk_nvme_poll_group *group, uint32_t completions_per_qpair,
35 : : spdk_nvme_disconnected_qpair_cb disconnected_qpair_cb),
36 : : 0);
37 : :
38 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_qpair_process_completions,
39 : : int32_t,
40 : : (struct spdk_nvme_qpair *qpair, uint32_t max_completions),
41 : : 0);
42 : :
43 [ # # ]: 0 : DEFINE_STUB(spdk_nvme_ctrlr_get_regs_csts,
44 : : union spdk_nvme_csts_register,
45 : : (struct spdk_nvme_ctrlr *ctrlr),
46 : : {});
47 : :
48 [ # # ]: 0 : DEFINE_STUB(spdk_pci_event_listen, int, (void), 1);
49 : :
50 : 0 : DEFINE_STUB_V(nvme_ctrlr_fail,
51 : : (struct spdk_nvme_ctrlr *ctrlr, bool hotremove));
52 : :
53 [ # # ]: 0 : DEFINE_STUB(nvme_transport_ctrlr_destruct,
54 : : int,
55 : : (struct spdk_nvme_ctrlr *ctrlr),
56 : : 0);
57 : :
58 [ # # ]: 0 : DEFINE_STUB(nvme_ctrlr_get_current_process,
59 : : struct spdk_nvme_ctrlr_process *,
60 : : (struct spdk_nvme_ctrlr *ctrlr),
61 : : (struct spdk_nvme_ctrlr_process *)(uintptr_t)0x1);
62 : :
63 [ # # ]: 0 : DEFINE_STUB(nvme_transport_ctrlr_scan_attached,
64 : : int,
65 : : (struct spdk_nvme_probe_ctx *probe_ctx),
66 : : 0);
67 : :
68 : : int
69 : 36 : nvme_qpair_submit_request(struct spdk_nvme_qpair *qpair, struct nvme_request *req)
70 : : {
71 : 36 : g_request = req;
72 : :
73 : 36 : return 0;
74 : : }
75 : :
76 : : void
77 : 0 : nvme_ctrlr_destruct(struct spdk_nvme_ctrlr *ctrlr)
78 : : {
79 : 0 : }
80 : :
81 : : void
82 : 0 : nvme_ctrlr_proc_get_ref(struct spdk_nvme_ctrlr *ctrlr)
83 : : {
84 : 0 : return;
85 : : }
86 : :
87 : : int
88 : 0 : nvme_ctrlr_process_init(struct spdk_nvme_ctrlr *ctrlr)
89 : : {
90 : 0 : return 0;
91 : : }
92 : :
93 : : void
94 : 0 : nvme_ctrlr_proc_put_ref(struct spdk_nvme_ctrlr *ctrlr)
95 : : {
96 : 0 : return;
97 : : }
98 : :
99 : : void
100 : 0 : spdk_nvme_ctrlr_get_default_ctrlr_opts(struct spdk_nvme_ctrlr_opts *opts, size_t opts_size)
101 : : {
102 [ # # ]: 0 : memset(opts, 0, sizeof(*opts));
103 : 0 : }
104 : :
105 : : bool
106 : 0 : spdk_nvme_transport_available_by_name(const char *transport_name)
107 : : {
108 : 0 : return true;
109 : : }
110 : :
111 : 0 : struct spdk_nvme_ctrlr *nvme_transport_ctrlr_construct(const struct spdk_nvme_transport_id *trid,
112 : : const struct spdk_nvme_ctrlr_opts *opts,
113 : : void *devhandle)
114 : : {
115 : 0 : return NULL;
116 : : }
117 : :
118 : : int
119 : 0 : nvme_ctrlr_get_ref_count(struct spdk_nvme_ctrlr *ctrlr)
120 : : {
121 : 0 : return 0;
122 : : }
123 : :
124 : : int
125 : 0 : nvme_transport_ctrlr_scan(struct spdk_nvme_probe_ctx *probe_ctx,
126 : : bool direct_connect)
127 : : {
128 : 0 : return 0;
129 : : }
130 : :
131 : : uint32_t
132 : 36 : spdk_nvme_ns_get_max_io_xfer_size(struct spdk_nvme_ns *ns)
133 : : {
134 : 36 : return ns->ctrlr->max_xfer_size;
135 : : }
136 : :
137 : : static void
138 : 36 : prepare_for_test(struct spdk_nvme_ns *ns, struct spdk_nvme_ctrlr *ctrlr,
139 : : struct spdk_nvme_qpair *qpair,
140 : : uint32_t sector_size, uint32_t md_size, uint32_t max_xfer_size,
141 : : uint32_t stripe_size, bool extended_lba)
142 : : {
143 : 36 : uint32_t num_requests = 32;
144 : : uint32_t i;
145 : :
146 [ - + ]: 36 : memset(ctrlr, 0, sizeof(*ctrlr));
147 : 36 : ctrlr->max_xfer_size = max_xfer_size;
148 : : /*
149 : : * Clear the flags field - we especially want to make sure the SGL_SUPPORTED flag is not set
150 : : * so that we test the SGL splitting path.
151 : : */
152 : 36 : ctrlr->flags = 0;
153 : 36 : ctrlr->min_page_size = 4096;
154 : 36 : ctrlr->page_size = 4096;
155 [ - + ]: 36 : memset(&ctrlr->opts, 0, sizeof(ctrlr->opts));
156 [ - + ]: 36 : memset(ns, 0, sizeof(*ns));
157 : 36 : ns->ctrlr = ctrlr;
158 : 36 : ns->sector_size = sector_size;
159 : 36 : ns->extended_lba_size = sector_size;
160 [ - + ]: 36 : if (extended_lba) {
161 : 0 : ns->flags |= SPDK_NVME_NS_EXTENDED_LBA_SUPPORTED;
162 : 0 : ns->extended_lba_size += md_size;
163 : : }
164 : 36 : ns->md_size = md_size;
165 [ - + ]: 36 : ns->sectors_per_max_io = spdk_nvme_ns_get_max_io_xfer_size(ns) / ns->extended_lba_size;
166 [ - + ]: 36 : ns->sectors_per_stripe = stripe_size / ns->extended_lba_size;
167 : :
168 [ - + ]: 36 : memset(qpair, 0, sizeof(*qpair));
169 : 36 : qpair->ctrlr = ctrlr;
170 : 36 : qpair->req_buf = calloc(num_requests, sizeof(struct nvme_request));
171 [ - + ]: 36 : SPDK_CU_ASSERT_FATAL(qpair->req_buf != NULL);
172 : :
173 [ + + ]: 1188 : for (i = 0; i < num_requests; i++) {
174 : 1152 : struct nvme_request *req = qpair->req_buf + i * sizeof(struct nvme_request);
175 : :
176 : 1152 : req->qpair = qpair;
177 [ + + ]: 1152 : STAILQ_INSERT_HEAD(&qpair->free_req, req, stailq);
178 : : }
179 : :
180 : 36 : g_request = NULL;
181 : 36 : }
182 : :
183 : : static void
184 : 36 : cleanup_after_test(struct spdk_nvme_qpair *qpair)
185 : : {
186 : 36 : free(qpair->req_buf);
187 : 36 : }
188 : :
189 : : static void
190 : 3 : test_nvme_ocssd_ns_cmd_vector_reset_single_entry(void)
191 : : {
192 : 3 : const uint32_t max_xfer_size = 0x10000;
193 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
194 : :
195 : 3 : struct spdk_nvme_ns ns;
196 : 3 : struct spdk_nvme_ctrlr ctrlr;
197 : 3 : struct spdk_nvme_qpair qpair;
198 : :
199 : 3 : int rc = 0;
200 : :
201 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
202 : 3 : uint64_t lba_list = 0x12345678;
203 : 3 : spdk_nvme_ocssd_ns_cmd_vector_reset(&ns, &qpair, &lba_list, 1,
204 : : NULL, NULL, NULL);
205 : :
206 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
207 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
208 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
209 : :
210 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_RESET);
211 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
212 : 3 : CU_ASSERT(g_request->cmd.cdw10 == lba_list);
213 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
214 : :
215 : 3 : nvme_free_request(g_request);
216 : 3 : cleanup_after_test(&qpair);
217 : 3 : }
218 : :
219 : : static void
220 : 3 : test_nvme_ocssd_ns_cmd_vector_reset(void)
221 : 3 : {
222 : 3 : const uint32_t max_xfer_size = 0x10000;
223 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
224 : 3 : const uint32_t vector_size = 0x10;
225 : :
226 : 3 : struct spdk_nvme_ns ns;
227 : 3 : struct spdk_nvme_ctrlr ctrlr;
228 : 3 : struct spdk_nvme_qpair qpair;
229 : :
230 : 3 : int rc = 0;
231 : :
232 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
233 [ - + ]: 3 : uint64_t lba_list[vector_size];
234 : 3 : spdk_nvme_ocssd_ns_cmd_vector_reset(&ns, &qpair, lba_list, vector_size,
235 : : NULL, NULL, NULL);
236 : :
237 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
238 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
239 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
240 : :
241 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_RESET);
242 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
243 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
244 : :
245 : 3 : nvme_free_request(g_request);
246 : 3 : cleanup_after_test(&qpair);
247 : 3 : }
248 : :
249 : : static void
250 : 3 : test_nvme_ocssd_ns_cmd_vector_read_with_md_single_entry(void)
251 : : {
252 : 3 : const uint32_t max_xfer_size = 0x10000;
253 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
254 : 3 : const uint32_t md_size = 0x80;
255 : :
256 : 3 : struct spdk_nvme_ns ns;
257 : 3 : struct spdk_nvme_ctrlr ctrlr;
258 : 3 : struct spdk_nvme_qpair qpair;
259 : :
260 : 3 : int rc = 0;
261 : :
262 : 3 : char *buffer = malloc(sector_size);
263 : 3 : char *metadata = malloc(md_size);
264 : 3 : uint64_t lba_list = 0x12345678;
265 : :
266 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
267 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(metadata != NULL);
268 : :
269 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, md_size, max_xfer_size, 0, false);
270 : 3 : rc = spdk_nvme_ocssd_ns_cmd_vector_read_with_md(&ns, &qpair, buffer, metadata,
271 : : &lba_list, 1, NULL, NULL, 0);
272 : :
273 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
274 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
275 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
276 : :
277 : 3 : CU_ASSERT(g_request->payload.md == metadata);
278 : 3 : CU_ASSERT(g_request->payload_size == OCSSD_SECTOR_SIZE);
279 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
280 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_READ);
281 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
282 : 3 : CU_ASSERT(g_request->cmd.cdw10 == lba_list);
283 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
284 : :
285 : 3 : nvme_free_request(g_request);
286 : 3 : cleanup_after_test(&qpair);
287 : :
288 : 3 : free(buffer);
289 : 3 : free(metadata);
290 : 3 : }
291 : :
292 : : static void
293 : 3 : test_nvme_ocssd_ns_cmd_vector_read_with_md(void)
294 : 3 : {
295 : 3 : const uint32_t max_xfer_size = 0x10000;
296 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
297 : 3 : const uint32_t md_size = 0x80;
298 : 3 : const uint32_t vector_size = 0x10;
299 : :
300 : 3 : struct spdk_nvme_ns ns;
301 : 3 : struct spdk_nvme_ctrlr ctrlr;
302 : 3 : struct spdk_nvme_qpair qpair;
303 : :
304 : 3 : int rc = 0;
305 : :
306 : 3 : char *buffer = malloc(sector_size * vector_size);
307 : 3 : char *metadata = malloc(md_size * vector_size);
308 [ - + ]: 3 : uint64_t lba_list[vector_size];
309 : :
310 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
311 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(metadata != NULL);
312 : :
313 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, md_size, max_xfer_size, 0, false);
314 : 3 : rc = spdk_nvme_ocssd_ns_cmd_vector_read_with_md(&ns, &qpair, buffer, metadata,
315 : : lba_list, vector_size,
316 : : NULL, NULL, 0);
317 : :
318 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
319 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
320 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
321 : :
322 : 3 : CU_ASSERT(g_request->payload.md == metadata);
323 : 3 : CU_ASSERT(g_request->payload_size == max_xfer_size);
324 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
325 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_READ);
326 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
327 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
328 : :
329 : 3 : nvme_free_request(g_request);
330 : 3 : cleanup_after_test(&qpair);
331 : :
332 : 3 : free(buffer);
333 : 3 : free(metadata);
334 : 3 : }
335 : :
336 : : static void
337 : 3 : test_nvme_ocssd_ns_cmd_vector_read_single_entry(void)
338 : : {
339 : 3 : const uint32_t max_xfer_size = 0x10000;
340 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
341 : :
342 : 3 : struct spdk_nvme_ns ns;
343 : 3 : struct spdk_nvme_ctrlr ctrlr;
344 : 3 : struct spdk_nvme_qpair qpair;
345 : :
346 : 3 : int rc = 0;
347 : :
348 : 3 : char *buffer = malloc(sector_size);
349 : 3 : uint64_t lba_list = 0x12345678;
350 : :
351 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
352 : :
353 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
354 : 3 : rc = spdk_nvme_ocssd_ns_cmd_vector_read(&ns, &qpair, buffer, &lba_list, 1,
355 : : NULL, NULL, 0);
356 : :
357 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
358 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
359 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
360 : :
361 : 3 : CU_ASSERT(g_request->payload_size == OCSSD_SECTOR_SIZE);
362 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
363 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_READ);
364 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
365 : 3 : CU_ASSERT(g_request->cmd.cdw10 == lba_list);
366 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
367 : :
368 : 3 : nvme_free_request(g_request);
369 : 3 : cleanup_after_test(&qpair);
370 : 3 : free(buffer);
371 : 3 : }
372 : :
373 : : static void
374 : 3 : test_nvme_ocssd_ns_cmd_vector_read(void)
375 : 3 : {
376 : 3 : const uint32_t max_xfer_size = 0x10000;
377 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
378 : 3 : const uint32_t vector_size = 0x10;
379 : :
380 : 3 : struct spdk_nvme_ns ns;
381 : 3 : struct spdk_nvme_ctrlr ctrlr;
382 : 3 : struct spdk_nvme_qpair qpair;
383 : :
384 : 3 : int rc = 0;
385 : :
386 : 3 : char *buffer = malloc(sector_size * vector_size);
387 [ - + ]: 3 : uint64_t lba_list[vector_size];
388 : :
389 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
390 : :
391 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
392 : 3 : rc = spdk_nvme_ocssd_ns_cmd_vector_read(&ns, &qpair, buffer, lba_list, vector_size,
393 : : NULL, NULL, 0);
394 : :
395 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
396 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
397 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
398 : :
399 : 3 : CU_ASSERT(g_request->payload_size == max_xfer_size);
400 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
401 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_READ);
402 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
403 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
404 : :
405 : 3 : nvme_free_request(g_request);
406 : 3 : cleanup_after_test(&qpair);
407 : 3 : free(buffer);
408 : 3 : }
409 : :
410 : : static void
411 : 3 : test_nvme_ocssd_ns_cmd_vector_write_with_md_single_entry(void)
412 : : {
413 : 3 : const uint32_t max_xfer_size = 0x10000;
414 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
415 : 3 : const uint32_t md_size = 0x80;
416 : :
417 : 3 : struct spdk_nvme_ns ns;
418 : 3 : struct spdk_nvme_ctrlr ctrlr;
419 : 3 : struct spdk_nvme_qpair qpair;
420 : :
421 : 3 : int rc = 0;
422 : :
423 : 3 : char *buffer = malloc(sector_size);
424 : 3 : char *metadata = malloc(md_size);
425 : 3 : uint64_t lba_list = 0x12345678;
426 : :
427 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
428 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(metadata != NULL);
429 : :
430 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, md_size, max_xfer_size, 0, false);
431 : 3 : spdk_nvme_ocssd_ns_cmd_vector_write_with_md(&ns, &qpair, buffer, metadata,
432 : : &lba_list, 1, NULL, NULL, 0);
433 : :
434 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
435 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
436 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
437 : :
438 : 3 : CU_ASSERT(g_request->payload.md == metadata);
439 : 3 : CU_ASSERT(g_request->payload_size == OCSSD_SECTOR_SIZE);
440 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
441 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_WRITE);
442 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
443 : 3 : CU_ASSERT(g_request->cmd.cdw10 == lba_list);
444 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
445 : :
446 : 3 : nvme_free_request(g_request);
447 : 3 : cleanup_after_test(&qpair);
448 : :
449 : 3 : free(buffer);
450 : 3 : free(metadata);
451 : 3 : }
452 : :
453 : :
454 : : static void
455 : 3 : test_nvme_ocssd_ns_cmd_vector_write_with_md(void)
456 : 3 : {
457 : 3 : const uint32_t max_xfer_size = 0x10000;
458 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
459 : 3 : const uint32_t md_size = 0x80;
460 : 3 : const uint32_t vector_size = 0x10;
461 : :
462 : 3 : struct spdk_nvme_ns ns;
463 : 3 : struct spdk_nvme_ctrlr ctrlr;
464 : 3 : struct spdk_nvme_qpair qpair;
465 : :
466 : 3 : int rc = 0;
467 : :
468 : 3 : char *buffer = malloc(sector_size * vector_size);
469 : 3 : char *metadata = malloc(md_size * vector_size);
470 [ - + ]: 3 : uint64_t lba_list[vector_size];
471 : :
472 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
473 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(metadata != NULL);
474 : :
475 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, md_size, max_xfer_size, 0, false);
476 : 3 : spdk_nvme_ocssd_ns_cmd_vector_write_with_md(&ns, &qpair, buffer, metadata,
477 : : lba_list, vector_size,
478 : : NULL, NULL, 0);
479 : :
480 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
481 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
482 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
483 : :
484 : 3 : CU_ASSERT(g_request->payload.md == metadata);
485 : 3 : CU_ASSERT(g_request->payload_size == max_xfer_size);
486 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
487 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_WRITE);
488 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
489 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
490 : :
491 : 3 : nvme_free_request(g_request);
492 : 3 : cleanup_after_test(&qpair);
493 : :
494 : 3 : free(buffer);
495 : 3 : free(metadata);
496 : 3 : }
497 : :
498 : : static void
499 : 3 : test_nvme_ocssd_ns_cmd_vector_write_single_entry(void)
500 : : {
501 : 3 : const uint32_t max_xfer_size = 0x10000;
502 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
503 : :
504 : 3 : struct spdk_nvme_ns ns;
505 : 3 : struct spdk_nvme_ctrlr ctrlr;
506 : 3 : struct spdk_nvme_qpair qpair;
507 : :
508 : 3 : int rc = 0;
509 : :
510 : 3 : char *buffer = malloc(sector_size);
511 : 3 : uint64_t lba_list = 0x12345678;
512 : :
513 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
514 : :
515 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
516 : 3 : spdk_nvme_ocssd_ns_cmd_vector_write(&ns, &qpair, buffer,
517 : : &lba_list, 1, NULL, NULL, 0);
518 : :
519 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
520 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
521 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
522 : :
523 : 3 : CU_ASSERT(g_request->payload_size == OCSSD_SECTOR_SIZE);
524 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
525 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_WRITE);
526 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
527 : 3 : CU_ASSERT(g_request->cmd.cdw10 == lba_list);
528 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
529 : :
530 : 3 : nvme_free_request(g_request);
531 : 3 : cleanup_after_test(&qpair);
532 : :
533 : 3 : free(buffer);
534 : 3 : }
535 : :
536 : : static void
537 : 3 : test_nvme_ocssd_ns_cmd_vector_write(void)
538 : 3 : {
539 : 3 : const uint32_t max_xfer_size = 0x10000;
540 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
541 : 3 : const uint32_t vector_size = 0x10;
542 : :
543 : 3 : struct spdk_nvme_ns ns;
544 : 3 : struct spdk_nvme_ctrlr ctrlr;
545 : 3 : struct spdk_nvme_qpair qpair;
546 : :
547 : 3 : int rc = 0;
548 : :
549 : 3 : char *buffer = malloc(sector_size * vector_size);
550 [ - + ]: 3 : uint64_t lba_list[vector_size];
551 : :
552 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(buffer != NULL);
553 : :
554 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
555 : 3 : spdk_nvme_ocssd_ns_cmd_vector_write(&ns, &qpair, buffer,
556 : : lba_list, vector_size,
557 : : NULL, NULL, 0);
558 : :
559 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
560 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
561 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
562 : :
563 : 3 : CU_ASSERT(g_request->payload_size == max_xfer_size);
564 : 3 : CU_ASSERT(g_request->payload.contig_or_cb_arg == buffer);
565 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_WRITE);
566 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
567 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
568 : :
569 : 3 : nvme_free_request(g_request);
570 : 3 : cleanup_after_test(&qpair);
571 : :
572 : 3 : free(buffer);
573 : 3 : }
574 : :
575 : : static void
576 : 3 : test_nvme_ocssd_ns_cmd_vector_copy_single_entry(void)
577 : : {
578 : 3 : const uint32_t max_xfer_size = 0x10000;
579 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
580 : :
581 : 3 : struct spdk_nvme_ns ns;
582 : 3 : struct spdk_nvme_ctrlr ctrlr;
583 : 3 : struct spdk_nvme_qpair qpair;
584 : :
585 : 3 : int rc = 0;
586 : :
587 : 3 : uint64_t src_lba_list = 0x12345678;
588 : 3 : uint64_t dst_lba_list = 0x87654321;
589 : :
590 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
591 : 3 : spdk_nvme_ocssd_ns_cmd_vector_copy(&ns, &qpair, &dst_lba_list, &src_lba_list, 1,
592 : : NULL, NULL, 0);
593 : :
594 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
595 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
596 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
597 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_COPY);
598 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
599 : 3 : CU_ASSERT(g_request->cmd.cdw10 == src_lba_list);
600 : 3 : CU_ASSERT(g_request->cmd.cdw12 == 0);
601 : 3 : CU_ASSERT(g_request->cmd.cdw14 == dst_lba_list);
602 : :
603 : 3 : nvme_free_request(g_request);
604 : 3 : cleanup_after_test(&qpair);
605 : 3 : }
606 : :
607 : : static void
608 : 3 : test_nvme_ocssd_ns_cmd_vector_copy(void)
609 : 3 : {
610 : 3 : const uint32_t max_xfer_size = 0x10000;
611 : 3 : const uint32_t sector_size = OCSSD_SECTOR_SIZE;
612 : 3 : const uint32_t vector_size = 0x10;
613 : :
614 : 3 : struct spdk_nvme_ns ns;
615 : 3 : struct spdk_nvme_ctrlr ctrlr;
616 : 3 : struct spdk_nvme_qpair qpair;
617 : :
618 : 3 : int rc = 0;
619 : :
620 [ - + ]: 3 : uint64_t src_lba_list[vector_size];
621 [ - + ]: 3 : uint64_t dst_lba_list[vector_size];
622 : :
623 : 3 : prepare_for_test(&ns, &ctrlr, &qpair, sector_size, 0, max_xfer_size, 0, false);
624 : 3 : spdk_nvme_ocssd_ns_cmd_vector_copy(&ns, &qpair,
625 : : dst_lba_list, src_lba_list, vector_size,
626 : : NULL, NULL, 0);
627 : :
628 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(rc == 0);
629 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request != NULL);
630 [ - + ]: 3 : SPDK_CU_ASSERT_FATAL(g_request->num_children == 0);
631 : 3 : CU_ASSERT(g_request->cmd.opc == SPDK_OCSSD_OPC_VECTOR_COPY);
632 : 3 : CU_ASSERT(g_request->cmd.nsid == ns.id);
633 : 3 : CU_ASSERT(g_request->cmd.cdw12 == vector_size - 1);
634 : :
635 : 3 : nvme_free_request(g_request);
636 : 3 : cleanup_after_test(&qpair);
637 : 3 : }
638 : :
639 : : int
640 : 3 : main(int argc, char **argv)
641 : : {
642 : 3 : CU_pSuite suite = NULL;
643 : : unsigned int num_failures;
644 : :
645 : 3 : CU_initialize_registry();
646 : :
647 : 3 : suite = CU_add_suite("nvme_ns_cmd", NULL, NULL);
648 : :
649 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_reset);
650 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_reset_single_entry);
651 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_with_md);
652 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_with_md_single_entry);
653 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read);
654 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_read_single_entry);
655 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_with_md);
656 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_with_md_single_entry);
657 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write);
658 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_write_single_entry);
659 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_copy);
660 : 3 : CU_ADD_TEST(suite, test_nvme_ocssd_ns_cmd_vector_copy_single_entry);
661 : :
662 : 3 : g_spdk_nvme_driver = &_g_nvme_driver;
663 : :
664 : 3 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
665 : 3 : CU_cleanup_registry();
666 : 3 : return num_failures;
667 : : }
|