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_vdev.h>
  37 #include <rte_malloc.h>
  38 #include <rte_cpuflags.h>
  39 #include <rte_reorder.h>
  40
  41 #include "rte_cryptodev_scheduler.h"
  42 #include "scheduler_pmd_private.h"
  43
  44 struct scheduler_init_params {
  45         struct rte_crypto_vdev_init_params def_p;
  46         uint32_t nb_slaves;
  47         enum rte_cryptodev_scheduler_mode mode;
  48         uint32_t enable_ordering;
  49         char slave_names[RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES]
  50                         [RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN];
  51 };
  52
  53 #define RTE_CRYPTODEV_VDEV_NAME                 ("name")
  54 #define RTE_CRYPTODEV_VDEV_SLAVE                ("slave")
  55 #define RTE_CRYPTODEV_VDEV_MODE                 ("mode")
  56 #define RTE_CRYPTODEV_VDEV_ORDERING             ("ordering")
  57 #define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG        ("max_nb_queue_pairs")
  58 #define RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG      ("max_nb_sessions")
  59 #define RTE_CRYPTODEV_VDEV_SOCKET_ID            ("socket_id")
  60
  61 const char *scheduler_valid_params[] = {
  62         RTE_CRYPTODEV_VDEV_NAME,
  63         RTE_CRYPTODEV_VDEV_SLAVE,
  64         RTE_CRYPTODEV_VDEV_MODE,
  65         RTE_CRYPTODEV_VDEV_ORDERING,
  66         RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
  67         RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
  68         RTE_CRYPTODEV_VDEV_SOCKET_ID
  69 };
  70
  71 struct scheduler_parse_map {
  72         const char *name;
  73         uint32_t val;
  74 };
  75
  76 const struct scheduler_parse_map scheduler_mode_map[] = {
  77         {RTE_STR(SCHEDULER_MODE_NAME_ROUND_ROBIN),
  78                         CDEV_SCHED_MODE_ROUNDROBIN},
  79         {RTE_STR(SCHEDULER_MODE_NAME_PKT_SIZE_DISTR),
  80                         CDEV_SCHED_MODE_PKT_SIZE_DISTR},
  81         {RTE_STR(SCHEDULER_MODE_NAME_FAIL_OVER),
  82                         CDEV_SCHED_MODE_FAILOVER}
  83 };
  84
  85 const struct scheduler_parse_map scheduler_ordering_map[] = {
  86                 {"enable", 1},
  87                 {"disable", 0}
  88 };
  89
  90 static int
  91 cryptodev_scheduler_create(const char *name,
  92         struct scheduler_init_params *init_params)
  93 {
  94         struct rte_cryptodev *dev;
  95         struct scheduler_ctx *sched_ctx;
  96         uint32_t i;
  97         int ret;
  98
  99         if (init_params->def_p.name[0] == '\0')
 100                 snprintf(init_params->def_p.name,
 101                                 sizeof(init_params->def_p.name),
 102                                 "%s", name);
 103
 104         dev = rte_cryptodev_pmd_virtual_dev_init(init_params->def_p.name,
 105                         sizeof(struct scheduler_ctx),
 106                         init_params->def_p.socket_id);
 107         if (dev == NULL) {
 108                 CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
 109                         name);
 110                 return -EFAULT;
 111         }
 112
 113         dev->dev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
 114         dev->dev_ops = rte_crypto_scheduler_pmd_ops;
 115
 116         sched_ctx = dev->data->dev_private;
 117         sched_ctx->max_nb_queue_pairs =
 118                         init_params->def_p.max_nb_queue_pairs;
 119
 120         if (init_params->mode > CDEV_SCHED_MODE_USERDEFINED &&
 121                         init_params->mode < CDEV_SCHED_MODE_COUNT) {
 122                 ret = rte_cryptodev_scheduler_mode_set(dev->data->dev_id,
 123                         init_params->mode);
 124                 if (ret < 0) {
 125                         rte_cryptodev_pmd_release_device(dev);
 126                         return ret;
 127                 }
 128
 129                 for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
 130                         if (scheduler_mode_map[i].val != sched_ctx->mode)
 131                                 continue;
 132
 133                         RTE_LOG(INFO, PMD, "  Scheduling mode = %s\n",
 134                                         scheduler_mode_map[i].name);
 135                         break;
 136                 }
 137         }
 138
 139         sched_ctx->reordering_enabled = init_params->enable_ordering;
 140
 141         for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
 142                 if (scheduler_ordering_map[i].val !=
 143                                 sched_ctx->reordering_enabled)
 144                         continue;
 145
 146                 RTE_LOG(INFO, PMD, "  Packet ordering = %s\n",
 147                                 scheduler_ordering_map[i].name);
 148
 149                 break;
 150         }
 151
 152         for (i = 0; i < init_params->nb_slaves; i++) {
 153                 sched_ctx->init_slave_names[sched_ctx->nb_init_slaves] =
 154                         rte_zmalloc_socket(
 155                                 NULL,
 156                                 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN, 0,
 157                                 SOCKET_ID_ANY);
 158
 159                 if (!sched_ctx->init_slave_names[
 160                                 sched_ctx->nb_init_slaves]) {
 161                         CS_LOG_ERR("driver %s: Insufficient memory",
 162                                         name);
 163                         return -ENOMEM;
 164                 }
 165
 166                 strncpy(sched_ctx->init_slave_names[
 167                                         sched_ctx->nb_init_slaves],
 168                                 init_params->slave_names[i],
 169                                 RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
 170
 171                 sched_ctx->nb_init_slaves++;
 172         }
 173
 174         /*
 175          * Initialize capabilities structure as an empty structure,
 176          * in case device information is requested when no slaves are attached
 177          */
 178         sched_ctx->capabilities = rte_zmalloc_socket(NULL,
 179                         sizeof(struct rte_cryptodev_capabilities),
 180                         0, SOCKET_ID_ANY);
 181
 182         if (!sched_ctx->capabilities) {
 183                 RTE_LOG(ERR, PMD, "Not enough memory for capability "
 184                                 "information\n");
 185                 return -ENOMEM;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int
 192 cryptodev_scheduler_remove(struct rte_vdev_device *vdev)
 193 {
 194         const char *name;
 195         struct rte_cryptodev *dev;
 196         struct scheduler_ctx *sched_ctx;
 197
 198         if (vdev == NULL)
 199                 return -EINVAL;
 200
 201         name = rte_vdev_device_name(vdev);
 202         dev = rte_cryptodev_pmd_get_named_dev(name);
 203         if (dev == NULL)
 204                 return -EINVAL;
 205
 206         sched_ctx = dev->data->dev_private;
 207
 208         if (sched_ctx->nb_slaves) {
 209                 uint32_t i;
 210
 211                 for (i = 0; i < sched_ctx->nb_slaves; i++)
 212                         rte_cryptodev_scheduler_slave_detach(dev->data->dev_id,
 213                                         sched_ctx->slaves[i].dev_id);
 214         }
 215
 216         RTE_LOG(INFO, PMD, "Closing Crypto Scheduler device %s on numa "
 217                 "socket %u\n", name, rte_socket_id());
 218
 219         return 0;
 220 }
 221
 222 static uint8_t
 223 number_of_sockets(void)
 224 {
 225         int sockets = 0;
 226         int i;
 227         const struct rte_memseg *ms = rte_eal_get_physmem_layout();
 228
 229         for (i = 0; ((i < RTE_MAX_MEMSEG) && (ms[i].addr != NULL)); i++) {
 230                 if (sockets < ms[i].socket_id)
 231                         sockets = ms[i].socket_id;
 232         }
 233
 234         /* Number of sockets = maximum socket_id + 1 */
 235         return ++sockets;
 236 }
 237
 238 /** Parse integer from integer argument */
 239 static int
 240 parse_integer_arg(const char *key __rte_unused,
 241                 const char *value, void *extra_args)
 242 {
 243         int *i = (int *) extra_args;
 244
 245         *i = atoi(value);
 246         if (*i < 0) {
 247                 CS_LOG_ERR("Argument has to be positive.\n");
 248                 return -EINVAL;
 249         }
 250
 251         return 0;
 252 }
 253
 254 /** Parse name */
 255 static int
 256 parse_name_arg(const char *key __rte_unused,
 257                 const char *value, void *extra_args)
 258 {
 259         struct rte_crypto_vdev_init_params *params = extra_args;
 260
 261         if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
 262                 CS_LOG_ERR("Invalid name %s, should be less than "
 263                                 "%u bytes.\n", value,
 264                                 RTE_CRYPTODEV_NAME_MAX_LEN - 1);
 265                 return -EINVAL;
 266         }
 267
 268         strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
 269
 270         return 0;
 271 }
 272
 273 /** Parse slave */
 274 static int
 275 parse_slave_arg(const char *key __rte_unused,
 276                 const char *value, void *extra_args)
 277 {
 278         struct scheduler_init_params *param = extra_args;
 279
 280         if (param->nb_slaves >= RTE_CRYPTODEV_SCHEDULER_MAX_NB_SLAVES - 1) {
 281                 CS_LOG_ERR("Too many slaves.\n");
 282                 return -ENOMEM;
 283         }
 284
 285         strncpy(param->slave_names[param->nb_slaves++], value,
 286                         RTE_CRYPTODEV_SCHEDULER_NAME_MAX_LEN - 1);
 287
 288         return 0;
 289 }
 290
 291 static int
 292 parse_mode_arg(const char *key __rte_unused,
 293                 const char *value, void *extra_args)
 294 {
 295         struct scheduler_init_params *param = extra_args;
 296         uint32_t i;
 297
 298         for (i = 0; i < RTE_DIM(scheduler_mode_map); i++) {
 299                 if (strcmp(value, scheduler_mode_map[i].name) == 0) {
 300                         param->mode = (enum rte_cryptodev_scheduler_mode)
 301                                         scheduler_mode_map[i].val;
 302                         break;
 303                 }
 304         }
 305
 306         if (i == RTE_DIM(scheduler_mode_map)) {
 307                 CS_LOG_ERR("Unrecognized input.\n");
 308                 return -EINVAL;
 309         }
 310
 311         return 0;
 312 }
 313
 314 static int
 315 parse_ordering_arg(const char *key __rte_unused,
 316                 const char *value, void *extra_args)
 317 {
 318         struct scheduler_init_params *param = extra_args;
 319         uint32_t i;
 320
 321         for (i = 0; i < RTE_DIM(scheduler_ordering_map); i++) {
 322                 if (strcmp(value, scheduler_ordering_map[i].name) == 0) {
 323                         param->enable_ordering =
 324                                         scheduler_ordering_map[i].val;
 325                         break;
 326                 }
 327         }
 328
 329         if (i == RTE_DIM(scheduler_ordering_map)) {
 330                 CS_LOG_ERR("Unrecognized input.\n");
 331                 return -EINVAL;
 332         }
 333
 334         return 0;
 335 }
 336
 337 static int
 338 scheduler_parse_init_params(struct scheduler_init_params *params,
 339                 const char *input_args)
 340 {
 341         struct rte_kvargs *kvlist = NULL;
 342         int ret = 0;
 343
 344         if (params == NULL)
 345                 return -EINVAL;
 346
 347         if (input_args) {
 348                 kvlist = rte_kvargs_parse(input_args,
 349                                 scheduler_valid_params);
 350                 if (kvlist == NULL)
 351                         return -1;
 352
 353                 ret = rte_kvargs_process(kvlist,
 354                                 RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
 355                                 &parse_integer_arg,
 356                                 &params->def_p.max_nb_queue_pairs);
 357                 if (ret < 0)
 358                         goto free_kvlist;
 359
 360                 ret = rte_kvargs_process(kvlist,
 361                                 RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
 362                                 &parse_integer_arg,
 363                                 &params->def_p.max_nb_sessions);
 364                 if (ret < 0)
 365                         goto free_kvlist;
 366
 367                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SOCKET_ID,
 368                                 &parse_integer_arg,
 369                                 &params->def_p.socket_id);
 370                 if (ret < 0)
 371                         goto free_kvlist;
 372
 373                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_NAME,
 374                                 &parse_name_arg,
 375                                 &params->def_p);
 376                 if (ret < 0)
 377                         goto free_kvlist;
 378
 379                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SLAVE,
 380                                 &parse_slave_arg, params);
 381                 if (ret < 0)
 382                         goto free_kvlist;
 383
 384                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_MODE,
 385                                 &parse_mode_arg, params);
 386                 if (ret < 0)
 387                         goto free_kvlist;
 388
 389                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_ORDERING,
 390                                 &parse_ordering_arg, params);
 391                 if (ret < 0)
 392                         goto free_kvlist;
 393
 394                 if (params->def_p.socket_id >= number_of_sockets()) {
 395                         CDEV_LOG_ERR("Invalid socket id specified to create "
 396                                 "the virtual crypto device on");
 397                         goto free_kvlist;
 398                 }
 399         }
 400
 401 free_kvlist:
 402         rte_kvargs_free(kvlist);
 403         return ret;
 404 }
 405
 406 static int
 407 cryptodev_scheduler_probe(struct rte_vdev_device *vdev)
 408 {
 409         struct scheduler_init_params init_params = {
 410                 .def_p = {
 411                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
 412                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
 413                         rte_socket_id(),
 414                         ""
 415                 },
 416                 .nb_slaves = 0,
 417                 .mode = CDEV_SCHED_MODE_NOT_SET,
 418                 .enable_ordering = 0,
 419                 .slave_names = { {0} }
 420         };
 421         const char *name;
 422
 423         name = rte_vdev_device_name(vdev);
 424         if (name == NULL)
 425                 return -EINVAL;
 426
 427         scheduler_parse_init_params(&init_params,
 428                                     rte_vdev_device_args(vdev));
 429
 430         RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n",
 431                         name,
 432                         init_params.def_p.socket_id);
 433         RTE_LOG(INFO, PMD, "  Max number of queue pairs = %d\n",
 434                         init_params.def_p.max_nb_queue_pairs);
 435         RTE_LOG(INFO, PMD, "  Max number of sessions = %d\n",
 436                         init_params.def_p.max_nb_sessions);
 437         if (init_params.def_p.name[0] != '\0')
 438                 RTE_LOG(INFO, PMD, "  User defined name = %s\n",
 439                         init_params.def_p.name);
 440
 441         return cryptodev_scheduler_create(name,
 442                                         &init_params);
 443 }
 444
 445 static struct rte_vdev_driver cryptodev_scheduler_pmd_drv = {
 446         .probe = cryptodev_scheduler_probe,
 447         .remove = cryptodev_scheduler_remove
 448 };
 449
 450 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_SCHEDULER_PMD,
 451         cryptodev_scheduler_pmd_drv);
 452 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_SCHEDULER_PMD,
 453         "max_nb_queue_pairs=<int> "
 454         "max_nb_sessions=<int> "
 455         "socket_id=<int> "
 456         "slave=<name>");