crypto/scheduler: fix build with gcc 8.2

[dpdk.git] / drivers / crypto / scheduler / scheduler_pmd.c

diff --git a/drivers/crypto/scheduler/scheduler_pmd.c b/drivers/crypto/scheduler/scheduler_pmd.c
index 6c5c01d..a1632a2 100644 (file)
--- a/drivers/crypto/scheduler/scheduler_pmd.c
+++ b/drivers/crypto/scheduler/scheduler_pmd.c
@@ -9,16 +9,18 @@
 #include <rte_malloc.h>
 #include <rte_cpuflags.h>
 #include <rte_reorder.h>
+#include <rte_string_fns.h>
 
 #include "rte_cryptodev_scheduler.h"
 #include "scheduler_pmd_private.h"
 
-uint8_t cryptodev_driver_id;
+uint8_t cryptodev_scheduler_driver_id;
 
 struct scheduler_init_params {
        struct rte_cryptodev_pmd_init_params def_p;
        uint32_t nb_slaves;
        enum rte_cryptodev_scheduler_mode mode;
+       char mode_param_str[RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
        uint32_t enable_ordering;
        uint16_t wc_pool[RTE_MAX_LCORE];
        uint16_t nb_wc;
@@ -29,16 +31,18 @@ struct scheduler_init_params {
 #define RTE_CRYPTODEV_VDEV_NAME                        ("name")
 #define RTE_CRYPTODEV_VDEV_SLAVE               ("slave")
 #define RTE_CRYPTODEV_VDEV_MODE                        ("mode")
+#define RTE_CRYPTODEV_VDEV_MODE_PARAM          ("mode_param")
 #define RTE_CRYPTODEV_VDEV_ORDERING            ("ordering")
 #define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG       ("max_nb_queue_pairs")
 #define RTE_CRYPTODEV_VDEV_SOCKET_ID           ("socket_id")
 #define RTE_CRYPTODEV_VDEV_COREMASK            ("coremask")
 #define RTE_CRYPTODEV_VDEV_CORELIST            ("corelist")
 
-const char *scheduler_valid_params[] = {
+static const char * const scheduler_valid_params[] = {
        RTE_CRYPTODEV_VDEV_NAME,
        RTE_CRYPTODEV_VDEV_SLAVE,
        RTE_CRYPTODEV_VDEV_MODE,
+       RTE_CRYPTODEV_VDEV_MODE_PARAM,
        RTE_CRYPTODEV_VDEV_ORDERING,
        RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
        RTE_CRYPTODEV_VDEV_SOCKET_ID,
@@ -67,6 +71,8 @@ const struct scheduler_parse_map scheduler_ordering_map[] = {
                {"disable", 0}
 };
 
+#define CDEV_SCHED_MODE_PARAM_SEP_CHAR         ':'
+
 static int
 cryptodev_scheduler_create(const char *name,
                struct rte_vdev_device *vdev,
@@ -85,7 +91,7 @@ cryptodev_scheduler_create(const char *name,
                return -EFAULT;
        }
 
-       dev->driver_id = cryptodev_driver_id;
+       dev->driver_id = cryptodev_scheduler_driver_id;
        dev->dev_ops = rte_crypto_scheduler_pmd_ops;
 
        sched_ctx = dev->data->dev_private;
@@ -106,6 +112,15 @@ cryptodev_scheduler_create(const char *name,
 
        if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
                        init_params->mode < CDEV_SCHED_MODE_COUNT) {
+               union {
+                       struct rte_cryptodev_scheduler_threshold_option
+                                       threshold_option;
+               } option;
+               enum rte_cryptodev_schedule_option_type option_type;
+               char param_name[RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN] = {0};
+               char param_val[RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN] = {0};
+               char *s, *end;
+
                ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
                        init_params->mode);
                if (ret < 0) {
@@ -121,6 +136,48 @@ cryptodev_scheduler_create(const char *name,
                                        scheduler_mode_map[i].name);
                        break;
                }
+
+               if (strlen(init_params->mode_param_str) > 0) {
+                       s = strchr(init_params->mode_param_str,
+                                       CDEV_SCHED_MODE_PARAM_SEP_CHAR);
+                       if (s == NULL) {
+                               CR_SCHED_LOG(ERR, "Invalid mode param");
+                               return -EINVAL;
+                       }
+
+                       strlcpy(param_name, init_params->mode_param_str,
+                                       s - init_params->mode_param_str + 1);
+                       s++;
+                       strlcpy(param_val, s,
+                                       RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN);
+
+                       switch (init_params->mode) {
+                       case CDEV_SCHED_MODE_PKT_SIZE_DISTR:
+                               if (strcmp(param_name,
+                                       RTE_CRYPTODEV_SCHEDULER_PARAM_THRES)
+                                               != 0) {
+                                       CR_SCHED_LOG(ERR, "Invalid mode param");
+                                       return -EINVAL;
+                               }
+                               option_type = CDEV_SCHED_OPTION_THRESHOLD;
+
+                               option.threshold_option.threshold =
+                                               strtoul(param_val, &end, 0);
+                               break;
+                       default:
+                               CR_SCHED_LOG(ERR, "Invalid mode param");
+                               return -EINVAL;
+                       }
+
+                       if (sched_ctx->ops.option_set(dev, option_type,
+                                       (void *)&option) < 0) {
+                               CR_SCHED_LOG(ERR, "Invalid mode param");
+                               return -EINVAL;
+                       }
+
+                       RTE_LOG(INFO, PMD, "  Sched mode param (%s = %s)\n",
+                                       param_name, param_val);
+               }
        }
 
        sched_ctx->reordering_enabled = init_params->enable_ordering;
@@ -312,7 +369,7 @@ parse_name_arg(const char *key __rte_unused,
                return -EINVAL;
        }
 
-       strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
+       strlcpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
 
        return 0;
 }
@@ -346,6 +403,7 @@ parse_mode_arg(const char *key __rte_unused,
                if (strcmp(value, scheduler_mode_map[i].name) == 0) {
                        param->mode = (enum rte_cryptodev_scheduler_mode)
                                        scheduler_mode_map[i].val;
+
                        break;
                }
        }
@@ -358,6 +416,18 @@ parse_mode_arg(const char *key __rte_unused,
        return 0;
 }
 
+static int
+parse_mode_param_arg(const char *key __rte_unused,
+               const char *value, void *extra_args)
+{
+       struct scheduler_init_params *param = extra_args;
+
+       strlcpy(param->mode_param_str, value,
+                       RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN);
+
+       return 0;
+}
+
 static int
 parse_ordering_arg(const char *key __rte_unused,
                const char *value, void *extra_args)
@@ -438,6 +508,11 @@ scheduler_parse_init_params(struct scheduler_init_params *params,
                if (ret < 0)
                        goto free_kvlist;
 
+               ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_MODE_PARAM,
+                               &parse_mode_param_arg, params);
+               if (ret < 0)
+                       goto free_kvlist;
+
                ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_ORDERING,
                                &parse_ordering_arg, params);
                if (ret < 0)
@@ -494,4 +569,4 @@ RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_SCHEDULER_PMD,
        "slave=<name>");
 RTE_PMD_REGISTER_CRYPTO_DRIVER(scheduler_crypto_drv,
                cryptodev_scheduler_pmd_drv.driver,
-               cryptodev_driver_id);
+               cryptodev_scheduler_driver_id);