Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2021 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2022, 2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk_internal/cunit.h"
8 : : #include "spdk_internal/mock.h"
9 : : #include "spdk/accel_module.h"
10 : : #include "thread/thread_internal.h"
11 : : #include "common/lib/ut_multithread.c"
12 : : #include "common/lib/test_iobuf.c"
13 : : #include "accel/accel.c"
14 : : #include "accel/accel_sw.c"
15 : : #include "unit/lib/json_mock.c"
16 : :
17 : 10 : DEFINE_STUB_V(spdk_memory_domain_destroy, (struct spdk_memory_domain *domain));
18 : 10 : DEFINE_STUB(spdk_memory_domain_get_dma_device_id, const char *,
19 : : (struct spdk_memory_domain *domain), "UT_DMA");
20 : :
21 : : int
22 : 10 : spdk_memory_domain_create(struct spdk_memory_domain **domain, enum spdk_dma_device_type type,
23 : : struct spdk_memory_domain_ctx *ctx, const char *id)
24 : : {
25 [ + - ]: 10 : *domain = (void *)0xdeadbeef;
26 : :
27 : 10 : return 0;
28 : : }
29 : :
30 : : struct ut_domain_ctx {
31 : : struct iovec iov;
32 : : struct iovec expected;
33 : : int pull_submit_status;
34 : : int push_submit_status;
35 : : int pull_complete_status;
36 : : int push_complete_status;
37 : : };
38 : :
39 : : static struct spdk_memory_domain *g_ut_domain = (void *)0xa55e1;
40 : :
41 : : int
42 : 45 : spdk_memory_domain_pull_data(struct spdk_memory_domain *sd, void *sctx, struct iovec *siov,
43 : : uint32_t siovcnt, struct iovec *diov, uint32_t diovcnt,
44 : : spdk_memory_domain_data_cpl_cb cpl_cb, void *cpl_arg)
45 : : {
46 : 45 : struct ut_domain_ctx *ctx = sctx;
47 : :
48 : 45 : CU_ASSERT_EQUAL(sd, g_ut_domain);
49 : 45 : CU_ASSERT_EQUAL(siovcnt, 1);
50 [ + + + + : 45 : CU_ASSERT_EQUAL(memcmp(siov, &ctx->expected, sizeof(*siov)), 0);
+ - ]
51 : :
52 [ + + + - : 45 : if (ctx->pull_submit_status != 0) {
+ + ]
53 [ + - + - ]: 5 : return ctx->pull_submit_status;
54 : : }
55 : :
56 [ + + + - : 40 : if (ctx->pull_complete_status != 0) {
+ + ]
57 [ - + + - : 5 : cpl_cb(cpl_arg, ctx->pull_complete_status);
+ - + - ]
58 : 5 : return 0;
59 : : }
60 : :
61 [ + - ]: 35 : spdk_iovcpy(&ctx->iov, 1, diov, diovcnt);
62 [ - + + - ]: 35 : cpl_cb(cpl_arg, 0);
63 : :
64 : 35 : return 0;
65 : 9 : }
66 : :
67 : : int
68 : 40 : spdk_memory_domain_push_data(struct spdk_memory_domain *dd, void *dctx, struct iovec *diov,
69 : : uint32_t diovcnt, struct iovec *siov, uint32_t siovcnt,
70 : : spdk_memory_domain_data_cpl_cb cpl_cb, void *cpl_arg)
71 : : {
72 : 40 : struct ut_domain_ctx *ctx = dctx;
73 : :
74 : 40 : CU_ASSERT_EQUAL(dd, g_ut_domain);
75 : 40 : CU_ASSERT_EQUAL(diovcnt, 1);
76 [ + + + + : 40 : CU_ASSERT_EQUAL(memcmp(diov, &ctx->expected, sizeof(*diov)), 0);
+ - ]
77 : :
78 [ + + + - : 40 : if (ctx->push_submit_status != 0) {
+ + ]
79 [ + - + - ]: 5 : return ctx->push_submit_status;
80 : : }
81 : :
82 [ + + + - : 35 : if (ctx->push_complete_status != 0) {
+ + ]
83 [ - + + - : 5 : cpl_cb(cpl_arg, ctx->push_complete_status);
+ - + - ]
84 : 5 : return 0;
85 : : }
86 : :
87 [ + - ]: 30 : spdk_iovcpy(siov, siovcnt, &ctx->iov, 1);
88 [ - + + - ]: 30 : cpl_cb(cpl_arg, 0);
89 : :
90 : 30 : return 0;
91 : 8 : }
92 : :
93 : : /* global vars and setup/cleanup functions used for all test functions */
94 : : struct spdk_accel_module_if g_module_if = {};
95 : : struct accel_module g_module = { .module = &g_module_if };
96 : : struct spdk_io_channel *g_ch = NULL;
97 : : struct accel_io_channel *g_accel_ch = NULL;
98 : : struct sw_accel_io_channel *g_sw_ch = NULL;
99 : : struct spdk_io_channel *g_module_ch = NULL;
100 : :
101 : : static uint64_t g_opc_mask = 0;
102 : :
103 : : static uint64_t
104 : 0 : _accel_op_to_bit(enum spdk_accel_opcode opc)
105 : : {
106 [ # # # # ]: 0 : return (1 << opc);
107 : : }
108 : :
109 : : static bool
110 : 0 : _supports_opcode(enum spdk_accel_opcode opc)
111 : : {
112 [ # # ]: 0 : if (_accel_op_to_bit(opc) & g_opc_mask) {
113 : 0 : return true;
114 : : }
115 : 0 : return false;
116 : 0 : }
117 : :
118 : : static int
119 : 5 : test_setup(void)
120 : : {
121 : 1 : int i;
122 : :
123 : 5 : g_ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct accel_io_channel));
124 [ + + ]: 5 : if (g_ch == NULL) {
125 : : /* for some reason the assert fatal macro doesn't work in the setup function. */
126 : 0 : CU_ASSERT(false);
127 : 0 : return -1;
128 : : }
129 [ + - ]: 5 : g_accel_ch = (struct accel_io_channel *)((char *)g_ch + sizeof(struct spdk_io_channel));
130 : 5 : g_module_ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct sw_accel_io_channel));
131 [ + + ]: 5 : if (g_module_ch == NULL) {
132 : 0 : CU_ASSERT(false);
133 : 0 : return -1;
134 : : }
135 : :
136 [ + - ]: 5 : g_module_if.submit_tasks = sw_accel_submit_tasks;
137 : 5 : g_module_if.name = "software";
138 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; i++) {
139 [ + - + - : 70 : g_accel_ch->module_ch[i] = g_module_ch;
+ - + - ]
140 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
141 : 14 : }
142 [ + - ]: 5 : g_sw_ch = (struct sw_accel_io_channel *)((char *)g_module_ch + sizeof(
143 : : struct spdk_io_channel));
144 [ + - + - : 5 : STAILQ_INIT(&g_sw_ch->tasks_to_complete);
+ - + - +
- + - + -
+ - ]
145 [ + - ]: 5 : g_module_if.supports_opcode = _supports_opcode;
146 : 5 : return 0;
147 : 1 : }
148 : :
149 : : static int
150 : 5 : test_cleanup(void)
151 : : {
152 : 5 : free(g_ch);
153 : 5 : free(g_module_ch);
154 : :
155 : 5 : return 0;
156 : : }
157 : :
158 : : #define DUMMY_ARG 0xDEADBEEF
159 : : static bool g_dummy_cb_called = false;
160 : : static void
161 : 5 : dummy_cb_fn(void *cb_arg, int status)
162 : : {
163 [ + - ]: 5 : CU_ASSERT(*(uint32_t *)cb_arg == DUMMY_ARG);
164 : 5 : CU_ASSERT(status == 0);
165 : 5 : g_dummy_cb_called = true;
166 : 5 : }
167 : :
168 : : static void
169 : 5 : test_spdk_accel_task_complete(void)
170 : : {
171 : 5 : struct spdk_accel_task accel_task = {};
172 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
173 : 5 : uint32_t cb_arg = DUMMY_ARG;
174 : 5 : int status = 0;
175 : :
176 [ + - ]: 5 : accel_task.accel_ch = g_accel_ch;
177 [ + - + - ]: 5 : accel_task.cb_fn = dummy_cb_fn;
178 [ + - ]: 5 : accel_task.cb_arg = &cb_arg;
179 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
180 : :
181 : : /* Confirm cb is called and task added to list. */
182 : 5 : spdk_accel_task_complete(&accel_task, status);
183 [ + + ]: 5 : CU_ASSERT(g_dummy_cb_called == true);
184 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_accel_ch->task_pool);
+ - ]
185 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_accel_ch->task_pool, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
186 : 5 : CU_ASSERT(expected_accel_task == &accel_task);
187 : 5 : }
188 : :
189 : : static void
190 : 5 : test_get_task(void)
191 : : {
192 : 1 : struct spdk_accel_task *task;
193 : 4 : struct spdk_accel_task _task;
194 : 5 : void *cb_arg = NULL;
195 : :
196 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
197 : :
198 : : /* no tasks left, return NULL. */
199 : 5 : task = _get_task(g_accel_ch, dummy_cb_fn, cb_arg);
200 : 5 : CU_ASSERT(task == NULL);
201 : :
202 [ + - + - ]: 5 : _task.cb_fn = dummy_cb_fn;
203 [ + - ]: 5 : _task.cb_arg = cb_arg;
204 [ + - ]: 5 : _task.accel_ch = g_accel_ch;
205 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &_task, link);
+ - + - +
- + - + -
+ - + - +
- ]
206 : :
207 : : /* Get a valid task. */
208 : 5 : task = _get_task(g_accel_ch, dummy_cb_fn, cb_arg);
209 : 5 : CU_ASSERT(task == &_task);
210 [ + - + - ]: 5 : CU_ASSERT(_task.cb_fn == dummy_cb_fn);
211 [ + - ]: 5 : CU_ASSERT(_task.cb_arg == cb_arg);
212 [ + - ]: 5 : CU_ASSERT(_task.accel_ch == g_accel_ch);
213 : 5 : }
214 : :
215 : : #define TEST_SUBMIT_SIZE 64
216 : : static void
217 : 5 : test_spdk_accel_submit_copy(void)
218 : : {
219 : 5 : const uint64_t nbytes = TEST_SUBMIT_SIZE;
220 : 5 : uint8_t dst[TEST_SUBMIT_SIZE] = {0};
221 : 5 : uint8_t src[TEST_SUBMIT_SIZE] = {0};
222 : 5 : void *cb_arg = NULL;
223 : 1 : int rc;
224 : 4 : struct spdk_accel_task task;
225 : 4 : struct spdk_accel_task_aux_data task_aux;
226 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
227 : 5 : int flags = 0;
228 : :
229 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
230 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
231 : :
232 : : /* Fail with no tasks on _get_task() */
233 : 5 : rc = spdk_accel_submit_copy(g_ch, src, dst, nbytes, flags, NULL, cb_arg);
234 : 5 : CU_ASSERT(rc == -ENOMEM);
235 : :
236 [ + - ]: 5 : task.accel_ch = g_accel_ch;
237 : 5 : task.flags = 1;
238 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
239 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
240 : :
241 : : /* submission OK. */
242 : 5 : rc = spdk_accel_submit_copy(g_ch, dst, src, nbytes, flags, NULL, cb_arg);
243 : 5 : CU_ASSERT(rc == 0);
244 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_COPY);
245 : 5 : CU_ASSERT(task.flags == 0);
246 [ + - + - ]: 5 : CU_ASSERT(memcmp(dst, src, TEST_SUBMIT_SIZE) == 0);
247 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
248 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
249 : 5 : CU_ASSERT(expected_accel_task == &task);
250 : 5 : }
251 : :
252 : : static void
253 : 5 : test_spdk_accel_submit_dualcast(void)
254 : : {
255 : 1 : void *dst1;
256 : 1 : void *dst2;
257 : 1 : void *src;
258 : 5 : uint32_t align = ALIGN_4K;
259 : 5 : uint64_t nbytes = TEST_SUBMIT_SIZE;
260 : 5 : void *cb_arg = NULL;
261 : 1 : int rc;
262 : 4 : struct spdk_accel_task task;
263 : 4 : struct spdk_accel_task_aux_data task_aux;
264 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
265 : 5 : int flags = 0;
266 : :
267 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
268 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
269 : :
270 : : /* Dualcast requires 4K alignment on dst addresses,
271 : : * hence using the hard coded address to test the buffer alignment
272 : : */
273 : 5 : dst1 = (void *)0x5000;
274 : 5 : dst2 = (void *)0x60f0;
275 : 5 : src = calloc(1, TEST_SUBMIT_SIZE);
276 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(src != NULL);
277 [ + + ]: 5 : memset(src, 0x5A, TEST_SUBMIT_SIZE);
278 : :
279 : : /* This should fail since dst2 is not 4k aligned */
280 : 5 : rc = spdk_accel_submit_dualcast(g_ch, dst1, dst2, src, nbytes, flags, NULL, cb_arg);
281 : 5 : CU_ASSERT(rc == -EINVAL);
282 : :
283 : 5 : dst1 = (void *)0x7010;
284 : 5 : dst2 = (void *)0x6000;
285 : : /* This should fail since dst1 is not 4k aligned */
286 : 5 : rc = spdk_accel_submit_dualcast(g_ch, dst1, dst2, src, nbytes, flags, NULL, cb_arg);
287 : 5 : CU_ASSERT(rc == -EINVAL);
288 : :
289 : : /* Dualcast requires 4K alignment on dst addresses */
290 : 5 : dst1 = (void *)0x7000;
291 : 5 : dst2 = (void *)0x6000;
292 : : /* Fail with no tasks on _get_task() */
293 : 5 : rc = spdk_accel_submit_dualcast(g_ch, dst1, dst2, src, nbytes, flags, NULL, cb_arg);
294 : 5 : CU_ASSERT(rc == -ENOMEM);
295 : :
296 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
297 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
298 : :
299 : : /* accel submission OK., since we test the SW path , need to use valid memory addresses
300 : : * cannot hardcode them anymore */
301 : 5 : dst1 = spdk_dma_zmalloc(nbytes, align, NULL);
302 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(dst1 != NULL);
303 : 5 : dst2 = spdk_dma_zmalloc(nbytes, align, NULL);
304 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(dst2 != NULL);
305 : : /* SW module does the dualcast. */
306 : 5 : rc = spdk_accel_submit_dualcast(g_ch, dst1, dst2, src, nbytes, flags, NULL, cb_arg);
307 : 5 : CU_ASSERT(rc == 0);
308 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_DUALCAST);
309 : 5 : CU_ASSERT(task.flags == 0);
310 [ + + + + ]: 5 : CU_ASSERT(memcmp(dst1, src, TEST_SUBMIT_SIZE) == 0);
311 [ + + + + ]: 5 : CU_ASSERT(memcmp(dst2, src, TEST_SUBMIT_SIZE) == 0);
312 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
313 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - -
+ + - + -
+ - + - +
- ]
314 : 5 : CU_ASSERT(expected_accel_task == &task);
315 : :
316 : 5 : free(src);
317 : 5 : spdk_free(dst1);
318 : 5 : spdk_free(dst2);
319 : 5 : }
320 : :
321 : : static void
322 : 5 : test_spdk_accel_submit_compare(void)
323 : : {
324 : 1 : void *src1;
325 : 1 : void *src2;
326 : 5 : uint64_t nbytes = TEST_SUBMIT_SIZE;
327 : 5 : void *cb_arg = NULL;
328 : 1 : int rc;
329 : 4 : struct spdk_accel_task task;
330 : 4 : struct spdk_accel_task_aux_data task_aux;
331 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
332 : :
333 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
334 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
335 : :
336 : 5 : src1 = calloc(1, TEST_SUBMIT_SIZE);
337 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(src1 != NULL);
338 : 5 : src2 = calloc(1, TEST_SUBMIT_SIZE);
339 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(src2 != NULL);
340 : :
341 : : /* Fail with no tasks on _get_task() */
342 : 5 : rc = spdk_accel_submit_compare(g_ch, src1, src2, nbytes, NULL, cb_arg);
343 : 5 : CU_ASSERT(rc == -ENOMEM);
344 : :
345 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
346 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
347 : :
348 : : /* accel submission OK. */
349 : 5 : rc = spdk_accel_submit_compare(g_ch, src1, src2, nbytes, NULL, cb_arg);
350 : 5 : CU_ASSERT(rc == 0);
351 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_COMPARE);
352 [ + + + + ]: 5 : CU_ASSERT(memcmp(src1, src2, TEST_SUBMIT_SIZE) == 0);
353 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
354 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - -
+ + - + -
+ - + - +
- ]
355 : 5 : CU_ASSERT(expected_accel_task == &task);
356 : :
357 : 5 : free(src1);
358 : 5 : free(src2);
359 : 5 : }
360 : :
361 : : static void
362 : 5 : test_spdk_accel_submit_fill(void)
363 : : {
364 : 1 : void *dst;
365 : 1 : void *src;
366 : 5 : uint8_t fill = 0xf;
367 : 4 : uint64_t fill64;
368 : 5 : uint64_t nbytes = TEST_SUBMIT_SIZE;
369 : 5 : void *cb_arg = NULL;
370 : 1 : int rc;
371 : 4 : struct spdk_accel_task task;
372 : 4 : struct spdk_accel_task_aux_data task_aux;
373 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
374 : 5 : int flags = 0;
375 : :
376 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
377 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
378 : :
379 : 5 : dst = calloc(1, TEST_SUBMIT_SIZE);
380 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(dst != NULL);
381 : 5 : src = calloc(1, TEST_SUBMIT_SIZE);
382 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(src != NULL);
383 [ + + ]: 5 : memset(src, fill, TEST_SUBMIT_SIZE);
384 [ + - ]: 5 : memset(&fill64, fill, sizeof(uint64_t));
385 : :
386 : : /* Fail with no tasks on _get_task() */
387 : 5 : rc = spdk_accel_submit_fill(g_ch, dst, fill, nbytes, flags, NULL, cb_arg);
388 : 5 : CU_ASSERT(rc == -ENOMEM);
389 : :
390 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
391 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
392 : :
393 : : /* accel submission OK. */
394 : 5 : rc = spdk_accel_submit_fill(g_ch, dst, fill, nbytes, flags, NULL, cb_arg);
395 : 5 : CU_ASSERT(rc == 0);
396 [ + - + - ]: 5 : CU_ASSERT(task.fill_pattern == fill64);
397 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_FILL);
398 : 5 : CU_ASSERT(task.flags == 0);
399 : :
400 [ + + + + ]: 5 : CU_ASSERT(memcmp(dst, src, TEST_SUBMIT_SIZE) == 0);
401 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
402 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - -
+ + - + -
+ - + - +
- ]
403 : 5 : CU_ASSERT(expected_accel_task == &task);
404 : :
405 : 5 : free(dst);
406 : 5 : free(src);
407 : 5 : }
408 : :
409 : : static void
410 : 5 : test_spdk_accel_submit_crc32c(void)
411 : : {
412 : 5 : const uint64_t nbytes = TEST_SUBMIT_SIZE;
413 : 4 : uint32_t crc_dst;
414 : 4 : uint8_t src[TEST_SUBMIT_SIZE];
415 : 5 : uint32_t seed = 1;
416 : 5 : void *cb_arg = NULL;
417 : 1 : int rc;
418 : 4 : struct spdk_accel_task task;
419 : 4 : struct spdk_accel_task_aux_data task_aux;
420 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
421 : :
422 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
423 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
424 : :
425 : : /* Fail with no tasks on _get_task() */
426 : 5 : rc = spdk_accel_submit_crc32c(g_ch, &crc_dst, src, seed, nbytes, NULL, cb_arg);
427 : 5 : CU_ASSERT(rc == -ENOMEM);
428 : :
429 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
430 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
431 : :
432 : : /* accel submission OK. */
433 : 5 : rc = spdk_accel_submit_crc32c(g_ch, &crc_dst, src, seed, nbytes, NULL, cb_arg);
434 : 5 : CU_ASSERT(rc == 0);
435 [ + - + - ]: 5 : CU_ASSERT(task.crc_dst == &crc_dst);
436 [ + - + - ]: 5 : CU_ASSERT(task.seed == seed);
437 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_CRC32C);
438 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
439 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
440 : 5 : CU_ASSERT(expected_accel_task == &task);
441 : 5 : }
442 : :
443 : : static void
444 : 5 : test_spdk_accel_submit_crc32cv(void)
445 : : {
446 : 4 : uint32_t crc_dst;
447 : 5 : uint32_t seed = 0;
448 : 5 : uint32_t iov_cnt = 32;
449 : 5 : void *cb_arg = NULL;
450 : 1 : int rc;
451 : 5 : uint32_t i = 0;
452 : 4 : struct spdk_accel_task task;
453 : 4 : struct spdk_accel_task_aux_data task_aux;
454 : 4 : struct iovec iov[32];
455 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
456 : :
457 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
458 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
459 : :
460 [ + + ]: 165 : for (i = 0; i < iov_cnt; i++) {
461 [ + - + - : 160 : iov[i].iov_base = calloc(1, TEST_SUBMIT_SIZE);
+ - + - ]
462 [ + + + - : 160 : SPDK_CU_ASSERT_FATAL(iov[i].iov_base != NULL);
+ - + - +
- # # ]
463 [ + - + - : 160 : iov[i].iov_len = TEST_SUBMIT_SIZE;
+ - + - ]
464 : 32 : }
465 : :
466 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
467 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
468 : :
469 : : /* accel submission OK. */
470 : 5 : rc = spdk_accel_submit_crc32cv(g_ch, &crc_dst, iov, iov_cnt, seed, NULL, cb_arg);
471 : 5 : CU_ASSERT(rc == 0);
472 [ + - + - : 5 : CU_ASSERT(task.s.iovs == iov);
+ - ]
473 [ + - + - : 5 : CU_ASSERT(task.s.iovcnt == iov_cnt);
+ - ]
474 [ + - + - ]: 5 : CU_ASSERT(task.crc_dst == &crc_dst);
475 [ + - + - ]: 5 : CU_ASSERT(task.seed == seed);
476 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_CRC32C);
477 [ + - ]: 5 : CU_ASSERT(task.cb_arg == cb_arg);
478 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
479 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - -
+ + - + -
+ - + - +
- ]
480 : 5 : CU_ASSERT(expected_accel_task == &task);
481 : :
482 [ + + ]: 165 : for (i = 0; i < iov_cnt; i++) {
483 [ + - + - : 160 : free(iov[i].iov_base);
+ - + - ]
484 : 32 : }
485 : 5 : }
486 : :
487 : : static void
488 : 5 : test_spdk_accel_submit_copy_crc32c(void)
489 : : {
490 : 5 : const uint64_t nbytes = TEST_SUBMIT_SIZE;
491 : 4 : uint32_t crc_dst;
492 : 4 : uint8_t dst[TEST_SUBMIT_SIZE];
493 : 4 : uint8_t src[TEST_SUBMIT_SIZE];
494 : 5 : uint32_t seed = 0;
495 : 5 : void *cb_arg = NULL;
496 : 1 : int rc;
497 : 4 : struct spdk_accel_task task;
498 : 4 : struct spdk_accel_task_aux_data task_aux;
499 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
500 : 5 : int flags = 0;
501 : :
502 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
503 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
504 : :
505 : : /* Fail with no tasks on _get_task() */
506 : 6 : rc = spdk_accel_submit_copy_crc32c(g_ch, dst, src, &crc_dst, seed, nbytes, flags,
507 : 1 : NULL, cb_arg);
508 : 5 : CU_ASSERT(rc == -ENOMEM);
509 : :
510 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
511 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
512 : :
513 : : /* accel submission OK. */
514 : 6 : rc = spdk_accel_submit_copy_crc32c(g_ch, dst, src, &crc_dst, seed, nbytes, flags,
515 : 1 : NULL, cb_arg);
516 : 5 : CU_ASSERT(rc == 0);
517 [ + - + - ]: 5 : CU_ASSERT(task.crc_dst == &crc_dst);
518 [ + - + - ]: 5 : CU_ASSERT(task.seed == seed);
519 : 5 : CU_ASSERT(task.flags == 0);
520 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_COPY_CRC32C);
521 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
522 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
523 : 5 : CU_ASSERT(expected_accel_task == &task);
524 : 5 : }
525 : :
526 : : static void
527 : 5 : test_spdk_accel_submit_xor(void)
528 : : {
529 : 5 : const uint64_t nbytes = TEST_SUBMIT_SIZE;
530 : 5 : uint8_t dst[TEST_SUBMIT_SIZE] = {0};
531 : 5 : uint8_t src1[TEST_SUBMIT_SIZE] = {0};
532 : 5 : uint8_t src2[TEST_SUBMIT_SIZE] = {0};
533 : 5 : void *sources[] = { src1, src2 };
534 : 5 : uint32_t nsrcs = SPDK_COUNTOF(sources);
535 : 1 : int rc;
536 : 4 : struct spdk_accel_task task;
537 : 4 : struct spdk_accel_task_aux_data task_aux;
538 : 5 : struct spdk_accel_task *expected_accel_task = NULL;
539 : :
540 [ + - + - : 5 : STAILQ_INIT(&g_accel_ch->task_pool);
+ - + - +
- + - + -
+ - ]
541 [ + - + - : 5 : SLIST_INIT(&g_accel_ch->task_aux_data_pool);
+ - ]
542 : :
543 : : /* Fail with no tasks on _get_task() */
544 : 5 : rc = spdk_accel_submit_xor(g_ch, dst, sources, nsrcs, nbytes, NULL, NULL);
545 : 5 : CU_ASSERT(rc == -ENOMEM);
546 : :
547 [ + - + - : 5 : STAILQ_INSERT_TAIL(&g_accel_ch->task_pool, &task, link);
+ - + - +
- + - + -
+ - + - +
- ]
548 [ + - + - : 5 : SLIST_INSERT_HEAD(&g_accel_ch->task_aux_data_pool, &task_aux, link);
+ - + - +
- + - ]
549 : :
550 : : /* submission OK. */
551 : 5 : rc = spdk_accel_submit_xor(g_ch, dst, sources, nsrcs, nbytes, NULL, NULL);
552 : 5 : CU_ASSERT(rc == 0);
553 [ + - + - : 5 : CU_ASSERT(task.nsrcs.srcs == sources);
+ - ]
554 [ + - + - : 5 : CU_ASSERT(task.nsrcs.cnt == nsrcs);
+ - ]
555 [ + - + - : 5 : CU_ASSERT(task.d.iovcnt == 1);
+ - ]
556 [ + - + - : 5 : CU_ASSERT(task.d.iovs[0].iov_base == dst);
+ - + - +
- + - ]
557 [ + - + - : 5 : CU_ASSERT(task.d.iovs[0].iov_len == nbytes);
+ - + - +
- + - ]
558 [ + - ]: 5 : CU_ASSERT(task.op_code == SPDK_ACCEL_OPC_XOR);
559 [ + - + - : 5 : expected_accel_task = STAILQ_FIRST(&g_sw_ch->tasks_to_complete);
+ - ]
560 [ + - + - : 5 : STAILQ_REMOVE_HEAD(&g_sw_ch->tasks_to_complete, link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
561 : 5 : CU_ASSERT(expected_accel_task == &task);
562 : 5 : }
563 : :
564 : : static void
565 : 5 : test_spdk_accel_module_find_by_name(void)
566 : : {
567 : 5 : struct spdk_accel_module_if mod1 = {};
568 : 5 : struct spdk_accel_module_if mod2 = {};
569 : 5 : struct spdk_accel_module_if mod3 = {};
570 : 5 : struct spdk_accel_module_if *accel_module = NULL;
571 : :
572 : 5 : mod1.name = "ioat";
573 : 5 : mod2.name = "idxd";
574 : 5 : mod3.name = "software";
575 : :
576 [ + - ]: 5 : TAILQ_INIT(&spdk_accel_module_list);
577 [ + - + - : 5 : TAILQ_INSERT_TAIL(&spdk_accel_module_list, &mod1, tailq);
+ - + - +
- + - + -
+ - + - ]
578 [ + - + - : 5 : TAILQ_INSERT_TAIL(&spdk_accel_module_list, &mod2, tailq);
+ - + - +
- + - + -
+ - + - ]
579 [ + - + - : 5 : TAILQ_INSERT_TAIL(&spdk_accel_module_list, &mod3, tailq);
+ - + - +
- + - + -
+ - + - ]
580 : :
581 : : /* Now let's find a valid engine */
582 : 5 : accel_module = _module_find_by_name("ioat");
583 : 5 : CU_ASSERT(accel_module != NULL);
584 : :
585 : : /* Try to find one that doesn't exist */
586 : 5 : accel_module = _module_find_by_name("XXX");
587 : 5 : CU_ASSERT(accel_module == NULL);
588 : 5 : }
589 : :
590 : : static int
591 : 20 : ut_module_init_nop(void)
592 : : {
593 : 20 : return 0;
594 : : }
595 : :
596 : : static bool
597 : 280 : ut_supports_opcode_all(enum spdk_accel_opcode opcode)
598 : : {
599 : 280 : return true;
600 : : }
601 : :
602 : : static void
603 : 5 : ut_accel_module_priority_finish_done(void *done)
604 : : {
605 [ + - ]: 5 : *(int *)done = 1;
606 : 5 : }
607 : :
608 : : static void
609 : 5 : test_spdk_accel_module_register(void)
610 : : {
611 : 5 : struct spdk_accel_module_if mods[] = {
612 : : { .name = "mod1", .priority = 1, },
613 : : { .name = "mod3", .priority = 3, },
614 : : { .name = "mod0", .priority = 0, },
615 : : { .name = "mod2", .priority = 2, },
616 : : };
617 : 5 : int rc, done = 0;
618 : 5 : const char *modname = NULL;
619 : 1 : size_t i;
620 : :
621 : 5 : allocate_cores(1);
622 : 5 : allocate_threads(1);
623 : 5 : set_thread(0);
624 : :
625 [ + - ]: 5 : TAILQ_INIT(&spdk_accel_module_list);
626 [ + + ]: 25 : for (i = 0; i < SPDK_COUNTOF(mods); ++i) {
627 [ + - + - : 20 : mods[i].module_init = ut_module_init_nop;
+ - + - ]
628 [ + - + - : 20 : mods[i].supports_opcode = ut_supports_opcode_all;
+ - + - ]
629 [ + - + - ]: 20 : spdk_accel_module_list_add(&mods[i]);
630 : 4 : }
631 : :
632 : 5 : rc = spdk_accel_initialize();
633 : 5 : CU_ASSERT_EQUAL(rc, 0);
634 : :
635 : : /* All opcodes should be assigned to the module with highest prio - mod3 */
636 [ + + ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
637 : 70 : rc = spdk_accel_get_opc_module_name((enum spdk_accel_opcode)i, &modname);
638 : 70 : CU_ASSERT_EQUAL(rc, 0);
639 [ + + + - ]: 70 : CU_ASSERT_STRING_EQUAL(modname, "mod3");
640 : 14 : }
641 : :
642 : 5 : spdk_accel_finish(ut_accel_module_priority_finish_done, &done);
643 [ + + ]: 10 : while (!done) {
644 : 5 : poll_threads();
645 : : }
646 : :
647 [ + - ]: 5 : TAILQ_INIT(&spdk_accel_module_list);
648 : 5 : free_threads();
649 : 5 : free_cores();
650 : 5 : }
651 : :
652 : : struct ut_sequence {
653 : : bool complete;
654 : : int status;
655 : : };
656 : :
657 : : static void
658 : 780 : ut_sequence_step_cb(void *cb_arg)
659 : : {
660 : 780 : int *completed = cb_arg;
661 : :
662 [ + - ]: 780 : (*completed)++;
663 : 780 : }
664 : :
665 : : static void
666 : 310 : ut_sequence_complete_cb(void *cb_arg, int status)
667 : : {
668 : 310 : struct ut_sequence *seq = cb_arg;
669 : :
670 [ + - + - ]: 310 : seq->complete = true;
671 [ + - + - ]: 310 : seq->status = status;
672 : 310 : }
673 : :
674 : : static void
675 : 5 : test_sequence_fill_copy(void)
676 : : {
677 : 5 : struct spdk_accel_sequence *seq = NULL;
678 : 1 : struct spdk_io_channel *ioch;
679 : 4 : struct ut_sequence ut_seq;
680 : 4 : char buf[4096], tmp[2][4096], expected[4096];
681 : 4 : struct iovec src_iovs[2], dst_iovs[2];
682 : 4 : int rc, completed;
683 : :
684 : 5 : ioch = spdk_accel_get_io_channel();
685 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
686 : :
687 : : /* First check the simplest case - single task in a sequence */
688 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
689 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
690 : 5 : completed = 0;
691 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, sizeof(buf), NULL, NULL, 0xa5, 0,
692 : : ut_sequence_step_cb, &completed);
693 : 5 : CU_ASSERT_EQUAL(rc, 0);
694 : 5 : CU_ASSERT_EQUAL(completed, 0);
695 : :
696 : 5 : ut_seq.complete = false;
697 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
698 : :
699 : 5 : poll_threads();
700 : 5 : CU_ASSERT_EQUAL(completed, 1);
701 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
702 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
703 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
704 : :
705 : : /* Check a single copy operation */
706 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
707 [ + - + - : 5 : memset(tmp[0], 0xa5, sizeof(tmp[0]));
+ - ]
708 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
709 : 5 : completed = 0;
710 : 5 : seq = NULL;
711 : :
712 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
713 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
714 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
715 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
716 : :
717 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
718 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
719 : : ut_sequence_step_cb, &completed);
720 : 5 : CU_ASSERT_EQUAL(rc, 0);
721 : :
722 : 5 : ut_seq.complete = false;
723 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
724 : :
725 : 5 : poll_threads();
726 : 5 : CU_ASSERT_EQUAL(completed, 1);
727 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
728 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
729 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
730 : :
731 : : /* Check multiple fill operations */
732 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
733 [ + - ]: 5 : memset(expected, 0xfe, 4096);
734 [ + - ]: 5 : memset(expected, 0xde, 2048);
735 [ + - ]: 5 : memset(expected, 0xa5, 1024);
736 : 5 : seq = NULL;
737 : 5 : completed = 0;
738 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 4096, NULL, NULL, 0xfe, 0,
739 : : ut_sequence_step_cb, &completed);
740 : 5 : CU_ASSERT_EQUAL(rc, 0);
741 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 2048, NULL, NULL, 0xde, 0,
742 : : ut_sequence_step_cb, &completed);
743 : 5 : CU_ASSERT_EQUAL(rc, 0);
744 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 1024, NULL, NULL, 0xa5, 0,
745 : : ut_sequence_step_cb, &completed);
746 : 5 : CU_ASSERT_EQUAL(rc, 0);
747 : :
748 : 5 : ut_seq.complete = false;
749 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
750 : :
751 : 5 : poll_threads();
752 : 5 : CU_ASSERT_EQUAL(completed, 3);
753 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
754 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
755 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
756 : :
757 : : /* Check multiple copy operations */
758 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
759 [ + - + - : 5 : memset(tmp[0], 0, sizeof(tmp[0]));
+ - ]
760 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
761 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
762 : 5 : seq = NULL;
763 : 5 : completed = 0;
764 : :
765 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], sizeof(tmp[0]), NULL, NULL, 0xa5, 0,
766 : : ut_sequence_step_cb, &completed);
767 : 5 : CU_ASSERT_EQUAL(rc, 0);
768 : :
769 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
770 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
771 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
772 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
773 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
774 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
775 : : ut_sequence_step_cb, &completed);
776 : 5 : CU_ASSERT_EQUAL(rc, 0);
777 : :
778 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
779 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
780 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
781 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
782 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
783 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
784 : : ut_sequence_step_cb, &completed);
785 : 5 : CU_ASSERT_EQUAL(rc, 0);
786 : :
787 : 5 : ut_seq.complete = false;
788 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
789 : :
790 : 5 : poll_threads();
791 : 5 : CU_ASSERT_EQUAL(completed, 3);
792 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
793 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
794 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
795 : :
796 : : /* Check that adding a copy operation at the end will change destination buffer */
797 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
798 [ + - + - : 5 : memset(tmp[0], 0, sizeof(tmp[0]));
+ - ]
799 [ + - ]: 5 : memset(expected, 0xa5, sizeof(buf));
800 : 5 : seq = NULL;
801 : 5 : completed = 0;
802 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], sizeof(tmp[0]), NULL, NULL, 0xa5, 0,
803 : : ut_sequence_step_cb, &completed);
804 : 5 : CU_ASSERT_EQUAL(rc, 0);
805 : :
806 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
807 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
808 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
809 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
810 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
811 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
812 : : ut_sequence_step_cb, &completed);
813 : 5 : CU_ASSERT_EQUAL(rc, 0);
814 : :
815 : 5 : ut_seq.complete = false;
816 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
817 : :
818 : 5 : poll_threads();
819 : 5 : CU_ASSERT_EQUAL(completed, 2);
820 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
821 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
822 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
823 : :
824 : : /* Check that it's also possible to add copy operation at the beginning */
825 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
826 [ + - + - : 5 : memset(tmp[0], 0xde, sizeof(tmp[0]));
+ - ]
827 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
828 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
829 : 5 : seq = NULL;
830 : 5 : completed = 0;
831 : :
832 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
833 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
834 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
835 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
836 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
837 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
838 : : ut_sequence_step_cb, &completed);
839 : 5 : CU_ASSERT_EQUAL(rc, 0);
840 : :
841 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], sizeof(tmp[1]), NULL, NULL, 0xa5, 0,
842 : : ut_sequence_step_cb, &completed);
843 : 5 : CU_ASSERT_EQUAL(rc, 0);
844 : :
845 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
846 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
847 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
848 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
849 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
850 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
851 : : ut_sequence_step_cb, &completed);
852 : 5 : CU_ASSERT_EQUAL(rc, 0);
853 : :
854 : 5 : ut_seq.complete = false;
855 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
856 : :
857 : 5 : poll_threads();
858 : 5 : CU_ASSERT_EQUAL(completed, 3);
859 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
860 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
861 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
862 : :
863 : 5 : spdk_put_io_channel(ioch);
864 : 5 : poll_threads();
865 : 5 : }
866 : :
867 : : static void
868 : 5 : test_sequence_abort(void)
869 : : {
870 : 5 : struct spdk_accel_sequence *seq = NULL;
871 : 1 : struct spdk_io_channel *ioch;
872 : 4 : char buf[4096], tmp[2][4096], expected[4096];
873 : 4 : struct iovec src_iovs[2], dst_iovs[2];
874 : 4 : int rc, completed;
875 : :
876 : 5 : ioch = spdk_accel_get_io_channel();
877 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
878 : :
879 : : /* Check that aborting a sequence calls operation's callback, the operation is not executed
880 : : * and the sequence is freed
881 : : */
882 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
883 [ + - ]: 5 : memset(expected, 0, sizeof(buf));
884 : 5 : completed = 0;
885 : 5 : seq = NULL;
886 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, sizeof(buf), NULL, NULL, 0xa5, 0,
887 : : ut_sequence_step_cb, &completed);
888 : 5 : CU_ASSERT_EQUAL(rc, 0);
889 : :
890 : 5 : spdk_accel_sequence_abort(seq);
891 : 5 : CU_ASSERT_EQUAL(completed, 1);
892 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
893 : :
894 : : /* Check sequence with multiple operations */
895 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
896 [ + - ]: 5 : memset(expected, 0, sizeof(buf));
897 : 5 : completed = 0;
898 : 5 : seq = NULL;
899 : :
900 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
901 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
902 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
903 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
904 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
905 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
906 : : ut_sequence_step_cb, &completed);
907 : 5 : CU_ASSERT_EQUAL(rc, 0);
908 : :
909 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 4096, NULL, NULL, 0xa5, 0,
910 : : ut_sequence_step_cb, &completed);
911 : 5 : CU_ASSERT_EQUAL(rc, 0);
912 : :
913 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 2048, NULL, NULL, 0xde, 0,
914 : : ut_sequence_step_cb, &completed);
915 : 5 : CU_ASSERT_EQUAL(rc, 0);
916 : :
917 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
918 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
919 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
920 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
921 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
922 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
923 : : ut_sequence_step_cb, &completed);
924 : 5 : CU_ASSERT_EQUAL(rc, 0);
925 : :
926 : 5 : spdk_accel_sequence_abort(seq);
927 : 5 : CU_ASSERT_EQUAL(completed, 4);
928 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
929 : :
930 : : /* This should be a no-op */
931 : 5 : spdk_accel_sequence_abort(NULL);
932 : :
933 : 5 : spdk_put_io_channel(ioch);
934 : 5 : poll_threads();
935 : 5 : }
936 : :
937 : : static void
938 : 5 : test_sequence_append_error(void)
939 : : {
940 : 5 : struct spdk_accel_sequence *seq = NULL;
941 : 1 : struct spdk_io_channel *ioch;
942 : 1 : struct accel_io_channel *accel_ch;
943 : 4 : struct iovec src_iovs, dst_iovs;
944 : 4 : char buf[4096];
945 : 5 : STAILQ_HEAD(, spdk_accel_task) tasks = STAILQ_HEAD_INITIALIZER(tasks);
946 : 5 : SLIST_HEAD(, spdk_accel_sequence) seqs = SLIST_HEAD_INITIALIZER(seqs);
947 : 1 : int rc;
948 : :
949 : 5 : ioch = spdk_accel_get_io_channel();
950 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
951 : 5 : accel_ch = spdk_io_channel_get_ctx(ioch);
952 : :
953 : : /* Check that append fails and no sequence object is allocated when there are no more free
954 : : * tasks */
955 [ + + + - : 5 : STAILQ_SWAP(&tasks, &accel_ch->task_pool, spdk_accel_task);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- # # + -
+ - + - -
+ + - + -
+ - + - +
- ]
956 : :
957 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, sizeof(buf), NULL, NULL, 0xa5, 0,
958 : : ut_sequence_step_cb, NULL);
959 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
960 : 5 : CU_ASSERT_PTR_NULL(seq);
961 : :
962 : 5 : dst_iovs.iov_base = buf;
963 [ + - ]: 5 : dst_iovs.iov_len = 2048;
964 [ + - + - ]: 5 : src_iovs.iov_base = &buf[2048];
965 [ + - ]: 5 : src_iovs.iov_len = 2048;
966 : 5 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs, 1, NULL, NULL,
967 : : &src_iovs, 1, NULL, NULL, 0, ut_sequence_step_cb, NULL);
968 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
969 : 5 : CU_ASSERT_PTR_NULL(seq);
970 : :
971 : 5 : dst_iovs.iov_base = buf;
972 [ + - ]: 5 : dst_iovs.iov_len = 2048;
973 [ + - + - ]: 5 : src_iovs.iov_base = &buf[2048];
974 [ + - ]: 5 : src_iovs.iov_len = 2048;
975 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
976 : : &src_iovs, 1, NULL, NULL, 0, ut_sequence_step_cb, NULL);
977 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
978 : 5 : CU_ASSERT_PTR_NULL(seq);
979 : :
980 : : /* Check that the same happens when the sequence queue is empty */
981 [ + - + + : 5 : STAILQ_SWAP(&tasks, &accel_ch->task_pool, spdk_accel_task);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - -
+ + - + -
+ - + - +
- # # # #
# # # # #
# ]
982 [ + - + - : 5 : SLIST_SWAP(&seqs, &accel_ch->seq_pool, spdk_accel_sequence);
+ - + - +
- + - ]
983 : :
984 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, sizeof(buf), NULL, NULL, 0xa5, 0,
985 : : ut_sequence_step_cb, NULL);
986 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
987 : 5 : CU_ASSERT_PTR_NULL(seq);
988 : :
989 : 5 : dst_iovs.iov_base = buf;
990 [ + - ]: 5 : dst_iovs.iov_len = 2048;
991 [ + - + - ]: 5 : src_iovs.iov_base = &buf[2048];
992 [ + - ]: 5 : src_iovs.iov_len = 2048;
993 : 5 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs, 1, NULL, NULL,
994 : : &src_iovs, 1, NULL, NULL, 0, ut_sequence_step_cb, NULL);
995 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
996 : 5 : CU_ASSERT_PTR_NULL(seq);
997 : :
998 : 5 : dst_iovs.iov_base = buf;
999 [ + - ]: 5 : dst_iovs.iov_len = 2048;
1000 [ + - + - ]: 5 : src_iovs.iov_base = &buf[2048];
1001 [ + - ]: 5 : src_iovs.iov_len = 2048;
1002 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
1003 : : &src_iovs, 1, NULL, NULL, 0, ut_sequence_step_cb, NULL);
1004 : 5 : CU_ASSERT_EQUAL(rc, -ENOMEM);
1005 : 5 : CU_ASSERT_PTR_NULL(seq);
1006 : :
1007 [ + + + - : 5 : STAILQ_SWAP(&tasks, &accel_ch->task_pool, spdk_accel_task);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- # # + -
+ - + - -
+ + - + -
+ - + - +
- ]
1008 : :
1009 : 5 : spdk_put_io_channel(ioch);
1010 : 5 : poll_threads();
1011 : 5 : }
1012 : :
1013 : : struct ut_sequence_operation {
1014 : : int complete_status;
1015 : : int submit_status;
1016 : : int count;
1017 : : struct iovec *src_iovs;
1018 : : uint32_t src_iovcnt;
1019 : : struct spdk_memory_domain *src_domain;
1020 : : void *src_domain_ctx;
1021 : : struct iovec *dst_iovs;
1022 : : uint32_t dst_iovcnt;
1023 : : struct spdk_memory_domain *dst_domain;
1024 : : void *dst_domain_ctx;
1025 : : int (*submit)(struct spdk_io_channel *ch, struct spdk_accel_task *t);
1026 : : };
1027 : :
1028 : : static struct ut_sequence_operation g_seq_operations[SPDK_ACCEL_OPC_LAST];
1029 : :
1030 : : static int
1031 : 365 : ut_sequnce_submit_tasks(struct spdk_io_channel *ch, struct spdk_accel_task *task)
1032 : : {
1033 [ + - + - : 365 : struct ut_sequence_operation *op = &g_seq_operations[task->op_code];
+ - + - ]
1034 : :
1035 [ + - + - ]: 365 : op->count++;
1036 [ + + + - : 365 : if (op->submit != NULL) {
+ + ]
1037 [ + - + - : 285 : return op->submit(ch, task);
- + + - ]
1038 : : }
1039 [ + + + - : 80 : if (op->src_iovs != NULL) {
+ + ]
1040 [ + - + - : 35 : CU_ASSERT_EQUAL(task->s.iovcnt, op->src_iovcnt);
+ - + - +
- + - ]
1041 [ + + + + : 35 : CU_ASSERT_EQUAL(memcmp(task->s.iovs, op->src_iovs,
+ - + - +
- + - + -
+ - + - +
- ]
1042 : : sizeof(struct iovec) * op->src_iovcnt), 0);
1043 : 7 : }
1044 [ + + + - : 80 : if (op->dst_iovs != NULL) {
+ + ]
1045 [ + - + - : 40 : CU_ASSERT_EQUAL(task->d.iovcnt, op->dst_iovcnt);
+ - + - +
- + - ]
1046 [ + + + + : 40 : CU_ASSERT_EQUAL(memcmp(task->d.iovs, op->dst_iovs,
+ - + - +
- + - + -
+ - + - +
- ]
1047 : : sizeof(struct iovec) * op->dst_iovcnt), 0);
1048 : 8 : }
1049 : :
1050 [ + - + - : 80 : CU_ASSERT_EQUAL(task->src_domain, op->src_domain);
+ - + - ]
1051 [ + - + - : 80 : CU_ASSERT_EQUAL(task->dst_domain, op->dst_domain);
+ - + - ]
1052 [ + + + - : 80 : if (op->src_domain != NULL) {
+ + ]
1053 [ + - + - : 5 : CU_ASSERT_EQUAL(task->src_domain_ctx, op->src_domain_ctx);
+ - + - ]
1054 : 1 : }
1055 [ + + + - : 80 : if (op->dst_domain != NULL) {
+ + ]
1056 [ + - + - : 5 : CU_ASSERT_EQUAL(task->dst_domain_ctx, op->dst_domain_ctx);
+ - + - ]
1057 : 1 : }
1058 : :
1059 [ + + + - : 80 : if (op->submit_status != 0) {
+ + ]
1060 [ + - + - ]: 10 : return op->submit_status;
1061 : : }
1062 : :
1063 [ + - + - ]: 70 : spdk_accel_task_complete(task, op->complete_status);
1064 : :
1065 : 70 : return 0;
1066 : 73 : }
1067 : :
1068 : : static void
1069 : 40 : ut_clear_operations(void)
1070 : : {
1071 [ + + ]: 40 : memset(&g_seq_operations, 0, sizeof(g_seq_operations));
1072 : 40 : }
1073 : :
1074 : : static void
1075 : 5 : test_sequence_completion_error(void)
1076 : : {
1077 : 5 : struct spdk_accel_sequence *seq = NULL;
1078 : 1 : struct spdk_io_channel *ioch;
1079 : 4 : struct ut_sequence ut_seq;
1080 : 4 : struct iovec src_iovs, dst_iovs;
1081 : 4 : char buf[4096], tmp[4096];
1082 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
1083 : 4 : int i, rc, completed;
1084 : :
1085 : 5 : ioch = spdk_accel_get_io_channel();
1086 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
1087 : :
1088 : : /* Override the submit_tasks function */
1089 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
1090 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
1091 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
1092 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
1093 : 14 : }
1094 : :
1095 [ + + ]: 5 : memset(buf, 0, sizeof(buf));
1096 [ + + ]: 5 : memset(tmp, 0, sizeof(tmp));
1097 : :
1098 : : /* Check that if the first operation completes with an error, the whole sequence is
1099 : : * completed with that error and that all operations' completion callbacks are executed
1100 : : */
1101 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].complete_status = -E2BIG;
+ - + - ]
1102 : 5 : completed = 0;
1103 : 5 : seq = NULL;
1104 : 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp, sizeof(tmp), NULL, NULL, 0xa5, 0,
1105 : : ut_sequence_step_cb, &completed);
1106 : 5 : CU_ASSERT_EQUAL(rc, 0);
1107 : :
1108 : 5 : dst_iovs.iov_base = buf;
1109 [ + - ]: 5 : dst_iovs.iov_len = sizeof(buf);
1110 : 5 : src_iovs.iov_base = tmp;
1111 [ + - ]: 5 : src_iovs.iov_len = sizeof(tmp);
1112 : :
1113 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
1114 : : &src_iovs, 1, NULL, NULL, 0,
1115 : : ut_sequence_step_cb, &completed);
1116 : 5 : CU_ASSERT_EQUAL(rc, 0);
1117 : :
1118 : 5 : ut_seq.complete = false;
1119 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1120 : :
1121 : 5 : poll_threads();
1122 : 5 : CU_ASSERT_EQUAL(completed, 2);
1123 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -E2BIG);
1124 : :
1125 : : /* Check the same with a second operation in the sequence */
1126 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].complete_status = -EACCES;
+ - + - ]
1127 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].complete_status = 0;
+ - + - ]
1128 : 5 : completed = 0;
1129 : 5 : seq = NULL;
1130 : 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp, sizeof(tmp), NULL, NULL, 0xa5, 0,
1131 : : ut_sequence_step_cb, &completed);
1132 : 5 : CU_ASSERT_EQUAL(rc, 0);
1133 : :
1134 : 5 : dst_iovs.iov_base = buf;
1135 [ + - ]: 5 : dst_iovs.iov_len = sizeof(buf);
1136 : 5 : src_iovs.iov_base = tmp;
1137 [ + - ]: 5 : src_iovs.iov_len = sizeof(tmp);
1138 : :
1139 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
1140 : : &src_iovs, 1, NULL, NULL, 0,
1141 : : ut_sequence_step_cb, &completed);
1142 : 5 : CU_ASSERT_EQUAL(rc, 0);
1143 : :
1144 : 5 : ut_seq.complete = false;
1145 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1146 : :
1147 : 5 : poll_threads();
1148 : 5 : CU_ASSERT_EQUAL(completed, 2);
1149 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EACCES);
1150 : :
1151 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].complete_status = 0;
+ - + - ]
1152 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].complete_status = 0;
+ - + - ]
1153 : :
1154 : : /* Check submission failure of the first operation */
1155 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].submit_status = -EADDRINUSE;
+ - + - ]
1156 : 5 : completed = 0;
1157 : 5 : seq = NULL;
1158 : 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp, sizeof(tmp), NULL, NULL, 0xa5, 0,
1159 : : ut_sequence_step_cb, &completed);
1160 : 5 : CU_ASSERT_EQUAL(rc, 0);
1161 : :
1162 : 5 : dst_iovs.iov_base = buf;
1163 [ + - ]: 5 : dst_iovs.iov_len = sizeof(buf);
1164 : 5 : src_iovs.iov_base = tmp;
1165 [ + - ]: 5 : src_iovs.iov_len = sizeof(tmp);
1166 : :
1167 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
1168 : : &src_iovs, 1, NULL, NULL, 0,
1169 : : ut_sequence_step_cb, &completed);
1170 : 5 : CU_ASSERT_EQUAL(rc, 0);
1171 : :
1172 : 5 : ut_seq.complete = false;
1173 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1174 : :
1175 : 5 : poll_threads();
1176 : 5 : CU_ASSERT_EQUAL(completed, 2);
1177 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EADDRINUSE);
1178 : :
1179 : : /* Check the same with a second operation */
1180 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].submit_status = -EADDRNOTAVAIL;
+ - + - ]
1181 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].submit_status = 0;
+ - + - ]
1182 : 5 : completed = 0;
1183 : 5 : seq = NULL;
1184 : 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp, sizeof(tmp), NULL, NULL, 0xa5, 0,
1185 : : ut_sequence_step_cb, &completed);
1186 : 5 : CU_ASSERT_EQUAL(rc, 0);
1187 : :
1188 : 5 : dst_iovs.iov_base = buf;
1189 [ + - ]: 5 : dst_iovs.iov_len = sizeof(buf);
1190 : 5 : src_iovs.iov_base = tmp;
1191 [ + - ]: 5 : src_iovs.iov_len = sizeof(tmp);
1192 : :
1193 : 5 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs, 1, NULL, NULL,
1194 : : &src_iovs, 1, NULL, NULL, 0,
1195 : : ut_sequence_step_cb, &completed);
1196 : 5 : CU_ASSERT_EQUAL(rc, 0);
1197 : :
1198 : 5 : ut_seq.complete = false;
1199 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1200 : :
1201 : 5 : poll_threads();
1202 : 5 : CU_ASSERT_EQUAL(completed, 2);
1203 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EADDRNOTAVAIL);
1204 : :
1205 : : /* Cleanup module pointers to make subsequent tests work correctly */
1206 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
1207 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
1208 : 14 : }
1209 : :
1210 : 5 : ut_clear_operations();
1211 : 5 : spdk_put_io_channel(ioch);
1212 : 5 : poll_threads();
1213 : 5 : }
1214 : :
1215 : : #ifdef SPDK_CONFIG_ISAL
1216 : : static void
1217 : 10 : ut_compress_cb(void *cb_arg, int status)
1218 : : {
1219 : 10 : int *completed = cb_arg;
1220 : :
1221 : 10 : CU_ASSERT_EQUAL(status, 0);
1222 : :
1223 [ + - ]: 10 : *completed = 1;
1224 : 10 : }
1225 : :
1226 : : static void
1227 : 5 : test_sequence_decompress(void)
1228 : : {
1229 : 5 : struct spdk_accel_sequence *seq = NULL;
1230 : 1 : struct spdk_io_channel *ioch;
1231 : 4 : struct ut_sequence ut_seq;
1232 : 4 : char buf[4096], tmp[2][4096], expected[4096];
1233 : 4 : struct iovec src_iovs[2], dst_iovs[2];
1234 : 4 : uint32_t compressed_size;
1235 : 5 : int rc, completed = 0;
1236 : :
1237 : 5 : ioch = spdk_accel_get_io_channel();
1238 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
1239 : :
1240 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
1241 [ + - + - ]: 5 : src_iovs[0].iov_base = expected;
1242 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(expected);
+ - ]
1243 [ + - + - : 5 : rc = spdk_accel_submit_compress(ioch, tmp[0], sizeof(tmp[0]), &src_iovs[0], 1,
+ - + - ]
1244 : : &compressed_size, 0, ut_compress_cb, &completed);
1245 : 5 : CU_ASSERT_EQUAL(rc, 0);
1246 : :
1247 [ + + ]: 10 : while (!completed) {
1248 : 5 : poll_threads();
1249 : : }
1250 : :
1251 : : /* Check a single decompress operation in a sequence */
1252 : 5 : seq = NULL;
1253 : 5 : completed = 0;
1254 : :
1255 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
1256 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
1257 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1258 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1259 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1260 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1261 : : ut_sequence_step_cb, &completed);
1262 : 5 : CU_ASSERT_EQUAL(rc, 0);
1263 : :
1264 : 5 : ut_seq.complete = false;
1265 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1266 : :
1267 : 5 : poll_threads();
1268 : :
1269 : 5 : CU_ASSERT_EQUAL(completed, 1);
1270 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1271 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1272 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1273 : :
1274 : : /* Put the decompress operation in the middle of a sequence with a copy operation at the
1275 : : * beginning and a fill at the end modifying the first 2048B of the buffer.
1276 : : */
1277 [ + - ]: 5 : memset(expected, 0xfe, 2048);
1278 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1279 : 5 : seq = NULL;
1280 : 5 : completed = 0;
1281 : :
1282 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1283 [ + - + - : 5 : dst_iovs[0].iov_len = compressed_size;
+ - ]
1284 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1285 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1286 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1287 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1288 : : ut_sequence_step_cb, &completed);
1289 : 5 : CU_ASSERT_EQUAL(rc, 0);
1290 : :
1291 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1292 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1293 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1294 [ + - + - : 5 : src_iovs[1].iov_len = compressed_size;
+ - + - ]
1295 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1296 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1297 : : ut_sequence_step_cb, &completed);
1298 : 5 : CU_ASSERT_EQUAL(rc, 0);
1299 : :
1300 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 2048, NULL, NULL, 0xfe, 0,
1301 : : ut_sequence_step_cb, &completed);
1302 : 5 : CU_ASSERT_EQUAL(rc, 0);
1303 : :
1304 : 5 : ut_seq.complete = false;
1305 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1306 : :
1307 : 5 : poll_threads();
1308 : :
1309 : 5 : CU_ASSERT_EQUAL(completed, 3);
1310 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1311 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1312 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1313 : :
1314 : : /* Check sequence with decompress at the beginning: decompress -> copy */
1315 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
1316 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1317 : 5 : seq = NULL;
1318 : 5 : completed = 0;
1319 : :
1320 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1321 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1322 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1323 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1324 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1325 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1326 : : ut_sequence_step_cb, &completed);
1327 : 5 : CU_ASSERT_EQUAL(rc, 0);
1328 : :
1329 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1330 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1331 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1332 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1333 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1334 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1335 : : ut_sequence_step_cb, &completed);
1336 : 5 : CU_ASSERT_EQUAL(rc, 0);
1337 : :
1338 : 5 : ut_seq.complete = false;
1339 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1340 : :
1341 : 5 : poll_threads();
1342 : :
1343 : 5 : CU_ASSERT_EQUAL(completed, 2);
1344 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1345 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1346 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1347 : :
1348 : 5 : spdk_put_io_channel(ioch);
1349 : 5 : poll_threads();
1350 : 5 : }
1351 : :
1352 : : static void
1353 : 5 : test_sequence_reverse(void)
1354 : : {
1355 : 5 : struct spdk_accel_sequence *seq = NULL;
1356 : 1 : struct spdk_io_channel *ioch;
1357 : 4 : struct ut_sequence ut_seq;
1358 : 4 : char buf[4096], tmp[2][4096], expected[4096];
1359 : 4 : struct iovec src_iovs[2], dst_iovs[2];
1360 : 4 : uint32_t compressed_size;
1361 : 5 : int rc, completed = 0;
1362 : :
1363 : 5 : ioch = spdk_accel_get_io_channel();
1364 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
1365 : :
1366 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
1367 [ + - + - ]: 5 : src_iovs[0].iov_base = expected;
1368 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(expected);
+ - ]
1369 [ + - + - : 5 : rc = spdk_accel_submit_compress(ioch, tmp[0], sizeof(tmp[0]), &src_iovs[0], 1,
+ - + - ]
1370 : : &compressed_size, 0, ut_compress_cb, &completed);
1371 : 5 : CU_ASSERT_EQUAL(rc, 0);
1372 : :
1373 [ + + ]: 10 : while (!completed) {
1374 : 5 : poll_threads();
1375 : : }
1376 : :
1377 : : /* First check that reversing a sequnce with a single operation is a no-op */
1378 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1379 : 5 : seq = NULL;
1380 : 5 : completed = 0;
1381 : :
1382 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
1383 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
1384 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1385 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1386 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1387 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1388 : : ut_sequence_step_cb, &completed);
1389 : 5 : CU_ASSERT_EQUAL(rc, 0);
1390 : :
1391 : 5 : spdk_accel_sequence_reverse(seq);
1392 : :
1393 : 5 : ut_seq.complete = false;
1394 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1395 : :
1396 : 5 : poll_threads();
1397 : :
1398 : 5 : CU_ASSERT_EQUAL(completed, 1);
1399 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1400 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1401 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1402 : :
1403 : : /* Add a copy operation at the end with src set to the compressed data. After reverse(),
1404 : : * that copy operation should be first, so decompress() should receive compressed data in
1405 : : * its src buffer.
1406 : : */
1407 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1408 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
1409 : 5 : seq = NULL;
1410 : 5 : completed = 0;
1411 : :
1412 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
1413 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
1414 [ + - + - : 5 : src_iovs[0].iov_base = tmp[1];
+ - + - ]
1415 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1416 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1417 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1418 : : ut_sequence_step_cb, &completed);
1419 : 5 : CU_ASSERT_EQUAL(rc, 0);
1420 : :
1421 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1422 [ + - + - : 5 : dst_iovs[1].iov_len = compressed_size;
+ - + - ]
1423 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
1424 [ + - + - : 5 : src_iovs[1].iov_len = compressed_size;
+ - + - ]
1425 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1426 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1427 : : ut_sequence_step_cb, &completed);
1428 : 5 : CU_ASSERT_EQUAL(rc, 0);
1429 : :
1430 : 5 : spdk_accel_sequence_reverse(seq);
1431 : :
1432 : 5 : ut_seq.complete = false;
1433 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1434 : :
1435 : 5 : poll_threads();
1436 : :
1437 : 5 : CU_ASSERT_EQUAL(completed, 2);
1438 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1439 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1440 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1441 : :
1442 : : /* Check the same, but add an extra fill operation at the beginning that should execute last
1443 : : * after reverse().
1444 : : */
1445 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1446 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
1447 [ + - ]: 5 : memset(expected, 0xfe, 2048);
1448 : 5 : seq = NULL;
1449 : 5 : completed = 0;
1450 : :
1451 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 2048, NULL, NULL, 0xfe, 0,
1452 : : ut_sequence_step_cb, &completed);
1453 : 5 : CU_ASSERT_EQUAL(rc, 0);
1454 : :
1455 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
1456 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
1457 [ + - + - : 5 : src_iovs[0].iov_base = tmp[1];
+ - + - ]
1458 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1459 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1460 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1461 : : ut_sequence_step_cb, &completed);
1462 : 5 : CU_ASSERT_EQUAL(rc, 0);
1463 : :
1464 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1465 [ + - + - : 5 : dst_iovs[1].iov_len = compressed_size;
+ - + - ]
1466 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
1467 [ + - + - : 5 : src_iovs[1].iov_len = compressed_size;
+ - + - ]
1468 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1469 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1470 : : ut_sequence_step_cb, &completed);
1471 : 5 : CU_ASSERT_EQUAL(rc, 0);
1472 : :
1473 : 5 : spdk_accel_sequence_reverse(seq);
1474 : :
1475 : 5 : ut_seq.complete = false;
1476 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1477 : :
1478 : 5 : poll_threads();
1479 : :
1480 : 5 : CU_ASSERT_EQUAL(completed, 3);
1481 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1482 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1483 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1484 : :
1485 : : /* Build the sequence in order and then reverse it twice */
1486 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
1487 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
1488 : 5 : seq = NULL;
1489 : 5 : completed = 0;
1490 : :
1491 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1492 [ + - + - : 5 : dst_iovs[0].iov_len = compressed_size;
+ - ]
1493 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1494 [ + - + - : 5 : src_iovs[0].iov_len = compressed_size;
+ - ]
1495 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1496 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1497 : : ut_sequence_step_cb, &completed);
1498 : 5 : CU_ASSERT_EQUAL(rc, 0);
1499 : :
1500 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1501 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1502 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1503 [ + - + - : 5 : src_iovs[1].iov_len = compressed_size;
+ - + - ]
1504 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1505 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1506 : : ut_sequence_step_cb, &completed);
1507 : 5 : CU_ASSERT_EQUAL(rc, 0);
1508 : :
1509 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 2048, NULL, NULL, 0xfe, 0,
1510 : : ut_sequence_step_cb, &completed);
1511 : 5 : CU_ASSERT_EQUAL(rc, 0);
1512 : :
1513 : 5 : spdk_accel_sequence_reverse(seq);
1514 : 5 : spdk_accel_sequence_reverse(seq);
1515 : :
1516 : 5 : ut_seq.complete = false;
1517 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1518 : :
1519 : 5 : poll_threads();
1520 : :
1521 : 5 : CU_ASSERT_EQUAL(completed, 3);
1522 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1523 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1524 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
1525 : :
1526 : 5 : spdk_put_io_channel(ioch);
1527 : 5 : poll_threads();
1528 : 5 : }
1529 : : #endif
1530 : :
1531 : : static void
1532 : 5 : test_sequence_copy_elision(void)
1533 : : {
1534 : 5 : struct spdk_accel_sequence *seq = NULL;
1535 : 1 : struct spdk_io_channel *ioch;
1536 : 4 : struct ut_sequence ut_seq;
1537 : 4 : struct iovec src_iovs[4], dst_iovs[4], exp_iovs[2];
1538 : 4 : char buf[4096], tmp[4][4096];
1539 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
1540 : 5 : struct spdk_accel_crypto_key key = {};
1541 : 4 : int i, rc, completed;
1542 : :
1543 : 5 : ioch = spdk_accel_get_io_channel();
1544 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
1545 : :
1546 : : /* Override the submit_tasks function */
1547 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
1548 [ + - ]: 5 : g_module.supports_memory_domains = true;
1549 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
1550 [ + - + - : 70 : g_seq_operations[i].complete_status = 0;
+ - + - ]
1551 [ + - + - : 70 : g_seq_operations[i].submit_status = 0;
+ - + - ]
1552 [ + - + - : 70 : g_seq_operations[i].count = 0;
+ - + - ]
1553 : :
1554 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
1555 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
1556 : 14 : }
1557 : :
1558 : : /* Check that a copy operation at the beginning is removed */
1559 : 5 : seq = NULL;
1560 : 5 : completed = 0;
1561 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].dst_iovcnt = 1;
+ - + - ]
1562 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].src_iovcnt = 1;
+ - + - ]
1563 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1564 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1565 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1566 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1567 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1568 [ + - + - : 5 : exp_iovs[1].iov_len = 2048;
+ - + - ]
1569 : :
1570 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1571 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1572 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1573 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1574 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1575 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1576 : : ut_sequence_step_cb, &completed);
1577 : 5 : CU_ASSERT_EQUAL(rc, 0);
1578 : :
1579 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1580 [ + - + - : 5 : dst_iovs[1].iov_len = 2048;
+ - + - ]
1581 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1582 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1583 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1584 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1585 : : ut_sequence_step_cb, &completed);
1586 : 5 : CU_ASSERT_EQUAL(rc, 0);
1587 : :
1588 : 5 : ut_seq.complete = false;
1589 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1590 : :
1591 : 5 : poll_threads();
1592 : :
1593 : 5 : CU_ASSERT_EQUAL(completed, 2);
1594 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1595 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1596 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1597 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
1598 : :
1599 : : /* Check that a copy operation at the end is removed too */
1600 : 5 : seq = NULL;
1601 : 5 : completed = 0;
1602 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1603 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
1604 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1605 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1606 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1607 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1608 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1609 [ + - + - : 5 : exp_iovs[1].iov_len = 2048;
+ - + - ]
1610 : :
1611 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1612 [ + - + - : 5 : dst_iovs[0].iov_len = 2048;
+ - ]
1613 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1614 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1615 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1616 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1617 : : ut_sequence_step_cb, &completed);
1618 : 5 : CU_ASSERT_EQUAL(rc, 0);
1619 : :
1620 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1621 [ + - + - : 5 : dst_iovs[1].iov_len = 2048;
+ - + - ]
1622 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1623 [ + - + - : 5 : src_iovs[1].iov_len = 2048;
+ - + - ]
1624 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1625 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1626 : : ut_sequence_step_cb, &completed);
1627 : 5 : CU_ASSERT_EQUAL(rc, 0);
1628 : :
1629 : 5 : ut_seq.complete = false;
1630 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1631 : :
1632 : 5 : poll_threads();
1633 : :
1634 : 5 : CU_ASSERT_EQUAL(completed, 2);
1635 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1636 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1637 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1638 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
1639 : :
1640 : : /* Check a copy operation both at the beginning and the end */
1641 : 5 : seq = NULL;
1642 : 5 : completed = 0;
1643 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1644 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
1645 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1646 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1647 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1648 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1649 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1650 [ + - + - : 5 : exp_iovs[1].iov_len = 2048;
+ - + - ]
1651 : :
1652 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1653 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1654 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1655 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1656 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1657 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1658 : : ut_sequence_step_cb, &completed);
1659 : 5 : CU_ASSERT_EQUAL(rc, 0);
1660 : :
1661 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
1662 [ + - + - : 5 : dst_iovs[1].iov_len = 2048;
+ - + - ]
1663 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1664 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1665 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1666 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1667 : : ut_sequence_step_cb, &completed);
1668 : 5 : CU_ASSERT_EQUAL(rc, 0);
1669 : :
1670 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
1671 [ + - + - : 5 : dst_iovs[2].iov_len = 2048;
+ - + - ]
1672 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
1673 [ + - + - : 5 : src_iovs[2].iov_len = 2048;
+ - + - ]
1674 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
1675 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
1676 : : ut_sequence_step_cb, &completed);
1677 : 5 : CU_ASSERT_EQUAL(rc, 0);
1678 : :
1679 : 5 : ut_seq.complete = false;
1680 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1681 : :
1682 : 5 : poll_threads();
1683 : :
1684 : 5 : CU_ASSERT_EQUAL(completed, 3);
1685 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1686 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1687 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1688 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
1689 : :
1690 : : /* Check decompress + copy + decompress + copy */
1691 : 5 : seq = NULL;
1692 : 5 : completed = 0;
1693 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1694 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
1695 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].src_iovs = NULL;
+ - + - ]
1696 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].dst_iovs = NULL;
+ - + - ]
1697 : :
1698 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1699 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1700 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1701 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1702 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1703 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1704 : : ut_sequence_step_cb, &completed);
1705 : 5 : CU_ASSERT_EQUAL(rc, 0);
1706 : :
1707 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
1708 [ + - + - : 5 : dst_iovs[1].iov_len = 2048;
+ - + - ]
1709 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1710 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1711 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1712 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1713 : : ut_sequence_step_cb, &completed);
1714 : 5 : CU_ASSERT_EQUAL(rc, 0);
1715 : :
1716 [ + - + - : 5 : dst_iovs[2].iov_base = tmp[3];
+ - + - +
- + - ]
1717 [ + - + - : 5 : dst_iovs[2].iov_len = 1024;
+ - + - ]
1718 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
1719 [ + - + - : 5 : src_iovs[2].iov_len = 2048;
+ - + - ]
1720 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
1721 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
1722 : : ut_sequence_step_cb, &completed);
1723 : 5 : CU_ASSERT_EQUAL(rc, 0);
1724 : :
1725 [ + - + - : 5 : dst_iovs[3].iov_base = buf;
+ - + - ]
1726 [ + - + - : 5 : dst_iovs[3].iov_len = 1024;
+ - + - ]
1727 [ + - + - : 5 : src_iovs[3].iov_base = tmp[3];
+ - + - +
- + - ]
1728 [ + - + - : 5 : src_iovs[3].iov_len = 1024;
+ - + - ]
1729 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[3], 1, NULL, NULL,
1730 [ + - + - ]: 1 : &src_iovs[3], 1, NULL, NULL, 0,
1731 : : ut_sequence_step_cb, &completed);
1732 : 5 : CU_ASSERT_EQUAL(rc, 0);
1733 : :
1734 : 5 : ut_seq.complete = false;
1735 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1736 : :
1737 : 5 : poll_threads();
1738 : :
1739 : 5 : CU_ASSERT_EQUAL(completed, 4);
1740 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1741 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1742 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1743 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 2);
+ - + - ]
1744 : :
1745 : : /* Check two copy operations - one of them should be removed, while the other should be
1746 : : * executed normally */
1747 : 5 : seq = NULL;
1748 : 5 : completed = 0;
1749 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1750 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].dst_iovcnt = 1;
+ - ]
1751 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].src_iovcnt = 1;
+ - ]
1752 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].src_iovs = &exp_iovs[0];
+ - + - +
- ]
1753 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].dst_iovs = &exp_iovs[1];
+ - + - +
- ]
1754 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1755 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1756 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1757 [ + - + - : 5 : exp_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1758 : :
1759 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1760 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1761 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1762 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1763 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1764 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1765 : : ut_sequence_step_cb, &completed);
1766 : 5 : CU_ASSERT_EQUAL(rc, 0);
1767 : :
1768 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
1769 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1770 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1771 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1772 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
1773 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
1774 : : ut_sequence_step_cb, &completed);
1775 : 5 : CU_ASSERT_EQUAL(rc, 0);
1776 : :
1777 : 5 : ut_seq.complete = false;
1778 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1779 : :
1780 : 5 : poll_threads();
1781 : :
1782 : 5 : CU_ASSERT_EQUAL(completed, 2);
1783 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1784 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1785 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 1);
+ - ]
1786 : :
1787 : : /* Check fill + copy */
1788 : 5 : seq = NULL;
1789 : 5 : completed = 0;
1790 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1791 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
1792 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].src_iovs = NULL;
+ - ]
1793 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].dst_iovs = NULL;
+ - ]
1794 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].dst_iovcnt = 1;
+ - + - ]
1795 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].dst_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1796 [ + - + - ]: 5 : exp_iovs[0].iov_base = buf;
1797 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(buf);
+ - ]
1798 : :
1799 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], sizeof(tmp[0]), NULL, NULL, 0xa5, 0,
1800 : : ut_sequence_step_cb, &completed);
1801 : 5 : CU_ASSERT_EQUAL(rc, 0);
1802 : :
1803 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
1804 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
1805 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1806 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1807 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1808 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1809 : : ut_sequence_step_cb, &completed);
1810 : 5 : CU_ASSERT_EQUAL(rc, 0);
1811 : :
1812 : 5 : ut_seq.complete = false;
1813 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1814 : :
1815 : 5 : poll_threads();
1816 : :
1817 : 5 : CU_ASSERT_EQUAL(completed, 2);
1818 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1819 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1820 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1821 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
1822 : :
1823 : : /* Check copy + encrypt + copy */
1824 : 5 : seq = NULL;
1825 : 5 : completed = 0;
1826 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1827 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
1828 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].dst_iovcnt = 1;
+ - + - ]
1829 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].src_iovcnt = 1;
+ - + - ]
1830 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1831 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1832 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1833 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1834 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1835 [ + - + - : 5 : exp_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1836 : :
1837 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1838 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1839 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1840 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1841 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1842 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1843 : : ut_sequence_step_cb, &completed);
1844 : 5 : CU_ASSERT_EQUAL(rc, 0);
1845 : :
1846 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
1847 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
1848 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1849 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1850 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
1851 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, sizeof(tmp[2]), 0,
1852 : : ut_sequence_step_cb, &completed);
1853 : 5 : CU_ASSERT_EQUAL(rc, 0);
1854 : :
1855 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
1856 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
1857 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
1858 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
1859 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
1860 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
1861 : : ut_sequence_step_cb, &completed);
1862 : 5 : CU_ASSERT_EQUAL(rc, 0);
1863 : :
1864 : 5 : ut_seq.complete = false;
1865 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1866 : :
1867 : 5 : poll_threads();
1868 : :
1869 : 5 : CU_ASSERT_EQUAL(completed, 3);
1870 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1871 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1872 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1873 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
1874 : :
1875 : : /* Check copy + decrypt + copy */
1876 : 5 : seq = NULL;
1877 : 5 : completed = 0;
1878 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1879 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
1880 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_iovcnt = 1;
+ - + - ]
1881 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_iovcnt = 1;
+ - + - ]
1882 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1883 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1884 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1885 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1886 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1887 [ + - + - : 5 : exp_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1888 : :
1889 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1890 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1891 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1892 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1893 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
1894 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
1895 : : ut_sequence_step_cb, &completed);
1896 : 5 : CU_ASSERT_EQUAL(rc, 0);
1897 : :
1898 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
1899 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
1900 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1901 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1902 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
1903 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, sizeof(tmp[2]), 0,
1904 : : ut_sequence_step_cb, &completed);
1905 : 5 : CU_ASSERT_EQUAL(rc, 0);
1906 : :
1907 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
1908 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
1909 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
1910 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
1911 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
1912 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
1913 : : ut_sequence_step_cb, &completed);
1914 : 5 : CU_ASSERT_EQUAL(rc, 0);
1915 : :
1916 : 5 : ut_seq.complete = false;
1917 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1918 : :
1919 : 5 : poll_threads();
1920 : :
1921 : 5 : CU_ASSERT_EQUAL(completed, 3);
1922 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1923 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1924 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1925 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
1926 : :
1927 : : /* Check a sequence with memory domains and verify their pointers (and their contexts) are
1928 : : * correctly set on the next/prev task when a copy is removed */
1929 : 5 : seq = NULL;
1930 : 5 : completed = 0;
1931 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
1932 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
1933 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_iovcnt = 1;
+ - + - ]
1934 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_iovcnt = 1;
+ - + - ]
1935 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_iovs = &exp_iovs[0];
+ - + - +
- + - ]
1936 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_iovs = &exp_iovs[1];
+ - + - +
- + - ]
1937 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_domain = (void *)0x1;
+ - + - ]
1938 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].dst_domain_ctx = (void *)0x2;
+ - + - ]
1939 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_domain = (void *)0x3;
+ - + - ]
1940 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].src_domain_ctx = (void *)0x4;
+ - + - ]
1941 [ + - + - : 5 : exp_iovs[0].iov_base = tmp[0];
+ - + - ]
1942 [ + - + - : 5 : exp_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1943 [ + - + - : 5 : exp_iovs[1].iov_base = buf;
+ - + - ]
1944 [ + - + - : 5 : exp_iovs[1].iov_len = sizeof(buf);
+ - + - ]
1945 : :
1946 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
1947 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
1948 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
1949 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
1950 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, (void *)0xdead, (void *)0xbeef,
1951 [ + - + - ]: 1 : &src_iovs[0], 1, (void *)0x3, (void *)0x4, 0,
1952 : : ut_sequence_step_cb, &completed);
1953 : 5 : CU_ASSERT_EQUAL(rc, 0);
1954 : :
1955 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
1956 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
1957 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
1958 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
1959 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[1], 1, (void *)0xdead, (void *)0xbeef,
1960 [ + - + - ]: 1 : &src_iovs[1], 1, (void *)0xdead, (void *)0xbeef, 0,
1961 : : sizeof(tmp[2]), 0, ut_sequence_step_cb, &completed);
1962 : 5 : CU_ASSERT_EQUAL(rc, 0);
1963 : :
1964 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
1965 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
1966 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
1967 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
1968 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, (void *)0x1, (void *)0x2,
1969 [ + - + - ]: 1 : &src_iovs[2], 1, (void *)0xdead, (void *)0xbeef, 0,
1970 : : ut_sequence_step_cb, &completed);
1971 : 5 : CU_ASSERT_EQUAL(rc, 0);
1972 : :
1973 : 5 : ut_seq.complete = false;
1974 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
1975 : :
1976 : 5 : poll_threads();
1977 : :
1978 : 5 : CU_ASSERT_EQUAL(completed, 3);
1979 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
1980 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
1981 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
1982 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
1983 : :
1984 : : /* Cleanup module pointers to make subsequent tests work correctly */
1985 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
1986 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
1987 : 14 : }
1988 : :
1989 [ + - ]: 5 : g_module.supports_memory_domains = false;
1990 : 5 : ut_clear_operations();
1991 : 5 : spdk_put_io_channel(ioch);
1992 : 5 : poll_threads();
1993 : 5 : }
1994 : :
1995 : : static int
1996 : 90 : ut_submit_decompress(struct spdk_io_channel *ch, struct spdk_accel_task *task)
1997 : : {
1998 [ + - + - : 90 : spdk_iovmove(task->s.iovs, task->s.iovcnt, task->d.iovs, task->d.iovcnt);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
1999 : :
2000 : 90 : spdk_accel_task_complete(task, 0);
2001 : :
2002 : 90 : return 0;
2003 : : }
2004 : :
2005 : : static void
2006 : 5 : test_sequence_accel_buffers(void)
2007 : : {
2008 : 5 : struct spdk_accel_sequence *seq = NULL;
2009 : 1 : struct spdk_io_channel *ioch;
2010 : 1 : struct accel_io_channel *accel_ch;
2011 : 4 : struct ut_sequence ut_seq;
2012 : 4 : struct iovec src_iovs[3], dst_iovs[3];
2013 : 4 : char srcbuf[4096], dstbuf[4096], expected[4096];
2014 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
2015 : 4 : void *buf[2], *domain_ctx[2], *iobuf_buf;
2016 : 4 : struct spdk_memory_domain *domain[2];
2017 : 1 : struct spdk_iobuf_buffer *cache_entry;
2018 : 4 : spdk_iobuf_buffer_stailq_t small_cache;
2019 : 1 : uint32_t small_cache_count;
2020 : 4 : int i, rc, completed;
2021 : 5 : struct spdk_iobuf_opts opts_iobuf = {};
2022 : :
2023 : : /* Set up the iobuf to always use the "small" pool */
2024 [ + - ]: 5 : opts_iobuf.large_bufsize = 0x20000;
2025 [ + - ]: 5 : opts_iobuf.large_pool_count = 0;
2026 [ + - ]: 5 : opts_iobuf.small_bufsize = 0x10000;
2027 : 5 : opts_iobuf.small_pool_count = 32;
2028 : :
2029 : 5 : rc = spdk_iobuf_set_opts(&opts_iobuf);
2030 : 5 : CU_ASSERT(rc == 0);
2031 : :
2032 : 5 : ioch = spdk_accel_get_io_channel();
2033 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
2034 : :
2035 : : /* Override the submit_tasks function */
2036 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
2037 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2038 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
2039 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
2040 : 14 : }
2041 : : /* Intercept decompress to make it simply copy the data, so that we can chain multiple
2042 : : * decompress operations together in one sequence.
2043 : : */
2044 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].submit = ut_submit_decompress;
+ - + - ]
2045 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].submit = sw_accel_submit_tasks;
+ - ]
2046 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].submit = sw_accel_submit_tasks;
+ - + - ]
2047 : :
2048 : : /* Check the simplest case: one operation using accel buffer as destination + copy operation
2049 : : * specifying the actual destination buffer
2050 : : */
2051 [ + - ]: 5 : memset(srcbuf, 0xa5, 4096);
2052 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2053 [ + - ]: 5 : memset(expected, 0xa5, 4096);
2054 : 5 : completed = 0;
2055 : 5 : seq = NULL;
2056 : :
2057 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2058 : 5 : CU_ASSERT_EQUAL(rc, 0);
2059 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2060 : :
2061 [ + - + - ]: 5 : src_iovs[0].iov_base = srcbuf;
2062 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2063 [ + - + - : 5 : dst_iovs[0].iov_base = buf[0];
+ - + - ]
2064 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2065 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, domain[0], domain_ctx[0],
+ - + - +
- + - ]
2066 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
2067 : : ut_sequence_step_cb, &completed);
2068 : 5 : CU_ASSERT_EQUAL(rc, 0);
2069 : :
2070 [ + - + - : 5 : src_iovs[1].iov_base = buf[0];
+ - + - +
- + - ]
2071 [ + - + - : 5 : src_iovs[1].iov_len = 4096;
+ - + - ]
2072 [ + - + - : 5 : dst_iovs[1].iov_base = dstbuf;
+ - + - ]
2073 [ + - + - : 5 : dst_iovs[1].iov_len = 4096;
+ - + - ]
2074 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
2075 [ + - + - : 1 : &src_iovs[1], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2076 : : ut_sequence_step_cb, &completed);
2077 : 5 : CU_ASSERT_EQUAL(rc, 0);
2078 : :
2079 : 5 : ut_seq.complete = false;
2080 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2081 : :
2082 : 5 : poll_threads();
2083 : :
2084 : 5 : CU_ASSERT_EQUAL(completed, 2);
2085 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2086 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2087 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2088 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2089 : :
2090 : : /* Start with a fill operation using accel buffer, followed by a decompress using another
2091 : : * accel buffer as dst, followed by a copy operation specifying dst buffer of the whole
2092 : : * sequence
2093 : : */
2094 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2095 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2096 [ + - ]: 5 : memset(expected, 0x5a, 4096);
2097 : 5 : completed = 0;
2098 : 5 : seq = NULL;
2099 : :
2100 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2101 : 5 : CU_ASSERT_EQUAL(rc, 0);
2102 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2103 : :
2104 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 4096, domain[0], domain_ctx[0], 0x5a, 0,
+ - + - +
- + - ]
2105 : : ut_sequence_step_cb, &completed);
2106 : 5 : CU_ASSERT_EQUAL(rc, 0);
2107 : :
2108 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[1], &domain[1], &domain_ctx[1]);
+ - + - +
- + - ]
2109 : 5 : CU_ASSERT_EQUAL(rc, 0);
2110 [ + - + - : 5 : CU_ASSERT_PTR_NOT_NULL(buf[1]);
+ - ]
2111 : :
2112 [ + - + - : 5 : src_iovs[0].iov_base = buf[0];
+ - + - ]
2113 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2114 [ + - + - : 5 : dst_iovs[0].iov_base = buf[1];
+ - + - +
- ]
2115 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2116 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, domain[1], domain_ctx[1],
+ - + - +
- + - + -
+ - ]
2117 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2118 : : ut_sequence_step_cb, &completed);
2119 : 5 : CU_ASSERT_EQUAL(rc, 0);
2120 : :
2121 [ + - + - : 5 : src_iovs[1].iov_base = buf[1];
+ - + - +
- + - +
- ]
2122 [ + - + - : 5 : src_iovs[1].iov_len = 4096;
+ - + - ]
2123 [ + - + - : 5 : dst_iovs[1].iov_base = dstbuf;
+ - + - ]
2124 [ + - + - : 5 : dst_iovs[1].iov_len = 4096;
+ - + - ]
2125 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
2126 [ + - + - : 1 : &src_iovs[1], 1, domain[1], domain_ctx[1], 0,
+ - + - +
- + - + -
+ - ]
2127 : : ut_sequence_step_cb, &completed);
2128 : :
2129 : 5 : ut_seq.complete = false;
2130 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2131 : :
2132 : 5 : poll_threads();
2133 : :
2134 : 5 : CU_ASSERT_EQUAL(completed, 3);
2135 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2136 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2137 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2138 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2139 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[1], domain[1], domain_ctx[1]);
+ - + - +
- + - + -
+ - + - ]
2140 : :
2141 : : /* Check the same, but with two decompress operations with the first one being in-place */
2142 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2143 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2144 [ + - ]: 5 : memset(expected, 0x5a, 4096);
2145 : 5 : completed = 0;
2146 : 5 : seq = NULL;
2147 : :
2148 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2149 : 5 : CU_ASSERT_EQUAL(rc, 0);
2150 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2151 : :
2152 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 4096, domain[0], domain_ctx[0], 0x5a, 0,
+ - + - +
- + - ]
2153 : : ut_sequence_step_cb, &completed);
2154 : 5 : CU_ASSERT_EQUAL(rc, 0);
2155 : :
2156 [ + - + - : 5 : src_iovs[0].iov_base = buf[0];
+ - + - ]
2157 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2158 [ + - + - : 5 : dst_iovs[0].iov_base = buf[0];
+ - + - ]
2159 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2160 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, domain[0], domain_ctx[0],
+ - + - +
- + - ]
2161 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2162 : : ut_sequence_step_cb, &completed);
2163 : 5 : CU_ASSERT_EQUAL(rc, 0);
2164 : :
2165 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[1], &domain[1], &domain_ctx[1]);
+ - + - +
- + - ]
2166 : 5 : CU_ASSERT_EQUAL(rc, 0);
2167 [ + - + - : 5 : CU_ASSERT_PTR_NOT_NULL(buf[1]);
+ - ]
2168 : :
2169 [ + - + - : 5 : src_iovs[1].iov_base = buf[0];
+ - + - +
- + - ]
2170 [ + - + - : 5 : src_iovs[1].iov_len = 4096;
+ - + - ]
2171 [ + - + - : 5 : dst_iovs[1].iov_base = buf[1];
+ - + - +
- + - +
- ]
2172 [ + - + - : 5 : dst_iovs[1].iov_len = 4096;
+ - + - ]
2173 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, domain[1], domain_ctx[1],
+ - + - +
- + - + -
+ - ]
2174 [ + - + - : 1 : &src_iovs[1], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2175 : : ut_sequence_step_cb, &completed);
2176 : 5 : CU_ASSERT_EQUAL(rc, 0);
2177 : :
2178 [ + - + - : 5 : src_iovs[2].iov_base = buf[1];
+ - + - +
- + - +
- ]
2179 [ + - + - : 5 : src_iovs[2].iov_len = 4096;
+ - + - ]
2180 [ + - + - : 5 : dst_iovs[2].iov_base = dstbuf;
+ - + - ]
2181 [ + - + - : 5 : dst_iovs[2].iov_len = 4096;
+ - + - ]
2182 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
2183 [ + - + - : 1 : &src_iovs[2], 1, domain[1], domain_ctx[1], 0,
+ - + - +
- + - + -
+ - ]
2184 : : ut_sequence_step_cb, &completed);
2185 : :
2186 : 5 : ut_seq.complete = false;
2187 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2188 : :
2189 : 5 : poll_threads();
2190 : :
2191 : 5 : CU_ASSERT_EQUAL(completed, 4);
2192 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2193 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2194 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2195 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2196 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[1], domain[1], domain_ctx[1]);
+ - + - +
- + - + -
+ - + - ]
2197 : :
2198 : : /* Check that specifying offsets within accel buffers works correctly */
2199 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2200 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2201 : 5 : completed = 0;
2202 : 5 : seq = NULL;
2203 : :
2204 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2205 : 5 : CU_ASSERT_EQUAL(rc, 0);
2206 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2207 : :
2208 : : /* Fill in each 1K of the buffer with different pattern */
2209 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 1024, domain[0], domain_ctx[0], 0xa5, 0,
+ - + - +
- + - ]
2210 : : ut_sequence_step_cb, &completed);
2211 : 5 : CU_ASSERT_EQUAL(rc, 0);
2212 : :
2213 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 1024, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2214 : : 0x5a, 0, ut_sequence_step_cb, &completed);
2215 : 5 : CU_ASSERT_EQUAL(rc, 0);
2216 : :
2217 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 2048, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2218 : : 0xfe, 0, ut_sequence_step_cb, &completed);
2219 : 5 : CU_ASSERT_EQUAL(rc, 0);
2220 : :
2221 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 3072, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2222 : : 0xed, 0, ut_sequence_step_cb, &completed);
2223 : 5 : CU_ASSERT_EQUAL(rc, 0);
2224 : :
2225 [ + - + - : 5 : src_iovs[0].iov_base = buf[0];
+ - + - ]
2226 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2227 [ + - + - ]: 5 : dst_iovs[0].iov_base = dstbuf;
2228 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2229 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
2230 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2231 : : ut_sequence_step_cb, &completed);
2232 : :
2233 : 5 : ut_seq.complete = false;
2234 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2235 : :
2236 : 5 : poll_threads();
2237 : :
2238 [ + - + - : 5 : memset(&expected[0], 0xa5, 1024);
+ - ]
2239 [ + - + - : 5 : memset(&expected[1024], 0x5a, 1024);
+ - ]
2240 [ + - + - : 5 : memset(&expected[2048], 0xfe, 1024);
+ - ]
2241 [ + - + - : 5 : memset(&expected[3072], 0xed, 1024);
+ - ]
2242 : 5 : CU_ASSERT_EQUAL(completed, 5);
2243 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2244 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2245 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2246 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2247 : :
2248 : : /* Check the same but this time with a decompress operation on part of the buffer (512B
2249 : : * offset) */
2250 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2251 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2252 : 5 : completed = 0;
2253 : 5 : seq = NULL;
2254 : :
2255 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2256 : 5 : CU_ASSERT_EQUAL(rc, 0);
2257 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2258 : :
2259 : : /* Fill in each 1K of the buffer with different pattern */
2260 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 1024, domain[0], domain_ctx[0], 0xa5, 0,
+ - + - +
- + - ]
2261 : : ut_sequence_step_cb, &completed);
2262 : 5 : CU_ASSERT_EQUAL(rc, 0);
2263 : :
2264 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 1024, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2265 : : 0x5a, 0, ut_sequence_step_cb, &completed);
2266 : 5 : CU_ASSERT_EQUAL(rc, 0);
2267 : :
2268 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 2048, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2269 : : 0xfe, 0, ut_sequence_step_cb, &completed);
2270 : 5 : CU_ASSERT_EQUAL(rc, 0);
2271 : :
2272 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, (char *)buf[0] + 3072, 1024, domain[0], domain_ctx[0],
+ - + - +
- + - +
- ]
2273 : : 0xed, 0, ut_sequence_step_cb, &completed);
2274 : 5 : CU_ASSERT_EQUAL(rc, 0);
2275 : :
2276 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 3072, &buf[1], &domain[1], &domain_ctx[1]);
+ - + - +
- + - ]
2277 : 5 : CU_ASSERT_EQUAL(rc, 0);
2278 [ + - + - : 5 : CU_ASSERT_PTR_NOT_NULL(buf[1]);
+ - ]
2279 : :
2280 [ + - + - : 5 : src_iovs[0].iov_base = (char *)buf[0] + 512;
+ - + - +
- ]
2281 [ + - + - : 5 : src_iovs[0].iov_len = 3072;
+ - ]
2282 [ + - + - : 5 : dst_iovs[0].iov_base = (char *)buf[1] + 256;
+ - + - +
- + - ]
2283 [ + - + - : 5 : dst_iovs[0].iov_len = 3072;
+ - ]
2284 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, domain[1], domain_ctx[1],
+ - + - +
- + - + -
+ - ]
2285 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2286 : : ut_sequence_step_cb, &completed);
2287 : :
2288 [ + - + - : 5 : src_iovs[1].iov_base = (char *)buf[1] + 256;
+ - + - +
- + - + -
+ - ]
2289 [ + - + - : 5 : src_iovs[1].iov_len = 3072;
+ - + - ]
2290 [ + - + - : 5 : dst_iovs[1].iov_base = dstbuf;
+ - + - ]
2291 [ + - + - : 5 : dst_iovs[1].iov_len = 3072;
+ - + - ]
2292 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
2293 [ + - + - : 1 : &src_iovs[1], 1, domain[1], domain_ctx[1], 0,
+ - + - +
- + - + -
+ - ]
2294 : : ut_sequence_step_cb, &completed);
2295 : :
2296 : 5 : ut_seq.complete = false;
2297 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2298 : :
2299 : 5 : poll_threads();
2300 : :
2301 [ + - + - : 5 : memset(&expected[0], 0xa5, 512);
+ - ]
2302 [ + - + - : 5 : memset(&expected[512], 0x5a, 1024);
+ - ]
2303 [ + - + - : 5 : memset(&expected[1536], 0xfe, 1024);
+ - ]
2304 [ + - + - : 5 : memset(&expected[2560], 0xed, 512);
+ - ]
2305 : 5 : CU_ASSERT_EQUAL(completed, 6);
2306 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2307 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2308 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 3072), 0);
2309 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2310 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[1], domain[1], domain_ctx[1]);
+ - + - +
- + - + -
+ - + - ]
2311 : :
2312 : : /* Check that if iobuf pool is empty, the sequence processing will wait until a buffer is
2313 : : * available
2314 : : */
2315 : 5 : accel_ch = spdk_io_channel_get_ctx(ioch);
2316 [ + - + - : 5 : small_cache_count = accel_ch->iobuf.small.cache_count;
+ - + - ]
2317 [ + - ]: 5 : STAILQ_INIT(&small_cache);
2318 [ + - + - : 5 : STAILQ_SWAP(&accel_ch->iobuf.small.cache, &small_cache, spdk_iobuf_buffer);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- + + - +
- + - + -
+ - + - +
- + - + -
- + + - ]
2319 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = 0;
+ - + - ]
2320 [ + - + - : 5 : accel_ch->iobuf.small.cache_size = 0;
+ - + - ]
2321 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2322 : :
2323 : : /* First allocate a single buffer used by two operations */
2324 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2325 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2326 [ + - ]: 5 : memset(expected, 0xa5, 4096);
2327 : 5 : completed = 0;
2328 : 5 : seq = NULL;
2329 : :
2330 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2331 : 5 : CU_ASSERT_EQUAL(rc, 0);
2332 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2333 : :
2334 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 4096, domain[0], domain_ctx[0], 0xa5, 0,
+ - + - +
- + - ]
2335 : : ut_sequence_step_cb, &completed);
2336 : 5 : CU_ASSERT_EQUAL(rc, 0);
2337 : :
2338 [ + - + - : 5 : src_iovs[0].iov_base = buf[0];
+ - + - ]
2339 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2340 [ + - + - ]: 5 : dst_iovs[0].iov_base = dstbuf;
2341 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2342 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
2343 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2344 : : ut_sequence_step_cb, &completed);
2345 : :
2346 : 5 : ut_seq.complete = false;
2347 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2348 : :
2349 : 5 : poll_threads();
2350 : :
2351 : 5 : CU_ASSERT_EQUAL(completed, 0);
2352 [ + + ]: 5 : CU_ASSERT(!ut_seq.complete);
2353 : :
2354 : : /* Get a buffer and return it to the pool to trigger the sequence to finish */
2355 [ + - ]: 5 : g_iobuf.small_pool_count = 1;
2356 [ + - ]: 5 : iobuf_buf = spdk_iobuf_get(&accel_ch->iobuf, 4096, NULL, NULL);
2357 : 5 : CU_ASSERT_PTR_NOT_NULL(iobuf_buf);
2358 [ + - ]: 5 : CU_ASSERT(g_iobuf.small_pool_count == 0);
2359 [ + - ]: 5 : spdk_iobuf_put(&accel_ch->iobuf, iobuf_buf, 4096);
2360 : :
2361 : 5 : poll_threads();
2362 : :
2363 : 5 : CU_ASSERT_EQUAL(completed, 2);
2364 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2365 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2366 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2367 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2368 : :
2369 : : /* Return the buffers back to the cache */
2370 [ + + + - : 5 : while (!STAILQ_EMPTY(&accel_ch->iobuf.small.cache)) {
+ - + - +
- - + ]
2371 [ # # # # : 0 : cache_entry = STAILQ_FIRST(&accel_ch->iobuf.small.cache);
# # # # #
# ]
2372 [ # # # # : 0 : STAILQ_REMOVE_HEAD(&accel_ch->iobuf.small.cache, stailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2373 [ # # # # : 0 : STAILQ_INSERT_HEAD(&small_cache, cache_entry, stailq);
# # # # #
# # # #
# ]
2374 : 0 : small_cache_count++;
2375 : : }
2376 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = 0;
+ - + - ]
2377 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2378 : :
2379 : : /* Check a bit more complex scenario, with two buffers in the sequence */
2380 [ + - ]: 5 : memset(srcbuf, 0x0, 4096);
2381 [ + - ]: 5 : memset(dstbuf, 0x0, 4096);
2382 [ + - ]: 5 : memset(expected, 0x5a, 4096);
2383 : 5 : completed = 0;
2384 : 5 : seq = NULL;
2385 : :
2386 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[0], &domain[0], &domain_ctx[0]);
+ - + - +
- + - ]
2387 : 5 : CU_ASSERT_EQUAL(rc, 0);
2388 [ + - + - ]: 5 : CU_ASSERT_PTR_NOT_NULL(buf[0]);
2389 : :
2390 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf[0], 4096, domain[0], domain_ctx[0], 0x5a, 0,
+ - + - +
- + - ]
2391 : : ut_sequence_step_cb, &completed);
2392 : 5 : CU_ASSERT_EQUAL(rc, 0);
2393 : :
2394 [ + - + - : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf[1], &domain[1], &domain_ctx[1]);
+ - + - +
- + - ]
2395 : 5 : CU_ASSERT_EQUAL(rc, 0);
2396 [ + - + - : 5 : CU_ASSERT_PTR_NOT_NULL(buf[1]);
+ - ]
2397 : :
2398 [ + - + - : 5 : src_iovs[0].iov_base = buf[0];
+ - + - ]
2399 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2400 [ + - + - : 5 : dst_iovs[0].iov_base = buf[1];
+ - + - +
- ]
2401 [ + - + - : 5 : dst_iovs[0].iov_len = 4096;
+ - ]
2402 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, domain[1], domain_ctx[1],
+ - + - +
- + - + -
+ - ]
2403 [ + - + - : 1 : &src_iovs[0], 1, domain[0], domain_ctx[0], 0,
+ - + - +
- + - ]
2404 : : ut_sequence_step_cb, &completed);
2405 : 5 : CU_ASSERT_EQUAL(rc, 0);
2406 : :
2407 [ + - + - : 5 : src_iovs[1].iov_base = buf[1];
+ - + - +
- + - +
- ]
2408 [ + - + - : 5 : src_iovs[1].iov_len = 4096;
+ - + - ]
2409 [ + - + - : 5 : dst_iovs[1].iov_base = dstbuf;
+ - + - ]
2410 [ + - + - : 5 : dst_iovs[1].iov_len = 4096;
+ - + - ]
2411 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
2412 [ + - + - : 1 : &src_iovs[1], 1, domain[1], domain_ctx[1], 0,
+ - + - +
- + - + -
+ - ]
2413 : : ut_sequence_step_cb, &completed);
2414 : 5 : CU_ASSERT_EQUAL(rc, 0);
2415 : :
2416 : 5 : ut_seq.complete = false;
2417 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2418 : :
2419 : 5 : poll_threads();
2420 : :
2421 : 5 : CU_ASSERT_EQUAL(completed, 0);
2422 [ + + ]: 5 : CU_ASSERT(!ut_seq.complete);
2423 : :
2424 [ + - ]: 5 : g_iobuf.small_pool_count = 1;
2425 [ + - ]: 5 : iobuf_buf = spdk_iobuf_get(&accel_ch->iobuf, 4096, NULL, NULL);
2426 : 5 : CU_ASSERT_PTR_NOT_NULL(iobuf_buf);
2427 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2428 [ + - ]: 5 : spdk_iobuf_put(&accel_ch->iobuf, iobuf_buf, 4096);
2429 : :
2430 : : /* One buffer is not enough to finish the whole sequence */
2431 : 5 : poll_threads();
2432 [ + + ]: 5 : CU_ASSERT(!ut_seq.complete);
2433 : :
2434 [ + - ]: 5 : g_iobuf.small_pool_count = 1;
2435 [ + - ]: 5 : iobuf_buf = spdk_iobuf_get(&accel_ch->iobuf, 4096, NULL, NULL);
2436 : 5 : CU_ASSERT_PTR_NOT_NULL(iobuf_buf);
2437 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2438 [ + - ]: 5 : spdk_iobuf_put(&accel_ch->iobuf, iobuf_buf, 4096);
2439 : :
2440 : 5 : poll_threads();
2441 : :
2442 : 5 : CU_ASSERT_EQUAL(completed, 3);
2443 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2444 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2445 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2446 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[0], domain[0], domain_ctx[0]);
+ - + - +
- + - ]
2447 [ + - + - : 5 : spdk_accel_put_buf(ioch, buf[1], domain[1], domain_ctx[1]);
+ - + - +
- + - + -
+ - + - ]
2448 : :
2449 : : /* Return the buffers back to the cache */
2450 [ + + + - : 5 : while (!STAILQ_EMPTY(&accel_ch->iobuf.small.cache)) {
+ - + - +
- - + ]
2451 [ # # # # : 0 : cache_entry = STAILQ_FIRST(&accel_ch->iobuf.small.cache);
# # # # #
# ]
2452 [ # # # # : 0 : STAILQ_REMOVE_HEAD(&accel_ch->iobuf.small.cache, stailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2453 [ # # # # : 0 : STAILQ_INSERT_HEAD(&small_cache, cache_entry, stailq);
# # # # #
# # # #
# ]
2454 : 0 : small_cache_count++;
2455 : : }
2456 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = 0;
+ - + - ]
2457 : :
2458 [ + - ]: 5 : g_iobuf.small_pool_count = 32;
2459 [ + - + - : 5 : STAILQ_SWAP(&accel_ch->iobuf.small.cache, &small_cache, spdk_iobuf_buffer);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- + + - +
- + - + -
+ - + - +
- + - + -
- + + - ]
2460 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = small_cache_count;
+ - + - ]
2461 : :
2462 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2463 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
2464 : 14 : }
2465 : :
2466 : 5 : ut_clear_operations();
2467 : 5 : spdk_put_io_channel(ioch);
2468 : 5 : poll_threads();
2469 : 5 : }
2470 : :
2471 : : static void
2472 : 120 : ut_domain_ctx_init(struct ut_domain_ctx *ctx, void *base, size_t len, struct iovec *expected)
2473 : : {
2474 [ + - + - : 120 : ctx->iov.iov_base = base;
+ - ]
2475 [ + - + - : 120 : ctx->iov.iov_len = len;
+ - ]
2476 [ + - ]: 120 : ctx->expected = *expected;
2477 [ + - + - ]: 120 : ctx->pull_submit_status = 0;
2478 [ + - + - ]: 120 : ctx->push_submit_status = 0;
2479 [ + - + - ]: 120 : ctx->pull_complete_status = 0;
2480 [ + - + - ]: 120 : ctx->push_complete_status = 0;
2481 : 120 : }
2482 : :
2483 : : static void
2484 : 5 : test_sequence_memory_domain(void)
2485 : : {
2486 : 5 : struct spdk_accel_sequence *seq = NULL;
2487 : 1 : struct spdk_io_channel *ioch;
2488 : 1 : struct accel_io_channel *accel_ch;
2489 : 4 : struct ut_sequence ut_seq;
2490 : 4 : struct ut_domain_ctx domctx[4];
2491 : 1 : struct spdk_iobuf_buffer *cache_entry;
2492 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
2493 : 4 : struct spdk_memory_domain *accel_domain;
2494 : 4 : spdk_iobuf_buffer_stailq_t small_cache;
2495 : 4 : char srcbuf[4096], dstbuf[4096], expected[4096], tmp[4096];
2496 : 4 : struct iovec src_iovs[2], dst_iovs[2];
2497 : 1 : uint32_t small_cache_count;
2498 : 4 : void *accel_buf, *accel_domain_ctx, *iobuf_buf;
2499 : 4 : int i, rc, completed;
2500 : :
2501 : 5 : ioch = spdk_accel_get_io_channel();
2502 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
2503 : :
2504 : : /* Override the submit_tasks function */
2505 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
2506 [ + - ]: 5 : g_module.supports_memory_domains = false;
2507 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2508 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
2509 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
2510 : 14 : }
2511 : : /* Intercept decompress to make it simply copy the data, so that we can chain multiple
2512 : : * decompress operations together in one sequence.
2513 : : */
2514 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].submit = ut_submit_decompress;
+ - + - ]
2515 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].submit = sw_accel_submit_tasks;
+ - ]
2516 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].submit = sw_accel_submit_tasks;
+ - + - ]
2517 : :
2518 : : /* First check the simplest case - single fill operation with dstbuf in domain */
2519 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
2520 [ + - ]: 5 : memset(dstbuf, 0x0, sizeof(dstbuf));
2521 : 5 : completed = 0;
2522 : 5 : seq = NULL;
2523 : :
2524 : : /* Use some garbage pointer as dst and use domain ctx to get the actual dstbuf */
2525 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xcafebabe;
2526 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2527 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2528 : :
2529 [ + - + - : 6 : rc = spdk_accel_append_fill(&seq, ioch, dst_iovs[0].iov_base, dst_iovs[0].iov_len,
+ - + - +
- ]
2530 [ + - + - ]: 1 : g_ut_domain, &domctx[0], 0xa5, 0,
2531 : : ut_sequence_step_cb, &completed);
2532 : 5 : CU_ASSERT_EQUAL(rc, 0);
2533 : :
2534 : 5 : ut_seq.complete = false;
2535 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2536 : :
2537 : 5 : poll_threads();
2538 : 5 : CU_ASSERT_EQUAL(completed, 1);
2539 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2540 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2541 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(expected, dstbuf, sizeof(dstbuf)), 0);
2542 : :
2543 : : /* Check operation with both srcbuf and dstbuf in remote memory domain */
2544 [ + - ]: 5 : memset(expected, 0x5a, sizeof(expected));
2545 [ + - ]: 5 : memset(dstbuf, 0x0, sizeof(dstbuf));
2546 [ + - ]: 5 : memset(srcbuf, 0x5a, sizeof(dstbuf));
2547 : 5 : completed = 0;
2548 : 5 : seq = NULL;
2549 : :
2550 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xcafebabe;
2551 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2552 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xbeefdead;
2553 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2554 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2555 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2556 : :
2557 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2558 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2559 : : ut_sequence_step_cb, &completed);
2560 : 5 : CU_ASSERT_EQUAL(rc, 0);
2561 : :
2562 : 5 : ut_seq.complete = false;
2563 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2564 : :
2565 : 5 : poll_threads();
2566 : 5 : CU_ASSERT_EQUAL(completed, 1);
2567 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2568 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2569 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(expected, dstbuf, sizeof(dstbuf)), 0);
2570 : :
2571 : : /* Two operations using a buffer in remote domain */
2572 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
2573 [ + - ]: 5 : memset(srcbuf, 0xa5, sizeof(srcbuf));
2574 [ + - ]: 5 : memset(tmp, 0x0, sizeof(tmp));
2575 [ + - ]: 5 : memset(dstbuf, 0x0, sizeof(dstbuf));
2576 : 5 : completed = 0;
2577 : 5 : seq = NULL;
2578 : :
2579 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xcafebabe;
2580 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2581 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xbeefdead;
2582 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp);
+ - ]
2583 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], tmp, sizeof(tmp), &dst_iovs[0]);
+ - + - ]
2584 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2585 : :
2586 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2587 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2588 : : ut_sequence_step_cb, &completed);
2589 : 5 : CU_ASSERT_EQUAL(rc, 0);
2590 : :
2591 [ + - + - : 5 : src_iovs[1].iov_base = (void *)0xbeefdead;
+ - + - ]
2592 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp);
+ - + - ]
2593 [ + - + - : 5 : dst_iovs[1].iov_base = (void *)0xa5a5a5a5;
+ - + - ]
2594 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(dstbuf);
+ - + - ]
2595 [ + - + - : 5 : ut_domain_ctx_init(&domctx[2], dstbuf, sizeof(dstbuf), &dst_iovs[1]);
+ - + - ]
2596 [ + - + - : 5 : ut_domain_ctx_init(&domctx[3], tmp, sizeof(tmp), &src_iovs[1]);
+ - + - ]
2597 : :
2598 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, g_ut_domain, &domctx[2],
+ - + - ]
2599 [ + - + - : 1 : &src_iovs[1], 1, g_ut_domain, &domctx[3], 0,
+ - + - ]
2600 : : ut_sequence_step_cb, &completed);
2601 : 5 : CU_ASSERT_EQUAL(rc, 0);
2602 : :
2603 : 5 : ut_seq.complete = false;
2604 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2605 : :
2606 : 5 : poll_threads();
2607 : 5 : CU_ASSERT_EQUAL(completed, 2);
2608 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2609 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2610 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(expected, dstbuf, sizeof(dstbuf)), 0);
2611 : :
2612 : : /* Use buffer in remote memory domain and accel buffer at the same time */
2613 [ + - ]: 5 : memset(expected, 0x5a, sizeof(expected));
2614 [ + - ]: 5 : memset(srcbuf, 0x5a, sizeof(expected));
2615 [ + - ]: 5 : memset(dstbuf, 0x0, sizeof(dstbuf));
2616 : 5 : completed = 0;
2617 : 5 : seq = NULL;
2618 : :
2619 : 5 : rc = spdk_accel_get_buf(ioch, sizeof(dstbuf), &accel_buf, &accel_domain, &accel_domain_ctx);
2620 : 5 : CU_ASSERT_EQUAL(rc, 0);
2621 : :
2622 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xfeedbeef;
2623 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2624 [ + - + - ]: 5 : dst_iovs[0].iov_base = accel_buf;
2625 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2626 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2627 : :
2628 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, accel_domain, accel_domain_ctx,
2629 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[0], 0,
+ - + - ]
2630 : : ut_sequence_step_cb, &completed);
2631 : 5 : CU_ASSERT_EQUAL(rc, 0);
2632 : :
2633 [ + - + - : 5 : src_iovs[1].iov_base = accel_buf;
+ - + - ]
2634 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(dstbuf);
+ - + - ]
2635 [ + - + - : 5 : dst_iovs[1].iov_base = (void *)0xbeeffeed;
+ - + - ]
2636 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(dstbuf);
+ - + - ]
2637 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], dstbuf, sizeof(dstbuf), &dst_iovs[1]);
+ - + - ]
2638 : :
2639 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, g_ut_domain, &domctx[1],
+ - + - ]
2640 [ + - + - ]: 1 : &src_iovs[1], 1, accel_domain, accel_domain_ctx, 0,
2641 : : ut_sequence_step_cb, &completed);
2642 : 5 : CU_ASSERT_EQUAL(rc, 0);
2643 : :
2644 : 5 : ut_seq.complete = false;
2645 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2646 : :
2647 : 5 : poll_threads();
2648 : 5 : CU_ASSERT_EQUAL(completed, 2);
2649 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2650 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2651 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(expected, dstbuf, sizeof(dstbuf)), 0);
2652 : 5 : spdk_accel_put_buf(ioch, accel_buf, accel_domain, accel_domain_ctx);
2653 : :
2654 : : /* Check that a sequence with memory domains is correctly executed if buffers are not
2655 : : * immediately available */
2656 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
2657 [ + - ]: 5 : memset(srcbuf, 0xa5, sizeof(srcbuf));
2658 [ + - ]: 5 : memset(dstbuf, 0x0, sizeof(dstbuf));
2659 : 5 : completed = 0;
2660 : 5 : seq = NULL;
2661 : : /* Make sure the buffer pool is empty */
2662 : 5 : accel_ch = spdk_io_channel_get_ctx(ioch);
2663 [ + - + - : 5 : small_cache_count = accel_ch->iobuf.small.cache_count;
+ - + - ]
2664 [ + - ]: 5 : STAILQ_INIT(&small_cache);
2665 [ + - + - : 5 : STAILQ_SWAP(&accel_ch->iobuf.small.cache, &small_cache, spdk_iobuf_buffer);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- + + - +
- + - + -
+ - + - +
- + - + -
- + + - ]
2666 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = 0;
+ - + - ]
2667 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2668 : :
2669 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xdeadbeef;
2670 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2671 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2672 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2673 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2674 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2675 : :
2676 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2677 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2678 : : ut_sequence_step_cb, &completed);
2679 : 5 : CU_ASSERT_EQUAL(rc, 0);
2680 : :
2681 : 5 : ut_seq.complete = false;
2682 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2683 : :
2684 : 5 : poll_threads();
2685 : 5 : CU_ASSERT_EQUAL(completed, 0);
2686 [ + + ]: 5 : CU_ASSERT(!ut_seq.complete);
2687 : :
2688 : : /* Get a buffer and return it to the pool to trigger the sequence to resume. It shouldn't
2689 : : * be able to complete, as it needs two buffers */
2690 [ + - ]: 5 : g_iobuf.small_pool_count = 1;
2691 [ + - ]: 5 : iobuf_buf = spdk_iobuf_get(&accel_ch->iobuf, sizeof(dstbuf), NULL, NULL);
2692 : 5 : CU_ASSERT_PTR_NOT_NULL(iobuf_buf);
2693 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2694 [ + - ]: 5 : spdk_iobuf_put(&accel_ch->iobuf, iobuf_buf, sizeof(dstbuf));
2695 : :
2696 : 5 : CU_ASSERT_EQUAL(completed, 0);
2697 [ + + ]: 5 : CU_ASSERT(!ut_seq.complete);
2698 : :
2699 : : /* Return another buffer, this time the sequence should finish */
2700 [ + - ]: 5 : g_iobuf.small_pool_count = 1;
2701 [ + - ]: 5 : iobuf_buf = spdk_iobuf_get(&accel_ch->iobuf, sizeof(dstbuf), NULL, NULL);
2702 : 5 : CU_ASSERT_PTR_NOT_NULL(iobuf_buf);
2703 [ + - ]: 5 : g_iobuf.small_pool_count = 0;
2704 [ + - ]: 5 : spdk_iobuf_put(&accel_ch->iobuf, iobuf_buf, sizeof(dstbuf));
2705 : :
2706 : 5 : poll_threads();
2707 : 5 : CU_ASSERT_EQUAL(completed, 1);
2708 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2709 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2710 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(expected, dstbuf, sizeof(dstbuf)), 0);
2711 : :
2712 : : /* Return the buffers back to the cache */
2713 [ + + + - : 5 : while (!STAILQ_EMPTY(&accel_ch->iobuf.small.cache)) {
+ - + - +
- - + ]
2714 [ # # # # : 0 : cache_entry = STAILQ_FIRST(&accel_ch->iobuf.small.cache);
# # # # #
# ]
2715 [ # # # # : 0 : STAILQ_REMOVE_HEAD(&accel_ch->iobuf.small.cache, stailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2716 [ # # # # : 0 : STAILQ_INSERT_HEAD(&small_cache, cache_entry, stailq);
# # # # #
# # # #
# ]
2717 : 0 : small_cache_count++;
2718 : : }
2719 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = 0;
+ - + - ]
2720 : :
2721 [ + - ]: 5 : g_iobuf.small_pool_count = 32;
2722 [ + - + - : 5 : STAILQ_SWAP(&accel_ch->iobuf.small.cache, &small_cache, spdk_iobuf_buffer);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
- + + - +
- + - + -
+ - + - +
- + - + -
- + + - ]
2723 [ + - + - : 5 : accel_ch->iobuf.small.cache_count = small_cache_count;
+ - + - ]
2724 : :
2725 : : /* Check error cases, starting with an error from spdk_memory_domain_pull_data() */
2726 : 5 : completed = 0;
2727 : 5 : seq = NULL;
2728 : :
2729 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xdeadbeef;
2730 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2731 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2732 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2733 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2734 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2735 [ + - + - : 5 : domctx[1].pull_submit_status = -E2BIG;
+ - + - ]
2736 : :
2737 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2738 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2739 : : ut_sequence_step_cb, &completed);
2740 : 5 : CU_ASSERT_EQUAL(rc, 0);
2741 : :
2742 : 5 : ut_seq.complete = false;
2743 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2744 : :
2745 : 5 : CU_ASSERT_EQUAL(completed, 1);
2746 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2747 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -E2BIG);
2748 : :
2749 : : /* Check completion error from spdk_memory_domain_pull_data() */
2750 : 5 : completed = 0;
2751 : 5 : seq = NULL;
2752 : :
2753 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xdeadbeef;
2754 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2755 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2756 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2757 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2758 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2759 [ + - + - : 5 : domctx[1].pull_complete_status = -EACCES;
+ - + - ]
2760 : :
2761 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2762 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2763 : : ut_sequence_step_cb, &completed);
2764 : 5 : CU_ASSERT_EQUAL(rc, 0);
2765 : :
2766 : 5 : ut_seq.complete = false;
2767 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2768 : :
2769 : 5 : CU_ASSERT_EQUAL(completed, 1);
2770 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2771 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EACCES);
2772 : :
2773 : : /* Check submission error from spdk_memory_domain_push_data() */
2774 : 5 : completed = 0;
2775 : 5 : seq = NULL;
2776 : :
2777 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xdeadbeef;
2778 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2779 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2780 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2781 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2782 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2783 [ + - + - : 5 : domctx[0].push_submit_status = -EADDRINUSE;
+ - ]
2784 : :
2785 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2786 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2787 : : ut_sequence_step_cb, &completed);
2788 : 5 : CU_ASSERT_EQUAL(rc, 0);
2789 : :
2790 : 5 : ut_seq.complete = false;
2791 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2792 : :
2793 : 5 : CU_ASSERT_EQUAL(completed, 1);
2794 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2795 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EADDRINUSE);
2796 : :
2797 : : /* Check completion error from spdk_memory_domain_push_data() */
2798 : 5 : completed = 0;
2799 : 5 : seq = NULL;
2800 : :
2801 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xdeadbeef;
2802 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2803 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2804 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2805 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2806 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2807 [ + - + - : 5 : domctx[0].push_complete_status = -EADDRNOTAVAIL;
+ - ]
2808 : :
2809 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2810 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2811 : : ut_sequence_step_cb, &completed);
2812 : 5 : CU_ASSERT_EQUAL(rc, 0);
2813 : :
2814 : 5 : ut_seq.complete = false;
2815 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2816 : :
2817 : 5 : CU_ASSERT_EQUAL(completed, 1);
2818 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2819 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EADDRNOTAVAIL);
2820 : :
2821 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2822 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
2823 : 14 : }
2824 : :
2825 : 5 : ut_clear_operations();
2826 : 5 : spdk_put_io_channel(ioch);
2827 : 5 : poll_threads();
2828 : 5 : }
2829 : :
2830 : : static int
2831 : 20 : ut_submit_decompress_memory_domain(struct spdk_io_channel *ch, struct spdk_accel_task *task)
2832 : : {
2833 : 4 : struct ut_domain_ctx *ctx;
2834 : 4 : struct iovec *src_iovs, *dst_iovs;
2835 : 4 : uint32_t src_iovcnt, dst_iovcnt;
2836 : :
2837 [ + - + - : 20 : src_iovs = task->s.iovs;
+ - + - ]
2838 [ + - + - : 20 : dst_iovs = task->d.iovs;
+ - + - ]
2839 [ + - + - : 20 : src_iovcnt = task->s.iovcnt;
+ - + - ]
2840 [ + - + - : 20 : dst_iovcnt = task->d.iovcnt;
+ - + - ]
2841 : :
2842 [ + + + - : 20 : if (task->src_domain != NULL) {
+ + ]
2843 [ + - + - ]: 10 : ctx = task->src_domain_ctx;
2844 [ + + + + : 10 : CU_ASSERT_EQUAL(memcmp(task->s.iovs, &ctx->expected, sizeof(struct iovec)), 0);
+ - + - +
- + - +
- ]
2845 [ + - ]: 10 : src_iovs = &ctx->iov;
2846 : 10 : src_iovcnt = 1;
2847 : 2 : }
2848 : :
2849 [ + + + - : 20 : if (task->dst_domain != NULL) {
+ + ]
2850 [ + - + - ]: 15 : ctx = task->dst_domain_ctx;
2851 [ + + + + : 15 : CU_ASSERT_EQUAL(memcmp(task->d.iovs, &ctx->expected, sizeof(struct iovec)), 0);
+ - + - +
- + - +
- ]
2852 [ + - ]: 15 : dst_iovs = &ctx->iov;
2853 : 15 : dst_iovcnt = 1;
2854 : 3 : }
2855 : :
2856 : 20 : spdk_iovcpy(src_iovs, src_iovcnt, dst_iovs, dst_iovcnt);
2857 : 20 : spdk_accel_task_complete(task, 0);
2858 : :
2859 : 20 : return 0;
2860 : 4 : }
2861 : :
2862 : : static void
2863 : 5 : test_sequence_module_memory_domain(void)
2864 : : {
2865 : 5 : struct spdk_accel_sequence *seq = NULL;
2866 : 1 : struct spdk_io_channel *ioch;
2867 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
2868 : 4 : struct spdk_memory_domain *accel_domain;
2869 : 4 : struct ut_sequence ut_seq;
2870 : 4 : struct ut_domain_ctx domctx[2];
2871 : 4 : struct iovec src_iovs[2], dst_iovs[2];
2872 : 4 : void *buf, *accel_domain_ctx;
2873 : 4 : char srcbuf[4096], dstbuf[4096], tmp[4096], expected[4096];
2874 : 4 : int i, rc, completed;
2875 : :
2876 : 5 : ioch = spdk_accel_get_io_channel();
2877 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
2878 : :
2879 : : /* Override the submit_tasks function */
2880 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
2881 [ + - ]: 5 : g_module.supports_memory_domains = true;
2882 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2883 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
2884 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
2885 : 14 : }
2886 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].submit = ut_submit_decompress_memory_domain;
+ - + - ]
2887 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].submit = sw_accel_submit_tasks;
+ - + - ]
2888 : :
2889 : : /* Check a sequence with both buffers in memory domains */
2890 [ + - ]: 5 : memset(srcbuf, 0xa5, sizeof(srcbuf));
2891 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
2892 [ + - ]: 5 : memset(dstbuf, 0, sizeof(dstbuf));
2893 : 5 : seq = NULL;
2894 : 5 : completed = 0;
2895 : :
2896 [ + - + - ]: 5 : src_iovs[0].iov_base = (void *)0xcafebabe;
2897 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2898 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2899 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2900 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2901 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], srcbuf, sizeof(srcbuf), &src_iovs[0]);
+ - + - ]
2902 : :
2903 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2904 [ + - + - : 1 : &src_iovs[0], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2905 : : ut_sequence_step_cb, &completed);
2906 : 5 : CU_ASSERT_EQUAL(rc, 0);
2907 : :
2908 : 5 : ut_seq.complete = false;
2909 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2910 : :
2911 : 5 : poll_threads();
2912 : :
2913 : 5 : CU_ASSERT_EQUAL(completed, 1);
2914 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2915 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2916 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2917 : :
2918 : : /* Check two operations each with a single buffer in memory domain */
2919 [ + - ]: 5 : memset(srcbuf, 0x5a, sizeof(srcbuf));
2920 [ + - ]: 5 : memset(expected, 0x5a, sizeof(expected));
2921 [ + - ]: 5 : memset(dstbuf, 0, sizeof(dstbuf));
2922 [ + - ]: 5 : memset(tmp, 0, sizeof(tmp));
2923 : 5 : seq = NULL;
2924 : 5 : completed = 0;
2925 : :
2926 [ + - + - ]: 5 : src_iovs[0].iov_base = srcbuf;
2927 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(srcbuf);
+ - ]
2928 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2929 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp);
+ - ]
2930 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], tmp, sizeof(tmp), &dst_iovs[0]);
+ - + - ]
2931 : :
2932 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2933 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
2934 : : ut_sequence_step_cb, &completed);
2935 : 5 : CU_ASSERT_EQUAL(rc, 0);
2936 : :
2937 [ + - + - : 5 : src_iovs[1].iov_base = (void *)0xfeedbeef;
+ - + - ]
2938 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp);
+ - + - ]
2939 [ + - + - : 5 : dst_iovs[1].iov_base = dstbuf;
+ - + - ]
2940 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(dstbuf);
+ - + - ]
2941 [ + - + - : 5 : ut_domain_ctx_init(&domctx[1], tmp, sizeof(tmp), &src_iovs[1]);
+ - + - ]
2942 : :
2943 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
2944 [ + - + - : 1 : &src_iovs[1], 1, g_ut_domain, &domctx[1], 0,
+ - + - ]
2945 : : ut_sequence_step_cb, &completed);
2946 : 5 : CU_ASSERT_EQUAL(rc, 0);
2947 : :
2948 : 5 : ut_seq.complete = false;
2949 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2950 : :
2951 : 5 : poll_threads();
2952 : :
2953 : 5 : CU_ASSERT_EQUAL(completed, 2);
2954 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2955 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2956 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2957 : :
2958 : : /* Check a sequence with an accel buffer and a buffer in a regular memory domain */
2959 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
2960 [ + - ]: 5 : memset(dstbuf, 0, sizeof(dstbuf));
2961 [ + - ]: 5 : memset(tmp, 0, sizeof(tmp));
2962 : 5 : seq = NULL;
2963 : 5 : completed = 0;
2964 : :
2965 : 5 : rc = spdk_accel_get_buf(ioch, 4096, &buf, &accel_domain, &accel_domain_ctx);
2966 : 5 : CU_ASSERT_EQUAL(rc, 0);
2967 : :
2968 : 5 : rc = spdk_accel_append_fill(&seq, ioch, buf, 4096, accel_domain, accel_domain_ctx,
2969 : : 0xa5, 0, ut_sequence_step_cb, &completed);
2970 : 5 : CU_ASSERT_EQUAL(rc, 0);
2971 : :
2972 [ + - + - ]: 5 : src_iovs[0].iov_base = buf;
2973 [ + - + - : 5 : src_iovs[0].iov_len = 4096;
+ - ]
2974 [ + - + - ]: 5 : dst_iovs[0].iov_base = (void *)0xfeedbeef;
2975 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(dstbuf);
+ - ]
2976 [ + - + - : 5 : ut_domain_ctx_init(&domctx[0], dstbuf, sizeof(dstbuf), &dst_iovs[0]);
+ - + - ]
2977 : :
2978 [ + - + - : 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, g_ut_domain, &domctx[0],
+ - + - ]
2979 [ + - + - ]: 1 : &src_iovs[0], 1, accel_domain, accel_domain_ctx, 0,
2980 : : ut_sequence_step_cb, &completed);
2981 : 5 : CU_ASSERT_EQUAL(rc, 0);
2982 : :
2983 : 5 : ut_seq.complete = false;
2984 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
2985 : :
2986 : 5 : poll_threads();
2987 : :
2988 : 5 : CU_ASSERT_EQUAL(completed, 2);
2989 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
2990 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
2991 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(dstbuf, expected, 4096), 0);
2992 : :
2993 : 5 : spdk_accel_put_buf(ioch, buf, accel_domain, accel_domain_ctx);
2994 : :
2995 [ + - ]: 5 : g_module.supports_memory_domains = false;
2996 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
2997 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
2998 : 14 : }
2999 : :
3000 : 5 : ut_clear_operations();
3001 : 5 : spdk_put_io_channel(ioch);
3002 : 5 : poll_threads();
3003 : 5 : }
3004 : :
3005 : : #ifdef SPDK_CONFIG_ISAL_CRYPTO
3006 : : static void
3007 : 5 : ut_encrypt_cb(void *cb_arg, int status)
3008 : : {
3009 : 5 : int *completed = cb_arg;
3010 : :
3011 : 5 : CU_ASSERT_EQUAL(status, 0);
3012 : :
3013 [ + - ]: 5 : *completed = 1;
3014 : 5 : }
3015 : :
3016 : : static void
3017 : 5 : test_sequence_crypto(void)
3018 : : {
3019 : 5 : struct spdk_accel_sequence *seq = NULL;
3020 : 1 : struct spdk_io_channel *ioch;
3021 : 1 : struct spdk_accel_crypto_key *key;
3022 : 5 : struct spdk_accel_crypto_key_create_param key_params = {
3023 : : .cipher = "AES_XTS",
3024 : : .hex_key = "00112233445566778899aabbccddeeff",
3025 : : .hex_key2 = "ffeeddccbbaa99887766554433221100",
3026 : : .key_name = "ut_key",
3027 : : };
3028 : 4 : struct ut_sequence ut_seq;
3029 : 5 : unsigned char buf[4096], encrypted[4096] = {}, data[4096], tmp[3][4096];
3030 : 4 : struct iovec src_iovs[4], dst_iovs[4];
3031 : 5 : int rc, completed = 0;
3032 : 1 : size_t i;
3033 : :
3034 : 5 : ioch = spdk_accel_get_io_channel();
3035 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
3036 : :
3037 : 5 : rc = spdk_accel_crypto_key_create(&key_params);
3038 : 5 : CU_ASSERT_EQUAL(rc, 0);
3039 [ + - ]: 5 : key = spdk_accel_crypto_key_get(key_params.key_name);
3040 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(key != NULL);
3041 : :
3042 [ + + ]: 20485 : for (i = 0; i < sizeof(data); ++i) {
3043 [ + - + - : 20480 : data[i] = (uint8_t)i & 0xff;
+ - ]
3044 : 4096 : }
3045 : :
3046 [ + - + - ]: 5 : dst_iovs[0].iov_base = encrypted;
3047 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(encrypted);
+ - ]
3048 [ + - + - ]: 5 : src_iovs[0].iov_base = data;
3049 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(data);
+ - ]
3050 [ + - + - : 5 : rc = spdk_accel_submit_encrypt(ioch, key, &dst_iovs[0], 1, &src_iovs[0], 1, 0, 4096, 0,
+ - + - ]
3051 : : ut_encrypt_cb, &completed);
3052 : 5 : CU_ASSERT_EQUAL(rc, 0);
3053 : :
3054 [ + + ]: 10 : while (!completed) {
3055 : 5 : poll_threads();
3056 : : }
3057 : :
3058 : : /* Verify that encryption operation in a sequence produces the same result */
3059 : 5 : seq = NULL;
3060 : 5 : completed = 0;
3061 : :
3062 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[0];
+ - + - ]
3063 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3064 [ + - + - ]: 5 : src_iovs[0].iov_base = data;
3065 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(data);
+ - ]
3066 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3067 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3068 : : ut_sequence_step_cb, &completed);
3069 : 5 : CU_ASSERT_EQUAL(rc, 0);
3070 : :
3071 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3072 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3073 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
3074 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[0]);
+ - + - ]
3075 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, key, &dst_iovs[1], 1, NULL, NULL,
3076 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3077 : : ut_sequence_step_cb, &completed);
3078 : 5 : CU_ASSERT_EQUAL(rc, 0);
3079 : :
3080 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
3081 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
3082 [ + - + - : 5 : src_iovs[2].iov_base = tmp[1];
+ - + - +
- + - ]
3083 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[1]);
+ - + - ]
3084 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
3085 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
3086 : : ut_sequence_step_cb, &completed);
3087 : 5 : CU_ASSERT_EQUAL(rc, 0);
3088 : :
3089 : 5 : ut_seq.complete = false;
3090 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3091 : :
3092 : 5 : poll_threads();
3093 : :
3094 : 5 : CU_ASSERT_EQUAL(completed, 3);
3095 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3096 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3097 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, encrypted, sizeof(buf)), 0);
3098 : :
3099 : : /* Check that decryption produces the original buffer */
3100 : 5 : seq = NULL;
3101 : 5 : completed = 0;
3102 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3103 : :
3104 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[0];
+ - + - ]
3105 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3106 [ + - + - ]: 5 : src_iovs[0].iov_base = encrypted;
3107 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(encrypted);
+ - ]
3108 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3109 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3110 : : ut_sequence_step_cb, &completed);
3111 : 5 : CU_ASSERT_EQUAL(rc, 0);
3112 : :
3113 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3114 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3115 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
3116 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[0]);
+ - + - ]
3117 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, key, &dst_iovs[1], 1, NULL, NULL,
3118 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3119 : : ut_sequence_step_cb, &completed);
3120 : 5 : CU_ASSERT_EQUAL(rc, 0);
3121 : :
3122 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
3123 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
3124 [ + - + - : 5 : src_iovs[2].iov_base = tmp[1];
+ - + - +
- + - ]
3125 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[1]);
+ - + - ]
3126 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
3127 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
3128 : : ut_sequence_step_cb, &completed);
3129 : 5 : CU_ASSERT_EQUAL(rc, 0);
3130 : :
3131 : 5 : ut_seq.complete = false;
3132 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3133 : :
3134 : 5 : poll_threads();
3135 : :
3136 : 5 : CU_ASSERT_EQUAL(completed, 3);
3137 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3138 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3139 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, data, sizeof(buf)), 0);
3140 : :
3141 : : /* Check encrypt + decrypt in a single sequence */
3142 : 5 : seq = NULL;
3143 : 5 : completed = 0;
3144 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3145 : :
3146 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[0];
+ - + - ]
3147 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3148 [ + - + - ]: 5 : src_iovs[0].iov_base = data;
3149 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(data);
+ - ]
3150 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3151 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3152 : : ut_sequence_step_cb, &completed);
3153 : 5 : CU_ASSERT_EQUAL(rc, 0);
3154 : :
3155 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3156 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3157 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
3158 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[0]);
+ - + - ]
3159 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, key, &dst_iovs[1], 1, NULL, NULL,
3160 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3161 : : ut_sequence_step_cb, &completed);
3162 : 5 : CU_ASSERT_EQUAL(rc, 0);
3163 : :
3164 : :
3165 [ + - + - : 5 : dst_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
3166 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
3167 [ + - + - : 5 : src_iovs[2].iov_base = tmp[1];
+ - + - +
- + - ]
3168 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[1]);
+ - + - ]
3169 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, key, &dst_iovs[2], 1, NULL, NULL,
3170 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0, 4096, 0,
3171 : : ut_sequence_step_cb, &completed);
3172 : 5 : CU_ASSERT_EQUAL(rc, 0);
3173 : :
3174 [ + - + - : 5 : dst_iovs[3].iov_base = buf;
+ - + - ]
3175 [ + - + - : 5 : dst_iovs[3].iov_len = sizeof(buf);
+ - + - ]
3176 [ + - + - : 5 : src_iovs[3].iov_base = tmp[2];
+ - + - +
- + - ]
3177 [ + - + - : 5 : src_iovs[3].iov_len = sizeof(tmp[2]);
+ - + - ]
3178 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[3], 1, NULL, NULL,
3179 [ + - + - ]: 1 : &src_iovs[3], 1, NULL, NULL, 0,
3180 : : ut_sequence_step_cb, &completed);
3181 : 5 : CU_ASSERT_EQUAL(rc, 0);
3182 : :
3183 : 5 : ut_seq.complete = false;
3184 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3185 : :
3186 : 5 : poll_threads();
3187 : :
3188 : 5 : CU_ASSERT_EQUAL(completed, 4);
3189 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3190 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3191 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, data, sizeof(buf)), 0);
3192 : :
3193 : 5 : rc = spdk_accel_crypto_key_destroy(key);
3194 : 5 : CU_ASSERT_EQUAL(rc, 0);
3195 : 5 : spdk_put_io_channel(ioch);
3196 : 5 : poll_threads();
3197 : 5 : }
3198 : : #endif /* SPDK_CONFIG_ISAL_CRYPTO */
3199 : :
3200 : : static int
3201 : 40 : ut_submit_crypto(struct spdk_io_channel *ch, struct spdk_accel_task *task)
3202 : : {
3203 [ + - + - : 40 : spdk_iovmove(task->s.iovs, task->s.iovcnt, task->d.iovs, task->d.iovcnt);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
3204 : :
3205 : 40 : spdk_accel_task_complete(task, 0);
3206 : :
3207 : 40 : return 0;
3208 : : }
3209 : :
3210 : : struct ut_driver_operation {
3211 : : int complete_status;
3212 : : int submit_status;
3213 : : int count;
3214 : : bool supported;
3215 : : };
3216 : :
3217 : : static struct ut_driver_operation g_drv_operations[SPDK_ACCEL_OPC_LAST];
3218 : : static bool g_ut_driver_async_continue;
3219 : :
3220 : : static void
3221 : 5 : ut_driver_async_continue(void *arg)
3222 : : {
3223 : 5 : struct spdk_accel_sequence *seq = arg;
3224 : :
3225 : 5 : spdk_accel_sequence_continue(seq);
3226 : 5 : }
3227 : :
3228 : : static int
3229 : 65 : ut_driver_execute_sequence(struct spdk_io_channel *ch, struct spdk_accel_sequence *seq)
3230 : : {
3231 : 13 : struct spdk_accel_task *task;
3232 : 13 : struct ut_driver_operation *drv_ops;
3233 : :
3234 [ + + ]: 120 : while ((task = spdk_accel_sequence_first_task(seq)) != NULL) {
3235 [ + - + - : 105 : drv_ops = &g_drv_operations[task->op_code];
+ - + - ]
3236 [ + + + + : 105 : if (!drv_ops->supported) {
+ - + + ]
3237 : 40 : break;
3238 : : }
3239 : :
3240 [ + - + - ]: 65 : drv_ops->count++;
3241 [ + + + - : 65 : if (drv_ops->submit_status != 0) {
+ + ]
3242 [ + - + - ]: 5 : return drv_ops->submit_status;
3243 : : }
3244 : :
3245 [ + + + - : 60 : if (drv_ops->complete_status != 0) {
+ + ]
3246 [ - + - + ]: 5 : spdk_accel_task_complete(task, drv_ops->complete_status);
3247 : 5 : break;
3248 : : }
3249 : :
3250 [ + + + - : 55 : switch (task->op_code) {
- + + ]
3251 : 20 : case SPDK_ACCEL_OPC_DECOMPRESS:
3252 [ + - + - : 25 : spdk_iovmove(task->s.iovs, task->s.iovcnt, task->d.iovs, task->d.iovcnt);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
3253 : 25 : break;
3254 : 24 : case SPDK_ACCEL_OPC_FILL:
3255 [ + - + - : 36 : spdk_iov_memset(task->d.iovs, task->d.iovcnt,
+ - + - +
- + - + -
+ - ]
3256 [ + - + - : 30 : (int)(task->fill_pattern & 0xff));
+ - ]
3257 : 30 : break;
3258 : 0 : default:
3259 : 0 : CU_ASSERT(0 && "unexpected opcode");
3260 : 0 : break;
3261 : : }
3262 : :
3263 : 55 : spdk_accel_task_complete(task, 0);
3264 : : }
3265 : :
3266 [ + + + + ]: 60 : if (g_ut_driver_async_continue) {
3267 : 5 : spdk_thread_send_msg(spdk_get_thread(), ut_driver_async_continue, seq);
3268 : 1 : } else {
3269 : 55 : spdk_accel_sequence_continue(seq);
3270 : : }
3271 : :
3272 : 60 : return 0;
3273 : 13 : }
3274 : :
3275 : : static struct spdk_io_channel *
3276 : 0 : ut_driver_get_io_channel(void)
3277 : : {
3278 : 0 : return (void *)0xdeadbeef;
3279 : : }
3280 : :
3281 : : static struct spdk_accel_driver g_ut_driver = {
3282 : : .name = "ut",
3283 : : .execute_sequence = ut_driver_execute_sequence,
3284 : : .get_io_channel = ut_driver_get_io_channel,
3285 : : };
3286 : :
3287 : 5 : SPDK_ACCEL_DRIVER_REGISTER(ut, &g_ut_driver);
3288 : :
3289 : : static void
3290 : 5 : test_sequence_driver(void)
3291 : : {
3292 : 5 : struct spdk_accel_sequence *seq = NULL;
3293 : 1 : struct spdk_io_channel *ioch;
3294 : 5 : struct spdk_accel_crypto_key key = {};
3295 : 4 : struct ut_sequence ut_seq;
3296 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
3297 : 4 : char buf[4096], tmp[3][4096], expected[4096];
3298 : 4 : struct iovec src_iovs[3], dst_iovs[3];
3299 : 5 : int i, rc, completed = 0;
3300 : :
3301 : 5 : ioch = spdk_accel_get_io_channel();
3302 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
3303 : 5 : rc = spdk_accel_set_driver("ut");
3304 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(rc == 0);
3305 : :
3306 : : /* Override the submit_tasks function */
3307 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
3308 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
3309 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
3310 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
3311 : 14 : }
3312 : : /* Intercept crypto operations, as they should be executed by an accel module */
3313 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].submit = ut_submit_crypto;
+ - + - ]
3314 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].submit = ut_submit_crypto;
+ - + - ]
3315 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3316 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3317 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3318 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3319 : :
3320 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].supported = true;
+ - + - ]
3321 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].supported = true;
+ - + - ]
3322 : :
3323 : : /* First check a sequence that is fully executed using a driver, with the copy at the end
3324 : : * being removed */
3325 : 5 : seq = NULL;
3326 : 5 : completed = 0;
3327 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3328 [ + - + - : 5 : memset(tmp[0], 0, sizeof(tmp[0]));
+ - ]
3329 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
3330 [ + - + - : 5 : memset(&expected[0], 0xa5, 2048);
+ - ]
3331 [ + - + - : 5 : memset(&expected[2048], 0xbe, 2048);
+ - ]
3332 : :
3333 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], 2048, NULL, NULL, 0xa5, 0,
3334 : : ut_sequence_step_cb, &completed);
3335 : 5 : CU_ASSERT_EQUAL(rc, 0);
3336 [ + - + - : 5 : rc = spdk_accel_append_fill(&seq, ioch, &tmp[0][2048], 2048, NULL, NULL, 0xbe, 0,
+ - + - ]
3337 : : ut_sequence_step_cb, &completed);
3338 : 5 : CU_ASSERT_EQUAL(rc, 0);
3339 : :
3340 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3341 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3342 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3343 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3344 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3345 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3346 : : ut_sequence_step_cb, &completed);
3347 : 5 : CU_ASSERT_EQUAL(rc, 0);
3348 : :
3349 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
3350 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
3351 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3352 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3353 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
3354 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
3355 : : ut_sequence_step_cb, &completed);
3356 : 5 : CU_ASSERT_EQUAL(rc, 0);
3357 : :
3358 : 5 : ut_seq.complete = false;
3359 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3360 : :
3361 : 5 : poll_threads();
3362 : :
3363 : 5 : CU_ASSERT_EQUAL(completed, 4);
3364 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3365 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3366 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3367 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 0);
+ - + - ]
3368 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
3369 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 2);
+ - + - ]
3370 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
3371 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3372 : :
3373 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3374 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3375 : :
3376 : : /* Check a sequence when the first two operations are executed by a driver, while the rest
3377 : : * is executed via modules */
3378 : 5 : seq = NULL;
3379 : 5 : completed = 0;
3380 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3381 [ + - + - : 5 : memset(tmp[0], 0, sizeof(tmp[0]));
+ - ]
3382 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
3383 [ + - + - : 5 : memset(tmp[2], 0, sizeof(tmp[2]));
+ - ]
3384 [ + - + - : 5 : memset(&expected[0], 0xfe, 4096);
+ - ]
3385 : :
3386 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], sizeof(tmp[0]), NULL, NULL, 0xfe, 0,
3387 : : ut_sequence_step_cb, &completed);
3388 : 5 : CU_ASSERT_EQUAL(rc, 0);
3389 : :
3390 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3391 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3392 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3393 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3394 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3395 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3396 : : ut_sequence_step_cb, &completed);
3397 : 5 : CU_ASSERT_EQUAL(rc, 0);
3398 : :
3399 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
3400 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
3401 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3402 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3403 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
3404 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3405 : : ut_sequence_step_cb, &completed);
3406 : 5 : CU_ASSERT_EQUAL(rc, 0);
3407 : :
3408 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
3409 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
3410 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
3411 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
3412 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[2], 1, NULL, NULL,
3413 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0, 4096, 0,
3414 : : ut_sequence_step_cb, &completed);
3415 : 5 : CU_ASSERT_EQUAL(rc, 0);
3416 : :
3417 : 5 : ut_seq.complete = false;
3418 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3419 : :
3420 : 5 : poll_threads();
3421 : :
3422 : 5 : CU_ASSERT_EQUAL(completed, 4);
3423 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3424 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3425 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3426 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 0);
+ - + - ]
3427 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3428 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
3429 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3430 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
3431 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3432 : :
3433 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3434 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3435 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3436 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3437 : :
3438 : : /* Check sequence when the first and last operations are executed through modules, while the
3439 : : * ones in the middle are executed by the driver */
3440 : 5 : seq = NULL;
3441 : 5 : completed = 0;
3442 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3443 [ + - + - : 5 : memset(tmp[0], 0xa5, sizeof(tmp[0]));
+ - ]
3444 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
3445 [ + - + - : 5 : memset(tmp[2], 0, sizeof(tmp[2]));
+ - ]
3446 [ + - + - : 5 : memset(&expected[0], 0xfe, 2048);
+ - ]
3447 [ + - + - : 5 : memset(&expected[2048], 0xa5, 2048);
+ - ]
3448 : :
3449 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3450 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3451 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3452 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3453 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[0], 1, NULL, NULL,
3454 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0, 4096, 0,
3455 : : ut_sequence_step_cb, &completed);
3456 : 5 : CU_ASSERT_EQUAL(rc, 0);
3457 : :
3458 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 2048, NULL, NULL, 0xfe, 0,
3459 : : ut_sequence_step_cb, &completed);
3460 : 5 : CU_ASSERT_EQUAL(rc, 0);
3461 : :
3462 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
3463 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
3464 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3465 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3466 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
3467 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
3468 : : ut_sequence_step_cb, &completed);
3469 : 5 : CU_ASSERT_EQUAL(rc, 0);
3470 : :
3471 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
3472 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
3473 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
3474 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
3475 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[2], 1, NULL, NULL,
3476 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0, 4096, 0,
3477 : : ut_sequence_step_cb, &completed);
3478 : 5 : CU_ASSERT_EQUAL(rc, 0);
3479 : :
3480 : 5 : ut_seq.complete = false;
3481 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3482 : :
3483 : 5 : poll_threads();
3484 : :
3485 : 5 : CU_ASSERT_EQUAL(completed, 4);
3486 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3487 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3488 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3489 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 0);
+ - + - ]
3490 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3491 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
3492 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3493 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
3494 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3495 : :
3496 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3497 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3498 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3499 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3500 : :
3501 : : /* Check a sequence with operations executed by: module, driver, module, driver */
3502 : 5 : seq = NULL;
3503 : 5 : completed = 0;
3504 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3505 [ + - + - : 5 : memset(tmp[0], 0x5a, sizeof(tmp[0]));
+ - ]
3506 [ + - + - : 5 : memset(tmp[1], 0, sizeof(tmp[1]));
+ - ]
3507 [ + - + - : 5 : memset(tmp[2], 0, sizeof(tmp[2]));
+ - ]
3508 [ + - + - : 5 : memset(&expected[0], 0xef, 2048);
+ - ]
3509 [ + - + - : 5 : memset(&expected[2048], 0x5a, 2048);
+ - ]
3510 : :
3511 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3512 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3513 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3514 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3515 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[0], 1, NULL, NULL,
3516 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0, 4096, 0,
3517 : : ut_sequence_step_cb, &completed);
3518 : 5 : CU_ASSERT_EQUAL(rc, 0);
3519 : :
3520 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 2048, NULL, NULL, 0xef, 0,
3521 : : ut_sequence_step_cb, &completed);
3522 : 5 : CU_ASSERT_EQUAL(rc, 0);
3523 : :
3524 [ + - + - : 5 : dst_iovs[1].iov_base = tmp[2];
+ - + - +
- + - ]
3525 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(tmp[2]);
+ - + - ]
3526 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3527 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3528 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
3529 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3530 : : ut_sequence_step_cb, &completed);
3531 : 5 : CU_ASSERT_EQUAL(rc, 0);
3532 : :
3533 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
3534 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
3535 [ + - + - : 5 : src_iovs[2].iov_base = tmp[2];
+ - + - +
- + - ]
3536 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[2]);
+ - + - ]
3537 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
3538 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
3539 : : ut_sequence_step_cb, &completed);
3540 : 5 : CU_ASSERT_EQUAL(rc, 0);
3541 : :
3542 : 5 : ut_seq.complete = false;
3543 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3544 : :
3545 : 5 : poll_threads();
3546 : :
3547 : 5 : CU_ASSERT_EQUAL(completed, 4);
3548 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3549 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3550 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3551 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 0);
+ - + - ]
3552 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3553 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
3554 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3555 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
3556 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3557 : :
3558 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3559 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3560 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3561 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3562 : :
3563 : : /* Check that an error returned from driver's execute_sequence() will fail the whole
3564 : : * sequence and any subsequent operations won't be processed */
3565 : 5 : seq = NULL;
3566 : 5 : completed = 0;
3567 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3568 [ + - ]: 5 : memset(expected, 0, sizeof(expected));
3569 [ + - + - : 5 : memset(tmp[0], 0xa5, sizeof(tmp[0]));
+ - ]
3570 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].submit_status = -EPERM;
+ - + - ]
3571 : :
3572 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3573 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3574 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3575 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3576 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[0], 1, NULL, NULL,
3577 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0, 4096, 0,
3578 : : ut_sequence_step_cb, &completed);
3579 : 5 : CU_ASSERT_EQUAL(rc, 0);
3580 : :
3581 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 2048, NULL, NULL, 0xef, 0,
3582 : : ut_sequence_step_cb, &completed);
3583 : 5 : CU_ASSERT_EQUAL(rc, 0);
3584 : :
3585 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
3586 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
3587 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3588 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3589 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
3590 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3591 : : ut_sequence_step_cb, &completed);
3592 : 5 : CU_ASSERT_EQUAL(rc, 0);
3593 : :
3594 : 5 : ut_seq.complete = false;
3595 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3596 : :
3597 : 5 : poll_threads();
3598 : :
3599 : 5 : CU_ASSERT_EQUAL(completed, 3);
3600 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3601 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -EPERM);
3602 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3603 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3604 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 0);
+ - + - ]
3605 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3606 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, 4096), 0);
3607 : :
3608 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3609 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3610 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].submit_status = 0;
+ - + - ]
3611 : :
3612 : : /* Check that a failed task completed by a driver will cause the whole sequence to be failed
3613 : : * and any subsequent operations won't be processed */
3614 : 5 : seq = NULL;
3615 : 5 : completed = 0;
3616 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3617 [ + - ]: 5 : memset(expected, 0, sizeof(expected));
3618 [ + - + - : 5 : memset(tmp[0], 0xa5, sizeof(tmp[0]));
+ - ]
3619 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].complete_status = -ENOENT;
+ - + - ]
3620 : :
3621 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
3622 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
3623 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3624 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3625 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &dst_iovs[0], 1, NULL, NULL,
3626 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0, 4096, 0,
3627 : : ut_sequence_step_cb, &completed);
3628 : 5 : CU_ASSERT_EQUAL(rc, 0);
3629 : :
3630 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[1], 2048, NULL, NULL, 0xef, 0,
3631 : : ut_sequence_step_cb, &completed);
3632 : 5 : CU_ASSERT_EQUAL(rc, 0);
3633 : :
3634 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
3635 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
3636 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
3637 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
3638 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &dst_iovs[1], 1, NULL, NULL,
3639 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0, 4096, 0,
3640 : : ut_sequence_step_cb, &completed);
3641 : 5 : CU_ASSERT_EQUAL(rc, 0);
3642 : :
3643 : 5 : ut_seq.complete = false;
3644 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3645 : :
3646 : 5 : poll_threads();
3647 : :
3648 : 5 : CU_ASSERT_EQUAL(completed, 3);
3649 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3650 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, -ENOENT);
3651 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3652 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3653 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 0);
+ - + - ]
3654 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3655 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3656 : :
3657 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].complete_status = 0;
+ - + - ]
3658 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3659 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3660 : :
3661 : : /* Check asynchronous spdk_accel_sequence_continue() */
3662 : 5 : g_ut_driver_async_continue = true;
3663 : 5 : seq = NULL;
3664 : 5 : completed = 0;
3665 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3666 [ + - + - : 5 : memset(tmp[0], 0, sizeof(tmp[0]));
+ - ]
3667 [ + - + - : 5 : memset(&expected[0], 0xfe, 4096);
+ - ]
3668 : :
3669 [ + - + - ]: 5 : rc = spdk_accel_append_fill(&seq, ioch, tmp[0], sizeof(tmp[0]), NULL, NULL, 0xfe, 0,
3670 : : ut_sequence_step_cb, &completed);
3671 : 5 : CU_ASSERT_EQUAL(rc, 0);
3672 : :
3673 [ + - + - ]: 5 : dst_iovs[0].iov_base = buf;
3674 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(buf);
+ - ]
3675 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3676 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3677 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3678 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3679 : : ut_sequence_step_cb, &completed);
3680 : 5 : CU_ASSERT_EQUAL(rc, 0);
3681 : :
3682 : 5 : ut_seq.complete = false;
3683 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3684 : :
3685 : 5 : poll_threads();
3686 : :
3687 : 5 : CU_ASSERT_EQUAL(completed, 2);
3688 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3689 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3690 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_FILL].count, 0);
+ - + - ]
3691 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 0);
+ - + - ]
3692 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_FILL].count, 1);
+ - + - ]
3693 [ + - + - : 5 : CU_ASSERT_EQUAL(g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
3694 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3695 : :
3696 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_FILL].count = 0;
+ - + - ]
3697 [ + - + - : 5 : g_drv_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
3698 : :
3699 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
3700 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
3701 : 14 : }
3702 : :
3703 : : /* Clear the driver so that other tests won't use it */
3704 : 5 : g_accel_driver = NULL;
3705 [ + - ]: 5 : memset(&g_drv_operations, 0, sizeof(g_drv_operations));
3706 : :
3707 : 5 : ut_clear_operations();
3708 : 5 : spdk_put_io_channel(ioch);
3709 : 5 : poll_threads();
3710 : 5 : }
3711 : :
3712 : : struct ut_saved_iovs {
3713 : : struct iovec src;
3714 : : struct iovec dst;
3715 : : };
3716 : :
3717 : : static struct ut_saved_iovs g_seq_saved_iovs[SPDK_ACCEL_OPC_LAST];
3718 : :
3719 : : static int
3720 : 20 : ut_submit_save_iovs(struct spdk_io_channel *ch, struct spdk_accel_task *task)
3721 : : {
3722 [ + + + - : 20 : SPDK_CU_ASSERT_FATAL(task->s.iovcnt == 1);
+ - + - +
- # # ]
3723 [ + + + - : 20 : SPDK_CU_ASSERT_FATAL(task->d.iovcnt == 1);
+ - + - +
- # # ]
3724 : :
3725 [ + - + - : 20 : g_seq_saved_iovs[task->op_code].src = task->s.iovs[0];
+ - + - +
- + - + -
+ - + - +
- ]
3726 [ + - + - : 20 : g_seq_saved_iovs[task->op_code].dst = task->d.iovs[0];
+ - + - +
- + - + -
+ - + - +
- ]
3727 : :
3728 [ + - + - : 20 : spdk_iovmove(task->s.iovs, task->s.iovcnt, task->d.iovs, task->d.iovcnt);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - ]
3729 : :
3730 : 20 : spdk_accel_task_complete(task, 0);
3731 : :
3732 : 20 : return 0;
3733 : : }
3734 : :
3735 : : static void
3736 : 5 : test_sequence_same_iovs(void)
3737 : : {
3738 : 5 : struct spdk_accel_sequence *seq = NULL;
3739 : 1 : struct spdk_io_channel *ioch;
3740 : 5 : struct spdk_accel_crypto_key key = {};
3741 : 4 : struct ut_sequence ut_seq;
3742 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
3743 : 4 : char buf[4096], tmp[4096], expected[4096];
3744 : 4 : struct iovec iovs[3], expected_siov, expected_diov;
3745 : 4 : struct spdk_memory_domain *domain;
3746 : 4 : void *accel_buf, *domain_ctx;
3747 : 5 : int i, rc, completed = 0;
3748 : :
3749 : 5 : ioch = spdk_accel_get_io_channel();
3750 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
3751 : :
3752 : : /* Override the submit_tasks function */
3753 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
3754 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
3755 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
3756 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
3757 : 14 : }
3758 : : /* Intercept crypto operations, as they should be executed by an accel module */
3759 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].submit = ut_submit_save_iovs;
+ - + - ]
3760 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].submit = ut_submit_save_iovs;
+ - + - ]
3761 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3762 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3763 : :
3764 : : /* Check that it's possible to use the same iovec ptr for different operations */
3765 : 5 : seq = NULL;
3766 : 5 : completed = 0;
3767 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3768 [ + - ]: 5 : memset(expected, 0xa5, sizeof(expected));
3769 : :
3770 [ + - + - ]: 5 : iovs[0].iov_base = expected;
3771 [ + - + - : 5 : iovs[0].iov_len = sizeof(expected);
+ - ]
3772 [ + - + - : 5 : iovs[1].iov_base = tmp;
+ - + - ]
3773 [ + - + - : 5 : iovs[1].iov_len = sizeof(tmp);
+ - + - ]
3774 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &iovs[1], 1, NULL, NULL,
3775 [ + - + - ]: 1 : &iovs[0], 1, NULL, NULL, 0, 4096, 0,
3776 : : ut_sequence_step_cb, &completed);
3777 : 5 : CU_ASSERT_EQUAL(rc, 0);
3778 : : /* Reuse iov[1] as src */
3779 [ + - + - : 5 : iovs[2].iov_base = buf;
+ - + - ]
3780 [ + - + - : 5 : iovs[2].iov_len = sizeof(buf);
+ - + - ]
3781 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &iovs[2], 1, NULL, NULL,
3782 [ + - + - ]: 1 : &iovs[1], 1, NULL, NULL, 0, 4096, 0,
3783 : : ut_sequence_step_cb, &completed);
3784 : 5 : CU_ASSERT_EQUAL(rc, 0);
3785 : :
3786 : 5 : ut_seq.complete = false;
3787 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3788 : :
3789 : 5 : poll_threads();
3790 : :
3791 : 5 : CU_ASSERT_EQUAL(completed, 2);
3792 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3793 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3794 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3795 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
3796 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3797 : 5 : expected_siov.iov_base = expected;
3798 [ + - ]: 5 : expected_siov.iov_len = sizeof(expected);
3799 : 5 : expected_diov.iov_base = tmp;
3800 [ + - ]: 5 : expected_diov.iov_len = sizeof(tmp);
3801 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_ENCRYPT].src,
+ - + - +
- ]
3802 : : &expected_siov, sizeof(expected_siov)), 0);
3803 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_ENCRYPT].dst,
+ - + - +
- ]
3804 : : &expected_diov, sizeof(expected_diov)), 0);
3805 : 5 : expected_siov.iov_base = tmp;
3806 [ + - ]: 5 : expected_siov.iov_len = sizeof(tmp);
3807 : 5 : expected_diov.iov_base = buf;
3808 [ + - ]: 5 : expected_diov.iov_len = sizeof(buf);
3809 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_DECRYPT].src,
+ - + - +
- ]
3810 : : &expected_siov, sizeof(expected_siov)), 0);
3811 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_DECRYPT].dst,
+ - + - +
- ]
3812 : : &expected_diov, sizeof(expected_diov)), 0);
3813 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count = 0;
+ - + - ]
3814 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count = 0;
+ - + - ]
3815 : :
3816 : : /* Check the same with an accel buffer */
3817 : 5 : seq = NULL;
3818 : 5 : completed = 0;
3819 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3820 [ + - ]: 5 : memset(expected, 0x5a, sizeof(expected));
3821 : :
3822 : 5 : rc = spdk_accel_get_buf(ioch, sizeof(buf), &accel_buf, &domain, &domain_ctx);
3823 : 5 : CU_ASSERT_EQUAL(rc, 0);
3824 : :
3825 [ + - + - ]: 5 : iovs[0].iov_base = expected;
3826 [ + - + - : 5 : iovs[0].iov_len = sizeof(expected);
+ - ]
3827 [ + - + - : 5 : iovs[1].iov_base = accel_buf;
+ - + - ]
3828 [ + - + - : 5 : iovs[1].iov_len = sizeof(buf);
+ - + - ]
3829 [ + - + - ]: 6 : rc = spdk_accel_append_encrypt(&seq, ioch, &key, &iovs[1], 1, domain, domain_ctx,
3830 [ + - + - ]: 1 : &iovs[0], 1, NULL, NULL, 0, 4096, 0,
3831 : : ut_sequence_step_cb, &completed);
3832 : 5 : CU_ASSERT_EQUAL(rc, 0);
3833 : : /* Reuse iov[1] as src */
3834 [ + - + - : 5 : iovs[2].iov_base = buf;
+ - + - ]
3835 [ + - + - : 5 : iovs[2].iov_len = sizeof(buf);
+ - + - ]
3836 [ + - + - ]: 6 : rc = spdk_accel_append_decrypt(&seq, ioch, &key, &iovs[2], 1, NULL, NULL,
3837 [ + - + - ]: 1 : &iovs[1], 1, domain, domain_ctx, 0, 4096, 0,
3838 : : ut_sequence_step_cb, &completed);
3839 : 5 : CU_ASSERT_EQUAL(rc, 0);
3840 : :
3841 : 5 : ut_seq.complete = false;
3842 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3843 : :
3844 : 5 : poll_threads();
3845 : :
3846 : 5 : CU_ASSERT_EQUAL(completed, 2);
3847 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3848 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3849 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_ENCRYPT].count, 1);
+ - + - ]
3850 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECRYPT].count, 1);
+ - + - ]
3851 [ + - + - ]: 5 : CU_ASSERT_EQUAL(memcmp(buf, expected, sizeof(buf)), 0);
3852 : 5 : expected_siov.iov_base = expected;
3853 [ + - ]: 5 : expected_siov.iov_len = sizeof(expected);
3854 : 5 : expected_diov.iov_base = buf;
3855 [ + - ]: 5 : expected_diov.iov_len = sizeof(buf);
3856 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_ENCRYPT].src,
+ - + - +
- ]
3857 : : &expected_siov, sizeof(expected_siov)), 0);
3858 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_DECRYPT].dst,
+ - + - +
- ]
3859 : : &expected_diov, sizeof(expected_diov)), 0);
3860 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&g_seq_saved_iovs[SPDK_ACCEL_OPC_ENCRYPT].dst,
+ - + - +
- + - + -
+ - ]
3861 : : &g_seq_saved_iovs[SPDK_ACCEL_OPC_DECRYPT].src,
3862 : : sizeof(struct iovec)), 0);
3863 : 5 : spdk_accel_put_buf(ioch, accel_buf, domain, domain_ctx);
3864 : :
3865 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
3866 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
3867 : 14 : }
3868 : :
3869 : 5 : ut_clear_operations();
3870 : 5 : spdk_put_io_channel(ioch);
3871 : 5 : poll_threads();
3872 : 5 : }
3873 : :
3874 : : static void
3875 : 5 : test_sequence_crc32(void)
3876 : : {
3877 : 5 : struct spdk_accel_sequence *seq = NULL;
3878 : 1 : struct spdk_io_channel *ioch;
3879 : 4 : struct ut_sequence ut_seq;
3880 : 4 : struct accel_module modules[SPDK_ACCEL_OPC_LAST];
3881 : 4 : char buf[4096], tmp[3][4096];
3882 : 4 : struct iovec src_iovs[4], dst_iovs[4];
3883 : 4 : uint32_t crc, crc2;
3884 : 4 : int i, rc, completed;
3885 : :
3886 : 5 : ioch = spdk_accel_get_io_channel();
3887 [ + + # # ]: 5 : SPDK_CU_ASSERT_FATAL(ioch != NULL);
3888 : :
3889 : : /* Override the submit_tasks function */
3890 [ + - ]: 5 : g_module_if.submit_tasks = ut_sequnce_submit_tasks;
3891 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
3892 [ + - + - : 70 : g_seq_operations[i].submit = sw_accel_submit_tasks;
+ - + - ]
3893 [ + - + - : 70 : modules[i] = g_modules_opc[i];
+ - + - ]
3894 [ + - + - ]: 70 : g_modules_opc[i] = g_module;
3895 : 14 : }
3896 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].submit = ut_submit_decompress;
+ - + - ]
3897 : :
3898 : : /* First check the simplest case - single crc32c operation */
3899 : 5 : seq = NULL;
3900 : 5 : completed = 0;
3901 : 5 : crc = 0;
3902 [ + - ]: 5 : memset(buf, 0xa5, sizeof(buf));
3903 : :
3904 [ + - + - ]: 5 : src_iovs[0].iov_base = buf;
3905 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(buf);
+ - ]
3906 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc, &src_iovs[0], 1, NULL, NULL, 0,
3907 : : ut_sequence_step_cb, &completed);
3908 : 5 : CU_ASSERT_EQUAL(rc, 0);
3909 : :
3910 : 5 : ut_seq.complete = false;
3911 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3912 : :
3913 : 5 : poll_threads();
3914 : 5 : CU_ASSERT_EQUAL(completed, 1);
3915 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3916 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3917 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count, 1);
+ - + - ]
3918 : 5 : CU_ASSERT_EQUAL(crc, spdk_crc32c_update(buf, sizeof(buf), ~0u));
3919 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count = 0;
+ - + - ]
3920 : :
3921 : : /* Now check copy+crc - this should remove the copy operation and change the buffer for the
3922 : : * crc operation */
3923 : 5 : seq = NULL;
3924 : 5 : completed = 0;
3925 : 5 : crc = 0;
3926 [ + - ]: 5 : memset(buf, 0x5a, sizeof(buf));
3927 [ + - + - : 5 : memset(&tmp[0], 0, sizeof(tmp[0]));
+ - ]
3928 : :
3929 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[0];
+ - + - ]
3930 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3931 [ + - + - ]: 5 : src_iovs[0].iov_base = buf;
3932 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(buf);
+ - ]
3933 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
3934 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
3935 : : ut_sequence_step_cb, &completed);
3936 : 5 : CU_ASSERT_EQUAL(rc, 0);
3937 : :
3938 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
3939 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[0]);
+ - + - ]
3940 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc, &src_iovs[1], 1, NULL, NULL, 0,
3941 : : ut_sequence_step_cb, &completed);
3942 : 5 : CU_ASSERT_EQUAL(rc, 0);
3943 : :
3944 : 5 : ut_seq.complete = false;
3945 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3946 : :
3947 : 5 : poll_threads();
3948 : 5 : CU_ASSERT_EQUAL(completed, 2);
3949 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3950 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3951 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count, 1);
+ - + - ]
3952 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
3953 : 5 : CU_ASSERT_EQUAL(crc, spdk_crc32c_update(buf, sizeof(buf), ~0u));
3954 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count = 0;
+ - + - ]
3955 : :
3956 : : /* Check crc+copy - this time the copy cannot be removed, because there's no operation
3957 : : * before crc to change the buffer */
3958 : 5 : seq = NULL;
3959 : 5 : completed = 0;
3960 : 5 : crc = 0;
3961 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
3962 [ + - + - : 5 : memset(&tmp[0], 0xa5, sizeof(tmp[0]));
+ - ]
3963 : :
3964 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
3965 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
3966 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc, &src_iovs[0], 1, NULL, NULL, 0,
3967 : : ut_sequence_step_cb, &completed);
3968 : 5 : CU_ASSERT_EQUAL(rc, 0);
3969 : :
3970 [ + - + - : 5 : dst_iovs[1].iov_base = buf;
+ - + - ]
3971 [ + - + - : 5 : dst_iovs[1].iov_len = sizeof(buf);
+ - + - ]
3972 [ + - + - : 5 : src_iovs[1].iov_base = tmp[0];
+ - + - +
- + - ]
3973 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[0]);
+ - + - ]
3974 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[1], 1, NULL, NULL,
3975 [ + - + - ]: 1 : &src_iovs[1], 1, NULL, NULL, 0,
3976 : : ut_sequence_step_cb, &completed);
3977 : 5 : CU_ASSERT_EQUAL(rc, 0);
3978 : :
3979 : 5 : ut_seq.complete = false;
3980 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
3981 : :
3982 : 5 : poll_threads();
3983 : 5 : CU_ASSERT_EQUAL(completed, 2);
3984 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
3985 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
3986 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count, 1);
+ - + - ]
3987 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 1);
+ - ]
3988 [ + - + - ]: 5 : CU_ASSERT_EQUAL(crc, spdk_crc32c_update(tmp[0], sizeof(tmp[0]), ~0u));
3989 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(buf, tmp[0], sizeof(buf)), 0);
+ - + - ]
3990 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count = 0;
+ - + - ]
3991 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
3992 : :
3993 : : /* Check a sequence with an operation at the beginning that can have its buffer changed, two
3994 : : * crc operations and a copy at the end. The copy should be removed and the dst buffer of
3995 : : * the first operation and the src buffer of the crc operations should be changed.
3996 : : */
3997 : 5 : seq = NULL;
3998 : 5 : completed = 0;
3999 : 5 : crc = crc2 = 0;
4000 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
4001 [ + - + - : 5 : memset(&tmp[0], 0x5a, sizeof(tmp[0]));
+ - ]
4002 [ + - + - : 5 : dst_iovs[0].iov_base = tmp[1];
+ - + - ]
4003 [ + - + - : 5 : dst_iovs[0].iov_len = sizeof(tmp[1]);
+ - ]
4004 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
4005 [ + - + - : 5 : src_iovs[0].iov_len = sizeof(tmp[0]);
+ - ]
4006 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
4007 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
4008 : : ut_sequence_step_cb, &completed);
4009 : 5 : CU_ASSERT_EQUAL(rc, 0);
4010 : :
4011 [ + - + - : 5 : src_iovs[1].iov_base = tmp[1];
+ - + - +
- + - ]
4012 [ + - + - : 5 : src_iovs[1].iov_len = sizeof(tmp[1]);
+ - + - ]
4013 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc, &src_iovs[1], 1, NULL, NULL, 0,
4014 : : ut_sequence_step_cb, &completed);
4015 : 5 : CU_ASSERT_EQUAL(rc, 0);
4016 : :
4017 [ + - + - : 5 : src_iovs[2].iov_base = tmp[1];
+ - + - +
- + - ]
4018 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[1]);
+ - + - ]
4019 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc2, &src_iovs[2], 1, NULL, NULL, 0,
4020 : : ut_sequence_step_cb, &completed);
4021 : 5 : CU_ASSERT_EQUAL(rc, 0);
4022 : :
4023 [ + - + - : 5 : dst_iovs[3].iov_base = buf;
+ - + - ]
4024 [ + - + - : 5 : dst_iovs[3].iov_len = sizeof(buf);
+ - + - ]
4025 [ + - + - : 5 : src_iovs[3].iov_base = tmp[1];
+ - + - +
- + - ]
4026 [ + - + - : 5 : src_iovs[3].iov_len = sizeof(tmp[1]);
+ - + - ]
4027 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[3], 1, NULL, NULL,
4028 [ + - + - ]: 1 : &src_iovs[3], 1, NULL, NULL, 0,
4029 : : ut_sequence_step_cb, &completed);
4030 : 5 : CU_ASSERT_EQUAL(rc, 0);
4031 : :
4032 : 5 : ut_seq.complete = false;
4033 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
4034 : :
4035 : 5 : poll_threads();
4036 : 5 : CU_ASSERT_EQUAL(completed, 4);
4037 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
4038 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
4039 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
4040 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count, 2);
+ - + - ]
4041 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 0);
+ - ]
4042 [ + - + - ]: 5 : CU_ASSERT_EQUAL(crc, spdk_crc32c_update(tmp[0], sizeof(tmp[0]), ~0u));
4043 : 5 : CU_ASSERT_EQUAL(crc, crc2);
4044 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(buf, tmp[0], sizeof(buf)), 0);
+ - + - ]
4045 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count = 0;
+ - + - ]
4046 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
4047 : :
4048 : : /* Check that a copy won't be removed if the buffers don't match */
4049 : 5 : seq = NULL;
4050 : 5 : completed = 0;
4051 : 5 : crc = 0;
4052 [ + - ]: 5 : memset(buf, 0, sizeof(buf));
4053 [ + - + - : 5 : memset(&tmp[0], 0xa5, 2048);
+ - ]
4054 [ + - + - : 5 : memset(&tmp[1], 0xfe, sizeof(tmp[1]));
+ - ]
4055 [ + - + - : 5 : memset(&tmp[2], 0xfe, sizeof(tmp[1]));
+ - ]
4056 [ + - + - : 5 : dst_iovs[0].iov_base = &tmp[1][2048];
+ - + - +
- + - ]
4057 [ + - + - : 5 : dst_iovs[0].iov_len = 2048;
+ - ]
4058 [ + - + - : 5 : src_iovs[0].iov_base = tmp[0];
+ - + - ]
4059 [ + - + - : 5 : src_iovs[0].iov_len = 2048;
+ - ]
4060 [ + - + - ]: 6 : rc = spdk_accel_append_decompress(&seq, ioch, &dst_iovs[0], 1, NULL, NULL,
4061 [ + - + - ]: 1 : &src_iovs[0], 1, NULL, NULL, 0,
4062 : : ut_sequence_step_cb, &completed);
4063 : 5 : CU_ASSERT_EQUAL(rc, 0);
4064 : :
4065 [ + - + - : 5 : src_iovs[1].iov_base = &tmp[1][2048];
+ - + - +
- + - + -
+ - ]
4066 [ + - + - : 5 : src_iovs[1].iov_len = 2048;
+ - + - ]
4067 [ + - + - ]: 5 : rc = spdk_accel_append_crc32c(&seq, ioch, &crc, &src_iovs[1], 1, NULL, NULL, 0,
4068 : : ut_sequence_step_cb, &completed);
4069 : 5 : CU_ASSERT_EQUAL(rc, 0);
4070 : :
4071 [ + - + - : 5 : dst_iovs[2].iov_base = buf;
+ - + - ]
4072 [ + - + - : 5 : dst_iovs[2].iov_len = sizeof(buf);
+ - + - ]
4073 [ + - + - : 5 : src_iovs[2].iov_base = tmp[1];
+ - + - +
- + - ]
4074 [ + - + - : 5 : src_iovs[2].iov_len = sizeof(tmp[1]);
+ - + - ]
4075 [ + - + - ]: 6 : rc = spdk_accel_append_copy(&seq, ioch, &dst_iovs[2], 1, NULL, NULL,
4076 [ + - + - ]: 1 : &src_iovs[2], 1, NULL, NULL, 0,
4077 : : ut_sequence_step_cb, &completed);
4078 : 5 : CU_ASSERT_EQUAL(rc, 0);
4079 : :
4080 : 5 : ut_seq.complete = false;
4081 : 5 : spdk_accel_sequence_finish(seq, ut_sequence_complete_cb, &ut_seq);
4082 : :
4083 : 5 : poll_threads();
4084 : 5 : CU_ASSERT_EQUAL(completed, 3);
4085 [ + + ]: 5 : CU_ASSERT(ut_seq.complete);
4086 [ + - ]: 5 : CU_ASSERT_EQUAL(ut_seq.status, 0);
4087 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count, 1);
+ - + - ]
4088 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count, 1);
+ - + - ]
4089 [ + - + - : 5 : CU_ASSERT_EQUAL(g_seq_operations[SPDK_ACCEL_OPC_COPY].count, 1);
+ - ]
4090 [ + - + - ]: 5 : CU_ASSERT_EQUAL(crc, spdk_crc32c_update(tmp[0], 2048, ~0u));
4091 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(buf, tmp[2], 2048), 0);
+ - + - ]
4092 [ + - + - : 5 : CU_ASSERT_EQUAL(memcmp(&buf[2048], tmp[0], 2048), 0);
+ - + - +
- + - ]
4093 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_CRC32C].count = 0;
+ - + - ]
4094 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_DECOMPRESS].count = 0;
+ - + - ]
4095 [ + - + - : 5 : g_seq_operations[SPDK_ACCEL_OPC_COPY].count = 0;
+ - ]
4096 : :
4097 [ + + + - ]: 75 : for (i = 0; i < SPDK_ACCEL_OPC_LAST; ++i) {
4098 [ + - + - : 70 : g_modules_opc[i] = modules[i];
+ - + - ]
4099 : 14 : }
4100 : :
4101 : 5 : ut_clear_operations();
4102 : 5 : spdk_put_io_channel(ioch);
4103 : 5 : poll_threads();
4104 : 5 : }
4105 : :
4106 : : static int
4107 : 5 : test_sequence_setup(void)
4108 : : {
4109 : 1 : int rc;
4110 : :
4111 : 5 : allocate_cores(1);
4112 : 5 : allocate_threads(1);
4113 : 5 : set_thread(0);
4114 : :
4115 : 5 : rc = spdk_iobuf_initialize();
4116 [ - + ]: 5 : if (rc != 0) {
4117 : 0 : CU_ASSERT(false);
4118 : 0 : return -1;
4119 : : }
4120 : :
4121 : 5 : rc = spdk_accel_initialize();
4122 [ + + ]: 5 : if (rc != 0) {
4123 : 0 : CU_ASSERT(false);
4124 : 0 : return -1;
4125 : : }
4126 : :
4127 : 5 : return 0;
4128 : 1 : }
4129 : :
4130 : : static void
4131 : 10 : finish_cb(void *cb_arg)
4132 : : {
4133 : 10 : bool *done = cb_arg;
4134 : :
4135 [ + - ]: 10 : *done = true;
4136 : 10 : }
4137 : :
4138 : : static int
4139 : 5 : test_sequence_cleanup(void)
4140 : : {
4141 : 5 : bool done = false;
4142 : :
4143 : 5 : spdk_accel_finish(finish_cb, &done);
4144 : :
4145 [ + + + + ]: 10 : while (!done) {
4146 : 5 : poll_threads();
4147 : : }
4148 : :
4149 : 5 : done = false;
4150 : 5 : spdk_iobuf_finish(finish_cb, &done);
4151 [ + + - + ]: 5 : while (!done) {
4152 : 0 : poll_threads();
4153 : : }
4154 : :
4155 : 5 : free_threads();
4156 : 5 : free_cores();
4157 : :
4158 : 5 : return 0;
4159 : 1 : }
4160 : :
4161 : : int
4162 : 5 : main(int argc, char **argv)
4163 : : {
4164 : 5 : CU_pSuite suite = NULL, seq_suite;
4165 : 1 : unsigned int num_failures;
4166 : :
4167 : 5 : CU_initialize_registry();
4168 : :
4169 : : /* Sequence tests require accel to be initialized normally, so run them before the other
4170 : : * tests which register accel modules which aren't fully implemented, causing accel
4171 : : * initialization to fail.
4172 : : */
4173 : 5 : seq_suite = CU_add_suite("accel_sequence", test_sequence_setup, test_sequence_cleanup);
4174 : 5 : CU_ADD_TEST(seq_suite, test_sequence_fill_copy);
4175 : 5 : CU_ADD_TEST(seq_suite, test_sequence_abort);
4176 : 5 : CU_ADD_TEST(seq_suite, test_sequence_append_error);
4177 : 5 : CU_ADD_TEST(seq_suite, test_sequence_completion_error);
4178 : : #ifdef SPDK_CONFIG_ISAL /* accel_sw requires isa-l for compression */
4179 : 5 : CU_ADD_TEST(seq_suite, test_sequence_decompress);
4180 : 5 : CU_ADD_TEST(seq_suite, test_sequence_reverse);
4181 : : #endif
4182 : 5 : CU_ADD_TEST(seq_suite, test_sequence_copy_elision);
4183 : 5 : CU_ADD_TEST(seq_suite, test_sequence_accel_buffers);
4184 : 5 : CU_ADD_TEST(seq_suite, test_sequence_memory_domain);
4185 : 5 : CU_ADD_TEST(seq_suite, test_sequence_module_memory_domain);
4186 : : #ifdef SPDK_CONFIG_ISAL_CRYPTO /* accel_sw requires isa-l-crypto for crypto operations */
4187 : 5 : CU_ADD_TEST(seq_suite, test_sequence_crypto);
4188 : : #endif
4189 : 5 : CU_ADD_TEST(seq_suite, test_sequence_driver);
4190 : 5 : CU_ADD_TEST(seq_suite, test_sequence_same_iovs);
4191 : 5 : CU_ADD_TEST(seq_suite, test_sequence_crc32);
4192 : :
4193 : 5 : suite = CU_add_suite("accel", test_setup, test_cleanup);
4194 : 5 : CU_ADD_TEST(suite, test_spdk_accel_task_complete);
4195 : 5 : CU_ADD_TEST(suite, test_get_task);
4196 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_copy);
4197 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_dualcast);
4198 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_compare);
4199 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_fill);
4200 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_crc32c);
4201 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_crc32cv);
4202 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_copy_crc32c);
4203 : 5 : CU_ADD_TEST(suite, test_spdk_accel_submit_xor);
4204 : 5 : CU_ADD_TEST(suite, test_spdk_accel_module_find_by_name);
4205 : 5 : CU_ADD_TEST(suite, test_spdk_accel_module_register);
4206 : :
4207 : 5 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
4208 : 5 : CU_cleanup_registry();
4209 : :
4210 : 6 : return num_failures;
4211 : 1 : }
|