vdpa/mlx5: add task ring for multi-thread management

[dpdk.git] / drivers / vdpa / mlx5 / mlx5_vdpa_lm.c

diff --git a/drivers/vdpa/mlx5/mlx5_vdpa_lm.c b/drivers/vdpa/mlx5/mlx5_vdpa_lm.c
index 0b0ffeb..bfa5d4d 100644 (file)
--- a/drivers/vdpa/mlx5/mlx5_vdpa_lm.c
+++ b/drivers/vdpa/mlx5/mlx5_vdpa_lm.c
@@ -12,21 +12,31 @@ int
 mlx5_vdpa_logging_enable(struct mlx5_vdpa_priv *priv, int enable)
 {
        struct mlx5_devx_virtq_attr attr = {
-               .type = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_DUMP_ENABLE,
+               .mod_fields_bitmap =
+                       MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_DUMP_ENABLE,
                .dirty_bitmap_dump_enable = enable,
        };
+       struct mlx5_vdpa_virtq *virtq;
        int i;
 
        for (i = 0; i < priv->nr_virtqs; ++i) {
                attr.queue_index = i;
-               if (!priv->virtqs[i].virtq) {
-                       DRV_LOG(DEBUG, "virtq %d is invalid for dirty bitmap "
-                               "enabling.", i);
-               } else if (mlx5_devx_cmd_modify_virtq(priv->virtqs[i].virtq,
+               virtq = &priv->virtqs[i];
+               if (!virtq->configured) {
+                       DRV_LOG(DEBUG, "virtq %d is invalid for dirty bitmap enabling.", i);
+               } else {
+                       struct mlx5_vdpa_virtq *virtq = &priv->virtqs[i];
+
+                       pthread_mutex_lock(&virtq->virtq_lock);
+                       if (mlx5_devx_cmd_modify_virtq(priv->virtqs[i].virtq,
                           &attr)) {
-                       DRV_LOG(ERR, "Failed to modify virtq %d for dirty "
-                               "bitmap enabling.", i);
-                       return -1;
+                               pthread_mutex_unlock(&virtq->virtq_lock);
+                               DRV_LOG(ERR,
+                                       "Failed to modify virtq %d for dirty bitmap enabling.",
+                                       i);
+                               return -1;
+                       }
+                       pthread_mutex_unlock(&virtq->virtq_lock);
                }
        }
        return 0;
@@ -36,57 +46,46 @@ int
 mlx5_vdpa_dirty_bitmap_set(struct mlx5_vdpa_priv *priv, uint64_t log_base,
                           uint64_t log_size)
 {
-       struct mlx5_devx_mkey_attr mkey_attr = {
-                       .addr = (uintptr_t)log_base,
-                       .size = log_size,
-                       .pd = priv->pdn,
-                       .pg_access = 1,
-       };
        struct mlx5_devx_virtq_attr attr = {
-               .type = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_PARAMS,
+               .mod_fields_bitmap = MLX5_VIRTQ_MODIFY_TYPE_DIRTY_BITMAP_PARAMS,
                .dirty_bitmap_addr = log_base,
                .dirty_bitmap_size = log_size,
        };
-       struct mlx5_vdpa_query_mr *mr = rte_malloc(__func__, sizeof(*mr), 0);
+       struct mlx5_vdpa_virtq *virtq;
        int i;
+       int ret = mlx5_os_wrapped_mkey_create(priv->cdev->ctx, priv->cdev->pd,
+                                             priv->cdev->pdn,
+                                             (void *)(uintptr_t)log_base,
+                                             log_size, &priv->lm_mr);
 
-       if (!mr) {
-               DRV_LOG(ERR, "Failed to allocate mem for lm mr.");
+       if (ret) {
+               DRV_LOG(ERR, "Failed to allocate wrapped MR for lm.");
                return -1;
        }
-       mr->umem = mlx5_glue->devx_umem_reg(priv->cdev->ctx,
-                                           (void *)(uintptr_t)log_base,
-                                           log_size, IBV_ACCESS_LOCAL_WRITE);
-       if (!mr->umem) {
-               DRV_LOG(ERR, "Failed to register umem for lm mr.");
-               goto err;
-       }
-       mkey_attr.umem_id = mr->umem->umem_id;
-       mr->mkey = mlx5_devx_cmd_mkey_create(priv->cdev->ctx, &mkey_attr);
-       if (!mr->mkey) {
-               DRV_LOG(ERR, "Failed to create Mkey for lm.");
-               goto err;
-       }
-       attr.dirty_bitmap_mkey = mr->mkey->id;
+       attr.dirty_bitmap_mkey = priv->lm_mr.lkey;
        for (i = 0; i < priv->nr_virtqs; ++i) {
                attr.queue_index = i;
-               if (!priv->virtqs[i].virtq) {
+               virtq = &priv->virtqs[i];
+               if (!virtq->configured) {
                        DRV_LOG(DEBUG, "virtq %d is invalid for LM.", i);
-               } else if (mlx5_devx_cmd_modify_virtq(priv->virtqs[i].virtq,
-                                                     &attr)) {
-                       DRV_LOG(ERR, "Failed to modify virtq %d for LM.", i);
-                       goto err;
+               } else {
+                       struct mlx5_vdpa_virtq *virtq = &priv->virtqs[i];
+
+                       pthread_mutex_lock(&virtq->virtq_lock);
+                       if (mlx5_devx_cmd_modify_virtq(
+                                       priv->virtqs[i].virtq,
+                                       &attr)) {
+                               pthread_mutex_unlock(&virtq->virtq_lock);
+                               DRV_LOG(ERR,
+                               "Failed to modify virtq %d for LM.", i);
+                               goto err;
+                       }
+                       pthread_mutex_unlock(&virtq->virtq_lock);
                }
        }
-       mr->is_indirect = 0;
-       SLIST_INSERT_HEAD(&priv->mr_list, mr, next);
        return 0;
 err:
-       if (mr->mkey)
-               mlx5_devx_cmd_destroy(mr->mkey);
-       if (mr->umem)
-               mlx5_glue->devx_umem_dereg(mr->umem);
-       rte_free(mr);
+       mlx5_os_wrapped_mkey_destroy(&priv->lm_mr);
        return -1;
 }
 
@@ -96,6 +95,7 @@ err:
 int
 mlx5_vdpa_lm_log(struct mlx5_vdpa_priv *priv)
 {
+       struct mlx5_vdpa_virtq *virtq;
        uint64_t features;
        int ret = rte_vhost_get_negotiated_features(priv->vid, &features);
        int i;
@@ -107,10 +107,13 @@ mlx5_vdpa_lm_log(struct mlx5_vdpa_priv *priv)
        if (!RTE_VHOST_NEED_LOG(features))
                return 0;
        for (i = 0; i < priv->nr_virtqs; ++i) {
+               virtq = &priv->virtqs[i];
                if (!priv->virtqs[i].virtq) {
                        DRV_LOG(DEBUG, "virtq %d is invalid for LM log.", i);
                } else {
+                       pthread_mutex_lock(&virtq->virtq_lock);
                        ret = mlx5_vdpa_virtq_stop(priv, i);
+                       pthread_mutex_unlock(&virtq->virtq_lock);
                        if (ret) {
                                DRV_LOG(ERR, "Failed to stop virtq %d for LM "
                                        "log.", i);