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