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