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
  10 #include <rte_cycles.h>
  11 #include <rte_malloc.h>
  12 #include <rte_mempool.h>
  13 #include <rte_mbuf.h>
  14 #include <rte_compressdev.h>
  15 #include <rte_string_fns.h>
  16
  17 #include "test_compressdev_test_buffer.h"
  18 #include "test.h"
  19
  20 #define DIV_CEIL(a, b)  ((a) / (b) + ((a) % (b) != 0))
  21
  22 #define DEFAULT_WINDOW_SIZE 15
  23 #define DEFAULT_MEM_LEVEL 8
  24 #define MAX_DEQD_RETRIES 10
  25 #define DEQUEUE_WAIT_TIME 10000
  26
  27 /*
  28  * 30% extra size for compressed data compared to original data,
  29  * in case data size cannot be reduced and it is actually bigger
  30  * due to the compress block headers
  31  */
  32 #define COMPRESS_BUF_SIZE_RATIO 1.3
  33 #define COMPRESS_BUF_SIZE_RATIO_OVERFLOW 0.2
  34 #define NUM_LARGE_MBUFS 16
  35 #define SMALL_SEG_SIZE 256
  36 #define MAX_SEGS 16
  37 #define NUM_OPS 16
  38 #define NUM_MAX_XFORMS 16
  39 #define NUM_MAX_INFLIGHT_OPS 128
  40 #define CACHE_SIZE 0
  41
  42 #define ZLIB_CRC_CHECKSUM_WINDOW_BITS 31
  43 #define ZLIB_HEADER_SIZE 2
  44 #define ZLIB_TRAILER_SIZE 4
  45 #define GZIP_HEADER_SIZE 10
  46 #define GZIP_TRAILER_SIZE 8
  47
  48 #define OUT_OF_SPACE_BUF 1
  49
  50 #define MAX_MBUF_SEGMENT_SIZE 65535
  51 #define MAX_DATA_MBUF_SIZE (MAX_MBUF_SEGMENT_SIZE - RTE_PKTMBUF_HEADROOM)
  52 #define NUM_BIG_MBUFS 4
  53 #define BIG_DATA_TEST_SIZE (MAX_DATA_MBUF_SIZE * NUM_BIG_MBUFS / 2)
  54
  55 const char *
  56 huffman_type_strings[] = {
  57         [RTE_COMP_HUFFMAN_DEFAULT]      = "PMD default",
  58         [RTE_COMP_HUFFMAN_FIXED]        = "Fixed",
  59         [RTE_COMP_HUFFMAN_DYNAMIC]      = "Dynamic"
  60 };
  61
  62 enum zlib_direction {
  63         ZLIB_NONE,
  64         ZLIB_COMPRESS,
  65         ZLIB_DECOMPRESS,
  66         ZLIB_ALL
  67 };
  68
  69 enum varied_buff {
  70         LB_BOTH = 0,    /* both input and output are linear*/
  71         SGL_BOTH,       /* both input and output are chained */
  72         SGL_TO_LB,      /* input buffer is chained */
  73         LB_TO_SGL       /* output buffer is chained */
  74 };
  75
  76 enum overflow_test {
  77         OVERFLOW_DISABLED,
  78         OVERFLOW_ENABLED
  79 };
  80
  81 enum operation_type {
  82         OPERATION_COMPRESSION,
  83         OPERATION_DECOMPRESSION
  84 };
  85
  86 struct priv_op_data {
  87         uint16_t orig_idx;
  88 };
  89
  90 struct comp_testsuite_params {
  91         struct rte_mempool *large_mbuf_pool;
  92         struct rte_mempool *small_mbuf_pool;
  93         struct rte_mempool *big_mbuf_pool;
  94         struct rte_mempool *op_pool;
  95         struct rte_comp_xform *def_comp_xform;
  96         struct rte_comp_xform *def_decomp_xform;
  97 };
  98
  99 struct interim_data_params {
 100         const char * const *test_bufs;
 101         unsigned int num_bufs;
 102         uint16_t *buf_idx;
 103         struct rte_comp_xform **compress_xforms;
 104         struct rte_comp_xform **decompress_xforms;
 105         unsigned int num_xforms;
 106 };
 107
 108 struct test_data_params {
 109         enum rte_comp_op_type compress_state;
 110         enum rte_comp_op_type decompress_state;
 111         enum varied_buff buff_type;
 112         enum zlib_direction zlib_dir;
 113         unsigned int out_of_space;
 114         unsigned int big_data;
 115         /* stateful decompression specific parameters */
 116         unsigned int decompress_output_block_size;
 117         unsigned int decompress_steps_max;
 118         /* external mbufs specific parameters */
 119         unsigned int use_external_mbufs;
 120         unsigned int inbuf_data_size;
 121         const struct rte_memzone *inbuf_memzone;
 122         const struct rte_memzone *compbuf_memzone;
 123         const struct rte_memzone *uncompbuf_memzone;
 124         /* overflow test activation */
 125         enum overflow_test overflow;
 126 };
 127
 128 struct test_private_arrays {
 129         struct rte_mbuf **uncomp_bufs;
 130         struct rte_mbuf **comp_bufs;
 131         struct rte_comp_op **ops;
 132         struct rte_comp_op **ops_processed;
 133         void **priv_xforms;
 134         uint64_t *compress_checksum;
 135         uint32_t *compressed_data_size;
 136         void **stream;
 137         char **all_decomp_data;
 138         unsigned int *decomp_produced_data_size;
 139         uint16_t num_priv_xforms;
 140 };
 141
 142 static struct comp_testsuite_params testsuite_params = { 0 };
 143
 144 static void
 145 testsuite_teardown(void)
 146 {
 147         struct comp_testsuite_params *ts_params = &testsuite_params;
 148
 149         if (rte_mempool_in_use_count(ts_params->large_mbuf_pool))
 150                 RTE_LOG(ERR, USER1, "Large mbuf pool still has unfreed bufs\n");
 151         if (rte_mempool_in_use_count(ts_params->small_mbuf_pool))
 152                 RTE_LOG(ERR, USER1, "Small mbuf pool still has unfreed bufs\n");
 153         if (rte_mempool_in_use_count(ts_params->big_mbuf_pool))
 154                 RTE_LOG(ERR, USER1, "Big mbuf pool still has unfreed bufs\n");
 155         if (rte_mempool_in_use_count(ts_params->op_pool))
 156                 RTE_LOG(ERR, USER1, "op pool still has unfreed ops\n");
 157
 158         rte_mempool_free(ts_params->large_mbuf_pool);
 159         rte_mempool_free(ts_params->small_mbuf_pool);
 160         rte_mempool_free(ts_params->big_mbuf_pool);
 161         rte_mempool_free(ts_params->op_pool);
 162         rte_free(ts_params->def_comp_xform);
 163         rte_free(ts_params->def_decomp_xform);
 164 }
 165
 166 static int
 167 testsuite_setup(void)
 168 {
 169         struct comp_testsuite_params *ts_params = &testsuite_params;
 170         uint32_t max_buf_size = 0;
 171         unsigned int i;
 172
 173         if (rte_compressdev_count() == 0) {
 174                 RTE_LOG(WARNING, USER1, "Need at least one compress device\n");
 175                 return TEST_SKIPPED;
 176         }
 177
 178         RTE_LOG(NOTICE, USER1, "Running tests on device %s\n",
 179                                 rte_compressdev_name_get(0));
 180
 181         for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
 182                 max_buf_size = RTE_MAX(max_buf_size,
 183                                 strlen(compress_test_bufs[i]) + 1);
 184
 185         /*
 186          * Buffers to be used in compression and decompression.
 187          * Since decompressed data might be larger than
 188          * compressed data (due to block header),
 189          * buffers should be big enough for both cases.
 190          */
 191         max_buf_size *= COMPRESS_BUF_SIZE_RATIO;
 192         ts_params->large_mbuf_pool = rte_pktmbuf_pool_create("large_mbuf_pool",
 193                         NUM_LARGE_MBUFS,
 194                         CACHE_SIZE, 0,
 195                         max_buf_size + RTE_PKTMBUF_HEADROOM,
 196                         rte_socket_id());
 197         if (ts_params->large_mbuf_pool == NULL) {
 198                 RTE_LOG(ERR, USER1, "Large mbuf pool could not be created\n");
 199                 return TEST_FAILED;
 200         }
 201
 202         /* Create mempool with smaller buffers for SGL testing */
 203         ts_params->small_mbuf_pool = rte_pktmbuf_pool_create("small_mbuf_pool",
 204                         NUM_LARGE_MBUFS * MAX_SEGS,
 205                         CACHE_SIZE, 0,
 206                         SMALL_SEG_SIZE + RTE_PKTMBUF_HEADROOM,
 207                         rte_socket_id());
 208         if (ts_params->small_mbuf_pool == NULL) {
 209                 RTE_LOG(ERR, USER1, "Small mbuf pool could not be created\n");
 210                 goto exit;
 211         }
 212
 213         /* Create mempool with big buffers for SGL testing */
 214         ts_params->big_mbuf_pool = rte_pktmbuf_pool_create("big_mbuf_pool",
 215                         NUM_BIG_MBUFS + 1,
 216                         CACHE_SIZE, 0,
 217                         MAX_MBUF_SEGMENT_SIZE,
 218                         rte_socket_id());
 219         if (ts_params->big_mbuf_pool == NULL) {
 220                 RTE_LOG(ERR, USER1, "Big mbuf pool could not be created\n");
 221                 goto exit;
 222         }
 223
 224         ts_params->op_pool = rte_comp_op_pool_create("op_pool", NUM_OPS,
 225                                 0, sizeof(struct priv_op_data),
 226                                 rte_socket_id());
 227         if (ts_params->op_pool == NULL) {
 228                 RTE_LOG(ERR, USER1, "Operation pool could not be created\n");
 229                 goto exit;
 230         }
 231
 232         ts_params->def_comp_xform =
 233                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
 234         if (ts_params->def_comp_xform == NULL) {
 235                 RTE_LOG(ERR, USER1,
 236                         "Default compress xform could not be created\n");
 237                 goto exit;
 238         }
 239         ts_params->def_decomp_xform =
 240                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
 241         if (ts_params->def_decomp_xform == NULL) {
 242                 RTE_LOG(ERR, USER1,
 243                         "Default decompress xform could not be created\n");
 244                 goto exit;
 245         }
 246
 247         /* Initializes default values for compress/decompress xforms */
 248         ts_params->def_comp_xform->type = RTE_COMP_COMPRESS;
 249         ts_params->def_comp_xform->compress.algo = RTE_COMP_ALGO_DEFLATE,
 250         ts_params->def_comp_xform->compress.deflate.huffman =
 251                                                 RTE_COMP_HUFFMAN_DEFAULT;
 252         ts_params->def_comp_xform->compress.level = RTE_COMP_LEVEL_PMD_DEFAULT;
 253         ts_params->def_comp_xform->compress.chksum = RTE_COMP_CHECKSUM_NONE;
 254         ts_params->def_comp_xform->compress.window_size = DEFAULT_WINDOW_SIZE;
 255
 256         ts_params->def_decomp_xform->type = RTE_COMP_DECOMPRESS;
 257         ts_params->def_decomp_xform->decompress.algo = RTE_COMP_ALGO_DEFLATE,
 258         ts_params->def_decomp_xform->decompress.chksum = RTE_COMP_CHECKSUM_NONE;
 259         ts_params->def_decomp_xform->decompress.window_size = DEFAULT_WINDOW_SIZE;
 260
 261         return TEST_SUCCESS;
 262
 263 exit:
 264         testsuite_teardown();
 265
 266         return TEST_FAILED;
 267 }
 268
 269 static int
 270 generic_ut_setup(void)
 271 {
 272         /* Configure compressdev (one device, one queue pair) */
 273         struct rte_compressdev_config config = {
 274                 .socket_id = rte_socket_id(),
 275                 .nb_queue_pairs = 1,
 276                 .max_nb_priv_xforms = NUM_MAX_XFORMS,
 277                 .max_nb_streams = 1
 278         };
 279
 280         if (rte_compressdev_configure(0, &config) < 0) {
 281                 RTE_LOG(ERR, USER1, "Device configuration failed\n");
 282                 return -1;
 283         }
 284
 285         if (rte_compressdev_queue_pair_setup(0, 0, NUM_MAX_INFLIGHT_OPS,
 286                         rte_socket_id()) < 0) {
 287                 RTE_LOG(ERR, USER1, "Queue pair setup failed\n");
 288                 return -1;
 289         }
 290
 291         if (rte_compressdev_start(0) < 0) {
 292                 RTE_LOG(ERR, USER1, "Device could not be started\n");
 293                 return -1;
 294         }
 295
 296         return 0;
 297 }
 298
 299 static void
 300 generic_ut_teardown(void)
 301 {
 302         rte_compressdev_stop(0);
 303         if (rte_compressdev_close(0) < 0)
 304                 RTE_LOG(ERR, USER1, "Device could not be closed\n");
 305 }
 306
 307 static int
 308 test_compressdev_invalid_configuration(void)
 309 {
 310         struct rte_compressdev_config invalid_config;
 311         struct rte_compressdev_config valid_config = {
 312                 .socket_id = rte_socket_id(),
 313                 .nb_queue_pairs = 1,
 314                 .max_nb_priv_xforms = NUM_MAX_XFORMS,
 315                 .max_nb_streams = 1
 316         };
 317         struct rte_compressdev_info dev_info;
 318
 319         /* Invalid configuration with 0 queue pairs */
 320         memcpy(&invalid_config, &valid_config,
 321                         sizeof(struct rte_compressdev_config));
 322         invalid_config.nb_queue_pairs = 0;
 323
 324         TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
 325                         "Device configuration was successful "
 326                         "with no queue pairs (invalid)\n");
 327
 328         /*
 329          * Invalid configuration with too many queue pairs
 330          * (if there is an actual maximum number of queue pairs)
 331          */
 332         rte_compressdev_info_get(0, &dev_info);
 333         if (dev_info.max_nb_queue_pairs != 0) {
 334                 memcpy(&invalid_config, &valid_config,
 335                         sizeof(struct rte_compressdev_config));
 336                 invalid_config.nb_queue_pairs = dev_info.max_nb_queue_pairs + 1;
 337
 338                 TEST_ASSERT_FAIL(rte_compressdev_configure(0, &invalid_config),
 339                                 "Device configuration was successful "
 340                                 "with too many queue pairs (invalid)\n");
 341         }
 342
 343         /* Invalid queue pair setup, with no number of queue pairs set */
 344         TEST_ASSERT_FAIL(rte_compressdev_queue_pair_setup(0, 0,
 345                                 NUM_MAX_INFLIGHT_OPS, rte_socket_id()),
 346                         "Queue pair setup was successful "
 347                         "with no queue pairs set (invalid)\n");
 348
 349         return TEST_SUCCESS;
 350 }
 351
 352 static int
 353 compare_buffers(const char *buffer1, uint32_t buffer1_len,
 354                 const char *buffer2, uint32_t buffer2_len)
 355 {
 356         if (buffer1_len != buffer2_len) {
 357                 RTE_LOG(ERR, USER1, "Buffer lengths are different\n");
 358                 return -1;
 359         }
 360
 361         if (memcmp(buffer1, buffer2, buffer1_len) != 0) {
 362                 RTE_LOG(ERR, USER1, "Buffers are different\n");
 363                 return -1;
 364         }
 365
 366         return 0;
 367 }
 368
 369 /*
 370  * Maps compressdev and Zlib flush flags
 371  */
 372 static int
 373 map_zlib_flush_flag(enum rte_comp_flush_flag flag)
 374 {
 375         switch (flag) {
 376         case RTE_COMP_FLUSH_NONE:
 377                 return Z_NO_FLUSH;
 378         case RTE_COMP_FLUSH_SYNC:
 379                 return Z_SYNC_FLUSH;
 380         case RTE_COMP_FLUSH_FULL:
 381                 return Z_FULL_FLUSH;
 382         case RTE_COMP_FLUSH_FINAL:
 383                 return Z_FINISH;
 384         /*
 385          * There should be only the values above,
 386          * so this should never happen
 387          */
 388         default:
 389                 return -1;
 390         }
 391 }
 392
 393 static int
 394 compress_zlib(struct rte_comp_op *op,
 395                 const struct rte_comp_xform *xform, int mem_level)
 396 {
 397         z_stream stream;
 398         int zlib_flush;
 399         int strategy, window_bits, comp_level;
 400         int ret = TEST_FAILED;
 401         uint8_t *single_src_buf = NULL;
 402         uint8_t *single_dst_buf = NULL;
 403
 404         /* initialize zlib stream */
 405         stream.zalloc = Z_NULL;
 406         stream.zfree = Z_NULL;
 407         stream.opaque = Z_NULL;
 408
 409         if (xform->compress.deflate.huffman == RTE_COMP_HUFFMAN_FIXED)
 410                 strategy = Z_FIXED;
 411         else
 412                 strategy = Z_DEFAULT_STRATEGY;
 413
 414         /*
 415          * Window bits is the base two logarithm of the window size (in bytes).
 416          * When doing raw DEFLATE, this number will be negative.
 417          */
 418         window_bits = -(xform->compress.window_size);
 419         if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32)
 420                 window_bits *= -1;
 421         else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32)
 422                 window_bits = ZLIB_CRC_CHECKSUM_WINDOW_BITS;
 423
 424         comp_level = xform->compress.level;
 425
 426         if (comp_level != RTE_COMP_LEVEL_NONE)
 427                 ret = deflateInit2(&stream, comp_level, Z_DEFLATED,
 428                         window_bits, mem_level, strategy);
 429         else
 430                 ret = deflateInit(&stream, Z_NO_COMPRESSION);
 431
 432         if (ret != Z_OK) {
 433                 printf("Zlib deflate could not be initialized\n");
 434                 goto exit;
 435         }
 436
 437         /* Assuming stateless operation */
 438         /* SGL Input */
 439         if (op->m_src->nb_segs > 1) {
 440                 single_src_buf = rte_malloc(NULL,
 441                                 rte_pktmbuf_pkt_len(op->m_src), 0);
 442                 if (single_src_buf == NULL) {
 443                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 444                         goto exit;
 445                 }
 446
 447                 if (rte_pktmbuf_read(op->m_src, op->src.offset,
 448                                         rte_pktmbuf_pkt_len(op->m_src) -
 449                                         op->src.offset,
 450                                         single_src_buf) == NULL) {
 451                         RTE_LOG(ERR, USER1,
 452                                 "Buffer could not be read entirely\n");
 453                         goto exit;
 454                 }
 455
 456                 stream.avail_in = op->src.length;
 457                 stream.next_in = single_src_buf;
 458
 459         } else {
 460                 stream.avail_in = op->src.length;
 461                 stream.next_in = rte_pktmbuf_mtod_offset(op->m_src, uint8_t *,
 462                                 op->src.offset);
 463         }
 464         /* SGL output */
 465         if (op->m_dst->nb_segs > 1) {
 466
 467                 single_dst_buf = rte_malloc(NULL,
 468                                 rte_pktmbuf_pkt_len(op->m_dst), 0);
 469                         if (single_dst_buf == NULL) {
 470                                 RTE_LOG(ERR, USER1,
 471                                         "Buffer could not be allocated\n");
 472                         goto exit;
 473                 }
 474
 475                 stream.avail_out = op->m_dst->pkt_len;
 476                 stream.next_out = single_dst_buf;
 477
 478         } else {/* linear output */
 479                 stream.avail_out = op->m_dst->data_len;
 480                 stream.next_out = rte_pktmbuf_mtod_offset(op->m_dst, uint8_t *,
 481                                 op->dst.offset);
 482         }
 483
 484         /* Stateless operation, all buffer will be compressed in one go */
 485         zlib_flush = map_zlib_flush_flag(op->flush_flag);
 486         ret = deflate(&stream, zlib_flush);
 487
 488         if (stream.avail_in != 0) {
 489                 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
 490                 goto exit;
 491         }
 492
 493         if (ret != Z_STREAM_END)
 494                 goto exit;
 495
 496         /* Copy data to destination SGL */
 497         if (op->m_dst->nb_segs > 1) {
 498                 uint32_t remaining_data = stream.total_out;
 499                 uint8_t *src_data = single_dst_buf;
 500                 struct rte_mbuf *dst_buf = op->m_dst;
 501
 502                 while (remaining_data > 0) {
 503                         uint8_t *dst_data = rte_pktmbuf_mtod_offset(dst_buf,
 504                                                 uint8_t *, op->dst.offset);
 505                         /* Last segment */
 506                         if (remaining_data < dst_buf->data_len) {
 507                                 memcpy(dst_data, src_data, remaining_data);
 508                                 remaining_data = 0;
 509                         } else {
 510                                 memcpy(dst_data, src_data, dst_buf->data_len);
 511                                 remaining_data -= dst_buf->data_len;
 512                                 src_data += dst_buf->data_len;
 513                                 dst_buf = dst_buf->next;
 514                         }
 515                 }
 516         }
 517
 518         op->consumed = stream.total_in;
 519         if (xform->compress.chksum == RTE_COMP_CHECKSUM_ADLER32) {
 520                 rte_pktmbuf_adj(op->m_dst, ZLIB_HEADER_SIZE);
 521                 rte_pktmbuf_trim(op->m_dst, ZLIB_TRAILER_SIZE);
 522                 op->produced = stream.total_out - (ZLIB_HEADER_SIZE +
 523                                 ZLIB_TRAILER_SIZE);
 524         } else if (xform->compress.chksum == RTE_COMP_CHECKSUM_CRC32) {
 525                 rte_pktmbuf_adj(op->m_dst, GZIP_HEADER_SIZE);
 526                 rte_pktmbuf_trim(op->m_dst, GZIP_TRAILER_SIZE);
 527                 op->produced = stream.total_out - (GZIP_HEADER_SIZE +
 528                                 GZIP_TRAILER_SIZE);
 529         } else
 530                 op->produced = stream.total_out;
 531
 532         op->status = RTE_COMP_OP_STATUS_SUCCESS;
 533         op->output_chksum = stream.adler;
 534
 535         deflateReset(&stream);
 536
 537         ret = 0;
 538 exit:
 539         deflateEnd(&stream);
 540         rte_free(single_src_buf);
 541         rte_free(single_dst_buf);
 542
 543         return ret;
 544 }
 545
 546 static int
 547 decompress_zlib(struct rte_comp_op *op,
 548                 const struct rte_comp_xform *xform)
 549 {
 550         z_stream stream;
 551         int window_bits;
 552         int zlib_flush;
 553         int ret = TEST_FAILED;
 554         uint8_t *single_src_buf = NULL;
 555         uint8_t *single_dst_buf = NULL;
 556
 557         /* initialize zlib stream */
 558         stream.zalloc = Z_NULL;
 559         stream.zfree = Z_NULL;
 560         stream.opaque = Z_NULL;
 561
 562         /*
 563          * Window bits is the base two logarithm of the window size (in bytes).
 564          * When doing raw DEFLATE, this number will be negative.
 565          */
 566         window_bits = -(xform->decompress.window_size);
 567         ret = inflateInit2(&stream, window_bits);
 568
 569         if (ret != Z_OK) {
 570                 printf("Zlib deflate could not be initialized\n");
 571                 goto exit;
 572         }
 573
 574         /* Assuming stateless operation */
 575         /* SGL */
 576         if (op->m_src->nb_segs > 1) {
 577                 single_src_buf = rte_malloc(NULL,
 578                                 rte_pktmbuf_pkt_len(op->m_src), 0);
 579                 if (single_src_buf == NULL) {
 580                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 581                         goto exit;
 582                 }
 583                 single_dst_buf = rte_malloc(NULL,
 584                                 rte_pktmbuf_pkt_len(op->m_dst), 0);
 585                 if (single_dst_buf == NULL) {
 586                         RTE_LOG(ERR, USER1, "Buffer could not be allocated\n");
 587                         goto exit;
 588                 }
 589                 if (rte_pktmbuf_read(op->m_src, 0,
 590                                         rte_pktmbuf_pkt_len(op->m_src),
 591                                         single_src_buf) == NULL) {
 592                         RTE_LOG(ERR, USER1,
 593                                 "Buffer could not be read entirely\n");
 594                         goto exit;
 595                 }
 596
 597                 stream.avail_in = op->src.length;
 598                 stream.next_in = single_src_buf;
 599                 stream.avail_out = rte_pktmbuf_pkt_len(op->m_dst);
 600                 stream.next_out = single_dst_buf;
 601
 602         } else {
 603                 stream.avail_in = op->src.length;
 604                 stream.next_in = rte_pktmbuf_mtod(op->m_src, uint8_t *);
 605                 stream.avail_out = op->m_dst->data_len;
 606                 stream.next_out = rte_pktmbuf_mtod(op->m_dst, uint8_t *);
 607         }
 608
 609         /* Stateless operation, all buffer will be compressed in one go */
 610         zlib_flush = map_zlib_flush_flag(op->flush_flag);
 611         ret = inflate(&stream, zlib_flush);
 612
 613         if (stream.avail_in != 0) {
 614                 RTE_LOG(ERR, USER1, "Buffer could not be read entirely\n");
 615                 goto exit;
 616         }
 617
 618         if (ret != Z_STREAM_END)
 619                 goto exit;
 620
 621         if (op->m_src->nb_segs > 1) {
 622                 uint32_t remaining_data = stream.total_out;
 623                 uint8_t *src_data = single_dst_buf;
 624                 struct rte_mbuf *dst_buf = op->m_dst;
 625
 626                 while (remaining_data > 0) {
 627                         uint8_t *dst_data = rte_pktmbuf_mtod(dst_buf,
 628                                         uint8_t *);
 629                         /* Last segment */
 630                         if (remaining_data < dst_buf->data_len) {
 631                                 memcpy(dst_data, src_data, remaining_data);
 632                                 remaining_data = 0;
 633                         } else {
 634                                 memcpy(dst_data, src_data, dst_buf->data_len);
 635                                 remaining_data -= dst_buf->data_len;
 636                                 src_data += dst_buf->data_len;
 637                                 dst_buf = dst_buf->next;
 638                         }
 639                 }
 640         }
 641
 642         op->consumed = stream.total_in;
 643         op->produced = stream.total_out;
 644         op->status = RTE_COMP_OP_STATUS_SUCCESS;
 645
 646         inflateReset(&stream);
 647
 648         ret = 0;
 649 exit:
 650         inflateEnd(&stream);
 651
 652         return ret;
 653 }
 654
 655 static int
 656 prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 657                 uint32_t total_data_size,
 658                 struct rte_mempool *small_mbuf_pool,
 659                 struct rte_mempool *large_mbuf_pool,
 660                 uint8_t limit_segs_in_sgl,
 661                 uint16_t seg_size)
 662 {
 663         uint32_t remaining_data = total_data_size;
 664         uint16_t num_remaining_segs = DIV_CEIL(remaining_data, seg_size);
 665         struct rte_mempool *pool;
 666         struct rte_mbuf *next_seg;
 667         uint32_t data_size;
 668         char *buf_ptr;
 669         const char *data_ptr = test_buf;
 670         uint16_t i;
 671         int ret;
 672
 673         if (limit_segs_in_sgl != 0 && num_remaining_segs > limit_segs_in_sgl)
 674                 num_remaining_segs = limit_segs_in_sgl - 1;
 675
 676         /*
 677          * Allocate data in the first segment (header) and
 678          * copy data if test buffer is provided
 679          */
 680         if (remaining_data < seg_size)
 681                 data_size = remaining_data;
 682         else
 683                 data_size = seg_size;
 684
 685         buf_ptr = rte_pktmbuf_append(head_buf, data_size);
 686         if (buf_ptr == NULL) {
 687                 RTE_LOG(ERR, USER1,
 688                         "Not enough space in the 1st buffer\n");
 689                 return -1;
 690         }
 691
 692         if (data_ptr != NULL) {
 693                 /* Copy characters without NULL terminator */
 694                 strncpy(buf_ptr, data_ptr, data_size);
 695                 data_ptr += data_size;
 696         }
 697         remaining_data -= data_size;
 698         num_remaining_segs--;
 699
 700         /*
 701          * Allocate the rest of the segments,
 702          * copy the rest of the data and chain the segments.
 703          */
 704         for (i = 0; i < num_remaining_segs; i++) {
 705
 706                 if (i == (num_remaining_segs - 1)) {
 707                         /* last segment */
 708                         if (remaining_data > seg_size)
 709                                 pool = large_mbuf_pool;
 710                         else
 711                                 pool = small_mbuf_pool;
 712                         data_size = remaining_data;
 713                 } else {
 714                         data_size = seg_size;
 715                         pool = small_mbuf_pool;
 716                 }
 717
 718                 next_seg = rte_pktmbuf_alloc(pool);
 719                 if (next_seg == NULL) {
 720                         RTE_LOG(ERR, USER1,
 721                                 "New segment could not be allocated "
 722                                 "from the mempool\n");
 723                         return -1;
 724                 }
 725                 buf_ptr = rte_pktmbuf_append(next_seg, data_size);
 726                 if (buf_ptr == NULL) {
 727                         RTE_LOG(ERR, USER1,
 728                                 "Not enough space in the buffer\n");
 729                         rte_pktmbuf_free(next_seg);
 730                         return -1;
 731                 }
 732                 if (data_ptr != NULL) {
 733                         /* Copy characters without NULL terminator */
 734                         strncpy(buf_ptr, data_ptr, data_size);
 735                         data_ptr += data_size;
 736                 }
 737                 remaining_data -= data_size;
 738
 739                 ret = rte_pktmbuf_chain(head_buf, next_seg);
 740                 if (ret != 0) {
 741                         rte_pktmbuf_free(next_seg);
 742                         RTE_LOG(ERR, USER1,
 743                                 "Segment could not chained\n");
 744                         return -1;
 745                 }
 746         }
 747
 748         return 0;
 749 }
 750
 751 static void
 752 extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
 753 {
 754 }
 755
 756 static int
 757 test_run_enqueue_dequeue(struct rte_comp_op **ops,
 758                          struct rte_comp_op **ops_processed,
 759                          unsigned int num_bufs)
 760 {
 761         uint16_t num_enqd, num_deqd, num_total_deqd;
 762         unsigned int deqd_retries = 0;
 763
 764         /* Enqueue and dequeue all operations */
 765         num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
 766         if (num_enqd < num_bufs) {
 767                 RTE_LOG(ERR, USER1,
 768                         "Some operations could not be enqueued\n");
 769                 return -1;
 770         }
 771
 772         num_total_deqd = 0;
 773         do {
 774                 /*
 775                  * If retrying a dequeue call, wait for 10 ms to allow
 776                  * enough time to the driver to process the operations
 777                  */
 778                 if (deqd_retries != 0) {
 779                         /*
 780                          * Avoid infinite loop if not all the
 781                          * operations get out of the device
 782                          */
 783                         if (deqd_retries == MAX_DEQD_RETRIES) {
 784                                 RTE_LOG(ERR, USER1,
 785                                         "Not all operations could be dequeued\n");
 786                                 return -1;
 787                         }
 788                         usleep(DEQUEUE_WAIT_TIME);
 789                 }
 790                 num_deqd = rte_compressdev_dequeue_burst(0, 0,
 791                                 &ops_processed[num_total_deqd], num_bufs);
 792                 num_total_deqd += num_deqd;
 793                 deqd_retries++;
 794
 795         } while (num_total_deqd < num_enqd);
 796
 797         return 0;
 798 }
 799
 800 /**
 801  * Arrays initialization. Input buffers preparation for compression.
 802  *
 803  * API that initializes all the private arrays to NULL
 804  * and allocates input buffers to perform compression operations.
 805  *
 806  * @param int_data
 807  *   Interim data containing session/transformation objects.
 808  * @param test_data
 809  *   The test parameters set by users (command line parameters).
 810  * @param test_priv_data
 811  *   A container used for aggregation all the private test arrays.
 812  * @return
 813  *   - 0: On success.
 814  *   - -1: On error.
 815  */
 816 static int
 817 test_setup_com_bufs(const struct interim_data_params *int_data,
 818                 const struct test_data_params *test_data,
 819                 const struct test_private_arrays *test_priv_data)
 820 {
 821         /* local variables: */
 822         unsigned int i;
 823         uint32_t data_size;
 824         char *buf_ptr;
 825         int ret;
 826         char **all_decomp_data = test_priv_data->all_decomp_data;
 827
 828         struct comp_testsuite_params *ts_params = &testsuite_params;
 829
 830         /* from int_data: */
 831         const char * const *test_bufs = int_data->test_bufs;
 832         unsigned int num_bufs = int_data->num_bufs;
 833
 834         /* from test_data: */
 835         unsigned int buff_type = test_data->buff_type;
 836         unsigned int big_data = test_data->big_data;
 837
 838         /* from test_priv_data: */
 839         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
 840         struct rte_mempool *buf_pool;
 841
 842         static struct rte_mbuf_ext_shared_info inbuf_info;
 843
 844         size_t array_size = sizeof(void *) * num_bufs;
 845
 846         /* Initialize all arrays to NULL */
 847         memset(test_priv_data->uncomp_bufs, 0, array_size);
 848         memset(test_priv_data->comp_bufs, 0, array_size);
 849         memset(test_priv_data->ops, 0, array_size);
 850         memset(test_priv_data->ops_processed, 0, array_size);
 851         memset(test_priv_data->priv_xforms, 0, array_size);
 852         memset(test_priv_data->compressed_data_size,
 853                0, sizeof(uint32_t) * num_bufs);
 854
 855         if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
 856                 data_size = strlen(test_bufs[0]) + 1;
 857                 *all_decomp_data = rte_malloc(NULL, data_size,
 858                                              RTE_CACHE_LINE_SIZE);
 859         }
 860
 861         if (big_data)
 862                 buf_pool = ts_params->big_mbuf_pool;
 863         else if (buff_type == SGL_BOTH)
 864                 buf_pool = ts_params->small_mbuf_pool;
 865         else
 866                 buf_pool = ts_params->large_mbuf_pool;
 867
 868         /* for compression uncomp_bufs is used as a source buffer */
 869         /* allocation from buf_pool (mempool type) */
 870         ret = rte_pktmbuf_alloc_bulk(buf_pool,
 871                                 uncomp_bufs, num_bufs);
 872         if (ret < 0) {
 873                 RTE_LOG(ERR, USER1,
 874                         "Source mbufs could not be allocated "
 875                         "from the mempool\n");
 876                 return -1;
 877         }
 878
 879         if (test_data->use_external_mbufs) {
 880                 inbuf_info.free_cb = extbuf_free_callback;
 881                 inbuf_info.fcb_opaque = NULL;
 882                 rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
 883                 for (i = 0; i < num_bufs; i++) {
 884                         rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
 885                                         test_data->inbuf_memzone->addr,
 886                                         test_data->inbuf_memzone->iova,
 887                                         test_data->inbuf_data_size,
 888                                         &inbuf_info);
 889                         buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
 890                                         test_data->inbuf_data_size);
 891                         if (buf_ptr == NULL) {
 892                                 RTE_LOG(ERR, USER1,
 893                                         "Append extra bytes to the source mbuf failed\n");
 894                                 return -1;
 895                         }
 896                 }
 897         } else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 898                 for (i = 0; i < num_bufs; i++) {
 899                         data_size = strlen(test_bufs[i]) + 1;
 900                         if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
 901                             data_size,
 902                             big_data ? buf_pool : ts_params->small_mbuf_pool,
 903                             big_data ? buf_pool : ts_params->large_mbuf_pool,
 904                             big_data ? 0 : MAX_SEGS,
 905                             big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
 906                                 return -1;
 907                 }
 908         } else {
 909                 for (i = 0; i < num_bufs; i++) {
 910                         data_size = strlen(test_bufs[i]) + 1;
 911
 912                         buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
 913                         if (buf_ptr == NULL) {
 914                                 RTE_LOG(ERR, USER1,
 915                                         "Append extra bytes to the source mbuf failed\n");
 916                                 return -1;
 917                         }
 918                         strlcpy(buf_ptr, test_bufs[i], data_size);
 919                 }
 920         }
 921
 922         return 0;
 923 }
 924
 925 /**
 926  * Data size calculation (for both compression and decompression).
 927  *
 928  * Calculate size of anticipated output buffer required for both
 929  * compression and decompression operations based on input int_data.
 930  *
 931  * @param op_type
 932  *   Operation type: compress or decompress
 933  * @param out_of_space_and_zlib
 934  *   Boolean value to switch into "out of space" buffer if set.
 935  *   To test "out-of-space" data size, zlib_decompress must be set as well.
 936  * @param test_priv_data
 937  *   A container used for aggregation all the private test arrays.
 938  * @param int_data
 939  *   Interim data containing session/transformation objects.
 940  * @param test_data
 941  *   The test parameters set by users (command line parameters).
 942  * @param i
 943  *   current buffer index
 944  * @return
 945  *   data size
 946  */
 947 static inline uint32_t
 948 test_mbufs_calculate_data_size(
 949                 enum operation_type op_type,
 950                 unsigned int out_of_space_and_zlib,
 951                 const struct test_private_arrays *test_priv_data,
 952                 const struct interim_data_params *int_data,
 953                 const struct test_data_params *test_data,
 954                 unsigned int i)
 955 {
 956         /* local variables: */
 957         uint32_t data_size;
 958         struct priv_op_data *priv_data;
 959         float ratio;
 960         uint8_t not_zlib_compr; /* true if zlib isn't current compression dev */
 961         enum overflow_test overflow = test_data->overflow;
 962
 963         /* from test_priv_data: */
 964         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
 965
 966         /* from int_data: */
 967         const char * const *test_bufs = int_data->test_bufs;
 968
 969         if (out_of_space_and_zlib)
 970                 data_size = OUT_OF_SPACE_BUF;
 971         else {
 972                 if (op_type == OPERATION_COMPRESSION) {
 973                         not_zlib_compr = (test_data->zlib_dir == ZLIB_DECOMPRESS
 974                                 || test_data->zlib_dir == ZLIB_NONE);
 975
 976                         ratio = (not_zlib_compr &&
 977                                 (overflow == OVERFLOW_ENABLED)) ?
 978                                 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
 979                                 COMPRESS_BUF_SIZE_RATIO;
 980
 981                         data_size = strlen(test_bufs[i]) * ratio;
 982
 983                 } else {
 984                         priv_data = (struct priv_op_data *)
 985                                         (ops_processed[i] + 1);
 986                         data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
 987                 }
 988         }
 989
 990         return data_size;
 991 }
 992
 993
 994 /**
 995  * Memory buffers preparation (for both compression and decompression).
 996  *
 997  * Function allocates output buffers to perform compression
 998  * or decompression operations depending on value of op_type.
 999  *
1000  * @param op_type
1001  *   Operation type: compress or decompress
1002  * @param out_of_space_and_zlib
1003  *   Boolean value to switch into "out of space" buffer if set.
1004  *   To test "out-of-space" data size, zlib_decompress must be set as well.
1005  * @param test_priv_data
1006  *   A container used for aggregation all the private test arrays.
1007  * @param int_data
1008  *   Interim data containing session/transformation objects.
1009  * @param test_data
1010  *   The test parameters set by users (command line parameters).
1011  * @param current_extbuf_info,
1012  *   The structure containing all the information related to external mbufs
1013  * @return
1014  *   - 0: On success.
1015  *   - -1: On error.
1016  */
1017 static int
1018 test_setup_output_bufs(
1019                 enum operation_type op_type,
1020                 unsigned int out_of_space_and_zlib,
1021                 const struct test_private_arrays *test_priv_data,
1022                 const struct interim_data_params *int_data,
1023                 const struct test_data_params *test_data,
1024                 struct rte_mbuf_ext_shared_info *current_extbuf_info)
1025 {
1026         /* local variables: */
1027         unsigned int i;
1028         uint32_t data_size;
1029         int ret;
1030         char *buf_ptr;
1031
1032         /* from test_priv_data: */
1033         struct rte_mbuf **current_bufs;
1034
1035         /* from int_data: */
1036         unsigned int num_bufs = int_data->num_bufs;
1037
1038         /* from test_data: */
1039         unsigned int buff_type = test_data->buff_type;
1040         unsigned int big_data = test_data->big_data;
1041         const struct rte_memzone *current_memzone;
1042
1043         struct comp_testsuite_params *ts_params = &testsuite_params;
1044         struct rte_mempool *buf_pool;
1045
1046         if (big_data)
1047                 buf_pool = ts_params->big_mbuf_pool;
1048         else if (buff_type == SGL_BOTH)
1049                 buf_pool = ts_params->small_mbuf_pool;
1050         else
1051                 buf_pool = ts_params->large_mbuf_pool;
1052
1053         if (op_type == OPERATION_COMPRESSION)
1054                 current_bufs = test_priv_data->comp_bufs;
1055         else
1056                 current_bufs = test_priv_data->uncomp_bufs;
1057
1058         /* the mbufs allocation*/
1059         ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
1060         if (ret < 0) {
1061                 RTE_LOG(ERR, USER1,
1062                         "Destination mbufs could not be allocated "
1063                         "from the mempool\n");
1064                 return -1;
1065         }
1066
1067         if (test_data->use_external_mbufs) {
1068                 current_extbuf_info->free_cb = extbuf_free_callback;
1069                 current_extbuf_info->fcb_opaque = NULL;
1070                 rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
1071                 if (op_type == OPERATION_COMPRESSION)
1072                         current_memzone = test_data->compbuf_memzone;
1073                 else
1074                         current_memzone = test_data->uncompbuf_memzone;
1075
1076                 for (i = 0; i < num_bufs; i++) {
1077                         rte_pktmbuf_attach_extbuf(current_bufs[i],
1078                                         current_memzone->addr,
1079                                         current_memzone->iova,
1080                                         current_memzone->len,
1081                                         current_extbuf_info);
1082                         rte_pktmbuf_append(current_bufs[i],
1083                                         current_memzone->len);
1084                 }
1085         } else {
1086                 for (i = 0; i < num_bufs; i++) {
1087
1088                         /* data size calculation */
1089                         data_size = test_mbufs_calculate_data_size(
1090                                         op_type,
1091                                         out_of_space_and_zlib,
1092                                         test_priv_data,
1093                                         int_data,
1094                                         test_data,
1095                                         i);
1096
1097                         /* data allocation */
1098                         if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
1099                                 ret = prepare_sgl_bufs(NULL, current_bufs[i],
1100                                       data_size,
1101                                       big_data ? buf_pool :
1102                                                 ts_params->small_mbuf_pool,
1103                                       big_data ? buf_pool :
1104                                                 ts_params->large_mbuf_pool,
1105                                       big_data ? 0 : MAX_SEGS,
1106                                       big_data ? MAX_DATA_MBUF_SIZE :
1107                                                  SMALL_SEG_SIZE);
1108                                 if (ret < 0)
1109                                         return -1;
1110                         } else {
1111                                 buf_ptr = rte_pktmbuf_append(current_bufs[i],
1112                                                 data_size);
1113                                 if (buf_ptr == NULL) {
1114                                         RTE_LOG(ERR, USER1,
1115                                                 "Append extra bytes to the destination mbuf failed\n");
1116                                         return -1;
1117                                 }
1118                         }
1119                 }
1120         }
1121
1122         return 0;
1123 }
1124
1125 /**
1126  * The main compression function.
1127  *
1128  * Function performs compression operation.
1129  * Operation(s) configuration, depending on CLI parameters.
1130  * Operation(s) processing.
1131  *
1132  * @param int_data
1133  *   Interim data containing session/transformation objects.
1134  * @param test_data
1135  *   The test parameters set by users (command line parameters).
1136  * @param test_priv_data
1137  *   A container used for aggregation all the private test arrays.
1138  * @return
1139  *   - 0: On success.
1140  *   - -1: On error.
1141  */
1142 static int
1143 test_deflate_comp_run(const struct interim_data_params *int_data,
1144                 const struct test_data_params *test_data,
1145                 const struct test_private_arrays *test_priv_data)
1146 {
1147         /* local variables: */
1148         struct priv_op_data *priv_data;
1149         unsigned int i;
1150         uint16_t num_priv_xforms = 0;
1151         int ret;
1152         int ret_status = 0;
1153         char *buf_ptr;
1154
1155         struct comp_testsuite_params *ts_params = &testsuite_params;
1156
1157         /* from test_data: */
1158         enum rte_comp_op_type operation_type = test_data->compress_state;
1159         unsigned int zlib_compress =
1160                         (test_data->zlib_dir == ZLIB_ALL ||
1161                         test_data->zlib_dir == ZLIB_COMPRESS);
1162
1163         /* from int_data: */
1164         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1165         unsigned int num_xforms = int_data->num_xforms;
1166         unsigned int num_bufs = int_data->num_bufs;
1167
1168         /* from test_priv_data: */
1169         struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1170         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1171         struct rte_comp_op **ops = test_priv_data->ops;
1172         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1173         void **priv_xforms = test_priv_data->priv_xforms;
1174
1175         const struct rte_compressdev_capabilities *capa =
1176                 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1177
1178         /* Build the compression operations */
1179         ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1180         if (ret < 0) {
1181                 RTE_LOG(ERR, USER1,
1182                         "Compress operations could not be allocated "
1183                         "from the mempool\n");
1184                 ret_status = -1;
1185                 goto exit;
1186         }
1187
1188         for (i = 0; i < num_bufs; i++) {
1189                 ops[i]->m_src = uncomp_bufs[i];
1190                 ops[i]->m_dst = comp_bufs[i];
1191                 ops[i]->src.offset = 0;
1192                 ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
1193                 ops[i]->dst.offset = 0;
1194
1195                 if (operation_type == RTE_COMP_OP_STATELESS) {
1196                         ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1197                 } else {
1198                         RTE_LOG(ERR, USER1,
1199                                 "Compression: stateful operations are not "
1200                                 "supported in these tests yet\n");
1201                         ret_status = -1;
1202                         goto exit;
1203                 }
1204                 ops[i]->input_chksum = 0;
1205                 /*
1206                  * Store original operation index in private data,
1207                  * since ordering does not have to be maintained,
1208                  * when dequeueing from compressdev, so a comparison
1209                  * at the end of the test can be done.
1210                  */
1211                 priv_data = (struct priv_op_data *) (ops[i] + 1);
1212                 priv_data->orig_idx = i;
1213         }
1214
1215         /* Compress data (either with Zlib API or compressdev API */
1216         if (zlib_compress) {
1217                 for (i = 0; i < num_bufs; i++) {
1218                         const struct rte_comp_xform *compress_xform =
1219                                 compress_xforms[i % num_xforms];
1220                         ret = compress_zlib(ops[i], compress_xform,
1221                                         DEFAULT_MEM_LEVEL);
1222                         if (ret < 0) {
1223                                 ret_status = -1;
1224                                 goto exit;
1225                         }
1226
1227                         ops_processed[i] = ops[i];
1228                 }
1229         } else {
1230                 /* Create compress private xform data */
1231                 for (i = 0; i < num_xforms; i++) {
1232                         ret = rte_compressdev_private_xform_create(0,
1233                                 (const struct rte_comp_xform *)
1234                                         compress_xforms[i],
1235                                 &priv_xforms[i]);
1236                         if (ret < 0) {
1237                                 RTE_LOG(ERR, USER1,
1238                                         "Compression private xform "
1239                                         "could not be created\n");
1240                                 ret_status = -1;
1241                                 goto exit;
1242                         }
1243                         num_priv_xforms++;
1244                 }
1245                 if (capa->comp_feature_flags &
1246                                 RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1247                         /* Attach shareable private xform data to ops */
1248                         for (i = 0; i < num_bufs; i++)
1249                                 ops[i]->private_xform =
1250                                                 priv_xforms[i % num_xforms];
1251                 } else {
1252                 /* Create rest of the private xforms for the other ops */
1253                         for (i = num_xforms; i < num_bufs; i++) {
1254                                 ret = rte_compressdev_private_xform_create(0,
1255                                         compress_xforms[i % num_xforms],
1256                                         &priv_xforms[i]);
1257                                 if (ret < 0) {
1258                                         RTE_LOG(ERR, USER1,
1259                                                 "Compression private xform "
1260                                                 "could not be created\n");
1261                                         ret_status = -1;
1262                                         goto exit;
1263                                 }
1264                                 num_priv_xforms++;
1265                         }
1266                         /* Attach non shareable private xform data to ops */
1267                         for (i = 0; i < num_bufs; i++)
1268                                 ops[i]->private_xform = priv_xforms[i];
1269                 }
1270
1271 recovery_lb:
1272                 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
1273                 if (ret < 0) {
1274                         RTE_LOG(ERR, USER1,
1275                                 "Compression: enqueue/dequeue operation failed\n");
1276                         ret_status = -1;
1277                         goto exit;
1278                 }
1279
1280                 for (i = 0; i < num_bufs; i++) {
1281                         test_priv_data->compressed_data_size[i] +=
1282                                         ops_processed[i]->produced;
1283
1284                         if (ops_processed[i]->status ==
1285                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
1286
1287                                 ops[i]->status =
1288                                         RTE_COMP_OP_STATUS_NOT_PROCESSED;
1289                                 ops[i]->src.offset +=
1290                                         ops_processed[i]->consumed;
1291                                 ops[i]->src.length -=
1292                                         ops_processed[i]->consumed;
1293                                 ops[i]->dst.offset +=
1294                                         ops_processed[i]->produced;
1295
1296                                 buf_ptr = rte_pktmbuf_append(
1297                                         ops[i]->m_dst,
1298                                         ops_processed[i]->produced);
1299
1300                                 if (buf_ptr == NULL) {
1301                                         RTE_LOG(ERR, USER1,
1302                                                 "Data recovery: append extra bytes to the current mbuf failed\n");
1303                                         ret_status = -1;
1304                                         goto exit;
1305                                 }
1306                                 goto recovery_lb;
1307                         }
1308                 }
1309         }
1310
1311 exit:
1312         /* Free resources */
1313         if (ret_status < 0)
1314                 for (i = 0; i < num_bufs; i++) {
1315                         rte_comp_op_free(ops[i]);
1316                         ops_processed[i] = NULL;
1317                 }
1318
1319         /* Free compress private xforms */
1320         for (i = 0; i < num_priv_xforms; i++) {
1321                 if (priv_xforms[i] != NULL) {
1322                         rte_compressdev_private_xform_free(0, priv_xforms[i]);
1323                         priv_xforms[i] = NULL;
1324                 }
1325         }
1326
1327         return ret_status;
1328 }
1329
1330 /**
1331  * Prints out the test report. Memory freeing.
1332  *
1333  * Called after successful compression.
1334  * Operation(s) status validation and decompression buffers freeing.
1335
1336  * -1 returned if function fail.
1337  *
1338  * @param int_data
1339  *   Interim data containing session/transformation objects.
1340  * @param test_data
1341  *   The test parameters set by users (command line parameters).
1342  * @param test_priv_data
1343  *   A container used for aggregation all the private test arrays.
1344  * @return
1345  *   - 2: Some operation is not supported
1346  *   - 1: Decompression should be skipped
1347  *   - 0: On success.
1348  *   - -1: On error.
1349  */
1350 static int
1351 test_deflate_comp_finalize(const struct interim_data_params *int_data,
1352                 const struct test_data_params *test_data,
1353                 const struct test_private_arrays *test_priv_data)
1354 {
1355         /* local variables: */
1356         unsigned int i;
1357         struct priv_op_data *priv_data;
1358
1359         /* from int_data: */
1360         unsigned int num_xforms = int_data->num_xforms;
1361         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1362         uint16_t *buf_idx = int_data->buf_idx;
1363         unsigned int num_bufs = int_data->num_bufs;
1364
1365         /* from test_priv_data: */
1366         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1367         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1368         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1369         struct rte_comp_op **ops = test_priv_data->ops;
1370
1371         /* from test_data: */
1372         unsigned int out_of_space = test_data->out_of_space;
1373         unsigned int zlib_compress =
1374                         (test_data->zlib_dir == ZLIB_ALL ||
1375                         test_data->zlib_dir == ZLIB_COMPRESS);
1376         unsigned int zlib_decompress =
1377                         (test_data->zlib_dir == ZLIB_ALL ||
1378                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1379
1380         for (i = 0; i < num_bufs; i++) {
1381                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1382                 uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1383                 const struct rte_comp_compress_xform *compress_xform =
1384                                 &compress_xforms[xform_idx]->compress;
1385                 enum rte_comp_huffman huffman_type =
1386                         compress_xform->deflate.huffman;
1387                 char engine[] = "zlib (directly, not PMD)";
1388                 if (zlib_decompress)
1389                         strlcpy(engine, "PMD", sizeof(engine));
1390
1391                 RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
1392                         " %u bytes (level = %d, huffman = %s)\n",
1393                         buf_idx[priv_data->orig_idx], engine,
1394                         ops_processed[i]->consumed, ops_processed[i]->produced,
1395                         compress_xform->level,
1396                         huffman_type_strings[huffman_type]);
1397                 RTE_LOG(DEBUG, USER1, "Compression ratio = %.2f\n",
1398                         ops_processed[i]->consumed == 0 ? 0 :
1399                         (float)ops_processed[i]->produced /
1400                         ops_processed[i]->consumed * 100);
1401                 if (compress_xform->chksum != RTE_COMP_CHECKSUM_NONE)
1402                         compress_checksum[i] = ops_processed[i]->output_chksum;
1403                 ops[i] = NULL;
1404         }
1405
1406         /*
1407          * Check operation status and free source mbufs (destination mbuf and
1408          * compress operation information is needed for the decompression stage)
1409          */
1410         for (i = 0; i < num_bufs; i++) {
1411                 if (out_of_space && !zlib_compress) {
1412                         if (ops_processed[i]->status !=
1413                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1414                                 RTE_LOG(ERR, USER1,
1415                                         "Operation without expected out of "
1416                                         "space status error\n");
1417                                 return -1;
1418                         } else
1419                                 continue;
1420                 }
1421
1422                 if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
1423                         if (test_data->overflow == OVERFLOW_ENABLED) {
1424                                 if (ops_processed[i]->status ==
1425                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1426                                         RTE_LOG(INFO, USER1,
1427                                         "Out-of-space-recoverable functionality"
1428                                         " is not supported on this device\n");
1429                                         return 2;
1430                                 }
1431                         }
1432
1433                         RTE_LOG(ERR, USER1,
1434                                 "Some operations were not successful\n");
1435                         return -1;
1436                 }
1437                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1438                 rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
1439                 uncomp_bufs[priv_data->orig_idx] = NULL;
1440         }
1441
1442         if (out_of_space && !zlib_compress)
1443                 return 1;
1444
1445         return 0;
1446 }
1447
1448 /**
1449  * The main decompression function.
1450  *
1451  * Function performs decompression operation.
1452  * Operation(s) configuration, depending on CLI parameters.
1453  * Operation(s) processing.
1454  *
1455  * @param int_data
1456  *   Interim data containing session/transformation objects.
1457  * @param test_data
1458  *   The test parameters set by users (command line parameters).
1459  * @param test_priv_data
1460  *   A container used for aggregation all the private test arrays.
1461  * @return
1462  *   - 0: On success.
1463  *   - -1: On error.
1464  */
1465 static int
1466 test_deflate_decomp_run(const struct interim_data_params *int_data,
1467                 const struct test_data_params *test_data,
1468                 struct test_private_arrays *test_priv_data)
1469 {
1470
1471         /* local variables: */
1472         struct priv_op_data *priv_data;
1473         unsigned int i;
1474         uint16_t num_priv_xforms = 0;
1475         int ret;
1476         int ret_status = 0;
1477
1478         struct comp_testsuite_params *ts_params = &testsuite_params;
1479
1480         /* from test_data: */
1481         enum rte_comp_op_type operation_type = test_data->decompress_state;
1482         unsigned int zlib_decompress =
1483                         (test_data->zlib_dir == ZLIB_ALL ||
1484                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1485
1486         /* from int_data: */
1487         struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
1488         unsigned int num_xforms = int_data->num_xforms;
1489         unsigned int num_bufs = int_data->num_bufs;
1490
1491         /* from test_priv_data: */
1492         struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
1493         struct rte_comp_op **ops = test_priv_data->ops;
1494         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1495         void **priv_xforms = test_priv_data->priv_xforms;
1496         uint32_t *compressed_data_size = test_priv_data->compressed_data_size;
1497         void **stream = test_priv_data->stream;
1498
1499         const struct rte_compressdev_capabilities *capa =
1500                 rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1501
1502         ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
1503         if (ret < 0) {
1504                 RTE_LOG(ERR, USER1,
1505                         "Decompress operations could not be allocated "
1506                         "from the mempool\n");
1507                 ret_status = -1;
1508                 goto exit;
1509         }
1510
1511         /* Source buffer is the compressed data from the previous operations */
1512         for (i = 0; i < num_bufs; i++) {
1513                 ops[i]->m_src = ops_processed[i]->m_dst;
1514                 ops[i]->m_dst = uncomp_bufs[i];
1515                 ops[i]->src.offset = 0;
1516                 /*
1517                  * Set the length of the compressed data to the
1518                  * number of bytes that were produced in the previous stage
1519                  */
1520
1521                 if (compressed_data_size[i])
1522                         ops[i]->src.length = compressed_data_size[i];
1523                 else
1524                         ops[i]->src.length = ops_processed[i]->produced;
1525
1526                 ops[i]->dst.offset = 0;
1527
1528                 if (operation_type == RTE_COMP_OP_STATELESS) {
1529                         ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
1530                         ops[i]->op_type = RTE_COMP_OP_STATELESS;
1531                 } else if (!zlib_decompress) {
1532                         ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
1533                         ops[i]->op_type = RTE_COMP_OP_STATEFUL;
1534                 } else {
1535                         RTE_LOG(ERR, USER1,
1536                                 "Decompression: stateful operations are"
1537                                 " not supported in these tests yet\n");
1538                         ret_status = -1;
1539                         goto exit;
1540                 }
1541                 ops[i]->input_chksum = 0;
1542                 /*
1543                  * Copy private data from previous operations,
1544                  * to keep the pointer to the original buffer
1545                  */
1546                 memcpy(ops[i] + 1, ops_processed[i] + 1,
1547                                 sizeof(struct priv_op_data));
1548         }
1549
1550         /*
1551          * Free the previous compress operations,
1552          * as they are not needed anymore
1553          */
1554         rte_comp_op_bulk_free(ops_processed, num_bufs);
1555
1556         /* Decompress data (either with Zlib API or compressdev API */
1557         if (zlib_decompress) {
1558                 for (i = 0; i < num_bufs; i++) {
1559                         priv_data = (struct priv_op_data *)(ops[i] + 1);
1560                         uint16_t xform_idx = priv_data->orig_idx % num_xforms;
1561                         const struct rte_comp_xform *decompress_xform =
1562                                 decompress_xforms[xform_idx];
1563
1564                         ret = decompress_zlib(ops[i], decompress_xform);
1565                         if (ret < 0) {
1566                                 ret_status = -1;
1567                                 goto exit;
1568                         }
1569
1570                         ops_processed[i] = ops[i];
1571                 }
1572         } else {
1573                 if (operation_type == RTE_COMP_OP_STATELESS) {
1574                         /* Create decompress private xform data */
1575                         for (i = 0; i < num_xforms; i++) {
1576                                 ret = rte_compressdev_private_xform_create(0,
1577                                         (const struct rte_comp_xform *)
1578                                         decompress_xforms[i],
1579                                         &priv_xforms[i]);
1580                                 if (ret < 0) {
1581                                         RTE_LOG(ERR, USER1,
1582                                                 "Decompression private xform "
1583                                                 "could not be created\n");
1584                                         ret_status = -1;
1585                                         goto exit;
1586                                 }
1587                                 num_priv_xforms++;
1588                         }
1589
1590                         if (capa->comp_feature_flags &
1591                                         RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
1592                                 /* Attach shareable private xform data to ops */
1593                                 for (i = 0; i < num_bufs; i++) {
1594                                         priv_data = (struct priv_op_data *)
1595                                                         (ops[i] + 1);
1596                                         uint16_t xform_idx =
1597                                                priv_data->orig_idx % num_xforms;
1598                                         ops[i]->private_xform =
1599                                                         priv_xforms[xform_idx];
1600                                 }
1601                         } else {
1602                                 /* Create rest of the private xforms */
1603                                 /* for the other ops */
1604                                 for (i = num_xforms; i < num_bufs; i++) {
1605                                         ret =
1606                                          rte_compressdev_private_xform_create(0,
1607                                               decompress_xforms[i % num_xforms],
1608                                               &priv_xforms[i]);
1609                                         if (ret < 0) {
1610                                                 RTE_LOG(ERR, USER1,
1611                                                         "Decompression private xform"
1612                                                         " could not be created\n");
1613                                                 ret_status = -1;
1614                                                 goto exit;
1615                                         }
1616                                         num_priv_xforms++;
1617                                 }
1618
1619                                 /* Attach non shareable private xform data */
1620                                 /* to ops */
1621                                 for (i = 0; i < num_bufs; i++) {
1622                                         priv_data = (struct priv_op_data *)
1623                                                         (ops[i] + 1);
1624                                         uint16_t xform_idx =
1625                                                         priv_data->orig_idx;
1626                                         ops[i]->private_xform =
1627                                                         priv_xforms[xform_idx];
1628                                 }
1629                         }
1630                 } else {
1631                         /* Create a stream object for stateful decompression */
1632                         ret = rte_compressdev_stream_create(0,
1633                                         decompress_xforms[0], stream);
1634                         if (ret < 0) {
1635                                 RTE_LOG(ERR, USER1,
1636                                         "Decompression stream could not be created, error %d\n",
1637                                         ret);
1638                                 ret_status = -1;
1639                                 goto exit;
1640                         }
1641                         /* Attach stream to ops */
1642                         for (i = 0; i < num_bufs; i++)
1643                                 ops[i]->stream = *stream;
1644                 }
1645
1646                 test_priv_data->num_priv_xforms = num_priv_xforms;
1647         }
1648
1649 exit:
1650         return ret_status;
1651 }
1652
1653 /**
1654  * Prints out the test report. Memory freeing.
1655  *
1656  * Called after successful decompression.
1657  * Operation(s) status validation and compression buffers freeing.
1658
1659  * -1 returned if function fail.
1660  *
1661  * @param int_data
1662  *   Interim data containing session/transformation objects.
1663  * @param test_data
1664  *   The test parameters set by users (command line parameters).
1665  * @param test_priv_data
1666  *   A container used for aggregation all the private test arrays.
1667  * @return
1668  *   - 2: Next step must be executed by the caller (stateful decompression only)
1669  *   - 1: On success (caller should stop and exit)
1670  *   - 0: On success.
1671  *   - -1: On error.
1672  */
1673 static int
1674 test_deflate_decomp_finalize(const struct interim_data_params *int_data,
1675                 const struct test_data_params *test_data,
1676                 const struct test_private_arrays *test_priv_data)
1677 {
1678         /* local variables: */
1679         unsigned int i;
1680         struct priv_op_data *priv_data;
1681         static unsigned int step;
1682
1683         /* from int_data: */
1684         uint16_t *buf_idx = int_data->buf_idx;
1685         unsigned int num_bufs = int_data->num_bufs;
1686         const char * const *test_bufs = int_data->test_bufs;
1687         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1688
1689         /* from test_priv_data: */
1690         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1691         struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
1692         struct rte_comp_op **ops = test_priv_data->ops;
1693         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1694         unsigned int *decomp_produced_data_size =
1695                         test_priv_data->decomp_produced_data_size;
1696         char **all_decomp_data = test_priv_data->all_decomp_data;
1697
1698         /* from test_data: */
1699         unsigned int out_of_space = test_data->out_of_space;
1700         enum rte_comp_op_type operation_type = test_data->decompress_state;
1701
1702         unsigned int zlib_compress =
1703                         (test_data->zlib_dir == ZLIB_ALL ||
1704                         test_data->zlib_dir == ZLIB_COMPRESS);
1705         unsigned int zlib_decompress =
1706                         (test_data->zlib_dir == ZLIB_ALL ||
1707                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1708
1709         for (i = 0; i < num_bufs; i++) {
1710                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1711                 char engine[] = "zlib, (directly, no PMD)";
1712                 if (zlib_compress)
1713                         strlcpy(engine, "pmd", sizeof(engine));
1714                 RTE_LOG(DEBUG, USER1,
1715                         "Buffer %u decompressed by %s from %u to %u bytes\n",
1716                         buf_idx[priv_data->orig_idx], engine,
1717                         ops_processed[i]->consumed, ops_processed[i]->produced);
1718                 ops[i] = NULL;
1719         }
1720
1721         /*
1722          * Check operation status and free source mbuf (destination mbuf and
1723          * compress operation information is still needed)
1724          */
1725         for (i = 0; i < num_bufs; i++) {
1726                 if (out_of_space && !zlib_decompress) {
1727                         if (ops_processed[i]->status !=
1728                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
1729
1730                                 RTE_LOG(ERR, USER1,
1731                                         "Operation without expected out of "
1732                                         "space status error\n");
1733                                 return -1;
1734                         } else
1735                                 continue;
1736                 }
1737
1738                 if (operation_type == RTE_COMP_OP_STATEFUL
1739                         && (ops_processed[i]->status ==
1740                                 RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
1741                             || ops_processed[i]->status ==
1742                                 RTE_COMP_OP_STATUS_SUCCESS)) {
1743                         /* collect the output into all_decomp_data */
1744                         const void *ptr = rte_pktmbuf_read(
1745                                         ops_processed[i]->m_dst,
1746                                         ops_processed[i]->dst.offset,
1747                                         ops_processed[i]->produced,
1748                                         *all_decomp_data +
1749                                                 *decomp_produced_data_size);
1750                         if (ptr != *all_decomp_data +
1751                                         *decomp_produced_data_size)
1752                                 rte_memcpy(*all_decomp_data +
1753                                            *decomp_produced_data_size,
1754                                            ptr, ops_processed[i]->produced);
1755
1756                         *decomp_produced_data_size +=
1757                                         ops_processed[i]->produced;
1758                         if (ops_processed[i]->src.length >
1759                                         ops_processed[i]->consumed) {
1760                                 if (ops_processed[i]->status ==
1761                                                 RTE_COMP_OP_STATUS_SUCCESS) {
1762                                         RTE_LOG(ERR, USER1,
1763                                               "Operation finished too early\n");
1764                                         return -1;
1765                                 }
1766                                 step++;
1767                                 if (step >= test_data->decompress_steps_max) {
1768                                         RTE_LOG(ERR, USER1,
1769                                           "Operation exceeded maximum steps\n");
1770                                         return -1;
1771                                 }
1772                                 ops[i] = ops_processed[i];
1773                                 ops[i]->status =
1774                                                RTE_COMP_OP_STATUS_NOT_PROCESSED;
1775                                 ops[i]->src.offset +=
1776                                                 ops_processed[i]->consumed;
1777                                 ops[i]->src.length -=
1778                                                 ops_processed[i]->consumed;
1779                                 /* repeat the operation */
1780                                 //goto next_step;
1781                                 return 2;
1782                         } else {
1783                                 /* Compare the original stream with the */
1784                                 /* decompressed stream (in size and the data) */
1785                                 priv_data = (struct priv_op_data *)
1786                                                 (ops_processed[i] + 1);
1787                                 const char *buf1 =
1788                                                 test_bufs[priv_data->orig_idx];
1789                                 const char *buf2 = *all_decomp_data;
1790
1791                                 if (compare_buffers(buf1, strlen(buf1) + 1,
1792                                           buf2, *decomp_produced_data_size) < 0)
1793                                         return -1;
1794                                 /* Test checksums */
1795                                 if (compress_xforms[0]->compress.chksum
1796                                                 != RTE_COMP_CHECKSUM_NONE) {
1797                                         if (ops_processed[i]->output_chksum
1798                                                       != compress_checksum[i]) {
1799                                                 RTE_LOG(ERR, USER1,
1800                         "The checksums differ\n"
1801                         "Compression Checksum: %" PRIu64 "\tDecompression "
1802                         "Checksum: %" PRIu64 "\n", compress_checksum[i],
1803                                                ops_processed[i]->output_chksum);
1804                                                 return -1;
1805                                         }
1806                                 }
1807                         }
1808                 } else if (ops_processed[i]->status !=
1809                            RTE_COMP_OP_STATUS_SUCCESS) {
1810                         RTE_LOG(ERR, USER1,
1811                                 "Some operations were not successful\n");
1812                         return -1;
1813                 }
1814                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1815                 rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
1816                 comp_bufs[priv_data->orig_idx] = NULL;
1817         }
1818
1819         if (out_of_space && !zlib_decompress)
1820                 return 1;
1821
1822         return 0;
1823 }
1824
1825 /**
1826  * Validation of the output (compression/decompression) data.
1827  *
1828  * The function compares the source stream with the output stream,
1829  * after decompression, to check if compression/decompression
1830  * was correct.
1831  * -1 returned if function fail.
1832  *
1833  * @param int_data
1834  *   Interim data containing session/transformation objects.
1835  * @param test_data
1836  *   The test parameters set by users (command line parameters).
1837  * @param test_priv_data
1838  *   A container used for aggregation all the private test arrays.
1839  * @return
1840  *   - 0: On success.
1841  *   - -1: On error.
1842  */
1843 static int
1844 test_results_validation(const struct interim_data_params *int_data,
1845                 const struct test_data_params *test_data,
1846                 const struct test_private_arrays *test_priv_data)
1847 {
1848         /* local variables: */
1849         unsigned int i;
1850         struct priv_op_data *priv_data;
1851         const char *buf1;
1852         const char *buf2;
1853         char *contig_buf = NULL;
1854         uint32_t data_size;
1855
1856         /* from int_data: */
1857         struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
1858         unsigned int num_bufs = int_data->num_bufs;
1859         const char * const *test_bufs = int_data->test_bufs;
1860
1861         /* from test_priv_data: */
1862         uint64_t *compress_checksum = test_priv_data->compress_checksum;
1863         struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
1864
1865         /*
1866          * Compare the original stream with the decompressed stream
1867          * (in size and the data)
1868          */
1869         for (i = 0; i < num_bufs; i++) {
1870                 priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
1871                 buf1 = test_data->use_external_mbufs ?
1872                                 test_data->inbuf_memzone->addr :
1873                                 test_bufs[priv_data->orig_idx];
1874                 data_size = test_data->use_external_mbufs ?
1875                                 test_data->inbuf_data_size :
1876                                 strlen(buf1) + 1;
1877
1878                 contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
1879                 if (contig_buf == NULL) {
1880                         RTE_LOG(ERR, USER1, "Contiguous buffer could not "
1881                                         "be allocated\n");
1882                         goto exit;
1883                 }
1884
1885                 buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
1886                                 ops_processed[i]->produced, contig_buf);
1887                 if (compare_buffers(buf1, data_size,
1888                                 buf2, ops_processed[i]->produced) < 0)
1889                         goto exit;
1890
1891                 /* Test checksums */
1892                 if (compress_xforms[0]->compress.chksum !=
1893                                 RTE_COMP_CHECKSUM_NONE) {
1894                         if (ops_processed[i]->output_chksum !=
1895                                         compress_checksum[i]) {
1896                                 RTE_LOG(ERR, USER1, "The checksums differ\n"
1897                         "Compression Checksum: %" PRIu64 "\tDecompression "
1898                         "Checksum: %" PRIu64 "\n", compress_checksum[i],
1899                         ops_processed[i]->output_chksum);
1900                                 goto exit;
1901                         }
1902                 }
1903
1904                 rte_free(contig_buf);
1905                 contig_buf = NULL;
1906         }
1907         return 0;
1908
1909 exit:
1910         rte_free(contig_buf);
1911         return -1;
1912 }
1913
1914 /**
1915  * Compresses and decompresses input stream with compressdev API and Zlib API
1916  *
1917  * Basic test function. Common for all the functional tests.
1918  * -1 returned if function fail.
1919  *
1920  * @param int_data
1921  *   Interim data containing session/transformation objects.
1922  * @param test_data
1923  *   The test parameters set by users (command line parameters).
1924  * @return
1925  *   - 1: Some operation not supported
1926  *   - 0: On success.
1927  *   - -1: On error.
1928  */
1929
1930 static int
1931 test_deflate_comp_decomp(const struct interim_data_params *int_data,
1932                 const struct test_data_params *test_data)
1933 {
1934         unsigned int num_bufs = int_data->num_bufs;
1935         unsigned int out_of_space = test_data->out_of_space;
1936
1937         void *stream = NULL;
1938         char *all_decomp_data = NULL;
1939         unsigned int decomp_produced_data_size = 0;
1940
1941         int ret_status = -1;
1942         int ret;
1943         struct rte_mbuf *uncomp_bufs[num_bufs];
1944         struct rte_mbuf *comp_bufs[num_bufs];
1945         struct rte_comp_op *ops[num_bufs];
1946         struct rte_comp_op *ops_processed[num_bufs];
1947         void *priv_xforms[num_bufs];
1948         unsigned int i;
1949
1950         uint64_t compress_checksum[num_bufs];
1951         uint32_t compressed_data_size[num_bufs];
1952         char *contig_buf = NULL;
1953
1954         struct rte_mbuf_ext_shared_info compbuf_info;
1955         struct rte_mbuf_ext_shared_info decompbuf_info;
1956
1957         const struct rte_compressdev_capabilities *capa;
1958
1959         /* Compressing with CompressDev */
1960         unsigned int zlib_compress =
1961                         (test_data->zlib_dir == ZLIB_ALL ||
1962                         test_data->zlib_dir == ZLIB_COMPRESS);
1963         unsigned int zlib_decompress =
1964                         (test_data->zlib_dir == ZLIB_ALL ||
1965                         test_data->zlib_dir == ZLIB_DECOMPRESS);
1966
1967         struct test_private_arrays test_priv_data;
1968
1969         test_priv_data.uncomp_bufs = uncomp_bufs;
1970         test_priv_data.comp_bufs = comp_bufs;
1971         test_priv_data.ops = ops;
1972         test_priv_data.ops_processed = ops_processed;
1973         test_priv_data.priv_xforms = priv_xforms;
1974         test_priv_data.compress_checksum = compress_checksum;
1975         test_priv_data.compressed_data_size = compressed_data_size;
1976
1977         test_priv_data.stream = &stream;
1978         test_priv_data.all_decomp_data = &all_decomp_data;
1979         test_priv_data.decomp_produced_data_size = &decomp_produced_data_size;
1980
1981         test_priv_data.num_priv_xforms = 0; /* it's used for deompression only */
1982
1983         capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
1984         if (capa == NULL) {
1985                 RTE_LOG(ERR, USER1,
1986                         "Compress device does not support DEFLATE\n");
1987                 return -1;
1988         }
1989         //test_objects_init(&test_priv_data, num_bufs);
1990
1991         /* Prepare the source mbufs with the data */
1992         ret = test_setup_com_bufs(int_data, test_data, &test_priv_data);
1993         if (ret < 0) {
1994                 ret_status = -1;
1995                 goto exit;
1996         }
1997
1998 /* COMPRESSION  */
1999
2000         /* Prepare output (destination) mbufs for compressed data */
2001         ret = test_setup_output_bufs(
2002                         OPERATION_COMPRESSION,
2003                         out_of_space == 1 && !zlib_compress,
2004                         &test_priv_data,
2005                         int_data,
2006                         test_data,
2007                         &compbuf_info);
2008         if (ret < 0) {
2009                 ret_status = -1;
2010                 goto exit;
2011         }
2012
2013         /* Run compression */
2014         ret = test_deflate_comp_run(int_data, test_data, &test_priv_data);
2015         if (ret < 0) {
2016                 ret_status = -1;
2017                 goto exit;
2018         }
2019
2020         ret = test_deflate_comp_finalize(int_data, test_data, &test_priv_data);
2021         if (ret < 0) {
2022                 ret_status = -1;
2023                 goto exit;
2024         } else if (ret == 1) {
2025                 ret_status = 0;
2026                 goto exit;
2027         } else if (ret == 2) {
2028                 ret_status = 1;  /* some operation not supported */
2029                 goto exit;
2030         }
2031
2032 /* DECOMPRESSION  */
2033
2034         /* Prepare output (destination) mbufs for decompressed data */
2035         ret = test_setup_output_bufs(
2036                         OPERATION_DECOMPRESSION,
2037                         out_of_space == 1 && !zlib_decompress,
2038                         &test_priv_data,
2039                         int_data,
2040                         test_data,
2041                         &decompbuf_info);
2042         if (ret < 0) {
2043                 ret_status = -1;
2044                 goto exit;
2045         }
2046
2047         /* Run decompression */
2048         ret = test_deflate_decomp_run(int_data, test_data, &test_priv_data);
2049         if (ret < 0) {
2050                 ret_status = -1;
2051                 goto exit;
2052         }
2053
2054         if (!zlib_decompress) {
2055 next_step:      /* next step for stateful decompression only */
2056                 ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
2057                 if (ret < 0) {
2058                         ret_status = -1;
2059                         RTE_LOG(ERR, USER1,
2060                                 "Decompression: enqueue/dequeue operation failed\n");
2061                 }
2062         }
2063
2064         ret = test_deflate_decomp_finalize(int_data, test_data, &test_priv_data);
2065         if (ret < 0) {
2066                 ret_status = -1;
2067                 goto exit;
2068         } else if (ret == 1) {
2069                 ret_status = 0;
2070                 goto exit;
2071         } else if (ret == 2) {
2072                 goto next_step;
2073         }
2074
2075 /* FINAL PROCESSING  */
2076
2077         ret = test_results_validation(int_data, test_data, &test_priv_data);
2078         if (ret < 0) {
2079                 ret_status = -1;
2080                 goto exit;
2081         }
2082         ret_status = 0;
2083
2084 exit:
2085         /* Free resources */
2086
2087         if (stream != NULL)
2088                 rte_compressdev_stream_free(0, stream);
2089         if (all_decomp_data != NULL)
2090                 rte_free(all_decomp_data);
2091
2092         /* Free compress private xforms */
2093         for (i = 0; i < test_priv_data.num_priv_xforms; i++) {
2094                 if (priv_xforms[i] != NULL) {
2095                         rte_compressdev_private_xform_free(0, priv_xforms[i]);
2096                         priv_xforms[i] = NULL;
2097                 }
2098         }
2099
2100         for (i = 0; i < num_bufs; i++) {
2101                 rte_pktmbuf_free(uncomp_bufs[i]);
2102                 rte_pktmbuf_free(comp_bufs[i]);
2103                 rte_comp_op_free(ops[i]);
2104                 rte_comp_op_free(ops_processed[i]);
2105         }
2106         rte_free(contig_buf);
2107
2108         return ret_status;
2109 }
2110
2111 static int
2112 test_compressdev_deflate_stateless_fixed(void)
2113 {
2114         struct comp_testsuite_params *ts_params = &testsuite_params;
2115         uint16_t i;
2116         int ret;
2117         const struct rte_compressdev_capabilities *capab;
2118
2119         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2120         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2121
2122         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2123                 return -ENOTSUP;
2124
2125         struct rte_comp_xform *compress_xform =
2126                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2127
2128         if (compress_xform == NULL) {
2129                 RTE_LOG(ERR, USER1,
2130                         "Compress xform could not be created\n");
2131                 ret = TEST_FAILED;
2132                 goto exit;
2133         }
2134
2135         memcpy(compress_xform, ts_params->def_comp_xform,
2136                         sizeof(struct rte_comp_xform));
2137         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
2138
2139         struct interim_data_params int_data = {
2140                 NULL,
2141                 1,
2142                 NULL,
2143                 &compress_xform,
2144                 &ts_params->def_decomp_xform,
2145                 1
2146         };
2147
2148         struct test_data_params test_data = {
2149                 .compress_state = RTE_COMP_OP_STATELESS,
2150                 .decompress_state = RTE_COMP_OP_STATELESS,
2151                 .buff_type = LB_BOTH,
2152                 .zlib_dir = ZLIB_DECOMPRESS,
2153                 .out_of_space = 0,
2154                 .big_data = 0,
2155                 .overflow = OVERFLOW_DISABLED
2156         };
2157
2158         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2159                 int_data.test_bufs = &compress_test_bufs[i];
2160                 int_data.buf_idx = &i;
2161
2162                 /* Compress with compressdev, decompress with Zlib */
2163                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2164                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2165                 if (ret < 0)
2166                         goto exit;
2167
2168                 /* Compress with Zlib, decompress with compressdev */
2169                 test_data.zlib_dir = ZLIB_COMPRESS;
2170                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2171                 if (ret < 0)
2172                         goto exit;
2173         }
2174
2175         ret = TEST_SUCCESS;
2176
2177 exit:
2178         rte_free(compress_xform);
2179         return ret;
2180 }
2181
2182 static int
2183 test_compressdev_deflate_stateless_dynamic(void)
2184 {
2185         struct comp_testsuite_params *ts_params = &testsuite_params;
2186         uint16_t i;
2187         int ret;
2188         struct rte_comp_xform *compress_xform =
2189                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2190
2191         const struct rte_compressdev_capabilities *capab;
2192
2193         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2194         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2195
2196         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2197                 return -ENOTSUP;
2198
2199         if (compress_xform == NULL) {
2200                 RTE_LOG(ERR, USER1,
2201                         "Compress xform could not be created\n");
2202                 ret = TEST_FAILED;
2203                 goto exit;
2204         }
2205
2206         memcpy(compress_xform, ts_params->def_comp_xform,
2207                         sizeof(struct rte_comp_xform));
2208         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_DYNAMIC;
2209
2210         struct interim_data_params int_data = {
2211                 NULL,
2212                 1,
2213                 NULL,
2214                 &compress_xform,
2215                 &ts_params->def_decomp_xform,
2216                 1
2217         };
2218
2219         struct test_data_params test_data = {
2220                 .compress_state = RTE_COMP_OP_STATELESS,
2221                 .decompress_state = RTE_COMP_OP_STATELESS,
2222                 .buff_type = LB_BOTH,
2223                 .zlib_dir = ZLIB_DECOMPRESS,
2224                 .out_of_space = 0,
2225                 .big_data = 0,
2226                 .overflow = OVERFLOW_DISABLED
2227         };
2228
2229         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2230                 int_data.test_bufs = &compress_test_bufs[i];
2231                 int_data.buf_idx = &i;
2232
2233                 /* Compress with compressdev, decompress with Zlib */
2234                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2235                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2236                 if (ret < 0)
2237                         goto exit;
2238
2239                 /* Compress with Zlib, decompress with compressdev */
2240                 test_data.zlib_dir = ZLIB_COMPRESS;
2241                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2242                 if (ret < 0)
2243                         goto exit;
2244         }
2245
2246         ret = TEST_SUCCESS;
2247
2248 exit:
2249         rte_free(compress_xform);
2250         return ret;
2251 }
2252
2253 static int
2254 test_compressdev_deflate_stateless_multi_op(void)
2255 {
2256         struct comp_testsuite_params *ts_params = &testsuite_params;
2257         uint16_t num_bufs = RTE_DIM(compress_test_bufs);
2258         uint16_t buf_idx[num_bufs];
2259         uint16_t i;
2260         int ret;
2261
2262         for (i = 0; i < num_bufs; i++)
2263                 buf_idx[i] = i;
2264
2265         struct interim_data_params int_data = {
2266                 compress_test_bufs,
2267                 num_bufs,
2268                 buf_idx,
2269                 &ts_params->def_comp_xform,
2270                 &ts_params->def_decomp_xform,
2271                 1
2272         };
2273
2274         struct test_data_params test_data = {
2275                 .compress_state = RTE_COMP_OP_STATELESS,
2276                 .decompress_state = RTE_COMP_OP_STATELESS,
2277                 .buff_type = LB_BOTH,
2278                 .zlib_dir = ZLIB_DECOMPRESS,
2279                 .out_of_space = 0,
2280                 .big_data = 0,
2281                 .overflow = OVERFLOW_DISABLED
2282         };
2283
2284         /* Compress with compressdev, decompress with Zlib */
2285         test_data.zlib_dir = ZLIB_DECOMPRESS;
2286         ret = test_deflate_comp_decomp(&int_data, &test_data);
2287         if (ret < 0)
2288                 return ret;
2289
2290         /* Compress with Zlib, decompress with compressdev */
2291         test_data.zlib_dir = ZLIB_COMPRESS;
2292         ret = test_deflate_comp_decomp(&int_data, &test_data);
2293         if (ret < 0)
2294                 return ret;
2295
2296         return TEST_SUCCESS;
2297 }
2298
2299 static int
2300 test_compressdev_deflate_stateless_multi_level(void)
2301 {
2302         struct comp_testsuite_params *ts_params = &testsuite_params;
2303         unsigned int level;
2304         uint16_t i;
2305         int ret;
2306         struct rte_comp_xform *compress_xform =
2307                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2308
2309         if (compress_xform == NULL) {
2310                 RTE_LOG(ERR, USER1,
2311                         "Compress xform could not be created\n");
2312                 ret = TEST_FAILED;
2313                 goto exit;
2314         }
2315
2316         memcpy(compress_xform, ts_params->def_comp_xform,
2317                         sizeof(struct rte_comp_xform));
2318
2319         struct interim_data_params int_data = {
2320                 NULL,
2321                 1,
2322                 NULL,
2323                 &compress_xform,
2324                 &ts_params->def_decomp_xform,
2325                 1
2326         };
2327
2328         struct test_data_params test_data = {
2329                 .compress_state = RTE_COMP_OP_STATELESS,
2330                 .decompress_state = RTE_COMP_OP_STATELESS,
2331                 .buff_type = LB_BOTH,
2332                 .zlib_dir = ZLIB_DECOMPRESS,
2333                 .out_of_space = 0,
2334                 .big_data = 0,
2335                 .overflow = OVERFLOW_DISABLED
2336         };
2337
2338         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2339                 int_data.test_bufs = &compress_test_bufs[i];
2340                 int_data.buf_idx = &i;
2341
2342                 for (level = RTE_COMP_LEVEL_MIN; level <= RTE_COMP_LEVEL_MAX;
2343                                 level++) {
2344                         compress_xform->compress.level = level;
2345                         /* Compress with compressdev, decompress with Zlib */
2346                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2347                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2348                         if (ret < 0)
2349                                 goto exit;
2350                 }
2351         }
2352
2353         ret = TEST_SUCCESS;
2354
2355 exit:
2356         rte_free(compress_xform);
2357         return ret;
2358 }
2359
2360 #define NUM_XFORMS 3
2361 static int
2362 test_compressdev_deflate_stateless_multi_xform(void)
2363 {
2364         struct comp_testsuite_params *ts_params = &testsuite_params;
2365         uint16_t num_bufs = NUM_XFORMS;
2366         struct rte_comp_xform *compress_xforms[NUM_XFORMS] = {NULL};
2367         struct rte_comp_xform *decompress_xforms[NUM_XFORMS] = {NULL};
2368         const char *test_buffers[NUM_XFORMS];
2369         uint16_t i;
2370         unsigned int level = RTE_COMP_LEVEL_MIN;
2371         uint16_t buf_idx[num_bufs];
2372         int ret;
2373
2374         /* Create multiple xforms with various levels */
2375         for (i = 0; i < NUM_XFORMS; i++) {
2376                 compress_xforms[i] = rte_malloc(NULL,
2377                                 sizeof(struct rte_comp_xform), 0);
2378                 if (compress_xforms[i] == NULL) {
2379                         RTE_LOG(ERR, USER1,
2380                                 "Compress xform could not be created\n");
2381                         ret = TEST_FAILED;
2382                         goto exit;
2383                 }
2384
2385                 memcpy(compress_xforms[i], ts_params->def_comp_xform,
2386                                 sizeof(struct rte_comp_xform));
2387                 compress_xforms[i]->compress.level = level;
2388                 level++;
2389
2390                 decompress_xforms[i] = rte_malloc(NULL,
2391                                 sizeof(struct rte_comp_xform), 0);
2392                 if (decompress_xforms[i] == NULL) {
2393                         RTE_LOG(ERR, USER1,
2394                                 "Decompress xform could not be created\n");
2395                         ret = TEST_FAILED;
2396                         goto exit;
2397                 }
2398
2399                 memcpy(decompress_xforms[i], ts_params->def_decomp_xform,
2400                                 sizeof(struct rte_comp_xform));
2401         }
2402
2403         for (i = 0; i < NUM_XFORMS; i++) {
2404                 buf_idx[i] = 0;
2405                 /* Use the same buffer in all sessions */
2406                 test_buffers[i] = compress_test_bufs[0];
2407         }
2408
2409         struct interim_data_params int_data = {
2410                 test_buffers,
2411                 num_bufs,
2412                 buf_idx,
2413                 compress_xforms,
2414                 decompress_xforms,
2415                 NUM_XFORMS
2416         };
2417
2418         struct test_data_params test_data = {
2419                 .compress_state = RTE_COMP_OP_STATELESS,
2420                 .decompress_state = RTE_COMP_OP_STATELESS,
2421                 .buff_type = LB_BOTH,
2422                 .zlib_dir = ZLIB_DECOMPRESS,
2423                 .out_of_space = 0,
2424                 .big_data = 0,
2425                 .overflow = OVERFLOW_DISABLED
2426         };
2427
2428         /* Compress with compressdev, decompress with Zlib */
2429         ret = test_deflate_comp_decomp(&int_data, &test_data);
2430         if (ret < 0)
2431                 goto exit;
2432
2433         ret = TEST_SUCCESS;
2434
2435 exit:
2436         for (i = 0; i < NUM_XFORMS; i++) {
2437                 rte_free(compress_xforms[i]);
2438                 rte_free(decompress_xforms[i]);
2439         }
2440
2441         return ret;
2442 }
2443
2444 static int
2445 test_compressdev_deflate_stateless_sgl(void)
2446 {
2447         struct comp_testsuite_params *ts_params = &testsuite_params;
2448         uint16_t i;
2449         int ret;
2450         const struct rte_compressdev_capabilities *capab;
2451
2452         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2453         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2454
2455         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2456                 return -ENOTSUP;
2457
2458         struct interim_data_params int_data = {
2459                 NULL,
2460                 1,
2461                 NULL,
2462                 &ts_params->def_comp_xform,
2463                 &ts_params->def_decomp_xform,
2464                 1
2465         };
2466
2467         struct test_data_params test_data = {
2468                 .compress_state = RTE_COMP_OP_STATELESS,
2469                 .decompress_state = RTE_COMP_OP_STATELESS,
2470                 .buff_type = SGL_BOTH,
2471                 .zlib_dir = ZLIB_DECOMPRESS,
2472                 .out_of_space = 0,
2473                 .big_data = 0,
2474                 .overflow = OVERFLOW_DISABLED
2475         };
2476
2477         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2478                 int_data.test_bufs = &compress_test_bufs[i];
2479                 int_data.buf_idx = &i;
2480
2481                 /* Compress with compressdev, decompress with Zlib */
2482                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2483                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2484                 if (ret < 0)
2485                         return ret;
2486
2487                 /* Compress with Zlib, decompress with compressdev */
2488                 test_data.zlib_dir = ZLIB_COMPRESS;
2489                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2490                 if (ret < 0)
2491                         return ret;
2492
2493                 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_LB_OUT) {
2494                         /* Compress with compressdev, decompress with Zlib */
2495                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2496                         test_data.buff_type = SGL_TO_LB;
2497                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2498                         if (ret < 0)
2499                                 return ret;
2500
2501                         /* Compress with Zlib, decompress with compressdev */
2502                         test_data.zlib_dir = ZLIB_COMPRESS;
2503                         test_data.buff_type = SGL_TO_LB;
2504                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2505                         if (ret < 0)
2506                                 return ret;
2507                 }
2508
2509                 if (capab->comp_feature_flags & RTE_COMP_FF_OOP_LB_IN_SGL_OUT) {
2510                         /* Compress with compressdev, decompress with Zlib */
2511                         test_data.zlib_dir = ZLIB_DECOMPRESS;
2512                         test_data.buff_type = LB_TO_SGL;
2513                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2514                         if (ret < 0)
2515                                 return ret;
2516
2517                         /* Compress with Zlib, decompress with compressdev */
2518                         test_data.zlib_dir = ZLIB_COMPRESS;
2519                         test_data.buff_type = LB_TO_SGL;
2520                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2521                         if (ret < 0)
2522                                 return ret;
2523                 }
2524         }
2525
2526         return TEST_SUCCESS;
2527 }
2528
2529 static int
2530 test_compressdev_deflate_stateless_checksum(void)
2531 {
2532         struct comp_testsuite_params *ts_params = &testsuite_params;
2533         uint16_t i;
2534         int ret;
2535         const struct rte_compressdev_capabilities *capab;
2536
2537         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2538         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2539
2540         /* Check if driver supports any checksum */
2541         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) == 0 &&
2542                         (capab->comp_feature_flags &
2543                         RTE_COMP_FF_ADLER32_CHECKSUM) == 0 &&
2544                         (capab->comp_feature_flags &
2545                         RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) == 0)
2546                 return -ENOTSUP;
2547
2548         struct rte_comp_xform *compress_xform =
2549                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2550         if (compress_xform == NULL) {
2551                 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2552                 return TEST_FAILED;
2553         }
2554
2555         memcpy(compress_xform, ts_params->def_comp_xform,
2556                         sizeof(struct rte_comp_xform));
2557
2558         struct rte_comp_xform *decompress_xform =
2559                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2560         if (decompress_xform == NULL) {
2561                 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2562                 rte_free(compress_xform);
2563                 return TEST_FAILED;
2564         }
2565
2566         memcpy(decompress_xform, ts_params->def_decomp_xform,
2567                         sizeof(struct rte_comp_xform));
2568
2569         struct interim_data_params int_data = {
2570                 NULL,
2571                 1,
2572                 NULL,
2573                 &compress_xform,
2574                 &decompress_xform,
2575                 1
2576         };
2577
2578         struct test_data_params test_data = {
2579                 .compress_state = RTE_COMP_OP_STATELESS,
2580                 .decompress_state = RTE_COMP_OP_STATELESS,
2581                 .buff_type = LB_BOTH,
2582                 .zlib_dir = ZLIB_DECOMPRESS,
2583                 .out_of_space = 0,
2584                 .big_data = 0,
2585                 .overflow = OVERFLOW_DISABLED
2586         };
2587
2588         /* Check if driver supports crc32 checksum and test */
2589         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM)) {
2590                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
2591                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
2592
2593                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2594                         /* Compress with compressdev, decompress with Zlib */
2595                         int_data.test_bufs = &compress_test_bufs[i];
2596                         int_data.buf_idx = &i;
2597
2598                         /* Generate zlib checksum and test against selected
2599                          * drivers decompression checksum
2600                          */
2601                         test_data.zlib_dir = ZLIB_COMPRESS;
2602                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2603                         if (ret < 0)
2604                                 goto exit;
2605
2606                         /* Generate compression and decompression
2607                          * checksum of selected driver
2608                          */
2609                         test_data.zlib_dir = ZLIB_NONE;
2610                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2611                         if (ret < 0)
2612                                 goto exit;
2613                 }
2614         }
2615
2616         /* Check if driver supports adler32 checksum and test */
2617         if ((capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM)) {
2618                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2619                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2620
2621                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2622                         int_data.test_bufs = &compress_test_bufs[i];
2623                         int_data.buf_idx = &i;
2624
2625                         /* Generate zlib checksum and test against selected
2626                          * drivers decompression checksum
2627                          */
2628                         test_data.zlib_dir = ZLIB_COMPRESS;
2629                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2630                         if (ret < 0)
2631                                 goto exit;
2632                         /* Generate compression and decompression
2633                          * checksum of selected driver
2634                          */
2635                         test_data.zlib_dir = ZLIB_NONE;
2636                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2637                         if (ret < 0)
2638                                 goto exit;
2639                 }
2640         }
2641
2642         /* Check if driver supports combined crc and adler checksum and test */
2643         if ((capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)) {
2644                 compress_xform->compress.chksum =
2645                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2646                 decompress_xform->decompress.chksum =
2647                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2648
2649                 for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
2650                         int_data.test_bufs = &compress_test_bufs[i];
2651                         int_data.buf_idx = &i;
2652
2653                         /* Generate compression and decompression
2654                          * checksum of selected driver
2655                          */
2656                         test_data.zlib_dir = ZLIB_NONE;
2657                         ret = test_deflate_comp_decomp(&int_data, &test_data);
2658                         if (ret < 0)
2659                                 goto exit;
2660                 }
2661         }
2662
2663         ret = TEST_SUCCESS;
2664
2665 exit:
2666         rte_free(compress_xform);
2667         rte_free(decompress_xform);
2668         return ret;
2669 }
2670
2671 static int
2672 test_compressdev_out_of_space_buffer(void)
2673 {
2674         struct comp_testsuite_params *ts_params = &testsuite_params;
2675         int ret;
2676         uint16_t i;
2677         const struct rte_compressdev_capabilities *capab;
2678
2679         RTE_LOG(INFO, USER1, "This is a negative test, errors are expected\n");
2680
2681         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2682         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2683
2684         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
2685                 return -ENOTSUP;
2686
2687         struct interim_data_params int_data = {
2688                 &compress_test_bufs[0],
2689                 1,
2690                 &i,
2691                 &ts_params->def_comp_xform,
2692                 &ts_params->def_decomp_xform,
2693                 1
2694         };
2695
2696         struct test_data_params test_data = {
2697                 .compress_state = RTE_COMP_OP_STATELESS,
2698                 .decompress_state = RTE_COMP_OP_STATELESS,
2699                 .buff_type = LB_BOTH,
2700                 .zlib_dir = ZLIB_DECOMPRESS,
2701                 .out_of_space = 1,  /* run out-of-space test */
2702                 .big_data = 0,
2703                 .overflow = OVERFLOW_DISABLED
2704         };
2705         /* Compress with compressdev, decompress with Zlib */
2706         test_data.zlib_dir = ZLIB_DECOMPRESS;
2707         ret = test_deflate_comp_decomp(&int_data, &test_data);
2708         if (ret < 0)
2709                 goto exit;
2710
2711         /* Compress with Zlib, decompress with compressdev */
2712         test_data.zlib_dir = ZLIB_COMPRESS;
2713         ret = test_deflate_comp_decomp(&int_data, &test_data);
2714         if (ret < 0)
2715                 goto exit;
2716
2717         if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2718                 /* Compress with compressdev, decompress with Zlib */
2719                 test_data.zlib_dir = ZLIB_DECOMPRESS;
2720                 test_data.buff_type = SGL_BOTH;
2721                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2722                 if (ret < 0)
2723                         goto exit;
2724
2725                 /* Compress with Zlib, decompress with compressdev */
2726                 test_data.zlib_dir = ZLIB_COMPRESS;
2727                 test_data.buff_type = SGL_BOTH;
2728                 ret = test_deflate_comp_decomp(&int_data, &test_data);
2729                 if (ret < 0)
2730                         goto exit;
2731         }
2732
2733         ret  = TEST_SUCCESS;
2734
2735 exit:
2736         return ret;
2737 }
2738
2739 static int
2740 test_compressdev_deflate_stateless_dynamic_big(void)
2741 {
2742         struct comp_testsuite_params *ts_params = &testsuite_params;
2743         uint16_t i = 0;
2744         int ret;
2745         int j;
2746         const struct rte_compressdev_capabilities *capab;
2747         char *test_buffer = NULL;
2748
2749         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2750         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2751
2752         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_DYNAMIC) == 0)
2753                 return -ENOTSUP;
2754
2755         if ((capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) == 0)
2756                 return -ENOTSUP;
2757
2758         test_buffer = rte_malloc(NULL, BIG_DATA_TEST_SIZE, 0);
2759         if (test_buffer == NULL) {
2760                 RTE_LOG(ERR, USER1,
2761                         "Can't allocate buffer for big-data\n");
2762                 return TEST_FAILED;
2763         }
2764
2765         struct interim_data_params int_data = {
2766                 (const char * const *)&test_buffer,
2767                 1,
2768                 &i,
2769                 &ts_params->def_comp_xform,
2770                 &ts_params->def_decomp_xform,
2771                 1
2772         };
2773
2774         struct test_data_params test_data = {
2775                 .compress_state = RTE_COMP_OP_STATELESS,
2776                 .decompress_state = RTE_COMP_OP_STATELESS,
2777                 .buff_type = SGL_BOTH,
2778                 .zlib_dir = ZLIB_DECOMPRESS,
2779                 .out_of_space = 0,
2780                 .big_data = 1,
2781                 .overflow = OVERFLOW_DISABLED
2782         };
2783
2784         ts_params->def_comp_xform->compress.deflate.huffman =
2785                                                 RTE_COMP_HUFFMAN_DYNAMIC;
2786
2787         /* fill the buffer with data based on rand. data */
2788         srand(BIG_DATA_TEST_SIZE);
2789         for (j = 0; j < BIG_DATA_TEST_SIZE - 1; ++j)
2790                 test_buffer[j] = (uint8_t)(rand() % ((uint8_t)-1)) | 1;
2791         test_buffer[BIG_DATA_TEST_SIZE-1] = 0;
2792
2793         /* Compress with compressdev, decompress with Zlib */
2794         test_data.zlib_dir = ZLIB_DECOMPRESS;
2795         ret = test_deflate_comp_decomp(&int_data, &test_data);
2796         if (ret < 0)
2797                 goto exit;
2798
2799         /* Compress with Zlib, decompress with compressdev */
2800         test_data.zlib_dir = ZLIB_COMPRESS;
2801         ret = test_deflate_comp_decomp(&int_data, &test_data);
2802         if (ret < 0)
2803                 goto exit;
2804
2805         ret = TEST_SUCCESS;
2806
2807 exit:
2808         ts_params->def_comp_xform->compress.deflate.huffman =
2809                                                 RTE_COMP_HUFFMAN_DEFAULT;
2810         rte_free(test_buffer);
2811         return ret;
2812 }
2813
2814 static int
2815 test_compressdev_deflate_stateful_decomp(void)
2816 {
2817         struct comp_testsuite_params *ts_params = &testsuite_params;
2818         int ret;
2819         uint16_t i;
2820         const struct rte_compressdev_capabilities *capab;
2821
2822         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2823         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2824
2825         if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2826                 return -ENOTSUP;
2827
2828         struct interim_data_params int_data = {
2829                 &compress_test_bufs[0],
2830                 1,
2831                 &i,
2832                 &ts_params->def_comp_xform,
2833                 &ts_params->def_decomp_xform,
2834                 1
2835         };
2836
2837         struct test_data_params test_data = {
2838                 .compress_state = RTE_COMP_OP_STATELESS,
2839                 .decompress_state = RTE_COMP_OP_STATEFUL,
2840                 .buff_type = LB_BOTH,
2841                 .zlib_dir = ZLIB_COMPRESS,
2842                 .out_of_space = 0,
2843                 .big_data = 0,
2844                 .decompress_output_block_size = 2000,
2845                 .decompress_steps_max = 4,
2846                 .overflow = OVERFLOW_DISABLED
2847         };
2848
2849         /* Compress with Zlib, decompress with compressdev */
2850         if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2851                 ret = TEST_FAILED;
2852                 goto exit;
2853         }
2854
2855         if (capab->comp_feature_flags & RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2856                 /* Now test with SGL buffers */
2857                 test_data.buff_type = SGL_BOTH;
2858                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2859                         ret = TEST_FAILED;
2860                         goto exit;
2861                 }
2862         }
2863
2864         ret  = TEST_SUCCESS;
2865
2866 exit:
2867         return ret;
2868 }
2869
2870 static int
2871 test_compressdev_deflate_stateful_decomp_checksum(void)
2872 {
2873         struct comp_testsuite_params *ts_params = &testsuite_params;
2874         int ret;
2875         uint16_t i;
2876         const struct rte_compressdev_capabilities *capab;
2877
2878         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
2879         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
2880
2881         if (!(capab->comp_feature_flags & RTE_COMP_FF_STATEFUL_DECOMPRESSION))
2882                 return -ENOTSUP;
2883
2884         /* Check if driver supports any checksum */
2885         if (!(capab->comp_feature_flags &
2886              (RTE_COMP_FF_CRC32_CHECKSUM | RTE_COMP_FF_ADLER32_CHECKSUM |
2887               RTE_COMP_FF_CRC32_ADLER32_CHECKSUM)))
2888                 return -ENOTSUP;
2889
2890         struct rte_comp_xform *compress_xform =
2891                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2892         if (compress_xform == NULL) {
2893                 RTE_LOG(ERR, USER1, "Compress xform could not be created\n");
2894                 return TEST_FAILED;
2895         }
2896
2897         memcpy(compress_xform, ts_params->def_comp_xform,
2898                sizeof(struct rte_comp_xform));
2899
2900         struct rte_comp_xform *decompress_xform =
2901                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
2902         if (decompress_xform == NULL) {
2903                 RTE_LOG(ERR, USER1, "Decompress xform could not be created\n");
2904                 rte_free(compress_xform);
2905                 return TEST_FAILED;
2906         }
2907
2908         memcpy(decompress_xform, ts_params->def_decomp_xform,
2909                sizeof(struct rte_comp_xform));
2910
2911         struct interim_data_params int_data = {
2912                 &compress_test_bufs[0],
2913                 1,
2914                 &i,
2915                 &compress_xform,
2916                 &decompress_xform,
2917                 1
2918         };
2919
2920         struct test_data_params test_data = {
2921                 .compress_state = RTE_COMP_OP_STATELESS,
2922                 .decompress_state = RTE_COMP_OP_STATEFUL,
2923                 .buff_type = LB_BOTH,
2924                 .zlib_dir = ZLIB_COMPRESS,
2925                 .out_of_space = 0,
2926                 .big_data = 0,
2927                 .decompress_output_block_size = 2000,
2928                 .decompress_steps_max = 4,
2929                 .overflow = OVERFLOW_DISABLED
2930         };
2931
2932         /* Check if driver supports crc32 checksum and test */
2933         if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_CHECKSUM) {
2934                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_CRC32;
2935                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_CRC32;
2936                 /* Compress with Zlib, decompress with compressdev */
2937                 test_data.buff_type = LB_BOTH;
2938                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2939                         ret = TEST_FAILED;
2940                         goto exit;
2941                 }
2942                 if (capab->comp_feature_flags &
2943                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2944                         /* Now test with SGL buffers */
2945                         test_data.buff_type = SGL_BOTH;
2946                         if (test_deflate_comp_decomp(&int_data,
2947                                                      &test_data) < 0) {
2948                                 ret = TEST_FAILED;
2949                                 goto exit;
2950                         }
2951                 }
2952         }
2953
2954         /* Check if driver supports adler32 checksum and test */
2955         if (capab->comp_feature_flags & RTE_COMP_FF_ADLER32_CHECKSUM) {
2956                 compress_xform->compress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2957                 decompress_xform->decompress.chksum = RTE_COMP_CHECKSUM_ADLER32;
2958                 /* Compress with Zlib, decompress with compressdev */
2959                 test_data.buff_type = LB_BOTH;
2960                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2961                         ret = TEST_FAILED;
2962                         goto exit;
2963                 }
2964                 if (capab->comp_feature_flags &
2965                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2966                         /* Now test with SGL buffers */
2967                         test_data.buff_type = SGL_BOTH;
2968                         if (test_deflate_comp_decomp(&int_data,
2969                                                      &test_data) < 0) {
2970                                 ret = TEST_FAILED;
2971                                 goto exit;
2972                         }
2973                 }
2974         }
2975
2976         /* Check if driver supports combined crc and adler checksum and test */
2977         if (capab->comp_feature_flags & RTE_COMP_FF_CRC32_ADLER32_CHECKSUM) {
2978                 compress_xform->compress.chksum =
2979                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2980                 decompress_xform->decompress.chksum =
2981                                 RTE_COMP_CHECKSUM_CRC32_ADLER32;
2982                 /* Zlib doesn't support combined checksum */
2983                 test_data.zlib_dir = ZLIB_NONE;
2984                 /* Compress stateless, decompress stateful with compressdev */
2985                 test_data.buff_type = LB_BOTH;
2986                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0) {
2987                         ret = TEST_FAILED;
2988                         goto exit;
2989                 }
2990                 if (capab->comp_feature_flags &
2991                                 RTE_COMP_FF_OOP_SGL_IN_SGL_OUT) {
2992                         /* Now test with SGL buffers */
2993                         test_data.buff_type = SGL_BOTH;
2994                         if (test_deflate_comp_decomp(&int_data,
2995                                                      &test_data) < 0) {
2996                                 ret = TEST_FAILED;
2997                                 goto exit;
2998                         }
2999                 }
3000         }
3001
3002         ret  = TEST_SUCCESS;
3003
3004 exit:
3005         rte_free(compress_xform);
3006         rte_free(decompress_xform);
3007         return ret;
3008 }
3009
3010 static const struct rte_memzone *
3011 make_memzone(const char *name, size_t size)
3012 {
3013         unsigned int socket_id = rte_socket_id();
3014         char mz_name[RTE_MEMZONE_NAMESIZE];
3015         const struct rte_memzone *memzone;
3016
3017         snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id);
3018         memzone = rte_memzone_lookup(mz_name);
3019         if (memzone != NULL && memzone->len != size) {
3020                 rte_memzone_free(memzone);
3021                 memzone = NULL;
3022         }
3023         if (memzone == NULL) {
3024                 memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
3025                                 RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
3026                 if (memzone == NULL)
3027                         RTE_LOG(ERR, USER1, "Can't allocate memory zone %s",
3028                                 mz_name);
3029         }
3030         return memzone;
3031 }
3032
3033 static int
3034 test_compressdev_external_mbufs(void)
3035 {
3036         struct comp_testsuite_params *ts_params = &testsuite_params;
3037         size_t data_len = 0;
3038         uint16_t i;
3039         int ret = TEST_FAILED;
3040
3041         for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
3042                 data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
3043
3044         struct interim_data_params int_data = {
3045                 NULL,
3046                 1,
3047                 NULL,
3048                 &ts_params->def_comp_xform,
3049                 &ts_params->def_decomp_xform,
3050                 1
3051         };
3052
3053         struct test_data_params test_data = {
3054                 .compress_state = RTE_COMP_OP_STATELESS,
3055                 .decompress_state = RTE_COMP_OP_STATELESS,
3056                 .buff_type = LB_BOTH,
3057                 .zlib_dir = ZLIB_DECOMPRESS,
3058                 .out_of_space = 0,
3059                 .big_data = 0,
3060                 .use_external_mbufs = 1,
3061                 .inbuf_data_size = data_len,
3062                 .inbuf_memzone = make_memzone("inbuf", data_len),
3063                 .compbuf_memzone = make_memzone("compbuf", data_len *
3064                                                 COMPRESS_BUF_SIZE_RATIO),
3065                 .uncompbuf_memzone = make_memzone("decompbuf", data_len),
3066                 .overflow = OVERFLOW_DISABLED
3067         };
3068
3069         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3070                 /* prepare input data */
3071                 data_len = strlen(compress_test_bufs[i]) + 1;
3072                 rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
3073                            data_len);
3074                 test_data.inbuf_data_size = data_len;
3075                 int_data.buf_idx = &i;
3076
3077                 /* Compress with compressdev, decompress with Zlib */
3078                 test_data.zlib_dir = ZLIB_DECOMPRESS;
3079                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3080                         goto exit;
3081
3082                 /* Compress with Zlib, decompress with compressdev */
3083                 test_data.zlib_dir = ZLIB_COMPRESS;
3084                 if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
3085                         goto exit;
3086         }
3087
3088         ret = TEST_SUCCESS;
3089
3090 exit:
3091         rte_memzone_free(test_data.inbuf_memzone);
3092         rte_memzone_free(test_data.compbuf_memzone);
3093         rte_memzone_free(test_data.uncompbuf_memzone);
3094         return ret;
3095 }
3096
3097 static int
3098 test_compressdev_deflate_stateless_fixed_oos_recoverable(void)
3099 {
3100         struct comp_testsuite_params *ts_params = &testsuite_params;
3101         uint16_t i;
3102         int ret;
3103         int comp_result;
3104         const struct rte_compressdev_capabilities *capab;
3105
3106         capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
3107         TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
3108
3109         if ((capab->comp_feature_flags & RTE_COMP_FF_HUFFMAN_FIXED) == 0)
3110                 return -ENOTSUP;
3111
3112         struct rte_comp_xform *compress_xform =
3113                         rte_malloc(NULL, sizeof(struct rte_comp_xform), 0);
3114
3115         if (compress_xform == NULL) {
3116                 RTE_LOG(ERR, USER1,
3117                         "Compress xform could not be created\n");
3118                 ret = TEST_FAILED;
3119                 goto exit;
3120         }
3121
3122         memcpy(compress_xform, ts_params->def_comp_xform,
3123                         sizeof(struct rte_comp_xform));
3124         compress_xform->compress.deflate.huffman = RTE_COMP_HUFFMAN_FIXED;
3125
3126         struct interim_data_params int_data = {
3127                 NULL,
3128                 1,
3129                 NULL,
3130                 &compress_xform,
3131                 &ts_params->def_decomp_xform,
3132                 1
3133         };
3134
3135         struct test_data_params test_data = {
3136                 .compress_state = RTE_COMP_OP_STATELESS,
3137                 .decompress_state = RTE_COMP_OP_STATELESS,
3138                 .buff_type = LB_BOTH,
3139                 .zlib_dir = ZLIB_DECOMPRESS,
3140                 .out_of_space = 0,
3141                 .big_data = 0,
3142                 .overflow = OVERFLOW_ENABLED
3143         };
3144
3145         for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
3146                 int_data.test_bufs = &compress_test_bufs[i];
3147                 int_data.buf_idx = &i;
3148
3149                 /* Compress with compressdev, decompress with Zlib */
3150                 test_data.zlib_dir = ZLIB_DECOMPRESS;
3151                 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3152                 if (comp_result < 0) {
3153                         ret = TEST_FAILED;
3154                         goto exit;
3155                 } else if (comp_result > 0) {
3156                         ret = -ENOTSUP;
3157                         goto exit;
3158                 }
3159
3160                 /* Compress with Zlib, decompress with compressdev */
3161                 test_data.zlib_dir = ZLIB_COMPRESS;
3162                 comp_result = test_deflate_comp_decomp(&int_data, &test_data);
3163                 if (comp_result < 0) {
3164                         ret = TEST_FAILED;
3165                         goto exit;
3166                 } else if (comp_result > 0) {
3167                         ret = -ENOTSUP;
3168                         goto exit;
3169                 }
3170         }
3171
3172         ret = TEST_SUCCESS;
3173
3174 exit:
3175         rte_free(compress_xform);
3176         return ret;
3177 }
3178
3179 static struct unit_test_suite compressdev_testsuite  = {
3180         .suite_name = "compressdev unit test suite",
3181         .setup = testsuite_setup,
3182         .teardown = testsuite_teardown,
3183         .unit_test_cases = {
3184                 TEST_CASE_ST(NULL, NULL,
3185                         test_compressdev_invalid_configuration),
3186                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3187                         test_compressdev_deflate_stateless_fixed),
3188                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3189                         test_compressdev_deflate_stateless_dynamic),
3190                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3191                         test_compressdev_deflate_stateless_dynamic_big),
3192                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3193                         test_compressdev_deflate_stateless_multi_op),
3194                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3195                         test_compressdev_deflate_stateless_multi_level),
3196                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3197                         test_compressdev_deflate_stateless_multi_xform),
3198                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3199                         test_compressdev_deflate_stateless_sgl),
3200                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3201                         test_compressdev_deflate_stateless_checksum),
3202                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3203                         test_compressdev_out_of_space_buffer),
3204                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3205                         test_compressdev_deflate_stateful_decomp),
3206                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3207                         test_compressdev_deflate_stateful_decomp_checksum),
3208                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3209                         test_compressdev_external_mbufs),
3210                 TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
3211                 test_compressdev_deflate_stateless_fixed_oos_recoverable),
3212                 TEST_CASES_END() /**< NULL terminate unit test array */
3213         }
3214 };
3215
3216 static int
3217 test_compressdev(void)
3218 {
3219         return unit_test_suite_runner(&compressdev_testsuite);
3220 }
3221
3222 REGISTER_TEST_COMMAND(compressdev_autotest, test_compressdev);