Statistics
| Branch: | Revision:

root / hw / virtio-net.c @ afbaa7b4

History | View | Annotate | Download (30.7 kB)

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 "iov.h"
15
#include "virtio.h"
16
#include "net.h"
17
#include "net/checksum.h"
18
#include "net/tap.h"
19
#include "qemu-error.h"
20
#include "qemu-timer.h"
21
#include "virtio-net.h"
22
#include "vhost_net.h"
23

    
24
#define VIRTIO_NET_VM_VERSION    11
25

    
26
#define MAC_TABLE_ENTRIES    64
27
#define MAX_VLAN    (1 << 12)   /* Per 802.1Q definition */
28

    
29
typedef struct VirtIONet
30
{
31
    VirtIODevice vdev;
32
    uint8_t mac[ETH_ALEN];
33
    uint16_t status;
34
    VirtQueue *rx_vq;
35
    VirtQueue *tx_vq;
36
    VirtQueue *ctrl_vq;
37
    NICState *nic;
38
    QEMUTimer *tx_timer;
39
    QEMUBH *tx_bh;
40
    uint32_t tx_timeout;
41
    int32_t tx_burst;
42
    int tx_waiting;
43
    uint32_t has_vnet_hdr;
44
    uint8_t has_ufo;
45
    struct {
46
        VirtQueueElement elem;
47
        ssize_t len;
48
    } async_tx;
49
    int mergeable_rx_bufs;
50
    uint8_t promisc;
51
    uint8_t allmulti;
52
    uint8_t alluni;
53
    uint8_t nomulti;
54
    uint8_t nouni;
55
    uint8_t nobcast;
56
    uint8_t vhost_started;
57
    bool vm_running;
58
    VMChangeStateEntry *vmstate;
59
    struct {
60
        int in_use;
61
        int first_multi;
62
        uint8_t multi_overflow;
63
        uint8_t uni_overflow;
64
        uint8_t *macs;
65
    } mac_table;
66
    uint32_t *vlans;
67
    DeviceState *qdev;
68
} VirtIONet;
69

    
70
/* TODO
71
 * - we could suppress RX interrupt if we were so inclined.
72
 */
73

    
74
static VirtIONet *to_virtio_net(VirtIODevice *vdev)
75
{
76
    return (VirtIONet *)vdev;
77
}
78

    
79
static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
80
{
81
    VirtIONet *n = to_virtio_net(vdev);
82
    struct virtio_net_config netcfg;
83

    
84
    netcfg.status = n->status;
85
    memcpy(netcfg.mac, n->mac, ETH_ALEN);
86
    memcpy(config, &netcfg, sizeof(netcfg));
87
}
88

    
89
static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
90
{
91
    VirtIONet *n = to_virtio_net(vdev);
92
    struct virtio_net_config netcfg;
93

    
94
    memcpy(&netcfg, config, sizeof(netcfg));
95

    
96
    if (memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
97
        memcpy(n->mac, netcfg.mac, ETH_ALEN);
98
        qemu_format_nic_info_str(&n->nic->nc, n->mac);
99
    }
100
}
101

    
102
static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
103
{
104
    VirtIONet *n = to_virtio_net(vdev);
105
    if (!n->nic->nc.peer) {
106
        return;
107
    }
108
    if (n->nic->nc.peer->info->type != NET_CLIENT_TYPE_TAP) {
109
        return;
110
    }
111

    
112
    if (!tap_get_vhost_net(n->nic->nc.peer)) {
113
        return;
114
    }
115
    if (!!n->vhost_started == ((status & VIRTIO_CONFIG_S_DRIVER_OK) &&
116
                               (n->status & VIRTIO_NET_S_LINK_UP) &&
117
                               n->vm_running)) {
118
        return;
119
    }
120
    if (!n->vhost_started) {
121
        int r = vhost_net_start(tap_get_vhost_net(n->nic->nc.peer), &n->vdev);
122
        if (r < 0) {
123
            fprintf(stderr, "unable to start vhost net: %d: "
124
                    "falling back on userspace virtio\n", -r);
125
        } else {
126
            n->vhost_started = 1;
127
        }
128
    } else {
129
        vhost_net_stop(tap_get_vhost_net(n->nic->nc.peer), &n->vdev);
130
        n->vhost_started = 0;
131
    }
132
}
133

    
134
static void virtio_net_set_link_status(VLANClientState *nc)
135
{
136
    VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
137
    uint16_t old_status = n->status;
138

    
139
    if (nc->link_down)
140
        n->status &= ~VIRTIO_NET_S_LINK_UP;
141
    else
142
        n->status |= VIRTIO_NET_S_LINK_UP;
143

    
144
    if (n->status != old_status)
145
        virtio_notify_config(&n->vdev);
146

    
147
    virtio_net_set_status(&n->vdev, n->vdev.status);
148
}
149

    
150
static void virtio_net_reset(VirtIODevice *vdev)
151
{
152
    VirtIONet *n = to_virtio_net(vdev);
153

    
154
    /* Reset back to compatibility mode */
155
    n->promisc = 1;
156
    n->allmulti = 0;
157
    n->alluni = 0;
158
    n->nomulti = 0;
159
    n->nouni = 0;
160
    n->nobcast = 0;
161

    
162
    /* Flush any MAC and VLAN filter table state */
163
    n->mac_table.in_use = 0;
164
    n->mac_table.first_multi = 0;
165
    n->mac_table.multi_overflow = 0;
166
    n->mac_table.uni_overflow = 0;
167
    memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
168
    memset(n->vlans, 0, MAX_VLAN >> 3);
169
}
170

    
171
static int peer_has_vnet_hdr(VirtIONet *n)
172
{
173
    if (!n->nic->nc.peer)
174
        return 0;
175

    
176
    if (n->nic->nc.peer->info->type != NET_CLIENT_TYPE_TAP)
177
        return 0;
178

    
179
    n->has_vnet_hdr = tap_has_vnet_hdr(n->nic->nc.peer);
180

    
181
    return n->has_vnet_hdr;
182
}
183

    
184
static int peer_has_ufo(VirtIONet *n)
185
{
186
    if (!peer_has_vnet_hdr(n))
187
        return 0;
188

    
189
    n->has_ufo = tap_has_ufo(n->nic->nc.peer);
190

    
191
    return n->has_ufo;
192
}
193

    
194
static uint32_t virtio_net_get_features(VirtIODevice *vdev, uint32_t features)
195
{
196
    VirtIONet *n = to_virtio_net(vdev);
197

    
198
    features |= (1 << VIRTIO_NET_F_MAC);
199

    
200
    if (peer_has_vnet_hdr(n)) {
201
        tap_using_vnet_hdr(n->nic->nc.peer, 1);
202
    } else {
203
        features &= ~(0x1 << VIRTIO_NET_F_CSUM);
204
        features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO4);
205
        features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO6);
