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/atomic.h"
16 #include "qemu/iov.h"
17 #include "qemu/log.h"
18 #include "qemu/main-loop.h"
19 #include "qemu/module.h"
20 #include "hw/virtio/virtio.h"
21 #include "net/net.h"
22 #include "net/checksum.h"
23 #include "net/tap.h"
24 #include "qemu/error-report.h"
25 #include "qemu/timer.h"
26 #include "qemu/option.h"
27 #include "qemu/option_int.h"
28 #include "qemu/config-file.h"
29 #include "qobject/qdict.h"
30 #include "hw/virtio/virtio-net.h"
31 #include "net/vhost_net.h"
32 #include "net/announce.h"
33 #include "hw/virtio/virtio-bus.h"
34 #include "qapi/error.h"
35 #include "qapi/qapi-events-net.h"
36 #include "hw/qdev-properties.h"
37 #include "qapi/qapi-types-migration.h"
38 #include "qapi/qapi-events-migration.h"
39 #include "hw/virtio/virtio-access.h"
40 #include "migration/misc.h"
41 #include "standard-headers/linux/ethtool.h"
42 #include "system/system.h"
43 #include "system/replay.h"
44 #include "trace.h"
45 #include "monitor/qdev.h"
46 #include "monitor/monitor.h"
47 #include "hw/pci/pci_device.h"
48 #include "net_rx_pkt.h"
49 #include "hw/virtio/vhost.h"
50 #include "system/qtest.h"
51
52 #define VIRTIO_NET_VM_VERSION 11
53
54 /* previously fixed value */
55 #define VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE 256
56 #define VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE 256
57
58 /* for now, only allow larger queue_pairs; with virtio-1, guest can downsize */
59 #define VIRTIO_NET_RX_QUEUE_MIN_SIZE VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE
60 #define VIRTIO_NET_TX_QUEUE_MIN_SIZE VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE
61
62 #define VIRTIO_NET_IP4_ADDR_SIZE 8 /* ipv4 saddr + daddr */
63
64 #define VIRTIO_NET_TCP_FLAG 0x3F
65 #define VIRTIO_NET_TCP_HDR_LENGTH 0xF000
66
67 /* IPv4 max payload, 16 bits in the header */
68 #define VIRTIO_NET_MAX_IP4_PAYLOAD (65535 - sizeof(struct ip_header))
69 #define VIRTIO_NET_MAX_TCP_PAYLOAD 65535
70
71 /* header length value in ip header without option */
72 #define VIRTIO_NET_IP4_HEADER_LENGTH 5
73
74 #define VIRTIO_NET_IP6_ADDR_SIZE 32 /* ipv6 saddr + daddr */
75 #define VIRTIO_NET_MAX_IP6_PAYLOAD VIRTIO_NET_MAX_TCP_PAYLOAD
76
77 /* Purge coalesced packets timer interval, This value affects the performance
78 a lot, and should be tuned carefully, '300000'(300us) is the recommended
79 value to pass the WHQL test, '50000' can gain 2x netperf throughput with
80 tso/gso/gro 'off'. */
81 #define VIRTIO_NET_RSC_DEFAULT_INTERVAL 300000
82
83 #define VIRTIO_NET_RSS_SUPPORTED_HASHES (VIRTIO_NET_RSS_HASH_TYPE_IPv4 | \
84 VIRTIO_NET_RSS_HASH_TYPE_TCPv4 | \
85 VIRTIO_NET_RSS_HASH_TYPE_UDPv4 | \
86 VIRTIO_NET_RSS_HASH_TYPE_IPv6 | \
87 VIRTIO_NET_RSS_HASH_TYPE_TCPv6 | \
88 VIRTIO_NET_RSS_HASH_TYPE_UDPv6 | \
89 VIRTIO_NET_RSS_HASH_TYPE_IP_EX | \
90 VIRTIO_NET_RSS_HASH_TYPE_TCP_EX | \
91 VIRTIO_NET_RSS_HASH_TYPE_UDP_EX)
92
93 static const VirtIOFeature feature_sizes[] = {
94 {.flags = 1ULL << VIRTIO_NET_F_MAC,
95 .end = endof(struct virtio_net_config, mac)},
96 {.flags = 1ULL << VIRTIO_NET_F_STATUS,
97 .end = endof(struct virtio_net_config, status)},
98 {.flags = 1ULL << VIRTIO_NET_F_MQ,
99 .end = endof(struct virtio_net_config, max_virtqueue_pairs)},
100 {.flags = 1ULL << VIRTIO_NET_F_MTU,
101 .end = endof(struct virtio_net_config, mtu)},
102 {.flags = 1ULL << VIRTIO_NET_F_SPEED_DUPLEX,
103 .end = endof(struct virtio_net_config, duplex)},
104 {.flags = (1ULL << VIRTIO_NET_F_RSS) | (1ULL << VIRTIO_NET_F_HASH_REPORT),
105 .end = endof(struct virtio_net_config, supported_hash_types)},
106 {}
107 };
108
109 static const VirtIOConfigSizeParams cfg_size_params = {
110 .min_size = endof(struct virtio_net_config, mac),
111 .max_size = sizeof(struct virtio_net_config),
112 .feature_sizes = feature_sizes
113 };
114
virtio_net_get_subqueue(NetClientState * nc)115 static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
116 {
117 VirtIONet *n = qemu_get_nic_opaque(nc);
118
119 return &n->vqs[nc->queue_index];
120 }
121
vq2q(int queue_index)122 static int vq2q(int queue_index)
123 {
124 return queue_index / 2;
125 }
126
flush_or_purge_queued_packets(NetClientState * nc)127 static void flush_or_purge_queued_packets(NetClientState *nc)
128 {
129 if (!nc->peer) {
130 return;
131 }
132
133 qemu_flush_or_purge_queued_packets(nc->peer, true);
134 assert(!virtio_net_get_subqueue(nc)->async_tx.elem);
135 }
136
137 /* TODO
138 * - we could suppress RX interrupt if we were so inclined.
139 */
140
virtio_net_get_config(VirtIODevice * vdev,uint8_t * config)141 static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
142 {
143 VirtIONet *n = VIRTIO_NET(vdev);
144 struct virtio_net_config netcfg;
145 NetClientState *nc = qemu_get_queue(n->nic);
146 static const MACAddr zero = { .a = { 0, 0, 0, 0, 0, 0 } };
147
148 int ret = 0;
149 memset(&netcfg, 0 , sizeof(struct virtio_net_config));
150 virtio_stw_p(vdev, &netcfg.status, n->status);
151 virtio_stw_p(vdev, &netcfg.max_virtqueue_pairs, n->max_queue_pairs);
152 virtio_stw_p(vdev, &netcfg.mtu, n->net_conf.mtu);
153 memcpy(netcfg.mac, n->mac, ETH_ALEN);
154 virtio_stl_p(vdev, &netcfg.speed, n->net_conf.speed);
155 netcfg.duplex = n->net_conf.duplex;
156 netcfg.rss_max_key_size = VIRTIO_NET_RSS_MAX_KEY_SIZE;
157 virtio_stw_p(vdev, &netcfg.rss_max_indirection_table_length,
158 virtio_host_has_feature(vdev, VIRTIO_NET_F_RSS) ?
159 VIRTIO_NET_RSS_MAX_TABLE_LEN : 1);
160 virtio_stl_p(vdev, &netcfg.supported_hash_types,
161 VIRTIO_NET_RSS_SUPPORTED_HASHES);
162 memcpy(config, &netcfg, n->config_size);
163
164 /*
165 * Is this VDPA? No peer means not VDPA: there's no way to
166 * disconnect/reconnect a VDPA peer.
167 */
168 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_VDPA) {
169 ret = vhost_net_get_config(get_vhost_net(nc->peer), (uint8_t *)&netcfg,
170 n->config_size);
171 if (ret == -1) {
172 return;
173 }
174
175 /*
176 * Some NIC/kernel combinations present 0 as the mac address. As that
177 * is not a legal address, try to proceed with the address from the
178 * QEMU command line in the hope that the address has been configured
179 * correctly elsewhere - just not reported by the device.
180 */
181 if (memcmp(&netcfg.mac, &zero, sizeof(zero)) == 0) {
182 info_report("Zero hardware mac address detected. Ignoring.");
183 memcpy(netcfg.mac, n->mac, ETH_ALEN);
184 }
185
186 netcfg.status |= virtio_tswap16(vdev,
187 n->status & VIRTIO_NET_S_ANNOUNCE);
188 memcpy(config, &netcfg, n->config_size);
189 }
190 }
191
virtio_net_set_config(VirtIODevice * vdev,const uint8_t * config)192 static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
193 {
194 VirtIONet *n = VIRTIO_NET(vdev);
195 struct virtio_net_config netcfg = {};
196 NetClientState *nc = qemu_get_queue(n->nic);
197
198 memcpy(&netcfg, config, n->config_size);
199
200 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_MAC_ADDR) &&
201 !virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1) &&
202 memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
203 memcpy(n->mac, netcfg.mac, ETH_ALEN);
204 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
205 }
206
207 /*
208 * Is this VDPA? No peer means not VDPA: there's no way to
209 * disconnect/reconnect a VDPA peer.
210 */
211 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_VDPA) {
212 vhost_net_set_config(get_vhost_net(nc->peer),
213 (uint8_t *)&netcfg, 0, n->config_size,
214 VHOST_SET_CONFIG_TYPE_FRONTEND);
215 }
216 }
217
virtio_net_started(VirtIONet * n,uint8_t status)218 static bool virtio_net_started(VirtIONet *n, uint8_t status)
219 {
220 VirtIODevice *vdev = VIRTIO_DEVICE(n);
221 return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
222 (n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
223 }
224
virtio_net_announce_notify(VirtIONet * net)225 static void virtio_net_announce_notify(VirtIONet *net)
226 {
227 VirtIODevice *vdev = VIRTIO_DEVICE(net);
228 trace_virtio_net_announce_notify();
229
230 net->status |= VIRTIO_NET_S_ANNOUNCE;
231 virtio_notify_config(vdev);
232 }
233
virtio_net_announce_timer(void * opaque)234 static void virtio_net_announce_timer(void *opaque)
235 {
236 VirtIONet *n = opaque;
237 trace_virtio_net_announce_timer(n->announce_timer.round);
238
239 n->announce_timer.round--;
240 virtio_net_announce_notify(n);
241 }
242
virtio_net_announce(NetClientState * nc)243 static void virtio_net_announce(NetClientState *nc)
244 {
245 VirtIONet *n = qemu_get_nic_opaque(nc);
246 VirtIODevice *vdev = VIRTIO_DEVICE(n);
247
248 /*
249 * Make sure the virtio migration announcement timer isn't running
250 * If it is, let it trigger announcement so that we do not cause
251 * confusion.
252 */
253 if (n->announce_timer.round) {
254 return;
255 }
256
257 if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
258 virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
259 virtio_net_announce_notify(n);
260 }
261 }
262
virtio_net_vhost_status(VirtIONet * n,uint8_t status)263 static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
264 {
265 VirtIODevice *vdev = VIRTIO_DEVICE(n);
266 NetClientState *nc = qemu_get_queue(n->nic);
267 int queue_pairs = n->multiqueue ? n->max_queue_pairs : 1;
268 int cvq = virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ) ?
269 n->max_ncs - n->max_queue_pairs : 0;
270
271 if (!get_vhost_net(nc->peer)) {
272 return;
273 }
274
275 if ((virtio_net_started(n, status) && !nc->peer->link_down) ==
276 !!n->vhost_started) {
277 return;
278 }
279 if (!n->vhost_started) {
280 int r, i;
281
282 if (n->needs_vnet_hdr_swap) {
283 error_report("backend does not support %s vnet headers; "
284 "falling back on userspace virtio",
285 virtio_is_big_endian(vdev) ? "BE" : "LE");
286 return;
287 }
288
289 /* Any packets outstanding? Purge them to avoid touching rings
290 * when vhost is running.
291 */
292 for (i = 0; i < queue_pairs; i++) {
293 NetClientState *qnc = qemu_get_subqueue(n->nic, i);
294
295 /* Purge both directions: TX and RX. */
296 qemu_net_queue_purge(qnc->peer->incoming_queue, qnc);
297 qemu_net_queue_purge(qnc->incoming_queue, qnc->peer);
298 }
299
300 if (virtio_has_feature(vdev->guest_features, VIRTIO_NET_F_MTU)) {
301 r = vhost_net_set_mtu(get_vhost_net(nc->peer), n->net_conf.mtu);
302 if (r < 0) {
303 error_report("%uBytes MTU not supported by the backend",
304 n->net_conf.mtu);
305
306 return;
307 }
308 }
309
310 n->vhost_started = 1;
311 r = vhost_net_start(vdev, n->nic->ncs, queue_pairs, cvq);
312 if (r < 0) {
313 error_report("unable to start vhost net: %d: "
314 "falling back on userspace virtio", -r);
315 n->vhost_started = 0;
316 }
317 } else {
318 vhost_net_stop(vdev, n->nic->ncs, queue_pairs, cvq);
319 n->vhost_started = 0;
320 }
321 }
322
virtio_net_set_vnet_endian_one(VirtIODevice * vdev,NetClientState * peer,bool enable)323 static int virtio_net_set_vnet_endian_one(VirtIODevice *vdev,
324 NetClientState *peer,
325 bool enable)
326 {
327 if (virtio_is_big_endian(vdev)) {
328 return qemu_set_vnet_be(peer, enable);
329 } else {
330 return qemu_set_vnet_le(peer, enable);
331 }
332 }
333
virtio_net_set_vnet_endian(VirtIODevice * vdev,NetClientState * ncs,int queue_pairs,bool enable)334 static bool virtio_net_set_vnet_endian(VirtIODevice *vdev, NetClientState *ncs,
335 int queue_pairs, bool enable)
336 {
337 int i;
338
339 for (i = 0; i < queue_pairs; i++) {
340 if (virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, enable) < 0 &&
341 enable) {
342 while (--i >= 0) {
343 virtio_net_set_vnet_endian_one(vdev, ncs[i].peer, false);
344 }
345
346 return true;
347 }
348 }
349
350 return false;
351 }
352
virtio_net_vnet_endian_status(VirtIONet * n,uint8_t status)353 static void virtio_net_vnet_endian_status(VirtIONet *n, uint8_t status)
354 {
355 VirtIODevice *vdev = VIRTIO_DEVICE(n);
356 int queue_pairs = n->multiqueue ? n->max_queue_pairs : 1;
357
358 if (virtio_net_started(n, status)) {
359 /* Before using the device, we tell the network backend about the
360 * endianness to use when parsing vnet headers. If the backend
361 * can't do it, we fallback onto fixing the headers in the core
362 * virtio-net code.
363 */
364 n->needs_vnet_hdr_swap = n->has_vnet_hdr &&
365 virtio_net_set_vnet_endian(vdev, n->nic->ncs,
366 queue_pairs, true);
367 } else if (virtio_net_started(n, vdev->status)) {
368 /* After using the device, we need to reset the network backend to
369 * the default (guest native endianness), otherwise the guest may
370 * lose network connectivity if it is rebooted into a different
371 * endianness.
372 */
373 virtio_net_set_vnet_endian(vdev, n->nic->ncs, queue_pairs, false);
374 }
375 }
376
virtio_net_drop_tx_queue_data(VirtIODevice * vdev,VirtQueue * vq)377 static void virtio_net_drop_tx_queue_data(VirtIODevice *vdev, VirtQueue *vq)
378 {
379 unsigned int dropped = virtqueue_drop_all(vq);
380 if (dropped) {
381 virtio_notify(vdev, vq);
382 }
383 }
384
virtio_net_set_status(struct VirtIODevice * vdev,uint8_t status)385 static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
386 {
387 VirtIONet *n = VIRTIO_NET(vdev);
388 VirtIONetQueue *q;
389 int i;
390 uint8_t queue_status;
391
392 virtio_net_vnet_endian_status(n, status);
393 virtio_net_vhost_status(n, status);
394
395 for (i = 0; i < n->max_queue_pairs; i++) {
396 NetClientState *ncs = qemu_get_subqueue(n->nic, i);
397 bool queue_started;
398 q = &n->vqs[i];
399
400 if ((!n->multiqueue && i != 0) || i >= n->curr_queue_pairs) {
401 queue_status = 0;
402 } else {
403 queue_status = status;
404 }
405 queue_started =
406 virtio_net_started(n, queue_status) && !n->vhost_started;
407
408 if (queue_started) {
409 qemu_flush_queued_packets(ncs);
410 }
411
412 if (!q->tx_waiting) {
413 continue;
414 }
415
416 if (queue_started) {
417 if (q->tx_timer) {
418 timer_mod(q->tx_timer,
419 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
420 } else {
421 replay_bh_schedule_event(q->tx_bh);
422 }
423 } else {
424 if (q->tx_timer) {
425 timer_del(q->tx_timer);
426 } else {
427 qemu_bh_cancel(q->tx_bh);
428 }
429 if ((n->status & VIRTIO_NET_S_LINK_UP) == 0 &&
430 (queue_status & VIRTIO_CONFIG_S_DRIVER_OK) &&
431 vdev->vm_running) {
432 /* if tx is waiting we are likely have some packets in tx queue
433 * and disabled notification */
434 q->tx_waiting = 0;
435 virtio_queue_set_notification(q->tx_vq, 1);
436 virtio_net_drop_tx_queue_data(vdev, q->tx_vq);
437 }
438 }
439 }
440 }
441
virtio_net_set_link_status(NetClientState * nc)442 static void virtio_net_set_link_status(NetClientState *nc)
443 {
444 VirtIONet *n = qemu_get_nic_opaque(nc);
445 VirtIODevice *vdev = VIRTIO_DEVICE(n);
446 uint16_t old_status = n->status;
447
448 if (nc->link_down)
449 n->status &= ~VIRTIO_NET_S_LINK_UP;
450 else
451 n->status |= VIRTIO_NET_S_LINK_UP;
452
453 if (n->status != old_status)
454 virtio_notify_config(vdev);
455
456 virtio_net_set_status(vdev, vdev->status);
457 }
458
rxfilter_notify(NetClientState * nc)459 static void rxfilter_notify(NetClientState *nc)
460 {
461 VirtIONet *n = qemu_get_nic_opaque(nc);
462
463 if (nc->rxfilter_notify_enabled) {
464 char *path = object_get_canonical_path(OBJECT(n->qdev));
465 qapi_event_send_nic_rx_filter_changed(n->netclient_name, path);
466 g_free(path);
467
468 /* disable event notification to avoid events flooding */
469 nc->rxfilter_notify_enabled = 0;
470 }
471 }
472
get_vlan_table(VirtIONet * n)473 static intList *get_vlan_table(VirtIONet *n)
474 {
475 intList *list;
476 int i, j;
477
478 list = NULL;
479 for (i = 0; i < MAX_VLAN >> 5; i++) {
480 for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
481 if (n->vlans[i] & (1U << j)) {
482 QAPI_LIST_PREPEND(list, (i << 5) + j);
483 }
484 }
485 }
486
487 return list;
488 }
489
virtio_net_query_rxfilter(NetClientState * nc)490 static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
491 {
492 VirtIONet *n = qemu_get_nic_opaque(nc);
493 VirtIODevice *vdev = VIRTIO_DEVICE(n);
494 RxFilterInfo *info;
495 strList *str_list;
496 int i;
497
498 info = g_malloc0(sizeof(*info));
499 info->name = g_strdup(nc->name);
500 info->promiscuous = n->promisc;
501
502 if (n->nouni) {
503 info->unicast = RX_STATE_NONE;
504 } else if (n->alluni) {
505 info->unicast = RX_STATE_ALL;
506 } else {
507 info->unicast = RX_STATE_NORMAL;
508 }
509
510 if (n->nomulti) {
511 info->multicast = RX_STATE_NONE;
512 } else if (n->allmulti) {
513 info->multicast = RX_STATE_ALL;
514 } else {
515 info->multicast = RX_STATE_NORMAL;
516 }
517
518 info->broadcast_allowed = n->nobcast;
519 info->multicast_overflow = n->mac_table.multi_overflow;
520 info->unicast_overflow = n->mac_table.uni_overflow;
521
522 info->main_mac = qemu_mac_strdup_printf(n->mac);
523
524 str_list = NULL;
525 for (i = 0; i < n->mac_table.first_multi; i++) {
526 QAPI_LIST_PREPEND(str_list,
527 qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN));
528 }
529 info->unicast_table = str_list;
530
531 str_list = NULL;
532 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
533 QAPI_LIST_PREPEND(str_list,
534 qemu_mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN));
535 }
536 info->multicast_table = str_list;
537 info->vlan_table = get_vlan_table(n);
538
539 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VLAN)) {
540 info->vlan = RX_STATE_ALL;
541 } else if (!info->vlan_table) {
542 info->vlan = RX_STATE_NONE;
543 } else {
544 info->vlan = RX_STATE_NORMAL;
545 }
546
547 /* enable event notification after query */
548 nc->rxfilter_notify_enabled = 1;
549
550 return info;
551 }
552
virtio_net_queue_reset(VirtIODevice * vdev,uint32_t queue_index)553 static void virtio_net_queue_reset(VirtIODevice *vdev, uint32_t queue_index)
554 {
555 VirtIONet *n = VIRTIO_NET(vdev);
556 NetClientState *nc;
557
558 /* validate queue_index and skip for cvq */
559 if (queue_index >= n->max_queue_pairs * 2) {
560 return;
561 }
562
563 nc = qemu_get_subqueue(n->nic, vq2q(queue_index));
564
565 if (!nc->peer) {
566 return;
567 }
568
569 if (get_vhost_net(nc->peer) &&
570 nc->peer->info->type == NET_CLIENT_DRIVER_TAP) {
571 vhost_net_virtqueue_reset(vdev, nc, queue_index);
572 }
573
574 flush_or_purge_queued_packets(nc);
575 }
576
virtio_net_queue_enable(VirtIODevice * vdev,uint32_t queue_index)577 static void virtio_net_queue_enable(VirtIODevice *vdev, uint32_t queue_index)
578 {
579 VirtIONet *n = VIRTIO_NET(vdev);
580 NetClientState *nc;
581 int r;
582
583 /* validate queue_index and skip for cvq */
584 if (queue_index >= n->max_queue_pairs * 2) {
585 return;
586 }
587
588 nc = qemu_get_subqueue(n->nic, vq2q(queue_index));
589
590 if (!nc->peer || !vdev->vhost_started) {
591 return;
592 }
593
594 if (get_vhost_net(nc->peer) &&
595 nc->peer->info->type == NET_CLIENT_DRIVER_TAP) {
596 r = vhost_net_virtqueue_restart(vdev, nc, queue_index);
597 if (r < 0) {
598 error_report("unable to restart vhost net virtqueue: %d, "
599 "when resetting the queue", queue_index);
600 }
601 }
602 }
603
peer_test_vnet_hdr(VirtIONet * n)604 static void peer_test_vnet_hdr(VirtIONet *n)
605 {
606 NetClientState *nc = qemu_get_queue(n->nic);
607 if (!nc->peer) {
608 return;
609 }
610
611 n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
612 }
613
peer_has_vnet_hdr(VirtIONet * n)614 static int peer_has_vnet_hdr(VirtIONet *n)
615 {
616 return n->has_vnet_hdr;
617 }
618
peer_has_ufo(VirtIONet * n)619 static int peer_has_ufo(VirtIONet *n)
620 {
621 if (!peer_has_vnet_hdr(n))
622 return 0;
623
624 n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
625
626 return n->has_ufo;
627 }
628
peer_has_uso(VirtIONet * n)629 static int peer_has_uso(VirtIONet *n)
630 {
631 if (!peer_has_vnet_hdr(n)) {
632 return 0;
633 }
634
635 return qemu_has_uso(qemu_get_queue(n->nic)->peer);
636 }
637
virtio_net_set_mrg_rx_bufs(VirtIONet * n,int mergeable_rx_bufs,int version_1,int hash_report)638 static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs,
639 int version_1, int hash_report)
640 {
641 int i;
642 NetClientState *nc;
643
644 n->mergeable_rx_bufs = mergeable_rx_bufs;
645
646 if (version_1) {
647 n->guest_hdr_len = hash_report ?
648 sizeof(struct virtio_net_hdr_v1_hash) :
649 sizeof(struct virtio_net_hdr_mrg_rxbuf);
650 n->rss_data.populate_hash = !!hash_report;
651 } else {
652 n->guest_hdr_len = n->mergeable_rx_bufs ?
653 sizeof(struct virtio_net_hdr_mrg_rxbuf) :
654 sizeof(struct virtio_net_hdr);
655 n->rss_data.populate_hash = false;
656 }
657
658 for (i = 0; i < n->max_queue_pairs; i++) {
659 nc = qemu_get_subqueue(n->nic, i);
660
661 if (peer_has_vnet_hdr(n) &&
662 qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
663 qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
664 n->host_hdr_len = n->guest_hdr_len;
665 }
666 }
667 }
668
virtio_net_max_tx_queue_size(VirtIONet * n)669 static int virtio_net_max_tx_queue_size(VirtIONet *n)
670 {
671 NetClientState *peer = n->nic_conf.peers.ncs[0];
672
673 /*
674 * Backends other than vhost-user or vhost-vdpa don't support max queue
675 * size.
676 */
677 if (!peer) {
678 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
679 }
680
681 switch(peer->info->type) {
682 case NET_CLIENT_DRIVER_VHOST_USER:
683 case NET_CLIENT_DRIVER_VHOST_VDPA:
684 return VIRTQUEUE_MAX_SIZE;
685 default:
686 return VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE;
687 };
688 }
689
peer_attach(VirtIONet * n,int index)690 static int peer_attach(VirtIONet *n, int index)
691 {
692 NetClientState *nc = qemu_get_subqueue(n->nic, index);
693
694 if (!nc->peer) {
695 return 0;
696 }
697
698 if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
699 vhost_set_vring_enable(nc->peer, 1);
700 }
701
702 if (nc->peer->info->type != NET_CLIENT_DRIVER_TAP) {
703 return 0;
704 }
705
706 if (n->max_queue_pairs == 1) {
707 return 0;
708 }
709
710 return tap_enable(nc->peer);
711 }
712
peer_detach(VirtIONet * n,int index)713 static int peer_detach(VirtIONet *n, int index)
714 {
715 NetClientState *nc = qemu_get_subqueue(n->nic, index);
716
717 if (!nc->peer) {
718 return 0;
719 }
720
721 if (nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_USER) {
722 vhost_set_vring_enable(nc->peer, 0);
723 }
724
725 if (nc->peer->info->type != NET_CLIENT_DRIVER_TAP) {
726 return 0;
727 }
728
729 return tap_disable(nc->peer);
730 }
731
virtio_net_set_queue_pairs(VirtIONet * n)732 static void virtio_net_set_queue_pairs(VirtIONet *n)
733 {
734 int i;
735 int r;
736
737 if (n->nic->peer_deleted) {
738 return;
739 }
740
741 for (i = 0; i < n->max_queue_pairs; i++) {
742 if (i < n->curr_queue_pairs) {
743 r = peer_attach(n, i);
744 assert(!r);
745 } else {
746 r = peer_detach(n, i);
747 assert(!r);
748 }
749 }
750 }
751
752 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
753
virtio_net_get_features(VirtIODevice * vdev,uint64_t features,Error ** errp)754 static uint64_t virtio_net_get_features(VirtIODevice *vdev, uint64_t features,
755 Error **errp)
756 {
757 VirtIONet *n = VIRTIO_NET(vdev);
758 NetClientState *nc = qemu_get_queue(n->nic);
759
760 /* Firstly sync all virtio-net possible supported features */
761 features |= n->host_features;
762
763 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
764
765 if (!peer_has_vnet_hdr(n)) {
766 virtio_clear_feature(&features, VIRTIO_NET_F_CSUM);
767 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO4);
768 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_TSO6);
769 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_ECN);
770
771 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_CSUM);
772 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO4);
773 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_TSO6);
774 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ECN);
775
776 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_USO);
777 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_USO4);
778 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_USO6);
779
780 virtio_clear_feature(&features, VIRTIO_NET_F_HASH_REPORT);
781 }
782
783 if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
784 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_UFO);
785 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_UFO);
786 }
787
788 if (!peer_has_uso(n)) {
789 virtio_clear_feature(&features, VIRTIO_NET_F_HOST_USO);
790 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_USO4);
791 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_USO6);
792 }
793
794 if (!get_vhost_net(nc->peer)) {
795 return features;
796 }
797
798 if (!ebpf_rss_is_loaded(&n->ebpf_rss)) {
799 virtio_clear_feature(&features, VIRTIO_NET_F_RSS);
800 }
801 features = vhost_net_get_features(get_vhost_net(nc->peer), features);
802 vdev->backend_features = features;
803
804 if (n->mtu_bypass_backend &&
805 (n->host_features & 1ULL << VIRTIO_NET_F_MTU)) {
806 features |= (1ULL << VIRTIO_NET_F_MTU);
807 }
808
809 /*
810 * Since GUEST_ANNOUNCE is emulated the feature bit could be set without
811 * enabled. This happens in the vDPA case.
812 *
813 * Make sure the feature set is not incoherent, as the driver could refuse
814 * to start.
815 *
816 * TODO: QEMU is able to emulate a CVQ just for guest_announce purposes,
817 * helping guest to notify the new location with vDPA devices that does not
818 * support it.
819 */
820 if (!virtio_has_feature(vdev->backend_features, VIRTIO_NET_F_CTRL_VQ)) {
821 virtio_clear_feature(&features, VIRTIO_NET_F_GUEST_ANNOUNCE);
822 }
823
824 return features;
825 }
826
virtio_net_bad_features(VirtIODevice * vdev)827 static uint64_t virtio_net_bad_features(VirtIODevice *vdev)
828 {
829 uint64_t features = 0;
830
831 /* Linux kernel 2.6.25. It understood MAC (as everyone must),
832 * but also these: */
833 virtio_add_feature(&features, VIRTIO_NET_F_MAC);
834 virtio_add_feature(&features, VIRTIO_NET_F_CSUM);
835 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO4);
836 virtio_add_feature(&features, VIRTIO_NET_F_HOST_TSO6);
837 virtio_add_feature(&features, VIRTIO_NET_F_HOST_ECN);
838
839 return features;
840 }
841
virtio_net_apply_guest_offloads(VirtIONet * n)842 static void virtio_net_apply_guest_offloads(VirtIONet *n)
843 {
844 qemu_set_offload(qemu_get_queue(n->nic)->peer,
845 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
846 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
847 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
848 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
849 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)),
850 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_USO4)),
851 !!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_USO6)));
852 }
853
virtio_net_guest_offloads_by_features(uint64_t features)854 static uint64_t virtio_net_guest_offloads_by_features(uint64_t features)
855 {
856 static const uint64_t guest_offloads_mask =
857 (1ULL << VIRTIO_NET_F_GUEST_CSUM) |
858 (1ULL << VIRTIO_NET_F_GUEST_TSO4) |
859 (1ULL << VIRTIO_NET_F_GUEST_TSO6) |
860 (1ULL << VIRTIO_NET_F_GUEST_ECN) |
861 (1ULL << VIRTIO_NET_F_GUEST_UFO) |
862 (1ULL << VIRTIO_NET_F_GUEST_USO4) |
863 (1ULL << VIRTIO_NET_F_GUEST_USO6);
864
865 return guest_offloads_mask & features;
866 }
867
virtio_net_supported_guest_offloads(const VirtIONet * n)868 uint64_t virtio_net_supported_guest_offloads(const VirtIONet *n)
869 {
870 VirtIODevice *vdev = VIRTIO_DEVICE(n);
871 return virtio_net_guest_offloads_by_features(vdev->guest_features);
872 }
873
874 typedef struct {
875 VirtIONet *n;
876 DeviceState *dev;
877 } FailoverDevice;
878
879 /**
880 * Set the failover primary device
881 *
882 * @opaque: FailoverId to setup
883 * @opts: opts for device we are handling
884 * @errp: returns an error if this function fails
885 */
failover_set_primary(DeviceState * dev,void * opaque)886 static int failover_set_primary(DeviceState *dev, void *opaque)
887 {
888 FailoverDevice *fdev = opaque;
889 PCIDevice *pci_dev = (PCIDevice *)
890 object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE);
891
892 if (!pci_dev) {
893 return 0;
894 }
895
896 if (!g_strcmp0(pci_dev->failover_pair_id, fdev->n->netclient_name)) {
897 fdev->dev = dev;
898 return 1;
899 }
900
901 return 0;
902 }
903
904 /**
905 * Find the primary device for this failover virtio-net
906 *
907 * @n: VirtIONet device
908 * @errp: returns an error if this function fails
909 */
failover_find_primary_device(VirtIONet * n)910 static DeviceState *failover_find_primary_device(VirtIONet *n)
911 {
912 FailoverDevice fdev = {
913 .n = n,
914 };
915
916 qbus_walk_children(sysbus_get_default(), failover_set_primary, NULL,
917 NULL, NULL, &fdev);
918 return fdev.dev;
919 }
920
failover_add_primary(VirtIONet * n,Error ** errp)921 static void failover_add_primary(VirtIONet *n, Error **errp)
922 {
923 Error *err = NULL;
924 DeviceState *dev = failover_find_primary_device(n);
925
926 if (dev) {
927 return;
928 }
929
930 if (!n->primary_opts) {
931 error_setg(errp, "Primary device not found");
932 error_append_hint(errp, "Virtio-net failover will not work. Make "
933 "sure primary device has parameter"
934 " failover_pair_id=%s\n", n->netclient_name);
935 return;
936 }
937
938 dev = qdev_device_add_from_qdict(n->primary_opts,
939 n->primary_opts_from_json,
940 &err);
941 if (err) {
942 qobject_unref(n->primary_opts);
943 n->primary_opts = NULL;
944 } else {
945 object_unref(OBJECT(dev));
946 }
947 error_propagate(errp, err);
948 }
949
virtio_net_set_features(VirtIODevice * vdev,uint64_t features)950 static void virtio_net_set_features(VirtIODevice *vdev, uint64_t features)
951 {
952 VirtIONet *n = VIRTIO_NET(vdev);
953 Error *err = NULL;
954 int i;
955
956 if (n->mtu_bypass_backend &&
957 !virtio_has_feature(vdev->backend_features, VIRTIO_NET_F_MTU)) {
958 features &= ~(1ULL << VIRTIO_NET_F_MTU);
959 }
960
961 virtio_net_set_multiqueue(n,
962 virtio_has_feature(features, VIRTIO_NET_F_RSS) ||
963 virtio_has_feature(features, VIRTIO_NET_F_MQ));
964
965 virtio_net_set_mrg_rx_bufs(n,
966 virtio_has_feature(features,
967 VIRTIO_NET_F_MRG_RXBUF),
968 virtio_has_feature(features,
969 VIRTIO_F_VERSION_1),
970 virtio_has_feature(features,
971 VIRTIO_NET_F_HASH_REPORT));
972
973 n->rsc4_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
974 virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO4);
975 n->rsc6_enabled = virtio_has_feature(features, VIRTIO_NET_F_RSC_EXT) &&
976 virtio_has_feature(features, VIRTIO_NET_F_GUEST_TSO6);
977 n->rss_data.redirect = virtio_has_feature(features, VIRTIO_NET_F_RSS);
978
979 if (n->has_vnet_hdr) {
980 n->curr_guest_offloads =
981 virtio_net_guest_offloads_by_features(features);
982 virtio_net_apply_guest_offloads(n);
983 }
984
985 for (i = 0; i < n->max_queue_pairs; i++) {
986 NetClientState *nc = qemu_get_subqueue(n->nic, i);
987
988 if (!get_vhost_net(nc->peer)) {
989 continue;
990 }
991 vhost_net_ack_features(get_vhost_net(nc->peer), features);
992
993 /*
994 * keep acked_features in NetVhostUserState up-to-date so it
995 * can't miss any features configured by guest virtio driver.
996 */
997 vhost_net_save_acked_features(nc->peer);
998 }
999
1000 if (!virtio_has_feature(features, VIRTIO_NET_F_CTRL_VLAN)) {
1001 memset(n->vlans, 0xff, MAX_VLAN >> 3);
1002 }
1003
1004 if (virtio_has_feature(features, VIRTIO_NET_F_STANDBY)) {
1005 qapi_event_send_failover_negotiated(n->netclient_name);
1006 qatomic_set(&n->failover_primary_hidden, false);
1007 failover_add_primary(n, &err);
1008 if (err) {
1009 if (!qtest_enabled()) {
1010 warn_report_err(err);
1011 } else {
1012 error_free(err);
1013 }
1014 }
1015 }
1016 }
1017
virtio_net_handle_rx_mode(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1018 static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
1019 struct iovec *iov, unsigned int iov_cnt)
1020 {
1021 uint8_t on;
1022 size_t s;
1023 NetClientState *nc = qemu_get_queue(n->nic);
1024
1025 s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
1026 if (s != sizeof(on)) {
1027 return VIRTIO_NET_ERR;
1028 }
1029
1030 if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
1031 n->promisc = on;
1032 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
1033 n->allmulti = on;
1034 } else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
1035 n->alluni = on;
1036 } else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
1037 n->nomulti = on;
1038 } else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
1039 n->nouni = on;
1040 } else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
1041 n->nobcast = on;
1042 } else {
1043 return VIRTIO_NET_ERR;
1044 }
1045
1046 rxfilter_notify(nc);
1047
1048 return VIRTIO_NET_OK;
1049 }
1050
virtio_net_handle_offloads(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1051 static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
1052 struct iovec *iov, unsigned int iov_cnt)
1053 {
1054 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1055 uint64_t offloads;
1056 size_t s;
1057
1058 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
1059 return VIRTIO_NET_ERR;
1060 }
1061
1062 s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
1063 if (s != sizeof(offloads)) {
1064 return VIRTIO_NET_ERR;
1065 }
1066
1067 if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
1068 uint64_t supported_offloads;
1069
1070 offloads = virtio_ldq_p(vdev, &offloads);
1071
1072 if (!n->has_vnet_hdr) {
1073 return VIRTIO_NET_ERR;
1074 }
1075
1076 n->rsc4_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
1077 virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO4);
1078 n->rsc6_enabled = virtio_has_feature(offloads, VIRTIO_NET_F_RSC_EXT) &&
1079 virtio_has_feature(offloads, VIRTIO_NET_F_GUEST_TSO6);
1080 virtio_clear_feature(&offloads, VIRTIO_NET_F_RSC_EXT);
1081
1082 supported_offloads = virtio_net_supported_guest_offloads(n);
1083 if (offloads & ~supported_offloads) {
1084 return VIRTIO_NET_ERR;
1085 }
1086
1087 n->curr_guest_offloads = offloads;
1088 virtio_net_apply_guest_offloads(n);
1089
1090 return VIRTIO_NET_OK;
1091 } else {
1092 return VIRTIO_NET_ERR;
1093 }
1094 }
1095
virtio_net_handle_mac(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1096 static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
1097 struct iovec *iov, unsigned int iov_cnt)
1098 {
1099 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1100 struct virtio_net_ctrl_mac mac_data;
1101 size_t s;
1102 NetClientState *nc = qemu_get_queue(n->nic);
1103
1104 if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
1105 if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
1106 return VIRTIO_NET_ERR;
1107 }
1108 s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
1109 assert(s == sizeof(n->mac));
1110 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
1111 rxfilter_notify(nc);
1112
1113 return VIRTIO_NET_OK;
1114 }
1115
1116 if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
1117 return VIRTIO_NET_ERR;
1118 }
1119
1120 int in_use = 0;
1121 int first_multi = 0;
1122 uint8_t uni_overflow = 0;
1123 uint8_t multi_overflow = 0;
1124 uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
1125
1126 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
1127 sizeof(mac_data.entries));
1128 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
1129 if (s != sizeof(mac_data.entries)) {
1130 goto error;
1131 }
1132 iov_discard_front(&iov, &iov_cnt, s);
1133
1134 if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
1135 goto error;
1136 }
1137
1138 if (mac_data.entries <= MAC_TABLE_ENTRIES) {
1139 s = iov_to_buf(iov, iov_cnt, 0, macs,
1140 mac_data.entries * ETH_ALEN);
1141 if (s != mac_data.entries * ETH_ALEN) {
1142 goto error;
1143 }
1144 in_use += mac_data.entries;
1145 } else {
1146 uni_overflow = 1;
1147 }
1148
1149 iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
1150
1151 first_multi = in_use;
1152
1153 s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
1154 sizeof(mac_data.entries));
1155 mac_data.entries = virtio_ldl_p(vdev, &mac_data.entries);
1156 if (s != sizeof(mac_data.entries)) {
1157 goto error;
1158 }
1159
1160 iov_discard_front(&iov, &iov_cnt, s);
1161
1162 if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
1163 goto error;
1164 }
1165
1166 if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
1167 s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
1168 mac_data.entries * ETH_ALEN);
1169 if (s != mac_data.entries * ETH_ALEN) {
1170 goto error;
1171 }
1172 in_use += mac_data.entries;
1173 } else {
1174 multi_overflow = 1;
1175 }
1176
1177 n->mac_table.in_use = in_use;
1178 n->mac_table.first_multi = first_multi;
1179 n->mac_table.uni_overflow = uni_overflow;
1180 n->mac_table.multi_overflow = multi_overflow;
1181 memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
1182 g_free(macs);
1183 rxfilter_notify(nc);
1184
1185 return VIRTIO_NET_OK;
1186
1187 error:
1188 g_free(macs);
1189 return VIRTIO_NET_ERR;
1190 }
1191
virtio_net_handle_vlan_table(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1192 static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
1193 struct iovec *iov, unsigned int iov_cnt)
1194 {
1195 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1196 uint16_t vid;
1197 size_t s;
1198 NetClientState *nc = qemu_get_queue(n->nic);
1199
1200 s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
1201 vid = virtio_lduw_p(vdev, &vid);
1202 if (s != sizeof(vid)) {
1203 return VIRTIO_NET_ERR;
1204 }
1205
1206 if (vid >= MAX_VLAN)
1207 return VIRTIO_NET_ERR;
1208
1209 if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
1210 n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
1211 else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
1212 n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
1213 else
1214 return VIRTIO_NET_ERR;
1215
1216 rxfilter_notify(nc);
1217
1218 return VIRTIO_NET_OK;
1219 }
1220
virtio_net_handle_announce(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1221 static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
1222 struct iovec *iov, unsigned int iov_cnt)
1223 {
1224 trace_virtio_net_handle_announce(n->announce_timer.round);
1225 if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
1226 n->status & VIRTIO_NET_S_ANNOUNCE) {
1227 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
1228 if (n->announce_timer.round) {
1229 qemu_announce_timer_step(&n->announce_timer);
1230 }
1231 return VIRTIO_NET_OK;
1232 } else {
1233 return VIRTIO_NET_ERR;
1234 }
1235 }
1236
virtio_net_attach_ebpf_to_backend(NICState * nic,int prog_fd)1237 static bool virtio_net_attach_ebpf_to_backend(NICState *nic, int prog_fd)
1238 {
1239 NetClientState *nc = qemu_get_peer(qemu_get_queue(nic), 0);
1240 if (nc == NULL || nc->info->set_steering_ebpf == NULL) {
1241 return false;
1242 }
1243
1244 trace_virtio_net_rss_attach_ebpf(nic, prog_fd);
1245 return nc->info->set_steering_ebpf(nc, prog_fd);
1246 }
1247
rss_data_to_rss_config(struct VirtioNetRssData * data,struct EBPFRSSConfig * config)1248 static void rss_data_to_rss_config(struct VirtioNetRssData *data,
1249 struct EBPFRSSConfig *config)
1250 {
1251 config->redirect = data->redirect;
1252 config->populate_hash = data->populate_hash;
1253 config->hash_types = data->hash_types;
1254 config->indirections_len = data->indirections_len;
1255 config->default_queue = data->default_queue;
1256 }
1257
virtio_net_attach_ebpf_rss(VirtIONet * n)1258 static bool virtio_net_attach_ebpf_rss(VirtIONet *n)
1259 {
1260 struct EBPFRSSConfig config = {};
1261
1262 if (!ebpf_rss_is_loaded(&n->ebpf_rss)) {
1263 return false;
1264 }
1265
1266 rss_data_to_rss_config(&n->rss_data, &config);
1267
1268 if (!ebpf_rss_set_all(&n->ebpf_rss, &config,
1269 n->rss_data.indirections_table, n->rss_data.key,
1270 NULL)) {
1271 return false;
1272 }
1273
1274 if (!virtio_net_attach_ebpf_to_backend(n->nic, n->ebpf_rss.program_fd)) {
1275 return false;
1276 }
1277
1278 return true;
1279 }
1280
virtio_net_detach_ebpf_rss(VirtIONet * n)1281 static void virtio_net_detach_ebpf_rss(VirtIONet *n)
1282 {
1283 virtio_net_attach_ebpf_to_backend(n->nic, -1);
1284 }
1285
virtio_net_commit_rss_config(VirtIONet * n)1286 static void virtio_net_commit_rss_config(VirtIONet *n)
1287 {
1288 if (n->rss_data.enabled) {
1289 n->rss_data.enabled_software_rss = n->rss_data.populate_hash;
1290 if (n->rss_data.populate_hash) {
1291 virtio_net_detach_ebpf_rss(n);
1292 } else if (!virtio_net_attach_ebpf_rss(n)) {
1293 if (get_vhost_net(qemu_get_queue(n->nic)->peer)) {
1294 warn_report("Can't load eBPF RSS for vhost");
1295 } else {
1296 warn_report("Can't load eBPF RSS - fallback to software RSS");
1297 n->rss_data.enabled_software_rss = true;
1298 }
1299 }
1300
1301 trace_virtio_net_rss_enable(n,
1302 n->rss_data.hash_types,
1303 n->rss_data.indirections_len,
1304 sizeof(n->rss_data.key));
1305 } else {
1306 virtio_net_detach_ebpf_rss(n);
1307 trace_virtio_net_rss_disable(n);
1308 }
1309 }
1310
virtio_net_disable_rss(VirtIONet * n)1311 static void virtio_net_disable_rss(VirtIONet *n)
1312 {
1313 if (!n->rss_data.enabled) {
1314 return;
1315 }
1316
1317 n->rss_data.enabled = false;
1318 virtio_net_commit_rss_config(n);
1319 }
1320
virtio_net_load_ebpf_fds(VirtIONet * n,Error ** errp)1321 static bool virtio_net_load_ebpf_fds(VirtIONet *n, Error **errp)
1322 {
1323 int fds[EBPF_RSS_MAX_FDS] = { [0 ... EBPF_RSS_MAX_FDS - 1] = -1};
1324 int ret = true;
1325 int i = 0;
1326
1327 if (n->nr_ebpf_rss_fds != EBPF_RSS_MAX_FDS) {
1328 error_setg(errp, "Expected %d file descriptors but got %d",
1329 EBPF_RSS_MAX_FDS, n->nr_ebpf_rss_fds);
1330 return false;
1331 }
1332
1333 for (i = 0; i < n->nr_ebpf_rss_fds; i++) {
1334 fds[i] = monitor_fd_param(monitor_cur(), n->ebpf_rss_fds[i], errp);
1335 if (fds[i] < 0) {
1336 ret = false;
1337 goto exit;
1338 }
1339 }
1340
1341 ret = ebpf_rss_load_fds(&n->ebpf_rss, fds[0], fds[1], fds[2], fds[3], errp);
1342
1343 exit:
1344 if (!ret) {
1345 for (i = 0; i < n->nr_ebpf_rss_fds && fds[i] != -1; i++) {
1346 close(fds[i]);
1347 }
1348 }
1349
1350 return ret;
1351 }
1352
virtio_net_load_ebpf(VirtIONet * n,Error ** errp)1353 static bool virtio_net_load_ebpf(VirtIONet *n, Error **errp)
1354 {
1355 if (!virtio_net_attach_ebpf_to_backend(n->nic, -1)) {
1356 return true;
1357 }
1358
1359 trace_virtio_net_rss_load(n, n->nr_ebpf_rss_fds, n->ebpf_rss_fds);
1360
1361 /*
1362 * If user explicitly gave QEMU RSS FDs to use, then
1363 * failing to use them must be considered a fatal
1364 * error. If no RSS FDs were provided, QEMU is trying
1365 * eBPF on a "best effort" basis only, so report a
1366 * warning and allow fallback to software RSS.
1367 */
1368 if (n->ebpf_rss_fds) {
1369 return virtio_net_load_ebpf_fds(n, errp);
1370 }
1371
1372 ebpf_rss_load(&n->ebpf_rss, &error_warn);
1373 return true;
1374 }
1375
virtio_net_unload_ebpf(VirtIONet * n)1376 static void virtio_net_unload_ebpf(VirtIONet *n)
1377 {
1378 virtio_net_attach_ebpf_to_backend(n->nic, -1);
1379 ebpf_rss_unload(&n->ebpf_rss);
1380 }
1381
virtio_net_handle_rss(VirtIONet * n,struct iovec * iov,unsigned int iov_cnt,bool do_rss)1382 static uint16_t virtio_net_handle_rss(VirtIONet *n,
1383 struct iovec *iov,
1384 unsigned int iov_cnt,
1385 bool do_rss)
1386 {
1387 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1388 struct virtio_net_rss_config cfg;
1389 size_t s, offset = 0, size_get;
1390 uint16_t queue_pairs, i;
1391 struct {
1392 uint16_t us;
1393 uint8_t b;
1394 } QEMU_PACKED temp;
1395 const char *err_msg = "";
1396 uint32_t err_value = 0;
1397
1398 if (do_rss && !virtio_vdev_has_feature(vdev, VIRTIO_NET_F_RSS)) {
1399 err_msg = "RSS is not negotiated";
1400 goto error;
1401 }
1402 if (!do_rss && !virtio_vdev_has_feature(vdev, VIRTIO_NET_F_HASH_REPORT)) {
1403 err_msg = "Hash report is not negotiated";
1404 goto error;
1405 }
1406 size_get = offsetof(struct virtio_net_rss_config, indirection_table);
1407 s = iov_to_buf(iov, iov_cnt, offset, &cfg, size_get);
1408 if (s != size_get) {
1409 err_msg = "Short command buffer";
1410 err_value = (uint32_t)s;
1411 goto error;
1412 }
1413 n->rss_data.hash_types = virtio_ldl_p(vdev, &cfg.hash_types);
1414 n->rss_data.indirections_len =
1415 virtio_lduw_p(vdev, &cfg.indirection_table_mask);
1416 if (!do_rss) {
1417 n->rss_data.indirections_len = 0;
1418 }
1419 if (n->rss_data.indirections_len >= VIRTIO_NET_RSS_MAX_TABLE_LEN) {
1420 err_msg = "Too large indirection table";
1421 err_value = n->rss_data.indirections_len;
1422 goto error;
1423 }
1424 n->rss_data.indirections_len++;
1425 if (!is_power_of_2(n->rss_data.indirections_len)) {
1426 err_msg = "Invalid size of indirection table";
1427 err_value = n->rss_data.indirections_len;
1428 goto error;
1429 }
1430 n->rss_data.default_queue = do_rss ?
1431 virtio_lduw_p(vdev, &cfg.unclassified_queue) : 0;
1432 if (n->rss_data.default_queue >= n->max_queue_pairs) {
1433 err_msg = "Invalid default queue";
1434 err_value = n->rss_data.default_queue;
1435 goto error;
1436 }
1437 offset += size_get;
1438 size_get = sizeof(uint16_t) * n->rss_data.indirections_len;
1439 g_free(n->rss_data.indirections_table);
1440 n->rss_data.indirections_table = g_malloc(size_get);
1441 if (!n->rss_data.indirections_table) {
1442 err_msg = "Can't allocate indirections table";
1443 err_value = n->rss_data.indirections_len;
1444 goto error;
1445 }
1446 s = iov_to_buf(iov, iov_cnt, offset,
1447 n->rss_data.indirections_table, size_get);
1448 if (s != size_get) {
1449 err_msg = "Short indirection table buffer";
1450 err_value = (uint32_t)s;
1451 goto error;
1452 }
1453 for (i = 0; i < n->rss_data.indirections_len; ++i) {
1454 uint16_t val = n->rss_data.indirections_table[i];
1455 n->rss_data.indirections_table[i] = virtio_lduw_p(vdev, &val);
1456 }
1457 offset += size_get;
1458 size_get = sizeof(temp);
1459 s = iov_to_buf(iov, iov_cnt, offset, &temp, size_get);
1460 if (s != size_get) {
1461 err_msg = "Can't get queue_pairs";
1462 err_value = (uint32_t)s;
1463 goto error;
1464 }
1465 queue_pairs = do_rss ? virtio_lduw_p(vdev, &temp.us) : n->curr_queue_pairs;
1466 if (queue_pairs == 0 || queue_pairs > n->max_queue_pairs) {
1467 err_msg = "Invalid number of queue_pairs";
1468 err_value = queue_pairs;
1469 goto error;
1470 }
1471 if (temp.b > VIRTIO_NET_RSS_MAX_KEY_SIZE) {
1472 err_msg = "Invalid key size";
1473 err_value = temp.b;
1474 goto error;
1475 }
1476 if (!temp.b && n->rss_data.hash_types) {
1477 err_msg = "No key provided";
1478 err_value = 0;
1479 goto error;
1480 }
1481 if (!temp.b && !n->rss_data.hash_types) {
1482 virtio_net_disable_rss(n);
1483 return queue_pairs;
1484 }
1485 offset += size_get;
1486 size_get = temp.b;
1487 s = iov_to_buf(iov, iov_cnt, offset, n->rss_data.key, size_get);
1488 if (s != size_get) {
1489 err_msg = "Can get key buffer";
1490 err_value = (uint32_t)s;
1491 goto error;
1492 }
1493 n->rss_data.enabled = true;
1494 virtio_net_commit_rss_config(n);
1495 return queue_pairs;
1496 error:
1497 trace_virtio_net_rss_error(n, err_msg, err_value);
1498 virtio_net_disable_rss(n);
1499 return 0;
1500 }
1501
virtio_net_handle_mq(VirtIONet * n,uint8_t cmd,struct iovec * iov,unsigned int iov_cnt)1502 static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
1503 struct iovec *iov, unsigned int iov_cnt)
1504 {
1505 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1506 uint16_t queue_pairs;
1507 NetClientState *nc = qemu_get_queue(n->nic);
1508
1509 virtio_net_disable_rss(n);
1510 if (cmd == VIRTIO_NET_CTRL_MQ_HASH_CONFIG) {
1511 queue_pairs = virtio_net_handle_rss(n, iov, iov_cnt, false);
1512 return queue_pairs ? VIRTIO_NET_OK : VIRTIO_NET_ERR;
1513 }
1514 if (cmd == VIRTIO_NET_CTRL_MQ_RSS_CONFIG) {
1515 queue_pairs = virtio_net_handle_rss(n, iov, iov_cnt, true);
1516 } else if (cmd == VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
1517 struct virtio_net_ctrl_mq mq;
1518 size_t s;
1519 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_MQ)) {
1520 return VIRTIO_NET_ERR;
1521 }
1522 s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
1523 if (s != sizeof(mq)) {
1524 return VIRTIO_NET_ERR;
1525 }
1526 queue_pairs = virtio_lduw_p(vdev, &mq.virtqueue_pairs);
1527
1528 } else {
1529 return VIRTIO_NET_ERR;
1530 }
1531
1532 if (queue_pairs < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
1533 queue_pairs > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
1534 queue_pairs > n->max_queue_pairs ||
1535 !n->multiqueue) {
1536 return VIRTIO_NET_ERR;
1537 }
1538
1539 n->curr_queue_pairs = queue_pairs;
1540 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_VDPA) {
1541 /*
1542 * Avoid updating the backend for a vdpa device: We're only interested
1543 * in updating the device model queues.
1544 */
1545 return VIRTIO_NET_OK;
1546 }
1547 /* stop the backend before changing the number of queue_pairs to avoid handling a
1548 * disabled queue */
1549 virtio_net_set_status(vdev, vdev->status);
1550 virtio_net_set_queue_pairs(n);
1551
1552 return VIRTIO_NET_OK;
1553 }
1554
virtio_net_handle_ctrl_iov(VirtIODevice * vdev,const struct iovec * in_sg,unsigned in_num,const struct iovec * out_sg,unsigned out_num)1555 size_t virtio_net_handle_ctrl_iov(VirtIODevice *vdev,
1556 const struct iovec *in_sg, unsigned in_num,
1557 const struct iovec *out_sg,
1558 unsigned out_num)
1559 {
1560 VirtIONet *n = VIRTIO_NET(vdev);
1561 struct virtio_net_ctrl_hdr ctrl;
1562 virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
1563 size_t s;
1564 struct iovec *iov, *iov2;
1565
1566 if (iov_size(in_sg, in_num) < sizeof(status) ||
1567 iov_size(out_sg, out_num) < sizeof(ctrl)) {
1568 virtio_error(vdev, "virtio-net ctrl missing headers");
1569 return 0;
1570 }
1571
1572 iov2 = iov = g_memdup2(out_sg, sizeof(struct iovec) * out_num);
1573 s = iov_to_buf(iov, out_num, 0, &ctrl, sizeof(ctrl));
1574 iov_discard_front(&iov, &out_num, sizeof(ctrl));
1575 if (s != sizeof(ctrl)) {
1576 status = VIRTIO_NET_ERR;
1577 } else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
1578 status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, out_num);
1579 } else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
1580 status = virtio_net_handle_mac(n, ctrl.cmd, iov, out_num);
1581 } else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
1582 status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, out_num);
1583 } else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
1584 status = virtio_net_handle_announce(n, ctrl.cmd, iov, out_num);
1585 } else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
1586 status = virtio_net_handle_mq(n, ctrl.cmd, iov, out_num);
1587 } else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
1588 status = virtio_net_handle_offloads(n, ctrl.cmd, iov, out_num);
1589 }
1590
1591 s = iov_from_buf(in_sg, in_num, 0, &status, sizeof(status));
1592 assert(s == sizeof(status));
1593
1594 g_free(iov2);
1595 return sizeof(status);
1596 }
1597
virtio_net_handle_ctrl(VirtIODevice * vdev,VirtQueue * vq)1598 static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
1599 {
1600 VirtQueueElement *elem;
1601
1602 for (;;) {
1603 size_t written;
1604 elem = virtqueue_pop(vq, sizeof(VirtQueueElement));
1605 if (!elem) {
1606 break;
1607 }
1608
1609 written = virtio_net_handle_ctrl_iov(vdev, elem->in_sg, elem->in_num,
1610 elem->out_sg, elem->out_num);
1611 if (written > 0) {
1612 virtqueue_push(vq, elem, written);
1613 virtio_notify(vdev, vq);
1614 g_free(elem);
1615 } else {
1616 virtqueue_detach_element(vq, elem, 0);
1617 g_free(elem);
1618 break;
1619 }
1620 }
1621 }
1622
1623 /* RX */
1624
virtio_net_handle_rx(VirtIODevice * vdev,VirtQueue * vq)1625 static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
1626 {
1627 VirtIONet *n = VIRTIO_NET(vdev);
1628 int queue_index = vq2q(virtio_get_queue_index(vq));
1629
1630 qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
1631 }
1632
virtio_net_can_receive(NetClientState * nc)1633 static bool virtio_net_can_receive(NetClientState *nc)
1634 {
1635 VirtIONet *n = qemu_get_nic_opaque(nc);
1636 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1637 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
1638
1639 if (!vdev->vm_running) {
1640 return false;
1641 }
1642
1643 if (nc->queue_index >= n->curr_queue_pairs) {
1644 return false;
1645 }
1646
1647 if (!virtio_queue_ready(q->rx_vq) ||
1648 !(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
1649 return false;
1650 }
1651
1652 return true;
1653 }
1654
virtio_net_has_buffers(VirtIONetQueue * q,int bufsize)1655 static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
1656 {
1657 int opaque;
1658 unsigned int in_bytes;
1659 VirtIONet *n = q->n;
1660
1661 while (virtio_queue_empty(q->rx_vq) || n->mergeable_rx_bufs) {
1662 opaque = virtqueue_get_avail_bytes(q->rx_vq, &in_bytes, NULL,
1663 bufsize, 0);
1664 /* Buffer is enough, disable notifiaction */
1665 if (bufsize <= in_bytes) {
1666 break;
1667 }
1668
1669 if (virtio_queue_enable_notification_and_check(q->rx_vq, opaque)) {
1670 /* Guest has added some buffers, try again */
1671 continue;
1672 } else {
1673 return 0;
1674 }
1675 }
1676
1677 virtio_queue_set_notification(q->rx_vq, 0);
1678
1679 return 1;
1680 }
1681
virtio_net_hdr_swap(VirtIODevice * vdev,struct virtio_net_hdr * hdr)1682 static void virtio_net_hdr_swap(VirtIODevice *vdev, struct virtio_net_hdr *hdr)
1683 {
1684 virtio_tswap16s(vdev, &hdr->hdr_len);
1685 virtio_tswap16s(vdev, &hdr->gso_size);
1686 virtio_tswap16s(vdev, &hdr->csum_start);
1687 virtio_tswap16s(vdev, &hdr->csum_offset);
1688 }
1689
1690 /* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
1691 * it never finds out that the packets don't have valid checksums. This
1692 * causes dhclient to get upset. Fedora's carried a patch for ages to
1693 * fix this with Xen but it hasn't appeared in an upstream release of
1694 * dhclient yet.
1695 *
1696 * To avoid breaking existing guests, we catch udp packets and add
1697 * checksums. This is terrible but it's better than hacking the guest
1698 * kernels.
1699 *
1700 * N.B. if we introduce a zero-copy API, this operation is no longer free so
1701 * we should provide a mechanism to disable it to avoid polluting the host
1702 * cache.
1703 */
work_around_broken_dhclient(struct virtio_net_hdr * hdr,uint8_t * buf,size_t size)1704 static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
1705 uint8_t *buf, size_t size)
1706 {
1707 size_t csum_size = ETH_HLEN + sizeof(struct ip_header) +
1708 sizeof(struct udp_header);
1709
1710 if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
1711 (size >= csum_size && size < 1500) && /* normal sized MTU */
1712 (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
1713 (buf[23] == 17) && /* ip.protocol == UDP */
1714 (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
1715 net_checksum_calculate(buf, size, CSUM_UDP);
1716 hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
1717 }
1718 }
1719
receive_header(VirtIONet * n,const struct iovec * iov,int iov_cnt,const void * buf,size_t size)1720 static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
1721 const void *buf, size_t size)
1722 {
1723 if (n->has_vnet_hdr) {
1724 /* FIXME this cast is evil */
1725 void *wbuf = (void *)buf;
1726 work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
1727 size - n->host_hdr_len);
1728
1729 if (n->needs_vnet_hdr_swap) {
1730 virtio_net_hdr_swap(VIRTIO_DEVICE(n), wbuf);
1731 }
1732 iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
1733 } else {
1734 struct virtio_net_hdr hdr = {
1735 .flags = 0,
1736 .gso_type = VIRTIO_NET_HDR_GSO_NONE
1737 };
1738 iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
1739 }
1740 }
1741
receive_filter(VirtIONet * n,const uint8_t * buf,int size)1742 static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
1743 {
1744 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1745 static const uint8_t vlan[] = {0x81, 0x00};
1746 uint8_t *ptr = (uint8_t *)buf;
1747 int i;
1748
1749 if (n->promisc)
1750 return 1;
1751
1752 ptr += n->host_hdr_len;
1753
1754 if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
1755 int vid = lduw_be_p(ptr + 14) & 0xfff;
1756 if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
1757 return 0;
1758 }
1759
1760 if (ptr[0] & 1) { // multicast
1761 if (!memcmp(ptr, bcast, sizeof(bcast))) {
1762 return !n->nobcast;
1763 } else if (n->nomulti) {
1764 return 0;
1765 } else if (n->allmulti || n->mac_table.multi_overflow) {
1766 return 1;
1767 }
1768
1769 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
1770 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1771 return 1;
1772 }
1773 }
1774 } else { // unicast
1775 if (n->nouni) {
1776 return 0;
1777 } else if (n->alluni || n->mac_table.uni_overflow) {
1778 return 1;
1779 } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
1780 return 1;
1781 }
1782
1783 for (i = 0; i < n->mac_table.first_multi; i++) {
1784 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
1785 return 1;
1786 }
1787 }
1788 }
1789
1790 return 0;
1791 }
1792
virtio_net_get_hash_type(bool hasip4,bool hasip6,EthL4HdrProto l4hdr_proto,uint32_t types)1793 static uint8_t virtio_net_get_hash_type(bool hasip4,
1794 bool hasip6,
1795 EthL4HdrProto l4hdr_proto,
1796 uint32_t types)
1797 {
1798 if (hasip4) {
1799 switch (l4hdr_proto) {
1800 case ETH_L4_HDR_PROTO_TCP:
1801 if (types & VIRTIO_NET_RSS_HASH_TYPE_TCPv4) {
1802 return NetPktRssIpV4Tcp;
1803 }
1804 break;
1805
1806 case ETH_L4_HDR_PROTO_UDP:
1807 if (types & VIRTIO_NET_RSS_HASH_TYPE_UDPv4) {
1808 return NetPktRssIpV4Udp;
1809 }
1810 break;
1811
1812 default:
1813 break;
1814 }
1815
1816 if (types & VIRTIO_NET_RSS_HASH_TYPE_IPv4) {
1817 return NetPktRssIpV4;
1818 }
1819 } else if (hasip6) {
1820 switch (l4hdr_proto) {
1821 case ETH_L4_HDR_PROTO_TCP:
1822 if (types & VIRTIO_NET_RSS_HASH_TYPE_TCP_EX) {
1823 return NetPktRssIpV6TcpEx;
1824 }
1825 if (types & VIRTIO_NET_RSS_HASH_TYPE_TCPv6) {
1826 return NetPktRssIpV6Tcp;
1827 }
1828 break;
1829
1830 case ETH_L4_HDR_PROTO_UDP:
1831 if (types & VIRTIO_NET_RSS_HASH_TYPE_UDP_EX) {
1832 return NetPktRssIpV6UdpEx;
1833 }
1834 if (types & VIRTIO_NET_RSS_HASH_TYPE_UDPv6) {
1835 return NetPktRssIpV6Udp;
1836 }
1837 break;
1838
1839 default:
1840 break;
1841 }
1842
1843 if (types & VIRTIO_NET_RSS_HASH_TYPE_IP_EX) {
1844 return NetPktRssIpV6Ex;
1845 }
1846 if (types & VIRTIO_NET_RSS_HASH_TYPE_IPv6) {
1847 return NetPktRssIpV6;
1848 }
1849 }
1850 return 0xff;
1851 }
1852
virtio_net_process_rss(NetClientState * nc,const uint8_t * buf,size_t size,struct virtio_net_hdr_v1_hash * hdr)1853 static int virtio_net_process_rss(NetClientState *nc, const uint8_t *buf,
1854 size_t size,
1855 struct virtio_net_hdr_v1_hash *hdr)
1856 {
1857 VirtIONet *n = qemu_get_nic_opaque(nc);
1858 unsigned int index = nc->queue_index, new_index = index;
1859 struct NetRxPkt *pkt = n->rx_pkt;
1860 uint8_t net_hash_type;
1861 uint32_t hash;
1862 bool hasip4, hasip6;
1863 EthL4HdrProto l4hdr_proto;
1864 static const uint8_t reports[NetPktRssIpV6UdpEx + 1] = {
1865 VIRTIO_NET_HASH_REPORT_IPv4,
1866 VIRTIO_NET_HASH_REPORT_TCPv4,
1867 VIRTIO_NET_HASH_REPORT_TCPv6,
1868 VIRTIO_NET_HASH_REPORT_IPv6,
1869 VIRTIO_NET_HASH_REPORT_IPv6_EX,
1870 VIRTIO_NET_HASH_REPORT_TCPv6_EX,
1871 VIRTIO_NET_HASH_REPORT_UDPv4,
1872 VIRTIO_NET_HASH_REPORT_UDPv6,
1873 VIRTIO_NET_HASH_REPORT_UDPv6_EX
1874 };
1875 struct iovec iov = {
1876 .iov_base = (void *)buf,
1877 .iov_len = size
1878 };
1879
1880 net_rx_pkt_set_protocols(pkt, &iov, 1, n->host_hdr_len);
1881 net_rx_pkt_get_protocols(pkt, &hasip4, &hasip6, &l4hdr_proto);
1882 net_hash_type = virtio_net_get_hash_type(hasip4, hasip6, l4hdr_proto,
1883 n->rss_data.hash_types);
1884 if (net_hash_type > NetPktRssIpV6UdpEx) {
1885 if (n->rss_data.populate_hash) {
1886 hdr->hash_value = VIRTIO_NET_HASH_REPORT_NONE;
1887 hdr->hash_report = 0;
1888 }
1889 return n->rss_data.redirect ? n->rss_data.default_queue : -1;
1890 }
1891
1892 hash = net_rx_pkt_calc_rss_hash(pkt, net_hash_type, n->rss_data.key);
1893
1894 if (n->rss_data.populate_hash) {
1895 hdr->hash_value = hash;
1896 hdr->hash_report = reports[net_hash_type];
1897 }
1898
1899 if (n->rss_data.redirect) {
1900 new_index = hash & (n->rss_data.indirections_len - 1);
1901 new_index = n->rss_data.indirections_table[new_index];
1902 }
1903
1904 return (index == new_index) ? -1 : new_index;
1905 }
1906
virtio_net_receive_rcu(NetClientState * nc,const uint8_t * buf,size_t size)1907 static ssize_t virtio_net_receive_rcu(NetClientState *nc, const uint8_t *buf,
1908 size_t size)
1909 {
1910 VirtIONet *n = qemu_get_nic_opaque(nc);
1911 VirtIONetQueue *q;
1912 VirtIODevice *vdev = VIRTIO_DEVICE(n);
1913 VirtQueueElement *elems[VIRTQUEUE_MAX_SIZE];
1914 size_t lens[VIRTQUEUE_MAX_SIZE];
1915 struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
1916 struct virtio_net_hdr_v1_hash extra_hdr;
1917 unsigned mhdr_cnt = 0;
1918 size_t offset, i, guest_offset, j;
1919 ssize_t err;
1920
1921 memset(&extra_hdr, 0, sizeof(extra_hdr));
1922
1923 if (n->rss_data.enabled && n->rss_data.enabled_software_rss) {
1924 int index = virtio_net_process_rss(nc, buf, size, &extra_hdr);
1925 if (index >= 0) {
1926 nc = qemu_get_subqueue(n->nic, index % n->curr_queue_pairs);
1927 }
1928 }
1929
1930 if (!virtio_net_can_receive(nc)) {
1931 return -1;
1932 }
1933
1934 q = virtio_net_get_subqueue(nc);
1935
1936 /* hdr_len refers to the header we supply to the guest */
1937 if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
1938 return 0;
1939 }
1940
1941 if (!receive_filter(n, buf, size))
1942 return size;
1943
1944 offset = i = 0;
1945
1946 while (offset < size) {
1947 VirtQueueElement *elem;
1948 int len, total;
1949 const struct iovec *sg;
1950
1951 total = 0;
1952
1953 if (i == VIRTQUEUE_MAX_SIZE) {
1954 virtio_error(vdev, "virtio-net unexpected long buffer chain");
1955 err = size;
1956 goto err;
1957 }
1958
1959 elem = virtqueue_pop(q->rx_vq, sizeof(VirtQueueElement));
1960 if (!elem) {
1961 if (i) {
1962 virtio_error(vdev, "virtio-net unexpected empty queue: "
1963 "i %zd mergeable %d offset %zd, size %zd, "
1964 "guest hdr len %zd, host hdr len %zd "
1965 "guest features 0x%" PRIx64,
1966 i, n->mergeable_rx_bufs, offset, size,
1967 n->guest_hdr_len, n->host_hdr_len,
1968 vdev->guest_features);
1969 }
1970 err = -1;
1971 goto err;
1972 }
1973
1974 if (elem->in_num < 1) {
1975 virtio_error(vdev,
1976 "virtio-net receive queue contains no in buffers");
1977 virtqueue_detach_element(q->rx_vq, elem, 0);
1978 g_free(elem);
1979 err = -1;
1980 goto err;
1981 }
1982
1983 sg = elem->in_sg;
1984 if (i == 0) {
1985 assert(offset == 0);
1986 if (n->mergeable_rx_bufs) {
1987 mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
1988 sg, elem->in_num,
1989 offsetof(typeof(extra_hdr), hdr.num_buffers),
1990 sizeof(extra_hdr.hdr.num_buffers));
1991 } else {
1992 extra_hdr.hdr.num_buffers = cpu_to_le16(1);
1993 }
1994
1995 receive_header(n, sg, elem->in_num, buf, size);
1996 if (n->rss_data.populate_hash) {
1997 offset = offsetof(typeof(extra_hdr), hash_value);
1998 iov_from_buf(sg, elem->in_num, offset,
1999 (char *)&extra_hdr + offset,
2000 sizeof(extra_hdr.hash_value) +
2001 sizeof(extra_hdr.hash_report));
2002 }
2003 offset = n->host_hdr_len;
2004 total += n->guest_hdr_len;
2005 guest_offset = n->guest_hdr_len;
2006 } else {
2007 guest_offset = 0;
2008 }
2009
2010 /* copy in packet. ugh */
2011 len = iov_from_buf(sg, elem->in_num, guest_offset,
2012 buf + offset, size - offset);
2013 total += len;
2014 offset += len;
2015 /* If buffers can't be merged, at this point we
2016 * must have consumed the complete packet.
2017 * Otherwise, drop it. */
2018 if (!n->mergeable_rx_bufs && offset < size) {
2019 virtqueue_unpop(q->rx_vq, elem, total);
2020 g_free(elem);
2021 err = size;
2022 goto err;
2023 }
2024
2025 elems[i] = elem;
2026 lens[i] = total;
2027 i++;
2028 }
2029
2030 if (mhdr_cnt) {
2031 virtio_stw_p(vdev, &extra_hdr.hdr.num_buffers, i);
2032 iov_from_buf(mhdr_sg, mhdr_cnt,
2033 0,
2034 &extra_hdr.hdr.num_buffers,
2035 sizeof extra_hdr.hdr.num_buffers);
2036 }
2037
2038 for (j = 0; j < i; j++) {
2039 /* signal other side */
2040 virtqueue_fill(q->rx_vq, elems[j], lens[j], j);
2041 g_free(elems[j]);
2042 }
2043
2044 virtqueue_flush(q->rx_vq, i);
2045 virtio_notify(vdev, q->rx_vq);
2046
2047 return size;
2048
2049 err:
2050 for (j = 0; j < i; j++) {
2051 virtqueue_detach_element(q->rx_vq, elems[j], lens[j]);
2052 g_free(elems[j]);
2053 }
2054
2055 return err;
2056 }
2057
virtio_net_do_receive(NetClientState * nc,const uint8_t * buf,size_t size)2058 static ssize_t virtio_net_do_receive(NetClientState *nc, const uint8_t *buf,
2059 size_t size)
2060 {
2061 RCU_READ_LOCK_GUARD();
2062
2063 return virtio_net_receive_rcu(nc, buf, size);
2064 }
2065
2066 /*
2067 * Accessors to read and write the IP packet data length field. This
2068 * is a potentially unaligned network-byte-order 16 bit unsigned integer
2069 * pointed to by unit->ip_len.
2070 */
read_unit_ip_len(VirtioNetRscUnit * unit)2071 static uint16_t read_unit_ip_len(VirtioNetRscUnit *unit)
2072 {
2073 return lduw_be_p(unit->ip_plen);
2074 }
2075
write_unit_ip_len(VirtioNetRscUnit * unit,uint16_t l)2076 static void write_unit_ip_len(VirtioNetRscUnit *unit, uint16_t l)
2077 {
2078 stw_be_p(unit->ip_plen, l);
2079 }
2080
virtio_net_rsc_extract_unit4(VirtioNetRscChain * chain,const uint8_t * buf,VirtioNetRscUnit * unit)2081 static void virtio_net_rsc_extract_unit4(VirtioNetRscChain *chain,
2082 const uint8_t *buf,
2083 VirtioNetRscUnit *unit)
2084 {
2085 uint16_t ip_hdrlen;
2086 struct ip_header *ip;
2087
2088 ip = (struct ip_header *)(buf + chain->n->guest_hdr_len
2089 + sizeof(struct eth_header));
2090 unit->ip = (void *)ip;
2091 ip_hdrlen = (ip->ip_ver_len & 0xF) << 2;
2092 unit->ip_plen = &ip->ip_len;
2093 unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip) + ip_hdrlen);
2094 unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
2095 unit->payload = read_unit_ip_len(unit) - ip_hdrlen - unit->tcp_hdrlen;
2096 }
2097
virtio_net_rsc_extract_unit6(VirtioNetRscChain * chain,const uint8_t * buf,VirtioNetRscUnit * unit)2098 static void virtio_net_rsc_extract_unit6(VirtioNetRscChain *chain,
2099 const uint8_t *buf,
2100 VirtioNetRscUnit *unit)
2101 {
2102 struct ip6_header *ip6;
2103
2104 ip6 = (struct ip6_header *)(buf + chain->n->guest_hdr_len
2105 + sizeof(struct eth_header));
2106 unit->ip = ip6;
2107 unit->ip_plen = &(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
2108 unit->tcp = (struct tcp_header *)(((uint8_t *)unit->ip)
2109 + sizeof(struct ip6_header));
2110 unit->tcp_hdrlen = (htons(unit->tcp->th_offset_flags) & 0xF000) >> 10;
2111
2112 /* There is a difference between payload length in ipv4 and v6,
2113 ip header is excluded in ipv6 */
2114 unit->payload = read_unit_ip_len(unit) - unit->tcp_hdrlen;
2115 }
2116
virtio_net_rsc_drain_seg(VirtioNetRscChain * chain,VirtioNetRscSeg * seg)2117 static size_t virtio_net_rsc_drain_seg(VirtioNetRscChain *chain,
2118 VirtioNetRscSeg *seg)
2119 {
2120 int ret;
2121 struct virtio_net_hdr_v1 *h;
2122
2123 h = (struct virtio_net_hdr_v1 *)seg->buf;
2124 h->flags = 0;
2125 h->gso_type = VIRTIO_NET_HDR_GSO_NONE;
2126
2127 if (seg->is_coalesced) {
2128 h->rsc.segments = seg->packets;
2129 h->rsc.dup_acks = seg->dup_ack;
2130 h->flags = VIRTIO_NET_HDR_F_RSC_INFO;
2131 if (chain->proto == ETH_P_IP) {
2132 h->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
2133 } else {
2134 h->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
2135 }
2136 }
2137
2138 ret = virtio_net_do_receive(seg->nc, seg->buf, seg->size);
2139 QTAILQ_REMOVE(&chain->buffers, seg, next);
2140 g_free(seg->buf);
2141 g_free(seg);
2142
2143 return ret;
2144 }
2145
virtio_net_rsc_purge(void * opq)2146 static void virtio_net_rsc_purge(void *opq)
2147 {
2148 VirtioNetRscSeg *seg, *rn;
2149 VirtioNetRscChain *chain = (VirtioNetRscChain *)opq;
2150
2151 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn) {
2152 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
2153 chain->stat.purge_failed++;
2154 continue;
2155 }
2156 }
2157
2158 chain->stat.timer++;
2159 if (!QTAILQ_EMPTY(&chain->buffers)) {
2160 timer_mod(chain->drain_timer,
2161 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + chain->n->rsc_timeout);
2162 }
2163 }
2164
virtio_net_rsc_cleanup(VirtIONet * n)2165 static void virtio_net_rsc_cleanup(VirtIONet *n)
2166 {
2167 VirtioNetRscChain *chain, *rn_chain;
2168 VirtioNetRscSeg *seg, *rn_seg;
2169
2170 QTAILQ_FOREACH_SAFE(chain, &n->rsc_chains, next, rn_chain) {
2171 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, rn_seg) {
2172 QTAILQ_REMOVE(&chain->buffers, seg, next);
2173 g_free(seg->buf);
2174 g_free(seg);
2175 }
2176
2177 timer_free(chain->drain_timer);
2178 QTAILQ_REMOVE(&n->rsc_chains, chain, next);
2179 g_free(chain);
2180 }
2181 }
2182
virtio_net_rsc_cache_buf(VirtioNetRscChain * chain,NetClientState * nc,const uint8_t * buf,size_t size)2183 static void virtio_net_rsc_cache_buf(VirtioNetRscChain *chain,
2184 NetClientState *nc,
2185 const uint8_t *buf, size_t size)
2186 {
2187 uint16_t hdr_len;
2188 VirtioNetRscSeg *seg;
2189
2190 hdr_len = chain->n->guest_hdr_len;
2191 seg = g_new(VirtioNetRscSeg, 1);
2192 seg->buf = g_malloc(hdr_len + sizeof(struct eth_header)
2193 + sizeof(struct ip6_header) + VIRTIO_NET_MAX_TCP_PAYLOAD);
2194 memcpy(seg->buf, buf, size);
2195 seg->size = size;
2196 seg->packets = 1;
2197 seg->dup_ack = 0;
2198 seg->is_coalesced = 0;
2199 seg->nc = nc;
2200
2201 QTAILQ_INSERT_TAIL(&chain->buffers, seg, next);
2202 chain->stat.cache++;
2203
2204 switch (chain->proto) {
2205 case ETH_P_IP:
2206 virtio_net_rsc_extract_unit4(chain, seg->buf, &seg->unit);
2207 break;
2208 case ETH_P_IPV6:
2209 virtio_net_rsc_extract_unit6(chain, seg->buf, &seg->unit);
2210 break;
2211 default:
2212 g_assert_not_reached();
2213 }
2214 }
2215
virtio_net_rsc_handle_ack(VirtioNetRscChain * chain,VirtioNetRscSeg * seg,const uint8_t * buf,struct tcp_header * n_tcp,struct tcp_header * o_tcp)2216 static int32_t virtio_net_rsc_handle_ack(VirtioNetRscChain *chain,
2217 VirtioNetRscSeg *seg,
2218 const uint8_t *buf,
2219 struct tcp_header *n_tcp,
2220 struct tcp_header *o_tcp)
2221 {
2222 uint32_t nack, oack;
2223 uint16_t nwin, owin;
2224
2225 nack = htonl(n_tcp->th_ack);
2226 nwin = htons(n_tcp->th_win);
2227 oack = htonl(o_tcp->th_ack);
2228 owin = htons(o_tcp->th_win);
2229
2230 if ((nack - oack) >= VIRTIO_NET_MAX_TCP_PAYLOAD) {
2231 chain->stat.ack_out_of_win++;
2232 return RSC_FINAL;
2233 } else if (nack == oack) {
2234 /* duplicated ack or window probe */
2235 if (nwin == owin) {
2236 /* duplicated ack, add dup ack count due to whql test up to 1 */
2237 chain->stat.dup_ack++;
2238 return RSC_FINAL;
2239 } else {
2240 /* Coalesce window update */
2241 o_tcp->th_win = n_tcp->th_win;
2242 chain->stat.win_update++;
2243 return RSC_COALESCE;
2244 }
2245 } else {
2246 /* pure ack, go to 'C', finalize*/
2247 chain->stat.pure_ack++;
2248 return RSC_FINAL;
2249 }
2250 }
2251
virtio_net_rsc_coalesce_data(VirtioNetRscChain * chain,VirtioNetRscSeg * seg,const uint8_t * buf,VirtioNetRscUnit * n_unit)2252 static int32_t virtio_net_rsc_coalesce_data(VirtioNetRscChain *chain,
2253 VirtioNetRscSeg *seg,
2254 const uint8_t *buf,
2255 VirtioNetRscUnit *n_unit)
2256 {
2257 void *data;
2258 uint16_t o_ip_len;
2259 uint32_t nseq, oseq;
2260 VirtioNetRscUnit *o_unit;
2261
2262 o_unit = &seg->unit;
2263 o_ip_len = read_unit_ip_len(o_unit);
2264 nseq = htonl(n_unit->tcp->th_seq);
2265 oseq = htonl(o_unit->tcp->th_seq);
2266
2267 /* out of order or retransmitted. */
2268 if ((nseq - oseq) > VIRTIO_NET_MAX_TCP_PAYLOAD) {
2269 chain->stat.data_out_of_win++;
2270 return RSC_FINAL;
2271 }
2272
2273 data = ((uint8_t *)n_unit->tcp) + n_unit->tcp_hdrlen;
2274 if (nseq == oseq) {
2275 if ((o_unit->payload == 0) && n_unit->payload) {
2276 /* From no payload to payload, normal case, not a dup ack or etc */
2277 chain->stat.data_after_pure_ack++;
2278 goto coalesce;
2279 } else {
2280 return virtio_net_rsc_handle_ack(chain, seg, buf,
2281 n_unit->tcp, o_unit->tcp);
2282 }
2283 } else if ((nseq - oseq) != o_unit->payload) {
2284 /* Not a consistent packet, out of order */
2285 chain->stat.data_out_of_order++;
2286 return RSC_FINAL;
2287 } else {
2288 coalesce:
2289 if ((o_ip_len + n_unit->payload) > chain->max_payload) {
2290 chain->stat.over_size++;
2291 return RSC_FINAL;
2292 }
2293
2294 /* Here comes the right data, the payload length in v4/v6 is different,
2295 so use the field value to update and record the new data len */
2296 o_unit->payload += n_unit->payload; /* update new data len */
2297
2298 /* update field in ip header */
2299 write_unit_ip_len(o_unit, o_ip_len + n_unit->payload);
2300
2301 /* Bring 'PUSH' big, the whql test guide says 'PUSH' can be coalesced
2302 for windows guest, while this may change the behavior for linux
2303 guest (only if it uses RSC feature). */
2304 o_unit->tcp->th_offset_flags = n_unit->tcp->th_offset_flags;
2305
2306 o_unit->tcp->th_ack = n_unit->tcp->th_ack;
2307 o_unit->tcp->th_win = n_unit->tcp->th_win;
2308
2309 memmove(seg->buf + seg->size, data, n_unit->payload);
2310 seg->size += n_unit->payload;
2311 seg->packets++;
2312 chain->stat.coalesced++;
2313 return RSC_COALESCE;
2314 }
2315 }
2316
virtio_net_rsc_coalesce4(VirtioNetRscChain * chain,VirtioNetRscSeg * seg,const uint8_t * buf,size_t size,VirtioNetRscUnit * unit)2317 static int32_t virtio_net_rsc_coalesce4(VirtioNetRscChain *chain,
2318 VirtioNetRscSeg *seg,
2319 const uint8_t *buf, size_t size,
2320 VirtioNetRscUnit *unit)
2321 {
2322 struct ip_header *ip1, *ip2;
2323
2324 ip1 = (struct ip_header *)(unit->ip);
2325 ip2 = (struct ip_header *)(seg->unit.ip);
2326 if ((ip1->ip_src ^ ip2->ip_src) || (ip1->ip_dst ^ ip2->ip_dst)
2327 || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
2328 || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
2329 chain->stat.no_match++;
2330 return RSC_NO_MATCH;
2331 }
2332
2333 return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
2334 }
2335
virtio_net_rsc_coalesce6(VirtioNetRscChain * chain,VirtioNetRscSeg * seg,const uint8_t * buf,size_t size,VirtioNetRscUnit * unit)2336 static int32_t virtio_net_rsc_coalesce6(VirtioNetRscChain *chain,
2337 VirtioNetRscSeg *seg,
2338 const uint8_t *buf, size_t size,
2339 VirtioNetRscUnit *unit)
2340 {
2341 struct ip6_header *ip1, *ip2;
2342
2343 ip1 = (struct ip6_header *)(unit->ip);
2344 ip2 = (struct ip6_header *)(seg->unit.ip);
2345 if (memcmp(&ip1->ip6_src, &ip2->ip6_src, sizeof(struct in6_address))
2346 || memcmp(&ip1->ip6_dst, &ip2->ip6_dst, sizeof(struct in6_address))
2347 || (unit->tcp->th_sport ^ seg->unit.tcp->th_sport)
2348 || (unit->tcp->th_dport ^ seg->unit.tcp->th_dport)) {
2349 chain->stat.no_match++;
2350 return RSC_NO_MATCH;
2351 }
2352
2353 return virtio_net_rsc_coalesce_data(chain, seg, buf, unit);
2354 }
2355
2356 /* Packets with 'SYN' should bypass, other flag should be sent after drain
2357 * to prevent out of order */
virtio_net_rsc_tcp_ctrl_check(VirtioNetRscChain * chain,struct tcp_header * tcp)2358 static int virtio_net_rsc_tcp_ctrl_check(VirtioNetRscChain *chain,
2359 struct tcp_header *tcp)
2360 {
2361 uint16_t tcp_hdr;
2362 uint16_t tcp_flag;
2363
2364 tcp_flag = htons(tcp->th_offset_flags);
2365 tcp_hdr = (tcp_flag & VIRTIO_NET_TCP_HDR_LENGTH) >> 10;
2366 tcp_flag &= VIRTIO_NET_TCP_FLAG;
2367 if (tcp_flag & TH_SYN) {
2368 chain->stat.tcp_syn++;
2369 return RSC_BYPASS;
2370 }
2371
2372 if (tcp_flag & (TH_FIN | TH_URG | TH_RST | TH_ECE | TH_CWR)) {
2373 chain->stat.tcp_ctrl_drain++;
2374 return RSC_FINAL;
2375 }
2376
2377 if (tcp_hdr > sizeof(struct tcp_header)) {
2378 chain->stat.tcp_all_opt++;
2379 return RSC_FINAL;
2380 }
2381
2382 return RSC_CANDIDATE;
2383 }
2384
virtio_net_rsc_do_coalesce(VirtioNetRscChain * chain,NetClientState * nc,const uint8_t * buf,size_t size,VirtioNetRscUnit * unit)2385 static size_t virtio_net_rsc_do_coalesce(VirtioNetRscChain *chain,
2386 NetClientState *nc,
2387 const uint8_t *buf, size_t size,
2388 VirtioNetRscUnit *unit)
2389 {
2390 int ret;
2391 VirtioNetRscSeg *seg, *nseg;
2392
2393 if (QTAILQ_EMPTY(&chain->buffers)) {
2394 chain->stat.empty_cache++;
2395 virtio_net_rsc_cache_buf(chain, nc, buf, size);
2396 timer_mod(chain->drain_timer,
2397 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + chain->n->rsc_timeout);
2398 return size;
2399 }
2400
2401 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
2402 if (chain->proto == ETH_P_IP) {
2403 ret = virtio_net_rsc_coalesce4(chain, seg, buf, size, unit);
2404 } else {
2405 ret = virtio_net_rsc_coalesce6(chain, seg, buf, size, unit);
2406 }
2407
2408 if (ret == RSC_FINAL) {
2409 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
2410 /* Send failed */
2411 chain->stat.final_failed++;
2412 return 0;
2413 }
2414
2415 /* Send current packet */
2416 return virtio_net_do_receive(nc, buf, size);
2417 } else if (ret == RSC_NO_MATCH) {
2418 continue;
2419 } else {
2420 /* Coalesced, mark coalesced flag to tell calc cksum for ipv4 */
2421 seg->is_coalesced = 1;
2422 return size;
2423 }
2424 }
2425
2426 chain->stat.no_match_cache++;
2427 virtio_net_rsc_cache_buf(chain, nc, buf, size);
2428 return size;
2429 }
2430
2431 /* Drain a connection data, this is to avoid out of order segments */
virtio_net_rsc_drain_flow(VirtioNetRscChain * chain,NetClientState * nc,const uint8_t * buf,size_t size,uint16_t ip_start,uint16_t ip_size,uint16_t tcp_port)2432 static size_t virtio_net_rsc_drain_flow(VirtioNetRscChain *chain,
2433 NetClientState *nc,
2434 const uint8_t *buf, size_t size,
2435 uint16_t ip_start, uint16_t ip_size,
2436 uint16_t tcp_port)
2437 {
2438 VirtioNetRscSeg *seg, *nseg;
2439 uint32_t ppair1, ppair2;
2440
2441 ppair1 = *(uint32_t *)(buf + tcp_port);
2442 QTAILQ_FOREACH_SAFE(seg, &chain->buffers, next, nseg) {
2443 ppair2 = *(uint32_t *)(seg->buf + tcp_port);
2444 if (memcmp(buf + ip_start, seg->buf + ip_start, ip_size)
2445 || (ppair1 != ppair2)) {
2446 continue;
2447 }
2448 if (virtio_net_rsc_drain_seg(chain, seg) == 0) {
2449 chain->stat.drain_failed++;
2450 }
2451
2452 break;
2453 }
2454
2455 return virtio_net_do_receive(nc, buf, size);
2456 }
2457
virtio_net_rsc_sanity_check4(VirtioNetRscChain * chain,struct ip_header * ip,const uint8_t * buf,size_t size)2458 static int32_t virtio_net_rsc_sanity_check4(VirtioNetRscChain *chain,
2459 struct ip_header *ip,
2460 const uint8_t *buf, size_t size)
2461 {
2462 uint16_t ip_len;
2463
2464 /* Not an ipv4 packet */
2465 if (((ip->ip_ver_len & 0xF0) >> 4) != IP_HEADER_VERSION_4) {
2466 chain->stat.ip_option++;
2467 return RSC_BYPASS;
2468 }
2469
2470 /* Don't handle packets with ip option */
2471 if ((ip->ip_ver_len & 0xF) != VIRTIO_NET_IP4_HEADER_LENGTH) {
2472 chain->stat.ip_option++;
2473 return RSC_BYPASS;
2474 }
2475
2476 if (ip->ip_p != IPPROTO_TCP) {
2477 chain->stat.bypass_not_tcp++;
2478 return RSC_BYPASS;
2479 }
2480
2481 /* Don't handle packets with ip fragment */
2482 if (!(htons(ip->ip_off) & IP_DF)) {
2483 chain->stat.ip_frag++;
2484 return RSC_BYPASS;
2485 }
2486
2487 /* Don't handle packets with ecn flag */
2488 if (IPTOS_ECN(ip->ip_tos)) {
2489 chain->stat.ip_ecn++;
2490 return RSC_BYPASS;
2491 }
2492
2493 ip_len = htons(ip->ip_len);
2494 if (ip_len < (sizeof(struct ip_header) + sizeof(struct tcp_header))
2495 || ip_len > (size - chain->n->guest_hdr_len -
2496 sizeof(struct eth_header))) {
2497 chain->stat.ip_hacked++;
2498 return RSC_BYPASS;
2499 }
2500
2501 return RSC_CANDIDATE;
2502 }
2503
virtio_net_rsc_receive4(VirtioNetRscChain * chain,NetClientState * nc,const uint8_t * buf,size_t size)2504 static size_t virtio_net_rsc_receive4(VirtioNetRscChain *chain,
2505 NetClientState *nc,
2506 const uint8_t *buf, size_t size)
2507 {
2508 int32_t ret;
2509 uint16_t hdr_len;
2510 VirtioNetRscUnit unit;
2511
2512 hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
2513
2514 if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header)
2515 + sizeof(struct tcp_header))) {
2516 chain->stat.bypass_not_tcp++;
2517 return virtio_net_do_receive(nc, buf, size);
2518 }
2519
2520 virtio_net_rsc_extract_unit4(chain, buf, &unit);
2521 if (virtio_net_rsc_sanity_check4(chain, unit.ip, buf, size)
2522 != RSC_CANDIDATE) {
2523 return virtio_net_do_receive(nc, buf, size);
2524 }
2525
2526 ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
2527 if (ret == RSC_BYPASS) {
2528 return virtio_net_do_receive(nc, buf, size);
2529 } else if (ret == RSC_FINAL) {
2530 return virtio_net_rsc_drain_flow(chain, nc, buf, size,
2531 ((hdr_len + sizeof(struct eth_header)) + 12),
2532 VIRTIO_NET_IP4_ADDR_SIZE,
2533 hdr_len + sizeof(struct eth_header) + sizeof(struct ip_header));
2534 }
2535
2536 return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
2537 }
2538
virtio_net_rsc_sanity_check6(VirtioNetRscChain * chain,struct ip6_header * ip6,const uint8_t * buf,size_t size)2539 static int32_t virtio_net_rsc_sanity_check6(VirtioNetRscChain *chain,
2540 struct ip6_header *ip6,
2541 const uint8_t *buf, size_t size)
2542 {
2543 uint16_t ip_len;
2544
2545 if (((ip6->ip6_ctlun.ip6_un1.ip6_un1_flow & 0xF0) >> 4)
2546 != IP_HEADER_VERSION_6) {
2547 return RSC_BYPASS;
2548 }
2549
2550 /* Both option and protocol is checked in this */
2551 if (ip6->ip6_ctlun.ip6_un1.ip6_un1_nxt != IPPROTO_TCP) {
2552 chain->stat.bypass_not_tcp++;
2553 return RSC_BYPASS;
2554 }
2555
2556 ip_len = htons(ip6->ip6_ctlun.ip6_un1.ip6_un1_plen);
2557 if (ip_len < sizeof(struct tcp_header) ||
2558 ip_len > (size - chain->n->guest_hdr_len - sizeof(struct eth_header)
2559 - sizeof(struct ip6_header))) {
2560 chain->stat.ip_hacked++;
2561 return RSC_BYPASS;
2562 }
2563
2564 /* Don't handle packets with ecn flag */
2565 if (IP6_ECN(ip6->ip6_ctlun.ip6_un3.ip6_un3_ecn)) {
2566 chain->stat.ip_ecn++;
2567 return RSC_BYPASS;
2568 }
2569
2570 return RSC_CANDIDATE;
2571 }
2572
virtio_net_rsc_receive6(void * opq,NetClientState * nc,const uint8_t * buf,size_t size)2573 static size_t virtio_net_rsc_receive6(void *opq, NetClientState *nc,
2574 const uint8_t *buf, size_t size)
2575 {
2576 int32_t ret;
2577 uint16_t hdr_len;
2578 VirtioNetRscChain *chain;
2579 VirtioNetRscUnit unit;
2580
2581 chain = opq;
2582 hdr_len = ((VirtIONet *)(chain->n))->guest_hdr_len;
2583
2584 if (size < (hdr_len + sizeof(struct eth_header) + sizeof(struct ip6_header)
2585 + sizeof(tcp_header))) {
2586 return virtio_net_do_receive(nc, buf, size);
2587 }
2588
2589 virtio_net_rsc_extract_unit6(chain, buf, &unit);
2590 if (RSC_CANDIDATE != virtio_net_rsc_sanity_check6(chain,
2591 unit.ip, buf, size)) {
2592 return virtio_net_do_receive(nc, buf, size);
2593 }
2594
2595 ret = virtio_net_rsc_tcp_ctrl_check(chain, unit.tcp);
2596 if (ret == RSC_BYPASS) {
2597 return virtio_net_do_receive(nc, buf, size);
2598 } else if (ret == RSC_FINAL) {
2599 return virtio_net_rsc_drain_flow(chain, nc, buf, size,
2600 ((hdr_len + sizeof(struct eth_header)) + 8),
2601 VIRTIO_NET_IP6_ADDR_SIZE,
2602 hdr_len + sizeof(struct eth_header)
2603 + sizeof(struct ip6_header));
2604 }
2605
2606 return virtio_net_rsc_do_coalesce(chain, nc, buf, size, &unit);
2607 }
2608
virtio_net_rsc_lookup_chain(VirtIONet * n,NetClientState * nc,uint16_t proto)2609 static VirtioNetRscChain *virtio_net_rsc_lookup_chain(VirtIONet *n,
2610 NetClientState *nc,
2611 uint16_t proto)
2612 {
2613 VirtioNetRscChain *chain;
2614
2615 if ((proto != (uint16_t)ETH_P_IP) && (proto != (uint16_t)ETH_P_IPV6)) {
2616 return NULL;
2617 }
2618
2619 QTAILQ_FOREACH(chain, &n->rsc_chains, next) {
2620 if (chain->proto == proto) {
2621 return chain;
2622 }
2623 }
2624
2625 chain = g_malloc(sizeof(*chain));
2626 chain->n = n;
2627 chain->proto = proto;
2628 if (proto == (uint16_t)ETH_P_IP) {
2629 chain->max_payload = VIRTIO_NET_MAX_IP4_PAYLOAD;
2630 chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
2631 } else {
2632 chain->max_payload = VIRTIO_NET_MAX_IP6_PAYLOAD;
2633 chain->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
2634 }
2635 chain->drain_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2636 virtio_net_rsc_purge, chain);
2637 memset(&chain->stat, 0, sizeof(chain->stat));
2638
2639 QTAILQ_INIT(&chain->buffers);
2640 QTAILQ_INSERT_TAIL(&n->rsc_chains, chain, next);
2641
2642 return chain;
2643 }
2644
virtio_net_rsc_receive(NetClientState * nc,const uint8_t * buf,size_t size)2645 static ssize_t virtio_net_rsc_receive(NetClientState *nc,
2646 const uint8_t *buf,
2647 size_t size)
2648 {
2649 uint16_t proto;
2650 VirtioNetRscChain *chain;
2651 struct eth_header *eth;
2652 VirtIONet *n;
2653
2654 n = qemu_get_nic_opaque(nc);
2655 if (size < (n->host_hdr_len + sizeof(struct eth_header))) {
2656 return virtio_net_do_receive(nc, buf, size);
2657 }
2658
2659 eth = (struct eth_header *)(buf + n->guest_hdr_len);
2660 proto = htons(eth->h_proto);
2661
2662 chain = virtio_net_rsc_lookup_chain(n, nc, proto);
2663 if (chain) {
2664 chain->stat.received++;
2665 if (proto == (uint16_t)ETH_P_IP && n->rsc4_enabled) {
2666 return virtio_net_rsc_receive4(chain, nc, buf, size);
2667 } else if (proto == (uint16_t)ETH_P_IPV6 && n->rsc6_enabled) {
2668 return virtio_net_rsc_receive6(chain, nc, buf, size);
2669 }
2670 }
2671 return virtio_net_do_receive(nc, buf, size);
2672 }
2673
virtio_net_receive(NetClientState * nc,const uint8_t * buf,size_t size)2674 static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf,
2675 size_t size)
2676 {
2677 VirtIONet *n = qemu_get_nic_opaque(nc);
2678 if ((n->rsc4_enabled || n->rsc6_enabled)) {
2679 return virtio_net_rsc_receive(nc, buf, size);
2680 } else {
2681 return virtio_net_do_receive(nc, buf, size);
2682 }
2683 }
2684
2685 static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
2686
virtio_net_tx_complete(NetClientState * nc,ssize_t len)2687 static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
2688 {
2689 VirtIONet *n = qemu_get_nic_opaque(nc);
2690 VirtIONetQueue *q = virtio_net_get_subqueue(nc);
2691 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2692 int ret;
2693
2694 virtqueue_push(q->tx_vq, q->async_tx.elem, 0);
2695 virtio_notify(vdev, q->tx_vq);
2696
2697 g_free(q->async_tx.elem);
2698 q->async_tx.elem = NULL;
2699
2700 virtio_queue_set_notification(q->tx_vq, 1);
2701 ret = virtio_net_flush_tx(q);
2702 if (ret >= n->tx_burst) {
2703 /*
2704 * the flush has been stopped by tx_burst
2705 * we will not receive notification for the
2706 * remainining part, so re-schedule
2707 */
2708 virtio_queue_set_notification(q->tx_vq, 0);
2709 if (q->tx_bh) {
2710 replay_bh_schedule_event(q->tx_bh);
2711 } else {
2712 timer_mod(q->tx_timer,
2713 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2714 }
2715 q->tx_waiting = 1;
2716 }
2717 }
2718
2719 /* TX */
virtio_net_flush_tx(VirtIONetQueue * q)2720 static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
2721 {
2722 VirtIONet *n = q->n;
2723 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2724 VirtQueueElement *elem;
2725 int32_t num_packets = 0;
2726 int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
2727 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2728 return num_packets;
2729 }
2730
2731 if (q->async_tx.elem) {
2732 virtio_queue_set_notification(q->tx_vq, 0);
2733 return num_packets;
2734 }
2735
2736 for (;;) {
2737 ssize_t ret;
2738 unsigned int out_num;
2739 struct iovec sg[VIRTQUEUE_MAX_SIZE], sg2[VIRTQUEUE_MAX_SIZE + 1], *out_sg;
2740 struct virtio_net_hdr vhdr;
2741
2742 elem = virtqueue_pop(q->tx_vq, sizeof(VirtQueueElement));
2743 if (!elem) {
2744 break;
2745 }
2746
2747 out_num = elem->out_num;
2748 out_sg = elem->out_sg;
2749 if (out_num < 1) {
2750 virtio_error(vdev, "virtio-net header not in first element");
2751 goto detach;
2752 }
2753
2754 if (n->needs_vnet_hdr_swap) {
2755 if (iov_to_buf(out_sg, out_num, 0, &vhdr, sizeof(vhdr)) <
2756 sizeof(vhdr)) {
2757 virtio_error(vdev, "virtio-net header incorrect");
2758 goto detach;
2759 }
2760 virtio_net_hdr_swap(vdev, &vhdr);
2761 sg2[0].iov_base = &vhdr;
2762 sg2[0].iov_len = sizeof(vhdr);
2763 out_num = iov_copy(&sg2[1], ARRAY_SIZE(sg2) - 1, out_sg, out_num,
2764 sizeof(vhdr), -1);
2765 if (out_num == VIRTQUEUE_MAX_SIZE) {
2766 goto drop;
2767 }
2768 out_num += 1;
2769 out_sg = sg2;
2770 }
2771 /*
2772 * If host wants to see the guest header as is, we can
2773 * pass it on unchanged. Otherwise, copy just the parts
2774 * that host is interested in.
2775 */
2776 assert(n->host_hdr_len <= n->guest_hdr_len);
2777 if (n->host_hdr_len != n->guest_hdr_len) {
2778 if (iov_size(out_sg, out_num) < n->guest_hdr_len) {
2779 virtio_error(vdev, "virtio-net header is invalid");
2780 goto detach;
2781 }
2782 unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
2783 out_sg, out_num,
2784 0, n->host_hdr_len);
2785 sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
2786 out_sg, out_num,
2787 n->guest_hdr_len, -1);
2788 out_num = sg_num;
2789 out_sg = sg;
2790
2791 if (out_num < 1) {
2792 virtio_error(vdev, "virtio-net nothing to send");
2793 goto detach;
2794 }
2795 }
2796
2797 ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
2798 out_sg, out_num, virtio_net_tx_complete);
2799 if (ret == 0) {
2800 virtio_queue_set_notification(q->tx_vq, 0);
2801 q->async_tx.elem = elem;
2802 return -EBUSY;
2803 }
2804
2805 drop:
2806 virtqueue_push(q->tx_vq, elem, 0);
2807 virtio_notify(vdev, q->tx_vq);
2808 g_free(elem);
2809
2810 if (++num_packets >= n->tx_burst) {
2811 break;
2812 }
2813 }
2814 return num_packets;
2815
2816 detach:
2817 virtqueue_detach_element(q->tx_vq, elem, 0);
2818 g_free(elem);
2819 return -EINVAL;
2820 }
2821
2822 static void virtio_net_tx_timer(void *opaque);
2823
virtio_net_handle_tx_timer(VirtIODevice * vdev,VirtQueue * vq)2824 static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
2825 {
2826 VirtIONet *n = VIRTIO_NET(vdev);
2827 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2828
2829 if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2830 virtio_net_drop_tx_queue_data(vdev, vq);
2831 return;
2832 }
2833
2834 /* This happens when device was stopped but VCPU wasn't. */
2835 if (!vdev->vm_running) {
2836 q->tx_waiting = 1;
2837 return;
2838 }
2839
2840 if (q->tx_waiting) {
2841 /* We already have queued packets, immediately flush */
2842 timer_del(q->tx_timer);
2843 virtio_net_tx_timer(q);
2844 } else {
2845 /* re-arm timer to flush it (and more) on next tick */
2846 timer_mod(q->tx_timer,
2847 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2848 q->tx_waiting = 1;
2849 virtio_queue_set_notification(vq, 0);
2850 }
2851 }
2852
virtio_net_handle_tx_bh(VirtIODevice * vdev,VirtQueue * vq)2853 static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
2854 {
2855 VirtIONet *n = VIRTIO_NET(vdev);
2856 VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
2857
2858 if (unlikely(n->vhost_started)) {
2859 return;
2860 }
2861
2862 if (unlikely((n->status & VIRTIO_NET_S_LINK_UP) == 0)) {
2863 virtio_net_drop_tx_queue_data(vdev, vq);
2864 return;
2865 }
2866
2867 if (unlikely(q->tx_waiting)) {
2868 return;
2869 }
2870 q->tx_waiting = 1;
2871 /* This happens when device was stopped but VCPU wasn't. */
2872 if (!vdev->vm_running) {
2873 return;
2874 }
2875 virtio_queue_set_notification(vq, 0);
2876 replay_bh_schedule_event(q->tx_bh);
2877 }
2878
virtio_net_tx_timer(void * opaque)2879 static void virtio_net_tx_timer(void *opaque)
2880 {
2881 VirtIONetQueue *q = opaque;
2882 VirtIONet *n = q->n;
2883 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2884 int ret;
2885
2886 /* This happens when device was stopped but BH wasn't. */
2887 if (!vdev->vm_running) {
2888 /* Make sure tx waiting is set, so we'll run when restarted. */
2889 assert(q->tx_waiting);
2890 return;
2891 }
2892
2893 q->tx_waiting = 0;
2894
2895 /* Just in case the driver is not ready on more */
2896 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
2897 return;
2898 }
2899
2900 ret = virtio_net_flush_tx(q);
2901 if (ret == -EBUSY || ret == -EINVAL) {
2902 return;
2903 }
2904 /*
2905 * If we flush a full burst of packets, assume there are
2906 * more coming and immediately rearm
2907 */
2908 if (ret >= n->tx_burst) {
2909 q->tx_waiting = 1;
2910 timer_mod(q->tx_timer,
2911 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2912 return;
2913 }
2914 /*
2915 * If less than a full burst, re-enable notification and flush
2916 * anything that may have come in while we weren't looking. If
2917 * we find something, assume the guest is still active and rearm
2918 */
2919 virtio_queue_set_notification(q->tx_vq, 1);
2920 ret = virtio_net_flush_tx(q);
2921 if (ret > 0) {
2922 virtio_queue_set_notification(q->tx_vq, 0);
2923 q->tx_waiting = 1;
2924 timer_mod(q->tx_timer,
2925 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
2926 }
2927 }
2928
virtio_net_tx_bh(void * opaque)2929 static void virtio_net_tx_bh(void *opaque)
2930 {
2931 VirtIONetQueue *q = opaque;
2932 VirtIONet *n = q->n;
2933 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2934 int32_t ret;
2935
2936 /* This happens when device was stopped but BH wasn't. */
2937 if (!vdev->vm_running) {
2938 /* Make sure tx waiting is set, so we'll run when restarted. */
2939 assert(q->tx_waiting);
2940 return;
2941 }
2942
2943 q->tx_waiting = 0;
2944
2945 /* Just in case the driver is not ready on more */
2946 if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
2947 return;
2948 }
2949
2950 ret = virtio_net_flush_tx(q);
2951 if (ret == -EBUSY || ret == -EINVAL) {
2952 return; /* Notification re-enable handled by tx_complete or device
2953 * broken */
2954 }
2955
2956 /* If we flush a full burst of packets, assume there are
2957 * more coming and immediately reschedule */
2958 if (ret >= n->tx_burst) {
2959 replay_bh_schedule_event(q->tx_bh);
2960 q->tx_waiting = 1;
2961 return;
2962 }
2963
2964 /* If less than a full burst, re-enable notification and flush
2965 * anything that may have come in while we weren't looking. If
2966 * we find something, assume the guest is still active and reschedule */
2967 virtio_queue_set_notification(q->tx_vq, 1);
2968 ret = virtio_net_flush_tx(q);
2969 if (ret == -EINVAL) {
2970 return;
2971 } else if (ret > 0) {
2972 virtio_queue_set_notification(q->tx_vq, 0);
2973 replay_bh_schedule_event(q->tx_bh);
2974 q->tx_waiting = 1;
2975 }
2976 }
2977
virtio_net_add_queue(VirtIONet * n,int index)2978 static void virtio_net_add_queue(VirtIONet *n, int index)
2979 {
2980 VirtIODevice *vdev = VIRTIO_DEVICE(n);
2981
2982 n->vqs[index].rx_vq = virtio_add_queue(vdev, n->net_conf.rx_queue_size,
2983 virtio_net_handle_rx);
2984
2985 if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
2986 n->vqs[index].tx_vq =
2987 virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2988 virtio_net_handle_tx_timer);
2989 n->vqs[index].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2990 virtio_net_tx_timer,
2991 &n->vqs[index]);
2992 } else {
2993 n->vqs[index].tx_vq =
2994 virtio_add_queue(vdev, n->net_conf.tx_queue_size,
2995 virtio_net_handle_tx_bh);
2996 n->vqs[index].tx_bh = qemu_bh_new_guarded(virtio_net_tx_bh, &n->vqs[index],
2997 &DEVICE(vdev)->mem_reentrancy_guard);
2998 }
2999
3000 n->vqs[index].tx_waiting = 0;
3001 n->vqs[index].n = n;
3002 }
3003
virtio_net_del_queue(VirtIONet * n,int index)3004 static void virtio_net_del_queue(VirtIONet *n, int index)
3005 {
3006 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3007 VirtIONetQueue *q = &n->vqs[index];
3008 NetClientState *nc = qemu_get_subqueue(n->nic, index);
3009
3010 qemu_purge_queued_packets(nc);
3011
3012 virtio_del_queue(vdev, index * 2);
3013 if (q->tx_timer) {
3014 timer_free(q->tx_timer);
3015 q->tx_timer = NULL;
3016 } else {
3017 qemu_bh_delete(q->tx_bh);
3018 q->tx_bh = NULL;
3019 }
3020 q->tx_waiting = 0;
3021 virtio_del_queue(vdev, index * 2 + 1);
3022 }
3023
virtio_net_change_num_queue_pairs(VirtIONet * n,int new_max_queue_pairs)3024 static void virtio_net_change_num_queue_pairs(VirtIONet *n, int new_max_queue_pairs)
3025 {
3026 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3027 int old_num_queues = virtio_get_num_queues(vdev);
3028 int new_num_queues = new_max_queue_pairs * 2 + 1;
3029 int i;
3030
3031 assert(old_num_queues >= 3);
3032 assert(old_num_queues % 2 == 1);
3033
3034 if (old_num_queues == new_num_queues) {
3035 return;
3036 }
3037
3038 /*
3039 * We always need to remove and add ctrl vq if
3040 * old_num_queues != new_num_queues. Remove ctrl_vq first,
3041 * and then we only enter one of the following two loops.
3042 */
3043 virtio_del_queue(vdev, old_num_queues - 1);
3044
3045 for (i = new_num_queues - 1; i < old_num_queues - 1; i += 2) {
3046 /* new_num_queues < old_num_queues */
3047 virtio_net_del_queue(n, i / 2);
3048 }
3049
3050 for (i = old_num_queues - 1; i < new_num_queues - 1; i += 2) {
3051 /* new_num_queues > old_num_queues */
3052 virtio_net_add_queue(n, i / 2);
3053 }
3054
3055 /* add ctrl_vq last */
3056 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
3057 }
3058
virtio_net_set_multiqueue(VirtIONet * n,int multiqueue)3059 static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
3060 {
3061 int max = multiqueue ? n->max_queue_pairs : 1;
3062
3063 n->multiqueue = multiqueue;
3064 virtio_net_change_num_queue_pairs(n, max);
3065
3066 virtio_net_set_queue_pairs(n);
3067 }
3068
virtio_net_pre_load_queues(VirtIODevice * vdev)3069 static int virtio_net_pre_load_queues(VirtIODevice *vdev)
3070 {
3071 virtio_net_set_multiqueue(VIRTIO_NET(vdev),
3072 virtio_has_feature(vdev->guest_features, VIRTIO_NET_F_RSS) ||
3073 virtio_has_feature(vdev->guest_features, VIRTIO_NET_F_MQ));
3074
3075 return 0;
3076 }
3077
virtio_net_post_load_device(void * opaque,int version_id)3078 static int virtio_net_post_load_device(void *opaque, int version_id)
3079 {
3080 VirtIONet *n = opaque;
3081 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3082 int i, link_down;
3083
3084 trace_virtio_net_post_load_device();
3085 virtio_net_set_mrg_rx_bufs(n, n->mergeable_rx_bufs,
3086 virtio_vdev_has_feature(vdev,
3087 VIRTIO_F_VERSION_1),
3088 virtio_vdev_has_feature(vdev,
3089 VIRTIO_NET_F_HASH_REPORT));
3090
3091 /* MAC_TABLE_ENTRIES may be different from the saved image */
3092 if (n->mac_table.in_use > MAC_TABLE_ENTRIES) {
3093 n->mac_table.in_use = 0;
3094 }
3095
3096 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)) {
3097 n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
3098 }
3099
3100 /*
3101 * curr_guest_offloads will be later overwritten by the
3102 * virtio_set_features_nocheck call done from the virtio_load.
3103 * Here we make sure it is preserved and restored accordingly
3104 * in the virtio_net_post_load_virtio callback.
3105 */
3106 n->saved_guest_offloads = n->curr_guest_offloads;
3107
3108 virtio_net_set_queue_pairs(n);
3109
3110 /* Find the first multicast entry in the saved MAC filter */
3111 for (i = 0; i < n->mac_table.in_use; i++) {
3112 if (n->mac_table.macs[i * ETH_ALEN] & 1) {
3113 break;
3114 }
3115 }
3116 n->mac_table.first_multi = i;
3117
3118 /* nc.link_down can't be migrated, so infer link_down according
3119 * to link status bit in n->status */
3120 link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
3121 for (i = 0; i < n->max_queue_pairs; i++) {
3122 qemu_get_subqueue(n->nic, i)->link_down = link_down;
3123 }
3124
3125 if (virtio_vdev_has_feature(vdev, VIRTIO_NET_F_GUEST_ANNOUNCE) &&
3126 virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
3127 qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
3128 QEMU_CLOCK_VIRTUAL,
3129 virtio_net_announce_timer, n);
3130 if (n->announce_timer.round) {
3131 timer_mod(n->announce_timer.tm,
3132 qemu_clock_get_ms(n->announce_timer.type));
3133 } else {
3134 qemu_announce_timer_del(&n->announce_timer, false);
3135 }
3136 }
3137
3138 virtio_net_commit_rss_config(n);
3139 return 0;
3140 }
3141
virtio_net_post_load_virtio(VirtIODevice * vdev)3142 static int virtio_net_post_load_virtio(VirtIODevice *vdev)
3143 {
3144 VirtIONet *n = VIRTIO_NET(vdev);
3145 /*
3146 * The actual needed state is now in saved_guest_offloads,
3147 * see virtio_net_post_load_device for detail.
3148 * Restore it back and apply the desired offloads.
3149 */
3150 n->curr_guest_offloads = n->saved_guest_offloads;
3151 if (peer_has_vnet_hdr(n)) {
3152 virtio_net_apply_guest_offloads(n);
3153 }
3154
3155 return 0;
3156 }
3157
3158 /* tx_waiting field of a VirtIONetQueue */
3159 static const VMStateDescription vmstate_virtio_net_queue_tx_waiting = {
3160 .name = "virtio-net-queue-tx_waiting",
3161 .fields = (const VMStateField[]) {
3162 VMSTATE_UINT32(tx_waiting, VirtIONetQueue),
3163 VMSTATE_END_OF_LIST()
3164 },
3165 };
3166
max_queue_pairs_gt_1(void * opaque,int version_id)3167 static bool max_queue_pairs_gt_1(void *opaque, int version_id)
3168 {
3169 return VIRTIO_NET(opaque)->max_queue_pairs > 1;
3170 }
3171
has_ctrl_guest_offloads(void * opaque,int version_id)3172 static bool has_ctrl_guest_offloads(void *opaque, int version_id)
3173 {
3174 return virtio_vdev_has_feature(VIRTIO_DEVICE(opaque),
3175 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS);
3176 }
3177
mac_table_fits(void * opaque,int version_id)3178 static bool mac_table_fits(void *opaque, int version_id)
3179 {
3180 return VIRTIO_NET(opaque)->mac_table.in_use <= MAC_TABLE_ENTRIES;
3181 }
3182
mac_table_doesnt_fit(void * opaque,int version_id)3183 static bool mac_table_doesnt_fit(void *opaque, int version_id)
3184 {
3185 return !mac_table_fits(opaque, version_id);
3186 }
3187
3188 /* This temporary type is shared by all the WITH_TMP methods
3189 * although only some fields are used by each.
3190 */
3191 struct VirtIONetMigTmp {
3192 VirtIONet *parent;
3193 VirtIONetQueue *vqs_1;
3194 uint16_t curr_queue_pairs_1;
3195 uint8_t has_ufo;
3196 uint32_t has_vnet_hdr;
3197 };
3198
3199 /* The 2nd and subsequent tx_waiting flags are loaded later than
3200 * the 1st entry in the queue_pairs and only if there's more than one
3201 * entry. We use the tmp mechanism to calculate a temporary
3202 * pointer and count and also validate the count.
3203 */
3204
virtio_net_tx_waiting_pre_save(void * opaque)3205 static int virtio_net_tx_waiting_pre_save(void *opaque)
3206 {
3207 struct VirtIONetMigTmp *tmp = opaque;
3208
3209 tmp->vqs_1 = tmp->parent->vqs + 1;
3210 tmp->curr_queue_pairs_1 = tmp->parent->curr_queue_pairs - 1;
3211 if (tmp->parent->curr_queue_pairs == 0) {
3212 tmp->curr_queue_pairs_1 = 0;
3213 }
3214
3215 return 0;
3216 }
3217
virtio_net_tx_waiting_pre_load(void * opaque)3218 static int virtio_net_tx_waiting_pre_load(void *opaque)
3219 {
3220 struct VirtIONetMigTmp *tmp = opaque;
3221
3222 /* Reuse the pointer setup from save */
3223 virtio_net_tx_waiting_pre_save(opaque);
3224
3225 if (tmp->parent->curr_queue_pairs > tmp->parent->max_queue_pairs) {
3226 error_report("virtio-net: curr_queue_pairs %x > max_queue_pairs %x",
3227 tmp->parent->curr_queue_pairs, tmp->parent->max_queue_pairs);
3228
3229 return -EINVAL;
3230 }
3231
3232 return 0; /* all good */
3233 }
3234
3235 static const VMStateDescription vmstate_virtio_net_tx_waiting = {
3236 .name = "virtio-net-tx_waiting",
3237 .pre_load = virtio_net_tx_waiting_pre_load,
3238 .pre_save = virtio_net_tx_waiting_pre_save,
3239 .fields = (const VMStateField[]) {
3240 VMSTATE_STRUCT_VARRAY_POINTER_UINT16(vqs_1, struct VirtIONetMigTmp,
3241 curr_queue_pairs_1,
3242 vmstate_virtio_net_queue_tx_waiting,
3243 struct VirtIONetQueue),
3244 VMSTATE_END_OF_LIST()
3245 },
3246 };
3247
3248 /* the 'has_ufo' flag is just tested; if the incoming stream has the
3249 * flag set we need to check that we have it
3250 */
virtio_net_ufo_post_load(void * opaque,int version_id)3251 static int virtio_net_ufo_post_load(void *opaque, int version_id)
3252 {
3253 struct VirtIONetMigTmp *tmp = opaque;
3254
3255 if (tmp->has_ufo && !peer_has_ufo(tmp->parent)) {
3256 error_report("virtio-net: saved image requires TUN_F_UFO support");
3257 return -EINVAL;
3258 }
3259
3260 return 0;
3261 }
3262
virtio_net_ufo_pre_save(void * opaque)3263 static int virtio_net_ufo_pre_save(void *opaque)
3264 {
3265 struct VirtIONetMigTmp *tmp = opaque;
3266
3267 tmp->has_ufo = tmp->parent->has_ufo;
3268
3269 return 0;
3270 }
3271
3272 static const VMStateDescription vmstate_virtio_net_has_ufo = {
3273 .name = "virtio-net-ufo",
3274 .post_load = virtio_net_ufo_post_load,
3275 .pre_save = virtio_net_ufo_pre_save,
3276 .fields = (const VMStateField[]) {
3277 VMSTATE_UINT8(has_ufo, struct VirtIONetMigTmp),
3278 VMSTATE_END_OF_LIST()
3279 },
3280 };
3281
3282 /* the 'has_vnet_hdr' flag is just tested; if the incoming stream has the
3283 * flag set we need to check that we have it
3284 */
virtio_net_vnet_post_load(void * opaque,int version_id)3285 static int virtio_net_vnet_post_load(void *opaque, int version_id)
3286 {
3287 struct VirtIONetMigTmp *tmp = opaque;
3288
3289 if (tmp->has_vnet_hdr && !peer_has_vnet_hdr(tmp->parent)) {
3290 error_report("virtio-net: saved image requires vnet_hdr=on");
3291 return -EINVAL;
3292 }
3293
3294 return 0;
3295 }
3296
virtio_net_vnet_pre_save(void * opaque)3297 static int virtio_net_vnet_pre_save(void *opaque)
3298 {
3299 struct VirtIONetMigTmp *tmp = opaque;
3300
3301 tmp->has_vnet_hdr = tmp->parent->has_vnet_hdr;
3302
3303 return 0;
3304 }
3305
3306 static const VMStateDescription vmstate_virtio_net_has_vnet = {
3307 .name = "virtio-net-vnet",
3308 .post_load = virtio_net_vnet_post_load,
3309 .pre_save = virtio_net_vnet_pre_save,
3310 .fields = (const VMStateField[]) {
3311 VMSTATE_UINT32(has_vnet_hdr, struct VirtIONetMigTmp),
3312 VMSTATE_END_OF_LIST()
3313 },
3314 };
3315
virtio_net_rss_needed(void * opaque)3316 static bool virtio_net_rss_needed(void *opaque)
3317 {
3318 return VIRTIO_NET(opaque)->rss_data.enabled;
3319 }
3320
3321 static const VMStateDescription vmstate_virtio_net_rss = {
3322 .name = "virtio-net-device/rss",
3323 .version_id = 1,
3324 .minimum_version_id = 1,
3325 .needed = virtio_net_rss_needed,
3326 .fields = (const VMStateField[]) {
3327 VMSTATE_BOOL(rss_data.enabled, VirtIONet),
3328 VMSTATE_BOOL(rss_data.redirect, VirtIONet),
3329 VMSTATE_BOOL(rss_data.populate_hash, VirtIONet),
3330 VMSTATE_UINT32(rss_data.hash_types, VirtIONet),
3331 VMSTATE_UINT16(rss_data.indirections_len, VirtIONet),
3332 VMSTATE_UINT16(rss_data.default_queue, VirtIONet),
3333 VMSTATE_UINT8_ARRAY(rss_data.key, VirtIONet,
3334 VIRTIO_NET_RSS_MAX_KEY_SIZE),
3335 VMSTATE_VARRAY_UINT16_ALLOC(rss_data.indirections_table, VirtIONet,
3336 rss_data.indirections_len, 0,
3337 vmstate_info_uint16, uint16_t),
3338 VMSTATE_END_OF_LIST()
3339 },
3340 };
3341
virtio_net_get_vhost(VirtIODevice * vdev)3342 static struct vhost_dev *virtio_net_get_vhost(VirtIODevice *vdev)
3343 {
3344 VirtIONet *n = VIRTIO_NET(vdev);
3345 NetClientState *nc;
3346 struct vhost_net *net;
3347
3348 if (!n->nic) {
3349 return NULL;
3350 }
3351
3352 nc = qemu_get_queue(n->nic);
3353 if (!nc) {
3354 return NULL;
3355 }
3356
3357 net = get_vhost_net(nc->peer);
3358 if (!net) {
3359 return NULL;
3360 }
3361
3362 return &net->dev;
3363 }
3364
vhost_user_net_save_state(QEMUFile * f,void * pv,size_t size,const VMStateField * field,JSONWriter * vmdesc)3365 static int vhost_user_net_save_state(QEMUFile *f, void *pv, size_t size,
3366 const VMStateField *field,
3367 JSONWriter *vmdesc)
3368 {
3369 VirtIONet *n = pv;
3370 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3371 struct vhost_dev *vhdev;
3372 Error *local_error = NULL;
3373 int ret;
3374
3375 vhdev = virtio_net_get_vhost(vdev);
3376 if (vhdev == NULL) {
3377 error_reportf_err(local_error,
3378 "Error getting vhost back-end of %s device %s: ",
3379 vdev->name, vdev->parent_obj.canonical_path);
3380 return -1;
3381 }
3382
3383 ret = vhost_save_backend_state(vhdev, f, &local_error);
3384 if (ret < 0) {
3385 error_reportf_err(local_error,
3386 "Error saving back-end state of %s device %s: ",
3387 vdev->name, vdev->parent_obj.canonical_path);
3388 return ret;
3389 }
3390
3391 return 0;
3392 }
3393
vhost_user_net_load_state(QEMUFile * f,void * pv,size_t size,const VMStateField * field)3394 static int vhost_user_net_load_state(QEMUFile *f, void *pv, size_t size,
3395 const VMStateField *field)
3396 {
3397 VirtIONet *n = pv;
3398 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3399 struct vhost_dev *vhdev;
3400 Error *local_error = NULL;
3401 int ret;
3402
3403 vhdev = virtio_net_get_vhost(vdev);
3404 if (vhdev == NULL) {
3405 error_reportf_err(local_error,
3406 "Error getting vhost back-end of %s device %s: ",
3407 vdev->name, vdev->parent_obj.canonical_path);
3408 return -1;
3409 }
3410
3411 ret = vhost_load_backend_state(vhdev, f, &local_error);
3412 if (ret < 0) {
3413 error_reportf_err(local_error,
3414 "Error loading back-end state of %s device %s: ",
3415 vdev->name, vdev->parent_obj.canonical_path);
3416 return ret;
3417 }
3418
3419 return 0;
3420 }
3421
vhost_user_net_is_internal_migration(void * opaque)3422 static bool vhost_user_net_is_internal_migration(void *opaque)
3423 {
3424 VirtIONet *n = opaque;
3425 VirtIODevice *vdev = VIRTIO_DEVICE(n);
3426 struct vhost_dev *vhdev;
3427
3428 vhdev = virtio_net_get_vhost(vdev);
3429 if (vhdev == NULL) {
3430 return false;
3431 }
3432
3433 return vhost_supports_device_state(vhdev);
3434 }
3435
3436 static const VMStateDescription vhost_user_net_backend_state = {
3437 .name = "virtio-net-device/backend",
3438 .version_id = 0,
3439 .needed = vhost_user_net_is_internal_migration,
3440 .fields = (const VMStateField[]) {
3441 {
3442 .name = "backend",
3443 .info = &(const VMStateInfo) {
3444 .name = "virtio-net vhost-user backend state",
3445 .get = vhost_user_net_load_state,
3446 .put = vhost_user_net_save_state,
3447 },
3448 },
3449 VMSTATE_END_OF_LIST()
3450 }
3451 };
3452
3453 static const VMStateDescription vmstate_virtio_net_device = {
3454 .name = "virtio-net-device",
3455 .version_id = VIRTIO_NET_VM_VERSION,
3456 .minimum_version_id = VIRTIO_NET_VM_VERSION,
3457 .post_load = virtio_net_post_load_device,
3458 .fields = (const VMStateField[]) {
3459 VMSTATE_UINT8_ARRAY(mac, VirtIONet, ETH_ALEN),
3460 VMSTATE_STRUCT_POINTER(vqs, VirtIONet,
3461 vmstate_virtio_net_queue_tx_waiting,
3462 VirtIONetQueue),
3463 VMSTATE_UINT32(mergeable_rx_bufs, VirtIONet),
3464 VMSTATE_UINT16(status, VirtIONet),
3465 VMSTATE_UINT8(promisc, VirtIONet),
3466 VMSTATE_UINT8(allmulti, VirtIONet),
3467 VMSTATE_UINT32(mac_table.in_use, VirtIONet),
3468
3469 /* Guarded pair: If it fits we load it, else we throw it away
3470 * - can happen if source has a larger MAC table.; post-load
3471 * sets flags in this case.
3472 */
3473 VMSTATE_VBUFFER_MULTIPLY(mac_table.macs, VirtIONet,
3474 0, mac_table_fits, mac_table.in_use,
3475 ETH_ALEN),
3476 VMSTATE_UNUSED_VARRAY_UINT32(VirtIONet, mac_table_doesnt_fit, 0,
3477 mac_table.in_use, ETH_ALEN),
3478
3479 /* Note: This is an array of uint32's that's always been saved as a
3480 * buffer; hold onto your endiannesses; it's actually used as a bitmap
3481 * but based on the uint.
3482 */
3483 VMSTATE_BUFFER_POINTER_UNSAFE(vlans, VirtIONet, 0, MAX_VLAN >> 3),
3484 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
3485 vmstate_virtio_net_has_vnet),
3486 VMSTATE_UINT8(mac_table.multi_overflow, VirtIONet),
3487 VMSTATE_UINT8(mac_table.uni_overflow, VirtIONet),
3488 VMSTATE_UINT8(alluni, VirtIONet),
3489 VMSTATE_UINT8(nomulti, VirtIONet),
3490 VMSTATE_UINT8(nouni, VirtIONet),
3491 VMSTATE_UINT8(nobcast, VirtIONet),
3492 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
3493 vmstate_virtio_net_has_ufo),
3494 VMSTATE_SINGLE_TEST(max_queue_pairs, VirtIONet, max_queue_pairs_gt_1, 0,
3495 vmstate_info_uint16_equal, uint16_t),
3496 VMSTATE_UINT16_TEST(curr_queue_pairs, VirtIONet, max_queue_pairs_gt_1),
3497 VMSTATE_WITH_TMP(VirtIONet, struct VirtIONetMigTmp,
3498 vmstate_virtio_net_tx_waiting),
3499 VMSTATE_UINT64_TEST(curr_guest_offloads, VirtIONet,
3500 has_ctrl_guest_offloads),
3501 VMSTATE_END_OF_LIST()
3502 },
3503 .subsections = (const VMStateDescription * const []) {
3504 &vmstate_virtio_net_rss,
3505 &vhost_user_net_backend_state,
3506 NULL
3507 }
3508 };
3509
3510 static NetClientInfo net_virtio_info = {
3511 .type = NET_CLIENT_DRIVER_NIC,
3512 .size = sizeof(NICState),
3513 .can_receive = virtio_net_can_receive,
3514 .receive = virtio_net_receive,
3515 .link_status_changed = virtio_net_set_link_status,
3516 .query_rx_filter = virtio_net_query_rxfilter,
3517 .announce = virtio_net_announce,
3518 };
3519
virtio_net_guest_notifier_pending(VirtIODevice * vdev,int idx)3520 static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
3521 {
3522 VirtIONet *n = VIRTIO_NET(vdev);
3523 NetClientState *nc;
3524 assert(n->vhost_started);
3525 if (!n->multiqueue && idx == 2) {
3526 /* Must guard against invalid features and bogus queue index
3527 * from being set by malicious guest, or penetrated through
3528 * buggy migration stream.
3529 */
3530 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
3531 qemu_log_mask(LOG_GUEST_ERROR,
3532 "%s: bogus vq index ignored\n", __func__);
3533 return false;
3534 }
3535 nc = qemu_get_subqueue(n->nic, n->max_queue_pairs);
3536 } else {
3537 nc = qemu_get_subqueue(n->nic, vq2q(idx));
3538 }
3539 /*
3540 * Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
3541 * as the macro of configure interrupt's IDX, If this driver does not
3542 * support, the function will return false
3543 */
3544
3545 if (idx == VIRTIO_CONFIG_IRQ_IDX) {
3546 return vhost_net_config_pending(get_vhost_net(nc->peer));
3547 }
3548 return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
3549 }
3550
virtio_net_guest_notifier_mask(VirtIODevice * vdev,int idx,bool mask)3551 static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
3552 bool mask)
3553 {
3554 VirtIONet *n = VIRTIO_NET(vdev);
3555 NetClientState *nc;
3556 assert(n->vhost_started);
3557 if (!n->multiqueue && idx == 2) {
3558 /* Must guard against invalid features and bogus queue index
3559 * from being set by malicious guest, or penetrated through
3560 * buggy migration stream.
3561 */
3562 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ)) {
3563 qemu_log_mask(LOG_GUEST_ERROR,
3564 "%s: bogus vq index ignored\n", __func__);
3565 return;
3566 }
3567 nc = qemu_get_subqueue(n->nic, n->max_queue_pairs);
3568 } else {
3569 nc = qemu_get_subqueue(n->nic, vq2q(idx));
3570 }
3571 /*
3572 *Add the check for configure interrupt, Use VIRTIO_CONFIG_IRQ_IDX -1
3573 * as the macro of configure interrupt's IDX, If this driver does not
3574 * support, the function will return
3575 */
3576
3577 if (idx == VIRTIO_CONFIG_IRQ_IDX) {
3578 vhost_net_config_mask(get_vhost_net(nc->peer), vdev, mask);
3579 return;
3580 }
3581 vhost_net_virtqueue_mask(get_vhost_net(nc->peer), vdev, idx, mask);
3582 }
3583
virtio_net_set_config_size(VirtIONet * n,uint64_t host_features)3584 static void virtio_net_set_config_size(VirtIONet *n, uint64_t host_features)
3585 {
3586 virtio_add_feature(&host_features, VIRTIO_NET_F_MAC);
3587
3588 n->config_size = virtio_get_config_size(&cfg_size_params, host_features);
3589 }
3590
virtio_net_set_netclient_name(VirtIONet * n,const char * name,const char * type)3591 void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
3592 const char *type)
3593 {
3594 /*
3595 * The name can be NULL, the netclient name will be type.x.
3596 */
3597 assert(type != NULL);
3598
3599 g_free(n->netclient_name);
3600 g_free(n->netclient_type);
3601 n->netclient_name = g_strdup(name);
3602 n->netclient_type = g_strdup(type);
3603 }
3604
failover_unplug_primary(VirtIONet * n,DeviceState * dev)3605 static bool failover_unplug_primary(VirtIONet *n, DeviceState *dev)
3606 {
3607 HotplugHandler *hotplug_ctrl;
3608 PCIDevice *pci_dev;
3609 Error *err = NULL;
3610
3611 hotplug_ctrl = qdev_get_hotplug_handler(dev);
3612 if (hotplug_ctrl) {
3613 pci_dev = PCI_DEVICE(dev);
3614 pci_dev->partially_hotplugged = true;
3615 hotplug_handler_unplug_request(hotplug_ctrl, dev, &err);
3616 if (err) {
3617 error_report_err(err);
3618 return false;
3619 }
3620 } else {
3621 return false;
3622 }
3623 return true;
3624 }
3625
failover_replug_primary(VirtIONet * n,DeviceState * dev,Error ** errp)3626 static bool failover_replug_primary(VirtIONet *n, DeviceState *dev,
3627 Error **errp)
3628 {
3629 Error *err = NULL;
3630 HotplugHandler *hotplug_ctrl;
3631 PCIDevice *pdev = PCI_DEVICE(dev);
3632 BusState *primary_bus;
3633
3634 if (!pdev->partially_hotplugged) {
3635 return true;
3636 }
3637 primary_bus = dev->parent_bus;
3638 if (!primary_bus) {
3639 error_setg(errp, "virtio_net: couldn't find primary bus");
3640 return false;
3641 }
3642 qdev_set_parent_bus(dev, primary_bus, &error_abort);
3643 qatomic_set(&n->failover_primary_hidden, false);
3644 hotplug_ctrl = qdev_get_hotplug_handler(dev);
3645 if (hotplug_ctrl) {
3646 hotplug_handler_pre_plug(hotplug_ctrl, dev, &err);
3647 if (err) {
3648 goto out;
3649 }
3650 hotplug_handler_plug(hotplug_ctrl, dev, &err);
3651 }
3652 pdev->partially_hotplugged = false;
3653
3654 out:
3655 error_propagate(errp, err);
3656 return !err;
3657 }
3658
virtio_net_handle_migration_primary(VirtIONet * n,MigrationEvent * e)3659 static void virtio_net_handle_migration_primary(VirtIONet *n, MigrationEvent *e)
3660 {
3661 bool should_be_hidden;
3662 Error *err = NULL;
3663 DeviceState *dev = failover_find_primary_device(n);
3664
3665 if (!dev) {
3666 return;
3667 }
3668
3669 should_be_hidden = qatomic_read(&n->failover_primary_hidden);
3670
3671 if (e->type == MIG_EVENT_PRECOPY_SETUP && !should_be_hidden) {
3672 if (failover_unplug_primary(n, dev)) {
3673 vmstate_unregister(VMSTATE_IF(dev), qdev_get_vmsd(dev), dev);
3674 qapi_event_send_unplug_primary(dev->id);
3675 qatomic_set(&n->failover_primary_hidden, true);
3676 } else {
3677 warn_report("couldn't unplug primary device");
3678 }
3679 } else if (e->type == MIG_EVENT_PRECOPY_FAILED) {
3680 /* We already unplugged the device let's plug it back */
3681 if (!failover_replug_primary(n, dev, &err)) {
3682 if (err) {
3683 error_report_err(err);
3684 }
3685 }
3686 }
3687 }
3688
virtio_net_migration_state_notifier(NotifierWithReturn * notifier,MigrationEvent * e,Error ** errp)3689 static int virtio_net_migration_state_notifier(NotifierWithReturn *notifier,
3690 MigrationEvent *e, Error **errp)
3691 {
3692 VirtIONet *n = container_of(notifier, VirtIONet, migration_state);
3693 virtio_net_handle_migration_primary(n, e);
3694 return 0;
3695 }
3696
failover_hide_primary_device(DeviceListener * listener,const QDict * device_opts,bool from_json,Error ** errp)3697 static bool failover_hide_primary_device(DeviceListener *listener,
3698 const QDict *device_opts,
3699 bool from_json,
3700 Error **errp)
3701 {
3702 VirtIONet *n = container_of(listener, VirtIONet, primary_listener);
3703 const char *standby_id;
3704
3705 if (!device_opts) {
3706 return false;
3707 }
3708
3709 if (!qdict_haskey(device_opts, "failover_pair_id")) {
3710 return false;
3711 }
3712
3713 if (!qdict_haskey(device_opts, "id")) {
3714 error_setg(errp, "Device with failover_pair_id needs to have id");
3715 return false;
3716 }
3717
3718 standby_id = qdict_get_str(device_opts, "failover_pair_id");
3719 if (g_strcmp0(standby_id, n->netclient_name) != 0) {
3720 return false;
3721 }
3722
3723 /*
3724 * The hide helper can be called several times for a given device.
3725 * Check there is only one primary for a virtio-net device but
3726 * don't duplicate the qdict several times if it's called for the same
3727 * device.
3728 */
3729 if (n->primary_opts) {
3730 const char *old, *new;
3731 /* devices with failover_pair_id always have an id */
3732 old = qdict_get_str(n->primary_opts, "id");
3733 new = qdict_get_str(device_opts, "id");
3734 if (strcmp(old, new) != 0) {
3735 error_setg(errp, "Cannot attach more than one primary device to "
3736 "'%s': '%s' and '%s'", n->netclient_name, old, new);
3737 return false;
3738 }
3739 } else {
3740 n->primary_opts = qdict_clone_shallow(device_opts);
3741 n->primary_opts_from_json = from_json;
3742 }
3743
3744 /* failover_primary_hidden is set during feature negotiation */
3745 return qatomic_read(&n->failover_primary_hidden);
3746 }
3747
virtio_net_device_realize(DeviceState * dev,Error ** errp)3748 static void virtio_net_device_realize(DeviceState *dev, Error **errp)
3749 {
3750 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
3751 VirtIONet *n = VIRTIO_NET(dev);
3752 NetClientState *nc;
3753 int i;
3754
3755 if (n->net_conf.mtu) {
3756 n->host_features |= (1ULL << VIRTIO_NET_F_MTU);
3757 }
3758
3759 if (n->net_conf.duplex_str) {
3760 if (strncmp(n->net_conf.duplex_str, "half", 5) == 0) {
3761 n->net_conf.duplex = DUPLEX_HALF;
3762 } else if (strncmp(n->net_conf.duplex_str, "full", 5) == 0) {
3763 n->net_conf.duplex = DUPLEX_FULL;
3764 } else {
3765 error_setg(errp, "'duplex' must be 'half' or 'full'");
3766 return;
3767 }
3768 n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
3769 } else {
3770 n->net_conf.duplex = DUPLEX_UNKNOWN;
3771 }
3772
3773 if (n->net_conf.speed < SPEED_UNKNOWN) {
3774 error_setg(errp, "'speed' must be between 0 and INT_MAX");
3775 return;
3776 }
3777 if (n->net_conf.speed >= 0) {
3778 n->host_features |= (1ULL << VIRTIO_NET_F_SPEED_DUPLEX);
3779 }
3780
3781 if (n->failover) {
3782 n->primary_listener.hide_device = failover_hide_primary_device;
3783 qatomic_set(&n->failover_primary_hidden, true);
3784 device_listener_register(&n->primary_listener);
3785 migration_add_notifier(&n->migration_state,
3786 virtio_net_migration_state_notifier);
3787 n->host_features |= (1ULL << VIRTIO_NET_F_STANDBY);
3788 }
3789
3790 virtio_net_set_config_size(n, n->host_features);
3791 virtio_init(vdev, VIRTIO_ID_NET, n->config_size);
3792
3793 /*
3794 * We set a lower limit on RX queue size to what it always was.
3795 * Guests that want a smaller ring can always resize it without
3796 * help from us (using virtio 1 and up).
3797 */
3798 if (n->net_conf.rx_queue_size < VIRTIO_NET_RX_QUEUE_MIN_SIZE ||
3799 n->net_conf.rx_queue_size > VIRTQUEUE_MAX_SIZE ||
3800 !is_power_of_2(n->net_conf.rx_queue_size)) {
3801 error_setg(errp, "Invalid rx_queue_size (= %" PRIu16 "), "
3802 "must be a power of 2 between %d and %d.",
3803 n->net_conf.rx_queue_size, VIRTIO_NET_RX_QUEUE_MIN_SIZE,
3804 VIRTQUEUE_MAX_SIZE);
3805 virtio_cleanup(vdev);
3806 return;
3807 }
3808
3809 if (n->net_conf.tx_queue_size < VIRTIO_NET_TX_QUEUE_MIN_SIZE ||
3810 n->net_conf.tx_queue_size > virtio_net_max_tx_queue_size(n) ||
3811 !is_power_of_2(n->net_conf.tx_queue_size)) {
3812 error_setg(errp, "Invalid tx_queue_size (= %" PRIu16 "), "
3813 "must be a power of 2 between %d and %d",
3814 n->net_conf.tx_queue_size, VIRTIO_NET_TX_QUEUE_MIN_SIZE,
3815 virtio_net_max_tx_queue_size(n));
3816 virtio_cleanup(vdev);
3817 return;
3818 }
3819
3820 n->max_ncs = MAX(n->nic_conf.peers.queues, 1);
3821
3822 /*
3823 * Figure out the datapath queue pairs since the backend could
3824 * provide control queue via peers as well.
3825 */
3826 if (n->nic_conf.peers.queues) {
3827 for (i = 0; i < n->max_ncs; i++) {
3828 if (n->nic_conf.peers.ncs[i]->is_datapath) {
3829 ++n->max_queue_pairs;
3830 }
3831 }
3832 }
3833 n->max_queue_pairs = MAX(n->max_queue_pairs, 1);
3834
3835 if (n->max_queue_pairs * 2 + 1 > VIRTIO_QUEUE_MAX) {
3836 error_setg(errp, "Invalid number of queue pairs (= %" PRIu32 "), "
3837 "must be a positive integer less than %d.",
3838 n->max_queue_pairs, (VIRTIO_QUEUE_MAX - 1) / 2);
3839 virtio_cleanup(vdev);
3840 return;
3841 }
3842 n->vqs = g_new0(VirtIONetQueue, n->max_queue_pairs);
3843 n->curr_queue_pairs = 1;
3844 n->tx_timeout = n->net_conf.txtimer;
3845
3846 if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
3847 && strcmp(n->net_conf.tx, "bh")) {
3848 warn_report("virtio-net: "
3849 "Unknown option tx=%s, valid options: \"timer\" \"bh\"",
3850 n->net_conf.tx);
3851 error_printf("Defaulting to \"bh\"");
3852 }
3853
3854 n->net_conf.tx_queue_size = MIN(virtio_net_max_tx_queue_size(n),
3855 n->net_conf.tx_queue_size);
3856
3857 virtio_net_add_queue(n, 0);
3858
3859 n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
3860 qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
3861 memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
3862 n->status = VIRTIO_NET_S_LINK_UP;
3863 qemu_announce_timer_reset(&n->announce_timer, migrate_announce_params(),
3864 QEMU_CLOCK_VIRTUAL,
3865 virtio_net_announce_timer, n);
3866 n->announce_timer.round = 0;
3867
3868 if (n->netclient_type) {
3869 /*
3870 * Happen when virtio_net_set_netclient_name has been called.
3871 */
3872 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
3873 n->netclient_type, n->netclient_name,
3874 &dev->mem_reentrancy_guard, n);
3875 } else {
3876 n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
3877 object_get_typename(OBJECT(dev)), dev->id,
3878 &dev->mem_reentrancy_guard, n);
3879 }
3880
3881 for (i = 0; i < n->max_queue_pairs; i++) {
3882 n->nic->ncs[i].do_not_pad = true;
3883 }
3884
3885 peer_test_vnet_hdr(n);
3886 if (peer_has_vnet_hdr(n)) {
3887 n->host_hdr_len = sizeof(struct virtio_net_hdr);
3888 } else {
3889 n->host_hdr_len = 0;
3890 }
3891
3892 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
3893
3894 n->vqs[0].tx_waiting = 0;
3895 n->tx_burst = n->net_conf.txburst;
3896 virtio_net_set_mrg_rx_bufs(n, 0, 0, 0);
3897 n->promisc = 1; /* for compatibility */
3898
3899 n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
3900
3901 n->vlans = g_malloc0(MAX_VLAN >> 3);
3902
3903 nc = qemu_get_queue(n->nic);
3904 nc->rxfilter_notify_enabled = 1;
3905
3906 if (nc->peer && nc->peer->info->type == NET_CLIENT_DRIVER_VHOST_VDPA) {
3907 struct virtio_net_config netcfg = {};
3908 memcpy(&netcfg.mac, &n->nic_conf.macaddr, ETH_ALEN);
3909 vhost_net_set_config(get_vhost_net(nc->peer),
3910 (uint8_t *)&netcfg, 0, ETH_ALEN, VHOST_SET_CONFIG_TYPE_FRONTEND);
3911 }
3912 QTAILQ_INIT(&n->rsc_chains);
3913 n->qdev = dev;
3914
3915 net_rx_pkt_init(&n->rx_pkt);
3916
3917 if (virtio_has_feature(n->host_features, VIRTIO_NET_F_RSS)) {
3918 virtio_net_load_ebpf(n, errp);
3919 }
3920 }
3921
virtio_net_device_unrealize(DeviceState * dev)3922 static void virtio_net_device_unrealize(DeviceState *dev)
3923 {
3924 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
3925 VirtIONet *n = VIRTIO_NET(dev);
3926 int i, max_queue_pairs;
3927
3928 if (virtio_has_feature(n->host_features, VIRTIO_NET_F_RSS)) {
3929 virtio_net_unload_ebpf(n);
3930 }
3931
3932 /* This will stop vhost backend if appropriate. */
3933 virtio_net_set_status(vdev, 0);
3934
3935 g_free(n->netclient_name);
3936 n->netclient_name = NULL;
3937 g_free(n->netclient_type);
3938 n->netclient_type = NULL;
3939
3940 g_free(n->mac_table.macs);
3941 g_free(n->vlans);
3942
3943 if (n->failover) {
3944 qobject_unref(n->primary_opts);
3945 device_listener_unregister(&n->primary_listener);
3946 migration_remove_notifier(&n->migration_state);
3947 } else {
3948 assert(n->primary_opts == NULL);
3949 }
3950
3951 max_queue_pairs = n->multiqueue ? n->max_queue_pairs : 1;
3952 for (i = 0; i < max_queue_pairs; i++) {
3953 virtio_net_del_queue(n, i);
3954 }
3955 /* delete also control vq */
3956 virtio_del_queue(vdev, max_queue_pairs * 2);
3957 qemu_announce_timer_del(&n->announce_timer, false);
3958 g_free(n->vqs);
3959 qemu_del_nic(n->nic);
3960 virtio_net_rsc_cleanup(n);
3961 g_free(n->rss_data.indirections_table);
3962 net_rx_pkt_uninit(n->rx_pkt);
3963 virtio_cleanup(vdev);
3964 }
3965
virtio_net_reset(VirtIODevice * vdev)3966 static void virtio_net_reset(VirtIODevice *vdev)
3967 {
3968 VirtIONet *n = VIRTIO_NET(vdev);
3969 int i;
3970
3971 /* Reset back to compatibility mode */
3972 n->promisc = 1;
3973 n->allmulti = 0;
3974 n->alluni = 0;
3975 n->nomulti = 0;
3976 n->nouni = 0;
3977 n->nobcast = 0;
3978 /* multiqueue is disabled by default */
3979 n->curr_queue_pairs = 1;
3980 timer_del(n->announce_timer.tm);
3981 n->announce_timer.round = 0;
3982 n->status &= ~VIRTIO_NET_S_ANNOUNCE;
3983
3984 /* Flush any MAC and VLAN filter table state */
3985 n->mac_table.in_use = 0;
3986 n->mac_table.first_multi = 0;
3987 n->mac_table.multi_overflow = 0;
3988 n->mac_table.uni_overflow = 0;
3989 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
3990 memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
3991 qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
3992 memset(n->vlans, 0, MAX_VLAN >> 3);
3993
3994 /* Flush any async TX */
3995 for (i = 0; i < n->max_queue_pairs; i++) {
3996 flush_or_purge_queued_packets(qemu_get_subqueue(n->nic, i));
3997 }
3998
3999 virtio_net_disable_rss(n);
4000 }
4001
virtio_net_instance_init(Object * obj)4002 static void virtio_net_instance_init(Object *obj)
4003 {
4004 VirtIONet *n = VIRTIO_NET(obj);
4005
4006 /*
4007 * The default config_size is sizeof(struct virtio_net_config).
4008 * Can be overridden with virtio_net_set_config_size.
4009 */
4010 n->config_size = sizeof(struct virtio_net_config);
4011 device_add_bootindex_property(obj, &n->nic_conf.bootindex,
4012 "bootindex", "/ethernet-phy@0",
4013 DEVICE(n));
4014
4015 ebpf_rss_init(&n->ebpf_rss);
4016 }
4017
virtio_net_pre_save(void * opaque)4018 static int virtio_net_pre_save(void *opaque)
4019 {
4020 VirtIONet *n = opaque;
4021
4022 /* At this point, backend must be stopped, otherwise
4023 * it might keep writing to memory. */
4024 assert(!n->vhost_started);
4025
4026 return 0;
4027 }
4028
primary_unplug_pending(void * opaque)4029 static bool primary_unplug_pending(void *opaque)
4030 {
4031 DeviceState *dev = opaque;
4032 DeviceState *primary;
4033 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
4034 VirtIONet *n = VIRTIO_NET(vdev);
4035
4036 if (!virtio_vdev_has_feature(vdev, VIRTIO_NET_F_STANDBY)) {
4037 return false;
4038 }
4039 primary = failover_find_primary_device(n);
4040 return primary ? primary->pending_deleted_event : false;
4041 }
4042
dev_unplug_pending(void * opaque)4043 static bool dev_unplug_pending(void *opaque)
4044 {
4045 DeviceState *dev = opaque;
4046 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
4047
4048 return vdc->primary_unplug_pending(dev);
4049 }
4050
4051 static const VMStateDescription vmstate_virtio_net = {
4052 .name = "virtio-net",
4053 .minimum_version_id = VIRTIO_NET_VM_VERSION,
4054 .version_id = VIRTIO_NET_VM_VERSION,
4055 .fields = (const VMStateField[]) {
4056 VMSTATE_VIRTIO_DEVICE,
4057 VMSTATE_END_OF_LIST()
4058 },
4059 .pre_save = virtio_net_pre_save,
4060 .dev_unplug_pending = dev_unplug_pending,
4061 };
4062
4063 static const Property virtio_net_properties[] = {
4064 DEFINE_PROP_BIT64("csum", VirtIONet, host_features,
4065 VIRTIO_NET_F_CSUM, true),
4066 DEFINE_PROP_BIT64("guest_csum", VirtIONet, host_features,
4067 VIRTIO_NET_F_GUEST_CSUM, true),
4068 DEFINE_PROP_BIT64("gso", VirtIONet, host_features, VIRTIO_NET_F_GSO, true),
4069 DEFINE_PROP_BIT64("guest_tso4", VirtIONet, host_features,
4070 VIRTIO_NET_F_GUEST_TSO4, true),
4071 DEFINE_PROP_BIT64("guest_tso6", VirtIONet, host_features,
4072 VIRTIO_NET_F_GUEST_TSO6, true),
4073 DEFINE_PROP_BIT64("guest_ecn", VirtIONet, host_features,
4074 VIRTIO_NET_F_GUEST_ECN, true),
4075 DEFINE_PROP_BIT64("guest_ufo", VirtIONet, host_features,
4076 VIRTIO_NET_F_GUEST_UFO, true),
4077 DEFINE_PROP_BIT64("guest_announce", VirtIONet, host_features,
4078 VIRTIO_NET_F_GUEST_ANNOUNCE, true),
4079 DEFINE_PROP_BIT64("host_tso4", VirtIONet, host_features,
4080 VIRTIO_NET_F_HOST_TSO4, true),
4081 DEFINE_PROP_BIT64("host_tso6", VirtIONet, host_features,
4082 VIRTIO_NET_F_HOST_TSO6, true),
4083 DEFINE_PROP_BIT64("host_ecn", VirtIONet, host_features,
4084 VIRTIO_NET_F_HOST_ECN, true),
4085 DEFINE_PROP_BIT64("host_ufo", VirtIONet, host_features,
4086 VIRTIO_NET_F_HOST_UFO, true),
4087 DEFINE_PROP_BIT64("mrg_rxbuf", VirtIONet, host_features,
4088 VIRTIO_NET_F_MRG_RXBUF, true),
4089 DEFINE_PROP_BIT64("status", VirtIONet, host_features,
4090 VIRTIO_NET_F_STATUS, true),
4091 DEFINE_PROP_BIT64("ctrl_vq", VirtIONet, host_features,
4092 VIRTIO_NET_F_CTRL_VQ, true),
4093 DEFINE_PROP_BIT64("ctrl_rx", VirtIONet, host_features,
4094 VIRTIO_NET_F_CTRL_RX, true),
4095 DEFINE_PROP_BIT64("ctrl_vlan", VirtIONet, host_features,
4096 VIRTIO_NET_F_CTRL_VLAN, true),
4097 DEFINE_PROP_BIT64("ctrl_rx_extra", VirtIONet, host_features,
4098 VIRTIO_NET_F_CTRL_RX_EXTRA, true),
4099 DEFINE_PROP_BIT64("ctrl_mac_addr", VirtIONet, host_features,
4100 VIRTIO_NET_F_CTRL_MAC_ADDR, true),
4101 DEFINE_PROP_BIT64("ctrl_guest_offloads", VirtIONet, host_features,
4102 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, true),
4103 DEFINE_PROP_BIT64("mq", VirtIONet, host_features, VIRTIO_NET_F_MQ, false),
4104 DEFINE_PROP_BIT64("rss", VirtIONet, host_features,
4105 VIRTIO_NET_F_RSS, false),
4106 DEFINE_PROP_BIT64("hash", VirtIONet, host_features,
4107 VIRTIO_NET_F_HASH_REPORT, false),
4108 DEFINE_PROP_ARRAY("ebpf-rss-fds", VirtIONet, nr_ebpf_rss_fds,
4109 ebpf_rss_fds, qdev_prop_string, char*),
4110 DEFINE_PROP_BIT64("guest_rsc_ext", VirtIONet, host_features,
4111 VIRTIO_NET_F_RSC_EXT, false),
4112 DEFINE_PROP_UINT32("rsc_interval", VirtIONet, rsc_timeout,
4113 VIRTIO_NET_RSC_DEFAULT_INTERVAL),
4114 DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
4115 DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
4116 TX_TIMER_INTERVAL),
4117 DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
4118 DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
4119 DEFINE_PROP_UINT16("rx_queue_size", VirtIONet, net_conf.rx_queue_size,
4120 VIRTIO_NET_RX_QUEUE_DEFAULT_SIZE),
4121 DEFINE_PROP_UINT16("tx_queue_size", VirtIONet, net_conf.tx_queue_size,
4122 VIRTIO_NET_TX_QUEUE_DEFAULT_SIZE),
4123 DEFINE_PROP_UINT16("host_mtu", VirtIONet, net_conf.mtu, 0),
4124 DEFINE_PROP_BOOL("x-mtu-bypass-backend", VirtIONet, mtu_bypass_backend,
4125 true),
4126 DEFINE_PROP_INT32("speed", VirtIONet, net_conf.speed, SPEED_UNKNOWN),
4127 DEFINE_PROP_STRING("duplex", VirtIONet, net_conf.duplex_str),
4128 DEFINE_PROP_BOOL("failover", VirtIONet, failover, false),
4129 DEFINE_PROP_BIT64("guest_uso4", VirtIONet, host_features,
4130 VIRTIO_NET_F_GUEST_USO4, true),
4131 DEFINE_PROP_BIT64("guest_uso6", VirtIONet, host_features,
4132 VIRTIO_NET_F_GUEST_USO6, true),
4133 DEFINE_PROP_BIT64("host_uso", VirtIONet, host_features,
4134 VIRTIO_NET_F_HOST_USO, true),
4135 };
4136
virtio_net_class_init(ObjectClass * klass,void * data)4137 static void virtio_net_class_init(ObjectClass *klass, void *data)
4138 {
4139 DeviceClass *dc = DEVICE_CLASS(klass);
4140 VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
4141
4142 device_class_set_props(dc, virtio_net_properties);
4143 dc->vmsd = &vmstate_virtio_net;
4144 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
4145 vdc->realize = virtio_net_device_realize;
4146 vdc->unrealize = virtio_net_device_unrealize;
4147 vdc->get_config = virtio_net_get_config;
4148 vdc->set_config = virtio_net_set_config;
4149 vdc->get_features = virtio_net_get_features;
4150 vdc->set_features = virtio_net_set_features;
4151 vdc->bad_features = virtio_net_bad_features;
4152 vdc->reset = virtio_net_reset;
4153 vdc->queue_reset = virtio_net_queue_reset;
4154 vdc->queue_enable = virtio_net_queue_enable;
4155 vdc->set_status = virtio_net_set_status;
4156 vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
4157 vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
4158 vdc->legacy_features |= (0x1 << VIRTIO_NET_F_GSO);
4159 vdc->pre_load_queues = virtio_net_pre_load_queues;
4160 vdc->post_load = virtio_net_post_load_virtio;
4161 vdc->vmsd = &vmstate_virtio_net_device;
4162 vdc->primary_unplug_pending = primary_unplug_pending;
4163 vdc->get_vhost = virtio_net_get_vhost;
4164 vdc->toggle_device_iotlb = vhost_toggle_device_iotlb;
4165 }
4166
4167 static const TypeInfo virtio_net_info = {
4168 .name = TYPE_VIRTIO_NET,
4169 .parent = TYPE_VIRTIO_DEVICE,
4170 .instance_size = sizeof(VirtIONet),
4171 .instance_init = virtio_net_instance_init,
4172 .class_init = virtio_net_class_init,
4173 };
4174
virtio_register_types(void)4175 static void virtio_register_types(void)
4176 {
4177 type_register_static(&virtio_net_info);
4178 }
4179
4180 type_init(virtio_register_types)
4181