1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Intel Corporation
4 #include <rte_common.h>
5 #include <rte_hexdump.h>
6 #include <rte_cryptodev.h>
7 #include <rte_cryptodev_pmd.h>
8 #include <rte_bus_vdev.h>
9 #include <rte_malloc.h>
10 #include <rte_cpuflags.h>
11 #include <rte_reorder.h>
13 #include "rte_cryptodev_scheduler.h"
14 #include "scheduler_pmd_private.h"
16 uint8_t cryptodev_driver_id;
18 struct scheduler_init_params {
19 struct rte_cryptodev_pmd_init_params def_p;
21 enum rte_cryptodev_scheduler_mode mode;
22 uint32_t enable_ordering;
23 uint16_t wc_pool[RTE_MAX_LCORE];
25 char slave_names[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES]
26 [RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
29 #define RTE_CRYPTODEV_VDEV_NAME ("name")
30 #define RTE_CRYPTODEV_VDEV_SLAVE ("slave")
31 #define RTE_CRYPTODEV_VDEV_MODE ("mode")
32 #define RTE_CRYPTODEV_VDEV_ORDERING ("ordering")
33 #define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG ("max_nb_queue_pairs")
34 #define RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG ("max_nb_sessions")
35 #define RTE_CRYPTODEV_VDEV_SOCKET_ID ("socket_id")
36 #define RTE_CRYPTODEV_VDEV_COREMASK ("coremask")
37 #define RTE_CRYPTODEV_VDEV_CORELIST ("corelist")
39 const char *scheduler_valid_params[] = {
40 RTE_CRYPTODEV_VDEV_NAME,
41 RTE_CRYPTODEV_VDEV_SLAVE,
42 RTE_CRYPTODEV_VDEV_MODE,
43 RTE_CRYPTODEV_VDEV_ORDERING,
44 RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
45 RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
46 RTE_CRYPTODEV_VDEV_SOCKET_ID,
47 RTE_CRYPTODEV_VDEV_COREMASK,
48 RTE_CRYPTODEV_VDEV_CORELIST
51 struct scheduler_parse_map {
56 const struct scheduler_parse_map scheduler_mode_map[] = {
57 {RTE_STR(SCHEDULER_MODE_NAME_ROUND_ROBIN),
58 CDEV_SCHED_MODE_ROUNDROBIN},
59 {RTE_STR(SCHEDULER_MODE_NAME_PKT_SIZE_DISTR),
60 CDEV_SCHED_MODE_PKT_SIZE_DISTR},
61 {RTE_STR(SCHEDULER_MODE_NAME_FAIL_OVER),
62 CDEV_SCHED_MODE_FAILOVER},
63 {RTE_STR(SCHEDULER_MODE_NAME_MULTI_CORE),
64 CDEV_SCHED_MODE_MULTICORE}
67 const struct scheduler_parse_map scheduler_ordering_map[] = {
73 cryptodev_scheduler_create(const char *name,
74 struct rte_vdev_device *vdev,
75 struct scheduler_init_params *init_params)
77 struct rte_cryptodev *dev;
78 struct scheduler_ctx *sched_ctx;
82 dev = rte_cryptodev_pmd_create(name, &vdev->device,
85 CR_SCHED_LOG(ERR, "driver %s: failed to create cryptodev vdev",
90 dev->driver_id = cryptodev_driver_id;
91 dev->dev_ops = rte_crypto_scheduler_pmd_ops;
93 sched_ctx = dev->data->dev_private;
94 sched_ctx->max_nb_queue_pairs =
95 init_params->def_p.max_nb_queue_pairs;
97 if (init_params->mode == CDEV_SCHED_MODE_MULTICORE) {
100 sched_ctx->nb_wc = init_params->nb_wc;
102 for (i = 0; i < sched_ctx->nb_wc; i++) {
103 sched_ctx->wc_pool[i] = init_params->wc_pool[i];
104 CR_SCHED_LOG(INFO, " Worker core[%u]=%u added",
105 i, sched_ctx->wc_pool[i]);
109 if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
110 init_params->mode < CDEV_SCHED_MODE_COUNT) {
111 ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
114 rte_cryptodev_pmd_release_device(dev);
118 for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
119 if (scheduler_mode_map[i].val != sched_ctx->mode)
122 CR_SCHED_LOG(INFO, " Scheduling mode = %s",
123 scheduler_mode_map[i].name);
128 sched_ctx->reordering_enabled = init_params->enable_ordering;
130 for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
131 if (scheduler_ordering_map[i].val !=
132 sched_ctx->reordering_enabled)
135 CR_SCHED_LOG(INFO, " Packet ordering = %s",
136 scheduler_ordering_map[i].name);
141 for (i = 0; i < init_params->nb_slaves; i++) {
142 sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
145 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
148 if (!sched_ctx->init_slave_names[
149 sched_ctx->nb_init_slaves]) {
150 CR_SCHED_LOG(ERR, "driver %s: Insufficient memory",
155 strncpy(sched_ctx->init_slave_names[
156 sched_ctx->nb_init_slaves],
157 init_params->slave_names[i],
158 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
160 sched_ctx->nb_init_slaves++;
164 * Initialize capabilities structure as an empty structure,
165 * in case device information is requested when no slaves are attached
167 sched_ctx->capabilities = rte_zmalloc_socket(NULL,
168 sizeof(struct rte_cryptodev_capabilities),
171 if (!sched_ctx->capabilities) {
172 CR_SCHED_LOG(ERR, "Not enough memory for capability "
181 cryptodev_scheduler_remove(struct rte_vdev_device *vdev)
184 struct rte_cryptodev *dev;
185 struct scheduler_ctx *sched_ctx;
190 name = rte_vdev_device_name(vdev);
191 dev = rte_cryptodev_pmd_get_named_dev(name);
195 sched_ctx = dev->data->dev_private;
197 if (sched_ctx->nb_slaves) {
200 for (i = 0; i < sched_ctx->nb_slaves; i++)
201 rte_cryptodev_scheduler_slave_detach(dev->data->dev_id,
202 sched_ctx->slaves[i].dev_id);
205 return rte_cryptodev_pmd_destroy(dev);
208 /** Parse integer from integer argument */
210 parse_integer_arg(const char *key __rte_unused,
211 const char *value, void *extra_args)
213 int *i = (int *) extra_args;
217 CR_SCHED_LOG(ERR, "Argument has to be positive.");
224 /** Parse integer from hexadecimal integer argument */
226 parse_coremask_arg(const char *key __rte_unused,
227 const char *value, void *extra_args)
232 struct scheduler_init_params *params = extra_args;
238 /* Remove all blank characters ahead and after .
239 * Remove 0x/0X if exists.
241 while (isblank(*value))
243 if (value[0] == '0' && ((value[1] == 'x') || (value[1] == 'X')))
246 while ((i > 0) && isblank(value[i - 1]))
252 for (i = i - 1; i >= 0 && idx < RTE_MAX_LCORE; i--) {
254 if (isxdigit(c) == 0) {
255 /* invalid characters */
265 for (j = 0; j < 4 && idx < RTE_MAX_LCORE; j++, idx++) {
267 params->wc_pool[params->nb_wc++] = idx;
274 /** Parse integer from list of integers argument */
276 parse_corelist_arg(const char *key __rte_unused,
277 const char *value, void *extra_args)
279 struct scheduler_init_params *params = extra_args;
283 const char *token = value;
285 while (isdigit(token[0])) {
287 unsigned int core = strtoul(token, &rval, 10);
289 if (core >= RTE_MAX_LCORE) {
290 CR_SCHED_LOG(ERR, "Invalid worker core %u, should be smaller "
291 "than %u.", core, RTE_MAX_LCORE);
293 params->wc_pool[params->nb_wc++] = (uint16_t)core;
294 token = (const char *)rval;
295 if (token[0] == '\0')
305 parse_name_arg(const char *key __rte_unused,
306 const char *value, void *extra_args)
308 struct rte_cryptodev_pmd_init_params *params = extra_args;
310 if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
311 CR_SCHED_LOG(ERR, "Invalid name %s, should be less than "
313 RTE_CRYPTODEV_NAME_MAX_LEN - 1);
317 strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
324 parse_slave_arg(const char *key __rte_unused,
325 const char *value, void *extra_args)
327 struct scheduler_init_params *param = extra_args;
329 if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES) {
330 CR_SCHED_LOG(ERR, "Too many slaves.");
334 strncpy(param->slave_names[param->nb_slaves++], value,
335 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
341 parse_mode_arg(const char *key __rte_unused,
342 const char *value, void *extra_args)
344 struct scheduler_init_params *param = extra_args;
347 for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
348 if (strcmp(value, scheduler_mode_map[i].name) == 0) {
349 param->mode = (enum rte_cryptodev_scheduler_mode)
350 scheduler_mode_map[i].val;
355 if (i == RTE_DIM(scheduler_mode_map)) {
356 CR_SCHED_LOG(ERR, "Unrecognized input.");
364 parse_ordering_arg(const char *key __rte_unused,
365 const char *value, void *extra_args)
367 struct scheduler_init_params *param = extra_args;
370 for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
371 if (strcmp(value, scheduler_ordering_map[i].name) == 0) {
372 param->enable_ordering =
373 scheduler_ordering_map[i].val;
378 if (i == RTE_DIM(scheduler_ordering_map)) {
379 CR_SCHED_LOG(ERR, "Unrecognized input.");
387 scheduler_parse_init_params(struct scheduler_init_params *params,
388 const char *input_args)
390 struct rte_kvargs *kvlist = NULL;
397 kvlist = rte_kvargs_parse(input_args,
398 scheduler_valid_params);
402 ret = rte_kvargs_process(kvlist,
403 RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
405 ¶ms->def_p.max_nb_queue_pairs);
409 ret = rte_kvargs_process(kvlist,
410 RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
412 ¶ms->def_p.max_nb_sessions);
416 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SOCKET_ID,
418 ¶ms->def_p.socket_id);
422 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_COREMASK,
428 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_CORELIST,
434 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_NAME,
440 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SLAVE,
441 &parse_slave_arg, params);
445 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_MODE,
446 &parse_mode_arg, params);
450 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_ORDERING,
451 &parse_ordering_arg, params);
457 rte_kvargs_free(kvlist);
462 cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
464 struct scheduler_init_params init_params = {
467 sizeof(struct scheduler_ctx),
469 RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
470 RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_SESSIONS
473 .mode = CDEV_SCHED_MODE_NOT_SET,
474 .enable_ordering = 0,
475 .slave_names = { {0} }
479 name = rte_vdev_device_name(vdev);
483 scheduler_parse_init_params(&init_params,
484 rte_vdev_device_args(vdev));
487 return cryptodev_scheduler_create(name,
492 static struct rte_vdev_driver cryptodev_scheduler_pmd_drv = {
493 .probe = cryptodev_scheduler_probe,
494 .remove = cryptodev_scheduler_remove
497 static struct cryptodev_driver scheduler_crypto_drv;
499 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_SCHEDULER_PMD,
500 cryptodev_scheduler_pmd_drv);
501 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_SCHEDULER_PMD,
502 "max_nb_queue_pairs=<int> "
503 "max_nb_sessions=<int> "
506 RTE_PMD_REGISTER_CRYPTO_DRIVER(scheduler_crypto_drv,
507 cryptodev_scheduler_pmd_drv.driver,
508 cryptodev_driver_id);