1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2016-2017 Intel Corporation. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * * Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * * Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * * Neither the name of Intel Corporation nor the names of its 17 * contributors may be used to endorse or promote products derived 18 * from this software without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <getopt.h> 34 #include <unistd.h> 35 36 #include <rte_cryptodev.h> 37 #include <rte_malloc.h> 38 39 #include "cperf_options.h" 40 41 struct name_id_map { 42 const char *name; 43 uint32_t id; 44 }; 45 46 static int 47 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len, 48 const char *str_key) 49 { 50 unsigned int i; 51 52 for (i = 0; i < map_len; i++) { 53 54 if (strcmp(str_key, map[i].name) == 0) 55 return map[i].id; 56 } 57 58 return -1; 59 } 60 61 static int 62 parse_cperf_test_type(struct cperf_options *opts, const char *arg) 63 { 64 struct name_id_map cperftest_namemap[] = { 65 { 66 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT], 67 CPERF_TEST_TYPE_THROUGHPUT 68 }, 69 { 70 cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT], 71 CPERF_TEST_TYPE_CYCLECOUNT 72 }, 73 { 74 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], 75 CPERF_TEST_TYPE_LATENCY 76 } 77 }; 78 79 int id = get_str_key_id_mapping( 80 (struct name_id_map *)cperftest_namemap, 81 RTE_DIM(cperftest_namemap), arg); 82 if (id < 0) { 83 RTE_LOG(ERR, USER1, "failed to parse test type"); 84 return -1; 85 } 86 87 opts->test = (enum cperf_perf_test_type)id; 88 89 return 0; 90 } 91 92 static int 93 parse_uint32_t(uint32_t *value, const char *arg) 94 { 95 char *end = NULL; 96 unsigned long n = strtoul(arg, &end, 10); 97 98 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0')) 99 return -1; 100 101 if (n > UINT32_MAX) 102 return -ERANGE; 103 104 *value = (uint32_t) n; 105 106 return 0; 107 } 108 109 static int 110 parse_uint16_t(uint16_t *value, const char *arg) 111 { 112 uint32_t val = 0; 113 int ret = parse_uint32_t(&val, arg); 114 115 if (ret < 0) 116 return ret; 117 118 if (val > UINT16_MAX) 119 return -ERANGE; 120 121 *value = (uint16_t) val; 122 123 return 0; 124 } 125 126 static int 127 parse_total_ops(struct cperf_options *opts, const char *arg) 128 { 129 int ret = parse_uint32_t(&opts->total_ops, arg); 130 131 if (ret) 132 RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); 133 134 if (opts->total_ops == 0) { 135 RTE_LOG(ERR, USER1, 136 "invalid total operations count number specified\n"); 137 return -1; 138 } 139 140 return ret; 141 } 142 143 static int 144 parse_pool_sz(struct cperf_options *opts, const char *arg) 145 { 146 int ret = parse_uint32_t(&opts->pool_sz, arg); 147 148 if (ret) 149 RTE_LOG(ERR, USER1, "failed to parse pool size"); 150 return ret; 151 } 152 153 static int 154 parse_burst_sz(struct cperf_options *opts, const char *arg) 155 { 156 int ret = parse_uint32_t(&opts->burst_sz, arg); 157 158 if (ret) 159 RTE_LOG(ERR, USER1, "failed to parse burst size"); 160 return ret; 161 } 162 163 static int 164 parse_buffer_sz(struct cperf_options *opts, const char *arg) 165 { 166 uint32_t i, valid_buf_sz[] = { 167 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792, 168 2048 169 }; 170 171 if (parse_uint32_t(&opts->buffer_sz, arg)) { 172 RTE_LOG(ERR, USER1, "failed to parse buffer size"); 173 return -1; 174 } 175 176 for (i = 0; i < RTE_DIM(valid_buf_sz); i++) 177 if (valid_buf_sz[i] == opts->buffer_sz) 178 return 0; 179 180 RTE_LOG(ERR, USER1, "invalid buffer size specified"); 181 return -1; 182 } 183 184 static int 185 parse_segments_nb(struct cperf_options *opts, const char *arg) 186 { 187 int ret = parse_uint32_t(&opts->segments_nb, arg); 188 189 if (ret) { 190 RTE_LOG(ERR, USER1, "failed to parse segments number\n"); 191 return -1; 192 } 193 194 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) { 195 RTE_LOG(ERR, USER1, "invalid segments number specified\n"); 196 return -1; 197 } 198 199 return 0; 200 } 201 202 static int 203 parse_device_type(struct cperf_options *opts, const char *arg) 204 { 205 if (strlen(arg) > (sizeof(opts->device_type) - 1)) 206 return -1; 207 208 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1); 209 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0'; 210 211 return 0; 212 } 213 214 static int 215 parse_op_type(struct cperf_options *opts, const char *arg) 216 { 217 struct name_id_map optype_namemap[] = { 218 { 219 cperf_op_type_strs[CPERF_CIPHER_ONLY], 220 CPERF_CIPHER_ONLY 221 }, 222 { 223 cperf_op_type_strs[CPERF_AUTH_ONLY], 224 CPERF_AUTH_ONLY 225 }, 226 { 227 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH], 228 CPERF_CIPHER_THEN_AUTH 229 }, 230 { 231 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER], 232 CPERF_AUTH_THEN_CIPHER 233 }, 234 { 235 cperf_op_type_strs[CPERF_AEAD], 236 CPERF_AEAD 237 } 238 }; 239 240 int id = get_str_key_id_mapping(optype_namemap, 241 RTE_DIM(optype_namemap), arg); 242 if (id < 0) { 243 RTE_LOG(ERR, USER1, "invalid opt type specified\n"); 244 return -1; 245 } 246 247 opts->op_type = (enum cperf_op_type)id; 248 249 return 0; 250 } 251 252 static int 253 parse_sessionless(struct cperf_options *opts, 254 const char *arg __rte_unused) 255 { 256 opts->sessionless = 1; 257 return 0; 258 } 259 260 static int 261 parse_out_of_place(struct cperf_options *opts, 262 const char *arg __rte_unused) 263 { 264 opts->out_of_place = 1; 265 return 0; 266 } 267 268 static int 269 parse_verify(struct cperf_options *opts, 270 const char *arg __rte_unused) 271 { 272 opts->verify = 1; 273 274 return 0; 275 } 276 277 static int 278 parse_test_file(struct cperf_options *opts, 279 const char *arg) 280 { 281 opts->test_file = strdup(arg); 282 if (access(opts->test_file, F_OK) != -1) 283 return 0; 284 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n"); 285 286 return -1; 287 } 288 289 static int 290 parse_test_name(struct cperf_options *opts, 291 const char *arg) 292 { 293 char *test_name = (char *) rte_zmalloc(NULL, 294 sizeof(char) * (strlen(arg) + 3), 0); 295 snprintf(test_name, strlen(arg) + 3, "[%s]", arg); 296 opts->test_name = test_name; 297 298 return 0; 299 } 300 301 static int 302 parse_silent(struct cperf_options *opts, 303 const char *arg __rte_unused) 304 { 305 opts->silent = 1; 306 307 return 0; 308 } 309 310 static int 311 parse_cipher_algo(struct cperf_options *opts, const char *arg) 312 { 313 314 enum rte_crypto_cipher_algorithm cipher_algo; 315 316 if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) { 317 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); 318 return -1; 319 } 320 321 opts->cipher_algo = cipher_algo; 322 323 return 0; 324 } 325 326 static int 327 parse_cipher_op(struct cperf_options *opts, const char *arg) 328 { 329 struct name_id_map cipher_op_namemap[] = { 330 { 331 rte_crypto_cipher_operation_strings 332 [RTE_CRYPTO_CIPHER_OP_ENCRYPT], 333 RTE_CRYPTO_CIPHER_OP_ENCRYPT }, 334 { 335 rte_crypto_cipher_operation_strings 336 [RTE_CRYPTO_CIPHER_OP_DECRYPT], 337 RTE_CRYPTO_CIPHER_OP_DECRYPT 338 } 339 }; 340 341 int id = get_str_key_id_mapping(cipher_op_namemap, 342 RTE_DIM(cipher_op_namemap), arg); 343 if (id < 0) { 344 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n"); 345 return -1; 346 } 347 348 opts->cipher_op = (enum rte_crypto_cipher_operation)id; 349 350 return 0; 351 } 352 353 static int 354 parse_cipher_key_sz(struct cperf_options *opts, const char *arg) 355 { 356 return parse_uint16_t(&opts->cipher_key_sz, arg); 357 } 358 359 static int 360 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) 361 { 362 return parse_uint16_t(&opts->cipher_iv_sz, arg); 363 } 364 365 static int 366 parse_auth_algo(struct cperf_options *opts, const char *arg) 367 { 368 enum rte_crypto_auth_algorithm auth_algo; 369 370 if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) { 371 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n"); 372 return -1; 373 } 374 375 opts->auth_algo = auth_algo; 376 377 return 0; 378 } 379 380 static int 381 parse_auth_op(struct cperf_options *opts, const char *arg) 382 { 383 struct name_id_map auth_op_namemap[] = { 384 { 385 rte_crypto_auth_operation_strings 386 [RTE_CRYPTO_AUTH_OP_GENERATE], 387 RTE_CRYPTO_AUTH_OP_GENERATE }, 388 { 389 rte_crypto_auth_operation_strings 390 [RTE_CRYPTO_AUTH_OP_VERIFY], 391 RTE_CRYPTO_AUTH_OP_VERIFY 392 } 393 }; 394 395 int id = get_str_key_id_mapping(auth_op_namemap, 396 RTE_DIM(auth_op_namemap), arg); 397 if (id < 0) { 398 RTE_LOG(ERR, USER1, "invalid authentication operation specified" 399 "\n"); 400 return -1; 401 } 402 403 opts->auth_op = (enum rte_crypto_auth_operation)id; 404 405 return 0; 406 } 407 408 static int 409 parse_auth_key_sz(struct cperf_options *opts, const char *arg) 410 { 411 return parse_uint16_t(&opts->auth_key_sz, arg); 412 } 413 414 static int 415 parse_auth_digest_sz(struct cperf_options *opts, const char *arg) 416 { 417 return parse_uint16_t(&opts->auth_digest_sz, arg); 418 } 419 420 static int 421 parse_auth_aad_sz(struct cperf_options *opts, const char *arg) 422 { 423 return parse_uint16_t(&opts->auth_aad_sz, arg); 424 } 425 426 static int 427 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) 428 { 429 opts->csv = 1; 430 opts->silent = 1; 431 return 0; 432 } 433 434 typedef int (*option_parser_t)(struct cperf_options *opts, 435 const char *arg); 436 437 struct long_opt_parser { 438 const char *lgopt_name; 439 option_parser_t parser_fn; 440 441 }; 442 443 static struct option lgopts[] = { 444 445 { CPERF_PTEST_TYPE, required_argument, 0, 0 }, 446 447 { CPERF_POOL_SIZE, required_argument, 0, 0 }, 448 { CPERF_TOTAL_OPS, required_argument, 0, 0 }, 449 { CPERF_BURST_SIZE, required_argument, 0, 0 }, 450 { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, 451 { CPERF_SEGMENTS_NB, required_argument, 0, 0 }, 452 453 { CPERF_DEVTYPE, required_argument, 0, 0 }, 454 { CPERF_OPTYPE, required_argument, 0, 0 }, 455 456 { CPERF_SILENT, no_argument, 0, 0 }, 457 { CPERF_SESSIONLESS, no_argument, 0, 0 }, 458 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, 459 { CPERF_VERIFY, no_argument, 0, 0 }, 460 { CPERF_TEST_FILE, required_argument, 0, 0 }, 461 { CPERF_TEST_NAME, required_argument, 0, 0 }, 462 463 { CPERF_CIPHER_ALGO, required_argument, 0, 0 }, 464 { CPERF_CIPHER_OP, required_argument, 0, 0 }, 465 466 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 }, 467 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 }, 468 469 { CPERF_AUTH_ALGO, required_argument, 0, 0 }, 470 { CPERF_AUTH_OP, required_argument, 0, 0 }, 471 472 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, 473 { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 }, 474 { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 }, 475 { CPERF_CSV, no_argument, 0, 0}, 476 477 { NULL, 0, 0, 0 } 478 }; 479 480 void 481 cperf_options_default(struct cperf_options *opts) 482 { 483 opts->test = CPERF_TEST_TYPE_THROUGHPUT; 484 485 opts->pool_sz = 8192; 486 opts->total_ops = 10000000; 487 opts->burst_sz = 32; 488 opts->buffer_sz = 64; 489 opts->segments_nb = 1; 490 491 strncpy(opts->device_type, "crypto_aesni_mb", 492 sizeof(opts->device_type)); 493 494 opts->op_type = CPERF_CIPHER_THEN_AUTH; 495 496 opts->silent = 0; 497 opts->verify = 0; 498 opts->test_file = NULL; 499 opts->test_name = NULL; 500 opts->sessionless = 0; 501 opts->out_of_place = 0; 502 opts->csv = 0; 503 504 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC; 505 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 506 opts->cipher_key_sz = 16; 507 opts->cipher_iv_sz = 16; 508 509 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 510 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; 511 512 opts->auth_key_sz = 64; 513 opts->auth_digest_sz = 12; 514 opts->auth_aad_sz = 0; 515 } 516 517 static int 518 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) 519 { 520 struct long_opt_parser parsermap[] = { 521 { CPERF_PTEST_TYPE, parse_cperf_test_type }, 522 { CPERF_SILENT, parse_silent }, 523 { CPERF_POOL_SIZE, parse_pool_sz }, 524 { CPERF_TOTAL_OPS, parse_total_ops }, 525 { CPERF_BURST_SIZE, parse_burst_sz }, 526 { CPERF_BUFFER_SIZE, parse_buffer_sz }, 527 { CPERF_SEGMENTS_NB, parse_segments_nb }, 528 { CPERF_DEVTYPE, parse_device_type }, 529 { CPERF_OPTYPE, parse_op_type }, 530 { CPERF_SESSIONLESS, parse_sessionless }, 531 { CPERF_OUT_OF_PLACE, parse_out_of_place }, 532 { CPERF_VERIFY, parse_verify }, 533 { CPERF_TEST_FILE, parse_test_file }, 534 { CPERF_TEST_NAME, parse_test_name }, 535 { CPERF_CIPHER_ALGO, parse_cipher_algo }, 536 { CPERF_CIPHER_OP, parse_cipher_op }, 537 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz }, 538 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz }, 539 { CPERF_AUTH_ALGO, parse_auth_algo }, 540 { CPERF_AUTH_OP, parse_auth_op }, 541 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, 542 { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz }, 543 { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz }, 544 { CPERF_CSV, parse_csv_friendly}, 545 }; 546 unsigned int i; 547 548 for (i = 0; i < RTE_DIM(parsermap); i++) { 549 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name, 550 strlen(lgopts[opt_idx].name)) == 0) 551 return parsermap[i].parser_fn(opts, optarg); 552 } 553 554 return -EINVAL; 555 } 556 557 int 558 cperf_options_parse(struct cperf_options *options, int argc, char **argv) 559 { 560 int opt, retval, opt_idx; 561 562 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) { 563 switch (opt) { 564 /* long options */ 565 case 0: 566 567 retval = cperf_opts_parse_long(opt_idx, options); 568 if (retval != 0) 569 return retval; 570 571 break; 572 573 default: 574 return -EINVAL; 575 } 576 } 577 578 return 0; 579 } 580 581 int 582 cperf_options_check(struct cperf_options *options) 583 { 584 if (options->segments_nb > options->buffer_sz) { 585 RTE_LOG(ERR, USER1, 586 "Segments number greater than buffer size.\n"); 587 return -EINVAL; 588 } 589 590 if (options->verify && options->test_file == NULL) { 591 RTE_LOG(ERR, USER1, "Define path to the file with test" 592 " vectors.\n"); 593 return -EINVAL; 594 } 595 596 if (options->test_name != NULL && options->test_file == NULL) { 597 RTE_LOG(ERR, USER1, "Define path to the file with test" 598 " vectors.\n"); 599 return -EINVAL; 600 } 601 602 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY && 603 options->test_file == NULL) { 604 RTE_LOG(ERR, USER1, "Define path to the file with test" 605 " vectors.\n"); 606 return -EINVAL; 607 } 608 609 if (options->verify && 610 options->total_ops > options->pool_sz) { 611 RTE_LOG(ERR, USER1, "Total number of ops must be less than or" 612 " equal to the pool size.\n"); 613 return -EINVAL; 614 } 615 616 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 617 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT && 618 options->auth_op != 619 RTE_CRYPTO_AUTH_OP_GENERATE) { 620 RTE_LOG(ERR, USER1, "Option cipher then auth must use" 621 " options: encrypt and generate.\n"); 622 return -EINVAL; 623 } 624 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) { 625 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT && 626 options->auth_op != 627 RTE_CRYPTO_AUTH_OP_VERIFY) { 628 RTE_LOG(ERR, USER1, "Option auth then cipher must use" 629 " options: decrypt and verify.\n"); 630 return -EINVAL; 631 } 632 } else if (options->op_type == CPERF_AEAD) { 633 if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT && 634 options->auth_op == 635 RTE_CRYPTO_AUTH_OP_GENERATE) && 636 !(options->cipher_op == 637 RTE_CRYPTO_CIPHER_OP_DECRYPT && 638 options->auth_op == 639 RTE_CRYPTO_AUTH_OP_VERIFY)) { 640 RTE_LOG(ERR, USER1, "Use together options: encrypt and" 641 " generate or decrypt and verify.\n"); 642 return -EINVAL; 643 } 644 } 645 646 if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_GCM || 647 options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CCM || 648 options->auth_algo == RTE_CRYPTO_AUTH_AES_GCM || 649 options->auth_algo == RTE_CRYPTO_AUTH_AES_CCM || 650 options->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { 651 if (options->op_type != CPERF_AEAD) { 652 RTE_LOG(ERR, USER1, "Use --optype aead\n"); 653 return -EINVAL; 654 } 655 } 656 657 return 0; 658 } 659 660 void 661 cperf_options_dump(struct cperf_options *opts) 662 { 663 printf("# Crypto Performance Application Options:\n"); 664 printf("#\n"); 665 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); 666 printf("#\n"); 667 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); 668 printf("# total number of ops: %u\n", opts->total_ops); 669 printf("# burst size: %u\n", opts->burst_sz); 670 printf("# buffer size: %u\n", opts->buffer_sz); 671 printf("# segments per buffer: %u\n", opts->segments_nb); 672 printf("#\n"); 673 printf("# cryptodev type: %s\n", opts->device_type); 674 printf("#\n"); 675 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); 676 printf("# verify operation: %s\n", opts->verify ? "yes" : "no"); 677 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); 678 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); 679 680 printf("#\n"); 681 682 if (opts->op_type == CPERF_AUTH_ONLY || 683 opts->op_type == CPERF_CIPHER_THEN_AUTH || 684 opts->op_type == CPERF_AUTH_THEN_CIPHER || 685 opts->op_type == CPERF_AEAD) { 686 printf("# auth algorithm: %s\n", 687 rte_crypto_auth_algorithm_strings[opts->auth_algo]); 688 printf("# auth operation: %s\n", 689 rte_crypto_auth_operation_strings[opts->auth_op]); 690 printf("# auth key size: %u\n", opts->auth_key_sz); 691 printf("# auth digest size: %u\n", opts->auth_digest_sz); 692 printf("# auth aad size: %u\n", opts->auth_aad_sz); 693 printf("#\n"); 694 } 695 696 if (opts->op_type == CPERF_CIPHER_ONLY || 697 opts->op_type == CPERF_CIPHER_THEN_AUTH || 698 opts->op_type == CPERF_AUTH_THEN_CIPHER || 699 opts->op_type == CPERF_AEAD) { 700 printf("# cipher algorithm: %s\n", 701 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); 702 printf("# cipher operation: %s\n", 703 rte_crypto_cipher_operation_strings[opts->cipher_op]); 704 printf("# cipher key size: %u\n", opts->cipher_key_sz); 705 printf("# cipher iv size: %u\n", opts->cipher_iv_sz); 706 printf("#\n"); 707 } 708 } 709