lib/librte_vhost/vhost.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2016 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <linux/vhost.h>
  35 #include <linux/virtio_net.h>
  36 #include <stddef.h>
  37 #include <stdint.h>
  38 #include <stdlib.h>
  39 #ifdef RTE_LIBRTE_VHOST_NUMA
  40 #include <numaif.h>
  41 #endif
  42
  43 #include <rte_errno.h>
  44 #include <rte_ethdev.h>
  45 #include <rte_log.h>
  46 #include <rte_string_fns.h>
  47 #include <rte_memory.h>
  48 #include <rte_malloc.h>
  49 #include <rte_vhost.h>
  50 #include <rte_rwlock.h>
  51
  52 #include "iotlb.h"
  53 #include "vhost.h"
  54 #include "vhost_user.h"
  55
  56 struct virtio_net *vhost_devices[MAX_VHOST_DEVICE];
  57
  58 uint64_t
  59 __vhost_iova_to_vva(struct virtio_net *dev, struct vhost_virtqueue *vq,
  60                     uint64_t iova, uint64_t size, uint8_t perm)
  61 {
  62         uint64_t vva, tmp_size;
  63
  64         if (unlikely(!size))
  65                 return 0;
  66
  67         tmp_size = size;
  68
  69         vva = vhost_user_iotlb_cache_find(vq, iova, &tmp_size, perm);
  70         if (tmp_size == size)
  71                 return vva;
  72
  73         if (!vhost_user_iotlb_pending_miss(vq, iova + tmp_size, perm)) {
  74                 vhost_user_iotlb_pending_insert(vq, iova + tmp_size, perm);
  75                 vhost_user_iotlb_miss(dev, iova + tmp_size, perm);
  76         }
  77
  78         return 0;
  79 }
  80
  81 struct virtio_net *
  82 get_device(int vid)
  83 {
  84         struct virtio_net *dev = vhost_devices[vid];
  85
  86         if (unlikely(!dev)) {
  87                 RTE_LOG(ERR, VHOST_CONFIG,
  88                         "(%d) device not found.\n", vid);
  89         }
  90
  91         return dev;
  92 }
  93
  94 static void
  95 cleanup_vq(struct vhost_virtqueue *vq, int destroy)
  96 {
  97         if ((vq->callfd >= 0) && (destroy != 0))
  98                 close(vq->callfd);
  99         if (vq->kickfd >= 0)
 100                 close(vq->kickfd);
 101 }
 102
 103 /*
 104  * Unmap any memory, close any file descriptors and
 105  * free any memory owned by a device.
 106  */
 107 void
 108 cleanup_device(struct virtio_net *dev, int destroy)
 109 {
 110         uint32_t i;
 111
 112         vhost_backend_cleanup(dev);
 113
 114         for (i = 0; i < dev->nr_vring; i++)
 115                 cleanup_vq(dev->virtqueue[i], destroy);
 116 }
 117
 118 /*
 119  * Release virtqueues and device memory.
 120  */
 121 static void
 122 free_device(struct virtio_net *dev)
 123 {
 124         uint32_t i;
 125         struct vhost_virtqueue *vq;
 126
 127         for (i = 0; i < dev->nr_vring; i++) {
 128                 vq = dev->virtqueue[i];
 129
 130                 rte_free(vq->shadow_used_ring);
 131                 rte_free(vq->batch_copy_elems);
 132                 rte_mempool_free(vq->iotlb_pool);
 133                 rte_free(vq);
 134         }
 135
 136         rte_free(dev);
 137 }
 138
 139 static void
 140 init_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 141 {
 142         struct vhost_virtqueue *vq;
 143
 144         if (vring_idx >= VHOST_MAX_VRING) {
 145                 RTE_LOG(ERR, VHOST_CONFIG,
 146                                 "Failed not init vring, out of bound (%d)\n",
 147                                 vring_idx);
 148                 return;
 149         }
 150
 151         vq = dev->virtqueue[vring_idx];
 152
 153         memset(vq, 0, sizeof(struct vhost_virtqueue));
 154
 155         vq->kickfd = VIRTIO_UNINITIALIZED_EVENTFD;
 156         vq->callfd = VIRTIO_UNINITIALIZED_EVENTFD;
 157
 158         vhost_user_iotlb_init(dev, vring_idx);
 159         /* Backends are set to -1 indicating an inactive device. */
 160         vq->backend = -1;
 161
 162         TAILQ_INIT(&vq->zmbuf_list);
 163 }
 164
 165 static void
 166 reset_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 167 {
 168         struct vhost_virtqueue *vq;
 169         int callfd;
 170
 171         if (vring_idx >= VHOST_MAX_VRING) {
 172                 RTE_LOG(ERR, VHOST_CONFIG,
 173                                 "Failed not init vring, out of bound (%d)\n",
 174                                 vring_idx);
 175                 return;
 176         }
 177
 178         vq = dev->virtqueue[vring_idx];
 179         callfd = vq->callfd;
 180         init_vring_queue(dev, vring_idx);
 181         vq->callfd = callfd;
 182 }
 183
 184 int
 185 alloc_vring_queue(struct virtio_net *dev, uint32_t vring_idx)
 186 {
 187         struct vhost_virtqueue *vq;
 188
 189         vq = rte_malloc(NULL, sizeof(struct vhost_virtqueue), 0);
 190         if (vq == NULL) {
 191                 RTE_LOG(ERR, VHOST_CONFIG,
 192                         "Failed to allocate memory for vring:%u.\n", vring_idx);
 193                 return -1;
 194         }
 195
 196         dev->virtqueue[vring_idx] = vq;
 197         init_vring_queue(dev, vring_idx);
 198
 199         dev->nr_vring += 1;
 200
 201         return 0;
 202 }
 203
 204 /*
 205  * Reset some variables in device structure, while keeping few
 206  * others untouched, such as vid, ifname, nr_vring: they
 207  * should be same unless the device is removed.
 208  */
 209 void
 210 reset_device(struct virtio_net *dev)
 211 {
 212         uint32_t i;
 213
 214         dev->features = 0;
 215         dev->protocol_features = 0;
 216         dev->flags = 0;
 217
 218         for (i = 0; i < dev->nr_vring; i++)
 219                 reset_vring_queue(dev, i);
 220 }
 221
 222 /*
 223  * Invoked when there is a new vhost-user connection established (when
 224  * there is a new virtio device being attached).
 225  */
 226 int
 227 vhost_new_device(void)
 228 {
 229         struct virtio_net *dev;
 230         int i;
 231
 232         dev = rte_zmalloc(NULL, sizeof(struct virtio_net), 0);
 233         if (dev == NULL) {
 234                 RTE_LOG(ERR, VHOST_CONFIG,
 235                         "Failed to allocate memory for new dev.\n");
 236                 return -1;
 237         }
 238
 239         for (i = 0; i < MAX_VHOST_DEVICE; i++) {
 240                 if (vhost_devices[i] == NULL)
 241                         break;
 242         }
 243         if (i == MAX_VHOST_DEVICE) {
 244                 RTE_LOG(ERR, VHOST_CONFIG,
 245                         "Failed to find a free slot for new device.\n");
 246                 rte_free(dev);
 247                 return -1;
 248         }
 249
 250         vhost_devices[i] = dev;
 251         dev->vid = i;
 252         dev->slave_req_fd = -1;
 253
 254         return i;
 255 }
 256
 257 /*
 258  * Invoked when there is the vhost-user connection is broken (when
 259  * the virtio device is being detached).
 260  */
 261 void
 262 vhost_destroy_device(int vid)
 263 {
 264         struct virtio_net *dev = get_device(vid);
 265
 266         if (dev == NULL)
 267                 return;
 268
 269         if (dev->flags & VIRTIO_DEV_RUNNING) {
 270                 dev->flags &= ~VIRTIO_DEV_RUNNING;
 271                 dev->notify_ops->destroy_device(vid);
 272         }
 273
 274         cleanup_device(dev, 1);
 275         free_device(dev);
 276
 277         vhost_devices[vid] = NULL;
 278 }
 279
 280 void
 281 vhost_set_ifname(int vid, const char *if_name, unsigned int if_len)
 282 {
 283         struct virtio_net *dev;
 284         unsigned int len;
 285
 286         dev = get_device(vid);
 287         if (dev == NULL)
 288                 return;
 289
 290         len = if_len > sizeof(dev->ifname) ?
 291                 sizeof(dev->ifname) : if_len;
 292
 293         strncpy(dev->ifname, if_name, len);
 294         dev->ifname[sizeof(dev->ifname) - 1] = '\0';
 295 }
 296
 297 void
 298 vhost_enable_dequeue_zero_copy(int vid)
 299 {
 300         struct virtio_net *dev = get_device(vid);
 301
 302         if (dev == NULL)
 303                 return;
 304
 305         dev->dequeue_zero_copy = 1;
 306 }
 307
 308 int
 309 rte_vhost_get_mtu(int vid, uint16_t *mtu)
 310 {
 311         struct virtio_net *dev = get_device(vid);
 312
 313         if (!dev)
 314                 return -ENODEV;
 315
 316         if (!(dev->flags & VIRTIO_DEV_READY))
 317                 return -EAGAIN;
 318
 319         if (!(dev->features & (1ULL << VIRTIO_NET_F_MTU)))
 320                 return -ENOTSUP;
 321
 322         *mtu = dev->mtu;
 323
 324         return 0;
 325 }
 326
 327 int
 328 rte_vhost_get_numa_node(int vid)
 329 {
 330 #ifdef RTE_LIBRTE_VHOST_NUMA
 331         struct virtio_net *dev = get_device(vid);
 332         int numa_node;
 333         int ret;
 334
 335         if (dev == NULL)
 336                 return -1;
 337
 338         ret = get_mempolicy(&numa_node, NULL, 0, dev,
 339                             MPOL_F_NODE | MPOL_F_ADDR);
 340         if (ret < 0) {
 341                 RTE_LOG(ERR, VHOST_CONFIG,
 342                         "(%d) failed to query numa node: %s\n",
 343                         vid, rte_strerror(errno));
 344                 return -1;
 345         }
 346
 347         return numa_node;
 348 #else
 349         RTE_SET_USED(vid);
 350         return -1;
 351 #endif
 352 }
 353
 354 uint32_t
 355 rte_vhost_get_queue_num(int vid)
 356 {
 357         struct virtio_net *dev = get_device(vid);
 358
 359         if (dev == NULL)
 360                 return 0;
 361
 362         return dev->nr_vring / 2;
 363 }
 364
 365 uint16_t
 366 rte_vhost_get_vring_num(int vid)
 367 {
 368         struct virtio_net *dev = get_device(vid);
 369
 370         if (dev == NULL)
 371                 return 0;
 372
 373         return dev->nr_vring;
 374 }
 375
 376 int
 377 rte_vhost_get_ifname(int vid, char *buf, size_t len)
 378 {
 379         struct virtio_net *dev = get_device(vid);
 380
 381         if (dev == NULL)
 382                 return -1;
 383
 384         len = RTE_MIN(len, sizeof(dev->ifname));
 385
 386         strncpy(buf, dev->ifname, len);
 387         buf[len - 1] = '\0';
 388
 389         return 0;
 390 }
 391
 392 int
 393 rte_vhost_get_negotiated_features(int vid, uint64_t *features)
 394 {
 395         struct virtio_net *dev;
 396
 397         dev = get_device(vid);
 398         if (!dev)
 399                 return -1;
 400
 401         *features = dev->features;
 402         return 0;
 403 }
 404
 405 int
 406 rte_vhost_get_mem_table(int vid, struct rte_vhost_memory **mem)
 407 {
 408         struct virtio_net *dev;
 409         struct rte_vhost_memory *m;
 410         size_t size;
 411
 412         dev = get_device(vid);
 413         if (!dev)
 414                 return -1;
 415
 416         size = dev->mem->nregions * sizeof(struct rte_vhost_mem_region);
 417         m = malloc(sizeof(struct rte_vhost_memory) + size);
 418         if (!m)
 419                 return -1;
 420
 421         m->nregions = dev->mem->nregions;
 422         memcpy(m->regions, dev->mem->regions, size);
 423         *mem = m;
 424
 425         return 0;
 426 }
 427
 428 int
 429 rte_vhost_get_vhost_vring(int vid, uint16_t vring_idx,
 430                           struct rte_vhost_vring *vring)
 431 {
 432         struct virtio_net *dev;
 433         struct vhost_virtqueue *vq;
 434
 435         dev = get_device(vid);
 436         if (!dev)
 437                 return -1;
 438
 439         if (vring_idx >= VHOST_MAX_VRING)
 440                 return -1;
 441
 442         vq = dev->virtqueue[vring_idx];
 443         if (!vq)
 444                 return -1;
 445
 446         vring->desc  = vq->desc;
 447         vring->avail = vq->avail;
 448         vring->used  = vq->used;
 449         vring->log_guest_addr  = vq->log_guest_addr;
 450
 451         vring->callfd  = vq->callfd;
 452         vring->kickfd  = vq->kickfd;
 453         vring->size    = vq->size;
 454
 455         return 0;
 456 }
 457
 458 uint16_t
 459 rte_vhost_avail_entries(int vid, uint16_t queue_id)
 460 {
 461         struct virtio_net *dev;
 462         struct vhost_virtqueue *vq;
 463
 464         dev = get_device(vid);
 465         if (!dev)
 466                 return 0;
 467
 468         vq = dev->virtqueue[queue_id];
 469         if (!vq->enabled)
 470                 return 0;
 471
 472         return *(volatile uint16_t *)&vq->avail->idx - vq->last_used_idx;
 473 }
 474
 475 int
 476 rte_vhost_enable_guest_notification(int vid, uint16_t queue_id, int enable)
 477 {
 478         struct virtio_net *dev = get_device(vid);
 479
 480         if (dev == NULL)
 481                 return -1;
 482
 483         if (enable) {
 484                 RTE_LOG(ERR, VHOST_CONFIG,
 485                         "guest notification isn't supported.\n");
 486                 return -1;
 487         }
 488
 489         dev->virtqueue[queue_id]->used->flags = VRING_USED_F_NO_NOTIFY;
 490         return 0;
 491 }
 492
 493 void
 494 rte_vhost_log_write(int vid, uint64_t addr, uint64_t len)
 495 {
 496         struct virtio_net *dev = get_device(vid);
 497
 498         if (dev == NULL)
 499                 return;
 500
 501         vhost_log_write(dev, addr, len);
 502 }
 503
 504 void
 505 rte_vhost_log_used_vring(int vid, uint16_t vring_idx,
 506                          uint64_t offset, uint64_t len)
 507 {
 508         struct virtio_net *dev;
 509         struct vhost_virtqueue *vq;
 510
 511         dev = get_device(vid);
 512         if (dev == NULL)
 513                 return;
 514
 515         if (vring_idx >= VHOST_MAX_VRING)
 516                 return;
 517         vq = dev->virtqueue[vring_idx];
 518         if (!vq)
 519                 return;
 520
 521         vhost_log_used_vring(dev, vq, offset, len);
 522 }
 523
 524 uint32_t
 525 rte_vhost_rx_queue_count(int vid, uint16_t qid)
 526 {
 527         struct virtio_net *dev;
 528         struct vhost_virtqueue *vq;
 529
 530         dev = get_device(vid);
 531         if (dev == NULL)
 532                 return 0;
 533
 534         if (unlikely(qid >= dev->nr_vring || (qid & 1) == 0)) {
 535                 RTE_LOG(ERR, VHOST_DATA, "(%d) %s: invalid virtqueue idx %d.\n",
 536                         dev->vid, __func__, qid);
 537                 return 0;
 538         }
 539
 540         vq = dev->virtqueue[qid];
 541         if (vq == NULL)
 542                 return 0;
 543
 544         if (unlikely(vq->enabled == 0 || vq->avail == NULL))
 545                 return 0;
 546
 547         return *((volatile uint16_t *)&vq->avail->idx) - vq->last_avail_idx;
 548 }