remove experimental tags from all symbol definitions

[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 2a8e07d..be9f026 100644 (file)
--- a/lib/librte_cryptodev/rte_cryptodev.c
+++ b/lib/librte_cryptodev/rte_cryptodev.c
@@ -250,7 +250,7 @@ rte_cryptodev_get_aead_algo_enum(enum rte_crypto_aead_algorithm *algo_enum,
        return -1;
 }
 
-int __rte_experimental
+int
 rte_cryptodev_asym_get_xform_enum(enum rte_crypto_asym_xform_type *xform_enum,
                const char *xform_string)
 {
@@ -338,7 +338,7 @@ param_range_check(uint16_t size, const struct rte_crypto_param_range *range)
        return -1;
 }
 
-const struct rte_cryptodev_asymmetric_xform_capability * __rte_experimental
+const struct rte_cryptodev_asymmetric_xform_capability *
 rte_cryptodev_asym_capability_get(uint8_t dev_id,
                const struct rte_cryptodev_asym_capability_idx *idx)
 {
@@ -411,7 +411,7 @@ rte_cryptodev_sym_capability_check_aead(
 
        return 0;
 }
-int __rte_experimental
+int
 rte_cryptodev_asym_xform_capability_check_optype(
        const struct rte_cryptodev_asymmetric_xform_capability *capability,
        enum rte_crypto_asym_op_type op_type)
@@ -422,7 +422,7 @@ rte_cryptodev_asym_xform_capability_check_optype(
        return 0;
 }
 
-int __rte_experimental
+int
 rte_cryptodev_asym_xform_capability_check_modlen(
        const struct rte_cryptodev_asymmetric_xform_capability *capability,
        uint16_t modlen)
@@ -486,6 +486,10 @@ rte_cryptodev_get_feature_name(uint64_t flag)
                return "CPU_ARM_CE";
        case RTE_CRYPTODEV_FF_SECURITY:
                return "SECURITY_PROTOCOL";
+       case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_EXP:
+               return "RSA_PRIV_OP_KEY_EXP";
+       case RTE_CRYPTODEV_FF_RSA_PRIV_OP_KEY_QT:
+               return "RSA_PRIV_OP_KEY_QT";
        default:
                return NULL;
        }
@@ -586,7 +590,7 @@ rte_cryptodev_devices_get(const char *driver_name, uint8_t *devices,
 
                        cmp = strncmp(devs[i].device->driver->name,
                                        driver_name,
-                                       strlen(driver_name));
+                                       strlen(driver_name) + 1);
 
                        if (cmp == 0)
                                devices[count++] = devs[i].data->dev_id;
@@ -694,8 +698,8 @@ rte_cryptodev_pmd_allocate(const char *name, int socket_id)
 
                cryptodev->data = cryptodev_data;
 
-               snprintf(cryptodev->data->name, RTE_CRYPTODEV_NAME_MAX_LEN,
-                               "%s", name);
+               strlcpy(cryptodev->data->name, name,
+                       RTE_CRYPTODEV_NAME_MAX_LEN);
 
                cryptodev->data->dev_id = dev_id;
                cryptodev->data->socket_id = socket_id;
@@ -992,6 +996,7 @@ rte_cryptodev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id,
                }
 
                s.nb_drivers = pool_priv->nb_drivers;
