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                 .type = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_DUMP_ENABLE,
  16                 .dirty_bitmap_dump_enable = enable,
  17         };
  18         struct mlx5_vdpa_virtq *virtq;
  19
  20         SLIST_FOREACH(virtq, &priv->virtq_list, next) {
  21                 attr.queue_index = virtq->index;
  22                 if (mlx5_devx_cmd_modify_virtq(virtq->virtq, &attr)) {
  23                         DRV_LOG(ERR, "Failed to modify virtq %d logging.",
  24                                 virtq->index);
  25                         return -1;
  26                 }
  27         }
  28         return 0;
  29 }
  30
  31 int
  32 mlx5_vdpa_dirty_bitmap_set(struct mlx5_vdpa_priv *priv, uint64_t log_base,
  33                            uint64_t log_size)
  34 {
  35         struct mlx5_devx_mkey_attr mkey_attr = {
  36                         .addr = (uintptr_t)log_base,
  37                         .size = log_size,
  38                         .pd = priv->pdn,
  39                         .pg_access = 1,
  40                         .klm_array = NULL,
  41                         .klm_num = 0,
  42                         .relaxed_ordering = 0,
  43         };
  44         struct mlx5_devx_virtq_attr attr = {
  45                 .type = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_PARAMS,
  46                 .dirty_bitmap_addr = log_base,
  47                 .dirty_bitmap_size = log_size,
  48         };
  49         struct mlx5_vdpa_query_mr *mr = rte_malloc(__func__, sizeof(*mr), 0);
  50         struct mlx5_vdpa_virtq *virtq;
  51
  52         if (!mr) {
  53                 DRV_LOG(ERR, "Failed to allocate mem for lm mr.");
  54                 return -1;
  55         }
  56         mr->umem = mlx5_glue->devx_umem_reg(priv->ctx,
  57                                             (void *)(uintptr_t)log_base,
  58                                             log_size, IBV_ACCESS_LOCAL_WRITE);
  59         if (!mr->umem) {
  60                 DRV_LOG(ERR, "Failed to register umem for lm mr.");
  61                 goto err;
  62         }
  63         mkey_attr.umem_id = mr->umem->umem_id;
  64         mr->mkey = mlx5_devx_cmd_mkey_create(priv->ctx, &mkey_attr);
  65         if (!mr->mkey) {
  66                 DRV_LOG(ERR, "Failed to create Mkey for lm.");
  67                 goto err;
  68         }
  69         attr.dirty_bitmap_mkey = mr->mkey->id;
  70         SLIST_FOREACH(virtq, &priv->virtq_list, next) {
  71                 attr.queue_index = virtq->index;
  72                 if (mlx5_devx_cmd_modify_virtq(virtq->virtq, &attr)) {
  73                         DRV_LOG(ERR, "Failed to modify virtq %d for lm.",
  74                                 virtq->index);
  75                         goto err;
  76                 }
  77         }
  78         mr->is_indirect = 0;
  79         SLIST_INSERT_HEAD(&priv->mr_list, mr, next);
  80         return 0;
  81 err:
  82         if (mr->mkey)
  83                 mlx5_devx_cmd_destroy(mr->mkey);
  84         if (mr->umem)
  85                 mlx5_glue->devx_umem_dereg(mr->umem);
  86         rte_free(mr);
  87         return -1;
  88 }
  89
  90 #define MLX5_VDPA_USED_RING_LEN(size) \
  91         ((size) * sizeof(struct vring_used_elem) + sizeof(uint16_t) * 3)
  92
  93 int
  94 mlx5_vdpa_lm_log(struct mlx5_vdpa_priv *priv)
  95 {
  96         struct mlx5_devx_virtq_attr attr = {0};
  97         struct mlx5_vdpa_virtq *virtq;
  98         uint64_t features;
  99         int ret = rte_vhost_get_negotiated_features(priv->vid, &features);
 100
 101         if (ret) {
 102                 DRV_LOG(ERR, "Failed to get negotiated features.");
 103                 return -1;
 104         }
 105         if (!RTE_VHOST_NEED_LOG(features))
 106                 return 0;
 107         SLIST_FOREACH(virtq, &priv->virtq_list, next) {
 108                 ret = mlx5_vdpa_virtq_modify(virtq, 0);
 109                 if (ret)
 110                         return -1;
 111                 if (mlx5_devx_cmd_query_virtq(virtq->virtq, &attr)) {
 112                         DRV_LOG(ERR, "Failed to query virtq %d.", virtq->index);
 113                         return -1;
 114                 }
 115                 DRV_LOG(INFO, "Query vid %d vring %d: hw_available_idx=%d, "
 116                         "hw_used_index=%d", priv->vid, virtq->index,
 117                         attr.hw_available_index, attr.hw_used_index);
 118                 ret = rte_vhost_set_vring_base(priv->vid, virtq->index,
 119                                                attr.hw_available_index,
 120                                                attr.hw_used_index);
 121                 if (ret) {
 122                         DRV_LOG(ERR, "Failed to set virtq %d base.",
 123                                 virtq->index);
 124                         return -1;
 125                 }
 126                 rte_vhost_log_used_vring(priv->vid, virtq->index, 0,
 127                                        MLX5_VDPA_USED_RING_LEN(virtq->vq_size));
 128         }
 129         return 0;
 130 }