examples/ip_pipeline/cryptodev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7
   8 #include <rte_cryptodev.h>
   9 #include <rte_cryptodev_pmd.h>
  10 #include <rte_string_fns.h>
  11
  12 #include "cryptodev.h"
  13
  14 #define PIPELINE_CRYPTO_SESSION_CACHE_SIZE      128
  15
  16 static struct cryptodev_list cryptodev_list;
  17
  18 int
  19 cryptodev_init(void)
  20 {
  21         TAILQ_INIT(&cryptodev_list);
  22
  23         return 0;
  24 }
  25
  26 struct cryptodev *
  27 cryptodev_find(const char *name)
  28 {
  29         struct cryptodev *cryptodev;
  30
  31         if (name == NULL)
  32                 return NULL;
  33
  34         TAILQ_FOREACH(cryptodev, &cryptodev_list, node)
  35                 if (strcmp(cryptodev->name, name) == 0)
  36                         return cryptodev;
  37
  38         return NULL;
  39 }
  40
  41 struct cryptodev *
  42 cryptodev_next(struct cryptodev *cryptodev)
  43 {
  44         return (cryptodev == NULL) ?
  45                         TAILQ_FIRST(&cryptodev_list) :
  46                         TAILQ_NEXT(cryptodev, node);
  47 }
  48
  49 struct cryptodev *
  50 cryptodev_create(const char *name, struct cryptodev_params *params)
  51 {
  52         struct rte_cryptodev_info dev_info;
  53         struct rte_cryptodev_config dev_conf;
  54         struct rte_cryptodev_qp_conf queue_conf;
  55         struct cryptodev *cryptodev;
  56         uint32_t dev_id, i;
  57         uint32_t socket_id;
  58         uint32_t cache_size;
  59         char mp_name[NAME_SIZE];
  60         int status;
  61
  62         /* Check input params */
  63         if ((name == NULL) ||
  64                 cryptodev_find(name) ||
  65                 (params->n_queues == 0) ||
  66                 (params->queue_size == 0) ||
  67                 (params->session_pool_size == 0))
  68                 return NULL;
  69
  70         if (params->dev_name) {
  71                 status = rte_cryptodev_get_dev_id(params->dev_name);
  72                 if (status == -1)
  73                         return NULL;
  74
  75                 dev_id = (uint32_t)status;
  76         } else {
  77                 if (rte_cryptodev_pmd_is_valid_dev(params->dev_id) == 0)
  78                         return NULL;
  79
  80                 dev_id = params->dev_id;
  81         }
  82
  83         cache_size = (params->session_pool_size / 2 <
  84                         PIPELINE_CRYPTO_SESSION_CACHE_SIZE) ?
  85                                         (params->session_pool_size / 2) :
  86                                         PIPELINE_CRYPTO_SESSION_CACHE_SIZE;
  87
  88         socket_id = rte_cryptodev_socket_id(dev_id);
  89         rte_cryptodev_info_get(dev_id, &dev_info);
  90
  91         if (dev_info.max_nb_queue_pairs < params->n_queues)
  92                 return NULL;
  93         if (dev_info.feature_flags & RTE_CRYPTODEV_FF_HW_ACCELERATED)
  94                 return NULL;
  95
  96         dev_conf.socket_id = socket_id;
  97         dev_conf.nb_queue_pairs = params->n_queues;
  98         dev_conf.ff_disable = 0;
  99
 100         status = rte_cryptodev_configure(dev_id, &dev_conf);
 101         if (status < 0)
 102                 return NULL;
 103
 104         queue_conf.nb_descriptors = params->queue_size;
 105         for (i = 0; i < params->n_queues; i++) {
 106                 status = rte_cryptodev_queue_pair_setup(dev_id, i,
 107                                 &queue_conf, socket_id);
 108                 if (status < 0)
 109                         return NULL;
 110         }
 111
 112         if (rte_cryptodev_start(dev_id) < 0)
 113                 return NULL;
 114
 115         cryptodev = calloc(1, sizeof(struct cryptodev));
 116         if (cryptodev == NULL) {
 117                 rte_cryptodev_stop(dev_id);
 118                 return NULL;
 119         }
 120
 121         strlcpy(cryptodev->name, name, sizeof(cryptodev->name));
 122         cryptodev->dev_id = dev_id;
 123         cryptodev->n_queues = params->n_queues;
 124
 125         snprintf(mp_name, NAME_SIZE, "%s_mp%u", name, dev_id);
 126         cryptodev->mp_create = rte_cryptodev_sym_session_pool_create(
 127                         mp_name,
 128                         params->session_pool_size,
 129                         0,
 130                         cache_size,
 131                         0,
 132                         socket_id);
 133         if (!cryptodev->mp_create)
 134                 goto error_exit;
 135
 136         snprintf(mp_name, NAME_SIZE, "%s_mp_priv%u", name, dev_id);
 137         cryptodev->mp_init = rte_mempool_create(
 138                         NULL,
 139                         params->session_pool_size,
 140                         rte_cryptodev_sym_get_private_session_size(dev_id),
 141                         cache_size,
 142                         0,
 143                         NULL,
 144                         NULL,
 145                         NULL,
 146                         NULL,
 147                         socket_id,
 148                         0);
 149         if (!cryptodev->mp_init)
 150                 goto error_exit;
 151
 152         TAILQ_INSERT_TAIL(&cryptodev_list, cryptodev, node);
 153
 154         return cryptodev;
 155
 156 error_exit:
 157         if (cryptodev->mp_create)
 158                 rte_mempool_free(cryptodev->mp_create);
 159         if (cryptodev->mp_init)
 160                 rte_mempool_free(cryptodev->mp_init);
 161
 162         free(cryptodev);
 163
 164         return NULL;
 165 }