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