drivers/crypto/null/null_crypto_pmd_ops.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016-2017 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6
   7 #include <rte_common.h>
   8 #include <rte_malloc.h>
   9 #include <rte_cryptodev_pmd.h>
  10
  11 #include "null_crypto_pmd_private.h"
  12
  13 static const struct rte_cryptodev_capabilities null_crypto_pmd_capabilities[] = {
  14         {       /* NULL (AUTH) */
  15                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  16                 {.sym = {
  17                         .xform_type = RTE_CRYPTO_SYM_XFORM_AUTH,
  18                         {.auth = {
  19                                 .algo = RTE_CRYPTO_AUTH_NULL,
  20                                 .block_size = 1,
  21                                 .key_size = {
  22                                         .min = 0,
  23                                         .max = 0,
  24                                         .increment = 0
  25                                 },
  26                                 .digest_size = {
  27                                         .min = 0,
  28                                         .max = 0,
  29                                         .increment = 0
  30                                 },
  31                                 .iv_size = { 0 }
  32                         }, },
  33                 }, },
  34         },
  35         {       /* NULL (CIPHER) */
  36                 .op = RTE_CRYPTO_OP_TYPE_SYMMETRIC,
  37                 {.sym = {
  38                         .xform_type = RTE_CRYPTO_SYM_XFORM_CIPHER,
  39                         {.cipher = {
  40                                 .algo = RTE_CRYPTO_CIPHER_NULL,
  41                                 .block_size = 1,
  42                                 .key_size = {
  43                                         .min = 0,
  44                                         .max = 0,
  45                                         .increment = 0
  46                                 },
  47                                 .iv_size = { 0 }
  48                         }, },
  49                 }, }
  50         },
  51         RTE_CRYPTODEV_END_OF_CAPABILITIES_LIST()
  52 };
  53
  54 /** Configure device */
  55 static int
  56 null_crypto_pmd_config(__rte_unused struct rte_cryptodev *dev,
  57                 __rte_unused struct rte_cryptodev_config *config)
  58 {
  59         return 0;
  60 }
  61
  62 /** Start device */
  63 static int
  64 null_crypto_pmd_start(__rte_unused struct rte_cryptodev *dev)
  65 {
  66         return 0;
  67 }
  68
  69 /** Stop device */
  70 static void
  71 null_crypto_pmd_stop(__rte_unused struct rte_cryptodev *dev)
  72 {
  73 }
  74
  75 /** Close device */
  76 static int
  77 null_crypto_pmd_close(__rte_unused struct rte_cryptodev *dev)
  78 {
  79         return 0;
  80 }
  81
  82 /** Get device statistics */
  83 static void
  84 null_crypto_pmd_stats_get(struct rte_cryptodev *dev,
  85                 struct rte_cryptodev_stats *stats)
  86 {
  87         int qp_id;
  88
  89         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
  90                 struct null_crypto_qp *qp = dev->data->queue_pairs[qp_id];
  91
  92                 stats->enqueued_count += qp->qp_stats.enqueued_count;
  93                 stats->dequeued_count += qp->qp_stats.dequeued_count;
  94
  95                 stats->enqueue_err_count += qp->qp_stats.enqueue_err_count;
  96                 stats->dequeue_err_count += qp->qp_stats.dequeue_err_count;
  97         }
  98 }
  99
 100 /** Reset device statistics */
 101 static void
 102 null_crypto_pmd_stats_reset(struct rte_cryptodev *dev)
 103 {
 104         int qp_id;
 105
 106         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
 107                 struct null_crypto_qp *qp = dev->data->queue_pairs[qp_id];
 108
 109                 memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
 110         }
 111 }
 112
 113
 114 /** Get device info */
 115 static void
 116 null_crypto_pmd_info_get(struct rte_cryptodev *dev,
 117                 struct rte_cryptodev_info *dev_info)
 118 {
 119         struct null_crypto_private *internals = dev->data->dev_private;
 120
 121         if (dev_info != NULL) {
 122                 dev_info->driver_id = dev->driver_id;
 123                 dev_info->max_nb_queue_pairs = internals->max_nb_qpairs;
 124                 /* No limit of number of sessions */
 125                 dev_info->sym.max_nb_sessions = 0;
 126                 dev_info->feature_flags = dev->feature_flags;
 127                 dev_info->capabilities = null_crypto_pmd_capabilities;
 128         }
 129 }
 130
 131 /** Release queue pair */
 132 static int
 133 null_crypto_pmd_qp_release(struct rte_cryptodev *dev, uint16_t qp_id)
 134 {
 135         if (dev->data->queue_pairs[qp_id] != NULL) {
 136                 struct null_crypto_qp *qp = dev->data->queue_pairs[qp_id];
 137
 138                 if (qp->processed_pkts)
 139                         rte_ring_free(qp->processed_pkts);
 140
 141                 rte_free(dev->data->queue_pairs[qp_id]);
 142                 dev->data->queue_pairs[qp_id] = NULL;
 143         }
 144         return 0;
 145 }
 146
 147 /** set a unique name for the queue pair based on it's name, dev_id and qp_id */
 148 static int
 149 null_crypto_pmd_qp_set_unique_name(struct rte_cryptodev *dev,
 150                 struct null_crypto_qp *qp)
 151 {
 152         unsigned n = snprintf(qp->name, sizeof(qp->name),
 153                         "null_crypto_pmd_%u_qp_%u",
 154                         dev->data->dev_id, qp->id);
 155
 156         if (n >= sizeof(qp->name))
 157                 return -1;
 158
 159         return 0;
 160 }
 161
 162 /** Create a ring to place process packets on */
 163 static struct rte_ring *
 164 null_crypto_pmd_qp_create_processed_pkts_ring(struct null_crypto_qp *qp,
 165                 unsigned ring_size, int socket_id)
 166 {
 167         struct rte_ring *r;
 168
 169         r = rte_ring_lookup(qp->name);
 170         if (r) {
 171                 if (rte_ring_get_size(r) >= ring_size) {
 172                         NULL_LOG(INFO,
 173                                         "Reusing existing ring %s for "
 174                                         " processed packets", qp->name);
 175                         return r;
 176                 }
 177
 178                 NULL_LOG(INFO,
 179                                 "Unable to reuse existing ring %s for "
 180                                 " processed packets", qp->name);
 181                 return NULL;
 182         }
 183
 184         return rte_ring_create(qp->name, ring_size, socket_id,
 185                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 186 }
 187
 188 /** Setup a queue pair */
 189 static int
 190 null_crypto_pmd_qp_setup(struct rte_cryptodev *dev, uint16_t qp_id,
 191                 const struct rte_cryptodev_qp_conf *qp_conf,
 192                 int socket_id)
 193 {
 194         struct null_crypto_private *internals = dev->data->dev_private;
 195         struct null_crypto_qp *qp;
 196         int retval;
 197
 198         if (qp_id >= internals->max_nb_qpairs) {
 199                 NULL_LOG(ERR, "Invalid qp_id %u, greater than maximum "
 200                                 "number of queue pairs supported (%u).",
 201                                 qp_id, internals->max_nb_qpairs);
 202                 return (-EINVAL);
 203         }
 204
 205         /* Free memory prior to re-allocation if needed. */
 206         if (dev->data->queue_pairs[qp_id] != NULL)
 207                 null_crypto_pmd_qp_release(dev, qp_id);
 208
 209         /* Allocate the queue pair data structure. */
 210         qp = rte_zmalloc_socket("Null Crypto PMD Queue Pair", sizeof(*qp),
 211                                         RTE_CACHE_LINE_SIZE, socket_id);
 212         if (qp == NULL) {
 213                 NULL_LOG(ERR, "Failed to allocate queue pair memory");
 214                 return (-ENOMEM);
 215         }
 216
 217         qp->id = qp_id;
 218         dev->data->queue_pairs[qp_id] = qp;
 219
 220         retval = null_crypto_pmd_qp_set_unique_name(dev, qp);
 221         if (retval) {
 222                 NULL_LOG(ERR, "Failed to create unique name for null "
 223                                 "crypto device");
 224
 225                 goto qp_setup_cleanup;
 226         }
 227
 228         qp->processed_pkts = null_crypto_pmd_qp_create_processed_pkts_ring(qp,
 229                         qp_conf->nb_descriptors, socket_id);
 230         if (qp->processed_pkts == NULL) {
 231                 NULL_LOG(ERR, "Failed to create unique name for null "
 232                                 "crypto device");
 233                 goto qp_setup_cleanup;
 234         }
 235
 236         qp->sess_mp = qp_conf->mp_session;
 237         qp->sess_mp_priv = qp_conf->mp_session_private;
 238
 239         memset(&qp->qp_stats, 0, sizeof(qp->qp_stats));
 240
 241         return 0;
 242
 243 qp_setup_cleanup:
 244         if (qp)
 245                 rte_free(qp);
 246
 247         return -1;
 248 }
 249
 250 /** Return the number of allocated queue pairs */
 251 static uint32_t
 252 null_crypto_pmd_qp_count(struct rte_cryptodev *dev)
 253 {
 254         return dev->data->nb_queue_pairs;
 255 }
 256
 257 /** Returns the size of the NULL crypto session structure */
 258 static unsigned
 259 null_crypto_pmd_sym_session_get_size(struct rte_cryptodev *dev __rte_unused)
 260 {
 261         return sizeof(struct null_crypto_session);
 262 }
 263
 264 /** Configure a null crypto session from a crypto xform chain */
 265 static int
 266 null_crypto_pmd_sym_session_configure(struct rte_cryptodev *dev __rte_unused,
 267                 struct rte_crypto_sym_xform *xform,
 268                 struct rte_cryptodev_sym_session *sess,
 269                 struct rte_mempool *mp)
 270 {
 271         void *sess_private_data;
 272         int ret;
 273
 274         if (unlikely(sess == NULL)) {
 275                 NULL_LOG(ERR, "invalid session struct");
 276                 return -EINVAL;
 277         }
 278
 279         if (rte_mempool_get(mp, &sess_private_data)) {
 280                 NULL_LOG(ERR,
 281                                 "Couldn't get object from session mempool");
 282                 return -ENOMEM;
 283         }
 284
 285         ret = null_crypto_set_session_parameters(sess_private_data, xform);
 286         if (ret != 0) {
 287                 NULL_LOG(ERR, "failed configure session parameters");
 288
 289                 /* Return session to mempool */
 290                 rte_mempool_put(mp, sess_private_data);
 291                 return ret;
 292         }
 293
 294         set_sym_session_private_data(sess, dev->driver_id,
 295                 sess_private_data);
 296
 297         return 0;
 298 }
 299
 300 /** Clear the memory of session so it doesn't leave key material behind */
 301 static void
 302 null_crypto_pmd_sym_session_clear(struct rte_cryptodev *dev,
 303                 struct rte_cryptodev_sym_session *sess)
 304 {
 305         uint8_t index = dev->driver_id;
 306         void *sess_priv = get_sym_session_private_data(sess, index);
 307
 308         /* Zero out the whole structure */
 309         if (sess_priv) {
 310                 memset(sess_priv, 0, sizeof(struct null_crypto_session));
 311                 struct rte_mempool *sess_mp = rte_mempool_from_obj(sess_priv);
 312                 set_sym_session_private_data(sess, index, NULL);
 313                 rte_mempool_put(sess_mp, sess_priv);
 314         }
 315 }
 316
 317 static struct rte_cryptodev_ops pmd_ops = {
 318                 .dev_configure          = null_crypto_pmd_config,
 319                 .dev_start              = null_crypto_pmd_start,
 320                 .dev_stop               = null_crypto_pmd_stop,
 321                 .dev_close              = null_crypto_pmd_close,
 322
 323                 .stats_get              = null_crypto_pmd_stats_get,
 324                 .stats_reset            = null_crypto_pmd_stats_reset,
 325
 326                 .dev_infos_get          = null_crypto_pmd_info_get,
 327
 328                 .queue_pair_setup       = null_crypto_pmd_qp_setup,
 329                 .queue_pair_release     = null_crypto_pmd_qp_release,
 330                 .queue_pair_count       = null_crypto_pmd_qp_count,
 331
 332                 .sym_session_get_size   = null_crypto_pmd_sym_session_get_size,
 333                 .sym_session_configure  = null_crypto_pmd_sym_session_configure,
 334                 .sym_session_clear      = null_crypto_pmd_sym_session_clear
 335 };
 336
 337 struct rte_cryptodev_ops *null_crypto_pmd_ops = &pmd_ops;