d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cryptodev: break dependency on virtual device bus

Browse Source 
Removes any dependency of librte_cryptodev on the virtual device
infrastructure code and removes the functions which were virtual
device specific.

Updates all virtual PMDs to remove dependencies on rte_cryptodev_vdev.h
and replaces those calls with the new bus independent functions.

Due to these changes, the cryptodev ABI version gets bumped.

Signed-off-by: Declan Doherty <declan.doherty@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
Tested-by: Tomasz Duszynski <tdu@semihalf.com>
This commit is contained in:
Declan Doherty 2017-10-25 13:00:35 +01:00 committed by Pablo de Lara
parent 9e6edea418
commit f2f020d210
19 changed files with 191 additions and 587 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
doc/guides/rel_notes/deprecation.rst
View File

@ -71,10 +71,5 @@ Deprecation Notices
- ``rte_cryptodev_create_vdev``
* cryptodev: the following function will be static in 17.11 and included
by all crypto drivers, therefore, will not be public:
- ``rte_cryptodev_vdev_pmd_init``
* librte_meter: The API will change to accommodate configuration profiles.
Most of the API functions will have an additional opaque parameter.

9
doc/guides/rel_notes/release_17_11.rst
View File

@ -296,6 +296,13 @@ API Changes
The function ``rte_cryptodev_allocate_driver()`` has been modified.
An extra parameter ``struct cryptodev_driver *crypto_drv`` has been added.
* **Removed virtual device bus specific functions from librte_cryptodev.**
The functions ``rte_cryptodev_vdev_parse_init_params()`` and
``rte_cryptodev_vdev_pmd_init()`` have been removed from librte_cryptodev
and have been replaced by non bus specific functions
``rte_cryptodev_pmd_parse_input_args()`` and ``rte_cryptodev_pmd_create()``.
* **Removed deprecated functions to manage log level or type.**
The functions ``rte_set_log_level()``, ``rte_get_log_level()``,
@ -362,7 +369,7 @@ The libraries prepended with a plus sign were incremented in this version.
+ librte_bitratestats.so.2
librte_cfgfile.so.2
librte_cmdline.so.2
librte_cryptodev.so.3
+ librte_cryptodev.so.4
librte_distributor.so.1
+ librte_eal.so.6
+ librte_ethdev.so.8

56
drivers/crypto/aesni_gcm/aesni_gcm_pmd.c
View File

