test/crypto: add UDP-encapsulated IPsec cases

[dpdk.git] / app / test-crypto-perf / main.c

diff --git a/app/test-crypto-perf/main.c b/app/test-crypto-perf/main.c
index b9325d3..3903808 100644 (file)
--- a/app/test-crypto-perf/main.c
+++ b/app/test-crypto-perf/main.c
@@ -40,7 +40,8 @@ const char *cperf_op_type_strs[] = {
        [CPERF_AUTH_THEN_CIPHER] = "auth-then-cipher",
        [CPERF_AEAD] = "aead",
        [CPERF_PDCP] = "pdcp",
-       [CPERF_DOCSIS] = "docsis"
+       [CPERF_DOCSIS] = "docsis",
+       [CPERF_ASYM_MODEX] = "modex"
 };
 
 const struct cperf_test cperf_testmap[] = {
@@ -66,6 +67,50 @@ const struct cperf_test cperf_testmap[] = {
                }
 };
 
+static int
+create_asym_op_pool_socket(uint8_t dev_id, int32_t socket_id,
+                          uint32_t nb_sessions)
+{
+       char mp_name[RTE_MEMPOOL_NAMESIZE];
+       struct rte_mempool *mpool = NULL;
+       unsigned int session_size =
+               RTE_MAX(rte_cryptodev_asym_get_private_session_size(dev_id),
+                       rte_cryptodev_asym_get_header_session_size());
+
+       if (session_pool_socket[socket_id].priv_mp == NULL) {
+               snprintf(mp_name, RTE_MEMPOOL_NAMESIZE, "perf_asym_priv_pool%u",
+                        socket_id);
+
+               mpool = rte_mempool_create(mp_name, nb_sessions, session_size,
+                                          0, 0, NULL, NULL, NULL, NULL,
+                                          socket_id, 0);
+               if (mpool == NULL) {
+                       printf("Cannot create pool \"%s\" on socket %d\n",
+                              mp_name, socket_id);
+                       return -ENOMEM;
+               }
+               printf("Allocated pool \"%s\" on socket %d\n", mp_name,
+                      socket_id);
+               session_pool_socket[socket_id].priv_mp = mpool;
+       }
+
+       if (session_pool_socket[socket_id].sess_mp == NULL) {
+
+               snprintf(mp_name, RTE_MEMPOOL_NAMESIZE, "perf_asym_sess_pool%u",
+                        socket_id);
+               mpool = rte_mempool_create(mp_name, nb_sessions,
+                                          session_size, 0, 0, NULL, NULL, NULL,
+                                          NULL, socket_id, 0);
+               if (mpool == NULL) {
+                       printf("Cannot create pool \"%s\" on socket %d\n",
+                              mp_name, socket_id);
+                       return -ENOMEM;
+               }
+               session_pool_socket[socket_id].sess_mp = mpool;
+       }
+       return 0;
+}
+
 static int
 fill_session_pool_socket(int32_t socket_id, uint32_t session_priv_size,
                uint32_t nb_sessions)
@@ -199,6 +244,13 @@ cperf_initialize_cryptodev(struct cperf_options *opts, uint8_t *enabled_cdevs)
                        socket_id = 0;
 
                rte_cryptodev_info_get(cdev_id, &cdev_info);
