1
2
3
4
5
6
7
8
9
10
11
12
13
14#include "virtio.h"
15#include "net.h"
16#include "net/checksum.h"
17#include "net/tap.h"
18#include "qemu-timer.h"
19#include "virtio-net.h"
20
21#define VIRTIO_NET_VM_VERSION 11
22
23#define MAC_TABLE_ENTRIES 64
24#define MAX_VLAN (1 << 12)
25
26typedef struct VirtIONet
27{
28 VirtIODevice vdev;
29 uint8_t mac[ETH_ALEN];
30 uint16_t status;
31 VirtQueue *rx_vq;
32 VirtQueue *tx_vq;
33 VirtQueue *ctrl_vq;
34 NICState *nic;
35 QEMUTimer *tx_timer;
36 int tx_timer_active;
37 uint32_t has_vnet_hdr;
38 uint8_t has_ufo;
39 struct {
40 VirtQueueElement elem;
41 ssize_t len;
42 } async_tx;
43 int mergeable_rx_bufs;
44 uint8_t promisc;
45 uint8_t allmulti;
46 uint8_t alluni;
47 uint8_t nomulti;
48 uint8_t nouni;
49 uint8_t nobcast;
50 struct {
51 int in_use;
52 int first_multi;
53 uint8_t multi_overflow;
54 uint8_t uni_overflow;
55 uint8_t *macs;
56 } mac_table;
57 uint32_t *vlans;
58} VirtIONet;
59
60
61
62
63
64static VirtIONet *to_virtio_net(VirtIODevice *vdev)
65{
66 return (VirtIONet *)vdev;
67}
68
69static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
70{
71 VirtIONet *n = to_virtio_net(vdev);
72 struct virtio_net_config netcfg;
73
74 netcfg.status = n->status;
75 memcpy(netcfg.mac, n->mac, ETH_ALEN);
76 memcpy(config, &netcfg, sizeof(netcfg));
77}
78
79static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
80{
81 VirtIONet *n = to_virtio_net(vdev);
82 struct virtio_net_config netcfg;
83
84 memcpy(&netcfg, config, sizeof(netcfg));
85
86 if (memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
87 memcpy(n->mac, netcfg.mac, ETH_ALEN);
88 qemu_format_nic_info_str(&n->nic->nc, n->mac);
89 }
90}
91
92static void virtio_net_set_link_status(VLANClientState *nc)
93{
94 VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
95 uint16_t old_status = n->status;
96
97 if (nc->link_down)
98 n->status &= ~VIRTIO_NET_S_LINK_UP;
99 else
100 n->status |= VIRTIO_NET_S_LINK_UP;
101
102 if (n->status != old_status)
103 virtio_notify_config(&n->vdev);
104}
105
106static void virtio_net_reset(VirtIODevice *vdev)
107{
108 VirtIONet *n = to_virtio_net(vdev);
109
110
111 n->promisc = 1;
112 n->allmulti = 0;
113 n->alluni = 0;
114 n->nomulti = 0;
115 n->nouni = 0;
116 n->nobcast = 0;
117
118
119 n->mac_table.in_use = 0;
120 n->mac_table.first_multi = 0;
121 n->mac_table.multi_overflow = 0;
122 n->mac_table.uni_overflow = 0;
123 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
124 memset(n->vlans, 0, MAX_VLAN >> 3);
125}
126
127static int peer_has_vnet_hdr(VirtIONet *n)
128{
129 if (!n->nic->nc.peer)
130 return 0;
131
132 if (n->nic->nc.peer->info->type != NET_CLIENT_TYPE_TAP)
133 return 0;
134
135 n->has_vnet_hdr = tap_has_vnet_hdr(n->nic->nc.peer);
136
137 return n->has_vnet_hdr;
138}
139
140static int peer_has_ufo(VirtIONet *n)
141{
142 if (!peer_has_vnet_hdr(n))
143 return 0;
144
145 n->has_ufo = tap_has_ufo(n->nic->nc.peer);
146
147 return n->has_ufo;
148}
149
150static uint32_t virtio_net_get_features(VirtIODevice *vdev)
151{
152 VirtIONet *n = to_virtio_net(vdev);
153 uint32_t features = (1 << VIRTIO_NET_F_MAC) |
154 (1 << VIRTIO_NET_F_MRG_RXBUF) |
155 (1 << VIRTIO_NET_F_STATUS) |
156 (1 << VIRTIO_NET_F_CTRL_VQ) |
157 (1 << VIRTIO_NET_F_CTRL_RX) |
158 (1 << VIRTIO_NET_F_CTRL_VLAN) |
159 (1 << VIRTIO_NET_F_CTRL_RX_EXTRA);
160
161 if (peer_has_vnet_hdr(n)) {
162 tap_using_vnet_hdr(n->nic->nc.peer, 1);
163
164 features |= (1 << VIRTIO_NET_F_CSUM);
165 features |= (1 << VIRTIO_NET_F_HOST_TSO4);
166 features |= (1 << VIRTIO_NET_F_HOST_TSO6);
167 features |= (1 << VIRTIO_NET_F_HOST_ECN);
168
169 features |= (1 << VIRTIO_NET_F_GUEST_CSUM);
170 features |= (1 << VIRTIO_NET_F_GUEST_TSO4);
171 features |= (1 << VIRTIO_NET_F_GUEST_TSO6);
172 features |= (1 << VIRTIO_NET_F_GUEST_ECN);
173
174 if (peer_has_ufo(n)) {
175 features |= (1 << VIRTIO_NET_F_GUEST_UFO);
176 features |= (1 << VIRTIO_NET_F_HOST_UFO);
177 }
178 }
179
180 return features;
181}
182
183static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
184{
185 uint32_t features = 0;
186
187
188
189 features |= (1 << VIRTIO_NET_F_MAC);
190 features |= (1 << VIRTIO_NET_F_CSUM);
191 features |= (1 << VIRTIO_NET_F_HOST_TSO4);
192 features |= (1 << VIRTIO_NET_F_HOST_TSO6);
193 features |= (1 << VIRTIO_NET_F_HOST_ECN);
194
195 return features & virtio_net_get_features(vdev);
196}
197
198static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
199{
200 VirtIONet *n = to_virtio_net(vdev);
201
202 n->mergeable_rx_bufs = !!(features & (1 << VIRTIO_NET_F_MRG_RXBUF));
203
204 if (n->has_vnet_hdr) {
205 tap_set_offload(n->nic->nc.peer,
206 (features >> VIRTIO_NET_F_GUEST_CSUM) & 1,
207 (features >> VIRTIO_NET_F_GUEST_TSO4) & 1,
208 (features >> VIRTIO_NET_F_GUEST_TSO6) & 1,
209 (features >> VIRTIO_NET_F_GUEST_ECN) & 1,
210 (features >> VIRTIO_NET_F_GUEST_UFO) & 1);
211 }
212}
213
214static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
215 VirtQueueElement *elem)
216{
217 uint8_t on;
218
219 if (elem->out_num != 2 || elem->out_sg[1].iov_len != sizeof(on)) {
220 fprintf(stderr, "virtio-net ctrl invalid rx mode command\n");
221 exit(1);
222 }
223
224 on = ldub_p(elem->out_sg[1].iov_base);
225
226 if (cmd == VIRTIO_NET_CTRL_RX_MODE_PROMISC)
227 n->promisc = on;
228 else if (cmd == VIRTIO_NET_CTRL_RX_MODE_ALLMULTI)
229 n->allmulti = on;
230 else if (cmd == VIRTIO_NET_CTRL_RX_MODE_ALLUNI)
231 n->alluni = on;
232 else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOMULTI)
233 n->nomulti = on;
234 else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOUNI)
235 n->nouni = on;
236 else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOBCAST)
237 n->nobcast = on;
238 else
239 return VIRTIO_NET_ERR;
240
241 return VIRTIO_NET_OK;
242}
243
244static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
245 VirtQueueElement *elem)
246{
247 struct virtio_net_ctrl_mac mac_data;
248
249 if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET || elem->out_num != 3 ||
250 elem->out_sg[1].iov_len < sizeof(mac_data) ||
251 elem->out_sg[2].iov_len < sizeof(mac_data))
252 return VIRTIO_NET_ERR;
253
254 n->mac_table.in_use = 0;
255 n->mac_table.first_multi = 0;
256 n->mac_table.uni_overflow = 0;
257 n->mac_table.multi_overflow = 0;
258 memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
259
260 mac_data.entries = ldl_le_p(elem->out_sg[1].iov_base);
261
262 if (sizeof(mac_data.entries) +
263 (mac_data.entries * ETH_ALEN) > elem->out_sg[1].iov_len)
264 return VIRTIO_NET_ERR;
265
266 if (mac_data.entries <= MAC_TABLE_ENTRIES) {
267 memcpy(n->mac_table.macs, elem->out_sg[1].iov_base + sizeof(mac_data),
268 mac_data.entries * ETH_ALEN);
269 n->mac_table.in_use += mac_data.entries;
270 } else {
271 n->mac_table.uni_overflow = 1;
272 }
273
274 n->mac_table.first_multi = n->mac_table.in_use;
275
276 mac_data.entries = ldl_le_p(elem->out_sg[2].iov_base);
277
278 if (sizeof(mac_data.entries) +
279 (mac_data.entries * ETH_ALEN) > elem->out_sg[2].iov_len)
280 return VIRTIO_NET_ERR;
281
282 if (mac_data.entries) {
283 if (n->mac_table.in_use + mac_data.entries <= MAC_TABLE_ENTRIES) {
284 memcpy(n->mac_table.macs + (n->mac_table.in_use * ETH_ALEN),
285 elem->out_sg[2].iov_base + sizeof(mac_data),
286 mac_data.entries * ETH_ALEN);
287 n->mac_table.in_use += mac_data.entries;
288 } else {
289 n->mac_table.multi_overflow = 1;
290 }
291 }
292
293 return VIRTIO_NET_OK;
294}
295
296static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
297 VirtQueueElement *elem)
298{
299 uint16_t vid;
300
301 if (elem->out_num != 2 || elem->out_sg[1].iov_len != sizeof(vid)) {
302 fprintf(stderr, "virtio-net ctrl invalid vlan command\n");
303 return VIRTIO_NET_ERR;
304 }
305
306 vid = lduw_le_p(elem->out_sg[1].iov_base);
307
308 if (vid >= MAX_VLAN)
309 return VIRTIO_NET_ERR;
310
311 if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
312 n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
313 else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
314 n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
315 else
316 return VIRTIO_NET_ERR;
317
318 return VIRTIO_NET_OK;
319}
320
321static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
322{
323 VirtIONet *n = to_virtio_net(vdev);
324 struct virtio_net_ctrl_hdr ctrl;
325 virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
326 VirtQueueElement elem;
327
328 while (virtqueue_pop(vq, &elem)) {
329 if ((elem.in_num < 1) || (elem.out_num < 1)) {
330 fprintf(stderr, "virtio-net ctrl missing headers\n");
331 exit(1);
332 }
333
334 if (elem.out_sg[0].iov_len < sizeof(ctrl) ||
335 elem.in_sg[elem.in_num - 1].iov_len < sizeof(status)) {
336 fprintf(stderr, "virtio-net ctrl header not in correct element\n");
337 exit(1);
338 }
339
340 ctrl.class = ldub_p(elem.out_sg[0].iov_base);
341 ctrl.cmd = ldub_p(elem.out_sg[0].iov_base + sizeof(ctrl.class));
342
343 if (ctrl.class == VIRTIO_NET_CTRL_RX_MODE)
344 status = virtio_net_handle_rx_mode(n, ctrl.cmd, &elem);
345 else if (ctrl.class == VIRTIO_NET_CTRL_MAC)
346 status = virtio_net_handle_mac(n, ctrl.cmd, &elem);
347 else if (ctrl.class == VIRTIO_NET_CTRL_VLAN)
348 status = virtio_net_handle_vlan_table(n, ctrl.cmd, &elem);
349
350 stb_p(elem.in_sg[elem.in_num - 1].iov_base, status);
351
352 virtqueue_push(vq, &elem, sizeof(status));
353 virtio_notify(vdev, vq);
354 }
355}
356
357
358
359static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
360{
361 VirtIONet *n = to_virtio_net(vdev);
362
363 qemu_flush_queued_packets(&n->nic->nc);
364
365
366
367 qemu_notify_event();
368}
369
370static int virtio_net_can_receive(VLANClientState *nc)
371{
372 VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
373
374 if (!virtio_queue_ready(n->rx_vq) ||
375 !(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
376 return 0;
377
378 return 1;
379}
380
381static int virtio_net_has_buffers(VirtIONet *n, int bufsize)
382{
383 if (virtio_queue_empty(n->rx_vq) ||
384 (n->mergeable_rx_bufs &&
385 !virtqueue_avail_bytes(n->rx_vq, bufsize, 0))) {
386 virtio_queue_set_notification(n->rx_vq, 1);
387 return 0;
388 }
389
390 virtio_queue_set_notification(n->rx_vq, 0);
391 return 1;
392}
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
409 const uint8_t *buf, size_t size)
410{
411 if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
412 (size > 27 && size < 1500) &&
413 (buf[12] == 0x08 && buf[13] == 0x00) &&
414 (buf[23] == 17) &&
415 (buf[34] == 0 && buf[35] == 67)) {
416
417 net_checksum_calculate((uint8_t *)buf, size);
418 hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
419 }
420}
421
422static int iov_fill(struct iovec *iov, int iovcnt, const void *buf, int count)
423{
424 int offset, i;
425
426 offset = i = 0;
427 while (offset < count && i < iovcnt) {
428 int len = MIN(iov[i].iov_len, count - offset);
429 memcpy(iov[i].iov_base, buf + offset, len);
430 offset += len;
431 i++;
432 }
433
434 return offset;
435}
436
437static int receive_header(VirtIONet *n, struct iovec *iov, int iovcnt,
438 const void *buf, size_t size, size_t hdr_len)
439{
440 struct virtio_net_hdr *hdr = (struct virtio_net_hdr *)iov[0].iov_base;
441 int offset = 0;
442
443 hdr->flags = 0;
444 hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
445
446 if (n->has_vnet_hdr) {
447 memcpy(hdr, buf, sizeof(*hdr));
448 offset = sizeof(*hdr);
449 work_around_broken_dhclient(hdr, buf + offset, size - offset);
450 }
451
452
453
454
455 iov[0].iov_base += hdr_len;
456 iov[0].iov_len -= hdr_len;
457
458 return offset;
459}
460
461static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
462{
463 static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
464 static const uint8_t vlan[] = {0x81, 0x00};
465 uint8_t *ptr = (uint8_t *)buf;
466 int i;
467
468 if (n->promisc)
469 return 1;
470
471 if (n->has_vnet_hdr) {
472 ptr += sizeof(struct virtio_net_hdr);
473 }
474
475 if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
476 int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
477 if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
478 return 0;
479 }
480
481 if (ptr[0] & 1) {
482 if (!memcmp(ptr, bcast, sizeof(bcast))) {
483 return !n->nobcast;
484 } else if (n->nomulti) {
485 return 0;
486 } else if (n->allmulti || n->mac_table.multi_overflow) {
487 return 1;
488 }
489
490 for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
491 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
492 return 1;
493 }
494 }
495 } else {
496 if (n->nouni) {
497 return 0;
498 } else if (n->alluni || n->mac_table.uni_overflow) {
499 return 1;
500 } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
501 return 1;
502 }
503
504 for (i = 0; i < n->mac_table.first_multi; i++) {
505 if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
506 return 1;
507 }
508 }
509 }
510
511 return 0;
512}
513
514static ssize_t virtio_net_receive(VLANClientState *nc, const uint8_t *buf, size_t size)
515{
516 VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
517 struct virtio_net_hdr_mrg_rxbuf *mhdr = NULL;
518 size_t hdr_len, offset, i;
519
520 if (!virtio_net_can_receive(&n->nic->nc))
521 return -1;
522
523 if (!virtio_net_has_buffers(n, size))
524 return 0;
525
526 if (!receive_filter(n, buf, size))
527 return size;
528
529
530 hdr_len = n->mergeable_rx_bufs ?
531 sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
532
533 offset = i = 0;
534
535 while (offset < size) {
536 VirtQueueElement elem;
537 int len, total;
538 struct iovec sg[VIRTQUEUE_MAX_SIZE];
539
540 len = total = 0;
541
542 if ((i != 0 && !n->mergeable_rx_bufs) ||
543 virtqueue_pop(n->rx_vq, &elem) == 0) {
544 if (i == 0)
545 return -1;
546 fprintf(stderr, "virtio-net truncating packet\n");
547 exit(1);
548 }
549
550 if (elem.in_num < 1) {
551 fprintf(stderr, "virtio-net receive queue contains no in buffers\n");
552 exit(1);
553 }
554
555 if (!n->mergeable_rx_bufs && elem.in_sg[0].iov_len != hdr_len) {
556 fprintf(stderr, "virtio-net header not in first element\n");
557 exit(1);
558 }
559
560 memcpy(&sg, &elem.in_sg[0], sizeof(sg[0]) * elem.in_num);
561
562 if (i == 0) {
563 if (n->mergeable_rx_bufs)
564 mhdr = (struct virtio_net_hdr_mrg_rxbuf *)sg[0].iov_base;
565
566 offset += receive_header(n, sg, elem.in_num,
567 buf + offset, size - offset, hdr_len);
568 total += hdr_len;
569 }
570
571
572 len = iov_fill(sg, elem.in_num,
573 buf + offset, size - offset);
574 total += len;
575
576
577 virtqueue_fill(n->rx_vq, &elem, total, i++);
578
579 offset += len;
580 }
581
582 if (mhdr)
583 mhdr->num_buffers = i;
584
585 virtqueue_flush(n->rx_vq, i);
586 virtio_notify(&n->vdev, n->rx_vq);
587
588 return size;
589}
590
591static void virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq);
592
593static void virtio_net_tx_complete(VLANClientState *nc, ssize_t len)
594{
595 VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
596
597 virtqueue_push(n->tx_vq, &n->async_tx.elem, n->async_tx.len);
598 virtio_notify(&n->vdev, n->tx_vq);
599
600 n->async_tx.elem.out_num = n->async_tx.len = 0;
601
602 virtio_queue_set_notification(n->tx_vq, 1);
603 virtio_net_flush_tx(n, n->tx_vq);
604}
605
606
607static void virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq)
608{
609 VirtQueueElement elem;
610
611 if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
612 return;
613
614 if (n->async_tx.elem.out_num) {
615 virtio_queue_set_notification(n->tx_vq, 0);
616 return;
617 }
618
619 while (virtqueue_pop(vq, &elem)) {
620 ssize_t ret, len = 0;
621 unsigned int out_num = elem.out_num;
622 struct iovec *out_sg = &elem.out_sg[0];
623 unsigned hdr_len;
624
625
626 hdr_len = n->mergeable_rx_bufs ?
627 sizeof(struct virtio_net_hdr_mrg_rxbuf) :
628 sizeof(struct virtio_net_hdr);
629
630 if (out_num < 1 || out_sg->iov_len != hdr_len) {
631 fprintf(stderr, "virtio-net header not in first element\n");
632 exit(1);
633 }
634
635
636 if (!n->has_vnet_hdr) {
637 out_num--;
638 out_sg++;
639 len += hdr_len;
640 } else if (n->mergeable_rx_bufs) {
641
642 hdr_len -= sizeof(struct virtio_net_hdr);
643 out_sg->iov_len -= hdr_len;
644 len += hdr_len;
645 }
646
647 ret = qemu_sendv_packet_async(&n->nic->nc, out_sg, out_num,
648 virtio_net_tx_complete);
649 if (ret == 0) {
650 virtio_queue_set_notification(n->tx_vq, 0);
651 n->async_tx.elem = elem;
652 n->async_tx.len = len;
653 return;
654 }
655
656 len += ret;
657
658 virtqueue_push(vq, &elem, len);
659 virtio_notify(&n->vdev, vq);
660 }
661}
662
663static void virtio_net_handle_tx(VirtIODevice *vdev, VirtQueue *vq)
664{
665 VirtIONet *n = to_virtio_net(vdev);
666
667 if (n->tx_timer_active) {
668 virtio_queue_set_notification(vq, 1);
669 qemu_del_timer(n->tx_timer);
670 n->tx_timer_active = 0;
671 virtio_net_flush_tx(n, vq);
672 } else {
673 qemu_mod_timer(n->tx_timer,
674 qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
675 n->tx_timer_active = 1;
676 virtio_queue_set_notification(vq, 0);
677 }
678}
679
680static void virtio_net_tx_timer(void *opaque)
681{
682 VirtIONet *n = opaque;
683
684 n->tx_timer_active = 0;
685
686
687 if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
688 return;
689
690 virtio_queue_set_notification(n->tx_vq, 1);
691 virtio_net_flush_tx(n, n->tx_vq);
692}
693
694static void virtio_net_save(QEMUFile *f, void *opaque)
695{
696 VirtIONet *n = opaque;
697
698 virtio_save(&n->vdev, f);
699
700 qemu_put_buffer(f, n->mac, ETH_ALEN);
701 qemu_put_be32(f, n->tx_timer_active);
702 qemu_put_be32(f, n->mergeable_rx_bufs);
703 qemu_put_be16(f, n->status);
704 qemu_put_byte(f, n->promisc);
705 qemu_put_byte(f, n->allmulti);
706 qemu_put_be32(f, n->mac_table.in_use);
707 qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
708 qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
709 qemu_put_be32(f, n->has_vnet_hdr);
710 qemu_put_byte(f, n->mac_table.multi_overflow);
711 qemu_put_byte(f, n->mac_table.uni_overflow);
712 qemu_put_byte(f, n->alluni);
713 qemu_put_byte(f, n->nomulti);
714 qemu_put_byte(f, n->nouni);
715 qemu_put_byte(f, n->nobcast);
716 qemu_put_byte(f, n->has_ufo);
717}
718
719static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
720{
721 VirtIONet *n = opaque;
722 int i;
723
724 if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
725 return -EINVAL;
726
727 virtio_load(&n->vdev, f);
728
729 qemu_get_buffer(f, n->mac, ETH_ALEN);
730 n->tx_timer_active = qemu_get_be32(f);
731 n->mergeable_rx_bufs = qemu_get_be32(f);
732
733 if (version_id >= 3)
734 n->status = qemu_get_be16(f);
735
736 if (version_id >= 4) {
737 if (version_id < 8) {
738 n->promisc = qemu_get_be32(f);
739 n->allmulti = qemu_get_be32(f);
740 } else {
741 n->promisc = qemu_get_byte(f);
742 n->allmulti = qemu_get_byte(f);
743 }
744 }
745
746 if (version_id >= 5) {
747 n->mac_table.in_use = qemu_get_be32(f);
748
749 if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
750 qemu_get_buffer(f, n->mac_table.macs,
751 n->mac_table.in_use * ETH_ALEN);
752 } else if (n->mac_table.in_use) {
753 qemu_fseek(f, n->mac_table.in_use * ETH_ALEN, SEEK_CUR);
754 n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
755 n->mac_table.in_use = 0;
756 }
757 }
758
759 if (version_id >= 6)
760 qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
761
762 if (version_id >= 7) {
763 if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
764 qemu_error("virtio-net: saved image requires vnet_hdr=on\n");
765 return -1;
766 }
767
768 if (n->has_vnet_hdr) {
769 tap_using_vnet_hdr(n->nic->nc.peer, 1);
770 tap_set_offload(n->nic->nc.peer,
771 (n->vdev.features >> VIRTIO_NET_F_GUEST_CSUM) & 1,
772 (n->vdev.features >> VIRTIO_NET_F_GUEST_TSO4) & 1,
773 (n->vdev.features >> VIRTIO_NET_F_GUEST_TSO6) & 1,
774 (n->vdev.features >> VIRTIO_NET_F_GUEST_ECN) & 1,
775 (n->vdev.features >> VIRTIO_NET_F_GUEST_UFO) & 1);
776 }
777 }
778
779 if (version_id >= 9) {
780 n->mac_table.multi_overflow = qemu_get_byte(f);
781 n->mac_table.uni_overflow = qemu_get_byte(f);
782 }
783
784 if (version_id >= 10) {
785 n->alluni = qemu_get_byte(f);
786 n->nomulti = qemu_get_byte(f);
787 n->nouni = qemu_get_byte(f);
788 n->nobcast = qemu_get_byte(f);
789 }
790
791 if (version_id >= 11) {
792 if (qemu_get_byte(f) && !peer_has_ufo(n)) {
793 qemu_error("virtio-net: saved image requires TUN_F_UFO support\n");
794 return -1;
795 }
796 }
797
798
799 for (i = 0; i < n->mac_table.in_use; i++) {
800 if (n->mac_table.macs[i * ETH_ALEN] & 1) {
801 break;
802 }
803 }
804 n->mac_table.first_multi = i;
805
806 if (n->tx_timer_active) {
807 qemu_mod_timer(n->tx_timer,
808 qemu_get_clock(vm_clock) + TX_TIMER_INTERVAL);
809 }
810
811 return 0;
812}
813
814static void virtio_net_cleanup(VLANClientState *nc)
815{
816 VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
817
818 n->nic = NULL;
819}
820
821static NetClientInfo net_virtio_info = {
822 .type = NET_CLIENT_TYPE_NIC,
823 .size = sizeof(NICState),
824 .can_receive = virtio_net_can_receive,
825 .receive = virtio_net_receive,
826 .cleanup = virtio_net_cleanup,
827 .link_status_changed = virtio_net_set_link_status,
828};
829
830VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf)
831{
832 VirtIONet *n;
833 static int virtio_net_id;
834
835 n = (VirtIONet *)virtio_common_init("virtio-net", VIRTIO_ID_NET,
836 sizeof(struct virtio_net_config),
837 sizeof(VirtIONet));
838
839 n->vdev.get_config = virtio_net_get_config;
840 n->vdev.set_config = virtio_net_set_config;
841 n->vdev.get_features = virtio_net_get_features;
842 n->vdev.set_features = virtio_net_set_features;
843 n->vdev.bad_features = virtio_net_bad_features;
844 n->vdev.reset = virtio_net_reset;
845 n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx);
846 n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx);
847 n->ctrl_vq = virtio_add_queue(&n->vdev, 64, virtio_net_handle_ctrl);
848 qemu_macaddr_default_if_unset(&conf->macaddr);
849 memcpy(&n->mac[0], &conf->macaddr, sizeof(n->mac));
850 n->status = VIRTIO_NET_S_LINK_UP;
851
852 n->nic = qemu_new_nic(&net_virtio_info, conf, dev->info->name, dev->id, n);
853
854 qemu_format_nic_info_str(&n->nic->nc, conf->macaddr.a);
855
856 n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
857 n->tx_timer_active = 0;
858 n->mergeable_rx_bufs = 0;
859 n->promisc = 1;
860
861 n->mac_table.macs = qemu_mallocz(MAC_TABLE_ENTRIES * ETH_ALEN);
862
863 n->vlans = qemu_mallocz(MAX_VLAN >> 3);
864
865 register_savevm("virtio-net", virtio_net_id++, VIRTIO_NET_VM_VERSION,
866 virtio_net_save, virtio_net_load, n);
867
868 return &n->vdev;
869}
870
871void virtio_net_exit(VirtIODevice *vdev)
872{
873 VirtIONet *n = DO_UPCAST(VirtIONet, vdev, vdev);
874
875 qemu_purge_queued_packets(&n->nic->nc);
876
877 unregister_savevm("virtio-net", n);
878
879 qemu_free(n->mac_table.macs);
880 qemu_free(n->vlans);
881
882 qemu_del_timer(n->tx_timer);
883 qemu_free_timer(n->tx_timer);
884
885 virtio_cleanup(&n->vdev);
886 qemu_del_vlan_client(&n->nic->nc);
887}
888
