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 #define AES_BLOCK_SIZE 16 42 #define DES_BLOCK_SIZE 8 43 44 struct name_id_map { 45 const char *name; 46 uint32_t id; 47 }; 48 49 static int 50 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len, 51 const char *str_key) 52 { 53 unsigned int i; 54 55 for (i = 0; i < map_len; i++) { 56 57 if (strcmp(str_key, map[i].name) == 0) 58 return map[i].id; 59 } 60 61 return -1; 62 } 63 64 static int 65 parse_cperf_test_type(struct cperf_options *opts, const char *arg) 66 { 67 struct name_id_map cperftest_namemap[] = { 68 { 69 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT], 70 CPERF_TEST_TYPE_THROUGHPUT 71 }, 72 { 73 cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY], 74 CPERF_TEST_TYPE_VERIFY 75 }, 76 { 77 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], 78 CPERF_TEST_TYPE_LATENCY 79 } 80 }; 81 82 int id = get_str_key_id_mapping( 83 (struct name_id_map *)cperftest_namemap, 84 RTE_DIM(cperftest_namemap), arg); 85 if (id < 0) { 86 RTE_LOG(ERR, USER1, "failed to parse test type"); 87 return -1; 88 } 89 90 opts->test = (enum cperf_perf_test_type)id; 91 92 return 0; 93 } 94 95 static int 96 parse_uint32_t(uint32_t *value, const char *arg) 97 { 98 char *end = NULL; 99 unsigned long n = strtoul(arg, &end, 10); 100 101 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0')) 102 return -1; 103 104 if (n > UINT32_MAX) 105 return -ERANGE; 106 107 *value = (uint32_t) n; 108 109 return 0; 110 } 111 112 static int 113 parse_uint16_t(uint16_t *value, const char *arg) 114 { 115 uint32_t val = 0; 116 int ret = parse_uint32_t(&val, arg); 117 118 if (ret < 0) 119 return ret; 120 121 if (val > UINT16_MAX) 122 return -ERANGE; 123 124 *value = (uint16_t) val; 125 126 return 0; 127 } 128 129 static int 130 parse_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc) 131 { 132 char *token; 133 uint32_t number; 134 135 char *copy_arg = strdup(arg); 136 137 if (copy_arg == NULL) 138 return -1; 139 140 errno = 0; 141 token = strtok(copy_arg, ":"); 142 143 /* Parse minimum value */ 144 if (token != NULL) { 145 number = strtoul(token, NULL, 10); 146 147 if (errno == EINVAL || errno == ERANGE || 148 number == 0) 149 goto err_range; 150 151 *min = number; 152 } else 153 goto err_range; 154 155 token = strtok(NULL, ":"); 156 157 /* Parse increment value */ 158 if (token != NULL) { 159 number = strtoul(token, NULL, 10); 160 161 if (errno == EINVAL || errno == ERANGE || 162 number == 0) 163 goto err_range; 164 165 *inc = number; 166 } else 167 goto err_range; 168 169 token = strtok(NULL, ":"); 170 171 /* Parse maximum value */ 172 if (token != NULL) { 173 number = strtoul(token, NULL, 10); 174 175 if (errno == EINVAL || errno == ERANGE || 176 number == 0 || 177 number < *min) 178 goto err_range; 179 180 *max = number; 181 } else 182 goto err_range; 183 184 if (strtok(NULL, ":") != NULL) 185 goto err_range; 186 187 free(copy_arg); 188 return 0; 189 190 err_range: 191 free(copy_arg); 192 return -1; 193 } 194 195 static int 196 parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max) 197 { 198 char *token; 199 uint32_t number; 200 uint8_t count = 0; 201 202 char *copy_arg = strdup(arg); 203 204 if (copy_arg == NULL) 205 return -1; 206 207 errno = 0; 208 token = strtok(copy_arg, ","); 209 210 /* Parse first value */ 211 if (token != NULL) { 212 number = strtoul(token, NULL, 10); 213 214 if (errno == EINVAL || errno == ERANGE || 215 number == 0) 216 goto err_list; 217 218 list[count++] = number; 219 *min = number; 220 *max = number; 221 } else 222 goto err_list; 223 224 token = strtok(NULL, ","); 225 226 while (token != NULL) { 227 if (count == MAX_LIST) { 228 RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n", 229 MAX_LIST); 230 break; 231 } 232 233 number = strtoul(token, NULL, 10); 234 235 if (errno == EINVAL || errno == ERANGE || 236 number == 0) 237 goto err_list; 238 239 list[count++] = number; 240 241 if (number < *min) 242 *min = number; 243 if (number > *max) 244 *max = number; 245 246 token = strtok(NULL, ","); 247 } 248 249 free(copy_arg); 250 return count; 251 252 err_list: 253 free(copy_arg); 254 return -1; 255 } 256 257 static int 258 parse_total_ops(struct cperf_options *opts, const char *arg) 259 { 260 int ret = parse_uint32_t(&opts->total_ops, arg); 261 262 if (ret) 263 RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); 264 265 if (opts->total_ops == 0) { 266 RTE_LOG(ERR, USER1, 267 "invalid total operations count number specified\n"); 268 return -1; 269 } 270 271 return ret; 272 } 273 274 static int 275 parse_pool_sz(struct cperf_options *opts, const char *arg) 276 { 277 int ret = parse_uint32_t(&opts->pool_sz, arg); 278 279 if (ret) 280 RTE_LOG(ERR, USER1, "failed to parse pool size"); 281 return ret; 282 } 283 284 static int 285 parse_burst_sz(struct cperf_options *opts, const char *arg) 286 { 287 int ret; 288 289 /* Try parsing the argument as a range, if it fails, parse it as a list */ 290 if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size, 291 &opts->inc_burst_size) < 0) { 292 ret = parse_list(arg, opts->burst_size_list, 293 &opts->min_burst_size, 294 &opts->max_burst_size); 295 if (ret < 0) { 296 RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); 297 return -1; 298 } 299 opts->burst_size_count = ret; 300 } 301 302 return 0; 303 } 304 305 static int 306 parse_buffer_sz(struct cperf_options *opts, const char *arg) 307 { 308 int ret; 309 310 /* Try parsing the argument as a range, if it fails, parse it as a list */ 311 if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size, 312 &opts->inc_buffer_size) < 0) { 313 ret = parse_list(arg, opts->buffer_size_list, 314 &opts->min_buffer_size, 315 &opts->max_buffer_size); 316 if (ret < 0) { 317 RTE_LOG(ERR, USER1, "failed to parse buffer size/s\n"); 318 return -1; 319 } 320 opts->buffer_size_count = ret; 321 } 322 323 return 0; 324 } 325 326 static int 327 parse_segments_nb(struct cperf_options *opts, const char *arg) 328 { 329 int ret = parse_uint32_t(&opts->segments_nb, arg); 330 331 if (ret) { 332 RTE_LOG(ERR, USER1, "failed to parse segments number\n"); 333 return -1; 334 } 335 336 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) { 337 RTE_LOG(ERR, USER1, "invalid segments number specified\n"); 338 return -1; 339 } 340 341 return 0; 342 } 343 344 static int 345 parse_desc_nb(struct cperf_options *opts, const char *arg) 346 { 347 int ret = parse_uint32_t(&opts->nb_descriptors, arg); 348 349 if (ret) { 350 RTE_LOG(ERR, USER1, "failed to parse descriptors number\n"); 351 return -1; 352 } 353 354 if (opts->nb_descriptors == 0) { 355 RTE_LOG(ERR, USER1, "invalid descriptors number specified\n"); 356 return -1; 357 } 358 359 return 0; 360 } 361 362 static int 363 parse_device_type(struct cperf_options *opts, const char *arg) 364 { 365 if (strlen(arg) > (sizeof(opts->device_type) - 1)) 366 return -1; 367 368 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1); 369 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0'; 370 371 return 0; 372 } 373 374 static int 375 parse_op_type(struct cperf_options *opts, const char *arg) 376 { 377 struct name_id_map optype_namemap[] = { 378 { 379 cperf_op_type_strs[CPERF_CIPHER_ONLY], 380 CPERF_CIPHER_ONLY 381 }, 382 { 383 cperf_op_type_strs[CPERF_AUTH_ONLY], 384 CPERF_AUTH_ONLY 385 }, 386 { 387 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH], 388 CPERF_CIPHER_THEN_AUTH 389 }, 390 { 391 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER], 392 CPERF_AUTH_THEN_CIPHER 393 }, 394 { 395 cperf_op_type_strs[CPERF_AEAD], 396 CPERF_AEAD 397 } 398 }; 399 400 int id = get_str_key_id_mapping(optype_namemap, 401 RTE_DIM(optype_namemap), arg); 402 if (id < 0) { 403 RTE_LOG(ERR, USER1, "invalid opt type specified\n"); 404 return -1; 405 } 406 407 opts->op_type = (enum cperf_op_type)id; 408 409 return 0; 410 } 411 412 static int 413 parse_sessionless(struct cperf_options *opts, 414 const char *arg __rte_unused) 415 { 416 opts->sessionless = 1; 417 return 0; 418 } 419 420 static int 421 parse_out_of_place(struct cperf_options *opts, 422 const char *arg __rte_unused) 423 { 424 opts->out_of_place = 1; 425 return 0; 426 } 427 428 static int 429 parse_test_file(struct cperf_options *opts, 430 const char *arg) 431 { 432 opts->test_file = strdup(arg); 433 if (access(opts->test_file, F_OK) != -1) 434 return 0; 435 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n"); 436 437 return -1; 438 } 439 440 static int 441 parse_test_name(struct cperf_options *opts, 442 const char *arg) 443 { 444 char *test_name = (char *) rte_zmalloc(NULL, 445 sizeof(char) * (strlen(arg) + 3), 0); 446 snprintf(test_name, strlen(arg) + 3, "[%s]", arg); 447 opts->test_name = test_name; 448 449 return 0; 450 } 451 452 static int 453 parse_silent(struct cperf_options *opts, 454 const char *arg __rte_unused) 455 { 456 opts->silent = 1; 457 458 return 0; 459 } 460 461 static int 462 parse_cipher_algo(struct cperf_options *opts, const char *arg) 463 { 464 465 enum rte_crypto_cipher_algorithm cipher_algo; 466 467 if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) { 468 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); 469 return -1; 470 } 471 472 opts->cipher_algo = cipher_algo; 473 474 return 0; 475 } 476 477 static int 478 parse_cipher_op(struct cperf_options *opts, const char *arg) 479 { 480 struct name_id_map cipher_op_namemap[] = { 481 { 482 rte_crypto_cipher_operation_strings 483 [RTE_CRYPTO_CIPHER_OP_ENCRYPT], 484 RTE_CRYPTO_CIPHER_OP_ENCRYPT }, 485 { 486 rte_crypto_cipher_operation_strings 487 [RTE_CRYPTO_CIPHER_OP_DECRYPT], 488 RTE_CRYPTO_CIPHER_OP_DECRYPT 489 } 490 }; 491 492 int id = get_str_key_id_mapping(cipher_op_namemap, 493 RTE_DIM(cipher_op_namemap), arg); 494 if (id < 0) { 495 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n"); 496 return -1; 497 } 498 499 opts->cipher_op = (enum rte_crypto_cipher_operation)id; 500 501 return 0; 502 } 503 504 static int 505 parse_cipher_key_sz(struct cperf_options *opts, const char *arg) 506 { 507 return parse_uint16_t(&opts->cipher_key_sz, arg); 508 } 509 510 static int 511 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) 512 { 513 return parse_uint16_t(&opts->cipher_iv_sz, arg); 514 } 515 516 static int 517 parse_auth_algo(struct cperf_options *opts, const char *arg) 518 { 519 enum rte_crypto_auth_algorithm auth_algo; 520 521 if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) { 522 RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n"); 523 return -1; 524 } 525 526 opts->auth_algo = auth_algo; 527 528 return 0; 529 } 530 531 static int 532 parse_auth_op(struct cperf_options *opts, const char *arg) 533 { 534 struct name_id_map auth_op_namemap[] = { 535 { 536 rte_crypto_auth_operation_strings 537 [RTE_CRYPTO_AUTH_OP_GENERATE], 538 RTE_CRYPTO_AUTH_OP_GENERATE }, 539 { 540 rte_crypto_auth_operation_strings 541 [RTE_CRYPTO_AUTH_OP_VERIFY], 542 RTE_CRYPTO_AUTH_OP_VERIFY 543 } 544 }; 545 546 int id = get_str_key_id_mapping(auth_op_namemap, 547 RTE_DIM(auth_op_namemap), arg); 548 if (id < 0) { 549 RTE_LOG(ERR, USER1, "invalid authentication operation specified" 550 "\n"); 551 return -1; 552 } 553 554 opts->auth_op = (enum rte_crypto_auth_operation)id; 555 556 return 0; 557 } 558 559 static int 560 parse_auth_key_sz(struct cperf_options *opts, const char *arg) 561 { 562 return parse_uint16_t(&opts->auth_key_sz, arg); 563 } 564 565 static int 566 parse_digest_sz(struct cperf_options *opts, const char *arg) 567 { 568 return parse_uint16_t(&opts->digest_sz, arg); 569 } 570 571 static int 572 parse_auth_iv_sz(struct cperf_options *opts, const char *arg) 573 { 574 return parse_uint16_t(&opts->auth_iv_sz, arg); 575 } 576 577 static int 578 parse_aead_algo(struct cperf_options *opts, const char *arg) 579 { 580 enum rte_crypto_aead_algorithm aead_algo; 581 582 if (rte_cryptodev_get_aead_algo_enum(&aead_algo, arg) < 0) { 583 RTE_LOG(ERR, USER1, "Invalid AEAD algorithm specified\n"); 584 return -1; 585 } 586 587 opts->aead_algo = aead_algo; 588 589 return 0; 590 } 591 592 static int 593 parse_aead_op(struct cperf_options *opts, const char *arg) 594 { 595 struct name_id_map aead_op_namemap[] = { 596 { 597 rte_crypto_aead_operation_strings 598 [RTE_CRYPTO_AEAD_OP_ENCRYPT], 599 RTE_CRYPTO_AEAD_OP_ENCRYPT }, 600 { 601 rte_crypto_aead_operation_strings 602 [RTE_CRYPTO_AEAD_OP_DECRYPT], 603 RTE_CRYPTO_AEAD_OP_DECRYPT 604 } 605 }; 606 607 int id = get_str_key_id_mapping(aead_op_namemap, 608 RTE_DIM(aead_op_namemap), arg); 609 if (id < 0) { 610 RTE_LOG(ERR, USER1, "invalid AEAD operation specified" 611 "\n"); 612 return -1; 613 } 614 615 opts->aead_op = (enum rte_crypto_aead_operation)id; 616 617 return 0; 618 } 619 620 static int 621 parse_aead_key_sz(struct cperf_options *opts, const char *arg) 622 { 623 return parse_uint16_t(&opts->aead_key_sz, arg); 624 } 625 626 static int 627 parse_aead_iv_sz(struct cperf_options *opts, const char *arg) 628 { 629 return parse_uint16_t(&opts->aead_iv_sz, arg); 630 } 631 632 static int 633 parse_aead_aad_sz(struct cperf_options *opts, const char *arg) 634 { 635 return parse_uint16_t(&opts->aead_aad_sz, arg); 636 } 637 638 static int 639 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) 640 { 641 opts->csv = 1; 642 opts->silent = 1; 643 return 0; 644 } 645 646 typedef int (*option_parser_t)(struct cperf_options *opts, 647 const char *arg); 648 649 struct long_opt_parser { 650 const char *lgopt_name; 651 option_parser_t parser_fn; 652 653 }; 654 655 static struct option lgopts[] = { 656 657 { CPERF_PTEST_TYPE, required_argument, 0, 0 }, 658 659 { CPERF_POOL_SIZE, required_argument, 0, 0 }, 660 { CPERF_TOTAL_OPS, required_argument, 0, 0 }, 661 { CPERF_BURST_SIZE, required_argument, 0, 0 }, 662 { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, 663 { CPERF_SEGMENTS_NB, required_argument, 0, 0 }, 664 { CPERF_DESC_NB, required_argument, 0, 0 }, 665 666 { CPERF_DEVTYPE, required_argument, 0, 0 }, 667 { CPERF_OPTYPE, required_argument, 0, 0 }, 668 669 { CPERF_SILENT, no_argument, 0, 0 }, 670 { CPERF_SESSIONLESS, no_argument, 0, 0 }, 671 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, 672 { CPERF_TEST_FILE, required_argument, 0, 0 }, 673 { CPERF_TEST_NAME, required_argument, 0, 0 }, 674 675 { CPERF_CIPHER_ALGO, required_argument, 0, 0 }, 676 { CPERF_CIPHER_OP, required_argument, 0, 0 }, 677 678 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 }, 679 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 }, 680 681 { CPERF_AUTH_ALGO, required_argument, 0, 0 }, 682 { CPERF_AUTH_OP, required_argument, 0, 0 }, 683 684 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, 685 { CPERF_AUTH_IV_SZ, required_argument, 0, 0 }, 686 687 { CPERF_AEAD_ALGO, required_argument, 0, 0 }, 688 { CPERF_AEAD_OP, required_argument, 0, 0 }, 689 690 { CPERF_AEAD_KEY_SZ, required_argument, 0, 0 }, 691 { CPERF_AEAD_AAD_SZ, required_argument, 0, 0 }, 692 { CPERF_AEAD_IV_SZ, required_argument, 0, 0 }, 693 694 { CPERF_DIGEST_SZ, required_argument, 0, 0 }, 695 696 { CPERF_CSV, no_argument, 0, 0}, 697 698 { NULL, 0, 0, 0 } 699 }; 700 701 void 702 cperf_options_default(struct cperf_options *opts) 703 { 704 opts->test = CPERF_TEST_TYPE_THROUGHPUT; 705 706 opts->pool_sz = 8192; 707 opts->total_ops = 10000000; 708 opts->nb_descriptors = 2048; 709 710 opts->buffer_size_list[0] = 64; 711 opts->buffer_size_count = 1; 712 opts->max_buffer_size = 64; 713 opts->min_buffer_size = 64; 714 opts->inc_buffer_size = 0; 715 716 opts->burst_size_list[0] = 32; 717 opts->burst_size_count = 1; 718 opts->max_burst_size = 32; 719 opts->min_burst_size = 32; 720 opts->inc_burst_size = 0; 721 722 opts->segments_nb = 1; 723 724 strncpy(opts->device_type, "crypto_aesni_mb", 725 sizeof(opts->device_type)); 726 727 opts->op_type = CPERF_CIPHER_THEN_AUTH; 728 729 opts->silent = 0; 730 opts->test_file = NULL; 731 opts->test_name = NULL; 732 opts->sessionless = 0; 733 opts->out_of_place = 0; 734 opts->csv = 0; 735 736 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC; 737 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 738 opts->cipher_key_sz = 16; 739 opts->cipher_iv_sz = 16; 740 741 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 742 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; 743 744 opts->auth_key_sz = 64; 745 opts->auth_iv_sz = 0; 746 747 opts->aead_key_sz = 0; 748 opts->aead_iv_sz = 0; 749 opts->aead_aad_sz = 0; 750 751 opts->digest_sz = 12; 752 } 753 754 static int 755 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) 756 { 757 struct long_opt_parser parsermap[] = { 758 { CPERF_PTEST_TYPE, parse_cperf_test_type }, 759 { CPERF_SILENT, parse_silent }, 760 { CPERF_POOL_SIZE, parse_pool_sz }, 761 { CPERF_TOTAL_OPS, parse_total_ops }, 762 { CPERF_BURST_SIZE, parse_burst_sz }, 763 { CPERF_BUFFER_SIZE, parse_buffer_sz }, 764 { CPERF_SEGMENTS_NB, parse_segments_nb }, 765 { CPERF_DESC_NB, parse_desc_nb }, 766 { CPERF_DEVTYPE, parse_device_type }, 767 { CPERF_OPTYPE, parse_op_type }, 768 { CPERF_SESSIONLESS, parse_sessionless }, 769 { CPERF_OUT_OF_PLACE, parse_out_of_place }, 770 { CPERF_TEST_FILE, parse_test_file }, 771 { CPERF_TEST_NAME, parse_test_name }, 772 { CPERF_CIPHER_ALGO, parse_cipher_algo }, 773 { CPERF_CIPHER_OP, parse_cipher_op }, 774 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz }, 775 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz }, 776 { CPERF_AUTH_ALGO, parse_auth_algo }, 777 { CPERF_AUTH_OP, parse_auth_op }, 778 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, 779 { CPERF_AUTH_IV_SZ, parse_auth_iv_sz }, 780 { CPERF_AEAD_ALGO, parse_aead_algo }, 781 { CPERF_AEAD_OP, parse_aead_op }, 782 { CPERF_AEAD_KEY_SZ, parse_aead_key_sz }, 783 { CPERF_AEAD_IV_SZ, parse_aead_iv_sz }, 784 { CPERF_AEAD_AAD_SZ, parse_aead_aad_sz }, 785 { CPERF_DIGEST_SZ, parse_digest_sz }, 786 { CPERF_CSV, parse_csv_friendly}, 787 }; 788 unsigned int i; 789 790 for (i = 0; i < RTE_DIM(parsermap); i++) { 791 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name, 792 strlen(lgopts[opt_idx].name)) == 0) 793 return parsermap[i].parser_fn(opts, optarg); 794 } 795 796 return -EINVAL; 797 } 798 799 int 800 cperf_options_parse(struct cperf_options *options, int argc, char **argv) 801 { 802 int opt, retval, opt_idx; 803 804 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) { 805 switch (opt) { 806 /* long options */ 807 case 0: 808 809 retval = cperf_opts_parse_long(opt_idx, options); 810 if (retval != 0) 811 return retval; 812 813 break; 814 815 default: 816 return -EINVAL; 817 } 818 } 819 820 return 0; 821 } 822 823 static int 824 check_cipher_buffer_length(struct cperf_options *options) 825 { 826 uint32_t buffer_size, buffer_size_idx = 0; 827 828 if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC || 829 options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) { 830 if (options->inc_buffer_size != 0) 831 buffer_size = options->min_buffer_size; 832 else 833 buffer_size = options->buffer_size_list[0]; 834 835 while (buffer_size <= options->max_buffer_size) { 836 if ((buffer_size % AES_BLOCK_SIZE) != 0) { 837 RTE_LOG(ERR, USER1, "Some of the buffer sizes are " 838 "not suitable for the algorithm selected\n"); 839 return -EINVAL; 840 } 841 842 if (options->inc_buffer_size != 0) 843 buffer_size += options->inc_buffer_size; 844 else { 845 if (++buffer_size_idx == options->buffer_size_count) 846 break; 847 buffer_size = options->buffer_size_list[buffer_size_idx]; 848 } 849 850 } 851 } 852 853 if (options->cipher_algo == RTE_CRYPTO_CIPHER_DES_CBC || 854 options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_CBC || 855 options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_ECB) { 856 for (buffer_size = options->min_buffer_size; 857 buffer_size < options->max_buffer_size; 858 buffer_size += options->inc_buffer_size) { 859 if ((buffer_size % DES_BLOCK_SIZE) != 0) { 860 RTE_LOG(ERR, USER1, "Some of the buffer sizes are " 861 "not suitable for the algorithm selected\n"); 862 return -EINVAL; 863 } 864 } 865 } 866 867 return 0; 868 } 869 870 int 871 cperf_options_check(struct cperf_options *options) 872 { 873 if (options->segments_nb > options->min_buffer_size) { 874 RTE_LOG(ERR, USER1, 875 "Segments number greater than buffer size.\n"); 876 return -EINVAL; 877 } 878 879 if (options->test == CPERF_TEST_TYPE_VERIFY && 880 options->test_file == NULL) { 881 RTE_LOG(ERR, USER1, "Define path to the file with test" 882 " vectors.\n"); 883 return -EINVAL; 884 } 885 886 if (options->test == CPERF_TEST_TYPE_VERIFY && 887 options->op_type != CPERF_CIPHER_ONLY && 888 options->test_name == NULL) { 889 RTE_LOG(ERR, USER1, "Define test name to get the correct digest" 890 " from the test vectors.\n"); 891 return -EINVAL; 892 } 893 894 if (options->test_name != NULL && options->test_file == NULL) { 895 RTE_LOG(ERR, USER1, "Define path to the file with test" 896 " vectors.\n"); 897 return -EINVAL; 898 } 899 900 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY && 901 options->test_file == NULL) { 902 RTE_LOG(ERR, USER1, "Define path to the file with test" 903 " vectors.\n"); 904 return -EINVAL; 905 } 906 907 if (options->test == CPERF_TEST_TYPE_VERIFY && 908 options->total_ops > options->pool_sz) { 909 RTE_LOG(ERR, USER1, "Total number of ops must be less than or" 910 " equal to the pool size.\n"); 911 return -EINVAL; 912 } 913 914 if (options->test == CPERF_TEST_TYPE_VERIFY && 915 (options->inc_buffer_size != 0 || 916 options->buffer_size_count > 1)) { 917 RTE_LOG(ERR, USER1, "Only one buffer size is allowed when " 918 "using the verify test.\n"); 919 return -EINVAL; 920 } 921 922 if (options->test == CPERF_TEST_TYPE_VERIFY && 923 (options->inc_burst_size != 0 || 924 options->burst_size_count > 1)) { 925 RTE_LOG(ERR, USER1, "Only one burst size is allowed when " 926 "using the verify test.\n"); 927 return -EINVAL; 928 } 929 930 if (options->op_type == CPERF_CIPHER_THEN_AUTH) { 931 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT && 932 options->auth_op != 933 RTE_CRYPTO_AUTH_OP_GENERATE) { 934 RTE_LOG(ERR, USER1, "Option cipher then auth must use" 935 " options: encrypt and generate.\n"); 936 return -EINVAL; 937 } 938 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) { 939 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT && 940 options->auth_op != 941 RTE_CRYPTO_AUTH_OP_VERIFY) { 942 RTE_LOG(ERR, USER1, "Option auth then cipher must use" 943 " options: decrypt and verify.\n"); 944 return -EINVAL; 945 } 946 } 947 948 if (options->op_type == CPERF_CIPHER_ONLY || 949 options->op_type == CPERF_CIPHER_THEN_AUTH || 950 options->op_type == CPERF_AUTH_THEN_CIPHER) { 951 if (check_cipher_buffer_length(options) < 0) 952 return -EINVAL; 953 } 954 955 return 0; 956 } 957 958 void 959 cperf_options_dump(struct cperf_options *opts) 960 { 961 uint8_t size_idx; 962 963 printf("# Crypto Performance Application Options:\n"); 964 printf("#\n"); 965 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); 966 printf("#\n"); 967 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); 968 printf("# total number of ops: %u\n", opts->total_ops); 969 if (opts->inc_buffer_size != 0) { 970 printf("# buffer size:\n"); 971 printf("#\t min: %u\n", opts->min_buffer_size); 972 printf("#\t max: %u\n", opts->max_buffer_size); 973 printf("#\t inc: %u\n", opts->inc_buffer_size); 974 } else { 975 printf("# buffer sizes: "); 976 for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++) 977 printf("%u ", opts->buffer_size_list[size_idx]); 978 printf("\n"); 979 } 980 if (opts->inc_burst_size != 0) { 981 printf("# burst size:\n"); 982 printf("#\t min: %u\n", opts->min_burst_size); 983 printf("#\t max: %u\n", opts->max_burst_size); 984 printf("#\t inc: %u\n", opts->inc_burst_size); 985 } else { 986 printf("# burst sizes: "); 987 for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++) 988 printf("%u ", opts->burst_size_list[size_idx]); 989 printf("\n"); 990 } 991 printf("\n# segments per buffer: %u\n", opts->segments_nb); 992 printf("#\n"); 993 printf("# cryptodev type: %s\n", opts->device_type); 994 printf("#\n"); 995 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); 996 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); 997 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); 998 999 printf("#\n"); 1000 1001 if (opts->op_type == CPERF_AUTH_ONLY || 1002 opts->op_type == CPERF_CIPHER_THEN_AUTH || 1003 opts->op_type == CPERF_AUTH_THEN_CIPHER) { 1004 printf("# auth algorithm: %s\n", 1005 rte_crypto_auth_algorithm_strings[opts->auth_algo]); 1006 printf("# auth operation: %s\n", 1007 rte_crypto_auth_operation_strings[opts->auth_op]); 1008 printf("# auth key size: %u\n", opts->auth_key_sz); 1009 printf("# auth iv size: %u\n", opts->auth_iv_sz); 1010 printf("# auth digest size: %u\n", opts->digest_sz); 1011 printf("#\n"); 1012 } 1013 1014 if (opts->op_type == CPERF_CIPHER_ONLY || 1015 opts->op_type == CPERF_CIPHER_THEN_AUTH || 1016 opts->op_type == CPERF_AUTH_THEN_CIPHER) { 1017 printf("# cipher algorithm: %s\n", 1018 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); 1019 printf("# cipher operation: %s\n", 1020 rte_crypto_cipher_operation_strings[opts->cipher_op]); 1021 printf("# cipher key size: %u\n", opts->cipher_key_sz); 1022 printf("# cipher iv size: %u\n", opts->cipher_iv_sz); 1023 printf("#\n"); 1024 } 1025 1026 if (opts->op_type == CPERF_AEAD) { 1027 printf("# aead algorithm: %s\n", 1028 rte_crypto_aead_algorithm_strings[opts->aead_algo]); 1029 printf("# aead operation: %s\n", 1030 rte_crypto_aead_operation_strings[opts->aead_op]); 1031 printf("# aead key size: %u\n", opts->aead_key_sz); 1032 printf("# aead iv size: %u\n", opts->aead_iv_sz); 1033 printf("# aead digest size: %u\n", opts->digest_sz); 1034 printf("# aead aad size: %u\n", opts->aead_aad_sz); 1035 printf("#\n"); 1036 } 1037 } 1038