hw/vhost_net.c

   1 /*
   2  * vhost-net support
   3  *
   4  * Copyright Red Hat, Inc. 2010
   5  *
   6  * Authors:
   7  *  Michael S. Tsirkin <mst@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  * Contributions after 2012-01-13 are licensed under the terms of the
  13  * GNU GPL, version 2 or (at your option) any later version.
  14  */
  15
  16 #include "net/net.h"
  17 #include "net/tap.h"
  18
  19 #include "virtio-net.h"
  20 #include "vhost_net.h"
  21 #include "qemu/error-report.h"
  22
  23 #include "config.h"
  24
  25 #ifdef CONFIG_VHOST_NET
  26 #include <linux/vhost.h>
  27 #include <sys/socket.h>
  28 #include <linux/kvm.h>
  29 #include <fcntl.h>
  30 #include <sys/ioctl.h>
  31 #include <linux/virtio_ring.h>
  32 #include <netpacket/packet.h>
  33 #include <net/ethernet.h>
  34 #include <net/if.h>
  35 #include <netinet/in.h>
  36
  37 #include <stdio.h>
  38
  39 #include "vhost.h"
  40
  41 struct vhost_net {
  42     struct vhost_dev dev;
  43     struct vhost_virtqueue vqs[2];
  44     int backend;
  45     NetClientState *nc;
  46 };
  47
  48 unsigned vhost_net_get_features(struct vhost_net *net, unsigned features)
  49 {
  50     /* Clear features not supported by host kernel. */
  51     if (!(net->dev.features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY))) {
  52         features &= ~(1 << VIRTIO_F_NOTIFY_ON_EMPTY);
  53     }
  54     if (!(net->dev.features & (1 << VIRTIO_RING_F_INDIRECT_DESC))) {
  55         features &= ~(1 << VIRTIO_RING_F_INDIRECT_DESC);
  56     }
  57     if (!(net->dev.features & (1 << VIRTIO_RING_F_EVENT_IDX))) {
  58         features &= ~(1 << VIRTIO_RING_F_EVENT_IDX);
  59     }
  60     if (!(net->dev.features & (1 << VIRTIO_NET_F_MRG_RXBUF))) {
  61         features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);
  62     }
  63     return features;
  64 }
  65
  66 void vhost_net_ack_features(struct vhost_net *net, unsigned features)
  67 {
  68     net->dev.acked_features = net->dev.backend_features;
  69     if (features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY)) {
  70         net->dev.acked_features |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
  71     }
  72     if (features & (1 << VIRTIO_RING_F_INDIRECT_DESC)) {
  73         net->dev.acked_features |= (1 << VIRTIO_RING_F_INDIRECT_DESC);
  74     }
  75     if (features & (1 << VIRTIO_RING_F_EVENT_IDX)) {
  76         net->dev.acked_features |= (1 << VIRTIO_RING_F_EVENT_IDX);
  77     }
  78     if (features & (1 << VIRTIO_NET_F_MRG_RXBUF)) {
  79         net->dev.acked_features |= (1 << VIRTIO_NET_F_MRG_RXBUF);
  80     }
  81 }
  82
  83 static int vhost_net_get_fd(NetClientState *backend)
  84 {
  85     switch (backend->info->type) {
  86     case NET_CLIENT_OPTIONS_KIND_TAP:
  87         return tap_get_fd(backend);
  88     default:
  89         fprintf(stderr, "vhost-net requires tap backend\n");
  90         return -EBADFD;
  91     }
  92 }
  93
  94 struct vhost_net *vhost_net_init(NetClientState *backend, int devfd,
  95                                  bool force)
  96 {
  97     int r;
  98     struct vhost_net *net = g_malloc(sizeof *net);
  99     if (!backend) {
 100         fprintf(stderr, "vhost-net requires backend to be setup\n");
 101         goto fail;
 102     }
 103     r = vhost_net_get_fd(backend);
 104     if (r < 0) {
 105         goto fail;
 106     }
 107     net->nc = backend;
 108     net->dev.backend_features = tap_has_vnet_hdr(backend) ? 0 :
 109         (1 << VHOST_NET_F_VIRTIO_NET_HDR);
 110     net->backend = r;
 111
 112     r = vhost_dev_init(&net->dev, devfd, "/dev/vhost-net", force);
 113     if (r < 0) {
 114         goto fail;
 115     }
 116     if (!tap_has_vnet_hdr_len(backend,
 117                               sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
 118         net->dev.features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);
 119     }
 120     if (~net->dev.features & net->dev.backend_features) {
 121         fprintf(stderr, "vhost lacks feature mask %" PRIu64 " for backend\n",
 122                 (uint64_t)(~net->dev.features & net->dev.backend_features));
 123         vhost_dev_cleanup(&net->dev);
 124         goto fail;
 125     }
 126
 127     /* Set sane init value. Override when guest acks. */
 128     vhost_net_ack_features(net, 0);
 129     return net;
 130 fail:
 131     g_free(net);
 132     return NULL;
 133 }
 134
 135 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 136 {
 137     return vhost_dev_query(&net->dev, dev);
 138 }
 139
 140 int vhost_net_start(struct vhost_net *net,
 141                     VirtIODevice *dev)
 142 {
 143     struct vhost_vring_file file = { };
 144     int r;
 145
 146     net->dev.nvqs = 2;
 147     net->dev.vqs = net->vqs;
 148
 149     r = vhost_dev_enable_notifiers(&net->dev, dev);
 150     if (r < 0) {
 151         goto fail_notifiers;
 152     }
 153
 154     r = vhost_dev_start(&net->dev, dev);
 155     if (r < 0) {
 156         goto fail_start;
 157     }
 158
 159     net->nc->info->poll(net->nc, false);
 160     qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
 161     file.fd = net->backend;
 162     for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
 163         r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 164         if (r < 0) {
 165             r = -errno;
 166             goto fail;
 167         }
 168     }
 169     return 0;
 170 fail:
 171     file.fd = -1;
 172     while (file.index-- > 0) {
 173         int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 174         assert(r >= 0);
 175     }
 176     net->nc->info->poll(net->nc, true);
 177     vhost_dev_stop(&net->dev, dev);
 178 fail_start:
 179     vhost_dev_disable_notifiers(&net->dev, dev);
 180 fail_notifiers:
 181     return r;
 182 }
 183
 184 void vhost_net_stop(struct vhost_net *net,
 185                     VirtIODevice *dev)
 186 {
 187     struct vhost_vring_file file = { .fd = -1 };
 188
 189     for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
 190         int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 191         assert(r >= 0);
 192     }
 193     net->nc->info->poll(net->nc, true);
 194     vhost_dev_stop(&net->dev, dev);
 195     vhost_dev_disable_notifiers(&net->dev, dev);
 196 }
 197
 198 void vhost_net_cleanup(struct vhost_net *net)
 199 {
 200     vhost_dev_cleanup(&net->dev);
 201     g_free(net);
 202 }
 203 #else
 204 struct vhost_net *vhost_net_init(NetClientState *backend, int devfd,
 205                                  bool force)
 206 {
 207     error_report("vhost-net support is not compiled in");
 208     return NULL;
 209 }
 210
 211 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 212 {
 213     return false;
 214 }
 215
 216 int vhost_net_start(struct vhost_net *net,
 217                     VirtIODevice *dev)
 218 {
 219     return -ENOSYS;
 220 }
 221 void vhost_net_stop(struct vhost_net *net,
 222                     VirtIODevice *dev)
 223 {
 224 }
 225
 226 void vhost_net_cleanup(struct vhost_net *net)
 227 {
 228 }
 229
 230 unsigned vhost_net_get_features(struct vhost_net *net, unsigned features)
 231 {
 232     return features;
 233 }
 234 void vhost_net_ack_features(struct vhost_net *net, unsigned features)
 235 {
 236 }
 237 #endif