trace: simplify trace point headers

[dpdk.git] / lib / librte_cryptodev / rte_cryptodev.c

diff --git a/lib/librte_cryptodev/rte_cryptodev.c b/lib/librte_cryptodev/rte_cryptodev.c
index b16ef7b..7693eb6 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev.c
+++ b/lib/librte_cryptodev/rte_cryptodev.c
@@ -1,5 +1,5 @@
 /* SPDX-License-Identifier: BSD-3-Clause
- * Copyright(c) 2015-2017 Intel Corporation
+ * Copyright(c) 2015-2020 Intel Corporation
  */
 
 #include <sys/types.h>
@@ -40,6 +40,7 @@
 #include "rte_crypto.h"
 #include "rte_cryptodev.h"
 #include "rte_cryptodev_pmd.h"
+#include "rte_cryptodev_trace.h"
 
 static uint8_t nb_drivers;
 
@@ -50,8 +51,7 @@ struct rte_cryptodev *rte_cryptodevs = rte_crypto_devices;
 static struct rte_cryptodev_global cryptodev_globals = {
                .devs                   = rte_crypto_devices,
                .data                   = { NULL },
-               .nb_devs                = 0,
-               .max_devs               = RTE_CRYPTO_MAX_DEVS
+               .nb_devs                = 0
 };
 
 /* spinlock for crypto device callbacks */
