X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=test%2Ftest%2Ftest_cryptodev_perf.c;h=e3d0479721530c35858f544bc7ab31c3cb7bbfaa;hb=4428eda8bb756a487a05a3e6c86da0b2de7227ae;hp=f4406dcc4a00b05e7a977ea5c6646e523bb641b0;hpb=8fec4832c95f82806f947389799f8ae54fb79421;p=dpdk.git diff --git a/test/test/test_cryptodev_perf.c b/test/test/test_cryptodev_perf.c index f4406dcc4a..e3d0479721 100644 --- a/test/test/test_cryptodev_perf.c +++ b/test/test/test_cryptodev_perf.c @@ -1,7 +1,7 @@ /*- * BSD LICENSE * - * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. + * Copyright(c) 2015-2017 Intel Corporation. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions @@ -43,6 +43,9 @@ #include "test_cryptodev.h" #include "test_cryptodev_gcm_test_vectors.h" +#define AES_CIPHER_IV_LENGTH 16 +#define TRIPLE_DES_CIPHER_IV_LENGTH 8 +#define AES_GCM_AAD_LENGTH 16 #define PERF_NUM_OPS_INFLIGHT (128) #define DEFAULT_NUM_REQS_TO_SUBMIT (10000000) @@ -62,16 +65,13 @@ enum chain_mode { CIPHER_HASH, HASH_CIPHER, CIPHER_ONLY, - HASH_ONLY + HASH_ONLY, + AEAD }; struct symmetric_op { - const uint8_t *iv_data; - uint32_t iv_len; - const uint8_t *aad_data; - uint32_t aad_len; const uint8_t *p_data; uint32_t p_len; @@ -87,6 +87,7 @@ struct symmetric_op { struct symmetric_session_attrs { enum rte_crypto_cipher_operation cipher; enum rte_crypto_auth_operation auth; + enum rte_crypto_aead_operation aead; enum rte_crypto_cipher_algorithm cipher_algorithm; const uint8_t *key_cipher_data; @@ -96,6 +97,13 @@ struct symmetric_session_attrs { const uint8_t *key_auth_data; uint32_t key_auth_len; + enum rte_crypto_aead_algorithm aead_algorithm; + const uint8_t *key_aead_data; + uint32_t key_aead_len; + + const uint8_t *iv_data; + uint16_t iv_len; + uint16_t aad_len; uint32_t digest_len; }; @@ -110,7 +118,6 @@ struct symmetric_session_attrs { struct crypto_params { uint8_t *aad; - uint8_t *iv; uint8_t *digest; }; @@ -123,8 +130,9 @@ struct perf_test_params { enum chain_mode chain; enum rte_crypto_cipher_algorithm cipher_algo; - unsigned cipher_key_length; + unsigned int key_length; enum rte_crypto_auth_algorithm auth_algo; + enum rte_crypto_aead_algorithm aead_algo; struct symmetric_session_attrs *session_attrs; @@ -156,7 +164,8 @@ static struct rte_cryptodev_sym_session * test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain, enum rte_crypto_cipher_algorithm cipher_algo, unsigned int cipher_key_len, - enum rte_crypto_auth_algorithm auth_algo); + enum rte_crypto_auth_algorithm auth_algo, + enum rte_crypto_aead_algorithm aead_algo); static struct rte_cryptodev_sym_session * test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain, enum rte_crypto_cipher_algorithm cipher_algo, @@ -167,20 +176,19 @@ static struct rte_mbuf * test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz); static inline struct rte_crypto_op * test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m, - struct rte_cryptodev_sym_session *sess, unsigned data_len, - unsigned digest_len); + struct rte_cryptodev_sym_session *sess, unsigned int data_len); static inline struct rte_crypto_op * test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain); + enum chain_mode chain); static inline struct rte_crypto_op * test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain __rte_unused); + enum chain_mode chain __rte_unused); static inline struct rte_crypto_op * test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain __rte_unused); + enum chain_mode chain __rte_unused); static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo); @@ -191,6 +199,7 @@ static const char *chain_mode_name(enum chain_mode mode) case HASH_CIPHER: return "hash_cipher"; break; case CIPHER_ONLY: return "cipher_only"; break; case HASH_ONLY: return "hash_only"; break; + case AEAD: return "aead"; break; default: return ""; break; } } @@ -207,62 +216,13 @@ static const char *pmd_name(enum rte_cryptodev_type pmd) return RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD); case RTE_CRYPTODEV_SNOW3G_PMD: return RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD); + case RTE_CRYPTODEV_DPAA2_SEC_PMD: + return RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD); default: return ""; } } -static const char *cipher_algo_name(enum rte_crypto_cipher_algorithm cipher_algo) -{ - switch (cipher_algo) { - case RTE_CRYPTO_CIPHER_NULL: return "NULL"; - case RTE_CRYPTO_CIPHER_3DES_CBC: return "3DES_CBC"; - case RTE_CRYPTO_CIPHER_3DES_CTR: return "3DES_CTR"; - case RTE_CRYPTO_CIPHER_3DES_ECB: return "3DES_ECB"; - case RTE_CRYPTO_CIPHER_AES_CBC: return "AES_CBC"; - case RTE_CRYPTO_CIPHER_AES_CCM: return "AES_CCM"; - case RTE_CRYPTO_CIPHER_AES_CTR: return "AES_CTR"; - case RTE_CRYPTO_CIPHER_AES_ECB: return "AES_ECB"; - case RTE_CRYPTO_CIPHER_AES_F8: return "AES_F8"; - case RTE_CRYPTO_CIPHER_AES_GCM: return "AES_GCM"; - case RTE_CRYPTO_CIPHER_AES_XTS: return "AES_XTS"; - case RTE_CRYPTO_CIPHER_ARC4: return "ARC4"; - case RTE_CRYPTO_CIPHER_KASUMI_F8: return "KASUMI_F8"; - case RTE_CRYPTO_CIPHER_SNOW3G_UEA2: return "SNOW3G_UEA2"; - case RTE_CRYPTO_CIPHER_ZUC_EEA3: return "ZUC_EEA3"; - default: return "Another cipher algo"; - } -} - -static const char *auth_algo_name(enum rte_crypto_auth_algorithm auth_algo) -{ - switch (auth_algo) { - case RTE_CRYPTO_AUTH_NULL: return "NULL"; break; - case RTE_CRYPTO_AUTH_AES_CBC_MAC: return "AES_CBC_MAC"; break; - case RTE_CRYPTO_AUTH_AES_CCM: return "AES_CCM"; break; - case RTE_CRYPTO_AUTH_AES_CMAC: return "AES_CMAC,"; break; - case RTE_CRYPTO_AUTH_AES_GCM: return "AES_GCM"; break; - case RTE_CRYPTO_AUTH_AES_GMAC: return "AES_GMAC"; break; - case RTE_CRYPTO_AUTH_AES_XCBC_MAC: return "AES_XCBC_MAC"; break; - case RTE_CRYPTO_AUTH_KASUMI_F9: return "KASUMI_F9"; break; - case RTE_CRYPTO_AUTH_MD5: return "MD5"; break; - case RTE_CRYPTO_AUTH_MD5_HMAC: return "MD5_HMAC,"; break; - case RTE_CRYPTO_AUTH_SHA1: return "SHA1"; break; - case RTE_CRYPTO_AUTH_SHA1_HMAC: return "SHA1_HMAC"; break; - case RTE_CRYPTO_AUTH_SHA224: return "SHA224"; break; - case RTE_CRYPTO_AUTH_SHA224_HMAC: return "SHA224_HMAC"; break; - case RTE_CRYPTO_AUTH_SHA256: return "SHA256"; break; - case RTE_CRYPTO_AUTH_SHA256_HMAC: return "SHA256_HMAC"; break; - case RTE_CRYPTO_AUTH_SHA384: return "SHA384,"; break; - case RTE_CRYPTO_AUTH_SHA384_HMAC: return "SHA384_HMAC,"; break; - case RTE_CRYPTO_AUTH_SHA512: return "SHA512,"; break; - case RTE_CRYPTO_AUTH_SHA512_HMAC: return "SHA512_HMAC,"; break; - case RTE_CRYPTO_AUTH_SNOW3G_UIA2: return "SNOW3G_UIA2"; break; - case RTE_CRYPTO_AUTH_ZUC_EIA3: return "RTE_CRYPTO_AUTH_ZUC_EIA3"; break; - default: return "Another auth algo"; break; - }; -} - static struct rte_mbuf * setup_test_string(struct rte_mempool *mpool, const uint8_t *data, size_t len, uint8_t blocksize) @@ -314,7 +274,8 @@ testsuite_setup(void) RTE_CRYPTO_OP_TYPE_SYMMETRIC, NUM_MBUFS, MBUF_CACHE_SIZE, DEFAULT_NUM_XFORMS * - sizeof(struct rte_crypto_sym_xform), + sizeof(struct rte_crypto_sym_xform) + + MAXIMUM_IV_LENGTH, rte_socket_id()); if (ts_params->op_mpool == NULL) { RTE_LOG(ERR, USER1, "Can't create CRYPTO_OP_POOL\n"); @@ -330,7 +291,7 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_MB_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL); TEST_ASSERT(ret == 0, @@ -348,7 +309,7 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_AESNI_GCM_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL); TEST_ASSERT(ret == 0, @@ -366,7 +327,7 @@ testsuite_setup(void) #endif nb_devs = rte_cryptodev_count_devtype(RTE_CRYPTODEV_SNOW3G_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL); TEST_ASSERT(ret == 0, @@ -385,7 +346,7 @@ testsuite_setup(void) nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_OPENSSL_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD), NULL); @@ -405,7 +366,7 @@ testsuite_setup(void) nb_devs = rte_cryptodev_count_devtype( RTE_CRYPTODEV_ARMV8_PMD); if (nb_devs < 1) { - ret = rte_eal_vdev_init( + ret = rte_vdev_init( RTE_STR(CRYPTODEV_NAME_ARMV8_PMD), NULL); @@ -1982,7 +1943,8 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num) ut_params->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_DECRYPT; ut_params->cipher_xform.cipher.key.data = aes_cbc_128_key; ut_params->cipher_xform.cipher.key.length = CIPHER_IV_LENGTH_AES_CBC; - + ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET; + ut_params->cipher_xform.cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; /* Setup HMAC Parameters */ ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; @@ -2025,21 +1987,14 @@ test_perf_crypto_qp_vary_burst_size(uint16_t dev_num) op->sym->auth.digest.data = ut_params->digest; op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_params[0].length); - op->sym->auth.digest.length = DIGEST_BYTE_LENGTH_SHA256; - op->sym->auth.data.offset = CIPHER_IV_LENGTH_AES_CBC; + op->sym->auth.data.offset = 0; op->sym->auth.data.length = data_params[0].length; + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + aes_cbc_128_iv, CIPHER_IV_LENGTH_AES_CBC); - op->sym->cipher.iv.data = (uint8_t *)rte_pktmbuf_prepend(m, - CIPHER_IV_LENGTH_AES_CBC); - op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m); - op->sym->cipher.iv.length = CIPHER_IV_LENGTH_AES_CBC; - - rte_memcpy(op->sym->cipher.iv.data, aes_cbc_128_iv, - CIPHER_IV_LENGTH_AES_CBC); - - op->sym->cipher.data.offset = CIPHER_IV_LENGTH_AES_CBC; + op->sym->cipher.data.offset = 0; op->sym->cipher.data.length = data_params[0].length; op->sym->m_src = m; @@ -2139,7 +2094,7 @@ test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams) /* Create Crypto session*/ sess = test_perf_create_snow3g_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate Crypto op data structure(s)*/ @@ -2154,20 +2109,28 @@ test_perf_snow3G_optimise_cyclecount(struct perf_test_params *pparams) RTE_CRYPTO_OP_TYPE_SYMMETRIC); TEST_ASSERT_NOT_NULL(op, "Failed to allocate op"); - op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size, - get_auth_digest_length(pparams->auth_algo)); + op = test_perf_set_crypto_op_snow3g(op, m, sess, pparams->buf_size); TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session"); c_ops[i] = op; } - printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, " + if (pparams->chain == AEAD) + printf("\nOn %s dev%u qp%u, %s, aead algo:%s, " "Packet Size %u bytes", pmd_name(gbl_cryptodev_perftest_devtype), ts_params->dev_id, 0, chain_mode_name(pparams->chain), - cipher_algo_name(pparams->cipher_algo), - auth_algo_name(pparams->auth_algo), + rte_crypto_aead_algorithm_strings[pparams->aead_algo], + pparams->buf_size); + else + printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, " + "Packet Size %u bytes", + pmd_name(gbl_cryptodev_perftest_devtype), + ts_params->dev_id, 0, + chain_mode_name(pparams->chain), + rte_crypto_cipher_algorithm_strings[pparams->cipher_algo], + rte_crypto_auth_algorithm_strings[pparams->auth_algo], pparams->buf_size); printf("\nOps Tx\tOps Rx\tOps/burst "); printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\tIACycles/Byte"); @@ -2251,14 +2214,14 @@ test_perf_snow3G_vary_burst_size(void) { .chain = CIPHER_ONLY, .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_NULL, }, { .chain = HASH_ONLY, .cipher_algo = RTE_CRYPTO_CIPHER_NULL, .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2, - .cipher_key_length = 16 + .key_length = 16 }, }; @@ -2304,11 +2267,9 @@ test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams) static struct rte_crypto_op *(*test_perf_set_crypto_op) (struct rte_crypto_op *, struct rte_mbuf *, struct rte_cryptodev_sym_session *, - unsigned int, unsigned int, + unsigned int, enum chain_mode); - unsigned int digest_length = get_auth_digest_length(pparams->auth_algo); - if (rte_cryptodev_count() == 0) { printf("\nNo crypto devices found. Is PMD build configured?\n"); return TEST_FAILED; @@ -2317,7 +2278,8 @@ test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams) /* Create Crypto session*/ sess = test_perf_create_openssl_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo, + pparams->aead_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate Crypto op data structure(s)*/ @@ -2332,38 +2294,49 @@ test_perf_openssl_optimise_cyclecount(struct perf_test_params *pparams) RTE_CRYPTO_OP_TYPE_SYMMETRIC); TEST_ASSERT_NOT_NULL(op, "Failed to allocate op"); - switch (pparams->cipher_algo) { - case RTE_CRYPTO_CIPHER_3DES_CBC: - case RTE_CRYPTO_CIPHER_3DES_CTR: - test_perf_set_crypto_op = test_perf_set_crypto_op_3des; - break; - case RTE_CRYPTO_CIPHER_AES_CBC: - case RTE_CRYPTO_CIPHER_AES_CTR: - test_perf_set_crypto_op = test_perf_set_crypto_op_aes; - break; - case RTE_CRYPTO_CIPHER_AES_GCM: + if (pparams->chain == AEAD) test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm; - break; - default: - return TEST_FAILED; + else { + switch (pparams->cipher_algo) { + case RTE_CRYPTO_CIPHER_3DES_CBC: + case RTE_CRYPTO_CIPHER_3DES_CTR: + test_perf_set_crypto_op = test_perf_set_crypto_op_3des; + break; + case RTE_CRYPTO_CIPHER_AES_CBC: + case RTE_CRYPTO_CIPHER_AES_CTR: + test_perf_set_crypto_op = test_perf_set_crypto_op_aes; + break; + default: + return TEST_FAILED; + } } op = test_perf_set_crypto_op(op, m, sess, pparams->buf_size, - digest_length, pparams->chain); + pparams->chain); TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session"); c_ops[i] = op; } - printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, cipher key length:%u, " - "auth_algo:%s, Packet Size %u bytes", + if (pparams->chain == AEAD) + printf("\nOn %s dev%u qp%u, %s, aead_algo:%s, " + "key length:%u, Packet Size %u bytes", pmd_name(gbl_cryptodev_perftest_devtype), ts_params->dev_id, 0, chain_mode_name(pparams->chain), - cipher_algo_name(pparams->cipher_algo), - pparams->cipher_key_length, - auth_algo_name(pparams->auth_algo), + rte_crypto_aead_algorithm_strings[pparams->aead_algo], + pparams->key_length, + pparams->buf_size); + else + printf("\nOn %s dev%u qp%u, %s, cipher algo:%s, auth_algo:%s, " + "key length:%u, Packet Size %u bytes", + pmd_name(gbl_cryptodev_perftest_devtype), + ts_params->dev_id, 0, + chain_mode_name(pparams->chain), + rte_crypto_cipher_algorithm_strings[pparams->cipher_algo], + rte_crypto_auth_algorithm_strings[pparams->auth_algo], + pparams->key_length, pparams->buf_size); printf("\nOps Tx\tOps Rx\tOps/burst "); printf("Retries EmptyPolls\tIACycles/CyOp\tIACycles/Burst\t" @@ -2459,8 +2432,6 @@ test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams) static struct rte_cryptodev_sym_session *sess; - unsigned int digest_length = get_auth_digest_length(pparams->auth_algo); - if (rte_cryptodev_count() == 0) { printf("\nNo crypto devices found. Is PMD build configured?\n"); return TEST_FAILED; @@ -2469,7 +2440,7 @@ test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams) /* Create Crypto session*/ sess = test_perf_create_armv8_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate Crypto op data structure(s)*/ @@ -2485,7 +2456,7 @@ test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams) TEST_ASSERT_NOT_NULL(op, "Failed to allocate op"); op = test_perf_set_crypto_op_aes(op, m, sess, pparams->buf_size, - digest_length, pparams->chain); + pparams->chain); TEST_ASSERT_NOT_NULL(op, "Failed to attach op to session"); c_ops[i] = op; @@ -2496,9 +2467,9 @@ test_perf_armv8_optimise_cyclecount(struct perf_test_params *pparams) pmd_name(gbl_cryptodev_perftest_devtype), ts_params->dev_id, 0, chain_mode_name(pparams->chain), - cipher_algo_name(pparams->cipher_algo), - pparams->cipher_key_length, - auth_algo_name(pparams->auth_algo), + rte_crypto_cipher_algorithm_strings[pparams->cipher_algo], + pparams->key_length, + rte_crypto_auth_algorithm_strings[pparams->auth_algo], pparams->buf_size); printf("\nOps Tx\tOps Rx\tOps/burst "); printf("Retries " @@ -2591,8 +2562,6 @@ static uint32_t get_auth_key_max_length(enum rte_crypto_auth_algorithm algo) return 128; case RTE_CRYPTO_AUTH_SHA512_HMAC: return 128; - case RTE_CRYPTO_AUTH_AES_GCM: - return 0; default: return 0; } @@ -2613,7 +2582,15 @@ static uint32_t get_auth_digest_length(enum rte_crypto_auth_algorithm algo) return TRUNCATED_DIGEST_BYTE_LENGTH_SHA384; case RTE_CRYPTO_AUTH_SHA512_HMAC: return TRUNCATED_DIGEST_BYTE_LENGTH_SHA512; - case RTE_CRYPTO_AUTH_AES_GCM: + default: + return 0; + } +} + +static uint32_t get_aead_digest_length(enum rte_crypto_aead_algorithm algo) +{ + switch (algo) { + case RTE_CRYPTO_AEAD_AES_GCM: return DIGEST_BYTE_LENGTH_AES_GCM; default: return 0; @@ -2632,6 +2609,11 @@ static uint8_t aes_iv[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; +static uint8_t aes_gcm_aad[] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; + static uint8_t triple_des_key[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, @@ -2693,6 +2675,8 @@ test_perf_create_aes_sha_session(uint8_t dev_id, enum chain_mode chain, cipher_xform.cipher.key.data = aes_key; cipher_xform.cipher.key.length = cipher_key_len; + cipher_xform.cipher.iv.offset = IV_OFFSET; + cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH; if (chain != CIPHER_ONLY) { /* Setup HMAC Parameters */ auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; @@ -2741,16 +2725,21 @@ test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain, cipher_xform.cipher.key.data = snow3g_cipher_key; cipher_xform.cipher.key.length = cipher_key_len; + cipher_xform.cipher.iv.offset = IV_OFFSET; + cipher_xform.cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH; + /* Setup HMAC Parameters */ auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; auth_xform.auth.algo = auth_algo; - auth_xform.auth.add_auth_data_length = SNOW3G_CIPHER_IV_LENGTH; auth_xform.auth.key.data = snow3g_hash_key; auth_xform.auth.key.length = get_auth_key_max_length(auth_algo); auth_xform.auth.digest_length = get_auth_digest_length(auth_algo); + /* Auth IV will be after cipher IV */ + auth_xform.auth.iv.offset = IV_OFFSET + SNOW3G_CIPHER_IV_LENGTH; + auth_xform.auth.iv.length = SNOW3G_CIPHER_IV_LENGTH; switch (chain) { case CIPHER_HASH: @@ -2779,51 +2768,73 @@ test_perf_create_snow3g_session(uint8_t dev_id, enum chain_mode chain, static struct rte_cryptodev_sym_session * test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain, enum rte_crypto_cipher_algorithm cipher_algo, - unsigned int cipher_key_len, - enum rte_crypto_auth_algorithm auth_algo) + unsigned int key_len, + enum rte_crypto_auth_algorithm auth_algo, + enum rte_crypto_aead_algorithm aead_algo) { struct rte_crypto_sym_xform cipher_xform = { 0 }; struct rte_crypto_sym_xform auth_xform = { 0 }; + struct rte_crypto_sym_xform aead_xform = { 0 }; - /* Setup Cipher Parameters */ - cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cipher_xform.cipher.algo = cipher_algo; - cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; + if (chain == CIPHER_HASH || chain == HASH_CIPHER) { + /* Setup Cipher Parameters */ + cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cipher_xform.cipher.algo = cipher_algo; + cipher_xform.cipher.iv.offset = IV_OFFSET; + cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - switch (cipher_algo) { - case RTE_CRYPTO_CIPHER_3DES_CBC: - case RTE_CRYPTO_CIPHER_3DES_CTR: - cipher_xform.cipher.key.data = triple_des_key; - break; - case RTE_CRYPTO_CIPHER_AES_CBC: - case RTE_CRYPTO_CIPHER_AES_CTR: - case RTE_CRYPTO_CIPHER_AES_GCM: - cipher_xform.cipher.key.data = aes_key; - break; - default: - return NULL; - } + switch (cipher_algo) { + case RTE_CRYPTO_CIPHER_3DES_CBC: + case RTE_CRYPTO_CIPHER_3DES_CTR: + cipher_xform.cipher.key.data = triple_des_key; + cipher_xform.cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH; + break; + case RTE_CRYPTO_CIPHER_AES_CBC: + case RTE_CRYPTO_CIPHER_AES_CTR: + cipher_xform.cipher.key.data = aes_key; + cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH; + break; + default: + return NULL; + } - cipher_xform.cipher.key.length = cipher_key_len; + cipher_xform.cipher.key.length = key_len; - /* Setup Auth Parameters */ - auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; - auth_xform.auth.algo = auth_algo; + /* Setup Auth Parameters */ + auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; + auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + auth_xform.auth.algo = auth_algo; - switch (auth_algo) { - case RTE_CRYPTO_AUTH_SHA1_HMAC: - auth_xform.auth.key.data = hmac_sha_key; - break; - case RTE_CRYPTO_AUTH_AES_GCM: - auth_xform.auth.key.data = NULL; - break; - default: - return NULL; - } + switch (auth_algo) { + case RTE_CRYPTO_AUTH_SHA1_HMAC: + auth_xform.auth.key.data = hmac_sha_key; + break; + default: + return NULL; + } - auth_xform.auth.key.length = get_auth_key_max_length(auth_algo); - auth_xform.auth.digest_length = get_auth_digest_length(auth_algo); + auth_xform.auth.key.length = get_auth_key_max_length(auth_algo); + auth_xform.auth.digest_length = get_auth_digest_length(auth_algo); + } else if (chain == AEAD) { + /* Setup AEAD Parameters */ + aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; + aead_xform.aead.op = RTE_CRYPTO_AEAD_OP_ENCRYPT; + aead_xform.aead.algo = aead_algo; + aead_xform.aead.iv.offset = IV_OFFSET; + + switch (aead_algo) { + case RTE_CRYPTO_AEAD_AES_GCM: + aead_xform.aead.key.data = aes_key; + aead_xform.aead.iv.length = AES_CIPHER_IV_LENGTH; + aead_xform.aead.add_auth_data_length = AES_GCM_AAD_LENGTH; + aead_xform.aead.digest_length = get_aead_digest_length(aead_algo); + break; + default: + return NULL; + } + + aead_xform.aead.key.length = key_len; + } switch (chain) { case CIPHER_HASH: @@ -2836,6 +2847,9 @@ test_perf_create_openssl_session(uint8_t dev_id, enum chain_mode chain, cipher_xform.next = NULL; /* Create Crypto session*/ return rte_cryptodev_sym_session_create(dev_id, &auth_xform); + case AEAD: + /* Create Crypto session*/ + return rte_cryptodev_sym_session_create(dev_id, &aead_xform); default: return NULL; } @@ -2863,6 +2877,8 @@ test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain, } cipher_xform.cipher.key.length = cipher_key_len; + cipher_xform.cipher.iv.offset = IV_OFFSET; + cipher_xform.cipher.iv.length = AES_CIPHER_IV_LENGTH; /* Setup Auth Parameters */ auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; @@ -2891,12 +2907,6 @@ test_perf_create_armv8_session(uint8_t dev_id, enum chain_mode chain, } } -#define AES_BLOCK_SIZE 16 -#define AES_CIPHER_IV_LENGTH 16 - -#define TRIPLE_DES_BLOCK_SIZE 8 -#define TRIPLE_DES_CIPHER_IV_LENGTH 8 - static struct rte_mbuf * test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz) { @@ -2915,7 +2925,7 @@ test_perf_create_pktmbuf(struct rte_mempool *mpool, unsigned buf_sz) static inline struct rte_crypto_op * test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain) + enum chain_mode chain) { if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); @@ -2926,32 +2936,24 @@ test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m, if (chain == CIPHER_ONLY) { op->sym->auth.digest.data = NULL; op->sym->auth.digest.phys_addr = 0; - op->sym->auth.digest.length = 0; - op->sym->auth.aad.data = NULL; - op->sym->auth.aad.length = 0; op->sym->auth.data.offset = 0; op->sym->auth.data.length = 0; } else { op->sym->auth.digest.data = rte_pktmbuf_mtod_offset(m, - uint8_t *, AES_CIPHER_IV_LENGTH + data_len); + uint8_t *, data_len); op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, - AES_CIPHER_IV_LENGTH + data_len); - op->sym->auth.digest.length = digest_len; - op->sym->auth.aad.data = aes_iv; - op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH; - op->sym->auth.data.offset = AES_CIPHER_IV_LENGTH; + data_len); + op->sym->auth.data.offset = 0; op->sym->auth.data.length = data_len; } - /* Cipher Parameters */ - op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *); - op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m); - op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH; + /* Copy the IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + aes_iv, AES_CIPHER_IV_LENGTH); - rte_memcpy(op->sym->cipher.iv.data, aes_iv, AES_CIPHER_IV_LENGTH); - - op->sym->cipher.data.offset = AES_CIPHER_IV_LENGTH; + /* Cipher Parameters */ + op->sym->cipher.data.offset = 0; op->sym->cipher.data.length = data_len; op->sym->m_src = m; @@ -2962,7 +2964,7 @@ test_perf_set_crypto_op_aes(struct rte_crypto_op *op, struct rte_mbuf *m, static inline struct rte_crypto_op * test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain __rte_unused) + enum chain_mode chain __rte_unused) { if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); @@ -2970,24 +2972,19 @@ test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m, } /* Authentication Parameters */ - op->sym->auth.digest.data = (uint8_t *)m->buf_addr + + op->sym->aead.digest.data = (uint8_t *)m->buf_addr + (m->data_off + data_len); - op->sym->auth.digest.phys_addr = + op->sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len); - op->sym->auth.digest.length = digest_len; - op->sym->auth.aad.data = aes_iv; - op->sym->auth.aad.length = AES_CIPHER_IV_LENGTH; + op->sym->aead.aad.data = aes_gcm_aad; - /* Cipher Parameters */ - op->sym->cipher.iv.data = aes_iv; - op->sym->cipher.iv.length = AES_CIPHER_IV_LENGTH; + /* Copy IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + aes_iv, AES_CIPHER_IV_LENGTH); /* Data lengths/offsets Parameters */ - op->sym->auth.data.offset = AES_BLOCK_SIZE; - op->sym->auth.data.length = data_len - AES_BLOCK_SIZE; - - op->sym->cipher.data.offset = AES_BLOCK_SIZE; - op->sym->cipher.data.length = data_len - AES_BLOCK_SIZE; + op->sym->aead.data.offset = 0; + op->sym->aead.data.length = data_len; op->sym->m_src = m; @@ -2996,26 +2993,23 @@ test_perf_set_crypto_op_aes_gcm(struct rte_crypto_op *op, struct rte_mbuf *m, static inline struct rte_crypto_op * test_perf_set_crypto_op_snow3g(struct rte_crypto_op *op, struct rte_mbuf *m, - struct rte_cryptodev_sym_session *sess, unsigned data_len, - unsigned digest_len) + struct rte_cryptodev_sym_session *sess, unsigned int data_len) { + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op, + uint8_t *, IV_OFFSET); + if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); return NULL; } + rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH); + /* Authentication Parameters */ op->sym->auth.digest.data = (uint8_t *)m->buf_addr + (m->data_off + data_len); op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len); - op->sym->auth.digest.length = digest_len; - op->sym->auth.aad.data = snow3g_iv; - op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH; - - /* Cipher Parameters */ - op->sym->cipher.iv.data = snow3g_iv; - op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH; /* Data lengths/offsets Parameters */ op->sym->auth.data.offset = 0; @@ -3040,15 +3034,18 @@ test_perf_set_crypto_op_snow3g_cipher(struct rte_crypto_op *op, return NULL; } - /* Cipher Parameters */ - op->sym->cipher.iv.data = rte_pktmbuf_mtod(m, uint8_t *); - op->sym->cipher.iv.length = SNOW3G_CIPHER_IV_LENGTH; - rte_memcpy(op->sym->cipher.iv.data, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH); - op->sym->cipher.iv.phys_addr = rte_pktmbuf_mtophys(m); + /* Copy IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + snow3g_iv, SNOW3G_CIPHER_IV_LENGTH); - op->sym->cipher.data.offset = SNOW3G_CIPHER_IV_LENGTH; + /* Cipher Parameters */ + op->sym->cipher.data.offset = 0; op->sym->cipher.data.length = data_len << 3; + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + snow3g_iv, + SNOW3G_CIPHER_IV_LENGTH); + op->sym->m_src = m; return op; @@ -3059,14 +3056,18 @@ static inline struct rte_crypto_op * test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, - unsigned data_len, - unsigned digest_len) + unsigned int data_len) { + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op, + uint8_t *, IV_OFFSET); + if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); return NULL; } + rte_memcpy(iv_ptr, snow3g_iv, SNOW3G_CIPHER_IV_LENGTH); + /* Authentication Parameters */ op->sym->auth.digest.data = @@ -3075,15 +3076,9 @@ test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op, op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len + SNOW3G_CIPHER_IV_LENGTH); - op->sym->auth.digest.length = digest_len; - op->sym->auth.aad.data = rte_pktmbuf_mtod(m, uint8_t *); - op->sym->auth.aad.length = SNOW3G_CIPHER_IV_LENGTH; - rte_memcpy(op->sym->auth.aad.data, snow3g_iv, - SNOW3G_CIPHER_IV_LENGTH); - op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys(m); /* Data lengths/offsets Parameters */ - op->sym->auth.data.offset = SNOW3G_CIPHER_IV_LENGTH; + op->sym->auth.data.offset = 0; op->sym->auth.data.length = data_len << 3; op->sym->m_src = m; @@ -3095,7 +3090,7 @@ test_perf_set_crypto_op_snow3g_hash(struct rte_crypto_op *op, static inline struct rte_crypto_op * test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m, struct rte_cryptodev_sym_session *sess, unsigned int data_len, - unsigned int digest_len, enum chain_mode chain __rte_unused) + enum chain_mode chain __rte_unused) { if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); @@ -3107,20 +3102,17 @@ test_perf_set_crypto_op_3des(struct rte_crypto_op *op, struct rte_mbuf *m, (m->data_off + data_len); op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, data_len); - op->sym->auth.digest.length = digest_len; - op->sym->auth.aad.data = triple_des_iv; - op->sym->auth.aad.length = TRIPLE_DES_CIPHER_IV_LENGTH; - /* Cipher Parameters */ - op->sym->cipher.iv.data = triple_des_iv; - op->sym->cipher.iv.length = TRIPLE_DES_CIPHER_IV_LENGTH; + /* Copy IV at the end of the crypto operation */ + rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET), + triple_des_iv, TRIPLE_DES_CIPHER_IV_LENGTH); /* Data lengths/offsets Parameters */ op->sym->auth.data.offset = 0; op->sym->auth.data.length = data_len; - op->sym->cipher.data.offset = TRIPLE_DES_BLOCK_SIZE; - op->sym->cipher.data.length = data_len - TRIPLE_DES_BLOCK_SIZE; + op->sym->cipher.data.offset = 0; + op->sym->cipher.data.length = data_len; op->sym->m_src = m; @@ -3163,7 +3155,7 @@ test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id, /* Create Crypto session*/ sess = test_perf_create_aes_sha_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate a burst of crypto operations */ @@ -3179,10 +3171,9 @@ test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id, return -1; } - /* Make room for Digest and IV in mbuf */ + /* Make room for Digest in mbuf */ if (pparams->chain != CIPHER_ONLY) rte_pktmbuf_append(mbufs[i], digest_length); - rte_pktmbuf_prepend(mbufs[i], AES_CIPHER_IV_LENGTH); } @@ -3203,7 +3194,7 @@ test_perf_aes_sha(uint8_t dev_id, uint16_t queue_id, ops[i] = test_perf_set_crypto_op_aes(ops[i], mbufs[i + (pparams->burst_size * (j % NUM_MBUF_SETS))], - sess, pparams->buf_size, digest_length, + sess, pparams->buf_size, pparams->chain); /* enqueue burst */ @@ -3297,18 +3288,18 @@ test_perf_snow3g(uint8_t dev_id, uint16_t queue_id, /* Create Crypto session*/ sess = test_perf_create_snow3g_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate a burst of crypto operations */ for (i = 0; i < (pparams->burst_size * NUM_MBUF_SETS); i++) { /* - * Buffer size + iv/aad len is allocated, for perf tests they + * Buffer size is allocated, for perf tests they * are equal + digest len. */ mbufs[i] = test_perf_create_pktmbuf( ts_params->mbuf_mp, - pparams->buf_size + SNOW3G_CIPHER_IV_LENGTH + + pparams->buf_size + digest_length); if (mbufs[i] == NULL) { @@ -3345,7 +3336,7 @@ test_perf_snow3g(uint8_t dev_id, uint16_t queue_id, mbufs[i + (pparams->burst_size * (j % NUM_MBUF_SETS))], sess, - pparams->buf_size, digest_length); + pparams->buf_size); else if (pparams->chain == CIPHER_ONLY) ops[i+op_offset] = test_perf_set_crypto_op_snow3g_cipher(ops[i+op_offset], @@ -3441,8 +3432,6 @@ test_perf_openssl(uint8_t dev_id, uint16_t queue_id, uint64_t processed = 0, failed_polls = 0, retries = 0; uint64_t tsc_start = 0, tsc_end = 0; - unsigned int digest_length = get_auth_digest_length(pparams->auth_algo); - struct rte_crypto_op *ops[pparams->burst_size]; struct rte_crypto_op *proc_ops[pparams->burst_size]; @@ -3455,23 +3444,25 @@ test_perf_openssl(uint8_t dev_id, uint16_t queue_id, static struct rte_crypto_op *(*test_perf_set_crypto_op) (struct rte_crypto_op *, struct rte_mbuf *, struct rte_cryptodev_sym_session *, - unsigned int, unsigned int, + unsigned int, enum chain_mode); - switch (pparams->cipher_algo) { - case RTE_CRYPTO_CIPHER_3DES_CBC: - case RTE_CRYPTO_CIPHER_3DES_CTR: - test_perf_set_crypto_op = test_perf_set_crypto_op_3des; - break; - case RTE_CRYPTO_CIPHER_AES_CBC: - case RTE_CRYPTO_CIPHER_AES_CTR: - test_perf_set_crypto_op = test_perf_set_crypto_op_aes; - break; - case RTE_CRYPTO_CIPHER_AES_GCM: - test_perf_set_crypto_op = test_perf_set_crypto_op_aes_gcm; - break; - default: - return TEST_FAILED; + if (pparams->chain == AEAD) + test_perf_set_crypto_op = + test_perf_set_crypto_op_aes_gcm; + else { + switch (pparams->cipher_algo) { + case RTE_CRYPTO_CIPHER_3DES_CBC: + case RTE_CRYPTO_CIPHER_3DES_CTR: + test_perf_set_crypto_op = test_perf_set_crypto_op_3des; + break; + case RTE_CRYPTO_CIPHER_AES_CBC: + case RTE_CRYPTO_CIPHER_AES_CTR: + test_perf_set_crypto_op = test_perf_set_crypto_op_aes; + break; + default: + return TEST_FAILED; + } } if (rte_cryptodev_count() == 0) { @@ -3482,7 +3473,8 @@ test_perf_openssl(uint8_t dev_id, uint16_t queue_id, /* Create Crypto session*/ sess = test_perf_create_openssl_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo, + pparams->aead_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate a burst of crypto operations */ @@ -3517,7 +3509,7 @@ test_perf_openssl(uint8_t dev_id, uint16_t queue_id, ops[i] = test_perf_set_crypto_op(ops[i], mbufs[i + (pparams->burst_size * (j % NUM_MBUF_SETS))], - sess, pparams->buf_size, digest_length, + sess, pparams->buf_size, pparams->chain); /* enqueue burst */ @@ -3595,8 +3587,6 @@ test_perf_armv8(uint8_t dev_id, uint16_t queue_id, uint64_t processed = 0, failed_polls = 0, retries = 0; uint64_t tsc_start = 0, tsc_end = 0; - unsigned int digest_length = get_auth_digest_length(pparams->auth_algo); - struct rte_crypto_op *ops[pparams->burst_size]; struct rte_crypto_op *proc_ops[pparams->burst_size]; @@ -3614,7 +3604,7 @@ test_perf_armv8(uint8_t dev_id, uint16_t queue_id, /* Create Crypto session*/ sess = test_perf_create_armv8_session(ts_params->dev_id, pparams->chain, pparams->cipher_algo, - pparams->cipher_key_length, pparams->auth_algo); + pparams->key_length, pparams->auth_algo); TEST_ASSERT_NOT_NULL(sess, "Session creation failed"); /* Generate a burst of crypto operations */ @@ -3651,7 +3641,7 @@ test_perf_armv8(uint8_t dev_id, uint16_t queue_id, ops[i] = test_perf_set_crypto_op_aes(ops[i], mbufs[i + (pparams->burst_size * (j % NUM_MBUF_SETS))], sess, - pparams->buf_size, digest_length, + pparams->buf_size, pparams->chain); /* enqueue burst */ @@ -3740,48 +3730,48 @@ test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void) { .chain = CIPHER_ONLY, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_NULL }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 32, + .key_length = 32, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 32, + .key_length = 32, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 32, + .key_length = 32, .auth_algo = RTE_CRYPTO_AUTH_SHA512_HMAC }, }; @@ -3791,12 +3781,12 @@ test_perf_aes_cbc_encrypt_digest_vary_pkt_size(void) params_set[i].total_operations = total_operations; params_set[i].burst_size = burst_size; printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u." - " burst_size: %d ops\n", - chain_mode_name(params_set[i].chain), - cipher_algo_name(params_set[i].cipher_algo), - auth_algo_name(params_set[i].auth_algo), - params_set[i].cipher_key_length, - burst_size); + " burst_size: %d ops\n", + chain_mode_name(params_set[i].chain), + rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo], + rte_crypto_auth_algorithm_strings[params_set[i].auth_algo], + params_set[i].key_length, + burst_size); printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t" "Retries\tEmptyPolls\n"); for (j = 0; j < RTE_DIM(buf_lengths); j++) { @@ -3821,14 +3811,14 @@ test_perf_snow3G_vary_pkt_size(void) { .chain = CIPHER_ONLY, .cipher_algo = RTE_CRYPTO_CIPHER_SNOW3G_UEA2, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_NULL, }, { .chain = HASH_ONLY, .cipher_algo = RTE_CRYPTO_CIPHER_NULL, .auth_algo = RTE_CRYPTO_AUTH_SNOW3G_UIA2, - .cipher_key_length = 16 + .key_length = 16 }, }; @@ -3841,13 +3831,17 @@ test_perf_snow3G_vary_pkt_size(void) printf("\n\n"); params_set[i].total_operations = total_operations; for (k = 0; k < RTE_DIM(burst_sizes); k++) { + enum rte_crypto_cipher_algorithm cipher_algo = + params_set[i].cipher_algo; + enum rte_crypto_auth_algorithm auth_algo = + params_set[i].auth_algo; printf("\nOn %s dev%u qp%u, %s, " "cipher algo:%s, auth algo:%s, burst_size: %d ops", pmd_name(gbl_cryptodev_perftest_devtype), testsuite_params.dev_id, 0, chain_mode_name(params_set[i].chain), - cipher_algo_name(params_set[i].cipher_algo), - auth_algo_name(params_set[i].auth_algo), + rte_crypto_cipher_algorithm_strings[cipher_algo], + rte_crypto_auth_algorithm_strings[auth_algo], burst_sizes[k]); params_set[i].burst_size = burst_sizes[k]; @@ -3879,63 +3873,77 @@ test_perf_openssl_vary_pkt_size(void) .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC, - .cipher_key_length = 24, + .key_length = 24, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR, - .cipher_key_length = 32, + .key_length = 32, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR, - .cipher_key_length = 24, + .key_length = 24, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { - .chain = CIPHER_HASH, + .chain = AEAD, - .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM, - .cipher_key_length = 16, - .auth_algo = RTE_CRYPTO_AUTH_AES_GCM + .aead_algo = RTE_CRYPTO_AEAD_AES_GCM, + .key_length = 16, }, }; for (i = 0; i < RTE_DIM(params_set); i++) { params_set[i].total_operations = total_operations; params_set[i].burst_size = burst_size; - printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u." + if (params_set[i].chain == AEAD) { + enum rte_crypto_aead_algorithm aead_algo = + params_set[i].aead_algo; + printf("\n%s. aead algo: %s key size=%u." + " burst_size: %d ops\n", + chain_mode_name(params_set[i].chain), + rte_crypto_aead_algorithm_strings[aead_algo], + params_set[i].key_length, + burst_size); + } else { + enum rte_crypto_cipher_algorithm cipher_algo = + params_set[i].cipher_algo; + enum rte_crypto_auth_algorithm auth_algo = + params_set[i].auth_algo; + printf("\n%s. cipher algo: %s auth algo: %s key size=%u." " burst_size: %d ops\n", chain_mode_name(params_set[i].chain), - cipher_algo_name(params_set[i].cipher_algo), - auth_algo_name(params_set[i].auth_algo), - params_set[i].cipher_key_length, + rte_crypto_cipher_algorithm_strings[cipher_algo], + rte_crypto_auth_algorithm_strings[auth_algo], + params_set[i].key_length, burst_size); + } printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t" "EmptyPolls\n"); for (j = 0; j < RTE_DIM(buf_lengths); j++) { @@ -3960,50 +3968,49 @@ test_perf_openssl_vary_burst_size(void) .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CBC, - .cipher_key_length = 24, + .key_length = 24, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CTR, - .cipher_key_length = 32, + .key_length = 32, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_3DES_CTR, - .cipher_key_length = 24, + .key_length = 24, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { - .chain = CIPHER_HASH, + .chain = AEAD, - .cipher_algo = RTE_CRYPTO_CIPHER_AES_GCM, - .cipher_key_length = 16, - .auth_algo = RTE_CRYPTO_AUTH_AES_GCM + .aead_algo = RTE_CRYPTO_AEAD_AES_GCM, + .key_length = 16, }, }; @@ -4040,28 +4047,28 @@ test_perf_armv8_vary_pkt_size(void) .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = HASH_CIPHER, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, { .chain = HASH_CIPHER, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, }; @@ -4070,12 +4077,12 @@ test_perf_armv8_vary_pkt_size(void) params_set[i].total_operations = total_operations; params_set[i].burst_size = burst_size; printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u." - " burst_size: %d ops\n", - chain_mode_name(params_set[i].chain), - cipher_algo_name(params_set[i].cipher_algo), - auth_algo_name(params_set[i].auth_algo), - params_set[i].cipher_key_length, - burst_size); + " burst_size: %d ops\n", + chain_mode_name(params_set[i].chain), + rte_crypto_cipher_algorithm_strings[params_set[i].cipher_algo], + rte_crypto_auth_algorithm_strings[params_set[i].auth_algo], + params_set[i].key_length, + burst_size); printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\tRetries\t" "EmptyPolls\n"); for (j = 0; j < RTE_DIM(buf_lengths); j++) { @@ -4100,28 +4107,28 @@ test_perf_armv8_vary_burst_size(void) .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = HASH_CIPHER, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }, { .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, { .chain = HASH_CIPHER, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA256_HMAC }, }; @@ -4156,45 +4163,26 @@ static struct rte_cryptodev_sym_session * test_perf_create_session(uint8_t dev_id, struct perf_test_params *pparams) { static struct rte_cryptodev_sym_session *sess; - struct rte_crypto_sym_xform cipher_xform = { 0 }; - struct rte_crypto_sym_xform auth_xform = { 0 }; + struct rte_crypto_sym_xform aead_xform = { 0 }; - uint8_t cipher_key[pparams->session_attrs->key_cipher_len]; - uint8_t auth_key[pparams->session_attrs->key_auth_len]; + uint8_t aead_key[pparams->session_attrs->key_aead_len]; - memcpy(cipher_key, pparams->session_attrs->key_cipher_data, - pparams->session_attrs->key_cipher_len); - memcpy(auth_key, pparams->session_attrs->key_auth_data, - pparams->session_attrs->key_auth_len); + memcpy(aead_key, pparams->session_attrs->key_aead_data, + pparams->session_attrs->key_aead_len); - cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cipher_xform.next = NULL; - - cipher_xform.cipher.algo = pparams->session_attrs->cipher_algorithm; - cipher_xform.cipher.op = pparams->session_attrs->cipher; - cipher_xform.cipher.key.data = cipher_key; - cipher_xform.cipher.key.length = pparams->session_attrs->key_cipher_len; - - auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; - auth_xform.next = NULL; + aead_xform.type = RTE_CRYPTO_SYM_XFORM_AEAD; + aead_xform.next = NULL; - auth_xform.auth.op = pparams->session_attrs->auth; - auth_xform.auth.algo = pparams->session_attrs->auth_algorithm; + aead_xform.aead.algo = pparams->session_attrs->aead_algorithm; + aead_xform.aead.op = pparams->session_attrs->aead; + aead_xform.aead.key.data = aead_key; + aead_xform.aead.key.length = pparams->session_attrs->key_aead_len; + aead_xform.aead.iv.length = pparams->session_attrs->iv_len; + aead_xform.aead.iv.offset = IV_OFFSET; + aead_xform.aead.add_auth_data_length = pparams->session_attrs->aad_len; + aead_xform.aead.digest_length = pparams->session_attrs->digest_len; - auth_xform.auth.digest_length = pparams->session_attrs->digest_len; - auth_xform.auth.key.length = pparams->session_attrs->key_auth_len; - - - cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; - if (cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) { - cipher_xform.next = &auth_xform; - sess = rte_cryptodev_sym_session_create(dev_id, - &cipher_xform); - } else { - auth_xform.next = &cipher_xform; - sess = rte_cryptodev_sym_session_create(dev_id, - &auth_xform); - } + sess = rte_cryptodev_sym_session_create(dev_id, &aead_xform); return sess; } @@ -4205,47 +4193,35 @@ perf_gcm_set_crypto_op(struct rte_crypto_op *op, struct rte_mbuf *m, struct crypto_params *m_hlp, struct perf_test_params *params) { + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op, + uint8_t *, IV_OFFSET); + if (rte_crypto_op_attach_sym_session(op, sess) != 0) { rte_crypto_op_free(op); return NULL; } - uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, - 16); - - op->sym->auth.digest.data = m_hlp->digest; - op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset( + op->sym->aead.digest.data = m_hlp->digest; + op->sym->aead.digest.phys_addr = rte_pktmbuf_mtophys_offset( m, - params->symmetric_op->aad_len + - iv_pad_len + + params->session_attrs->aad_len + params->symmetric_op->p_len); - op->sym->auth.digest.length = params->symmetric_op->t_len; - op->sym->auth.aad.data = m_hlp->aad; - op->sym->auth.aad.length = params->symmetric_op->aad_len; - op->sym->auth.aad.phys_addr = rte_pktmbuf_mtophys_offset( - m, - iv_pad_len); + op->sym->aead.aad.data = m_hlp->aad; + op->sym->aead.aad.phys_addr = rte_pktmbuf_mtophys(m); - rte_memcpy(op->sym->auth.aad.data, params->symmetric_op->aad_data, - params->symmetric_op->aad_len); + rte_memcpy(op->sym->aead.aad.data, params->symmetric_op->aad_data, + params->session_attrs->aad_len); - op->sym->cipher.iv.data = m_hlp->iv; - rte_memcpy(op->sym->cipher.iv.data, params->symmetric_op->iv_data, - params->symmetric_op->iv_len); - if (params->symmetric_op->iv_len == 12) - op->sym->cipher.iv.data[15] = 1; + rte_memcpy(iv_ptr, params->session_attrs->iv_data, + params->session_attrs->iv_len); + if (params->session_attrs->iv_len == 12) + iv_ptr[15] = 1; - op->sym->cipher.iv.length = params->symmetric_op->iv_len; - - op->sym->auth.data.offset = - iv_pad_len + params->symmetric_op->aad_len; - op->sym->auth.data.length = params->symmetric_op->p_len; - - op->sym->cipher.data.offset = - iv_pad_len + params->symmetric_op->aad_len; - op->sym->cipher.data.length = params->symmetric_op->p_len; + op->sym->aead.data.offset = + params->session_attrs->aad_len; + op->sym->aead.data.length = params->symmetric_op->p_len; op->sym->m_src = m; @@ -4258,9 +4234,7 @@ test_perf_create_pktmbuf_fill(struct rte_mempool *mpool, unsigned buf_sz, struct crypto_params *m_hlp) { struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); - uint16_t iv_pad_len = - ALIGN_POW2_ROUNDUP(params->symmetric_op->iv_len, 16); - uint16_t aad_len = params->symmetric_op->aad_len; + uint16_t aad_len = params->session_attrs->aad_len; uint16_t digest_size = params->symmetric_op->t_len; char *p; @@ -4271,13 +4245,6 @@ test_perf_create_pktmbuf_fill(struct rte_mempool *mpool, } m_hlp->aad = (uint8_t *)p; - p = rte_pktmbuf_append(m, iv_pad_len); - if (p == NULL) { - rte_pktmbuf_free(m); - return NULL; - } - m_hlp->iv = (uint8_t *)p; - p = rte_pktmbuf_append(m, buf_sz); if (p == NULL) { rte_pktmbuf_free(m); @@ -4396,23 +4363,21 @@ perf_AES_GCM(uint8_t dev_id, uint16_t queue_id, for (m = 0; m < burst_dequeued; m++) { if (test_ops) { - uint16_t iv_pad_len = ALIGN_POW2_ROUNDUP - (pparams->symmetric_op->iv_len, 16); uint8_t *pkt = rte_pktmbuf_mtod( proc_ops[m]->sym->m_src, uint8_t *); TEST_ASSERT_BUFFERS_ARE_EQUAL( pparams->symmetric_op->c_data, - pkt + iv_pad_len + - pparams->symmetric_op->aad_len, + pkt + + pparams->session_attrs->aad_len, pparams->symmetric_op->c_len, "GCM Ciphertext data not as expected"); TEST_ASSERT_BUFFERS_ARE_EQUAL( pparams->symmetric_op->t_data, - pkt + iv_pad_len + - pparams->symmetric_op->aad_len + + pkt + + pparams->session_attrs->aad_len + pparams->symmetric_op->c_len, pparams->symmetric_op->t_len, "GCM MAC data not as expected"); @@ -4470,27 +4435,21 @@ test_perf_AES_GCM(int continual_buf_len, int continual_size) gcm_test = gcm_tests[i]; - session_attrs[i].cipher = - RTE_CRYPTO_CIPHER_OP_ENCRYPT; - session_attrs[i].cipher_algorithm = - RTE_CRYPTO_CIPHER_AES_GCM; - session_attrs[i].key_cipher_data = + session_attrs[i].aead = + RTE_CRYPTO_AEAD_OP_ENCRYPT; + session_attrs[i].aead_algorithm = + RTE_CRYPTO_AEAD_AES_GCM; + session_attrs[i].key_aead_data = gcm_test->key.data; - session_attrs[i].key_cipher_len = + session_attrs[i].key_aead_len = gcm_test->key.len; - session_attrs[i].auth_algorithm = - RTE_CRYPTO_AUTH_AES_GCM; - session_attrs[i].auth = - RTE_CRYPTO_AUTH_OP_GENERATE; - session_attrs[i].key_auth_data = NULL; - session_attrs[i].key_auth_len = 0; + session_attrs[i].aad_len = gcm_test->aad.len; session_attrs[i].digest_len = gcm_test->auth_tag.len; + session_attrs[i].iv_len = gcm_test->iv.len; + session_attrs[i].iv_data = gcm_test->iv.data; ops_set[i].aad_data = gcm_test->aad.data; - ops_set[i].aad_len = gcm_test->aad.len; - ops_set[i].iv_data = gcm_test->iv.data; - ops_set[i].iv_len = gcm_test->iv.len; ops_set[i].p_data = gcm_test->plaintext.data; ops_set[i].p_len = buf_lengths[i]; ops_set[i].c_data = gcm_test->ciphertext.data; @@ -4498,7 +4457,7 @@ test_perf_AES_GCM(int continual_buf_len, int continual_size) ops_set[i].t_data = gcm_test->auth_tags[i].data; ops_set[i].t_len = gcm_test->auth_tags[i].len; - params_set[i].chain = CIPHER_HASH; + params_set[i].chain = AEAD; params_set[i].session_attrs = &session_attrs[i]; params_set[i].symmetric_op = &ops_set[i]; if (continual_buf_len) @@ -4600,18 +4559,18 @@ test_perf_continual_performance_test(void) .chain = CIPHER_HASH, .cipher_algo = RTE_CRYPTO_CIPHER_AES_CBC, - .cipher_key_length = 16, + .key_length = 16, .auth_algo = RTE_CRYPTO_AUTH_SHA1_HMAC }; for (i = 1; i <= total_loops; ++i) { printf("\n%s. cipher algo: %s auth algo: %s cipher key size=%u." - " burst_size: %d ops\n", - chain_mode_name(params_set.chain), - cipher_algo_name(params_set.cipher_algo), - auth_algo_name(params_set.auth_algo), - params_set.cipher_key_length, - burst_size); + " burst_size: %d ops\n", + chain_mode_name(params_set.chain), + rte_crypto_cipher_algorithm_strings[params_set.cipher_algo], + rte_crypto_auth_algorithm_strings[params_set.auth_algo], + params_set.key_length, + burst_size); printf("\nBuffer Size(B)\tOPS(M)\tThroughput(Gbps)\t" "Retries\tEmptyPolls\n"); test_perf_aes_sha(testsuite_params.dev_id, 0, @@ -4649,6 +4608,17 @@ static struct unit_test_suite cryptodev_testsuite = { } }; +static struct unit_test_suite cryptodev_dpaa2_sec_testsuite = { + .suite_name = "Crypto Device DPAA2_SEC Unit Test Suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(ut_setup, ut_teardown, + test_perf_aes_cbc_encrypt_digest_vary_pkt_size), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + static struct unit_test_suite cryptodev_gcm_testsuite = { .suite_name = "Crypto Device AESNI GCM Unit Test Suite", .setup = testsuite_setup, @@ -4774,6 +4744,14 @@ perftest_sw_armv8_cryptodev(void /*argv __rte_unused, int argc __rte_unused*/) return unit_test_suite_runner(&cryptodev_armv8_testsuite); } +static int +perftest_dpaa2_sec_cryptodev(void) +{ + gbl_cryptodev_perftest_devtype = RTE_CRYPTODEV_DPAA2_SEC_PMD; + + return unit_test_suite_runner(&cryptodev_dpaa2_sec_testsuite); +} + REGISTER_TEST_COMMAND(cryptodev_aesni_mb_perftest, perftest_aesni_mb_cryptodev); REGISTER_TEST_COMMAND(cryptodev_qat_perftest, perftest_qat_cryptodev); REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_perftest, perftest_sw_snow3g_cryptodev); @@ -4785,3 +4763,5 @@ REGISTER_TEST_COMMAND(cryptodev_qat_continual_perftest, perftest_qat_continual_cryptodev); REGISTER_TEST_COMMAND(cryptodev_sw_armv8_perftest, perftest_sw_armv8_cryptodev); +REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_perftest, + perftest_dpaa2_sec_cryptodev);