* [Qemu-devel] [PATCH v4 01/22] vhost-user: refactor ioctl translation
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 02/22] vhost-user: add protocol feature negotiation marcandre.lureau
` (20 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel; +Cc: thibaut.collet, jasowang, mst, haifeng.lin, pbonzini
From: "Michael S. Tsirkin" <mst@redhat.com>
translate at the outset, have rest of code use vhost-user features
exclusively.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
---
hw/virtio/vhost-user.c | 87 ++++++++++++++++++++++++++------------------------
1 file changed, 46 insertions(+), 41 deletions(-)
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index e7ab829..5a83d00 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -89,35 +89,40 @@ static bool ioeventfd_enabled(void)
return kvm_enabled() && kvm_eventfds_enabled();
}
-static unsigned long int ioctl_to_vhost_user_request[VHOST_USER_MAX] = {
- -1, /* VHOST_USER_NONE */
- VHOST_GET_FEATURES, /* VHOST_USER_GET_FEATURES */
- VHOST_SET_FEATURES, /* VHOST_USER_SET_FEATURES */
- VHOST_SET_OWNER, /* VHOST_USER_SET_OWNER */
- VHOST_RESET_OWNER, /* VHOST_USER_RESET_OWNER */
- VHOST_SET_MEM_TABLE, /* VHOST_USER_SET_MEM_TABLE */
- VHOST_SET_LOG_BASE, /* VHOST_USER_SET_LOG_BASE */
- VHOST_SET_LOG_FD, /* VHOST_USER_SET_LOG_FD */
- VHOST_SET_VRING_NUM, /* VHOST_USER_SET_VRING_NUM */
- VHOST_SET_VRING_ADDR, /* VHOST_USER_SET_VRING_ADDR */
- VHOST_SET_VRING_BASE, /* VHOST_USER_SET_VRING_BASE */
- VHOST_GET_VRING_BASE, /* VHOST_USER_GET_VRING_BASE */
- VHOST_SET_VRING_KICK, /* VHOST_USER_SET_VRING_KICK */
- VHOST_SET_VRING_CALL, /* VHOST_USER_SET_VRING_CALL */
- VHOST_SET_VRING_ERR /* VHOST_USER_SET_VRING_ERR */
-};
-
static VhostUserRequest vhost_user_request_translate(unsigned long int request)
{
- VhostUserRequest idx;
-
- for (idx = 0; idx < VHOST_USER_MAX; idx++) {
- if (ioctl_to_vhost_user_request[idx] == request) {
- break;
- }
+ switch (request) {
+ case VHOST_GET_FEATURES:
+ return VHOST_USER_GET_FEATURES;
+ case VHOST_SET_FEATURES:
+ return VHOST_USER_SET_FEATURES;
+ case VHOST_SET_OWNER:
+ return VHOST_USER_SET_OWNER;
+ case VHOST_RESET_OWNER:
+ return VHOST_USER_RESET_OWNER;
+ case VHOST_SET_MEM_TABLE:
+ return VHOST_USER_SET_MEM_TABLE;
+ case VHOST_SET_LOG_BASE:
+ return VHOST_USER_SET_LOG_BASE;
+ case VHOST_SET_LOG_FD:
+ return VHOST_USER_SET_LOG_FD;
+ case VHOST_SET_VRING_NUM:
+ return VHOST_USER_SET_VRING_NUM;
+ case VHOST_SET_VRING_ADDR:
+ return VHOST_USER_SET_VRING_ADDR;
+ case VHOST_SET_VRING_BASE:
+ return VHOST_USER_SET_VRING_BASE;
+ case VHOST_GET_VRING_BASE:
+ return VHOST_USER_GET_VRING_BASE;
+ case VHOST_SET_VRING_KICK:
+ return VHOST_USER_SET_VRING_KICK;
+ case VHOST_SET_VRING_CALL:
+ return VHOST_USER_SET_VRING_CALL;
+ case VHOST_SET_VRING_ERR:
+ return VHOST_USER_SET_VRING_ERR;
+ default:
+ return VHOST_USER_MAX;
}
-
- return (idx == VHOST_USER_MAX) ? VHOST_USER_NONE : idx;
}
static int vhost_user_read(struct vhost_dev *dev, VhostUserMsg *msg)
@@ -198,22 +203,22 @@ static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
msg.flags = VHOST_USER_VERSION;
msg.size = 0;
- switch (request) {
- case VHOST_GET_FEATURES:
+ switch (msg_request) {
+ case VHOST_USER_GET_FEATURES:
need_reply = 1;
break;
- case VHOST_SET_FEATURES:
- case VHOST_SET_LOG_BASE:
+ case VHOST_USER_SET_FEATURES:
+ case VHOST_USER_SET_LOG_BASE:
msg.u64 = *((__u64 *) arg);
msg.size = sizeof(m.u64);
break;
- case VHOST_SET_OWNER:
- case VHOST_RESET_OWNER:
+ case VHOST_USER_SET_OWNER:
+ case VHOST_USER_RESET_OWNER:
break;
- case VHOST_SET_MEM_TABLE:
+ case VHOST_USER_SET_MEM_TABLE:
for (i = 0; i < dev->mem->nregions; ++i) {
struct vhost_memory_region *reg = dev->mem->regions + i;
ram_addr_t ram_addr;
@@ -246,30 +251,30 @@ static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
break;
- case VHOST_SET_LOG_FD:
+ case VHOST_USER_SET_LOG_FD:
fds[fd_num++] = *((int *) arg);
break;
- case VHOST_SET_VRING_NUM:
- case VHOST_SET_VRING_BASE:
+ case VHOST_USER_SET_VRING_NUM:
+ case VHOST_USER_SET_VRING_BASE:
memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
msg.size = sizeof(m.state);
break;
- case VHOST_GET_VRING_BASE:
+ case VHOST_USER_GET_VRING_BASE:
memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
msg.size = sizeof(m.state);
need_reply = 1;
break;
- case VHOST_SET_VRING_ADDR:
+ case VHOST_USER_SET_VRING_ADDR:
memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
msg.size = sizeof(m.addr);
break;
- case VHOST_SET_VRING_KICK:
- case VHOST_SET_VRING_CALL:
- case VHOST_SET_VRING_ERR:
+ case VHOST_USER_SET_VRING_KICK:
+ case VHOST_USER_SET_VRING_CALL:
+ case VHOST_USER_SET_VRING_ERR:
file = arg;
msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
msg.size = sizeof(m.u64);
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 02/22] vhost-user: add protocol feature negotiation
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 01/22] vhost-user: refactor ioctl translation marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 03/22] vhost-user: unit test for new messages marcandre.lureau
` (19 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel; +Cc: thibaut.collet, jasowang, mst, haifeng.lin, pbonzini
From: "Michael S. Tsirkin" <mst@redhat.com>
Support a separate bitmask for vhost-user protocol features,
and messages to get/set protocol features.
Invoke them at init.
No features are defined yet.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
---
docs/specs/vhost-user.txt | 37 +++++++++++++++++++++++++++++++++
hw/net/vhost_net.c | 2 ++
hw/virtio/vhost-user.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++
include/hw/virtio/vhost.h | 1 +
4 files changed, 92 insertions(+)
diff --git a/docs/specs/vhost-user.txt b/docs/specs/vhost-user.txt
index 650bb18..0062baa 100644
--- a/docs/specs/vhost-user.txt
+++ b/docs/specs/vhost-user.txt
@@ -113,6 +113,7 @@ message replies. Most of the requests don't require replies. Here is a list of
the ones that do:
* VHOST_GET_FEATURES
+ * VHOST_GET_PROTOCOL_FEATURES
* VHOST_GET_VRING_BASE
There are several messages that the master sends with file descriptors passed
@@ -127,6 +128,13 @@ in the ancillary data:
If Master is unable to send the full message or receives a wrong reply it will
close the connection. An optional reconnection mechanism can be implemented.
+Any protocol extensions are gated by protocol feature bits,
+which allows full backwards compatibility on both master
+and slave.
+As older slaves don't support negotiating protocol features,
+a feature bit was dedicated for this purpose:
+#define VHOST_USER_F_PROTOCOL_FEATURES 30
+
Message types
-------------
@@ -138,6 +146,8 @@ Message types
Slave payload: u64
Get from the underlying vhost implementation the features bitmask.
+ Feature bit VHOST_USER_F_PROTOCOL_FEATURES signals slave support for
+ VHOST_USER_GET_PROTOCOL_FEATURES and VHOST_USER_SET_PROTOCOL_FEATURES.
* VHOST_USER_SET_FEATURES
@@ -146,6 +156,33 @@ Message types
Master payload: u64
Enable features in the underlying vhost implementation using a bitmask.
+ Feature bit VHOST_USER_F_PROTOCOL_FEATURES signals master support for
+ VHOST_USER_GET_PROTOCOL_FEATURES and VHOST_USER_SET_PROTOCOL_FEATURES.
+
+ * VHOST_USER_GET_PROTOCOL_FEATURES
+
+ Id: 15
+ Equivalent ioctl: VHOST_GET_FEATURES
+ Master payload: N/A
+ Slave payload: u64
+
+ Get the protocol feature bitmask from the underlying vhost implementation.
+ Only legal if feature bit VHOST_USER_F_PROTOCOL_FEATURES is present in
+ VHOST_USER_GET_FEATURES.
+ Note: slave that reported VHOST_USER_F_PROTOCOL_FEATURES must support
+ this message even before VHOST_USER_SET_FEATURES was called.
+
+ * VHOST_USER_SET_PROTOCOL_FEATURES
+
+ Id: 16
+ Ioctl: VHOST_SET_FEATURES
+ Master payload: u64
+
+ Enable protocol features in the underlying vhost implementation.
+ Only legal if feature bit VHOST_USER_F_PROTOCOL_FEATURES is present in
+ VHOST_USER_GET_FEATURES.
+ Note: slave that reported VHOST_USER_F_PROTOCOL_FEATURES must support
+ this message even before VHOST_USER_SET_FEATURES was called.
* VHOST_USER_SET_OWNER
diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
index 1d76b94..9d32d76 100644
--- a/hw/net/vhost_net.c
+++ b/hw/net/vhost_net.c
@@ -152,8 +152,10 @@ struct vhost_net *vhost_net_init(VhostNetOptions *options)
net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend)
? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR);
net->backend = r;
+ net->dev.protocol_features = 0;
} else {
net->dev.backend_features = 0;
+ net->dev.protocol_features = 0;
net->backend = -1;
}
net->nc = options->net_backend;
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index 5a83d00..de87562 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -25,6 +25,9 @@
#define VHOST_MEMORY_MAX_NREGIONS 8
+#define VHOST_USER_F_PROTOCOL_FEATURES 30
+#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x0ULL
+
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
VHOST_USER_GET_FEATURES = 1,
@@ -41,6 +44,8 @@ typedef enum VhostUserRequest {
VHOST_USER_SET_VRING_KICK = 12,
VHOST_USER_SET_VRING_CALL = 13,
VHOST_USER_SET_VRING_ERR = 14,
+ VHOST_USER_GET_PROTOCOL_FEATURES = 15,
+ VHOST_USER_SET_PROTOCOL_FEATURES = 16,
VHOST_USER_MAX
} VhostUserRequest;
@@ -332,10 +337,57 @@ static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
static int vhost_user_init(struct vhost_dev *dev, void *opaque)
{
+ VhostUserMsg msg = { 0 };
+ int err;
+
assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
dev->opaque = opaque;
+ msg.request = VHOST_USER_GET_FEATURES;
+ msg.flags = VHOST_USER_VERSION;
+ msg.size = 0;
+
+ err = vhost_user_write(dev, &msg, NULL, 0);
+ if (err < 0) {
+ return err;
+ }
+
+ err = vhost_user_read(dev, &msg);
+ if (err < 0) {
+ return err;
+ }
+
+ if (virtio_has_feature(msg.u64, VHOST_USER_F_PROTOCOL_FEATURES)) {
+ dev->backend_features |= 1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
+
+ msg.request = VHOST_USER_GET_PROTOCOL_FEATURES;
+ msg.flags = VHOST_USER_VERSION;
+ msg.size = 0;
+
+ err = vhost_user_write(dev, &msg, NULL, 0);
+ if (err < 0) {
+ return err;
+ }
+
+ err = vhost_user_read(dev, &msg);
+ if (err < 0) {
+ return err;
+ }
+
+ dev->protocol_features = msg.u64 & VHOST_USER_PROTOCOL_FEATURE_MASK;
+
+ msg.request = VHOST_USER_SET_PROTOCOL_FEATURES;
+ msg.flags = VHOST_USER_VERSION;
+ msg.u64 = dev->protocol_features;
+ msg.size = sizeof msg.u64;
+
+ err = vhost_user_write(dev, &msg, NULL, 0);
+ if (err < 0) {
+ return err;
+ }
+ }
+
return 0;
}
diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h
index dd51050..6467c73 100644
--- a/include/hw/virtio/vhost.h
+++ b/include/hw/virtio/vhost.h
@@ -47,6 +47,7 @@ struct vhost_dev {
unsigned long long features;
unsigned long long acked_features;
unsigned long long backend_features;
+ unsigned long long protocol_features;
bool started;
bool log_enabled;
unsigned long long log_size;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 03/22] vhost-user: unit test for new messages
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 01/22] vhost-user: refactor ioctl translation marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 02/22] vhost-user: add protocol feature negotiation marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 04/22] configure: probe for memfd marcandre.lureau
` (18 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel; +Cc: thibaut.collet, jasowang, mst, haifeng.lin, pbonzini
From: "Michael S. Tsirkin" <mst@redhat.com>
Data is empty for now, but do make sure master
sets the new feature bit flag.
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
---
tests/vhost-user-test.c | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 75fedf0..228acb6 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -53,6 +53,8 @@
#define VHOST_MEMORY_MAX_NREGIONS 8
+#define VHOST_USER_F_PROTOCOL_FEATURES 30
+
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
VHOST_USER_GET_FEATURES = 1,
@@ -69,6 +71,8 @@ typedef enum VhostUserRequest {
VHOST_USER_SET_VRING_KICK = 12,
VHOST_USER_SET_VRING_CALL = 13,
VHOST_USER_SET_VRING_ERR = 14,
+ VHOST_USER_GET_PROTOCOL_FEATURES = 15,
+ VHOST_USER_SET_PROTOCOL_FEATURES = 16,
VHOST_USER_MAX
} VhostUserRequest;
@@ -293,11 +297,26 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.u64);
+ msg.u64 = 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
+ p = (uint8_t *) &msg;
+ qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
+ break;
+
+ case VHOST_USER_SET_FEATURES:
+ g_assert_cmpint(msg.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
+ !=, 0ULL);
+ break;
+
+ case VHOST_USER_GET_PROTOCOL_FEATURES:
+ /* send back features to qemu */
+ msg.flags |= VHOST_USER_REPLY_MASK;
+ msg.size = sizeof(m.u64);
msg.u64 = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
+
case VHOST_USER_GET_VRING_BASE:
/* send back vring base to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 04/22] configure: probe for memfd
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (2 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 03/22] vhost-user: unit test for new messages marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 05/22] util: add linux-only memfd fallback marcandre.lureau
` (17 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Check if memfd_create() is part of system libc.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
configure | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/configure b/configure
index 52f5b79..a7cdfa4 100755
--- a/configure
+++ b/configure
@@ -3455,6 +3455,22 @@ if compile_prog "" "" ; then
eventfd=yes
fi
+# check if memfd is supported
+memfd=no
+cat > $TMPC << EOF
+#include <sys/memfd.h>
+
+int main(void)
+{
+ return memfd_create("foo", MFD_ALLOW_SEALING);
+}
+EOF
+if compile_prog "" "" ; then
+ memfd=yes
+fi
+
+
+
# check for fallocate
fallocate=no
cat > $TMPC << EOF
@@ -4840,6 +4856,9 @@ fi
if test "$eventfd" = "yes" ; then
echo "CONFIG_EVENTFD=y" >> $config_host_mak
fi
+if test "$memfd" = "yes" ; then
+ echo "CONFIG_MEMFD=y" >> $config_host_mak
+fi
if test "$fallocate" = "yes" ; then
echo "CONFIG_FALLOCATE=y" >> $config_host_mak
fi
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 05/22] util: add linux-only memfd fallback
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (3 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 04/22] configure: probe for memfd marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 06/22] util: add memfd helpers marcandre.lureau
` (16 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Implement memfd_create() fallback if not available in system libc.
memfd_create() is still not included in glibc today, atlhough it's been
available since Linux 3.17 in Oct 2014.
memfd has numerous advantages over traditional shm/mmap for ipc memory
sharing with fd handler, which we are going to make use of for
vhost-user logging memory in following patches.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
include/qemu/memfd.h | 20 +++++++++++++++++++
util/Makefile.objs | 2 +-
util/memfd.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 77 insertions(+), 1 deletion(-)
create mode 100644 include/qemu/memfd.h
create mode 100644 util/memfd.c
diff --git a/include/qemu/memfd.h b/include/qemu/memfd.h
new file mode 100644
index 0000000..8b1fe6a
--- /dev/null
+++ b/include/qemu/memfd.h
@@ -0,0 +1,20 @@
+#ifndef QEMU_MEMFD_H
+#define QEMU_MEMFD_H
+
+#include "config-host.h"
+
+#ifndef F_LINUX_SPECIFIC_BASE
+#define F_LINUX_SPECIFIC_BASE 1024
+#endif
+
+#ifndef F_ADD_SEALS
+#define F_ADD_SEALS (F_LINUX_SPECIFIC_BASE + 9)
+#define F_GET_SEALS (F_LINUX_SPECIFIC_BASE + 10)
+
+#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */
+#define F_SEAL_SHRINK 0x0002 /* prevent file from shrinking */
+#define F_SEAL_GROW 0x0004 /* prevent file from growing */
+#define F_SEAL_WRITE 0x0008 /* prevent writes */
+#endif
+
+#endif /* QEMU_MEMFD_H */
diff --git a/util/Makefile.objs b/util/Makefile.objs
index 114d657..84c5485 100644
--- a/util/Makefile.objs
+++ b/util/Makefile.objs
@@ -1,6 +1,6 @@
util-obj-y = osdep.o cutils.o unicode.o qemu-timer-common.o
util-obj-$(CONFIG_WIN32) += oslib-win32.o qemu-thread-win32.o event_notifier-win32.o
-util-obj-$(CONFIG_POSIX) += oslib-posix.o qemu-thread-posix.o event_notifier-posix.o qemu-openpty.o
+util-obj-$(CONFIG_POSIX) += oslib-posix.o qemu-thread-posix.o event_notifier-posix.o qemu-openpty.o memfd.o
util-obj-y += envlist.o path.o module.o
util-obj-$(call lnot,$(CONFIG_INT128)) += host-utils.o
util-obj-y += bitmap.o bitops.o hbitmap.o
diff --git a/util/memfd.c b/util/memfd.c
new file mode 100644
index 0000000..a98d57e
--- /dev/null
+++ b/util/memfd.c
@@ -0,0 +1,56 @@
+/*
+ * memfd.c
+ *
+ * Copyright (c) 2015 Red Hat, Inc.
+ *
+ * QEMU library functions on POSIX which are shared between QEMU and
+ * the QEMU tools.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "config-host.h"
+
+#include "qemu/memfd.h"
+
+#ifdef CONFIG_MEMFD
+#include <sys/memfd.h>
+#elif defined CONFIG_LINUX
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <asm/unistd.h>
+
+#ifndef MFD_CLOEXEC
+#define MFD_CLOEXEC 0x0001U
+#endif
+
+#ifndef MFD_ALLOW_SEALING
+#define MFD_ALLOW_SEALING 0x0002U
+#endif
+
+static inline int memfd_create(const char *name, unsigned int flags)
+{
+ return syscall(__NR_memfd_create, name, flags);
+}
+#else /* !LINUX */
+static inline int memfd_create(const char *name, unsigned int flags)
+{
+ return -1;
+}
+#endif
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 06/22] util: add memfd helpers
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (4 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 05/22] util: add linux-only memfd fallback marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log marcandre.lureau
` (15 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Add qemu_memfd_alloc/free() helpers.
The function helps to allocate and seal a memfd, and implements an
open/unlink/mmap fallback for system that do not support memfd.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
include/qemu/memfd.h | 4 +++
util/memfd.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++++++--
2 files changed, 76 insertions(+), 2 deletions(-)
diff --git a/include/qemu/memfd.h b/include/qemu/memfd.h
index 8b1fe6a..950fb88 100644
--- a/include/qemu/memfd.h
+++ b/include/qemu/memfd.h
@@ -17,4 +17,8 @@
#define F_SEAL_WRITE 0x0008 /* prevent writes */
#endif
+void *qemu_memfd_alloc(const char *name, size_t size, unsigned int seals,
+ int *fd);
+void qemu_memfd_free(void *ptr, size_t size, int fd);
+
#endif /* QEMU_MEMFD_H */
diff --git a/util/memfd.c b/util/memfd.c
index a98d57e..8b2b785 100644
--- a/util/memfd.c
+++ b/util/memfd.c
@@ -27,6 +27,14 @@
#include "config-host.h"
+#include <glib.h>
+#include <glib/gprintf.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
#include "qemu/memfd.h"
#ifdef CONFIG_MEMFD
@@ -44,13 +52,75 @@
#define MFD_ALLOW_SEALING 0x0002U
#endif
-static inline int memfd_create(const char *name, unsigned int flags)
+static int memfd_create(const char *name, unsigned int flags)
{
return syscall(__NR_memfd_create, name, flags);
}
#else /* !LINUX */
-static inline int memfd_create(const char *name, unsigned int flags)
+static int memfd_create(const char *name, unsigned int flags)
{
return -1;
}
#endif
+
+void *qemu_memfd_alloc(const char *name, size_t size, unsigned int seals,
+ int *fd)
+{
+ void *ptr;
+ int mfd;
+
+ mfd = memfd_create(name, MFD_ALLOW_SEALING|MFD_CLOEXEC);
+ if (mfd != -1) {
+ if (ftruncate(mfd, size) == -1) {
+ perror("ftruncate");
+ close(mfd);
+ return NULL;
+ }
+
+ if (fcntl(mfd, F_ADD_SEALS, seals) == -1) {
+ perror("fcntl");
+ close(mfd);
+ return NULL;
+ }
+ } else {
+ const char *tmpdir = getenv("TMPDIR");
+ gchar *fname;
+
+ tmpdir = tmpdir ? tmpdir : "/tmp";
+
+ fname = g_strdup_printf("%s/memfd-XXXXXX", tmpdir);
+ mfd = mkstemp(fname);
+ unlink(fname);
+ g_free(fname);
+
+ if (mfd == -1) {
+ perror("mkstemp");
+ return NULL;
+ }
+
+ if (ftruncate(mfd, size) == -1) {
+ perror("ftruncate");
+ close(mfd);
+ return NULL;
+ }
+ }
+
+ ptr = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, mfd, 0);
+ if (ptr == MAP_FAILED) {
+ perror("mmap");
+ close(mfd);
+ return NULL;
+ }
+
+ *fd = mfd;
+ return ptr;
+}
+
+void qemu_memfd_free(void *ptr, size_t size, int fd)
+{
+ if (ptr) {
+ munmap(ptr, size);
+ }
+
+ close(fd);
+}
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (5 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 06/22] util: add memfd helpers marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-21 8:44 ` Michael S. Tsirkin
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 08/22] vhost: document log resizing marcandre.lureau
` (14 subsequent siblings)
21 siblings, 1 reply; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
If the backend is of type VHOST_BACKEND_TYPE_USER, allocate
shareable memory. Next patch will only allocate when the backend
has the required feature.
Note: vhost_log_get() can use a global "vhost_log" that can be shared by
several vhost devices. We may want instead a common shareable log and a
common non-shareable one.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/virtio/vhost.c | 38 +++++++++++++++++++++++++++++++-------
include/hw/virtio/vhost.h | 3 ++-
2 files changed, 33 insertions(+), 8 deletions(-)
diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
index a08c36b..cd3af16 100644
--- a/hw/virtio/vhost.c
+++ b/hw/virtio/vhost.c
@@ -18,6 +18,7 @@
#include "qemu/atomic.h"
#include "qemu/range.h"
#include "qemu/error-report.h"
+#include "qemu/memfd.h"
#include <linux/vhost.h>
#include "exec/address-spaces.h"
#include "hw/virtio/virtio-bus.h"
@@ -286,20 +287,34 @@ static uint64_t vhost_get_log_size(struct vhost_dev *dev)
}
return log_size;
}
-static struct vhost_log *vhost_log_alloc(uint64_t size)
+
+static struct vhost_log *vhost_log_alloc(uint64_t size, bool share)
{
- struct vhost_log *log = g_malloc0(sizeof *log + size * sizeof(*(log->log)));
+ struct vhost_log *log;
+ uint64_t logsize = size * sizeof(*(log->log));
+ int fd = -1;
+
+ log = g_new0(struct vhost_log, 1);
+ if (share) {
+ log->log = qemu_memfd_alloc("vhost-log", logsize,
+ F_SEAL_GROW|F_SEAL_SHRINK|F_SEAL_SEAL, &fd);
+ memset(log->log, 0, logsize);
+ } else {
+ log->log = g_malloc0(logsize);
+ }
log->size = size;
log->refcnt = 1;
+ log->fd = fd;
return log;
}
-static struct vhost_log *vhost_log_get(uint64_t size)
+static struct vhost_log *vhost_log_get(uint64_t size, bool share)
{
- if (!vhost_log || vhost_log->size != size) {
- vhost_log = vhost_log_alloc(size);
+ if (!vhost_log || vhost_log->size != size ||
+ (share && vhost_log->fd == -1)) {
+ vhost_log = vhost_log_alloc(size, share);
} else {
++vhost_log->refcnt;
}
@@ -324,13 +339,21 @@ static void vhost_log_put(struct vhost_dev *dev, bool sync)
if (vhost_log == log) {
vhost_log = NULL;
}
+
+ if (log->fd == -1) {
+ g_free(log->log);
+ } else {
+ qemu_memfd_free(log->log, log->size * sizeof(*(log->log)),
+ log->fd);
+ }
g_free(log);
}
}
static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
{
- struct vhost_log *log = vhost_log_get(size);
+ bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
+ struct vhost_log *log = vhost_log_get(size, share);
uint64_t log_base = (uintptr_t)log->log;
int r;
@@ -1136,9 +1159,10 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
if (hdev->log_enabled) {
uint64_t log_base;
+ bool share = hdev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
hdev->log_size = vhost_get_log_size(hdev);
- hdev->log = vhost_log_get(hdev->log_size);
+ hdev->log = vhost_log_get(hdev->log_size, share);
log_base = (uintptr_t)hdev->log->log;
r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
hdev->log_size ? &log_base : NULL);
diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h
index 6467c73..ab1dcac 100644
--- a/include/hw/virtio/vhost.h
+++ b/include/hw/virtio/vhost.h
@@ -31,7 +31,8 @@ typedef unsigned long vhost_log_chunk_t;
struct vhost_log {
unsigned long long size;
int refcnt;
- vhost_log_chunk_t log[0];
+ int fd;
+ vhost_log_chunk_t *log;
};
struct vhost_memory;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log marcandre.lureau
@ 2015-09-21 8:44 ` Michael S. Tsirkin
2015-09-21 14:02 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 8:44 UTC (permalink / raw)
To: marcandre.lureau
Cc: haifeng.lin, thibaut.collet, jasowang, qemu-devel, pbonzini
On Sat, Sep 19, 2015 at 12:11:58PM +0200, marcandre.lureau@redhat.com wrote:
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> If the backend is of type VHOST_BACKEND_TYPE_USER, allocate
> shareable memory. Next patch will only allocate when the backend
> has the required feature.
>
> Note: vhost_log_get() can use a global "vhost_log" that can be shared by
> several vhost devices. We may want instead a common shareable log and a
> common non-shareable one.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Well you do at least need to count the number of times the log is
shared. Otherwise, if you share the log, then unshare it, you are left
with a shared one.
> ---
> hw/virtio/vhost.c | 38 +++++++++++++++++++++++++++++++-------
> include/hw/virtio/vhost.h | 3 ++-
> 2 files changed, 33 insertions(+), 8 deletions(-)
>
> diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> index a08c36b..cd3af16 100644
> --- a/hw/virtio/vhost.c
> +++ b/hw/virtio/vhost.c
> @@ -18,6 +18,7 @@
> #include "qemu/atomic.h"
> #include "qemu/range.h"
> #include "qemu/error-report.h"
> +#include "qemu/memfd.h"
> #include <linux/vhost.h>
> #include "exec/address-spaces.h"
> #include "hw/virtio/virtio-bus.h"
> @@ -286,20 +287,34 @@ static uint64_t vhost_get_log_size(struct vhost_dev *dev)
> }
> return log_size;
> }
> -static struct vhost_log *vhost_log_alloc(uint64_t size)
> +
> +static struct vhost_log *vhost_log_alloc(uint64_t size, bool share)
> {
> - struct vhost_log *log = g_malloc0(sizeof *log + size * sizeof(*(log->log)));
> + struct vhost_log *log;
> + uint64_t logsize = size * sizeof(*(log->log));
> + int fd = -1;
> +
> + log = g_new0(struct vhost_log, 1);
> + if (share) {
> + log->log = qemu_memfd_alloc("vhost-log", logsize,
> + F_SEAL_GROW|F_SEAL_SHRINK|F_SEAL_SEAL, &fd);
> + memset(log->log, 0, logsize);
> + } else {
> + log->log = g_malloc0(logsize);
> + }
>
> log->size = size;
> log->refcnt = 1;
> + log->fd = fd;
>
> return log;
> }
>
> -static struct vhost_log *vhost_log_get(uint64_t size)
> +static struct vhost_log *vhost_log_get(uint64_t size, bool share)
> {
> - if (!vhost_log || vhost_log->size != size) {
> - vhost_log = vhost_log_alloc(size);
> + if (!vhost_log || vhost_log->size != size ||
> + (share && vhost_log->fd == -1)) {
> + vhost_log = vhost_log_alloc(size, share);
> } else {
> ++vhost_log->refcnt;
> }
> @@ -324,13 +339,21 @@ static void vhost_log_put(struct vhost_dev *dev, bool sync)
> if (vhost_log == log) {
> vhost_log = NULL;
> }
> +
> + if (log->fd == -1) {
> + g_free(log->log);
> + } else {
> + qemu_memfd_free(log->log, log->size * sizeof(*(log->log)),
> + log->fd);
> + }
> g_free(log);
> }
> }
>
> static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
> {
> - struct vhost_log *log = vhost_log_get(size);
> + bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
> + struct vhost_log *log = vhost_log_get(size, share);
> uint64_t log_base = (uintptr_t)log->log;
> int r;
>
> @@ -1136,9 +1159,10 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
>
> if (hdev->log_enabled) {
> uint64_t log_base;
> + bool share = hdev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
>
> hdev->log_size = vhost_get_log_size(hdev);
> - hdev->log = vhost_log_get(hdev->log_size);
> + hdev->log = vhost_log_get(hdev->log_size, share);
> log_base = (uintptr_t)hdev->log->log;
> r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> hdev->log_size ? &log_base : NULL);
> diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h
> index 6467c73..ab1dcac 100644
> --- a/include/hw/virtio/vhost.h
> +++ b/include/hw/virtio/vhost.h
> @@ -31,7 +31,8 @@ typedef unsigned long vhost_log_chunk_t;
> struct vhost_log {
> unsigned long long size;
> int refcnt;
> - vhost_log_chunk_t log[0];
> + int fd;
> + vhost_log_chunk_t *log;
> };
>
> struct vhost_memory;
> --
> 2.4.3
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-21 8:44 ` Michael S. Tsirkin
@ 2015-09-21 14:02 ` Marc-André Lureau
2015-09-21 19:29 ` Michael S. Tsirkin
0 siblings, 1 reply; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-21 14:02 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
Hi
----- Original Message -----
> On Sat, Sep 19, 2015 at 12:11:58PM +0200, marcandre.lureau@redhat.com wrote:
> > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> > If the backend is of type VHOST_BACKEND_TYPE_USER, allocate
> > shareable memory. Next patch will only allocate when the backend
> > has the required feature.
> >
> > Note: vhost_log_get() can use a global "vhost_log" that can be shared by
> > several vhost devices. We may want instead a common shareable log and a
> > common non-shareable one.
> >
> > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Well you do at least need to count the number of times the log is
> shared. Otherwise, if you share the log, then unshare it, you are left
> with a shared one.
Do you mean that if the device is removed (or stopped, so that the log is unref) and a shm log is no longer needed, it should replace the log of other devices with a non-shm log? In this case, wouldn't it make more sense to have a log shm per device, because replacing other devices log do not seem simple without more tracking of devices sharing the log.
Can this be considered a future enhancement?
>
> > ---
> > hw/virtio/vhost.c | 38 +++++++++++++++++++++++++++++++-------
> > include/hw/virtio/vhost.h | 3 ++-
> > 2 files changed, 33 insertions(+), 8 deletions(-)
> >
> > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > index a08c36b..cd3af16 100644
> > --- a/hw/virtio/vhost.c
> > +++ b/hw/virtio/vhost.c
> > @@ -18,6 +18,7 @@
> > #include "qemu/atomic.h"
> > #include "qemu/range.h"
> > #include "qemu/error-report.h"
> > +#include "qemu/memfd.h"
> > #include <linux/vhost.h>
> > #include "exec/address-spaces.h"
> > #include "hw/virtio/virtio-bus.h"
> > @@ -286,20 +287,34 @@ static uint64_t vhost_get_log_size(struct vhost_dev
> > *dev)
> > }
> > return log_size;
> > }
> > -static struct vhost_log *vhost_log_alloc(uint64_t size)
> > +
> > +static struct vhost_log *vhost_log_alloc(uint64_t size, bool share)
> > {
> > - struct vhost_log *log = g_malloc0(sizeof *log + size *
> > sizeof(*(log->log)));
> > + struct vhost_log *log;
> > + uint64_t logsize = size * sizeof(*(log->log));
> > + int fd = -1;
> > +
> > + log = g_new0(struct vhost_log, 1);
> > + if (share) {
> > + log->log = qemu_memfd_alloc("vhost-log", logsize,
> > + F_SEAL_GROW|F_SEAL_SHRINK|F_SEAL_SEAL,
> > &fd);
> > + memset(log->log, 0, logsize);
> > + } else {
> > + log->log = g_malloc0(logsize);
> > + }
> >
> > log->size = size;
> > log->refcnt = 1;
> > + log->fd = fd;
> >
> > return log;
> > }
> >
> > -static struct vhost_log *vhost_log_get(uint64_t size)
> > +static struct vhost_log *vhost_log_get(uint64_t size, bool share)
> > {
> > - if (!vhost_log || vhost_log->size != size) {
> > - vhost_log = vhost_log_alloc(size);
> > + if (!vhost_log || vhost_log->size != size ||
> > + (share && vhost_log->fd == -1)) {
> > + vhost_log = vhost_log_alloc(size, share);
> > } else {
> > ++vhost_log->refcnt;
> > }
> > @@ -324,13 +339,21 @@ static void vhost_log_put(struct vhost_dev *dev, bool
> > sync)
> > if (vhost_log == log) {
> > vhost_log = NULL;
> > }
> > +
> > + if (log->fd == -1) {
> > + g_free(log->log);
> > + } else {
> > + qemu_memfd_free(log->log, log->size * sizeof(*(log->log)),
> > + log->fd);
> > + }
> > g_free(log);
> > }
> > }
> >
> > static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t
> > size)
> > {
> > - struct vhost_log *log = vhost_log_get(size);
> > + bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
> > + struct vhost_log *log = vhost_log_get(size, share);
> > uint64_t log_base = (uintptr_t)log->log;
> > int r;
> >
> > @@ -1136,9 +1159,10 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > VirtIODevice *vdev)
> >
> > if (hdev->log_enabled) {
> > uint64_t log_base;
> > + bool share = hdev->vhost_ops->backend_type ==
> > VHOST_BACKEND_TYPE_USER;
> >
> > hdev->log_size = vhost_get_log_size(hdev);
> > - hdev->log = vhost_log_get(hdev->log_size);
> > + hdev->log = vhost_log_get(hdev->log_size, share);
> > log_base = (uintptr_t)hdev->log->log;
> > r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> > hdev->log_size ? &log_base :
> > NULL);
> > diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h
> > index 6467c73..ab1dcac 100644
> > --- a/include/hw/virtio/vhost.h
> > +++ b/include/hw/virtio/vhost.h
> > @@ -31,7 +31,8 @@ typedef unsigned long vhost_log_chunk_t;
> > struct vhost_log {
> > unsigned long long size;
> > int refcnt;
> > - vhost_log_chunk_t log[0];
> > + int fd;
> > + vhost_log_chunk_t *log;
> > };
> >
> > struct vhost_memory;
> > --
> > 2.4.3
>
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-21 14:02 ` Marc-André Lureau
@ 2015-09-21 19:29 ` Michael S. Tsirkin
2015-09-21 21:44 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 19:29 UTC (permalink / raw)
To: Marc-André Lureau
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
On Mon, Sep 21, 2015 at 10:02:02AM -0400, Marc-André Lureau wrote:
> Hi
>
> ----- Original Message -----
> > On Sat, Sep 19, 2015 at 12:11:58PM +0200, marcandre.lureau@redhat.com wrote:
> > > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> > >
> > > If the backend is of type VHOST_BACKEND_TYPE_USER, allocate
> > > shareable memory. Next patch will only allocate when the backend
> > > has the required feature.
> > >
> > > Note: vhost_log_get() can use a global "vhost_log" that can be shared by
> > > several vhost devices. We may want instead a common shareable log and a
> > > common non-shareable one.
> > >
> > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> > Well you do at least need to count the number of times the log is
> > shared. Otherwise, if you share the log, then unshare it, you are left
> > with a shared one.
>
> Do you mean that if the device is removed (or stopped, so that the log
> is unref) and a shm log is no longer needed, it should replace the log
> of other devices with a non-shm log?
Yes. Basically, you have code to swicth non-shared -> shared
but not back. That's asymmetrical.
> In this case, wouldn't it make
> more sense to have a log shm per device, because replacing other
> devices log do not seem simple without more tracking of devices
> sharing the log.
A per device log slows down syncs. Jason coded the shared one
specifically to avoid the need to do that.
> Can this be considered a future enhancement?
What's the big issue? Just count the devices that need a shared one, if
that count is 0 reallocate with shared == false.
> >
> > > ---
> > > hw/virtio/vhost.c | 38 +++++++++++++++++++++++++++++++-------
> > > include/hw/virtio/vhost.h | 3 ++-
> > > 2 files changed, 33 insertions(+), 8 deletions(-)
> > >
> > > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > > index a08c36b..cd3af16 100644
> > > --- a/hw/virtio/vhost.c
> > > +++ b/hw/virtio/vhost.c
> > > @@ -18,6 +18,7 @@
> > > #include "qemu/atomic.h"
> > > #include "qemu/range.h"
> > > #include "qemu/error-report.h"
> > > +#include "qemu/memfd.h"
> > > #include <linux/vhost.h>
> > > #include "exec/address-spaces.h"
> > > #include "hw/virtio/virtio-bus.h"
> > > @@ -286,20 +287,34 @@ static uint64_t vhost_get_log_size(struct vhost_dev
> > > *dev)
> > > }
> > > return log_size;
> > > }
> > > -static struct vhost_log *vhost_log_alloc(uint64_t size)
> > > +
> > > +static struct vhost_log *vhost_log_alloc(uint64_t size, bool share)
> > > {
> > > - struct vhost_log *log = g_malloc0(sizeof *log + size *
> > > sizeof(*(log->log)));
> > > + struct vhost_log *log;
> > > + uint64_t logsize = size * sizeof(*(log->log));
> > > + int fd = -1;
> > > +
> > > + log = g_new0(struct vhost_log, 1);
> > > + if (share) {
> > > + log->log = qemu_memfd_alloc("vhost-log", logsize,
> > > + F_SEAL_GROW|F_SEAL_SHRINK|F_SEAL_SEAL,
> > > &fd);
> > > + memset(log->log, 0, logsize);
> > > + } else {
> > > + log->log = g_malloc0(logsize);
> > > + }
> > >
> > > log->size = size;
> > > log->refcnt = 1;
> > > + log->fd = fd;
> > >
> > > return log;
> > > }
> > >
> > > -static struct vhost_log *vhost_log_get(uint64_t size)
> > > +static struct vhost_log *vhost_log_get(uint64_t size, bool share)
> > > {
> > > - if (!vhost_log || vhost_log->size != size) {
> > > - vhost_log = vhost_log_alloc(size);
> > > + if (!vhost_log || vhost_log->size != size ||
> > > + (share && vhost_log->fd == -1)) {
> > > + vhost_log = vhost_log_alloc(size, share);
> > > } else {
> > > ++vhost_log->refcnt;
> > > }
> > > @@ -324,13 +339,21 @@ static void vhost_log_put(struct vhost_dev *dev, bool
> > > sync)
> > > if (vhost_log == log) {
> > > vhost_log = NULL;
> > > }
> > > +
> > > + if (log->fd == -1) {
> > > + g_free(log->log);
> > > + } else {
> > > + qemu_memfd_free(log->log, log->size * sizeof(*(log->log)),
> > > + log->fd);
> > > + }
> > > g_free(log);
> > > }
> > > }
> > >
> > > static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t
> > > size)
> > > {
> > > - struct vhost_log *log = vhost_log_get(size);
> > > + bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
> > > + struct vhost_log *log = vhost_log_get(size, share);
> > > uint64_t log_base = (uintptr_t)log->log;
> > > int r;
> > >
> > > @@ -1136,9 +1159,10 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > > VirtIODevice *vdev)
> > >
> > > if (hdev->log_enabled) {
> > > uint64_t log_base;
> > > + bool share = hdev->vhost_ops->backend_type ==
> > > VHOST_BACKEND_TYPE_USER;
> > >
> > > hdev->log_size = vhost_get_log_size(hdev);
> > > - hdev->log = vhost_log_get(hdev->log_size);
> > > + hdev->log = vhost_log_get(hdev->log_size, share);
> > > log_base = (uintptr_t)hdev->log->log;
> > > r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> > > hdev->log_size ? &log_base :
> > > NULL);
> > > diff --git a/include/hw/virtio/vhost.h b/include/hw/virtio/vhost.h
> > > index 6467c73..ab1dcac 100644
> > > --- a/include/hw/virtio/vhost.h
> > > +++ b/include/hw/virtio/vhost.h
> > > @@ -31,7 +31,8 @@ typedef unsigned long vhost_log_chunk_t;
> > > struct vhost_log {
> > > unsigned long long size;
> > > int refcnt;
> > > - vhost_log_chunk_t log[0];
> > > + int fd;
> > > + vhost_log_chunk_t *log;
> > > };
> > >
> > > struct vhost_memory;
> > > --
> > > 2.4.3
> >
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-21 19:29 ` Michael S. Tsirkin
@ 2015-09-21 21:44 ` Marc-André Lureau
2015-09-22 10:12 ` Michael S. Tsirkin
0 siblings, 1 reply; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-21 21:44 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
Hi
On Mon, Sep 21, 2015 at 9:29 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
>> Can this be considered a future enhancement?
>
> What's the big issue? Just count the devices that need a shared one, if
> that count is 0 reallocate with shared == false.
But then it should also VHOST_SET_LOG_BASE all the other devices with
the new log, unless you want to tackle only the future log users. So
it needs to track all the users of the log. Is there a clear benefit
of this? since the memory isn't shared without the memfd passed to
another process and the overhead of memfd is probably quite small, and
pre-shm or future resize will not use the shared memory already.
--
Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-21 21:44 ` Marc-André Lureau
@ 2015-09-22 10:12 ` Michael S. Tsirkin
2015-09-22 11:01 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-22 10:12 UTC (permalink / raw)
To: Marc-André Lureau
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
On Mon, Sep 21, 2015 at 11:44:38PM +0200, Marc-André Lureau wrote:
> Hi
>
> On Mon, Sep 21, 2015 at 9:29 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
> >> Can this be considered a future enhancement?
> >
> > What's the big issue? Just count the devices that need a shared one, if
> > that count is 0 reallocate with shared == false.
>
>
> But then it should also VHOST_SET_LOG_BASE all the other devices with
> the new log, unless you want to tackle only the future log users. So
> it needs to track all the users of the log.
We already do this.
Same applies to non-memfd->memfd switch.
> Is there a clear benefit
> of this? since the memory isn't shared without the memfd passed to
> another process and the overhead of memfd is probably quite small, and
> pre-shm or future resize will not use the shared memory already.
For example, THP doesn't work for memfd at the moment,
so all accesses are a bit slower.
Really, I don't want to merge hacks. Switching from non memfd
to memfd but not back has all the signs of one.
Let's do it cleanly please.
> --
> Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-22 10:12 ` Michael S. Tsirkin
@ 2015-09-22 11:01 ` Marc-André Lureau
2015-09-22 11:41 ` Michael S. Tsirkin
0 siblings, 1 reply; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-22 11:01 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
Hi
On Tue, Sep 22, 2015 at 12:12 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
>> But then it should also VHOST_SET_LOG_BASE all the other devices with
>> the new log, unless you want to tackle only the future log users. So
>> it needs to track all the users of the log.
>
> We already do this.
> Same applies to non-memfd->memfd switch.
>
I failed to see how the log of other devices is being updated when one
device needs a resize. There are multiple log already in this case.
>> Is there a clear benefit
>> of this? since the memory isn't shared without the memfd passed to
>> another process and the overhead of memfd is probably quite small, and
>> pre-shm or future resize will not use the shared memory already.
>
> For example, THP doesn't work for memfd at the moment,
> so all accesses are a bit slower.
What's THP? How is it slower once the fd is mmap?
> Really, I don't want to merge hacks. Switching from non memfd
> to memfd but not back has all the signs of one.
> Let's do it cleanly please.
The current code isn't switching existing logs either. What would be
simpler to do is to allocate a different log region for the "share"
case. So there would be no need to switch other non-shareable logs (to
the cost of using twice the memory needed).
--
Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-22 11:01 ` Marc-André Lureau
@ 2015-09-22 11:41 ` Michael S. Tsirkin
2015-09-22 11:50 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-22 11:41 UTC (permalink / raw)
To: Marc-André Lureau
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
On Tue, Sep 22, 2015 at 01:01:03PM +0200, Marc-André Lureau wrote:
> Hi
>
> On Tue, Sep 22, 2015 at 12:12 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
> >> But then it should also VHOST_SET_LOG_BASE all the other devices with
> >> the new log, unless you want to tackle only the future log users. So
> >> it needs to track all the users of the log.
> >
> > We already do this.
> > Same applies to non-memfd->memfd switch.
> >
>
> I failed to see how the log of other devices is being updated when one
> device needs a resize. There are multiple log already in this case.
There's a single log at the moment:
static struct vhost_log *vhost_log;
But all devices are updated by the memory core, we don't
have a list in the vhost code.
> >> Is there a clear benefit
> >> of this? since the memory isn't shared without the memfd passed to
> >> another process and the overhead of memfd is probably quite small, and
> >> pre-shm or future resize will not use the shared memory already.
> >
> > For example, THP doesn't work for memfd at the moment,
> > so all accesses are a bit slower.
>
> What's THP? How is it slower once the fd is mmap?
Transparent huge page. This process doesn't work for
memfd AFAIK.
> > Really, I don't want to merge hacks. Switching from non memfd
> > to memfd but not back has all the signs of one.
> > Let's do it cleanly please.
>
> The current code isn't switching existing logs either. What would be
> simpler to do is to allocate a different log region for the "share"
> case. So there would be no need to switch other non-shareable logs (to
> the cost of using twice the memory needed).
OK, that's not too bad. Let's go for it.
> --
> Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-22 11:41 ` Michael S. Tsirkin
@ 2015-09-22 11:50 ` Marc-André Lureau
2015-09-22 11:54 ` Michael S. Tsirkin
0 siblings, 1 reply; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-22 11:50 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
hi
On Tue, Sep 22, 2015 at 1:41 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
> There's a single log at the moment:
> static struct vhost_log *vhost_log;
>
> But all devices are updated by the memory core, we don't
> have a list in the vhost code.
Do you mean that all devices will have their memory listener restart
the log, so they all point to the same global vhost_log?
>> >> Is there a clear benefit
>> >> of this? since the memory isn't shared without the memfd passed to
>> >> another process and the overhead of memfd is probably quite small, and
>> >> pre-shm or future resize will not use the shared memory already.
>> >
>> > For example, THP doesn't work for memfd at the moment,
>> > so all accesses are a bit slower.
>>
>> What's THP? How is it slower once the fd is mmap?
>
> Transparent huge page. This process doesn't work for
> memfd AFAIK.
>
>> > Really, I don't want to merge hacks. Switching from non memfd
>> > to memfd but not back has all the signs of one.
>> > Let's do it cleanly please.
>>
>> The current code isn't switching existing logs either. What would be
>> simpler to do is to allocate a different log region for the "share"
>> case. So there would be no need to switch other non-shareable logs (to
>> the cost of using twice the memory needed).
>
> OK, that's not too bad. Let's go for it.
ok, working on new patch
--
Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log
2015-09-22 11:50 ` Marc-André Lureau
@ 2015-09-22 11:54 ` Michael S. Tsirkin
0 siblings, 0 replies; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-22 11:54 UTC (permalink / raw)
To: Marc-André Lureau
Cc: thibaut collet, Jason Wang, Paolo Bonzini, haifeng lin, QEMU
On Tue, Sep 22, 2015 at 01:50:47PM +0200, Marc-André Lureau wrote:
> hi
>
> On Tue, Sep 22, 2015 at 1:41 PM, Michael S. Tsirkin <mst@redhat.com> wrote:
> > There's a single log at the moment:
> > static struct vhost_log *vhost_log;
> >
> > But all devices are updated by the memory core, we don't
> > have a list in the vhost code.
>
> Do you mean that all devices will have their memory listener restart
> the log, so they all point to the same global vhost_log?
Exactly.
> >> >> Is there a clear benefit
> >> >> of this? since the memory isn't shared without the memfd passed to
> >> >> another process and the overhead of memfd is probably quite small, and
> >> >> pre-shm or future resize will not use the shared memory already.
> >> >
> >> > For example, THP doesn't work for memfd at the moment,
> >> > so all accesses are a bit slower.
> >>
> >> What's THP? How is it slower once the fd is mmap?
> >
> > Transparent huge page. This process doesn't work for
> > memfd AFAIK.
> >
> >> > Really, I don't want to merge hacks. Switching from non memfd
> >> > to memfd but not back has all the signs of one.
> >> > Let's do it cleanly please.
> >>
> >> The current code isn't switching existing logs either. What would be
> >> simpler to do is to allocate a different log region for the "share"
> >> case. So there would be no need to switch other non-shareable logs (to
> >> the cost of using twice the memory needed).
> >
> > OK, that's not too bad. Let's go for it.
>
>
> ok, working on new patch
I've tentatively applied the multiqueue patches, please make sure
yours work on top.
> --
> Marc-André Lureau
^ permalink raw reply [flat|nested] 41+ messages in thread
* [Qemu-devel] [PATCH v4 08/22] vhost: document log resizing
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (6 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 07/22] vhost: alloc shareable log marcandre.lureau
@ 2015-09-19 10:11 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call marcandre.lureau
` (13 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:11 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/virtio/vhost.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
index cd3af16..81209ba 100644
--- a/hw/virtio/vhost.c
+++ b/hw/virtio/vhost.c
@@ -357,6 +357,8 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
uint64_t log_base = (uintptr_t)log->log;
int r;
+ /* inform backend of log switching, this must be done before
+ releasing the current log, to ensure no logging is lost */
r = dev->vhost_ops->vhost_call(dev, VHOST_SET_LOG_BASE, &log_base);
assert(r >= 0);
vhost_log_put(dev, true);
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (7 preceding siblings ...)
2015-09-19 10:11 ` [Qemu-devel] [PATCH v4 08/22] vhost: document log resizing marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-21 7:33 ` Thibaut Collet
2015-09-21 8:58 ` Michael S. Tsirkin
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 10/22] vhost-user: remove vhost_user_request_translate() marcandre.lureau
` (12 subsequent siblings)
21 siblings, 2 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Replace the generic vhost_call() by specific functions for each
function call to help with type safety and changing arguments.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/net/vhost_net.c | 12 +-
hw/scsi/vhost-scsi.c | 7 +-
hw/virtio/vhost-backend.c | 140 +++++++++++--
hw/virtio/vhost-user.c | 402 ++++++++++++++++++++++++++------------
hw/virtio/vhost.c | 34 ++--
include/hw/virtio/vhost-backend.h | 59 +++++-
6 files changed, 484 insertions(+), 170 deletions(-)
diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
index 9d32d76..d116fb3 100644
--- a/hw/net/vhost_net.c
+++ b/hw/net/vhost_net.c
@@ -243,8 +243,7 @@ static int vhost_net_start_one(struct vhost_net *net,
file.fd = net->backend;
for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
const VhostOps *vhost_ops = net->dev.vhost_ops;
- r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
- &file);
+ r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
if (r < 0) {
r = -errno;
goto fail;
@@ -257,8 +256,7 @@ fail:
if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
while (file.index-- > 0) {
const VhostOps *vhost_ops = net->dev.vhost_ops;
- int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
- &file);
+ int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
assert(r >= 0);
}
}
@@ -280,15 +278,13 @@ static void vhost_net_stop_one(struct vhost_net *net,
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;
- int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
- &file);
+ int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
assert(r >= 0);
}
} else if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER) {
for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
const VhostOps *vhost_ops = net->dev.vhost_ops;
- int r = vhost_ops->vhost_call(&net->dev, VHOST_RESET_OWNER,
- NULL);
+ int r = vhost_ops->vhost_reset_owner(&net->dev);
assert(r >= 0);
}
}
diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
index bac9ddb..a0034ab 100644
--- a/hw/scsi/vhost-scsi.c
+++ b/hw/scsi/vhost-scsi.c
@@ -45,7 +45,7 @@ static int vhost_scsi_set_endpoint(VHostSCSI *s)
memset(&backend, 0, sizeof(backend));
pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
- ret = vhost_ops->vhost_call(&s->dev, VHOST_SCSI_SET_ENDPOINT, &backend);
+ ret = vhost_ops->vhost_scsi_set_endpoint(&s->dev, &backend);
if (ret < 0) {
return -errno;
}
@@ -60,7 +60,7 @@ static void vhost_scsi_clear_endpoint(VHostSCSI *s)
memset(&backend, 0, sizeof(backend));
pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
- vhost_ops->vhost_call(&s->dev, VHOST_SCSI_CLEAR_ENDPOINT, &backend);
+ vhost_ops->vhost_scsi_clear_endpoint(&s->dev, &backend);
}
static int vhost_scsi_start(VHostSCSI *s)
@@ -76,8 +76,7 @@ static int vhost_scsi_start(VHostSCSI *s)
return -ENOSYS;
}
- ret = vhost_ops->vhost_call(&s->dev,
- VHOST_SCSI_GET_ABI_VERSION, &abi_version);
+ ret = vhost_ops->vhost_scsi_get_abi_version(&s->dev, &abi_version);
if (ret < 0) {
return -errno;
}
diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
index 4d68a27..bf2d1d4 100644
--- a/hw/virtio/vhost-backend.c
+++ b/hw/virtio/vhost-backend.c
@@ -11,19 +11,10 @@
#include "hw/virtio/vhost.h"
#include "hw/virtio/vhost-backend.h"
#include "qemu/error-report.h"
+#include "linux/vhost.h"
#include <sys/ioctl.h>
-static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int request,
- void *arg)
-{
- int fd = (uintptr_t) dev->opaque;
-
- assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
-
- return ioctl(fd, request, arg);
-}
-
static int vhost_kernel_init(struct vhost_dev *dev, void *opaque)
{
assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
@@ -42,11 +33,136 @@ static int vhost_kernel_cleanup(struct vhost_dev *dev)
return close(fd);
}
+static int vhost_kernel_call(struct vhost_dev *dev,
+ unsigned long int request, void *arg)
+{
+ int fd = (uintptr_t) dev->opaque;
+
+ assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
+
+ return ioctl(fd, request, arg);
+}
+
+static int vhost_net_set_backend(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
+}
+
+static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
+ struct vhost_scsi_target *target)
+{
+ return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
+}
+
+static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
+ struct vhost_scsi_target *target)
+{
+ return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
+}
+
+static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
+{
+ return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
+}
+
+static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
+{
+ return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
+}
+
+static int vhost_set_mem_table(struct vhost_dev *dev,
+ struct vhost_memory *mem)
+{
+ return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
+}
+
+static int vhost_set_vring_addr(struct vhost_dev *dev,
+ struct vhost_vring_addr *addr)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
+}
+
+static int vhost_set_vring_endian(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
+}
+
+static int vhost_set_vring_num(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
+}
+
+static int vhost_set_vring_base(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
+}
+
+static int vhost_get_vring_base(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
+}
+
+static int vhost_set_vring_kick(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
+}
+
+static int vhost_set_vring_call(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
+}
+
+static int vhost_set_features(struct vhost_dev *dev,
+ uint64_t features)
+{
+ return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
+}
+
+static int vhost_kernel_get_features(struct vhost_dev *dev,
+ uint64_t *features)
+{
+ return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
+}
+
+static int vhost_set_owner(struct vhost_dev *dev)
+{
+ return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
+}
+
+static int vhost_reset_owner(struct vhost_dev *dev)
+{
+ return vhost_kernel_call(dev, VHOST_RESET_OWNER, NULL);
+}
+
static const VhostOps kernel_ops = {
.backend_type = VHOST_BACKEND_TYPE_KERNEL,
- .vhost_call = vhost_kernel_call,
.vhost_backend_init = vhost_kernel_init,
- .vhost_backend_cleanup = vhost_kernel_cleanup
+ .vhost_backend_cleanup = vhost_kernel_cleanup,
+
+ .vhost_net_set_backend = vhost_net_set_backend,
+ .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
+ .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
+ .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
+ .vhost_set_log_base = vhost_set_log_base,
+ .vhost_set_mem_table = vhost_set_mem_table,
+ .vhost_set_vring_addr = vhost_set_vring_addr,
+ .vhost_set_vring_endian = vhost_set_vring_endian,
+ .vhost_set_vring_num = vhost_set_vring_num,
+ .vhost_set_vring_base = vhost_set_vring_base,
+ .vhost_get_vring_base = vhost_get_vring_base,
+ .vhost_set_vring_kick = vhost_set_vring_kick,
+ .vhost_set_vring_call = vhost_set_vring_call,
+ .vhost_set_features = vhost_set_features,
+ .vhost_get_features = vhost_kernel_get_features,
+ .vhost_set_owner = vhost_set_owner,
+ .vhost_reset_owner = vhost_reset_owner,
};
int vhost_set_backend_type(struct vhost_dev *dev, VhostBackendType backend_type)
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index de87562..d5b7951 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -176,6 +176,7 @@ fail:
return -1;
}
+/* most non-init callers ignore the error */
static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
int *fds, int fd_num)
{
@@ -190,148 +191,280 @@ static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
0 : -1;
}
-static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
- void *arg)
+static int vhost_net_set_backend(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ error_report("vhost-user trying to send unhandled ioctl");
+ return -1;
+}
+
+static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
+ struct vhost_scsi_target *target)
+{
+ error_report("vhost-user trying to send unhandled ioctl");
+ return -1;
+}
+
+static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
+ struct vhost_scsi_target *target)
+{
+ error_report("vhost-user trying to send unhandled ioctl");
+ return -1;
+}
+
+static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
+{
+ error_report("vhost-user trying to send unhandled ioctl");
+ return -1;
+}
+
+static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_LOG_BASE,
+ .flags = VHOST_USER_VERSION,
+ .u64 = base,
+ .size = sizeof(m.u64),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_set_mem_table(struct vhost_dev *dev,
+ struct vhost_memory *mem)
{
- VhostUserMsg msg;
- VhostUserRequest msg_request;
- struct vhost_vring_file *file = 0;
- int need_reply = 0;
int fds[VHOST_MEMORY_MAX_NREGIONS];
int i, fd;
size_t fd_num = 0;
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_MEM_TABLE,
+ .flags = VHOST_USER_VERSION,
+ };
- assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
+ for (i = 0; i < dev->mem->nregions; ++i) {
+ struct vhost_memory_region *reg = dev->mem->regions + i;
+ ram_addr_t ram_addr;
+
+ assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
+ qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr,
+ &ram_addr);
+ fd = qemu_get_ram_fd(ram_addr);
+ if (fd > 0) {
+ msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
+ msg.memory.regions[fd_num].memory_size = reg->memory_size;
+ msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
+ msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
+ (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
+ assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
+ fds[fd_num++] = fd;
+ }
+ }
- msg_request = vhost_user_request_translate(request);
- msg.request = msg_request;
- msg.flags = VHOST_USER_VERSION;
- msg.size = 0;
+ msg.memory.nregions = fd_num;
- switch (msg_request) {
- case VHOST_USER_GET_FEATURES:
- need_reply = 1;
- break;
-
- case VHOST_USER_SET_FEATURES:
- case VHOST_USER_SET_LOG_BASE:
- msg.u64 = *((__u64 *) arg);
- msg.size = sizeof(m.u64);
- break;
-
- case VHOST_USER_SET_OWNER:
- case VHOST_USER_RESET_OWNER:
- break;
-
- case VHOST_USER_SET_MEM_TABLE:
- for (i = 0; i < dev->mem->nregions; ++i) {
- struct vhost_memory_region *reg = dev->mem->regions + i;
- ram_addr_t ram_addr;
-
- assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
- qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr, &ram_addr);
- fd = qemu_get_ram_fd(ram_addr);
- if (fd > 0) {
- msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
- msg.memory.regions[fd_num].memory_size = reg->memory_size;
- msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
- msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
- (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
- assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
- fds[fd_num++] = fd;
- }
- }
+ if (!fd_num) {
+ error_report("Failed initializing vhost-user memory map, "
+ "consider using -object memory-backend-file share=on");
+ return -1;
+ }
- msg.memory.nregions = fd_num;
+ msg.size = sizeof(m.memory.nregions);
+ msg.size += sizeof(m.memory.padding);
+ msg.size += fd_num * sizeof(VhostUserMemoryRegion);
- if (!fd_num) {
- error_report("Failed initializing vhost-user memory map, "
- "consider using -object memory-backend-file share=on");
- return -1;
- }
+ vhost_user_write(dev, &msg, fds, fd_num);
- msg.size = sizeof(m.memory.nregions);
- msg.size += sizeof(m.memory.padding);
- msg.size += fd_num * sizeof(VhostUserMemoryRegion);
-
- break;
-
- case VHOST_USER_SET_LOG_FD:
- fds[fd_num++] = *((int *) arg);
- break;
-
- case VHOST_USER_SET_VRING_NUM:
- case VHOST_USER_SET_VRING_BASE:
- memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
- msg.size = sizeof(m.state);
- break;
-
- case VHOST_USER_GET_VRING_BASE:
- memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
- msg.size = sizeof(m.state);
- need_reply = 1;
- break;
-
- case VHOST_USER_SET_VRING_ADDR:
- memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
- msg.size = sizeof(m.addr);
- break;
-
- case VHOST_USER_SET_VRING_KICK:
- case VHOST_USER_SET_VRING_CALL:
- case VHOST_USER_SET_VRING_ERR:
- file = arg;
- msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
- msg.size = sizeof(m.u64);
- if (ioeventfd_enabled() && file->fd > 0) {
- fds[fd_num++] = file->fd;
- } else {
- msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
- }
- break;
- default:
- error_report("vhost-user trying to send unhandled ioctl");
+ return 0;
+}
+
+static int vhost_set_vring_addr(struct vhost_dev *dev,
+ struct vhost_vring_addr *addr)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_VRING_ADDR,
+ .flags = VHOST_USER_VERSION,
+ .addr = *addr,
+ .size = sizeof(*addr),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_set_vring_endian(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ error_report("vhost-user trying to send unhandled ioctl");
+ return -1;
+}
+
+static int vhost_set_vring_num(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_VRING_NUM,
+ .flags = VHOST_USER_VERSION,
+ .state = *ring,
+ .size = sizeof(*ring),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_set_vring_base(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_VRING_BASE,
+ .flags = VHOST_USER_VERSION,
+ .state = *ring,
+ .size = sizeof(*ring),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_get_vring_base(struct vhost_dev *dev,
+ struct vhost_vring_state *ring)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_GET_VRING_BASE,
+ .flags = VHOST_USER_VERSION,
+ .state = *ring,
+ .size = sizeof(*ring),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ if (vhost_user_read(dev, &msg) < 0) {
+ return 0;
+ }
+
+ if (msg.request != VHOST_USER_GET_VRING_BASE) {
+ error_report("Received unexpected msg type. Expected %d received %d",
+ VHOST_USER_GET_FEATURES, msg.request);
return -1;
- break;
}
- if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
- return 0;
+ if (msg.size != sizeof(m.state)) {
+ error_report("Received bad msg size.");
+ return -1;
}
- if (need_reply) {
- if (vhost_user_read(dev, &msg) < 0) {
- return 0;
- }
+ *ring = msg.state;
- if (msg_request != msg.request) {
- error_report("Received unexpected msg type."
- " Expected %d received %d", msg_request, msg.request);
- return -1;
- }
+ return 0;
+}
- switch (msg_request) {
- case VHOST_USER_GET_FEATURES:
- if (msg.size != sizeof(m.u64)) {
- error_report("Received bad msg size.");
- return -1;
- }
- *((__u64 *) arg) = msg.u64;
- break;
- case VHOST_USER_GET_VRING_BASE:
- if (msg.size != sizeof(m.state)) {
- error_report("Received bad msg size.");
- return -1;
- }
- memcpy(arg, &msg.state, sizeof(struct vhost_vring_state));
- break;
- default:
- error_report("Received unexpected msg type.");
- return -1;
- break;
- }
+static int vhost_set_vring_file(struct vhost_dev *dev,
+ VhostUserRequest request,
+ struct vhost_vring_file *file)
+{
+ int fds[VHOST_MEMORY_MAX_NREGIONS];
+ size_t fd_num = 0;
+ VhostUserMsg msg = {
+ .request = request,
+ .flags = VHOST_USER_VERSION,
+ .u64 = file->index & VHOST_USER_VRING_IDX_MASK,
+ .size = sizeof(m.u64),
+ };
+
+ if (ioeventfd_enabled() && file->fd > 0) {
+ fds[fd_num++] = file->fd;
+ } else {
+ msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
}
+ vhost_user_write(dev, &msg, fds, fd_num);
+
+ return 0;
+}
+
+static int vhost_set_vring_kick(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
+}
+
+static int vhost_set_vring_call(struct vhost_dev *dev,
+ struct vhost_vring_file *file)
+{
+ return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
+}
+
+static int vhost_set_features(struct vhost_dev *dev,
+ uint64_t features)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ .u64 = features,
+ .size = sizeof(m.u64),
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_user_get_features(struct vhost_dev *dev,
+ uint64_t *features)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_GET_FEATURES,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ if (vhost_user_read(dev, &msg) < 0) {
+ return 0;
+ }
+
+ if (msg.request != VHOST_USER_GET_FEATURES) {
+ error_report("Received unexpected msg type. Expected %d received %d",
+ VHOST_USER_GET_FEATURES, msg.request);
+ return -1;
+ }
+
+ if (msg.size != sizeof(m.u64)) {
+ error_report("Received bad msg size.");
+ return -1;
+ }
+
+ *features = msg.u64;
+
+ return 0;
+}
+
+static int vhost_set_owner(struct vhost_dev *dev)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_SET_OWNER,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
+ return 0;
+}
+
+static int vhost_reset_owner(struct vhost_dev *dev)
+{
+ VhostUserMsg msg = {
+ .request = VHOST_USER_RESET_OWNER,
+ .flags = VHOST_USER_VERSION,
+ };
+
+ vhost_user_write(dev, &msg, NULL, 0);
+
return 0;
}
@@ -402,7 +535,24 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
const VhostOps user_ops = {
.backend_type = VHOST_BACKEND_TYPE_USER,
- .vhost_call = vhost_user_call,
.vhost_backend_init = vhost_user_init,
- .vhost_backend_cleanup = vhost_user_cleanup
- };
+ .vhost_backend_cleanup = vhost_user_cleanup,
+
+ .vhost_net_set_backend = vhost_net_set_backend,
+ .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
+ .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
+ .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
+ .vhost_set_log_base = vhost_set_log_base,
+ .vhost_set_mem_table = vhost_set_mem_table,
+ .vhost_set_vring_addr = vhost_set_vring_addr,
+ .vhost_set_vring_endian = vhost_set_vring_endian,
+ .vhost_set_vring_num = vhost_set_vring_num,
+ .vhost_set_vring_base = vhost_set_vring_base,
+ .vhost_get_vring_base = vhost_get_vring_base,
+ .vhost_set_vring_kick = vhost_set_vring_kick,
+ .vhost_set_vring_call = vhost_set_vring_call,
+ .vhost_set_features = vhost_set_features,
+ .vhost_get_features = vhost_user_get_features,
+ .vhost_set_owner = vhost_set_owner,
+ .vhost_reset_owner = vhost_reset_owner,
+};
diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
index 81209ba..83ef164 100644
--- a/hw/virtio/vhost.c
+++ b/hw/virtio/vhost.c
@@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
/* inform backend of log switching, this must be done before
releasing the current log, to ensure no logging is lost */
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_LOG_BASE, &log_base);
+ r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
assert(r >= 0);
vhost_log_put(dev, true);
dev->log = log;
@@ -525,7 +525,7 @@ static void vhost_commit(MemoryListener *listener)
}
if (!dev->log_enabled) {
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
+ r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
assert(r >= 0);
dev->memory_changed = false;
return;
@@ -538,7 +538,7 @@ static void vhost_commit(MemoryListener *listener)
if (dev->log_size < log_size) {
vhost_dev_log_resize(dev, log_size + VHOST_LOG_BUFFER);
}
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
+ r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
assert(r >= 0);
/* To log less, can only decrease log size after table update. */
if (dev->log_size > log_size + VHOST_LOG_BUFFER) {
@@ -606,7 +606,7 @@ static int vhost_virtqueue_set_addr(struct vhost_dev *dev,
.log_guest_addr = vq->used_phys,
.flags = enable_log ? (1 << VHOST_VRING_F_LOG) : 0,
};
- int r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ADDR, &addr);
+ int r = dev->vhost_ops->vhost_set_vring_addr(dev, &addr);
if (r < 0) {
return -errno;
}
@@ -620,7 +620,7 @@ static int vhost_dev_set_features(struct vhost_dev *dev, bool enable_log)
if (enable_log) {
features |= 0x1ULL << VHOST_F_LOG_ALL;
}
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_FEATURES, &features);
+ r = dev->vhost_ops->vhost_set_features(dev, features);
return r < 0 ? -errno : 0;
}
@@ -725,7 +725,7 @@ static int vhost_virtqueue_set_vring_endian_legacy(struct vhost_dev *dev,
.num = is_big_endian
};
- if (!dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ENDIAN, &s)) {
+ if (!dev->vhost_ops->vhost_set_vring_endian(dev, &s)) {
return 0;
}
@@ -756,13 +756,13 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
vq->num = state.num = virtio_queue_get_num(vdev, idx);
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_NUM, &state);
+ r = dev->vhost_ops->vhost_set_vring_num(dev, &state);
if (r) {
return -errno;
}
state.num = virtio_queue_get_last_avail_idx(vdev, idx);
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_BASE, &state);
+ r = dev->vhost_ops->vhost_set_vring_base(dev, &state);
if (r) {
return -errno;
}
@@ -814,7 +814,7 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
}
file.fd = event_notifier_get_fd(virtio_queue_get_host_notifier(vvq));
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_KICK, &file);
+ r = dev->vhost_ops->vhost_set_vring_kick(dev, &file);
if (r) {
r = -errno;
goto fail_kick;
@@ -853,7 +853,7 @@ static void vhost_virtqueue_stop(struct vhost_dev *dev,
};
int r;
assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
- r = dev->vhost_ops->vhost_call(dev, VHOST_GET_VRING_BASE, &state);
+ r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
if (r < 0) {
fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
fflush(stderr);
@@ -909,7 +909,7 @@ static int vhost_virtqueue_init(struct vhost_dev *dev,
}
file.fd = event_notifier_get_fd(&vq->masked_notifier);
- r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_CALL, &file);
+ r = dev->vhost_ops->vhost_set_vring_call(dev, &file);
if (r) {
r = -errno;
goto fail_call;
@@ -941,12 +941,12 @@ int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
return -errno;
}
- r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_OWNER, NULL);
+ r = hdev->vhost_ops->vhost_set_owner(hdev);
if (r < 0) {
goto fail;
}
- r = hdev->vhost_ops->vhost_call(hdev, VHOST_GET_FEATURES, &features);
+ r = hdev->vhost_ops->vhost_get_features(hdev, &features);
if (r < 0) {
goto fail;
}
@@ -1102,7 +1102,7 @@ void vhost_virtqueue_mask(struct vhost_dev *hdev, VirtIODevice *vdev, int n,
} else {
file.fd = event_notifier_get_fd(virtio_queue_get_guest_notifier(vvq));
}
- r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_VRING_CALL, &file);
+ r = hdev->vhost_ops->vhost_set_vring_call(hdev, &file);
assert(r >= 0);
}
@@ -1144,7 +1144,7 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
if (r < 0) {
goto fail_features;
}
- r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_MEM_TABLE, hdev->mem);
+ r = hdev->vhost_ops->vhost_set_mem_table(hdev, hdev->mem);
if (r < 0) {
r = -errno;
goto fail_mem;
@@ -1166,8 +1166,8 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
hdev->log_size = vhost_get_log_size(hdev);
hdev->log = vhost_log_get(hdev->log_size, share);
log_base = (uintptr_t)hdev->log->log;
- r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
- hdev->log_size ? &log_base : NULL);
+ r = hdev->vhost_ops->vhost_set_log_base(hdev,
+ hdev->log_size ? log_base : 0);
if (r < 0) {
r = -errno;
goto fail_log;
diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
index e472f29..42cfb87 100644
--- a/include/hw/virtio/vhost-backend.h
+++ b/include/hw/virtio/vhost-backend.h
@@ -19,17 +19,70 @@ typedef enum VhostBackendType {
} VhostBackendType;
struct vhost_dev;
+struct vhost_memory;
+struct vhost_vring_file;
+struct vhost_vring_state;
+struct vhost_vring_addr;
+struct vhost_scsi_target;
-typedef int (*vhost_call)(struct vhost_dev *dev, unsigned long int request,
- void *arg);
typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
+typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
+ struct vhost_vring_file *file);
+typedef int (*vhost_scsi_set_endpoint_op)(struct vhost_dev *dev,
+ struct vhost_scsi_target *target);
+typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
+ struct vhost_scsi_target *target);
+typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
+ int *version);
+typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base);
+typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
+ struct vhost_memory *mem);
+typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
+ struct vhost_vring_addr *addr);
+typedef int (*vhost_set_vring_endian_op)(struct vhost_dev *dev,
+ struct vhost_vring_state *ring);
+typedef int (*vhost_set_vring_num_op)(struct vhost_dev *dev,
+ struct vhost_vring_state *ring);
+typedef int (*vhost_set_vring_base_op)(struct vhost_dev *dev,
+ struct vhost_vring_state *ring);
+typedef int (*vhost_get_vring_base_op)(struct vhost_dev *dev,
+ struct vhost_vring_state *ring);
+typedef int (*vhost_set_vring_kick_op)(struct vhost_dev *dev,
+ struct vhost_vring_file *file);
+typedef int (*vhost_set_vring_call_op)(struct vhost_dev *dev,
+ struct vhost_vring_file *file);
+typedef int (*vhost_set_features_op)(struct vhost_dev *dev,
+ uint64_t features);
+typedef int (*vhost_get_features_op)(struct vhost_dev *dev,
+ uint64_t *features);
+typedef int (*vhost_set_owner_op)(struct vhost_dev *dev);
+typedef int (*vhost_reset_owner_op)(struct vhost_dev *dev);
+
typedef struct VhostOps {
VhostBackendType backend_type;
- vhost_call vhost_call;
+
vhost_backend_init vhost_backend_init;
vhost_backend_cleanup vhost_backend_cleanup;
+
+ vhost_net_set_backend_op vhost_net_set_backend;
+ vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
+ vhost_scsi_clear_endpoint_op vhost_scsi_clear_endpoint;
+ vhost_scsi_get_abi_version_op vhost_scsi_get_abi_version;
+ vhost_set_log_base_op vhost_set_log_base;
+ vhost_set_mem_table_op vhost_set_mem_table;
+ vhost_set_vring_addr_op vhost_set_vring_addr;
+ vhost_set_vring_endian_op vhost_set_vring_endian;
+ vhost_set_vring_num_op vhost_set_vring_num;
+ vhost_set_vring_base_op vhost_set_vring_base;
+ vhost_get_vring_base_op vhost_get_vring_base;
+ vhost_set_vring_kick_op vhost_set_vring_kick;
+ vhost_set_vring_call_op vhost_set_vring_call;
+ vhost_set_features_op vhost_set_features;
+ vhost_get_features_op vhost_get_features;
+ vhost_set_owner_op vhost_set_owner;
+ vhost_reset_owner_op vhost_reset_owner;
} VhostOps;
extern const VhostOps user_ops;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call marcandre.lureau
@ 2015-09-21 7:33 ` Thibaut Collet
2015-09-21 8:56 ` Michael S. Tsirkin
2015-09-21 8:58 ` Michael S. Tsirkin
1 sibling, 1 reply; 41+ messages in thread
From: Thibaut Collet @ 2015-09-21 7:33 UTC (permalink / raw)
To: marcandre.lureau
Cc: Paolo Bonzini, Jason Wang, Michael S. Tsirkin, qemu-devel,
Linhaifeng
On Sat, Sep 19, 2015 at 12:12 PM, <marcandre.lureau@redhat.com> wrote:
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Replace the generic vhost_call() by specific functions for each
> function call to help with type safety and changing arguments.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> ---
> hw/net/vhost_net.c | 12 +-
> hw/scsi/vhost-scsi.c | 7 +-
> hw/virtio/vhost-backend.c | 140 +++++++++++--
> hw/virtio/vhost-user.c | 402 ++++++++++++++++++++++++++------------
> hw/virtio/vhost.c | 34 ++--
> include/hw/virtio/vhost-backend.h | 59 +++++-
> 6 files changed, 484 insertions(+), 170 deletions(-)
>
> diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
> index 9d32d76..d116fb3 100644
> --- a/hw/net/vhost_net.c
> +++ b/hw/net/vhost_net.c
> @@ -243,8 +243,7 @@ static int vhost_net_start_one(struct vhost_net *net,
> file.fd = net->backend;
> for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> if (r < 0) {
> r = -errno;
> goto fail;
> @@ -257,8 +256,7 @@ fail:
> if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
> while (file.index-- > 0) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> assert(r >= 0);
> }
> }
> @@ -280,15 +278,13 @@ static void vhost_net_stop_one(struct vhost_net *net,
> 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;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> assert(r >= 0);
> }
> } else if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER) {
> for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_RESET_OWNER,
> - NULL);
> + int r = vhost_ops->vhost_reset_owner(&net->dev);
> assert(r >= 0);
> }
> }
> diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
> index bac9ddb..a0034ab 100644
> --- a/hw/scsi/vhost-scsi.c
> +++ b/hw/scsi/vhost-scsi.c
> @@ -45,7 +45,7 @@ static int vhost_scsi_set_endpoint(VHostSCSI *s)
>
> memset(&backend, 0, sizeof(backend));
> pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
> - ret = vhost_ops->vhost_call(&s->dev, VHOST_SCSI_SET_ENDPOINT, &backend);
> + ret = vhost_ops->vhost_scsi_set_endpoint(&s->dev, &backend);
> if (ret < 0) {
> return -errno;
> }
> @@ -60,7 +60,7 @@ static void vhost_scsi_clear_endpoint(VHostSCSI *s)
>
> memset(&backend, 0, sizeof(backend));
> pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
> - vhost_ops->vhost_call(&s->dev, VHOST_SCSI_CLEAR_ENDPOINT, &backend);
> + vhost_ops->vhost_scsi_clear_endpoint(&s->dev, &backend);
> }
>
> static int vhost_scsi_start(VHostSCSI *s)
> @@ -76,8 +76,7 @@ static int vhost_scsi_start(VHostSCSI *s)
> return -ENOSYS;
> }
>
> - ret = vhost_ops->vhost_call(&s->dev,
> - VHOST_SCSI_GET_ABI_VERSION, &abi_version);
> + ret = vhost_ops->vhost_scsi_get_abi_version(&s->dev, &abi_version);
> if (ret < 0) {
> return -errno;
> }
> diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> index 4d68a27..bf2d1d4 100644
> --- a/hw/virtio/vhost-backend.c
> +++ b/hw/virtio/vhost-backend.c
> @@ -11,19 +11,10 @@
> #include "hw/virtio/vhost.h"
> #include "hw/virtio/vhost-backend.h"
> #include "qemu/error-report.h"
> +#include "linux/vhost.h"
>
> #include <sys/ioctl.h>
>
> -static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int request,
> - void *arg)
> -{
> - int fd = (uintptr_t) dev->opaque;
> -
> - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> -
> - return ioctl(fd, request, arg);
> -}
> -
> static int vhost_kernel_init(struct vhost_dev *dev, void *opaque)
> {
> assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> @@ -42,11 +33,136 @@ static int vhost_kernel_cleanup(struct vhost_dev *dev)
> return close(fd);
> }
>
> +static int vhost_kernel_call(struct vhost_dev *dev,
> + unsigned long int request, void *arg)
> +{
> + int fd = (uintptr_t) dev->opaque;
> +
> + assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> +
> + return ioctl(fd, request, arg);
> +}
> +
> +static int vhost_net_set_backend(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
> +}
> +
> +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
> +}
> +
> +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
> +}
> +
> +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> +}
> +
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> +}
> +
> +static int vhost_set_mem_table(struct vhost_dev *dev,
> + struct vhost_memory *mem)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
> +}
> +
> +static int vhost_set_vring_addr(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
> +}
> +
> +static int vhost_set_vring_endian(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
> +}
> +
> +static int vhost_set_vring_num(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
> +}
> +
> +static int vhost_set_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
> +}
> +
> +static int vhost_get_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
> +}
> +
> +static int vhost_set_vring_kick(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
> +}
> +
> +static int vhost_set_vring_call(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
> +}
> +
> +static int vhost_set_features(struct vhost_dev *dev,
> + uint64_t features)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
> +}
> +
> +static int vhost_kernel_get_features(struct vhost_dev *dev,
> + uint64_t *features)
> +{
> + return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
> +}
> +
> +static int vhost_set_owner(struct vhost_dev *dev)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
> +}
> +
> +static int vhost_reset_owner(struct vhost_dev *dev)
> +{
> + return vhost_kernel_call(dev, VHOST_RESET_OWNER, NULL);
> +}
> +
> static const VhostOps kernel_ops = {
> .backend_type = VHOST_BACKEND_TYPE_KERNEL,
> - .vhost_call = vhost_kernel_call,
> .vhost_backend_init = vhost_kernel_init,
> - .vhost_backend_cleanup = vhost_kernel_cleanup
> + .vhost_backend_cleanup = vhost_kernel_cleanup,
> +
> + .vhost_net_set_backend = vhost_net_set_backend,
> + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> + .vhost_set_log_base = vhost_set_log_base,
> + .vhost_set_mem_table = vhost_set_mem_table,
> + .vhost_set_vring_addr = vhost_set_vring_addr,
> + .vhost_set_vring_endian = vhost_set_vring_endian,
> + .vhost_set_vring_num = vhost_set_vring_num,
> + .vhost_set_vring_base = vhost_set_vring_base,
> + .vhost_get_vring_base = vhost_get_vring_base,
> + .vhost_set_vring_kick = vhost_set_vring_kick,
> + .vhost_set_vring_call = vhost_set_vring_call,
> + .vhost_set_features = vhost_set_features,
> + .vhost_get_features = vhost_kernel_get_features,
> + .vhost_set_owner = vhost_set_owner,
> + .vhost_reset_owner = vhost_reset_owner,
> };
>
> int vhost_set_backend_type(struct vhost_dev *dev, VhostBackendType backend_type)
> diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> index de87562..d5b7951 100644
> --- a/hw/virtio/vhost-user.c
> +++ b/hw/virtio/vhost-user.c
> @@ -176,6 +176,7 @@ fail:
> return -1;
> }
>
> +/* most non-init callers ignore the error */
> static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
> int *fds, int fd_num)
> {
> @@ -190,148 +191,280 @@ static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
> 0 : -1;
> }
>
> -static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
> - void *arg)
> +static int vhost_net_set_backend(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_LOG_BASE,
> + .flags = VHOST_USER_VERSION,
> + .u64 = base,
> + .size = sizeof(m.u64),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_mem_table(struct vhost_dev *dev,
> + struct vhost_memory *mem)
> {
> - VhostUserMsg msg;
> - VhostUserRequest msg_request;
> - struct vhost_vring_file *file = 0;
> - int need_reply = 0;
> int fds[VHOST_MEMORY_MAX_NREGIONS];
> int i, fd;
> size_t fd_num = 0;
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_MEM_TABLE,
> + .flags = VHOST_USER_VERSION,
> + };
>
> - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
> + for (i = 0; i < dev->mem->nregions; ++i) {
> + struct vhost_memory_region *reg = dev->mem->regions + i;
> + ram_addr_t ram_addr;
> +
> + assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> + qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr,
> + &ram_addr);
> + fd = qemu_get_ram_fd(ram_addr);
> + if (fd > 0) {
> + msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
> + msg.memory.regions[fd_num].memory_size = reg->memory_size;
> + msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
> + msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
> + (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> + assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> + fds[fd_num++] = fd;
> + }
> + }
>
> - msg_request = vhost_user_request_translate(request);
> - msg.request = msg_request;
> - msg.flags = VHOST_USER_VERSION;
> - msg.size = 0;
> + msg.memory.nregions = fd_num;
>
> - switch (msg_request) {
> - case VHOST_USER_GET_FEATURES:
> - need_reply = 1;
> - break;
> -
> - case VHOST_USER_SET_FEATURES:
> - case VHOST_USER_SET_LOG_BASE:
> - msg.u64 = *((__u64 *) arg);
> - msg.size = sizeof(m.u64);
> - break;
> -
> - case VHOST_USER_SET_OWNER:
> - case VHOST_USER_RESET_OWNER:
> - break;
> -
> - case VHOST_USER_SET_MEM_TABLE:
> - for (i = 0; i < dev->mem->nregions; ++i) {
> - struct vhost_memory_region *reg = dev->mem->regions + i;
> - ram_addr_t ram_addr;
> -
> - assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> - qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr, &ram_addr);
> - fd = qemu_get_ram_fd(ram_addr);
> - if (fd > 0) {
> - msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
> - msg.memory.regions[fd_num].memory_size = reg->memory_size;
> - msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
> - msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
> - (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> - assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> - fds[fd_num++] = fd;
> - }
> - }
> + if (!fd_num) {
> + error_report("Failed initializing vhost-user memory map, "
> + "consider using -object memory-backend-file share=on");
> + return -1;
> + }
>
> - msg.memory.nregions = fd_num;
> + msg.size = sizeof(m.memory.nregions);
> + msg.size += sizeof(m.memory.padding);
> + msg.size += fd_num * sizeof(VhostUserMemoryRegion);
>
> - if (!fd_num) {
> - error_report("Failed initializing vhost-user memory map, "
> - "consider using -object memory-backend-file share=on");
> - return -1;
> - }
> + vhost_user_write(dev, &msg, fds, fd_num);
>
> - msg.size = sizeof(m.memory.nregions);
> - msg.size += sizeof(m.memory.padding);
> - msg.size += fd_num * sizeof(VhostUserMemoryRegion);
> -
> - break;
> -
> - case VHOST_USER_SET_LOG_FD:
> - fds[fd_num++] = *((int *) arg);
> - break;
> -
> - case VHOST_USER_SET_VRING_NUM:
> - case VHOST_USER_SET_VRING_BASE:
> - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> - msg.size = sizeof(m.state);
> - break;
> -
> - case VHOST_USER_GET_VRING_BASE:
> - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> - msg.size = sizeof(m.state);
> - need_reply = 1;
> - break;
> -
> - case VHOST_USER_SET_VRING_ADDR:
> - memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
> - msg.size = sizeof(m.addr);
> - break;
> -
> - case VHOST_USER_SET_VRING_KICK:
> - case VHOST_USER_SET_VRING_CALL:
> - case VHOST_USER_SET_VRING_ERR:
> - file = arg;
> - msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
> - msg.size = sizeof(m.u64);
> - if (ioeventfd_enabled() && file->fd > 0) {
> - fds[fd_num++] = file->fd;
> - } else {
> - msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> - }
> - break;
> - default:
> - error_report("vhost-user trying to send unhandled ioctl");
> + return 0;
> +}
> +
> +static int vhost_set_vring_addr(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_ADDR,
> + .flags = VHOST_USER_VERSION,
> + .addr = *addr,
> + .size = sizeof(*addr),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_endian(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_set_vring_num(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_NUM,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_BASE,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_get_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_GET_VRING_BASE,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + if (vhost_user_read(dev, &msg) < 0) {
> + return 0;
> + }
> +
> + if (msg.request != VHOST_USER_GET_VRING_BASE) {
> + error_report("Received unexpected msg type. Expected %d received %d",
> + VHOST_USER_GET_FEATURES, msg.request);
> return -1;
> - break;
> }
>
> - if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
> - return 0;
> + if (msg.size != sizeof(m.state)) {
> + error_report("Received bad msg size.");
> + return -1;
> }
>
> - if (need_reply) {
> - if (vhost_user_read(dev, &msg) < 0) {
> - return 0;
> - }
> + *ring = msg.state;
>
> - if (msg_request != msg.request) {
> - error_report("Received unexpected msg type."
> - " Expected %d received %d", msg_request, msg.request);
> - return -1;
> - }
> + return 0;
> +}
>
> - switch (msg_request) {
> - case VHOST_USER_GET_FEATURES:
> - if (msg.size != sizeof(m.u64)) {
> - error_report("Received bad msg size.");
> - return -1;
> - }
> - *((__u64 *) arg) = msg.u64;
> - break;
> - case VHOST_USER_GET_VRING_BASE:
> - if (msg.size != sizeof(m.state)) {
> - error_report("Received bad msg size.");
> - return -1;
> - }
> - memcpy(arg, &msg.state, sizeof(struct vhost_vring_state));
> - break;
> - default:
> - error_report("Received unexpected msg type.");
> - return -1;
> - break;
> - }
> +static int vhost_set_vring_file(struct vhost_dev *dev,
> + VhostUserRequest request,
> + struct vhost_vring_file *file)
> +{
> + int fds[VHOST_MEMORY_MAX_NREGIONS];
> + size_t fd_num = 0;
> + VhostUserMsg msg = {
> + .request = request,
> + .flags = VHOST_USER_VERSION,
> + .u64 = file->index & VHOST_USER_VRING_IDX_MASK,
> + .size = sizeof(m.u64),
> + };
> +
> + if (ioeventfd_enabled() && file->fd > 0) {
> + fds[fd_num++] = file->fd;
> + } else {
> + msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> }
>
> + vhost_user_write(dev, &msg, fds, fd_num);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_kick(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
> +}
> +
> +static int vhost_set_vring_call(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
> +}
> +
> +static int vhost_set_features(struct vhost_dev *dev,
> + uint64_t features)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_FEATURES,
> + .flags = VHOST_USER_VERSION,
> + .u64 = features,
> + .size = sizeof(m.u64),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_user_get_features(struct vhost_dev *dev,
> + uint64_t *features)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_GET_FEATURES,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + if (vhost_user_read(dev, &msg) < 0) {
> + return 0;
> + }
> +
> + if (msg.request != VHOST_USER_GET_FEATURES) {
> + error_report("Received unexpected msg type. Expected %d received %d",
> + VHOST_USER_GET_FEATURES, msg.request);
> + return -1;
> + }
> +
> + if (msg.size != sizeof(m.u64)) {
> + error_report("Received bad msg size.");
> + return -1;
> + }
> +
> + *features = msg.u64;
> +
> + return 0;
> +}
> +
> +static int vhost_set_owner(struct vhost_dev *dev)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_OWNER,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_reset_owner(struct vhost_dev *dev)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_RESET_OWNER,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> return 0;
> }
>
If you define a specific function for each messages it can be
interesting to add function for messages to get/set protocol features
(VHOST_USER_GET_PROTOCOL_FEATURES and
VHOST_USER_SET_PROTOCOL_FEATURES) and modify the vhost_user_init
function to call these specific functions (this function can be
already modified to use the specific function for
VHOST_USER_GET_FEATURES message to avoid code duplication)
> @@ -402,7 +535,24 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
>
> const VhostOps user_ops = {
> .backend_type = VHOST_BACKEND_TYPE_USER,
> - .vhost_call = vhost_user_call,
> .vhost_backend_init = vhost_user_init,
> - .vhost_backend_cleanup = vhost_user_cleanup
> - };
> + .vhost_backend_cleanup = vhost_user_cleanup,
> +
> + .vhost_net_set_backend = vhost_net_set_backend,
> + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> + .vhost_set_log_base = vhost_set_log_base,
> + .vhost_set_mem_table = vhost_set_mem_table,
> + .vhost_set_vring_addr = vhost_set_vring_addr,
> + .vhost_set_vring_endian = vhost_set_vring_endian,
> + .vhost_set_vring_num = vhost_set_vring_num,
> + .vhost_set_vring_base = vhost_set_vring_base,
> + .vhost_get_vring_base = vhost_get_vring_base,
> + .vhost_set_vring_kick = vhost_set_vring_kick,
> + .vhost_set_vring_call = vhost_set_vring_call,
> + .vhost_set_features = vhost_set_features,
> + .vhost_get_features = vhost_user_get_features,
> + .vhost_set_owner = vhost_set_owner,
> + .vhost_reset_owner = vhost_reset_owner,
> +};
> diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> index 81209ba..83ef164 100644
> --- a/hw/virtio/vhost.c
> +++ b/hw/virtio/vhost.c
> @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
>
> /* inform backend of log switching, this must be done before
> releasing the current log, to ensure no logging is lost */
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_LOG_BASE, &log_base);
> + r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> assert(r >= 0);
> vhost_log_put(dev, true);
> dev->log = log;
> @@ -525,7 +525,7 @@ static void vhost_commit(MemoryListener *listener)
> }
>
> if (!dev->log_enabled) {
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
> + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> assert(r >= 0);
> dev->memory_changed = false;
> return;
> @@ -538,7 +538,7 @@ static void vhost_commit(MemoryListener *listener)
> if (dev->log_size < log_size) {
> vhost_dev_log_resize(dev, log_size + VHOST_LOG_BUFFER);
> }
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
> + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> assert(r >= 0);
> /* To log less, can only decrease log size after table update. */
> if (dev->log_size > log_size + VHOST_LOG_BUFFER) {
> @@ -606,7 +606,7 @@ static int vhost_virtqueue_set_addr(struct vhost_dev *dev,
> .log_guest_addr = vq->used_phys,
> .flags = enable_log ? (1 << VHOST_VRING_F_LOG) : 0,
> };
> - int r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ADDR, &addr);
> + int r = dev->vhost_ops->vhost_set_vring_addr(dev, &addr);
> if (r < 0) {
> return -errno;
> }
> @@ -620,7 +620,7 @@ static int vhost_dev_set_features(struct vhost_dev *dev, bool enable_log)
> if (enable_log) {
> features |= 0x1ULL << VHOST_F_LOG_ALL;
> }
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_FEATURES, &features);
> + r = dev->vhost_ops->vhost_set_features(dev, features);
> return r < 0 ? -errno : 0;
> }
>
> @@ -725,7 +725,7 @@ static int vhost_virtqueue_set_vring_endian_legacy(struct vhost_dev *dev,
> .num = is_big_endian
> };
>
> - if (!dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ENDIAN, &s)) {
> + if (!dev->vhost_ops->vhost_set_vring_endian(dev, &s)) {
> return 0;
> }
>
> @@ -756,13 +756,13 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
> assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
>
> vq->num = state.num = virtio_queue_get_num(vdev, idx);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_NUM, &state);
> + r = dev->vhost_ops->vhost_set_vring_num(dev, &state);
> if (r) {
> return -errno;
> }
>
> state.num = virtio_queue_get_last_avail_idx(vdev, idx);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_BASE, &state);
> + r = dev->vhost_ops->vhost_set_vring_base(dev, &state);
> if (r) {
> return -errno;
> }
> @@ -814,7 +814,7 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
> }
>
> file.fd = event_notifier_get_fd(virtio_queue_get_host_notifier(vvq));
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_KICK, &file);
> + r = dev->vhost_ops->vhost_set_vring_kick(dev, &file);
> if (r) {
> r = -errno;
> goto fail_kick;
> @@ -853,7 +853,7 @@ static void vhost_virtqueue_stop(struct vhost_dev *dev,
> };
> int r;
> assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_GET_VRING_BASE, &state);
> + r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
> if (r < 0) {
> fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
> fflush(stderr);
> @@ -909,7 +909,7 @@ static int vhost_virtqueue_init(struct vhost_dev *dev,
> }
>
> file.fd = event_notifier_get_fd(&vq->masked_notifier);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_CALL, &file);
> + r = dev->vhost_ops->vhost_set_vring_call(dev, &file);
> if (r) {
> r = -errno;
> goto fail_call;
> @@ -941,12 +941,12 @@ int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
> return -errno;
> }
>
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_OWNER, NULL);
> + r = hdev->vhost_ops->vhost_set_owner(hdev);
> if (r < 0) {
> goto fail;
> }
>
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_GET_FEATURES, &features);
> + r = hdev->vhost_ops->vhost_get_features(hdev, &features);
> if (r < 0) {
> goto fail;
> }
> @@ -1102,7 +1102,7 @@ void vhost_virtqueue_mask(struct vhost_dev *hdev, VirtIODevice *vdev, int n,
> } else {
> file.fd = event_notifier_get_fd(virtio_queue_get_guest_notifier(vvq));
> }
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_VRING_CALL, &file);
> + r = hdev->vhost_ops->vhost_set_vring_call(hdev, &file);
> assert(r >= 0);
> }
>
> @@ -1144,7 +1144,7 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
> if (r < 0) {
> goto fail_features;
> }
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_MEM_TABLE, hdev->mem);
> + r = hdev->vhost_ops->vhost_set_mem_table(hdev, hdev->mem);
> if (r < 0) {
> r = -errno;
> goto fail_mem;
> @@ -1166,8 +1166,8 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
> hdev->log_size = vhost_get_log_size(hdev);
> hdev->log = vhost_log_get(hdev->log_size, share);
> log_base = (uintptr_t)hdev->log->log;
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> - hdev->log_size ? &log_base : NULL);
> + r = hdev->vhost_ops->vhost_set_log_base(hdev,
> + hdev->log_size ? log_base : 0);
> if (r < 0) {
> r = -errno;
> goto fail_log;
> diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
> index e472f29..42cfb87 100644
> --- a/include/hw/virtio/vhost-backend.h
> +++ b/include/hw/virtio/vhost-backend.h
> @@ -19,17 +19,70 @@ typedef enum VhostBackendType {
> } VhostBackendType;
>
> struct vhost_dev;
> +struct vhost_memory;
> +struct vhost_vring_file;
> +struct vhost_vring_state;
> +struct vhost_vring_addr;
> +struct vhost_scsi_target;
>
> -typedef int (*vhost_call)(struct vhost_dev *dev, unsigned long int request,
> - void *arg);
> typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
> typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
>
> +typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_scsi_set_endpoint_op)(struct vhost_dev *dev,
> + struct vhost_scsi_target *target);
> +typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
> + struct vhost_scsi_target *target);
> +typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> + int *version);
> +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base);
> +typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> + struct vhost_memory *mem);
> +typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr);
> +typedef int (*vhost_set_vring_endian_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_num_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_base_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_get_vring_base_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_kick_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_set_vring_call_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_set_features_op)(struct vhost_dev *dev,
> + uint64_t features);
> +typedef int (*vhost_get_features_op)(struct vhost_dev *dev,
> + uint64_t *features);
> +typedef int (*vhost_set_owner_op)(struct vhost_dev *dev);
> +typedef int (*vhost_reset_owner_op)(struct vhost_dev *dev);
> +
> typedef struct VhostOps {
> VhostBackendType backend_type;
> - vhost_call vhost_call;
> +
> vhost_backend_init vhost_backend_init;
> vhost_backend_cleanup vhost_backend_cleanup;
> +
> + vhost_net_set_backend_op vhost_net_set_backend;
> + vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
> + vhost_scsi_clear_endpoint_op vhost_scsi_clear_endpoint;
> + vhost_scsi_get_abi_version_op vhost_scsi_get_abi_version;
> + vhost_set_log_base_op vhost_set_log_base;
> + vhost_set_mem_table_op vhost_set_mem_table;
> + vhost_set_vring_addr_op vhost_set_vring_addr;
> + vhost_set_vring_endian_op vhost_set_vring_endian;
> + vhost_set_vring_num_op vhost_set_vring_num;
> + vhost_set_vring_base_op vhost_set_vring_base;
> + vhost_get_vring_base_op vhost_get_vring_base;
> + vhost_set_vring_kick_op vhost_set_vring_kick;
> + vhost_set_vring_call_op vhost_set_vring_call;
> + vhost_set_features_op vhost_set_features;
> + vhost_get_features_op vhost_get_features;
> + vhost_set_owner_op vhost_set_owner;
> + vhost_reset_owner_op vhost_reset_owner;
> } VhostOps;
>
> extern const VhostOps user_ops;
> --
> 2.4.3
>
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call
2015-09-21 7:33 ` Thibaut Collet
@ 2015-09-21 8:56 ` Michael S. Tsirkin
0 siblings, 0 replies; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 8:56 UTC (permalink / raw)
To: Thibaut Collet
Cc: Linhaifeng, marcandre.lureau, Jason Wang, qemu-devel,
Paolo Bonzini
On Mon, Sep 21, 2015 at 09:33:04AM +0200, Thibaut Collet wrote:
> > +static int vhost_reset_owner(struct vhost_dev *dev)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_RESET_OWNER,
> > + .flags = VHOST_USER_VERSION,
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > return 0;
> > }
> >
>
> If you define a specific function for each messages it can be
> interesting to add function for messages to get/set protocol features
> (VHOST_USER_GET_PROTOCOL_FEATURES and
> VHOST_USER_SET_PROTOCOL_FEATURES) and modify the vhost_user_init
> function to call these specific functions (this function can be
> already modified to use the specific function for
> VHOST_USER_GET_FEATURES message to avoid code duplication)
I'm not sure what this would buy us ... can be a patch on top.
--
MST
^ permalink raw reply [flat|nested] 41+ messages in thread
* Re: [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call marcandre.lureau
2015-09-21 7:33 ` Thibaut Collet
@ 2015-09-21 8:58 ` Michael S. Tsirkin
2015-09-21 14:05 ` Marc-André Lureau
1 sibling, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 8:58 UTC (permalink / raw)
To: marcandre.lureau
Cc: haifeng.lin, thibaut.collet, jasowang, qemu-devel, pbonzini
On Sat, Sep 19, 2015 at 12:12:00PM +0200, marcandre.lureau@redhat.com wrote:
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Replace the generic vhost_call() by specific functions for each
> function call to help with type safety and changing arguments.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
OK but I would rather not make logging feature depend on the
refactoring.
How about moving each call over from vhost_call by a separate patch?
Start with vhost_set_log_base as the 1st one, this way I can apply
logging support while we still review the larger refactorings.
> ---
> hw/net/vhost_net.c | 12 +-
> hw/scsi/vhost-scsi.c | 7 +-
> hw/virtio/vhost-backend.c | 140 +++++++++++--
> hw/virtio/vhost-user.c | 402 ++++++++++++++++++++++++++------------
> hw/virtio/vhost.c | 34 ++--
> include/hw/virtio/vhost-backend.h | 59 +++++-
> 6 files changed, 484 insertions(+), 170 deletions(-)
>
> diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
> index 9d32d76..d116fb3 100644
> --- a/hw/net/vhost_net.c
> +++ b/hw/net/vhost_net.c
> @@ -243,8 +243,7 @@ static int vhost_net_start_one(struct vhost_net *net,
> file.fd = net->backend;
> for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> if (r < 0) {
> r = -errno;
> goto fail;
> @@ -257,8 +256,7 @@ fail:
> if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
> while (file.index-- > 0) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> assert(r >= 0);
> }
> }
> @@ -280,15 +278,13 @@ static void vhost_net_stop_one(struct vhost_net *net,
> 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;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> - &file);
> + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> assert(r >= 0);
> }
> } else if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER) {
> for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> const VhostOps *vhost_ops = net->dev.vhost_ops;
> - int r = vhost_ops->vhost_call(&net->dev, VHOST_RESET_OWNER,
> - NULL);
> + int r = vhost_ops->vhost_reset_owner(&net->dev);
> assert(r >= 0);
> }
> }
> diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
> index bac9ddb..a0034ab 100644
> --- a/hw/scsi/vhost-scsi.c
> +++ b/hw/scsi/vhost-scsi.c
> @@ -45,7 +45,7 @@ static int vhost_scsi_set_endpoint(VHostSCSI *s)
>
> memset(&backend, 0, sizeof(backend));
> pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
> - ret = vhost_ops->vhost_call(&s->dev, VHOST_SCSI_SET_ENDPOINT, &backend);
> + ret = vhost_ops->vhost_scsi_set_endpoint(&s->dev, &backend);
> if (ret < 0) {
> return -errno;
> }
> @@ -60,7 +60,7 @@ static void vhost_scsi_clear_endpoint(VHostSCSI *s)
>
> memset(&backend, 0, sizeof(backend));
> pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn), vs->conf.wwpn);
> - vhost_ops->vhost_call(&s->dev, VHOST_SCSI_CLEAR_ENDPOINT, &backend);
> + vhost_ops->vhost_scsi_clear_endpoint(&s->dev, &backend);
> }
>
> static int vhost_scsi_start(VHostSCSI *s)
> @@ -76,8 +76,7 @@ static int vhost_scsi_start(VHostSCSI *s)
> return -ENOSYS;
> }
>
> - ret = vhost_ops->vhost_call(&s->dev,
> - VHOST_SCSI_GET_ABI_VERSION, &abi_version);
> + ret = vhost_ops->vhost_scsi_get_abi_version(&s->dev, &abi_version);
> if (ret < 0) {
> return -errno;
> }
> diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> index 4d68a27..bf2d1d4 100644
> --- a/hw/virtio/vhost-backend.c
> +++ b/hw/virtio/vhost-backend.c
> @@ -11,19 +11,10 @@
> #include "hw/virtio/vhost.h"
> #include "hw/virtio/vhost-backend.h"
> #include "qemu/error-report.h"
> +#include "linux/vhost.h"
>
> #include <sys/ioctl.h>
>
> -static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int request,
> - void *arg)
> -{
> - int fd = (uintptr_t) dev->opaque;
> -
> - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> -
> - return ioctl(fd, request, arg);
> -}
> -
> static int vhost_kernel_init(struct vhost_dev *dev, void *opaque)
> {
> assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> @@ -42,11 +33,136 @@ static int vhost_kernel_cleanup(struct vhost_dev *dev)
> return close(fd);
> }
>
> +static int vhost_kernel_call(struct vhost_dev *dev,
> + unsigned long int request, void *arg)
> +{
> + int fd = (uintptr_t) dev->opaque;
> +
> + assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> +
> + return ioctl(fd, request, arg);
> +}
> +
> +static int vhost_net_set_backend(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
> +}
> +
> +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
> +}
> +
> +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
> +}
> +
> +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> +{
> + return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> +}
> +
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> +}
> +
> +static int vhost_set_mem_table(struct vhost_dev *dev,
> + struct vhost_memory *mem)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
> +}
> +
> +static int vhost_set_vring_addr(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
> +}
> +
> +static int vhost_set_vring_endian(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
> +}
> +
> +static int vhost_set_vring_num(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
> +}
> +
> +static int vhost_set_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
> +}
> +
> +static int vhost_get_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
> +}
> +
> +static int vhost_set_vring_kick(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
> +}
> +
> +static int vhost_set_vring_call(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
> +}
> +
> +static int vhost_set_features(struct vhost_dev *dev,
> + uint64_t features)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
> +}
> +
> +static int vhost_kernel_get_features(struct vhost_dev *dev,
> + uint64_t *features)
> +{
> + return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
> +}
> +
> +static int vhost_set_owner(struct vhost_dev *dev)
> +{
> + return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
> +}
> +
> +static int vhost_reset_owner(struct vhost_dev *dev)
> +{
> + return vhost_kernel_call(dev, VHOST_RESET_OWNER, NULL);
> +}
> +
> static const VhostOps kernel_ops = {
> .backend_type = VHOST_BACKEND_TYPE_KERNEL,
> - .vhost_call = vhost_kernel_call,
> .vhost_backend_init = vhost_kernel_init,
> - .vhost_backend_cleanup = vhost_kernel_cleanup
> + .vhost_backend_cleanup = vhost_kernel_cleanup,
> +
> + .vhost_net_set_backend = vhost_net_set_backend,
> + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> + .vhost_set_log_base = vhost_set_log_base,
> + .vhost_set_mem_table = vhost_set_mem_table,
> + .vhost_set_vring_addr = vhost_set_vring_addr,
> + .vhost_set_vring_endian = vhost_set_vring_endian,
> + .vhost_set_vring_num = vhost_set_vring_num,
> + .vhost_set_vring_base = vhost_set_vring_base,
> + .vhost_get_vring_base = vhost_get_vring_base,
> + .vhost_set_vring_kick = vhost_set_vring_kick,
> + .vhost_set_vring_call = vhost_set_vring_call,
> + .vhost_set_features = vhost_set_features,
> + .vhost_get_features = vhost_kernel_get_features,
> + .vhost_set_owner = vhost_set_owner,
> + .vhost_reset_owner = vhost_reset_owner,
> };
>
> int vhost_set_backend_type(struct vhost_dev *dev, VhostBackendType backend_type)
> diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> index de87562..d5b7951 100644
> --- a/hw/virtio/vhost-user.c
> +++ b/hw/virtio/vhost-user.c
> @@ -176,6 +176,7 @@ fail:
> return -1;
> }
>
> +/* most non-init callers ignore the error */
> static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
> int *fds, int fd_num)
> {
> @@ -190,148 +191,280 @@ static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
> 0 : -1;
> }
>
> -static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
> - void *arg)
> +static int vhost_net_set_backend(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> + struct vhost_scsi_target *target)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_LOG_BASE,
> + .flags = VHOST_USER_VERSION,
> + .u64 = base,
> + .size = sizeof(m.u64),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_mem_table(struct vhost_dev *dev,
> + struct vhost_memory *mem)
> {
> - VhostUserMsg msg;
> - VhostUserRequest msg_request;
> - struct vhost_vring_file *file = 0;
> - int need_reply = 0;
> int fds[VHOST_MEMORY_MAX_NREGIONS];
> int i, fd;
> size_t fd_num = 0;
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_MEM_TABLE,
> + .flags = VHOST_USER_VERSION,
> + };
>
> - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
> + for (i = 0; i < dev->mem->nregions; ++i) {
> + struct vhost_memory_region *reg = dev->mem->regions + i;
> + ram_addr_t ram_addr;
> +
> + assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> + qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr,
> + &ram_addr);
> + fd = qemu_get_ram_fd(ram_addr);
> + if (fd > 0) {
> + msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
> + msg.memory.regions[fd_num].memory_size = reg->memory_size;
> + msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
> + msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
> + (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> + assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> + fds[fd_num++] = fd;
> + }
> + }
>
> - msg_request = vhost_user_request_translate(request);
> - msg.request = msg_request;
> - msg.flags = VHOST_USER_VERSION;
> - msg.size = 0;
> + msg.memory.nregions = fd_num;
>
> - switch (msg_request) {
> - case VHOST_USER_GET_FEATURES:
> - need_reply = 1;
> - break;
> -
> - case VHOST_USER_SET_FEATURES:
> - case VHOST_USER_SET_LOG_BASE:
> - msg.u64 = *((__u64 *) arg);
> - msg.size = sizeof(m.u64);
> - break;
> -
> - case VHOST_USER_SET_OWNER:
> - case VHOST_USER_RESET_OWNER:
> - break;
> -
> - case VHOST_USER_SET_MEM_TABLE:
> - for (i = 0; i < dev->mem->nregions; ++i) {
> - struct vhost_memory_region *reg = dev->mem->regions + i;
> - ram_addr_t ram_addr;
> -
> - assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> - qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr, &ram_addr);
> - fd = qemu_get_ram_fd(ram_addr);
> - if (fd > 0) {
> - msg.memory.regions[fd_num].userspace_addr = reg->userspace_addr;
> - msg.memory.regions[fd_num].memory_size = reg->memory_size;
> - msg.memory.regions[fd_num].guest_phys_addr = reg->guest_phys_addr;
> - msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
> - (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> - assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> - fds[fd_num++] = fd;
> - }
> - }
> + if (!fd_num) {
> + error_report("Failed initializing vhost-user memory map, "
> + "consider using -object memory-backend-file share=on");
> + return -1;
> + }
>
> - msg.memory.nregions = fd_num;
> + msg.size = sizeof(m.memory.nregions);
> + msg.size += sizeof(m.memory.padding);
> + msg.size += fd_num * sizeof(VhostUserMemoryRegion);
>
> - if (!fd_num) {
> - error_report("Failed initializing vhost-user memory map, "
> - "consider using -object memory-backend-file share=on");
> - return -1;
> - }
> + vhost_user_write(dev, &msg, fds, fd_num);
>
> - msg.size = sizeof(m.memory.nregions);
> - msg.size += sizeof(m.memory.padding);
> - msg.size += fd_num * sizeof(VhostUserMemoryRegion);
> -
> - break;
> -
> - case VHOST_USER_SET_LOG_FD:
> - fds[fd_num++] = *((int *) arg);
> - break;
> -
> - case VHOST_USER_SET_VRING_NUM:
> - case VHOST_USER_SET_VRING_BASE:
> - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> - msg.size = sizeof(m.state);
> - break;
> -
> - case VHOST_USER_GET_VRING_BASE:
> - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> - msg.size = sizeof(m.state);
> - need_reply = 1;
> - break;
> -
> - case VHOST_USER_SET_VRING_ADDR:
> - memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
> - msg.size = sizeof(m.addr);
> - break;
> -
> - case VHOST_USER_SET_VRING_KICK:
> - case VHOST_USER_SET_VRING_CALL:
> - case VHOST_USER_SET_VRING_ERR:
> - file = arg;
> - msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
> - msg.size = sizeof(m.u64);
> - if (ioeventfd_enabled() && file->fd > 0) {
> - fds[fd_num++] = file->fd;
> - } else {
> - msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> - }
> - break;
> - default:
> - error_report("vhost-user trying to send unhandled ioctl");
> + return 0;
> +}
> +
> +static int vhost_set_vring_addr(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_ADDR,
> + .flags = VHOST_USER_VERSION,
> + .addr = *addr,
> + .size = sizeof(*addr),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_endian(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + error_report("vhost-user trying to send unhandled ioctl");
> + return -1;
> +}
> +
> +static int vhost_set_vring_num(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_NUM,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_VRING_BASE,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_get_vring_base(struct vhost_dev *dev,
> + struct vhost_vring_state *ring)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_GET_VRING_BASE,
> + .flags = VHOST_USER_VERSION,
> + .state = *ring,
> + .size = sizeof(*ring),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + if (vhost_user_read(dev, &msg) < 0) {
> + return 0;
> + }
> +
> + if (msg.request != VHOST_USER_GET_VRING_BASE) {
> + error_report("Received unexpected msg type. Expected %d received %d",
> + VHOST_USER_GET_FEATURES, msg.request);
> return -1;
> - break;
> }
>
> - if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
> - return 0;
> + if (msg.size != sizeof(m.state)) {
> + error_report("Received bad msg size.");
> + return -1;
> }
>
> - if (need_reply) {
> - if (vhost_user_read(dev, &msg) < 0) {
> - return 0;
> - }
> + *ring = msg.state;
>
> - if (msg_request != msg.request) {
> - error_report("Received unexpected msg type."
> - " Expected %d received %d", msg_request, msg.request);
> - return -1;
> - }
> + return 0;
> +}
>
> - switch (msg_request) {
> - case VHOST_USER_GET_FEATURES:
> - if (msg.size != sizeof(m.u64)) {
> - error_report("Received bad msg size.");
> - return -1;
> - }
> - *((__u64 *) arg) = msg.u64;
> - break;
> - case VHOST_USER_GET_VRING_BASE:
> - if (msg.size != sizeof(m.state)) {
> - error_report("Received bad msg size.");
> - return -1;
> - }
> - memcpy(arg, &msg.state, sizeof(struct vhost_vring_state));
> - break;
> - default:
> - error_report("Received unexpected msg type.");
> - return -1;
> - break;
> - }
> +static int vhost_set_vring_file(struct vhost_dev *dev,
> + VhostUserRequest request,
> + struct vhost_vring_file *file)
> +{
> + int fds[VHOST_MEMORY_MAX_NREGIONS];
> + size_t fd_num = 0;
> + VhostUserMsg msg = {
> + .request = request,
> + .flags = VHOST_USER_VERSION,
> + .u64 = file->index & VHOST_USER_VRING_IDX_MASK,
> + .size = sizeof(m.u64),
> + };
> +
> + if (ioeventfd_enabled() && file->fd > 0) {
> + fds[fd_num++] = file->fd;
> + } else {
> + msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> }
>
> + vhost_user_write(dev, &msg, fds, fd_num);
> +
> + return 0;
> +}
> +
> +static int vhost_set_vring_kick(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
> +}
> +
> +static int vhost_set_vring_call(struct vhost_dev *dev,
> + struct vhost_vring_file *file)
> +{
> + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
> +}
> +
> +static int vhost_set_features(struct vhost_dev *dev,
> + uint64_t features)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_FEATURES,
> + .flags = VHOST_USER_VERSION,
> + .u64 = features,
> + .size = sizeof(m.u64),
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_user_get_features(struct vhost_dev *dev,
> + uint64_t *features)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_GET_FEATURES,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + if (vhost_user_read(dev, &msg) < 0) {
> + return 0;
> + }
> +
> + if (msg.request != VHOST_USER_GET_FEATURES) {
> + error_report("Received unexpected msg type. Expected %d received %d",
> + VHOST_USER_GET_FEATURES, msg.request);
> + return -1;
> + }
> +
> + if (msg.size != sizeof(m.u64)) {
> + error_report("Received bad msg size.");
> + return -1;
> + }
> +
> + *features = msg.u64;
> +
> + return 0;
> +}
> +
> +static int vhost_set_owner(struct vhost_dev *dev)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_SET_OWNER,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> + return 0;
> +}
> +
> +static int vhost_reset_owner(struct vhost_dev *dev)
> +{
> + VhostUserMsg msg = {
> + .request = VHOST_USER_RESET_OWNER,
> + .flags = VHOST_USER_VERSION,
> + };
> +
> + vhost_user_write(dev, &msg, NULL, 0);
> +
> return 0;
> }
>
> @@ -402,7 +535,24 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
>
> const VhostOps user_ops = {
> .backend_type = VHOST_BACKEND_TYPE_USER,
> - .vhost_call = vhost_user_call,
> .vhost_backend_init = vhost_user_init,
> - .vhost_backend_cleanup = vhost_user_cleanup
> - };
> + .vhost_backend_cleanup = vhost_user_cleanup,
> +
> + .vhost_net_set_backend = vhost_net_set_backend,
> + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> + .vhost_set_log_base = vhost_set_log_base,
> + .vhost_set_mem_table = vhost_set_mem_table,
> + .vhost_set_vring_addr = vhost_set_vring_addr,
> + .vhost_set_vring_endian = vhost_set_vring_endian,
> + .vhost_set_vring_num = vhost_set_vring_num,
> + .vhost_set_vring_base = vhost_set_vring_base,
> + .vhost_get_vring_base = vhost_get_vring_base,
> + .vhost_set_vring_kick = vhost_set_vring_kick,
> + .vhost_set_vring_call = vhost_set_vring_call,
> + .vhost_set_features = vhost_set_features,
> + .vhost_get_features = vhost_user_get_features,
> + .vhost_set_owner = vhost_set_owner,
> + .vhost_reset_owner = vhost_reset_owner,
> +};
> diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> index 81209ba..83ef164 100644
> --- a/hw/virtio/vhost.c
> +++ b/hw/virtio/vhost.c
> @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
>
> /* inform backend of log switching, this must be done before
> releasing the current log, to ensure no logging is lost */
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_LOG_BASE, &log_base);
> + r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> assert(r >= 0);
> vhost_log_put(dev, true);
> dev->log = log;
> @@ -525,7 +525,7 @@ static void vhost_commit(MemoryListener *listener)
> }
>
> if (!dev->log_enabled) {
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
> + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> assert(r >= 0);
> dev->memory_changed = false;
> return;
> @@ -538,7 +538,7 @@ static void vhost_commit(MemoryListener *listener)
> if (dev->log_size < log_size) {
> vhost_dev_log_resize(dev, log_size + VHOST_LOG_BUFFER);
> }
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
> + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> assert(r >= 0);
> /* To log less, can only decrease log size after table update. */
> if (dev->log_size > log_size + VHOST_LOG_BUFFER) {
> @@ -606,7 +606,7 @@ static int vhost_virtqueue_set_addr(struct vhost_dev *dev,
> .log_guest_addr = vq->used_phys,
> .flags = enable_log ? (1 << VHOST_VRING_F_LOG) : 0,
> };
> - int r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ADDR, &addr);
> + int r = dev->vhost_ops->vhost_set_vring_addr(dev, &addr);
> if (r < 0) {
> return -errno;
> }
> @@ -620,7 +620,7 @@ static int vhost_dev_set_features(struct vhost_dev *dev, bool enable_log)
> if (enable_log) {
> features |= 0x1ULL << VHOST_F_LOG_ALL;
> }
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_FEATURES, &features);
> + r = dev->vhost_ops->vhost_set_features(dev, features);
> return r < 0 ? -errno : 0;
> }
>
> @@ -725,7 +725,7 @@ static int vhost_virtqueue_set_vring_endian_legacy(struct vhost_dev *dev,
> .num = is_big_endian
> };
>
> - if (!dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ENDIAN, &s)) {
> + if (!dev->vhost_ops->vhost_set_vring_endian(dev, &s)) {
> return 0;
> }
>
> @@ -756,13 +756,13 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
> assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
>
> vq->num = state.num = virtio_queue_get_num(vdev, idx);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_NUM, &state);
> + r = dev->vhost_ops->vhost_set_vring_num(dev, &state);
> if (r) {
> return -errno;
> }
>
> state.num = virtio_queue_get_last_avail_idx(vdev, idx);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_BASE, &state);
> + r = dev->vhost_ops->vhost_set_vring_base(dev, &state);
> if (r) {
> return -errno;
> }
> @@ -814,7 +814,7 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
> }
>
> file.fd = event_notifier_get_fd(virtio_queue_get_host_notifier(vvq));
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_KICK, &file);
> + r = dev->vhost_ops->vhost_set_vring_kick(dev, &file);
> if (r) {
> r = -errno;
> goto fail_kick;
> @@ -853,7 +853,7 @@ static void vhost_virtqueue_stop(struct vhost_dev *dev,
> };
> int r;
> assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_GET_VRING_BASE, &state);
> + r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
> if (r < 0) {
> fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
> fflush(stderr);
> @@ -909,7 +909,7 @@ static int vhost_virtqueue_init(struct vhost_dev *dev,
> }
>
> file.fd = event_notifier_get_fd(&vq->masked_notifier);
> - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_CALL, &file);
> + r = dev->vhost_ops->vhost_set_vring_call(dev, &file);
> if (r) {
> r = -errno;
> goto fail_call;
> @@ -941,12 +941,12 @@ int vhost_dev_init(struct vhost_dev *hdev, void *opaque,
> return -errno;
> }
>
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_OWNER, NULL);
> + r = hdev->vhost_ops->vhost_set_owner(hdev);
> if (r < 0) {
> goto fail;
> }
>
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_GET_FEATURES, &features);
> + r = hdev->vhost_ops->vhost_get_features(hdev, &features);
> if (r < 0) {
> goto fail;
> }
> @@ -1102,7 +1102,7 @@ void vhost_virtqueue_mask(struct vhost_dev *hdev, VirtIODevice *vdev, int n,
> } else {
> file.fd = event_notifier_get_fd(virtio_queue_get_guest_notifier(vvq));
> }
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_VRING_CALL, &file);
> + r = hdev->vhost_ops->vhost_set_vring_call(hdev, &file);
> assert(r >= 0);
> }
>
> @@ -1144,7 +1144,7 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
> if (r < 0) {
> goto fail_features;
> }
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_MEM_TABLE, hdev->mem);
> + r = hdev->vhost_ops->vhost_set_mem_table(hdev, hdev->mem);
> if (r < 0) {
> r = -errno;
> goto fail_mem;
> @@ -1166,8 +1166,8 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
> hdev->log_size = vhost_get_log_size(hdev);
> hdev->log = vhost_log_get(hdev->log_size, share);
> log_base = (uintptr_t)hdev->log->log;
> - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> - hdev->log_size ? &log_base : NULL);
> + r = hdev->vhost_ops->vhost_set_log_base(hdev,
> + hdev->log_size ? log_base : 0);
> if (r < 0) {
> r = -errno;
> goto fail_log;
> diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
> index e472f29..42cfb87 100644
> --- a/include/hw/virtio/vhost-backend.h
> +++ b/include/hw/virtio/vhost-backend.h
> @@ -19,17 +19,70 @@ typedef enum VhostBackendType {
> } VhostBackendType;
>
> struct vhost_dev;
> +struct vhost_memory;
> +struct vhost_vring_file;
> +struct vhost_vring_state;
> +struct vhost_vring_addr;
> +struct vhost_scsi_target;
>
> -typedef int (*vhost_call)(struct vhost_dev *dev, unsigned long int request,
> - void *arg);
> typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
> typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
>
> +typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_scsi_set_endpoint_op)(struct vhost_dev *dev,
> + struct vhost_scsi_target *target);
> +typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
> + struct vhost_scsi_target *target);
> +typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> + int *version);
> +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base);
> +typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> + struct vhost_memory *mem);
> +typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> + struct vhost_vring_addr *addr);
> +typedef int (*vhost_set_vring_endian_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_num_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_base_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_get_vring_base_op)(struct vhost_dev *dev,
> + struct vhost_vring_state *ring);
> +typedef int (*vhost_set_vring_kick_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_set_vring_call_op)(struct vhost_dev *dev,
> + struct vhost_vring_file *file);
> +typedef int (*vhost_set_features_op)(struct vhost_dev *dev,
> + uint64_t features);
> +typedef int (*vhost_get_features_op)(struct vhost_dev *dev,
> + uint64_t *features);
> +typedef int (*vhost_set_owner_op)(struct vhost_dev *dev);
> +typedef int (*vhost_reset_owner_op)(struct vhost_dev *dev);
> +
> typedef struct VhostOps {
> VhostBackendType backend_type;
> - vhost_call vhost_call;
> +
> vhost_backend_init vhost_backend_init;
> vhost_backend_cleanup vhost_backend_cleanup;
> +
> + vhost_net_set_backend_op vhost_net_set_backend;
> + vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
> + vhost_scsi_clear_endpoint_op vhost_scsi_clear_endpoint;
> + vhost_scsi_get_abi_version_op vhost_scsi_get_abi_version;
> + vhost_set_log_base_op vhost_set_log_base;
> + vhost_set_mem_table_op vhost_set_mem_table;
> + vhost_set_vring_addr_op vhost_set_vring_addr;
> + vhost_set_vring_endian_op vhost_set_vring_endian;
> + vhost_set_vring_num_op vhost_set_vring_num;
> + vhost_set_vring_base_op vhost_set_vring_base;
> + vhost_get_vring_base_op vhost_get_vring_base;
> + vhost_set_vring_kick_op vhost_set_vring_kick;
> + vhost_set_vring_call_op vhost_set_vring_call;
> + vhost_set_features_op vhost_set_features;
> + vhost_get_features_op vhost_get_features;
> + vhost_set_owner_op vhost_set_owner;
> + vhost_reset_owner_op vhost_reset_owner;
> } VhostOps;
>
> extern const VhostOps user_ops;
> --
> 2.4.3
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call
2015-09-21 8:58 ` Michael S. Tsirkin
@ 2015-09-21 14:05 ` Marc-André Lureau
0 siblings, 0 replies; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-21 14:05 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
----- Original Message -----
> On Sat, Sep 19, 2015 at 12:12:00PM +0200, marcandre.lureau@redhat.com wrote:
> > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> > Replace the generic vhost_call() by specific functions for each
> > function call to help with type safety and changing arguments.
> >
> > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> OK but I would rather not make logging feature depend on the
> refactoring.
The refactoring is straightforward, but I can split this patch.
> How about moving each call over from vhost_call by a separate patch?
> Start with vhost_set_log_base as the 1st one, this way I can apply
> logging support while we still review the larger refactorings.
>
ok
> > ---
> > hw/net/vhost_net.c | 12 +-
> > hw/scsi/vhost-scsi.c | 7 +-
> > hw/virtio/vhost-backend.c | 140 +++++++++++--
> > hw/virtio/vhost-user.c | 402
> > ++++++++++++++++++++++++++------------
> > hw/virtio/vhost.c | 34 ++--
> > include/hw/virtio/vhost-backend.h | 59 +++++-
> > 6 files changed, 484 insertions(+), 170 deletions(-)
> >
> > diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
> > index 9d32d76..d116fb3 100644
> > --- a/hw/net/vhost_net.c
> > +++ b/hw/net/vhost_net.c
> > @@ -243,8 +243,7 @@ static int vhost_net_start_one(struct vhost_net *net,
> > file.fd = net->backend;
> > for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> > const VhostOps *vhost_ops = net->dev.vhost_ops;
> > - r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND,
> > - &file);
> > + r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> > if (r < 0) {
> > r = -errno;
> > goto fail;
> > @@ -257,8 +256,7 @@ fail:
> > if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) {
> > while (file.index-- > 0) {
> > const VhostOps *vhost_ops = net->dev.vhost_ops;
> > - int r = vhost_ops->vhost_call(&net->dev,
> > VHOST_NET_SET_BACKEND,
> > - &file);
> > + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> > assert(r >= 0);
> > }
> > }
> > @@ -280,15 +278,13 @@ static void vhost_net_stop_one(struct vhost_net *net,
> > 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;
> > - int r = vhost_ops->vhost_call(&net->dev,
> > VHOST_NET_SET_BACKEND,
> > - &file);
> > + int r = vhost_ops->vhost_net_set_backend(&net->dev, &file);
> > assert(r >= 0);
> > }
> > } else if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER)
> > {
> > for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
> > const VhostOps *vhost_ops = net->dev.vhost_ops;
> > - int r = vhost_ops->vhost_call(&net->dev, VHOST_RESET_OWNER,
> > - NULL);
> > + int r = vhost_ops->vhost_reset_owner(&net->dev);
> > assert(r >= 0);
> > }
> > }
> > diff --git a/hw/scsi/vhost-scsi.c b/hw/scsi/vhost-scsi.c
> > index bac9ddb..a0034ab 100644
> > --- a/hw/scsi/vhost-scsi.c
> > +++ b/hw/scsi/vhost-scsi.c
> > @@ -45,7 +45,7 @@ static int vhost_scsi_set_endpoint(VHostSCSI *s)
> >
> > memset(&backend, 0, sizeof(backend));
> > pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn),
> > vs->conf.wwpn);
> > - ret = vhost_ops->vhost_call(&s->dev, VHOST_SCSI_SET_ENDPOINT,
> > &backend);
> > + ret = vhost_ops->vhost_scsi_set_endpoint(&s->dev, &backend);
> > if (ret < 0) {
> > return -errno;
> > }
> > @@ -60,7 +60,7 @@ static void vhost_scsi_clear_endpoint(VHostSCSI *s)
> >
> > memset(&backend, 0, sizeof(backend));
> > pstrcpy(backend.vhost_wwpn, sizeof(backend.vhost_wwpn),
> > vs->conf.wwpn);
> > - vhost_ops->vhost_call(&s->dev, VHOST_SCSI_CLEAR_ENDPOINT, &backend);
> > + vhost_ops->vhost_scsi_clear_endpoint(&s->dev, &backend);
> > }
> >
> > static int vhost_scsi_start(VHostSCSI *s)
> > @@ -76,8 +76,7 @@ static int vhost_scsi_start(VHostSCSI *s)
> > return -ENOSYS;
> > }
> >
> > - ret = vhost_ops->vhost_call(&s->dev,
> > - VHOST_SCSI_GET_ABI_VERSION, &abi_version);
> > + ret = vhost_ops->vhost_scsi_get_abi_version(&s->dev, &abi_version);
> > if (ret < 0) {
> > return -errno;
> > }
> > diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> > index 4d68a27..bf2d1d4 100644
> > --- a/hw/virtio/vhost-backend.c
> > +++ b/hw/virtio/vhost-backend.c
> > @@ -11,19 +11,10 @@
> > #include "hw/virtio/vhost.h"
> > #include "hw/virtio/vhost-backend.h"
> > #include "qemu/error-report.h"
> > +#include "linux/vhost.h"
> >
> > #include <sys/ioctl.h>
> >
> > -static int vhost_kernel_call(struct vhost_dev *dev, unsigned long int
> > request,
> > - void *arg)
> > -{
> > - int fd = (uintptr_t) dev->opaque;
> > -
> > - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> > -
> > - return ioctl(fd, request, arg);
> > -}
> > -
> > static int vhost_kernel_init(struct vhost_dev *dev, void *opaque)
> > {
> > assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> > @@ -42,11 +33,136 @@ static int vhost_kernel_cleanup(struct vhost_dev *dev)
> > return close(fd);
> > }
> >
> > +static int vhost_kernel_call(struct vhost_dev *dev,
> > + unsigned long int request, void *arg)
> > +{
> > + int fd = (uintptr_t) dev->opaque;
> > +
> > + assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_KERNEL);
> > +
> > + return ioctl(fd, request, arg);
> > +}
> > +
> > +static int vhost_net_set_backend(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + return vhost_kernel_call(dev, VHOST_NET_SET_BACKEND, file);
> > +}
> > +
> > +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> > + struct vhost_scsi_target *target)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SCSI_SET_ENDPOINT, target);
> > +}
> > +
> > +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> > + struct vhost_scsi_target *target)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SCSI_CLEAR_ENDPOINT, target);
> > +}
> > +
> > +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> > +}
> > +
> > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> > +}
> > +
> > +static int vhost_set_mem_table(struct vhost_dev *dev,
> > + struct vhost_memory *mem)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_MEM_TABLE, mem);
> > +}
> > +
> > +static int vhost_set_vring_addr(struct vhost_dev *dev,
> > + struct vhost_vring_addr *addr)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_ADDR, addr);
> > +}
> > +
> > +static int vhost_set_vring_endian(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_ENDIAN, ring);
> > +}
> > +
> > +static int vhost_set_vring_num(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_NUM, ring);
> > +}
> > +
> > +static int vhost_set_vring_base(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_BASE, ring);
> > +}
> > +
> > +static int vhost_get_vring_base(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + return vhost_kernel_call(dev, VHOST_GET_VRING_BASE, ring);
> > +}
> > +
> > +static int vhost_set_vring_kick(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_KICK, file);
> > +}
> > +
> > +static int vhost_set_vring_call(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_VRING_CALL, file);
> > +}
> > +
> > +static int vhost_set_features(struct vhost_dev *dev,
> > + uint64_t features)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_FEATURES, &features);
> > +}
> > +
> > +static int vhost_kernel_get_features(struct vhost_dev *dev,
> > + uint64_t *features)
> > +{
> > + return vhost_kernel_call(dev, VHOST_GET_FEATURES, features);
> > +}
> > +
> > +static int vhost_set_owner(struct vhost_dev *dev)
> > +{
> > + return vhost_kernel_call(dev, VHOST_SET_OWNER, NULL);
> > +}
> > +
> > +static int vhost_reset_owner(struct vhost_dev *dev)
> > +{
> > + return vhost_kernel_call(dev, VHOST_RESET_OWNER, NULL);
> > +}
> > +
> > static const VhostOps kernel_ops = {
> > .backend_type = VHOST_BACKEND_TYPE_KERNEL,
> > - .vhost_call = vhost_kernel_call,
> > .vhost_backend_init = vhost_kernel_init,
> > - .vhost_backend_cleanup = vhost_kernel_cleanup
> > + .vhost_backend_cleanup = vhost_kernel_cleanup,
> > +
> > + .vhost_net_set_backend = vhost_net_set_backend,
> > + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> > + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> > + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> > + .vhost_set_log_base = vhost_set_log_base,
> > + .vhost_set_mem_table = vhost_set_mem_table,
> > + .vhost_set_vring_addr = vhost_set_vring_addr,
> > + .vhost_set_vring_endian = vhost_set_vring_endian,
> > + .vhost_set_vring_num = vhost_set_vring_num,
> > + .vhost_set_vring_base = vhost_set_vring_base,
> > + .vhost_get_vring_base = vhost_get_vring_base,
> > + .vhost_set_vring_kick = vhost_set_vring_kick,
> > + .vhost_set_vring_call = vhost_set_vring_call,
> > + .vhost_set_features = vhost_set_features,
> > + .vhost_get_features = vhost_kernel_get_features,
> > + .vhost_set_owner = vhost_set_owner,
> > + .vhost_reset_owner = vhost_reset_owner,
> > };
> >
> > int vhost_set_backend_type(struct vhost_dev *dev, VhostBackendType
> > backend_type)
> > diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> > index de87562..d5b7951 100644
> > --- a/hw/virtio/vhost-user.c
> > +++ b/hw/virtio/vhost-user.c
> > @@ -176,6 +176,7 @@ fail:
> > return -1;
> > }
> >
> > +/* most non-init callers ignore the error */
> > static int vhost_user_write(struct vhost_dev *dev, VhostUserMsg *msg,
> > int *fds, int fd_num)
> > {
> > @@ -190,148 +191,280 @@ static int vhost_user_write(struct vhost_dev *dev,
> > VhostUserMsg *msg,
> > 0 : -1;
> > }
> >
> > -static int vhost_user_call(struct vhost_dev *dev, unsigned long int
> > request,
> > - void *arg)
> > +static int vhost_net_set_backend(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + error_report("vhost-user trying to send unhandled ioctl");
> > + return -1;
> > +}
> > +
> > +static int vhost_scsi_set_endpoint(struct vhost_dev *dev,
> > + struct vhost_scsi_target *target)
> > +{
> > + error_report("vhost-user trying to send unhandled ioctl");
> > + return -1;
> > +}
> > +
> > +static int vhost_scsi_clear_endpoint(struct vhost_dev *dev,
> > + struct vhost_scsi_target *target)
> > +{
> > + error_report("vhost-user trying to send unhandled ioctl");
> > + return -1;
> > +}
> > +
> > +static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> > +{
> > + error_report("vhost-user trying to send unhandled ioctl");
> > + return -1;
> > +}
> > +
> > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_LOG_BASE,
> > + .flags = VHOST_USER_VERSION,
> > + .u64 = base,
> > + .size = sizeof(m.u64),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_set_mem_table(struct vhost_dev *dev,
> > + struct vhost_memory *mem)
> > {
> > - VhostUserMsg msg;
> > - VhostUserRequest msg_request;
> > - struct vhost_vring_file *file = 0;
> > - int need_reply = 0;
> > int fds[VHOST_MEMORY_MAX_NREGIONS];
> > int i, fd;
> > size_t fd_num = 0;
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_MEM_TABLE,
> > + .flags = VHOST_USER_VERSION,
> > + };
> >
> > - assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
> > + for (i = 0; i < dev->mem->nregions; ++i) {
> > + struct vhost_memory_region *reg = dev->mem->regions + i;
> > + ram_addr_t ram_addr;
> > +
> > + assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> > + qemu_ram_addr_from_host((void *)(uintptr_t)reg->userspace_addr,
> > + &ram_addr);
> > + fd = qemu_get_ram_fd(ram_addr);
> > + if (fd > 0) {
> > + msg.memory.regions[fd_num].userspace_addr =
> > reg->userspace_addr;
> > + msg.memory.regions[fd_num].memory_size = reg->memory_size;
> > + msg.memory.regions[fd_num].guest_phys_addr =
> > reg->guest_phys_addr;
> > + msg.memory.regions[fd_num].mmap_offset = reg->userspace_addr -
> > + (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> > + assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> > + fds[fd_num++] = fd;
> > + }
> > + }
> >
> > - msg_request = vhost_user_request_translate(request);
> > - msg.request = msg_request;
> > - msg.flags = VHOST_USER_VERSION;
> > - msg.size = 0;
> > + msg.memory.nregions = fd_num;
> >
> > - switch (msg_request) {
> > - case VHOST_USER_GET_FEATURES:
> > - need_reply = 1;
> > - break;
> > -
> > - case VHOST_USER_SET_FEATURES:
> > - case VHOST_USER_SET_LOG_BASE:
> > - msg.u64 = *((__u64 *) arg);
> > - msg.size = sizeof(m.u64);
> > - break;
> > -
> > - case VHOST_USER_SET_OWNER:
> > - case VHOST_USER_RESET_OWNER:
> > - break;
> > -
> > - case VHOST_USER_SET_MEM_TABLE:
> > - for (i = 0; i < dev->mem->nregions; ++i) {
> > - struct vhost_memory_region *reg = dev->mem->regions + i;
> > - ram_addr_t ram_addr;
> > -
> > - assert((uintptr_t)reg->userspace_addr == reg->userspace_addr);
> > - qemu_ram_addr_from_host((void
> > *)(uintptr_t)reg->userspace_addr, &ram_addr);
> > - fd = qemu_get_ram_fd(ram_addr);
> > - if (fd > 0) {
> > - msg.memory.regions[fd_num].userspace_addr =
> > reg->userspace_addr;
> > - msg.memory.regions[fd_num].memory_size =
> > reg->memory_size;
> > - msg.memory.regions[fd_num].guest_phys_addr =
> > reg->guest_phys_addr;
> > - msg.memory.regions[fd_num].mmap_offset =
> > reg->userspace_addr -
> > - (uintptr_t) qemu_get_ram_block_host_ptr(ram_addr);
> > - assert(fd_num < VHOST_MEMORY_MAX_NREGIONS);
> > - fds[fd_num++] = fd;
> > - }
> > - }
> > + if (!fd_num) {
> > + error_report("Failed initializing vhost-user memory map, "
> > + "consider using -object memory-backend-file
> > share=on");
> > + return -1;
> > + }
> >
> > - msg.memory.nregions = fd_num;
> > + msg.size = sizeof(m.memory.nregions);
> > + msg.size += sizeof(m.memory.padding);
> > + msg.size += fd_num * sizeof(VhostUserMemoryRegion);
> >
> > - if (!fd_num) {
> > - error_report("Failed initializing vhost-user memory map, "
> > - "consider using -object memory-backend-file
> > share=on");
> > - return -1;
> > - }
> > + vhost_user_write(dev, &msg, fds, fd_num);
> >
> > - msg.size = sizeof(m.memory.nregions);
> > - msg.size += sizeof(m.memory.padding);
> > - msg.size += fd_num * sizeof(VhostUserMemoryRegion);
> > -
> > - break;
> > -
> > - case VHOST_USER_SET_LOG_FD:
> > - fds[fd_num++] = *((int *) arg);
> > - break;
> > -
> > - case VHOST_USER_SET_VRING_NUM:
> > - case VHOST_USER_SET_VRING_BASE:
> > - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> > - msg.size = sizeof(m.state);
> > - break;
> > -
> > - case VHOST_USER_GET_VRING_BASE:
> > - memcpy(&msg.state, arg, sizeof(struct vhost_vring_state));
> > - msg.size = sizeof(m.state);
> > - need_reply = 1;
> > - break;
> > -
> > - case VHOST_USER_SET_VRING_ADDR:
> > - memcpy(&msg.addr, arg, sizeof(struct vhost_vring_addr));
> > - msg.size = sizeof(m.addr);
> > - break;
> > -
> > - case VHOST_USER_SET_VRING_KICK:
> > - case VHOST_USER_SET_VRING_CALL:
> > - case VHOST_USER_SET_VRING_ERR:
> > - file = arg;
> > - msg.u64 = file->index & VHOST_USER_VRING_IDX_MASK;
> > - msg.size = sizeof(m.u64);
> > - if (ioeventfd_enabled() && file->fd > 0) {
> > - fds[fd_num++] = file->fd;
> > - } else {
> > - msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> > - }
> > - break;
> > - default:
> > - error_report("vhost-user trying to send unhandled ioctl");
> > + return 0;
> > +}
> > +
> > +static int vhost_set_vring_addr(struct vhost_dev *dev,
> > + struct vhost_vring_addr *addr)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_VRING_ADDR,
> > + .flags = VHOST_USER_VERSION,
> > + .addr = *addr,
> > + .size = sizeof(*addr),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_set_vring_endian(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + error_report("vhost-user trying to send unhandled ioctl");
> > + return -1;
> > +}
> > +
> > +static int vhost_set_vring_num(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_VRING_NUM,
> > + .flags = VHOST_USER_VERSION,
> > + .state = *ring,
> > + .size = sizeof(*ring),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_set_vring_base(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_VRING_BASE,
> > + .flags = VHOST_USER_VERSION,
> > + .state = *ring,
> > + .size = sizeof(*ring),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_get_vring_base(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_GET_VRING_BASE,
> > + .flags = VHOST_USER_VERSION,
> > + .state = *ring,
> > + .size = sizeof(*ring),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + if (vhost_user_read(dev, &msg) < 0) {
> > + return 0;
> > + }
> > +
> > + if (msg.request != VHOST_USER_GET_VRING_BASE) {
> > + error_report("Received unexpected msg type. Expected %d received
> > %d",
> > + VHOST_USER_GET_FEATURES, msg.request);
> > return -1;
> > - break;
> > }
> >
> > - if (vhost_user_write(dev, &msg, fds, fd_num) < 0) {
> > - return 0;
> > + if (msg.size != sizeof(m.state)) {
> > + error_report("Received bad msg size.");
> > + return -1;
> > }
> >
> > - if (need_reply) {
> > - if (vhost_user_read(dev, &msg) < 0) {
> > - return 0;
> > - }
> > + *ring = msg.state;
> >
> > - if (msg_request != msg.request) {
> > - error_report("Received unexpected msg type."
> > - " Expected %d received %d", msg_request, msg.request);
> > - return -1;
> > - }
> > + return 0;
> > +}
> >
> > - switch (msg_request) {
> > - case VHOST_USER_GET_FEATURES:
> > - if (msg.size != sizeof(m.u64)) {
> > - error_report("Received bad msg size.");
> > - return -1;
> > - }
> > - *((__u64 *) arg) = msg.u64;
> > - break;
> > - case VHOST_USER_GET_VRING_BASE:
> > - if (msg.size != sizeof(m.state)) {
> > - error_report("Received bad msg size.");
> > - return -1;
> > - }
> > - memcpy(arg, &msg.state, sizeof(struct vhost_vring_state));
> > - break;
> > - default:
> > - error_report("Received unexpected msg type.");
> > - return -1;
> > - break;
> > - }
> > +static int vhost_set_vring_file(struct vhost_dev *dev,
> > + VhostUserRequest request,
> > + struct vhost_vring_file *file)
> > +{
> > + int fds[VHOST_MEMORY_MAX_NREGIONS];
> > + size_t fd_num = 0;
> > + VhostUserMsg msg = {
> > + .request = request,
> > + .flags = VHOST_USER_VERSION,
> > + .u64 = file->index & VHOST_USER_VRING_IDX_MASK,
> > + .size = sizeof(m.u64),
> > + };
> > +
> > + if (ioeventfd_enabled() && file->fd > 0) {
> > + fds[fd_num++] = file->fd;
> > + } else {
> > + msg.u64 |= VHOST_USER_VRING_NOFD_MASK;
> > }
> >
> > + vhost_user_write(dev, &msg, fds, fd_num);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_set_vring_kick(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_KICK, file);
> > +}
> > +
> > +static int vhost_set_vring_call(struct vhost_dev *dev,
> > + struct vhost_vring_file *file)
> > +{
> > + return vhost_set_vring_file(dev, VHOST_USER_SET_VRING_CALL, file);
> > +}
> > +
> > +static int vhost_set_features(struct vhost_dev *dev,
> > + uint64_t features)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_FEATURES,
> > + .flags = VHOST_USER_VERSION,
> > + .u64 = features,
> > + .size = sizeof(m.u64),
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_user_get_features(struct vhost_dev *dev,
> > + uint64_t *features)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_GET_FEATURES,
> > + .flags = VHOST_USER_VERSION,
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + if (vhost_user_read(dev, &msg) < 0) {
> > + return 0;
> > + }
> > +
> > + if (msg.request != VHOST_USER_GET_FEATURES) {
> > + error_report("Received unexpected msg type. Expected %d received
> > %d",
> > + VHOST_USER_GET_FEATURES, msg.request);
> > + return -1;
> > + }
> > +
> > + if (msg.size != sizeof(m.u64)) {
> > + error_report("Received bad msg size.");
> > + return -1;
> > + }
> > +
> > + *features = msg.u64;
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_set_owner(struct vhost_dev *dev)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_SET_OWNER,
> > + .flags = VHOST_USER_VERSION,
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > + return 0;
> > +}
> > +
> > +static int vhost_reset_owner(struct vhost_dev *dev)
> > +{
> > + VhostUserMsg msg = {
> > + .request = VHOST_USER_RESET_OWNER,
> > + .flags = VHOST_USER_VERSION,
> > + };
> > +
> > + vhost_user_write(dev, &msg, NULL, 0);
> > +
> > return 0;
> > }
> >
> > @@ -402,7 +535,24 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
> >
> > const VhostOps user_ops = {
> > .backend_type = VHOST_BACKEND_TYPE_USER,
> > - .vhost_call = vhost_user_call,
> > .vhost_backend_init = vhost_user_init,
> > - .vhost_backend_cleanup = vhost_user_cleanup
> > - };
> > + .vhost_backend_cleanup = vhost_user_cleanup,
> > +
> > + .vhost_net_set_backend = vhost_net_set_backend,
> > + .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> > + .vhost_scsi_clear_endpoint = vhost_scsi_clear_endpoint,
> > + .vhost_scsi_get_abi_version = vhost_scsi_get_abi_version,
> > + .vhost_set_log_base = vhost_set_log_base,
> > + .vhost_set_mem_table = vhost_set_mem_table,
> > + .vhost_set_vring_addr = vhost_set_vring_addr,
> > + .vhost_set_vring_endian = vhost_set_vring_endian,
> > + .vhost_set_vring_num = vhost_set_vring_num,
> > + .vhost_set_vring_base = vhost_set_vring_base,
> > + .vhost_get_vring_base = vhost_get_vring_base,
> > + .vhost_set_vring_kick = vhost_set_vring_kick,
> > + .vhost_set_vring_call = vhost_set_vring_call,
> > + .vhost_set_features = vhost_set_features,
> > + .vhost_get_features = vhost_user_get_features,
> > + .vhost_set_owner = vhost_set_owner,
> > + .vhost_reset_owner = vhost_reset_owner,
> > +};
> > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > index 81209ba..83ef164 100644
> > --- a/hw/virtio/vhost.c
> > +++ b/hw/virtio/vhost.c
> > @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct
> > vhost_dev* dev, uint64_t size)
> >
> > /* inform backend of log switching, this must be done before
> > releasing the current log, to ensure no logging is lost */
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_LOG_BASE, &log_base);
> > + r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> > assert(r >= 0);
> > vhost_log_put(dev, true);
> > dev->log = log;
> > @@ -525,7 +525,7 @@ static void vhost_commit(MemoryListener *listener)
> > }
> >
> > if (!dev->log_enabled) {
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE,
> > dev->mem);
> > + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> > assert(r >= 0);
> > dev->memory_changed = false;
> > return;
> > @@ -538,7 +538,7 @@ static void vhost_commit(MemoryListener *listener)
> > if (dev->log_size < log_size) {
> > vhost_dev_log_resize(dev, log_size + VHOST_LOG_BUFFER);
> > }
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_MEM_TABLE, dev->mem);
> > + r = dev->vhost_ops->vhost_set_mem_table(dev, dev->mem);
> > assert(r >= 0);
> > /* To log less, can only decrease log size after table update. */
> > if (dev->log_size > log_size + VHOST_LOG_BUFFER) {
> > @@ -606,7 +606,7 @@ static int vhost_virtqueue_set_addr(struct vhost_dev
> > *dev,
> > .log_guest_addr = vq->used_phys,
> > .flags = enable_log ? (1 << VHOST_VRING_F_LOG) : 0,
> > };
> > - int r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ADDR, &addr);
> > + int r = dev->vhost_ops->vhost_set_vring_addr(dev, &addr);
> > if (r < 0) {
> > return -errno;
> > }
> > @@ -620,7 +620,7 @@ static int vhost_dev_set_features(struct vhost_dev
> > *dev, bool enable_log)
> > if (enable_log) {
> > features |= 0x1ULL << VHOST_F_LOG_ALL;
> > }
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_FEATURES, &features);
> > + r = dev->vhost_ops->vhost_set_features(dev, features);
> > return r < 0 ? -errno : 0;
> > }
> >
> > @@ -725,7 +725,7 @@ static int
> > vhost_virtqueue_set_vring_endian_legacy(struct vhost_dev *dev,
> > .num = is_big_endian
> > };
> >
> > - if (!dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_ENDIAN, &s)) {
> > + if (!dev->vhost_ops->vhost_set_vring_endian(dev, &s)) {
> > return 0;
> > }
> >
> > @@ -756,13 +756,13 @@ static int vhost_virtqueue_start(struct vhost_dev
> > *dev,
> > assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
> >
> > vq->num = state.num = virtio_queue_get_num(vdev, idx);
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_NUM, &state);
> > + r = dev->vhost_ops->vhost_set_vring_num(dev, &state);
> > if (r) {
> > return -errno;
> > }
> >
> > state.num = virtio_queue_get_last_avail_idx(vdev, idx);
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_BASE, &state);
> > + r = dev->vhost_ops->vhost_set_vring_base(dev, &state);
> > if (r) {
> > return -errno;
> > }
> > @@ -814,7 +814,7 @@ static int vhost_virtqueue_start(struct vhost_dev *dev,
> > }
> >
> > file.fd = event_notifier_get_fd(virtio_queue_get_host_notifier(vvq));
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_KICK, &file);
> > + r = dev->vhost_ops->vhost_set_vring_kick(dev, &file);
> > if (r) {
> > r = -errno;
> > goto fail_kick;
> > @@ -853,7 +853,7 @@ static void vhost_virtqueue_stop(struct vhost_dev *dev,
> > };
> > int r;
> > assert(idx >= dev->vq_index && idx < dev->vq_index + dev->nvqs);
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_GET_VRING_BASE, &state);
> > + r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
> > if (r < 0) {
> > fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
> > fflush(stderr);
> > @@ -909,7 +909,7 @@ static int vhost_virtqueue_init(struct vhost_dev *dev,
> > }
> >
> > file.fd = event_notifier_get_fd(&vq->masked_notifier);
> > - r = dev->vhost_ops->vhost_call(dev, VHOST_SET_VRING_CALL, &file);
> > + r = dev->vhost_ops->vhost_set_vring_call(dev, &file);
> > if (r) {
> > r = -errno;
> > goto fail_call;
> > @@ -941,12 +941,12 @@ int vhost_dev_init(struct vhost_dev *hdev, void
> > *opaque,
> > return -errno;
> > }
> >
> > - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_OWNER, NULL);
> > + r = hdev->vhost_ops->vhost_set_owner(hdev);
> > if (r < 0) {
> > goto fail;
> > }
> >
> > - r = hdev->vhost_ops->vhost_call(hdev, VHOST_GET_FEATURES, &features);
> > + r = hdev->vhost_ops->vhost_get_features(hdev, &features);
> > if (r < 0) {
> > goto fail;
> > }
> > @@ -1102,7 +1102,7 @@ void vhost_virtqueue_mask(struct vhost_dev *hdev,
> > VirtIODevice *vdev, int n,
> > } else {
> > file.fd =
> > event_notifier_get_fd(virtio_queue_get_guest_notifier(vvq));
> > }
> > - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_VRING_CALL, &file);
> > + r = hdev->vhost_ops->vhost_set_vring_call(hdev, &file);
> > assert(r >= 0);
> > }
> >
> > @@ -1144,7 +1144,7 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > VirtIODevice *vdev)
> > if (r < 0) {
> > goto fail_features;
> > }
> > - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_MEM_TABLE, hdev->mem);
> > + r = hdev->vhost_ops->vhost_set_mem_table(hdev, hdev->mem);
> > if (r < 0) {
> > r = -errno;
> > goto fail_mem;
> > @@ -1166,8 +1166,8 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > VirtIODevice *vdev)
> > hdev->log_size = vhost_get_log_size(hdev);
> > hdev->log = vhost_log_get(hdev->log_size, share);
> > log_base = (uintptr_t)hdev->log->log;
> > - r = hdev->vhost_ops->vhost_call(hdev, VHOST_SET_LOG_BASE,
> > - hdev->log_size ? &log_base :
> > NULL);
> > + r = hdev->vhost_ops->vhost_set_log_base(hdev,
> > + hdev->log_size ? log_base
> > : 0);
> > if (r < 0) {
> > r = -errno;
> > goto fail_log;
> > diff --git a/include/hw/virtio/vhost-backend.h
> > b/include/hw/virtio/vhost-backend.h
> > index e472f29..42cfb87 100644
> > --- a/include/hw/virtio/vhost-backend.h
> > +++ b/include/hw/virtio/vhost-backend.h
> > @@ -19,17 +19,70 @@ typedef enum VhostBackendType {
> > } VhostBackendType;
> >
> > struct vhost_dev;
> > +struct vhost_memory;
> > +struct vhost_vring_file;
> > +struct vhost_vring_state;
> > +struct vhost_vring_addr;
> > +struct vhost_scsi_target;
> >
> > -typedef int (*vhost_call)(struct vhost_dev *dev, unsigned long int
> > request,
> > - void *arg);
> > typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
> > typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
> >
> > +typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
> > + struct vhost_vring_file *file);
> > +typedef int (*vhost_scsi_set_endpoint_op)(struct vhost_dev *dev,
> > + struct vhost_scsi_target
> > *target);
> > +typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
> > + struct vhost_scsi_target
> > *target);
> > +typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> > + int *version);
> > +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t
> > base);
> > +typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> > + struct vhost_memory *mem);
> > +typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> > + struct vhost_vring_addr *addr);
> > +typedef int (*vhost_set_vring_endian_op)(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring);
> > +typedef int (*vhost_set_vring_num_op)(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring);
> > +typedef int (*vhost_set_vring_base_op)(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring);
> > +typedef int (*vhost_get_vring_base_op)(struct vhost_dev *dev,
> > + struct vhost_vring_state *ring);
> > +typedef int (*vhost_set_vring_kick_op)(struct vhost_dev *dev,
> > + struct vhost_vring_file *file);
> > +typedef int (*vhost_set_vring_call_op)(struct vhost_dev *dev,
> > + struct vhost_vring_file *file);
> > +typedef int (*vhost_set_features_op)(struct vhost_dev *dev,
> > + uint64_t features);
> > +typedef int (*vhost_get_features_op)(struct vhost_dev *dev,
> > + uint64_t *features);
> > +typedef int (*vhost_set_owner_op)(struct vhost_dev *dev);
> > +typedef int (*vhost_reset_owner_op)(struct vhost_dev *dev);
> > +
> > typedef struct VhostOps {
> > VhostBackendType backend_type;
> > - vhost_call vhost_call;
> > +
> > vhost_backend_init vhost_backend_init;
> > vhost_backend_cleanup vhost_backend_cleanup;
> > +
> > + vhost_net_set_backend_op vhost_net_set_backend;
> > + vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
> > + vhost_scsi_clear_endpoint_op vhost_scsi_clear_endpoint;
> > + vhost_scsi_get_abi_version_op vhost_scsi_get_abi_version;
> > + vhost_set_log_base_op vhost_set_log_base;
> > + vhost_set_mem_table_op vhost_set_mem_table;
> > + vhost_set_vring_addr_op vhost_set_vring_addr;
> > + vhost_set_vring_endian_op vhost_set_vring_endian;
> > + vhost_set_vring_num_op vhost_set_vring_num;
> > + vhost_set_vring_base_op vhost_set_vring_base;
> > + vhost_get_vring_base_op vhost_get_vring_base;
> > + vhost_set_vring_kick_op vhost_set_vring_kick;
> > + vhost_set_vring_call_op vhost_set_vring_call;
> > + vhost_set_features_op vhost_set_features;
> > + vhost_get_features_op vhost_get_features;
> > + vhost_set_owner_op vhost_set_owner;
> > + vhost_reset_owner_op vhost_reset_owner;
> > } VhostOps;
> >
> > extern const VhostOps user_ops;
> > --
> > 2.4.3
>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [Qemu-devel] [PATCH v4 10/22] vhost-user: remove vhost_user_request_translate()
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (8 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 09/22] vhost: use a function for each call marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base marcandre.lureau
` (11 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
The translation is no longer needed.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/virtio/vhost-user.c | 36 ------------------------------------
1 file changed, 36 deletions(-)
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index d5b7951..d3334f5 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -94,42 +94,6 @@ static bool ioeventfd_enabled(void)
return kvm_enabled() && kvm_eventfds_enabled();
}
-static VhostUserRequest vhost_user_request_translate(unsigned long int request)
-{
- switch (request) {
- case VHOST_GET_FEATURES:
- return VHOST_USER_GET_FEATURES;
- case VHOST_SET_FEATURES:
- return VHOST_USER_SET_FEATURES;
- case VHOST_SET_OWNER:
- return VHOST_USER_SET_OWNER;
- case VHOST_RESET_OWNER:
- return VHOST_USER_RESET_OWNER;
- case VHOST_SET_MEM_TABLE:
- return VHOST_USER_SET_MEM_TABLE;
- case VHOST_SET_LOG_BASE:
- return VHOST_USER_SET_LOG_BASE;
- case VHOST_SET_LOG_FD:
- return VHOST_USER_SET_LOG_FD;
- case VHOST_SET_VRING_NUM:
- return VHOST_USER_SET_VRING_NUM;
- case VHOST_SET_VRING_ADDR:
- return VHOST_USER_SET_VRING_ADDR;
- case VHOST_SET_VRING_BASE:
- return VHOST_USER_SET_VRING_BASE;
- case VHOST_GET_VRING_BASE:
- return VHOST_USER_GET_VRING_BASE;
- case VHOST_SET_VRING_KICK:
- return VHOST_USER_SET_VRING_KICK;
- case VHOST_SET_VRING_CALL:
- return VHOST_USER_SET_VRING_CALL;
- case VHOST_SET_VRING_ERR:
- return VHOST_USER_SET_VRING_ERR;
- default:
- return VHOST_USER_MAX;
- }
-}
-
static int vhost_user_read(struct vhost_dev *dev, VhostUserMsg *msg)
{
CharDriverState *chr = dev->opaque;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (9 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 10/22] vhost-user: remove vhost_user_request_translate() marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-21 8:49 ` Michael S. Tsirkin
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend marcandre.lureau
` (10 subsequent siblings)
21 siblings, 1 reply; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Send the shm for the dirty pages logging if the backend supports
VHOST_USER_PROTOCOL_F_LOG_SHMFD.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/virtio/vhost-backend.c | 3 ++-
hw/virtio/vhost-user.c | 17 ++++++++++++++---
hw/virtio/vhost.c | 5 +++--
include/hw/virtio/vhost-backend.h | 4 +++-
4 files changed, 22 insertions(+), 7 deletions(-)
diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
index bf2d1d4..3f2d6ea 100644
--- a/hw/virtio/vhost-backend.c
+++ b/hw/virtio/vhost-backend.c
@@ -66,7 +66,8 @@ static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
}
-static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
+static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
+ struct vhost_log *log)
{
return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
}
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index d3334f5..3cb5559 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -26,7 +26,9 @@
#define VHOST_MEMORY_MAX_NREGIONS 8
#define VHOST_USER_F_PROTOCOL_FEATURES 30
-#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x0ULL
+
+#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x1ULL
+#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
@@ -182,8 +184,11 @@ static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
return -1;
}
-static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
+static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
+ struct vhost_log *log)
{
+ int fds[VHOST_MEMORY_MAX_NREGIONS];
+ size_t fd_num = 0;
VhostUserMsg msg = {
.request = VHOST_USER_SET_LOG_BASE,
.flags = VHOST_USER_VERSION,
@@ -191,7 +196,13 @@ static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
.size = sizeof(m.u64),
};
- vhost_user_write(dev, &msg, NULL, 0);
+ if (virtio_has_feature(dev->protocol_features,
+ VHOST_USER_PROTOCOL_F_LOG_SHMFD) &&
+ log->fd != -1) {
+ fds[fd_num++] = log->fd;
+ }
+
+ vhost_user_write(dev, &msg, fds, fd_num);
return 0;
}
diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
index 83ef164..0fa7b69 100644
--- a/hw/virtio/vhost.c
+++ b/hw/virtio/vhost.c
@@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
/* inform backend of log switching, this must be done before
releasing the current log, to ensure no logging is lost */
- r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
+ r = dev->vhost_ops->vhost_set_log_base(dev, log_base, log);
assert(r >= 0);
vhost_log_put(dev, true);
dev->log = log;
@@ -1167,7 +1167,8 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
hdev->log = vhost_log_get(hdev->log_size, share);
log_base = (uintptr_t)hdev->log->log;
r = hdev->vhost_ops->vhost_set_log_base(hdev,
- hdev->log_size ? log_base : 0);
+ hdev->log_size ? log_base : 0,
+ hdev->log);
if (r < 0) {
r = -errno;
goto fail_log;
diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
index 42cfb87..a87f0b3 100644
--- a/include/hw/virtio/vhost-backend.h
+++ b/include/hw/virtio/vhost-backend.h
@@ -20,6 +20,7 @@ typedef enum VhostBackendType {
struct vhost_dev;
struct vhost_memory;
+struct vhost_log;
struct vhost_vring_file;
struct vhost_vring_state;
struct vhost_vring_addr;
@@ -36,7 +37,8 @@ typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
struct vhost_scsi_target *target);
typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
int *version);
-typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base);
+typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base,
+ struct vhost_log *log);
typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
struct vhost_memory *mem);
typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base marcandre.lureau
@ 2015-09-21 8:49 ` Michael S. Tsirkin
2015-09-21 14:05 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 8:49 UTC (permalink / raw)
To: marcandre.lureau
Cc: haifeng.lin, thibaut.collet, jasowang, qemu-devel, pbonzini
On Sat, Sep 19, 2015 at 12:12:02PM +0200, marcandre.lureau@redhat.com wrote:
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Send the shm for the dirty pages logging if the backend supports
> VHOST_USER_PROTOCOL_F_LOG_SHMFD.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> ---
> hw/virtio/vhost-backend.c | 3 ++-
> hw/virtio/vhost-user.c | 17 ++++++++++++++---
> hw/virtio/vhost.c | 5 +++--
> include/hw/virtio/vhost-backend.h | 4 +++-
> 4 files changed, 22 insertions(+), 7 deletions(-)
>
> diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> index bf2d1d4..3f2d6ea 100644
> --- a/hw/virtio/vhost-backend.c
> +++ b/hw/virtio/vhost-backend.c
> @@ -66,7 +66,8 @@ static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> }
>
> -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> + struct vhost_log *log)
> {
> return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> }
> diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> index d3334f5..3cb5559 100644
> --- a/hw/virtio/vhost-user.c
> +++ b/hw/virtio/vhost-user.c
> @@ -26,7 +26,9 @@
> #define VHOST_MEMORY_MAX_NREGIONS 8
>
> #define VHOST_USER_F_PROTOCOL_FEATURES 30
> -#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x0ULL
> +
> +#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x1ULL
> +#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
>
> typedef enum VhostUserRequest {
> VHOST_USER_NONE = 0,
> @@ -182,8 +184,11 @@ static int vhost_scsi_get_abi_version(struct vhost_dev *dev, int *version)
> return -1;
> }
>
> -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> + struct vhost_log *log)
> {
> + int fds[VHOST_MEMORY_MAX_NREGIONS];
> + size_t fd_num = 0;
> VhostUserMsg msg = {
> .request = VHOST_USER_SET_LOG_BASE,
> .flags = VHOST_USER_VERSION,
> @@ -191,7 +196,13 @@ static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> .size = sizeof(m.u64),
> };
>
> - vhost_user_write(dev, &msg, NULL, 0);
> + if (virtio_has_feature(dev->protocol_features,
> + VHOST_USER_PROTOCOL_F_LOG_SHMFD) &&
> + log->fd != -1) {
> + fds[fd_num++] = log->fd;
> + }
> +
> + vhost_user_write(dev, &msg, fds, fd_num);
>
> return 0;
> }
Doesn't this one have to get a response?
Otherwise the other side might still be using the old
buffer after we've updated this one.
Probably need a protocol feature, but I guess we can reuse
VHOST_USER_PROTOCOL_F_LOG_SHMFD - IIUC logging doesn't
work without this anyway ...
> diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> index 83ef164..0fa7b69 100644
> --- a/hw/virtio/vhost.c
> +++ b/hw/virtio/vhost.c
> @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
>
> /* inform backend of log switching, this must be done before
> releasing the current log, to ensure no logging is lost */
> - r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> + r = dev->vhost_ops->vhost_set_log_base(dev, log_base, log);
> assert(r >= 0);
> vhost_log_put(dev, true);
> dev->log = log;
> @@ -1167,7 +1167,8 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
> hdev->log = vhost_log_get(hdev->log_size, share);
> log_base = (uintptr_t)hdev->log->log;
> r = hdev->vhost_ops->vhost_set_log_base(hdev,
> - hdev->log_size ? log_base : 0);
> + hdev->log_size ? log_base : 0,
> + hdev->log);
> if (r < 0) {
> r = -errno;
> goto fail_log;
> diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
> index 42cfb87..a87f0b3 100644
> --- a/include/hw/virtio/vhost-backend.h
> +++ b/include/hw/virtio/vhost-backend.h
> @@ -20,6 +20,7 @@ typedef enum VhostBackendType {
>
> struct vhost_dev;
> struct vhost_memory;
> +struct vhost_log;
> struct vhost_vring_file;
> struct vhost_vring_state;
> struct vhost_vring_addr;
> @@ -36,7 +37,8 @@ typedef int (*vhost_scsi_clear_endpoint_op)(struct vhost_dev *dev,
> struct vhost_scsi_target *target);
> typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> int *version);
> -typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base);
> +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base,
> + struct vhost_log *log);
> typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> struct vhost_memory *mem);
> typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> --
> 2.4.3
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base
2015-09-21 8:49 ` Michael S. Tsirkin
@ 2015-09-21 14:05 ` Marc-André Lureau
2015-09-21 19:30 ` Michael S. Tsirkin
0 siblings, 1 reply; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-21 14:05 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
----- Original Message -----
> On Sat, Sep 19, 2015 at 12:12:02PM +0200, marcandre.lureau@redhat.com wrote:
> > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> > Send the shm for the dirty pages logging if the backend supports
> > VHOST_USER_PROTOCOL_F_LOG_SHMFD.
> >
> > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> > ---
> > hw/virtio/vhost-backend.c | 3 ++-
> > hw/virtio/vhost-user.c | 17 ++++++++++++++---
> > hw/virtio/vhost.c | 5 +++--
> > include/hw/virtio/vhost-backend.h | 4 +++-
> > 4 files changed, 22 insertions(+), 7 deletions(-)
> >
> > diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> > index bf2d1d4..3f2d6ea 100644
> > --- a/hw/virtio/vhost-backend.c
> > +++ b/hw/virtio/vhost-backend.c
> > @@ -66,7 +66,8 @@ static int vhost_scsi_get_abi_version(struct vhost_dev
> > *dev, int *version)
> > return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> > }
> >
> > -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> > + struct vhost_log *log)
> > {
> > return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> > }
> > diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> > index d3334f5..3cb5559 100644
> > --- a/hw/virtio/vhost-user.c
> > +++ b/hw/virtio/vhost-user.c
> > @@ -26,7 +26,9 @@
> > #define VHOST_MEMORY_MAX_NREGIONS 8
> >
> > #define VHOST_USER_F_PROTOCOL_FEATURES 30
> > -#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x0ULL
> > +
> > +#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x1ULL
> > +#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
> >
> > typedef enum VhostUserRequest {
> > VHOST_USER_NONE = 0,
> > @@ -182,8 +184,11 @@ static int vhost_scsi_get_abi_version(struct vhost_dev
> > *dev, int *version)
> > return -1;
> > }
> >
> > -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> > + struct vhost_log *log)
> > {
> > + int fds[VHOST_MEMORY_MAX_NREGIONS];
> > + size_t fd_num = 0;
> > VhostUserMsg msg = {
> > .request = VHOST_USER_SET_LOG_BASE,
> > .flags = VHOST_USER_VERSION,
> > @@ -191,7 +196,13 @@ static int vhost_set_log_base(struct vhost_dev *dev,
> > uint64_t base)
> > .size = sizeof(m.u64),
> > };
> >
> > - vhost_user_write(dev, &msg, NULL, 0);
> > + if (virtio_has_feature(dev->protocol_features,
> > + VHOST_USER_PROTOCOL_F_LOG_SHMFD) &&
> > + log->fd != -1) {
> > + fds[fd_num++] = log->fd;
> > + }
> > +
> > + vhost_user_write(dev, &msg, fds, fd_num);
> >
> > return 0;
> > }
>
> Doesn't this one have to get a response?
> Otherwise the other side might still be using the old
> buffer after we've updated this one.
That make sense, though I wonder about all other SET commands in the protocol then. Isn't there other commands that may change the fd or memory region over time?
> Probably need a protocol feature, but I guess we can reuse
> VHOST_USER_PROTOCOL_F_LOG_SHMFD - IIUC logging doesn't
> work without this anyway ...
ok
>
>
> > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > index 83ef164..0fa7b69 100644
> > --- a/hw/virtio/vhost.c
> > +++ b/hw/virtio/vhost.c
> > @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct
> > vhost_dev* dev, uint64_t size)
> >
> > /* inform backend of log switching, this must be done before
> > releasing the current log, to ensure no logging is lost */
> > - r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> > + r = dev->vhost_ops->vhost_set_log_base(dev, log_base, log);
> > assert(r >= 0);
> > vhost_log_put(dev, true);
> > dev->log = log;
> > @@ -1167,7 +1167,8 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > VirtIODevice *vdev)
> > hdev->log = vhost_log_get(hdev->log_size, share);
> > log_base = (uintptr_t)hdev->log->log;
> > r = hdev->vhost_ops->vhost_set_log_base(hdev,
> > - hdev->log_size ? log_base
> > : 0);
> > + hdev->log_size ? log_base
> > : 0,
> > + hdev->log);
> > if (r < 0) {
> > r = -errno;
> > goto fail_log;
> > diff --git a/include/hw/virtio/vhost-backend.h
> > b/include/hw/virtio/vhost-backend.h
> > index 42cfb87..a87f0b3 100644
> > --- a/include/hw/virtio/vhost-backend.h
> > +++ b/include/hw/virtio/vhost-backend.h
> > @@ -20,6 +20,7 @@ typedef enum VhostBackendType {
> >
> > struct vhost_dev;
> > struct vhost_memory;
> > +struct vhost_log;
> > struct vhost_vring_file;
> > struct vhost_vring_state;
> > struct vhost_vring_addr;
> > @@ -36,7 +37,8 @@ typedef int (*vhost_scsi_clear_endpoint_op)(struct
> > vhost_dev *dev,
> > struct vhost_scsi_target
> > *target);
> > typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> > int *version);
> > -typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t
> > base);
> > +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base,
> > + struct vhost_log *log);
> > typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> > struct vhost_memory *mem);
> > typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> > --
> > 2.4.3
>
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base
2015-09-21 14:05 ` Marc-André Lureau
@ 2015-09-21 19:30 ` Michael S. Tsirkin
0 siblings, 0 replies; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 19:30 UTC (permalink / raw)
To: Marc-André Lureau
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
On Mon, Sep 21, 2015 at 10:05:22AM -0400, Marc-André Lureau wrote:
>
>
> ----- Original Message -----
> > On Sat, Sep 19, 2015 at 12:12:02PM +0200, marcandre.lureau@redhat.com wrote:
> > > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> > >
> > > Send the shm for the dirty pages logging if the backend supports
> > > VHOST_USER_PROTOCOL_F_LOG_SHMFD.
> > >
> > > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> > > ---
> > > hw/virtio/vhost-backend.c | 3 ++-
> > > hw/virtio/vhost-user.c | 17 ++++++++++++++---
> > > hw/virtio/vhost.c | 5 +++--
> > > include/hw/virtio/vhost-backend.h | 4 +++-
> > > 4 files changed, 22 insertions(+), 7 deletions(-)
> > >
> > > diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
> > > index bf2d1d4..3f2d6ea 100644
> > > --- a/hw/virtio/vhost-backend.c
> > > +++ b/hw/virtio/vhost-backend.c
> > > @@ -66,7 +66,8 @@ static int vhost_scsi_get_abi_version(struct vhost_dev
> > > *dev, int *version)
> > > return vhost_kernel_call(dev, VHOST_SCSI_GET_ABI_VERSION, version);
> > > }
> > >
> > > -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> > > + struct vhost_log *log)
> > > {
> > > return vhost_kernel_call(dev, VHOST_SET_LOG_BASE, &base);
> > > }
> > > diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> > > index d3334f5..3cb5559 100644
> > > --- a/hw/virtio/vhost-user.c
> > > +++ b/hw/virtio/vhost-user.c
> > > @@ -26,7 +26,9 @@
> > > #define VHOST_MEMORY_MAX_NREGIONS 8
> > >
> > > #define VHOST_USER_F_PROTOCOL_FEATURES 30
> > > -#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x0ULL
> > > +
> > > +#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x1ULL
> > > +#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
> > >
> > > typedef enum VhostUserRequest {
> > > VHOST_USER_NONE = 0,
> > > @@ -182,8 +184,11 @@ static int vhost_scsi_get_abi_version(struct vhost_dev
> > > *dev, int *version)
> > > return -1;
> > > }
> > >
> > > -static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base)
> > > +static int vhost_set_log_base(struct vhost_dev *dev, uint64_t base,
> > > + struct vhost_log *log)
> > > {
> > > + int fds[VHOST_MEMORY_MAX_NREGIONS];
> > > + size_t fd_num = 0;
> > > VhostUserMsg msg = {
> > > .request = VHOST_USER_SET_LOG_BASE,
> > > .flags = VHOST_USER_VERSION,
> > > @@ -191,7 +196,13 @@ static int vhost_set_log_base(struct vhost_dev *dev,
> > > uint64_t base)
> > > .size = sizeof(m.u64),
> > > };
> > >
> > > - vhost_user_write(dev, &msg, NULL, 0);
> > > + if (virtio_has_feature(dev->protocol_features,
> > > + VHOST_USER_PROTOCOL_F_LOG_SHMFD) &&
> > > + log->fd != -1) {
> > > + fds[fd_num++] = log->fd;
> > > + }
> > > +
> > > + vhost_user_write(dev, &msg, fds, fd_num);
> > >
> > > return 0;
> > > }
> >
> > Doesn't this one have to get a response?
> > Otherwise the other side might still be using the old
> > buffer after we've updated this one.
>
> That make sense, though I wonder about all other SET commands in the protocol then. Isn't there other commands that may change the fd or memory region over time?
I suspect most commands need to get a response but I think it's
best to fix this separately.
> > Probably need a protocol feature, but I guess we can reuse
> > VHOST_USER_PROTOCOL_F_LOG_SHMFD - IIUC logging doesn't
> > work without this anyway ...
>
> ok
>
> >
> >
> > > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > > index 83ef164..0fa7b69 100644
> > > --- a/hw/virtio/vhost.c
> > > +++ b/hw/virtio/vhost.c
> > > @@ -359,7 +359,7 @@ static inline void vhost_dev_log_resize(struct
> > > vhost_dev* dev, uint64_t size)
> > >
> > > /* inform backend of log switching, this must be done before
> > > releasing the current log, to ensure no logging is lost */
> > > - r = dev->vhost_ops->vhost_set_log_base(dev, log_base);
> > > + r = dev->vhost_ops->vhost_set_log_base(dev, log_base, log);
> > > assert(r >= 0);
> > > vhost_log_put(dev, true);
> > > dev->log = log;
> > > @@ -1167,7 +1167,8 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > > VirtIODevice *vdev)
> > > hdev->log = vhost_log_get(hdev->log_size, share);
> > > log_base = (uintptr_t)hdev->log->log;
> > > r = hdev->vhost_ops->vhost_set_log_base(hdev,
> > > - hdev->log_size ? log_base
> > > : 0);
> > > + hdev->log_size ? log_base
> > > : 0,
> > > + hdev->log);
> > > if (r < 0) {
> > > r = -errno;
> > > goto fail_log;
> > > diff --git a/include/hw/virtio/vhost-backend.h
> > > b/include/hw/virtio/vhost-backend.h
> > > index 42cfb87..a87f0b3 100644
> > > --- a/include/hw/virtio/vhost-backend.h
> > > +++ b/include/hw/virtio/vhost-backend.h
> > > @@ -20,6 +20,7 @@ typedef enum VhostBackendType {
> > >
> > > struct vhost_dev;
> > > struct vhost_memory;
> > > +struct vhost_log;
> > > struct vhost_vring_file;
> > > struct vhost_vring_state;
> > > struct vhost_vring_addr;
> > > @@ -36,7 +37,8 @@ typedef int (*vhost_scsi_clear_endpoint_op)(struct
> > > vhost_dev *dev,
> > > struct vhost_scsi_target
> > > *target);
> > > typedef int (*vhost_scsi_get_abi_version_op)(struct vhost_dev *dev,
> > > int *version);
> > > -typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t
> > > base);
> > > +typedef int (*vhost_set_log_base_op)(struct vhost_dev *dev, uint64_t base,
> > > + struct vhost_log *log);
> > > typedef int (*vhost_set_mem_table_op)(struct vhost_dev *dev,
> > > struct vhost_memory *mem);
> > > typedef int (*vhost_set_vring_addr_op)(struct vhost_dev *dev,
> > > --
> > > 2.4.3
> >
^ permalink raw reply [flat|nested] 41+ messages in thread
* [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (10 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 11/22] vhost-user: send log shm fd along with log_base marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-21 8:46 ` Michael S. Tsirkin
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 13/22] vhost-user: document migration log marcandre.lureau
` (9 subsequent siblings)
21 siblings, 1 reply; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Do not allocate a shared log if the backend doesn't support it.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
hw/virtio/vhost-user.c | 9 +++++++++
hw/virtio/vhost.c | 15 ++++++++++-----
include/hw/virtio/vhost-backend.h | 4 ++++
3 files changed, 23 insertions(+), 5 deletions(-)
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index 3cb5559..d12cd66 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -508,10 +508,19 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
return 0;
}
+static bool vhost_user_want_shm_log(struct vhost_dev *dev)
+{
+ assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
+
+ return virtio_has_feature(dev->protocol_features,
+ VHOST_USER_PROTOCOL_F_LOG_SHMFD);
+}
+
const VhostOps user_ops = {
.backend_type = VHOST_BACKEND_TYPE_USER,
.vhost_backend_init = vhost_user_init,
.vhost_backend_cleanup = vhost_user_cleanup,
+ .vhost_backend_want_shm_log = vhost_user_want_shm_log,
.vhost_net_set_backend = vhost_net_set_backend,
.vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
index 0fa7b69..d5070fb 100644
--- a/hw/virtio/vhost.c
+++ b/hw/virtio/vhost.c
@@ -350,10 +350,15 @@ static void vhost_log_put(struct vhost_dev *dev, bool sync)
}
}
-static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
+static bool vhost_dev_log_is_shared(struct vhost_dev *dev)
{
- bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
- struct vhost_log *log = vhost_log_get(size, share);
+ return dev->vhost_ops->vhost_backend_want_shm_log &&
+ dev->vhost_ops->vhost_backend_want_shm_log(dev);
+}
+
+static inline void vhost_dev_log_resize(struct vhost_dev *dev, uint64_t size)
+{
+ struct vhost_log *log = vhost_log_get(size, vhost_dev_log_is_shared(dev));
uint64_t log_base = (uintptr_t)log->log;
int r;
@@ -1161,10 +1166,10 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
if (hdev->log_enabled) {
uint64_t log_base;
- bool share = hdev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
hdev->log_size = vhost_get_log_size(hdev);
- hdev->log = vhost_log_get(hdev->log_size, share);
+ hdev->log = vhost_log_get(hdev->log_size,
+ vhost_dev_log_is_shared(hdev));
log_base = (uintptr_t)hdev->log->log;
r = hdev->vhost_ops->vhost_set_log_base(hdev,
hdev->log_size ? log_base : 0,
diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
index a87f0b3..44bf200 100644
--- a/include/hw/virtio/vhost-backend.h
+++ b/include/hw/virtio/vhost-backend.h
@@ -11,6 +11,8 @@
#ifndef VHOST_BACKEND_H_
#define VHOST_BACKEND_H_
+#include <stdbool.h>
+
typedef enum VhostBackendType {
VHOST_BACKEND_TYPE_NONE = 0,
VHOST_BACKEND_TYPE_KERNEL = 1,
@@ -28,6 +30,7 @@ struct vhost_scsi_target;
typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
+typedef bool (*vhost_backend_want_shm_log)(struct vhost_dev *dev);
typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
struct vhost_vring_file *file);
@@ -67,6 +70,7 @@ typedef struct VhostOps {
vhost_backend_init vhost_backend_init;
vhost_backend_cleanup vhost_backend_cleanup;
+ vhost_backend_want_shm_log vhost_backend_want_shm_log;
vhost_net_set_backend_op vhost_net_set_backend;
vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend marcandre.lureau
@ 2015-09-21 8:46 ` Michael S. Tsirkin
2015-09-21 14:03 ` Marc-André Lureau
0 siblings, 1 reply; 41+ messages in thread
From: Michael S. Tsirkin @ 2015-09-21 8:46 UTC (permalink / raw)
To: marcandre.lureau
Cc: haifeng.lin, thibaut.collet, jasowang, qemu-devel, pbonzini
On Sat, Sep 19, 2015 at 12:12:03PM +0200, marcandre.lureau@redhat.com wrote:
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Do not allocate a shared log if the backend doesn't support it.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
If not there, we probably want to block live migration, correct?
> ---
> hw/virtio/vhost-user.c | 9 +++++++++
> hw/virtio/vhost.c | 15 ++++++++++-----
> include/hw/virtio/vhost-backend.h | 4 ++++
> 3 files changed, 23 insertions(+), 5 deletions(-)
>
> diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> index 3cb5559..d12cd66 100644
> --- a/hw/virtio/vhost-user.c
> +++ b/hw/virtio/vhost-user.c
> @@ -508,10 +508,19 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
> return 0;
> }
>
> +static bool vhost_user_want_shm_log(struct vhost_dev *dev)
> +{
> + assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
> +
> + return virtio_has_feature(dev->protocol_features,
> + VHOST_USER_PROTOCOL_F_LOG_SHMFD);
> +}
> +
> const VhostOps user_ops = {
> .backend_type = VHOST_BACKEND_TYPE_USER,
> .vhost_backend_init = vhost_user_init,
> .vhost_backend_cleanup = vhost_user_cleanup,
> + .vhost_backend_want_shm_log = vhost_user_want_shm_log,
>
> .vhost_net_set_backend = vhost_net_set_backend,
> .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> index 0fa7b69..d5070fb 100644
> --- a/hw/virtio/vhost.c
> +++ b/hw/virtio/vhost.c
> @@ -350,10 +350,15 @@ static void vhost_log_put(struct vhost_dev *dev, bool sync)
> }
> }
>
> -static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t size)
> +static bool vhost_dev_log_is_shared(struct vhost_dev *dev)
> {
> - bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
> - struct vhost_log *log = vhost_log_get(size, share);
> + return dev->vhost_ops->vhost_backend_want_shm_log &&
> + dev->vhost_ops->vhost_backend_want_shm_log(dev);
> +}
> +
> +static inline void vhost_dev_log_resize(struct vhost_dev *dev, uint64_t size)
> +{
> + struct vhost_log *log = vhost_log_get(size, vhost_dev_log_is_shared(dev));
> uint64_t log_base = (uintptr_t)log->log;
> int r;
>
> @@ -1161,10 +1166,10 @@ int vhost_dev_start(struct vhost_dev *hdev, VirtIODevice *vdev)
>
> if (hdev->log_enabled) {
> uint64_t log_base;
> - bool share = hdev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
>
> hdev->log_size = vhost_get_log_size(hdev);
> - hdev->log = vhost_log_get(hdev->log_size, share);
> + hdev->log = vhost_log_get(hdev->log_size,
> + vhost_dev_log_is_shared(hdev));
> log_base = (uintptr_t)hdev->log->log;
> r = hdev->vhost_ops->vhost_set_log_base(hdev,
> hdev->log_size ? log_base : 0,
> diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
> index a87f0b3..44bf200 100644
> --- a/include/hw/virtio/vhost-backend.h
> +++ b/include/hw/virtio/vhost-backend.h
> @@ -11,6 +11,8 @@
> #ifndef VHOST_BACKEND_H_
> #define VHOST_BACKEND_H_
>
> +#include <stdbool.h>
> +
> typedef enum VhostBackendType {
> VHOST_BACKEND_TYPE_NONE = 0,
> VHOST_BACKEND_TYPE_KERNEL = 1,
> @@ -28,6 +30,7 @@ struct vhost_scsi_target;
>
> typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
> typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
> +typedef bool (*vhost_backend_want_shm_log)(struct vhost_dev *dev);
>
> typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
> struct vhost_vring_file *file);
> @@ -67,6 +70,7 @@ typedef struct VhostOps {
>
> vhost_backend_init vhost_backend_init;
> vhost_backend_cleanup vhost_backend_cleanup;
> + vhost_backend_want_shm_log vhost_backend_want_shm_log;
>
> vhost_net_set_backend_op vhost_net_set_backend;
> vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
> --
> 2.4.3
^ permalink raw reply [flat|nested] 41+ messages in thread* Re: [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend
2015-09-21 8:46 ` Michael S. Tsirkin
@ 2015-09-21 14:03 ` Marc-André Lureau
0 siblings, 0 replies; 41+ messages in thread
From: Marc-André Lureau @ 2015-09-21 14:03 UTC (permalink / raw)
To: Michael S. Tsirkin
Cc: haifeng lin, thibaut collet, jasowang, qemu-devel, pbonzini,
marcandre lureau
Hi
----- Original Message -----
> On Sat, Sep 19, 2015 at 12:12:03PM +0200, marcandre.lureau@redhat.com wrote:
> > From: Marc-André Lureau <marcandre.lureau@redhat.com>
> >
> > Do not allocate a shared log if the backend doesn't support it.
> >
> > Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> If not there, we probably want to block live migration, correct?
That make sense to me, I'll add that.
> > ---
> > hw/virtio/vhost-user.c | 9 +++++++++
> > hw/virtio/vhost.c | 15 ++++++++++-----
> > include/hw/virtio/vhost-backend.h | 4 ++++
> > 3 files changed, 23 insertions(+), 5 deletions(-)
> >
> > diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
> > index 3cb5559..d12cd66 100644
> > --- a/hw/virtio/vhost-user.c
> > +++ b/hw/virtio/vhost-user.c
> > @@ -508,10 +508,19 @@ static int vhost_user_cleanup(struct vhost_dev *dev)
> > return 0;
> > }
> >
> > +static bool vhost_user_want_shm_log(struct vhost_dev *dev)
> > +{
> > + assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
> > +
> > + return virtio_has_feature(dev->protocol_features,
> > + VHOST_USER_PROTOCOL_F_LOG_SHMFD);
> > +}
> > +
> > const VhostOps user_ops = {
> > .backend_type = VHOST_BACKEND_TYPE_USER,
> > .vhost_backend_init = vhost_user_init,
> > .vhost_backend_cleanup = vhost_user_cleanup,
> > + .vhost_backend_want_shm_log = vhost_user_want_shm_log,
> >
> > .vhost_net_set_backend = vhost_net_set_backend,
> > .vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
> > diff --git a/hw/virtio/vhost.c b/hw/virtio/vhost.c
> > index 0fa7b69..d5070fb 100644
> > --- a/hw/virtio/vhost.c
> > +++ b/hw/virtio/vhost.c
> > @@ -350,10 +350,15 @@ static void vhost_log_put(struct vhost_dev *dev, bool
> > sync)
> > }
> > }
> >
> > -static inline void vhost_dev_log_resize(struct vhost_dev* dev, uint64_t
> > size)
> > +static bool vhost_dev_log_is_shared(struct vhost_dev *dev)
> > {
> > - bool share = dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER;
> > - struct vhost_log *log = vhost_log_get(size, share);
> > + return dev->vhost_ops->vhost_backend_want_shm_log &&
> > + dev->vhost_ops->vhost_backend_want_shm_log(dev);
> > +}
> > +
> > +static inline void vhost_dev_log_resize(struct vhost_dev *dev, uint64_t
> > size)
> > +{
> > + struct vhost_log *log = vhost_log_get(size,
> > vhost_dev_log_is_shared(dev));
> > uint64_t log_base = (uintptr_t)log->log;
> > int r;
> >
> > @@ -1161,10 +1166,10 @@ int vhost_dev_start(struct vhost_dev *hdev,
> > VirtIODevice *vdev)
> >
> > if (hdev->log_enabled) {
> > uint64_t log_base;
> > - bool share = hdev->vhost_ops->backend_type ==
> > VHOST_BACKEND_TYPE_USER;
> >
> > hdev->log_size = vhost_get_log_size(hdev);
> > - hdev->log = vhost_log_get(hdev->log_size, share);
> > + hdev->log = vhost_log_get(hdev->log_size,
> > + vhost_dev_log_is_shared(hdev));
> > log_base = (uintptr_t)hdev->log->log;
> > r = hdev->vhost_ops->vhost_set_log_base(hdev,
> > hdev->log_size ? log_base
> > : 0,
> > diff --git a/include/hw/virtio/vhost-backend.h
> > b/include/hw/virtio/vhost-backend.h
> > index a87f0b3..44bf200 100644
> > --- a/include/hw/virtio/vhost-backend.h
> > +++ b/include/hw/virtio/vhost-backend.h
> > @@ -11,6 +11,8 @@
> > #ifndef VHOST_BACKEND_H_
> > #define VHOST_BACKEND_H_
> >
> > +#include <stdbool.h>
> > +
> > typedef enum VhostBackendType {
> > VHOST_BACKEND_TYPE_NONE = 0,
> > VHOST_BACKEND_TYPE_KERNEL = 1,
> > @@ -28,6 +30,7 @@ struct vhost_scsi_target;
> >
> > typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
> > typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
> > +typedef bool (*vhost_backend_want_shm_log)(struct vhost_dev *dev);
> >
> > typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
> > struct vhost_vring_file *file);
> > @@ -67,6 +70,7 @@ typedef struct VhostOps {
> >
> > vhost_backend_init vhost_backend_init;
> > vhost_backend_cleanup vhost_backend_cleanup;
> > + vhost_backend_want_shm_log vhost_backend_want_shm_log;
> >
> > vhost_net_set_backend_op vhost_net_set_backend;
> > vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
> > --
> > 2.4.3
>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [Qemu-devel] [PATCH v4 13/22] vhost-user: document migration log
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (11 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 12/22] vhost: only use shared log if in use by backend marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 14/22] net: add trace_vhost_user_event marcandre.lureau
` (8 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
docs/specs/vhost-user.txt | 42 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/docs/specs/vhost-user.txt b/docs/specs/vhost-user.txt
index 0062baa..0322bcf 100644
--- a/docs/specs/vhost-user.txt
+++ b/docs/specs/vhost-user.txt
@@ -120,6 +120,7 @@ There are several messages that the master sends with file descriptors passed
in the ancillary data:
* VHOST_SET_MEM_TABLE
+ * VHOST_SET_LOG_BASE (if VHOST_USER_PROTOCOL_F_LOG_SHMFD)
* VHOST_SET_LOG_FD
* VHOST_SET_VRING_KICK
* VHOST_SET_VRING_CALL
@@ -135,6 +136,11 @@ As older slaves don't support negotiating protocol features,
a feature bit was dedicated for this purpose:
#define VHOST_USER_F_PROTOCOL_FEATURES 30
+Protocol features
+-----------------
+
+#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
+
Message types
-------------
@@ -301,3 +307,39 @@ Message types
Bits (0-7) of the payload contain the vring index. Bit 8 is the
invalid FD flag. This flag is set when there is no file descriptor
in the ancillary data.
+
+Migration
+---------
+
+During live migration, the master may need to track the modifications
+the slave makes to the memory mapped regions. The client should mark
+the dirty pages in a log. Once it complies to this logging, it may
+declare the VHOST_F_LOG_ALL vhost feature.
+
+All the modifications to memory pointed by vring "descriptor" should
+be marked. Modifications to "used" vring should be marked if
+VHOST_VRING_F_LOG is part of ring's features.
+
+Dirty pages are of size:
+#define VHOST_LOG_PAGE 0x1000
+
+The log memory fd is provided in the ancillary data of
+VHOST_USER_SET_LOG_BASE message when the slave has
+VHOST_USER_PROTOCOL_F_LOG_SHMFD protocol feature.
+
+The size of the log may be computed by using all the known guest
+addresses. The log covers from address 0 to the maximum of guest
+regions. In pseudo-code, to mark page at "addr" as dirty:
+
+page = addr / VHOST_LOG_PAGE
+log[page / 8] |= 1 << page % 8
+
+Use atomic operations, as the log may be concurrently manipulated.
+
+VHOST_USER_SET_LOG_FD is an optional message with an eventfd in
+ancillary data, it may be used to inform the master that the log has
+been modified.
+
+Once the source has finished migration, VHOST_USER_RESET_OWNER message
+will be sent by the source. No further update must be done before the
+destination takes over with new regions & rings.
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 14/22] net: add trace_vhost_user_event
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (12 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 13/22] vhost-user: document migration log marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 15/22] vhost user: add support of live migration marcandre.lureau
` (7 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Replace error_report() and use tracing instead. It's not an error to get
a connection or a disconnection, so silence this and trace it instead.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
net/vhost-user.c | 5 +++--
trace-events | 4 ++++
2 files changed, 7 insertions(+), 2 deletions(-)
diff --git a/net/vhost-user.c b/net/vhost-user.c
index 93dcecd..bbcd9ff 100644
--- a/net/vhost-user.c
+++ b/net/vhost-user.c
@@ -14,6 +14,7 @@
#include "sysemu/char.h"
#include "qemu/config-file.h"
#include "qemu/error-report.h"
+#include "trace.h"
typedef struct VhostUserState {
NetClientState nc;
@@ -116,16 +117,16 @@ static void net_vhost_user_event(void *opaque, int event)
{
VhostUserState *s = opaque;
+ trace_vhost_user_event(s->chr->label, event);
+
switch (event) {
case CHR_EVENT_OPENED:
vhost_user_start(s);
net_vhost_link_down(s, false);
- error_report("chardev \"%s\" went up", s->chr->label);
break;
case CHR_EVENT_CLOSED:
net_vhost_link_down(s, true);
vhost_user_stop(s);
- error_report("chardev \"%s\" went down", s->chr->label);
break;
}
}
diff --git a/trace-events b/trace-events
index 88a2f14..1c4d61f 100644
--- a/trace-events
+++ b/trace-events
@@ -1685,3 +1685,7 @@ qcrypto_tls_creds_x509_load_cert_list(void *creds, const char *file) "TLS creds
# crypto/tlssession.c
qcrypto_tls_session_new(void *session, void *creds, const char *hostname, const char *aclname, int endpoint) "TLS session new session=%p creds=%p hostname=%s aclname=%s endpoint=%d"
+
+# net/vhost-user.c
+vhost_user_event(const char *chr, int event) "chr: %s got event: %d"
+
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 15/22] vhost user: add support of live migration
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (13 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 14/22] net: add trace_vhost_user_event marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 16/22] vhost user: add rarp sending after live migration for legacy guest marcandre.lureau
` (6 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel; +Cc: thibaut.collet, jasowang, mst, haifeng.lin, pbonzini
From: Thibaut Collet <thibaut.collet@6wind.com>
Some vhost user backends are able to support live migration.
To provide this service the following features must be added:
1. Add the VIRTIO_NET_F_GUEST_ANNOUNCE capability to vhost-net when netdev
backend is vhost-user.
2. Provide a nop receive callback to vhost-user.
This callback is called by:
* qemu_announce_self after a migration to send fake RARP to avoid network
outage for peers talking to the migrated guest.
- For guest with GUEST_ANNOUNCE capabilities, guest already sends GARP
when the bit VIRTIO_NET_S_ANNOUNCE is set.
=> These packets must be discarded.
- For guest without GUEST_ANNOUNCE capabilities, migration termination
is notified when the guest sends packets.
=> These packets can be discarded.
* virtio_net_tx_bh with a dummy boot to send fake bootp/dhcp request.
BIOS guest manages virtio driver to send 4 bootp/dhcp request in case of
dummy boot.
=> These packets must be discarded.
Signed-off-by: Thibaut Collet <thibaut.collet@6wind.com>
---
hw/net/vhost_net.c | 2 ++
net/vhost-user.c | 12 ++++++++++--
2 files changed, 12 insertions(+), 2 deletions(-)
diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
index d116fb3..3de171b 100644
--- a/hw/net/vhost_net.c
+++ b/hw/net/vhost_net.c
@@ -85,6 +85,8 @@ static const int user_feature_bits[] = {
VIRTIO_NET_F_CTRL_MAC_ADDR,
VIRTIO_NET_F_CTRL_GUEST_OFFLOADS,
+ VIRTIO_NET_F_GUEST_ANNOUNCE,
+
VIRTIO_NET_F_MQ,
VHOST_INVALID_FEATURE_BIT
diff --git a/net/vhost-user.c b/net/vhost-user.c
index bbcd9ff..555d80f 100644
--- a/net/vhost-user.c
+++ b/net/vhost-user.c
@@ -66,6 +66,15 @@ static void vhost_user_stop(VhostUserState *s)
s->vhost_net = 0;
}
+static ssize_t vhost_user_receive(NetClientState *nc, const uint8_t *buf,
+ size_t size)
+{
+ /* Discard the request that is received and managed by backend
+ * by an other way.
+ */
+ return size;
+}
+
static void vhost_user_cleanup(NetClientState *nc)
{
VhostUserState *s = DO_UPCAST(VhostUserState, nc, nc);
@@ -91,6 +100,7 @@ static bool vhost_user_has_ufo(NetClientState *nc)
static NetClientInfo net_vhost_user_info = {
.type = NET_CLIENT_OPTIONS_KIND_VHOST_USER,
.size = sizeof(VhostUserState),
+ .receive = vhost_user_receive,
.cleanup = vhost_user_cleanup,
.has_vnet_hdr = vhost_user_has_vnet_hdr,
.has_ufo = vhost_user_has_ufo,
@@ -144,8 +154,6 @@ static int net_vhost_user_init(NetClientState *peer, const char *device,
s = DO_UPCAST(VhostUserState, nc, nc);
- /* We don't provide a receive callback */
- s->nc.receive_disabled = 1;
s->chr = chr;
qemu_chr_add_handlers(s->chr, NULL, NULL, net_vhost_user_event, s);
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 16/22] vhost user: add rarp sending after live migration for legacy guest
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (14 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 15/22] vhost user: add support of live migration marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 17/22] vhost-user-test: move wait_for_fds() out marcandre.lureau
` (5 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Thibaut Collet <thibaut.collet@6wind.com>
A new vhost user message is added to allow QEMU to ask to vhost user backend to
broadcast a fake RARP after live migration for guest without GUEST_ANNOUNCE
capability.
This new message is sent only if the backend supports the new
VHOST_USER_PROTOCOL_F_RARP protocol feature.
The payload of this new message is the MAC address of the guest (not known by
the backend). The MAC address is copied in the first 6 bytes of a u64 to avoid
to create a new payload message type.
This new message has no equivalent ioctl so a new callback is added in the
userOps structure to send the request.
Upon reception of this new message the vhost user backend must generate and
broadcast a fake RARP request to notify the migration is terminated.
Signed-off-by: Thibaut Collet <thibaut.collet@6wind.com>
[Rebased and fixed checkpatch errors - Marc-André]
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
docs/specs/vhost-user.txt | 15 +++++++++++++++
hw/net/vhost_net.c | 17 +++++++++++++++++
hw/virtio/vhost-backend.c | 1 +
hw/virtio/vhost-user.c | 32 +++++++++++++++++++++++++++++++-
include/hw/virtio/vhost-backend.h | 3 +++
include/net/vhost_net.h | 1 +
net/vhost-user.c | 24 ++++++++++++++++++++++--
7 files changed, 90 insertions(+), 3 deletions(-)
diff --git a/docs/specs/vhost-user.txt b/docs/specs/vhost-user.txt
index 0322bcf..118ed55 100644
--- a/docs/specs/vhost-user.txt
+++ b/docs/specs/vhost-user.txt
@@ -140,6 +140,7 @@ Protocol features
-----------------
#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
+#define VHOST_USER_PROTOCOL_F_RARP 1
Message types
-------------
@@ -308,6 +309,20 @@ Message types
invalid FD flag. This flag is set when there is no file descriptor
in the ancillary data.
+ * VHOST_USER_SEND_RARP
+
+ Id: 17
+ Equivalent ioctl: N/A
+ Master payload: u64
+
+ Ask vhost user backend to broadcast a fake RARP to notify the migration
+ is terminated for guest that does not support GUEST_ANNOUNCE.
+ Only legal if feature bit VHOST_USER_F_PROTOCOL_FEATURES is present in
+ VHOST_USER_GET_FEATURES and protocol feature bit VHOST_USER_PROTOCOL_F_RARP
+ is present in VHOST_USER_GET_PROTOCOL_FEATURES.
+ The first 6 bytes of the payload contain the mac address of the guest to
+ allow the vhost user backend to construct and broadcast the fake RARP.
+
Migration
---------
diff --git a/hw/net/vhost_net.c b/hw/net/vhost_net.c
index 3de171b..bae5ab9 100644
--- a/hw/net/vhost_net.c
+++ b/hw/net/vhost_net.c
@@ -379,6 +379,18 @@ void vhost_net_cleanup(struct vhost_net *net)
g_free(net);
}
+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_backend_migration_done) {
+ r = vhost_ops->vhost_backend_migration_done(&net->dev, mac_addr);
+ }
+
+ return r;
+}
+
bool vhost_net_virtqueue_pending(VHostNetState *net, int idx)
{
return vhost_virtqueue_pending(&net->dev, idx);
@@ -452,6 +464,11 @@ void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
{
}
+int vhost_net_notify_migration_done(struct vhost_net *net)
+{
+ return -1;
+}
+
VHostNetState *get_vhost_net(NetClientState *nc)
{
return 0;
diff --git a/hw/virtio/vhost-backend.c b/hw/virtio/vhost-backend.c
index 3f2d6ea..182f6a8 100644
--- a/hw/virtio/vhost-backend.c
+++ b/hw/virtio/vhost-backend.c
@@ -146,6 +146,7 @@ static const VhostOps kernel_ops = {
.backend_type = VHOST_BACKEND_TYPE_KERNEL,
.vhost_backend_init = vhost_kernel_init,
.vhost_backend_cleanup = vhost_kernel_cleanup,
+ .vhost_backend_migration_done = NULL,
.vhost_net_set_backend = vhost_net_set_backend,
.vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
diff --git a/hw/virtio/vhost-user.c b/hw/virtio/vhost-user.c
index d12cd66..a6a7ab2 100644
--- a/hw/virtio/vhost-user.c
+++ b/hw/virtio/vhost-user.c
@@ -10,6 +10,7 @@
#include "hw/virtio/vhost.h"
#include "hw/virtio/vhost-backend.h"
+#include "hw/virtio/virtio-net.h"
#include "sysemu/char.h"
#include "sysemu/kvm.h"
#include "qemu/error-report.h"
@@ -27,8 +28,9 @@
#define VHOST_USER_F_PROTOCOL_FEATURES 30
-#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x1ULL
+#define VHOST_USER_PROTOCOL_FEATURE_MASK 0x3ULL
#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
+#define VHOST_USER_PROTOCOL_F_RARP 1
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
@@ -48,6 +50,7 @@ typedef enum VhostUserRequest {
VHOST_USER_SET_VRING_ERR = 14,
VHOST_USER_GET_PROTOCOL_FEATURES = 15,
VHOST_USER_SET_PROTOCOL_FEATURES = 16,
+ VHOST_USER_SEND_RARP = 17,
VHOST_USER_MAX
} VhostUserRequest;
@@ -516,11 +519,38 @@ static bool vhost_user_want_shm_log(struct vhost_dev *dev)
VHOST_USER_PROTOCOL_F_LOG_SHMFD);
}
+static int vhost_user_migration_done(struct vhost_dev *dev, char* mac_addr)
+{
+ VhostUserMsg msg = { 0 };
+ int err;
+
+ assert(dev->vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER);
+
+ /* If guest supports GUEST_ANNOUNCE do nothing */
+ if (virtio_has_feature(dev->acked_features, VIRTIO_NET_F_GUEST_ANNOUNCE)) {
+ return 0;
+ }
+
+ /* if backend supports VHOST_USER_PROTOCOL_F_RARP ask it to send the RARP */
+ if (virtio_has_feature(dev->protocol_features,
+ VHOST_USER_PROTOCOL_F_RARP)) {
+ msg.request = VHOST_USER_SEND_RARP;
+ msg.flags = VHOST_USER_VERSION;
+ memcpy((char *)&msg.u64, mac_addr, 6);
+ msg.size = sizeof(m.u64);
+
+ err = vhost_user_write(dev, &msg, NULL, 0);
+ return err;
+ }
+ return -1;
+}
+
const VhostOps user_ops = {
.backend_type = VHOST_BACKEND_TYPE_USER,
.vhost_backend_init = vhost_user_init,
.vhost_backend_cleanup = vhost_user_cleanup,
.vhost_backend_want_shm_log = vhost_user_want_shm_log,
+ .vhost_backend_migration_done = vhost_user_migration_done,
.vhost_net_set_backend = vhost_net_set_backend,
.vhost_scsi_set_endpoint = vhost_scsi_set_endpoint,
diff --git a/include/hw/virtio/vhost-backend.h b/include/hw/virtio/vhost-backend.h
index 44bf200..0c75ed6 100644
--- a/include/hw/virtio/vhost-backend.h
+++ b/include/hw/virtio/vhost-backend.h
@@ -31,6 +31,8 @@ struct vhost_scsi_target;
typedef int (*vhost_backend_init)(struct vhost_dev *dev, void *opaque);
typedef int (*vhost_backend_cleanup)(struct vhost_dev *dev);
typedef bool (*vhost_backend_want_shm_log)(struct vhost_dev *dev);
+typedef int (*vhost_backend_migration_done)(struct vhost_dev *dev,
+ char *mac_addr);
typedef int (*vhost_net_set_backend_op)(struct vhost_dev *dev,
struct vhost_vring_file *file);
@@ -71,6 +73,7 @@ typedef struct VhostOps {
vhost_backend_init vhost_backend_init;
vhost_backend_cleanup vhost_backend_cleanup;
vhost_backend_want_shm_log vhost_backend_want_shm_log;
+ vhost_backend_migration_done vhost_backend_migration_done;
vhost_net_set_backend_op vhost_net_set_backend;
vhost_scsi_set_endpoint_op vhost_scsi_set_endpoint;
diff --git a/include/net/vhost_net.h b/include/net/vhost_net.h
index 840d4b1..8e5dfd4 100644
--- a/include/net/vhost_net.h
+++ b/include/net/vhost_net.h
@@ -26,5 +26,6 @@ void vhost_net_ack_features(VHostNetState *net, uint64_t features);
bool vhost_net_virtqueue_pending(VHostNetState *net, int n);
void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev,
int idx, bool mask);
+int vhost_net_notify_migration_done(VHostNetState *net, char* mac_addr);
VHostNetState *get_vhost_net(NetClientState *nc);
#endif
diff --git a/net/vhost-user.c b/net/vhost-user.c
index 555d80f..3c1b01c 100644
--- a/net/vhost-user.c
+++ b/net/vhost-user.c
@@ -69,9 +69,29 @@ static void vhost_user_stop(VhostUserState *s)
static ssize_t vhost_user_receive(NetClientState *nc, const uint8_t *buf,
size_t size)
{
- /* Discard the request that is received and managed by backend
- * by an other way.
+ /* In case of RARP (message size is 60) notify backup to send a fake RARP.
+ This fake RARP will be sent by backend only for guest
+ without GUEST_ANNOUNCE capability.
*/
+ if (size == 60) {
+ VhostUserState *s = DO_UPCAST(VhostUserState, nc, nc);
+ int r;
+ static int display_rarp_failure = 1;
+ char mac_addr[6];
+
+ /* extract guest mac address from the RARP message */
+ memcpy(mac_addr, &buf[6], 6);
+
+ r = vhost_net_notify_migration_done(s->vhost_net, mac_addr);
+
+ if ((r != 0) && (display_rarp_failure)) {
+ fprintf(stderr,
+ "Vhost user backend fails to broadcast fake RARP\n");
+ fflush(stderr);
+ display_rarp_failure = 0;
+ }
+ }
+
return size;
}
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 17/22] vhost-user-test: move wait_for_fds() out
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (15 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 16/22] vhost user: add rarp sending after live migration for legacy guest marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 18/22] vhost-user-test: remove useless static check marcandre.lureau
` (4 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
This function is a precondition for most vhost-user tests.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 17 ++++++++++++-----
1 file changed, 12 insertions(+), 5 deletions(-)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 228acb6..551a664 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -205,15 +205,11 @@ static GThread *_thread_new(const gchar *name, GThreadFunc func, gpointer data)
return thread;
}
-static void read_guest_mem(void)
+static void wait_for_fds(void)
{
- uint32_t *guest_mem;
gint64 end_time;
- int i, j;
- size_t size;
g_mutex_lock(data_mutex);
-
end_time = _get_time() + 5 * G_TIME_SPAN_SECOND;
while (!fds_num) {
if (!_cond_wait_until(data_cond, data_mutex, end_time)) {
@@ -227,6 +223,17 @@ static void read_guest_mem(void)
g_assert_cmpint(fds_num, >, 0);
g_assert_cmpint(fds_num, ==, memory.nregions);
+ g_mutex_unlock(data_mutex);
+}
+
+static void read_guest_mem(void)
+{
+ uint32_t *guest_mem;
+ int i, j;
+ size_t size;
+
+ wait_for_fds();
+
/* iterate all regions */
for (i = 0; i < fds_num; i++) {
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 18/22] vhost-user-test: remove useless static check
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (16 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 17/22] vhost-user-test: move wait_for_fds() out marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 19/22] vhost-user-test: wrap server in TestServer struct marcandre.lureau
` (3 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 551a664..68badf9 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -262,7 +262,6 @@ static void read_guest_mem(void)
munmap(guest_mem, memory.regions[i].memory_size);
}
- g_assert_cmpint(1, ==, 1);
g_mutex_unlock(data_mutex);
}
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 19/22] vhost-user-test: wrap server in TestServer struct
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (17 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 18/22] vhost-user-test: remove useless static check marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 20/22] vhost-user-test: learn to tweak various qemu arguments marcandre.lureau
` (2 subsequent siblings)
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
In the coming patches, a test will use several servers
simultaneously. Wrap the server in a struct, out of the global scope.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 146 ++++++++++++++++++++++++++++++------------------
1 file changed, 92 insertions(+), 54 deletions(-)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 68badf9..6605fba 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -115,10 +115,18 @@ static VhostUserMsg m __attribute__ ((unused));
#define VHOST_USER_VERSION (0x1)
/*****************************************************************************/
-int fds_num = 0, fds[VHOST_MEMORY_MAX_NREGIONS];
-static VhostUserMemory memory;
-static GMutex *data_mutex;
-static GCond *data_cond;
+typedef struct TestServer {
+ gchar *socket_path;
+ gchar *chr_name;
+ CharDriverState *chr;
+ int fds_num;
+ int fds[VHOST_MEMORY_MAX_NREGIONS];
+ VhostUserMemory memory;
+ GMutex *data_mutex;
+ GCond *data_cond;
+} TestServer;
+
+static const char *hugefs;
static gint64 _get_time(void)
{
@@ -205,64 +213,63 @@ static GThread *_thread_new(const gchar *name, GThreadFunc func, gpointer data)
return thread;
}
-static void wait_for_fds(void)
+static void wait_for_fds(TestServer *s)
{
gint64 end_time;
- g_mutex_lock(data_mutex);
+ g_mutex_lock(s->data_mutex);
end_time = _get_time() + 5 * G_TIME_SPAN_SECOND;
- while (!fds_num) {
- if (!_cond_wait_until(data_cond, data_mutex, end_time)) {
+ while (!s->fds_num) {
+ if (!_cond_wait_until(s->data_cond, s->data_mutex, end_time)) {
/* timeout has passed */
- g_assert(fds_num);
+ g_assert(s->fds_num);
break;
}
}
/* check for sanity */
- g_assert_cmpint(fds_num, >, 0);
- g_assert_cmpint(fds_num, ==, memory.nregions);
+ g_assert_cmpint(s->fds_num, >, 0);
+ g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
- g_mutex_unlock(data_mutex);
+ g_mutex_unlock(s->data_mutex);
}
-static void read_guest_mem(void)
+static void read_guest_mem(TestServer *s)
{
uint32_t *guest_mem;
int i, j;
size_t size;
- wait_for_fds();
+ wait_for_fds(s);
/* iterate all regions */
- for (i = 0; i < fds_num; i++) {
+ for (i = 0; i < s->fds_num; i++) {
/* We'll check only the region statring at 0x0*/
- if (memory.regions[i].guest_phys_addr != 0x0) {
+ if (s->memory.regions[i].guest_phys_addr != 0x0) {
continue;
}
- g_assert_cmpint(memory.regions[i].memory_size, >, 1024);
+ g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
- size = memory.regions[i].memory_size + memory.regions[i].mmap_offset;
+ size = s->memory.regions[i].memory_size +
+ s->memory.regions[i].mmap_offset;
guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
- MAP_SHARED, fds[i], 0);
+ MAP_SHARED, s->fds[i], 0);
g_assert(guest_mem != MAP_FAILED);
- guest_mem += (memory.regions[i].mmap_offset / sizeof(*guest_mem));
+ guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
for (j = 0; j < 256; j++) {
- uint32_t a = readl(memory.regions[i].guest_phys_addr + j*4);
+ uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4);
uint32_t b = guest_mem[j];
g_assert_cmpint(a, ==, b);
}
- munmap(guest_mem, memory.regions[i].memory_size);
+ munmap(guest_mem, s->memory.regions[i].memory_size);
}
-
- g_mutex_unlock(data_mutex);
}
static void *thread_function(void *data)
@@ -280,7 +287,8 @@ static int chr_can_read(void *opaque)
static void chr_read(void *opaque, const uint8_t *buf, int size)
{
- CharDriverState *chr = opaque;
+ TestServer *s = opaque;
+ CharDriverState *chr = s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int fd;
@@ -290,12 +298,12 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
return;
}
- g_mutex_lock(data_mutex);
+ g_mutex_lock(s->data_mutex);
memcpy(p, buf, VHOST_USER_HDR_SIZE);
if (msg.size) {
p += VHOST_USER_HDR_SIZE;
- qemu_chr_fe_read_all(chr, p, msg.size);
+ g_assert_cmpint(qemu_chr_fe_read_all(chr, p, msg.size), ==, msg.size);
}
switch (msg.request) {
@@ -334,11 +342,11 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
case VHOST_USER_SET_MEM_TABLE:
/* received the mem table */
- memcpy(&memory, &msg.memory, sizeof(msg.memory));
- fds_num = qemu_chr_fe_get_msgfds(chr, fds, sizeof(fds) / sizeof(int));
+ memcpy(&s->memory, &msg.memory, sizeof(msg.memory));
+ s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
/* signal the test that it can continue */
- g_cond_signal(data_cond);
+ g_cond_signal(s->data_cond);
break;
case VHOST_USER_SET_VRING_KICK:
@@ -355,7 +363,53 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
default:
break;
}
- g_mutex_unlock(data_mutex);
+
+ g_mutex_unlock(s->data_mutex);
+}
+
+static TestServer *test_server_new(const gchar *name)
+{
+ TestServer *server = g_new0(TestServer, 1);
+ gchar *chr_path;
+
+ server->socket_path = g_strdup_printf("/tmp/vhost-%s-%d.sock",
+ name, getpid());
+
+ chr_path = g_strdup_printf("unix:%s,server,nowait", server->socket_path);
+ server->chr_name = g_strdup_printf("chr-%s", name);
+ server->chr = qemu_chr_new(server->chr_name, chr_path, NULL);
+ g_free(chr_path);
+
+ qemu_chr_add_handlers(server->chr, chr_can_read, chr_read, NULL, server);
+
+ /* run the main loop thread so the chardev may operate */
+ server->data_mutex = _mutex_new();
+ server->data_cond = _cond_new();
+
+ return server;
+}
+
+#define GET_QEMU_CMD(s) \
+ g_strdup_printf(QEMU_CMD, (hugefs), (s)->socket_path)
+
+
+static void test_server_free(TestServer *server)
+{
+ int i;
+
+ qemu_chr_delete(server->chr);
+
+ for (i = 0; i < server->fds_num; i++) {
+ close(server->fds[i]);
+ }
+
+ unlink(server->socket_path);
+ g_free(server->socket_path);
+
+ _cond_free(server->data_cond);
+ _mutex_free(server->data_mutex);
+
+ g_free(server);
}
static const char *init_hugepagefs(void)
@@ -394,41 +448,28 @@ static const char *init_hugepagefs(void)
int main(int argc, char **argv)
{
QTestState *s = NULL;
- CharDriverState *chr = NULL;
- const char *hugefs = 0;
- char *socket_path = 0;
- char *qemu_cmd = 0;
- char *chr_path = 0;
+ TestServer *server = NULL;
+ char *qemu_cmd;
int ret;
g_test_init(&argc, &argv, NULL);
module_call_init(MODULE_INIT_QOM);
+ qemu_add_opts(&qemu_chardev_opts);
hugefs = init_hugepagefs();
if (!hugefs) {
return 0;
}
- socket_path = g_strdup_printf("/tmp/vhost-%d.sock", getpid());
-
- /* create char dev and add read handlers */
- qemu_add_opts(&qemu_chardev_opts);
- chr_path = g_strdup_printf("unix:%s,server,nowait", socket_path);
- chr = qemu_chr_new("chr0", chr_path, NULL);
- g_free(chr_path);
- qemu_chr_add_handlers(chr, chr_can_read, chr_read, NULL, chr);
-
- /* run the main loop thread so the chardev may operate */
- data_mutex = _mutex_new();
- data_cond = _cond_new();
_thread_new(NULL, thread_function, NULL);
- qemu_cmd = g_strdup_printf(QEMU_CMD, hugefs, socket_path);
+ server = test_server_new("test");
+ qemu_cmd = GET_QEMU_CMD(server);
s = qtest_start(qemu_cmd);
g_free(qemu_cmd);
- qtest_add_func("/vhost-user/read-guest-mem", read_guest_mem);
+ qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem);
ret = g_test_run();
@@ -437,10 +478,7 @@ int main(int argc, char **argv)
}
/* cleanup */
- unlink(socket_path);
- g_free(socket_path);
- _cond_free(data_cond);
- _mutex_free(data_mutex);
+ test_server_free(server);
return ret;
}
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 20/22] vhost-user-test: learn to tweak various qemu arguments
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (18 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 19/22] vhost-user-test: wrap server in TestServer struct marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 21/22] vhost-user-test: add live-migration test marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 22/22] vhost-user-test: check ownership during migration marcandre.lureau
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Add a new macro to make the qemu command line with other
values of memory size, and specific chardev id.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 14 +++++++++-----
1 file changed, 9 insertions(+), 5 deletions(-)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 6605fba..4ef2d6c 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -37,10 +37,10 @@
#endif
#define QEMU_CMD_ACCEL " -machine accel=tcg"
-#define QEMU_CMD_MEM " -m 512 -object memory-backend-file,id=mem,size=512M,"\
+#define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\
"mem-path=%s,share=on -numa node,memdev=mem"
-#define QEMU_CMD_CHR " -chardev socket,id=chr0,path=%s"
-#define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=chr0,vhostforce"
+#define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s"
+#define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce"
#define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0 "
#define QEMU_CMD_ROM " -option-rom ../pc-bios/pxe-virtio.rom"
@@ -389,9 +389,13 @@ static TestServer *test_server_new(const gchar *name)
return server;
}
-#define GET_QEMU_CMD(s) \
- g_strdup_printf(QEMU_CMD, (hugefs), (s)->socket_path)
+#define GET_QEMU_CMD(s) \
+ g_strdup_printf(QEMU_CMD, 512, 512, (hugefs), \
+ (s)->chr_name, (s)->socket_path, (s)->chr_name)
+#define GET_QEMU_CMDE(s, mem, extra, ...) \
+ g_strdup_printf(QEMU_CMD extra, (mem), (mem), (hugefs), \
+ (s)->chr_name, (s)->socket_path, (s)->chr_name, ##__VA_ARGS__)
static void test_server_free(TestServer *server)
{
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 21/22] vhost-user-test: add live-migration test
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (19 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 20/22] vhost-user-test: learn to tweak various qemu arguments marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 22/22] vhost-user-test: check ownership during migration marcandre.lureau
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
This test checks that the log fd is given to the migration source, and
mark dirty pages during migration.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 162 +++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 159 insertions(+), 3 deletions(-)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index 4ef2d6c..dcc14bf 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -13,6 +13,7 @@
#include "libqtest.h"
#include "qemu/option.h"
+#include "qemu/range.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"
@@ -54,6 +55,9 @@
#define VHOST_MEMORY_MAX_NREGIONS 8
#define VHOST_USER_F_PROTOCOL_FEATURES 30
+#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 0
+
+#define VHOST_LOG_PAGE 0x1000
typedef enum VhostUserRequest {
VHOST_USER_NONE = 0,
@@ -124,6 +128,7 @@ typedef struct TestServer {
VhostUserMemory memory;
GMutex *data_mutex;
GCond *data_cond;
+ int log_fd;
} TestServer;
static const char *hugefs;
@@ -311,7 +316,8 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.u64);
- msg.u64 = 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
+ msg.u64 = 0x1ULL << VHOST_F_LOG_ALL |
+ 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
@@ -325,12 +331,11 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.u64);
- msg.u64 = 0;
+ msg.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
-
case VHOST_USER_GET_VRING_BASE:
/* send back vring base to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
@@ -360,6 +365,12 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
*/
qemu_set_nonblock(fd);
break;
+
+ case VHOST_USER_SET_LOG_BASE:
+ qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
+ g_cond_signal(s->data_cond);
+ break;
+
default:
break;
}
@@ -386,6 +397,8 @@ static TestServer *test_server_new(const gchar *name)
server->data_mutex = _mutex_new();
server->data_cond = _cond_new();
+ server->log_fd = -1;
+
return server;
}
@@ -407,15 +420,157 @@ static void test_server_free(TestServer *server)
close(server->fds[i]);
}
+ if (server->log_fd != -1) {
+ close(server->log_fd);
+ }
+
unlink(server->socket_path);
g_free(server->socket_path);
_cond_free(server->data_cond);
_mutex_free(server->data_mutex);
+ g_free(server->chr_name);
g_free(server);
}
+static void wait_for_log_fd(TestServer *s)
+{
+ gint64 end_time;
+
+ g_mutex_lock(s->data_mutex);
+ end_time = _get_time() + 5 * G_TIME_SPAN_SECOND;
+ while (s->log_fd == -1) {
+ if (!_cond_wait_until(s->data_cond, s->data_mutex, end_time)) {
+ /* timeout has passed */
+ g_assert(s->log_fd != -1);
+ break;
+ }
+ }
+
+ g_mutex_unlock(s->data_mutex);
+}
+
+static void write_guest_mem(TestServer *s, uint32 seed)
+{
+ uint32_t *guest_mem;
+ int i, j;
+ size_t size;
+
+ wait_for_fds(s);
+
+ /* iterate all regions */
+ for (i = 0; i < s->fds_num; i++) {
+
+ /* We'll write only the region statring at 0x0 */
+ if (s->memory.regions[i].guest_phys_addr != 0x0) {
+ continue;
+ }
+
+ g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
+
+ size = s->memory.regions[i].memory_size +
+ s->memory.regions[i].mmap_offset;
+
+ guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
+ MAP_SHARED, s->fds[i], 0);
+
+ g_assert(guest_mem != MAP_FAILED);
+ guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
+
+ for (j = 0; j < 256; j++) {
+ guest_mem[j] = seed + j;
+ }
+
+ munmap(guest_mem, s->memory.regions[i].memory_size);
+ break;
+ }
+}
+
+static guint64 get_log_size(TestServer *s)
+{
+ guint64 log_size = 0;
+ int i;
+
+ for (i = 0; i < s->memory.nregions; ++i) {
+ VhostUserMemoryRegion *reg = &s->memory.regions[i];
+ guint64 last = range_get_last(reg->guest_phys_addr,
+ reg->memory_size);
+ log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
+ }
+
+ return log_size;
+}
+
+static void test_migrate(void)
+{
+ TestServer *s = test_server_new("src");
+ TestServer *dest = test_server_new("dest");
+ const char *uri = "tcp:127.0.0.1:1234";
+ QTestState *global = global_qtest, *from, *to;
+ gchar *cmd;
+ QDict *rsp;
+ guint8 *log;
+ guint64 size;
+
+ cmd = GET_QEMU_CMDE(s, 2, "");
+ from = qtest_start(cmd);
+ g_free(cmd);
+
+ wait_for_fds(s);
+ size = get_log_size(s);
+ g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
+
+ cmd = GET_QEMU_CMDE(dest, 2, " -incoming %s", uri);
+ to = qtest_init(cmd);
+ g_free(cmd);
+
+ /* slow down migration to have time to fiddle with log */
+ /* TODO: qtest could learn to break on some places */
+ rsp = qmp("{ 'execute': 'migrate_set_speed',"
+ "'arguments': { 'value': 10 } }");
+ g_assert(qdict_haskey(rsp, "return"));
+ QDECREF(rsp);
+
+ cmd = g_strdup_printf("{ 'execute': 'migrate',"
+ "'arguments': { 'uri': '%s' } }",
+ uri);
+ rsp = qmp(cmd);
+ g_free(cmd);
+ g_assert(qdict_haskey(rsp, "return"));
+ QDECREF(rsp);
+
+ wait_for_log_fd(s);
+
+ log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
+ g_assert(log != MAP_FAILED);
+
+ /* modify first page */
+ write_guest_mem(s, 0x42);
+ log[0] = 1;
+ munmap(log, size);
+
+ /* speed things up */
+ rsp = qmp("{ 'execute': 'migrate_set_speed',"
+ "'arguments': { 'value': 0 } }");
+ g_assert(qdict_haskey(rsp, "return"));
+ QDECREF(rsp);
+
+ qmp_eventwait("STOP");
+
+ global_qtest = to;
+ qmp_eventwait("RESUME");
+
+ read_guest_mem(dest);
+
+ qtest_quit(to);
+ test_server_free(dest);
+ qtest_quit(from);
+ test_server_free(s);
+
+ global_qtest = global;
+}
+
static const char *init_hugepagefs(void)
{
const char *path;
@@ -474,6 +629,7 @@ int main(int argc, char **argv)
g_free(qemu_cmd);
qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem);
+ qtest_add_func("/vhost-user/migrate", test_migrate);
ret = g_test_run();
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread* [Qemu-devel] [PATCH v4 22/22] vhost-user-test: check ownership during migration
2015-09-19 10:11 [Qemu-devel] [PATCH v4 00/22] vhost-user: add migration support marcandre.lureau
` (20 preceding siblings ...)
2015-09-19 10:12 ` [Qemu-devel] [PATCH v4 21/22] vhost-user-test: add live-migration test marcandre.lureau
@ 2015-09-19 10:12 ` marcandre.lureau
21 siblings, 0 replies; 41+ messages in thread
From: marcandre.lureau @ 2015-09-19 10:12 UTC (permalink / raw)
To: qemu-devel
Cc: haifeng.lin, mst, thibaut.collet, jasowang, pbonzini,
Marc-André Lureau
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Check that backend source and destination do not have simultaneous
ownership during migration.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/vhost-user-test.c | 38 ++++++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/tests/vhost-user-test.c b/tests/vhost-user-test.c
index dcc14bf..f78483d 100644
--- a/tests/vhost-user-test.c
+++ b/tests/vhost-user-test.c
@@ -371,6 +371,10 @@ static void chr_read(void *opaque, const uint8_t *buf, int size)
g_cond_signal(s->data_cond);
break;
+ case VHOST_USER_RESET_OWNER:
+ s->fds_num = 0;
+ break;
+
default:
break;
}
@@ -502,12 +506,37 @@ static guint64 get_log_size(TestServer *s)
return log_size;
}
+typedef struct TestMigrateSource {
+ GSource source;
+ TestServer *src;
+ TestServer *dest;
+} TestMigrateSource;
+
+static gboolean
+test_migrate_source_check(GSource *source)
+{
+ TestMigrateSource *t = (TestMigrateSource *)source;
+ gboolean overlap = t->src->fds_num > 0 && t->dest->fds_num > 0;
+
+ g_assert(!overlap);
+
+ return FALSE;
+}
+
+GSourceFuncs test_migrate_source_funcs = {
+ NULL,
+ test_migrate_source_check,
+ NULL,
+ NULL
+};
+
static void test_migrate(void)
{
TestServer *s = test_server_new("src");
TestServer *dest = test_server_new("dest");
const char *uri = "tcp:127.0.0.1:1234";
QTestState *global = global_qtest, *from, *to;
+ GSource *source;
gchar *cmd;
QDict *rsp;
guint8 *log;
@@ -525,6 +554,12 @@ static void test_migrate(void)
to = qtest_init(cmd);
g_free(cmd);
+ source = g_source_new(&test_migrate_source_funcs,
+ sizeof(TestMigrateSource));
+ ((TestMigrateSource *)source)->src = s;
+ ((TestMigrateSource *)source)->dest = dest;
+ g_source_attach(source, NULL);
+
/* slow down migration to have time to fiddle with log */
/* TODO: qtest could learn to break on some places */
rsp = qmp("{ 'execute': 'migrate_set_speed',"
@@ -563,6 +598,9 @@ static void test_migrate(void)
read_guest_mem(dest);
+ g_source_destroy(source);
+ g_source_unref(source);
+
qtest_quit(to);
test_server_free(dest);
qtest_quit(from);
--
2.4.3
^ permalink raw reply related [flat|nested] 41+ messages in thread