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