206
        features &= ~(0x1 << VIRTIO_NET_F_HOST_ECN);
207

    
208
        features &= ~(0x1 << VIRTIO_NET_F_GUEST_CSUM);
209
        features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO4);
210
        features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO6);
211
        features &= ~(0x1 << VIRTIO_NET_F_GUEST_ECN);
212
    }
213

    
214
    if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
215
        features &= ~(0x1 << VIRTIO_NET_F_GUEST_UFO);
216
        features &= ~(0x1 << VIRTIO_NET_F_HOST_UFO);
217
    }
218

    
219
    if (!n->nic->nc.peer ||
220
        n->nic->nc.peer->info->type != NET_CLIENT_TYPE_TAP) {
221
        return features;
222
    }
223
    if (!tap_get_vhost_net(n->nic->nc.peer)) {
224
        return features;
225
    }
226
    return vhost_net_get_features(tap_get_vhost_net(n->nic->nc.peer), features);
227
}
228

    
229
static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
230
{
231
    uint32_t features = 0;
232

    
233
    /* Linux kernel 2.6.25.  It understood MAC (as everyone must),
234
     * but also these: */
235
    features |= (1 << VIRTIO_NET_F_MAC);
236
    features |= (1 << VIRTIO_NET_F_CSUM);
237
    features |= (1 << VIRTIO_NET_F_HOST_TSO4);
238
    features |= (1 << VIRTIO_NET_F_HOST_TSO6);
239
    features |= (1 << VIRTIO_NET_F_HOST_ECN);
240

    
241
    return features;
242
}
243

    
244
static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
245
{
246
    VirtIONet *n = to_virtio_net(vdev);
247

    
248
    n->mergeable_rx_bufs = !!(features & (1 << VIRTIO_NET_F_MRG_RXBUF));
249

    
250
    if (n->has_vnet_hdr) {
251
        tap_set_offload(n->nic->nc.peer,
252
                        (features >> VIRTIO_NET_F_GUEST_CSUM) & 1,
253
                        (features >> VIRTIO_NET_F_GUEST_TSO4) & 1,
254
                        (features >> VIRTIO_NET_F_GUEST_TSO6) & 1,
255
                        (features >> VIRTIO_NET_F_GUEST_ECN)  & 1,
256
                        (features >> VIRTIO_NET_F_GUEST_UFO)  & 1);
257
    }
258
    if (!n->nic->nc.peer ||
259
        n->nic->nc.peer->info->type != NET_CLIENT_TYPE_TAP) {
260
        return;
261
    }
262
    if (!tap_get_vhost_net(n->nic->nc.peer)) {
263
        return;
264
    }
265
    vhost_net_ack_features(tap_get_vhost_net(n->nic->nc.peer), features);
266
}
267

    
268
static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
269
                                     VirtQueueElement *elem)
