2020-07-01 17:55:38 +03:00
|
|
|
/*
|
|
|
|
* vhost-vdpa.c
|
|
|
|
*
|
|
|
|
* Copyright(c) 2017-2018 Intel Corporation.
|
|
|
|
* Copyright(c) 2020 Red Hat, Inc.
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include "clients.h"
|
2022-07-20 09:59:42 +03:00
|
|
|
#include "hw/virtio/virtio-net.h"
|
2020-07-01 17:55:38 +03:00
|
|
|
#include "net/vhost_net.h"
|
|
|
|
#include "net/vhost-vdpa.h"
|
|
|
|
#include "hw/virtio/vhost-vdpa.h"
|
|
|
|
#include "qemu/config-file.h"
|
|
|
|
#include "qemu/error-report.h"
|
2022-07-20 09:59:42 +03:00
|
|
|
#include "qemu/log.h"
|
|
|
|
#include "qemu/memalign.h"
|
2020-07-01 17:55:38 +03:00
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qapi/error.h"
|
2021-10-20 07:56:00 +03:00
|
|
|
#include <linux/vhost.h>
|
2020-07-01 17:55:38 +03:00
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <err.h>
|
|
|
|
#include "standard-headers/linux/virtio_net.h"
|
|
|
|
#include "monitor/monitor.h"
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
#include "migration/migration.h"
|
|
|
|
#include "migration/misc.h"
|
2020-07-01 17:55:38 +03:00
|
|
|
#include "hw/virtio/vhost.h"
|
|
|
|
|
|
|
|
/* Todo:need to add the multiqueue support here */
|
|
|
|
typedef struct VhostVDPAState {
|
|
|
|
NetClientState nc;
|
|
|
|
struct vhost_vdpa vhost_vdpa;
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
Notifier migration_state;
|
2020-07-01 17:55:38 +03:00
|
|
|
VHostNetState *vhost_net;
|
2022-07-20 09:59:43 +03:00
|
|
|
|
|
|
|
/* Control commands shadow buffers */
|
2022-09-06 18:07:14 +03:00
|
|
|
void *cvq_cmd_out_buffer;
|
|
|
|
virtio_net_ctrl_ack *status;
|
|
|
|
|
2022-12-15 14:31:42 +03:00
|
|
|
/* The device always have SVQ enabled */
|
|
|
|
bool always_svq;
|
2020-07-01 17:55:38 +03:00
|
|
|
bool started;
|
|
|
|
} VhostVDPAState;
|
|
|
|
|
|
|
|
const int vdpa_feature_bits[] = {
|
|
|
|
VIRTIO_F_NOTIFY_ON_EMPTY,
|
|
|
|
VIRTIO_RING_F_INDIRECT_DESC,
|
|
|
|
VIRTIO_RING_F_EVENT_IDX,
|
|
|
|
VIRTIO_F_ANY_LAYOUT,
|
|
|
|
VIRTIO_F_VERSION_1,
|
|
|
|
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,
|
|
|
|
VIRTIO_NET_F_MTU,
|
2021-10-20 07:56:00 +03:00
|
|
|
VIRTIO_NET_F_CTRL_RX,
|
|
|
|
VIRTIO_NET_F_CTRL_RX_EXTRA,
|
|
|
|
VIRTIO_NET_F_CTRL_VLAN,
|
|
|
|
VIRTIO_NET_F_CTRL_MAC_ADDR,
|
|
|
|
VIRTIO_NET_F_RSS,
|
|
|
|
VIRTIO_NET_F_MQ,
|
|
|
|
VIRTIO_NET_F_CTRL_VQ,
|
2020-07-01 17:55:38 +03:00
|
|
|
VIRTIO_F_IOMMU_PLATFORM,
|
|
|
|
VIRTIO_F_RING_PACKED,
|
2022-11-21 13:11:01 +03:00
|
|
|
VIRTIO_F_RING_RESET,
|
2021-05-14 14:48:33 +03:00
|
|
|
VIRTIO_NET_F_RSS,
|
|
|
|
VIRTIO_NET_F_HASH_REPORT,
|
2020-10-01 23:09:45 +03:00
|
|
|
VIRTIO_NET_F_STATUS,
|
2020-07-01 17:55:38 +03:00
|
|
|
VHOST_INVALID_FEATURE_BIT
|
|
|
|
};
|
|
|
|
|
2022-07-20 09:59:46 +03:00
|
|
|
/** Supported device specific feature bits with SVQ */
|
|
|
|
static const uint64_t vdpa_svq_device_features =
|
|
|
|
BIT_ULL(VIRTIO_NET_F_CSUM) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_GUEST_CSUM) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_MTU) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_MAC) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_GUEST_TSO4) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_GUEST_TSO6) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_GUEST_ECN) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_GUEST_UFO) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_HOST_TSO4) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_HOST_TSO6) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_HOST_ECN) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_HOST_UFO) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_MRG_RXBUF) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_STATUS) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_CTRL_VQ) |
|
2022-09-06 18:07:19 +03:00
|
|
|
BIT_ULL(VIRTIO_NET_F_MQ) |
|
2022-07-20 09:59:46 +03:00
|
|
|
BIT_ULL(VIRTIO_F_ANY_LAYOUT) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_CTRL_MAC_ADDR) |
|
2023-03-03 20:24:44 +03:00
|
|
|
/* VHOST_F_LOG_ALL is exposed by SVQ */
|
|
|
|
BIT_ULL(VHOST_F_LOG_ALL) |
|
2022-07-20 09:59:46 +03:00
|
|
|
BIT_ULL(VIRTIO_NET_F_RSC_EXT) |
|
|
|
|
BIT_ULL(VIRTIO_NET_F_STANDBY);
|
|
|
|
|
2022-12-15 14:31:44 +03:00
|
|
|
#define VHOST_VDPA_NET_CVQ_ASID 1
|
|
|
|
|
2020-07-01 17:55:38 +03:00
|
|
|
VHostNetState *vhost_vdpa_get_vhost_net(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
return s->vhost_net;
|
|
|
|
}
|
|
|
|
|
2022-12-15 14:31:37 +03:00
|
|
|
static bool vhost_vdpa_net_valid_svq_features(uint64_t features, Error **errp)
|
|
|
|
{
|
|
|
|
uint64_t invalid_dev_features =
|
|
|
|
features & ~vdpa_svq_device_features &
|
|
|
|
/* Transport are all accepted at this point */
|
|
|
|
~MAKE_64BIT_MASK(VIRTIO_TRANSPORT_F_START,
|
|
|
|
VIRTIO_TRANSPORT_F_END - VIRTIO_TRANSPORT_F_START);
|
|
|
|
|
|
|
|
if (invalid_dev_features) {
|
|
|
|
error_setg(errp, "vdpa svq does not work with features 0x%" PRIx64,
|
|
|
|
invalid_dev_features);
|
2022-12-15 14:31:39 +03:00
|
|
|
return false;
|
2022-12-15 14:31:37 +03:00
|
|
|
}
|
|
|
|
|
2022-12-15 14:31:39 +03:00
|
|
|
return vhost_svq_valid_features(features, errp);
|
2022-12-15 14:31:37 +03:00
|
|
|
}
|
|
|
|
|
2020-07-01 17:55:38 +03:00
|
|
|
static int vhost_vdpa_net_check_device_id(struct vhost_net *net)
|
|
|
|
{
|
|
|
|
uint32_t device_id;
|
|
|
|
int ret;
|
|
|
|
struct vhost_dev *hdev;
|
|
|
|
|
|
|
|
hdev = (struct vhost_dev *)&net->dev;
|
|
|
|
ret = hdev->vhost_ops->vhost_get_device_id(hdev, &device_id);
|
|
|
|
if (device_id != VIRTIO_ID_NET) {
|
|
|
|
return -ENOTSUP;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2021-10-20 07:56:00 +03:00
|
|
|
static int vhost_vdpa_add(NetClientState *ncs, void *be,
|
|
|
|
int queue_pair_index, int nvqs)
|
2020-07-01 17:55:38 +03:00
|
|
|
{
|
|
|
|
VhostNetOptions options;
|
|
|
|
struct vhost_net *net = NULL;
|
|
|
|
VhostVDPAState *s;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
options.backend_type = VHOST_BACKEND_TYPE_VDPA;
|
|
|
|
assert(ncs->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
s = DO_UPCAST(VhostVDPAState, nc, ncs);
|
|
|
|
options.net_backend = ncs;
|
|
|
|
options.opaque = be;
|
|
|
|
options.busyloop_timeout = 0;
|
2021-10-20 07:56:00 +03:00
|
|
|
options.nvqs = nvqs;
|
2020-07-01 17:55:38 +03:00
|
|
|
|
|
|
|
net = vhost_net_init(&options);
|
|
|
|
if (!net) {
|
|
|
|
error_report("failed to init vhost_net for queue");
|
2021-09-03 12:10:19 +03:00
|
|
|
goto err_init;
|
2020-07-01 17:55:38 +03:00
|
|
|
}
|
|
|
|
s->vhost_net = net;
|
|
|
|
ret = vhost_vdpa_net_check_device_id(net);
|
|
|
|
if (ret) {
|
2021-09-03 12:10:19 +03:00
|
|
|
goto err_check;
|
2020-07-01 17:55:38 +03:00
|
|
|
}
|
|
|
|
return 0;
|
2021-09-03 12:10:19 +03:00
|
|
|
err_check:
|
|
|
|
vhost_net_cleanup(net);
|
|
|
|
g_free(net);
|
|
|
|
err_init:
|
2020-07-01 17:55:38 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vhost_vdpa_cleanup(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
|
2022-07-20 09:59:43 +03:00
|
|
|
qemu_vfree(s->cvq_cmd_out_buffer);
|
2022-09-06 18:07:14 +03:00
|
|
|
qemu_vfree(s->status);
|
2020-07-01 17:55:38 +03:00
|
|
|
if (s->vhost_net) {
|
|
|
|
vhost_net_cleanup(s->vhost_net);
|
|
|
|
g_free(s->vhost_net);
|
|
|
|
s->vhost_net = NULL;
|
|
|
|
}
|
2020-10-16 06:09:08 +03:00
|
|
|
if (s->vhost_vdpa.device_fd >= 0) {
|
|
|
|
qemu_close(s->vhost_vdpa.device_fd);
|
|
|
|
s->vhost_vdpa.device_fd = -1;
|
|
|
|
}
|
2020-07-01 17:55:38 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool vhost_vdpa_has_vnet_hdr(NetClientState *nc)
|
|
|
|
{
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vhost_vdpa_has_ufo(NetClientState *nc)
|
|
|
|
{
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
uint64_t features = 0;
|
|
|
|
features |= (1ULL << VIRTIO_NET_F_HOST_UFO);
|
|
|
|
features = vhost_net_get_features(s->vhost_net, features);
|
|
|
|
return !!(features & (1ULL << VIRTIO_NET_F_HOST_UFO));
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2021-10-08 16:34:30 +03:00
|
|
|
static bool vhost_vdpa_check_peer_type(NetClientState *nc, ObjectClass *oc,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
const char *driver = object_class_get_name(oc);
|
|
|
|
|
|
|
|
if (!g_str_has_prefix(driver, "virtio-net-")) {
|
|
|
|
error_setg(errp, "vhost-vdpa requires frontend driver virtio-net-*");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-11-25 13:16:13 +03:00
|
|
|
/** Dummy receive in case qemu falls back to userland tap networking */
|
|
|
|
static ssize_t vhost_vdpa_receive(NetClientState *nc, const uint8_t *buf,
|
|
|
|
size_t size)
|
|
|
|
{
|
vhost-vdpa: fix assert !virtio_net_get_subqueue(nc)->async_tx.elem in virtio_net_reset
The citing commit has incorrect code in vhost_vdpa_receive() that returns
zero instead of full packet size to the caller. This renders pending packets
unable to be freed so then get clogged in the tx queue forever. When device
is being reset later on, below assertion failure ensues:
0 0x00007f86d53bb387 in raise () from /lib64/libc.so.6
1 0x00007f86d53bca78 in abort () from /lib64/libc.so.6
2 0x00007f86d53b41a6 in __assert_fail_base () from /lib64/libc.so.6
3 0x00007f86d53b4252 in __assert_fail () from /lib64/libc.so.6
4 0x000055b8f6ff6fcc in virtio_net_reset (vdev=<optimized out>) at /usr/src/debug/qemu/hw/net/virtio-net.c:563
5 0x000055b8f7012fcf in virtio_reset (opaque=0x55b8faf881f0) at /usr/src/debug/qemu/hw/virtio/virtio.c:1993
6 0x000055b8f71f0086 in virtio_bus_reset (bus=bus@entry=0x55b8faf88178) at /usr/src/debug/qemu/hw/virtio/virtio-bus.c:102
7 0x000055b8f71f1620 in virtio_pci_reset (qdev=<optimized out>) at /usr/src/debug/qemu/hw/virtio/virtio-pci.c:1845
8 0x000055b8f6fafc6c in memory_region_write_accessor (mr=<optimized out>, addr=<optimized out>, value=<optimized out>,
size=<optimized out>, shift=<optimized out>, mask=<optimized out>, attrs=...) at /usr/src/debug/qemu/memory.c:483
9 0x000055b8f6fadce9 in access_with_adjusted_size (addr=addr@entry=20, value=value@entry=0x7f867e7fb7e8, size=size@entry=1,
access_size_min=<optimized out>, access_size_max=<optimized out>, access_fn=0x55b8f6fafc20 <memory_region_write_accessor>,
mr=0x55b8faf80a50, attrs=...) at /usr/src/debug/qemu/memory.c:544
10 0x000055b8f6fb1d0b in memory_region_dispatch_write (mr=mr@entry=0x55b8faf80a50, addr=addr@entry=20, data=0, op=<optimized out>,
attrs=attrs@entry=...) at /usr/src/debug/qemu/memory.c:1470
11 0x000055b8f6f62ada in flatview_write_continue (fv=fv@entry=0x7f86ac04cd20, addr=addr@entry=549755813908, attrs=...,
attrs@entry=..., buf=buf@entry=0x7f86d0223028 <Address 0x7f86d0223028 out of bounds>, len=len@entry=1, addr1=20, l=1,
mr=0x55b8faf80a50) at /usr/src/debug/qemu/exec.c:3266
12 0x000055b8f6f62c8f in flatview_write (fv=0x7f86ac04cd20, addr=549755813908, attrs=...,
buf=0x7f86d0223028 <Address 0x7f86d0223028 out of bounds>, len=1) at /usr/src/debug/qemu/exec.c:3306
13 0x000055b8f6f674cb in address_space_write (as=<optimized out>, addr=<optimized out>, attrs=..., buf=<optimized out>,
len=<optimized out>) at /usr/src/debug/qemu/exec.c:3396
14 0x000055b8f6f67575 in address_space_rw (as=<optimized out>, addr=<optimized out>, attrs=..., attrs@entry=...,
buf=buf@entry=0x7f86d0223028 <Address 0x7f86d0223028 out of bounds>, len=<optimized out>, is_write=<optimized out>)
at /usr/src/debug/qemu/exec.c:3406
15 0x000055b8f6fc1cc8 in kvm_cpu_exec (cpu=cpu@entry=0x55b8f9aa0e10) at /usr/src/debug/qemu/accel/kvm/kvm-all.c:2410
16 0x000055b8f6fa5f5e in qemu_kvm_cpu_thread_fn (arg=0x55b8f9aa0e10) at /usr/src/debug/qemu/cpus.c:1318
17 0x000055b8f7336e16 in qemu_thread_start (args=0x55b8f9ac8480) at /usr/src/debug/qemu/util/qemu-thread-posix.c:519
18 0x00007f86d575aea5 in start_thread () from /lib64/libpthread.so.0
19 0x00007f86d5483b2d in clone () from /lib64/libc.so.6
Make vhost_vdpa_receive() return the size passed in as is, so that the
caller qemu_deliver_packet_iov() would eventually propagate it back to
virtio_net_flush_tx() to release pending packets from the async_tx queue.
Which corresponds to the drop path where qemu_sendv_packet_async() returns
non-zero in virtio_net_flush_tx().
Fixes: 846a1e85da64 ("vdpa: Add dummy receive callback")
Cc: Eugenio Perez Martin <eperezma@redhat.com>
Signed-off-by: Si-Wei Liu <si-wei.liu@oracle.com>
Signed-off-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20221108041929.18417-2-jasowang@redhat.com>
2022-11-08 07:19:28 +03:00
|
|
|
return size;
|
2021-11-25 13:16:13 +03:00
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
/** From any vdpa net client, get the netclient of the first queue pair */
|
|
|
|
static VhostVDPAState *vhost_vdpa_net_first_nc_vdpa(VhostVDPAState *s)
|
|
|
|
{
|
|
|
|
NICState *nic = qemu_get_nic(s->nc.peer);
|
|
|
|
NetClientState *nc0 = qemu_get_peer(nic->ncs, 0);
|
|
|
|
|
|
|
|
return DO_UPCAST(VhostVDPAState, nc, nc0);
|
|
|
|
}
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
static void vhost_vdpa_net_log_global_enable(VhostVDPAState *s, bool enable)
|
|
|
|
{
|
|
|
|
struct vhost_vdpa *v = &s->vhost_vdpa;
|
|
|
|
VirtIONet *n;
|
|
|
|
VirtIODevice *vdev;
|
|
|
|
int data_queue_pairs, cvq, r;
|
|
|
|
|
|
|
|
/* We are only called on the first data vqs and only if x-svq is not set */
|
|
|
|
if (s->vhost_vdpa.shadow_vqs_enabled == enable) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
vdev = v->dev->vdev;
|
|
|
|
n = VIRTIO_NET(vdev);
|
|
|
|
if (!n->vhost_started) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data_queue_pairs = n->multiqueue ? n->max_queue_pairs : 1;
|
|
|
|
cvq = virtio_vdev_has_feature(vdev, VIRTIO_NET_F_CTRL_VQ) ?
|
|
|
|
n->max_ncs - n->max_queue_pairs : 0;
|
|
|
|
/*
|
|
|
|
* TODO: vhost_net_stop does suspend, get_base and reset. We can be smarter
|
|
|
|
* in the future and resume the device if read-only operations between
|
|
|
|
* suspend and reset goes wrong.
|
|
|
|
*/
|
|
|
|
vhost_net_stop(vdev, n->nic->ncs, data_queue_pairs, cvq);
|
|
|
|
|
|
|
|
/* Start will check migration setup_or_active to configure or not SVQ */
|
|
|
|
r = vhost_net_start(vdev, n->nic->ncs, data_queue_pairs, cvq);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
error_report("unable to start vhost net: %s(%d)", g_strerror(-r), -r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vdpa_net_migration_state_notifier(Notifier *notifier, void *data)
|
|
|
|
{
|
|
|
|
MigrationState *migration = data;
|
|
|
|
VhostVDPAState *s = container_of(notifier, VhostVDPAState,
|
|
|
|
migration_state);
|
|
|
|
|
|
|
|
if (migration_in_setup(migration)) {
|
|
|
|
vhost_vdpa_net_log_global_enable(s, true);
|
|
|
|
} else if (migration_has_failed(migration)) {
|
|
|
|
vhost_vdpa_net_log_global_enable(s, false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
static void vhost_vdpa_net_data_start_first(VhostVDPAState *s)
|
|
|
|
{
|
|
|
|
struct vhost_vdpa *v = &s->vhost_vdpa;
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
add_migration_state_change_notifier(&s->migration_state);
|
2023-03-03 20:24:32 +03:00
|
|
|
if (v->shadow_vqs_enabled) {
|
|
|
|
v->iova_tree = vhost_iova_tree_new(v->iova_range.first,
|
|
|
|
v->iova_range.last);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vhost_vdpa_net_data_start(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
struct vhost_vdpa *v = &s->vhost_vdpa;
|
|
|
|
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
if (s->always_svq ||
|
|
|
|
migration_is_setup_or_active(migrate_get_current()->state)) {
|
|
|
|
v->shadow_vqs_enabled = true;
|
|
|
|
v->shadow_data = true;
|
|
|
|
} else {
|
|
|
|
v->shadow_vqs_enabled = false;
|
|
|
|
v->shadow_data = false;
|
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
if (v->index == 0) {
|
|
|
|
vhost_vdpa_net_data_start_first(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (v->shadow_vqs_enabled) {
|
|
|
|
VhostVDPAState *s0 = vhost_vdpa_net_first_nc_vdpa(s);
|
|
|
|
v->iova_tree = s0->vhost_vdpa.iova_tree;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vhost_vdpa_net_client_stop(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
struct vhost_dev *dev;
|
|
|
|
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
if (s->vhost_vdpa.index == 0) {
|
|
|
|
remove_migration_state_change_notifier(&s->migration_state);
|
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
dev = s->vhost_vdpa.dev;
|
|
|
|
if (dev->vq_index + dev->nvqs == dev->vq_index_end) {
|
|
|
|
g_clear_pointer(&s->vhost_vdpa.iova_tree, vhost_iova_tree_delete);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-01 17:55:38 +03:00
|
|
|
static NetClientInfo net_vhost_vdpa_info = {
|
|
|
|
.type = NET_CLIENT_DRIVER_VHOST_VDPA,
|
|
|
|
.size = sizeof(VhostVDPAState),
|
2021-11-25 13:16:13 +03:00
|
|
|
.receive = vhost_vdpa_receive,
|
2023-03-03 20:24:32 +03:00
|
|
|
.start = vhost_vdpa_net_data_start,
|
|
|
|
.stop = vhost_vdpa_net_client_stop,
|
2020-07-01 17:55:38 +03:00
|
|
|
.cleanup = vhost_vdpa_cleanup,
|
|
|
|
.has_vnet_hdr = vhost_vdpa_has_vnet_hdr,
|
|
|
|
.has_ufo = vhost_vdpa_has_ufo,
|
2021-10-08 16:34:30 +03:00
|
|
|
.check_peer_type = vhost_vdpa_check_peer_type,
|
2020-07-01 17:55:38 +03:00
|
|
|
};
|
|
|
|
|
2022-12-15 14:31:44 +03:00
|
|
|
static int64_t vhost_vdpa_get_vring_group(int device_fd, unsigned vq_index)
|
|
|
|
{
|
|
|
|
struct vhost_vring_state state = {
|
|
|
|
.index = vq_index,
|
|
|
|
};
|
|
|
|
int r = ioctl(device_fd, VHOST_VDPA_GET_VRING_GROUP, &state);
|
|
|
|
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
error_report("Cannot get VQ %u group: %s", vq_index,
|
|
|
|
g_strerror(errno));
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return state.num;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vhost_vdpa_set_address_space_id(struct vhost_vdpa *v,
|
|
|
|
unsigned vq_group,
|
|
|
|
unsigned asid_num)
|
|
|
|
{
|
|
|
|
struct vhost_vring_state asid = {
|
|
|
|
.index = vq_group,
|
|
|
|
.num = asid_num,
|
|
|
|
};
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = ioctl(v->device_fd, VHOST_VDPA_SET_GROUP_ASID, &asid);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
error_report("Can't set vq group %u asid %u, errno=%d (%s)",
|
|
|
|
asid.index, asid.num, errno, g_strerror(errno));
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-07-20 09:59:43 +03:00
|
|
|
static void vhost_vdpa_cvq_unmap_buf(struct vhost_vdpa *v, void *addr)
|
|
|
|
{
|
|
|
|
VhostIOVATree *tree = v->iova_tree;
|
|
|
|
DMAMap needle = {
|
|
|
|
/*
|
|
|
|
* No need to specify size or to look for more translations since
|
|
|
|
* this contiguous chunk was allocated by us.
|
|
|
|
*/
|
|
|
|
.translated_addr = (hwaddr)(uintptr_t)addr,
|
|
|
|
};
|
|
|
|
const DMAMap *map = vhost_iova_tree_find_iova(tree, &needle);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if (unlikely(!map)) {
|
|
|
|
error_report("Cannot locate expected map");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2022-12-15 14:31:41 +03:00
|
|
|
r = vhost_vdpa_dma_unmap(v, v->address_space_id, map->iova, map->size + 1);
|
2022-07-20 09:59:43 +03:00
|
|
|
if (unlikely(r != 0)) {
|
|
|
|
error_report("Device cannot unmap: %s(%d)", g_strerror(r), r);
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:20:04 +03:00
|
|
|
vhost_iova_tree_remove(tree, *map);
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static size_t vhost_vdpa_net_cvq_cmd_len(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* MAC_TABLE_SET is the ctrl command that produces the longer out buffer.
|
|
|
|
* In buffer is always 1 byte, so it should fit here
|
|
|
|
*/
|
|
|
|
return sizeof(struct virtio_net_ctrl_hdr) +
|
|
|
|
2 * sizeof(struct virtio_net_ctrl_mac) +
|
|
|
|
MAC_TABLE_ENTRIES * ETH_ALEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t vhost_vdpa_net_cvq_cmd_page_len(void)
|
|
|
|
{
|
|
|
|
return ROUND_UP(vhost_vdpa_net_cvq_cmd_len(), qemu_real_host_page_size());
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
/** Map CVQ buffer. */
|
|
|
|
static int vhost_vdpa_cvq_map_buf(struct vhost_vdpa *v, void *buf, size_t size,
|
|
|
|
bool write)
|
2022-07-20 09:59:43 +03:00
|
|
|
{
|
|
|
|
DMAMap map = {};
|
|
|
|
int r;
|
|
|
|
|
|
|
|
map.translated_addr = (hwaddr)(uintptr_t)buf;
|
2022-08-23 21:30:33 +03:00
|
|
|
map.size = size - 1;
|
2022-07-20 09:59:43 +03:00
|
|
|
map.perm = write ? IOMMU_RW : IOMMU_RO,
|
|
|
|
r = vhost_iova_tree_map_alloc(v->iova_tree, &map);
|
|
|
|
if (unlikely(r != IOVA_OK)) {
|
|
|
|
error_report("Cannot map injected element");
|
2022-08-23 21:30:33 +03:00
|
|
|
return r;
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
2022-12-15 14:31:41 +03:00
|
|
|
r = vhost_vdpa_dma_map(v, v->address_space_id, map.iova,
|
|
|
|
vhost_vdpa_net_cvq_cmd_page_len(), buf, !write);
|
2022-07-20 09:59:43 +03:00
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
goto dma_map_err;
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
return 0;
|
2022-07-20 09:59:43 +03:00
|
|
|
|
|
|
|
dma_map_err:
|
2022-08-23 21:20:04 +03:00
|
|
|
vhost_iova_tree_remove(v->iova_tree, map);
|
2022-08-23 21:30:33 +03:00
|
|
|
return r;
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
static int vhost_vdpa_net_cvq_start(NetClientState *nc)
|
2022-07-20 09:59:43 +03:00
|
|
|
{
|
2023-03-03 20:24:32 +03:00
|
|
|
VhostVDPAState *s, *s0;
|
2022-12-15 14:31:44 +03:00
|
|
|
struct vhost_vdpa *v;
|
|
|
|
uint64_t backend_features;
|
|
|
|
int64_t cvq_group;
|
|
|
|
int cvq_index, r;
|
2022-07-20 09:59:43 +03:00
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
|
|
|
s = DO_UPCAST(VhostVDPAState, nc, nc);
|
2022-12-15 14:31:44 +03:00
|
|
|
v = &s->vhost_vdpa;
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
s0 = vhost_vdpa_net_first_nc_vdpa(s);
|
|
|
|
v->shadow_data = s0->vhost_vdpa.shadow_vqs_enabled;
|
2022-12-15 14:31:44 +03:00
|
|
|
v->shadow_vqs_enabled = s->always_svq;
|
|
|
|
s->vhost_vdpa.address_space_id = VHOST_VDPA_GUEST_PA_ASID;
|
|
|
|
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
if (s->vhost_vdpa.shadow_data) {
|
2022-12-15 14:31:44 +03:00
|
|
|
/* SVQ is already configured for all virtqueues */
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we early return in these cases SVQ will not be enabled. The migration
|
|
|
|
* will be blocked as long as vhost-vdpa backends will not offer _F_LOG.
|
|
|
|
*
|
|
|
|
* Calling VHOST_GET_BACKEND_FEATURES as they are not available in v->dev
|
|
|
|
* yet.
|
|
|
|
*/
|
|
|
|
r = ioctl(v->device_fd, VHOST_GET_BACKEND_FEATURES, &backend_features);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
error_report("Cannot get vdpa backend_features: %s(%d)",
|
|
|
|
g_strerror(errno), errno);
|
|
|
|
return -1;
|
|
|
|
}
|
2023-01-17 13:53:08 +03:00
|
|
|
if (!(backend_features & BIT_ULL(VHOST_BACKEND_F_IOTLB_ASID)) ||
|
2022-12-15 14:31:44 +03:00
|
|
|
!vhost_vdpa_net_valid_svq_features(v->dev->features, NULL)) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if all the virtqueues of the virtio device are in a different vq
|
|
|
|
* than the last vq. VQ group of last group passed in cvq_group.
|
|
|
|
*/
|
|
|
|
cvq_index = v->dev->vq_index_end - 1;
|
|
|
|
cvq_group = vhost_vdpa_get_vring_group(v->device_fd, cvq_index);
|
|
|
|
if (unlikely(cvq_group < 0)) {
|
|
|
|
return cvq_group;
|
|
|
|
}
|
|
|
|
for (int i = 0; i < cvq_index; ++i) {
|
|
|
|
int64_t group = vhost_vdpa_get_vring_group(v->device_fd, i);
|
|
|
|
|
|
|
|
if (unlikely(group < 0)) {
|
|
|
|
return group;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (group == cvq_group) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
r = vhost_vdpa_set_address_space_id(v, cvq_group, VHOST_VDPA_NET_CVQ_ASID);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
v->shadow_vqs_enabled = true;
|
|
|
|
s->vhost_vdpa.address_space_id = VHOST_VDPA_NET_CVQ_ASID;
|
|
|
|
|
|
|
|
out:
|
2022-08-23 21:30:33 +03:00
|
|
|
if (!s->vhost_vdpa.shadow_vqs_enabled) {
|
|
|
|
return 0;
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
if (s0->vhost_vdpa.iova_tree) {
|
|
|
|
/*
|
|
|
|
* SVQ is already configured for all virtqueues. Reuse IOVA tree for
|
|
|
|
* simplicity, whether CVQ shares ASID with guest or not, because:
|
|
|
|
* - Memory listener need access to guest's memory addresses allocated
|
|
|
|
* in the IOVA tree.
|
|
|
|
* - There should be plenty of IOVA address space for both ASID not to
|
|
|
|
* worry about collisions between them. Guest's translations are
|
|
|
|
* still validated with virtio virtqueue_pop so there is no risk for
|
|
|
|
* the guest to access memory that it shouldn't.
|
|
|
|
*
|
|
|
|
* To allocate a iova tree per ASID is doable but it complicates the
|
|
|
|
* code and it is not worth it for the moment.
|
|
|
|
*/
|
|
|
|
v->iova_tree = s0->vhost_vdpa.iova_tree;
|
|
|
|
} else {
|
|
|
|
v->iova_tree = vhost_iova_tree_new(v->iova_range.first,
|
|
|
|
v->iova_range.last);
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
r = vhost_vdpa_cvq_map_buf(&s->vhost_vdpa, s->cvq_cmd_out_buffer,
|
|
|
|
vhost_vdpa_net_cvq_cmd_page_len(), false);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2022-09-06 18:07:14 +03:00
|
|
|
r = vhost_vdpa_cvq_map_buf(&s->vhost_vdpa, s->status,
|
2022-08-23 21:30:33 +03:00
|
|
|
vhost_vdpa_net_cvq_cmd_page_len(), true);
|
|
|
|
if (unlikely(r < 0)) {
|
2022-07-20 09:59:43 +03:00
|
|
|
vhost_vdpa_cvq_unmap_buf(&s->vhost_vdpa, s->cvq_cmd_out_buffer);
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vhost_vdpa_net_cvq_stop(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
|
|
|
if (s->vhost_vdpa.shadow_vqs_enabled) {
|
|
|
|
vhost_vdpa_cvq_unmap_buf(&s->vhost_vdpa, s->cvq_cmd_out_buffer);
|
2022-09-06 18:07:14 +03:00
|
|
|
vhost_vdpa_cvq_unmap_buf(&s->vhost_vdpa, s->status);
|
2022-08-23 21:30:33 +03:00
|
|
|
}
|
2023-03-03 20:24:32 +03:00
|
|
|
|
|
|
|
vhost_vdpa_net_client_stop(nc);
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:34 +03:00
|
|
|
static ssize_t vhost_vdpa_net_cvq_add(VhostVDPAState *s, size_t out_len,
|
|
|
|
size_t in_len)
|
|
|
|
{
|
|
|
|
/* Buffers for the device */
|
|
|
|
const struct iovec out = {
|
|
|
|
.iov_base = s->cvq_cmd_out_buffer,
|
|
|
|
.iov_len = out_len,
|
|
|
|
};
|
|
|
|
const struct iovec in = {
|
2022-09-06 18:07:14 +03:00
|
|
|
.iov_base = s->status,
|
2022-08-23 21:30:34 +03:00
|
|
|
.iov_len = sizeof(virtio_net_ctrl_ack),
|
|
|
|
};
|
|
|
|
VhostShadowVirtqueue *svq = g_ptr_array_index(s->vhost_vdpa.shadow_vqs, 0);
|
|
|
|
int r;
|
|
|
|
|
|
|
|
r = vhost_svq_add(svq, &out, 1, &in, 1, NULL);
|
|
|
|
if (unlikely(r != 0)) {
|
|
|
|
if (unlikely(r == -ENOSPC)) {
|
|
|
|
qemu_log_mask(LOG_GUEST_ERROR, "%s: No space on device queue\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We can poll here since we've had BQL from the time we sent the
|
|
|
|
* descriptor. Also, we need to take the answer before SVQ pulls by itself,
|
|
|
|
* when BQL is released
|
|
|
|
*/
|
|
|
|
return vhost_svq_poll(svq);
|
|
|
|
}
|
|
|
|
|
2022-09-06 18:07:15 +03:00
|
|
|
static ssize_t vhost_vdpa_net_load_cmd(VhostVDPAState *s, uint8_t class,
|
|
|
|
uint8_t cmd, const void *data,
|
|
|
|
size_t data_size)
|
|
|
|
{
|
|
|
|
const struct virtio_net_ctrl_hdr ctrl = {
|
|
|
|
.class = class,
|
|
|
|
.cmd = cmd,
|
|
|
|
};
|
|
|
|
|
|
|
|
assert(data_size < vhost_vdpa_net_cvq_cmd_page_len() - sizeof(ctrl));
|
|
|
|
|
|
|
|
memcpy(s->cvq_cmd_out_buffer, &ctrl, sizeof(ctrl));
|
|
|
|
memcpy(s->cvq_cmd_out_buffer + sizeof(ctrl), data, data_size);
|
|
|
|
|
|
|
|
return vhost_vdpa_net_cvq_add(s, sizeof(ctrl) + data_size,
|
|
|
|
sizeof(virtio_net_ctrl_ack));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vhost_vdpa_net_load_mac(VhostVDPAState *s, const VirtIONet *n)
|
|
|
|
{
|
|
|
|
uint64_t features = n->parent_obj.guest_features;
|
|
|
|
if (features & BIT_ULL(VIRTIO_NET_F_CTRL_MAC_ADDR)) {
|
|
|
|
ssize_t dev_written = vhost_vdpa_net_load_cmd(s, VIRTIO_NET_CTRL_MAC,
|
|
|
|
VIRTIO_NET_CTRL_MAC_ADDR_SET,
|
|
|
|
n->mac, sizeof(n->mac));
|
|
|
|
if (unlikely(dev_written < 0)) {
|
|
|
|
return dev_written;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *s->status != VIRTIO_NET_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-09-06 18:07:16 +03:00
|
|
|
static int vhost_vdpa_net_load_mq(VhostVDPAState *s,
|
|
|
|
const VirtIONet *n)
|
|
|
|
{
|
|
|
|
struct virtio_net_ctrl_mq mq;
|
|
|
|
uint64_t features = n->parent_obj.guest_features;
|
|
|
|
ssize_t dev_written;
|
|
|
|
|
|
|
|
if (!(features & BIT_ULL(VIRTIO_NET_F_MQ))) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
mq.virtqueue_pairs = cpu_to_le16(n->curr_queue_pairs);
|
|
|
|
dev_written = vhost_vdpa_net_load_cmd(s, VIRTIO_NET_CTRL_MQ,
|
|
|
|
VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET, &mq,
|
|
|
|
sizeof(mq));
|
|
|
|
if (unlikely(dev_written < 0)) {
|
|
|
|
return dev_written;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *s->status != VIRTIO_NET_OK;
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:36 +03:00
|
|
|
static int vhost_vdpa_net_load(NetClientState *nc)
|
|
|
|
{
|
|
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
2022-09-06 18:07:15 +03:00
|
|
|
struct vhost_vdpa *v = &s->vhost_vdpa;
|
2022-08-23 21:30:36 +03:00
|
|
|
const VirtIONet *n;
|
2022-09-06 18:07:15 +03:00
|
|
|
int r;
|
2022-08-23 21:30:36 +03:00
|
|
|
|
|
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
|
|
|
|
if (!v->shadow_vqs_enabled) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = VIRTIO_NET(v->dev->vdev);
|
2022-09-06 18:07:15 +03:00
|
|
|
r = vhost_vdpa_net_load_mac(s, n);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
return r;
|
2022-08-23 21:30:36 +03:00
|
|
|
}
|
2022-09-06 18:07:16 +03:00
|
|
|
r = vhost_vdpa_net_load_mq(s, n);
|
|
|
|
if (unlikely(r)) {
|
|
|
|
return r;
|
|
|
|
}
|
2022-08-23 21:30:36 +03:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-08-23 21:30:32 +03:00
|
|
|
static NetClientInfo net_vhost_vdpa_cvq_info = {
|
|
|
|
.type = NET_CLIENT_DRIVER_VHOST_VDPA,
|
|
|
|
.size = sizeof(VhostVDPAState),
|
|
|
|
.receive = vhost_vdpa_receive,
|
2022-08-23 21:30:33 +03:00
|
|
|
.start = vhost_vdpa_net_cvq_start,
|
2022-08-23 21:30:36 +03:00
|
|
|
.load = vhost_vdpa_net_load,
|
2022-08-23 21:30:33 +03:00
|
|
|
.stop = vhost_vdpa_net_cvq_stop,
|
2022-08-23 21:30:32 +03:00
|
|
|
.cleanup = vhost_vdpa_cleanup,
|
|
|
|
.has_vnet_hdr = vhost_vdpa_has_vnet_hdr,
|
|
|
|
.has_ufo = vhost_vdpa_has_ufo,
|
|
|
|
.check_peer_type = vhost_vdpa_check_peer_type,
|
|
|
|
};
|
|
|
|
|
2022-07-20 09:59:43 +03:00
|
|
|
/**
|
|
|
|
* Validate and copy control virtqueue commands.
|
|
|
|
*
|
|
|
|
* Following QEMU guidelines, we offer a copy of the buffers to the device to
|
|
|
|
* prevent TOCTOU bugs.
|
2022-07-20 09:59:42 +03:00
|
|
|
*/
|
|
|
|
static int vhost_vdpa_net_handle_ctrl_avail(VhostShadowVirtqueue *svq,
|
|
|
|
VirtQueueElement *elem,
|
|
|
|
void *opaque)
|
|
|
|
{
|
2022-07-20 09:59:43 +03:00
|
|
|
VhostVDPAState *s = opaque;
|
2022-08-23 21:30:34 +03:00
|
|
|
size_t in_len;
|
2022-07-20 09:59:42 +03:00
|
|
|
virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
|
2022-08-23 21:30:33 +03:00
|
|
|
/* Out buffer sent to both the vdpa device and the device model */
|
|
|
|
struct iovec out = {
|
|
|
|
.iov_base = s->cvq_cmd_out_buffer,
|
|
|
|
};
|
2022-07-20 09:59:43 +03:00
|
|
|
/* in buffer used for device model */
|
|
|
|
const struct iovec in = {
|
|
|
|
.iov_base = &status,
|
|
|
|
.iov_len = sizeof(status),
|
|
|
|
};
|
2022-08-23 21:30:34 +03:00
|
|
|
ssize_t dev_written = -EINVAL;
|
2022-07-20 09:59:43 +03:00
|
|
|
|
2022-08-23 21:30:33 +03:00
|
|
|
out.iov_len = iov_to_buf(elem->out_sg, elem->out_num, 0,
|
|
|
|
s->cvq_cmd_out_buffer,
|
|
|
|
vhost_vdpa_net_cvq_cmd_len());
|
2022-12-21 14:50:14 +03:00
|
|
|
if (*(uint8_t *)s->cvq_cmd_out_buffer == VIRTIO_NET_CTRL_ANNOUNCE) {
|
|
|
|
/*
|
|
|
|
* Guest announce capability is emulated by qemu, so don't forward to
|
|
|
|
* the device.
|
|
|
|
*/
|
|
|
|
dev_written = sizeof(status);
|
|
|
|
*s->status = VIRTIO_NET_OK;
|
|
|
|
} else {
|
|
|
|
dev_written = vhost_vdpa_net_cvq_add(s, out.iov_len, sizeof(status));
|
|
|
|
if (unlikely(dev_written < 0)) {
|
|
|
|
goto out;
|
|
|
|
}
|
2022-07-20 09:59:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
if (unlikely(dev_written < sizeof(status))) {
|
|
|
|
error_report("Insufficient written data (%zu)", dev_written);
|
2022-07-20 09:59:43 +03:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2022-09-06 18:07:14 +03:00
|
|
|
if (*s->status != VIRTIO_NET_OK) {
|
2022-08-23 21:30:34 +03:00
|
|
|
return VIRTIO_NET_ERR;
|
2022-07-20 09:59:43 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
status = VIRTIO_NET_ERR;
|
2022-08-23 21:30:33 +03:00
|
|
|
virtio_net_handle_ctrl_iov(svq->vdev, &in, 1, &out, 1);
|
2022-07-20 09:59:43 +03:00
|
|
|
if (status != VIRTIO_NET_OK) {
|
|
|
|
error_report("Bad CVQ processing in model");
|
2022-07-20 09:59:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
in_len = iov_from_buf(elem->in_sg, elem->in_num, 0, &status,
|
|
|
|
sizeof(status));
|
|
|
|
if (unlikely(in_len < sizeof(status))) {
|
|
|
|
error_report("Bad device CVQ written length");
|
|
|
|
}
|
|
|
|
vhost_svq_push_elem(svq, elem, MIN(in_len, sizeof(status)));
|
|
|
|
g_free(elem);
|
2022-08-23 21:30:34 +03:00
|
|
|
return dev_written < 0 ? dev_written : 0;
|
2022-07-20 09:59:42 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
static const VhostShadowVirtqueueOps vhost_vdpa_net_svq_ops = {
|
|
|
|
.avail_handler = vhost_vdpa_net_handle_ctrl_avail,
|
|
|
|
};
|
|
|
|
|
2021-10-20 07:55:54 +03:00
|
|
|
static NetClientState *net_vhost_vdpa_init(NetClientState *peer,
|
2022-12-15 14:31:38 +03:00
|
|
|
const char *device,
|
|
|
|
const char *name,
|
|
|
|
int vdpa_device_fd,
|
|
|
|
int queue_pair_index,
|
|
|
|
int nvqs,
|
|
|
|
bool is_datapath,
|
|
|
|
bool svq,
|
2023-03-03 20:24:42 +03:00
|
|
|
struct vhost_vdpa_iova_range iova_range,
|
|
|
|
uint64_t features)
|
2020-07-01 17:55:38 +03:00
|
|
|
{
|
|
|
|
NetClientState *nc = NULL;
|
|
|
|
VhostVDPAState *s;
|
|
|
|
int ret = 0;
|
|
|
|
assert(name);
|
2021-10-20 07:56:00 +03:00
|
|
|
if (is_datapath) {
|
|
|
|
nc = qemu_new_net_client(&net_vhost_vdpa_info, peer, device,
|
|
|
|
name);
|
|
|
|
} else {
|
2022-08-23 21:30:32 +03:00
|
|
|
nc = qemu_new_net_control_client(&net_vhost_vdpa_cvq_info, peer,
|
2021-10-20 07:56:00 +03:00
|
|
|
device, name);
|
|
|
|
}
|
2022-10-21 12:09:10 +03:00
|
|
|
qemu_set_info_str(nc, TYPE_VHOST_VDPA);
|
2020-07-01 17:55:38 +03:00
|
|
|
s = DO_UPCAST(VhostVDPAState, nc, nc);
|
2021-10-20 07:55:51 +03:00
|
|
|
|
2020-07-01 17:55:38 +03:00
|
|
|
s->vhost_vdpa.device_fd = vdpa_device_fd;
|
2021-10-20 07:56:00 +03:00
|
|
|
s->vhost_vdpa.index = queue_pair_index;
|
2022-12-15 14:31:42 +03:00
|
|
|
s->always_svq = svq;
|
vdpa: add vdpa net migration state notifier
This allows net to restart the device backend to configure SVQ on it.
Ideally, these changes should not be net specific and they could be done
in:
* vhost_vdpa_set_features (with VHOST_F_LOG_ALL)
* vhost_vdpa_set_vring_addr (with .enable_log)
* vhost_vdpa_set_log_base.
However, the vdpa net backend is the one with enough knowledge to
configure everything because of some reasons:
* Queues might need to be shadowed or not depending on its kind (control
vs data).
* Queues need to share the same map translations (iova tree).
Also, there are other problems that may have solutions but complicates
the implementation at this stage:
* We're basically duplicating vhost_dev_start and vhost_dev_stop, and
they could go out of sync. If we want to reuse them, we need a way to
skip some function calls to avoid recursiveness (either vhost_ops ->
vhost_set_features, vhost_set_vring_addr, ...).
* We need to traverse all vhost_dev of a given net device twice: one to
stop and get the vq state and another one after the reset to
configure properties like address, fd, etc.
Because of that it is cleaner to restart the whole net backend and
configure again as expected, similar to how vhost-kernel moves between
userspace and passthrough.
If more kinds of devices need dynamic switching to SVQ we can:
* Create a callback struct like VhostOps and move most of the code
there. VhostOps cannot be reused since all vdpa backend share them,
and to personalize just for networking would be too heavy.
* Add a parent struct or link all the vhost_vdpa or vhost_dev structs so
we can traverse them.
Signed-off-by: Eugenio Pérez <eperezma@redhat.com>
Message-Id: <20230303172445.1089785-9-eperezma@redhat.com>
Tested-by: Lei Yang <leiyang@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
2023-03-03 20:24:39 +03:00
|
|
|
s->migration_state.notify = vdpa_net_migration_state_notifier;
|
2022-07-20 09:59:46 +03:00
|
|
|
s->vhost_vdpa.shadow_vqs_enabled = svq;
|
2022-12-15 14:31:38 +03:00
|
|
|
s->vhost_vdpa.iova_range = iova_range;
|
2022-12-15 14:31:43 +03:00
|
|
|
s->vhost_vdpa.shadow_data = svq;
|
2023-03-03 20:24:42 +03:00
|
|
|
if (queue_pair_index == 0) {
|
|
|
|
vhost_vdpa_net_valid_svq_features(features,
|
|
|
|
&s->vhost_vdpa.migration_blocker);
|
|
|
|
} else if (!is_datapath) {
|
2022-07-20 09:59:43 +03:00
|
|
|
s->cvq_cmd_out_buffer = qemu_memalign(qemu_real_host_page_size(),
|
|
|
|
vhost_vdpa_net_cvq_cmd_page_len());
|
|
|
|
memset(s->cvq_cmd_out_buffer, 0, vhost_vdpa_net_cvq_cmd_page_len());
|
2022-09-06 18:07:14 +03:00
|
|
|
s->status = qemu_memalign(qemu_real_host_page_size(),
|
|
|
|
vhost_vdpa_net_cvq_cmd_page_len());
|
|
|
|
memset(s->status, 0, vhost_vdpa_net_cvq_cmd_page_len());
|
2022-07-20 09:59:43 +03:00
|
|
|
|
2022-07-20 09:59:42 +03:00
|
|
|
s->vhost_vdpa.shadow_vq_ops = &vhost_vdpa_net_svq_ops;
|
|
|
|
s->vhost_vdpa.shadow_vq_ops_opaque = s;
|
2023-03-03 20:24:41 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* TODO: We cannot migrate devices with CVQ as there is no way to set
|
|
|
|
* the device state (MAC, MQ, etc) before starting the datapath.
|
|
|
|
*
|
|
|
|
* Migration blocker ownership now belongs to s->vhost_vdpa.
|
|
|
|
*/
|
|
|
|
error_setg(&s->vhost_vdpa.migration_blocker,
|
|
|
|
"net vdpa cannot migrate with CVQ feature");
|
2022-07-20 09:59:42 +03:00
|
|
|
}
|
2021-10-20 07:56:00 +03:00
|
|
|
ret = vhost_vdpa_add(nc, (void *)&s->vhost_vdpa, queue_pair_index, nvqs);
|
2021-09-03 12:10:20 +03:00
|
|
|
if (ret) {
|
|
|
|
qemu_del_net_client(nc);
|
2021-10-20 07:55:54 +03:00
|
|
|
return NULL;
|
2021-09-03 12:10:20 +03:00
|
|
|
}
|
2021-10-20 07:55:54 +03:00
|
|
|
return nc;
|
2020-07-01 17:55:38 +03:00
|
|
|
}
|
|
|
|
|
2022-07-20 09:59:44 +03:00
|
|
|
static int vhost_vdpa_get_features(int fd, uint64_t *features, Error **errp)
|
|
|
|
{
|
|
|
|
int ret = ioctl(fd, VHOST_GET_FEATURES, features);
|
|
|
|
if (unlikely(ret < 0)) {
|
|
|
|
error_setg_errno(errp, errno,
|
|
|
|
"Fail to query features from vhost-vDPA device");
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vhost_vdpa_get_max_queue_pairs(int fd, uint64_t features,
|
|
|
|
int *has_cvq, Error **errp)
|
2021-10-20 07:56:00 +03:00
|
|
|
{
|
|
|
|
unsigned long config_size = offsetof(struct vhost_vdpa_config, buf);
|
2021-11-02 18:51:57 +03:00
|
|
|
g_autofree struct vhost_vdpa_config *config = NULL;
|
2021-10-20 07:56:00 +03:00
|
|
|
__virtio16 *max_queue_pairs;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (features & (1 << VIRTIO_NET_F_CTRL_VQ)) {
|
|
|
|
*has_cvq = 1;
|
|
|
|
} else {
|
|
|
|
*has_cvq = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (features & (1 << VIRTIO_NET_F_MQ)) {
|
|
|
|
config = g_malloc0(config_size + sizeof(*max_queue_pairs));
|
|
|
|
config->off = offsetof(struct virtio_net_config, max_virtqueue_pairs);
|
|
|
|
config->len = sizeof(*max_queue_pairs);
|
|
|
|
|
|
|
|
ret = ioctl(fd, VHOST_VDPA_GET_CONFIG, config);
|
|
|
|
if (ret) {
|
|
|
|
error_setg(errp, "Fail to get config from vhost-vDPA device");
|
|
|
|
return -ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
max_queue_pairs = (__virtio16 *)&config->buf;
|
|
|
|
|
|
|
|
return lduw_le_p(max_queue_pairs);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2020-07-01 17:55:38 +03:00
|
|
|
int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
|
|
|
|
NetClientState *peer, Error **errp)
|
|
|
|
{
|
|
|
|
const NetdevVhostVDPAOptions *opts;
|
2022-07-20 09:59:44 +03:00
|
|
|
uint64_t features;
|
2021-10-20 07:55:54 +03:00
|
|
|
int vdpa_device_fd;
|
2022-02-14 22:34:15 +03:00
|
|
|
g_autofree NetClientState **ncs = NULL;
|
2022-12-15 14:31:38 +03:00
|
|
|
struct vhost_vdpa_iova_range iova_range;
|
2022-02-14 22:34:15 +03:00
|
|
|
NetClientState *nc;
|
2022-08-02 14:24:46 +03:00
|
|
|
int queue_pairs, r, i = 0, has_cvq = 0;
|
2020-07-01 17:55:38 +03:00
|
|
|
|
|
|
|
assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
|
|
opts = &netdev->u.vhost_vdpa;
|
2022-11-04 19:07:00 +03:00
|
|
|
if (!opts->vhostdev && !opts->vhostfd) {
|
2022-10-08 10:58:58 +03:00
|
|
|
error_setg(errp,
|
|
|
|
"vhost-vdpa: neither vhostdev= nor vhostfd= was specified");
|
2021-11-12 22:34:31 +03:00
|
|
|
return -1;
|
|
|
|
}
|
2021-10-20 07:55:51 +03:00
|
|
|
|
2022-11-04 19:07:00 +03:00
|
|
|
if (opts->vhostdev && opts->vhostfd) {
|
2022-10-08 10:58:58 +03:00
|
|
|
error_setg(errp,
|
|
|
|
"vhost-vdpa: vhostdev= and vhostfd= are mutually exclusive");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2022-11-04 19:07:00 +03:00
|
|
|
if (opts->vhostdev) {
|
2022-10-08 10:58:58 +03:00
|
|
|
vdpa_device_fd = qemu_open(opts->vhostdev, O_RDWR, errp);
|
|
|
|
if (vdpa_device_fd == -1) {
|
|
|
|
return -errno;
|
|
|
|
}
|
2022-10-31 16:29:01 +03:00
|
|
|
} else {
|
|
|
|
/* has_vhostfd */
|
2022-10-08 10:58:58 +03:00
|
|
|
vdpa_device_fd = monitor_fd_param(monitor_cur(), opts->vhostfd, errp);
|
|
|
|
if (vdpa_device_fd == -1) {
|
|
|
|
error_prepend(errp, "vhost-vdpa: unable to parse vhostfd: ");
|
|
|
|
return -1;
|
|
|
|
}
|
2021-10-20 07:55:51 +03:00
|
|
|
}
|
|
|
|
|
2022-07-20 09:59:44 +03:00
|
|
|
r = vhost_vdpa_get_features(vdpa_device_fd, &features, errp);
|
|
|
|
if (unlikely(r < 0)) {
|
2022-08-02 14:24:46 +03:00
|
|
|
goto err;
|
2022-07-20 09:59:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
queue_pairs = vhost_vdpa_get_max_queue_pairs(vdpa_device_fd, features,
|
2021-10-20 07:56:00 +03:00
|
|
|
&has_cvq, errp);
|
|
|
|
if (queue_pairs < 0) {
|
2021-10-20 07:55:51 +03:00
|
|
|
qemu_close(vdpa_device_fd);
|
2021-10-20 07:56:00 +03:00
|
|
|
return queue_pairs;
|
|
|
|
}
|
|
|
|
|
2022-12-24 14:48:48 +03:00
|
|
|
r = vhost_vdpa_get_iova_range(vdpa_device_fd, &iova_range);
|
|
|
|
if (unlikely(r < 0)) {
|
|
|
|
error_setg(errp, "vhost-vdpa: get iova range failed: %s",
|
|
|
|
strerror(-r));
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2023-03-03 20:24:32 +03:00
|
|
|
if (opts->x_svq && !vhost_vdpa_net_valid_svq_features(features, errp)) {
|
|
|
|
goto err;
|
2022-07-20 09:59:46 +03:00
|
|
|
}
|
|
|
|
|
2021-10-20 07:56:00 +03:00
|
|
|
ncs = g_malloc0(sizeof(*ncs) * queue_pairs);
|
|
|
|
|
|
|
|
for (i = 0; i < queue_pairs; i++) {
|
|
|
|
ncs[i] = net_vhost_vdpa_init(peer, TYPE_VHOST_VDPA, name,
|
2022-07-20 09:59:46 +03:00
|
|
|
vdpa_device_fd, i, 2, true, opts->x_svq,
|
2023-03-03 20:24:42 +03:00
|
|
|
iova_range, features);
|
2021-10-20 07:56:00 +03:00
|
|
|
if (!ncs[i])
|
|
|
|
goto err;
|
2021-10-20 07:55:51 +03:00
|
|
|
}
|
|
|
|
|
2021-10-20 07:56:00 +03:00
|
|
|
if (has_cvq) {
|
|
|
|
nc = net_vhost_vdpa_init(peer, TYPE_VHOST_VDPA, name,
|
2022-07-20 09:59:46 +03:00
|
|
|
vdpa_device_fd, i, 1, false,
|
2023-03-03 20:24:42 +03:00
|
|
|
opts->x_svq, iova_range, features);
|
2021-10-20 07:56:00 +03:00
|
|
|
if (!nc)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
2021-10-20 07:55:54 +03:00
|
|
|
return 0;
|
2021-10-20 07:56:00 +03:00
|
|
|
|
|
|
|
err:
|
|
|
|
if (i) {
|
2022-05-07 05:28:14 +03:00
|
|
|
for (i--; i >= 0; i--) {
|
|
|
|
qemu_del_net_client(ncs[i]);
|
|
|
|
}
|
2021-10-20 07:56:00 +03:00
|
|
|
}
|
2022-07-20 09:59:46 +03:00
|
|
|
|
2021-10-20 07:56:00 +03:00
|
|
|
qemu_close(vdpa_device_fd);
|
|
|
|
|
|
|
|
return -1;
|
2020-07-01 17:55:38 +03:00
|
|
|
}
|