This patch adds the cryptodev raw API test support to unit test.
In addtion a new test-case for QAT PMD for the test type is
enabled.
Signed-off-by: Fan Zhang <roy.fan.zh...@intel.com>
---
app/test/test_cryptodev.c | 759 ++++++++++++++++++++++++--
app/test/test_cryptodev.h | 12 +
app/test/test_cryptodev_blockcipher.c | 58 +-
3 files changed, 775 insertions(+), 54 deletions(-)
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index 99f1eed82..4e7dd1b63 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -49,6 +49,10 @@
#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,6 +61,8 @@ static int gbl_driver_id;
static enum rte_security_session_action_type gbl_action_type =
RTE_SECURITY_ACTION_TYPE_NONE;
+enum cryptodev_api_test_type global_api_test_type = CRYPTODEV_API_TEST;
+
struct crypto_testsuite_params {
struct rte_mempool *mbuf_pool;
struct rte_mempool *large_mbuf_pool;
@@ -147,6 +153,187 @@ ceil_byte_length(uint32_t num_bits)
return (num_bits >> 3);
}
+void
+process_sym_raw_hw_api_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)
+{
+ int32_t n;
+ 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_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;
+ 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;
+ int ctx_service_size;
+ int32_t status = 0;
+
+ ctx_service_size = rte_cryptodev_raw_get_dp_context_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;
+ }
+
+ if (rte_cryptodev_raw_configure_dp_context(dev_id, qp_id, ctx) < 0) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ return;
+ }
+
+ sess.crypto_sess = sop->session;
+ if (rte_cryptodev_raw_attach_session(dev_id, qp_id, ctx,
+ op->sess_type, sess) < 0) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ return;
+ }
+
+ 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.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;
+ return;
+ }
+
+ sgl.num = n;
+
+ if (rte_cryptodev_raw_enqueue_burst(ctx, &vec, ofs, (void **)&op)
+ < 1) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ return;
+ }
+
+ status = rte_cryptodev_raw_enqueue_done(ctx, 1);
+ if (status < 0) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ return;
+ }
+
+
+ status = -1;
+ while (count++ < MAX_RAW_DEQUEUE_COUNT && status == -1) {
+ status = rte_cryptodev_raw_dequeue(ctx, (void **)&ret_op);
+ if (status == -1)
+ rte_pause();
+ }
+
+ if (status != -1) {
+ if (rte_cryptodev_raw_dequeue_done(ctx, 1) < 0) {
+ op->status = RTE_CRYPTO_OP_STATUS_ERROR;
+ return;
+ }
+ }
+
+ op->status = (count == MAX_RAW_DEQUEUE_COUNT + 1 || ret_op != op ||
+ status != 1) ? RTE_CRYPTO_OP_STATUS_ERROR :
+ RTE_CRYPTO_OP_STATUS_SUCCESS;
+}
+
static void
process_cpu_aead_op(uint8_t dev_id, struct rte_crypto_op *op)
{
@@ -1661,6 +1848,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_hw_api_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],
@@ -1715,12 +1905,18 @@ test_AES_cipheronly_all(void)
static int
test_AES_docsis_all(void)
{
+ /* Data-path service does not support DOCSIS yet */
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
return test_blockcipher(BLKCIPHER_AES_DOCSIS_TYPE);
}
static int
test_DES_docsis_all(void)
{
+ /* Data-path service does not support DOCSIS yet */
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
return test_blockcipher(BLKCIPHER_DES_DOCSIS_TYPE);
}
@@ -2435,6 +2631,12 @@ test_snow3g_authentication(const struct
snow3g_hash_test_data *tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't 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_AUTH;
@@ -2475,7 +2677,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_hw_api_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");
@@ -2513,6 +2719,12 @@ test_snow3g_authentication_verify(const struct
snow3g_hash_test_data *tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't 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_AUTH;
@@ -2554,7 +2766,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_hw_api_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;
@@ -2580,6 +2796,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2624,6 +2850,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_hw_api_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);
@@ -2653,6 +2882,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2695,7 +2934,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_hw_api_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;
@@ -2860,6 +3103,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -2902,8 +3155,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_hw_api_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;
@@ -2959,6 +3216,12 @@ test_kasumi_encryption_sgl(const struct kasumi_test_data
*tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -2988,7 +3251,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_hw_api_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");
@@ -3031,10 +3298,14 @@ 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;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3116,6 +3387,9 @@ test_kasumi_encryption_oop_sgl(const struct
kasumi_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
uint64_t feat_flags = dev_info.feature_flags;
@@ -3201,6 +3475,9 @@ test_kasumi_decryption_oop(const struct kasumi_test_data
*tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* Create KASUMI session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3269,6 +3546,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3311,7 +3598,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_hw_api_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");
@@ -3344,6 +3635,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3386,7 +3687,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_hw_api_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");
@@ -3427,6 +3732,9 @@ test_snow3g_encryption_oop(const struct snow3g_test_data
*tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3510,6 +3818,9 @@ test_snow3g_encryption_oop_sgl(const struct
snow3g_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
uint64_t feat_flags = dev_info.feature_flags;
@@ -3629,6 +3940,9 @@ test_snow3g_encryption_offset_oop(const struct
snow3g_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_ENCRYPT,
@@ -3719,6 +4033,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -3761,7 +4085,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_hw_api_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;
@@ -3799,6 +4127,9 @@ static int test_snow3g_decryption_oop(const struct
snow3g_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* Create SNOW 3G session */
retval = create_wireless_algo_cipher_session(ts_params->valid_devs[0],
RTE_CRYPTO_CIPHER_OP_DECRYPT,
@@ -3886,6 +4217,12 @@ test_zuc_cipher_auth(const struct wireless_test_data
*tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
/* Check if device supports ZUC EEA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
cap_idx.algo.cipher = RTE_CRYPTO_CIPHER_ZUC_EEA3;
@@ -3929,7 +4266,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_hw_api_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;
@@ -3969,6 +4310,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -4024,7 +4375,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_hw_api_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;
@@ -4092,6 +4447,14 @@ test_snow3g_auth_cipher(const struct snow3g_test_data
*tdata,
printf("Device doesn't support digest encrypted.\n");
return -ENOTSUP;
}
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+ }
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
}
/* Create SNOW 3G session */
@@ -4160,7 +4523,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_hw_api_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");
@@ -4270,7 +4637,14 @@ test_snow3g_auth_cipher_sgl(const struct
snow3g_test_data *tdata,
"in both input and output mbufs.\n");
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
} else {
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
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");
@@ -4349,7 +4723,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_hw_api_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");
@@ -4457,7 +4835,15 @@ test_kasumi_auth_cipher(const struct kasumi_test_data
*tdata,
uint64_t feat_flags = dev_info.feature_flags;
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
if (op_mode == OUT_OF_PLACE) {
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
if (!(feat_flags & RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED)) {
printf("Device doesn't support digest encrypted.\n");
return -ENOTSUP;
@@ -4531,7 +4917,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_hw_api_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");
@@ -4642,7 +5032,14 @@ test_kasumi_auth_cipher_sgl(const struct
kasumi_test_data *tdata,
"in both input and output mbufs.\n");
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
} else {
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
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");
@@ -4721,7 +5118,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_hw_api_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");
@@ -4806,6 +5207,16 @@ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -4862,7 +5273,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_hw_api_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");
@@ -4905,6 +5320,16 @@ 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;
+
+ 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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -4949,7 +5374,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_hw_api_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");
@@ -5004,6 +5433,12 @@ test_zuc_encryption_sgl(const struct wireless_test_data
*tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
plaintext_len = ceil_byte_length(tdata->plaintext.len);
/* Append data which is padded to a multiple */
@@ -5036,7 +5471,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_hw_api_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");
@@ -5084,6 +5523,12 @@ test_zuc_authentication(const struct wireless_test_data
*tdata)
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
/* Check if device supports ZUC EIA3 */
cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
cap_idx.algo.auth = RTE_CRYPTO_AUTH_ZUC_EIA3;
@@ -5124,7 +5569,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_hw_api_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");
@@ -5181,7 +5630,15 @@ test_zuc_auth_cipher(const struct wireless_test_data
*tdata,
"in both input and output mbufs.\n");
return -ENOTSUP;
}
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
} else {
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
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");
@@ -5256,7 +5713,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_hw_api_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");
@@ -5363,7 +5824,15 @@ test_zuc_auth_cipher_sgl(const struct wireless_test_data
*tdata,
"in both input and output mbufs.\n");
return -ENOTSUP;
}
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
} else {
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
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");
@@ -5442,7 +5911,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_hw_api_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");
@@ -5585,6 +6058,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 -ENOTSUP;
return test_kasumi_decryption(&kasumi_test_case_3);
}
@@ -5784,6 +6260,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 -ENOTSUP;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_test_case_3, IN_PLACE, 0);
}
@@ -5798,6 +6277,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 -ENOTSUP;
return test_snow3g_auth_cipher_sgl(
&snow3g_auth_cipher_partial_digest_encryption,
IN_PLACE, 0);
@@ -6151,11 +6633,12 @@ test_mixed_auth_cipher(const struct
mixed_cipher_auth_test_data *tdata,
unsigned int ciphertext_len;
struct rte_cryptodev_info dev_info;
- struct rte_crypto_op *op;
/* Check if device supports particular algorithms separately */
if (test_mixed_check_if_unsupported(tdata))
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
@@ -6166,6 +6649,9 @@ test_mixed_auth_cipher(const struct
mixed_cipher_auth_test_data *tdata,
return -ENOTSUP;
}
+ if (op_mode == OUT_OF_PLACE)
+ return -ENOTSUP;
+
/* Create the session */
if (verify)
retval = create_wireless_algo_cipher_auth_session(
@@ -6197,9 +6683,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);
@@ -6240,18 +6728,17 @@ 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 = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
/* Check if the op failed because the device doesn't */
/* support this particular combination of algorithms */
- if (op == NULL && ut_params->op->status ==
+ if (ut_params->op == NULL && ut_params->op->status ==
RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
printf("Device doesn't support this mixed combination. "
"Test Skipped.\n");
return -ENOTSUP;
}
- ut_params->op = op;
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
@@ -6342,11 +6829,12 @@ test_mixed_auth_cipher_sgl(const struct
mixed_cipher_auth_test_data *tdata,
uint8_t digest_buffer[10000];
struct rte_cryptodev_info dev_info;
- struct rte_crypto_op *op;
/* Check if device supports particular algorithms */
if (test_mixed_check_if_unsupported(tdata))
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
rte_cryptodev_info_get(ts_params->valid_devs[0], &dev_info);
@@ -6445,20 +6933,18 @@ 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 = process_crypto_request(ts_params->valid_devs[0],
ut_params->op);
/* Check if the op failed because the device doesn't */
/* support this particular combination of algorithms */
- if (op == NULL && ut_params->op->status ==
+ if (ut_params->op == NULL && ut_params->op->status ==
RTE_CRYPTO_OP_STATUS_INVALID_SESSION) {
printf("Device doesn't support this mixed combination. "
"Test Skipped.\n");
return -ENOTSUP;
}
- ut_params->op = op;
-
TEST_ASSERT_NOT_NULL(ut_params->op, "failed to retrieve obuf");
ut_params->obuf = (op_mode == IN_PLACE ?
@@ -6999,6 +7485,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -7048,6 +7544,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_hw_api_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],
@@ -8496,6 +8995,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -8545,6 +9054,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_hw_api_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],
@@ -8839,6 +9351,9 @@ test_authenticated_encryption_oop(const struct
aead_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST)
+ return -ENOTSUP;
+
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
return -ENOTSUP;
@@ -8928,8 +9443,9 @@ test_authenticated_decryption_oop(const struct
aead_test_data *tdata)
&cap_idx) == NULL)
return -ENOTSUP;
- /* not supported with CPU crypto */
- if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
+ /* not supported with CPU crypto and raw data-path APIs*/
+ if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO ||
+ global_api_test_type == CRYPTODEV_RAW_API_TEST)
return -ENOTSUP;
/* Create AEAD session */
@@ -9115,6 +9631,12 @@ test_authenticated_decryption_sessionless(
return -ENOTSUP;
}
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
+
/* not supported with CPU crypto */
if (gbl_action_type == RTE_SECURITY_ACTION_TYPE_CPU_CRYPTO)
return -ENOTSUP;
@@ -9156,8 +9678,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_hw_api_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");
@@ -9449,6 +9976,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -9477,6 +10014,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_hw_api_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],
@@ -9509,6 +10049,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -9535,6 +10085,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_hw_api_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],
@@ -10040,6 +10593,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
int retval;
@@ -10103,6 +10666,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_hw_api_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],
@@ -10161,6 +10727,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
TEST_ASSERT_NOT_EQUAL(tdata->gmac_tag.len, 0,
"No GMAC length in the source data");
@@ -10220,6 +10796,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_hw_api_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],
@@ -10735,6 +11314,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10744,6 +11333,7 @@ test_authentication_verify_fail_when_data_corruption(
&cap_idx) == NULL)
return -ENOTSUP;
+
/* Create session */
retval = create_auth_session(ut_params,
ts_params->valid_devs[0],
@@ -10785,7 +11375,10 @@ 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_hw_api_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");
@@ -10803,6 +11396,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10856,7 +11459,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_hw_api_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");
@@ -10875,6 +11481,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -10931,7 +11547,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_hw_api_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");
@@ -10952,6 +11571,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -11026,6 +11655,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_hw_api_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);
@@ -11072,6 +11704,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_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
/* Verify the capabilities */
struct rte_cryptodev_sym_capability_idx cap_idx;
@@ -11146,6 +11788,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_hw_api_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);
@@ -11286,10 +11931,21 @@ test_authenticated_encryption_SGL(const struct
aead_test_data *tdata,
if (sgl_in && (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_IN_PLACE_SGL)))
return -ENOTSUP;
+
+ uint64_t feat_flags = dev_info.feature_flags;
+
+ if ((global_api_test_type == CRYPTODEV_RAW_API_TEST) &&
+ (!(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP))) {
+ printf("Device doesn't support RAW data-path APIs.\n");
+ return -ENOTSUP;
+ }
} 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 -ENOTSUP;
if (sgl_in && !sgl_out) {
if (!(dev_info.feature_flags &
RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT))
@@ -11485,6 +12141,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_hw_api_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],
@@ -13046,6 +13705,30 @@ test_cryptodev_nitrox(void)
return unit_test_suite_runner(&cryptodev_nitrox_testsuite);
}
+static int
+test_cryptodev_qat_raw_api(void /*argv __rte_unused, int argc __rte_unused*/)
+{
+ int ret;
+
+ gbl_driver_id = rte_cryptodev_driver_id_get(
+ RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
+
+ if (gbl_driver_id == -1) {
+ RTE_LOG(ERR, USER1, "QAT PMD must be loaded. Check that both "
+ "CONFIG_RTE_LIBRTE_PMD_QAT and CONFIG_RTE_LIBRTE_PMD_QAT_SYM "
+ "are enabled in config file to run this testsuite.\n");
+ return TEST_SKIPPED;
+ }
+
+ global_api_test_type = CRYPTODEV_RAW_API_TEST;
+ ret = unit_test_suite_runner(&cryptodev_testsuite);
+ global_api_test_type = CRYPTODEV_API_TEST;
+
+ return ret;
+}
+
+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,
diff --git a/app/test/test_cryptodev.h b/app/test/test_cryptodev.h
index 41542e055..d8fc0db53 100644
--- a/app/test/test_cryptodev.h
+++ b/app/test/test_cryptodev.h
@@ -71,6 +71,13 @@
#define CRYPTODEV_NAME_CAAM_JR_PMD crypto_caam_jr
#define CRYPTODEV_NAME_NITROX_PMD crypto_nitrox_sym
+enum cryptodev_api_test_type {
+ CRYPTODEV_API_TEST = 0,
+ CRYPTODEV_RAW_API_TEST
+};
+
+extern enum cryptodev_api_test_type global_api_test_type;
+
/**
* Write (spread) data from buffer to mbuf data
*
@@ -209,4 +216,9 @@ create_segmented_mbuf(struct rte_mempool *mbuf_pool, int
pkt_len,
return NULL;
}
+void
+process_sym_raw_hw_api_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);
+
#endif /* TEST_CRYPTODEV_H_ */
diff --git a/app/test/test_cryptodev_blockcipher.c
b/app/test/test_cryptodev_blockcipher.c
index 221262341..f675a2c92 100644
--- a/app/test/test_cryptodev_blockcipher.c
+++ b/app/test/test_cryptodev_blockcipher.c
@@ -136,6 +136,14 @@ test_blockcipher_one_case(const struct
blockcipher_test_case *t,
nb_segs = 3;
}
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST &&
+ !(feat_flags & RTE_CRYPTODEV_FF_SYM_HW_RAW_DP)) {
+ printf("Device doesn't support raw data-path APIs. "
+ "Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
+ return TEST_SKIPPED;
+ }
+
if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
uint64_t oop_flags = RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT |
RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT |
@@ -148,6 +156,13 @@ test_blockcipher_one_case(const struct
blockcipher_test_case *t,
"SKIPPED");
return TEST_SKIPPED;
}
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
+ printf("Raw Data Path APIs do not support OOP, "
+ "Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
+ status = TEST_SUCCESS;
+ goto error_exit;
+ }
}
if (tdata->cipher_key.len)
@@ -462,25 +477,36 @@ test_blockcipher_one_case(const struct
blockcipher_test_case *t,
}
/* Process crypto operation */
- if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
- snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
- "line %u FAILED: %s",
- __LINE__, "Error sending packet for encryption");
- status = TEST_FAILED;
- goto error_exit;
- }
+ if (global_api_test_type == CRYPTODEV_RAW_API_TEST) {
+ uint8_t is_cipher = 0, is_auth = 0;
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER)
+ is_cipher = 1;
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH)
+ is_auth = 1;
- op = NULL;
+ process_sym_raw_hw_api_op(dev_id, 0, op, is_cipher, is_auth, 0,
+ tdata->iv.len);
+ } else {
+ if (rte_cryptodev_enqueue_burst(dev_id, 0, &op, 1) != 1) {
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "line %u FAILED: %s",
+ __LINE__, "Error sending packet for
encryption");
+ status = TEST_FAILED;
+ goto error_exit;
+ }
- while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
- rte_pause();
+ op = NULL;
- if (!op) {
- snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
- "line %u FAILED: %s",
- __LINE__, "Failed to process sym crypto op");
- status = TEST_FAILED;
- goto error_exit;
+ while (rte_cryptodev_dequeue_burst(dev_id, 0, &op, 1) == 0)
+ rte_pause();
+
+ if (!op) {
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "line %u FAILED: %s",
+ __LINE__, "Failed to process sym crypto op");
+ status = TEST_FAILED;
+ goto error_exit;
+ }
}
debug_hexdump(stdout, "m_src(after):",
--
2.20.1