+               s.user_data_sz = pool_priv->user_data_sz;
 
                if ((rte_cryptodev_sym_get_existing_header_session_size(&s) >
                        obj_size) || (s.nb_drivers <= dev->driver_id) ||
@@ -1215,7 +1220,7 @@ rte_cryptodev_sym_session_init(uint8_t dev_id,
 
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->sym_session_configure, -ENOTSUP);
 
-       if (sess->sess_data[index].data == NULL) {
+       if (sess->sess_data[index].refcnt == 0) {
                ret = dev->dev_ops->sym_session_configure(dev, xforms,
                                                        sess, mp);
                if (ret < 0) {
@@ -1226,10 +1231,11 @@ rte_cryptodev_sym_session_init(uint8_t dev_id,
                }
        }
 
+       sess->sess_data[index].refcnt++;
        return 0;
 }
 
-int __rte_experimental
+int
 rte_cryptodev_asym_session_init(uint8_t dev_id,
                struct rte_cryptodev_asym_session *sess,
                struct rte_crypto_asym_xform *xforms,
@@ -1264,7 +1270,7 @@ rte_cryptodev_asym_session_init(uint8_t dev_id,
        return 0;
 }
 
-struct rte_mempool * __rte_experimental
+struct rte_mempool *
 rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,
        uint32_t elt_size, uint32_t cache_size, uint16_t user_data_size,
        int socket_id)
@@ -1307,7 +1313,8 @@ rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,
 static unsigned int
 rte_cryptodev_sym_session_data_size(struct rte_cryptodev_sym_session *sess)
 {
-       return (sizeof(sess->sess_data[0]) * sess->nb_drivers);
+       return (sizeof(sess->sess_data[0]) * sess->nb_drivers) +
+                       sess->user_data_sz;
 }
 
 struct rte_cryptodev_sym_session *
@@ -1335,7 +1342,8 @@ rte_cryptodev_sym_session_create(struct rte_mempool *mp)
        }
 
        sess->nb_drivers = pool_priv->nb_drivers;
-
+       sess->user_data_sz = pool_priv->user_data_sz;
+       sess->opaque_data = 0;
 
        /* Clear device session pointer.
         * Include the flag indicating presence of user data
@@ -1346,7 +1354,7 @@ rte_cryptodev_sym_session_create(struct rte_mempool *mp)
        return sess;
 }
 
-struct rte_cryptodev_asym_session * __rte_experimental
+struct rte_cryptodev_asym_session *
 rte_cryptodev_asym_session_create(struct rte_mempool *mp)
 {
        struct rte_cryptodev_asym_session *sess;
@@ -1370,12 +1378,19 @@ rte_cryptodev_sym_session_clear(uint8_t dev_id,
                struct rte_cryptodev_sym_session *sess)
 {
        struct rte_cryptodev *dev;
+       uint8_t driver_id;
 
        dev = rte_cryptodev_pmd_get_dev(dev_id);
 
        if (dev == NULL || sess == NULL)
                return -EINVAL;
 
+       driver_id = dev->driver_id;
+       if (sess->sess_data[driver_id].refcnt == 0)
+               return 0;
+       if (--sess->sess_data[driver_id].refcnt != 0)
+               return -EBUSY;
+
        RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->sym_session_clear, -ENOTSUP);
 
        dev->dev_ops->sym_session_clear(dev, sess);
@@ -1383,7 +1398,7 @@ rte_cryptodev_sym_session_clear(uint8_t dev_id,
        return 0;
 }
 
-int __rte_experimental
+int
 rte_cryptodev_asym_session_clear(uint8_t dev_id,
                struct rte_cryptodev_asym_session *sess)
 {
@@ -1405,16 +1420,14 @@ int
 rte_cryptodev_sym_session_free(struct rte_cryptodev_sym_session *sess)
 {
        uint8_t i;
-       void *sess_priv;
        struct rte_mempool *sess_mp;
 
        if (sess == NULL)
                return -EINVAL;
 
        /* Check that all device private data has been freed */
-       for (i = 0; i < nb_drivers; i++) {
-               sess_priv = get_sym_session_private_data(sess, i);
-               if (sess_priv != NULL)
+       for (i = 0; i < sess->nb_drivers; i++) {
+               if (sess->sess_data[i].refcnt != 0)
                        return -EBUSY;
        }
 
@@ -1425,7 +1438,7 @@ rte_cryptodev_sym_session_free(struct rte_cryptodev_sym_session *sess)
        return 0;
 }
 
-int __rte_experimental
+int
 rte_cryptodev_asym_session_free(struct rte_cryptodev_asym_session *sess)
 {
        uint8_t i;
@@ -1465,7 +1478,7 @@ rte_cryptodev_sym_get_header_session_size(void)
                        rte_cryptodev_sym_session_data_size(&s));
 }
 
-unsigned int __rte_experimental
+unsigned int
 rte_cryptodev_sym_get_existing_header_session_size(
                struct rte_cryptodev_sym_session *sess)
 {
@@ -1476,7 +1489,7 @@ rte_cryptodev_sym_get_existing_header_session_size(
                                rte_cryptodev_sym_session_data_size(sess));
 }
 
-unsigned int __rte_experimental
+unsigned int
 rte_cryptodev_asym_get_header_session_size(void)
 {
        /*
@@ -1506,7 +1519,7 @@ rte_cryptodev_sym_get_private_session_size(uint8_t dev_id)
        return priv_sess_size;
 }
 
-unsigned int __rte_experimental
+unsigned int
 rte_cryptodev_asym_get_private_session_size(uint8_t dev_id)
 {
        struct rte_cryptodev *dev;
@@ -1529,7 +1542,7 @@ rte_cryptodev_asym_get_private_session_size(uint8_t dev_id)
 
 }
 
-int __rte_experimental
+int
 rte_cryptodev_sym_session_set_user_data(
                                        struct rte_cryptodev_sym_session *sess,
                                        void *data,
@@ -1538,15 +1551,18 @@ rte_cryptodev_sym_session_set_user_data(
        if (sess == NULL)
                return -EINVAL;
 
+       if (sess->user_data_sz < size)
+               return -ENOMEM;
+
        rte_memcpy(sess->sess_data + sess->nb_drivers, data, size);
        return 0;
 }
 
-void * __rte_experimental
+void *
 rte_cryptodev_sym_session_get_user_data(
                                        struct rte_cryptodev_sym_session *sess)
 {
-       if (sess == NULL)
+       if (sess == NULL || sess->user_data_sz == 0)
                return NULL;
 
        return (void *)(sess->sess_data + sess->nb_drivers);
@@ -1681,7 +1697,7 @@ rte_cryptodev_driver_id_get(const char *name)
 
        TAILQ_FOREACH(driver, &cryptodev_driver_list, next) {
                driver_name = driver->driver->name;
-               if (strncmp(driver_name, name, strlen(driver_name)) == 0)
+               if (strncmp(driver_name, name, strlen(driver_name) + 1) == 0)
                        return driver->id;
        }
        return -1;