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[MAX_SLAVES_NUM];
  48 };
  49
  50 #define RTE_CRYPTODEV_VDEV_NAME                         ("name")
  51 #define RTE_CRYPTODEV_VDEV_SLAVE                        ("slave")
  52 #define RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG        ("max_nb_queue_pairs")
  53 #define RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG      ("max_nb_sessions")
  54 #define RTE_CRYPTODEV_VDEV_SOCKET_ID            ("socket_id")
  55
  56 const char *scheduler_valid_params[] = {
  57         RTE_CRYPTODEV_VDEV_NAME,
  58         RTE_CRYPTODEV_VDEV_SLAVE,
  59         RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
  60         RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
  61         RTE_CRYPTODEV_VDEV_SOCKET_ID
  62 };
  63
  64 static int
  65 attach_init_slaves(uint8_t scheduler_id,
  66                 const uint8_t *slaves, const uint8_t nb_slaves)
  67 {
  68         uint8_t i;
  69
  70         for (i = 0; i < nb_slaves; i++) {
  71                 struct rte_cryptodev *dev =
  72                                 rte_cryptodev_pmd_get_dev(slaves[i]);
  73                 int status = rte_cryptodev_scheduler_slave_attach(
  74                                 scheduler_id, slaves[i]);
  75
  76                 if (status < 0 || !dev) {
  77                         CS_LOG_ERR("Failed to attach slave cryptodev "
  78                                         "%u.\n", slaves[i]);
  79                         return status;
  80                 }
  81
  82                 RTE_LOG(INFO, PMD, "  Attached slave cryptodev %s\n",
  83                                 dev->data->name);
  84         }
  85
  86         return 0;
  87 }
  88
  89 static int
  90 cryptodev_scheduler_create(const char *name,
  91         struct scheduler_init_params *init_params)
  92 {
  93         char crypto_dev_name[RTE_CRYPTODEV_NAME_MAX_LEN] = {0};
  94         struct rte_cryptodev *dev;
  95         struct scheduler_ctx *sched_ctx;
  96
  97         if (init_params->def_p.name[0] == '\0') {
  98                 int ret = rte_cryptodev_pmd_create_dev_name(
  99                                 crypto_dev_name,
 100                                 RTE_STR(CRYPTODEV_NAME_SCHEDULER_PMD));
 101
 102                 if (ret < 0) {
 103                         CS_LOG_ERR("failed to create unique name");
 104                         return ret;
 105                 }
 106         } else {
 107                 strncpy(crypto_dev_name, init_params->def_p.name,
 108                                 RTE_CRYPTODEV_NAME_MAX_LEN - 1);
 109         }
 110
 111         dev = rte_cryptodev_pmd_virtual_dev_init(crypto_dev_name,
 112                         sizeof(struct scheduler_ctx),
 113                         init_params->def_p.socket_id);
 114         if (dev == NULL) {
 115                 CS_LOG_ERR("driver %s: failed to create cryptodev vdev",
 116                         name);
 117                 return -EFAULT;
 118         }
 119
 120         dev->dev_type = RTE_CRYPTODEV_SCHEDULER_PMD;
 121         dev->dev_ops = rte_crypto_scheduler_pmd_ops;
 122
 123         sched_ctx = dev->data->dev_private;
 124         sched_ctx->max_nb_queue_pairs =
 125                         init_params->def_p.max_nb_queue_pairs;
 126
 127         return attach_init_slaves(dev->data->dev_id, init_params->slaves,
 128                         init_params->nb_slaves);
 129 }
 130
 131 static int
 132 cryptodev_scheduler_remove(const char *name)
 133 {
 134         struct rte_cryptodev *dev;
 135         struct scheduler_ctx *sched_ctx;
 136
 137         if (name == NULL)
 138                 return -EINVAL;
 139
 140         dev = rte_cryptodev_pmd_get_named_dev(name);
 141         if (dev == NULL)
 142                 return -EINVAL;
 143
 144         sched_ctx = dev->data->dev_private;
 145
 146         if (sched_ctx->nb_slaves) {
 147                 uint32_t i;
 148
 149                 for (i = 0; i < sched_ctx->nb_slaves; i++)
 150                         rte_cryptodev_scheduler_slave_detach(dev->data->dev_id,
 151                                         sched_ctx->slaves[i].dev_id);
 152         }
 153
 154         RTE_LOG(INFO, PMD, "Closing Crypto Scheduler device %s on numa "
 155                 "socket %u\n", name, rte_socket_id());
 156
 157         return 0;
 158 }
 159
 160 static uint8_t
 161 number_of_sockets(void)
 162 {
 163         int sockets = 0;
 164         int i;
 165         const struct rte_memseg *ms = rte_eal_get_physmem_layout();
 166
 167         for (i = 0; ((i < RTE_MAX_MEMSEG) && (ms[i].addr != NULL)); i++) {
 168                 if (sockets < ms[i].socket_id)
 169                         sockets = ms[i].socket_id;
 170         }
 171
 172         /* Number of sockets = maximum socket_id + 1 */
 173         return ++sockets;
 174 }
 175
 176 /** Parse integer from integer argument */
 177 static int
 178 parse_integer_arg(const char *key __rte_unused,
 179                 const char *value, void *extra_args)
 180 {
 181         int *i = (int *) extra_args;
 182
 183         *i = atoi(value);
 184         if (*i < 0) {
 185                 CS_LOG_ERR("Argument has to be positive.\n");
 186                 return -1;
 187         }
 188
 189         return 0;
 190 }
 191
 192 /** Parse name */
 193 static int
 194 parse_name_arg(const char *key __rte_unused,
 195                 const char *value, void *extra_args)
 196 {
 197         struct rte_crypto_vdev_init_params *params = extra_args;
 198
 199         if (strlen(value) >= RTE_CRYPTODEV_NAME_MAX_LEN - 1) {
 200                 CS_LOG_ERR("Invalid name %s, should be less than "
 201                                 "%u bytes.\n", value,
 202                                 RTE_CRYPTODEV_NAME_MAX_LEN - 1);
 203                 return -1;
 204         }
 205
 206         strncpy(params->name, value, RTE_CRYPTODEV_NAME_MAX_LEN);
 207
 208         return 0;
 209 }
 210
 211 /** Parse slave */
 212 static int
 213 parse_slave_arg(const char *key __rte_unused,
 214                 const char *value, void *extra_args)
 215 {
 216         struct scheduler_init_params *param = extra_args;
 217         struct rte_cryptodev *dev =
 218                         rte_cryptodev_pmd_get_named_dev(value);
 219
 220         if (!dev) {
 221                 RTE_LOG(ERR, PMD, "Invalid slave name %s.\n", value);
 222                 return -1;
 223         }
 224
 225         if (param->nb_slaves >= MAX_SLAVES_NUM - 1) {
 226                 CS_LOG_ERR("Too many slaves.\n");
 227                 return -1;
 228         }
 229
 230         param->slaves[param->nb_slaves] = dev->data->dev_id;
 231         param->nb_slaves++;
 232
 233         return 0;
 234 }
 235
 236 static int
 237 scheduler_parse_init_params(struct scheduler_init_params *params,
 238                 const char *input_args)
 239 {
 240         struct rte_kvargs *kvlist = NULL;
 241         int ret = 0;
 242
 243         if (params == NULL)
 244                 return -EINVAL;
 245
 246         if (input_args) {
 247                 kvlist = rte_kvargs_parse(input_args,
 248                                 scheduler_valid_params);
 249                 if (kvlist == NULL)
 250                         return -1;
 251
 252                 ret = rte_kvargs_process(kvlist,
 253                                 RTE_CRYPTODEV_VDEV_MAX_NB_QP_ARG,
 254                                 &parse_integer_arg,
 255                                 &params->def_p.max_nb_queue_pairs);
 256                 if (ret < 0)
 257                         goto free_kvlist;
 258
 259                 ret = rte_kvargs_process(kvlist,
 260                                 RTE_CRYPTODEV_VDEV_MAX_NB_SESS_ARG,
 261                                 &parse_integer_arg,
 262                                 &params->def_p.max_nb_sessions);
 263                 if (ret < 0)
 264                         goto free_kvlist;
 265
 266                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SOCKET_ID,
 267                                 &parse_integer_arg,
 268                                 &params->def_p.socket_id);
 269                 if (ret < 0)
 270                         goto free_kvlist;
 271
 272                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_NAME,
 273                                 &parse_name_arg,
 274                                 &params->def_p);
 275                 if (ret < 0)
 276                         goto free_kvlist;
 277
 278                 ret = rte_kvargs_process(kvlist, RTE_CRYPTODEV_VDEV_SLAVE,
 279                                 &parse_slave_arg, params);
 280                 if (ret < 0)
 281                         goto free_kvlist;
 282
 283                 if (params->def_p.socket_id >= number_of_sockets()) {
 284                         CDEV_LOG_ERR("Invalid socket id specified to create "
 285                                 "the virtual crypto device on");
 286                         goto free_kvlist;
 287                 }
 288         }
 289
 290 free_kvlist:
 291         rte_kvargs_free(kvlist);
 292         return ret;
 293 }
 294
 295 static int
 296 cryptodev_scheduler_probe(const char *name, const char *input_args)
 297 {
 298         struct scheduler_init_params init_params = {
 299                 .def_p = {
 300                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_QUEUE_PAIRS,
 301                         RTE_CRYPTODEV_VDEV_DEFAULT_MAX_NB_SESSIONS,
 302                         rte_socket_id(),
 303                         ""
 304                 },
 305                 .nb_slaves = 0,
 306                 .slaves = {0}
 307         };
 308
 309         scheduler_parse_init_params(&init_params, input_args);
 310
 311         RTE_LOG(INFO, PMD, "Initialising %s on NUMA node %d\n", name,
 312                         init_params.def_p.socket_id);
 313         RTE_LOG(INFO, PMD, "  Max number of queue pairs = %d\n",
 314                         init_params.def_p.max_nb_queue_pairs);
 315         RTE_LOG(INFO, PMD, "  Max number of sessions = %d\n",
 316                         init_params.def_p.max_nb_sessions);
 317         if (init_params.def_p.name[0] != '\0')
 318                 RTE_LOG(INFO, PMD, "  User defined name = %s\n",
 319                         init_params.def_p.name);
 320
 321         return cryptodev_scheduler_create(name, &init_params);
 322 }
 323
 324 static struct rte_vdev_driver cryptodev_scheduler_pmd_drv = {
 325         .probe = cryptodev_scheduler_probe,
 326         .remove = cryptodev_scheduler_remove
 327 };
 328
 329 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_SCHEDULER_PMD,
 330         cryptodev_scheduler_pmd_drv);
 331 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_SCHEDULER_PMD,
 332         "max_nb_queue_pairs=<int> "
 333         "max_nb_sessions=<int> "
 334         "socket_id=<int> "
 335         "slave=<name>");