@@ -174,6 +174,8 @@ const char *rte_crypto_asym_xform_strings[] = {
        [RTE_CRYPTO_ASYM_XFORM_MODINV]  = "modinv",
        [RTE_CRYPTO_ASYM_XFORM_DH]      = "dh",
        [RTE_CRYPTO_ASYM_XFORM_DSA]     = "dsa",
+       [RTE_CRYPTO_ASYM_XFORM_ECDSA]   = "ecdsa",
+       [RTE_CRYPTO_ASYM_XFORM_ECPM]    = "ecpm",
 };
 
 /**
@@ -492,6 +494,12 @@ rte_cryptodev_get_feature_name(uint64_t flag)
                return "RSA_PRIV_OP_KEY_QT";
        case RTE_CRYPTODEV_FF_DIGEST_ENCRYPTED:
                return "DIGEST_ENCRYPTED";
+       case RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO:
+               return "SYM_CPU_CRYPTO";
+       case RTE_CRYPTODEV_FF_ASYM_SESSIONLESS:
+               return "ASYM_SESSIONLESS";
+       case RTE_CRYPTODEV_FF_SYM_SESSIONLESS:
+               return "SYM_SESSIONLESS";
        default:
                return NULL;
        }
@@ -512,7 +520,7 @@ rte_cryptodev_pmd_get_named_dev(const char *name)
        if (name == NULL)
                return NULL;
 
-       for (i = 0; i < cryptodev_globals.max_devs; i++) {
+       for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) {
                dev = &cryptodev_globals.devs[i];
 
                if ((dev->attached == RTE_CRYPTODEV_ATTACHED) &&
@@ -523,12 +531,22 @@ rte_cryptodev_pmd_get_named_dev(const char *name)
        return NULL;
 }
 
+static inline uint8_t
+rte_cryptodev_is_valid_device_data(uint8_t dev_id)
+{
+       if (dev_id >= RTE_CRYPTO_MAX_DEVS ||
+                       rte_crypto_devices[dev_id].data == NULL)
+               return 0;
+
+       return 1;
+}
+
 unsigned int
 rte_cryptodev_pmd_is_valid_dev(uint8_t dev_id)
 {
        struct rte_cryptodev *dev = NULL;
 
-       if (dev_id >= cryptodev_globals.nb_devs)
+       if (!rte_cryptodev_is_valid_device_data(dev_id))
                return 0;
 
        dev = rte_cryptodev_pmd_get_dev(dev_id);
@@ -547,12 +565,15 @@ rte_cryptodev_get_dev_id(const char *name)
        if (name == NULL)
                return -1;
 
-       for (i = 0; i < cryptodev_globals.nb_devs; i++)
+       for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++) {
+               if (!rte_cryptodev_is_valid_device_data(i))
+                       continue;
                if ((strcmp(cryptodev_globals.devs[i].data->name, name)
                                == 0) &&
                                (cryptodev_globals.devs[i].attached ==
                                                RTE_CRYPTODEV_ATTACHED))
                        return i;
+       }
 
        return -1;
 }
@@ -568,7 +589,7 @@ rte_cryptodev_device_count_by_driver(uint8_t driver_id)
 {
        uint8_t i, dev_count = 0;
 
-       for (i = 0; i < cryptodev_globals.max_devs; i++)
+       for (i = 0; i < RTE_CRYPTO_MAX_DEVS; i++)
                if (cryptodev_globals.devs[i].driver_id == driver_id &&
                        cryptodev_globals.devs[i].attached ==
                                        RTE_CRYPTODEV_ATTACHED)
@@ -583,9 +604,10 @@ rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,
 {
        uint8_t i, count = 0;
        struct rte_cryptodev *devs = cryptodev_globals.devs;
-       uint8_t max_devs = cryptodev_globals.max_devs;
 
-       for (i = 0; i < max_devs && count < nb_devices; i++) {
+       for (i = 0; i < RTE_CRYPTO_MAX_DEVS && count < nb_devices; i++) {
+               if (!rte_cryptodev_is_valid_device_data(i))
+                       continue;
 
                if (devs[i].attached == RTE_CRYPTODEV_ATTACHED) {
                        int cmp;
@@ -605,8 +627,9 @@ rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,
 void *
 rte_cryptodev_get_sec_ctx(uint8_t dev_id)
 {
-       if (rte_crypto_devices[dev_id].feature_flags &
-                       RTE_CRYPTODEV_FF_SECURITY)
+       if (dev_id < RTE_CRYPTO_MAX_DEVS &&
+                       (rte_crypto_devices[dev_id].feature_flags &
+                       RTE_CRYPTODEV_FF_SECURITY))
                return rte_crypto_devices[dev_id].security_ctx;
 
        return NULL;
@@ -777,6 +800,11 @@ rte_cryptodev_queue_pair_count(uint8_t dev_id)
 {
        struct rte_cryptodev *dev;
 
+       if (!rte_cryptodev_is_valid_device_data(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return 0;
+       }
+
        dev = &rte_crypto_devices[dev_id];
        return dev->data->nb_queue_pairs;
 }
@@ -889,6 +917,7 @@ rte_cryptodev_configure(uint8_t dev_id, struct rte_cryptodev_config *config)
                return diag;
        }
 
+       rte_cryptodev_trace_configure(dev_id, config);
        return (*dev->dev_ops->dev_configure)(dev, config);
 }
 
@@ -917,6 +946,7 @@ rte_cryptodev_start(uint8_t dev_id)
        }
 
        diag = (*dev->dev_ops->dev_start)(dev);
+       rte_cryptodev_trace_start(dev_id, diag);
        if (diag == 0)
                dev->data->dev_started = 1;
        else
@@ -946,6 +976,7 @@ rte_cryptodev_stop(uint8_t dev_id)
        }
 
        (*dev->dev_ops->dev_stop)(dev);
+       rte_cryptodev_trace_stop(dev_id);
        dev->data->dev_started = 0;
 }
 
@@ -982,6 +1013,7 @@ rte_cryptodev_close(uint8_t dev_id)
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_close, -ENOTSUP);
        retval = (*dev->dev_ops->dev_close)(dev);
+       rte_cryptodev_trace_close(dev_id, retval);
 
        if (retval < 0)
                return retval;
@@ -1051,6 +1083,7 @@ rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->queue_pair_setup, -ENOTSUP);
 
+       rte_cryptodev_trace_queue_pair_setup(dev_id, queue_pair_id, qp_conf);
        return (*dev->dev_ops->queue_pair_setup)(dev, queue_pair_id, qp_conf,
                        socket_id);
 }
@@ -1101,7 +1134,7 @@ rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info)
 {
        struct rte_cryptodev *dev;
 
-       if (dev_id >= cryptodev_globals.nb_devs) {
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
                CDEV_LOG_ERR("Invalid dev_id=%d", dev_id);
                return;
        }
@@ -1242,6 +1275,11 @@ rte_cryptodev_sym_session_init(uint8_t dev_id,
        uint8_t index;
        int ret;
 
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return -EINVAL;
+       }
+
        dev = rte_cryptodev_pmd_get_dev(dev_id);
 
        if (sess == NULL || xforms == NULL || dev == NULL)
@@ -1267,6 +1305,7 @@ rte_cryptodev_sym_session_init(uint8_t dev_id,
                }
        }
 
+       rte_cryptodev_trace_sym_session_init(dev_id, sess, xforms, mp);
        sess->sess_data[index].refcnt++;
        return 0;
 }
@@ -1281,6 +1320,11 @@ rte_cryptodev_asym_session_init(uint8_t dev_id,
        uint8_t index;
        int ret;
 
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return -EINVAL;
+       }
+
        dev = rte_cryptodev_pmd_get_dev(dev_id);
 
        if (sess == NULL || xforms == NULL || dev == NULL)
@@ -1303,6 +1347,7 @@ rte_cryptodev_asym_session_init(uint8_t dev_id,
                }
        }
 
+       rte_cryptodev_trace_asym_session_init(dev_id, sess, xforms, mp);
        return 0;
 }
 
@@ -1343,6 +1388,8 @@ rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,
        pool_priv->nb_drivers = nb_drivers;
        pool_priv->user_data_sz = user_data_size;
 
+       rte_cryptodev_trace_sym_session_pool_create(name, nb_elts,
+               elt_size, cache_size, user_data_size, mp);
        return mp;
 }
 
@@ -1387,6 +1434,7 @@ rte_cryptodev_sym_session_create(struct rte_mempool *mp)
        memset(sess->sess_data, 0,
                        rte_cryptodev_sym_session_data_size(sess));
 
+       rte_cryptodev_trace_sym_session_create(mp, sess);
        return sess;
 }
 
@@ -1406,6 +1454,7 @@ rte_cryptodev_asym_session_create(struct rte_mempool *mp)
         */
        memset(sess, 0, (sizeof(void *) * nb_drivers) + sizeof(uint8_t));
 
