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/error.h"
26 #include "qapi/qapi-events-net.h"
27 #include "hw/virtio/virtio-access.h"
28 #include "migration/misc.h"
29 #include "standard-headers/linux/ethtool.h"
31 #define VIRTIO_NET_VM_VERSION 11
33 #define MAC_TABLE_ENTRIES 64
34 #define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
36 /* previously fixed value */
37 #define VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE 256
38 #define VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE 256
40 /* for now, only allow larger queues; with virtio-1, guest can downsize */
41 #define VIRTIO_NET_RX_QUEUE_MIN_SIZE VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE
42 #define VIRTIO_NET_TX_QUEUE_MIN_SIZE VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
45 * Calculate the number of bytes up to and including the given 'field' of
48 #define endof(container, field) \
49 (offsetof(container, field) + sizeof(((container *)0)->field))
51 typedef struct VirtIOFeature
{
56 static VirtIOFeature feature_sizes
[] = {
57 {.flags
= 1ULL << VIRTIO_NET_F_MAC
,
58 .end
= endof(struct virtio_net_config
, mac
)},
59 {.flags
= 1ULL << VIRTIO_NET_F_STATUS
,
60 .end
= endof(struct virtio_net_config
, status
)},
61 {.flags
= 1ULL << VIRTIO_NET_F_MQ
,
62 .end
= endof(struct virtio_net_config
, max_virtqueue_pairs
)},
63 {.flags
= 1ULL << VIRTIO_NET_F_MTU
,
64 .end
= endof(struct virtio_net_config
, mtu
)},
65 {.flags
= 1ULL << VIRTIO_NET_F_SPEED_DUPLEX
,
66 .end
= endof(struct virtio_net_config
, duplex
)},
70 static VirtIONetQueue
*virtio_net_get_subqueue(NetClientState
*nc
)
72 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
74 return &n
->vqs
[nc
->queue_index
];
77 static int vq2q(int queue_index
)
79 return queue_index
/ 2;
83 * - we could suppress RX interrupt if we were so inclined.
86 static void virtio_net_get_config(VirtIODevice
*vdev
, uint8_t *config
)
88 VirtIONet
*n
= VIRTIO_NET(vdev
);
89 struct virtio_net_config netcfg
;
91 virtio_stw_p(vdev
, &netcfg
.status
, n
->status
);
92 virtio_stw_p(vdev
, &netcfg
.max_virtqueue_pairs
, n
->max_queues
);
93 virtio_stw_p(vdev
, &netcfg
.mtu
, n
->net_conf
.mtu
);
94 memcpy(netcfg
.mac
, n
->mac
, ETH_ALEN
);
95 virtio_stl_p(vdev
, &netcfg
.speed
, n
->net_conf
.speed
);
96 netcfg
.duplex
= n
->net_conf
.duplex
;
97 memcpy(config
, &netcfg
, n
->config_size
);
100 static void virtio_net_set_config(VirtIODevice
*vdev
, const uint8_t *config
)
102 VirtIONet
*n
= VIRTIO_NET(vdev
);
103 struct virtio_net_config netcfg
= {};
105 memcpy(&netcfg
, config
, n
->config_size
);
107 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_MAC_ADDR
) &&
108 !virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
) &&
109 memcmp(netcfg
.mac
, n
->mac
, ETH_ALEN
)) {
110 memcpy(n
->mac
, netcfg
.mac
, ETH_ALEN
);
111 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
115 static bool virtio_net_started(VirtIONet
*n
, uint8_t status
)
117 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
118 return (status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
119 (n
->status
& VIRTIO_NET_S_LINK_UP
) && vdev
->vm_running
;
122 static void virtio_net_announce_timer(void *opaque
)
124 VirtIONet
*n
= opaque
;
125 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
127 n
->announce_counter
--;
128 n
->status
|= VIRTIO_NET_S_ANNOUNCE
;
129 virtio_notify_config(vdev
);
132 static void virtio_net_vhost_status(VirtIONet
*n
, uint8_t status
)
134 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
135 NetClientState
*nc
= qemu_get_queue(n
->nic
);
136 int queues
= n
->multiqueue
? n
->max_queues
: 1;
138 if (!get_vhost_net(nc
->peer
)) {
142 if ((virtio_net_started(n
, status
) && !nc
->peer
->link_down
) ==
143 !!n
->vhost_started
) {
146 if (!n
->vhost_started
) {
149 if (n
->needs_vnet_hdr_swap
) {
150 error_report("backend does not support %s vnet headers; "
151 "falling back on userspace virtio",
152 virtio_is_big_endian(vdev
) ? "BE" : "LE");
156 /* Any packets outstanding? Purge them to avoid touching rings
157 * when vhost is running.
159 for (i
= 0; i
< queues
; i
++) {
160 NetClientState
*qnc
= qemu_get_subqueue(n
->nic
, i
);
162 /* Purge both directions: TX and RX. */
163 qemu_net_queue_purge(qnc
->peer
->incoming_queue
, qnc
);
164 qemu_net_queue_purge(qnc
->incoming_queue
, qnc
->peer
);
167 if (virtio_has_feature(vdev
->guest_features
, VIRTIO_NET_F_MTU
)) {
168 r
= vhost_net_set_mtu(get_vhost_net(nc
->peer
), n
->net_conf
.mtu
);
170 error_report("%uBytes MTU not supported by the backend",
177 n
->vhost_started
= 1;
178 r
= vhost_net_start(vdev
, n
->nic
->ncs
, queues
);
180 error_report("unable to start vhost net: %d: "
181 "falling back on userspace virtio", -r
);
182 n
->vhost_started
= 0;
185 vhost_net_stop(vdev
, n
->nic
->ncs
, queues
);
186 n
->vhost_started
= 0;
190 static int virtio_net_set_vnet_endian_one(VirtIODevice
*vdev
,
191 NetClientState
*peer
,
194 if (virtio_is_big_endian(vdev
)) {
195 return qemu_set_vnet_be(peer
, enable
);
197 return qemu_set_vnet_le(peer
, enable
);
201 static bool virtio_net_set_vnet_endian(VirtIODevice
*vdev
, NetClientState
*ncs
,
202 int queues
, bool enable
)
206 for (i
= 0; i
< queues
; i
++) {
207 if (virtio_net_set_vnet_endian_one(vdev
, ncs
[i
].peer
, enable
) < 0 &&
210 virtio_net_set_vnet_endian_one(vdev
, ncs
[i
].peer
, false);
220 static void virtio_net_vnet_endian_status(VirtIONet
*n
, uint8_t status
)
222 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
223 int queues
= n
->multiqueue
? n
->max_queues
: 1;
225 if (virtio_net_started(n
, status
)) {
226 /* Before using the device, we tell the network backend about the
227 * endianness to use when parsing vnet headers. If the backend
228 * can't do it, we fallback onto fixing the headers in the core
231 n
->needs_vnet_hdr_swap
= virtio_net_set_vnet_endian(vdev
, n
->nic
->ncs
,
233 } else if (virtio_net_started(n
, vdev
->status
)) {
234 /* After using the device, we need to reset the network backend to
235 * the default (guest native endianness), otherwise the guest may
236 * lose network connectivity if it is rebooted into a different
239 virtio_net_set_vnet_endian(vdev
, n
->nic
->ncs
, queues
, false);
243 static void virtio_net_drop_tx_queue_data(VirtIODevice
*vdev
, VirtQueue
*vq
)
245 unsigned int dropped
= virtqueue_drop_all(vq
);
247 virtio_notify(vdev
, vq
);
251 static void virtio_net_set_status(struct VirtIODevice
*vdev
, uint8_t status
)
253 VirtIONet
*n
= VIRTIO_NET(vdev
);
256 uint8_t queue_status
;
258 virtio_net_vnet_endian_status(n
, status
);
259 virtio_net_vhost_status(n
, status
);
261 for (i
= 0; i
< n
->max_queues
; i
++) {
262 NetClientState
*ncs
= qemu_get_subqueue(n
->nic
, i
);
266 if ((!n
->multiqueue
&& i
!= 0) || i
>= n
->curr_queues
) {
269 queue_status
= status
;
272 virtio_net_started(n
, queue_status
) && !n
->vhost_started
;
275 qemu_flush_queued_packets(ncs
);
278 if (!q
->tx_waiting
) {
284 timer_mod(q
->tx_timer
,
285 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
287 qemu_bh_schedule(q
->tx_bh
);
291 timer_del(q
->tx_timer
);
293 qemu_bh_cancel(q
->tx_bh
);
295 if ((n
->status
& VIRTIO_NET_S_LINK_UP
) == 0 &&
296 (queue_status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
298 /* if tx is waiting we are likely have some packets in tx queue
299 * and disabled notification */
301 virtio_queue_set_notification(q
->tx_vq
, 1);
302 virtio_net_drop_tx_queue_data(vdev
, q
->tx_vq
);
308 static void virtio_net_set_link_status(NetClientState
*nc
)
310 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
311 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
312 uint16_t old_status
= n
->status
;
315 n
->status
&= ~VIRTIO_NET_S_LINK_UP
;
317 n
->status
|= VIRTIO_NET_S_LINK_UP
;
319 if (n
->status
!= old_status
)
320 virtio_notify_config(vdev
);
322 virtio_net_set_status(vdev
, vdev
->status
);
325 static void rxfilter_notify(NetClientState
*nc
)
327 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
329 if (nc
->rxfilter_notify_enabled
) {
330 gchar
*path
= object_get_canonical_path(OBJECT(n
->qdev
));
331 qapi_event_send_nic_rx_filter_changed(!!n
->netclient_name
,
332 n
->netclient_name
, path
, &error_abort
);
335 /* disable event notification to avoid events flooding */
336 nc
->rxfilter_notify_enabled
= 0;
340 static intList
*get_vlan_table(VirtIONet
*n
)
342 intList
*list
, *entry
;
346 for (i
= 0; i
< MAX_VLAN
>> 5; i
++) {
347 for (j
= 0; n
->vlans
[i
] && j
<= 0x1f; j
++) {
348 if (n
->vlans
[i
] & (1U << j
)) {
349 entry
= g_malloc0(sizeof(*entry
));
350 entry
->value
= (i
<< 5) + j
;
360 static RxFilterInfo
*virtio_net_query_rxfilter(NetClientState
*nc
)
362 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
363 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
365 strList
*str_list
, *entry
;
368 info
= g_malloc0(sizeof(*info
));
369 info
->name
= g_strdup(nc
->name
);
370 info
->promiscuous
= n
->promisc
;
373 info
->unicast
= RX_STATE_NONE
;
374 } else if (n
->alluni
) {
375 info
->unicast
= RX_STATE_ALL
;
377 info
->unicast
= RX_STATE_NORMAL
;
381 info
->multicast
= RX_STATE_NONE
;
382 } else if (n
->allmulti
) {
383 info
->multicast
= RX_STATE_ALL
;
385 info
->multicast
= RX_STATE_NORMAL
;
388 info
->broadcast_allowed
= n
->nobcast
;
389 info
->multicast_overflow
= n
->mac_table
.multi_overflow
;
390 info
->unicast_overflow
= n
->mac_table
.uni_overflow
;
392 info
->main_mac
= qemu_mac_strdup_printf(n
->mac
);
395 for (i
= 0; i
< n
->mac_table
.first_multi
; i
++) {
396 entry
= g_malloc0(sizeof(*entry
));
397 entry
->value
= qemu_mac_strdup_printf(n
->mac_table
.macs
+ i
* ETH_ALEN
);
398 entry
->next
= str_list
;
401 info
->unicast_table
= str_list
;
404 for (i
= n
->mac_table
.first_multi
; i
< n
->mac_table
.in_use
; i
++) {
405 entry
= g_malloc0(sizeof(*entry
));
406 entry
->value
= qemu_mac_strdup_printf(n
->mac_table
.macs
+ i
* ETH_ALEN
);
407 entry
->next
= str_list
;
410 info
->multicast_table
= str_list
;
411 info
->vlan_table
= get_vlan_table(n
);
413 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_VLAN
)) {
414 info
->vlan
= RX_STATE_ALL
;
415 } else if (!info
->vlan_table
) {
416 info
->vlan
= RX_STATE_NONE
;
418 info
->vlan
= RX_STATE_NORMAL
;
421 /* enable event notification after query */
422 nc
->rxfilter_notify_enabled
= 1;
427 static void virtio_net_reset(VirtIODevice
*vdev
)
429 VirtIONet
*n
= VIRTIO_NET(vdev
);
431 /* Reset back to compatibility mode */
438 /* multiqueue is disabled by default */
440 timer_del(n
->announce_timer
);
441 n
->announce_counter
= 0;
442 n
->status
&= ~VIRTIO_NET_S_ANNOUNCE
;
444 /* Flush any MAC and VLAN filter table state */
445 n
->mac_table
.in_use
= 0;
446 n
->mac_table
.first_multi
= 0;
447 n
->mac_table
.multi_overflow
= 0;
448 n
->mac_table
.uni_overflow
= 0;
449 memset(n
->mac_table
.macs
, 0, MAC_TABLE_ENTRIES
* ETH_ALEN
);
450 memcpy(&n
->mac
[0], &n
->nic
->conf
->macaddr
, sizeof(n
->mac
));
451 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
452 memset(n
->vlans
, 0, MAX_VLAN
>> 3);
455 static void peer_test_vnet_hdr(VirtIONet
*n
)
457 NetClientState
*nc
= qemu_get_queue(n
->nic
);
462 n
->has_vnet_hdr
= qemu_has_vnet_hdr(nc
->peer
);
465 static int peer_has_vnet_hdr(VirtIONet
*n
)
467 return n
->has_vnet_hdr
;
470 static int peer_has_ufo(VirtIONet
*n
)
472 if (!peer_has_vnet_hdr(n
))
475 n
->has_ufo
= qemu_has_ufo(qemu_get_queue(n
->nic
)->peer
);
480 static void virtio_net_set_mrg_rx_bufs(VirtIONet
*n
, int mergeable_rx_bufs
,
486 n
->mergeable_rx_bufs
= mergeable_rx_bufs
;
489 n
->guest_hdr_len
= sizeof(struct virtio_net_hdr_mrg_rxbuf
);
491 n
->guest_hdr_len
= n
->mergeable_rx_bufs
?
492 sizeof(struct virtio_net_hdr_mrg_rxbuf
) :
493 sizeof(struct virtio_net_hdr
);
496 for (i
= 0; i
< n
->max_queues
; i
++) {
497 nc
= qemu_get_subqueue(n
->nic
, i
);
499 if (peer_has_vnet_hdr(n
) &&
500 qemu_has_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
)) {
501 qemu_set_vnet_hdr_len(nc
->peer
, n
->guest_hdr_len
);
502 n
->host_hdr_len
= n
->guest_hdr_len
;
507 static int virtio_net_max_tx_queue_size(VirtIONet
*n
)
509 NetClientState
*peer
= n
->nic_conf
.peers
.ncs
[0];
512 * Backends other than vhost-user don't support max queue size.
515 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
;
518 if (peer
->info
->type
!= NET_CLIENT_DRIVER_VHOST_USER
) {
519 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
;
522 return VIRTQUEUE_MAX_SIZE
;
525 static int peer_attach(VirtIONet
*n
, int index
)
527 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
533 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
) {
534 vhost_set_vring_enable(nc
->peer
, 1);
537 if (nc
->peer
->info
->type
!= NET_CLIENT_DRIVER_TAP
) {
541 if (n
->max_queues
== 1) {
545 return tap_enable(nc
->peer
);
548 static int peer_detach(VirtIONet
*n
, int index
)
550 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
556 if (nc
->peer
->info
->type
== NET_CLIENT_DRIVER_VHOST_USER
) {
557 vhost_set_vring_enable(nc
->peer
, 0);
560 if (nc
->peer
->info
->type
!= NET_CLIENT_DRIVER_TAP
) {
564 return tap_disable(nc
->peer
);
567 static void virtio_net_set_queues(VirtIONet
*n
)
572 if (n
->nic
->peer_deleted
) {
576 for (i
= 0; i
< n
->max_queues
; i
++) {
577 if (i
< n
->curr_queues
) {
578 r
= peer_attach(n
, i
);
581 r
= peer_detach(n
, i
);
587 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
);
589 static uint64_t virtio_net_get_features(VirtIODevice
*vdev
, uint64_t features
,
592 VirtIONet
*n
= VIRTIO_NET(vdev
);
593 NetClientState
*nc
= qemu_get_queue(n
->nic
);
595 /* Firstly sync all virtio-net possible supported features */
596 features
|= n
->host_features
;
598 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
600 if (!peer_has_vnet_hdr(n
)) {
601 virtio_clear_feature(&features
, VIRTIO_NET_F_CSUM
);
602 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
603 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
604 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
606 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_CSUM
);
607 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO4
);
608 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_TSO6
);
609 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_ECN
);
612 if (!peer_has_vnet_hdr(n
) || !peer_has_ufo(n
)) {
613 virtio_clear_feature(&features
, VIRTIO_NET_F_GUEST_UFO
);
614 virtio_clear_feature(&features
, VIRTIO_NET_F_HOST_UFO
);
617 if (!get_vhost_net(nc
->peer
)) {
620 features
= vhost_net_get_features(get_vhost_net(nc
->peer
), features
);
621 vdev
->backend_features
= features
;
623 if (n
->mtu_bypass_backend
&&
624 (n
->host_features
& 1ULL << VIRTIO_NET_F_MTU
)) {
625 features
|= (1ULL << VIRTIO_NET_F_MTU
);
631 static uint64_t virtio_net_bad_features(VirtIODevice
*vdev
)
633 uint64_t features
= 0;
635 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
637 virtio_add_feature(&features
, VIRTIO_NET_F_MAC
);
638 virtio_add_feature(&features
, VIRTIO_NET_F_CSUM
);
639 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO4
);
640 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_TSO6
);
641 virtio_add_feature(&features
, VIRTIO_NET_F_HOST_ECN
);
646 static void virtio_net_apply_guest_offloads(VirtIONet
*n
)
648 qemu_set_offload(qemu_get_queue(n
->nic
)->peer
,
649 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_CSUM
)),
650 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO4
)),
651 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_TSO6
)),
652 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_ECN
)),
653 !!(n
->curr_guest_offloads
& (1ULL << VIRTIO_NET_F_GUEST_UFO
)));
656 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features
)
658 static const uint64_t guest_offloads_mask
=
659 (1ULL << VIRTIO_NET_F_GUEST_CSUM
) |
660 (1ULL << VIRTIO_NET_F_GUEST_TSO4
) |
661 (1ULL << VIRTIO_NET_F_GUEST_TSO6
) |
662 (1ULL << VIRTIO_NET_F_GUEST_ECN
) |
663 (1ULL << VIRTIO_NET_F_GUEST_UFO
);
665 return guest_offloads_mask
& features
;
668 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet
*n
)
670 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
671 return virtio_net_guest_offloads_by_features(vdev
->guest_features
);
674 static void virtio_net_set_features(VirtIODevice
*vdev
, uint64_t features
)
676 VirtIONet
*n
= VIRTIO_NET(vdev
);
679 if (n
->mtu_bypass_backend
&&
680 !virtio_has_feature(vdev
->backend_features
, VIRTIO_NET_F_MTU
)) {
681 features
&= ~(1ULL << VIRTIO_NET_F_MTU
);
684 virtio_net_set_multiqueue(n
,
685 virtio_has_feature(features
, VIRTIO_NET_F_MQ
));
687 virtio_net_set_mrg_rx_bufs(n
,
688 virtio_has_feature(features
,
689 VIRTIO_NET_F_MRG_RXBUF
),
690 virtio_has_feature(features
,
691 VIRTIO_F_VERSION_1
));
693 if (n
->has_vnet_hdr
) {
694 n
->curr_guest_offloads
=
695 virtio_net_guest_offloads_by_features(features
);
696 virtio_net_apply_guest_offloads(n
);
699 for (i
= 0; i
< n
->max_queues
; i
++) {
700 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, i
);
702 if (!get_vhost_net(nc
->peer
)) {
705 vhost_net_ack_features(get_vhost_net(nc
->peer
), features
);
708 if (virtio_has_feature(features
, VIRTIO_NET_F_CTRL_VLAN
)) {
709 memset(n
->vlans
, 0, MAX_VLAN
>> 3);
711 memset(n
->vlans
, 0xff, MAX_VLAN
>> 3);
715 static int virtio_net_handle_rx_mode(VirtIONet
*n
, uint8_t cmd
,
716 struct iovec
*iov
, unsigned int iov_cnt
)
720 NetClientState
*nc
= qemu_get_queue(n
->nic
);
722 s
= iov_to_buf(iov
, iov_cnt
, 0, &on
, sizeof(on
));
723 if (s
!= sizeof(on
)) {
724 return VIRTIO_NET_ERR
;
727 if (cmd
== VIRTIO_NET_CTRL_RX_PROMISC
) {
729 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLMULTI
) {
731 } else if (cmd
== VIRTIO_NET_CTRL_RX_ALLUNI
) {
733 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOMULTI
) {
735 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOUNI
) {
737 } else if (cmd
== VIRTIO_NET_CTRL_RX_NOBCAST
) {
740 return VIRTIO_NET_ERR
;
745 return VIRTIO_NET_OK
;
748 static int virtio_net_handle_offloads(VirtIONet
*n
, uint8_t cmd
,
749 struct iovec
*iov
, unsigned int iov_cnt
)
751 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
755 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
756 return VIRTIO_NET_ERR
;
759 s
= iov_to_buf(iov
, iov_cnt
, 0, &offloads
, sizeof(offloads
));
760 if (s
!= sizeof(offloads
)) {
761 return VIRTIO_NET_ERR
;
764 if (cmd
== VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET
) {
765 uint64_t supported_offloads
;
767 offloads
= virtio_ldq_p(vdev
, &offloads
);
769 if (!n
->has_vnet_hdr
) {
770 return VIRTIO_NET_ERR
;
773 supported_offloads
= virtio_net_supported_guest_offloads(n
);
774 if (offloads
& ~supported_offloads
) {
775 return VIRTIO_NET_ERR
;
778 n
->curr_guest_offloads
= offloads
;
779 virtio_net_apply_guest_offloads(n
);
781 return VIRTIO_NET_OK
;
783 return VIRTIO_NET_ERR
;
787 static int virtio_net_handle_mac(VirtIONet
*n
, uint8_t cmd
,
788 struct iovec
*iov
, unsigned int iov_cnt
)
790 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
791 struct virtio_net_ctrl_mac mac_data
;
793 NetClientState
*nc
= qemu_get_queue(n
->nic
);
795 if (cmd
== VIRTIO_NET_CTRL_MAC_ADDR_SET
) {
796 if (iov_size(iov
, iov_cnt
) != sizeof(n
->mac
)) {
797 return VIRTIO_NET_ERR
;
799 s
= iov_to_buf(iov
, iov_cnt
, 0, &n
->mac
, sizeof(n
->mac
));
800 assert(s
== sizeof(n
->mac
));
801 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->mac
);
804 return VIRTIO_NET_OK
;
807 if (cmd
!= VIRTIO_NET_CTRL_MAC_TABLE_SET
) {
808 return VIRTIO_NET_ERR
;
813 uint8_t uni_overflow
= 0;
814 uint8_t multi_overflow
= 0;
815 uint8_t *macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
817 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
818 sizeof(mac_data
.entries
));
819 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
820 if (s
!= sizeof(mac_data
.entries
)) {
823 iov_discard_front(&iov
, &iov_cnt
, s
);
825 if (mac_data
.entries
* ETH_ALEN
> iov_size(iov
, iov_cnt
)) {
829 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
) {
830 s
= iov_to_buf(iov
, iov_cnt
, 0, macs
,
831 mac_data
.entries
* ETH_ALEN
);
832 if (s
!= mac_data
.entries
* ETH_ALEN
) {
835 in_use
+= mac_data
.entries
;
840 iov_discard_front(&iov
, &iov_cnt
, mac_data
.entries
* ETH_ALEN
);
842 first_multi
= in_use
;
844 s
= iov_to_buf(iov
, iov_cnt
, 0, &mac_data
.entries
,
845 sizeof(mac_data
.entries
));
846 mac_data
.entries
= virtio_ldl_p(vdev
, &mac_data
.entries
);
847 if (s
!= sizeof(mac_data
.entries
)) {
851 iov_discard_front(&iov
, &iov_cnt
, s
);
853 if (mac_data
.entries
* ETH_ALEN
!= iov_size(iov
, iov_cnt
)) {
857 if (mac_data
.entries
<= MAC_TABLE_ENTRIES
- in_use
) {
858 s
= iov_to_buf(iov
, iov_cnt
, 0, &macs
[in_use
* ETH_ALEN
],
859 mac_data
.entries
* ETH_ALEN
);
860 if (s
!= mac_data
.entries
* ETH_ALEN
) {
863 in_use
+= mac_data
.entries
;
868 n
->mac_table
.in_use
= in_use
;
869 n
->mac_table
.first_multi
= first_multi
;
870 n
->mac_table
.uni_overflow
= uni_overflow
;
871 n
->mac_table
.multi_overflow
= multi_overflow
;
872 memcpy(n
->mac_table
.macs
, macs
, MAC_TABLE_ENTRIES
* ETH_ALEN
);
876 return VIRTIO_NET_OK
;
880 return VIRTIO_NET_ERR
;
883 static int virtio_net_handle_vlan_table(VirtIONet
*n
, uint8_t cmd
,
884 struct iovec
*iov
, unsigned int iov_cnt
)
886 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
889 NetClientState
*nc
= qemu_get_queue(n
->nic
);
891 s
= iov_to_buf(iov
, iov_cnt
, 0, &vid
, sizeof(vid
));
892 vid
= virtio_lduw_p(vdev
, &vid
);
893 if (s
!= sizeof(vid
)) {
894 return VIRTIO_NET_ERR
;
898 return VIRTIO_NET_ERR
;
900 if (cmd
== VIRTIO_NET_CTRL_VLAN_ADD
)
901 n
->vlans
[vid
>> 5] |= (1U << (vid
& 0x1f));
902 else if (cmd
== VIRTIO_NET_CTRL_VLAN_DEL
)
903 n
->vlans
[vid
>> 5] &= ~(1U << (vid
& 0x1f));
905 return VIRTIO_NET_ERR
;
909 return VIRTIO_NET_OK
;
912 static int virtio_net_handle_announce(VirtIONet
*n
, uint8_t cmd
,
913 struct iovec
*iov
, unsigned int iov_cnt
)
915 if (cmd
== VIRTIO_NET_CTRL_ANNOUNCE_ACK
&&
916 n
->status
& VIRTIO_NET_S_ANNOUNCE
) {
917 n
->status
&= ~VIRTIO_NET_S_ANNOUNCE
;
918 if (n
->announce_counter
) {
919 timer_mod(n
->announce_timer
,
920 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
921 self_announce_delay(n
->announce_counter
));
923 return VIRTIO_NET_OK
;
925 return VIRTIO_NET_ERR
;
929 static int virtio_net_handle_mq(VirtIONet
*n
, uint8_t cmd
,
930 struct iovec
*iov
, unsigned int iov_cnt
)
932 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
933 struct virtio_net_ctrl_mq mq
;
937 s
= iov_to_buf(iov
, iov_cnt
, 0, &mq
, sizeof(mq
));
938 if (s
!= sizeof(mq
)) {
939 return VIRTIO_NET_ERR
;
942 if (cmd
!= VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET
) {
943 return VIRTIO_NET_ERR
;
946 queues
= virtio_lduw_p(vdev
, &mq
.virtqueue_pairs
);
948 if (queues
< VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN
||
949 queues
> VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX
||
950 queues
> n
->max_queues
||
952 return VIRTIO_NET_ERR
;
955 n
->curr_queues
= queues
;
956 /* stop the backend before changing the number of queues to avoid handling a
958 virtio_net_set_status(vdev
, vdev
->status
);
959 virtio_net_set_queues(n
);
961 return VIRTIO_NET_OK
;
964 static void virtio_net_handle_ctrl(VirtIODevice
*vdev
, VirtQueue
*vq
)
966 VirtIONet
*n
= VIRTIO_NET(vdev
);
967 struct virtio_net_ctrl_hdr ctrl
;
968 virtio_net_ctrl_ack status
= VIRTIO_NET_ERR
;
969 VirtQueueElement
*elem
;
971 struct iovec
*iov
, *iov2
;
972 unsigned int iov_cnt
;
975 elem
= virtqueue_pop(vq
, sizeof(VirtQueueElement
));
979 if (iov_size(elem
->in_sg
, elem
->in_num
) < sizeof(status
) ||
980 iov_size(elem
->out_sg
, elem
->out_num
) < sizeof(ctrl
)) {
981 virtio_error(vdev
, "virtio-net ctrl missing headers");
982 virtqueue_detach_element(vq
, elem
, 0);
987 iov_cnt
= elem
->out_num
;
988 iov2
= iov
= g_memdup(elem
->out_sg
, sizeof(struct iovec
) * elem
->out_num
);
989 s
= iov_to_buf(iov
, iov_cnt
, 0, &ctrl
, sizeof(ctrl
));
990 iov_discard_front(&iov
, &iov_cnt
, sizeof(ctrl
));
991 if (s
!= sizeof(ctrl
)) {
992 status
= VIRTIO_NET_ERR
;
993 } else if (ctrl
.class == VIRTIO_NET_CTRL_RX
) {
994 status
= virtio_net_handle_rx_mode(n
, ctrl
.cmd
, iov
, iov_cnt
);
995 } else if (ctrl
.class == VIRTIO_NET_CTRL_MAC
) {
996 status
= virtio_net_handle_mac(n
, ctrl
.cmd
, iov
, iov_cnt
);
997 } else if (ctrl
.class == VIRTIO_NET_CTRL_VLAN
) {
998 status
= virtio_net_handle_vlan_table(n
, ctrl
.cmd
, iov
, iov_cnt
);
999 } else if (ctrl
.class == VIRTIO_NET_CTRL_ANNOUNCE
) {
1000 status
= virtio_net_handle_announce(n
, ctrl
.cmd
, iov
, iov_cnt
);
1001 } else if (ctrl
.class == VIRTIO_NET_CTRL_MQ
) {
1002 status
= virtio_net_handle_mq(n
, ctrl
.cmd
, iov
, iov_cnt
);
1003 } else if (ctrl
.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS
) {
1004 status
= virtio_net_handle_offloads(n
, ctrl
.cmd
, iov
, iov_cnt
);
1007 s
= iov_from_buf(elem
->in_sg
, elem
->in_num
, 0, &status
, sizeof(status
));
1008 assert(s
== sizeof(status
));
1010 virtqueue_push(vq
, elem
, sizeof(status
));
1011 virtio_notify(vdev
, vq
);
1019 static void virtio_net_handle_rx(VirtIODevice
*vdev
, VirtQueue
*vq
)
1021 VirtIONet
*n
= VIRTIO_NET(vdev
);
1022 int queue_index
= vq2q(virtio_get_queue_index(vq
));
1024 qemu_flush_queued_packets(qemu_get_subqueue(n
->nic
, queue_index
));
1027 static int virtio_net_can_receive(NetClientState
*nc
)
1029 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1030 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1031 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1033 if (!vdev
->vm_running
) {
1037 if (nc
->queue_index
>= n
->curr_queues
) {
1041 if (!virtio_queue_ready(q
->rx_vq
) ||
1042 !(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1049 static int virtio_net_has_buffers(VirtIONetQueue
*q
, int bufsize
)
1051 VirtIONet
*n
= q
->n
;
1052 if (virtio_queue_empty(q
->rx_vq
) ||
1053 (n
->mergeable_rx_bufs
&&
1054 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
1055 virtio_queue_set_notification(q
->rx_vq
, 1);
1057 /* To avoid a race condition where the guest has made some buffers
1058 * available after the above check but before notification was
1059 * enabled, check for available buffers again.
1061 if (virtio_queue_empty(q
->rx_vq
) ||
1062 (n
->mergeable_rx_bufs
&&
1063 !virtqueue_avail_bytes(q
->rx_vq
, bufsize
, 0))) {
1068 virtio_queue_set_notification(q
->rx_vq
, 0);
1072 static void virtio_net_hdr_swap(VirtIODevice
*vdev
, struct virtio_net_hdr
*hdr
)
1074 virtio_tswap16s(vdev
, &hdr
->hdr_len
);
1075 virtio_tswap16s(vdev
, &hdr
->gso_size
);
1076 virtio_tswap16s(vdev
, &hdr
->csum_start
);
1077 virtio_tswap16s(vdev
, &hdr
->csum_offset
);
1080 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
1081 * it never finds out that the packets don't have valid checksums. This
1082 * causes dhclient to get upset. Fedora's carried a patch for ages to
1083 * fix this with Xen but it hasn't appeared in an upstream release of
1086 * To avoid breaking existing guests, we catch udp packets and add
1087 * checksums. This is terrible but it's better than hacking the guest
1090 * N.B. if we introduce a zero-copy API, this operation is no longer free so
1091 * we should provide a mechanism to disable it to avoid polluting the host
1094 static void work_around_broken_dhclient(struct virtio_net_hdr
*hdr
,
1095 uint8_t *buf
, size_t size
)
1097 if ((hdr
->flags
& VIRTIO_NET_HDR_F_NEEDS_CSUM
) && /* missing csum */
1098 (size
> 27 && size
< 1500) && /* normal sized MTU */
1099 (buf
[12] == 0x08 && buf
[13] == 0x00) && /* ethertype == IPv4 */
1100 (buf
[23] == 17) && /* ip.protocol == UDP */
1101 (buf
[34] == 0 && buf
[35] == 67)) { /* udp.srcport == bootps */
1102 net_checksum_calculate(buf
, size
);
1103 hdr
->flags
&= ~VIRTIO_NET_HDR_F_NEEDS_CSUM
;
1107 static void receive_header(VirtIONet
*n
, const struct iovec
*iov
, int iov_cnt
,
1108 const void *buf
, size_t size
)
1110 if (n
->has_vnet_hdr
) {
1111 /* FIXME this cast is evil */
1112 void *wbuf
= (void *)buf
;
1113 work_around_broken_dhclient(wbuf
, wbuf
+ n
->host_hdr_len
,
1114 size
- n
->host_hdr_len
);
1116 if (n
->needs_vnet_hdr_swap
) {
1117 virtio_net_hdr_swap(VIRTIO_DEVICE(n
), wbuf
);
1119 iov_from_buf(iov
, iov_cnt
, 0, buf
, sizeof(struct virtio_net_hdr
));
1121 struct virtio_net_hdr hdr
= {
1123 .gso_type
= VIRTIO_NET_HDR_GSO_NONE
1125 iov_from_buf(iov
, iov_cnt
, 0, &hdr
, sizeof hdr
);
1129 static int receive_filter(VirtIONet
*n
, const uint8_t *buf
, int size
)
1131 static const uint8_t bcast
[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1132 static const uint8_t vlan
[] = {0x81, 0x00};
1133 uint8_t *ptr
= (uint8_t *)buf
;
1139 ptr
+= n
->host_hdr_len
;
1141 if (!memcmp(&ptr
[12], vlan
, sizeof(vlan
))) {
1142 int vid
= lduw_be_p(ptr
+ 14) & 0xfff;
1143 if (!(n
->vlans
[vid
>> 5] & (1U << (vid
& 0x1f))))
1147 if (ptr
[0] & 1) { // multicast
1148 if (!memcmp(ptr
, bcast
, sizeof(bcast
))) {
1150 } else if (n
->nomulti
) {
1152 } else if (n
->allmulti
|| n
->mac_table
.multi_overflow
) {
1156 for (i
= n
->mac_table
.first_multi
; i
< n
->mac_table
.in_use
; i
++) {
1157 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
1164 } else if (n
->alluni
|| n
->mac_table
.uni_overflow
) {
1166 } else if (!memcmp(ptr
, n
->mac
, ETH_ALEN
)) {
1170 for (i
= 0; i
< n
->mac_table
.first_multi
; i
++) {
1171 if (!memcmp(ptr
, &n
->mac_table
.macs
[i
* ETH_ALEN
], ETH_ALEN
)) {
1180 static ssize_t
virtio_net_receive_rcu(NetClientState
*nc
, const uint8_t *buf
,
1183 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1184 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1185 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1186 struct iovec mhdr_sg
[VIRTQUEUE_MAX_SIZE
];
1187 struct virtio_net_hdr_mrg_rxbuf mhdr
;
1188 unsigned mhdr_cnt
= 0;
1189 size_t offset
, i
, guest_offset
;
1191 if (!virtio_net_can_receive(nc
)) {
1195 /* hdr_len refers to the header we supply to the guest */
1196 if (!virtio_net_has_buffers(q
, size
+ n
->guest_hdr_len
- n
->host_hdr_len
)) {
1200 if (!receive_filter(n
, buf
, size
))
1205 while (offset
< size
) {
1206 VirtQueueElement
*elem
;
1208 const struct iovec
*sg
;
1212 elem
= virtqueue_pop(q
->rx_vq
, sizeof(VirtQueueElement
));
1215 virtio_error(vdev
, "virtio-net unexpected empty queue: "
1216 "i %zd mergeable %d offset %zd, size %zd, "
1217 "guest hdr len %zd, host hdr len %zd "
1218 "guest features 0x%" PRIx64
,
1219 i
, n
->mergeable_rx_bufs
, offset
, size
,
1220 n
->guest_hdr_len
, n
->host_hdr_len
,
1221 vdev
->guest_features
);
1226 if (elem
->in_num
< 1) {
1228 "virtio-net receive queue contains no in buffers");
1229 virtqueue_detach_element(q
->rx_vq
, elem
, 0);
1236 assert(offset
== 0);
1237 if (n
->mergeable_rx_bufs
) {
1238 mhdr_cnt
= iov_copy(mhdr_sg
, ARRAY_SIZE(mhdr_sg
),
1240 offsetof(typeof(mhdr
), num_buffers
),
1241 sizeof(mhdr
.num_buffers
));
1244 receive_header(n
, sg
, elem
->in_num
, buf
, size
);
1245 offset
= n
->host_hdr_len
;
1246 total
+= n
->guest_hdr_len
;
1247 guest_offset
= n
->guest_hdr_len
;
1252 /* copy in packet. ugh */
1253 len
= iov_from_buf(sg
, elem
->in_num
, guest_offset
,
1254 buf
+ offset
, size
- offset
);
1257 /* If buffers can't be merged, at this point we
1258 * must have consumed the complete packet.
1259 * Otherwise, drop it. */
1260 if (!n
->mergeable_rx_bufs
&& offset
< size
) {
1261 virtqueue_unpop(q
->rx_vq
, elem
, total
);
1266 /* signal other side */
1267 virtqueue_fill(q
->rx_vq
, elem
, total
, i
++);
1272 virtio_stw_p(vdev
, &mhdr
.num_buffers
, i
);
1273 iov_from_buf(mhdr_sg
, mhdr_cnt
,
1275 &mhdr
.num_buffers
, sizeof mhdr
.num_buffers
);
1278 virtqueue_flush(q
->rx_vq
, i
);
1279 virtio_notify(vdev
, q
->rx_vq
);
1284 static ssize_t
virtio_net_receive(NetClientState
*nc
, const uint8_t *buf
,
1290 r
= virtio_net_receive_rcu(nc
, buf
, size
);
1295 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
);
1297 static void virtio_net_tx_complete(NetClientState
*nc
, ssize_t len
)
1299 VirtIONet
*n
= qemu_get_nic_opaque(nc
);
1300 VirtIONetQueue
*q
= virtio_net_get_subqueue(nc
);
1301 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1303 virtqueue_push(q
->tx_vq
, q
->async_tx
.elem
, 0);
1304 virtio_notify(vdev
, q
->tx_vq
);
1306 g_free(q
->async_tx
.elem
);
1307 q
->async_tx
.elem
= NULL
;
1309 virtio_queue_set_notification(q
->tx_vq
, 1);
1310 virtio_net_flush_tx(q
);
1314 static int32_t virtio_net_flush_tx(VirtIONetQueue
*q
)
1316 VirtIONet
*n
= q
->n
;
1317 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1318 VirtQueueElement
*elem
;
1319 int32_t num_packets
= 0;
1320 int queue_index
= vq2q(virtio_get_queue_index(q
->tx_vq
));
1321 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1325 if (q
->async_tx
.elem
) {
1326 virtio_queue_set_notification(q
->tx_vq
, 0);
1332 unsigned int out_num
;
1333 struct iovec sg
[VIRTQUEUE_MAX_SIZE
], sg2
[VIRTQUEUE_MAX_SIZE
+ 1], *out_sg
;
1334 struct virtio_net_hdr_mrg_rxbuf mhdr
;
1336 elem
= virtqueue_pop(q
->tx_vq
, sizeof(VirtQueueElement
));
1341 out_num
= elem
->out_num
;
1342 out_sg
= elem
->out_sg
;
1344 virtio_error(vdev
, "virtio-net header not in first element");
1345 virtqueue_detach_element(q
->tx_vq
, elem
, 0);
1350 if (n
->has_vnet_hdr
) {
1351 if (iov_to_buf(out_sg
, out_num
, 0, &mhdr
, n
->guest_hdr_len
) <
1353 virtio_error(vdev
, "virtio-net header incorrect");
1354 virtqueue_detach_element(q
->tx_vq
, elem
, 0);
1358 if (n
->needs_vnet_hdr_swap
) {
1359 virtio_net_hdr_swap(vdev
, (void *) &mhdr
);
1360 sg2
[0].iov_base
= &mhdr
;
1361 sg2
[0].iov_len
= n
->guest_hdr_len
;
1362 out_num
= iov_copy(&sg2
[1], ARRAY_SIZE(sg2
) - 1,
1364 n
->guest_hdr_len
, -1);
1365 if (out_num
== VIRTQUEUE_MAX_SIZE
) {
1373 * If host wants to see the guest header as is, we can
1374 * pass it on unchanged. Otherwise, copy just the parts
1375 * that host is interested in.
1377 assert(n
->host_hdr_len
<= n
->guest_hdr_len
);
1378 if (n
->host_hdr_len
!= n
->guest_hdr_len
) {
1379 unsigned sg_num
= iov_copy(sg
, ARRAY_SIZE(sg
),
1381 0, n
->host_hdr_len
);
1382 sg_num
+= iov_copy(sg
+ sg_num
, ARRAY_SIZE(sg
) - sg_num
,
1384 n
->guest_hdr_len
, -1);
1389 ret
= qemu_sendv_packet_async(qemu_get_subqueue(n
->nic
, queue_index
),
1390 out_sg
, out_num
, virtio_net_tx_complete
);
1392 virtio_queue_set_notification(q
->tx_vq
, 0);
1393 q
->async_tx
.elem
= elem
;
1398 virtqueue_push(q
->tx_vq
, elem
, 0);
1399 virtio_notify(vdev
, q
->tx_vq
);
1402 if (++num_packets
>= n
->tx_burst
) {
1409 static void virtio_net_handle_tx_timer(VirtIODevice
*vdev
, VirtQueue
*vq
)
1411 VirtIONet
*n
= VIRTIO_NET(vdev
);
1412 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1414 if (unlikely((n
->status
& VIRTIO_NET_S_LINK_UP
) == 0)) {
1415 virtio_net_drop_tx_queue_data(vdev
, vq
);
1419 /* This happens when device was stopped but VCPU wasn't. */
1420 if (!vdev
->vm_running
) {
1425 if (q
->tx_waiting
) {
1426 virtio_queue_set_notification(vq
, 1);
1427 timer_del(q
->tx_timer
);
1429 if (virtio_net_flush_tx(q
) == -EINVAL
) {
1433 timer_mod(q
->tx_timer
,
1434 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) + n
->tx_timeout
);
1436 virtio_queue_set_notification(vq
, 0);
1440 static void virtio_net_handle_tx_bh(VirtIODevice
*vdev
, VirtQueue
*vq
)
1442 VirtIONet
*n
= VIRTIO_NET(vdev
);
1443 VirtIONetQueue
*q
= &n
->vqs
[vq2q(virtio_get_queue_index(vq
))];
1445 if (unlikely((n
->status
& VIRTIO_NET_S_LINK_UP
) == 0)) {
1446 virtio_net_drop_tx_queue_data(vdev
, vq
);
1450 if (unlikely(q
->tx_waiting
)) {
1454 /* This happens when device was stopped but VCPU wasn't. */
1455 if (!vdev
->vm_running
) {
1458 virtio_queue_set_notification(vq
, 0);
1459 qemu_bh_schedule(q
->tx_bh
);
1462 static void virtio_net_tx_timer(void *opaque
)
1464 VirtIONetQueue
*q
= opaque
;
1465 VirtIONet
*n
= q
->n
;
1466 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1467 /* This happens when device was stopped but BH wasn't. */
1468 if (!vdev
->vm_running
) {
1469 /* Make sure tx waiting is set, so we'll run when restarted. */
1470 assert(q
->tx_waiting
);
1476 /* Just in case the driver is not ready on more */
1477 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
1481 virtio_queue_set_notification(q
->tx_vq
, 1);
1482 virtio_net_flush_tx(q
);
1485 static void virtio_net_tx_bh(void *opaque
)
1487 VirtIONetQueue
*q
= opaque
;
1488 VirtIONet
*n
= q
->n
;
1489 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1492 /* This happens when device was stopped but BH wasn't. */
1493 if (!vdev
->vm_running
) {
1494 /* Make sure tx waiting is set, so we'll run when restarted. */
1495 assert(q
->tx_waiting
);
1501 /* Just in case the driver is not ready on more */
1502 if (unlikely(!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
))) {
1506 ret
= virtio_net_flush_tx(q
);
1507 if (ret
== -EBUSY
|| ret
== -EINVAL
) {
1508 return; /* Notification re-enable handled by tx_complete or device
1512 /* If we flush a full burst of packets, assume there are
1513 * more coming and immediately reschedule */
1514 if (ret
>= n
->tx_burst
) {
1515 qemu_bh_schedule(q
->tx_bh
);
1520 /* If less than a full burst, re-enable notification and flush
1521 * anything that may have come in while we weren't looking. If
1522 * we find something, assume the guest is still active and reschedule */
1523 virtio_queue_set_notification(q
->tx_vq
, 1);
1524 ret
= virtio_net_flush_tx(q
);
1525 if (ret
== -EINVAL
) {
1527 } else if (ret
> 0) {
1528 virtio_queue_set_notification(q
->tx_vq
, 0);
1529 qemu_bh_schedule(q
->tx_bh
);
1534 static void virtio_net_add_queue(VirtIONet
*n
, int index
)
1536 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1538 n
->vqs
[index
].rx_vq
= virtio_add_queue(vdev
, n
->net_conf
.rx_queue_size
,
1539 virtio_net_handle_rx
);
1541 if (n
->net_conf
.tx
&& !strcmp(n
->net_conf
.tx
, "timer")) {
1542 n
->vqs
[index
].tx_vq
=
1543 virtio_add_queue(vdev
, n
->net_conf
.tx_queue_size
,
1544 virtio_net_handle_tx_timer
);
1545 n
->vqs
[index
].tx_timer
= timer_new_ns(QEMU_CLOCK_VIRTUAL
,
1546 virtio_net_tx_timer
,
1549 n
->vqs
[index
].tx_vq
=
1550 virtio_add_queue(vdev
, n
->net_conf
.tx_queue_size
,
1551 virtio_net_handle_tx_bh
);
1552 n
->vqs
[index
].tx_bh
= qemu_bh_new(virtio_net_tx_bh
, &n
->vqs
[index
]);
1555 n
->vqs
[index
].tx_waiting
= 0;
1556 n
->vqs
[index
].n
= n
;
1559 static void virtio_net_del_queue(VirtIONet
*n
, int index
)
1561 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1562 VirtIONetQueue
*q
= &n
->vqs
[index
];
1563 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, index
);
1565 qemu_purge_queued_packets(nc
);
1567 virtio_del_queue(vdev
, index
* 2);
1569 timer_del(q
->tx_timer
);
1570 timer_free(q
->tx_timer
);
1573 qemu_bh_delete(q
->tx_bh
);
1577 virtio_del_queue(vdev
, index
* 2 + 1);
1580 static void virtio_net_change_num_queues(VirtIONet
*n
, int new_max_queues
)
1582 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1583 int old_num_queues
= virtio_get_num_queues(vdev
);
1584 int new_num_queues
= new_max_queues
* 2 + 1;
1587 assert(old_num_queues
>= 3);
1588 assert(old_num_queues
% 2 == 1);
1590 if (old_num_queues
== new_num_queues
) {
1595 * We always need to remove and add ctrl vq if
1596 * old_num_queues != new_num_queues. Remove ctrl_vq first,
1597 * and then we only enter one of the following too loops.
1599 virtio_del_queue(vdev
, old_num_queues
- 1);
1601 for (i
= new_num_queues
- 1; i
< old_num_queues
- 1; i
+= 2) {
1602 /* new_num_queues < old_num_queues */
1603 virtio_net_del_queue(n
, i
/ 2);
1606 for (i
= old_num_queues
- 1; i
< new_num_queues
- 1; i
+= 2) {
1607 /* new_num_queues > old_num_queues */
1608 virtio_net_add_queue(n
, i
/ 2);
1611 /* add ctrl_vq last */
1612 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
1615 static void virtio_net_set_multiqueue(VirtIONet
*n
, int multiqueue
)
1617 int max
= multiqueue
? n
->max_queues
: 1;
1619 n
->multiqueue
= multiqueue
;
1620 virtio_net_change_num_queues(n
, max
);
1622 virtio_net_set_queues(n
);
1625 static int virtio_net_post_load_device(void *opaque
, int version_id
)
1627 VirtIONet
*n
= opaque
;
1628 VirtIODevice
*vdev
= VIRTIO_DEVICE(n
);
1631 virtio_net_set_mrg_rx_bufs(n
, n
->mergeable_rx_bufs
,
1632 virtio_vdev_has_feature(vdev
,
1633 VIRTIO_F_VERSION_1
));
1635 /* MAC_TABLE_ENTRIES may be different from the saved image */
1636 if (n
->mac_table
.in_use
> MAC_TABLE_ENTRIES
) {
1637 n
->mac_table
.in_use
= 0;
1640 if (!virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
)) {
1641 n
->curr_guest_offloads
= virtio_net_supported_guest_offloads(n
);
1644 if (peer_has_vnet_hdr(n
)) {
1645 virtio_net_apply_guest_offloads(n
);
1648 virtio_net_set_queues(n
);
1650 /* Find the first multicast entry in the saved MAC filter */
1651 for (i
= 0; i
< n
->mac_table
.in_use
; i
++) {
1652 if (n
->mac_table
.macs
[i
* ETH_ALEN
] & 1) {
1656 n
->mac_table
.first_multi
= i
;
1658 /* nc.link_down can't be migrated, so infer link_down according
1659 * to link status bit in n->status */
1660 link_down
= (n
->status
& VIRTIO_NET_S_LINK_UP
) == 0;
1661 for (i
= 0; i
< n
->max_queues
; i
++) {
1662 qemu_get_subqueue(n
->nic
, i
)->link_down
= link_down
;
1665 if (virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_GUEST_ANNOUNCE
) &&
1666 virtio_vdev_has_feature(vdev
, VIRTIO_NET_F_CTRL_VQ
)) {
1667 n
->announce_counter
= SELF_ANNOUNCE_ROUNDS
;
1668 timer_mod(n
->announce_timer
, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
));
1674 /* tx_waiting field of a VirtIONetQueue */
1675 static const VMStateDescription vmstate_virtio_net_queue_tx_waiting
= {
1676 .name
= "virtio-net-queue-tx_waiting",
1677 .fields
= (VMStateField
[]) {
1678 VMSTATE_UINT32(tx_waiting
, VirtIONetQueue
),
1679 VMSTATE_END_OF_LIST()
1683 static bool max_queues_gt_1(void *opaque
, int version_id
)
1685 return VIRTIO_NET(opaque
)->max_queues
> 1;
1688 static bool has_ctrl_guest_offloads(void *opaque
, int version_id
)
1690 return virtio_vdev_has_feature(VIRTIO_DEVICE(opaque
),
1691 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
);
1694 static bool mac_table_fits(void *opaque
, int version_id
)
1696 return VIRTIO_NET(opaque
)->mac_table
.in_use
<= MAC_TABLE_ENTRIES
;
1699 static bool mac_table_doesnt_fit(void *opaque
, int version_id
)
1701 return !mac_table_fits(opaque
, version_id
);
1704 /* This temporary type is shared by all the WITH_TMP methods
1705 * although only some fields are used by each.
1707 struct VirtIONetMigTmp
{
1709 VirtIONetQueue
*vqs_1
;
1710 uint16_t curr_queues_1
;
1712 uint32_t has_vnet_hdr
;
1715 /* The 2nd and subsequent tx_waiting flags are loaded later than
1716 * the 1st entry in the queues and only if there's more than one
1717 * entry. We use the tmp mechanism to calculate a temporary
1718 * pointer and count and also validate the count.
1721 static int virtio_net_tx_waiting_pre_save(void *opaque
)
1723 struct VirtIONetMigTmp
*tmp
= opaque
;
1725 tmp
->vqs_1
= tmp
->parent
->vqs
+ 1;
1726 tmp
->curr_queues_1
= tmp
->parent
->curr_queues
- 1;
1727 if (tmp
->parent
->curr_queues
== 0) {
1728 tmp
->curr_queues_1
= 0;
1734 static int virtio_net_tx_waiting_pre_load(void *opaque
)
1736 struct VirtIONetMigTmp
*tmp
= opaque
;
1738 /* Reuse the pointer setup from save */
1739 virtio_net_tx_waiting_pre_save(opaque
);
1741 if (tmp
->parent
->curr_queues
> tmp
->parent
->max_queues
) {
1742 error_report("virtio-net: curr_queues %x > max_queues %x",
1743 tmp
->parent
->curr_queues
, tmp
->parent
->max_queues
);
1748 return 0; /* all good */
1751 static const VMStateDescription vmstate_virtio_net_tx_waiting
= {
1752 .name
= "virtio-net-tx_waiting",
1753 .pre_load
= virtio_net_tx_waiting_pre_load
,
1754 .pre_save
= virtio_net_tx_waiting_pre_save
,
1755 .fields
= (VMStateField
[]) {
1756 VMSTATE_STRUCT_VARRAY_POINTER_UINT16(vqs_1
, struct VirtIONetMigTmp
,
1758 vmstate_virtio_net_queue_tx_waiting
,
1759 struct VirtIONetQueue
),
1760 VMSTATE_END_OF_LIST()
1764 /* the 'has_ufo' flag is just tested; if the incoming stream has the
1765 * flag set we need to check that we have it
1767 static int virtio_net_ufo_post_load(void *opaque
, int version_id
)
1769 struct VirtIONetMigTmp
*tmp
= opaque
;
1771 if (tmp
->has_ufo
&& !peer_has_ufo(tmp
->parent
)) {
1772 error_report("virtio-net: saved image requires TUN_F_UFO support");
1779 static int virtio_net_ufo_pre_save(void *opaque
)
1781 struct VirtIONetMigTmp
*tmp
= opaque
;
1783 tmp
->has_ufo
= tmp
->parent
->has_ufo
;
1788 static const VMStateDescription vmstate_virtio_net_has_ufo
= {
1789 .name
= "virtio-net-ufo",
1790 .post_load
= virtio_net_ufo_post_load
,
1791 .pre_save
= virtio_net_ufo_pre_save
,
1792 .fields
= (VMStateField
[]) {
1793 VMSTATE_UINT8(has_ufo
, struct VirtIONetMigTmp
),
1794 VMSTATE_END_OF_LIST()
1798 /* the 'has_vnet_hdr' flag is just tested; if the incoming stream has the
1799 * flag set we need to check that we have it
1801 static int virtio_net_vnet_post_load(void *opaque
, int version_id
)
1803 struct VirtIONetMigTmp
*tmp
= opaque
;
1805 if (tmp
->has_vnet_hdr
&& !peer_has_vnet_hdr(tmp
->parent
)) {
1806 error_report("virtio-net: saved image requires vnet_hdr=on");
1813 static int virtio_net_vnet_pre_save(void *opaque
)
1815 struct VirtIONetMigTmp
*tmp
= opaque
;
1817 tmp
->has_vnet_hdr
= tmp
->parent
->has_vnet_hdr
;
1822 static const VMStateDescription vmstate_virtio_net_has_vnet
= {
1823 .name
= "virtio-net-vnet",
1824 .post_load
= virtio_net_vnet_post_load
,
1825 .pre_save
= virtio_net_vnet_pre_save
,
1826 .fields
= (VMStateField
[]) {
1827 VMSTATE_UINT32(has_vnet_hdr
, struct VirtIONetMigTmp
),
1828 VMSTATE_END_OF_LIST()
1832 static const VMStateDescription vmstate_virtio_net_device
= {
1833 .name
= "virtio-net-device",
1834 .version_id
= VIRTIO_NET_VM_VERSION
,
1835 .minimum_version_id
= VIRTIO_NET_VM_VERSION
,
1836 .post_load
= virtio_net_post_load_device
,
1837 .fields
= (VMStateField
[]) {
1838 VMSTATE_UINT8_ARRAY(mac
, VirtIONet
, ETH_ALEN
),
1839 VMSTATE_STRUCT_POINTER(vqs
, VirtIONet
,
1840 vmstate_virtio_net_queue_tx_waiting
,
1842 VMSTATE_UINT32(mergeable_rx_bufs
, VirtIONet
),
1843 VMSTATE_UINT16(status
, VirtIONet
),
1844 VMSTATE_UINT8(promisc
, VirtIONet
),
1845 VMSTATE_UINT8(allmulti
, VirtIONet
),
1846 VMSTATE_UINT32(mac_table
.in_use
, VirtIONet
),
1848 /* Guarded pair: If it fits we load it, else we throw it away
1849 * - can happen if source has a larger MAC table.; post-load
1850 * sets flags in this case.
1852 VMSTATE_VBUFFER_MULTIPLY(mac_table
.macs
, VirtIONet
,
1853 0, mac_table_fits
, mac_table
.in_use
,
1855 VMSTATE_UNUSED_VARRAY_UINT32(VirtIONet
, mac_table_doesnt_fit
, 0,
1856 mac_table
.in_use
, ETH_ALEN
),
1858 /* Note: This is an array of uint32's that's always been saved as a
1859 * buffer; hold onto your endiannesses; it's actually used as a bitmap
1860 * but based on the uint.
1862 VMSTATE_BUFFER_POINTER_UNSAFE(vlans
, VirtIONet
, 0, MAX_VLAN
>> 3),
1863 VMSTATE_WITH_TMP(VirtIONet
, struct VirtIONetMigTmp
,
1864 vmstate_virtio_net_has_vnet
),
1865 VMSTATE_UINT8(mac_table
.multi_overflow
, VirtIONet
),
1866 VMSTATE_UINT8(mac_table
.uni_overflow
, VirtIONet
),
1867 VMSTATE_UINT8(alluni
, VirtIONet
),
1868 VMSTATE_UINT8(nomulti
, VirtIONet
),
1869 VMSTATE_UINT8(nouni
, VirtIONet
),
1870 VMSTATE_UINT8(nobcast
, VirtIONet
),
1871 VMSTATE_WITH_TMP(VirtIONet
, struct VirtIONetMigTmp
,
1872 vmstate_virtio_net_has_ufo
),
1873 VMSTATE_SINGLE_TEST(max_queues
, VirtIONet
, max_queues_gt_1
, 0,
1874 vmstate_info_uint16_equal
, uint16_t),
1875 VMSTATE_UINT16_TEST(curr_queues
, VirtIONet
, max_queues_gt_1
),
1876 VMSTATE_WITH_TMP(VirtIONet
, struct VirtIONetMigTmp
,
1877 vmstate_virtio_net_tx_waiting
),
1878 VMSTATE_UINT64_TEST(curr_guest_offloads
, VirtIONet
,
1879 has_ctrl_guest_offloads
),
1880 VMSTATE_END_OF_LIST()
1884 static NetClientInfo net_virtio_info
= {
1885 .type
= NET_CLIENT_DRIVER_NIC
,
1886 .size
= sizeof(NICState
),
1887 .can_receive
= virtio_net_can_receive
,
1888 .receive
= virtio_net_receive
,
1889 .link_status_changed
= virtio_net_set_link_status
,
1890 .query_rx_filter
= virtio_net_query_rxfilter
,
1893 static bool virtio_net_guest_notifier_pending(VirtIODevice
*vdev
, int idx
)
1895 VirtIONet
*n
= VIRTIO_NET(vdev
);
1896 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1897 assert(n
->vhost_started
);
1898 return vhost_net_virtqueue_pending(get_vhost_net(nc
->peer
), idx
);
1901 static void virtio_net_guest_notifier_mask(VirtIODevice
*vdev
, int idx
,
1904 VirtIONet
*n
= VIRTIO_NET(vdev
);
1905 NetClientState
*nc
= qemu_get_subqueue(n
->nic
, vq2q(idx
));
1906 assert(n
->vhost_started
);
1907 vhost_net_virtqueue_mask(get_vhost_net(nc
->peer
),
1911 static void virtio_net_set_config_size(VirtIONet
*n
, uint64_t host_features
)
1913 int i
, config_size
= 0;
1914 virtio_add_feature(&host_features
, VIRTIO_NET_F_MAC
);
1916 for (i
= 0; feature_sizes
[i
].flags
!= 0; i
++) {
1917 if (host_features
& feature_sizes
[i
].flags
) {
1918 config_size
= MAX(feature_sizes
[i
].end
, config_size
);
1921 n
->config_size
= config_size
;
1924 void virtio_net_set_netclient_name(VirtIONet
*n
, const char *name
,
1928 * The name can be NULL, the netclient name will be type.x.
1930 assert(type
!= NULL
);
1932 g_free(n
->netclient_name
);
1933 g_free(n
->netclient_type
);
1934 n
->netclient_name
= g_strdup(name
);
1935 n
->netclient_type
= g_strdup(type
);
1938 static void virtio_net_device_realize(DeviceState
*dev
, Error
**errp
)
1940 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1941 VirtIONet
*n
= VIRTIO_NET(dev
);
1945 if (n
->net_conf
.mtu
) {
1946 n
->host_features
|= (1ULL << VIRTIO_NET_F_MTU
);
1949 if (n
->net_conf
.duplex_str
) {
1950 if (strncmp(n
->net_conf
.duplex_str
, "half", 5) == 0) {
1951 n
->net_conf
.duplex
= DUPLEX_HALF
;
1952 } else if (strncmp(n
->net_conf
.duplex_str
, "full", 5) == 0) {
1953 n
->net_conf
.duplex
= DUPLEX_FULL
;
1955 error_setg(errp
, "'duplex' must be 'half' or 'full'");
1957 n
->host_features
|= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX
);
1959 n
->net_conf
.duplex
= DUPLEX_UNKNOWN
;
1962 if (n
->net_conf
.speed
< SPEED_UNKNOWN
) {
1963 error_setg(errp
, "'speed' must be between 0 and INT_MAX");
1964 } else if (n
->net_conf
.speed
>= 0) {
1965 n
->host_features
|= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX
);
1968 virtio_net_set_config_size(n
, n
->host_features
);
1969 virtio_init(vdev
, "virtio-net", VIRTIO_ID_NET
, n
->config_size
);
1972 * We set a lower limit on RX queue size to what it always was.
1973 * Guests that want a smaller ring can always resize it without
1974 * help from us (using virtio 1 and up).
1976 if (n
->net_conf
.rx_queue_size
< VIRTIO_NET_RX_QUEUE_MIN_SIZE
||
1977 n
->net_conf
.rx_queue_size
> VIRTQUEUE_MAX_SIZE
||
1978 !is_power_of_2(n
->net_conf
.rx_queue_size
)) {
1979 error_setg(errp
, "Invalid rx_queue_size (= %" PRIu16
"), "
1980 "must be a power of 2 between %d and %d.",
1981 n
->net_conf
.rx_queue_size
, VIRTIO_NET_RX_QUEUE_MIN_SIZE
,
1982 VIRTQUEUE_MAX_SIZE
);
1983 virtio_cleanup(vdev
);
1987 if (n
->net_conf
.tx_queue_size
< VIRTIO_NET_TX_QUEUE_MIN_SIZE
||
1988 n
->net_conf
.tx_queue_size
> VIRTQUEUE_MAX_SIZE
||
1989 !is_power_of_2(n
->net_conf
.tx_queue_size
)) {
1990 error_setg(errp
, "Invalid tx_queue_size (= %" PRIu16
"), "
1991 "must be a power of 2 between %d and %d",
1992 n
->net_conf
.tx_queue_size
, VIRTIO_NET_TX_QUEUE_MIN_SIZE
,
1993 VIRTQUEUE_MAX_SIZE
);
1994 virtio_cleanup(vdev
);
1998 n
->max_queues
= MAX(n
->nic_conf
.peers
.queues
, 1);
1999 if (n
->max_queues
* 2 + 1 > VIRTIO_QUEUE_MAX
) {
2000 error_setg(errp
, "Invalid number of queues (= %" PRIu32
"), "
2001 "must be a positive integer less than %d.",
2002 n
->max_queues
, (VIRTIO_QUEUE_MAX
- 1) / 2);
2003 virtio_cleanup(vdev
);
2006 n
->vqs
= g_malloc0(sizeof(VirtIONetQueue
) * n
->max_queues
);
2008 n
->tx_timeout
= n
->net_conf
.txtimer
;
2010 if (n
->net_conf
.tx
&& strcmp(n
->net_conf
.tx
, "timer")
2011 && strcmp(n
->net_conf
.tx
, "bh")) {
2012 error_report("virtio-net: "
2013 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
2015 error_report("Defaulting to \"bh\"");
2018 n
->net_conf
.tx_queue_size
= MIN(virtio_net_max_tx_queue_size(n
),
2019 n
->net_conf
.tx_queue_size
);
2021 for (i
= 0; i
< n
->max_queues
; i
++) {
2022 virtio_net_add_queue(n
, i
);
2025 n
->ctrl_vq
= virtio_add_queue(vdev
, 64, virtio_net_handle_ctrl
);
2026 qemu_macaddr_default_if_unset(&n
->nic_conf
.macaddr
);
2027 memcpy(&n
->mac
[0], &n
->nic_conf
.macaddr
, sizeof(n
->mac
));
2028 n
->status
= VIRTIO_NET_S_LINK_UP
;
2029 n
->announce_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
2030 virtio_net_announce_timer
, n
);
2032 if (n
->netclient_type
) {
2034 * Happen when virtio_net_set_netclient_name has been called.
2036 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
2037 n
->netclient_type
, n
->netclient_name
, n
);
2039 n
->nic
= qemu_new_nic(&net_virtio_info
, &n
->nic_conf
,
2040 object_get_typename(OBJECT(dev
)), dev
->id
, n
);
2043 peer_test_vnet_hdr(n
);
2044 if (peer_has_vnet_hdr(n
)) {
2045 for (i
= 0; i
< n
->max_queues
; i
++) {
2046 qemu_using_vnet_hdr(qemu_get_subqueue(n
->nic
, i
)->peer
, true);
2048 n
->host_hdr_len
= sizeof(struct virtio_net_hdr
);
2050 n
->host_hdr_len
= 0;
2053 qemu_format_nic_info_str(qemu_get_queue(n
->nic
), n
->nic_conf
.macaddr
.a
);
2055 n
->vqs
[0].tx_waiting
= 0;
2056 n
->tx_burst
= n
->net_conf
.txburst
;
2057 virtio_net_set_mrg_rx_bufs(n
, 0, 0);
2058 n
->promisc
= 1; /* for compatibility */
2060 n
->mac_table
.macs
= g_malloc0(MAC_TABLE_ENTRIES
* ETH_ALEN
);
2062 n
->vlans
= g_malloc0(MAX_VLAN
>> 3);
2064 nc
= qemu_get_queue(n
->nic
);
2065 nc
->rxfilter_notify_enabled
= 1;
2070 static void virtio_net_device_unrealize(DeviceState
*dev
, Error
**errp
)
2072 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
2073 VirtIONet
*n
= VIRTIO_NET(dev
);
2076 /* This will stop vhost backend if appropriate. */
2077 virtio_net_set_status(vdev
, 0);
2079 g_free(n
->netclient_name
);
2080 n
->netclient_name
= NULL
;
2081 g_free(n
->netclient_type
);
2082 n
->netclient_type
= NULL
;
2084 g_free(n
->mac_table
.macs
);
2087 max_queues
= n
->multiqueue
? n
->max_queues
: 1;
2088 for (i
= 0; i
< max_queues
; i
++) {
2089 virtio_net_del_queue(n
, i
);
2092 timer_del(n
->announce_timer
);
2093 timer_free(n
->announce_timer
);
2095 qemu_del_nic(n
->nic
);
2096 virtio_cleanup(vdev
);
2099 static void virtio_net_instance_init(Object
*obj
)
2101 VirtIONet
*n
= VIRTIO_NET(obj
);
2104 * The default config_size is sizeof(struct virtio_net_config).
2105 * Can be overriden with virtio_net_set_config_size.
2107 n
->config_size
= sizeof(struct virtio_net_config
);
2108 device_add_bootindex_property(obj
, &n
->nic_conf
.bootindex
,
2109 "bootindex", "/ethernet-phy@0",
2113 static int virtio_net_pre_save(void *opaque
)
2115 VirtIONet
*n
= opaque
;
2117 /* At this point, backend must be stopped, otherwise
2118 * it might keep writing to memory. */
2119 assert(!n
->vhost_started
);
2124 static const VMStateDescription vmstate_virtio_net
= {
2125 .name
= "virtio-net",
2126 .minimum_version_id
= VIRTIO_NET_VM_VERSION
,
2127 .version_id
= VIRTIO_NET_VM_VERSION
,
2128 .fields
= (VMStateField
[]) {
2129 VMSTATE_VIRTIO_DEVICE
,
2130 VMSTATE_END_OF_LIST()
2132 .pre_save
= virtio_net_pre_save
,
2135 static Property virtio_net_properties
[] = {
2136 DEFINE_PROP_BIT64("csum", VirtIONet
, host_features
,
2137 VIRTIO_NET_F_CSUM
, true),
2138 DEFINE_PROP_BIT64("guest_csum", VirtIONet
, host_features
,
2139 VIRTIO_NET_F_GUEST_CSUM
, true),
2140 DEFINE_PROP_BIT64("gso", VirtIONet
, host_features
, VIRTIO_NET_F_GSO
, true),
2141 DEFINE_PROP_BIT64("guest_tso4", VirtIONet
, host_features
,
2142 VIRTIO_NET_F_GUEST_TSO4
, true),
2143 DEFINE_PROP_BIT64("guest_tso6", VirtIONet
, host_features
,
2144 VIRTIO_NET_F_GUEST_TSO6
, true),
2145 DEFINE_PROP_BIT64("guest_ecn", VirtIONet
, host_features
,
2146 VIRTIO_NET_F_GUEST_ECN
, true),
2147 DEFINE_PROP_BIT64("guest_ufo", VirtIONet
, host_features
,
2148 VIRTIO_NET_F_GUEST_UFO
, true),
2149 DEFINE_PROP_BIT64("guest_announce", VirtIONet
, host_features
,
2150 VIRTIO_NET_F_GUEST_ANNOUNCE
, true),
2151 DEFINE_PROP_BIT64("host_tso4", VirtIONet
, host_features
,
2152 VIRTIO_NET_F_HOST_TSO4
, true),
2153 DEFINE_PROP_BIT64("host_tso6", VirtIONet
, host_features
,
2154 VIRTIO_NET_F_HOST_TSO6
, true),
2155 DEFINE_PROP_BIT64("host_ecn", VirtIONet
, host_features
,
2156 VIRTIO_NET_F_HOST_ECN
, true),
2157 DEFINE_PROP_BIT64("host_ufo", VirtIONet
, host_features
,
2158 VIRTIO_NET_F_HOST_UFO
, true),
2159 DEFINE_PROP_BIT64("mrg_rxbuf", VirtIONet
, host_features
,
2160 VIRTIO_NET_F_MRG_RXBUF
, true),
2161 DEFINE_PROP_BIT64("status", VirtIONet
, host_features
,
2162 VIRTIO_NET_F_STATUS
, true),
2163 DEFINE_PROP_BIT64("ctrl_vq", VirtIONet
, host_features
,
2164 VIRTIO_NET_F_CTRL_VQ
, true),
2165 DEFINE_PROP_BIT64("ctrl_rx", VirtIONet
, host_features
,
2166 VIRTIO_NET_F_CTRL_RX
, true),
2167 DEFINE_PROP_BIT64("ctrl_vlan", VirtIONet
, host_features
,
2168 VIRTIO_NET_F_CTRL_VLAN
, true),
2169 DEFINE_PROP_BIT64("ctrl_rx_extra", VirtIONet
, host_features
,
2170 VIRTIO_NET_F_CTRL_RX_EXTRA
, true),
2171 DEFINE_PROP_BIT64("ctrl_mac_addr", VirtIONet
, host_features
,
2172 VIRTIO_NET_F_CTRL_MAC_ADDR
, true),
2173 DEFINE_PROP_BIT64("ctrl_guest_offloads", VirtIONet
, host_features
,
2174 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
, true),
2175 DEFINE_PROP_BIT64("mq", VirtIONet
, host_features
, VIRTIO_NET_F_MQ
, false),
2176 DEFINE_NIC_PROPERTIES(VirtIONet
, nic_conf
),
2177 DEFINE_PROP_UINT32("x-txtimer", VirtIONet
, net_conf
.txtimer
,
2179 DEFINE_PROP_INT32("x-txburst", VirtIONet
, net_conf
.txburst
, TX_BURST
),
2180 DEFINE_PROP_STRING("tx", VirtIONet
, net_conf
.tx
),
2181 DEFINE_PROP_UINT16("rx_queue_size", VirtIONet
, net_conf
.rx_queue_size
,
2182 VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE
),
2183 DEFINE_PROP_UINT16("tx_queue_size", VirtIONet
, net_conf
.tx_queue_size
,
2184 VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
),
2185 DEFINE_PROP_UINT16("host_mtu", VirtIONet
, net_conf
.mtu
, 0),
2186 DEFINE_PROP_BOOL("x-mtu-bypass-backend", VirtIONet
, mtu_bypass_backend
,
2188 DEFINE_PROP_INT32("speed", VirtIONet
, net_conf
.speed
, SPEED_UNKNOWN
),
2189 DEFINE_PROP_STRING("duplex", VirtIONet
, net_conf
.duplex_str
),
2190 DEFINE_PROP_END_OF_LIST(),
2193 static void virtio_net_class_init(ObjectClass
*klass
, void *data
)
2195 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2196 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
2198 dc
->props
= virtio_net_properties
;
2199 dc
->vmsd
= &vmstate_virtio_net
;
2200 set_bit(DEVICE_CATEGORY_NETWORK
, dc
->categories
);
2201 vdc
->realize
= virtio_net_device_realize
;
2202 vdc
->unrealize
= virtio_net_device_unrealize
;
2203 vdc
->get_config
= virtio_net_get_config
;
2204 vdc
->set_config
= virtio_net_set_config
;
2205 vdc
->get_features
= virtio_net_get_features
;
2206 vdc
->set_features
= virtio_net_set_features
;
2207 vdc
->bad_features
= virtio_net_bad_features
;
2208 vdc
->reset
= virtio_net_reset
;
2209 vdc
->set_status
= virtio_net_set_status
;
2210 vdc
->guest_notifier_mask
= virtio_net_guest_notifier_mask
;
2211 vdc
->guest_notifier_pending
= virtio_net_guest_notifier_pending
;
2212 vdc
->legacy_features
|= (0x1 << VIRTIO_NET_F_GSO
);
2213 vdc
->vmsd
= &vmstate_virtio_net_device
;
2216 static const TypeInfo virtio_net_info
= {
2217 .name
= TYPE_VIRTIO_NET
,
2218 .parent
= TYPE_VIRTIO_DEVICE
,
2219 .instance_size
= sizeof(VirtIONet
),
2220 .instance_init
= virtio_net_instance_init
,
2221 .class_init
= virtio_net_class_init
,
2224 static void virtio_register_types(void)
2226 type_register_static(&virtio_net_info
);
2229 type_init(virtio_register_types
)