4 * Copyright(c) 2016-2017 Intel Corporation. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
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
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.
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.
36 #include <rte_malloc.h>
38 #include "cperf_options.h"
46 get_str_key_id_mapping(struct name_id_map *map, unsigned int map_len,
51 for (i = 0; i < map_len; i++) {
53 if (strcmp(str_key, map[i].name) == 0)
61 parse_cperf_test_type(struct cperf_options *opts, const char *arg)
63 struct name_id_map cperftest_namemap[] = {
65 cperf_test_type_strs[CPERF_TEST_TYPE_THROUGHPUT],
66 CPERF_TEST_TYPE_THROUGHPUT
69 cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT],
70 CPERF_TEST_TYPE_CYCLECOUNT
73 cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY],
74 CPERF_TEST_TYPE_LATENCY
78 int id = get_str_key_id_mapping(
79 (struct name_id_map *)cperftest_namemap,
80 RTE_DIM(cperftest_namemap), arg);
82 RTE_LOG(ERR, USER1, "failed to parse test type");
86 opts->test = (enum cperf_perf_test_type)id;
92 parse_uint32_t(uint32_t *value, const char *arg)
95 unsigned long n = strtoul(arg, &end, 10);
97 if ((optarg[0] == '\0') || (end == NULL) || (*end != '\0'))
103 *value = (uint32_t) n;
109 parse_uint16_t(uint16_t *value, const char *arg)
112 int ret = parse_uint32_t(&val, arg);
117 if (val > UINT16_MAX)
120 *value = (uint16_t) val;
126 parse_total_ops(struct cperf_options *opts, const char *arg)
128 int ret = parse_uint32_t(&opts->total_ops, arg);
131 RTE_LOG(ERR, USER1, "failed to parse total operations count\n");
133 if (opts->total_ops == 0) {
135 "invalid total operations count number specified\n");
143 parse_pool_sz(struct cperf_options *opts, const char *arg)
145 int ret = parse_uint32_t(&opts->pool_sz, arg);
148 RTE_LOG(ERR, USER1, "failed to parse pool size");
153 parse_burst_sz(struct cperf_options *opts, const char *arg)
155 int ret = parse_uint32_t(&opts->burst_sz, arg);
158 RTE_LOG(ERR, USER1, "failed to parse burst size");
163 parse_buffer_sz(struct cperf_options *opts, const char *arg)
165 uint32_t i, valid_buf_sz[] = {
166 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792,
170 if (parse_uint32_t(&opts->buffer_sz, arg)) {
171 RTE_LOG(ERR, USER1, "failed to parse buffer size");
175 for (i = 0; i < RTE_DIM(valid_buf_sz); i++)
176 if (valid_buf_sz[i] == opts->buffer_sz)
179 RTE_LOG(ERR, USER1, "invalid buffer size specified");
184 parse_segments_nb(struct cperf_options *opts, const char *arg)
186 int ret = parse_uint32_t(&opts->segments_nb, arg);
189 RTE_LOG(ERR, USER1, "failed to parse segments number\n");
193 if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) {
194 RTE_LOG(ERR, USER1, "invalid segments number specified\n");
202 parse_device_type(struct cperf_options *opts, const char *arg)
204 if (strlen(arg) > (sizeof(opts->device_type) - 1))
207 strncpy(opts->device_type, arg, sizeof(opts->device_type) - 1);
208 *(opts->device_type + sizeof(opts->device_type) - 1) = '\0';
214 parse_op_type(struct cperf_options *opts, const char *arg)
216 struct name_id_map optype_namemap[] = {
218 cperf_op_type_strs[CPERF_CIPHER_ONLY],
222 cperf_op_type_strs[CPERF_AUTH_ONLY],
226 cperf_op_type_strs[CPERF_CIPHER_THEN_AUTH],
227 CPERF_CIPHER_THEN_AUTH
230 cperf_op_type_strs[CPERF_AUTH_THEN_CIPHER],
231 CPERF_AUTH_THEN_CIPHER
234 cperf_op_type_strs[CPERF_AEAD],
239 int id = get_str_key_id_mapping(optype_namemap,
240 RTE_DIM(optype_namemap), arg);
242 RTE_LOG(ERR, USER1, "invalid opt type specified\n");
246 opts->op_type = (enum cperf_op_type)id;
252 parse_sessionless(struct cperf_options *opts,
253 const char *arg __rte_unused)
255 opts->sessionless = 1;
260 parse_out_of_place(struct cperf_options *opts,
261 const char *arg __rte_unused)
263 opts->out_of_place = 1;
268 parse_verify(struct cperf_options *opts,
269 const char *arg __rte_unused)
277 parse_test_file(struct cperf_options *opts,
280 opts->test_file = strdup(arg);
281 if (access(opts->test_file, F_OK) != -1)
283 RTE_LOG(ERR, USER1, "Test vector file doesn't exist\n");
289 parse_test_name(struct cperf_options *opts,
292 char *test_name = (char *) rte_zmalloc(NULL,
293 sizeof(char) * (strlen(arg) + 3), 0);
294 snprintf(test_name, strlen(arg) + 3, "[%s]", arg);
295 opts->test_name = test_name;
301 parse_silent(struct cperf_options *opts,
302 const char *arg __rte_unused)
310 parse_cipher_algo(struct cperf_options *opts, const char *arg)
312 struct name_id_map cipher_algo_namemap[] = {
314 rte_crypto_cipher_algorithm_strings
315 [RTE_CRYPTO_CIPHER_3DES_CBC],
316 RTE_CRYPTO_CIPHER_3DES_CBC
319 rte_crypto_cipher_algorithm_strings
320 [RTE_CRYPTO_CIPHER_3DES_ECB],
321 RTE_CRYPTO_CIPHER_3DES_ECB
324 rte_crypto_cipher_algorithm_strings
325 [RTE_CRYPTO_CIPHER_3DES_CTR],
326 RTE_CRYPTO_CIPHER_3DES_CTR
329 rte_crypto_cipher_algorithm_strings
330 [RTE_CRYPTO_CIPHER_AES_CBC],
331 RTE_CRYPTO_CIPHER_AES_CBC
334 rte_crypto_cipher_algorithm_strings
335 [RTE_CRYPTO_CIPHER_AES_CCM],
336 RTE_CRYPTO_CIPHER_AES_CCM
339 rte_crypto_cipher_algorithm_strings
340 [RTE_CRYPTO_CIPHER_AES_CTR],
341 RTE_CRYPTO_CIPHER_AES_CTR
344 rte_crypto_cipher_algorithm_strings
345 [RTE_CRYPTO_CIPHER_AES_ECB],
346 RTE_CRYPTO_CIPHER_AES_ECB
349 rte_crypto_cipher_algorithm_strings
350 [RTE_CRYPTO_CIPHER_AES_GCM],
351 RTE_CRYPTO_CIPHER_AES_GCM
354 rte_crypto_cipher_algorithm_strings
355 [RTE_CRYPTO_CIPHER_AES_F8],
356 RTE_CRYPTO_CIPHER_AES_F8
359 rte_crypto_cipher_algorithm_strings
360 [RTE_CRYPTO_CIPHER_AES_XTS],
361 RTE_CRYPTO_CIPHER_AES_XTS
364 rte_crypto_cipher_algorithm_strings
365 [RTE_CRYPTO_CIPHER_ARC4],
366 RTE_CRYPTO_CIPHER_ARC4
369 rte_crypto_cipher_algorithm_strings
370 [RTE_CRYPTO_CIPHER_NULL],
371 RTE_CRYPTO_CIPHER_NULL
374 rte_crypto_cipher_algorithm_strings
375 [RTE_CRYPTO_CIPHER_KASUMI_F8],
376 RTE_CRYPTO_CIPHER_KASUMI_F8
379 rte_crypto_cipher_algorithm_strings
380 [RTE_CRYPTO_CIPHER_SNOW3G_UEA2],
381 RTE_CRYPTO_CIPHER_SNOW3G_UEA2
384 rte_crypto_cipher_algorithm_strings
385 [RTE_CRYPTO_CIPHER_ZUC_EEA3],
386 RTE_CRYPTO_CIPHER_ZUC_EEA3
391 int id = get_str_key_id_mapping(cipher_algo_namemap,
392 RTE_DIM(cipher_algo_namemap), arg);
394 RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n");
398 opts->cipher_algo = (enum rte_crypto_cipher_algorithm)id;
404 parse_cipher_op(struct cperf_options *opts, const char *arg)
406 struct name_id_map cipher_op_namemap[] = {
408 rte_crypto_cipher_operation_strings
409 [RTE_CRYPTO_CIPHER_OP_ENCRYPT],
410 RTE_CRYPTO_CIPHER_OP_ENCRYPT },
412 rte_crypto_cipher_operation_strings
413 [RTE_CRYPTO_CIPHER_OP_DECRYPT],
414 RTE_CRYPTO_CIPHER_OP_DECRYPT
418 int id = get_str_key_id_mapping(cipher_op_namemap,
419 RTE_DIM(cipher_op_namemap), arg);
421 RTE_LOG(ERR, USER1, "Invalid cipher operation specified\n");
425 opts->cipher_op = (enum rte_crypto_cipher_operation)id;
431 parse_cipher_key_sz(struct cperf_options *opts, const char *arg)
433 return parse_uint16_t(&opts->cipher_key_sz, arg);
437 parse_cipher_iv_sz(struct cperf_options *opts, const char *arg)
439 return parse_uint16_t(&opts->cipher_iv_sz, arg);
443 parse_auth_algo(struct cperf_options *opts, const char *arg) {
444 struct name_id_map cipher_auth_namemap[] = {
446 rte_crypto_auth_algorithm_strings
447 [RTE_CRYPTO_AUTH_AES_CBC_MAC],
448 RTE_CRYPTO_AUTH_AES_CBC_MAC
451 rte_crypto_auth_algorithm_strings
452 [RTE_CRYPTO_AUTH_AES_CCM],
453 RTE_CRYPTO_AUTH_AES_CCM
456 rte_crypto_auth_algorithm_strings
457 [RTE_CRYPTO_AUTH_AES_CMAC],
458 RTE_CRYPTO_AUTH_AES_CMAC
461 rte_crypto_auth_algorithm_strings
462 [RTE_CRYPTO_AUTH_AES_GCM],
463 RTE_CRYPTO_AUTH_AES_GCM
466 rte_crypto_auth_algorithm_strings
467 [RTE_CRYPTO_AUTH_AES_GMAC],
468 RTE_CRYPTO_AUTH_AES_GMAC
471 rte_crypto_auth_algorithm_strings
472 [RTE_CRYPTO_AUTH_AES_XCBC_MAC],
473 RTE_CRYPTO_AUTH_AES_XCBC_MAC
476 rte_crypto_auth_algorithm_strings
477 [RTE_CRYPTO_AUTH_MD5],
481 rte_crypto_auth_algorithm_strings
482 [RTE_CRYPTO_AUTH_MD5_HMAC],
483 RTE_CRYPTO_AUTH_MD5_HMAC
486 rte_crypto_auth_algorithm_strings
487 [RTE_CRYPTO_AUTH_SHA1],
491 rte_crypto_auth_algorithm_strings
492 [RTE_CRYPTO_AUTH_SHA1_HMAC],
493 RTE_CRYPTO_AUTH_SHA1_HMAC
496 rte_crypto_auth_algorithm_strings
497 [RTE_CRYPTO_AUTH_SHA224],
498 RTE_CRYPTO_AUTH_SHA224
501 rte_crypto_auth_algorithm_strings
502 [RTE_CRYPTO_AUTH_SHA224_HMAC],
503 RTE_CRYPTO_AUTH_SHA224_HMAC
506 rte_crypto_auth_algorithm_strings
507 [RTE_CRYPTO_AUTH_SHA256],
508 RTE_CRYPTO_AUTH_SHA256
511 rte_crypto_auth_algorithm_strings
512 [RTE_CRYPTO_AUTH_SHA256_HMAC],
513 RTE_CRYPTO_AUTH_SHA256_HMAC
516 rte_crypto_auth_algorithm_strings
517 [RTE_CRYPTO_AUTH_SHA384],
518 RTE_CRYPTO_AUTH_SHA384
521 rte_crypto_auth_algorithm_strings
522 [RTE_CRYPTO_AUTH_SHA384_HMAC],
523 RTE_CRYPTO_AUTH_SHA384_HMAC
526 rte_crypto_auth_algorithm_strings
527 [RTE_CRYPTO_AUTH_SHA512],
528 RTE_CRYPTO_AUTH_SHA512
531 rte_crypto_auth_algorithm_strings
532 [RTE_CRYPTO_AUTH_SHA512_HMAC],
533 RTE_CRYPTO_AUTH_SHA512_HMAC
536 rte_crypto_auth_algorithm_strings
537 [RTE_CRYPTO_AUTH_KASUMI_F9],
538 RTE_CRYPTO_AUTH_KASUMI_F9
541 rte_crypto_auth_algorithm_strings
542 [RTE_CRYPTO_AUTH_SNOW3G_UIA2],
543 RTE_CRYPTO_AUTH_SNOW3G_UIA2
546 rte_crypto_auth_algorithm_strings
547 [RTE_CRYPTO_AUTH_ZUC_EIA3],
548 RTE_CRYPTO_AUTH_ZUC_EIA3
553 int id = get_str_key_id_mapping(cipher_auth_namemap,
554 RTE_DIM(cipher_auth_namemap), arg);
556 RTE_LOG(ERR, USER1, "invalid authentication algorithm specified"
561 opts->auth_algo = (enum rte_crypto_auth_algorithm)id;
567 parse_auth_op(struct cperf_options *opts, const char *arg)
569 struct name_id_map auth_op_namemap[] = {
571 rte_crypto_auth_operation_strings
572 [RTE_CRYPTO_AUTH_OP_GENERATE],
573 RTE_CRYPTO_AUTH_OP_GENERATE },
575 rte_crypto_auth_operation_strings
576 [RTE_CRYPTO_AUTH_OP_VERIFY],
577 RTE_CRYPTO_AUTH_OP_VERIFY
581 int id = get_str_key_id_mapping(auth_op_namemap,
582 RTE_DIM(auth_op_namemap), arg);
584 RTE_LOG(ERR, USER1, "invalid authentication operation specified"
589 opts->auth_op = (enum rte_crypto_auth_operation)id;
595 parse_auth_key_sz(struct cperf_options *opts, const char *arg)
597 return parse_uint16_t(&opts->auth_key_sz, arg);
601 parse_auth_digest_sz(struct cperf_options *opts, const char *arg)
603 return parse_uint16_t(&opts->auth_digest_sz, arg);
607 parse_auth_aad_sz(struct cperf_options *opts, const char *arg)
609 return parse_uint16_t(&opts->auth_aad_sz, arg);
613 parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused)
620 typedef int (*option_parser_t)(struct cperf_options *opts,
623 struct long_opt_parser {
624 const char *lgopt_name;
625 option_parser_t parser_fn;
629 static struct option lgopts[] = {
631 { CPERF_PTEST_TYPE, required_argument, 0, 0 },
633 { CPERF_POOL_SIZE, required_argument, 0, 0 },
634 { CPERF_TOTAL_OPS, required_argument, 0, 0 },
635 { CPERF_BURST_SIZE, required_argument, 0, 0 },
636 { CPERF_BUFFER_SIZE, required_argument, 0, 0 },
637 { CPERF_SEGMENTS_NB, required_argument, 0, 0 },
639 { CPERF_DEVTYPE, required_argument, 0, 0 },
640 { CPERF_OPTYPE, required_argument, 0, 0 },
642 { CPERF_SILENT, no_argument, 0, 0 },
643 { CPERF_SESSIONLESS, no_argument, 0, 0 },
644 { CPERF_OUT_OF_PLACE, no_argument, 0, 0 },
645 { CPERF_VERIFY, no_argument, 0, 0 },
646 { CPERF_TEST_FILE, required_argument, 0, 0 },
647 { CPERF_TEST_NAME, required_argument, 0, 0 },
649 { CPERF_CIPHER_ALGO, required_argument, 0, 0 },
650 { CPERF_CIPHER_OP, required_argument, 0, 0 },
652 { CPERF_CIPHER_KEY_SZ, required_argument, 0, 0 },
653 { CPERF_CIPHER_IV_SZ, required_argument, 0, 0 },
655 { CPERF_AUTH_ALGO, required_argument, 0, 0 },
656 { CPERF_AUTH_OP, required_argument, 0, 0 },
658 { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 },
659 { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 },
660 { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 },
661 { CPERF_CSV, no_argument, 0, 0},
667 cperf_options_default(struct cperf_options *opts)
669 opts->test = CPERF_TEST_TYPE_THROUGHPUT;
671 opts->pool_sz = 8192;
672 opts->total_ops = 10000000;
674 opts->buffer_sz = 64;
675 opts->segments_nb = 1;
677 strncpy(opts->device_type, "crypto_aesni_mb",
678 sizeof(opts->device_type));
680 opts->op_type = CPERF_CIPHER_THEN_AUTH;
684 opts->test_file = NULL;
685 opts->test_name = NULL;
686 opts->sessionless = 0;
687 opts->out_of_place = 0;
690 opts->cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC;
691 opts->cipher_op = RTE_CRYPTO_CIPHER_OP_ENCRYPT;
692 opts->cipher_key_sz = 16;
693 opts->cipher_iv_sz = 16;
695 opts->auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC;
696 opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE;
698 opts->auth_key_sz = 64;
699 opts->auth_digest_sz = 12;
700 opts->auth_aad_sz = 0;
704 cperf_opts_parse_long(int opt_idx, struct cperf_options *opts)
706 struct long_opt_parser parsermap[] = {
707 { CPERF_PTEST_TYPE, parse_cperf_test_type },
708 { CPERF_SILENT, parse_silent },
709 { CPERF_POOL_SIZE, parse_pool_sz },
710 { CPERF_TOTAL_OPS, parse_total_ops },
711 { CPERF_BURST_SIZE, parse_burst_sz },
712 { CPERF_BUFFER_SIZE, parse_buffer_sz },
713 { CPERF_SEGMENTS_NB, parse_segments_nb },
714 { CPERF_DEVTYPE, parse_device_type },
715 { CPERF_OPTYPE, parse_op_type },
716 { CPERF_SESSIONLESS, parse_sessionless },
717 { CPERF_OUT_OF_PLACE, parse_out_of_place },
718 { CPERF_VERIFY, parse_verify },
719 { CPERF_TEST_FILE, parse_test_file },
720 { CPERF_TEST_NAME, parse_test_name },
721 { CPERF_CIPHER_ALGO, parse_cipher_algo },
722 { CPERF_CIPHER_OP, parse_cipher_op },
723 { CPERF_CIPHER_KEY_SZ, parse_cipher_key_sz },
724 { CPERF_CIPHER_IV_SZ, parse_cipher_iv_sz },
725 { CPERF_AUTH_ALGO, parse_auth_algo },
726 { CPERF_AUTH_OP, parse_auth_op },
727 { CPERF_AUTH_KEY_SZ, parse_auth_key_sz },
728 { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz },
729 { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz },
730 { CPERF_CSV, parse_csv_friendly},
734 for (i = 0; i < RTE_DIM(parsermap); i++) {
735 if (strncmp(lgopts[opt_idx].name, parsermap[i].lgopt_name,
736 strlen(lgopts[opt_idx].name)) == 0)
737 return parsermap[i].parser_fn(opts, optarg);
744 cperf_options_parse(struct cperf_options *options, int argc, char **argv)
746 int opt, retval, opt_idx;
748 while ((opt = getopt_long(argc, argv, "", lgopts, &opt_idx)) != EOF) {
753 retval = cperf_opts_parse_long(opt_idx, options);
768 cperf_options_check(struct cperf_options *options)
770 if (options->segments_nb > options->buffer_sz) {
772 "Segments number greater than buffer size.\n");
776 if (options->verify && options->test_file == NULL) {
777 RTE_LOG(ERR, USER1, "Define path to the file with test"
782 if (options->test_name != NULL && options->test_file == NULL) {
783 RTE_LOG(ERR, USER1, "Define path to the file with test"
788 if (options->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY &&
789 options->test_file == NULL) {
790 RTE_LOG(ERR, USER1, "Define path to the file with test"
795 if (options->verify &&
796 options->total_ops > options->pool_sz) {
797 RTE_LOG(ERR, USER1, "Total number of ops must be less than or"
798 " equal to the pool size.\n");
802 if (options->op_type == CPERF_CIPHER_THEN_AUTH) {
803 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
805 RTE_CRYPTO_AUTH_OP_GENERATE) {
806 RTE_LOG(ERR, USER1, "Option cipher then auth must use"
807 " options: encrypt and generate.\n");
810 } else if (options->op_type == CPERF_AUTH_THEN_CIPHER) {
811 if (options->cipher_op != RTE_CRYPTO_CIPHER_OP_DECRYPT &&
813 RTE_CRYPTO_AUTH_OP_VERIFY) {
814 RTE_LOG(ERR, USER1, "Option auth then cipher must use"
815 " options: decrypt and verify.\n");
818 } else if (options->op_type == CPERF_AEAD) {
819 if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT &&
821 RTE_CRYPTO_AUTH_OP_GENERATE) &&
822 !(options->cipher_op ==
823 RTE_CRYPTO_CIPHER_OP_DECRYPT &&
825 RTE_CRYPTO_AUTH_OP_VERIFY)) {
826 RTE_LOG(ERR, USER1, "Use together options: encrypt and"
827 " generate or decrypt and verify.\n");
836 cperf_options_dump(struct cperf_options *opts)
838 printf("# Crypto Performance Application Options:\n");
840 printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]);
842 printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz);
843 printf("# total number of ops: %u\n", opts->total_ops);
844 printf("# burst size: %u\n", opts->burst_sz);
845 printf("# buffer size: %u\n", opts->buffer_sz);
846 printf("# segments per buffer: %u\n", opts->segments_nb);
848 printf("# cryptodev type: %s\n", opts->device_type);
850 printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]);
851 printf("# verify operation: %s\n", opts->verify ? "yes" : "no");
852 printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no");
853 printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no");
857 if (opts->op_type == CPERF_AUTH_ONLY ||
858 opts->op_type == CPERF_CIPHER_THEN_AUTH ||
859 opts->op_type == CPERF_AUTH_THEN_CIPHER ||
860 opts->op_type == CPERF_AEAD) {
861 printf("# auth algorithm: %s\n",
862 rte_crypto_auth_algorithm_strings[opts->auth_algo]);
863 printf("# auth operation: %s\n",
864 rte_crypto_auth_operation_strings[opts->auth_op]);
865 printf("# auth key size: %u\n", opts->auth_key_sz);
866 printf("# auth digest size: %u\n", opts->auth_digest_sz);
867 printf("# auth aad size: %u\n", opts->auth_aad_sz);
871 if (opts->op_type == CPERF_CIPHER_ONLY ||
872 opts->op_type == CPERF_CIPHER_THEN_AUTH ||
873 opts->op_type == CPERF_AUTH_THEN_CIPHER ||
874 opts->op_type == CPERF_AEAD) {
875 printf("# cipher algorithm: %s\n",
876 rte_crypto_cipher_algorithm_strings[opts->cipher_algo]);
877 printf("# cipher operation: %s\n",
878 rte_crypto_cipher_operation_strings[opts->cipher_op]);
879 printf("# cipher key size: %u\n", opts->cipher_key_sz);
880 printf("# cipher iv size: %u\n", opts->cipher_iv_sz);