2010-03-17 12:08:17 +01:00
|
|
|
/*
|
|
|
|
* vhost-net support
|
|
|
|
*
|
|
|
|
* Copyright Red Hat, Inc. 2010
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Michael S. Tsirkin <mst@redhat.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
* the COPYING file in the top-level directory.
|
2012-01-13 17:44:23 +01:00
|
|
|
*
|
|
|
|
* Contributions after 2012-01-13 are licensed under the terms of the
|
|
|
|
* GNU GPL, version 2 or (at your option) any later version.
|
2010-03-17 12:08:17 +01:00
|
|
|
*/
|
|
|
|
|
2016-01-26 19:17:11 +01:00
|
|
|
#include "qemu/osdep.h"
|
2012-10-24 08:43:34 +02:00
|
|
|
#include "net/net.h"
|
2010-03-17 12:08:17 +01:00
|
|
|
#include "net/tap.h"
|
2014-06-10 12:02:16 +02:00
|
|
|
#include "net/vhost-user.h"
|
2010-03-17 12:08:17 +01:00
|
|
|
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/virtio-net.h"
|
|
|
|
#include "net/vhost_net.h"
|
2012-12-17 18:20:00 +01:00
|
|
|
#include "qemu/error-report.h"
|
2010-03-17 12:08:17 +01:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_VHOST_NET
|
|
|
|
#include <linux/vhost.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <linux/kvm.h>
|
|
|
|
#include <netpacket/packet.h>
|
|
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
|
|
|
|
|
2015-02-16 22:35:40 +01:00
|
|
|
#include "standard-headers/linux/virtio_ring.h"
|
2013-02-05 17:06:20 +01:00
|
|
|
#include "hw/virtio/vhost.h"
|
2013-04-24 10:21:21 +02:00
|
|
|
#include "hw/virtio/virtio-bus.h"
|
2015-06-17 15:23:49 +02:00
|
|
|
#include "hw/virtio/virtio-access.h"
|
2010-03-17 12:08:17 +01:00
|
|
|
|
|
|
|
struct vhost_net {
|
|
|
|
struct vhost_dev dev;
|
|
|
|
struct vhost_virtqueue vqs[2];
|
|
|
|
int backend;
|
2012-07-24 17:35:14 +02:00
|
|
|
NetClientState *nc;
|
2010-03-17 12:08:17 +01:00
|
|
|
};
|
|
|
|
|
2014-05-27 14:04:42 +02:00
|
|
|
/* Features supported by host kernel. */
|
|
|
|
static const int kernel_feature_bits[] = {
|
|
|
|
VIRTIO_F_NOTIFY_ON_EMPTY,
|
|
|
|
VIRTIO_RING_F_INDIRECT_DESC,
|
|
|
|
VIRTIO_RING_F_EVENT_IDX,
|
|
|
|
VIRTIO_NET_F_MRG_RXBUF,
|
2015-06-04 12:34:19 +02:00
|
|
|
VIRTIO_F_VERSION_1,
|
2014-05-27 14:04:42 +02:00
|
|
|
VHOST_INVALID_FEATURE_BIT
|
|
|
|
};
|
|
|
|
|
2014-05-27 14:06:16 +02:00
|
|
|
/* Features supported by others. */
|
2015-02-28 19:19:17 +01:00
|
|
|
static const int user_feature_bits[] = {
|
2014-05-27 14:06:16 +02:00
|
|
|
VIRTIO_F_NOTIFY_ON_EMPTY,
|
|
|
|
VIRTIO_RING_F_INDIRECT_DESC,
|
|
|
|
VIRTIO_RING_F_EVENT_IDX,
|
|
|
|
|
|
|
|
VIRTIO_F_ANY_LAYOUT,
|
2015-06-04 12:34:19 +02:00
|
|
|
VIRTIO_F_VERSION_1,
|
2014-05-27 14:06:16 +02:00
|
|
|
VIRTIO_NET_F_CSUM,
|
|
|
|
VIRTIO_NET_F_GUEST_CSUM,
|
|
|
|
VIRTIO_NET_F_GSO,
|
|
|
|
VIRTIO_NET_F_GUEST_TSO4,
|
|
|
|
VIRTIO_NET_F_GUEST_TSO6,
|
|
|
|
VIRTIO_NET_F_GUEST_ECN,
|
|
|
|
VIRTIO_NET_F_GUEST_UFO,
|
|
|
|
VIRTIO_NET_F_HOST_TSO4,
|
|
|
|
VIRTIO_NET_F_HOST_TSO6,
|
|
|
|
VIRTIO_NET_F_HOST_ECN,
|
|
|
|
VIRTIO_NET_F_HOST_UFO,
|
|
|
|
VIRTIO_NET_F_MRG_RXBUF,
|
|
|
|
|
2015-11-17 15:55:17 +01:00
|
|
|
/* This bit implies RARP isn't sent by QEMU out of band */
|
2015-10-09 17:17:31 +02:00
|
|
|
VIRTIO_NET_F_GUEST_ANNOUNCE,
|
|
|
|
|
2014-05-27 14:06:16 +02:00
|
|
|
VIRTIO_NET_F_MQ,
|
|
|
|
|
|
|
|
VHOST_INVALID_FEATURE_BIT
|
|
|
|
};
|
|
|
|
|
2014-05-27 14:04:42 +02:00
|
|
|
static const int *vhost_net_get_feature_bits(struct vhost_net *net)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
2014-05-27 14:04:42 +02:00
|
|
|
const int *feature_bits = 0;
|
|
|
|
|
|
|
|
switch (net->nc->info->type) {
|
|
|
|
case NET_CLIENT_OPTIONS_KIND_TAP:
|
|
|
|
feature_bits = kernel_feature_bits;
|
|
|
|
break;
|
2014-05-27 14:06:16 +02:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
|
|
|
|
feature_bits = user_feature_bits;
|
|
|
|
break;
|
2014-05-27 14:04:42 +02:00
|
|
|
default:
|
|
|
|
error_report("Feature bits not defined for this type: %d",
|
|
|
|
net->nc->info->type);
|
|
|
|
break;
|
2010-07-16 10:43:43 +02:00
|
|
|
}
|
2014-05-27 14:04:42 +02:00
|
|
|
|
|
|
|
return feature_bits;
|
|
|
|
}
|
|
|
|
|
2015-06-04 12:34:20 +02:00
|
|
|
uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features)
|
2014-05-27 14:04:42 +02:00
|
|
|
{
|
|
|
|
return vhost_get_features(&net->dev, vhost_net_get_feature_bits(net),
|
|
|
|
features);
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
|
2015-06-04 12:34:20 +02:00
|
|
|
void vhost_net_ack_features(struct vhost_net *net, uint64_t features)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
2014-09-03 08:25:30 +02:00
|
|
|
net->dev.acked_features = net->dev.backend_features;
|
2014-05-27 14:04:42 +02:00
|
|
|
vhost_ack_features(&net->dev, vhost_net_get_feature_bits(net), features);
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
|
2015-09-23 06:19:58 +02:00
|
|
|
uint64_t vhost_net_get_max_queues(VHostNetState *net)
|
|
|
|
{
|
|
|
|
return net->dev.max_queues;
|
|
|
|
}
|
|
|
|
|
2012-07-24 17:35:13 +02:00
|
|
|
static int vhost_net_get_fd(NetClientState *backend)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
switch (backend->info->type) {
|
2012-07-17 16:17:12 +02:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_TAP:
|
2010-03-17 12:08:17 +01:00
|
|
|
return tap_get_fd(backend);
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "vhost-net requires tap backend\n");
|
|
|
|
return -EBADFD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-27 14:05:22 +02:00
|
|
|
struct vhost_net *vhost_net_init(VhostNetOptions *options)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
int r;
|
2014-05-27 14:05:49 +02:00
|
|
|
bool backend_kernel = options->backend_type == VHOST_BACKEND_TYPE_KERNEL;
|
2011-08-21 05:09:37 +02:00
|
|
|
struct vhost_net *net = g_malloc(sizeof *net);
|
2014-05-27 14:05:22 +02:00
|
|
|
|
|
|
|
if (!options->net_backend) {
|
|
|
|
fprintf(stderr, "vhost-net requires net backend to be setup\n");
|
2010-03-17 12:08:17 +01:00
|
|
|
goto fail;
|
|
|
|
}
|
vhost-user: add multiple queue support
This patch is initially based a patch from Nikolay Nikolaev.
This patch adds vhost-user multiple queue support, by creating a nc
and vhost_net pair for each queue.
Qemu exits if find that the backend can't support the number of requested
queues (by providing queues=# option). The max number is queried by a
new message, VHOST_USER_GET_QUEUE_NUM, and is sent only when protocol
feature VHOST_USER_PROTOCOL_F_MQ is present first.
The max queue check is done at vhost-user initiation stage. We initiate
one queue first, which, in the meantime, also gets the max_queues the
backend supports.
In older version, it was reported that some messages are sent more times
than necessary. Here we came an agreement with Michael that we could
categorize vhost user messages to 2 types: non-vring specific messages,
which should be sent only once, and vring specific messages, which should
be sent per queue.
Here I introduced a helper function vhost_user_one_time_request(), which
lists following messages as non-vring specific messages:
VHOST_USER_SET_OWNER
VHOST_USER_RESET_DEVICE
VHOST_USER_SET_MEM_TABLE
VHOST_USER_GET_QUEUE_NUM
For above messages, we simply ignore them when they are not sent the first
time.
Signed-off-by: Nikolay Nikolaev <n.nikolaev@virtualopensystems.com>
Signed-off-by: Changchun Ouyang <changchun.ouyang@intel.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Jason Wang <jasowang@redhat.com>
Tested-by: Marcel Apfelbaum <marcel@redhat.com>
2015-09-23 06:20:00 +02:00
|
|
|
net->nc = options->net_backend;
|
2014-05-27 14:05:22 +02:00
|
|
|
|
2015-09-23 06:19:58 +02:00
|
|
|
net->dev.max_queues = 1;
|
vhost-user: add multiple queue support
This patch is initially based a patch from Nikolay Nikolaev.
This patch adds vhost-user multiple queue support, by creating a nc
and vhost_net pair for each queue.
Qemu exits if find that the backend can't support the number of requested
queues (by providing queues=# option). The max number is queried by a
new message, VHOST_USER_GET_QUEUE_NUM, and is sent only when protocol
feature VHOST_USER_PROTOCOL_F_MQ is present first.
The max queue check is done at vhost-user initiation stage. We initiate
one queue first, which, in the meantime, also gets the max_queues the
backend supports.
In older version, it was reported that some messages are sent more times
than necessary. Here we came an agreement with Michael that we could
categorize vhost user messages to 2 types: non-vring specific messages,
which should be sent only once, and vring specific messages, which should
be sent per queue.
Here I introduced a helper function vhost_user_one_time_request(), which
lists following messages as non-vring specific messages:
VHOST_USER_SET_OWNER
VHOST_USER_RESET_DEVICE
VHOST_USER_SET_MEM_TABLE
VHOST_USER_GET_QUEUE_NUM
For above messages, we simply ignore them when they are not sent the first
time.
Signed-off-by: Nikolay Nikolaev <n.nikolaev@virtualopensystems.com>
Signed-off-by: Changchun Ouyang <changchun.ouyang@intel.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Jason Wang <jasowang@redhat.com>
Tested-by: Marcel Apfelbaum <marcel@redhat.com>
2015-09-23 06:20:00 +02:00
|
|
|
net->dev.nvqs = 2;
|
|
|
|
net->dev.vqs = net->vqs;
|
2015-09-23 06:19:58 +02:00
|
|
|
|
2014-05-27 14:05:49 +02:00
|
|
|
if (backend_kernel) {
|
|
|
|
r = vhost_net_get_fd(options->net_backend);
|
|
|
|
if (r < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend)
|
2015-06-04 12:34:20 +02:00
|
|
|
? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR);
|
2014-05-27 14:05:49 +02:00
|
|
|
net->backend = r;
|
2015-09-23 06:19:56 +02:00
|
|
|
net->dev.protocol_features = 0;
|
2014-05-27 14:05:49 +02:00
|
|
|
} else {
|
|
|
|
net->dev.backend_features = 0;
|
2015-09-23 06:19:56 +02:00
|
|
|
net->dev.protocol_features = 0;
|
2014-05-27 14:05:49 +02:00
|
|
|
net->backend = -1;
|
2010-03-17 12:08:17 +01:00
|
|
|
|
vhost-user: add multiple queue support
This patch is initially based a patch from Nikolay Nikolaev.
This patch adds vhost-user multiple queue support, by creating a nc
and vhost_net pair for each queue.
Qemu exits if find that the backend can't support the number of requested
queues (by providing queues=# option). The max number is queried by a
new message, VHOST_USER_GET_QUEUE_NUM, and is sent only when protocol
feature VHOST_USER_PROTOCOL_F_MQ is present first.
The max queue check is done at vhost-user initiation stage. We initiate
one queue first, which, in the meantime, also gets the max_queues the
backend supports.
In older version, it was reported that some messages are sent more times
than necessary. Here we came an agreement with Michael that we could
categorize vhost user messages to 2 types: non-vring specific messages,
which should be sent only once, and vring specific messages, which should
be sent per queue.
Here I introduced a helper function vhost_user_one_time_request(), which
lists following messages as non-vring specific messages:
VHOST_USER_SET_OWNER
VHOST_USER_RESET_DEVICE
VHOST_USER_SET_MEM_TABLE
VHOST_USER_GET_QUEUE_NUM
For above messages, we simply ignore them when they are not sent the first
time.
Signed-off-by: Nikolay Nikolaev <n.nikolaev@virtualopensystems.com>
Signed-off-by: Changchun Ouyang <changchun.ouyang@intel.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>
Reviewed-by: Jason Wang <jasowang@redhat.com>
Tested-by: Marcel Apfelbaum <marcel@redhat.com>
2015-09-23 06:20:00 +02:00
|
|
|
/* vhost-user needs vq_index to initiate a specific queue pair */
|
|
|
|
net->dev.vq_index = net->nc->queue_index * net->dev.nvqs;
|
|
|
|
}
|
2012-12-24 16:37:01 +01:00
|
|
|
|
2014-05-27 14:05:22 +02:00
|
|
|
r = vhost_dev_init(&net->dev, options->opaque,
|
2015-06-16 10:18:59 +02:00
|
|
|
options->backend_type);
|
2010-03-17 12:08:17 +01:00
|
|
|
if (r < 0) {
|
|
|
|
goto fail;
|
|
|
|
}
|
2014-05-27 14:05:49 +02:00
|
|
|
if (backend_kernel) {
|
2014-09-11 23:55:48 +02:00
|
|
|
if (!qemu_has_vnet_hdr_len(options->net_backend,
|
|
|
|
sizeof(struct virtio_net_hdr_mrg_rxbuf))) {
|
2015-06-04 12:34:20 +02:00
|
|
|
net->dev.features &= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF);
|
2014-09-11 23:55:48 +02:00
|
|
|
}
|
2014-05-27 14:05:49 +02:00
|
|
|
if (~net->dev.features & net->dev.backend_features) {
|
|
|
|
fprintf(stderr, "vhost lacks feature mask %" PRIu64
|
|
|
|
" for backend\n",
|
|
|
|
(uint64_t)(~net->dev.features & net->dev.backend_features));
|
|
|
|
vhost_dev_cleanup(&net->dev);
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
/* Set sane init value. Override when guest acks. */
|
|
|
|
vhost_net_ack_features(net, 0);
|
|
|
|
return net;
|
|
|
|
fail:
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(net);
|
2010-03-17 12:08:17 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-08-19 06:56:29 +02:00
|
|
|
static void vhost_net_set_vq_index(struct vhost_net *net, int vq_index)
|
|
|
|
{
|
|
|
|
net->dev.vq_index = vq_index;
|
|
|
|
}
|
|
|
|
|
2015-06-17 15:23:49 +02:00
|
|
|
static int vhost_net_set_vnet_endian(VirtIODevice *dev, NetClientState *peer,
|
|
|
|
bool set)
|
|
|
|
{
|
|
|
|
int r = 0;
|
|
|
|
|
2015-08-17 11:48:29 +02:00
|
|
|
if (virtio_vdev_has_feature(dev, VIRTIO_F_VERSION_1) ||
|
2015-06-17 15:23:49 +02:00
|
|
|
(virtio_legacy_is_cross_endian(dev) && !virtio_is_big_endian(dev))) {
|
|
|
|
r = qemu_set_vnet_le(peer, set);
|
|
|
|
if (r) {
|
|
|
|
error_report("backend does not support LE vnet headers");
|
|
|
|
}
|
|
|
|
} else if (virtio_legacy_is_cross_endian(dev)) {
|
|
|
|
r = qemu_set_vnet_be(peer, set);
|
|
|
|
if (r) {
|
|
|
|
error_report("backend does not support BE vnet headers");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
static int vhost_net_start_one(struct vhost_net *net,
|
2014-08-19 06:56:29 +02:00
|
|
|
VirtIODevice *dev)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
struct vhost_vring_file file = { };
|
|
|
|
int r;
|
2011-08-11 09:21:18 +02:00
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
net->dev.nvqs = 2;
|
|
|
|
net->dev.vqs = net->vqs;
|
|
|
|
|
2011-08-11 09:21:18 +02:00
|
|
|
r = vhost_dev_enable_notifiers(&net->dev, dev);
|
|
|
|
if (r < 0) {
|
|
|
|
goto fail_notifiers;
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
|
|
|
|
r = vhost_dev_start(&net->dev, dev);
|
|
|
|
if (r < 0) {
|
2011-08-11 09:21:18 +02:00
|
|
|
goto fail_start;
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
|
2014-05-27 14:04:55 +02:00
|
|
|
if (net->nc->info->poll) {
|
|
|
|
net->nc->info->poll(net->nc, false);
|
|
|
|
}
|
|
|
|
|
2014-05-27 14:05:49 +02:00
|
|
|
if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
|
|
|
|
qemu_set_fd_handler(net->backend, NULL, NULL, NULL);
|
|
|
|
file.fd = net->backend;
|
|
|
|
for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
|
|
|
|
const VhostOps *vhost_ops = net->dev.vhost_ops;
|
2015-10-09 17:17:28 +02:00
|
|
|
r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
|
2014-05-27 14:05:49 +02:00
|
|
|
if (r < 0) {
|
|
|
|
r = -errno;
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
file.fd = -1;
|
2014-05-27 14:05:49 +02:00
|
|
|
if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
|
|
|
|
while (file.index-- > 0) {
|
|
|
|
const VhostOps *vhost_ops = net->dev.vhost_ops;
|
2015-10-09 17:17:28 +02:00
|
|
|
int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
|
2014-05-27 14:05:49 +02:00
|
|
|
assert(r >= 0);
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
2014-05-27 14:04:55 +02:00
|
|
|
if (net->nc->info->poll) {
|
|
|
|
net->nc->info->poll(net->nc, true);
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
vhost_dev_stop(&net->dev, dev);
|
2011-08-11 09:21:18 +02:00
|
|
|
fail_start:
|
|
|
|
vhost_dev_disable_notifiers(&net->dev, dev);
|
|
|
|
fail_notifiers:
|
2010-03-17 12:08:17 +01:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
static void vhost_net_stop_one(struct vhost_net *net,
|
|
|
|
VirtIODevice *dev)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
struct vhost_vring_file file = { .fd = -1 };
|
|
|
|
|
2014-05-27 14:05:49 +02:00
|
|
|
if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
|
|
|
|
for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
|
|
|
|
const VhostOps *vhost_ops = net->dev.vhost_ops;
|
2015-10-09 17:17:28 +02:00
|
|
|
int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
|
2014-05-27 14:05:49 +02:00
|
|
|
assert(r >= 0);
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
2014-05-27 14:04:55 +02:00
|
|
|
if (net->nc->info->poll) {
|
|
|
|
net->nc->info->poll(net->nc, true);
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
vhost_dev_stop(&net->dev, dev);
|
2011-08-11 09:21:18 +02:00
|
|
|
vhost_dev_disable_notifiers(&net->dev, dev);
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
int vhost_net_start(VirtIODevice *dev, NetClientState *ncs,
|
|
|
|
int total_queues)
|
|
|
|
{
|
2013-04-24 10:21:21 +02:00
|
|
|
BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
|
|
|
|
VirtioBusState *vbus = VIRTIO_BUS(qbus);
|
|
|
|
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
|
2016-01-13 20:26:25 +01:00
|
|
|
int r, e, i, j;
|
2013-01-30 12:12:35 +01:00
|
|
|
|
2013-04-24 10:21:21 +02:00
|
|
|
if (!k->set_guest_notifiers) {
|
error: Strip trailing '\n' from error string arguments (again)
Commit 6daf194d and be62a2eb got rid of a bunch, but they keep coming
back. Tracked down with this Coccinelle semantic patch:
@r@
expression err, eno, cls, fmt;
position p;
@@
(
error_report(fmt, ...)@p
|
error_set(err, cls, fmt, ...)@p
|
error_set_errno(err, eno, cls, fmt, ...)@p
|
error_setg(err, fmt, ...)@p
|
error_setg_errno(err, eno, fmt, ...)@p
)
@script:python@
fmt << r.fmt;
p << r.p;
@@
if "\\n" in str(fmt):
print "%s:%s:%s:%s" % (p[0].file, p[0].line, p[0].column, fmt)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-4-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:16 +01:00
|
|
|
error_report("binding does not support guest notifiers");
|
2016-01-13 20:26:25 +01:00
|
|
|
return -ENOSYS;
|
2013-01-30 12:12:35 +01:00
|
|
|
}
|
|
|
|
|
2016-01-13 20:26:25 +01:00
|
|
|
for (j = 0; j < total_queues; j++) {
|
|
|
|
r = vhost_net_set_vnet_endian(dev, ncs[j].peer, true);
|
|
|
|
if (r < 0) {
|
|
|
|
goto err_endian;
|
|
|
|
}
|
|
|
|
vhost_net_set_vq_index(get_vhost_net(ncs[j].peer), j * 2);
|
2013-01-30 12:12:35 +01:00
|
|
|
}
|
|
|
|
|
2013-04-24 10:21:21 +02:00
|
|
|
r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true);
|
2013-01-30 12:12:35 +01:00
|
|
|
if (r < 0) {
|
error: Strip trailing '\n' from error string arguments (again)
Commit 6daf194d and be62a2eb got rid of a bunch, but they keep coming
back. Tracked down with this Coccinelle semantic patch:
@r@
expression err, eno, cls, fmt;
position p;
@@
(
error_report(fmt, ...)@p
|
error_set(err, cls, fmt, ...)@p
|
error_set_errno(err, eno, cls, fmt, ...)@p
|
error_setg(err, fmt, ...)@p
|
error_setg_errno(err, eno, fmt, ...)@p
)
@script:python@
fmt << r.fmt;
p << r.p;
@@
if "\\n" in str(fmt):
print "%s:%s:%s:%s" % (p[0].file, p[0].line, p[0].column, fmt)
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Message-id: 1360354939-10994-4-git-send-email-armbru@redhat.com
Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
2013-02-08 21:22:16 +01:00
|
|
|
error_report("Error binding guest notifier: %d", -r);
|
2015-06-17 15:23:49 +02:00
|
|
|
goto err_endian;
|
2013-01-30 12:12:35 +01:00
|
|
|
}
|
|
|
|
|
2014-08-19 06:56:29 +02:00
|
|
|
for (i = 0; i < total_queues; i++) {
|
|
|
|
r = vhost_net_start_one(get_vhost_net(ncs[i].peer), dev);
|
|
|
|
|
|
|
|
if (r < 0) {
|
|
|
|
goto err_start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
return 0;
|
|
|
|
|
2014-08-19 06:56:29 +02:00
|
|
|
err_start:
|
2013-01-30 12:12:35 +01:00
|
|
|
while (--i >= 0) {
|
2014-05-27 14:05:08 +02:00
|
|
|
vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev);
|
2013-01-30 12:12:35 +01:00
|
|
|
}
|
2014-08-19 06:56:29 +02:00
|
|
|
e = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
|
|
|
|
if (e < 0) {
|
|
|
|
fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e);
|
|
|
|
fflush(stderr);
|
|
|
|
}
|
2015-06-17 15:23:49 +02:00
|
|
|
err_endian:
|
2016-01-13 20:26:25 +01:00
|
|
|
while (--j >= 0) {
|
|
|
|
vhost_net_set_vnet_endian(dev, ncs[j].peer, false);
|
|
|
|
}
|
2013-01-30 12:12:35 +01:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs,
|
|
|
|
int total_queues)
|
|
|
|
{
|
2013-04-24 10:21:21 +02:00
|
|
|
BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev)));
|
|
|
|
VirtioBusState *vbus = VIRTIO_BUS(qbus);
|
|
|
|
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
|
2013-01-30 12:12:35 +01:00
|
|
|
int i, r;
|
|
|
|
|
2014-08-19 06:56:29 +02:00
|
|
|
for (i = 0; i < total_queues; i++) {
|
|
|
|
vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev);
|
|
|
|
}
|
|
|
|
|
2013-04-24 10:21:21 +02:00
|
|
|
r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false);
|
2013-01-30 12:12:35 +01:00
|
|
|
if (r < 0) {
|
|
|
|
fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r);
|
|
|
|
fflush(stderr);
|
|
|
|
}
|
|
|
|
assert(r >= 0);
|
2015-06-17 15:23:49 +02:00
|
|
|
|
|
|
|
assert(vhost_net_set_vnet_endian(dev, ncs[0].peer, false) >= 0);
|
2013-01-30 12:12:35 +01:00
|
|
|
}
|
|
|
|
|
2010-03-17 12:08:17 +01:00
|
|
|
void vhost_net_cleanup(struct vhost_net *net)
|
|
|
|
{
|
|
|
|
vhost_dev_cleanup(&net->dev);
|
2011-08-21 05:09:37 +02:00
|
|
|
g_free(net);
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
2012-12-24 16:37:01 +01:00
|
|
|
|
2015-10-09 17:17:32 +02:00
|
|
|
int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr)
|
|
|
|
{
|
|
|
|
const VhostOps *vhost_ops = net->dev.vhost_ops;
|
|
|
|
int r = -1;
|
|
|
|
|
|
|
|
if (vhost_ops->vhost_migration_done) {
|
|
|
|
r = vhost_ops->vhost_migration_done(&net->dev, mac_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2012-12-24 16:37:01 +01:00
|
|
|
bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
|
|
|
|
{
|
|
|
|
return vhost_virtqueue_pending(&net->dev, idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
|
|
|
|
int idx, bool mask)
|
|
|
|
{
|
|
|
|
vhost_virtqueue_mask(&net->dev, dev, idx, mask);
|
|
|
|
}
|
2014-05-27 14:05:08 +02:00
|
|
|
|
|
|
|
VHostNetState *get_vhost_net(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VHostNetState *vhost_net = 0;
|
|
|
|
|
|
|
|
if (!nc) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (nc->info->type) {
|
|
|
|
case NET_CLIENT_OPTIONS_KIND_TAP:
|
|
|
|
vhost_net = tap_get_vhost_net(nc);
|
|
|
|
break;
|
2014-06-10 12:02:16 +02:00
|
|
|
case NET_CLIENT_OPTIONS_KIND_VHOST_USER:
|
|
|
|
vhost_net = vhost_user_get_vhost_net(nc);
|
|
|
|
break;
|
2014-05-27 14:05:08 +02:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return vhost_net;
|
|
|
|
}
|
2015-09-23 06:20:01 +02:00
|
|
|
|
|
|
|
int vhost_set_vring_enable(NetClientState *nc, int enable)
|
|
|
|
{
|
|
|
|
VHostNetState *net = get_vhost_net(nc);
|
|
|
|
const VhostOps *vhost_ops = net->dev.vhost_ops;
|
|
|
|
|
2015-10-09 17:17:28 +02:00
|
|
|
if (vhost_ops->vhost_set_vring_enable) {
|
|
|
|
return vhost_ops->vhost_set_vring_enable(&net->dev, enable);
|
2015-09-23 06:20:01 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-03-17 12:08:17 +01:00
|
|
|
#else
|
2015-09-23 06:19:58 +02:00
|
|
|
uint64_t vhost_net_get_max_queues(VHostNetState *net)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-05-27 14:05:22 +02:00
|
|
|
struct vhost_net *vhost_net_init(VhostNetOptions *options)
|
2011-02-01 21:13:42 +01:00
|
|
|
{
|
2011-06-09 22:55:57 +02:00
|
|
|
error_report("vhost-net support is not compiled in");
|
2011-02-01 21:13:42 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-01-30 12:12:35 +01:00
|
|
|
int vhost_net_start(VirtIODevice *dev,
|
|
|
|
NetClientState *ncs,
|
|
|
|
int total_queues)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
2011-02-01 21:13:42 +01:00
|
|
|
return -ENOSYS;
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
2013-01-30 12:12:35 +01:00
|
|
|
void vhost_net_stop(VirtIODevice *dev,
|
|
|
|
NetClientState *ncs,
|
|
|
|
int total_queues)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void vhost_net_cleanup(struct vhost_net *net)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-06-04 12:34:20 +02:00
|
|
|
uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
2011-02-01 21:13:42 +01:00
|
|
|
return features;
|
2010-03-17 12:08:17 +01:00
|
|
|
}
|
2015-06-04 12:34:20 +02:00
|
|
|
void vhost_net_ack_features(struct vhost_net *net, uint64_t features)
|
2010-03-17 12:08:17 +01:00
|
|
|
{
|
|
|
|
}
|
2012-12-24 16:37:01 +01:00
|
|
|
|
|
|
|
bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
|
|
|
|
{
|
2013-12-22 15:51:22 +01:00
|
|
|
return false;
|
2012-12-24 16:37:01 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
|
|
|
|
int idx, bool mask)
|
|
|
|
{
|
|
|
|
}
|
2014-05-27 14:05:08 +02:00
|
|
|
|
2015-10-09 17:17:32 +02:00
|
|
|
int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-05-27 14:05:08 +02:00
|
|
|
VHostNetState *get_vhost_net(NetClientState *nc)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2015-09-23 06:20:01 +02:00
|
|
|
|
|
|
|
int vhost_set_vring_enable(NetClientState *nc, int enable)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2010-03-17 12:08:17 +01:00
|
|
|
#endif
|