app/test-crypto-perf/cperf_options_parsing.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2017 Intel Corporation
   3  */
   4
   5 #include <getopt.h>
   6 #include <unistd.h>
   7
   8 #include <rte_cryptodev.h>
   9 #include <rte_malloc.h>
  10 #include <rte_ether.h>
  11
  12 #include "cperf_options.h"
  13
  14 #define AES_BLOCK_SIZE 16
  15 #define DES_BLOCK_SIZE 8
  16
  17 struct name_id_map {
  18         const char *name;
  19         uint32_t id;
  20 };
  21
  22 static void
  23 usage(char *progname)
  24 {
  25         printf("%s [EAL options] --\n"
  26                 " --silent: disable options dump\n"
  27                 " --ptest throughput / latency / verify / pmd-cyclecount :"
  28                 " set test type\n"
  29                 " --pool_sz N: set the number of crypto ops/mbufs allocated\n"
  30                 " --total-ops N: set the number of total operations performed\n"
  31                 " --burst-sz N: set the number of packets per burst\n"
  32                 " --buffer-sz N: set the size of a single packet\n"
  33                 " --imix N: set the distribution of packet sizes\n"
  34                 " --segment-sz N: set the size of the segment to use\n"
  35                 " --desc-nb N: set number of descriptors for each crypto device\n"
  36                 " --devtype TYPE: set crypto device type to use\n"
  37                 " --optype cipher-only / auth-only / cipher-then-auth /\n"
  38                 "           auth-then-cipher / aead : set operation type\n"
  39                 " --sessionless: enable session-less crypto operations\n"
  40                 " --out-of-place: enable out-of-place crypto operations\n"
  41                 " --test-file NAME: set the test vector file path\n"
  42                 " --test-name NAME: set specific test name section in test file\n"
  43                 " --cipher-algo ALGO: set cipher algorithm\n"
  44                 " --cipher-op encrypt / decrypt: set the cipher operation\n"
  45                 " --cipher-key-sz N: set the cipher key size\n"
  46                 " --cipher-iv-sz N: set the cipher IV size\n"
  47                 " --auth-algo ALGO: set auth algorithm\n"
  48                 " --auth-op generate / verify: set the auth operation\n"
  49                 " --auth-key-sz N: set the auth key size\n"
  50                 " --auth-iv-sz N: set the auth IV size\n"
  51                 " --aead-algo ALGO: set AEAD algorithm\n"
  52                 " --aead-op encrypt / decrypt: set the AEAD operation\n"
  53                 " --aead-key-sz N: set the AEAD key size\n"
  54                 " --aead-iv-sz N: set the AEAD IV size\n"
  55                 " --aead-aad-sz N: set the AEAD AAD size\n"
  56                 " --digest-sz N: set the digest size\n"
  57                 " --pmd-cyclecount-delay-ms N: set delay between enqueue\n"
  58                 "           and dequeue in pmd-cyclecount benchmarking mode\n"
  59                 " --csv-friendly: enable test result output CSV friendly\n"
  60 #ifdef RTE_LIB_SECURITY
  61                 " --pdcp-sn-sz N: set PDCP SN size N <5/7/12/15/18>\n"
  62                 " --pdcp-domain DOMAIN: set PDCP domain <control/user>\n"
  63                 " --pdcp-ses-hfn-en: enable session based fixed HFN\n"
  64                 " --docsis-hdr-sz: set DOCSIS header size\n"
  65 #endif
  66                 " -h: prints this help\n",
  67                 progname);
  68 }
  69
  70 static int
  71 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
  72                 const char *str_key)
  73 {
  74         unsigned int i;
  75
  76         for (i = 0; i < map_len; i++) {
  77
  78                 if (strcmp(str_key, map[i].name) == 0)
  79                         return map[i].id;
  80         }
  81
  82         return -1;
  83 }
  84
  85 static int
  86 parse_cperf_test_type(struct cperf_options *opts, const char *arg)
  87 {
  88         struct name_id_map cperftest_namemap[] = {
  89                 {
  90                         cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT],
  91                         CPERF_TEST_TYPE_THROUGHPUT
  92                 },
  93                 {
  94                         cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY],
  95                         CPERF_TEST_TYPE_VERIFY
  96                 },
  97                 {
  98                         cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY],
  99                         CPERF_TEST_TYPE_LATENCY
 100                 },
 101                 {
 102                         cperf_test_type_strs[CPERF_TEST_TYPE_PMDCC],
 103                         CPERF_TEST_TYPE_PMDCC
 104                 }
 105         };
 106
 107         int id = get_str_key_id_mapping(
 108                         (struct name_id_map *)cperftest_namemap,
 109                         RTE_DIM(cperftest_namemap), arg);
 110         if (id < 0) {
 111                 RTE_LOG(ERR, USER1, "failed to parse test type");
 112                 return -1;
 113         }
 114
 115         opts->test = (enum cperf_perf_test_type)id;
 116
 117         return 0;
 118 }
 119
 120 static int
 121 parse_uint32_t(uint32_t *value, const char *arg)
 122 {
 123         char *end = NULL;
 124         unsigned long n = strtoul(arg, &end, 10);
 125
 126         if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
 127                 return -1;
 128
 129         if (n > UINT32_MAX)
 130                 return -ERANGE;
 131
 132         *value = (uint32_t) n;
 133
 134         return 0;
 135 }
 136
 137 static int
 138 parse_uint16_t(uint16_t *value, const char *arg)
 139 {
 140         uint32_t val = 0;
 141         int ret = parse_uint32_t(&val, arg);
 142
 143         if (ret < 0)
 144                 return ret;
 145
 146         if (val > UINT16_MAX)
 147                 return -ERANGE;
 148
 149         *value = (uint16_t) val;
 150
 151         return 0;
 152 }
 153
 154 static int
 155 parse_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc)
 156 {
 157         char *token;
 158         uint32_t number;
 159
 160         char *copy_arg = strdup(arg);
 161
 162         if (copy_arg == NULL)
 163                 return -1;
 164
 165         errno = 0;
 166         token = strtok(copy_arg, ":");
 167
 168         /* Parse minimum value */
 169         if (token != NULL) {
 170                 number = strtoul(token, NULL, 10);
 171
 172                 if (errno == EINVAL || errno == ERANGE ||
 173                                 number == 0)
 174                         goto err_range;
 175
 176                 *min = number;
 177         } else
 178                 goto err_range;
 179
 180         token = strtok(NULL, ":");
 181
 182         /* Parse increment value */
 183         if (token != NULL) {
 184                 number = strtoul(token, NULL, 10);
 185
 186                 if (errno == EINVAL || errno == ERANGE ||
 187                                 number == 0)
 188                         goto err_range;
 189
 190                 *inc = number;
 191         } else
 192                 goto err_range;
 193
 194         token = strtok(NULL, ":");
 195
 196         /* Parse maximum value */
 197         if (token != NULL) {
 198                 number = strtoul(token, NULL, 10);
 199
 200                 if (errno == EINVAL || errno == ERANGE ||
 201                                 number == 0 ||
 202                                 number < *min)
 203                         goto err_range;
 204
 205                 *max = number;
 206         } else
 207                 goto err_range;
 208
 209         if (strtok(NULL, ":") != NULL)
 210                 goto err_range;
 211
 212         free(copy_arg);
 213         return 0;
 214
 215 err_range:
 216         free(copy_arg);
 217         return -1;
 218 }
 219
 220 static int
 221 parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max)
 222 {
 223         char *token;
 224         uint32_t number;
 225         uint8_t count = 0;
 226         uint32_t temp_min;
 227         uint32_t temp_max;
 228
 229         char *copy_arg = strdup(arg);
 230
 231         if (copy_arg == NULL)
 232                 return -1;
 233
 234         errno = 0;
 235         token = strtok(copy_arg, ",");
 236
 237         /* Parse first value */
 238         if (token != NULL) {
 239                 number = strtoul(token, NULL, 10);
 240
 241                 if (errno == EINVAL || errno == ERANGE ||
 242                                 number == 0)
 243                         goto err_list;
 244
 245                 list[count++] = number;
 246                 temp_min = number;
 247                 temp_max = number;
 248         } else
 249                 goto err_list;
 250
 251         token = strtok(NULL, ",");
 252
 253         while (token != NULL) {
 254                 if (count == MAX_LIST) {
 255                         RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n",
 256                                         MAX_LIST);
 257                         break;
 258                 }
 259
 260                 number = strtoul(token, NULL, 10);
 261
 262                 if (errno == EINVAL || errno == ERANGE ||
 263                                 number == 0)
 264                         goto err_list;
 265
 266                 list[count++] = number;
 267
 268                 if (number < temp_min)
 269                         temp_min = number;
 270                 if (number > temp_max)
 271                         temp_max = number;
 272
 273                 token = strtok(NULL, ",");
 274         }
 275
 276         if (min)
 277                 *min = temp_min;
 278         if (max)
 279                 *max = temp_max;
 280
 281         free(copy_arg);
 282         return count;
 283
 284 err_list:
 285         free(copy_arg);
 286         return -1;
 287 }
 288
 289 static int
 290 parse_total_ops(struct cperf_options *opts, const char *arg)
 291 {
 292         int ret = parse_uint32_t(&opts->total_ops, arg);
 293
 294         if (ret)
 295                 RTE_LOG(ERR, USER1, "failed to parse total operations count\n");
 296
 297         if (opts->total_ops == 0) {
 298                 RTE_LOG(ERR, USER1,
 299                                 "invalid total operations count number specified\n");
 300                 return -1;
 301         }
 302
 303         return ret;
 304 }
 305
 306 static int
 307 parse_pool_sz(struct cperf_options *opts, const char *arg)
 308 {
 309         int ret =  parse_uint32_t(&opts->pool_sz, arg);
 310
 311         if (ret)
 312                 RTE_LOG(ERR, USER1, "failed to parse pool size");
 313         return ret;
 314 }
 315
 316 static int
 317 parse_burst_sz(struct cperf_options *opts, const char *arg)
 318 {
 319         int ret;
 320
 321         /* Try parsing the argument as a range, if it fails, parse it as a list */
 322         if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size,
 323                         &opts->inc_burst_size) < 0) {
 324                 ret = parse_list(arg, opts->burst_size_list,
 325                                         &opts->min_burst_size,
 326                                         &opts->max_burst_size);
 327                 if (ret < 0) {
 328                         RTE_LOG(ERR, USER1, "failed to parse burst size/s\n");
 329                         return -1;
 330                 }
 331                 opts->burst_size_count = ret;
 332         }
 333
 334         return 0;
 335 }
 336
 337 static int
 338 parse_buffer_sz(struct cperf_options *opts, const char *arg)
 339 {
 340         int ret;
 341
 342         /* Try parsing the argument as a range, if it fails, parse it as a list */
 343         if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size,
 344                         &opts->inc_buffer_size) < 0) {
 345                 ret = parse_list(arg, opts->buffer_size_list,
 346                                         &opts->min_buffer_size,
 347                                         &opts->max_buffer_size);
 348                 if (ret < 0) {
 349                         RTE_LOG(ERR, USER1, "failed to parse buffer size/s\n");
 350                         return -1;
 351                 }
 352                 opts->buffer_size_count = ret;
 353         }
 354
 355         return 0;
 356 }
 357
 358 static int
 359 parse_segment_sz(struct cperf_options *opts, const char *arg)
 360 {
 361         int ret = parse_uint32_t(&opts->segment_sz, arg);
 362
 363         if (ret) {
 364                 RTE_LOG(ERR, USER1, "failed to parse segment size\n");
 365                 return -1;
 366         }
 367
 368         if (opts->segment_sz == 0) {
 369                 RTE_LOG(ERR, USER1, "Segment size has to be bigger than 0\n");
 370                 return -1;
 371         }
 372
 373         return 0;
 374 }
 375
 376 static int
 377 parse_imix(struct cperf_options *opts, const char *arg)
 378 {
 379         int ret;
 380
 381         ret = parse_list(arg, opts->imix_distribution_list,
 382                                 NULL, NULL);
 383         if (ret < 0) {
 384                 RTE_LOG(ERR, USER1, "failed to parse imix distribution\n");
 385                 return -1;
 386         }
 387
 388         opts->imix_distribution_count = ret;
 389
 390         if (opts->imix_distribution_count <= 1) {
 391                 RTE_LOG(ERR, USER1, "imix distribution should have "
 392                                 "at least two entries\n");
 393                 return -1;
 394         }
 395
 396         return 0;
 397 }
 398
 399 static int
 400 parse_desc_nb(struct cperf_options *opts, const char *arg)
 401 {
 402         int ret = parse_uint32_t(&opts->nb_descriptors, arg);
 403
 404         if (ret) {
 405                 RTE_LOG(ERR, USER1, "failed to parse descriptors number\n");
 406                 return -1;
 407         }
 408
 409         if (opts->nb_descriptors == 0) {
 410                 RTE_LOG(ERR, USER1, "invalid descriptors number specified\n");
 411                 return -1;
 412         }
 413
 414         return 0;
 415 }
 416
 417 static int
 418 parse_device_type(struct cperf_options *opts, const char *arg)
 419 {
 420         if (strlen(arg) > (sizeof(opts->device_type) - 1))
 421                 return -1;
 422
 423         strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1);
 424         *(opts->device_type + sizeof(opts->device_type) - 1) = '\0';
 425
 426         return 0;
 427 }
 428
 429 static int
 430 parse_op_type(struct cperf_options *opts, const char *arg)
 431 {
 432         struct name_id_map optype_namemap[] = {
 433                 {
 434                         cperf_op_type_strs[CPERF_CIPHER_ONLY],
 435                         CPERF_CIPHER_ONLY
 436                 },
 437                 {
 438                         cperf_op_type_strs[CPERF_AUTH_ONLY],
 439                         CPERF_AUTH_ONLY
 440                 },
 441                 {
 442                         cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH],
 443                         CPERF_CIPHER_THEN_AUTH
 444                 },
 445                 {
 446                         cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER],
 447                         CPERF_AUTH_THEN_CIPHER
 448                 },
 449                 {
 450                         cperf_op_type_strs[CPERF_AEAD],
 451                         CPERF_AEAD
 452                 },
 453                 {
 454                         cperf_op_type_strs[CPERF_PDCP],
 455                         CPERF_PDCP
 456                 },
 457                 {
 458                         cperf_op_type_strs[CPERF_DOCSIS],
 459                         CPERF_DOCSIS
 460                 },
 461                 {
 462                         cperf_op_type_strs[CPERF_ASYM_MODEX],
 463                         CPERF_ASYM_MODEX
 464                 }
 465         };
 466
 467         int id = get_str_key_id_mapping(optype_namemap,
 468                         RTE_DIM(optype_namemap), arg);
 469         if (id < 0) {
 470                 RTE_LOG(ERR, USER1, "invalid opt type specified\n");
 471                 return -1;
 472         }
 473
 474         opts->op_type = (enum cperf_op_type)id;
 475
 476         return 0;
 477 }
 478
 479 static int
 480 parse_sessionless(struct cperf_options *opts,
 481                 const char *arg __rte_unused)
 482 {
 483         opts->sessionless = 1;
 484         return 0;
 485 }
 486
 487 static int
 488 parse_out_of_place(struct cperf_options *opts,
 489                 const char *arg __rte_unused)
 490 {
 491         opts->out_of_place = 1;
 492         return 0;
 493 }
 494
 495 static int
 496 parse_test_file(struct cperf_options *opts,
 497                 const char *arg)
 498 {
 499         opts->test_file = strdup(arg);
 500         if (access(opts->test_file, F_OK) != -1)
 501                 return 0;
 502         RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n");
 503
 504         return -1;
 505 }
 506
 507 static int
 508 parse_test_name(struct cperf_options *opts,
 509                 const char *arg)
 510 {
 511         char *test_name = (char *) rte_zmalloc(NULL,
 512                 sizeof(char) * (strlen(arg) + 3), 0);
 513         if (test_name == NULL) {
 514                 RTE_LOG(ERR, USER1, "Failed to rte zmalloc with size: %zu\n",
 515                         strlen(arg) + 3);
 516                 return -1;
 517         }
 518
 519         snprintf(test_name, strlen(arg) + 3, "[%s]", arg);
 520         opts->test_name = test_name;
 521
 522         return 0;
 523 }
 524
 525 static int
 526 parse_silent(struct cperf_options *opts,
 527                 const char *arg __rte_unused)
 528 {
 529         opts->silent = 1;
 530
 531         return 0;
 532 }
 533
 534 static int
 535 parse_cipher_algo(struct cperf_options *opts, const char *arg)
 536 {
 537
 538         enum rte_crypto_cipher_algorithm cipher_algo;
 539
 540         if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) {
 541                 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n");
 542                 return -1;
 543         }
 544
 545         opts->cipher_algo = cipher_algo;
 546
 547         return 0;
 548 }
 549
 550 static int
 551 parse_cipher_op(struct cperf_options *opts, const char *arg)
 552 {
 553         struct name_id_map cipher_op_namemap[] = {
 554                 {
 555                         rte_crypto_cipher_operation_strings
 556                         [RTE_CRYPTO_CIPHER_OP_ENCRYPT],
 557                         RTE_CRYPTO_CIPHER_OP_ENCRYPT },
 558                 {
 559                         rte_crypto_cipher_operation_strings
 560                         [RTE_CRYPTO_CIPHER_OP_DECRYPT],
 561                         RTE_CRYPTO_CIPHER_OP_DECRYPT
 562                 }
 563         };
 564
 565         int id = get_str_key_id_mapping(cipher_op_namemap,
 566                         RTE_DIM(cipher_op_namemap), arg);
 567         if (id < 0) {
 568                 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n");
 569                 return -1;
 570         }
 571
 572         opts->cipher_op = (enum rte_crypto_cipher_operation)id;
 573
 574         return 0;
 575 }
 576
 577 static int
 578 parse_cipher_key_sz(struct cperf_options *opts, const char *arg)
 579 {
 580         return parse_uint16_t(&opts->cipher_key_sz, arg);
 581 }
 582
 583 static int
 584 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg)
 585 {
 586         return parse_uint16_t(&opts->cipher_iv_sz, arg);
 587 }
 588
 589 static int
 590 parse_auth_algo(struct cperf_options *opts, const char *arg)
 591 {
 592         enum rte_crypto_auth_algorithm auth_algo;
 593
 594         if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) {
 595                 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n");
 596                 return -1;
 597         }
 598
 599         opts->auth_algo = auth_algo;
 600
 601         return 0;
 602 }
 603
 604 static int
 605 parse_auth_op(struct cperf_options *opts, const char *arg)
 606 {
 607         struct name_id_map auth_op_namemap[] = {
 608                 {
 609                         rte_crypto_auth_operation_strings
 610                         [RTE_CRYPTO_AUTH_OP_GENERATE],
 611                         RTE_CRYPTO_AUTH_OP_GENERATE },
 612                 {
 613                         rte_crypto_auth_operation_strings
 614                         [RTE_CRYPTO_AUTH_OP_VERIFY],
 615                         RTE_CRYPTO_AUTH_OP_VERIFY
 616                 }
 617         };
 618
 619         int id = get_str_key_id_mapping(auth_op_namemap,
 620                         RTE_DIM(auth_op_namemap), arg);
 621         if (id < 0) {
 622                 RTE_LOG(ERR, USER1, "invalid authentication operation specified"
 623                                 "\n");
 624                 return -1;
 625         }
 626
 627         opts->auth_op = (enum rte_crypto_auth_operation)id;
 628
 629         return 0;
 630 }
 631
 632 static int
 633 parse_auth_key_sz(struct cperf_options *opts, const char *arg)
 634 {
 635         return parse_uint16_t(&opts->auth_key_sz, arg);
 636 }
 637
 638 static int
 639 parse_digest_sz(struct cperf_options *opts, const char *arg)
 640 {
 641         return parse_uint16_t(&opts->digest_sz, arg);
 642 }
 643
 644 #ifdef RTE_LIB_SECURITY
 645 static int
 646 parse_pdcp_sn_sz(struct cperf_options *opts, const char *arg)
 647 {
 648         uint32_t val = 0;
 649         int ret = parse_uint32_t(&val, arg);
 650
 651         if (ret < 0)
 652                 return ret;
 653
 654         if (val != RTE_SECURITY_PDCP_SN_SIZE_5 &&
 655                         val != RTE_SECURITY_PDCP_SN_SIZE_7 &&
 656                         val != RTE_SECURITY_PDCP_SN_SIZE_12 &&
 657                         val != RTE_SECURITY_PDCP_SN_SIZE_15 &&
 658                         val != RTE_SECURITY_PDCP_SN_SIZE_18) {
 659                 printf("\nInvalid pdcp SN size: %u\n", val);
 660                 return -ERANGE;
 661         }
 662         opts->pdcp_sn_sz = val;
 663
 664         return 0;
 665 }
 666
 667 const char *cperf_pdcp_domain_strs[] = {
 668         [RTE_SECURITY_PDCP_MODE_CONTROL] = "control",
 669         [RTE_SECURITY_PDCP_MODE_DATA] = "data",
 670         [RTE_SECURITY_PDCP_MODE_SHORT_MAC] = "short_mac"
 671 };
 672
 673 static int
 674 parse_pdcp_domain(struct cperf_options *opts, const char *arg)
 675 {
 676         struct name_id_map pdcp_domain_namemap[] = {
 677                 {
 678                         cperf_pdcp_domain_strs
 679                         [RTE_SECURITY_PDCP_MODE_CONTROL],
 680                         RTE_SECURITY_PDCP_MODE_CONTROL },
 681                 {
 682                         cperf_pdcp_domain_strs
 683                         [RTE_SECURITY_PDCP_MODE_DATA],
 684                         RTE_SECURITY_PDCP_MODE_DATA
 685                 },
 686                 {
 687                         cperf_pdcp_domain_strs
 688                         [RTE_SECURITY_PDCP_MODE_SHORT_MAC],
 689                         RTE_SECURITY_PDCP_MODE_SHORT_MAC
 690                 }
 691         };
 692
 693         int id = get_str_key_id_mapping(pdcp_domain_namemap,
 694                         RTE_DIM(pdcp_domain_namemap), arg);
 695         if (id < 0) {
 696                 RTE_LOG(ERR, USER1, "invalid pdcp domain specified"
 697                                 "\n");
 698                 return -1;
 699         }
 700
 701         opts->pdcp_domain = (enum rte_security_pdcp_domain)id;
 702
 703         return 0;
 704 }
 705
 706 static int
 707 parse_pdcp_ses_hfn_en(struct cperf_options *opts, const char *arg __rte_unused)
 708 {
 709         opts->pdcp_ses_hfn_en = 1;
 710         return 0;
 711 }
 712
 713 static int
 714 parse_docsis_hdr_sz(struct cperf_options *opts, const char *arg)
 715 {
 716         return parse_uint16_t(&opts->docsis_hdr_sz, arg);
 717 }
 718 #endif
 719
 720 static int
 721 parse_auth_iv_sz(struct cperf_options *opts, const char *arg)
 722 {
 723         return parse_uint16_t(&opts->auth_iv_sz, arg);
 724 }
 725
 726 static int
 727 parse_aead_algo(struct cperf_options *opts, const char *arg)
 728 {
 729         enum rte_crypto_aead_algorithm aead_algo;
 730
 731         if (rte_cryptodev_get_aead_algo_enum(&aead_algo, arg) < 0) {
 732                 RTE_LOG(ERR, USER1, "Invalid AEAD algorithm specified\n");
 733                 return -1;
 734         }
 735
 736         opts->aead_algo = aead_algo;
 737
 738         return 0;
 739 }
 740
 741 static int
 742 parse_aead_op(struct cperf_options *opts, const char *arg)
 743 {
 744         struct name_id_map aead_op_namemap[] = {
 745                 {
 746                         rte_crypto_aead_operation_strings
 747                         [RTE_CRYPTO_AEAD_OP_ENCRYPT],
 748                         RTE_CRYPTO_AEAD_OP_ENCRYPT },
 749                 {
 750                         rte_crypto_aead_operation_strings
 751                         [RTE_CRYPTO_AEAD_OP_DECRYPT],
 752                         RTE_CRYPTO_AEAD_OP_DECRYPT
 753                 }
 754         };
 755
 756         int id = get_str_key_id_mapping(aead_op_namemap,
 757                         RTE_DIM(aead_op_namemap), arg);
 758         if (id < 0) {
 759                 RTE_LOG(ERR, USER1, "invalid AEAD operation specified"
 760                                 "\n");
 761                 return -1;
 762         }
 763
 764         opts->aead_op = (enum rte_crypto_aead_operation)id;
 765
 766         return 0;
 767 }
 768
 769 static int
 770 parse_aead_key_sz(struct cperf_options *opts, const char *arg)
 771 {
 772         return parse_uint16_t(&opts->aead_key_sz, arg);
 773 }
 774
 775 static int
 776 parse_aead_iv_sz(struct cperf_options *opts, const char *arg)
 777 {
 778         return parse_uint16_t(&opts->aead_iv_sz, arg);
 779 }
 780
 781 static int
 782 parse_aead_aad_sz(struct cperf_options *opts, const char *arg)
 783 {
 784         return parse_uint16_t(&opts->aead_aad_sz, arg);
 785 }
 786
 787 static int
 788 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused)
 789 {
 790         opts->csv = 1;
 791         opts->silent = 1;
 792         return 0;
 793 }
 794
 795 static int
 796 parse_pmd_cyclecount_delay_ms(struct cperf_options *opts,
 797                         const char *arg)
 798 {
 799         int ret = parse_uint32_t(&opts->pmdcc_delay, arg);
 800
 801         if (ret) {
 802                 RTE_LOG(ERR, USER1, "failed to parse pmd-cyclecount delay\n");
 803                 return -1;
 804         }
 805
 806         return 0;
 807 }
 808
 809 typedef int (*option_parser_t)(struct cperf_options *opts,
 810                 const char *arg);
 811
 812 struct long_opt_parser {
 813         const char *lgopt_name;
 814         option_parser_t parser_fn;
 815
 816 };
 817
 818 static struct option lgopts[] = {
 819
 820         { CPERF_PTEST_TYPE, required_argument, 0, 0 },
 821
 822         { CPERF_POOL_SIZE, required_argument, 0, 0 },
 823         { CPERF_TOTAL_OPS, required_argument, 0, 0 },
 824         { CPERF_BURST_SIZE, required_argument, 0, 0 },
 825         { CPERF_BUFFER_SIZE, required_argument, 0, 0 },
 826         { CPERF_SEGMENT_SIZE, required_argument, 0, 0 },
 827         { CPERF_DESC_NB, required_argument, 0, 0 },
 828
 829         { CPERF_IMIX, required_argument, 0, 0 },
 830         { CPERF_DEVTYPE, required_argument, 0, 0 },
 831         { CPERF_OPTYPE, required_argument, 0, 0 },
 832
 833         { CPERF_SILENT, no_argument, 0, 0 },
 834         { CPERF_SESSIONLESS, no_argument, 0, 0 },
 835         { CPERF_OUT_OF_PLACE, no_argument, 0, 0 },
 836         { CPERF_TEST_FILE, required_argument, 0, 0 },
 837         { CPERF_TEST_NAME, required_argument, 0, 0 },
 838
 839         { CPERF_CIPHER_ALGO, required_argument, 0, 0 },
 840         { CPERF_CIPHER_OP, required_argument, 0, 0 },
 841
 842         { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 },
 843         { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 },
 844
 845         { CPERF_AUTH_ALGO, required_argument, 0, 0 },
 846         { CPERF_AUTH_OP, required_argument, 0, 0 },
 847
 848         { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 },
 849         { CPERF_AUTH_IV_SZ, required_argument, 0, 0 },
 850
 851         { CPERF_AEAD_ALGO, required_argument, 0, 0 },
 852         { CPERF_AEAD_OP, required_argument, 0, 0 },
 853
 854         { CPERF_AEAD_KEY_SZ, required_argument, 0, 0 },
 855         { CPERF_AEAD_AAD_SZ, required_argument, 0, 0 },
 856         { CPERF_AEAD_IV_SZ, required_argument, 0, 0 },
 857
 858         { CPERF_DIGEST_SZ, required_argument, 0, 0 },
 859
 860 #ifdef RTE_LIB_SECURITY
 861         { CPERF_PDCP_SN_SZ, required_argument, 0, 0 },
 862         { CPERF_PDCP_DOMAIN, required_argument, 0, 0 },
 863         { CPERF_PDCP_SES_HFN_EN, no_argument, 0, 0 },
 864         { CPERF_DOCSIS_HDR_SZ, required_argument, 0, 0 },
 865 #endif
 866         { CPERF_CSV, no_argument, 0, 0},
 867
 868         { CPERF_PMDCC_DELAY_MS, required_argument, 0, 0 },
 869
 870         { NULL, 0, 0, 0 }
 871 };
 872
 873 void
 874 cperf_options_default(struct cperf_options *opts)
 875 {
 876         opts->test = CPERF_TEST_TYPE_THROUGHPUT;
 877
 878         opts->pool_sz = 8192;
 879         opts->total_ops = 10000000;
 880         opts->nb_descriptors = 2048;
 881
 882         opts->buffer_size_list[0] = 64;
 883         opts->buffer_size_count = 1;
 884         opts->max_buffer_size = 64;
 885         opts->min_buffer_size = 64;
 886         opts->inc_buffer_size = 0;
 887
 888         opts->burst_size_list[0] = 32;
 889         opts->burst_size_count = 1;
 890         opts->max_burst_size = 32;
 891         opts->min_burst_size = 32;
 892         opts->inc_burst_size = 0;
 893
 894         /*
 895          * Will be parsed from command line or set to
 896          * maximum buffer size + digest, later
 897          */
 898         opts->segment_sz = 0;
 899
 900         opts->imix_distribution_count = 0;
 901         strncpy(opts->device_type, "crypto_aesni_mb",
 902                         sizeof(opts->device_type));
 903         opts->nb_qps = 1;
 904
 905         opts->op_type = CPERF_CIPHER_THEN_AUTH;
 906
 907         opts->silent = 0;
 908         opts->test_file = NULL;
 909         opts->test_name = NULL;
 910         opts->sessionless = 0;
 911         opts->out_of_place = 0;
 912         opts->csv = 0;
 913
 914         opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC;
 915         opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
 916         opts->cipher_key_sz = 16;
 917         opts->cipher_iv_sz = 16;
 918
 919         opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
 920         opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE;
 921
 922         opts->auth_key_sz = 64;
 923         opts->auth_iv_sz = 0;
 924
 925         opts->aead_key_sz = 0;
 926         opts->aead_iv_sz = 0;
 927         opts->aead_aad_sz = 0;
 928
 929         opts->digest_sz = 12;
 930
 931         opts->pmdcc_delay = 0;
 932 #ifdef RTE_LIB_SECURITY
 933         opts->pdcp_sn_sz = 12;
 934         opts->pdcp_domain = RTE_SECURITY_PDCP_MODE_CONTROL;
 935         opts->pdcp_ses_hfn_en = 0;
 936         opts->docsis_hdr_sz = 17;
 937 #endif
 938 }
 939
 940 static int
 941 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts)
 942 {
 943         struct long_opt_parser parsermap[] = {
 944                 { CPERF_PTEST_TYPE,     parse_cperf_test_type },
 945                 { CPERF_SILENT,         parse_silent },
 946                 { CPERF_POOL_SIZE,      parse_pool_sz },
 947                 { CPERF_TOTAL_OPS,      parse_total_ops },
 948                 { CPERF_BURST_SIZE,     parse_burst_sz },
 949                 { CPERF_BUFFER_SIZE,    parse_buffer_sz },
 950                 { CPERF_SEGMENT_SIZE,   parse_segment_sz },
 951                 { CPERF_DESC_NB,        parse_desc_nb },
 952                 { CPERF_DEVTYPE,        parse_device_type },
 953                 { CPERF_OPTYPE,         parse_op_type },
 954                 { CPERF_SESSIONLESS,    parse_sessionless },
 955                 { CPERF_OUT_OF_PLACE,   parse_out_of_place },
 956                 { CPERF_IMIX,           parse_imix },
 957                 { CPERF_TEST_FILE,      parse_test_file },
 958                 { CPERF_TEST_NAME,      parse_test_name },
 959                 { CPERF_CIPHER_ALGO,    parse_cipher_algo },
 960                 { CPERF_CIPHER_OP,      parse_cipher_op },
 961                 { CPERF_CIPHER_KEY_SZ,  parse_cipher_key_sz },
 962                 { CPERF_CIPHER_IV_SZ,   parse_cipher_iv_sz },
 963                 { CPERF_AUTH_ALGO,      parse_auth_algo },
 964                 { CPERF_AUTH_OP,        parse_auth_op },
 965                 { CPERF_AUTH_KEY_SZ,    parse_auth_key_sz },
 966                 { CPERF_AUTH_IV_SZ,     parse_auth_iv_sz },
 967                 { CPERF_AEAD_ALGO,      parse_aead_algo },
 968                 { CPERF_AEAD_OP,        parse_aead_op },
 969                 { CPERF_AEAD_KEY_SZ,    parse_aead_key_sz },
 970                 { CPERF_AEAD_IV_SZ,     parse_aead_iv_sz },
 971                 { CPERF_AEAD_AAD_SZ,    parse_aead_aad_sz },
 972                 { CPERF_DIGEST_SZ,      parse_digest_sz },
 973 #ifdef RTE_LIB_SECURITY
 974                 { CPERF_PDCP_SN_SZ,     parse_pdcp_sn_sz },
 975                 { CPERF_PDCP_DOMAIN,    parse_pdcp_domain },
 976                 { CPERF_PDCP_SES_HFN_EN,        parse_pdcp_ses_hfn_en },
 977                 { CPERF_DOCSIS_HDR_SZ,  parse_docsis_hdr_sz },
 978 #endif
 979                 { CPERF_CSV,            parse_csv_friendly},
 980                 { CPERF_PMDCC_DELAY_MS, parse_pmd_cyclecount_delay_ms},
 981         };
 982         unsigned int i;
 983
 984         for (i = 0; i < RTE_DIM(parsermap); i++) {
 985                 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
 986                                 strlen(lgopts[opt_idx].name)) == 0)
 987                         return parsermap[i].parser_fn(opts, optarg);
 988         }
 989
 990         return -EINVAL;
 991 }
 992
 993 int
 994 cperf_options_parse(struct cperf_options *options, int argc, char **argv)
 995 {
 996         int opt, retval, opt_idx;
 997
 998         while ((opt = getopt_long(argc, argv, "h", lgopts, &opt_idx)) != EOF) {
 999                 switch (opt) {
1000                 case 'h':
1001                         usage(argv[0]);
1002                         exit(EXIT_SUCCESS);
1003                         break;
1004                 /* long options */
1005                 case 0:
1006                         retval = cperf_opts_parse_long(opt_idx, options);
1007                         if (retval != 0)
1008                                 return retval;
1009
1010                         break;
1011
1012                 default:
1013                         usage(argv[0]);
1014                         return -EINVAL;
1015                 }
1016         }
1017
1018         return 0;
1019 }
1020
1021 static int
1022 check_cipher_buffer_length(struct cperf_options *options)
1023 {
1024         uint32_t buffer_size, buffer_size_idx = 0;
1025
1026         if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC ||
1027                         options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) {
1028                 if (options->inc_buffer_size != 0)
1029                         buffer_size = options->min_buffer_size;
1030                 else
1031                         buffer_size = options->buffer_size_list[0];
1032
1033                 while (buffer_size <= options->max_buffer_size) {
1034                         if ((buffer_size % AES_BLOCK_SIZE) != 0) {
1035                                 RTE_LOG(ERR, USER1, "Some of the buffer sizes are "
1036                                         "not suitable for the algorithm selected\n");
1037                                 return -EINVAL;
1038                         }
1039
1040                         if (options->inc_buffer_size != 0)
1041                                 buffer_size += options->inc_buffer_size;
1042                         else {
1043                                 if (++buffer_size_idx == options->buffer_size_count)
1044                                         break;
1045                                 buffer_size = options->buffer_size_list[buffer_size_idx];
1046                         }
1047
1048                 }
1049         }
1050
1051         if (options->cipher_algo == RTE_CRYPTO_CIPHER_DES_CBC ||
1052                         options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_CBC ||
1053                         options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_ECB) {
1054                 if (options->inc_buffer_size != 0)
1055                         buffer_size = options->min_buffer_size;
1056                 else
1057                         buffer_size = options->buffer_size_list[0];
1058
1059                 while (buffer_size <= options->max_buffer_size) {
1060                         if ((buffer_size % DES_BLOCK_SIZE) != 0) {
1061                                 RTE_LOG(ERR, USER1, "Some of the buffer sizes are "
1062                                         "not suitable for the algorithm selected\n");
1063                                 return -EINVAL;
1064                         }
1065
1066                         if (options->inc_buffer_size != 0)
1067                                 buffer_size += options->inc_buffer_size;
1068                         else {
1069                                 if (++buffer_size_idx == options->buffer_size_count)
1070                                         break;
1071                                 buffer_size = options->buffer_size_list[buffer_size_idx];
1072                         }
1073
1074                 }
1075         }
1076
1077         return 0;
1078 }
1079
1080 #ifdef RTE_LIB_SECURITY
1081 static int
1082 check_docsis_buffer_length(struct cperf_options *options)
1083 {
1084         uint32_t buffer_size, buffer_size_idx = 0;
1085
1086         if (options->inc_buffer_size != 0)
1087                 buffer_size = options->min_buffer_size;
1088         else
1089                 buffer_size = options->buffer_size_list[0];
1090
1091         while (buffer_size <= options->max_buffer_size) {
1092                 if (buffer_size < (uint32_t)(options->docsis_hdr_sz +
1093                                 RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN)) {
1094                         RTE_LOG(ERR, USER1, "Some of the buffer sizes are not "
1095                                 "valid for DOCSIS\n");
1096                         return -EINVAL;
1097                 }
1098
1099                 if (options->inc_buffer_size != 0)
1100                         buffer_size += options->inc_buffer_size;
1101                 else {
1102                         if (++buffer_size_idx == options->buffer_size_count)
1103                                 break;
1104                         buffer_size =
1105                                 options->buffer_size_list[buffer_size_idx];
1106                 }
1107         }
1108
1109         return 0;
1110 }
1111 #endif
1112
1113 int
1114 cperf_options_check(struct cperf_options *options)
1115 {
1116         if (options->op_type == CPERF_CIPHER_ONLY ||
1117                         options->op_type == CPERF_DOCSIS)
1118                 options->digest_sz = 0;
1119
1120         if (options->out_of_place &&
1121                         options->segment_sz <= options->max_buffer_size) {
1122                 RTE_LOG(ERR, USER1, "Out of place mode can only work "
1123                                         "with non segmented buffers\n");
1124                 return -EINVAL;
1125         }
1126
1127         /*
1128          * If segment size is not set, assume only one segment,
1129          * big enough to contain the largest buffer and the digest
1130          */
1131         if (options->segment_sz == 0)
1132                 options->segment_sz = options->max_buffer_size +
1133                                 options->digest_sz;
1134
1135         if (options->segment_sz < options->digest_sz) {
1136                 RTE_LOG(ERR, USER1,
1137                                 "Segment size should be at least "
1138                                 "the size of the digest\n");
1139                 return -EINVAL;
1140         }
1141
1142         if ((options->imix_distribution_count != 0) &&
1143                         (options->imix_distribution_count !=
1144                                 options->buffer_size_count)) {
1145                 RTE_LOG(ERR, USER1, "IMIX distribution must have the same "
1146                                 "number of buffer sizes\n");
1147                 return -EINVAL;
1148         }
1149
1150         if (options->test == CPERF_TEST_TYPE_VERIFY &&
1151                         options->test_file == NULL) {
1152                 RTE_LOG(ERR, USER1, "Define path to the file with test"
1153                                 " vectors.\n");
1154                 return -EINVAL;
1155         }
1156
1157         if (options->test == CPERF_TEST_TYPE_VERIFY &&
1158                         options->op_type != CPERF_CIPHER_ONLY &&
1159                         options->test_name == NULL) {
1160                 RTE_LOG(ERR, USER1, "Define test name to get the correct digest"
1161                                 " from the test vectors.\n");
1162                 return -EINVAL;
1163         }
1164
1165         if (options->test_name != NULL && options->test_file == NULL) {
1166                 RTE_LOG(ERR, USER1, "Define path to the file with test"
1167                                 " vectors.\n");
1168                 return -EINVAL;
1169         }
1170
1171         if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY &&
1172                         options->test_file == NULL) {
1173                 RTE_LOG(ERR, USER1, "Define path to the file with test"
1174                                 " vectors.\n");
1175                 return -EINVAL;
1176         }
1177
1178         if (options->test == CPERF_TEST_TYPE_VERIFY &&
1179                         (options->inc_buffer_size != 0 ||
1180                         options->buffer_size_count > 1)) {
1181                 RTE_LOG(ERR, USER1, "Only one buffer size is allowed when "
1182                                 "using the verify test.\n");
1183                 return -EINVAL;
1184         }
1185
1186         if (options->test == CPERF_TEST_TYPE_VERIFY &&
1187                         (options->inc_burst_size != 0 ||
1188                         options->burst_size_count > 1)) {
1189                 RTE_LOG(ERR, USER1, "Only one burst size is allowed when "
1190                                 "using the verify test.\n");
1191                 return -EINVAL;
1192         }
1193
1194         if (options->test == CPERF_TEST_TYPE_PMDCC &&
1195                         options->pool_sz < options->nb_descriptors) {
1196                 RTE_LOG(ERR, USER1, "For pmd cyclecount benchmarks, pool size "
1197                                 "must be equal or greater than the number of "
1198                                 "cryptodev descriptors.\n");
1199                 return -EINVAL;
1200         }
1201
1202         if (options->test == CPERF_TEST_TYPE_VERIFY &&
1203                         options->imix_distribution_count > 0) {
1204                 RTE_LOG(ERR, USER1, "IMIX is not allowed when "
1205                                 "using the verify test.\n");
1206                 return -EINVAL;
1207         }
1208
1209         if (options->op_type == CPERF_CIPHER_THEN_AUTH) {
1210                 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
1211                                 options->auth_op !=
1212                                 RTE_CRYPTO_AUTH_OP_GENERATE) {
1213                         RTE_LOG(ERR, USER1, "Option cipher then auth must use"
1214                                         " options: encrypt and generate.\n");
1215                         return -EINVAL;
1216                 }
1217         } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) {
1218                 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT &&
1219                                 options->auth_op !=
1220                                 RTE_CRYPTO_AUTH_OP_VERIFY) {
1221                         RTE_LOG(ERR, USER1, "Option auth then cipher must use"
1222                                         " options: decrypt and verify.\n");
1223                         return -EINVAL;
1224                 }
1225         }
1226
1227         if (options->op_type == CPERF_CIPHER_ONLY ||
1228                         options->op_type == CPERF_CIPHER_THEN_AUTH ||
1229                         options->op_type == CPERF_AUTH_THEN_CIPHER) {
1230                 if (check_cipher_buffer_length(options) < 0)
1231                         return -EINVAL;
1232         }
1233
1234 #ifdef RTE_LIB_SECURITY
1235         if (options->op_type == CPERF_DOCSIS) {
1236                 if (check_docsis_buffer_length(options) < 0)
1237                         return -EINVAL;
1238         }
1239 #endif
1240
1241         return 0;
1242 }
1243
1244 void
1245 cperf_options_dump(struct cperf_options *opts)
1246 {
1247         uint8_t size_idx;
1248
1249         printf("# Crypto Performance Application Options:\n");
1250         printf("#\n");
1251         printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]);
1252         printf("#\n");
1253         printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz);
1254         printf("# total number of ops: %u\n", opts->total_ops);
1255         if (opts->inc_buffer_size != 0) {
1256                 printf("# buffer size:\n");
1257                 printf("#\t min: %u\n", opts->min_buffer_size);
1258                 printf("#\t max: %u\n", opts->max_buffer_size);
1259                 printf("#\t inc: %u\n", opts->inc_buffer_size);
1260         } else {
1261                 printf("# buffer sizes: ");
1262                 for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++)
1263                         printf("%u ", opts->buffer_size_list[size_idx]);
1264                 printf("\n");
1265         }
1266         if (opts->inc_burst_size != 0) {
1267                 printf("# burst size:\n");
1268                 printf("#\t min: %u\n", opts->min_burst_size);
1269                 printf("#\t max: %u\n", opts->max_burst_size);
1270                 printf("#\t inc: %u\n", opts->inc_burst_size);
1271         } else {
1272                 printf("# burst sizes: ");
1273                 for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++)
1274                         printf("%u ", opts->burst_size_list[size_idx]);
1275                 printf("\n");
1276         }
1277         printf("\n# segment size: %u\n", opts->segment_sz);
1278         printf("#\n");
1279         printf("# cryptodev type: %s\n", opts->device_type);
1280         printf("#\n");
1281         printf("# number of queue pairs per device: %u\n", opts->nb_qps);
1282         printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]);
1283         printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no");
1284         printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no");
1285         if (opts->test == CPERF_TEST_TYPE_PMDCC)
1286                 printf("# inter-burst delay: %u ms\n", opts->pmdcc_delay);
1287
1288         printf("#\n");
1289
1290         if (opts->op_type == CPERF_AUTH_ONLY ||
1291                         opts->op_type == CPERF_CIPHER_THEN_AUTH ||
1292                         opts->op_type == CPERF_AUTH_THEN_CIPHER) {
1293                 printf("# auth algorithm: %s\n",
1294                         rte_crypto_auth_algorithm_strings[opts->auth_algo]);
1295                 printf("# auth operation: %s\n",
1296                         rte_crypto_auth_operation_strings[opts->auth_op]);
1297                 printf("# auth key size: %u\n", opts->auth_key_sz);
1298                 printf("# auth iv size: %u\n", opts->auth_iv_sz);
1299                 printf("# auth digest size: %u\n", opts->digest_sz);
1300                 printf("#\n");
1301         }
1302
1303         if (opts->op_type == CPERF_CIPHER_ONLY ||
1304                         opts->op_type == CPERF_CIPHER_THEN_AUTH ||
1305                         opts->op_type == CPERF_AUTH_THEN_CIPHER) {
1306                 printf("# cipher algorithm: %s\n",
1307                         rte_crypto_cipher_algorithm_strings[opts->cipher_algo]);
1308                 printf("# cipher operation: %s\n",
1309                         rte_crypto_cipher_operation_strings[opts->cipher_op]);
1310                 printf("# cipher key size: %u\n", opts->cipher_key_sz);
1311                 printf("# cipher iv size: %u\n", opts->cipher_iv_sz);
1312                 printf("#\n");
1313         }
1314
1315         if (opts->op_type == CPERF_AEAD) {
1316                 printf("# aead algorithm: %s\n",
1317                         rte_crypto_aead_algorithm_strings[opts->aead_algo]);
1318                 printf("# aead operation: %s\n",
1319                         rte_crypto_aead_operation_strings[opts->aead_op]);
1320                 printf("# aead key size: %u\n", opts->aead_key_sz);
1321                 printf("# aead iv size: %u\n", opts->aead_iv_sz);
1322                 printf("# aead digest size: %u\n", opts->digest_sz);
1323                 printf("# aead aad size: %u\n", opts->aead_aad_sz);
1324                 printf("#\n");
1325         }
1326
1327 #ifdef RTE_LIB_SECURITY
1328         if (opts->op_type == CPERF_DOCSIS) {
1329                 printf("# docsis header size: %u\n", opts->docsis_hdr_sz);
1330                 printf("#\n");
1331         }
1332 #endif
1333 }