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 "qemu-kvm.h"
  18
  19 /* from Linux's virtio_net.h */
  20
  21 /* The ID for virtio_net */
  22 #define VIRTIO_ID_NET   1
  23
  24 /* The feature bitmap for virtio net */
  25 #define VIRTIO_NET_F_CSUM       0       /* Host handles pkts w/ partial csum */
  26 #define VIRTIO_NET_F_GUEST_CSUM 1       /* Guest handles pkts w/ partial csum */
  27 #define VIRTIO_NET_F_MAC        5       /* Host has given MAC address. */
  28 #define VIRTIO_NET_F_GSO        6       /* Host handles pkts w/ any GSO type */
  29 #define VIRTIO_NET_F_GUEST_TSO4 7       /* Guest can handle TSOv4 in. */
  30 #define VIRTIO_NET_F_GUEST_TSO6 8       /* Guest can handle TSOv6 in. */
  31 #define VIRTIO_NET_F_GUEST_ECN  9       /* Guest can handle TSO[6] w/ ECN in. */
  32 #define VIRTIO_NET_F_GUEST_UFO  10      /* Guest can handle UFO in. */
  33 #define VIRTIO_NET_F_HOST_TSO4  11      /* Host can handle TSOv4 in. */
  34 #define VIRTIO_NET_F_HOST_TSO6  12      /* Host can handle TSOv6 in. */
  35 #define VIRTIO_NET_F_HOST_ECN   13      /* Host can handle TSO[6] w/ ECN in. */
  36 #define VIRTIO_NET_F_HOST_UFO   14      /* Host can handle UFO in. */
  37
  38 #define TX_TIMER_INTERVAL 250000 /* 250 us */
  39
  40 /* The config defining mac address (6 bytes) */
  41 struct virtio_net_config
  42 {
  43     uint8_t mac[6];
  44 } __attribute__((packed));
  45
  46 /* This is the first element of the scatter-gather list.  If you don't
  47  * specify GSO or CSUM features, you can simply ignore the header. */
  48 struct virtio_net_hdr
  49 {
  50 #define VIRTIO_NET_HDR_F_NEEDS_CSUM     1       // Use csum_start, csum_offset
  51     uint8_t flags;
  52 #define VIRTIO_NET_HDR_GSO_NONE         0       // Not a GSO frame
  53 #define VIRTIO_NET_HDR_GSO_TCPV4        1       // GSO frame, IPv4 TCP (TSO)
  54 #define VIRTIO_NET_HDR_GSO_UDP          3       // GSO frame, IPv4 UDP (UFO)
  55 #define VIRTIO_NET_HDR_GSO_TCPV6        4       // GSO frame, IPv6 TCP
  56 #define VIRTIO_NET_HDR_GSO_ECN          0x80    // TCP has ECN set
  57     uint8_t gso_type;
  58     uint16_t hdr_len;
  59     uint16_t gso_size;
  60     uint16_t csum_start;
  61     uint16_t csum_offset;
  62 };
  63
  64 typedef struct VirtIONet
  65 {
  66     VirtIODevice vdev;
  67     uint8_t mac[6];
  68     VirtQueue *rx_vq;
  69     VirtQueue *tx_vq;
  70     VLANClientState *vc;
  71     QEMUTimer *tx_timer;
  72     int tx_timer_active;
  73 } VirtIONet;
  74
  75 /* TODO
  76  * - we could suppress RX interrupt if we were so inclined.
  77  */
  78
  79 static VirtIONet *to_virtio_net(VirtIODevice *vdev)
  80 {
  81     return (VirtIONet *)vdev;
  82 }
  83
  84 static void virtio_net_update_config(VirtIODevice *vdev, uint8_t *config)
  85 {
  86     VirtIONet *n = to_virtio_net(vdev);
  87     struct virtio_net_config netcfg;
  88
  89     memcpy(netcfg.mac, n->mac, 6);
  90     memcpy(config, &netcfg, sizeof(netcfg));
  91 }
  92
  93 static uint32_t virtio_net_get_features(VirtIODevice *vdev)
  94 {
  95     VirtIONet *n = to_virtio_net(vdev);
  96     VLANClientState *host = n->vc->vlan->first_client;
  97     uint32_t features = (1 << VIRTIO_NET_F_MAC);
  98
  99     if (tap_has_vnet_hdr(host)) {
 100         features |= (1 << VIRTIO_NET_F_CSUM);
 101         features |= (1 << VIRTIO_NET_F_GUEST_CSUM);
 102         features |= (1 << VIRTIO_NET_F_GUEST_TSO4);
 103         features |= (1 << VIRTIO_NET_F_GUEST_TSO6);
 104         features |= (1 << VIRTIO_NET_F_GUEST_ECN);
 105         features |= (1 << VIRTIO_NET_F_HOST_TSO4);
 106         features |= (1 << VIRTIO_NET_F_HOST_TSO6);
 107         features |= (1 << VIRTIO_NET_F_HOST_ECN);
 108         /* Kernel can't actually handle UFO in software currently. */
 109     }
 110
 111     return features;
 112 }
 113
 114 static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
 115 {
 116     VirtIONet *n = to_virtio_net(vdev);
 117     VLANClientState *host = n->vc->vlan->first_client;
 118
 119     if (!tap_has_vnet_hdr(host) || !host->set_offload)
 120         return;
 121
 122     host->set_offload(host,
 123                       (features >> VIRTIO_NET_F_GUEST_CSUM) & 1,
 124                       (features >> VIRTIO_NET_F_GUEST_TSO4) & 1,
 125                       (features >> VIRTIO_NET_F_GUEST_TSO6) & 1,
 126                       (features >> VIRTIO_NET_F_GUEST_ECN)  & 1);
 127 }
 128
 129 /* RX */
 130
 131 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
 132 {
 133     /* We now have RX buffers, signal to the IO thread to break out of the
 134        select to re-poll the tap file descriptor */
 135     if (kvm_enabled())
 136         qemu_kvm_notify_work();
 137 }
 138
 139 static int virtio_net_can_receive(void *opaque)
 140 {
 141     VirtIONet *n = opaque;
 142
 143     if (n->rx_vq->vring.avail == NULL ||
 144         !(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 145         return 0;
 146
 147     if (n->rx_vq->vring.avail->idx == n->rx_vq->last_avail_idx) {
 148         n->rx_vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
 149         return 0;
 150     }
 151
 152     n->rx_vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
 153     return 1;
 154 }
 155
 156 static void virtio_net_receive(void *opaque, const uint8_t *buf, int size)
 157 {
 158     VirtIONet *n = opaque;
 159     VirtQueueElement elem;
 160     struct virtio_net_hdr *hdr;
 161     int offset, i;
 162     int total;
 163
 164     if (virtqueue_pop(n->rx_vq, &elem) == 0)
 165         return;
 166
 167     if (elem.in_num < 1 || elem.in_sg[0].iov_len != sizeof(*hdr)) {
 168         fprintf(stderr, "virtio-net header not in first element\n");
 169         exit(1);
 170     }
 171
 172     hdr = (void *)elem.in_sg[0].iov_base;
 173     hdr->flags = 0;
 174     hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
 175
 176     offset = 0;
 177     total = sizeof(*hdr);
 178
 179     if (tap_has_vnet_hdr(n->vc->vlan->first_client)) {
 180         memcpy(hdr, buf, sizeof(*hdr));
 181         offset += total;
 182     }
 183
 184     /* copy in packet.  ugh */
 185     i = 1;
 186     while (offset < size && i < elem.in_num) {
 187         int len = MIN(elem.in_sg[i].iov_len, size - offset);
 188         memcpy(elem.in_sg[i].iov_base, buf + offset, len);
 189         offset += len;
 190         total += len;
 191         i++;
 192     }
 193
 194     /* signal other side */
 195     virtqueue_push(n->rx_vq, &elem, total);
 196     virtio_notify(&n->vdev, n->rx_vq);
 197 }
 198
 199 /* TX */
 200 static void virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq)
 201 {
 202     VirtQueueElement elem;
 203     int has_vnet_hdr = tap_has_vnet_hdr(n->vc->vlan->first_client);
 204
 205     if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 206         return;
 207
 208     while (virtqueue_pop(vq, &elem)) {
 209         ssize_t len = 0;
 210         unsigned int out_num = elem.out_num;
 211         struct iovec *out_sg = &elem.out_sg[0];
 212
 213         if (out_num < 1 || out_sg->iov_len != sizeof(struct virtio_net_hdr)) {
 214             fprintf(stderr, "virtio-net header not in first element\n");
 215             exit(1);
 216         }
 217
 218         /* ignore the header if GSO is not supported */
 219         if (!has_vnet_hdr) {
 220             out_num--;
 221             out_sg++;
 222             len += sizeof(struct virtio_net_hdr);
 223         }
 224
 225         len += qemu_sendv_packet(n->vc, out_sg, out_num);
 226
 227         virtqueue_push(vq, &elem, len);
 228         virtio_notify(&n->vdev, vq);
 229     }
 230 }
 231
 232 static void virtio_net_handle_tx(VirtIODevice *vdev, VirtQueue *vq)
 233 {
 234     VirtIONet *n = to_virtio_net(vdev);
 235
 236     if (n->tx_timer_active) {
 237         vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
 238         qemu_del_timer(n->tx_timer);
 239         n->tx_timer_active = 0;
 240         virtio_net_flush_tx(n, vq);
 241     } else {
 242         qemu_mod_timer(n->tx_timer,
 243                        qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
 244         n->tx_timer_active = 1;
 245         vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
 246     }
 247 }
 248
 249 static void virtio_net_tx_timer(void *opaque)
 250 {
 251     VirtIONet *n = opaque;
 252
 253     n->tx_timer_active = 0;
 254
 255     /* Just in case the driver is not ready on more */
 256     if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
 257         return;
 258
 259     n->tx_vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
 260     virtio_net_flush_tx(n, n->tx_vq);
 261 }
 262
 263 static void virtio_net_save(QEMUFile *f, void *opaque)
 264 {
 265     VirtIONet *n = opaque;
 266
 267     virtio_save(&n->vdev, f);
 268
 269     qemu_put_buffer(f, n->mac, 6);
 270     qemu_put_be32(f, n->tx_timer_active);
 271 }
 272
 273 static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
 274 {
 275     VirtIONet *n = opaque;
 276
 277     if (version_id != 1)
 278         return -EINVAL;
 279
 280     virtio_load(&n->vdev, f);
 281
 282     qemu_get_buffer(f, n->mac, 6);
 283     n->tx_timer_active = qemu_get_be32(f);
 284
 285     if (n->tx_timer_active) {
 286         qemu_mod_timer(n->tx_timer,
 287                        qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
 288     }
 289
 290     return 0;
 291 }
 292
 293 PCIDevice *virtio_net_init(PCIBus *bus, NICInfo *nd, int devfn)
 294 {
 295     VirtIONet *n;
 296     static int virtio_net_id;
 297
 298     n = (VirtIONet *)virtio_init_pci(bus, "virtio-net", 6900, 0x1000,
 299                                      0, VIRTIO_ID_NET,
 300                                      0x02, 0x00, 0x00,
 301                                      6, sizeof(VirtIONet));
 302     if (!n)
 303         return NULL;
 304
 305     n->vdev.update_config = virtio_net_update_config;
 306     n->vdev.get_features = virtio_net_get_features;
 307     n->vdev.set_features = virtio_net_set_features;
 308     n->rx_vq = virtio_add_queue(&n->vdev, 128, virtio_net_handle_rx);
 309     n->tx_vq = virtio_add_queue(&n->vdev, 128, virtio_net_handle_tx);
 310     memcpy(n->mac, nd->macaddr, 6);
 311     n->vc = qemu_new_vlan_client(nd->vlan, virtio_net_receive,
 312                                  virtio_net_can_receive, n);
 313
 314     n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
 315     n->tx_timer_active = 0;
 316
 317     register_savevm("virtio-net", virtio_net_id++, 1,
 318                     virtio_net_save, virtio_net_load, n);
 319
 320     return (PCIDevice *)n;
 321 }