X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-crypto-perf%2Fcperf_options_parsing.c;h=3974c8173e6dbe354d96141b2d6f9ebf4a87b01b;hb=5b2b0a740fba32db438d92390a4a853d3af2381c;hp=691e7889a14ecd5964662abeb3a57c7ec85650ea;hpb=8ecd4048ba5d23c016df9a10225972bb78fd8044;p=dpdk.git diff --git a/app/test-crypto-perf/cperf_options_parsing.c b/app/test-crypto-perf/cperf_options_parsing.c index 691e7889a1..3974c8173e 100644 --- a/app/test-crypto-perf/cperf_options_parsing.c +++ b/app/test-crypto-perf/cperf_options_parsing.c @@ -33,10 +33,14 @@ #include #include +#include #include #include "cperf_options.h" +#define AES_BLOCK_SIZE 16 +#define DES_BLOCK_SIZE 8 + struct name_id_map { const char *name; uint32_t id; @@ -66,12 +70,16 @@ parse_cperf_test_type(struct cperf_options *opts, const char *arg) CPERF_TEST_TYPE_THROUGHPUT }, { - cperf_test_type_strs[CPERF_TEST_TYPE_CYCLECOUNT], - CPERF_TEST_TYPE_CYCLECOUNT + cperf_test_type_strs[CPERF_TEST_TYPE_VERIFY], + CPERF_TEST_TYPE_VERIFY }, { cperf_test_type_strs[CPERF_TEST_TYPE_LATENCY], CPERF_TEST_TYPE_LATENCY + }, + { + cperf_test_type_strs[CPERF_TEST_TYPE_PMDCC], + CPERF_TEST_TYPE_PMDCC } }; @@ -122,13 +130,147 @@ parse_uint16_t(uint16_t *value, const char *arg) return 0; } +static int +parse_range(const char *arg, uint32_t *min, uint32_t *max, uint32_t *inc) +{ + char *token; + uint32_t number; + + char *copy_arg = strdup(arg); + + if (copy_arg == NULL) + return -1; + + errno = 0; + token = strtok(copy_arg, ":"); + + /* Parse minimum value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_range; + + *min = number; + } else + goto err_range; + + token = strtok(NULL, ":"); + + /* Parse increment value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_range; + + *inc = number; + } else + goto err_range; + + token = strtok(NULL, ":"); + + /* Parse maximum value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0 || + number < *min) + goto err_range; + + *max = number; + } else + goto err_range; + + if (strtok(NULL, ":") != NULL) + goto err_range; + + free(copy_arg); + return 0; + +err_range: + free(copy_arg); + return -1; +} + +static int +parse_list(const char *arg, uint32_t *list, uint32_t *min, uint32_t *max) +{ + char *token; + uint32_t number; + uint8_t count = 0; + + char *copy_arg = strdup(arg); + + if (copy_arg == NULL) + return -1; + + errno = 0; + token = strtok(copy_arg, ","); + + /* Parse first value */ + if (token != NULL) { + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_list; + + list[count++] = number; + *min = number; + *max = number; + } else + goto err_list; + + token = strtok(NULL, ","); + + while (token != NULL) { + if (count == MAX_LIST) { + RTE_LOG(WARNING, USER1, "Using only the first %u sizes\n", + MAX_LIST); + break; + } + + number = strtoul(token, NULL, 10); + + if (errno == EINVAL || errno == ERANGE || + number == 0) + goto err_list; + + list[count++] = number; + + if (number < *min) + *min = number; + if (number > *max) + *max = number; + + token = strtok(NULL, ","); + } + + free(copy_arg); + return count; + +err_list: + free(copy_arg); + return -1; +} + static int parse_total_ops(struct cperf_options *opts, const char *arg) { int ret = parse_uint32_t(&opts->total_ops, arg); if (ret) - RTE_LOG(ERR, USER1, "failed to parse total operations count"); + RTE_LOG(ERR, USER1, "failed to parse total operations count\n"); + + if (opts->total_ops == 0) { + RTE_LOG(ERR, USER1, + "invalid total operations count number specified\n"); + return -1; + } return ret; } @@ -146,46 +288,75 @@ parse_pool_sz(struct cperf_options *opts, const char *arg) static int parse_burst_sz(struct cperf_options *opts, const char *arg) { - int ret = parse_uint32_t(&opts->burst_sz, arg); + int ret; + + /* Try parsing the argument as a range, if it fails, parse it as a list */ + if (parse_range(arg, &opts->min_burst_size, &opts->max_burst_size, + &opts->inc_burst_size) < 0) { + ret = parse_list(arg, opts->burst_size_list, + &opts->min_burst_size, + &opts->max_burst_size); + if (ret < 0) { + RTE_LOG(ERR, USER1, "failed to parse burst size/s\n"); + return -1; + } + opts->burst_size_count = ret; + } - if (ret) - RTE_LOG(ERR, USER1, "failed to parse burst size"); - return ret; + return 0; } static int parse_buffer_sz(struct cperf_options *opts, const char *arg) { - uint32_t i, valid_buf_sz[] = { - 32, 64, 128, 256, 384, 512, 768, 1024, 1280, 1536, 1792, - 2048 - }; + int ret; + + /* Try parsing the argument as a range, if it fails, parse it as a list */ + if (parse_range(arg, &opts->min_buffer_size, &opts->max_buffer_size, + &opts->inc_buffer_size) < 0) { + ret = parse_list(arg, opts->buffer_size_list, + &opts->min_buffer_size, + &opts->max_buffer_size); + if (ret < 0) { + RTE_LOG(ERR, USER1, "failed to parse buffer size/s\n"); + return -1; + } + opts->buffer_size_count = ret; + } + + return 0; +} - if (parse_uint32_t(&opts->buffer_sz, arg)) { - RTE_LOG(ERR, USER1, "failed to parse buffer size"); +static int +parse_segment_sz(struct cperf_options *opts, const char *arg) +{ + int ret = parse_uint32_t(&opts->segment_sz, arg); + + if (ret) { + RTE_LOG(ERR, USER1, "failed to parse segment size\n"); return -1; } - for (i = 0; i < RTE_DIM(valid_buf_sz); i++) - if (valid_buf_sz[i] == opts->buffer_sz) - return 0; + if (opts->segment_sz == 0) { + RTE_LOG(ERR, USER1, "Segment size has to be bigger than 0\n"); + return -1; + } - RTE_LOG(ERR, USER1, "invalid buffer size specified"); - return -1; + return 0; } static int -parse_segments_nb(struct cperf_options *opts, const char *arg) +parse_desc_nb(struct cperf_options *opts, const char *arg) { - int ret = parse_uint32_t(&opts->segments_nb, arg); + int ret = parse_uint32_t(&opts->nb_descriptors, arg); if (ret) { - RTE_LOG(ERR, USER1, "failed to parse segments number\n"); + RTE_LOG(ERR, USER1, "failed to parse descriptors number\n"); return -1; } - if ((opts->segments_nb == 0) || (opts->segments_nb > 255)) { - RTE_LOG(ERR, USER1, "invalid segments number specified\n"); + if (opts->nb_descriptors == 0) { + RTE_LOG(ERR, USER1, "invalid descriptors number specified\n"); return -1; } @@ -258,15 +429,6 @@ parse_out_of_place(struct cperf_options *opts, return 0; } -static int -parse_verify(struct cperf_options *opts, - const char *arg __rte_unused) -{ - opts->verify = 1; - - return 0; -} - static int parse_test_file(struct cperf_options *opts, const char *arg) @@ -303,93 +465,15 @@ parse_silent(struct cperf_options *opts, static int parse_cipher_algo(struct cperf_options *opts, const char *arg) { - struct name_id_map cipher_algo_namemap[] = { - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_3DES_CBC], - RTE_CRYPTO_CIPHER_3DES_CBC - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_3DES_ECB], - RTE_CRYPTO_CIPHER_3DES_ECB - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_3DES_CTR], - RTE_CRYPTO_CIPHER_3DES_CTR - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_CBC], - RTE_CRYPTO_CIPHER_AES_CBC - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_CCM], - RTE_CRYPTO_CIPHER_AES_CCM - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_CTR], - RTE_CRYPTO_CIPHER_AES_CTR - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_ECB], - RTE_CRYPTO_CIPHER_AES_ECB - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_GCM], - RTE_CRYPTO_CIPHER_AES_GCM - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_F8], - RTE_CRYPTO_CIPHER_AES_F8 - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_AES_XTS], - RTE_CRYPTO_CIPHER_AES_XTS - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_ARC4], - RTE_CRYPTO_CIPHER_ARC4 - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_NULL], - RTE_CRYPTO_CIPHER_NULL - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_KASUMI_F8], - RTE_CRYPTO_CIPHER_KASUMI_F8 - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_SNOW3G_UEA2], - RTE_CRYPTO_CIPHER_SNOW3G_UEA2 - }, - { - rte_crypto_cipher_algorithm_strings - [RTE_CRYPTO_CIPHER_ZUC_EEA3], - RTE_CRYPTO_CIPHER_ZUC_EEA3 - }, - }; + enum rte_crypto_cipher_algorithm cipher_algo; - int id = get_str_key_id_mapping(cipher_algo_namemap, - RTE_DIM(cipher_algo_namemap), arg); - if (id < 0) { + if (rte_cryptodev_get_cipher_algo_enum(&cipher_algo, arg) < 0) { RTE_LOG(ERR, USER1, "Invalid cipher algorithm specified\n"); return -1; } - opts->cipher_algo = (enum rte_crypto_cipher_algorithm)id; + opts->cipher_algo = cipher_algo; return 0; } @@ -434,125 +518,16 @@ parse_cipher_iv_sz(struct cperf_options *opts, const char *arg) } static int -parse_auth_algo(struct cperf_options *opts, const char *arg) { - struct name_id_map cipher_auth_namemap[] = { - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_CBC_MAC], - RTE_CRYPTO_AUTH_AES_CBC_MAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_CCM], - RTE_CRYPTO_AUTH_AES_CCM - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_CMAC], - RTE_CRYPTO_AUTH_AES_CMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_GCM], - RTE_CRYPTO_AUTH_AES_GCM - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_GMAC], - RTE_CRYPTO_AUTH_AES_GMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_AES_XCBC_MAC], - RTE_CRYPTO_AUTH_AES_XCBC_MAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_MD5], - RTE_CRYPTO_AUTH_MD5 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_MD5_HMAC], - RTE_CRYPTO_AUTH_MD5_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA1], - RTE_CRYPTO_AUTH_SHA1 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA1_HMAC], - RTE_CRYPTO_AUTH_SHA1_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA224], - RTE_CRYPTO_AUTH_SHA224 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA224_HMAC], - RTE_CRYPTO_AUTH_SHA224_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA256], - RTE_CRYPTO_AUTH_SHA256 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA256_HMAC], - RTE_CRYPTO_AUTH_SHA256_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA384], - RTE_CRYPTO_AUTH_SHA384 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA384_HMAC], - RTE_CRYPTO_AUTH_SHA384_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA512], - RTE_CRYPTO_AUTH_SHA512 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SHA512_HMAC], - RTE_CRYPTO_AUTH_SHA512_HMAC - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_KASUMI_F9], - RTE_CRYPTO_AUTH_KASUMI_F9 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_SNOW3G_UIA2], - RTE_CRYPTO_AUTH_SNOW3G_UIA2 - }, - { - rte_crypto_auth_algorithm_strings - [RTE_CRYPTO_AUTH_ZUC_EIA3], - RTE_CRYPTO_AUTH_ZUC_EIA3 - }, - }; - +parse_auth_algo(struct cperf_options *opts, const char *arg) +{ + enum rte_crypto_auth_algorithm auth_algo; - int id = get_str_key_id_mapping(cipher_auth_namemap, - RTE_DIM(cipher_auth_namemap), arg); - if (id < 0) { - RTE_LOG(ERR, USER1, "invalid authentication algorithm specified" - "\n"); + if (rte_cryptodev_get_auth_algo_enum(&auth_algo, arg) < 0) { + RTE_LOG(ERR, USER1, "Invalid authentication algorithm specified\n"); return -1; } - opts->auth_algo = (enum rte_crypto_auth_algorithm)id; + opts->auth_algo = auth_algo; return 0; } @@ -592,15 +567,76 @@ parse_auth_key_sz(struct cperf_options *opts, const char *arg) } static int -parse_auth_digest_sz(struct cperf_options *opts, const char *arg) +parse_digest_sz(struct cperf_options *opts, const char *arg) +{ + return parse_uint16_t(&opts->digest_sz, arg); +} + +static int +parse_auth_iv_sz(struct cperf_options *opts, const char *arg) +{ + return parse_uint16_t(&opts->auth_iv_sz, arg); +} + +static int +parse_aead_algo(struct cperf_options *opts, const char *arg) +{ + enum rte_crypto_aead_algorithm aead_algo; + + if (rte_cryptodev_get_aead_algo_enum(&aead_algo, arg) < 0) { + RTE_LOG(ERR, USER1, "Invalid AEAD algorithm specified\n"); + return -1; + } + + opts->aead_algo = aead_algo; + + return 0; +} + +static int +parse_aead_op(struct cperf_options *opts, const char *arg) +{ + struct name_id_map aead_op_namemap[] = { + { + rte_crypto_aead_operation_strings + [RTE_CRYPTO_AEAD_OP_ENCRYPT], + RTE_CRYPTO_AEAD_OP_ENCRYPT }, + { + rte_crypto_aead_operation_strings + [RTE_CRYPTO_AEAD_OP_DECRYPT], + RTE_CRYPTO_AEAD_OP_DECRYPT + } + }; + + int id = get_str_key_id_mapping(aead_op_namemap, + RTE_DIM(aead_op_namemap), arg); + if (id < 0) { + RTE_LOG(ERR, USER1, "invalid AEAD operation specified" + "\n"); + return -1; + } + + opts->aead_op = (enum rte_crypto_aead_operation)id; + + return 0; +} + +static int +parse_aead_key_sz(struct cperf_options *opts, const char *arg) { - return parse_uint16_t(&opts->auth_digest_sz, arg); + return parse_uint16_t(&opts->aead_key_sz, arg); } static int -parse_auth_aad_sz(struct cperf_options *opts, const char *arg) +parse_aead_iv_sz(struct cperf_options *opts, const char *arg) { - return parse_uint16_t(&opts->auth_aad_sz, arg); + return parse_uint16_t(&opts->aead_iv_sz, arg); +} + +static int +parse_aead_aad_sz(struct cperf_options *opts, const char *arg) +{ + return parse_uint16_t(&opts->aead_aad_sz, arg); } static int @@ -611,6 +647,20 @@ parse_csv_friendly(struct cperf_options *opts, const char *arg __rte_unused) return 0; } +static int +parse_pmd_cyclecount_delay_ms(struct cperf_options *opts, + const char *arg) +{ + int ret = parse_uint32_t(&opts->pmdcc_delay, arg); + + if (ret) { + RTE_LOG(ERR, USER1, "failed to parse pmd-cyclecount delay\n"); + return -1; + } + + return 0; +} + typedef int (*option_parser_t)(struct cperf_options *opts, const char *arg); @@ -628,7 +678,8 @@ static struct option lgopts[] = { { CPERF_TOTAL_OPS, required_argument, 0, 0 }, { CPERF_BURST_SIZE, required_argument, 0, 0 }, { CPERF_BUFFER_SIZE, required_argument, 0, 0 }, - { CPERF_SEGMENTS_NB, required_argument, 0, 0 }, + { CPERF_SEGMENT_SIZE, required_argument, 0, 0 }, + { CPERF_DESC_NB, required_argument, 0, 0 }, { CPERF_DEVTYPE, required_argument, 0, 0 }, { CPERF_OPTYPE, required_argument, 0, 0 }, @@ -636,7 +687,6 @@ static struct option lgopts[] = { { CPERF_SILENT, no_argument, 0, 0 }, { CPERF_SESSIONLESS, no_argument, 0, 0 }, { CPERF_OUT_OF_PLACE, no_argument, 0, 0 }, - { CPERF_VERIFY, no_argument, 0, 0 }, { CPERF_TEST_FILE, required_argument, 0, 0 }, { CPERF_TEST_NAME, required_argument, 0, 0 }, @@ -650,10 +700,21 @@ static struct option lgopts[] = { { CPERF_AUTH_OP, required_argument, 0, 0 }, { CPERF_AUTH_KEY_SZ, required_argument, 0, 0 }, - { CPERF_AUTH_DIGEST_SZ, required_argument, 0, 0 }, - { CPERF_AUTH_AAD_SZ, required_argument, 0, 0 }, + { CPERF_AUTH_IV_SZ, required_argument, 0, 0 }, + + { CPERF_AEAD_ALGO, required_argument, 0, 0 }, + { CPERF_AEAD_OP, required_argument, 0, 0 }, + + { CPERF_AEAD_KEY_SZ, required_argument, 0, 0 }, + { CPERF_AEAD_AAD_SZ, required_argument, 0, 0 }, + { CPERF_AEAD_IV_SZ, required_argument, 0, 0 }, + + { CPERF_DIGEST_SZ, required_argument, 0, 0 }, + { CPERF_CSV, no_argument, 0, 0}, + { CPERF_PMDCC_DELAY_MS, required_argument, 0, 0 }, + { NULL, 0, 0, 0 } }; @@ -664,9 +725,25 @@ cperf_options_default(struct cperf_options *opts) opts->pool_sz = 8192; opts->total_ops = 10000000; - opts->burst_sz = 32; - opts->buffer_sz = 64; - opts->segments_nb = 1; + opts->nb_descriptors = 2048; + + opts->buffer_size_list[0] = 64; + opts->buffer_size_count = 1; + opts->max_buffer_size = 64; + opts->min_buffer_size = 64; + opts->inc_buffer_size = 0; + + opts->burst_size_list[0] = 32; + opts->burst_size_count = 1; + opts->max_burst_size = 32; + opts->min_burst_size = 32; + opts->inc_burst_size = 0; + + /* + * Will be parsed from command line or set to + * maximum buffer size + digest, later + */ + opts->segment_sz = 0; strncpy(opts->device_type, "crypto_aesni_mb", sizeof(opts->device_type)); @@ -674,7 +751,6 @@ cperf_options_default(struct cperf_options *opts) opts->op_type = CPERF_CIPHER_THEN_AUTH; opts->silent = 0; - opts->verify = 0; opts->test_file = NULL; opts->test_name = NULL; opts->sessionless = 0; @@ -690,8 +766,15 @@ cperf_options_default(struct cperf_options *opts) opts->auth_op = RTE_CRYPTO_AUTH_OP_GENERATE; opts->auth_key_sz = 64; - opts->auth_digest_sz = 12; - opts->auth_aad_sz = 0; + opts->auth_iv_sz = 0; + + opts->aead_key_sz = 0; + opts->aead_iv_sz = 0; + opts->aead_aad_sz = 0; + + opts->digest_sz = 12; + + opts->pmdcc_delay = 0; } static int @@ -704,12 +787,12 @@ cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) { CPERF_TOTAL_OPS, parse_total_ops }, { CPERF_BURST_SIZE, parse_burst_sz }, { CPERF_BUFFER_SIZE, parse_buffer_sz }, - { CPERF_SEGMENTS_NB, parse_segments_nb }, + { CPERF_SEGMENT_SIZE, parse_segment_sz }, + { CPERF_DESC_NB, parse_desc_nb }, { CPERF_DEVTYPE, parse_device_type }, { CPERF_OPTYPE, parse_op_type }, { CPERF_SESSIONLESS, parse_sessionless }, { CPERF_OUT_OF_PLACE, parse_out_of_place }, - { CPERF_VERIFY, parse_verify }, { CPERF_TEST_FILE, parse_test_file }, { CPERF_TEST_NAME, parse_test_name }, { CPERF_CIPHER_ALGO, parse_cipher_algo }, @@ -719,9 +802,15 @@ cperf_opts_parse_long(int opt_idx, struct cperf_options *opts) { CPERF_AUTH_ALGO, parse_auth_algo }, { CPERF_AUTH_OP, parse_auth_op }, { CPERF_AUTH_KEY_SZ, parse_auth_key_sz }, - { CPERF_AUTH_DIGEST_SZ, parse_auth_digest_sz }, - { CPERF_AUTH_AAD_SZ, parse_auth_aad_sz }, - { CPERF_CSV, parse_csv_friendly}, + { CPERF_AUTH_IV_SZ, parse_auth_iv_sz }, + { CPERF_AEAD_ALGO, parse_aead_algo }, + { CPERF_AEAD_OP, parse_aead_op }, + { CPERF_AEAD_KEY_SZ, parse_aead_key_sz }, + { CPERF_AEAD_IV_SZ, parse_aead_iv_sz }, + { CPERF_AEAD_AAD_SZ, parse_aead_aad_sz }, + { CPERF_DIGEST_SZ, parse_digest_sz }, + { CPERF_CSV, parse_csv_friendly}, + { CPERF_PMDCC_DELAY_MS, parse_pmd_cyclecount_delay_ms}, }; unsigned int i; @@ -758,21 +847,101 @@ cperf_options_parse(struct cperf_options *options, int argc, char **argv) return 0; } +static int +check_cipher_buffer_length(struct cperf_options *options) +{ + uint32_t buffer_size, buffer_size_idx = 0; + + if (options->cipher_algo == RTE_CRYPTO_CIPHER_AES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_AES_ECB) { + if (options->inc_buffer_size != 0) + buffer_size = options->min_buffer_size; + else + buffer_size = options->buffer_size_list[0]; + + while (buffer_size <= options->max_buffer_size) { + if ((buffer_size % AES_BLOCK_SIZE) != 0) { + RTE_LOG(ERR, USER1, "Some of the buffer sizes are " + "not suitable for the algorithm selected\n"); + return -EINVAL; + } + + if (options->inc_buffer_size != 0) + buffer_size += options->inc_buffer_size; + else { + if (++buffer_size_idx == options->buffer_size_count) + break; + buffer_size = options->buffer_size_list[buffer_size_idx]; + } + + } + } + + if (options->cipher_algo == RTE_CRYPTO_CIPHER_DES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_CBC || + options->cipher_algo == RTE_CRYPTO_CIPHER_3DES_ECB) { + if (options->inc_buffer_size != 0) + buffer_size = options->min_buffer_size; + else + buffer_size = options->buffer_size_list[0]; + + while (buffer_size <= options->max_buffer_size) { + if ((buffer_size % DES_BLOCK_SIZE) != 0) { + RTE_LOG(ERR, USER1, "Some of the buffer sizes are " + "not suitable for the algorithm selected\n"); + return -EINVAL; + } + + if (options->inc_buffer_size != 0) + buffer_size += options->inc_buffer_size; + else { + if (++buffer_size_idx == options->buffer_size_count) + break; + buffer_size = options->buffer_size_list[buffer_size_idx]; + } + + } + } + + return 0; +} + int cperf_options_check(struct cperf_options *options) { - if (options->segments_nb > options->buffer_sz) { + if (options->op_type == CPERF_CIPHER_ONLY) + options->digest_sz = 0; + + /* + * If segment size is not set, assume only one segment, + * big enough to contain the largest buffer and the digest + */ + if (options->segment_sz == 0) + options->segment_sz = options->max_buffer_size + + options->digest_sz; + + if (options->segment_sz < options->digest_sz) { RTE_LOG(ERR, USER1, - "Segments number greater than buffer size.\n"); + "Segment size should be at least " + "the size of the digest\n"); return -EINVAL; } - if (options->verify && options->test_file == NULL) { + if (options->test == CPERF_TEST_TYPE_VERIFY && + options->test_file == NULL) { RTE_LOG(ERR, USER1, "Define path to the file with test" " vectors.\n"); return -EINVAL; } + if (options->test == CPERF_TEST_TYPE_VERIFY && + options->op_type != CPERF_CIPHER_ONLY && + options->test_name == NULL) { + RTE_LOG(ERR, USER1, "Define test name to get the correct digest" + " from the test vectors.\n"); + return -EINVAL; + } + if (options->test_name != NULL && options->test_file == NULL) { RTE_LOG(ERR, USER1, "Define path to the file with test" " vectors.\n"); @@ -786,10 +955,27 @@ cperf_options_check(struct cperf_options *options) return -EINVAL; } - if (options->verify && - options->total_ops > options->pool_sz) { - RTE_LOG(ERR, USER1, "Total number of ops must be less than or" - " equal to the pool size.\n"); + if (options->test == CPERF_TEST_TYPE_VERIFY && + (options->inc_buffer_size != 0 || + options->buffer_size_count > 1)) { + RTE_LOG(ERR, USER1, "Only one buffer size is allowed when " + "using the verify test.\n"); + return -EINVAL; + } + + if (options->test == CPERF_TEST_TYPE_VERIFY && + (options->inc_burst_size != 0 || + options->burst_size_count > 1)) { + RTE_LOG(ERR, USER1, "Only one burst size is allowed when " + "using the verify test.\n"); + return -EINVAL; + } + + if (options->test == CPERF_TEST_TYPE_PMDCC && + options->pool_sz < options->nb_descriptors) { + RTE_LOG(ERR, USER1, "For pmd cyclecount benchmarks, pool size " + "must be equal or greater than the number of " + "cryptodev descriptors.\n"); return -EINVAL; } @@ -809,18 +995,13 @@ cperf_options_check(struct cperf_options *options) " options: decrypt and verify.\n"); return -EINVAL; } - } else if (options->op_type == CPERF_AEAD) { - if (!(options->cipher_op == RTE_CRYPTO_CIPHER_OP_ENCRYPT && - options->auth_op == - RTE_CRYPTO_AUTH_OP_GENERATE) && - !(options->cipher_op == - RTE_CRYPTO_CIPHER_OP_DECRYPT && - options->auth_op == - RTE_CRYPTO_AUTH_OP_VERIFY)) { - RTE_LOG(ERR, USER1, "Use together options: encrypt and" - " generate or decrypt and verify.\n"); + } + + if (options->op_type == CPERF_CIPHER_ONLY || + options->op_type == CPERF_CIPHER_THEN_AUTH || + options->op_type == CPERF_AUTH_THEN_CIPHER) { + if (check_cipher_buffer_length(options) < 0) return -EINVAL; - } } return 0; @@ -829,43 +1010,64 @@ cperf_options_check(struct cperf_options *options) void cperf_options_dump(struct cperf_options *opts) { + uint8_t size_idx; + printf("# Crypto Performance Application Options:\n"); printf("#\n"); printf("# cperf test: %s\n", cperf_test_type_strs[opts->test]); printf("#\n"); printf("# size of crypto op / mbuf pool: %u\n", opts->pool_sz); printf("# total number of ops: %u\n", opts->total_ops); - printf("# burst size: %u\n", opts->burst_sz); - printf("# buffer size: %u\n", opts->buffer_sz); - printf("# segments per buffer: %u\n", opts->segments_nb); + if (opts->inc_buffer_size != 0) { + printf("# buffer size:\n"); + printf("#\t min: %u\n", opts->min_buffer_size); + printf("#\t max: %u\n", opts->max_buffer_size); + printf("#\t inc: %u\n", opts->inc_buffer_size); + } else { + printf("# buffer sizes: "); + for (size_idx = 0; size_idx < opts->buffer_size_count; size_idx++) + printf("%u ", opts->buffer_size_list[size_idx]); + printf("\n"); + } + if (opts->inc_burst_size != 0) { + printf("# burst size:\n"); + printf("#\t min: %u\n", opts->min_burst_size); + printf("#\t max: %u\n", opts->max_burst_size); + printf("#\t inc: %u\n", opts->inc_burst_size); + } else { + printf("# burst sizes: "); + for (size_idx = 0; size_idx < opts->burst_size_count; size_idx++) + printf("%u ", opts->burst_size_list[size_idx]); + printf("\n"); + } + printf("\n# segment size: %u\n", opts->segment_sz); printf("#\n"); printf("# cryptodev type: %s\n", opts->device_type); printf("#\n"); printf("# crypto operation: %s\n", cperf_op_type_strs[opts->op_type]); - printf("# verify operation: %s\n", opts->verify ? "yes" : "no"); printf("# sessionless: %s\n", opts->sessionless ? "yes" : "no"); printf("# out of place: %s\n", opts->out_of_place ? "yes" : "no"); + if (opts->test == CPERF_TEST_TYPE_PMDCC) + printf("# inter-burst delay: %u ms\n", opts->pmdcc_delay); printf("#\n"); if (opts->op_type == CPERF_AUTH_ONLY || opts->op_type == CPERF_CIPHER_THEN_AUTH || - opts->op_type == CPERF_AUTH_THEN_CIPHER || - opts->op_type == CPERF_AEAD) { + opts->op_type == CPERF_AUTH_THEN_CIPHER) { printf("# auth algorithm: %s\n", rte_crypto_auth_algorithm_strings[opts->auth_algo]); printf("# auth operation: %s\n", rte_crypto_auth_operation_strings[opts->auth_op]); printf("# auth key size: %u\n", opts->auth_key_sz); - printf("# auth digest size: %u\n", opts->auth_digest_sz); - printf("# auth aad size: %u\n", opts->auth_aad_sz); + printf("# auth iv size: %u\n", opts->auth_iv_sz); + printf("# auth digest size: %u\n", opts->digest_sz); printf("#\n"); } if (opts->op_type == CPERF_CIPHER_ONLY || opts->op_type == CPERF_CIPHER_THEN_AUTH || - opts->op_type == CPERF_AUTH_THEN_CIPHER || - opts->op_type == CPERF_AEAD) { + opts->op_type == CPERF_AUTH_THEN_CIPHER) { printf("# cipher algorithm: %s\n", rte_crypto_cipher_algorithm_strings[opts->cipher_algo]); printf("# cipher operation: %s\n", @@ -874,4 +1076,16 @@ cperf_options_dump(struct cperf_options *opts) printf("# cipher iv size: %u\n", opts->cipher_iv_sz); printf("#\n"); } + + if (opts->op_type == CPERF_AEAD) { + printf("# aead algorithm: %s\n", + rte_crypto_aead_algorithm_strings[opts->aead_algo]); + printf("# aead operation: %s\n", + rte_crypto_aead_operation_strings[opts->aead_op]); + printf("# aead key size: %u\n", opts->aead_key_sz); + printf("# aead iv size: %u\n", opts->aead_iv_sz); + printf("# aead digest size: %u\n", opts->digest_sz); + printf("# aead aad size: %u\n", opts->aead_aad_sz); + printf("#\n"); + } }