270
{
271
    uint8_t on;
272

    
273
    if (elem->out_num != 2 || elem->out_sg[1].iov_len != sizeof(on)) {
274
        fprintf(stderr, "virtio-net ctrl invalid rx mode command\n");
275
        exit(1);
276
    }
277

    
278
    on = ldub_p(elem->out_sg[1].iov_base);
279

    
280
    if (cmd == VIRTIO_NET_CTRL_RX_MODE_PROMISC)
281
        n->promisc = on;
282
    else if (cmd == VIRTIO_NET_CTRL_RX_MODE_ALLMULTI)
283
        n->allmulti = on;
284
    else if (cmd == VIRTIO_NET_CTRL_RX_MODE_ALLUNI)
285
        n->alluni = on;
286
    else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOMULTI)
287
        n->nomulti = on;
288
    else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOUNI)
289
        n->nouni = on;
290
    else if (cmd == VIRTIO_NET_CTRL_RX_MODE_NOBCAST)
291
        n->nobcast = on;
292
    else
293
        return VIRTIO_NET_ERR;
294

    
295
    return VIRTIO_NET_OK;
296
}
297

    
298
static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
299
                                 VirtQueueElement *elem)
300
{
301
    struct virtio_net_ctrl_mac mac_data;
302

    
303
    if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET || elem->out_num != 3 ||
304
        elem->out_sg[1].iov_len < sizeof(mac_data) ||
305
        elem->out_sg[2].iov_len < sizeof(mac_data))
306
        return VIRTIO_NET_ERR;
307

    
308
    n->mac_table.in_use = 0;
309
    n->mac_table.first_multi = 0;
310
    n->mac_table.uni_overflow = 0;
311
    n->mac_table.multi_overflow = 0;
312
    memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
313

    
314
    mac_data.entries = ldl_le_p(elem->out_sg[1].iov_base);
315

    
316
    if (sizeof(mac_data.entries) +
317
        (mac_data.entries * ETH_ALEN) > elem->out_sg[1].iov_len)
318
        return VIRTIO_NET_ERR;
319

    
320
    if (mac_data.entries <= MAC_TABLE_ENTRIES) {
321
        memcpy(n->mac_table.macs, elem->out_sg[1].iov_base + sizeof(mac_data),
322
               mac_data.entries * ETH_ALEN);
323
        n->mac_table.in_use += mac_data.entries;
324
    } else {
325
        n->mac_table.uni_overflow = 1;
326
    }
327

    
328
    n->mac_table.first_multi = n->mac_table.in_use;
329

    
330
    mac_data.entries = ldl_le_p(elem->out_sg[2].iov_base);
331

    
332
    if (sizeof(mac_data.entries) +
333
        (mac_data.entries * ETH_ALEN) > elem->out_sg[2].iov_len)
334
        return VIRTIO_NET_ERR;
335

    
336
    if (mac_data.entries) {
337
        if (n->mac_table.in_use + mac_data.entries <= MAC_TABLE_ENTRIES) {
338
            memcpy(n->mac_table.macs + (n->mac_table.in_use * ETH_ALEN),
339
                   elem->out_sg[2].iov_base + sizeof(mac_data),
340
                   mac_data.entries * ETH_ALEN);
341
            n->mac_table.in_use += mac_data.entries;
342
        } else {
343
            n->mac_table.multi_overflow = 1;
344
        }
345
    }
346

    
347
    return VIRTIO_NET_OK;
348
}
349

    
350
static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
351
                                        VirtQueueElement *elem)
