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