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.
14 #include "qemu/osdep.h"
16 #include "hw/virtio/virtio.h"
18 #include "net/checksum.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"
29 #define VIRTIO_NET_VM_VERSION 11
31 #define MAC_TABLE_ENTRIES 64
32 #define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
35 * Calculate the number of bytes up to and including the given 'field' of
38 #define endof(container, field) \
39 (offsetof(container, field) + sizeof(((container *)0)->field))
41 typedef struct VirtIOFeature
{
46 static VirtIOFeature feature_sizes
[] = {
47 {.flags
= 1 << VIRTIO_NET_F_MAC
,
48 .end
= endof(struct virtio_net_config
, mac
)},
49 {.flags
= 1 << VIRTIO_NET_F_STATUS
,
50 .end
= endof(struct virtio_net_config
, status
)},
51 {.flags
= 1 << VIRTIO_NET_F_MQ
,
52 .end
= endof(struct virtio_net_config
, max_virtqueue_pairs
)},
56 static VirtIONetQueue
*virtio_net_get_subqueue(NetClientState
*nc
)
58 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
60 return &n
->vqs
[nc
->queue_index
];
63 static int vq2q(int queue_index
)
65 return queue_index
/ 2;
69 * - we could suppress RX interrupt if we were so inclined.
72 static void virtio_net_get_config(VirtIODevice
*vdev
, uint8_t *config
)
74 VirtIONet
*n
= VIRTIO_NET(vdev
);
75 struct virtio_net_config netcfg
;
77 virtio_stw_p(vdev
, &netcfg
.status
, n
->status
);
78 virtio_stw_p(vdev
, &netcfg
.max_virtqueue_pairs
, n
->max_queues
);
79 memcpy(netcfg
.mac
, n
->mac
, ETH_ALEN
);
80 memcpy(config
, &netcfg
, n
->config_size
);
83 static void virtio_net_set_config(VirtIODevice
*vdev
, const uint8_t *config
)
85 VirtIONet
*n
= VIRTIO_NET(vdev
);
86 struct virtio_net_config netcfg
= {};
88 memcpy(&netcfg
, config
, n
->config_size
);
90 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_MAC_ADDR
) &&
91 !virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
) &&
92 memcmp(netcfg
.mac
, n
->mac
, ETH_ALEN
)) {
93 memcpy(n
->mac
, netcfg
.mac
, ETH_ALEN
);
94 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
98 static bool virtio_net_started(VirtIONet
*n
, uint8_t status
)
100 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
101 return (status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
102 (n
->status
& VIRTIO_NET_S_LINK_UP
) && vdev
->vm_running
;
105 static void virtio_net_announce_timer(void *opaque
)
107 VirtIONet
*n
= opaque
;
108 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
110 n
->announce_counter
--;
111 n
->status
|= VIRTIO_NET_S_ANNOUNCE
;
112 virtio_notify_config(vdev
);
115 static void virtio_net_vhost_status(VirtIONet
*n
, uint8_t status
)
117 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
118 NetClientState
*nc
= qemu_get_queue(n
->nic
);
119 int queues
= n
->multiqueue
? n
->max_queues
: 1;
121 if (!get_vhost_net(nc
->peer
)) {
125 if ((virtio_net_started(n
, status
) && !nc
->peer
->link_down
) ==
126 !!n
->vhost_started
) {
129 if (!n
->vhost_started
) {
132 /* Any packets outstanding? Purge them to avoid touching rings
133 * when vhost is running.
135 for (i
= 0; i
< queues
; i
++) {
136 NetClientState
*qnc
= qemu_get_subqueue(n
->nic
, i
);
138 /* Purge both directions: TX and RX. */
139 qemu_net_queue_purge(qnc
->peer
->incoming_queue
, qnc
);
140 qemu_net_queue_purge(qnc
->incoming_queue
, qnc
->peer
);
143 n
->vhost_started
= 1;
144 r
= vhost_net_start(vdev
, n
->nic
->ncs
, queues
);
146 error_report("unable to start vhost net: %d: "
147 "falling back on userspace virtio", -r
);
148 n
->vhost_started
= 0;
151 vhost_net_stop(vdev
, n
->nic
->ncs
, queues
);
152 n
->vhost_started
= 0;
156 static void virtio_net_set_status(struct VirtIODevice
*vdev
, uint8_t status
)
158 VirtIONet
*n
= VIRTIO_NET(vdev
);
161 uint8_t queue_status
;
163 virtio_net_vhost_status(n
, status
);
165 for (i
= 0; i
< n
->max_queues
; i
++) {
166 NetClientState
*ncs
= qemu_get_subqueue(n
->nic
, i
);
170 if ((!n
->multiqueue
&& i
!= 0) || i
>= n
->curr_queues
) {
173 queue_status
= status
;
176 virtio_net_started(n
, queue_status
) && !n
->vhost_started
;
179 qemu_flush_queued_packets(ncs
);
182 if (!q
->tx_waiting
) {
188 timer_mod(q
->tx_timer
,
189 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
191 qemu_bh_schedule(q
->tx_bh
);
195 timer_del(q
->tx_timer
);
197 qemu_bh_cancel(q
->tx_bh
);
203 static void virtio_net_set_link_status(NetClientState
*nc
)
205 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
206 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
207 uint16_t old_status
= n
->status
;
210 n
->status
&= ~VIRTIO_NET_S_LINK_UP
;
212 n
->status
|= VIRTIO_NET_S_LINK_UP
;
214 if (n
->status
!= old_status
)
215 virtio_notify_config(vdev
);
217 virtio_net_set_status(vdev
, vdev
->status
);
220 static void rxfilter_notify(NetClientState
*nc
)
222 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
224 if (nc
->rxfilter_notify_enabled
) {
225 gchar
*path
= object_get_canonical_path(OBJECT(n
->qdev
));
226 qapi_event_send_nic_rx_filter_changed(!!n
->netclient_name
,
227 n
->netclient_name
, path
, &error_abort
);
230 /* disable event notification to avoid events flooding */
231 nc
->rxfilter_notify_enabled
= 0;
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
= qemu_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
= qemu_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
= qemu_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_vdev_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
,
381 n
->mergeable_rx_bufs
= mergeable_rx_bufs
;
384 n
->guest_hdr_len
= sizeof(struct virtio_net_hdr_mrg_rxbuf
);
386 n
->guest_hdr_len
= n
->mergeable_rx_bufs
?
387 sizeof(struct virtio_net_hdr_mrg_rxbuf
) :
388 sizeof(struct virtio_net_hdr
);
391 for (i
= 0; i
< n
->max_queues
; i
++) {
392 nc
= qemu_get_subqueue(n
->nic
, i
);
394 if (peer_has_vnet_hdr(n
) &&
395 qemu_has_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
)) {
396 qemu_set_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
);
397 n
->host_hdr_len
= n
->guest_hdr_len
;
402 static int peer_attach(VirtIONet
*n
, int index
)
404 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
410 if (nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_VHOST_USER
) {
411 vhost_set_vring_enable(nc
->peer
, 1);
414 if (nc
->peer
->info
->type
!= NET_CLIENT_OPTIONS_KIND_TAP
) {
418 return tap_enable(nc
->peer
);
421 static int peer_detach(VirtIONet
*n
, int index
)
423 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
429 if (nc
->peer
->info
->type
== NET_CLIENT_OPTIONS_KIND_VHOST_USER
) {
430 vhost_set_vring_enable(nc
->peer
, 0);
433 if (nc
->peer
->info
->type
!= NET_CLIENT_OPTIONS_KIND_TAP
) {
437 return tap_disable(nc
->peer
);
440 static void virtio_net_set_queues(VirtIONet
*n
)
445 for (i
= 0; i
< n
->max_queues
; i
++) {
446 if (i
< n
->curr_queues
) {
447 r
= peer_attach(n
, i
);
450 r
= peer_detach(n
, i
);
456 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
);
458 static uint64_t virtio_net_get_features(VirtIODevice
*vdev
, uint64_t features
,
461 VirtIONet
*n
= VIRTIO_NET(vdev
);
462 NetClientState
*nc
= qemu_get_queue(n
->nic
);
464 /* Firstly sync all virtio-net possible supported features */
465 features
|= n
->host_features
;
467 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
469 if (!peer_has_vnet_hdr(n
)) {
470 virtio_clear_feature(&features
, VIRTIO_NET_F_CSUM
);
471 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
472 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
473 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
475 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_CSUM
);
476 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO4
);
477 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO6
);
478 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_ECN
);
481 if (!peer_has_vnet_hdr(n
) || !peer_has_ufo(n
)) {
482 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_UFO
);
483 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_UFO
);
486 if (!get_vhost_net(nc
->peer
)) {
489 return vhost_net_get_features(get_vhost_net(nc
->peer
), features
);
492 static uint64_t virtio_net_bad_features(VirtIODevice
*vdev
)
494 uint64_t features
= 0;
496 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
498 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
499 virtio_add_feature(&features
, VIRTIO_NET_F_CSUM
);
500 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
501 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
502 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
507 static void virtio_net_apply_guest_offloads(VirtIONet
*n
)
509 qemu_set_offload(qemu_get_queue(n
->nic
)->peer
,
510 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_CSUM
)),
511 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO4
)),
512 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO6
)),
513 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_ECN
)),
514 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_UFO
)));
517 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features
)
519 static const uint64_t guest_offloads_mask
=
520 (1ULL << VIRTIO_NET_F_GUEST_CSUM
) |
521 (1ULL << VIRTIO_NET_F_GUEST_TSO4
) |
522 (1ULL << VIRTIO_NET_F_GUEST_TSO6
) |
523 (1ULL << VIRTIO_NET_F_GUEST_ECN
) |
524 (1ULL << VIRTIO_NET_F_GUEST_UFO
);
526 return guest_offloads_mask
& features
;
529 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet
*n
)
531 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
532 return virtio_net_guest_offloads_by_features(vdev
->guest_features
);
535 static void virtio_net_set_features(VirtIODevice
*vdev
, uint64_t features
)
537 VirtIONet
*n
= VIRTIO_NET(vdev
);
540 virtio_net_set_multiqueue(n
,
541 virtio_has_feature(features
, VIRTIO_NET_F_MQ
));
543 virtio_net_set_mrg_rx_bufs(n
,
544 virtio_has_feature(features
,
545 VIRTIO_NET_F_MRG_RXBUF
),
546 virtio_has_feature(features
,
547 VIRTIO_F_VERSION_1
));
549 if (n
->has_vnet_hdr
) {
550 n
->curr_guest_offloads
=
551 virtio_net_guest_offloads_by_features(features
);
552 virtio_net_apply_guest_offloads(n
);
555 for (i
= 0; i
< n
->max_queues
; i
++) {
556 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, i
);
558 if (!get_vhost_net(nc
->peer
)) {
561 vhost_net_ack_features(get_vhost_net(nc
->peer
), features
);
564 if (virtio_has_feature(features
, VIRTIO_NET_F_CTRL_VLAN
)) {
565 memset(n
->vlans
, 0, MAX_VLAN
>> 3);
567 memset(n
->vlans
, 0xff, MAX_VLAN
>> 3);
571 static int virtio_net_handle_rx_mode(VirtIONet
*n
, uint8_t cmd
,
572 struct iovec
*iov
, unsigned int iov_cnt
)
576 NetClientState
*nc
= qemu_get_queue(n
->nic
);
578 s
= iov_to_buf(iov
, iov_cnt
, 0, &on
, sizeof(on
));
579 if (s
!= sizeof(on
)) {
580 return VIRTIO_NET_ERR
;
583 if (cmd
== VIRTIO_NET_CTRL_RX_PROMISC
) {
585 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLMULTI
) {
587 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLUNI
) {
589 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOMULTI
) {
591 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOUNI
) {
593 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOBCAST
) {
596 return VIRTIO_NET_ERR
;
601 return VIRTIO_NET_OK
;
604 static int virtio_net_handle_offloads(VirtIONet
*n
, uint8_t cmd
,
605 struct iovec
*iov
, unsigned int iov_cnt
)
607 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
611 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
612 return VIRTIO_NET_ERR
;
615 s
= iov_to_buf(iov
, iov_cnt
, 0, &offloads
, sizeof(offloads
));
616 if (s
!= sizeof(offloads
)) {
617 return VIRTIO_NET_ERR
;
620 if (cmd
== VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET
) {
621 uint64_t supported_offloads
;
623 if (!n
->has_vnet_hdr
) {
624 return VIRTIO_NET_ERR
;
627 supported_offloads
= virtio_net_supported_guest_offloads(n
);
628 if (offloads
& ~supported_offloads
) {
629 return VIRTIO_NET_ERR
;
632 n
->curr_guest_offloads
= offloads
;
633 virtio_net_apply_guest_offloads(n
);
635 return VIRTIO_NET_OK
;
637 return VIRTIO_NET_ERR
;
641 static int virtio_net_handle_mac(VirtIONet
*n
, uint8_t cmd
,
642 struct iovec
*iov
, unsigned int iov_cnt
)
644 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
645 struct virtio_net_ctrl_mac mac_data
;
647 NetClientState
*nc
= qemu_get_queue(n
->nic
);
649 if (cmd
== VIRTIO_NET_CTRL_MAC_ADDR_SET
) {
650 if (iov_size(iov
, iov_cnt
) != sizeof(n
->mac
)) {
651 return VIRTIO_NET_ERR
;
653 s
= iov_to_buf(iov
, iov_cnt
, 0, &n
->mac
, sizeof(n
->mac
));
654 assert(s
== sizeof(n
->mac
));
655 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
658 return VIRTIO_NET_OK
;
661 if (cmd
!= VIRTIO_NET_CTRL_MAC_TABLE_SET
) {
662 return VIRTIO_NET_ERR
;
667 uint8_t uni_overflow
= 0;
668 uint8_t multi_overflow
= 0;
669 uint8_t *macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
671 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
672 sizeof(mac_data
.entries
));
673 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
674 if (s
!= sizeof(mac_data
.entries
)) {
677 iov_discard_front(&iov
, &iov_cnt
, s
);
679 if (mac_data
.entries
* ETH_ALEN
> iov_size(iov
, iov_cnt
)) {
683 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
) {
684 s
= iov_to_buf(iov
, iov_cnt
, 0, macs
,
685 mac_data
.entries
* ETH_ALEN
);
686 if (s
!= mac_data
.entries
* ETH_ALEN
) {
689 in_use
+= mac_data
.entries
;
694 iov_discard_front(&iov
, &iov_cnt
, mac_data
.entries
* ETH_ALEN
);
696 first_multi
= in_use
;
698 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
699 sizeof(mac_data
.entries
));
700 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
701 if (s
!= sizeof(mac_data
.entries
)) {
705 iov_discard_front(&iov
, &iov_cnt
, s
);
707 if (mac_data
.entries
* ETH_ALEN
!= iov_size(iov
, iov_cnt
)) {
711 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
- in_use
) {
712 s
= iov_to_buf(iov
, iov_cnt
, 0, &macs
[in_use
* ETH_ALEN
],
713 mac_data
.entries
* ETH_ALEN
);
714 if (s
!= mac_data
.entries
* ETH_ALEN
) {
717 in_use
+= mac_data
.entries
;
722 n
->mac_table
.in_use
= in_use
;
723 n
->mac_table
.first_multi
= first_multi
;
724 n
->mac_table
.uni_overflow
= uni_overflow
;
725 n
->mac_table
.multi_overflow
= multi_overflow
;
726 memcpy(n
->mac_table
.macs
, macs
, MAC_TABLE_ENTRIES
* ETH_ALEN
);
730 return VIRTIO_NET_OK
;
734 return VIRTIO_NET_ERR
;
737 static int virtio_net_handle_vlan_table(VirtIONet
*n
, uint8_t cmd
,
738 struct iovec
*iov
, unsigned int iov_cnt
)
740 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
743 NetClientState
*nc
= qemu_get_queue(n
->nic
);
745 s
= iov_to_buf(iov
, iov_cnt
, 0, &vid
, sizeof(vid
));
746 vid
= virtio_lduw_p(vdev
, &vid
);
747 if (s
!= sizeof(vid
)) {
748 return VIRTIO_NET_ERR
;
752 return VIRTIO_NET_ERR
;
754 if (cmd
== VIRTIO_NET_CTRL_VLAN_ADD
)
755 n
->vlans
[vid
>> 5] |= (1U << (vid
& 0x1f));
756 else if (cmd
== VIRTIO_NET_CTRL_VLAN_DEL
)
757 n
->vlans
[vid
>> 5] &= ~(1U << (vid
& 0x1f));
759 return VIRTIO_NET_ERR
;
763 return VIRTIO_NET_OK
;
766 static int virtio_net_handle_announce(VirtIONet
*n
, uint8_t cmd
,
767 struct iovec
*iov
, unsigned int iov_cnt
)
769 if (cmd
== VIRTIO_NET_CTRL_ANNOUNCE_ACK
&&
770 n
->status
& VIRTIO_NET_S_ANNOUNCE
) {
771 n
->status
&= ~VIRTIO_NET_S_ANNOUNCE
;
772 if (n
->announce_counter
) {
773 timer_mod(n
->announce_timer
,
774 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
775 self_announce_delay(n
->announce_counter
));
777 return VIRTIO_NET_OK
;
779 return VIRTIO_NET_ERR
;
783 static int virtio_net_handle_mq(VirtIONet
*n
, uint8_t cmd
,
784 struct iovec
*iov
, unsigned int iov_cnt
)
786 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
787 struct virtio_net_ctrl_mq mq
;
791 s
= iov_to_buf(iov
, iov_cnt
, 0, &mq
, sizeof(mq
));
792 if (s
!= sizeof(mq
)) {
793 return VIRTIO_NET_ERR
;
796 if (cmd
!= VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET
) {
797 return VIRTIO_NET_ERR
;
800 queues
= virtio_lduw_p(vdev
, &mq
.virtqueue_pairs
);
802 if (queues
< VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN
||
803 queues
> VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX
||
804 queues
> n
->max_queues
||
806 return VIRTIO_NET_ERR
;
809 n
->curr_queues
= queues
;
810 /* stop the backend before changing the number of queues to avoid handling a
812 virtio_net_set_status(vdev
, vdev
->status
);
813 virtio_net_set_queues(n
);
815 return VIRTIO_NET_OK
;
817 static void virtio_net_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
819 VirtIONet
*n
= VIRTIO_NET(vdev
);
820 struct virtio_net_ctrl_hdr ctrl
;
821 virtio_net_ctrl_ack status
= VIRTIO_NET_ERR
;
822 VirtQueueElement elem
;
824 struct iovec
*iov
, *iov2
;
825 unsigned int iov_cnt
;
827 while (virtqueue_pop(vq
, &elem
)) {
828 if (iov_size(elem
.in_sg
, elem
.in_num
) < sizeof(status
) ||
829 iov_size(elem
.out_sg
, elem
.out_num
) < sizeof(ctrl
)) {
830 error_report("virtio-net ctrl missing headers");
834 iov_cnt
= elem
.out_num
;
835 iov2
= iov
= g_memdup(elem
.out_sg
, sizeof(struct iovec
) * elem
.out_num
);
836 s
= iov_to_buf(iov
, iov_cnt
, 0, &ctrl
, sizeof(ctrl
));
837 iov_discard_front(&iov
, &iov_cnt
, sizeof(ctrl
));
838 if (s
!= sizeof(ctrl
)) {
839 status
= VIRTIO_NET_ERR
;
840 } else if (ctrl
.class == VIRTIO_NET_CTRL_RX
) {
841 status
= virtio_net_handle_rx_mode(n
, ctrl
.cmd
, iov
, iov_cnt
);
842 } else if (ctrl
.class == VIRTIO_NET_CTRL_MAC
) {
843 status
= virtio_net_handle_mac(n
, ctrl
.cmd
, iov
, iov_cnt
);
844 } else if (ctrl
.class == VIRTIO_NET_CTRL_VLAN
) {
845 status
= virtio_net_handle_vlan_table(n
, ctrl
.cmd
, iov
, iov_cnt
);
846 } else if (ctrl
.class == VIRTIO_NET_CTRL_ANNOUNCE
) {
847 status
= virtio_net_handle_announce(n
, ctrl
.cmd
, iov
, iov_cnt
);
848 } else if (ctrl
.class == VIRTIO_NET_CTRL_MQ
) {
849 status
= virtio_net_handle_mq(n
, ctrl
.cmd
, iov
, iov_cnt
);
850 } else if (ctrl
.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS
) {
851 status
= virtio_net_handle_offloads(n
, ctrl
.cmd
, iov
, iov_cnt
);
854 s
= iov_from_buf(elem
.in_sg
, elem
.in_num
, 0, &status
, sizeof(status
));
855 assert(s
== sizeof(status
));
857 virtqueue_push(vq
, &elem
, sizeof(status
));
858 virtio_notify(vdev
, vq
);
865 static void virtio_net_handle_rx(VirtIODevice
*vdev
, VirtQueue
*vq
)
867 VirtIONet
*n
= VIRTIO_NET(vdev
);
868 int queue_index
= vq2q(virtio_get_queue_index(vq
));
870 qemu_flush_queued_packets(qemu_get_subqueue(n
->nic
, queue_index
));
873 static int virtio_net_can_receive(NetClientState
*nc
)
875 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
876 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
877 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
879 if (!vdev
->vm_running
) {
883 if (nc
->queue_index
>= n
->curr_queues
) {
887 if (!virtio_queue_ready(q
->rx_vq
) ||
888 !(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
895 static int virtio_net_has_buffers(VirtIONetQueue
*q
, int bufsize
)
898 if (virtio_queue_empty(q
->rx_vq
) ||
899 (n
->mergeable_rx_bufs
&&
900 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
901 virtio_queue_set_notification(q
->rx_vq
, 1);
903 /* To avoid a race condition where the guest has made some buffers
904 * available after the above check but before notification was
905 * enabled, check for available buffers again.
907 if (virtio_queue_empty(q
->rx_vq
) ||
908 (n
->mergeable_rx_bufs
&&
909 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
914 virtio_queue_set_notification(q
->rx_vq
, 0);
918 static void virtio_net_hdr_swap(VirtIODevice
*vdev
, struct virtio_net_hdr
*hdr
)
920 virtio_tswap16s(vdev
, &hdr
->hdr_len
);
921 virtio_tswap16s(vdev
, &hdr
->gso_size
);
922 virtio_tswap16s(vdev
, &hdr
->csum_start
);
923 virtio_tswap16s(vdev
, &hdr
->csum_offset
);
926 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
927 * it never finds out that the packets don't have valid checksums. This
928 * causes dhclient to get upset. Fedora's carried a patch for ages to
929 * fix this with Xen but it hasn't appeared in an upstream release of
932 * To avoid breaking existing guests, we catch udp packets and add
933 * checksums. This is terrible but it's better than hacking the guest
936 * N.B. if we introduce a zero-copy API, this operation is no longer free so
937 * we should provide a mechanism to disable it to avoid polluting the host
940 static void work_around_broken_dhclient(struct virtio_net_hdr
*hdr
,
941 uint8_t *buf
, size_t size
)
943 if ((hdr
->flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) && /* missing csum */
944 (size
> 27 && size
< 1500) && /* normal sized MTU */
945 (buf
[12] == 0x08 && buf
[13] == 0x00) && /* ethertype == IPv4 */
946 (buf
[23] == 17) && /* ip.protocol == UDP */
947 (buf
[34] == 0 && buf
[35] == 67)) { /* udp.srcport == bootps */
948 net_checksum_calculate(buf
, size
);
949 hdr
->flags
&= ~VIRTIO_NET_HDR_F_NEEDS_CSUM
;
953 static void receive_header(VirtIONet
*n
, const struct iovec
*iov
, int iov_cnt
,
954 const void *buf
, size_t size
)
956 if (n
->has_vnet_hdr
) {
957 /* FIXME this cast is evil */
958 void *wbuf
= (void *)buf
;
959 work_around_broken_dhclient(wbuf
, wbuf
+ n
->host_hdr_len
,
960 size
- n
->host_hdr_len
);
961 virtio_net_hdr_swap(VIRTIO_DEVICE(n
), wbuf
);
962 iov_from_buf(iov
, iov_cnt
, 0, buf
, sizeof(struct virtio_net_hdr
));
964 struct virtio_net_hdr hdr
= {
966 .gso_type
= VIRTIO_NET_HDR_GSO_NONE
968 iov_from_buf(iov
, iov_cnt
, 0, &hdr
, sizeof hdr
);
972 static int receive_filter(VirtIONet
*n
, const uint8_t *buf
, int size
)
974 static const uint8_t bcast
[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
975 static const uint8_t vlan
[] = {0x81, 0x00};
976 uint8_t *ptr
= (uint8_t *)buf
;
982 ptr
+= n
->host_hdr_len
;
984 if (!memcmp(&ptr
[12], vlan
, sizeof(vlan
))) {
985 int vid
= be16_to_cpup((uint16_t *)(ptr
+ 14)) & 0xfff;
986 if (!(n
->vlans
[vid
>> 5] & (1U << (vid
& 0x1f))))
990 if (ptr
[0] & 1) { // multicast
991 if (!memcmp(ptr
, bcast
, sizeof(bcast
))) {
993 } else if (n
->nomulti
) {
995 } else if (n
->allmulti
|| n
->mac_table
.multi_overflow
) {
999 for (i
= n
->mac_table
.first_multi
; i
< n
->mac_table
.in_use
; i
++) {
1000 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
1007 } else if (n
->alluni
|| n
->mac_table
.uni_overflow
) {
1009 } else if (!memcmp(ptr
, n
->mac
, ETH_ALEN
)) {
1013 for (i
= 0; i
< n
->mac_table
.first_multi
; i
++) {
1014 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
1023 static ssize_t
virtio_net_receive(NetClientState
*nc
, const uint8_t *buf
, size_t size
)
1025 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1026 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1027 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1028 struct iovec mhdr_sg
[VIRTQUEUE_MAX_SIZE
];
1029 struct virtio_net_hdr_mrg_rxbuf mhdr
;
1030 unsigned mhdr_cnt
= 0;
1031 size_t offset
, i
, guest_offset
;
1033 if (!virtio_net_can_receive(nc
)) {
1037 /* hdr_len refers to the header we supply to the guest */
1038 if (!virtio_net_has_buffers(q
, size
+ n
->guest_hdr_len
- n
->host_hdr_len
)) {
1042 if (!receive_filter(n
, buf
, size
))
1047 while (offset
< size
) {
1048 VirtQueueElement elem
;
1050 const struct iovec
*sg
= elem
.in_sg
;
1054 if (virtqueue_pop(q
->rx_vq
, &elem
) == 0) {
1057 error_report("virtio-net unexpected empty queue: "
1058 "i %zd mergeable %d offset %zd, size %zd, "
1059 "guest hdr len %zd, host hdr len %zd "
1060 "guest features 0x%" PRIx64
,
1061 i
, n
->mergeable_rx_bufs
, offset
, size
,
1062 n
->guest_hdr_len
, n
->host_hdr_len
,
1063 vdev
->guest_features
);
1067 if (elem
.in_num
< 1) {
1068 error_report("virtio-net receive queue contains no in buffers");
1073 assert(offset
== 0);
1074 if (n
->mergeable_rx_bufs
) {
1075 mhdr_cnt
= iov_copy(mhdr_sg
, ARRAY_SIZE(mhdr_sg
),
1077 offsetof(typeof(mhdr
), num_buffers
),
1078 sizeof(mhdr
.num_buffers
));
1081 receive_header(n
, sg
, elem
.in_num
, buf
, size
);
1082 offset
= n
->host_hdr_len
;
1083 total
+= n
->guest_hdr_len
;
1084 guest_offset
= n
->guest_hdr_len
;
1089 /* copy in packet. ugh */
1090 len
= iov_from_buf(sg
, elem
.in_num
, guest_offset
,
1091 buf
+ offset
, size
- offset
);
1094 /* If buffers can't be merged, at this point we
1095 * must have consumed the complete packet.
1096 * Otherwise, drop it. */
1097 if (!n
->mergeable_rx_bufs
&& offset
< size
) {
1098 virtqueue_discard(q
->rx_vq
, &elem
, total
);
1102 /* signal other side */
1103 virtqueue_fill(q
->rx_vq
, &elem
, total
, i
++);
1107 virtio_stw_p(vdev
, &mhdr
.num_buffers
, i
);
1108 iov_from_buf(mhdr_sg
, mhdr_cnt
,
1110 &mhdr
.num_buffers
, sizeof mhdr
.num_buffers
);
1113 virtqueue_flush(q
->rx_vq
, i
);
1114 virtio_notify(vdev
, q
->rx_vq
);
1119 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
);
1121 static void virtio_net_tx_complete(NetClientState
*nc
, ssize_t len
)
1123 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1124 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1125 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1127 virtqueue_push(q
->tx_vq
, &q
->async_tx
.elem
, 0);
1128 virtio_notify(vdev
, q
->tx_vq
);
1130 q
->async_tx
.elem
.out_num
= 0;
1132 virtio_queue_set_notification(q
->tx_vq
, 1);
1133 virtio_net_flush_tx(q
);
1137 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
)
1139 VirtIONet
*n
= q
->n
;
1140 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1141 VirtQueueElement elem
;
1142 int32_t num_packets
= 0;
1143 int queue_index
= vq2q(virtio_get_queue_index(q
->tx_vq
));
1144 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1148 if (q
->async_tx
.elem
.out_num
) {
1149 virtio_queue_set_notification(q
->tx_vq
, 0);
1153 while (virtqueue_pop(q
->tx_vq
, &elem
)) {
1155 unsigned int out_num
= elem
.out_num
;
1156 struct iovec
*out_sg
= &elem
.out_sg
[0];
1157 struct iovec sg
[VIRTQUEUE_MAX_SIZE
], sg2
[VIRTQUEUE_MAX_SIZE
+ 1];
1158 struct virtio_net_hdr_mrg_rxbuf mhdr
;
1161 error_report("virtio-net header not in first element");
1165 if (n
->has_vnet_hdr
) {
1166 if (iov_to_buf(out_sg
, out_num
, 0, &mhdr
, n
->guest_hdr_len
) <
1168 error_report("virtio-net header incorrect");
1171 if (virtio_needs_swap(vdev
)) {
1172 virtio_net_hdr_swap(vdev
, (void *) &mhdr
);
1173 sg2
[0].iov_base
= &mhdr
;
1174 sg2
[0].iov_len
= n
->guest_hdr_len
;
1175 out_num
= iov_copy(&sg2
[1], ARRAY_SIZE(sg2
) - 1,
1177 n
->guest_hdr_len
, -1);
1178 if (out_num
== VIRTQUEUE_MAX_SIZE
) {
1186 * If host wants to see the guest header as is, we can
1187 * pass it on unchanged. Otherwise, copy just the parts
1188 * that host is interested in.
1190 assert(n
->host_hdr_len
<= n
->guest_hdr_len
);
1191 if (n
->host_hdr_len
!= n
->guest_hdr_len
) {
1192 unsigned sg_num
= iov_copy(sg
, ARRAY_SIZE(sg
),
1194 0, n
->host_hdr_len
);
1195 sg_num
+= iov_copy(sg
+ sg_num
, ARRAY_SIZE(sg
) - sg_num
,
1197 n
->guest_hdr_len
, -1);
1202 ret
= qemu_sendv_packet_async(qemu_get_subqueue(n
->nic
, queue_index
),
1203 out_sg
, out_num
, virtio_net_tx_complete
);
1205 virtio_queue_set_notification(q
->tx_vq
, 0);
1206 q
->async_tx
.elem
= elem
;
1211 virtqueue_push(q
->tx_vq
, &elem
, 0);
1212 virtio_notify(vdev
, q
->tx_vq
);
1214 if (++num_packets
>= n
->tx_burst
) {
1221 static void virtio_net_handle_tx_timer(VirtIODevice
*vdev
, VirtQueue
*vq
)
1223 VirtIONet
*n
= VIRTIO_NET(vdev
);
1224 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1226 /* This happens when device was stopped but VCPU wasn't. */
1227 if (!vdev
->vm_running
) {
1232 if (q
->tx_waiting
) {
1233 virtio_queue_set_notification(vq
, 1);
1234 timer_del(q
->tx_timer
);
1236 virtio_net_flush_tx(q
);
1238 timer_mod(q
->tx_timer
,
1239 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
1241 virtio_queue_set_notification(vq
, 0);
1245 static void virtio_net_handle_tx_bh(VirtIODevice
*vdev
, VirtQueue
*vq
)
1247 VirtIONet
*n
= VIRTIO_NET(vdev
);
1248 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1250 if (unlikely(q
->tx_waiting
)) {
1254 /* This happens when device was stopped but VCPU wasn't. */
1255 if (!vdev
->vm_running
) {
1258 virtio_queue_set_notification(vq
, 0);
1259 qemu_bh_schedule(q
->tx_bh
);
1262 static void virtio_net_tx_timer(void *opaque
)
1264 VirtIONetQueue
*q
= opaque
;
1265 VirtIONet
*n
= q
->n
;
1266 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 (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1281 virtio_queue_set_notification(q
->tx_vq
, 1);
1282 virtio_net_flush_tx(q
);
1285 static void virtio_net_tx_bh(void *opaque
)
1287 VirtIONetQueue
*q
= opaque
;
1288 VirtIONet
*n
= q
->n
;
1289 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1292 /* This happens when device was stopped but BH wasn't. */
1293 if (!vdev
->vm_running
) {
1294 /* Make sure tx waiting is set, so we'll run when restarted. */
1295 assert(q
->tx_waiting
);
1301 /* Just in case the driver is not ready on more */
1302 if (unlikely(!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
))) {
1306 ret
= virtio_net_flush_tx(q
);
1307 if (ret
== -EBUSY
) {
1308 return; /* Notification re-enable handled by tx_complete */
1311 /* If we flush a full burst of packets, assume there are
1312 * more coming and immediately reschedule */
1313 if (ret
>= n
->tx_burst
) {
1314 qemu_bh_schedule(q
->tx_bh
);
1319 /* If less than a full burst, re-enable notification and flush
1320 * anything that may have come in while we weren't looking. If
1321 * we find something, assume the guest is still active and reschedule */
1322 virtio_queue_set_notification(q
->tx_vq
, 1);
1323 if (virtio_net_flush_tx(q
) > 0) {
1324 virtio_queue_set_notification(q
->tx_vq
, 0);
1325 qemu_bh_schedule(q
->tx_bh
);
1330 static void virtio_net_add_queue(VirtIONet
*n
, int index
)
1332 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1334 n
->vqs
[index
].rx_vq
= virtio_add_queue(vdev
, 256, virtio_net_handle_rx
);
1335 if (n
->net_conf
.tx
&& !strcmp(n
->net_conf
.tx
, "timer")) {
1336 n
->vqs
[index
].tx_vq
=
1337 virtio_add_queue(vdev
, 256, virtio_net_handle_tx_timer
);
1338 n
->vqs
[index
].tx_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
1339 virtio_net_tx_timer
,
1342 n
->vqs
[index
].tx_vq
=
1343 virtio_add_queue(vdev
, 256, virtio_net_handle_tx_bh
);
1344 n
->vqs
[index
].tx_bh
= qemu_bh_new(virtio_net_tx_bh
, &n
->vqs
[index
]);
1347 n
->vqs
[index
].tx_waiting
= 0;
1348 n
->vqs
[index
].n
= n
;
1351 static void virtio_net_del_queue(VirtIONet
*n
, int index
)
1353 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1354 VirtIONetQueue
*q
= &n
->vqs
[index
];
1355 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
1357 qemu_purge_queued_packets(nc
);
1359 virtio_del_queue(vdev
, index
* 2);
1361 timer_del(q
->tx_timer
);
1362 timer_free(q
->tx_timer
);
1364 qemu_bh_delete(q
->tx_bh
);
1366 virtio_del_queue(vdev
, index
* 2 + 1);
1369 static void virtio_net_change_num_queues(VirtIONet
*n
, int new_max_queues
)
1371 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1372 int old_num_queues
= virtio_get_num_queues(vdev
);
1373 int new_num_queues
= new_max_queues
* 2 + 1;
1376 assert(old_num_queues
>= 3);
1377 assert(old_num_queues
% 2 == 1);
1379 if (old_num_queues
== new_num_queues
) {
1384 * We always need to remove and add ctrl vq if
1385 * old_num_queues != new_num_queues. Remove ctrl_vq first,
1386 * and then we only enter one of the following too loops.
1388 virtio_del_queue(vdev
, old_num_queues
- 1);
1390 for (i
= new_num_queues
- 1; i
< old_num_queues
- 1; i
+= 2) {
1391 /* new_num_queues < old_num_queues */
1392 virtio_net_del_queue(n
, i
/ 2);
1395 for (i
= old_num_queues
- 1; i
< new_num_queues
- 1; i
+= 2) {
1396 /* new_num_queues > old_num_queues */
1397 virtio_net_add_queue(n
, i
/ 2);
1400 /* add ctrl_vq last */
1401 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
1404 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
)
1406 int max
= multiqueue
? n
->max_queues
: 1;
1408 n
->multiqueue
= multiqueue
;
1409 virtio_net_change_num_queues(n
, max
);
1411 virtio_net_set_queues(n
);
1414 static void virtio_net_save(QEMUFile
*f
, void *opaque
)
1416 VirtIONet
*n
= opaque
;
1417 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1419 /* At this point, backend must be stopped, otherwise
1420 * it might keep writing to memory. */
1421 assert(!n
->vhost_started
);
1422 virtio_save(vdev
, f
);
1425 static void virtio_net_save_device(VirtIODevice
*vdev
, QEMUFile
*f
)
1427 VirtIONet
*n
= VIRTIO_NET(vdev
);
1430 qemu_put_buffer(f
, n
->mac
, ETH_ALEN
);
1431 qemu_put_be32(f
, n
->vqs
[0].tx_waiting
);
1432 qemu_put_be32(f
, n
->mergeable_rx_bufs
);
1433 qemu_put_be16(f
, n
->status
);
1434 qemu_put_byte(f
, n
->promisc
);
1435 qemu_put_byte(f
, n
->allmulti
);
1436 qemu_put_be32(f
, n
->mac_table
.in_use
);
1437 qemu_put_buffer(f
, n
->mac_table
.macs
, n
->mac_table
.in_use
* ETH_ALEN
);
1438 qemu_put_buffer(f
, (uint8_t *)n
->vlans
, MAX_VLAN
>> 3);
1439 qemu_put_be32(f
, n
->has_vnet_hdr
);
1440 qemu_put_byte(f
, n
->mac_table
.multi_overflow
);
1441 qemu_put_byte(f
, n
->mac_table
.uni_overflow
);
1442 qemu_put_byte(f
, n
->alluni
);
1443 qemu_put_byte(f
, n
->nomulti
);
1444 qemu_put_byte(f
, n
->nouni
);
1445 qemu_put_byte(f
, n
->nobcast
);
1446 qemu_put_byte(f
, n
->has_ufo
);
1447 if (n
->max_queues
> 1) {
1448 qemu_put_be16(f
, n
->max_queues
);
1449 qemu_put_be16(f
, n
->curr_queues
);
1450 for (i
= 1; i
< n
->curr_queues
; i
++) {
1451 qemu_put_be32(f
, n
->vqs
[i
].tx_waiting
);
1455 if (virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
1456 qemu_put_be64(f
, n
->curr_guest_offloads
);
1460 static int virtio_net_load(QEMUFile
*f
, void *opaque
, int version_id
)
1462 VirtIONet
*n
= opaque
;
1463 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1466 if (version_id
< 2 || version_id
> VIRTIO_NET_VM_VERSION
)
1469 ret
= virtio_load(vdev
, f
, version_id
);
1474 if (virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
1475 n
->curr_guest_offloads
= qemu_get_be64(f
);
1477 n
->curr_guest_offloads
= virtio_net_supported_guest_offloads(n
);
1480 if (peer_has_vnet_hdr(n
)) {
1481 virtio_net_apply_guest_offloads(n
);
1484 if (virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_GUEST_ANNOUNCE
) &&
1485 virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_VQ
)) {
1486 n
->announce_counter
= SELF_ANNOUNCE_ROUNDS
;
1487 timer_mod(n
->announce_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
));
1493 static int virtio_net_load_device(VirtIODevice
*vdev
, QEMUFile
*f
,
1496 VirtIONet
*n
= VIRTIO_NET(vdev
);
1499 qemu_get_buffer(f
, n
->mac
, ETH_ALEN
);
1500 n
->vqs
[0].tx_waiting
= qemu_get_be32(f
);
1502 virtio_net_set_mrg_rx_bufs(n
, qemu_get_be32(f
),
1503 virtio_vdev_has_feature(vdev
,
1504 VIRTIO_F_VERSION_1
));
1506 if (version_id
>= 3)
1507 n
->status
= qemu_get_be16(f
);
1509 if (version_id
>= 4) {
1510 if (version_id
< 8) {
1511 n
->promisc
= qemu_get_be32(f
);
1512 n
->allmulti
= qemu_get_be32(f
);
1514 n
->promisc
= qemu_get_byte(f
);
1515 n
->allmulti
= qemu_get_byte(f
);
1519 if (version_id
>= 5) {
1520 n
->mac_table
.in_use
= qemu_get_be32(f
);
1521 /* MAC_TABLE_ENTRIES may be different from the saved image */
1522 if (n
->mac_table
.in_use
<= MAC_TABLE_ENTRIES
) {
1523 qemu_get_buffer(f
, n
->mac_table
.macs
,
1524 n
->mac_table
.in_use
* ETH_ALEN
);
1528 /* Overflow detected - can happen if source has a larger MAC table.
1529 * We simply set overflow flag so there's no need to maintain the
1530 * table of addresses, discard them all.
1531 * Note: 64 bit math to avoid integer overflow.
1533 for (i
= 0; i
< (int64_t)n
->mac_table
.in_use
* ETH_ALEN
; ++i
) {
1536 n
->mac_table
.multi_overflow
= n
->mac_table
.uni_overflow
= 1;
1537 n
->mac_table
.in_use
= 0;
1541 if (version_id
>= 6)
1542 qemu_get_buffer(f
, (uint8_t *)n
->vlans
, MAX_VLAN
>> 3);
1544 if (version_id
>= 7) {
1545 if (qemu_get_be32(f
) && !peer_has_vnet_hdr(n
)) {
1546 error_report("virtio-net: saved image requires vnet_hdr=on");
1551 if (version_id
>= 9) {
1552 n
->mac_table
.multi_overflow
= qemu_get_byte(f
);
1553 n
->mac_table
.uni_overflow
= qemu_get_byte(f
);
1556 if (version_id
>= 10) {
1557 n
->alluni
= qemu_get_byte(f
);
1558 n
->nomulti
= qemu_get_byte(f
);
1559 n
->nouni
= qemu_get_byte(f
);
1560 n
->nobcast
= qemu_get_byte(f
);
1563 if (version_id
>= 11) {
1564 if (qemu_get_byte(f
) && !peer_has_ufo(n
)) {
1565 error_report("virtio-net: saved image requires TUN_F_UFO support");
1570 if (n
->max_queues
> 1) {
1571 if (n
->max_queues
!= qemu_get_be16(f
)) {
1572 error_report("virtio-net: different max_queues ");
1576 n
->curr_queues
= qemu_get_be16(f
);
1577 if (n
->curr_queues
> n
->max_queues
) {
1578 error_report("virtio-net: curr_queues %x > max_queues %x",
1579 n
->curr_queues
, n
->max_queues
);
1582 for (i
= 1; i
< n
->curr_queues
; i
++) {
1583 n
->vqs
[i
].tx_waiting
= qemu_get_be32(f
);
1587 virtio_net_set_queues(n
);
1589 /* Find the first multicast entry in the saved MAC filter */
1590 for (i
= 0; i
< n
->mac_table
.in_use
; i
++) {
1591 if (n
->mac_table
.macs
[i
* ETH_ALEN
] & 1) {
1595 n
->mac_table
.first_multi
= i
;
1597 /* nc.link_down can't be migrated, so infer link_down according
1598 * to link status bit in n->status */
1599 link_down
= (n
->status
& VIRTIO_NET_S_LINK_UP
) == 0;
1600 for (i
= 0; i
< n
->max_queues
; i
++) {
1601 qemu_get_subqueue(n
->nic
, i
)->link_down
= link_down
;
1607 static NetClientInfo net_virtio_info
= {
1608 .type
= NET_CLIENT_OPTIONS_KIND_NIC
,
1609 .size
= sizeof(NICState
),
1610 .can_receive
= virtio_net_can_receive
,
1611 .receive
= virtio_net_receive
,
1612 .link_status_changed
= virtio_net_set_link_status
,
1613 .query_rx_filter
= virtio_net_query_rxfilter
,
1616 static bool virtio_net_guest_notifier_pending(VirtIODevice
*vdev
, int idx
)
1618 VirtIONet
*n
= VIRTIO_NET(vdev
);
1619 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1620 assert(n
->vhost_started
);
1621 return vhost_net_virtqueue_pending(get_vhost_net(nc
->peer
), idx
);
1624 static void virtio_net_guest_notifier_mask(VirtIODevice
*vdev
, int idx
,
1627 VirtIONet
*n
= VIRTIO_NET(vdev
);
1628 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1629 assert(n
->vhost_started
);
1630 vhost_net_virtqueue_mask(get_vhost_net(nc
->peer
),
1634 static void virtio_net_set_config_size(VirtIONet
*n
, uint64_t host_features
)
1636 int i
, config_size
= 0;
1637 virtio_add_feature(&host_features
, VIRTIO_NET_F_MAC
);
1638 for (i
= 0; feature_sizes
[i
].flags
!= 0; i
++) {
1639 if (host_features
& feature_sizes
[i
].flags
) {
1640 config_size
= MAX(feature_sizes
[i
].end
, config_size
);
1643 n
->config_size
= config_size
;
1646 void virtio_net_set_netclient_name(VirtIONet
*n
, const char *name
,
1650 * The name can be NULL, the netclient name will be type.x.
1652 assert(type
!= NULL
);
1654 g_free(n
->netclient_name
);
1655 g_free(n
->netclient_type
);
1656 n
->netclient_name
= g_strdup(name
);
1657 n
->netclient_type
= g_strdup(type
);
1660 static void virtio_net_device_realize(DeviceState
*dev
, Error
**errp
)
1662 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1663 VirtIONet
*n
= VIRTIO_NET(dev
);
1667 virtio_net_set_config_size(n
, n
->host_features
);
1668 virtio_init(vdev
, "virtio-net", VIRTIO_ID_NET
, n
->config_size
);
1670 n
->max_queues
= MAX(n
->nic_conf
.peers
.queues
, 1);
1671 if (n
->max_queues
* 2 + 1 > VIRTIO_QUEUE_MAX
) {
1672 error_setg(errp
, "Invalid number of queues (= %" PRIu32
"), "
1673 "must be a positive integer less than %d.",
1674 n
->max_queues
, (VIRTIO_QUEUE_MAX
- 1) / 2);
1675 virtio_cleanup(vdev
);
1678 n
->vqs
= g_malloc0(sizeof(VirtIONetQueue
) * n
->max_queues
);
1680 n
->tx_timeout
= n
->net_conf
.txtimer
;
1682 if (n
->net_conf
.tx
&& strcmp(n
->net_conf
.tx
, "timer")
1683 && strcmp(n
->net_conf
.tx
, "bh")) {
1684 error_report("virtio-net: "
1685 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
1687 error_report("Defaulting to \"bh\"");
1690 for (i
= 0; i
< n
->max_queues
; i
++) {
1691 virtio_net_add_queue(n
, i
);
1694 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
1695 qemu_macaddr_default_if_unset(&n
->nic_conf
.macaddr
);
1696 memcpy(&n
->mac
[0], &n
->nic_conf
.macaddr
, sizeof(n
->mac
));
1697 n
->status
= VIRTIO_NET_S_LINK_UP
;
1698 n
->announce_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
1699 virtio_net_announce_timer
, n
);
1701 if (n
->netclient_type
) {
1703 * Happen when virtio_net_set_netclient_name has been called.
1705 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
1706 n
->netclient_type
, n
->netclient_name
, n
);
1708 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
1709 object_get_typename(OBJECT(dev
)), dev
->id
, n
);
1712 peer_test_vnet_hdr(n
);
1713 if (peer_has_vnet_hdr(n
)) {
1714 for (i
= 0; i
< n
->max_queues
; i
++) {
1715 qemu_using_vnet_hdr(qemu_get_subqueue(n
->nic
, i
)->peer
, true);
1717 n
->host_hdr_len
= sizeof(struct virtio_net_hdr
);
1719 n
->host_hdr_len
= 0;
1722 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->nic_conf
.macaddr
.a
);
1724 n
->vqs
[0].tx_waiting
= 0;
1725 n
->tx_burst
= n
->net_conf
.txburst
;
1726 virtio_net_set_mrg_rx_bufs(n
, 0, 0);
1727 n
->promisc
= 1; /* for compatibility */
1729 n
->mac_table
.macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
1731 n
->vlans
= g_malloc0(MAX_VLAN
>> 3);
1733 nc
= qemu_get_queue(n
->nic
);
1734 nc
->rxfilter_notify_enabled
= 1;
1737 register_savevm(dev
, "virtio-net", -1, VIRTIO_NET_VM_VERSION
,
1738 virtio_net_save
, virtio_net_load
, n
);
1741 static void virtio_net_device_unrealize(DeviceState
*dev
, Error
**errp
)
1743 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1744 VirtIONet
*n
= VIRTIO_NET(dev
);
1747 /* This will stop vhost backend if appropriate. */
1748 virtio_net_set_status(vdev
, 0);
1750 unregister_savevm(dev
, "virtio-net", n
);
1752 g_free(n
->netclient_name
);
1753 n
->netclient_name
= NULL
;
1754 g_free(n
->netclient_type
);
1755 n
->netclient_type
= NULL
;
1757 g_free(n
->mac_table
.macs
);
1760 max_queues
= n
->multiqueue
? n
->max_queues
: 1;
1761 for (i
= 0; i
< max_queues
; i
++) {
1762 virtio_net_del_queue(n
, i
);
1765 timer_del(n
->announce_timer
);
1766 timer_free(n
->announce_timer
);
1768 qemu_del_nic(n
->nic
);
1769 virtio_cleanup(vdev
);
1772 static void virtio_net_instance_init(Object
*obj
)
1774 VirtIONet
*n
= VIRTIO_NET(obj
);
1777 * The default config_size is sizeof(struct virtio_net_config).
1778 * Can be overriden with virtio_net_set_config_size.
1780 n
->config_size
= sizeof(struct virtio_net_config
);
1781 device_add_bootindex_property(obj
, &n
->nic_conf
.bootindex
,
1782 "bootindex", "/ethernet-phy@0",
1786 static Property virtio_net_properties
[] = {
1787 DEFINE_PROP_BIT("csum", VirtIONet
, host_features
, VIRTIO_NET_F_CSUM
, true),
1788 DEFINE_PROP_BIT("guest_csum", VirtIONet
, host_features
,
1789 VIRTIO_NET_F_GUEST_CSUM
, true),
1790 DEFINE_PROP_BIT("gso", VirtIONet
, host_features
, VIRTIO_NET_F_GSO
, true),
1791 DEFINE_PROP_BIT("guest_tso4", VirtIONet
, host_features
,
1792 VIRTIO_NET_F_GUEST_TSO4
, true),
1793 DEFINE_PROP_BIT("guest_tso6", VirtIONet
, host_features
,
1794 VIRTIO_NET_F_GUEST_TSO6
, true),
1795 DEFINE_PROP_BIT("guest_ecn", VirtIONet
, host_features
,
1796 VIRTIO_NET_F_GUEST_ECN
, true),
1797 DEFINE_PROP_BIT("guest_ufo", VirtIONet
, host_features
,
1798 VIRTIO_NET_F_GUEST_UFO
, true),
1799 DEFINE_PROP_BIT("guest_announce", VirtIONet
, host_features
,
1800 VIRTIO_NET_F_GUEST_ANNOUNCE
, true),
1801 DEFINE_PROP_BIT("host_tso4", VirtIONet
, host_features
,
1802 VIRTIO_NET_F_HOST_TSO4
, true),
1803 DEFINE_PROP_BIT("host_tso6", VirtIONet
, host_features
,
1804 VIRTIO_NET_F_HOST_TSO6
, true),
1805 DEFINE_PROP_BIT("host_ecn", VirtIONet
, host_features
,
1806 VIRTIO_NET_F_HOST_ECN
, true),
1807 DEFINE_PROP_BIT("host_ufo", VirtIONet
, host_features
,
1808 VIRTIO_NET_F_HOST_UFO
, true),
1809 DEFINE_PROP_BIT("mrg_rxbuf", VirtIONet
, host_features
,
1810 VIRTIO_NET_F_MRG_RXBUF
, true),
1811 DEFINE_PROP_BIT("status", VirtIONet
, host_features
,
1812 VIRTIO_NET_F_STATUS
, true),
1813 DEFINE_PROP_BIT("ctrl_vq", VirtIONet
, host_features
,
1814 VIRTIO_NET_F_CTRL_VQ
, true),
1815 DEFINE_PROP_BIT("ctrl_rx", VirtIONet
, host_features
,
1816 VIRTIO_NET_F_CTRL_RX
, true),
1817 DEFINE_PROP_BIT("ctrl_vlan", VirtIONet
, host_features
,
1818 VIRTIO_NET_F_CTRL_VLAN
, true),
1819 DEFINE_PROP_BIT("ctrl_rx_extra", VirtIONet
, host_features
,
1820 VIRTIO_NET_F_CTRL_RX_EXTRA
, true),
1821 DEFINE_PROP_BIT("ctrl_mac_addr", VirtIONet
, host_features
,
1822 VIRTIO_NET_F_CTRL_MAC_ADDR
, true),
1823 DEFINE_PROP_BIT("ctrl_guest_offloads", VirtIONet
, host_features
,
1824 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
, true),
1825 DEFINE_PROP_BIT("mq", VirtIONet
, host_features
, VIRTIO_NET_F_MQ
, false),
1826 DEFINE_NIC_PROPERTIES(VirtIONet
, nic_conf
),
1827 DEFINE_PROP_UINT32("x-txtimer", VirtIONet
, net_conf
.txtimer
,
1829 DEFINE_PROP_INT32("x-txburst", VirtIONet
, net_conf
.txburst
, TX_BURST
),
1830 DEFINE_PROP_STRING("tx", VirtIONet
, net_conf
.tx
),
1831 DEFINE_PROP_END_OF_LIST(),
1834 static void virtio_net_class_init(ObjectClass
*klass
, void *data
)
1836 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1837 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
1839 dc
->props
= virtio_net_properties
;
1840 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
1841 vdc
->realize
= virtio_net_device_realize
;
1842 vdc
->unrealize
= virtio_net_device_unrealize
;
1843 vdc
->get_config
= virtio_net_get_config
;
1844 vdc
->set_config
= virtio_net_set_config
;
1845 vdc
->get_features
= virtio_net_get_features
;
1846 vdc
->set_features
= virtio_net_set_features
;
1847 vdc
->bad_features
= virtio_net_bad_features
;
1848 vdc
->reset
= virtio_net_reset
;
1849 vdc
->set_status
= virtio_net_set_status
;
1850 vdc
->guest_notifier_mask
= virtio_net_guest_notifier_mask
;
1851 vdc
->guest_notifier_pending
= virtio_net_guest_notifier_pending
;
1852 vdc
->load
= virtio_net_load_device
;
1853 vdc
->save
= virtio_net_save_device
;
1856 static const TypeInfo virtio_net_info
= {
1857 .name
= TYPE_VIRTIO_NET
,
1858 .parent
= TYPE_VIRTIO_DEVICE
,
1859 .instance_size
= sizeof(VirtIONet
),
1860 .instance_init
= virtio_net_instance_init
,
1861 .class_init
= virtio_net_class_init
,
1864 static void virtio_register_types(void)
1866 type_register_static(&virtio_net_info
);
1869 type_init(virtio_register_types
)