352
{
353
    uint16_t vid;
354

    
355
    if (elem->out_num != 2 || elem->out_sg[1].iov_len != sizeof(vid)) {
356
        fprintf(stderr, "virtio-net ctrl invalid vlan command\n");
357
        return VIRTIO_NET_ERR;
358
    }
359

    
360
    vid = lduw_le_p(elem->out_sg[1].iov_base);
361

    
362
    if (vid >= MAX_VLAN)
363
        return VIRTIO_NET_ERR;
364

    
365
    if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
366
        n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
367
    else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
368
        n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
369
    else
370
        return VIRTIO_NET_ERR;
371

    
372
    return VIRTIO_NET_OK;
373
}
374

    
375
static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
376
{
377
    VirtIONet *n = to_virtio_net(vdev);
378
    struct virtio_net_ctrl_hdr ctrl;
379
    virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
380
    VirtQueueElement elem;
381

    
382
    while (virtqueue_pop(vq, &elem)) {
383
        if ((elem.in_num < 1) || (elem.out_num < 1)) {
384
            fprintf(stderr, "virtio-net ctrl missing headers\n");
385
            exit(1);
386
        }
387

    
388
        if (elem.out_sg[0].iov_len < sizeof(ctrl) ||
389
            elem.in_sg[elem.in_num - 1].iov_len < sizeof(status)) {
390
            fprintf(stderr, "virtio-net ctrl header not in correct element\n");
391
            exit(1);
392
        }
393

    
394
        ctrl.class = ldub_p(elem.out_sg[0].iov_base);
395
        ctrl.cmd = ldub_p(elem.out_sg[0].iov_base + sizeof(ctrl.class));
396

    
397
        if (ctrl.class == VIRTIO_NET_CTRL_RX_MODE)
398
            status = virtio_net_handle_rx_mode(n, ctrl.cmd, &elem);
399
        else if (ctrl.class == VIRTIO_NET_CTRL_MAC)
400
            status = virtio_net_handle_mac(n, ctrl.cmd, &elem);
401
        else if (ctrl.class == VIRTIO_NET_CTRL_VLAN)
402
            status = virtio_net_handle_vlan_table(n, ctrl.cmd, &elem);
403

    
404
        stb_p(elem.in_sg[elem.in_num - 1].iov_base, status);
405

    
406
        virtqueue_push(vq, &elem, sizeof(status));
407
        virtio_notify(vdev, vq);
408
    }
409
}
410

    
411
/* RX */
412

    
413
static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
414
{
415
    VirtIONet *n = to_virtio_net(vdev);
416

    
417
    qemu_flush_queued_packets(&n->nic->nc);
418

    
419
    /* We now have RX buffers, signal to the IO thread to break out of the
420
     * select to re-poll the tap file descriptor */
421
    qemu_notify_event();
422
}
423

    
424
static int virtio_net_can_receive(VLANClientState *nc)
425
{
426
    VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
427

    
428
    if (!virtio_queue_ready(n->rx_vq) ||
429
        !(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
430
        return 0;
431

    
432
    return 1;
433
}
434

    
435
static int virtio_net_has_buffers(VirtIONet *n, int bufsize)
436
{
437
    if (virtio_queue_empty(n->rx_vq) ||
438
        (n->mergeable_rx_bufs &&
439
         !virtqueue_avail_bytes(n->rx_vq, bufsize, 0))) {
440
        virtio_queue_set_notification(n->rx_vq, 1);
441

    
442
        /* To avoid a race condition where the guest has made some buffers
443
         * available after the above check but before notification was
444
         * enabled, check for available buffers again.
445
         */
446
        if (virtio_queue_empty(n->rx_vq) ||
447
            (n->mergeable_rx_bufs &&
448
             !virtqueue_avail_bytes(n->rx_vq, bufsize, 0)))
449
            return 0;
450
    }
451

    
452
    virtio_queue_set_notification(n->rx_vq, 0);
453
    return 1;
454
}
455

    
456
/* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
457
 * it never finds out that the packets don't have valid checksums.  This
458
 * causes dhclient to get upset.  Fedora's carried a patch for ages to
459
 * fix this with Xen but it hasn't appeared in an upstream release of
460
 * dhclient yet.
461
 *
462
 * To avoid breaking existing guests, we catch udp packets and add
463
 * checksums.  This is terrible but it's better than hacking the guest
464
 * kernels.
465
 *
466
 * N.B. if we introduce a zero-copy API, this operation is no longer free so
467
 * we should provide a mechanism to disable it to avoid polluting the host
468
 * cache.
469
 */
470
static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
471
                                        const uint8_t *buf, size_t size)
472
{
473
    if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
474
        (size > 27 && size < 1500) && /* normal sized MTU */
475
        (buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
476
        (buf[23] == 17) && /* ip.protocol == UDP */
477
        (buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
478
        /* FIXME this cast is evil */
479
        net_checksum_calculate((uint8_t *)buf, size);
480
        hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
481
    }
482
}
483

    
484
static int receive_header(VirtIONet *n, struct iovec *iov, int iovcnt,
485
                          const void *buf, size_t size, size_t hdr_len)
486
{
487
    struct virtio_net_hdr *hdr = (struct virtio_net_hdr *)iov[0].iov_base;
488
    int offset = 0;
489

    
490
    hdr->flags = 0;
491
    hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
492

    
493
    if (n->has_vnet_hdr) {
494
        memcpy(hdr, buf, sizeof(*hdr));
495
        offset = sizeof(*hdr);
496
        work_around_broken_dhclient(hdr, buf + offset, size - offset);
497
    }
498

    
499
    /* We only ever receive a struct virtio_net_hdr from the tapfd,
500
     * but we may be passing along a larger header to the guest.
501
     */
502
    iov[0].iov_base += hdr_len;
503
    iov[0].iov_len  -= hdr_len;
504

    
505
    return offset;
506
}
507

    
508
static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
509
{
510
    static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
511
    static const uint8_t vlan[] = {0x81, 0x00};
512
    uint8_t *ptr = (uint8_t *)buf;
513
    int i;
514

    
515
    if (n->promisc)
516
        return 1;
517

    
518
    if (n->has_vnet_hdr) {
519
        ptr += sizeof(struct virtio_net_hdr);
520
    }
521

    
522
    if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
523
        int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
524
        if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
525
            return 0;
526
    }
527

    
528
    if (ptr[0] & 1) { // multicast
529
        if (!memcmp(ptr, bcast, sizeof(bcast))) {
530
            return !n->nobcast;
531
        } else if (n->nomulti) {
532
            return 0;
533
        } else if (n->allmulti || n->mac_table.multi_overflow) {
534
            return 1;
535
        }
536

    
537
        for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
538
            if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
539
                return 1;
540
            }
541
        }
542
    } else { // unicast
543
        if (n->nouni) {
544
            return 0;
545
        } else if (n->alluni || n->mac_table.uni_overflow) {
546
            return 1;
547
        } else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
548
            return 1;
549
        }
