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_VERIFY], 71 CPERF_TEST_TYPE_VERIFY 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_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc) 128 { 129 char *token; 130 uint32_t number; 131 132 char *copy_arg = strdup(arg); 133 134 if (copy_arg == NULL) 135 return -1; 136 137 token = strtok(copy_arg, ":"); 138 139 /* Parse minimum value */ 140 if (token != NULL) { 141 number = strtoul(token, NULL, 10); 142 143 if (errno == EINVAL || errno == ERANGE || 144 number == 0) 145 goto err_range; 146 147 *min = number; 148 } else 149 goto err_range; 150 151 token = strtok(NULL, ":"); 152 153 /* Parse increment value */ 154 if (token != NULL) { 155 number = strtoul(token, NULL, 10); 156 157 if (errno == EINVAL || errno == ERANGE || 158 number == 0) 159 goto err_range; 160 161 *inc = number; 162 } else 163 goto err_range; 164 165 token = strtok(NULL, ":"); 166 167 /* Parse maximum value */ 168 if (token != NULL) { 169 number = strtoul(token, NULL, 10); 170 171 if (errno == EINVAL || errno == ERANGE || 172 number == 0 || 173 number < *min) 174 goto err_range; 175 176 *max = number; 177 } else 178 goto err_range; 179 180 if (strtok(NULL, ":") != NULL) 181 goto err_range; 182 183 free(copy_arg); 184 return 0; 185 186 err_range: 187 free(copy_arg); 188 return -1; 189 } 190 191 static int 192 parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max) 193 { 194 char *token; 195 uint32_t number; 196 uint8_t count = 0; 197 198 char *copy_arg = strdup(arg); 199 200 if (copy_arg == NULL) 201 return -1; 202 203 token = strtok(copy_arg, ","); 204 205 /* Parse first value */ 206 if (token != NULL) { 207 number = strtoul(token, NULL, 10); 208 209 if (errno == EINVAL || errno == ERANGE || 210 number == 0) 211 goto err_list; 212 213 list[count++] = number; 214 *min = number; 215 *max = number; 216 } else 217 goto err_list; 218 219 token = strtok(NULL, ","); 220 221 while (token != NULL) { 222 if (count == MAX_LIST) { 223 RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n", 224 MAX_LIST); 225 break; 226 } 227 228 number = strtoul(token, NULL, 10); 229 230 if (errno == EINVAL || errno == ERANGE || 231 number == 0) 232 goto err_list; 233 234 list[count++] = number; 235 236 if (number < *min) 237 *min = number; 238 if (number > *max) 239 *max = number; 240 241 token = strtok(NULL, ","); 242 } 243 244 free(copy_arg); 245 return count; 246 247 err_list: 248 free(copy_arg); 249 return -1; 250 } 251 252 static int 253 parse_total_ops(struct cperf_options *opts, const char *arg) 254 { 255 int ret = parse_uint32_t(&opts->total_ops, arg); 256 257 if (ret) 258 RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); 259 260 if (opts->total_ops == 0) { 261 RTE_LOG(ERR, USER1, 262 "invalid total operations count number specified\n"); 263 return -1; 264 } 265 266 return ret; 267 } 268 269 static int 270 parse_pool_sz(struct cperf_options *opts, const char *arg) 271 { 272 int ret = parse_uint32_t(&opts->pool_sz, arg); 273 274 if (ret) 275 RTE_LOG(ERR, USER1, "failed to parse pool size"); 276 return ret; 277 } 278 279 static int 280 parse_burst_sz(struct cperf_options *opts, const char *arg) 281 { 282 int ret; 283 284 /* Try parsing the argument as a range, if it fails, parse it as a list */ 285 if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size, 286 &opts->inc_burst_size) < 0) { 287 ret = parse_list(arg, opts->burst_size_list, 288 &opts->min_burst_size, 289 &opts->max_burst_size); 290 if (ret < 0) { 291 RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); 292 return -1; 293 } 294 opts->burst_size_count = ret; 295 } 296 297 return 0; 298 } 299 300 static int 301 parse_buffer_sz(struct cperf_options *opts, const char *arg) 302 { 303 int ret; 304 305 /* Try parsing the argument as a range, if it fails, parse it as a list */ 306 if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size, 307 &opts->inc_buffer_size) < 0) { 308 ret = parse_list(arg, opts->buffer_size_list, 309 &opts->min_buffer_size, 310 &opts->max_buffer_size); 311 if (ret < 0) { 312 RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); 313 return -1; 314 } 315 opts->buffer_size_count = ret; 316 } 317 318 return 0; 319 } 320 321 static int 322 parse_segments_nb(struct cperf_options *opts, const char *arg) 323 { 324 int ret = parse_uint32_t(&opts->segments_nb, arg); 325 326 if (ret) { 327 RTE_LOG(ERR, USER1, "failed to parse segments number\n"); 328 return -1; 329 } 330 331 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) { 332 RTE_LOG(ERR, USER1, "invalid segments number specified\n"); 333 return -1; 334 } 335 336 return 0; 337 } 338 339 static int 340 parse_device_type(struct cperf_options *opts, const char *arg) 341 { 342 if (strlen(arg) > (sizeof(opts->device_type) - 1)) 343 return -1; 344 345 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1); 346 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0'; 347 348 return 0; 349 } 350 351 static int 352 parse_op_type(struct cperf_options *opts, const char *arg) 353 { 354 struct name_id_map optype_namemap[] = { 355 { 356 cperf_op_type_strs[CPERF_CIPHER_ONLY], 357 CPERF_CIPHER_ONLY 358 }, 359 { 360 cperf_op_type_strs[CPERF_AUTH_ONLY], 361 CPERF_AUTH_ONLY 362 }, 363 { 364 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH], 365 CPERF_CIPHER_THEN_AUTH 366 }, 367 { 368 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER], 369 CPERF_AUTH_THEN_CIPHER 370 }, 371 { 372 cperf_op_type_strs[CPERF_AEAD], 373 CPERF_AEAD 374 } 375 }; 376 377 int id = get_str_key_id_mapping(optype_namemap, 378 RTE_DIM(optype_namemap), arg); 379 if (id < 0) { 380 RTE_LOG(ERR, USER1, "invalid opt type specified\n"); 381 return -1; 382 } 383 384 opts->op_type = (enum cperf_op_type)id; 385 386 return 0; 387 } 388 389 static int 390 parse_sessionless(struct cperf_options *opts, 391 const char *arg __rte_unused) 392 { 393 opts->sessionless = 1; 394 return 0; 395 } 396 397 static int 398 parse_out_of_place(struct cperf_options *opts, 399 const char *arg __rte_unused) 400 { 401 opts->out_of_place = 1; 402 return 0; 403 } 404 405 static int 406 parse_test_file(struct cperf_options *opts, 407 const char *arg) 408 { 409 opts->test_file = strdup(arg); 410 if (access(opts->test_file, F_OK) != -1) 411 return 0; 412 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n"); 413 414 return -1; 415 } 416 417 static int 418 parse_test_name(struct cperf_options *opts, 419 const char *arg) 420 { 421 char *test_name = (char *) rte_zmalloc(NULL, 422 sizeof(char) * (strlen(arg) + 3), 0); 423 snprintf(test_name, strlen(arg) + 3, "[%s]", arg); 424 opts->test_name = test_name; 425 426 return 0; 427 } 428 429 static int 430 parse_silent(struct cperf_options *opts, 431 const char *arg __rte_unused) 432 { 433 opts->silent = 1; 434 435 return 0; 436 } 437 438 static int 439 parse_cipher_algo(struct cperf_options *opts, const char *arg) 440 { 441 442 enum rte_crypto_cipher_algorithm cipher_algo; 443 444 if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) { 445 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); 446 return -1; 447 } 448 449 opts->cipher_algo = cipher_algo; 450 451 return 0; 452 } 453 454 static int 455 parse_cipher_op(struct cperf_options *opts, const char *arg) 456 { 457 struct name_id_map cipher_op_namemap[] = { 458 { 459 rte_crypto_cipher_operation_strings 460 [RTE_CRYPTO_CIPHER_OP_ENCRYPT], 461 RTE_CRYPTO_CIPHER_OP_ENCRYPT }, 462 { 463 rte_crypto_cipher_operation_strings 464 [RTE_CRYPTO_CIPHER_OP_DECRYPT], 465 RTE_CRYPTO_CIPHER_OP_DECRYPT 466 } 467 }; 468 469 int id = get_str_key_id_mapping(cipher_op_namemap, 470 RTE_DIM(cipher_op_namemap), arg); 471 if (id < 0) { 472 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n"); 473 return -1; 474 } 475 476 opts->cipher_op = (enum rte_crypto_cipher_operation)id; 477 478 return 0; 479 } 480 481 static int 482 parse_cipher_key_sz(struct cperf_options *opts, const char *arg) 483 { 484 return parse_uint16_t(&opts->cipher_key_sz, arg); 485 } 486 487 static int 488 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) 489 { 490 return parse_uint16_t(&opts->cipher_iv_sz, arg); 491 } 492 493 static int 494 parse_auth_algo(struct cperf_options *opts, const char *arg) 495 { 496 enum rte_crypto_auth_algorithm auth_algo; 497 498 if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) { 499 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n"); 500 return -1; 501 } 502 503 opts->auth_algo = auth_algo; 504 505 return 0; 506 } 507 508 static int 509 parse_auth_op(struct cperf_options *opts, const char *arg) 510 { 511 struct name_id_map auth_op_namemap[] = { 512 { 513 rte_crypto_auth_operation_strings 514 [RTE_CRYPTO_AUTH_OP_GENERATE], 515 RTE_CRYPTO_AUTH_OP_GENERATE }, 516 { 517 rte_crypto_auth_operation_strings 518 [RTE_CRYPTO_AUTH_OP_VERIFY], 519 RTE_CRYPTO_AUTH_OP_VERIFY 520 } 521 }; 522 523 int id = get_str_key_id_mapping(auth_op_namemap, 524 RTE_DIM(auth_op_namemap), arg); 525 if (id < 0) { 526 RTE_LOG(ERR, USER1, "invalid authentication operation specified" 527 "\n"); 528 return -1; 529 } 530 531 opts->auth_op = (enum rte_crypto_auth_operation)id; 532 533 return 0; 534 } 535 536 static int 537 parse_auth_key_sz(struct cperf_options *opts, const char *arg) 538 { 539 return parse_uint16_t(&opts->auth_key_sz, arg); 540 } 541 542 static int 543 parse_auth_digest_sz(struct cperf_options *opts, const char *arg) 544 { 545 return parse_uint16_t(&opts->auth_digest_sz, arg); 546 } 547 548 static int 549 parse_auth_aad_sz(struct cperf_options *opts, const char *arg) 550 { 551 return parse_uint16_t(&opts->auth_aad_sz, arg); 552 } 553 554 static int 555 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) 556 { 557 opts->csv = 1; 558 opts->silent = 1; 559 return 0; 560 } 561 562 typedef int (*option_parser_t)(struct cperf_options *opts, 563 const char *arg); 564 565 struct long_opt_parser { 566 const char *lgopt_name; 567 option_parser_t parser_fn; 568 569 }; 570 571 static struct option lgopts[] = { 572 573 { CPERF_PTEST_TYPE, required_argument, 0, 0 }, 574 575 { CPERF_POOL_SIZE, required_argument, 0, 0 }, 576 { CPERF_TOTAL_OPS, required_argument, 0, 0 }, 577 { CPERF_BURST_SIZE, required_argument, 0, 0 }, 578 { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, 579 { CPERF_SEGMENTS_NB, required_argument, 0, 0 }, 580 581 { CPERF_DEVTYPE, required_argument, 0, 0 }, 582 { CPERF_OPTYPE, required_argument, 0, 0 }, 583 584 { CPERF_SILENT, no_argument, 0, 0 }, 585 { CPERF_SESSIONLESS, no_argument, 0, 0 }, 586 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, 587 { CPERF_TEST_FILE, required_argument, 0, 0 }, 588 { CPERF_TEST_NAME, required_argument, 0, 0 }, 589 590 { CPERF_CIPHER_ALGO, required_argument, 0, 0 }, 591 { CPERF_CIPHER_OP, required_argument, 0, 0 }, 592 593 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 }, 594 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 }, 595 596 { CPERF_AUTH_ALGO, required_argument, 0, 0 }, 597 { CPERF_AUTH_OP, required_argument, 0, 0 }, 598 599 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, 600 { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 }, 601 { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 }, 602 { CPERF_CSV, no_argument, 0, 0}, 603 604 { NULL, 0, 0, 0 } 605 }; 606 607 void 608 cperf_options_default(struct cperf_options *opts) 609 { 610 opts->test = CPERF_TEST_TYPE_THROUGHPUT; 611 612 opts->pool_sz = 8192; 613 opts->total_ops = 10000000; 614 615 opts->buffer_size_list[0] = 64; 616 opts->buffer_size_count = 1; 617 opts->max_buffer_size = 64; 618 opts->min_buffer_size = 64; 619 opts->inc_buffer_size = 0; 620 621 opts->burst_size_list[0] = 32; 622 opts->burst_size_count = 1; 623 opts->max_burst_size = 32; 624 opts->min_burst_size = 32; 625 opts->inc_burst_size = 0; 626 627 opts->segments_nb = 1; 628 629 strncpy(opts->device_type, "crypto_aesni_mb", 630 sizeof(opts->device_type)); 631 632 opts->op_type = CPERF_CIPHER_THEN_AUTH; 633 634 opts->silent = 0; 635 opts->test_file = NULL; 636 opts->test_name = NULL; 637 opts->sessionless = 0; 638 opts->out_of_place = 0; 639 opts->csv = 0; 640 641 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC; 642 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 643 opts->cipher_key_sz = 16; 644 opts->cipher_iv_sz = 16; 645 646 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 647 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; 648 649 opts->auth_key_sz = 64; 650 opts->auth_digest_sz = 12; 651 opts->auth_aad_sz = 0; 652 } 653 654 static int 655 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) 656 { 657 struct long_opt_parser parsermap[] = { 658 { CPERF_PTEST_TYPE, parse_cperf_test_type }, 659 { CPERF_SILENT, parse_silent }, 660 { CPERF_POOL_SIZE, parse_pool_sz }, 661 { CPERF_TOTAL_OPS, parse_total_ops }, 662 { CPERF_BURST_SIZE, parse_burst_sz }, 663 { CPERF_BUFFER_SIZE, parse_buffer_sz }, 664 { CPERF_SEGMENTS_NB, parse_segments_nb }, 665 { CPERF_DEVTYPE, parse_device_type }, 666 { CPERF_OPTYPE, parse_op_type }, 667 { CPERF_SESSIONLESS, parse_sessionless }, 668 { CPERF_OUT_OF_PLACE, parse_out_of_place }, 669 { CPERF_TEST_FILE, parse_test_file }, 670 { CPERF_TEST_NAME, parse_test_name }, 671 { CPERF_CIPHER_ALGO, parse_cipher_algo }, 672 { CPERF_CIPHER_OP, parse_cipher_op }, 673 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz }, 674 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz }, 675 { CPERF_AUTH_ALGO, parse_auth_algo }, 676 { CPERF_AUTH_OP, parse_auth_op }, 677 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, 678 { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz }, 679 { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz }, 680 { CPERF_CSV, parse_csv_friendly}, 681 }; 682 unsigned int i; 683 684 for (i = 0; i < RTE_DIM(parsermap); i++) { 685 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name, 686 strlen(lgopts[opt_idx].name)) == 0) 687 return parsermap[i].parser_fn(opts, optarg); 688 } 689 690 return -EINVAL; 691 } 692 693 int 694 cperf_options_parse(struct cperf_options *options, int argc, char **argv) 695 { 696 int opt, retval, opt_idx; 697 698 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) { 699 switch (opt) { 700 /* long options */ 701 case 0: 702 703 retval = cperf_opts_parse_long(opt_idx, options); 704 if (retval != 0) 705 return retval; 706 707 break; 708 709 default: 710 return -EINVAL; 711 } 712 } 713 714 return 0; 715 } 716 717 int 718 cperf_options_check(struct cperf_options *options) 719 { 720 if (options->segments_nb > options->min_buffer_size) { 721 RTE_LOG(ERR, USER1, 722 "Segments number greater than buffer size.\n"); 723 return -EINVAL; 724 } 725 726 if (options->test == CPERF_TEST_TYPE_VERIFY && 727 options->test_file == NULL) { 728 RTE_LOG(ERR, USER1, "Define path to the file with test" 729 " vectors.\n"); 730 return -EINVAL; 731 } 732 733 if (options->test_name != NULL && options->test_file == NULL) { 734 RTE_LOG(ERR, USER1, "Define path to the file with test" 735 " vectors.\n"); 736 return -EINVAL; 737 } 738 739 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY && 740 options->test_file == NULL) { 741 RTE_LOG(ERR, USER1, "Define path to the file with test" 742 " vectors.\n"); 743 return -EINVAL; 744 } 745 746 if (options->test == CPERF_TEST_TYPE_VERIFY && 747 options->total_ops > options->pool_sz) { 748 RTE_LOG(ERR, USER1, "Total number of ops must be less than or" 749 " equal to the pool size.\n"); 750 return -EINVAL; 751 } 752 753 if (options->test == CPERF_TEST_TYPE_VERIFY && 754 (options->inc_buffer_size != 0 || 755 options->buffer_size_count > 1)) { 756 RTE_LOG(ERR, USER1, "Only one buffer size is allowed when " 757 "using the verify test.\n"); 758 return -EINVAL; 759 } 760 761 if (options->test == CPERF_TEST_TYPE_VERIFY && 762 (options->inc_burst_size != 0 || 763 options->burst_size_count > 1)) { 764 RTE_LOG(ERR, USER1, "Only one burst size is allowed when " 765 "using the verify test.\n"); 766 return -EINVAL; 767 } 768 769 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 770 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT && 771 options->auth_op != 772 RTE_CRYPTO_AUTH_OP_GENERATE) { 773 RTE_LOG(ERR, USER1, "Option cipher then auth must use" 774 " options: encrypt and generate.\n"); 775 return -EINVAL; 776 } 777 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) { 778 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT && 779 options->auth_op != 780 RTE_CRYPTO_AUTH_OP_VERIFY) { 781 RTE_LOG(ERR, USER1, "Option auth then cipher must use" 782 " options: decrypt and verify.\n"); 783 return -EINVAL; 784 } 785 } else if (options->op_type == CPERF_AEAD) { 786 if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT && 787 options->auth_op == 788 RTE_CRYPTO_AUTH_OP_GENERATE) && 789 !(options->cipher_op == 790 RTE_CRYPTO_CIPHER_OP_DECRYPT && 791 options->auth_op == 792 RTE_CRYPTO_AUTH_OP_VERIFY)) { 793 RTE_LOG(ERR, USER1, "Use together options: encrypt and" 794 " generate or decrypt and verify.\n"); 795 return -EINVAL; 796 } 797 } 798 799 if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_GCM || 800 options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CCM || 801 options->auth_algo == RTE_CRYPTO_AUTH_AES_GCM || 802 options->auth_algo == RTE_CRYPTO_AUTH_AES_CCM || 803 options->auth_algo == RTE_CRYPTO_AUTH_AES_GMAC) { 804 if (options->op_type != CPERF_AEAD) { 805 RTE_LOG(ERR, USER1, "Use --optype aead\n"); 806 return -EINVAL; 807 } 808 } 809 810 return 0; 811 } 812 813 void 814 cperf_options_dump(struct cperf_options *opts) 815 { 816 uint8_t size_idx; 817 818 printf("# Crypto Performance Application Options:\n"); 819 printf("#\n"); 820 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); 821 printf("#\n"); 822 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); 823 printf("# total number of ops: %u\n", opts->total_ops); 824 if (opts->inc_buffer_size != 0) { 825 printf("# buffer size:\n"); 826 printf("#\t min: %u\n", opts->min_buffer_size); 827 printf("#\t max: %u\n", opts->max_buffer_size); 828 printf("#\t inc: %u\n", opts->inc_buffer_size); 829 } else { 830 printf("# buffer sizes: "); 831 for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++) 832 printf("%u ", opts->buffer_size_list[size_idx]); 833 printf("\n"); 834 } 835 if (opts->inc_burst_size != 0) { 836 printf("# burst size:\n"); 837 printf("#\t min: %u\n", opts->min_burst_size); 838 printf("#\t max: %u\n", opts->max_burst_size); 839 printf("#\t inc: %u\n", opts->inc_burst_size); 840 } else { 841 printf("# burst sizes: "); 842 for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++) 843 printf("%u ", opts->burst_size_list[size_idx]); 844 printf("\n"); 845 } 846 printf("\n# segments per buffer: %u\n", opts->segments_nb); 847 printf("#\n"); 848 printf("# cryptodev type: %s\n", opts->device_type); 849 printf("#\n"); 850 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); 851 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); 852 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); 853 854 printf("#\n"); 855 856 if (opts->op_type == CPERF_AUTH_ONLY || 857 opts->op_type == CPERF_CIPHER_THEN_AUTH || 858 opts->op_type == CPERF_AUTH_THEN_CIPHER || 859 opts->op_type == CPERF_AEAD) { 860 printf("# auth algorithm: %s\n", 861 rte_crypto_auth_algorithm_strings[opts->auth_algo]); 862 printf("# auth operation: %s\n", 863 rte_crypto_auth_operation_strings[opts->auth_op]); 864 printf("# auth key size: %u\n", opts->auth_key_sz); 865 printf("# auth digest size: %u\n", opts->auth_digest_sz); 866 printf("# auth aad size: %u\n", opts->auth_aad_sz); 867 printf("#\n"); 868 } 869 870 if (opts->op_type == CPERF_CIPHER_ONLY || 871 opts->op_type == CPERF_CIPHER_THEN_AUTH || 872 opts->op_type == CPERF_AUTH_THEN_CIPHER || 873 opts->op_type == CPERF_AEAD) { 874 printf("# cipher algorithm: %s\n", 875 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); 876 printf("# cipher operation: %s\n", 877 rte_crypto_cipher_operation_strings[opts->cipher_op]); 878 printf("# cipher key size: %u\n", opts->cipher_key_sz); 879 printf("# cipher iv size: %u\n", opts->cipher_iv_sz); 880 printf("#\n"); 881 } 882 } 883