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     net->dev.nvqs = 2;
 113     net->dev.vqs = net->vqs;
 114
 115     r = vhost_dev_init(&net->dev, devfd, "/dev/vhost-net", force);
 116     if (r < 0) {
 117         goto fail;
 118     }
 119     if (!tap_has_vnet_hdr_len(backend,
 120                               sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
 121         net->dev.features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);
 122     }
 123     if (~net->dev.features & net->dev.backend_features) {
 124         fprintf(stderr, "vhost lacks feature mask %" PRIu64 " for backend\n",
 125                 (uint64_t)(~net->dev.features & net->dev.backend_features));
 126         vhost_dev_cleanup(&net->dev);
 127         goto fail;
 128     }
 129
 130     /* Set sane init value. Override when guest acks. */
 131     vhost_net_ack_features(net, 0);
 132     return net;
 133 fail:
 134     g_free(net);
 135     return NULL;
 136 }
 137
 138 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 139 {
 140     return vhost_dev_query(&net->dev, dev);
 141 }
 142
 143 int vhost_net_start(struct vhost_net *net,
 144                     VirtIODevice *dev)
 145 {
 146     struct vhost_vring_file file = { };
 147     int r;
 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
 204 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
 205 {
 206     return vhost_virtqueue_pending(&net->dev, idx);
 207 }
 208
 209 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
 210                               int idx, bool mask)
 211 {
 212     vhost_virtqueue_mask(&net->dev, dev, idx, mask);
 213 }
 214 #else
 215 struct vhost_net *vhost_net_init(NetClientState *backend, int devfd,
 216                                  bool force)
 217 {
 218     error_report("vhost-net support is not compiled in");
 219     return NULL;
 220 }
 221
 222 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 223 {
 224     return false;
 225 }
 226
 227 int vhost_net_start(struct vhost_net *net,
 228                     VirtIODevice *dev)
 229 {
 230     return -ENOSYS;
 231 }
 232 void vhost_net_stop(struct vhost_net *net,
 233                     VirtIODevice *dev)
 234 {
 235 }
 236
 237 void vhost_net_cleanup(struct vhost_net *net)
 238 {
 239 }
 240
 241 unsigned vhost_net_get_features(struct vhost_net *net, unsigned features)
 242 {
 243     return features;
 244 }
 245 void vhost_net_ack_features(struct vhost_net *net, unsigned features)
 246 {
 247 }
 248
 249 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
 250 {
 251     return -ENOSYS;
 252 }
 253
 254 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
 255                               int idx, bool mask)
 256 {
 257 }
 258 #endif