?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Include qemu/main-loop.h less
[qemu/ar7.git] / hw / net / virtio-net.c
blobcdf4d774da19c16c90227ddd67aee42deecf7c04
1 /*
2 * Virtio Network Device
3 *
4 * Copyright IBM, Corp. 2007
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
11 *
12 */
13
14 #include "qemu/osdep.h"
15 #include "qemu/iov.h"
16 #include "qemu/main-loop.h"
17 #include "qemu/module.h"
18 #include "hw/virtio/virtio.h"
19 #include "net/net.h"
20 #include "net/checksum.h"
21 #include "net/tap.h"
22 #include "qemu/error-report.h"
23 #include "qemu/timer.h"
24 #include "hw/virtio/virtio-net.h"
25 #include "net/vhost_net.h"
26 #include "net/announce.h"
27 #include "hw/virtio/virtio-bus.h"
28 #include "qapi/error.h"
29 #include "qapi/qapi-events-net.h"
30 #include "hw/virtio/virtio-access.h"
31 #include "migration/misc.h"
32 #include "standard-headers/linux/ethtool.h"
33 #include "trace.h"
34
35 #define VIRTIO_NET_VM_VERSION 11
36
37 #define MAC_TABLE_ENTRIES 64
38 #define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
39
40 /* previously fixed value */
41 #define VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE 256
42 #define VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE 256
43
44 /* for now, only allow larger queues; with virtio-1, guest can downsize */
45 #define VIRTIO_NET_RX_QUEUE_MIN_SIZE VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE
46 #define VIRTIO_NET_TX_QUEUE_MIN_SIZE VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
47
48 #define VIRTIO_NET_IP4_ADDR_SIZE 8 /* ipv4 saddr + daddr */
49
50 #define VIRTIO_NET_TCP_FLAG 0x3F
51 #define VIRTIO_NET_TCP_HDR_LENGTH 0xF000
52
53 /* IPv4 max payload, 16 bits in the header */
54 #define VIRTIO_NET_MAX_IP4_PAYLOAD (65535 - sizeof(struct ip_header))
55 #define VIRTIO_NET_MAX_TCP_PAYLOAD 65535
56
57 /* header length value in ip header without option */
58 #define VIRTIO_NET_IP4_HEADER_LENGTH 5
59
60 #define VIRTIO_NET_IP6_ADDR_SIZE 32 /* ipv6 saddr + daddr */
61 #define VIRTIO_NET_MAX_IP6_PAYLOAD VIRTIO_NET_MAX_TCP_PAYLOAD
62
63 /* Purge coalesced packets timer interval, This value affects the performance
64 a lot, and should be tuned carefully, '300000'(300us) is the recommended
65 value to pass the WHQL test, '50000' can gain 2x netperf throughput with
66 tso/gso/gro 'off'. */
67 #define VIRTIO_NET_RSC_DEFAULT_INTERVAL 300000
68
69 /* temporary until standard header include it */
70 #if !defined(VIRTIO_NET_HDR_F_RSC_INFO)
71
72 #define VIRTIO_NET_HDR_F_RSC_INFO 4 /* rsc_ext data in csum_ fields */
73 #define VIRTIO_NET_F_RSC_EXT 61
74
75 static inline __virtio16 *virtio_net_rsc_ext_num_packets(
76 struct virtio_net_hdr *hdr)
77 {
78 return &hdr->csum_start;
79 }
80
81 static inline __virtio16 *virtio_net_rsc_ext_num_dupacks(
82 struct virtio_net_hdr *hdr)
83 {
84 return &hdr->csum_offset;
85 }
86
87 #endif
88
89 static VirtIOFeature feature_sizes[] = {
90 {.flags = 1ULL << VIRTIO_NET_F_MAC,
91 .end = virtio_endof(struct virtio_net_config, mac)},
92 {.flags = 1ULL << VIRTIO_NET_F_STATUS,
93 .end = virtio_endof(struct virtio_net_config, status)},
94 {.flags = 1ULL << VIRTIO_NET_F_MQ,
95 .end = virtio_endof(struct virtio_net_config, max_virtqueue_pairs)},
96 {.flags = 1ULL << VIRTIO_NET_F_MTU,
97 .end = virtio_endof(struct virtio_net_config, mtu)},
98 {.flags = 1ULL << VIRTIO_NET_F_SPEED_DUPLEX,
99 .end = virtio_endof(struct virtio_net_config, duplex)},
100 {}
101 };
102
103 static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
104 {
105 VirtIONet *n = qemu_get_nic_opaque(nc);
106
107 return &n->vqs[nc->queue_index];
108 }
109
110 static int vq2q(int queue_index)
111 {
112 return queue_index / 2;
113 }
114
115 /* TODO
116 * - we could suppress RX interrupt if we were so inclined.
117 */
118
119 static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
120 {
121 VirtIONet *n = VIRTIO_NET(vdev);
122 struct virtio_net_config netcfg;
123
124 virtio_stw_p(vdev, &netcfg.status, n->status);
125 virtio_stw_p(vdev, &netcfg.max_virtqueue_pairs, n->max_queues);
126 virtio_stw_p(vdev, &netcfg.mtu, n->net_conf.mtu);
127 memcpy(netcfg.mac, n->mac, ETH_ALEN);
128 virtio_stl_p(vdev, &netcfg.speed, n->net_conf.speed);
129 netcfg.duplex = n->net_conf.duplex;
130 memcpy(config, &netcfg, n->config_size);
131 }
132
133 static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
134 {
135 VirtIONet *n = VIRTIO_NET(vdev);
136 struct virtio_net_config netcfg = {};
137
138 memcpy(&netcfg, config, n->config_size);
139
140 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR) &&
141 !virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1) &&
142 memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
143 memcpy(n->mac, netcfg.mac, ETH_ALEN);
144 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
145 }
146 }
147
148 static bool virtio_net_started(VirtIONet *n, uint8_t status)
149 {
150 VirtIODevice *vdev = VIRTIO_DEVICE(n);
151 return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
152 (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
153 }
154
155 static void virtio_net_announce_notify(VirtIONet *net)
156 {
157 VirtIODevice *vdev = VIRTIO_DEVICE(net);
158 trace_virtio_net_announce_notify();
159
160 net->status |= VIRTIO_NET_S_ANNOUNCE;
161 virtio_notify_config(vdev);
162 }
163
164 static void virtio_net_announce_timer(void *opaque)
165 {
166 VirtIONet *n = opaque;
167 trace_virtio_net_announce_timer(n->announce_timer.round);
168
169 n->announce_timer.round--;
170 virtio_net_announce_notify(n);
171 }
172
173 static void virtio_net_announce(NetClientState *nc)
174 {
175 VirtIONet *n = qemu_get_nic_opaque(nc);
176 VirtIODevice *vdev = VIRTIO_DEVICE(n);
177
178 /*
179 * Make sure the virtio migration announcement timer isn't running
180 * If it is, let it trigger announcement so that we do not cause
181 * confusion.
182 */
183 if (n->announce_timer.round) {
184 return;
185 }
186
187 if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
188 virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
189 virtio_net_announce_notify(n);
190 }
191 }
192
193 static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
194 {
195 VirtIODevice *vdev = VIRTIO_DEVICE(n);
196 NetClientState *nc = qemu_get_queue(n->nic);
197 int queues = n->multiqueue ? n->max_queues : 1;
198
199 if (!get_vhost_net(nc->peer)) {
200 return;
201 }
202
203 if ((virtio_net_started(n, status) && !nc->peer->link_down) ==
204 !!n->vhost_started) {
205 return;
206 }
207 if (!n->vhost_started) {
208 int r, i;
209
210 if (n->needs_vnet_hdr_swap) {
211 error_report("backend does not support %s vnet headers; "
212 "falling back on userspace virtio",
213 virtio_is_big_endian(vdev) ? "BE" : "LE");
214 return;
215 }
216
217 /* Any packets outstanding? Purge them to avoid touching rings
218 * when vhost is running.
219 */
220 for (i = 0; i < queues; i++) {
221 NetClientState *qnc = qemu_get_subqueue(n->nic, i);
222
223 /* Purge both directions: TX and RX. */
224 qemu_net_queue_purge(qnc->peer->incoming_queue, qnc);
225 qemu_net_queue_purge(qnc->incoming_queue, qnc->peer);
226 }
227
228 if (virtio_has_feature(vdev->guest_features, VIRTIO_NET_F_MTU)) {
229 r = vhost_net_set_mtu(get_vhost_net(nc->peer), n->net_conf.mtu);
230 if (r < 0) {
231 error_report("%uBytes MTU not supported by the backend",
232 n->net_conf.mtu);
233
234 return;
235 }
236 }
237
238 n->vhost_started = 1;
239 r = vhost_net_start(vdev, n->nic->ncs, queues);
240 if (r < 0) {
241 error_report("unable to start vhost net: %d: "
242 "falling back on userspace virtio", -r);
243 n->vhost_started = 0;
244 }
245 } else {
246 vhost_net_stop(vdev, n->nic->ncs, queues);
247 n->vhost_started = 0;
248 }
249 }
250
251 static int virtio_net_set_vnet_endian_one(VirtIODevice *vdev,
252 NetClientState *peer,
253 bool enable)
254 {
255 if (virtio_is_big_endian(vdev)) {
256 return qemu_set_vnet_be(peer, enable);
257 } else {
258 return qemu_set_vnet_le(peer, enable);
259 }
260 }
261
262 static bool virtio_net_set_vnet_endian(VirtIODevice *vdev, NetClientState *ncs,
263 int queues, bool enable)
264 {
265 int i;
266
267 for (i = 0; i < queues; i++) {
268 if (virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, enable) < 0 &&
269 enable) {
270 while (--i >= 0) {
271 virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, false);
272 }
273
274 return true;
275 }
276 }
277
278 return false;
279 }
280
281 static void virtio_net_vnet_endian_status(VirtIONet *n, uint8_t status)
282 {
283 VirtIODevice *vdev = VIRTIO_DEVICE(n);
284 int queues = n->multiqueue ? n->max_queues : 1;
285
286 if (virtio_net_started(n, status)) {
287 /* Before using the device, we tell the network backend about the
288 * endianness to use when parsing vnet headers. If the backend
289 * can't do it, we fallback onto fixing the headers in the core
290 * virtio-net code.
291 */
292 n->needs_vnet_hdr_swap = virtio_net_set_vnet_endian(vdev, n->nic->ncs,
293 queues, true);
294 } else if (virtio_net_started(n, vdev->status)) {
295 /* After using the device, we need to reset the network backend to
296 * the default (guest native endianness), otherwise the guest may
297 * lose network connectivity if it is rebooted into a different
298 * endianness.
299 */
300 virtio_net_set_vnet_endian(vdev, n->nic->ncs, queues, false);
301 }
302 }
303
304 static void virtio_net_drop_tx_queue_data(VirtIODevice *vdev, VirtQueue *vq)
305 {
306 unsigned int dropped = virtqueue_drop_all(vq);
307 if (dropped) {
308 virtio_notify(vdev, vq);
309 }
310 }
311
312 static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
313 {
314 VirtIONet *n = VIRTIO_NET(vdev);
315 VirtIONetQueue *q;
316 int i;
317 uint8_t queue_status;
318
319 virtio_net_vnet_endian_status(n, status);
320 virtio_net_vhost_status(n, status);
321
322 for (i = 0; i < n->max_queues; i++) {
323 NetClientState *ncs = qemu_get_subqueue(n->nic, i);
324 bool queue_started;
325 q = &n->vqs[i];
326
327 if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
328 queue_status = 0;
329 } else {
330 queue_status = status;
331 }
332 queue_started =
333 virtio_net_started(n, queue_status) && !n->vhost_started;
334
335 if (queue_started) {
336 qemu_flush_queued_packets(ncs);
337 }
338
339 if (!q->tx_waiting) {
340 continue;
341 }
342
343 if (queue_started) {
344 if (q->tx_timer) {
345 timer_mod(q->tx_timer,
346 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
347 } else {
348 qemu_bh_schedule(q->tx_bh);
349 }
350 } else {
351 if (q->tx_timer) {
352 timer_del(q->tx_timer);
353 } else {
354 qemu_bh_cancel(q->tx_bh);
355 }
356 if ((n->status & VIRTIO_NET_S_LINK_UP) == 0 &&
357 (queue_status & VIRTIO_CONFIG_S_DRIVER_OK) &&
358 vdev->vm_running) {
359 /* if tx is waiting we are likely have some packets in tx queue
360 * and disabled notification */
361 q->tx_waiting = 0;
362 virtio_queue_set_notification(q->tx_vq, 1);
363 virtio_net_drop_tx_queue_data(vdev, q->tx_vq);
364 }
365 }
366 }
367 }
368
369 static void virtio_net_set_link_status(NetClientState *nc)
370 {
371 VirtIONet *n = qemu_get_nic_opaque(nc);
372 VirtIODevice *vdev = VIRTIO_DEVICE(n);
373 uint16_t old_status = n->status;
374
375 if (nc->link_down)
376 n->status &= ~VIRTIO_NET_S_LINK_UP;
377 else
378 n->status |= VIRTIO_NET_S_LINK_UP;
379
380 if (n->status != old_status)
381 virtio_notify_config(vdev);
382
383 virtio_net_set_status(vdev, vdev->status);
384 }
385
386 static void rxfilter_notify(NetClientState *nc)
387 {
388 VirtIONet *n = qemu_get_nic_opaque(nc);
389
390 if (nc->rxfilter_notify_enabled) {
391 gchar *path = object_get_canonical_path(OBJECT(n->qdev));
392 qapi_event_send_nic_rx_filter_changed(!!n->netclient_name,
393 n->netclient_name, path);
394 g_free(path);
395
396 /* disable event notification to avoid events flooding */
397 nc->rxfilter_notify_enabled = 0;
398 }
399 }
400
401 static intList *get_vlan_table(VirtIONet *n)
402 {
403 intList *list, *entry;
404 int i, j;
405
406 list = NULL;
407 for (i = 0; i < MAX_VLAN >> 5; i++) {
408 for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
409 if (n->vlans[i] & (1U << j)) {
410 entry = g_malloc0(sizeof(*entry));
411 entry->value = (i << 5) + j;
412 entry->next = list;
413 list = entry;
414 }
415 }
416 }
417
418 return list;
419 }
420
421 static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
422 {
423 VirtIONet *n = qemu_get_nic_opaque(nc);
424 VirtIODevice *vdev = VIRTIO_DEVICE(n);
425 RxFilterInfo *info;
426 strList *str_list, *entry;
427 int i;
428
429 info = g_malloc0(sizeof(*info));
430 info->name = g_strdup(nc->name);
431 info->promiscuous = n->promisc;
432
433 if (n->nouni) {
434 info->unicast = RX_STATE_NONE;
435 } else if (n->alluni) {
436 info->unicast = RX_STATE_ALL;
437 } else {
438 info->unicast = RX_STATE_NORMAL;
439 }
440
441 if (n->nomulti) {
442 info->multicast = RX_STATE_NONE;
443 } else if (n->allmulti) {
444 info->multicast = RX_STATE_ALL;
445 } else {
446 info->multicast = RX_STATE_NORMAL;
447 }
448
449 info->broadcast_allowed = n->nobcast;
450 info->multicast_overflow = n->mac_table.multi_overflow;
451 info->unicast_overflow = n->mac_table.uni_overflow;
452
453 info->main_mac = qemu_mac_strdup_printf(n->mac);
454
455 str_list = NULL;
456 for (i = 0; i < n->mac_table.first_multi; i++) {
457 entry = g_malloc0(sizeof(*entry));
458 entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
459 entry->next = str_list;
460 str_list = entry;
461 }
462 info->unicast_table = str_list;
463
464 str_list = NULL;
465 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
466 entry = g_malloc0(sizeof(*entry));
467 entry->value = qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
468 entry->next = str_list;
469 str_list = entry;
470 }
471 info->multicast_table = str_list;
472 info->vlan_table = get_vlan_table(n);
473
474 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VLAN)) {
475 info->vlan = RX_STATE_ALL;
476 } else if (!info->vlan_table) {
477 info->vlan = RX_STATE_NONE;
478 } else {
479 info->vlan = RX_STATE_NORMAL;
480 }
481
482 /* enable event notification after query */
483 nc->rxfilter_notify_enabled = 1;
484
485 return info;
486 }
487
488 static void virtio_net_reset(VirtIODevice *vdev)
489 {
490 VirtIONet *n = VIRTIO_NET(vdev);
491 int i;
492
493 /* Reset back to compatibility mode */
494 n->promisc = 1;
495 n->allmulti = 0;
496 n->alluni = 0;
497 n->nomulti = 0;
498 n->nouni = 0;
499 n->nobcast = 0;
500 /* multiqueue is disabled by default */
501 n->curr_queues = 1;
502 timer_del(n->announce_timer.tm);
503 n->announce_timer.round = 0;
504 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
505
506 /* Flush any MAC and VLAN filter table state */
507 n->mac_table.in_use = 0;
508 n->mac_table.first_multi = 0;
509 n->mac_table.multi_overflow = 0;
510 n->mac_table.uni_overflow = 0;
511 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
512 memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
513 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
514 memset(n->vlans, 0, MAX_VLAN >> 3);
515
516 /* Flush any async TX */
517 for (i = 0; i < n->max_queues; i++) {
518 NetClientState *nc = qemu_get_subqueue(n->nic, i);
519
520 if (nc->peer) {
521 qemu_flush_or_purge_queued_packets(nc->peer, true);
522 assert(!virtio_net_get_subqueue(nc)->async_tx.elem);
523 }
524 }
525 }
526
527 static void peer_test_vnet_hdr(VirtIONet *n)
528 {
529 NetClientState *nc = qemu_get_queue(n->nic);
530 if (!nc->peer) {
531 return;
532 }
533
534 n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
535 }
536
537 static int peer_has_vnet_hdr(VirtIONet *n)
538 {
539 return n->has_vnet_hdr;
540 }
541
542 static int peer_has_ufo(VirtIONet *n)
543 {
544 if (!peer_has_vnet_hdr(n))
545 return 0;
546
547 n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
548
549 return n->has_ufo;
550 }
551
552 static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs,
553 int version_1)
554 {
555 int i;
556 NetClientState *nc;
557
558 n->mergeable_rx_bufs = mergeable_rx_bufs;
559
560 if (version_1) {
561 n->guest_hdr_len = sizeof(struct virtio_net_hdr_mrg_rxbuf);
562 } else {
563 n->guest_hdr_len = n->mergeable_rx_bufs ?
564 sizeof(struct virtio_net_hdr_mrg_rxbuf) :
565 sizeof(struct virtio_net_hdr);
566 }
567
568 for (i = 0; i < n->max_queues; i++) {
569 nc = qemu_get_subqueue(n->nic, i);
570
571 if (peer_has_vnet_hdr(n) &&
572 qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
573 qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
574 n->host_hdr_len = n->guest_hdr_len;
575 }
576 }
577 }
578
579 static int virtio_net_max_tx_queue_size(VirtIONet *n)
580 {
581 NetClientState *peer = n->nic_conf.peers.ncs[0];
582
583 /*
584 * Backends other than vhost-user don't support max queue size.
585 */
586 if (!peer) {
587 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
588 }
589
590 if (peer->info->type != NET_CLIENT_DRIVER_VHOST_USER) {
591 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
592 }
593
594 return VIRTQUEUE_MAX_SIZE;
595 }
596
597 static int peer_attach(VirtIONet *n, int index)
598 {
599 NetClientState *nc = qemu_get_subqueue(n->nic, index);
600
601 if (!nc->peer) {
602 return 0;
603 }
604
605 if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
606 vhost_set_vring_enable(nc->peer, 1);
607 }
608
609 if (nc->peer->info->type != NET_CLIENT_DRIVER_TAP) {
610 return 0;
611 }
612
613 if (n->max_queues == 1) {
614 return 0;
615 }
616
617 return tap_enable(nc->peer);
618 }
619
620 static int peer_detach(VirtIONet *n, int index)
621 {
622 NetClientState *nc = qemu_get_subqueue(n->nic, index);
623
624 if (!nc->peer) {
625 return 0;
626 }
627
628 if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
629 vhost_set_vring_enable(nc->peer, 0);
630 }
631
632 if (nc->peer->info->type != NET_CLIENT_DRIVER_TAP) {
633 return 0;
634 }
635
636 return tap_disable(nc->peer);
637 }
638
639 static void virtio_net_set_queues(VirtIONet *n)
640 {
641 int i;
642 int r;
643
644 if (n->nic->peer_deleted) {
645 return;
646 }
647
648 for (i = 0; i < n->max_queues; i++) {
649 if (i < n->curr_queues) {
650 r = peer_attach(n, i);
651 assert(!r);
652 } else {
653 r = peer_detach(n, i);
654 assert(!r);
655 }
656 }
657 }
658
659 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
660
661 static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
662 Error **errp)
663 {
664 VirtIONet *n = VIRTIO_NET(vdev);
665 NetClientState *nc = qemu_get_queue(n->nic);
666
667 /* Firstly sync all virtio-net possible supported features */
668 features |= n->host_features;
669
670 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
671
672 if (!peer_has_vnet_hdr(n)) {
673 virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
674 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
675 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
676 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
677
678 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
679 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
680 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
681 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
682 }
683
684 if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
685 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
686 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
687 }
688
689 if (!get_vhost_net(nc->peer)) {
690 return features;
691 }
692
693 features = vhost_net_get_features(get_vhost_net(nc->peer), features);
694 vdev->backend_features = features;
695
696 if (n->mtu_bypass_backend &&
697 (n->host_features & 1ULL << VIRTIO_NET_F_MTU)) {
698 features |= (1ULL << VIRTIO_NET_F_MTU);
699 }
700
701 return features;
702 }
703
704 static uint64_t virtio_net_bad_features(VirtIODevice *vdev)
705 {
706 uint64_t features = 0;
707
708 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
709 * but also these: */
710 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
711 virtio_add_feature(&features, VIRTIO_NET_F_CSUM);
712 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO4);
713 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO6);
714 virtio_add_feature(&features, VIRTIO_NET_F_HOST_ECN);
715
716 return features;
717 }
718
719 static void virtio_net_apply_guest_offloads(VirtIONet *n)
720 {
721 qemu_set_offload(qemu_get_queue(n->nic)->peer,
722 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
723 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
724 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
725 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
726 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
727 }
728
729 static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
730 {
731 static const uint64_t guest_offloads_mask =
732 (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
733 (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
734 (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
735 (1ULL << VIRTIO_NET_F_GUEST_ECN) |
736 (1ULL << VIRTIO_NET_F_GUEST_UFO);
737
738 return guest_offloads_mask & features;
739 }
740
741 static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
742 {
743 VirtIODevice *vdev = VIRTIO_DEVICE(n);
744 return virtio_net_guest_offloads_by_features(vdev->guest_features);
745 }
746
747 static void virtio_net_set_features(VirtIODevice *vdev, uint64_t features)
748 {
749 VirtIONet *n = VIRTIO_NET(vdev);
750 int i;
751
752 if (n->mtu_bypass_backend &&
753 !virtio_has_feature(vdev->backend_features, VIRTIO_NET_F_MTU)) {
754 features &= ~(1ULL << VIRTIO_NET_F_MTU);
755 }
756
757 virtio_net_set_multiqueue(n,
758 virtio_has_feature(features, VIRTIO_NET_F_MQ));
759
760 virtio_net_set_mrg_rx_bufs(n,
761 virtio_has_feature(features,
762 VIRTIO_NET_F_MRG_RXBUF),
763 virtio_has_feature(features,
764 VIRTIO_F_VERSION_1));
765
766 n->rsc4_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
767 virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO4);
768 n->rsc6_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
769 virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO6);
770
771 if (n->has_vnet_hdr) {
772 n->curr_guest_offloads =
773 virtio_net_guest_offloads_by_features(features);
774 virtio_net_apply_guest_offloads(n);
775 }
776
777 for (i = 0; i < n->max_queues; i++) {
778 NetClientState *nc = qemu_get_subqueue(n->nic, i);
779
780 if (!get_vhost_net(nc->peer)) {
781 continue;
782 }
783 vhost_net_ack_features(get_vhost_net(nc->peer), features);
784 }
785
786 if (virtio_has_feature(features, VIRTIO_NET_F_CTRL_VLAN)) {
787 memset(n->vlans, 0, MAX_VLAN >> 3);
788 } else {
789 memset(n->vlans, 0xff, MAX_VLAN >> 3);
790 }
791 }
792
793 static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
794 struct iovec *iov, unsigned int iov_cnt)
795 {
796 uint8_t on;
797 size_t s;
798 NetClientState *nc = qemu_get_queue(n->nic);
799
800 s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
801 if (s != sizeof(on)) {
802 return VIRTIO_NET_ERR;
803 }
804
805 if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
806 n->promisc = on;
807 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
808 n->allmulti = on;
809 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
810 n->alluni = on;
811 } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
812 n->nomulti = on;
813 } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
814 n->nouni = on;
815 } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
816 n->nobcast = on;
817 } else {
818 return VIRTIO_NET_ERR;
819 }
820
821 rxfilter_notify(nc);
822
823 return VIRTIO_NET_OK;
824 }
825
826 static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
827 struct iovec *iov, unsigned int iov_cnt)
828 {
829 VirtIODevice *vdev = VIRTIO_DEVICE(n);
830 uint64_t offloads;
831 size_t s;
832
833 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
834 return VIRTIO_NET_ERR;
835 }
836
837 s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
838 if (s != sizeof(offloads)) {
839 return VIRTIO_NET_ERR;
840 }
841
842 if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
843 uint64_t supported_offloads;
844
845 offloads = virtio_ldq_p(vdev, &offloads);
846
847 if (!n->has_vnet_hdr) {
848 return VIRTIO_NET_ERR;
849 }
850
851 n->rsc4_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
852 virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO4);
853 n->rsc6_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
854 virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO6);
855 virtio_clear_feature(&offloads, VIRTIO_NET_F_RSC_EXT);
856
857 supported_offloads = virtio_net_supported_guest_offloads(n);
858 if (offloads & ~supported_offloads) {
859 return VIRTIO_NET_ERR;
860 }
861
862 n->curr_guest_offloads = offloads;
863 virtio_net_apply_guest_offloads(n);
864
865 return VIRTIO_NET_OK;
866 } else {
867 return VIRTIO_NET_ERR;
868 }
869 }
870
871 static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
872 struct iovec *iov, unsigned int iov_cnt)
873 {
874 VirtIODevice *vdev = VIRTIO_DEVICE(n);
875 struct virtio_net_ctrl_mac mac_data;
876 size_t s;
877 NetClientState *nc = qemu_get_queue(n->nic);
878
879 if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
880 if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
881 return VIRTIO_NET_ERR;
882 }
883 s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
884 assert(s == sizeof(n->mac));
885 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
886 rxfilter_notify(nc);
887
888 return VIRTIO_NET_OK;
889 }
890
891 if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
892 return VIRTIO_NET_ERR;
893 }
894
895 int in_use = 0;
896 int first_multi = 0;
897 uint8_t uni_overflow = 0;
898 uint8_t multi_overflow = 0;
899 uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
900
901 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
902 sizeof(mac_data.entries));
903 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
904 if (s != sizeof(mac_data.entries)) {
905 goto error;
906 }
907 iov_discard_front(&iov, &iov_cnt, s);
908
909 if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
910 goto error;
911 }
912
913 if (mac_data.entries <= MAC_TABLE_ENTRIES) {
914 s = iov_to_buf(iov, iov_cnt, 0, macs,
915 mac_data.entries * ETH_ALEN);
916 if (s != mac_data.entries * ETH_ALEN) {
917 goto error;
918 }
919 in_use += mac_data.entries;
920 } else {
921 uni_overflow = 1;
922 }
923
924 iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
925
926 first_multi = in_use;
927
928 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
929 sizeof(mac_data.entries));
930 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
931 if (s != sizeof(mac_data.entries)) {
932 goto error;
933 }
934
935 iov_discard_front(&iov, &iov_cnt, s);
936
937 if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
938 goto error;
939 }
940
941 if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
942 s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
943 mac_data.entries * ETH_ALEN);
944 if (s != mac_data.entries * ETH_ALEN) {
945 goto error;
946 }
947 in_use += mac_data.entries;
948 } else {
949 multi_overflow = 1;
950 }
951
952 n->mac_table.in_use = in_use;
953 n->mac_table.first_multi = first_multi;
954 n->mac_table.uni_overflow = uni_overflow;
955 n->mac_table.multi_overflow = multi_overflow;
956 memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
957 g_free(macs);
958 rxfilter_notify(nc);
959
960 return VIRTIO_NET_OK;
961
962 error:
963 g_free(macs);
964 return VIRTIO_NET_ERR;
965 }
966
967 static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
968 struct iovec *iov, unsigned int iov_cnt)
969 {
970 VirtIODevice *vdev = VIRTIO_DEVICE(n);
971 uint16_t vid;
972 size_t s;
973 NetClientState *nc = qemu_get_queue(n->nic);
974
975 s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
976 vid = virtio_lduw_p(vdev, &vid);
977 if (s != sizeof(vid)) {
978 return VIRTIO_NET_ERR;
979 }
980
981 if (vid >= MAX_VLAN)
982 return VIRTIO_NET_ERR;
983
984 if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
985 n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
986 else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
987 n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
988 else
989 return VIRTIO_NET_ERR;
990
991 rxfilter_notify(nc);
992
993 return VIRTIO_NET_OK;
994 }
995
996 static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
997 struct iovec *iov, unsigned int iov_cnt)
998 {
999 trace_virtio_net_handle_announce(n->announce_timer.round);
1000 if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
1001 n->status & VIRTIO_NET_S_ANNOUNCE) {
1002 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
1003 if (n->announce_timer.round) {
1004 qemu_announce_timer_step(&n->announce_timer);
1005 }
1006 return VIRTIO_NET_OK;
1007 } else {
1008 return VIRTIO_NET_ERR;
1009 }
1010 }
1011
1012 static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
1013 struct iovec *iov, unsigned int iov_cnt)
1014 {
1015 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1016 struct virtio_net_ctrl_mq mq;
1017 size_t s;
1018 uint16_t queues;
1019
1020 s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
1021 if (s != sizeof(mq)) {
1022 return VIRTIO_NET_ERR;
1023 }
1024
1025 if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
1026 return VIRTIO_NET_ERR;
1027 }
1028
1029 queues = virtio_lduw_p(vdev, &mq.virtqueue_pairs);
1030
1031 if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
1032 queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
1033 queues > n->max_queues ||
1034 !n->multiqueue) {
1035 return VIRTIO_NET_ERR;
1036 }
1037
1038 n->curr_queues = queues;
1039 /* stop the backend before changing the number of queues to avoid handling a
1040 * disabled queue */
1041 virtio_net_set_status(vdev, vdev->status);
1042 virtio_net_set_queues(n);
1043
1044 return VIRTIO_NET_OK;
1045 }
1046
1047 static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
1048 {
1049 VirtIONet *n = VIRTIO_NET(vdev);
1050 struct virtio_net_ctrl_hdr ctrl;
1051 virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
1052 VirtQueueElement *elem;
1053 size_t s;
1054 struct iovec *iov, *iov2;
1055 unsigned int iov_cnt;
1056
1057 for (;;) {
1058 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
1059 if (!elem) {
1060 break;
1061 }
1062 if (iov_size(elem->in_sg, elem->in_num) < sizeof(status) ||
1063 iov_size(elem->out_sg, elem->out_num) < sizeof(ctrl)) {
1064 virtio_error(vdev, "virtio-net ctrl missing headers");
1065 virtqueue_detach_element(vq, elem, 0);
1066 g_free(elem);
1067 break;
1068 }
1069
1070 iov_cnt = elem->out_num;
1071 iov2 = iov = g_memdup(elem->out_sg, sizeof(struct iovec) * elem->out_num);
1072 s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
1073 iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
1074 if (s != sizeof(ctrl)) {
1075 status = VIRTIO_NET_ERR;
1076 } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
1077 status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
1078 } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
1079 status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
1080 } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
1081 status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
1082 } else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
1083 status = virtio_net_handle_announce(n, ctrl.cmd, iov, iov_cnt);
1084 } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
1085 status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
1086 } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
1087 status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
1088 }
1089
1090 s = iov_from_buf(elem->in_sg, elem->in_num, 0, &status, sizeof(status));
1091 assert(s == sizeof(status));
1092
1093 virtqueue_push(vq, elem, sizeof(status));
1094 virtio_notify(vdev, vq);
1095 g_free(iov2);
1096 g_free(elem);
1097 }
1098 }
1099
1100 /* RX */
1101
1102 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
1103 {
1104 VirtIONet *n = VIRTIO_NET(vdev);
1105 int queue_index = vq2q(virtio_get_queue_index(vq));
1106
1107 qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
1108 }
1109
1110 static int virtio_net_can_receive(NetClientState *nc)
1111 {
1112 VirtIONet *n = qemu_get_nic_opaque(nc);
1113 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1114 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1115
1116 if (!vdev->vm_running) {
1117 return 0;
1118 }
1119
1120 if (nc->queue_index >= n->curr_queues) {
1121 return 0;
1122 }
1123
1124 if (!virtio_queue_ready(q->rx_vq) ||
1125 !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1126 return 0;
1127 }
1128
1129 return 1;
1130 }
1131
1132 static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
1133 {
1134 VirtIONet *n = q->n;
1135 if (virtio_queue_empty(q->rx_vq) ||
1136 (n->mergeable_rx_bufs &&
1137 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
1138 virtio_queue_set_notification(q->rx_vq, 1);
1139
1140 /* To avoid a race condition where the guest has made some buffers
1141 * available after the above check but before notification was
1142 * enabled, check for available buffers again.
1143 */
1144 if (virtio_queue_empty(q->rx_vq) ||
1145 (n->mergeable_rx_bufs &&
1146 !virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
1147 return 0;
1148 }
1149 }
1150
1151 virtio_queue_set_notification(q->rx_vq, 0);
1152 return 1;
1153 }
1154
1155 static void virtio_net_hdr_swap(VirtIODevice *vdev, struct virtio_net_hdr *hdr)
1156 {
1157 virtio_tswap16s(vdev, &hdr->hdr_len);
1158 virtio_tswap16s(vdev, &hdr->gso_size);
1159 virtio_tswap16s(vdev, &hdr->csum_start);
1160 virtio_tswap16s(vdev, &hdr->csum_offset);
1161 }
1162
1163 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
1164 * it never finds out that the packets don't have valid checksums. This
1165 * causes dhclient to get upset. Fedora's carried a patch for ages to
1166 * fix this with Xen but it hasn't appeared in an upstream release of
1167 * dhclient yet.
1168 *
1169 * To avoid breaking existing guests, we catch udp packets and add
1170 * checksums. This is terrible but it's better than hacking the guest
1171 * kernels.
1172 *
1173 * N.B. if we introduce a zero-copy API, this operation is no longer free so
1174 * we should provide a mechanism to disable it to avoid polluting the host
1175 * cache.
1176 */
1177 static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
1178 uint8_t *buf, size_t size)
1179 {
1180 if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
1181 (size > 27 && size < 1500) && /* normal sized MTU */
1182 (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
1183 (buf[23] == 17) && /* ip.protocol == UDP */
1184 (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
1185 net_checksum_calculate(buf, size);
1186 hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
1187 }
1188 }
1189
1190 static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
1191 const void *buf, size_t size)
1192 {
1193 if (n->has_vnet_hdr) {
1194 /* FIXME this cast is evil */
1195 void *wbuf = (void *)buf;
1196 work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
1197 size - n->host_hdr_len);
1198
1199 if (n->needs_vnet_hdr_swap) {
1200 virtio_net_hdr_swap(VIRTIO_DEVICE(n), wbuf);
1201 }
1202 iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
1203 } else {
1204 struct virtio_net_hdr hdr = {
1205 .flags = 0,
1206 .gso_type = VIRTIO_NET_HDR_GSO_NONE
1207 };
1208 iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
1209 }
1210 }
1211
1212 static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
1213 {
1214 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1215 static const uint8_t vlan[] = {0x81, 0x00};
1216 uint8_t *ptr = (uint8_t *)buf;
1217 int i;
1218
1219 if (n->promisc)
1220 return 1;
1221
1222 ptr += n->host_hdr_len;
1223
1224 if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
1225 int vid = lduw_be_p(ptr + 14) & 0xfff;
1226 if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
1227 return 0;
1228 }
1229
1230 if (ptr[0] & 1) { // multicast
1231 if (!memcmp(ptr, bcast, sizeof(bcast))) {
1232 return !n->nobcast;
1233 } else if (n->nomulti) {
1234 return 0;
1235 } else if (n->allmulti || n->mac_table.multi_overflow) {
1236 return 1;
1237 }
1238
1239 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
1240 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1241 return 1;
1242 }
1243 }
1244 } else { // unicast
1245 if (n->nouni) {
1246 return 0;
1247 } else if (n->alluni || n->mac_table.uni_overflow) {
1248 return 1;
1249 } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
1250 return 1;
1251 }
1252
1253 for (i = 0; i < n->mac_table.first_multi; i++) {
1254 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1255 return 1;
1256 }
1257 }
1258 }
1259
1260 return 0;
1261 }
1262
1263 static ssize_t virtio_net_receive_rcu(NetClientState *nc, const uint8_t *buf,
1264 size_t size)
1265 {
1266 VirtIONet *n = qemu_get_nic_opaque(nc);
1267 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1268 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1269 struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
1270 struct virtio_net_hdr_mrg_rxbuf mhdr;
1271 unsigned mhdr_cnt = 0;
1272 size_t offset, i, guest_offset;
1273
1274 if (!virtio_net_can_receive(nc)) {
1275 return -1;
1276 }
1277
1278 /* hdr_len refers to the header we supply to the guest */
1279 if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
1280 return 0;
1281 }
1282
1283 if (!receive_filter(n, buf, size))
1284 return size;
1285
1286 offset = i = 0;
1287
1288 while (offset < size) {
1289 VirtQueueElement *elem;
1290 int len, total;
1291 const struct iovec *sg;
1292
1293 total = 0;
1294
1295 elem = virtqueue_pop(q->rx_vq, sizeof(VirtQueueElement));
1296 if (!elem) {
1297 if (i) {
1298 virtio_error(vdev, "virtio-net unexpected empty queue: "
1299 "i %zd mergeable %d offset %zd, size %zd, "
1300 "guest hdr len %zd, host hdr len %zd "
1301 "guest features 0x%" PRIx64,
1302 i, n->mergeable_rx_bufs, offset, size,
1303 n->guest_hdr_len, n->host_hdr_len,
1304 vdev->guest_features);
1305 }
1306 return -1;
1307 }
1308
1309 if (elem->in_num < 1) {
1310 virtio_error(vdev,
1311 "virtio-net receive queue contains no in buffers");
1312 virtqueue_detach_element(q->rx_vq, elem, 0);
1313 g_free(elem);
1314 return -1;
1315 }
1316
1317 sg = elem->in_sg;
1318 if (i == 0) {
1319 assert(offset == 0);
1320 if (n->mergeable_rx_bufs) {
1321 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
1322 sg, elem->in_num,
1323 offsetof(typeof(mhdr), num_buffers),
1324 sizeof(mhdr.num_buffers));
1325 }
1326
1327 receive_header(n, sg, elem->in_num, buf, size);
1328 offset = n->host_hdr_len;
1329 total += n->guest_hdr_len;
1330 guest_offset = n->guest_hdr_len;
1331 } else {
1332 guest_offset = 0;
1333 }
1334
1335 /* copy in packet. ugh */
1336 len = iov_from_buf(sg, elem->in_num, guest_offset,
1337 buf + offset, size - offset);
1338 total += len;
1339 offset += len;
1340 /* If buffers can't be merged, at this point we
1341 * must have consumed the complete packet.
1342 * Otherwise, drop it. */
1343 if (!n->mergeable_rx_bufs && offset < size) {
1344 virtqueue_unpop(q->rx_vq, elem, total);
1345 g_free(elem);
1346 return size;
1347 }
1348
1349 /* signal other side */
1350 virtqueue_fill(q->rx_vq, elem, total, i++);
1351 g_free(elem);
1352 }
1353
1354 if (mhdr_cnt) {
1355 virtio_stw_p(vdev, &mhdr.num_buffers, i);
1356 iov_from_buf(mhdr_sg, mhdr_cnt,
1357 0,
1358 &mhdr.num_buffers, sizeof mhdr.num_buffers);
1359 }
1360
1361 virtqueue_flush(q->rx_vq, i);
1362 virtio_notify(vdev, q->rx_vq);
1363
1364 return size;
1365 }
1366
1367 static ssize_t virtio_net_do_receive(NetClientState *nc, const uint8_t *buf,
1368 size_t size)
1369 {
1370 ssize_t r;
1371
1372 rcu_read_lock();
1373 r = virtio_net_receive_rcu(nc, buf, size);
1374 rcu_read_unlock();
1375 return r;
1376 }
1377
1378 static void virtio_net_rsc_extract_unit4(VirtioNetRscChain *chain,
1379 const uint8_t *buf,
1380 VirtioNetRscUnit *unit)
1381 {
1382 uint16_t ip_hdrlen;
1383 struct ip_header *ip;
1384
1385 ip = (struct ip_header *)(buf + chain->n->guest_hdr_len
1386 + sizeof(struct eth_header));
1387 unit->ip = (void *)ip;
1388 ip_hdrlen = (ip->ip_ver_len & 0xF) << 2;
1389 unit->ip_plen = &ip->ip_len;
1390 unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip) + ip_hdrlen);
1391 unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
1392 unit->payload = htons(*unit->ip_plen) - ip_hdrlen - unit->tcp_hdrlen;
1393 }
1394
1395 static void virtio_net_rsc_extract_unit6(VirtioNetRscChain *chain,
1396 const uint8_t *buf,
1397 VirtioNetRscUnit *unit)
1398 {
1399 struct ip6_header *ip6;
1400
1401 ip6 = (struct ip6_header *)(buf + chain->n->guest_hdr_len
1402 + sizeof(struct eth_header));
1403 unit->ip = ip6;
1404 unit->ip_plen = &(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
1405 unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip)\
1406 + sizeof(struct ip6_header));
1407 unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
1408
1409 /* There is a difference between payload lenght in ipv4 and v6,
1410 ip header is excluded in ipv6 */
1411 unit->payload = htons(*unit->ip_plen) - unit->tcp_hdrlen;
1412 }
1413
1414 static size_t virtio_net_rsc_drain_seg(VirtioNetRscChain *chain,
1415 VirtioNetRscSeg *seg)
1416 {
1417 int ret;
1418 struct virtio_net_hdr *h;
1419
1420 h = (struct virtio_net_hdr *)seg->buf;
1421 h->flags = 0;
1422 h->gso_type = VIRTIO_NET_HDR_GSO_NONE;
1423
1424 if (seg->is_coalesced) {
1425 *virtio_net_rsc_ext_num_packets(h) = seg->packets;
1426 *virtio_net_rsc_ext_num_dupacks(h) = seg->dup_ack;
1427 h->flags = VIRTIO_NET_HDR_F_RSC_INFO;
1428 if (chain->proto == ETH_P_IP) {
1429 h->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
1430 } else {
1431 h->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
1432 }
1433 }
1434
1435 ret = virtio_net_do_receive(seg->nc, seg->buf, seg->size);
1436 QTAILQ_REMOVE(&chain->buffers, seg, next);
1437 g_free(seg->buf);
1438 g_free(seg);
1439
1440 return ret;
1441 }
1442
1443 static void virtio_net_rsc_purge(void *opq)
1444 {
1445 VirtioNetRscSeg *seg, *rn;
1446 VirtioNetRscChain *chain = (VirtioNetRscChain *)opq;
1447
1448 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn) {
1449 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1450 chain->stat.purge_failed++;
1451 continue;
1452 }
1453 }
1454
1455 chain->stat.timer++;
1456 if (!QTAILQ_EMPTY(&chain->buffers)) {
1457 timer_mod(chain->drain_timer,
1458 qemu_clock_get_ns(QEMU_CLOCK_HOST) + chain->n->rsc_timeout);
1459 }
1460 }
1461
1462 static void virtio_net_rsc_cleanup(VirtIONet *n)
1463 {
1464 VirtioNetRscChain *chain, *rn_chain;
1465 VirtioNetRscSeg *seg, *rn_seg;
1466
1467 QTAILQ_FOREACH_SAFE(chain, &n->rsc_chains, next, rn_chain) {
1468 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn_seg) {
1469 QTAILQ_REMOVE(&chain->buffers, seg, next);
1470 g_free(seg->buf);
1471 g_free(seg);
1472 }
1473
1474 timer_del(chain->drain_timer);
1475 timer_free(chain->drain_timer);
1476 QTAILQ_REMOVE(&n->rsc_chains, chain, next);
1477 g_free(chain);
1478 }
1479 }
1480
1481 static void virtio_net_rsc_cache_buf(VirtioNetRscChain *chain,
1482 NetClientState *nc,
1483 const uint8_t *buf, size_t size)
1484 {
1485 uint16_t hdr_len;
1486 VirtioNetRscSeg *seg;
1487
1488 hdr_len = chain->n->guest_hdr_len;
1489 seg = g_malloc(sizeof(VirtioNetRscSeg));
1490 seg->buf = g_malloc(hdr_len + sizeof(struct eth_header)
1491 + sizeof(struct ip6_header) + VIRTIO_NET_MAX_TCP_PAYLOAD);
1492 memcpy(seg->buf, buf, size);
1493 seg->size = size;
1494 seg->packets = 1;
1495 seg->dup_ack = 0;
1496 seg->is_coalesced = 0;
1497 seg->nc = nc;
1498
1499 QTAILQ_INSERT_TAIL(&chain->buffers, seg, next);
1500 chain->stat.cache++;
1501
1502 switch (chain->proto) {
1503 case ETH_P_IP:
1504 virtio_net_rsc_extract_unit4(chain, seg->buf, &seg->unit);
1505 break;
1506 case ETH_P_IPV6:
1507 virtio_net_rsc_extract_unit6(chain, seg->buf, &seg->unit);
1508 break;
1509 default:
1510 g_assert_not_reached();
1511 }
1512 }
1513
1514 static int32_t virtio_net_rsc_handle_ack(VirtioNetRscChain *chain,
1515 VirtioNetRscSeg *seg,
1516 const uint8_t *buf,
1517 struct tcp_header *n_tcp,
1518 struct tcp_header *o_tcp)
1519 {
1520 uint32_t nack, oack;
1521 uint16_t nwin, owin;
1522
1523 nack = htonl(n_tcp->th_ack);
1524 nwin = htons(n_tcp->th_win);
1525 oack = htonl(o_tcp->th_ack);
1526 owin = htons(o_tcp->th_win);
1527
1528 if ((nack - oack) >= VIRTIO_NET_MAX_TCP_PAYLOAD) {
1529 chain->stat.ack_out_of_win++;
1530 return RSC_FINAL;
1531 } else if (nack == oack) {
1532 /* duplicated ack or window probe */
1533 if (nwin == owin) {
1534 /* duplicated ack, add dup ack count due to whql test up to 1 */
1535 chain->stat.dup_ack++;
1536 return RSC_FINAL;
1537 } else {
1538 /* Coalesce window update */
1539 o_tcp->th_win = n_tcp->th_win;
1540 chain->stat.win_update++;
1541 return RSC_COALESCE;
1542 }
1543 } else {
1544 /* pure ack, go to 'C', finalize*/
1545 chain->stat.pure_ack++;
1546 return RSC_FINAL;
1547 }
1548 }
1549
1550 static int32_t virtio_net_rsc_coalesce_data(VirtioNetRscChain *chain,
1551 VirtioNetRscSeg *seg,
1552 const uint8_t *buf,
1553 VirtioNetRscUnit *n_unit)
1554 {
1555 void *data;
1556 uint16_t o_ip_len;
1557 uint32_t nseq, oseq;
1558 VirtioNetRscUnit *o_unit;
1559
1560 o_unit = &seg->unit;
1561 o_ip_len = htons(*o_unit->ip_plen);
1562 nseq = htonl(n_unit->tcp->th_seq);
1563 oseq = htonl(o_unit->tcp->th_seq);
1564
1565 /* out of order or retransmitted. */
1566 if ((nseq - oseq) > VIRTIO_NET_MAX_TCP_PAYLOAD) {
1567 chain->stat.data_out_of_win++;
1568 return RSC_FINAL;
1569 }
1570
1571 data = ((uint8_t *)n_unit->tcp) + n_unit->tcp_hdrlen;
1572 if (nseq == oseq) {
1573 if ((o_unit->payload == 0) && n_unit->payload) {
1574 /* From no payload to payload, normal case, not a dup ack or etc */
1575 chain->stat.data_after_pure_ack++;
1576 goto coalesce;
1577 } else {
1578 return virtio_net_rsc_handle_ack(chain, seg, buf,
1579 n_unit->tcp, o_unit->tcp);
1580 }
1581 } else if ((nseq - oseq) != o_unit->payload) {
1582 /* Not a consistent packet, out of order */
1583 chain->stat.data_out_of_order++;
1584 return RSC_FINAL;
1585 } else {
1586 coalesce:
1587 if ((o_ip_len + n_unit->payload) > chain->max_payload) {
1588 chain->stat.over_size++;
1589 return RSC_FINAL;
1590 }
1591
1592 /* Here comes the right data, the payload length in v4/v6 is different,
1593 so use the field value to update and record the new data len */
1594 o_unit->payload += n_unit->payload; /* update new data len */
1595
1596 /* update field in ip header */
1597 *o_unit->ip_plen = htons(o_ip_len + n_unit->payload);
1598
1599 /* Bring 'PUSH' big, the whql test guide says 'PUSH' can be coalesced
1600 for windows guest, while this may change the behavior for linux
1601 guest (only if it uses RSC feature). */
1602 o_unit->tcp->th_offset_flags = n_unit->tcp->th_offset_flags;
1603
1604 o_unit->tcp->th_ack = n_unit->tcp->th_ack;
1605 o_unit->tcp->th_win = n_unit->tcp->th_win;
1606
1607 memmove(seg->buf + seg->size, data, n_unit->payload);
1608 seg->size += n_unit->payload;
1609 seg->packets++;
1610 chain->stat.coalesced++;
1611 return RSC_COALESCE;
1612 }
1613 }
1614
1615 static int32_t virtio_net_rsc_coalesce4(VirtioNetRscChain *chain,
1616 VirtioNetRscSeg *seg,
1617 const uint8_t *buf, size_t size,
1618 VirtioNetRscUnit *unit)
1619 {
1620 struct ip_header *ip1, *ip2;
1621
1622 ip1 = (struct ip_header *)(unit->ip);
1623 ip2 = (struct ip_header *)(seg->unit.ip);
1624 if ((ip1->ip_src ^ ip2->ip_src) || (ip1->ip_dst ^ ip2->ip_dst)
1625 || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
1626 || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
1627 chain->stat.no_match++;
1628 return RSC_NO_MATCH;
1629 }
1630
1631 return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
1632 }
1633
1634 static int32_t virtio_net_rsc_coalesce6(VirtioNetRscChain *chain,
1635 VirtioNetRscSeg *seg,
1636 const uint8_t *buf, size_t size,
1637 VirtioNetRscUnit *unit)
1638 {
1639 struct ip6_header *ip1, *ip2;
1640
1641 ip1 = (struct ip6_header *)(unit->ip);
1642 ip2 = (struct ip6_header *)(seg->unit.ip);
1643 if (memcmp(&ip1->ip6_src, &ip2->ip6_src, sizeof(struct in6_address))
1644 || memcmp(&ip1->ip6_dst, &ip2->ip6_dst, sizeof(struct in6_address))
1645 || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
1646 || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
1647 chain->stat.no_match++;
1648 return RSC_NO_MATCH;
1649 }
1650
1651 return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
1652 }
1653
1654 /* Packets with 'SYN' should bypass, other flag should be sent after drain
1655 * to prevent out of order */
1656 static int virtio_net_rsc_tcp_ctrl_check(VirtioNetRscChain *chain,
1657 struct tcp_header *tcp)
1658 {
1659 uint16_t tcp_hdr;
1660 uint16_t tcp_flag;
1661
1662 tcp_flag = htons(tcp->th_offset_flags);
1663 tcp_hdr = (tcp_flag & VIRTIO_NET_TCP_HDR_LENGTH) >> 10;
1664 tcp_flag &= VIRTIO_NET_TCP_FLAG;
1665 tcp_flag = htons(tcp->th_offset_flags) & 0x3F;
1666 if (tcp_flag & TH_SYN) {
1667 chain->stat.tcp_syn++;
1668 return RSC_BYPASS;
1669 }
1670
1671 if (tcp_flag & (TH_FIN | TH_URG | TH_RST | TH_ECE | TH_CWR)) {
1672 chain->stat.tcp_ctrl_drain++;
1673 return RSC_FINAL;
1674 }
1675
1676 if (tcp_hdr > sizeof(struct tcp_header)) {
1677 chain->stat.tcp_all_opt++;
1678 return RSC_FINAL;
1679 }
1680
1681 return RSC_CANDIDATE;
1682 }
1683
1684 static size_t virtio_net_rsc_do_coalesce(VirtioNetRscChain *chain,
1685 NetClientState *nc,
1686 const uint8_t *buf, size_t size,
1687 VirtioNetRscUnit *unit)
1688 {
1689 int ret;
1690 VirtioNetRscSeg *seg, *nseg;
1691
1692 if (QTAILQ_EMPTY(&chain->buffers)) {
1693 chain->stat.empty_cache++;
1694 virtio_net_rsc_cache_buf(chain, nc, buf, size);
1695 timer_mod(chain->drain_timer,
1696 qemu_clock_get_ns(QEMU_CLOCK_HOST) + chain->n->rsc_timeout);
1697 return size;
1698 }
1699
1700 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
1701 if (chain->proto == ETH_P_IP) {
1702 ret = virtio_net_rsc_coalesce4(chain, seg, buf, size, unit);
1703 } else {
1704 ret = virtio_net_rsc_coalesce6(chain, seg, buf, size, unit);
1705 }
1706
1707 if (ret == RSC_FINAL) {
1708 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1709 /* Send failed */
1710 chain->stat.final_failed++;
1711 return 0;
1712 }
1713
1714 /* Send current packet */
1715 return virtio_net_do_receive(nc, buf, size);
1716 } else if (ret == RSC_NO_MATCH) {
1717 continue;
1718 } else {
1719 /* Coalesced, mark coalesced flag to tell calc cksum for ipv4 */
1720 seg->is_coalesced = 1;
1721 return size;
1722 }
1723 }
1724
1725 chain->stat.no_match_cache++;
1726 virtio_net_rsc_cache_buf(chain, nc, buf, size);
1727 return size;
1728 }
1729
1730 /* Drain a connection data, this is to avoid out of order segments */
1731 static size_t virtio_net_rsc_drain_flow(VirtioNetRscChain *chain,
1732 NetClientState *nc,
1733 const uint8_t *buf, size_t size,
1734 uint16_t ip_start, uint16_t ip_size,
1735 uint16_t tcp_port)
1736 {
1737 VirtioNetRscSeg *seg, *nseg;
1738 uint32_t ppair1, ppair2;
1739
1740 ppair1 = *(uint32_t *)(buf + tcp_port);
1741 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
1742 ppair2 = *(uint32_t *)(seg->buf + tcp_port);
1743 if (memcmp(buf + ip_start, seg->buf + ip_start, ip_size)
1744 || (ppair1 != ppair2)) {
1745 continue;
1746 }
1747 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
1748 chain->stat.drain_failed++;
1749 }
1750
1751 break;
1752 }
1753
1754 return virtio_net_do_receive(nc, buf, size);
1755 }
1756
1757 static int32_t virtio_net_rsc_sanity_check4(VirtioNetRscChain *chain,
1758 struct ip_header *ip,
1759 const uint8_t *buf, size_t size)
1760 {
1761 uint16_t ip_len;
1762
1763 /* Not an ipv4 packet */
1764 if (((ip->ip_ver_len & 0xF0) >> 4) != IP_HEADER_VERSION_4) {
1765 chain->stat.ip_option++;
1766 return RSC_BYPASS;
1767 }
1768
1769 /* Don't handle packets with ip option */
1770 if ((ip->ip_ver_len & 0xF) != VIRTIO_NET_IP4_HEADER_LENGTH) {
1771 chain->stat.ip_option++;
1772 return RSC_BYPASS;
1773 }
1774
1775 if (ip->ip_p != IPPROTO_TCP) {
1776 chain->stat.bypass_not_tcp++;
1777 return RSC_BYPASS;
1778 }
1779
1780 /* Don't handle packets with ip fragment */
1781 if (!(htons(ip->ip_off) & IP_DF)) {
1782 chain->stat.ip_frag++;
1783 return RSC_BYPASS;
1784 }
1785
1786 /* Don't handle packets with ecn flag */
1787 if (IPTOS_ECN(ip->ip_tos)) {
1788 chain->stat.ip_ecn++;
1789 return RSC_BYPASS;
1790 }
1791
1792 ip_len = htons(ip->ip_len);
1793 if (ip_len < (sizeof(struct ip_header) + sizeof(struct tcp_header))
1794 || ip_len > (size - chain->n->guest_hdr_len -
1795 sizeof(struct eth_header))) {
1796 chain->stat.ip_hacked++;
1797 return RSC_BYPASS;
1798 }
1799
1800 return RSC_CANDIDATE;
1801 }
1802
1803 static size_t virtio_net_rsc_receive4(VirtioNetRscChain *chain,
1804 NetClientState *nc,
1805 const uint8_t *buf, size_t size)
1806 {
1807 int32_t ret;
1808 uint16_t hdr_len;
1809 VirtioNetRscUnit unit;
1810
1811 hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
1812
1813 if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header)
1814 + sizeof(struct tcp_header))) {
1815 chain->stat.bypass_not_tcp++;
1816 return virtio_net_do_receive(nc, buf, size);
1817 }
1818
1819 virtio_net_rsc_extract_unit4(chain, buf, &unit);
1820 if (virtio_net_rsc_sanity_check4(chain, unit.ip, buf, size)
1821 != RSC_CANDIDATE) {
1822 return virtio_net_do_receive(nc, buf, size);
1823 }
1824
1825 ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
1826 if (ret == RSC_BYPASS) {
1827 return virtio_net_do_receive(nc, buf, size);
1828 } else if (ret == RSC_FINAL) {
1829 return virtio_net_rsc_drain_flow(chain, nc, buf, size,
1830 ((hdr_len + sizeof(struct eth_header)) + 12),
1831 VIRTIO_NET_IP4_ADDR_SIZE,
1832 hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header));
1833 }
1834
1835 return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
1836 }
1837
1838 static int32_t virtio_net_rsc_sanity_check6(VirtioNetRscChain *chain,
1839 struct ip6_header *ip6,
1840 const uint8_t *buf, size_t size)
1841 {
1842 uint16_t ip_len;
1843
1844 if (((ip6->ip6_ctlun.ip6_un1.ip6_un1_flow & 0xF0) >> 4)
1845 != IP_HEADER_VERSION_6) {
1846 return RSC_BYPASS;
1847 }
1848
1849 /* Both option and protocol is checked in this */
1850 if (ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP) {
1851 chain->stat.bypass_not_tcp++;
1852 return RSC_BYPASS;
1853 }
1854
1855 ip_len = htons(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
1856 if (ip_len < sizeof(struct tcp_header) ||
1857 ip_len > (size - chain->n->guest_hdr_len - sizeof(struct eth_header)
1858 - sizeof(struct ip6_header))) {
1859 chain->stat.ip_hacked++;
1860 return RSC_BYPASS;
1861 }
1862
1863 /* Don't handle packets with ecn flag */
1864 if (IP6_ECN(ip6->ip6_ctlun.ip6_un3.ip6_un3_ecn)) {
1865 chain->stat.ip_ecn++;
1866 return RSC_BYPASS;
1867 }
1868
1869 return RSC_CANDIDATE;
1870 }
1871
1872 static size_t virtio_net_rsc_receive6(void *opq, NetClientState *nc,
1873 const uint8_t *buf, size_t size)
1874 {
1875 int32_t ret;
1876 uint16_t hdr_len;
1877 VirtioNetRscChain *chain;
1878 VirtioNetRscUnit unit;
1879
1880 chain = (VirtioNetRscChain *)opq;
1881 hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
1882
1883 if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip6_header)
1884 + sizeof(tcp_header))) {
1885 return virtio_net_do_receive(nc, buf, size);
1886 }
1887
1888 virtio_net_rsc_extract_unit6(chain, buf, &unit);
1889 if (RSC_CANDIDATE != virtio_net_rsc_sanity_check6(chain,
1890 unit.ip, buf, size)) {
1891 return virtio_net_do_receive(nc, buf, size);
1892 }
1893
1894 ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
1895 if (ret == RSC_BYPASS) {
1896 return virtio_net_do_receive(nc, buf, size);
1897 } else if (ret == RSC_FINAL) {
1898 return virtio_net_rsc_drain_flow(chain, nc, buf, size,
1899 ((hdr_len + sizeof(struct eth_header)) + 8),
1900 VIRTIO_NET_IP6_ADDR_SIZE,
1901 hdr_len + sizeof(struct eth_header)
1902 + sizeof(struct ip6_header));
1903 }
1904
1905 return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
1906 }
1907
1908 static VirtioNetRscChain *virtio_net_rsc_lookup_chain(VirtIONet *n,
1909 NetClientState *nc,
1910 uint16_t proto)
1911 {
1912 VirtioNetRscChain *chain;
1913
1914 if ((proto != (uint16_t)ETH_P_IP) && (proto != (uint16_t)ETH_P_IPV6)) {
1915 return NULL;
1916 }
1917
1918 QTAILQ_FOREACH(chain, &n->rsc_chains, next) {
1919 if (chain->proto == proto) {
1920 return chain;
1921 }
1922 }
1923
1924 chain = g_malloc(sizeof(*chain));
1925 chain->n = n;
1926 chain->proto = proto;
1927 if (proto == (uint16_t)ETH_P_IP) {
1928 chain->max_payload = VIRTIO_NET_MAX_IP4_PAYLOAD;
1929 chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
1930 } else {
1931 chain->max_payload = VIRTIO_NET_MAX_IP6_PAYLOAD;
1932 chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
1933 }
1934 chain->drain_timer = timer_new_ns(QEMU_CLOCK_HOST,
1935 virtio_net_rsc_purge, chain);
1936 memset(&chain->stat, 0, sizeof(chain->stat));
1937
1938 QTAILQ_INIT(&chain->buffers);
1939 QTAILQ_INSERT_TAIL(&n->rsc_chains, chain, next);
1940
1941 return chain;
1942 }
1943
1944 static ssize_t virtio_net_rsc_receive(NetClientState *nc,
1945 const uint8_t *buf,
1946 size_t size)
1947 {
1948 uint16_t proto;
1949 VirtioNetRscChain *chain;
1950 struct eth_header *eth;
1951 VirtIONet *n;
1952
1953 n = qemu_get_nic_opaque(nc);
1954 if (size < (n->host_hdr_len + sizeof(struct eth_header))) {
1955 return virtio_net_do_receive(nc, buf, size);
1956 }
1957
1958 eth = (struct eth_header *)(buf + n->guest_hdr_len);
1959 proto = htons(eth->h_proto);
1960
1961 chain = virtio_net_rsc_lookup_chain(n, nc, proto);
1962 if (chain) {
1963 chain->stat.received++;
1964 if (proto == (uint16_t)ETH_P_IP && n->rsc4_enabled) {
1965 return virtio_net_rsc_receive4(chain, nc, buf, size);
1966 } else if (proto == (uint16_t)ETH_P_IPV6 && n->rsc6_enabled) {
1967 return virtio_net_rsc_receive6(chain, nc, buf, size);
1968 }
1969 }
1970 return virtio_net_do_receive(nc, buf, size);
1971 }
1972
1973 static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf,
1974 size_t size)
1975 {
1976 VirtIONet *n = qemu_get_nic_opaque(nc);
1977 if ((n->rsc4_enabled || n->rsc6_enabled)) {
1978 return virtio_net_rsc_receive(nc, buf, size);
1979 } else {
1980 return virtio_net_do_receive(nc, buf, size);
1981 }
1982 }
1983
1984 static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
1985
1986 static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
1987 {
1988 VirtIONet *n = qemu_get_nic_opaque(nc);
1989 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1990 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1991
1992 virtqueue_push(q->tx_vq, q->async_tx.elem, 0);
1993 virtio_notify(vdev, q->tx_vq);
1994
1995 g_free(q->async_tx.elem);
1996 q->async_tx.elem = NULL;
1997
1998 virtio_queue_set_notification(q->tx_vq, 1);
1999 virtio_net_flush_tx(q);
2000 }
2001
2002 /* TX */
2003 static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
2004 {
2005 VirtIONet *n = q->n;
2006 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2007 VirtQueueElement *elem;
2008 int32_t num_packets = 0;
2009 int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
2010 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2011 return num_packets;
2012 }
2013
2014 if (q->async_tx.elem) {
2015 virtio_queue_set_notification(q->tx_vq, 0);
2016 return num_packets;
2017 }
2018
2019 for (;;) {
2020 ssize_t ret;
2021 unsigned int out_num;
2022 struct iovec sg[VIRTQUEUE_MAX_SIZE], sg2[VIRTQUEUE_MAX_SIZE + 1], *out_sg;
2023 struct virtio_net_hdr_mrg_rxbuf mhdr;
2024
2025 elem = virtqueue_pop(q->tx_vq, sizeof(VirtQueueElement));
2026 if (!elem) {
2027 break;
2028 }
2029
2030 out_num = elem->out_num;
2031 out_sg = elem->out_sg;
2032 if (out_num < 1) {
2033 virtio_error(vdev, "virtio-net header not in first element");
2034 virtqueue_detach_element(q->tx_vq, elem, 0);
2035 g_free(elem);
2036 return -EINVAL;
2037 }
2038
2039 if (n->has_vnet_hdr) {
2040 if (iov_to_buf(out_sg, out_num, 0, &mhdr, n->guest_hdr_len) <
2041 n->guest_hdr_len) {
2042 virtio_error(vdev, "virtio-net header incorrect");
2043 virtqueue_detach_element(q->tx_vq, elem, 0);
2044 g_free(elem);
2045 return -EINVAL;
2046 }
2047 if (n->needs_vnet_hdr_swap) {
2048 virtio_net_hdr_swap(vdev, (void *) &mhdr);
2049 sg2[0].iov_base = &mhdr;
2050 sg2[0].iov_len = n->guest_hdr_len;
2051 out_num = iov_copy(&sg2[1], ARRAY_SIZE(sg2) - 1,
2052 out_sg, out_num,
2053 n->guest_hdr_len, -1);
2054 if (out_num == VIRTQUEUE_MAX_SIZE) {
2055 goto drop;
2056 }
2057 out_num += 1;
2058 out_sg = sg2;
2059 }
2060 }
2061 /*
2062 * If host wants to see the guest header as is, we can
2063 * pass it on unchanged. Otherwise, copy just the parts
2064 * that host is interested in.
2065 */
2066 assert(n->host_hdr_len <= n->guest_hdr_len);
2067 if (n->host_hdr_len != n->guest_hdr_len) {
2068 unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
2069 out_sg, out_num,
2070 0, n->host_hdr_len);
2071 sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
2072 out_sg, out_num,
2073 n->guest_hdr_len, -1);
2074 out_num = sg_num;
2075 out_sg = sg;
2076 }
2077
2078 ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
2079 out_sg, out_num, virtio_net_tx_complete);
2080 if (ret == 0) {
2081 virtio_queue_set_notification(q->tx_vq, 0);
2082 q->async_tx.elem = elem;
2083 return -EBUSY;
2084 }
2085
2086 drop:
2087 virtqueue_push(q->tx_vq, elem, 0);
2088 virtio_notify(vdev, q->tx_vq);
2089 g_free(elem);
2090
2091 if (++num_packets >= n->tx_burst) {
2092 break;
2093 }
2094 }
2095 return num_packets;
2096 }
2097
2098 static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
2099 {
2100 VirtIONet *n = VIRTIO_NET(vdev);
2101 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2102
2103 if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2104 virtio_net_drop_tx_queue_data(vdev, vq);
2105 return;
2106 }
2107
2108 /* This happens when device was stopped but VCPU wasn't. */
2109 if (!vdev->vm_running) {
2110 q->tx_waiting = 1;
2111 return;
2112 }
2113
2114 if (q->tx_waiting) {
2115 virtio_queue_set_notification(vq, 1);
2116 timer_del(q->tx_timer);
2117 q->tx_waiting = 0;
2118 if (virtio_net_flush_tx(q) == -EINVAL) {
2119 return;
2120 }
2121 } else {
2122 timer_mod(q->tx_timer,
2123 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2124 q->tx_waiting = 1;
2125 virtio_queue_set_notification(vq, 0);
2126 }
2127 }
2128
2129 static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
2130 {
2131 VirtIONet *n = VIRTIO_NET(vdev);
2132 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2133
2134 if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2135 virtio_net_drop_tx_queue_data(vdev, vq);
2136 return;
2137 }
2138
2139 if (unlikely(q->tx_waiting)) {
2140 return;
2141 }
2142 q->tx_waiting = 1;
2143 /* This happens when device was stopped but VCPU wasn't. */
2144 if (!vdev->vm_running) {
2145 return;
2146 }
2147 virtio_queue_set_notification(vq, 0);
2148 qemu_bh_schedule(q->tx_bh);
2149 }
2150
2151 static void virtio_net_tx_timer(void *opaque)
2152 {
2153 VirtIONetQueue *q = opaque;
2154 VirtIONet *n = q->n;
2155 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2156 /* This happens when device was stopped but BH wasn't. */
2157 if (!vdev->vm_running) {
2158 /* Make sure tx waiting is set, so we'll run when restarted. */
2159 assert(q->tx_waiting);
2160 return;
2161 }
2162
2163 q->tx_waiting = 0;
2164
2165 /* Just in case the driver is not ready on more */
2166 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2167 return;
2168 }
2169
2170 virtio_queue_set_notification(q->tx_vq, 1);
2171 virtio_net_flush_tx(q);
2172 }
2173
2174 static void virtio_net_tx_bh(void *opaque)
2175 {
2176 VirtIONetQueue *q = opaque;
2177 VirtIONet *n = q->n;
2178 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2179 int32_t ret;
2180
2181 /* This happens when device was stopped but BH wasn't. */
2182 if (!vdev->vm_running) {
2183 /* Make sure tx waiting is set, so we'll run when restarted. */
2184 assert(q->tx_waiting);
2185 return;
2186 }
2187
2188 q->tx_waiting = 0;
2189
2190 /* Just in case the driver is not ready on more */
2191 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
2192 return;
2193 }
2194
2195 ret = virtio_net_flush_tx(q);
2196 if (ret == -EBUSY || ret == -EINVAL) {
2197 return; /* Notification re-enable handled by tx_complete or device
2198 * broken */
2199 }
2200
2201 /* If we flush a full burst of packets, assume there are
2202 * more coming and immediately reschedule */
2203 if (ret >= n->tx_burst) {
2204 qemu_bh_schedule(q->tx_bh);
2205 q->tx_waiting = 1;
2206 return;
2207 }
2208
2209 /* If less than a full burst, re-enable notification and flush
2210 * anything that may have come in while we weren't looking. If
2211 * we find something, assume the guest is still active and reschedule */
2212 virtio_queue_set_notification(q->tx_vq, 1);
2213 ret = virtio_net_flush_tx(q);
2214 if (ret == -EINVAL) {
2215 return;
2216 } else if (ret > 0) {
2217 virtio_queue_set_notification(q->tx_vq, 0);
2218 qemu_bh_schedule(q->tx_bh);
2219 q->tx_waiting = 1;
2220 }
2221 }
2222
2223 static void virtio_net_add_queue(VirtIONet *n, int index)
2224 {
2225 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2226
2227 n->vqs[index].rx_vq = virtio_add_queue(vdev, n->net_conf.rx_queue_size,
2228 virtio_net_handle_rx);
2229
2230 if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
2231 n->vqs[index].tx_vq =
2232 virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2233 virtio_net_handle_tx_timer);
2234 n->vqs[index].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2235 virtio_net_tx_timer,
2236 &n->vqs[index]);
2237 } else {
2238 n->vqs[index].tx_vq =
2239 virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2240 virtio_net_handle_tx_bh);
2241 n->vqs[index].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[index]);
2242 }
2243
2244 n->vqs[index].tx_waiting = 0;
2245 n->vqs[index].n = n;
2246 }
2247
2248 static void virtio_net_del_queue(VirtIONet *n, int index)
2249 {
2250 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2251 VirtIONetQueue *q = &n->vqs[index];
2252 NetClientState *nc = qemu_get_subqueue(n->nic, index);
2253
2254 qemu_purge_queued_packets(nc);
2255
2256 virtio_del_queue(vdev, index * 2);
2257 if (q->tx_timer) {
2258 timer_del(q->tx_timer);
2259 timer_free(q->tx_timer);
2260 q->tx_timer = NULL;
2261 } else {
2262 qemu_bh_delete(q->tx_bh);
2263 q->tx_bh = NULL;
2264 }
2265 q->tx_waiting = 0;
2266 virtio_del_queue(vdev, index * 2 + 1);
2267 }
2268
2269 static void virtio_net_change_num_queues(VirtIONet *n, int new_max_queues)
2270 {
2271 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2272 int old_num_queues = virtio_get_num_queues(vdev);
2273 int new_num_queues = new_max_queues * 2 + 1;
2274 int i;
2275
2276 assert(old_num_queues >= 3);
2277 assert(old_num_queues % 2 == 1);
2278
2279 if (old_num_queues == new_num_queues) {
2280 return;
2281 }
2282
2283 /*
2284 * We always need to remove and add ctrl vq if
2285 * old_num_queues != new_num_queues. Remove ctrl_vq first,
2286 * and then we only enter one of the following two loops.
2287 */
2288 virtio_del_queue(vdev, old_num_queues - 1);
2289
2290 for (i = new_num_queues - 1; i < old_num_queues - 1; i += 2) {
2291 /* new_num_queues < old_num_queues */
2292 virtio_net_del_queue(n, i / 2);
2293 }
2294
2295 for (i = old_num_queues - 1; i < new_num_queues - 1; i += 2) {
2296 /* new_num_queues > old_num_queues */
2297 virtio_net_add_queue(n, i / 2);
2298 }
2299
2300 /* add ctrl_vq last */
2301 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
2302 }
2303
2304 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
2305 {
2306 int max = multiqueue ? n->max_queues : 1;
2307
2308 n->multiqueue = multiqueue;
2309 virtio_net_change_num_queues(n, max);
2310
2311 virtio_net_set_queues(n);
2312 }
2313
2314 static int virtio_net_post_load_device(void *opaque, int version_id)
2315 {
2316 VirtIONet *n = opaque;
2317 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2318 int i, link_down;
2319
2320 trace_virtio_net_post_load_device();
2321 virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
2322 virtio_vdev_has_feature(vdev,
2323 VIRTIO_F_VERSION_1));
2324
2325 /* MAC_TABLE_ENTRIES may be different from the saved image */
2326 if (n->mac_table.in_use > MAC_TABLE_ENTRIES) {
2327 n->mac_table.in_use = 0;
2328 }
2329
2330 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
2331 n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
2332 }
2333
2334 if (peer_has_vnet_hdr(n)) {
2335 virtio_net_apply_guest_offloads(n);
2336 }
2337
2338 virtio_net_set_queues(n);
2339
2340 /* Find the first multicast entry in the saved MAC filter */
2341 for (i = 0; i < n->mac_table.in_use; i++) {
2342 if (n->mac_table.macs[i * ETH_ALEN] & 1) {
2343 break;
2344 }
2345 }
2346 n->mac_table.first_multi = i;
2347
2348 /* nc.link_down can't be migrated, so infer link_down according
2349 * to link status bit in n->status */
2350 link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
2351 for (i = 0; i < n->max_queues; i++) {
2352 qemu_get_subqueue(n->nic, i)->link_down = link_down;
2353 }
2354
2355 if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
2356 virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
2357 qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
2358 QEMU_CLOCK_VIRTUAL,
2359 virtio_net_announce_timer, n);
2360 if (n->announce_timer.round) {
2361 timer_mod(n->announce_timer.tm,
2362 qemu_clock_get_ms(n->announce_timer.type));
2363 } else {
2364 qemu_announce_timer_del(&n->announce_timer, false);
2365 }
2366 }
2367
2368 return 0;
2369 }
2370
2371 /* tx_waiting field of a VirtIONetQueue */
2372 static const VMStateDescription vmstate_virtio_net_queue_tx_waiting = {
2373 .name = "virtio-net-queue-tx_waiting",
2374 .fields = (VMStateField[]) {
2375 VMSTATE_UINT32(tx_waiting, VirtIONetQueue),
2376 VMSTATE_END_OF_LIST()
2377 },
2378 };
2379
2380 static bool max_queues_gt_1(void *opaque, int version_id)
2381 {
2382 return VIRTIO_NET(opaque)->max_queues > 1;
2383 }
2384
2385 static bool has_ctrl_guest_offloads(void *opaque, int version_id)
2386 {
2387 return virtio_vdev_has_feature(VIRTIO_DEVICE(opaque),
2388 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS);
2389 }
2390
2391 static bool mac_table_fits(void *opaque, int version_id)
2392 {
2393 return VIRTIO_NET(opaque)->mac_table.in_use <= MAC_TABLE_ENTRIES;
2394 }
2395
2396 static bool mac_table_doesnt_fit(void *opaque, int version_id)
2397 {
2398 return !mac_table_fits(opaque, version_id);
2399 }
2400
2401 /* This temporary type is shared by all the WITH_TMP methods
2402 * although only some fields are used by each.
2403 */
2404 struct VirtIONetMigTmp {
2405 VirtIONet *parent;
2406 VirtIONetQueue *vqs_1;
2407 uint16_t curr_queues_1;
2408 uint8_t has_ufo;
2409 uint32_t has_vnet_hdr;
2410 };
2411
2412 /* The 2nd and subsequent tx_waiting flags are loaded later than
2413 * the 1st entry in the queues and only if there's more than one
2414 * entry. We use the tmp mechanism to calculate a temporary
2415 * pointer and count and also validate the count.
2416 */
2417
2418 static int virtio_net_tx_waiting_pre_save(void *opaque)
2419 {
2420 struct VirtIONetMigTmp *tmp = opaque;
2421
2422 tmp->vqs_1 = tmp->parent->vqs + 1;
2423 tmp->curr_queues_1 = tmp->parent->curr_queues - 1;
2424 if (tmp->parent->curr_queues == 0) {
2425 tmp->curr_queues_1 = 0;
2426 }
2427
2428 return 0;
2429 }
2430
2431 static int virtio_net_tx_waiting_pre_load(void *opaque)
2432 {
2433 struct VirtIONetMigTmp *tmp = opaque;
2434
2435 /* Reuse the pointer setup from save */
2436 virtio_net_tx_waiting_pre_save(opaque);
2437
2438 if (tmp->parent->curr_queues > tmp->parent->max_queues) {
2439 error_report("virtio-net: curr_queues %x > max_queues %x",
2440 tmp->parent->curr_queues, tmp->parent->max_queues);
2441
2442 return -EINVAL;
2443 }
2444
2445 return 0; /* all good */
2446 }
2447
2448 static const VMStateDescription vmstate_virtio_net_tx_waiting = {
2449 .name = "virtio-net-tx_waiting",
2450 .pre_load = virtio_net_tx_waiting_pre_load,
2451 .pre_save = virtio_net_tx_waiting_pre_save,
2452 .fields = (VMStateField[]) {
2453 VMSTATE_STRUCT_VARRAY_POINTER_UINT16(vqs_1, struct VirtIONetMigTmp,
2454 curr_queues_1,
2455 vmstate_virtio_net_queue_tx_waiting,
2456 struct VirtIONetQueue),
2457 VMSTATE_END_OF_LIST()
2458 },
2459 };
2460
2461 /* the 'has_ufo' flag is just tested; if the incoming stream has the
2462 * flag set we need to check that we have it
2463 */
2464 static int virtio_net_ufo_post_load(void *opaque, int version_id)
2465 {
2466 struct VirtIONetMigTmp *tmp = opaque;
2467
2468 if (tmp->has_ufo && !peer_has_ufo(tmp->parent)) {
2469 error_report("virtio-net: saved image requires TUN_F_UFO support");
2470 return -EINVAL;
2471 }
2472
2473 return 0;
2474 }
2475
2476 static int virtio_net_ufo_pre_save(void *opaque)
2477 {
2478 struct VirtIONetMigTmp *tmp = opaque;
2479
2480 tmp->has_ufo = tmp->parent->has_ufo;
2481
2482 return 0;
2483 }
2484
2485 static const VMStateDescription vmstate_virtio_net_has_ufo = {
2486 .name = "virtio-net-ufo",
2487 .post_load = virtio_net_ufo_post_load,
2488 .pre_save = virtio_net_ufo_pre_save,
2489 .fields = (VMStateField[]) {
2490 VMSTATE_UINT8(has_ufo, struct VirtIONetMigTmp),
2491 VMSTATE_END_OF_LIST()
2492 },
2493 };
2494
2495 /* the 'has_vnet_hdr' flag is just tested; if the incoming stream has the
2496 * flag set we need to check that we have it
2497 */
2498 static int virtio_net_vnet_post_load(void *opaque, int version_id)
2499 {
2500 struct VirtIONetMigTmp *tmp = opaque;
2501
2502 if (tmp->has_vnet_hdr && !peer_has_vnet_hdr(tmp->parent)) {
2503 error_report("virtio-net: saved image requires vnet_hdr=on");
2504 return -EINVAL;
2505 }
2506
2507 return 0;
2508 }
2509
2510 static int virtio_net_vnet_pre_save(void *opaque)
2511 {
2512 struct VirtIONetMigTmp *tmp = opaque;
2513
2514 tmp->has_vnet_hdr = tmp->parent->has_vnet_hdr;
2515
2516 return 0;
2517 }
2518
2519 static const VMStateDescription vmstate_virtio_net_has_vnet = {
2520 .name = "virtio-net-vnet",
2521 .post_load = virtio_net_vnet_post_load,
2522 .pre_save = virtio_net_vnet_pre_save,
2523 .fields = (VMStateField[]) {
2524 VMSTATE_UINT32(has_vnet_hdr, struct VirtIONetMigTmp),
2525 VMSTATE_END_OF_LIST()
2526 },
2527 };
2528
2529 static const VMStateDescription vmstate_virtio_net_device = {
2530 .name = "virtio-net-device",
2531 .version_id = VIRTIO_NET_VM_VERSION,
2532 .minimum_version_id = VIRTIO_NET_VM_VERSION,
2533 .post_load = virtio_net_post_load_device,
2534 .fields = (VMStateField[]) {
2535 VMSTATE_UINT8_ARRAY(mac, VirtIONet, ETH_ALEN),
2536 VMSTATE_STRUCT_POINTER(vqs, VirtIONet,
2537 vmstate_virtio_net_queue_tx_waiting,
2538 VirtIONetQueue),
2539 VMSTATE_UINT32(mergeable_rx_bufs, VirtIONet),
2540 VMSTATE_UINT16(status, VirtIONet),
2541 VMSTATE_UINT8(promisc, VirtIONet),
2542 VMSTATE_UINT8(allmulti, VirtIONet),
2543 VMSTATE_UINT32(mac_table.in_use, VirtIONet),
2544
2545 /* Guarded pair: If it fits we load it, else we throw it away
2546 * - can happen if source has a larger MAC table.; post-load
2547 * sets flags in this case.
2548 */
2549 VMSTATE_VBUFFER_MULTIPLY(mac_table.macs, VirtIONet,
2550 0, mac_table_fits, mac_table.in_use,
2551 ETH_ALEN),
2552 VMSTATE_UNUSED_VARRAY_UINT32(VirtIONet, mac_table_doesnt_fit, 0,
2553 mac_table.in_use, ETH_ALEN),
2554
2555 /* Note: This is an array of uint32's that's always been saved as a
2556 * buffer; hold onto your endiannesses; it's actually used as a bitmap
2557 * but based on the uint.
2558 */
2559 VMSTATE_BUFFER_POINTER_UNSAFE(vlans, VirtIONet, 0, MAX_VLAN >> 3),
2560 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2561 vmstate_virtio_net_has_vnet),
2562 VMSTATE_UINT8(mac_table.multi_overflow, VirtIONet),
2563 VMSTATE_UINT8(mac_table.uni_overflow, VirtIONet),
2564 VMSTATE_UINT8(alluni, VirtIONet),
2565 VMSTATE_UINT8(nomulti, VirtIONet),
2566 VMSTATE_UINT8(nouni, VirtIONet),
2567 VMSTATE_UINT8(nobcast, VirtIONet),
2568 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2569 vmstate_virtio_net_has_ufo),
2570 VMSTATE_SINGLE_TEST(max_queues, VirtIONet, max_queues_gt_1, 0,
2571 vmstate_info_uint16_equal, uint16_t),
2572 VMSTATE_UINT16_TEST(curr_queues, VirtIONet, max_queues_gt_1),
2573 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
2574 vmstate_virtio_net_tx_waiting),
2575 VMSTATE_UINT64_TEST(curr_guest_offloads, VirtIONet,
2576 has_ctrl_guest_offloads),
2577 VMSTATE_END_OF_LIST()
2578 },
2579 };
2580
2581 static NetClientInfo net_virtio_info = {
2582 .type = NET_CLIENT_DRIVER_NIC,
2583 .size = sizeof(NICState),
2584 .can_receive = virtio_net_can_receive,
2585 .receive = virtio_net_receive,
2586 .link_status_changed = virtio_net_set_link_status,
2587 .query_rx_filter = virtio_net_query_rxfilter,
2588 .announce = virtio_net_announce,
2589 };
2590
2591 static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
2592 {
2593 VirtIONet *n = VIRTIO_NET(vdev);
2594 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
2595 assert(n->vhost_started);
2596 return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
2597 }
2598
2599 static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
2600 bool mask)
2601 {
2602 VirtIONet *n = VIRTIO_NET(vdev);
2603 NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
2604 assert(n->vhost_started);
2605 vhost_net_virtqueue_mask(get_vhost_net(nc->peer),
2606 vdev, idx, mask);
2607 }
2608
2609 static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
2610 {
2611 virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
2612
2613 n->config_size = virtio_feature_get_config_size(feature_sizes,
2614 host_features);
2615 }
2616
2617 void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
2618 const char *type)
2619 {
2620 /*
2621 * The name can be NULL, the netclient name will be type.x.
2622 */
2623 assert(type != NULL);
2624
2625 g_free(n->netclient_name);
2626 g_free(n->netclient_type);
2627 n->netclient_name = g_strdup(name);
2628 n->netclient_type = g_strdup(type);
2629 }
2630
2631 static void virtio_net_device_realize(DeviceState *dev, Error **errp)
2632 {
2633 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
2634 VirtIONet *n = VIRTIO_NET(dev);
2635 NetClientState *nc;
2636 int i;
2637
2638 if (n->net_conf.mtu) {
2639 n->host_features |= (1ULL << VIRTIO_NET_F_MTU);
2640 }
2641
2642 if (n->net_conf.duplex_str) {
2643 if (strncmp(n->net_conf.duplex_str, "half", 5) == 0) {
2644 n->net_conf.duplex = DUPLEX_HALF;
2645 } else if (strncmp(n->net_conf.duplex_str, "full", 5) == 0) {
2646 n->net_conf.duplex = DUPLEX_FULL;
2647 } else {
2648 error_setg(errp, "'duplex' must be 'half' or 'full'");
2649 }
2650 n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
2651 } else {
2652 n->net_conf.duplex = DUPLEX_UNKNOWN;
2653 }
2654
2655 if (n->net_conf.speed < SPEED_UNKNOWN) {
2656 error_setg(errp, "'speed' must be between 0 and INT_MAX");
2657 } else if (n->net_conf.speed >= 0) {
2658 n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
2659 }
2660
2661 virtio_net_set_config_size(n, n->host_features);
2662 virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
2663
2664 /*
2665 * We set a lower limit on RX queue size to what it always was.
2666 * Guests that want a smaller ring can always resize it without
2667 * help from us (using virtio 1 and up).
2668 */
2669 if (n->net_conf.rx_queue_size < VIRTIO_NET_RX_QUEUE_MIN_SIZE ||
2670 n->net_conf.rx_queue_size > VIRTQUEUE_MAX_SIZE ||
2671 !is_power_of_2(n->net_conf.rx_queue_size)) {
2672 error_setg(errp, "Invalid rx_queue_size (= %" PRIu16 "), "
2673 "must be a power of 2 between %d and %d.",
2674 n->net_conf.rx_queue_size, VIRTIO_NET_RX_QUEUE_MIN_SIZE,
2675 VIRTQUEUE_MAX_SIZE);
2676 virtio_cleanup(vdev);
2677 return;
2678 }
2679
2680 if (n->net_conf.tx_queue_size < VIRTIO_NET_TX_QUEUE_MIN_SIZE ||
2681 n->net_conf.tx_queue_size > VIRTQUEUE_MAX_SIZE ||
2682 !is_power_of_2(n->net_conf.tx_queue_size)) {
2683 error_setg(errp, "Invalid tx_queue_size (= %" PRIu16 "), "
2684 "must be a power of 2 between %d and %d",
2685 n->net_conf.tx_queue_size, VIRTIO_NET_TX_QUEUE_MIN_SIZE,
2686 VIRTQUEUE_MAX_SIZE);
2687 virtio_cleanup(vdev);
2688 return;
2689 }
2690
2691 n->max_queues = MAX(n->nic_conf.peers.queues, 1);
2692 if (n->max_queues * 2 + 1 > VIRTIO_QUEUE_MAX) {
2693 error_setg(errp, "Invalid number of queues (= %" PRIu32 "), "
2694 "must be a positive integer less than %d.",
2695 n->max_queues, (VIRTIO_QUEUE_MAX - 1) / 2);
2696 virtio_cleanup(vdev);
2697 return;
2698 }
2699 n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
2700 n->curr_queues = 1;
2701 n->tx_timeout = n->net_conf.txtimer;
2702
2703 if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
2704 && strcmp(n->net_conf.tx, "bh")) {
2705 warn_report("virtio-net: "
2706 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
2707 n->net_conf.tx);
2708 error_printf("Defaulting to \"bh\"");
2709 }
2710
2711 n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n),
2712 n->net_conf.tx_queue_size);
2713
2714 for (i = 0; i < n->max_queues; i++) {
2715 virtio_net_add_queue(n, i);
2716 }
2717
2718 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
2719 qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
2720 memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
2721 n->status = VIRTIO_NET_S_LINK_UP;
2722 qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
2723 QEMU_CLOCK_VIRTUAL,
2724 virtio_net_announce_timer, n);
2725 n->announce_timer.round = 0;
2726
2727 if (n->netclient_type) {
2728 /*
2729 * Happen when virtio_net_set_netclient_name has been called.
2730 */
2731 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
2732 n->netclient_type, n->netclient_name, n);
2733 } else {
2734 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
2735 object_get_typename(OBJECT(dev)), dev->id, n);
2736 }
2737
2738 peer_test_vnet_hdr(n);
2739 if (peer_has_vnet_hdr(n)) {
2740 for (i = 0; i < n->max_queues; i++) {
2741 qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
2742 }
2743 n->host_hdr_len = sizeof(struct virtio_net_hdr);
2744 } else {
2745 n->host_hdr_len = 0;
2746 }
2747
2748 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
2749
2750 n->vqs[0].tx_waiting = 0;
2751 n->tx_burst = n->net_conf.txburst;
2752 virtio_net_set_mrg_rx_bufs(n, 0, 0);
2753 n->promisc = 1; /* for compatibility */
2754
2755 n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
2756
2757 n->vlans = g_malloc0(MAX_VLAN >> 3);
2758
2759 nc = qemu_get_queue(n->nic);
2760 nc->rxfilter_notify_enabled = 1;
2761
2762 QTAILQ_INIT(&n->rsc_chains);
2763 n->qdev = dev;
2764 }
2765
2766 static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
2767 {
2768 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
2769 VirtIONet *n = VIRTIO_NET(dev);
2770 int i, max_queues;
2771
2772 /* This will stop vhost backend if appropriate. */
2773 virtio_net_set_status(vdev, 0);
2774
2775 g_free(n->netclient_name);
2776 n->netclient_name = NULL;
2777 g_free(n->netclient_type);
2778 n->netclient_type = NULL;
2779
2780 g_free(n->mac_table.macs);
2781 g_free(n->vlans);
2782
2783 max_queues = n->multiqueue ? n->max_queues : 1;
2784 for (i = 0; i < max_queues; i++) {
2785 virtio_net_del_queue(n, i);
2786 }
2787
2788 qemu_announce_timer_del(&n->announce_timer, false);
2789 g_free(n->vqs);
2790 qemu_del_nic(n->nic);
2791 virtio_net_rsc_cleanup(n);
2792 virtio_cleanup(vdev);
2793 }
2794
2795 static void virtio_net_instance_init(Object *obj)
2796 {
2797 VirtIONet *n = VIRTIO_NET(obj);
2798
2799 /*
2800 * The default config_size is sizeof(struct virtio_net_config).
2801 * Can be overriden with virtio_net_set_config_size.
2802 */
2803 n->config_size = sizeof(struct virtio_net_config);
2804 device_add_bootindex_property(obj, &n->nic_conf.bootindex,
2805 "bootindex", "/ethernet-phy@0",
2806 DEVICE(n), NULL);
2807 }
2808
2809 static int virtio_net_pre_save(void *opaque)
2810 {
2811 VirtIONet *n = opaque;
2812
2813 /* At this point, backend must be stopped, otherwise
2814 * it might keep writing to memory. */
2815 assert(!n->vhost_started);
2816
2817 return 0;
2818 }
2819
2820 static const VMStateDescription vmstate_virtio_net = {
2821 .name = "virtio-net",
2822 .minimum_version_id = VIRTIO_NET_VM_VERSION,
2823 .version_id = VIRTIO_NET_VM_VERSION,
2824 .fields = (VMStateField[]) {
2825 VMSTATE_VIRTIO_DEVICE,
2826 VMSTATE_END_OF_LIST()
2827 },
2828 .pre_save = virtio_net_pre_save,
2829 };
2830
2831 static Property virtio_net_properties[] = {
2832 DEFINE_PROP_BIT64("csum", VirtIONet, host_features,
2833 VIRTIO_NET_F_CSUM, true),
2834 DEFINE_PROP_BIT64("guest_csum", VirtIONet, host_features,
2835 VIRTIO_NET_F_GUEST_CSUM, true),
2836 DEFINE_PROP_BIT64("gso", VirtIONet, host_features, VIRTIO_NET_F_GSO, true),
2837 DEFINE_PROP_BIT64("guest_tso4", VirtIONet, host_features,
2838 VIRTIO_NET_F_GUEST_TSO4, true),
2839 DEFINE_PROP_BIT64("guest_tso6", VirtIONet, host_features,
2840 VIRTIO_NET_F_GUEST_TSO6, true),
2841 DEFINE_PROP_BIT64("guest_ecn", VirtIONet, host_features,
2842 VIRTIO_NET_F_GUEST_ECN, true),
2843 DEFINE_PROP_BIT64("guest_ufo", VirtIONet, host_features,
2844 VIRTIO_NET_F_GUEST_UFO, true),
2845 DEFINE_PROP_BIT64("guest_announce", VirtIONet, host_features,
2846 VIRTIO_NET_F_GUEST_ANNOUNCE, true),
2847 DEFINE_PROP_BIT64("host_tso4", VirtIONet, host_features,
2848 VIRTIO_NET_F_HOST_TSO4, true),
2849 DEFINE_PROP_BIT64("host_tso6", VirtIONet, host_features,
2850 VIRTIO_NET_F_HOST_TSO6, true),
2851 DEFINE_PROP_BIT64("host_ecn", VirtIONet, host_features,
2852 VIRTIO_NET_F_HOST_ECN, true),
2853 DEFINE_PROP_BIT64("host_ufo", VirtIONet, host_features,
2854 VIRTIO_NET_F_HOST_UFO, true),
2855 DEFINE_PROP_BIT64("mrg_rxbuf", VirtIONet, host_features,
2856 VIRTIO_NET_F_MRG_RXBUF, true),
2857 DEFINE_PROP_BIT64("status", VirtIONet, host_features,
2858 VIRTIO_NET_F_STATUS, true),
2859 DEFINE_PROP_BIT64("ctrl_vq", VirtIONet, host_features,
2860 VIRTIO_NET_F_CTRL_VQ, true),
2861 DEFINE_PROP_BIT64("ctrl_rx", VirtIONet, host_features,
2862 VIRTIO_NET_F_CTRL_RX, true),
2863 DEFINE_PROP_BIT64("ctrl_vlan", VirtIONet, host_features,
2864 VIRTIO_NET_F_CTRL_VLAN, true),
2865 DEFINE_PROP_BIT64("ctrl_rx_extra", VirtIONet, host_features,
2866 VIRTIO_NET_F_CTRL_RX_EXTRA, true),
2867 DEFINE_PROP_BIT64("ctrl_mac_addr", VirtIONet, host_features,
2868 VIRTIO_NET_F_CTRL_MAC_ADDR, true),
2869 DEFINE_PROP_BIT64("ctrl_guest_offloads", VirtIONet, host_features,
2870 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, true),
2871 DEFINE_PROP_BIT64("mq", VirtIONet, host_features, VIRTIO_NET_F_MQ, false),
2872 DEFINE_PROP_BIT64("guest_rsc_ext", VirtIONet, host_features,
2873 VIRTIO_NET_F_RSC_EXT, false),
2874 DEFINE_PROP_UINT32("rsc_interval", VirtIONet, rsc_timeout,
2875 VIRTIO_NET_RSC_DEFAULT_INTERVAL),
2876 DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
2877 DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
2878 TX_TIMER_INTERVAL),
2879 DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
2880 DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
2881 DEFINE_PROP_UINT16("rx_queue_size", VirtIONet, net_conf.rx_queue_size,
2882 VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE),
2883 DEFINE_PROP_UINT16("tx_queue_size", VirtIONet, net_conf.tx_queue_size,
2884 VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE),
2885 DEFINE_PROP_UINT16("host_mtu", VirtIONet, net_conf.mtu, 0),
2886 DEFINE_PROP_BOOL("x-mtu-bypass-backend", VirtIONet, mtu_bypass_backend,
2887 true),
2888 DEFINE_PROP_INT32("speed", VirtIONet, net_conf.speed, SPEED_UNKNOWN),
2889 DEFINE_PROP_STRING("duplex", VirtIONet, net_conf.duplex_str),
2890 DEFINE_PROP_END_OF_LIST(),
2891 };
2892
2893 static void virtio_net_class_init(ObjectClass *klass, void *data)
2894 {
2895 DeviceClass *dc = DEVICE_CLASS(klass);
2896 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
2897
2898 dc->props = virtio_net_properties;
2899 dc->vmsd = &vmstate_virtio_net;
2900 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
2901 vdc->realize = virtio_net_device_realize;
2902 vdc->unrealize = virtio_net_device_unrealize;
2903 vdc->get_config = virtio_net_get_config;
2904 vdc->set_config = virtio_net_set_config;
2905 vdc->get_features = virtio_net_get_features;
2906 vdc->set_features = virtio_net_set_features;
2907 vdc->bad_features = virtio_net_bad_features;
2908 vdc->reset = virtio_net_reset;
2909 vdc->set_status = virtio_net_set_status;
2910 vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
2911 vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
2912 vdc->legacy_features |= (0x1 << VIRTIO_NET_F_GSO);
2913 vdc->vmsd = &vmstate_virtio_net_device;
2914 }
2915
2916 static const TypeInfo virtio_net_info = {
2917 .name = TYPE_VIRTIO_NET,
2918 .parent = TYPE_VIRTIO_DEVICE,
2919 .instance_size = sizeof(VirtIONet),
2920 .instance_init = virtio_net_instance_init,
2921 .class_init = virtio_net_class_init,
2922 };
2923
2924 static void virtio_register_types(void)
2925 {
2926 type_register_static(&virtio_net_info);
2927 }
2928
2929 type_init(virtio_register_types)
AR7 emulation for QEMU