drivers/crypto/scheduler/scheduler_pmd.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
   5  *
   6  *   Redistribution and use in source and binary forms, with or without
   7  *   modification, are permitted provided that the following conditions
   8  *   are met:
   9  *
  10  *     * Redistributions of source code must retain the above copyright
  11  *       notice, this list of conditions and the following disclaimer.
  12  *     * Redistributions in binary form must reproduce the above copyright
  13  *       notice, this list of conditions and the following disclaimer in
  14  *       the documentation and/or other materials provided with the
  15  *       distribution.
  16  *     * Neither the name of Intel Corporation nor the names of its
  17  *       contributors may be used to endorse or promote products derived
  18  *       from this software without specific prior written permission.
  19  *
  20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  */
  32 #include <rte_common.h>
  33 #include <rte_hexdump.h>
  34 #include <rte_cryptodev.h>
  35 #include <rte_cryptodev_pmd.h>
  36 #include <rte_cryptodev_vdev.h>
  37 #include <rte_vdev.h>
  38 #include <rte_malloc.h>
  39 #include <rte_cpuflags.h>
  40 #include <rte_reorder.h>
  41
  42 #include "rte_cryptodev_scheduler.h"
  43 #include "scheduler_pmd_private.h"
  44
  45 struct scheduler_init_params {
  46         struct rte_crypto_vdev_init_params def_p;
  47         uint32_t nb_slaves;
  48         enum rte_cryptodev_scheduler_mode mode;
  49         uint32_t enable_ordering;
  50         char slave_names[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES]
  51                         [RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
  52 };
  53
  54 #define RTE_CRYPTODEV_VDEV_NAME                 ("name")
  55 #define RTE_CRYPTODEV_VDEV_SLAVE                ("slave")
  56 #define RTE_CRYPTODEV_VDEV_MODE                 ("mode")
  57 #define RTE_CRYPTODEV_VDEV_ORDERING             ("ordering")
  58 #define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG        ("max_nb_queue_pairs")
  59 #define RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG      ("max_nb_sessions")
  60 #define RTE_CRYPTODEV_VDEV_SOCKET_ID            ("socket_id")
  61
  62 const char *scheduler_valid_params[] = {
  63         RTE_CRYPTODEV_VDEV_NAME,
  64         RTE_CRYPTODEV_VDEV_SLAVE,
  65         RTE_CRYPTODEV_VDEV_MODE,
  66         RTE_CRYPTODEV_VDEV_ORDERING,
  67         RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
  68         RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
  69         RTE_CRYPTODEV_VDEV_SOCKET_ID
  70 };
  71
  72 struct scheduler_parse_map {
  73         const char *name;
  74         uint32_t val;
  75 };
  76
  77 const struct scheduler_parse_map scheduler_mode_map[] = {
  78         {RTE_STR(SCHEDULER_MODE_NAME_ROUND_ROBIN),
  79                         CDEV_SCHED_MODE_ROUNDROBIN},
  80         {RTE_STR(SCHEDULER_MODE_NAME_PKT_SIZE_DISTR),
  81                         CDEV_SCHED_MODE_PKT_SIZE_DISTR},
  82         {RTE_STR(SCHEDULER_MODE_NAME_FAIL_OVER),
  83                         CDEV_SCHED_MODE_FAILOVER}
  84 };
  85
  86 const struct scheduler_parse_map scheduler_ordering_map[] = {
  87                 {"enable", 1},
  88                 {"disable", 0}
  89 };
  90
  91 static int
  92 cryptodev_scheduler_create(const char *name,
  93                 struct rte_vdev_device *vdev,
  94                 struct scheduler_init_params *init_params)
  95 {
  96         struct rte_cryptodev *dev;
  97         struct scheduler_ctx *sched_ctx;
  98         uint32_t i;
  99         int ret;
 100
 101         if (init_params->def_p.name[0] == '\0')
 102                 snprintf(init_params->def_p.name,
 103                                 sizeof(init_params->def_p.name),
 104                                 "%s", name);
 105
 106         dev = rte_cryptodev_vdev_pmd_init(init_params->def_p.name,
 107                         sizeof(struct scheduler_ctx),
 108                         init_params->def_p.socket_id,
 109                         vdev);
 110         if (dev == NULL) {
 111                 CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
 112                         name);
 113                 return -EFAULT;
 114         }
 115
 116         dev->dev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
 117         dev->dev_ops = rte_crypto_scheduler_pmd_ops;
 118
 119         sched_ctx = dev->data->dev_private;
 120         sched_ctx->max_nb_queue_pairs =
 121                         init_params->def_p.max_nb_queue_pairs;
 122
 123         if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
 124                         init_params->mode < CDEV_SCHED_MODE_COUNT) {
 125                 ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
 126                         init_params->mode);
 127                 if (ret < 0) {
 128                         rte_cryptodev_pmd_release_device(dev);
 129                         return ret;
 130                 }
 131
 132                 for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
 133                         if (scheduler_mode_map[i].val != sched_ctx->mode)
 134                                 continue;
 135
 136                         RTE_LOG(INFO, PMD, "  Scheduling mode = %s\n",
 137                                         scheduler_mode_map[i].name);
 138                         break;
 139                 }
 140         }
 141
 142         sched_ctx->reordering_enabled = init_params->enable_ordering;
 143
 144         for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
 145                 if (scheduler_ordering_map[i].val !=
 146                                 sched_ctx->reordering_enabled)
 147                         continue;
 148
 149                 RTE_LOG(INFO, PMD, "  Packet ordering = %s\n",
 150                                 scheduler_ordering_map[i].name);
 151
 152                 break;
 153         }
 154
 155         for (i = 0; i < init_params->nb_slaves; i++) {
 156                 sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
 157                         rte_zmalloc_socket(
 158                                 NULL,
 159                                 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
 160                                 SOCKET_ID_ANY);
 161
 162                 if (!sched_ctx->init_slave_names[
 163                                 sched_ctx->nb_init_slaves]) {
 164                         CS_LOG_ERR("driver %s: Insufficient memory",
 165                                         name);
 166                         return -ENOMEM;
 167                 }
 168
 169                 strncpy(sched_ctx->init_slave_names[
 170                                         sched_ctx->nb_init_slaves],
 171                                 init_params->slave_names[i],
 172                                 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
 173
 174                 sched_ctx->nb_init_slaves++;
 175         }
 176
 177         /*
 178          * Initialize capabilities structure as an empty structure,
 179          * in case device information is requested when no slaves are attached
 180          */
 181         sched_ctx->capabilities = rte_zmalloc_socket(NULL,
 182                         sizeof(struct rte_cryptodev_capabilities),
 183                         0, SOCKET_ID_ANY);
 184
 185         if (!sched_ctx->capabilities) {
 186                 RTE_LOG(ERR, PMD, "Not enough memory for capability "
 187                                 "information\n");
 188                 return -ENOMEM;
 189         }
 190
 191         return 0;
 192 }
 193
 194 static int
 195 cryptodev_scheduler_remove(struct rte_vdev_device *vdev)
 196 {
 197         const char *name;
 198         struct rte_cryptodev *dev;
 199         struct scheduler_ctx *sched_ctx;
 200
 201         if (vdev == NULL)
 202                 return -EINVAL;
 203
 204         name = rte_vdev_device_name(vdev);
 205         dev = rte_cryptodev_pmd_get_named_dev(name);
 206         if (dev == NULL)
 207                 return -EINVAL;
 208
 209         sched_ctx = dev->data->dev_private;
 210
 211         if (sched_ctx->nb_slaves) {
 212                 uint32_t i;
 213
 214                 for (i = 0; i < sched_ctx->nb_slaves; i++)
 215                         rte_cryptodev_scheduler_slave_detach(dev->data->dev_id,
 216                                         sched_ctx->slaves[i].dev_id);
 217         }
 218
 219         RTE_LOG(INFO, PMD, "Closing Crypto Scheduler device %s on numa "
 220                 "socket %u\n", name, rte_socket_id());
 221
 222         return 0;
 223 }
 224
 225 /** Parse integer from integer argument */
 226 static int
 227 parse_integer_arg(const char *key __rte_unused,
 228                 const char *value, void *extra_args)
 229 {
 230         int *i = (int *) extra_args;
 231
 232         *i = atoi(value);
 233         if (*i < 0) {
 234                 CS_LOG_ERR("Argument has to be positive.\n");
 235                 return -EINVAL;
 236         }
 237
 238         return 0;
 239 }
 240
 241 /** Parse name */
 242 static int
 243 parse_name_arg(const char *key __rte_unused,
 244                 const char *value, void *extra_args)
 245 {
 246         struct rte_crypto_vdev_init_params *params = extra_args;
 247
 248         if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
 249                 CS_LOG_ERR("Invalid name %s, should be less than "
 250                                 "%u bytes.\n", value,
 251                                 RTE_CRYPTODEV_NAME_MAX_LEN - 1);
 252                 return -EINVAL;
 253         }
 254
 255         strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
 256
 257         return 0;
 258 }
 259
 260 /** Parse slave */
 261 static int
 262 parse_slave_arg(const char *key __rte_unused,
 263                 const char *value, void *extra_args)
 264 {
 265         struct scheduler_init_params *param = extra_args;
 266
 267         if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES - 1) {
 268                 CS_LOG_ERR("Too many slaves.\n");
 269                 return -ENOMEM;
 270         }
 271
 272         strncpy(param->slave_names[param->nb_slaves++], value,
 273                         RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
 274
 275         return 0;
 276 }
 277
 278 static int
 279 parse_mode_arg(const char *key __rte_unused,
 280                 const char *value, void *extra_args)
 281 {
 282         struct scheduler_init_params *param = extra_args;
 283         uint32_t i;
 284
 285         for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
 286                 if (strcmp(value, scheduler_mode_map[i].name) == 0) {
 287                         param->mode = (enum rte_cryptodev_scheduler_mode)
 288                                         scheduler_mode_map[i].val;
 289                         break;
 290                 }
 291         }
 292
 293         if (i == RTE_DIM(scheduler_mode_map)) {
 294                 CS_LOG_ERR("Unrecognized input.\n");
 295                 return -EINVAL;
 296         }
 297
 298         return 0;
 299 }
 300
 301 static int
 302 parse_ordering_arg(const char *key __rte_unused,
 303                 const char *value, void *extra_args)
 304 {
 305         struct scheduler_init_params *param = extra_args;
 306         uint32_t i;
 307
 308         for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
 309                 if (strcmp(value, scheduler_ordering_map[i].name) == 0) {
 310                         param->enable_ordering =
 311                                         scheduler_ordering_map[i].val;
 312                         break;
 313                 }
 314         }
 315
 316         if (i == RTE_DIM(scheduler_ordering_map)) {
 317                 CS_LOG_ERR("Unrecognized input.\n");
 318                 return -EINVAL;
 319         }
 320
 321         return 0;
 322 }
 323
 324 static int
 325 scheduler_parse_init_params(struct scheduler_init_params *params,
 326                 const char *input_args)
 327 {
 328         struct rte_kvargs *kvlist = NULL;
 329         int ret = 0;
 330
 331         if (params == NULL)
 332                 return -EINVAL;
 333
 334         if (input_args) {
 335                 kvlist = rte_kvargs_parse(input_args,
 336                                 scheduler_valid_params);
 337                 if (kvlist == NULL)
 338                         return -1;
 339
 340                 ret = rte_kvargs_process(kvlist,
 341                                 RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
 342                                 &parse_integer_arg,
 343                                 &params->def_p.max_nb_queue_pairs);
 344                 if (ret < 0)
 345                         goto free_kvlist;
 346
 347                 ret = rte_kvargs_process(kvlist,
 348                                 RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
 349                                 &parse_integer_arg,
 350                                 &params->def_p.max_nb_sessions);
 351                 if (ret < 0)
 352                         goto free_kvlist;
 353
 354                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SOCKET_ID,
 355                                 &parse_integer_arg,
 356                                 &params->def_p.socket_id);
 357                 if (ret < 0)
 358                         goto free_kvlist;
 359
 360                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_NAME,
 361                                 &parse_name_arg,
 362                                 &params->def_p);
 363                 if (ret < 0)
 364                         goto free_kvlist;
 365
 366                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SLAVE,
 367                                 &parse_slave_arg, params);
 368                 if (ret < 0)
 369                         goto free_kvlist;
 370
 371                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_MODE,
 372                                 &parse_mode_arg, params);
 373                 if (ret < 0)
 374                         goto free_kvlist;
 375
 376                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_ORDERING,
 377                                 &parse_ordering_arg, params);
 378                 if (ret < 0)
 379                         goto free_kvlist;
 380         }
 381
 382 free_kvlist:
 383         rte_kvargs_free(kvlist);
 384         return ret;
 385 }
 386
 387 static int
 388 cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
 389 {
 390         struct scheduler_init_params init_params = {
 391                 .def_p = {
 392                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
 393                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
 394                         rte_socket_id(),
 395                         ""
 396                 },
 397                 .nb_slaves = 0,
 398                 .mode = CDEV_SCHED_MODE_NOT_SET,
 399                 .enable_ordering = 0,
 400                 .slave_names = { {0} }
 401         };
 402         const char *name;
 403
 404         name = rte_vdev_device_name(vdev);
 405         if (name == NULL)
 406                 return -EINVAL;
 407
 408         scheduler_parse_init_params(&init_params,
 409                                     rte_vdev_device_args(vdev));
 410
 411         RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n",
 412                         name,
 413                         init_params.def_p.socket_id);
 414         RTE_LOG(INFO, PMD, "  Max number of queue pairs = %d\n",
 415                         init_params.def_p.max_nb_queue_pairs);
 416         RTE_LOG(INFO, PMD, "  Max number of sessions = %d\n",
 417                         init_params.def_p.max_nb_sessions);
 418         if (init_params.def_p.name[0] != '\0')
 419                 RTE_LOG(INFO, PMD, "  User defined name = %s\n",
 420                         init_params.def_p.name);
 421
 422         return cryptodev_scheduler_create(name,
 423                                         vdev,
 424                                         &init_params);
 425 }
 426
 427 static struct rte_vdev_driver cryptodev_scheduler_pmd_drv = {
 428         .probe = cryptodev_scheduler_probe,
 429         .remove = cryptodev_scheduler_remove
 430 };
 431
 432 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_SCHEDULER_PMD,
 433         cryptodev_scheduler_pmd_drv);
 434 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_SCHEDULER_PMD,
 435         "max_nb_queue_pairs=<int> "
 436         "max_nb_sessions=<int> "
 437         "socket_id=<int> "
 438         "slave=<name>");