Vendor driver may not support or implement config interrupt delivery for link status notifications. In this event, vendor driver is expected to NACK the feature, but guest will keep link always up. Signed-off-by: Si-Wei Liu <si-wei.liu@oracle.com> Message-Id: <1601582985-14944-1-git-send-email-si-wei.liu@oracle.com> Reviewed-by: Michael S. Tsirkin <mst@redhat.com> Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
230 lines
6.1 KiB
C
230 lines
6.1 KiB
C
/*
|
|
* 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"
|
|
#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"
|
|
#include "qemu/option.h"
|
|
#include "qapi/error.h"
|
|
#include <sys/ioctl.h>
|
|
#include <err.h>
|
|
#include "standard-headers/linux/virtio_net.h"
|
|
#include "monitor/monitor.h"
|
|
#include "hw/virtio/vhost.h"
|
|
|
|
/* Todo:need to add the multiqueue support here */
|
|
typedef struct VhostVDPAState {
|
|
NetClientState nc;
|
|
struct vhost_vdpa vhost_vdpa;
|
|
VHostNetState *vhost_net;
|
|
uint64_t acked_features;
|
|
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,
|
|
VIRTIO_F_IOMMU_PLATFORM,
|
|
VIRTIO_F_RING_PACKED,
|
|
VIRTIO_NET_F_GUEST_ANNOUNCE,
|
|
VIRTIO_NET_F_STATUS,
|
|
VHOST_INVALID_FEATURE_BIT
|
|
};
|
|
|
|
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;
|
|
}
|
|
|
|
uint64_t vhost_vdpa_get_acked_features(NetClientState *nc)
|
|
{
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
assert(nc->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
s->acked_features = vhost_net_get_acked_features(s->vhost_net);
|
|
|
|
return s->acked_features;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static void vhost_vdpa_del(NetClientState *ncs)
|
|
{
|
|
VhostVDPAState *s;
|
|
assert(ncs->info->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
s = DO_UPCAST(VhostVDPAState, nc, ncs);
|
|
if (s->vhost_net) {
|
|
vhost_net_cleanup(s->vhost_net);
|
|
}
|
|
}
|
|
|
|
static int vhost_vdpa_add(NetClientState *ncs, void *be)
|
|
{
|
|
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;
|
|
|
|
net = vhost_net_init(&options);
|
|
if (!net) {
|
|
error_report("failed to init vhost_net for queue");
|
|
goto err;
|
|
}
|
|
if (s->vhost_net) {
|
|
vhost_net_cleanup(s->vhost_net);
|
|
g_free(s->vhost_net);
|
|
}
|
|
s->vhost_net = net;
|
|
ret = vhost_vdpa_net_check_device_id(net);
|
|
if (ret) {
|
|
goto err;
|
|
}
|
|
return 0;
|
|
err:
|
|
if (net) {
|
|
vhost_net_cleanup(net);
|
|
}
|
|
vhost_vdpa_del(ncs);
|
|
return -1;
|
|
}
|
|
|
|
static void vhost_vdpa_cleanup(NetClientState *nc)
|
|
{
|
|
VhostVDPAState *s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
|
|
if (s->vhost_net) {
|
|
vhost_net_cleanup(s->vhost_net);
|
|
g_free(s->vhost_net);
|
|
s->vhost_net = NULL;
|
|
}
|
|
}
|
|
|
|
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));
|
|
|
|
}
|
|
|
|
static NetClientInfo net_vhost_vdpa_info = {
|
|
.type = NET_CLIENT_DRIVER_VHOST_VDPA,
|
|
.size = sizeof(VhostVDPAState),
|
|
.cleanup = vhost_vdpa_cleanup,
|
|
.has_vnet_hdr = vhost_vdpa_has_vnet_hdr,
|
|
.has_ufo = vhost_vdpa_has_ufo,
|
|
};
|
|
|
|
static int net_vhost_vdpa_init(NetClientState *peer, const char *device,
|
|
const char *name, const char *vhostdev)
|
|
{
|
|
NetClientState *nc = NULL;
|
|
VhostVDPAState *s;
|
|
int vdpa_device_fd = -1;
|
|
int ret = 0;
|
|
assert(name);
|
|
nc = qemu_new_net_client(&net_vhost_vdpa_info, peer, device, name);
|
|
snprintf(nc->info_str, sizeof(nc->info_str), TYPE_VHOST_VDPA);
|
|
nc->queue_index = 0;
|
|
s = DO_UPCAST(VhostVDPAState, nc, nc);
|
|
vdpa_device_fd = qemu_open_old(vhostdev, O_RDWR);
|
|
if (vdpa_device_fd == -1) {
|
|
return -errno;
|
|
}
|
|
s->vhost_vdpa.device_fd = vdpa_device_fd;
|
|
ret = vhost_vdpa_add(nc, (void *)&s->vhost_vdpa);
|
|
assert(s->vhost_net);
|
|
return ret;
|
|
}
|
|
|
|
static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp)
|
|
{
|
|
const char *name = opaque;
|
|
const char *driver, *netdev;
|
|
|
|
driver = qemu_opt_get(opts, "driver");
|
|
netdev = qemu_opt_get(opts, "netdev");
|
|
if (!driver || !netdev) {
|
|
return 0;
|
|
}
|
|
if (strcmp(netdev, name) == 0 &&
|
|
!g_str_has_prefix(driver, "virtio-net-")) {
|
|
error_setg(errp, "vhost-vdpa requires frontend driver virtio-net-*");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int net_init_vhost_vdpa(const Netdev *netdev, const char *name,
|
|
NetClientState *peer, Error **errp)
|
|
{
|
|
const NetdevVhostVDPAOptions *opts;
|
|
|
|
assert(netdev->type == NET_CLIENT_DRIVER_VHOST_VDPA);
|
|
opts = &netdev->u.vhost_vdpa;
|
|
/* verify net frontend */
|
|
if (qemu_opts_foreach(qemu_find_opts("device"), net_vhost_check_net,
|
|
(char *)name, errp)) {
|
|
return -1;
|
|
}
|
|
return net_vhost_vdpa_init(peer, TYPE_VHOST_VDPA, name, opts->vhostdev);
|
|
}
|