+       rte_cryptodev_trace_asym_session_create(mp, sess);
        return sess;
 }
 
@@ -1416,6 +1465,11 @@ rte_cryptodev_sym_session_clear(uint8_t dev_id,
        struct rte_cryptodev *dev;
        uint8_t driver_id;
 
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return -EINVAL;
+       }
+
        dev = rte_cryptodev_pmd_get_dev(dev_id);
 
        if (dev == NULL || sess == NULL)
@@ -1431,6 +1485,7 @@ rte_cryptodev_sym_session_clear(uint8_t dev_id,
 
        dev->dev_ops->sym_session_clear(dev, sess);
 
+       rte_cryptodev_trace_sym_session_clear(dev_id, sess);
        return 0;
 }
 
@@ -1440,6 +1495,11 @@ rte_cryptodev_asym_session_clear(uint8_t dev_id,
 {
        struct rte_cryptodev *dev;
 
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return -EINVAL;
+       }
+
        dev = rte_cryptodev_pmd_get_dev(dev_id);
 
        if (dev == NULL || sess == NULL)
@@ -1449,6 +1509,7 @@ rte_cryptodev_asym_session_clear(uint8_t dev_id,
 
        dev->dev_ops->asym_session_clear(dev, sess);
 
+       rte_cryptodev_trace_sym_session_clear(dev_id, sess);
        return 0;
 }
 
@@ -1471,6 +1532,7 @@ rte_cryptodev_sym_session_free(struct rte_cryptodev_sym_session *sess)
        sess_mp = rte_mempool_from_obj(sess);
        rte_mempool_put(sess_mp, sess);
 
+       rte_cryptodev_trace_sym_session_free(sess);
        return 0;
 }
 
@@ -1495,6 +1557,7 @@ rte_cryptodev_asym_session_free(struct rte_cryptodev_asym_session *sess)
        sess_mp = rte_mempool_from_obj(sess);
        rte_mempool_put(sess_mp, sess);
 
+       rte_cryptodev_trace_asym_session_free(sess);
        return 0;
 }
 
@@ -1604,6 +1667,37 @@ rte_cryptodev_sym_session_get_user_data(
        return (void *)(sess->sess_data + sess->nb_drivers);
 }
 
+static inline void
+sym_crypto_fill_status(struct rte_crypto_sym_vec *vec, int32_t errnum)
+{
+       uint32_t i;
+       for (i = 0; i < vec->num; i++)
+               vec->status[i] = errnum;
+}
+
+uint32_t
+rte_cryptodev_sym_cpu_crypto_process(uint8_t dev_id,
+       struct rte_cryptodev_sym_session *sess, union rte_crypto_sym_ofs ofs,
+       struct rte_crypto_sym_vec *vec)
+{
+       struct rte_cryptodev *dev;
+
+       if (!rte_cryptodev_pmd_is_valid_dev(dev_id)) {
+               sym_crypto_fill_status(vec, EINVAL);
+               return 0;
+       }
+
+       dev = rte_cryptodev_pmd_get_dev(dev_id);
+
+       if (*dev->dev_ops->sym_cpu_process == NULL ||
+               !(dev->feature_flags & RTE_CRYPTODEV_FF_SYM_CPU_CRYPTO)) {
+               sym_crypto_fill_status(vec, ENOTSUP);
+               return 0;
+       }
+
+       return dev->dev_ops->sym_cpu_process(dev, sess, ofs, vec);
+}
+
 /** Initialise rte_crypto_op mempool element */
 static void
 rte_crypto_op_init(struct rte_mempool *mempool,
@@ -1742,8 +1836,14 @@ rte_cryptodev_driver_id_get(const char *name)
 const char *
 rte_cryptodev_name_get(uint8_t dev_id)
 {
-       struct rte_cryptodev *dev = rte_cryptodev_pmd_get_dev(dev_id);
+       struct rte_cryptodev *dev;
 
+       if (!rte_cryptodev_is_valid_device_data(dev_id)) {
+               CDEV_LOG_ERR("Invalid dev_id=%" PRIu8, dev_id);
+               return NULL;
+       }
+
+       dev = rte_cryptodev_pmd_get_dev(dev_id);
        if (dev == NULL)
                return NULL;