@ -35,7 +35,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -486,22 +485,24 @@ static int aesni_gcm_remove(struct rte_vdev_device *vdev);
static int
aesni_gcm_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct aesni_gcm_private *internals;
enum aesni_gcm_vector_mode vector_mode;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
/* Check CPU for support for AES instruction set */
if (!rte_cpu_get_flag_enabled(RTE_CPUFLAG_AES)) {
GCM_LOG_ERR("AES instructions not supported by CPU");
return -EFAULT;
}
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
GCM_LOG_ERR("driver %s: create failed", init_params->name);
return -ENODEV;
}
/* Check CPU for supported vector instruction set */
if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX2))
vector_mode = RTE_AESNI_GCM_AVX2;
@ -510,14 +511,6 @@ aesni_gcm_create(const char *name,
else
vector_mode = RTE_AESNI_GCM_SSE;
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct aesni_gcm_private), init_params->socket_id,
vdev);
if (dev == NULL) {
GCM_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
}
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_aesni_gcm_pmd_ops;
@ -552,22 +545,17 @@ aesni_gcm_create(const char *name,
internals->max_nb_sessions = init_params->max_nb_sessions;
return 0;
init_error:
GCM_LOG_ERR("driver %s: create failed", init_params->name);
aesni_gcm_remove(vdev);
return -EFAULT;
}
static int
aesni_gcm_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct aesni_gcm_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -576,17 +564,7 @@ aesni_gcm_probe(struct rte_vdev_device *vdev)
if (name == NULL)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return aesni_gcm_create(name, vdev, &init_params);
}
@ -594,16 +572,18 @@ aesni_gcm_probe(struct rte_vdev_device *vdev)
static int
aesni_gcm_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
GCM_LOG_INFO("Closing AESNI crypto device %s on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver aesni_gcm_pmd_drv = {

71
drivers/crypto/aesni_mb/rte_aesni_mb_pmd.c
View File

@ -36,7 +36,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -715,15 +714,23 @@ static int cryptodev_aesni_mb_remove(struct rte_vdev_device *vdev);
static int
cryptodev_aesni_mb_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct aesni_mb_private *internals;
enum aesni_mb_vector_mode vector_mode;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
/* Check CPU for support for AES instruction set */
if (!rte_cpu_get_flag_enabled(RTE_CPUFLAG_AES)) {
MB_LOG_ERR("AES instructions not supported by CPU");
return -EFAULT;
}
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
MB_LOG_ERR("failed to create cryptodev vdev");
return -ENODEV;
}
/* Check CPU for supported vector instruction set */
if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX512F))
@ -735,14 +742,6 @@ cryptodev_aesni_mb_create(const char *name,
else
vector_mode = RTE_AESNI_MB_SSE;
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct aesni_mb_private), init_params->socket_id,
vdev);
if (dev == NULL) {
MB_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
}
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_aesni_mb_pmd_ops;
@ -779,41 +778,33 @@ cryptodev_aesni_mb_create(const char *name,
internals->max_nb_sessions = init_params->max_nb_sessions;
return 0;
init_error:
MB_LOG_ERR("driver %s: cryptodev_aesni_create failed",
init_params->name);
cryptodev_aesni_mb_remove(vdev);
return -EFAULT;
}
static int
cryptodev_aesni_mb_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct aesni_mb_private),
rte_socket_id(),
""
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
const char *name, *args;
int retval;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
args = rte_vdev_device_args(vdev);
retval = rte_cryptodev_pmd_parse_input_args(&init_params, args);
if (retval) {
MB_LOG_ERR("Failed to parse initialisation arguments[%s]\n",
args);
return -EINVAL;
}
return cryptodev_aesni_mb_create(name, vdev, &init_params);
}
@ -821,16 +812,18 @@ cryptodev_aesni_mb_probe(struct rte_vdev_device *vdev)
static int
cryptodev_aesni_mb_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Closing AESNI crypto device %s on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_aesni_mb_pmd_drv = {

41
drivers/crypto/armv8/rte_armv8_pmd.c
View File

@ -36,7 +36,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -759,7 +758,7 @@ armv8_crypto_pmd_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops,
static int
cryptodev_armv8_crypto_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct armv8_crypto_private *internals;
@ -786,14 +785,7 @@ cryptodev_armv8_crypto_create(const char *name,
return -EFAULT;
}
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct armv8_crypto_private),
init_params->socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
ARMV8_CRYPTO_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
@ -832,11 +824,12 @@ init_error:
static int
cryptodev_armv8_crypto_init(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct armv8_crypto_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -845,18 +838,7 @@ cryptodev_armv8_crypto_init(struct rte_vdev_device *vdev)
if (name == NULL)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0') {
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
}
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_armv8_crypto_create(name, vdev, &init_params);
}
@ -865,6 +847,7 @@ cryptodev_armv8_crypto_init(struct rte_vdev_device *vdev)
static int
cryptodev_armv8_crypto_uninit(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
@ -875,7 +858,11 @@ cryptodev_armv8_crypto_uninit(struct rte_vdev_device *vdev)
"Closing ARMv8 crypto device %s on numa socket %u\n",
name, rte_socket_id());
return 0;
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver armv8_crypto_pmd_drv = {

11
drivers/crypto/dpaa2_sec/dpaa2_sec_dpseci.c
View File

@ -2016,16 +2016,7 @@ cryptodev_dpaa2_sec_remove(struct rte_dpaa2_device *dpaa2_dev)
if (ret)
return ret;
/* free crypto device */
rte_cryptodev_pmd_release_device(cryptodev);
if (rte_eal_process_type() == RTE_PROC_PRIMARY)
rte_free(cryptodev->data->dev_private);
cryptodev->device = NULL;
cryptodev->data = NULL;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_dpaa2_driver rte_dpaa2_sec_driver = {

14
drivers/crypto/dpaa_sec/dpaa_sec.c
View File

@ -1529,19 +1529,7 @@ cryptodev_dpaa_sec_remove(struct rte_dpaa_device *dpaa_dev)
if (ret)
return ret;
/* free crypto device */
rte_cryptodev_pmd_release_device(cryptodev);
if (rte_eal_process_type() == RTE_PROC_PRIMARY)
rte_free(cryptodev->data->dev_private);
PMD_INIT_LOG(INFO, "Closing dpaa crypto device %s",
cryptodev->data->name);
cryptodev->device = NULL;
cryptodev->data = NULL;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_dpaa_driver rte_dpaa_sec_driver = {

49
drivers/crypto/kasumi/rte_kasumi_pmd.c
View File

@ -35,7 +35,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -553,15 +552,17 @@ static int cryptodev_kasumi_remove(struct rte_vdev_device *vdev);
static int
cryptodev_kasumi_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct kasumi_private *internals;
uint64_t cpu_flags = 0;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
KASUMI_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
}
/* Check CPU for supported vector instruction set */
if (rte_cpu_get_flag_enabled(RTE_CPUFLAG_AVX))
@ -569,14 +570,6 @@ cryptodev_kasumi_create(const char *name,
else
cpu_flags |= RTE_CRYPTODEV_FF_CPU_SSE;
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct kasumi_private), init_params->socket_id,
vdev);
if (dev == NULL) {
KASUMI_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
}
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_kasumi_pmd_ops;
@ -605,11 +598,12 @@ init_error:
static int
cryptodev_kasumi_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct kasumi_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -619,17 +613,7 @@ cryptodev_kasumi_probe(struct rte_vdev_device *vdev)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_kasumi_create(name, vdev, &init_params);
}
@ -637,17 +621,18 @@ cryptodev_kasumi_probe(struct rte_vdev_device *vdev)
static int
cryptodev_kasumi_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Closing KASUMI crypto device %s"
" on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_kasumi_pmd_drv = {

