2008-12-17 20:13:11 +01:00
|
|
|
/*
|
|
|
|
* Virtio Network Device
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2007
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/iov.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio.h"
|
2012-10-24 08:43:34 +02:00
|
|
|
#include "net/net.h"
|
2009-10-22 18:49:03 +02:00
|
|
|
#include "net/checksum.h"
|
2009-10-22 18:49:05 +02:00
|
|
|
#include "net/tap.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
|
|
|
#include "qemu/timer.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio-net.h"
|
|
|
|
#include "net/vhost_net.h"
|
2013-04-11 16:29:57 +02:00
|
|
|
#include "hw/virtio/virtio-bus.h"
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2014-06-18 08:43:48 +02:00
|
|
|
#include "qapi-event.h"
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-10-22 18:43:50 +02:00
|
|
|
#define VIRTIO_NET_VM_VERSION 11
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2009-06-05 22:47:23 +02:00
|
|
|
#define MAC_TABLE_ENTRIES 64
|
2009-02-05 23:36:32 +01:00
|
|
|
#define MAX_VLAN (1 << 12) /* Per 802.1Q definition */
|
2009-02-05 23:36:04 +01:00
|
|
|
|
2013-02-06 00:47:16 +01:00
|
|
|
/*
|
|
|
|
* Calculate the number of bytes up to and including the given 'field' of
|
|
|
|
* 'container'.
|
|
|
|
*/
|
|
|
|
#define endof(container, field) \
|
|
|
|
(offsetof(container, field) + sizeof(((container *)0)->field))
|
|
|
|
|
|
|
|
typedef struct VirtIOFeature {
|
|
|
|
uint32_t flags;
|
|
|
|
size_t end;
|
|
|
|
} VirtIOFeature;
|
|
|
|
|
|
|
|
static VirtIOFeature feature_sizes[] = {
|
|
|
|
{.flags = 1 << VIRTIO_NET_F_MAC,
|
|
|
|
.end = endof(struct virtio_net_config, mac)},
|
|
|
|
{.flags = 1 << VIRTIO_NET_F_STATUS,
|
|
|
|
.end = endof(struct virtio_net_config, status)},
|
|
|
|
{.flags = 1 << VIRTIO_NET_F_MQ,
|
|
|
|
.end = endof(struct virtio_net_config, max_virtqueue_pairs)},
|
|
|
|
{}
|
|
|
|
};
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
static VirtIONetQueue *virtio_net_get_subqueue(NetClientState *nc)
|
2013-01-30 12:12:38 +01:00
|
|
|
{
|
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
return &n->vqs[nc->queue_index];
|
2013-01-30 12:12:38 +01:00
|
|
|
}
|
2013-01-30 12:12:39 +01:00
|
|
|
|
|
|
|
static int vq2q(int queue_index)
|
|
|
|
{
|
|
|
|
return queue_index / 2;
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
/* TODO
|
|
|
|
* - we could suppress RX interrupt if we were so inclined.
|
|
|
|
*/
|
|
|
|
|
2009-02-05 23:36:08 +01:00
|
|
|
static void virtio_net_get_config(VirtIODevice *vdev, uint8_t *config)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2008-12-17 20:13:11 +01:00
|
|
|
struct virtio_net_config netcfg;
|
|
|
|
|
2011-03-03 22:42:28 +01:00
|
|
|
stw_p(&netcfg.status, n->status);
|
2013-01-30 12:12:39 +01:00
|
|
|
stw_p(&netcfg.max_virtqueue_pairs, n->max_queues);
|
2009-02-05 23:36:12 +01:00
|
|
|
memcpy(netcfg.mac, n->mac, ETH_ALEN);
|
2013-02-06 00:47:16 +01:00
|
|
|
memcpy(config, &netcfg, n->config_size);
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:08 +01:00
|
|
|
static void virtio_net_set_config(VirtIODevice *vdev, const uint8_t *config)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-02-06 00:47:16 +01:00
|
|
|
struct virtio_net_config netcfg = {};
|
2009-02-05 23:36:08 +01:00
|
|
|
|
2013-02-06 00:47:16 +01:00
|
|
|
memcpy(&netcfg, config, n->config_size);
|
2009-02-05 23:36:08 +01:00
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!(vdev->guest_features >> VIRTIO_NET_F_CTRL_MAC_ADDR & 1) &&
|
2013-01-22 16:44:45 +01:00
|
|
|
memcmp(netcfg.mac, n->mac, ETH_ALEN)) {
|
2009-02-05 23:36:12 +01:00
|
|
|
memcpy(n->mac, netcfg.mac, ETH_ALEN);
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
|
2009-02-05 23:36:08 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-22 18:52:30 +01:00
|
|
|
static bool virtio_net_started(VirtIONet *n, uint8_t status)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2010-11-22 18:52:30 +01:00
|
|
|
return (status & VIRTIO_CONFIG_S_DRIVER_OK) &&
|
2013-04-11 16:30:01 +02:00
|
|
|
(n->status & VIRTIO_NET_S_LINK_UP) && vdev->vm_running;
|
2010-11-22 18:52:30 +01:00
|
|
|
}
|
|
|
|
|
2014-05-20 08:01:44 +02:00
|
|
|
static void virtio_net_announce_timer(void *opaque)
|
|
|
|
{
|
|
|
|
VirtIONet *n = opaque;
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
|
|
|
|
|
|
|
n->announce_counter--;
|
|
|
|
n->status |= VIRTIO_NET_S_ANNOUNCE;
|
|
|
|
virtio_notify_config(vdev);
|
|
|
|
}
|
|
|
|
|
2010-11-22 18:52:30 +01:00
|
|
|
static void virtio_net_vhost_status(VirtIONet *n, uint8_t status)
|
2010-09-27 18:41:30 +02:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2013-01-30 12:12:22 +01:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
2013-01-30 12:12:39 +01:00
|
|
|
int queues = n->multiqueue ? n->max_queues : 1;
|
2013-01-30 12:12:22 +01:00
|
|
|
|
2014-05-27 14:05:08 +02:00
|
|
|
if (!get_vhost_net(nc->peer)) {
|
2010-09-27 18:41:30 +02:00
|
|
|
return;
|
|
|
|
}
|
2013-01-30 12:12:39 +01:00
|
|
|
|
2013-04-26 12:27:40 +02:00
|
|
|
if (!!n->vhost_started ==
|
|
|
|
(virtio_net_started(n, status) && !nc->peer->link_down)) {
|
2010-09-27 18:41:30 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!n->vhost_started) {
|
2011-02-01 21:13:42 +01:00
|
|
|
int r;
|
2014-05-27 14:05:08 +02:00
|
|
|
if (!vhost_net_query(get_vhost_net(nc->peer), vdev)) {
|
2011-02-01 21:13:42 +01:00
|
|
|
return;
|
|
|
|
}
|
2012-12-25 16:38:59 +01:00
|
|
|
n->vhost_started = 1;
|
2013-04-11 16:30:01 +02:00
|
|
|
r = vhost_net_start(vdev, n->nic->ncs, queues);
|
2010-09-27 18:41:30 +02:00
|
|
|
if (r < 0) {
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("unable to start vhost net: %d: "
|
|
|
|
"falling back on userspace virtio", -r);
|
2012-12-25 16:38:59 +01:00
|
|
|
n->vhost_started = 0;
|
2010-09-27 18:41:30 +02:00
|
|
|
}
|
|
|
|
} else {
|
2013-04-11 16:30:01 +02:00
|
|
|
vhost_net_stop(vdev, n->nic->ncs, queues);
|
2010-09-27 18:41:30 +02:00
|
|
|
n->vhost_started = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-22 18:52:30 +01:00
|
|
|
static void virtio_net_set_status(struct VirtIODevice *vdev, uint8_t status)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q;
|
|
|
|
int i;
|
|
|
|
uint8_t queue_status;
|
2010-11-22 18:52:30 +01:00
|
|
|
|
|
|
|
virtio_net_vhost_status(n, status);
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
q = &n->vqs[i];
|
2010-11-22 18:52:30 +01:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
if ((!n->multiqueue && i != 0) || i >= n->curr_queues) {
|
|
|
|
queue_status = 0;
|
2010-11-22 18:52:30 +01:00
|
|
|
} else {
|
2013-01-30 12:12:39 +01:00
|
|
|
queue_status = status;
|
2010-11-22 18:52:30 +01:00
|
|
|
}
|
2013-01-30 12:12:39 +01:00
|
|
|
|
|
|
|
if (!q->tx_waiting) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (virtio_net_started(n, queue_status) && !n->vhost_started) {
|
|
|
|
if (q->tx_timer) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(q->tx_timer,
|
|
|
|
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
|
2013-01-30 12:12:39 +01:00
|
|
|
} else {
|
|
|
|
qemu_bh_schedule(q->tx_bh);
|
|
|
|
}
|
2010-11-22 18:52:30 +01:00
|
|
|
} else {
|
2013-01-30 12:12:39 +01:00
|
|
|
if (q->tx_timer) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(q->tx_timer);
|
2013-01-30 12:12:39 +01:00
|
|
|
} else {
|
|
|
|
qemu_bh_cancel(q->tx_bh);
|
|
|
|
}
|
2010-11-22 18:52:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static void virtio_net_set_link_status(NetClientState *nc)
|
2009-01-08 20:46:33 +01:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2009-01-08 20:46:33 +01:00
|
|
|
uint16_t old_status = n->status;
|
|
|
|
|
2009-11-25 19:49:11 +01:00
|
|
|
if (nc->link_down)
|
2009-01-08 20:46:33 +01:00
|
|
|
n->status &= ~VIRTIO_NET_S_LINK_UP;
|
|
|
|
else
|
|
|
|
n->status |= VIRTIO_NET_S_LINK_UP;
|
|
|
|
|
|
|
|
if (n->status != old_status)
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_notify_config(vdev);
|
2010-09-27 18:41:30 +02:00
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_net_set_status(vdev, vdev->status);
|
2009-01-08 20:46:33 +01:00
|
|
|
}
|
|
|
|
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
static void rxfilter_notify(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
|
|
|
|
|
|
|
if (nc->rxfilter_notify_enabled) {
|
2013-11-18 16:32:17 +01:00
|
|
|
gchar *path = object_get_canonical_path(OBJECT(n->qdev));
|
2014-06-18 08:43:48 +02:00
|
|
|
qapi_event_send_nic_rx_filter_changed(!!n->netclient_name,
|
|
|
|
n->netclient_name, path, &error_abort);
|
2013-11-18 16:32:17 +01:00
|
|
|
g_free(path);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
|
|
|
|
/* disable event notification to avoid events flooding */
|
|
|
|
nc->rxfilter_notify_enabled = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *mac_strdup_printf(const uint8_t *mac)
|
|
|
|
{
|
|
|
|
return g_strdup_printf("%.2x:%.2x:%.2x:%.2x:%.2x:%.2x", mac[0],
|
|
|
|
mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
|
|
}
|
|
|
|
|
2014-03-26 01:19:43 +01:00
|
|
|
static intList *get_vlan_table(VirtIONet *n)
|
|
|
|
{
|
|
|
|
intList *list, *entry;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
list = NULL;
|
|
|
|
for (i = 0; i < MAX_VLAN >> 5; i++) {
|
|
|
|
for (j = 0; n->vlans[i] && j <= 0x1f; j++) {
|
|
|
|
if (n->vlans[i] & (1U << j)) {
|
|
|
|
entry = g_malloc0(sizeof(*entry));
|
|
|
|
entry->value = (i << 5) + j;
|
|
|
|
entry->next = list;
|
|
|
|
list = entry;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
static RxFilterInfo *virtio_net_query_rxfilter(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2014-03-26 01:19:43 +01:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
RxFilterInfo *info;
|
|
|
|
strList *str_list, *entry;
|
2014-03-26 01:19:43 +01:00
|
|
|
int i;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
|
|
|
|
info = g_malloc0(sizeof(*info));
|
|
|
|
info->name = g_strdup(nc->name);
|
|
|
|
info->promiscuous = n->promisc;
|
|
|
|
|
|
|
|
if (n->nouni) {
|
|
|
|
info->unicast = RX_STATE_NONE;
|
|
|
|
} else if (n->alluni) {
|
|
|
|
info->unicast = RX_STATE_ALL;
|
|
|
|
} else {
|
|
|
|
info->unicast = RX_STATE_NORMAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n->nomulti) {
|
|
|
|
info->multicast = RX_STATE_NONE;
|
|
|
|
} else if (n->allmulti) {
|
|
|
|
info->multicast = RX_STATE_ALL;
|
|
|
|
} else {
|
|
|
|
info->multicast = RX_STATE_NORMAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
info->broadcast_allowed = n->nobcast;
|
|
|
|
info->multicast_overflow = n->mac_table.multi_overflow;
|
|
|
|
info->unicast_overflow = n->mac_table.uni_overflow;
|
|
|
|
|
|
|
|
info->main_mac = mac_strdup_printf(n->mac);
|
|
|
|
|
|
|
|
str_list = NULL;
|
|
|
|
for (i = 0; i < n->mac_table.first_multi; i++) {
|
|
|
|
entry = g_malloc0(sizeof(*entry));
|
|
|
|
entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
|
|
|
|
entry->next = str_list;
|
|
|
|
str_list = entry;
|
|
|
|
}
|
|
|
|
info->unicast_table = str_list;
|
|
|
|
|
|
|
|
str_list = NULL;
|
|
|
|
for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
|
|
|
|
entry = g_malloc0(sizeof(*entry));
|
|
|
|
entry->value = mac_strdup_printf(n->mac_table.macs + i * ETH_ALEN);
|
|
|
|
entry->next = str_list;
|
|
|
|
str_list = entry;
|
|
|
|
}
|
|
|
|
info->multicast_table = str_list;
|
2014-03-26 01:19:43 +01:00
|
|
|
info->vlan_table = get_vlan_table(n);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
|
2014-03-26 01:19:43 +01:00
|
|
|
if (!((1 << VIRTIO_NET_F_CTRL_VLAN) & vdev->guest_features)) {
|
|
|
|
info->vlan = RX_STATE_ALL;
|
|
|
|
} else if (!info->vlan_table) {
|
|
|
|
info->vlan = RX_STATE_NONE;
|
|
|
|
} else {
|
|
|
|
info->vlan = RX_STATE_NORMAL;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* enable event notification after query */
|
|
|
|
nc->rxfilter_notify_enabled = 1;
|
|
|
|
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:20 +01:00
|
|
|
static void virtio_net_reset(VirtIODevice *vdev)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2009-02-05 23:36:20 +01:00
|
|
|
|
|
|
|
/* Reset back to compatibility mode */
|
|
|
|
n->promisc = 1;
|
|
|
|
n->allmulti = 0;
|
2009-06-05 22:47:18 +02:00
|
|
|
n->alluni = 0;
|
|
|
|
n->nomulti = 0;
|
|
|
|
n->nouni = 0;
|
|
|
|
n->nobcast = 0;
|
2013-01-30 12:12:39 +01:00
|
|
|
/* multiqueue is disabled by default */
|
|
|
|
n->curr_queues = 1;
|
2014-05-20 08:01:44 +02:00
|
|
|
timer_del(n->announce_timer);
|
|
|
|
n->announce_counter = 0;
|
|
|
|
n->status &= ~VIRTIO_NET_S_ANNOUNCE;
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2009-02-05 23:36:32 +01:00
|
|
|
/* Flush any MAC and VLAN filter table state */
|
2009-02-05 23:36:28 +01:00
|
|
|
n->mac_table.in_use = 0;
|
2009-06-05 22:47:13 +02:00
|
|
|
n->mac_table.first_multi = 0;
|
2009-06-05 22:47:08 +02:00
|
|
|
n->mac_table.multi_overflow = 0;
|
|
|
|
n->mac_table.uni_overflow = 0;
|
2009-02-05 23:36:28 +01:00
|
|
|
memset(n->mac_table.macs, 0, MAC_TABLE_ENTRIES * ETH_ALEN);
|
2013-01-16 10:37:40 +01:00
|
|
|
memcpy(&n->mac[0], &n->nic->conf->macaddr, sizeof(n->mac));
|
2013-09-17 10:45:36 +02:00
|
|
|
qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
|
2009-02-05 23:36:32 +01:00
|
|
|
memset(n->vlans, 0, MAX_VLAN >> 3);
|
2009-02-05 23:36:20 +01:00
|
|
|
}
|
|
|
|
|
2012-09-24 17:04:21 +02:00
|
|
|
static void peer_test_vnet_hdr(VirtIONet *n)
|
2009-10-22 18:43:45 +02:00
|
|
|
{
|
2013-01-30 12:12:22 +01:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
|
|
|
if (!nc->peer) {
|
2012-09-24 17:04:21 +02:00
|
|
|
return;
|
2013-01-30 12:12:22 +01:00
|
|
|
}
|
2009-10-22 18:43:45 +02:00
|
|
|
|
2014-02-20 12:14:07 +01:00
|
|
|
n->has_vnet_hdr = qemu_has_vnet_hdr(nc->peer);
|
2012-09-24 17:04:21 +02:00
|
|
|
}
|
2009-10-22 18:43:45 +02:00
|
|
|
|
2012-09-24 17:04:21 +02:00
|
|
|
static int peer_has_vnet_hdr(VirtIONet *n)
|
|
|
|
{
|
2009-10-22 18:43:45 +02:00
|
|
|
return n->has_vnet_hdr;
|
|
|
|
}
|
|
|
|
|
2009-10-22 18:43:50 +02:00
|
|
|
static int peer_has_ufo(VirtIONet *n)
|
|
|
|
{
|
|
|
|
if (!peer_has_vnet_hdr(n))
|
|
|
|
return 0;
|
|
|
|
|
2014-02-20 12:14:07 +01:00
|
|
|
n->has_ufo = qemu_has_ufo(qemu_get_queue(n->nic)->peer);
|
2009-10-22 18:43:50 +02:00
|
|
|
|
|
|
|
return n->has_ufo;
|
|
|
|
}
|
|
|
|
|
2012-09-24 21:05:03 +02:00
|
|
|
static void virtio_net_set_mrg_rx_bufs(VirtIONet *n, int mergeable_rx_bufs)
|
|
|
|
{
|
2013-01-30 12:12:39 +01:00
|
|
|
int i;
|
|
|
|
NetClientState *nc;
|
|
|
|
|
2012-09-24 21:05:03 +02:00
|
|
|
n->mergeable_rx_bufs = mergeable_rx_bufs;
|
|
|
|
|
|
|
|
n->guest_hdr_len = n->mergeable_rx_bufs ?
|
|
|
|
sizeof(struct virtio_net_hdr_mrg_rxbuf) : sizeof(struct virtio_net_hdr);
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
nc = qemu_get_subqueue(n->nic, i);
|
|
|
|
|
|
|
|
if (peer_has_vnet_hdr(n) &&
|
2014-02-20 12:14:07 +01:00
|
|
|
qemu_has_vnet_hdr_len(nc->peer, n->guest_hdr_len)) {
|
|
|
|
qemu_set_vnet_hdr_len(nc->peer, n->guest_hdr_len);
|
2013-01-30 12:12:39 +01:00
|
|
|
n->host_hdr_len = n->guest_hdr_len;
|
|
|
|
}
|
2012-09-24 21:05:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
static int peer_attach(VirtIONet *n, int index)
|
|
|
|
{
|
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, index);
|
|
|
|
|
|
|
|
if (!nc->peer) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return tap_enable(nc->peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int peer_detach(VirtIONet *n, int index)
|
|
|
|
{
|
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, index);
|
|
|
|
|
|
|
|
if (!nc->peer) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nc->peer->info->type != NET_CLIENT_OPTIONS_KIND_TAP) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return tap_disable(nc->peer);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_net_set_queues(VirtIONet *n)
|
|
|
|
{
|
|
|
|
int i;
|
2014-02-11 01:12:02 +01:00
|
|
|
int r;
|
2013-01-30 12:12:39 +01:00
|
|
|
|
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
if (i < n->curr_queues) {
|
2014-02-11 01:12:02 +01:00
|
|
|
r = peer_attach(n, i);
|
|
|
|
assert(!r);
|
2013-01-30 12:12:39 +01:00
|
|
|
} else {
|
2014-02-11 01:12:02 +01:00
|
|
|
r = peer_detach(n, i);
|
|
|
|
assert(!r);
|
2013-01-30 12:12:39 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-25 09:24:23 +02:00
|
|
|
static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue);
|
2013-01-30 12:12:39 +01:00
|
|
|
|
2010-01-10 12:52:53 +01:00
|
|
|
static uint32_t virtio_net_get_features(VirtIODevice *vdev, uint32_t features)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:22 +01:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2010-01-12 19:50:17 +01:00
|
|
|
features |= (1 << VIRTIO_NET_F_MAC);
|
|
|
|
|
2012-09-24 17:04:21 +02:00
|
|
|
if (!peer_has_vnet_hdr(n)) {
|
2010-01-10 12:52:53 +01:00
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_CSUM);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO4);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_HOST_TSO6);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_HOST_ECN);
|
|
|
|
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_GUEST_CSUM);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO4);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_GUEST_TSO6);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_GUEST_ECN);
|
|
|
|
}
|
2009-10-22 18:43:45 +02:00
|
|
|
|
2010-01-10 12:52:53 +01:00
|
|
|
if (!peer_has_vnet_hdr(n) || !peer_has_ufo(n)) {
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_GUEST_UFO);
|
|
|
|
features &= ~(0x1 << VIRTIO_NET_F_HOST_UFO);
|
2009-10-22 18:43:45 +02:00
|
|
|
}
|
|
|
|
|
2014-05-27 14:05:08 +02:00
|
|
|
if (!get_vhost_net(nc->peer)) {
|
2010-03-17 12:08:42 +01:00
|
|
|
return features;
|
|
|
|
}
|
2014-05-27 14:05:08 +02:00
|
|
|
return vhost_net_get_features(get_vhost_net(nc->peer), features);
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2009-04-05 19:40:08 +02:00
|
|
|
static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
|
|
|
|
{
|
|
|
|
uint32_t features = 0;
|
|
|
|
|
|
|
|
/* Linux kernel 2.6.25. It understood MAC (as everyone must),
|
|
|
|
* but also these: */
|
|
|
|
features |= (1 << VIRTIO_NET_F_MAC);
|
2009-10-29 16:34:15 +01:00
|
|
|
features |= (1 << VIRTIO_NET_F_CSUM);
|
|
|
|
features |= (1 << VIRTIO_NET_F_HOST_TSO4);
|
|
|
|
features |= (1 << VIRTIO_NET_F_HOST_TSO6);
|
|
|
|
features |= (1 << VIRTIO_NET_F_HOST_ECN);
|
2009-04-05 19:40:08 +02:00
|
|
|
|
2010-01-10 12:52:53 +01:00
|
|
|
return features;
|
2009-04-05 19:40:08 +02:00
|
|
|
}
|
|
|
|
|
2013-05-20 10:18:14 +02:00
|
|
|
static void virtio_net_apply_guest_offloads(VirtIONet *n)
|
|
|
|
{
|
2014-02-20 12:14:09 +01:00
|
|
|
qemu_set_offload(qemu_get_queue(n->nic)->peer,
|
2013-05-20 10:18:14 +02:00
|
|
|
!!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_CSUM)),
|
|
|
|
!!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO4)),
|
|
|
|
!!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_TSO6)),
|
|
|
|
!!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_ECN)),
|
|
|
|
!!(n->curr_guest_offloads & (1ULL << VIRTIO_NET_F_GUEST_UFO)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint64_t virtio_net_guest_offloads_by_features(uint32_t features)
|
|
|
|
{
|
|
|
|
static const uint64_t guest_offloads_mask =
|
|
|
|
(1ULL << VIRTIO_NET_F_GUEST_CSUM) |
|
|
|
|
(1ULL << VIRTIO_NET_F_GUEST_TSO4) |
|
|
|
|
(1ULL << VIRTIO_NET_F_GUEST_TSO6) |
|
|
|
|
(1ULL << VIRTIO_NET_F_GUEST_ECN) |
|
|
|
|
(1ULL << VIRTIO_NET_F_GUEST_UFO);
|
|
|
|
|
|
|
|
return guest_offloads_mask & features;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint64_t virtio_net_supported_guest_offloads(VirtIONet *n)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
|
|
|
return virtio_net_guest_offloads_by_features(vdev->guest_features);
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
static void virtio_net_set_features(VirtIODevice *vdev, uint32_t features)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
int i;
|
|
|
|
|
2013-04-25 09:24:23 +02:00
|
|
|
virtio_net_set_multiqueue(n, !!(features & (1 << VIRTIO_NET_F_MQ)));
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2012-09-24 21:05:03 +02:00
|
|
|
virtio_net_set_mrg_rx_bufs(n, !!(features & (1 << VIRTIO_NET_F_MRG_RXBUF)));
|
2009-10-22 18:43:47 +02:00
|
|
|
|
|
|
|
if (n->has_vnet_hdr) {
|
2013-05-20 10:18:14 +02:00
|
|
|
n->curr_guest_offloads =
|
|
|
|
virtio_net_guest_offloads_by_features(features);
|
|
|
|
virtio_net_apply_guest_offloads(n);
|
2009-10-22 18:43:47 +02:00
|
|
|
}
|
2013-01-30 12:12:39 +01:00
|
|
|
|
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, i);
|
|
|
|
|
2014-05-27 14:05:08 +02:00
|
|
|
if (!get_vhost_net(nc->peer)) {
|
2013-01-30 12:12:39 +01:00
|
|
|
continue;
|
|
|
|
}
|
2014-05-27 14:05:08 +02:00
|
|
|
vhost_net_ack_features(get_vhost_net(nc->peer), features);
|
2010-03-31 20:20:31 +02:00
|
|
|
}
|
2014-03-26 11:29:52 +01:00
|
|
|
|
|
|
|
if ((1 << VIRTIO_NET_F_CTRL_VLAN) & features) {
|
|
|
|
memset(n->vlans, 0, MAX_VLAN >> 3);
|
|
|
|
} else {
|
|
|
|
memset(n->vlans, 0xff, MAX_VLAN >> 3);
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:20 +01:00
|
|
|
static int virtio_net_handle_rx_mode(VirtIONet *n, uint8_t cmd,
|
2013-01-22 16:44:44 +01:00
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
2009-02-05 23:36:20 +01:00
|
|
|
{
|
|
|
|
uint8_t on;
|
2013-01-22 16:44:44 +01:00
|
|
|
size_t s;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
2009-02-05 23:36:20 +01:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &on, sizeof(on));
|
|
|
|
if (s != sizeof(on)) {
|
|
|
|
return VIRTIO_NET_ERR;
|
2009-02-05 23:36:20 +01:00
|
|
|
}
|
|
|
|
|
2013-01-22 16:44:46 +01:00
|
|
|
if (cmd == VIRTIO_NET_CTRL_RX_PROMISC) {
|
2009-02-05 23:36:20 +01:00
|
|
|
n->promisc = on;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (cmd == VIRTIO_NET_CTRL_RX_ALLMULTI) {
|
2009-02-05 23:36:20 +01:00
|
|
|
n->allmulti = on;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (cmd == VIRTIO_NET_CTRL_RX_ALLUNI) {
|
2009-06-05 22:47:18 +02:00
|
|
|
n->alluni = on;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (cmd == VIRTIO_NET_CTRL_RX_NOMULTI) {
|
2009-06-05 22:47:18 +02:00
|
|
|
n->nomulti = on;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (cmd == VIRTIO_NET_CTRL_RX_NOUNI) {
|
2009-06-05 22:47:18 +02:00
|
|
|
n->nouni = on;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (cmd == VIRTIO_NET_CTRL_RX_NOBCAST) {
|
2009-06-05 22:47:18 +02:00
|
|
|
n->nobcast = on;
|
2013-01-22 16:44:44 +01:00
|
|
|
} else {
|
2009-02-05 23:36:20 +01:00
|
|
|
return VIRTIO_NET_ERR;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
2009-02-05 23:36:20 +01:00
|
|
|
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
rxfilter_notify(nc);
|
|
|
|
|
2009-02-05 23:36:20 +01:00
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
}
|
|
|
|
|
2013-05-20 10:18:14 +02:00
|
|
|
static int virtio_net_handle_offloads(VirtIONet *n, uint8_t cmd,
|
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
|
|
|
{
|
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
|
|
|
uint64_t offloads;
|
|
|
|
size_t s;
|
|
|
|
|
|
|
|
if (!((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features)) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &offloads, sizeof(offloads));
|
|
|
|
if (s != sizeof(offloads)) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd == VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET) {
|
|
|
|
uint64_t supported_offloads;
|
|
|
|
|
|
|
|
if (!n->has_vnet_hdr) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
supported_offloads = virtio_net_supported_guest_offloads(n);
|
|
|
|
if (offloads & ~supported_offloads) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
n->curr_guest_offloads = offloads;
|
|
|
|
virtio_net_apply_guest_offloads(n);
|
|
|
|
|
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
} else {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:28 +01:00
|
|
|
static int virtio_net_handle_mac(VirtIONet *n, uint8_t cmd,
|
2013-01-22 16:44:44 +01:00
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
2009-02-05 23:36:28 +01:00
|
|
|
{
|
|
|
|
struct virtio_net_ctrl_mac mac_data;
|
2013-01-22 16:44:44 +01:00
|
|
|
size_t s;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2013-01-22 16:44:45 +01:00
|
|
|
if (cmd == VIRTIO_NET_CTRL_MAC_ADDR_SET) {
|
|
|
|
if (iov_size(iov, iov_cnt) != sizeof(n->mac)) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &n->mac, sizeof(n->mac));
|
|
|
|
assert(s == sizeof(n->mac));
|
2013-01-30 12:12:22 +01:00
|
|
|
qemu_format_nic_info_str(qemu_get_queue(n->nic), n->mac);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
rxfilter_notify(nc);
|
|
|
|
|
2013-01-22 16:44:45 +01:00
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
}
|
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
if (cmd != VIRTIO_NET_CTRL_MAC_TABLE_SET) {
|
2009-02-05 23:36:28 +01:00
|
|
|
return VIRTIO_NET_ERR;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2013-11-11 04:48:36 +01:00
|
|
|
int in_use = 0;
|
|
|
|
int first_multi = 0;
|
|
|
|
uint8_t uni_overflow = 0;
|
|
|
|
uint8_t multi_overflow = 0;
|
|
|
|
uint8_t *macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
|
|
|
|
sizeof(mac_data.entries));
|
|
|
|
mac_data.entries = ldl_p(&mac_data.entries);
|
|
|
|
if (s != sizeof(mac_data.entries)) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
|
|
|
iov_discard_front(&iov, &iov_cnt, s);
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
if (mac_data.entries * ETH_ALEN > iov_size(iov, iov_cnt)) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
2009-02-05 23:36:28 +01:00
|
|
|
|
|
|
|
if (mac_data.entries <= MAC_TABLE_ENTRIES) {
|
2013-11-11 04:48:36 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, macs,
|
2013-01-22 16:44:44 +01:00
|
|
|
mac_data.entries * ETH_ALEN);
|
|
|
|
if (s != mac_data.entries * ETH_ALEN) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
2013-11-11 04:48:36 +01:00
|
|
|
in_use += mac_data.entries;
|
2009-02-05 23:36:28 +01:00
|
|
|
} else {
|
2013-11-11 04:48:36 +01:00
|
|
|
uni_overflow = 1;
|
2009-02-05 23:36:28 +01:00
|
|
|
}
|
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
iov_discard_front(&iov, &iov_cnt, mac_data.entries * ETH_ALEN);
|
|
|
|
|
2013-11-11 04:48:36 +01:00
|
|
|
first_multi = in_use;
|
2009-06-05 22:47:13 +02:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &mac_data.entries,
|
|
|
|
sizeof(mac_data.entries));
|
|
|
|
mac_data.entries = ldl_p(&mac_data.entries);
|
|
|
|
if (s != sizeof(mac_data.entries)) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
iov_discard_front(&iov, &iov_cnt, s);
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
if (mac_data.entries * ETH_ALEN != iov_size(iov, iov_cnt)) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2013-01-22 16:44:44 +01:00
|
|
|
}
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2014-04-11 14:18:08 +02:00
|
|
|
if (mac_data.entries <= MAC_TABLE_ENTRIES - in_use) {
|
2013-11-11 04:48:36 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &macs[in_use * ETH_ALEN],
|
2013-01-22 16:44:44 +01:00
|
|
|
mac_data.entries * ETH_ALEN);
|
|
|
|
if (s != mac_data.entries * ETH_ALEN) {
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
goto error;
|
2009-06-05 22:47:08 +02:00
|
|
|
}
|
2013-11-11 04:48:36 +01:00
|
|
|
in_use += mac_data.entries;
|
2013-01-22 16:44:44 +01:00
|
|
|
} else {
|
2013-11-11 04:48:36 +01:00
|
|
|
multi_overflow = 1;
|
2009-02-05 23:36:28 +01:00
|
|
|
}
|
|
|
|
|
2013-11-11 04:48:36 +01:00
|
|
|
n->mac_table.in_use = in_use;
|
|
|
|
n->mac_table.first_multi = first_multi;
|
|
|
|
n->mac_table.uni_overflow = uni_overflow;
|
|
|
|
n->mac_table.multi_overflow = multi_overflow;
|
|
|
|
memcpy(n->mac_table.macs, macs, MAC_TABLE_ENTRIES * ETH_ALEN);
|
|
|
|
g_free(macs);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
rxfilter_notify(nc);
|
|
|
|
|
2009-02-05 23:36:28 +01:00
|
|
|
return VIRTIO_NET_OK;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
|
|
|
|
error:
|
2013-11-11 04:48:36 +01:00
|
|
|
g_free(macs);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
return VIRTIO_NET_ERR;
|
2009-02-05 23:36:28 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:32 +01:00
|
|
|
static int virtio_net_handle_vlan_table(VirtIONet *n, uint8_t cmd,
|
2013-01-22 16:44:44 +01:00
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
2009-02-05 23:36:32 +01:00
|
|
|
{
|
|
|
|
uint16_t vid;
|
2013-01-22 16:44:44 +01:00
|
|
|
size_t s;
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
NetClientState *nc = qemu_get_queue(n->nic);
|
2009-02-05 23:36:32 +01:00
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &vid, sizeof(vid));
|
|
|
|
vid = lduw_p(&vid);
|
|
|
|
if (s != sizeof(vid)) {
|
2009-02-05 23:36:32 +01:00
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vid >= MAX_VLAN)
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
|
|
|
|
if (cmd == VIRTIO_NET_CTRL_VLAN_ADD)
|
|
|
|
n->vlans[vid >> 5] |= (1U << (vid & 0x1f));
|
|
|
|
else if (cmd == VIRTIO_NET_CTRL_VLAN_DEL)
|
|
|
|
n->vlans[vid >> 5] &= ~(1U << (vid & 0x1f));
|
|
|
|
else
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
rxfilter_notify(nc);
|
|
|
|
|
2009-02-05 23:36:32 +01:00
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
}
|
|
|
|
|
2014-05-20 08:01:44 +02:00
|
|
|
static int virtio_net_handle_announce(VirtIONet *n, uint8_t cmd,
|
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
|
|
|
{
|
|
|
|
if (cmd == VIRTIO_NET_CTRL_ANNOUNCE_ACK &&
|
|
|
|
n->status & VIRTIO_NET_S_ANNOUNCE) {
|
|
|
|
n->status &= ~VIRTIO_NET_S_ANNOUNCE;
|
|
|
|
if (n->announce_counter) {
|
|
|
|
timer_mod(n->announce_timer,
|
|
|
|
qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) +
|
|
|
|
self_announce_delay(n->announce_counter));
|
|
|
|
}
|
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
} else {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
static int virtio_net_handle_mq(VirtIONet *n, uint8_t cmd,
|
2013-03-06 06:50:27 +01:00
|
|
|
struct iovec *iov, unsigned int iov_cnt)
|
2013-01-30 12:12:39 +01:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2013-03-06 06:50:27 +01:00
|
|
|
struct virtio_net_ctrl_mq mq;
|
|
|
|
size_t s;
|
|
|
|
uint16_t queues;
|
2013-01-30 12:12:39 +01:00
|
|
|
|
2013-03-06 06:50:27 +01:00
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &mq, sizeof(mq));
|
|
|
|
if (s != sizeof(mq)) {
|
2013-01-30 12:12:39 +01:00
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cmd != VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
2013-03-06 06:50:27 +01:00
|
|
|
queues = lduw_p(&mq.virtqueue_pairs);
|
2013-01-30 12:12:39 +01:00
|
|
|
|
2013-03-06 06:50:27 +01:00
|
|
|
if (queues < VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN ||
|
|
|
|
queues > VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX ||
|
|
|
|
queues > n->max_queues ||
|
2013-01-30 12:12:39 +01:00
|
|
|
!n->multiqueue) {
|
|
|
|
return VIRTIO_NET_ERR;
|
|
|
|
}
|
|
|
|
|
2013-03-06 06:50:27 +01:00
|
|
|
n->curr_queues = queues;
|
2013-01-30 12:12:39 +01:00
|
|
|
/* stop the backend before changing the number of queues to avoid handling a
|
|
|
|
* disabled queue */
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_net_set_status(vdev, vdev->status);
|
2013-01-30 12:12:39 +01:00
|
|
|
virtio_net_set_queues(n);
|
|
|
|
|
|
|
|
return VIRTIO_NET_OK;
|
|
|
|
}
|
2009-02-05 23:36:16 +01:00
|
|
|
static void virtio_net_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2009-02-05 23:36:16 +01:00
|
|
|
struct virtio_net_ctrl_hdr ctrl;
|
|
|
|
virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
|
|
|
|
VirtQueueElement elem;
|
2013-01-22 16:44:44 +01:00
|
|
|
size_t s;
|
|
|
|
struct iovec *iov;
|
|
|
|
unsigned int iov_cnt;
|
2009-02-05 23:36:16 +01:00
|
|
|
|
|
|
|
while (virtqueue_pop(vq, &elem)) {
|
2013-01-22 16:44:44 +01:00
|
|
|
if (iov_size(elem.in_sg, elem.in_num) < sizeof(status) ||
|
|
|
|
iov_size(elem.out_sg, elem.out_num) < sizeof(ctrl)) {
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net ctrl missing headers");
|
2009-02-05 23:36:16 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
iov = elem.out_sg;
|
|
|
|
iov_cnt = elem.out_num;
|
|
|
|
s = iov_to_buf(iov, iov_cnt, 0, &ctrl, sizeof(ctrl));
|
|
|
|
iov_discard_front(&iov, &iov_cnt, sizeof(ctrl));
|
|
|
|
if (s != sizeof(ctrl)) {
|
|
|
|
status = VIRTIO_NET_ERR;
|
2013-01-22 16:44:46 +01:00
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_RX) {
|
2013-01-22 16:44:44 +01:00
|
|
|
status = virtio_net_handle_rx_mode(n, ctrl.cmd, iov, iov_cnt);
|
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_MAC) {
|
|
|
|
status = virtio_net_handle_mac(n, ctrl.cmd, iov, iov_cnt);
|
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_VLAN) {
|
|
|
|
status = virtio_net_handle_vlan_table(n, ctrl.cmd, iov, iov_cnt);
|
2014-05-20 08:01:44 +02:00
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_ANNOUNCE) {
|
|
|
|
status = virtio_net_handle_announce(n, ctrl.cmd, iov, iov_cnt);
|
2013-01-30 12:12:39 +01:00
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_MQ) {
|
2013-03-06 06:50:27 +01:00
|
|
|
status = virtio_net_handle_mq(n, ctrl.cmd, iov, iov_cnt);
|
2013-05-20 10:18:14 +02:00
|
|
|
} else if (ctrl.class == VIRTIO_NET_CTRL_GUEST_OFFLOADS) {
|
|
|
|
status = virtio_net_handle_offloads(n, ctrl.cmd, iov, iov_cnt);
|
2009-02-05 23:36:16 +01:00
|
|
|
}
|
|
|
|
|
2013-01-22 16:44:44 +01:00
|
|
|
s = iov_from_buf(elem.in_sg, elem.in_num, 0, &status, sizeof(status));
|
|
|
|
assert(s == sizeof(status));
|
2009-02-05 23:36:16 +01:00
|
|
|
|
|
|
|
virtqueue_push(vq, &elem, sizeof(status));
|
|
|
|
virtio_notify(vdev, vq);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
/* RX */
|
|
|
|
|
|
|
|
static void virtio_net_handle_rx(VirtIODevice *vdev, VirtQueue *vq)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
int queue_index = vq2q(virtio_get_queue_index(vq));
|
2009-04-29 14:40:02 +02:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
qemu_flush_queued_packets(qemu_get_subqueue(n->nic, queue_index));
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static int virtio_net_can_receive(NetClientState *nc)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q = virtio_net_get_subqueue(nc);
|
2013-01-30 12:12:38 +01:00
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!vdev->vm_running) {
|
2010-11-22 18:52:19 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2009-10-27 19:16:38 +01:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
if (nc->queue_index >= n->curr_queues) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
if (!virtio_queue_ready(q->rx_vq) ||
|
2013-04-11 16:30:01 +02:00
|
|
|
!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
|
2008-12-17 20:13:11 +01:00
|
|
|
return 0;
|
2013-01-30 12:12:38 +01:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-10-27 19:16:38 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
static int virtio_net_has_buffers(VirtIONetQueue *q, int bufsize)
|
2009-10-27 19:16:38 +01:00
|
|
|
{
|
2013-01-30 12:12:38 +01:00
|
|
|
VirtIONet *n = q->n;
|
|
|
|
if (virtio_queue_empty(q->rx_vq) ||
|
2008-12-17 20:13:11 +01:00
|
|
|
(n->mergeable_rx_bufs &&
|
2013-01-30 12:12:38 +01:00
|
|
|
!virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
|
|
|
|
virtio_queue_set_notification(q->rx_vq, 1);
|
2010-02-08 17:10:01 +01:00
|
|
|
|
|
|
|
/* To avoid a race condition where the guest has made some buffers
|
|
|
|
* available after the above check but before notification was
|
|
|
|
* enabled, check for available buffers again.
|
|
|
|
*/
|
2013-01-30 12:12:38 +01:00
|
|
|
if (virtio_queue_empty(q->rx_vq) ||
|
2010-02-08 17:10:01 +01:00
|
|
|
(n->mergeable_rx_bufs &&
|
2013-01-30 12:12:38 +01:00
|
|
|
!virtqueue_avail_bytes(q->rx_vq, bufsize, 0))) {
|
2010-02-08 17:10:01 +01:00
|
|
|
return 0;
|
2013-01-30 12:12:38 +01:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtio_queue_set_notification(q->rx_vq, 0);
|
2008-12-17 20:13:11 +01:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-06-24 19:11:32 +02:00
|
|
|
static void virtio_net_hdr_swap(struct virtio_net_hdr *hdr)
|
|
|
|
{
|
|
|
|
tswap16s(&hdr->hdr_len);
|
|
|
|
tswap16s(&hdr->gso_size);
|
|
|
|
tswap16s(&hdr->csum_start);
|
|
|
|
tswap16s(&hdr->csum_offset);
|
|
|
|
}
|
|
|
|
|
2009-10-22 18:43:48 +02:00
|
|
|
/* dhclient uses AF_PACKET but doesn't pass auxdata to the kernel so
|
|
|
|
* it never finds out that the packets don't have valid checksums. This
|
|
|
|
* causes dhclient to get upset. Fedora's carried a patch for ages to
|
|
|
|
* fix this with Xen but it hasn't appeared in an upstream release of
|
|
|
|
* dhclient yet.
|
|
|
|
*
|
|
|
|
* To avoid breaking existing guests, we catch udp packets and add
|
|
|
|
* checksums. This is terrible but it's better than hacking the guest
|
|
|
|
* kernels.
|
|
|
|
*
|
|
|
|
* N.B. if we introduce a zero-copy API, this operation is no longer free so
|
|
|
|
* we should provide a mechanism to disable it to avoid polluting the host
|
|
|
|
* cache.
|
|
|
|
*/
|
|
|
|
static void work_around_broken_dhclient(struct virtio_net_hdr *hdr,
|
2012-09-24 13:14:16 +02:00
|
|
|
uint8_t *buf, size_t size)
|
2009-10-22 18:43:48 +02:00
|
|
|
{
|
|
|
|
if ((hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && /* missing csum */
|
|
|
|
(size > 27 && size < 1500) && /* normal sized MTU */
|
|
|
|
(buf[12] == 0x08 && buf[13] == 0x00) && /* ethertype == IPv4 */
|
|
|
|
(buf[23] == 17) && /* ip.protocol == UDP */
|
|
|
|
(buf[34] == 0 && buf[35] == 67)) { /* udp.srcport == bootps */
|
2012-09-24 13:14:16 +02:00
|
|
|
net_checksum_calculate(buf, size);
|
2009-10-22 18:43:48 +02:00
|
|
|
hdr->flags &= ~VIRTIO_NET_HDR_F_NEEDS_CSUM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-09-24 13:24:17 +02:00
|
|
|
static void receive_header(VirtIONet *n, const struct iovec *iov, int iov_cnt,
|
|
|
|
const void *buf, size_t size)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2009-10-22 18:43:45 +02:00
|
|
|
if (n->has_vnet_hdr) {
|
2012-09-24 13:14:16 +02:00
|
|
|
/* FIXME this cast is evil */
|
|
|
|
void *wbuf = (void *)buf;
|
2012-09-24 13:24:17 +02:00
|
|
|
work_around_broken_dhclient(wbuf, wbuf + n->host_hdr_len,
|
|
|
|
size - n->host_hdr_len);
|
2014-06-24 19:11:32 +02:00
|
|
|
virtio_net_hdr_swap(wbuf);
|
2012-09-24 13:24:17 +02:00
|
|
|
iov_from_buf(iov, iov_cnt, 0, buf, sizeof(struct virtio_net_hdr));
|
2012-09-24 13:14:16 +02:00
|
|
|
} else {
|
|
|
|
struct virtio_net_hdr hdr = {
|
|
|
|
.flags = 0,
|
|
|
|
.gso_type = VIRTIO_NET_HDR_GSO_NONE
|
|
|
|
};
|
|
|
|
iov_from_buf(iov, iov_cnt, 0, &hdr, sizeof hdr);
|
2009-10-22 18:43:45 +02:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:24 +01:00
|
|
|
static int receive_filter(VirtIONet *n, const uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
static const uint8_t bcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
2009-02-05 23:36:32 +01:00
|
|
|
static const uint8_t vlan[] = {0x81, 0x00};
|
2009-02-05 23:36:24 +01:00
|
|
|
uint8_t *ptr = (uint8_t *)buf;
|
2009-02-05 23:36:28 +01:00
|
|
|
int i;
|
2009-02-05 23:36:24 +01:00
|
|
|
|
|
|
|
if (n->promisc)
|
|
|
|
return 1;
|
|
|
|
|
2012-09-24 16:27:27 +02:00
|
|
|
ptr += n->host_hdr_len;
|
2009-10-22 18:43:45 +02:00
|
|
|
|
2009-02-05 23:36:32 +01:00
|
|
|
if (!memcmp(&ptr[12], vlan, sizeof(vlan))) {
|
|
|
|
int vid = be16_to_cpup((uint16_t *)(ptr + 14)) & 0xfff;
|
|
|
|
if (!(n->vlans[vid >> 5] & (1U << (vid & 0x1f))))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-05 22:47:02 +02:00
|
|
|
if (ptr[0] & 1) { // multicast
|
|
|
|
if (!memcmp(ptr, bcast, sizeof(bcast))) {
|
2009-06-05 22:47:18 +02:00
|
|
|
return !n->nobcast;
|
|
|
|
} else if (n->nomulti) {
|
|
|
|
return 0;
|
2009-06-05 22:47:08 +02:00
|
|
|
} else if (n->allmulti || n->mac_table.multi_overflow) {
|
2009-06-05 22:47:02 +02:00
|
|
|
return 1;
|
|
|
|
}
|
2009-06-05 22:47:13 +02:00
|
|
|
|
|
|
|
for (i = n->mac_table.first_multi; i < n->mac_table.in_use; i++) {
|
|
|
|
if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2009-06-05 22:47:02 +02:00
|
|
|
} else { // unicast
|
2009-06-05 22:47:18 +02:00
|
|
|
if (n->nouni) {
|
|
|
|
return 0;
|
|
|
|
} else if (n->alluni || n->mac_table.uni_overflow) {
|
2009-06-05 22:47:08 +02:00
|
|
|
return 1;
|
|
|
|
} else if (!memcmp(ptr, n->mac, ETH_ALEN)) {
|
2009-06-05 22:47:02 +02:00
|
|
|
return 1;
|
|
|
|
}
|
2009-02-05 23:36:24 +01:00
|
|
|
|
2009-06-05 22:47:13 +02:00
|
|
|
for (i = 0; i < n->mac_table.first_multi; i++) {
|
|
|
|
if (!memcmp(ptr, &n->mac_table.macs[i * ETH_ALEN], ETH_ALEN)) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
2009-02-05 23:36:28 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:24 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static ssize_t virtio_net_receive(NetClientState *nc, const uint8_t *buf, size_t size)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q = virtio_net_get_subqueue(nc);
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2012-09-24 13:17:13 +02:00
|
|
|
struct iovec mhdr_sg[VIRTQUEUE_MAX_SIZE];
|
|
|
|
struct virtio_net_hdr_mrg_rxbuf mhdr;
|
|
|
|
unsigned mhdr_cnt = 0;
|
2012-09-24 13:14:16 +02:00
|
|
|
size_t offset, i, guest_offset;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
if (!virtio_net_can_receive(nc)) {
|
2009-10-27 19:16:38 +01:00
|
|
|
return -1;
|
2013-01-30 12:12:22 +01:00
|
|
|
}
|
2009-10-27 19:16:38 +01:00
|
|
|
|
2010-06-06 17:53:10 +02:00
|
|
|
/* hdr_len refers to the header we supply to the guest */
|
2013-01-30 12:12:38 +01:00
|
|
|
if (!virtio_net_has_buffers(q, size + n->guest_hdr_len - n->host_hdr_len)) {
|
2009-04-29 14:40:02 +02:00
|
|
|
return 0;
|
2013-01-30 12:12:38 +01:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-02-05 23:36:24 +01:00
|
|
|
if (!receive_filter(n, buf, size))
|
2009-05-18 14:40:55 +02:00
|
|
|
return size;
|
2009-02-05 23:36:24 +01:00
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
offset = i = 0;
|
|
|
|
|
|
|
|
while (offset < size) {
|
|
|
|
VirtQueueElement elem;
|
|
|
|
int len, total;
|
2012-09-24 13:14:16 +02:00
|
|
|
const struct iovec *sg = elem.in_sg;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2010-01-13 11:54:43 +01:00
|
|
|
total = 0;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
if (virtqueue_pop(q->rx_vq, &elem) == 0) {
|
2008-12-17 20:13:11 +01:00
|
|
|
if (i == 0)
|
2009-05-18 14:40:55 +02:00
|
|
|
return -1;
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net unexpected empty queue: "
|
2010-06-22 15:22:49 +02:00
|
|
|
"i %zd mergeable %d offset %zd, size %zd, "
|
2010-11-15 21:44:37 +01:00
|
|
|
"guest hdr len %zd, host hdr len %zd guest features 0x%x",
|
2010-06-22 15:22:49 +02:00
|
|
|
i, n->mergeable_rx_bufs, offset, size,
|
2013-04-11 16:30:01 +02:00
|
|
|
n->guest_hdr_len, n->host_hdr_len, vdev->guest_features);
|
2008-12-17 20:13:11 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (elem.in_num < 1) {
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net receive queue contains no in buffers");
|
2008-12-17 20:13:11 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i == 0) {
|
2012-09-24 13:26:55 +02:00
|
|
|
assert(offset == 0);
|
2012-09-24 13:17:13 +02:00
|
|
|
if (n->mergeable_rx_bufs) {
|
|
|
|
mhdr_cnt = iov_copy(mhdr_sg, ARRAY_SIZE(mhdr_sg),
|
|
|
|
sg, elem.in_num,
|
|
|
|
offsetof(typeof(mhdr), num_buffers),
|
|
|
|
sizeof(mhdr.num_buffers));
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2012-09-24 13:26:55 +02:00
|
|
|
receive_header(n, sg, elem.in_num, buf, size);
|
|
|
|
offset = n->host_hdr_len;
|
2012-09-24 12:12:25 +02:00
|
|
|
total += n->guest_hdr_len;
|
2012-09-24 13:14:16 +02:00
|
|
|
guest_offset = n->guest_hdr_len;
|
|
|
|
} else {
|
|
|
|
guest_offset = 0;
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* copy in packet. ugh */
|
2012-09-24 13:14:16 +02:00
|
|
|
len = iov_from_buf(sg, elem.in_num, guest_offset,
|
change iov_* function prototypes to be more appropriate
Reorder arguments to be more natural, readable and
consistent with other iov_* functions, and change
argument names, from:
iov_from_buf(iov, iov_cnt, buf, iov_off, size)
to
iov_from_buf(iov, iov_cnt, offset, buf, bytes)
The result becomes natural English:
copy data to this `iov' vector with `iov_cnt'
elements starting at byte offset `offset'
from memory buffer `buf', processing `bytes'
bytes max.
(Try to read the original prototype this way).
Also change iov_clear() to more general iov_memset()
(it uses memset() internally anyway).
While at it, add comments to the header file
describing what the routines actually does.
The patch only renames argumens in the header, but
keeps old names in the implementation. The next
patch will touch actual code to match.
Now, it might look wrong to pay so much attention
to so small things. But we've so many badly designed
interfaces already so the whole thing becomes rather
confusing or error prone. One example of this is
previous commit and small discussion which emerged
from it, with an outcome that the utility functions
like these aren't well-understdandable, leading to
strange usage cases. That's why I paid quite some
attention to this set of functions and a few
others in subsequent patches.
Signed-off-by: Michael Tokarev <mjt@tls.msk.ru>
2012-03-11 15:05:12 +01:00
|
|
|
buf + offset, size - offset);
|
2008-12-17 20:13:11 +01:00
|
|
|
total += len;
|
2010-06-22 15:22:49 +02:00
|
|
|
offset += len;
|
|
|
|
/* If buffers can't be merged, at this point we
|
|
|
|
* must have consumed the complete packet.
|
|
|
|
* Otherwise, drop it. */
|
|
|
|
if (!n->mergeable_rx_bufs && offset < size) {
|
|
|
|
#if 0
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net truncated non-mergeable packet: "
|
|
|
|
"i %zd mergeable %d offset %zd, size %zd, "
|
|
|
|
"guest hdr len %zd, host hdr len %zd",
|
|
|
|
i, n->mergeable_rx_bufs,
|
2012-09-24 12:12:25 +02:00
|
|
|
offset, size, n->guest_hdr_len, n->host_hdr_len);
|
2010-06-22 15:22:49 +02:00
|
|
|
#endif
|
|
|
|
return size;
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
|
|
|
/* signal other side */
|
2013-01-30 12:12:38 +01:00
|
|
|
virtqueue_fill(q->rx_vq, &elem, total, i++);
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2012-09-24 13:17:13 +02:00
|
|
|
if (mhdr_cnt) {
|
|
|
|
stw_p(&mhdr.num_buffers, i);
|
|
|
|
iov_from_buf(mhdr_sg, mhdr_cnt,
|
|
|
|
0,
|
|
|
|
&mhdr.num_buffers, sizeof mhdr.num_buffers);
|
2011-01-25 11:55:14 +01:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtqueue_flush(q->rx_vq, i);
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_notify(vdev, q->rx_vq);
|
2009-05-18 14:40:55 +02:00
|
|
|
|
|
|
|
return size;
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
static int32_t virtio_net_flush_tx(VirtIONetQueue *q);
|
2009-06-18 19:21:36 +02:00
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static void virtio_net_tx_complete(NetClientState *nc, ssize_t len)
|
2009-06-18 19:21:36 +02:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q = virtio_net_get_subqueue(nc);
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2009-06-18 19:21:36 +02:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtqueue_push(q->tx_vq, &q->async_tx.elem, 0);
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_notify(vdev, q->tx_vq);
|
2009-06-18 19:21:36 +02:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
q->async_tx.elem.out_num = q->async_tx.len = 0;
|
2009-06-18 19:21:36 +02:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtio_queue_set_notification(q->tx_vq, 1);
|
|
|
|
virtio_net_flush_tx(q);
|
2009-06-18 19:21:36 +02:00
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
/* TX */
|
2013-01-30 12:12:38 +01:00
|
|
|
static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-01-30 12:12:38 +01:00
|
|
|
VirtIONet *n = q->n;
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2008-12-17 20:13:11 +01:00
|
|
|
VirtQueueElement elem;
|
2010-09-02 17:00:57 +02:00
|
|
|
int32_t num_packets = 0;
|
2013-01-30 12:12:39 +01:00
|
|
|
int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
|
2010-09-02 17:00:57 +02:00
|
|
|
return num_packets;
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
assert(vdev->vm_running);
|
2010-11-22 18:52:30 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
if (q->async_tx.elem.out_num) {
|
|
|
|
virtio_queue_set_notification(q->tx_vq, 0);
|
2010-09-02 17:00:57 +02:00
|
|
|
return num_packets;
|
2009-06-18 19:21:36 +02:00
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
while (virtqueue_pop(q->tx_vq, &elem)) {
|
2012-09-24 14:52:28 +02:00
|
|
|
ssize_t ret, len;
|
2008-12-17 20:13:11 +01:00
|
|
|
unsigned int out_num = elem.out_num;
|
|
|
|
struct iovec *out_sg = &elem.out_sg[0];
|
2012-09-24 14:52:28 +02:00
|
|
|
struct iovec sg[VIRTQUEUE_MAX_SIZE];
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2012-09-24 14:54:44 +02:00
|
|
|
if (out_num < 1) {
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net header not in first element");
|
2008-12-17 20:13:11 +01:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2014-06-24 19:11:32 +02:00
|
|
|
if (n->has_vnet_hdr) {
|
|
|
|
if (out_sg[0].iov_len < n->guest_hdr_len) {
|
|
|
|
error_report("virtio-net header incorrect");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
virtio_net_hdr_swap((void *) out_sg[0].iov_base);
|
|
|
|
}
|
|
|
|
|
2012-09-24 14:52:28 +02:00
|
|
|
/*
|
|
|
|
* If host wants to see the guest header as is, we can
|
|
|
|
* pass it on unchanged. Otherwise, copy just the parts
|
|
|
|
* that host is interested in.
|
|
|
|
*/
|
|
|
|
assert(n->host_hdr_len <= n->guest_hdr_len);
|
|
|
|
if (n->host_hdr_len != n->guest_hdr_len) {
|
|
|
|
unsigned sg_num = iov_copy(sg, ARRAY_SIZE(sg),
|
|
|
|
out_sg, out_num,
|
|
|
|
0, n->host_hdr_len);
|
|
|
|
sg_num += iov_copy(sg + sg_num, ARRAY_SIZE(sg) - sg_num,
|
|
|
|
out_sg, out_num,
|
|
|
|
n->guest_hdr_len, -1);
|
|
|
|
out_num = sg_num;
|
|
|
|
out_sg = sg;
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2012-09-24 14:54:44 +02:00
|
|
|
len = n->guest_hdr_len;
|
2012-09-24 14:52:28 +02:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
|
|
|
|
out_sg, out_num, virtio_net_tx_complete);
|
2009-06-18 19:21:36 +02:00
|
|
|
if (ret == 0) {
|
2013-01-30 12:12:38 +01:00
|
|
|
virtio_queue_set_notification(q->tx_vq, 0);
|
|
|
|
q->async_tx.elem = elem;
|
|
|
|
q->async_tx.len = len;
|
2010-09-02 17:00:57 +02:00
|
|
|
return -EBUSY;
|
2009-06-18 19:21:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
len += ret;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtqueue_push(q->tx_vq, &elem, 0);
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_notify(vdev, q->tx_vq);
|
2010-09-02 17:00:57 +02:00
|
|
|
|
|
|
|
if (++num_packets >= n->tx_burst) {
|
|
|
|
break;
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
2010-09-02 17:00:57 +02:00
|
|
|
return num_packets;
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2010-09-02 17:01:10 +02:00
|
|
|
static void virtio_net_handle_tx_timer(VirtIODevice *vdev, VirtQueue *vq)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2010-11-22 18:52:30 +01:00
|
|
|
/* This happens when device was stopped but VCPU wasn't. */
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!vdev->vm_running) {
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 1;
|
2010-11-22 18:52:30 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
if (q->tx_waiting) {
|
2008-12-17 20:13:11 +01:00
|
|
|
virtio_queue_set_notification(vq, 1);
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(q->tx_timer);
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 0;
|
|
|
|
virtio_net_flush_tx(q);
|
2008-12-17 20:13:11 +01:00
|
|
|
} else {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_mod(q->tx_timer,
|
|
|
|
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + n->tx_timeout);
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 1;
|
2008-12-17 20:13:11 +01:00
|
|
|
virtio_queue_set_notification(vq, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-02 17:01:10 +02:00
|
|
|
static void virtio_net_handle_tx_bh(VirtIODevice *vdev, VirtQueue *vq)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
VirtIONetQueue *q = &n->vqs[vq2q(virtio_get_queue_index(vq))];
|
2010-09-02 17:01:10 +02:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
if (unlikely(q->tx_waiting)) {
|
2010-09-02 17:01:10 +02:00
|
|
|
return;
|
|
|
|
}
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 1;
|
2010-11-22 18:52:30 +01:00
|
|
|
/* This happens when device was stopped but VCPU wasn't. */
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!vdev->vm_running) {
|
2010-11-22 18:52:30 +01:00
|
|
|
return;
|
|
|
|
}
|
2010-09-02 17:01:10 +02:00
|
|
|
virtio_queue_set_notification(vq, 0);
|
2013-01-30 12:12:38 +01:00
|
|
|
qemu_bh_schedule(q->tx_bh);
|
2010-09-02 17:01:10 +02:00
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
static void virtio_net_tx_timer(void *opaque)
|
|
|
|
{
|
2013-01-30 12:12:38 +01:00
|
|
|
VirtIONetQueue *q = opaque;
|
|
|
|
VirtIONet *n = q->n;
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
|
|
|
assert(vdev->vm_running);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 0;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
|
|
|
/* Just in case the driver is not ready on more */
|
2013-04-11 16:30:01 +02:00
|
|
|
if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
|
2008-12-17 20:13:11 +01:00
|
|
|
return;
|
2013-04-11 16:30:01 +02:00
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
virtio_queue_set_notification(q->tx_vq, 1);
|
|
|
|
virtio_net_flush_tx(q);
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
2010-09-02 17:01:10 +02:00
|
|
|
static void virtio_net_tx_bh(void *opaque)
|
|
|
|
{
|
2013-01-30 12:12:38 +01:00
|
|
|
VirtIONetQueue *q = opaque;
|
|
|
|
VirtIONet *n = q->n;
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2010-09-02 17:01:10 +02:00
|
|
|
int32_t ret;
|
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
assert(vdev->vm_running);
|
2010-11-22 18:52:30 +01:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
q->tx_waiting = 0;
|
2010-09-02 17:01:10 +02:00
|
|
|
|
|
|
|
/* Just in case the driver is not ready on more */
|
2013-04-11 16:30:01 +02:00
|
|
|
if (unlikely(!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))) {
|
2010-09-02 17:01:10 +02:00
|
|
|
return;
|
2013-04-11 16:30:01 +02:00
|
|
|
}
|
2010-09-02 17:01:10 +02:00
|
|
|
|
2013-01-30 12:12:38 +01:00
|
|
|
ret = virtio_net_flush_tx(q);
|
2010-09-02 17:01:10 +02:00
|
|
|
if (ret == -EBUSY) {
|
|
|
|
return; /* Notification re-enable handled by tx_complete */
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If we flush a full burst of packets, assume there are
|
|
|
|
* more coming and immediately reschedule */
|
|
|
|
if (ret >= n->tx_burst) {
|
2013-01-30 12:12:38 +01:00
|
|
|
qemu_bh_schedule(q->tx_bh);
|
|
|
|
q->tx_waiting = 1;
|
2010-09-02 17:01:10 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If less than a full burst, re-enable notification and flush
|
|
|
|
* anything that may have come in while we weren't looking. If
|
|
|
|
* we find something, assume the guest is still active and reschedule */
|
2013-01-30 12:12:38 +01:00
|
|
|
virtio_queue_set_notification(q->tx_vq, 1);
|
|
|
|
if (virtio_net_flush_tx(q) > 0) {
|
|
|
|
virtio_queue_set_notification(q->tx_vq, 0);
|
|
|
|
qemu_bh_schedule(q->tx_bh);
|
|
|
|
q->tx_waiting = 1;
|
2010-09-02 17:01:10 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-25 09:24:23 +02:00
|
|
|
static void virtio_net_set_multiqueue(VirtIONet *n, int multiqueue)
|
2013-01-30 12:12:39 +01:00
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2013-01-30 12:12:39 +01:00
|
|
|
int i, max = multiqueue ? n->max_queues : 1;
|
|
|
|
|
|
|
|
n->multiqueue = multiqueue;
|
|
|
|
|
|
|
|
for (i = 2; i <= n->max_queues * 2 + 1; i++) {
|
|
|
|
virtio_del_queue(vdev, i);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 1; i < max; i++) {
|
|
|
|
n->vqs[i].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
|
|
|
|
if (n->vqs[i].tx_timer) {
|
|
|
|
n->vqs[i].tx_vq =
|
|
|
|
virtio_add_queue(vdev, 256, virtio_net_handle_tx_timer);
|
2013-08-21 17:03:08 +02:00
|
|
|
n->vqs[i].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
|
2013-01-30 12:12:39 +01:00
|
|
|
virtio_net_tx_timer,
|
|
|
|
&n->vqs[i]);
|
|
|
|
} else {
|
|
|
|
n->vqs[i].tx_vq =
|
|
|
|
virtio_add_queue(vdev, 256, virtio_net_handle_tx_bh);
|
|
|
|
n->vqs[i].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
n->vqs[i].tx_waiting = 0;
|
|
|
|
n->vqs[i].n = n;
|
|
|
|
}
|
|
|
|
|
2013-04-25 09:24:23 +02:00
|
|
|
/* Note: Minux Guests (version 3.2.1) use ctrl vq but don't ack
|
|
|
|
* VIRTIO_NET_F_CTRL_VQ. Create ctrl vq unconditionally to avoid
|
|
|
|
* breaking them.
|
|
|
|
*/
|
|
|
|
n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
|
2013-01-30 12:12:39 +01:00
|
|
|
|
|
|
|
virtio_net_set_queues(n);
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
static void virtio_net_save(QEMUFile *f, void *opaque)
|
|
|
|
{
|
2013-01-30 12:12:40 +01:00
|
|
|
int i;
|
2008-12-17 20:13:11 +01:00
|
|
|
VirtIONet *n = opaque;
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2010-09-27 18:41:30 +02:00
|
|
|
/* At this point, backend must be stopped, otherwise
|
|
|
|
* it might keep writing to memory. */
|
|
|
|
assert(!n->vhost_started);
|
2013-04-11 16:30:01 +02:00
|
|
|
virtio_save(vdev, f);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-02-05 23:36:12 +01:00
|
|
|
qemu_put_buffer(f, n->mac, ETH_ALEN);
|
2013-01-30 12:12:40 +01:00
|
|
|
qemu_put_be32(f, n->vqs[0].tx_waiting);
|
2009-01-07 18:50:45 +01:00
|
|
|
qemu_put_be32(f, n->mergeable_rx_bufs);
|
2009-02-05 23:36:04 +01:00
|
|
|
qemu_put_be16(f, n->status);
|
2009-06-05 22:46:57 +02:00
|
|
|
qemu_put_byte(f, n->promisc);
|
|
|
|
qemu_put_byte(f, n->allmulti);
|
2009-02-05 23:36:28 +01:00
|
|
|
qemu_put_be32(f, n->mac_table.in_use);
|
|
|
|
qemu_put_buffer(f, n->mac_table.macs, n->mac_table.in_use * ETH_ALEN);
|
2009-02-05 23:36:32 +01:00
|
|
|
qemu_put_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
|
2009-10-22 18:43:45 +02:00
|
|
|
qemu_put_be32(f, n->has_vnet_hdr);
|
2009-06-05 22:47:08 +02:00
|
|
|
qemu_put_byte(f, n->mac_table.multi_overflow);
|
|
|
|
qemu_put_byte(f, n->mac_table.uni_overflow);
|
2009-06-05 22:47:18 +02:00
|
|
|
qemu_put_byte(f, n->alluni);
|
|
|
|
qemu_put_byte(f, n->nomulti);
|
|
|
|
qemu_put_byte(f, n->nouni);
|
|
|
|
qemu_put_byte(f, n->nobcast);
|
2009-10-22 18:43:50 +02:00
|
|
|
qemu_put_byte(f, n->has_ufo);
|
2013-01-30 12:12:40 +01:00
|
|
|
if (n->max_queues > 1) {
|
|
|
|
qemu_put_be16(f, n->max_queues);
|
|
|
|
qemu_put_be16(f, n->curr_queues);
|
|
|
|
for (i = 1; i < n->curr_queues; i++) {
|
|
|
|
qemu_put_be32(f, n->vqs[i].tx_waiting);
|
|
|
|
}
|
|
|
|
}
|
2013-05-20 10:18:14 +02:00
|
|
|
|
|
|
|
if ((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features) {
|
|
|
|
qemu_put_be64(f, n->curr_guest_offloads);
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int virtio_net_load(QEMUFile *f, void *opaque, int version_id)
|
|
|
|
{
|
|
|
|
VirtIONet *n = opaque;
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(n);
|
2013-01-30 12:12:40 +01:00
|
|
|
int ret, i, link_down;
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-02-05 23:36:04 +01:00
|
|
|
if (version_id < 2 || version_id > VIRTIO_NET_VM_VERSION)
|
2008-12-17 20:13:11 +01:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-04-11 16:30:01 +02:00
|
|
|
ret = virtio_load(vdev, f);
|
2012-05-16 12:21:35 +02:00
|
|
|
if (ret) {
|
|
|
|
return ret;
|
|
|
|
}
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-02-05 23:36:12 +01:00
|
|
|
qemu_get_buffer(f, n->mac, ETH_ALEN);
|
2013-01-30 12:12:40 +01:00
|
|
|
n->vqs[0].tx_waiting = qemu_get_be32(f);
|
2012-09-24 21:05:03 +02:00
|
|
|
|
|
|
|
virtio_net_set_mrg_rx_bufs(n, qemu_get_be32(f));
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2009-02-05 23:36:04 +01:00
|
|
|
if (version_id >= 3)
|
|
|
|
n->status = qemu_get_be16(f);
|
|
|
|
|
2009-02-05 23:36:20 +01:00
|
|
|
if (version_id >= 4) {
|
2009-06-05 22:46:57 +02:00
|
|
|
if (version_id < 8) {
|
|
|
|
n->promisc = qemu_get_be32(f);
|
|
|
|
n->allmulti = qemu_get_be32(f);
|
|
|
|
} else {
|
|
|
|
n->promisc = qemu_get_byte(f);
|
|
|
|
n->allmulti = qemu_get_byte(f);
|
|
|
|
}
|
2009-02-05 23:36:20 +01:00
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:28 +01:00
|
|
|
if (version_id >= 5) {
|
|
|
|
n->mac_table.in_use = qemu_get_be32(f);
|
|
|
|
/* MAC_TABLE_ENTRIES may be different from the saved image */
|
|
|
|
if (n->mac_table.in_use <= MAC_TABLE_ENTRIES) {
|
|
|
|
qemu_get_buffer(f, n->mac_table.macs,
|
|
|
|
n->mac_table.in_use * ETH_ALEN);
|
2014-04-28 15:08:21 +02:00
|
|
|
} else {
|
|
|
|
int64_t i;
|
|
|
|
|
|
|
|
/* Overflow detected - can happen if source has a larger MAC table.
|
|
|
|
* We simply set overflow flag so there's no need to maintain the
|
|
|
|
* table of addresses, discard them all.
|
|
|
|
* Note: 64 bit math to avoid integer overflow.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < (int64_t)n->mac_table.in_use * ETH_ALEN; ++i) {
|
|
|
|
qemu_get_byte(f);
|
|
|
|
}
|
2009-06-05 22:47:08 +02:00
|
|
|
n->mac_table.multi_overflow = n->mac_table.uni_overflow = 1;
|
2009-02-05 23:36:28 +01:00
|
|
|
n->mac_table.in_use = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-02-05 23:36:32 +01:00
|
|
|
if (version_id >= 6)
|
|
|
|
qemu_get_buffer(f, (uint8_t *)n->vlans, MAX_VLAN >> 3);
|
|
|
|
|
2009-10-22 18:43:45 +02:00
|
|
|
if (version_id >= 7) {
|
|
|
|
if (qemu_get_be32(f) && !peer_has_vnet_hdr(n)) {
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("virtio-net: saved image requires vnet_hdr=on");
|
2009-10-22 18:43:45 +02:00
|
|
|
return -1;
|
|
|
|
}
|
2009-06-05 22:46:52 +02:00
|
|
|
}
|
|
|
|
|
2009-06-05 22:47:08 +02:00
|
|
|
if (version_id >= 9) {
|
|
|
|
n->mac_table.multi_overflow = qemu_get_byte(f);
|
|
|
|
n->mac_table.uni_overflow = qemu_get_byte(f);
|
|
|
|
}
|
|
|
|
|
2009-06-05 22:47:18 +02:00
|
|
|
if (version_id >= 10) {
|
|
|
|
n->alluni = qemu_get_byte(f);
|
|
|
|
n->nomulti = qemu_get_byte(f);
|
|
|
|
n->nouni = qemu_get_byte(f);
|
|
|
|
n->nobcast = qemu_get_byte(f);
|
|
|
|
}
|
|
|
|
|
2009-10-22 18:43:50 +02:00
|
|
|
if (version_id >= 11) {
|
|
|
|
if (qemu_get_byte(f) && !peer_has_ufo(n)) {
|
2010-02-18 17:25:24 +01:00
|
|
|
error_report("virtio-net: saved image requires TUN_F_UFO support");
|
2009-10-22 18:43:50 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:40 +01:00
|
|
|
if (n->max_queues > 1) {
|
|
|
|
if (n->max_queues != qemu_get_be16(f)) {
|
|
|
|
error_report("virtio-net: different max_queues ");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
n->curr_queues = qemu_get_be16(f);
|
2014-04-03 18:50:56 +02:00
|
|
|
if (n->curr_queues > n->max_queues) {
|
|
|
|
error_report("virtio-net: curr_queues %x > max_queues %x",
|
|
|
|
n->curr_queues, n->max_queues);
|
|
|
|
return -1;
|
|
|
|
}
|
2013-01-30 12:12:40 +01:00
|
|
|
for (i = 1; i < n->curr_queues; i++) {
|
|
|
|
n->vqs[i].tx_waiting = qemu_get_be32(f);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-05-20 10:18:14 +02:00
|
|
|
if ((1 << VIRTIO_NET_F_CTRL_GUEST_OFFLOADS) & vdev->guest_features) {
|
|
|
|
n->curr_guest_offloads = qemu_get_be64(f);
|
|
|
|
} else {
|
|
|
|
n->curr_guest_offloads = virtio_net_supported_guest_offloads(n);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (peer_has_vnet_hdr(n)) {
|
|
|
|
virtio_net_apply_guest_offloads(n);
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:40 +01:00
|
|
|
virtio_net_set_queues(n);
|
|
|
|
|
2009-06-05 22:47:13 +02:00
|
|
|
/* Find the first multicast entry in the saved MAC filter */
|
|
|
|
for (i = 0; i < n->mac_table.in_use; i++) {
|
|
|
|
if (n->mac_table.macs[i * ETH_ALEN] & 1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
n->mac_table.first_multi = i;
|
2012-09-28 04:06:02 +02:00
|
|
|
|
|
|
|
/* nc.link_down can't be migrated, so infer link_down according
|
|
|
|
* to link status bit in n->status */
|
2013-01-30 12:12:40 +01:00
|
|
|
link_down = (n->status & VIRTIO_NET_S_LINK_UP) == 0;
|
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
qemu_get_subqueue(n->nic, i)->link_down = link_down;
|
|
|
|
}
|
2012-09-28 04:06:02 +02:00
|
|
|
|
2014-05-20 08:01:44 +02:00
|
|
|
if (vdev->guest_features & (0x1 << VIRTIO_NET_F_GUEST_ANNOUNCE) &&
|
|
|
|
vdev->guest_features & (0x1 << VIRTIO_NET_F_CTRL_VQ)) {
|
|
|
|
n->announce_counter = SELF_ANNOUNCE_ROUNDS;
|
|
|
|
timer_mod(n->announce_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL));
|
|
|
|
}
|
|
|
|
|
2008-12-17 20:13:11 +01:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static void virtio_net_cleanup(NetClientState *nc)
|
2009-04-17 19:11:08 +02:00
|
|
|
{
|
2013-01-30 12:12:23 +01:00
|
|
|
VirtIONet *n = qemu_get_nic_opaque(nc);
|
2009-04-17 19:11:08 +02:00
|
|
|
|
2009-11-25 19:49:11 +01:00
|
|
|
n->nic = NULL;
|
2009-04-17 19:11:08 +02:00
|
|
|
}
|
|
|
|
|
2009-11-25 19:49:11 +01:00
|
|
|
static NetClientInfo net_virtio_info = {
|
2012-07-17 16:17:12 +02:00
|
|
|
.type = NET_CLIENT_OPTIONS_KIND_NIC,
|
2009-11-25 19:49:11 +01:00
|
|
|
.size = sizeof(NICState),
|
|
|
|
.can_receive = virtio_net_can_receive,
|
|
|
|
.receive = virtio_net_receive,
|
2013-11-27 08:35:26 +01:00
|
|
|
.cleanup = virtio_net_cleanup,
|
2009-11-25 19:49:11 +01:00
|
|
|
.link_status_changed = virtio_net_set_link_status,
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
.query_rx_filter = virtio_net_query_rxfilter,
|
2009-11-25 19:49:11 +01:00
|
|
|
};
|
|
|
|
|
2012-12-24 16:37:01 +01:00
|
|
|
static bool virtio_net_guest_notifier_pending(VirtIODevice *vdev, int idx)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
|
2012-12-24 16:37:01 +01:00
|
|
|
assert(n->vhost_started);
|
2014-05-27 14:05:08 +02:00
|
|
|
return vhost_net_virtqueue_pending(get_vhost_net(nc->peer), idx);
|
2012-12-24 16:37:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_net_guest_notifier_mask(VirtIODevice *vdev, int idx,
|
|
|
|
bool mask)
|
|
|
|
{
|
2013-04-11 16:30:01 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(vdev);
|
2013-01-30 12:12:39 +01:00
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, vq2q(idx));
|
2012-12-24 16:37:01 +01:00
|
|
|
assert(n->vhost_started);
|
2014-05-27 14:05:08 +02:00
|
|
|
vhost_net_virtqueue_mask(get_vhost_net(nc->peer),
|
2012-12-24 16:37:01 +01:00
|
|
|
vdev, idx, mask);
|
|
|
|
}
|
|
|
|
|
2013-04-11 16:29:57 +02:00
|
|
|
void virtio_net_set_config_size(VirtIONet *n, uint32_t host_features)
|
2008-12-17 20:13:11 +01:00
|
|
|
{
|
2013-02-06 00:47:16 +01:00
|
|
|
int i, config_size = 0;
|
2013-04-25 09:26:54 +02:00
|
|
|
host_features |= (1 << VIRTIO_NET_F_MAC);
|
2013-02-06 00:47:16 +01:00
|
|
|
for (i = 0; feature_sizes[i].flags != 0; i++) {
|
|
|
|
if (host_features & feature_sizes[i].flags) {
|
|
|
|
config_size = MAX(feature_sizes[i].end, config_size);
|
|
|
|
}
|
|
|
|
}
|
2013-04-11 16:29:57 +02:00
|
|
|
n->config_size = config_size;
|
|
|
|
}
|
|
|
|
|
2013-05-15 14:12:49 +02:00
|
|
|
void virtio_net_set_netclient_name(VirtIONet *n, const char *name,
|
|
|
|
const char *type)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* The name can be NULL, the netclient name will be type.x.
|
|
|
|
*/
|
|
|
|
assert(type != NULL);
|
|
|
|
|
2014-06-06 18:43:29 +02:00
|
|
|
g_free(n->netclient_name);
|
|
|
|
g_free(n->netclient_type);
|
2014-06-06 18:43:30 +02:00
|
|
|
n->netclient_name = g_strdup(name);
|
2013-05-15 14:12:49 +02:00
|
|
|
n->netclient_type = g_strdup(type);
|
|
|
|
}
|
|
|
|
|
2013-07-30 02:36:06 +02:00
|
|
|
static void virtio_net_device_realize(DeviceState *dev, Error **errp)
|
2013-04-11 16:29:57 +02:00
|
|
|
{
|
2013-07-30 02:36:06 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
|
2013-07-30 05:02:48 +02:00
|
|
|
VirtIONet *n = VIRTIO_NET(dev);
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
NetClientState *nc;
|
2013-07-30 05:02:48 +02:00
|
|
|
int i;
|
2013-04-11 16:30:02 +02:00
|
|
|
|
2013-07-30 05:02:48 +02:00
|
|
|
virtio_init(vdev, "virtio-net", VIRTIO_ID_NET, n->config_size);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2014-05-26 12:04:08 +02:00
|
|
|
n->max_queues = MAX(n->nic_conf.peers.queues, 1);
|
2013-02-22 16:15:06 +01:00
|
|
|
n->vqs = g_malloc0(sizeof(VirtIONetQueue) * n->max_queues);
|
2013-04-11 16:30:01 +02:00
|
|
|
n->vqs[0].rx_vq = virtio_add_queue(vdev, 256, virtio_net_handle_rx);
|
2013-01-30 12:12:39 +01:00
|
|
|
n->curr_queues = 1;
|
|
|
|
n->vqs[0].n = n;
|
2013-04-11 16:30:02 +02:00
|
|
|
n->tx_timeout = n->net_conf.txtimer;
|
2010-09-02 17:01:10 +02:00
|
|
|
|
2013-04-11 16:30:02 +02:00
|
|
|
if (n->net_conf.tx && strcmp(n->net_conf.tx, "timer")
|
|
|
|
&& strcmp(n->net_conf.tx, "bh")) {
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("virtio-net: "
|
|
|
|
"Unknown option tx=%s, valid options: \"timer\" \"bh\"",
|
2013-04-11 16:30:02 +02:00
|
|
|
n->net_conf.tx);
|
2010-11-15 21:44:37 +01:00
|
|
|
error_report("Defaulting to \"bh\"");
|
2010-09-02 17:01:10 +02:00
|
|
|
}
|
|
|
|
|
2013-04-11 16:30:02 +02:00
|
|
|
if (n->net_conf.tx && !strcmp(n->net_conf.tx, "timer")) {
|
2013-04-11 16:30:01 +02:00
|
|
|
n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
|
2013-01-30 12:12:39 +01:00
|
|
|
virtio_net_handle_tx_timer);
|
2013-08-21 17:03:08 +02:00
|
|
|
n->vqs[0].tx_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, virtio_net_tx_timer,
|
2013-01-30 12:12:39 +01:00
|
|
|
&n->vqs[0]);
|
2010-09-02 17:01:10 +02:00
|
|
|
} else {
|
2013-04-11 16:30:01 +02:00
|
|
|
n->vqs[0].tx_vq = virtio_add_queue(vdev, 256,
|
2013-01-30 12:12:39 +01:00
|
|
|
virtio_net_handle_tx_bh);
|
|
|
|
n->vqs[0].tx_bh = qemu_bh_new(virtio_net_tx_bh, &n->vqs[0]);
|
2010-09-02 17:01:10 +02:00
|
|
|
}
|
2013-04-11 16:30:01 +02:00
|
|
|
n->ctrl_vq = virtio_add_queue(vdev, 64, virtio_net_handle_ctrl);
|
2013-04-11 16:30:02 +02:00
|
|
|
qemu_macaddr_default_if_unset(&n->nic_conf.macaddr);
|
|
|
|
memcpy(&n->mac[0], &n->nic_conf.macaddr, sizeof(n->mac));
|
2009-01-08 20:46:33 +01:00
|
|
|
n->status = VIRTIO_NET_S_LINK_UP;
|
2014-05-20 08:01:44 +02:00
|
|
|
n->announce_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL,
|
|
|
|
virtio_net_announce_timer, n);
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2013-05-15 14:12:49 +02:00
|
|
|
if (n->netclient_type) {
|
|
|
|
/*
|
|
|
|
* Happen when virtio_net_set_netclient_name has been called.
|
|
|
|
*/
|
|
|
|
n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
|
|
|
|
n->netclient_type, n->netclient_name, n);
|
|
|
|
} else {
|
|
|
|
n->nic = qemu_new_nic(&net_virtio_info, &n->nic_conf,
|
2013-07-30 05:02:48 +02:00
|
|
|
object_get_typename(OBJECT(dev)), dev->id, n);
|
2013-05-15 14:12:49 +02:00
|
|
|
}
|
|
|
|
|
2012-09-24 17:04:21 +02:00
|
|
|
peer_test_vnet_hdr(n);
|
|
|
|
if (peer_has_vnet_hdr(n)) {
|
2013-01-30 12:12:39 +01:00
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
2014-02-20 12:14:07 +01:00
|
|
|
qemu_using_vnet_hdr(qemu_get_subqueue(n->nic, i)->peer, true);
|
2013-01-30 12:12:39 +01:00
|
|
|
}
|
2012-09-24 17:04:21 +02:00
|
|
|
n->host_hdr_len = sizeof(struct virtio_net_hdr);
|
|
|
|
} else {
|
|
|
|
n->host_hdr_len = 0;
|
|
|
|
}
|
2009-11-25 19:49:11 +01:00
|
|
|
|
2013-04-11 16:30:02 +02:00
|
|
|
qemu_format_nic_info_str(qemu_get_queue(n->nic), n->nic_conf.macaddr.a);
|
2009-01-07 18:47:15 +01:00
|
|
|
|
2013-01-30 12:12:39 +01:00
|
|
|
n->vqs[0].tx_waiting = 0;
|
2013-04-11 16:30:02 +02:00
|
|
|
n->tx_burst = n->net_conf.txburst;
|
2012-09-24 21:05:03 +02:00
|
|
|
virtio_net_set_mrg_rx_bufs(n, 0);
|
2009-02-05 23:36:20 +01:00
|
|
|
n->promisc = 1; /* for compatibility */
|
2008-12-17 20:13:11 +01:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
n->mac_table.macs = g_malloc0(MAC_TABLE_ENTRIES * ETH_ALEN);
|
2009-02-05 23:36:28 +01:00
|
|
|
|
2011-08-21 05:09:37 +02:00
|
|
|
n->vlans = g_malloc0(MAX_VLAN >> 3);
|
2009-02-05 23:36:32 +01:00
|
|
|
|
net: add support of mac-programming over macvtap in QEMU side
Currently macvtap based macvlan device is working in promiscuous
mode, we want to implement mac-programming over macvtap through
Libvirt for better performance.
Design:
QEMU notifies Libvirt when rx-filter config is changed in guest,
then Libvirt query the rx-filter information by a monitor command,
and sync the change to macvtap device. Related rx-filter config
of the nic contains main mac, rx-mode items and vlan table.
This patch adds a QMP event to notify management of rx-filter change,
and adds a monitor command for management to query rx-filter
information.
Test:
If we repeatedly add/remove vlan, and change macaddr of vlan
interfaces in guest by a loop script.
Result:
The events will flood the QMP client(management), management takes
too much resource to process the events.
Event_throttle API (set rate to 1 ms) can avoid the events to flood
QMP client, but it could cause an unexpected delay (~1ms), guests
guests normally expect rx-filter updates immediately.
So we use a flag for each nic to avoid events flooding, the event
is emitted once until the query command is executed. The flag
implementation could not introduce unexpected delay.
There maybe exist an uncontrollable delay if we let Libvirt do the
real change, guests normally expect rx-filter updates immediately.
But it's another separate issue, we can investigate it when the
work in Libvirt side is done.
Michael S. Tsirkin: tweaked to enable events on start
Michael S. Tsirkin: fixed not to crash when no id
Michael S. Tsirkin: fold in patch:
"additional fixes for mac-programming feature"
Amos Kong: always notify QMP client if mactable is changed
Amos Kong: return NULL list if no net client supports rx-filter query
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Amos Kong <akong@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2013-06-14 09:45:52 +02:00
|
|
|
nc = qemu_get_queue(n->nic);
|
|
|
|
nc->rxfilter_notify_enabled = 1;
|
|
|
|
|
2013-07-30 05:02:48 +02:00
|
|
|
n->qdev = dev;
|
|
|
|
register_savevm(dev, "virtio-net", -1, VIRTIO_NET_VM_VERSION,
|
2008-12-17 20:13:11 +01:00
|
|
|
virtio_net_save, virtio_net_load, n);
|
2009-05-14 23:35:07 +02:00
|
|
|
|
2013-07-30 05:02:48 +02:00
|
|
|
add_boot_device_path(n->nic_conf.bootindex, dev, "/ethernet-phy@0");
|
2013-04-11 16:29:57 +02:00
|
|
|
}
|
|
|
|
|
2013-07-30 03:50:44 +02:00
|
|
|
static void virtio_net_device_unrealize(DeviceState *dev, Error **errp)
|
2013-04-11 16:29:57 +02:00
|
|
|
{
|
2013-07-30 03:50:44 +02:00
|
|
|
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
|
|
|
|
VirtIONet *n = VIRTIO_NET(dev);
|
2013-04-11 16:29:57 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
/* This will stop vhost backend if appropriate. */
|
|
|
|
virtio_net_set_status(vdev, 0);
|
|
|
|
|
2013-07-30 03:50:44 +02:00
|
|
|
unregister_savevm(dev, "virtio-net", n);
|
2013-04-11 16:29:57 +02:00
|
|
|
|
2014-06-06 18:43:29 +02:00
|
|
|
g_free(n->netclient_name);
|
|
|
|
n->netclient_name = NULL;
|
|
|
|
g_free(n->netclient_type);
|
|
|
|
n->netclient_type = NULL;
|
2013-05-15 14:12:49 +02:00
|
|
|
|
2013-04-11 16:29:57 +02:00
|
|
|
g_free(n->mac_table.macs);
|
|
|
|
g_free(n->vlans);
|
|
|
|
|
|
|
|
for (i = 0; i < n->max_queues; i++) {
|
|
|
|
VirtIONetQueue *q = &n->vqs[i];
|
|
|
|
NetClientState *nc = qemu_get_subqueue(n->nic, i);
|
|
|
|
|
|
|
|
qemu_purge_queued_packets(nc);
|
|
|
|
|
|
|
|
if (q->tx_timer) {
|
2013-08-21 17:03:08 +02:00
|
|
|
timer_del(q->tx_timer);
|
|
|
|
timer_free(q->tx_timer);
|
2013-11-06 09:58:08 +01:00
|
|
|
} else if (q->tx_bh) {
|
2013-04-11 16:29:57 +02:00
|
|
|
qemu_bh_delete(q->tx_bh);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-20 08:01:44 +02:00
|
|
|
timer_del(n->announce_timer);
|
|
|
|
timer_free(n->announce_timer);
|
2013-04-11 16:29:57 +02:00
|
|
|
g_free(n->vqs);
|
|
|
|
qemu_del_nic(n->nic);
|
2013-04-24 10:21:22 +02:00
|
|
|
virtio_cleanup(vdev);
|
2013-04-11 16:29:57 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void virtio_net_instance_init(Object *obj)
|
|
|
|
{
|
|
|
|
VirtIONet *n = VIRTIO_NET(obj);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The default config_size is sizeof(struct virtio_net_config).
|
|
|
|
* Can be overriden with virtio_net_set_config_size.
|
|
|
|
*/
|
|
|
|
n->config_size = sizeof(struct virtio_net_config);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Property virtio_net_properties[] = {
|
|
|
|
DEFINE_NIC_PROPERTIES(VirtIONet, nic_conf),
|
|
|
|
DEFINE_PROP_UINT32("x-txtimer", VirtIONet, net_conf.txtimer,
|
|
|
|
TX_TIMER_INTERVAL),
|
|
|
|
DEFINE_PROP_INT32("x-txburst", VirtIONet, net_conf.txburst, TX_BURST),
|
|
|
|
DEFINE_PROP_STRING("tx", VirtIONet, net_conf.tx),
|
|
|
|
DEFINE_PROP_END_OF_LIST(),
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_net_class_init(ObjectClass *klass, void *data)
|
|
|
|
{
|
|
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
|
|
VirtioDeviceClass *vdc = VIRTIO_DEVICE_CLASS(klass);
|
2013-07-30 02:36:06 +02:00
|
|
|
|
2013-04-11 16:29:57 +02:00
|
|
|
dc->props = virtio_net_properties;
|
2013-07-29 16:17:45 +02:00
|
|
|
set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
|
2013-07-30 02:36:06 +02:00
|
|
|
vdc->realize = virtio_net_device_realize;
|
2013-07-30 03:50:44 +02:00
|
|
|
vdc->unrealize = virtio_net_device_unrealize;
|
2013-04-11 16:29:57 +02:00
|
|
|
vdc->get_config = virtio_net_get_config;
|
|
|
|
vdc->set_config = virtio_net_set_config;
|
|
|
|
vdc->get_features = virtio_net_get_features;
|
|
|
|
vdc->set_features = virtio_net_set_features;
|
|
|
|
vdc->bad_features = virtio_net_bad_features;
|
|
|
|
vdc->reset = virtio_net_reset;
|
|
|
|
vdc->set_status = virtio_net_set_status;
|
|
|
|
vdc->guest_notifier_mask = virtio_net_guest_notifier_mask;
|
|
|
|
vdc->guest_notifier_pending = virtio_net_guest_notifier_pending;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const TypeInfo virtio_net_info = {
|
|
|
|
.name = TYPE_VIRTIO_NET,
|
|
|
|
.parent = TYPE_VIRTIO_DEVICE,
|
|
|
|
.instance_size = sizeof(VirtIONet),
|
|
|
|
.instance_init = virtio_net_instance_init,
|
|
|
|
.class_init = virtio_net_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void virtio_register_types(void)
|
|
|
|
{
|
|
|
|
type_register_static(&virtio_net_info);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(virtio_register_types)
|