/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2015-2020 Intel Corporation
+ * Copyright 2020 NXP
*/
#include <time.h>
#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
#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"
#include "test_cryptodev_security_docsis_test_vectors.h"
+
+#define SDAP_DISABLED 0
+#define SDAP_ENABLED 1
#endif
#define VDEV_ARGS_SIZE 100
#define IN_PLACE 0
#define OUT_OF_PLACE 1
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
+#endif
+
static int gbl_driver_id;
static enum rte_security_session_action_type gbl_action_type =
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;
#define ALIGN_POW2_ROUNDUP(num, align) \
(((num) + (align) - 1) & ~((align) - 1))
+#define ADD_STATIC_TESTSUITE(index, parent_ts, child_ts, num_child_ts) \
+ for (j = 0; j < num_child_ts; index++, j++) \
+ parent_ts.unit_test_suites[index] = child_ts[j]
+
/*
* Forward declarations.
*/
return (num_bits >> 3);
}
-static uint32_t
-get_raw_dp_dequeue_count(void *user_data __rte_unused)
-{
- return 1;
-}
-
static void
post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused,
uint8_t is_op_success)
n = n_success = 0;
while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) {
n = rte_cryptodev_raw_dequeue_burst(ctx,
- get_raw_dp_dequeue_count, post_process_raw_dp_op,
+ NULL, 1, post_process_raw_dp_op,
(void **)&ret_op, 0, &n_success,
&dequeue_status);
if (dequeue_status < 0) {
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct rte_cryptodev_info info;
uint32_t i = 0, nb_devs, dev_id;
- int ret;
uint16_t qp_id;
memset(ts_params, 0, sizeof(*ts_params));
return TEST_FAILED;
}
- /* Create an AESNI MB device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), NULL);
-
- TEST_ASSERT(ret == 0,
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
- }
- }
-
- /* Create an AESNI GCM device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD)));
- if (nb_devs < 1) {
- TEST_ASSERT_SUCCESS(rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD), NULL),
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
- }
- }
-
- /* Create a SNOW 3G device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD)));
- if (nb_devs < 1) {
- TEST_ASSERT_SUCCESS(rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD), NULL),
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
- }
- }
-
- /* Create a KASUMI device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_KASUMI_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)));
- if (nb_devs < 1) {
- TEST_ASSERT_SUCCESS(rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_KASUMI_PMD), NULL),
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
- }
- }
-
- /* Create a ZUC device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ZUC_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ZUC_PMD)));
- if (nb_devs < 1) {
- TEST_ASSERT_SUCCESS(rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_ZUC_PMD), NULL),
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
- }
- }
-
- /* Create a NULL device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD), NULL);
-
- TEST_ASSERT(ret == 0,
- "Failed to create instance of"
- " pmd : %s",
- RTE_STR(CRYPTODEV_NAME_NULL_PMD));
- }
- }
-
- /* Create an OPENSSL device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
- }
- }
-
- /* Create a ARMv8 device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
- }
- }
-
- /* Create a MVSAM device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
- }
- }
-
- /* Create an CCP device if required */
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD))) {
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD),
- NULL);
-
- TEST_ASSERT(ret == 0, "Failed to create "
- "instance of pmd : %s",
- RTE_STR(CRYPTODEV_NAME_CCP_PMD));
- }
- }
-
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
- char vdev_args[VDEV_ARGS_SIZE] = {""};
- char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
- "ordering=enable,name=cryptodev_test_scheduler,corelist="};
- uint16_t worker_core_count = 0;
- uint16_t socket_id = 0;
-
- if (gbl_driver_id == rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
-
- /* Identify the Worker Cores
- * Use 2 worker cores for the device args
- */
- RTE_LCORE_FOREACH_SLAVE(i) {
- if (worker_core_count > 1)
- break;
- snprintf(vdev_args, sizeof(vdev_args),
- "%s%d", temp_str, i);
- strcpy(temp_str, vdev_args);
- strlcat(temp_str, ";", sizeof(temp_str));
- worker_core_count++;
- socket_id = rte_lcore_to_socket_id(i);
- }
- if (worker_core_count != 2) {
- RTE_LOG(ERR, USER1,
- "Cryptodev scheduler test require at least "
- "two worker cores to run. "
- "Please use the correct coremask.\n");
- return TEST_FAILED;
- }
- strcpy(temp_str, vdev_args);
- snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
- temp_str, socket_id);
- RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
- nb_devs = rte_cryptodev_device_count_by_driver(
- rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
- if (nb_devs < 1) {
- ret = rte_vdev_init(
- RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
- vdev_args);
- TEST_ASSERT(ret == 0,
- "Failed to create instance %u of"
- " pmd : %s",
- i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
- }
- }
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
-
nb_devs = rte_cryptodev_count();
if (nb_devs < 1) {
RTE_LOG(WARNING, USER1, "No crypto devices found?\n");
return TEST_SKIPPED;
}
+ if (rte_cryptodev_device_count_by_driver(gbl_driver_id) < 1) {
+ RTE_LOG(WARNING, USER1, "No %s devices found?\n",
+ rte_cryptodev_driver_name_get(gbl_driver_id));
+ return TEST_SKIPPED;
+ }
+
/* Create list of valid crypto devs */
for (i = 0; i < nb_devs; i++) {
rte_cryptodev_info_get(i, &info);
unsigned int session_size =
rte_cryptodev_sym_get_private_session_size(dev_id);
+#ifdef RTE_LIB_SECURITY
+ unsigned int security_session_size = rte_security_session_get_size(
+ rte_cryptodev_get_sec_ctx(dev_id));
+
+ if (session_size < security_session_size)
+ session_size = security_session_size;
+#endif
/*
- * Create mempool with maximum number of sessions * 2,
- * to include the session headers
+ * Create mempool with maximum number of sessions.
*/
if (info.sym.max_nb_sessions != 0 &&
info.sym.max_nb_sessions < MAX_NB_SESSIONS) {
testsuite_teardown(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
+ int res;
if (ts_params->mbuf_pool != NULL) {
RTE_LOG(DEBUG, USER1, "CRYPTO_MBUFPOOL count %u\n",
rte_mempool_free(ts_params->session_mpool);
ts_params->session_mpool = NULL;
}
+
+ res = rte_cryptodev_close(ts_params->valid_devs[0]);
+ if (res)
+ RTE_LOG(ERR, USER1, "Crypto device close error %d\n", res);
}
static int
-dev_configure_and_start(uint64_t ff_disable)
+check_capabilities_supported(enum rte_crypto_sym_xform_type type,
+ const int *algs, uint16_t num_algs)
{
- struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
+ uint8_t dev_id = testsuite_params.valid_devs[0];
+ bool some_alg_supported = FALSE;
+ uint16_t i;
- uint16_t qp_id;
+ for (i = 0; i < num_algs && !some_alg_supported; i++) {
+ struct rte_cryptodev_sym_capability_idx alg = {
+ type, {algs[i]}
+ };
+ if (rte_cryptodev_sym_capability_get(dev_id,
+ &alg) != NULL)
+ some_alg_supported = TRUE;
+ }
+ if (!some_alg_supported)
+ return TEST_SKIPPED;
- /* Clear unit test parameters before running test */
- memset(ut_params, 0, sizeof(*ut_params));
+ return 0;
+}
- /* Reconfigure device to default parameters */
- ts_params->conf.socket_id = SOCKET_ID_ANY;
- ts_params->conf.ff_disable = ff_disable;
- ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
- ts_params->qp_conf.mp_session = ts_params->session_mpool;
- ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
+int
+check_cipher_capabilities_supported(const enum rte_crypto_cipher_algorithm *ciphers,
+ uint16_t num_ciphers)
+{
+ return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_CIPHER,
+ (const int *) ciphers, num_ciphers);
+}
- TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
- &ts_params->conf),
- "Failed to configure cryptodev %u",
- ts_params->valid_devs[0]);
+int
+check_auth_capabilities_supported(const enum rte_crypto_auth_algorithm *auths,
+ uint16_t num_auths)
+{
+ return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AUTH,
+ (const int *) auths, num_auths);
+}
- for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
- TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
- ts_params->valid_devs[0], qp_id,
- &ts_params->qp_conf,
- rte_cryptodev_socket_id(ts_params->valid_devs[0])),
- "Failed to setup queue pair %u on cryptodev %u",
- qp_id, ts_params->valid_devs[0]);
- }
+int
+check_aead_capabilities_supported(const enum rte_crypto_aead_algorithm *aeads,
+ uint16_t num_aeads)
+{
+ return check_capabilities_supported(RTE_CRYPTO_SYM_XFORM_AEAD,
+ (const int *) aeads, num_aeads);
+}
+static int
+null_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_NULL
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_NULL
+ };
- rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
+ rte_cryptodev_info_get(dev_id, &dev_info);
- /* Start the device */
- TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
- "Failed to start cryptodev %u",
- ts_params->valid_devs[0]);
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for NULL "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
- return TEST_SUCCESS;
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for NULL "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
}
static int
-ut_setup(void)
+crypto_gen_testsuite_setup(void)
{
- /* Configure and start the device with security feature disabled */
- return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Crypto Gen "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
}
+#ifdef RTE_LIB_SECURITY
static int
-ut_setup_security(void)
+pdcp_proto_testsuite_setup(void)
{
- /* Configure and start the device with no features disabled */
- return dev_configure_and_start(0);
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_NULL,
+ RTE_CRYPTO_CIPHER_AES_CTR,
+ RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_NULL,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+ RTE_CRYPTO_AUTH_AES_CMAC,
+ RTE_CRYPTO_AUTH_ZUC_EIA3
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ !(dev_info.feature_flags &
+ RTE_CRYPTODEV_FF_SECURITY)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for PDCP Proto "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for PDCP Proto "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
}
-static void
-ut_teardown(void)
+static int
+docsis_proto_testsuite_setup(void)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
- struct crypto_unittest_params *ut_params = &unittest_params;
- struct rte_cryptodev_stats stats;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_AES_DOCSISBPI
+ };
- /* free crypto session structure */
-#ifdef RTE_LIBRTE_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
- (ts_params->valid_devs[0]),
- ut_params->sec_session);
- ut_params->sec_session = NULL;
- }
- } else
-#endif
- {
- if (ut_params->sess) {
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ !(dev_info.feature_flags &
+ RTE_CRYPTODEV_FF_SECURITY)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Docsis "
+ "Proto testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Docsis Proto "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+#endif
+
+static int
+aes_ccm_auth_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_aead_algorithm aeads[] = {
+ RTE_CRYPTO_AEAD_AES_CCM
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for AES CCM "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for AES CCM "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+aes_gcm_auth_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_aead_algorithm aeads[] = {
+ RTE_CRYPTO_AEAD_AES_GCM
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for AES GCM "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for AES GCM "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+aes_gmac_auth_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_AES_GMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for AES GMAC "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for AES GMAC "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+chacha20_poly1305_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_aead_algorithm aeads[] = {
+ RTE_CRYPTO_AEAD_CHACHA20_POLY1305
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for "
+ "Chacha20-Poly1305 testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for "
+ "Chacha20-Poly1305 testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+snow3g_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2
+
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Snow3G "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Snow3G "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+zuc_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_ZUC_EEA3
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_ZUC_EIA3
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for ZUC "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for ZUC "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+hmac_md5_auth_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_MD5_HMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for HMAC MD5 "
+ "Auth testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for HMAC MD5 "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+kasumi_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_KASUMI_F8
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_KASUMI_F9
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Kasumi "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Kasumi "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+negative_aes_gcm_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_aead_algorithm aeads[] = {
+ RTE_CRYPTO_AEAD_AES_GCM
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
+ "AES GCM testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_aead_capabilities_supported(aeads, RTE_DIM(aeads)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Negative "
+ "AES GCM testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+negative_aes_gmac_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_AES_GMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
+ "AES GMAC testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_auth_capabilities_supported(auths, RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Negative "
+ "AES GMAC testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+mixed_cipher_hash_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ uint64_t feat_flags;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_NULL,
+ RTE_CRYPTO_CIPHER_AES_CTR,
+ RTE_CRYPTO_CIPHER_ZUC_EEA3,
+ RTE_CRYPTO_CIPHER_SNOW3G_UEA2
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_NULL,
+ RTE_CRYPTO_AUTH_SNOW3G_UIA2,
+ RTE_CRYPTO_AUTH_AES_CMAC,
+ RTE_CRYPTO_AUTH_ZUC_EIA3
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+ feat_flags = dev_info.feature_flags;
+
+ if (!(feat_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ (global_api_test_type == CRYPTODEV_RAW_API_TEST)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Mixed "
+ "Cipher Hash testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Mixed "
+ "Cipher Hash testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+esn_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_AES_CBC
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_SHA1_HMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for ESN "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for ESN "
+ "testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+multi_session_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_AES_CBC
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_SHA512_HMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO)) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Multi "
+ "Session testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Multi "
+ "Session testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+negative_hmac_sha1_testsuite_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ uint8_t dev_id = ts_params->valid_devs[0];
+ struct rte_cryptodev_info dev_info;
+ const enum rte_crypto_cipher_algorithm ciphers[] = {
+ RTE_CRYPTO_CIPHER_AES_CBC
+ };
+ const enum rte_crypto_auth_algorithm auths[] = {
+ RTE_CRYPTO_AUTH_SHA1_HMAC
+ };
+
+ rte_cryptodev_info_get(dev_id, &dev_info);
+
+ if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) ||
+ ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ !(dev_info.feature_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
+ RTE_LOG(INFO, USER1, "Feature flag requirements for Negative "
+ "HMAC SHA1 testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ if (check_cipher_capabilities_supported(ciphers, RTE_DIM(ciphers)) != 0
+ && check_auth_capabilities_supported(auths,
+ RTE_DIM(auths)) != 0) {
+ RTE_LOG(INFO, USER1, "Capability requirements for Negative "
+ "HMAC SHA1 testsuite not met\n");
+ return TEST_SKIPPED;
+ }
+
+ return 0;
+}
+
+static int
+dev_configure_and_start(uint64_t ff_disable)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+
+ uint16_t qp_id;
+
+ /* Clear unit test parameters before running test */
+ memset(ut_params, 0, sizeof(*ut_params));
+
+ /* Reconfigure device to default parameters */
+ ts_params->conf.socket_id = SOCKET_ID_ANY;
+ ts_params->conf.ff_disable = ff_disable;
+ ts_params->qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
+ ts_params->qp_conf.mp_session = ts_params->session_mpool;
+ ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool;
+
+ TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
+ &ts_params->conf),
+ "Failed to configure cryptodev %u",
+ ts_params->valid_devs[0]);
+
+ for (qp_id = 0; qp_id < ts_params->conf.nb_queue_pairs ; qp_id++) {
+ TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
+ ts_params->valid_devs[0], qp_id,
+ &ts_params->qp_conf,
+ rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+ "Failed to setup queue pair %u on cryptodev %u",
+ qp_id, ts_params->valid_devs[0]);
+ }
+
+
+ rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
+
+ /* Start the device */
+ TEST_ASSERT_SUCCESS(rte_cryptodev_start(ts_params->valid_devs[0]),
+ "Failed to start cryptodev %u",
+ ts_params->valid_devs[0]);
+
+ return TEST_SUCCESS;
+}
+
+static int
+ut_setup(void)
+{
+ /* Configure and start the device with security feature disabled */
+ return dev_configure_and_start(RTE_CRYPTODEV_FF_SECURITY);
+}
+
+static int
+ut_setup_security(void)
+{
+ /* Configure and start the device with no features disabled */
+ return dev_configure_and_start(0);
+}
+
+static void
+ut_teardown(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct crypto_unittest_params *ut_params = &unittest_params;
+ struct rte_cryptodev_stats stats;
+
+ /* free crypto session structure */
+#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
+ (ts_params->valid_devs[0]),
+ ut_params->sec_session);
+ ut_params->sec_session = NULL;
+ }
+ } else
+#endif
+ {
+ if (ut_params->sess) {
rte_cryptodev_sym_session_clear(
ts_params->valid_devs[0],
ut_params->sess);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Generate test mbuf data and space for digest */
ut_params->ibuf = setup_test_string(ts_params->mbuf_pool,
{
/* Data-path service does not support DOCSIS yet */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
}
{
/* Data-path service does not support DOCSIS yet */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
}
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
return 0;
&ut_params->cipher_xform,
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
ts_params->session_priv_mpool);
if (status == -ENOTSUP)
- return status;
+ return TEST_SKIPPED;
TEST_ASSERT_EQUAL(status, 0, "session init failed");
iv_ptr += cipher_iv_len;
rte_memcpy(iv_ptr, auth_iv, auth_iv_len);
+ /* Only copy over the offset data needed from src to dst in OOP,
+ * if the auth and cipher offsets are not aligned
+ */
+ if (op_mode == OUT_OF_PLACE) {
+ if (cipher_offset > auth_offset)
+ rte_memcpy(
+ rte_pktmbuf_mtod_offset(
+ sym_op->m_dst,
+ uint8_t *, auth_offset >> 3),
+ rte_pktmbuf_mtod_offset(
+ sym_op->m_src,
+ uint8_t *, auth_offset >> 3),
+ ((cipher_offset >> 3) - (auth_offset >> 3)));
+ }
+
if (cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 ||
cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8 ||
cipher_algo == RTE_CRYPTO_CIPHER_ZUC_EEA3) {
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validAuthLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validAuthLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
/* Data-path service does not support OOP */
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create KASUMI session */
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create SNOW 3G session */
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
((tdata->validDataLenInBits.len % 8) != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
((tdata->validAuthLenInBits.len % 8 != 0) ||
(tdata->validDataLenInBits.len % 8 != 0))) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Check if device supports ZUC EEA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports ZUC EIA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_zuc_cipher_auth_encrypt_generate_session(
ts_params->valid_devs[0],
tdata);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_auth_session(ts_params->valid_devs[0],
tdata->key.data, tdata->key.len,
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (op_mode == OUT_OF_PLACE) {
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Create SNOW 3G session */
tdata->key.data, tdata->key.len,
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
-
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
/* Validate obuf */
if (verify) {
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
plaintext,
tdata->plaintext.data,
- tdata->plaintext.len >> 3,
+ (tdata->plaintext.len - tdata->cipher.offset_bits -
+ (tdata->digest.len << 3)),
+ tdata->cipher.offset_bits,
"SNOW 3G Plaintext data not as expected");
} else {
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
ciphertext,
tdata->ciphertext.data,
- tdata->validDataLenInBits.len,
+ (tdata->validDataLenInBits.len -
+ tdata->cipher.offset_bits),
+ tdata->cipher.offset_bits,
"SNOW 3G Ciphertext data not as expected");
TEST_ASSERT_BUFFERS_ARE_EQUAL(
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SNOW3G_UIA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_SNOW3G_UEA2;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
/* Validate obuf */
if (verify) {
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
plaintext,
tdata->plaintext.data,
- tdata->plaintext.len >> 3,
+ (tdata->plaintext.len - tdata->cipher.offset_bits -
+ (tdata->digest.len << 3)),
+ tdata->cipher.offset_bits,
"SNOW 3G Plaintext data not as expected");
} else {
- TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT(
+ TEST_ASSERT_BUFFERS_ARE_EQUAL_BIT_OFFSET(
ciphertext,
tdata->ciphertext.data,
- tdata->validDataLenInBits.len,
+ (tdata->validDataLenInBits.len -
+ tdata->cipher.offset_bits),
+ tdata->cipher.offset_bits,
"SNOW 3G Ciphertext data not as expected");
TEST_ASSERT_BUFFERS_ARE_EQUAL(
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
if (op_mode == OUT_OF_PLACE) {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_KASUMI_F9;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_KASUMI_F8;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create KASUMI session */
retval = create_wireless_algo_cipher_auth_session(
tdata->key.data, tdata->key.len,
0, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
struct rte_cryptodev_sym_capability_idx cap_idx;
/* Check if device supports ZUC EEA3 */
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
+
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather. "
"Test Skipped.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
plaintext_len = ceil_byte_length(tdata->plaintext.len);
if (!(feat_flags & RTE_CRYPTODEV_FF_NON_BYTE_ALIGNED_DATA) &&
(tdata->validAuthLenInBits.len % 8 != 0)) {
printf("Device doesn't support NON-Byte Aligned Data.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ return TEST_SKIPPED;
+
/* Check if device supports ZUC EIA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create ZUC session */
retval = create_wireless_algo_hash_session(ts_params->valid_devs[0],
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (op_mode == IN_PLACE) {
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_iv.len, tdata->digest.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len);
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_kasumi_decryption(&kasumi_test_case_3);
}
test_snow3g_decryption_with_digest_test_case_1(void)
{
struct snow3g_hash_test_data snow3g_hash_data;
+ struct rte_cryptodev_info dev_info;
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+
+ if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
+ printf("Device doesn't support encrypted digest operations.\n");
+ return TEST_SKIPPED;
+ }
/*
* Function prepare data for hash veryfication test case.
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
}
{
/* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_partial_digest_encryption,
IN_PLACE, 0);
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = tdata->cipher_algo;
if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check if device supports particular hash algorithm */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = tdata->auth_algo;
if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
return 0;
}
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))
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
- if (op_mode == OUT_OF_PLACE)
- return -ENOTSUP;
-
/* Create the session */
if (verify)
retval = create_wireless_algo_cipher_auth_session(
tdata->auth_key.data, tdata->auth_key.len,
tdata->auth_iv.len, tdata->digest_enc.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
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;
+ return TEST_SKIPPED;
}
+ ut_params->op = op;
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
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))
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
if (!(feat_flags & RTE_CRYPTODEV_FF_IN_PLACE_SGL)) {
printf("Device doesn't support in-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
if (!(feat_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT)) {
printf("Device doesn't support out-of-place scatter-gather "
"in both input and output mbufs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
tdata->auth_key.data, tdata->auth_key.len,
tdata->auth_iv.len, tdata->digest_enc.len,
tdata->cipher_iv.len);
- if (retval < 0)
+ if (retval != 0)
return retval;
ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits);
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;
+ return TEST_SKIPPED;
}
+ ut_params->op = op;
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
capability = rte_cryptodev_sym_capability_get(
ts_params->valid_devs[0], &cap_idx);
if (capability == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_sym_capability_check_aead(
capability, tdata->key.len, tdata->auth_tag.len,
tdata->aad.len, tdata->iv.len))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
}
-#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)
* on input_vec. Checks the output of the crypto operation against
* output_vec.
*/
-static int
-test_pdcp_proto(int i, int oop,
- enum rte_crypto_cipher_operation opc,
- enum rte_crypto_auth_operation opa,
- uint8_t *input_vec,
- unsigned int input_vec_len,
- uint8_t *output_vec,
- unsigned int output_vec_len)
+static int test_pdcp_proto(int i, int oop, enum rte_crypto_cipher_operation opc,
+ enum rte_crypto_auth_operation opa,
+ const uint8_t *input_vec, unsigned int input_vec_len,
+ const uint8_t *output_vec,
+ unsigned int output_vec_len,
+ enum rte_crypto_cipher_algorithm cipher_alg,
+ const uint8_t *cipher_key, uint32_t cipher_key_len,
+ enum rte_crypto_auth_algorithm auth_alg,
+ const uint8_t *auth_key, uint32_t auth_key_len,
+ uint8_t bearer, enum rte_security_pdcp_domain domain,
+ uint8_t packet_direction, uint8_t sn_size,
+ uint32_t hfn, uint32_t hfn_threshold, uint8_t sdap)
{
struct crypto_testsuite_params *ts_params = &testsuite_params;
struct crypto_unittest_params *ut_params = &unittest_params;
sec_cap_idx.action = ut_params->type;
sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
- sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
+ sec_cap_idx.pdcp.domain = domain;
if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Generate test mbuf data */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
- ut_params->cipher_xform.cipher.algo = pdcp_test_params[i].cipher_alg;
+ ut_params->cipher_xform.cipher.algo = cipher_alg;
ut_params->cipher_xform.cipher.op = opc;
- ut_params->cipher_xform.cipher.key.data = pdcp_test_crypto_key[i];
- ut_params->cipher_xform.cipher.key.length =
- pdcp_test_params[i].cipher_key_len;
+ ut_params->cipher_xform.cipher.key.data = cipher_key;
+ ut_params->cipher_xform.cipher.key.length = cipher_key_len;
ut_params->cipher_xform.cipher.iv.length =
- pdcp_test_packet_direction[i] ? 4 : 0;
+ packet_direction ? 4 : 0;
ut_params->cipher_xform.cipher.iv.offset = IV_OFFSET;
/* Setup HMAC Parameters if ICV header is required */
- if (pdcp_test_params[i].auth_alg != 0) {
+ if (auth_alg != 0) {
ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH;
ut_params->auth_xform.next = NULL;
- ut_params->auth_xform.auth.algo = pdcp_test_params[i].auth_alg;
+ ut_params->auth_xform.auth.algo = auth_alg;
ut_params->auth_xform.auth.op = opa;
- ut_params->auth_xform.auth.key.data = pdcp_test_auth_key[i];
- ut_params->auth_xform.auth.key.length =
- pdcp_test_params[i].auth_key_len;
+ ut_params->auth_xform.auth.key.data = auth_key;
+ ut_params->auth_xform.auth.key.length = auth_key_len;
ut_params->cipher_xform.next = &ut_params->auth_xform;
} else {
.action_type = ut_params->type,
.protocol = RTE_SECURITY_PROTOCOL_PDCP,
{.pdcp = {
- .bearer = pdcp_test_bearer[i],
- .domain = pdcp_test_params[i].domain,
- .pkt_dir = pdcp_test_packet_direction[i],
- .sn_size = pdcp_test_data_sn_size[i],
- .hfn = pdcp_test_packet_direction[i] ?
- 0 : pdcp_test_hfn[i],
- /**
- * hfn can be set as pdcp_test_hfn[i]
- * if hfn_ovrd is not set. Here, PDCP
- * packet direction is just used to
- * run half of the cases with session
- * HFN and other half with per packet
- * HFN.
- */
- .hfn_threshold = pdcp_test_hfn_threshold[i],
- .hfn_ovrd = pdcp_test_packet_direction[i] ? 1 : 0,
+ .bearer = bearer,
+ .domain = domain,
+ .pkt_dir = packet_direction,
+ .sn_size = sn_size,
+ .hfn = packet_direction ? 0 : hfn,
+ /**
+ * hfn can be set as pdcp_test_hfn[i]
+ * if hfn_ovrd is not set. Here, PDCP
+ * packet direction is just used to
+ * run half of the cases with session
+ * HFN and other half with per packet
+ * HFN.
+ */
+ .hfn_threshold = hfn_threshold,
+ .hfn_ovrd = packet_direction ? 1 : 0,
+ .sdap_enabled = sdap,
} },
.crypto_xform = &ut_params->cipher_xform
};
/* Create security session */
ut_params->sec_session = rte_security_session_create(ctx,
- &sess_conf, ts_params->session_priv_mpool);
+ &sess_conf, ts_params->session_mpool,
+ ts_params->session_priv_mpool);
if (!ut_params->sec_session) {
printf("TestCase %s()-%d line %d failed %s: ",
uint32_t *per_pkt_hfn = rte_crypto_op_ctod_offset(ut_params->op,
uint32_t *, IV_OFFSET);
- *per_pkt_hfn = pdcp_test_packet_direction[i] ? pdcp_test_hfn[i] : 0;
+ *per_pkt_hfn = packet_direction ? hfn : 0;
rte_security_attach_session(ut_params->op, ut_params->sec_session);
sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_PDCP;
sec_cap_idx.pdcp.domain = pdcp_test_params[i].domain;
if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (fragsz > input_vec_len)
fragsz = input_vec_len;
/* Create security session */
ut_params->sec_session = rte_security_session_create(ctx,
- &sess_conf, ts_params->session_priv_mpool);
+ &sess_conf, ts_params->session_mpool,
+ ts_params->session_priv_mpool);
if (!ut_params->sec_session) {
printf("TestCase %s()-%d line %d failed %s: ",
int
test_pdcp_proto_cplane_encap(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_ENCRYPT,
- RTE_CRYPTO_AUTH_OP_GENERATE,
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i],
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i]+4);
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
int
test_pdcp_proto_uplane_encap(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_ENCRYPT,
- RTE_CRYPTO_AUTH_OP_GENERATE,
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i],
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i]);
-
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i],
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
int
test_pdcp_proto_uplane_encap_with_int(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_ENCRYPT,
- RTE_CRYPTO_AUTH_OP_GENERATE,
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i],
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i] + 4);
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT, RTE_CRYPTO_AUTH_OP_GENERATE,
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
int
test_pdcp_proto_cplane_decap(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_DECRYPT,
- RTE_CRYPTO_AUTH_OP_VERIFY,
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i] + 4,
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i]);
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
int
test_pdcp_proto_uplane_decap(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_DECRYPT,
- RTE_CRYPTO_AUTH_OP_VERIFY,
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i],
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i]);
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i],
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
int
test_pdcp_proto_uplane_decap_with_int(int i)
{
- return test_pdcp_proto(i, 0,
- RTE_CRYPTO_CIPHER_OP_DECRYPT,
- RTE_CRYPTO_AUTH_OP_VERIFY,
- pdcp_test_data_out[i],
- pdcp_test_data_in_len[i] + 4,
- pdcp_test_data_in[i],
- pdcp_test_data_in_len[i]);
+ return test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT, RTE_CRYPTO_AUTH_OP_VERIFY,
+ pdcp_test_data_out[i], pdcp_test_data_in_len[i] + 4,
+ pdcp_test_data_in[i], pdcp_test_data_in_len[i],
+ pdcp_test_params[i].cipher_alg, pdcp_test_crypto_key[i],
+ pdcp_test_params[i].cipher_key_len,
+ pdcp_test_params[i].auth_alg, pdcp_test_auth_key[i],
+ pdcp_test_params[i].auth_key_len, pdcp_test_bearer[i],
+ pdcp_test_params[i].domain, pdcp_test_packet_direction[i],
+ pdcp_test_data_sn_size[i], pdcp_test_hfn[i],
+ pdcp_test_hfn_threshold[i], SDAP_DISABLED);
}
static int
128, 32);
}
+static int
+test_PDCP_SDAP_PROTO_encap_all(void)
+{
+ int i = 0, size = 0;
+ int err, all_err = TEST_SUCCESS;
+ const struct pdcp_sdap_test *cur_test;
+
+ size = ARRAY_SIZE(list_pdcp_sdap_tests);
+
+ for (i = 0; i < size; i++) {
+ cur_test = &list_pdcp_sdap_tests[i];
+ err = test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_ENCRYPT,
+ RTE_CRYPTO_AUTH_OP_GENERATE, cur_test->data_in,
+ cur_test->in_len, cur_test->data_out,
+ cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
+ cur_test->param.cipher_alg, cur_test->cipher_key,
+ cur_test->param.cipher_key_len,
+ cur_test->param.auth_alg,
+ cur_test->auth_key, cur_test->param.auth_key_len,
+ cur_test->bearer, cur_test->param.domain,
+ cur_test->packet_direction, cur_test->sn_size,
+ cur_test->hfn,
+ cur_test->hfn_threshold, SDAP_ENABLED);
+ if (err) {
+ printf("\t%d) %s: Encapsulation failed\n",
+ cur_test->test_idx,
+ cur_test->param.name);
+ err = TEST_FAILED;
+ } else {
+ printf("\t%d) %s: Encap PASS\n", cur_test->test_idx,
+ cur_test->param.name);
+ err = TEST_SUCCESS;
+ }
+ all_err += err;
+ }
+
+ printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
+
+ return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
+}
+
+static int
+test_PDCP_SDAP_PROTO_decap_all(void)
+{
+ int i = 0, size = 0;
+ int err, all_err = TEST_SUCCESS;
+ const struct pdcp_sdap_test *cur_test;
+
+ size = ARRAY_SIZE(list_pdcp_sdap_tests);
+
+ for (i = 0; i < size; i++) {
+ cur_test = &list_pdcp_sdap_tests[i];
+ err = test_pdcp_proto(
+ i, 0, RTE_CRYPTO_CIPHER_OP_DECRYPT,
+ RTE_CRYPTO_AUTH_OP_VERIFY,
+ cur_test->data_out,
+ cur_test->in_len + ((cur_test->auth_key) ? 4 : 0),
+ cur_test->data_in, cur_test->in_len,
+ cur_test->param.cipher_alg,
+ cur_test->cipher_key, cur_test->param.cipher_key_len,
+ cur_test->param.auth_alg, cur_test->auth_key,
+ cur_test->param.auth_key_len, cur_test->bearer,
+ cur_test->param.domain, cur_test->packet_direction,
+ cur_test->sn_size, cur_test->hfn,
+ cur_test->hfn_threshold, SDAP_ENABLED);
+ if (err) {
+ printf("\t%d) %s: Decapsulation failed\n",
+ cur_test->test_idx,
+ cur_test->param.name);
+ err = TEST_FAILED;
+ } else {
+ printf("\t%d) %s: Decap PASS\n", cur_test->test_idx,
+ cur_test->param.name);
+ err = TEST_SUCCESS;
+ }
+ all_err += err;
+ }
+
+ printf("Success: %d, Failure: %d\n", size + all_err, -all_err);
+
+ return (all_err == TEST_SUCCESS) ? TEST_SUCCESS : TEST_FAILED;
+}
+
static int
test_PDCP_PROTO_all(void)
{
uint64_t feat_flags = dev_info.feature_flags;
if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Set action type */
ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
if (security_proto_supported(ut_params->type,
RTE_SECURITY_PROTOCOL_PDCP) < 0)
- return -ENOTSUP;
+ return TEST_SKIPPED;
status = test_PDCP_PROTO_cplane_encap_all();
status += test_PDCP_PROTO_cplane_decap_all();
status += test_PDCP_PROTO_SGL_oop_32B_128B();
status += test_PDCP_PROTO_SGL_oop_32B_40B();
status += test_PDCP_PROTO_SGL_oop_128B_32B();
+ status += test_PDCP_SDAP_PROTO_encap_all();
+ status += test_PDCP_SDAP_PROTO_decap_all();
if (status)
return TEST_FAILED;
sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
if (sec_cap == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
RTE_CRYPTO_OP_TYPE_UNDEFINED) {
}
if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup source mbuf payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
/* Create security session */
ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
+ ts_params->session_mpool,
ts_params->session_priv_mpool);
if (!ut_params->sec_session) {
sec_cap = rte_security_capability_get(ctx, &sec_cap_idx);
if (sec_cap == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
while ((crypto_cap = &sec_cap->crypto_capabilities[j++])->op !=
RTE_CRYPTO_OP_TYPE_UNDEFINED) {
}
if (crypto_cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup source mbuf payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
/* Create security session */
ut_params->sec_session = rte_security_session_create(ctx, &sess_conf,
+ ts_params->session_mpool,
ts_params->session_priv_mpool);
if (!ut_params->sec_session) {
printf("\t%2d)", n++); \
printf("+++++ PASSED:" #func"\n"); \
p++; \
- } else if (ret == -ENOTSUP) { \
+ } else if (ret == TEST_SKIPPED) { \
printf("\t%2d)", n++); \
- printf("~~~~~ UNSUPP:" #func"\n"); \
- u++; \
+ printf("~~~~~ SKIPPED:" #func"\n"); \
+ s++; \
} else { \
printf("\t%2d)", n++); \
printf("----- FAILED:" #func"\n"); \
static int
test_DOCSIS_PROTO_uplink_all(void)
{
- int p = 0, u = 0, f = 0, n = 0;
+ int p = 0, s = 0, f = 0, n = 0;
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(1, &docsis_test_case_1));
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(2, &docsis_test_case_2));
TEST_DOCSIS_COUNT(test_docsis_proto_uplink(26, &docsis_test_case_26));
if (f)
- printf("## %s: %d passed out of %d (%d unsupported)\n",
- __func__, p, n, u);
+ printf("## %s: %d passed out of %d (%d skipped)\n",
+ __func__, p, n, s);
return f;
};
static int
test_DOCSIS_PROTO_downlink_all(void)
{
- int p = 0, u = 0, f = 0, n = 0;
+ int p = 0, s = 0, f = 0, n = 0;
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(1, &docsis_test_case_1));
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(2, &docsis_test_case_2));
TEST_DOCSIS_COUNT(test_docsis_proto_downlink(26, &docsis_test_case_26));
if (f)
- printf("## %s: %d passed out of %d (%d unsupported)\n",
- __func__, p, n, u);
+ printf("## %s: %d passed out of %d (%d skipped)\n",
+ __func__, p, n, s);
return f;
};
uint64_t feat_flags = dev_info.feature_flags;
if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Set action type */
ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ?
if (security_proto_supported(ut_params->type,
RTE_SECURITY_PROTOCOL_DOCSIS) < 0)
- return -ENOTSUP;
+ return TEST_SKIPPED;
status = test_DOCSIS_PROTO_uplink_all();
status += test_DOCSIS_PROTO_downlink_all();
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.iv.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.plaintext.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.ciphertext.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.aad.len += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
aad[0] += 1;
tdata.aad.data = aad;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.auth_tag.data[0] += 1;
res = test_authenticated_encryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "encryption not failed");
return TEST_SUCCESS;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
capability = rte_cryptodev_sym_capability_get(
ts_params->valid_devs[0], &cap_idx);
if (capability == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_sym_capability_check_aead(
capability, tdata->key.len, tdata->auth_tag.len,
tdata->aad.len, tdata->iv.len))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.iv.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.plaintext.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.ciphertext.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.aad.len += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
aad[0] += 1;
tdata.aad.data = aad;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "decryption not failed");
return TEST_SUCCESS;
memcpy(&tdata, &gcm_test_case_7, sizeof(struct aead_test_data));
tdata.auth_tag.data[0] += 1;
res = test_authenticated_decryption(&tdata);
- if (res == -ENOTSUP)
+ if (res == TEST_SKIPPED)
return res;
TEST_ASSERT_EQUAL(res, TEST_FAILED, "authentication not failed");
return TEST_SUCCESS;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* not supported with CPU crypto and raw data-path APIs*/
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create AEAD session */
retval = create_aead_session(ts_params->valid_devs[0],
if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
printf("Device doesn't support Sessionless ops.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
printf("Device doesn't support Sessionless ops.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* alloc mbuf and set payload */
ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool);
struct rte_cryptodev_stats stats;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA1_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats)
== -ENOTSUP)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_stats_reset(ts_params->valid_devs[0]);
TEST_ASSERT((rte_cryptodev_stats_get(ts_params->valid_devs[0] + 600,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (MD5_HMAC_create_session(ts_params, ut_params,
RTE_CRYPTO_AUTH_OP_GENERATE, test_case))
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = RTE_CRYPTO_AUTH_MD5_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (MD5_HMAC_create_session(ts_params, ut_params,
RTE_CRYPTO_AUTH_OP_VERIFY, test_case)) {
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
test_AES_CBC_HMAC_SHA512_decrypt_create_session_params(ut_params,
aes_cbc_key, hmac_sha512_key);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_SHA512_HMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_AES_CBC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
/* This test is for NULL PMD only */
if (gbl_driver_id != rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
/* This test is for NULL PMD only */
if (gbl_driver_id != rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_NULL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Setup Cipher Parameters */
ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
ut_params->sess = rte_cryptodev_sym_session_create(
ts_params->session_mpool);
- /* Create Crypto session*/
- rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
- ut_params->sess, &ut_params->cipher_xform,
- ts_params->session_priv_mpool);
- TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+ /* Create Crypto session*/
+ rte_cryptodev_sym_session_init(ts_params->valid_devs[0],
+ ut_params->sess, &ut_params->cipher_xform,
+ ts_params->session_priv_mpool);
+ TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed");
+
+ TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
+ RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
+ burst_len, "failed to generate burst of crypto ops");
+
+ /* Generate an operation for each mbuf in burst */
+ for (i = 0; i < burst_len; i++) {
+ struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+
+ TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
+
+ unsigned *data = (unsigned *)rte_pktmbuf_append(m,
+ sizeof(unsigned));
+ *data = i;
+
+ rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
+
+ burst[i]->sym->m_src = m;
+ }
+
+ /* Process crypto operation */
+ TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
+ 0, burst, burst_len),
+ burst_len,
+ "Error enqueuing burst");
+
+ TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
+ 0, burst_dequeued, burst_len),
+ burst_len,
+ "Error dequeuing burst");
+
+
+ for (i = 0; i < burst_len; i++) {
+ TEST_ASSERT_EQUAL(
+ *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
+ *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
+ uint32_t *),
+ "data not as expected");
+
+ rte_pktmbuf_free(burst[i]->sym->m_src);
+ rte_crypto_op_free(burst[i]);
+ }
+
+ return TEST_SUCCESS;
+}
+
+static uint16_t
+test_enq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
+ uint16_t nb_ops, void *user_param)
+{
+ RTE_SET_USED(dev_id);
+ RTE_SET_USED(qp_id);
+ RTE_SET_USED(ops);
+ RTE_SET_USED(user_param);
+
+ printf("crypto enqueue callback called\n");
+ return nb_ops;
+}
+
+static uint16_t
+test_deq_callback(uint16_t dev_id, uint16_t qp_id, struct rte_crypto_op **ops,
+ uint16_t nb_ops, void *user_param)
+{
+ RTE_SET_USED(dev_id);
+ RTE_SET_USED(qp_id);
+ RTE_SET_USED(ops);
+ RTE_SET_USED(user_param);
+
+ printf("crypto dequeue callback called\n");
+ return nb_ops;
+}
+
+/*
+ * Thread using enqueue/dequeue callback with RCU.
+ */
+static int
+test_enqdeq_callback_thread(void *arg)
+{
+ RTE_SET_USED(arg);
+ /* DP thread calls rte_cryptodev_enqueue_burst()/
+ * rte_cryptodev_dequeue_burst() and invokes callback.
+ */
+ test_null_burst_operation();
+ return 0;
+}
+
+static int
+test_enq_callback_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct rte_cryptodev_info dev_info;
+ struct rte_cryptodev_qp_conf qp_conf = {
+ .nb_descriptors = MAX_NUM_OPS_INFLIGHT
+ };
+
+ struct rte_cryptodev_cb *cb;
+ uint16_t qp_id = 0;
+
+ /* Stop the device in case it's started so it can be configured */
+ rte_cryptodev_stop(ts_params->valid_devs[0]);
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
+
+ TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
+ &ts_params->conf),
+ "Failed to configure cryptodev %u",
+ ts_params->valid_devs[0]);
+
+ qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
+ qp_conf.mp_session = ts_params->session_mpool;
+ qp_conf.mp_session_private = ts_params->session_priv_mpool;
+
+ TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
+ ts_params->valid_devs[0], qp_id, &qp_conf,
+ rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+ "Failed test for "
+ "rte_cryptodev_queue_pair_setup: num_inflights "
+ "%u on qp %u on cryptodev %u",
+ qp_conf.nb_descriptors, qp_id,
+ ts_params->valid_devs[0]);
+
+ /* Test with invalid crypto device */
+ cb = rte_cryptodev_add_enq_callback(RTE_CRYPTO_MAX_DEVS,
+ qp_id, test_enq_callback, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ qp_id, RTE_CRYPTO_MAX_DEVS);
+
+ /* Test with invalid queue pair */
+ cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
+ dev_info.max_nb_queue_pairs + 1,
+ test_enq_callback, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ dev_info.max_nb_queue_pairs + 1,
+ ts_params->valid_devs[0]);
+
+ /* Test with NULL callback */
+ cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
+ qp_id, NULL, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ qp_id, ts_params->valid_devs[0]);
+
+ /* Test with valid configuration */
+ cb = rte_cryptodev_add_enq_callback(ts_params->valid_devs[0],
+ qp_id, test_enq_callback, NULL);
+ TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
+ "qp %u on cryptodev %u",
+ qp_id, ts_params->valid_devs[0]);
+
+ rte_cryptodev_start(ts_params->valid_devs[0]);
+
+ /* Launch a thread */
+ rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
+ rte_get_next_lcore(-1, 1, 0));
+
+ /* Wait until reader exited. */
+ rte_eal_mp_wait_lcore();
+
+ /* Test with invalid crypto device */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
+ RTE_CRYPTO_MAX_DEVS, qp_id, cb),
+ "Expected call to fail as crypto device is invalid");
+
+ /* Test with invalid queue pair */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
+ ts_params->valid_devs[0],
+ dev_info.max_nb_queue_pairs + 1, cb),
+ "Expected call to fail as queue pair is invalid");
+
+ /* Test with NULL callback */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_enq_callback(
+ ts_params->valid_devs[0], qp_id, NULL),
+ "Expected call to fail as callback is NULL");
+
+ /* Test with valid configuration */
+ TEST_ASSERT_SUCCESS(rte_cryptodev_remove_enq_callback(
+ ts_params->valid_devs[0], qp_id, cb),
+ "Failed test to remove callback on "
+ "qp %u on cryptodev %u",
+ qp_id, ts_params->valid_devs[0]);
+
+ return TEST_SUCCESS;
+}
+
+static int
+test_deq_callback_setup(void)
+{
+ struct crypto_testsuite_params *ts_params = &testsuite_params;
+ struct rte_cryptodev_info dev_info;
+ struct rte_cryptodev_qp_conf qp_conf = {
+ .nb_descriptors = MAX_NUM_OPS_INFLIGHT
+ };
+
+ struct rte_cryptodev_cb *cb;
+ uint16_t qp_id = 0;
+
+ /* Stop the device in case it's started so it can be configured */
+ rte_cryptodev_stop(ts_params->valid_devs[0]);
+
+ rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
- TEST_ASSERT_EQUAL(rte_crypto_op_bulk_alloc(ts_params->op_mpool,
- RTE_CRYPTO_OP_TYPE_SYMMETRIC, burst, burst_len),
- burst_len, "failed to generate burst of crypto ops");
+ TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
+ &ts_params->conf),
+ "Failed to configure cryptodev %u",
+ ts_params->valid_devs[0]);
- /* Generate an operation for each mbuf in burst */
- for (i = 0; i < burst_len; i++) {
- struct rte_mbuf *m = rte_pktmbuf_alloc(ts_params->mbuf_pool);
+ qp_conf.nb_descriptors = MAX_NUM_OPS_INFLIGHT;
+ qp_conf.mp_session = ts_params->session_mpool;
+ qp_conf.mp_session_private = ts_params->session_priv_mpool;
- TEST_ASSERT_NOT_NULL(m, "Failed to allocate mbuf");
+ TEST_ASSERT_SUCCESS(rte_cryptodev_queue_pair_setup(
+ ts_params->valid_devs[0], qp_id, &qp_conf,
+ rte_cryptodev_socket_id(ts_params->valid_devs[0])),
+ "Failed test for "
+ "rte_cryptodev_queue_pair_setup: num_inflights "
+ "%u on qp %u on cryptodev %u",
+ qp_conf.nb_descriptors, qp_id,
+ ts_params->valid_devs[0]);
- unsigned *data = (unsigned *)rte_pktmbuf_append(m,
- sizeof(unsigned));
- *data = i;
+ /* Test with invalid crypto device */
+ cb = rte_cryptodev_add_deq_callback(RTE_CRYPTO_MAX_DEVS,
+ qp_id, test_deq_callback, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ qp_id, RTE_CRYPTO_MAX_DEVS);
+
+ /* Test with invalid queue pair */
+ cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
+ dev_info.max_nb_queue_pairs + 1,
+ test_deq_callback, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ dev_info.max_nb_queue_pairs + 1,
+ ts_params->valid_devs[0]);
- rte_crypto_op_attach_sym_session(burst[i], ut_params->sess);
+ /* Test with NULL callback */
+ cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
+ qp_id, NULL, NULL);
+ TEST_ASSERT_NULL(cb, "Add callback on qp %u on "
+ "cryptodev %u did not fail",
+ qp_id, ts_params->valid_devs[0]);
- burst[i]->sym->m_src = m;
- }
+ /* Test with valid configuration */
+ cb = rte_cryptodev_add_deq_callback(ts_params->valid_devs[0],
+ qp_id, test_deq_callback, NULL);
+ TEST_ASSERT_NOT_NULL(cb, "Failed test to add callback on "
+ "qp %u on cryptodev %u",
+ qp_id, ts_params->valid_devs[0]);
- /* Process crypto operation */
- TEST_ASSERT_EQUAL(rte_cryptodev_enqueue_burst(ts_params->valid_devs[0],
- 0, burst, burst_len),
- burst_len,
- "Error enqueuing burst");
+ rte_cryptodev_start(ts_params->valid_devs[0]);
- TEST_ASSERT_EQUAL(rte_cryptodev_dequeue_burst(ts_params->valid_devs[0],
- 0, burst_dequeued, burst_len),
- burst_len,
- "Error dequeuing burst");
+ /* Launch a thread */
+ rte_eal_remote_launch(test_enqdeq_callback_thread, NULL,
+ rte_get_next_lcore(-1, 1, 0));
+ /* Wait until reader exited. */
+ rte_eal_mp_wait_lcore();
- for (i = 0; i < burst_len; i++) {
- TEST_ASSERT_EQUAL(
- *rte_pktmbuf_mtod(burst[i]->sym->m_src, uint32_t *),
- *rte_pktmbuf_mtod(burst_dequeued[i]->sym->m_src,
- uint32_t *),
- "data not as expected");
+ /* Test with invalid crypto device */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
+ RTE_CRYPTO_MAX_DEVS, qp_id, cb),
+ "Expected call to fail as crypto device is invalid");
- rte_pktmbuf_free(burst[i]->sym->m_src);
- rte_crypto_op_free(burst[i]);
- }
+ /* Test with invalid queue pair */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
+ ts_params->valid_devs[0],
+ dev_info.max_nb_queue_pairs + 1, cb),
+ "Expected call to fail as queue pair is invalid");
+
+ /* Test with NULL callback */
+ TEST_ASSERT_FAIL(rte_cryptodev_remove_deq_callback(
+ ts_params->valid_devs[0], qp_id, NULL),
+ "Expected call to fail as callback is NULL");
+
+ /* Test with valid configuration */
+ TEST_ASSERT_SUCCESS(rte_cryptodev_remove_deq_callback(
+ ts_params->valid_devs[0], qp_id, cb),
+ "Failed test to remove callback on "
+ "qp %u on cryptodev %u",
+ qp_id, ts_params->valid_devs[0]);
return TEST_SUCCESS;
}
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
int retval;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
retval = create_gmac_session(ts_params->valid_devs[0],
tdata, RTE_CRYPTO_AUTH_OP_GENERATE);
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
retval = create_gmac_session(ts_params->valid_devs[0],
tdata, RTE_CRYPTO_AUTH_OP_VERIFY);
cap_idx.algo.auth = RTE_CRYPTO_AUTH_AES_GMAC;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Check for any input SGL support */
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;
+ return TEST_SKIPPED;
if (fragsz > tdata->plaintext.len)
fragsz = tdata->plaintext.len;
ut_params->op->sym->m_src = ut_params->ibuf;
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
TEST_ASSERT_NOT_NULL(
process_crypto_request(ts_params->valid_devs[0],
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
retval = create_auth_cipher_session(ut_params,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
retval = create_auth_cipher_session(ut_params,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
memcpy(cipher_key, reference->cipher_key.data,
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
/* Verify the capabilities */
cap_idx.algo.auth = reference->auth_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = reference->crypto_algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Create session */
memcpy(cipher_key, reference->cipher_key.data,
cap_idx.algo.aead = tdata->algo;
if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0],
&cap_idx) == NULL)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* OOP not supported with CPU crypto */
if (oop && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
- return -ENOTSUP;
+ return TEST_SKIPPED;
/* Detailed check for the particular SGL support flag */
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
unsigned int sgl_in = fragsz < tdata->plaintext.len;
if (sgl_in && (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
uint64_t feat_flags = dev_info.feature_flags;
if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
(!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) {
printf("Device doesn't support RAW data-path APIs.\n");
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
} else {
unsigned int sgl_in = fragsz < tdata->plaintext.len;
tdata->plaintext.len;
/* Raw data path API does not support OOP */
if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
- return -ENOTSUP;
+ return TEST_SKIPPED;
if (sgl_in && !sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
} else if (!sgl_in && sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
} else if (sgl_in && sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))
- return -ENOTSUP;
+ return TEST_SKIPPED;
}
}
/* This test is not for OPENSSL PMD */
if (gbl_driver_id == rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD)))
- return -ENOTSUP;
+ return TEST_SKIPPED;
return test_authenticated_encryption_SGL(
&gcm_test_case_SGL_1, IN_PLACE, 1500, 0);
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];
+static int
+scheduler_testsuite_setup(void)
+{
+ uint32_t i = 0;
+ int32_t nb_devs, ret;
+ char vdev_args[VDEV_ARGS_SIZE] = {""};
+ char temp_str[VDEV_ARGS_SIZE] = {"mode=multi-core,"
+ "ordering=enable,name=cryptodev_test_scheduler,corelist="};
+ uint16_t worker_core_count = 0;
+ uint16_t socket_id = 0;
+
+ if (gbl_driver_id == rte_cryptodev_driver_id_get(
+ RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD))) {
+
+ /* Identify the Worker Cores
+ * Use 2 worker cores for the device args
+ */
+ RTE_LCORE_FOREACH_WORKER(i) {
+ if (worker_core_count > 1)
+ break;
+ snprintf(vdev_args, sizeof(vdev_args),
+ "%s%d", temp_str, i);
+ strcpy(temp_str, vdev_args);
+ strlcat(temp_str, ";", sizeof(temp_str));
+ worker_core_count++;
+ socket_id = rte_lcore_to_socket_id(i);
+ }
+ if (worker_core_count != 2) {
+ RTE_LOG(ERR, USER1,
+ "Cryptodev scheduler test require at least "
+ "two worker cores to run. "
+ "Please use the correct coremask.\n");
+ return TEST_FAILED;
+ }
+ strcpy(temp_str, vdev_args);
+ snprintf(vdev_args, sizeof(vdev_args), "%s,socket_id=%d",
+ temp_str, socket_id);
+ RTE_LOG(DEBUG, USER1, "vdev_args: %s\n", vdev_args);
+ nb_devs = rte_cryptodev_device_count_by_driver(
+ rte_cryptodev_driver_id_get(
+ RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD)));
+ if (nb_devs < 1) {
+ ret = rte_vdev_init(
+ RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD),
+ vdev_args);
+ TEST_ASSERT(ret == 0,
+ "Failed to create instance %u of pmd : %s",
+ i, RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
+ }
+ }
+ return testsuite_setup();
+}
+
static int
test_scheduler_attach_slave_op(void)
{
return 0;
}
-static struct unit_test_suite cryptodev_scheduler_testsuite = {
- .suite_name = "Crypto Device Scheduler Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- /* Multi Core */
- TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
- TEST_CASE_ST(NULL, NULL, test_scheduler_mode_multicore_op),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+static int
+scheduler_multicore_testsuite_setup(void)
+{
+ if (test_scheduler_attach_slave_op() < 0)
+ return TEST_SKIPPED;
+ if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0)
+ return TEST_SKIPPED;
+ return 0;
+}
- /* Round Robin */
- TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
- TEST_CASE_ST(NULL, NULL, test_scheduler_mode_roundrobin_op),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+static int
+scheduler_roundrobin_testsuite_setup(void)
+{
+ if (test_scheduler_attach_slave_op() < 0)
+ return TEST_SKIPPED;
+ if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0)
+ return TEST_SKIPPED;
+ return 0;
+}
- /* Fail over */
- TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
- TEST_CASE_ST(NULL, NULL, test_scheduler_mode_failover_op),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+static int
+scheduler_failover_testsuite_setup(void)
+{
+ if (test_scheduler_attach_slave_op() < 0)
+ return TEST_SKIPPED;
+ if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0)
+ return TEST_SKIPPED;
+ return 0;
+}
- /* PKT SIZE */
- TEST_CASE_ST(NULL, NULL, test_scheduler_attach_slave_op),
- TEST_CASE_ST(NULL, NULL, test_scheduler_mode_pkt_size_distr_op),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(NULL, NULL, test_scheduler_detach_slave_op),
+static int
+scheduler_pkt_size_distr_testsuite_setup(void)
+{
+ if (test_scheduler_attach_slave_op() < 0)
+ return TEST_SKIPPED;
+ if (test_scheduler_mode_op(CDEV_SCHED_MODE_PKT_SIZE_DISTR) < 0)
+ return TEST_SKIPPED;
+ return 0;
+}
+
+static void
+scheduler_mode_testsuite_teardown(void)
+{
+ test_scheduler_detach_slave_op();
+}
+#endif /* RTE_CRYPTO_SCHEDULER */
+
+static struct unit_test_suite end_testsuite = {
+ .suite_name = NULL,
+ .setup = NULL,
+ .teardown = NULL,
+ .unit_test_suites = NULL
+};
+
+#ifdef RTE_LIB_SECURITY
+static struct unit_test_suite pdcp_proto_testsuite = {
+ .suite_name = "PDCP Proto Unit Test Suite",
+ .setup = pdcp_proto_testsuite_setup,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup_security, ut_teardown,
+ test_PDCP_PROTO_all),
TEST_CASES_END() /**< NULL terminate unit test array */
}
};
-#endif /* RTE_LIBRTE_PMD_CRYPTO_SCHEDULER */
+static struct unit_test_suite docsis_proto_testsuite = {
+ .suite_name = "Docsis Proto Unit Test Suite",
+ .setup = docsis_proto_testsuite_setup,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup_security, ut_teardown,
+ test_DOCSIS_PROTO_all),
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+#endif
-static struct unit_test_suite cryptodev_testsuite = {
- .suite_name = "Crypto Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
+static struct unit_test_suite cryptodev_gen_testsuite = {
+ .suite_name = "Crypto General Unit Test Suite",
+ .setup = crypto_gen_testsuite_setup,
.unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_device_configure_invalid_dev_id),
test_queue_pair_descriptor_setup),
TEST_CASE_ST(ut_setup, ut_teardown,
test_device_configure_invalid_queue_pair_ids),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
-
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_null_invalid_operation),
- TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
-
TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_DES_docsis_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
TEST_CASE_ST(ut_setup, ut_teardown, test_stats),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_enq_callback_setup),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_deq_callback_setup),
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_negative_hmac_sha1_testsuite = {
+ .suite_name = "Negative HMAC SHA1 Unit Test Suite",
+ .setup = negative_hmac_sha1_testsuite_setup,
+ .unit_test_cases = {
+ /** Negative tests */
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ authentication_verify_HMAC_SHA1_fail_data_corrupt),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
- /** AES CCM Authenticated Encryption 128 bits key */
+static struct unit_test_suite cryptodev_multi_session_testsuite = {
+ .suite_name = "Multi Session Unit Test Suite",
+ .setup = multi_session_testsuite_setup,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_multi_session_random_usage),
+
+ TEST_CASES_END() /**< NULL terminate unit test array */
+ }
+};
+
+static struct unit_test_suite cryptodev_null_testsuite = {
+ .suite_name = "NULL Test Suite",
+ .setup = null_testsuite_setup,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_null_invalid_operation),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_null_burst_operation),
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_aes_ccm_auth_testsuite = {
+ .suite_name = "AES CCM Authenticated Test Suite",
+ .setup = aes_ccm_auth_testsuite_setup,
+ .unit_test_cases = {
+ /** AES CCM Authenticated Encryption 128 bits key*/
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_CCM_authenticated_encryption_test_case_128_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_CCM_authenticated_decryption_test_case_256_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_CCM_authenticated_decryption_test_case_256_3),
+ TEST_CASES_END()
+ }
+};
+static struct unit_test_suite cryptodev_aes_gcm_auth_testsuite = {
+ .suite_name = "AES GCM Authenticated Test Suite",
+ .setup = aes_gcm_auth_testsuite_setup,
+ .unit_test_cases = {
/** AES GCM Authenticated Encryption */
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_auth_encrypt_SGL_in_place_1500B),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_authenticated_decryption_sessionless_test_case_1),
- /** AES GMAC Authentication */
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_aes_gmac_auth_testsuite = {
+ .suite_name = "AES GMAC Authentication Test Suite",
+ .setup = aes_gmac_auth_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GMAC_authentication_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GMAC_authentication_SGL_2047B),
- /** Chacha20-Poly1305 */
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_chacha20_poly1305_testsuite = {
+ .suite_name = "Chacha20-Poly1305 Test Suite",
+ .setup = chacha20_poly1305_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_chacha20_poly1305_encrypt_test_case_rfc8439),
TEST_CASE_ST(ut_setup, ut_teardown,
test_chacha20_poly1305_decrypt_test_case_rfc8439),
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_snow3g_testsuite = {
+ .suite_name = "SNOW 3G Test Suite",
+ .setup = snow3g_testsuite_setup,
+ .unit_test_cases = {
/** SNOW 3G encrypt only (UEA2) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_encryption_test_case_1),
test_snow3g_hash_generate_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_generate_test_case_3),
+
/* Tests with buffers which length is not byte-aligned */
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_generate_test_case_4),
test_snow3g_hash_verify_test_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_verify_test_case_3),
+
/* Tests with buffers which length is not byte-aligned */
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_hash_verify_test_case_4),
test_snow3g_cipher_auth_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_snow3g_auth_cipher_with_digest_test_case_1),
+ TEST_CASES_END()
+ }
+};
+static struct unit_test_suite cryptodev_zuc_testsuite = {
+ .suite_name = "ZUC Test Suite",
+ .setup = zuc_testsuite_setup,
+ .unit_test_cases = {
/** ZUC encrypt only (EEA3) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_encryption_test_case_1),
test_zuc_auth_cipher_verify_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
test_zuc_auth_cipher_verify_test_case_1_oop_sgl),
+ TEST_CASES_END()
+ }
+};
- /** HMAC_MD5 Authentication */
+static struct unit_test_suite cryptodev_hmac_md5_auth_testsuite = {
+ .suite_name = "HMAC_MD5 Authentication Test Suite",
+ .setup = hmac_md5_auth_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_MD5_HMAC_generate_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_MD5_HMAC_generate_case_2),
TEST_CASE_ST(ut_setup, ut_teardown,
test_MD5_HMAC_verify_case_2),
+ TEST_CASES_END()
+ }
+};
+static struct unit_test_suite cryptodev_kasumi_testsuite = {
+ .suite_name = "Kasumi Test Suite",
+ .setup = kasumi_testsuite_setup,
+ .unit_test_cases = {
/** KASUMI hash only (UIA1) */
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_hash_generate_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_kasumi_auth_cipher_verify_test_case_2_oop_sgl),
- /** ESN Testcase */
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_esn_testsuite = {
+ .suite_name = "ESN Test Suite",
+ .setup = esn_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
auth_encrypt_AES128CBC_HMAC_SHA1_esn_check),
TEST_CASE_ST(ut_setup, ut_teardown,
auth_decrypt_AES128CBC_HMAC_SHA1_esn_check),
+ TEST_CASES_END()
+ }
+};
- /** Negative tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
+static struct unit_test_suite cryptodev_negative_aes_gcm_testsuite = {
+ .suite_name = "Negative AES GCM Test Suite",
+ .setup = negative_aes_gcm_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_auth_encryption_fail_iv_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_auth_decryption_fail_aad_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
test_AES_GCM_auth_decryption_fail_tag_corrupt),
+
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_negative_aes_gmac_testsuite = {
+ .suite_name = "Negative AES GMAC Test Suite",
+ .setup = negative_aes_gmac_testsuite_setup,
+ .unit_test_cases = {
TEST_CASE_ST(ut_setup, ut_teardown,
authentication_verify_AES128_GMAC_fail_data_corrupt),
TEST_CASE_ST(ut_setup, ut_teardown,
authentication_verify_AES128_GMAC_fail_tag_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
- /** Mixed CIPHER + HASH algorithms */
+ TEST_CASES_END()
+ }
+};
+
+static struct unit_test_suite cryptodev_mixed_cipher_hash_testsuite = {
+ .suite_name = "Mixed CIPHER + HASH algorithms Test Suite",
+ .setup = mixed_cipher_hash_testsuite_setup,
+ .unit_test_cases = {
/** AUTH AES CMAC + CIPHER AES CTR */
TEST_CASE_ST(ut_setup, ut_teardown,
test_aes_cmac_aes_ctr_digest_enc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_sgl),
TEST_CASE_ST(ut_setup, ut_teardown,
- test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
+ test_verify_aes_cmac_aes_ctr_digest_enc_test_case_1_oop_sgl),
/** AUTH ZUC + CIPHER SNOW3G */
TEST_CASE_ST(ut_setup, ut_teardown,
test_auth_aes_cmac_cipher_null_test_case_1),
TEST_CASE_ST(ut_setup, ut_teardown,
test_verify_auth_aes_cmac_cipher_null_test_case_1),
-
-#ifdef RTE_LIBRTE_SECURITY
- TEST_CASE_ST(ut_setup_security, ut_teardown,
- test_PDCP_PROTO_all),
- TEST_CASE_ST(ut_setup_security, ut_teardown,
- test_DOCSIS_PROTO_all),
-#endif
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_virtio_testsuite = {
- .suite_name = "Crypto VIRTIO Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
-
-static struct unit_test_suite cryptodev_caam_jr_testsuite = {
- .suite_name = "Crypto CAAM JR Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_device_configure_invalid_dev_id),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session),
-
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
-
- TEST_CASES_END() /**< NULL terminate unit test array */
+ TEST_CASES_END()
}
};
-static struct unit_test_suite cryptodev_mrvl_testsuite = {
- .suite_name = "Crypto Device Marvell Component Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
+static int
+run_cryptodev_testsuite(const char *pmd_name)
+{
+ uint8_t ret, j, i = 0;
+ struct unit_test_suite *static_suites[] = {
+ &cryptodev_multi_session_testsuite,
+ &cryptodev_null_testsuite,
+ &cryptodev_aes_ccm_auth_testsuite,
+ &cryptodev_aes_gcm_auth_testsuite,
+ &cryptodev_aes_gmac_auth_testsuite,
+ &cryptodev_snow3g_testsuite,
+ &cryptodev_chacha20_poly1305_testsuite,
+ &cryptodev_zuc_testsuite,
+ &cryptodev_hmac_md5_auth_testsuite,
+ &cryptodev_kasumi_testsuite,
+ &cryptodev_esn_testsuite,
+ &cryptodev_negative_aes_gcm_testsuite,
+ &cryptodev_negative_aes_gmac_testsuite,
+ &cryptodev_mixed_cipher_hash_testsuite,
+ &cryptodev_negative_hmac_sha1_testsuite,
+ &cryptodev_gen_testsuite,
+#ifdef RTE_LIB_SECURITY
+ &pdcp_proto_testsuite,
+ &docsis_proto_testsuite,
+#endif
+ &end_testsuite
+ };
+ static struct unit_test_suite ts = {
+ .suite_name = "Cryptodev Unit Test Suite",
+ .setup = testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {TEST_CASES_END()}
+ };
- /** Negative tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+ gbl_driver_id = rte_cryptodev_driver_id_get(pmd_name);
- TEST_CASES_END() /**< NULL terminate unit test array */
+ if (gbl_driver_id == -1) {
+ RTE_LOG(ERR, USER1, "%s PMD must be loaded.\n", pmd_name);
+ return TEST_FAILED;
}
-};
-static struct unit_test_suite cryptodev_ccp_testsuite = {
- .suite_name = "Crypto Device CCP Unit Test Suite",
- .setup = testsuite_setup,
- .teardown = testsuite_teardown,
- .unit_test_cases = {
- TEST_CASE_ST(ut_setup, ut_teardown, test_multi_session),
- TEST_CASE_ST(ut_setup, ut_teardown,
- test_multi_session_random_usage),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_AES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_cipheronly_all),
- TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
+ RTE_DIM(static_suites));
- /** Negative tests */
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- authentication_verify_HMAC_SHA1_fail_tag_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_data_corrupt),
- TEST_CASE_ST(ut_setup, ut_teardown,
- auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt),
+ ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
+ ret = unit_test_suite_runner(&ts);
- TEST_CASES_END() /**< NULL terminate unit test array */
- }
-};
+ free(ts.unit_test_suites);
+ return ret;
+}
static int
test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "QAT PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
}
static int
test_cryptodev_virtio(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "VIRTIO PMD must be loaded.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_virtio_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
}
static int
test_cryptodev_aesni_mb(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
}
static int
test_cryptodev_cpu_aesni_mb(void)
{
int32_t rc;
- enum rte_security_session_action_type at;
-
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- at = gbl_action_type;
+ enum rte_security_session_action_type at = gbl_action_type;
gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
- rc = unit_test_suite_runner(&cryptodev_testsuite);
+ rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
gbl_action_type = at;
return rc;
}
static int
test_cryptodev_openssl(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "OPENSSL PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
}
static int
test_cryptodev_aesni_gcm(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
}
static int
test_cryptodev_cpu_aesni_gcm(void)
{
int32_t rc;
- enum rte_security_session_action_type at;
-
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "AESNI GCM PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- at = gbl_action_type;
+ enum rte_security_session_action_type at = gbl_action_type;
gbl_action_type = RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO;
- rc = unit_test_suite_runner(&cryptodev_testsuite);
+ rc = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_AESNI_GCM_PMD));
gbl_action_type = at;
return rc;
}
static int
test_cryptodev_null(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NULL_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "NULL PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NULL_PMD));
}
static int
test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "SNOW3G PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_SNOW3G_PMD));
}
static int
test_cryptodev_sw_kasumi(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD));
}
static int
test_cryptodev_sw_zuc(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "ZUC PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ZUC_PMD));
}
static int
test_cryptodev_armv8(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "ARMV8 PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
}
static int
test_cryptodev_mrvl(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "MVSAM PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_mrvl_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
}
-#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER
+#ifdef RTE_CRYPTO_SCHEDULER
static int
test_cryptodev_scheduler(void /*argv __rte_unused, int argc __rte_unused*/)
{
+ uint8_t ret, j, i = 0;
+ static struct unit_test_suite scheduler_multicore = {
+ .suite_name = "Scheduler Multicore Unit Test Suite",
+ .setup = scheduler_multicore_testsuite_setup,
+ .teardown = scheduler_mode_testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASES_END()
+ }
+ };
+ static struct unit_test_suite scheduler_round_robin = {
+ .suite_name = "Scheduler Round Robin Unit Test Suite",
+ .setup = scheduler_roundrobin_testsuite_setup,
+ .teardown = scheduler_mode_testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASES_END()
+ }
+ };
+ static struct unit_test_suite scheduler_failover = {
+ .suite_name = "Scheduler Failover Unit Test Suite",
+ .setup = scheduler_failover_testsuite_setup,
+ .teardown = scheduler_mode_testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASES_END()
+ }
+ };
+ static struct unit_test_suite scheduler_pkt_size_distr = {
+ .suite_name = "Scheduler Pkt Size Distr Unit Test Suite",
+ .setup = scheduler_pkt_size_distr_testsuite_setup,
+ .teardown = scheduler_mode_testsuite_teardown,
+ .unit_test_cases = {
+ TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all),
+ TEST_CASE_ST(ut_setup, ut_teardown,
+ test_AES_cipheronly_all),
+ TEST_CASE_ST(ut_setup, ut_teardown, test_authonly_all),
+ TEST_CASES_END()
+ }
+ };
+ struct unit_test_suite *sched_mode_suites[] = {
+ &scheduler_multicore,
+ &scheduler_round_robin,
+ &scheduler_failover,
+ &scheduler_pkt_size_distr
+ };
+ static struct unit_test_suite scheduler_config = {
+ .suite_name = "Crypto Device Scheduler Config Unit Test Suite",
+ .unit_test_cases = {
+ TEST_CASE(test_scheduler_attach_slave_op),
+ TEST_CASE(test_scheduler_mode_multicore_op),
+ TEST_CASE(test_scheduler_mode_roundrobin_op),
+ TEST_CASE(test_scheduler_mode_failover_op),
+ TEST_CASE(test_scheduler_mode_pkt_size_distr_op),
+ TEST_CASE(test_scheduler_detach_slave_op),
+
+ TEST_CASES_END() /**< NULL terminate array */
+ }
+ };
+ struct unit_test_suite *static_suites[] = {
+ &scheduler_config,
+ &end_testsuite
+ };
+ static struct unit_test_suite ts = {
+ .suite_name = "Scheduler Unit Test Suite",
+ .setup = scheduler_testsuite_setup,
+ .teardown = testsuite_teardown,
+ .unit_test_cases = {TEST_CASES_END()}
+ };
+
gbl_driver_id = rte_cryptodev_driver_id_get(
RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) {
RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n");
return TEST_SKIPPED;
-}
- return unit_test_suite_runner(&cryptodev_scheduler_testsuite);
+ }
+
+ ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) *
+ (RTE_DIM(static_suites) + RTE_DIM(sched_mode_suites)));
+ ADD_STATIC_TESTSUITE(i, ts, sched_mode_suites,
+ RTE_DIM(sched_mode_suites));
+ ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites));
+ ret = unit_test_suite_runner(&ts);
+
+ free(ts.unit_test_suites);
+ return ret;
}
REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler);
static int
test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
}
static int
test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded.\n");
- return TEST_SKIPPED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
}
static int
test_cryptodev_ccp(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "CCP PMD must be loaded.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_ccp_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD));
}
static int
test_cryptodev_octeontx(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "OCTEONTX PMD must be loaded.\n");
- return TEST_FAILED;
- }
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
}
static int
test_cryptodev_octeontx2(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "OCTEON TX2 PMD must be loaded.\n");
- return TEST_FAILED;
- }
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD));
}
static int
test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_caam_jr_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
}
static int
test_cryptodev_nitrox(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "NITROX PMD must be loaded.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD));
}
static int
test_cryptodev_bcmfs(void)
{
- gbl_driver_id = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
-
- if (gbl_driver_id == -1) {
- RTE_LOG(ERR, USER1, "BCMFS PMD must be loaded.\n");
- return TEST_FAILED;
- }
-
- return unit_test_suite_runner(&cryptodev_testsuite);
+ return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD));
}
static int
{
int ret;
- gbl_driver_id = rte_cryptodev_driver_id_get(
- 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");
- return TEST_SKIPPED;
- }
-
global_api_test_type = CRYPTODEV_RAW_API_TEST;
- ret = unit_test_suite_runner(&cryptodev_testsuite);
+ ret = run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
global_api_test_type = CRYPTODEV_API_TEST;
return ret;