app/test/test_compressdev.c

   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 #include <stdio.h>
  10
  11 #include <rte_cycles.h>
  12 #include <rte_malloc.h>
  13 #include <rte_mempool.h>
  14 #include <rte_mbuf.h>
  15 #include <rte_compressdev.h>
  16 #include <rte_string_fns.h>
  17
  18 #include "test_compressdev_test_buffer.h"
  19 #include "test.h"
  20
  21 #define DIV_CEIL(a, b)  ((a) / (b) + ((a) % (b) != 0))
  22
  23 #define DEFAULT_WINDOW_SIZE 15
  24 #define DEFAULT_MEM_LEVEL 8
  25 #define MAX_DEQD_RETRIES 10
  26 #define DEQUEUE_WAIT_TIME 10000
  27
  28 /*
  29  * 30% extra size for compressed data compared to original data,
  30  * in case data size cannot be reduced and it is actually bigger
  31  * due to the compress block headers
  32  */
  33 #define COMPRESS_BUF_SIZE_RATIO 1.3
  34 #define COMPRESS_BUF_SIZE_RATIO_DISABLED 1.0
  35 #define COMPRESS_BUF_SIZE_RATIO_OVERFLOW 0.2
  36 #define NUM_LARGE_MBUFS 16
  37 #define SMALL_SEG_SIZE 256
  38 #define MAX_SEGS 16
  39 #define NUM_OPS 16
  40 #define NUM_MAX_XFORMS 16
  41 #define NUM_MAX_INFLIGHT_OPS 128
  42 #define CACHE_SIZE 0
  43
  44 #define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31
  45 #define ZLIB_HEADER_SIZE 2
  46 #define ZLIB_TRAILER_SIZE 4
  47 #define GZIP_HEADER_SIZE 10
  48 #define GZIP_TRAILER_SIZE 8
  49
  50 #define OUT_OF_SPACE_BUF 1
  51
  52 #define MAX_MBUF_SEGMENT_SIZE 65535
  53 #define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM)
  54 #define NUM_BIG_MBUFS (512 + 1)
  55 #define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * 2)
  56
  57 /* constants for "im buffer" tests start here */
  58
  59 /* number of mbufs lower than number of inflight ops */
  60 #define IM_BUF_NUM_MBUFS 3
  61 /* above threshold (QAT_FALLBACK_THLD) and below max mbuf size */
  62 #define IM_BUF_DATA_TEST_SIZE_LB 59600
  63 /* data size smaller than the queue capacity */
  64 #define IM_BUF_DATA_TEST_SIZE_SGL (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS)
  65 /* number of mbufs bigger than number of inflight ops */
  66 #define IM_BUF_NUM_MBUFS_OVER (NUM_MAX_INFLIGHT_OPS + 1)
  67 /* data size bigger than the queue capacity */
  68 #define IM_BUF_DATA_TEST_SIZE_OVER (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS_OVER)
  69 /* number of mid-size mbufs */
  70 #define IM_BUF_NUM_MBUFS_MID ((NUM_MAX_INFLIGHT_OPS / 3) + 1)
  71 /* capacity of mid-size mbufs */
  72 #define IM_BUF_DATA_TEST_SIZE_MID (MAX_DATA_MBUF_SIZE * IM_BUF_NUM_MBUFS_MID)
  73
  74
  75 const char *
  76 huffman_type_strings[] = {
  77         [RTE_COMP_HUFFMAN_DEFAULT]      = "PMD default",
  78         [RTE_COMP_HUFFMAN_FIXED]        = "Fixed",
  79         [RTE_COMP_HUFFMAN_DYNAMIC]      = "Dynamic"
  80 };
  81
  82 enum zlib_direction {
  83         ZLIB_NONE,
  84         ZLIB_COMPRESS,
  85         ZLIB_DECOMPRESS,
  86         ZLIB_ALL
  87 };
  88
  89 enum varied_buff {
  90         LB_BOTH = 0,    /* both input and output are linear*/
  91         SGL_BOTH,       /* both input and output are chained */
  92         SGL_TO_LB,      /* input buffer is chained */
  93         LB_TO_SGL       /* output buffer is chained */
  94 };
  95
  96 enum overflow_test {
  97         OVERFLOW_DISABLED,
  98         OVERFLOW_ENABLED
  99 };
 100
 101 enum ratio_switch {
 102         RATIO_DISABLED,
 103         RATIO_ENABLED
 104 };
 105
 106 enum operation_type {
 107         OPERATION_COMPRESSION,
 108         OPERATION_DECOMPRESSION
 109 };
 110
 111 struct priv_op_data {
 112         uint16_t orig_idx;
 113 };
 114
 115 struct comp_testsuite_params {
 116         struct rte_mempool *large_mbuf_pool;
 117         struct rte_mempool *small_mbuf_pool;
 118         struct rte_mempool *big_mbuf_pool;
 119         struct rte_mempool *op_pool;
 120         struct rte_comp_xform *def_comp_xform;
 121         struct rte_comp_xform *def_decomp_xform;
 122 };
 123
 124 struct interim_data_params {
 125         const char * const *test_bufs;
 126         unsigned int num_bufs;
 127         uint16_t *buf_idx;
 128         struct rte_comp_xform **compress_xforms;
 129         struct rte_comp_xform **decompress_xforms;
 130         unsigned int num_xforms;
 131 };
 132
 133 struct test_data_params {
 134         enum rte_comp_op_type compress_state;
 135         enum rte_comp_op_type decompress_state;
 136         enum varied_buff buff_type;
 137         enum zlib_direction zlib_dir;
 138         unsigned int out_of_space;
 139         unsigned int big_data;
 140         /* stateful decompression specific parameters */
 141         unsigned int decompress_output_block_size;
 142         unsigned int decompress_steps_max;
 143         /* external mbufs specific parameters */
 144         unsigned int use_external_mbufs;
 145         unsigned int inbuf_data_size;
 146         const struct rte_memzone *inbuf_memzone;
 147         const struct rte_memzone *compbuf_memzone;
 148         const struct rte_memzone *uncompbuf_memzone;
 149         /* overflow test activation */
 150         enum overflow_test overflow;
 151         enum ratio_switch ratio;
 152 };
 153
 154 struct test_private_arrays {
 155         struct rte_mbuf **uncomp_bufs;
 156         struct rte_mbuf **comp_bufs;
 157         struct rte_comp_op **ops;
 158         struct rte_comp_op **ops_processed;
 159         void **priv_xforms;
 160         uint64_t *compress_checksum;
 161         uint32_t *compressed_data_size;
 162         void **stream;
 163         char **all_decomp_data;
 164         unsigned int *decomp_produced_data_size;
 165         uint16_t num_priv_xforms;
 166 };
 167
 168 static struct comp_testsuite_params testsuite_params = { 0 };
 169
 170
 171 static void
 172 testsuite_teardown(void)
 173 {
 174         struct comp_testsuite_params *ts_params = &testsuite_params;
 175
 176         if (rte_mempool_in_use_count(ts_params->large_mbuf_pool))
 177                 RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n");
 178         if (rte_mempool_in_use_count(ts_params->small_mbuf_pool))
 179                 RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n");
 180         if (rte_mempool_in_use_count(ts_params->big_mbuf_pool))
 181                 RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n");
 182         if (rte_mempool_in_use_count(ts_params->op_pool))
 183                 RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n");
 184
 185         rte_mempool_free(ts_params->large_mbuf_pool);
 186         rte_mempool_free(ts_params->small_mbuf_pool);
 187         rte_mempool_free(ts_params->big_mbuf_pool);
 188         rte_mempool_free(ts_params->op_pool);
 189         rte_free(ts_params->def_comp_xform);
 190         rte_free(ts_params->def_decomp_xform);
 191 }
 192
 193 static int
 194 testsuite_setup(void)
 195 {
 196         struct comp_testsuite_params *ts_params = &testsuite_params;
 197         uint32_t max_buf_size = 0;
 198         unsigned int i;
 199
 200         if (rte_compressdev_count() == 0) {
 201                 RTE_LOG(WARNING, USER1, "Need at least one compress device\n");
 202                 return TEST_SKIPPED;
 203         }
 204
 205         RTE_LOG(NOTICE, USER1, "Running tests on device %s\n",
 206                                 rte_compressdev_name_get(0));
 207
 208         for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
 209                 max_buf_size = RTE_MAX(max_buf_size,
 210                                 strlen(compress_test_bufs[i]) + 1);
 211
 212         /*
 213          * Buffers to be used in compression and decompression.
 214          * Since decompressed data might be larger than
 215          * compressed data (due to block header),
 216          * buffers should be big enough for both cases.
 217          */
 218         max_buf_size *= COMPRESS_BUF_SIZE_RATIO;
 219         ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool",
 220                         NUM_LARGE_MBUFS,
 221                         CACHE_SIZE, 0,
 222                         max_buf_size + RTE_PKTMBUF_HEADROOM,
 223                         rte_socket_id());
 224         if (ts_params->large_mbuf_pool == NULL) {
 225                 RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n");
 226                 return TEST_FAILED;
 227         }
 228
 229         /* Create mempool with smaller buffers for SGL testing */
 230         ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool",
 231                         NUM_LARGE_MBUFS * MAX_SEGS,
 232                         CACHE_SIZE, 0,
 233                         SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM,
 234                         rte_socket_id());
 235         if (ts_params->small_mbuf_pool == NULL) {
 236                 RTE_LOG(ERR, USER1, "Small mbuf pool could not be created\n");
 237                 goto exit;
 238         }
 239
 240         /* Create mempool with big buffers for SGL testing */
 241         ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool",
 242                         NUM_BIG_MBUFS + 1,
 243                         CACHE_SIZE, 0,
 244                         MAX_MBUF_SEGMENT_SIZE,
 245                         rte_socket_id());
 246         if (ts_params->big_mbuf_pool == NULL) {
 247                 RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n");
 248                 goto exit;
 249         }
 250
 251         ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS,
 252                                 0, sizeof(struct priv_op_data),
 253                                 rte_socket_id());
 254         if (ts_params->op_pool == NULL) {
 255                 RTE_LOG(ERR, USER1, "Operation pool could not be created\n");
 256                 goto exit;
 257         }
 258
 259         ts_params->def_comp_xform =
 260                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
 261         if (ts_params->def_comp_xform == NULL) {
 262                 RTE_LOG(ERR, USER1,
 263                         "Default compress xform could not be created\n");
 264                 goto exit;
 265         }
 266         ts_params->def_decomp_xform =
 267                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
 268         if (ts_params->def_decomp_xform == NULL) {
 269                 RTE_LOG(ERR, USER1,
 270                         "Default decompress xform could not be created\n");
 271                 goto exit;
 272         }
 273
 274         /* Initializes default values for compress/decompress xforms */
 275         ts_params->def_comp_xform->type = RTE_COMP_COMPRESS;
 276         ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE,
 277         ts_params->def_comp_xform->compress.deflate.huffman =
 278                                                 RTE_COMP_HUFFMAN_DEFAULT;
 279         ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT;
 280         ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE;
 281         ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE;
 282
 283         ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS;
 284         ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE,
 285         ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE;
 286         ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE;
 287
 288         return TEST_SUCCESS;
 289
 290 exit:
 291         testsuite_teardown();
 292
 293         return TEST_FAILED;
 294 }
 295
 296 static int
 297 generic_ut_setup(void)
 298 {
 299         /* Configure compressdev (one device, one queue pair) */
 300         struct rte_compressdev_config config = {
 301                 .socket_id = rte_socket_id(),
 302                 .nb_queue_pairs = 1,
 303                 .max_nb_priv_xforms = NUM_MAX_XFORMS,
 304                 .max_nb_streams = 1
 305         };
 306
 307         if (rte_compressdev_configure(0, &config) < 0) {
 308                 RTE_LOG(ERR, USER1, "Device configuration failed\n");
 309                 return -1;
 310         }
 311
 312         if (rte_compressdev_queue_pair_setup(0, 0, NUM_MAX_INFLIGHT_OPS,
 313                         rte_socket_id()) < 0) {
 314                 RTE_LOG(ERR, USER1, "Queue pair setup failed\n");
 315                 return -1;
 316         }
 317
 318         if (rte_compressdev_start(0) < 0) {
 319                 RTE_LOG(ERR, USER1, "Device could not be started\n");
 320                 return -1;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static void
 327 generic_ut_teardown(void)
 328 {
 329         rte_compressdev_stop(0);
 330         if (rte_compressdev_close(0) < 0)
 331                 RTE_LOG(ERR, USER1, "Device could not be closed\n");
 332 }
 333
 334 static int
 335 test_compressdev_invalid_configuration(void)
 336 {
 337         struct rte_compressdev_config invalid_config;
 338         struct rte_compressdev_config valid_config = {
 339                 .socket_id = rte_socket_id(),
 340                 .nb_queue_pairs = 1,
 341                 .max_nb_priv_xforms = NUM_MAX_XFORMS,
 342                 .max_nb_streams = 1
 343         };
 344         struct rte_compressdev_info dev_info;
 345
 346         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
 347
 348         /* Invalid configuration with 0 queue pairs */
 349         memcpy(&invalid_config, &valid_config,
 350                         sizeof(struct rte_compressdev_config));
 351         invalid_config.nb_queue_pairs = 0;
 352
 353         TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
 354                         "Device configuration was successful "
 355                         "with no queue pairs (invalid)\n");
 356
 357         /*
 358          * Invalid configuration with too many queue pairs
 359          * (if there is an actual maximum number of queue pairs)
 360          */
 361         rte_compressdev_info_get(0, &dev_info);
 362         if (dev_info.max_nb_queue_pairs != 0) {
 363                 memcpy(&invalid_config, &valid_config,
 364                         sizeof(struct rte_compressdev_config));
 365                 invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1;
 366
 367                 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
 368                                 "Device configuration was successful "
 369                                 "with too many queue pairs (invalid)\n");
 370         }
 371
 372         /* Invalid queue pair setup, with no number of queue pairs set */
 373         TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0,
 374                                 NUM_MAX_INFLIGHT_OPS, rte_socket_id()),
 375                         "Queue pair setup was successful "
 376                         "with no queue pairs set (invalid)\n");
 377
 378         return TEST_SUCCESS;
 379 }
 380
 381 static int
 382 compare_buffers(const char *buffer1, uint32_t buffer1_len,
 383                 const char *buffer2, uint32_t buffer2_len)
 384 {
 385         if (buffer1_len != buffer2_len) {
 386                 RTE_LOG(ERR, USER1, "Buffer lengths are different\n");
 387                 return -1;
 388         }
 389
 390         if (memcmp(buffer1, buffer2, buffer1_len) != 0) {
 391                 RTE_LOG(ERR, USER1, "Buffers are different\n");
 392                 return -1;
 393         }
 394
 395         return 0;
 396 }
 397
 398 /*
 399  * Maps compressdev and Zlib flush flags
 400  */
 401 static int
 402 map_zlib_flush_flag(enum rte_comp_flush_flag flag)
 403 {
 404         switch (flag) {
 405         case RTE_COMP_FLUSH_NONE:
 406                 return Z_NO_FLUSH;
 407         case RTE_COMP_FLUSH_SYNC:
 408                 return Z_SYNC_FLUSH;
 409         case RTE_COMP_FLUSH_FULL:
 410                 return Z_FULL_FLUSH;
 411         case RTE_COMP_FLUSH_FINAL:
 412                 return Z_FINISH;
 413         /*
 414          * There should be only the values above,
 415          * so this should never happen
 416          */
 417         default:
 418                 return -1;
 419         }
 420 }
 421
 422 static int
 423 compress_zlib(struct rte_comp_op *op,
 424                 const struct rte_comp_xform *xform, int mem_level)
 425 {
 426         z_stream stream;
 427         int zlib_flush;
 428         int strategy, window_bits, comp_level;
 429         int ret = TEST_FAILED;
 430         uint8_t *single_src_buf = NULL;
 431         uint8_t *single_dst_buf = NULL;
 432
 433         /* initialize zlib stream */
 434         stream.zalloc = Z_NULL;
 435         stream.zfree = Z_NULL;
 436         stream.opaque = Z_NULL;
 437
 438         if (xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED)
 439                 strategy = Z_FIXED;
 440         else
 441                 strategy = Z_DEFAULT_STRATEGY;
 442
 443         /*
 444          * Window bits is the base two logarithm of the window size (in bytes).
 445          * When doing raw DEFLATE, this number will be negative.
 446          */
 447         window_bits = -(xform->compress.window_size);
 448         if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32)
 449                 window_bits *= -1;
 450         else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32)
 451                 window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS;
 452
 453         comp_level = xform->compress.level;
 454
 455         if (comp_level != RTE_COMP_LEVEL_NONE)
 456                 ret = deflateInit2(&stream, comp_level, Z_DEFLATED,
 457                         window_bits, mem_level, strategy);
 458         else
 459                 ret = deflateInit(&stream, Z_NO_COMPRESSION);
 460
 461         if (ret != Z_OK) {
 462                 printf("Zlib deflate could not be initialized\n");
 463                 goto exit;
 464         }
 465
 466         /* Assuming stateless operation */
 467         /* SGL Input */
 468         if (op->m_src->nb_segs > 1) {
 469                 single_src_buf = rte_malloc(NULL,
 470                                 rte_pktmbuf_pkt_len(op->m_src), 0);
 471                 if (single_src_buf == NULL) {
 472                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 473                         goto exit;
 474                 }
 475
 476                 if (rte_pktmbuf_read(op->m_src, op->src.offset,
 477                                         rte_pktmbuf_pkt_len(op->m_src) -
 478                                         op->src.offset,
 479                                         single_src_buf) == NULL) {
 480                         RTE_LOG(ERR, USER1,
 481                                 "Buffer could not be read entirely\n");
 482                         goto exit;
 483                 }
 484
 485                 stream.avail_in = op->src.length;
 486                 stream.next_in = single_src_buf;
 487
 488         } else {
 489                 stream.avail_in = op->src.length;
 490                 stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
 491                                 op->src.offset);
 492         }
 493         /* SGL output */
 494         if (op->m_dst->nb_segs > 1) {
 495
 496                 single_dst_buf = rte_malloc(NULL,
 497                                 rte_pktmbuf_pkt_len(op->m_dst), 0);
 498                         if (single_dst_buf == NULL) {
 499                                 RTE_LOG(ERR, USER1,
 500                                         "Buffer could not be allocated\n");
 501                         goto exit;
 502                 }
 503
 504                 stream.avail_out = op->m_dst->pkt_len;
 505                 stream.next_out = single_dst_buf;
 506
 507         } else {/* linear output */
 508                 stream.avail_out = op->m_dst->data_len;
 509                 stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
 510                                 op->dst.offset);
 511         }
 512
 513         /* Stateless operation, all buffer will be compressed in one go */
 514         zlib_flush = map_zlib_flush_flag(op->flush_flag);
 515         ret = deflate(&stream, zlib_flush);
 516
 517         if (stream.avail_in != 0) {
 518                 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
 519                 goto exit;
 520         }
 521
 522         if (ret != Z_STREAM_END)
 523                 goto exit;
 524
 525         /* Copy data to destination SGL */
 526         if (op->m_dst->nb_segs > 1) {
 527                 uint32_t remaining_data = stream.total_out;
 528                 uint8_t *src_data = single_dst_buf;
 529                 struct rte_mbuf *dst_buf = op->m_dst;
 530
 531                 while (remaining_data > 0) {
 532                         uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf,
 533                                                 uint8_t *, op->dst.offset);
 534                         /* Last segment */
 535                         if (remaining_data < dst_buf->data_len) {
 536                                 memcpy(dst_data, src_data, remaining_data);
 537                                 remaining_data = 0;
 538                         } else {
 539                                 memcpy(dst_data, src_data, dst_buf->data_len);
 540                                 remaining_data -= dst_buf->data_len;
 541                                 src_data += dst_buf->data_len;
 542                                 dst_buf = dst_buf->next;
 543                         }
 544                 }
 545         }
 546
 547         op->consumed = stream.total_in;
 548         if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) {
 549                 rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE);
 550                 rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE);
 551                 op->produced = stream.total_out - (ZLIB_HEADER_SIZE +
 552                                 ZLIB_TRAILER_SIZE);
 553         } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) {
 554                 rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE);
 555                 rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE);
 556                 op->produced = stream.total_out - (GZIP_HEADER_SIZE +
 557                                 GZIP_TRAILER_SIZE);
 558         } else
 559                 op->produced = stream.total_out;
 560
 561         op->status = RTE_COMP_OP_STATUS_SUCCESS;
 562         op->output_chksum = stream.adler;
 563
 564         deflateReset(&stream);
 565
 566         ret = 0;
 567 exit:
 568         deflateEnd(&stream);
 569         rte_free(single_src_buf);
 570         rte_free(single_dst_buf);
 571
 572         return ret;
 573 }
 574
 575 static int
 576 decompress_zlib(struct rte_comp_op *op,
 577                 const struct rte_comp_xform *xform)
 578 {
 579         z_stream stream;
 580         int window_bits;
 581         int zlib_flush;
 582         int ret = TEST_FAILED;
 583         uint8_t *single_src_buf = NULL;
 584         uint8_t *single_dst_buf = NULL;
 585
 586         /* initialize zlib stream */
 587         stream.zalloc = Z_NULL;
 588         stream.zfree = Z_NULL;
 589         stream.opaque = Z_NULL;
 590
 591         /*
 592          * Window bits is the base two logarithm of the window size (in bytes).
 593          * When doing raw DEFLATE, this number will be negative.
 594          */
 595         window_bits = -(xform->decompress.window_size);
 596         ret = inflateInit2(&stream, window_bits);
 597
 598         if (ret != Z_OK) {
 599                 printf("Zlib deflate could not be initialized\n");
 600                 goto exit;
 601         }
 602
 603         /* Assuming stateless operation */
 604         /* SGL */
 605         if (op->m_src->nb_segs > 1) {
 606                 single_src_buf = rte_malloc(NULL,
 607                                 rte_pktmbuf_pkt_len(op->m_src), 0);
 608                 if (single_src_buf == NULL) {
 609                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 610                         goto exit;
 611                 }
 612                 single_dst_buf = rte_malloc(NULL,
 613                                 rte_pktmbuf_pkt_len(op->m_dst), 0);
 614                 if (single_dst_buf == NULL) {
 615                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 616                         goto exit;
 617                 }
 618                 if (rte_pktmbuf_read(op->m_src, 0,
 619                                         rte_pktmbuf_pkt_len(op->m_src),
 620                                         single_src_buf) == NULL) {
 621                         RTE_LOG(ERR, USER1,
 622                                 "Buffer could not be read entirely\n");
 623                         goto exit;
 624                 }
 625
 626                 stream.avail_in = op->src.length;
 627                 stream.next_in = single_src_buf;
 628                 stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst);
 629                 stream.next_out = single_dst_buf;
 630
 631         } else {
 632                 stream.avail_in = op->src.length;
 633                 stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
 634                 stream.avail_out = op->m_dst->data_len;
 635                 stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
 636         }
 637
 638         /* Stateless operation, all buffer will be compressed in one go */
 639         zlib_flush = map_zlib_flush_flag(op->flush_flag);
 640         ret = inflate(&stream, zlib_flush);
 641
 642         if (stream.avail_in != 0) {
 643                 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
 644                 goto exit;
 645         }
 646
 647         if (ret != Z_STREAM_END)
 648                 goto exit;
 649
 650         if (op->m_src->nb_segs > 1) {
 651                 uint32_t remaining_data = stream.total_out;
 652                 uint8_t *src_data = single_dst_buf;
 653                 struct rte_mbuf *dst_buf = op->m_dst;
 654
 655                 while (remaining_data > 0) {
 656                         uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf,
 657                                         uint8_t *);
 658                         /* Last segment */
 659                         if (remaining_data < dst_buf->data_len) {
 660                                 memcpy(dst_data, src_data, remaining_data);
 661                                 remaining_data = 0;
 662                         } else {
 663                                 memcpy(dst_data, src_data, dst_buf->data_len);
 664                                 remaining_data -= dst_buf->data_len;
 665                                 src_data += dst_buf->data_len;
 666                                 dst_buf = dst_buf->next;
 667                         }
 668                 }
 669         }
 670
 671         op->consumed = stream.total_in;
 672         op->produced = stream.total_out;
 673         op->status = RTE_COMP_OP_STATUS_SUCCESS;
 674
 675         inflateReset(&stream);
 676
 677         ret = 0;
 678 exit:
 679         inflateEnd(&stream);
 680
 681         return ret;
 682 }
 683
 684 static int
 685 prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 686                 uint32_t total_data_size,
 687                 struct rte_mempool *small_mbuf_pool,
 688                 struct rte_mempool *large_mbuf_pool,
 689                 uint8_t limit_segs_in_sgl,
 690                 uint16_t seg_size)
 691 {
 692         uint32_t remaining_data = total_data_size;
 693         uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size);
 694         struct rte_mempool *pool;
 695         struct rte_mbuf *next_seg;
 696         uint32_t data_size;
 697         char *buf_ptr;
 698         const char *data_ptr = test_buf;
 699         uint16_t i;
 700         int ret;
 701
 702         if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl)
 703                 num_remaining_segs = limit_segs_in_sgl - 1;
 704
 705         /*
 706          * Allocate data in the first segment (header) and
 707          * copy data if test buffer is provided
 708          */
 709         if (remaining_data < seg_size)
 710                 data_size = remaining_data;
 711         else
 712                 data_size = seg_size;
 713
 714         buf_ptr = rte_pktmbuf_append(head_buf, data_size);
 715         if (buf_ptr == NULL) {
 716                 RTE_LOG(ERR, USER1,
 717                         "Not enough space in the 1st buffer\n");
 718                 return -1;
 719         }
 720
 721         if (data_ptr != NULL) {
 722                 /* Copy characters without NULL terminator */
 723                 memcpy(buf_ptr, data_ptr, data_size);
 724                 data_ptr += data_size;
 725         }
 726         remaining_data -= data_size;
 727         num_remaining_segs--;
 728
 729         /*
 730          * Allocate the rest of the segments,
 731          * copy the rest of the data and chain the segments.
 732          */
 733         for (i = 0; i < num_remaining_segs; i++) {
 734
 735                 if (i == (num_remaining_segs - 1)) {
 736                         /* last segment */
 737                         if (remaining_data > seg_size)
 738                                 pool = large_mbuf_pool;
 739                         else
 740                                 pool = small_mbuf_pool;
 741                         data_size = remaining_data;
 742                 } else {
 743                         data_size = seg_size;
 744                         pool = small_mbuf_pool;
 745                 }
 746
 747                 next_seg = rte_pktmbuf_alloc(pool);
 748                 if (next_seg == NULL) {
 749                         RTE_LOG(ERR, USER1,
 750                                 "New segment could not be allocated "
 751                                 "from the mempool\n");
 752                         return -1;
 753                 }
 754                 buf_ptr = rte_pktmbuf_append(next_seg, data_size);
 755                 if (buf_ptr == NULL) {
 756                         RTE_LOG(ERR, USER1,
 757                                 "Not enough space in the buffer\n");
 758                         rte_pktmbuf_free(next_seg);
 759                         return -1;
 760                 }
 761                 if (data_ptr != NULL) {
 762                         /* Copy characters without NULL terminator */
 763                         memcpy(buf_ptr, data_ptr, data_size);
 764                         data_ptr += data_size;
 765                 }
 766                 remaining_data -= data_size;
 767
 768                 ret = rte_pktmbuf_chain(head_buf, next_seg);
 769                 if (ret != 0) {
 770                         rte_pktmbuf_free(next_seg);
 771                         RTE_LOG(ERR, USER1,
 772                                 "Segment could not chained\n");
 773                         return -1;
 774                 }
 775         }
 776
 777         return 0;
 778 }
 779
 780 static void
 781 extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
 782 {
 783 }
 784
 785 static int
 786 test_run_enqueue_dequeue(struct rte_comp_op **ops,
 787                          struct rte_comp_op **ops_processed,
 788                          unsigned int num_bufs)
 789 {
 790         uint16_t num_enqd, num_deqd, num_total_deqd;
 791         unsigned int deqd_retries = 0;
 792         int res = 0;
 793
 794         /* Enqueue and dequeue all operations */
 795         num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
 796         if (num_enqd < num_bufs) {
 797                 RTE_LOG(ERR, USER1,
 798                         "Some operations could not be enqueued\n");
 799                 res = -1;
 800         }
 801
 802         /* dequeue ops even on error (same number of ops as was enqueued) */
 803
 804         num_total_deqd = 0;
 805         while (num_total_deqd < num_enqd) {
 806                 /*
 807                  * If retrying a dequeue call, wait for 10 ms to allow
 808                  * enough time to the driver to process the operations
 809                  */
 810                 if (deqd_retries != 0) {
 811                         /*
 812                          * Avoid infinite loop if not all the
 813                          * operations get out of the device
 814                          */
 815                         if (deqd_retries == MAX_DEQD_RETRIES) {
 816                                 RTE_LOG(ERR, USER1,
 817                                         "Not all operations could be dequeued\n");
 818                                 res = -1;
 819                                 break;
 820                         }
 821                         usleep(DEQUEUE_WAIT_TIME);
 822                 }
 823                 num_deqd = rte_compressdev_dequeue_burst(0, 0,
 824                                 &ops_processed[num_total_deqd], num_bufs);
 825                 num_total_deqd += num_deqd;
 826                 deqd_retries++;
 827
 828         }
 829
 830         return res;
 831 }
 832
 833 /**
 834  * Arrays initialization. Input buffers preparation for compression.
 835  *
 836  * API that initializes all the private arrays to NULL
 837  * and allocates input buffers to perform compression operations.
 838  *
 839  * @param int_data
 840  *   Interim data containing session/transformation objects.
 841  * @param test_data
 842  *   The test parameters set by users (command line parameters).
 843  * @param test_priv_data
 844  *   A container used for aggregation all the private test arrays.
 845  * @return
 846  *   - 0: On success.
 847  *   - -1: On error.
 848  */
 849 static int
 850 test_setup_com_bufs(const struct interim_data_params *int_data,
 851                 const struct test_data_params *test_data,
 852                 const struct test_private_arrays *test_priv_data)
 853 {
 854         /* local variables: */
 855         unsigned int i;
 856         uint32_t data_size;
 857         char *buf_ptr;
 858         int ret;
 859         char **all_decomp_data = test_priv_data->all_decomp_data;
 860
 861         struct comp_testsuite_params *ts_params = &testsuite_params;
 862
 863         /* from int_data: */
 864         const char * const *test_bufs = int_data->test_bufs;
 865         unsigned int num_bufs = int_data->num_bufs;
 866
 867         /* from test_data: */
 868         unsigned int buff_type = test_data->buff_type;
 869         unsigned int big_data = test_data->big_data;
 870
 871         /* from test_priv_data: */
 872         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
 873         struct rte_mempool *buf_pool;
 874
 875         static struct rte_mbuf_ext_shared_info inbuf_info;
 876
 877         size_t array_size = sizeof(void *) * num_bufs;
 878
 879         /* Initialize all arrays to NULL */
 880         memset(test_priv_data->uncomp_bufs, 0, array_size);
 881         memset(test_priv_data->comp_bufs, 0, array_size);
 882         memset(test_priv_data->ops, 0, array_size);
 883         memset(test_priv_data->ops_processed, 0, array_size);
 884         memset(test_priv_data->priv_xforms, 0, array_size);
 885         memset(test_priv_data->compressed_data_size,
 886                0, sizeof(uint32_t) * num_bufs);
 887
 888         if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
 889                 data_size = strlen(test_bufs[0]) + 1;
 890                 *all_decomp_data = rte_malloc(NULL, data_size,
 891                                              RTE_CACHE_LINE_SIZE);
 892         }
 893
 894         if (big_data)
 895                 buf_pool = ts_params->big_mbuf_pool;
 896         else if (buff_type == SGL_BOTH)
 897                 buf_pool = ts_params->small_mbuf_pool;
 898         else
 899                 buf_pool = ts_params->large_mbuf_pool;
 900
 901         /* for compression uncomp_bufs is used as a source buffer */
 902         /* allocation from buf_pool (mempool type) */
 903         ret = rte_pktmbuf_alloc_bulk(buf_pool,
 904                                 uncomp_bufs, num_bufs);
 905         if (ret < 0) {
 906                 RTE_LOG(ERR, USER1,
 907                         "Source mbufs could not be allocated "
 908                         "from the mempool\n");
 909                 return -1;
 910         }
 911
 912         if (test_data->use_external_mbufs) {
 913                 inbuf_info.free_cb = extbuf_free_callback;
 914                 inbuf_info.fcb_opaque = NULL;
 915                 rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
 916                 for (i = 0; i < num_bufs; i++) {
 917                         rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
 918                                         test_data->inbuf_memzone->addr,
 919                                         test_data->inbuf_memzone->iova,
 920                                         test_data->inbuf_data_size,
 921                                         &inbuf_info);
 922                         buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
 923                                         test_data->inbuf_data_size);
 924                         if (buf_ptr == NULL) {
 925                                 RTE_LOG(ERR, USER1,
 926                                         "Append extra bytes to the source mbuf failed\n");
 927                                 return -1;
 928                         }
 929                 }
 930         } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 931                 for (i = 0; i < num_bufs; i++) {
 932                         data_size = strlen(test_bufs[i]) + 1;
 933                         if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
 934                             data_size,
 935                             big_data ? buf_pool : ts_params->small_mbuf_pool,
 936                             big_data ? buf_pool : ts_params->large_mbuf_pool,
 937                             big_data ? 0 : MAX_SEGS,
 938                             big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
 939                                 return -1;
 940                 }
 941         } else {
 942                 for (i = 0; i < num_bufs; i++) {
 943                         data_size = strlen(test_bufs[i]) + 1;
 944
 945                         buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
 946                         if (buf_ptr == NULL) {
 947                                 RTE_LOG(ERR, USER1,
 948                                         "Append extra bytes to the source mbuf failed\n");
 949                                 return -1;
 950                         }
 951                         strlcpy(buf_ptr, test_bufs[i], data_size);
 952                 }
 953         }
 954
 955         return 0;
 956 }
 957
 958 /**
 959  * Data size calculation (for both compression and decompression).
 960  *
 961  * Calculate size of anticipated output buffer required for both
 962  * compression and decompression operations based on input int_data.
 963  *
 964  * @param op_type
 965  *   Operation type: compress or decompress
 966  * @param out_of_space_and_zlib
 967  *   Boolean value to switch into "out of space" buffer if set.
 968  *   To test "out-of-space" data size, zlib_decompress must be set as well.
 969  * @param test_priv_data
 970  *   A container used for aggregation all the private test arrays.
 971  * @param int_data
 972  *   Interim data containing session/transformation objects.
 973  * @param test_data
 974  *   The test parameters set by users (command line parameters).
 975  * @param i
 976  *   current buffer index
 977  * @return
 978  *   data size
 979  */
 980 static inline uint32_t
 981 test_mbufs_calculate_data_size(
 982                 enum operation_type op_type,
 983                 unsigned int out_of_space_and_zlib,
 984                 const struct test_private_arrays *test_priv_data,
 985                 const struct interim_data_params *int_data,
 986                 const struct test_data_params *test_data,
 987                 unsigned int i)
 988 {
 989         /* local variables: */
 990         uint32_t data_size;
 991         struct priv_op_data *priv_data;
 992         float ratio_val;
 993         enum ratio_switch ratio = test_data->ratio;
 994
 995         uint8_t not_zlib_compr; /* true if zlib isn't current compression dev */
 996         enum overflow_test overflow = test_data->overflow;
 997
 998         /* from test_priv_data: */
 999         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1000
1001         /* from int_data: */
1002         const char * const *test_bufs = int_data->test_bufs;
1003
1004         if (out_of_space_and_zlib)
1005                 data_size = OUT_OF_SPACE_BUF;
1006         else {
1007                 if (op_type == OPERATION_COMPRESSION) {
1008                         not_zlib_compr = (test_data->zlib_dir == ZLIB_DECOMPRESS
1009                                 || test_data->zlib_dir == ZLIB_NONE);
1010
1011                         ratio_val = (ratio == RATIO_ENABLED) ?
1012                                         COMPRESS_BUF_SIZE_RATIO :
1013                                         COMPRESS_BUF_SIZE_RATIO_DISABLED;
1014
1015                         ratio_val = (not_zlib_compr &&
1016                                 (overflow == OVERFLOW_ENABLED)) ?
1017                                 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
1018                                 ratio_val;
1019
1020                         data_size = strlen(test_bufs[i]) * ratio_val;
1021                 } else {
1022                         priv_data = (struct priv_op_data *)
1023                                         (ops_processed[i] + 1);
1024                         data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
1025                 }
1026         }
1027
1028         return data_size;
1029 }
1030
1031
1032 /**
1033  * Memory buffers preparation (for both compression and decompression).
1034  *
1035  * Function allocates output buffers to perform compression
1036  * or decompression operations depending on value of op_type.
1037  *
1038  * @param op_type
1039  *   Operation type: compress or decompress
1040  * @param out_of_space_and_zlib
1041  *   Boolean value to switch into "out of space" buffer if set.
1042  *   To test "out-of-space" data size, zlib_decompress must be set as well.
1043  * @param test_priv_data
1044  *   A container used for aggregation all the private test arrays.
1045  * @param int_data
1046  *   Interim data containing session/transformation objects.
1047  * @param test_data
1048  *   The test parameters set by users (command line parameters).
1049  * @param current_extbuf_info,
1050  *   The structure containing all the information related to external mbufs
1051  * @return
1052  *   - 0: On success.
1053  *   - -1: On error.
1054  */
1055 static int
1056 test_setup_output_bufs(
1057                 enum operation_type op_type,
1058                 unsigned int out_of_space_and_zlib,
1059                 const struct test_private_arrays *test_priv_data,
1060                 const struct interim_data_params *int_data,
1061                 const struct test_data_params *test_data,
1062                 struct rte_mbuf_ext_shared_info *current_extbuf_info)
1063 {
1064         /* local variables: */
1065         unsigned int i;
1066         uint32_t data_size;
1067         int ret;
1068         char *buf_ptr;
1069
1070         /* from test_priv_data: */
1071         struct rte_mbuf **current_bufs;
1072
1073         /* from int_data: */
1074         unsigned int num_bufs = int_data->num_bufs;
1075
1076         /* from test_data: */
1077         unsigned int buff_type = test_data->buff_type;
1078         unsigned int big_data = test_data->big_data;
1079         const struct rte_memzone *current_memzone;
1080
1081         struct comp_testsuite_params *ts_params = &testsuite_params;
1082         struct rte_mempool *buf_pool;
1083
1084         if (big_data)
1085                 buf_pool = ts_params->big_mbuf_pool;
1086         else if (buff_type == SGL_BOTH)
1087                 buf_pool = ts_params->small_mbuf_pool;
1088         else
1089                 buf_pool = ts_params->large_mbuf_pool;
1090
1091         if (op_type == OPERATION_COMPRESSION)
1092                 current_bufs = test_priv_data->comp_bufs;
1093         else
1094                 current_bufs = test_priv_data->uncomp_bufs;
1095
1096         /* the mbufs allocation*/
1097         ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
1098         if (ret < 0) {
1099                 RTE_LOG(ERR, USER1,
1100                         "Destination mbufs could not be allocated "
1101                         "from the mempool\n");
1102                 return -1;
1103         }
1104
1105         if (test_data->use_external_mbufs) {
1106                 current_extbuf_info->free_cb = extbuf_free_callback;
1107                 current_extbuf_info->fcb_opaque = NULL;
1108                 rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
1109                 if (op_type == OPERATION_COMPRESSION)
1110                         current_memzone = test_data->compbuf_memzone;
1111                 else
1112                         current_memzone = test_data->uncompbuf_memzone;
1113
1114                 for (i = 0; i < num_bufs; i++) {
1115                         rte_pktmbuf_attach_extbuf(current_bufs[i],
1116                                         current_memzone->addr,
1117                                         current_memzone->iova,
1118                                         current_memzone->len,
1119                                         current_extbuf_info);
1120                         rte_pktmbuf_append(current_bufs[i],
1121                                         current_memzone->len);
1122                 }
1123         } else {
1124                 for (i = 0; i < num_bufs; i++) {
1125
1126                         enum rte_comp_huffman comp_huffman =
1127                         ts_params->def_comp_xform->compress.deflate.huffman;
1128
1129                         /* data size calculation */
1130                         data_size = test_mbufs_calculate_data_size(
1131                                         op_type,
1132                                         out_of_space_and_zlib,
1133                                         test_priv_data,
1134                                         int_data,
1135                                         test_data,
1136                                         i);
1137
1138                         if (comp_huffman != RTE_COMP_HUFFMAN_DYNAMIC) {
1139                                 if (op_type == OPERATION_DECOMPRESSION)
1140                                         data_size *= COMPRESS_BUF_SIZE_RATIO;
1141                         }
1142
1143                         /* data allocation */
1144                         if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
1145                                 ret = prepare_sgl_bufs(NULL, current_bufs[i],
1146                                       data_size,
1147                                       big_data ? buf_pool :
1148                                                 ts_params->small_mbuf_pool,
1149                                       big_data ? buf_pool :
1150                                                 ts_params->large_mbuf_pool,
1151                                       big_data ? 0 : MAX_SEGS,
1152                                       big_data ? MAX_DATA_MBUF_SIZE :
1153                                                  SMALL_SEG_SIZE);
1154                                 if (ret < 0)
1155                                         return -1;
1156                         } else {
1157                                 buf_ptr = rte_pktmbuf_append(current_bufs[i],
1158                                                 data_size);
1159                                 if (buf_ptr == NULL) {
1160                                         RTE_LOG(ERR, USER1,
1161                                                 "Append extra bytes to the destination mbuf failed\n");
1162                                         return -1;
1163                                 }
1164                         }
1165                 }
1166         }
1167
1168         return 0;
1169 }
1170
1171 /**
1172  * The main compression function.
1173  *
1174  * Function performs compression operation.
1175  * Operation(s) configuration, depending on CLI parameters.
1176  * Operation(s) processing.
1177  *
1178  * @param int_data
1179  *   Interim data containing session/transformation objects.
1180  * @param test_data
1181  *   The test parameters set by users (command line parameters).
1182  * @param test_priv_data
1183  *   A container used for aggregation all the private test arrays.
1184  * @return
1185  *   - 0: On success.
1186  *   - -1: On error.
1187  */
1188 static int
1189 test_deflate_comp_run(const struct interim_data_params *int_data,
1190                 const struct test_data_params *test_data,
1191                 const struct test_private_arrays *test_priv_data)
1192 {
1193         /* local variables: */
1194         struct priv_op_data *priv_data;
1195         unsigned int i;
1196         uint16_t num_priv_xforms = 0;
1197         int ret;
1198         int ret_status = 0;
1199         char *buf_ptr;
1200
1201         struct comp_testsuite_params *ts_params = &testsuite_params;
1202
1203         /* from test_data: */
1204         enum rte_comp_op_type operation_type = test_data->compress_state;
1205         unsigned int zlib_compress =
1206                         (test_data->zlib_dir == ZLIB_ALL ||
1207                         test_data->zlib_dir == ZLIB_COMPRESS);
1208
1209         /* from int_data: */
1210         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1211         unsigned int num_xforms = int_data->num_xforms;
1212         unsigned int num_bufs = int_data->num_bufs;
1213
1214         /* from test_priv_data: */
1215         struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1216         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1217         struct rte_comp_op **ops = test_priv_data->ops;
1218         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1219         void **priv_xforms = test_priv_data->priv_xforms;
1220
1221         const struct rte_compressdev_capabilities *capa =
1222                 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1223
1224         /* Build the compression operations */
1225         ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1226         if (ret < 0) {
1227                 RTE_LOG(ERR, USER1,
1228                         "Compress operations could not be allocated "
1229                         "from the mempool\n");
1230                 ret_status = -1;
1231                 goto exit;
1232         }
1233
1234         for (i = 0; i < num_bufs; i++) {
1235                 ops[i]->m_src = uncomp_bufs[i];
1236                 ops[i]->m_dst = comp_bufs[i];
1237                 ops[i]->src.offset = 0;
1238                 ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
1239                 ops[i]->dst.offset = 0;
1240
1241                 RTE_LOG(DEBUG, USER1,
1242                                 "Uncompressed buffer length = %u compressed buffer length = %u",
1243                                 rte_pktmbuf_pkt_len(uncomp_bufs[i]),
1244                                 rte_pktmbuf_pkt_len(comp_bufs[i]));
1245
1246                 if (operation_type == RTE_COMP_OP_STATELESS) {
1247                         ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1248                 } else {
1249                         RTE_LOG(ERR, USER1,
1250                                 "Compression: stateful operations are not "
1251                                 "supported in these tests yet\n");
1252                         ret_status = -1;
1253                         goto exit;
1254                 }
1255                 ops[i]->input_chksum = 0;
1256                 /*
1257                  * Store original operation index in private data,
1258                  * since ordering does not have to be maintained,
1259                  * when dequeueing from compressdev, so a comparison
1260                  * at the end of the test can be done.
1261                  */
1262                 priv_data = (struct priv_op_data *) (ops[i] + 1);
1263                 priv_data->orig_idx = i;
1264         }
1265
1266         /* Compress data (either with Zlib API or compressdev API */
1267         if (zlib_compress) {
1268                 for (i = 0; i < num_bufs; i++) {
1269                         const struct rte_comp_xform *compress_xform =
1270                                 compress_xforms[i % num_xforms];
1271                         ret = compress_zlib(ops[i], compress_xform,
1272                                         DEFAULT_MEM_LEVEL);
1273                         if (ret < 0) {
1274                                 ret_status = -1;
1275                                 goto exit;
1276                         }
1277
1278                         ops_processed[i] = ops[i];
1279                 }
1280         } else {
1281                 /* Create compress private xform data */
1282                 for (i = 0; i < num_xforms; i++) {
1283                         ret = rte_compressdev_private_xform_create(0,
1284                                 (const struct rte_comp_xform *)
1285                                         compress_xforms[i],
1286                                 &priv_xforms[i]);
1287                         if (ret < 0) {
1288                                 RTE_LOG(ERR, USER1,
1289                                         "Compression private xform "
1290                                         "could not be created\n");
1291                                 ret_status = -1;
1292                                 goto exit;
1293                         }
1294                         num_priv_xforms++;
1295                 }
1296                 if (capa->comp_feature_flags &
1297                                 RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1298                         /* Attach shareable private xform data to ops */
1299                         for (i = 0; i < num_bufs; i++)
1300                                 ops[i]->private_xform =
1301                                                 priv_xforms[i % num_xforms];
1302                 } else {
1303                 /* Create rest of the private xforms for the other ops */
1304                         for (i = num_xforms; i < num_bufs; i++) {
1305                                 ret = rte_compressdev_private_xform_create(0,
1306                                         compress_xforms[i % num_xforms],
1307                                         &priv_xforms[i]);
1308                                 if (ret < 0) {
1309                                         RTE_LOG(ERR, USER1,
1310                                                 "Compression private xform "
1311                                                 "could not be created\n");
1312                                         ret_status = -1;
1313                                         goto exit;
1314                                 }
1315                                 num_priv_xforms++;
1316                         }
1317                         /* Attach non shareable private xform data to ops */
1318                         for (i = 0; i < num_bufs; i++)
1319                                 ops[i]->private_xform = priv_xforms[i];
1320                 }
1321
1322 recovery_lb:
1323                 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
1324                 if (ret < 0) {
1325                         RTE_LOG(ERR, USER1,
1326                                 "Compression: enqueue/dequeue operation failed\n");
1327                         ret_status = -1;
1328                         goto exit;
1329                 }
1330
1331                 for (i = 0; i < num_bufs; i++) {
1332                         test_priv_data->compressed_data_size[i] +=
1333                                         ops_processed[i]->produced;
1334
1335                         if (ops_processed[i]->status ==
1336                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
1337
1338                                 ops[i]->status =
1339                                         RTE_COMP_OP_STATUS_NOT_PROCESSED;
1340                                 ops[i]->src.offset +=
1341                                         ops_processed[i]->consumed;
1342                                 ops[i]->src.length -=
1343                                         ops_processed[i]->consumed;
1344                                 ops[i]->dst.offset +=
1345                                         ops_processed[i]->produced;
1346
1347                                 buf_ptr = rte_pktmbuf_append(
1348                                         ops[i]->m_dst,
1349                                         ops_processed[i]->produced);
1350
1351                                 if (buf_ptr == NULL) {
1352                                         RTE_LOG(ERR, USER1,
1353                                                 "Data recovery: append extra bytes to the current mbuf failed\n");
1354                                         ret_status = -1;
1355                                         goto exit;
1356                                 }
1357                                 goto recovery_lb;
1358                         }
1359                 }
1360         }
1361
1362 exit:
1363         /* Free resources */
1364         if (ret_status < 0)
1365                 for (i = 0; i < num_bufs; i++) {
1366                         rte_comp_op_free(ops[i]);
1367                         ops[i] = NULL;
1368                         ops_processed[i] = NULL;
1369                 }
1370
1371         /* Free compress private xforms */
1372         for (i = 0; i < num_priv_xforms; i++) {
1373                 if (priv_xforms[i] != NULL) {
1374                         rte_compressdev_private_xform_free(0, priv_xforms[i]);
1375                         priv_xforms[i] = NULL;
1376                 }
1377         }
1378
1379         return ret_status;
1380 }
1381
1382 /**
1383  * Prints out the test report. Memory freeing.
1384  *
1385  * Called after successful compression.
1386  * Operation(s) status validation and decompression buffers freeing.
1387
1388  * -1 returned if function fail.
1389  *
1390  * @param int_data
1391  *   Interim data containing session/transformation objects.
1392  * @param test_data
1393  *   The test parameters set by users (command line parameters).
1394  * @param test_priv_data
1395  *   A container used for aggregation all the private test arrays.
1396  * @return
1397  *   - 2: Some operation is not supported
1398  *   - 1: Decompression should be skipped
1399  *   - 0: On success.
1400  *   - -1: On error.
1401  */
1402 static int
1403 test_deflate_comp_finalize(const struct interim_data_params *int_data,
1404                 const struct test_data_params *test_data,
1405                 const struct test_private_arrays *test_priv_data)
1406 {
1407         /* local variables: */
1408         unsigned int i;
1409         struct priv_op_data *priv_data;
1410
1411         /* from int_data: */
1412         unsigned int num_xforms = int_data->num_xforms;
1413         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1414         uint16_t *buf_idx = int_data->buf_idx;
1415         unsigned int num_bufs = int_data->num_bufs;
1416
1417         /* from test_priv_data: */
1418         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1419         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1420         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1421         struct rte_comp_op **ops = test_priv_data->ops;
1422
1423         /* from test_data: */
1424         unsigned int out_of_space = test_data->out_of_space;
1425         unsigned int zlib_compress =
1426                         (test_data->zlib_dir == ZLIB_ALL ||
1427                         test_data->zlib_dir == ZLIB_COMPRESS);
1428         unsigned int zlib_decompress =
1429                         (test_data->zlib_dir == ZLIB_ALL ||
1430                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1431
1432         for (i = 0; i < num_bufs; i++) {
1433                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1434                 uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1435                 const struct rte_comp_compress_xform *compress_xform =
1436                                 &compress_xforms[xform_idx]->compress;
1437                 enum rte_comp_huffman huffman_type =
1438                         compress_xform->deflate.huffman;
1439                 char engine[] = "zlib (directly, not PMD)";
1440                 if (zlib_decompress)
1441                         strlcpy(engine, "PMD", sizeof(engine));
1442
1443                 RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
1444                         " %u bytes (level = %d, huffman = %s)\n",
1445                         buf_idx[priv_data->orig_idx], engine,
1446                         ops_processed[i]->consumed, ops_processed[i]->produced,
1447                         compress_xform->level,
1448                         huffman_type_strings[huffman_type]);
1449                 RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f\n",
1450                         ops_processed[i]->consumed == 0 ? 0 :
1451                         (float)ops_processed[i]->produced /
1452                         ops_processed[i]->consumed * 100);
1453                 if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE)
1454                         compress_checksum[i] = ops_processed[i]->output_chksum;
1455                 ops[i] = NULL;
1456         }
1457
1458         /*
1459          * Check operation status and free source mbufs (destination mbuf and
1460          * compress operation information is needed for the decompression stage)
1461          */
1462         for (i = 0; i < num_bufs; i++) {
1463                 if (out_of_space && !zlib_compress) {
1464                         if (ops_processed[i]->status !=
1465                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1466                                 RTE_LOG(ERR, USER1,
1467                                         "Operation without expected out of "
1468                                         "space status error\n");
1469                                 return -1;
1470                         } else
1471                                 continue;
1472                 }
1473
1474                 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
1475                         if (test_data->overflow == OVERFLOW_ENABLED) {
1476                                 if (ops_processed[i]->status ==
1477                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1478                                         RTE_LOG(INFO, USER1,
1479                                         "Out-of-space-recoverable functionality"
1480                                         " is not supported on this device\n");
1481                                         return 2;
1482                                 }
1483                         }
1484
1485                         RTE_LOG(ERR, USER1,
1486                                 "Comp: Some operations were not successful\n");
1487                         return -1;
1488                 }
1489                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1490                 rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
1491                 uncomp_bufs[priv_data->orig_idx] = NULL;
1492         }
1493
1494         if (out_of_space && !zlib_compress)
1495                 return 1;
1496
1497         return 0;
1498 }
1499
1500 /**
1501  * The main decompression function.
1502  *
1503  * Function performs decompression operation.
1504  * Operation(s) configuration, depending on CLI parameters.
1505  * Operation(s) processing.
1506  *
1507  * @param int_data
1508  *   Interim data containing session/transformation objects.
1509  * @param test_data
1510  *   The test parameters set by users (command line parameters).
1511  * @param test_priv_data
1512  *   A container used for aggregation all the private test arrays.
1513  * @return
1514  *   - 0: On success.
1515  *   - -1: On error.
1516  */
1517 static int
1518 test_deflate_decomp_run(const struct interim_data_params *int_data,
1519                 const struct test_data_params *test_data,
1520                 struct test_private_arrays *test_priv_data)
1521 {
1522
1523         /* local variables: */
1524         struct priv_op_data *priv_data;
1525         unsigned int i;
1526         uint16_t num_priv_xforms = 0;
1527         int ret;
1528         int ret_status = 0;
1529
1530         struct comp_testsuite_params *ts_params = &testsuite_params;
1531
1532         /* from test_data: */
1533         enum rte_comp_op_type operation_type = test_data->decompress_state;
1534         unsigned int zlib_decompress =
1535                         (test_data->zlib_dir == ZLIB_ALL ||
1536                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1537
1538         /* from int_data: */
1539         struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
1540         unsigned int num_xforms = int_data->num_xforms;
1541         unsigned int num_bufs = int_data->num_bufs;
1542
1543         /* from test_priv_data: */
1544         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1545         struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1546         struct rte_comp_op **ops = test_priv_data->ops;
1547         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1548         void **priv_xforms = test_priv_data->priv_xforms;
1549         uint32_t *compressed_data_size = test_priv_data->compressed_data_size;
1550         void **stream = test_priv_data->stream;
1551
1552         const struct rte_compressdev_capabilities *capa =
1553                 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1554
1555         ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1556         if (ret < 0) {
1557                 RTE_LOG(ERR, USER1,
1558                         "Decompress operations could not be allocated "
1559                         "from the mempool\n");
1560                 ret_status = -1;
1561                 goto exit;
1562         }
1563
1564         /* Source buffer is the compressed data from the previous operations */
1565         for (i = 0; i < num_bufs; i++) {
1566                 ops[i]->m_src = comp_bufs[i];
1567                 ops[i]->m_dst = uncomp_bufs[i];
1568                 ops[i]->src.offset = 0;
1569                 /*
1570                  * Set the length of the compressed data to the
1571                  * number of bytes that were produced in the previous stage
1572                  */
1573
1574                 if (compressed_data_size[i])
1575                         ops[i]->src.length = compressed_data_size[i];
1576                 else
1577                         ops[i]->src.length = ops_processed[i]->produced;
1578
1579                 ops[i]->dst.offset = 0;
1580
1581                 if (operation_type == RTE_COMP_OP_STATELESS) {
1582                         ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1583                         ops[i]->op_type = RTE_COMP_OP_STATELESS;
1584                 } else if (!zlib_decompress) {
1585                         ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
1586                         ops[i]->op_type = RTE_COMP_OP_STATEFUL;
1587                 } else {
1588                         RTE_LOG(ERR, USER1,
1589                                 "Decompression: stateful operations are"
1590                                 " not supported in these tests yet\n");
1591                         ret_status = -1;
1592                         goto exit;
1593                 }
1594                 ops[i]->input_chksum = 0;
1595                 /*
1596                  * Copy private data from previous operations,
1597                  * to keep the pointer to the original buffer
1598                  */
1599                 memcpy(ops[i] + 1, ops_processed[i] + 1,
1600                                 sizeof(struct priv_op_data));
1601         }
1602
1603         /*
1604          * Free the previous compress operations,
1605          * as they are not needed anymore
1606          */
1607         rte_comp_op_bulk_free(ops_processed, num_bufs);
1608
1609         /* Decompress data (either with Zlib API or compressdev API */
1610         if (zlib_decompress) {
1611                 for (i = 0; i < num_bufs; i++) {
1612                         priv_data = (struct priv_op_data *)(ops[i] + 1);
1613                         uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1614                         const struct rte_comp_xform *decompress_xform =
1615                                 decompress_xforms[xform_idx];
1616
1617                         ret = decompress_zlib(ops[i], decompress_xform);
1618                         if (ret < 0) {
1619                                 ret_status = -1;
1620                                 goto exit;
1621                         }
1622
1623                         ops_processed[i] = ops[i];
1624                 }
1625         } else {
1626                 if (operation_type == RTE_COMP_OP_STATELESS) {
1627                         /* Create decompress private xform data */
1628                         for (i = 0; i < num_xforms; i++) {
1629                                 ret = rte_compressdev_private_xform_create(0,
1630                                         (const struct rte_comp_xform *)
1631                                         decompress_xforms[i],
1632                                         &priv_xforms[i]);
1633                                 if (ret < 0) {
1634                                         RTE_LOG(ERR, USER1,
1635                                                 "Decompression private xform "
1636                                                 "could not be created\n");
1637                                         ret_status = -1;
1638                                         goto exit;
1639                                 }
1640                                 num_priv_xforms++;
1641                         }
1642
1643                         if (capa->comp_feature_flags &
1644                                         RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1645                                 /* Attach shareable private xform data to ops */
1646                                 for (i = 0; i < num_bufs; i++) {
1647                                         priv_data = (struct priv_op_data *)
1648                                                         (ops[i] + 1);
1649                                         uint16_t xform_idx =
1650                                                priv_data->orig_idx % num_xforms;
1651                                         ops[i]->private_xform =
1652                                                         priv_xforms[xform_idx];
1653                                 }
1654                         } else {
1655                                 /* Create rest of the private xforms */
1656                                 /* for the other ops */
1657                                 for (i = num_xforms; i < num_bufs; i++) {
1658                                         ret =
1659                                          rte_compressdev_private_xform_create(0,
1660                                               decompress_xforms[i % num_xforms],
1661                                               &priv_xforms[i]);
1662                                         if (ret < 0) {
1663                                                 RTE_LOG(ERR, USER1,
1664                                                         "Decompression private xform"
1665                                                         " could not be created\n");
1666                                                 ret_status = -1;
1667                                                 goto exit;
1668                                         }
1669                                         num_priv_xforms++;
1670                                 }
1671
1672                                 /* Attach non shareable private xform data */
1673                                 /* to ops */
1674                                 for (i = 0; i < num_bufs; i++) {
1675                                         priv_data = (struct priv_op_data *)
1676                                                         (ops[i] + 1);
1677                                         uint16_t xform_idx =
1678                                                         priv_data->orig_idx;
1679                                         ops[i]->private_xform =
1680                                                         priv_xforms[xform_idx];
1681                                 }
1682                         }
1683                 } else {
1684                         /* Create a stream object for stateful decompression */
1685                         ret = rte_compressdev_stream_create(0,
1686                                         decompress_xforms[0], stream);
1687                         if (ret < 0) {
1688                                 RTE_LOG(ERR, USER1,
1689                                         "Decompression stream could not be created, error %d\n",
1690                                         ret);
1691                                 ret_status = -1;
1692                                 goto exit;
1693                         }
1694                         /* Attach stream to ops */
1695                         for (i = 0; i < num_bufs; i++)
1696                                 ops[i]->stream = *stream;
1697                 }
1698
1699                 test_priv_data->num_priv_xforms = num_priv_xforms;
1700         }
1701
1702 exit:
1703         return ret_status;
1704 }
1705
1706 /**
1707  * Prints out the test report. Memory freeing.
1708  *
1709  * Called after successful decompression.
1710  * Operation(s) status validation and compression buffers freeing.
1711
1712  * -1 returned if function fail.
1713  *
1714  * @param int_data
1715  *   Interim data containing session/transformation objects.
1716  * @param test_data
1717  *   The test parameters set by users (command line parameters).
1718  * @param test_priv_data
1719  *   A container used for aggregation all the private test arrays.
1720  * @return
1721  *   - 2: Next step must be executed by the caller (stateful decompression only)
1722  *   - 1: On success (caller should stop and exit)
1723  *   - 0: On success.
1724  *   - -1: On error.
1725  */
1726 static int
1727 test_deflate_decomp_finalize(const struct interim_data_params *int_data,
1728                 const struct test_data_params *test_data,
1729                 const struct test_private_arrays *test_priv_data)
1730 {
1731         /* local variables: */
1732         unsigned int i;
1733         struct priv_op_data *priv_data;
1734         static unsigned int step;
1735
1736         /* from int_data: */
1737         uint16_t *buf_idx = int_data->buf_idx;
1738         unsigned int num_bufs = int_data->num_bufs;
1739         const char * const *test_bufs = int_data->test_bufs;
1740         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1741
1742         /* from test_priv_data: */
1743         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1744         struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1745         struct rte_comp_op **ops = test_priv_data->ops;
1746         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1747         unsigned int *decomp_produced_data_size =
1748                         test_priv_data->decomp_produced_data_size;
1749         char **all_decomp_data = test_priv_data->all_decomp_data;
1750
1751         /* from test_data: */
1752         unsigned int out_of_space = test_data->out_of_space;
1753         enum rte_comp_op_type operation_type = test_data->decompress_state;
1754
1755         unsigned int zlib_compress =
1756                         (test_data->zlib_dir == ZLIB_ALL ||
1757                         test_data->zlib_dir == ZLIB_COMPRESS);
1758         unsigned int zlib_decompress =
1759                         (test_data->zlib_dir == ZLIB_ALL ||
1760                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1761
1762         for (i = 0; i < num_bufs; i++) {
1763                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1764                 char engine[] = "zlib, (directly, no PMD)";
1765                 if (zlib_compress)
1766                         strlcpy(engine, "pmd", sizeof(engine));
1767                 RTE_LOG(DEBUG, USER1,
1768                         "Buffer %u decompressed by %s from %u to %u bytes\n",
1769                         buf_idx[priv_data->orig_idx], engine,
1770                         ops_processed[i]->consumed, ops_processed[i]->produced);
1771                 ops[i] = NULL;
1772         }
1773
1774         /*
1775          * Check operation status and free source mbuf (destination mbuf and
1776          * compress operation information is still needed)
1777          */
1778         for (i = 0; i < num_bufs; i++) {
1779                 if (out_of_space && !zlib_decompress) {
1780                         if (ops_processed[i]->status !=
1781                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1782
1783                                 RTE_LOG(ERR, USER1,
1784                                         "Operation without expected out of "
1785                                         "space status error\n");
1786                                 return -1;
1787                         } else
1788                                 continue;
1789                 }
1790
1791                 if (operation_type == RTE_COMP_OP_STATEFUL
1792                         && (ops_processed[i]->status ==
1793                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
1794                             || ops_processed[i]->status ==
1795                                 RTE_COMP_OP_STATUS_SUCCESS)) {
1796
1797                         RTE_LOG(DEBUG, USER1,
1798                                         ".............RECOVERABLE\n");
1799
1800                         /* collect the output into all_decomp_data */
1801                         const void *ptr = rte_pktmbuf_read(
1802                                         ops_processed[i]->m_dst,
1803                                         ops_processed[i]->dst.offset,
1804                                         ops_processed[i]->produced,
1805                                         *all_decomp_data +
1806                                                 *decomp_produced_data_size);
1807                         if (ptr != *all_decomp_data +
1808                                         *decomp_produced_data_size)
1809                                 rte_memcpy(*all_decomp_data +
1810                                            *decomp_produced_data_size,
1811                                            ptr, ops_processed[i]->produced);
1812
1813                         *decomp_produced_data_size +=
1814                                         ops_processed[i]->produced;
1815                         if (ops_processed[i]->src.length >
1816                                         ops_processed[i]->consumed) {
1817                                 if (ops_processed[i]->status ==
1818                                                 RTE_COMP_OP_STATUS_SUCCESS) {
1819                                         RTE_LOG(ERR, USER1,
1820                                               "Operation finished too early\n");
1821                                         return -1;
1822                                 }
1823                                 step++;
1824                                 if (step >= test_data->decompress_steps_max) {
1825                                         RTE_LOG(ERR, USER1,
1826                                           "Operation exceeded maximum steps\n");
1827                                         return -1;
1828                                 }
1829                                 ops[i] = ops_processed[i];
1830                                 ops[i]->status =
1831                                                RTE_COMP_OP_STATUS_NOT_PROCESSED;
1832                                 ops[i]->src.offset +=
1833                                                 ops_processed[i]->consumed;
1834                                 ops[i]->src.length -=
1835                                                 ops_processed[i]->consumed;
1836                                 /* repeat the operation */
1837                                 return 2;
1838                         } else {
1839                                 /* Compare the original stream with the */
1840                                 /* decompressed stream (in size and the data) */
1841                                 priv_data = (struct priv_op_data *)
1842                                                 (ops_processed[i] + 1);
1843                                 const char *buf1 =
1844                                                 test_bufs[priv_data->orig_idx];
1845                                 const char *buf2 = *all_decomp_data;
1846
1847                                 if (compare_buffers(buf1, strlen(buf1) + 1,
1848                                           buf2, *decomp_produced_data_size) < 0)
1849                                         return -1;
1850                                 /* Test checksums */
1851                                 if (compress_xforms[0]->compress.chksum
1852                                                 != RTE_COMP_CHECKSUM_NONE) {
1853                                         if (ops_processed[i]->output_chksum
1854                                                       != compress_checksum[i]) {
1855                                                 RTE_LOG(ERR, USER1,
1856                         "The checksums differ\n"
1857                         "Compression Checksum: %" PRIu64 "\tDecompression "
1858                         "Checksum: %" PRIu64 "\n", compress_checksum[i],
1859                                                ops_processed[i]->output_chksum);
1860                                                 return -1;
1861                                         }
1862                                 }
1863                         }
1864                 } else if (ops_processed[i]->status !=
1865                            RTE_COMP_OP_STATUS_SUCCESS) {
1866                         RTE_LOG(ERR, USER1,
1867                                         "Decomp: Some operations were not successful, status = %u\n",
1868                                         ops_processed[i]->status);
1869                         return -1;
1870                 }
1871                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1872                 rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
1873                 comp_bufs[priv_data->orig_idx] = NULL;
1874         }
1875
1876         if (out_of_space && !zlib_decompress)
1877                 return 1;
1878
1879         return 0;
1880 }
1881
1882 /**
1883  * Validation of the output (compression/decompression) data.
1884  *
1885  * The function compares the source stream with the output stream,
1886  * after decompression, to check if compression/decompression
1887  * was correct.
1888  * -1 returned if function fail.
1889  *
1890  * @param int_data
1891  *   Interim data containing session/transformation objects.
1892  * @param test_data
1893  *   The test parameters set by users (command line parameters).
1894  * @param test_priv_data
1895  *   A container used for aggregation all the private test arrays.
1896  * @return
1897  *   - 0: On success.
1898  *   - -1: On error.
1899  */
1900 static int
1901 test_results_validation(const struct interim_data_params *int_data,
1902                 const struct test_data_params *test_data,
1903                 const struct test_private_arrays *test_priv_data)
1904 {
1905         /* local variables: */
1906         unsigned int i;
1907         struct priv_op_data *priv_data;
1908         const char *buf1;
1909         const char *buf2;
1910         char *contig_buf = NULL;
1911         uint32_t data_size;
1912
1913         /* from int_data: */
1914         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1915         unsigned int num_bufs = int_data->num_bufs;
1916         const char * const *test_bufs = int_data->test_bufs;
1917
1918         /* from test_priv_data: */
1919         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1920         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1921
1922         /*
1923          * Compare the original stream with the decompressed stream
1924          * (in size and the data)
1925          */
1926         for (i = 0; i < num_bufs; i++) {
1927                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1928                 buf1 = test_data->use_external_mbufs ?
1929                                 test_data->inbuf_memzone->addr :
1930                                 test_bufs[priv_data->orig_idx];
1931                 data_size = test_data->use_external_mbufs ?
1932                                 test_data->inbuf_data_size :
1933                                 strlen(buf1) + 1;
1934
1935                 contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
1936                 if (contig_buf == NULL) {
1937                         RTE_LOG(ERR, USER1, "Contiguous buffer could not "
1938                                         "be allocated\n");
1939                         goto exit;
1940                 }
1941
1942                 buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
1943                                 ops_processed[i]->produced, contig_buf);
1944                 if (compare_buffers(buf1, data_size,
1945                                 buf2, ops_processed[i]->produced) < 0)
1946                         goto exit;
1947
1948                 /* Test checksums */
1949                 if (compress_xforms[0]->compress.chksum !=
1950                                 RTE_COMP_CHECKSUM_NONE) {
1951                         if (ops_processed[i]->output_chksum !=
1952                                         compress_checksum[i]) {
1953                                 RTE_LOG(ERR, USER1, "The checksums differ\n"
1954                         "Compression Checksum: %" PRIu64 "\tDecompression "
1955                         "Checksum: %" PRIu64 "\n", compress_checksum[i],
1956                         ops_processed[i]->output_chksum);
1957                                 goto exit;
1958                         }
1959                 }
1960
1961                 rte_free(contig_buf);
1962                 contig_buf = NULL;
1963         }
1964         return 0;
1965
1966 exit:
1967         rte_free(contig_buf);
1968         return -1;
1969 }
1970
1971 /**
1972  * Compresses and decompresses input stream with compressdev API and Zlib API
1973  *
1974  * Basic test function. Common for all the functional tests.
1975  * -1 returned if function fail.
1976  *
1977  * @param int_data
1978  *   Interim data containing session/transformation objects.
1979  * @param test_data
1980  *   The test parameters set by users (command line parameters).
1981  * @return
1982  *   - 1: Some operation not supported
1983  *   - 0: On success.
1984  *   - -1: On error.
1985  */
1986
1987 static int
1988 test_deflate_comp_decomp(const struct interim_data_params *int_data,
1989                 const struct test_data_params *test_data)
1990 {
1991         unsigned int num_bufs = int_data->num_bufs;
1992         unsigned int out_of_space = test_data->out_of_space;
1993
1994         void *stream = NULL;
1995         char *all_decomp_data = NULL;
1996         unsigned int decomp_produced_data_size = 0;
1997
1998         int ret_status = -1;
1999         int ret;
2000         struct rte_mbuf *uncomp_bufs[num_bufs];
2001         struct rte_mbuf *comp_bufs[num_bufs];
2002         struct rte_comp_op *ops[num_bufs];
2003         struct rte_comp_op *ops_processed[num_bufs];
2004         void *priv_xforms[num_bufs];
2005         unsigned int i;
2006
2007         uint64_t compress_checksum[num_bufs];
2008         uint32_t compressed_data_size[num_bufs];
2009         char *contig_buf = NULL;
2010
2011         struct rte_mbuf_ext_shared_info compbuf_info;
2012         struct rte_mbuf_ext_shared_info decompbuf_info;
2013
2014         const struct rte_compressdev_capabilities *capa;
2015
2016         /* Compressing with CompressDev */
2017         unsigned int zlib_compress =
2018                         (test_data->zlib_dir == ZLIB_ALL ||
2019                         test_data->zlib_dir == ZLIB_COMPRESS);
2020         unsigned int zlib_decompress =
2021                         (test_data->zlib_dir == ZLIB_ALL ||
2022                         test_data->zlib_dir == ZLIB_DECOMPRESS);
2023
2024         struct test_private_arrays test_priv_data;
2025
2026         test_priv_data.uncomp_bufs = uncomp_bufs;
2027         test_priv_data.comp_bufs = comp_bufs;
2028         test_priv_data.ops = ops;
2029         test_priv_data.ops_processed = ops_processed;
2030         test_priv_data.priv_xforms = priv_xforms;
2031         test_priv_data.compress_checksum = compress_checksum;
2032         test_priv_data.compressed_data_size = compressed_data_size;
2033
2034         test_priv_data.stream = &stream;
2035         test_priv_data.all_decomp_data = &all_decomp_data;
2036         test_priv_data.decomp_produced_data_size = &decomp_produced_data_size;
2037
2038         test_priv_data.num_priv_xforms = 0; /* it's used for deompression only */
2039
2040         capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2041         if (capa == NULL) {
2042                 RTE_LOG(ERR, USER1,
2043                         "Compress device does not support DEFLATE\n");
2044                 return -1;
2045         }
2046
2047         /* Prepare the source mbufs with the data */
2048         ret = test_setup_com_bufs(int_data, test_data, &test_priv_data);
2049         if (ret < 0) {
2050                 ret_status = -1;
2051                 goto exit;
2052         }
2053
2054         RTE_LOG(DEBUG, USER1, "<<< COMPRESSION >>>\n");
2055
2056 /* COMPRESSION  */
2057
2058         /* Prepare output (destination) mbufs for compressed data */
2059         ret = test_setup_output_bufs(
2060                         OPERATION_COMPRESSION,
2061                         out_of_space == 1 && !zlib_compress,
2062                         &test_priv_data,
2063                         int_data,
2064                         test_data,
2065                         &compbuf_info);
2066         if (ret < 0) {
2067                 ret_status = -1;
2068                 goto exit;
2069         }
2070
2071         /* Run compression */
2072         ret = test_deflate_comp_run(int_data, test_data, &test_priv_data);
2073         if (ret < 0) {
2074                 ret_status = -1;
2075                 goto exit;
2076         }
2077
2078         ret = test_deflate_comp_finalize(int_data, test_data, &test_priv_data);
2079         if (ret < 0) {
2080                 ret_status = -1;
2081                 goto exit;
2082         } else if (ret == 1) {
2083                 ret_status = 0;
2084                 goto exit;
2085         } else if (ret == 2) {
2086                 ret_status = 1;  /* some operation not supported */
2087                 goto exit;
2088         }
2089
2090 /* DECOMPRESSION  */
2091
2092         RTE_LOG(DEBUG, USER1, "<<< DECOMPRESSION >>>\n");
2093
2094         /* Prepare output (destination) mbufs for decompressed data */
2095         ret = test_setup_output_bufs(
2096                         OPERATION_DECOMPRESSION,
2097                         out_of_space == 1 && !zlib_decompress,
2098                         &test_priv_data,
2099                         int_data,
2100                         test_data,
2101                         &decompbuf_info);
2102         if (ret < 0) {
2103                 ret_status = -1;
2104                 goto exit;
2105         }
2106
2107         /* Run decompression */
2108         ret = test_deflate_decomp_run(int_data, test_data, &test_priv_data);
2109         if (ret < 0) {
2110                 ret_status = -1;
2111                 goto exit;
2112         }
2113
2114         if (!zlib_decompress) {
2115 next_step:      /* next step for stateful decompression only */
2116                 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
2117                 if (ret < 0) {
2118                         ret_status = -1;
2119                         RTE_LOG(ERR, USER1,
2120                                 "Decompression: enqueue/dequeue operation failed\n");
2121                 }
2122         }
2123
2124         ret = test_deflate_decomp_finalize(int_data, test_data, &test_priv_data);
2125         if (ret < 0) {
2126                 ret_status = -1;
2127                 goto exit;
2128         } else if (ret == 1) {
2129                 ret_status = 0;
2130                 goto exit;
2131         } else if (ret == 2) {
2132                 goto next_step;
2133         }
2134
2135 /* FINAL PROCESSING  */
2136
2137         ret = test_results_validation(int_data, test_data, &test_priv_data);
2138         if (ret < 0) {
2139                 ret_status = -1;
2140                 goto exit;
2141         }
2142         ret_status = 0;
2143
2144 exit:
2145         /* Free resources */
2146
2147         if (stream != NULL)
2148                 rte_compressdev_stream_free(0, stream);
2149         if (all_decomp_data != NULL)
2150                 rte_free(all_decomp_data);
2151
2152         /* Free compress private xforms */
2153         for (i = 0; i < test_priv_data.num_priv_xforms; i++) {
2154                 if (priv_xforms[i] != NULL) {
2155                         rte_compressdev_private_xform_free(0, priv_xforms[i]);
2156                         priv_xforms[i] = NULL;
2157                 }
2158         }
2159         for (i = 0; i < num_bufs; i++) {
2160                 rte_pktmbuf_free(uncomp_bufs[i]);
2161                 rte_pktmbuf_free(comp_bufs[i]);
2162                 rte_comp_op_free(ops[i]);
2163                 rte_comp_op_free(ops_processed[i]);
2164         }
2165         rte_free(contig_buf);
2166
2167         return ret_status;
2168 }
2169
2170 static int
2171 test_compressdev_deflate_stateless_fixed(void)
2172 {
2173         struct comp_testsuite_params *ts_params = &testsuite_params;
2174         uint16_t i;
2175         int ret;
2176         const struct rte_compressdev_capabilities *capab;
2177
2178         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2179         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2180
2181         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2182                 return -ENOTSUP;
2183
2184         struct rte_comp_xform *compress_xform =
2185                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2186
2187         if (compress_xform == NULL) {
2188                 RTE_LOG(ERR, USER1,
2189                         "Compress xform could not be created\n");
2190                 ret = TEST_FAILED;
2191                 goto exit;
2192         }
2193
2194         memcpy(compress_xform, ts_params->def_comp_xform,
2195                         sizeof(struct rte_comp_xform));
2196         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
2197
2198         struct interim_data_params int_data = {
2199                 NULL,
2200                 1,
2201                 NULL,
2202                 &compress_xform,
2203                 &ts_params->def_decomp_xform,
2204                 1
2205         };
2206
2207         struct test_data_params test_data = {
2208                 .compress_state = RTE_COMP_OP_STATELESS,
2209                 .decompress_state = RTE_COMP_OP_STATELESS,
2210                 .buff_type = LB_BOTH,
2211                 .zlib_dir = ZLIB_DECOMPRESS,
2212                 .out_of_space = 0,
2213                 .big_data = 0,
2214                 .overflow = OVERFLOW_DISABLED,
2215                 .ratio = RATIO_ENABLED
2216         };
2217
2218         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2219                 int_data.test_bufs = &compress_test_bufs[i];
2220                 int_data.buf_idx = &i;
2221
2222                 /* Compress with compressdev, decompress with Zlib */
2223                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2224                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2225                 if (ret < 0)
2226                         goto exit;
2227
2228                 /* Compress with Zlib, decompress with compressdev */
2229                 test_data.zlib_dir = ZLIB_COMPRESS;
2230                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2231                 if (ret < 0)
2232                         goto exit;
2233         }
2234
2235         ret = TEST_SUCCESS;
2236
2237 exit:
2238         rte_free(compress_xform);
2239         return ret;
2240 }
2241
2242 static int
2243 test_compressdev_deflate_stateless_dynamic(void)
2244 {
2245         struct comp_testsuite_params *ts_params = &testsuite_params;
2246         uint16_t i;
2247         int ret;
2248         struct rte_comp_xform *compress_xform =
2249                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2250
2251         const struct rte_compressdev_capabilities *capab;
2252
2253         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2254         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2255
2256         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2257                 return -ENOTSUP;
2258
2259         if (compress_xform == NULL) {
2260                 RTE_LOG(ERR, USER1,
2261                         "Compress xform could not be created\n");
2262                 ret = TEST_FAILED;
2263                 goto exit;
2264         }
2265
2266         memcpy(compress_xform, ts_params->def_comp_xform,
2267                         sizeof(struct rte_comp_xform));
2268         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC;
2269
2270         struct interim_data_params int_data = {
2271                 NULL,
2272                 1,
2273                 NULL,
2274                 &compress_xform,
2275                 &ts_params->def_decomp_xform,
2276                 1
2277         };
2278
2279         struct test_data_params test_data = {
2280                 .compress_state = RTE_COMP_OP_STATELESS,
2281                 .decompress_state = RTE_COMP_OP_STATELESS,
2282                 .buff_type = LB_BOTH,
2283                 .zlib_dir = ZLIB_DECOMPRESS,
2284                 .out_of_space = 0,
2285                 .big_data = 0,
2286                 .overflow = OVERFLOW_DISABLED,
2287                 .ratio = RATIO_ENABLED
2288         };
2289
2290         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2291                 int_data.test_bufs = &compress_test_bufs[i];
2292                 int_data.buf_idx = &i;
2293
2294                 /* Compress with compressdev, decompress with Zlib */
2295                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2296                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2297                 if (ret < 0)
2298                         goto exit;
2299
2300                 /* Compress with Zlib, decompress with compressdev */
2301                 test_data.zlib_dir = ZLIB_COMPRESS;
2302                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2303                 if (ret < 0)
2304                         goto exit;
2305         }
2306
2307         ret = TEST_SUCCESS;
2308
2309 exit:
2310         rte_free(compress_xform);
2311         return ret;
2312 }
2313
2314 static int
2315 test_compressdev_deflate_stateless_multi_op(void)
2316 {
2317         struct comp_testsuite_params *ts_params = &testsuite_params;
2318         uint16_t num_bufs = RTE_DIM(compress_test_bufs);
2319         uint16_t buf_idx[num_bufs];
2320         uint16_t i;
2321         int ret;
2322
2323         for (i = 0; i < num_bufs; i++)
2324                 buf_idx[i] = i;
2325
2326         struct interim_data_params int_data = {
2327                 compress_test_bufs,
2328                 num_bufs,
2329                 buf_idx,
2330                 &ts_params->def_comp_xform,
2331                 &ts_params->def_decomp_xform,
2332                 1
2333         };
2334
2335         struct test_data_params test_data = {
2336                 .compress_state = RTE_COMP_OP_STATELESS,
2337                 .decompress_state = RTE_COMP_OP_STATELESS,
2338                 .buff_type = LB_BOTH,
2339                 .zlib_dir = ZLIB_DECOMPRESS,
2340                 .out_of_space = 0,
2341                 .big_data = 0,
2342                 .overflow = OVERFLOW_DISABLED,
2343                 .ratio = RATIO_ENABLED
2344         };
2345
2346         /* Compress with compressdev, decompress with Zlib */
2347         test_data.zlib_dir = ZLIB_DECOMPRESS;
2348         ret = test_deflate_comp_decomp(&int_data, &test_data);
2349         if (ret < 0)
2350                 return ret;
2351
2352         /* Compress with Zlib, decompress with compressdev */
2353         test_data.zlib_dir = ZLIB_COMPRESS;
2354         ret = test_deflate_comp_decomp(&int_data, &test_data);
2355         if (ret < 0)
2356                 return ret;
2357
2358         return TEST_SUCCESS;
2359 }
2360
2361 static int
2362 test_compressdev_deflate_stateless_multi_level(void)
2363 {
2364         struct comp_testsuite_params *ts_params = &testsuite_params;
2365         unsigned int level;
2366         uint16_t i;
2367         int ret;
2368         struct rte_comp_xform *compress_xform =
2369                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2370
2371         if (compress_xform == NULL) {
2372                 RTE_LOG(ERR, USER1,
2373                         "Compress xform could not be created\n");
2374                 ret = TEST_FAILED;
2375                 goto exit;
2376         }
2377
2378         memcpy(compress_xform, ts_params->def_comp_xform,
2379                         sizeof(struct rte_comp_xform));
2380
2381         struct interim_data_params int_data = {
2382                 NULL,
2383                 1,
2384                 NULL,
2385                 &compress_xform,
2386                 &ts_params->def_decomp_xform,
2387                 1
2388         };
2389
2390         struct test_data_params test_data = {
2391                 .compress_state = RTE_COMP_OP_STATELESS,
2392                 .decompress_state = RTE_COMP_OP_STATELESS,
2393                 .buff_type = LB_BOTH,
2394                 .zlib_dir = ZLIB_DECOMPRESS,
2395                 .out_of_space = 0,
2396                 .big_data = 0,
2397                 .overflow = OVERFLOW_DISABLED,
2398                 .ratio = RATIO_ENABLED
2399         };
2400
2401         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2402                 int_data.test_bufs = &compress_test_bufs[i];
2403                 int_data.buf_idx = &i;
2404
2405                 for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX;
2406                                 level++) {
2407                         compress_xform->compress.level = level;
2408                         /* Compress with compressdev, decompress with Zlib */
2409                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2410                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2411                         if (ret < 0)
2412                                 goto exit;
2413                 }
2414         }
2415
2416         ret = TEST_SUCCESS;
2417
2418 exit:
2419         rte_free(compress_xform);
2420         return ret;
2421 }
2422
2423 #define NUM_XFORMS 3
2424 static int
2425 test_compressdev_deflate_stateless_multi_xform(void)
2426 {
2427         struct comp_testsuite_params *ts_params = &testsuite_params;
2428         uint16_t num_bufs = NUM_XFORMS;
2429         struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL};
2430         struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL};
2431         const char *test_buffers[NUM_XFORMS];
2432         uint16_t i;
2433         unsigned int level = RTE_COMP_LEVEL_MIN;
2434         uint16_t buf_idx[num_bufs];
2435         int ret;
2436
2437         /* Create multiple xforms with various levels */
2438         for (i = 0; i < NUM_XFORMS; i++) {
2439                 compress_xforms[i] = rte_malloc(NULL,
2440                                 sizeof(struct rte_comp_xform), 0);
2441                 if (compress_xforms[i] == NULL) {
2442                         RTE_LOG(ERR, USER1,
2443                                 "Compress xform could not be created\n");
2444                         ret = TEST_FAILED;
2445                         goto exit;
2446                 }
2447
2448                 memcpy(compress_xforms[i], ts_params->def_comp_xform,
2449                                 sizeof(struct rte_comp_xform));
2450                 compress_xforms[i]->compress.level = level;
2451                 level++;
2452
2453                 decompress_xforms[i] = rte_malloc(NULL,
2454                                 sizeof(struct rte_comp_xform), 0);
2455                 if (decompress_xforms[i] == NULL) {
2456                         RTE_LOG(ERR, USER1,
2457                                 "Decompress xform could not be created\n");
2458                         ret = TEST_FAILED;
2459                         goto exit;
2460                 }
2461
2462                 memcpy(decompress_xforms[i], ts_params->def_decomp_xform,
2463                                 sizeof(struct rte_comp_xform));
2464         }
2465
2466         for (i = 0; i < NUM_XFORMS; i++) {
2467                 buf_idx[i] = 0;
2468                 /* Use the same buffer in all sessions */
2469                 test_buffers[i] = compress_test_bufs[0];
2470         }
2471
2472         struct interim_data_params int_data = {
2473                 test_buffers,
2474                 num_bufs,
2475                 buf_idx,
2476                 compress_xforms,
2477                 decompress_xforms,
2478                 NUM_XFORMS
2479         };
2480
2481         struct test_data_params test_data = {
2482                 .compress_state = RTE_COMP_OP_STATELESS,
2483                 .decompress_state = RTE_COMP_OP_STATELESS,
2484                 .buff_type = LB_BOTH,
2485                 .zlib_dir = ZLIB_DECOMPRESS,
2486                 .out_of_space = 0,
2487                 .big_data = 0,
2488                 .overflow = OVERFLOW_DISABLED,
2489                 .ratio = RATIO_ENABLED
2490         };
2491
2492         /* Compress with compressdev, decompress with Zlib */
2493         ret = test_deflate_comp_decomp(&int_data, &test_data);
2494         if (ret < 0)
2495                 goto exit;
2496
2497         ret = TEST_SUCCESS;
2498
2499 exit:
2500         for (i = 0; i < NUM_XFORMS; i++) {
2501                 rte_free(compress_xforms[i]);
2502                 rte_free(decompress_xforms[i]);
2503         }
2504
2505         return ret;
2506 }
2507
2508 static int
2509 test_compressdev_deflate_stateless_sgl(void)
2510 {
2511         struct comp_testsuite_params *ts_params = &testsuite_params;
2512         uint16_t i;
2513         int ret;
2514         const struct rte_compressdev_capabilities *capab;
2515
2516         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2517         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2518
2519         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2520                 return -ENOTSUP;
2521
2522         struct interim_data_params int_data = {
2523                 NULL,
2524                 1,
2525                 NULL,
2526                 &ts_params->def_comp_xform,
2527                 &ts_params->def_decomp_xform,
2528                 1
2529         };
2530
2531         struct test_data_params test_data = {
2532                 .compress_state = RTE_COMP_OP_STATELESS,
2533                 .decompress_state = RTE_COMP_OP_STATELESS,
2534                 .buff_type = SGL_BOTH,
2535                 .zlib_dir = ZLIB_DECOMPRESS,
2536                 .out_of_space = 0,
2537                 .big_data = 0,
2538                 .overflow = OVERFLOW_DISABLED,
2539                 .ratio = RATIO_ENABLED
2540         };
2541
2542         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2543                 int_data.test_bufs = &compress_test_bufs[i];
2544                 int_data.buf_idx = &i;
2545
2546                 /* Compress with compressdev, decompress with Zlib */
2547                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2548                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2549                 if (ret < 0)
2550                         return ret;
2551
2552                 /* Compress with Zlib, decompress with compressdev */
2553                 test_data.zlib_dir = ZLIB_COMPRESS;
2554                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2555                 if (ret < 0)
2556                         return ret;
2557
2558                 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) {
2559                         /* Compress with compressdev, decompress with Zlib */
2560                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2561                         test_data.buff_type = SGL_TO_LB;
2562                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2563                         if (ret < 0)
2564                                 return ret;
2565
2566                         /* Compress with Zlib, decompress with compressdev */
2567                         test_data.zlib_dir = ZLIB_COMPRESS;
2568                         test_data.buff_type = SGL_TO_LB;
2569                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2570                         if (ret < 0)
2571                                 return ret;
2572                 }
2573
2574                 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) {
2575                         /* Compress with compressdev, decompress with Zlib */
2576                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2577                         test_data.buff_type = LB_TO_SGL;
2578                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2579                         if (ret < 0)
2580                                 return ret;
2581
2582                         /* Compress with Zlib, decompress with compressdev */
2583                         test_data.zlib_dir = ZLIB_COMPRESS;
2584                         test_data.buff_type = LB_TO_SGL;
2585                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2586                         if (ret < 0)
2587                                 return ret;
2588                 }
2589         }
2590
2591         return TEST_SUCCESS;
2592 }
2593
2594 static int
2595 test_compressdev_deflate_stateless_checksum(void)
2596 {
2597         struct comp_testsuite_params *ts_params = &testsuite_params;
2598         uint16_t i;
2599         int ret;
2600         const struct rte_compressdev_capabilities *capab;
2601
2602         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2603         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2604
2605         /* Check if driver supports any checksum */
2606         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 &&
2607                         (capab->comp_feature_flags &
2608                         RTE_COMP_FF_ADLER32_CHECKSUM) == 0 &&
2609                         (capab->comp_feature_flags &
2610                         RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 0)
2611                 return -ENOTSUP;
2612
2613         struct rte_comp_xform *compress_xform =
2614                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2615         if (compress_xform == NULL) {
2616                 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2617                 return TEST_FAILED;
2618         }
2619
2620         memcpy(compress_xform, ts_params->def_comp_xform,
2621                         sizeof(struct rte_comp_xform));
2622
2623         struct rte_comp_xform *decompress_xform =
2624                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2625         if (decompress_xform == NULL) {
2626                 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2627                 rte_free(compress_xform);
2628                 return TEST_FAILED;
2629         }
2630
2631         memcpy(decompress_xform, ts_params->def_decomp_xform,
2632                         sizeof(struct rte_comp_xform));
2633
2634         struct interim_data_params int_data = {
2635                 NULL,
2636                 1,
2637                 NULL,
2638                 &compress_xform,
2639                 &decompress_xform,
2640                 1
2641         };
2642
2643         struct test_data_params test_data = {
2644                 .compress_state = RTE_COMP_OP_STATELESS,
2645                 .decompress_state = RTE_COMP_OP_STATELESS,
2646                 .buff_type = LB_BOTH,
2647                 .zlib_dir = ZLIB_DECOMPRESS,
2648                 .out_of_space = 0,
2649                 .big_data = 0,
2650                 .overflow = OVERFLOW_DISABLED,
2651                 .ratio = RATIO_ENABLED
2652         };
2653
2654         /* Check if driver supports crc32 checksum and test */
2655         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) {
2656                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
2657                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
2658
2659                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2660                         /* Compress with compressdev, decompress with Zlib */
2661                         int_data.test_bufs = &compress_test_bufs[i];
2662                         int_data.buf_idx = &i;
2663
2664                         /* Generate zlib checksum and test against selected
2665                          * drivers decompression checksum
2666                          */
2667                         test_data.zlib_dir = ZLIB_COMPRESS;
2668                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2669                         if (ret < 0)
2670                                 goto exit;
2671
2672                         /* Generate compression and decompression
2673                          * checksum of selected driver
2674                          */
2675                         test_data.zlib_dir = ZLIB_NONE;
2676                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2677                         if (ret < 0)
2678                                 goto exit;
2679                 }
2680         }
2681
2682         /* Check if driver supports adler32 checksum and test */
2683         if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) {
2684                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2685                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2686
2687                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2688                         int_data.test_bufs = &compress_test_bufs[i];
2689                         int_data.buf_idx = &i;
2690
2691                         /* Generate zlib checksum and test against selected
2692                          * drivers decompression checksum
2693                          */
2694                         test_data.zlib_dir = ZLIB_COMPRESS;
2695                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2696                         if (ret < 0)
2697                                 goto exit;
2698                         /* Generate compression and decompression
2699                          * checksum of selected driver
2700                          */
2701                         test_data.zlib_dir = ZLIB_NONE;
2702                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2703                         if (ret < 0)
2704                                 goto exit;
2705                 }
2706         }
2707
2708         /* Check if driver supports combined crc and adler checksum and test */
2709         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) {
2710                 compress_xform->compress.chksum =
2711                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2712                 decompress_xform->decompress.chksum =
2713                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2714
2715                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2716                         int_data.test_bufs = &compress_test_bufs[i];
2717                         int_data.buf_idx = &i;
2718
2719                         /* Generate compression and decompression
2720                          * checksum of selected driver
2721                          */
2722                         test_data.zlib_dir = ZLIB_NONE;
2723                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2724                         if (ret < 0)
2725                                 goto exit;
2726                 }
2727         }
2728
2729         ret = TEST_SUCCESS;
2730
2731 exit:
2732         rte_free(compress_xform);
2733         rte_free(decompress_xform);
2734         return ret;
2735 }
2736
2737 static int
2738 test_compressdev_out_of_space_buffer(void)
2739 {
2740         struct comp_testsuite_params *ts_params = &testsuite_params;
2741         int ret;
2742         uint16_t i;
2743         const struct rte_compressdev_capabilities *capab;
2744
2745         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
2746
2747         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2748         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2749
2750         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2751                 return -ENOTSUP;
2752
2753         struct interim_data_params int_data = {
2754                 &compress_test_bufs[0],
2755                 1,
2756                 &i,
2757                 &ts_params->def_comp_xform,
2758                 &ts_params->def_decomp_xform,
2759                 1
2760         };
2761
2762         struct test_data_params test_data = {
2763                 .compress_state = RTE_COMP_OP_STATELESS,
2764                 .decompress_state = RTE_COMP_OP_STATELESS,
2765                 .buff_type = LB_BOTH,
2766                 .zlib_dir = ZLIB_DECOMPRESS,
2767                 .out_of_space = 1,  /* run out-of-space test */
2768                 .big_data = 0,
2769                 .overflow = OVERFLOW_DISABLED,
2770                 .ratio = RATIO_ENABLED
2771         };
2772         /* Compress with compressdev, decompress with Zlib */
2773         test_data.zlib_dir = ZLIB_DECOMPRESS;
2774         ret = test_deflate_comp_decomp(&int_data, &test_data);
2775         if (ret < 0)
2776                 goto exit;
2777
2778         /* Compress with Zlib, decompress with compressdev */
2779         test_data.zlib_dir = ZLIB_COMPRESS;
2780         ret = test_deflate_comp_decomp(&int_data, &test_data);
2781         if (ret < 0)
2782                 goto exit;
2783
2784         if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2785                 /* Compress with compressdev, decompress with Zlib */
2786                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2787                 test_data.buff_type = SGL_BOTH;
2788                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2789                 if (ret < 0)
2790                         goto exit;
2791
2792                 /* Compress with Zlib, decompress with compressdev */
2793                 test_data.zlib_dir = ZLIB_COMPRESS;
2794                 test_data.buff_type = SGL_BOTH;
2795                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2796                 if (ret < 0)
2797                         goto exit;
2798         }
2799
2800         ret  = TEST_SUCCESS;
2801
2802 exit:
2803         return ret;
2804 }
2805
2806 static int
2807 test_compressdev_deflate_stateless_dynamic_big(void)
2808 {
2809         struct comp_testsuite_params *ts_params = &testsuite_params;
2810         uint16_t i = 0;
2811         int ret;
2812         unsigned int j;
2813         const struct rte_compressdev_capabilities *capab;
2814         char *test_buffer = NULL;
2815
2816         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2817         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2818
2819         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2820                 return -ENOTSUP;
2821
2822         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2823                 return -ENOTSUP;
2824
2825         test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0);
2826         if (test_buffer == NULL) {
2827                 RTE_LOG(ERR, USER1,
2828                         "Can't allocate buffer for big-data\n");
2829                 return TEST_FAILED;
2830         }
2831
2832         struct interim_data_params int_data = {
2833                 (const char * const *)&test_buffer,
2834                 1,
2835                 &i,
2836                 &ts_params->def_comp_xform,
2837                 &ts_params->def_decomp_xform,
2838                 1
2839         };
2840
2841         struct test_data_params test_data = {
2842                 .compress_state = RTE_COMP_OP_STATELESS,
2843                 .decompress_state = RTE_COMP_OP_STATELESS,
2844                 .buff_type = SGL_BOTH,
2845                 .zlib_dir = ZLIB_DECOMPRESS,
2846                 .out_of_space = 0,
2847                 .big_data = 1,
2848                 .overflow = OVERFLOW_DISABLED,
2849                 .ratio = RATIO_DISABLED
2850         };
2851
2852         ts_params->def_comp_xform->compress.deflate.huffman =
2853                                                 RTE_COMP_HUFFMAN_DYNAMIC;
2854
2855         /* fill the buffer with data based on rand. data */
2856         srand(BIG_DATA_TEST_SIZE);
2857         for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j)
2858                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
2859         test_buffer[BIG_DATA_TEST_SIZE - 1] = 0;
2860
2861         /* Compress with compressdev, decompress with Zlib */
2862         test_data.zlib_dir = ZLIB_DECOMPRESS;
2863         ret = test_deflate_comp_decomp(&int_data, &test_data);
2864         if (ret < 0)
2865                 goto exit;
2866
2867         /* Compress with Zlib, decompress with compressdev */
2868         test_data.zlib_dir = ZLIB_COMPRESS;
2869         ret = test_deflate_comp_decomp(&int_data, &test_data);
2870         if (ret < 0)
2871                 goto exit;
2872
2873         ret = TEST_SUCCESS;
2874
2875 exit:
2876         ts_params->def_comp_xform->compress.deflate.huffman =
2877                                                 RTE_COMP_HUFFMAN_DEFAULT;
2878         rte_free(test_buffer);
2879         return ret;
2880 }
2881
2882 static int
2883 test_compressdev_deflate_stateful_decomp(void)
2884 {
2885         struct comp_testsuite_params *ts_params = &testsuite_params;
2886         int ret;
2887         uint16_t i;
2888         const struct rte_compressdev_capabilities *capab;
2889
2890         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2891         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2892
2893         if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2894                 return -ENOTSUP;
2895
2896         struct interim_data_params int_data = {
2897                 &compress_test_bufs[0],
2898                 1,
2899                 &i,
2900                 &ts_params->def_comp_xform,
2901                 &ts_params->def_decomp_xform,
2902                 1
2903         };
2904
2905         struct test_data_params test_data = {
2906                 .compress_state = RTE_COMP_OP_STATELESS,
2907                 .decompress_state = RTE_COMP_OP_STATEFUL,
2908                 .buff_type = LB_BOTH,
2909                 .zlib_dir = ZLIB_COMPRESS,
2910                 .out_of_space = 0,
2911                 .big_data = 0,
2912                 .decompress_output_block_size = 2000,
2913                 .decompress_steps_max = 4,
2914                 .overflow = OVERFLOW_DISABLED,
2915                 .ratio = RATIO_ENABLED
2916         };
2917
2918         /* Compress with Zlib, decompress with compressdev */
2919         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2920                 ret = TEST_FAILED;
2921                 goto exit;
2922         }
2923
2924         if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2925                 /* Now test with SGL buffers */
2926                 test_data.buff_type = SGL_BOTH;
2927                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2928                         ret = TEST_FAILED;
2929                         goto exit;
2930                 }
2931         }
2932
2933         ret  = TEST_SUCCESS;
2934
2935 exit:
2936         return ret;
2937 }
2938
2939 static int
2940 test_compressdev_deflate_stateful_decomp_checksum(void)
2941 {
2942         struct comp_testsuite_params *ts_params = &testsuite_params;
2943         int ret;
2944         uint16_t i;
2945         const struct rte_compressdev_capabilities *capab;
2946
2947         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2948         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2949
2950         if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2951                 return -ENOTSUP;
2952
2953         /* Check if driver supports any checksum */
2954         if (!(capab->comp_feature_flags &
2955              (RTE_COMP_FF_CRC32_CHECKSUM | RTE_COMP_FF_ADLER32_CHECKSUM |
2956               RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)))
2957                 return -ENOTSUP;
2958
2959         struct rte_comp_xform *compress_xform =
2960                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2961         if (compress_xform == NULL) {
2962                 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2963                 return TEST_FAILED;
2964         }
2965
2966         memcpy(compress_xform, ts_params->def_comp_xform,
2967                sizeof(struct rte_comp_xform));
2968
2969         struct rte_comp_xform *decompress_xform =
2970                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2971         if (decompress_xform == NULL) {
2972                 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2973                 rte_free(compress_xform);
2974                 return TEST_FAILED;
2975         }
2976
2977         memcpy(decompress_xform, ts_params->def_decomp_xform,
2978                sizeof(struct rte_comp_xform));
2979
2980         struct interim_data_params int_data = {
2981                 &compress_test_bufs[0],
2982                 1,
2983                 &i,
2984                 &compress_xform,
2985                 &decompress_xform,
2986                 1
2987         };
2988
2989         struct test_data_params test_data = {
2990                 .compress_state = RTE_COMP_OP_STATELESS,
2991                 .decompress_state = RTE_COMP_OP_STATEFUL,
2992                 .buff_type = LB_BOTH,
2993                 .zlib_dir = ZLIB_COMPRESS,
2994                 .out_of_space = 0,
2995                 .big_data = 0,
2996                 .decompress_output_block_size = 2000,
2997                 .decompress_steps_max = 4,
2998                 .overflow = OVERFLOW_DISABLED,
2999                 .ratio = RATIO_ENABLED
3000         };
3001
3002         /* Check if driver supports crc32 checksum and test */
3003         if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) {
3004                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
3005                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
3006                 /* Compress with Zlib, decompress with compressdev */
3007                 test_data.buff_type = LB_BOTH;
3008                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3009                         ret = TEST_FAILED;
3010                         goto exit;
3011                 }
3012                 if (capab->comp_feature_flags &
3013                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3014                         /* Now test with SGL buffers */
3015                         test_data.buff_type = SGL_BOTH;
3016                         if (test_deflate_comp_decomp(&int_data,
3017                                                      &test_data) < 0) {
3018                                 ret = TEST_FAILED;
3019                                 goto exit;
3020                         }
3021                 }
3022         }
3023
3024         /* Check if driver supports adler32 checksum and test */
3025         if (capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM) {
3026                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
3027                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
3028                 /* Compress with Zlib, decompress with compressdev */
3029                 test_data.buff_type = LB_BOTH;
3030                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3031                         ret = TEST_FAILED;
3032                         goto exit;
3033                 }
3034                 if (capab->comp_feature_flags &
3035                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3036                         /* Now test with SGL buffers */
3037                         test_data.buff_type = SGL_BOTH;
3038                         if (test_deflate_comp_decomp(&int_data,
3039                                                      &test_data) < 0) {
3040                                 ret = TEST_FAILED;
3041                                 goto exit;
3042                         }
3043                 }
3044         }
3045
3046         /* Check if driver supports combined crc and adler checksum and test */
3047         if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) {
3048                 compress_xform->compress.chksum =
3049                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
3050                 decompress_xform->decompress.chksum =
3051                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
3052                 /* Zlib doesn't support combined checksum */
3053                 test_data.zlib_dir = ZLIB_NONE;
3054                 /* Compress stateless, decompress stateful with compressdev */
3055                 test_data.buff_type = LB_BOTH;
3056                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3057                         ret = TEST_FAILED;
3058                         goto exit;
3059                 }
3060                 if (capab->comp_feature_flags &
3061                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
3062                         /* Now test with SGL buffers */
3063                         test_data.buff_type = SGL_BOTH;
3064                         if (test_deflate_comp_decomp(&int_data,
3065                                                      &test_data) < 0) {
3066                                 ret = TEST_FAILED;
3067                                 goto exit;
3068                         }
3069                 }
3070         }
3071
3072         ret  = TEST_SUCCESS;
3073
3074 exit:
3075         rte_free(compress_xform);
3076         rte_free(decompress_xform);
3077         return ret;
3078 }
3079
3080 static const struct rte_memzone *
3081 make_memzone(const char *name, size_t size)
3082 {
3083         unsigned int socket_id = rte_socket_id();
3084         char mz_name[RTE_MEMZONE_NAMESIZE];
3085         const struct rte_memzone *memzone;
3086
3087         snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id);
3088         memzone = rte_memzone_lookup(mz_name);
3089         if (memzone != NULL && memzone->len != size) {
3090                 rte_memzone_free(memzone);
3091                 memzone = NULL;
3092         }
3093         if (memzone == NULL) {
3094                 memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
3095                                 RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
3096                 if (memzone == NULL)
3097                         RTE_LOG(ERR, USER1, "Can't allocate memory zone %s",
3098                                 mz_name);
3099         }
3100         return memzone;
3101 }
3102
3103 static int
3104 test_compressdev_external_mbufs(void)
3105 {
3106         struct comp_testsuite_params *ts_params = &testsuite_params;
3107         size_t data_len = 0;
3108         uint16_t i;
3109         int ret = TEST_FAILED;
3110
3111         for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
3112                 data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
3113
3114         struct interim_data_params int_data = {
3115                 NULL,
3116                 1,
3117                 NULL,
3118                 &ts_params->def_comp_xform,
3119                 &ts_params->def_decomp_xform,
3120                 1
3121         };
3122
3123         struct test_data_params test_data = {
3124                 .compress_state = RTE_COMP_OP_STATELESS,
3125                 .decompress_state = RTE_COMP_OP_STATELESS,
3126                 .buff_type = LB_BOTH,
3127                 .zlib_dir = ZLIB_DECOMPRESS,
3128                 .out_of_space = 0,
3129                 .big_data = 0,
3130                 .use_external_mbufs = 1,
3131                 .inbuf_data_size = data_len,
3132                 .inbuf_memzone = make_memzone("inbuf", data_len),
3133                 .compbuf_memzone = make_memzone("compbuf", data_len *
3134                                                 COMPRESS_BUF_SIZE_RATIO),
3135                 .uncompbuf_memzone = make_memzone("decompbuf", data_len),
3136                 .overflow = OVERFLOW_DISABLED
3137         };
3138
3139         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3140                 /* prepare input data */
3141                 data_len = strlen(compress_test_bufs[i]) + 1;
3142                 rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
3143                            data_len);
3144                 test_data.inbuf_data_size = data_len;
3145                 int_data.buf_idx = &i;
3146
3147                 /* Compress with compressdev, decompress with Zlib */
3148                 test_data.zlib_dir = ZLIB_DECOMPRESS;
3149                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3150                         goto exit;
3151
3152                 /* Compress with Zlib, decompress with compressdev */
3153                 test_data.zlib_dir = ZLIB_COMPRESS;
3154                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3155                         goto exit;
3156         }
3157
3158         ret = TEST_SUCCESS;
3159
3160 exit:
3161         rte_memzone_free(test_data.inbuf_memzone);
3162         rte_memzone_free(test_data.compbuf_memzone);
3163         rte_memzone_free(test_data.uncompbuf_memzone);
3164         return ret;
3165 }
3166
3167 static int
3168 test_compressdev_deflate_stateless_fixed_oos_recoverable(void)
3169 {
3170         struct comp_testsuite_params *ts_params = &testsuite_params;
3171         uint16_t i;
3172         int ret;
3173         int comp_result;
3174         const struct rte_compressdev_capabilities *capab;
3175
3176         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3177         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3178
3179         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
3180                 return -ENOTSUP;
3181
3182         struct rte_comp_xform *compress_xform =
3183                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
3184
3185         if (compress_xform == NULL) {
3186                 RTE_LOG(ERR, USER1,
3187                         "Compress xform could not be created\n");
3188                 ret = TEST_FAILED;
3189                 goto exit;
3190         }
3191
3192         memcpy(compress_xform, ts_params->def_comp_xform,
3193                         sizeof(struct rte_comp_xform));
3194         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
3195
3196         struct interim_data_params int_data = {
3197                 NULL,
3198                 1,
3199                 NULL,
3200                 &compress_xform,
3201                 &ts_params->def_decomp_xform,
3202                 1
3203         };
3204
3205         struct test_data_params test_data = {
3206                 .compress_state = RTE_COMP_OP_STATELESS,
3207                 .decompress_state = RTE_COMP_OP_STATELESS,
3208                 .buff_type = LB_BOTH,
3209                 .zlib_dir = ZLIB_DECOMPRESS,
3210                 .out_of_space = 0,
3211                 .big_data = 0,
3212                 .overflow = OVERFLOW_ENABLED,
3213                 .ratio = RATIO_ENABLED
3214         };
3215
3216         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3217                 int_data.test_bufs = &compress_test_bufs[i];
3218                 int_data.buf_idx = &i;
3219
3220                 /* Compress with compressdev, decompress with Zlib */
3221                 test_data.zlib_dir = ZLIB_DECOMPRESS;
3222                 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3223                 if (comp_result < 0) {
3224                         ret = TEST_FAILED;
3225                         goto exit;
3226                 } else if (comp_result > 0) {
3227                         ret = -ENOTSUP;
3228                         goto exit;
3229                 }
3230
3231                 /* Compress with Zlib, decompress with compressdev */
3232                 test_data.zlib_dir = ZLIB_COMPRESS;
3233                 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3234                 if (comp_result < 0) {
3235                         ret = TEST_FAILED;
3236                         goto exit;
3237                 } else if (comp_result > 0) {
3238                         ret = -ENOTSUP;
3239                         goto exit;
3240                 }
3241         }
3242
3243         ret = TEST_SUCCESS;
3244
3245 exit:
3246         rte_free(compress_xform);
3247         return ret;
3248 }
3249
3250 static int
3251 test_compressdev_deflate_im_buffers_LB_1op(void)
3252 {
3253         struct comp_testsuite_params *ts_params = &testsuite_params;
3254         uint16_t i = 0;
3255         int ret = TEST_SUCCESS;
3256         int j;
3257         const struct rte_compressdev_capabilities *capab;
3258         char *test_buffer = NULL;
3259
3260         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3261         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3262
3263         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3264                 return -ENOTSUP;
3265
3266         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3267                 return -ENOTSUP;
3268
3269         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3270         if (test_buffer == NULL) {
3271                 RTE_LOG(ERR, USER1,
3272                         "Can't allocate buffer for 'im buffer' test\n");
3273                 return TEST_FAILED;
3274         }
3275
3276         struct interim_data_params int_data = {
3277                 (const char * const *)&test_buffer,
3278                 1,
3279                 &i,
3280                 &ts_params->def_comp_xform,
3281                 &ts_params->def_decomp_xform,
3282                 1
3283         };
3284
3285         struct test_data_params test_data = {
3286                 .compress_state = RTE_COMP_OP_STATELESS,
3287                 .decompress_state = RTE_COMP_OP_STATELESS,
3288                                 /* must be LB to SGL,
3289                                  * input LB buffer reaches its maximum,
3290                                  * if ratio 1.3 than another mbuf must be
3291                                  * created and attached
3292                                  */
3293                 .buff_type = LB_BOTH,
3294                 .zlib_dir = ZLIB_NONE,
3295                 .out_of_space = 0,
3296                 .big_data = 1,
3297                 .overflow = OVERFLOW_DISABLED,
3298                 .ratio = RATIO_DISABLED
3299         };
3300
3301         ts_params->def_comp_xform->compress.deflate.huffman =
3302                         RTE_COMP_HUFFMAN_DYNAMIC;
3303
3304         /* fill the buffer with data based on rand. data */
3305         srand(IM_BUF_DATA_TEST_SIZE_LB);
3306         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3307                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3308
3309         /* Compress with compressdev, decompress with compressdev */
3310         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3311                 ret = TEST_FAILED;
3312                 goto end;
3313         }
3314
3315 end:
3316         ts_params->def_comp_xform->compress.deflate.huffman =
3317                         RTE_COMP_HUFFMAN_DEFAULT;
3318         rte_free(test_buffer);
3319         return ret;
3320 }
3321
3322 static int
3323 test_compressdev_deflate_im_buffers_LB_2ops_first(void)
3324 {
3325         struct comp_testsuite_params *ts_params = &testsuite_params;
3326         uint16_t i = 0;
3327         int ret = TEST_SUCCESS;
3328         int j;
3329         const struct rte_compressdev_capabilities *capab;
3330         char *test_buffer = NULL;
3331         const char *test_buffers[2];
3332
3333         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3334         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3335
3336         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3337                 return -ENOTSUP;
3338
3339         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3340                 return -ENOTSUP;
3341
3342         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3343         if (test_buffer == NULL) {
3344                 RTE_LOG(ERR, USER1,
3345                         "Can't allocate buffer for 'im buffer' test\n");
3346                 return TEST_FAILED;
3347         }
3348
3349         test_buffers[0] = test_buffer;
3350         test_buffers[1] = compress_test_bufs[0];
3351
3352         struct interim_data_params int_data = {
3353                 (const char * const *)test_buffers,
3354                 2,
3355                 &i,
3356                 &ts_params->def_comp_xform,
3357                 &ts_params->def_decomp_xform,
3358                 1
3359         };
3360
3361         struct test_data_params test_data = {
3362                 .compress_state = RTE_COMP_OP_STATELESS,
3363                 .decompress_state = RTE_COMP_OP_STATELESS,
3364                 .buff_type = LB_BOTH,
3365                 .zlib_dir = ZLIB_NONE,
3366                 .out_of_space = 0,
3367                 .big_data = 1,
3368                 .overflow = OVERFLOW_DISABLED,
3369                 .ratio = RATIO_DISABLED
3370         };
3371
3372         ts_params->def_comp_xform->compress.deflate.huffman =
3373                         RTE_COMP_HUFFMAN_DYNAMIC;
3374
3375         /* fill the buffer with data based on rand. data */
3376         srand(IM_BUF_DATA_TEST_SIZE_LB);
3377         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3378                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3379
3380         /* Compress with compressdev, decompress with compressdev */
3381         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3382                 ret = TEST_FAILED;
3383                 goto end;
3384         }
3385
3386 end:
3387         ts_params->def_comp_xform->compress.deflate.huffman =
3388                         RTE_COMP_HUFFMAN_DEFAULT;
3389         rte_free(test_buffer);
3390         return ret;
3391 }
3392
3393 static int
3394 test_compressdev_deflate_im_buffers_LB_2ops_second(void)
3395 {
3396         struct comp_testsuite_params *ts_params = &testsuite_params;
3397         uint16_t i = 0;
3398         int ret = TEST_SUCCESS;
3399         int j;
3400         const struct rte_compressdev_capabilities *capab;
3401         char *test_buffer = NULL;
3402         const char *test_buffers[2];
3403
3404         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3405         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3406
3407         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3408                 return -ENOTSUP;
3409
3410         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3411                 return -ENOTSUP;
3412
3413         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3414         if (test_buffer == NULL) {
3415                 RTE_LOG(ERR, USER1,
3416                         "Can't allocate buffer for 'im buffer' test\n");
3417                 return TEST_FAILED;
3418         }
3419
3420         test_buffers[0] = compress_test_bufs[0];
3421         test_buffers[1] = test_buffer;
3422
3423         struct interim_data_params int_data = {
3424                 (const char * const *)test_buffers,
3425                 2,
3426                 &i,
3427                 &ts_params->def_comp_xform,
3428                 &ts_params->def_decomp_xform,
3429                 1
3430         };
3431
3432         struct test_data_params test_data = {
3433                 .compress_state = RTE_COMP_OP_STATELESS,
3434                 .decompress_state = RTE_COMP_OP_STATELESS,
3435                 .buff_type = LB_BOTH,
3436                 .zlib_dir = ZLIB_NONE,
3437                 .out_of_space = 0,
3438                 .big_data = 1,
3439                 .overflow = OVERFLOW_DISABLED,
3440                 .ratio = RATIO_DISABLED
3441         };
3442
3443         ts_params->def_comp_xform->compress.deflate.huffman =
3444                         RTE_COMP_HUFFMAN_DYNAMIC;
3445
3446         /* fill the buffer with data based on rand. data */
3447         srand(IM_BUF_DATA_TEST_SIZE_LB);
3448         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3449                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3450
3451         /* Compress with compressdev, decompress with compressdev */
3452         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3453                 ret = TEST_FAILED;
3454                 goto end;
3455         }
3456
3457 end:
3458         ts_params->def_comp_xform->compress.deflate.huffman =
3459                         RTE_COMP_HUFFMAN_DEFAULT;
3460         rte_free(test_buffer);
3461         return ret;
3462 }
3463
3464 static int
3465 test_compressdev_deflate_im_buffers_LB_3ops(void)
3466 {
3467         struct comp_testsuite_params *ts_params = &testsuite_params;
3468         uint16_t i = 0;
3469         int ret = TEST_SUCCESS;
3470         int j;
3471         const struct rte_compressdev_capabilities *capab;
3472         char *test_buffer = NULL;
3473         const char *test_buffers[3];
3474
3475         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3476         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3477
3478         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3479                 return -ENOTSUP;
3480
3481         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3482                 return -ENOTSUP;
3483
3484         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3485         if (test_buffer == NULL) {
3486                 RTE_LOG(ERR, USER1,
3487                         "Can't allocate buffer for 'im buffer' test\n");
3488                 return TEST_FAILED;
3489         }
3490
3491         test_buffers[0] = compress_test_bufs[0];
3492         test_buffers[1] = test_buffer;
3493         test_buffers[2] = compress_test_bufs[1];
3494
3495         struct interim_data_params int_data = {
3496                 (const char * const *)test_buffers,
3497                 3,
3498                 &i,
3499                 &ts_params->def_comp_xform,
3500                 &ts_params->def_decomp_xform,
3501                 1
3502         };
3503
3504         struct test_data_params test_data = {
3505                 .compress_state = RTE_COMP_OP_STATELESS,
3506                 .decompress_state = RTE_COMP_OP_STATELESS,
3507                 .buff_type = LB_BOTH,
3508                 .zlib_dir = ZLIB_NONE,
3509                 .out_of_space = 0,
3510                 .big_data = 1,
3511                 .overflow = OVERFLOW_DISABLED,
3512                 .ratio = RATIO_DISABLED
3513         };
3514
3515         ts_params->def_comp_xform->compress.deflate.huffman =
3516                         RTE_COMP_HUFFMAN_DYNAMIC;
3517
3518         /* fill the buffer with data based on rand. data */
3519         srand(IM_BUF_DATA_TEST_SIZE_LB);
3520         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3521                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3522
3523         /* Compress with compressdev, decompress with compressdev */
3524         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3525                 ret = TEST_FAILED;
3526                 goto end;
3527         }
3528
3529 end:
3530         ts_params->def_comp_xform->compress.deflate.huffman =
3531                         RTE_COMP_HUFFMAN_DEFAULT;
3532         rte_free(test_buffer);
3533         return ret;
3534 }
3535
3536 static int
3537 test_compressdev_deflate_im_buffers_LB_4ops(void)
3538 {
3539         struct comp_testsuite_params *ts_params = &testsuite_params;
3540         uint16_t i = 0;
3541         int ret = TEST_SUCCESS;
3542         int j;
3543         const struct rte_compressdev_capabilities *capab;
3544         char *test_buffer = NULL;
3545         const char *test_buffers[4];
3546
3547         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3548         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3549
3550         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3551                 return -ENOTSUP;
3552
3553         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3554                 return -ENOTSUP;
3555
3556         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_LB, 0);
3557         if (test_buffer == NULL) {
3558                 RTE_LOG(ERR, USER1,
3559                         "Can't allocate buffer for 'im buffer' test\n");
3560                 return TEST_FAILED;
3561         }
3562
3563         test_buffers[0] = compress_test_bufs[0];
3564         test_buffers[1] = test_buffer;
3565         test_buffers[2] = compress_test_bufs[1];
3566         test_buffers[3] = test_buffer;
3567
3568         struct interim_data_params int_data = {
3569                 (const char * const *)test_buffers,
3570                 4,
3571                 &i,
3572                 &ts_params->def_comp_xform,
3573                 &ts_params->def_decomp_xform,
3574                 1
3575         };
3576
3577         struct test_data_params test_data = {
3578                 .compress_state = RTE_COMP_OP_STATELESS,
3579                 .decompress_state = RTE_COMP_OP_STATELESS,
3580                 .buff_type = LB_BOTH,
3581                 .zlib_dir = ZLIB_NONE,
3582                 .out_of_space = 0,
3583                 .big_data = 1,
3584                 .overflow = OVERFLOW_DISABLED,
3585                 .ratio = RATIO_DISABLED
3586         };
3587
3588         ts_params->def_comp_xform->compress.deflate.huffman =
3589                         RTE_COMP_HUFFMAN_DYNAMIC;
3590
3591         /* fill the buffer with data based on rand. data */
3592         srand(IM_BUF_DATA_TEST_SIZE_LB);
3593         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_LB - 1; ++j)
3594                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3595
3596         /* Compress with compressdev, decompress with compressdev */
3597         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3598                 ret = TEST_FAILED;
3599                 goto end;
3600         }
3601
3602 end:
3603         ts_params->def_comp_xform->compress.deflate.huffman =
3604                         RTE_COMP_HUFFMAN_DEFAULT;
3605         rte_free(test_buffer);
3606         return ret;
3607 }
3608
3609
3610 static int
3611 test_compressdev_deflate_im_buffers_SGL_1op(void)
3612 {
3613         struct comp_testsuite_params *ts_params = &testsuite_params;
3614         uint16_t i = 0;
3615         int ret = TEST_SUCCESS;
3616         int j;
3617         const struct rte_compressdev_capabilities *capab;
3618         char *test_buffer = NULL;
3619
3620         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3621         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3622
3623         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3624                 return -ENOTSUP;
3625
3626         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3627                 return -ENOTSUP;
3628
3629         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3630         if (test_buffer == NULL) {
3631                 RTE_LOG(ERR, USER1,
3632                         "Can't allocate buffer for big-data\n");
3633                 return TEST_FAILED;
3634         }
3635
3636         struct interim_data_params int_data = {
3637                 (const char * const *)&test_buffer,
3638                 1,
3639                 &i,
3640                 &ts_params->def_comp_xform,
3641                 &ts_params->def_decomp_xform,
3642                 1
3643         };
3644
3645         struct test_data_params test_data = {
3646                 .compress_state = RTE_COMP_OP_STATELESS,
3647                 .decompress_state = RTE_COMP_OP_STATELESS,
3648                 .buff_type = SGL_BOTH,
3649                 .zlib_dir = ZLIB_NONE,
3650                 .out_of_space = 0,
3651                 .big_data = 1,
3652                 .overflow = OVERFLOW_DISABLED,
3653                 .ratio = RATIO_DISABLED
3654         };
3655
3656         ts_params->def_comp_xform->compress.deflate.huffman =
3657                         RTE_COMP_HUFFMAN_DYNAMIC;
3658
3659         /* fill the buffer with data based on rand. data */
3660         srand(IM_BUF_DATA_TEST_SIZE_SGL);
3661         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3662                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3663
3664         /* Compress with compressdev, decompress with compressdev */
3665         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3666                 ret = TEST_FAILED;
3667                 goto end;
3668         }
3669
3670 end:
3671         ts_params->def_comp_xform->compress.deflate.huffman =
3672                         RTE_COMP_HUFFMAN_DEFAULT;
3673         rte_free(test_buffer);
3674         return ret;
3675 }
3676
3677 static int
3678 test_compressdev_deflate_im_buffers_SGL_2ops_first(void)
3679 {
3680         struct comp_testsuite_params *ts_params = &testsuite_params;
3681         uint16_t i = 0;
3682         int ret = TEST_SUCCESS;
3683         int j;
3684         const struct rte_compressdev_capabilities *capab;
3685         char *test_buffer = NULL;
3686         const char *test_buffers[2];
3687
3688         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3689         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3690
3691         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3692                 return -ENOTSUP;
3693
3694         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3695                 return -ENOTSUP;
3696
3697         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3698         if (test_buffer == NULL) {
3699                 RTE_LOG(ERR, USER1,
3700                         "Can't allocate buffer for big-data\n");
3701                 return TEST_FAILED;
3702         }
3703
3704         test_buffers[0] = test_buffer;
3705         test_buffers[1] = compress_test_bufs[0];
3706
3707         struct interim_data_params int_data = {
3708                 (const char * const *)test_buffers,
3709                 2,
3710                 &i,
3711                 &ts_params->def_comp_xform,
3712                 &ts_params->def_decomp_xform,
3713                 1
3714         };
3715
3716         struct test_data_params test_data = {
3717                 .compress_state = RTE_COMP_OP_STATELESS,
3718                 .decompress_state = RTE_COMP_OP_STATELESS,
3719                 .buff_type = SGL_BOTH,
3720                 .zlib_dir = ZLIB_NONE,
3721                 .out_of_space = 0,
3722                 .big_data = 1,
3723                 .overflow = OVERFLOW_DISABLED,
3724                 .ratio = RATIO_DISABLED
3725         };
3726
3727         ts_params->def_comp_xform->compress.deflate.huffman =
3728                         RTE_COMP_HUFFMAN_DYNAMIC;
3729
3730         /* fill the buffer with data based on rand. data */
3731         srand(IM_BUF_DATA_TEST_SIZE_SGL);
3732         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3733                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3734
3735         /* Compress with compressdev, decompress with compressdev */
3736         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3737                 ret = TEST_FAILED;
3738                 goto end;
3739         }
3740
3741 end:
3742         ts_params->def_comp_xform->compress.deflate.huffman =
3743                         RTE_COMP_HUFFMAN_DEFAULT;
3744         rte_free(test_buffer);
3745         return ret;
3746 }
3747
3748 static int
3749 test_compressdev_deflate_im_buffers_SGL_2ops_second(void)
3750 {
3751         struct comp_testsuite_params *ts_params = &testsuite_params;
3752         uint16_t i = 0;
3753         int ret = TEST_SUCCESS;
3754         int j;
3755         const struct rte_compressdev_capabilities *capab;
3756         char *test_buffer = NULL;
3757         const char *test_buffers[2];
3758
3759         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3760         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3761
3762         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3763                 return -ENOTSUP;
3764
3765         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3766                 return -ENOTSUP;
3767
3768         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3769         if (test_buffer == NULL) {
3770                 RTE_LOG(ERR, USER1,
3771                         "Can't allocate buffer for big-data\n");
3772                 return TEST_FAILED;
3773         }
3774
3775         test_buffers[0] = compress_test_bufs[0];
3776         test_buffers[1] = test_buffer;
3777
3778         struct interim_data_params int_data = {
3779                 (const char * const *)test_buffers,
3780                 2,
3781                 &i,
3782                 &ts_params->def_comp_xform,
3783                 &ts_params->def_decomp_xform,
3784                 1
3785         };
3786
3787         struct test_data_params test_data = {
3788                 .compress_state = RTE_COMP_OP_STATELESS,
3789                 .decompress_state = RTE_COMP_OP_STATELESS,
3790                 .buff_type = SGL_BOTH,
3791                 .zlib_dir = ZLIB_NONE,
3792                 .out_of_space = 0,
3793                 .big_data = 1,
3794                 .overflow = OVERFLOW_DISABLED,
3795                 .ratio = RATIO_DISABLED
3796         };
3797
3798         ts_params->def_comp_xform->compress.deflate.huffman =
3799                         RTE_COMP_HUFFMAN_DYNAMIC;
3800
3801         /* fill the buffer with data based on rand. data */
3802         srand(IM_BUF_DATA_TEST_SIZE_SGL);
3803         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3804                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3805
3806         /* Compress with compressdev, decompress with compressdev */
3807         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3808                 ret = TEST_FAILED;
3809                 goto end;
3810         }
3811
3812 end:
3813         ts_params->def_comp_xform->compress.deflate.huffman =
3814                         RTE_COMP_HUFFMAN_DEFAULT;
3815         rte_free(test_buffer);
3816         return ret;
3817 }
3818
3819 static int
3820 test_compressdev_deflate_im_buffers_SGL_3ops(void)
3821 {
3822         struct comp_testsuite_params *ts_params = &testsuite_params;
3823         uint16_t i = 0;
3824         int ret = TEST_SUCCESS;
3825         int j;
3826         const struct rte_compressdev_capabilities *capab;
3827         char *test_buffer = NULL;
3828         const char *test_buffers[3];
3829
3830         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3831         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3832
3833         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3834                 return -ENOTSUP;
3835
3836         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3837                 return -ENOTSUP;
3838
3839         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3840         if (test_buffer == NULL) {
3841                 RTE_LOG(ERR, USER1,
3842                         "Can't allocate buffer for big-data\n");
3843                 return TEST_FAILED;
3844         }
3845
3846         test_buffers[0] = compress_test_bufs[0];
3847         test_buffers[1] = test_buffer;
3848         test_buffers[2] = compress_test_bufs[1];
3849
3850         struct interim_data_params int_data = {
3851                 (const char * const *)test_buffers,
3852                 3,
3853                 &i,
3854                 &ts_params->def_comp_xform,
3855                 &ts_params->def_decomp_xform,
3856                 1
3857         };
3858
3859         struct test_data_params test_data = {
3860                 .compress_state = RTE_COMP_OP_STATELESS,
3861                 .decompress_state = RTE_COMP_OP_STATELESS,
3862                 .buff_type = SGL_BOTH,
3863                 .zlib_dir = ZLIB_NONE,
3864                 .out_of_space = 0,
3865                 .big_data = 1,
3866                 .overflow = OVERFLOW_DISABLED,
3867                 .ratio = RATIO_DISABLED
3868         };
3869
3870         ts_params->def_comp_xform->compress.deflate.huffman =
3871                         RTE_COMP_HUFFMAN_DYNAMIC;
3872
3873         /* fill the buffer with data based on rand. data */
3874         srand(IM_BUF_DATA_TEST_SIZE_SGL);
3875         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3876                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3877
3878         /* Compress with compressdev, decompress with compressdev */
3879         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3880                 ret = TEST_FAILED;
3881                 goto end;
3882         }
3883
3884 end:
3885         ts_params->def_comp_xform->compress.deflate.huffman =
3886                         RTE_COMP_HUFFMAN_DEFAULT;
3887         rte_free(test_buffer);
3888         return ret;
3889 }
3890
3891
3892 static int
3893 test_compressdev_deflate_im_buffers_SGL_4ops(void)
3894 {
3895         struct comp_testsuite_params *ts_params = &testsuite_params;
3896         uint16_t i = 0;
3897         int ret = TEST_SUCCESS;
3898         int j;
3899         const struct rte_compressdev_capabilities *capab;
3900         char *test_buffer = NULL;
3901         const char *test_buffers[4];
3902
3903         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3904         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3905
3906         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3907                 return -ENOTSUP;
3908
3909         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3910                 return -ENOTSUP;
3911
3912         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_SGL, 0);
3913         if (test_buffer == NULL) {
3914                 RTE_LOG(ERR, USER1,
3915                         "Can't allocate buffer for big-data\n");
3916                 return TEST_FAILED;
3917         }
3918
3919         test_buffers[0] = compress_test_bufs[0];
3920         test_buffers[1] = test_buffer;
3921         test_buffers[2] = compress_test_bufs[1];
3922         test_buffers[3] = test_buffer;
3923
3924         struct interim_data_params int_data = {
3925                 (const char * const *)test_buffers,
3926                 4,
3927                 &i,
3928                 &ts_params->def_comp_xform,
3929                 &ts_params->def_decomp_xform,
3930                 1
3931         };
3932
3933         struct test_data_params test_data = {
3934                 .compress_state = RTE_COMP_OP_STATELESS,
3935                 .decompress_state = RTE_COMP_OP_STATELESS,
3936                 .buff_type = SGL_BOTH,
3937                 .zlib_dir = ZLIB_NONE,
3938                 .out_of_space = 0,
3939                 .big_data = 1,
3940                 .overflow = OVERFLOW_DISABLED,
3941                 .ratio = RATIO_DISABLED
3942         };
3943
3944         ts_params->def_comp_xform->compress.deflate.huffman =
3945                         RTE_COMP_HUFFMAN_DYNAMIC;
3946
3947         /* fill the buffer with data based on rand. data */
3948         srand(IM_BUF_DATA_TEST_SIZE_SGL);
3949         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_SGL - 1; ++j)
3950                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
3951
3952         /* Compress with compressdev, decompress with compressdev */
3953         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
3954                 ret = TEST_FAILED;
3955                 goto end;
3956         }
3957
3958 end:
3959         ts_params->def_comp_xform->compress.deflate.huffman =
3960                         RTE_COMP_HUFFMAN_DEFAULT;
3961         rte_free(test_buffer);
3962         return ret;
3963 }
3964
3965 static int
3966 test_compressdev_deflate_im_buffers_SGL_over_1op(void)
3967 {
3968         struct comp_testsuite_params *ts_params = &testsuite_params;
3969         uint16_t i = 0;
3970         int ret = TEST_SUCCESS;
3971         int j;
3972         const struct rte_compressdev_capabilities *capab;
3973         char *test_buffer = NULL;
3974
3975         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
3976
3977         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3978         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3979
3980         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
3981                 return -ENOTSUP;
3982
3983         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
3984                 return -ENOTSUP;
3985
3986         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
3987         if (test_buffer == NULL) {
3988                 RTE_LOG(ERR, USER1,
3989                         "Can't allocate buffer for big-data\n");
3990                 return TEST_FAILED;
3991         }
3992
3993         struct interim_data_params int_data = {
3994                 (const char * const *)&test_buffer,
3995                 1,
3996                 &i,
3997                 &ts_params->def_comp_xform,
3998                 &ts_params->def_decomp_xform,
3999                 1
4000         };
4001
4002         struct test_data_params test_data = {
4003                 .compress_state = RTE_COMP_OP_STATELESS,
4004                 .decompress_state = RTE_COMP_OP_STATELESS,
4005                 .buff_type = SGL_BOTH,
4006                 .zlib_dir = ZLIB_NONE,
4007                 .out_of_space = 0,
4008                 .big_data = 1,
4009                 .overflow = OVERFLOW_DISABLED,
4010                 .ratio = RATIO_DISABLED
4011         };
4012
4013         ts_params->def_comp_xform->compress.deflate.huffman =
4014                         RTE_COMP_HUFFMAN_DYNAMIC;
4015
4016         /* fill the buffer with data based on rand. data */
4017         srand(IM_BUF_DATA_TEST_SIZE_OVER);
4018         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4019                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4020
4021         /* Compress with compressdev, decompress with compressdev */
4022         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4023                 ret = TEST_SUCCESS;
4024                 goto end;
4025         }
4026
4027 end:
4028         ts_params->def_comp_xform->compress.deflate.huffman =
4029                         RTE_COMP_HUFFMAN_DEFAULT;
4030         rte_free(test_buffer);
4031
4032         return ret;
4033 }
4034
4035
4036 static int
4037 test_compressdev_deflate_im_buffers_SGL_over_2ops_first(void)
4038 {
4039         struct comp_testsuite_params *ts_params = &testsuite_params;
4040         uint16_t i = 0;
4041         int ret = TEST_SUCCESS;
4042         int j;
4043         const struct rte_compressdev_capabilities *capab;
4044         char *test_buffer = NULL;
4045         const char *test_buffers[2];
4046
4047         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
4048
4049         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
4050         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
4051
4052         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
4053                 return -ENOTSUP;
4054
4055         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
4056                 return -ENOTSUP;
4057
4058         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
4059         if (test_buffer == NULL) {
4060                 RTE_LOG(ERR, USER1,
4061                         "Can't allocate buffer for big-data\n");
4062                 return TEST_FAILED;
4063         }
4064
4065         test_buffers[0] = test_buffer;
4066         test_buffers[1] = compress_test_bufs[0];
4067
4068         struct interim_data_params int_data = {
4069                 (const char * const *)test_buffers,
4070                 2,
4071                 &i,
4072                 &ts_params->def_comp_xform,
4073                 &ts_params->def_decomp_xform,
4074                 1
4075         };
4076
4077         struct test_data_params test_data = {
4078                 .compress_state = RTE_COMP_OP_STATELESS,
4079                 .decompress_state = RTE_COMP_OP_STATELESS,
4080                 .buff_type = SGL_BOTH,
4081                 .zlib_dir = ZLIB_NONE,
4082                 .out_of_space = 0,
4083                 .big_data = 1,
4084                 .overflow = OVERFLOW_DISABLED,
4085                 .ratio = RATIO_DISABLED
4086         };
4087
4088         ts_params->def_comp_xform->compress.deflate.huffman =
4089                         RTE_COMP_HUFFMAN_DYNAMIC;
4090
4091         /* fill the buffer with data based on rand. data */
4092         srand(IM_BUF_DATA_TEST_SIZE_OVER);
4093         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4094                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4095
4096         /* Compress with compressdev, decompress with compressdev */
4097         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4098                 ret = TEST_SUCCESS;
4099                 goto end;
4100         }
4101
4102 end:
4103         ts_params->def_comp_xform->compress.deflate.huffman =
4104                         RTE_COMP_HUFFMAN_DEFAULT;
4105         rte_free(test_buffer);
4106         return ret;
4107 }
4108
4109 static int
4110 test_compressdev_deflate_im_buffers_SGL_over_2ops_second(void)
4111 {
4112         struct comp_testsuite_params *ts_params = &testsuite_params;
4113         uint16_t i = 0;
4114         int ret = TEST_SUCCESS;
4115         int j;
4116         const struct rte_compressdev_capabilities *capab;
4117         char *test_buffer = NULL;
4118         const char *test_buffers[2];
4119
4120         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
4121
4122         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
4123         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
4124
4125         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
4126                 return -ENOTSUP;
4127
4128         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
4129                 return -ENOTSUP;
4130
4131         test_buffer = rte_malloc(NULL, IM_BUF_DATA_TEST_SIZE_OVER, 0);
4132         if (test_buffer == NULL) {
4133                 RTE_LOG(ERR, USER1,
4134                         "Can't allocate buffer for big-data\n");
4135                 return TEST_FAILED;
4136         }
4137
4138         test_buffers[0] = compress_test_bufs[0];
4139         test_buffers[1] = test_buffer;
4140
4141         struct interim_data_params int_data = {
4142                 (const char * const *)test_buffers,
4143                 2,
4144                 &i,
4145                 &ts_params->def_comp_xform,
4146                 &ts_params->def_decomp_xform,
4147                 1
4148         };
4149
4150         struct test_data_params test_data = {
4151                 .compress_state = RTE_COMP_OP_STATELESS,
4152                 .decompress_state = RTE_COMP_OP_STATELESS,
4153                 .buff_type = SGL_BOTH,
4154                 .zlib_dir = ZLIB_NONE,
4155                 .out_of_space = 0,
4156                 .big_data = 1,
4157                 .overflow = OVERFLOW_DISABLED,
4158                 .ratio = RATIO_DISABLED
4159         };
4160
4161         ts_params->def_comp_xform->compress.deflate.huffman =
4162                         RTE_COMP_HUFFMAN_DYNAMIC;
4163
4164         /* fill the buffer with data based on rand. data */
4165         srand(IM_BUF_DATA_TEST_SIZE_OVER);
4166         for (j = 0; j < IM_BUF_DATA_TEST_SIZE_OVER - 1; ++j)
4167                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
4168
4169         /* Compress with compressdev, decompress with compressdev */
4170         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
4171                 ret = TEST_SUCCESS;
4172                 goto end;
4173         }
4174
4175 end:
4176         ts_params->def_comp_xform->compress.deflate.huffman =
4177                         RTE_COMP_HUFFMAN_DEFAULT;
4178         rte_free(test_buffer);
4179         return ret;
4180 }
4181
4182 static struct unit_test_suite compressdev_testsuite  = {
4183         .suite_name = "compressdev unit test suite",
4184         .setup = testsuite_setup,
4185         .teardown = testsuite_teardown,
4186         .unit_test_cases = {
4187                 TEST_CASE_ST(NULL, NULL,
4188                         test_compressdev_invalid_configuration),
4189                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4190                         test_compressdev_deflate_stateless_fixed),
4191                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4192                         test_compressdev_deflate_stateless_dynamic),
4193                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4194                         test_compressdev_deflate_stateless_dynamic_big),
4195                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4196                         test_compressdev_deflate_stateless_multi_op),
4197                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4198                         test_compressdev_deflate_stateless_multi_level),
4199                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4200                         test_compressdev_deflate_stateless_multi_xform),
4201                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4202                         test_compressdev_deflate_stateless_sgl),
4203                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4204                         test_compressdev_deflate_stateless_checksum),
4205                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4206                         test_compressdev_out_of_space_buffer),
4207                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4208                         test_compressdev_deflate_stateful_decomp),
4209                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4210                         test_compressdev_deflate_stateful_decomp_checksum),
4211                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4212                         test_compressdev_external_mbufs),
4213                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4214                       test_compressdev_deflate_stateless_fixed_oos_recoverable),
4215
4216                 /* Positive test cases for IM buffer handling verification */
4217                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4218                         test_compressdev_deflate_im_buffers_LB_1op),
4219                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4220                         test_compressdev_deflate_im_buffers_LB_2ops_first),
4221                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4222                         test_compressdev_deflate_im_buffers_LB_2ops_second),
4223                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4224                         test_compressdev_deflate_im_buffers_LB_3ops),
4225
4226                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4227                         test_compressdev_deflate_im_buffers_LB_4ops),
4228                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4229                         test_compressdev_deflate_im_buffers_SGL_1op),
4230
4231                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4232                         test_compressdev_deflate_im_buffers_SGL_2ops_first),
4233                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4234                         test_compressdev_deflate_im_buffers_SGL_2ops_second),
4235                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4236                         test_compressdev_deflate_im_buffers_SGL_3ops),
4237                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4238                         test_compressdev_deflate_im_buffers_SGL_4ops),
4239
4240                 /* Negative test cases for IM buffer handling verification */
4241
4242                 /* For this test huge mempool is necessary.
4243                  * It tests one case:
4244                  * only one op containing big amount of data, so that
4245                  * number of requested descriptors higher than number
4246                  * of available descriptors (128)
4247                  */
4248                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4249                         test_compressdev_deflate_im_buffers_SGL_over_1op),
4250
4251                 /* For this test huge mempool is necessary.
4252                  * 2 ops. First op contains big amount of data:
4253                  * number of requested descriptors higher than number
4254                  * of available descriptors (128), the second op is
4255                  * relatively small. In this case both ops are rejected
4256                  */
4257                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4258                        test_compressdev_deflate_im_buffers_SGL_over_2ops_first),
4259
4260                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
4261                       test_compressdev_deflate_im_buffers_SGL_over_2ops_second),
4262
4263                 TEST_CASES_END() /**< NULL terminate unit test array */
4264         }
4265 };
4266
4267 static int
4268 test_compressdev(void)
4269 {
4270         return unit_test_suite_runner(&compressdev_testsuite);
4271 }
4272
4273 REGISTER_TEST_COMMAND(compressdev_autotest, test_compressdev);