Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2023 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk_internal/cunit.h"
7 : : #include "spdk_internal/mock.h"
8 : : #include "spdk_internal/idxd.h"
9 : : #include "common/lib/test_env.c"
10 : :
11 : : #include "idxd/idxd.c"
12 : :
13 : : static void
14 : 0 : test_idxd_validate_dif_common_params(void)
15 : : {
16 : 0 : struct spdk_dif_ctx dif_ctx;
17 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
18 : : int rc;
19 : :
20 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
21 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
22 : :
23 : : /* Check all supported combinations of the block size and metadata size */
24 : : /* ## supported: block-size = 512, metadata = 8 */
25 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
26 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
27 : : METADATA_SIZE_8,
28 : : true,
29 : : false,
30 : : SPDK_DIF_TYPE1,
31 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
32 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
33 : : 0, 0, 0, 0, 0, &dif_opts);
34 : 0 : CU_ASSERT(rc == 0);
35 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
36 : 0 : CU_ASSERT(rc == 0);
37 : :
38 : : /* ## supported: block-size = 512, metadata = 16 */
39 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
40 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_16,
41 : : METADATA_SIZE_16,
42 : : true,
43 : : false,
44 : : SPDK_DIF_TYPE1,
45 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
46 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
47 : : 0, 0, 0, 0, 0, &dif_opts);
48 : 0 : CU_ASSERT(rc == 0);
49 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
50 : 0 : CU_ASSERT(rc == 0);
51 : :
52 : : /* ## supported: block-size = 4096, metadata = 8 */
53 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
54 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_8,
55 : : METADATA_SIZE_8,
56 : : true,
57 : : false,
58 : : SPDK_DIF_TYPE1,
59 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
60 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
61 : : 0, 0, 0, 0, 0, &dif_opts);
62 : 0 : CU_ASSERT(rc == 0);
63 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
64 : 0 : CU_ASSERT(rc == 0);
65 : :
66 : : /* ## supported: block-size = 4096, metadata = 16 */
67 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
68 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_16,
69 : : METADATA_SIZE_16,
70 : : true,
71 : : false,
72 : : SPDK_DIF_TYPE1,
73 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
74 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
75 : : 0, 0, 0, 0, 0, &dif_opts);
76 : 0 : CU_ASSERT(rc == 0);
77 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
78 : 0 : CU_ASSERT(rc == 0);
79 : :
80 : : /* Check byte offset from the start of the whole data buffer */
81 : : /* ## not-supported: data_offset != 0 */
82 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
83 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
84 : : METADATA_SIZE_8,
85 : : true,
86 : : false,
87 : : SPDK_DIF_TYPE1,
88 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
89 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
90 : : 0, 0, 0, 10, 0, &dif_opts);
91 : 0 : CU_ASSERT(rc == 0);
92 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
93 : 0 : CU_ASSERT(rc == -EINVAL);
94 : :
95 : : /* Check seed value for guard computation */
96 : : /* ## not-supported: guard_seed != 0 */
97 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
98 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
99 : : METADATA_SIZE_8,
100 : : true,
101 : : false,
102 : : SPDK_DIF_TYPE1,
103 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
104 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
105 : : 0, 0, 0, 0, 10, &dif_opts);
106 : 0 : CU_ASSERT(rc == 0);
107 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
108 : 0 : CU_ASSERT(rc == -EINVAL);
109 : :
110 : : /* Check for supported metadata sizes */
111 : : /* ## not-supported: md_size != 8 or md_size != 16 */
112 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
113 : : DATA_BLOCK_SIZE_4096 + 32,
114 : : 32,
115 : : true,
116 : : false,
117 : : SPDK_DIF_TYPE1,
118 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
119 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
120 : : 0, 0, 0, 0, 0, &dif_opts);
121 : 0 : CU_ASSERT(rc == 0);
122 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
123 : 0 : CU_ASSERT(rc == -EINVAL);
124 : :
125 : : /* Check for supported metadata locations */
126 : : /* ## not-supported: md_interleave == false (separated metadata location) */
127 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
128 : : DATA_BLOCK_SIZE_4096,
129 : : METADATA_SIZE_16,
130 : : false,
131 : : false,
132 : : SPDK_DIF_TYPE1,
133 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
134 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
135 : : 0, 0, 0, 0, 0, &dif_opts);
136 : 0 : CU_ASSERT(rc == 0);
137 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
138 : 0 : CU_ASSERT(rc == -EINVAL);
139 : :
140 : : /* Check for supported DIF alignments */
141 : : /* ## not-supported: dif_loc == true (DIF left alignment) */
142 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
143 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_16,
144 : : METADATA_SIZE_16,
145 : : true,
146 : : true,
147 : : SPDK_DIF_TYPE1,
148 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
149 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
150 : : 0, 0, 0, 0, 0, &dif_opts);
151 : 0 : CU_ASSERT(rc == 0);
152 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
153 : 0 : CU_ASSERT(rc == -EINVAL);
154 : :
155 : : /* Check for supported DIF block sizes */
156 : : /* ## not-supported: block_size (without metadata) != 512,520,4096,4104 */
157 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
158 : : DATA_BLOCK_SIZE_512 + 10,
159 : : METADATA_SIZE_8,
160 : : true,
161 : : false,
162 : : SPDK_DIF_TYPE1,
163 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
164 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
165 : : 0, 0, 0, 0, 0, &dif_opts);
166 : 0 : CU_ASSERT(rc == 0);
167 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
168 : 0 : CU_ASSERT(rc == -EINVAL);
169 : :
170 : : /* Check for supported DIF PI formats */
171 : : /* ## not-supported: DIF PI format == 32 */
172 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_32;
173 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
174 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_16,
175 : : METADATA_SIZE_16,
176 : : true,
177 : : false,
178 : : SPDK_DIF_TYPE1,
179 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
180 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
181 : : 0, 0, 0, 0, 0, &dif_opts);
182 : 0 : CU_ASSERT(rc == 0);
183 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
184 : 0 : CU_ASSERT(rc == -EINVAL);
185 : :
186 : : /* ## not-supported: DIF PI format == 64 */
187 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_64;
188 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
189 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_16,
190 : : METADATA_SIZE_16,
191 : : true,
192 : : false,
193 : : SPDK_DIF_TYPE1,
194 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
195 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
196 : : 0, 0, 0, 0, 0, &dif_opts);
197 : 0 : CU_ASSERT(rc == 0);
198 : 0 : rc = idxd_validate_dif_common_params(&dif_ctx);
199 : 0 : CU_ASSERT(rc == -EINVAL);
200 : 0 : }
201 : :
202 : : static void
203 : 0 : test_idxd_validate_dif_check_params(void)
204 : : {
205 : 0 : struct spdk_dif_ctx dif_ctx;
206 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
207 : : int rc;
208 : :
209 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
210 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
211 : :
212 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
213 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
214 : : METADATA_SIZE_8,
215 : : true,
216 : : false,
217 : : SPDK_DIF_TYPE1,
218 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK,
219 : : 0, 0, 0, 0, 0, &dif_opts);
220 : 0 : CU_ASSERT(rc == 0);
221 : :
222 : 0 : rc = idxd_validate_dif_check_params(&dif_ctx);
223 : 0 : CU_ASSERT(rc == 0);
224 : 0 : }
225 : :
226 : : static void
227 : 0 : test_idxd_validate_dif_insert_params(void)
228 : : {
229 : 0 : struct spdk_dif_ctx dif_ctx;
230 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
231 : : int rc;
232 : :
233 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
234 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
235 : :
236 : : /* Check for required DIF flags */
237 : : /* ## supported: Guard, ApplicationTag, ReferenceTag check flags set */
238 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
239 : : 512 + 8,
240 : : 8,
241 : : true,
242 : : false,
243 : : SPDK_DIF_TYPE1,
244 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
245 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
246 : : 0, 0, 0, 0, 0, &dif_opts);
247 : 0 : CU_ASSERT(rc == 0);
248 : 0 : rc = idxd_validate_dif_insert_params(&dif_ctx);
249 : 0 : CU_ASSERT(rc == 0);
250 : :
251 : : /* ## not-supported: Guard check flag not set */
252 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
253 : : 512 + 8,
254 : : 8,
255 : : true,
256 : : false,
257 : : SPDK_DIF_TYPE1,
258 : : SPDK_DIF_FLAGS_APPTAG_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK,
259 : : 0, 0, 0, 0, 0, &dif_opts);
260 : 0 : CU_ASSERT(rc == 0);
261 : 0 : rc = idxd_validate_dif_insert_params(&dif_ctx);
262 : 0 : CU_ASSERT(rc == -EINVAL);
263 : :
264 : : /* ## not-supported: Application Tag check flag not set */
265 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
266 : : 512 + 8,
267 : : 8,
268 : : true,
269 : : false,
270 : : SPDK_DIF_TYPE1,
271 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK,
272 : : 0, 0, 0, 0, 0, &dif_opts);
273 : 0 : CU_ASSERT(rc == 0);
274 : 0 : rc = idxd_validate_dif_insert_params(&dif_ctx);
275 : 0 : CU_ASSERT(rc == -EINVAL);
276 : :
277 : : /* ## not-supported: Reference Tag check flag not set */
278 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
279 : : 512 + 8,
280 : : 8,
281 : : true,
282 : : false,
283 : : SPDK_DIF_TYPE1,
284 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK,
285 : : 0, 0, 0, 0, 0, &dif_opts);
286 : 0 : CU_ASSERT(rc == 0);
287 : 0 : rc = idxd_validate_dif_insert_params(&dif_ctx);
288 : 0 : CU_ASSERT(rc == -EINVAL);
289 : 0 : }
290 : :
291 : : static void
292 : 0 : test_idxd_validate_dif_check_buf_align(void)
293 : : {
294 : 0 : struct spdk_dif_ctx dif_ctx;
295 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
296 : : int rc;
297 : :
298 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
299 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
300 : :
301 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
302 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
303 : : METADATA_SIZE_8,
304 : : true,
305 : : false,
306 : : SPDK_DIF_TYPE1,
307 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
308 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
309 : : 0, 0, 0, 0, 0, &dif_opts);
310 : 0 : CU_ASSERT(rc == 0);
311 : :
312 : 0 : rc = idxd_validate_dif_check_buf_align(&dif_ctx, 4 * (512 + 8));
313 : 0 : CU_ASSERT(rc == 0);
314 : :
315 : : /* The memory buffer length is not a multiple of block size with metadata */
316 : 0 : rc = idxd_validate_dif_check_buf_align(&dif_ctx, 4 * (512 + 8) + 10);
317 : 0 : CU_ASSERT(rc == -EINVAL);
318 : 0 : }
319 : :
320 : : static void
321 : 0 : test_idxd_validate_dif_insert_buf_align(void)
322 : : {
323 : 0 : struct spdk_dif_ctx dif_ctx;
324 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
325 : : int rc;
326 : :
327 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
328 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
329 : :
330 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
331 : : 512 + 8,
332 : : 8,
333 : : true,
334 : : false,
335 : : SPDK_DIF_TYPE1,
336 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
337 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
338 : : 0, 0, 0, 0, 0, &dif_opts);
339 : 0 : CU_ASSERT(rc == 0);
340 : :
341 : : /* The memory source and destination buffer length set correctly */
342 : 0 : rc = idxd_validate_dif_insert_buf_align(&dif_ctx, 4 * 512, 4 * 520);
343 : 0 : CU_ASSERT(rc == 0);
344 : :
345 : : /* The memory source buffer length is not a multiple of block size without metadata */
346 : 0 : rc = idxd_validate_dif_insert_buf_align(&dif_ctx, 4 * 512 + 10, 4 * 520);
347 : 0 : CU_ASSERT(rc == -EINVAL);
348 : :
349 : : /* The memory destination buffer length is not a multiple of block size with metadata */
350 : 0 : rc = idxd_validate_dif_insert_buf_align(&dif_ctx, 4 * 512, 4 * 520 + 10);
351 : 0 : CU_ASSERT(rc == -EINVAL);
352 : :
353 : : /* The memory source and destiantion must hold the same number of blocks */
354 : 0 : rc = idxd_validate_dif_insert_buf_align(&dif_ctx, 4 * 512, 5 * 520);
355 : 0 : CU_ASSERT(rc == -EINVAL);
356 : 0 : }
357 : :
358 : : static void
359 : 0 : test_idxd_get_dif_flags(void)
360 : : {
361 : 0 : struct spdk_dif_ctx dif_ctx;
362 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
363 : 0 : uint8_t flags;
364 : : int rc;
365 : :
366 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
367 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
368 : :
369 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
370 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
371 : : METADATA_SIZE_8,
372 : : true,
373 : : false,
374 : : SPDK_DIF_TYPE1,
375 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
376 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
377 : : 0, 0, 0, 0, 0, &dif_opts);
378 : 0 : CU_ASSERT(rc == 0);
379 : :
380 : 0 : rc = idxd_get_dif_flags(&dif_ctx, &flags);
381 : 0 : CU_ASSERT(rc == 0);
382 : 0 : CU_ASSERT(flags == IDXD_DIF_FLAG_DIF_BLOCK_SIZE_512);
383 : :
384 : 0 : dif_ctx.guard_interval = 100;
385 : 0 : rc = idxd_get_dif_flags(&dif_ctx, &flags);
386 : 0 : CU_ASSERT(rc == -EINVAL);
387 : :
388 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
389 : : DATA_BLOCK_SIZE_520 + METADATA_SIZE_8,
390 : : METADATA_SIZE_8,
391 : : true,
392 : : false,
393 : : SPDK_DIF_TYPE1,
394 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
395 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
396 : : 0, 0, 0, 0, 0, &dif_opts);
397 : 0 : CU_ASSERT(rc == 0);
398 : :
399 : 0 : rc = idxd_get_dif_flags(&dif_ctx, &flags);
400 : 0 : CU_ASSERT(rc == 0);
401 : 0 : CU_ASSERT(flags == IDXD_DIF_FLAG_DIF_BLOCK_SIZE_520);
402 : :
403 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
404 : : DATA_BLOCK_SIZE_4096 + METADATA_SIZE_8,
405 : : METADATA_SIZE_8,
406 : : true,
407 : : false,
408 : : SPDK_DIF_TYPE1,
409 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
410 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
411 : : 0, 0, 0, 0, 0, &dif_opts);
412 : 0 : CU_ASSERT(rc == 0);
413 : :
414 : 0 : rc = idxd_get_dif_flags(&dif_ctx, &flags);
415 : 0 : CU_ASSERT(rc == 0);
416 : 0 : CU_ASSERT(flags == IDXD_DIF_FLAG_DIF_BLOCK_SIZE_4096);
417 : :
418 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
419 : : DATA_BLOCK_SIZE_4104 + METADATA_SIZE_8,
420 : : METADATA_SIZE_8,
421 : : true,
422 : : false,
423 : : SPDK_DIF_TYPE1,
424 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK |
425 : : SPDK_DIF_FLAGS_REFTAG_CHECK,
426 : : 0, 0, 0, 0, 0, &dif_opts);
427 : 0 : CU_ASSERT(rc == 0);
428 : :
429 : 0 : rc = idxd_get_dif_flags(&dif_ctx, &flags);
430 : 0 : CU_ASSERT(rc == 0);
431 : 0 : CU_ASSERT(flags == IDXD_DIF_FLAG_DIF_BLOCK_SIZE_4104);
432 : 0 : }
433 : :
434 : : static void
435 : 0 : test_idxd_get_source_dif_flags(void)
436 : : {
437 : 0 : struct spdk_dif_ctx dif_ctx;
438 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
439 : 0 : uint8_t flags;
440 : : int rc;
441 : :
442 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
443 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
444 : :
445 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
446 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
447 : : METADATA_SIZE_8,
448 : : true,
449 : : false,
450 : : SPDK_DIF_TYPE1,
451 : : 0,
452 : : 0, 0, 0, 0, 0, &dif_opts);
453 : 0 : CU_ASSERT(rc == 0);
454 : :
455 : 0 : rc = idxd_get_source_dif_flags(&dif_ctx, &flags);
456 : 0 : CU_ASSERT(rc == 0);
457 : 0 : CU_ASSERT(flags == (IDXD_DIF_SOURCE_FLAG_GUARD_CHECK_DISABLE |
458 : : IDXD_DIF_SOURCE_FLAG_REF_TAG_CHECK_DISABLE |
459 : : IDXD_DIF_SOURCE_FLAG_APP_TAG_F_DETECT));
460 : :
461 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
462 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
463 : : METADATA_SIZE_8,
464 : : true,
465 : : false,
466 : : SPDK_DIF_TYPE1,
467 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK,
468 : : 0, 0, 0, 0, 0, &dif_opts);
469 : 0 : CU_ASSERT(rc == 0);
470 : :
471 : 0 : rc = idxd_get_source_dif_flags(&dif_ctx, &flags);
472 : 0 : CU_ASSERT(rc == 0);
473 : 0 : CU_ASSERT(flags == (IDXD_DIF_SOURCE_FLAG_APP_TAG_F_DETECT));
474 : :
475 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
476 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
477 : : METADATA_SIZE_8,
478 : : true,
479 : : false,
480 : : SPDK_DIF_TYPE3,
481 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_REFTAG_CHECK,
482 : : 0, 0, 0, 0, 0, &dif_opts);
483 : 0 : CU_ASSERT(rc == 0);
484 : :
485 : 0 : rc = idxd_get_source_dif_flags(&dif_ctx, &flags);
486 : 0 : CU_ASSERT(rc == 0);
487 : 0 : CU_ASSERT(flags == (IDXD_DIF_SOURCE_FLAG_APP_AND_REF_TAG_F_DETECT));
488 : :
489 : 0 : dif_ctx.dif_type = 0xF;
490 : 0 : rc = idxd_get_source_dif_flags(&dif_ctx, &flags);
491 : 0 : CU_ASSERT(rc == -EINVAL);
492 : 0 : }
493 : :
494 : : static void
495 : 0 : test_idxd_get_app_tag_mask(void)
496 : : {
497 : 0 : struct spdk_dif_ctx dif_ctx;
498 : 0 : struct spdk_dif_ctx_init_ext_opts dif_opts;
499 : 0 : uint16_t app_tag_mask, app_tag_mask_expected;
500 : : int rc;
501 : :
502 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
503 : 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
504 : :
505 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
506 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
507 : : METADATA_SIZE_8,
508 : : true,
509 : : false,
510 : : SPDK_DIF_TYPE1,
511 : : SPDK_DIF_FLAGS_GUARD_CHECK,
512 : : 0, 0, 0, 0, 0, &dif_opts);
513 : 0 : CU_ASSERT(rc == 0);
514 : :
515 : 0 : rc = idxd_get_app_tag_mask(&dif_ctx, &app_tag_mask);
516 : 0 : CU_ASSERT(rc == 0);
517 : 0 : app_tag_mask_expected = 0xFFFF;
518 : 0 : CU_ASSERT(app_tag_mask == app_tag_mask_expected);
519 : :
520 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
521 : : DATA_BLOCK_SIZE_512 + METADATA_SIZE_8,
522 : : METADATA_SIZE_8,
523 : : true,
524 : : false,
525 : : SPDK_DIF_TYPE1,
526 : : SPDK_DIF_FLAGS_GUARD_CHECK | SPDK_DIF_FLAGS_APPTAG_CHECK,
527 : : 0, 10, 0, 0, 0, &dif_opts);
528 : 0 : CU_ASSERT(rc == 0);
529 : :
530 : 0 : rc = idxd_get_app_tag_mask(&dif_ctx, &app_tag_mask);
531 : 0 : CU_ASSERT(rc == 0);
532 : 0 : app_tag_mask_expected = ~dif_ctx.apptag_mask;
533 : 0 : CU_ASSERT(app_tag_mask == app_tag_mask_expected);
534 : 0 : }
535 : :
536 : : int
537 : 0 : main(int argc, char **argv)
538 : : {
539 : 0 : CU_pSuite suite = NULL;
540 : : unsigned int num_failures;
541 : :
542 : 0 : CU_initialize_registry();
543 : :
544 : 0 : suite = CU_add_suite("idxd", NULL, NULL);
545 : :
546 : 0 : CU_ADD_TEST(suite, test_idxd_validate_dif_common_params);
547 : 0 : CU_ADD_TEST(suite, test_idxd_validate_dif_check_params);
548 : 0 : CU_ADD_TEST(suite, test_idxd_validate_dif_check_buf_align);
549 : 0 : CU_ADD_TEST(suite, test_idxd_validate_dif_insert_params);
550 : 0 : CU_ADD_TEST(suite, test_idxd_validate_dif_insert_buf_align);
551 : 0 : CU_ADD_TEST(suite, test_idxd_get_dif_flags);
552 : 0 : CU_ADD_TEST(suite, test_idxd_get_source_dif_flags);
553 : 0 : CU_ADD_TEST(suite, test_idxd_get_app_tag_mask);
554 : :
555 : 0 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
556 : 0 : CU_cleanup_registry();
557 : 0 : return num_failures;
558 : : }
|