Add enqueue/dequeue functions and related dependency functions
to multi process crypto app. Command line options to use are
described in mp_crypto.rst file.

Signed-off-by: Arek Kusztal <arkadiuszx.kusz...@intel.com>
---
 app/test-mp-crypto/Makefile            |   2 +-
 app/test-mp-crypto/main.c              | 544 +++++++++++++++++++++++++++++++++
 app/test-mp-crypto/meson.build         |   3 +-
 app/test-mp-crypto/mp_crypto.c         |  91 ++++++
 app/test-mp-crypto/mp_crypto.h         |  27 ++
 app/test-mp-crypto/mp_crypto_vectors.c | 174 +++++++++++
 app/test-mp-crypto/mp_crypto_vectors.h |  66 ++++
 7 files changed, 905 insertions(+), 2 deletions(-)
 create mode 100644 app/test-mp-crypto/mp_crypto_vectors.c
 create mode 100644 app/test-mp-crypto/mp_crypto_vectors.h

diff --git a/app/test-mp-crypto/Makefile b/app/test-mp-crypto/Makefile
index 9fc1f3c..5d59503 100644
--- a/app/test-mp-crypto/Makefile
+++ b/app/test-mp-crypto/Makefile
@@ -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
diff --git a/app/test-mp-crypto/main.c b/app/test-mp-crypto/main.c
index 46c8055..25833d6 100644
--- a/app/test-mp-crypto/main.c
+++ b/app/test-mp-crypto/main.c
@@ -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;
diff --git a/app/test-mp-crypto/meson.build b/app/test-mp-crypto/meson.build
index 12a6d49..885668b 100644
--- a/app/test-mp-crypto/meson.build
+++ b/app/test-mp-crypto/meson.build
@@ -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')
diff --git a/app/test-mp-crypto/mp_crypto.c b/app/test-mp-crypto/mp_crypto.c
index b996cf5..efa2634 100644
--- a/app/test-mp-crypto/mp_crypto.c
+++ b/app/test-mp-crypto/mp_crypto.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;
+}
diff --git a/app/test-mp-crypto/mp_crypto.h b/app/test-mp-crypto/mp_crypto.h
index fad0230..2616052 100644
--- a/app/test-mp-crypto/mp_crypto.h
+++ b/app/test-mp-crypto/mp_crypto.h
@@ -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))
diff --git a/app/test-mp-crypto/mp_crypto_vectors.c 
b/app/test-mp-crypto/mp_crypto_vectors.c
new file mode 100644
index 0000000..37a4f68
--- /dev/null
+++ b/app/test-mp-crypto/mp_crypto_vectors.c
@@ -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 */
diff --git a/app/test-mp-crypto/mp_crypto_vectors.h 
b/app/test-mp-crypto/mp_crypto_vectors.h
new file mode 100644
index 0000000..65386ad
--- /dev/null
+++ b/app/test-mp-crypto/mp_crypto_vectors.h
@@ -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
-- 
2.1.0

Reply via email to