550

    
551
        for (i = 0; i < n->mac_table.first_multi; i++) {
552
            if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
553
                return 1;
554
            }
555
        }
556
    }
557

    
558
    return 0;
559
}
560

    
561
static ssize_t virtio_net_receive(VLANClientState *nc, const uint8_t *buf, size_t size)
562
{
563
    VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
564
    struct virtio_net_hdr_mrg_rxbuf *mhdr = NULL;
565
    size_t guest_hdr_len, offset, i, host_hdr_len;
566

    
567
    if (!virtio_net_can_receive(&n->nic->nc))
568
        return -1;
569

    
570
    /* hdr_len refers to the header we supply to the guest */
571
    guest_hdr_len = n->mergeable_rx_bufs ?
572
        sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
573

    
574

    
575
    host_hdr_len = n->has_vnet_hdr ? sizeof(struct virtio_net_hdr) : 0;
576
    if (!virtio_net_has_buffers(n, size + guest_hdr_len - host_hdr_len))
577
        return 0;
578

    
579
    if (!receive_filter(n, buf, size))
580
        return size;
581

    
582
    offset = i = 0;
583

    
584
    while (offset < size) {
585
        VirtQueueElement elem;
586
        int len, total;
587
        struct iovec sg[VIRTQUEUE_MAX_SIZE];
588

    
589
        total = 0;
590

    
591
        if (virtqueue_pop(n->rx_vq, &elem) == 0) {
592
            if (i == 0)
593
                return -1;
594
            fprintf(stderr, "virtio-net unexpected empty queue: "
595
                    "i %zd mergeable %d offset %zd, size %zd, "
596
                    "guest hdr len %zd, host hdr len %zd guest features 0x%x\n",
597
                    i, n->mergeable_rx_bufs, offset, size,
598
                    guest_hdr_len, host_hdr_len, n->vdev.guest_features);
599
            exit(1);
600
        }
601

    
602
        if (elem.in_num < 1) {
603
            fprintf(stderr, "virtio-net receive queue contains no in buffers\n");
604
            exit(1);
605
        }
606

    
607
        if (!n->mergeable_rx_bufs && elem.in_sg[0].iov_len != guest_hdr_len) {
608
            fprintf(stderr, "virtio-net header not in first element\n");
609
            exit(1);
610
        }
611

    
612
        memcpy(&sg, &elem.in_sg[0], sizeof(sg[0]) * elem.in_num);
613

    
614
        if (i == 0) {
615
            if (n->mergeable_rx_bufs)
616
                mhdr = (struct virtio_net_hdr_mrg_rxbuf *)sg[0].iov_base;
617

    
618
            offset += receive_header(n, sg, elem.in_num,
619
                                     buf + offset, size - offset, guest_hdr_len);
620
            total += guest_hdr_len;
621
        }
622

    
623
        /* copy in packet.  ugh */
624
        len = iov_from_buf(sg, elem.in_num,
625
                           buf + offset, size - offset);
626
        total += len;
627
        offset += len;
628
        /* If buffers can't be merged, at this point we
629
         * must have consumed the complete packet.
630
         * Otherwise, drop it. */
631
        if (!n->mergeable_rx_bufs && offset < size) {
632
#if 0
633
            fprintf(stderr, "virtio-net truncated non-mergeable packet: "
634

635
                    "i %zd mergeable %d offset %zd, size %zd, "
636
                    "guest hdr len %zd, host hdr len %zd\n",
637
                    i, n->mergeable_rx_bufs,
638
                    offset, size, guest_hdr_len, host_hdr_len);
639
#endif
640
            return size;
641
        }
642

    
643
        /* signal other side */
644
        virtqueue_fill(n->rx_vq, &elem, total, i++);
645
    }
646

    
647
    if (mhdr)
648
        mhdr->num_buffers = i;
649

    
650
    virtqueue_flush(n->rx_vq, i);
651
    virtio_notify(&n->vdev, n->rx_vq);
652

    
653
    return size;
654
}
655

    
656
static int32_t virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq);
657

    
658
static void virtio_net_tx_complete(VLANClientState *nc, ssize_t len)
659
{
660
    VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
661

    
662
    virtqueue_push(n->tx_vq, &n->async_tx.elem, n->async_tx.len);
663
    virtio_notify(&n->vdev, n->tx_vq);
664

    
665
    n->async_tx.elem.out_num = n->async_tx.len = 0;
666

    
667
    virtio_queue_set_notification(n->tx_vq, 1);
668
    virtio_net_flush_tx(n, n->tx_vq);
669
}
670

    
671
/* TX */
672
static int32_t virtio_net_flush_tx(VirtIONet *n, VirtQueue *vq)
673
{
674
    VirtQueueElement elem;
675
    int32_t num_packets = 0;
676

    
677
    if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK)) {
678
        return num_packets;
679
    }
