1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2018 - 2019 Intel Corporation 3 */ 4 #include <string.h> 5 #include <zlib.h> 6 #include <math.h> 7 #include <stdlib.h> 8 #include <unistd.h> 9 10 #include <rte_cycles.h> 11 #include <rte_malloc.h> 12 #include <rte_mempool.h> 13 #include <rte_mbuf.h> 14 #include <rte_compressdev.h> 15 #include <rte_string_fns.h> 16 17 #include "test_compressdev_test_buffer.h" 18 #include "test.h" 19 20 #define DIV_CEIL(a, b) ((a) / (b) + ((a) % (b) != 0)) 21 22 #define DEFAULT_WINDOW_SIZE 15 23 #define DEFAULT_MEM_LEVEL 8 24 #define MAX_DEQD_RETRIES 10 25 #define DEQUEUE_WAIT_TIME 10000 26 27 /* 28 * 30% extra size for compressed data compared to original data, 29 * in case data size cannot be reduced and it is actually bigger 30 * due to the compress block headers 31 */ 32 #define COMPRESS_BUF_SIZE_RATIO 1.3 33 #define NUM_LARGE_MBUFS 16 34 #define SMALL_SEG_SIZE 256 35 #define MAX_SEGS 16 36 #define NUM_OPS 16 37 #define NUM_MAX_XFORMS 16 38 #define NUM_MAX_INFLIGHT_OPS 128 39 #define CACHE_SIZE 0 40 41 #define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31 42 #define ZLIB_HEADER_SIZE 2 43 #define ZLIB_TRAILER_SIZE 4 44 #define GZIP_HEADER_SIZE 10 45 #define GZIP_TRAILER_SIZE 8 46 47 #define OUT_OF_SPACE_BUF 1 48 49 #define MAX_MBUF_SEGMENT_SIZE 65535 50 #define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM) 51 #define NUM_BIG_MBUFS 4 52 #define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * NUM_BIG_MBUFS / 2) 53 54 const char * 55 huffman_type_strings[] = { 56 [RTE_COMP_HUFFMAN_DEFAULT] = "PMD default", 57 [RTE_COMP_HUFFMAN_FIXED] = "Fixed", 58 [RTE_COMP_HUFFMAN_DYNAMIC] = "Dynamic" 59 }; 60 61 enum zlib_direction { 62 ZLIB_NONE, 63 ZLIB_COMPRESS, 64 ZLIB_DECOMPRESS, 65 ZLIB_ALL 66 }; 67 68 enum varied_buff { 69 LB_BOTH = 0, /* both input and output are linear*/ 70 SGL_BOTH, /* both input and output are chained */ 71 SGL_TO_LB, /* input buffer is chained */ 72 LB_TO_SGL /* output buffer is chained */ 73 }; 74 75 struct priv_op_data { 76 uint16_t orig_idx; 77 }; 78 79 struct comp_testsuite_params { 80 struct rte_mempool *large_mbuf_pool; 81 struct rte_mempool *small_mbuf_pool; 82 struct rte_mempool *big_mbuf_pool; 83 struct rte_mempool *op_pool; 84 struct rte_comp_xform *def_comp_xform; 85 struct rte_comp_xform *def_decomp_xform; 86 }; 87 88 struct interim_data_params { 89 const char * const *test_bufs; 90 unsigned int num_bufs; 91 uint16_t *buf_idx; 92 struct rte_comp_xform **compress_xforms; 93 struct rte_comp_xform **decompress_xforms; 94 unsigned int num_xforms; 95 }; 96 97 struct test_data_params { 98 enum rte_comp_op_type compress_state; 99 enum rte_comp_op_type decompress_state; 100 enum varied_buff buff_type; 101 enum zlib_direction zlib_dir; 102 unsigned int out_of_space; 103 unsigned int big_data; 104 /* stateful decompression specific parameters */ 105 unsigned int decompress_output_block_size; 106 unsigned int decompress_steps_max; 107 /* external mbufs specific parameters */ 108 unsigned int use_external_mbufs; 109 unsigned int inbuf_data_size; 110 const struct rte_memzone *inbuf_memzone; 111 const struct rte_memzone *compbuf_memzone; 112 const struct rte_memzone *uncompbuf_memzone; 113 }; 114 115 static struct comp_testsuite_params testsuite_params = { 0 }; 116 117 static void 118 testsuite_teardown(void) 119 { 120 struct comp_testsuite_params *ts_params = &testsuite_params; 121 122 if (rte_mempool_in_use_count(ts_params->large_mbuf_pool)) 123 RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n"); 124 if (rte_mempool_in_use_count(ts_params->small_mbuf_pool)) 125 RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n"); 126 if (rte_mempool_in_use_count(ts_params->big_mbuf_pool)) 127 RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n"); 128 if (rte_mempool_in_use_count(ts_params->op_pool)) 129 RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n"); 130 131 rte_mempool_free(ts_params->large_mbuf_pool); 132 rte_mempool_free(ts_params->small_mbuf_pool); 133 rte_mempool_free(ts_params->big_mbuf_pool); 134 rte_mempool_free(ts_params->op_pool); 135 rte_free(ts_params->def_comp_xform); 136 rte_free(ts_params->def_decomp_xform); 137 } 138 139 static int 140 testsuite_setup(void) 141 { 142 struct comp_testsuite_params *ts_params = &testsuite_params; 143 uint32_t max_buf_size = 0; 144 unsigned int i; 145 146 if (rte_compressdev_count() == 0) { 147 RTE_LOG(WARNING, USER1, "Need at least one compress device\n"); 148 return TEST_SKIPPED; 149 } 150 151 RTE_LOG(NOTICE, USER1, "Running tests on device %s\n", 152 rte_compressdev_name_get(0)); 153 154 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) 155 max_buf_size = RTE_MAX(max_buf_size, 156 strlen(compress_test_bufs[i]) + 1); 157 158 /* 159 * Buffers to be used in compression and decompression. 160 * Since decompressed data might be larger than 161 * compressed data (due to block header), 162 * buffers should be big enough for both cases. 163 */ 164 max_buf_size *= COMPRESS_BUF_SIZE_RATIO; 165 ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool", 166 NUM_LARGE_MBUFS, 167 CACHE_SIZE, 0, 168 max_buf_size + RTE_PKTMBUF_HEADROOM, 169 rte_socket_id()); 170 if (ts_params->large_mbuf_pool == NULL) { 171 RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n"); 172 return TEST_FAILED; 173 } 174 175 /* Create mempool with smaller buffers for SGL testing */ 176 ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool", 177 NUM_LARGE_MBUFS * MAX_SEGS, 178 CACHE_SIZE, 0, 179 SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM, 180 rte_socket_id()); 181 if (ts_params->small_mbuf_pool == NULL) { 182 RTE_LOG(ERR, USER1, "Small mbuf pool could not be created\n"); 183 goto exit; 184 } 185 186 /* Create mempool with big buffers for SGL testing */ 187 ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool", 188 NUM_BIG_MBUFS + 1, 189 CACHE_SIZE, 0, 190 MAX_MBUF_SEGMENT_SIZE, 191 rte_socket_id()); 192 if (ts_params->big_mbuf_pool == NULL) { 193 RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n"); 194 goto exit; 195 } 196 197 ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS, 198 0, sizeof(struct priv_op_data), 199 rte_socket_id()); 200 if (ts_params->op_pool == NULL) { 201 RTE_LOG(ERR, USER1, "Operation pool could not be created\n"); 202 goto exit; 203 } 204 205 ts_params->def_comp_xform = 206 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 207 if (ts_params->def_comp_xform == NULL) { 208 RTE_LOG(ERR, USER1, 209 "Default compress xform could not be created\n"); 210 goto exit; 211 } 212 ts_params->def_decomp_xform = 213 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 214 if (ts_params->def_decomp_xform == NULL) { 215 RTE_LOG(ERR, USER1, 216 "Default decompress xform could not be created\n"); 217 goto exit; 218 } 219 220 /* Initializes default values for compress/decompress xforms */ 221 ts_params->def_comp_xform->type = RTE_COMP_COMPRESS; 222 ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE, 223 ts_params->def_comp_xform->compress.deflate.huffman = 224 RTE_COMP_HUFFMAN_DEFAULT; 225 ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT; 226 ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE; 227 ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE; 228 229 ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS; 230 ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE, 231 ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE; 232 ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE; 233 234 return TEST_SUCCESS; 235 236 exit: 237 testsuite_teardown(); 238 239 return TEST_FAILED; 240 } 241 242 static int 243 generic_ut_setup(void) 244 { 245 /* Configure compressdev (one device, one queue pair) */ 246 struct rte_compressdev_config config = { 247 .socket_id = rte_socket_id(), 248 .nb_queue_pairs = 1, 249 .max_nb_priv_xforms = NUM_MAX_XFORMS, 250 .max_nb_streams = 1 251 }; 252 253 if (rte_compressdev_configure(0, &config) < 0) { 254 RTE_LOG(ERR, USER1, "Device configuration failed\n"); 255 return -1; 256 } 257 258 if (rte_compressdev_queue_pair_setup(0, 0, NUM_MAX_INFLIGHT_OPS, 259 rte_socket_id()) < 0) { 260 RTE_LOG(ERR, USER1, "Queue pair setup failed\n"); 261 return -1; 262 } 263 264 if (rte_compressdev_start(0) < 0) { 265 RTE_LOG(ERR, USER1, "Device could not be started\n"); 266 return -1; 267 } 268 269 return 0; 270 } 271 272 static void 273 generic_ut_teardown(void) 274 { 275 rte_compressdev_stop(0); 276 if (rte_compressdev_close(0) < 0) 277 RTE_LOG(ERR, USER1, "Device could not be closed\n"); 278 } 279 280 static int 281 test_compressdev_invalid_configuration(void) 282 { 283 struct rte_compressdev_config invalid_config; 284 struct rte_compressdev_config valid_config = { 285 .socket_id = rte_socket_id(), 286 .nb_queue_pairs = 1, 287 .max_nb_priv_xforms = NUM_MAX_XFORMS, 288 .max_nb_streams = 1 289 }; 290 struct rte_compressdev_info dev_info; 291 292 /* Invalid configuration with 0 queue pairs */ 293 memcpy(&invalid_config, &valid_config, 294 sizeof(struct rte_compressdev_config)); 295 invalid_config.nb_queue_pairs = 0; 296 297 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config), 298 "Device configuration was successful " 299 "with no queue pairs (invalid)\n"); 300 301 /* 302 * Invalid configuration with too many queue pairs 303 * (if there is an actual maximum number of queue pairs) 304 */ 305 rte_compressdev_info_get(0, &dev_info); 306 if (dev_info.max_nb_queue_pairs != 0) { 307 memcpy(&invalid_config, &valid_config, 308 sizeof(struct rte_compressdev_config)); 309 invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1; 310 311 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config), 312 "Device configuration was successful " 313 "with too many queue pairs (invalid)\n"); 314 } 315 316 /* Invalid queue pair setup, with no number of queue pairs set */ 317 TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0, 318 NUM_MAX_INFLIGHT_OPS, rte_socket_id()), 319 "Queue pair setup was successful " 320 "with no queue pairs set (invalid)\n"); 321 322 return TEST_SUCCESS; 323 } 324 325 static int 326 compare_buffers(const char *buffer1, uint32_t buffer1_len, 327 const char *buffer2, uint32_t buffer2_len) 328 { 329 if (buffer1_len != buffer2_len) { 330 RTE_LOG(ERR, USER1, "Buffer lengths are different\n"); 331 return -1; 332 } 333 334 if (memcmp(buffer1, buffer2, buffer1_len) != 0) { 335 RTE_LOG(ERR, USER1, "Buffers are different\n"); 336 return -1; 337 } 338 339 return 0; 340 } 341 342 /* 343 * Maps compressdev and Zlib flush flags 344 */ 345 static int 346 map_zlib_flush_flag(enum rte_comp_flush_flag flag) 347 { 348 switch (flag) { 349 case RTE_COMP_FLUSH_NONE: 350 return Z_NO_FLUSH; 351 case RTE_COMP_FLUSH_SYNC: 352 return Z_SYNC_FLUSH; 353 case RTE_COMP_FLUSH_FULL: 354 return Z_FULL_FLUSH; 355 case RTE_COMP_FLUSH_FINAL: 356 return Z_FINISH; 357 /* 358 * There should be only the values above, 359 * so this should never happen 360 */ 361 default: 362 return -1; 363 } 364 } 365 366 static int 367 compress_zlib(struct rte_comp_op *op, 368 const struct rte_comp_xform *xform, int mem_level) 369 { 370 z_stream stream; 371 int zlib_flush; 372 int strategy, window_bits, comp_level; 373 int ret = TEST_FAILED; 374 uint8_t *single_src_buf = NULL; 375 uint8_t *single_dst_buf = NULL; 376 377 /* initialize zlib stream */ 378 stream.zalloc = Z_NULL; 379 stream.zfree = Z_NULL; 380 stream.opaque = Z_NULL; 381 382 if (xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED) 383 strategy = Z_FIXED; 384 else 385 strategy = Z_DEFAULT_STRATEGY; 386 387 /* 388 * Window bits is the base two logarithm of the window size (in bytes). 389 * When doing raw DEFLATE, this number will be negative. 390 */ 391 window_bits = -(xform->compress.window_size); 392 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) 393 window_bits *= -1; 394 else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) 395 window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS; 396 397 comp_level = xform->compress.level; 398 399 if (comp_level != RTE_COMP_LEVEL_NONE) 400 ret = deflateInit2(&stream, comp_level, Z_DEFLATED, 401 window_bits, mem_level, strategy); 402 else 403 ret = deflateInit(&stream, Z_NO_COMPRESSION); 404 405 if (ret != Z_OK) { 406 printf("Zlib deflate could not be initialized\n"); 407 goto exit; 408 } 409 410 /* Assuming stateless operation */ 411 /* SGL Input */ 412 if (op->m_src->nb_segs > 1) { 413 single_src_buf = rte_malloc(NULL, 414 rte_pktmbuf_pkt_len(op->m_src), 0); 415 if (single_src_buf == NULL) { 416 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 417 goto exit; 418 } 419 420 if (rte_pktmbuf_read(op->m_src, op->src.offset, 421 rte_pktmbuf_pkt_len(op->m_src) - 422 op->src.offset, 423 single_src_buf) == NULL) { 424 RTE_LOG(ERR, USER1, 425 "Buffer could not be read entirely\n"); 426 goto exit; 427 } 428 429 stream.avail_in = op->src.length; 430 stream.next_in = single_src_buf; 431 432 } else { 433 stream.avail_in = op->src.length; 434 stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *, 435 op->src.offset); 436 } 437 /* SGL output */ 438 if (op->m_dst->nb_segs > 1) { 439 440 single_dst_buf = rte_malloc(NULL, 441 rte_pktmbuf_pkt_len(op->m_dst), 0); 442 if (single_dst_buf == NULL) { 443 RTE_LOG(ERR, USER1, 444 "Buffer could not be allocated\n"); 445 goto exit; 446 } 447 448 stream.avail_out = op->m_dst->pkt_len; 449 stream.next_out = single_dst_buf; 450 451 } else {/* linear output */ 452 stream.avail_out = op->m_dst->data_len; 453 stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *, 454 op->dst.offset); 455 } 456 457 /* Stateless operation, all buffer will be compressed in one go */ 458 zlib_flush = map_zlib_flush_flag(op->flush_flag); 459 ret = deflate(&stream, zlib_flush); 460 461 if (stream.avail_in != 0) { 462 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n"); 463 goto exit; 464 } 465 466 if (ret != Z_STREAM_END) 467 goto exit; 468 469 /* Copy data to destination SGL */ 470 if (op->m_dst->nb_segs > 1) { 471 uint32_t remaining_data = stream.total_out; 472 uint8_t *src_data = single_dst_buf; 473 struct rte_mbuf *dst_buf = op->m_dst; 474 475 while (remaining_data > 0) { 476 uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf, 477 uint8_t *, op->dst.offset); 478 /* Last segment */ 479 if (remaining_data < dst_buf->data_len) { 480 memcpy(dst_data, src_data, remaining_data); 481 remaining_data = 0; 482 } else { 483 memcpy(dst_data, src_data, dst_buf->data_len); 484 remaining_data -= dst_buf->data_len; 485 src_data += dst_buf->data_len; 486 dst_buf = dst_buf->next; 487 } 488 } 489 } 490 491 op->consumed = stream.total_in; 492 if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) { 493 rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE); 494 rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE); 495 op->produced = stream.total_out - (ZLIB_HEADER_SIZE + 496 ZLIB_TRAILER_SIZE); 497 } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) { 498 rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE); 499 rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE); 500 op->produced = stream.total_out - (GZIP_HEADER_SIZE + 501 GZIP_TRAILER_SIZE); 502 } else 503 op->produced = stream.total_out; 504 505 op->status = RTE_COMP_OP_STATUS_SUCCESS; 506 op->output_chksum = stream.adler; 507 508 deflateReset(&stream); 509 510 ret = 0; 511 exit: 512 deflateEnd(&stream); 513 rte_free(single_src_buf); 514 rte_free(single_dst_buf); 515 516 return ret; 517 } 518 519 static int 520 decompress_zlib(struct rte_comp_op *op, 521 const struct rte_comp_xform *xform) 522 { 523 z_stream stream; 524 int window_bits; 525 int zlib_flush; 526 int ret = TEST_FAILED; 527 uint8_t *single_src_buf = NULL; 528 uint8_t *single_dst_buf = NULL; 529 530 /* initialize zlib stream */ 531 stream.zalloc = Z_NULL; 532 stream.zfree = Z_NULL; 533 stream.opaque = Z_NULL; 534 535 /* 536 * Window bits is the base two logarithm of the window size (in bytes). 537 * When doing raw DEFLATE, this number will be negative. 538 */ 539 window_bits = -(xform->decompress.window_size); 540 ret = inflateInit2(&stream, window_bits); 541 542 if (ret != Z_OK) { 543 printf("Zlib deflate could not be initialized\n"); 544 goto exit; 545 } 546 547 /* Assuming stateless operation */ 548 /* SGL */ 549 if (op->m_src->nb_segs > 1) { 550 single_src_buf = rte_malloc(NULL, 551 rte_pktmbuf_pkt_len(op->m_src), 0); 552 if (single_src_buf == NULL) { 553 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 554 goto exit; 555 } 556 single_dst_buf = rte_malloc(NULL, 557 rte_pktmbuf_pkt_len(op->m_dst), 0); 558 if (single_dst_buf == NULL) { 559 RTE_LOG(ERR, USER1, "Buffer could not be allocated\n"); 560 goto exit; 561 } 562 if (rte_pktmbuf_read(op->m_src, 0, 563 rte_pktmbuf_pkt_len(op->m_src), 564 single_src_buf) == NULL) { 565 RTE_LOG(ERR, USER1, 566 "Buffer could not be read entirely\n"); 567 goto exit; 568 } 569 570 stream.avail_in = op->src.length; 571 stream.next_in = single_src_buf; 572 stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst); 573 stream.next_out = single_dst_buf; 574 575 } else { 576 stream.avail_in = op->src.length; 577 stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *); 578 stream.avail_out = op->m_dst->data_len; 579 stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *); 580 } 581 582 /* Stateless operation, all buffer will be compressed in one go */ 583 zlib_flush = map_zlib_flush_flag(op->flush_flag); 584 ret = inflate(&stream, zlib_flush); 585 586 if (stream.avail_in != 0) { 587 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n"); 588 goto exit; 589 } 590 591 if (ret != Z_STREAM_END) 592 goto exit; 593 594 if (op->m_src->nb_segs > 1) { 595 uint32_t remaining_data = stream.total_out; 596 uint8_t *src_data = single_dst_buf; 597 struct rte_mbuf *dst_buf = op->m_dst; 598 599 while (remaining_data > 0) { 600 uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf, 601 uint8_t *); 602 /* Last segment */ 603 if (remaining_data < dst_buf->data_len) { 604 memcpy(dst_data, src_data, remaining_data); 605 remaining_data = 0; 606 } else { 607 memcpy(dst_data, src_data, dst_buf->data_len); 608 remaining_data -= dst_buf->data_len; 609 src_data += dst_buf->data_len; 610 dst_buf = dst_buf->next; 611 } 612 } 613 } 614 615 op->consumed = stream.total_in; 616 op->produced = stream.total_out; 617 op->status = RTE_COMP_OP_STATUS_SUCCESS; 618 619 inflateReset(&stream); 620 621 ret = 0; 622 exit: 623 inflateEnd(&stream); 624 625 return ret; 626 } 627 628 static int 629 prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf, 630 uint32_t total_data_size, 631 struct rte_mempool *small_mbuf_pool, 632 struct rte_mempool *large_mbuf_pool, 633 uint8_t limit_segs_in_sgl, 634 uint16_t seg_size) 635 { 636 uint32_t remaining_data = total_data_size; 637 uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size); 638 struct rte_mempool *pool; 639 struct rte_mbuf *next_seg; 640 uint32_t data_size; 641 char *buf_ptr; 642 const char *data_ptr = test_buf; 643 uint16_t i; 644 int ret; 645 646 if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl) 647 num_remaining_segs = limit_segs_in_sgl - 1; 648 649 /* 650 * Allocate data in the first segment (header) and 651 * copy data if test buffer is provided 652 */ 653 if (remaining_data < seg_size) 654 data_size = remaining_data; 655 else 656 data_size = seg_size; 657 buf_ptr = rte_pktmbuf_append(head_buf, data_size); 658 if (buf_ptr == NULL) { 659 RTE_LOG(ERR, USER1, 660 "Not enough space in the 1st buffer\n"); 661 return -1; 662 } 663 664 if (data_ptr != NULL) { 665 /* Copy characters without NULL terminator */ 666 strncpy(buf_ptr, data_ptr, data_size); 667 data_ptr += data_size; 668 } 669 remaining_data -= data_size; 670 num_remaining_segs--; 671 672 /* 673 * Allocate the rest of the segments, 674 * copy the rest of the data and chain the segments. 675 */ 676 for (i = 0; i < num_remaining_segs; i++) { 677 678 if (i == (num_remaining_segs - 1)) { 679 /* last segment */ 680 if (remaining_data > seg_size) 681 pool = large_mbuf_pool; 682 else 683 pool = small_mbuf_pool; 684 data_size = remaining_data; 685 } else { 686 data_size = seg_size; 687 pool = small_mbuf_pool; 688 } 689 690 next_seg = rte_pktmbuf_alloc(pool); 691 if (next_seg == NULL) { 692 RTE_LOG(ERR, USER1, 693 "New segment could not be allocated " 694 "from the mempool\n"); 695 return -1; 696 } 697 buf_ptr = rte_pktmbuf_append(next_seg, data_size); 698 if (buf_ptr == NULL) { 699 RTE_LOG(ERR, USER1, 700 "Not enough space in the buffer\n"); 701 rte_pktmbuf_free(next_seg); 702 return -1; 703 } 704 if (data_ptr != NULL) { 705 /* Copy characters without NULL terminator */ 706 strncpy(buf_ptr, data_ptr, data_size); 707 data_ptr += data_size; 708 } 709 remaining_data -= data_size; 710 711 ret = rte_pktmbuf_chain(head_buf, next_seg); 712 if (ret != 0) { 713 rte_pktmbuf_free(next_seg); 714 RTE_LOG(ERR, USER1, 715 "Segment could not chained\n"); 716 return -1; 717 } 718 } 719 720 return 0; 721 } 722 723 static void 724 extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused) 725 { 726 } 727 728 /* 729 * Compresses and decompresses buffer with compressdev API and Zlib API 730 */ 731 static int 732 test_deflate_comp_decomp(const struct interim_data_params *int_data, 733 const struct test_data_params *test_data) 734 { 735 struct comp_testsuite_params *ts_params = &testsuite_params; 736 const char * const *test_bufs = int_data->test_bufs; 737 unsigned int num_bufs = int_data->num_bufs; 738 uint16_t *buf_idx = int_data->buf_idx; 739 struct rte_comp_xform **compress_xforms = int_data->compress_xforms; 740 struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms; 741 unsigned int num_xforms = int_data->num_xforms; 742 enum rte_comp_op_type compress_state = test_data->compress_state; 743 enum rte_comp_op_type decompress_state = test_data->decompress_state; 744 unsigned int buff_type = test_data->buff_type; 745 unsigned int out_of_space = test_data->out_of_space; 746 unsigned int big_data = test_data->big_data; 747 enum zlib_direction zlib_dir = test_data->zlib_dir; 748 int ret_status = TEST_FAILED; 749 struct rte_mbuf_ext_shared_info inbuf_info; 750 struct rte_mbuf_ext_shared_info compbuf_info; 751 struct rte_mbuf_ext_shared_info decompbuf_info; 752 int ret; 753 struct rte_mbuf *uncomp_bufs[num_bufs]; 754 struct rte_mbuf *comp_bufs[num_bufs]; 755 struct rte_comp_op *ops[num_bufs]; 756 struct rte_comp_op *ops_processed[num_bufs]; 757 void *priv_xforms[num_bufs]; 758 uint16_t num_enqd, num_deqd, num_total_deqd; 759 uint16_t num_priv_xforms = 0; 760 unsigned int deqd_retries = 0; 761 struct priv_op_data *priv_data; 762 char *buf_ptr; 763 unsigned int i; 764 struct rte_mempool *buf_pool; 765 uint32_t data_size; 766 /* Compressing with CompressDev */ 767 unsigned int oos_zlib_decompress = 768 (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS); 769 /* Decompressing with CompressDev */ 770 unsigned int oos_zlib_compress = 771 (zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS); 772 const struct rte_compressdev_capabilities *capa = 773 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 774 char *contig_buf = NULL; 775 uint64_t compress_checksum[num_bufs]; 776 void *stream = NULL; 777 char *all_decomp_data = NULL; 778 unsigned int decomp_produced_data_size = 0; 779 unsigned int step = 0; 780 781 TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS || num_bufs == 1, 782 "Number of stateful operations in a step should be 1"); 783 784 if (capa == NULL) { 785 RTE_LOG(ERR, USER1, 786 "Compress device does not support DEFLATE\n"); 787 return -ENOTSUP; 788 } 789 790 /* Initialize all arrays to NULL */ 791 memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs); 792 memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs); 793 memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs); 794 memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs); 795 memset(priv_xforms, 0, sizeof(void *) * num_bufs); 796 797 if (decompress_state == RTE_COMP_OP_STATEFUL) { 798 data_size = strlen(test_bufs[0]) + 1; 799 all_decomp_data = rte_malloc(NULL, data_size, 800 RTE_CACHE_LINE_SIZE); 801 } 802 803 if (big_data) 804 buf_pool = ts_params->big_mbuf_pool; 805 else if (buff_type == SGL_BOTH) 806 buf_pool = ts_params->small_mbuf_pool; 807 else 808 buf_pool = ts_params->large_mbuf_pool; 809 810 /* Prepare the source mbufs with the data */ 811 ret = rte_pktmbuf_alloc_bulk(buf_pool, 812 uncomp_bufs, num_bufs); 813 if (ret < 0) { 814 RTE_LOG(ERR, USER1, 815 "Source mbufs could not be allocated " 816 "from the mempool\n"); 817 goto exit; 818 } 819 820 if (test_data->use_external_mbufs) { 821 inbuf_info.free_cb = extbuf_free_callback; 822 inbuf_info.fcb_opaque = NULL; 823 rte_mbuf_ext_refcnt_set(&inbuf_info, 1); 824 for (i = 0; i < num_bufs; i++) { 825 rte_pktmbuf_attach_extbuf(uncomp_bufs[i], 826 test_data->inbuf_memzone->addr, 827 test_data->inbuf_memzone->iova, 828 test_data->inbuf_data_size, 829 &inbuf_info); 830 rte_pktmbuf_append(uncomp_bufs[i], 831 test_data->inbuf_data_size); 832 } 833 } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) { 834 for (i = 0; i < num_bufs; i++) { 835 data_size = strlen(test_bufs[i]) + 1; 836 if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i], 837 data_size, 838 big_data ? buf_pool : ts_params->small_mbuf_pool, 839 big_data ? buf_pool : ts_params->large_mbuf_pool, 840 big_data ? 0 : MAX_SEGS, 841 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0) 842 goto exit; 843 } 844 } else { 845 for (i = 0; i < num_bufs; i++) { 846 data_size = strlen(test_bufs[i]) + 1; 847 buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size); 848 strlcpy(buf_ptr, test_bufs[i], data_size); 849 } 850 } 851 852 /* Prepare the destination mbufs */ 853 ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs); 854 if (ret < 0) { 855 RTE_LOG(ERR, USER1, 856 "Destination mbufs could not be allocated " 857 "from the mempool\n"); 858 goto exit; 859 } 860 861 if (test_data->use_external_mbufs) { 862 compbuf_info.free_cb = extbuf_free_callback; 863 compbuf_info.fcb_opaque = NULL; 864 rte_mbuf_ext_refcnt_set(&compbuf_info, 1); 865 for (i = 0; i < num_bufs; i++) { 866 rte_pktmbuf_attach_extbuf(comp_bufs[i], 867 test_data->compbuf_memzone->addr, 868 test_data->compbuf_memzone->iova, 869 test_data->compbuf_memzone->len, 870 &compbuf_info); 871 rte_pktmbuf_append(comp_bufs[i], 872 test_data->compbuf_memzone->len); 873 } 874 } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { 875 for (i = 0; i < num_bufs; i++) { 876 if (out_of_space == 1 && oos_zlib_decompress) 877 data_size = OUT_OF_SPACE_BUF; 878 else 879 (data_size = strlen(test_bufs[i]) * 880 COMPRESS_BUF_SIZE_RATIO); 881 882 if (prepare_sgl_bufs(NULL, comp_bufs[i], 883 data_size, 884 big_data ? buf_pool : ts_params->small_mbuf_pool, 885 big_data ? buf_pool : ts_params->large_mbuf_pool, 886 big_data ? 0 : MAX_SEGS, 887 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) 888 < 0) 889 goto exit; 890 } 891 892 } else { 893 for (i = 0; i < num_bufs; i++) { 894 if (out_of_space == 1 && oos_zlib_decompress) 895 data_size = OUT_OF_SPACE_BUF; 896 else 897 (data_size = strlen(test_bufs[i]) * 898 COMPRESS_BUF_SIZE_RATIO); 899 900 rte_pktmbuf_append(comp_bufs[i], data_size); 901 } 902 } 903 904 /* Build the compression operations */ 905 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs); 906 if (ret < 0) { 907 RTE_LOG(ERR, USER1, 908 "Compress operations could not be allocated " 909 "from the mempool\n"); 910 goto exit; 911 } 912 913 914 for (i = 0; i < num_bufs; i++) { 915 ops[i]->m_src = uncomp_bufs[i]; 916 ops[i]->m_dst = comp_bufs[i]; 917 ops[i]->src.offset = 0; 918 ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]); 919 ops[i]->dst.offset = 0; 920 if (compress_state == RTE_COMP_OP_STATELESS) 921 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; 922 else { 923 RTE_LOG(ERR, USER1, 924 "Stateful operations are not supported " 925 "in these tests yet\n"); 926 goto exit; 927 } 928 ops[i]->input_chksum = 0; 929 /* 930 * Store original operation index in private data, 931 * since ordering does not have to be maintained, 932 * when dequeueing from compressdev, so a comparison 933 * at the end of the test can be done. 934 */ 935 priv_data = (struct priv_op_data *) (ops[i] + 1); 936 priv_data->orig_idx = i; 937 } 938 939 /* Compress data (either with Zlib API or compressdev API */ 940 if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) { 941 for (i = 0; i < num_bufs; i++) { 942 const struct rte_comp_xform *compress_xform = 943 compress_xforms[i % num_xforms]; 944 ret = compress_zlib(ops[i], compress_xform, 945 DEFAULT_MEM_LEVEL); 946 if (ret < 0) 947 goto exit; 948 949 ops_processed[i] = ops[i]; 950 } 951 } else { 952 /* Create compress private xform data */ 953 for (i = 0; i < num_xforms; i++) { 954 ret = rte_compressdev_private_xform_create(0, 955 (const struct rte_comp_xform *)compress_xforms[i], 956 &priv_xforms[i]); 957 if (ret < 0) { 958 RTE_LOG(ERR, USER1, 959 "Compression private xform " 960 "could not be created\n"); 961 goto exit; 962 } 963 num_priv_xforms++; 964 } 965 966 if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) { 967 /* Attach shareable private xform data to ops */ 968 for (i = 0; i < num_bufs; i++) 969 ops[i]->private_xform = priv_xforms[i % num_xforms]; 970 } else { 971 /* Create rest of the private xforms for the other ops */ 972 for (i = num_xforms; i < num_bufs; i++) { 973 ret = rte_compressdev_private_xform_create(0, 974 compress_xforms[i % num_xforms], 975 &priv_xforms[i]); 976 if (ret < 0) { 977 RTE_LOG(ERR, USER1, 978 "Compression private xform " 979 "could not be created\n"); 980 goto exit; 981 } 982 num_priv_xforms++; 983 } 984 985 /* Attach non shareable private xform data to ops */ 986 for (i = 0; i < num_bufs; i++) 987 ops[i]->private_xform = priv_xforms[i]; 988 } 989 990 /* Enqueue and dequeue all operations */ 991 num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs); 992 if (num_enqd < num_bufs) { 993 RTE_LOG(ERR, USER1, 994 "The operations could not be enqueued\n"); 995 goto exit; 996 } 997 998 num_total_deqd = 0; 999 do { 1000 /* 1001 * If retrying a dequeue call, wait for 10 ms to allow 1002 * enough time to the driver to process the operations 1003 */ 1004 if (deqd_retries != 0) { 1005 /* 1006 * Avoid infinite loop if not all the 1007 * operations get out of the device 1008 */ 1009 if (deqd_retries == MAX_DEQD_RETRIES) { 1010 RTE_LOG(ERR, USER1, 1011 "Not all operations could be " 1012 "dequeued\n"); 1013 goto exit; 1014 } 1015 usleep(DEQUEUE_WAIT_TIME); 1016 } 1017 num_deqd = rte_compressdev_dequeue_burst(0, 0, 1018 &ops_processed[num_total_deqd], num_bufs); 1019 num_total_deqd += num_deqd; 1020 deqd_retries++; 1021 1022 } while (num_total_deqd < num_enqd); 1023 1024 deqd_retries = 0; 1025 1026 /* Free compress private xforms */ 1027 for (i = 0; i < num_priv_xforms; i++) { 1028 rte_compressdev_private_xform_free(0, priv_xforms[i]); 1029 priv_xforms[i] = NULL; 1030 } 1031 num_priv_xforms = 0; 1032 } 1033 1034 for (i = 0; i < num_bufs; i++) { 1035 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1036 uint16_t xform_idx = priv_data->orig_idx % num_xforms; 1037 const struct rte_comp_compress_xform *compress_xform = 1038 &compress_xforms[xform_idx]->compress; 1039 enum rte_comp_huffman huffman_type = 1040 compress_xform->deflate.huffman; 1041 char engine[] = "zlib (directly, not PMD)"; 1042 if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL) 1043 strlcpy(engine, "PMD", sizeof(engine)); 1044 1045 RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to" 1046 " %u bytes (level = %d, huffman = %s)\n", 1047 buf_idx[priv_data->orig_idx], engine, 1048 ops_processed[i]->consumed, ops_processed[i]->produced, 1049 compress_xform->level, 1050 huffman_type_strings[huffman_type]); 1051 RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f\n", 1052 ops_processed[i]->consumed == 0 ? 0 : 1053 (float)ops_processed[i]->produced / 1054 ops_processed[i]->consumed * 100); 1055 if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE) 1056 compress_checksum[i] = ops_processed[i]->output_chksum; 1057 ops[i] = NULL; 1058 } 1059 1060 /* 1061 * Check operation status and free source mbufs (destination mbuf and 1062 * compress operation information is needed for the decompression stage) 1063 */ 1064 for (i = 0; i < num_bufs; i++) { 1065 if (out_of_space && oos_zlib_decompress) { 1066 if (ops_processed[i]->status != 1067 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { 1068 ret_status = TEST_FAILED; 1069 RTE_LOG(ERR, USER1, 1070 "Operation without expected out of " 1071 "space status error\n"); 1072 goto exit; 1073 } else 1074 continue; 1075 } 1076 1077 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) { 1078 RTE_LOG(ERR, USER1, 1079 "Some operations were not successful\n"); 1080 goto exit; 1081 } 1082 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1083 rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]); 1084 uncomp_bufs[priv_data->orig_idx] = NULL; 1085 } 1086 1087 if (out_of_space && oos_zlib_decompress) { 1088 ret_status = TEST_SUCCESS; 1089 goto exit; 1090 } 1091 1092 /* Allocate buffers for decompressed data */ 1093 ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs); 1094 if (ret < 0) { 1095 RTE_LOG(ERR, USER1, 1096 "Destination mbufs could not be allocated " 1097 "from the mempool\n"); 1098 goto exit; 1099 } 1100 1101 if (test_data->use_external_mbufs) { 1102 decompbuf_info.free_cb = extbuf_free_callback; 1103 decompbuf_info.fcb_opaque = NULL; 1104 rte_mbuf_ext_refcnt_set(&decompbuf_info, 1); 1105 for (i = 0; i < num_bufs; i++) { 1106 rte_pktmbuf_attach_extbuf(uncomp_bufs[i], 1107 test_data->uncompbuf_memzone->addr, 1108 test_data->uncompbuf_memzone->iova, 1109 test_data->uncompbuf_memzone->len, 1110 &decompbuf_info); 1111 rte_pktmbuf_append(uncomp_bufs[i], 1112 test_data->uncompbuf_memzone->len); 1113 } 1114 } else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) { 1115 for (i = 0; i < num_bufs; i++) { 1116 priv_data = (struct priv_op_data *) 1117 (ops_processed[i] + 1); 1118 if (out_of_space == 1 && oos_zlib_compress) 1119 data_size = OUT_OF_SPACE_BUF; 1120 else if (test_data->decompress_output_block_size != 0) 1121 data_size = 1122 test_data->decompress_output_block_size; 1123 else 1124 data_size = 1125 strlen(test_bufs[priv_data->orig_idx]) + 1; 1126 1127 if (prepare_sgl_bufs(NULL, uncomp_bufs[i], 1128 data_size, 1129 big_data ? buf_pool : ts_params->small_mbuf_pool, 1130 big_data ? buf_pool : ts_params->large_mbuf_pool, 1131 big_data ? 0 : MAX_SEGS, 1132 big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) 1133 < 0) 1134 goto exit; 1135 } 1136 1137 } else { 1138 for (i = 0; i < num_bufs; i++) { 1139 priv_data = (struct priv_op_data *) 1140 (ops_processed[i] + 1); 1141 if (out_of_space == 1 && oos_zlib_compress) 1142 data_size = OUT_OF_SPACE_BUF; 1143 else if (test_data->decompress_output_block_size != 0) 1144 data_size = 1145 test_data->decompress_output_block_size; 1146 else 1147 data_size = 1148 strlen(test_bufs[priv_data->orig_idx]) + 1; 1149 1150 rte_pktmbuf_append(uncomp_bufs[i], data_size); 1151 } 1152 } 1153 1154 /* Build the decompression operations */ 1155 ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs); 1156 if (ret < 0) { 1157 RTE_LOG(ERR, USER1, 1158 "Decompress operations could not be allocated " 1159 "from the mempool\n"); 1160 goto exit; 1161 } 1162 1163 /* Source buffer is the compressed data from the previous operations */ 1164 for (i = 0; i < num_bufs; i++) { 1165 ops[i]->m_src = ops_processed[i]->m_dst; 1166 ops[i]->m_dst = uncomp_bufs[i]; 1167 ops[i]->src.offset = 0; 1168 /* 1169 * Set the length of the compressed data to the 1170 * number of bytes that were produced in the previous stage 1171 */ 1172 ops[i]->src.length = ops_processed[i]->produced; 1173 1174 ops[i]->dst.offset = 0; 1175 if (decompress_state == RTE_COMP_OP_STATELESS) { 1176 ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL; 1177 ops[i]->op_type = RTE_COMP_OP_STATELESS; 1178 } else if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_NONE) { 1179 ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC; 1180 ops[i]->op_type = RTE_COMP_OP_STATEFUL; 1181 } else { 1182 RTE_LOG(ERR, USER1, 1183 "Stateful operations are not supported " 1184 "in these tests yet\n"); 1185 goto exit; 1186 } 1187 ops[i]->input_chksum = 0; 1188 /* 1189 * Copy private data from previous operations, 1190 * to keep the pointer to the original buffer 1191 */ 1192 memcpy(ops[i] + 1, ops_processed[i] + 1, 1193 sizeof(struct priv_op_data)); 1194 } 1195 1196 /* 1197 * Free the previous compress operations, 1198 * as they are not needed anymore 1199 */ 1200 rte_comp_op_bulk_free(ops_processed, num_bufs); 1201 1202 /* Decompress data (either with Zlib API or compressdev API */ 1203 if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) { 1204 for (i = 0; i < num_bufs; i++) { 1205 priv_data = (struct priv_op_data *)(ops[i] + 1); 1206 uint16_t xform_idx = priv_data->orig_idx % num_xforms; 1207 const struct rte_comp_xform *decompress_xform = 1208 decompress_xforms[xform_idx]; 1209 1210 ret = decompress_zlib(ops[i], decompress_xform); 1211 if (ret < 0) 1212 goto exit; 1213 1214 ops_processed[i] = ops[i]; 1215 } 1216 } else { 1217 if (decompress_state == RTE_COMP_OP_STATELESS) { 1218 /* Create decompress private xform data */ 1219 for (i = 0; i < num_xforms; i++) { 1220 ret = rte_compressdev_private_xform_create(0, 1221 (const struct rte_comp_xform *) 1222 decompress_xforms[i], 1223 &priv_xforms[i]); 1224 if (ret < 0) { 1225 RTE_LOG(ERR, USER1, 1226 "Decompression private xform " 1227 "could not be created\n"); 1228 goto exit; 1229 } 1230 num_priv_xforms++; 1231 } 1232 1233 if (capa->comp_feature_flags & 1234 RTE_COMP_FF_SHAREABLE_PRIV_XFORM) { 1235 /* Attach shareable private xform data to ops */ 1236 for (i = 0; i < num_bufs; i++) { 1237 priv_data = (struct priv_op_data *) 1238 (ops[i] + 1); 1239 uint16_t xform_idx = 1240 priv_data->orig_idx % num_xforms; 1241 ops[i]->private_xform = 1242 priv_xforms[xform_idx]; 1243 } 1244 } else { 1245 /* Create rest of the private xforms */ 1246 /* for the other ops */ 1247 for (i = num_xforms; i < num_bufs; i++) { 1248 ret = 1249 rte_compressdev_private_xform_create(0, 1250 decompress_xforms[i % num_xforms], 1251 &priv_xforms[i]); 1252 if (ret < 0) { 1253 RTE_LOG(ERR, USER1, 1254 "Decompression private xform could not be created\n"); 1255 goto exit; 1256 } 1257 num_priv_xforms++; 1258 } 1259 1260 /* Attach non shareable private xform data */ 1261 /* to ops */ 1262 for (i = 0; i < num_bufs; i++) { 1263 priv_data = (struct priv_op_data *) 1264 (ops[i] + 1); 1265 uint16_t xform_idx = 1266 priv_data->orig_idx; 1267 ops[i]->private_xform = 1268 priv_xforms[xform_idx]; 1269 } 1270 } 1271 } else { 1272 /* Create a stream object for stateful decompression */ 1273 ret = rte_compressdev_stream_create(0, 1274 decompress_xforms[0], &stream); 1275 if (ret < 0) { 1276 RTE_LOG(ERR, USER1, 1277 "Decompression stream could not be created, error %d\n", 1278 ret); 1279 goto exit; 1280 } 1281 /* Attach stream to ops */ 1282 for (i = 0; i < num_bufs; i++) 1283 ops[i]->stream = stream; 1284 } 1285 1286 next_step: 1287 /* Enqueue and dequeue all operations */ 1288 num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs); 1289 if (num_enqd < num_bufs) { 1290 RTE_LOG(ERR, USER1, 1291 "The operations could not be enqueued\n"); 1292 goto exit; 1293 } 1294 1295 num_total_deqd = 0; 1296 do { 1297 /* 1298 * If retrying a dequeue call, wait for 10 ms to allow 1299 * enough time to the driver to process the operations 1300 */ 1301 if (deqd_retries != 0) { 1302 /* 1303 * Avoid infinite loop if not all the 1304 * operations get out of the device 1305 */ 1306 if (deqd_retries == MAX_DEQD_RETRIES) { 1307 RTE_LOG(ERR, USER1, 1308 "Not all operations could be " 1309 "dequeued\n"); 1310 goto exit; 1311 } 1312 usleep(DEQUEUE_WAIT_TIME); 1313 } 1314 num_deqd = rte_compressdev_dequeue_burst(0, 0, 1315 &ops_processed[num_total_deqd], num_bufs); 1316 num_total_deqd += num_deqd; 1317 deqd_retries++; 1318 } while (num_total_deqd < num_enqd); 1319 1320 deqd_retries = 0; 1321 } 1322 1323 for (i = 0; i < num_bufs; i++) { 1324 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1325 char engine[] = "zlib, (directly, no PMD)"; 1326 if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL) 1327 strlcpy(engine, "pmd", sizeof(engine)); 1328 RTE_LOG(DEBUG, USER1, 1329 "Buffer %u decompressed by %s from %u to %u bytes\n", 1330 buf_idx[priv_data->orig_idx], engine, 1331 ops_processed[i]->consumed, ops_processed[i]->produced); 1332 ops[i] = NULL; 1333 } 1334 1335 /* 1336 * Check operation status and free source mbuf (destination mbuf and 1337 * compress operation information is still needed) 1338 */ 1339 for (i = 0; i < num_bufs; i++) { 1340 if (out_of_space && oos_zlib_compress) { 1341 if (ops_processed[i]->status != 1342 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) { 1343 ret_status = TEST_FAILED; 1344 RTE_LOG(ERR, USER1, 1345 "Operation without expected out of " 1346 "space status error\n"); 1347 goto exit; 1348 } else 1349 continue; 1350 } 1351 1352 if (decompress_state == RTE_COMP_OP_STATEFUL 1353 && (ops_processed[i]->status == 1354 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE 1355 || ops_processed[i]->status == 1356 RTE_COMP_OP_STATUS_SUCCESS)) { 1357 /* collect the output into all_decomp_data */ 1358 const void *ptr = rte_pktmbuf_read( 1359 ops_processed[i]->m_dst, 1360 ops_processed[i]->dst.offset, 1361 ops_processed[i]->produced, 1362 all_decomp_data + 1363 decomp_produced_data_size); 1364 if (ptr != all_decomp_data + decomp_produced_data_size) 1365 rte_memcpy(all_decomp_data + 1366 decomp_produced_data_size, 1367 ptr, ops_processed[i]->produced); 1368 decomp_produced_data_size += ops_processed[i]->produced; 1369 if (ops_processed[i]->src.length > 1370 ops_processed[i]->consumed) { 1371 if (ops_processed[i]->status == 1372 RTE_COMP_OP_STATUS_SUCCESS) { 1373 ret_status = -1; 1374 RTE_LOG(ERR, USER1, 1375 "Operation finished too early\n"); 1376 goto exit; 1377 } 1378 step++; 1379 if (step >= test_data->decompress_steps_max) { 1380 ret_status = -1; 1381 RTE_LOG(ERR, USER1, 1382 "Operation exceeded maximum steps\n"); 1383 goto exit; 1384 } 1385 ops[i] = ops_processed[i]; 1386 ops[i]->status = 1387 RTE_COMP_OP_STATUS_NOT_PROCESSED; 1388 ops[i]->src.offset += 1389 ops_processed[i]->consumed; 1390 ops[i]->src.length -= 1391 ops_processed[i]->consumed; 1392 goto next_step; 1393 } else { 1394 /* Compare the original stream with the */ 1395 /* decompressed stream (in size and the data) */ 1396 priv_data = (struct priv_op_data *) 1397 (ops_processed[i] + 1); 1398 const char *buf1 = 1399 test_bufs[priv_data->orig_idx]; 1400 const char *buf2 = all_decomp_data; 1401 1402 if (compare_buffers(buf1, strlen(buf1) + 1, 1403 buf2, decomp_produced_data_size) < 0) 1404 goto exit; 1405 /* Test checksums */ 1406 if (compress_xforms[0]->compress.chksum 1407 != RTE_COMP_CHECKSUM_NONE) { 1408 if (ops_processed[i]->output_chksum 1409 != compress_checksum[i]) { 1410 RTE_LOG(ERR, USER1, 1411 "The checksums differ\n" 1412 "Compression Checksum: %" PRIu64 "\tDecompression " 1413 "Checksum: %" PRIu64 "\n", compress_checksum[i], 1414 ops_processed[i]->output_chksum); 1415 goto exit; 1416 } 1417 } 1418 } 1419 } else if (ops_processed[i]->status != 1420 RTE_COMP_OP_STATUS_SUCCESS) { 1421 RTE_LOG(ERR, USER1, 1422 "Some operations were not successful\n"); 1423 goto exit; 1424 } 1425 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1426 rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]); 1427 comp_bufs[priv_data->orig_idx] = NULL; 1428 } 1429 1430 if ((out_of_space && oos_zlib_compress) 1431 || (decompress_state == RTE_COMP_OP_STATEFUL)) { 1432 ret_status = TEST_SUCCESS; 1433 goto exit; 1434 } 1435 1436 /* 1437 * Compare the original stream with the decompressed stream 1438 * (in size and the data) 1439 */ 1440 for (i = 0; i < num_bufs; i++) { 1441 priv_data = (struct priv_op_data *)(ops_processed[i] + 1); 1442 const char *buf1 = test_data->use_external_mbufs ? 1443 test_data->inbuf_memzone->addr : 1444 test_bufs[priv_data->orig_idx]; 1445 const char *buf2; 1446 data_size = test_data->use_external_mbufs ? 1447 test_data->inbuf_data_size : 1448 strlen(buf1) + 1; 1449 contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0); 1450 if (contig_buf == NULL) { 1451 RTE_LOG(ERR, USER1, "Contiguous buffer could not " 1452 "be allocated\n"); 1453 goto exit; 1454 } 1455 1456 buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0, 1457 ops_processed[i]->produced, contig_buf); 1458 if (compare_buffers(buf1, data_size, 1459 buf2, ops_processed[i]->produced) < 0) 1460 goto exit; 1461 1462 /* Test checksums */ 1463 if (compress_xforms[0]->compress.chksum != 1464 RTE_COMP_CHECKSUM_NONE) { 1465 if (ops_processed[i]->output_chksum != 1466 compress_checksum[i]) { 1467 RTE_LOG(ERR, USER1, "The checksums differ\n" 1468 "Compression Checksum: %" PRIu64 "\tDecompression " 1469 "Checksum: %" PRIu64 "\n", compress_checksum[i], 1470 ops_processed[i]->output_chksum); 1471 goto exit; 1472 } 1473 } 1474 1475 rte_free(contig_buf); 1476 contig_buf = NULL; 1477 } 1478 1479 ret_status = TEST_SUCCESS; 1480 1481 exit: 1482 /* Free resources */ 1483 for (i = 0; i < num_bufs; i++) { 1484 rte_pktmbuf_free(uncomp_bufs[i]); 1485 rte_pktmbuf_free(comp_bufs[i]); 1486 rte_comp_op_free(ops[i]); 1487 rte_comp_op_free(ops_processed[i]); 1488 } 1489 for (i = 0; i < num_priv_xforms; i++) 1490 if (priv_xforms[i] != NULL) 1491 rte_compressdev_private_xform_free(0, priv_xforms[i]); 1492 if (stream != NULL) 1493 rte_compressdev_stream_free(0, stream); 1494 if (all_decomp_data != NULL) 1495 rte_free(all_decomp_data); 1496 rte_free(contig_buf); 1497 1498 return ret_status; 1499 } 1500 1501 static int 1502 test_compressdev_deflate_stateless_fixed(void) 1503 { 1504 struct comp_testsuite_params *ts_params = &testsuite_params; 1505 uint16_t i; 1506 int ret; 1507 const struct rte_compressdev_capabilities *capab; 1508 1509 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1510 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1511 1512 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) 1513 return -ENOTSUP; 1514 1515 struct rte_comp_xform *compress_xform = 1516 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1517 1518 if (compress_xform == NULL) { 1519 RTE_LOG(ERR, USER1, 1520 "Compress xform could not be created\n"); 1521 ret = TEST_FAILED; 1522 goto exit; 1523 } 1524 1525 memcpy(compress_xform, ts_params->def_comp_xform, 1526 sizeof(struct rte_comp_xform)); 1527 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED; 1528 1529 struct interim_data_params int_data = { 1530 NULL, 1531 1, 1532 NULL, 1533 &compress_xform, 1534 &ts_params->def_decomp_xform, 1535 1 1536 }; 1537 1538 struct test_data_params test_data = { 1539 .compress_state = RTE_COMP_OP_STATELESS, 1540 .decompress_state = RTE_COMP_OP_STATELESS, 1541 .buff_type = LB_BOTH, 1542 .zlib_dir = ZLIB_DECOMPRESS, 1543 .out_of_space = 0, 1544 .big_data = 0 1545 }; 1546 1547 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1548 int_data.test_bufs = &compress_test_bufs[i]; 1549 int_data.buf_idx = &i; 1550 1551 /* Compress with compressdev, decompress with Zlib */ 1552 test_data.zlib_dir = ZLIB_DECOMPRESS; 1553 ret = test_deflate_comp_decomp(&int_data, &test_data); 1554 if (ret < 0) 1555 goto exit; 1556 1557 /* Compress with Zlib, decompress with compressdev */ 1558 test_data.zlib_dir = ZLIB_COMPRESS; 1559 ret = test_deflate_comp_decomp(&int_data, &test_data); 1560 if (ret < 0) 1561 goto exit; 1562 } 1563 1564 ret = TEST_SUCCESS; 1565 1566 exit: 1567 rte_free(compress_xform); 1568 return ret; 1569 } 1570 1571 static int 1572 test_compressdev_deflate_stateless_dynamic(void) 1573 { 1574 struct comp_testsuite_params *ts_params = &testsuite_params; 1575 uint16_t i; 1576 int ret; 1577 struct rte_comp_xform *compress_xform = 1578 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1579 1580 const struct rte_compressdev_capabilities *capab; 1581 1582 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1583 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1584 1585 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) 1586 return -ENOTSUP; 1587 1588 if (compress_xform == NULL) { 1589 RTE_LOG(ERR, USER1, 1590 "Compress xform could not be created\n"); 1591 ret = TEST_FAILED; 1592 goto exit; 1593 } 1594 1595 memcpy(compress_xform, ts_params->def_comp_xform, 1596 sizeof(struct rte_comp_xform)); 1597 compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC; 1598 1599 struct interim_data_params int_data = { 1600 NULL, 1601 1, 1602 NULL, 1603 &compress_xform, 1604 &ts_params->def_decomp_xform, 1605 1 1606 }; 1607 1608 struct test_data_params test_data = { 1609 .compress_state = RTE_COMP_OP_STATELESS, 1610 .decompress_state = RTE_COMP_OP_STATELESS, 1611 .buff_type = LB_BOTH, 1612 .zlib_dir = ZLIB_DECOMPRESS, 1613 .out_of_space = 0, 1614 .big_data = 0 1615 }; 1616 1617 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1618 int_data.test_bufs = &compress_test_bufs[i]; 1619 int_data.buf_idx = &i; 1620 1621 /* Compress with compressdev, decompress with Zlib */ 1622 test_data.zlib_dir = ZLIB_DECOMPRESS; 1623 ret = test_deflate_comp_decomp(&int_data, &test_data); 1624 if (ret < 0) 1625 goto exit; 1626 1627 /* Compress with Zlib, decompress with compressdev */ 1628 test_data.zlib_dir = ZLIB_COMPRESS; 1629 ret = test_deflate_comp_decomp(&int_data, &test_data); 1630 if (ret < 0) 1631 goto exit; 1632 } 1633 1634 ret = TEST_SUCCESS; 1635 1636 exit: 1637 rte_free(compress_xform); 1638 return ret; 1639 } 1640 1641 static int 1642 test_compressdev_deflate_stateless_multi_op(void) 1643 { 1644 struct comp_testsuite_params *ts_params = &testsuite_params; 1645 uint16_t num_bufs = RTE_DIM(compress_test_bufs); 1646 uint16_t buf_idx[num_bufs]; 1647 uint16_t i; 1648 int ret; 1649 1650 for (i = 0; i < num_bufs; i++) 1651 buf_idx[i] = i; 1652 1653 struct interim_data_params int_data = { 1654 compress_test_bufs, 1655 num_bufs, 1656 buf_idx, 1657 &ts_params->def_comp_xform, 1658 &ts_params->def_decomp_xform, 1659 1 1660 }; 1661 1662 struct test_data_params test_data = { 1663 .compress_state = RTE_COMP_OP_STATELESS, 1664 .decompress_state = RTE_COMP_OP_STATELESS, 1665 .buff_type = LB_BOTH, 1666 .zlib_dir = ZLIB_DECOMPRESS, 1667 .out_of_space = 0, 1668 .big_data = 0 1669 }; 1670 1671 /* Compress with compressdev, decompress with Zlib */ 1672 test_data.zlib_dir = ZLIB_DECOMPRESS; 1673 ret = test_deflate_comp_decomp(&int_data, &test_data); 1674 if (ret < 0) 1675 return ret; 1676 1677 /* Compress with Zlib, decompress with compressdev */ 1678 test_data.zlib_dir = ZLIB_COMPRESS; 1679 ret = test_deflate_comp_decomp(&int_data, &test_data); 1680 if (ret < 0) 1681 return ret; 1682 1683 return TEST_SUCCESS; 1684 } 1685 1686 static int 1687 test_compressdev_deflate_stateless_multi_level(void) 1688 { 1689 struct comp_testsuite_params *ts_params = &testsuite_params; 1690 unsigned int level; 1691 uint16_t i; 1692 int ret; 1693 struct rte_comp_xform *compress_xform = 1694 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1695 1696 if (compress_xform == NULL) { 1697 RTE_LOG(ERR, USER1, 1698 "Compress xform could not be created\n"); 1699 ret = TEST_FAILED; 1700 goto exit; 1701 } 1702 1703 memcpy(compress_xform, ts_params->def_comp_xform, 1704 sizeof(struct rte_comp_xform)); 1705 1706 struct interim_data_params int_data = { 1707 NULL, 1708 1, 1709 NULL, 1710 &compress_xform, 1711 &ts_params->def_decomp_xform, 1712 1 1713 }; 1714 1715 struct test_data_params test_data = { 1716 .compress_state = RTE_COMP_OP_STATELESS, 1717 .decompress_state = RTE_COMP_OP_STATELESS, 1718 .buff_type = LB_BOTH, 1719 .zlib_dir = ZLIB_DECOMPRESS, 1720 .out_of_space = 0, 1721 .big_data = 0 1722 }; 1723 1724 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1725 int_data.test_bufs = &compress_test_bufs[i]; 1726 int_data.buf_idx = &i; 1727 1728 for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX; 1729 level++) { 1730 compress_xform->compress.level = level; 1731 /* Compress with compressdev, decompress with Zlib */ 1732 test_data.zlib_dir = ZLIB_DECOMPRESS; 1733 ret = test_deflate_comp_decomp(&int_data, &test_data); 1734 if (ret < 0) 1735 goto exit; 1736 } 1737 } 1738 1739 ret = TEST_SUCCESS; 1740 1741 exit: 1742 rte_free(compress_xform); 1743 return ret; 1744 } 1745 1746 #define NUM_XFORMS 3 1747 static int 1748 test_compressdev_deflate_stateless_multi_xform(void) 1749 { 1750 struct comp_testsuite_params *ts_params = &testsuite_params; 1751 uint16_t num_bufs = NUM_XFORMS; 1752 struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL}; 1753 struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL}; 1754 const char *test_buffers[NUM_XFORMS]; 1755 uint16_t i; 1756 unsigned int level = RTE_COMP_LEVEL_MIN; 1757 uint16_t buf_idx[num_bufs]; 1758 int ret; 1759 1760 /* Create multiple xforms with various levels */ 1761 for (i = 0; i < NUM_XFORMS; i++) { 1762 compress_xforms[i] = rte_malloc(NULL, 1763 sizeof(struct rte_comp_xform), 0); 1764 if (compress_xforms[i] == NULL) { 1765 RTE_LOG(ERR, USER1, 1766 "Compress xform could not be created\n"); 1767 ret = TEST_FAILED; 1768 goto exit; 1769 } 1770 1771 memcpy(compress_xforms[i], ts_params->def_comp_xform, 1772 sizeof(struct rte_comp_xform)); 1773 compress_xforms[i]->compress.level = level; 1774 level++; 1775 1776 decompress_xforms[i] = rte_malloc(NULL, 1777 sizeof(struct rte_comp_xform), 0); 1778 if (decompress_xforms[i] == NULL) { 1779 RTE_LOG(ERR, USER1, 1780 "Decompress xform could not be created\n"); 1781 ret = TEST_FAILED; 1782 goto exit; 1783 } 1784 1785 memcpy(decompress_xforms[i], ts_params->def_decomp_xform, 1786 sizeof(struct rte_comp_xform)); 1787 } 1788 1789 for (i = 0; i < NUM_XFORMS; i++) { 1790 buf_idx[i] = 0; 1791 /* Use the same buffer in all sessions */ 1792 test_buffers[i] = compress_test_bufs[0]; 1793 } 1794 1795 struct interim_data_params int_data = { 1796 test_buffers, 1797 num_bufs, 1798 buf_idx, 1799 compress_xforms, 1800 decompress_xforms, 1801 NUM_XFORMS 1802 }; 1803 1804 struct test_data_params test_data = { 1805 .compress_state = RTE_COMP_OP_STATELESS, 1806 .decompress_state = RTE_COMP_OP_STATELESS, 1807 .buff_type = LB_BOTH, 1808 .zlib_dir = ZLIB_DECOMPRESS, 1809 .out_of_space = 0, 1810 .big_data = 0 1811 }; 1812 1813 /* Compress with compressdev, decompress with Zlib */ 1814 ret = test_deflate_comp_decomp(&int_data, &test_data); 1815 if (ret < 0) 1816 goto exit; 1817 1818 ret = TEST_SUCCESS; 1819 1820 exit: 1821 for (i = 0; i < NUM_XFORMS; i++) { 1822 rte_free(compress_xforms[i]); 1823 rte_free(decompress_xforms[i]); 1824 } 1825 1826 return ret; 1827 } 1828 1829 static int 1830 test_compressdev_deflate_stateless_sgl(void) 1831 { 1832 struct comp_testsuite_params *ts_params = &testsuite_params; 1833 uint16_t i; 1834 int ret; 1835 const struct rte_compressdev_capabilities *capab; 1836 1837 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1838 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1839 1840 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) 1841 return -ENOTSUP; 1842 1843 struct interim_data_params int_data = { 1844 NULL, 1845 1, 1846 NULL, 1847 &ts_params->def_comp_xform, 1848 &ts_params->def_decomp_xform, 1849 1 1850 }; 1851 1852 struct test_data_params test_data = { 1853 .compress_state = RTE_COMP_OP_STATELESS, 1854 .decompress_state = RTE_COMP_OP_STATELESS, 1855 .buff_type = SGL_BOTH, 1856 .zlib_dir = ZLIB_DECOMPRESS, 1857 .out_of_space = 0, 1858 .big_data = 0 1859 }; 1860 1861 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1862 int_data.test_bufs = &compress_test_bufs[i]; 1863 int_data.buf_idx = &i; 1864 1865 /* Compress with compressdev, decompress with Zlib */ 1866 test_data.zlib_dir = ZLIB_DECOMPRESS; 1867 ret = test_deflate_comp_decomp(&int_data, &test_data); 1868 if (ret < 0) 1869 return ret; 1870 1871 /* Compress with Zlib, decompress with compressdev */ 1872 test_data.zlib_dir = ZLIB_COMPRESS; 1873 ret = test_deflate_comp_decomp(&int_data, &test_data); 1874 if (ret < 0) 1875 return ret; 1876 1877 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) { 1878 /* Compress with compressdev, decompress with Zlib */ 1879 test_data.zlib_dir = ZLIB_DECOMPRESS; 1880 test_data.buff_type = SGL_TO_LB; 1881 ret = test_deflate_comp_decomp(&int_data, &test_data); 1882 if (ret < 0) 1883 return ret; 1884 1885 /* Compress with Zlib, decompress with compressdev */ 1886 test_data.zlib_dir = ZLIB_COMPRESS; 1887 test_data.buff_type = SGL_TO_LB; 1888 ret = test_deflate_comp_decomp(&int_data, &test_data); 1889 if (ret < 0) 1890 return ret; 1891 } 1892 1893 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) { 1894 /* Compress with compressdev, decompress with Zlib */ 1895 test_data.zlib_dir = ZLIB_DECOMPRESS; 1896 test_data.buff_type = LB_TO_SGL; 1897 ret = test_deflate_comp_decomp(&int_data, &test_data); 1898 if (ret < 0) 1899 return ret; 1900 1901 /* Compress with Zlib, decompress with compressdev */ 1902 test_data.zlib_dir = ZLIB_COMPRESS; 1903 test_data.buff_type = LB_TO_SGL; 1904 ret = test_deflate_comp_decomp(&int_data, &test_data); 1905 if (ret < 0) 1906 return ret; 1907 } 1908 } 1909 1910 return TEST_SUCCESS; 1911 } 1912 1913 static int 1914 test_compressdev_deflate_stateless_checksum(void) 1915 { 1916 struct comp_testsuite_params *ts_params = &testsuite_params; 1917 uint16_t i; 1918 int ret; 1919 const struct rte_compressdev_capabilities *capab; 1920 1921 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 1922 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 1923 1924 /* Check if driver supports any checksum */ 1925 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 && 1926 (capab->comp_feature_flags & 1927 RTE_COMP_FF_ADLER32_CHECKSUM) == 0 && 1928 (capab->comp_feature_flags & 1929 RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 0) 1930 return -ENOTSUP; 1931 1932 struct rte_comp_xform *compress_xform = 1933 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1934 if (compress_xform == NULL) { 1935 RTE_LOG(ERR, USER1, "Compress xform could not be created\n"); 1936 return TEST_FAILED; 1937 } 1938 1939 memcpy(compress_xform, ts_params->def_comp_xform, 1940 sizeof(struct rte_comp_xform)); 1941 1942 struct rte_comp_xform *decompress_xform = 1943 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 1944 if (decompress_xform == NULL) { 1945 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n"); 1946 rte_free(compress_xform); 1947 return TEST_FAILED; 1948 } 1949 1950 memcpy(decompress_xform, ts_params->def_decomp_xform, 1951 sizeof(struct rte_comp_xform)); 1952 1953 struct interim_data_params int_data = { 1954 NULL, 1955 1, 1956 NULL, 1957 &compress_xform, 1958 &decompress_xform, 1959 1 1960 }; 1961 1962 struct test_data_params test_data = { 1963 .compress_state = RTE_COMP_OP_STATELESS, 1964 .decompress_state = RTE_COMP_OP_STATELESS, 1965 .buff_type = LB_BOTH, 1966 .zlib_dir = ZLIB_DECOMPRESS, 1967 .out_of_space = 0, 1968 .big_data = 0 1969 }; 1970 1971 /* Check if driver supports crc32 checksum and test */ 1972 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) { 1973 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32; 1974 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32; 1975 1976 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 1977 /* Compress with compressdev, decompress with Zlib */ 1978 int_data.test_bufs = &compress_test_bufs[i]; 1979 int_data.buf_idx = &i; 1980 1981 /* Generate zlib checksum and test against selected 1982 * drivers decompression checksum 1983 */ 1984 test_data.zlib_dir = ZLIB_COMPRESS; 1985 ret = test_deflate_comp_decomp(&int_data, &test_data); 1986 if (ret < 0) 1987 goto exit; 1988 1989 /* Generate compression and decompression 1990 * checksum of selected driver 1991 */ 1992 test_data.zlib_dir = ZLIB_NONE; 1993 ret = test_deflate_comp_decomp(&int_data, &test_data); 1994 if (ret < 0) 1995 goto exit; 1996 } 1997 } 1998 1999 /* Check if driver supports adler32 checksum and test */ 2000 if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) { 2001 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32; 2002 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32; 2003 2004 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 2005 int_data.test_bufs = &compress_test_bufs[i]; 2006 int_data.buf_idx = &i; 2007 2008 /* Generate zlib checksum and test against selected 2009 * drivers decompression checksum 2010 */ 2011 test_data.zlib_dir = ZLIB_COMPRESS; 2012 ret = test_deflate_comp_decomp(&int_data, &test_data); 2013 if (ret < 0) 2014 goto exit; 2015 /* Generate compression and decompression 2016 * checksum of selected driver 2017 */ 2018 test_data.zlib_dir = ZLIB_NONE; 2019 ret = test_deflate_comp_decomp(&int_data, &test_data); 2020 if (ret < 0) 2021 goto exit; 2022 } 2023 } 2024 2025 /* Check if driver supports combined crc and adler checksum and test */ 2026 if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) { 2027 compress_xform->compress.chksum = 2028 RTE_COMP_CHECKSUM_CRC32_ADLER32; 2029 decompress_xform->decompress.chksum = 2030 RTE_COMP_CHECKSUM_CRC32_ADLER32; 2031 2032 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 2033 int_data.test_bufs = &compress_test_bufs[i]; 2034 int_data.buf_idx = &i; 2035 2036 /* Generate compression and decompression 2037 * checksum of selected driver 2038 */ 2039 test_data.zlib_dir = ZLIB_NONE; 2040 ret = test_deflate_comp_decomp(&int_data, &test_data); 2041 if (ret < 0) 2042 goto exit; 2043 } 2044 } 2045 2046 ret = TEST_SUCCESS; 2047 2048 exit: 2049 rte_free(compress_xform); 2050 rte_free(decompress_xform); 2051 return ret; 2052 } 2053 2054 static int 2055 test_compressdev_out_of_space_buffer(void) 2056 { 2057 struct comp_testsuite_params *ts_params = &testsuite_params; 2058 int ret; 2059 uint16_t i; 2060 const struct rte_compressdev_capabilities *capab; 2061 2062 RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n"); 2063 2064 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 2065 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 2066 2067 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0) 2068 return -ENOTSUP; 2069 2070 struct interim_data_params int_data = { 2071 &compress_test_bufs[0], 2072 1, 2073 &i, 2074 &ts_params->def_comp_xform, 2075 &ts_params->def_decomp_xform, 2076 1 2077 }; 2078 2079 struct test_data_params test_data = { 2080 .compress_state = RTE_COMP_OP_STATELESS, 2081 .decompress_state = RTE_COMP_OP_STATELESS, 2082 .buff_type = LB_BOTH, 2083 .zlib_dir = ZLIB_DECOMPRESS, 2084 .out_of_space = 1, /* run out-of-space test */ 2085 .big_data = 0 2086 }; 2087 /* Compress with compressdev, decompress with Zlib */ 2088 test_data.zlib_dir = ZLIB_DECOMPRESS; 2089 ret = test_deflate_comp_decomp(&int_data, &test_data); 2090 if (ret < 0) 2091 goto exit; 2092 2093 /* Compress with Zlib, decompress with compressdev */ 2094 test_data.zlib_dir = ZLIB_COMPRESS; 2095 ret = test_deflate_comp_decomp(&int_data, &test_data); 2096 if (ret < 0) 2097 goto exit; 2098 2099 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 2100 /* Compress with compressdev, decompress with Zlib */ 2101 test_data.zlib_dir = ZLIB_DECOMPRESS; 2102 test_data.buff_type = SGL_BOTH; 2103 ret = test_deflate_comp_decomp(&int_data, &test_data); 2104 if (ret < 0) 2105 goto exit; 2106 2107 /* Compress with Zlib, decompress with compressdev */ 2108 test_data.zlib_dir = ZLIB_COMPRESS; 2109 test_data.buff_type = SGL_BOTH; 2110 ret = test_deflate_comp_decomp(&int_data, &test_data); 2111 if (ret < 0) 2112 goto exit; 2113 } 2114 2115 ret = TEST_SUCCESS; 2116 2117 exit: 2118 return ret; 2119 } 2120 2121 static int 2122 test_compressdev_deflate_stateless_dynamic_big(void) 2123 { 2124 struct comp_testsuite_params *ts_params = &testsuite_params; 2125 uint16_t i = 0; 2126 int ret; 2127 int j; 2128 const struct rte_compressdev_capabilities *capab; 2129 char *test_buffer = NULL; 2130 2131 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 2132 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 2133 2134 if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0) 2135 return -ENOTSUP; 2136 2137 if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0) 2138 return -ENOTSUP; 2139 2140 test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0); 2141 if (test_buffer == NULL) { 2142 RTE_LOG(ERR, USER1, 2143 "Can't allocate buffer for big-data\n"); 2144 return TEST_FAILED; 2145 } 2146 2147 struct interim_data_params int_data = { 2148 (const char * const *)&test_buffer, 2149 1, 2150 &i, 2151 &ts_params->def_comp_xform, 2152 &ts_params->def_decomp_xform, 2153 1 2154 }; 2155 2156 struct test_data_params test_data = { 2157 .compress_state = RTE_COMP_OP_STATELESS, 2158 .decompress_state = RTE_COMP_OP_STATELESS, 2159 .buff_type = SGL_BOTH, 2160 .zlib_dir = ZLIB_DECOMPRESS, 2161 .out_of_space = 0, 2162 .big_data = 1 2163 }; 2164 2165 ts_params->def_comp_xform->compress.deflate.huffman = 2166 RTE_COMP_HUFFMAN_DYNAMIC; 2167 2168 /* fill the buffer with data based on rand. data */ 2169 srand(BIG_DATA_TEST_SIZE); 2170 for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j) 2171 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1; 2172 test_buffer[BIG_DATA_TEST_SIZE-1] = 0; 2173 2174 /* Compress with compressdev, decompress with Zlib */ 2175 test_data.zlib_dir = ZLIB_DECOMPRESS; 2176 ret = test_deflate_comp_decomp(&int_data, &test_data); 2177 if (ret < 0) 2178 goto exit; 2179 2180 /* Compress with Zlib, decompress with compressdev */ 2181 test_data.zlib_dir = ZLIB_COMPRESS; 2182 ret = test_deflate_comp_decomp(&int_data, &test_data); 2183 if (ret < 0) 2184 goto exit; 2185 2186 ret = TEST_SUCCESS; 2187 2188 exit: 2189 ts_params->def_comp_xform->compress.deflate.huffman = 2190 RTE_COMP_HUFFMAN_DEFAULT; 2191 rte_free(test_buffer); 2192 return ret; 2193 } 2194 2195 static int 2196 test_compressdev_deflate_stateful_decomp(void) 2197 { 2198 struct comp_testsuite_params *ts_params = &testsuite_params; 2199 int ret; 2200 uint16_t i; 2201 const struct rte_compressdev_capabilities *capab; 2202 2203 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 2204 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 2205 2206 if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION)) 2207 return -ENOTSUP; 2208 2209 struct interim_data_params int_data = { 2210 &compress_test_bufs[0], 2211 1, 2212 &i, 2213 &ts_params->def_comp_xform, 2214 &ts_params->def_decomp_xform, 2215 1 2216 }; 2217 2218 struct test_data_params test_data = { 2219 .compress_state = RTE_COMP_OP_STATELESS, 2220 .decompress_state = RTE_COMP_OP_STATEFUL, 2221 .buff_type = LB_BOTH, 2222 .zlib_dir = ZLIB_COMPRESS, 2223 .out_of_space = 0, 2224 .big_data = 0, 2225 .decompress_output_block_size = 2000, 2226 .decompress_steps_max = 4 2227 }; 2228 2229 /* Compress with Zlib, decompress with compressdev */ 2230 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2231 ret = TEST_FAILED; 2232 goto exit; 2233 } 2234 2235 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 2236 /* Now test with SGL buffers */ 2237 test_data.buff_type = SGL_BOTH; 2238 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2239 ret = TEST_FAILED; 2240 goto exit; 2241 } 2242 } 2243 2244 ret = TEST_SUCCESS; 2245 2246 exit: 2247 return ret; 2248 } 2249 2250 static int 2251 test_compressdev_deflate_stateful_decomp_checksum(void) 2252 { 2253 struct comp_testsuite_params *ts_params = &testsuite_params; 2254 int ret; 2255 uint16_t i; 2256 const struct rte_compressdev_capabilities *capab; 2257 2258 capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE); 2259 TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities"); 2260 2261 if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION)) 2262 return -ENOTSUP; 2263 2264 /* Check if driver supports any checksum */ 2265 if (!(capab->comp_feature_flags & 2266 (RTE_COMP_FF_CRC32_CHECKSUM | RTE_COMP_FF_ADLER32_CHECKSUM | 2267 RTE_COMP_FF_CRC32_ADLER32_CHECKSUM))) 2268 return -ENOTSUP; 2269 2270 struct rte_comp_xform *compress_xform = 2271 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 2272 if (compress_xform == NULL) { 2273 RTE_LOG(ERR, USER1, "Compress xform could not be created\n"); 2274 return TEST_FAILED; 2275 } 2276 2277 memcpy(compress_xform, ts_params->def_comp_xform, 2278 sizeof(struct rte_comp_xform)); 2279 2280 struct rte_comp_xform *decompress_xform = 2281 rte_malloc(NULL, sizeof(struct rte_comp_xform), 0); 2282 if (decompress_xform == NULL) { 2283 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n"); 2284 rte_free(compress_xform); 2285 return TEST_FAILED; 2286 } 2287 2288 memcpy(decompress_xform, ts_params->def_decomp_xform, 2289 sizeof(struct rte_comp_xform)); 2290 2291 struct interim_data_params int_data = { 2292 &compress_test_bufs[0], 2293 1, 2294 &i, 2295 &compress_xform, 2296 &decompress_xform, 2297 1 2298 }; 2299 2300 struct test_data_params test_data = { 2301 .compress_state = RTE_COMP_OP_STATELESS, 2302 .decompress_state = RTE_COMP_OP_STATEFUL, 2303 .buff_type = LB_BOTH, 2304 .zlib_dir = ZLIB_COMPRESS, 2305 .out_of_space = 0, 2306 .big_data = 0, 2307 .decompress_output_block_size = 2000, 2308 .decompress_steps_max = 4 2309 }; 2310 2311 /* Check if driver supports crc32 checksum and test */ 2312 if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) { 2313 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32; 2314 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32; 2315 /* Compress with Zlib, decompress with compressdev */ 2316 test_data.buff_type = LB_BOTH; 2317 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2318 ret = TEST_FAILED; 2319 goto exit; 2320 } 2321 if (capab->comp_feature_flags & 2322 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 2323 /* Now test with SGL buffers */ 2324 test_data.buff_type = SGL_BOTH; 2325 if (test_deflate_comp_decomp(&int_data, 2326 &test_data) < 0) { 2327 ret = TEST_FAILED; 2328 goto exit; 2329 } 2330 } 2331 } 2332 2333 /* Check if driver supports adler32 checksum and test */ 2334 if (capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM) { 2335 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32; 2336 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32; 2337 /* Compress with Zlib, decompress with compressdev */ 2338 test_data.buff_type = LB_BOTH; 2339 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2340 ret = TEST_FAILED; 2341 goto exit; 2342 } 2343 if (capab->comp_feature_flags & 2344 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 2345 /* Now test with SGL buffers */ 2346 test_data.buff_type = SGL_BOTH; 2347 if (test_deflate_comp_decomp(&int_data, 2348 &test_data) < 0) { 2349 ret = TEST_FAILED; 2350 goto exit; 2351 } 2352 } 2353 } 2354 2355 /* Check if driver supports combined crc and adler checksum and test */ 2356 if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) { 2357 compress_xform->compress.chksum = 2358 RTE_COMP_CHECKSUM_CRC32_ADLER32; 2359 decompress_xform->decompress.chksum = 2360 RTE_COMP_CHECKSUM_CRC32_ADLER32; 2361 /* Zlib doesn't support combined checksum */ 2362 test_data.zlib_dir = ZLIB_NONE; 2363 /* Compress stateless, decompress stateful with compressdev */ 2364 test_data.buff_type = LB_BOTH; 2365 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) { 2366 ret = TEST_FAILED; 2367 goto exit; 2368 } 2369 if (capab->comp_feature_flags & 2370 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) { 2371 /* Now test with SGL buffers */ 2372 test_data.buff_type = SGL_BOTH; 2373 if (test_deflate_comp_decomp(&int_data, 2374 &test_data) < 0) { 2375 ret = TEST_FAILED; 2376 goto exit; 2377 } 2378 } 2379 } 2380 2381 ret = TEST_SUCCESS; 2382 2383 exit: 2384 rte_free(compress_xform); 2385 rte_free(decompress_xform); 2386 return ret; 2387 } 2388 2389 static const struct rte_memzone * 2390 make_memzone(const char *name, size_t size) 2391 { 2392 unsigned int socket_id = rte_socket_id(); 2393 char mz_name[RTE_MEMZONE_NAMESIZE]; 2394 const struct rte_memzone *memzone; 2395 2396 snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id); 2397 memzone = rte_memzone_lookup(mz_name); 2398 if (memzone != NULL && memzone->len != size) { 2399 rte_memzone_free(memzone); 2400 memzone = NULL; 2401 } 2402 if (memzone == NULL) { 2403 memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id, 2404 RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE); 2405 if (memzone == NULL) 2406 RTE_LOG(ERR, USER1, "Can't allocate memory zone %s", 2407 mz_name); 2408 } 2409 return memzone; 2410 } 2411 2412 static int 2413 test_compressdev_external_mbufs(void) 2414 { 2415 struct comp_testsuite_params *ts_params = &testsuite_params; 2416 size_t data_len = 0; 2417 uint16_t i; 2418 int ret = TEST_FAILED; 2419 2420 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) 2421 data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1); 2422 2423 struct interim_data_params int_data = { 2424 NULL, 2425 1, 2426 NULL, 2427 &ts_params->def_comp_xform, 2428 &ts_params->def_decomp_xform, 2429 1 2430 }; 2431 2432 struct test_data_params test_data = { 2433 .compress_state = RTE_COMP_OP_STATELESS, 2434 .decompress_state = RTE_COMP_OP_STATELESS, 2435 .buff_type = LB_BOTH, 2436 .zlib_dir = ZLIB_DECOMPRESS, 2437 .out_of_space = 0, 2438 .big_data = 0, 2439 .use_external_mbufs = 1, 2440 .inbuf_data_size = data_len, 2441 .inbuf_memzone = make_memzone("inbuf", data_len), 2442 .compbuf_memzone = make_memzone("compbuf", data_len * 2443 COMPRESS_BUF_SIZE_RATIO), 2444 .uncompbuf_memzone = make_memzone("decompbuf", data_len) 2445 }; 2446 2447 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) { 2448 /* prepare input data */ 2449 data_len = strlen(compress_test_bufs[i]) + 1; 2450 rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i], 2451 data_len); 2452 test_data.inbuf_data_size = data_len; 2453 int_data.buf_idx = &i; 2454 2455 /* Compress with compressdev, decompress with Zlib */ 2456 test_data.zlib_dir = ZLIB_DECOMPRESS; 2457 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 2458 goto exit; 2459 2460 /* Compress with Zlib, decompress with compressdev */ 2461 test_data.zlib_dir = ZLIB_COMPRESS; 2462 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) 2463 goto exit; 2464 } 2465 2466 ret = TEST_SUCCESS; 2467 2468 exit: 2469 rte_memzone_free(test_data.inbuf_memzone); 2470 rte_memzone_free(test_data.compbuf_memzone); 2471 rte_memzone_free(test_data.uncompbuf_memzone); 2472 return ret; 2473 } 2474 2475 static struct unit_test_suite compressdev_testsuite = { 2476 .suite_name = "compressdev unit test suite", 2477 .setup = testsuite_setup, 2478 .teardown = testsuite_teardown, 2479 .unit_test_cases = { 2480 TEST_CASE_ST(NULL, NULL, 2481 test_compressdev_invalid_configuration), 2482 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2483 test_compressdev_deflate_stateless_fixed), 2484 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2485 test_compressdev_deflate_stateless_dynamic), 2486 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2487 test_compressdev_deflate_stateless_dynamic_big), 2488 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2489 test_compressdev_deflate_stateless_multi_op), 2490 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2491 test_compressdev_deflate_stateless_multi_level), 2492 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2493 test_compressdev_deflate_stateless_multi_xform), 2494 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2495 test_compressdev_deflate_stateless_sgl), 2496 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2497 test_compressdev_deflate_stateless_checksum), 2498 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2499 test_compressdev_out_of_space_buffer), 2500 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2501 test_compressdev_deflate_stateful_decomp), 2502 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2503 test_compressdev_deflate_stateful_decomp_checksum), 2504 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown, 2505 test_compressdev_external_mbufs), 2506 TEST_CASES_END() /**< NULL terminate unit test array */ 2507 } 2508 }; 2509 2510 static int 2511 test_compressdev(void) 2512 { 2513 return unit_test_suite_runner(&compressdev_testsuite); 2514 } 2515 2516 REGISTER_TEST_COMMAND(compressdev_autotest, test_compressdev); 2517