pdump: replace constant for device name size

[dpdk.git] / app / test / test_cryptodev.c

diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 3afc1d8..8189053 100644 (file)
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -19,7 +19,7 @@
 #include <rte_cryptodev_pmd.h>
 #include <rte_string_fns.h>
 
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+#ifdef RTE_CRYPTO_SCHEDULER
 #include <rte_cryptodev_scheduler.h>
 #include <rte_cryptodev_scheduler_operations.h>
 #endif
@@ -41,7 +41,7 @@
 #include "test_cryptodev_aead_test_vectors.h"
 #include "test_cryptodev_hmac_test_vectors.h"
 #include "test_cryptodev_mixed_test_vectors.h"
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
 #include "test_cryptodev_security_pdcp_test_vectors.h"
 #include "test_cryptodev_security_pdcp_sdap_test_vectors.h"
 #include "test_cryptodev_security_pdcp_test_func.h"
@@ -89,17 +89,17 @@ struct crypto_unittest_params {
        struct rte_crypto_sym_xform cipher_xform;
        struct rte_crypto_sym_xform auth_xform;
        struct rte_crypto_sym_xform aead_xform;
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
        struct rte_security_docsis_xform docsis_xform;
 #endif
 
        union {
                struct rte_cryptodev_sym_session *sess;
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
                struct rte_security_session *sec_session;
 #endif
        };
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
        enum rte_security_session_action_type type;
 #endif
        struct rte_crypto_op *op;
@@ -704,7 +704,7 @@ testsuite_setup(void)
                }
        }
 
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+#ifdef RTE_CRYPTO_SCHEDULER
        char vdev_args[VDEV_ARGS_SIZE] = {""};
        char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
                "ordering=enable,name=cryptodev_test_scheduler,corelist="};
@@ -717,7 +717,7 @@ testsuite_setup(void)
                /* Identify the Worker Cores
                 * Use 2 worker cores for the device args
                 */
-               RTE_LCORE_FOREACH_SLAVE(i) {
+               RTE_LCORE_FOREACH_WORKER(i) {
                        if (worker_core_count > 1)
                                break;
                        snprintf(vdev_args, sizeof(vdev_args),
@@ -751,7 +751,7 @@ testsuite_setup(void)
                                i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
                }
        }
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
+#endif /* RTE_CRYPTO_SCHEDULER */
 
        nb_devs = rte_cryptodev_count();
        if (nb_devs < 1) {
@@ -782,7 +782,7 @@ testsuite_setup(void)
        unsigned int session_size =
                rte_cryptodev_sym_get_private_session_size(dev_id);
 
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
        unsigned int security_session_size = rte_security_session_get_size(
                        rte_cryptodev_get_sec_ctx(dev_id));
 
@@ -930,7 +930,7 @@ ut_teardown(void)
        struct rte_cryptodev_stats stats;
 
        /* free crypto session structure */
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
        if (ut_params->type == RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL) {
                if (ut_params->sec_session) {
                        rte_security_session_destroy(rte_cryptodev_get_sec_ctx
@@ -2680,6 +2680,9 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -2768,6 +2771,9 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -2850,6 +2856,9 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -2936,6 +2945,9 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -3157,6 +3169,9 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
@@ -3265,6 +3280,9 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3349,6 +3367,9 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3433,6 +3454,9 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -3521,6 +3545,9 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create KASUMI session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3600,6 +3627,9 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
@@ -3689,6 +3719,9 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
@@ -3778,6 +3811,9 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3864,6 +3900,9 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -3986,6 +4025,9 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -4087,6 +4129,9 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
@@ -4173,6 +4218,9 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata)
        if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -4266,6 +4314,9 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Check if device supports ZUC EEA3 */
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
        cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
@@ -4364,6 +4415,9 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -4481,6 +4535,9 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata,
                        &cap_idx) == NULL)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -4670,6 +4727,9 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata,
                        &cap_idx) == NULL)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -4884,6 +4944,9 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata,
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        if (op_mode == OUT_OF_PLACE) {
                if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
                        return -ENOTSUP;
@@ -5065,6 +5128,9 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata,
                        &cap_idx) == NULL)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -5261,6 +5327,9 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Verify the capabilities */
        struct rte_cryptodev_sym_capability_idx cap_idx;
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
@@ -5374,6 +5443,9 @@ test_zuc_encryption(const struct wireless_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        struct rte_cryptodev_sym_capability_idx cap_idx;
 
        /* Check if device supports ZUC EEA3 */
@@ -5466,6 +5538,9 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata)
                        &cap_idx) == NULL)
                return -ENOTSUP;
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
 
        uint64_t feat_flags = dev_info.feature_flags;