680

    
681
    if (n->async_tx.elem.out_num) {
682
        virtio_queue_set_notification(n->tx_vq, 0);
683
        return num_packets;
684
    }
685

    
686
    while (virtqueue_pop(vq, &elem)) {
687
        ssize_t ret, len = 0;
688
        unsigned int out_num = elem.out_num;
689
        struct iovec *out_sg = &elem.out_sg[0];
690
        unsigned hdr_len;
691

    
692
        /* hdr_len refers to the header received from the guest */
693
        hdr_len = n->mergeable_rx_bufs ?
694
            sizeof(struct virtio_net_hdr_mrg_rxbuf) :
695
            sizeof(struct virtio_net_hdr);
696

    
697
        if (out_num < 1 || out_sg->iov_len != hdr_len) {
698
            fprintf(stderr, "virtio-net header not in first element\n");
699
            exit(1);
700
        }
701

    
702
        /* ignore the header if GSO is not supported */
703
        if (!n->has_vnet_hdr) {
704
            out_num--;
705
            out_sg++;
706
            len += hdr_len;
707
        } else if (n->mergeable_rx_bufs) {
708
            /* tapfd expects a struct virtio_net_hdr */
709
            hdr_len -= sizeof(struct virtio_net_hdr);
710
            out_sg->iov_len -= hdr_len;
711
            len += hdr_len;
712
        }
713

    
714
        ret = qemu_sendv_packet_async(&n->nic->nc, out_sg, out_num,
715
                                      virtio_net_tx_complete);
716
        if (ret == 0) {
717
            virtio_queue_set_notification(n->tx_vq, 0);
718
            n->async_tx.elem = elem;
719
            n->async_tx.len  = len;
720
            return -EBUSY;
721
        }
722

    
723
        len += ret;
724

    
725
        virtqueue_push(vq, &elem, len);
726
        virtio_notify(&n->vdev, vq);
727

    
728
        if (++num_packets >= n->tx_burst) {
729
            break;
730
        }
731
    }
732
    return num_packets;
733
}
734

    
735
static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
736
{
737
    VirtIONet *n = to_virtio_net(vdev);
738

    
739
    if (n->tx_waiting) {
740
        virtio_queue_set_notification(vq, 1);
741
        qemu_del_timer(n->tx_timer);
742
        n->tx_waiting = 0;
743
        virtio_net_flush_tx(n, vq);
744
    } else {
745
        qemu_mod_timer(n->tx_timer,
746
                       qemu_get_clock(vm_clock) + n->tx_timeout);
747
        n->tx_waiting = 1;
748
        virtio_queue_set_notification(vq, 0);
749
    }
750
}
751

    
752
static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
753
{
754
    VirtIONet *n = to_virtio_net(vdev);
755

    
756
    if (unlikely(n->tx_waiting)) {
757
        return;
758
    }
759
    virtio_queue_set_notification(vq, 0);
760
    qemu_bh_schedule(n->tx_bh);
761
    n->tx_waiting = 1;
762
}
763

    
764
static void virtio_net_tx_timer(void *opaque)
765
{
766
    VirtIONet *n = opaque;
767

    
768
    n->tx_waiting = 0;
769

    
770
    /* Just in case the driver is not ready on more */
771
    if (!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK))
772
        return;
773

    
774
    virtio_queue_set_notification(n->tx_vq, 1);
775
    virtio_net_flush_tx(n, n->tx_vq);
