Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2023 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : :
8 : : #include "spdk/accel.h"
9 : : #include "spdk/env.h"
10 : : #include "spdk/log.h"
11 : : #include "spdk/thread.h"
12 : : #include "spdk/event.h"
13 : : #include "spdk/rpc.h"
14 : : #include "spdk/util.h"
15 : : #include "spdk/string.h"
16 : : #include "spdk_internal/cunit.h"
17 : :
18 : : #include "CUnit/Basic.h"
19 : :
20 : : pthread_mutex_t g_test_mutex;
21 : : pthread_cond_t g_test_cond;
22 : :
23 : : #define WORKER_COUNT 2
24 : : #define WORKER_IO 0
25 : : #define WORKER_UT 1
26 : :
27 : : static struct spdk_thread *g_thread[WORKER_COUNT];
28 : : static int g_num_failures = 0;
29 : : static bool g_shutdown = false;
30 : : static bool g_completion_success;
31 : : struct spdk_io_channel *g_channel = NULL;
32 : :
33 : : struct dif_task {
34 : : struct iovec *dst_iovs;
35 : : uint32_t dst_iovcnt;
36 : : struct iovec *src_iovs;
37 : : uint32_t src_iovcnt;
38 : : uint32_t num_blocks; /* used for the DIF related operations */
39 : : struct spdk_dif_ctx dif_ctx;
40 : : struct spdk_dif_error dif_err;
41 : : };
42 : :
43 : : static void
44 : 437 : execute_spdk_function(spdk_msg_fn fn, void *arg)
45 : : {
46 [ + + ]: 437 : pthread_mutex_lock(&g_test_mutex);
47 [ + - + - ]: 437 : spdk_thread_send_msg(g_thread[WORKER_IO], fn, arg);
48 [ + + + + ]: 437 : pthread_cond_wait(&g_test_cond, &g_test_mutex);
49 [ + + ]: 437 : pthread_mutex_unlock(&g_test_mutex);
50 : 437 : }
51 : :
52 : : static void
53 : 437 : wake_ut_thread(void)
54 : : {
55 [ + + ]: 437 : pthread_mutex_lock(&g_test_mutex);
56 [ + + ]: 437 : pthread_cond_signal(&g_test_cond);
57 [ + + ]: 437 : pthread_mutex_unlock(&g_test_mutex);
58 : 437 : }
59 : :
60 : : static void
61 : 19 : exit_io_thread(void *arg)
62 : : {
63 [ + + + - : 19 : assert(spdk_get_thread() == g_thread[WORKER_IO]);
+ - # # ]
64 [ + - + - ]: 19 : spdk_thread_exit(g_thread[WORKER_IO]);
65 : 19 : wake_ut_thread();
66 : 19 : }
67 : :
68 : : #define DATA_PATTERN 0x5A
69 : :
70 : : static int g_xfer_size_bytes = 4096;
71 : : static int g_block_size_bytes = 512;
72 : : static int g_md_size_bytes = 8;
73 : : struct dif_task g_dif_task;
74 : :
75 : : struct accel_dif_request {
76 : : struct spdk_io_channel *channel;
77 : : struct iovec *dst_iovs;
78 : : size_t dst_iovcnt;
79 : : struct iovec *src_iovs;
80 : : size_t src_iovcnt;
81 : : uint32_t num_blocks;
82 : : const struct spdk_dif_ctx *ctx;
83 : : struct spdk_dif_error *err;
84 : : spdk_accel_completion_cb cb_fn;
85 : : void *cb_arg;
86 : : };
87 : :
88 : : static void
89 : 380 : accel_dif_oper_done(void *arg1, int status)
90 : : {
91 [ + + ]: 380 : if (status == 0) {
92 : 266 : g_completion_success = true;
93 : 14 : }
94 : 380 : wake_ut_thread();
95 : 380 : }
96 : :
97 : : static int
98 : 228 : get_dif_verify_alloc_bufs(struct dif_task *task, uint32_t chained_count)
99 : : {
100 : 228 : int src_buff_len = g_xfer_size_bytes;
101 : 228 : uint32_t i = 0;
102 : :
103 [ + + # # ]: 228 : assert(chained_count > 0);
104 [ + - + - ]: 228 : task->src_iovcnt = chained_count;
105 [ + - + - : 228 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
+ - + - ]
106 [ + + + - : 228 : SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);
+ - # # ]
107 : :
108 [ + + + - : 228 : src_buff_len += (g_xfer_size_bytes / g_block_size_bytes) * g_md_size_bytes;
+ - ]
109 : :
110 [ + + + - : 494 : for (i = 0; i < task->src_iovcnt; i++) {
+ + ]
111 [ + - + - : 266 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
+ - + - +
- ]
112 [ + + + - : 266 : SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
113 : :
114 [ + + + - : 266 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
+ - + - +
- + - ]
115 [ + - + - : 266 : task->src_iovs[i].iov_len = src_buff_len;
+ - + - +
- ]
116 : 14 : }
117 : :
118 [ + + + - : 228 : task->num_blocks = (g_xfer_size_bytes * chained_count) / g_block_size_bytes;
+ - ]
119 : :
120 : 228 : return 0;
121 : : }
122 : :
123 : : static int
124 : 228 : get_dif_verify_free_bufs(struct dif_task *task)
125 : : {
126 : 228 : uint32_t i = 0;
127 : :
128 [ + + + - : 228 : SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);
+ - # # ]
129 [ + + + - : 494 : for (i = 0; i < task->src_iovcnt; i++) {
+ + ]
130 [ + + + - : 266 : SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
131 [ + - + - : 266 : spdk_dma_free(task->src_iovs[i].iov_base);
+ - + - +
- ]
132 : 14 : }
133 [ + - + - ]: 228 : free(task->src_iovs);
134 : :
135 : 228 : return 0;
136 : : }
137 : :
138 : : static int
139 : 152 : get_dif_generate_copy_alloc_bufs(struct dif_task *task, uint32_t chained_count)
140 : : {
141 : 152 : int src_buff_len = g_xfer_size_bytes;
142 : : uint32_t transfer_size_with_md;
143 : 152 : uint32_t i = 0;
144 : :
145 [ + + # # ]: 152 : assert(chained_count > 0);
146 [ + - + - ]: 152 : task->dst_iovcnt = chained_count;
147 [ + - + - : 152 : task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
+ - + - ]
148 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->dst_iovs != NULL);
+ - # # ]
149 : :
150 [ + + + - : 152 : task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
+ - ]
151 : :
152 : : /* Add bytes for each block for metadata */
153 [ + - + - ]: 152 : transfer_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
154 : :
155 [ + + + - : 304 : for (i = 0; i < task->dst_iovcnt; i++) {
+ + ]
156 [ + - + - : 152 : task->dst_iovs[i].iov_base = spdk_dma_zmalloc(transfer_size_with_md, 0, NULL);
+ - + - +
- ]
157 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->dst_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
158 : :
159 [ + + + - : 152 : memset(task->dst_iovs[i].iov_base, 0, transfer_size_with_md);
+ - + - +
- + - ]
160 [ + - + - : 152 : task->dst_iovs[i].iov_len = transfer_size_with_md;
+ - + - +
- ]
161 : 8 : }
162 : :
163 [ + - + - ]: 152 : task->src_iovcnt = chained_count;
164 [ + - + - : 152 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
+ - + - ]
165 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);
+ - # # ]
166 : :
167 [ + + + - : 304 : for (i = 0; i < task->src_iovcnt; i++) {
+ + ]
168 [ + - + - : 152 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
+ - + - +
- ]
169 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
170 : :
171 [ + + + - : 152 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
+ - + - +
- + - ]
172 [ + - + - : 152 : task->src_iovs[i].iov_len = src_buff_len;
+ - + - +
- ]
173 : 8 : }
174 : :
175 : 152 : return 0;
176 : : }
177 : :
178 : : static int
179 : 152 : get_dif_generate_copy_free_bufs(struct dif_task *task)
180 : : {
181 : 152 : uint32_t i = 0;
182 : :
183 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->dst_iovs != NULL);
+ - # # ]
184 [ + + + - : 304 : for (i = 0; i < task->dst_iovcnt; i++) {
+ + ]
185 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->dst_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
186 [ + - + - : 152 : spdk_dma_free(task->dst_iovs[i].iov_base);
+ - + - +
- ]
187 : 8 : }
188 [ + - + - ]: 152 : free(task->dst_iovs);
189 : :
190 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->src_iovs != NULL);
+ - # # ]
191 [ + + + - : 304 : for (i = 0; i < task->src_iovcnt; i++) {
+ + ]
192 [ + + + - : 152 : SPDK_CU_ASSERT_FATAL(task->src_iovs[i].iov_base != NULL);
+ - + - +
- + - #
# ]
193 [ + - + - : 152 : spdk_dma_free(task->src_iovs[i].iov_base);
+ - + - +
- ]
194 : 8 : }
195 [ + - + - ]: 152 : free(task->src_iovs);
196 : :
197 : 152 : return 0;
198 : : }
199 : :
200 : : static void
201 : 228 : accel_dif_verify_test(void *arg)
202 : : {
203 : : int rc;
204 : 228 : struct accel_dif_request *req = arg;
205 : :
206 : 228 : g_completion_success = false;
207 [ + - + - : 240 : rc = spdk_accel_submit_dif_verify(req->channel, req->src_iovs, req->src_iovcnt,
+ - + - +
- + - ]
208 [ + - + - : 12 : req->num_blocks, req->ctx, req->err,
+ - + - +
- + - ]
209 [ + - + - : 12 : req->cb_fn, req->cb_arg);
+ - + - ]
210 [ + + ]: 228 : if (rc) {
211 : 0 : wake_ut_thread();
212 : 0 : }
213 : 228 : }
214 : :
215 : : static void
216 : 152 : accel_dif_generate_copy_test(void *arg)
217 : : {
218 : : int rc;
219 : 152 : struct accel_dif_request *req = arg;
220 : :
221 : 152 : g_completion_success = false;
222 [ + - + - : 160 : rc = spdk_accel_submit_dif_generate_copy(req->channel, req->dst_iovs, req->dst_iovcnt,
+ - + - +
- + - ]
223 [ + - + - : 8 : req->src_iovs, req->src_iovcnt, req->num_blocks, req->ctx,
+ - + - +
- + - + -
+ - ]
224 [ + - + - : 8 : req->cb_fn, req->cb_arg);
+ - + - ]
225 [ + + ]: 152 : if (rc) {
226 : 0 : wake_ut_thread();
227 : 0 : }
228 : 152 : }
229 : :
230 : : static void
231 : 57 : accel_dif_verify_op_dif_generated_do_check(uint32_t dif_flags)
232 : : {
233 : 24 : struct spdk_dif_ctx_init_ext_opts dif_opts;
234 : 24 : struct accel_dif_request req;
235 : 57 : struct dif_task *task = &g_dif_task;
236 : : int rc;
237 : :
238 : 57 : rc = get_dif_verify_alloc_bufs(task, 1);
239 : 57 : CU_ASSERT(rc == 0);
240 : :
241 : 57 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
242 [ + - ]: 57 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
243 : :
244 [ + - ]: 60 : rc = spdk_dif_ctx_init(&task->dif_ctx,
245 [ + - ]: 57 : g_block_size_bytes + g_md_size_bytes,
246 : 3 : g_md_size_bytes, true, true,
247 : : SPDK_DIF_TYPE1,
248 [ + - ]: 3 : SPDK_DIF_FLAGS_GUARD_CHECK |
249 [ + - ]: 3 : SPDK_DIF_FLAGS_APPTAG_CHECK |
250 [ + - ]: 3 : SPDK_DIF_FLAGS_REFTAG_CHECK,
251 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
252 : 57 : CU_ASSERT(rc == 0);
253 : :
254 [ + - + - : 57 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
255 : 57 : CU_ASSERT(rc == 0);
256 : :
257 [ + - ]: 57 : rc = spdk_dif_ctx_init(&task->dif_ctx,
258 [ + - ]: 57 : g_block_size_bytes + g_md_size_bytes,
259 : 3 : g_md_size_bytes, true, true,
260 : : SPDK_DIF_TYPE1,
261 : 3 : dif_flags,
262 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
263 : 57 : CU_ASSERT(rc == 0);
264 : :
265 : 57 : req.channel = g_channel;
266 [ + - + - : 57 : req.src_iovs = task->src_iovs;
+ - ]
267 [ + - + - : 57 : req.src_iovcnt = task->src_iovcnt;
+ - ]
268 [ + - + - : 57 : req.num_blocks = task->num_blocks;
+ - ]
269 [ + - + - ]: 57 : req.ctx = &task->dif_ctx;
270 [ + - + - ]: 57 : req.err = &task->dif_err;
271 [ + - ]: 57 : req.cb_fn = accel_dif_oper_done;
272 [ + - ]: 57 : req.cb_arg = task;
273 : :
274 : 57 : execute_spdk_function(accel_dif_verify_test, &req);
275 [ + + ]: 57 : CU_ASSERT_EQUAL(g_completion_success, true);
276 : :
277 : 57 : get_dif_verify_free_bufs(task);
278 : 57 : }
279 : :
280 : : static void
281 : 19 : accel_dif_verify_op_dif_generated_guard_check(void)
282 : : {
283 [ + - ]: 19 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
284 : 19 : }
285 : :
286 : : static void
287 : 19 : accel_dif_verify_op_dif_generated_apptag_check(void)
288 : : {
289 [ + - ]: 19 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
290 : 19 : }
291 : :
292 : : static void
293 : 19 : accel_dif_verify_op_dif_generated_reftag_check(void)
294 : : {
295 [ + - ]: 19 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
296 : 19 : }
297 : :
298 : : static void
299 : 57 : accel_dif_verify_op_dif_not_generated_do_check(uint32_t dif_flags)
300 : : {
301 : 24 : struct spdk_dif_ctx_init_ext_opts dif_opts;
302 : 24 : struct accel_dif_request req;
303 : 57 : struct dif_task *task = &g_dif_task;
304 : 24 : struct spdk_dif_error dif_err;
305 : : int rc;
306 : :
307 : 57 : rc = get_dif_verify_alloc_bufs(task, 1);
308 : 57 : CU_ASSERT(rc == 0);
309 : :
310 : 57 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
311 [ + - ]: 57 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
312 : :
313 [ + - ]: 57 : rc = spdk_dif_ctx_init(&task->dif_ctx,
314 [ + - ]: 57 : g_block_size_bytes + g_md_size_bytes,
315 : 3 : g_md_size_bytes, true, true,
316 : : SPDK_DIF_TYPE1,
317 : 3 : dif_flags,
318 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
319 : 57 : CU_ASSERT(rc == 0);
320 : :
321 : 57 : req.channel = g_channel;
322 [ + - + - : 57 : req.src_iovs = task->src_iovs;
+ - ]
323 [ + - + - : 57 : req.src_iovcnt = task->src_iovcnt;
+ - ]
324 [ + - + - : 57 : req.num_blocks = task->num_blocks;
+ - ]
325 [ + - + - ]: 57 : req.ctx = &task->dif_ctx;
326 [ + - + - ]: 57 : req.err = &task->dif_err;
327 [ + - ]: 57 : req.cb_fn = accel_dif_oper_done;
328 [ + - ]: 57 : req.cb_arg = task;
329 : :
330 : 57 : execute_spdk_function(accel_dif_verify_test, &req);
331 [ + + ]: 57 : CU_ASSERT_EQUAL(g_completion_success, false);
332 : :
333 [ + - + - : 57 : rc = spdk_dif_verify(task->src_iovs, task->src_iovcnt, task->num_blocks,
+ - + - +
- + - ]
334 [ + - ]: 57 : &task->dif_ctx, &dif_err);
335 : 57 : CU_ASSERT(rc != 0);
336 : :
337 : 57 : get_dif_verify_free_bufs(task);
338 : 57 : }
339 : :
340 : : static void
341 : 19 : accel_dif_verify_op_dif_not_generated_guard_check(void)
342 : : {
343 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
344 : 19 : }
345 : :
346 : : static void
347 : 19 : accel_dif_verify_op_dif_not_generated_apptag_check(void)
348 : : {
349 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
350 : 19 : }
351 : :
352 : : static void
353 : 19 : accel_dif_verify_op_dif_not_generated_reftag_check(void)
354 : : {
355 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
356 : 19 : }
357 : :
358 : : static void
359 : 19 : accel_dif_verify_op_apptag_correct_apptag_check(void)
360 : : {
361 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
362 : 8 : struct accel_dif_request req;
363 : 19 : struct dif_task *task = &g_dif_task;
364 : : int rc;
365 : :
366 : 19 : rc = get_dif_verify_alloc_bufs(task, 1);
367 : 19 : CU_ASSERT(rc == 0);
368 : :
369 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
370 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
371 : :
372 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
373 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
374 : 1 : g_md_size_bytes, true, true,
375 : : SPDK_DIF_TYPE1,
376 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK,
377 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
378 : 19 : CU_ASSERT(rc == 0);
379 : :
380 [ + - + - : 19 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
381 : 19 : CU_ASSERT(rc == 0);
382 : :
383 : 19 : req.channel = g_channel;
384 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
385 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
386 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
387 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
388 [ + - + - ]: 19 : req.err = &task->dif_err;
389 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
390 [ + - ]: 19 : req.cb_arg = task;
391 : :
392 : 19 : execute_spdk_function(accel_dif_verify_test, &req);
393 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
394 : :
395 : 19 : get_dif_verify_free_bufs(task);
396 : 19 : }
397 : :
398 : : static void
399 : 19 : accel_dif_verify_op_apptag_incorrect_apptag_check(void)
400 : : {
401 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
402 : 8 : struct accel_dif_request req;
403 : 19 : struct dif_task *task = &g_dif_task;
404 : : int rc;
405 : :
406 : 19 : rc = get_dif_verify_alloc_bufs(task, 1);
407 : 19 : CU_ASSERT(rc == 0);
408 : :
409 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
410 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
411 : :
412 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
413 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
414 : 1 : g_md_size_bytes, true, true,
415 : : SPDK_DIF_TYPE1,
416 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK,
417 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
418 : 19 : CU_ASSERT(rc == 0);
419 : :
420 [ + - + - : 19 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
421 : 19 : CU_ASSERT(rc == 0);
422 : :
423 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
424 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
425 : 1 : g_md_size_bytes, true, true,
426 : : SPDK_DIF_TYPE1,
427 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK,
428 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
429 : 19 : CU_ASSERT(rc == 0);
430 : :
431 : 19 : req.channel = g_channel;
432 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
433 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
434 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
435 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
436 [ + - + - ]: 19 : req.err = &task->dif_err;
437 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
438 [ + - ]: 19 : req.cb_arg = task;
439 : :
440 : 19 : execute_spdk_function(accel_dif_verify_test, &req);
441 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, false);
442 : :
443 : 19 : get_dif_verify_free_bufs(task);
444 : 19 : }
445 : :
446 : : static void
447 : 38 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)
448 : : {
449 : 16 : struct spdk_dif_ctx_init_ext_opts dif_opts;
450 : 16 : struct accel_dif_request req;
451 : 38 : struct dif_task *task = &g_dif_task;
452 : : int rc;
453 : :
454 : 38 : rc = get_dif_verify_alloc_bufs(task, 1);
455 : 38 : CU_ASSERT(rc == 0);
456 : :
457 : 38 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
458 [ + - ]: 38 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
459 : :
460 : : /* For set 'Application Tag F Detect' (Source DIF Flags)
461 : : * When all bits of the Application Tag field of the source Data Integrity Field
462 : : * are equal to 1, the Application Tag check is not done and the Guard field and
463 : : * Reference Tag field are ignored. */
464 [ + - ]: 40 : rc = spdk_dif_ctx_init(&task->dif_ctx,
465 [ + - ]: 38 : g_block_size_bytes + g_md_size_bytes,
466 : 2 : g_md_size_bytes, true, true,
467 : : SPDK_DIF_TYPE1,
468 [ + - ]: 2 : SPDK_DIF_FLAGS_GUARD_CHECK |
469 [ + - ]: 2 : SPDK_DIF_FLAGS_APPTAG_CHECK |
470 [ + - ]: 2 : SPDK_DIF_FLAGS_REFTAG_CHECK,
471 : : 10, 0xFFFF, 0xFFFF, 0, 0, &dif_opts);
472 : 38 : CU_ASSERT(rc == 0);
473 : :
474 [ + - + - : 38 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
475 : 38 : CU_ASSERT(rc == 0);
476 : :
477 [ + - ]: 38 : rc = spdk_dif_ctx_init(&task->dif_ctx,
478 [ + - ]: 38 : g_block_size_bytes + g_md_size_bytes,
479 : 2 : g_md_size_bytes, true, true,
480 : : SPDK_DIF_TYPE1,
481 : 2 : dif_flags,
482 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
483 : 38 : CU_ASSERT(rc == 0);
484 : :
485 : 38 : req.channel = g_channel;
486 [ + - + - : 38 : req.src_iovs = task->src_iovs;
+ - ]
487 [ + - + - : 38 : req.src_iovcnt = task->src_iovcnt;
+ - ]
488 [ + - + - : 38 : req.num_blocks = task->num_blocks;
+ - ]
489 [ + - + - ]: 38 : req.ctx = &task->dif_ctx;
490 [ + - + - ]: 38 : req.err = &task->dif_err;
491 [ + - ]: 38 : req.cb_fn = accel_dif_oper_done;
492 [ + - ]: 38 : req.cb_arg = task;
493 : :
494 : 38 : execute_spdk_function(accel_dif_verify_test, &req);
495 [ + + ]: 38 : CU_ASSERT_EQUAL(g_completion_success, true);
496 : :
497 : 38 : get_dif_verify_free_bufs(task);
498 : 38 : }
499 : :
500 : : static void
501 : 19 : accel_dif_verify_op_apptag_incorrect_no_apptag_check(void)
502 : : {
503 [ + - ]: 19 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);
504 : 19 : }
505 : :
506 : : static void
507 : 19 : accel_dif_verify_op_reftag_incorrect_reftag_ignore(void)
508 : : {
509 [ + - ]: 19 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);
510 : 19 : }
511 : :
512 : : static void
513 : 19 : accel_dif_verify_op_reftag_init_correct_reftag_check(void)
514 : : {
515 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
516 : 8 : struct accel_dif_request req;
517 : 19 : struct dif_task *task = &g_dif_task;
518 : : int rc;
519 : :
520 : 19 : rc = get_dif_verify_alloc_bufs(task, 2);
521 : 19 : CU_ASSERT(rc == 0);
522 : :
523 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
524 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
525 : :
526 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
527 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
528 : 1 : g_md_size_bytes, true, true,
529 : : SPDK_DIF_TYPE1,
530 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
531 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
532 : 19 : CU_ASSERT(rc == 0);
533 : :
534 [ + - + - : 19 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
535 : 19 : CU_ASSERT(rc == 0);
536 : :
537 : 19 : req.channel = g_channel;
538 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
539 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
540 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
541 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
542 [ + - + - ]: 19 : req.err = &task->dif_err;
543 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
544 [ + - ]: 19 : req.cb_arg = task;
545 : :
546 : 19 : execute_spdk_function(accel_dif_verify_test, &req);
547 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
548 : :
549 : 19 : get_dif_verify_free_bufs(task);
550 : 19 : }
551 : :
552 : : static void
553 : 19 : accel_dif_verify_op_reftag_init_incorrect_reftag_check(void)
554 : : {
555 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
556 : 8 : struct accel_dif_request req;
557 : 19 : struct dif_task *task = &g_dif_task;
558 : : int rc;
559 : :
560 : 19 : rc = get_dif_verify_alloc_bufs(task, 2);
561 : 19 : CU_ASSERT(rc == 0);
562 : :
563 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
564 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
565 : :
566 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
567 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
568 : 1 : g_md_size_bytes, true, true,
569 : : SPDK_DIF_TYPE1,
570 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
571 : : 16, 0xFFFF, 20, 0, 0, &dif_opts);
572 : 19 : CU_ASSERT(rc == 0);
573 : :
574 [ + - + - : 19 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
+ - + - +
- + - +
- ]
575 : 19 : CU_ASSERT(rc == 0);
576 : :
577 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
578 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
579 : 1 : g_md_size_bytes, true, true,
580 : : SPDK_DIF_TYPE1,
581 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
582 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
583 : 19 : CU_ASSERT(rc == 0);
584 : :
585 : 19 : req.channel = g_channel;
586 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
587 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
588 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
589 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
590 [ + - + - ]: 19 : req.err = &task->dif_err;
591 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
592 [ + - ]: 19 : req.cb_arg = task;
593 : :
594 : 19 : execute_spdk_function(accel_dif_verify_test, &req);
595 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, false);
596 : :
597 : 19 : get_dif_verify_free_bufs(task);
598 : 19 : }
599 : :
600 : : static void
601 : 57 : accel_dif_generate_copy_op_dif_generated_do_check(uint32_t dif_flags)
602 : : {
603 : 24 : struct spdk_dif_ctx_init_ext_opts dif_opts;
604 : 24 : struct accel_dif_request req;
605 : 57 : struct dif_task *task = &g_dif_task;
606 : 24 : struct spdk_dif_error err_blk;
607 : : int rc;
608 : :
609 : 57 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
610 : 57 : CU_ASSERT(rc == 0);
611 : :
612 : 57 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
613 [ + - ]: 57 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
614 : :
615 [ + - ]: 60 : rc = spdk_dif_ctx_init(&task->dif_ctx,
616 [ + - ]: 57 : g_block_size_bytes + g_md_size_bytes,
617 : 3 : g_md_size_bytes, true, true,
618 : : SPDK_DIF_TYPE1,
619 [ + - ]: 3 : SPDK_DIF_FLAGS_GUARD_CHECK |
620 [ + - ]: 3 : SPDK_DIF_FLAGS_APPTAG_CHECK |
621 [ + - ]: 3 : SPDK_DIF_FLAGS_REFTAG_CHECK,
622 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
623 : 57 : CU_ASSERT(rc == 0);
624 : :
625 : 57 : req.channel = g_channel;
626 [ + - + - : 57 : req.dst_iovs = task->dst_iovs;
+ - ]
627 [ + - + - : 57 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
628 [ + - + - : 57 : req.src_iovs = task->src_iovs;
+ - ]
629 [ + - + - : 57 : req.src_iovcnt = task->src_iovcnt;
+ - ]
630 [ + - + - : 57 : req.num_blocks = task->num_blocks;
+ - ]
631 [ + - + - ]: 57 : req.ctx = &task->dif_ctx;
632 [ + - + - ]: 57 : req.err = &task->dif_err;
633 [ + - ]: 57 : req.cb_fn = accel_dif_oper_done;
634 [ + - ]: 57 : req.cb_arg = task;
635 : :
636 : 57 : execute_spdk_function(accel_dif_generate_copy_test, &req);
637 [ + + ]: 57 : CU_ASSERT_EQUAL(g_completion_success, true);
638 : :
639 [ + - ]: 57 : rc = spdk_dif_ctx_init(&task->dif_ctx,
640 [ + - ]: 57 : g_block_size_bytes + g_md_size_bytes,
641 : 3 : g_md_size_bytes, true, true,
642 : : SPDK_DIF_TYPE1,
643 : 3 : dif_flags,
644 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
645 : 57 : CU_ASSERT(rc == 0);
646 : :
647 [ + - + - : 57 : rc = spdk_dif_verify(req.dst_iovs, req.dst_iovcnt, req.num_blocks,
+ - ]
648 [ + - ]: 57 : &task->dif_ctx, &err_blk);
649 : 57 : CU_ASSERT(rc == 0);
650 : :
651 : 57 : get_dif_generate_copy_free_bufs(task);
652 : 57 : }
653 : :
654 : : static void
655 : 19 : accel_dif_generate_copy_op_dif_generated_guard_check(void)
656 : : {
657 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
658 : 19 : }
659 : :
660 : : static void
661 : 19 : accel_dif_generate_copy_op_dif_generated_apptag_check(void)
662 : : {
663 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
664 : 19 : }
665 : :
666 : : static void
667 : 19 : accel_dif_generate_copy_op_dif_generated_reftag_check(void)
668 : : {
669 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
670 : 19 : }
671 : :
672 : : static void
673 : 19 : accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set(void)
674 : : {
675 : 19 : const char *module_name = NULL;
676 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
677 : 8 : struct accel_dif_request req;
678 : 19 : struct dif_task *task = &g_dif_task;
679 : : int rc;
680 : :
681 : 19 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
682 : 19 : CU_ASSERT(rc == 0);
683 : :
684 : 19 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
685 : 19 : CU_ASSERT(rc == 0);
686 : :
687 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
688 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
689 : :
690 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
691 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
692 : 1 : g_md_size_bytes, true, true,
693 : : SPDK_DIF_TYPE1,
694 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK |
695 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
696 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
697 : 19 : CU_ASSERT(rc == 0);
698 : :
699 : 19 : req.channel = g_channel;
700 [ + - + - : 19 : req.dst_iovs = task->dst_iovs;
+ - ]
701 [ + - + - : 19 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
702 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
703 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
704 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
705 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
706 [ + - + - ]: 19 : req.err = &task->dif_err;
707 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
708 [ + - ]: 19 : req.cb_arg = task;
709 : :
710 : 19 : execute_spdk_function(accel_dif_generate_copy_test, &req);
711 : :
712 : : /* Intel DSA does not allow for selective DIF fields generation */
713 [ + + + + : 19 : if (!strcmp(module_name, "dsa")) {
+ - ]
714 [ # # ]: 0 : CU_ASSERT_EQUAL(g_completion_success, false);
715 [ + + + - : 19 : } else if (!strcmp(module_name, "software")) {
- + ]
716 [ - + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
717 : 1 : } else {
718 : 0 : CU_ASSERT(false);
719 : : }
720 : :
721 : 19 : get_dif_generate_copy_free_bufs(task);
722 : 19 : }
723 : :
724 : : static void
725 : 19 : accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set(void)
726 : : {
727 : 19 : const char *module_name = NULL;
728 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
729 : 8 : struct accel_dif_request req;
730 : 19 : struct dif_task *task = &g_dif_task;
731 : : int rc;
732 : :
733 : 19 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
734 : 19 : CU_ASSERT(rc == 0);
735 : :
736 : 19 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
737 : 19 : CU_ASSERT(rc == 0);
738 : :
739 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
740 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
741 : :
742 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
743 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
744 : 1 : g_md_size_bytes, true, true,
745 : : SPDK_DIF_TYPE1,
746 [ + - ]: 1 : SPDK_DIF_FLAGS_GUARD_CHECK |
747 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
748 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
749 : 19 : CU_ASSERT(rc == 0);
750 : :
751 : 19 : req.channel = g_channel;
752 [ + - + - : 19 : req.dst_iovs = task->dst_iovs;
+ - ]
753 [ + - + - : 19 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
754 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
755 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
756 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
757 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
758 [ + - + - ]: 19 : req.err = &task->dif_err;
759 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
760 [ + - ]: 19 : req.cb_arg = task;
761 : :
762 : 19 : execute_spdk_function(accel_dif_generate_copy_test, &req);
763 : :
764 : : /* Intel DSA does not allow for selective DIF fields generation */
765 [ + + + + : 19 : if (!strcmp(module_name, "dsa")) {
+ - ]
766 [ # # ]: 0 : CU_ASSERT_EQUAL(g_completion_success, false);
767 [ + + + - : 19 : } else if (!strcmp(module_name, "software")) {
- + ]
768 [ - + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
769 : 1 : } else {
770 : 0 : CU_ASSERT(false);
771 : : }
772 : :
773 : 19 : get_dif_generate_copy_free_bufs(task);
774 : 19 : }
775 : :
776 : : static void
777 : 19 : accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set(void)
778 : : {
779 : 19 : const char *module_name = NULL;
780 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
781 : 8 : struct accel_dif_request req;
782 : 19 : struct dif_task *task = &g_dif_task;
783 : : int rc;
784 : :
785 : 19 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
786 : 19 : CU_ASSERT(rc == 0);
787 : :
788 : 19 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
789 : 19 : CU_ASSERT(rc == 0);
790 : :
791 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
792 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
793 : :
794 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
795 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
796 : 1 : g_md_size_bytes, true, true,
797 : : SPDK_DIF_TYPE1,
798 [ + - ]: 1 : SPDK_DIF_FLAGS_GUARD_CHECK |
799 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK,
800 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
801 : 19 : CU_ASSERT(rc == 0);
802 : :
803 : 19 : req.channel = g_channel;
804 [ + - + - : 19 : req.dst_iovs = task->dst_iovs;
+ - ]
805 [ + - + - : 19 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
806 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
807 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
808 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
809 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
810 [ + - + - ]: 19 : req.err = &task->dif_err;
811 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
812 [ + - ]: 19 : req.cb_arg = task;
813 : :
814 : 19 : execute_spdk_function(accel_dif_generate_copy_test, &req);
815 : :
816 : : /* Intel DSA does not allow for selective DIF fields generation */
817 [ + + + + : 19 : if (!strcmp(module_name, "dsa")) {
+ - ]
818 [ # # ]: 0 : CU_ASSERT_EQUAL(g_completion_success, false);
819 [ + + + - : 19 : } else if (!strcmp(module_name, "software")) {
- + ]
820 [ - + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
821 : 1 : } else {
822 : 0 : CU_ASSERT(false);
823 : : }
824 : :
825 : 19 : get_dif_generate_copy_free_bufs(task);
826 : 19 : }
827 : :
828 : : static void
829 : 19 : accel_dif_generate_copy_op_iovecs_len_validate(void)
830 : : {
831 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
832 : 8 : struct accel_dif_request req;
833 : 19 : struct dif_task *task = &g_dif_task;
834 : : int rc;
835 : :
836 : 19 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
837 : 19 : CU_ASSERT(rc == 0);
838 : :
839 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
840 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
841 : :
842 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
843 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
844 : 1 : g_md_size_bytes, true, true,
845 : : SPDK_DIF_TYPE1,
846 [ + - ]: 1 : SPDK_DIF_FLAGS_GUARD_CHECK |
847 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK |
848 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
849 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
850 : 19 : CU_ASSERT(rc == 0);
851 : :
852 : 19 : req.channel = g_channel;
853 [ + - + - : 19 : req.dst_iovs = task->dst_iovs;
+ - ]
854 : : /* Make iov_len param incorrect */
855 [ + - + - : 19 : req.dst_iovs->iov_len += 16;
+ - ]
856 [ + - + - : 19 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
857 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
858 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
859 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
860 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
861 [ + - + - ]: 19 : req.err = &task->dif_err;
862 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
863 [ + - ]: 19 : req.cb_arg = task;
864 : :
865 : 19 : execute_spdk_function(accel_dif_generate_copy_test, &req);
866 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, false);
867 : :
868 : 19 : get_dif_generate_copy_free_bufs(task);
869 : 19 : }
870 : :
871 : : static void
872 : 19 : accel_dif_generate_copy_op_buf_align_validate(void)
873 : : {
874 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
875 : 8 : struct accel_dif_request req;
876 : 19 : struct dif_task *task = &g_dif_task;
877 : : int rc;
878 : :
879 : 19 : rc = get_dif_generate_copy_alloc_bufs(task, 1);
880 : 19 : CU_ASSERT(rc == 0);
881 : :
882 : 19 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
883 [ + - ]: 19 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
884 : :
885 [ + - ]: 20 : rc = spdk_dif_ctx_init(&task->dif_ctx,
886 [ + - ]: 19 : g_block_size_bytes + g_md_size_bytes,
887 : 1 : g_md_size_bytes, true, true,
888 : : SPDK_DIF_TYPE1,
889 [ + - ]: 1 : SPDK_DIF_FLAGS_GUARD_CHECK |
890 [ + - ]: 1 : SPDK_DIF_FLAGS_APPTAG_CHECK |
891 [ + - ]: 1 : SPDK_DIF_FLAGS_REFTAG_CHECK,
892 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
893 : 19 : CU_ASSERT(rc == 0);
894 : :
895 : 19 : req.channel = g_channel;
896 [ + - + - : 19 : req.dst_iovs = task->dst_iovs;
+ - ]
897 [ + - + - : 19 : req.dst_iovcnt = task->dst_iovcnt;
+ - ]
898 [ + - + - : 19 : req.src_iovs = task->src_iovs;
+ - ]
899 [ + - + - : 19 : req.src_iovcnt = task->src_iovcnt;
+ - ]
900 [ + - + - : 19 : req.num_blocks = task->num_blocks;
+ - ]
901 [ + - + - ]: 19 : req.ctx = &task->dif_ctx;
902 [ + - + - ]: 19 : req.err = &task->dif_err;
903 [ + - ]: 19 : req.cb_fn = accel_dif_oper_done;
904 [ + - ]: 19 : req.cb_arg = task;
905 : :
906 : 19 : execute_spdk_function(accel_dif_generate_copy_test, &req);
907 [ + + ]: 19 : CU_ASSERT_EQUAL(g_completion_success, true);
908 : :
909 : 19 : get_dif_generate_copy_free_bufs(task);
910 : 19 : }
911 : :
912 : : static void
913 : 19 : _stop_init_thread(void *arg)
914 : : {
915 : 19 : unsigned num_failures = g_num_failures;
916 : :
917 : 19 : g_num_failures = 0;
918 : :
919 [ + + + - : 19 : assert(spdk_get_thread() == g_thread[WORKER_UT]);
+ - + - #
# ]
920 [ + + # # ]: 19 : assert(spdk_thread_is_app_thread(NULL));
921 : 19 : execute_spdk_function(exit_io_thread, NULL);
922 : 19 : spdk_app_stop(num_failures);
923 : 19 : }
924 : :
925 : : static void
926 : 19 : stop_init_thread(unsigned num_failures, struct spdk_jsonrpc_request *request)
927 : : {
928 : 19 : g_num_failures = num_failures;
929 : :
930 [ + - + - : 19 : spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, request);
+ - ]
931 : 19 : }
932 : :
933 : : static int
934 : 19 : setup_accel_tests(void)
935 : : {
936 : 19 : unsigned rc = 0;
937 : 19 : CU_pSuite suite = NULL;
938 : :
939 : 19 : suite = CU_add_suite("accel_dif", NULL, NULL);
940 [ + + ]: 19 : if (suite == NULL) {
941 : 0 : CU_cleanup_registry();
942 : 0 : rc = CU_get_error();
943 : 0 : return -rc;
944 : : }
945 : :
946 [ + - ]: 20 : if (CU_add_test(suite, "verify: DIF generated, GUARD check",
947 [ + - ]: 19 : accel_dif_verify_op_dif_generated_guard_check) == NULL ||
948 : 19 : CU_add_test(suite, "verify: DIF generated, APPTAG check",
949 [ + - ]: 19 : accel_dif_verify_op_dif_generated_apptag_check) == NULL ||
950 : 19 : CU_add_test(suite, "verify: DIF generated, REFTAG check",
951 [ + - ]: 19 : accel_dif_verify_op_dif_generated_reftag_check) == NULL ||
952 : :
953 : 19 : CU_add_test(suite, "verify: DIF not generated, GUARD check",
954 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_guard_check) == NULL ||
955 : 19 : CU_add_test(suite, "verify: DIF not generated, APPTAG check",
956 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_apptag_check) == NULL ||
957 : 19 : CU_add_test(suite, "verify: DIF not generated, REFTAG check",
958 [ + - ]: 19 : accel_dif_verify_op_dif_not_generated_reftag_check) == NULL ||
959 : :
960 : 19 : CU_add_test(suite, "verify: APPTAG correct, APPTAG check",
961 [ + - ]: 19 : accel_dif_verify_op_apptag_correct_apptag_check) == NULL ||
962 : 19 : CU_add_test(suite, "verify: APPTAG incorrect, APPTAG check",
963 [ + - ]: 19 : accel_dif_verify_op_apptag_incorrect_apptag_check) == NULL ||
964 : 19 : CU_add_test(suite, "verify: APPTAG incorrect, no APPTAG check",
965 [ + - ]: 19 : accel_dif_verify_op_apptag_incorrect_no_apptag_check) == NULL ||
966 : 19 : CU_add_test(suite, "verify: REFTAG incorrect, REFTAG ignore",
967 [ + - ]: 19 : accel_dif_verify_op_reftag_incorrect_reftag_ignore) == NULL ||
968 : :
969 : 19 : CU_add_test(suite, "verify: REFTAG_INIT correct, REFTAG check",
970 [ + - ]: 19 : accel_dif_verify_op_reftag_init_correct_reftag_check) == NULL ||
971 : 19 : CU_add_test(suite, "verify: REFTAG_INIT incorrect, REFTAG check",
972 [ + - ]: 19 : accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL ||
973 : :
974 : 19 : CU_add_test(suite, "generate copy: DIF generated, GUARD check",
975 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_guard_check) == NULL ||
976 : 19 : CU_add_test(suite, "generate copy: DIF generated, APTTAG check",
977 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_apptag_check) == NULL ||
978 : 19 : CU_add_test(suite, "generate copy: DIF generated, REFTAG check",
979 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_reftag_check) == NULL ||
980 : :
981 : 19 : CU_add_test(suite, "generate copy: DIF generated, no GUARD check flag set",
982 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set) == NULL ||
983 : 19 : CU_add_test(suite, "generate copy: DIF generated, no APPTAG check flag set",
984 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set) == NULL ||
985 : 19 : CU_add_test(suite, "generate copy: DIF generated, no REFTAG check flag set",
986 [ + - ]: 19 : accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set) == NULL ||
987 : :
988 : 19 : CU_add_test(suite, "generate copy: iovecs-len validate",
989 [ + + ]: 19 : accel_dif_generate_copy_op_iovecs_len_validate) == NULL ||
990 : 19 : CU_add_test(suite, "generate copy: buffer alignment validate",
991 : 1 : accel_dif_generate_copy_op_buf_align_validate) == NULL) {
992 : 0 : CU_cleanup_registry();
993 : 0 : rc = CU_get_error();
994 : 0 : return -rc;
995 : : }
996 : 19 : return 0;
997 : 1 : }
998 : :
999 : : static void
1000 : 19 : get_io_channel(void *arg)
1001 : : {
1002 : 19 : g_channel = spdk_accel_get_io_channel();
1003 [ + + # # ]: 19 : assert(g_channel);
1004 : 19 : wake_ut_thread();
1005 : 19 : }
1006 : :
1007 : : static void
1008 : 19 : put_io_channel(void *arg)
1009 : : {
1010 [ + + # # ]: 19 : assert(g_channel);
1011 : 19 : spdk_put_io_channel(g_channel);
1012 : 19 : wake_ut_thread();
1013 : 19 : }
1014 : :
1015 : : static void
1016 : 19 : run_accel_test_thread(void *arg)
1017 : : {
1018 : 19 : struct spdk_jsonrpc_request *request = arg;
1019 : 19 : int rc = 0;
1020 : :
1021 : 19 : execute_spdk_function(get_io_channel, NULL);
1022 [ - + ]: 19 : if (g_channel == NULL) {
1023 [ # # # # ]: 0 : fprintf(stderr, "Unable to get an accel channel\n");
1024 : 0 : goto ret;
1025 : : }
1026 : :
1027 [ - + ]: 19 : if (CU_initialize_registry() != CUE_SUCCESS) {
1028 : : /* CUnit error, probably won't recover */
1029 : 0 : rc = CU_get_error();
1030 [ # # ]: 0 : rc = -rc;
1031 : 0 : goto ret;
1032 : : }
1033 : :
1034 : 19 : rc = setup_accel_tests();
1035 [ + + ]: 19 : if (rc < 0) {
1036 : : /* CUnit error, probably won't recover */
1037 [ # # ]: 0 : rc = -rc;
1038 : 0 : goto ret;
1039 : : }
1040 : 19 : CU_basic_set_mode(CU_BRM_VERBOSE);
1041 : 19 : CU_basic_run_tests();
1042 : 19 : rc = CU_get_number_of_failures();
1043 : 19 : CU_cleanup_registry();
1044 : :
1045 : 18 : ret:
1046 [ + + ]: 19 : if (g_channel != NULL) {
1047 : 19 : execute_spdk_function(put_io_channel, NULL);
1048 : 1 : }
1049 : 19 : stop_init_thread(rc, request);
1050 : 19 : }
1051 : :
1052 : : static void
1053 : 19 : accel_dif_test_main(void *arg1)
1054 : : {
1055 : 19 : struct spdk_cpuset tmpmask = {};
1056 : : uint32_t i;
1057 : :
1058 [ + + ]: 19 : pthread_mutex_init(&g_test_mutex, NULL);
1059 [ + + ]: 19 : pthread_cond_init(&g_test_cond, NULL);
1060 : :
1061 : : /* This test runs specifically on at least two cores.
1062 : : * g_thread[WORKER_UT] is the app_thread on main core from event framework.
1063 : : * Next one is only for the tests and should always be on separate CPU cores. */
1064 [ - + ]: 19 : if (spdk_env_get_core_count() < 3) {
1065 : 0 : spdk_app_stop(-1);
1066 : 0 : return;
1067 : : }
1068 : :
1069 [ + + ]: 76 : SPDK_ENV_FOREACH_CORE(i) {
1070 [ + + ]: 57 : if (i == spdk_env_get_current_core()) {
1071 [ + - + - : 19 : g_thread[WORKER_UT] = spdk_get_thread();
+ - ]
1072 : 19 : continue;
1073 : : }
1074 : 38 : spdk_cpuset_zero(&tmpmask);
1075 : 38 : spdk_cpuset_set_cpu(&tmpmask, i, true);
1076 [ + + + - : 38 : if (g_thread[WORKER_IO] == NULL) {
+ + ]
1077 [ + - + - ]: 19 : g_thread[WORKER_IO] = spdk_thread_create("io_thread", &tmpmask);
1078 : 1 : }
1079 : :
1080 : 2 : }
1081 : :
1082 [ + - + - : 19 : spdk_thread_send_msg(g_thread[WORKER_UT], run_accel_test_thread, NULL);
+ - ]
1083 : 1 : }
1084 : :
1085 : : static void
1086 : 0 : accel_dif_usage(void)
1087 : : {
1088 : 0 : }
1089 : :
1090 : : static int
1091 : 0 : accel_dif_parse_arg(int ch, char *arg)
1092 : : {
1093 : 0 : return 0;
1094 : : }
1095 : :
1096 : : static void
1097 : 0 : spdk_dif_shutdown_cb(void)
1098 : : {
1099 : 0 : g_shutdown = true;
1100 [ # # # # : 0 : spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, NULL);
# # ]
1101 : 0 : }
1102 : :
1103 : : int
1104 : 19 : main(int argc, char **argv)
1105 : : {
1106 : 19 : struct spdk_app_opts opts = {};
1107 : 8 : char reactor_mask[8];
1108 : : int rc;
1109 : :
1110 : 19 : spdk_app_opts_init(&opts, sizeof(opts));
1111 : 19 : opts.name = "DIF";
1112 [ - + + - ]: 19 : snprintf(reactor_mask, sizeof(reactor_mask), "0x%x", (1 << (SPDK_COUNTOF(g_thread) + 1)) - 1);
1113 : 19 : opts.reactor_mask = reactor_mask;
1114 : 19 : opts.shutdown_cb = spdk_dif_shutdown_cb;
1115 : :
1116 [ - + - + ]: 20 : if ((rc = spdk_app_parse_args(argc, argv, &opts, "", NULL,
1117 : 1 : accel_dif_parse_arg, accel_dif_usage)) !=
1118 : : SPDK_APP_PARSE_ARGS_SUCCESS) {
1119 : 0 : return rc;
1120 : : }
1121 : :
1122 : 19 : rc = spdk_app_start(&opts, accel_dif_test_main, NULL);
1123 : 19 : spdk_app_fini();
1124 : :
1125 : 19 : return rc;
1126 : 1 : }
|