2 * Virtio Network Device
4 * Copyright IBM, Corp. 2007
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
15 #include "hw/virtio/virtio.h"
17 #include "net/checksum.h"
19 #include "qemu/error-report.h"
20 #include "qemu/timer.h"
21 #include "hw/virtio/virtio-net.h"
22 #include "net/vhost_net.h"
23 #include "hw/virtio/virtio-bus.h"
24 #include "qapi/qmp/qjson.h"
25 #include "qapi-event.h"
26 #include "hw/virtio/virtio-access.h"
28 #define VIRTIO_NET_VM_VERSION 11
30 #define MAC_TABLE_ENTRIES 64
31 #define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
34 * Calculate the number of bytes up to and including the given 'field' of
37 #define endof(container, field) \
38 (offsetof(container, field) + sizeof(((container *)0)->field))
40 typedef struct VirtIOFeature
{
45 static VirtIOFeature feature_sizes
[] = {
46 {.flags
= 1 << VIRTIO_NET_F_MAC
,
47 .end
= endof(struct virtio_net_config
, mac
)},
48 {.flags
= 1 << VIRTIO_NET_F_STATUS
,
49 .end
= endof(struct virtio_net_config
, status
)},
50 {.flags
= 1 << VIRTIO_NET_F_MQ
,
51 .end
= endof(struct virtio_net_config
, max_virtqueue_pairs
)},
55 static VirtIONetQueue
*virtio_net_get_subqueue(NetClientState
*nc
)
57 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
59 return &n
->vqs
[nc
->queue_index
];
62 static int vq2q(int queue_index
)
64 return queue_index
/ 2;
68 * - we could suppress RX interrupt if we were so inclined.
71 static void virtio_net_get_config(VirtIODevice
*vdev
, uint8_t *config
)
73 VirtIONet
*n
= VIRTIO_NET(vdev
);
74 struct virtio_net_config netcfg
;
76 virtio_stw_p(vdev
, &netcfg
.status
, n
->status
);
77 virtio_stw_p(vdev
, &netcfg
.max_virtqueue_pairs
, n
->max_queues
);
78 memcpy(netcfg
.mac
, n
->mac
, ETH_ALEN
);
79 memcpy(config
, &netcfg
, n
->config_size
);
82 static void virtio_net_set_config(VirtIODevice
*vdev
, const uint8_t *config
)
84 VirtIONet
*n
= VIRTIO_NET(vdev
);
85 struct virtio_net_config netcfg
= {};
87 memcpy(&netcfg
, config
, n
->config_size
);
89 if (!virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_MAC_ADDR
) &&
90 memcmp(netcfg
.mac
, n
->mac
, ETH_ALEN
)) {
91 memcpy(n
->mac
, netcfg
.mac
, ETH_ALEN
);
92 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
96 static bool virtio_net_started(VirtIONet
*n
, uint8_t status
)
98 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
99 return (status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
100 (n
->status
& VIRTIO_NET_S_LINK_UP
) && vdev
->vm_running
;
103 static void virtio_net_announce_timer(void *opaque
)
105 VirtIONet
*n
= opaque
;
106 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
108 n
->announce_counter
--;
109 n
->status
|= VIRTIO_NET_S_ANNOUNCE
;
110 virtio_notify_config(vdev
);
113 static void virtio_net_vhost_status(VirtIONet
*n
, uint8_t status
)
115 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
116 NetClientState
*nc
= qemu_get_queue(n
->nic
);
117 int queues
= n
->multiqueue
? n
->max_queues
: 1;
119 if (!get_vhost_net(nc
->peer
)) {
123 if ((virtio_net_started(n
, status
) && !nc
->peer
->link_down
) ==
124 !!n
->vhost_started
) {
127 if (!n
->vhost_started
) {
130 if (!vhost_net_query(get_vhost_net(nc
->peer
), vdev
)) {
134 /* Any packets outstanding? Purge them to avoid touching rings
135 * when vhost is running.
137 for (i
= 0; i
< queues
; i
++) {
138 NetClientState
*qnc
= qemu_get_subqueue(n
->nic
, i
);
140 /* Purge both directions: TX and RX. */
141 qemu_net_queue_purge(qnc
->peer
->incoming_queue
, qnc
);
142 qemu_net_queue_purge(qnc
->incoming_queue
, qnc
->peer
);
145 n
->vhost_started
= 1;
146 r
= vhost_net_start(vdev
, n
->nic
->ncs
, queues
);
148 error_report("unable to start vhost net: %d: "
149 "falling back on userspace virtio", -r
);
150 n
->vhost_started
= 0;
153 vhost_net_stop(vdev
, n
->nic
->ncs
, queues
);
154 n
->vhost_started
= 0;
158 static void virtio_net_set_status(struct VirtIODevice
*vdev
, uint8_t status
)
160 VirtIONet
*n
= VIRTIO_NET(vdev
);
163 uint8_t queue_status
;
165 virtio_net_vhost_status(n
, status
);
167 for (i
= 0; i
< n
->max_queues
; i
++) {
170 if ((!n
->multiqueue
&& i
!= 0) || i
>= n
->curr_queues
) {
173 queue_status
= status
;
176 if (!q
->tx_waiting
) {
180 if (virtio_net_started(n
, queue_status
) && !n
->vhost_started
) {
182 timer_mod(q
->tx_timer
,
183 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
185 qemu_bh_schedule(q
->tx_bh
);
189 timer_del(q
->tx_timer
);
191 qemu_bh_cancel(q
->tx_bh
);
197 static void virtio_net_set_link_status(NetClientState
*nc
)
199 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
200 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
201 uint16_t old_status
= n
->status
;
204 n
->status
&= ~VIRTIO_NET_S_LINK_UP
;
206 n
->status
|= VIRTIO_NET_S_LINK_UP
;
208 if (n
->status
!= old_status
)
209 virtio_notify_config(vdev
);
211 virtio_net_set_status(vdev
, vdev
->status
);
214 static void rxfilter_notify(NetClientState
*nc
)
216 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
218 if (nc
->rxfilter_notify_enabled
) {
219 gchar
*path
= object_get_canonical_path(OBJECT(n
->qdev
));
220 qapi_event_send_nic_rx_filter_changed(!!n
->netclient_name
,
221 n
->netclient_name
, path
, &error_abort
);
224 /* disable event notification to avoid events flooding */
225 nc
->rxfilter_notify_enabled
= 0;
229 static char *mac_strdup_printf(const uint8_t *mac
)
231 return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac
[0],
232 mac
[1], mac
[2], mac
[3], mac
[4], mac
[5]);
235 static intList
*get_vlan_table(VirtIONet
*n
)
237 intList
*list
, *entry
;
241 for (i
= 0; i
< MAX_VLAN
>> 5; i
++) {
242 for (j
= 0; n
->vlans
[i
] && j
<= 0x1f; j
++) {
243 if (n
->vlans
[i
] & (1U << j
)) {
244 entry
= g_malloc0(sizeof(*entry
));
245 entry
->value
= (i
<< 5) + j
;
255 static RxFilterInfo
*virtio_net_query_rxfilter(NetClientState
*nc
)
257 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
258 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
260 strList
*str_list
, *entry
;
263 info
= g_malloc0(sizeof(*info
));
264 info
->name
= g_strdup(nc
->name
);
265 info
->promiscuous
= n
->promisc
;
268 info
->unicast
= RX_STATE_NONE
;
269 } else if (n
->alluni
) {
270 info
->unicast
= RX_STATE_ALL
;
272 info
->unicast
= RX_STATE_NORMAL
;
276 info
->multicast
= RX_STATE_NONE
;
277 } else if (n
->allmulti
) {
278 info
->multicast
= RX_STATE_ALL
;
280 info
->multicast
= RX_STATE_NORMAL
;
283 info
->broadcast_allowed
= n
->nobcast
;
284 info
->multicast_overflow
= n
->mac_table
.multi_overflow
;
285 info
->unicast_overflow
= n
->mac_table
.uni_overflow
;
287 info
->main_mac
= mac_strdup_printf(n
->mac
);
290 for (i
= 0; i
< n
->mac_table
.first_multi
; i
++) {
291 entry
= g_malloc0(sizeof(*entry
));
292 entry
->value
= mac_strdup_printf(n
->mac_table
.macs
+ i
* ETH_ALEN
);
293 entry
->next
= str_list
;
296 info
->unicast_table
= str_list
;
299 for (i
= n
->mac_table
.first_multi
; i
< n
->mac_table
.in_use
; i
++) {
300 entry
= g_malloc0(sizeof(*entry
));
301 entry
->value
= mac_strdup_printf(n
->mac_table
.macs
+ i
* ETH_ALEN
);
302 entry
->next
= str_list
;
305 info
->multicast_table
= str_list
;
306 info
->vlan_table
= get_vlan_table(n
);
308 if (!virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_VLAN
)) {
309 info
->vlan
= RX_STATE_ALL
;
310 } else if (!info
->vlan_table
) {
311 info
->vlan
= RX_STATE_NONE
;
313 info
->vlan
= RX_STATE_NORMAL
;
316 /* enable event notification after query */
317 nc
->rxfilter_notify_enabled
= 1;
322 static void virtio_net_reset(VirtIODevice
*vdev
)
324 VirtIONet
*n
= VIRTIO_NET(vdev
);
326 /* Reset back to compatibility mode */
333 /* multiqueue is disabled by default */
335 timer_del(n
->announce_timer
);
336 n
->announce_counter
= 0;
337 n
->status
&= ~VIRTIO_NET_S_ANNOUNCE
;
339 /* Flush any MAC and VLAN filter table state */
340 n
->mac_table
.in_use
= 0;
341 n
->mac_table
.first_multi
= 0;
342 n
->mac_table
.multi_overflow
= 0;
343 n
->mac_table
.uni_overflow
= 0;
344 memset(n
->mac_table
.macs
, 0, MAC_TABLE_ENTRIES
* ETH_ALEN
);
345 memcpy(&n
->mac
[0], &n
->nic
->conf
->macaddr
, sizeof(n
->mac
));
346 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
347 memset(n
->vlans
, 0, MAX_VLAN
>> 3);
350 static void peer_test_vnet_hdr(VirtIONet
*n
)
352 NetClientState
*nc
= qemu_get_queue(n
->nic
);
357 n
->has_vnet_hdr
= qemu_has_vnet_hdr(nc
->peer
);
360 static int peer_has_vnet_hdr(VirtIONet
*n
)
362 return n
->has_vnet_hdr
;
365 static int peer_has_ufo(VirtIONet
*n
)
367 if (!peer_has_vnet_hdr(n
))
370 n
->has_ufo
= qemu_has_ufo(qemu_get_queue(n
->nic
)->peer
);
375 static void virtio_net_set_mrg_rx_bufs(VirtIONet
*n
, int mergeable_rx_bufs
)
380 n
->mergeable_rx_bufs
= mergeable_rx_bufs
;
382 n
->guest_hdr_len
= n
->mergeable_rx_bufs
?
383 sizeof(struct virtio_net_hdr_mrg_rxbuf
) : sizeof(struct virtio_net_hdr
);
385 for (i
= 0; i
< n
->max_queues
; i
++) {
386 nc
= qemu_get_subqueue(n
->nic
, i
);
388 if (peer_has_vnet_hdr(n
) &&
389 qemu_has_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
)) {
390 qemu_set_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
);
391 n
->host_hdr_len
= n
->guest_hdr_len
;
396 static int peer_attach(VirtIONet
*n
, int index
)
398 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
404 if (nc
->peer
->info
->type
!= NET_CLIENT_OPTIONS_KIND_TAP
) {
408 return tap_enable(nc
->peer
);
411 static int peer_detach(VirtIONet
*n
, int index
)
413 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
419 if (nc
->peer
->info
->type
!= NET_CLIENT_OPTIONS_KIND_TAP
) {
423 return tap_disable(nc
->peer
);
426 static void virtio_net_set_queues(VirtIONet
*n
)
431 for (i
= 0; i
< n
->max_queues
; i
++) {
432 if (i
< n
->curr_queues
) {
433 r
= peer_attach(n
, i
);
436 r
= peer_detach(n
, i
);
442 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
);
444 static uint32_t virtio_net_get_features(VirtIODevice
*vdev
, uint32_t features
)
446 VirtIONet
*n
= VIRTIO_NET(vdev
);
447 NetClientState
*nc
= qemu_get_queue(n
->nic
);
449 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
451 if (!peer_has_vnet_hdr(n
)) {
452 virtio_clear_feature(&features
, VIRTIO_NET_F_CSUM
);
453 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
454 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
455 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
457 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_CSUM
);
458 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO4
);
459 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO6
);
460 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_ECN
);
463 if (!peer_has_vnet_hdr(n
) || !peer_has_ufo(n
)) {
464 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_UFO
);
465 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_UFO
);
468 if (!get_vhost_net(nc
->peer
)) {
471 return vhost_net_get_features(get_vhost_net(nc
->peer
), features
);
474 static uint32_t virtio_net_bad_features(VirtIODevice
*vdev
)
476 uint32_t features
= 0;
478 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
480 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
481 virtio_add_feature(&features
, VIRTIO_NET_F_CSUM
);
482 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
483 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
484 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
489 static void virtio_net_apply_guest_offloads(VirtIONet
*n
)
491 qemu_set_offload(qemu_get_queue(n
->nic
)->peer
,
492 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_CSUM
)),
493 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO4
)),
494 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO6
)),
495 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_ECN
)),
496 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_UFO
)));
499 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features
)
501 static const uint64_t guest_offloads_mask
=
502 (1ULL << VIRTIO_NET_F_GUEST_CSUM
) |
503 (1ULL << VIRTIO_NET_F_GUEST_TSO4
) |
504 (1ULL << VIRTIO_NET_F_GUEST_TSO6
) |
505 (1ULL << VIRTIO_NET_F_GUEST_ECN
) |
506 (1ULL << VIRTIO_NET_F_GUEST_UFO
);
508 return guest_offloads_mask
& features
;
511 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet
*n
)
513 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
514 return virtio_net_guest_offloads_by_features(vdev
->guest_features
);
517 static void virtio_net_set_features(VirtIODevice
*vdev
, uint32_t features
)
519 VirtIONet
*n
= VIRTIO_NET(vdev
);
522 virtio_net_set_multiqueue(n
,
523 __virtio_has_feature(features
, VIRTIO_NET_F_MQ
));
525 virtio_net_set_mrg_rx_bufs(n
,
526 __virtio_has_feature(features
,
527 VIRTIO_NET_F_MRG_RXBUF
));
529 if (n
->has_vnet_hdr
) {
530 n
->curr_guest_offloads
=
531 virtio_net_guest_offloads_by_features(features
);
532 virtio_net_apply_guest_offloads(n
);
535 for (i
= 0; i
< n
->max_queues
; i
++) {
536 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, i
);
538 if (!get_vhost_net(nc
->peer
)) {
541 vhost_net_ack_features(get_vhost_net(nc
->peer
), features
);
544 if (__virtio_has_feature(features
, VIRTIO_NET_F_CTRL_VLAN
)) {
545 memset(n
->vlans
, 0, MAX_VLAN
>> 3);
547 memset(n
->vlans
, 0xff, MAX_VLAN
>> 3);
551 static int virtio_net_handle_rx_mode(VirtIONet
*n
, uint8_t cmd
,
552 struct iovec
*iov
, unsigned int iov_cnt
)
556 NetClientState
*nc
= qemu_get_queue(n
->nic
);
558 s
= iov_to_buf(iov
, iov_cnt
, 0, &on
, sizeof(on
));
559 if (s
!= sizeof(on
)) {
560 return VIRTIO_NET_ERR
;
563 if (cmd
== VIRTIO_NET_CTRL_RX_PROMISC
) {
565 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLMULTI
) {
567 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLUNI
) {
569 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOMULTI
) {
571 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOUNI
) {
573 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOBCAST
) {
576 return VIRTIO_NET_ERR
;
581 return VIRTIO_NET_OK
;
584 static int virtio_net_handle_offloads(VirtIONet
*n
, uint8_t cmd
,
585 struct iovec
*iov
, unsigned int iov_cnt
)
587 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
591 if (!virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
592 return VIRTIO_NET_ERR
;
595 s
= iov_to_buf(iov
, iov_cnt
, 0, &offloads
, sizeof(offloads
));
596 if (s
!= sizeof(offloads
)) {
597 return VIRTIO_NET_ERR
;
600 if (cmd
== VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET
) {
601 uint64_t supported_offloads
;
603 if (!n
->has_vnet_hdr
) {
604 return VIRTIO_NET_ERR
;
607 supported_offloads
= virtio_net_supported_guest_offloads(n
);
608 if (offloads
& ~supported_offloads
) {
609 return VIRTIO_NET_ERR
;
612 n
->curr_guest_offloads
= offloads
;
613 virtio_net_apply_guest_offloads(n
);
615 return VIRTIO_NET_OK
;
617 return VIRTIO_NET_ERR
;
621 static int virtio_net_handle_mac(VirtIONet
*n
, uint8_t cmd
,
622 struct iovec
*iov
, unsigned int iov_cnt
)
624 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
625 struct virtio_net_ctrl_mac mac_data
;
627 NetClientState
*nc
= qemu_get_queue(n
->nic
);
629 if (cmd
== VIRTIO_NET_CTRL_MAC_ADDR_SET
) {
630 if (iov_size(iov
, iov_cnt
) != sizeof(n
->mac
)) {
631 return VIRTIO_NET_ERR
;
633 s
= iov_to_buf(iov
, iov_cnt
, 0, &n
->mac
, sizeof(n
->mac
));
634 assert(s
== sizeof(n
->mac
));
635 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
638 return VIRTIO_NET_OK
;
641 if (cmd
!= VIRTIO_NET_CTRL_MAC_TABLE_SET
) {
642 return VIRTIO_NET_ERR
;
647 uint8_t uni_overflow
= 0;
648 uint8_t multi_overflow
= 0;
649 uint8_t *macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
651 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
652 sizeof(mac_data
.entries
));
653 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
654 if (s
!= sizeof(mac_data
.entries
)) {
657 iov_discard_front(&iov
, &iov_cnt
, s
);
659 if (mac_data
.entries
* ETH_ALEN
> iov_size(iov
, iov_cnt
)) {
663 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
) {
664 s
= iov_to_buf(iov
, iov_cnt
, 0, macs
,
665 mac_data
.entries
* ETH_ALEN
);
666 if (s
!= mac_data
.entries
* ETH_ALEN
) {
669 in_use
+= mac_data
.entries
;
674 iov_discard_front(&iov
, &iov_cnt
, mac_data
.entries
* ETH_ALEN
);
676 first_multi
= in_use
;
678 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
679 sizeof(mac_data
.entries
));
680 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
681 if (s
!= sizeof(mac_data
.entries
)) {
685 iov_discard_front(&iov
, &iov_cnt
, s
);
687 if (mac_data
.entries
* ETH_ALEN
!= iov_size(iov
, iov_cnt
)) {
691 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
- in_use
) {
692 s
= iov_to_buf(iov
, iov_cnt
, 0, &macs
[in_use
* ETH_ALEN
],
693 mac_data
.entries
* ETH_ALEN
);
694 if (s
!= mac_data
.entries
* ETH_ALEN
) {
697 in_use
+= mac_data
.entries
;
702 n
->mac_table
.in_use
= in_use
;
703 n
->mac_table
.first_multi
= first_multi
;
704 n
->mac_table
.uni_overflow
= uni_overflow
;
705 n
->mac_table
.multi_overflow
= multi_overflow
;
706 memcpy(n
->mac_table
.macs
, macs
, MAC_TABLE_ENTRIES
* ETH_ALEN
);
710 return VIRTIO_NET_OK
;
714 return VIRTIO_NET_ERR
;
717 static int virtio_net_handle_vlan_table(VirtIONet
*n
, uint8_t cmd
,
718 struct iovec
*iov
, unsigned int iov_cnt
)
720 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
723 NetClientState
*nc
= qemu_get_queue(n
->nic
);
725 s
= iov_to_buf(iov
, iov_cnt
, 0, &vid
, sizeof(vid
));
726 vid
= virtio_lduw_p(vdev
, &vid
);
727 if (s
!= sizeof(vid
)) {
728 return VIRTIO_NET_ERR
;
732 return VIRTIO_NET_ERR
;
734 if (cmd
== VIRTIO_NET_CTRL_VLAN_ADD
)
735 n
->vlans
[vid
>> 5] |= (1U << (vid
& 0x1f));
736 else if (cmd
== VIRTIO_NET_CTRL_VLAN_DEL
)
737 n
->vlans
[vid
>> 5] &= ~(1U << (vid
& 0x1f));
739 return VIRTIO_NET_ERR
;
743 return VIRTIO_NET_OK
;
746 static int virtio_net_handle_announce(VirtIONet
*n
, uint8_t cmd
,
747 struct iovec
*iov
, unsigned int iov_cnt
)
749 if (cmd
== VIRTIO_NET_CTRL_ANNOUNCE_ACK
&&
750 n
->status
& VIRTIO_NET_S_ANNOUNCE
) {
751 n
->status
&= ~VIRTIO_NET_S_ANNOUNCE
;
752 if (n
->announce_counter
) {
753 timer_mod(n
->announce_timer
,
754 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
755 self_announce_delay(n
->announce_counter
));
757 return VIRTIO_NET_OK
;
759 return VIRTIO_NET_ERR
;
763 static int virtio_net_handle_mq(VirtIONet
*n
, uint8_t cmd
,
764 struct iovec
*iov
, unsigned int iov_cnt
)
766 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
767 struct virtio_net_ctrl_mq mq
;
771 s
= iov_to_buf(iov
, iov_cnt
, 0, &mq
, sizeof(mq
));
772 if (s
!= sizeof(mq
)) {
773 return VIRTIO_NET_ERR
;
776 if (cmd
!= VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET
) {
777 return VIRTIO_NET_ERR
;
780 queues
= virtio_lduw_p(vdev
, &mq
.virtqueue_pairs
);
782 if (queues
< VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN
||
783 queues
> VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX
||
784 queues
> n
->max_queues
||
786 return VIRTIO_NET_ERR
;
789 n
->curr_queues
= queues
;
790 /* stop the backend before changing the number of queues to avoid handling a
792 virtio_net_set_status(vdev
, vdev
->status
);
793 virtio_net_set_queues(n
);
795 return VIRTIO_NET_OK
;
797 static void virtio_net_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
799 VirtIONet
*n
= VIRTIO_NET(vdev
);
800 struct virtio_net_ctrl_hdr ctrl
;
801 virtio_net_ctrl_ack status
= VIRTIO_NET_ERR
;
802 VirtQueueElement elem
;
804 struct iovec
*iov
, *iov2
;
805 unsigned int iov_cnt
;
807 while (virtqueue_pop(vq
, &elem
)) {
808 if (iov_size(elem
.in_sg
, elem
.in_num
) < sizeof(status
) ||
809 iov_size(elem
.out_sg
, elem
.out_num
) < sizeof(ctrl
)) {
810 error_report("virtio-net ctrl missing headers");
814 iov_cnt
= elem
.out_num
;
815 iov2
= iov
= g_memdup(elem
.out_sg
, sizeof(struct iovec
) * elem
.out_num
);
816 s
= iov_to_buf(iov
, iov_cnt
, 0, &ctrl
, sizeof(ctrl
));
817 iov_discard_front(&iov
, &iov_cnt
, sizeof(ctrl
));
818 if (s
!= sizeof(ctrl
)) {
819 status
= VIRTIO_NET_ERR
;
820 } else if (ctrl
.class == VIRTIO_NET_CTRL_RX
) {
821 status
= virtio_net_handle_rx_mode(n
, ctrl
.cmd
, iov
, iov_cnt
);
822 } else if (ctrl
.class == VIRTIO_NET_CTRL_MAC
) {
823 status
= virtio_net_handle_mac(n
, ctrl
.cmd
, iov
, iov_cnt
);
824 } else if (ctrl
.class == VIRTIO_NET_CTRL_VLAN
) {
825 status
= virtio_net_handle_vlan_table(n
, ctrl
.cmd
, iov
, iov_cnt
);
826 } else if (ctrl
.class == VIRTIO_NET_CTRL_ANNOUNCE
) {
827 status
= virtio_net_handle_announce(n
, ctrl
.cmd
, iov
, iov_cnt
);
828 } else if (ctrl
.class == VIRTIO_NET_CTRL_MQ
) {
829 status
= virtio_net_handle_mq(n
, ctrl
.cmd
, iov
, iov_cnt
);
830 } else if (ctrl
.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS
) {
831 status
= virtio_net_handle_offloads(n
, ctrl
.cmd
, iov
, iov_cnt
);
834 s
= iov_from_buf(elem
.in_sg
, elem
.in_num
, 0, &status
, sizeof(status
));
835 assert(s
== sizeof(status
));
837 virtqueue_push(vq
, &elem
, sizeof(status
));
838 virtio_notify(vdev
, vq
);
845 static void virtio_net_handle_rx(VirtIODevice
*vdev
, VirtQueue
*vq
)
847 VirtIONet
*n
= VIRTIO_NET(vdev
);
848 int queue_index
= vq2q(virtio_get_queue_index(vq
));
850 qemu_flush_queued_packets(qemu_get_subqueue(n
->nic
, queue_index
));
853 static int virtio_net_can_receive(NetClientState
*nc
)
855 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
856 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
857 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
859 if (!vdev
->vm_running
) {
863 if (nc
->queue_index
>= n
->curr_queues
) {
867 if (!virtio_queue_ready(q
->rx_vq
) ||
868 !(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
875 static int virtio_net_has_buffers(VirtIONetQueue
*q
, int bufsize
)
878 if (virtio_queue_empty(q
->rx_vq
) ||
879 (n
->mergeable_rx_bufs
&&
880 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
881 virtio_queue_set_notification(q
->rx_vq
, 1);
883 /* To avoid a race condition where the guest has made some buffers
884 * available after the above check but before notification was
885 * enabled, check for available buffers again.
887 if (virtio_queue_empty(q
->rx_vq
) ||
888 (n
->mergeable_rx_bufs
&&
889 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
894 virtio_queue_set_notification(q
->rx_vq
, 0);
898 static void virtio_net_hdr_swap(VirtIODevice
*vdev
, struct virtio_net_hdr
*hdr
)
900 virtio_tswap16s(vdev
, &hdr
->hdr_len
);
901 virtio_tswap16s(vdev
, &hdr
->gso_size
);
902 virtio_tswap16s(vdev
, &hdr
->csum_start
);
903 virtio_tswap16s(vdev
, &hdr
->csum_offset
);
906 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
907 * it never finds out that the packets don't have valid checksums. This
908 * causes dhclient to get upset. Fedora's carried a patch for ages to
909 * fix this with Xen but it hasn't appeared in an upstream release of
912 * To avoid breaking existing guests, we catch udp packets and add
913 * checksums. This is terrible but it's better than hacking the guest
916 * N.B. if we introduce a zero-copy API, this operation is no longer free so
917 * we should provide a mechanism to disable it to avoid polluting the host
920 static void work_around_broken_dhclient(struct virtio_net_hdr
*hdr
,
921 uint8_t *buf
, size_t size
)
923 if ((hdr
->flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) && /* missing csum */
924 (size
> 27 && size
< 1500) && /* normal sized MTU */
925 (buf
[12] == 0x08 && buf
[13] == 0x00) && /* ethertype == IPv4 */
926 (buf
[23] == 17) && /* ip.protocol == UDP */
927 (buf
[34] == 0 && buf
[35] == 67)) { /* udp.srcport == bootps */
928 net_checksum_calculate(buf
, size
);
929 hdr
->flags
&= ~VIRTIO_NET_HDR_F_NEEDS_CSUM
;
933 static void receive_header(VirtIONet
*n
, const struct iovec
*iov
, int iov_cnt
,
934 const void *buf
, size_t size
)
936 if (n
->has_vnet_hdr
) {
937 /* FIXME this cast is evil */
938 void *wbuf
= (void *)buf
;
939 work_around_broken_dhclient(wbuf
, wbuf
+ n
->host_hdr_len
,
940 size
- n
->host_hdr_len
);
941 virtio_net_hdr_swap(VIRTIO_DEVICE(n
), wbuf
);
942 iov_from_buf(iov
, iov_cnt
, 0, buf
, sizeof(struct virtio_net_hdr
));
944 struct virtio_net_hdr hdr
= {
946 .gso_type
= VIRTIO_NET_HDR_GSO_NONE
948 iov_from_buf(iov
, iov_cnt
, 0, &hdr
, sizeof hdr
);
952 static int receive_filter(VirtIONet
*n
, const uint8_t *buf
, int size
)
954 static const uint8_t bcast
[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
955 static const uint8_t vlan
[] = {0x81, 0x00};
956 uint8_t *ptr
= (uint8_t *)buf
;
962 ptr
+= n
->host_hdr_len
;
964 if (!memcmp(&ptr
[12], vlan
, sizeof(vlan
))) {
965 int vid
= be16_to_cpup((uint16_t *)(ptr
+ 14)) & 0xfff;
966 if (!(n
->vlans
[vid
>> 5] & (1U << (vid
& 0x1f))))
970 if (ptr
[0] & 1) { // multicast
971 if (!memcmp(ptr
, bcast
, sizeof(bcast
))) {
973 } else if (n
->nomulti
) {
975 } else if (n
->allmulti
|| n
->mac_table
.multi_overflow
) {
979 for (i
= n
->mac_table
.first_multi
; i
< n
->mac_table
.in_use
; i
++) {
980 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
987 } else if (n
->alluni
|| n
->mac_table
.uni_overflow
) {
989 } else if (!memcmp(ptr
, n
->mac
, ETH_ALEN
)) {
993 for (i
= 0; i
< n
->mac_table
.first_multi
; i
++) {
994 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
1003 static ssize_t
virtio_net_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
1005 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1006 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1007 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1008 struct iovec mhdr_sg
[VIRTQUEUE_MAX_SIZE
];
1009 struct virtio_net_hdr_mrg_rxbuf mhdr
;
1010 unsigned mhdr_cnt
= 0;
1011 size_t offset
, i
, guest_offset
;
1013 if (!virtio_net_can_receive(nc
)) {
1017 /* hdr_len refers to the header we supply to the guest */
1018 if (!virtio_net_has_buffers(q
, size
+ n
->guest_hdr_len
- n
->host_hdr_len
)) {
1022 if (!receive_filter(n
, buf
, size
))
1027 while (offset
< size
) {
1028 VirtQueueElement elem
;
1030 const struct iovec
*sg
= elem
.in_sg
;
1034 if (virtqueue_pop(q
->rx_vq
, &elem
) == 0) {
1037 error_report("virtio-net unexpected empty queue: "
1038 "i %zd mergeable %d offset %zd, size %zd, "
1039 "guest hdr len %zd, host hdr len %zd guest features 0x%x",
1040 i
, n
->mergeable_rx_bufs
, offset
, size
,
1041 n
->guest_hdr_len
, n
->host_hdr_len
, vdev
->guest_features
);
1045 if (elem
.in_num
< 1) {
1046 error_report("virtio-net receive queue contains no in buffers");
1051 assert(offset
== 0);
1052 if (n
->mergeable_rx_bufs
) {
1053 mhdr_cnt
= iov_copy(mhdr_sg
, ARRAY_SIZE(mhdr_sg
),
1055 offsetof(typeof(mhdr
), num_buffers
),
1056 sizeof(mhdr
.num_buffers
));
1059 receive_header(n
, sg
, elem
.in_num
, buf
, size
);
1060 offset
= n
->host_hdr_len
;
1061 total
+= n
->guest_hdr_len
;
1062 guest_offset
= n
->guest_hdr_len
;
1067 /* copy in packet. ugh */
1068 len
= iov_from_buf(sg
, elem
.in_num
, guest_offset
,
1069 buf
+ offset
, size
- offset
);
1072 /* If buffers can't be merged, at this point we
1073 * must have consumed the complete packet.
1074 * Otherwise, drop it. */
1075 if (!n
->mergeable_rx_bufs
&& offset
< size
) {
1077 error_report("virtio-net truncated non-mergeable packet: "
1078 "i %zd mergeable %d offset %zd, size %zd, "
1079 "guest hdr len %zd, host hdr len %zd",
1080 i
, n
->mergeable_rx_bufs
,
1081 offset
, size
, n
->guest_hdr_len
, n
->host_hdr_len
);
1086 /* signal other side */
1087 virtqueue_fill(q
->rx_vq
, &elem
, total
, i
++);
1091 virtio_stw_p(vdev
, &mhdr
.num_buffers
, i
);
1092 iov_from_buf(mhdr_sg
, mhdr_cnt
,
1094 &mhdr
.num_buffers
, sizeof mhdr
.num_buffers
);
1097 virtqueue_flush(q
->rx_vq
, i
);
1098 virtio_notify(vdev
, q
->rx_vq
);
1103 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
);
1105 static void virtio_net_tx_complete(NetClientState
*nc
, ssize_t len
)
1107 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1108 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1109 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1111 virtqueue_push(q
->tx_vq
, &q
->async_tx
.elem
, 0);
1112 virtio_notify(vdev
, q
->tx_vq
);
1114 q
->async_tx
.elem
.out_num
= q
->async_tx
.len
= 0;
1116 virtio_queue_set_notification(q
->tx_vq
, 1);
1117 virtio_net_flush_tx(q
);
1121 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
)
1123 VirtIONet
*n
= q
->n
;
1124 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1125 VirtQueueElement elem
;
1126 int32_t num_packets
= 0;
1127 int queue_index
= vq2q(virtio_get_queue_index(q
->tx_vq
));
1128 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1132 if (q
->async_tx
.elem
.out_num
) {
1133 virtio_queue_set_notification(q
->tx_vq
, 0);
1137 while (virtqueue_pop(q
->tx_vq
, &elem
)) {
1139 unsigned int out_num
= elem
.out_num
;
1140 struct iovec
*out_sg
= &elem
.out_sg
[0];
1141 struct iovec sg
[VIRTQUEUE_MAX_SIZE
];
1144 error_report("virtio-net header not in first element");
1148 if (n
->has_vnet_hdr
) {
1149 if (out_sg
[0].iov_len
< n
->guest_hdr_len
) {
1150 error_report("virtio-net header incorrect");
1153 virtio_net_hdr_swap(vdev
, (void *) out_sg
[0].iov_base
);
1157 * If host wants to see the guest header as is, we can
1158 * pass it on unchanged. Otherwise, copy just the parts
1159 * that host is interested in.
1161 assert(n
->host_hdr_len
<= n
->guest_hdr_len
);
1162 if (n
->host_hdr_len
!= n
->guest_hdr_len
) {
1163 unsigned sg_num
= iov_copy(sg
, ARRAY_SIZE(sg
),
1165 0, n
->host_hdr_len
);
1166 sg_num
+= iov_copy(sg
+ sg_num
, ARRAY_SIZE(sg
) - sg_num
,
1168 n
->guest_hdr_len
, -1);
1173 len
= n
->guest_hdr_len
;
1175 ret
= qemu_sendv_packet_async(qemu_get_subqueue(n
->nic
, queue_index
),
1176 out_sg
, out_num
, virtio_net_tx_complete
);
1178 virtio_queue_set_notification(q
->tx_vq
, 0);
1179 q
->async_tx
.elem
= elem
;
1180 q
->async_tx
.len
= len
;
1186 virtqueue_push(q
->tx_vq
, &elem
, 0);
1187 virtio_notify(vdev
, q
->tx_vq
);
1189 if (++num_packets
>= n
->tx_burst
) {
1196 static void virtio_net_handle_tx_timer(VirtIODevice
*vdev
, VirtQueue
*vq
)
1198 VirtIONet
*n
= VIRTIO_NET(vdev
);
1199 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1201 /* This happens when device was stopped but VCPU wasn't. */
1202 if (!vdev
->vm_running
) {
1207 if (q
->tx_waiting
) {
1208 virtio_queue_set_notification(vq
, 1);
1209 timer_del(q
->tx_timer
);
1211 virtio_net_flush_tx(q
);
1213 timer_mod(q
->tx_timer
,
1214 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
1216 virtio_queue_set_notification(vq
, 0);
1220 static void virtio_net_handle_tx_bh(VirtIODevice
*vdev
, VirtQueue
*vq
)
1222 VirtIONet
*n
= VIRTIO_NET(vdev
);
1223 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1225 if (unlikely(q
->tx_waiting
)) {
1229 /* This happens when device was stopped but VCPU wasn't. */
1230 if (!vdev
->vm_running
) {
1233 virtio_queue_set_notification(vq
, 0);
1234 qemu_bh_schedule(q
->tx_bh
);
1237 static void virtio_net_tx_timer(void *opaque
)
1239 VirtIONetQueue
*q
= opaque
;
1240 VirtIONet
*n
= q
->n
;
1241 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1242 /* This happens when device was stopped but BH wasn't. */
1243 if (!vdev
->vm_running
) {
1244 /* Make sure tx waiting is set, so we'll run when restarted. */
1245 assert(q
->tx_waiting
);
1251 /* Just in case the driver is not ready on more */
1252 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1256 virtio_queue_set_notification(q
->tx_vq
, 1);
1257 virtio_net_flush_tx(q
);
1260 static void virtio_net_tx_bh(void *opaque
)
1262 VirtIONetQueue
*q
= opaque
;
1263 VirtIONet
*n
= q
->n
;
1264 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1267 /* This happens when device was stopped but BH wasn't. */
1268 if (!vdev
->vm_running
) {
1269 /* Make sure tx waiting is set, so we'll run when restarted. */
1270 assert(q
->tx_waiting
);
1276 /* Just in case the driver is not ready on more */
1277 if (unlikely(!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
))) {
1281 ret
= virtio_net_flush_tx(q
);
1282 if (ret
== -EBUSY
) {
1283 return; /* Notification re-enable handled by tx_complete */
1286 /* If we flush a full burst of packets, assume there are
1287 * more coming and immediately reschedule */
1288 if (ret
>= n
->tx_burst
) {
1289 qemu_bh_schedule(q
->tx_bh
);
1294 /* If less than a full burst, re-enable notification and flush
1295 * anything that may have come in while we weren't looking. If
1296 * we find something, assume the guest is still active and reschedule */
1297 virtio_queue_set_notification(q
->tx_vq
, 1);
1298 if (virtio_net_flush_tx(q
) > 0) {
1299 virtio_queue_set_notification(q
->tx_vq
, 0);
1300 qemu_bh_schedule(q
->tx_bh
);
1305 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
)
1307 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1308 int i
, max
= multiqueue
? n
->max_queues
: 1;
1310 n
->multiqueue
= multiqueue
;
1312 for (i
= 2; i
<= n
->max_queues
* 2 + 1; i
++) {
1313 virtio_del_queue(vdev
, i
);
1316 for (i
= 1; i
< max
; i
++) {
1317 n
->vqs
[i
].rx_vq
= virtio_add_queue(vdev
, 256, virtio_net_handle_rx
);
1318 if (n
->vqs
[i
].tx_timer
) {
1320 virtio_add_queue(vdev
, 256, virtio_net_handle_tx_timer
);
1321 n
->vqs
[i
].tx_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
1322 virtio_net_tx_timer
,
1326 virtio_add_queue(vdev
, 256, virtio_net_handle_tx_bh
);
1327 n
->vqs
[i
].tx_bh
= qemu_bh_new(virtio_net_tx_bh
, &n
->vqs
[i
]);
1330 n
->vqs
[i
].tx_waiting
= 0;
1334 /* Note: Minux Guests (version 3.2.1) use ctrl vq but don't ack
1335 * VIRTIO_NET_F_CTRL_VQ. Create ctrl vq unconditionally to avoid
1338 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
1340 virtio_net_set_queues(n
);
1343 static void virtio_net_save(QEMUFile
*f
, void *opaque
)
1345 VirtIONet
*n
= opaque
;
1346 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1348 /* At this point, backend must be stopped, otherwise
1349 * it might keep writing to memory. */
1350 assert(!n
->vhost_started
);
1351 virtio_save(vdev
, f
);
1354 static void virtio_net_save_device(VirtIODevice
*vdev
, QEMUFile
*f
)
1356 VirtIONet
*n
= VIRTIO_NET(vdev
);
1359 qemu_put_buffer(f
, n
->mac
, ETH_ALEN
);
1360 qemu_put_be32(f
, n
->vqs
[0].tx_waiting
);
1361 qemu_put_be32(f
, n
->mergeable_rx_bufs
);
1362 qemu_put_be16(f
, n
->status
);
1363 qemu_put_byte(f
, n
->promisc
);
1364 qemu_put_byte(f
, n
->allmulti
);
1365 qemu_put_be32(f
, n
->mac_table
.in_use
);
1366 qemu_put_buffer(f
, n
->mac_table
.macs
, n
->mac_table
.in_use
* ETH_ALEN
);
1367 qemu_put_buffer(f
, (uint8_t *)n
->vlans
, MAX_VLAN
>> 3);
1368 qemu_put_be32(f
, n
->has_vnet_hdr
);
1369 qemu_put_byte(f
, n
->mac_table
.multi_overflow
);
1370 qemu_put_byte(f
, n
->mac_table
.uni_overflow
);
1371 qemu_put_byte(f
, n
->alluni
);
1372 qemu_put_byte(f
, n
->nomulti
);
1373 qemu_put_byte(f
, n
->nouni
);
1374 qemu_put_byte(f
, n
->nobcast
);
1375 qemu_put_byte(f
, n
->has_ufo
);
1376 if (n
->max_queues
> 1) {
1377 qemu_put_be16(f
, n
->max_queues
);
1378 qemu_put_be16(f
, n
->curr_queues
);
1379 for (i
= 1; i
< n
->curr_queues
; i
++) {
1380 qemu_put_be32(f
, n
->vqs
[i
].tx_waiting
);
1384 if (virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
1385 qemu_put_be64(f
, n
->curr_guest_offloads
);
1389 static int virtio_net_load(QEMUFile
*f
, void *opaque
, int version_id
)
1391 VirtIONet
*n
= opaque
;
1392 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1394 if (version_id
< 2 || version_id
> VIRTIO_NET_VM_VERSION
)
1397 return virtio_load(vdev
, f
, version_id
);
1400 static int virtio_net_load_device(VirtIODevice
*vdev
, QEMUFile
*f
,
1403 VirtIONet
*n
= VIRTIO_NET(vdev
);
1406 qemu_get_buffer(f
, n
->mac
, ETH_ALEN
);
1407 n
->vqs
[0].tx_waiting
= qemu_get_be32(f
);
1409 virtio_net_set_mrg_rx_bufs(n
, qemu_get_be32(f
));
1411 if (version_id
>= 3)
1412 n
->status
= qemu_get_be16(f
);
1414 if (version_id
>= 4) {
1415 if (version_id
< 8) {
1416 n
->promisc
= qemu_get_be32(f
);
1417 n
->allmulti
= qemu_get_be32(f
);
1419 n
->promisc
= qemu_get_byte(f
);
1420 n
->allmulti
= qemu_get_byte(f
);
1424 if (version_id
>= 5) {
1425 n
->mac_table
.in_use
= qemu_get_be32(f
);
1426 /* MAC_TABLE_ENTRIES may be different from the saved image */
1427 if (n
->mac_table
.in_use
<= MAC_TABLE_ENTRIES
) {
1428 qemu_get_buffer(f
, n
->mac_table
.macs
,
1429 n
->mac_table
.in_use
* ETH_ALEN
);
1433 /* Overflow detected - can happen if source has a larger MAC table.
1434 * We simply set overflow flag so there's no need to maintain the
1435 * table of addresses, discard them all.
1436 * Note: 64 bit math to avoid integer overflow.
1438 for (i
= 0; i
< (int64_t)n
->mac_table
.in_use
* ETH_ALEN
; ++i
) {
1441 n
->mac_table
.multi_overflow
= n
->mac_table
.uni_overflow
= 1;
1442 n
->mac_table
.in_use
= 0;
1446 if (version_id
>= 6)
1447 qemu_get_buffer(f
, (uint8_t *)n
->vlans
, MAX_VLAN
>> 3);
1449 if (version_id
>= 7) {
1450 if (qemu_get_be32(f
) && !peer_has_vnet_hdr(n
)) {
1451 error_report("virtio-net: saved image requires vnet_hdr=on");
1456 if (version_id
>= 9) {
1457 n
->mac_table
.multi_overflow
= qemu_get_byte(f
);
1458 n
->mac_table
.uni_overflow
= qemu_get_byte(f
);
1461 if (version_id
>= 10) {
1462 n
->alluni
= qemu_get_byte(f
);
1463 n
->nomulti
= qemu_get_byte(f
);
1464 n
->nouni
= qemu_get_byte(f
);
1465 n
->nobcast
= qemu_get_byte(f
);
1468 if (version_id
>= 11) {
1469 if (qemu_get_byte(f
) && !peer_has_ufo(n
)) {
1470 error_report("virtio-net: saved image requires TUN_F_UFO support");
1475 if (n
->max_queues
> 1) {
1476 if (n
->max_queues
!= qemu_get_be16(f
)) {
1477 error_report("virtio-net: different max_queues ");
1481 n
->curr_queues
= qemu_get_be16(f
);
1482 if (n
->curr_queues
> n
->max_queues
) {
1483 error_report("virtio-net: curr_queues %x > max_queues %x",
1484 n
->curr_queues
, n
->max_queues
);
1487 for (i
= 1; i
< n
->curr_queues
; i
++) {
1488 n
->vqs
[i
].tx_waiting
= qemu_get_be32(f
);
1492 if (virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
1493 n
->curr_guest_offloads
= qemu_get_be64(f
);
1495 n
->curr_guest_offloads
= virtio_net_supported_guest_offloads(n
);
1498 if (peer_has_vnet_hdr(n
)) {
1499 virtio_net_apply_guest_offloads(n
);
1502 virtio_net_set_queues(n
);
1504 /* Find the first multicast entry in the saved MAC filter */
1505 for (i
= 0; i
< n
->mac_table
.in_use
; i
++) {
1506 if (n
->mac_table
.macs
[i
* ETH_ALEN
] & 1) {
1510 n
->mac_table
.first_multi
= i
;
1512 /* nc.link_down can't be migrated, so infer link_down according
1513 * to link status bit in n->status */
1514 link_down
= (n
->status
& VIRTIO_NET_S_LINK_UP
) == 0;
1515 for (i
= 0; i
< n
->max_queues
; i
++) {
1516 qemu_get_subqueue(n
->nic
, i
)->link_down
= link_down
;
1519 if (virtio_has_feature(vdev
, VIRTIO_NET_F_GUEST_ANNOUNCE
) &&
1520 virtio_has_feature(vdev
, VIRTIO_NET_F_CTRL_VQ
)) {
1521 n
->announce_counter
= SELF_ANNOUNCE_ROUNDS
;
1522 timer_mod(n
->announce_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
));
1528 static NetClientInfo net_virtio_info
= {
1529 .type
= NET_CLIENT_OPTIONS_KIND_NIC
,
1530 .size
= sizeof(NICState
),
1531 .can_receive
= virtio_net_can_receive
,
1532 .receive
= virtio_net_receive
,
1533 .link_status_changed
= virtio_net_set_link_status
,
1534 .query_rx_filter
= virtio_net_query_rxfilter
,
1537 static bool virtio_net_guest_notifier_pending(VirtIODevice
*vdev
, int idx
)
1539 VirtIONet
*n
= VIRTIO_NET(vdev
);
1540 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1541 assert(n
->vhost_started
);
1542 return vhost_net_virtqueue_pending(get_vhost_net(nc
->peer
), idx
);
1545 static void virtio_net_guest_notifier_mask(VirtIODevice
*vdev
, int idx
,
1548 VirtIONet
*n
= VIRTIO_NET(vdev
);
1549 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1550 assert(n
->vhost_started
);
1551 vhost_net_virtqueue_mask(get_vhost_net(nc
->peer
),
1555 void virtio_net_set_config_size(VirtIONet
*n
, uint32_t host_features
)
1557 int i
, config_size
= 0;
1558 virtio_add_feature(&host_features
, VIRTIO_NET_F_MAC
);
1559 for (i
= 0; feature_sizes
[i
].flags
!= 0; i
++) {
1560 if (host_features
& feature_sizes
[i
].flags
) {
1561 config_size
= MAX(feature_sizes
[i
].end
, config_size
);
1564 n
->config_size
= config_size
;
1567 void virtio_net_set_netclient_name(VirtIONet
*n
, const char *name
,
1571 * The name can be NULL, the netclient name will be type.x.
1573 assert(type
!= NULL
);
1575 g_free(n
->netclient_name
);
1576 g_free(n
->netclient_type
);
1577 n
->netclient_name
= g_strdup(name
);
1578 n
->netclient_type
= g_strdup(type
);
1581 static void virtio_net_device_realize(DeviceState
*dev
, Error
**errp
)
1583 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1584 VirtIONet
*n
= VIRTIO_NET(dev
);
1588 virtio_init(vdev
, "virtio-net", VIRTIO_ID_NET
, n
->config_size
);
1590 n
->max_queues
= MAX(n
->nic_conf
.peers
.queues
, 1);
1591 n
->vqs
= g_malloc0(sizeof(VirtIONetQueue
) * n
->max_queues
);
1592 n
->vqs
[0].rx_vq
= virtio_add_queue(vdev
, 256, virtio_net_handle_rx
);
1595 n
->tx_timeout
= n
->net_conf
.txtimer
;
1597 if (n
->net_conf
.tx
&& strcmp(n
->net_conf
.tx
, "timer")
1598 && strcmp(n
->net_conf
.tx
, "bh")) {
1599 error_report("virtio-net: "
1600 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
1602 error_report("Defaulting to \"bh\"");
1605 if (n
->net_conf
.tx
&& !strcmp(n
->net_conf
.tx
, "timer")) {
1606 n
->vqs
[0].tx_vq
= virtio_add_queue(vdev
, 256,
1607 virtio_net_handle_tx_timer
);
1608 n
->vqs
[0].tx_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
, virtio_net_tx_timer
,
1611 n
->vqs
[0].tx_vq
= virtio_add_queue(vdev
, 256,
1612 virtio_net_handle_tx_bh
);
1613 n
->vqs
[0].tx_bh
= qemu_bh_new(virtio_net_tx_bh
, &n
->vqs
[0]);
1615 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
1616 qemu_macaddr_default_if_unset(&n
->nic_conf
.macaddr
);
1617 memcpy(&n
->mac
[0], &n
->nic_conf
.macaddr
, sizeof(n
->mac
));
1618 n
->status
= VIRTIO_NET_S_LINK_UP
;
1619 n
->announce_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
1620 virtio_net_announce_timer
, n
);
1622 if (n
->netclient_type
) {
1624 * Happen when virtio_net_set_netclient_name has been called.
1626 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
1627 n
->netclient_type
, n
->netclient_name
, n
);
1629 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
1630 object_get_typename(OBJECT(dev
)), dev
->id
, n
);
1633 peer_test_vnet_hdr(n
);
1634 if (peer_has_vnet_hdr(n
)) {
1635 for (i
= 0; i
< n
->max_queues
; i
++) {
1636 qemu_using_vnet_hdr(qemu_get_subqueue(n
->nic
, i
)->peer
, true);
1638 n
->host_hdr_len
= sizeof(struct virtio_net_hdr
);
1640 n
->host_hdr_len
= 0;
1643 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->nic_conf
.macaddr
.a
);
1645 n
->vqs
[0].tx_waiting
= 0;
1646 n
->tx_burst
= n
->net_conf
.txburst
;
1647 virtio_net_set_mrg_rx_bufs(n
, 0);
1648 n
->promisc
= 1; /* for compatibility */
1650 n
->mac_table
.macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
1652 n
->vlans
= g_malloc0(MAX_VLAN
>> 3);
1654 nc
= qemu_get_queue(n
->nic
);
1655 nc
->rxfilter_notify_enabled
= 1;
1658 register_savevm(dev
, "virtio-net", -1, VIRTIO_NET_VM_VERSION
,
1659 virtio_net_save
, virtio_net_load
, n
);
1662 static void virtio_net_device_unrealize(DeviceState
*dev
, Error
**errp
)
1664 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1665 VirtIONet
*n
= VIRTIO_NET(dev
);
1668 /* This will stop vhost backend if appropriate. */
1669 virtio_net_set_status(vdev
, 0);
1671 unregister_savevm(dev
, "virtio-net", n
);
1673 g_free(n
->netclient_name
);
1674 n
->netclient_name
= NULL
;
1675 g_free(n
->netclient_type
);
1676 n
->netclient_type
= NULL
;
1678 g_free(n
->mac_table
.macs
);
1681 for (i
= 0; i
< n
->max_queues
; i
++) {
1682 VirtIONetQueue
*q
= &n
->vqs
[i
];
1683 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, i
);
1685 qemu_purge_queued_packets(nc
);
1688 timer_del(q
->tx_timer
);
1689 timer_free(q
->tx_timer
);
1690 } else if (q
->tx_bh
) {
1691 qemu_bh_delete(q
->tx_bh
);
1695 timer_del(n
->announce_timer
);
1696 timer_free(n
->announce_timer
);
1698 qemu_del_nic(n
->nic
);
1699 virtio_cleanup(vdev
);
1702 static void virtio_net_instance_init(Object
*obj
)
1704 VirtIONet
*n
= VIRTIO_NET(obj
);
1707 * The default config_size is sizeof(struct virtio_net_config).
1708 * Can be overriden with virtio_net_set_config_size.
1710 n
->config_size
= sizeof(struct virtio_net_config
);
1711 device_add_bootindex_property(obj
, &n
->nic_conf
.bootindex
,
1712 "bootindex", "/ethernet-phy@0",
1716 static Property virtio_net_properties
[] = {
1717 DEFINE_NIC_PROPERTIES(VirtIONet
, nic_conf
),
1718 DEFINE_PROP_UINT32("x-txtimer", VirtIONet
, net_conf
.txtimer
,
1720 DEFINE_PROP_INT32("x-txburst", VirtIONet
, net_conf
.txburst
, TX_BURST
),
1721 DEFINE_PROP_STRING("tx", VirtIONet
, net_conf
.tx
),
1722 DEFINE_PROP_END_OF_LIST(),
1725 static void virtio_net_class_init(ObjectClass
*klass
, void *data
)
1727 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1728 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
1730 dc
->props
= virtio_net_properties
;
1731 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1732 vdc
->realize
= virtio_net_device_realize
;
1733 vdc
->unrealize
= virtio_net_device_unrealize
;
1734 vdc
->get_config
= virtio_net_get_config
;
1735 vdc
->set_config
= virtio_net_set_config
;
1736 vdc
->get_features
= virtio_net_get_features
;
1737 vdc
->set_features
= virtio_net_set_features
;
1738 vdc
->bad_features
= virtio_net_bad_features
;
1739 vdc
->reset
= virtio_net_reset
;
1740 vdc
->set_status
= virtio_net_set_status
;
1741 vdc
->guest_notifier_mask
= virtio_net_guest_notifier_mask
;
1742 vdc
->guest_notifier_pending
= virtio_net_guest_notifier_pending
;
1743 vdc
->load
= virtio_net_load_device
;
1744 vdc
->save
= virtio_net_save_device
;
1747 static const TypeInfo virtio_net_info
= {
1748 .name
= TYPE_VIRTIO_NET
,
1749 .parent
= TYPE_VIRTIO_DEVICE
,
1750 .instance_size
= sizeof(VirtIONet
),
1751 .instance_init
= virtio_net_instance_init
,
1752 .class_init
= virtio_net_class_init
,
1755 static void virtio_register_types(void)
1757 type_register_static(&virtio_net_info
);
1760 type_init(virtio_register_types
)