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