#include "test_cryptodev_des_test_vectors.h"
#include "test_cryptodev_hash_test_vectors.h"
+static int
+verify_algo_support(const struct blockcipher_test_case *t,
+ const uint8_t dev_id, const uint32_t digest_len)
+{
+ int ret = 0;
+ const struct blockcipher_test_data *tdata = t->test_data;
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+ const struct rte_cryptodev_symmetric_capability *capability;
+
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_CIPHER) {
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_CIPHER;
+ cap_idx.algo.cipher = tdata->crypto_algo;
+ capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
+ if (capability == NULL)
+ return -1;
+
+ if (cap_idx.algo.cipher != RTE_CRYPTO_CIPHER_NULL)
+ ret = rte_cryptodev_sym_capability_check_cipher(capability,
+ tdata->cipher_key.len,
+ tdata->iv.len);
+ if (ret != 0)
+ return -1;
+ }
+
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH) {
+ cap_idx.type = RTE_CRYPTO_SYM_XFORM_AUTH;
+ cap_idx.algo.auth = tdata->auth_algo;
+ capability = rte_cryptodev_sym_capability_get(dev_id, &cap_idx);
+ if (capability == NULL)
+ return -1;
+
+ if (cap_idx.algo.auth != RTE_CRYPTO_AUTH_NULL)
+ ret = rte_cryptodev_sym_capability_check_auth(capability,
+ tdata->auth_key.len,
+ digest_len,
+ 0);
+ if (ret != 0)
+ return -1;
+ }
+
+ return 0;
+}
+
static int
test_blockcipher_one_case(const struct blockcipher_test_case *t,
struct rte_mempool *mbuf_pool,
struct rte_mempool *sess_mpool,
struct rte_mempool *sess_priv_mpool,
uint8_t dev_id,
- int driver_id,
char *test_msg)
{
struct rte_mbuf *ibuf = NULL;
uint8_t cipher_key[tdata->cipher_key.len];
uint8_t auth_key[tdata->auth_key.len];
uint32_t buf_len = tdata->ciphertext.len;
- uint32_t digest_len = 0;
+ uint32_t digest_len = tdata->digest.len;
char *buf_p = NULL;
uint8_t src_pattern = 0xa5;
uint8_t dst_pattern = 0xb6;
uint8_t tmp_src_buf[MBUF_SIZE];
uint8_t tmp_dst_buf[MBUF_SIZE];
- int openssl_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
- int ccp_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD));
- int scheduler_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
- int armv8_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
- int aesni_mb_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
- int qat_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
- int dpaa2_sec_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
- int dpaa_sec_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
- int caam_jr_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
- int mrvl_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
- int virtio_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
- int octeontx_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
-
int nb_segs = 1;
+ uint32_t nb_iterates = 0;
rte_cryptodev_info_get(dev_id, &dev_info);
+ uint64_t feat_flags = dev_info.feature_flags;
+ if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) {
+ if (!(feat_flags & RTE_CRYPTODEV_FF_SYM_SESSIONLESS)) {
+ printf("Device doesn't support sesionless operations "
+ "Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "SKIPPED");
+ return 0;
+ }
+ }
if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SG) {
- uint64_t feat_flags = dev_info.feature_flags;
uint64_t oop_flag = RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT;
- if (t->feature_mask && BLOCKCIPHER_TEST_FEATURE_OOP) {
+ if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
if (!(feat_flags & oop_flag)) {
printf("Device doesn't support out-of-place "
"scatter-gather in input mbuf. "
"Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "SKIPPED");
return 0;
}
} else {
printf("Device doesn't support in-place "
"scatter-gather mbufs. "
"Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "SKIPPED");
return 0;
}
}
nb_segs = 3;
}
+ 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 |
+ RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT |
+ RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT;
+ if (!(feat_flags & oop_flags)) {
+ printf("Device doesn't support out-of-place operations."
+ "Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
+ "SKIPPED");
+ return 0;
+ }
+ }
+
if (tdata->cipher_key.len)
memcpy(cipher_key, tdata->cipher_key.data,
tdata->cipher_key.len);
memcpy(auth_key, tdata->auth_key.data,
tdata->auth_key.len);
- if (driver_id == dpaa2_sec_pmd ||
- driver_id == dpaa_sec_pmd ||
- driver_id == caam_jr_pmd ||
- driver_id == qat_pmd ||
- driver_id == openssl_pmd ||
- driver_id == armv8_pmd ||
- driver_id == mrvl_pmd ||
- driver_id == ccp_pmd ||
- driver_id == virtio_pmd ||
- driver_id == octeontx_pmd) { /* Fall through */
- digest_len = tdata->digest.len;
- } else if (driver_id == aesni_mb_pmd ||
- driver_id == scheduler_pmd) {
- digest_len = tdata->digest.truncated_len;
- } else {
- snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN,
- "line %u FAILED: %s",
- __LINE__, "Unsupported PMD type");
- status = TEST_FAILED;
- goto error_exit;
+ /* Check if PMD is capable of performing that test */
+ if (verify_algo_support(t, dev_id, digest_len) < 0) {
+ RTE_LOG(DEBUG, USER1,
+ "Device does not support this algorithm."
+ "Test Skipped.\n");
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "SKIPPED");
+ return 0;
}
/* preparing data */
sym_op = op->sym;
+iterate:
+ if (nb_iterates) {
+ struct rte_mbuf *tmp_buf = ibuf;
+
+ ibuf = obuf;
+ obuf = tmp_buf;
+
+ rte_pktmbuf_reset(ibuf);
+ rte_pktmbuf_reset(obuf);
+
+ rte_pktmbuf_append(ibuf, tdata->ciphertext.len);
+
+ /* only encryption requires plaintext.data input,
+ * decryption/(digest gen)/(digest verify) use ciphertext.data
+ * to be computed
+ */
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT)
+ pktmbuf_write(ibuf, 0, tdata->plaintext.len,
+ tdata->plaintext.data);
+ else
+ pktmbuf_write(ibuf, 0, tdata->ciphertext.len,
+ tdata->ciphertext.data);
+
+ buf_p = rte_pktmbuf_append(ibuf, digest_len);
+ if (t->op_mask & BLOCKCIPHER_TEST_OP_AUTH_VERIFY)
+ rte_memcpy(buf_p, tdata->digest.data, digest_len);
+ else
+ memset(buf_p, 0, digest_len);
+
+ memset(obuf->buf_addr, dst_pattern, obuf->buf_len);
+
+ buf_p = rte_pktmbuf_append(obuf, buf_len);
+ if (!buf_p) {
+ snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
+ "FAILED: %s", __LINE__,
+ "No room to append mbuf");
+ status = TEST_FAILED;
+ goto error_exit;
+ }
+ memset(buf_p, 0, buf_len);
+ }
+
sym_op->m_src = ibuf;
if (t->feature_mask & BLOCKCIPHER_TEST_FEATURE_OOP) {
cipher_xform->cipher.iv.offset = IV_OFFSET;
cipher_xform->cipher.iv.length = tdata->iv.len;
- sym_op->cipher.data.offset = 0;
- sym_op->cipher.data.length = tdata->ciphertext.len;
+ sym_op->cipher.data.offset = tdata->cipher_offset;
+ sym_op->cipher.data.length = tdata->ciphertext.len -
+ tdata->cipher_offset;
rte_memcpy(rte_crypto_op_ctod_offset(op, uint8_t *, IV_OFFSET),
tdata->iv.data,
tdata->iv.len);
digest_offset);
}
- sym_op->auth.data.offset = 0;
- sym_op->auth.data.length = tdata->ciphertext.len;
+ sym_op->auth.data.offset = tdata->auth_offset;
+ sym_op->auth.data.length = tdata->ciphertext.len -
+ tdata->auth_offset;
}
- /* create session for sessioned op */
- if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS)) {
+ /**
+ * Create session for sessioned op. For mbuf iteration test,
+ * skip the session creation for the second iteration.
+ */
+ if (!(t->feature_mask & BLOCKCIPHER_TEST_FEATURE_SESSIONLESS) &&
+ nb_iterates == 0) {
sess = rte_cryptodev_sym_session_create(sess_mpool);
rte_cryptodev_sym_session_init(dev_id, sess, init_xform,
uint32_t compare_len;
if (t->op_mask & BLOCKCIPHER_TEST_OP_ENCRYPT) {
- compare_ref = tdata->ciphertext.data;
- compare_len = tdata->ciphertext.len;
+ compare_ref = tdata->ciphertext.data +
+ tdata->cipher_offset;
+ compare_len = tdata->ciphertext.len -
+ tdata->cipher_offset;
} else {
- compare_ref = tdata->plaintext.data;
- compare_len = tdata->plaintext.len;
+ compare_ref = tdata->plaintext.data +
+ tdata->cipher_offset;
+ compare_len = tdata->plaintext.len -
+ tdata->cipher_offset;
}
- if (memcmp(rte_pktmbuf_read(iobuf, 0, compare_len,
- buffer), compare_ref, compare_len)) {
+ if (memcmp(rte_pktmbuf_read(iobuf, tdata->cipher_offset,
+ compare_len, buffer), compare_ref,
+ compare_len)) {
snprintf(test_msg, BLOCKCIPHER_TEST_MSG_LEN, "line %u "
"FAILED: %s", __LINE__,
"Crypto data not as expected");
goto error_exit;
}
}
+
+ if (!nb_iterates) {
+ nb_iterates++;
+ goto iterate;
+ }
} else {
/* In-place operation */
struct rte_mbuf *mbuf;
struct rte_mempool *sess_mpool,
struct rte_mempool *sess_priv_mpool,
uint8_t dev_id,
- int driver_id,
enum blockcipher_test_type test_type)
{
int status, overall_status = TEST_SUCCESS;
uint32_t i, test_index = 0;
char test_msg[BLOCKCIPHER_TEST_MSG_LEN + 1];
uint32_t n_test_cases = 0;
- uint32_t target_pmd_mask = 0;
const struct blockcipher_test_case *tcs = NULL;
- int openssl_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OPENSSL_PMD));
- int ccp_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CCP_PMD));
- int dpaa2_sec_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA2_SEC_PMD));
- int dpaa_sec_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_DPAA_SEC_PMD));
- int caam_jr_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_CAAM_JR_PMD));
- int scheduler_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
- int armv8_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_ARMV8_PMD));
- int aesni_mb_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_AESNI_MB_PMD));
- int qat_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_QAT_SYM_PMD));
- int mrvl_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_MVSAM_PMD));
- int virtio_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_VIRTIO_PMD));
- int octeontx_pmd = rte_cryptodev_driver_id_get(
- RTE_STR(CRYPTODEV_NAME_OCTEONTX_SYM_PMD));
-
switch (test_type) {
case BLKCIPHER_AES_CHAIN_TYPE:
n_test_cases = sizeof(aes_chain_test_cases) /
break;
}
- if (driver_id == aesni_mb_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MB;
- else if (driver_id == qat_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_QAT;
- else if (driver_id == openssl_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OPENSSL;
- else if (driver_id == armv8_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_ARMV8;
- else if (driver_id == scheduler_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_SCHEDULER;
- else if (driver_id == dpaa2_sec_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA2_SEC;
- else if (driver_id == ccp_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_CCP;
- else if (driver_id == dpaa_sec_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_DPAA_SEC;
- else if (driver_id == caam_jr_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_CAAM_JR;
- else if (driver_id == mrvl_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_MVSAM;
- else if (driver_id == virtio_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_VIRTIO;
- else if (driver_id == octeontx_pmd)
- target_pmd_mask = BLOCKCIPHER_TEST_TARGET_PMD_OCTEONTX;
- else
- TEST_ASSERT(0, "Unrecognized cryptodev type");
-
for (i = 0; i < n_test_cases; i++) {
const struct blockcipher_test_case *tc = &tcs[i];
- if (!(tc->pmd_mask & target_pmd_mask))
- continue;
-
status = test_blockcipher_one_case(tc, mbuf_pool, op_mpool,
- sess_mpool, sess_priv_mpool, dev_id, driver_id,
+ sess_mpool, sess_priv_mpool, dev_id,
test_msg);
printf(" %u) TestCase %s %s\n", test_index ++,
git.droids-corp.org / dpdk.git / blobdiff