56
drivers/crypto/mrvl/rte_mrvl_pmd.c
View File

@ -36,7 +36,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -720,26 +719,14 @@ mrvl_crypto_pmd_dequeue_burst(void *queue_pair,
static int
cryptodev_mrvl_crypto_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct mrvl_crypto_private *internals;
struct sam_init_params sam_params;
int ret;
if (init_params->name[0] == '\0') {
ret = rte_cryptodev_pmd_create_dev_name(
init_params->name, name);
if (ret < 0) {
MRVL_CRYPTO_LOG_ERR("failed to create unique name");
return ret;
}
}
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct mrvl_crypto_private),
init_params->socket_id, vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
MRVL_CRYPTO_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
@ -796,41 +783,29 @@ init_error:
static int
cryptodev_mrvl_crypto_init(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = { };
const char *name;
const char *input_args;
struct rte_cryptodev_pmd_init_params init_params = { };
const char *name, *args;
int ret;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
if (!input_args)
return -EINVAL;
args = rte_vdev_device_args(vdev);
init_params.private_data_size = sizeof(struct mrvl_crypto_private);
init_params.max_nb_queue_pairs = sam_get_num_inst() * SAM_HW_RING_NUM;
init_params.max_nb_sessions =
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS;
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS;
init_params.socket_id = rte_socket_id();
ret = rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
ret = rte_cryptodev_pmd_parse_input_args(&init_params, args);
if (ret) {
RTE_LOG(ERR, PMD, "Failed to parse input arguments\n");
return ret;
RTE_LOG(ERR, PMD,
"Failed to parse initialisation arguments[%s]\n",
args);
return -EINVAL;
}
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0') {
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
}
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
return cryptodev_mrvl_crypto_create(name, vdev, &init_params);
}
@ -843,6 +818,7 @@ cryptodev_mrvl_crypto_init(struct rte_vdev_device *vdev)
static int
cryptodev_mrvl_crypto_uninit(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name = rte_vdev_device_name(vdev);
if (name == NULL)
@ -854,7 +830,11 @@ cryptodev_mrvl_crypto_uninit(struct rte_vdev_device *vdev)
sam_deinit();
return 0;
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return rte_cryptodev_pmd_destroy(cryptodev);
}
/**

72
drivers/crypto/null/null_crypto_pmd.c
View File

@ -33,7 +33,6 @@
#include <rte_common.h>
#include <rte_config.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
@ -183,28 +182,19 @@ null_crypto_pmd_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops,
return nb_dequeued;
}
static int cryptodev_null_remove(const char *name);
/** Create crypto device */
static int
cryptodev_null_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct null_crypto_private *internals;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct null_crypto_private),
init_params->socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
NULL_CRYPTO_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
return -EFAULT;
}
dev->driver_id = cryptodev_driver_id;
@ -224,61 +214,53 @@ cryptodev_null_create(const char *name,
internals->max_nb_sessions = init_params->max_nb_sessions;
return 0;
init_error:
NULL_CRYPTO_LOG_ERR("driver %s: cryptodev_null_create failed",
init_params->name);
cryptodev_null_remove(init_params->name);
return -EFAULT;
}
/** Initialise null crypto device */
static int
cryptodev_null_probe(struct rte_vdev_device *dev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct null_crypto_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *name, *args;
int retval;
name = rte_vdev_device_name(dev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n",
name, init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
args = rte_vdev_device_args(dev);
retval = rte_cryptodev_pmd_parse_input_args(&init_params, args);
if (retval) {
RTE_LOG(ERR, PMD,
"Failed to parse initialisation arguments[%s]\n", args);
return -EINVAL;
}
return cryptodev_null_create(name, dev, &init_params);
}
/** Uninitialise null crypto device */
static int
cryptodev_null_remove(const char *name)
cryptodev_null_remove_dev(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Closing null crypto device %s on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
}
static int
cryptodev_null_remove_dev(struct rte_vdev_device *dev)
{
return cryptodev_null_remove(rte_vdev_device_name(dev));
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_null_pmd_drv = {

42
drivers/crypto/openssl/rte_openssl_pmd.c
View File

@ -34,7 +34,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -1668,19 +1667,12 @@ openssl_pmd_dequeue_burst(void *queue_pair, struct rte_crypto_op **ops,
static int
cryptodev_openssl_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct openssl_private *internals;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct openssl_private),
init_params->socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
OPENSSL_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
@ -1718,11 +1710,12 @@ init_error:
static int
cryptodev_openssl_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct openssl_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -1732,17 +1725,7 @@ cryptodev_openssl_probe(struct rte_vdev_device *vdev)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_openssl_create(name, vdev, &init_params);
}
@ -1751,17 +1734,18 @@ cryptodev_openssl_probe(struct rte_vdev_device *vdev)
static int
cryptodev_openssl_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD,
"Closing OPENSSL crypto device %s on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_openssl_pmd_drv = {

45
drivers/crypto/scheduler/scheduler_pmd.c
View File

@ -33,7 +33,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -45,7 +44,7 @@
uint8_t cryptodev_driver_id;
struct scheduler_init_params {
struct rte_crypto_vdev_init_params def_p;
struct rte_cryptodev_pmd_init_params def_p;
uint32_t nb_slaves;
enum rte_cryptodev_scheduler_mode mode;
uint32_t enable_ordering;
@ -107,21 +106,18 @@ cryptodev_scheduler_create(const char *name,
uint32_t i;
int ret;
if (init_params->def_p.name[0] == '\0')
snprintf(init_params->def_p.name,
sizeof(init_params->def_p.name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->def_p.name,
sizeof(struct scheduler_ctx),
init_params->def_p.socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device,
&init_params->def_p);
if (dev == NULL) {
CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
name);
return -EFAULT;
}
if (init_params->wcmask != 0)
RTE_LOG(INFO, PMD, " workers core mask = %"PRIx64"\n",
init_params->wcmask);
dev->driver_id = cryptodev_driver_id;
dev->dev_ops = rte_crypto_scheduler_pmd_ops;
@ -240,10 +236,7 @@ cryptodev_scheduler_remove(struct rte_vdev_device *vdev)
sched_ctx->slaves[i].dev_id);
}
RTE_LOG(INFO, PMD, "Closing Crypto Scheduler device %s on numa "
"socket %u\n", name, rte_socket_id());
return 0;
return rte_cryptodev_pmd_destroy(dev);
}
/** Parse integer from integer argument */
@ -304,7 +297,7 @@ static int
parse_name_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
struct rte_crypto_vdev_init_params *params = extra_args;
struct rte_cryptodev_pmd_init_params *params = extra_args;
if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
CS_LOG_ERR("Invalid name %s, should be less than "
@ -462,10 +455,11 @@ cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
{
struct scheduler_init_params init_params = {
.def_p = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
"",
sizeof(struct scheduler_ctx),
rte_socket_id(),
""
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
},
.nb_slaves = 0,
.mode = CDEV_SCHED_MODE_NOT_SET,
@ -481,19 +475,6 @@ cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
scheduler_parse_init_params(&init_params,
rte_vdev_device_args(vdev));
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n",
name,
init_params.def_p.socket_id);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.def_p.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.def_p.max_nb_sessions);
if (init_params.def_p.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.def_p.name);
if (init_params.wcmask != 0)
RTE_LOG(INFO, PMD, " workers core mask = %"PRIx64"\n",
init_params.wcmask);
return cryptodev_scheduler_create(name,
vdev,

3
drivers/crypto/scheduler/scheduler_pmd_ops.c
View File

@ -37,7 +37,6 @@
#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"
@ -347,7 +346,7 @@ scheduler_pmd_info_get(struct rte_cryptodev *dev,
{
struct scheduler_ctx *sched_ctx = dev->data->dev_private;
uint32_t max_nb_sessions = sched_ctx->nb_slaves ?
UINT32_MAX : RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS;
UINT32_MAX : RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS;
uint32_t i;
if (!dev_info)

41
drivers/crypto/snow3g/rte_snow3g_pmd.c
View File

@ -35,7 +35,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -559,19 +558,13 @@ static int cryptodev_snow3g_remove(struct rte_vdev_device *vdev);
static int
cryptodev_snow3g_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct snow3g_private *internals;
uint64_t cpu_flags = RTE_CRYPTODEV_FF_CPU_SSE;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct snow3g_private), init_params->socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
SNOW3G_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
@ -605,11 +598,12 @@ init_error:
static int
cryptodev_snow3g_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct snow3g_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -619,17 +613,7 @@ cryptodev_snow3g_probe(struct rte_vdev_device *vdev)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_snow3g_create(name, vdev, &init_params);
}
@ -637,17 +621,18 @@ cryptodev_snow3g_probe(struct rte_vdev_device *vdev)
static int
cryptodev_snow3g_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Closing SNOW 3G crypto device %s"
" on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_snow3g_pmd_drv = {

41
drivers/crypto/zuc/rte_zuc_pmd.c
View File

@ -35,7 +35,6 @@
#include <rte_hexdump.h>
#include <rte_cryptodev.h>
#include <rte_cryptodev_pmd.h>
#include <rte_cryptodev_vdev.h>
#include <rte_vdev.h>
#include <rte_malloc.h>
#include <rte_cpuflags.h>
@ -463,19 +462,14 @@ static int cryptodev_zuc_remove(struct rte_vdev_device *vdev);
static int
cryptodev_zuc_create(const char *name,
struct rte_vdev_device *vdev,
struct rte_crypto_vdev_init_params *init_params)
struct rte_cryptodev_pmd_init_params *init_params)
{
struct rte_cryptodev *dev;
struct zuc_private *internals;
uint64_t cpu_flags = RTE_CRYPTODEV_FF_CPU_SSE;
if (init_params->name[0] == '\0')
snprintf(init_params->name, sizeof(init_params->name),
"%s", name);
dev = rte_cryptodev_vdev_pmd_init(init_params->name,
sizeof(struct zuc_private), init_params->socket_id,
vdev);
dev = rte_cryptodev_pmd_create(name, &vdev->device, init_params);
if (dev == NULL) {
ZUC_LOG_ERR("failed to create cryptodev vdev");
goto init_error;
@ -509,11 +503,12 @@ init_error:
static int
cryptodev_zuc_probe(struct rte_vdev_device *vdev)
{
struct rte_crypto_vdev_init_params init_params = {
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
struct rte_cryptodev_pmd_init_params init_params = {
"",
sizeof(struct zuc_private),
rte_socket_id(),
{0}
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
};
const char *name;
const char *input_args;
@ -523,17 +518,7 @@ cryptodev_zuc_probe(struct rte_vdev_device *vdev)
return -EINVAL;
input_args = rte_vdev_device_args(vdev);
rte_cryptodev_vdev_parse_init_params(&init_params, input_args);
RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
init_params.socket_id);
if (init_params.name[0] != '\0')
RTE_LOG(INFO, PMD, " User defined name = %s\n",
init_params.name);
RTE_LOG(INFO, PMD, " Max number of queue pairs = %d\n",
init_params.max_nb_queue_pairs);
RTE_LOG(INFO, PMD, " Max number of sessions = %d\n",
init_params.max_nb_sessions);
rte_cryptodev_pmd_parse_input_args(&init_params, input_args);
return cryptodev_zuc_create(name, vdev, &init_params);
}
@ -541,17 +526,19 @@ cryptodev_zuc_probe(struct rte_vdev_device *vdev)
static int
cryptodev_zuc_remove(struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
const char *name;
name = rte_vdev_device_name(vdev);
if (name == NULL)
return -EINVAL;
RTE_LOG(INFO, PMD, "Closing ZUC crypto device %s"
" on numa socket %u\n",
name, rte_socket_id());
cryptodev = rte_cryptodev_pmd_get_named_dev(name);
if (cryptodev == NULL)
return -ENODEV;
return 0;
return rte_cryptodev_pmd_destroy(cryptodev);
}
static struct rte_vdev_driver cryptodev_zuc_pmd_drv = {

3
lib/librte_cryptodev/Makefile
View File

@ -34,7 +34,7 @@ include $(RTE_SDK)/mk/rte.vars.mk
LIB = librte_cryptodev.a
# library version
LIBABIVER := 3
LIBABIVER := 4
# build flags
CFLAGS += -O3
@ -50,7 +50,6 @@ SYMLINK-y-include += rte_crypto.h
SYMLINK-y-include += rte_crypto_sym.h
SYMLINK-y-include += rte_cryptodev.h
SYMLINK-y-include += rte_cryptodev_pmd.h
SYMLINK-y-include += rte_cryptodev_vdev.h
SYMLINK-y-include += rte_cryptodev_pci.h
# versioning export map

117
lib/librte_cryptodev/rte_cryptodev_pmd.c
View File

@ -32,7 +32,6 @@
#include <rte_malloc.h>
#include "rte_cryptodev_vdev.h"
#include "rte_cryptodev_pci.h"
#include "rte_cryptodev_pmd.h"
@ -202,122 +201,6 @@ rte_cryptodev_pmd_destroy(struct rte_cryptodev *cryptodev)
return 0;
}
/**
* Parse name from argument
*/
static int
rte_cryptodev_vdev_parse_name_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
struct rte_crypto_vdev_init_params *params = extra_args;
if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
CDEV_LOG_ERR("Invalid name %s, should be less than "
"%u bytes", value,
RTE_CRYPTODEV_NAME_MAX_LEN - 1);
return -1;
}
strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
return 0;
}
/**
* Parse integer from argument
*/
static int
rte_cryptodev_vdev_parse_integer_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
int *i = extra_args;
*i = atoi(value);
if (*i < 0) {
CDEV_LOG_ERR("Argument has to be positive.");
return -1;
}
return 0;
}
struct rte_cryptodev *
rte_cryptodev_vdev_pmd_init(const char *name, size_t dev_private_size,
int socket_id, struct rte_vdev_device *vdev)
{
struct rte_cryptodev *cryptodev;
/* allocate device structure */
cryptodev = rte_cryptodev_pmd_allocate(name, socket_id);
if (cryptodev == NULL)
return NULL;
/* allocate private device structure */
if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
cryptodev->data->dev_private =
rte_zmalloc_socket("cryptodev device private",
dev_private_size,
RTE_CACHE_LINE_SIZE,
socket_id);
if (cryptodev->data->dev_private == NULL)
rte_panic("Cannot allocate memzone for private device"
" data");
}
cryptodev->device = &vdev->device;
return cryptodev;
}
int
rte_cryptodev_vdev_parse_init_params(struct rte_crypto_vdev_init_params *params,
const char *input_args)
{
struct rte_kvargs *kvlist = NULL;
int ret = 0;
if (params == NULL)
return -EINVAL;
if (input_args) {
kvlist = rte_kvargs_parse(input_args,
cryptodev_vdev_valid_params);
if (kvlist == NULL)
return -1;
ret = rte_kvargs_process(kvlist,
RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
&rte_cryptodev_vdev_parse_integer_arg,
&params->max_nb_queue_pairs);
if (ret < 0)
goto free_kvlist;
ret = rte_kvargs_process(kvlist,
RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
&rte_cryptodev_vdev_parse_integer_arg,
&params->max_nb_sessions);
if (ret < 0)
goto free_kvlist;
ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SOCKET_ID,
&rte_cryptodev_vdev_parse_integer_arg,
&params->socket_id);
if (ret < 0)
goto free_kvlist;
ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_NAME,
&rte_cryptodev_vdev_parse_name_arg,
params);
if (ret < 0)
goto free_kvlist;
}
free_kvlist:
rte_kvargs_free(kvlist);
return ret;
}
int
rte_cryptodev_pci_generic_probe(struct rte_pci_device *pci_dev,
size_t private_data_size,

100
lib/librte_cryptodev/rte_cryptodev_vdev.h
View File

@ -1,100 +0,0 @@
/*-
* BSD LICENSE
*
* Copyright(c) 2017 Intel Corporation. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _RTE_CRYPTODEV_VDEV_H_
#define _RTE_CRYPTODEV_VDEV_H_
#include <rte_vdev.h>
#include <inttypes.h>
#include "rte_cryptodev.h"
#define RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS 8
#define RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS 2048
#define RTE_CRYPTODEV_VDEV_NAME ("name")
#define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG ("max_nb_queue_pairs")
#define RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG ("max_nb_sessions")
#define RTE_CRYPTODEV_VDEV_SOCKET_ID ("socket_id")
static const char * const cryptodev_vdev_valid_params[] = {
RTE_CRYPTODEV_VDEV_NAME,
RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
RTE_CRYPTODEV_VDEV_SOCKET_ID
};
/**
* @internal
* Initialisation parameters for virtual crypto devices
*/
struct rte_crypto_vdev_init_params {
unsigned int max_nb_queue_pairs;
unsigned int max_nb_sessions;
uint8_t socket_id;
char name[RTE_CRYPTODEV_NAME_MAX_LEN];
};
/**
* @internal
* Creates a new virtual crypto device and returns the pointer
* to that device.
*
* @param name PMD type name
* @param dev_private_size Size of crypto PMDs private data
* @param socket_id Socket to allocate resources on.
* @param vdev Pointer to virtual device structure.
*
* @return
* - Cryptodev pointer if device is successfully created.
* - NULL if device cannot be created.
*/
struct rte_cryptodev *
rte_cryptodev_vdev_pmd_init(const char *name, size_t dev_private_size,
int socket_id, struct rte_vdev_device *vdev);
/**
* @internal
* Parse virtual device initialisation parameters input arguments
*
* @params params Initialisation parameters with defaults set.
* @params input_args Command line arguments
*
* @return
* 0 on successful parse
* <0 on failure to parse
*/
int
rte_cryptodev_vdev_parse_init_params(struct rte_crypto_vdev_init_params *params,
const char *input_args);
#endif /* _RTE_CRYPTODEV_VDEV_H_ */

2
lib/librte_cryptodev/rte_cryptodev_version.map
View File

@ -73,8 +73,6 @@ DPDK_17.08 {
rte_cryptodev_sym_capability_check_aead;
rte_cryptodev_sym_session_init;
rte_cryptodev_sym_session_clear;
rte_cryptodev_vdev_parse_init_params;
rte_cryptodev_vdev_pmd_init;
rte_crypto_aead_algorithm_strings;
rte_crypto_aead_operation_strings;