1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2019 Mellanox Technologies, Ltd
6 #include <sys/socket.h>
10 #include <netinet/in.h>
12 #include <rte_malloc.h>
14 #include <rte_errno.h>
15 #include <rte_string_fns.h>
16 #include <rte_bus_pci.h>
17 #include <rte_eal_paging.h>
19 #include <mlx5_glue.h>
20 #include <mlx5_common.h>
21 #include <mlx5_common_defs.h>
22 #include <mlx5_devx_cmds.h>
26 #include "mlx5_vdpa_utils.h"
27 #include "mlx5_vdpa.h"
29 #define MLX5_VDPA_DRIVER_NAME vdpa_mlx5
31 #define MLX5_VDPA_DEFAULT_FEATURES ((1ULL << VHOST_USER_F_PROTOCOL_FEATURES) | \
32 (1ULL << VIRTIO_F_ANY_LAYOUT) | \
33 (1ULL << VIRTIO_NET_F_MQ) | \
34 (1ULL << VIRTIO_NET_F_GUEST_ANNOUNCE) | \
35 (1ULL << VIRTIO_F_ORDER_PLATFORM) | \
36 (1ULL << VHOST_F_LOG_ALL) | \
37 (1ULL << VIRTIO_NET_F_MTU))
39 #define MLX5_VDPA_PROTOCOL_FEATURES \
40 ((1ULL << VHOST_USER_PROTOCOL_F_SLAVE_REQ) | \
41 (1ULL << VHOST_USER_PROTOCOL_F_SLAVE_SEND_FD) | \
42 (1ULL << VHOST_USER_PROTOCOL_F_HOST_NOTIFIER) | \
43 (1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD) | \
44 (1ULL << VHOST_USER_PROTOCOL_F_MQ) | \
45 (1ULL << VHOST_USER_PROTOCOL_F_NET_MTU) | \
46 (1ULL << VHOST_USER_PROTOCOL_F_STATUS))
48 #define MLX5_VDPA_DEFAULT_NO_TRAFFIC_MAX 16LLU
50 TAILQ_HEAD(mlx5_vdpa_privs, mlx5_vdpa_priv) priv_list =
51 TAILQ_HEAD_INITIALIZER(priv_list);
52 static pthread_mutex_t priv_list_lock = PTHREAD_MUTEX_INITIALIZER;
54 static void mlx5_vdpa_dev_release(struct mlx5_vdpa_priv *priv);
56 static struct mlx5_vdpa_priv *
57 mlx5_vdpa_find_priv_resource_by_vdev(struct rte_vdpa_device *vdev)
59 struct mlx5_vdpa_priv *priv;
62 pthread_mutex_lock(&priv_list_lock);
63 TAILQ_FOREACH(priv, &priv_list, next) {
64 if (vdev == priv->vdev) {
69 pthread_mutex_unlock(&priv_list_lock);
71 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
79 mlx5_vdpa_get_queue_num(struct rte_vdpa_device *vdev, uint32_t *queue_num)
81 struct mlx5_vdpa_priv *priv =
82 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
85 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
88 *queue_num = priv->caps.max_num_virtio_queues / 2;
93 mlx5_vdpa_get_vdpa_features(struct rte_vdpa_device *vdev, uint64_t *features)
95 struct mlx5_vdpa_priv *priv =
96 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
99 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
102 *features = MLX5_VDPA_DEFAULT_FEATURES;
103 if (priv->caps.virtio_queue_type & (1 << MLX5_VIRTQ_TYPE_PACKED))
104 *features |= (1ULL << VIRTIO_F_RING_PACKED);
105 if (priv->caps.tso_ipv4)
106 *features |= (1ULL << VIRTIO_NET_F_HOST_TSO4);
107 if (priv->caps.tso_ipv6)
108 *features |= (1ULL << VIRTIO_NET_F_HOST_TSO6);
109 if (priv->caps.tx_csum)
110 *features |= (1ULL << VIRTIO_NET_F_CSUM);
111 if (priv->caps.rx_csum)
112 *features |= (1ULL << VIRTIO_NET_F_GUEST_CSUM);
113 if (priv->caps.virtio_version_1_0)
114 *features |= (1ULL << VIRTIO_F_VERSION_1);
119 mlx5_vdpa_get_protocol_features(struct rte_vdpa_device *vdev,
122 struct mlx5_vdpa_priv *priv =
123 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
126 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
129 *features = MLX5_VDPA_PROTOCOL_FEATURES;
134 mlx5_vdpa_set_vring_state(int vid, int vring, int state)
136 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
137 struct mlx5_vdpa_priv *priv =
138 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
142 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
145 if (vring >= (int)priv->caps.max_num_virtio_queues) {
146 DRV_LOG(ERR, "Too big vring id: %d.", vring);
149 pthread_mutex_lock(&priv->vq_config_lock);
150 ret = mlx5_vdpa_virtq_enable(priv, vring, state);
151 pthread_mutex_unlock(&priv->vq_config_lock);
156 mlx5_vdpa_features_set(int vid)
158 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
159 struct mlx5_vdpa_priv *priv =
160 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
161 uint64_t log_base, log_size;
166 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
169 ret = rte_vhost_get_negotiated_features(vid, &features);
171 DRV_LOG(ERR, "Failed to get negotiated features.");
174 if (RTE_VHOST_NEED_LOG(features)) {
175 ret = rte_vhost_get_log_base(vid, &log_base, &log_size);
177 DRV_LOG(ERR, "Failed to get log base.");
180 ret = mlx5_vdpa_dirty_bitmap_set(priv, log_base, log_size);
182 DRV_LOG(ERR, "Failed to set dirty bitmap.");
185 DRV_LOG(INFO, "mlx5 vdpa: enabling dirty logging...");
186 ret = mlx5_vdpa_logging_enable(priv, 1);
188 DRV_LOG(ERR, "Failed t enable dirty logging.");
196 mlx5_vdpa_mtu_set(struct mlx5_vdpa_priv *priv)
198 struct ifreq request;
199 uint16_t vhost_mtu = 0;
200 uint16_t kern_mtu = 0;
201 int ret = rte_vhost_get_mtu(priv->vid, &vhost_mtu);
203 int retries = MLX5_VDPA_MAX_RETRIES;
206 DRV_LOG(DEBUG, "Cannot get vhost MTU - %d.", ret);
210 DRV_LOG(DEBUG, "Vhost MTU is 0.");
213 ret = mlx5_get_ifname_sysfs
214 (mlx5_os_get_ctx_device_name(priv->cdev->ctx),
217 DRV_LOG(DEBUG, "Cannot get kernel IF name - %d.", ret);
220 sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
222 DRV_LOG(DEBUG, "Cannot open IF socket.");
226 ret = ioctl(sock, SIOCGIFMTU, &request);
229 kern_mtu = request.ifr_mtu;
230 DRV_LOG(DEBUG, "MTU: current %d requested %d.", (int)kern_mtu,
232 if (kern_mtu == vhost_mtu)
234 request.ifr_mtu = vhost_mtu;
235 ret = ioctl(sock, SIOCSIFMTU, &request);
239 usleep(MLX5_VDPA_USEC);
242 return kern_mtu == vhost_mtu ? 0 : -1;
246 mlx5_vdpa_dev_cache_clean(struct mlx5_vdpa_priv *priv)
248 /* Clean pre-created resource in dev removal only. */
250 mlx5_vdpa_virtqs_cleanup(priv);
251 mlx5_vdpa_mem_dereg(priv);
255 mlx5_vdpa_dev_close(int vid)
257 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
258 struct mlx5_vdpa_priv *priv =
259 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
263 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
266 mlx5_vdpa_cqe_event_unset(priv);
267 if (priv->state == MLX5_VDPA_STATE_CONFIGURED) {
268 ret |= mlx5_vdpa_lm_log(priv);
269 priv->state = MLX5_VDPA_STATE_IN_PROGRESS;
271 mlx5_vdpa_steer_unset(priv);
272 mlx5_vdpa_virtqs_release(priv);
273 mlx5_vdpa_drain_cq(priv);
274 if (priv->lm_mr.addr)
275 mlx5_os_wrapped_mkey_destroy(&priv->lm_mr);
276 priv->state = MLX5_VDPA_STATE_PROBED;
277 if (!priv->connected)
278 mlx5_vdpa_dev_cache_clean(priv);
280 /* The mutex may stay locked after event thread cancel - initiate it. */
281 pthread_mutex_init(&priv->vq_config_lock, NULL);
282 DRV_LOG(INFO, "vDPA device %d was closed.", vid);
287 mlx5_vdpa_dev_config(int vid)
289 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
290 struct mlx5_vdpa_priv *priv =
291 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
294 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
297 if (priv->state == MLX5_VDPA_STATE_CONFIGURED &&
298 mlx5_vdpa_dev_close(vid)) {
299 DRV_LOG(ERR, "Failed to reconfigure vid %d.", vid);
303 priv->connected = true;
304 if (mlx5_vdpa_mtu_set(priv))
305 DRV_LOG(WARNING, "MTU cannot be set on device %s.",
307 if (mlx5_vdpa_mem_register(priv) ||
308 mlx5_vdpa_virtqs_prepare(priv) || mlx5_vdpa_steer_setup(priv) ||
309 mlx5_vdpa_cqe_event_setup(priv)) {
310 mlx5_vdpa_dev_close(vid);
313 priv->state = MLX5_VDPA_STATE_CONFIGURED;
314 DRV_LOG(INFO, "vDPA device %d was configured.", vid);
319 mlx5_vdpa_get_device_fd(int vid)
321 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
322 struct mlx5_vdpa_priv *priv =
323 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
326 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
329 return ((struct ibv_context *)priv->cdev->ctx)->cmd_fd;
333 mlx5_vdpa_get_notify_area(int vid, int qid, uint64_t *offset, uint64_t *size)
335 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
336 struct mlx5_vdpa_priv *priv =
337 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
341 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
345 DRV_LOG(ERR, "VAR was not created for device %s, is the device"
346 " configured?.", vdev->device->name);
349 *offset = priv->var->mmap_off;
350 *size = priv->var->length;
355 mlx5_vdpa_get_stats_names(struct rte_vdpa_device *vdev,
356 struct rte_vdpa_stat_name *stats_names,
359 static const char *mlx5_vdpa_stats_names[MLX5_VDPA_STATS_MAX] = {
360 "received_descriptors",
361 "completed_descriptors",
362 "bad descriptor errors",
367 struct mlx5_vdpa_priv *priv =
368 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
372 DRV_LOG(ERR, "Invalid device: %s.", vdev->device->name);
376 return MLX5_VDPA_STATS_MAX;
377 size = RTE_MIN(size, (unsigned int)MLX5_VDPA_STATS_MAX);
378 for (i = 0; i < size; ++i)
379 strlcpy(stats_names[i].name, mlx5_vdpa_stats_names[i],
380 RTE_VDPA_STATS_NAME_SIZE);
385 mlx5_vdpa_get_stats(struct rte_vdpa_device *vdev, int qid,
386 struct rte_vdpa_stat *stats, unsigned int n)
388 struct mlx5_vdpa_priv *priv =
389 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
392 DRV_LOG(ERR, "Invalid device: %s.", vdev->device->name);
395 if (qid >= (int)priv->caps.max_num_virtio_queues) {
396 DRV_LOG(ERR, "Too big vring id: %d for device %s.", qid,
400 if (!priv->caps.queue_counters_valid) {
401 DRV_LOG(ERR, "Virtq statistics is not supported for device %s.",
405 return mlx5_vdpa_virtq_stats_get(priv, qid, stats, n);
409 mlx5_vdpa_reset_stats(struct rte_vdpa_device *vdev, int qid)
411 struct mlx5_vdpa_priv *priv =
412 mlx5_vdpa_find_priv_resource_by_vdev(vdev);
415 DRV_LOG(ERR, "Invalid device: %s.", vdev->device->name);
418 if (qid >= (int)priv->caps.max_num_virtio_queues) {
419 DRV_LOG(ERR, "Too big vring id: %d for device %s.", qid,
423 if (!priv->caps.queue_counters_valid) {
424 DRV_LOG(ERR, "Virtq statistics is not supported for device %s.",
428 return mlx5_vdpa_virtq_stats_reset(priv, qid);
432 mlx5_vdpa_dev_cleanup(int vid)
434 struct rte_vdpa_device *vdev = rte_vhost_get_vdpa_device(vid);
435 struct mlx5_vdpa_priv *priv;
439 priv = mlx5_vdpa_find_priv_resource_by_vdev(vdev);
441 DRV_LOG(ERR, "Invalid vDPA device: %s.", vdev->device->name);
444 if (priv->state == MLX5_VDPA_STATE_PROBED)
445 mlx5_vdpa_dev_cache_clean(priv);
446 priv->connected = false;
450 static struct rte_vdpa_dev_ops mlx5_vdpa_ops = {
451 .get_queue_num = mlx5_vdpa_get_queue_num,
452 .get_features = mlx5_vdpa_get_vdpa_features,
453 .get_protocol_features = mlx5_vdpa_get_protocol_features,
454 .dev_conf = mlx5_vdpa_dev_config,
455 .dev_close = mlx5_vdpa_dev_close,
456 .dev_cleanup = mlx5_vdpa_dev_cleanup,
457 .set_vring_state = mlx5_vdpa_set_vring_state,
458 .set_features = mlx5_vdpa_features_set,
459 .migration_done = NULL,
460 .get_vfio_group_fd = NULL,
461 .get_vfio_device_fd = mlx5_vdpa_get_device_fd,
462 .get_notify_area = mlx5_vdpa_get_notify_area,
463 .get_stats_names = mlx5_vdpa_get_stats_names,
464 .get_stats = mlx5_vdpa_get_stats,
465 .reset_stats = mlx5_vdpa_reset_stats,
469 mlx5_vdpa_args_check_handler(const char *key, const char *val, void *opaque)
471 struct mlx5_vdpa_priv *priv = opaque;
473 int n_cores = sysconf(_SC_NPROCESSORS_ONLN);
476 tmp = strtoul(val, NULL, 0);
478 DRV_LOG(WARNING, "%s: \"%s\" is an invalid integer.", key, val);
481 if (strcmp(key, "event_mode") == 0) {
482 if (tmp <= MLX5_VDPA_EVENT_MODE_ONLY_INTERRUPT)
483 priv->event_mode = (int)tmp;
485 DRV_LOG(WARNING, "Invalid event_mode %s.", val);
486 } else if (strcmp(key, "event_us") == 0) {
487 priv->event_us = (uint32_t)tmp;
488 } else if (strcmp(key, "no_traffic_time") == 0) {
489 priv->no_traffic_max = (uint32_t)tmp;
490 } else if (strcmp(key, "event_core") == 0) {
491 if (tmp >= (unsigned long)n_cores)
492 DRV_LOG(WARNING, "Invalid event_core %s.", val);
494 priv->event_core = tmp;
495 } else if (strcmp(key, "hw_latency_mode") == 0) {
496 priv->hw_latency_mode = (uint32_t)tmp;
497 } else if (strcmp(key, "hw_max_latency_us") == 0) {
498 priv->hw_max_latency_us = (uint32_t)tmp;
499 } else if (strcmp(key, "hw_max_pending_comp") == 0) {
500 priv->hw_max_pending_comp = (uint32_t)tmp;
501 } else if (strcmp(key, "queue_size") == 0) {
502 priv->queue_size = (uint16_t)tmp;
503 } else if (strcmp(key, "queues") == 0) {
504 priv->queues = (uint16_t)tmp;
506 DRV_LOG(WARNING, "Invalid key %s.", key);
512 mlx5_vdpa_config_get(struct mlx5_kvargs_ctrl *mkvlist,
513 struct mlx5_vdpa_priv *priv)
515 const char **params = (const char *[]){
521 "hw_max_pending_comp",
526 priv->event_mode = MLX5_VDPA_EVENT_MODE_FIXED_TIMER;
528 priv->event_core = -1;
529 priv->no_traffic_max = MLX5_VDPA_DEFAULT_NO_TRAFFIC_MAX;
532 mlx5_kvargs_process(mkvlist, params, mlx5_vdpa_args_check_handler,
534 if (!priv->event_us &&
535 priv->event_mode == MLX5_VDPA_EVENT_MODE_DYNAMIC_TIMER)
536 priv->event_us = MLX5_VDPA_DEFAULT_TIMER_STEP_US;
537 if ((priv->queue_size && !priv->queues) ||
538 (!priv->queue_size && priv->queues)) {
539 priv->queue_size = 0;
541 DRV_LOG(WARNING, "Please provide both queue_size and queues.");
543 DRV_LOG(DEBUG, "event mode is %d.", priv->event_mode);
544 DRV_LOG(DEBUG, "event_us is %u us.", priv->event_us);
545 DRV_LOG(DEBUG, "no traffic max is %u.", priv->no_traffic_max);
546 DRV_LOG(DEBUG, "queues is %u, queue_size is %u.", priv->queues,
551 mlx5_vdpa_virtq_resource_prepare(struct mlx5_vdpa_priv *priv)
558 for (index = 0; index < (priv->queues * 2); ++index) {
559 struct mlx5_vdpa_virtq *virtq = &priv->virtqs[index];
560 int ret = mlx5_vdpa_event_qp_prepare(priv, priv->queue_size,
564 DRV_LOG(ERR, "Failed to create event QPs for virtq %d.",
568 if (priv->caps.queue_counters_valid) {
569 if (!virtq->counters)
571 mlx5_devx_cmd_create_virtio_q_counters
573 if (!virtq->counters) {
574 DRV_LOG(ERR, "Failed to create virtq couners for virtq"
579 for (i = 0; i < RTE_DIM(virtq->umems); ++i) {
582 struct mlx5dv_devx_umem *obj;
584 size = priv->caps.umems[i].a * priv->queue_size +
585 priv->caps.umems[i].b;
586 buf = rte_zmalloc(__func__, size, 4096);
588 DRV_LOG(ERR, "Cannot allocate umem %d memory for virtq"
592 obj = mlx5_glue->devx_umem_reg(priv->cdev->ctx, buf,
593 size, IBV_ACCESS_LOCAL_WRITE);
596 DRV_LOG(ERR, "Failed to register umem %d for virtq %u.",
600 virtq->umems[i].size = size;
601 virtq->umems[i].buf = buf;
602 virtq->umems[i].obj = obj;
609 mlx5_vdpa_create_dev_resources(struct mlx5_vdpa_priv *priv)
611 struct mlx5_devx_tis_attr tis_attr = {0};
612 struct ibv_context *ctx = priv->cdev->ctx;
616 for (retry = 0; retry < 7; retry++) {
617 priv->var = mlx5_glue->dv_alloc_var(ctx, 0);
618 if (priv->var != NULL)
620 DRV_LOG(WARNING, "Failed to allocate VAR, retry %d.", retry);
621 /* Wait Qemu release VAR during vdpa restart, 0.1 sec based. */
622 usleep(100000U << retry);
625 DRV_LOG(ERR, "Failed to allocate VAR %u.", errno);
629 /* Always map the entire page. */
630 priv->virtq_db_addr = mmap(NULL, priv->var->length, PROT_READ |
631 PROT_WRITE, MAP_SHARED, ctx->cmd_fd,
632 priv->var->mmap_off);
633 if (priv->virtq_db_addr == MAP_FAILED) {
634 DRV_LOG(ERR, "Failed to map doorbell page %u.", errno);
635 priv->virtq_db_addr = NULL;
639 /* Add within page offset for 64K page system. */
640 priv->virtq_db_addr = (char *)priv->virtq_db_addr +
641 ((rte_mem_page_size() - 1) & priv->caps.doorbell_bar_offset);
642 DRV_LOG(DEBUG, "VAR address of doorbell mapping is %p.",
643 priv->virtq_db_addr);
644 priv->td = mlx5_devx_cmd_create_td(ctx);
646 DRV_LOG(ERR, "Failed to create transport domain.");
650 tis_attr.transport_domain = priv->td->id;
651 for (i = 0; i < priv->num_lag_ports; i++) {
652 /* 0 is auto affinity, non-zero value to propose port. */
653 tis_attr.lag_tx_port_affinity = i + 1;
654 priv->tiss[i] = mlx5_devx_cmd_create_tis(ctx, &tis_attr);
655 if (!priv->tiss[i]) {
656 DRV_LOG(ERR, "Failed to create TIS %u.", i);
660 priv->null_mr = mlx5_glue->alloc_null_mr(priv->cdev->pd);
661 if (!priv->null_mr) {
662 DRV_LOG(ERR, "Failed to allocate null MR.");
666 DRV_LOG(DEBUG, "Dump fill Mkey = %u.", priv->null_mr->lkey);
667 #ifdef HAVE_MLX5DV_DR
668 priv->steer.domain = mlx5_glue->dr_create_domain(ctx,
669 MLX5DV_DR_DOMAIN_TYPE_NIC_RX);
670 if (!priv->steer.domain) {
671 DRV_LOG(ERR, "Failed to create Rx domain.");
676 priv->steer.tbl = mlx5_glue->dr_create_flow_tbl(priv->steer.domain, 0);
677 if (!priv->steer.tbl) {
678 DRV_LOG(ERR, "Failed to create table 0 with Rx domain.");
682 if (mlx5_vdpa_err_event_setup(priv) != 0)
684 if (mlx5_vdpa_event_qp_global_prepare(priv))
686 if (mlx5_vdpa_virtq_resource_prepare(priv))
692 mlx5_vdpa_dev_probe(struct mlx5_common_device *cdev,
693 struct mlx5_kvargs_ctrl *mkvlist)
695 struct mlx5_vdpa_priv *priv = NULL;
696 struct mlx5_hca_attr *attr = &cdev->config.hca_attr;
698 if (!attr->vdpa.valid || !attr->vdpa.max_num_virtio_queues) {
699 DRV_LOG(ERR, "Not enough capabilities to support vdpa, maybe "
700 "old FW/OFED version?");
704 if (!attr->vdpa.queue_counters_valid)
705 DRV_LOG(DEBUG, "No capability to support virtq statistics.");
706 priv = rte_zmalloc("mlx5 vDPA device private", sizeof(*priv) +
707 sizeof(struct mlx5_vdpa_virtq) *
708 attr->vdpa.max_num_virtio_queues,
709 RTE_CACHE_LINE_SIZE);
711 DRV_LOG(ERR, "Failed to allocate private memory.");
715 priv->caps = attr->vdpa;
716 priv->log_max_rqt_size = attr->log_max_rqt_size;
717 priv->num_lag_ports = attr->num_lag_ports;
718 if (attr->num_lag_ports == 0)
719 priv->num_lag_ports = 1;
720 pthread_mutex_init(&priv->vq_config_lock, NULL);
722 mlx5_vdpa_config_get(mkvlist, priv);
723 if (mlx5_vdpa_create_dev_resources(priv))
725 priv->vdev = rte_vdpa_register_device(cdev->dev, &mlx5_vdpa_ops);
726 if (priv->vdev == NULL) {
727 DRV_LOG(ERR, "Failed to register vDPA device.");
728 rte_errno = rte_errno ? rte_errno : EINVAL;
731 SLIST_INIT(&priv->mr_list);
732 pthread_mutex_lock(&priv_list_lock);
733 TAILQ_INSERT_TAIL(&priv_list, priv, next);
734 pthread_mutex_unlock(&priv_list_lock);
738 mlx5_vdpa_dev_release(priv);
743 mlx5_vdpa_dev_remove(struct mlx5_common_device *cdev)
745 struct mlx5_vdpa_priv *priv = NULL;
748 pthread_mutex_lock(&priv_list_lock);
749 TAILQ_FOREACH(priv, &priv_list, next) {
750 if (priv->vdev->device == cdev->dev) {
756 TAILQ_REMOVE(&priv_list, priv, next);
757 pthread_mutex_unlock(&priv_list_lock);
759 mlx5_vdpa_dev_release(priv);
764 mlx5_vdpa_release_dev_resources(struct mlx5_vdpa_priv *priv)
769 mlx5_vdpa_virtqs_cleanup(priv);
770 mlx5_vdpa_dev_cache_clean(priv);
771 for (i = 0; i < priv->caps.max_num_virtio_queues; i++) {
772 if (!priv->virtqs[i].counters)
774 claim_zero(mlx5_devx_cmd_destroy(priv->virtqs[i].counters));
776 mlx5_vdpa_event_qp_global_release(priv);
777 mlx5_vdpa_err_event_unset(priv);
779 claim_zero(mlx5_glue->dr_destroy_flow_tbl(priv->steer.tbl));
780 if (priv->steer.domain)
781 claim_zero(mlx5_glue->dr_destroy_domain(priv->steer.domain));
783 claim_zero(mlx5_glue->dereg_mr(priv->null_mr));
784 for (i = 0; i < priv->num_lag_ports; i++) {
786 claim_zero(mlx5_devx_cmd_destroy(priv->tiss[i]));
789 claim_zero(mlx5_devx_cmd_destroy(priv->td));
790 if (priv->virtq_db_addr)
791 /* Mask out the within page offset for munmap. */
792 claim_zero(munmap((void *)((uintptr_t)priv->virtq_db_addr &
793 ~(rte_mem_page_size() - 1)), priv->var->length));
795 mlx5_glue->dv_free_var(priv->var);
799 mlx5_vdpa_dev_release(struct mlx5_vdpa_priv *priv)
801 if (priv->state == MLX5_VDPA_STATE_CONFIGURED)
802 mlx5_vdpa_dev_close(priv->vid);
803 mlx5_vdpa_release_dev_resources(priv);
805 rte_vdpa_unregister_device(priv->vdev);
806 pthread_mutex_destroy(&priv->vq_config_lock);
810 static const struct rte_pci_id mlx5_vdpa_pci_id_map[] = {
812 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
813 PCI_DEVICE_ID_MELLANOX_CONNECTX6)
816 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
817 PCI_DEVICE_ID_MELLANOX_CONNECTX6VF)
820 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
821 PCI_DEVICE_ID_MELLANOX_CONNECTX6DX)
824 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
825 PCI_DEVICE_ID_MELLANOX_CONNECTXVF)
828 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
829 PCI_DEVICE_ID_MELLANOX_CONNECTX6DXBF)
832 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
833 PCI_DEVICE_ID_MELLANOX_CONNECTX7)
836 RTE_PCI_DEVICE(PCI_VENDOR_ID_MELLANOX,
837 PCI_DEVICE_ID_MELLANOX_CONNECTX7BF)
844 static struct mlx5_class_driver mlx5_vdpa_driver = {
845 .drv_class = MLX5_CLASS_VDPA,
846 .name = RTE_STR(MLX5_VDPA_DRIVER_NAME),
847 .id_table = mlx5_vdpa_pci_id_map,
848 .probe = mlx5_vdpa_dev_probe,
849 .remove = mlx5_vdpa_dev_remove,
852 RTE_LOG_REGISTER_DEFAULT(mlx5_vdpa_logtype, NOTICE)
855 * Driver initialization routine.
857 RTE_INIT(rte_mlx5_vdpa_init)
861 mlx5_class_driver_register(&mlx5_vdpa_driver);
864 RTE_PMD_EXPORT_NAME(MLX5_VDPA_DRIVER_NAME, __COUNTER__);
865 RTE_PMD_REGISTER_PCI_TABLE(MLX5_VDPA_DRIVER_NAME, mlx5_vdpa_pci_id_map);
866 RTE_PMD_REGISTER_KMOD_DEP(MLX5_VDPA_DRIVER_NAME, "* ib_uverbs & mlx5_core & mlx5_ib");