lib/librte_vhost/vhost.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2016 Intel Corporation
   3  */
   4
   5 #include <linux/vhost.h>
   6 #include <linux/virtio_net.h>
   7 #include <stddef.h>
   8 #include <stdint.h>
   9 #include <stdlib.h>
  10 #ifdef RTE_LIBRTE_VHOST_NUMA
  11 #include <numaif.h>
  12 #endif
  13
  14 #include <rte_errno.h>
  15 #include <rte_ethdev.h>
  16 #include <rte_log.h>
  17 #include <rte_string_fns.h>
  18 #include <rte_memory.h>
  19 #include <rte_malloc.h>
  20 #include <rte_vhost.h>
  21 #include <rte_rwlock.h>
  22
  23 #include "iotlb.h"
  24 #include "vhost.h"
  25 #include "vhost_user.h"
  26
  27 struct virtio_net *vhost_devices[MAX_VHOST_DEVICE];
  28
  29 /* Called with iotlb_lock read-locked */
  30 uint64_t
  31 __vhost_iova_to_vva(struct virtio_net *dev, struct vhost_virtqueue *vq,
  32                     uint64_t iova, uint64_t size, uint8_t perm)
  33 {
  34         uint64_t vva, tmp_size;
  35
  36         if (unlikely(!size))
  37                 return 0;
  38
  39         tmp_size = size;
  40
  41         vva = vhost_user_iotlb_cache_find(vq, iova, &tmp_size, perm);
  42         if (tmp_size == size)
  43                 return vva;
  44
  45         iova += tmp_size;
  46
  47         if (!vhost_user_iotlb_pending_miss(vq, iova, perm)) {
  48                 /*
  49                  * iotlb_lock is read-locked for a full burst,
  50                  * but it only protects the iotlb cache.
  51                  * In case of IOTLB miss, we might block on the socket,
  52                  * which could cause a deadlock with QEMU if an IOTLB update
  53                  * is being handled. We can safely unlock here to avoid it.
  54                  */
  55                 vhost_user_iotlb_rd_unlock(vq);
  56
  57                 vhost_user_iotlb_pending_insert(vq, iova, perm);
  58                 if (vhost_user_iotlb_miss(dev, iova, perm)) {
  59                         RTE_LOG(ERR, VHOST_CONFIG,
  60                                 "IOTLB miss req failed for IOVA 0x%" PRIx64 "\n",
  61                                 iova);
  62                         vhost_user_iotlb_pending_remove(vq, iova, 1, perm);
  63                 }
  64
  65                 vhost_user_iotlb_rd_lock(vq);
  66         }
  67
  68         return 0;
  69 }
  70
  71 void
  72 cleanup_vq(struct vhost_virtqueue *vq, int destroy)
  73 {
  74         if ((vq->callfd >= 0) && (destroy != 0))
  75                 close(vq->callfd);
  76         if (vq->kickfd >= 0)
  77                 close(vq->kickfd);
  78 }
  79
  80 /*
  81  * Unmap any memory, close any file descriptors and
  82  * free any memory owned by a device.
  83  */
  84 void
  85 cleanup_device(struct virtio_net *dev, int destroy)
  86 {
  87         uint32_t i;
  88
  89         vhost_backend_cleanup(dev);
  90
  91         for (i = 0; i < dev->nr_vring; i++)
  92                 cleanup_vq(dev->virtqueue[i], destroy);
  93 }
  94
  95 void
  96 free_vq(struct vhost_virtqueue *vq)
  97 {
  98         rte_free(vq->shadow_used_ring);
  99         rte_free(vq->batch_copy_elems);
 100         rte_mempool_free(vq->iotlb_pool);
 101         rte_free(vq);
 102 }
 103
 104 /*
 105  * Release virtqueues and device memory.
 106  */
 107 static void
 108 free_device(struct virtio_net *dev)
 109 {
 110         uint32_t i;
 111
 112         for (i = 0; i < dev->nr_vring; i++)
 113                 free_vq(dev->virtqueue[i]);
 114
 115         rte_free(dev);
 116 }
 117
 118 int
 119 vring_translate(struct virtio_net *dev, struct vhost_virtqueue *vq)
 120 {
 121         uint64_t size;
 122
 123         if (!(dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM)))
 124                 goto out;
 125
 126         size = sizeof(struct vring_desc) * vq->size;
 127         vq->desc = (struct vring_desc *)(uintptr_t)vhost_iova_to_vva(dev, vq,
 128                                                 vq->ring_addrs.desc_user_addr,
 129                                                 size, VHOST_ACCESS_RW);
 130         if (!vq->desc)
 131                 return -1;
 132
 133         size = sizeof(struct vring_avail);
 134         size += sizeof(uint16_t) * vq->size;
 135         vq->avail = (struct vring_avail *)(uintptr_t)vhost_iova_to_vva(dev, vq,
 136                                                 vq->ring_addrs.avail_user_addr,
 137                                                 size, VHOST_ACCESS_RW);
 138         if (!vq->avail)
 139                 return -1;
 140
 141         size = sizeof(struct vring_used);
 142         size += sizeof(struct vring_used_elem) * vq->size;
 143         vq->used = (struct vring_used *)(uintptr_t)vhost_iova_to_vva(dev, vq,
 144                                                 vq->ring_addrs.used_user_addr,
 145                                                 size, VHOST_ACCESS_RW);
 146         if (!vq->used)
 147                 return -1;
 148
 149 out:
 150         vq->access_ok = 1;
 151
 152         return 0;
 153 }
 154
 155 void
 156 vring_invalidate(struct virtio_net *dev, struct vhost_virtqueue *vq)
 157 {
 158         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 159                 vhost_user_iotlb_wr_lock(vq);
 160
 161         vq->access_ok = 0;
 162         vq->desc = NULL;
 163         vq->avail = NULL;
 164         vq->used = NULL;
 165
 166         if (dev->features & (1ULL << VIRTIO_F_IOMMU_PLATFORM))
 167                 vhost_user_iotlb_wr_unlock(vq);
 168 }
 169
 170 static void
 171 init_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 172 {
 173         struct vhost_virtqueue *vq;
 174
 175         if (vring_idx >= VHOST_MAX_VRING) {
 176                 RTE_LOG(ERR, VHOST_CONFIG,
 177                                 "Failed not init vring, out of bound (%d)\n",
 178                                 vring_idx);
 179                 return;
 180         }
 181
 182         vq = dev->virtqueue[vring_idx];
 183
 184         memset(vq, 0, sizeof(struct vhost_virtqueue));
 185
 186         vq->kickfd = VIRTIO_UNINITIALIZED_EVENTFD;
 187         vq->callfd = VIRTIO_UNINITIALIZED_EVENTFD;
 188
 189         vhost_user_iotlb_init(dev, vring_idx);
 190         /* Backends are set to -1 indicating an inactive device. */
 191         vq->backend = -1;
 192
 193         TAILQ_INIT(&vq->zmbuf_list);
 194 }
 195
 196 static void
 197 reset_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 198 {
 199         struct vhost_virtqueue *vq;
 200         int callfd;
 201
 202         if (vring_idx >= VHOST_MAX_VRING) {
 203                 RTE_LOG(ERR, VHOST_CONFIG,
 204                                 "Failed not init vring, out of bound (%d)\n",
 205                                 vring_idx);
 206                 return;
 207         }
 208
 209         vq = dev->virtqueue[vring_idx];
 210         callfd = vq->callfd;
 211         init_vring_queue(dev, vring_idx);
 212         vq->callfd = callfd;
 213 }
 214
 215 int
 216 alloc_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 217 {
 218         struct vhost_virtqueue *vq;
 219
 220         vq = rte_malloc(NULL, sizeof(struct vhost_virtqueue), 0);
 221         if (vq == NULL) {
 222                 RTE_LOG(ERR, VHOST_CONFIG,
 223                         "Failed to allocate memory for vring:%u.\n", vring_idx);
 224                 return -1;
 225         }
 226
 227         dev->virtqueue[vring_idx] = vq;
 228         init_vring_queue(dev, vring_idx);
 229         rte_spinlock_init(&vq->access_lock);
 230
 231         dev->nr_vring += 1;
 232
 233         return 0;
 234 }
 235
 236 /*
 237  * Reset some variables in device structure, while keeping few
 238  * others untouched, such as vid, ifname, nr_vring: they
 239  * should be same unless the device is removed.
 240  */
 241 void
 242 reset_device(struct virtio_net *dev)
 243 {
 244         uint32_t i;
 245
 246         dev->features = 0;
 247         dev->protocol_features = 0;
 248         dev->flags &= VIRTIO_DEV_BUILTIN_VIRTIO_NET;
 249
 250         for (i = 0; i < dev->nr_vring; i++)
 251                 reset_vring_queue(dev, i);
 252 }
 253
 254 /*
 255  * Invoked when there is a new vhost-user connection established (when
 256  * there is a new virtio device being attached).
 257  */
 258 int
 259 vhost_new_device(void)
 260 {
 261         struct virtio_net *dev;
 262         int i;
 263
 264         dev = rte_zmalloc(NULL, sizeof(struct virtio_net), 0);
 265         if (dev == NULL) {
 266                 RTE_LOG(ERR, VHOST_CONFIG,
 267                         "Failed to allocate memory for new dev.\n");
 268                 return -1;
 269         }
 270
 271         for (i = 0; i < MAX_VHOST_DEVICE; i++) {
 272                 if (vhost_devices[i] == NULL)
 273                         break;
 274         }
 275         if (i == MAX_VHOST_DEVICE) {
 276                 RTE_LOG(ERR, VHOST_CONFIG,
 277                         "Failed to find a free slot for new device.\n");
 278                 rte_free(dev);
 279                 return -1;
 280         }
 281
 282         vhost_devices[i] = dev;
 283         dev->vid = i;
 284         dev->flags = VIRTIO_DEV_BUILTIN_VIRTIO_NET;
 285         dev->slave_req_fd = -1;
 286         dev->vdpa_dev_id = -1;
 287
 288         return i;
 289 }
 290
 291 /*
 292  * Invoked when there is the vhost-user connection is broken (when
 293  * the virtio device is being detached).
 294  */
 295 void
 296 vhost_destroy_device(int vid)
 297 {
 298         struct virtio_net *dev = get_device(vid);
 299
 300         if (dev == NULL)
 301                 return;
 302
 303         if (dev->flags & VIRTIO_DEV_RUNNING) {
 304                 dev->flags &= ~VIRTIO_DEV_RUNNING;
 305                 dev->notify_ops->destroy_device(vid);
 306         }
 307
 308         cleanup_device(dev, 1);
 309         free_device(dev);
 310
 311         vhost_devices[vid] = NULL;
 312 }
 313
 314 void
 315 vhost_attach_vdpa_device(int vid, int did)
 316 {
 317         struct virtio_net *dev = get_device(vid);
 318
 319         if (dev == NULL)
 320                 return;
 321
 322         if (rte_vdpa_get_device(did) == NULL)
 323                 return;
 324
 325         dev->vdpa_dev_id = did;
 326 }
 327
 328 void
 329 vhost_detach_vdpa_device(int vid)
 330 {
 331         struct virtio_net *dev = get_device(vid);
 332
 333         if (dev == NULL)
 334                 return;
 335
 336         dev->vdpa_dev_id = -1;
 337 }
 338
 339 void
 340 vhost_set_ifname(int vid, const char *if_name, unsigned int if_len)
 341 {
 342         struct virtio_net *dev;
 343         unsigned int len;
 344
 345         dev = get_device(vid);
 346         if (dev == NULL)
 347                 return;
 348
 349         len = if_len > sizeof(dev->ifname) ?
 350                 sizeof(dev->ifname) : if_len;
 351
 352         strncpy(dev->ifname, if_name, len);
 353         dev->ifname[sizeof(dev->ifname) - 1] = '\0';
 354 }
 355
 356 void
 357 vhost_enable_dequeue_zero_copy(int vid)
 358 {
 359         struct virtio_net *dev = get_device(vid);
 360
 361         if (dev == NULL)
 362                 return;
 363
 364         dev->dequeue_zero_copy = 1;
 365 }
 366
 367 void
 368 vhost_set_builtin_virtio_net(int vid, bool enable)
 369 {
 370         struct virtio_net *dev = get_device(vid);
 371
 372         if (dev == NULL)
 373                 return;
 374
 375         if (enable)
 376                 dev->flags |= VIRTIO_DEV_BUILTIN_VIRTIO_NET;
 377         else
 378                 dev->flags &= ~VIRTIO_DEV_BUILTIN_VIRTIO_NET;
 379 }
 380
 381 int
 382 rte_vhost_get_mtu(int vid, uint16_t *mtu)
 383 {
 384         struct virtio_net *dev = get_device(vid);
 385
 386         if (!dev)
 387                 return -ENODEV;
 388
 389         if (!(dev->flags & VIRTIO_DEV_READY))
 390                 return -EAGAIN;
 391
 392         if (!(dev->features & (1ULL << VIRTIO_NET_F_MTU)))
 393                 return -ENOTSUP;
 394
 395         *mtu = dev->mtu;
 396
 397         return 0;
 398 }
 399
 400 int
 401 rte_vhost_get_numa_node(int vid)
 402 {
 403 #ifdef RTE_LIBRTE_VHOST_NUMA
 404         struct virtio_net *dev = get_device(vid);
 405         int numa_node;
 406         int ret;
 407
 408         if (dev == NULL)
 409                 return -1;
 410
 411         ret = get_mempolicy(&numa_node, NULL, 0, dev,
 412                             MPOL_F_NODE | MPOL_F_ADDR);
 413         if (ret < 0) {
 414                 RTE_LOG(ERR, VHOST_CONFIG,
 415                         "(%d) failed to query numa node: %s\n",
 416                         vid, rte_strerror(errno));
 417                 return -1;
 418         }
 419
 420         return numa_node;
 421 #else
 422         RTE_SET_USED(vid);
 423         return -1;
 424 #endif
 425 }
 426
 427 uint32_t
 428 rte_vhost_get_queue_num(int vid)
 429 {
 430         struct virtio_net *dev = get_device(vid);
 431
 432         if (dev == NULL)
 433                 return 0;
 434
 435         return dev->nr_vring / 2;
 436 }
 437
 438 uint16_t
 439 rte_vhost_get_vring_num(int vid)
 440 {
 441         struct virtio_net *dev = get_device(vid);
 442
 443         if (dev == NULL)
 444                 return 0;
 445
 446         return dev->nr_vring;
 447 }
 448
 449 int
 450 rte_vhost_get_ifname(int vid, char *buf, size_t len)
 451 {
 452         struct virtio_net *dev = get_device(vid);
 453
 454         if (dev == NULL)
 455                 return -1;
 456
 457         len = RTE_MIN(len, sizeof(dev->ifname));
 458
 459         strncpy(buf, dev->ifname, len);
 460         buf[len - 1] = '\0';
 461
 462         return 0;
 463 }
 464
 465 int
 466 rte_vhost_get_negotiated_features(int vid, uint64_t *features)
 467 {
 468         struct virtio_net *dev;
 469
 470         dev = get_device(vid);
 471         if (!dev)
 472                 return -1;
 473
 474         *features = dev->features;
 475         return 0;
 476 }
 477
 478 int
 479 rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem)
 480 {
 481         struct virtio_net *dev;
 482         struct rte_vhost_memory *m;
 483         size_t size;
 484
 485         dev = get_device(vid);
 486         if (!dev)
 487                 return -1;
 488
 489         size = dev->mem->nregions * sizeof(struct rte_vhost_mem_region);
 490         m = malloc(sizeof(struct rte_vhost_memory) + size);
 491         if (!m)
 492                 return -1;
 493
 494         m->nregions = dev->mem->nregions;
 495         memcpy(m->regions, dev->mem->regions, size);
 496         *mem = m;
 497
 498         return 0;
 499 }
 500
 501 int
 502 rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,
 503                           struct rte_vhost_vring *vring)
 504 {
 505         struct virtio_net *dev;
 506         struct vhost_virtqueue *vq;
 507
 508         dev = get_device(vid);
 509         if (!dev)
 510                 return -1;
 511
 512         if (vring_idx >= VHOST_MAX_VRING)
 513                 return -1;
 514
 515         vq = dev->virtqueue[vring_idx];
 516         if (!vq)
 517                 return -1;
 518
 519         vring->desc  = vq->desc;
 520         vring->avail = vq->avail;
 521         vring->used  = vq->used;
 522         vring->log_guest_addr  = vq->log_guest_addr;
 523
 524         vring->callfd  = vq->callfd;
 525         vring->kickfd  = vq->kickfd;
 526         vring->size    = vq->size;
 527
 528         return 0;
 529 }
 530
 531 int
 532 rte_vhost_vring_call(int vid, uint16_t vring_idx)
 533 {
 534         struct virtio_net *dev;
 535         struct vhost_virtqueue *vq;
 536
 537         dev = get_device(vid);
 538         if (!dev)
 539                 return -1;
 540
 541         if (vring_idx >= VHOST_MAX_VRING)
 542                 return -1;
 543
 544         vq = dev->virtqueue[vring_idx];
 545         if (!vq)
 546                 return -1;
 547
 548         vhost_vring_call(dev, vq);
 549         return 0;
 550 }
 551
 552 uint16_t
 553 rte_vhost_avail_entries(int vid, uint16_t queue_id)
 554 {
 555         struct virtio_net *dev;
 556         struct vhost_virtqueue *vq;
 557
 558         dev = get_device(vid);
 559         if (!dev)
 560                 return 0;
 561
 562         vq = dev->virtqueue[queue_id];
 563         if (!vq->enabled)
 564                 return 0;
 565
 566         return *(volatile uint16_t *)&vq->avail->idx - vq->last_used_idx;
 567 }
 568
 569 int
 570 rte_vhost_enable_guest_notification(int vid, uint16_t queue_id, int enable)
 571 {
 572         struct virtio_net *dev = get_device(vid);
 573
 574         if (dev == NULL)
 575                 return -1;
 576
 577         if (enable) {
 578                 RTE_LOG(ERR, VHOST_CONFIG,
 579                         "guest notification isn't supported.\n");
 580                 return -1;
 581         }
 582
 583         dev->virtqueue[queue_id]->used->flags = VRING_USED_F_NO_NOTIFY;
 584         return 0;
 585 }
 586
 587 void
 588 rte_vhost_log_write(int vid, uint64_t addr, uint64_t len)
 589 {
 590         struct virtio_net *dev = get_device(vid);
 591
 592         if (dev == NULL)
 593                 return;
 594
 595         vhost_log_write(dev, addr, len);
 596 }
 597
 598 void
 599 rte_vhost_log_used_vring(int vid, uint16_t vring_idx,
 600                          uint64_t offset, uint64_t len)
 601 {
 602         struct virtio_net *dev;
 603         struct vhost_virtqueue *vq;
 604
 605         dev = get_device(vid);
 606         if (dev == NULL)
 607                 return;
 608
 609         if (vring_idx >= VHOST_MAX_VRING)
 610                 return;
 611         vq = dev->virtqueue[vring_idx];
 612         if (!vq)
 613                 return;
 614
 615         vhost_log_used_vring(dev, vq, offset, len);
 616 }
 617
 618 uint32_t
 619 rte_vhost_rx_queue_count(int vid, uint16_t qid)
 620 {
 621         struct virtio_net *dev;
 622         struct vhost_virtqueue *vq;
 623
 624         dev = get_device(vid);
 625         if (dev == NULL)
 626                 return 0;
 627
 628         if (unlikely(qid >= dev->nr_vring || (qid & 1) == 0)) {
 629                 RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
 630                         dev->vid, __func__, qid);
 631                 return 0;
 632         }
 633
 634         vq = dev->virtqueue[qid];
 635         if (vq == NULL)
 636                 return 0;
 637
 638         if (unlikely(vq->enabled == 0 || vq->avail == NULL))
 639                 return 0;
 640
 641         return *((volatile uint16_t *)&vq->avail->idx) - vq->last_avail_idx;
 642 }
 643
 644 int rte_vhost_get_vdpa_device_id(int vid)
 645 {
 646         struct virtio_net *dev = get_device(vid);
 647
 648         if (dev == NULL)
 649                 return -1;
 650
 651         return dev->vdpa_dev_id;
 652 }