hw/virtio-net.c

   1 /*
   2  * Virtio Network Device
   3  *
   4  * Copyright IBM, Corp. 2007
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.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  */
  13
  14 #include "virtio.h"
  15 #include "net.h"
  16 #include "qemu-timer.h"
  17 #include "virtio-net.h"
  18
  19 #define VIRTIO_NET_VM_VERSION    3
  20
  21 typedef struct VirtIONet
  22 {
  23     VirtIODevice vdev;
  24     uint8_t mac[ETH_ALEN];
  25     uint16_t status;
  26     VirtQueue *rx_vq;
  27     VirtQueue *tx_vq;
  28     VLANClientState *vc;
  29     QEMUTimer *tx_timer;
  30     int tx_timer_active;
  31     int mergeable_rx_bufs;
  32 } VirtIONet;
  33
  34 /* TODO
  35  * - we could suppress RX interrupt if we were so inclined.
  36  */
  37
  38 static VirtIONet *to_virtio_net(VirtIODevice *vdev)
  39 {
  40     return (VirtIONet *)vdev;
  41 }
  42
  43 static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
  44 {
  45     VirtIONet *n = to_virtio_net(vdev);
  46     struct virtio_net_config netcfg;
  47
  48     netcfg.status = n->status;
  49     memcpy(netcfg.mac, n->mac, ETH_ALEN);
  50     memcpy(config, &netcfg, sizeof(netcfg));
  51 }
  52
  53 static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
  54 {
  55     VirtIONet *n = to_virtio_net(vdev);
  56     struct virtio_net_config netcfg;
  57
  58     memcpy(&netcfg, config, sizeof(netcfg));
  59
  60     if (memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
  61         memcpy(n->mac, netcfg.mac, ETH_ALEN);
  62         qemu_format_nic_info_str(n->vc, n->mac);
  63     }
  64 }
  65
  66 static void virtio_net_set_link_status(VLANClientState *vc)
  67 {
  68     VirtIONet *n = vc->opaque;
  69     uint16_t old_status = n->status;
  70
  71     if (vc->link_down)
  72         n->status &= ~VIRTIO_NET_S_LINK_UP;
  73     else
  74         n->status |= VIRTIO_NET_S_LINK_UP;
  75
  76     if (n->status != old_status)
  77         virtio_notify_config(&n->vdev);
  78 }
  79
  80 static uint32_t virtio_net_get_features(VirtIODevice *vdev)
  81 {
  82     uint32_t features = (1 << VIRTIO_NET_F_MAC) | (1 << VIRTIO_NET_F_STATUS);
  83
  84     return features;
  85 }
  86
  87 static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
  88 {
  89     VirtIONet *n = to_virtio_net(vdev);
  90
  91     n->mergeable_rx_bufs = !!(features & (1 << VIRTIO_NET_F_MRG_RXBUF));
  92 }
  93
  94 /* RX */
  95
  96 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
  97 {
  98 }
  99
 100 static int do_virtio_net_can_receive(VirtIONet *n, int bufsize)
 101 {
 102     if (!virtio_queue_ready(n->rx_vq) ||
 103         !(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 104         return 0;
 105
 106     if (virtio_queue_empty(n->rx_vq) ||
 107         (n->mergeable_rx_bufs &&
 108          !virtqueue_avail_bytes(n->rx_vq, bufsize, 0))) {
 109         virtio_queue_set_notification(n->rx_vq, 1);
 110         return 0;
 111     }
 112
 113     virtio_queue_set_notification(n->rx_vq, 0);
 114     return 1;
 115 }
 116
 117 static int virtio_net_can_receive(void *opaque)
 118 {
 119     VirtIONet *n = opaque;
 120
 121     return do_virtio_net_can_receive(n, VIRTIO_NET_MAX_BUFSIZE);
 122 }
 123
 124 static int iov_fill(struct iovec *iov, int iovcnt, const void *buf, int count)
 125 {
 126     int offset, i;
 127
 128     offset = i = 0;
 129     while (offset < count && i < iovcnt) {
 130         int len = MIN(iov[i].iov_len, count - offset);
 131         memcpy(iov[i].iov_base, buf + offset, len);
 132         offset += len;
 133         i++;
 134     }
 135
 136     return offset;
 137 }
 138
 139 static int receive_header(VirtIONet *n, struct iovec *iov, int iovcnt,
 140                           const void *buf, size_t size, size_t hdr_len)
 141 {
 142     struct virtio_net_hdr *hdr = iov[0].iov_base;
 143     int offset = 0;
 144
 145     hdr->flags = 0;
 146     hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
 147
 148     /* We only ever receive a struct virtio_net_hdr from the tapfd,
 149      * but we may be passing along a larger header to the guest.
 150      */
 151     iov[0].iov_base += hdr_len;
 152     iov[0].iov_len  -= hdr_len;
 153
 154     return offset;
 155 }
 156
 157 static void virtio_net_receive(void *opaque, const uint8_t *buf, int size)
 158 {
 159     VirtIONet *n = opaque;
 160     struct virtio_net_hdr_mrg_rxbuf *mhdr = NULL;
 161     size_t hdr_len, offset, i;
 162
 163     if (!do_virtio_net_can_receive(n, size))
 164         return;
 165
 166     /* hdr_len refers to the header we supply to the guest */
 167     hdr_len = n->mergeable_rx_bufs ?
 168         sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
 169
 170     offset = i = 0;
 171
 172     while (offset < size) {
 173         VirtQueueElement elem;
 174         int len, total;
 175         struct iovec sg[VIRTQUEUE_MAX_SIZE];
 176
 177         len = total = 0;
 178
 179         if ((i != 0 && !n->mergeable_rx_bufs) ||
 180             virtqueue_pop(n->rx_vq, &elem) == 0) {
 181             if (i == 0)
 182                 return;
 183             fprintf(stderr, "virtio-net truncating packet\n");
 184             exit(1);
 185         }
 186
 187         if (elem.in_num < 1) {
 188             fprintf(stderr, "virtio-net receive queue contains no in buffers\n");
 189             exit(1);
 190         }
 191
 192         if (!n->mergeable_rx_bufs && elem.in_sg[0].iov_len != hdr_len) {
 193             fprintf(stderr, "virtio-net header not in first element\n");
 194             exit(1);
 195         }
 196
 197         memcpy(&sg, &elem.in_sg[0], sizeof(sg[0]) * elem.in_num);
 198
 199         if (i == 0) {
 200             if (n->mergeable_rx_bufs)
 201                 mhdr = (struct virtio_net_hdr_mrg_rxbuf *)sg[0].iov_base;
 202
 203             offset += receive_header(n, sg, elem.in_num,
 204                                      buf + offset, size - offset, hdr_len);
 205             total += hdr_len;
 206         }
 207
 208         /* copy in packet.  ugh */
 209         len = iov_fill(sg, elem.in_num,
 210                        buf + offset, size - offset);
 211         total += len;
 212
 213         /* signal other side */
 214         virtqueue_fill(n->rx_vq, &elem, total, i++);
 215
 216         offset += len;
 217     }
 218
 219     if (mhdr)
 220         mhdr->num_buffers = i;
 221
 222     virtqueue_flush(n->rx_vq, i);
 223     virtio_notify(&n->vdev, n->rx_vq);
 224 }
 225
 226 /* TX */
 227 static void virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq)
 228 {
 229     VirtQueueElement elem;
 230     int has_vnet_hdr = 0;
 231
 232     if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 233         return;
 234
 235     while (virtqueue_pop(vq, &elem)) {
 236         ssize_t len = 0;
 237         unsigned int out_num = elem.out_num;
 238         struct iovec *out_sg = &elem.out_sg[0];
 239         unsigned hdr_len;
 240
 241         /* hdr_len refers to the header received from the guest */
 242         hdr_len = n->mergeable_rx_bufs ?
 243             sizeof(struct virtio_net_hdr_mrg_rxbuf) :
 244             sizeof(struct virtio_net_hdr);
 245
 246         if (out_num < 1 || out_sg->iov_len != hdr_len) {
 247             fprintf(stderr, "virtio-net header not in first element\n");
 248             exit(1);
 249         }
 250
 251         /* ignore the header if GSO is not supported */
 252         if (!has_vnet_hdr) {
 253             out_num--;
 254             out_sg++;
 255             len += hdr_len;
 256         } else if (n->mergeable_rx_bufs) {
 257             /* tapfd expects a struct virtio_net_hdr */
 258             hdr_len -= sizeof(struct virtio_net_hdr);
 259             out_sg->iov_len -= hdr_len;
 260             len += hdr_len;
 261         }
 262
 263         len += qemu_sendv_packet(n->vc, out_sg, out_num);
 264
 265         virtqueue_push(vq, &elem, len);
 266         virtio_notify(&n->vdev, vq);
 267     }
 268 }
 269
 270 static void virtio_net_handle_tx(VirtIODevice *vdev, VirtQueue *vq)
 271 {
 272     VirtIONet *n = to_virtio_net(vdev);
 273
 274     if (n->tx_timer_active) {
 275         virtio_queue_set_notification(vq, 1);
 276         qemu_del_timer(n->tx_timer);
 277         n->tx_timer_active = 0;
 278         virtio_net_flush_tx(n, vq);
 279     } else {
 280         qemu_mod_timer(n->tx_timer,
 281                        qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
 282         n->tx_timer_active = 1;
 283         virtio_queue_set_notification(vq, 0);
 284     }
 285 }
 286
 287 static void virtio_net_tx_timer(void *opaque)
 288 {
 289     VirtIONet *n = opaque;
 290
 291     n->tx_timer_active = 0;
 292
 293     /* Just in case the driver is not ready on more */
 294     if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 295         return;
 296
 297     virtio_queue_set_notification(n->tx_vq, 1);
 298     virtio_net_flush_tx(n, n->tx_vq);
 299 }
 300
 301 static void virtio_net_save(QEMUFile *f, void *opaque)
 302 {
 303     VirtIONet *n = opaque;
 304
 305     virtio_save(&n->vdev, f);
 306
 307     qemu_put_buffer(f, n->mac, ETH_ALEN);
 308     qemu_put_be32(f, n->tx_timer_active);
 309     qemu_put_be32(f, n->mergeable_rx_bufs);
 310     qemu_put_be16(f, n->status);
 311 }
 312
 313 static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
 314 {
 315     VirtIONet *n = opaque;
 316
 317     if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
 318         return -EINVAL;
 319
 320     virtio_load(&n->vdev, f);
 321
 322     qemu_get_buffer(f, n->mac, ETH_ALEN);
 323     n->tx_timer_active = qemu_get_be32(f);
 324     n->mergeable_rx_bufs = qemu_get_be32(f);
 325
 326     if (version_id >= 3)
 327         n->status = qemu_get_be16(f);
 328
 329     if (n->tx_timer_active) {
 330         qemu_mod_timer(n->tx_timer,
 331                        qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
 332     }
 333
 334     return 0;
 335 }
 336
 337 void virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn)
 338 {
 339     VirtIONet *n;
 340     static int virtio_net_id;
 341
 342     n = (VirtIONet *)virtio_init_pci(bus, "virtio-net",
 343                                      PCI_VENDOR_ID_REDHAT_QUMRANET,
 344                                      PCI_DEVICE_ID_VIRTIO_NET,
 345                                      PCI_VENDOR_ID_REDHAT_QUMRANET,
 346                                      VIRTIO_ID_NET,
 347                                      PCI_CLASS_NETWORK_ETHERNET, 0x00,
 348                                      sizeof(struct virtio_net_config),
 349                                      sizeof(VirtIONet));
 350     if (!n)
 351         return;
 352
 353     n->vdev.get_config = virtio_net_get_config;
 354     n->vdev.set_config = virtio_net_set_config;
 355     n->vdev.get_features = virtio_net_get_features;
 356     n->vdev.set_features = virtio_net_set_features;
 357     n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx);
 358     n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx);
 359     memcpy(n->mac, nd->macaddr, ETH_ALEN);
 360     n->status = VIRTIO_NET_S_LINK_UP;
 361     n->vc = qemu_new_vlan_client(nd->vlan, nd->model, nd->name,
 362                                  virtio_net_receive, virtio_net_can_receive, n);
 363     n->vc->link_status_changed = virtio_net_set_link_status;
 364
 365     qemu_format_nic_info_str(n->vc, n->mac);
 366
 367     n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
 368     n->tx_timer_active = 0;
 369     n->mergeable_rx_bufs = 0;
 370
 371     register_savevm("virtio-net", virtio_net_id++, VIRTIO_NET_VM_VERSION,
 372                     virtio_net_save, virtio_net_load, n);
 373 }