LCOV - code coverage report
Current view: top level - drivers/crypto/mlx5 - mlx5_crypto.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 8 214 3.7 %
Date: 2024-02-14 00:53:57 Functions: 3 18 16.7 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 2 102 2.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright (c) 2021 NVIDIA Corporation & Affiliates
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <rte_malloc.h>
       6                 :            : #include <rte_mempool.h>
       7                 :            : #include <rte_eal_paging.h>
       8                 :            : #include <rte_errno.h>
       9                 :            : #include <rte_log.h>
      10                 :            : #include <bus_pci_driver.h>
      11                 :            : #include <rte_memory.h>
      12                 :            : 
      13                 :            : #include <mlx5_glue.h>
      14                 :            : #include <mlx5_common.h>
      15                 :            : #include <mlx5_devx_cmds.h>
      16                 :            : #include <mlx5_common_os.h>
      17                 :            : 
      18                 :            : #include "mlx5_crypto_utils.h"
      19                 :            : #include "mlx5_crypto.h"
      20                 :            : 
      21                 :            : #define MLX5_CRYPTO_DRIVER_NAME crypto_mlx5
      22                 :            : #define MLX5_CRYPTO_LOG_NAME pmd.crypto.mlx5
      23                 :            : #define MLX5_CRYPTO_MAX_QPS 128
      24                 :            : #define MLX5_CRYPTO_MAX_SEGS 56
      25                 :            : 
      26                 :            : #define MLX5_CRYPTO_FEATURE_FLAGS(wrapped_mode) \
      27                 :            :         (RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO | RTE_CRYPTODEV_FF_HW_ACCELERATED | \
      28                 :            :          RTE_CRYPTODEV_FF_IN_PLACE_SGL | RTE_CRYPTODEV_FF_OOP_SGL_IN_SGL_OUT | \
      29                 :            :          RTE_CRYPTODEV_FF_OOP_SGL_IN_LB_OUT | \
      30                 :            :          RTE_CRYPTODEV_FF_OOP_LB_IN_SGL_OUT | \
      31                 :            :          RTE_CRYPTODEV_FF_OOP_LB_IN_LB_OUT | \
      32                 :            :          (wrapped_mode ? RTE_CRYPTODEV_FF_CIPHER_WRAPPED_KEY : 0) | \
      33                 :            :          RTE_CRYPTODEV_FF_CIPHER_MULTIPLE_DATA_UNITS)
      34                 :            : 
      35                 :            : TAILQ_HEAD(mlx5_crypto_privs, mlx5_crypto_priv) mlx5_crypto_priv_list =
      36                 :            :                                 TAILQ_HEAD_INITIALIZER(mlx5_crypto_priv_list);
      37                 :            : static pthread_mutex_t priv_list_lock;
      38                 :            : 
      39                 :            : int mlx5_crypto_logtype;
      40                 :            : 
      41                 :            : uint8_t mlx5_crypto_driver_id;
      42                 :            : 
      43                 :            : static const char mlx5_crypto_drv_name[] = RTE_STR(MLX5_CRYPTO_DRIVER_NAME);
      44                 :            : 
      45                 :            : static const struct rte_driver mlx5_drv = {
      46                 :            :         .name = mlx5_crypto_drv_name,
      47                 :            :         .alias = mlx5_crypto_drv_name
      48                 :            : };
      49                 :            : 
      50                 :            : static struct cryptodev_driver mlx5_cryptodev_driver;
      51                 :            : 
      52                 :            : static void
      53                 :          0 : mlx5_crypto_dev_infos_get(struct rte_cryptodev *dev,
      54                 :            :                           struct rte_cryptodev_info *dev_info)
      55                 :            : {
      56                 :          0 :         struct mlx5_crypto_priv *priv = dev->data->dev_private;
      57                 :            : 
      58                 :            :         RTE_SET_USED(dev);
      59         [ #  # ]:          0 :         if (dev_info != NULL) {
      60                 :          0 :                 dev_info->driver_id = mlx5_crypto_driver_id;
      61                 :          0 :                 dev_info->feature_flags =
      62                 :          0 :                         MLX5_CRYPTO_FEATURE_FLAGS(priv->is_wrapped_mode);
      63                 :          0 :                 dev_info->capabilities = priv->caps;
      64                 :          0 :                 dev_info->max_nb_queue_pairs = MLX5_CRYPTO_MAX_QPS;
      65         [ #  # ]:          0 :                 if (priv->caps->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AEAD) {
      66                 :          0 :                         dev_info->min_mbuf_headroom_req = MLX5_CRYPTO_GCM_MAX_AAD;
      67                 :          0 :                         dev_info->min_mbuf_tailroom_req = MLX5_CRYPTO_GCM_MAX_DIGEST;
      68                 :            :                 } else {
      69                 :          0 :                         dev_info->min_mbuf_headroom_req = 0;
      70                 :          0 :                         dev_info->min_mbuf_tailroom_req = 0;
      71                 :            :                 }
      72                 :          0 :                 dev_info->sym.max_nb_sessions = 0;
      73                 :            :                 /*
      74                 :            :                  * If 0, the device does not have any limitation in number of
      75                 :            :                  * sessions that can be used.
      76                 :            :                  */
      77                 :            :         }
      78                 :          0 : }
      79                 :            : 
      80                 :            : void
      81                 :          0 : mlx5_crypto_indirect_mkeys_release(struct mlx5_crypto_qp *qp,
      82                 :            :                                    uint16_t n)
      83                 :            : {
      84                 :            :         uint32_t i;
      85                 :            : 
      86         [ #  # ]:          0 :         for (i = 0; i < n; i++)
      87         [ #  # ]:          0 :                 if (qp->mkey[i])
      88                 :          0 :                         claim_zero(mlx5_devx_cmd_destroy(qp->mkey[i]));
      89                 :          0 : }
      90                 :            : 
      91                 :            : int
      92                 :          0 : mlx5_crypto_indirect_mkeys_prepare(struct mlx5_crypto_priv *priv,
      93                 :            :                                    struct mlx5_crypto_qp *qp,
      94                 :            :                                    struct mlx5_devx_mkey_attr *attr,
      95                 :            :                                    mlx5_crypto_mkey_update_t update_cb)
      96                 :            : {
      97                 :            :         uint32_t i;
      98                 :            : 
      99         [ #  # ]:          0 :         for (i = 0; i < qp->entries_n; i++) {
     100                 :          0 :                 attr->klm_array = update_cb(priv, qp, i);
     101                 :          0 :                 qp->mkey[i] = mlx5_devx_cmd_mkey_create(priv->cdev->ctx, attr);
     102         [ #  # ]:          0 :                 if (!qp->mkey[i])
     103                 :          0 :                         goto error;
     104                 :            :         }
     105                 :            :         return 0;
     106                 :            : error:
     107                 :          0 :         DRV_LOG(ERR, "Failed to allocate indirect mkey.");
     108                 :          0 :         mlx5_crypto_indirect_mkeys_release(qp, i);
     109                 :          0 :         return -1;
     110                 :            : }
     111                 :            : 
     112                 :            : static int
     113                 :          0 : mlx5_crypto_dev_configure(struct rte_cryptodev *dev,
     114                 :            :                           struct rte_cryptodev_config *config)
     115                 :            : {
     116                 :          0 :         struct mlx5_crypto_priv *priv = dev->data->dev_private;
     117                 :            : 
     118         [ #  # ]:          0 :         if (config == NULL) {
     119                 :          0 :                 DRV_LOG(ERR, "Invalid crypto dev configure parameters.");
     120                 :          0 :                 return -EINVAL;
     121                 :            :         }
     122         [ #  # ]:          0 :         if ((config->ff_disable & RTE_CRYPTODEV_FF_SYMMETRIC_CRYPTO) != 0) {
     123                 :          0 :                 DRV_LOG(ERR,
     124                 :            :                         "Disabled symmetric crypto feature is not supported.");
     125                 :          0 :                 return -ENOTSUP;
     126                 :            :         }
     127         [ #  # ]:          0 :         if (mlx5_crypto_dek_setup(priv) != 0) {
     128                 :          0 :                 DRV_LOG(ERR, "Dek hash list creation has failed.");
     129                 :          0 :                 return -ENOMEM;
     130                 :            :         }
     131                 :          0 :         priv->dev_config = *config;
     132                 :          0 :         DRV_LOG(DEBUG, "Device %u was configured.", dev->driver_id);
     133                 :          0 :         return 0;
     134                 :            : }
     135                 :            : 
     136                 :            : static void
     137                 :          0 : mlx5_crypto_dev_stop(struct rte_cryptodev *dev)
     138                 :            : {
     139                 :            :         RTE_SET_USED(dev);
     140                 :          0 : }
     141                 :            : 
     142                 :            : static int
     143                 :          0 : mlx5_crypto_dev_start(struct rte_cryptodev *dev)
     144                 :            : {
     145                 :          0 :         struct mlx5_crypto_priv *priv = dev->data->dev_private;
     146                 :            : 
     147                 :          0 :         return mlx5_dev_mempool_subscribe(priv->cdev);
     148                 :            : }
     149                 :            : 
     150                 :            : static int
     151                 :          0 : mlx5_crypto_dev_close(struct rte_cryptodev *dev)
     152                 :            : {
     153                 :          0 :         struct mlx5_crypto_priv *priv = dev->data->dev_private;
     154                 :            : 
     155                 :          0 :         mlx5_crypto_dek_unset(priv);
     156                 :          0 :         DRV_LOG(DEBUG, "Device %u was closed.", dev->driver_id);
     157                 :          0 :         return 0;
     158                 :            : }
     159                 :            : 
     160                 :            : static unsigned int
     161                 :          0 : mlx5_crypto_sym_session_get_size(struct rte_cryptodev *dev __rte_unused)
     162                 :            : {
     163                 :          0 :         return sizeof(struct mlx5_crypto_session);
     164                 :            : }
     165                 :            : 
     166                 :            : static void
     167                 :          0 : mlx5_crypto_sym_session_clear(struct rte_cryptodev *dev,
     168                 :            :                               struct rte_cryptodev_sym_session *sess)
     169                 :            : {
     170                 :          0 :         struct mlx5_crypto_priv *priv = dev->data->dev_private;
     171                 :          0 :         struct mlx5_crypto_session *spriv = CRYPTODEV_GET_SYM_SESS_PRIV(sess);
     172                 :            : 
     173                 :            :         if (unlikely(spriv == NULL)) {
     174                 :            :                 DRV_LOG(ERR, "Failed to get session %p private data.", spriv);
     175                 :            :                 return;
     176                 :            :         }
     177                 :          0 :         mlx5_crypto_dek_destroy(priv, spriv->dek);
     178                 :          0 :         DRV_LOG(DEBUG, "Session %p was cleared.", spriv);
     179                 :            : }
     180                 :            : 
     181                 :            : static void
     182                 :          0 : mlx5_crypto_stats_get(struct rte_cryptodev *dev,
     183                 :            :                       struct rte_cryptodev_stats *stats)
     184                 :            : {
     185                 :            :         int qp_id;
     186                 :            : 
     187         [ #  # ]:          0 :         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
     188                 :          0 :                 struct mlx5_crypto_qp *qp = dev->data->queue_pairs[qp_id];
     189                 :            : 
     190                 :          0 :                 stats->enqueued_count += qp->stats.enqueued_count;
     191                 :          0 :                 stats->dequeued_count += qp->stats.dequeued_count;
     192                 :          0 :                 stats->enqueue_err_count += qp->stats.enqueue_err_count;
     193                 :          0 :                 stats->dequeue_err_count += qp->stats.dequeue_err_count;
     194                 :            :         }
     195                 :          0 : }
     196                 :            : 
     197                 :            : static void
     198                 :          0 : mlx5_crypto_stats_reset(struct rte_cryptodev *dev)
     199                 :            : {
     200                 :            :         int qp_id;
     201                 :            : 
     202         [ #  # ]:          0 :         for (qp_id = 0; qp_id < dev->data->nb_queue_pairs; qp_id++) {
     203                 :          0 :                 struct mlx5_crypto_qp *qp = dev->data->queue_pairs[qp_id];
     204                 :            : 
     205                 :          0 :                 memset(&qp->stats, 0, sizeof(qp->stats));
     206                 :            :         }
     207                 :          0 : }
     208                 :            : 
     209                 :            : static struct rte_cryptodev_ops mlx5_crypto_ops = {
     210                 :            :         .dev_configure                  = mlx5_crypto_dev_configure,
     211                 :            :         .dev_start                      = mlx5_crypto_dev_start,
     212                 :            :         .dev_stop                       = mlx5_crypto_dev_stop,
     213                 :            :         .dev_close                      = mlx5_crypto_dev_close,
     214                 :            :         .dev_infos_get                  = mlx5_crypto_dev_infos_get,
     215                 :            :         .stats_get                      = mlx5_crypto_stats_get,
     216                 :            :         .stats_reset                    = mlx5_crypto_stats_reset,
     217                 :            :         .sym_session_get_size           = mlx5_crypto_sym_session_get_size,
     218                 :            :         .sym_session_clear              = mlx5_crypto_sym_session_clear,
     219                 :            :         .sym_get_raw_dp_ctx_size        = NULL,
     220                 :            :         .sym_configure_raw_dp_ctx       = NULL,
     221                 :            : };
     222                 :            : 
     223                 :            : static int
     224                 :          0 : mlx5_crypto_args_check_handler(const char *key, const char *val, void *opaque)
     225                 :            : {
     226                 :            :         struct mlx5_crypto_devarg_params *devarg_prms = opaque;
     227                 :            :         struct mlx5_devx_crypto_login_attr *attr = &devarg_prms->login_attr;
     228                 :            :         unsigned long tmp;
     229                 :            :         FILE *file;
     230                 :            :         int ret;
     231                 :            :         int i;
     232                 :            : 
     233         [ #  # ]:          0 :         if (strcmp(key, "wcs_file") == 0) {
     234                 :          0 :                 file = fopen(val, "rb");
     235         [ #  # ]:          0 :                 if (file == NULL) {
     236                 :          0 :                         rte_errno = ENOTSUP;
     237                 :          0 :                         return -rte_errno;
     238                 :            :                 }
     239         [ #  # ]:          0 :                 for (i = 0 ; i < MLX5_CRYPTO_CREDENTIAL_SIZE ; i++) {
     240                 :          0 :                         ret = fscanf(file, "%02hhX", &attr->credential[i]);
     241         [ #  # ]:          0 :                         if (ret <= 0) {
     242                 :          0 :                                 fclose(file);
     243                 :          0 :                                 DRV_LOG(ERR,
     244                 :            :                                         "Failed to read credential from file.");
     245                 :          0 :                                 rte_errno = EINVAL;
     246                 :          0 :                                 return -rte_errno;
     247                 :            :                         }
     248                 :            :                 }
     249                 :          0 :                 fclose(file);
     250                 :          0 :                 devarg_prms->login_devarg = true;
     251                 :          0 :                 return 0;
     252                 :            :         }
     253                 :          0 :         errno = 0;
     254                 :          0 :         tmp = strtoul(val, NULL, 0);
     255         [ #  # ]:          0 :         if (errno) {
     256                 :          0 :                 DRV_LOG(WARNING, "%s: \"%s\" is an invalid integer.", key, val);
     257                 :          0 :                 return -errno;
     258                 :            :         }
     259         [ #  # ]:          0 :         if (strcmp(key, "max_segs_num") == 0) {
     260         [ #  # ]:          0 :                 if (!tmp) {
     261                 :          0 :                         DRV_LOG(ERR, "max_segs_num must be greater than 0.");
     262                 :          0 :                         rte_errno = EINVAL;
     263                 :          0 :                         return -rte_errno;
     264                 :            :                 }
     265                 :          0 :                 devarg_prms->max_segs_num = (uint32_t)tmp;
     266         [ #  # ]:          0 :         } else if (strcmp(key, "import_kek_id") == 0) {
     267                 :          0 :                 attr->session_import_kek_ptr = (uint32_t)tmp;
     268         [ #  # ]:          0 :         } else if (strcmp(key, "credential_id") == 0) {
     269                 :          0 :                 attr->credential_pointer = (uint32_t)tmp;
     270         [ #  # ]:          0 :         } else if (strcmp(key, "keytag") == 0) {
     271                 :          0 :                 devarg_prms->keytag = tmp;
     272         [ #  # ]:          0 :         } else if (strcmp(key, "algo") == 0) {
     273         [ #  # ]:          0 :                 if (tmp == 1) {
     274                 :          0 :                         devarg_prms->is_aes_gcm = 1;
     275         [ #  # ]:          0 :                 } else if (tmp > 1) {
     276                 :          0 :                         DRV_LOG(ERR, "Invalid algo.");
     277                 :          0 :                         rte_errno = EINVAL;
     278                 :          0 :                         return -rte_errno;
     279                 :            :                 }
     280                 :            :         }
     281                 :            :         return 0;
     282                 :            : }
     283                 :            : 
     284                 :            : static int
     285                 :          0 : mlx5_crypto_parse_devargs(struct mlx5_kvargs_ctrl *mkvlist,
     286                 :            :                           struct mlx5_crypto_devarg_params *devarg_prms,
     287                 :            :                           bool wrapped_mode)
     288                 :            : {
     289                 :            :         struct mlx5_devx_crypto_login_attr *attr = &devarg_prms->login_attr;
     290                 :          0 :         const char **params = (const char *[]){
     291                 :            :                 "credential_id",
     292                 :            :                 "import_kek_id",
     293                 :            :                 "keytag",
     294                 :            :                 "max_segs_num",
     295                 :            :                 "wcs_file",
     296                 :            :                 "algo",
     297                 :            :                 NULL,
     298                 :            :         };
     299                 :            : 
     300                 :            :         /* Default values. */
     301                 :          0 :         attr->credential_pointer = 0;
     302                 :          0 :         attr->session_import_kek_ptr = 0;
     303                 :          0 :         devarg_prms->keytag = 0;
     304                 :          0 :         devarg_prms->max_segs_num = 8;
     305         [ #  # ]:          0 :         if (mkvlist == NULL) {
     306         [ #  # ]:          0 :                 if (!wrapped_mode)
     307                 :            :                         return 0;
     308                 :          0 :                 DRV_LOG(ERR,
     309                 :            :                         "No login devargs in order to enable crypto operations in the device.");
     310                 :          0 :                 rte_errno = EINVAL;
     311                 :          0 :                 return -1;
     312                 :            :         }
     313         [ #  # ]:          0 :         if (mlx5_kvargs_process(mkvlist, params, mlx5_crypto_args_check_handler,
     314                 :            :                                 devarg_prms) != 0) {
     315                 :          0 :                 DRV_LOG(ERR, "Devargs handler function Failed.");
     316                 :          0 :                 rte_errno = EINVAL;
     317                 :          0 :                 return -1;
     318                 :            :         }
     319   [ #  #  #  # ]:          0 :         if (devarg_prms->login_devarg == false && wrapped_mode) {
     320                 :          0 :                 DRV_LOG(ERR,
     321                 :            :                         "No login credential devarg in order to enable crypto operations in the device while in wrapped import method.");
     322                 :          0 :                 rte_errno = EINVAL;
     323                 :          0 :                 return -1;
     324                 :            :         }
     325                 :            :         return 0;
     326                 :            : }
     327                 :            : 
     328                 :            : static int
     329                 :          0 : mlx5_crypto_dev_probe(struct mlx5_common_device *cdev,
     330                 :            :                       struct mlx5_kvargs_ctrl *mkvlist)
     331                 :            : {
     332                 :            :         struct rte_cryptodev *crypto_dev;
     333                 :            :         struct mlx5_devx_obj *login;
     334                 :            :         struct mlx5_crypto_priv *priv;
     335                 :          0 :         struct mlx5_crypto_devarg_params devarg_prms = { 0 };
     336                 :          0 :         struct rte_cryptodev_pmd_init_params init_params = {
     337                 :            :                 .name = "",
     338                 :            :                 .private_data_size = sizeof(struct mlx5_crypto_priv),
     339                 :          0 :                 .socket_id = cdev->dev->numa_node,
     340                 :            :                 .max_nb_queue_pairs =
     341                 :            :                                 RTE_CRYPTODEV_PMD_DEFAULT_MAX_NB_QUEUE_PAIRS,
     342                 :            :         };
     343         [ #  # ]:          0 :         const char *ibdev_name = mlx5_os_get_ctx_device_name(cdev->ctx);
     344                 :            :         int ret;
     345                 :            :         bool wrapped_mode;
     346                 :            : 
     347         [ #  # ]:          0 :         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
     348                 :          0 :                 DRV_LOG(ERR, "Non-primary process type is not supported.");
     349                 :          0 :                 rte_errno = ENOTSUP;
     350                 :          0 :                 return -rte_errno;
     351                 :            :         }
     352         [ #  # ]:          0 :         if (!cdev->config.hca_attr.crypto ||
     353         [ #  # ]:          0 :            (!cdev->config.hca_attr.aes_xts &&
     354         [ #  # ]:          0 :             !cdev->config.hca_attr.crypto_mmo.crypto_mmo_qp)) {
     355                 :          0 :                 DRV_LOG(ERR, "Not enough capabilities to support crypto "
     356                 :            :                         "operations, maybe old FW/OFED version?");
     357                 :          0 :                 rte_errno = ENOTSUP;
     358                 :          0 :                 return -ENOTSUP;
     359                 :            :         }
     360                 :          0 :         wrapped_mode = !!cdev->config.hca_attr.crypto_wrapped_import_method;
     361                 :          0 :         ret = mlx5_crypto_parse_devargs(mkvlist, &devarg_prms, wrapped_mode);
     362         [ #  # ]:          0 :         if (ret) {
     363                 :          0 :                 DRV_LOG(ERR, "Failed to parse devargs.");
     364                 :          0 :                 return -rte_errno;
     365                 :            :         }
     366                 :          0 :         crypto_dev = rte_cryptodev_pmd_create(ibdev_name, cdev->dev,
     367                 :            :                                               &init_params);
     368         [ #  # ]:          0 :         if (crypto_dev == NULL) {
     369                 :          0 :                 DRV_LOG(ERR, "Failed to create device \"%s\".", ibdev_name);
     370                 :          0 :                 return -ENODEV;
     371                 :            :         }
     372                 :          0 :         DRV_LOG(INFO,
     373                 :            :                 "Crypto device %s was created successfully.", ibdev_name);
     374                 :          0 :         crypto_dev->dev_ops = &mlx5_crypto_ops;
     375         [ #  # ]:          0 :         crypto_dev->feature_flags = MLX5_CRYPTO_FEATURE_FLAGS(wrapped_mode);
     376                 :          0 :         crypto_dev->driver_id = mlx5_crypto_driver_id;
     377                 :          0 :         priv = crypto_dev->data->dev_private;
     378                 :          0 :         priv->cdev = cdev;
     379                 :          0 :         priv->crypto_dev = crypto_dev;
     380                 :          0 :         priv->is_wrapped_mode = wrapped_mode;
     381                 :          0 :         priv->max_segs_num = devarg_prms.max_segs_num;
     382                 :            :         /* Init and override AES-GCM configuration. */
     383         [ #  # ]:          0 :         if (devarg_prms.is_aes_gcm) {
     384                 :          0 :                 ret = mlx5_crypto_gcm_init(priv);
     385         [ #  # ]:          0 :                 if (ret) {
     386                 :          0 :                         rte_cryptodev_pmd_destroy(priv->crypto_dev);
     387                 :          0 :                         DRV_LOG(ERR, "Failed to init AES-GCM crypto.");
     388                 :          0 :                         return -ENOTSUP;
     389                 :            :                 }
     390                 :            :         } else {
     391                 :          0 :                 ret = mlx5_crypto_xts_init(priv);
     392         [ #  # ]:          0 :                 if (ret) {
     393                 :          0 :                         rte_cryptodev_pmd_destroy(priv->crypto_dev);
     394                 :          0 :                         DRV_LOG(ERR, "Failed to init AES-XTS crypto.");
     395                 :          0 :                         return -ENOTSUP;
     396                 :            :                 }
     397                 :            :         }
     398         [ #  # ]:          0 :         if (mlx5_devx_uar_prepare(cdev, &priv->uar) != 0) {
     399                 :          0 :                 rte_cryptodev_pmd_destroy(priv->crypto_dev);
     400                 :          0 :                 return -1;
     401                 :            :         }
     402         [ #  # ]:          0 :         if (wrapped_mode) {
     403                 :          0 :                 login = mlx5_devx_cmd_create_crypto_login_obj(cdev->ctx,
     404                 :            :                                                       &devarg_prms.login_attr);
     405         [ #  # ]:          0 :                 if (login == NULL) {
     406                 :          0 :                         DRV_LOG(ERR, "Failed to configure login.");
     407                 :          0 :                         mlx5_devx_uar_release(&priv->uar);
     408                 :          0 :                         rte_cryptodev_pmd_destroy(priv->crypto_dev);
     409                 :          0 :                         return -rte_errno;
     410                 :            :                 }
     411                 :          0 :                 priv->login_obj = login;
     412                 :            :         }
     413         [ #  # ]:          0 :         priv->keytag = rte_cpu_to_be_64(devarg_prms.keytag);
     414                 :          0 :         DRV_LOG(INFO, "Max number of segments: %u.",
     415                 :            :                 (unsigned int)RTE_MIN(
     416                 :            :                         MLX5_CRYPTO_KLM_SEGS_NUM(priv->umr_wqe_size),
     417                 :            :                         (uint16_t)(priv->max_rdmar_ds - 2)));
     418                 :          0 :         pthread_mutex_lock(&priv_list_lock);
     419                 :          0 :         TAILQ_INSERT_TAIL(&mlx5_crypto_priv_list, priv, next);
     420                 :          0 :         pthread_mutex_unlock(&priv_list_lock);
     421                 :            : 
     422                 :          0 :         rte_cryptodev_pmd_probing_finish(crypto_dev);
     423                 :            : 
     424                 :          0 :         return 0;
     425                 :            : }
     426                 :            : 
     427                 :            : static int
     428                 :          0 : mlx5_crypto_dev_remove(struct mlx5_common_device *cdev)
     429                 :            : {
     430                 :            :         struct mlx5_crypto_priv *priv = NULL;
     431                 :            : 
     432                 :          0 :         pthread_mutex_lock(&priv_list_lock);
     433         [ #  # ]:          0 :         TAILQ_FOREACH(priv, &mlx5_crypto_priv_list, next)
     434         [ #  # ]:          0 :                 if (priv->crypto_dev->device == cdev->dev)
     435                 :            :                         break;
     436         [ #  # ]:          0 :         if (priv)
     437         [ #  # ]:          0 :                 TAILQ_REMOVE(&mlx5_crypto_priv_list, priv, next);
     438                 :          0 :         pthread_mutex_unlock(&priv_list_lock);
     439         [ #  # ]:          0 :         if (priv) {
     440                 :          0 :                 claim_zero(mlx5_devx_cmd_destroy(priv->login_obj));
     441                 :          0 :                 mlx5_devx_uar_release(&priv->uar);
     442                 :          0 :                 rte_cryptodev_pmd_destroy(priv->crypto_dev);
     443                 :            :         }
     444                 :          0 :         return 0;
     445                 :            : }
     446                 :            : 
     447                 :            : static const struct rte_pci_id mlx5_crypto_pci_id_map[] = {
     448                 :            :                 {
     449                 :            :                         RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
     450                 :            :                                         PCI_DEVICE_ID_MELLANOX_CONNECTX6)
     451                 :            :                 },
     452                 :            :                 {
     453                 :            :                         RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
     454                 :            :                                         PCI_DEVICE_ID_MELLANOX_CONNECTX6DX)
     455                 :            :                 },
     456                 :            :                 {
     457                 :            :                         RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
     458                 :            :                                         PCI_DEVICE_ID_MELLANOX_BLUEFIELD2)
     459                 :            :                 },
     460                 :            :                 {
     461                 :            :                         RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
     462                 :            :                                         PCI_DEVICE_ID_MELLANOX_CONNECTX7)
     463                 :            :                 },
     464                 :            :                 {
     465                 :            :                         RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
     466                 :            :                                         PCI_DEVICE_ID_MELLANOX_BLUEFIELD3)
     467                 :            :                 },
     468                 :            :                 {
     469                 :            :                         .vendor_id = 0
     470                 :            :                 }
     471                 :            : };
     472                 :            : 
     473                 :            : static struct mlx5_class_driver mlx5_crypto_driver = {
     474                 :            :         .drv_class = MLX5_CLASS_CRYPTO,
     475                 :            :         .name = RTE_STR(MLX5_CRYPTO_DRIVER_NAME),
     476                 :            :         .id_table = mlx5_crypto_pci_id_map,
     477                 :            :         .probe = mlx5_crypto_dev_probe,
     478                 :            :         .remove = mlx5_crypto_dev_remove,
     479                 :            : };
     480                 :            : 
     481                 :        235 : RTE_INIT(rte_mlx5_crypto_init)
     482                 :            : {
     483                 :        235 :         pthread_mutex_init(&priv_list_lock, NULL);
     484                 :        235 :         mlx5_common_init();
     485         [ +  - ]:        235 :         if (mlx5_glue != NULL)
     486                 :        235 :                 mlx5_class_driver_register(&mlx5_crypto_driver);
     487                 :        235 : }
     488                 :            : 
     489                 :        235 : RTE_PMD_REGISTER_CRYPTO_DRIVER(mlx5_cryptodev_driver, mlx5_drv,
     490                 :            :                                mlx5_crypto_driver_id);
     491                 :            : 
     492         [ -  + ]:        235 : RTE_LOG_REGISTER_DEFAULT(mlx5_crypto_logtype, NOTICE)
     493                 :            : RTE_PMD_EXPORT_NAME(MLX5_CRYPTO_DRIVER_NAME, __COUNTER__);
     494                 :            : RTE_PMD_REGISTER_PCI_TABLE(MLX5_CRYPTO_DRIVER_NAME, mlx5_crypto_pci_id_map);
     495                 :            : RTE_PMD_REGISTER_KMOD_DEP(MLX5_CRYPTO_DRIVER_NAME, "* ib_uverbs & mlx5_core & mlx5_ib");

Generated by: LCOV version 1.14