776
}
777

    
778
static void virtio_net_tx_bh(void *opaque)
779
{
780
    VirtIONet *n = opaque;
781
    int32_t ret;
782

    
783
    n->tx_waiting = 0;
784

    
785
    /* Just in case the driver is not ready on more */
786
    if (unlikely(!(n->vdev.status & VIRTIO_CONFIG_S_DRIVER_OK)))
787
        return;
788

    
789
    ret = virtio_net_flush_tx(n, n->tx_vq);
790
    if (ret == -EBUSY) {
791
        return; /* Notification re-enable handled by tx_complete */
792
    }
793

    
794
    /* If we flush a full burst of packets, assume there are
795
     * more coming and immediately reschedule */
796
    if (ret >= n->tx_burst) {
797
        qemu_bh_schedule(n->tx_bh);
798
        n->tx_waiting = 1;
799
        return;
800
    }
801

    
802
    /* If less than a full burst, re-enable notification and flush
803
     * anything that may have come in while we weren't looking.  If
804
     * we find something, assume the guest is still active and reschedule */
805
    virtio_queue_set_notification(n->tx_vq, 1);
806
    if (virtio_net_flush_tx(n, n->tx_vq) > 0) {
807
        virtio_queue_set_notification(n->tx_vq, 0);
808
        qemu_bh_schedule(n->tx_bh);
809
        n->tx_waiting = 1;
810
    }
811
}
812

    
813
static void virtio_net_save(QEMUFile *f, void *opaque)
814
{
815
    VirtIONet *n = opaque;
816

    
817
    /* At this point, backend must be stopped, otherwise
818
     * it might keep writing to memory. */
819
    assert(!n->vhost_started);
820
    virtio_save(&n->vdev, f);
821

    
822
    qemu_put_buffer(f, n->mac, ETH_ALEN);
823
    qemu_put_be32(f, n->tx_waiting);
824
    qemu_put_be32(f, n->mergeable_rx_bufs);
825
    qemu_put_be16(f, n->status);
826
    qemu_put_byte(f, n->promisc);
827
    qemu_put_byte(f, n->allmulti);
828
    qemu_put_be32(f, n->mac_table.in_use);
829
    qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
830
    qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
831
    qemu_put_be32(f, n->has_vnet_hdr);
832
    qemu_put_byte(f, n->mac_table.multi_overflow);
833
    qemu_put_byte(f, n->mac_table.uni_overflow);
834
    qemu_put_byte(f, n->alluni);
835
    qemu_put_byte(f, n->nomulti);
836
    qemu_put_byte(f, n->nouni);
837
    qemu_put_byte(f, n->nobcast);
838
    qemu_put_byte(f, n->has_ufo);
839
}
840

    
841
static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
842
{
843
    VirtIONet *n = opaque;
844
    int i;
845

    
846
    if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
847
        return -EINVAL;
848

    
849
    virtio_load(&n->vdev, f);
850

    
851
    qemu_get_buffer(f, n->mac, ETH_ALEN);
852
    n->tx_waiting = qemu_get_be32(f);
853
    n->mergeable_rx_bufs = qemu_get_be32(f);
854

    
855
    if (version_id >= 3)
856
        n->status = qemu_get_be16(f);
857

    
858
    if (version_id >= 4) {
859
        if (version_id < 8) {
860
            n->promisc = qemu_get_be32(f);
861
            n->allmulti = qemu_get_be32(f);
862
        } else {
863
            n->promisc = qemu_get_byte(f);
864
            n->allmulti = qemu_get_byte(f);
865
        }
866
    }
867

    
868
    if (version_id >= 5) {
869
        n->mac_table.in_use = qemu_get_be32(f);
870
        /* MAC_TABLE_ENTRIES may be different from the saved image */
871
        if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
872
            qemu_get_buffer(f, n->mac_table.macs,
873
                            n->mac_table.in_use * ETH_ALEN);
874
        } else if (n->mac_table.in_use) {
875
            qemu_fseek(f, n->mac_table.in_use * ETH_ALEN, SEEK_CUR);
876
            n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
877
            n->mac_table.in_use = 0;
878
        }
879
    }
880
 
881
    if (version_id >= 6)
882
        qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
883

    
884
    if (version_id >= 7) {
885
        if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
886
            error_report("virtio-net: saved image requires vnet_hdr=on");
887
            return -1;
888
        }
889

    
890
        if (n->has_vnet_hdr) {
891
            tap_using_vnet_hdr(n->nic->nc.peer, 1);
892
            tap_set_offload(n->nic->nc.peer,
893
                    (n->vdev.guest_features >> VIRTIO_NET_F_GUEST_CSUM) & 1,
894
                    (n->vdev.guest_features >> VIRTIO_NET_F_GUEST_TSO4) & 1,
895
                    (n->vdev.guest_features >> VIRTIO_NET_F_GUEST_TSO6) & 1,
896
                    (n->vdev.guest_features >> VIRTIO_NET_F_GUEST_ECN)  & 1,
897
                    (n->vdev.guest_features >> VIRTIO_NET_F_GUEST_UFO)  & 1);
898
        }
899
    }
900

    
901
    if (version_id >= 9) {
902
        n->mac_table.multi_overflow = qemu_get_byte(f);
903
        n->mac_table.uni_overflow = qemu_get_byte(f);
904
    }
905

    
906
    if (version_id >= 10) {
907
        n->alluni = qemu_get_byte(f);
908
        n->nomulti = qemu_get_byte(f);
909
        n->nouni = qemu_get_byte(f);
910
        n->nobcast = qemu_get_byte(f);
911
    }
912

    
913
    if (version_id >= 11) {
914
        if (qemu_get_byte(f) && !peer_has_ufo(n)) {
915
            error_report("virtio-net: saved image requires TUN_F_UFO support");
916
            return -1;
917
        }
918
    }
919

    
920
    /* Find the first multicast entry in the saved MAC filter */
921
    for (i = 0; i < n->mac_table.in_use; i++) {
922
        if (n->mac_table.macs[i * ETH_ALEN] & 1) {
923
            break;
924
        }
925
    }
926
    n->mac_table.first_multi = i;
927

    
928
    if (n->tx_waiting) {
929
        if (n->tx_timer) {
930
            qemu_mod_timer(n->tx_timer,
931
                           qemu_get_clock(vm_clock) + n->tx_timeout);
932
        } else {
933
            qemu_bh_schedule(n->tx_bh);
934
        }
935
    }
936
    return 0;
