@@ -10,6 +10,6 @@ CFLAGS += $(WERROR_FLAGS)
CFLAGS += -O3
# all source are stored in SRCS-y
-SRCS-y := main.c mp_crypto.c mp_crypto_parser.c mp_crypto_ipc.c
+SRCS-y := main.c mp_crypto.c mp_crypto_parser.c mp_crypto_ipc.c mp_crypto_vectors.c
include $(RTE_SDK)/mk/rte.app.mk
@@ -562,6 +562,533 @@ int mp_crypto_setup_mpool(void)
return 0;
}
+static int check_capabilities(int dev_id,
+ const struct mp_crypto_session_vector *vector)
+{
+ struct rte_cryptodev_sym_capability_idx cap_idx;
+
+ cap_idx.type = vector->x_type;
+ if (vector->x_type == RTE_CRYPTO_SYM_XFORM_AEAD)
+ cap_idx.algo.aead = vector->aead_algo;
+
+ /* For now rescricted only to AEAD */
+
+ if (rte_cryptodev_sym_capability_get(dev_id, &cap_idx) == NULL)
+ return -ENOTSUP;
+
+ return 0;
+}
+
+int
+mp_crypto_init_sessions(void)
+{
+ uint64_t session_mask_id;
+ uint64_t session_id;
+ int i;
+ int capabiliy_checked = 1;
+ /* Check if all devices support vector 0 */
+ for (i = 0; i < MP_APP_MAX_VECTORS; i++) {
+ int dev_id = mp_app_devs[i].id;
+ /* TODO use proper vector(s), not hardcoded one */
+ if (dev_id < 0)
+ continue;
+
+ int k = 0;
+
+ while (mp_app_params->enq_param.vector_number[k] >= 0 &&
+ k < MP_APP_MAX_VECTORS) {
+ int vector_number =
+ mp_app_params->enq_param.vector_number[k];
+
+ if (vector_number >= (int)mp_app_numof_ops) {
+ MP_APP_LOG(ERR, COL_RED,
+ "Not recognized test vector %d",
+ vector_number);
+ return -1;
+ }
+ if (check_capabilities(dev_id,
+ &session_vectors[vectors[
+ vector_number].session])) {
+ MP_APP_LOG(ERR, COL_RED,
+ "Algorithm unsupported on dev %d",
+ dev_id);
+ capabiliy_checked = 0;
+ }
+ k++;
+ }
+ }
+ if (capabiliy_checked == 0)
+ return -1;
+
+ for (session_mask_id = 1, session_id = 0;
+ session_id <= mp_app_numof_sessions;
+ session_mask_id <<= 1, session_id++) {
+
+ if (session_mask_id & mp_app_params->session_mask) {
+ struct rte_cryptodev_sym_session *sess =
+ mp_app_create_session(mp_app_device_id,
+ &session_vectors[session_id]);
+ if (sess == NULL) {
+ MP_APP_LOG(ERR, COL_RED,
+ "Error when creating session = %p",
+ sess);
+ return -1;
+ }
+ rte_spinlock_lock(&mp_shared_data->sessions.lock);
+ int clear_session = 1;
+
+ if (mp_shared_data->sessions.sym_sessions[
+ session_id].session
+ == NULL) {
+ mp_shared_data->sessions.sym_sessions[
+ session_id].session
+ = sess;
+ clear_session = 0;
+ MP_APP_LOG(INFO, COL_BLUE,
+ "Initialized session = %"PRIu64,
+ session_id);
+ } else {
+ /* Actually refcnt should be incremented
+ * on demand mp_shared_data->sessions.
+ * sym_sessions [session_id].refcnt++;
+ */
+ }
+ rte_spinlock_unlock(&mp_shared_data->sessions.lock);
+ if (clear_session)
+ rte_cryptodev_sym_session_free(sess);
+ }
+ }
+ return 0;
+}
+
+static void
+setup_ops_main_loop(int session_id, int vector_number)
+{
+ while (1) {
+ rte_spinlock_lock(&mp_shared_data->sessions.lock);
+ if (mp_shared_data->sessions.sym_sessions[
+ session_id].session
+ != NULL) {
+ mp_shared_data->sessions.sym_sessions[
+ session_id].refcnt++;
+ rte_spinlock_unlock(&mp_shared_data->sessions.lock);
+ return;
+ }
+ rte_spinlock_unlock(&mp_shared_data->sessions.lock);
+
+ MP_APP_LOG(WARNING, COL_YEL,
+ "Session %d was not yet created, vector %d",
+ session_id, vector_number);
+ char c;
+
+ MP_APP_LOG(INFO, COL_NORM,
+ "Session %d not yet created.\n - Press 'w' to wait until other process will create it\n - Press 'n' to create local session",
+ vectors[session_id].session);
+ int __rte_unused r = scanf("%c", &c);
+
+ if (c == 'n') {
+ struct rte_cryptodev_sym_session *sess =
+ mp_app_create_session(
+ mp_app_device_id,
+ &session_vectors[session_id]);
+ mp_crypto_local_sessions[session_id] =
+ sess;
+ return;
+ } else if (c == 'w') {
+ int timeout = 3;
+ int counter = 1;
+
+ while (counter <= timeout) {
+ rte_delay_ms(1000);
+ MP_APP_LOG(INFO, COL_NORM,
+ "Waiting for %d out of %d seconds",
+ counter++, timeout);
+ }
+ }
+ }
+}
+
+int mp_crypto_setup_ops(void)
+{
+ int i;
+ int used_vectors = 0;
+ int selected_vectors[MP_APP_MAX_VECTORS];
+
+ for (i = 0; i < MP_APP_MAX_VECTORS; i++)
+ selected_vectors[i] = -1;
+
+ i = 0;
+ while (mp_app_params->enq_param.vector_number[i] >= 0 &&
+ i < MP_APP_MAX_VECTORS) {
+ int vector_number = mp_app_params->enq_param.vector_number[i];
+
+ if (mp_app_params->enq_param.vector_number[i] >=
+ (int)mp_app_numof_ops) {
+ MP_APP_LOG(ERR, COL_RED,
+ "Crypto vector %d not defined, skipping",
+ mp_app_params->enq_param.vector_number[i]);
+ i++;
+ continue;
+ }
+ /* Aquire session */
+ int session_id = vectors[vector_number].session;
+
+ setup_ops_main_loop(vectors[vector_number].session,
+ vector_number);
+ MP_APP_LOG(INFO, COL_BLUE,
+ "Configuring vector %d, using session %d",
+ vector_number, session_id);
+
+ selected_vectors[used_vectors++] = vector_number;
+ i++;
+ }
+
+ if (used_vectors == 0)
+ return 0;
+
+ int curr_vector = 0;
+ /* Create vectors and attach to sessions */
+
+ for (i = 0; i < MP_CRYPTO_QP_DESC_NUM; i++) {
+ int session_id =
+ vectors[selected_vectors[curr_vector]].session;
+ if (mp_crypto_local_sessions[session_id] != NULL) {
+ mp_crypto_create_op(mp_crypto_ops[i],
+ mp_crypto_mbufs[i],
+ selected_vectors[curr_vector],
+ mp_crypto_local_sessions[session_id]);
+ } else {
+ mp_crypto_create_op(mp_crypto_ops[i],
+ mp_crypto_mbufs[i],
+ selected_vectors[curr_vector],
+ mp_shared_data->sessions.sym_sessions
+ [session_id].session);
+ }
+ }
+ return 0;
+}
+
+static int check_for_queue(int dev_id, int qp_id)
+{
+ int ret = rte_cryptodev_get_qp_status(dev_id, qp_id);
+
+ if (ret <= 0) {
+ MP_APP_LOG(WARNING, COL_YEL,
+ "Queue %d on dev %d not initialized",
+ qp_id, dev_id);
+ printf(
+ "\n - Press 'w' to wait until other process will initialize it");
+ printf("\n - Press 'x' to exit");
+ char c;
+ int __rte_unused r = scanf("%s", &c);
+
+ if (c == 'w') {
+ int timeout = 3;
+ int counter = 1;
+
+ while (counter <= timeout) {
+ rte_delay_ms(1000);
+ MP_APP_LOG(INFO, COL_NORM,
+ "Waiting for %d out of %d seconds",
+ counter++, 3);
+ }
+ return -1;
+ } else if (c == 'x')
+ return -2;
+ else
+ return -2;
+ }
+ return 0;
+}
+
+static void enqueue(int enq_dev_id, int enq_qp_id, uint64_t *enqueued,
+ uint64_t pcks_to_enq, uint64_t *curr_offset_enq,
+ int *enq_livesign, int process_enq, int process_deq,
+ int *livesign_print_idx, int *livesign_deq_print_idx)
+{
+ if (*enqueued < pcks_to_enq || pcks_to_enq == 0) {
+ /* Consider clearing param above */
+ uint64_t enq;
+ uint64_t to_enq = (MP_CRYPTO_QP_DESC_NUM -
+ *curr_offset_enq) > MP_CRYPTO_BURST_NUM ?
+ MP_CRYPTO_BURST_NUM : MP_CRYPTO_QP_DESC_NUM
+ - *curr_offset_enq;
+
+ if (pcks_to_enq && to_enq > pcks_to_enq - *enqueued)
+ to_enq = pcks_to_enq - *enqueued;
+ enq = rte_cryptodev_enqueue_burst(enq_dev_id,
+ enq_qp_id, &mp_crypto_ops[*curr_offset_enq],
+ to_enq);
+
+ *enqueued += enq;
+ *enq_livesign += enq;
+ *curr_offset_enq = *enqueued % MP_CRYPTO_QP_DESC_NUM;
+ if (*enq_livesign > mp_app_params->enq_param.checkpoint) {
+
+ if (process_enq && !process_deq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM,
+ "Enqueuing %c",
+ livesign_print_char[*livesign_print_idx]);
+ }
+ if (process_enq && process_deq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM,
+ "Enqueuing %c Dequeueing %c",
+ livesign_print_char[*livesign_print_idx],
+ livesign_print_char[*livesign_deq_print_idx]);
+ }
+
+ (*livesign_print_idx)++;
+ *livesign_print_idx = *livesign_print_idx % 4;
+ *enq_livesign = 0;
+ }
+ }
+}
+
+static int dequeue(int deq_dev_id, int deq_qp_id, uint64_t *dequeued,
+ uint64_t pcks_to_deq, uint64_t *curr_offset_deq,
+ int *deq_livesign, int process_enq, int process_deq,
+ int *livesign_print_idx, int *livesign_deq_print_idx,
+ int64_t *deq_stall_counter, uint64_t *deq_threshold)
+{
+ if (*dequeued < pcks_to_deq || pcks_to_deq == 0) {
+ uint64_t deq;
+ uint64_t to_deq = (MP_CRYPTO_QP_DESC_NUM -
+ *curr_offset_deq)
+ > MP_CRYPTO_BURST_NUM ? MP_CRYPTO_BURST_NUM :
+ MP_CRYPTO_QP_DESC_NUM - *curr_offset_deq;
+
+ if (pcks_to_deq && to_deq > pcks_to_deq - *dequeued)
+ to_deq = pcks_to_deq - *dequeued;
+ deq = rte_cryptodev_dequeue_burst(deq_dev_id,
+ deq_qp_id, &mp_crypto_ops_ret[*curr_offset_deq],
+ to_deq);
+ *dequeued += deq;
+ *deq_livesign += deq;
+ *curr_offset_deq = *dequeued % MP_CRYPTO_QP_DESC_NUM;
+ if (*deq_livesign > mp_app_params->deq_param.checkpoint) {
+ if (process_deq && !process_enq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM,
+ "Dequeueing %c",
+ livesign_print_char[*livesign_deq_print_idx]);
+ }
+ if (process_enq && process_deq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM,
+ "Enqueuing %c Dequeueing %c",
+ livesign_print_char[*livesign_print_idx],
+ livesign_print_char[*livesign_deq_print_idx]);
+ }
+ (*livesign_deq_print_idx)++;
+ *livesign_deq_print_idx %= 4;
+ *deq_livesign = 0;
+ }
+ if (deq == 0)
+ (*deq_stall_counter)++;
+ else
+ *deq_stall_counter = 0;
+ if (mp_crypto_exit_flag) {
+ *deq_threshold += deq;
+ if (*deq_threshold > DEQ_THRESHOLD)
+ return -1;
+ if (*deq_stall_counter > DEQ_THRESHOLD)
+ return -1;
+ }
+ }
+ return 0;
+}
+
+int mp_crypto_flow(void)
+{
+ int process_enq = 0, process_deq = 0;
+ uint64_t curr_offset_enq = 0;
+ uint64_t curr_offset_deq = 0;
+ uint64_t enqueued = 0;
+ uint64_t dequeued = 0;
+ uint64_t deq_threshold = 0;
+ char c = 0;
+ uint64_t pcks_to_enq = 0, pcks_to_deq = 0;
+
+ int enq_dev_id = mp_app_devs[mp_app_params->enq_param.dev_id].id;
+ int deq_dev_id = mp_app_devs[mp_app_params->deq_param.dev_id].id;
+ int enq_qp_id = mp_app_params->enq_param.qp_id;
+ int deq_qp_id = mp_app_params->deq_param.qp_id;
+ int enq_livesign = 0, deq_livesign = 0;
+ int64_t deq_stall_counter = 0;
+ int livesign_print_idx = 0;
+ int livesign_deq_print_idx = 0;
+
+ if (mp_app_params->enq_param.dev_id >= 0 &&
+ !mp_app_devs[mp_app_params->enq_param.dev_id].probed) {
+ MP_APP_LOG(ERR, COL_RED, "Incorrect enq device provided %d",
+ mp_app_params->enq_param.dev_id);
+ } else if (mp_app_params->enq_param.dev_id >= 0) {
+ MP_APP_LOG(INFO, COL_BLUE,
+ "Start enqueuing packets on dev %d qp %d",
+ mp_app_params->enq_param.dev_id,
+ mp_app_params->enq_param.qp_id);
+ pcks_to_enq = mp_app_params->enq_param.ops_no;
+ process_enq = 1;
+ }
+ if (mp_app_params->deq_param.dev_id >= 0 &&
+ !mp_app_devs[mp_app_params->deq_param.dev_id].probed) {
+ MP_APP_LOG(ERR, COL_RED, "Incorrect deq device provided %d",
+ mp_app_params->deq_param.dev_id);
+ } else if (mp_app_params->deq_param.dev_id >= 0) {
+ MP_APP_LOG(INFO, COL_BLUE,
+ "Start dequeuing packets on dev %d qp %d",
+ mp_app_params->deq_param.dev_id,
+ mp_app_params->deq_param.qp_id);
+ pcks_to_deq = mp_app_params->deq_param.ops_no;
+ process_deq = 1;
+ }
+
+ if (process_enq == 0 && process_deq == 0) {
+ MP_APP_LOG_2(WARNING, COL_YEL, "Nothing to process");
+ if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+ while (c != 'k') {
+ printf("\nPress 'k' to exit: ");
+ int __rte_unused r = scanf("%c", &c);
+ }
+ }
+ return 0;
+ }
+
+ /* Check if enq queue was configured */
+ while (process_enq) {
+ int v = check_for_queue(enq_dev_id, enq_qp_id);
+
+ if (v == -1)
+ continue;
+ else if (v == 0)
+ break;
+ else
+ return -1;
+ }
+
+ /* Check if deq queue was configured */
+ while (process_deq) {
+ int v = check_for_queue(deq_dev_id, deq_qp_id);
+
+ if (v == -1)
+ continue;
+ else if (v == 0)
+ break;
+ else
+ return -1;
+ }
+
+ if (process_enq && !process_deq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM, "Enqueuing %c",
+ livesign_print_char[livesign_print_idx]);
+ } else if (process_deq && !process_enq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM, "Dequeuing %c",
+ livesign_print_char[livesign_deq_print_idx]);
+ } else if (process_enq && process_deq) {
+ MP_APP_LOG_NO_RET(INFO, COL_NORM, "Enqueuing %c Dequeueing %c",
+ livesign_print_char[livesign_print_idx],
+ livesign_print_char[livesign_deq_print_idx]);
+ }
+ while (1) {
+ if (process_enq && !mp_crypto_exit_flag) {
+ enqueue(enq_dev_id, enq_qp_id, &enqueued,
+ pcks_to_enq, &curr_offset_enq,
+ &enq_livesign, process_enq, process_deq,
+ &livesign_print_idx, &livesign_deq_print_idx);
+ }
+
+ if (process_deq) {
+ int ret = dequeue(deq_dev_id, deq_qp_id, &dequeued,
+ pcks_to_deq, &curr_offset_deq,
+ &deq_livesign, process_enq, process_deq,
+ &livesign_print_idx, &livesign_deq_print_idx,
+ &deq_stall_counter, &deq_threshold);
+
+ if (ret < 0)
+ break;
+ }
+
+ if (((dequeued == pcks_to_deq && process_deq)) &&
+ ((enqueued == pcks_to_enq && process_enq))) {
+ MP_APP_LOG(INFO, COL_GREEN,
+ "\nEnqueued %"PRIu64", dequeued %"PRIu64" packets",
+ enqueued, dequeued);
+ break;
+ } else if (dequeued == pcks_to_deq && process_deq &&
+ !process_enq && pcks_to_deq) {
+ MP_APP_LOG(INFO, COL_GREEN, "\nDequeued %"PRIu64" packets",
+ dequeued);
+ break;
+ } else if (enqueued == pcks_to_enq && process_enq &&
+ !process_deq && process_enq) {
+ MP_APP_LOG(INFO, COL_GREEN, "\nEnqueued %"PRIu64" packets",
+ enqueued);
+ break;
+ }
+ if (mp_crypto_exit_flag && !process_deq)
+ break;
+ }
+
+ /* Verify if all packets are correct */
+ if (process_deq) {
+ uint64_t last_packet = pcks_to_deq > MP_CRYPTO_QP_DESC_NUM ?
+ MP_CRYPTO_QP_DESC_NUM : pcks_to_deq;
+ if (pcks_to_deq == 0)
+ last_packet = MP_CRYPTO_QP_DESC_NUM;
+ if (last_packet >= dequeued)
+ last_packet = dequeued;
+ uint64_t k;
+ int err = 0;
+
+ for (k = 0; k < last_packet; k++) {
+ if (mp_crypto_ops_ret[k]->status !=
+ RTE_CRYPTO_OP_STATUS_SUCCESS) {
+ MP_APP_LOG(ERR, COL_RED,
+ "error when checking status of %"PRIu64" packet out of last %"PRIu64" packets",
+ k, last_packet);
+ err = 1;
+ break;
+ }
+ }
+ if (err == 0) {
+ MP_APP_LOG(INFO, COL_GREEN,
+ "\nAll %"PRIu64" last packets verified correctly",
+ last_packet);
+ }
+ }
+
+ if (mp_app_params->print_stats) {
+ struct rte_cryptodev_stats stats;
+
+ if (enq_qp_id >= 0) {
+ rte_cryptodev_stats_get(enq_dev_id, &stats);
+ MP_APP_LOG(INFO, COL_BLUE,
+ "STATS: Enqueued on dev %d = %"PRIu64,
+ enq_dev_id, stats.enqueued_count);
+ MP_APP_LOG(INFO, COL_BLUE,
+ "STATS: Enqueue err count on dev %d = %"PRIu64,
+ enq_dev_id,
+ stats.enqueue_err_count);
+ }
+ if (deq_qp_id >= 0) {
+ rte_cryptodev_stats_get(deq_dev_id, &stats);
+ MP_APP_LOG(INFO, COL_BLUE,
+ "STATS: Dequeued on dev %d = %"PRIu64,
+ deq_dev_id, stats.dequeued_count);
+ MP_APP_LOG(INFO, COL_BLUE,
+ "STATS: Dequeue err count on dev %d = %"PRIu64,
+ deq_dev_id, stats.dequeue_err_count);
+ }
+
+ if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+ while (c != 'k') {
+ printf("\nPress 'k' to exit: ");
+ int __rte_unused r = scanf("%c", &c);
+ }
+ }
+ }
+
+ return 0;
+}
+
int main(int argc, char *argv[])
{
@@ -587,6 +1114,23 @@ int main(int argc, char *argv[])
MP_APP_LOG_2(ERR, COL_RED, "Cannot create mempools");
goto err;
}
+ ret = mp_crypto_init_sessions();
+ if (ret < 0) {
+ MP_APP_LOG_2(ERR, COL_RED, "Cannot initialize sessions");
+ goto err;
+ }
+
+ ret = mp_crypto_setup_ops();
+ if (ret < 0) {
+ MP_APP_LOG_2(ERR, COL_RED, "Cannot setup ops");
+ goto err;
+ }
+
+ ret = mp_crypto_flow();
+ if (ret < 0) {
+ MP_APP_LOG_2(ERR, COL_RED, "Cannot enq/deq");
+ goto err;
+ }
mp_crypto_exit_app();
return 0;
@@ -1,7 +1,8 @@
# SPDX-License-Identifier: BSD-3-Clause
# Copyright(c) 2020 Intel Corporation
-sources = files('mp_crypto.c',
+sources = files('mp_crypto_vectors.c',
+ 'mp_crypto.c',
'mp_crypto_parser.c',
'mp_crypto_ipc.c',
'main.c')
@@ -43,3 +43,94 @@ struct rte_crypto_op *mp_crypto_ops_ret[MP_CRYPTO_OPS_NUM];
/* Per process set of return rte crypto ops */
struct rte_mbuf *mp_crypto_mbufs[MP_CRYPTO_OPS_NUM];
/* Per process set of rte mbufs */
+struct rte_cryptodev_sym_session *mp_crypto_local_sessions[MAX_NUM_OF_SESSIONS];
+/* Array of private sessions */
+
+/* Function for creating sessions */
+struct rte_cryptodev_sym_session *mp_app_create_session
+ (int dev_id, const struct mp_crypto_session_vector *vector)
+{
+ if (vector->x_type == RTE_CRYPTO_SYM_XFORM_AEAD)
+ return mp_app_create_aead_session(dev_id, vector);
+ MP_APP_LOG_2(ERR, COL_RED, "Invalid xform type");
+ return NULL;
+}
+
+/* Create AEAD session */
+struct rte_cryptodev_sym_session*
+mp_app_create_aead_session(int dev_id,
+ const struct mp_crypto_session_vector *vector)
+{
+ struct rte_cryptodev_sym_session *session;
+ struct rte_crypto_sym_xform xform;
+
+ xform.next = NULL;
+ xform.type = RTE_CRYPTO_SYM_XFORM_AEAD;
+ xform.aead.key.length = vector->crypto_key.len;
+ xform.aead.key.data = vector->crypto_key.data;
+ xform.aead.algo = vector->aead_algo;
+ xform.aead.digest_length = vector->digest_len;
+ xform.aead.iv.length = vector->iv_len;
+ xform.aead.iv.offset = IV_OFFSET;
+ xform.aead.aad_length = vector->aad_len;
+ xform.aead.op = RTE_CRYPTO_AEAD_OP_ENCRYPT;
+
+ session = rte_cryptodev_sym_session_create(mp_crypto_session_mempool);
+ if (session == NULL) {
+ MP_APP_LOG_2(ERR, COL_RED, "Failed to create session");
+ return NULL;
+ }
+ int status = rte_cryptodev_sym_session_init(dev_id, session,
+ &xform, mp_crypto_priv_session_mp);
+ if (status < 0) {
+ MP_APP_LOG_2(ERR, COL_RED, "Failed to init session");
+ return NULL;
+ }
+
+ return session;
+}
+
+int
+mp_crypto_create_op(struct rte_crypto_op *op, struct rte_mbuf *mbuf,
+ uint16_t vector_number,
+ struct rte_cryptodev_sym_session *sess)
+{
+ uint8_t *plaintext;
+ uint32_t aad_pad_len =
+ RTE_ALIGN_CEIL(session_vectors[vectors[vector_number].
+ session].aad_len, 16);
+
+ memset(rte_pktmbuf_mtod(mbuf, uint8_t *), 0,
+ rte_pktmbuf_tailroom(mbuf));
+ struct rte_crypto_sym_op *sym_op = op->sym;
+
+ sym_op->aead.aad.data = (uint8_t *)rte_pktmbuf_append(mbuf,
+ aad_pad_len);
+ sym_op->aead.aad.phys_addr =
+ rte_pktmbuf_iova(mbuf);
+ memcpy(sym_op->aead.aad.data, vectors[vector_number].aad.data,
+ session_vectors[vectors[vector_number].session].aad_len);
+ uint8_t *iv_ptr = rte_crypto_op_ctod_offset(op,
+ uint8_t *, IV_OFFSET);
+ rte_memcpy(iv_ptr, vectors[vector_number].iv,
+ session_vectors[vectors[vector_number].session].iv_len);
+
+ plaintext = (uint8_t *)rte_pktmbuf_append(mbuf,
+ vectors[vector_number].plaintext.len);
+ rte_memcpy(plaintext, vectors[vector_number].plaintext.data,
+ vectors[vector_number].plaintext.len);
+
+ sym_op->aead.digest.phys_addr =
+ rte_pktmbuf_iova_offset(mbuf,
+ vectors[vector_number].plaintext.len);
+
+ sym_op->aead.digest.data = (uint8_t *)rte_pktmbuf_append(
+ mbuf, vectors[vector_number].digest.len);
+
+ sym_op->aead.data.length = vectors[vector_number].plaintext.len;
+ sym_op->aead.data.offset = 0;
+
+ if (rte_crypto_op_attach_sym_session(op, sess))
+ return -1;
+ return 0;
+}
@@ -7,6 +7,7 @@
#include <stdint.h>
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
+#include "mp_crypto_vectors.h"
/* Intel QuickAssist Technology Symmetric service PMD name */
#define CRYPTODEV_NAME_QAT_SYM_PMD "crypto_qat"
@@ -32,6 +33,8 @@
#define MP_APP_CRYPTO_OP_POOL_NAME "MP_APP_OP_NAME"
/* Mbuf information */
#define MP_APP_MBUFPOOL_NAME "MP_APP_MBUF_NAME"
+/* How long to weit before quit when exit flag set */
+#define DEQ_THRESHOLD 100000
extern int mp_crypto_exit_flag;
/* Global exit flag */
@@ -189,6 +192,30 @@ int mp_crypto_init_devs(void);
int mp_crypto_setup_mpool(void);
/* Function to set or lookup for mempools */
+int mp_crypto_init_sessions(void);
+/* Function to setup session according to mask */
+
+int mp_crypto_setup_ops(void);
+/* Function to setup opse according to input string enq=[] */
+
+/* Create and init symmetric session */
+struct rte_cryptodev_sym_session *mp_app_create_session
+ (int dev_id, const struct mp_crypto_session_vector *vector);
+
+/* Create AEAD session */
+struct rte_cryptodev_sym_session*
+ mp_app_create_aead_session(int dev_id,
+ const struct mp_crypto_session_vector *vector);
+
+/* Create op */
+int
+mp_crypto_create_op(struct rte_crypto_op *op, struct rte_mbuf *mbuf,
+ uint16_t vector_number,
+ struct rte_cryptodev_sym_session *sess);
+
+int mp_crypto_flow(void);
+/* Flow function for enqueue dequeue */
+
#define IV_OFFSET (sizeof(struct rte_crypto_op) + \
sizeof(struct rte_crypto_sym_op) + DEFAULT_NUM_XFORMS * \
sizeof(struct rte_crypto_sym_xform))
new file mode 100644
@@ -0,0 +1,174 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Intel Corporation
+ */
+#include "mp_crypto_vectors.h"
+
+const struct mp_crypto_session_vector session_vectors[] = {
+ { /* Session 0 */
+ .aead_op = RTE_CRYPTO_AEAD_OP_ENCRYPT,
+ .x_type = RTE_CRYPTO_SYM_XFORM_AEAD,
+ .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
+ .crypto_key = {
+ .data = {
+ 0xfe, 0xff, 0xe9, 0x92, 0x86, 0x65, 0x73, 0x1c,
+ 0x6d, 0x6a, 0x8f, 0x94, 0x67, 0x30, 0x83, 0x08
+ },
+ .len = 16,
+ },
+ .aad_len = 0,
+ .iv_len = 12,
+ .digest_len = 16,
+ },
+ { /* Session 1 */
+ .aead_op = RTE_CRYPTO_AEAD_OP_ENCRYPT,
+ .x_type = RTE_CRYPTO_SYM_XFORM_AEAD,
+ .aead_algo = RTE_CRYPTO_AEAD_AES_GCM,
+ .crypto_key = {
+ .data = {
+ 0xFE, 0xFF, 0xE9, 0x92, 0x86, 0x65, 0x73, 0x1C,
+ 0x6D, 0x6A, 0x8F, 0x94, 0x67, 0x30, 0x83, 0x08,
+ 0xFE, 0xFF, 0xE9, 0x92, 0x86, 0x65, 0x73, 0x1C
+ },
+ .len = 24,
+ },
+ .aad_len = 0,
+ .iv_len = 12,
+ .digest_len = 16,
+ },
+};
+const uint64_t mp_app_numof_sessions =
+ RTE_DIM(session_vectors);
+/* Number of all sessions in array */
+
+const struct mp_crypto_vector vectors[] = {
+ { /* Vector 0 AES128-GCM */
+ .session = 0,
+ .plaintext = {
+ .data = {
+ 0xd9, 0x31, 0x32, 0x25,
+ 0xf8, 0x84, 0x06, 0xe5,
+ 0xa5, 0x59, 0x09, 0xc5,
+ 0xaf, 0xf5, 0x26, 0x9a,
+ 0x86, 0xa7, 0xa9, 0x53,
+ 0x15, 0x34, 0xf7, 0xda,
+ 0x2e, 0x4c, 0x30, 0x3d,
+ 0x8a, 0x31, 0x8a, 0x72,
+ 0x1c, 0x3c, 0x0c, 0x95,
+ 0x95, 0x68, 0x09, 0x53,
+ 0x2f, 0xcf, 0x0e, 0x24,
+ 0x49, 0xa6, 0xb5, 0x25,
+ 0xb1, 0x6a, 0xed, 0xf5,
+ 0xaa, 0x0d, 0xe6, 0x57,
+ 0xba, 0x63, 0x7b, 0x39,
+ },
+ .len = 60,
+ },
+ .iv = {
+ 0xca, 0xfe, 0xba, 0xbe,
+ 0xfa, 0xce, 0xdb, 0xad,
+ 0xde, 0xca, 0xf8, 0x88
+ },
+ .ciphertext = {
+ .data = {
+ 0x42, 0x83, 0x1e, 0xc2,
+ 0x21, 0x77, 0x74, 0x24,
+ 0x4b, 0x72, 0x21, 0xb7,
+ 0x84, 0xd0, 0xd4, 0x9c,
+ 0xe3, 0xaa, 0x21, 0x2f,
+ 0x2c, 0x02, 0xa4, 0xe0,
+ 0x35, 0xc1, 0x7e, 0x23,
+ 0x29, 0xac, 0xa1, 0x2e,
+ 0x21, 0xd5, 0x14, 0xb2,
+ 0x54, 0x66, 0x93, 0x1c,
+ 0x7d, 0x8f, 0x6a, 0x5a,
+ 0xac, 0x84, 0xaa, 0x05,
+ 0x1b, 0xa3, 0x0b, 0x39,
+ 0x6a, 0x0a, 0xac, 0x97,
+ 0x3d, 0x58, 0xe0, 0x91
+ },
+ .len = 60
+ },
+ .aad = {
+ .data = {
+
+ },
+ },
+ .digest = {
+ .data = {
+ 0xA2, 0xA4, 0x35, 0x75,
+ 0xDC, 0xB0, 0x57, 0x74,
+ 0x07, 0x02, 0x30, 0xC2,
+ 0xE7, 0x52, 0x02, 0x00},
+ .len = 16
+ },
+ },
+ { /* Vector 1 AES192-GCM */
+ .session = 1,
+ .plaintext = {
+ .data = {
+ 0xD9, 0x31, 0x32, 0x25,
+ 0xF8, 0x84, 0x06, 0xE5,
+ 0xA5, 0x59, 0x09, 0xC5,
+ 0xAF, 0xF5, 0x26, 0x9A,
+ 0x86, 0xA7, 0xA9, 0x53,
+ 0x15, 0x34, 0xF7, 0xDA,
+ 0x2E, 0x4C, 0x30, 0x3D,
+ 0x8A, 0x31, 0x8A, 0x72,
+ 0x1C, 0x3C, 0x0C, 0x95,
+ 0x95, 0x68, 0x09, 0x53,
+ 0x2F, 0xCF, 0x0E, 0x24,
+ 0x49, 0xA6, 0xB5, 0x25,
+ 0xB1, 0x6A, 0xED, 0xF5,
+ 0xAA, 0x0D, 0xE6, 0x57,
+ 0xBA, 0x63, 0x7B, 0x39,
+ 0x1A, 0xAF, 0xD2, 0x55
+ },
+ .len = 60,
+ },
+ .iv = {
+ 0xCA, 0xFE, 0xBA, 0xBE,
+ 0xFA, 0xCE, 0xDB, 0xAD,
+ 0xDE, 0xCA, 0xF8, 0x88
+ },
+ .ciphertext = {
+ .data = {
+ 0x39, 0x80, 0xCA, 0x0B,
+ 0x3C, 0x00, 0xE8, 0x41,
+ 0xEB, 0x06, 0xFA, 0xC4,
+ 0x87, 0x2A, 0x27, 0x57,
+ 0x85, 0x9E, 0x1C, 0xEA,
+ 0xA6, 0xEF, 0xD9, 0x84,
+ 0x62, 0x85, 0x93, 0xB4,
+ 0x0C, 0xA1, 0xE1, 0x9C,
+ 0x7D, 0x77, 0x3D, 0x00,
+ 0xC1, 0x44, 0xC5, 0x25,
+ 0xAC, 0x61, 0x9D, 0x18,
+ 0xC8, 0x4A, 0x3F, 0x47,
+ 0x18, 0xE2, 0x44, 0x8B,
+ 0x2F, 0xE3, 0x24, 0xD9,
+ 0xCC, 0xDA, 0x27, 0x10,
+ 0xAC, 0xAD, 0xE2, 0x56
+ },
+ .len = 60
+ },
+ .aad = {
+ .data = {
+
+ },
+ },
+ .digest = {
+ .data = {
+ 0x99, 0x24, 0xA7, 0xC8,
+ 0x58, 0x73, 0x36, 0xBF,
+ 0xB1, 0x18, 0x02, 0x4D,
+ 0xB8, 0x67, 0x4A, 0x14
+ },
+ .len = 16
+ },
+ },
+
+
+};
+
+const uint64_t mp_app_numof_ops = RTE_DIM(vectors);
+/* Number of all operation instances */
new file mode 100644
@@ -0,0 +1,66 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Intel Corporation
+ */
+#ifndef _MP_CRYPTO_SAMPLE_APP_VECTORS_
+#define _MP_CRYPTO_SAMPLE_APP_VECTORS_
+
+#include <rte_cryptodev.h>
+
+struct mp_crypto_session_vector {
+ union {
+ enum rte_crypto_aead_algorithm aead_algo;
+ enum rte_crypto_auth_algorithm auth_algo;
+ enum rte_crypto_cipher_algorithm cipher_algo;
+ };
+ enum rte_crypto_sym_xform_type x_type;
+ union {
+ enum rte_crypto_aead_operation aead_op;
+ enum rte_crypto_cipher_operation cipher_op;
+ enum rte_crypto_auth_operation auth_op;
+ };
+ struct {
+ uint8_t data[64];
+ uint16_t len;
+ } crypto_key;
+ struct {
+ uint8_t data[64];
+ uint16_t len;
+ } auth_key;
+ uint16_t aad_len;
+ uint16_t iv_len;
+ uint16_t digest_len;
+ int chained;
+};
+
+struct mp_crypto_vector {
+ int session;
+ struct {
+ uint8_t data[2048];
+ int len;
+ } ciphertext;
+ struct {
+ uint8_t data[2048];
+ int len;
+ } plaintext;
+ struct {
+ uint8_t data[2048];
+ int len;
+ } digest;
+ struct {
+ uint8_t data[64];
+ } aad;
+ uint8_t iv[16];
+};
+
+/* Predefinced vectors */
+extern const struct mp_crypto_session_vector session_vectors[];
+/* Sessions vectors for this device */
+extern const uint64_t mp_app_numof_sessions;
+/* Number of all sessions in array */
+
+extern const struct mp_crypto_vector vectors[];
+/* Operation vectors for this device */
+const uint64_t mp_app_numof_ops;
+/* Total number of operation types */
+
+#endif