drivers/vdpa/mlx5/mlx5_vdpa_lm.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2019 Mellanox Technologies, Ltd
   3  */
   4 #include <rte_malloc.h>
   5 #include <rte_errno.h>
   6
   7 #include "mlx5_vdpa_utils.h"
   8 #include "mlx5_vdpa.h"
   9
  10
  11 int
  12 mlx5_vdpa_logging_enable(struct mlx5_vdpa_priv *priv, int enable)
  13 {
  14         struct mlx5_devx_virtq_attr attr = {
  15                 .mod_fields_bitmap =
  16                         MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_DUMP_ENABLE,
  17                 .dirty_bitmap_dump_enable = enable,
  18         };
  19         struct mlx5_vdpa_virtq *virtq;
  20         int i;
  21
  22         for (i = 0; i < priv->nr_virtqs; ++i) {
  23                 attr.queue_index = i;
  24                 virtq = &priv->virtqs[i];
  25                 if (!virtq->configured) {
  26                         DRV_LOG(DEBUG, "virtq %d is invalid for dirty bitmap enabling.", i);
  27                 } else {
  28                         struct mlx5_vdpa_virtq *virtq = &priv->virtqs[i];
  29
  30                         pthread_mutex_lock(&virtq->virtq_lock);
  31                         if (mlx5_devx_cmd_modify_virtq(priv->virtqs[i].virtq,
  32                            &attr)) {
  33                                 pthread_mutex_unlock(&virtq->virtq_lock);
  34                                 DRV_LOG(ERR,
  35                                         "Failed to modify virtq %d for dirty bitmap enabling.",
  36                                         i);
  37                                 return -1;
  38                         }
  39                         pthread_mutex_unlock(&virtq->virtq_lock);
  40                 }
  41         }
  42         return 0;
  43 }
  44
  45 int
  46 mlx5_vdpa_dirty_bitmap_set(struct mlx5_vdpa_priv *priv, uint64_t log_base,
  47                            uint64_t log_size)
  48 {
  49         struct mlx5_devx_virtq_attr attr = {
  50                 .mod_fields_bitmap = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_PARAMS,
  51                 .dirty_bitmap_addr = log_base,
  52                 .dirty_bitmap_size = log_size,
  53         };
  54         struct mlx5_vdpa_virtq *virtq;
  55         int i;
  56         int ret = mlx5_os_wrapped_mkey_create(priv->cdev->ctx, priv->cdev->pd,
  57                                               priv->cdev->pdn,
  58                                               (void *)(uintptr_t)log_base,
  59                                               log_size, &priv->lm_mr);
  60
  61         if (ret) {
  62                 DRV_LOG(ERR, "Failed to allocate wrapped MR for lm.");
  63                 return -1;
  64         }
  65         attr.dirty_bitmap_mkey = priv->lm_mr.lkey;
  66         for (i = 0; i < priv->nr_virtqs; ++i) {
  67                 attr.queue_index = i;
  68                 virtq = &priv->virtqs[i];
  69                 if (!virtq->configured) {
  70                         DRV_LOG(DEBUG, "virtq %d is invalid for LM.", i);
  71                 } else {
  72                         struct mlx5_vdpa_virtq *virtq = &priv->virtqs[i];
  73
  74                         pthread_mutex_lock(&virtq->virtq_lock);
  75                         if (mlx5_devx_cmd_modify_virtq(
  76                                         priv->virtqs[i].virtq,
  77                                         &attr)) {
  78                                 pthread_mutex_unlock(&virtq->virtq_lock);
  79                                 DRV_LOG(ERR,
  80                                 "Failed to modify virtq %d for LM.", i);
  81                                 goto err;
  82                         }
  83                         pthread_mutex_unlock(&virtq->virtq_lock);
  84                 }
  85         }
  86         return 0;
  87 err:
  88         mlx5_os_wrapped_mkey_destroy(&priv->lm_mr);
  89         return -1;
  90 }
  91
  92 #define MLX5_VDPA_USED_RING_LEN(size) \
  93         ((size) * sizeof(struct vring_used_elem) + sizeof(uint16_t) * 3)
  94
  95 int
  96 mlx5_vdpa_lm_log(struct mlx5_vdpa_priv *priv)
  97 {
  98         struct mlx5_vdpa_virtq *virtq;
  99         uint64_t features;
 100         int ret = rte_vhost_get_negotiated_features(priv->vid, &features);
 101         int i;
 102
 103         if (ret) {
 104                 DRV_LOG(ERR, "Failed to get negotiated features.");
 105                 return -1;
 106         }
 107         if (!RTE_VHOST_NEED_LOG(features))
 108                 return 0;
 109         for (i = 0; i < priv->nr_virtqs; ++i) {
 110                 virtq = &priv->virtqs[i];
 111                 if (!priv->virtqs[i].virtq) {
 112                         DRV_LOG(DEBUG, "virtq %d is invalid for LM log.", i);
 113                 } else {
 114                         pthread_mutex_lock(&virtq->virtq_lock);
 115                         ret = mlx5_vdpa_virtq_stop(priv, i);
 116                         pthread_mutex_unlock(&virtq->virtq_lock);
 117                         if (ret) {
 118                                 DRV_LOG(ERR, "Failed to stop virtq %d for LM "
 119                                         "log.", i);
 120                                 return -1;
 121                         }
 122                 }
 123                 rte_vhost_log_used_vring(priv->vid, i, 0,
 124                               MLX5_VDPA_USED_RING_LEN(priv->virtqs[i].vq_size));
 125         }
 126         return 0;
 127 }