937
}
938

    
939
static void virtio_net_cleanup(VLANClientState *nc)
940
{
941
    VirtIONet *n = DO_UPCAST(NICState, nc, nc)->opaque;
942

    
943
    n->nic = NULL;
944
}
945

    
946
static NetClientInfo net_virtio_info = {
947
    .type = NET_CLIENT_TYPE_NIC,
948
    .size = sizeof(NICState),
949
    .can_receive = virtio_net_can_receive,
950
    .receive = virtio_net_receive,
951
        .cleanup = virtio_net_cleanup,
952
    .link_status_changed = virtio_net_set_link_status,
953
};
954

    
955
static void virtio_net_vmstate_change(void *opaque, int running, int reason)
956
{
957
    VirtIONet *n = opaque;
958
    n->vm_running = running;
959
    /* This is called when vm is started/stopped,
960
     * it will start/stop vhost backend if appropriate
961
     * e.g. after migration. */
962
    virtio_net_set_status(&n->vdev, n->vdev.status);
963
}
964

    
965
VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf,
966
                              virtio_net_conf *net)
967
{
968
    VirtIONet *n;
969

    
970
    n = (VirtIONet *)virtio_common_init("virtio-net", VIRTIO_ID_NET,
971
                                        sizeof(struct virtio_net_config),
972
                                        sizeof(VirtIONet));
973

    
974
    n->vdev.get_config = virtio_net_get_config;
975
    n->vdev.set_config = virtio_net_set_config;
976
    n->vdev.get_features = virtio_net_get_features;
977
    n->vdev.set_features = virtio_net_set_features;
978
    n->vdev.bad_features = virtio_net_bad_features;
979
    n->vdev.reset = virtio_net_reset;
980
    n->vdev.set_status = virtio_net_set_status;
981
    n->rx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_rx);
982

    
983
    if (net->tx && strcmp(net->tx, "timer") && strcmp(net->tx, "bh")) {
984
        fprintf(stderr, "virtio-net: "
985
                "Unknown option tx=%s, valid options: \"timer\" \"bh\"\n",
986
                net->tx);
987
        fprintf(stderr, "Defaulting to \"bh\"\n");
988
    }
989

    
990
    if (net->tx && !strcmp(net->tx, "timer")) {
991
        n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx_timer);
992
        n->tx_timer = qemu_new_timer(vm_clock, virtio_net_tx_timer, n);
993
        n->tx_timeout = net->txtimer;
994
    } else {
995
        n->tx_vq = virtio_add_queue(&n->vdev, 256, virtio_net_handle_tx_bh);
996
        n->tx_bh = qemu_bh_new(virtio_net_tx_bh, n);
997
    }
998
    n->ctrl_vq = virtio_add_queue(&n->vdev, 64, virtio_net_handle_ctrl);
999
    qemu_macaddr_default_if_unset(&conf->macaddr);
1000
    memcpy(&n->mac[0], &conf->macaddr, sizeof(n->mac));
1001
    n->status = VIRTIO_NET_S_LINK_UP;
1002

    
1003
    n->nic = qemu_new_nic(&net_virtio_info, conf, dev->info->name, dev->id, n);
1004

    
1005
    qemu_format_nic_info_str(&n->nic->nc, conf->macaddr.a);
1006

    
1007
    n->tx_waiting = 0;
1008
    n->tx_burst = net->txburst;
1009
    n->mergeable_rx_bufs = 0;
1010
    n->promisc = 1; /* for compatibility */
1011

    
1012
    n->mac_table.macs = qemu_mallocz(MAC_TABLE_ENTRIES * ETH_ALEN);
1013

    
1014
    n->vlans = qemu_mallocz(MAX_VLAN >> 3);
1015

    
1016
    n->qdev = dev;
1017
    register_savevm(dev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
1018
                    virtio_net_save, virtio_net_load, n);
1019
    n->vmstate = qemu_add_vm_change_state_handler(virtio_net_vmstate_change, n);
1020

    
1021
    return &n->vdev;
1022
}
1023

    
1024
void virtio_net_exit(VirtIODevice *vdev)
1025
{
1026
    VirtIONet *n = DO_UPCAST(VirtIONet, vdev, vdev);
1027
    qemu_del_vm_change_state_handler(n->vmstate);
1028

    
1029
    /* This will stop vhost backend if appropriate. */
1030
    virtio_net_set_status(vdev, 0);
1031

    
1032
    qemu_purge_queued_packets(&n->nic->nc);
1033

    
1034
    unregister_savevm(n->qdev, "virtio-net", n);
1035

    
1036
    qemu_free(n->mac_table.macs);
1037
    qemu_free(n->vlans);
1038

    
1039
    if (n->tx_timer) {
1040
        qemu_del_timer(n->tx_timer);
1041
        qemu_free_timer(n->tx_timer);
1042
    } else {
1043
        qemu_bh_delete(n->tx_bh);
1044
    }
1045

    
1046
    virtio_cleanup(&n->vdev);
1047
    qemu_del_vlan_client(&n->nic->nc);
1048
}