hw/net/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 "hw/virtio/virtio-net.h"
  20 #include "net/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 "hw/virtio/vhost.h"
  40 #include "hw/virtio/virtio-bus.h"
  41
  42 struct vhost_net {
  43     struct vhost_dev dev;
  44     struct vhost_virtqueue vqs[2];
  45     int backend;
  46     NetClientState *nc;
  47 };
  48
  49 unsigned vhost_net_get_features(struct vhost_net *net, unsigned features)
  50 {
  51     /* Clear features not supported by host kernel. */
  52     if (!(net->dev.features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY))) {
  53         features &= ~(1 << VIRTIO_F_NOTIFY_ON_EMPTY);
  54     }
  55     if (!(net->dev.features & (1 << VIRTIO_RING_F_INDIRECT_DESC))) {
  56         features &= ~(1 << VIRTIO_RING_F_INDIRECT_DESC);
  57     }
  58     if (!(net->dev.features & (1 << VIRTIO_RING_F_EVENT_IDX))) {
  59         features &= ~(1 << VIRTIO_RING_F_EVENT_IDX);
  60     }
  61     if (!(net->dev.features & (1 << VIRTIO_NET_F_MRG_RXBUF))) {
  62         features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);
  63     }
  64     return features;
  65 }
  66
  67 void vhost_net_ack_features(struct vhost_net *net, unsigned features)
  68 {
  69     net->dev.acked_features = net->dev.backend_features;
  70     if (features & (1 << VIRTIO_F_NOTIFY_ON_EMPTY)) {
  71         net->dev.acked_features |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
  72     }
  73     if (features & (1 << VIRTIO_RING_F_INDIRECT_DESC)) {
  74         net->dev.acked_features |= (1 << VIRTIO_RING_F_INDIRECT_DESC);
  75     }
  76     if (features & (1 << VIRTIO_RING_F_EVENT_IDX)) {
  77         net->dev.acked_features |= (1 << VIRTIO_RING_F_EVENT_IDX);
  78     }
  79     if (features & (1 << VIRTIO_NET_F_MRG_RXBUF)) {
  80         net->dev.acked_features |= (1 << VIRTIO_NET_F_MRG_RXBUF);
  81     }
  82 }
  83
  84 static int vhost_net_get_fd(NetClientState *backend)
  85 {
  86     switch (backend->info->type) {
  87     case NET_CLIENT_OPTIONS_KIND_TAP:
  88         return tap_get_fd(backend);
  89     default:
  90         fprintf(stderr, "vhost-net requires tap backend\n");
  91         return -EBADFD;
  92     }
  93 }
  94
  95 struct vhost_net *vhost_net_init(NetClientState *backend, int devfd,
  96                                  bool force)
  97 {
  98     int r;
  99     struct vhost_net *net = g_malloc(sizeof *net);
 100     if (!backend) {
 101         fprintf(stderr, "vhost-net requires backend to be setup\n");
 102         goto fail;
 103     }
 104     r = vhost_net_get_fd(backend);
 105     if (r < 0) {
 106         goto fail;
 107     }
 108     net->nc = backend;
 109     net->dev.backend_features = qemu_has_vnet_hdr(backend) ? 0 :
 110         (1 << VHOST_NET_F_VIRTIO_NET_HDR);
 111     net->backend = r;
 112
 113     net->dev.nvqs = 2;
 114     net->dev.vqs = net->vqs;
 115
 116     r = vhost_dev_init(&net->dev, devfd, "/dev/vhost-net", force);
 117     if (r < 0) {
 118         goto fail;
 119     }
 120     if (!qemu_has_vnet_hdr_len(backend,
 121                                sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
 122         net->dev.features &= ~(1 << VIRTIO_NET_F_MRG_RXBUF);
 123     }
 124     if (~net->dev.features & net->dev.backend_features) {
 125         fprintf(stderr, "vhost lacks feature mask %" PRIu64 " for backend\n",
 126                 (uint64_t)(~net->dev.features & net->dev.backend_features));
 127         vhost_dev_cleanup(&net->dev);
 128         goto fail;
 129     }
 130
 131     /* Set sane init value. Override when guest acks. */
 132     vhost_net_ack_features(net, 0);
 133     return net;
 134 fail:
 135     g_free(net);
 136     return NULL;
 137 }
 138
 139 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 140 {
 141     return vhost_dev_query(&net->dev, dev);
 142 }
 143
 144 static int vhost_net_start_one(struct vhost_net *net,
 145                                VirtIODevice *dev,
 146                                int vq_index)
 147 {
 148     struct vhost_vring_file file = { };
 149     int r;
 150
 151     if (net->dev.started) {
 152         return 0;
 153     }
 154
 155     net->dev.nvqs = 2;
 156     net->dev.vqs = net->vqs;
 157     net->dev.vq_index = vq_index;
 158
 159     r = vhost_dev_enable_notifiers(&net->dev, dev);
 160     if (r < 0) {
 161         goto fail_notifiers;
 162     }
 163
 164     r = vhost_dev_start(&net->dev, dev);
 165     if (r < 0) {
 166         goto fail_start;
 167     }
 168
 169     net->nc->info->poll(net->nc, false);
 170     qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
 171     file.fd = net->backend;
 172     for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
 173         r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 174         if (r < 0) {
 175             r = -errno;
 176             goto fail;
 177         }
 178     }
 179     return 0;
 180 fail:
 181     file.fd = -1;
 182     while (file.index-- > 0) {
 183         int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 184         assert(r >= 0);
 185     }
 186     net->nc->info->poll(net->nc, true);
 187     vhost_dev_stop(&net->dev, dev);
 188 fail_start:
 189     vhost_dev_disable_notifiers(&net->dev, dev);
 190 fail_notifiers:
 191     return r;
 192 }
 193
 194 static void vhost_net_stop_one(struct vhost_net *net,
 195                                VirtIODevice *dev)
 196 {
 197     struct vhost_vring_file file = { .fd = -1 };
 198
 199     if (!net->dev.started) {
 200         return;
 201     }
 202
 203     for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
 204         int r = ioctl(net->dev.control, VHOST_NET_SET_BACKEND, &file);
 205         assert(r >= 0);
 206     }
 207     net->nc->info->poll(net->nc, true);
 208     vhost_dev_stop(&net->dev, dev);
 209     vhost_dev_disable_notifiers(&net->dev, dev);
 210 }
 211
 212 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs,
 213                     int total_queues)
 214 {
 215     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
 216     VirtioBusState *vbus = VIRTIO_BUS(qbus);
 217     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
 218     int r, i = 0;
 219
 220     if (!k->set_guest_notifiers) {
 221         error_report("binding does not support guest notifiers");
 222         r = -ENOSYS;
 223         goto err;
 224     }
 225
 226     for (i = 0; i < total_queues; i++) {
 227         r = vhost_net_start_one(tap_get_vhost_net(ncs[i].peer), dev, i * 2);
 228
 229         if (r < 0) {
 230             goto err;
 231         }
 232     }
 233
 234     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true);
 235     if (r < 0) {
 236         error_report("Error binding guest notifier: %d", -r);
 237         goto err;
 238     }
 239
 240     return 0;
 241
 242 err:
 243     while (--i >= 0) {
 244         vhost_net_stop_one(tap_get_vhost_net(ncs[i].peer), dev);
 245     }
 246     return r;
 247 }
 248
 249 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs,
 250                     int total_queues)
 251 {
 252     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
 253     VirtioBusState *vbus = VIRTIO_BUS(qbus);
 254     VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
 255     int i, r;
 256
 257     r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
 258     if (r < 0) {
 259         fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r);
 260         fflush(stderr);
 261     }
 262     assert(r >= 0);
 263
 264     for (i = 0; i < total_queues; i++) {
 265         vhost_net_stop_one(tap_get_vhost_net(ncs[i].peer), dev);
 266     }
 267 }
 268
 269 void vhost_net_cleanup(struct vhost_net *net)
 270 {
 271     vhost_dev_cleanup(&net->dev);
 272     g_free(net);
 273 }
 274
 275 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
 276 {
 277     return vhost_virtqueue_pending(&net->dev, idx);
 278 }
 279
 280 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
 281                               int idx, bool mask)
 282 {
 283     vhost_virtqueue_mask(&net->dev, dev, idx, mask);
 284 }
 285 #else
 286 struct vhost_net *vhost_net_init(NetClientState *backend, int devfd,
 287                                  bool force)
 288 {
 289     error_report("vhost-net support is not compiled in");
 290     return NULL;
 291 }
 292
 293 bool vhost_net_query(VHostNetState *net, VirtIODevice *dev)
 294 {
 295     return false;
 296 }
 297
 298 int vhost_net_start(VirtIODevice *dev,
 299                     NetClientState *ncs,
 300                     int total_queues)
 301 {
 302     return -ENOSYS;
 303 }
 304 void vhost_net_stop(VirtIODevice *dev,
 305                     NetClientState *ncs,
 306                     int total_queues)
 307 {
 308 }
 309
 310 void vhost_net_cleanup(struct vhost_net *net)
 311 {
 312 }
 313
 314 unsigned vhost_net_get_features(struct vhost_net *net, unsigned features)
 315 {
 316     return features;
 317 }
 318 void vhost_net_ack_features(struct vhost_net *net, unsigned features)
 319 {
 320 }
 321
 322 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
 323 {
 324     return false;
 325 }
 326
 327 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
 328                               int idx, bool mask)
 329 {
 330 }
 331 #endif