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