vhost-user block device backend implementation
Subsystems (2)
v10 cover vhost-user block device backend implementation
v10
- Use a linked list of VuFdWatch objects to keep kick info [Stefan]
- Merge improvements and fixes from Stefan
- Rename libvhost-user's vu_message_read to vu_message_read_default [Kevin]
- When shutting down the client, wait for the coroutine of processing vhost-user messages to be finished [Kevin]
- Allocate struct req_data on the heap [Kevin]
- Improve coding of qtest case [Thomas]
- Fix several memory leaks detected by ASAN
v9
- move logical block size check function to a utility function
- fix issues regarding license, coding style, memory deallocation, etc.
v8
- re-try connecting to socket server to fix asan error
- fix license naming issue
v7
- fix docker-test-debug@fedora errors by freeing malloced memory
v6
- add missing license header and include guard
- vhost-user server only serve one client one time
- fix a bug in custom vu_message_read
- using qemu-storage-daemon to start vhost-user-blk-server
- a bug fix to pass docker-test-clang@ubuntu
v5:
* re-use vu_kick_cb in libvhost-user
* keeping processing VhostUserMsg in the same coroutine until there is detachment/attachment of AIOContext
* Spawn separate coroutine for each VuVirtqElement
* Other changes including relocating vhost-user-blk-server.c, coding style etc.
v4:
* add object properties in class_init
* relocate vhost-user-blk-test
* other changes including using SocketAddress, coding style, etc.
v3:
* separate generic vhost-user-server code from vhost-user-blk-server code
* re-write vu_message_read and kick hander function as coroutines to directly call blk_co_preadv, blk_co_pwritev, etc.
* add aio_context notifier functions to support multi-threading model
* other fixes regarding coding style, warning report, etc.
v2:
* Only enable this feature for Linux because eventfd is a Linux-specific feature
This patch series is an implementation of vhost-user block device backend server, thanks to Stefan and Kevin's guidance.
Vhost-user block device backend server is a UserCreatable object and can be started using object_add,
(qemu) object_add vhost-user-blk-server,id=ID,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512 (qemu) object_del ID
or appending the "-object" option when starting QEMU,
$ -object vhost-user-blk-server,id=disk,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512
Then vhost-user client can connect to the server backend. For example, QEMU could act as a client,
$ -m 256 -object memory-backend-memfd,id=mem,size=256M,share=on -numa node,memdev=mem -chardev socket,id=char1,path=/tmp/vhost-user-blk_vhost.socket -device vhost-user-blk-pci,id=blk0,chardev=char1
And guest OS could access this vhost-user block device after mounting it.
Coiby Xu (7):
libvhost-user: Allow vu_message_read to be replaced
libvhost-user: remove watch for kick_fd when de-initialize vu-dev util/vhost-user-server: generic vhost user server
block: move logical block size check function to a common utility
function
block/export: vhost-user block device backend server
test: new qTest case to test the vhost-user-blk-server
MAINTAINERS: Add vhost-user block device backend server maintainer
MAINTAINERS | 8 + block/export/vhost-user-blk-server.c | 661 ++++++++++++++++++ block/export/vhost-user-blk-server.h | 36 + block/meson.build | 1 + contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 15 +- contrib/libvhost-user/libvhost-user.h | 21 + hw/core/qdev-properties.c | 31 +- softmmu/vl.c | 4 + tests/qtest/libqos/libqtest.h | 17 + tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/vhost-user-blk.c | 129 ++++ tests/qtest/libqos/vhost-user-blk.h | 48 ++ tests/qtest/libqtest.c | 36 +- tests/qtest/meson.build | 4 +- tests/qtest/vhost-user-blk-test.c | 751 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 + tools/virtiofsd/fuse_virtio.c | 4 +- util/block-helpers.c | 46 ++ util/block-helpers.h | 19 + util/meson.build | 2 + util/vhost-user-server.c | 428 ++++++++++++ util/vhost-user-server.h | 65 ++ 23 files changed, 2292 insertions(+), 39 deletions(-) create mode 100644 block/export/vhost-user-blk-server.c create mode 100644 block/export/vhost-user-blk-server.h create mode 100644 tests/qtest/libqos/vhost-user-blk.c create mode 100644 tests/qtest/libqos/vhost-user-blk.h create mode 100644 tests/qtest/vhost-user-blk-test.c create mode 100644 util/block-helpers.c create mode 100644 util/block-helpers.h create mode 100644 util/vhost-user-server.c create mode 100644 util/vhost-user-server.h
--
2.28.0
PATCH v10 1/7 libvhost-user: Allow vu_message_read to be replaced
Allow vu_message_read to be replaced by one which will make use of the QIOChannel functions. Thus reading vhost-user message won't stall the guest. For slave channel, we still use the default vu_message_read.
--- contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 14 +++++++------- contrib/libvhost-user/libvhost-user.h | 21 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 ++ tools/virtiofsd/fuse_virtio.c | 4 ++-- 5 files changed, 33 insertions(+), 10 deletions(-)
contrib/libvhost-user/libvhost-user-glib.c +1 -1
@@ -147,7 +147,7 @@ vug_init(VugDev *dev, uint16_t max_queues, int socket,g_assert (dev);g_assert (iface); -if (!vu_init (&dev->parent, max_queues, socket, panic, set_watch, +if (!vu_init (&dev->parent, max_queues, socket, panic,NULL , set_watch, remove_watch, iface)) {return false; }
contrib/libvhost-user/libvhost-user.c +7 -7
@@ -67,8 +67,6 @@/* The version of inflight buffer */ #define INFLIGHT_VERSION 1 -#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) -/* The version of the protocol we support */ #define VHOST_USER_VERSION 1#define LIBVHOST_USER_DEBUG 0
@@ -267,7 +265,7 @@ have_userfault(void) }static bool -vu_message_read (VuDev *dev,int conn_fd,VhostUserMsg *vmsg) +vu_message_read_default (VuDev *dev,int conn_fd,VhostUserMsg *vmsg) {char control[CMSG_SPACE (VHOST_MEMORY_BASELINE_NREGIONS *sizeof (int ))] = {};struct iovec iov = {
@@ -415,7 +413,7 @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg) goto out; } -if (!vu_message_read (dev, dev->slave_fd, &msg_reply)) { +if (!vu_message_read_default (dev, dev->slave_fd, &msg_reply)) { goto out; }
@@ -898,7 +896,7 @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)/* Wait for QEMU to confirm that it's registered the handler for the * faults. */ -if (!vu_message_read (dev, dev->sock, vmsg) || +if (!dev->read_msg (dev, dev->sock, vmsg) || vmsg->size !=sizeof (vmsg->payload.u64) || vmsg->payload.u64 !=0 ) {vu_panic (dev,"failed to receive valid ack for postcopy set-mem-table" );
@@ -1860,7 +1858,7 @@ vu_dispatch(VuDev *dev)int reply_requested;bool need_reply, success = false; -if (!vu_message_read (dev, dev->sock, &vmsg)) { +if (!dev->read_msg (dev, dev->sock, &vmsg)) { goto end; }
@@ -1958,6 +1956,7 @@ vu_init(VuDev *dev,uint16_t max_queues, int socket, vu_panic_cb panic, + vu_read_msg_cb read_msg, vu_set_watch_cb set_watch, vu_remove_watch_cb remove_watch, const VuDevIface *iface)
@@ -1975,6 +1974,7 @@ vu_init(VuDev *dev, dev->sock = socket; dev->panic = panic; + dev->read_msg = read_msg ? read_msg : vu_message_read_default; dev->set_watch = set_watch; dev->remove_watch = remove_watch; dev->iface = iface;
@@ -2340,7 +2340,7 @@ static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync)vu_message_write (dev, dev->slave_fd, &vmsg);if (ack) { -vu_message_read (dev, dev->slave_fd, &vmsg); +vu_message_read_default (dev, dev->slave_fd, &vmsg); }return ; }
contrib/libvhost-user/libvhost-user.h +21 -0
@@ -36,6 +36,8 @@*/ #define VHOST_USER_MAX_RAM_SLOTS 32 +#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64) + typedef enum VhostSetConfigType { VHOST_SET_CONFIG_TYPE_MASTER = 0, VHOST_SET_CONFIG_TYPE_MIGRATION = 1,
@@ -221,6 +223,7 @@ typedef uint64_t (*vu_get_features_cb) (VuDev *dev);typedef void (*vu_set_features_cb ) (VuDev *dev,uint64_t features);typedef int (*vu_process_msg_cb ) (VuDev *dev,VhostUserMsg *vmsg,int *do_reply); +typedef bool (*vu_read_msg_cb ) (VuDev *dev,int sock,VhostUserMsg *vmsg);typedef void (*vu_queue_set_started_cb ) (VuDev *dev,int qidx,bool started);typedef bool (*vu_queue_is_processed_in_order_cb ) (VuDev *dev,int qidx);typedef int (*vu_get_config_cb ) (VuDev *dev,uint8_t *config,uint32_t len);
@@ -389,6 +392,23 @@ struct VuDev {bool broken;uint16_t max_queues; +/* @read_msg: custom method to read vhost-user message +* +* Read data from vhost_user socket fd and fill up +* the passed VhostUserMsg *vmsg struct. +* +* If reading fails, it should close the received set of file +* descriptors as socket message's auxiliary data. +* +* For the details, please refer to vu_message_read in libvhost-user.c +* which will be used by default if not custom method is provided when +* calling vu_init +* +* Returns: true if vhost-user message successfully received, +* otherwise return false. +* +*/ +vu_read_msg_cb read_msg;/* @set_watch: add or update the given fd to the watch set, * call cb when condition is met */ vu_set_watch_cb set_watch;
@@ -432,6 +452,7 @@ bool vu_init(VuDev *dev,uint16_t max_queues, int socket, vu_panic_cb panic, + vu_read_msg_cb read_msg, vu_set_watch_cb set_watch, vu_remove_watch_cb remove_watch, const VuDevIface *iface);
tests/vhost-user-bridge.c +2 -0
@@ -520,6 +520,7 @@ vubr_accept_cb(int sock, void *ctx)VHOST_USER_BRIDGE_MAX_QUEUES , conn_fd, vubr_panic, +NULL , vubr_set_watch, vubr_remove_watch, &vuiface)) {
@@ -573,6 +574,7 @@ vubr_new(const char *path, bool client)VHOST_USER_BRIDGE_MAX_QUEUES , dev->sock, vubr_panic, +NULL , vubr_set_watch, vubr_remove_watch, &vuiface)) {
tools/virtiofsd/fuse_virtio.c +2 -2
@@ -996,8 +996,8 @@ int virtio_session_mount(struct fuse_session *se) se->vu_socketfd = data_sock; se->virtio_dev->se = se;pthread_rwlock_init (&se->virtio_dev->vu_dispatch_rwlock,NULL ); -vu_init (&se->virtio_dev->dev,2 , se->vu_socketfd, fv_panic, fv_set_watch, - fv_remove_watch, &fv_iface); +vu_init (&se->virtio_dev->dev,2 , se->vu_socketfd, fv_panic,NULL , + fv_set_watch, fv_remove_watch, &fv_iface);return 0 ; }
Signature · 1 line
2.28.0
Re: [PATCH v10 1/7] libvhost-user: Allow vu_message_read to be replaced
Quoted 6 lines · Coiby Xu
Allow
vu_message_readto be replaced by one which will make use of the QIOChannel functions. Thus reading vhost-user message won't stall the guest. For slave channel, we still use the defaultvu_message_read.Reviewed-by Marc-André Lureau <[email protected]>Signed-off-by Coiby Xu <[email protected]>
Quoted 7 lines
--- contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 14 +++++++------- contrib/libvhost-user/libvhost-user.h | 21 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 ++ tools/virtiofsd/fuse_virtio.c | 4 ++-- 5 files changed, 33 insertions(+), 10 deletions(-)
PATCH v10 2/7 libvhost-user: remove watch for kick_fd when de-initialize vu-dev
In reply to Coiby XuWhen the client is running in gdb and quit command is run in gdb, QEMU will still dispatch the event which will cause segment fault in the callback function.
--- contrib/libvhost-user/libvhost-user.c | 1 + 1 file changed, 1 insertion(+)
contrib/libvhost-user/libvhost-user.c +1 -0
@@ -1909,6 +1909,7 @@ vu_deinit(VuDev *dev) }if (vq->kick_fd !=-1 ) { + dev->remove_watch (dev, vq->kick_fd);close (vq->kick_fd); vq->kick_fd =-1 ; }
Signature · 1 line
2.28.0
Re: [PATCH v10 2/7] libvhost-user: remove watch for kick_fd when de-initialize vu-dev
Quoted 8 lines · Coiby Xu
When the client is running in gdb and quit command is run in gdb, QEMU will still dispatch the event which will cause segment fault in the callback function.
Signed-off-by Coiby Xu <[email protected]>--- contrib/libvhost-user/libvhost-user.c | 1 + 1 file changed, 1 insertion(+)
PATCH v10 3/7 util/vhost-user-server: generic vhost user server
In reply to Coiby XuSharing QEMU devices via vhost-user protocol.
Only one vhost-user client can connect to the server one time.
--- util/meson.build | 1 + util/vhost-user-server.c | 428 +++++++++++++++++++++++++++++++++++++++ util/vhost-user-server.h | 65 ++++++ 3 files changed, 494 insertions(+) create mode 100644 util/vhost-user-server.c create mode 100644 util/vhost-user-server.h
util/meson.build +1 -0
@@ -66,6 +66,7 @@ if have_block util_ss.add(files('main-loop.c')) util_ss.add(files('nvdimm-utils.c')) util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c')) + util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c')) util_ss.add(files('qemu-coroutine-sleep.c')) util_ss.add(files('qemu-co-shared-resource.c')) util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
util/vhost-user-server.c new file +428 -0
428 lines not on this page · raw message
util/vhost-user-server.h new file +65 -0
65 lines not on this page · raw message
Signature · 1 line
2.28.0
PATCH v10 4/7 block: move logical block size check function to a common utility function
In reply to Coiby XuMove the constants from hw/core/qdev-properties.c to util/block-helpers.h so that knowledge of the min/max values is
--- hw/core/qdev-properties.c | 31 +++++--------------------- util/block-helpers.c | 46 +++++++++++++++++++++++++++++++++++++++ util/block-helpers.h | 19 ++++++++++++++++ util/meson.build | 1 + 4 files changed, 71 insertions(+), 26 deletions(-) create mode 100644 util/block-helpers.c create mode 100644 util/block-helpers.h
hw/core/qdev-properties.c +5 -26
@@ -16,6 +16,7 @@#include "qemu/uuid.h" #include "qemu/units.h" #include "qemu/cutils.h" +#include "util/block-helpers.h" void qdev_prop_set_after_realize (DeviceState *dev,const char *name,Error **errp)
@@ -851,16 +852,6 @@ const PropertyInfo qdev_prop_size32 = {/* --- blocksize --- */ -/* lower limit is sector size */ -#define MIN_BLOCK_SIZE 512 -#define MIN_BLOCK_SIZE_STR "512 B" -/* -* upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and -* matches qcow2 cluster size limit -*/ -#define MAX_BLOCK_SIZE (2 * MiB) -#define MAX_BLOCK_SIZE_STR "2 MiB" -static void set_blocksize (Object *obj,Visitor *v,const char *name,void *opaque,Error **errp) {
@@ -868,6 +859,7 @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,Property *prop = opaque;uint32_t *ptr =qdev_get_prop_ptr (dev, prop);uint64_t value; +Error *local_err =NULL ;if (dev->realized) {qdev_prop_set_after_realize (dev, name, errp);
@@ -877,24 +869,11 @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,if (!visit_type_size (v, name, &value, errp)) {return ; } -/* value of 0 means "unset" */ -if (value && (value <MIN_BLOCK_SIZE || value >MAX_BLOCK_SIZE )) { -error_setg (errp, -"Property %s.%s doesn't take value %" PRIu64 -" (minimum: " MIN_BLOCK_SIZE_STR -", maximum: " MAX_BLOCK_SIZE_STR ")" , - dev->id ? :"" , name, value); -return ; - } - -/* We rely on power-of-2 blocksizes for bitmasks */ -if ((value & (value -1 )) !=0 ) { -error_setg (errp, -"Property %s.%s doesn't take value '%" PRId64"', it's not a power of 2" , - dev->id ?:"" , name, (int64_t )value); +check_block_size (dev->id ? :"" , name, value, &local_err); +if (local_err) { +error_propagate (errp, local_err);return ; } - *ptr = value; }
util/block-helpers.c new file +46 -0
46 lines not on this page · raw message
util/block-helpers.h new file +19 -0
@@ -0,0 +1,19 @@ +#ifndef BLOCK_HELPERS_H +#define BLOCK_HELPERS_H + +#include "qemu/units.h" + +/* lower limit is sector size */ +#define MIN_BLOCK_SIZE INT64_C(512) +#define MIN_BLOCK_SIZE_STR "512 B" +/* +* upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and +* matches qcow2 cluster size limit +*/ +#define MAX_BLOCK_SIZE (2 * MiB) +#define MAX_BLOCK_SIZE_STR "2 MiB" + +void check_block_size (const char *id,const char *name,int64_t value, +Error **errp); + +#endif /* BLOCK_HELPERS_H */
util/meson.build +1 -0
@@ -67,6 +67,7 @@ if have_block util_ss.add(files('nvdimm-utils.c')) util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c')) util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c')) + util_ss.add(files('block-helpers.c')) util_ss.add(files('qemu-coroutine-sleep.c')) util_ss.add(files('qemu-co-shared-resource.c')) util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
Signature · 1 line
2.28.0
Re: [PATCH v10 4/7] block: move logical block size check function to a common utility function
Quoted 5 lines · Coiby Xu
Move the constants from
hw/core/qdev-properties.ctoutil/block-helpers.hso that knowledge of the min/max values isSigned-off-by Stefan Hajnoczi <[email protected]>Signed-off-by Coiby Xu <[email protected]>
Signature · 1 line
Eduardo
PATCH v10 5/7 block/export: vhost-user block device backend server
In reply to Coiby XuBy making use of libvhost-user, block device drive can be shared to the connected vhost-user client. Only one client can connect to the server one time.
Since vhost-user-server needs a block drive to be created first, delay the creation of this object.
--- block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++ block/export/vhost-user-blk-server.h | 36 ++ block/meson.build | 1 + softmmu/vl.c | 4 + 4 files changed, 702 insertions(+) create mode 100644 block/export/vhost-user-blk-server.c create mode 100644 block/export/vhost-user-blk-server.h
block/export/vhost-user-blk-server.c new file +661 -0
@@ -0,0 +1,661 @@ +/* +* Sharing QEMU block devices via vhost-user protocal +* +* Parts of the code based on nbd/server.c. +* +* Copyright (c) Coiby Xu <[email protected]>. +* Copyright (c) 2020 Red Hat, Inc. +* +* This work is licensed under the terms of the GNU GPL, version 2 or +* later. See the COPYING file in the top-level directory. +*/ +#include "qemu/osdep.h" +#include "block/block.h" +#include "vhost-user-blk-server.h" +#include "qapi/error.h" +#include "qom/object_interfaces.h" +#include "sysemu/block-backend.h" +#include "util/block-helpers.h" + +enum { +VHOST_USER_BLK_MAX_QUEUES =1 , +}; +struct virtio_blk_inhdr { +unsigned char status; +}; + +typedef struct VuBlockReq { +VuVirtqElement *elem; +int64_t sector_num; +size_t size; +struct virtio_blk_inhdr *in; +struct virtio_blk_outhdr out; +VuServer *server; +struct VuVirtq *vq; +}VuBlockReq ; + +static void vu_block_req_complete (VuBlockReq *req) +{ +VuDev *vu_dev = &req->server->vu_dev; + +/* IO size with 1 extra status byte */ +vu_queue_push (vu_dev, req->vq, req->elem, req->size +1 ); +vu_queue_notify (vu_dev, req->vq); + +if (req->elem) { +free (req->elem); + } + +g_free (req); +} + +static VuBlockDev *get_vu_block_device_by_server (VuServer *server) +{ +return container_of (server, VuBlockDev, vu_server); +} + +static int coroutine_fn +vu_block_discard_write_zeroes (VuBlockReq *req,struct iovec *iov, +uint32_t iovcnt,uint32_t type) +{ +struct virtio_blk_discard_write_zeroes desc; +ssize_t size =iov_to_buf (iov, iovcnt,0 , &desc,sizeof (desc)); +if (unlikely (size !=sizeof (desc))) { +error_report ("Invalid size %ld, expect %ld" , size,sizeof (desc)); +return -EINVAL ; + } + +VuBlockDev *vdev_blk =get_vu_block_device_by_server (req->server); +uint64_t range[2 ] = {le64_to_cpu (desc.sector) <<9 , +le32_to_cpu (desc.num_sectors) <<9 }; +if (type ==VIRTIO_BLK_T_DISCARD ) { +if (blk_co_pdiscard (vdev_blk->backend, range[0 ], range[1 ]) ==0 ) { +return 0 ; + } + }else if (type ==VIRTIO_BLK_T_WRITE_ZEROES ) { +if (blk_co_pwrite_zeroes (vdev_blk->backend, + range[0 ], range[1 ],0 ) ==0 ) { +return 0 ; + } + } + +return -EINVAL ; +} + +static void coroutine_fn vu_block_flush(VuBlockReq *req) +{ +VuBlockDev *vdev_blk =get_vu_block_device_by_server (req->server); +BlockBackend *backend = vdev_blk->backend; +blk_co_flush (backend); +} + +struct req_data { +VuServer *server; +VuVirtq *vq; +VuVirtqElement *elem; +}; + +static void coroutine_fn vu_block_virtio_process_req(void *opaque) +{ +struct req_data *data = opaque; +VuServer *server = data->server; +VuVirtq *vq = data->vq; +VuVirtqElement *elem = data->elem; +uint32_t type; +VuBlockReq *req; + +VuBlockDev *vdev_blk =get_vu_block_device_by_server (server); +BlockBackend *backend = vdev_blk->backend; + +struct iovec *in_iov = elem->in_sg; +struct iovec *out_iov = elem->out_sg; +unsigned in_num = elem->in_num; +unsigned out_num = elem->out_num; +/* refer to hw/block/virtio_blk.c */ +if (elem->out_num <1 || elem->in_num <1 ) { +error_report ("virtio-blk request missing headers" ); +free (elem); +return ; + } + + req =g_new0 (VuBlockReq,1 ); + req->server = server; + req->vq = vq; + req->elem = elem; + +if (unlikely (iov_to_buf (out_iov, out_num,0 , &req->out, +sizeof (req->out)) !=sizeof (req->out))) { +error_report ("virtio-blk request outhdr too short" ); + goto err; + } + +iov_discard_front (&out_iov, &out_num,sizeof (req->out)); + +if (in_iov[in_num -1 ].iov_len <sizeof (struct virtio_blk_inhdr )) { +error_report ("virtio-blk request inhdr too short" ); + goto err; + } + +/* We always touch the last byte, so just see how big in_iov is. */ + req->in = (void *)in_iov[in_num -1 ].iov_base + + in_iov[in_num -1 ].iov_len + -sizeof (struct virtio_blk_inhdr ); +iov_discard_back (in_iov, &in_num,sizeof (struct virtio_blk_inhdr )); + + type =le32_to_cpu (req->out.type); +switch (type & ~VIRTIO_BLK_T_BARRIER ) { +case VIRTIO_BLK_T_IN : +case VIRTIO_BLK_T_OUT : { +ssize_t ret =0 ; +bool is_write = type &VIRTIO_BLK_T_OUT ; + req->sector_num =le64_to_cpu (req->out.sector); + +int64_t offset = req->sector_num * vdev_blk->blk_size; +QEMUIOVector qiov; +if (is_write) { +qemu_iovec_init_external (&qiov, out_iov, out_num); + ret =blk_co_pwritev (backend, offset, qiov.size, + &qiov,0 ); + }else { +qemu_iovec_init_external (&qiov, in_iov, in_num); + ret =blk_co_preadv (backend, offset, qiov.size, + &qiov,0 ); + } +if (ret >=0 ) { + req->in->status =VIRTIO_BLK_S_OK ; + }else { + req->in->status =VIRTIO_BLK_S_IOERR ; + } +break ; + } +case VIRTIO_BLK_T_FLUSH : +vu_block_flush (req); + req->in->status =VIRTIO_BLK_S_OK ; +break ; +case VIRTIO_BLK_T_GET_ID : { +size_t size =MIN (iov_size (&elem->in_sg[0 ], in_num), +VIRTIO_BLK_ID_BYTES ); +snprintf (elem->in_sg[0 ].iov_base, size,"%s" ,"vhost_user_blk_server" ); + req->in->status =VIRTIO_BLK_S_OK ; + req->size = elem->in_sg[0 ].iov_len; +break ; + } +case VIRTIO_BLK_T_DISCARD : +case VIRTIO_BLK_T_WRITE_ZEROES : { +int rc; + rc =vu_block_discard_write_zeroes (req, &elem->out_sg[1 ], + out_num, type); +if (rc ==0 ) { + req->in->status =VIRTIO_BLK_S_OK ; + }else { + req->in->status =VIRTIO_BLK_S_IOERR ; + } +break ; + } +default : + req->in->status =VIRTIO_BLK_S_UNSUPP ; +break ; + } + +vu_block_req_complete (req); +return ; + +err: +free (elem); +g_free (req); +return ; +} + +static void vu_block_process_vq (VuDev *vu_dev,int idx) +{ +VuServer *server; +VuVirtq *vq; +struct req_data *req_data; + + server =container_of (vu_dev, VuServer, vu_dev); +assert (server); + + vq =vu_get_queue (vu_dev, idx); +assert (vq); +VuVirtqElement *elem; +while (1 ) { + elem =vu_queue_pop (vu_dev, vq,sizeof (VuVirtqElement) + +sizeof (VuBlockReq)); +if (elem) { + req_data = g_new0(struct req_data, 1); + req_data->server = server; + req_data->vq = vq; + req_data->elem = elem; +Coroutine *co =qemu_coroutine_create (vu_block_virtio_process_req, + req_data); +aio_co_enter (server->ioc->ctx, co); + }else { +break ; + } + } +} + +static void vu_block_queue_set_started (VuDev *vu_dev,int idx,bool started) +{ +VuVirtq *vq; + +assert (vu_dev); + + vq =vu_get_queue (vu_dev, idx); +vu_set_queue_handler (vu_dev, vq, started ? vu_block_process_vq :NULL ); +} + +static uint64_t vu_block_get_features (VuDev *dev) +{ +uint64_t features; +VuServer *server =container_of (dev, VuServer, vu_dev); +VuBlockDev *vdev_blk =get_vu_block_device_by_server (server); + features =1ull <<VIRTIO_BLK_F_SIZE_MAX | +1ull <<VIRTIO_BLK_F_SEG_MAX | +1ull <<VIRTIO_BLK_F_TOPOLOGY | +1ull <<VIRTIO_BLK_F_BLK_SIZE | +1ull <<VIRTIO_BLK_F_FLUSH | +1ull <<VIRTIO_BLK_F_DISCARD | +1ull <<VIRTIO_BLK_F_WRITE_ZEROES | +1ull <<VIRTIO_BLK_F_CONFIG_WCE | +1ull <<VIRTIO_F_VERSION_1 | +1ull <<VIRTIO_RING_F_INDIRECT_DESC | +1ull <<VIRTIO_RING_F_EVENT_IDX | +1ull <<VHOST_USER_F_PROTOCOL_FEATURES ; + +if (!vdev_blk->writable) { + features |=1ull <<VIRTIO_BLK_F_RO ; + } + +return features; +} + +static uint64_t vu_block_get_protocol_features (VuDev *dev) +{ +return 1ull <<VHOST_USER_PROTOCOL_F_CONFIG | +1ull <<VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD ; +} + +static int +vu_block_get_config (VuDev *vu_dev,uint8_t *config,uint32_t len) +{ +VuServer *server =container_of (vu_dev, VuServer, vu_dev); +VuBlockDev *vdev_blk =get_vu_block_device_by_server (server); +memcpy (config, &vdev_blk->blkcfg, len); + +return 0 ; +} + +static int +vu_block_set_config (VuDev *vu_dev,const uint8_t *data, +uint32_t offset,uint32_t size,uint32_t flags) +{ +VuServer *server =container_of (vu_dev, VuServer, vu_dev); +VuBlockDev *vdev_blk =get_vu_block_device_by_server (server); +uint8_t wce; + +/* don't support live migration */ +if (flags !=VHOST_SET_CONFIG_TYPE_MASTER ) { +return -EINVAL ; + } + +if (offset != offsetof(struct virtio_blk_config , wce) || + size !=1 ) { +return -EINVAL ; + } + + wce = *data; + vdev_blk->blkcfg.wce = wce; +blk_set_enable_write_cache (vdev_blk->backend, wce); +return 0 ; +} + +/* +* When the client disconnects, it sends a VHOST_USER_NONE request +* and vu_process_message will simple call exit which cause the VM +* to exit abruptly. +* To avoid this issue, process VHOST_USER_NONE request ahead +* of vu_process_message. +* +*/ +static int vu_block_process_msg (VuDev *dev,VhostUserMsg *vmsg,int *do_reply) +{ +if (vmsg->request ==VHOST_USER_NONE ) { + dev->panic (dev,"disconnect" ); +return true; + } +return false; +} + +static const VuDevIface vu_block_iface = { + .get_features = vu_block_get_features, + .queue_set_started = vu_block_queue_set_started, + .get_protocol_features = vu_block_get_protocol_features, + .get_config = vu_block_get_config, + .set_config = vu_block_set_config, + .process_msg = vu_block_process_msg, +}; + +static void blk_aio_attached (AioContext *ctx,void *opaque) +{ +VuBlockDev *vub_dev = opaque; +aio_context_acquire (ctx); +vhost_user_server_set_aio_context (&vub_dev->vu_server, ctx); +aio_context_release (ctx); +} + +static void blk_aio_detach (void *opaque) +{ +VuBlockDev *vub_dev = opaque; +AioContext *ctx = vub_dev->vu_server.ctx; +aio_context_acquire (ctx); +vhost_user_server_set_aio_context (&vub_dev->vu_server,NULL ); +aio_context_release (ctx); +} + +static void +vu_block_initialize_config (BlockDriverState *bs, +struct virtio_blk_config *config,uint32_t blk_size) +{ + config->capacity =bdrv_getlength (bs) >>BDRV_SECTOR_BITS ; + config->blk_size = blk_size; + config->size_max =0 ; + config->seg_max =128 -2 ; + config->min_io_size =1 ; + config->opt_io_size =1 ; + config->num_queues =VHOST_USER_BLK_MAX_QUEUES ; + config->max_discard_sectors =32768 ; + config->max_discard_seg =1 ; + config->discard_sector_alignment = config->blk_size >>9 ; + config->max_write_zeroes_sectors =32768 ; + config->max_write_zeroes_seg =1 ; +} + +static VuBlockDev *vu_block_init (VuBlockDev *vu_block_device,Error **errp) +{ + +BlockBackend *blk; +Error *local_error =NULL ; +const char *node_name = vu_block_device->node_name; +bool writable = vu_block_device->writable; +uint64_t perm =BLK_PERM_CONSISTENT_READ ; +int ret; + +AioContext *ctx; + +BlockDriverState *bs =bdrv_lookup_bs (node_name, node_name, &local_error); + +if (!bs) { +error_propagate (errp, local_error); +return NULL ; + } + +if (bdrv_is_read_only (bs)) { + writable = false; + } + +if (writable) { + perm |=BLK_PERM_WRITE ; + } + + ctx =bdrv_get_aio_context (bs); +aio_context_acquire (ctx); +bdrv_invalidate_cache (bs,NULL ); +aio_context_release (ctx); + +/* +* Don't allow resize while the vhost user server is running, +* otherwise we don't care what happens with the node. +*/ + blk =blk_new (bdrv_get_aio_context (bs), perm, +BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE_UNCHANGED | +BLK_PERM_WRITE |BLK_PERM_GRAPH_MOD ); + ret =blk_insert_bs (blk, bs, errp); + +if (ret <0 ) { + goto fail; + } + +blk_set_enable_write_cache (blk, false); + +blk_set_allow_aio_context_change (blk, true); + + vu_block_device->blkcfg.wce =0 ; + vu_block_device->backend = blk; +if (!vu_block_device->blk_size) { + vu_block_device->blk_size =BDRV_SECTOR_SIZE ; + } + vu_block_device->blkcfg.blk_size = vu_block_device->blk_size; +blk_set_guest_block_size (blk, vu_block_device->blk_size); +vu_block_initialize_config (bs, &vu_block_device->blkcfg, + vu_block_device->blk_size); +return vu_block_device; + +fail: +blk_unref (blk); +return NULL ; +} + +static void vu_block_deinit (VuBlockDev *vu_block_device) +{ +if (vu_block_device->backend) { +blk_remove_aio_context_notifier (vu_block_device->backend, blk_aio_attached, + blk_aio_detach, vu_block_device); + } + +blk_unref (vu_block_device->backend); +} + +static void vhost_user_blk_server_stop (VuBlockDev *vu_block_device) +{ +vhost_user_server_stop (&vu_block_device->vu_server); +vu_block_deinit (vu_block_device); +} + +static void vhost_user_blk_server_start (VuBlockDev *vu_block_device, +Error **errp) +{ +AioContext *ctx; +SocketAddress *addr = vu_block_device->addr; + +if (!vu_block_init (vu_block_device, errp)) { +return ; + } + + ctx =bdrv_get_aio_context (blk_bs (vu_block_device->backend)); + +if (!vhost_user_server_start (&vu_block_device->vu_server, addr, ctx, +VHOST_USER_BLK_MAX_QUEUES , +NULL , &vu_block_iface, + errp)) { + goto error; + } + +blk_add_aio_context_notifier (vu_block_device->backend, blk_aio_attached, + blk_aio_detach, vu_block_device); + vu_block_device->running = true; +return ; + + error: +vu_block_deinit (vu_block_device); +} + +static bool vu_prop_modifiable (VuBlockDev *vus,Error **errp) +{ +if (vus->running) { +error_setg (errp,"The property can't be modified " +"while the server is running" ); +return false; + } +return true; +} + +static void vu_set_node_name (Object *obj,const char *value,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); + +if (!vu_prop_modifiable (vus, errp)) { +return ; + } + +if (vus->node_name) { +g_free (vus->node_name); + } + + vus->node_name =g_strdup (value); +} + +static char *vu_get_node_name (Object *obj,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); +return g_strdup (vus->node_name); +} + +static void free_socket_addr (SocketAddress *addr) +{ +g_free (addr->u.q_unix.path); +g_free (addr); +} + +static void vu_set_unix_socket (Object *obj,const char *value, +Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); + +if (!vu_prop_modifiable (vus, errp)) { +return ; + } + +if (vus->addr) { +free_socket_addr (vus->addr); + } + +SocketAddress *addr =g_new0 (SocketAddress,1 ); + addr->type =SOCKET_ADDRESS_TYPE_UNIX ; + addr->u.q_unix.path =g_strdup (value); + vus->addr = addr; +} + +static char *vu_get_unix_socket (Object *obj,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); +return g_strdup (vus->addr->u.q_unix.path); +} + +static bool vu_get_block_writable (Object *obj,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); +return vus->writable; +} + +static void vu_set_block_writable (Object *obj,bool value,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); + +if (!vu_prop_modifiable (vus, errp)) { +return ; + } + + vus->writable = value; +} + +static void vu_get_blk_size (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); +uint32_t value = vus->blk_size; + +visit_type_uint32 (v, name, &value, errp); +} + +static void vu_set_blk_size (Object *obj,Visitor *v,const char *name, +void *opaque,Error **errp) +{ +VuBlockDev *vus =VHOST_USER_BLK_SERVER (obj); + +Error *local_err =NULL ; +uint32_t value; + +if (!vu_prop_modifiable (vus, errp)) { +return ; + } + +visit_type_uint32 (v, name, &value, &local_err); +if (local_err) { + goto out; + } + +check_block_size (object_get_typename (obj), name, value, &local_err); +if (local_err) { + goto out; + } + + vus->blk_size = value; + +out: +error_propagate (errp, local_err); +} + +static void vhost_user_blk_server_instance_finalize (Object *obj) +{ +VuBlockDev *vub =VHOST_USER_BLK_SERVER (obj); + +vhost_user_blk_server_stop (vub); + +/* +* Unlike object_property_add_str, object_class_property_add_str +* doesn't have a release method. Thus manual memory freeing is +* needed. +*/ +free_socket_addr (vub->addr); +g_free (vub->node_name); +} + +static void vhost_user_blk_server_complete (UserCreatable *obj,Error **errp) +{ +VuBlockDev *vub =VHOST_USER_BLK_SERVER (obj); + +vhost_user_blk_server_start (vub, errp); +} + +static void vhost_user_blk_server_class_init (ObjectClass *klass, +void *class_data) +{ +UserCreatableClass *ucc =USER_CREATABLE_CLASS (klass); + ucc->complete = vhost_user_blk_server_complete; + +object_class_property_add_bool (klass,"writable" , + vu_get_block_writable, + vu_set_block_writable); + +object_class_property_add_str (klass,"node-name" , + vu_get_node_name, + vu_set_node_name); + +object_class_property_add_str (klass,"unix-socket" , + vu_get_unix_socket, + vu_set_unix_socket); + +object_class_property_add (klass,"logical-block-size" ,"uint32" , + vu_get_blk_size, vu_set_blk_size, +NULL ,NULL ); +} + +static const TypeInfo vhost_user_blk_server_info = { + .name =TYPE_VHOST_USER_BLK_SERVER , + .parent =TYPE_OBJECT , + .instance_size =sizeof (VuBlockDev), + .instance_finalize = vhost_user_blk_server_instance_finalize, + .class_init = vhost_user_blk_server_class_init, + .interfaces = (InterfaceInfo []) { + {TYPE_USER_CREATABLE }, + {} + }, +}; + +static void vhost_user_blk_server_register_types (void ) +{ +type_register_static (&vhost_user_blk_server_info); +} + +type_init (vhost_user_blk_server_register_types)
block/export/vhost-user-blk-server.h new file +36 -0
@@ -0,0 +1,36 @@ +/* +* Sharing QEMU block devices via vhost-user protocal +* +* Copyright (c) Coiby Xu <[email protected]>. +* Copyright (c) 2020 Red Hat, Inc. +* +* This work is licensed under the terms of the GNU GPL, version 2 or +* later. See the COPYING file in the top-level directory. +*/ + +#ifndef VHOST_USER_BLK_SERVER_H +#define VHOST_USER_BLK_SERVER_H +#include "util/vhost-user-server.h" + +typedef struct VuBlockDev VuBlockDev ; +#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server" +#define VHOST_USER_BLK_SERVER (obj) \ + OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER) + +/* vhost user block device */ +struct VuBlockDev { +Object parent_obj; +char *node_name; +SocketAddress *addr; +AioContext *ctx; +VuServer vu_server; +bool running; +uint32_t blk_size; +BlockBackend *backend; +QIOChannelSocket *sioc; +QTAILQ_ENTRY (VuBlockDev) next; +struct virtio_blk_config blkcfg; +bool writable; +}; + +#endif /* VHOST_USER_BLK_SERVER_H */
block/meson.build +1 -0
@@ -60,6 +60,7 @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c') block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit]) block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c')) block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c')) +block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c')) block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c')) block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c')) block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
softmmu/vl.c +4 -0
@@ -2537,6 +2537,10 @@ static bool object_create_initial(const char *type, QemuOpts *opts) }#endif +/* Reason: vhost-user-blk-server property "node-name" */ +if (g_str_equal (type,"vhost-user-blk-server" )) { +return false; + }/* * Reason: filter-* property "netdev" etc. */
Signature · 1 line
2.28.0
Re: [PATCH v10 5/7] block/export: vhost-user block device backend server
block/export/vhost-user-blk-server.c line 178
Quoted 4 lines · Coiby Xu
block/export/vhost-user-blk-server.c new file +4
-0+case VIRTIO_BLK_T_GET_ID : { +size_t size =MIN (iov_size (&elem->in_sg[0 ], in_num), +VIRTIO_BLK_ID_BYTES ); +snprintf (elem->in_sg[0 ].iov_base, size,"%s" ,"vhost_user_blk_server" );
gcc (GCC) 10.2.1 says:
../block/export/vhost-user-blk-server.c:178:50: error: ‘%s’ directive output truncated writing 21 bytes into a region of size 20 [-Werror=format-truncation=]
178 | snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk_server");
| ^~ ~~~~~~~~~~~~~~~~~~~~~~~I suggest changing this string constant to "vhost_user_blk" for now.
PATCH v10 6/7 test: new qTest case to test the vhost-user-blk-server
In reply to Coiby XuThis test case has the same tests as tests/virtio-blk-test.c except for tests have block_resize. Since vhost-user server can only server one client one time, two instances of vhost-user-blk-server are started by qemu-storage-daemon for the hotplug test.
In order to not block scripts/tap-driver.pl, vhost-user-blk-server will send "quit" command to qemu-storage-daemon's QMP monitor. So a function is added to libqtest.c to establish socket connection with socket server.
--- tests/qtest/libqos/libqtest.h | 17 + tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/vhost-user-blk.c | 129 +++++ tests/qtest/libqos/vhost-user-blk.h | 48 ++ tests/qtest/libqtest.c | 36 +- tests/qtest/meson.build | 4 +- tests/qtest/vhost-user-blk-test.c | 751 ++++++++++++++++++++++++++++ 7 files changed, 983 insertions(+), 3 deletions(-) create mode 100644 tests/qtest/libqos/vhost-user-blk.c create mode 100644 tests/qtest/libqos/vhost-user-blk.h create mode 100644 tests/qtest/vhost-user-blk-test.c
tests/qtest/libqos/libqtest.h +17 -0
@@ -132,6 +132,23 @@ void qtest_qmp_send(QTestState *s, const char *fmt, ...) void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...) GCC_FMT_ATTR(2, 3); +/** +* qtest_socket_client: +* @server_socket_path: the socket server's path +* +* Connect to a socket server. +*/ +int qtest_socket_client (char *server_socket_path); + +/** +* qtest_create_state_with_qmp_fd: +* @fd: socket fd +* +* Wrap socket fd in QTestState to make use of qtest_qmp* +* functions +*/ +QTestState *qtest_create_state_with_qmp_fd (int fd); +/** * qtest_vqmp_fds: * @s: #QTestState instance to operate on.
tests/qtest/libqos/meson.build +1 -0
@@ -32,6 +32,7 @@ libqos_srcs = files('../libqtest.c', 'virtio-9p.c', 'virtio-balloon.c', 'virtio-blk.c', + 'vhost-user-blk.c', 'virtio-mmio.c', 'virtio-net.c', 'virtio-pci.c',
tests/qtest/libqos/vhost-user-blk.c new file +129 -0
129 lines not on this page · raw message
tests/qtest/libqos/vhost-user-blk.h new file +48 -0
48 lines not on this page · raw message
tests/qtest/libqtest.c +34 -2
@@ -4,11 +4,13 @@* Copyright IBM, Corp. 2012 * Copyright Red Hat, Inc. 2012 * Copyright SUSE LINUX Products GmbH 2013 +* Copyright Copyright (c) Coiby Xu * * Authors: * Anthony Liguori <[email protected]> * Paolo Bonzini <[email protected]> * Andreas Färber <[email protected]> +* Coiby Xu <[email protected]> * * This work is licensed under the terms of the GNU GPL, version 2 or later. * See the COPYING file in the top-level directory.
@@ -52,8 +54,7 @@ typedef struct QTestClientTransportOps {QTestRecvFn recv_line;/* for receiving qtest command responses */ } QTestTransportOps; -struct QTestState -{ +struct QTestState {int fd;int qmp_fd;pid_t qemu_pid;/* our child QEMU process */
@@ -608,6 +609,37 @@ QDict *qtest_qmp_receive(QTestState *s)return qmp_fd_receive (s->qmp_fd); } +QTestState *qtest_create_state_with_qmp_fd (int fd) +{ +QTestState *qmp_test_state =g_new0 (QTestState,1 ); + qmp_test_state->qmp_fd = fd; +return qmp_test_state; +} + +int qtest_socket_client (char *server_socket_path) +{ +struct sockaddr_un serv_addr; +int sock; +int ret; +int retries =0 ; + sock =socket (PF_UNIX ,SOCK_STREAM ,0 ); + g_assert_cmpint(sock, !=, -1); + serv_addr.sun_family =AF_UNIX ; +snprintf (serv_addr.sun_path,sizeof (serv_addr.sun_path),"%s" , + server_socket_path); + +for (retries =0 ; retries <3 ; retries++) { + ret =connect (sock, (struct sockaddr *)&serv_addr,sizeof (serv_addr)); +if (ret ==0 ) { +break ; + } +g_usleep (G_USEC_PER_SEC ); + } + + g_assert_cmpint(ret, ==, 0); +return sock; +} +/** * Allow users to send a message without waiting for the reply, * in the case that they choose to discard all replies up until
tests/qtest/meson.build +3 -1
@@ -191,6 +191,7 @@ qos_test_ss.add( ) qos_test_ss.add(when: 'CONFIG_VIRTFS', if_true: files('virtio-9p-test.c')) qos_test_ss.add(when: 'CONFIG_VHOST_USER', if_true: files('vhost-user-test.c')) +qos_test_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-test.c')) extra_qtest_deps = { 'bios-tables-test': [io],
@@ -234,7 +235,8 @@ foreach dir : target_dirs qtest_env.set('QTEST_QEMU_IMG', './qemu-img') qtest_env.set('G_TEST_DBUS_DAEMON', meson.source_root() / 'tests/dbus-vmstate-daemon.sh') qtest_env.set('QTEST_QEMU_BINARY', './qemu-system-' + target_base) - + qtest_env.set('QTEST_QEMU_STORAGE_DAEMON_BINARY', './storage-daemon/qemu-storage-daemon') + foreach test : qtests # Executables are shared across targets, declare them only the first time we # encounter them
tests/qtest/vhost-user-blk-test.c new file +751 -0
751 lines not on this page · raw message
Signature · 1 line
2.28.0
Re: [PATCH v10 6/7] test: new qTest case to test the vhost-user-blk-server
Quoted 9 lines · Coiby Xu
tests/qtest/libqtest.c +9
-0+int qtest_socket_client (char *server_socket_path) +{ +struct sockaddr_un serv_addr; +int sock; +int ret; +int retries =0 ; + sock =socket (PF_UNIX ,SOCK_STREAM ,0 ); + g_assert_cmpint(sock, !=, -1); + serv_addr.sun_family =AF_UNIX ;
tests/qtest/libqtest.c QDict *qtest_qmp_receive(QTestState *s) · line 637
Quoted 10 lines
tests/qtest/libqtest.c +10
-0+snprintf (serv_addr.sun_path,sizeof (serv_addr.sun_path),"%s" , + server_socket_path); + +for (retries =0 ; retries <3 ; retries++) { + ret =connect (sock, (struct sockaddr *)&serv_addr,sizeof (serv_addr)); +if (ret ==0 ) { +break ; + } +g_usleep (G_USEC_PER_SEC ); + }
This is a race condition. On a heavily loaded machine the server might not be available within 3 seconds and the test will fail randomly.
Solutions:
1. Wait output from the server indicating it is ready (e.g. 'Listening on /path/to/foo.sock...') when spawning the server process.
2. Create the listen socket and pass the fd to the server process. This way the socket already exists can the client will block in connect until the server accepts the connection.
3. Create a socketpair. Pass one side to the server and use the other side in the client.
However, I think this is okay for now. After my patch series that converts the vhost-user-blk server to the new block exports API we can consider how to pass file descriptors.
Quoted 4 lines
tests/qtest/vhost-user-blk-test.c new file +4
-0+static void quit_storage_daemon (void *qmp_test_state) +{ +const char quit_str[] ="{ 'execute': 'quit' }" ; +
tests/qtest/vhost-user-blk-test.c line 640
Quoted 10 lines
tests/qtest/vhost-user-blk-test.c new file +10
-0+/* Before quiting storate-daemon, quit qemu to avoid dubious messages */ +qobject_unref (qtest_qmp (global_qtest, quit_str)); + +/* +* Give storage-daemon enough time to wake up&terminate +* vu_client_trip coroutine so the Coroutine object could +* be cleaned up. Otherwise LeakSanitizer would complain +* about memory leaks. +*/ +g_usleep (1000 );
Also a race that may cause random failures. This can be addressed after the block exports API conversion.
Re: [PATCH v10 6/7] test: new qTest case to test the vhost-user-blk-server
Quoted 46 lines · Stefan Hajnoczi
Quoted 9 lines · Coiby Xu
tests/qtest/libqtest.c +9
-0+int qtest_socket_client (char *server_socket_path) +{ +struct sockaddr_un serv_addr; +int sock; +int ret; +int retries =0 ; + sock =socket (PF_UNIX ,SOCK_STREAM ,0 ); + g_assert_cmpint(sock, !=, -1); + serv_addr.sun_family =AF_UNIX ;tests/qtest/libqtest.c QDict *qtest_qmp_receive(QTestState *s) · line 637
Quoted 10 lines
tests/qtest/libqtest.c +10
-0+snprintf (serv_addr.sun_path,sizeof (serv_addr.sun_path),"%s" , + server_socket_path); + +for (retries =0 ; retries <3 ; retries++) { + ret =connect (sock, (struct sockaddr *)&serv_addr,sizeof (serv_addr)); +if (ret ==0 ) { +break ; + } +g_usleep (G_USEC_PER_SEC ); + }This is a race condition. On a heavily loaded machine the server might not be available within 3 seconds and the test will fail randomly.
Solutions:
1. Wait output from the server indicating it is ready (e.g. 'Listening on /path/to/foo.sock...') when spawning the server process.
2. Create the listen socket and pass the fd to the server process. This way the socket already exists can the client will block in connect until the server accepts the connection.
3. Create a socketpair. Pass one side to the server and use the other side in the client.However, I think this is okay for now. After my patch series that converts the vhost-user-blk server to the new block exports API we can consider how to pass file descriptors.
Quoted 9 lines
tests/qtest/vhost-user-blk-test.c new file +9
-0+static void quit_storage_daemon (void *qmp_test_state) +{ +const char quit_str[] ="{ 'execute': 'quit' }" ; + +/* Before quiting storate-daemon, quit qemu to avoid dubious messages */ +qobject_unref (qtest_qmp (global_qtest, quit_str)); + +/* +* Give storage-daemon enough time to wake up&terminate
Quoted 8 lines
tests/qtest/vhost-user-blk-test.c line 640
Quoted 5 lines
tests/qtest/vhost-user-blk-test.c new file +5
-0+* vu_client_trip coroutine so the Coroutine object could +* be cleaned up. Otherwise LeakSanitizer would complain +* about memory leaks. +*/ +g_usleep (1000 );Also a race that may cause random failures. This can be addressed after the block exports API conversion.
Thank you for spotting two race conditions!
--
Best regards,
Coiby
PATCH v10 7/7 MAINTAINERS: Add vhost-user block device backend server maintainer
In reply to Coiby Xu--- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+)
MAINTAINERS +8 -0
@@ -3039,6 +3039,14 @@ L: [email protected] S: Supported F: tests/image-fuzzer/ +Vhost-user block device backend server +M: Coiby Xu <[email protected]> +S: Maintained +F: block/export/vhost-user-blk-server.c +F: util/vhost-user-server.c +F: tests/qtest/vhost-user-blk-test.c +F: tests/qtest/libqos/vhost-user-blk.c + Replication M: Wen Congyang <[email protected]> M: Xie Changlong <[email protected]>
Signature · 1 line
2.28.0
Re: [PATCH v10 7/7] MAINTAINERS: Add vhost-user block device backend server maintainer
Quoted 11 lines · Coiby Xu
Suggested-by Stefano Garzarella <[email protected]>Signed-off-by Coiby Xu <[email protected]>--- MAINTAINERS | 8 ++++++++ 1 file changed, 8 insertions(+)MAINTAINERS +0
-0
MAINTAINERS L: [email protected] · line 3048
Quoted 10 lines
MAINTAINERS +7
-0@@ -3039,6 +3039,14 @@ L: [email protected] S: Supported F: tests/image-fuzzer/ +Vhost-user block device backend server +M: Coiby Xu <[email protected]> +S: Maintained +F: block/export/vhost-user-blk-server.c +F: util/vhost-user-server.c +F: tests/qtest/vhost-user-blk-test.c +F: tests/qtest/libqos/vhost-user-blk.c
I will send a patch to also include the header files and move them to include/.
Quoted 9 lines · Coiby Xu
v10
- Use a linked list of VuFdWatch objects to keep kick info [Stefan]
- Merge improvements and fixes from Stefan
- Rename libvhost-user'svu_message_readtovu_message_read_default[Kevin]
- When shutting down the client, wait for the coroutine of processing vhost-user messages to be finished [Kevin]
- Allocate structreq_dataon the heap [Kevin]
- Improve coding of qtest case [Thomas]
- Fix several memory leaks detected by ASAN
Great, thank you for sending this. I spent Friday looking at the first few patches and running qemu-storage-daemon with this.
I will post a follow-up series with cleanups and port it to the new QAPI block exports API (NBD, FUSE, vhost-user-blk, etc).
Kevin is currently on vacation but will be back soon. If he has no further comments we could merge this.
Stefan
Quoted 9 lines · Coiby Xu
v10
- Use a linked list of VuFdWatch objects to keep kick info [Stefan]
- Merge improvements and fixes from Stefan
- Rename libvhost-user'svu_message_readtovu_message_read_default[Kevin]
- When shutting down the client, wait for the coroutine of processing vhost-user messages to be finished [Kevin]
- Allocate structreq_dataon the heap [Kevin]
- Improve coding of qtest case [Thomas]
- Fix several memory leaks detected by ASAN
Hi,
I have sent a patch series with cleanups and a conversion to the new block exports API:
https://lists.gnu.org/archive/html/qemu-devel/2020-09/msg07946.html
I will do a final review of your series tomorrow. Thanks!
Stefan
Thanks for contributing this feature! I have replied with comments about additional steps I'm taking (fixes, cleanups, etc).
This series looks good:
Stefan Hajnoczi
AppliedQuoted 118 lines · Coiby Xu
v10
- Use a linked list of VuFdWatch objects to keep kick info [Stefan]
- Merge improvements and fixes from Stefan
- Rename libvhost-user'svu_message_readtovu_message_read_default[Kevin]
- When shutting down the client, wait for the coroutine of processing vhost-user messages to be finished [Kevin]
- Allocate structreq_dataon the heap [Kevin]
- Improve coding of qtest case [Thomas]
- Fix several memory leaks detected by ASANv9
- move logical block size check function to a utility function
- fix issues regarding license, coding style, memory deallocation, etc.v8
- re-try connecting to socket server to fix asan error
- fix license naming issuev7
- fix docker-test-debug@fedora errors by freeing malloced memoryv6
- add missing license header and include guard
- vhost-user server only serve one client one time
- fix a bug in customvu_message_read
- using qemu-storage-daemon to start vhost-user-blk-server
- a bug fix to pass docker-test-clang@ubuntuv5:
* re-usevu_kick_cbin libvhost-user
* keeping processing VhostUserMsg in the same coroutine until there is detachment/attachment of AIOContext
* Spawn separate coroutine for each VuVirtqElement
* Other changes including relocatingvhost-user-blk-server.c, coding style etc.v4:
* add object properties inclass_init
* relocate vhost-user-blk-test
* other changes including using SocketAddress, coding style, etc.v3:
* separate generic vhost-user-server code from vhost-user-blk-server code
* re-writevu_message_readand kick hander function as coroutines to directly callblk_co_preadv,blk_co_pwritev, etc.
* addaio_contextnotifier functions to support multi-threading model
* other fixes regarding coding style, warning report, etc.v2:
* Only enable this feature for Linux because eventfd is a Linux-specific featureThis patch series is an implementation of vhost-user block device backend server, thanks to Stefan and Kevin's guidance.
Vhost-user block device backend server is a UserCreatable object and can be started using
object_add,(qemu)
object_addvhost-user-blk-server,id=ID,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512 (qemu)object_delIDor appending the "-object" option when starting QEMU,
$ -object vhost-user-blk-server,id=disk,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512Then vhost-user client can connect to the server backend. For example, QEMU could act as a client,
$ -m 256 -object memory-backend-memfd,id=mem,size=256M,share=on -numa node,memdev=mem -chardev socket,id=char1,path=/tmp/vhost-user-blk_vhost.socket -device vhost-user-blk-pci,id=blk0,chardev=char1And guest OS could access this vhost-user block device after mounting it.
Coiby Xu (7):
libvhost-user: Allowvu_message_readto be replaced
libvhost-user: remove watch forkick_fdwhen de-initialize vu-dev util/vhost-user-server: generic vhost user server
block: move logical block size check function to a common utility
function
block/export: vhost-user block device backend server
test: new qTest case to test the vhost-user-blk-server
MAINTAINERS: Add vhost-user block device backend server maintainerMAINTAINERS | 8 + block/export/vhost-user-blk-server.c | 661 ++++++++++++++++++ block/export/vhost-user-blk-server.h | 36 + block/meson.build | 1 + contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 15 +- contrib/libvhost-user/libvhost-user.h | 21 + hw/core/qdev-properties.c | 31 +- softmmu/vl.c | 4 + tests/qtest/libqos/libqtest.h | 17 + tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/vhost-user-blk.c | 129 ++++ tests/qtest/libqos/vhost-user-blk.h | 48 ++ tests/qtest/libqtest.c | 36 +- tests/qtest/meson.build | 4 +- tests/qtest/vhost-user-blk-test.c | 751 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 + tools/virtiofsd/fuse_virtio.c | 4 +- util/block-helpers.c | 46 ++ util/block-helpers.h | 19 + util/meson.build | 2 + util/vhost-user-server.c | 428 ++++++++++++ util/vhost-user-server.h | 65 ++ 23 files changed, 2292 insertions(+), 39 deletions(-) create mode 100644 block/export/vhost-user-blk-server.c create mode 100644 block/export/vhost-user-blk-server.h create mode 100644 tests/qtest/libqos/vhost-user-blk.c create mode 100644 tests/qtest/libqos/vhost-user-blk.h create mode 100644 tests/qtest/vhost-user-blk-test.c create mode 100644 util/block-helpers.c create mode 100644 util/block-helpers.h create mode 100644 util/vhost-user-server.c create mode 100644 util/vhost-user-server.h
Quoted 3 lines
--
2.28.0
Thanks, applied to my block tree:
https://github.com/stefanha/qemu/commits/block
Stefan
Quoted 119 lines · Stefan Hajnoczi
Quoted 118 lines · Coiby Xu
v10
- Use a linked list of VuFdWatch objects to keep kick info [Stefan]
- Merge improvements and fixes from Stefan
- Rename libvhost-user'svu_message_readtovu_message_read_default[Kevin]
- When shutting down the client, wait for the coroutine of processing vhost-user messages to be finished [Kevin]
- Allocate structreq_dataon the heap [Kevin]
- Improve coding of qtest case [Thomas]
- Fix several memory leaks detected by ASANv9
- move logical block size check function to a utility function
- fix issues regarding license, coding style, memory deallocation, etc.v8
- re-try connecting to socket server to fix asan error
- fix license naming issuev7
- fix docker-test-debug@fedora errors by freeing malloced memoryv6
- add missing license header and include guard
- vhost-user server only serve one client one time
- fix a bug in customvu_message_read
- using qemu-storage-daemon to start vhost-user-blk-server
- a bug fix to pass docker-test-clang@ubuntuv5:
* re-usevu_kick_cbin libvhost-user
* keeping processing VhostUserMsg in the same coroutine until there is detachment/attachment of AIOContext
* Spawn separate coroutine for each VuVirtqElement
* Other changes including relocatingvhost-user-blk-server.c, coding style etc.v4:
* add object properties inclass_init
* relocate vhost-user-blk-test
* other changes including using SocketAddress, coding style, etc.v3:
* separate generic vhost-user-server code from vhost-user-blk-server code
* re-writevu_message_readand kick hander function as coroutines to directly callblk_co_preadv,blk_co_pwritev, etc.
* addaio_contextnotifier functions to support multi-threading model
* other fixes regarding coding style, warning report, etc.v2:
* Only enable this feature for Linux because eventfd is a Linux-specific featureThis patch series is an implementation of vhost-user block device backend server, thanks to Stefan and Kevin's guidance.
Vhost-user block device backend server is a UserCreatable object and can be started using
object_add,(qemu)
object_addvhost-user-blk-server,id=ID,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512 (qemu)object_delIDor appending the "-object" option when starting QEMU,
$ -object vhost-user-blk-server,id=disk,unix-socket=/tmp/vhost-user-blk_vhost.socket,node-name=DRIVE_NAME,writable=off,logical-block-size=512Then vhost-user client can connect to the server backend. For example, QEMU could act as a client,
$ -m 256 -object memory-backend-memfd,id=mem,size=256M,share=on -numa node,memdev=mem -chardev socket,id=char1,path=/tmp/vhost-user-blk_vhost.socket -device vhost-user-blk-pci,id=blk0,chardev=char1And guest OS could access this vhost-user block device after mounting it.
Coiby Xu (7):
libvhost-user: Allowvu_message_readto be replaced
libvhost-user: remove watch forkick_fdwhen de-initialize vu-dev util/vhost-user-server: generic vhost user server
block: move logical block size check function to a common utility
function
block/export: vhost-user block device backend server
test: new qTest case to test the vhost-user-blk-server
MAINTAINERS: Add vhost-user block device backend server maintainerMAINTAINERS | 8 + block/export/vhost-user-blk-server.c | 661 ++++++++++++++++++ block/export/vhost-user-blk-server.h | 36 + block/meson.build | 1 + contrib/libvhost-user/libvhost-user-glib.c | 2 +- contrib/libvhost-user/libvhost-user.c | 15 +- contrib/libvhost-user/libvhost-user.h | 21 + hw/core/qdev-properties.c | 31 +- softmmu/vl.c | 4 + tests/qtest/libqos/libqtest.h | 17 + tests/qtest/libqos/meson.build | 1 + tests/qtest/libqos/vhost-user-blk.c | 129 ++++ tests/qtest/libqos/vhost-user-blk.h | 48 ++ tests/qtest/libqtest.c | 36 +- tests/qtest/meson.build | 4 +- tests/qtest/vhost-user-blk-test.c | 751 +++++++++++++++++++++ tests/vhost-user-bridge.c | 2 + tools/virtiofsd/fuse_virtio.c | 4 +- util/block-helpers.c | 46 ++ util/block-helpers.h | 19 + util/meson.build | 2 + util/vhost-user-server.c | 428 ++++++++++++ util/vhost-user-server.h | 65 ++ 23 files changed, 2292 insertions(+), 39 deletions(-) create mode 100644 block/export/vhost-user-blk-server.c create mode 100644 block/export/vhost-user-blk-server.h create mode 100644 tests/qtest/libqos/vhost-user-blk.c create mode 100644 tests/qtest/libqos/vhost-user-blk.h create mode 100644 tests/qtest/vhost-user-blk-test.c create mode 100644 util/block-helpers.c create mode 100644 util/block-helpers.h create mode 100644 util/vhost-user-server.c create mode 100644 util/vhost-user-server.h
Quoted 7 lines
Quoted 3 lines
--
2.28.0Thanks, applied to my block tree:
https://github.com/stefanha/qemu/commits/block
Thank you for improving the code! I'm going to study the changes to understand how the improvements are made.
Quoted 1 line
Stefan
--
Best regards,
Coiby