New upstream version 17.08

[deb_dpdk.git] / drivers / crypto / scheduler / scheduler_pmd_ops.c

diff --git a/drivers/crypto/scheduler/scheduler_pmd_ops.c b/drivers/crypto/scheduler/scheduler_pmd_ops.c
index 2b5858d..d379534 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pmd_ops.c
+++ b/drivers/crypto/scheduler/scheduler_pmd_ops.c
@@ -37,6 +37,7 @@
 #include <rte_dev.h>
 #include <rte_cryptodev.h>
 #include <rte_cryptodev_pmd.h>
+#include <rte_cryptodev_vdev.h>
 #include <rte_reorder.h>
 
 #include "scheduler_pmd_private.h"
@@ -368,7 +369,7 @@ scheduler_pmd_info_get(struct rte_cryptodev *dev,
                                max_nb_sessions;
        }
 
-       dev_info->dev_type = dev->dev_type;
+       dev_info->driver_id = dev->driver_id;
        dev_info->feature_flags = dev->feature_flags;
        dev_info->capabilities = sched_ctx->capabilities;
        dev_info->max_nb_queue_pairs = sched_ctx->max_nb_queue_pairs;
@@ -398,7 +399,8 @@ scheduler_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id)
 /** Setup a queue pair */
 static int
 scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
-       const struct rte_cryptodev_qp_conf *qp_conf, int socket_id)
+       const struct rte_cryptodev_qp_conf *qp_conf, int socket_id,
+       struct rte_mempool *session_pool)
 {
        struct scheduler_ctx *sched_ctx = dev->data->dev_private;
        struct scheduler_qp_ctx *qp_ctx;
@@ -420,8 +422,13 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
        for (i = 0; i < sched_ctx->nb_slaves; i++) {
                uint8_t slave_id = sched_ctx->slaves[i].dev_id;
 
+               /*
+                * All slaves will share the same session mempool
+                * for session-less operations, so the objects
+                * must be big enough for all the drivers used.
+                */
                ret = rte_cryptodev_queue_pair_setup(slave_id, qp_id,
-                               qp_conf, socket_id);
+                               qp_conf, socket_id, session_pool);
                if (ret < 0)
                        return ret;
        }
@@ -483,37 +490,41 @@ scheduler_pmd_qp_count(struct rte_cryptodev *dev)
 static uint32_t
 scheduler_pmd_session_get_size(struct rte_cryptodev *dev __rte_unused)
 {
-       return sizeof(struct scheduler_session);
+       struct scheduler_ctx *sched_ctx = dev->data->dev_private;
+       uint8_t i = 0;
+       uint32_t max_priv_sess_size = 0;
+
+       /* Check what is the maximum private session size for all slaves */
+       for (i = 0; i < sched_ctx->nb_slaves; i++) {
+               uint8_t slave_dev_id = sched_ctx->slaves[i].dev_id;
+               struct rte_cryptodev *dev = &rte_cryptodevs[slave_dev_id];
+               uint32_t priv_sess_size = (*dev->dev_ops->session_get_size)(dev);
+
+               if (max_priv_sess_size < priv_sess_size)
+                       max_priv_sess_size = priv_sess_size;
+       }
+
+       return max_priv_sess_size;
 }
 
 static int
-config_slave_sess(struct scheduler_ctx *sched_ctx,
-               struct rte_crypto_sym_xform *xform,
-               struct scheduler_session *sess,
-               uint32_t create)
+scheduler_pmd_session_configure(struct rte_cryptodev *dev,
+       struct rte_crypto_sym_xform *xform,
+       struct rte_cryptodev_sym_session *sess,
+       struct rte_mempool *mempool)
 {
+       struct scheduler_ctx *sched_ctx = dev->data->dev_private;
        uint32_t i;
+       int ret;
 
        for (i = 0; i < sched_ctx->nb_slaves; i++) {
                struct scheduler_slave *slave = &sched_ctx->slaves[i];
 
-               if (sess->sessions[i]) {
-                       if (create)
-                               continue;
-                       /* !create */
-                       sess->sessions[i] = rte_cryptodev_sym_session_free(
-                                       slave->dev_id, sess->sessions[i]);
-               } else {
-                       if (!create)
-                               continue;
-                       /* create */
-                       sess->sessions[i] =
-                                       rte_cryptodev_sym_session_create(
-                                                       slave->dev_id, xform);
-                       if (!sess->sessions[i]) {
-                               config_slave_sess(sched_ctx, NULL, sess, 0);
-                               return -1;
-                       }
+               ret = rte_cryptodev_sym_session_init(slave->dev_id, sess,
+                                       xform, mempool);
+               if (ret < 0) {
+                       CS_LOG_ERR("unabled to config sym session");
+                       return ret;
                }
        }
 
@@ -523,27 +534,17 @@ config_slave_sess(struct scheduler_ctx *sched_ctx,
 /** Clear the memory of session so it doesn't leave key material behind */
 static void
 scheduler_pmd_session_clear(struct rte_cryptodev *dev,
-       void *sess)
+               struct rte_cryptodev_sym_session *sess)
 {
        struct scheduler_ctx *sched_ctx = dev->data->dev_private;
+       uint32_t i;
 
-       config_slave_sess(sched_ctx, NULL, sess, 0);
-
-       memset(sess, 0, sizeof(struct scheduler_session));
-}
-
-static void *
-scheduler_pmd_session_configure(struct rte_cryptodev *dev,
-       struct rte_crypto_sym_xform *xform, void *sess)
-{
-       struct scheduler_ctx *sched_ctx = dev->data->dev_private;
+       /* Clear private data of slaves */
+       for (i = 0; i < sched_ctx->nb_slaves; i++) {
+               struct scheduler_slave *slave = &sched_ctx->slaves[i];
 
-       if (config_slave_sess(sched_ctx, xform, sess, 1) < 0) {
-               CS_LOG_ERR("unabled to config sym session");
-               return NULL;
+               rte_cryptodev_sym_session_clear(slave->dev_id, sess);
        }
-
-       return sess;
 }
 
 struct rte_cryptodev_ops scheduler_pmd_ops = {