git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
net/sfc: rename array of SW stats descriptions
[dpdk.git] / app / test / test_cryptodev.c
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 65b64e1..01af4cf 100644 (file)
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -186,11 +186,11 @@ process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
 {
        struct rte_crypto_sym_op *sop = op->sym;
        struct rte_crypto_op *ret_op = NULL;
-       struct rte_crypto_vec data_vec[UINT8_MAX];
+       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;
+       struct rte_crypto_sgl sgl, dest_sgl;
        uint32_t max_len;
        union rte_cryptodev_session_ctx sess;
        uint32_t count = 0;
@@ -232,7 +232,7 @@ process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
        digest.va = NULL;
        sgl.vec = data_vec;
        vec.num = 1;
-       vec.sgl = &sgl;
+       vec.src_sgl = &sgl;
        vec.iv = &cipher_iv;
        vec.digest = &digest;
        vec.aad = &aad_auth_iv;
@@ -326,6 +326,19 @@ process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
        }
 
        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) {
@@ -366,6 +379,7 @@ process_sym_raw_dp_op(uint8_t dev_id, uint16_t qp_id,
        }
 
        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;
 
@@ -396,7 +410,7 @@ process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
 
        sgl.vec = vec;
        sgl.num = n;
-       symvec.sgl = &sgl;
+       symvec.src_sgl = &sgl;
        symvec.iv = &iv_ptr;
        symvec.digest = &digest_ptr;
        symvec.aad = &aad_ptr;
@@ -442,7 +456,7 @@ process_cpu_crypt_auth_op(uint8_t dev_id, struct rte_crypto_op *op)
 
        sgl.vec = vec;
        sgl.num = n;
-       symvec.sgl = &sgl;
+       symvec.src_sgl = &sgl;
        symvec.iv = &iv_ptr;
        symvec.digest = &digest_ptr;
        symvec.status = &st;
@@ -4197,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;
@@ -4252,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");
 
@@ -4312,6 +4340,12 @@ test_snow3g_encryption_oop_sgl(const struct snow3g_test_data *tdata)
                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;
+       }
+
        /* Create SNOW 3G session */
        retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
                                        RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -4346,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");
 
@@ -4473,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");
 
@@ -4604,7 +4646,16 @@ 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;
@@ -4662,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;
@@ -8381,10 +8436,21 @@ 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;
 
@@ -8568,8 +8634,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");
@@ -10450,6 +10531,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;
@@ -10459,7 +10541,11 @@ test_authenticated_encryption_oop(const struct aead_test_data *tdata)
                        &cap_idx) == NULL)
                return TEST_SKIPPED;
 
-       if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+       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 */
@@ -10496,7 +10582,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,
@@ -10542,6 +10632,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;
@@ -10556,6 +10650,12 @@ test_authenticated_decryption_oop(const struct aead_test_data *tdata)
                        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],
                        tdata->algo,
@@ -10586,7 +10686,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,
@@ -12935,10 +13039,13 @@ test_authentication_verify_fail_when_data_corruption(
        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
@@ -15434,6 +15541,46 @@ test_cryptodev_cn10k(void)
        return run_cryptodev_testsuite(RTE_STR(CRYPTODEV_NAME_CN10K_PMD));
 }
 
+static int
+test_cryptodev_dpaa2_sec_raw_api(void)
+{
+       static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_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_dpaa_sec_raw_api(void)
+{
+       static const char *pmd_name = RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_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;
+}
+
+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);
DPDK repo used for reviews