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

crypto/scheduler: improve parameters parsing

Browse Source 
This patch improves the cryptodev scheduler PMD's commandline
parsing capability. Originally, the scheduler's slave option
requires the slave vdev(s) being declared prior to it. This
patch removes this limitation by storing the slave names
temporarily and attaching them later.

Signed-off-by: Fan Zhang <roy.fan.zhang@intel.com>
Acked-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
This commit is contained in:
Fan Zhang 2017-04-18 12:28:14 +01:00 committed by Pablo de Lara
parent 217179d1bc
commit 50e14527b9
3 changed files with 101 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -44,9 +44,10 @@
struct scheduler_init_params {
struct rte_crypto_vdev_init_params def_p;
uint32_t nb_slaves;
uint8_t slaves[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES];
enum rte_cryptodev_scheduler_mode mode;
uint32_t enable_ordering;
char slave_names[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES]
[RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
};
#define RTE_CRYPTODEV_VDEV_NAME ("name")
@ -86,30 +87,6 @@ const struct scheduler_parse_map scheduler_ordering_map[] = {
{"disable", 0}
};
static int
attach_init_slaves(uint8_t scheduler_id,
const uint8_t *slaves, const uint8_t nb_slaves)
{
uint8_t i;
for (i = 0; i < nb_slaves; i++) {
struct rte_cryptodev *dev =
rte_cryptodev_pmd_get_dev(slaves[i]);
int status = rte_cryptodev_scheduler_slave_attach(
scheduler_id, slaves[i]);
if (status < 0 || !dev) {
CS_LOG_ERR("Failed to attach slave cryptodev "
"%u.\n", slaves[i]);
return status;
}
RTE_LOG(INFO, PMD, " Attached Slave %s\n", dev->data->name);
}
return 0;
}
static int
cryptodev_scheduler_create(const char *name,
struct scheduler_init_params *init_params)
@ -150,13 +127,6 @@ cryptodev_scheduler_create(const char *name,
sched_ctx->max_nb_queue_pairs =
init_params->def_p.max_nb_queue_pairs;
ret = attach_init_slaves(dev->data->dev_id, init_params->slaves,
init_params->nb_slaves);
if (ret < 0) {
rte_cryptodev_pmd_release_device(dev);
return ret;
}
if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
init_params->mode < CDEV_SCHED_MODE_COUNT) {
ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
@ -189,6 +159,28 @@ cryptodev_scheduler_create(const char *name,
break;
}
for (i = 0; i < init_params->nb_slaves; i++) {
sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
rte_zmalloc_socket(
NULL,
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
SOCKET_ID_ANY);
if (!sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves]) {
CS_LOG_ERR("driver %s: Insufficient memory",
name);
return -ENOMEM;
}
strncpy(sched_ctx->init_slave_names[
sched_ctx->nb_init_slaves],
init_params->slave_names[i],
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
sched_ctx->nb_init_slaves++;
}
return 0;
}
@ -280,21 +272,14 @@ parse_slave_arg(const char *key __rte_unused,
const char *value, void *extra_args)
{
struct scheduler_init_params *param = extra_args;
struct rte_cryptodev *dev =
rte_cryptodev_pmd_get_named_dev(value);
if (!dev) {
RTE_LOG(ERR, PMD, "Invalid slave name %s.\n", value);
return -EINVAL;
}
if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES - 1) {
CS_LOG_ERR("Too many slaves.\n");
return -ENOMEM;
}
param->slaves[param->nb_slaves] = dev->data->dev_id;
param->nb_slaves++;
strncpy(param->slave_names[param->nb_slaves++], value,
RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
return 0;
}
@ -425,9 +410,9 @@ cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
""
},
.nb_slaves = 0,
.slaves = {0},
.mode = CDEV_SCHED_MODE_NOT_SET,
.enable_ordering = 0
.enable_ordering = 0,
.slave_names = { {0} }
};
scheduler_parse_init_params(&init_params,

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

@ -41,6 +41,46 @@
#include "scheduler_pmd_private.h"
/** attaching the slaves predefined by scheduler's EAL options */
static int
scheduler_attach_init_slave(struct rte_cryptodev *dev)
{
struct scheduler_ctx *sched_ctx = dev->data->dev_private;
uint8_t scheduler_id = dev->data->dev_id;
int i;
for (i = sched_ctx->nb_init_slaves - 1; i >= 0; i--) {
const char *dev_name = sched_ctx->init_slave_names[i];
struct rte_cryptodev *slave_dev =
rte_cryptodev_pmd_get_named_dev(dev_name);
int status;
if (!slave_dev) {
CS_LOG_ERR("Failed to locate slave dev %s",
dev_name);
return -EINVAL;
}
status = rte_cryptodev_scheduler_slave_attach(
scheduler_id, slave_dev->data->dev_id);
if (status < 0) {
CS_LOG_ERR("Failed to attach slave cryptodev %u",
slave_dev->data->dev_id);
return status;
}
CS_LOG_INFO("Scheduler %s attached slave %s\n",
dev->data->name,
sched_ctx->init_slave_names[i]);
rte_free(sched_ctx->init_slave_names[i]);
sched_ctx->nb_init_slaves -= 1;
}
return 0;
}
/** Configure device */
static int
scheduler_pmd_config(struct rte_cryptodev *dev,
@ -48,7 +88,14 @@ scheduler_pmd_config(struct rte_cryptodev *dev,
{
struct scheduler_ctx *sched_ctx = dev->data->dev_private;
uint32_t i;
int ret = 0;
int ret;
/* although scheduler_attach_init_slave presents multiple times,
* there will be only 1 meaningful execution.
*/
ret = scheduler_attach_init_slave(dev);
if (ret < 0)
return ret;
for (i = 0; i < sched_ctx->nb_slaves; i++) {
uint8_t slave_dev_id = sched_ctx->slaves[i].dev_id;
@ -116,6 +163,13 @@ scheduler_pmd_start(struct rte_cryptodev *dev)
if (dev->data->dev_started)
return 0;
/* although scheduler_attach_init_slave presents multiple times,
* there will be only 1 meaningful execution.
*/
ret = scheduler_attach_init_slave(dev);
if (ret < 0)
return ret;
for (i = 0; i < dev->data->nb_queue_pairs; i++) {
ret = update_order_ring(dev, i);
if (ret < 0) {
@ -298,6 +352,11 @@ scheduler_pmd_info_get(struct rte_cryptodev *dev,
if (!dev_info)
return;
/* although scheduler_attach_init_slave presents multiple times,
* there will be only 1 meaningful execution.
*/
scheduler_attach_init_slave(dev);
for (i = 0; i < sched_ctx->nb_slaves; i++) {
uint8_t slave_dev_id = sched_ctx->slaves[i].dev_id;
struct rte_cryptodev_info slave_info;
@ -378,6 +437,16 @@ scheduler_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
dev->data->queue_pairs[qp_id] = qp_ctx;
/* although scheduler_attach_init_slave presents multiple times,
* there will be only 1 meaningful execution.
*/
ret = scheduler_attach_init_slave(dev);
if (ret < 0) {
CS_LOG_ERR("Failed to attach slave");
scheduler_pmd_qp_release(dev, qp_id);
return ret;
}
if (*sched_ctx->ops.config_queue_pair) {
if ((*sched_ctx->ops.config_queue_pair)(dev, qp_id) < 0) {
CS_LOG_ERR("Unable to configure queue pair");

3
drivers/crypto/scheduler/scheduler_pmd_private.h
View File

@ -86,6 +86,9 @@ struct scheduler_ctx {
char name[RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
char description[RTE_CRYPTODEV_SCHEDULER_DESC_MAX_LEN];
char *init_slave_names[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES];
int nb_init_slaves;
} __rte_cache_aligned;
struct scheduler_qp_ctx {