hw/net/virtio-net.c

   1 /*
   2  * Virtio Network Device
   3  *
   4  * Copyright IBM, Corp. 2007
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <[email protected]>
   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 "qemu/osdep.h"
  15 #include "qemu/iov.h"
  16 #include "qemu/main-loop.h"
  17 #include "qemu/module.h"
  18 #include "hw/virtio/virtio.h"
  19 #include "net/net.h"
  20 #include "net/checksum.h"
  21 #include "net/tap.h"
  22 #include "qemu/error-report.h"
  23 #include "qemu/timer.h"
  24 #include "hw/virtio/virtio-net.h"
  25 #include "net/vhost_net.h"
  26 #include "net/announce.h"
  27 #include "hw/virtio/virtio-bus.h"
  28 #include "qapi/error.h"
  29 #include "qapi/qapi-events-net.h"
  30 #include "hw/virtio/virtio-access.h"
  31 #include "migration/misc.h"
  32 #include "standard-headers/linux/ethtool.h"
  33 #include "trace.h"
  34
  35 #define VIRTIO_NET_VM_VERSION    11
  36
  37 #define MAC_TABLE_ENTRIES    64
  38 #define MAX_VLAN    (1 << 12)   /* Per 802.1Q definition */
  39
  40 /* previously fixed value */
  41 #define VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE 256
  42 #define VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE 256
  43
  44 /* for now, only allow larger queues; with virtio-1, guest can downsize */
  45 #define VIRTIO_NET_RX_QUEUE_MIN_SIZE VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE
  46 #define VIRTIO_NET_TX_QUEUE_MIN_SIZE VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
  47
  48 #define VIRTIO_NET_IP4_ADDR_SIZE   8        /* ipv4 saddr + daddr */
  49
  50 #define VIRTIO_NET_TCP_FLAG         0x3F
  51 #define VIRTIO_NET_TCP_HDR_LENGTH   0xF000
  52
  53 /* IPv4 max payload, 16 bits in the header */
  54 #define VIRTIO_NET_MAX_IP4_PAYLOAD (65535 - sizeof(struct ip_header))
  55 #define VIRTIO_NET_MAX_TCP_PAYLOAD 65535
  56
  57 /* header length value in ip header without option */
  58 #define VIRTIO_NET_IP4_HEADER_LENGTH 5
  59
  60 #define VIRTIO_NET_IP6_ADDR_SIZE   32      /* ipv6 saddr + daddr */
  61 #define VIRTIO_NET_MAX_IP6_PAYLOAD VIRTIO_NET_MAX_TCP_PAYLOAD
  62
  63 /* Purge coalesced packets timer interval, This value affects the performance
  64    a lot, and should be tuned carefully, '300000'(300us) is the recommended
  65    value to pass the WHQL test, '50000' can gain 2x netperf throughput with
  66    tso/gso/gro 'off'. */
  67 #define VIRTIO_NET_RSC_DEFAULT_INTERVAL 300000
  68
  69 /* temporary until standard header include it */
  70 #if !defined(VIRTIO_NET_HDR_F_RSC_INFO)
  71
  72 #define VIRTIO_NET_HDR_F_RSC_INFO  4 /* rsc_ext data in csum_ fields */
  73 #define VIRTIO_NET_F_RSC_EXT       61
  74
  75 static inline __virtio16 *virtio_net_rsc_ext_num_packets(
  76     struct virtio_net_hdr *hdr)
  77 {
  78     return &hdr->csum_start;
  79 }
  80
  81 static inline __virtio16 *virtio_net_rsc_ext_num_dupacks(
  82     struct virtio_net_hdr *hdr)
  83 {
  84     return &hdr->csum_offset;
  85 }
  86
  87 #endif
  88
  89 static VirtIOFeature feature_sizes[] = {
  90     {.flags = 1ULL << VIRTIO_NET_F_MAC,
  91      .end = virtio_endof(struct virtio_net_config, mac)},
  92     {.flags = 1ULL << VIRTIO_NET_F_STATUS,
  93      .end = virtio_endof(struct virtio_net_config, status)},
  94     {.flags = 1ULL << VIRTIO_NET_F_MQ,
  95      .end = virtio_endof(struct virtio_net_config, max_virtqueue_pairs)},
  96     {.flags = 1ULL << VIRTIO_NET_F_MTU,
  97      .end = virtio_endof(struct virtio_net_config, mtu)},
  98     {.flags = 1ULL << VIRTIO_NET_F_SPEED_DUPLEX,
  99      .end = virtio_endof(struct virtio_net_config, duplex)},
 100     {}
 101 };
 102
 103 static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
 104 {
 105     VirtIONet *n = qemu_get_nic_opaque(nc);
 106
 107     return &n->vqs[nc->queue_index];
 108 }
 109
 110 static int vq2q(int queue_index)
 111 {
 112     return queue_index / 2;
 113 }
 114
 115 /* TODO
 116  * - we could suppress RX interrupt if we were so inclined.
 117  */
 118
 119 static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
 120 {
 121     VirtIONet *n = VIRTIO_NET(vdev);
 122     struct virtio_net_config netcfg;
 123
 124     virtio_stw_p(vdev, &netcfg.status, n->status);
 125     virtio_stw_p(vdev, &netcfg.max_virtqueue_pairs, n->max_queues);
 126     virtio_stw_p(vdev, &netcfg.mtu, n->net_conf.mtu);
 127     memcpy(netcfg.mac, n->mac, ETH_ALEN);
 128     virtio_stl_p(vdev, &netcfg.speed, n->net_conf.speed);
 129     netcfg.duplex = n->net_conf.duplex;
 130     memcpy(config, &netcfg, n->config_size);
 131 }
 132
 133 static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
 134 {
 135     VirtIONet *n = VIRTIO_NET(vdev);
 136     struct virtio_net_config netcfg = {};
 137
 138     memcpy(&netcfg, config, n->config_size);
 139
 140     if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR) &&
 141         !virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1) &&
 142         memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
 143         memcpy(n->mac, netcfg.mac, ETH_ALEN);
 144         qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
 145     }
 146 }
 147
 148 static bool virtio_net_started(VirtIONet *n, uint8_t status)
 149 {
 150     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 151     return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
 152         (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
 153 }
 154
 155 static void virtio_net_announce_notify(VirtIONet *net)
 156 {
 157     VirtIODevice *vdev = VIRTIO_DEVICE(net);
 158     trace_virtio_net_announce_notify();
 159
 160     net->status |= VIRTIO_NET_S_ANNOUNCE;
 161     virtio_notify_config(vdev);
 162 }
 163
 164 static void virtio_net_announce_timer(void *opaque)
 165 {
 166     VirtIONet *n = opaque;
 167     trace_virtio_net_announce_timer(n->announce_timer.round);
 168
 169     n->announce_timer.round--;
 170     virtio_net_announce_notify(n);
 171 }
 172
 173 static void virtio_net_announce(NetClientState *nc)
 174 {
 175     VirtIONet *n = qemu_get_nic_opaque(nc);
 176     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 177
 178     /*
 179      * Make sure the virtio migration announcement timer isn't running
 180      * If it is, let it trigger announcement so that we do not cause
 181      * confusion.
 182      */
 183     if (n->announce_timer.round) {
 184         return;
 185     }
 186
 187     if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
 188         virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
 189             virtio_net_announce_notify(n);
 190     }
 191 }
 192
 193 static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
 194 {
 195     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 196     NetClientState *nc = qemu_get_queue(n->nic);
 197     int queues = n->multiqueue ? n->max_queues : 1;
 198
 199     if (!get_vhost_net(nc->peer)) {
 200         return;
 201     }
 202
 203     if ((virtio_net_started(n, status) && !nc->peer->link_down) ==
 204         !!n->vhost_started) {
 205         return;
 206     }
 207     if (!n->vhost_started) {
 208         int r, i;
 209
 210         if (n->needs_vnet_hdr_swap) {
 211             error_report("backend does not support %s vnet headers; "
 212                          "falling back on userspace virtio",
 213                          virtio_is_big_endian(vdev) ? "BE" : "LE");
 214             return;
 215         }
 216
 217         /* Any packets outstanding? Purge them to avoid touching rings
 218          * when vhost is running.
 219          */
 220         for (i = 0;  i < queues; i++) {
 221             NetClientState *qnc = qemu_get_subqueue(n->nic, i);
 222
 223             /* Purge both directions: TX and RX. */
 224             qemu_net_queue_purge(qnc->peer->incoming_queue, qnc);
 225             qemu_net_queue_purge(qnc->incoming_queue, qnc->peer);
 226         }
 227
 228         if (virtio_has_feature(vdev->guest_features, VIRTIO_NET_F_MTU)) {
 229             r = vhost_net_set_mtu(get_vhost_net(nc->peer), n->net_conf.mtu);
 230             if (r < 0) {
 231                 error_report("%uBytes MTU not supported by the backend",
 232                              n->net_conf.mtu);
 233
 234                 return;
 235             }
 236         }
 237
 238         n->vhost_started = 1;
 239         r = vhost_net_start(vdev, n->nic->ncs, queues);
 240         if (r < 0) {
 241             error_report("unable to start vhost net: %d: "
 242                          "falling back on userspace virtio", -r);
 243             n->vhost_started = 0;
 244         }
 245     } else {
 246         vhost_net_stop(vdev, n->nic->ncs, queues);
 247         n->vhost_started = 0;
 248     }
 249 }
 250
 251 static int virtio_net_set_vnet_endian_one(VirtIODevice *vdev,
 252                                           NetClientState *peer,
 253                                           bool enable)
 254 {
 255     if (virtio_is_big_endian(vdev)) {
 256         return qemu_set_vnet_be(peer, enable);
 257     } else {
 258         return qemu_set_vnet_le(peer, enable);
 259     }
 260 }
 261
 262 static bool virtio_net_set_vnet_endian(VirtIODevice *vdev, NetClientState *ncs,
 263                                        int queues, bool enable)
 264 {
 265     int i;
 266
 267     for (i = 0; i < queues; i++) {
 268         if (virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, enable) < 0 &&
 269             enable) {
 270             while (--i >= 0) {
 271                 virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, false);
 272             }
 273
 274             return true;
 275         }
 276     }
 277
 278     return false;
 279 }
 280
 281 static void virtio_net_vnet_endian_status(VirtIONet *n, uint8_t status)
 282 {
 283     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 284     int queues = n->multiqueue ? n->max_queues : 1;
 285
 286     if (virtio_net_started(n, status)) {
 287         /* Before using the device, we tell the network backend about the
 288          * endianness to use when parsing vnet headers. If the backend
 289          * can't do it, we fallback onto fixing the headers in the core
 290          * virtio-net code.
 291          */
 292         n->needs_vnet_hdr_swap = virtio_net_set_vnet_endian(vdev, n->nic->ncs,
 293                                                             queues, true);
 294     } else if (virtio_net_started(n, vdev->status)) {
 295         /* After using the device, we need to reset the network backend to
 296          * the default (guest native endianness), otherwise the guest may
 297          * lose network connectivity if it is rebooted into a different
 298          * endianness.
 299          */
 300         virtio_net_set_vnet_endian(vdev, n->nic->ncs, queues, false);
 301     }
 302 }
 303
 304 static void virtio_net_drop_tx_queue_data(VirtIODevice *vdev, VirtQueue *vq)
 305 {
 306     unsigned int dropped = virtqueue_drop_all(vq);
 307     if (dropped) {
 308         virtio_notify(vdev, vq);
 309     }
 310 }
 311
 312 static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
 313 {
 314     VirtIONet *n = VIRTIO_NET(vdev);
 315     VirtIONetQueue *q;
 316     int i;
 317     uint8_t queue_status;
 318
 319     virtio_net_vnet_endian_status(n, status);
 320     virtio_net_vhost_status(n, status);
 321
 322     for (i = 0; i < n->max_queues; i++) {
 323         NetClientState *ncs = qemu_get_subqueue(n->nic, i);
 324         bool queue_started;
 325         q = &n->vqs[i];
 326
 327         if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
 328             queue_status = 0;
 329         } else {
 330             queue_status = status;
 331         }
 332         queue_started =
 333             virtio_net_started(n, queue_status) && !n->vhost_started;
 334
 335         if (queue_started) {
 336             qemu_flush_queued_packets(ncs);
 337         }
 338
 339         if (!q->tx_waiting) {
 340             continue;
 341         }
 342
 343         if (queue_started) {
 344             if (q->tx_timer) {
 345                 timer_mod(q->tx_timer,
 346                                qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
 347             } else {
 348                 qemu_bh_schedule(q->tx_bh);
 349             }
 350         } else {
 351             if (q->tx_timer) {
 352                 timer_del(q->tx_timer);
 353             } else {
 354                 qemu_bh_cancel(q->tx_bh);
 355             }
 356             if ((n->status & VIRTIO_NET_S_LINK_UP) == 0 &&
 357                 (queue_status & VIRTIO_CONFIG_S_DRIVER_OK) &&
 358                 vdev->vm_running) {
 359                 /* if tx is waiting we are likely have some packets in tx queue
 360                  * and disabled notification */
 361                 q->tx_waiting = 0;
 362                 virtio_queue_set_notification(q->tx_vq, 1);
 363                 virtio_net_drop_tx_queue_data(vdev, q->tx_vq);
 364             }
 365         }
 366     }
 367 }
 368
 369 static void virtio_net_set_link_status(NetClientState *nc)
 370 {
 371     VirtIONet *n = qemu_get_nic_opaque(nc);
 372     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 373     uint16_t old_status = n->status;
 374
 375     if (nc->link_down)
 376         n->status &= ~VIRTIO_NET_S_LINK_UP;
 377     else
 378         n->status |= VIRTIO_NET_S_LINK_UP;
 379
 380     if (n->status != old_status)
 381         virtio_notify_config(vdev);
 382
 383     virtio_net_set_status(vdev, vdev->status);
 384 }
 385
 386 static void rxfilter_notify(NetClientState *nc)
 387 {
 388     VirtIONet *n = qemu_get_nic_opaque(nc);
 389
 390     if (nc->rxfilter_notify_enabled) {
 391         gchar *path = object_get_canonical_path(OBJECT(n->qdev));
 392         qapi_event_send_nic_rx_filter_changed(!!n->netclient_name,
 393                                               n->netclient_name, path);
 394         g_free(path);
 395
 396         /* disable event notification to avoid events flooding */
 397         nc->rxfilter_notify_enabled = 0;
 398     }
 399 }
 400
 401 static intList *get_vlan_table(VirtIONet *n)
 402 {
 403     intList *list, *entry;
 404     int i, j;
 405
 406     list = NULL;
 407     for (i = 0; i < MAX_VLAN >> 5; i++) {
 408         for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
 409             if (n->vlans[i] & (1U << j)) {
 410                 entry = g_malloc0(sizeof(*entry));
 411                 entry->value = (i << 5) + j;
 412                 entry->next = list;
 413                 list = entry;
 414             }
 415         }
 416     }
 417
 418     return list;
 419 }
 420
 421 static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
 422 {
 423     VirtIONet *n = qemu_get_nic_opaque(nc);
 424     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 425     RxFilterInfo *info;
 426     strList *str_list, *entry;
 427     int i;
 428
 429     info = g_malloc0(sizeof(*info));
 430     info->name = g_strdup(nc->name);
 431     info->promiscuous = n->promisc;
 432
 433     if (n->nouni) {
 434         info->unicast = RX_STATE_NONE;
 435     } else if (n->alluni) {
 436         info->unicast = RX_STATE_ALL;
 437     } else {
 438         info->unicast = RX_STATE_NORMAL;
 439     }
 440
 441     if (n->nomulti) {
 442         info->multicast = RX_STATE_NONE;
 443     } else if (n->allmulti) {
 444         info->multicast = RX_STATE_ALL;
 445     } else {
 446         info->multicast = RX_STATE_NORMAL;
 447     }
 448
 449     info->broadcast_allowed = n->nobcast;
 450     info->multicast_overflow = n->mac_table.multi_overflow;
 451     info->unicast_overflow = n->mac_table.uni_overflow;
 452
 453     info->main_mac = qemu_mac_strdup_printf(n->mac);
 454
 455     str_list = NULL;
 456     for (i = 0; i < n->mac_table.first_multi; i++) {
 457         entry = g_malloc0(sizeof(*entry));
 458         entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
 459         entry->next = str_list;
 460         str_list = entry;
 461     }
 462     info->unicast_table = str_list;
 463
 464     str_list = NULL;
 465     for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
 466         entry = g_malloc0(sizeof(*entry));
 467         entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
 468         entry->next = str_list;
 469         str_list = entry;
 470     }
 471     info->multicast_table = str_list;
 472     info->vlan_table = get_vlan_table(n);
 473
 474     if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VLAN)) {
 475         info->vlan = RX_STATE_ALL;
 476     } else if (!info->vlan_table) {
 477         info->vlan = RX_STATE_NONE;
 478     } else {
 479         info->vlan = RX_STATE_NORMAL;
 480     }
 481
 482     /* enable event notification after query */
 483     nc->rxfilter_notify_enabled = 1;
 484
 485     return info;
 486 }
 487
 488 static void virtio_net_reset(VirtIODevice *vdev)
 489 {
 490     VirtIONet *n = VIRTIO_NET(vdev);
 491     int i;
 492
 493     /* Reset back to compatibility mode */
 494     n->promisc = 1;
 495     n->allmulti = 0;
 496     n->alluni = 0;
 497     n->nomulti = 0;
 498     n->nouni = 0;
 499     n->nobcast = 0;
 500     /* multiqueue is disabled by default */
 501     n->curr_queues = 1;
 502     timer_del(n->announce_timer.tm);
 503     n->announce_timer.round = 0;
 504     n->status &= ~VIRTIO_NET_S_ANNOUNCE;
 505
 506     /* Flush any MAC and VLAN filter table state */
 507     n->mac_table.in_use = 0;
 508     n->mac_table.first_multi = 0;
 509     n->mac_table.multi_overflow = 0;
 510     n->mac_table.uni_overflow = 0;
 511     memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
 512     memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
 513     qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
 514     memset(n->vlans, 0, MAX_VLAN >> 3);
 515
 516     /* Flush any async TX */
 517     for (i = 0;  i < n->max_queues; i++) {
 518         NetClientState *nc = qemu_get_subqueue(n->nic, i);
 519
 520         if (nc->peer) {
 521             qemu_flush_or_purge_queued_packets(nc->peer, true);
 522             assert(!virtio_net_get_subqueue(nc)->async_tx.elem);
 523         }
 524     }
 525 }
 526
 527 static void peer_test_vnet_hdr(VirtIONet *n)
 528 {
 529     NetClientState *nc = qemu_get_queue(n->nic);
 530     if (!nc->peer) {
 531         return;
 532     }
 533
 534     n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
 535 }
 536
 537 static int peer_has_vnet_hdr(VirtIONet *n)
 538 {
 539     return n->has_vnet_hdr;
 540 }
 541
 542 static int peer_has_ufo(VirtIONet *n)
 543 {
 544     if (!peer_has_vnet_hdr(n))
 545         return 0;
 546
 547     n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
 548
 549     return n->has_ufo;
 550 }
 551
 552 static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs,
 553                                        int version_1)
 554 {
 555     int i;
 556     NetClientState *nc;
 557
 558     n->mergeable_rx_bufs = mergeable_rx_bufs;
 559
 560     if (version_1) {
 561         n->guest_hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
 562     } else {
 563         n->guest_hdr_len = n->mergeable_rx_bufs ?
 564             sizeof(struct virtio_net_hdr_mrg_rxbuf) :
 565             sizeof(struct virtio_net_hdr);
 566     }
 567
 568     for (i = 0; i < n->max_queues; i++) {
 569         nc = qemu_get_subqueue(n->nic, i);
 570
 571         if (peer_has_vnet_hdr(n) &&
 572             qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
 573             qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
 574             n->host_hdr_len = n->guest_hdr_len;
 575         }
 576     }
 577 }
 578
 579 static int virtio_net_max_tx_queue_size(VirtIONet *n)
 580 {
 581     NetClientState *peer = n->nic_conf.peers.ncs[0];
 582
 583     /*
 584      * Backends other than vhost-user don't support max queue size.
 585      */
 586     if (!peer) {
 587         return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
 588     }
 589
 590     if (peer->info->type != NET_CLIENT_DRIVER_VHOST_USER) {
 591         return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
 592     }
 593
 594     return VIRTQUEUE_MAX_SIZE;
 595 }
 596
 597 static int peer_attach(VirtIONet *n, int index)
 598 {
 599     NetClientState *nc = qemu_get_subqueue(n->nic, index);
 600
 601     if (!nc->peer) {
 602         return 0;
 603     }
 604
 605     if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
 606         vhost_set_vring_enable(nc->peer, 1);
 607     }
 608
 609     if (nc->peer->info->type != NET_CLIENT_DRIVER_TAP) {
 610         return 0;
 611     }
 612
 613     if (n->max_queues == 1) {
 614         return 0;
 615     }
 616
 617     return tap_enable(nc->peer);
 618 }
 619
 620 static int peer_detach(VirtIONet *n, int index)
 621 {
 622     NetClientState *nc = qemu_get_subqueue(n->nic, index);
 623
 624     if (!nc->peer) {
 625         return 0;
 626     }
 627
 628     if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
 629         vhost_set_vring_enable(nc->peer, 0);
 630     }
 631
 632     if (nc->peer->info->type !=  NET_CLIENT_DRIVER_TAP) {
 633         return 0;
 634     }
 635
 636     return tap_disable(nc->peer);
 637 }
 638
 639 static void virtio_net_set_queues(VirtIONet *n)
 640 {
 641     int i;
 642     int r;
 643
 644     if (n->nic->peer_deleted) {
 645         return;
 646     }
 647
 648     for (i = 0; i < n->max_queues; i++) {
 649         if (i < n->curr_queues) {
 650             r = peer_attach(n, i);
 651             assert(!r);
 652         } else {
 653             r = peer_detach(n, i);
 654             assert(!r);
 655         }
 656     }
 657 }
 658
 659 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
 660
 661 static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
 662                                         Error **errp)
 663 {
 664     VirtIONet *n = VIRTIO_NET(vdev);
 665     NetClientState *nc = qemu_get_queue(n->nic);
 666
 667     /* Firstly sync all virtio-net possible supported features */
 668     features |= n->host_features;
 669
 670     virtio_add_feature(&features, VIRTIO_NET_F_MAC);
 671
 672     if (!peer_has_vnet_hdr(n)) {
 673         virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
 674         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
 675         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
 676         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
 677
 678         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
 679         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
 680         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
 681         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
 682     }
 683
 684     if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
 685         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
 686         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
 687     }
 688
 689     if (!get_vhost_net(nc->peer)) {
 690         return features;
 691     }
 692
 693     features = vhost_net_get_features(get_vhost_net(nc->peer), features);
 694     vdev->backend_features = features;
 695
 696     if (n->mtu_bypass_backend &&
 697             (n->host_features & 1ULL << VIRTIO_NET_F_MTU)) {
 698         features |= (1ULL << VIRTIO_NET_F_MTU);
 699     }
 700
 701     return features;
 702 }
 703
 704 static uint64_t virtio_net_bad_features(VirtIODevice *vdev)
 705 {
 706     uint64_t features = 0;
 707
 708     /* Linux kernel 2.6.25.  It understood MAC (as everyone must),
 709      * but also these: */
 710     virtio_add_feature(&features, VIRTIO_NET_F_MAC);
 711     virtio_add_feature(&features, VIRTIO_NET_F_CSUM);
 712     virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO4);
 713     virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO6);
 714     virtio_add_feature(&features, VIRTIO_NET_F_HOST_ECN);
 715
 716     return features;
 717 }
 718
 719 static void virtio_net_apply_guest_offloads(VirtIONet *n)
 720 {
 721     qemu_set_offload(qemu_get_queue(n->nic)->peer,
 722             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
 723             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
 724             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
 725             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
 726             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
 727 }
 728
 729 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
 730 {
 731     static const uint64_t guest_offloads_mask =
 732         (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
 733         (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
 734         (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
 735         (1ULL << VIRTIO_NET_F_GUEST_ECN)  |
 736         (1ULL << VIRTIO_NET_F_GUEST_UFO);
 737
 738     return guest_offloads_mask & features;
 739 }
 740
 741 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
 742 {
 743     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 744     return virtio_net_guest_offloads_by_features(vdev->guest_features);
 745 }
 746
 747 static void virtio_net_set_features(VirtIODevice *vdev, uint64_t features)
 748 {
 749     VirtIONet *n = VIRTIO_NET(vdev);
 750     int i;
 751
 752     if (n->mtu_bypass_backend &&
 753             !virtio_has_feature(vdev->backend_features, VIRTIO_NET_F_MTU)) {
 754         features &= ~(1ULL << VIRTIO_NET_F_MTU);
 755     }
 756
 757     virtio_net_set_multiqueue(n,
 758                               virtio_has_feature(features, VIRTIO_NET_F_MQ));
 759
 760     virtio_net_set_mrg_rx_bufs(n,
 761                                virtio_has_feature(features,
 762                                                   VIRTIO_NET_F_MRG_RXBUF),
 763                                virtio_has_feature(features,
 764                                                   VIRTIO_F_VERSION_1));
 765
 766     n->rsc4_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
 767         virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO4);
 768     n->rsc6_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
 769         virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO6);
 770
 771     if (n->has_vnet_hdr) {
 772         n->curr_guest_offloads =
 773             virtio_net_guest_offloads_by_features(features);
 774         virtio_net_apply_guest_offloads(n);
 775     }
 776
 777     for (i = 0;  i < n->max_queues; i++) {
 778         NetClientState *nc = qemu_get_subqueue(n->nic, i);
 779
 780         if (!get_vhost_net(nc->peer)) {
 781             continue;
 782         }
 783         vhost_net_ack_features(get_vhost_net(nc->peer), features);
 784     }
 785
 786     if (virtio_has_feature(features, VIRTIO_NET_F_CTRL_VLAN)) {
 787         memset(n->vlans, 0, MAX_VLAN >> 3);
 788     } else {
 789         memset(n->vlans, 0xff, MAX_VLAN >> 3);
 790     }
 791 }
 792
 793 static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
 794                                      struct iovec *iov, unsigned int iov_cnt)
 795 {
 796     uint8_t on;
 797     size_t s;
 798     NetClientState *nc = qemu_get_queue(n->nic);
 799
 800     s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
 801     if (s != sizeof(on)) {
 802         return VIRTIO_NET_ERR;
 803     }
 804
 805     if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
 806         n->promisc = on;
 807     } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
 808         n->allmulti = on;
 809     } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
 810         n->alluni = on;
 811     } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
 812         n->nomulti = on;
 813     } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
 814         n->nouni = on;
 815     } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
 816         n->nobcast = on;
 817     } else {
 818         return VIRTIO_NET_ERR;
 819     }
 820
 821     rxfilter_notify(nc);
 822
 823     return VIRTIO_NET_OK;
 824 }
 825
 826 static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
 827                                      struct iovec *iov, unsigned int iov_cnt)
 828 {
 829     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 830     uint64_t offloads;
 831     size_t s;
 832
 833     if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
 834         return VIRTIO_NET_ERR;
 835     }
 836
 837     s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
 838     if (s != sizeof(offloads)) {
 839         return VIRTIO_NET_ERR;
 840     }
 841
 842     if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
 843         uint64_t supported_offloads;
 844
 845         offloads = virtio_ldq_p(vdev, &offloads);
 846
 847         if (!n->has_vnet_hdr) {
 848             return VIRTIO_NET_ERR;
 849         }
 850
 851         n->rsc4_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
 852             virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO4);
 853         n->rsc6_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
 854             virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO6);
 855         virtio_clear_feature(&offloads, VIRTIO_NET_F_RSC_EXT);
 856
 857         supported_offloads = virtio_net_supported_guest_offloads(n);
 858         if (offloads & ~supported_offloads) {
 859             return VIRTIO_NET_ERR;
 860         }
 861
 862         n->curr_guest_offloads = offloads;
 863         virtio_net_apply_guest_offloads(n);
 864
 865         return VIRTIO_NET_OK;
 866     } else {
 867         return VIRTIO_NET_ERR;
 868     }
 869 }
 870
 871 static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
 872                                  struct iovec *iov, unsigned int iov_cnt)
 873 {
 874     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 875     struct virtio_net_ctrl_mac mac_data;
 876     size_t s;
 877     NetClientState *nc = qemu_get_queue(n->nic);
 878
 879     if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
 880         if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
 881             return VIRTIO_NET_ERR;
 882         }
 883         s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
 884         assert(s == sizeof(n->mac));
 885         qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
 886         rxfilter_notify(nc);
 887
 888         return VIRTIO_NET_OK;
 889     }
 890
 891     if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
 892         return VIRTIO_NET_ERR;
 893     }
 894
 895     int in_use = 0;
 896     int first_multi = 0;
 897     uint8_t uni_overflow = 0;
 898     uint8_t multi_overflow = 0;
 899     uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
 900
 901     s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
 902                    sizeof(mac_data.entries));
 903     mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
 904     if (s != sizeof(mac_data.entries)) {
 905         goto error;
 906     }
 907     iov_discard_front(&iov, &iov_cnt, s);
 908
 909     if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
 910         goto error;
 911     }
 912
 913     if (mac_data.entries <= MAC_TABLE_ENTRIES) {
 914         s = iov_to_buf(iov, iov_cnt, 0, macs,
 915                        mac_data.entries * ETH_ALEN);
 916         if (s != mac_data.entries * ETH_ALEN) {
 917             goto error;
 918         }
 919         in_use += mac_data.entries;
 920     } else {
 921         uni_overflow = 1;
 922     }
 923
 924     iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
 925
 926     first_multi = in_use;
 927
 928     s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
 929                    sizeof(mac_data.entries));
 930     mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
 931     if (s != sizeof(mac_data.entries)) {
 932         goto error;
 933     }
 934
 935     iov_discard_front(&iov, &iov_cnt, s);
 936
 937     if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
 938         goto error;
 939     }
 940
 941     if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
 942         s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
 943                        mac_data.entries * ETH_ALEN);
 944         if (s != mac_data.entries * ETH_ALEN) {
 945             goto error;
 946         }
 947         in_use += mac_data.entries;
 948     } else {
 949         multi_overflow = 1;
 950     }
 951
 952     n->mac_table.in_use = in_use;
 953     n->mac_table.first_multi = first_multi;
 954     n->mac_table.uni_overflow = uni_overflow;
 955     n->mac_table.multi_overflow = multi_overflow;
 956     memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
 957     g_free(macs);
 958     rxfilter_notify(nc);
 959
 960     return VIRTIO_NET_OK;
 961
 962 error:
 963     g_free(macs);
 964     return VIRTIO_NET_ERR;
 965 }
 966
 967 static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
 968                                         struct iovec *iov, unsigned int iov_cnt)
 969 {
 970     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 971     uint16_t vid;
 972     size_t s;
 973     NetClientState *nc = qemu_get_queue(n->nic);
 974
 975     s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
 976     vid = virtio_lduw_p(vdev, &vid);
 977     if (s != sizeof(vid)) {
 978         return VIRTIO_NET_ERR;
 979     }
 980
 981     if (vid >= MAX_VLAN)
 982         return VIRTIO_NET_ERR;
 983
 984     if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
 985         n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
 986     else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
 987         n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
 988     else
 989         return VIRTIO_NET_ERR;
 990
 991     rxfilter_notify(nc);
 992
 993     return VIRTIO_NET_OK;
 994 }
 995
 996 static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
 997                                       struct iovec *iov, unsigned int iov_cnt)
 998 {
 999     trace_virtio_net_handle_announce(n->announce_timer.round);
1000     if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
1001         n->status & VIRTIO_NET_S_ANNOUNCE) {
1002         n->status &= ~VIRTIO_NET_S_ANNOUNCE;
1003         if (n->announce_timer.round) {
1004             qemu_announce_timer_step(&n->announce_timer);
1005         }
1006         return VIRTIO_NET_OK;
1007     } else {
1008         return VIRTIO_NET_ERR;
1009     }
1010 }
1011
1012 static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
1013                                 struct iovec *iov, unsigned int iov_cnt)
1014 {
1015     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1016     struct virtio_net_ctrl_mq mq;
1017     size_t s;
1018     uint16_t queues;
1019
1020     s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
1021     if (s != sizeof(mq)) {
1022         return VIRTIO_NET_ERR;
1023     }
1024
1025     if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
1026         return VIRTIO_NET_ERR;
1027     }
1028
1029     queues = virtio_lduw_p(vdev, &mq.virtqueue_pairs);
1030
1031     if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
1032         queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
1033         queues > n->max_queues ||
1034         !n->multiqueue) {
1035         return VIRTIO_NET_ERR;
1036     }
1037
1038     n->curr_queues = queues;
1039     /* stop the backend before changing the number of queues to avoid handling a
1040      * disabled queue */
1041     virtio_net_set_status(vdev, vdev->status);
1042     virtio_net_set_queues(n);
1043
1044     return VIRTIO_NET_OK;
1045 }
1046
1047 static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
1048 {
1049     VirtIONet *n = VIRTIO_NET(vdev);
1050     struct virtio_net_ctrl_hdr ctrl;
1051     virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
1052     VirtQueueElement *elem;
1053     size_t s;
1054     struct iovec *iov, *iov2;
1055     unsigned int iov_cnt;
1056
1057     for (;;) {
1058         elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
1059         if (!elem) {
1060             break;
1061         }
1062         if (iov_size(elem->in_sg, elem->in_num) < sizeof(status) ||
1063             iov_size(elem->out_sg, elem->out_num) < sizeof(ctrl)) {
1064             virtio_error(vdev, "virtio-net ctrl missing headers");
1065             virtqueue_detach_element(vq, elem, 0);
1066             g_free(elem);
1067             break;
1068         }
1069
1070         iov_cnt = elem->out_num;
1071         iov2 = iov = g_memdup(elem->out_sg, sizeof(struct iovec) * elem->out_num);
1072         s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
1073         iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
1074         if (s != sizeof(ctrl)) {
1075             status = VIRTIO_NET_ERR;
1076         } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
1077             status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
1078         } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
1079             status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
1080         } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
1081             status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
1082         } else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
1083             status = virtio_net_handle_announce(n, ctrl.cmd, iov, iov_cnt);
1084         } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
1085             status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
1086         } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
1087             status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
1088         }
1089
1090         s = iov_from_buf(elem->in_sg, elem->in_num, 0, &status, sizeof(status));
1091         assert(s == sizeof(status));
1092
1093         virtqueue_push(vq, elem, sizeof(status));
1094         virtio_notify(vdev, vq);
1095         g_free(iov2);
1096         g_free(elem);
1097     }
1098 }
1099
1100 /* RX */
1101
1102 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
1103 {
1104     VirtIONet *n = VIRTIO_NET(vdev);
1105     int queue_index = vq2q(virtio_get_queue_index(vq));
1106
1107     qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
1108 }
1109
1110 static int virtio_net_can_receive(NetClientState *nc)
1111 {
1112     VirtIONet *n = qemu_get_nic_opaque(nc);
1113     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1114     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1115
1116     if (!vdev->vm_running) {
1117         return 0;
1118     }
1119
1120     if (nc->queue_index >= n->curr_queues) {
1121         return 0;
1122     }
1123
1124     if (!virtio_queue_ready(q->rx_vq) ||
1125         !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1126         return 0;
1127     }
1128
1129     return 1;
1130 }
1131
1132 static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
1133 {
1134     VirtIONet *n = q->n;
1135     if (virtio_queue_empty(q->rx_vq) ||
1136         (n->mergeable_rx_bufs &&
1137          !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
1138         virtio_queue_set_notification(q->rx_vq, 1);
1139
1140         /* To avoid a race condition where the guest has made some buffers
1141          * available after the above check but before notification was
1142          * enabled, check for available buffers again.
1143          */
1144         if (virtio_queue_empty(q->rx_vq) ||
1145             (n->mergeable_rx_bufs &&
1146              !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
1147             return 0;
1148         }
1149     }
1150
1151     virtio_queue_set_notification(q->rx_vq, 0);
1152     return 1;
1153 }
1154
1155 static void virtio_net_hdr_swap(VirtIODevice *vdev, struct virtio_net_hdr *hdr)
1156 {
1157     virtio_tswap16s(vdev, &hdr->hdr_len);
1158     virtio_tswap16s(vdev, &hdr->gso_size);
1159     virtio_tswap16s(vdev, &hdr->csum_start);
1160     virtio_tswap16s(vdev, &hdr->csum_offset);
1161 }
1162
1163 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
1164  * it never finds out that the packets don't have valid checksums.  This
1165  * causes dhclient to get upset.  Fedora's carried a patch for ages to
1166  * fix this with Xen but it hasn't appeared in an upstream release of
1167  * dhclient yet.
1168  *
1169  * To avoid breaking existing guests, we catch udp packets and add
1170  * checksums.  This is terrible but it's better than hacking the guest
1171  * kernels.
1172  *
1173  * N.B. if we introduce a zero-copy API, this operation is no longer free so
1174  * we should provide a mechanism to disable it to avoid polluting the host
1175  * cache.
1176  */
1177 static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
1178                                         uint8_t *buf, size_t size)
1179 {
1180     if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
1181         (size > 27 && size < 1500) && /* normal sized MTU */
1182         (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
1183         (buf[23] == 17) && /* ip.protocol == UDP */
1184         (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
1185         net_checksum_calculate(buf, size);
1186         hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
1187     }
1188 }
1189
1190 static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
1191                            const void *buf, size_t size)
1192 {
1193     if (n->has_vnet_hdr) {
1194         /* FIXME this cast is evil */
1195         void *wbuf = (void *)buf;
1196         work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
1197                                     size - n->host_hdr_len);
1198
1199         if (n->needs_vnet_hdr_swap) {
1200             virtio_net_hdr_swap(VIRTIO_DEVICE(n), wbuf);
1201         }
1202         iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
1203     } else {
1204         struct virtio_net_hdr hdr = {
1205             .flags = 0,
1206             .gso_type = VIRTIO_NET_HDR_GSO_NONE
1207         };
1208         iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
1209     }
1210 }
1211
1212 static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
1213 {
1214     static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1215     static const uint8_t vlan[] = {0x81, 0x00};
1216     uint8_t *ptr = (uint8_t *)buf;
1217     int i;
1218
1219     if (n->promisc)
1220         return 1;
1221
1222     ptr += n->host_hdr_len;
1223
1224     if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
1225         int vid = lduw_be_p(ptr + 14) & 0xfff;
1226         if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
1227             return 0;
1228     }
1229
1230     if (ptr[0] & 1) { // multicast
1231         if (!memcmp(ptr, bcast, sizeof(bcast))) {
1232             return !n->nobcast;
1233         } else if (n->nomulti) {
1234             return 0;
1235         } else if (n->allmulti || n->mac_table.multi_overflow) {
1236             return 1;
1237         }
1238
1239         for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
1240             if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1241                 return 1;
1242             }
1243         }
1244     } else { // unicast
1245         if (n->nouni) {
1246             return 0;
1247         } else if (n->alluni || n->mac_table.uni_overflow) {
1248             return 1;
1249         } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
1250             return 1;
1251         }
1252
1253         for (i = 0; i < n->mac_table.first_multi; i++) {
1254             if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1255                 return 1;
1256             }
1257         }
1258     }
1259
1260     return 0;
1261 }
1262
1263 static ssize_t virtio_net_receive_rcu(NetClientState *nc, const uint8_t *buf,
1264                                       size_t size)
1265 {
1266     VirtIONet *n = qemu_get_nic_opaque(nc);
1267     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1268     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1269     struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
1270     struct virtio_net_hdr_mrg_rxbuf mhdr;
1271     unsigned mhdr_cnt = 0;
1272     size_t offset, i, guest_offset;
1273
1274     if (!virtio_net_can_receive(nc)) {
1275         return -1;
1276     }
1277
1278     /* hdr_len refers to the header we supply to the guest */
1279     if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
1280         return 0;
1281     }
1282
1283     if (!receive_filter(n, buf, size))
1284         return size;
1285
1286     offset = i = 0;
1287
1288     while (offset < size) {
1289         VirtQueueElement *elem;
1290         int len, total;
1291         const struct iovec *sg;
1292
1293         total = 0;
1294
1295         elem = virtqueue_pop(q->rx_vq, sizeof(VirtQueueElement));
1296         if (!elem) {
1297             if (i) {
1298                 virtio_error(vdev, "virtio-net unexpected empty queue: "
1299                              "i %zd mergeable %d offset %zd, size %zd, "
1300                              "guest hdr len %zd, host hdr len %zd "
1301                              "guest features 0x%" PRIx64,
1302                              i, n->mergeable_rx_bufs, offset, size,
1303                              n->guest_hdr_len, n->host_hdr_len,
1304                              vdev->guest_features);
1305             }
1306             return -1;
1307         }
1308
1309         if (elem->in_num < 1) {
1310             virtio_error(vdev,
1311                          "virtio-net receive queue contains no in buffers");
1312             virtqueue_detach_element(q->rx_vq, elem, 0);
1313             g_free(elem);
1314             return -1;
1315         }
1316
1317         sg = elem->in_sg;
1318         if (i == 0) {
1319             assert(offset == 0);
1320             if (n->mergeable_rx_bufs) {
1321                 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
1322                                     sg, elem->in_num,
1323                                     offsetof(typeof(mhdr), num_buffers),
1324                                     sizeof(mhdr.num_buffers));
1325             }
1326
1327             receive_header(n, sg, elem->in_num, buf, size);
1328             offset = n->host_hdr_len;
1329             total += n->guest_hdr_len;
1330             guest_offset = n->guest_hdr_len;
1331         } else {
1332             guest_offset = 0;
1333         }
1334
1335         /* copy in packet.  ugh */
1336         len = iov_from_buf(sg, elem->in_num, guest_offset,
1337                            buf + offset, size - offset);
1338         total += len;
1339         offset += len;
1340         /* If buffers can't be merged, at this point we
1341          * must have consumed the complete packet.
1342          * Otherwise, drop it. */
1343         if (!n->mergeable_rx_bufs && offset < size) {
1344             virtqueue_unpop(q->rx_vq, elem, total);
1345             g_free(elem);
1346             return size;
1347         }
1348
1349         /* signal other side */
1350         virtqueue_fill(q->rx_vq, elem, total, i++);
1351         g_free(elem);
1352     }
1353
1354     if (mhdr_cnt) {
1355         virtio_stw_p(vdev, &mhdr.num_buffers, i);
1356         iov_from_buf(mhdr_sg, mhdr_cnt,
1357                      0,
1358                      &mhdr.num_buffers, sizeof mhdr.num_buffers);
1359     }
1360
1361     virtqueue_flush(q->rx_vq, i);
1362     virtio_notify(vdev, q->rx_vq);
1363
1364     return size;
1365 }
1366
1367 static ssize_t virtio_net_do_receive(NetClientState *nc, const uint8_t *buf,
1368                                   size_t size)
1369 {
1370     ssize_t r;
1371
1372     rcu_read_lock();
1373     r = virtio_net_receive_rcu(nc, buf, size);
1374     rcu_read_unlock();
1375     return r;
1376 }
1377
1378 static void virtio_net_rsc_extract_unit4(VirtioNetRscChain *chain,
1379                                          const uint8_t *buf,
1380                                          VirtioNetRscUnit *unit)
1381 {
1382     uint16_t ip_hdrlen;
1383     struct ip_header *ip;
1384
1385     ip = (struct ip_header *)(buf + chain->n->guest_hdr_len
1386                               + sizeof(struct eth_header));
1387     unit->ip = (void *)ip;
1388     ip_hdrlen = (ip->ip_ver_len & 0xF) << 2;
1389     unit->ip_plen = &ip->ip_len;
1390     unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip) + ip_hdrlen);
1391     unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
1392     unit->payload = htons(*unit->ip_plen) - ip_hdrlen - unit->tcp_hdrlen;
1393 }
1394
1395 static void virtio_net_rsc_extract_unit6(VirtioNetRscChain *chain,
1396                                          const uint8_t *buf,
1397                                          VirtioNetRscUnit *unit)
1398 {
1399     struct ip6_header *ip6;
1400
1401     ip6 = (struct ip6_header *)(buf + chain->n->guest_hdr_len
1402                                  + sizeof(struct eth_header));
1403     unit->ip = ip6;
1404     unit->ip_plen = &(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
1405     unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip)\
1406                                         + sizeof(struct ip6_header));
1407     unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
1408
1409     /* There is a difference between payload lenght in ipv4 and v6,
1410        ip header is excluded in ipv6 */
1411     unit->payload = htons(*unit->ip_plen) - unit->tcp_hdrlen;
1412 }
1413
1414 static size_t virtio_net_rsc_drain_seg(VirtioNetRscChain *chain,
1415                                        VirtioNetRscSeg *seg)
1416 {
1417     int ret;
1418     struct virtio_net_hdr *h;
1419
1420     h = (struct virtio_net_hdr *)seg->buf;
1421     h->flags = 0;
1422     h->gso_type = VIRTIO_NET_HDR_GSO_NONE;
1423
1424     if (seg->is_coalesced) {
1425         *virtio_net_rsc_ext_num_packets(h) = seg->packets;
1426         *virtio_net_rsc_ext_num_dupacks(h) = seg->dup_ack;
1427         h->flags = VIRTIO_NET_HDR_F_RSC_INFO;
1428         if (chain->proto == ETH_P_IP) {
1429             h->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
1430         } else {
1431             h->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
1432         }
1433     }
1434
1435     ret = virtio_net_do_receive(seg->nc, seg->buf, seg->size);
1436     QTAILQ_REMOVE(&chain->buffers, seg, next);
1437     g_free(seg->buf);
1438     g_free(seg);
1439
1440     return ret;
1441 }
1442
1443 static void virtio_net_rsc_purge(void *opq)
1444 {
1445     VirtioNetRscSeg *seg, *rn;
1446     VirtioNetRscChain *chain = (VirtioNetRscChain *)opq;
1447
1448     QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn) {
1449         if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1450             chain->stat.purge_failed++;
1451             continue;
1452         }
1453     }
1454
1455     chain->stat.timer++;
1456     if (!QTAILQ_EMPTY(&chain->buffers)) {
1457         timer_mod(chain->drain_timer,
1458               qemu_clock_get_ns(QEMU_CLOCK_HOST) + chain->n->rsc_timeout);
1459     }
1460 }
1461
1462 static void virtio_net_rsc_cleanup(VirtIONet *n)
1463 {
1464     VirtioNetRscChain *chain, *rn_chain;
1465     VirtioNetRscSeg *seg, *rn_seg;
1466
1467     QTAILQ_FOREACH_SAFE(chain, &n->rsc_chains, next, rn_chain) {
1468         QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn_seg) {
1469             QTAILQ_REMOVE(&chain->buffers, seg, next);
1470             g_free(seg->buf);
1471             g_free(seg);
1472         }
1473
1474         timer_del(chain->drain_timer);
1475         timer_free(chain->drain_timer);
1476         QTAILQ_REMOVE(&n->rsc_chains, chain, next);
1477         g_free(chain);
1478     }
1479 }
1480
1481 static void virtio_net_rsc_cache_buf(VirtioNetRscChain *chain,
1482                                      NetClientState *nc,
1483                                      const uint8_t *buf, size_t size)
1484 {
1485     uint16_t hdr_len;
1486     VirtioNetRscSeg *seg;
1487
1488     hdr_len = chain->n->guest_hdr_len;
1489     seg = g_malloc(sizeof(VirtioNetRscSeg));
1490     seg->buf = g_malloc(hdr_len + sizeof(struct eth_header)
1491         + sizeof(struct ip6_header) + VIRTIO_NET_MAX_TCP_PAYLOAD);
1492     memcpy(seg->buf, buf, size);
1493     seg->size = size;
1494     seg->packets = 1;
1495     seg->dup_ack = 0;
1496     seg->is_coalesced = 0;
1497     seg->nc = nc;
1498
1499     QTAILQ_INSERT_TAIL(&chain->buffers, seg, next);
1500     chain->stat.cache++;
1501
1502     switch (chain->proto) {
1503     case ETH_P_IP:
1504         virtio_net_rsc_extract_unit4(chain, seg->buf, &seg->unit);
1505         break;
1506     case ETH_P_IPV6:
1507         virtio_net_rsc_extract_unit6(chain, seg->buf, &seg->unit);
1508         break;
1509     default:
1510         g_assert_not_reached();
1511     }
1512 }
1513
1514 static int32_t virtio_net_rsc_handle_ack(VirtioNetRscChain *chain,
1515                                          VirtioNetRscSeg *seg,
1516                                          const uint8_t *buf,
1517                                          struct tcp_header *n_tcp,
1518                                          struct tcp_header *o_tcp)
1519 {
1520     uint32_t nack, oack;
1521     uint16_t nwin, owin;
1522
1523     nack = htonl(n_tcp->th_ack);
1524     nwin = htons(n_tcp->th_win);
1525     oack = htonl(o_tcp->th_ack);
1526     owin = htons(o_tcp->th_win);
1527
1528     if ((nack - oack) >= VIRTIO_NET_MAX_TCP_PAYLOAD) {
1529         chain->stat.ack_out_of_win++;
1530         return RSC_FINAL;
1531     } else if (nack == oack) {
1532         /* duplicated ack or window probe */
1533         if (nwin == owin) {
1534             /* duplicated ack, add dup ack count due to whql test up to 1 */
1535             chain->stat.dup_ack++;
1536             return RSC_FINAL;
1537         } else {
1538             /* Coalesce window update */
1539             o_tcp->th_win = n_tcp->th_win;
1540             chain->stat.win_update++;
1541             return RSC_COALESCE;
1542         }
1543     } else {
1544         /* pure ack, go to 'C', finalize*/
1545         chain->stat.pure_ack++;
1546         return RSC_FINAL;
1547     }
1548 }
1549
1550 static int32_t virtio_net_rsc_coalesce_data(VirtioNetRscChain *chain,
1551                                             VirtioNetRscSeg *seg,
1552                                             const uint8_t *buf,
1553                                             VirtioNetRscUnit *n_unit)
1554 {
1555     void *data;
1556     uint16_t o_ip_len;
1557     uint32_t nseq, oseq;
1558     VirtioNetRscUnit *o_unit;
1559
1560     o_unit = &seg->unit;
1561     o_ip_len = htons(*o_unit->ip_plen);
1562     nseq = htonl(n_unit->tcp->th_seq);
1563     oseq = htonl(o_unit->tcp->th_seq);
1564
1565     /* out of order or retransmitted. */
1566     if ((nseq - oseq) > VIRTIO_NET_MAX_TCP_PAYLOAD) {
1567         chain->stat.data_out_of_win++;
1568         return RSC_FINAL;
1569     }
1570
1571     data = ((uint8_t *)n_unit->tcp) + n_unit->tcp_hdrlen;
1572     if (nseq == oseq) {
1573         if ((o_unit->payload == 0) && n_unit->payload) {
1574             /* From no payload to payload, normal case, not a dup ack or etc */
1575             chain->stat.data_after_pure_ack++;
1576             goto coalesce;
1577         } else {
1578             return virtio_net_rsc_handle_ack(chain, seg, buf,
1579                                              n_unit->tcp, o_unit->tcp);
1580         }
1581     } else if ((nseq - oseq) != o_unit->payload) {
1582         /* Not a consistent packet, out of order */
1583         chain->stat.data_out_of_order++;
1584         return RSC_FINAL;
1585     } else {
1586 coalesce:
1587         if ((o_ip_len + n_unit->payload) > chain->max_payload) {
1588             chain->stat.over_size++;
1589             return RSC_FINAL;
1590         }
1591
1592         /* Here comes the right data, the payload length in v4/v6 is different,
1593            so use the field value to update and record the new data len */
1594         o_unit->payload += n_unit->payload; /* update new data len */
1595
1596         /* update field in ip header */
1597         *o_unit->ip_plen = htons(o_ip_len + n_unit->payload);
1598
1599         /* Bring 'PUSH' big, the whql test guide says 'PUSH' can be coalesced
1600            for windows guest, while this may change the behavior for linux
1601            guest (only if it uses RSC feature). */
1602         o_unit->tcp->th_offset_flags = n_unit->tcp->th_offset_flags;
1603
1604         o_unit->tcp->th_ack = n_unit->tcp->th_ack;
1605         o_unit->tcp->th_win = n_unit->tcp->th_win;
1606
1607         memmove(seg->buf + seg->size, data, n_unit->payload);
1608         seg->size += n_unit->payload;
1609         seg->packets++;
1610         chain->stat.coalesced++;
1611         return RSC_COALESCE;
1612     }
1613 }
1614
1615 static int32_t virtio_net_rsc_coalesce4(VirtioNetRscChain *chain,
1616                                         VirtioNetRscSeg *seg,
1617                                         const uint8_t *buf, size_t size,
1618                                         VirtioNetRscUnit *unit)
1619 {
1620     struct ip_header *ip1, *ip2;
1621
1622     ip1 = (struct ip_header *)(unit->ip);
1623     ip2 = (struct ip_header *)(seg->unit.ip);
1624     if ((ip1->ip_src ^ ip2->ip_src) || (ip1->ip_dst ^ ip2->ip_dst)
1625         || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
1626         || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
1627         chain->stat.no_match++;
1628         return RSC_NO_MATCH;
1629     }
1630
1631     return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
1632 }
1633
1634 static int32_t virtio_net_rsc_coalesce6(VirtioNetRscChain *chain,
1635                                         VirtioNetRscSeg *seg,
1636                                         const uint8_t *buf, size_t size,
1637                                         VirtioNetRscUnit *unit)
1638 {
1639     struct ip6_header *ip1, *ip2;
1640
1641     ip1 = (struct ip6_header *)(unit->ip);
1642     ip2 = (struct ip6_header *)(seg->unit.ip);
1643     if (memcmp(&ip1->ip6_src, &ip2->ip6_src, sizeof(struct in6_address))
1644         || memcmp(&ip1->ip6_dst, &ip2->ip6_dst, sizeof(struct in6_address))
1645         || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
1646         || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
1647             chain->stat.no_match++;
1648             return RSC_NO_MATCH;
1649     }
1650
1651     return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
1652 }
1653
1654 /* Packets with 'SYN' should bypass, other flag should be sent after drain
1655  * to prevent out of order */
1656 static int virtio_net_rsc_tcp_ctrl_check(VirtioNetRscChain *chain,
1657                                          struct tcp_header *tcp)
1658 {
1659     uint16_t tcp_hdr;
1660     uint16_t tcp_flag;
1661
1662     tcp_flag = htons(tcp->th_offset_flags);
1663     tcp_hdr = (tcp_flag & VIRTIO_NET_TCP_HDR_LENGTH) >> 10;
1664     tcp_flag &= VIRTIO_NET_TCP_FLAG;
1665     tcp_flag = htons(tcp->th_offset_flags) & 0x3F;
1666     if (tcp_flag & TH_SYN) {
1667         chain->stat.tcp_syn++;
1668         return RSC_BYPASS;
1669     }
1670
1671     if (tcp_flag & (TH_FIN | TH_URG | TH_RST | TH_ECE | TH_CWR)) {
1672         chain->stat.tcp_ctrl_drain++;
1673         return RSC_FINAL;
1674     }
1675
1676     if (tcp_hdr > sizeof(struct tcp_header)) {
1677         chain->stat.tcp_all_opt++;
1678         return RSC_FINAL;
1679     }
1680
1681     return RSC_CANDIDATE;
1682 }
1683
1684 static size_t virtio_net_rsc_do_coalesce(VirtioNetRscChain *chain,
1685                                          NetClientState *nc,
1686                                          const uint8_t *buf, size_t size,
1687                                          VirtioNetRscUnit *unit)
1688 {
1689     int ret;
1690     VirtioNetRscSeg *seg, *nseg;
1691
1692     if (QTAILQ_EMPTY(&chain->buffers)) {
1693         chain->stat.empty_cache++;
1694         virtio_net_rsc_cache_buf(chain, nc, buf, size);
1695         timer_mod(chain->drain_timer,
1696               qemu_clock_get_ns(QEMU_CLOCK_HOST) + chain->n->rsc_timeout);
1697         return size;
1698     }
1699
1700     QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
1701         if (chain->proto == ETH_P_IP) {
1702             ret = virtio_net_rsc_coalesce4(chain, seg, buf, size, unit);
1703         } else {
1704             ret = virtio_net_rsc_coalesce6(chain, seg, buf, size, unit);
1705         }
1706
1707         if (ret == RSC_FINAL) {
1708             if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1709                 /* Send failed */
1710                 chain->stat.final_failed++;
1711                 return 0;
1712             }
1713
1714             /* Send current packet */
1715             return virtio_net_do_receive(nc, buf, size);
1716         } else if (ret == RSC_NO_MATCH) {
1717             continue;
1718         } else {
1719             /* Coalesced, mark coalesced flag to tell calc cksum for ipv4 */
1720             seg->is_coalesced = 1;
1721             return size;
1722         }
1723     }
1724
1725     chain->stat.no_match_cache++;
1726     virtio_net_rsc_cache_buf(chain, nc, buf, size);
1727     return size;
1728 }
1729
1730 /* Drain a connection data, this is to avoid out of order segments */
1731 static size_t virtio_net_rsc_drain_flow(VirtioNetRscChain *chain,
1732                                         NetClientState *nc,
1733                                         const uint8_t *buf, size_t size,
1734                                         uint16_t ip_start, uint16_t ip_size,
1735                                         uint16_t tcp_port)
1736 {
1737     VirtioNetRscSeg *seg, *nseg;
1738     uint32_t ppair1, ppair2;
1739
1740     ppair1 = *(uint32_t *)(buf + tcp_port);
1741     QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
1742         ppair2 = *(uint32_t *)(seg->buf + tcp_port);
1743         if (memcmp(buf + ip_start, seg->buf + ip_start, ip_size)
1744             || (ppair1 != ppair2)) {
1745             continue;
1746         }
1747         if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1748             chain->stat.drain_failed++;
1749         }
1750
1751         break;
1752     }
1753
1754     return virtio_net_do_receive(nc, buf, size);
1755 }
1756
1757 static int32_t virtio_net_rsc_sanity_check4(VirtioNetRscChain *chain,
1758                                             struct ip_header *ip,
1759                                             const uint8_t *buf, size_t size)
1760 {
1761     uint16_t ip_len;
1762
1763     /* Not an ipv4 packet */
1764     if (((ip->ip_ver_len & 0xF0) >> 4) != IP_HEADER_VERSION_4) {
1765         chain->stat.ip_option++;
1766         return RSC_BYPASS;
1767     }
1768
1769     /* Don't handle packets with ip option */
1770     if ((ip->ip_ver_len & 0xF) != VIRTIO_NET_IP4_HEADER_LENGTH) {
1771         chain->stat.ip_option++;
1772         return RSC_BYPASS;
1773     }
1774
1775     if (ip->ip_p != IPPROTO_TCP) {
1776         chain->stat.bypass_not_tcp++;
1777         return RSC_BYPASS;
1778     }
1779
1780     /* Don't handle packets with ip fragment */
1781     if (!(htons(ip->ip_off) & IP_DF)) {
1782         chain->stat.ip_frag++;
1783         return RSC_BYPASS;
1784     }
1785
1786     /* Don't handle packets with ecn flag */
1787     if (IPTOS_ECN(ip->ip_tos)) {
1788         chain->stat.ip_ecn++;
1789         return RSC_BYPASS;
1790     }
1791
1792     ip_len = htons(ip->ip_len);
1793     if (ip_len < (sizeof(struct ip_header) + sizeof(struct tcp_header))
1794         || ip_len > (size - chain->n->guest_hdr_len -
1795                      sizeof(struct eth_header))) {
1796         chain->stat.ip_hacked++;
1797         return RSC_BYPASS;
1798     }
1799
1800     return RSC_CANDIDATE;
1801 }
1802
1803 static size_t virtio_net_rsc_receive4(VirtioNetRscChain *chain,
1804                                       NetClientState *nc,
1805                                       const uint8_t *buf, size_t size)
1806 {
1807     int32_t ret;
1808     uint16_t hdr_len;
1809     VirtioNetRscUnit unit;
1810
1811     hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
1812
1813     if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header)
1814         + sizeof(struct tcp_header))) {
1815         chain->stat.bypass_not_tcp++;
1816         return virtio_net_do_receive(nc, buf, size);
1817     }
1818
1819     virtio_net_rsc_extract_unit4(chain, buf, &unit);
1820     if (virtio_net_rsc_sanity_check4(chain, unit.ip, buf, size)
1821         != RSC_CANDIDATE) {
1822         return virtio_net_do_receive(nc, buf, size);
1823     }
1824
1825     ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
1826     if (ret == RSC_BYPASS) {
1827         return virtio_net_do_receive(nc, buf, size);
1828     } else if (ret == RSC_FINAL) {
1829         return virtio_net_rsc_drain_flow(chain, nc, buf, size,
1830                 ((hdr_len + sizeof(struct eth_header)) + 12),
1831                 VIRTIO_NET_IP4_ADDR_SIZE,
1832                 hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header));
1833     }
1834
1835     return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
1836 }
1837
1838 static int32_t virtio_net_rsc_sanity_check6(VirtioNetRscChain *chain,
1839                                             struct ip6_header *ip6,
1840                                             const uint8_t *buf, size_t size)
1841 {
1842     uint16_t ip_len;
1843
1844     if (((ip6->ip6_ctlun.ip6_un1.ip6_un1_flow & 0xF0) >> 4)
1845         != IP_HEADER_VERSION_6) {
1846         return RSC_BYPASS;
1847     }
1848
1849     /* Both option and protocol is checked in this */
1850     if (ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP) {
1851         chain->stat.bypass_not_tcp++;
1852         return RSC_BYPASS;
1853     }
1854
1855     ip_len = htons(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
1856     if (ip_len < sizeof(struct tcp_header) ||
1857         ip_len > (size - chain->n->guest_hdr_len - sizeof(struct eth_header)
1858                   - sizeof(struct ip6_header))) {
1859         chain->stat.ip_hacked++;
1860         return RSC_BYPASS;
1861     }
1862
1863     /* Don't handle packets with ecn flag */
1864     if (IP6_ECN(ip6->ip6_ctlun.ip6_un3.ip6_un3_ecn)) {
1865         chain->stat.ip_ecn++;
1866         return RSC_BYPASS;
1867     }
1868
1869     return RSC_CANDIDATE;
1870 }
1871
1872 static size_t virtio_net_rsc_receive6(void *opq, NetClientState *nc,
1873                                       const uint8_t *buf, size_t size)
1874 {
1875     int32_t ret;
1876     uint16_t hdr_len;
1877     VirtioNetRscChain *chain;
1878     VirtioNetRscUnit unit;
1879
1880     chain = (VirtioNetRscChain *)opq;
1881     hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
1882
1883     if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip6_header)
1884         + sizeof(tcp_header))) {
1885         return virtio_net_do_receive(nc, buf, size);
1886     }
1887
1888     virtio_net_rsc_extract_unit6(chain, buf, &unit);
1889     if (RSC_CANDIDATE != virtio_net_rsc_sanity_check6(chain,
1890                                                  unit.ip, buf, size)) {
1891         return virtio_net_do_receive(nc, buf, size);
1892     }
1893
1894     ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
1895     if (ret == RSC_BYPASS) {
1896         return virtio_net_do_receive(nc, buf, size);
1897     } else if (ret == RSC_FINAL) {
1898         return virtio_net_rsc_drain_flow(chain, nc, buf, size,
1899                 ((hdr_len + sizeof(struct eth_header)) + 8),
1900                 VIRTIO_NET_IP6_ADDR_SIZE,
1901                 hdr_len + sizeof(struct eth_header)
1902                 + sizeof(struct ip6_header));
1903     }
1904
1905     return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
1906 }
1907
1908 static VirtioNetRscChain *virtio_net_rsc_lookup_chain(VirtIONet *n,
1909                                                       NetClientState *nc,
1910                                                       uint16_t proto)
1911 {
1912     VirtioNetRscChain *chain;
1913
1914     if ((proto != (uint16_t)ETH_P_IP) && (proto != (uint16_t)ETH_P_IPV6)) {
1915         return NULL;
1916     }
1917
1918     QTAILQ_FOREACH(chain, &n->rsc_chains, next) {
1919         if (chain->proto == proto) {
1920             return chain;
1921         }
1922     }
1923
1924     chain = g_malloc(sizeof(*chain));
1925     chain->n = n;
1926     chain->proto = proto;
1927     if (proto == (uint16_t)ETH_P_IP) {
1928         chain->max_payload = VIRTIO_NET_MAX_IP4_PAYLOAD;
1929         chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
1930     } else {
1931         chain->max_payload = VIRTIO_NET_MAX_IP6_PAYLOAD;
1932         chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
1933     }
1934     chain->drain_timer = timer_new_ns(QEMU_CLOCK_HOST,
1935                                       virtio_net_rsc_purge, chain);
1936     memset(&chain->stat, 0, sizeof(chain->stat));
1937
1938     QTAILQ_INIT(&chain->buffers);
1939     QTAILQ_INSERT_TAIL(&n->rsc_chains, chain, next);
1940
1941     return chain;
1942 }
1943
1944 static ssize_t virtio_net_rsc_receive(NetClientState *nc,
1945                                       const uint8_t *buf,
1946                                       size_t size)
1947 {
1948     uint16_t proto;
1949     VirtioNetRscChain *chain;
1950     struct eth_header *eth;
1951     VirtIONet *n;
1952
1953     n = qemu_get_nic_opaque(nc);
1954     if (size < (n->host_hdr_len + sizeof(struct eth_header))) {
1955         return virtio_net_do_receive(nc, buf, size);
1956     }
1957
1958     eth = (struct eth_header *)(buf + n->guest_hdr_len);
1959     proto = htons(eth->h_proto);
1960
1961     chain = virtio_net_rsc_lookup_chain(n, nc, proto);
1962     if (chain) {
1963         chain->stat.received++;
1964         if (proto == (uint16_t)ETH_P_IP && n->rsc4_enabled) {
1965             return virtio_net_rsc_receive4(chain, nc, buf, size);
1966         } else if (proto == (uint16_t)ETH_P_IPV6 && n->rsc6_enabled) {
1967             return virtio_net_rsc_receive6(chain, nc, buf, size);
1968         }
1969     }
1970     return virtio_net_do_receive(nc, buf, size);
1971 }
1972
1973 static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf,
1974                                   size_t size)
1975 {
1976     VirtIONet *n = qemu_get_nic_opaque(nc);
1977     if ((n->rsc4_enabled || n->rsc6_enabled)) {
1978         return virtio_net_rsc_receive(nc, buf, size);
1979     } else {
1980         return virtio_net_do_receive(nc, buf, size);
1981     }
1982 }
1983
1984 static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
1985
1986 static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
1987 {
1988     VirtIONet *n = qemu_get_nic_opaque(nc);
1989     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1990     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1991
1992     virtqueue_push(q->tx_vq, q->async_tx.elem, 0);
1993     virtio_notify(vdev, q->tx_vq);
1994
1995     g_free(q->async_tx.elem);
1996     q->async_tx.elem = NULL;
1997
1998     virtio_queue_set_notification(q->tx_vq, 1);
1999     virtio_net_flush_tx(q);
2000 }
2001
2002 /* TX */
2003 static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
2004 {
2005     VirtIONet *n = q->n;
2006     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2007     VirtQueueElement *elem;
2008     int32_t num_packets = 0;
2009     int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
2010     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2011         return num_packets;
2012     }
2013
2014     if (q->async_tx.elem) {
2015         virtio_queue_set_notification(q->tx_vq, 0);
2016         return num_packets;
2017     }
2018
2019     for (;;) {
2020         ssize_t ret;
2021         unsigned int out_num;
2022         struct iovec sg[VIRTQUEUE_MAX_SIZE], sg2[VIRTQUEUE_MAX_SIZE + 1], *out_sg;
2023         struct virtio_net_hdr_mrg_rxbuf mhdr;
2024
2025         elem = virtqueue_pop(q->tx_vq, sizeof(VirtQueueElement));
2026         if (!elem) {
2027             break;
2028         }
2029
2030         out_num = elem->out_num;
2031         out_sg = elem->out_sg;
2032         if (out_num < 1) {
2033             virtio_error(vdev, "virtio-net header not in first element");
2034             virtqueue_detach_element(q->tx_vq, elem, 0);
2035             g_free(elem);
2036             return -EINVAL;
2037         }
2038
2039         if (n->has_vnet_hdr) {
2040             if (iov_to_buf(out_sg, out_num, 0, &mhdr, n->guest_hdr_len) <
2041                 n->guest_hdr_len) {
2042                 virtio_error(vdev, "virtio-net header incorrect");
2043                 virtqueue_detach_element(q->tx_vq, elem, 0);
2044                 g_free(elem);
2045                 return -EINVAL;
2046             }
2047             if (n->needs_vnet_hdr_swap) {
2048                 virtio_net_hdr_swap(vdev, (void *) &mhdr);
2049                 sg2[0].iov_base = &mhdr;
2050                 sg2[0].iov_len = n->guest_hdr_len;
2051                 out_num = iov_copy(&sg2[1], ARRAY_SIZE(sg2) - 1,
2052                                    out_sg, out_num,
2053                                    n->guest_hdr_len, -1);
2054                 if (out_num == VIRTQUEUE_MAX_SIZE) {
2055                     goto drop;
2056                 }
2057                 out_num += 1;
2058                 out_sg = sg2;
2059             }
2060         }
2061         /*
2062          * If host wants to see the guest header as is, we can
2063          * pass it on unchanged. Otherwise, copy just the parts
2064          * that host is interested in.
2065          */
2066         assert(n->host_hdr_len <= n->guest_hdr_len);
2067         if (n->host_hdr_len != n->guest_hdr_len) {
2068             unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
2069                                        out_sg, out_num,
2070                                        0, n->host_hdr_len);
2071             sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
2072                              out_sg, out_num,
2073                              n->guest_hdr_len, -1);
2074             out_num = sg_num;
2075             out_sg = sg;
2076         }
2077
2078         ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
2079                                       out_sg, out_num, virtio_net_tx_complete);
2080         if (ret == 0) {
2081             virtio_queue_set_notification(q->tx_vq, 0);
2082             q->async_tx.elem = elem;
2083             return -EBUSY;
2084         }
2085
2086 drop:
2087         virtqueue_push(q->tx_vq, elem, 0);
2088         virtio_notify(vdev, q->tx_vq);
2089         g_free(elem);
2090
2091         if (++num_packets >= n->tx_burst) {
2092             break;
2093         }
2094     }
2095     return num_packets;
2096 }
2097
2098 static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
2099 {
2100     VirtIONet *n = VIRTIO_NET(vdev);
2101     VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2102
2103     if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2104         virtio_net_drop_tx_queue_data(vdev, vq);
2105         return;
2106     }
2107
2108     /* This happens when device was stopped but VCPU wasn't. */
2109     if (!vdev->vm_running) {
2110         q->tx_waiting = 1;
2111         return;
2112     }
2113
2114     if (q->tx_waiting) {
2115         virtio_queue_set_notification(vq, 1);
2116         timer_del(q->tx_timer);
2117         q->tx_waiting = 0;
2118         if (virtio_net_flush_tx(q) == -EINVAL) {
2119             return;
2120         }
2121     } else {
2122         timer_mod(q->tx_timer,
2123                        qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2124         q->tx_waiting = 1;
2125         virtio_queue_set_notification(vq, 0);
2126     }
2127 }
2128
2129 static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
2130 {
2131     VirtIONet *n = VIRTIO_NET(vdev);
2132     VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2133
2134     if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2135         virtio_net_drop_tx_queue_data(vdev, vq);
2136         return;
2137     }
2138
2139     if (unlikely(q->tx_waiting)) {
2140         return;
2141     }
2142     q->tx_waiting = 1;
2143     /* This happens when device was stopped but VCPU wasn't. */
2144     if (!vdev->vm_running) {
2145         return;
2146     }
2147     virtio_queue_set_notification(vq, 0);
2148     qemu_bh_schedule(q->tx_bh);
2149 }
2150
2151 static void virtio_net_tx_timer(void *opaque)
2152 {
2153     VirtIONetQueue *q = opaque;
2154     VirtIONet *n = q->n;
2155     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2156     /* This happens when device was stopped but BH wasn't. */
2157     if (!vdev->vm_running) {
2158         /* Make sure tx waiting is set, so we'll run when restarted. */
2159         assert(q->tx_waiting);
2160         return;
2161     }
2162
2163     q->tx_waiting = 0;
2164
2165     /* Just in case the driver is not ready on more */
2166     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2167         return;
2168     }
2169
2170     virtio_queue_set_notification(q->tx_vq, 1);
2171     virtio_net_flush_tx(q);
2172 }
2173
2174 static void virtio_net_tx_bh(void *opaque)
2175 {
2176     VirtIONetQueue *q = opaque;
2177     VirtIONet *n = q->n;
2178     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2179     int32_t ret;
2180
2181     /* This happens when device was stopped but BH wasn't. */
2182     if (!vdev->vm_running) {
2183         /* Make sure tx waiting is set, so we'll run when restarted. */
2184         assert(q->tx_waiting);
2185         return;
2186     }
2187
2188     q->tx_waiting = 0;
2189
2190     /* Just in case the driver is not ready on more */
2191     if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
2192         return;
2193     }
2194
2195     ret = virtio_net_flush_tx(q);
2196     if (ret == -EBUSY || ret == -EINVAL) {
2197         return; /* Notification re-enable handled by tx_complete or device
2198                  * broken */
2199     }
2200
2201     /* If we flush a full burst of packets, assume there are
2202      * more coming and immediately reschedule */
2203     if (ret >= n->tx_burst) {
2204         qemu_bh_schedule(q->tx_bh);
2205         q->tx_waiting = 1;
2206         return;
2207     }
2208
2209     /* If less than a full burst, re-enable notification and flush
2210      * anything that may have come in while we weren't looking.  If
2211      * we find something, assume the guest is still active and reschedule */
2212     virtio_queue_set_notification(q->tx_vq, 1);
2213     ret = virtio_net_flush_tx(q);
2214     if (ret == -EINVAL) {
2215         return;
2216     } else if (ret > 0) {
2217         virtio_queue_set_notification(q->tx_vq, 0);
2218         qemu_bh_schedule(q->tx_bh);
2219         q->tx_waiting = 1;
2220     }
2221 }
2222
2223 static void virtio_net_add_queue(VirtIONet *n, int index)
2224 {
2225     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2226
2227     n->vqs[index].rx_vq = virtio_add_queue(vdev, n->net_conf.rx_queue_size,
2228                                            virtio_net_handle_rx);
2229
2230     if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
2231         n->vqs[index].tx_vq =
2232             virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2233                              virtio_net_handle_tx_timer);
2234         n->vqs[index].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2235                                               virtio_net_tx_timer,
2236                                               &n->vqs[index]);
2237     } else {
2238         n->vqs[index].tx_vq =
2239             virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2240                              virtio_net_handle_tx_bh);
2241         n->vqs[index].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[index]);
2242     }
2243
2244     n->vqs[index].tx_waiting = 0;
2245     n->vqs[index].n = n;
2246 }
2247
2248 static void virtio_net_del_queue(VirtIONet *n, int index)
2249 {
2250     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2251     VirtIONetQueue *q = &n->vqs[index];
2252     NetClientState *nc = qemu_get_subqueue(n->nic, index);
2253
2254     qemu_purge_queued_packets(nc);
2255
2256     virtio_del_queue(vdev, index * 2);
2257     if (q->tx_timer) {
2258         timer_del(q->tx_timer);
2259         timer_free(q->tx_timer);
2260         q->tx_timer = NULL;
2261     } else {
2262         qemu_bh_delete(q->tx_bh);
2263         q->tx_bh = NULL;
2264     }
2265     q->tx_waiting = 0;
2266     virtio_del_queue(vdev, index * 2 + 1);
2267 }
2268
2269 static void virtio_net_change_num_queues(VirtIONet *n, int new_max_queues)
2270 {
2271     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2272     int old_num_queues = virtio_get_num_queues(vdev);
2273     int new_num_queues = new_max_queues * 2 + 1;
2274     int i;
2275
2276     assert(old_num_queues >= 3);
2277     assert(old_num_queues % 2 == 1);
2278
2279     if (old_num_queues == new_num_queues) {
2280         return;
2281     }
2282
2283     /*
2284      * We always need to remove and add ctrl vq if
2285      * old_num_queues != new_num_queues. Remove ctrl_vq first,
2286      * and then we only enter one of the following two loops.
2287      */
2288     virtio_del_queue(vdev, old_num_queues - 1);
2289
2290     for (i = new_num_queues - 1; i < old_num_queues - 1; i += 2) {
2291         /* new_num_queues < old_num_queues */
2292         virtio_net_del_queue(n, i / 2);
2293     }
2294
2295     for (i = old_num_queues - 1; i < new_num_queues - 1; i += 2) {
2296         /* new_num_queues > old_num_queues */
2297         virtio_net_add_queue(n, i / 2);
2298     }
2299
2300     /* add ctrl_vq last */
2301     n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
2302 }
2303
2304 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
2305 {
2306     int max = multiqueue ? n->max_queues : 1;
2307
2308     n->multiqueue = multiqueue;
2309     virtio_net_change_num_queues(n, max);
2310
2311     virtio_net_set_queues(n);
2312 }
2313
2314 static int virtio_net_post_load_device(void *opaque, int version_id)
2315 {
2316     VirtIONet *n = opaque;
2317     VirtIODevice *vdev = VIRTIO_DEVICE(n);
2318     int i, link_down;
2319
2320     trace_virtio_net_post_load_device();
2321     virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
2322                                virtio_vdev_has_feature(vdev,
2323                                                        VIRTIO_F_VERSION_1));
2324
2325     /* MAC_TABLE_ENTRIES may be different from the saved image */
2326     if (n->mac_table.in_use > MAC_TABLE_ENTRIES) {
2327         n->mac_table.in_use = 0;
2328     }
2329
2330     if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
2331         n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
2332     }
2333
2334     if (peer_has_vnet_hdr(n)) {
2335         virtio_net_apply_guest_offloads(n);
2336     }
2337
2338     virtio_net_set_queues(n);
2339
2340     /* Find the first multicast entry in the saved MAC filter */
2341     for (i = 0; i < n->mac_table.in_use; i++) {
2342         if (n->mac_table.macs[i * ETH_ALEN] & 1) {
2343             break;
2344         }
2345     }
2346     n->mac_table.first_multi = i;
2347
2348     /* nc.link_down can't be migrated, so infer link_down according
2349      * to link status bit in n->status */
2350     link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
2351     for (i = 0; i < n->max_queues; i++) {
2352         qemu_get_subqueue(n->nic, i)->link_down = link_down;
2353     }
2354
2355     if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
2356         virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
2357         qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
2358                                   QEMU_CLOCK_VIRTUAL,
2359                                   virtio_net_announce_timer, n);
2360         if (n->announce_timer.round) {
2361             timer_mod(n->announce_timer.tm,
2362                       qemu_clock_get_ms(n->announce_timer.type));
2363         } else {
2364             qemu_announce_timer_del(&n->announce_timer, false);
2365         }
2366     }
2367
2368     return 0;
2369 }
2370
2371 /* tx_waiting field of a VirtIONetQueue */
2372 static const VMStateDescription vmstate_virtio_net_queue_tx_waiting = {
2373     .name = "virtio-net-queue-tx_waiting",
2374     .fields = (VMStateField[]) {
2375         VMSTATE_UINT32(tx_waiting, VirtIONetQueue),
2376         VMSTATE_END_OF_LIST()
2377    },
2378 };
2379
2380 static bool max_queues_gt_1(void *opaque, int version_id)
2381 {
2382     return VIRTIO_NET(opaque)->max_queues > 1;
2383 }
2384
2385 static bool has_ctrl_guest_offloads(void *opaque, int version_id)
2386 {
2387     return virtio_vdev_has_feature(VIRTIO_DEVICE(opaque),
2388                                    VIRTIO_NET_F_CTRL_GUEST_OFFLOADS);
2389 }
2390
2391 static bool mac_table_fits(void *opaque, int version_id)
2392 {
2393     return VIRTIO_NET(opaque)->mac_table.in_use <= MAC_TABLE_ENTRIES;
2394 }
2395
2396 static bool mac_table_doesnt_fit(void *opaque, int version_id)
2397 {
2398     return !mac_table_fits(opaque, version_id);
2399 }
2400
2401 /* This temporary type is shared by all the WITH_TMP methods
2402  * although only some fields are used by each.
2403  */
2404 struct VirtIONetMigTmp {
2405     VirtIONet      *parent;
2406     VirtIONetQueue *vqs_1;
2407     uint16_t        curr_queues_1;
2408     uint8_t         has_ufo;
2409     uint32_t        has_vnet_hdr;
2410 };
2411
2412 /* The 2nd and subsequent tx_waiting flags are loaded later than
2413  * the 1st entry in the queues and only if there's more than one
2414  * entry.  We use the tmp mechanism to calculate a temporary
2415  * pointer and count and also validate the count.
2416  */
2417
2418 static int virtio_net_tx_waiting_pre_save(void *opaque)
2419 {
2420     struct VirtIONetMigTmp *tmp = opaque;
2421
2422     tmp->vqs_1 = tmp->parent->vqs + 1;
2423     tmp->curr_queues_1 = tmp->parent->curr_queues - 1;
2424     if (tmp->parent->curr_queues == 0) {
2425         tmp->curr_queues_1 = 0;
2426     }
2427
2428     return 0;
2429 }
2430
2431 static int virtio_net_tx_waiting_pre_load(void *opaque)
2432 {
2433     struct VirtIONetMigTmp *tmp = opaque;
2434
2435     /* Reuse the pointer setup from save */
2436     virtio_net_tx_waiting_pre_save(opaque);
2437
2438     if (tmp->parent->curr_queues > tmp->parent->max_queues) {
2439         error_report("virtio-net: curr_queues %x > max_queues %x",
2440             tmp->parent->curr_queues, tmp->parent->max_queues);
2441
2442         return -EINVAL;
2443     }
2444
2445     return 0; /* all good */
2446 }
2447
2448 static const VMStateDescription vmstate_virtio_net_tx_waiting = {
2449     .name      = "virtio-net-tx_waiting",
2450     .pre_load  = virtio_net_tx_waiting_pre_load,
2451     .pre_save  = virtio_net_tx_waiting_pre_save,
2452     .fields    = (VMStateField[]) {
2453         VMSTATE_STRUCT_VARRAY_POINTER_UINT16(vqs_1, struct VirtIONetMigTmp,
2454                                      curr_queues_1,
2455                                      vmstate_virtio_net_queue_tx_waiting,
2456                                      struct VirtIONetQueue),
2457         VMSTATE_END_OF_LIST()
2458     },
2459 };
2460
2461 /* the 'has_ufo' flag is just tested; if the incoming stream has the
2462  * flag set we need to check that we have it
2463  */
2464 static int virtio_net_ufo_post_load(void *opaque, int version_id)
2465 {
2466     struct VirtIONetMigTmp *tmp = opaque;
2467
2468     if (tmp->has_ufo && !peer_has_ufo(tmp->parent)) {
2469         error_report("virtio-net: saved image requires TUN_F_UFO support");
2470         return -EINVAL;
2471     }
2472
2473     return 0;
2474 }
2475
2476 static int virtio_net_ufo_pre_save(void *opaque)
2477 {
2478     struct VirtIONetMigTmp *tmp = opaque;
2479
2480     tmp->has_ufo = tmp->parent->has_ufo;
2481
2482     return 0;
2483 }
2484
2485 static const VMStateDescription vmstate_virtio_net_has_ufo = {
2486     .name      = "virtio-net-ufo",
2487     .post_load = virtio_net_ufo_post_load,
2488     .pre_save  = virtio_net_ufo_pre_save,
2489     .fields    = (VMStateField[]) {
2490         VMSTATE_UINT8(has_ufo, struct VirtIONetMigTmp),
2491         VMSTATE_END_OF_LIST()
2492     },
2493 };
2494
2495 /* the 'has_vnet_hdr' flag is just tested; if the incoming stream has the
2496  * flag set we need to check that we have it
2497  */
2498 static int virtio_net_vnet_post_load(void *opaque, int version_id)
2499 {
2500     struct VirtIONetMigTmp *tmp = opaque;
2501
2502     if (tmp->has_vnet_hdr && !peer_has_vnet_hdr(tmp->parent)) {
2503         error_report("virtio-net: saved image requires vnet_hdr=on");
2504         return -EINVAL;
2505     }
2506
2507     return 0;
2508 }
2509
2510 static int virtio_net_vnet_pre_save(void *opaque)
2511 {
2512     struct VirtIONetMigTmp *tmp = opaque;
2513
2514     tmp->has_vnet_hdr = tmp->parent->has_vnet_hdr;
2515
2516     return 0;
2517 }
2518
2519 static const VMStateDescription vmstate_virtio_net_has_vnet = {
2520     .name      = "virtio-net-vnet",
2521     .post_load = virtio_net_vnet_post_load,
2522     .pre_save  = virtio_net_vnet_pre_save,
2523     .fields    = (VMStateField[]) {
2524         VMSTATE_UINT32(has_vnet_hdr, struct VirtIONetMigTmp),
2525         VMSTATE_END_OF_LIST()
2526     },
2527 };
2528
2529 static const VMStateDescription vmstate_virtio_net_device = {
2530     .name = "virtio-net-device",
2531     .version_id = VIRTIO_NET_VM_VERSION,
2532     .minimum_version_id = VIRTIO_NET_VM_VERSION,
2533     .post_load = virtio_net_post_load_device,
2534     .fields = (VMStateField[]) {
2535         VMSTATE_UINT8_ARRAY(mac, VirtIONet, ETH_ALEN),
2536         VMSTATE_STRUCT_POINTER(vqs, VirtIONet,
2537                                vmstate_virtio_net_queue_tx_waiting,
2538                                VirtIONetQueue),
2539         VMSTATE_UINT32(mergeable_rx_bufs, VirtIONet),
2540         VMSTATE_UINT16(status, VirtIONet),
2541         VMSTATE_UINT8(promisc, VirtIONet),
2542         VMSTATE_UINT8(allmulti, VirtIONet),
2543         VMSTATE_UINT32(mac_table.in_use, VirtIONet),
2544
2545         /* Guarded pair: If it fits we load it, else we throw it away
2546          * - can happen if source has a larger MAC table.; post-load
2547          *  sets flags in this case.
2548          */
2549         VMSTATE_VBUFFER_MULTIPLY(mac_table.macs, VirtIONet,
2550                                 0, mac_table_fits, mac_table.in_use,
2551                                  ETH_ALEN),
2552         VMSTATE_UNUSED_VARRAY_UINT32(VirtIONet, mac_table_doesnt_fit, 0,
2553                                      mac_table.in_use, ETH_ALEN),
2554
2555         /* Note: This is an array of uint32's that's always been saved as a
2556          * buffer; hold onto your endiannesses; it's actually used as a bitmap
2557          * but based on the uint.
2558          */
2559         VMSTATE_BUFFER_POINTER_UNSAFE(vlans, VirtIONet, 0, MAX_VLAN >> 3),
2560         VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2561                          vmstate_virtio_net_has_vnet),
2562         VMSTATE_UINT8(mac_table.multi_overflow, VirtIONet),
2563         VMSTATE_UINT8(mac_table.uni_overflow, VirtIONet),
2564         VMSTATE_UINT8(alluni, VirtIONet),
2565         VMSTATE_UINT8(nomulti, VirtIONet),
2566         VMSTATE_UINT8(nouni, VirtIONet),
2567         VMSTATE_UINT8(nobcast, VirtIONet),
2568         VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2569                          vmstate_virtio_net_has_ufo),
2570         VMSTATE_SINGLE_TEST(max_queues, VirtIONet, max_queues_gt_1, 0,
2571                             vmstate_info_uint16_equal, uint16_t),
2572         VMSTATE_UINT16_TEST(curr_queues, VirtIONet, max_queues_gt_1),
2573         VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2574                          vmstate_virtio_net_tx_waiting),
2575         VMSTATE_UINT64_TEST(curr_guest_offloads, VirtIONet,
2576                             has_ctrl_guest_offloads),
2577         VMSTATE_END_OF_LIST()
2578    },
2579 };
2580
2581 static NetClientInfo net_virtio_info = {
2582     .type = NET_CLIENT_DRIVER_NIC,
2583     .size = sizeof(NICState),
2584     .can_receive = virtio_net_can_receive,
2585     .receive = virtio_net_receive,
2586     .link_status_changed = virtio_net_set_link_status,
2587     .query_rx_filter = virtio_net_query_rxfilter,
2588     .announce = virtio_net_announce,
2589 };
2590
2591 static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
2592 {
2593     VirtIONet *n = VIRTIO_NET(vdev);
2594     NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
2595     assert(n->vhost_started);
2596     return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
2597 }
2598
2599 static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
2600                                            bool mask)
2601 {
2602     VirtIONet *n = VIRTIO_NET(vdev);
2603     NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
2604     assert(n->vhost_started);
2605     vhost_net_virtqueue_mask(get_vhost_net(nc->peer),
2606                              vdev, idx, mask);
2607 }
2608
2609 static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
2610 {
2611     virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
2612
2613     n->config_size = virtio_feature_get_config_size(feature_sizes,
2614                                                     host_features);
2615 }
2616
2617 void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
2618                                    const char *type)
2619 {
2620     /*
2621      * The name can be NULL, the netclient name will be type.x.
2622      */
2623     assert(type != NULL);
2624
2625     g_free(n->netclient_name);
2626     g_free(n->netclient_type);
2627     n->netclient_name = g_strdup(name);
2628     n->netclient_type = g_strdup(type);
2629 }
2630
2631 static void virtio_net_device_realize(DeviceState *dev, Error **errp)
2632 {
2633     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
2634     VirtIONet *n = VIRTIO_NET(dev);
2635     NetClientState *nc;
2636     int i;
2637
2638     if (n->net_conf.mtu) {
2639         n->host_features |= (1ULL << VIRTIO_NET_F_MTU);
2640     }
2641
2642     if (n->net_conf.duplex_str) {
2643         if (strncmp(n->net_conf.duplex_str, "half", 5) == 0) {
2644             n->net_conf.duplex = DUPLEX_HALF;
2645         } else if (strncmp(n->net_conf.duplex_str, "full", 5) == 0) {
2646             n->net_conf.duplex = DUPLEX_FULL;
2647         } else {
2648             error_setg(errp, "'duplex' must be 'half' or 'full'");
2649         }
2650         n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
2651     } else {
2652         n->net_conf.duplex = DUPLEX_UNKNOWN;
2653     }
2654
2655     if (n->net_conf.speed < SPEED_UNKNOWN) {
2656         error_setg(errp, "'speed' must be between 0 and INT_MAX");
2657     } else if (n->net_conf.speed >= 0) {
2658         n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
2659     }
2660
2661     virtio_net_set_config_size(n, n->host_features);
2662     virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
2663
2664     /*
2665      * We set a lower limit on RX queue size to what it always was.
2666      * Guests that want a smaller ring can always resize it without
2667      * help from us (using virtio 1 and up).
2668      */
2669     if (n->net_conf.rx_queue_size < VIRTIO_NET_RX_QUEUE_MIN_SIZE ||
2670         n->net_conf.rx_queue_size > VIRTQUEUE_MAX_SIZE ||
2671         !is_power_of_2(n->net_conf.rx_queue_size)) {
2672         error_setg(errp, "Invalid rx_queue_size (= %" PRIu16 "), "
2673                    "must be a power of 2 between %d and %d.",
2674                    n->net_conf.rx_queue_size, VIRTIO_NET_RX_QUEUE_MIN_SIZE,
2675                    VIRTQUEUE_MAX_SIZE);
2676         virtio_cleanup(vdev);
2677         return;
2678     }
2679
2680     if (n->net_conf.tx_queue_size < VIRTIO_NET_TX_QUEUE_MIN_SIZE ||
2681         n->net_conf.tx_queue_size > VIRTQUEUE_MAX_SIZE ||
2682         !is_power_of_2(n->net_conf.tx_queue_size)) {
2683         error_setg(errp, "Invalid tx_queue_size (= %" PRIu16 "), "
2684                    "must be a power of 2 between %d and %d",
2685                    n->net_conf.tx_queue_size, VIRTIO_NET_TX_QUEUE_MIN_SIZE,
2686                    VIRTQUEUE_MAX_SIZE);
2687         virtio_cleanup(vdev);
2688         return;
2689     }
2690
2691     n->max_queues = MAX(n->nic_conf.peers.queues, 1);
2692     if (n->max_queues * 2 + 1 > VIRTIO_QUEUE_MAX) {
2693         error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
2694                    "must be a positive integer less than %d.",
2695                    n->max_queues, (VIRTIO_QUEUE_MAX - 1) / 2);
2696         virtio_cleanup(vdev);
2697         return;
2698     }
2699     n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
2700     n->curr_queues = 1;
2701     n->tx_timeout = n->net_conf.txtimer;
2702
2703     if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
2704                        && strcmp(n->net_conf.tx, "bh")) {
2705         warn_report("virtio-net: "
2706                     "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
2707                     n->net_conf.tx);
2708         error_printf("Defaulting to \"bh\"");
2709     }
2710
2711     n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n),
2712                                     n->net_conf.tx_queue_size);
2713
2714     for (i = 0; i < n->max_queues; i++) {
2715         virtio_net_add_queue(n, i);
2716     }
2717
2718     n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
2719     qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
2720     memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
2721     n->status = VIRTIO_NET_S_LINK_UP;
2722     qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
2723                               QEMU_CLOCK_VIRTUAL,
2724                               virtio_net_announce_timer, n);
2725     n->announce_timer.round = 0;
2726
2727     if (n->netclient_type) {
2728         /*
2729          * Happen when virtio_net_set_netclient_name has been called.
2730          */
2731         n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
2732                               n->netclient_type, n->netclient_name, n);
2733     } else {
2734         n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
2735                               object_get_typename(OBJECT(dev)), dev->id, n);
2736     }
2737
2738     peer_test_vnet_hdr(n);
2739     if (peer_has_vnet_hdr(n)) {
2740         for (i = 0; i < n->max_queues; i++) {
2741             qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
2742         }
2743         n->host_hdr_len = sizeof(struct virtio_net_hdr);
2744     } else {
2745         n->host_hdr_len = 0;
2746     }
2747
2748     qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
2749
2750     n->vqs[0].tx_waiting = 0;
2751     n->tx_burst = n->net_conf.txburst;
2752     virtio_net_set_mrg_rx_bufs(n, 0, 0);
2753     n->promisc = 1; /* for compatibility */
2754
2755     n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
2756
2757     n->vlans = g_malloc0(MAX_VLAN >> 3);
2758
2759     nc = qemu_get_queue(n->nic);
2760     nc->rxfilter_notify_enabled = 1;
2761
2762     QTAILQ_INIT(&n->rsc_chains);
2763     n->qdev = dev;
2764 }
2765
2766 static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
2767 {
2768     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
2769     VirtIONet *n = VIRTIO_NET(dev);
2770     int i, max_queues;
2771
2772     /* This will stop vhost backend if appropriate. */
2773     virtio_net_set_status(vdev, 0);
2774
2775     g_free(n->netclient_name);
2776     n->netclient_name = NULL;
2777     g_free(n->netclient_type);
2778     n->netclient_type = NULL;
2779
2780     g_free(n->mac_table.macs);
2781     g_free(n->vlans);
2782
2783     max_queues = n->multiqueue ? n->max_queues : 1;
2784     for (i = 0; i < max_queues; i++) {
2785         virtio_net_del_queue(n, i);
2786     }
2787
2788     qemu_announce_timer_del(&n->announce_timer, false);
2789     g_free(n->vqs);
2790     qemu_del_nic(n->nic);
2791     virtio_net_rsc_cleanup(n);
2792     virtio_cleanup(vdev);
2793 }
2794
2795 static void virtio_net_instance_init(Object *obj)
2796 {
2797     VirtIONet *n = VIRTIO_NET(obj);
2798
2799     /*
2800      * The default config_size is sizeof(struct virtio_net_config).
2801      * Can be overriden with virtio_net_set_config_size.
2802      */
2803     n->config_size = sizeof(struct virtio_net_config);
2804     device_add_bootindex_property(obj, &n->nic_conf.bootindex,
2805                                   "bootindex", "/ethernet-phy@0",
2806                                   DEVICE(n), NULL);
2807 }
2808
2809 static int virtio_net_pre_save(void *opaque)
2810 {
2811     VirtIONet *n = opaque;
2812
2813     /* At this point, backend must be stopped, otherwise
2814      * it might keep writing to memory. */
2815     assert(!n->vhost_started);
2816
2817     return 0;
2818 }
2819
2820 static const VMStateDescription vmstate_virtio_net = {
2821     .name = "virtio-net",
2822     .minimum_version_id = VIRTIO_NET_VM_VERSION,
2823     .version_id = VIRTIO_NET_VM_VERSION,
2824     .fields = (VMStateField[]) {
2825         VMSTATE_VIRTIO_DEVICE,
2826         VMSTATE_END_OF_LIST()
2827     },
2828     .pre_save = virtio_net_pre_save,
2829 };
2830
2831 static Property virtio_net_properties[] = {
2832     DEFINE_PROP_BIT64("csum", VirtIONet, host_features,
2833                     VIRTIO_NET_F_CSUM, true),
2834     DEFINE_PROP_BIT64("guest_csum", VirtIONet, host_features,
2835                     VIRTIO_NET_F_GUEST_CSUM, true),
2836     DEFINE_PROP_BIT64("gso", VirtIONet, host_features, VIRTIO_NET_F_GSO, true),
2837     DEFINE_PROP_BIT64("guest_tso4", VirtIONet, host_features,
2838                     VIRTIO_NET_F_GUEST_TSO4, true),
2839     DEFINE_PROP_BIT64("guest_tso6", VirtIONet, host_features,
2840                     VIRTIO_NET_F_GUEST_TSO6, true),
2841     DEFINE_PROP_BIT64("guest_ecn", VirtIONet, host_features,
2842                     VIRTIO_NET_F_GUEST_ECN, true),
2843     DEFINE_PROP_BIT64("guest_ufo", VirtIONet, host_features,
2844                     VIRTIO_NET_F_GUEST_UFO, true),
2845     DEFINE_PROP_BIT64("guest_announce", VirtIONet, host_features,
2846                     VIRTIO_NET_F_GUEST_ANNOUNCE, true),
2847     DEFINE_PROP_BIT64("host_tso4", VirtIONet, host_features,
2848                     VIRTIO_NET_F_HOST_TSO4, true),
2849     DEFINE_PROP_BIT64("host_tso6", VirtIONet, host_features,
2850                     VIRTIO_NET_F_HOST_TSO6, true),
2851     DEFINE_PROP_BIT64("host_ecn", VirtIONet, host_features,
2852                     VIRTIO_NET_F_HOST_ECN, true),
2853     DEFINE_PROP_BIT64("host_ufo", VirtIONet, host_features,
2854                     VIRTIO_NET_F_HOST_UFO, true),
2855     DEFINE_PROP_BIT64("mrg_rxbuf", VirtIONet, host_features,
2856                     VIRTIO_NET_F_MRG_RXBUF, true),
2857     DEFINE_PROP_BIT64("status", VirtIONet, host_features,
2858                     VIRTIO_NET_F_STATUS, true),
2859     DEFINE_PROP_BIT64("ctrl_vq", VirtIONet, host_features,
2860                     VIRTIO_NET_F_CTRL_VQ, true),
2861     DEFINE_PROP_BIT64("ctrl_rx", VirtIONet, host_features,
2862                     VIRTIO_NET_F_CTRL_RX, true),
2863     DEFINE_PROP_BIT64("ctrl_vlan", VirtIONet, host_features,
2864                     VIRTIO_NET_F_CTRL_VLAN, true),
2865     DEFINE_PROP_BIT64("ctrl_rx_extra", VirtIONet, host_features,
2866                     VIRTIO_NET_F_CTRL_RX_EXTRA, true),
2867     DEFINE_PROP_BIT64("ctrl_mac_addr", VirtIONet, host_features,
2868                     VIRTIO_NET_F_CTRL_MAC_ADDR, true),
2869     DEFINE_PROP_BIT64("ctrl_guest_offloads", VirtIONet, host_features,
2870                     VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, true),
2871     DEFINE_PROP_BIT64("mq", VirtIONet, host_features, VIRTIO_NET_F_MQ, false),
2872     DEFINE_PROP_BIT64("guest_rsc_ext", VirtIONet, host_features,
2873                     VIRTIO_NET_F_RSC_EXT, false),
2874     DEFINE_PROP_UINT32("rsc_interval", VirtIONet, rsc_timeout,
2875                        VIRTIO_NET_RSC_DEFAULT_INTERVAL),
2876     DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
2877     DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
2878                        TX_TIMER_INTERVAL),
2879     DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
2880     DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
2881     DEFINE_PROP_UINT16("rx_queue_size", VirtIONet, net_conf.rx_queue_size,
2882                        VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE),
2883     DEFINE_PROP_UINT16("tx_queue_size", VirtIONet, net_conf.tx_queue_size,
2884                        VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE),
2885     DEFINE_PROP_UINT16("host_mtu", VirtIONet, net_conf.mtu, 0),
2886     DEFINE_PROP_BOOL("x-mtu-bypass-backend", VirtIONet, mtu_bypass_backend,
2887                      true),
2888     DEFINE_PROP_INT32("speed", VirtIONet, net_conf.speed, SPEED_UNKNOWN),
2889     DEFINE_PROP_STRING("duplex", VirtIONet, net_conf.duplex_str),
2890     DEFINE_PROP_END_OF_LIST(),
2891 };
2892
2893 static void virtio_net_class_init(ObjectClass *klass, void *data)
2894 {
2895     DeviceClass *dc = DEVICE_CLASS(klass);
2896     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
2897
2898     dc->props = virtio_net_properties;
2899     dc->vmsd = &vmstate_virtio_net;
2900     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
2901     vdc->realize = virtio_net_device_realize;
2902     vdc->unrealize = virtio_net_device_unrealize;
2903     vdc->get_config = virtio_net_get_config;
2904     vdc->set_config = virtio_net_set_config;
2905     vdc->get_features = virtio_net_get_features;
2906     vdc->set_features = virtio_net_set_features;
2907     vdc->bad_features = virtio_net_bad_features;
2908     vdc->reset = virtio_net_reset;
2909     vdc->set_status = virtio_net_set_status;
2910     vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
2911     vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
2912     vdc->legacy_features |= (0x1 << VIRTIO_NET_F_GSO);
2913     vdc->vmsd = &vmstate_virtio_net_device;
2914 }
2915
2916 static const TypeInfo virtio_net_info = {
2917     .name = TYPE_VIRTIO_NET,
2918     .parent = TYPE_VIRTIO_DEVICE,
2919     .instance_size = sizeof(VirtIONet),
2920     .instance_init = virtio_net_instance_init,
2921     .class_init = virtio_net_class_init,
2922 };
2923
2924 static void virtio_register_types(void)
2925 {
2926     type_register_static(&virtio_net_info);
2927 }
2928
2929 type_init(virtio_register_types)