X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest%2Ftest_cryptodev.c;h=f2c3c1f6d1aaea7f2fff9eb3e10883455f38c7fe;hb=f93fce6de4aa9c5cf90212d5d33ef0c0335c259e;hp=42e47059a9536e34c180cc142ee621fdc8e95245;hpb=27f30e288eb6aebf36c9e5a73ce71aa549630cc5;p=dpdk.git diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c index 42e47059a9..f2c3c1f6d1 100644 --- a/app/test/test_cryptodev.c +++ b/app/test/test_cryptodev.c @@ -1,5 +1,6 @@ /* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2015-2020 Intel Corporation + * Copyright 2020 NXP */ #include @@ -15,10 +16,12 @@ #include #include -#include +#include #include +#include +#include -#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER +#ifdef RTE_CRYPTO_SCHEDULER #include #include #endif @@ -40,15 +43,25 @@ #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_ipsec.h" +#include "test_cryptodev_security_ipsec_test_vectors.h" #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 MAX_NB_SESSIONS 4 +#define MAX_DRV_SERVICE_CTX_SIZE 256 + +#define MAX_RAW_DEQUEUE_COUNT 65535 + #define IN_PLACE 0 #define OUT_OF_PLACE 1 @@ -57,34 +70,23 @@ static int gbl_driver_id; static enum rte_security_session_action_type gbl_action_type = RTE_SECURITY_ACTION_TYPE_NONE; -struct crypto_testsuite_params { - struct rte_mempool *mbuf_pool; - struct rte_mempool *large_mbuf_pool; - struct rte_mempool *op_mpool; - struct rte_mempool *session_mpool; - struct rte_mempool *session_priv_mpool; - struct rte_cryptodev_config conf; - struct rte_cryptodev_qp_conf qp_conf; - - uint8_t valid_devs[RTE_CRYPTO_MAX_DEVS]; - uint8_t valid_dev_count; -}; +enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST; struct crypto_unittest_params { struct rte_crypto_sym_xform cipher_xform; struct rte_crypto_sym_xform auth_xform; struct rte_crypto_sym_xform aead_xform; -#ifdef RTE_LIBRTE_SECURITY +#ifdef RTE_LIB_SECURITY struct rte_security_docsis_xform docsis_xform; #endif union { struct rte_cryptodev_sym_session *sess; -#ifdef RTE_LIBRTE_SECURITY +#ifdef RTE_LIB_SECURITY struct rte_security_session *sec_session; #endif }; -#ifdef RTE_LIBRTE_SECURITY +#ifdef RTE_LIB_SECURITY enum rte_security_session_action_type type; #endif struct rte_crypto_op *op; @@ -97,6 +99,19 @@ struct crypto_unittest_params { #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] + +#define ADD_BLOCKCIPHER_TESTSUITE(index, parent_ts, blk_types, num_blk_types) \ + for (j = 0; j < num_blk_types; index++, j++) \ + parent_ts.unit_test_suites[index] = \ + build_blockcipher_test_suite(blk_types[j]) + +#define FREE_BLOCKCIPHER_TESTSUITE(index, parent_ts, num_blk_types) \ + for (j = index; j < index + num_blk_types; j++) \ + free_blockcipher_test_suite(parent_ts.unit_test_suites[j]) + /* * Forward declarations. */ @@ -113,6 +128,13 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, const uint8_t *digest, const uint8_t *iv); +static int +security_proto_supported(enum rte_security_session_action_type action, + enum rte_security_session_protocol proto); + +static int +dev_configure_and_start(uint64_t ff_disable); + static struct rte_mbuf * setup_test_string(struct rte_mempool *mpool, const char *string, size_t len, uint8_t blocksize) @@ -120,10 +142,11 @@ setup_test_string(struct rte_mempool *mpool, struct rte_mbuf *m = rte_pktmbuf_alloc(mpool); size_t t_len = len - (blocksize ? (len % blocksize) : 0); - memset(m->buf_addr, 0, m->buf_len); if (m) { - char *dst = rte_pktmbuf_append(m, t_len); + char *dst; + memset(m->buf_addr, 0, m->buf_len); + dst = rte_pktmbuf_append(m, t_len); if (!dst) { rte_pktmbuf_free(m); return NULL; @@ -147,15 +170,232 @@ ceil_byte_length(uint32_t num_bits) return (num_bits >> 3); } +static void +post_process_raw_dp_op(void *user_data, uint32_t index __rte_unused, + uint8_t is_op_success) +{ + struct rte_crypto_op *op = user_data; + op->status = is_op_success ? RTE_CRYPTO_OP_STATUS_SUCCESS : + RTE_CRYPTO_OP_STATUS_ERROR; +} + +void +process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id, + struct rte_crypto_op *op, uint8_t is_cipher, uint8_t is_auth, + uint8_t len_in_bits, uint8_t cipher_iv_len) +{ + struct rte_crypto_sym_op *sop = op->sym; + struct rte_crypto_op *ret_op = NULL; + struct rte_crypto_vec data_vec[UINT8_MAX], dest_data_vec[UINT8_MAX]; + struct rte_crypto_va_iova_ptr cipher_iv, digest, aad_auth_iv; + union rte_crypto_sym_ofs ofs; + struct rte_crypto_sym_vec vec; + struct rte_crypto_sgl sgl, dest_sgl; + uint32_t max_len; + union rte_cryptodev_session_ctx sess; + uint32_t count = 0; + struct rte_crypto_raw_dp_ctx *ctx; + uint32_t cipher_offset = 0, cipher_len = 0, auth_offset = 0, + auth_len = 0; + int32_t n; + uint32_t n_success; + int ctx_service_size; + int32_t status = 0; + int enqueue_status, dequeue_status; + + ctx_service_size = rte_cryptodev_get_raw_dp_ctx_size(dev_id); + if (ctx_service_size < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + return; + } + + ctx = malloc(ctx_service_size); + if (!ctx) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + return; + } + + /* Both are enums, setting crypto_sess will suit any session type */ + sess.crypto_sess = op->sym->session; + + if (rte_cryptodev_configure_raw_dp_ctx(dev_id, qp_id, ctx, + op->sess_type, sess, 0) < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + + cipher_iv.iova = 0; + cipher_iv.va = NULL; + aad_auth_iv.iova = 0; + aad_auth_iv.va = NULL; + digest.iova = 0; + digest.va = NULL; + sgl.vec = data_vec; + vec.num = 1; + vec.src_sgl = &sgl; + vec.iv = &cipher_iv; + vec.digest = &digest; + vec.aad = &aad_auth_iv; + vec.status = &status; + + ofs.raw = 0; + + if (is_cipher && is_auth) { + cipher_offset = sop->cipher.data.offset; + cipher_len = sop->cipher.data.length; + auth_offset = sop->auth.data.offset; + auth_len = sop->auth.data.length; + max_len = RTE_MAX(cipher_offset + cipher_len, + auth_offset + auth_len); + if (len_in_bits) { + max_len = max_len >> 3; + cipher_offset = cipher_offset >> 3; + auth_offset = auth_offset >> 3; + cipher_len = cipher_len >> 3; + auth_len = auth_len >> 3; + } + ofs.ofs.cipher.head = cipher_offset; + ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; + ofs.ofs.auth.head = auth_offset; + ofs.ofs.auth.tail = max_len - auth_offset - auth_len; + cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); + aad_auth_iv.va = rte_crypto_op_ctod_offset( + op, void *, IV_OFFSET + cipher_iv_len); + aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET + + cipher_iv_len); + digest.va = (void *)sop->auth.digest.data; + digest.iova = sop->auth.digest.phys_addr; + + } else if (is_cipher) { + cipher_offset = sop->cipher.data.offset; + cipher_len = sop->cipher.data.length; + max_len = cipher_len + cipher_offset; + if (len_in_bits) { + max_len = max_len >> 3; + cipher_offset = cipher_offset >> 3; + cipher_len = cipher_len >> 3; + } + ofs.ofs.cipher.head = cipher_offset; + ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; + cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); + + } else if (is_auth) { + auth_offset = sop->auth.data.offset; + auth_len = sop->auth.data.length; + max_len = auth_len + auth_offset; + if (len_in_bits) { + max_len = max_len >> 3; + auth_offset = auth_offset >> 3; + auth_len = auth_len >> 3; + } + ofs.ofs.auth.head = auth_offset; + ofs.ofs.auth.tail = max_len - auth_offset - auth_len; + aad_auth_iv.va = rte_crypto_op_ctod_offset( + op, void *, IV_OFFSET + cipher_iv_len); + aad_auth_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET + + cipher_iv_len); + digest.va = (void *)sop->auth.digest.data; + digest.iova = sop->auth.digest.phys_addr; + + } else { /* aead */ + cipher_offset = sop->aead.data.offset; + cipher_len = sop->aead.data.length; + max_len = cipher_len + cipher_offset; + if (len_in_bits) { + max_len = max_len >> 3; + cipher_offset = cipher_offset >> 3; + cipher_len = cipher_len >> 3; + } + ofs.ofs.cipher.head = cipher_offset; + ofs.ofs.cipher.tail = max_len - cipher_offset - cipher_len; + cipher_iv.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + cipher_iv.iova = rte_crypto_op_ctophys_offset(op, IV_OFFSET); + aad_auth_iv.va = (void *)sop->aead.aad.data; + aad_auth_iv.iova = sop->aead.aad.phys_addr; + digest.va = (void *)sop->aead.digest.data; + digest.iova = sop->aead.digest.phys_addr; + } + + n = rte_crypto_mbuf_to_vec(sop->m_src, 0, max_len, + data_vec, RTE_DIM(data_vec)); + if (n < 0 || n > sop->m_src->nb_segs) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + + sgl.num = n; + /* Out of place */ + if (sop->m_dst != NULL) { + dest_sgl.vec = dest_data_vec; + vec.dest_sgl = &dest_sgl; + n = rte_crypto_mbuf_to_vec(sop->m_dst, 0, max_len, + dest_data_vec, RTE_DIM(dest_data_vec)); + if (n < 0 || n > sop->m_dst->nb_segs) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + dest_sgl.num = n; + } else + vec.dest_sgl = NULL; + + if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op, + &enqueue_status) < 1) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + + if (enqueue_status == 0) { + status = rte_cryptodev_raw_enqueue_done(ctx, 1); + if (status < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + } else if (enqueue_status < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + + n = n_success = 0; + while (count++ < MAX_RAW_DEQUEUE_COUNT && n == 0) { + n = rte_cryptodev_raw_dequeue_burst(ctx, + NULL, 1, post_process_raw_dp_op, + (void **)&ret_op, 0, &n_success, + &dequeue_status); + if (dequeue_status < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + if (n == 0) + rte_pause(); + } + + if (n == 1 && dequeue_status == 0) { + if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) { + op->status = RTE_CRYPTO_OP_STATUS_ERROR; + goto exit; + } + } + + op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op || + ret_op->status == RTE_CRYPTO_OP_STATUS_ERROR || + n_success < 1) ? RTE_CRYPTO_OP_STATUS_ERROR : + RTE_CRYPTO_OP_STATUS_SUCCESS; + +exit: + free(ctx); +} + static void process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op) { int32_t n, st; - void *iv; struct rte_crypto_sym_op *sop; union rte_crypto_sym_ofs ofs; struct rte_crypto_sgl sgl; struct rte_crypto_sym_vec symvec; + struct rte_crypto_va_iova_ptr iv_ptr, aad_ptr, digest_ptr; struct rte_crypto_vec vec[UINT8_MAX]; sop = op->sym; @@ -170,14 +410,18 @@ process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op) sgl.vec = vec; sgl.num = n; - symvec.sgl = &sgl; - iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); - symvec.iv = &iv; - symvec.aad = (void **)&sop->aead.aad.data; - symvec.digest = (void **)&sop->aead.digest.data; + symvec.src_sgl = &sgl; + symvec.iv = &iv_ptr; + symvec.digest = &digest_ptr; + symvec.aad = &aad_ptr; symvec.status = &st; symvec.num = 1; + /* for CPU crypto the IOVA address is not required */ + iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + digest_ptr.va = (void *)sop->aead.digest.data; + aad_ptr.va = (void *)sop->aead.aad.data; + ofs.raw = 0; n = rte_cryptodev_sym_cpu_crypto_process(dev_id, sop->session, ofs, @@ -193,11 +437,11 @@ static void process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op) { int32_t n, st; - void *iv; struct rte_crypto_sym_op *sop; union rte_crypto_sym_ofs ofs; struct rte_crypto_sgl sgl; struct rte_crypto_sym_vec symvec; + struct rte_crypto_va_iova_ptr iv_ptr, digest_ptr; struct rte_crypto_vec vec[UINT8_MAX]; sop = op->sym; @@ -212,14 +456,15 @@ process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op) sgl.vec = vec; sgl.num = n; - symvec.sgl = &sgl; - iv = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); - symvec.iv = &iv; - symvec.aad = (void **)&sop->aead.aad.data; - symvec.digest = (void **)&sop->auth.digest.data; + symvec.src_sgl = &sgl; + symvec.iv = &iv_ptr; + symvec.digest = &digest_ptr; symvec.status = &st; symvec.num = 1; + iv_ptr.va = rte_crypto_op_ctod_offset(op, void *, IV_OFFSET); + digest_ptr.va = (void *)sop->auth.digest.data; + ofs.raw = 0; ofs.ofs.cipher.head = sop->cipher.data.offset - sop->auth.data.offset; ofs.ofs.cipher.tail = (sop->auth.data.offset + sop->auth.data.length) - @@ -259,6 +504,7 @@ process_crypto_request(uint8_t dev_id, struct rte_crypto_op *op) } static struct crypto_testsuite_params testsuite_params = { NULL }; +struct crypto_testsuite_params *p_testsuite_params = &testsuite_params; static struct crypto_unittest_params unittest_params; static int @@ -267,7 +513,6 @@ testsuite_setup(void) 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)); @@ -313,223 +558,18 @@ testsuite_setup(void) 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 slave_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 Slave Cores - * Use 2 slave cores for the device args - */ - RTE_LCORE_FOREACH_SLAVE(i) { - if (slave_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)); - slave_core_count++; - socket_id = rte_lcore_to_socket_id(i); - } - if (slave_core_count != 2) { - RTE_LOG(ERR, USER1, - "Cryptodev scheduler test require at least " - "two slave 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); @@ -553,9 +593,15 @@ testsuite_setup(void) 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) { @@ -607,6 +653,7 @@ static void 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", @@ -628,65 +675,732 @@ testsuite_teardown(void) 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 -ut_setup(void) +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 = RTE_CRYPTODEV_FF_SECURITY; - 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 void -ut_teardown(void) +static int +crypto_gen_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; - /* 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); + 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 +ipsec_proto_testsuite_setup(void) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + int ret = 0; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + + if (!(dev_info.feature_flags & RTE_CRYPTODEV_FF_SECURITY)) { + RTE_LOG(INFO, USER1, "Feature flag requirements for IPsec Proto " + "testsuite not met\n"); + return TEST_SKIPPED; + } + + /* Reconfigure to enable security */ + ret = dev_configure_and_start(0); + if (ret != TEST_SUCCESS) + return ret; + + /* Set action type */ + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + + if (security_proto_supported( + RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + RTE_SECURITY_PROTOCOL_IPSEC) < 0) { + RTE_LOG(INFO, USER1, "Capability requirements for IPsec Proto " + "test not met\n"); + ret = TEST_SKIPPED; + } + + /* + * Stop the device. Device would be started again by individual test + * case setup routine. + */ + rte_cryptodev_stop(ts_params->valid_devs[0]); + + return ret; +} + +static int +pdcp_proto_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, + 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 int +docsis_proto_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_DOCSISBPI + }; + + 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; +} + +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); +} + +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 @@ -741,7 +1455,7 @@ test_device_configure_invalid_dev_id(void) "Need at least %d devices for test", 1); /* valid dev_id values */ - dev_id = ts_params->valid_devs[ts_params->valid_dev_count - 1]; + dev_id = ts_params->valid_devs[0]; /* Stop the device in case it's started so it can be configured */ rte_cryptodev_stop(dev_id); @@ -1406,12 +2120,12 @@ test_AES_CBC_HMAC_SHA1_encrypt_digest(void) 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, @@ -1642,6 +2356,9 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -1667,74 +2384,6 @@ test_AES_CBC_HMAC_SHA512_decrypt_perform(struct rte_cryptodev_sym_session *sess, return TEST_SUCCESS; } -static int -test_blockcipher(enum blockcipher_test_type test_type) -{ - struct crypto_testsuite_params *ts_params = &testsuite_params; - int status; - - status = test_blockcipher_all_tests(ts_params->mbuf_pool, - ts_params->op_mpool, - ts_params->session_mpool, ts_params->session_priv_mpool, - ts_params->valid_devs[0], - test_type); - - if (status == -ENOTSUP) - return status; - - TEST_ASSERT_EQUAL(status, 0, "Test failed"); - - return TEST_SUCCESS; -} - -static int -test_AES_cipheronly_all(void) -{ - return test_blockcipher(BLKCIPHER_AES_CIPHERONLY_TYPE); -} - -static int -test_AES_docsis_all(void) -{ - return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE); -} - -static int -test_DES_docsis_all(void) -{ - return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE); -} - -static int -test_DES_cipheronly_all(void) -{ - return test_blockcipher(BLKCIPHER_DES_CIPHERONLY_TYPE); -} - -static int -test_authonly_all(void) -{ - return test_blockcipher(BLKCIPHER_AUTHONLY_TYPE); -} - -static int -test_AES_chain_all(void) -{ - return test_blockcipher(BLKCIPHER_AES_CHAIN_TYPE); -} - -static int -test_3DES_chain_all(void) -{ - return test_blockcipher(BLKCIPHER_3DES_CHAIN_TYPE); -} - -static int -test_3DES_cipheronly_all(void) -{ - return test_blockcipher(BLKCIPHER_3DES_CIPHERONLY_TYPE); -} - /* ***** SNOW 3G Tests ***** */ static int create_wireless_algo_hash_session(uint8_t dev_id, @@ -1770,6 +2419,9 @@ create_wireless_algo_hash_session(uint8_t dev_id, status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->auth_xform, ts_params->session_priv_mpool); + if (status == -ENOTSUP) + return TEST_SKIPPED; + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; @@ -1809,6 +2461,9 @@ create_wireless_algo_cipher_session(uint8_t dev_id, status = rte_cryptodev_sym_session_init(dev_id, ut_params->sess, &ut_params->cipher_xform, ts_params->session_priv_mpool); + if (status == -ENOTSUP) + return TEST_SKIPPED; + TEST_ASSERT_EQUAL(status, 0, "session init failed"); TEST_ASSERT_NOT_NULL(ut_params->sess, "Session creation failed"); return 0; @@ -1930,7 +2585,7 @@ create_wireless_algo_cipher_auth_session(uint8_t dev_id, &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; @@ -1993,7 +2648,7 @@ create_wireless_cipher_auth_session(uint8_t dev_id, &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"); @@ -2069,7 +2724,7 @@ create_wireless_algo_auth_cipher_session(uint8_t dev_id, ts_params->session_priv_mpool); if (status == -ENOTSUP) - return status; + return TEST_SKIPPED; TEST_ASSERT_EQUAL(status, 0, "session init failed"); @@ -2372,6 +3027,21 @@ create_wireless_algo_auth_cipher_operation( 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) { @@ -2413,16 +3083,25 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) 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 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], @@ -2456,7 +3135,11 @@ test_snow3g_authentication(const struct snow3g_hash_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 1, 0); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); ut_params->obuf = ut_params->op->sym->m_src; TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -2491,16 +3174,25 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) 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 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], @@ -2535,7 +3227,11 @@ test_snow3g_authentication_verify(const struct snow3g_hash_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 1, 0); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_src; @@ -2561,6 +3257,19 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -2568,7 +3277,7 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) 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], @@ -2605,6 +3314,9 @@ test_kasumi_authentication(const struct kasumi_hash_test_data *tdata) if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 1, 0); else ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); @@ -2634,6 +3346,19 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) unsigned plaintext_pad_len; unsigned plaintext_len; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -2641,7 +3366,7 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) 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], @@ -2676,7 +3401,11 @@ test_kasumi_authentication_verify(const struct kasumi_hash_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 1, 0); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_src; @@ -2841,6 +3570,19 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -2848,7 +3590,7 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) 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], @@ -2883,8 +3625,12 @@ test_kasumi_encryption(const struct kasumi_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], - ut_params->op); + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_dst; @@ -2928,7 +3674,7 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) 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); @@ -2937,9 +3683,18 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) 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 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, @@ -2969,7 +3724,11 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3012,9 +3771,16 @@ test_kasumi_encryption_oop(const struct kasumi_test_data *tdata) 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; + /* 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 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], @@ -3095,7 +3861,13 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) 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 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); @@ -3104,7 +3876,7 @@ test_kasumi_encryption_oop_sgl(const struct kasumi_test_data *tdata) 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 */ @@ -3180,7 +3952,13 @@ test_kasumi_decryption_oop(const struct kasumi_test_data *tdata) 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 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], @@ -3250,6 +4028,19 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) uint8_t *ciphertext, *plaintext; unsigned ciphertext_pad_len; unsigned ciphertext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -3257,7 +4048,7 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) 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], @@ -3292,7 +4083,11 @@ test_kasumi_decryption(const struct kasumi_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, 0); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3325,6 +4120,19 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -3332,7 +4140,7 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) 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], @@ -3367,7 +4175,11 @@ test_snow3g_encryption(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3399,6 +4211,16 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) int retval; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 does not support RAW data-path APIs.\n"); + return -ENOTSUP; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -3406,7 +4228,13 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) 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 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], @@ -3448,7 +4276,11 @@ test_snow3g_encryption_oop(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3489,7 +4321,13 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) 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 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); @@ -3499,6 +4337,12 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) printf("Device doesn't support out-of-place scatter-gather " "in both input and output mbufs. " "Test Skipped.\n"); + return TEST_SKIPPED; + } + + if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && + (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { + printf("Device does not support RAW data-path APIs.\n"); return -ENOTSUP; } @@ -3536,7 +4380,11 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3599,7 +4447,7 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 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 */ @@ -3608,7 +4456,13 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) 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 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], @@ -3657,7 +4511,11 @@ test_snow3g_encryption_offset_oop(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -3700,6 +4558,19 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned ciphertext_pad_len; unsigned ciphertext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -3707,7 +4578,7 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) 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], @@ -3742,7 +4613,11 @@ static int test_snow3g_decryption(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_dst; @@ -3771,14 +4646,29 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned ciphertext_pad_len; unsigned ciphertext_len; + struct rte_cryptodev_info dev_info; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 does not support RAW data-path APIs.\n"); + return -ENOTSUP; + } /* 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; + + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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], @@ -3823,7 +4713,11 @@ static int test_snow3g_decryption_oop(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_dst; @@ -3864,16 +4758,25 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) ((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 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; @@ -3881,13 +4784,13 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) 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); @@ -3910,7 +4813,11 @@ test_zuc_cipher_auth(const struct wireless_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_src; @@ -3950,6 +4857,19 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -3957,12 +4877,12 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) 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], @@ -3973,7 +4893,7 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) 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); @@ -4005,7 +4925,11 @@ test_snow3g_cipher_auth(const struct snow3g_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); ut_params->obuf = ut_params->op->sym->m_src; @@ -4057,12 +4981,15 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 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); @@ -4071,8 +4998,16 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 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 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 TEST_SKIPPED; } /* Create SNOW 3G session */ @@ -4087,8 +5022,7 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, 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); @@ -4141,7 +5075,11 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4186,16 +5124,20 @@ test_snow3g_auth_cipher(const struct snow3g_test_data *tdata, /* 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( @@ -4234,12 +5176,15 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, 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); @@ -4249,17 +5194,24 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, 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 TEST_SKIPPED; } } else { + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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; } } @@ -4276,7 +5228,7 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, 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); @@ -4330,7 +5282,11 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4383,16 +5339,20 @@ test_snow3g_auth_cipher_sgl(const struct snow3g_test_data *tdata, /* 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( @@ -4427,21 +5387,32 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, 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); 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 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 TEST_SKIPPED; if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { printf("Device doesn't support digest encrypted.\n"); - return -ENOTSUP; + return TEST_SKIPPED; } } @@ -4458,7 +5429,7 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, 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); @@ -4512,7 +5483,11 @@ test_kasumi_auth_cipher(const struct kasumi_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4606,12 +5581,15 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, 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); @@ -4621,17 +5599,24 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, 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 TEST_SKIPPED; } } else { + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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; } } @@ -4648,7 +5633,7 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, 0, tdata->digest.len, tdata->cipher_iv.len); - if (retval < 0) + if (retval != 0) return retval; ciphertext_len = ceil_byte_length(tdata->ciphertext.len); @@ -4702,7 +5687,11 @@ test_kasumi_auth_cipher_sgl(const struct kasumi_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4787,6 +5776,19 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 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; @@ -4794,12 +5796,12 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) 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( @@ -4811,7 +5813,7 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) 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); @@ -4843,7 +5845,11 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4876,6 +5882,61 @@ test_kasumi_cipher_auth(const struct kasumi_test_data *tdata) return 0; } +static int +check_cipher_capability(const struct crypto_testsuite_params *ts_params, + const enum rte_crypto_cipher_algorithm cipher_algo, + const uint16_t key_size, const uint16_t iv_size) +{ + struct rte_cryptodev_sym_capability_idx cap_idx; + const struct rte_cryptodev_symmetric_capability *cap; + + /* Check if device supports the algorithm */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; + cap_idx.algo.cipher = cipher_algo; + + cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx); + + if (cap == NULL) + return -1; + + /* Check if device supports key size and IV size */ + if (rte_cryptodev_sym_capability_check_cipher(cap, key_size, + iv_size) < 0) { + return -1; + } + + return 0; +} + +static int +check_auth_capability(const struct crypto_testsuite_params *ts_params, + const enum rte_crypto_auth_algorithm auth_algo, + const uint16_t key_size, const uint16_t iv_size, + const uint16_t tag_size) +{ + struct rte_cryptodev_sym_capability_idx cap_idx; + const struct rte_cryptodev_symmetric_capability *cap; + + /* Check if device supports the algorithm */ + cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; + cap_idx.algo.auth = auth_algo; + + cap = rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx); + + if (cap == NULL) + return -1; + + /* Check if device supports key size and IV size */ + if (rte_cryptodev_sym_capability_check_auth(cap, key_size, + tag_size, iv_size) < 0) { + return -1; + } + + return 0; +} + static int test_zuc_encryption(const struct wireless_test_data *tdata) { @@ -4886,16 +5947,24 @@ test_zuc_encryption(const struct wireless_test_data *tdata) uint8_t *plaintext, *ciphertext; unsigned plaintext_pad_len; unsigned plaintext_len; + struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_capability_idx cap_idx; + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + uint64_t feat_flags = dev_info.feature_flags; - /* Check if device supports ZUC EEA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; + 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 TEST_SKIPPED; + } - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return TEST_SKIPPED; + + /* Check if device supports ZUC EEA3 */ + if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3, + tdata->key.len, tdata->cipher_iv.len) < 0) + return TEST_SKIPPED; /* Create ZUC session */ retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0], @@ -4903,7 +5972,7 @@ test_zuc_encryption(const struct wireless_test_data *tdata) RTE_CRYPTO_CIPHER_ZUC_EEA3, tdata->key.data, tdata->key.len, tdata->cipher_iv.len); - if (retval < 0) + if (retval != 0) return retval; ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); @@ -4930,7 +5999,11 @@ test_zuc_encryption(const struct wireless_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -4965,15 +6038,13 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata) uint8_t ciphertext_buffer[2048]; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_capability_idx cap_idx; - /* Check if device supports ZUC EEA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER; - cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3; + if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3, + tdata->key.len, tdata->cipher_iv.len) < 0) + return TEST_SKIPPED; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return TEST_SKIPPED; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -4982,7 +6053,13 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata) 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 TEST_SKIPPED; } plaintext_len = ceil_byte_length(tdata->plaintext.len); @@ -5017,7 +6094,11 @@ test_zuc_encryption_sgl(const struct wireless_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 0, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -5053,7 +6134,6 @@ test_zuc_authentication(const struct wireless_test_data *tdata) unsigned plaintext_len; uint8_t *plaintext; - struct rte_cryptodev_sym_capability_idx cap_idx; struct rte_cryptodev_info dev_info; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -5062,16 +6142,23 @@ test_zuc_authentication(const struct wireless_test_data *tdata) 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; } - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + 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 TEST_SKIPPED; + } - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return TEST_SKIPPED; + + /* Check if device supports ZUC EIA3 */ + if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3, + tdata->key.len, tdata->auth_iv.len, + tdata->digest.len) < 0) + return TEST_SKIPPED; /* Create ZUC session */ retval = create_wireless_algo_hash_session(ts_params->valid_devs[0], @@ -5079,7 +6166,7 @@ test_zuc_authentication(const struct wireless_test_data *tdata) tdata->auth_iv.len, tdata->digest.len, RTE_CRYPTO_AUTH_OP_GENERATE, RTE_CRYPTO_AUTH_ZUC_EIA3); - if (retval < 0) + if (retval != 0) return retval; /* alloc mbuf and set payload */ @@ -5105,7 +6192,11 @@ test_zuc_authentication(const struct wireless_test_data *tdata) if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 1, 0); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); ut_params->obuf = ut_params->op->sym->m_src; TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -5138,15 +6229,17 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, unsigned int ciphertext_len; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_capability_idx cap_idx; - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + /* Check if device supports ZUC EEA3 */ + if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3, + tdata->key.len, tdata->cipher_iv.len) < 0) + return TEST_SKIPPED; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; + /* Check if device supports ZUC EIA3 */ + if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3, + tdata->key.len, tdata->auth_iv.len, + tdata->digest.len) < 0) + return TEST_SKIPPED; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -5154,19 +6247,27 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, 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 TEST_SKIPPED; } } else { + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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; } } @@ -5183,7 +6284,7 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, 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); @@ -5237,7 +6338,11 @@ test_zuc_auth_cipher(const struct wireless_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -5324,15 +6429,17 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, uint8_t digest_buffer[10000]; struct rte_cryptodev_info dev_info; - struct rte_cryptodev_sym_capability_idx cap_idx; - /* Check if device supports ZUC EIA3 */ - cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH; - cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3; + /* Check if device supports ZUC EEA3 */ + if (check_cipher_capability(ts_params, RTE_CRYPTO_CIPHER_ZUC_EEA3, + tdata->key.len, tdata->cipher_iv.len) < 0) + return TEST_SKIPPED; - if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], - &cap_idx) == NULL) - return -ENOTSUP; + /* Check if device supports ZUC EIA3 */ + if (check_auth_capability(ts_params, RTE_CRYPTO_AUTH_ZUC_EIA3, + tdata->key.len, tdata->auth_iv.len, + tdata->digest.len) < 0) + return TEST_SKIPPED; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -5342,17 +6449,25 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, 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 TEST_SKIPPED; } } else { + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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; } } @@ -5369,7 +6484,7 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, 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); @@ -5423,7 +6538,11 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data *tdata, if (retval < 0) return retval; - ut_params->op = process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 1, tdata->cipher_iv.len); + else + ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf"); @@ -5566,6 +6685,9 @@ test_kasumi_decryption_test_case_2(void) static int test_kasumi_decryption_test_case_3(void) { + /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + return TEST_SKIPPED; return test_kasumi_decryption(&kasumi_test_case_3); } @@ -5708,6 +6830,16 @@ static int 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. @@ -5765,6 +6897,9 @@ test_snow3g_auth_cipher_part_digest_enc_oop(void) static int test_snow3g_auth_cipher_test_case_3_sgl(void) { + /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + return TEST_SKIPPED; return test_snow3g_auth_cipher_sgl( &snow3g_auth_cipher_test_case_3, IN_PLACE, 0); } @@ -5779,6 +6914,9 @@ test_snow3g_auth_cipher_test_case_3_oop_sgl(void) static int test_snow3g_auth_cipher_part_digest_enc_sgl(void) { + /* rte_crypto_mbuf_to_vec does not support incomplete mbuf build */ + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + return TEST_SKIPPED; return test_snow3g_auth_cipher_sgl( &snow3g_auth_cipher_partial_digest_encryption, IN_PLACE, 0); @@ -5978,6 +7116,12 @@ test_zuc_encryption_test_case_6_sgl(void) return test_zuc_encryption_sgl(&zuc_test_case_cipher_193b); } +static int +test_zuc_encryption_test_case_7(void) +{ + return test_zuc_encryption(&zuc_test_case_cipher_800b_key_256b); +} + static int test_zuc_hash_generate_test_case_1(void) { @@ -6026,6 +7170,18 @@ test_zuc_hash_generate_test_case_8(void) return test_zuc_authentication(&zuc_test_case_auth_584b); } +static int +test_zuc_hash_generate_test_case_9(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_584b_mac_64b); +} + +static int +test_zuc_hash_generate_test_case_10(void) +{ + return test_zuc_authentication(&zuc_test_case_auth_2080b_mac_128b); +} + static int test_zuc_cipher_auth_test_case_1(void) { @@ -6105,13 +7261,13 @@ test_mixed_check_if_unsupported(const struct mixed_cipher_auth_test_data *tdata) 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; } @@ -6136,7 +7292,9 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, /* 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 TEST_SKIPPED; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -6144,7 +7302,7 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) { printf("Device doesn't support digest encrypted.\n"); - return -ENOTSUP; + return TEST_SKIPPED; } /* Create the session */ @@ -6168,7 +7326,7 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, 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); @@ -6178,9 +7336,11 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, /* clear mbuf payload */ memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->ibuf)); - if (op_mode == OUT_OF_PLACE) + if (op_mode == OUT_OF_PLACE) { + memset(rte_pktmbuf_mtod(ut_params->obuf, uint8_t *), 0, rte_pktmbuf_tailroom(ut_params->obuf)); + } ciphertext_len = ceil_byte_length(tdata->ciphertext.len_bits); plaintext_len = ceil_byte_length(tdata->plaintext.len_bits); @@ -6221,8 +7381,7 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, if (retval < 0) return retval; - 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 */ @@ -6230,7 +7389,7 @@ test_mixed_auth_cipher(const struct mixed_cipher_auth_test_data *tdata, 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; @@ -6327,7 +7486,9 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, /* 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 TEST_SKIPPED; rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); @@ -6337,17 +7498,17 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, 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; } } @@ -6372,7 +7533,7 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, 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); @@ -6426,8 +7587,7 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, if (retval < 0) return retval; - 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 */ @@ -6435,9 +7595,8 @@ test_mixed_auth_cipher_sgl(const struct mixed_cipher_auth_test_data *tdata, 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"); @@ -6980,6 +8139,16 @@ test_authenticated_encryption(const struct aead_test_data *tdata) uint8_t *ciphertext, *auth_tag; uint16_t plaintext_pad_len; uint32_t i; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -6989,11 +8158,11 @@ test_authenticated_encryption(const struct aead_test_data *tdata) 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], @@ -7029,6 +8198,9 @@ test_authenticated_encryption(const struct aead_test_data *tdata) /* Process crypto operation */ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -7071,9 +8243,10 @@ test_authenticated_encryption(const struct aead_test_data *tdata) } -#ifdef RTE_LIBRTE_SECURITY +#ifdef RTE_LIB_SECURITY static int -security_proto_supported(enum rte_security_session_protocol proto) +security_proto_supported(enum rte_security_session_action_type action, + enum rte_security_session_protocol proto) { struct crypto_testsuite_params *ts_params = &testsuite_params; @@ -7093,7 +8266,8 @@ security_proto_supported(enum rte_security_session_protocol proto) while ((capability = &capabilities[i++])->action != RTE_SECURITY_ACTION_TYPE_NONE) { - if (capability->protocol == proto) + if (capability->action == action && + capability->protocol == proto) return 0; } @@ -7105,14 +8279,18 @@ security_proto_supported(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; @@ -7125,11 +8303,11 @@ test_pdcp_proto(int i, int oop, /* Verify the capabilities */ struct rte_security_capability_idx sec_cap_idx; - sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + 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); @@ -7151,29 +8329,24 @@ test_pdcp_proto(int i, int oop, rte_pktmbuf_append(ut_params->obuf, output_vec_len); } - /* Set crypto type as IPSEC */ - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - /* 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 { @@ -7181,32 +8354,33 @@ test_pdcp_proto(int i, int oop, } struct rte_security_session_conf sess_conf = { - .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .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: ", @@ -7228,7 +8402,7 @@ test_pdcp_proto(int i, int oop, 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); @@ -7308,18 +8482,29 @@ test_pdcp_proto_SGL(int i, int oop, int to_trn_tbl[16]; int segs = 1; unsigned int trn_data = 0; + struct rte_cryptodev_info dev_info; + uint64_t feat_flags; struct rte_security_ctx *ctx = (struct rte_security_ctx *) rte_cryptodev_get_sec_ctx( ts_params->valid_devs[0]); + struct rte_mbuf *temp_mbuf; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 does not support RAW data-path APIs.\n"); + return -ENOTSUP; + } /* Verify the capabilities */ struct rte_security_capability_idx sec_cap_idx; - sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + 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; if (rte_security_capability_get(ctx, &sec_cap_idx) == NULL) - return -ENOTSUP; + return TEST_SKIPPED; if (fragsz > input_vec_len) fragsz = input_vec_len; @@ -7425,8 +8610,6 @@ test_pdcp_proto_SGL(int i, int oop, ut_params->obuf->nb_segs = segs; } - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - /* 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; @@ -7452,7 +8635,7 @@ test_pdcp_proto_SGL(int i, int oop, } struct rte_security_session_conf sess_conf = { - .action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL, + .action_type = ut_params->type, .protocol = RTE_SECURITY_PROTOCOL_PDCP, {.pdcp = { .bearer = pdcp_test_bearer[i], @@ -7468,7 +8651,8 @@ test_pdcp_proto_SGL(int i, int oop, /* 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: ", @@ -7496,8 +8680,23 @@ test_pdcp_proto_SGL(int i, int oop, ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ - if (process_crypto_request(ts_params->valid_devs[0], ut_params->op) - == NULL) { + temp_mbuf = ut_params->op->sym->m_src; + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) { + /* filling lengths */ + while (temp_mbuf) { + ut_params->op->sym->cipher.data.length + += temp_mbuf->pkt_len; + ut_params->op->sym->auth.data.length + += temp_mbuf->pkt_len; + temp_mbuf = temp_mbuf->next; + } + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 0, 0); + } else { + ut_params->op = process_crypto_request(ts_params->valid_devs[0], + ut_params->op); + } + if (ut_params->op == NULL) { printf("TestCase %s()-%d line %d failed %s: ", __func__, i, __LINE__, "failed to process sym crypto op"); @@ -7571,74 +8770,97 @@ on_err: 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 @@ -7691,26 +8913,550 @@ test_PDCP_PROTO_SGL_oop_32B_40B(void) 32, 40); } static int -test_PDCP_PROTO_SGL_oop_128B_32B(void) +test_PDCP_PROTO_SGL_oop_128B_32B(void) +{ + /* i can be used for running any PDCP case + * In this case it is cplane 12-bit AES-ZUC DL encap + */ + int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; + return test_pdcp_proto_SGL(i, OUT_OF_PLACE, + 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, + 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 = RTE_DIM(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_PROTO_short_mac(void) +{ + int i = 0, size = 0; + int err, all_err = TEST_SUCCESS; + const struct pdcp_short_mac_test *cur_test; + + size = RTE_DIM(list_pdcp_smac_tests); + + for (i = 0; i < size; i++) { + cur_test = &list_pdcp_smac_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), + RTE_CRYPTO_CIPHER_NULL, NULL, + 0, cur_test->param.auth_alg, + cur_test->auth_key, cur_test->param.auth_key_len, + 0, cur_test->param.domain, 0, 0, + 0, 0, 0); + if (err) { + printf("\t%d) %s: Short MAC test failed\n", + cur_test->test_idx, + cur_test->param.name); + err = TEST_FAILED; + } else { + printf("\t%d) %s: Short MAC test PASS\n", + cur_test->test_idx, + cur_test->param.name); + rte_hexdump(stdout, "MAC I", + cur_test->data_out + cur_test->in_len + 2, + 2); + 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 = RTE_DIM(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_ipsec_proto_process(const struct ipsec_test_data td[], + struct ipsec_test_data res_d[], + int nb_td, + bool silent, + const struct ipsec_test_flags *flags) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_security_capability_idx sec_cap_idx; + const struct rte_security_capability *sec_cap; + struct rte_security_ipsec_xform ipsec_xform; + uint8_t dev_id = ts_params->valid_devs[0]; + enum rte_security_ipsec_sa_direction dir; + struct ipsec_test_data *res_d_tmp = NULL; + uint32_t src = RTE_IPV4(192, 168, 1, 0); + uint32_t dst = RTE_IPV4(192, 168, 1, 1); + int salt_len, i, ret = TEST_SUCCESS; + struct rte_security_ctx *ctx; + uint8_t *input_text; + uint32_t verify; + + ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + gbl_action_type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + + /* Use first test data to create session */ + + /* Copy IPsec xform */ + memcpy(&ipsec_xform, &td[0].ipsec_xform, sizeof(ipsec_xform)); + + dir = ipsec_xform.direction; + verify = flags->tunnel_hdr_verify; + + if ((dir == RTE_SECURITY_IPSEC_SA_DIR_INGRESS) && verify) { + if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR) + src += 1; + else if (verify == RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR) + dst += 1; + } + + memcpy(&ipsec_xform.tunnel.ipv4.src_ip, &src, sizeof(src)); + memcpy(&ipsec_xform.tunnel.ipv4.dst_ip, &dst, sizeof(dst)); + + ctx = rte_cryptodev_get_sec_ctx(dev_id); + + sec_cap_idx.action = ut_params->type; + sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_IPSEC; + sec_cap_idx.ipsec.proto = ipsec_xform.proto; + sec_cap_idx.ipsec.mode = ipsec_xform.mode; + sec_cap_idx.ipsec.direction = ipsec_xform.direction; + + if (flags->udp_encap) + ipsec_xform.options.udp_encap = 1; + + sec_cap = rte_security_capability_get(ctx, &sec_cap_idx); + if (sec_cap == NULL) + return TEST_SKIPPED; + + /* Copy cipher session parameters */ + if (td[0].aead) { + memcpy(&ut_params->aead_xform, &td[0].xform.aead, + sizeof(ut_params->aead_xform)); + ut_params->aead_xform.aead.key.data = td[0].key.data; + ut_params->aead_xform.aead.iv.offset = IV_OFFSET; + + /* Verify crypto capabilities */ + if (test_ipsec_crypto_caps_aead_verify( + sec_cap, + &ut_params->aead_xform) != 0) { + if (!silent) + RTE_LOG(INFO, USER1, + "Crypto capabilities not supported\n"); + return TEST_SKIPPED; + } + } else { + /* Only AEAD supported now */ + return TEST_SKIPPED; + } + + if (test_ipsec_sec_caps_verify(&ipsec_xform, sec_cap, silent) != 0) + return TEST_SKIPPED; + + salt_len = RTE_MIN(sizeof(ipsec_xform.salt), td[0].salt.len); + memcpy(&ipsec_xform.salt, td[0].salt.data, salt_len); + + struct rte_security_session_conf sess_conf = { + .action_type = ut_params->type, + .protocol = RTE_SECURITY_PROTOCOL_IPSEC, + .ipsec = ipsec_xform, + .crypto_xform = &ut_params->aead_xform, + }; + + /* 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 == NULL) + return TEST_SKIPPED; + + for (i = 0; i < nb_td; i++) { + /* Setup source mbuf payload */ + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + input_text = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + td[i].input_text.len); + + memcpy(input_text, td[i].input_text.data, + td[i].input_text.len); + + /* Generate crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + if (!ut_params->op) { + printf("TestCase %s line %d: %s\n", + __func__, __LINE__, + "failed to allocate crypto op"); + ret = TEST_FAILED; + goto crypto_op_free; + } + + /* Attach session to operation */ + rte_security_attach_session(ut_params->op, + ut_params->sec_session); + + /* Set crypto operation mbufs */ + ut_params->op->sym->m_src = ut_params->ibuf; + ut_params->op->sym->m_dst = NULL; + + /* Copy IV in crypto operation when IV generation is disabled */ + if (dir == RTE_SECURITY_IPSEC_SA_DIR_EGRESS && + ipsec_xform.options.iv_gen_disable == 1) { + uint8_t *iv = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, + IV_OFFSET); + int len; + + if (td[i].aead) + len = td[i].xform.aead.aead.iv.length; + else + len = td[i].xform.chain.cipher.cipher.iv.length; + + memcpy(iv, td[i].iv.data, len); + } + + /* Process crypto operation */ + process_crypto_request(dev_id, ut_params->op); + + ret = test_ipsec_status_check(ut_params->op, flags, dir, i + 1); + if (ret != TEST_SUCCESS) + goto crypto_op_free; + + if (res_d != NULL) + res_d_tmp = &res_d[i]; + + ret = test_ipsec_post_process(ut_params->ibuf, &td[i], + res_d_tmp, silent, flags); + if (ret != TEST_SUCCESS) + goto crypto_op_free; + + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; + + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + } + +crypto_op_free: + rte_crypto_op_free(ut_params->op); + ut_params->op = NULL; + + rte_pktmbuf_free(ut_params->ibuf); + ut_params->ibuf = NULL; + + if (ut_params->sec_session) + rte_security_session_destroy(ctx, ut_params->sec_session); + ut_params->sec_session = NULL; + + return ret; +} + +static int +test_ipsec_proto_known_vec(const void *test_data) +{ + struct ipsec_test_data td_outb; + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + memcpy(&td_outb, test_data, sizeof(td_outb)); + + /* Disable IV gen to be able to test with known vectors */ + td_outb.ipsec_xform.options.iv_gen_disable = 1; + + return test_ipsec_proto_process(&td_outb, NULL, 1, false, &flags); +} + +static int +test_ipsec_proto_known_vec_inb(const void *td_outb) +{ + struct ipsec_test_flags flags; + struct ipsec_test_data td_inb; + + memset(&flags, 0, sizeof(flags)); + + test_ipsec_td_in_from_out(td_outb, &td_inb); + + return test_ipsec_proto_process(&td_inb, NULL, 1, false, &flags); +} + +static int +test_ipsec_proto_all(const struct ipsec_test_flags *flags) +{ + struct ipsec_test_data td_outb[IPSEC_TEST_PACKETS_MAX]; + struct ipsec_test_data td_inb[IPSEC_TEST_PACKETS_MAX]; + unsigned int i, nb_pkts = 1, pass_cnt = 0; + int ret; + + if (flags->iv_gen || + flags->sa_expiry_pkts_soft || + flags->sa_expiry_pkts_hard) + nb_pkts = IPSEC_TEST_PACKETS_MAX; + + for (i = 0; i < RTE_DIM(aead_list); i++) { + test_ipsec_td_prepare(&aead_list[i], + NULL, + flags, + td_outb, + nb_pkts); + + ret = test_ipsec_proto_process(td_outb, td_inb, nb_pkts, true, + flags); + if (ret == TEST_SKIPPED) + continue; + + if (ret == TEST_FAILED) + return TEST_FAILED; + + test_ipsec_td_update(td_inb, td_outb, nb_pkts, flags); + + ret = test_ipsec_proto_process(td_inb, NULL, nb_pkts, true, + flags); + if (ret == TEST_SKIPPED) + continue; + + if (ret == TEST_FAILED) + return TEST_FAILED; + + if (flags->display_alg) + test_ipsec_display_alg(&aead_list[i], NULL); + + pass_cnt++; + } + + if (pass_cnt > 0) + return TEST_SUCCESS; + else + return TEST_SKIPPED; +} + +static int +test_ipsec_proto_display_list(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.display_alg = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_iv_gen(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.iv_gen = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_sa_exp_pkts_soft(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.sa_expiry_pkts_soft = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_sa_exp_pkts_hard(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.sa_expiry_pkts_hard = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_err_icv_corrupt(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.icv_corrupt = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_udp_encap(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.udp_encap = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_tunnel_src_dst_addr_verify(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_SRC_DST_ADDR; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_tunnel_dst_addr_verify(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.tunnel_hdr_verify = RTE_SECURITY_IPSEC_TUNNEL_VERIFY_DST_ADDR; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_udp_ports_verify(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.udp_encap = true; + flags.udp_ports_verify = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_inner_ip_csum(const void *data __rte_unused) +{ + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.ip_csum = true; + + return test_ipsec_proto_all(&flags); +} + +static int +test_ipsec_proto_inner_l4_csum(const void *data __rte_unused) { - /* i can be used for running any PDCP case - * In this case it is cplane 12-bit AES-ZUC DL encap - */ - int i = PDCP_CPLANE_LONG_SN_OFFSET + AES_ENC + ZUC_AUTH + DOWNLINK; - return test_pdcp_proto_SGL(i, OUT_OF_PLACE, - 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, - 128, 32); + struct ipsec_test_flags flags; + + memset(&flags, 0, sizeof(flags)); + + flags.l4_csum = true; + + return test_ipsec_proto_all(&flags); } static int test_PDCP_PROTO_all(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; struct rte_cryptodev_info dev_info; int status; @@ -7718,10 +9464,16 @@ 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; - if (security_proto_supported(RTE_SECURITY_PROTOCOL_PDCP) < 0) - return -ENOTSUP; + /* Set action type */ + ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ? + RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL : + gbl_action_type; + + if (security_proto_supported(ut_params->type, + RTE_SECURITY_PROTOCOL_PDCP) < 0) + return TEST_SKIPPED; status = test_PDCP_PROTO_cplane_encap_all(); status += test_PDCP_PROTO_cplane_decap_all(); @@ -7731,6 +9483,9 @@ test_PDCP_PROTO_all(void) 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(); + status += test_PDCP_PROTO_short_mac(); if (status) return TEST_FAILED; @@ -7760,13 +9515,13 @@ test_docsis_proto_uplink(int i, struct docsis_test_data *d_td) const struct rte_cryptodev_symmetric_capability *sym_cap; int j = 0; - sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + sec_cap_idx.action = ut_params->type; sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS; sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_UPLINK; 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) { @@ -7784,7 +9539,7 @@ test_docsis_proto_uplink(int i, struct docsis_test_data *d_td) } 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); @@ -7796,9 +9551,6 @@ test_docsis_proto_uplink(int i, struct docsis_test_data *d_td) memcpy(ciphertext, d_td->ciphertext.data, d_td->ciphertext.len); - /* Set session action type */ - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - /* Setup cipher session parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI; @@ -7821,6 +9573,7 @@ test_docsis_proto_uplink(int i, struct docsis_test_data *d_td) /* 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) { @@ -7938,13 +9691,13 @@ test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) const struct rte_cryptodev_symmetric_capability *sym_cap; int j = 0; - sec_cap_idx.action = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; + sec_cap_idx.action = ut_params->type; sec_cap_idx.protocol = RTE_SECURITY_PROTOCOL_DOCSIS; sec_cap_idx.docsis.direction = RTE_SECURITY_DOCSIS_DOWNLINK; 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) { @@ -7962,7 +9715,7 @@ test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) } 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); @@ -7974,9 +9727,6 @@ test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) memcpy(plaintext, d_td->plaintext.data, d_td->plaintext.len); - /* Set session action type */ - ut_params->type = RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL; - /* Setup cipher session parameters */ ut_params->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; ut_params->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_DOCSISBPI; @@ -7999,6 +9749,7 @@ test_docsis_proto_downlink(int i, struct docsis_test_data *d_td) /* 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) { @@ -8099,10 +9850,10 @@ on_err: 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"); \ @@ -8113,7 +9864,7 @@ on_err: 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)); @@ -8143,8 +9894,8 @@ test_DOCSIS_PROTO_uplink_all(void) 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; }; @@ -8152,7 +9903,7 @@ test_DOCSIS_PROTO_uplink_all(void) 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)); @@ -8182,8 +9933,8 @@ test_DOCSIS_PROTO_downlink_all(void) 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; }; @@ -8192,6 +9943,7 @@ static int test_DOCSIS_PROTO_all(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; struct rte_cryptodev_info dev_info; int status; @@ -8199,10 +9951,16 @@ test_DOCSIS_PROTO_all(void) uint64_t feat_flags = dev_info.feature_flags; if (!(feat_flags & RTE_CRYPTODEV_FF_SECURITY)) - return -ENOTSUP; + return TEST_SKIPPED; - if (security_proto_supported(RTE_SECURITY_PROTOCOL_DOCSIS) < 0) - return -ENOTSUP; + /* Set action type */ + ut_params->type = gbl_action_type == RTE_SECURITY_ACTION_TYPE_NONE ? + RTE_SECURITY_ACTION_TYPE_LOOKASIDE_PROTOCOL : + gbl_action_type; + + if (security_proto_supported(ut_params->type, + RTE_SECURITY_PROTOCOL_DOCSIS) < 0) + return TEST_SKIPPED; status = test_DOCSIS_PROTO_uplink_all(); status += test_DOCSIS_PROTO_downlink_all(); @@ -8374,7 +10132,7 @@ test_AES_GCM_auth_encryption_fail_iv_corrupt(void) 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; @@ -8390,7 +10148,7 @@ test_AES_GCM_auth_encryption_fail_in_data_corrupt(void) 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; @@ -8406,7 +10164,7 @@ test_AES_GCM_auth_encryption_fail_out_data_corrupt(void) 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; @@ -8422,7 +10180,7 @@ test_AES_GCM_auth_encryption_fail_aad_len_corrupt(void) 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; @@ -8441,7 +10199,7 @@ test_AES_GCM_auth_encryption_fail_aad_corrupt(void) 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; @@ -8457,7 +10215,7 @@ test_AES_GCM_auth_encryption_fail_tag_corrupt(void) 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; @@ -8472,6 +10230,16 @@ test_authenticated_decryption(const struct aead_test_data *tdata) int retval; uint8_t *plaintext; uint32_t i; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -8481,11 +10249,11 @@ test_authenticated_decryption(const struct aead_test_data *tdata) 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], @@ -8521,6 +10289,9 @@ test_authenticated_decryption(const struct aead_test_data *tdata) /* Process crypto operation */ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -8712,7 +10483,7 @@ test_AES_GCM_auth_decryption_fail_iv_corrupt(void) 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; @@ -8728,7 +10499,7 @@ test_AES_GCM_auth_decryption_fail_in_data_corrupt(void) 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; @@ -8743,7 +10514,7 @@ test_AES_GCM_auth_decryption_fail_out_data_corrupt(void) 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; @@ -8758,7 +10529,7 @@ test_AES_GCM_auth_decryption_fail_aad_len_corrupt(void) 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; @@ -8776,7 +10547,7 @@ test_AES_GCM_auth_decryption_fail_aad_corrupt(void) 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; @@ -8791,7 +10562,7 @@ test_AES_GCM_auth_decryption_fail_tag_corrupt(void) 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; @@ -8806,6 +10577,7 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata) int retval; uint8_t *ciphertext, *auth_tag; uint16_t plaintext_pad_len; + struct rte_cryptodev_info dev_info; /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -8813,11 +10585,18 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata) 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; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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))) + 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], @@ -8849,7 +10628,11 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata) ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); + else + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], ut_params->op), "failed to process sym crypto op"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, @@ -8895,6 +10678,10 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) int retval; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + uint64_t feat_flags = dev_info.feature_flags; /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -8902,11 +10689,18 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) 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 */ - if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) - return -ENOTSUP; + /* 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 TEST_SKIPPED; + + if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) && + (!(feat_flags & RTE_CRYPTODEV_FF_SYM_RAW_DP))) { + printf("Device does not support RAW data-path APIs.\n"); + return TEST_SKIPPED; + } /* Create AEAD session */ retval = create_aead_session(ts_params->valid_devs[0], @@ -8938,7 +10732,11 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata) ut_params->op->sym->m_dst = ut_params->obuf; /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); + else + TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], ut_params->op), "failed to process sym crypto op"); TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, @@ -8986,12 +10784,12 @@ test_authenticated_encryption_sessionless( 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; @@ -8999,7 +10797,7 @@ test_authenticated_encryption_sessionless( 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); @@ -9088,12 +10886,18 @@ test_authenticated_decryption_sessionless( 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 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; @@ -9101,7 +10905,7 @@ test_authenticated_decryption_sessionless( 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); @@ -9132,8 +10936,13 @@ test_authenticated_decryption_sessionless( "crypto op session type not sessionless"); /* Process crypto operation */ - TEST_ASSERT_NOT_NULL(process_crypto_request(ts_params->valid_devs[0], - ut_params->op), "failed to process sym crypto op"); + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); + else + TEST_ASSERT_NOT_NULL(process_crypto_request( + ts_params->valid_devs[0], ut_params->op), + "failed to process sym crypto op"); TEST_ASSERT_NOT_NULL(ut_params->op, "failed crypto process"); @@ -9280,7 +11089,7 @@ test_stats(void) 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; @@ -9288,16 +11097,16 @@ test_stats(void) 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, @@ -9307,9 +11116,7 @@ test_stats(void) "rte_cryptodev_stats_get invalid Param failed"); /* Test expected values */ - ut_setup(); test_AES_CBC_HMAC_SHA1_encrypt_digest(); - ut_teardown(); TEST_ASSERT_SUCCESS(rte_cryptodev_stats_get(ts_params->valid_devs[0], &stats), "rte_cryptodev_stats_get failed"); @@ -9425,6 +11232,16 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -9432,7 +11249,7 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) 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)) @@ -9453,6 +11270,9 @@ test_MD5_HMAC_generate(const struct HMAC_MD5_vector *test_case) if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -9485,6 +11305,16 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -9492,7 +11322,7 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) 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)) { @@ -9511,6 +11341,9 @@ test_MD5_HMAC_verify(const struct HMAC_MD5_vector *test_case) if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -9564,12 +11397,12 @@ test_multi_session(void) 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); @@ -9578,8 +11411,8 @@ test_multi_session(void) rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); sessions = rte_malloc(NULL, - (sizeof(struct rte_cryptodev_sym_session *) * - MAX_NB_SESSIONS) + 1, 0); + sizeof(struct rte_cryptodev_sym_session *) * + (MAX_NB_SESSIONS + 1), 0); /* Create multiple crypto sessions*/ for (i = 0; i < MAX_NB_SESSIONS; i++) { @@ -9624,6 +11457,7 @@ test_multi_session(void) } } + sessions[i] = NULL; /* Next session create should fail */ rte_cryptodev_sym_session_init(ts_params->valid_devs[0], sessions[i], &ut_params->auth_xform, @@ -9692,12 +11526,12 @@ test_multi_session_random_usage(void) 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); @@ -9790,7 +11624,7 @@ test_null_invalid_operation(void) /* 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; @@ -9847,7 +11681,7 @@ test_null_burst_operation(void) /* 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; @@ -9860,59 +11694,299 @@ test_null_burst_operation(void) ut_params->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; ut_params->auth_xform.next = NULL; - ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; - ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + ut_params->auth_xform.auth.algo = RTE_CRYPTO_AUTH_NULL; + ut_params->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; + + 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"); + + 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; - ut_params->sess = rte_cryptodev_sym_session_create( - ts_params->session_mpool); + /* Stop the device in case it's started so it can be configured */ + rte_cryptodev_stop(ts_params->valid_devs[0]); - /* 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"); + 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; } @@ -9976,6 +12050,53 @@ create_gmac_operation(enum rte_crypto_auth_operation op, return 0; } +static int +create_gmac_operation_sgl(enum rte_crypto_auth_operation op, + const struct gmac_test_data *tdata, + void *digest_mem, uint64_t digest_phys) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_crypto_sym_op *sym_op; + + /* Generate Crypto op data structure */ + ut_params->op = rte_crypto_op_alloc(ts_params->op_mpool, + RTE_CRYPTO_OP_TYPE_SYMMETRIC); + TEST_ASSERT_NOT_NULL(ut_params->op, + "Failed to allocate symmetric crypto operation struct"); + + sym_op = ut_params->op->sym; + + sym_op->auth.digest.data = digest_mem; + TEST_ASSERT_NOT_NULL(sym_op->auth.digest.data, + "no room to append digest"); + + sym_op->auth.digest.phys_addr = digest_phys; + + if (op == RTE_CRYPTO_AUTH_OP_VERIFY) { + rte_memcpy(sym_op->auth.digest.data, tdata->gmac_tag.data, + tdata->gmac_tag.len); + debug_hexdump(stdout, "digest:", + sym_op->auth.digest.data, + tdata->gmac_tag.len); + } + + uint8_t *iv_ptr = rte_crypto_op_ctod_offset(ut_params->op, + uint8_t *, IV_OFFSET); + + rte_memcpy(iv_ptr, tdata->iv.data, tdata->iv.len); + + debug_hexdump(stdout, "iv:", iv_ptr, tdata->iv.len); + + sym_op->cipher.data.length = 0; + sym_op->cipher.data.offset = 0; + + sym_op->auth.data.offset = 0; + sym_op->auth.data.length = tdata->plaintext.len; + + return 0; +} + static int create_gmac_session(uint8_t dev_id, const struct gmac_test_data *tdata, enum rte_crypto_auth_operation auth_op) @@ -10016,6 +12137,16 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) { struct crypto_testsuite_params *ts_params = &testsuite_params; struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } int retval; @@ -10031,7 +12162,7 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) 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); @@ -10079,6 +12210,9 @@ test_AES_GMAC_authentication(const struct gmac_test_data *tdata) if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -10137,6 +12271,16 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) int retval; uint32_t plaintext_pad_len; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, "No GMAC length in the source data"); @@ -10147,7 +12291,7 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) 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); @@ -10196,6 +12340,9 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -10205,31 +12352,191 @@ test_AES_GMAC_authentication_verify(const struct gmac_test_data *tdata) "crypto op processing failed"); return 0; - + +} + +static int +test_AES_GMAC_authentication_verify_test_case_1(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_1); +} + +static int +test_AES_GMAC_authentication_verify_test_case_2(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_2); +} + +static int +test_AES_GMAC_authentication_verify_test_case_3(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_3); +} + +static int +test_AES_GMAC_authentication_verify_test_case_4(void) +{ + return test_AES_GMAC_authentication_verify(&gmac_test_case_4); +} + +static int +test_AES_GMAC_authentication_SGL(const struct gmac_test_data *tdata, + uint32_t fragsz) +{ + struct crypto_testsuite_params *ts_params = &testsuite_params; + struct crypto_unittest_params *ut_params = &unittest_params; + struct rte_cryptodev_info dev_info; + uint64_t feature_flags; + unsigned int trn_data = 0; + void *digest_mem = NULL; + uint32_t segs = 1; + unsigned int to_trn = 0; + struct rte_mbuf *buf = NULL; + uint8_t *auth_tag, *plaintext; + int retval; + + TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0, + "No GMAC length in the source data"); + + /* 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_AES_GMAC; + if (rte_cryptodev_sym_capability_get(ts_params->valid_devs[0], + &cap_idx) == NULL) + 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)) || + (!(feature_flags & RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT))) + return TEST_SKIPPED; + + if (fragsz > tdata->plaintext.len) + fragsz = tdata->plaintext.len; + + uint16_t plaintext_len = fragsz; + + retval = create_gmac_session(ts_params->valid_devs[0], + tdata, RTE_CRYPTO_AUTH_OP_GENERATE); + + if (retval < 0) + return retval; + + ut_params->ibuf = rte_pktmbuf_alloc(ts_params->mbuf_pool); + TEST_ASSERT_NOT_NULL(ut_params->ibuf, + "Failed to allocate input buffer in mempool"); + + memset(rte_pktmbuf_mtod(ut_params->ibuf, uint8_t *), 0, + rte_pktmbuf_tailroom(ut_params->ibuf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + plaintext_len); + TEST_ASSERT_NOT_NULL(plaintext, "no room to append plaintext"); + + memcpy(plaintext, tdata->plaintext.data, plaintext_len); + + trn_data += plaintext_len; + + buf = ut_params->ibuf; + + /* + * Loop until no more fragments + */ + + while (trn_data < tdata->plaintext.len) { + ++segs; + to_trn = (tdata->plaintext.len - trn_data < fragsz) ? + (tdata->plaintext.len - trn_data) : fragsz; + + buf->next = rte_pktmbuf_alloc(ts_params->mbuf_pool); + buf = buf->next; + + memset(rte_pktmbuf_mtod(buf, uint8_t *), 0, + rte_pktmbuf_tailroom(buf)); + + plaintext = (uint8_t *)rte_pktmbuf_append(buf, + to_trn); + + memcpy(plaintext, tdata->plaintext.data + trn_data, + to_trn); + trn_data += to_trn; + if (trn_data == tdata->plaintext.len) + digest_mem = (uint8_t *)rte_pktmbuf_append(buf, + tdata->gmac_tag.len); + } + ut_params->ibuf->nb_segs = segs; + + /* + * Place digest at the end of the last buffer + */ + uint64_t digest_phys = rte_pktmbuf_iova(buf) + to_trn; + + if (!digest_mem) { + digest_mem = (uint8_t *)rte_pktmbuf_append(ut_params->ibuf, + + tdata->gmac_tag.len); + digest_phys = rte_pktmbuf_iova_offset(ut_params->ibuf, + tdata->plaintext.len); + } + + retval = create_gmac_operation_sgl(RTE_CRYPTO_AUTH_OP_GENERATE, + tdata, digest_mem, digest_phys); + + if (retval < 0) + return retval; + + rte_crypto_op_attach_sym_session(ut_params->op, ut_params->sess); + + ut_params->op->sym->m_src = ut_params->ibuf; + + if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) + return TEST_SKIPPED; + + TEST_ASSERT_NOT_NULL( + process_crypto_request(ts_params->valid_devs[0], + ut_params->op), "failed to process sym crypto op"); + + TEST_ASSERT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, + "crypto op processing failed"); + + auth_tag = digest_mem; + debug_hexdump(stdout, "auth tag:", auth_tag, tdata->gmac_tag.len); + TEST_ASSERT_BUFFERS_ARE_EQUAL( + auth_tag, + tdata->gmac_tag.data, + tdata->gmac_tag.len, + "GMAC Generated auth tag not as expected"); + + return 0; } +/* Segment size not multiple of block size (16B) */ static int -test_AES_GMAC_authentication_verify_test_case_1(void) +test_AES_GMAC_authentication_SGL_40B(void) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_1); + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 40); } static int -test_AES_GMAC_authentication_verify_test_case_2(void) +test_AES_GMAC_authentication_SGL_80B(void) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_2); + return test_AES_GMAC_authentication_SGL(&gmac_test_case_1, 80); } static int -test_AES_GMAC_authentication_verify_test_case_3(void) +test_AES_GMAC_authentication_SGL_2048B(void) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_3); + return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2048); } +/* Segment size not multiple of block size (16B) */ static int -test_AES_GMAC_authentication_verify_test_case_4(void) +test_AES_GMAC_authentication_SGL_2047B(void) { - return test_AES_GMAC_authentication_verify(&gmac_test_case_4); + return test_AES_GMAC_authentication_SGL(&gmac_test_case_5, 2047); } struct test_crypto_vector { @@ -10711,6 +13018,16 @@ test_authentication_verify_fail_when_data_corruption( int retval; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -10718,7 +13035,8 @@ test_authentication_verify_fail_when_data_corruption( 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_session(ut_params, @@ -10761,13 +13079,19 @@ test_authentication_verify_fail_when_data_corruption( TEST_ASSERT_NOT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); - } else { + } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); + else { ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); - TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); } + if (ut_params->op == NULL) + return 0; + else if (ut_params->op->status != RTE_CRYPTO_OP_STATUS_SUCCESS) + return 0; - return 0; + return -1; } static int @@ -10779,6 +13103,16 @@ test_authentication_verify_GMAC_fail_when_corruption( { int retval; uint8_t *plaintext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -10786,7 +13120,7 @@ test_authentication_verify_GMAC_fail_when_corruption( 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, @@ -10832,7 +13166,10 @@ test_authentication_verify_GMAC_fail_when_corruption( TEST_ASSERT_NOT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); - } else { + } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 1, 0, 0); + else { ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); @@ -10851,6 +13188,16 @@ test_authenticated_decryption_fail_when_corruption( int retval; uint8_t *ciphertext; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -10858,12 +13205,12 @@ test_authenticated_decryption_fail_when_corruption( 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, @@ -10907,7 +13254,10 @@ test_authenticated_decryption_fail_when_corruption( TEST_ASSERT_NOT_EQUAL(ut_params->op->status, RTE_CRYPTO_OP_STATUS_SUCCESS, "authentication not failed"); - } else { + } else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 0, 0); + else { ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); TEST_ASSERT_NULL(ut_params->op, "authentication not failed"); @@ -10917,7 +13267,7 @@ test_authenticated_decryption_fail_when_corruption( } static int -test_authenticated_encryt_with_esn( +test_authenticated_encrypt_with_esn( struct crypto_testsuite_params *ts_params, struct crypto_unittest_params *ut_params, const struct test_crypto_vector *reference) @@ -10928,6 +13278,16 @@ test_authenticated_encryt_with_esn( uint16_t plaintext_pad_len; uint8_t cipher_key[reference->cipher_key.len + 1]; uint8_t auth_key[reference->auth_key.len + 1]; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -10935,12 +13295,12 @@ test_authenticated_encryt_with_esn( 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, @@ -11002,6 +13362,9 @@ test_authenticated_encryt_with_esn( if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 0, 0); else ut_params->op = process_crypto_request( ts_params->valid_devs[0], ut_params->op); @@ -11048,6 +13411,16 @@ test_authenticated_decrypt_with_esn( uint8_t *ciphertext; uint8_t cipher_key[reference->cipher_key.len + 1]; uint8_t auth_key[reference->auth_key.len + 1]; + struct rte_cryptodev_info dev_info; + + rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info); + 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 TEST_SKIPPED; + } /* Verify the capabilities */ struct rte_cryptodev_sym_capability_idx cap_idx; @@ -11055,12 +13428,12 @@ test_authenticated_decrypt_with_esn( 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, @@ -11122,6 +13495,9 @@ test_authenticated_decrypt_with_esn( if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_crypt_auth_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 1, 1, 0, 0); else ut_params->op = process_crypto_request(ts_params->valid_devs[0], ut_params->op); @@ -11249,11 +13625,11 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, 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); @@ -11261,23 +13637,34 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, 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 TEST_SKIPPED; + } } else { unsigned int sgl_in = fragsz < tdata->plaintext.len; unsigned int sgl_out = (fragsz_oop ? fragsz_oop : fragsz) < tdata->plaintext.len; + /* Raw data path API does not support OOP */ + if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + 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; } } @@ -11461,6 +13848,9 @@ test_authenticated_encryption_SGL(const struct aead_test_data *tdata, if (oop == IN_PLACE && gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO) process_cpu_aead_op(ts_params->valid_devs[0], ut_params->op); + else if (global_api_test_type == CRYPTODEV_RAW_API_TEST) + process_sym_raw_dp_op(ts_params->valid_devs[0], 0, + ut_params->op, 0, 0, 0, 0); else TEST_ASSERT_NOT_NULL( process_crypto_request(ts_params->valid_devs[0], @@ -11545,7 +13935,7 @@ test_AES_GCM_auth_encrypt_SGL_in_place_1500B(void) /* 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); @@ -11664,7 +14054,7 @@ auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt(void) static int auth_encrypt_AES128CBC_HMAC_SHA1_esn_check(void) { - return test_authenticated_encryt_with_esn( + return test_authenticated_encrypt_with_esn( &testsuite_params, &unittest_params, &aes128cbc_hmac_sha1_aad_test_vector); @@ -11691,41 +14081,95 @@ test_chacha20_poly1305_decrypt_test_case_rfc8439(void) return test_authenticated_decryption(&chacha20_poly1305_case_rfc8439); } -#ifdef RTE_LIBRTE_PMD_CRYPTO_SCHEDULER +#ifdef RTE_CRYPTO_SCHEDULER -/* global AESNI slave IDs for the scheduler test */ +/* global AESNI worker IDs for the scheduler test */ uint8_t aesni_ids[2]; static int -test_scheduler_attach_slave_op(void) +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_worker_op(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; uint8_t sched_id = ts_params->valid_devs[0]; - uint32_t nb_devs, i, nb_devs_attached = 0; + uint32_t i, nb_devs_attached = 0; int ret; char vdev_name[32]; + unsigned int count = rte_cryptodev_count(); - /* create 2 AESNI_MB if necessary */ - nb_devs = rte_cryptodev_device_count_by_driver( - rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD))); - if (nb_devs < 2) { - for (i = nb_devs; i < 2; i++) { - snprintf(vdev_name, sizeof(vdev_name), "%s_%u", - RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), - i); - ret = rte_vdev_init(vdev_name, NULL); + /* create 2 AESNI_MB vdevs on top of existing devices */ + for (i = count; i < count + 2; i++) { + snprintf(vdev_name, sizeof(vdev_name), "%s_%u", + RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD), + i); + ret = rte_vdev_init(vdev_name, NULL); - TEST_ASSERT(ret == 0, - "Failed to create instance %u of" - " pmd : %s", - i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); + TEST_ASSERT(ret == 0, + "Failed to create instance %u of" + " pmd : %s", + i, RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)); + + if (ret < 0) { + RTE_LOG(ERR, USER1, + "Failed to create 2 AESNI MB PMDs.\n"); + return TEST_SKIPPED; } } /* attach 2 AESNI_MB cdevs */ - for (i = 0; i < rte_cryptodev_count() && nb_devs_attached < 2; - i++) { + for (i = count; i < count + 2; i++) { struct rte_cryptodev_info info; unsigned int session_size; @@ -11791,7 +14235,7 @@ test_scheduler_attach_slave_op(void) ts_params->qp_conf.mp_session_private = ts_params->session_priv_mpool; - ret = rte_cryptodev_scheduler_slave_attach(sched_id, + ret = rte_cryptodev_scheduler_worker_attach(sched_id, (uint8_t)i); TEST_ASSERT(ret == 0, @@ -11807,7 +14251,7 @@ test_scheduler_attach_slave_op(void) } static int -test_scheduler_detach_slave_op(void) +test_scheduler_detach_worker_op(void) { struct crypto_testsuite_params *ts_params = &testsuite_params; uint8_t sched_id = ts_params->valid_devs[0]; @@ -11815,7 +14259,7 @@ test_scheduler_detach_slave_op(void) int ret; for (i = 0; i < 2; i++) { - ret = rte_cryptodev_scheduler_slave_detach(sched_id, + ret = rte_cryptodev_scheduler_worker_detach(sched_id, aesni_ids[i]); TEST_ASSERT(ret == 0, "Failed to detach device %u", aesni_ids[i]); @@ -11870,53 +14314,162 @@ test_scheduler_mode_pkt_size_distr_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, +static int +scheduler_multicore_testsuite_setup(void) +{ + if (test_scheduler_attach_worker_op() < 0) + return TEST_SKIPPED; + if (test_scheduler_mode_op(CDEV_SCHED_MODE_MULTICORE) < 0) + return TEST_SKIPPED; + return 0; +} + +static int +scheduler_roundrobin_testsuite_setup(void) +{ + if (test_scheduler_attach_worker_op() < 0) + return TEST_SKIPPED; + if (test_scheduler_mode_op(CDEV_SCHED_MODE_ROUNDROBIN) < 0) + return TEST_SKIPPED; + return 0; +} + +static int +scheduler_failover_testsuite_setup(void) +{ + if (test_scheduler_attach_worker_op() < 0) + return TEST_SKIPPED; + if (test_scheduler_mode_op(CDEV_SCHED_MODE_FAILOVER) < 0) + return TEST_SKIPPED; + return 0; +} + +static int +scheduler_pkt_size_distr_testsuite_setup(void) +{ + if (test_scheduler_attach_worker_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_worker_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 ipsec_proto_testsuite = { + .suite_name = "IPsec Proto Unit Test Suite", + .setup = ipsec_proto_testsuite_setup, .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), - - /* 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), - - /* 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), - - /* 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), + TEST_CASE_NAMED_WITH_DATA( + "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 128)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec, &pkt_aes_128_gcm), + TEST_CASE_NAMED_WITH_DATA( + "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 192)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec, &pkt_aes_192_gcm), + TEST_CASE_NAMED_WITH_DATA( + "Outbound known vector (ESP tunnel mode IPv4 AES-GCM 256)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec, &pkt_aes_256_gcm), + TEST_CASE_NAMED_WITH_DATA( + "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 128)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec_inb, &pkt_aes_128_gcm), + TEST_CASE_NAMED_WITH_DATA( + "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 192)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec_inb, &pkt_aes_192_gcm), + TEST_CASE_NAMED_WITH_DATA( + "Inbound known vector (ESP tunnel mode IPv4 AES-GCM 256)", + ut_setup_security, ut_teardown, + test_ipsec_proto_known_vec_inb, &pkt_aes_256_gcm), + TEST_CASE_NAMED_ST( + "Combined test alg list", + ut_setup_security, ut_teardown, + test_ipsec_proto_display_list), + TEST_CASE_NAMED_ST( + "IV generation", + ut_setup_security, ut_teardown, + test_ipsec_proto_iv_gen), + TEST_CASE_NAMED_ST( + "UDP encapsulation", + ut_setup_security, ut_teardown, + test_ipsec_proto_udp_encap), + TEST_CASE_NAMED_ST( + "UDP encapsulation ports verification test", + ut_setup_security, ut_teardown, + test_ipsec_proto_udp_ports_verify), + TEST_CASE_NAMED_ST( + "SA expiry packets soft", + ut_setup_security, ut_teardown, + test_ipsec_proto_sa_exp_pkts_soft), + TEST_CASE_NAMED_ST( + "SA expiry packets hard", + ut_setup_security, ut_teardown, + test_ipsec_proto_sa_exp_pkts_hard), + TEST_CASE_NAMED_ST( + "Negative test: ICV corruption", + ut_setup_security, ut_teardown, + test_ipsec_proto_err_icv_corrupt), + TEST_CASE_NAMED_ST( + "Tunnel dst addr verification", + ut_setup_security, ut_teardown, + test_ipsec_proto_tunnel_dst_addr_verify), + TEST_CASE_NAMED_ST( + "Tunnel src and dst addr verification", + ut_setup_security, ut_teardown, + test_ipsec_proto_tunnel_src_dst_addr_verify), + TEST_CASE_NAMED_ST( + "Inner IP checksum", + ut_setup_security, ut_teardown, + test_ipsec_proto_inner_ip_csum), + TEST_CASE_NAMED_ST( + "Inner L4 checksum", + ut_setup_security, ut_teardown, + test_ipsec_proto_inner_l4_csum), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; +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), @@ -11924,27 +14477,59 @@ static struct unit_test_suite cryptodev_testsuite = { 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_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, - test_multi_session), + auth_decryption_AES128CBC_HMAC_SHA1_fail_tag_corrupt), + + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +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() + } +}; - 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_DES_cipheronly_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_docsis_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), - - /** AES CCM Authenticated Encryption 128 bits key */ +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, @@ -11991,7 +14576,14 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12128,7 +14720,14 @@ static struct unit_test_suite cryptodev_testsuite = { 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, @@ -12145,11 +14744,35 @@ static struct unit_test_suite cryptodev_testsuite = { test_AES_GMAC_authentication_test_case_4), TEST_CASE_ST(ut_setup, ut_teardown, test_AES_GMAC_authentication_verify_test_case_4), - /** Chacha20-Poly1305 */ + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_40B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_80B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_2048B), + TEST_CASE_ST(ut_setup, ut_teardown, + test_AES_GMAC_authentication_SGL_2047B), + + 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), @@ -12230,6 +14853,7 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12243,6 +14867,7 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12254,7 +14879,14 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12268,6 +14900,8 @@ static struct unit_test_suite cryptodev_testsuite = { test_zuc_encryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, test_zuc_encryption_test_case_6_sgl), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_encryption_test_case_7), /** ZUC authenticate (EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12286,6 +14920,11 @@ static struct unit_test_suite cryptodev_testsuite = { test_zuc_hash_generate_test_case_7), TEST_CASE_ST(ut_setup, ut_teardown, test_zuc_hash_generate_test_case_8), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_9), + TEST_CASE_ST(ut_setup, ut_teardown, + test_zuc_hash_generate_test_case_10), + /** ZUC alg-chain (EEA3/EIA3) */ TEST_CASE_ST(ut_setup, ut_teardown, @@ -12312,8 +14951,14 @@ static struct unit_test_suite cryptodev_testsuite = { 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, @@ -12322,7 +14967,14 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12379,7 +15031,6 @@ static struct unit_test_suite cryptodev_testsuite = { test_kasumi_decryption_test_case_5), TEST_CASE_ST(ut_setup, ut_teardown, test_kasumi_decryption_test_case_1_oop), - TEST_CASE_ST(ut_setup, ut_teardown, test_kasumi_cipher_auth_test_case_1), @@ -12407,17 +15058,26 @@ static struct unit_test_suite cryptodev_testsuite = { 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, @@ -12442,16 +15102,28 @@ static struct unit_test_suite cryptodev_testsuite = { 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), @@ -12464,11 +15136,11 @@ static struct unit_test_suite cryptodev_testsuite = { 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, @@ -12531,204 +15203,133 @@ static struct unit_test_suite cryptodev_testsuite = { 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, ut_teardown, - test_PDCP_PROTO_all), - TEST_CASE_ST(ut_setup, 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 */ + TEST_CASES_END() } }; -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), +static int +run_cryptodev_testsuite(const char *pmd_name) +{ + uint8_t ret, j, i = 0, blk_start_idx = 0; + const enum blockcipher_test_type blk_suites[] = { + BLKCIPHER_AES_CHAIN_TYPE, + BLKCIPHER_AES_CIPHERONLY_TYPE, + BLKCIPHER_AES_DOCSIS_TYPE, + BLKCIPHER_3DES_CHAIN_TYPE, + BLKCIPHER_3DES_CIPHERONLY_TYPE, + BLKCIPHER_DES_CIPHERONLY_TYPE, + BLKCIPHER_DES_DOCSIS_TYPE, + BLKCIPHER_AUTHONLY_TYPE}; + 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 + &ipsec_proto_testsuite, + &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()} + }; - 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), + 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_SKIPPED; } -}; -static struct unit_test_suite cryptodev_armv8_testsuite = { - .suite_name = "Crypto Device ARMv8 Unit Test Suite", - .setup = testsuite_setup, - .teardown = testsuite_teardown, - .unit_test_cases = { - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), - - /** Negative tests */ - 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), + ts.unit_test_suites = malloc(sizeof(struct unit_test_suite *) * + (RTE_DIM(blk_suites) + RTE_DIM(static_suites))); - TEST_CASES_END() /**< NULL terminate unit test array */ - } -}; + ADD_BLOCKCIPHER_TESTSUITE(i, ts, blk_suites, RTE_DIM(blk_suites)); + ADD_STATIC_TESTSUITE(i, ts, static_suites, RTE_DIM(static_suites)); + ret = unit_test_suite_runner(&ts); -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), + FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, ts, RTE_DIM(blk_suites)); + free(ts.unit_test_suites); + return ret; +} - /** 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), +static int +require_feature_flag(const char *pmd_name, uint64_t flag, const char *flag_name) +{ + struct rte_cryptodev_info dev_info; + uint8_t i, nb_devs; + int driver_id; - TEST_CASES_END() /**< NULL terminate unit test array */ + driver_id = rte_cryptodev_driver_id_get(pmd_name); + if (driver_id == -1) { + RTE_LOG(WARNING, USER1, "%s PMD must be loaded.\n", pmd_name); + return TEST_SKIPPED; } -}; - -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), - - /** 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 */ + nb_devs = rte_cryptodev_count(); + if (nb_devs < 1) { + RTE_LOG(WARNING, USER1, "No crypto devices found?\n"); + return TEST_SKIPPED; } -}; - -static struct unit_test_suite cryptodev_nitrox_testsuite = { - .suite_name = "Crypto NITROX 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_device_configure_invalid_queue_pair_ids), - TEST_CASE_ST(ut_setup, ut_teardown, test_AES_chain_all), - TEST_CASE_ST(ut_setup, ut_teardown, test_3DES_chain_all), - TEST_CASES_END() /**< NULL terminate unit test array */ + for (i = 0; i < nb_devs; i++) { + rte_cryptodev_info_get(i, &dev_info); + if (dev_info.driver_id == driver_id) { + if (!(dev_info.feature_flags & flag)) { + RTE_LOG(INFO, USER1, "%s not supported\n", + flag_name); + return TEST_SKIPPED; + } + return 0; /* found */ + } } -}; + + RTE_LOG(INFO, USER1, "%s not supported\n", flag_name); + return TEST_SKIPPED; +} static int -test_cryptodev_qat(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_qat(void) { - 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; - } - - 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*/) +test_cryptodev_virtio(void) { - 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_VIRTIO_CRYPTO is enabled " - "in config file to run this testsuite.\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*/) +test_cryptodev_aesni_mb(void) { - 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled " - "in config file to run this testsuite.\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. Check if " - "CONFIG_RTE_LIBRTE_PMD_AESNI_MB is enabled " - "in config file to run this testsuite.\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; } @@ -12736,176 +15337,172 @@ test_cryptodev_cpu_aesni_mb(void) 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_OPENSSL is enabled " - "in config file to run this testsuite.\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. Check if " - "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled " - "in config file to run this testsuite.\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. Check if " - "CONFIG_RTE_LIBRTE_PMD_AESNI_GCM is enabled " - "in config file to run this testsuite.\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) +test_cryptodev_mlx5(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. Check if " - "CONFIG_RTE_LIBRTE_PMD_NULL is enabled " - "in config file to run this testsuite.\n"); - return TEST_SKIPPED; - } - - return unit_test_suite_runner(&cryptodev_testsuite); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_MLX5_PMD)); } static int -test_cryptodev_sw_snow3g(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_null(void) { - 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_SNOW3G is enabled " - "in config file to run this testsuite.\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_kasumi(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_sw_snow3g(void) { - 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_KASUMI is enabled " - "in config file to run this testsuite.\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_zuc(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_sw_kasumi(void) { - 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_ZUC is enabled " - "in config file to run this testsuite.\n"); - return TEST_SKIPPED; - } + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_KASUMI_PMD)); +} - return unit_test_suite_runner(&cryptodev_testsuite); +static int +test_cryptodev_sw_zuc(void) +{ + 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. Check if " - "CONFIG_RTE_LIBRTE_PMD_ARMV8 is enabled " - "in config file to run this testsuite.\n"); - return TEST_SKIPPED; - } - - return unit_test_suite_runner(&cryptodev_armv8_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. Check if " - "CONFIG_RTE_LIBRTE_PMD_MVSAM_CRYPTO is enabled " - "in config file to run this testsuite.\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*/) +test_cryptodev_scheduler(void) { + uint8_t ret, sched_i, j, i = 0, blk_start_idx = 0; + const enum blockcipher_test_type blk_suites[] = { + BLKCIPHER_AES_CHAIN_TYPE, + BLKCIPHER_AES_CIPHERONLY_TYPE, + BLKCIPHER_AUTHONLY_TYPE + }; + 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_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_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_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_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_worker_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_worker_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)); if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_SCHEDULER is enabled " - "in config file to run this testsuite.\n"); + RTE_LOG(ERR, USER1, "SCHEDULER PMD must be loaded.\n"); return TEST_SKIPPED; } if (rte_cryptodev_driver_id_get( RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD)) == -1) { - RTE_LOG(ERR, USER1, "CONFIG_RTE_LIBRTE_PMD_AESNI_MB must be" - " enabled in config file to run this testsuite.\n"); + RTE_LOG(ERR, USER1, "AESNI MB PMD must be loaded.\n"); return TEST_SKIPPED; -} - return unit_test_suite_runner(&cryptodev_scheduler_testsuite); + } + + for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) { + uint8_t blk_i = 0; + sched_mode_suites[sched_i]->unit_test_suites = malloc(sizeof + (struct unit_test_suite *) * + (RTE_DIM(blk_suites) + 1)); + ADD_BLOCKCIPHER_TESTSUITE(blk_i, (*sched_mode_suites[sched_i]), + blk_suites, RTE_DIM(blk_suites)); + sched_mode_suites[sched_i]->unit_test_suites[blk_i] = &end_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); + + for (sched_i = 0; sched_i < RTE_DIM(sched_mode_suites); sched_i++) { + FREE_BLOCKCIPHER_TESTSUITE(blk_start_idx, + (*sched_mode_suites[sched_i]), + RTE_DIM(blk_suites)); + free(sched_mode_suites[sched_i]->unit_test_suites); + } + free(ts.unit_test_suites); + return ret; } REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler); @@ -12913,115 +15510,125 @@ REGISTER_TEST_COMMAND(cryptodev_scheduler_autotest, test_cryptodev_scheduler); #endif static int -test_cryptodev_dpaa2_sec(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_dpaa2_sec(void) { - gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD)); +} - if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "DPAA2 SEC PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_DPAA2_SEC is enabled " - "in config file to run this testsuite.\n"); - return TEST_SKIPPED; - } +static int +test_cryptodev_dpaa_sec(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); +} - return unit_test_suite_runner(&cryptodev_testsuite); +static int +test_cryptodev_ccp(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CCP_PMD)); } static int -test_cryptodev_dpaa_sec(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_octeontx(void) { - gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD)); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD)); +} - if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "DPAA SEC PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_DPAA_SEC is enabled " - "in config file to run this testsuite.\n"); - return TEST_SKIPPED; - } +static int +test_cryptodev_octeontx2(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_OCTEONTX2_PMD)); +} - return unit_test_suite_runner(&cryptodev_testsuite); +static int +test_cryptodev_caam_jr(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); } static int -test_cryptodev_ccp(void) +test_cryptodev_nitrox(void) { - gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CCP_PMD)); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_NITROX_PMD)); +} - if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "CCP PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_CCP is enabled " - "in config file to run this testsuite.\n"); - return TEST_FAILED; - } +static int +test_cryptodev_bcmfs(void) +{ + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_BCMFS_PMD)); +} - return unit_test_suite_runner(&cryptodev_ccp_testsuite); +static int +test_cryptodev_qat_raw_api(void) +{ + static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD); + int ret; + + ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP, + "RAW API"); + if (ret) + return ret; + + global_api_test_type = CRYPTODEV_RAW_API_TEST; + ret = run_cryptodev_testsuite(pmd_name); + global_api_test_type = CRYPTODEV_API_TEST; + + return ret; } static int -test_cryptodev_octeontx(void) +test_cryptodev_cn9k(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. Check if " - "CONFIG_RTE_LIBRTE_PMD_OCTEONTX_CRYPTO is " - "enabled in config file to run this " - "testsuite.\n"); - return TEST_FAILED; - } - return unit_test_suite_runner(&cryptodev_testsuite); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN9K_PMD)); } static int -test_cryptodev_octeontx2(void) +test_cryptodev_cn10k(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. Check if " - "CONFIG_RTE_LIBRTE_PMD_OCTEONTX2_CRYPTO is " - "enabled in config file to run this " - "testsuite.\n"); - return TEST_FAILED; - } - return unit_test_suite_runner(&cryptodev_testsuite); + return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD)); } static int -test_cryptodev_caam_jr(void /*argv __rte_unused, int argc __rte_unused*/) +test_cryptodev_dpaa2_sec_raw_api(void) { - gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD)); + static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD); + int ret; - if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "CAAM_JR PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_CAAM_JR is enabled " - "in config file to run this testsuite.\n"); - return TEST_FAILED; - } + ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP, + "RAW API"); + if (ret) + return ret; - return unit_test_suite_runner(&cryptodev_caam_jr_testsuite); + global_api_test_type = CRYPTODEV_RAW_API_TEST; + ret = run_cryptodev_testsuite(pmd_name); + global_api_test_type = CRYPTODEV_API_TEST; + + return ret; } static int -test_cryptodev_nitrox(void) +test_cryptodev_dpaa_sec_raw_api(void) { - gbl_driver_id = rte_cryptodev_driver_id_get( - RTE_STR(CRYPTODEV_NAME_NITROX_PMD)); + static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD); + int ret; - if (gbl_driver_id == -1) { - RTE_LOG(ERR, USER1, "NITROX PMD must be loaded. Check if " - "CONFIG_RTE_LIBRTE_PMD_NITROX is enabled " - "in config file to run this testsuite.\n"); - return TEST_FAILED; - } + ret = require_feature_flag(pmd_name, RTE_CRYPTODEV_FF_SYM_RAW_DP, + "RAW API"); + if (ret) + return ret; - return unit_test_suite_runner(&cryptodev_nitrox_testsuite); + global_api_test_type = CRYPTODEV_RAW_API_TEST; + ret = run_cryptodev_testsuite(pmd_name); + global_api_test_type = CRYPTODEV_API_TEST; + + return ret; } +REGISTER_TEST_COMMAND(cryptodev_dpaa2_sec_raw_api_autotest, + test_cryptodev_dpaa2_sec_raw_api); +REGISTER_TEST_COMMAND(cryptodev_dpaa_sec_raw_api_autotest, + test_cryptodev_dpaa_sec_raw_api); +REGISTER_TEST_COMMAND(cryptodev_qat_raw_api_autotest, + test_cryptodev_qat_raw_api); REGISTER_TEST_COMMAND(cryptodev_qat_autotest, test_cryptodev_qat); REGISTER_TEST_COMMAND(cryptodev_aesni_mb_autotest, test_cryptodev_aesni_mb); REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_mb_autotest, @@ -13030,6 +15637,7 @@ REGISTER_TEST_COMMAND(cryptodev_openssl_autotest, test_cryptodev_openssl); REGISTER_TEST_COMMAND(cryptodev_aesni_gcm_autotest, test_cryptodev_aesni_gcm); REGISTER_TEST_COMMAND(cryptodev_cpu_aesni_gcm_autotest, test_cryptodev_cpu_aesni_gcm); +REGISTER_TEST_COMMAND(cryptodev_mlx5_autotest, test_cryptodev_mlx5); REGISTER_TEST_COMMAND(cryptodev_null_autotest, test_cryptodev_null); REGISTER_TEST_COMMAND(cryptodev_sw_snow3g_autotest, test_cryptodev_sw_snow3g); REGISTER_TEST_COMMAND(cryptodev_sw_kasumi_autotest, test_cryptodev_sw_kasumi); @@ -13044,3 +15652,6 @@ REGISTER_TEST_COMMAND(cryptodev_octeontx_autotest, test_cryptodev_octeontx); REGISTER_TEST_COMMAND(cryptodev_octeontx2_autotest, test_cryptodev_octeontx2); REGISTER_TEST_COMMAND(cryptodev_caam_jr_autotest, test_cryptodev_caam_jr); REGISTER_TEST_COMMAND(cryptodev_nitrox_autotest, test_cryptodev_nitrox); +REGISTER_TEST_COMMAND(cryptodev_bcmfs_autotest, test_cryptodev_bcmfs); +REGISTER_TEST_COMMAND(cryptodev_cn9k_autotest, test_cryptodev_cn9k); +REGISTER_TEST_COMMAND(cryptodev_cn10k_autotest, test_cryptodev_cn10k);