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 : : struct iovec *aux_iovs;
39 : : uint32_t aux_iovcnt;
40 : : struct iovec md_iov;
41 : : uint32_t num_blocks; /* used for the DIF related operations */
42 : : struct spdk_dif_ctx dif_ctx;
43 : : struct spdk_dif_error dif_err;
44 : : };
45 : :
46 : : static void
47 : 0 : execute_spdk_function(spdk_msg_fn fn, void *arg)
48 : : {
49 : 0 : pthread_mutex_lock(&g_test_mutex);
50 : 0 : spdk_thread_send_msg(g_thread[WORKER_IO], fn, arg);
51 : 0 : pthread_cond_wait(&g_test_cond, &g_test_mutex);
52 : 0 : pthread_mutex_unlock(&g_test_mutex);
53 : 0 : }
54 : :
55 : : static void
56 : 0 : wake_ut_thread(void)
57 : : {
58 : 0 : pthread_mutex_lock(&g_test_mutex);
59 : 0 : pthread_cond_signal(&g_test_cond);
60 : 0 : pthread_mutex_unlock(&g_test_mutex);
61 : 0 : }
62 : :
63 : : static void
64 : 0 : exit_io_thread(void *arg)
65 : : {
66 [ # # ]: 0 : assert(spdk_get_thread() == g_thread[WORKER_IO]);
67 : 0 : spdk_thread_exit(g_thread[WORKER_IO]);
68 : 0 : wake_ut_thread();
69 : 0 : }
70 : :
71 : : #define DATA_PATTERN 0x5A
72 : :
73 : : static int g_xfer_size_bytes = 4096;
74 : : static int g_block_size_bytes = 512;
75 : : static int g_md_size_bytes = 8;
76 : : struct dif_task g_dif_task;
77 : :
78 : : struct accel_dif_request {
79 : : struct spdk_accel_sequence *sequence;
80 : : struct spdk_io_channel *channel;
81 : : struct iovec *dst_iovs;
82 : : size_t dst_iovcnt;
83 : : struct iovec *src_iovs;
84 : : size_t src_iovcnt;
85 : : struct iovec *aux_iovs;
86 : : size_t aux_iovcnt;
87 : : struct iovec *md_iov;
88 : : uint32_t num_blocks;
89 : : const struct spdk_dif_ctx *ctx;
90 : : struct spdk_dif_error *err;
91 : : spdk_accel_completion_cb cb_fn;
92 : : void *cb_arg;
93 : : };
94 : :
95 : : static void
96 : 0 : accel_dif_oper_done(void *arg1, int status)
97 : : {
98 [ # # ]: 0 : if (status == 0) {
99 : 0 : g_completion_success = true;
100 : 0 : }
101 : 0 : wake_ut_thread();
102 : 0 : }
103 : :
104 : : static bool
105 : 0 : accel_dif_error_validate(const uint32_t dif_flags,
106 : : const struct spdk_dif_error *err)
107 : : {
108 [ # # ]: 0 : if (dif_flags & SPDK_DIF_FLAGS_GUARD_CHECK) {
109 : 0 : return err->err_type == SPDK_DIF_GUARD_ERROR;
110 [ # # ]: 0 : } else if (dif_flags & SPDK_DIF_FLAGS_APPTAG_CHECK) {
111 : 0 : return err->err_type == SPDK_DIF_APPTAG_ERROR;
112 [ # # ]: 0 : } else if (dif_flags & SPDK_DIF_FLAGS_REFTAG_CHECK) {
113 : 0 : return err->err_type == SPDK_DIF_REFTAG_ERROR;
114 : : }
115 : :
116 : 0 : return false;
117 : 0 : }
118 : :
119 : : static int
120 : 0 : alloc_dif_verify_bufs(struct dif_task *task, uint32_t chained_count)
121 : : {
122 : 0 : int src_buff_len = g_xfer_size_bytes;
123 : 0 : uint32_t i = 0;
124 : :
125 [ # # ]: 0 : assert(chained_count > 0);
126 : 0 : task->src_iovcnt = chained_count;
127 : 0 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
128 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs == NULL)) {
129 : 0 : return -ENOMEM;
130 : : }
131 : :
132 : 0 : src_buff_len += (g_xfer_size_bytes / g_block_size_bytes) * g_md_size_bytes;
133 : :
134 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
135 : 0 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
136 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
137 : 0 : return -ENOMEM;
138 : : }
139 : :
140 : 0 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
141 : 0 : task->src_iovs[i].iov_len = src_buff_len;
142 : 0 : }
143 : :
144 : 0 : task->num_blocks = (g_xfer_size_bytes * chained_count) / g_block_size_bytes;
145 : :
146 : 0 : return 0;
147 : 0 : }
148 : :
149 : : static int
150 : 0 : alloc_dix_bufs(struct dif_task *task, uint32_t chained_count)
151 : : {
152 : 0 : int src_buff_len = g_xfer_size_bytes, md_buff_len;
153 : 0 : uint32_t i = 0;
154 : :
155 [ # # ]: 0 : assert(chained_count > 0);
156 : 0 : task->src_iovcnt = chained_count;
157 : 0 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
158 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs == NULL)) {
159 : 0 : return -ENOMEM;
160 : : }
161 : :
162 : 0 : md_buff_len = (g_xfer_size_bytes / g_block_size_bytes) * g_md_size_bytes * chained_count;
163 : :
164 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
165 : 0 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
166 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
167 : 0 : return -ENOMEM;
168 : : }
169 : :
170 : 0 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
171 : 0 : task->src_iovs[i].iov_len = src_buff_len;
172 : 0 : }
173 : :
174 : 0 : task->md_iov.iov_base = spdk_dma_zmalloc(md_buff_len, 0, NULL);
175 [ # # ]: 0 : if (spdk_unlikely(task->md_iov.iov_base == NULL)) {
176 : 0 : return -ENOMEM;
177 : : }
178 : :
179 : 0 : task->md_iov.iov_len = md_buff_len;
180 : 0 : task->num_blocks = (g_xfer_size_bytes * chained_count) / g_block_size_bytes;
181 : :
182 : 0 : return 0;
183 : 0 : }
184 : :
185 : : static void
186 : 0 : free_dif_verify_bufs(struct dif_task *task)
187 : : {
188 : 0 : uint32_t i = 0;
189 : :
190 [ # # ]: 0 : if (task->src_iovs != NULL) {
191 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
192 [ # # ]: 0 : if (task->src_iovs[i].iov_base != NULL) {
193 : 0 : spdk_dma_free(task->src_iovs[i].iov_base);
194 : 0 : }
195 : 0 : }
196 : 0 : free(task->src_iovs);
197 : 0 : }
198 : 0 : }
199 : :
200 : : static void
201 : 0 : free_dix_bufs(struct dif_task *task)
202 : : {
203 : 0 : uint32_t i = 0;
204 : :
205 [ # # ]: 0 : if (task->src_iovs != NULL) {
206 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
207 [ # # ]: 0 : if (task->src_iovs[i].iov_base != NULL) {
208 : 0 : spdk_dma_free(task->src_iovs[i].iov_base);
209 : 0 : }
210 : 0 : }
211 : 0 : free(task->src_iovs);
212 : 0 : }
213 : :
214 [ # # ]: 0 : if (task->md_iov.iov_base != NULL) {
215 : 0 : spdk_dma_free(task->md_iov.iov_base);
216 : 0 : }
217 : 0 : }
218 : :
219 : : static int
220 : 0 : alloc_dif_verify_copy_bufs(struct dif_task *task, uint32_t chained_count)
221 : : {
222 : 0 : int dst_buff_len = g_xfer_size_bytes;
223 : : uint32_t data_size_with_md;
224 : 0 : uint32_t i = 0;
225 : :
226 [ # # ]: 0 : assert(chained_count > 0);
227 : 0 : task->src_iovcnt = chained_count;
228 : 0 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
229 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs == NULL)) {
230 : 0 : return -ENOMEM;
231 : : }
232 : :
233 : 0 : task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
234 : :
235 : : /* Add bytes for each block for metadata */
236 : 0 : data_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
237 : :
238 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
239 : 0 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(data_size_with_md, 0, NULL);
240 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
241 : 0 : return -ENOMEM;
242 : : }
243 : :
244 : 0 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, data_size_with_md);
245 : 0 : task->src_iovs[i].iov_len = data_size_with_md;
246 : 0 : }
247 : :
248 : 0 : task->dst_iovcnt = chained_count;
249 : 0 : task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
250 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs == NULL)) {
251 : 0 : return -ENOMEM;
252 : : }
253 : :
254 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
255 : 0 : task->dst_iovs[i].iov_base = spdk_dma_zmalloc(dst_buff_len, 0, NULL);
256 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs[i].iov_base == NULL)) {
257 : 0 : return -ENOMEM;
258 : : }
259 : :
260 : 0 : memset(task->dst_iovs[i].iov_base, 0, dst_buff_len);
261 : 0 : task->dst_iovs[i].iov_len = dst_buff_len;
262 : 0 : }
263 : :
264 : 0 : return 0;
265 : 0 : }
266 : :
267 : : static void
268 : 0 : free_dif_verify_copy_bufs(struct dif_task *task)
269 : : {
270 : 0 : uint32_t i = 0;
271 : :
272 [ # # ]: 0 : if (task->dst_iovs != NULL) {
273 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
274 [ # # ]: 0 : if (task->dst_iovs[i].iov_base != NULL) {
275 : 0 : spdk_dma_free(task->dst_iovs[i].iov_base);
276 : 0 : }
277 : 0 : }
278 : 0 : free(task->dst_iovs);
279 : 0 : }
280 : :
281 [ # # ]: 0 : if (task->src_iovs != NULL) {
282 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
283 [ # # ]: 0 : if (task->src_iovs[i].iov_base != NULL) {
284 : 0 : spdk_dma_free(task->src_iovs[i].iov_base);
285 : 0 : }
286 : 0 : }
287 : 0 : free(task->src_iovs);
288 : 0 : }
289 : 0 : }
290 : :
291 : : static int
292 : 0 : alloc_dif_generate_copy_bufs(struct dif_task *task, uint32_t chained_count)
293 : : {
294 : 0 : int src_buff_len = g_xfer_size_bytes;
295 : : uint32_t transfer_size_with_md;
296 : 0 : uint32_t i = 0;
297 : :
298 [ # # ]: 0 : assert(chained_count > 0);
299 : 0 : task->dst_iovcnt = chained_count;
300 : 0 : task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
301 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs == NULL)) {
302 : 0 : return -ENOMEM;
303 : : }
304 : :
305 : 0 : task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
306 : :
307 : : /* Add bytes for each block for metadata */
308 : 0 : transfer_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
309 : :
310 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
311 : 0 : task->dst_iovs[i].iov_base = spdk_dma_zmalloc(transfer_size_with_md, 0, NULL);
312 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs[i].iov_base == NULL)) {
313 : 0 : return -ENOMEM;
314 : : }
315 : :
316 : 0 : memset(task->dst_iovs[i].iov_base, 0, transfer_size_with_md);
317 : 0 : task->dst_iovs[i].iov_len = transfer_size_with_md;
318 : 0 : }
319 : :
320 : 0 : task->src_iovcnt = chained_count;
321 : 0 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
322 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs == NULL)) {
323 : 0 : return -ENOMEM;
324 : : }
325 : :
326 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
327 : 0 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
328 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
329 : 0 : return -ENOMEM;
330 : : }
331 : :
332 : 0 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
333 : 0 : task->src_iovs[i].iov_len = src_buff_len;
334 : 0 : }
335 : :
336 : 0 : return 0;
337 : 0 : }
338 : :
339 : : static void
340 : 0 : free_dif_generate_copy_bufs(struct dif_task *task)
341 : : {
342 : 0 : uint32_t i = 0;
343 : :
344 [ # # ]: 0 : if (task->dst_iovs != NULL) {
345 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
346 [ # # ]: 0 : if (task->dst_iovs[i].iov_base != NULL) {
347 : 0 : spdk_dma_free(task->dst_iovs[i].iov_base);
348 : 0 : }
349 : 0 : }
350 : 0 : free(task->dst_iovs);
351 : 0 : }
352 : :
353 [ # # ]: 0 : if (task->src_iovs != NULL) {
354 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
355 [ # # ]: 0 : if (task->src_iovs[i].iov_base != NULL) {
356 : 0 : spdk_dma_free(task->src_iovs[i].iov_base);
357 : 0 : }
358 : 0 : }
359 : 0 : free(task->src_iovs);
360 : 0 : }
361 : 0 : }
362 : :
363 : : static int
364 : 0 : alloc_dif_generate_copy_sequence_bufs(struct dif_task *task, uint32_t chained_count)
365 : : {
366 : 0 : int src_buff_len = g_xfer_size_bytes;
367 : : uint32_t transfer_size_with_md;
368 : 0 : uint32_t i = 0;
369 : :
370 [ # # ]: 0 : assert(chained_count > 0);
371 : 0 : task->dst_iovcnt = chained_count;
372 : 0 : task->dst_iovs = calloc(task->dst_iovcnt, sizeof(struct iovec));
373 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs == NULL)) {
374 : 0 : return -ENOMEM;
375 : : }
376 : :
377 : 0 : task->num_blocks = g_xfer_size_bytes / g_block_size_bytes;
378 : :
379 : : /* Add bytes for each block for metadata */
380 : 0 : transfer_size_with_md = g_xfer_size_bytes + (task->num_blocks * g_md_size_bytes);
381 : :
382 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
383 : 0 : task->dst_iovs[i].iov_base = spdk_dma_zmalloc(transfer_size_with_md, 0, NULL);
384 [ # # ]: 0 : if (spdk_unlikely(task->dst_iovs[i].iov_base == NULL)) {
385 : 0 : return -ENOMEM;
386 : : }
387 : :
388 : 0 : memset(task->dst_iovs[i].iov_base, 0, transfer_size_with_md);
389 : 0 : task->dst_iovs[i].iov_len = transfer_size_with_md;
390 : 0 : }
391 : :
392 : 0 : task->src_iovcnt = chained_count;
393 : 0 : task->src_iovs = calloc(task->src_iovcnt, sizeof(struct iovec));
394 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs == NULL)) {
395 : 0 : return -ENOMEM;
396 : : }
397 : :
398 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
399 : 0 : task->src_iovs[i].iov_base = spdk_dma_zmalloc(src_buff_len, 0, NULL);
400 [ # # ]: 0 : if (spdk_unlikely(task->src_iovs[i].iov_base == NULL)) {
401 : 0 : return -ENOMEM;
402 : : }
403 : :
404 : 0 : memset(task->src_iovs[i].iov_base, DATA_PATTERN, src_buff_len);
405 : 0 : task->src_iovs[i].iov_len = src_buff_len;
406 : 0 : }
407 : :
408 : : /*
409 : : * For write, we do not want to insert DIF in place because host does not expect
410 : : * write buffer to be updated. We allocate auxiliary buffer to simulate such case.
411 : : */
412 : 0 : task->aux_iovcnt = chained_count;
413 : 0 : task->aux_iovs = calloc(task->aux_iovcnt, sizeof(struct iovec));
414 [ # # ]: 0 : if (spdk_unlikely(task->aux_iovs == NULL)) {
415 : 0 : return -ENOMEM;
416 : : }
417 : :
418 [ # # ]: 0 : for (i = 0; i < task->aux_iovcnt; i++) {
419 : 0 : task->aux_iovs[i].iov_base = spdk_dma_zmalloc(transfer_size_with_md, 0, NULL);
420 [ # # ]: 0 : if (spdk_unlikely(task->aux_iovs[i].iov_base == NULL)) {
421 : 0 : return -ENOMEM;
422 : : }
423 : :
424 : 0 : memset(task->aux_iovs[i].iov_base, 0, transfer_size_with_md);
425 : 0 : task->aux_iovs[i].iov_len = transfer_size_with_md;
426 : 0 : }
427 : :
428 : 0 : return 0;
429 : 0 : }
430 : :
431 : : static void
432 : 0 : free_dif_generate_copy_sequence_bufs(struct dif_task *task)
433 : : {
434 : 0 : uint32_t i = 0;
435 : :
436 [ # # ]: 0 : if (task->dst_iovs != NULL) {
437 [ # # ]: 0 : for (i = 0; i < task->dst_iovcnt; i++) {
438 [ # # ]: 0 : if (task->dst_iovs[i].iov_base != NULL) {
439 : 0 : spdk_dma_free(task->dst_iovs[i].iov_base);
440 : 0 : }
441 : 0 : }
442 : 0 : free(task->dst_iovs);
443 : 0 : }
444 : :
445 [ # # ]: 0 : if (task->src_iovs != NULL) {
446 [ # # ]: 0 : for (i = 0; i < task->src_iovcnt; i++) {
447 [ # # ]: 0 : if (task->src_iovs[i].iov_base != NULL) {
448 : 0 : spdk_dma_free(task->src_iovs[i].iov_base);
449 : 0 : }
450 : 0 : }
451 : 0 : free(task->src_iovs);
452 : 0 : }
453 : :
454 [ # # ]: 0 : if (task->aux_iovs != NULL) {
455 [ # # ]: 0 : for (i = 0; i < task->aux_iovcnt; i++) {
456 [ # # ]: 0 : if (task->aux_iovs[i].iov_base != NULL) {
457 : 0 : spdk_dma_free(task->aux_iovs[i].iov_base);
458 : 0 : }
459 : 0 : }
460 : 0 : free(task->aux_iovs);
461 : 0 : }
462 : 0 : }
463 : :
464 : : static void
465 : 0 : accel_dif_verify_test(void *arg)
466 : : {
467 : : int rc;
468 : 0 : struct accel_dif_request *req = arg;
469 : :
470 : 0 : g_completion_success = false;
471 : 0 : rc = spdk_accel_submit_dif_verify(req->channel, req->src_iovs, req->src_iovcnt,
472 : 0 : req->num_blocks, req->ctx, req->err,
473 : 0 : req->cb_fn, req->cb_arg);
474 [ # # ]: 0 : if (rc) {
475 : 0 : wake_ut_thread();
476 : 0 : }
477 : 0 : }
478 : :
479 : : static void
480 : 0 : accel_dix_verify_test(void *arg)
481 : : {
482 : : int rc;
483 : 0 : struct accel_dif_request *req = arg;
484 : :
485 : 0 : g_completion_success = false;
486 : 0 : rc = spdk_accel_submit_dix_verify(req->channel, req->src_iovs, req->src_iovcnt, req->md_iov,
487 : 0 : req->num_blocks, req->ctx, req->err, req->cb_fn,
488 : 0 : req->cb_arg);
489 [ # # ]: 0 : if (rc) {
490 : 0 : wake_ut_thread();
491 : 0 : }
492 : 0 : }
493 : :
494 : : static void
495 : 0 : accel_dix_generate_test(void *arg)
496 : : {
497 : : int rc;
498 : 0 : struct accel_dif_request *req = arg;
499 : :
500 : 0 : g_completion_success = false;
501 : 0 : rc = spdk_accel_submit_dix_generate(req->channel, req->src_iovs, req->src_iovcnt,
502 : 0 : req->md_iov, req->num_blocks, req->ctx, req->cb_fn, req->cb_arg);
503 [ # # ]: 0 : if (rc) {
504 : 0 : wake_ut_thread();
505 : 0 : }
506 : 0 : }
507 : :
508 : : static void
509 : 0 : accel_dif_verify_copy_test(void *arg)
510 : : {
511 : : int rc;
512 : 0 : struct accel_dif_request *req = arg;
513 : :
514 : 0 : g_completion_success = false;
515 : 0 : rc = spdk_accel_submit_dif_verify_copy(req->channel, req->dst_iovs, req->dst_iovcnt,
516 : 0 : req->src_iovs, req->src_iovcnt,
517 : 0 : req->num_blocks, req->ctx, req->err,
518 : 0 : req->cb_fn, req->cb_arg);
519 [ # # ]: 0 : if (rc) {
520 : 0 : wake_ut_thread();
521 : 0 : }
522 : 0 : }
523 : :
524 : : static void
525 : 0 : accel_dif_generate_copy_test(void *arg)
526 : : {
527 : : int rc;
528 : 0 : struct accel_dif_request *req = arg;
529 : :
530 : 0 : g_completion_success = false;
531 : 0 : rc = spdk_accel_submit_dif_generate_copy(req->channel, req->dst_iovs, req->dst_iovcnt,
532 : 0 : req->src_iovs, req->src_iovcnt, req->num_blocks, req->ctx,
533 : 0 : req->cb_fn, req->cb_arg);
534 [ # # ]: 0 : if (rc) {
535 : 0 : wake_ut_thread();
536 : 0 : }
537 : 0 : }
538 : :
539 : : static void
540 : 0 : accel_dif_generate_copy_sequence_test(void *arg)
541 : : {
542 : : int rc;
543 : 0 : struct accel_dif_request *req = arg;
544 : :
545 : 0 : g_completion_success = false;
546 : 0 : req->sequence = NULL;
547 : :
548 : 0 : rc = spdk_accel_append_dif_generate_copy(&req->sequence, req->channel,
549 : 0 : req->aux_iovs, req->aux_iovcnt, NULL, NULL,
550 : 0 : req->src_iovs, req->src_iovcnt, NULL, NULL,
551 : 0 : req->num_blocks, req->ctx, NULL, NULL);
552 [ # # ]: 0 : if (rc) {
553 : 0 : wake_ut_thread();
554 : 0 : return;
555 : : }
556 : :
557 : 0 : rc = spdk_accel_append_copy(&req->sequence, req->channel,
558 : 0 : req->dst_iovs, req->dst_iovcnt, NULL, NULL,
559 : 0 : req->aux_iovs, req->aux_iovcnt, NULL, NULL,
560 : : NULL, NULL);
561 [ # # ]: 0 : if (rc) {
562 : 0 : spdk_accel_sequence_abort(req->sequence);
563 : 0 : wake_ut_thread();
564 : 0 : return;
565 : : }
566 : :
567 : 0 : spdk_accel_sequence_finish(req->sequence, req->cb_fn, req->cb_arg);
568 : 0 : }
569 : :
570 : : static void
571 : 0 : accel_dif_verify_copy_sequence_test(void *arg)
572 : : {
573 : : int rc;
574 : 0 : struct accel_dif_request *req = arg;
575 : :
576 : 0 : g_completion_success = false;
577 : 0 : req->sequence = NULL;
578 : :
579 : 0 : rc = spdk_accel_append_dif_verify_copy(&req->sequence, req->channel,
580 : 0 : req->dst_iovs, req->dst_iovcnt, NULL, NULL,
581 : 0 : req->dst_iovs, req->dst_iovcnt, NULL, NULL,
582 : 0 : req->num_blocks, req->ctx, req->err,
583 : : NULL, NULL);
584 [ # # ]: 0 : if (rc) {
585 : 0 : wake_ut_thread();
586 : 0 : return;
587 : : }
588 : :
589 : 0 : rc = spdk_accel_append_copy(&req->sequence, req->channel,
590 : 0 : req->dst_iovs, req->dst_iovcnt, NULL, NULL,
591 : 0 : req->src_iovs, req->src_iovcnt, NULL, NULL,
592 : : NULL, NULL);
593 [ # # ]: 0 : if (rc) {
594 : 0 : spdk_accel_sequence_abort(req->sequence);
595 : 0 : wake_ut_thread();
596 : 0 : return;
597 : : }
598 : :
599 : 0 : spdk_accel_sequence_reverse(req->sequence);
600 : 0 : spdk_accel_sequence_finish(req->sequence, req->cb_fn, req->cb_arg);
601 : 0 : }
602 : :
603 : : static void
604 : 0 : accel_dif_verify_op_dif_generated_do_check(uint32_t dif_flags)
605 : : {
606 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
607 : : struct accel_dif_request req;
608 : 0 : struct dif_task *task = &g_dif_task;
609 : : int rc;
610 : :
611 : 0 : rc = alloc_dif_verify_bufs(task, 1);
612 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
613 : :
614 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
615 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
616 : :
617 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
618 : 0 : g_block_size_bytes + g_md_size_bytes,
619 : 0 : g_md_size_bytes, true, true,
620 : : SPDK_DIF_TYPE1,
621 : : SPDK_DIF_FLAGS_GUARD_CHECK |
622 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
623 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
624 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
625 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
626 : :
627 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
628 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
629 : :
630 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
631 : 0 : g_block_size_bytes + g_md_size_bytes,
632 : 0 : g_md_size_bytes, true, true,
633 : : SPDK_DIF_TYPE1,
634 : 0 : dif_flags,
635 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
636 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
637 : :
638 : 0 : req.channel = g_channel;
639 : 0 : req.src_iovs = task->src_iovs;
640 : 0 : req.src_iovcnt = task->src_iovcnt;
641 : 0 : req.num_blocks = task->num_blocks;
642 : 0 : req.ctx = &task->dif_ctx;
643 : 0 : req.err = &task->dif_err;
644 : 0 : req.cb_fn = accel_dif_oper_done;
645 : 0 : req.cb_arg = task;
646 : :
647 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
648 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
649 : :
650 : 0 : free_dif_verify_bufs(task);
651 : 0 : }
652 : :
653 : : static void
654 : 0 : accel_dix_generate_verify(struct accel_dif_request *req,
655 : : uint32_t dif_flags_generate, uint32_t dif_flags_verify)
656 : : {
657 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
658 : 0 : struct dif_task *task = &g_dif_task;
659 : : int rc;
660 : :
661 : 0 : rc = alloc_dix_bufs(task, 1);
662 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
663 : :
664 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
665 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
666 : :
667 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
668 : 0 : g_block_size_bytes,
669 : 0 : g_md_size_bytes, false, true,
670 : : SPDK_DIF_TYPE1,
671 : 0 : dif_flags_generate,
672 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
673 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
674 : :
675 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
676 : 0 : &task->dif_ctx);
677 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
678 : :
679 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
680 : 0 : g_block_size_bytes,
681 : 0 : g_md_size_bytes, false, true,
682 : : SPDK_DIF_TYPE1,
683 : 0 : dif_flags_verify,
684 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
685 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
686 : :
687 : 0 : req->channel = g_channel;
688 : 0 : req->src_iovs = task->src_iovs;
689 : 0 : req->src_iovcnt = task->src_iovcnt;
690 : 0 : req->md_iov = &task->md_iov;
691 : 0 : req->num_blocks = task->num_blocks;
692 : 0 : req->ctx = &task->dif_ctx;
693 : 0 : req->err = &task->dif_err;
694 : 0 : req->cb_fn = accel_dif_oper_done;
695 : 0 : req->cb_arg = task;
696 : :
697 : 0 : execute_spdk_function(accel_dix_verify_test, req);
698 : :
699 : 0 : free_dix_bufs(task);
700 : 0 : }
701 : :
702 : : static void
703 : 0 : accel_dif_verify_op_dif_generated_guard_check(void)
704 : : {
705 : 0 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
706 : 0 : }
707 : :
708 : : static void
709 : 0 : accel_dif_verify_op_dif_generated_apptag_check(void)
710 : : {
711 : 0 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
712 : 0 : }
713 : :
714 : : static void
715 : 0 : accel_dif_verify_op_dif_generated_reftag_check(void)
716 : : {
717 : 0 : accel_dif_verify_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
718 : 0 : }
719 : :
720 : : static void
721 : 0 : accel_dix_verify_op_dix_generated_guard_check(void)
722 : : {
723 : : struct accel_dif_request req;
724 : 0 : const char *module_name = NULL;
725 : : int rc;
726 : :
727 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
728 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
729 : :
730 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
731 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
732 : 0 : return;
733 : : }
734 : :
735 : 0 : accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |
736 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
737 : : SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_GUARD_CHECK);
738 : :
739 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
740 : 0 : }
741 : :
742 : : static void
743 : 0 : accel_dix_verify_op_dix_generated_apptag_check(void)
744 : : {
745 : : struct accel_dif_request req;
746 : 0 : const char *module_name = NULL;
747 : : int rc;
748 : :
749 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
750 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
751 : :
752 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
753 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
754 : 0 : return;
755 : : }
756 : :
757 : 0 : accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |
758 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
759 : : SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_APPTAG_CHECK);
760 : :
761 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
762 : 0 : }
763 : :
764 : : static void
765 : 0 : accel_dix_verify_op_dix_generated_reftag_check(void)
766 : : {
767 : : struct accel_dif_request req;
768 : 0 : const char *module_name = NULL;
769 : : int rc;
770 : :
771 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
772 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
773 : :
774 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
775 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
776 : 0 : return;
777 : : }
778 : :
779 : 0 : accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |
780 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
781 : : SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_FLAGS_REFTAG_CHECK);
782 : :
783 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
784 : 0 : }
785 : :
786 : : static void
787 : 0 : accel_dix_verify_op_dix_generated_all_flags_check(void)
788 : : {
789 : : struct accel_dif_request req;
790 : 0 : accel_dix_generate_verify(&req, SPDK_DIF_FLAGS_GUARD_CHECK |
791 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
792 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
793 : : SPDK_DIF_FLAGS_GUARD_CHECK |
794 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
795 : : SPDK_DIF_FLAGS_REFTAG_CHECK);
796 : :
797 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
798 : 0 : }
799 : :
800 : : static void
801 : 0 : accel_dix_verify_op_dix_not_generated_all_flags_check(void)
802 : : {
803 : : struct accel_dif_request req;
804 : 0 : accel_dix_generate_verify(&req, 0,
805 : : SPDK_DIF_FLAGS_GUARD_CHECK |
806 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
807 : : SPDK_DIF_FLAGS_REFTAG_CHECK);
808 : :
809 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
810 : 0 : }
811 : :
812 : : static void
813 : 0 : accel_dif_verify_op_dif_not_generated_do_check(uint32_t dif_flags)
814 : : {
815 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
816 : : struct accel_dif_request req;
817 : 0 : struct dif_task *task = &g_dif_task;
818 : : int rc;
819 : :
820 : 0 : rc = alloc_dif_verify_bufs(task, 1);
821 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
822 : :
823 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
824 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
825 : :
826 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
827 : 0 : g_block_size_bytes + g_md_size_bytes,
828 : 0 : g_md_size_bytes, true, true,
829 : : SPDK_DIF_TYPE1,
830 : 0 : dif_flags,
831 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
832 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
833 : :
834 : 0 : req.channel = g_channel;
835 : 0 : req.src_iovs = task->src_iovs;
836 : 0 : req.src_iovcnt = task->src_iovcnt;
837 : 0 : req.num_blocks = task->num_blocks;
838 : 0 : req.ctx = &task->dif_ctx;
839 : 0 : req.err = &task->dif_err;
840 : 0 : req.cb_fn = accel_dif_oper_done;
841 : 0 : req.cb_arg = task;
842 : :
843 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
844 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
845 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags, req.err), true);
846 : :
847 : 0 : free_dif_verify_bufs(task);
848 : 0 : }
849 : :
850 : : static void
851 : 0 : accel_dif_verify_op_dif_not_generated_guard_check(void)
852 : : {
853 : 0 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
854 : 0 : }
855 : :
856 : : static void
857 : 0 : accel_dix_verify_op_dix_not_generated_guard_check(void)
858 : : {
859 : 0 : const char *module_name = NULL;
860 : 0 : uint32_t dif_flags_verify = SPDK_DIF_FLAGS_GUARD_CHECK;
861 : : struct accel_dif_request req;
862 : : int rc;
863 : :
864 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
865 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
866 : :
867 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
868 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
869 : 0 : return;
870 : : }
871 : :
872 : 0 : accel_dix_generate_verify(&req, 0, dif_flags_verify);
873 : :
874 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
875 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);
876 : 0 : }
877 : :
878 : : static void
879 : 0 : accel_dif_verify_op_dif_not_generated_apptag_check(void)
880 : : {
881 : 0 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
882 : 0 : }
883 : :
884 : : static void
885 : 0 : accel_dix_verify_op_dix_not_generated_apptag_check(void)
886 : : {
887 : 0 : const char *module_name = NULL;
888 : 0 : uint32_t dif_flags_verify = SPDK_DIF_FLAGS_APPTAG_CHECK;
889 : : struct accel_dif_request req;
890 : : int rc;
891 : :
892 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
893 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
894 : :
895 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
896 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
897 : 0 : return;
898 : : }
899 : :
900 : 0 : accel_dix_generate_verify(&req, 0, dif_flags_verify);
901 : :
902 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
903 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);
904 : 0 : }
905 : :
906 : : static void
907 : 0 : accel_dif_verify_op_dif_not_generated_reftag_check(void)
908 : : {
909 : 0 : accel_dif_verify_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
910 : 0 : }
911 : :
912 : : static void
913 : 0 : accel_dix_verify_op_dix_not_generated_reftag_check(void)
914 : : {
915 : 0 : const char *module_name = NULL;
916 : 0 : uint32_t dif_flags_verify = SPDK_DIF_FLAGS_REFTAG_CHECK;
917 : : struct accel_dif_request req;
918 : : int rc;
919 : :
920 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
921 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
922 : :
923 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
924 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
925 : 0 : return;
926 : : }
927 : :
928 : 0 : accel_dix_generate_verify(&req, 0, dif_flags_verify);
929 : :
930 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
931 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags_verify, req.err), true);
932 : 0 : }
933 : :
934 : : static void
935 : 0 : accel_dix_verify_op_dix_guard_not_generated_all_flags_check(void)
936 : : {
937 : : struct accel_dif_request req;
938 : 0 : accel_dix_generate_verify(&req,
939 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
940 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
941 : : SPDK_DIF_FLAGS_GUARD_CHECK |
942 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
943 : : SPDK_DIF_FLAGS_REFTAG_CHECK);
944 : :
945 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
946 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(SPDK_DIF_FLAGS_GUARD_CHECK, req.err), true);
947 : 0 : }
948 : :
949 : : static void
950 : 0 : accel_dix_verify_op_dix_apptag_not_generated_all_flags_check(void)
951 : : {
952 : : struct accel_dif_request req;
953 : 0 : accel_dix_generate_verify(&req,
954 : : SPDK_DIF_FLAGS_GUARD_CHECK |
955 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
956 : : SPDK_DIF_FLAGS_GUARD_CHECK |
957 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
958 : : SPDK_DIF_FLAGS_REFTAG_CHECK);
959 : :
960 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
961 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(SPDK_DIF_FLAGS_APPTAG_CHECK, req.err), true);
962 : 0 : }
963 : :
964 : : static void
965 : 0 : accel_dix_verify_op_dix_reftag_not_generated_all_flags_check(void)
966 : : {
967 : : struct accel_dif_request req;
968 : 0 : accel_dix_generate_verify(&req,
969 : : SPDK_DIF_FLAGS_GUARD_CHECK |
970 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
971 : : SPDK_DIF_FLAGS_GUARD_CHECK |
972 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
973 : : SPDK_DIF_FLAGS_REFTAG_CHECK);
974 : :
975 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
976 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(SPDK_DIF_FLAGS_REFTAG_CHECK, req.err), true);
977 : 0 : }
978 : :
979 : : static void
980 : 0 : accel_dif_verify_op_apptag_correct_apptag_check(void)
981 : : {
982 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
983 : : struct accel_dif_request req;
984 : 0 : struct dif_task *task = &g_dif_task;
985 : : int rc;
986 : :
987 : 0 : rc = alloc_dif_verify_bufs(task, 1);
988 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
989 : :
990 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
991 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
992 : :
993 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
994 : 0 : g_block_size_bytes + g_md_size_bytes,
995 : 0 : g_md_size_bytes, true, true,
996 : : SPDK_DIF_TYPE1,
997 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
998 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
999 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1000 : :
1001 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1002 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1003 : :
1004 : 0 : req.channel = g_channel;
1005 : 0 : req.src_iovs = task->src_iovs;
1006 : 0 : req.src_iovcnt = task->src_iovcnt;
1007 : 0 : req.num_blocks = task->num_blocks;
1008 : 0 : req.ctx = &task->dif_ctx;
1009 : 0 : req.err = &task->dif_err;
1010 : 0 : req.cb_fn = accel_dif_oper_done;
1011 : 0 : req.cb_arg = task;
1012 : :
1013 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
1014 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1015 : :
1016 : 0 : free_dif_verify_bufs(task);
1017 : 0 : }
1018 : :
1019 : : static void
1020 : 0 : accel_dix_verify_op_apptag_correct_apptag_check(void)
1021 : : {
1022 : 0 : const char *module_name = NULL;
1023 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1024 : : struct accel_dif_request req;
1025 : 0 : struct dif_task *task = &g_dif_task;
1026 : : int rc;
1027 : :
1028 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
1029 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1030 : :
1031 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
1032 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
1033 : 0 : return;
1034 : : }
1035 : :
1036 : 0 : rc = alloc_dix_bufs(task, 1);
1037 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1038 : :
1039 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1040 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1041 : :
1042 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1043 : 0 : g_block_size_bytes,
1044 : 0 : g_md_size_bytes, false, true,
1045 : : SPDK_DIF_TYPE1,
1046 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1047 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1048 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1049 : :
1050 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
1051 : 0 : &task->dif_ctx);
1052 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1053 : :
1054 : 0 : req.channel = g_channel;
1055 : 0 : req.src_iovs = task->src_iovs;
1056 : 0 : req.src_iovcnt = task->src_iovcnt;
1057 : 0 : req.md_iov = &task->md_iov;
1058 : 0 : req.num_blocks = task->num_blocks;
1059 : 0 : req.ctx = &task->dif_ctx;
1060 : 0 : req.err = &task->dif_err;
1061 : 0 : req.cb_fn = accel_dif_oper_done;
1062 : 0 : req.cb_arg = task;
1063 : :
1064 : 0 : execute_spdk_function(accel_dix_verify_test, &req);
1065 : :
1066 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1067 : :
1068 : 0 : free_dix_bufs(task);
1069 : 0 : }
1070 : :
1071 : : static void
1072 : 0 : accel_dif_verify_op_apptag_incorrect_apptag_check(void)
1073 : : {
1074 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1075 : : struct accel_dif_request req;
1076 : 0 : struct dif_task *task = &g_dif_task;
1077 : : int rc;
1078 : :
1079 : 0 : rc = alloc_dif_verify_bufs(task, 1);
1080 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1081 : :
1082 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1083 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1084 : :
1085 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1086 : 0 : g_block_size_bytes + g_md_size_bytes,
1087 : 0 : g_md_size_bytes, true, true,
1088 : : SPDK_DIF_TYPE1,
1089 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1090 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1091 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1092 : :
1093 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1094 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1095 : :
1096 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1097 : 0 : g_block_size_bytes + g_md_size_bytes,
1098 : 0 : g_md_size_bytes, true, true,
1099 : : SPDK_DIF_TYPE1,
1100 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1101 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
1102 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1103 : :
1104 : 0 : req.channel = g_channel;
1105 : 0 : req.src_iovs = task->src_iovs;
1106 : 0 : req.src_iovcnt = task->src_iovcnt;
1107 : 0 : req.num_blocks = task->num_blocks;
1108 : 0 : req.ctx = &task->dif_ctx;
1109 : 0 : req.err = &task->dif_err;
1110 : 0 : req.cb_fn = accel_dif_oper_done;
1111 : 0 : req.cb_arg = task;
1112 : :
1113 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
1114 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1115 : :
1116 : 0 : free_dif_verify_bufs(task);
1117 : 0 : }
1118 : :
1119 : : static void
1120 : 0 : accel_dix_verify_op_apptag_incorrect_apptag_check(void)
1121 : : {
1122 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1123 : : struct accel_dif_request req;
1124 : 0 : struct dif_task *task = &g_dif_task;
1125 : : int rc;
1126 : :
1127 : 0 : rc = alloc_dix_bufs(task, 1);
1128 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1129 : :
1130 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1131 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1132 : :
1133 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1134 : 0 : g_block_size_bytes,
1135 : 0 : g_md_size_bytes, false, true,
1136 : : SPDK_DIF_TYPE1,
1137 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1138 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1139 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1140 : :
1141 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
1142 : 0 : &task->dif_ctx);
1143 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1144 : :
1145 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1146 : 0 : g_block_size_bytes,
1147 : 0 : g_md_size_bytes, false, true,
1148 : : SPDK_DIF_TYPE1,
1149 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1150 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
1151 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1152 : :
1153 : 0 : req.channel = g_channel;
1154 : 0 : req.src_iovs = task->src_iovs;
1155 : 0 : req.src_iovcnt = task->src_iovcnt;
1156 : 0 : req.md_iov = &task->md_iov;
1157 : 0 : req.num_blocks = task->num_blocks;
1158 : 0 : req.ctx = &task->dif_ctx;
1159 : 0 : req.err = &task->dif_err;
1160 : 0 : req.cb_fn = accel_dif_oper_done;
1161 : 0 : req.cb_arg = task;
1162 : :
1163 : 0 : execute_spdk_function(accel_dix_verify_test, &req);
1164 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1165 : :
1166 : 0 : free_dix_bufs(task);
1167 : 0 : }
1168 : :
1169 : : static void
1170 : 0 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)
1171 : : {
1172 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1173 : : struct accel_dif_request req;
1174 : 0 : struct dif_task *task = &g_dif_task;
1175 : : int rc;
1176 : :
1177 : 0 : rc = alloc_dif_verify_bufs(task, 1);
1178 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1179 : :
1180 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1181 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1182 : :
1183 : : /* For set 'Application Tag F Detect' (Source DIF Flags)
1184 : : * When all bits of the Application Tag field of the source Data Integrity Field
1185 : : * are equal to 1, the Application Tag check is not done and the Guard field and
1186 : : * Reference Tag field are ignored. */
1187 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1188 : 0 : g_block_size_bytes + g_md_size_bytes,
1189 : 0 : g_md_size_bytes, true, true,
1190 : : SPDK_DIF_TYPE1,
1191 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1192 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1193 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1194 : : 10, 0xFFFF, 0xFFFF, 0, 0, &dif_opts);
1195 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1196 : :
1197 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1198 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1199 : :
1200 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1201 : 0 : g_block_size_bytes + g_md_size_bytes,
1202 : 0 : g_md_size_bytes, true, true,
1203 : : SPDK_DIF_TYPE1,
1204 : 0 : dif_flags,
1205 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
1206 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1207 : :
1208 : 0 : req.channel = g_channel;
1209 : 0 : req.src_iovs = task->src_iovs;
1210 : 0 : req.src_iovcnt = task->src_iovcnt;
1211 : 0 : req.num_blocks = task->num_blocks;
1212 : 0 : req.ctx = &task->dif_ctx;
1213 : 0 : req.err = &task->dif_err;
1214 : 0 : req.cb_fn = accel_dif_oper_done;
1215 : 0 : req.cb_arg = task;
1216 : :
1217 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
1218 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1219 : :
1220 : 0 : free_dif_verify_bufs(task);
1221 : 0 : }
1222 : :
1223 : : static void
1224 : 0 : accel_dix_verify_op_tag_incorrect_no_check_or_ignore(uint32_t dif_flags)
1225 : : {
1226 : 0 : const char *module_name = NULL;
1227 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1228 : : struct accel_dif_request req;
1229 : 0 : struct dif_task *task = &g_dif_task;
1230 : : int rc;
1231 : :
1232 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
1233 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1234 : :
1235 : : /* Intel DSA does not allow for selective DIF fields verify for DIX */
1236 [ # # # # ]: 0 : if (!strcmp(module_name, "dsa") && (dif_flags != (SPDK_DIF_FLAGS_GUARD_CHECK |
1237 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1238 : : SPDK_DIF_FLAGS_REFTAG_CHECK))) {
1239 : 0 : return;
1240 : : }
1241 : :
1242 : 0 : rc = alloc_dix_bufs(task, 1);
1243 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1244 : :
1245 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1246 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1247 : :
1248 : : /* For set 'Application Tag F Detect' (Source DIF Flags)
1249 : : * When all bits of the Application Tag field of the source Data Integrity Field
1250 : : * are equal to 1, the Application Tag check is not done and the Guard field and
1251 : : * Reference Tag field are ignored. */
1252 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1253 : 0 : g_block_size_bytes,
1254 : 0 : g_md_size_bytes, false, true,
1255 : : SPDK_DIF_TYPE1,
1256 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1257 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1258 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1259 : : 10, 0xFFFF, 0xFFFF, 0, 0, &dif_opts);
1260 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1261 : :
1262 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
1263 : 0 : &task->dif_ctx);
1264 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1265 : :
1266 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1267 : 0 : g_block_size_bytes,
1268 : 0 : g_md_size_bytes, false, true,
1269 : : SPDK_DIF_TYPE1,
1270 : 0 : dif_flags,
1271 : : 30, 0xFFFF, 40, 0, 0, &dif_opts);
1272 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1273 : :
1274 : 0 : req.channel = g_channel;
1275 : 0 : req.src_iovs = task->src_iovs;
1276 : 0 : req.src_iovcnt = task->src_iovcnt;
1277 : 0 : req.md_iov = &task->md_iov;
1278 : 0 : req.num_blocks = task->num_blocks;
1279 : 0 : req.ctx = &task->dif_ctx;
1280 : 0 : req.err = &task->dif_err;
1281 : 0 : req.cb_fn = accel_dif_oper_done;
1282 : 0 : req.cb_arg = task;
1283 : :
1284 : 0 : execute_spdk_function(accel_dix_verify_test, &req);
1285 : :
1286 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1287 : :
1288 : 0 : free_dix_bufs(task);
1289 : 0 : }
1290 : :
1291 : : static void
1292 : 0 : accel_dif_verify_op_apptag_incorrect_no_apptag_check(void)
1293 : : {
1294 : 0 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);
1295 : 0 : }
1296 : :
1297 : : static void
1298 : 0 : accel_dix_verify_op_apptag_incorrect_no_apptag_check(void)
1299 : : {
1300 : 0 : accel_dix_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_APPTAG_CHECK);
1301 : 0 : }
1302 : :
1303 : : static void
1304 : 0 : accel_dif_verify_op_reftag_incorrect_reftag_ignore(void)
1305 : : {
1306 : 0 : accel_dif_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);
1307 : 0 : }
1308 : :
1309 : : static void
1310 : 0 : accel_dix_verify_op_reftag_incorrect_reftag_ignore(void)
1311 : : {
1312 : 0 : accel_dix_verify_op_tag_incorrect_no_check_or_ignore(SPDK_DIF_FLAGS_REFTAG_CHECK);
1313 : 0 : }
1314 : :
1315 : : static void
1316 : 0 : accel_dif_verify_op_reftag_init_correct_reftag_check(void)
1317 : : {
1318 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1319 : : struct accel_dif_request req;
1320 : 0 : struct dif_task *task = &g_dif_task;
1321 : : int rc;
1322 : :
1323 : 0 : rc = alloc_dif_verify_bufs(task, 2);
1324 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1325 : :
1326 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1327 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1328 : :
1329 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1330 : 0 : g_block_size_bytes + g_md_size_bytes,
1331 : 0 : g_md_size_bytes, true, true,
1332 : : SPDK_DIF_TYPE1,
1333 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1334 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1335 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1336 : :
1337 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1338 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1339 : :
1340 : 0 : req.channel = g_channel;
1341 : 0 : req.src_iovs = task->src_iovs;
1342 : 0 : req.src_iovcnt = task->src_iovcnt;
1343 : 0 : req.num_blocks = task->num_blocks;
1344 : 0 : req.ctx = &task->dif_ctx;
1345 : 0 : req.err = &task->dif_err;
1346 : 0 : req.cb_fn = accel_dif_oper_done;
1347 : 0 : req.cb_arg = task;
1348 : :
1349 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
1350 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1351 : :
1352 : 0 : free_dif_verify_bufs(task);
1353 : 0 : }
1354 : :
1355 : : static void
1356 : 0 : accel_dix_verify_op_reftag_init_correct_reftag_check(void)
1357 : : {
1358 : 0 : const char *module_name = NULL;
1359 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1360 : : struct accel_dif_request req;
1361 : 0 : struct dif_task *task = &g_dif_task;
1362 : : int rc;
1363 : :
1364 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIX_VERIFY, &module_name);
1365 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1366 : :
1367 : : /* Intel DSA does not allow for selective DIF fields verification for DIX */
1368 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
1369 : 0 : return;
1370 : : }
1371 : :
1372 : 0 : rc = alloc_dix_bufs(task, 2);
1373 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1374 : :
1375 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1376 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1377 : :
1378 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1379 : 0 : g_block_size_bytes,
1380 : 0 : g_md_size_bytes, false, true,
1381 : : SPDK_DIF_TYPE1,
1382 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1383 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1384 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1385 : :
1386 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
1387 : 0 : &task->dif_ctx);
1388 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1389 : :
1390 : 0 : req.channel = g_channel;
1391 : 0 : req.src_iovs = task->src_iovs;
1392 : 0 : req.src_iovcnt = task->src_iovcnt;
1393 : 0 : req.md_iov = &task->md_iov;
1394 : 0 : req.num_blocks = task->num_blocks;
1395 : 0 : req.ctx = &task->dif_ctx;
1396 : 0 : req.err = &task->dif_err;
1397 : 0 : req.cb_fn = accel_dif_oper_done;
1398 : 0 : req.cb_arg = task;
1399 : :
1400 : 0 : execute_spdk_function(accel_dix_verify_test, &req);
1401 : :
1402 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1403 : :
1404 : 0 : free_dix_bufs(task);
1405 : 0 : }
1406 : :
1407 : : static void
1408 : 0 : accel_dif_verify_op_reftag_init_incorrect_reftag_check(void)
1409 : : {
1410 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1411 : : struct accel_dif_request req;
1412 : 0 : struct dif_task *task = &g_dif_task;
1413 : : int rc;
1414 : :
1415 : 0 : rc = alloc_dif_verify_bufs(task, 2);
1416 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1417 : :
1418 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1419 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1420 : :
1421 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1422 : 0 : g_block_size_bytes + g_md_size_bytes,
1423 : 0 : g_md_size_bytes, true, true,
1424 : : SPDK_DIF_TYPE1,
1425 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1426 : : 16, 0xFFFF, 20, 0, 0, &dif_opts);
1427 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1428 : :
1429 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1430 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1431 : :
1432 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1433 : 0 : g_block_size_bytes + g_md_size_bytes,
1434 : 0 : g_md_size_bytes, true, true,
1435 : : SPDK_DIF_TYPE1,
1436 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1437 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1438 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1439 : :
1440 : 0 : req.channel = g_channel;
1441 : 0 : req.src_iovs = task->src_iovs;
1442 : 0 : req.src_iovcnt = task->src_iovcnt;
1443 : 0 : req.num_blocks = task->num_blocks;
1444 : 0 : req.ctx = &task->dif_ctx;
1445 : 0 : req.err = &task->dif_err;
1446 : 0 : req.cb_fn = accel_dif_oper_done;
1447 : 0 : req.cb_arg = task;
1448 : :
1449 : 0 : execute_spdk_function(accel_dif_verify_test, &req);
1450 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1451 : :
1452 : 0 : free_dif_verify_bufs(task);
1453 : 0 : }
1454 : :
1455 : : static void
1456 : 0 : accel_dix_verify_op_reftag_init_incorrect_reftag_check(void)
1457 : : {
1458 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1459 : : struct accel_dif_request req;
1460 : 0 : struct dif_task *task = &g_dif_task;
1461 : : int rc;
1462 : :
1463 : 0 : rc = alloc_dix_bufs(task, 2);
1464 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1465 : :
1466 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1467 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1468 : :
1469 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1470 : 0 : g_block_size_bytes,
1471 : 0 : g_md_size_bytes, false, true,
1472 : : SPDK_DIF_TYPE1,
1473 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1474 : : 16, 0xFFFF, 20, 0, 0, &dif_opts);
1475 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1476 : :
1477 : 0 : rc = spdk_dix_generate(task->src_iovs, task->src_iovcnt, &task->md_iov, task->num_blocks,
1478 : 0 : &task->dif_ctx);
1479 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1480 : :
1481 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1482 : 0 : g_block_size_bytes,
1483 : 0 : g_md_size_bytes, false, true,
1484 : : SPDK_DIF_TYPE1,
1485 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1486 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1487 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1488 : :
1489 : 0 : req.channel = g_channel;
1490 : 0 : req.src_iovs = task->src_iovs;
1491 : 0 : req.src_iovcnt = task->src_iovcnt;
1492 : 0 : req.md_iov = &task->md_iov;
1493 : 0 : req.num_blocks = task->num_blocks;
1494 : 0 : req.ctx = &task->dif_ctx;
1495 : 0 : req.err = &task->dif_err;
1496 : 0 : req.cb_fn = accel_dif_oper_done;
1497 : 0 : req.cb_arg = task;
1498 : :
1499 : 0 : execute_spdk_function(accel_dix_verify_test, &req);
1500 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1501 : :
1502 : 0 : free_dix_bufs(task);
1503 : 0 : }
1504 : :
1505 : : static void
1506 : 0 : accel_dif_verify_copy_op_dif_generated_do_check(uint32_t dif_flags)
1507 : : {
1508 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1509 : : struct accel_dif_request req;
1510 : 0 : struct dif_task *task = &g_dif_task;
1511 : : int rc;
1512 : :
1513 : 0 : rc = alloc_dif_verify_copy_bufs(task, 1);
1514 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1515 : :
1516 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1517 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1518 : :
1519 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1520 : 0 : g_block_size_bytes + g_md_size_bytes,
1521 : 0 : g_md_size_bytes, true, true,
1522 : : SPDK_DIF_TYPE1,
1523 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1524 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1525 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1526 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1527 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1528 : :
1529 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
1530 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1531 : :
1532 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1533 : 0 : g_block_size_bytes + g_md_size_bytes,
1534 : 0 : g_md_size_bytes, true, true,
1535 : : SPDK_DIF_TYPE1,
1536 : 0 : dif_flags,
1537 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1538 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1539 : :
1540 : 0 : req.channel = g_channel;
1541 : 0 : req.dst_iovs = task->dst_iovs;
1542 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1543 : 0 : req.src_iovs = task->src_iovs;
1544 : 0 : req.src_iovcnt = task->src_iovcnt;
1545 : 0 : req.num_blocks = task->num_blocks;
1546 : 0 : req.ctx = &task->dif_ctx;
1547 : 0 : req.err = &task->dif_err;
1548 : 0 : req.cb_fn = accel_dif_oper_done;
1549 : 0 : req.cb_arg = task;
1550 : :
1551 : 0 : execute_spdk_function(accel_dif_verify_copy_test, &req);
1552 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1553 : :
1554 : 0 : free_dif_verify_copy_bufs(task);
1555 : 0 : }
1556 : :
1557 : : static void
1558 : 0 : accel_dif_verify_copy_op_dif_generated_guard_check(void)
1559 : : {
1560 : 0 : accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
1561 : 0 : }
1562 : :
1563 : : static void
1564 : 0 : accel_dif_verify_copy_op_dif_generated_apptag_check(void)
1565 : : {
1566 : 0 : accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
1567 : 0 : }
1568 : :
1569 : : static void
1570 : 0 : accel_dif_verify_copy_op_dif_generated_reftag_check(void)
1571 : : {
1572 : 0 : accel_dif_verify_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
1573 : 0 : }
1574 : :
1575 : : static void
1576 : 0 : accel_dif_verify_copy_op_dif_not_generated_do_check(uint32_t dif_flags)
1577 : : {
1578 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1579 : : struct accel_dif_request req;
1580 : 0 : struct dif_task *task = &g_dif_task;
1581 : : int rc;
1582 : :
1583 : 0 : rc = alloc_dif_verify_copy_bufs(task, 1);
1584 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1585 : :
1586 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1587 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1588 : :
1589 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1590 : 0 : g_block_size_bytes + g_md_size_bytes,
1591 : 0 : g_md_size_bytes, true, true,
1592 : : SPDK_DIF_TYPE1,
1593 : 0 : dif_flags,
1594 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1595 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1596 : :
1597 : 0 : req.channel = g_channel;
1598 : 0 : req.dst_iovs = task->dst_iovs;
1599 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1600 : 0 : req.src_iovs = task->src_iovs;
1601 : 0 : req.src_iovcnt = task->src_iovcnt;
1602 : 0 : req.num_blocks = task->num_blocks;
1603 : 0 : req.ctx = &task->dif_ctx;
1604 : 0 : req.err = &task->dif_err;
1605 : 0 : req.cb_fn = accel_dif_oper_done;
1606 : 0 : req.cb_arg = task;
1607 : :
1608 : 0 : execute_spdk_function(accel_dif_verify_copy_test, &req);
1609 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1610 : 0 : CU_ASSERT_EQUAL(accel_dif_error_validate(dif_flags, req.err), true);
1611 : :
1612 : 0 : free_dif_verify_copy_bufs(task);
1613 : 0 : }
1614 : :
1615 : : static void
1616 : 0 : accel_dif_verify_copy_op_dif_not_generated_guard_check(void)
1617 : : {
1618 : 0 : accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
1619 : 0 : }
1620 : :
1621 : : static void
1622 : 0 : accel_dif_verify_copy_op_dif_not_generated_apptag_check(void)
1623 : : {
1624 : 0 : accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
1625 : 0 : }
1626 : :
1627 : : static void
1628 : 0 : accel_dif_verify_copy_op_dif_not_generated_reftag_check(void)
1629 : : {
1630 : 0 : accel_dif_verify_copy_op_dif_not_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
1631 : 0 : }
1632 : :
1633 : : static void
1634 : 0 : accel_dif_generate_copy_op_dif_generated_do_check(uint32_t dif_flags)
1635 : : {
1636 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1637 : : struct accel_dif_request req;
1638 : 0 : struct dif_task *task = &g_dif_task;
1639 : : struct spdk_dif_error err_blk;
1640 : : int rc;
1641 : :
1642 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1643 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1644 : :
1645 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1646 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1647 : :
1648 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1649 : 0 : g_block_size_bytes + g_md_size_bytes,
1650 : 0 : g_md_size_bytes, true, true,
1651 : : SPDK_DIF_TYPE1,
1652 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1653 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1654 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1655 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1656 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1657 : :
1658 : 0 : req.channel = g_channel;
1659 : 0 : req.dst_iovs = task->dst_iovs;
1660 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1661 : 0 : req.src_iovs = task->src_iovs;
1662 : 0 : req.src_iovcnt = task->src_iovcnt;
1663 : 0 : req.num_blocks = task->num_blocks;
1664 : 0 : req.ctx = &task->dif_ctx;
1665 : 0 : req.err = &task->dif_err;
1666 : 0 : req.cb_fn = accel_dif_oper_done;
1667 : 0 : req.cb_arg = task;
1668 : :
1669 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
1670 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1671 : :
1672 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1673 : 0 : g_block_size_bytes + g_md_size_bytes,
1674 : 0 : g_md_size_bytes, true, true,
1675 : : SPDK_DIF_TYPE1,
1676 : 0 : dif_flags,
1677 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1678 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1679 : :
1680 : 0 : rc = spdk_dif_verify(req.dst_iovs, req.dst_iovcnt, req.num_blocks,
1681 : 0 : &task->dif_ctx, &err_blk);
1682 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1683 : :
1684 : 0 : free_dif_generate_copy_bufs(task);
1685 : 0 : }
1686 : :
1687 : : static void
1688 : 0 : accel_dix_generate_op_dix_generated_do_check(uint32_t dif_flags)
1689 : : {
1690 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1691 : : struct accel_dif_request req;
1692 : 0 : struct dif_task *task = &g_dif_task;
1693 : : struct spdk_dif_error err_blk;
1694 : : int rc;
1695 : :
1696 : 0 : rc = alloc_dix_bufs(task, 3);
1697 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1698 : :
1699 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1700 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1701 : :
1702 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1703 : 0 : g_block_size_bytes,
1704 : 0 : g_md_size_bytes, false, true,
1705 : : SPDK_DIF_TYPE1,
1706 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1707 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1708 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1709 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1710 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1711 : :
1712 : 0 : req.channel = g_channel;
1713 : 0 : req.src_iovs = task->src_iovs;
1714 : 0 : req.src_iovcnt = task->src_iovcnt;
1715 : 0 : req.md_iov = &task->md_iov;
1716 : 0 : req.num_blocks = task->num_blocks;
1717 : 0 : req.ctx = &task->dif_ctx;
1718 : 0 : req.err = &task->dif_err;
1719 : 0 : req.cb_fn = accel_dif_oper_done;
1720 : 0 : req.cb_arg = task;
1721 : :
1722 : 0 : execute_spdk_function(accel_dix_generate_test, &req);
1723 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1724 : :
1725 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1726 : 0 : g_block_size_bytes,
1727 : 0 : g_md_size_bytes, false, true,
1728 : : SPDK_DIF_TYPE1,
1729 : 0 : dif_flags,
1730 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
1731 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1732 : :
1733 : 0 : rc = spdk_dix_verify(req.src_iovs, req.src_iovcnt, req.md_iov, req.num_blocks,
1734 : 0 : &task->dif_ctx, &err_blk);
1735 : 0 : CU_ASSERT_EQUAL(rc, 0);
1736 : :
1737 : 0 : free_dix_bufs(task);
1738 : 0 : }
1739 : :
1740 : : static void
1741 : 0 : accel_dif_generate_copy_op_dif_generated_guard_check(void)
1742 : : {
1743 : 0 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
1744 : 0 : }
1745 : :
1746 : : static void
1747 : 0 : accel_dix_generate_op_dix_generated_guard_check(void)
1748 : : {
1749 : 0 : accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
1750 : 0 : }
1751 : :
1752 : : static void
1753 : 0 : accel_dif_generate_copy_op_dif_generated_apptag_check(void)
1754 : : {
1755 : 0 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
1756 : 0 : }
1757 : :
1758 : : static void
1759 : 0 : accel_dix_generate_op_dix_generated_apptag_check(void)
1760 : : {
1761 : 0 : accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
1762 : 0 : }
1763 : :
1764 : : static void
1765 : 0 : accel_dif_generate_copy_op_dif_generated_reftag_check(void)
1766 : : {
1767 : 0 : accel_dif_generate_copy_op_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
1768 : 0 : }
1769 : :
1770 : : static void
1771 : 0 : accel_dix_generate_op_dix_generated_reftag_check(void)
1772 : : {
1773 : 0 : accel_dix_generate_op_dix_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
1774 : 0 : }
1775 : :
1776 : : static void
1777 : 0 : accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set(void)
1778 : : {
1779 : 0 : const char *module_name = NULL;
1780 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1781 : : struct accel_dif_request req;
1782 : 0 : struct dif_task *task = &g_dif_task;
1783 : : int rc;
1784 : :
1785 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
1786 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1787 : :
1788 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1789 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1790 : :
1791 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1792 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1793 : :
1794 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1795 : 0 : g_block_size_bytes + g_md_size_bytes,
1796 : 0 : g_md_size_bytes, true, true,
1797 : : SPDK_DIF_TYPE1,
1798 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1799 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1800 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1801 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1802 : :
1803 : 0 : req.channel = g_channel;
1804 : 0 : req.dst_iovs = task->dst_iovs;
1805 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1806 : 0 : req.src_iovs = task->src_iovs;
1807 : 0 : req.src_iovcnt = task->src_iovcnt;
1808 : 0 : req.num_blocks = task->num_blocks;
1809 : 0 : req.ctx = &task->dif_ctx;
1810 : 0 : req.err = &task->dif_err;
1811 : 0 : req.cb_fn = accel_dif_oper_done;
1812 : 0 : req.cb_arg = task;
1813 : :
1814 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
1815 : :
1816 : : /* Intel DSA does not allow for selective DIF fields generation */
1817 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
1818 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1819 [ # # ]: 0 : } else if (!strcmp(module_name, "software")) {
1820 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1821 : 0 : } else {
1822 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(false);
1823 : : }
1824 : :
1825 : 0 : free_dif_generate_copy_bufs(task);
1826 : 0 : }
1827 : :
1828 : : static void
1829 : 0 : accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set(void)
1830 : : {
1831 : 0 : const char *module_name = NULL;
1832 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1833 : : struct accel_dif_request req;
1834 : 0 : struct dif_task *task = &g_dif_task;
1835 : : int rc;
1836 : :
1837 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
1838 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1839 : :
1840 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1841 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1842 : :
1843 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1844 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1845 : :
1846 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1847 : 0 : g_block_size_bytes + g_md_size_bytes,
1848 : 0 : g_md_size_bytes, true, true,
1849 : : SPDK_DIF_TYPE1,
1850 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1851 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1852 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1853 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1854 : :
1855 : 0 : req.channel = g_channel;
1856 : 0 : req.dst_iovs = task->dst_iovs;
1857 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1858 : 0 : req.src_iovs = task->src_iovs;
1859 : 0 : req.src_iovcnt = task->src_iovcnt;
1860 : 0 : req.num_blocks = task->num_blocks;
1861 : 0 : req.ctx = &task->dif_ctx;
1862 : 0 : req.err = &task->dif_err;
1863 : 0 : req.cb_fn = accel_dif_oper_done;
1864 : 0 : req.cb_arg = task;
1865 : :
1866 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
1867 : :
1868 : : /* Intel DSA does not allow for selective DIF fields generation */
1869 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
1870 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1871 [ # # ]: 0 : } else if (!strcmp(module_name, "software")) {
1872 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1873 : 0 : } else {
1874 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(false);
1875 : : }
1876 : :
1877 : 0 : free_dif_generate_copy_bufs(task);
1878 : 0 : }
1879 : :
1880 : : static void
1881 : 0 : accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set(void)
1882 : : {
1883 : 0 : const char *module_name = NULL;
1884 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1885 : : struct accel_dif_request req;
1886 : 0 : struct dif_task *task = &g_dif_task;
1887 : : int rc;
1888 : :
1889 : 0 : rc = spdk_accel_get_opc_module_name(SPDK_ACCEL_OPC_DIF_GENERATE_COPY, &module_name);
1890 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1891 : :
1892 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1893 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1894 : :
1895 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1896 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1897 : :
1898 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1899 : 0 : g_block_size_bytes + g_md_size_bytes,
1900 : 0 : g_md_size_bytes, true, true,
1901 : : SPDK_DIF_TYPE1,
1902 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1903 : : SPDK_DIF_FLAGS_APPTAG_CHECK,
1904 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1905 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1906 : :
1907 : 0 : req.channel = g_channel;
1908 : 0 : req.dst_iovs = task->dst_iovs;
1909 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1910 : 0 : req.src_iovs = task->src_iovs;
1911 : 0 : req.src_iovcnt = task->src_iovcnt;
1912 : 0 : req.num_blocks = task->num_blocks;
1913 : 0 : req.ctx = &task->dif_ctx;
1914 : 0 : req.err = &task->dif_err;
1915 : 0 : req.cb_fn = accel_dif_oper_done;
1916 : 0 : req.cb_arg = task;
1917 : :
1918 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
1919 : :
1920 : : /* Intel DSA does not allow for selective DIF fields generation */
1921 [ # # ]: 0 : if (!strcmp(module_name, "dsa")) {
1922 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1923 [ # # ]: 0 : } else if (!strcmp(module_name, "software")) {
1924 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
1925 : 0 : } else {
1926 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(false);
1927 : : }
1928 : :
1929 : 0 : free_dif_generate_copy_bufs(task);
1930 : 0 : }
1931 : :
1932 : : static void
1933 : 0 : accel_dif_generate_copy_op_iovecs_len_validate(void)
1934 : : {
1935 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1936 : : struct accel_dif_request req;
1937 : 0 : struct dif_task *task = &g_dif_task;
1938 : : int rc;
1939 : :
1940 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1941 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1942 : :
1943 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1944 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1945 : :
1946 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1947 : 0 : g_block_size_bytes + g_md_size_bytes,
1948 : 0 : g_md_size_bytes, true, true,
1949 : : SPDK_DIF_TYPE1,
1950 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1951 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1952 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1953 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1954 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1955 : :
1956 : 0 : req.channel = g_channel;
1957 : 0 : req.dst_iovs = task->dst_iovs;
1958 : : /* Make iov_len param incorrect */
1959 : 0 : req.dst_iovs->iov_len -= 16;
1960 : 0 : req.dst_iovcnt = task->dst_iovcnt;
1961 : 0 : req.src_iovs = task->src_iovs;
1962 : 0 : req.src_iovcnt = task->src_iovcnt;
1963 : 0 : req.num_blocks = task->num_blocks;
1964 : 0 : req.ctx = &task->dif_ctx;
1965 : 0 : req.err = &task->dif_err;
1966 : 0 : req.cb_fn = accel_dif_oper_done;
1967 : 0 : req.cb_arg = task;
1968 : :
1969 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
1970 : 0 : CU_ASSERT_EQUAL(g_completion_success, false);
1971 : :
1972 : 0 : free_dif_generate_copy_bufs(task);
1973 : 0 : }
1974 : :
1975 : : static void
1976 : 0 : accel_dif_generate_copy_op_buf_align_validate(void)
1977 : : {
1978 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
1979 : : struct accel_dif_request req;
1980 : 0 : struct dif_task *task = &g_dif_task;
1981 : : int rc;
1982 : :
1983 : 0 : rc = alloc_dif_generate_copy_bufs(task, 1);
1984 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1985 : :
1986 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1987 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
1988 : :
1989 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
1990 : 0 : g_block_size_bytes + g_md_size_bytes,
1991 : 0 : g_md_size_bytes, true, true,
1992 : : SPDK_DIF_TYPE1,
1993 : : SPDK_DIF_FLAGS_GUARD_CHECK |
1994 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
1995 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
1996 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
1997 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
1998 : :
1999 : 0 : req.channel = g_channel;
2000 : 0 : req.dst_iovs = task->dst_iovs;
2001 : 0 : req.dst_iovcnt = task->dst_iovcnt;
2002 : 0 : req.src_iovs = task->src_iovs;
2003 : 0 : req.src_iovcnt = task->src_iovcnt;
2004 : 0 : req.num_blocks = task->num_blocks;
2005 : 0 : req.ctx = &task->dif_ctx;
2006 : 0 : req.err = &task->dif_err;
2007 : 0 : req.cb_fn = accel_dif_oper_done;
2008 : 0 : req.cb_arg = task;
2009 : :
2010 : 0 : execute_spdk_function(accel_dif_generate_copy_test, &req);
2011 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
2012 : :
2013 : 0 : free_dif_generate_copy_bufs(task);
2014 : 0 : }
2015 : :
2016 : : static void
2017 : 0 : accel_dif_generate_copy_sequence_dif_generated_do_check(uint32_t dif_flags)
2018 : : {
2019 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
2020 : : struct accel_dif_request req;
2021 : 0 : struct dif_task *task = &g_dif_task;
2022 : : struct spdk_dif_error err_blk;
2023 : : int rc;
2024 : :
2025 : 0 : rc = alloc_dif_generate_copy_sequence_bufs(task, 1);
2026 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2027 : :
2028 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2029 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2030 : :
2031 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
2032 : 0 : g_block_size_bytes + g_md_size_bytes,
2033 : 0 : g_md_size_bytes, true, true,
2034 : : SPDK_DIF_TYPE1,
2035 : : SPDK_DIF_FLAGS_GUARD_CHECK |
2036 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
2037 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
2038 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
2039 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2040 : :
2041 : 0 : req.channel = g_channel;
2042 : 0 : req.dst_iovs = task->dst_iovs;
2043 : 0 : req.dst_iovcnt = task->dst_iovcnt;
2044 : 0 : req.src_iovs = task->src_iovs;
2045 : 0 : req.src_iovcnt = task->src_iovcnt;
2046 : 0 : req.aux_iovs = task->aux_iovs;
2047 : 0 : req.aux_iovcnt = task->aux_iovcnt;
2048 : 0 : req.num_blocks = task->num_blocks;
2049 : 0 : req.ctx = &task->dif_ctx;
2050 : 0 : req.err = &task->dif_err;
2051 : 0 : req.cb_fn = accel_dif_oper_done;
2052 : 0 : req.cb_arg = task;
2053 : :
2054 : 0 : execute_spdk_function(accel_dif_generate_copy_sequence_test, &req);
2055 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
2056 : :
2057 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
2058 : 0 : g_block_size_bytes + g_md_size_bytes,
2059 : 0 : g_md_size_bytes, true, true,
2060 : : SPDK_DIF_TYPE1,
2061 : 0 : dif_flags,
2062 : : 16, 0xFFFF, 10, 0, 0, &dif_opts);
2063 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2064 : :
2065 : 0 : rc = spdk_dif_verify(req.dst_iovs, req.dst_iovcnt, req.num_blocks,
2066 : 0 : &task->dif_ctx, &err_blk);
2067 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2068 : :
2069 : 0 : free_dif_generate_copy_sequence_bufs(task);
2070 : 0 : }
2071 : :
2072 : : static void
2073 : 0 : accel_dif_generate_copy_sequence_dif_generated_guard_check(void)
2074 : : {
2075 : 0 : accel_dif_generate_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
2076 : 0 : }
2077 : :
2078 : : static void
2079 : 0 : accel_dif_generate_copy_sequence_dif_generated_apptag_check(void)
2080 : : {
2081 : 0 : accel_dif_generate_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
2082 : 0 : }
2083 : :
2084 : : static void
2085 : 0 : accel_dif_generate_copy_sequence_dif_generated_reftag_check(void)
2086 : : {
2087 : 0 : accel_dif_generate_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
2088 : 0 : }
2089 : :
2090 : : static void
2091 : 0 : accel_dif_verify_copy_sequence_dif_generated_do_check(uint32_t dif_flags)
2092 : : {
2093 : : struct spdk_dif_ctx_init_ext_opts dif_opts;
2094 : : struct accel_dif_request req;
2095 : 0 : struct dif_task *task = &g_dif_task;
2096 : : int rc;
2097 : :
2098 : 0 : rc = alloc_dif_verify_copy_bufs(task, 1);
2099 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2100 : :
2101 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2102 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2103 : :
2104 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
2105 : 0 : g_block_size_bytes + g_md_size_bytes,
2106 : 0 : g_md_size_bytes, true, true,
2107 : : SPDK_DIF_TYPE1,
2108 : : SPDK_DIF_FLAGS_GUARD_CHECK |
2109 : : SPDK_DIF_FLAGS_APPTAG_CHECK |
2110 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
2111 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
2112 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2113 : :
2114 : 0 : rc = spdk_dif_generate(task->src_iovs, task->src_iovcnt, task->num_blocks, &task->dif_ctx);
2115 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2116 : :
2117 : 0 : rc = spdk_dif_ctx_init(&task->dif_ctx,
2118 : 0 : g_block_size_bytes + g_md_size_bytes,
2119 : 0 : g_md_size_bytes, true, true,
2120 : : SPDK_DIF_TYPE1,
2121 : 0 : dif_flags,
2122 : : 10, 0xFFFF, 20, 0, 0, &dif_opts);
2123 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(rc == 0);
2124 : :
2125 : 0 : req.channel = g_channel;
2126 : 0 : req.dst_iovs = task->dst_iovs;
2127 : 0 : req.dst_iovcnt = task->dst_iovcnt;
2128 : 0 : req.src_iovs = task->src_iovs;
2129 : 0 : req.src_iovcnt = task->src_iovcnt;
2130 : 0 : req.num_blocks = task->num_blocks;
2131 : 0 : req.ctx = &task->dif_ctx;
2132 : 0 : req.err = &task->dif_err;
2133 : 0 : req.cb_fn = accel_dif_oper_done;
2134 : 0 : req.cb_arg = task;
2135 : :
2136 : 0 : execute_spdk_function(accel_dif_verify_copy_sequence_test, &req);
2137 : 0 : CU_ASSERT_EQUAL(g_completion_success, true);
2138 : :
2139 : 0 : free_dif_verify_copy_bufs(task);
2140 : 0 : }
2141 : :
2142 : : static void
2143 : 0 : accel_dif_verify_copy_sequence_dif_generated_guard_check(void)
2144 : : {
2145 : 0 : accel_dif_verify_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_GUARD_CHECK);
2146 : 0 : }
2147 : :
2148 : : static void
2149 : 0 : accel_dif_verify_copy_sequence_dif_generated_apptag_check(void)
2150 : : {
2151 : 0 : accel_dif_verify_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_APPTAG_CHECK);
2152 : 0 : }
2153 : :
2154 : : static void
2155 : 0 : accel_dif_verify_copy_sequence_dif_generated_reftag_check(void)
2156 : : {
2157 : 0 : accel_dif_verify_copy_sequence_dif_generated_do_check(SPDK_DIF_FLAGS_REFTAG_CHECK);
2158 : 0 : }
2159 : :
2160 : : static void
2161 : 0 : _stop_init_thread(void *arg)
2162 : : {
2163 : 0 : unsigned num_failures = g_num_failures;
2164 : :
2165 : 0 : g_num_failures = 0;
2166 : :
2167 [ # # ]: 0 : assert(spdk_get_thread() == g_thread[WORKER_UT]);
2168 [ # # ]: 0 : assert(spdk_thread_is_app_thread(NULL));
2169 : 0 : execute_spdk_function(exit_io_thread, NULL);
2170 : 0 : spdk_app_stop(num_failures);
2171 : 0 : }
2172 : :
2173 : : static void
2174 : 0 : stop_init_thread(unsigned num_failures, struct spdk_jsonrpc_request *request)
2175 : : {
2176 : 0 : g_num_failures = num_failures;
2177 : :
2178 : 0 : spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, request);
2179 : 0 : }
2180 : :
2181 : : static int
2182 : 0 : setup_accel_tests(void)
2183 : : {
2184 : 0 : unsigned rc = 0;
2185 : 0 : CU_pSuite suite = NULL;
2186 : :
2187 : 0 : suite = CU_add_suite("accel_dif", NULL, NULL);
2188 [ # # ]: 0 : if (suite == NULL) {
2189 : 0 : CU_cleanup_registry();
2190 : 0 : rc = CU_get_error();
2191 : 0 : return -rc;
2192 : : }
2193 : :
2194 [ # # ]: 0 : if (CU_add_test(suite, "verify: DIF generated, GUARD check",
2195 [ # # ]: 0 : accel_dif_verify_op_dif_generated_guard_check) == NULL ||
2196 : 0 : CU_add_test(suite, "verify: DIX generated, GUARD check",
2197 [ # # ]: 0 : accel_dix_verify_op_dix_generated_guard_check) == NULL ||
2198 : 0 : CU_add_test(suite, "verify: DIF generated, APPTAG check",
2199 [ # # ]: 0 : accel_dif_verify_op_dif_generated_apptag_check) == NULL ||
2200 : 0 : CU_add_test(suite, "verify: DIX generated, APPTAG check",
2201 [ # # ]: 0 : accel_dix_verify_op_dix_generated_apptag_check) == NULL ||
2202 : 0 : CU_add_test(suite, "verify: DIF generated, REFTAG check",
2203 [ # # ]: 0 : accel_dif_verify_op_dif_generated_reftag_check) == NULL ||
2204 : 0 : CU_add_test(suite, "verify: DIX generated, REFTAG check",
2205 [ # # ]: 0 : accel_dix_verify_op_dix_generated_reftag_check) == NULL ||
2206 : 0 : CU_add_test(suite, "verify: DIX generated, all flags check",
2207 [ # # ]: 0 : accel_dix_verify_op_dix_generated_all_flags_check) == NULL ||
2208 : :
2209 : 0 : CU_add_test(suite, "verify: DIF not generated, GUARD check",
2210 [ # # ]: 0 : accel_dif_verify_op_dif_not_generated_guard_check) == NULL ||
2211 : 0 : CU_add_test(suite, "verify: DIX not generated, GUARD check",
2212 [ # # ]: 0 : accel_dix_verify_op_dix_not_generated_guard_check) == NULL ||
2213 : 0 : CU_add_test(suite, "verify: DIF not generated, APPTAG check",
2214 [ # # ]: 0 : accel_dif_verify_op_dif_not_generated_apptag_check) == NULL ||
2215 : 0 : CU_add_test(suite, "verify: DIX not generated, APPTAG check",
2216 [ # # ]: 0 : accel_dix_verify_op_dix_not_generated_apptag_check) == NULL ||
2217 : 0 : CU_add_test(suite, "verify: DIF not generated, REFTAG check",
2218 [ # # ]: 0 : accel_dif_verify_op_dif_not_generated_reftag_check) == NULL ||
2219 : 0 : CU_add_test(suite, "verify: DIX not generated, REFTAG check",
2220 [ # # ]: 0 : accel_dix_verify_op_dix_not_generated_reftag_check) == NULL ||
2221 : 0 : CU_add_test(suite, "verify: DIX not generated, all flags check",
2222 [ # # ]: 0 : accel_dix_verify_op_dix_not_generated_all_flags_check) == NULL ||
2223 : 0 : CU_add_test(suite, "verify: DIX guard not generated, all flags check",
2224 [ # # ]: 0 : accel_dix_verify_op_dix_guard_not_generated_all_flags_check) == NULL ||
2225 : 0 : CU_add_test(suite, "verify: DIX apptag not generated, all flags check",
2226 [ # # ]: 0 : accel_dix_verify_op_dix_apptag_not_generated_all_flags_check) == NULL ||
2227 : 0 : CU_add_test(suite, "verify: DIX reftag not generated, all flags check",
2228 [ # # ]: 0 : accel_dix_verify_op_dix_reftag_not_generated_all_flags_check) == NULL ||
2229 : :
2230 : 0 : CU_add_test(suite, "verify: DIF APPTAG correct, APPTAG check",
2231 [ # # ]: 0 : accel_dif_verify_op_apptag_correct_apptag_check) == NULL ||
2232 : 0 : CU_add_test(suite, "verify: DIX APPTAG correct, APPTAG check",
2233 [ # # ]: 0 : accel_dix_verify_op_apptag_correct_apptag_check) == NULL ||
2234 : 0 : CU_add_test(suite, "verify: DIF APPTAG incorrect, APPTAG check",
2235 [ # # ]: 0 : accel_dif_verify_op_apptag_incorrect_apptag_check) == NULL ||
2236 : 0 : CU_add_test(suite, "verify: DIX APPTAG incorrect, APPTAG check",
2237 [ # # ]: 0 : accel_dix_verify_op_apptag_incorrect_apptag_check) == NULL ||
2238 : 0 : CU_add_test(suite, "verify: DIF APPTAG incorrect, no APPTAG check",
2239 [ # # ]: 0 : accel_dif_verify_op_apptag_incorrect_no_apptag_check) == NULL ||
2240 : 0 : CU_add_test(suite, "verify: DIX APPTAG incorrect, no APPTAG check",
2241 [ # # ]: 0 : accel_dix_verify_op_apptag_incorrect_no_apptag_check) == NULL ||
2242 : 0 : CU_add_test(suite, "verify: DIF REFTAG incorrect, REFTAG ignore",
2243 [ # # ]: 0 : accel_dif_verify_op_reftag_incorrect_reftag_ignore) == NULL ||
2244 : 0 : CU_add_test(suite, "verify: DIX REFTAG incorrect, REFTAG ignore",
2245 [ # # ]: 0 : accel_dix_verify_op_reftag_incorrect_reftag_ignore) == NULL ||
2246 : :
2247 : 0 : CU_add_test(suite, "verify: DIF REFTAG_INIT correct, REFTAG check",
2248 [ # # ]: 0 : accel_dif_verify_op_reftag_init_correct_reftag_check) == NULL ||
2249 : 0 : CU_add_test(suite, "verify: DIX REFTAG_INIT correct, REFTAG check",
2250 [ # # ]: 0 : accel_dix_verify_op_reftag_init_correct_reftag_check) == NULL ||
2251 : 0 : CU_add_test(suite, "verify: DIF REFTAG_INIT incorrect, REFTAG check",
2252 [ # # ]: 0 : accel_dif_verify_op_reftag_init_incorrect_reftag_check) == NULL ||
2253 : 0 : CU_add_test(suite, "verify: DIX REFTAG_INIT incorrect, REFTAG check",
2254 [ # # ]: 0 : accel_dix_verify_op_reftag_init_incorrect_reftag_check) == NULL ||
2255 : :
2256 : 0 : CU_add_test(suite, "verify copy: DIF generated, GUARD check",
2257 [ # # ]: 0 : accel_dif_verify_copy_op_dif_generated_guard_check) == NULL ||
2258 : 0 : CU_add_test(suite, "verify copy: DIF generated, APPTAG check",
2259 [ # # ]: 0 : accel_dif_verify_copy_op_dif_generated_apptag_check) == NULL ||
2260 : 0 : CU_add_test(suite, "verify copy: DIF generated, REFTAG check",
2261 [ # # ]: 0 : accel_dif_verify_copy_op_dif_generated_reftag_check) == NULL ||
2262 : :
2263 : 0 : CU_add_test(suite, "verify copy: DIF not generated, GUARD check",
2264 [ # # ]: 0 : accel_dif_verify_copy_op_dif_not_generated_guard_check) == NULL ||
2265 : 0 : CU_add_test(suite, "verify copy: DIF not generated, APPTAG check",
2266 [ # # ]: 0 : accel_dif_verify_copy_op_dif_not_generated_apptag_check) == NULL ||
2267 : 0 : CU_add_test(suite, "verify copy: DIF not generated, REFTAG check",
2268 [ # # ]: 0 : accel_dif_verify_copy_op_dif_not_generated_reftag_check) == NULL ||
2269 : :
2270 : 0 : CU_add_test(suite, "generate copy: DIF generated, GUARD check",
2271 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_guard_check) == NULL ||
2272 : 0 : CU_add_test(suite, "generate copy: DIF generated, APTTAG check",
2273 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_apptag_check) == NULL ||
2274 : 0 : CU_add_test(suite, "generate copy: DIF generated, REFTAG check",
2275 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_reftag_check) == NULL ||
2276 : :
2277 : 0 : CU_add_test(suite, "generate: DIX generated, GUARD check",
2278 [ # # ]: 0 : accel_dix_generate_op_dix_generated_guard_check) == NULL ||
2279 : 0 : CU_add_test(suite, "generate: DIX generated, APTTAG check",
2280 [ # # ]: 0 : accel_dix_generate_op_dix_generated_apptag_check) == NULL ||
2281 : 0 : CU_add_test(suite, "generate: DIX generated, REFTAG check",
2282 [ # # ]: 0 : accel_dix_generate_op_dix_generated_reftag_check) == NULL ||
2283 : :
2284 : 0 : CU_add_test(suite, "generate copy: DIF generated, no GUARD check flag set",
2285 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_no_guard_check_flag_set) == NULL ||
2286 : 0 : CU_add_test(suite, "generate copy: DIF generated, no APPTAG check flag set",
2287 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_no_apptag_check_flag_set) == NULL ||
2288 : 0 : CU_add_test(suite, "generate copy: DIF generated, no REFTAG check flag set",
2289 [ # # ]: 0 : accel_dif_generate_copy_op_dif_generated_no_reftag_check_flag_set) == NULL ||
2290 : :
2291 : 0 : CU_add_test(suite, "generate copy: DIF iovecs-len validate",
2292 [ # # ]: 0 : accel_dif_generate_copy_op_iovecs_len_validate) == NULL ||
2293 : 0 : CU_add_test(suite, "generate copy: DIF buffer alignment validate",
2294 [ # # ]: 0 : accel_dif_generate_copy_op_buf_align_validate) == NULL ||
2295 : :
2296 : 0 : CU_add_test(suite, "generate copy sequence: DIF generated, GUARD check",
2297 [ # # ]: 0 : accel_dif_generate_copy_sequence_dif_generated_guard_check) == NULL ||
2298 : 0 : CU_add_test(suite, "generate copy sequence: DIF generated, APTTAG check",
2299 [ # # ]: 0 : accel_dif_generate_copy_sequence_dif_generated_apptag_check) == NULL ||
2300 : 0 : CU_add_test(suite, "generate copy sequence: DIF generated, REFTAG check",
2301 [ # # ]: 0 : accel_dif_generate_copy_sequence_dif_generated_reftag_check) == NULL ||
2302 : 0 : CU_add_test(suite, "verify copy sequence: DIF generated, GUARD check",
2303 [ # # ]: 0 : accel_dif_verify_copy_sequence_dif_generated_guard_check) == NULL ||
2304 : 0 : CU_add_test(suite, "verify copy sequence: DIF generated, APPTAG check",
2305 [ # # ]: 0 : accel_dif_verify_copy_sequence_dif_generated_apptag_check) == NULL ||
2306 : 0 : CU_add_test(suite, "verify copy sequence: DIF generated, REFTAG check",
2307 : 0 : accel_dif_verify_copy_sequence_dif_generated_reftag_check) == NULL) {
2308 : 0 : CU_cleanup_registry();
2309 : 0 : rc = CU_get_error();
2310 : 0 : return -rc;
2311 : : }
2312 : 0 : return 0;
2313 : 0 : }
2314 : :
2315 : : static void
2316 : 0 : get_io_channel(void *arg)
2317 : : {
2318 : 0 : g_channel = spdk_accel_get_io_channel();
2319 [ # # ]: 0 : assert(g_channel);
2320 : 0 : wake_ut_thread();
2321 : 0 : }
2322 : :
2323 : : static void
2324 : 0 : put_io_channel(void *arg)
2325 : : {
2326 [ # # ]: 0 : assert(g_channel);
2327 : 0 : spdk_put_io_channel(g_channel);
2328 : 0 : wake_ut_thread();
2329 : 0 : }
2330 : :
2331 : : static void
2332 : 0 : run_accel_test_thread(void *arg)
2333 : : {
2334 : 0 : struct spdk_jsonrpc_request *request = arg;
2335 : 0 : int rc = 0;
2336 : :
2337 : 0 : execute_spdk_function(get_io_channel, NULL);
2338 [ # # ]: 0 : if (g_channel == NULL) {
2339 : 0 : fprintf(stderr, "Unable to get an accel channel\n");
2340 : 0 : goto ret;
2341 : : }
2342 : :
2343 [ # # ]: 0 : if (CU_initialize_registry() != CUE_SUCCESS) {
2344 : : /* CUnit error, probably won't recover */
2345 : 0 : rc = CU_get_error();
2346 : 0 : rc = -rc;
2347 : 0 : goto ret;
2348 : : }
2349 : :
2350 : 0 : rc = setup_accel_tests();
2351 [ # # ]: 0 : if (rc < 0) {
2352 : : /* CUnit error, probably won't recover */
2353 : 0 : rc = -rc;
2354 : 0 : goto ret;
2355 : : }
2356 : 0 : CU_basic_set_mode(CU_BRM_VERBOSE);
2357 : 0 : CU_basic_run_tests();
2358 : 0 : rc = CU_get_number_of_failures();
2359 : 0 : CU_cleanup_registry();
2360 : :
2361 : : ret:
2362 [ # # ]: 0 : if (g_channel != NULL) {
2363 : 0 : execute_spdk_function(put_io_channel, NULL);
2364 : 0 : }
2365 : 0 : stop_init_thread(rc, request);
2366 : 0 : }
2367 : :
2368 : : static void
2369 : 0 : accel_dif_test_main(void *arg1)
2370 : : {
2371 : 0 : struct spdk_cpuset tmpmask = {};
2372 : : uint32_t i;
2373 : :
2374 : 0 : pthread_mutex_init(&g_test_mutex, NULL);
2375 : 0 : pthread_cond_init(&g_test_cond, NULL);
2376 : :
2377 : : /* This test runs specifically on at least two cores.
2378 : : * g_thread[WORKER_UT] is the app_thread on main core from event framework.
2379 : : * Next one is only for the tests and should always be on separate CPU cores. */
2380 [ # # ]: 0 : if (spdk_env_get_core_count() < 3) {
2381 : 0 : spdk_app_stop(-1);
2382 : 0 : return;
2383 : : }
2384 : :
2385 [ # # ]: 0 : SPDK_ENV_FOREACH_CORE(i) {
2386 [ # # ]: 0 : if (i == spdk_env_get_current_core()) {
2387 : 0 : g_thread[WORKER_UT] = spdk_get_thread();
2388 : 0 : continue;
2389 : : }
2390 : 0 : spdk_cpuset_zero(&tmpmask);
2391 : 0 : spdk_cpuset_set_cpu(&tmpmask, i, true);
2392 [ # # ]: 0 : if (g_thread[WORKER_IO] == NULL) {
2393 : 0 : g_thread[WORKER_IO] = spdk_thread_create("io_thread", &tmpmask);
2394 : 0 : }
2395 : :
2396 : 0 : }
2397 : :
2398 : 0 : spdk_thread_send_msg(g_thread[WORKER_UT], run_accel_test_thread, NULL);
2399 : 0 : }
2400 : :
2401 : : static void
2402 : 0 : accel_dif_usage(void)
2403 : : {
2404 : 0 : }
2405 : :
2406 : : static int
2407 : 0 : accel_dif_parse_arg(int ch, char *arg)
2408 : : {
2409 : 0 : return 0;
2410 : : }
2411 : :
2412 : : static void
2413 : 0 : spdk_dif_shutdown_cb(void)
2414 : : {
2415 : 0 : g_shutdown = true;
2416 : 0 : spdk_thread_send_msg(g_thread[WORKER_UT], _stop_init_thread, NULL);
2417 : 0 : }
2418 : :
2419 : : int
2420 : 0 : main(int argc, char **argv)
2421 : : {
2422 : 0 : struct spdk_app_opts opts = {};
2423 : : char reactor_mask[8];
2424 : : int rc;
2425 : :
2426 : 0 : spdk_app_opts_init(&opts, sizeof(opts));
2427 : 0 : opts.name = "DIF";
2428 : 0 : snprintf(reactor_mask, sizeof(reactor_mask), "0x%x", (1 << (SPDK_COUNTOF(g_thread) + 1)) - 1);
2429 : 0 : opts.reactor_mask = reactor_mask;
2430 : 0 : opts.shutdown_cb = spdk_dif_shutdown_cb;
2431 : 0 : opts.rpc_addr = NULL;
2432 : :
2433 [ # # # # ]: 0 : if ((rc = spdk_app_parse_args(argc, argv, &opts, "", NULL,
2434 : 0 : accel_dif_parse_arg, accel_dif_usage)) !=
2435 : : SPDK_APP_PARSE_ARGS_SUCCESS) {
2436 : 0 : return rc;
2437 : : }
2438 : :
2439 : 0 : rc = spdk_app_start(&opts, accel_dif_test_main, NULL);
2440 : 0 : spdk_app_fini();
2441 : :
2442 : 0 : return rc;
2443 : 0 : }
|