+
+               if (opts->op_type == CPERF_ASYM_MODEX) {
+                       if ((cdev_info.feature_flags &
+                            RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO) == 0)
+                               continue;
+               }
+
                if (opts->nb_qps > cdev_info.max_nb_queue_pairs) {
                        printf("Number of needed queue pairs is higher "
                                "than the maximum number of queue pairs "
@@ -210,12 +262,27 @@ cperf_initialize_cryptodev(struct cperf_options *opts, uint8_t *enabled_cdevs)
                struct rte_cryptodev_config conf = {
                        .nb_queue_pairs = opts->nb_qps,
                        .socket_id = socket_id,
-                       .ff_disable = RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO,
                };
 
-               if (opts->op_type != CPERF_PDCP &&
-                               opts->op_type != CPERF_DOCSIS)
+               switch (opts->op_type) {
+               case CPERF_ASYM_MODEX:
+                       conf.ff_disable |= (RTE_CRYPTODEV_FF_SECURITY |
+                                           RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO);
+                       break;
+               case CPERF_CIPHER_ONLY:
+               case CPERF_AUTH_ONLY:
+               case CPERF_CIPHER_THEN_AUTH:
+               case CPERF_AUTH_THEN_CIPHER:
+               case CPERF_AEAD:
                        conf.ff_disable |= RTE_CRYPTODEV_FF_SECURITY;
+                       /* Fall through */
+               case CPERF_PDCP:
+               case CPERF_DOCSIS:
+                       /* Fall through */
+               default:
+
+                       conf.ff_disable |= RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO;
+               }
 
                struct rte_cryptodev_qp_conf qp_conf = {
                        .nb_descriptors = opts->nb_descriptors
@@ -267,8 +334,12 @@ cperf_initialize_cryptodev(struct cperf_options *opts, uint8_t *enabled_cdevs)
                        return -ENOTSUP;
                }
 
-               ret = fill_session_pool_socket(socket_id, max_sess_size,
-                               sessions_needed);
+               if (opts->op_type == CPERF_ASYM_MODEX)
+                       ret = create_asym_op_pool_socket(cdev_id, socket_id,
+                                                        sessions_needed);
+               else
+                       ret = fill_session_pool_socket(socket_id, max_sess_size,
+                                                      sessions_needed);
                if (ret < 0)
                        return ret;
 
@@ -276,6 +347,11 @@ cperf_initialize_cryptodev(struct cperf_options *opts, uint8_t *enabled_cdevs)
                qp_conf.mp_session_private =
                                session_pool_socket[socket_id].priv_mp;
 
+               if (opts->op_type == CPERF_ASYM_MODEX) {
+                       qp_conf.mp_session = NULL;
+                       qp_conf.mp_session_private = NULL;
+               }
+
                ret = rte_cryptodev_configure(cdev_id, &conf);
                if (ret < 0) {
                        printf("Failed to configure cryptodev %u", cdev_id);
@@ -309,6 +385,9 @@ cperf_verify_devices_capabilities(struct cperf_options *opts,
 {
        struct rte_cryptodev_sym_capability_idx cap_idx;
        const struct rte_cryptodev_symmetric_capability *capability;
+       struct rte_cryptodev_asym_capability_idx asym_cap_idx;
+       const struct rte_cryptodev_asymmetric_xform_capability *asym_capability;
+
 
        uint8_t i, cdev_id;
        int ret;
@@ -317,6 +396,20 @@ cperf_verify_devices_capabilities(struct cperf_options *opts,
 
                cdev_id = enabled_cdevs[i];
 
+               if (opts->op_type == CPERF_ASYM_MODEX) {
+                       asym_cap_idx.type = RTE_CRYPTO_ASYM_XFORM_MODEX;
+                       asym_capability = rte_cryptodev_asym_capability_get(
+                               cdev_id, &asym_cap_idx);
+                       if (asym_capability == NULL)
+                               return -1;
+
+                       ret = rte_cryptodev_asym_xform_capability_check_modlen(
+                               asym_capability, sizeof(perf_mod_p));
+                       if (ret != 0)
+                               return ret;
+
+               }
+
                if (opts->op_type == CPERF_AUTH_ONLY ||
                                opts->op_type == CPERF_CIPHER_THEN_AUTH ||
                                opts->op_type == CPERF_AUTH_THEN_CIPHER) {
@@ -390,7 +483,7 @@ cperf_check_test_vector(struct cperf_options *opts,
                if (opts->cipher_algo == RTE_CRYPTO_CIPHER_NULL) {
                        if (test_vec->plaintext.data == NULL)
                                return -1;
-               } else if (opts->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
+               } else {
                        if (test_vec->plaintext.data == NULL)
                                return -1;
                        if (test_vec->plaintext.length < opts->max_buffer_size)
@@ -440,7 +533,7 @@ cperf_check_test_vector(struct cperf_options *opts,
                                return -1;
                        if (test_vec->plaintext.length < opts->max_buffer_size)
                                return -1;
-               } else if (opts->cipher_algo != RTE_CRYPTO_CIPHER_NULL) {
+               } else {
                        if (test_vec->plaintext.data == NULL)
                                return -1;
                        if (test_vec->plaintext.length < opts->max_buffer_size)
@@ -530,14 +623,14 @@ main(int argc, char **argv)
 
        ret = cperf_options_parse(&opts, argc, argv);
        if (ret) {
-               RTE_LOG(ERR, USER1, "Parsing on or more user options failed\n");
+               RTE_LOG(ERR, USER1, "Parsing one or more user options failed\n");
                goto err;
        }
 
        ret = cperf_options_check(&opts);
        if (ret) {
                RTE_LOG(ERR, USER1,
-                               "Checking on or more user options failed\n");
+                               "Checking one or more user options failed\n");
                goto err;
        }
 
@@ -600,7 +693,7 @@ main(int argc, char **argv)
 
        i = 0;
        uint8_t qp_id = 0, cdev_index = 0;
-       RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+       RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                if (i == total_nb_qps)
                        break;
@@ -664,7 +757,7 @@ main(int argc, char **argv)
                                distribution_total[buffer_size_count - 1];
 
                i = 0;
-               RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+               RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                        if (i == total_nb_qps)
                                break;
@@ -674,7 +767,7 @@ main(int argc, char **argv)
                        i++;
                }
                i = 0;
-               RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+               RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                        if (i == total_nb_qps)
                                break;
@@ -694,7 +787,7 @@ main(int argc, char **argv)
 
                while (opts.test_buffer_size <= opts.max_buffer_size) {
                        i = 0;
-                       RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+                       RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                                if (i == total_nb_qps)
                                        break;
@@ -704,7 +797,7 @@ main(int argc, char **argv)
                                i++;
                        }
                        i = 0;
-                       RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+                       RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                                if (i == total_nb_qps)
                                        break;
@@ -728,7 +821,7 @@ main(int argc, char **argv)
        }
 
        i = 0;
-       RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+       RTE_LCORE_FOREACH_WORKER(lcore_id) {
 
                if (i == total_nb_qps)
                        break;
@@ -738,8 +831,13 @@ main(int argc, char **argv)
        }
 
        for (i = 0; i < nb_cryptodevs &&
-                       i < RTE_CRYPTO_MAX_DEVS; i++)
+                       i < RTE_CRYPTO_MAX_DEVS; i++) {
                rte_cryptodev_stop(enabled_cdevs[i]);
+               ret = rte_cryptodev_close(enabled_cdevs[i]);
+               if (ret)
+                       RTE_LOG(ERR, USER1,
+                                       "Crypto device close error %d\n", ret);
+       }
 
        free_test_vector(t_vec, &opts);
 
@@ -748,7 +846,7 @@ main(int argc, char **argv)
 
 err:
        i = 0;
-       RTE_LCORE_FOREACH_SLAVE(lcore_id) {
+       RTE_LCORE_FOREACH_WORKER(lcore_id) {
                if (i == total_nb_qps)
                        break;
 
@@ -758,8 +856,14 @@ err:
        }
 
        for (i = 0; i < nb_cryptodevs &&
-                       i < RTE_CRYPTO_MAX_DEVS; i++)
+                       i < RTE_CRYPTO_MAX_DEVS; i++) {
                rte_cryptodev_stop(enabled_cdevs[i]);
+               ret = rte_cryptodev_close(enabled_cdevs[i]);
+               if (ret)
+                       RTE_LOG(ERR, USER1,
+                                       "Crypto device close error %d\n", ret);
+
+       }
        rte_free(opts.imix_buffer_sizes);
        free_test_vector(t_vec, &opts);