@@ -5572,6 +5647,9 @@ test_zuc_authentication(const struct wireless_test_data *tdata)
                return -ENOTSUP;
        }
 
+       if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+               return -ENOTSUP;
+
        /* Check if device supports ZUC EIA3 */
        cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
        cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
@@ -6676,6 +6754,7 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
        unsigned int ciphertext_len;
 
        struct rte_cryptodev_info dev_info;
+       struct rte_crypto_op *op;
 
        /* Check if device supports particular algorithms separately */
        if (test_mixed_check_if_unsupported(tdata))
@@ -6692,9 +6771,6 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
                return -ENOTSUP;
        }
 
-       if (op_mode == OUT_OF_PLACE)
-               return -ENOTSUP;
-
        /* Create the session */
        if (verify)
                retval = create_wireless_algo_cipher_auth_session(
@@ -6771,17 +6847,17 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata,
        if (retval < 0)
                return retval;
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-                       ut_params->op);
+       op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
 
        /* Check if the op failed because the device doesn't */
        /* support this particular combination of algorithms */
-       if (ut_params->op == NULL && ut_params->op->status ==
+       if (op == NULL && ut_params->op->status ==
                        RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
                printf("Device doesn't support this mixed combination. "
                                "Test Skipped.\n");
                return -ENOTSUP;
        }
+       ut_params->op = op;
 
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -6872,6 +6948,7 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
        uint8_t digest_buffer[10000];
 
        struct rte_cryptodev_info dev_info;
+       struct rte_crypto_op *op;
 
        /* Check if device supports particular algorithms */
        if (test_mixed_check_if_unsupported(tdata))
@@ -6976,17 +7053,17 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata,
        if (retval < 0)
                return retval;
 
-       ut_params->op = process_crypto_request(ts_params->valid_devs[0],
-                       ut_params->op);
+       op = process_crypto_request(ts_params->valid_devs[0], ut_params->op);
 
        /* Check if the op failed because the device doesn't */
        /* support this particular combination of algorithms */
-       if (ut_params->op == NULL && ut_params->op->status ==
+       if (op == NULL && ut_params->op->status ==
                        RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
                printf("Device doesn't support this mixed combination. "
                                "Test Skipped.\n");
                return -ENOTSUP;
        }
+       ut_params->op = op;
 
        TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
 
@@ -7632,7 +7709,7 @@ test_authenticated_encryption(const struct aead_test_data *tdata)
 
 }
 
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
 static int
 security_proto_supported(enum rte_security_session_action_type action,
        enum rte_security_session_protocol proto)
@@ -11069,8 +11146,8 @@ test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata,
        rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
        feature_flags = dev_info.feature_flags;
 
-       if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) &&
-                       (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) &&
+       if ((!(feature_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) ||
+                       (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT)) ||
                        (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)))
                return -ENOTSUP;
 
@@ -12737,7 +12814,7 @@ test_chacha20_poly1305_decrypt_test_case_rfc8439(void)
        return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439);
 }
 
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+#ifdef RTE_CRYPTO_SCHEDULER
 
 /* global AESNI worker IDs for the scheduler test */
 uint8_t aesni_ids[2];
@@ -12957,7 +13034,7 @@ static struct unit_test_suite cryptodev_scheduler_testsuite  = {
        }
 };
 
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
+#endif /* RTE_CRYPTO_SCHEDULER */
 
 static struct unit_test_suite cryptodev_testsuite  = {
        .suite_name = "Crypto Unit Test Suite",
@@ -13587,7 +13664,7 @@ static struct unit_test_suite cryptodev_testsuite  = {
                TEST_CASE_ST(ut_setup, ut_teardown,
                        test_verify_auth_aes_cmac_cipher_null_test_case_1),
 
-#ifdef RTE_LIBRTE_SECURITY
+#ifdef RTE_LIB_SECURITY
                TEST_CASE_ST(ut_setup_security, ut_teardown,
                        test_PDCP_PROTO_all),
                TEST_CASE_ST(ut_setup_security, ut_teardown,
@@ -13880,7 +13957,7 @@ test_cryptodev_mrvl(void)
        return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
 }
 
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+#ifdef RTE_CRYPTO_SCHEDULER
 
 static int
 test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
@@ -14022,9 +14099,7 @@ test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
                        RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
 
        if (gbl_driver_id == -1) {
-               RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
-               "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
-               "are enabled in config file to run this testsuite.\n");
+               RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
                return TEST_SKIPPED;
        }