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