Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2019 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : :
8 : : #include "spdk_internal/cunit.h"
9 : :
10 : : #include "util/dif.c"
11 : :
12 : : #define DATA_PATTERN(offset) ((uint8_t)(0xAB + (offset)))
13 : : #define GUARD_SEED 0xCD
14 : :
15 : : static int
16 : 2165 : ut_data_pattern_generate(struct iovec *iovs, int iovcnt,
17 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks)
18 : : {
19 : 1732 : struct _dif_sgl sgl;
20 : 1732 : uint32_t offset_blocks, offset_in_block, buf_len, data_offset, i;
21 : 1732 : uint8_t *buf;
22 : :
23 : 2165 : _dif_sgl_init(&sgl, iovs, iovcnt);
24 : :
25 [ - + ]: 2165 : if (!_dif_sgl_is_valid(&sgl, block_size * num_blocks)) {
26 : 0 : return -1;
27 : : }
28 : :
29 : 2165 : offset_blocks = 0;
30 : 2165 : data_offset = 0;
31 : :
32 [ + + ]: 11505 : while (offset_blocks < num_blocks) {
33 : 9340 : offset_in_block = 0;
34 [ + + ]: 24620 : while (offset_in_block < block_size) {
35 : 15280 : _dif_sgl_get_buf(&sgl, (void *)&buf, &buf_len);
36 [ + + ]: 15280 : if (offset_in_block < block_size - md_size) {
37 : 10405 : buf_len = spdk_min(buf_len,
38 : : block_size - md_size - offset_in_block);
39 [ + + ]: 34754725 : for (i = 0; i < buf_len; i++) {
40 : 34744320 : buf[i] = DATA_PATTERN(data_offset + i);
41 : : }
42 : 10405 : data_offset += buf_len;
43 : : } else {
44 : 4875 : buf_len = spdk_min(buf_len, block_size - offset_in_block);
45 [ - + ]: 4875 : memset(buf, 0, buf_len);
46 : : }
47 : 15280 : _dif_sgl_advance(&sgl, buf_len);
48 : 15280 : offset_in_block += buf_len;
49 : : }
50 : 9340 : offset_blocks++;
51 : : }
52 : :
53 : 2165 : return 0;
54 : : }
55 : :
56 : : static int
57 : 1590 : ut_data_pattern_verify(struct iovec *iovs, int iovcnt,
58 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks)
59 : : {
60 : 1272 : struct _dif_sgl sgl;
61 : 1272 : uint32_t offset_blocks, offset_in_block, buf_len, data_offset, i;
62 : 1272 : uint8_t *buf;
63 : :
64 : 1590 : _dif_sgl_init(&sgl, iovs, iovcnt);
65 : :
66 [ - + ]: 1590 : if (!_dif_sgl_is_valid(&sgl, block_size * num_blocks)) {
67 : 0 : return -1;
68 : : }
69 : :
70 : 1590 : offset_blocks = 0;
71 : 1590 : data_offset = 0;
72 : :
73 [ + + ]: 7445 : while (offset_blocks < num_blocks) {
74 : 6035 : offset_in_block = 0;
75 [ + + ]: 16516 : while (offset_in_block < block_size) {
76 : 10661 : _dif_sgl_get_buf(&sgl, (void *)&buf, &buf_len);
77 : :
78 [ + + ]: 10661 : if (offset_in_block < block_size - md_size) {
79 : 6531 : buf_len = spdk_min(buf_len,
80 : : block_size - md_size - offset_in_block);
81 [ + + ]: 20942803 : for (i = 0; i < buf_len; i++) {
82 [ + + ]: 20936452 : if (buf[i] != DATA_PATTERN(data_offset + i)) {
83 : 180 : return -1;
84 : : }
85 : : }
86 : 6351 : data_offset += buf_len;
87 : : } else {
88 : 4130 : buf_len = spdk_min(buf_len, block_size - offset_in_block);
89 : : }
90 : 10481 : _dif_sgl_advance(&sgl, buf_len);
91 : 10481 : offset_in_block += buf_len;
92 : : }
93 : 5855 : offset_blocks++;
94 : : }
95 : :
96 : 1410 : return 0;
97 : : }
98 : :
99 : : static void
100 : 1535 : _iov_alloc_buf(struct iovec *iov, uint32_t len)
101 : : {
102 : 1535 : iov->iov_base = calloc(1, len);
103 : 1535 : iov->iov_len = len;
104 [ - + ]: 1535 : SPDK_CU_ASSERT_FATAL(iov->iov_base != NULL);
105 : 1535 : }
106 : :
107 : : static void
108 : 1535 : _iov_free_buf(struct iovec *iov)
109 : : {
110 : 1535 : free(iov->iov_base);
111 : 1535 : }
112 : :
113 : : static void
114 : 335 : _iov_set_buf(struct iovec *iov, uint8_t *buf, uint32_t buf_len)
115 : : {
116 : 335 : iov->iov_base = buf;
117 : 335 : iov->iov_len = buf_len;
118 : 335 : }
119 : :
120 : : static bool
121 : 535 : _iov_check(struct iovec *iov, void *iov_base, uint32_t iov_len)
122 : : {
123 [ + - + - ]: 535 : return (iov->iov_base == iov_base && iov->iov_len == iov_len);
124 : : }
125 : :
126 : : static uint64_t
127 : 165 : _generate_guard(uint64_t guard_seed, void *buf, size_t buf_len,
128 : : enum spdk_dif_pi_format dif_pi_format)
129 : : {
130 : : uint64_t guard;
131 : :
132 [ + + ]: 165 : if (dif_pi_format == SPDK_DIF_PI_FORMAT_16) {
133 : 55 : guard = (uint64_t)spdk_crc16_t10dif((uint16_t)guard_seed, buf, buf_len);
134 [ + + ]: 110 : } else if (dif_pi_format == SPDK_DIF_PI_FORMAT_32) {
135 : 55 : guard = (uint64_t)spdk_crc32c_nvme(buf, buf_len, guard_seed);
136 : : } else {
137 : 55 : guard = spdk_crc64_nvme(buf, buf_len, guard_seed);
138 : : }
139 : :
140 : 165 : return guard;
141 : : }
142 : :
143 : : static void
144 : 105 : _dif_generate_and_verify(struct iovec *iov,
145 : : uint32_t block_size, uint32_t md_size, bool dif_loc,
146 : : enum spdk_dif_type dif_type, uint32_t dif_flags,
147 : : enum spdk_dif_pi_format dif_pi_format,
148 : : uint64_t ref_tag, uint64_t e_ref_tag,
149 : : uint16_t app_tag, uint16_t apptag_mask, uint16_t e_app_tag,
150 : : bool expect_pass)
151 : : {
152 : 105 : struct spdk_dif_ctx ctx = {};
153 : : uint32_t guard_interval;
154 : 105 : uint64_t guard = 0;
155 : : int rc;
156 : :
157 : 105 : rc = ut_data_pattern_generate(iov, 1, block_size, md_size, 1);
158 : 105 : CU_ASSERT(rc == 0);
159 : :
160 : 105 : ctx.dif_pi_format = dif_pi_format;
161 : :
162 : 105 : guard_interval = _get_guard_interval(block_size, md_size, dif_loc, true,
163 : 105 : _dif_size(ctx.dif_pi_format));
164 : :
165 : 105 : ctx.dif_type = dif_type;
166 : 105 : ctx.dif_flags = dif_flags;
167 : 105 : ctx.init_ref_tag = ref_tag;
168 : 105 : ctx.app_tag = app_tag;
169 : :
170 [ + - ]: 105 : if (dif_flags & SPDK_DIF_FLAGS_GUARD_CHECK) {
171 : 105 : guard = _generate_guard(0, iov->iov_base, guard_interval, ctx.dif_pi_format);
172 : : }
173 : 105 : _dif_generate(iov->iov_base + guard_interval, guard, 0, &ctx);
174 : :
175 : 105 : ctx.init_ref_tag = e_ref_tag;
176 : 105 : ctx.apptag_mask = apptag_mask;
177 : 105 : ctx.app_tag = e_app_tag;
178 : :
179 : 105 : rc = _dif_verify(iov->iov_base + guard_interval, guard, 0, &ctx, NULL);
180 [ + + - + : 105 : CU_ASSERT((expect_pass && rc == 0) || (!expect_pass && rc != 0));
+ - + - ]
181 : :
182 : 105 : rc = ut_data_pattern_verify(iov, 1, block_size, md_size, 1);
183 : 105 : CU_ASSERT(rc == 0);
184 : 105 : }
185 : :
186 : : static void
187 : 5 : dif_generate_and_verify_test(void)
188 : : {
189 : 4 : struct iovec iov;
190 : : uint32_t dif_flags;
191 : :
192 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
193 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
194 : :
195 : 5 : _iov_alloc_buf(&iov, 4096 + 128);
196 : :
197 : : /* Positive cases */
198 : :
199 : : /* The case that DIF is contained in the first 8/16 bytes of metadata. */
200 : 5 : _dif_generate_and_verify(&iov,
201 : : 4096 + 128, 128, true,
202 : : SPDK_DIF_TYPE1, dif_flags,
203 : : SPDK_DIF_PI_FORMAT_16,
204 : : 22, 22,
205 : : 0x22, 0xFFFF, 0x22,
206 : : true);
207 : :
208 : 5 : _dif_generate_and_verify(&iov,
209 : : 4096 + 128, 128, true,
210 : : SPDK_DIF_TYPE1, dif_flags,
211 : : SPDK_DIF_PI_FORMAT_32,
212 : : 22, 22,
213 : : 0x22, 0xFFFF, 0x22,
214 : : true);
215 : :
216 : 5 : _dif_generate_and_verify(&iov,
217 : : 4096 + 128, 128, true,
218 : : SPDK_DIF_TYPE1, dif_flags,
219 : : SPDK_DIF_PI_FORMAT_64,
220 : : 22, 22,
221 : : 0x22, 0xFFFF, 0x22,
222 : : true);
223 : :
224 : : /* The case that DIF is contained in the last 8/16 bytes of metadata. */
225 : 5 : _dif_generate_and_verify(&iov,
226 : : 4096 + 128, 128, false,
227 : : SPDK_DIF_TYPE1, dif_flags,
228 : : SPDK_DIF_PI_FORMAT_16,
229 : : 22, 22,
230 : : 0x22, 0xFFFF, 0x22,
231 : : true);
232 : :
233 : 5 : _dif_generate_and_verify(&iov,
234 : : 4096 + 128, 128, false,
235 : : SPDK_DIF_TYPE1, dif_flags,
236 : : SPDK_DIF_PI_FORMAT_32,
237 : : 22, 22,
238 : : 0x22, 0xFFFF, 0x22,
239 : : true);
240 : :
241 : 5 : _dif_generate_and_verify(&iov,
242 : : 4096 + 128, 128, false,
243 : : SPDK_DIF_TYPE1, dif_flags,
244 : : SPDK_DIF_PI_FORMAT_64,
245 : : 22, 22,
246 : : 0x22, 0xFFFF, 0x22,
247 : : true);
248 : :
249 : : /* Negative cases */
250 : :
251 : : /* Reference tag doesn't match. */
252 : 5 : _dif_generate_and_verify(&iov,
253 : : 4096 + 128, 128, false,
254 : : SPDK_DIF_TYPE1, dif_flags,
255 : : SPDK_DIF_PI_FORMAT_16,
256 : : 22, 23,
257 : : 0x22, 0xFFFF, 0x22,
258 : : false);
259 : :
260 : 5 : _dif_generate_and_verify(&iov,
261 : : 4096 + 128, 128, false,
262 : : SPDK_DIF_TYPE1, dif_flags,
263 : : SPDK_DIF_PI_FORMAT_32,
264 : : 22, 23,
265 : : 0x22, 0xFFFF, 0x22,
266 : : false);
267 : :
268 : 5 : _dif_generate_and_verify(&iov,
269 : : 4096 + 128, 128, false,
270 : : SPDK_DIF_TYPE1, dif_flags,
271 : : SPDK_DIF_PI_FORMAT_64,
272 : : 22, 23,
273 : : 0x22, 0xFFFF, 0x22,
274 : : false);
275 : :
276 : : /* Application tag doesn't match. */
277 : 5 : _dif_generate_and_verify(&iov,
278 : : 4096 + 128, 128, false,
279 : : SPDK_DIF_TYPE1, dif_flags,
280 : : SPDK_DIF_PI_FORMAT_16,
281 : : 22, 22,
282 : : 0x22, 0xFFFF, 0x23,
283 : : false);
284 : :
285 : 5 : _dif_generate_and_verify(&iov,
286 : : 4096 + 128, 128, false,
287 : : SPDK_DIF_TYPE1, dif_flags,
288 : : SPDK_DIF_PI_FORMAT_32,
289 : : 22, 22,
290 : : 0x22, 0xFFFF, 0x23,
291 : : false);
292 : :
293 : 5 : _dif_generate_and_verify(&iov,
294 : : 4096 + 128, 128, false,
295 : : SPDK_DIF_TYPE1, dif_flags,
296 : : SPDK_DIF_PI_FORMAT_64,
297 : : 22, 22,
298 : : 0x22, 0xFFFF, 0x23,
299 : : false);
300 : :
301 : 5 : _iov_free_buf(&iov);
302 : 5 : }
303 : :
304 : : static void
305 : 5 : dif_disable_check_test(void)
306 : : {
307 : 4 : struct iovec iov;
308 : : uint32_t dif_flags;
309 : :
310 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
311 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
312 : :
313 : 5 : _iov_alloc_buf(&iov, 4096 + 128);
314 : :
315 : : /* The case that DIF check is disabled when the Application Tag is 0xFFFF for
316 : : * Type 1. DIF check is disabled and pass is expected.
317 : : */
318 : 5 : _dif_generate_and_verify(&iov,
319 : : 4096 + 128, 128, false,
320 : : SPDK_DIF_TYPE1, dif_flags,
321 : : SPDK_DIF_PI_FORMAT_16,
322 : : 22, 22,
323 : : 0xFFFF, 0xFFFF, 0x22,
324 : : true);
325 : :
326 : 5 : _dif_generate_and_verify(&iov,
327 : : 4096 + 128, 128, false,
328 : : SPDK_DIF_TYPE1, dif_flags,
329 : : SPDK_DIF_PI_FORMAT_32,
330 : : 22, 22,
331 : : 0xFFFF, 0xFFFF, 0x22,
332 : : true);
333 : :
334 : 5 : _dif_generate_and_verify(&iov,
335 : : 4096 + 128, 128, false,
336 : : SPDK_DIF_TYPE1, dif_flags,
337 : : SPDK_DIF_PI_FORMAT_64,
338 : : 22, 22,
339 : : 0xFFFF, 0xFFFF, 0x22,
340 : : true);
341 : :
342 : : /* The case that DIF check is not disabled when the Application Tag is 0xFFFF but
343 : : * the Reference Tag is not 0xFFFFFFFF for Type 3. DIF check is not disabled and
344 : : * fail is expected.
345 : : */
346 : 5 : _dif_generate_and_verify(&iov,
347 : : 4096 + 128, 128, false,
348 : : SPDK_DIF_TYPE3, dif_flags,
349 : : SPDK_DIF_PI_FORMAT_16,
350 : : 22, 22,
351 : : 0xFFFF, 0xFFFF, 0x22,
352 : : false);
353 : :
354 : 5 : _dif_generate_and_verify(&iov,
355 : : 4096 + 128, 128, false,
356 : : SPDK_DIF_TYPE3, dif_flags,
357 : : SPDK_DIF_PI_FORMAT_32,
358 : : 22, 22,
359 : : 0xFFFF, 0xFFFF, 0x22,
360 : : false);
361 : :
362 : 5 : _dif_generate_and_verify(&iov,
363 : : 4096 + 128, 128, false,
364 : : SPDK_DIF_TYPE3, dif_flags,
365 : : SPDK_DIF_PI_FORMAT_64,
366 : : 22, 22,
367 : : 0xFFFF, 0xFFFF, 0x22,
368 : : false);
369 : :
370 : : /* The case that DIF check is disabled when the Application Tag is 0xFFFF and
371 : : * the Reference Tag is 0xFFFFFFFF for Type 3. DIF check is disabled and
372 : : * pass is expected.
373 : : */
374 : 5 : _dif_generate_and_verify(&iov,
375 : : 4096 + 128, 128, false,
376 : : SPDK_DIF_TYPE3, dif_flags,
377 : : SPDK_DIF_PI_FORMAT_16,
378 : : 0xFFFFFFFF, 22,
379 : : 0xFFFF, 0xFFFF, 0x22,
380 : : true);
381 : :
382 : 5 : _dif_generate_and_verify(&iov,
383 : : 4096 + 128, 128, false,
384 : : SPDK_DIF_TYPE3, dif_flags,
385 : : SPDK_DIF_PI_FORMAT_32,
386 : : 0xFFFFFFFFFFFFFFFF, 22,
387 : : 0xFFFF, 0xFFFF, 0x22,
388 : : true);
389 : :
390 : 5 : _dif_generate_and_verify(&iov,
391 : : 4096 + 128, 128, false,
392 : : SPDK_DIF_TYPE3, dif_flags,
393 : : SPDK_DIF_PI_FORMAT_64,
394 : : 0xFFFFFFFFFFFFFFFF, 22,
395 : : 0xFFFF, 0xFFFF, 0x22,
396 : : true);
397 : :
398 : 5 : _iov_free_buf(&iov);
399 : 5 : }
400 : :
401 : : static void
402 : 55 : _dif_generate_and_verify_different_pi_format(uint32_t dif_flags,
403 : : enum spdk_dif_pi_format dif_pi_format_1, enum spdk_dif_pi_format dif_pi_format_2)
404 : : {
405 : 55 : struct spdk_dif_ctx ctx_1 = {}, ctx_2 = {};
406 : : int rc;
407 : 44 : struct spdk_dif_ctx_init_ext_opts dif_opts;
408 : 44 : struct iovec iov;
409 : 55 : struct spdk_dif_error err_blk = {};
410 : 55 : uint8_t expected_err_type = 0;
411 : :
412 [ + + ]: 55 : if (dif_flags & SPDK_DIF_FLAGS_GUARD_CHECK) {
413 : 20 : expected_err_type = SPDK_DIF_GUARD_ERROR;
414 [ + + ]: 35 : } else if (dif_flags & SPDK_DIF_FLAGS_APPTAG_CHECK) {
415 : 20 : expected_err_type = SPDK_DIF_APPTAG_ERROR;
416 [ + - ]: 15 : } else if (dif_flags & SPDK_DIF_FLAGS_REFTAG_CHECK) {
417 : 15 : expected_err_type = SPDK_DIF_REFTAG_ERROR;
418 : : } else {
419 : 0 : CU_ASSERT(false);
420 : : }
421 : :
422 : 55 : CU_ASSERT(dif_pi_format_1 != dif_pi_format_2);
423 : :
424 : 55 : _iov_alloc_buf(&iov, 4096 + 128);
425 : :
426 : 55 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
427 : 55 : CU_ASSERT(rc == 0);
428 : :
429 : 55 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
430 : 55 : dif_opts.dif_pi_format = dif_pi_format_1;
431 : 55 : rc = spdk_dif_ctx_init(&ctx_1, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
432 : : 12, 0xFFFF, 23, 0, 0, &dif_opts);
433 : 55 : CU_ASSERT(rc == 0);
434 : :
435 : 55 : rc = spdk_dif_generate(&iov, 1, 1, &ctx_1);
436 : 55 : CU_ASSERT(rc == 0);
437 : :
438 : 55 : dif_opts.dif_pi_format = dif_pi_format_2;
439 : 55 : rc = spdk_dif_ctx_init(&ctx_2, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
440 : : 12, 0xFFFF, 23, 0, 0, &dif_opts);
441 : 55 : CU_ASSERT(rc == 0);
442 : :
443 : 55 : rc = spdk_dif_verify(&iov, 1, 1, &ctx_2, &err_blk);
444 : 55 : CU_ASSERT(rc != 0);
445 : 55 : CU_ASSERT(err_blk.err_type == expected_err_type);
446 : :
447 : 55 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 1);
448 : 55 : CU_ASSERT(rc == 0);
449 : :
450 : 55 : _iov_free_buf(&iov);
451 : 55 : }
452 : :
453 : : static void
454 : 5 : dif_generate_and_verify_different_pi_formats_test(void)
455 : : {
456 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_GUARD_CHECK,
457 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_32);
458 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_GUARD_CHECK,
459 : : SPDK_DIF_PI_FORMAT_32, SPDK_DIF_PI_FORMAT_16);
460 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_GUARD_CHECK,
461 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_64);
462 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_GUARD_CHECK,
463 : : SPDK_DIF_PI_FORMAT_32, SPDK_DIF_PI_FORMAT_64);
464 : :
465 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_APPTAG_CHECK,
466 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_32);
467 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_APPTAG_CHECK,
468 : : SPDK_DIF_PI_FORMAT_32, SPDK_DIF_PI_FORMAT_16);
469 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_APPTAG_CHECK,
470 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_64);
471 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_APPTAG_CHECK,
472 : : SPDK_DIF_PI_FORMAT_32, SPDK_DIF_PI_FORMAT_64);
473 : :
474 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_REFTAG_CHECK,
475 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_32);
476 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_REFTAG_CHECK,
477 : : SPDK_DIF_PI_FORMAT_32, SPDK_DIF_PI_FORMAT_16);
478 : 5 : _dif_generate_and_verify_different_pi_format(SPDK_DIF_FLAGS_REFTAG_CHECK,
479 : : SPDK_DIF_PI_FORMAT_16, SPDK_DIF_PI_FORMAT_64);
480 : : /* The ref tag in 32 and 64 PI formats will partially overlap, so skip the last test */
481 : 5 : }
482 : :
483 : : static void
484 : 10 : _dif_apptag_mask_test(enum spdk_dif_pi_format dif_pi_format)
485 : : {
486 : 10 : struct spdk_dif_ctx ctx = {};
487 : : int rc;
488 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
489 : 8 : struct iovec iov;
490 : 10 : struct spdk_dif_error err_blk = {};
491 : : uint32_t dif_flags;
492 : :
493 : 10 : dif_flags = SPDK_DIF_FLAGS_APPTAG_CHECK;
494 : :
495 : 10 : _iov_alloc_buf(&iov, 4096 + 128);
496 : :
497 : 10 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
498 : 10 : CU_ASSERT(rc == 0);
499 : :
500 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
501 : 10 : dif_opts.dif_pi_format = dif_pi_format;
502 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
503 : : 0, 0xFFFF, 0x1234, 0, 0, &dif_opts);
504 : 10 : CU_ASSERT(rc == 0);
505 : :
506 : 10 : rc = spdk_dif_generate(&iov, 1, 1, &ctx);
507 : 10 : CU_ASSERT(rc == 0);
508 : :
509 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
510 : : 12, 0xFFFF, 0x1256, 0, 0, &dif_opts);
511 : 10 : CU_ASSERT(rc == 0);
512 : :
513 : 10 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, &err_blk);
514 : 10 : CU_ASSERT(rc != 0);
515 : 10 : CU_ASSERT(err_blk.err_type == SPDK_DIF_APPTAG_ERROR);
516 : :
517 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
518 : : 12, 0xFF00, 0x1256, 0, 0, &dif_opts);
519 : 10 : CU_ASSERT(rc == 0);
520 : :
521 : 10 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, &err_blk);
522 : 10 : CU_ASSERT(rc == 0);
523 : :
524 : 10 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 1);
525 : 10 : CU_ASSERT(rc == 0);
526 : :
527 : 10 : _iov_free_buf(&iov);
528 : 10 : }
529 : :
530 : : static void
531 : 5 : dif_apptag_mask_test(void)
532 : : {
533 : 5 : _dif_apptag_mask_test(SPDK_DIF_PI_FORMAT_16);
534 : 5 : _dif_apptag_mask_test(SPDK_DIF_PI_FORMAT_32);
535 : 5 : }
536 : :
537 : : static void
538 : 5 : dif_sec_8_md_8_error_test(void)
539 : : {
540 : 5 : struct spdk_dif_ctx ctx = {};
541 : : int rc;
542 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
543 : :
544 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
545 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
546 : : /* Metadata size is 8 and block size is 8. */
547 : 5 : rc = spdk_dif_ctx_init(&ctx, 8, 8, true, false, SPDK_DIF_TYPE1, 0,
548 : : 0, 0, 0, 0, 0, &dif_opts);
549 : 5 : CU_ASSERT(rc != 0);
550 : 5 : }
551 : :
552 : : static void
553 : 5 : dif_sec_512_md_0_error_test(void)
554 : : {
555 : 5 : struct spdk_dif_ctx ctx = {};
556 : : int rc;
557 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
558 : :
559 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
560 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
561 : : /* Metadata size is 0. */
562 : 5 : rc = spdk_dif_ctx_init(&ctx, 512, 0, true, false, SPDK_DIF_TYPE1, 0,
563 : : 0, 0, 0, 0, 0, &dif_opts);
564 : 5 : CU_ASSERT(rc != 0);
565 : 5 : }
566 : :
567 : : static void
568 : 10 : _dif_sec_512_md_16_error_test(enum spdk_dif_pi_format dif_pi_format)
569 : : {
570 : 10 : struct spdk_dif_ctx ctx = {};
571 : : int rc;
572 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
573 : :
574 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
575 : 10 : dif_opts.dif_pi_format = dif_pi_format;
576 : : /* Metadata size is 16 but block size is 512. */
577 : 10 : rc = spdk_dif_ctx_init(&ctx, 512, 16, true, false, SPDK_DIF_TYPE1, 0,
578 : : 0, 0, 0, 0, 0, &dif_opts);
579 : 10 : CU_ASSERT(rc != 0);
580 : 10 : }
581 : :
582 : : static void
583 : 5 : dif_sec_512_md_16_error_test(void)
584 : : {
585 : 5 : _dif_sec_512_md_16_error_test(SPDK_DIF_PI_FORMAT_32);
586 : 5 : _dif_sec_512_md_16_error_test(SPDK_DIF_PI_FORMAT_64);
587 : 5 : }
588 : :
589 : : static void
590 : 10 : _dif_sec_4096_md_0_8_error_test(enum spdk_dif_pi_format dif_pi_format)
591 : : {
592 : 10 : struct spdk_dif_ctx ctx = {};
593 : : int rc;
594 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
595 : :
596 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
597 : 10 : dif_opts.dif_pi_format = dif_pi_format;
598 : : /* Metadata size is 0. */
599 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096, 0, true, false, SPDK_DIF_TYPE1, 0,
600 : : 0, 0, 0, 0, 0, &dif_opts);
601 : 10 : CU_ASSERT(rc != 0);
602 : :
603 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
604 : 10 : dif_opts.dif_pi_format = dif_pi_format;
605 : : /* Metadata size is 8. */
606 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096, 8, true, false, SPDK_DIF_TYPE1, 0,
607 : : 0, 0, 0, 0, 0, &dif_opts);
608 : 10 : CU_ASSERT(rc != 0);
609 : 10 : }
610 : :
611 : : static void
612 : 5 : dif_sec_4096_md_0_8_error_test(void)
613 : : {
614 : 5 : _dif_sec_4096_md_0_8_error_test(SPDK_DIF_PI_FORMAT_32);
615 : 5 : _dif_sec_4096_md_0_8_error_test(SPDK_DIF_PI_FORMAT_64);
616 : 5 : }
617 : :
618 : : static void
619 : 10 : _dif_sec_4100_md_128_error_test(enum spdk_dif_pi_format dif_pi_format)
620 : : {
621 : 10 : struct spdk_dif_ctx ctx = {};
622 : : int rc;
623 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
624 : :
625 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
626 : 10 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_32;
627 : : /* Block size is not multiple of 4kB, MD interleave = false */
628 : 10 : rc = spdk_dif_ctx_init(&ctx, 4100, 128, false, false, SPDK_DIF_TYPE1, 0,
629 : : 0, 0, 0, 0, 0, &dif_opts);
630 : 10 : CU_ASSERT(rc != 0);
631 : 10 : }
632 : :
633 : : static void
634 : 5 : dif_sec_4100_md_128_error_test(void)
635 : : {
636 : 5 : _dif_sec_4100_md_128_error_test(SPDK_DIF_PI_FORMAT_32);
637 : 5 : _dif_sec_4100_md_128_error_test(SPDK_DIF_PI_FORMAT_64);
638 : 5 : }
639 : :
640 : : static void
641 : 5 : _dif_guard_seed_test(uint32_t block_size, uint32_t md_size,
642 : : enum spdk_dif_pi_format dif_pi_format)
643 : : {
644 : 4 : struct iovec iov;
645 : 5 : struct spdk_dif_ctx ctx = {};
646 : 5 : struct spdk_dif_error err_blk = {};
647 : : struct spdk_dif *dif;
648 : : uint64_t guard;
649 : : int rc;
650 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
651 : :
652 : 5 : _iov_alloc_buf(&iov, block_size);
653 : :
654 [ - + ]: 5 : memset(iov.iov_base, 0, block_size);
655 : :
656 : 5 : dif = (struct spdk_dif *)(iov.iov_base + (block_size - md_size));
657 : :
658 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
659 : 5 : dif_opts.dif_pi_format = dif_pi_format;
660 : 5 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, true, SPDK_DIF_TYPE1,
661 : : SPDK_DIF_FLAGS_GUARD_CHECK,
662 : : 0, 0, 0, 0, 0, &dif_opts);
663 : 5 : CU_ASSERT(rc == 0);
664 : :
665 : 5 : rc = spdk_dif_generate(&iov, 1, 1, &ctx);
666 : 5 : CU_ASSERT(rc == 0);
667 : :
668 : : /* Guard should be zero if the block is all zero and seed is not added. */
669 : 5 : guard = _dif_get_guard(dif, ctx.dif_pi_format);
670 : 5 : CU_ASSERT(guard == 0);
671 : :
672 : 5 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, &err_blk);
673 : 5 : CU_ASSERT(rc == 0);
674 : :
675 : 5 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, true, SPDK_DIF_TYPE1,
676 : : SPDK_DIF_FLAGS_GUARD_CHECK,
677 : : 0, 0, 0, 0, GUARD_SEED, &dif_opts);
678 : 5 : CU_ASSERT(rc == 0);
679 : :
680 : 5 : rc = spdk_dif_generate(&iov, 1, 1, &ctx);
681 : 5 : CU_ASSERT(rc == 0);
682 : :
683 : : /* Guard should not be zero if the block is all zero but seed is added. */
684 : 5 : guard = _dif_get_guard(dif, ctx.dif_pi_format);
685 : 5 : CU_ASSERT(guard != 0);
686 : :
687 : 5 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, &err_blk);
688 : 5 : CU_ASSERT(rc == 0);
689 : :
690 : 5 : _iov_free_buf(&iov);
691 : 5 : }
692 : :
693 : : static void
694 : 5 : dif_guard_seed_test(void)
695 : : {
696 : 5 : _dif_guard_seed_test(512 + 8, 8, SPDK_DIF_PI_FORMAT_16);
697 : 5 : }
698 : :
699 : : static void
700 : 40 : _dif_guard_value_test(uint32_t block_size, uint32_t md_size,
701 : : enum spdk_dif_pi_format dif_pi_format, struct iovec *iov_input_data,
702 : : uint64_t expected_guard)
703 : : {
704 : 40 : struct spdk_dif_ctx ctx = {};
705 : 40 : struct spdk_dif_error err_blk = {};
706 : 32 : struct spdk_dif_ctx_init_ext_opts dif_opts;
707 : : struct spdk_dif *dif;
708 : : int rc;
709 : : uint64_t guard;
710 : :
711 : 40 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
712 : 40 : dif_opts.dif_pi_format = dif_pi_format;
713 : 40 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, true, SPDK_DIF_TYPE1,
714 : : SPDK_DIF_FLAGS_GUARD_CHECK,
715 : : 0, 0, 0, 0, 0, &dif_opts);
716 : 40 : CU_ASSERT(rc == 0);
717 : :
718 : 40 : dif = (struct spdk_dif *)(iov_input_data->iov_base + (block_size - md_size));
719 : :
720 : 40 : rc = spdk_dif_generate(iov_input_data, 1, 1, &ctx);
721 : 40 : CU_ASSERT(rc == 0);
722 : :
723 : 40 : guard = _dif_get_guard(dif, ctx.dif_pi_format);
724 : 40 : CU_ASSERT(guard == expected_guard);
725 : :
726 : 40 : rc = spdk_dif_verify(iov_input_data, 1, 1, &ctx, &err_blk);
727 : 40 : CU_ASSERT(rc == 0);
728 : 40 : }
729 : :
730 : : static void
731 : 5 : dif_guard_value_test(void)
732 : : {
733 : 4 : struct iovec iov;
734 : : unsigned int i, j;
735 : 5 : uint32_t block_size = 4096 + 128;
736 : 5 : uint32_t md_size = 128;
737 : :
738 : 5 : _iov_alloc_buf(&iov, block_size);
739 : :
740 : : /* All the expected CRC guard values are compliant with
741 : : * the NVM Command Set Specification 1.0c */
742 : :
743 : : /* Input buffer = 0s */
744 [ - + ]: 5 : memset(iov.iov_base, 0, block_size);
745 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_32, &iov, 0x98F94189);
746 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_64, &iov, 0x6482D367EB22B64E);
747 : :
748 : : /* Input buffer = 1s */
749 [ - + ]: 5 : memset(iov.iov_base, 0xFF, block_size);
750 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_32, &iov, 0x25C1FE13);
751 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_64, &iov, 0xC0DDBA7302ECA3AC);
752 : :
753 : : /* Input buffer = 0x00, 0x01, 0x02, ... */
754 [ - + ]: 5 : memset(iov.iov_base, 0, block_size);
755 : 5 : j = 0;
756 [ + + ]: 20485 : for (i = 0; i < block_size - md_size; i++) {
757 : 20480 : *((uint8_t *)(iov.iov_base) + i) = j;
758 [ + + ]: 20480 : if (j == 0xFF) {
759 : 80 : j = 0;
760 : : } else {
761 : 20400 : j++;
762 : : }
763 : : }
764 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_32, &iov, 0x9C71FE32);
765 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_64, &iov, 0x3E729F5F6750449C);
766 : :
767 : : /* Input buffer = 0xFF, 0xFE, 0xFD, ... */
768 [ - + ]: 5 : memset(iov.iov_base, 0, block_size);
769 : 5 : j = 0xFF;
770 [ + + ]: 20485 : for (i = 0; i < block_size - md_size ; i++) {
771 : 20480 : *((uint8_t *)(iov.iov_base) + i) = j;
772 [ + + ]: 20480 : if (j == 0) {
773 : 80 : j = 0xFF;
774 : : } else {
775 : 20400 : j--;
776 : : }
777 : : }
778 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_32, &iov, 0x214941A8);
779 : 5 : _dif_guard_value_test(block_size, md_size, SPDK_DIF_PI_FORMAT_64, &iov, 0x9A2DF64B8E9E517E);
780 : :
781 : :
782 : 5 : _iov_free_buf(&iov);
783 : 5 : }
784 : :
785 : : static void
786 : 220 : dif_generate_and_verify(struct iovec *iovs, int iovcnt,
787 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
788 : : bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
789 : : enum spdk_dif_pi_format dif_pi_format,
790 : : uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag)
791 : : {
792 : 220 : struct spdk_dif_ctx ctx = {};
793 : : int rc;
794 : 176 : struct spdk_dif_ctx_init_ext_opts dif_opts;
795 : :
796 : 220 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, md_size, num_blocks);
797 : 220 : CU_ASSERT(rc == 0);
798 : :
799 : 220 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
800 : 220 : dif_opts.dif_pi_format = dif_pi_format;
801 : 220 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc, dif_type, dif_flags,
802 : : init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
803 : 220 : CU_ASSERT(rc == 0);
804 : :
805 : 220 : rc = spdk_dif_generate(iovs, iovcnt, num_blocks, &ctx);
806 : 220 : CU_ASSERT(rc == 0);
807 : :
808 : 220 : rc = spdk_dif_verify(iovs, iovcnt, num_blocks, &ctx, NULL);
809 : 220 : CU_ASSERT(rc == 0);
810 : :
811 : 220 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size, md_size, num_blocks);
812 : 220 : CU_ASSERT(rc == 0);
813 : 220 : }
814 : :
815 : : static void
816 : 5 : dif_disable_sec_512_md_8_single_iov_test(void)
817 : : {
818 : 4 : struct iovec iov;
819 : :
820 : 5 : _iov_alloc_buf(&iov, 512 + 8);
821 : :
822 : 5 : dif_generate_and_verify(&iov, 1, 512 + 8, 8, 1, false, SPDK_DIF_DISABLE, 0,
823 : : SPDK_DIF_PI_FORMAT_16, 0, 0, 0);
824 : :
825 : 5 : _iov_free_buf(&iov);
826 : 5 : }
827 : :
828 : : static void
829 : 5 : dif_sec_512_md_8_prchk_0_single_iov_test(void)
830 : : {
831 : 4 : struct iovec iov;
832 : :
833 : 5 : _iov_alloc_buf(&iov, 512 + 8);
834 : :
835 : 5 : dif_generate_and_verify(&iov, 1, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1, 0,
836 : : SPDK_DIF_PI_FORMAT_16, 0, 0, 0);
837 : :
838 : 5 : _iov_free_buf(&iov);
839 : 5 : }
840 : :
841 : : static void
842 : 5 : dif_sec_4096_md_128_prchk_0_single_iov_test(void)
843 : : {
844 : 4 : struct iovec iov;
845 : :
846 : 5 : _iov_alloc_buf(&iov, 4096 + 128);
847 : :
848 : 5 : dif_generate_and_verify(&iov, 1, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1, 0,
849 : : SPDK_DIF_PI_FORMAT_32, 0, 0, 0);
850 : 5 : dif_generate_and_verify(&iov, 1, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1, 0,
851 : : SPDK_DIF_PI_FORMAT_64, 0, 0, 0);
852 : :
853 : 5 : _iov_free_buf(&iov);
854 : 5 : }
855 : :
856 : : static void
857 : 5 : dif_sec_512_md_8_prchk_0_1_2_4_multi_iovs_test(void)
858 : : {
859 : 4 : struct iovec iovs[4];
860 : : int i, num_blocks;
861 : :
862 : 5 : num_blocks = 0;
863 : :
864 [ + + ]: 25 : for (i = 0; i < 4; i++) {
865 : 20 : _iov_alloc_buf(&iovs[i], (512 + 8) * (i + 1));
866 : 20 : num_blocks += i + 1;
867 : : }
868 : :
869 : 5 : dif_generate_and_verify(iovs, 4, 512 + 8, 8, num_blocks, false, SPDK_DIF_TYPE1,
870 : : 0, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
871 : :
872 : 5 : dif_generate_and_verify(iovs, 4, 512 + 8, 8, num_blocks, false, SPDK_DIF_TYPE1,
873 : : SPDK_DIF_FLAGS_GUARD_CHECK, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
874 : :
875 : 5 : dif_generate_and_verify(iovs, 4, 512 + 8, 8, num_blocks, false, SPDK_DIF_TYPE1,
876 : : SPDK_DIF_FLAGS_APPTAG_CHECK, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
877 : :
878 : 5 : dif_generate_and_verify(iovs, 4, 512 + 8, 8, num_blocks, false, SPDK_DIF_TYPE1,
879 : : SPDK_DIF_FLAGS_REFTAG_CHECK, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
880 : :
881 [ + + ]: 25 : for (i = 0; i < 4; i++) {
882 : 20 : _iov_free_buf(&iovs[i]);
883 : : }
884 : 5 : }
885 : :
886 : : static void
887 : 10 : _dif_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(enum spdk_dif_pi_format dif_pi_format)
888 : : {
889 : 8 : struct iovec iovs[4];
890 : : int i, num_blocks;
891 : :
892 : 10 : num_blocks = 0;
893 : :
894 [ + + ]: 50 : for (i = 0; i < 4; i++) {
895 : 40 : _iov_alloc_buf(&iovs[i], (4096 + 128) * (i + 1));
896 : 40 : num_blocks += i + 1;
897 : : }
898 : :
899 : 10 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
900 : : 0, dif_pi_format, 22, 0xFFFF, 0x22);
901 : :
902 : 10 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
903 : : SPDK_DIF_FLAGS_GUARD_CHECK, dif_pi_format, 22, 0xFFFF, 0x22);
904 : :
905 : 10 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
906 : : SPDK_DIF_FLAGS_APPTAG_CHECK, dif_pi_format, 22, 0xFFFF, 0x22);
907 : :
908 : 10 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
909 : : SPDK_DIF_FLAGS_REFTAG_CHECK, dif_pi_format, 22, 0xFFFF, 0x22);
910 : :
911 [ + + ]: 50 : for (i = 0; i < 4; i++) {
912 : 40 : _iov_free_buf(&iovs[i]);
913 : : }
914 : 10 : }
915 : :
916 : : static void
917 : 5 : dif_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(void)
918 : : {
919 : 5 : _dif_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_32);
920 : 5 : _dif_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_64);
921 : 5 : }
922 : :
923 : : static void
924 : 15 : _dif_sec_4096_md_128_prchk_7_multi_iovs_test(enum spdk_dif_pi_format dif_pi_format)
925 : : {
926 : 12 : struct iovec iovs[4];
927 : : int i, num_blocks;
928 : : uint32_t dif_flags;
929 : :
930 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
931 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
932 : :
933 : 15 : num_blocks = 0;
934 : :
935 [ + + ]: 75 : for (i = 0; i < 4; i++) {
936 : 60 : _iov_alloc_buf(&iovs[i], (4096 + 128) * (i + 1));
937 : 60 : num_blocks += i + 1;
938 : : }
939 : :
940 : 15 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
941 : : dif_flags, dif_pi_format, 22, 0xFFFF, 0x22);
942 : :
943 : 15 : dif_generate_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, true, SPDK_DIF_TYPE1,
944 : : dif_flags, dif_pi_format, 22, 0xFFFF, 0x22);
945 : :
946 [ + + ]: 75 : for (i = 0; i < 4; i++) {
947 : 60 : _iov_free_buf(&iovs[i]);
948 : : }
949 : 15 : }
950 : :
951 : : static void
952 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_test(void)
953 : : {
954 : 5 : _dif_sec_4096_md_128_prchk_7_multi_iovs_test(SPDK_DIF_PI_FORMAT_16);
955 : 5 : _dif_sec_4096_md_128_prchk_7_multi_iovs_test(SPDK_DIF_PI_FORMAT_32);
956 : 5 : _dif_sec_4096_md_128_prchk_7_multi_iovs_test(SPDK_DIF_PI_FORMAT_64);
957 : 5 : }
958 : :
959 : : static void
960 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_split_data_and_md_test(void)
961 : : {
962 : 4 : struct iovec iovs[2];
963 : : uint32_t dif_flags;
964 : :
965 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
966 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
967 : :
968 : 5 : _iov_alloc_buf(&iovs[0], 512);
969 : 5 : _iov_alloc_buf(&iovs[1], 8);
970 : :
971 : 5 : dif_generate_and_verify(iovs, 2, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1,
972 : : dif_flags, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
973 : :
974 : 5 : _iov_free_buf(&iovs[0]);
975 : 5 : _iov_free_buf(&iovs[1]);
976 : 5 : }
977 : :
978 : : static void
979 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_split_data_and_md_test(void)
980 : : {
981 : 4 : struct iovec iovs[2];
982 : : uint32_t dif_flags;
983 : :
984 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
985 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
986 : :
987 : 5 : _iov_alloc_buf(&iovs[0], 4096);
988 : 5 : _iov_alloc_buf(&iovs[1], 128);
989 : :
990 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
991 : : dif_flags, SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
992 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
993 : : dif_flags, SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
994 : :
995 : 5 : _iov_free_buf(&iovs[0]);
996 : 5 : _iov_free_buf(&iovs[1]);
997 : 5 : }
998 : :
999 : : static void
1000 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_split_data_test(void)
1001 : : {
1002 : 4 : struct iovec iovs[2];
1003 : : uint32_t dif_flags;
1004 : :
1005 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1006 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1007 : :
1008 : 5 : _iov_alloc_buf(&iovs[0], 256);
1009 : 5 : _iov_alloc_buf(&iovs[1], 264);
1010 : :
1011 : 5 : dif_generate_and_verify(iovs, 2, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1,
1012 : : dif_flags, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1013 : :
1014 : 5 : _iov_free_buf(&iovs[0]);
1015 : 5 : _iov_free_buf(&iovs[1]);
1016 : 5 : }
1017 : :
1018 : : static void
1019 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_split_data_test(void)
1020 : : {
1021 : 4 : struct iovec iovs[2];
1022 : : uint32_t dif_flags;
1023 : :
1024 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1025 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1026 : :
1027 : 5 : _iov_alloc_buf(&iovs[0], 2048);
1028 : 5 : _iov_alloc_buf(&iovs[1], 2176);
1029 : :
1030 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1031 : : dif_flags, SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1032 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1033 : : dif_flags, SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1034 : :
1035 : 5 : _iov_free_buf(&iovs[0]);
1036 : 5 : _iov_free_buf(&iovs[1]);
1037 : 5 : }
1038 : :
1039 : : static void
1040 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_split_guard_test(void)
1041 : : {
1042 : 4 : struct iovec iovs[2];
1043 : : uint32_t dif_flags;
1044 : :
1045 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1046 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1047 : :
1048 : 5 : _iov_alloc_buf(&iovs[0], 513);
1049 : 5 : _iov_alloc_buf(&iovs[1], 7);
1050 : :
1051 : 5 : dif_generate_and_verify(iovs, 2, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1,
1052 : : dif_flags, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1053 : :
1054 : 5 : _iov_free_buf(&iovs[0]);
1055 : 5 : _iov_free_buf(&iovs[1]);
1056 : 5 : }
1057 : :
1058 : : static void
1059 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_split_guard_test(void)
1060 : : {
1061 : 4 : struct iovec iovs[2];
1062 : : uint32_t dif_flags;
1063 : :
1064 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1065 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1066 : :
1067 : 5 : _iov_alloc_buf(&iovs[0], 4097);
1068 : 5 : _iov_alloc_buf(&iovs[1], 127);
1069 : :
1070 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1071 : : dif_flags, SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1072 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1073 : : dif_flags, SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1074 : :
1075 : 5 : _iov_free_buf(&iovs[0]);
1076 : 5 : _iov_free_buf(&iovs[1]);
1077 : 5 : }
1078 : :
1079 : : static void
1080 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_split_apptag_test(void)
1081 : : {
1082 : 4 : struct iovec iovs[2];
1083 : : uint32_t dif_flags;
1084 : :
1085 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1086 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1087 : :
1088 : 5 : _iov_alloc_buf(&iovs[0], 515);
1089 : 5 : _iov_alloc_buf(&iovs[1], 5);
1090 : :
1091 : 5 : dif_generate_and_verify(iovs, 2, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1,
1092 : : dif_flags, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1093 : :
1094 : 5 : _iov_free_buf(&iovs[0]);
1095 : 5 : _iov_free_buf(&iovs[1]);
1096 : 5 : }
1097 : :
1098 : : static void
1099 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_split_apptag_test(void)
1100 : : {
1101 : 4 : struct iovec iovs[2];
1102 : : uint32_t dif_flags;
1103 : :
1104 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1105 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1106 : :
1107 : 5 : _iov_alloc_buf(&iovs[0], 4101);
1108 : 5 : _iov_alloc_buf(&iovs[1], 123);
1109 : :
1110 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1111 : : dif_flags, SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1112 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1113 : : dif_flags, SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1114 : :
1115 : 5 : _iov_free_buf(&iovs[0]);
1116 : 5 : _iov_free_buf(&iovs[1]);
1117 : 5 : }
1118 : :
1119 : : static void
1120 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_split_reftag_test(void)
1121 : : {
1122 : 4 : struct iovec iovs[2];
1123 : : uint32_t dif_flags;
1124 : :
1125 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1126 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1127 : :
1128 : 5 : _iov_alloc_buf(&iovs[0], 518);
1129 : 5 : _iov_alloc_buf(&iovs[1], 2);
1130 : :
1131 : 5 : dif_generate_and_verify(iovs, 2, 512 + 8, 8, 1, false, SPDK_DIF_TYPE1,
1132 : : dif_flags, SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1133 : :
1134 : 5 : _iov_free_buf(&iovs[0]);
1135 : 5 : _iov_free_buf(&iovs[1]);
1136 : 5 : }
1137 : :
1138 : : static void
1139 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_split_reftag_test(void)
1140 : : {
1141 : 4 : struct iovec iovs[2];
1142 : : uint32_t dif_flags;
1143 : :
1144 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1145 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1146 : :
1147 : 5 : _iov_alloc_buf(&iovs[0], 4108);
1148 : 5 : _iov_alloc_buf(&iovs[1], 116);
1149 : :
1150 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1151 : : dif_flags, SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1152 : 5 : dif_generate_and_verify(iovs, 2, 4096 + 128, 128, 1, false, SPDK_DIF_TYPE1,
1153 : : dif_flags, SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1154 : :
1155 : 5 : _iov_free_buf(&iovs[0]);
1156 : 5 : _iov_free_buf(&iovs[1]);
1157 : 5 : }
1158 : :
1159 : : static void
1160 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_complex_splits_test(void)
1161 : : {
1162 : 4 : struct iovec iovs[9];
1163 : : uint32_t dif_flags;
1164 : : int i;
1165 : :
1166 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1167 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1168 : :
1169 : : /* data[0][255:0] */
1170 : 5 : _iov_alloc_buf(&iovs[0], 256);
1171 : :
1172 : : /* data[0][511:256], guard[0][0] */
1173 : 5 : _iov_alloc_buf(&iovs[1], 256 + 1);
1174 : :
1175 : : /* guard[0][1], apptag[0][0] */
1176 : 5 : _iov_alloc_buf(&iovs[2], 1 + 1);
1177 : :
1178 : : /* apptag[0][1], reftag[0][0] */
1179 : 5 : _iov_alloc_buf(&iovs[3], 1 + 1);
1180 : :
1181 : : /* reftag[0][3:1], data[1][255:0] */
1182 : 5 : _iov_alloc_buf(&iovs[4], 3 + 256);
1183 : :
1184 : : /* data[1][511:256], guard[1][0] */
1185 : 5 : _iov_alloc_buf(&iovs[5], 256 + 1);
1186 : :
1187 : : /* guard[1][1], apptag[1][0] */
1188 : 5 : _iov_alloc_buf(&iovs[6], 1 + 1);
1189 : :
1190 : : /* apptag[1][1], reftag[1][0] */
1191 : 5 : _iov_alloc_buf(&iovs[7], 1 + 1);
1192 : :
1193 : : /* reftag[1][3:1] */
1194 : 5 : _iov_alloc_buf(&iovs[8], 3);
1195 : :
1196 : 5 : dif_generate_and_verify(iovs, 9, 512 + 8, 8, 2, false, SPDK_DIF_TYPE1, dif_flags,
1197 : : SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1198 : :
1199 [ + + ]: 50 : for (i = 0; i < 9; i++) {
1200 : 45 : _iov_free_buf(&iovs[i]);
1201 : : }
1202 : 5 : }
1203 : :
1204 : : static void
1205 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test(void)
1206 : : {
1207 : 4 : struct iovec iovs[11];
1208 : : uint32_t dif_flags;
1209 : : int i;
1210 : :
1211 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1212 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1213 : :
1214 : : /* data[0][1000:0] */
1215 : 5 : _iov_alloc_buf(&iovs[0], 1000);
1216 : :
1217 : : /* data[0][3095:1000], guard[0][0] */
1218 : 5 : _iov_alloc_buf(&iovs[1], 3096 + 1);
1219 : :
1220 : : /* guard[0][1], apptag[0][0] */
1221 : 5 : _iov_alloc_buf(&iovs[2], 1 + 1);
1222 : :
1223 : : /* apptag[0][1], reftag[0][0] */
1224 : 5 : _iov_alloc_buf(&iovs[3], 1 + 1);
1225 : :
1226 : : /* reftag[0][3:1], ignore[0][59:0] */
1227 : 5 : _iov_alloc_buf(&iovs[4], 3 + 60);
1228 : :
1229 : : /* ignore[119:60], data[1][3050:0] */
1230 : 5 : _iov_alloc_buf(&iovs[5], 60 + 3051);
1231 : :
1232 : : /* data[1][4095:3050], guard[1][0] */
1233 : 5 : _iov_alloc_buf(&iovs[6], 1045 + 1);
1234 : :
1235 : : /* guard[1][1], apptag[1][0] */
1236 : 5 : _iov_alloc_buf(&iovs[7], 1 + 1);
1237 : :
1238 : : /* apptag[1][1], reftag[1][0] */
1239 : 5 : _iov_alloc_buf(&iovs[8], 1 + 1);
1240 : :
1241 : : /* reftag[1][3:1], ignore[1][9:0] */
1242 : 5 : _iov_alloc_buf(&iovs[9], 3 + 10);
1243 : :
1244 : : /* ignore[1][127:9] */
1245 : 5 : _iov_alloc_buf(&iovs[10], 118);
1246 : :
1247 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
1248 : : SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1249 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
1250 : : SPDK_DIF_PI_FORMAT_16, 22, 0xFFFF, 0x22);
1251 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
1252 : : SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1253 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
1254 : : SPDK_DIF_PI_FORMAT_32, 22, 0xFFFF, 0x22);
1255 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
1256 : : SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1257 : 5 : dif_generate_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
1258 : : SPDK_DIF_PI_FORMAT_64, 22, 0xFFFF, 0x22);
1259 : :
1260 [ + + ]: 60 : for (i = 0; i < 11; i++) {
1261 : 55 : _iov_free_buf(&iovs[i]);
1262 : : }
1263 : 5 : }
1264 : :
1265 : : static void
1266 : 720 : _dif_inject_error_and_verify(struct iovec *iovs, int iovcnt,
1267 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
1268 : : uint32_t inject_flags, bool dif_loc, enum spdk_dif_pi_format dif_pi_format)
1269 : : {
1270 : 720 : struct spdk_dif_ctx ctx = {};
1271 : 720 : struct spdk_dif_error err_blk = {};
1272 : 720 : uint32_t inject_offset = 0, dif_flags;
1273 : : int rc;
1274 : 576 : struct spdk_dif_ctx_init_ext_opts dif_opts;
1275 : :
1276 : 720 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1277 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1278 : :
1279 : 720 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, md_size, num_blocks);
1280 : 720 : CU_ASSERT(rc == 0);
1281 : :
1282 : 720 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1283 : 720 : dif_opts.dif_pi_format = dif_pi_format;
1284 : 720 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc,
1285 : : SPDK_DIF_TYPE1, dif_flags,
1286 : : 88, 0xFFFF, 0x88, 0, GUARD_SEED, &dif_opts);
1287 : 720 : CU_ASSERT(rc == 0);
1288 : :
1289 : 720 : rc = spdk_dif_generate(iovs, iovcnt, num_blocks, &ctx);
1290 : 720 : CU_ASSERT(rc == 0);
1291 : :
1292 : 720 : rc = spdk_dif_inject_error(iovs, iovcnt, num_blocks, &ctx, inject_flags, &inject_offset);
1293 : 720 : CU_ASSERT(rc == 0);
1294 : :
1295 : 720 : rc = spdk_dif_verify(iovs, iovcnt, num_blocks, &ctx, &err_blk);
1296 : 720 : CU_ASSERT(rc != 0);
1297 [ + + ]: 720 : if (inject_flags == SPDK_DIF_DATA_ERROR) {
1298 : 180 : CU_ASSERT(SPDK_DIF_GUARD_ERROR == err_blk.err_type);
1299 : : } else {
1300 : 540 : CU_ASSERT(inject_flags == err_blk.err_type);
1301 : : }
1302 : 720 : CU_ASSERT(inject_offset == err_blk.err_offset);
1303 : :
1304 : 720 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size, md_size, num_blocks);
1305 [ + + - + : 720 : CU_ASSERT((rc == 0 && (inject_flags != SPDK_DIF_DATA_ERROR)) ||
+ - + - ]
1306 : : (rc != 0 && (inject_flags == SPDK_DIF_DATA_ERROR)));
1307 : 720 : }
1308 : :
1309 : : static void
1310 : 360 : dif_inject_error_and_verify(struct iovec *iovs, int iovcnt,
1311 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
1312 : : uint32_t inject_flags, enum spdk_dif_pi_format dif_pi_format)
1313 : : {
1314 : : /* The case that DIF is contained in the first 8/16 bytes of metadata. */
1315 : 360 : _dif_inject_error_and_verify(iovs, iovcnt, block_size, md_size, num_blocks,
1316 : : inject_flags, true, dif_pi_format);
1317 : :
1318 : : /* The case that DIF is contained in the last 8/16 bytes of metadata. */
1319 : 360 : _dif_inject_error_and_verify(iovs, iovcnt, block_size, md_size, num_blocks,
1320 : : inject_flags, false, dif_pi_format);
1321 : 360 : }
1322 : :
1323 : : static void
1324 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test(void)
1325 : : {
1326 : 4 : struct iovec iovs[4];
1327 : : int i, num_blocks;
1328 : :
1329 : 5 : num_blocks = 0;
1330 : :
1331 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1332 : 20 : _iov_alloc_buf(&iovs[i], (4096 + 128) * (i + 1));
1333 : 20 : num_blocks += i + 1;
1334 : : }
1335 : :
1336 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1337 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1338 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1339 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1340 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1341 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1342 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1343 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1344 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1345 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
1346 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1347 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1348 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1349 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1350 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1351 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
1352 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1353 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
1354 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1355 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1356 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1357 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1358 : 5 : dif_inject_error_and_verify(iovs, 4, 4096 + 128, 128, num_blocks,
1359 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
1360 : :
1361 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1362 : 20 : _iov_free_buf(&iovs[i]);
1363 : : }
1364 : 5 : }
1365 : :
1366 : : static void
1367 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_and_md_test(void)
1368 : : {
1369 : 4 : struct iovec iovs[2];
1370 : :
1371 : 5 : _iov_alloc_buf(&iovs[0], 4096);
1372 : 5 : _iov_alloc_buf(&iovs[1], 128);
1373 : :
1374 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1375 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1376 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1377 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1378 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1379 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1380 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1381 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1382 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1383 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
1384 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1385 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1386 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1387 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1388 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1389 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
1390 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1391 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
1392 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1393 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1394 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1395 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1396 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1397 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
1398 : :
1399 : :
1400 : 5 : _iov_free_buf(&iovs[0]);
1401 : 5 : _iov_free_buf(&iovs[1]);
1402 : 5 : }
1403 : :
1404 : : static void
1405 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_test(void)
1406 : : {
1407 : 4 : struct iovec iovs[2];
1408 : :
1409 : 5 : _iov_alloc_buf(&iovs[0], 2048);
1410 : 5 : _iov_alloc_buf(&iovs[1], 2048 + 128);
1411 : :
1412 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1413 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1414 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1415 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1416 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1417 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1418 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1419 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1420 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1421 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
1422 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1423 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1424 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1425 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1426 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1427 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
1428 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1429 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
1430 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1431 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1432 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1433 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1434 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1435 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
1436 : :
1437 : 5 : _iov_free_buf(&iovs[0]);
1438 : 5 : _iov_free_buf(&iovs[1]);
1439 : 5 : }
1440 : :
1441 : : static void
1442 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_guard_test(void)
1443 : : {
1444 : 4 : struct iovec iovs[2];
1445 : :
1446 : 5 : _iov_alloc_buf(&iovs[0], 4096 + 1);
1447 : 5 : _iov_alloc_buf(&iovs[1], 127);
1448 : :
1449 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1450 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1451 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1452 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1453 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1454 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1455 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1456 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1457 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1458 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
1459 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1460 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1461 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1462 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1463 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1464 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
1465 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1466 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
1467 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1468 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1469 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1470 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1471 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1472 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
1473 : :
1474 : 5 : _iov_free_buf(&iovs[0]);
1475 : 5 : _iov_free_buf(&iovs[1]);
1476 : 5 : }
1477 : :
1478 : : static void
1479 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_pi_16_test(void)
1480 : : {
1481 : 4 : struct iovec iovs[2];
1482 : :
1483 : 5 : _iov_alloc_buf(&iovs[0], 4096 + 3);
1484 : 5 : _iov_alloc_buf(&iovs[1], 125);
1485 : :
1486 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1487 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1488 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1489 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1490 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1491 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1492 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1493 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1494 : :
1495 : 5 : _iov_free_buf(&iovs[0]);
1496 : 5 : _iov_free_buf(&iovs[1]);
1497 : 5 : }
1498 : :
1499 : : static void
1500 : 10 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test(
1501 : : enum spdk_dif_pi_format dif_pi_format)
1502 : : {
1503 : 8 : struct iovec iovs[2];
1504 : :
1505 : 10 : _iov_alloc_buf(&iovs[0], 4096 + 5);
1506 : 10 : _iov_alloc_buf(&iovs[1], 123);
1507 : :
1508 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1509 : : SPDK_DIF_GUARD_ERROR, dif_pi_format);
1510 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1511 : : SPDK_DIF_APPTAG_ERROR, dif_pi_format);
1512 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1513 : : SPDK_DIF_REFTAG_ERROR, dif_pi_format);
1514 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1515 : : SPDK_DIF_DATA_ERROR, dif_pi_format);
1516 : :
1517 : 10 : _iov_free_buf(&iovs[0]);
1518 : 10 : _iov_free_buf(&iovs[1]);
1519 : 10 : }
1520 : :
1521 : : static void
1522 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test(void)
1523 : : {
1524 : 5 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test(SPDK_DIF_PI_FORMAT_32);
1525 : 5 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test(SPDK_DIF_PI_FORMAT_64);
1526 : 5 : }
1527 : :
1528 : : static void
1529 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_pi_16_test(void)
1530 : : {
1531 : 4 : struct iovec iovs[2];
1532 : :
1533 : 5 : _iov_alloc_buf(&iovs[0], 4096 + 6);
1534 : 5 : _iov_alloc_buf(&iovs[1], 122);
1535 : :
1536 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1537 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1538 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1539 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1540 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1541 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1542 : 5 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1543 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1544 : :
1545 : 5 : _iov_free_buf(&iovs[0]);
1546 : 5 : _iov_free_buf(&iovs[1]);
1547 : 5 : }
1548 : :
1549 : : static void
1550 : 10 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test(
1551 : : enum spdk_dif_pi_format dif_pi_format)
1552 : : {
1553 : 8 : struct iovec iovs[2];
1554 : :
1555 : 10 : _iov_alloc_buf(&iovs[0], 4096 + 9);
1556 : 10 : _iov_alloc_buf(&iovs[1], 119);
1557 : :
1558 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1559 : : SPDK_DIF_GUARD_ERROR, dif_pi_format);
1560 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1561 : : SPDK_DIF_APPTAG_ERROR, dif_pi_format);
1562 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1563 : : SPDK_DIF_REFTAG_ERROR, dif_pi_format);
1564 : 10 : dif_inject_error_and_verify(iovs, 2, 4096 + 128, 128, 1,
1565 : : SPDK_DIF_DATA_ERROR, dif_pi_format);
1566 : :
1567 : 10 : _iov_free_buf(&iovs[0]);
1568 : 10 : _iov_free_buf(&iovs[1]);
1569 : 10 : }
1570 : :
1571 : : static void
1572 : 5 : dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test(void)
1573 : : {
1574 : 5 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test(SPDK_DIF_PI_FORMAT_32);
1575 : 5 : _dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test(SPDK_DIF_PI_FORMAT_64);
1576 : 5 : }
1577 : :
1578 : : static void
1579 : 150 : dif_copy_gen_and_verify(struct iovec *iovs, int iovcnt, struct iovec *bounce_iov,
1580 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
1581 : : bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
1582 : : uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag,
1583 : : enum spdk_dif_pi_format dif_pi_format)
1584 : : {
1585 : 150 : struct spdk_dif_ctx ctx = {};
1586 : : int rc;
1587 : 120 : struct spdk_dif_ctx_init_ext_opts dif_opts;
1588 : :
1589 : 150 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size - md_size, 0, num_blocks);
1590 : 150 : CU_ASSERT(rc == 0);
1591 : :
1592 : 150 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1593 : 150 : dif_opts.dif_pi_format = dif_pi_format;
1594 : 150 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc, dif_type, dif_flags,
1595 : : init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
1596 : 150 : CU_ASSERT(rc == 0);
1597 : :
1598 : 150 : rc = spdk_dif_generate_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx);
1599 : 150 : CU_ASSERT(rc == 0);
1600 : :
1601 : 150 : rc = spdk_dif_verify_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx, NULL);
1602 : 150 : CU_ASSERT(rc == 0);
1603 : :
1604 : 150 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size - md_size, 0, num_blocks);
1605 : 150 : CU_ASSERT(rc == 0);
1606 : 150 : }
1607 : :
1608 : : static void
1609 : 5 : dif_copy_sec_512_md_8_prchk_0_single_iov(void)
1610 : : {
1611 : 4 : struct iovec iov, bounce_iov;
1612 : :
1613 : 5 : _iov_alloc_buf(&iov, 512 * 4);
1614 : 5 : _iov_alloc_buf(&bounce_iov, (512 + 8) * 4);
1615 : :
1616 : 5 : dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 512 + 8, 8, 4,
1617 : : false, SPDK_DIF_TYPE1, 0, 0, 0, 0, SPDK_DIF_PI_FORMAT_16);
1618 : 5 : dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 512 + 8, 8, 4,
1619 : : true, SPDK_DIF_TYPE1, 0, 0, 0, 0, SPDK_DIF_PI_FORMAT_16);
1620 : :
1621 : 5 : _iov_free_buf(&iov);
1622 : 5 : _iov_free_buf(&bounce_iov);
1623 : 5 : }
1624 : :
1625 : : static void
1626 : 10 : _dif_copy_sec_4096_md_128_prchk_0_single_iov_test(
1627 : : enum spdk_dif_pi_format dif_pi_format)
1628 : : {
1629 : 8 : struct iovec iov, bounce_iov;
1630 : :
1631 : 10 : _iov_alloc_buf(&iov, 4096 * 4);
1632 : 10 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * 4);
1633 : :
1634 : 10 : dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 4096 + 128, 128, 4,
1635 : : false, SPDK_DIF_TYPE1, 0, 0, 0, 0, dif_pi_format);
1636 : 10 : dif_copy_gen_and_verify(&iov, 1, &bounce_iov, 4096 + 128, 128, 4,
1637 : : true, SPDK_DIF_TYPE1, 0, 0, 0, 0, dif_pi_format);
1638 : :
1639 : 10 : _iov_free_buf(&iov);
1640 : 10 : _iov_free_buf(&bounce_iov);
1641 : 10 : }
1642 : :
1643 : : static void
1644 : 5 : dif_copy_sec_4096_md_128_prchk_0_single_iov_test(void)
1645 : : {
1646 : 5 : _dif_copy_sec_4096_md_128_prchk_0_single_iov_test(SPDK_DIF_PI_FORMAT_32);
1647 : 5 : _dif_copy_sec_4096_md_128_prchk_0_single_iov_test(SPDK_DIF_PI_FORMAT_64);
1648 : 5 : }
1649 : :
1650 : : static void
1651 : 5 : dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs(void)
1652 : : {
1653 : 4 : struct iovec iovs[4], bounce_iov;
1654 : : int i, num_blocks;
1655 : :
1656 : 5 : num_blocks = 0;
1657 : :
1658 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1659 : 20 : _iov_alloc_buf(&iovs[i], 512 * (i + 1));
1660 : 20 : num_blocks += i + 1;
1661 : : }
1662 : :
1663 : 5 : _iov_alloc_buf(&bounce_iov, (512 + 8) * num_blocks);
1664 : :
1665 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,
1666 : : false, SPDK_DIF_TYPE1, 0, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
1667 : :
1668 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,
1669 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22,
1670 : : SPDK_DIF_PI_FORMAT_16);
1671 : :
1672 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,
1673 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22,
1674 : : SPDK_DIF_PI_FORMAT_16);
1675 : :
1676 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 512 + 8, 8, num_blocks,
1677 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22,
1678 : : SPDK_DIF_PI_FORMAT_16);
1679 : :
1680 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1681 : 20 : _iov_free_buf(&iovs[i]);
1682 : : }
1683 : 5 : _iov_free_buf(&bounce_iov);
1684 : 5 : }
1685 : :
1686 : : static void
1687 : 10 : _dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(
1688 : : enum spdk_dif_pi_format dif_pi_format)
1689 : : {
1690 : 8 : struct iovec iovs[4], bounce_iov;
1691 : : int i, num_blocks;
1692 : :
1693 : 10 : num_blocks = 0;
1694 : :
1695 [ + + ]: 50 : for (i = 0; i < 4; i++) {
1696 : 40 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
1697 : 40 : num_blocks += i + 1;
1698 : : }
1699 : :
1700 : 10 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * num_blocks);
1701 : :
1702 : 10 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1703 : : false, SPDK_DIF_TYPE1, 0, 22, 0xFFFF, 0x22, dif_pi_format);
1704 : :
1705 : 10 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1706 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22,
1707 : : dif_pi_format);
1708 : :
1709 : 10 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1710 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22,
1711 : : dif_pi_format);
1712 : :
1713 : 10 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1714 : : false, SPDK_DIF_TYPE1, SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22,
1715 : : dif_pi_format);
1716 : :
1717 [ + + ]: 50 : for (i = 0; i < 4; i++) {
1718 : 40 : _iov_free_buf(&iovs[i]);
1719 : : }
1720 : 10 : _iov_free_buf(&bounce_iov);
1721 : 10 : }
1722 : :
1723 : : static void
1724 : 5 : dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(void)
1725 : : {
1726 : 5 : _dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_32);
1727 : 5 : _dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_64);
1728 : 5 : }
1729 : :
1730 : : static void
1731 : 5 : dif_copy_sec_4096_md_128_prchk_7_multi_iovs(void)
1732 : : {
1733 : 4 : struct iovec iovs[4], bounce_iov;
1734 : : uint32_t dif_flags;
1735 : : int i, num_blocks;
1736 : :
1737 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1738 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1739 : :
1740 : 5 : num_blocks = 0;
1741 : :
1742 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1743 : 20 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
1744 : 20 : num_blocks += i + 1;
1745 : : }
1746 : :
1747 : 5 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * num_blocks);
1748 : :
1749 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1750 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
1751 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1752 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
1753 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1754 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
1755 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1756 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
1757 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1758 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
1759 : 5 : dif_copy_gen_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128, num_blocks,
1760 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
1761 : :
1762 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1763 : 20 : _iov_free_buf(&iovs[i]);
1764 : : }
1765 : 5 : _iov_free_buf(&bounce_iov);
1766 : 5 : }
1767 : :
1768 : : static void
1769 : 5 : dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data(void)
1770 : : {
1771 : 4 : struct iovec iovs[2], bounce_iov;
1772 : : uint32_t dif_flags;
1773 : :
1774 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1775 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1776 : :
1777 : 5 : _iov_alloc_buf(&iovs[0], 256);
1778 : 5 : _iov_alloc_buf(&iovs[1], 256);
1779 : :
1780 : 5 : _iov_alloc_buf(&bounce_iov, 512 + 8);
1781 : :
1782 : 5 : dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 512 + 8, 8, 1,
1783 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
1784 : :
1785 : 5 : _iov_free_buf(&iovs[0]);
1786 : 5 : _iov_free_buf(&iovs[1]);
1787 : 5 : _iov_free_buf(&bounce_iov);
1788 : 5 : }
1789 : :
1790 : : static void
1791 : 5 : dif_copy_sec_4096_md_128_prchk_7_multi_iovs_split_data_test(void)
1792 : : {
1793 : 4 : struct iovec iovs[2], bounce_iov;
1794 : : uint32_t dif_flags;
1795 : :
1796 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1797 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1798 : :
1799 : 5 : _iov_alloc_buf(&iovs[0], 2048);
1800 : 5 : _iov_alloc_buf(&iovs[1], 2048);
1801 : :
1802 : 5 : _iov_alloc_buf(&bounce_iov, 4096 + 128);
1803 : :
1804 : 5 : dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 4096 + 128, 128, 1,
1805 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
1806 : 5 : dif_copy_gen_and_verify(iovs, 2, &bounce_iov, 4096 + 128, 128, 1,
1807 : : false, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
1808 : :
1809 : 5 : _iov_free_buf(&iovs[0]);
1810 : 5 : _iov_free_buf(&iovs[1]);
1811 : 5 : _iov_free_buf(&bounce_iov);
1812 : 5 : }
1813 : :
1814 : : static void
1815 : 5 : dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits(void)
1816 : : {
1817 : 4 : struct iovec iovs[6], bounce_iov;
1818 : : uint32_t dif_flags;
1819 : : int i;
1820 : :
1821 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1822 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1823 : :
1824 : : /* data[0][255:0] */
1825 : 5 : _iov_alloc_buf(&iovs[0], 256);
1826 : :
1827 : : /* data[0][511:256], data[1][255:0] */
1828 : 5 : _iov_alloc_buf(&iovs[1], 256 + 256);
1829 : :
1830 : : /* data[1][382:256] */
1831 : 5 : _iov_alloc_buf(&iovs[2], 128);
1832 : :
1833 : : /* data[1][383] */
1834 : 5 : _iov_alloc_buf(&iovs[3], 1);
1835 : :
1836 : : /* data[1][510:384] */
1837 : 5 : _iov_alloc_buf(&iovs[4], 126);
1838 : :
1839 : : /* data[1][511], data[2][511:0], data[3][511:0] */
1840 : 5 : _iov_alloc_buf(&iovs[5], 1 + 512 * 2);
1841 : :
1842 : 5 : _iov_alloc_buf(&bounce_iov, (512 + 8) * 4);
1843 : :
1844 : 5 : dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 512 + 8, 8, 4,
1845 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
1846 : :
1847 [ + + ]: 35 : for (i = 0; i < 6; i++) {
1848 : 30 : _iov_free_buf(&iovs[i]);
1849 : : }
1850 : 5 : _iov_free_buf(&bounce_iov);
1851 : 5 : }
1852 : :
1853 : : static void
1854 : 5 : dif_copy_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test(void)
1855 : : {
1856 : 4 : struct iovec iovs[6], bounce_iov;
1857 : : uint32_t dif_flags;
1858 : : int i;
1859 : :
1860 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1861 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1862 : :
1863 : : /* data[0][2047:0] */
1864 : 5 : _iov_alloc_buf(&iovs[0], 2048);
1865 : :
1866 : : /* data[0][4095:2048], data[1][2047:0] */
1867 : 5 : _iov_alloc_buf(&iovs[1], 2048 + 2048);
1868 : :
1869 : : /* data[1][3071:2048] */
1870 : 5 : _iov_alloc_buf(&iovs[2], 1024);
1871 : :
1872 : : /* data[1][3072] */
1873 : 5 : _iov_alloc_buf(&iovs[3], 1);
1874 : :
1875 : : /* data[1][4094:3073] */
1876 : 5 : _iov_alloc_buf(&iovs[4], 1022);
1877 : :
1878 : : /* data[1][4095], data[2][4095:0], data[3][4095:0] */
1879 : 5 : _iov_alloc_buf(&iovs[5], 1 + 4096 * 2);
1880 : :
1881 : 5 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * 4);
1882 : :
1883 : 5 : dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 4096 + 128, 128, 4,
1884 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
1885 : 5 : dif_copy_gen_and_verify(iovs, 6, &bounce_iov, 4096 + 128, 128, 4,
1886 : : true, SPDK_DIF_TYPE1, dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
1887 : :
1888 [ + + ]: 35 : for (i = 0; i < 6; i++) {
1889 : 30 : _iov_free_buf(&iovs[i]);
1890 : : }
1891 : 5 : _iov_free_buf(&bounce_iov);
1892 : 5 : }
1893 : :
1894 : : static void
1895 : 240 : _dif_copy_inject_error_and_verify(struct iovec *iovs, int iovcnt, struct iovec *bounce_iov,
1896 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
1897 : : uint32_t inject_flags, bool dif_loc, enum spdk_dif_pi_format dif_pi_format)
1898 : : {
1899 : 240 : struct spdk_dif_ctx ctx = {};
1900 : 240 : struct spdk_dif_error err_blk = {};
1901 : 240 : uint32_t inject_offset = 0, dif_flags;
1902 : : int rc;
1903 : 192 : struct spdk_dif_ctx_init_ext_opts dif_opts;
1904 : :
1905 : 240 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
1906 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
1907 : :
1908 : 240 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size - md_size, 0, num_blocks);
1909 : 240 : CU_ASSERT(rc == 0);
1910 : :
1911 : 240 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
1912 : 240 : dif_opts.dif_pi_format = dif_pi_format;
1913 : 240 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc, SPDK_DIF_TYPE1, dif_flags,
1914 : : 88, 0xFFFF, 0x88, 0, GUARD_SEED, &dif_opts);
1915 [ - + ]: 240 : SPDK_CU_ASSERT_FATAL(rc == 0);
1916 : :
1917 : 240 : rc = spdk_dif_generate_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx);
1918 : 240 : CU_ASSERT(rc == 0);
1919 : :
1920 : 240 : rc = spdk_dif_inject_error(bounce_iov, 1, num_blocks, &ctx, inject_flags, &inject_offset);
1921 : 240 : CU_ASSERT(rc == 0);
1922 : :
1923 : 240 : rc = spdk_dif_verify_copy(iovs, iovcnt, bounce_iov, 1, num_blocks, &ctx, &err_blk);
1924 : 240 : CU_ASSERT(rc != 0);
1925 [ + + ]: 240 : if (inject_flags == SPDK_DIF_DATA_ERROR) {
1926 : 60 : CU_ASSERT(SPDK_DIF_GUARD_ERROR == err_blk.err_type);
1927 : : } else {
1928 : 180 : CU_ASSERT(inject_flags == err_blk.err_type);
1929 : : }
1930 : 240 : CU_ASSERT(inject_offset == err_blk.err_offset);
1931 : 240 : }
1932 : :
1933 : : static void
1934 : 120 : dif_copy_inject_error_and_verify(struct iovec *iovs, int iovcnt, struct iovec *bounce_iov,
1935 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
1936 : : uint32_t inject_flags, enum spdk_dif_pi_format dif_pi_format)
1937 : : {
1938 : : /* The case that DIF is contained in the first 8/16 bytes of metadata. */
1939 : 120 : _dif_copy_inject_error_and_verify(iovs, iovcnt, bounce_iov,
1940 : : block_size, md_size, num_blocks,
1941 : : inject_flags, true, dif_pi_format);
1942 : :
1943 : : /* The case that DIF is contained in the last 8/16 bytes of metadata. */
1944 : 120 : _dif_copy_inject_error_and_verify(iovs, iovcnt, bounce_iov,
1945 : : block_size, md_size, num_blocks,
1946 : : inject_flags, false, dif_pi_format);
1947 : 120 : }
1948 : :
1949 : : static void
1950 : 5 : dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test(void)
1951 : : {
1952 : 4 : struct iovec iovs[4], bounce_iov;
1953 : : int i, num_blocks;
1954 : :
1955 : 5 : num_blocks = 0;
1956 : :
1957 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1958 : 20 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
1959 : 20 : num_blocks += i + 1;
1960 : : }
1961 : :
1962 : 5 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * num_blocks);
1963 : :
1964 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1965 : : num_blocks, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
1966 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1967 : : num_blocks, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1968 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1969 : : num_blocks, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
1970 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1971 : : num_blocks, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
1972 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1973 : : num_blocks, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
1974 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1975 : : num_blocks, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1976 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1977 : : num_blocks, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
1978 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1979 : : num_blocks, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
1980 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1981 : : num_blocks, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
1982 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1983 : : num_blocks, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1984 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1985 : : num_blocks, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
1986 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
1987 : : num_blocks, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
1988 : :
1989 [ + + ]: 25 : for (i = 0; i < 4; i++) {
1990 : 20 : _iov_free_buf(&iovs[i]);
1991 : : }
1992 : 5 : _iov_free_buf(&bounce_iov);
1993 : 5 : }
1994 : :
1995 : : static void
1996 : 5 : dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test(void)
1997 : : {
1998 : 4 : struct iovec iovs[4], bounce_iov;
1999 : : int i;
2000 : :
2001 : 5 : _iov_alloc_buf(&iovs[0], 2048);
2002 : 5 : _iov_alloc_buf(&iovs[1], 2048);
2003 : 5 : _iov_alloc_buf(&iovs[2], 1);
2004 : 5 : _iov_alloc_buf(&iovs[3], 4095);
2005 : :
2006 : 5 : _iov_alloc_buf(&bounce_iov, (4096 + 128) * 2);
2007 : :
2008 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2009 : : 2, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
2010 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2011 : : 2, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2012 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2013 : : 2, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2014 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2015 : : 2, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
2016 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2017 : : 2, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
2018 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2019 : : 2, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2020 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2021 : : 2, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2022 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2023 : : 2, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
2024 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2025 : : 2, SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
2026 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2027 : : 2, SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2028 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2029 : : 2, SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2030 : 5 : dif_copy_inject_error_and_verify(iovs, 4, &bounce_iov, 4096 + 128, 128,
2031 : : 2, SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
2032 : :
2033 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2034 : 20 : _iov_free_buf(&iovs[i]);
2035 : : }
2036 : 5 : _iov_free_buf(&bounce_iov);
2037 : 5 : }
2038 : :
2039 : : static void
2040 : 5 : dix_sec_0_md_8_error(void)
2041 : : {
2042 : 4 : struct spdk_dif_ctx ctx;
2043 : : int rc;
2044 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2045 : :
2046 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2047 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2048 : 5 : rc = spdk_dif_ctx_init(&ctx, 0, 8, false, false, SPDK_DIF_TYPE1, 0,
2049 : : 0, 0, 0, 0, 0, &dif_opts);
2050 : 5 : CU_ASSERT(rc != 0);
2051 : 5 : }
2052 : :
2053 : : static void
2054 : 5 : dix_sec_512_md_0_error(void)
2055 : : {
2056 : 4 : struct spdk_dif_ctx ctx;
2057 : : int rc;
2058 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2059 : :
2060 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2061 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2062 : 5 : rc = spdk_dif_ctx_init(&ctx, 512, 0, false, false, SPDK_DIF_TYPE1, 0,
2063 : : 0, 0, 0, 0, 0, &dif_opts);
2064 : 5 : CU_ASSERT(rc != 0);
2065 : 5 : }
2066 : :
2067 : : static void
2068 : 10 : _dix_sec_512_md_16_error(enum spdk_dif_pi_format dif_pi_format)
2069 : : {
2070 : 8 : struct spdk_dif_ctx ctx;
2071 : : int rc;
2072 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2073 : :
2074 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2075 : 10 : dif_opts.dif_pi_format = dif_pi_format;
2076 : 10 : rc = spdk_dif_ctx_init(&ctx, 512, 16, false, false, SPDK_DIF_TYPE1, 0,
2077 : : 0, 0, 0, 0, 0, &dif_opts);
2078 : 10 : CU_ASSERT(rc != 0);
2079 : 10 : }
2080 : :
2081 : : static void
2082 : 5 : dix_sec_512_md_16_error(void)
2083 : : {
2084 : 5 : _dix_sec_512_md_16_error(SPDK_DIF_PI_FORMAT_32);
2085 : 5 : _dix_sec_512_md_16_error(SPDK_DIF_PI_FORMAT_64);
2086 : 5 : }
2087 : :
2088 : : static void
2089 : 10 : _dix_sec_4096_md_0_8_error(enum spdk_dif_pi_format dif_pi_format)
2090 : : {
2091 : 10 : struct spdk_dif_ctx ctx = {};
2092 : : int rc;
2093 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2094 : :
2095 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2096 : 10 : dif_opts.dif_pi_format = dif_pi_format;
2097 : : /* Metadata size is 0. */
2098 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096, 0, true, false, SPDK_DIF_TYPE1, 0,
2099 : : 0, 0, 0, 0, 0, &dif_opts);
2100 : 10 : CU_ASSERT(rc != 0);
2101 : :
2102 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2103 : 10 : dif_opts.dif_pi_format = dif_pi_format;
2104 : : /* Metadata size is 0. */
2105 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096, 8, true, false, SPDK_DIF_TYPE1, 0,
2106 : : 0, 0, 0, 0, 0, &dif_opts);
2107 : 10 : CU_ASSERT(rc != 0);
2108 : 10 : }
2109 : :
2110 : : static void
2111 : 5 : dix_sec_4096_md_0_8_error(void)
2112 : : {
2113 : 5 : _dix_sec_4096_md_0_8_error(SPDK_DIF_PI_FORMAT_32);
2114 : 5 : _dix_sec_4096_md_0_8_error(SPDK_DIF_PI_FORMAT_64);
2115 : 5 : }
2116 : :
2117 : : static void
2118 : 150 : dix_generate_and_verify(struct iovec *iovs, int iovcnt, struct iovec *md_iov,
2119 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
2120 : : bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
2121 : : uint32_t init_ref_tag, uint16_t apptag_mask, uint16_t app_tag,
2122 : : enum spdk_dif_pi_format dif_pi_format)
2123 : : {
2124 : 120 : struct spdk_dif_ctx ctx;
2125 : : int rc;
2126 : 120 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2127 : :
2128 : 150 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, 0, num_blocks);
2129 : 150 : CU_ASSERT(rc == 0);
2130 : :
2131 : 150 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2132 : 150 : dif_opts.dif_pi_format = dif_pi_format;
2133 : 150 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, false, dif_loc, dif_type, dif_flags,
2134 : : init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
2135 : 150 : CU_ASSERT(rc == 0);
2136 : :
2137 : 150 : rc = spdk_dix_generate(iovs, iovcnt, md_iov, num_blocks, &ctx);
2138 : 150 : CU_ASSERT(rc == 0);
2139 : :
2140 : 150 : rc = spdk_dix_verify(iovs, iovcnt, md_iov, num_blocks, &ctx, NULL);
2141 : 150 : CU_ASSERT(rc == 0);
2142 : :
2143 : 150 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size, 0, num_blocks);
2144 : 150 : CU_ASSERT(rc == 0);
2145 : 150 : }
2146 : :
2147 : : static void
2148 : 5 : dix_sec_512_md_8_prchk_0_single_iov(void)
2149 : : {
2150 : 4 : struct iovec iov, md_iov;
2151 : :
2152 : 5 : _iov_alloc_buf(&iov, 512 * 4);
2153 : 5 : _iov_alloc_buf(&md_iov, 8 * 4);
2154 : :
2155 : 5 : dix_generate_and_verify(&iov, 1, &md_iov, 512, 8, 4, false, SPDK_DIF_TYPE1, 0, 0, 0, 0,
2156 : : SPDK_DIF_PI_FORMAT_16);
2157 : 5 : dix_generate_and_verify(&iov, 1, &md_iov, 512, 8, 4, true, SPDK_DIF_TYPE1, 0, 0, 0, 0,
2158 : : SPDK_DIF_PI_FORMAT_16);
2159 : :
2160 : 5 : _iov_free_buf(&iov);
2161 : 5 : _iov_free_buf(&md_iov);
2162 : 5 : }
2163 : :
2164 : : static void
2165 : 10 : _dix_sec_4096_md_128_prchk_0_single_iov_test(
2166 : : enum spdk_dif_pi_format dif_pi_format)
2167 : : {
2168 : 8 : struct iovec iov, md_iov;
2169 : :
2170 : 10 : _iov_alloc_buf(&iov, 4096 * 4);
2171 : 10 : _iov_alloc_buf(&md_iov, 128 * 4);
2172 : :
2173 : 10 : dix_generate_and_verify(&iov, 1, &md_iov, 4096, 128, 4, false, SPDK_DIF_TYPE1, 0, 0, 0, 0,
2174 : : dif_pi_format);
2175 : 10 : dix_generate_and_verify(&iov, 1, &md_iov, 4096, 128, 4, true, SPDK_DIF_TYPE1, 0, 0, 0, 0,
2176 : : dif_pi_format);
2177 : :
2178 : 10 : _iov_free_buf(&iov);
2179 : 10 : _iov_free_buf(&md_iov);
2180 : 10 : }
2181 : :
2182 : : static void
2183 : 5 : dix_sec_4096_md_128_prchk_0_single_iov_test(void)
2184 : : {
2185 : 5 : _dix_sec_4096_md_128_prchk_0_single_iov_test(SPDK_DIF_PI_FORMAT_32);
2186 : 5 : _dix_sec_4096_md_128_prchk_0_single_iov_test(SPDK_DIF_PI_FORMAT_64);
2187 : 5 : }
2188 : :
2189 : : static void
2190 : 5 : dix_sec_512_md_8_prchk_0_1_2_4_multi_iovs(void)
2191 : : {
2192 : 4 : struct iovec iovs[4], md_iov;
2193 : : int i, num_blocks;
2194 : :
2195 : 5 : num_blocks = 0;
2196 : :
2197 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2198 : 20 : _iov_alloc_buf(&iovs[i], 512 * (i + 1));
2199 : 20 : num_blocks += i + 1;
2200 : : }
2201 : 5 : _iov_alloc_buf(&md_iov, 8 * num_blocks);
2202 : :
2203 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 512, 8, num_blocks, false, SPDK_DIF_TYPE1,
2204 : : 0, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2205 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 512, 8, num_blocks, false, SPDK_DIF_TYPE1,
2206 : : SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2207 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 512, 8, num_blocks, false, SPDK_DIF_TYPE1,
2208 : : SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2209 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 512, 8, num_blocks, false, SPDK_DIF_TYPE1,
2210 : : SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2211 : :
2212 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2213 : 20 : _iov_free_buf(&iovs[i]);
2214 : : }
2215 : 5 : _iov_free_buf(&md_iov);
2216 : 5 : }
2217 : :
2218 : : static void
2219 : 10 : _dix_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(
2220 : : enum spdk_dif_pi_format dif_pi_format)
2221 : : {
2222 : 8 : struct iovec iovs[4], md_iov;
2223 : : int i, num_blocks;
2224 : :
2225 : 10 : num_blocks = 0;
2226 : :
2227 [ + + ]: 50 : for (i = 0; i < 4; i++) {
2228 : 40 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
2229 : 40 : num_blocks += i + 1;
2230 : : }
2231 : 10 : _iov_alloc_buf(&md_iov, 128 * num_blocks);
2232 : :
2233 : 10 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2234 : : 0, 22, 0xFFFF, 0x22, dif_pi_format);
2235 : 10 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2236 : : SPDK_DIF_FLAGS_GUARD_CHECK, 22, 0xFFFF, 0x22, dif_pi_format);
2237 : 10 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2238 : : SPDK_DIF_FLAGS_APPTAG_CHECK, 22, 0xFFFF, 0x22, dif_pi_format);
2239 : 10 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2240 : : SPDK_DIF_FLAGS_REFTAG_CHECK, 22, 0xFFFF, 0x22, dif_pi_format);
2241 : :
2242 [ + + ]: 50 : for (i = 0; i < 4; i++) {
2243 : 40 : _iov_free_buf(&iovs[i]);
2244 : : }
2245 : 10 : _iov_free_buf(&md_iov);
2246 : 10 : }
2247 : :
2248 : : static void
2249 : 5 : dix_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(void)
2250 : : {
2251 : 5 : _dix_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_32);
2252 : 5 : _dix_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test(SPDK_DIF_PI_FORMAT_64);
2253 : 5 : }
2254 : :
2255 : : /* TODO start here */
2256 : :
2257 : : static void
2258 : 5 : dix_sec_4096_md_128_prchk_7_multi_iovs(void)
2259 : : {
2260 : 4 : struct iovec iovs[4], md_iov;
2261 : : uint32_t dif_flags;
2262 : : int i, num_blocks;
2263 : :
2264 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2265 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2266 : :
2267 : 5 : num_blocks = 0;
2268 : :
2269 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2270 : 20 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
2271 : 20 : num_blocks += i + 1;
2272 : : }
2273 : 5 : _iov_alloc_buf(&md_iov, 128 * num_blocks);
2274 : :
2275 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2276 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2277 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
2278 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2279 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2280 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
2281 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
2282 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
2283 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
2284 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
2285 : 5 : dix_generate_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
2286 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
2287 : :
2288 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2289 : 20 : _iov_free_buf(&iovs[i]);
2290 : : }
2291 : 5 : _iov_free_buf(&md_iov);
2292 : 5 : }
2293 : :
2294 : : static void
2295 : 5 : dix_sec_512_md_8_prchk_7_multi_iovs_split_data(void)
2296 : : {
2297 : 4 : struct iovec iovs[2], md_iov;
2298 : : uint32_t dif_flags;
2299 : :
2300 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2301 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2302 : :
2303 : 5 : _iov_alloc_buf(&iovs[0], 256);
2304 : 5 : _iov_alloc_buf(&iovs[1], 256);
2305 : 5 : _iov_alloc_buf(&md_iov, 8);
2306 : :
2307 : 5 : dix_generate_and_verify(iovs, 2, &md_iov, 512, 8, 1, false, SPDK_DIF_TYPE1,
2308 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2309 : :
2310 : 5 : _iov_free_buf(&iovs[0]);
2311 : 5 : _iov_free_buf(&iovs[1]);
2312 : 5 : _iov_free_buf(&md_iov);
2313 : 5 : }
2314 : :
2315 : : static void
2316 : 5 : dix_sec_4096_md_128_prchk_7_multi_iovs_split_data_test(void)
2317 : : {
2318 : 4 : struct iovec iovs[2], md_iov;
2319 : : uint32_t dif_flags;
2320 : :
2321 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2322 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2323 : :
2324 : 5 : _iov_alloc_buf(&iovs[0], 2048);
2325 : 5 : _iov_alloc_buf(&iovs[1], 2048);
2326 : 5 : _iov_alloc_buf(&md_iov, 128);
2327 : :
2328 : 5 : dix_generate_and_verify(iovs, 2, &md_iov, 4096, 128, 1, false, SPDK_DIF_TYPE1,
2329 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
2330 : 5 : dix_generate_and_verify(iovs, 2, &md_iov, 4096, 128, 1, false, SPDK_DIF_TYPE1,
2331 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
2332 : :
2333 : 5 : _iov_free_buf(&iovs[0]);
2334 : 5 : _iov_free_buf(&iovs[1]);
2335 : 5 : _iov_free_buf(&md_iov);
2336 : 5 : }
2337 : :
2338 : : static void
2339 : 5 : dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits(void)
2340 : : {
2341 : 4 : struct iovec iovs[6], md_iov;
2342 : : uint32_t dif_flags;
2343 : : int i;
2344 : :
2345 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2346 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2347 : :
2348 : : /* data[0][255:0] */
2349 : 5 : _iov_alloc_buf(&iovs[0], 256);
2350 : :
2351 : : /* data[0][511:256], data[1][255:0] */
2352 : 5 : _iov_alloc_buf(&iovs[1], 256 + 256);
2353 : :
2354 : : /* data[1][382:256] */
2355 : 5 : _iov_alloc_buf(&iovs[2], 128);
2356 : :
2357 : : /* data[1][383] */
2358 : 5 : _iov_alloc_buf(&iovs[3], 1);
2359 : :
2360 : : /* data[1][510:384] */
2361 : 5 : _iov_alloc_buf(&iovs[4], 126);
2362 : :
2363 : : /* data[1][511], data[2][511:0], data[3][511:0] */
2364 : 5 : _iov_alloc_buf(&iovs[5], 1 + 512 * 2);
2365 : :
2366 : 5 : _iov_alloc_buf(&md_iov, 8 * 4);
2367 : :
2368 : 5 : dix_generate_and_verify(iovs, 6, &md_iov, 512, 8, 4, false, SPDK_DIF_TYPE1,
2369 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
2370 : :
2371 [ + + ]: 35 : for (i = 0; i < 6; i++) {
2372 : 30 : _iov_free_buf(&iovs[i]);
2373 : : }
2374 : 5 : _iov_free_buf(&md_iov);
2375 : 5 : }
2376 : :
2377 : : static void
2378 : 5 : dix_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test(void)
2379 : : {
2380 : 4 : struct iovec iovs[6], md_iov;
2381 : : uint32_t dif_flags;
2382 : : int i;
2383 : :
2384 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2385 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2386 : :
2387 : : /* data[0][2047:0] */
2388 : 5 : _iov_alloc_buf(&iovs[0], 2048);
2389 : :
2390 : : /* data[0][4095:2048], data[1][2047:0] */
2391 : 5 : _iov_alloc_buf(&iovs[1], 2048 + 2048);
2392 : :
2393 : : /* data[1][3071:2048] */
2394 : 5 : _iov_alloc_buf(&iovs[2], 1024);
2395 : :
2396 : : /* data[1][3072] */
2397 : 5 : _iov_alloc_buf(&iovs[3], 1);
2398 : :
2399 : : /* data[1][4094:3073] */
2400 : 5 : _iov_alloc_buf(&iovs[4], 1022);
2401 : :
2402 : : /* data[1][4095], data[2][4095:0], data[3][4095:0] */
2403 : 5 : _iov_alloc_buf(&iovs[5], 1 + 4096 * 2);
2404 : :
2405 : 5 : _iov_alloc_buf(&md_iov, 128 * 4);
2406 : :
2407 : 5 : dix_generate_and_verify(iovs, 6, &md_iov, 4096, 128, 4, false, SPDK_DIF_TYPE1,
2408 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
2409 : 5 : dix_generate_and_verify(iovs, 6, &md_iov, 4096, 128, 4, false, SPDK_DIF_TYPE1,
2410 : : dif_flags, 22, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
2411 : :
2412 [ + + ]: 35 : for (i = 0; i < 6; i++) {
2413 : 30 : _iov_free_buf(&iovs[i]);
2414 : : }
2415 : 5 : _iov_free_buf(&md_iov);
2416 : 5 : }
2417 : :
2418 : : static void
2419 : 240 : _dix_inject_error_and_verify(struct iovec *iovs, int iovcnt, struct iovec *md_iov,
2420 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
2421 : : uint32_t inject_flags, bool dif_loc, enum spdk_dif_pi_format dif_pi_format)
2422 : : {
2423 : 240 : struct spdk_dif_ctx ctx = {};
2424 : 240 : struct spdk_dif_error err_blk = {};
2425 : 240 : uint32_t inject_offset = 0, dif_flags;
2426 : : int rc;
2427 : 192 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2428 : :
2429 : 240 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2430 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2431 : :
2432 : 240 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, 0, num_blocks);
2433 : 240 : CU_ASSERT(rc == 0);
2434 : :
2435 : 240 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2436 : 240 : dif_opts.dif_pi_format = dif_pi_format;
2437 : 240 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, false, dif_loc, SPDK_DIF_TYPE1, dif_flags,
2438 : : 88, 0xFFFF, 0x88, 0, GUARD_SEED, &dif_opts);
2439 : 240 : CU_ASSERT(rc == 0);
2440 : :
2441 : 240 : rc = spdk_dix_generate(iovs, iovcnt, md_iov, num_blocks, &ctx);
2442 : 240 : CU_ASSERT(rc == 0);
2443 : :
2444 : 240 : rc = spdk_dix_inject_error(iovs, iovcnt, md_iov, num_blocks, &ctx, inject_flags, &inject_offset);
2445 : 240 : CU_ASSERT(rc == 0);
2446 : :
2447 : 240 : rc = spdk_dix_verify(iovs, iovcnt, md_iov, num_blocks, &ctx, &err_blk);
2448 : 240 : CU_ASSERT(rc != 0);
2449 : :
2450 [ + + ]: 240 : if (inject_flags == SPDK_DIF_DATA_ERROR) {
2451 : 60 : CU_ASSERT(SPDK_DIF_GUARD_ERROR == err_blk.err_type);
2452 : : } else {
2453 : 180 : CU_ASSERT(inject_flags == err_blk.err_type);
2454 : : }
2455 : 240 : CU_ASSERT(inject_offset == err_blk.err_offset);
2456 : 240 : }
2457 : :
2458 : : static void
2459 : 120 : dix_inject_error_and_verify(struct iovec *iovs, int iovcnt, struct iovec *md_iov,
2460 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
2461 : : uint32_t inject_flags, enum spdk_dif_pi_format dif_pi_format)
2462 : : {
2463 : : /* The case that DIF is contained in the first 8/16 bytes of metadata. */
2464 : 120 : _dix_inject_error_and_verify(iovs, iovcnt, md_iov, block_size, md_size, num_blocks,
2465 : : inject_flags, true, dif_pi_format);
2466 : :
2467 : : /* The case that DIF is contained in the last 8/16 bytes of metadata. */
2468 : 120 : _dix_inject_error_and_verify(iovs, iovcnt, md_iov, block_size, md_size, num_blocks,
2469 : : inject_flags, false, dif_pi_format);
2470 : 120 : }
2471 : :
2472 : : static void
2473 : 5 : dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test(void)
2474 : : {
2475 : 4 : struct iovec iovs[4], md_iov;
2476 : : int i, num_blocks;
2477 : :
2478 : 5 : num_blocks = 0;
2479 : :
2480 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2481 : 20 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
2482 : 20 : num_blocks += i + 1;
2483 : : }
2484 : :
2485 : 5 : _iov_alloc_buf(&md_iov, 128 * num_blocks);
2486 : :
2487 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2488 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
2489 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2490 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2491 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2492 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2493 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2494 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
2495 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2496 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
2497 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2498 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2499 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2500 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2501 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2502 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
2503 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2504 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
2505 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2506 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2507 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2508 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2509 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks,
2510 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
2511 : :
2512 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2513 : 20 : _iov_free_buf(&iovs[i]);
2514 : : }
2515 : 5 : _iov_free_buf(&md_iov);
2516 : 5 : }
2517 : :
2518 : : static void
2519 : 5 : dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test(void)
2520 : : {
2521 : 4 : struct iovec iovs[4], md_iov;
2522 : : int i;
2523 : :
2524 : 5 : _iov_alloc_buf(&iovs[0], 2048);
2525 : 5 : _iov_alloc_buf(&iovs[1], 2048);
2526 : 5 : _iov_alloc_buf(&iovs[2], 1);
2527 : 5 : _iov_alloc_buf(&iovs[3], 4095);
2528 : :
2529 : 5 : _iov_alloc_buf(&md_iov, 128 * 2);
2530 : :
2531 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2532 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_16);
2533 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2534 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2535 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2536 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_16);
2537 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2538 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_16);
2539 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2540 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_32);
2541 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2542 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2543 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2544 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_32);
2545 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2546 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_32);
2547 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2548 : : SPDK_DIF_GUARD_ERROR, SPDK_DIF_PI_FORMAT_64);
2549 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2550 : : SPDK_DIF_APPTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2551 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2552 : : SPDK_DIF_REFTAG_ERROR, SPDK_DIF_PI_FORMAT_64);
2553 : 5 : dix_inject_error_and_verify(iovs, 4, &md_iov, 4096, 128, 2,
2554 : : SPDK_DIF_DATA_ERROR, SPDK_DIF_PI_FORMAT_64);
2555 : :
2556 [ + + ]: 25 : for (i = 0; i < 4; i++) {
2557 : 20 : _iov_free_buf(&iovs[i]);
2558 : : }
2559 : 5 : _iov_free_buf(&md_iov);
2560 : 5 : }
2561 : :
2562 : : static int
2563 : 140 : ut_readv(uint32_t read_base, uint32_t read_len, struct iovec *iovs, int iovcnt)
2564 : : {
2565 : : int i;
2566 : : uint32_t j, offset;
2567 : : uint8_t *buf;
2568 : :
2569 : 140 : offset = 0;
2570 [ + + ]: 375 : for (i = 0; i < iovcnt; i++) {
2571 : 315 : buf = iovs[i].iov_base;
2572 [ + + ]: 502075 : for (j = 0; j < iovs[i].iov_len; j++, offset++) {
2573 [ + + ]: 501840 : if (offset >= read_len) {
2574 : 80 : return offset;
2575 : : }
2576 : 501760 : buf[j] = DATA_PATTERN(read_base + offset);
2577 : : }
2578 : : }
2579 : :
2580 : 60 : return offset;
2581 : : }
2582 : :
2583 : : static void
2584 : 15 : _set_md_interleave_iovs_test(enum spdk_dif_pi_format dif_pi_format)
2585 : : {
2586 : 15 : struct spdk_dif_ctx ctx = {};
2587 : 15 : struct spdk_dif_error err_blk = {};
2588 : 15 : struct iovec iov1, iov2, dif_iovs[4] = {};
2589 : 15 : uint32_t dif_check_flags, data_len, read_len, data_offset, mapped_len = 0;
2590 : : uint8_t *buf1, *buf2;
2591 : : int rc;
2592 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2593 : :
2594 : 15 : dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2595 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2596 : :
2597 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2598 : 15 : dif_opts.dif_pi_format = dif_pi_format;
2599 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
2600 : : dif_check_flags, 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
2601 : 15 : CU_ASSERT(rc == 0);
2602 : :
2603 : : /* The first data buffer:
2604 : : * - Create iovec array to Leave a space for metadata for each block
2605 : : * - Split vectored read and so creating iovec array is done before every vectored read.
2606 : : */
2607 : 15 : buf1 = calloc(1, (4096 + 128) * 4);
2608 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf1 != NULL);
2609 : 15 : _iov_set_buf(&iov1, buf1, (4096 + 128) * 4);
2610 : :
2611 : 15 : data_offset = 0;
2612 : 15 : data_len = 4096 * 4;
2613 : :
2614 : : /* 1st read */
2615 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
2616 : : data_offset, data_len, &mapped_len, &ctx);
2617 : 15 : CU_ASSERT(rc == 4);
2618 : 15 : CU_ASSERT(mapped_len == 4096 * 4);
2619 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1, 4096) == true);
2620 : 15 : CU_ASSERT(_iov_check(&dif_iovs[1], buf1 + 4096 + 128, 4096) == true);
2621 : 15 : CU_ASSERT(_iov_check(&dif_iovs[2], buf1 + (4096 + 128) * 2, 4096) == true);
2622 : 15 : CU_ASSERT(_iov_check(&dif_iovs[3], buf1 + (4096 + 128) * 3, 4096) == true);
2623 : :
2624 : 15 : read_len = ut_readv(data_offset, 1024, dif_iovs, 4);
2625 : 15 : CU_ASSERT(read_len == 1024);
2626 : :
2627 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, data_offset, read_len, &ctx);
2628 : 15 : CU_ASSERT(rc == 0);
2629 : :
2630 : 15 : data_offset += read_len;
2631 : 15 : data_len -= read_len;
2632 : :
2633 : : /* 2nd read */
2634 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
2635 : : data_offset, data_len, &mapped_len, &ctx);
2636 : 15 : CU_ASSERT(rc == 4);
2637 : 15 : CU_ASSERT(mapped_len == 3072 + 4096 * 3);
2638 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + 1024, 3072) == true);
2639 : 15 : CU_ASSERT(_iov_check(&dif_iovs[1], buf1 + 4096 + 128, 4096) == true);
2640 : 15 : CU_ASSERT(_iov_check(&dif_iovs[2], buf1 + (4096 + 128) * 2, 4096) == true);
2641 : 15 : CU_ASSERT(_iov_check(&dif_iovs[3], buf1 + (4096 + 128) * 3, 4096) == true);
2642 : :
2643 : 15 : read_len = ut_readv(data_offset, 3071, dif_iovs, 4);
2644 : 15 : CU_ASSERT(read_len == 3071);
2645 : :
2646 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, data_offset, read_len, &ctx);
2647 : 15 : CU_ASSERT(rc == 0);
2648 : :
2649 : 15 : data_offset += read_len;
2650 : 15 : data_len -= read_len;
2651 : :
2652 : : /* 3rd read */
2653 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
2654 : : data_offset, data_len, &mapped_len, &ctx);
2655 : 15 : CU_ASSERT(rc == 4);
2656 : 15 : CU_ASSERT(mapped_len == 1 + 4096 * 3);
2657 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + 4095, 1) == true);
2658 : 15 : CU_ASSERT(_iov_check(&dif_iovs[1], buf1 + 4096 + 128, 4096) == true);
2659 : 15 : CU_ASSERT(_iov_check(&dif_iovs[2], buf1 + (4096 + 128) * 2, 4096) == true);
2660 : 15 : CU_ASSERT(_iov_check(&dif_iovs[3], buf1 + (4096 + 128) * 3, 4096) == true);
2661 : :
2662 : 15 : read_len = ut_readv(data_offset, 1 + 4096 * 2 + 512, dif_iovs, 4);
2663 : 15 : CU_ASSERT(read_len == 1 + 4096 * 2 + 512);
2664 : :
2665 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, data_offset, read_len, &ctx);
2666 : 15 : CU_ASSERT(rc == 0);
2667 : :
2668 : 15 : data_offset += read_len;
2669 : 15 : data_len -= read_len;
2670 : :
2671 : : /* 4th read */
2672 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
2673 : : data_offset, data_len, &mapped_len, &ctx);
2674 : 15 : CU_ASSERT(rc == 1);
2675 : 15 : CU_ASSERT(mapped_len == 3584);
2676 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + (4096 + 128) * 3 + 512, 3584) == true);
2677 : :
2678 : 15 : read_len = ut_readv(data_offset, 3584, dif_iovs, 1);
2679 : 15 : CU_ASSERT(read_len == 3584);
2680 : :
2681 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, data_offset, read_len, &ctx);
2682 : 15 : CU_ASSERT(rc == 0);
2683 : :
2684 : 15 : data_offset += read_len;
2685 : 15 : CU_ASSERT(data_offset == 4096 * 4);
2686 : 15 : data_len -= read_len;
2687 : 15 : CU_ASSERT(data_len == 0);
2688 : :
2689 : : /* The second data buffer:
2690 : : * - Set data pattern with a space for metadata for each block.
2691 : : */
2692 : 15 : buf2 = calloc(1, (4096 + 128) * 4);
2693 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf2 != NULL);
2694 : 15 : _iov_set_buf(&iov2, buf2, (4096 + 128) * 4);
2695 : :
2696 : 15 : rc = ut_data_pattern_generate(&iov2, 1, 4096 + 128, 128, 4);
2697 : 15 : CU_ASSERT(rc == 0);
2698 : 15 : rc = spdk_dif_generate(&iov2, 1, 4, &ctx);
2699 : 15 : CU_ASSERT(rc == 0);
2700 : :
2701 : 15 : rc = spdk_dif_verify(&iov1, 1, 4, &ctx, &err_blk);
2702 : 15 : CU_ASSERT(rc == 0);
2703 : :
2704 : 15 : rc = spdk_dif_verify(&iov2, 1, 4, &ctx, &err_blk);
2705 : 15 : CU_ASSERT(rc == 0);
2706 : :
2707 : : /* Compare the first and the second data buffer by byte. */
2708 [ - + - + ]: 15 : rc = memcmp(buf1, buf2, (4096 + 128) * 4);
2709 : 15 : CU_ASSERT(rc == 0);
2710 : :
2711 : 15 : free(buf1);
2712 : 15 : free(buf2);
2713 : 15 : }
2714 : :
2715 : : static void
2716 : 5 : set_md_interleave_iovs_test(void)
2717 : : {
2718 : 5 : _set_md_interleave_iovs_test(SPDK_DIF_PI_FORMAT_16);
2719 : 5 : _set_md_interleave_iovs_test(SPDK_DIF_PI_FORMAT_32);
2720 : 5 : _set_md_interleave_iovs_test(SPDK_DIF_PI_FORMAT_64);
2721 : 5 : }
2722 : :
2723 : : static void
2724 : 5 : set_md_interleave_iovs_split_test(void)
2725 : : {
2726 : 5 : struct spdk_dif_ctx ctx = {};
2727 : 5 : struct spdk_dif_error err_blk = {};
2728 : 5 : struct iovec iovs1[7], iovs2[7], dif_iovs[8] = {};
2729 : 5 : uint32_t dif_check_flags, data_len, read_len, data_offset, mapped_len = 0;
2730 : : int rc, i;
2731 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2732 : :
2733 : 5 : dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2734 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2735 : :
2736 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2737 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2738 : 5 : rc = spdk_dif_ctx_init(&ctx, 512 + 8, 8, true, false, SPDK_DIF_TYPE1,
2739 : : dif_check_flags, 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
2740 : 5 : CU_ASSERT(rc == 0);
2741 : :
2742 : : /* The first SGL data buffer:
2743 : : * - Create iovec array to leave a space for metadata for each block
2744 : : * - Split vectored read and so creating iovec array is done before every vectored read.
2745 : : */
2746 : 5 : _iov_alloc_buf(&iovs1[0], 512 + 8 + 128);
2747 : 5 : _iov_alloc_buf(&iovs1[1], 128);
2748 : 5 : _iov_alloc_buf(&iovs1[2], 256 + 8);
2749 : 5 : _iov_alloc_buf(&iovs1[3], 100);
2750 : 5 : _iov_alloc_buf(&iovs1[4], 412 + 5);
2751 : 5 : _iov_alloc_buf(&iovs1[5], 3 + 300);
2752 : 5 : _iov_alloc_buf(&iovs1[6], 212 + 8);
2753 : :
2754 : 5 : data_offset = 0;
2755 : 5 : data_len = 512 * 4;
2756 : :
2757 : : /* 1st read */
2758 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 8, iovs1, 7,
2759 : : data_offset, data_len, &mapped_len, &ctx);
2760 : 5 : CU_ASSERT(rc == 8);
2761 : 5 : CU_ASSERT(mapped_len == 512 * 4);
2762 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], iovs1[0].iov_base, 512) == true);
2763 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], iovs1[0].iov_base + 512 + 8, 128) == true);
2764 : 5 : CU_ASSERT(_iov_check(&dif_iovs[2], iovs1[1].iov_base, 128) == true);
2765 : 5 : CU_ASSERT(_iov_check(&dif_iovs[3], iovs1[2].iov_base, 256) == true);
2766 : 5 : CU_ASSERT(_iov_check(&dif_iovs[4], iovs1[3].iov_base, 100) == true);
2767 : 5 : CU_ASSERT(_iov_check(&dif_iovs[5], iovs1[4].iov_base, 412) == true);
2768 : 5 : CU_ASSERT(_iov_check(&dif_iovs[6], iovs1[5].iov_base + 3, 300) == true);
2769 : 5 : CU_ASSERT(_iov_check(&dif_iovs[7], iovs1[6].iov_base, 212) == true);
2770 : :
2771 : 5 : read_len = ut_readv(data_offset, 128, dif_iovs, 8);
2772 : 5 : CU_ASSERT(read_len == 128);
2773 : :
2774 : 5 : rc = spdk_dif_generate_stream(iovs1, 7, data_offset, read_len, &ctx);
2775 : 5 : CU_ASSERT(rc == 0);
2776 : :
2777 : 5 : data_offset += read_len;
2778 : 5 : data_len -= read_len;
2779 : :
2780 : : /* 2nd read */
2781 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 8, iovs1, 7,
2782 : : data_offset, data_len, &mapped_len, &ctx);
2783 : 5 : CU_ASSERT(rc == 8);
2784 : 5 : CU_ASSERT(mapped_len == 384 + 512 * 3);
2785 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], iovs1[0].iov_base + 128, 384) == true);
2786 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], iovs1[0].iov_base + 512 + 8, 128) == true);
2787 : 5 : CU_ASSERT(_iov_check(&dif_iovs[2], iovs1[1].iov_base, 128) == true);
2788 : 5 : CU_ASSERT(_iov_check(&dif_iovs[3], iovs1[2].iov_base, 256) == true);
2789 : 5 : CU_ASSERT(_iov_check(&dif_iovs[4], iovs1[3].iov_base, 100) == true);
2790 : 5 : CU_ASSERT(_iov_check(&dif_iovs[5], iovs1[4].iov_base, 412) == true);
2791 : 5 : CU_ASSERT(_iov_check(&dif_iovs[6], iovs1[5].iov_base + 3, 300) == true);
2792 : 5 : CU_ASSERT(_iov_check(&dif_iovs[7], iovs1[6].iov_base, 212) == true);
2793 : :
2794 : 5 : read_len = ut_readv(data_offset, 383, dif_iovs, 8);
2795 : 5 : CU_ASSERT(read_len == 383);
2796 : :
2797 : 5 : rc = spdk_dif_generate_stream(iovs1, 7, data_offset, read_len, &ctx);
2798 : 5 : CU_ASSERT(rc == 0);
2799 : :
2800 : 5 : data_offset += read_len;
2801 : 5 : data_len -= read_len;
2802 : :
2803 : : /* 3rd read */
2804 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 8, iovs1, 7,
2805 : : data_offset, data_len, &mapped_len, &ctx);
2806 : 5 : CU_ASSERT(rc == 8);
2807 : 5 : CU_ASSERT(mapped_len == 1 + 512 * 3);
2808 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], iovs1[0].iov_base + 511, 1) == true);
2809 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], iovs1[0].iov_base + 512 + 8, 128) == true);
2810 : 5 : CU_ASSERT(_iov_check(&dif_iovs[2], iovs1[1].iov_base, 128) == true);
2811 : 5 : CU_ASSERT(_iov_check(&dif_iovs[3], iovs1[2].iov_base, 256) == true);
2812 : 5 : CU_ASSERT(_iov_check(&dif_iovs[4], iovs1[3].iov_base, 100) == true);
2813 : 5 : CU_ASSERT(_iov_check(&dif_iovs[5], iovs1[4].iov_base, 412) == true);
2814 : 5 : CU_ASSERT(_iov_check(&dif_iovs[6], iovs1[5].iov_base + 3, 300) == true);
2815 : 5 : CU_ASSERT(_iov_check(&dif_iovs[7], iovs1[6].iov_base, 212) == true);
2816 : :
2817 : 5 : read_len = ut_readv(data_offset, 1 + 512 * 2 + 128, dif_iovs, 8);
2818 : 5 : CU_ASSERT(read_len == 1 + 512 * 2 + 128);
2819 : :
2820 : 5 : rc = spdk_dif_generate_stream(iovs1, 7, data_offset, read_len, &ctx);
2821 : 5 : CU_ASSERT(rc == 0);
2822 : :
2823 : 5 : data_offset += read_len;
2824 : 5 : data_len -= read_len;
2825 : :
2826 : : /* 4th read */
2827 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 8, iovs1, 7,
2828 : : data_offset, data_len, &mapped_len, &ctx);
2829 : 5 : CU_ASSERT(rc == 2);
2830 : 5 : CU_ASSERT(mapped_len == 384);
2831 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], iovs1[5].iov_base + 3 + 128, 172) == true);
2832 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], iovs1[6].iov_base, 212) == true);
2833 : :
2834 : 5 : read_len = ut_readv(data_offset, 384, dif_iovs, 8);
2835 : 5 : CU_ASSERT(read_len == 384);
2836 : :
2837 : 5 : rc = spdk_dif_generate_stream(iovs1, 7, data_offset, read_len, &ctx);
2838 : 5 : CU_ASSERT(rc == 0);
2839 : :
2840 : 5 : data_offset += read_len;
2841 : 5 : CU_ASSERT(data_offset == 512 * 4);
2842 : 5 : data_len -= read_len;
2843 : 5 : CU_ASSERT(data_len == 0);
2844 : :
2845 : : /* The second SGL data buffer:
2846 : : * - Set data pattern with a space for metadata for each block.
2847 : : */
2848 : 5 : _iov_alloc_buf(&iovs2[0], 512 + 8 + 128);
2849 : 5 : _iov_alloc_buf(&iovs2[1], 128);
2850 : 5 : _iov_alloc_buf(&iovs2[2], 256 + 8);
2851 : 5 : _iov_alloc_buf(&iovs2[3], 100);
2852 : 5 : _iov_alloc_buf(&iovs2[4], 412 + 5);
2853 : 5 : _iov_alloc_buf(&iovs2[5], 3 + 300);
2854 : 5 : _iov_alloc_buf(&iovs2[6], 212 + 8);
2855 : :
2856 : 5 : rc = ut_data_pattern_generate(iovs2, 7, 512 + 8, 8, 4);
2857 : 5 : CU_ASSERT(rc == 0);
2858 : 5 : rc = spdk_dif_generate(iovs2, 7, 4, &ctx);
2859 : 5 : CU_ASSERT(rc == 0);
2860 : :
2861 : 5 : rc = spdk_dif_verify(iovs1, 7, 4, &ctx, &err_blk);
2862 : 5 : CU_ASSERT(rc == 0);
2863 : :
2864 : 5 : rc = spdk_dif_verify(iovs2, 7, 4, &ctx, &err_blk);
2865 : 5 : CU_ASSERT(rc == 0);
2866 : :
2867 : : /* Compare the first and the second SGL data buffer by byte. */
2868 [ + + ]: 40 : for (i = 0; i < 7; i++) {
2869 [ - + - + ]: 35 : rc = memcmp(iovs1[i].iov_base, iovs2[i].iov_base,
2870 : 28 : iovs1[i].iov_len);
2871 : 35 : CU_ASSERT(rc == 0);
2872 : : }
2873 : :
2874 [ + + ]: 40 : for (i = 0; i < 7; i++) {
2875 : 35 : _iov_free_buf(&iovs1[i]);
2876 : 35 : _iov_free_buf(&iovs2[i]);
2877 : : }
2878 : 5 : }
2879 : :
2880 : : static void
2881 : 5 : dif_generate_stream_pi_16_test(void)
2882 : : {
2883 : 4 : struct iovec iov;
2884 : 4 : struct spdk_dif_ctx ctx;
2885 : 4 : struct spdk_dif_error err_blk;
2886 : : uint32_t dif_flags;
2887 : : int rc;
2888 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2889 : :
2890 : 5 : _iov_alloc_buf(&iov, (512 + 8) * 5);
2891 : :
2892 : 5 : rc = ut_data_pattern_generate(&iov, 1, 512 + 8, 8, 5);
2893 : 5 : CU_ASSERT(rc == 0);
2894 : :
2895 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2896 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2897 : :
2898 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2899 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
2900 : 5 : rc = spdk_dif_ctx_init(&ctx, 512 + 8, 8, true, false, SPDK_DIF_TYPE1, dif_flags,
2901 : : 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
2902 : 5 : CU_ASSERT(rc == 0);
2903 : :
2904 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 0, 511, &ctx);
2905 : 5 : CU_ASSERT(rc == 0);
2906 : :
2907 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 511, 1, &ctx);
2908 : 5 : CU_ASSERT(rc == 0);
2909 : :
2910 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 512, 256, &ctx);
2911 : 5 : CU_ASSERT(rc == 0);
2912 : :
2913 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 768, 512, &ctx);
2914 : 5 : CU_ASSERT(rc == 0);
2915 : :
2916 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 1280, 1024, &ctx);
2917 : 5 : CU_ASSERT(rc == 0);
2918 : :
2919 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 2304, 256, &ctx);
2920 : 5 : CU_ASSERT(rc == 0);
2921 : :
2922 : 5 : rc = spdk_dif_generate_stream(&iov, 1, 2560, 512, &ctx);
2923 : 5 : CU_ASSERT(rc == -ERANGE);
2924 : :
2925 : 5 : rc = spdk_dif_verify(&iov, 1, 5, &ctx, &err_blk);
2926 : 5 : CU_ASSERT(rc == 0);
2927 : :
2928 : 5 : rc = ut_data_pattern_verify(&iov, 1, 512 + 8, 8, 5);
2929 : 5 : CU_ASSERT(rc == 0);
2930 : :
2931 : 5 : _iov_free_buf(&iov);
2932 : 5 : }
2933 : :
2934 : : static void
2935 : 10 : _dif_generate_stream_test(enum spdk_dif_pi_format dif_pi_format)
2936 : : {
2937 : 8 : struct iovec iov;
2938 : 8 : struct spdk_dif_ctx ctx;
2939 : 8 : struct spdk_dif_error err_blk;
2940 : : uint32_t dif_flags;
2941 : : int rc;
2942 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
2943 : :
2944 : 10 : _iov_alloc_buf(&iov, (4096 + 128) * 5);
2945 : :
2946 : 10 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 5);
2947 : 10 : CU_ASSERT(rc == 0);
2948 : :
2949 : 10 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
2950 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
2951 : :
2952 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
2953 : 10 : dif_opts.dif_pi_format = dif_pi_format;
2954 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1, dif_flags,
2955 : : 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
2956 : 10 : CU_ASSERT(rc == 0);
2957 : :
2958 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 0, 4095, &ctx);
2959 : 10 : CU_ASSERT(rc == 0);
2960 : :
2961 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 4095, 1, &ctx);
2962 : 10 : CU_ASSERT(rc == 0);
2963 : :
2964 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 4096, 2048, &ctx);
2965 : 10 : CU_ASSERT(rc == 0);
2966 : :
2967 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 6144, 4096, &ctx);
2968 : 10 : CU_ASSERT(rc == 0);
2969 : :
2970 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 10240, 8192, &ctx);
2971 : 10 : CU_ASSERT(rc == 0);
2972 : :
2973 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 18432, 2048, &ctx);
2974 : 10 : CU_ASSERT(rc == 0);
2975 : :
2976 : 10 : rc = spdk_dif_generate_stream(&iov, 1, 20480, 4096, &ctx);
2977 : 10 : CU_ASSERT(rc == -ERANGE);
2978 : :
2979 : 10 : rc = spdk_dif_verify(&iov, 1, 5, &ctx, &err_blk);
2980 : 10 : CU_ASSERT(rc == 0);
2981 : :
2982 : 10 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 5);
2983 : 10 : CU_ASSERT(rc == 0);
2984 : :
2985 : 10 : _iov_free_buf(&iov);
2986 : 10 : }
2987 : :
2988 : : static void
2989 : 5 : dif_generate_stream_test(void)
2990 : : {
2991 : 5 : _dif_generate_stream_test(SPDK_DIF_PI_FORMAT_32);
2992 : 5 : _dif_generate_stream_test(SPDK_DIF_PI_FORMAT_64);
2993 : 5 : }
2994 : :
2995 : : static void
2996 : 5 : set_md_interleave_iovs_alignment_test(void)
2997 : : {
2998 : 5 : struct iovec iovs[3], dif_iovs[5] = {};
2999 : 5 : uint32_t mapped_len = 0;
3000 : : int rc;
3001 : 4 : struct spdk_dif_ctx ctx;
3002 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3003 : :
3004 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3005 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
3006 : 5 : rc = spdk_dif_ctx_init(&ctx, 512 + 8, 8, true, false, SPDK_DIF_TYPE1,
3007 : : 0, 0, 0, 0, 0, 0, &dif_opts);
3008 : 5 : CU_ASSERT(rc == 0);
3009 : :
3010 : : /* The case that buffer size is smaller than necessary. */
3011 : 5 : _iov_set_buf(&iovs[0], (uint8_t *)0xDEADBEEF, 1024);
3012 : 5 : _iov_set_buf(&iovs[1], (uint8_t *)0xFEEDBEEF, 1024);
3013 : 5 : _iov_set_buf(&iovs[2], (uint8_t *)0xC0FFEE, 24);
3014 : :
3015 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 5, iovs, 3, 0, 2048, &mapped_len, &ctx);
3016 : 5 : CU_ASSERT(rc == -ERANGE);
3017 : :
3018 : : /* The following are the normal cases. */
3019 : 5 : _iov_set_buf(&iovs[2], (uint8_t *)0xC0FFEE, 32);
3020 : :
3021 : : /* data length is less than a data block size. */
3022 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 5, iovs, 3, 0, 500, &mapped_len, &ctx);
3023 : 5 : CU_ASSERT(rc == 1);
3024 : 5 : CU_ASSERT(mapped_len == 500);
3025 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], (void *)0xDEADBEEF, 500) == true);
3026 : :
3027 : : /* Pass enough number of iovecs */
3028 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 5, iovs, 3, 500, 1000, &mapped_len, &ctx);
3029 : 5 : CU_ASSERT(rc == 4);
3030 : 5 : CU_ASSERT(mapped_len == 1000);
3031 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], (void *)(0xDEADBEEF + 500), 12) == true);
3032 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], (void *)(0xDEADBEEF + 520), 504) == true);
3033 : 5 : CU_ASSERT(_iov_check(&dif_iovs[2], (void *)0xFEEDBEEF, 8) == true);
3034 : 5 : CU_ASSERT(_iov_check(&dif_iovs[3], (void *)(0xFEEDBEEF + 16), 476) == true);
3035 : :
3036 : : /* Pass iovecs smaller than necessary */
3037 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 3, iovs, 3, 500, 1000, &mapped_len, &ctx);
3038 : 5 : CU_ASSERT(rc == 3);
3039 : 5 : CU_ASSERT(mapped_len == 524);
3040 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], (void *)(0xDEADBEEF + 500), 12) == true);
3041 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], (void *)(0xDEADBEEF + 520), 504) == true);
3042 : 5 : CU_ASSERT(_iov_check(&dif_iovs[2], (void *)0xFEEDBEEF, 8) == true);
3043 : :
3044 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 5, iovs, 3, 1500, 500, &mapped_len, &ctx);
3045 : 5 : CU_ASSERT(rc == 2);
3046 : 5 : CU_ASSERT(mapped_len == 500);
3047 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], (void *)(0xFEEDBEEF + 492), 36) == true);
3048 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], (void *)(0xFEEDBEEF + 536), 464) == true);
3049 : :
3050 : 5 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 5, iovs, 3, 2000, 48, &mapped_len, &ctx);
3051 : 5 : CU_ASSERT(rc == 2);
3052 : 5 : CU_ASSERT(mapped_len == 48);
3053 : 5 : CU_ASSERT(_iov_check(&dif_iovs[0], (void *)0xFEEDBEEF + 1000, 24) == true);
3054 : 5 : CU_ASSERT(_iov_check(&dif_iovs[1], (void *)0xC0FFEE, 24) == true);
3055 : 5 : }
3056 : :
3057 : : static void
3058 : 15 : _dif_generate_split_test(enum spdk_dif_pi_format dif_pi_format)
3059 : : {
3060 : 15 : struct spdk_dif_ctx ctx = {};
3061 : 12 : struct iovec iov;
3062 : : uint8_t *buf1, *buf2;
3063 : 12 : struct _dif_sgl sgl;
3064 : 15 : uint64_t guard = 0, prev_guard;
3065 : : uint32_t dif_flags;
3066 : : int rc;
3067 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3068 : :
3069 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3070 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3071 : :
3072 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3073 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3074 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3075 : : dif_flags, 0, 0, 0, 0, GUARD_SEED, &dif_opts);
3076 : 15 : CU_ASSERT(rc == 0);
3077 : :
3078 : 15 : buf1 = calloc(1, 4096 + 128);
3079 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf1 != NULL);
3080 : 15 : _iov_set_buf(&iov, buf1, 4096 + 128);
3081 : :
3082 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
3083 : 15 : CU_ASSERT(rc == 0);
3084 : :
3085 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3086 : :
3087 : 15 : guard = GUARD_SEED;
3088 : 15 : prev_guard = GUARD_SEED;
3089 : :
3090 : 15 : guard = _dif_generate_split(&sgl, 0, 1000, guard, 0, &ctx);
3091 : 15 : CU_ASSERT(sgl.iov_offset == 1000);
3092 : 15 : CU_ASSERT(guard == _generate_guard(prev_guard, buf1, 1000, dif_pi_format));
3093 : :
3094 : 15 : prev_guard = guard;
3095 : :
3096 : 15 : guard = _dif_generate_split(&sgl, 1000, 3000, guard, 0, &ctx);
3097 : 15 : CU_ASSERT(sgl.iov_offset == 4000);
3098 : 15 : CU_ASSERT(guard == _generate_guard(prev_guard, buf1 + 1000, 3000, dif_pi_format));
3099 : :
3100 : 15 : guard = _dif_generate_split(&sgl, 4000, 96 + 128, guard, 0, &ctx);
3101 : 15 : CU_ASSERT(guard == GUARD_SEED);
3102 : 15 : CU_ASSERT(sgl.iov_offset == 0);
3103 : 15 : CU_ASSERT(sgl.iovcnt == 0);
3104 : :
3105 : 15 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 1);
3106 : 15 : CU_ASSERT(rc == 0);
3107 : :
3108 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3109 : :
3110 : 15 : rc = dif_verify(&sgl, 1, &ctx, NULL);
3111 : 15 : CU_ASSERT(rc == 0);
3112 : :
3113 : 15 : buf2 = calloc(1, 4096 + 128);
3114 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf2 != NULL);
3115 : 15 : _iov_set_buf(&iov, buf2, 4096 + 128);
3116 : :
3117 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
3118 : 15 : CU_ASSERT(rc == 0);
3119 : :
3120 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3121 : :
3122 : 15 : dif_generate(&sgl, 1, &ctx);
3123 : :
3124 : 15 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 1);
3125 : 15 : CU_ASSERT(rc == 0);
3126 : :
3127 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3128 : :
3129 : 15 : rc = dif_verify(&sgl, 1, &ctx, NULL);
3130 : 15 : CU_ASSERT(rc == 0);
3131 : :
3132 [ - + - + ]: 15 : rc = memcmp(buf1, buf2, 4096 + 128);
3133 : 15 : CU_ASSERT(rc == 0);
3134 : :
3135 : 15 : free(buf1);
3136 : 15 : free(buf2);
3137 : 15 : }
3138 : :
3139 : : static void
3140 : 5 : dif_generate_split_test(void)
3141 : : {
3142 : 5 : _dif_generate_split_test(SPDK_DIF_PI_FORMAT_16);
3143 : 5 : _dif_generate_split_test(SPDK_DIF_PI_FORMAT_32);
3144 : 5 : _dif_generate_split_test(SPDK_DIF_PI_FORMAT_64);
3145 : 5 : }
3146 : :
3147 : : static void
3148 : 15 : _set_md_interleave_iovs_multi_segments_test(enum spdk_dif_pi_format dif_pi_format)
3149 : : {
3150 : 15 : struct spdk_dif_ctx ctx = {};
3151 : 15 : struct spdk_dif_error err_blk = {};
3152 : 15 : struct iovec iov1 = {}, iov2 = {}, dif_iovs[4] = {};
3153 : 15 : uint32_t dif_check_flags, data_len, read_len, data_offset, read_offset, mapped_len = 0;
3154 : : uint8_t *buf1, *buf2;
3155 : : int rc;
3156 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3157 : :
3158 : 15 : dif_check_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3159 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3160 : :
3161 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3162 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3163 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3164 : : dif_check_flags, 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
3165 : 15 : CU_ASSERT(rc == 0);
3166 : :
3167 : : /* The first data buffer:
3168 : : * - Data buffer is split into multi data segments
3169 : : * - For each data segment,
3170 : : * - Create iovec array to Leave a space for metadata for each block
3171 : : * - Split vectored read and so creating iovec array is done before every vectored read.
3172 : : */
3173 : 15 : buf1 = calloc(1, (4096 + 128) * 4);
3174 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf1 != NULL);
3175 : 15 : _iov_set_buf(&iov1, buf1, (4096 + 128) * 4);
3176 : :
3177 : : /* 1st data segment */
3178 : 15 : data_offset = 0;
3179 : 15 : data_len = 1024;
3180 : :
3181 : 15 : spdk_dif_ctx_set_data_offset(&ctx, data_offset);
3182 : :
3183 : 15 : read_offset = 0;
3184 : :
3185 : : /* 1st read in 1st data segment */
3186 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
3187 : : read_offset, data_len - read_offset,
3188 : : &mapped_len, &ctx);
3189 : 15 : CU_ASSERT(rc == 1);
3190 : 15 : CU_ASSERT(mapped_len == 1024);
3191 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1, 1024) == true);
3192 : :
3193 : 15 : read_len = ut_readv(data_offset + read_offset, 1024, dif_iovs, 4);
3194 : 15 : CU_ASSERT(read_len == 1024);
3195 : :
3196 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, read_offset, read_len, &ctx);
3197 : 15 : CU_ASSERT(rc == 0);
3198 : :
3199 : 15 : read_offset += read_len;
3200 : 15 : CU_ASSERT(read_offset == data_len);
3201 : :
3202 : : /* 2nd data segment */
3203 : 15 : data_offset += data_len;
3204 : 15 : data_len = 3072 + 4096 * 2 + 512;
3205 : :
3206 : 15 : spdk_dif_ctx_set_data_offset(&ctx, data_offset);
3207 : 15 : _iov_set_buf(&iov1, buf1 + 1024, 3072 + 128 + (4096 + 128) * 3 + 512);
3208 : :
3209 : 15 : read_offset = 0;
3210 : :
3211 : : /* 1st read in 2nd data segment */
3212 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
3213 : : read_offset, data_len - read_offset,
3214 : : &mapped_len, &ctx);
3215 : 15 : CU_ASSERT(rc == 4);
3216 : 15 : CU_ASSERT(mapped_len == 3072 + 4096 * 2 + 512);
3217 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + 1024, 3072) == true);
3218 : 15 : CU_ASSERT(_iov_check(&dif_iovs[1], buf1 + 4096 + 128, 4096) == true);
3219 : 15 : CU_ASSERT(_iov_check(&dif_iovs[2], buf1 + (4096 + 128) * 2, 4096) == true);
3220 : 15 : CU_ASSERT(_iov_check(&dif_iovs[3], buf1 + (4096 + 128) * 3, 512) == true);
3221 : :
3222 : 15 : read_len = ut_readv(data_offset + read_offset, 3071, dif_iovs, 4);
3223 : 15 : CU_ASSERT(read_len == 3071);
3224 : :
3225 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, read_offset, read_len, &ctx);
3226 : 15 : CU_ASSERT(rc == 0);
3227 : :
3228 : 15 : read_offset += read_len;
3229 : :
3230 : : /* 2nd read in 2nd data segment */
3231 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
3232 : : read_offset, data_len - read_offset,
3233 : : &mapped_len, &ctx);
3234 : 15 : CU_ASSERT(rc == 4);
3235 : 15 : CU_ASSERT(mapped_len == 1 + 4096 * 2 + 512);
3236 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + 4095, 1) == true);
3237 : 15 : CU_ASSERT(_iov_check(&dif_iovs[1], buf1 + 4096 + 128, 4096) == true);
3238 : 15 : CU_ASSERT(_iov_check(&dif_iovs[2], buf1 + (4096 + 128) * 2, 4096) == true);
3239 : 15 : CU_ASSERT(_iov_check(&dif_iovs[3], buf1 + (4096 + 128) * 3, 512) == true);
3240 : :
3241 : 15 : read_len = ut_readv(data_offset + read_offset, 1 + 4096 * 2 + 512, dif_iovs, 4);
3242 : 15 : CU_ASSERT(read_len == 1 + 4096 * 2 + 512);
3243 : :
3244 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, read_offset, read_len, &ctx);
3245 : 15 : CU_ASSERT(rc == 0);
3246 : :
3247 : 15 : read_offset += read_len;
3248 : 15 : CU_ASSERT(read_offset == data_len);
3249 : :
3250 : : /* 3rd data segment */
3251 : 15 : data_offset += data_len;
3252 : 15 : data_len = 3584;
3253 : :
3254 : 15 : spdk_dif_ctx_set_data_offset(&ctx, data_offset);
3255 : 15 : _iov_set_buf(&iov1, buf1 + (4096 + 128) * 3 + 512, 3584 + 128);
3256 : :
3257 : 15 : read_offset = 0;
3258 : :
3259 : : /* 1st read in 3rd data segment */
3260 : 15 : rc = spdk_dif_set_md_interleave_iovs(dif_iovs, 4, &iov1, 1,
3261 : : read_offset, data_len - read_offset,
3262 : : &mapped_len, &ctx);
3263 : 15 : CU_ASSERT(rc == 1);
3264 : 15 : CU_ASSERT(mapped_len == 3584);
3265 : 15 : CU_ASSERT(_iov_check(&dif_iovs[0], buf1 + (4096 + 128) * 3 + 512, 3584) == true);
3266 : :
3267 : 15 : read_len = ut_readv(data_offset + read_offset, 3584, dif_iovs, 1);
3268 : 15 : CU_ASSERT(read_len == 3584);
3269 : :
3270 : 15 : rc = spdk_dif_generate_stream(&iov1, 1, read_offset, read_len, &ctx);
3271 : 15 : CU_ASSERT(rc == 0);
3272 : :
3273 : 15 : read_offset += read_len;
3274 : 15 : CU_ASSERT(read_offset == data_len);
3275 : 15 : data_offset += data_len;
3276 : 15 : CU_ASSERT(data_offset == 4096 * 4);
3277 : :
3278 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 0);
3279 : 15 : _iov_set_buf(&iov1, buf1, (4096 + 128) * 4);
3280 : :
3281 : : /* The second data buffer:
3282 : : * - Set data pattern with a space for metadata for each block.
3283 : : */
3284 : 15 : buf2 = calloc(1, (4096 + 128) * 4);
3285 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf2 != NULL);
3286 : 15 : _iov_set_buf(&iov2, buf2, (4096 + 128) * 4);
3287 : :
3288 : 15 : rc = ut_data_pattern_generate(&iov2, 1, 4096 + 128, 128, 4);
3289 : 15 : CU_ASSERT(rc == 0);
3290 : :
3291 : 15 : rc = spdk_dif_generate(&iov2, 1, 4, &ctx);
3292 : 15 : CU_ASSERT(rc == 0);
3293 : :
3294 : 15 : rc = spdk_dif_verify(&iov1, 1, 4, &ctx, &err_blk);
3295 : 15 : CU_ASSERT(rc == 0);
3296 : :
3297 : 15 : rc = spdk_dif_verify(&iov2, 1, 4, &ctx, &err_blk);
3298 : 15 : CU_ASSERT(rc == 0);
3299 : :
3300 : : /* Compare the first and the second data buffer by byte. */
3301 [ - + - + ]: 15 : rc = memcmp(buf1, buf2, (4096 + 128) * 4);
3302 : 15 : CU_ASSERT(rc == 0);
3303 : :
3304 : 15 : free(buf1);
3305 : 15 : free(buf2);
3306 : 15 : }
3307 : :
3308 : : static void
3309 : 5 : set_md_interleave_iovs_multi_segments_test(void)
3310 : : {
3311 : 5 : _set_md_interleave_iovs_multi_segments_test(SPDK_DIF_PI_FORMAT_16);
3312 : 5 : _set_md_interleave_iovs_multi_segments_test(SPDK_DIF_PI_FORMAT_32);
3313 : 5 : _set_md_interleave_iovs_multi_segments_test(SPDK_DIF_PI_FORMAT_64);
3314 : 5 : }
3315 : :
3316 : : static void
3317 : 15 : _dif_verify_split_test(enum spdk_dif_pi_format dif_pi_format)
3318 : : {
3319 : 15 : struct spdk_dif_ctx ctx = {};
3320 : 15 : struct spdk_dif_error err_blk = {};
3321 : 12 : struct iovec iov;
3322 : : uint8_t *buf;
3323 : 12 : struct _dif_sgl sgl;
3324 : 15 : uint64_t guard = 0, prev_guard = 0;
3325 : : uint32_t dif_flags;
3326 : : int rc;
3327 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3328 : :
3329 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3330 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3331 : :
3332 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3333 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3334 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3335 : : dif_flags, 0, 0, 0, 0, GUARD_SEED, &dif_opts);
3336 : 15 : CU_ASSERT(rc == 0);
3337 : :
3338 : 15 : buf = calloc(1, 4096 + 128);
3339 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf != NULL);
3340 : 15 : _iov_set_buf(&iov, buf, 4096 + 128);
3341 : :
3342 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
3343 : 15 : CU_ASSERT(rc == 0);
3344 : :
3345 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3346 : :
3347 : 15 : dif_generate(&sgl, 1, &ctx);
3348 : :
3349 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3350 : :
3351 : 15 : guard = GUARD_SEED;
3352 : 15 : prev_guard = GUARD_SEED;
3353 : :
3354 : 15 : rc = _dif_verify_split(&sgl, 0, 1000, &guard, 0, &ctx, &err_blk);
3355 : 15 : CU_ASSERT(rc == 0);
3356 : 15 : CU_ASSERT(guard == _generate_guard(prev_guard, buf, 1000, dif_pi_format));
3357 : 15 : CU_ASSERT(sgl.iov_offset == 1000);
3358 : :
3359 : 15 : prev_guard = guard;
3360 : :
3361 : 15 : rc = _dif_verify_split(&sgl, 1000, 3000, &guard, 0, &ctx, &err_blk);
3362 : 15 : CU_ASSERT(rc == 0);
3363 : 15 : CU_ASSERT(guard == _generate_guard(prev_guard, buf + 1000, 3000, dif_pi_format));
3364 : 15 : CU_ASSERT(sgl.iov_offset == 4000);
3365 : :
3366 : 15 : rc = _dif_verify_split(&sgl, 4000, 96 + 128, &guard, 0, &ctx, &err_blk);
3367 : 15 : CU_ASSERT(rc == 0);
3368 : 15 : CU_ASSERT(guard == GUARD_SEED);
3369 : 15 : CU_ASSERT(sgl.iov_offset == 0);
3370 : 15 : CU_ASSERT(sgl.iovcnt == 0);
3371 : :
3372 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3373 : :
3374 : 15 : rc = dif_verify(&sgl, 1, &ctx, &err_blk);
3375 : 15 : CU_ASSERT(rc == 0);
3376 : :
3377 : 15 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 1);
3378 : 15 : CU_ASSERT(rc == 0);
3379 : :
3380 : 15 : free(buf);
3381 : 15 : }
3382 : :
3383 : : static void
3384 : 5 : dif_verify_split_test(void)
3385 : : {
3386 : 5 : _dif_verify_split_test(SPDK_DIF_PI_FORMAT_16);
3387 : 5 : _dif_verify_split_test(SPDK_DIF_PI_FORMAT_32);
3388 : 5 : _dif_verify_split_test(SPDK_DIF_PI_FORMAT_64);
3389 : 5 : }
3390 : :
3391 : : static void
3392 : 15 : _dif_verify_stream_multi_segments_test(enum spdk_dif_pi_format dif_pi_format)
3393 : : {
3394 : 15 : struct spdk_dif_ctx ctx = {};
3395 : 15 : struct spdk_dif_error err_blk = {};
3396 : 15 : struct iovec iov = {};
3397 : : uint8_t *buf;
3398 : : uint32_t dif_flags;
3399 : : int rc;
3400 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3401 : :
3402 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3403 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3404 : :
3405 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3406 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3407 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3408 : : dif_flags, 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
3409 : 15 : CU_ASSERT(rc == 0);
3410 : :
3411 : 15 : buf = calloc(1, (4096 + 128) * 4);
3412 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf != NULL);
3413 : 15 : _iov_set_buf(&iov, buf, (4096 + 128) * 4);
3414 : :
3415 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 4);
3416 : 15 : CU_ASSERT(rc == 0);
3417 : :
3418 : 15 : rc = spdk_dif_generate(&iov, 1, 4, &ctx);
3419 : 15 : CU_ASSERT(rc == 0);
3420 : :
3421 : : /* 1st data segment */
3422 : 15 : _iov_set_buf(&iov, buf, 1024);
3423 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 0);
3424 : :
3425 : 15 : rc = spdk_dif_verify_stream(&iov, 1, 0, 1024, &ctx, &err_blk);
3426 : 15 : CU_ASSERT(rc == 0);
3427 : :
3428 : : /* 2nd data segment */
3429 : 15 : _iov_set_buf(&iov, buf + 1024, (3072 + 128) + (4096 + 128) * 2 + 512);
3430 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 1024);
3431 : :
3432 : 15 : rc = spdk_dif_verify_stream(&iov, 1, 0, 3072 + 4096 * 2 + 512, &ctx, &err_blk);
3433 : 15 : CU_ASSERT(rc == 0);
3434 : :
3435 : : /* 3rd data segment */
3436 : 15 : _iov_set_buf(&iov, buf + (4096 + 128) * 3 + 512, 3584 + 128);
3437 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 4096 * 3);
3438 : :
3439 : 15 : rc = spdk_dif_verify_stream(&iov, 1, 0, 3584, &ctx, &err_blk);
3440 : 15 : CU_ASSERT(rc == 0);
3441 : :
3442 : : /* verify all data segments once */
3443 : 15 : _iov_set_buf(&iov, buf, (4096 + 128) * 4);
3444 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 0);
3445 : :
3446 : 15 : rc = spdk_dif_verify(&iov, 1, 4, &ctx, &err_blk);
3447 : 15 : CU_ASSERT(rc == 0);
3448 : :
3449 : 15 : rc = ut_data_pattern_verify(&iov, 1, 4096 + 128, 128, 4);
3450 : 15 : CU_ASSERT(rc == 0);
3451 : :
3452 : 15 : free(buf);
3453 : 15 : }
3454 : :
3455 : : static void
3456 : 5 : dif_verify_stream_multi_segments_test(void)
3457 : : {
3458 : 5 : _dif_verify_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_16);
3459 : 5 : _dif_verify_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_32);
3460 : 5 : _dif_verify_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_64);
3461 : 5 : }
3462 : :
3463 : : #define UT_CRC32C_XOR 0xffffffffUL
3464 : :
3465 : : static void
3466 : 5 : update_crc32c_pi_16_test(void)
3467 : : {
3468 : 5 : struct spdk_dif_ctx ctx = {};
3469 : 4 : struct iovec iovs[7];
3470 : 4 : uint32_t crc32c1, crc32c2, crc32c3, crc32c4;
3471 : : uint32_t dif_flags;
3472 : : int i, rc;
3473 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3474 : :
3475 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3476 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3477 : :
3478 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3479 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
3480 : 5 : rc = spdk_dif_ctx_init(&ctx, 512 + 8, 8, true, false, SPDK_DIF_TYPE1,
3481 : : dif_flags, 0, 0, 0, 0, 0, &dif_opts);
3482 : 5 : CU_ASSERT(rc == 0);
3483 : :
3484 : : /* data[0][255:0] */
3485 : 5 : _iov_alloc_buf(&iovs[0], 256);
3486 : :
3487 : : /* data[0][511:256], md[0][0] */
3488 : 5 : _iov_alloc_buf(&iovs[1], 256 + 1);
3489 : :
3490 : : /* md[0][4:1] */
3491 : 5 : _iov_alloc_buf(&iovs[2], 4);
3492 : :
3493 : : /* md[0][7:5], data[1][122:0] */
3494 : 5 : _iov_alloc_buf(&iovs[3], 3 + 123);
3495 : :
3496 : : /* data[1][511:123], md[1][5:0] */
3497 : 5 : _iov_alloc_buf(&iovs[4], 389 + 6);
3498 : :
3499 : : /* md[1][7:6], data[2][511:0], md[2][7:0], data[3][431:0] */
3500 : 5 : _iov_alloc_buf(&iovs[5], 2 + 512 + 8 + 432);
3501 : :
3502 : : /* data[3][511:432], md[3][7:0] */
3503 : 5 : _iov_alloc_buf(&iovs[6], 80 + 8);
3504 : :
3505 : 5 : rc = ut_data_pattern_generate(iovs, 7, 512 + 8, 8, 4);
3506 : 5 : CU_ASSERT(rc == 0);
3507 : :
3508 : 5 : crc32c1 = UT_CRC32C_XOR;
3509 : :
3510 : 5 : rc = spdk_dif_update_crc32c(iovs, 7, 4, &crc32c1, &ctx);
3511 : 5 : CU_ASSERT(rc == 0);
3512 : :
3513 : : /* Test if DIF doesn't affect CRC for split case. */
3514 : 5 : rc = spdk_dif_generate(iovs, 7, 4, &ctx);
3515 : 5 : CU_ASSERT(rc == 0);
3516 : :
3517 : 5 : crc32c2 = UT_CRC32C_XOR;
3518 : :
3519 : 5 : rc = spdk_dif_update_crc32c(iovs, 7, 4, &crc32c2, &ctx);
3520 : 5 : CU_ASSERT(rc == 0);
3521 : :
3522 : 5 : CU_ASSERT(crc32c1 == crc32c2);
3523 : :
3524 [ + + ]: 40 : for (i = 0; i < 7; i++) {
3525 : 35 : _iov_free_buf(&iovs[i]);
3526 : : }
3527 : :
3528 : : /* Test if CRC is same regardless of splitting. */
3529 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3530 : 20 : _iov_alloc_buf(&iovs[i], 512 + 8);
3531 : : }
3532 : :
3533 : 5 : rc = ut_data_pattern_generate(iovs, 4, 512 + 8, 8, 4);
3534 : 5 : CU_ASSERT(rc == 0);
3535 : :
3536 : 5 : crc32c3 = UT_CRC32C_XOR;
3537 : :
3538 : 5 : rc = spdk_dif_update_crc32c(iovs, 4, 4, &crc32c3, &ctx);
3539 : 5 : CU_ASSERT(rc == 0);
3540 : :
3541 : 5 : CU_ASSERT(crc32c1 == crc32c3);
3542 : :
3543 : : /* Test if DIF doesn't affect CRC for non-split case. */
3544 : 5 : rc = spdk_dif_generate(iovs, 4, 4, &ctx);
3545 : 5 : CU_ASSERT(rc == 0);
3546 : :
3547 : 5 : crc32c4 = UT_CRC32C_XOR;
3548 : :
3549 : 5 : rc = spdk_dif_update_crc32c(iovs, 4, 4, &crc32c4, &ctx);
3550 : 5 : CU_ASSERT(rc == 0);
3551 : :
3552 : 5 : CU_ASSERT(crc32c1 == crc32c4);
3553 : :
3554 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3555 : 20 : _iov_free_buf(&iovs[i]);
3556 : : }
3557 : 5 : }
3558 : :
3559 : : static void
3560 : 10 : _update_crc32c_test(enum spdk_dif_pi_format dif_pi_format)
3561 : : {
3562 : 10 : struct spdk_dif_ctx ctx = {};
3563 : 8 : struct iovec iovs[7];
3564 : 8 : uint32_t crc32c1, crc32c2, crc32c3, crc32c4;
3565 : : uint32_t dif_flags;
3566 : : int i, rc;
3567 : 8 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3568 : :
3569 : 10 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3570 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3571 : :
3572 : 10 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3573 : 10 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_32;
3574 : 10 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3575 : : dif_flags, 0, 0, 0, 0, 0, &dif_opts);
3576 : 10 : CU_ASSERT(rc == 0);
3577 : :
3578 : : /* data[0][2047:0] */
3579 : 10 : _iov_alloc_buf(&iovs[0], 2048);
3580 : :
3581 : : /* data[0][4095:2048], md[0][0] */
3582 : 10 : _iov_alloc_buf(&iovs[1], 2048 + 1);
3583 : :
3584 : : /* md[0][4:1] */
3585 : 10 : _iov_alloc_buf(&iovs[2], 4);
3586 : :
3587 : : /* md[0][127:5], data[1][122:0] */
3588 : 10 : _iov_alloc_buf(&iovs[3], 123 + 123);
3589 : :
3590 : : /* data[1][4095:123], md[1][5:0] */
3591 : 10 : _iov_alloc_buf(&iovs[4], 3973 + 6);
3592 : :
3593 : : /* md[1][127:6], data[2][4095:0], md[2][127:0], data[3][431:0] */
3594 : 10 : _iov_alloc_buf(&iovs[5], 122 + 4096 + 128 + 432);
3595 : :
3596 : : /* data[3][511:432], md[3][127:0] */
3597 : 10 : _iov_alloc_buf(&iovs[6], 3665 + 128);
3598 : :
3599 : 10 : rc = ut_data_pattern_generate(iovs, 7, 4096 + 128, 128, 4);
3600 : 10 : CU_ASSERT(rc == 0);
3601 : :
3602 : 10 : crc32c1 = UT_CRC32C_XOR;
3603 : :
3604 : 10 : rc = spdk_dif_update_crc32c(iovs, 7, 4, &crc32c1, &ctx);
3605 : 10 : CU_ASSERT(rc == 0);
3606 : :
3607 : : /* Test if DIF doesn't affect CRC for split case. */
3608 : 10 : rc = spdk_dif_generate(iovs, 7, 4, &ctx);
3609 : 10 : CU_ASSERT(rc == 0);
3610 : :
3611 : 10 : crc32c2 = UT_CRC32C_XOR;
3612 : :
3613 : 10 : rc = spdk_dif_update_crc32c(iovs, 7, 4, &crc32c2, &ctx);
3614 : 10 : CU_ASSERT(rc == 0);
3615 : :
3616 : 10 : CU_ASSERT(crc32c1 == crc32c2);
3617 : :
3618 [ + + ]: 80 : for (i = 0; i < 7; i++) {
3619 : 70 : _iov_free_buf(&iovs[i]);
3620 : : }
3621 : :
3622 : : /* Test if CRC is same regardless of splitting. */
3623 [ + + ]: 50 : for (i = 0; i < 4; i++) {
3624 : 40 : _iov_alloc_buf(&iovs[i], 4096 + 128);
3625 : : }
3626 : :
3627 : 10 : rc = ut_data_pattern_generate(iovs, 4, 4096 + 128, 128, 4);
3628 : 10 : CU_ASSERT(rc == 0);
3629 : :
3630 : 10 : crc32c3 = UT_CRC32C_XOR;
3631 : :
3632 : 10 : rc = spdk_dif_update_crc32c(iovs, 4, 4, &crc32c3, &ctx);
3633 : 10 : CU_ASSERT(rc == 0);
3634 : :
3635 : 10 : CU_ASSERT(crc32c1 == crc32c3);
3636 : :
3637 : : /* Test if DIF doesn't affect CRC for non-split case. */
3638 : 10 : rc = spdk_dif_generate(iovs, 4, 4, &ctx);
3639 : 10 : CU_ASSERT(rc == 0);
3640 : :
3641 : 10 : crc32c4 = UT_CRC32C_XOR;
3642 : :
3643 : 10 : rc = spdk_dif_update_crc32c(iovs, 4, 4, &crc32c4, &ctx);
3644 : 10 : CU_ASSERT(rc == 0);
3645 : :
3646 : 10 : CU_ASSERT(crc32c1 == crc32c4);
3647 : :
3648 [ + + ]: 50 : for (i = 0; i < 4; i++) {
3649 : 40 : _iov_free_buf(&iovs[i]);
3650 : : }
3651 : 10 : }
3652 : :
3653 : : static void
3654 : 5 : update_crc32c_test(void)
3655 : : {
3656 : 5 : _update_crc32c_test(SPDK_DIF_PI_FORMAT_32);
3657 : 5 : _update_crc32c_test(SPDK_DIF_PI_FORMAT_64);
3658 : 5 : }
3659 : :
3660 : : static void
3661 : 15 : _dif_update_crc32c_split_test(enum spdk_dif_pi_format dif_pi_format)
3662 : : {
3663 : 15 : struct spdk_dif_ctx ctx = {};
3664 : 12 : struct iovec iov;
3665 : : uint8_t *buf;
3666 : 12 : struct _dif_sgl sgl;
3667 : : uint32_t dif_flags, crc32c, prev_crc32c;
3668 : : int rc;
3669 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3670 : :
3671 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3672 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3673 : :
3674 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3675 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3676 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3677 : : dif_flags, 0, 0, 0, 0, GUARD_SEED, &dif_opts);
3678 : 15 : CU_ASSERT(rc == 0);
3679 : :
3680 : 15 : buf = calloc(1, 4096 + 128);
3681 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf != NULL);
3682 : 15 : _iov_set_buf(&iov, buf, 4096 + 128);
3683 : :
3684 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 1);
3685 : 15 : CU_ASSERT(rc == 0);
3686 : :
3687 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3688 : :
3689 : 15 : dif_generate(&sgl, 1, &ctx);
3690 : :
3691 : 15 : _dif_sgl_init(&sgl, &iov, 1);
3692 : :
3693 : 15 : crc32c = _dif_update_crc32c_split(&sgl, 0, 1000, UT_CRC32C_XOR, &ctx);
3694 : 15 : CU_ASSERT(crc32c == spdk_crc32c_update(buf, 1000, UT_CRC32C_XOR));
3695 : :
3696 : 15 : prev_crc32c = crc32c;
3697 : :
3698 : 15 : crc32c = _dif_update_crc32c_split(&sgl, 1000, 3000, prev_crc32c, &ctx);
3699 : 15 : CU_ASSERT(crc32c == spdk_crc32c_update(buf + 1000, 3000, prev_crc32c));
3700 : :
3701 : 15 : prev_crc32c = crc32c;
3702 : :
3703 : 15 : crc32c = _dif_update_crc32c_split(&sgl, 4000, 96 + 128, prev_crc32c, &ctx);
3704 : 15 : CU_ASSERT(crc32c == spdk_crc32c_update(buf + 4000, 96, prev_crc32c));
3705 : :
3706 : 15 : CU_ASSERT(crc32c == spdk_crc32c_update(buf, 4096, UT_CRC32C_XOR));
3707 : :
3708 : 15 : free(buf);
3709 : 15 : }
3710 : :
3711 : : static void
3712 : 5 : dif_update_crc32c_split_test(void)
3713 : : {
3714 : 5 : _dif_update_crc32c_split_test(SPDK_DIF_PI_FORMAT_16);
3715 : 5 : _dif_update_crc32c_split_test(SPDK_DIF_PI_FORMAT_32);
3716 : 5 : _dif_update_crc32c_split_test(SPDK_DIF_PI_FORMAT_64);
3717 : 5 : }
3718 : :
3719 : : static void
3720 : 15 : _dif_update_crc32c_stream_multi_segments_test(enum spdk_dif_pi_format dif_pi_format)
3721 : : {
3722 : 15 : struct spdk_dif_ctx ctx = {};
3723 : 15 : struct iovec iov = {};
3724 : : uint8_t *buf;
3725 : 12 : uint32_t dif_flags, crc32c1, crc32c2;
3726 : : int rc;
3727 : 12 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3728 : :
3729 : 15 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3730 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3731 : :
3732 : 15 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3733 : 15 : dif_opts.dif_pi_format = dif_pi_format;
3734 : 15 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, SPDK_DIF_TYPE1,
3735 : : dif_flags, 22, 0xFFFF, 0x22, 0, GUARD_SEED, &dif_opts);
3736 : 15 : CU_ASSERT(rc == 0);
3737 : :
3738 : 15 : buf = calloc(1, (4096 + 128) * 4);
3739 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(buf != NULL);
3740 : 15 : _iov_set_buf(&iov, buf, (4096 + 128) * 4);
3741 : :
3742 : 15 : rc = ut_data_pattern_generate(&iov, 1, 4096 + 128, 128, 4);
3743 : 15 : CU_ASSERT(rc == 0);
3744 : :
3745 : 15 : rc = spdk_dif_generate(&iov, 1, 4, &ctx);
3746 : 15 : CU_ASSERT(rc == 0);
3747 : :
3748 : 15 : crc32c1 = UT_CRC32C_XOR;
3749 : 15 : crc32c2 = UT_CRC32C_XOR;
3750 : :
3751 : : /* 1st data segment */
3752 : 15 : _iov_set_buf(&iov, buf, 1024);
3753 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 0);
3754 : :
3755 : 15 : rc = spdk_dif_update_crc32c_stream(&iov, 1, 0, 1024, &crc32c1, &ctx);
3756 : 15 : CU_ASSERT(rc == 0);
3757 : :
3758 : : /* 2nd data segment */
3759 : 15 : _iov_set_buf(&iov, buf + 1024, (3072 + 128) + (4096 + 128) * 2 + 512);
3760 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 1024);
3761 : :
3762 : 15 : rc = spdk_dif_update_crc32c_stream(&iov, 1, 0, 3072 + 4096 * 2 + 512, &crc32c1, &ctx);
3763 : 15 : CU_ASSERT(rc == 0);
3764 : :
3765 : : /* 3rd data segment */
3766 : 15 : _iov_set_buf(&iov, buf + (4096 + 128) * 3 + 512, 3584 + 128);
3767 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 4096 * 3);
3768 : :
3769 : 15 : rc = spdk_dif_update_crc32c_stream(&iov, 1, 0, 3584, &crc32c1, &ctx);
3770 : 15 : CU_ASSERT(rc == 0);
3771 : :
3772 : : /* Update CRC32C for all data segments once */
3773 : 15 : _iov_set_buf(&iov, buf, (4096 + 128) * 4);
3774 : 15 : spdk_dif_ctx_set_data_offset(&ctx, 0);
3775 : :
3776 : 15 : rc = spdk_dif_update_crc32c(&iov, 1, 4, &crc32c2, &ctx);
3777 : 15 : CU_ASSERT(rc == 0);
3778 : :
3779 : 15 : CU_ASSERT(crc32c1 == crc32c2);
3780 : :
3781 : 15 : free(buf);
3782 : 15 : }
3783 : :
3784 : : static void
3785 : 5 : dif_update_crc32c_stream_multi_segments_test(void)
3786 : : {
3787 : 5 : _dif_update_crc32c_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_16);
3788 : 5 : _dif_update_crc32c_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_32);
3789 : 5 : _dif_update_crc32c_stream_multi_segments_test(SPDK_DIF_PI_FORMAT_64);
3790 : 5 : }
3791 : :
3792 : : static void
3793 : 5 : get_range_with_md_test(void)
3794 : : {
3795 : 5 : struct spdk_dif_ctx ctx = {};
3796 : 4 : uint32_t buf_offset, buf_len;
3797 : : int rc;
3798 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3799 : :
3800 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3801 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
3802 : 5 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, false, 0, 0,
3803 : : 0, 0, 0, 0, 0, &dif_opts);
3804 : 5 : CU_ASSERT(rc == 0);
3805 : :
3806 : 5 : spdk_dif_get_range_with_md(0, 2048, &buf_offset, &buf_len, &ctx);
3807 : 5 : CU_ASSERT(buf_offset == 0);
3808 : 5 : CU_ASSERT(buf_len == 2048);
3809 : :
3810 : 5 : spdk_dif_get_range_with_md(2048, 4096, &buf_offset, &buf_len, &ctx);
3811 : 5 : CU_ASSERT(buf_offset == 2048);
3812 : 5 : CU_ASSERT(buf_len == 4096 + 128);
3813 : :
3814 : 5 : spdk_dif_get_range_with_md(4096, 10240, &buf_offset, &buf_len, &ctx);
3815 : 5 : CU_ASSERT(buf_offset == 4096 + 128);
3816 : 5 : CU_ASSERT(buf_len == 10240 + 256);
3817 : :
3818 : 5 : spdk_dif_get_range_with_md(10240, 2048, &buf_offset, &buf_len, &ctx);
3819 : 5 : CU_ASSERT(buf_offset == 10240 + 256);
3820 : 5 : CU_ASSERT(buf_len == 2048 + 128);
3821 : :
3822 : 5 : buf_len = spdk_dif_get_length_with_md(6144, &ctx);
3823 : 5 : CU_ASSERT(buf_len == 6144 + 128);
3824 : 5 : }
3825 : :
3826 : : static void
3827 : 60 : dif_generate_remap_and_verify(struct iovec *iovs, int iovcnt,
3828 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
3829 : : bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
3830 : : uint32_t init_ref_tag, uint32_t remapped_init_ref_tag,
3831 : : uint16_t apptag_mask, uint16_t app_tag,
3832 : : enum spdk_dif_pi_format dif_pi_format)
3833 : : {
3834 : 60 : struct spdk_dif_ctx ctx = {};
3835 : : int rc;
3836 : 48 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3837 : :
3838 : 60 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, md_size, num_blocks);
3839 : 60 : CU_ASSERT(rc == 0);
3840 : :
3841 : 60 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
3842 : 60 : dif_opts.dif_pi_format = dif_pi_format;
3843 : 60 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc, dif_type, dif_flags,
3844 : : init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
3845 : 60 : CU_ASSERT(rc == 0);
3846 : :
3847 : 60 : rc = spdk_dif_generate(iovs, iovcnt, num_blocks, &ctx);
3848 : 60 : CU_ASSERT(rc == 0);
3849 : :
3850 : 60 : spdk_dif_ctx_set_remapped_init_ref_tag(&ctx, remapped_init_ref_tag);
3851 : :
3852 : 60 : rc = spdk_dif_remap_ref_tag(iovs, iovcnt, num_blocks, &ctx, NULL, true);
3853 : 60 : CU_ASSERT(rc == 0);
3854 : :
3855 : 60 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, true, dif_loc, dif_type, dif_flags,
3856 : : remapped_init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
3857 : 60 : CU_ASSERT(rc == 0);
3858 : :
3859 : 60 : rc = spdk_dif_verify(iovs, iovcnt, num_blocks, &ctx, NULL);
3860 : 60 : CU_ASSERT(rc == 0);
3861 : :
3862 : 60 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size, md_size, num_blocks);
3863 : 60 : CU_ASSERT(rc == 0);
3864 : 60 : }
3865 : :
3866 : : static void
3867 : 5 : dif_sec_512_md_8_prchk_7_multi_iovs_remap_pi_16_test(void)
3868 : : {
3869 : 4 : struct iovec iovs[4];
3870 : : int i, num_blocks;
3871 : : uint32_t dif_flags;
3872 : :
3873 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3874 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3875 : :
3876 : 5 : num_blocks = 0;
3877 : :
3878 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3879 : 20 : _iov_alloc_buf(&iovs[i], (512 + 8) * (i + 1));
3880 : 20 : num_blocks += i + 1;
3881 : : }
3882 : :
3883 : 5 : dif_generate_remap_and_verify(iovs, 4, 512 + 8, 8, num_blocks, false, SPDK_DIF_TYPE1,
3884 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
3885 : :
3886 : 5 : dif_generate_remap_and_verify(iovs, 4, 512 + 8, 8, num_blocks, true, SPDK_DIF_TYPE1,
3887 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
3888 : :
3889 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3890 : 20 : _iov_free_buf(&iovs[i]);
3891 : : }
3892 : 5 : }
3893 : :
3894 : : static void
3895 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_remap_test(void)
3896 : : {
3897 : 4 : struct iovec iovs[4];
3898 : : int i, num_blocks;
3899 : : uint32_t dif_flags;
3900 : :
3901 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3902 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3903 : :
3904 : 5 : num_blocks = 0;
3905 : :
3906 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3907 : 20 : _iov_alloc_buf(&iovs[i], (4096 + 128) * (i + 1));
3908 : 20 : num_blocks += i + 1;
3909 : : }
3910 : :
3911 : 5 : dif_generate_remap_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
3912 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
3913 : 5 : dif_generate_remap_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, true, SPDK_DIF_TYPE1,
3914 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
3915 : 5 : dif_generate_remap_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, false, SPDK_DIF_TYPE1,
3916 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
3917 : 5 : dif_generate_remap_and_verify(iovs, 4, 4096 + 128, 128, num_blocks, true, SPDK_DIF_TYPE1,
3918 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
3919 : :
3920 [ + + ]: 25 : for (i = 0; i < 4; i++) {
3921 : 20 : _iov_free_buf(&iovs[i]);
3922 : : }
3923 : 5 : }
3924 : :
3925 : : static void
3926 : 5 : dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test(void)
3927 : : {
3928 : 4 : struct iovec iovs[11];
3929 : : uint32_t dif_flags;
3930 : : int i;
3931 : :
3932 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
3933 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
3934 : :
3935 : : /* data[0][1000:0] */
3936 : 5 : _iov_alloc_buf(&iovs[0], 1000);
3937 : :
3938 : : /* data[0][3095:1000], guard[0][0] */
3939 : 5 : _iov_alloc_buf(&iovs[1], 3096 + 1);
3940 : :
3941 : : /* guard[0][1], apptag[0][0] */
3942 : 5 : _iov_alloc_buf(&iovs[2], 1 + 1);
3943 : :
3944 : : /* apptag[0][1], reftag[0][0] */
3945 : 5 : _iov_alloc_buf(&iovs[3], 1 + 1);
3946 : :
3947 : : /* reftag[0][3:1], ignore[0][59:0] */
3948 : 5 : _iov_alloc_buf(&iovs[4], 3 + 60);
3949 : :
3950 : : /* ignore[119:60], data[1][3050:0] */
3951 : 5 : _iov_alloc_buf(&iovs[5], 60 + 3051);
3952 : :
3953 : : /* data[1][4095:3050], guard[1][0] */
3954 : 5 : _iov_alloc_buf(&iovs[6], 1045 + 1);
3955 : :
3956 : : /* guard[1][1], apptag[1][0] */
3957 : 5 : _iov_alloc_buf(&iovs[7], 1 + 1);
3958 : :
3959 : : /* apptag[1][1], reftag[1][0] */
3960 : 5 : _iov_alloc_buf(&iovs[8], 1 + 1);
3961 : :
3962 : : /* reftag[1][3:1], ignore[1][9:0] */
3963 : 5 : _iov_alloc_buf(&iovs[9], 3 + 10);
3964 : :
3965 : : /* ignore[1][127:9] */
3966 : 5 : _iov_alloc_buf(&iovs[10], 118);
3967 : :
3968 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
3969 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
3970 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
3971 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
3972 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
3973 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
3974 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
3975 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
3976 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, false, SPDK_DIF_TYPE1, dif_flags,
3977 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
3978 : 5 : dif_generate_remap_and_verify(iovs, 11, 4096 + 128, 128, 2, true, SPDK_DIF_TYPE1, dif_flags,
3979 : : 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
3980 : :
3981 [ + + ]: 60 : for (i = 0; i < 11; i++) {
3982 : 55 : _iov_free_buf(&iovs[i]);
3983 : : }
3984 : 5 : }
3985 : :
3986 : : static void
3987 : 45 : dix_generate_remap_and_verify(struct iovec *iovs, int iovcnt, struct iovec *md_iov,
3988 : : uint32_t block_size, uint32_t md_size, uint32_t num_blocks,
3989 : : bool dif_loc, enum spdk_dif_type dif_type, uint32_t dif_flags,
3990 : : uint32_t init_ref_tag, uint32_t remapped_init_ref_tag,
3991 : : uint16_t apptag_mask, uint16_t app_tag,
3992 : : enum spdk_dif_pi_format dif_pi_format)
3993 : : {
3994 : 36 : struct spdk_dif_ctx ctx;
3995 : : int rc;
3996 : 36 : struct spdk_dif_ctx_init_ext_opts dif_opts;
3997 : :
3998 : 45 : rc = ut_data_pattern_generate(iovs, iovcnt, block_size, 0, num_blocks);
3999 : 45 : CU_ASSERT(rc == 0);
4000 : :
4001 : 45 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
4002 : 45 : dif_opts.dif_pi_format = dif_pi_format;
4003 : 45 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, false, dif_loc, dif_type, dif_flags,
4004 : : init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
4005 : 45 : CU_ASSERT(rc == 0);
4006 : :
4007 : 45 : rc = spdk_dix_generate(iovs, iovcnt, md_iov, num_blocks, &ctx);
4008 : 45 : CU_ASSERT(rc == 0);
4009 : :
4010 : 45 : spdk_dif_ctx_set_remapped_init_ref_tag(&ctx, remapped_init_ref_tag);
4011 : :
4012 : 45 : rc = spdk_dix_remap_ref_tag(md_iov, num_blocks, &ctx, NULL, true);
4013 : 45 : CU_ASSERT(rc == 0);
4014 : :
4015 : 45 : rc = spdk_dif_ctx_init(&ctx, block_size, md_size, false, dif_loc, dif_type, dif_flags,
4016 : : remapped_init_ref_tag, apptag_mask, app_tag, 0, GUARD_SEED, &dif_opts);
4017 : 45 : CU_ASSERT(rc == 0);
4018 : :
4019 : 45 : rc = spdk_dix_verify(iovs, iovcnt, md_iov, num_blocks, &ctx, NULL);
4020 : 45 : CU_ASSERT(rc == 0);
4021 : :
4022 : 45 : rc = ut_data_pattern_verify(iovs, iovcnt, block_size, 0, num_blocks);
4023 : 45 : CU_ASSERT(rc == 0);
4024 : 45 : }
4025 : :
4026 : : static void
4027 : 5 : dix_sec_4096_md_128_prchk_7_multi_iovs_remap(void)
4028 : : {
4029 : 4 : struct iovec iovs[4], md_iov;
4030 : : uint32_t dif_flags;
4031 : : int i, num_blocks;
4032 : :
4033 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
4034 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
4035 : :
4036 : 5 : num_blocks = 0;
4037 : :
4038 [ + + ]: 25 : for (i = 0; i < 4; i++) {
4039 : 20 : _iov_alloc_buf(&iovs[i], 4096 * (i + 1));
4040 : 20 : num_blocks += i + 1;
4041 : : }
4042 : 5 : _iov_alloc_buf(&md_iov, 128 * num_blocks);
4043 : :
4044 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
4045 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
4046 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
4047 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
4048 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
4049 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
4050 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
4051 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
4052 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, false, SPDK_DIF_TYPE1,
4053 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
4054 : 5 : dix_generate_remap_and_verify(iovs, 4, &md_iov, 4096, 128, num_blocks, true, SPDK_DIF_TYPE1,
4055 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
4056 : :
4057 [ + + ]: 25 : for (i = 0; i < 4; i++) {
4058 : 20 : _iov_free_buf(&iovs[i]);
4059 : : }
4060 : 5 : _iov_free_buf(&md_iov);
4061 : 5 : }
4062 : :
4063 : : static void
4064 : 5 : dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits_remap_pi_16_test(void)
4065 : : {
4066 : 4 : struct iovec iovs[6], md_iov;
4067 : : uint32_t dif_flags;
4068 : : int i;
4069 : :
4070 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
4071 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
4072 : :
4073 : : /* data[0][255:0] */
4074 : 5 : _iov_alloc_buf(&iovs[0], 256);
4075 : :
4076 : : /* data[0][511:256], data[1][255:0] */
4077 : 5 : _iov_alloc_buf(&iovs[1], 256 + 256);
4078 : :
4079 : : /* data[1][382:256] */
4080 : 5 : _iov_alloc_buf(&iovs[2], 128);
4081 : :
4082 : : /* data[1][383] */
4083 : 5 : _iov_alloc_buf(&iovs[3], 1);
4084 : :
4085 : : /* data[1][510:384] */
4086 : 5 : _iov_alloc_buf(&iovs[4], 126);
4087 : :
4088 : : /* data[1][511], data[2][511:0], data[3][511:0] */
4089 : 5 : _iov_alloc_buf(&iovs[5], 1 + 512 * 2);
4090 : :
4091 : 5 : _iov_alloc_buf(&md_iov, 8 * 4);
4092 : :
4093 : 5 : dix_generate_remap_and_verify(iovs, 6, &md_iov, 512, 8, 4, false, SPDK_DIF_TYPE1,
4094 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_16);
4095 : :
4096 [ + + ]: 35 : for (i = 0; i < 6; i++) {
4097 : 30 : _iov_free_buf(&iovs[i]);
4098 : : }
4099 : 5 : _iov_free_buf(&md_iov);
4100 : 5 : }
4101 : :
4102 : : static void
4103 : 5 : dix_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test(void)
4104 : : {
4105 : 4 : struct iovec iovs[6], md_iov;
4106 : : uint32_t dif_flags;
4107 : : int i;
4108 : :
4109 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
4110 : : SPDK_DIF_FLAGS_REFTAG_CHECK;
4111 : :
4112 : : /* data[0][2047:0] */
4113 : 5 : _iov_alloc_buf(&iovs[0], 2048);
4114 : :
4115 : : /* data[0][4095:2048], data[1][2047:0] */
4116 : 5 : _iov_alloc_buf(&iovs[1], 2048 + 2048);
4117 : :
4118 : : /* data[1][3071:2048] */
4119 : 5 : _iov_alloc_buf(&iovs[2], 1024);
4120 : :
4121 : : /* data[1][3072] */
4122 : 5 : _iov_alloc_buf(&iovs[3], 1);
4123 : :
4124 : : /* data[1][4094:3073] */
4125 : 5 : _iov_alloc_buf(&iovs[4], 1022);
4126 : :
4127 : : /* data[1][4095], data[2][4095:0], data[3][4095:0] */
4128 : 5 : _iov_alloc_buf(&iovs[5], 1 + 4096 * 2);
4129 : :
4130 : 5 : _iov_alloc_buf(&md_iov, 128 * 4);
4131 : :
4132 : 5 : dix_generate_remap_and_verify(iovs, 6, &md_iov, 4096, 128, 4, false, SPDK_DIF_TYPE1,
4133 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_32);
4134 : 5 : dix_generate_remap_and_verify(iovs, 6, &md_iov, 4096, 128, 4, false, SPDK_DIF_TYPE1,
4135 : : dif_flags, 22, 99, 0xFFFF, 0x22, SPDK_DIF_PI_FORMAT_64);
4136 : :
4137 [ + + ]: 35 : for (i = 0; i < 6; i++) {
4138 : 30 : _iov_free_buf(&iovs[i]);
4139 : : }
4140 : 5 : _iov_free_buf(&md_iov);
4141 : 5 : }
4142 : :
4143 : : static void
4144 : 5 : dif_generate_and_verify_unmap_test(void)
4145 : : {
4146 : 4 : struct iovec iov;
4147 : 5 : struct spdk_dif_ctx ctx = {};
4148 : : int rc;
4149 : 4 : struct spdk_dif_ctx_init_ext_opts dif_opts;
4150 : : uint32_t dif_flags;
4151 : : struct spdk_dif *dif;
4152 : :
4153 : 5 : _iov_alloc_buf(&iov, 4096 + 128);
4154 : :
4155 : 5 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
4156 : 5 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
4157 : 5 : dif = (struct spdk_dif *)(iov.iov_base + 4096);
4158 : :
4159 : : /* Case 1 for TYPE1 */
4160 [ - + ]: 5 : memset(iov.iov_base, 0, 4096 + 128);
4161 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK;
4162 : 5 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, true, SPDK_DIF_TYPE1, dif_flags,
4163 : : 0x100, 0xFFFF, SPDK_DIF_APPTAG_IGNORE, 0, 0, &dif_opts);
4164 : 5 : CU_ASSERT(rc == 0);
4165 : :
4166 : 5 : rc = spdk_dif_generate(&iov, 1, 1, &ctx);
4167 : 5 : CU_ASSERT(rc == 0);
4168 : :
4169 : 5 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, NULL);
4170 : 5 : CU_ASSERT(rc == 0);
4171 : :
4172 : 5 : CU_ASSERT(_dif_get_apptag(dif, ctx.dif_pi_format) == SPDK_DIF_APPTAG_IGNORE);
4173 : 5 : CU_ASSERT(_dif_get_reftag(dif, ctx.dif_pi_format) == 0x100);
4174 : :
4175 : : /* Case 2 for TYPE3 */
4176 [ - + ]: 5 : memset(iov.iov_base, 0, 4096 + 128);
4177 : :
4178 : 5 : dif_flags = SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK;
4179 : 5 : rc = spdk_dif_ctx_init(&ctx, 4096 + 128, 128, true, true, SPDK_DIF_TYPE3, dif_flags,
4180 : : SPDK_DIF_REFTAG_IGNORE, 0xFFFF, SPDK_DIF_APPTAG_IGNORE, 0, 0, &dif_opts);
4181 : 5 : CU_ASSERT(rc == 0);
4182 : :
4183 : 5 : rc = spdk_dif_generate(&iov, 1, 1, &ctx);
4184 : 5 : CU_ASSERT(rc == 0);
4185 : :
4186 : 5 : rc = spdk_dif_verify(&iov, 1, 1, &ctx, NULL);
4187 : 5 : CU_ASSERT(rc == 0);
4188 : :
4189 : 5 : CU_ASSERT(_dif_get_apptag(dif, ctx.dif_pi_format) == SPDK_DIF_APPTAG_IGNORE);
4190 : 5 : CU_ASSERT(_dif_get_reftag(dif, ctx.dif_pi_format) == REFTAG_MASK_16);
4191 : :
4192 : 5 : _iov_free_buf(&iov);
4193 : 5 : }
4194 : :
4195 : : static void
4196 : 5 : dif_pi_format_check_test(void)
4197 : : {
4198 : 5 : CU_ASSERT(_dif_pi_format_is_valid(SPDK_DIF_PI_FORMAT_16) == true);
4199 : 5 : CU_ASSERT(_dif_pi_format_is_valid(SPDK_DIF_PI_FORMAT_32) == true);
4200 : 5 : CU_ASSERT(_dif_pi_format_is_valid(SPDK_DIF_PI_FORMAT_64) == true);
4201 : 5 : CU_ASSERT(_dif_pi_format_is_valid(SPDK_DIF_PI_FORMAT_64 + 1) == false);
4202 : 5 : }
4203 : :
4204 : : static void
4205 : 5 : dif_type_check_test(void)
4206 : : {
4207 : 5 : CU_ASSERT(_dif_type_is_valid(SPDK_DIF_DISABLE) == true);
4208 : 5 : CU_ASSERT(_dif_type_is_valid(SPDK_DIF_TYPE1) == true);
4209 : 5 : CU_ASSERT(_dif_type_is_valid(SPDK_DIF_TYPE2) == true);
4210 : 5 : CU_ASSERT(_dif_type_is_valid(SPDK_DIF_TYPE3) == true);
4211 : 5 : CU_ASSERT(_dif_type_is_valid(SPDK_DIF_TYPE3 + 1) == false);
4212 : 5 : }
4213 : :
4214 : : int
4215 : 5 : main(int argc, char **argv)
4216 : : {
4217 : 5 : CU_pSuite suite = NULL;
4218 : : unsigned int num_failures;
4219 : :
4220 : 5 : CU_initialize_registry();
4221 : :
4222 : 5 : suite = CU_add_suite("dif", NULL, NULL);
4223 : :
4224 : 5 : CU_ADD_TEST(suite, dif_generate_and_verify_test);
4225 : 5 : CU_ADD_TEST(suite, dif_disable_check_test);
4226 : 5 : CU_ADD_TEST(suite, dif_generate_and_verify_different_pi_formats_test);
4227 : 5 : CU_ADD_TEST(suite, dif_apptag_mask_test);
4228 : 5 : CU_ADD_TEST(suite, dif_sec_8_md_8_error_test);
4229 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_0_error_test);
4230 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_16_error_test);
4231 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_0_8_error_test);
4232 : 5 : CU_ADD_TEST(suite, dif_sec_4100_md_128_error_test);
4233 : 5 : CU_ADD_TEST(suite, dif_guard_seed_test);
4234 : 5 : CU_ADD_TEST(suite, dif_guard_value_test);
4235 : 5 : CU_ADD_TEST(suite, dif_disable_sec_512_md_8_single_iov_test);
4236 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_0_single_iov_test);
4237 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_0_single_iov_test);
4238 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_0_1_2_4_multi_iovs_test);
4239 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test);
4240 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_test);
4241 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_data_and_md_test);
4242 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_split_data_and_md_test);
4243 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_data_test);
4244 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_split_data_test);
4245 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_guard_test);
4246 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_split_guard_test);
4247 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_apptag_test);
4248 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_split_apptag_test);
4249 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_split_reftag_test);
4250 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_split_reftag_test);
4251 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_complex_splits_test);
4252 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);
4253 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
4254 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_and_md_test);
4255 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_data_test);
4256 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_guard_test);
4257 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_pi_16_test);
4258 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_apptag_test);
4259 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_pi_16_test);
4260 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_reftag_test);
4261 : 5 : CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_0_single_iov);
4262 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_0_single_iov_test);
4263 : 5 : CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
4264 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test);
4265 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs);
4266 : 5 : CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_split_data);
4267 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs_split_data_test);
4268 : 5 : CU_ADD_TEST(suite, dif_copy_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
4269 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);
4270 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
4271 : 5 : CU_ADD_TEST(suite, dif_copy_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
4272 : 5 : CU_ADD_TEST(suite, dix_sec_0_md_8_error);
4273 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_0_error);
4274 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_16_error);
4275 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_0_8_error);
4276 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_0_single_iov);
4277 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_0_single_iov_test);
4278 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_0_1_2_4_multi_iovs);
4279 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_0_1_2_4_multi_iovs_test);
4280 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs);
4281 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_split_data);
4282 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs_split_data_test);
4283 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits);
4284 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_test);
4285 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_test);
4286 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_inject_1_2_4_8_multi_iovs_split_test);
4287 : 5 : CU_ADD_TEST(suite, set_md_interleave_iovs_test);
4288 : 5 : CU_ADD_TEST(suite, set_md_interleave_iovs_split_test);
4289 : 5 : CU_ADD_TEST(suite, dif_generate_stream_pi_16_test);
4290 : 5 : CU_ADD_TEST(suite, dif_generate_stream_test);
4291 : 5 : CU_ADD_TEST(suite, set_md_interleave_iovs_alignment_test);
4292 : 5 : CU_ADD_TEST(suite, dif_generate_split_test);
4293 : 5 : CU_ADD_TEST(suite, set_md_interleave_iovs_multi_segments_test);
4294 : 5 : CU_ADD_TEST(suite, dif_verify_split_test);
4295 : 5 : CU_ADD_TEST(suite, dif_verify_stream_multi_segments_test);
4296 : 5 : CU_ADD_TEST(suite, update_crc32c_pi_16_test);
4297 : 5 : CU_ADD_TEST(suite, update_crc32c_test);
4298 : 5 : CU_ADD_TEST(suite, dif_update_crc32c_split_test);
4299 : 5 : CU_ADD_TEST(suite, dif_update_crc32c_stream_multi_segments_test);
4300 : 5 : CU_ADD_TEST(suite, get_range_with_md_test);
4301 : 5 : CU_ADD_TEST(suite, dif_sec_512_md_8_prchk_7_multi_iovs_remap_pi_16_test);
4302 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_remap_test);
4303 : 5 : CU_ADD_TEST(suite, dif_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test);
4304 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs_remap);
4305 : 5 : CU_ADD_TEST(suite, dix_sec_512_md_8_prchk_7_multi_iovs_complex_splits_remap_pi_16_test);
4306 : 5 : CU_ADD_TEST(suite, dix_sec_4096_md_128_prchk_7_multi_iovs_complex_splits_remap_test);
4307 : 5 : CU_ADD_TEST(suite, dif_generate_and_verify_unmap_test);
4308 : 5 : CU_ADD_TEST(suite, dif_pi_format_check_test);
4309 : 5 : CU_ADD_TEST(suite, dif_type_check_test);
4310 : :
4311 : 5 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
4312 : :
4313 : 5 : CU_cleanup_registry();
4314 : :
4315 : 5 : return num_failures;
4316 : : }
|