qemu/hw/net/virtio-net.c

   1 /*
   2  * Virtio Network Device
   3  *
   4  * Copyright IBM, Corp. 2007
   5  *
   6  * Authors:
   7  *  Anthony Liguori   <aliguori@us.ibm.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2.  See
  10  * the COPYING file in the top-level directory.
  11  *
  12  */
  13
  14 #include "qemu/iov.h"
  15 #include "hw/virtio/virtio.h"
  16 #include "net/net.h"
  17 #include "net/checksum.h"
  18 #include "net/tap.h"
  19 #include "qemu/error-report.h"
  20 #include "qemu/timer.h"
  21 #include "hw/virtio/virtio-net.h"
  22 #include "net/vhost_net.h"
  23 #include "hw/virtio/virtio-bus.h"
  24 #include "qapi/qmp/qjson.h"
  25 #include "qapi-event.h"
  26 #include "hw/virtio/virtio-access.h"
  27
  28 #define VIRTIO_NET_VM_VERSION    11
  29
  30 #define MAC_TABLE_ENTRIES    64
  31 #define MAX_VLAN    (1 << 12)   /* Per 802.1Q definition */
  32
  33 /*
  34  * Calculate the number of bytes up to and including the given 'field' of
  35  * 'container'.
  36  */
  37 #define endof(container, field) \
  38     (offsetof(container, field) + sizeof(((container *)0)->field))
  39
  40 typedef struct VirtIOFeature {
  41     uint32_t flags;
  42     size_t end;
  43 } VirtIOFeature;
  44
  45 static VirtIOFeature feature_sizes[] = {
  46     {.flags = 1 << VIRTIO_NET_F_MAC,
  47      .end = endof(struct virtio_net_config, mac)},
  48     {.flags = 1 << VIRTIO_NET_F_STATUS,
  49      .end = endof(struct virtio_net_config, status)},
  50     {.flags = 1 << VIRTIO_NET_F_MQ,
  51      .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
  52     {}
  53 };
  54
  55 static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
  56 {
  57     VirtIONet *n = qemu_get_nic_opaque(nc);
  58
  59     return &n->vqs[nc->queue_index];
  60 }
  61
  62 static int vq2q(int queue_index)
  63 {
  64     return queue_index / 2;
  65 }
  66
  67 /* TODO
  68  * - we could suppress RX interrupt if we were so inclined.
  69  */
  70
  71 static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
  72 {
  73     VirtIONet *n = VIRTIO_NET(vdev);
  74     struct virtio_net_config netcfg;
  75
  76     virtio_stw_p(vdev, &netcfg.status, n->status);
  77     virtio_stw_p(vdev, &netcfg.max_virtqueue_pairs, n->max_queues);
  78     memcpy(netcfg.mac, n->mac, ETH_ALEN);
  79     memcpy(config, &netcfg, n->config_size);
  80 }
  81
  82 static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
  83 {
  84     VirtIONet *n = VIRTIO_NET(vdev);
  85     struct virtio_net_config netcfg = {};
  86
  87     memcpy(&netcfg, config, n->config_size);
  88
  89     if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR) &&
  90         !virtio_has_feature(vdev, VIRTIO_F_VERSION_1) &&
  91         memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
  92         memcpy(n->mac, netcfg.mac, ETH_ALEN);
  93         qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
  94     }
  95 }
  96
  97 static bool virtio_net_started(VirtIONet *n, uint8_t status)
  98 {
  99     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 100     return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
 101         (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
 102 }
 103
 104 static void virtio_net_announce_timer(void *opaque)
 105 {
 106     VirtIONet *n = opaque;
 107     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 108
 109     n->announce_counter--;
 110     n->status |= VIRTIO_NET_S_ANNOUNCE;
 111     virtio_notify_config(vdev);
 112 }
 113
 114 static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
 115 {
 116     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 117     NetClientState *nc = qemu_get_queue(n->nic);
 118     int queues = n->multiqueue ? n->max_queues : 1;
 119
 120     if (!get_vhost_net(nc->peer)) {
 121         return;
 122     }
 123
 124     if ((virtio_net_started(n, status) && !nc->peer->link_down) ==
 125         !!n->vhost_started) {
 126         return;
 127     }
 128     if (!n->vhost_started) {
 129         int r, i;
 130
 131         /* Any packets outstanding? Purge them to avoid touching rings
 132          * when vhost is running.
 133          */
 134         for (i = 0;  i < queues; i++) {
 135             NetClientState *qnc = qemu_get_subqueue(n->nic, i);
 136
 137             /* Purge both directions: TX and RX. */
 138             qemu_net_queue_purge(qnc->peer->incoming_queue, qnc);
 139             qemu_net_queue_purge(qnc->incoming_queue, qnc->peer);
 140         }
 141
 142         n->vhost_started = 1;
 143         r = vhost_net_start(vdev, n->nic->ncs, queues);
 144         if (r < 0) {
 145             error_report("unable to start vhost net: %d: "
 146                          "falling back on userspace virtio", -r);
 147             n->vhost_started = 0;
 148         }
 149     } else {
 150         vhost_net_stop(vdev, n->nic->ncs, queues);
 151         n->vhost_started = 0;
 152     }
 153 }
 154
 155 static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
 156 {
 157     VirtIONet *n = VIRTIO_NET(vdev);
 158     VirtIONetQueue *q;
 159     int i;
 160     uint8_t queue_status;
 161
 162     virtio_net_vhost_status(n, status);
 163
 164     for (i = 0; i < n->max_queues; i++) {
 165         NetClientState *ncs = qemu_get_subqueue(n->nic, i);
 166         bool queue_started;
 167         q = &n->vqs[i];
 168
 169         if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
 170             queue_status = 0;
 171         } else {
 172             queue_status = status;
 173         }
 174         queue_started =
 175             virtio_net_started(n, queue_status) && !n->vhost_started;
 176
 177         if (queue_started) {
 178             qemu_flush_queued_packets(ncs);
 179         }
 180
 181         if (!q->tx_waiting) {
 182             continue;
 183         }
 184
 185         if (queue_started) {
 186             if (q->tx_timer) {
 187                 timer_mod(q->tx_timer,
 188                                qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
 189             } else {
 190                 qemu_bh_schedule(q->tx_bh);
 191             }
 192         } else {
 193             if (q->tx_timer) {
 194                 timer_del(q->tx_timer);
 195             } else {
 196                 qemu_bh_cancel(q->tx_bh);
 197             }
 198         }
 199     }
 200 }
 201
 202 static void virtio_net_set_link_status(NetClientState *nc)
 203 {
 204     VirtIONet *n = qemu_get_nic_opaque(nc);
 205     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 206     uint16_t old_status = n->status;
 207
 208     if (nc->link_down)
 209         n->status &= ~VIRTIO_NET_S_LINK_UP;
 210     else
 211         n->status |= VIRTIO_NET_S_LINK_UP;
 212
 213     if (n->status != old_status)
 214         virtio_notify_config(vdev);
 215
 216     virtio_net_set_status(vdev, vdev->status);
 217 }
 218
 219 static void rxfilter_notify(NetClientState *nc)
 220 {
 221     VirtIONet *n = qemu_get_nic_opaque(nc);
 222
 223     if (nc->rxfilter_notify_enabled) {
 224         gchar *path = object_get_canonical_path(OBJECT(n->qdev));
 225         qapi_event_send_nic_rx_filter_changed(!!n->netclient_name,
 226                                               n->netclient_name, path, &error_abort);
 227         g_free(path);
 228
 229         /* disable event notification to avoid events flooding */
 230         nc->rxfilter_notify_enabled = 0;
 231     }
 232 }
 233
 234 static intList *get_vlan_table(VirtIONet *n)
 235 {
 236     intList *list, *entry;
 237     int i, j;
 238
 239     list = NULL;
 240     for (i = 0; i < MAX_VLAN >> 5; i++) {
 241         for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
 242             if (n->vlans[i] & (1U << j)) {
 243                 entry = g_malloc0(sizeof(*entry));
 244                 entry->value = (i << 5) + j;
 245                 entry->next = list;
 246                 list = entry;
 247             }
 248         }
 249     }
 250
 251     return list;
 252 }
 253
 254 static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
 255 {
 256     VirtIONet *n = qemu_get_nic_opaque(nc);
 257     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 258     RxFilterInfo *info;
 259     strList *str_list, *entry;
 260     int i;
 261
 262     info = g_malloc0(sizeof(*info));
 263     info->name = g_strdup(nc->name);
 264     info->promiscuous = n->promisc;
 265
 266     if (n->nouni) {
 267         info->unicast = RX_STATE_NONE;
 268     } else if (n->alluni) {
 269         info->unicast = RX_STATE_ALL;
 270     } else {
 271         info->unicast = RX_STATE_NORMAL;
 272     }
 273
 274     if (n->nomulti) {
 275         info->multicast = RX_STATE_NONE;
 276     } else if (n->allmulti) {
 277         info->multicast = RX_STATE_ALL;
 278     } else {
 279         info->multicast = RX_STATE_NORMAL;
 280     }
 281
 282     info->broadcast_allowed = n->nobcast;
 283     info->multicast_overflow = n->mac_table.multi_overflow;
 284     info->unicast_overflow = n->mac_table.uni_overflow;
 285
 286     info->main_mac = qemu_mac_strdup_printf(n->mac);
 287
 288     str_list = NULL;
 289     for (i = 0; i < n->mac_table.first_multi; i++) {
 290         entry = g_malloc0(sizeof(*entry));
 291         entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
 292         entry->next = str_list;
 293         str_list = entry;
 294     }
 295     info->unicast_table = str_list;
 296
 297     str_list = NULL;
 298     for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
 299         entry = g_malloc0(sizeof(*entry));
 300         entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
 301         entry->next = str_list;
 302         str_list = entry;
 303     }
 304     info->multicast_table = str_list;
 305     info->vlan_table = get_vlan_table(n);
 306
 307     if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VLAN)) {
 308         info->vlan = RX_STATE_ALL;
 309     } else if (!info->vlan_table) {
 310         info->vlan = RX_STATE_NONE;
 311     } else {
 312         info->vlan = RX_STATE_NORMAL;
 313     }
 314
 315     /* enable event notification after query */
 316     nc->rxfilter_notify_enabled = 1;
 317
 318     return info;
 319 }
 320
 321 static void virtio_net_reset(VirtIODevice *vdev)
 322 {
 323     VirtIONet *n = VIRTIO_NET(vdev);
 324
 325     /* Reset back to compatibility mode */
 326     n->promisc = 1;
 327     n->allmulti = 0;
 328     n->alluni = 0;
 329     n->nomulti = 0;
 330     n->nouni = 0;
 331     n->nobcast = 0;
 332     /* multiqueue is disabled by default */
 333     n->curr_queues = 1;
 334     timer_del(n->announce_timer);
 335     n->announce_counter = 0;
 336     n->status &= ~VIRTIO_NET_S_ANNOUNCE;
 337
 338     /* Flush any MAC and VLAN filter table state */
 339     n->mac_table.in_use = 0;
 340     n->mac_table.first_multi = 0;
 341     n->mac_table.multi_overflow = 0;
 342     n->mac_table.uni_overflow = 0;
 343     memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
 344     memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
 345     qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
 346     memset(n->vlans, 0, MAX_VLAN >> 3);
 347 }
 348
 349 static void peer_test_vnet_hdr(VirtIONet *n)
 350 {
 351     NetClientState *nc = qemu_get_queue(n->nic);
 352     if (!nc->peer) {
 353         return;
 354     }
 355
 356     n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
 357 }
 358
 359 static int peer_has_vnet_hdr(VirtIONet *n)
 360 {
 361     return n->has_vnet_hdr;
 362 }
 363
 364 static int peer_has_ufo(VirtIONet *n)
 365 {
 366     if (!peer_has_vnet_hdr(n))
 367         return 0;
 368
 369     n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
 370
 371     return n->has_ufo;
 372 }
 373
 374 static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs,
 375                                        int version_1)
 376 {
 377     int i;
 378     NetClientState *nc;
 379
 380     n->mergeable_rx_bufs = mergeable_rx_bufs;
 381
 382     if (version_1) {
 383         n->guest_hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
 384     } else {
 385         n->guest_hdr_len = n->mergeable_rx_bufs ?
 386             sizeof(struct virtio_net_hdr_mrg_rxbuf) :
 387             sizeof(struct virtio_net_hdr);
 388     }
 389
 390     for (i = 0; i < n->max_queues; i++) {
 391         nc = qemu_get_subqueue(n->nic, i);
 392
 393         if (peer_has_vnet_hdr(n) &&
 394             qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
 395             qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
 396             n->host_hdr_len = n->guest_hdr_len;
 397         }
 398     }
 399 }
 400
 401 static int peer_attach(VirtIONet *n, int index)
 402 {
 403     NetClientState *nc = qemu_get_subqueue(n->nic, index);
 404
 405     if (!nc->peer) {
 406         return 0;
 407     }
 408
 409     if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
 410         return 0;
 411     }
 412
 413     return tap_enable(nc->peer);
 414 }
 415
 416 static int peer_detach(VirtIONet *n, int index)
 417 {
 418     NetClientState *nc = qemu_get_subqueue(n->nic, index);
 419
 420     if (!nc->peer) {
 421         return 0;
 422     }
 423
 424     if (nc->peer->info->type !=  NET_CLIENT_OPTIONS_KIND_TAP) {
 425         return 0;
 426     }
 427
 428     return tap_disable(nc->peer);
 429 }
 430
 431 static void virtio_net_set_queues(VirtIONet *n)
 432 {
 433     int i;
 434     int r;
 435
 436     for (i = 0; i < n->max_queues; i++) {
 437         if (i < n->curr_queues) {
 438             r = peer_attach(n, i);
 439             assert(!r);
 440         } else {
 441             r = peer_detach(n, i);
 442             assert(!r);
 443         }
 444     }
 445 }
 446
 447 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
 448
 449 static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
 450                                         Error **errp)
 451 {
 452     VirtIONet *n = VIRTIO_NET(vdev);
 453     NetClientState *nc = qemu_get_queue(n->nic);
 454
 455     /* Firstly sync all virtio-net possible supported features */
 456     features |= n->host_features;
 457
 458     virtio_add_feature(&features, VIRTIO_NET_F_MAC);
 459
 460     if (!peer_has_vnet_hdr(n)) {
 461         virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
 462         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
 463         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
 464         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
 465
 466         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
 467         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
 468         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
 469         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
 470     }
 471
 472     if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
 473         virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
 474         virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
 475     }
 476
 477     if (!get_vhost_net(nc->peer)) {
 478         return features;
 479     }
 480     return vhost_net_get_features(get_vhost_net(nc->peer), features);
 481 }
 482
 483 static uint64_t virtio_net_bad_features(VirtIODevice *vdev)
 484 {
 485     uint64_t features = 0;
 486
 487     /* Linux kernel 2.6.25.  It understood MAC (as everyone must),
 488      * but also these: */
 489     virtio_add_feature(&features, VIRTIO_NET_F_MAC);
 490     virtio_add_feature(&features, VIRTIO_NET_F_CSUM);
 491     virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO4);
 492     virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO6);
 493     virtio_add_feature(&features, VIRTIO_NET_F_HOST_ECN);
 494
 495     return features;
 496 }
 497
 498 static void virtio_net_apply_guest_offloads(VirtIONet *n)
 499 {
 500     qemu_set_offload(qemu_get_queue(n->nic)->peer,
 501             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
 502             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
 503             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
 504             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
 505             !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
 506 }
 507
 508 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
 509 {
 510     static const uint64_t guest_offloads_mask =
 511         (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
 512         (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
 513         (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
 514         (1ULL << VIRTIO_NET_F_GUEST_ECN)  |
 515         (1ULL << VIRTIO_NET_F_GUEST_UFO);
 516
 517     return guest_offloads_mask & features;
 518 }
 519
 520 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
 521 {
 522     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 523     return virtio_net_guest_offloads_by_features(vdev->guest_features);
 524 }
 525
 526 static void virtio_net_set_features(VirtIODevice *vdev, uint64_t features)
 527 {
 528     VirtIONet *n = VIRTIO_NET(vdev);
 529     int i;
 530
 531     virtio_net_set_multiqueue(n,
 532                               __virtio_has_feature(features, VIRTIO_NET_F_MQ));
 533
 534     virtio_net_set_mrg_rx_bufs(n,
 535                                __virtio_has_feature(features,
 536                                                     VIRTIO_NET_F_MRG_RXBUF),
 537                                __virtio_has_feature(features,
 538                                                     VIRTIO_F_VERSION_1));
 539
 540     if (n->has_vnet_hdr) {
 541         n->curr_guest_offloads =
 542             virtio_net_guest_offloads_by_features(features);
 543         virtio_net_apply_guest_offloads(n);
 544     }
 545
 546     for (i = 0;  i < n->max_queues; i++) {
 547         NetClientState *nc = qemu_get_subqueue(n->nic, i);
 548
 549         if (!get_vhost_net(nc->peer)) {
 550             continue;
 551         }
 552         vhost_net_ack_features(get_vhost_net(nc->peer), features);
 553     }
 554
 555     if (__virtio_has_feature(features, VIRTIO_NET_F_CTRL_VLAN)) {
 556         memset(n->vlans, 0, MAX_VLAN >> 3);
 557     } else {
 558         memset(n->vlans, 0xff, MAX_VLAN >> 3);
 559     }
 560 }
 561
 562 static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
 563                                      struct iovec *iov, unsigned int iov_cnt)
 564 {
 565     uint8_t on;
 566     size_t s;
 567     NetClientState *nc = qemu_get_queue(n->nic);
 568
 569     s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
 570     if (s != sizeof(on)) {
 571         return VIRTIO_NET_ERR;
 572     }
 573
 574     if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
 575         n->promisc = on;
 576     } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
 577         n->allmulti = on;
 578     } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
 579         n->alluni = on;
 580     } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
 581         n->nomulti = on;
 582     } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
 583         n->nouni = on;
 584     } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
 585         n->nobcast = on;
 586     } else {
 587         return VIRTIO_NET_ERR;
 588     }
 589
 590     rxfilter_notify(nc);
 591
 592     return VIRTIO_NET_OK;
 593 }
 594
 595 static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
 596                                      struct iovec *iov, unsigned int iov_cnt)
 597 {
 598     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 599     uint64_t offloads;
 600     size_t s;
 601
 602     if (!virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
 603         return VIRTIO_NET_ERR;
 604     }
 605
 606     s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
 607     if (s != sizeof(offloads)) {
 608         return VIRTIO_NET_ERR;
 609     }
 610
 611     if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
 612         uint64_t supported_offloads;
 613
 614         if (!n->has_vnet_hdr) {
 615             return VIRTIO_NET_ERR;
 616         }
 617
 618         supported_offloads = virtio_net_supported_guest_offloads(n);
 619         if (offloads & ~supported_offloads) {
 620             return VIRTIO_NET_ERR;
 621         }
 622
 623         n->curr_guest_offloads = offloads;
 624         virtio_net_apply_guest_offloads(n);
 625
 626         return VIRTIO_NET_OK;
 627     } else {
 628         return VIRTIO_NET_ERR;
 629     }
 630 }
 631
 632 static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
 633                                  struct iovec *iov, unsigned int iov_cnt)
 634 {
 635     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 636     struct virtio_net_ctrl_mac mac_data;
 637     size_t s;
 638     NetClientState *nc = qemu_get_queue(n->nic);
 639
 640     if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
 641         if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
 642             return VIRTIO_NET_ERR;
 643         }
 644         s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
 645         assert(s == sizeof(n->mac));
 646         qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
 647         rxfilter_notify(nc);
 648
 649         return VIRTIO_NET_OK;
 650     }
 651
 652     if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
 653         return VIRTIO_NET_ERR;
 654     }
 655
 656     int in_use = 0;
 657     int first_multi = 0;
 658     uint8_t uni_overflow = 0;
 659     uint8_t multi_overflow = 0;
 660     uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
 661
 662     s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
 663                    sizeof(mac_data.entries));
 664     mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
 665     if (s != sizeof(mac_data.entries)) {
 666         goto error;
 667     }
 668     iov_discard_front(&iov, &iov_cnt, s);
 669
 670     if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
 671         goto error;
 672     }
 673
 674     if (mac_data.entries <= MAC_TABLE_ENTRIES) {
 675         s = iov_to_buf(iov, iov_cnt, 0, macs,
 676                        mac_data.entries * ETH_ALEN);
 677         if (s != mac_data.entries * ETH_ALEN) {
 678             goto error;
 679         }
 680         in_use += mac_data.entries;
 681     } else {
 682         uni_overflow = 1;
 683     }
 684
 685     iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
 686
 687     first_multi = in_use;
 688
 689     s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
 690                    sizeof(mac_data.entries));
 691     mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
 692     if (s != sizeof(mac_data.entries)) {
 693         goto error;
 694     }
 695
 696     iov_discard_front(&iov, &iov_cnt, s);
 697
 698     if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
 699         goto error;
 700     }
 701
 702     if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
 703         s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
 704                        mac_data.entries * ETH_ALEN);
 705         if (s != mac_data.entries * ETH_ALEN) {
 706             goto error;
 707         }
 708         in_use += mac_data.entries;
 709     } else {
 710         multi_overflow = 1;
 711     }
 712
 713     n->mac_table.in_use = in_use;
 714     n->mac_table.first_multi = first_multi;
 715     n->mac_table.uni_overflow = uni_overflow;
 716     n->mac_table.multi_overflow = multi_overflow;
 717     memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
 718     g_free(macs);
 719     rxfilter_notify(nc);
 720
 721     return VIRTIO_NET_OK;
 722
 723 error:
 724     g_free(macs);
 725     return VIRTIO_NET_ERR;
 726 }
 727
 728 static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
 729                                         struct iovec *iov, unsigned int iov_cnt)
 730 {
 731     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 732     uint16_t vid;
 733     size_t s;
 734     NetClientState *nc = qemu_get_queue(n->nic);
 735
 736     s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
 737     vid = virtio_lduw_p(vdev, &vid);
 738     if (s != sizeof(vid)) {
 739         return VIRTIO_NET_ERR;
 740     }
 741
 742     if (vid >= MAX_VLAN)
 743         return VIRTIO_NET_ERR;
 744
 745     if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
 746         n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
 747     else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
 748         n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
 749     else
 750         return VIRTIO_NET_ERR;
 751
 752     rxfilter_notify(nc);
 753
 754     return VIRTIO_NET_OK;
 755 }
 756
 757 static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
 758                                       struct iovec *iov, unsigned int iov_cnt)
 759 {
 760     if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
 761         n->status & VIRTIO_NET_S_ANNOUNCE) {
 762         n->status &= ~VIRTIO_NET_S_ANNOUNCE;
 763         if (n->announce_counter) {
 764             timer_mod(n->announce_timer,
 765                       qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
 766                       self_announce_delay(n->announce_counter));
 767         }
 768         return VIRTIO_NET_OK;
 769     } else {
 770         return VIRTIO_NET_ERR;
 771     }
 772 }
 773
 774 static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
 775                                 struct iovec *iov, unsigned int iov_cnt)
 776 {
 777     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 778     struct virtio_net_ctrl_mq mq;
 779     size_t s;
 780     uint16_t queues;
 781
 782     s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
 783     if (s != sizeof(mq)) {
 784         return VIRTIO_NET_ERR;
 785     }
 786
 787     if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
 788         return VIRTIO_NET_ERR;
 789     }
 790
 791     queues = virtio_lduw_p(vdev, &mq.virtqueue_pairs);
 792
 793     if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
 794         queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
 795         queues > n->max_queues ||
 796         !n->multiqueue) {
 797         return VIRTIO_NET_ERR;
 798     }
 799
 800     n->curr_queues = queues;
 801     /* stop the backend before changing the number of queues to avoid handling a
 802      * disabled queue */
 803     virtio_net_set_status(vdev, vdev->status);
 804     virtio_net_set_queues(n);
 805
 806     return VIRTIO_NET_OK;
 807 }
 808 static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
 809 {
 810     VirtIONet *n = VIRTIO_NET(vdev);
 811     struct virtio_net_ctrl_hdr ctrl;
 812     virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 813     VirtQueueElement elem;
 814     size_t s;
 815     struct iovec *iov, *iov2;
 816     unsigned int iov_cnt;
 817
 818     while (virtqueue_pop(vq, &elem)) {
 819         if (iov_size(elem.in_sg, elem.in_num) < sizeof(status) ||
 820             iov_size(elem.out_sg, elem.out_num) < sizeof(ctrl)) {
 821             error_report("virtio-net ctrl missing headers");
 822             exit(1);
 823         }
 824
 825         iov_cnt = elem.out_num;
 826         iov2 = iov = g_memdup(elem.out_sg, sizeof(struct iovec) * elem.out_num);
 827         s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
 828         iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
 829         if (s != sizeof(ctrl)) {
 830             status = VIRTIO_NET_ERR;
 831         } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
 832             status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
 833         } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
 834             status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
 835         } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
 836             status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
 837         } else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
 838             status = virtio_net_handle_announce(n, ctrl.cmd, iov, iov_cnt);
 839         } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
 840             status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
 841         } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
 842             status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
 843         }
 844
 845         s = iov_from_buf(elem.in_sg, elem.in_num, 0, &status, sizeof(status));
 846         assert(s == sizeof(status));
 847
 848         virtqueue_push(vq, &elem, sizeof(status));
 849         virtio_notify(vdev, vq);
 850         g_free(iov2);
 851     }
 852 }
 853
 854 /* RX */
 855
 856 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
 857 {
 858     VirtIONet *n = VIRTIO_NET(vdev);
 859     int queue_index = vq2q(virtio_get_queue_index(vq));
 860
 861     qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
 862 }
 863
 864 static int virtio_net_can_receive(NetClientState *nc)
 865 {
 866     VirtIONet *n = qemu_get_nic_opaque(nc);
 867     VirtIODevice *vdev = VIRTIO_DEVICE(n);
 868     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
 869
 870     if (!vdev->vm_running) {
 871         return 0;
 872     }
 873
 874     if (nc->queue_index >= n->curr_queues) {
 875         return 0;
 876     }
 877
 878     if (!virtio_queue_ready(q->rx_vq) ||
 879         !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
 880         return 0;
 881     }
 882
 883     return 1;
 884 }
 885
 886 static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
 887 {
 888     VirtIONet *n = q->n;
 889     if (virtio_queue_empty(q->rx_vq) ||
 890         (n->mergeable_rx_bufs &&
 891          !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
 892         virtio_queue_set_notification(q->rx_vq, 1);
 893
 894         /* To avoid a race condition where the guest has made some buffers
 895          * available after the above check but before notification was
 896          * enabled, check for available buffers again.
 897          */
 898         if (virtio_queue_empty(q->rx_vq) ||
 899             (n->mergeable_rx_bufs &&
 900              !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
 901             return 0;
 902         }
 903     }
 904
 905     virtio_queue_set_notification(q->rx_vq, 0);
 906     return 1;
 907 }
 908
 909 static void virtio_net_hdr_swap(VirtIODevice *vdev, struct virtio_net_hdr *hdr)
 910 {
 911     virtio_tswap16s(vdev, &hdr->hdr_len);
 912     virtio_tswap16s(vdev, &hdr->gso_size);
 913     virtio_tswap16s(vdev, &hdr->csum_start);
 914     virtio_tswap16s(vdev, &hdr->csum_offset);
 915 }
 916
 917 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
 918  * it never finds out that the packets don't have valid checksums.  This
 919  * causes dhclient to get upset.  Fedora's carried a patch for ages to
 920  * fix this with Xen but it hasn't appeared in an upstream release of
 921  * dhclient yet.
 922  *
 923  * To avoid breaking existing guests, we catch udp packets and add
 924  * checksums.  This is terrible but it's better than hacking the guest
 925  * kernels.
 926  *
 927  * N.B. if we introduce a zero-copy API, this operation is no longer free so
 928  * we should provide a mechanism to disable it to avoid polluting the host
 929  * cache.
 930  */
 931 static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
 932                                         uint8_t *buf, size_t size)
 933 {
 934     if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
 935         (size > 27 && size < 1500) && /* normal sized MTU */
 936         (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
 937         (buf[23] == 17) && /* ip.protocol == UDP */
 938         (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
 939         net_checksum_calculate(buf, size);
 940         hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
 941     }
 942 }
 943
 944 static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
 945                            const void *buf, size_t size)
 946 {
 947     if (n->has_vnet_hdr) {
 948         /* FIXME this cast is evil */
 949         void *wbuf = (void *)buf;
 950         work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
 951                                     size - n->host_hdr_len);
 952         virtio_net_hdr_swap(VIRTIO_DEVICE(n), wbuf);
 953         iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
 954     } else {
 955         struct virtio_net_hdr hdr = {
 956             .flags = 0,
 957             .gso_type = VIRTIO_NET_HDR_GSO_NONE
 958         };
 959         iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
 960     }
 961 }
 962
 963 static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
 964 {
 965     static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 966     static const uint8_t vlan[] = {0x81, 0x00};
 967     uint8_t *ptr = (uint8_t *)buf;
 968     int i;
 969
 970     if (n->promisc)
 971         return 1;
 972
 973     ptr += n->host_hdr_len;
 974
 975     if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
 976         int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
 977         if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
 978             return 0;
 979     }
 980
 981     if (ptr[0] & 1) { // multicast
 982         if (!memcmp(ptr, bcast, sizeof(bcast))) {
 983             return !n->nobcast;
 984         } else if (n->nomulti) {
 985             return 0;
 986         } else if (n->allmulti || n->mac_table.multi_overflow) {
 987             return 1;
 988         }
 989
 990         for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
 991             if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
 992                 return 1;
 993             }
 994         }
 995     } else { // unicast
 996         if (n->nouni) {
 997             return 0;
 998         } else if (n->alluni || n->mac_table.uni_overflow) {
 999             return 1;
1000         } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
1001             return 1;
1002         }
1003
1004         for (i = 0; i < n->mac_table.first_multi; i++) {
1005             if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1006                 return 1;
1007             }
1008         }
1009     }
1010
1011     return 0;
1012 }
1013
1014 static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf, size_t size)
1015 {
1016     VirtIONet *n = qemu_get_nic_opaque(nc);
1017     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1018     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1019     struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
1020     struct virtio_net_hdr_mrg_rxbuf mhdr;
1021     unsigned mhdr_cnt = 0;
1022     size_t offset, i, guest_offset;
1023
1024     if (!virtio_net_can_receive(nc)) {
1025         return -1;
1026     }
1027
1028     /* hdr_len refers to the header we supply to the guest */
1029     if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
1030         return 0;
1031     }
1032
1033     if (!receive_filter(n, buf, size))
1034         return size;
1035
1036     offset = i = 0;
1037
1038     while (offset < size) {
1039         VirtQueueElement elem;
1040         int len, total;
1041         const struct iovec *sg = elem.in_sg;
1042
1043         total = 0;
1044
1045         if (virtqueue_pop(q->rx_vq, &elem) == 0) {
1046             if (i == 0)
1047                 return -1;
1048             error_report("virtio-net unexpected empty queue: "
1049                          "i %zd mergeable %d offset %zd, size %zd, "
1050                          "guest hdr len %zd, host hdr len %zd "
1051                          "guest features 0x%" PRIx64,
1052                          i, n->mergeable_rx_bufs, offset, size,
1053                          n->guest_hdr_len, n->host_hdr_len,
1054                          vdev->guest_features);
1055             exit(1);
1056         }
1057
1058         if (elem.in_num < 1) {
1059             error_report("virtio-net receive queue contains no in buffers");
1060             exit(1);
1061         }
1062
1063         if (i == 0) {
1064             assert(offset == 0);
1065             if (n->mergeable_rx_bufs) {
1066                 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
1067                                     sg, elem.in_num,
1068                                     offsetof(typeof(mhdr), num_buffers),
1069                                     sizeof(mhdr.num_buffers));
1070             }
1071
1072             receive_header(n, sg, elem.in_num, buf, size);
1073             offset = n->host_hdr_len;
1074             total += n->guest_hdr_len;
1075             guest_offset = n->guest_hdr_len;
1076         } else {
1077             guest_offset = 0;
1078         }
1079
1080         /* copy in packet.  ugh */
1081         len = iov_from_buf(sg, elem.in_num, guest_offset,
1082                            buf + offset, size - offset);
1083         total += len;
1084         offset += len;
1085         /* If buffers can't be merged, at this point we
1086          * must have consumed the complete packet.
1087          * Otherwise, drop it. */
1088         if (!n->mergeable_rx_bufs && offset < size) {
1089 #if 0
1090             error_report("virtio-net truncated non-mergeable packet: "
1091                          "i %zd mergeable %d offset %zd, size %zd, "
1092                          "guest hdr len %zd, host hdr len %zd",
1093                          i, n->mergeable_rx_bufs,
1094                          offset, size, n->guest_hdr_len, n->host_hdr_len);
1095 #endif
1096             return size;
1097         }
1098
1099         /* signal other side */
1100         virtqueue_fill(q->rx_vq, &elem, total, i++);
1101     }
1102
1103     if (mhdr_cnt) {
1104         virtio_stw_p(vdev, &mhdr.num_buffers, i);
1105         iov_from_buf(mhdr_sg, mhdr_cnt,
1106                      0,
1107                      &mhdr.num_buffers, sizeof mhdr.num_buffers);
1108     }
1109
1110     virtqueue_flush(q->rx_vq, i);
1111     virtio_notify(vdev, q->rx_vq);
1112
1113     return size;
1114 }
1115
1116 static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
1117
1118 static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
1119 {
1120     VirtIONet *n = qemu_get_nic_opaque(nc);
1121     VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1122     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1123
1124     virtqueue_push(q->tx_vq, &q->async_tx.elem, 0);
1125     virtio_notify(vdev, q->tx_vq);
1126
1127     q->async_tx.elem.out_num = q->async_tx.len = 0;
1128
1129     virtio_queue_set_notification(q->tx_vq, 1);
1130     virtio_net_flush_tx(q);
1131 }
1132
1133 /* TX */
1134 static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
1135 {
1136     VirtIONet *n = q->n;
1137     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1138     VirtQueueElement elem;
1139     int32_t num_packets = 0;
1140     int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
1141     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1142         return num_packets;
1143     }
1144
1145     if (q->async_tx.elem.out_num) {
1146         virtio_queue_set_notification(q->tx_vq, 0);
1147         return num_packets;
1148     }
1149
1150     while (virtqueue_pop(q->tx_vq, &elem)) {
1151         ssize_t ret, len;
1152         unsigned int out_num = elem.out_num;
1153         struct iovec *out_sg = &elem.out_sg[0];
1154         struct iovec sg[VIRTQUEUE_MAX_SIZE], sg2[VIRTQUEUE_MAX_SIZE + 1];
1155         struct virtio_net_hdr_mrg_rxbuf mhdr;
1156
1157         if (out_num < 1) {
1158             error_report("virtio-net header not in first element");
1159             exit(1);
1160         }
1161
1162         if (n->has_vnet_hdr) {
1163             if (iov_to_buf(out_sg, out_num, 0, &mhdr, n->guest_hdr_len) <
1164                 n->guest_hdr_len) {
1165                 error_report("virtio-net header incorrect");
1166                 exit(1);
1167             }
1168             if (virtio_needs_swap(vdev)) {
1169                 virtio_net_hdr_swap(vdev, (void *) &mhdr);
1170                 sg2[0].iov_base = &mhdr;
1171                 sg2[0].iov_len = n->guest_hdr_len;
1172                 out_num = iov_copy(&sg2[1], ARRAY_SIZE(sg2) - 1,
1173                                    out_sg, out_num,
1174                                    n->guest_hdr_len, -1);
1175                 if (out_num == VIRTQUEUE_MAX_SIZE) {
1176                     goto drop;
1177                 }
1178                 out_num += 1;
1179                 out_sg = sg2;
1180             }
1181         }
1182         /*
1183          * If host wants to see the guest header as is, we can
1184          * pass it on unchanged. Otherwise, copy just the parts
1185          * that host is interested in.
1186          */
1187         assert(n->host_hdr_len <= n->guest_hdr_len);
1188         if (n->host_hdr_len != n->guest_hdr_len) {
1189             unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
1190                                        out_sg, out_num,
1191                                        0, n->host_hdr_len);
1192             sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
1193                              out_sg, out_num,
1194                              n->guest_hdr_len, -1);
1195             out_num = sg_num;
1196             out_sg = sg;
1197         }
1198
1199         len = n->guest_hdr_len;
1200
1201         ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
1202                                       out_sg, out_num, virtio_net_tx_complete);
1203         if (ret == 0) {
1204             virtio_queue_set_notification(q->tx_vq, 0);
1205             q->async_tx.elem = elem;
1206             q->async_tx.len  = len;
1207             return -EBUSY;
1208         }
1209
1210         len += ret;
1211 drop:
1212         virtqueue_push(q->tx_vq, &elem, 0);
1213         virtio_notify(vdev, q->tx_vq);
1214
1215         if (++num_packets >= n->tx_burst) {
1216             break;
1217         }
1218     }
1219     return num_packets;
1220 }
1221
1222 static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
1223 {
1224     VirtIONet *n = VIRTIO_NET(vdev);
1225     VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
1226
1227     /* This happens when device was stopped but VCPU wasn't. */
1228     if (!vdev->vm_running) {
1229         q->tx_waiting = 1;
1230         return;
1231     }
1232
1233     if (q->tx_waiting) {
1234         virtio_queue_set_notification(vq, 1);
1235         timer_del(q->tx_timer);
1236         q->tx_waiting = 0;
1237         virtio_net_flush_tx(q);
1238     } else {
1239         timer_mod(q->tx_timer,
1240                        qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
1241         q->tx_waiting = 1;
1242         virtio_queue_set_notification(vq, 0);
1243     }
1244 }
1245
1246 static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
1247 {
1248     VirtIONet *n = VIRTIO_NET(vdev);
1249     VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
1250
1251     if (unlikely(q->tx_waiting)) {
1252         return;
1253     }
1254     q->tx_waiting = 1;
1255     /* This happens when device was stopped but VCPU wasn't. */
1256     if (!vdev->vm_running) {
1257         return;
1258     }
1259     virtio_queue_set_notification(vq, 0);
1260     qemu_bh_schedule(q->tx_bh);
1261 }
1262
1263 static void virtio_net_tx_timer(void *opaque)
1264 {
1265     VirtIONetQueue *q = opaque;
1266     VirtIONet *n = q->n;
1267     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1268     /* This happens when device was stopped but BH wasn't. */
1269     if (!vdev->vm_running) {
1270         /* Make sure tx waiting is set, so we'll run when restarted. */
1271         assert(q->tx_waiting);
1272         return;
1273     }
1274
1275     q->tx_waiting = 0;
1276
1277     /* Just in case the driver is not ready on more */
1278     if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1279         return;
1280     }
1281
1282     virtio_queue_set_notification(q->tx_vq, 1);
1283     virtio_net_flush_tx(q);
1284 }
1285
1286 static void virtio_net_tx_bh(void *opaque)
1287 {
1288     VirtIONetQueue *q = opaque;
1289     VirtIONet *n = q->n;
1290     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1291     int32_t ret;
1292
1293     /* This happens when device was stopped but BH wasn't. */
1294     if (!vdev->vm_running) {
1295         /* Make sure tx waiting is set, so we'll run when restarted. */
1296         assert(q->tx_waiting);
1297         return;
1298     }
1299
1300     q->tx_waiting = 0;
1301
1302     /* Just in case the driver is not ready on more */
1303     if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
1304         return;
1305     }
1306
1307     ret = virtio_net_flush_tx(q);
1308     if (ret == -EBUSY) {
1309         return; /* Notification re-enable handled by tx_complete */
1310     }
1311
1312     /* If we flush a full burst of packets, assume there are
1313      * more coming and immediately reschedule */
1314     if (ret >= n->tx_burst) {
1315         qemu_bh_schedule(q->tx_bh);
1316         q->tx_waiting = 1;
1317         return;
1318     }
1319
1320     /* If less than a full burst, re-enable notification and flush
1321      * anything that may have come in while we weren't looking.  If
1322      * we find something, assume the guest is still active and reschedule */
1323     virtio_queue_set_notification(q->tx_vq, 1);
1324     if (virtio_net_flush_tx(q) > 0) {
1325         virtio_queue_set_notification(q->tx_vq, 0);
1326         qemu_bh_schedule(q->tx_bh);
1327         q->tx_waiting = 1;
1328     }
1329 }
1330
1331 static void virtio_net_add_queue(VirtIONet *n, int index)
1332 {
1333     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1334
1335     n->vqs[index].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
1336     if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
1337         n->vqs[index].tx_vq =
1338             virtio_add_queue(vdev, 256, virtio_net_handle_tx_timer);
1339         n->vqs[index].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
1340                                               virtio_net_tx_timer,
1341                                               &n->vqs[index]);
1342     } else {
1343         n->vqs[index].tx_vq =
1344             virtio_add_queue(vdev, 256, virtio_net_handle_tx_bh);
1345         n->vqs[index].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[index]);
1346     }
1347
1348     n->vqs[index].tx_waiting = 0;
1349     n->vqs[index].n = n;
1350 }
1351
1352 static void virtio_net_del_queue(VirtIONet *n, int index)
1353 {
1354     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1355     VirtIONetQueue *q = &n->vqs[index];
1356     NetClientState *nc = qemu_get_subqueue(n->nic, index);
1357
1358     qemu_purge_queued_packets(nc);
1359
1360     virtio_del_queue(vdev, index * 2);
1361     if (q->tx_timer) {
1362         timer_del(q->tx_timer);
1363         timer_free(q->tx_timer);
1364     } else {
1365         qemu_bh_delete(q->tx_bh);
1366     }
1367     virtio_del_queue(vdev, index * 2 + 1);
1368 }
1369
1370 static void virtio_net_change_num_queues(VirtIONet *n, int new_max_queues)
1371 {
1372     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1373     int old_num_queues = virtio_get_num_queues(vdev);
1374     int new_num_queues = new_max_queues * 2 + 1;
1375     int i;
1376
1377     assert(old_num_queues >= 3);
1378     assert(old_num_queues % 2 == 1);
1379
1380     if (old_num_queues == new_num_queues) {
1381         return;
1382     }
1383
1384     /*
1385      * We always need to remove and add ctrl vq if
1386      * old_num_queues != new_num_queues. Remove ctrl_vq first,
1387      * and then we only enter one of the following too loops.
1388      */
1389     virtio_del_queue(vdev, old_num_queues - 1);
1390
1391     for (i = new_num_queues - 1; i < old_num_queues - 1; i += 2) {
1392         /* new_num_queues < old_num_queues */
1393         virtio_net_del_queue(n, i / 2);
1394     }
1395
1396     for (i = old_num_queues - 1; i < new_num_queues - 1; i += 2) {
1397         /* new_num_queues > old_num_queues */
1398         virtio_net_add_queue(n, i / 2);
1399     }
1400
1401     /* add ctrl_vq last */
1402     n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
1403 }
1404
1405 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
1406 {
1407     int max = multiqueue ? n->max_queues : 1;
1408
1409     n->multiqueue = multiqueue;
1410     virtio_net_change_num_queues(n, max);
1411
1412     virtio_net_set_queues(n);
1413 }
1414
1415 static void virtio_net_save(QEMUFile *f, void *opaque)
1416 {
1417     VirtIONet *n = opaque;
1418     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1419
1420     /* At this point, backend must be stopped, otherwise
1421      * it might keep writing to memory. */
1422     assert(!n->vhost_started);
1423     virtio_save(vdev, f);
1424 }
1425
1426 static void virtio_net_save_device(VirtIODevice *vdev, QEMUFile *f)
1427 {
1428     VirtIONet *n = VIRTIO_NET(vdev);
1429     int i;
1430
1431     qemu_put_buffer(f, n->mac, ETH_ALEN);
1432     qemu_put_be32(f, n->vqs[0].tx_waiting);
1433     qemu_put_be32(f, n->mergeable_rx_bufs);
1434     qemu_put_be16(f, n->status);
1435     qemu_put_byte(f, n->promisc);
1436     qemu_put_byte(f, n->allmulti);
1437     qemu_put_be32(f, n->mac_table.in_use);
1438     qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
1439     qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
1440     qemu_put_be32(f, n->has_vnet_hdr);
1441     qemu_put_byte(f, n->mac_table.multi_overflow);
1442     qemu_put_byte(f, n->mac_table.uni_overflow);
1443     qemu_put_byte(f, n->alluni);
1444     qemu_put_byte(f, n->nomulti);
1445     qemu_put_byte(f, n->nouni);
1446     qemu_put_byte(f, n->nobcast);
1447     qemu_put_byte(f, n->has_ufo);
1448     if (n->max_queues > 1) {
1449         qemu_put_be16(f, n->max_queues);
1450         qemu_put_be16(f, n->curr_queues);
1451         for (i = 1; i < n->curr_queues; i++) {
1452             qemu_put_be32(f, n->vqs[i].tx_waiting);
1453         }
1454     }
1455
1456     if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
1457         qemu_put_be64(f, n->curr_guest_offloads);
1458     }
1459 }
1460
1461 static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
1462 {
1463     VirtIONet *n = opaque;
1464     VirtIODevice *vdev = VIRTIO_DEVICE(n);
1465
1466     if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
1467         return -EINVAL;
1468
1469     return virtio_load(vdev, f, version_id);
1470 }
1471
1472 static int virtio_net_load_device(VirtIODevice *vdev, QEMUFile *f,
1473                                   int version_id)
1474 {
1475     VirtIONet *n = VIRTIO_NET(vdev);
1476     int i, link_down;
1477
1478     qemu_get_buffer(f, n->mac, ETH_ALEN);
1479     n->vqs[0].tx_waiting = qemu_get_be32(f);
1480
1481     virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f),
1482                                virtio_has_feature(vdev, VIRTIO_F_VERSION_1));
1483
1484     if (version_id >= 3)
1485         n->status = qemu_get_be16(f);
1486
1487     if (version_id >= 4) {
1488         if (version_id < 8) {
1489             n->promisc = qemu_get_be32(f);
1490             n->allmulti = qemu_get_be32(f);
1491         } else {
1492             n->promisc = qemu_get_byte(f);
1493             n->allmulti = qemu_get_byte(f);
1494         }
1495     }
1496
1497     if (version_id >= 5) {
1498         n->mac_table.in_use = qemu_get_be32(f);
1499         /* MAC_TABLE_ENTRIES may be different from the saved image */
1500         if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
1501             qemu_get_buffer(f, n->mac_table.macs,
1502                             n->mac_table.in_use * ETH_ALEN);
1503         } else {
1504             int64_t i;
1505
1506             /* Overflow detected - can happen if source has a larger MAC table.
1507              * We simply set overflow flag so there's no need to maintain the
1508              * table of addresses, discard them all.
1509              * Note: 64 bit math to avoid integer overflow.
1510              */
1511             for (i = 0; i < (int64_t)n->mac_table.in_use * ETH_ALEN; ++i) {
1512                 qemu_get_byte(f);
1513             }
1514             n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
1515             n->mac_table.in_use = 0;
1516         }
1517     }
1518
1519     if (version_id >= 6)
1520         qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
1521
1522     if (version_id >= 7) {
1523         if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
1524             error_report("virtio-net: saved image requires vnet_hdr=on");
1525             return -1;
1526         }
1527     }
1528
1529     if (version_id >= 9) {
1530         n->mac_table.multi_overflow = qemu_get_byte(f);
1531         n->mac_table.uni_overflow = qemu_get_byte(f);
1532     }
1533
1534     if (version_id >= 10) {
1535         n->alluni = qemu_get_byte(f);
1536         n->nomulti = qemu_get_byte(f);
1537         n->nouni = qemu_get_byte(f);
1538         n->nobcast = qemu_get_byte(f);
1539     }
1540
1541     if (version_id >= 11) {
1542         if (qemu_get_byte(f) && !peer_has_ufo(n)) {
1543             error_report("virtio-net: saved image requires TUN_F_UFO support");
1544             return -1;
1545         }
1546     }
1547
1548     if (n->max_queues > 1) {
1549         if (n->max_queues != qemu_get_be16(f)) {
1550             error_report("virtio-net: different max_queues ");
1551             return -1;
1552         }
1553
1554         n->curr_queues = qemu_get_be16(f);
1555         if (n->curr_queues > n->max_queues) {
1556             error_report("virtio-net: curr_queues %x > max_queues %x",
1557                          n->curr_queues, n->max_queues);
1558             return -1;
1559         }
1560         for (i = 1; i < n->curr_queues; i++) {
1561             n->vqs[i].tx_waiting = qemu_get_be32(f);
1562         }
1563     }
1564
1565     if (virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
1566         n->curr_guest_offloads = qemu_get_be64(f);
1567     } else {
1568         n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
1569     }
1570
1571     if (peer_has_vnet_hdr(n)) {
1572         virtio_net_apply_guest_offloads(n);
1573     }
1574
1575     virtio_net_set_queues(n);
1576
1577     /* Find the first multicast entry in the saved MAC filter */
1578     for (i = 0; i < n->mac_table.in_use; i++) {
1579         if (n->mac_table.macs[i * ETH_ALEN] & 1) {
1580             break;
1581         }
1582     }
1583     n->mac_table.first_multi = i;
1584
1585     /* nc.link_down can't be migrated, so infer link_down according
1586      * to link status bit in n->status */
1587     link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
1588     for (i = 0; i < n->max_queues; i++) {
1589         qemu_get_subqueue(n->nic, i)->link_down = link_down;
1590     }
1591
1592     if (virtio_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
1593         virtio_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
1594         n->announce_counter = SELF_ANNOUNCE_ROUNDS;
1595         timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));
1596     }
1597
1598     return 0;
1599 }
1600
1601 static NetClientInfo net_virtio_info = {
1602     .type = NET_CLIENT_OPTIONS_KIND_NIC,
1603     .size = sizeof(NICState),
1604     .can_receive = virtio_net_can_receive,
1605     .receive = virtio_net_receive,
1606     .link_status_changed = virtio_net_set_link_status,
1607     .query_rx_filter = virtio_net_query_rxfilter,
1608 };
1609
1610 static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
1611 {
1612     VirtIONet *n = VIRTIO_NET(vdev);
1613     NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
1614     assert(n->vhost_started);
1615     return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
1616 }
1617
1618 static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
1619                                            bool mask)
1620 {
1621     VirtIONet *n = VIRTIO_NET(vdev);
1622     NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
1623     assert(n->vhost_started);
1624     vhost_net_virtqueue_mask(get_vhost_net(nc->peer),
1625                              vdev, idx, mask);
1626 }
1627
1628 static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
1629 {
1630     int i, config_size = 0;
1631     virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
1632     for (i = 0; feature_sizes[i].flags != 0; i++) {
1633         if (host_features & feature_sizes[i].flags) {
1634             config_size = MAX(feature_sizes[i].end, config_size);
1635         }
1636     }
1637     n->config_size = config_size;
1638 }
1639
1640 void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
1641                                    const char *type)
1642 {
1643     /*
1644      * The name can be NULL, the netclient name will be type.x.
1645      */
1646     assert(type != NULL);
1647
1648     g_free(n->netclient_name);
1649     g_free(n->netclient_type);
1650     n->netclient_name = g_strdup(name);
1651     n->netclient_type = g_strdup(type);
1652 }
1653
1654 static void virtio_net_device_realize(DeviceState *dev, Error **errp)
1655 {
1656     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1657     VirtIONet *n = VIRTIO_NET(dev);
1658     NetClientState *nc;
1659     int i;
1660
1661     virtio_net_set_config_size(n, n->host_features);
1662     virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
1663
1664     n->max_queues = MAX(n->nic_conf.peers.queues, 1);
1665     if (n->max_queues * 2 + 1 > VIRTIO_QUEUE_MAX) {
1666         error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
1667                    "must be a positive integer less than %d.",
1668                    n->max_queues, (VIRTIO_QUEUE_MAX - 1) / 2);
1669         virtio_cleanup(vdev);
1670         return;
1671     }
1672     n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
1673     n->curr_queues = 1;
1674     n->tx_timeout = n->net_conf.txtimer;
1675
1676     if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
1677                        && strcmp(n->net_conf.tx, "bh")) {
1678         error_report("virtio-net: "
1679                      "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
1680                      n->net_conf.tx);
1681         error_report("Defaulting to \"bh\"");
1682     }
1683
1684     for (i = 0; i < n->max_queues; i++) {
1685         virtio_net_add_queue(n, i);
1686     }
1687
1688     n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
1689     qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
1690     memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
1691     n->status = VIRTIO_NET_S_LINK_UP;
1692     n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
1693                                      virtio_net_announce_timer, n);
1694
1695     if (n->netclient_type) {
1696         /*
1697          * Happen when virtio_net_set_netclient_name has been called.
1698          */
1699         n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
1700                               n->netclient_type, n->netclient_name, n);
1701     } else {
1702         n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
1703                               object_get_typename(OBJECT(dev)), dev->id, n);
1704     }
1705
1706     peer_test_vnet_hdr(n);
1707     if (peer_has_vnet_hdr(n)) {
1708         for (i = 0; i < n->max_queues; i++) {
1709             qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
1710         }
1711         n->host_hdr_len = sizeof(struct virtio_net_hdr);
1712     } else {
1713         n->host_hdr_len = 0;
1714     }
1715
1716     qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
1717
1718     n->vqs[0].tx_waiting = 0;
1719     n->tx_burst = n->net_conf.txburst;
1720     virtio_net_set_mrg_rx_bufs(n, 0, 0);
1721     n->promisc = 1; /* for compatibility */
1722
1723     n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
1724
1725     n->vlans = g_malloc0(MAX_VLAN >> 3);
1726
1727     nc = qemu_get_queue(n->nic);
1728     nc->rxfilter_notify_enabled = 1;
1729
1730     n->qdev = dev;
1731     register_savevm(dev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
1732                     virtio_net_save, virtio_net_load, n);
1733 }
1734
1735 static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
1736 {
1737     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1738     VirtIONet *n = VIRTIO_NET(dev);
1739     int i, max_queues;
1740
1741     /* This will stop vhost backend if appropriate. */
1742     virtio_net_set_status(vdev, 0);
1743
1744     unregister_savevm(dev, "virtio-net", n);
1745
1746     g_free(n->netclient_name);
1747     n->netclient_name = NULL;
1748     g_free(n->netclient_type);
1749     n->netclient_type = NULL;
1750
1751     g_free(n->mac_table.macs);
1752     g_free(n->vlans);
1753
1754     max_queues = n->multiqueue ? n->max_queues : 1;
1755     for (i = 0; i < max_queues; i++) {
1756         virtio_net_del_queue(n, i);
1757     }
1758
1759     timer_del(n->announce_timer);
1760     timer_free(n->announce_timer);
1761     g_free(n->vqs);
1762     qemu_del_nic(n->nic);
1763     virtio_cleanup(vdev);
1764 }
1765
1766 static void virtio_net_instance_init(Object *obj)
1767 {
1768     VirtIONet *n = VIRTIO_NET(obj);
1769
1770     /*
1771      * The default config_size is sizeof(struct virtio_net_config).
1772      * Can be overriden with virtio_net_set_config_size.
1773      */
1774     n->config_size = sizeof(struct virtio_net_config);
1775     device_add_bootindex_property(obj, &n->nic_conf.bootindex,
1776                                   "bootindex", "/ethernet-phy@0",
1777                                   DEVICE(n), NULL);
1778 }
1779
1780 static Property virtio_net_properties[] = {
1781     DEFINE_PROP_BIT("csum", VirtIONet, host_features, VIRTIO_NET_F_CSUM, true),
1782     DEFINE_PROP_BIT("guest_csum", VirtIONet, host_features,
1783                     VIRTIO_NET_F_GUEST_CSUM, true),
1784     DEFINE_PROP_BIT("gso", VirtIONet, host_features, VIRTIO_NET_F_GSO, true),
1785     DEFINE_PROP_BIT("guest_tso4", VirtIONet, host_features,
1786                     VIRTIO_NET_F_GUEST_TSO4, true),
1787     DEFINE_PROP_BIT("guest_tso6", VirtIONet, host_features,
1788                     VIRTIO_NET_F_GUEST_TSO6, true),
1789     DEFINE_PROP_BIT("guest_ecn", VirtIONet, host_features,
1790                     VIRTIO_NET_F_GUEST_ECN, true),
1791     DEFINE_PROP_BIT("guest_ufo", VirtIONet, host_features,
1792                     VIRTIO_NET_F_GUEST_UFO, true),
1793     DEFINE_PROP_BIT("guest_announce", VirtIONet, host_features,
1794                     VIRTIO_NET_F_GUEST_ANNOUNCE, true),
1795     DEFINE_PROP_BIT("host_tso4", VirtIONet, host_features,
1796                     VIRTIO_NET_F_HOST_TSO4, true),
1797     DEFINE_PROP_BIT("host_tso6", VirtIONet, host_features,
1798                     VIRTIO_NET_F_HOST_TSO6, true),
1799     DEFINE_PROP_BIT("host_ecn", VirtIONet, host_features,
1800                     VIRTIO_NET_F_HOST_ECN, true),
1801     DEFINE_PROP_BIT("host_ufo", VirtIONet, host_features,
1802                     VIRTIO_NET_F_HOST_UFO, true),
1803     DEFINE_PROP_BIT("mrg_rxbuf", VirtIONet, host_features,
1804                     VIRTIO_NET_F_MRG_RXBUF, true),
1805     DEFINE_PROP_BIT("status", VirtIONet, host_features,
1806                     VIRTIO_NET_F_STATUS, true),
1807     DEFINE_PROP_BIT("ctrl_vq", VirtIONet, host_features,
1808                     VIRTIO_NET_F_CTRL_VQ, true),
1809     DEFINE_PROP_BIT("ctrl_rx", VirtIONet, host_features,
1810                     VIRTIO_NET_F_CTRL_RX, true),
1811     DEFINE_PROP_BIT("ctrl_vlan", VirtIONet, host_features,
1812                     VIRTIO_NET_F_CTRL_VLAN, true),
1813     DEFINE_PROP_BIT("ctrl_rx_extra", VirtIONet, host_features,
1814                     VIRTIO_NET_F_CTRL_RX_EXTRA, true),
1815     DEFINE_PROP_BIT("ctrl_mac_addr", VirtIONet, host_features,
1816                     VIRTIO_NET_F_CTRL_MAC_ADDR, true),
1817     DEFINE_PROP_BIT("ctrl_guest_offloads", VirtIONet, host_features,
1818                     VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, true),
1819     DEFINE_PROP_BIT("mq", VirtIONet, host_features, VIRTIO_NET_F_MQ, false),
1820     DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
1821     DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
1822                        TX_TIMER_INTERVAL),
1823     DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
1824     DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
1825     DEFINE_PROP_END_OF_LIST(),
1826 };
1827
1828 static void virtio_net_class_init(ObjectClass *klass, void *data)
1829 {
1830     DeviceClass *dc = DEVICE_CLASS(klass);
1831     VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
1832
1833     dc->props = virtio_net_properties;
1834     set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
1835     vdc->realize = virtio_net_device_realize;
1836     vdc->unrealize = virtio_net_device_unrealize;
1837     vdc->get_config = virtio_net_get_config;
1838     vdc->set_config = virtio_net_set_config;
1839     vdc->get_features = virtio_net_get_features;
1840     vdc->set_features = virtio_net_set_features;
1841     vdc->bad_features = virtio_net_bad_features;
1842     vdc->reset = virtio_net_reset;
1843     vdc->set_status = virtio_net_set_status;
1844     vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
1845     vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
1846     vdc->load = virtio_net_load_device;
1847     vdc->save = virtio_net_save_device;
1848 }
1849
1850 static const TypeInfo virtio_net_info = {
1851     .name = TYPE_VIRTIO_NET,
1852     .parent = TYPE_VIRTIO_DEVICE,
1853     .instance_size = sizeof(VirtIONet),
1854     .instance_init = virtio_net_instance_init,
1855     .class_init = virtio_net_class_init,
1856 };
1857
1858 static void virtio_register_types(void)
1859 {
1860     type_register_static(&virtio_net_info);
1861 }
1862
1863 type_init(virtio_register_types)