[Qemu-devel] [PULL 00/21] Block patches
[PULL v2 00/28] Block patches
1
The following changes since commit 98b2faeaee96ab084d0b1669918688d8895c155f:
1
The following changes since commit ac793156f650ae2d77834932d72224175ee69086:
2
2
3
Merge remote-tracking branch 'remotes/jnsnow/tags/ide-pull-request' into staging (2017-02-10 18:07:02 +0000)
3
Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20201020-1' into staging (2020-10-20 21:11:35 +0100)
4
4
5
are available in the git repository at:
5
are available in the Git repository at:
6
6
7
git://github.com/XanClic/qemu.git tags/pull-block-2017-02-12
7
https://gitlab.com/stefanha/qemu.git tags/block-pull-request
8
8
9
for you to fetch changes up to 10d6eda1926804a09aa0710ca62933087813de0b:
9
for you to fetch changes up to 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:
10
10
11
qemu-img: Avoid setting ret to unused value in img_convert() (2017-02-12 00:56:32 +0100)
11
iotests: add commit top->base cases to 274 (2020-10-22 09:55:39 +0100)
12
12
13
----------------------------------------------------------------
13
----------------------------------------------------------------
14
Block patches
14
Pull request
15
16
v2:
17
* Fix format string issues on 32-bit hosts [Peter]
18
* Fix qemu-nbd.c CONFIG_POSIX ifdef issue [Eric]
19
* Fix missing eventfd.h header on macOS [Peter]
20
* Drop unreliable vhost-user-blk test (will send a new patch when ready) [Peter]
21
22
This pull request contains the vhost-user-blk server by Coiby Xu along with my
23
additions, block/nvme.c alignment and hardware error statistics by Philippe
24
Mathieu-Daudé, and bdrv_co_block_status_above() fixes by Vladimir
25
Sementsov-Ogievskiy.
15
26
16
----------------------------------------------------------------
27
----------------------------------------------------------------
17
Alberto Garcia (2):
18
qcow2: Optimize the refcount-block overlap check
19
qemu-io: don't allow I/O operations larger than BDRV_REQUEST_MAX_BYTES
20
28
21
Daniel P. Berrange (1):
29
Coiby Xu (6):
22
iotests: record separate timings per format,protocol pair
30
libvhost-user: Allow vu_message_read to be replaced
31
libvhost-user: remove watch for kick_fd when de-initialize vu-dev
32
util/vhost-user-server: generic vhost user server
33
block: move logical block size check function to a common utility
34
function
35
block/export: vhost-user block device backend server
36
MAINTAINERS: Add vhost-user block device backend server maintainer
23
37
24
Dou Liyang (2):
38
Philippe Mathieu-Daudé (1):
25
block/qapi: reduce the coupling between the bdrv_query_stats and bdrv_query_bds_stats
39
block/nvme: Add driver statistics for access alignment and hw errors
26
block/qapi: reduce the execution time of qmp_query_blockstats
27
40
28
Fam Zheng (2):
41
Stefan Hajnoczi (16):
29
qapi: Tweak error message of bdrv_query_image_info
42
util/vhost-user-server: s/fileds/fields/ typo fix
30
iotests: Fix reference output for 059
43
util/vhost-user-server: drop unnecessary QOM cast
44
util/vhost-user-server: drop unnecessary watch deletion
45
block/export: consolidate request structs into VuBlockReq
46
util/vhost-user-server: drop unused DevicePanicNotifier
47
util/vhost-user-server: fix memory leak in vu_message_read()
48
util/vhost-user-server: check EOF when reading payload
49
util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
50
block/export: report flush errors
51
block/export: convert vhost-user-blk server to block export API
52
util/vhost-user-server: move header to include/
53
util/vhost-user-server: use static library in meson.build
54
qemu-storage-daemon: avoid compiling blockdev_ss twice
55
block: move block exports to libblockdev
56
block/export: add iothread and fixed-iothread options
57
block/export: add vhost-user-blk multi-queue support
31
58
32
Jeff Cody (3):
59
Vladimir Sementsov-Ogievskiy (5):
33
block: check full backing filename when searching protocol filenames
60
block/io: fix bdrv_co_block_status_above
34
qemu-iotests: Don't create fifos / pidfiles with protocol paths
61
block/io: bdrv_common_block_status_above: support include_base
35
qemu-iotest: test to lookup protocol-based image with relative backing
62
block/io: bdrv_common_block_status_above: support bs == base
63
block/io: fix bdrv_is_allocated_above
64
iotests: add commit top->base cases to 274
36
65
37
Max Reitz (1):
66
MAINTAINERS | 9 +
38
qemu-img: Improve commit invalid base message
67
qapi/block-core.json | 24 +-
68
qapi/block-export.json | 36 +-
69
block/coroutines.h | 2 +
70
block/export/vhost-user-blk-server.h | 19 +
71
contrib/libvhost-user/libvhost-user.h | 21 +
72
include/qemu/vhost-user-server.h | 65 +++
73
util/block-helpers.h | 19 +
74
block/export/export.c | 37 +-
75
block/export/vhost-user-blk-server.c | 431 ++++++++++++++++++++
76
block/io.c | 132 +++---
77
block/nvme.c | 27 ++
78
block/qcow2.c | 16 +-
79
contrib/libvhost-user/libvhost-user-glib.c | 2 +-
80
contrib/libvhost-user/libvhost-user.c | 15 +-
81
hw/core/qdev-properties-system.c | 31 +-
82
nbd/server.c | 2 -
83
qemu-nbd.c | 21 +-
84
softmmu/vl.c | 4 +
85
stubs/blk-exp-close-all.c | 7 +
86
tests/vhost-user-bridge.c | 2 +
87
tools/virtiofsd/fuse_virtio.c | 4 +-
88
util/block-helpers.c | 46 +++
89
util/vhost-user-server.c | 446 +++++++++++++++++++++
90
block/export/meson.build | 3 +-
91
contrib/libvhost-user/meson.build | 1 +
92
meson.build | 22 +-
93
nbd/meson.build | 2 +
94
storage-daemon/meson.build | 3 +-
95
stubs/meson.build | 1 +
96
tests/qemu-iotests/274 | 20 +
97
tests/qemu-iotests/274.out | 68 ++++
98
util/meson.build | 4 +
99
33 files changed, 1420 insertions(+), 122 deletions(-)
100
create mode 100644 block/export/vhost-user-blk-server.h
101
create mode 100644 include/qemu/vhost-user-server.h
102
create mode 100644 util/block-helpers.h
103
create mode 100644 block/export/vhost-user-blk-server.c
104
create mode 100644 stubs/blk-exp-close-all.c
105
create mode 100644 util/block-helpers.c
106
create mode 100644 util/vhost-user-server.c
39
107
40
Nir Soffer (3):
108
--
41
qemu-io: Return non-zero exit code on failure
109
2.26.2
42
qemu-iotests: Add _unsupported_fmt helper
43
qemu-io: Add failure regression tests
44
110
45
Peter Lieven (2):
46
block/nfs: fix NULL pointer dereference in URI parsing
47
block/nfs: fix naming of runtime opts
48
49
Peter Maydell (2):
50
qemu-img: Use qemu_strtoul() rather than raw strtoul()
51
qemu-img: Avoid setting ret to unused value in img_convert()
52
53
QingFeng Hao (2):
54
iotests: Fix a problem in common.filter
55
block/vmdk: Fix the endian problem of buf_len and lba
56
57
Vladimir Sementsov-Ogievskiy (1):
58
block: bdrv_invalidate_cache: invalidate children first
59
60
tests/qemu-iotests/Makefile | 2 +-
61
block/qcow2.h | 1 +
62
block.c | 24 +++++++---
63
block/nfs.c | 49 ++++++++++----------
64
block/qapi.c | 99 +++++++++++++++++-----------------------
65
block/qcow2-refcount.c | 24 +++++++++-
66
block/qcow2.c | 1 +
67
block/vmdk.c | 4 +-
68
qemu-img.c | 44 +++++++++---------
69
qemu-io-cmds.c | 20 +++++---
70
qemu-io.c | 8 +++-
71
tests/qemu-iotests/.gitignore | 2 +-
72
tests/qemu-iotests/059.out | 5 +-
73
tests/qemu-iotests/070.out | 1 -
74
tests/qemu-iotests/075.out | 7 ---
75
tests/qemu-iotests/076.out | 3 --
76
tests/qemu-iotests/078.out | 6 ---
77
tests/qemu-iotests/080.out | 18 --------
78
tests/qemu-iotests/083.out | 17 -------
79
tests/qemu-iotests/088.out | 6 ---
80
tests/qemu-iotests/092.out | 12 -----
81
tests/qemu-iotests/116.out | 7 ---
82
tests/qemu-iotests/131.out | 1 -
83
tests/qemu-iotests/140.out | 1 -
84
tests/qemu-iotests/173 | 97 +++++++++++++++++++++++++++++++++++++++
85
tests/qemu-iotests/173.out | 12 +++++
86
tests/qemu-iotests/174 | 59 ++++++++++++++++++++++++
87
tests/qemu-iotests/174.out | 7 +++
88
tests/qemu-iotests/check | 12 +++--
89
tests/qemu-iotests/common.config | 6 ++-
90
tests/qemu-iotests/common.filter | 2 +-
91
tests/qemu-iotests/common.qemu | 10 ++--
92
tests/qemu-iotests/common.rc | 17 +++++--
93
tests/qemu-iotests/group | 2 +
94
34 files changed, 366 insertions(+), 220 deletions(-)
95
create mode 100755 tests/qemu-iotests/173
96
create mode 100644 tests/qemu-iotests/173.out
97
create mode 100755 tests/qemu-iotests/174
98
create mode 100644 tests/qemu-iotests/174.out
99
diff view generated by jsdifflib
[Qemu-devel] [PULL 16/21] qemu-iotests: Add _unsupported_fmt helper
[PULL v2 01/28] block/nvme: Add driver statistics for access alignment and hw errors
1
From: Nir Soffer <nirsof@gmail.com>
1
From: Philippe Mathieu-Daudé <philmd@redhat.com>
2
2
3
This helper allows adding tests supporting any format expect the
3
Keep statistics of some hardware errors, and number of
4
specified formats. This may be useful to test that many formats behave
4
aligned/unaligned I/O accesses.
5
in a common way.
6
5
7
Signed-off-by: Nir Soffer <nirsof@gmail.com>
6
QMP example booting a full RHEL 8.3 aarch64 guest:
8
Message-id: 20170201003120.23378-3-nirsof@gmail.com
7
9
Reviewed-by: Max Reitz <mreitz@redhat.com>
8
{ "execute": "query-blockstats" }
10
Signed-off-by: Max Reitz <mreitz@redhat.com>
9
{
10
"return": [
11
{
12
"device": "",
13
"node-name": "drive0",
14
"stats": {
15
"flush_total_time_ns": 6026948,
16
"wr_highest_offset": 3383991230464,
17
"wr_total_time_ns": 807450995,
18
"failed_wr_operations": 0,
19
"failed_rd_operations": 0,
20
"wr_merged": 3,
21
"wr_bytes": 50133504,
22
"failed_unmap_operations": 0,
23
"failed_flush_operations": 0,
24
"account_invalid": false,
25
"rd_total_time_ns": 1846979900,
26
"flush_operations": 130,
27
"wr_operations": 659,
28
"rd_merged": 1192,
29
"rd_bytes": 218244096,
30
"account_failed": false,
31
"idle_time_ns": 2678641497,
32
"rd_operations": 7406,
33
},
34
"driver-specific": {
35
"driver": "nvme",
36
"completion-errors": 0,
37
"unaligned-accesses": 2959,
38
"aligned-accesses": 4477
39
},
40
"qdev": "/machine/peripheral-anon/device[0]/virtio-backend"
41
}
42
]
43
}
44
45
Suggested-by: Stefan Hajnoczi <stefanha@gmail.com>
46
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
47
Acked-by: Markus Armbruster <armbru@redhat.com>
48
Message-id: 20201001162939.1567915-1-philmd@redhat.com
49
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
11
---
50
---
12
tests/qemu-iotests/common.rc | 11 +++++++++++
51
qapi/block-core.json | 24 +++++++++++++++++++++++-
13
1 file changed, 11 insertions(+)
52
block/nvme.c | 27 +++++++++++++++++++++++++++
53
2 files changed, 50 insertions(+), 1 deletion(-)
14
54
15
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
55
diff --git a/qapi/block-core.json b/qapi/block-core.json
16
index XXXXXXX..XXXXXXX 100644
56
index XXXXXXX..XXXXXXX 100644
17
--- a/tests/qemu-iotests/common.rc
57
--- a/qapi/block-core.json
18
+++ b/tests/qemu-iotests/common.rc
58
+++ b/qapi/block-core.json
19
@@ -XXX,XX +XXX,XX @@ _supported_fmt()
59
@@ -XXX,XX +XXX,XX @@
20
_notrun "not suitable for this image format: $IMGFMT"
60
'discard-nb-failed': 'uint64',
61
'discard-bytes-ok': 'uint64' } }
62
63
+##
64
+# @BlockStatsSpecificNvme:
65
+#
66
+# NVMe driver statistics
67
+#
68
+# @completion-errors: The number of completion errors.
69
+#
70
+# @aligned-accesses: The number of aligned accesses performed by
71
+# the driver.
72
+#
73
+# @unaligned-accesses: The number of unaligned accesses performed by
74
+# the driver.
75
+#
76
+# Since: 5.2
77
+##
78
+{ 'struct': 'BlockStatsSpecificNvme',
79
+ 'data': {
80
+ 'completion-errors': 'uint64',
81
+ 'aligned-accesses': 'uint64',
82
+ 'unaligned-accesses': 'uint64' } }
83
+
84
##
85
# @BlockStatsSpecific:
86
#
87
@@ -XXX,XX +XXX,XX @@
88
'discriminator': 'driver',
89
'data': {
90
'file': 'BlockStatsSpecificFile',
91
- 'host_device': 'BlockStatsSpecificFile' } }
92
+ 'host_device': 'BlockStatsSpecificFile',
93
+ 'nvme': 'BlockStatsSpecificNvme' } }
94
95
##
96
# @BlockStats:
97
diff --git a/block/nvme.c b/block/nvme.c
98
index XXXXXXX..XXXXXXX 100644
99
--- a/block/nvme.c
100
+++ b/block/nvme.c
101
@@ -XXX,XX +XXX,XX @@ struct BDRVNVMeState {
102
103
/* PCI address (required for nvme_refresh_filename()) */
104
char *device;
105
+
106
+ struct {
107
+ uint64_t completion_errors;
108
+ uint64_t aligned_accesses;
109
+ uint64_t unaligned_accesses;
110
+ } stats;
111
};
112
113
#define NVME_BLOCK_OPT_DEVICE "device"
114
@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(NVMeQueuePair *q)
115
break;
116
}
117
ret = nvme_translate_error(c);
118
+ if (ret) {
119
+ s->stats.completion_errors++;
120
+ }
121
q->cq.head = (q->cq.head + 1) % NVME_QUEUE_SIZE;
122
if (!q->cq.head) {
123
q->cq_phase = !q->cq_phase;
124
@@ -XXX,XX +XXX,XX @@ static int nvme_co_prw(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
125
assert(QEMU_IS_ALIGNED(bytes, s->page_size));
126
assert(bytes <= s->max_transfer);
127
if (nvme_qiov_aligned(bs, qiov)) {
128
+ s->stats.aligned_accesses++;
129
return nvme_co_prw_aligned(bs, offset, bytes, qiov, is_write, flags);
130
}
131
+ s->stats.unaligned_accesses++;
132
trace_nvme_prw_buffered(s, offset, bytes, qiov->niov, is_write);
133
buf = qemu_try_memalign(s->page_size, bytes);
134
135
@@ -XXX,XX +XXX,XX @@ static void nvme_unregister_buf(BlockDriverState *bs, void *host)
136
qemu_vfio_dma_unmap(s->vfio, host);
21
}
137
}
22
138
23
+# tests whether $IMGFMT is one of the unsupported image format for a test
139
+static BlockStatsSpecific *nvme_get_specific_stats(BlockDriverState *bs)
24
+#
25
+_unsupported_fmt()
26
+{
140
+{
27
+ for f; do
141
+ BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
28
+ if [ "$f" = "$IMGFMT" ]; then
142
+ BDRVNVMeState *s = bs->opaque;
29
+ _notrun "not suitable for this image format: $IMGFMT"
143
+
30
+ fi
144
+ stats->driver = BLOCKDEV_DRIVER_NVME;
31
+ done
145
+ stats->u.nvme = (BlockStatsSpecificNvme) {
146
+ .completion_errors = s->stats.completion_errors,
147
+ .aligned_accesses = s->stats.aligned_accesses,
148
+ .unaligned_accesses = s->stats.unaligned_accesses,
149
+ };
150
+
151
+ return stats;
32
+}
152
+}
33
+
153
+
34
# tests whether $IMGPROTO is one of the supported image protocols for a test
154
static const char *const nvme_strong_runtime_opts[] = {
35
#
155
NVME_BLOCK_OPT_DEVICE,
36
_supported_proto()
156
NVME_BLOCK_OPT_NAMESPACE,
157
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {
158
.bdrv_refresh_filename = nvme_refresh_filename,
159
.bdrv_refresh_limits = nvme_refresh_limits,
160
.strong_runtime_opts = nvme_strong_runtime_opts,
161
+ .bdrv_get_specific_stats = nvme_get_specific_stats,
162
163
.bdrv_detach_aio_context = nvme_detach_aio_context,
164
.bdrv_attach_aio_context = nvme_attach_aio_context,
37
--
165
--
38
2.11.0
166
2.26.2
39
167
40
diff view generated by jsdifflib
[Qemu-devel] [PULL 03/21] qapi: Tweak error message of bdrv_query_image_info
[PULL v2 02/28] libvhost-user: Allow vu_message_read to be replaced
1
From: Fam Zheng <famz@redhat.com>
1
From: Coiby Xu <coiby.xu@gmail.com>
2
2
3
@bs doesn't always have a device name, such as when it comes from
3
Allow vu_message_read to be replaced by one which will make use of the
4
"qemu-img info". Report file name instead.
4
QIOChannel functions. Thus reading vhost-user message won't stall the
5
guest. For slave channel, we still use the default vu_message_read.
5
6
6
Signed-off-by: Fam Zheng <famz@redhat.com>
7
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
7
Message-id: 20170119130759.28319-2-famz@redhat.com
8
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
8
Reviewed-by: Eric Blake <eblake@redhat.com>
9
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
9
Signed-off-by: Max Reitz <mreitz@redhat.com>
10
Message-id: 20200918080912.321299-2-coiby.xu@gmail.com
11
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
10
---
12
---
11
block/qapi.c | 4 ++--
13
contrib/libvhost-user/libvhost-user.h | 21 +++++++++++++++++++++
12
1 file changed, 2 insertions(+), 2 deletions(-)
14
contrib/libvhost-user/libvhost-user-glib.c | 2 +-
15
contrib/libvhost-user/libvhost-user.c | 14 +++++++-------
16
tests/vhost-user-bridge.c | 2 ++
17
tools/virtiofsd/fuse_virtio.c | 4 ++--
18
5 files changed, 33 insertions(+), 10 deletions(-)
13
19
14
diff --git a/block/qapi.c b/block/qapi.c
20
diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/libvhost-user.h
15
index XXXXXXX..XXXXXXX 100644
21
index XXXXXXX..XXXXXXX 100644
16
--- a/block/qapi.c
22
--- a/contrib/libvhost-user/libvhost-user.h
17
+++ b/block/qapi.c
23
+++ b/contrib/libvhost-user/libvhost-user.h
18
@@ -XXX,XX +XXX,XX @@ void bdrv_query_image_info(BlockDriverState *bs,
24
@@ -XXX,XX +XXX,XX @@
19
25
*/
20
size = bdrv_getlength(bs);
26
#define VHOST_USER_MAX_RAM_SLOTS 32
21
if (size < 0) {
27
22
- error_setg_errno(errp, -size, "Can't get size of device '%s'",
28
+#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
23
- bdrv_get_device_name(bs));
29
+
24
+ error_setg_errno(errp, -size, "Can't get image size '%s'",
30
typedef enum VhostSetConfigType {
25
+ bs->exact_filename);
31
VHOST_SET_CONFIG_TYPE_MASTER = 0,
32
VHOST_SET_CONFIG_TYPE_MIGRATION = 1,
33
@@ -XXX,XX +XXX,XX @@ typedef uint64_t (*vu_get_features_cb) (VuDev *dev);
34
typedef void (*vu_set_features_cb) (VuDev *dev, uint64_t features);
35
typedef int (*vu_process_msg_cb) (VuDev *dev, VhostUserMsg *vmsg,
36
int *do_reply);
37
+typedef bool (*vu_read_msg_cb) (VuDev *dev, int sock, VhostUserMsg *vmsg);
38
typedef void (*vu_queue_set_started_cb) (VuDev *dev, int qidx, bool started);
39
typedef bool (*vu_queue_is_processed_in_order_cb) (VuDev *dev, int qidx);
40
typedef int (*vu_get_config_cb) (VuDev *dev, uint8_t *config, uint32_t len);
41
@@ -XXX,XX +XXX,XX @@ struct VuDev {
42
bool broken;
43
uint16_t max_queues;
44
45
+ /* @read_msg: custom method to read vhost-user message
46
+ *
47
+ * Read data from vhost_user socket fd and fill up
48
+ * the passed VhostUserMsg *vmsg struct.
49
+ *
50
+ * If reading fails, it should close the received set of file
51
+ * descriptors as socket message's auxiliary data.
52
+ *
53
+ * For the details, please refer to vu_message_read in libvhost-user.c
54
+ * which will be used by default if not custom method is provided when
55
+ * calling vu_init
56
+ *
57
+ * Returns: true if vhost-user message successfully received,
58
+ * otherwise return false.
59
+ *
60
+ */
61
+ vu_read_msg_cb read_msg;
62
/* @set_watch: add or update the given fd to the watch set,
63
* call cb when condition is met */
64
vu_set_watch_cb set_watch;
65
@@ -XXX,XX +XXX,XX @@ bool vu_init(VuDev *dev,
66
uint16_t max_queues,
67
int socket,
68
vu_panic_cb panic,
69
+ vu_read_msg_cb read_msg,
70
vu_set_watch_cb set_watch,
71
vu_remove_watch_cb remove_watch,
72
const VuDevIface *iface);
73
diff --git a/contrib/libvhost-user/libvhost-user-glib.c b/contrib/libvhost-user/libvhost-user-glib.c
74
index XXXXXXX..XXXXXXX 100644
75
--- a/contrib/libvhost-user/libvhost-user-glib.c
76
+++ b/contrib/libvhost-user/libvhost-user-glib.c
77
@@ -XXX,XX +XXX,XX @@ vug_init(VugDev *dev, uint16_t max_queues, int socket,
78
g_assert(dev);
79
g_assert(iface);
80
81
- if (!vu_init(&dev->parent, max_queues, socket, panic, set_watch,
82
+ if (!vu_init(&dev->parent, max_queues, socket, panic, NULL, set_watch,
83
remove_watch, iface)) {
84
return false;
85
}
86
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
87
index XXXXXXX..XXXXXXX 100644
88
--- a/contrib/libvhost-user/libvhost-user.c
89
+++ b/contrib/libvhost-user/libvhost-user.c
90
@@ -XXX,XX +XXX,XX @@
91
/* The version of inflight buffer */
92
#define INFLIGHT_VERSION 1
93
94
-#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
95
-
96
/* The version of the protocol we support */
97
#define VHOST_USER_VERSION 1
98
#define LIBVHOST_USER_DEBUG 0
99
@@ -XXX,XX +XXX,XX @@ have_userfault(void)
100
}
101
102
static bool
103
-vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
104
+vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
105
{
106
char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {};
107
struct iovec iov = {
108
@@ -XXX,XX +XXX,XX @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg)
26
goto out;
109
goto out;
27
}
110
}
28
111
112
- if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) {
113
+ if (!vu_message_read_default(dev, dev->slave_fd, &msg_reply)) {
114
goto out;
115
}
116
117
@@ -XXX,XX +XXX,XX @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
118
/* Wait for QEMU to confirm that it's registered the handler for the
119
* faults.
120
*/
121
- if (!vu_message_read(dev, dev->sock, vmsg) ||
122
+ if (!dev->read_msg(dev, dev->sock, vmsg) ||
123
vmsg->size != sizeof(vmsg->payload.u64) ||
124
vmsg->payload.u64 != 0) {
125
vu_panic(dev, "failed to receive valid ack for postcopy set-mem-table");
126
@@ -XXX,XX +XXX,XX @@ vu_dispatch(VuDev *dev)
127
int reply_requested;
128
bool need_reply, success = false;
129
130
- if (!vu_message_read(dev, dev->sock, &vmsg)) {
131
+ if (!dev->read_msg(dev, dev->sock, &vmsg)) {
132
goto end;
133
}
134
135
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
136
uint16_t max_queues,
137
int socket,
138
vu_panic_cb panic,
139
+ vu_read_msg_cb read_msg,
140
vu_set_watch_cb set_watch,
141
vu_remove_watch_cb remove_watch,
142
const VuDevIface *iface)
143
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
144
145
dev->sock = socket;
146
dev->panic = panic;
147
+ dev->read_msg = read_msg ? read_msg : vu_message_read_default;
148
dev->set_watch = set_watch;
149
dev->remove_watch = remove_watch;
150
dev->iface = iface;
151
@@ -XXX,XX +XXX,XX @@ static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync)
152
153
vu_message_write(dev, dev->slave_fd, &vmsg);
154
if (ack) {
155
- vu_message_read(dev, dev->slave_fd, &vmsg);
156
+ vu_message_read_default(dev, dev->slave_fd, &vmsg);
157
}
158
return;
159
}
160
diff --git a/tests/vhost-user-bridge.c b/tests/vhost-user-bridge.c
161
index XXXXXXX..XXXXXXX 100644
162
--- a/tests/vhost-user-bridge.c
163
+++ b/tests/vhost-user-bridge.c
164
@@ -XXX,XX +XXX,XX @@ vubr_accept_cb(int sock, void *ctx)
165
VHOST_USER_BRIDGE_MAX_QUEUES,
166
conn_fd,
167
vubr_panic,
168
+ NULL,
169
vubr_set_watch,
170
vubr_remove_watch,
171
&vuiface)) {
172
@@ -XXX,XX +XXX,XX @@ vubr_new(const char *path, bool client)
173
VHOST_USER_BRIDGE_MAX_QUEUES,
174
dev->sock,
175
vubr_panic,
176
+ NULL,
177
vubr_set_watch,
178
vubr_remove_watch,
179
&vuiface)) {
180
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
181
index XXXXXXX..XXXXXXX 100644
182
--- a/tools/virtiofsd/fuse_virtio.c
183
+++ b/tools/virtiofsd/fuse_virtio.c
184
@@ -XXX,XX +XXX,XX @@ int virtio_session_mount(struct fuse_session *se)
185
se->vu_socketfd = data_sock;
186
se->virtio_dev->se = se;
187
pthread_rwlock_init(&se->virtio_dev->vu_dispatch_rwlock, NULL);
188
- vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_watch,
189
- fv_remove_watch, &fv_iface);
190
+ vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, NULL,
191
+ fv_set_watch, fv_remove_watch, &fv_iface);
192
193
return 0;
194
}
29
--
195
--
30
2.11.0
196
2.26.2
31
197
32
diff view generated by jsdifflib
New patch
[PULL v2 03/28] libvhost-user: remove watch for kick_fd when de-initialize vu-dev
1
From: Coiby Xu <coiby.xu@gmail.com>
1
2
3
When the client is running in gdb and quit command is run in gdb,
4
QEMU will still dispatch the event which will cause segment fault in
5
the callback function.
6
7
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
8
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
9
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
10
Message-id: 20200918080912.321299-3-coiby.xu@gmail.com
11
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
12
---
13
contrib/libvhost-user/libvhost-user.c | 1 +
14
1 file changed, 1 insertion(+)
15
16
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
17
index XXXXXXX..XXXXXXX 100644
18
--- a/contrib/libvhost-user/libvhost-user.c
19
+++ b/contrib/libvhost-user/libvhost-user.c
20
@@ -XXX,XX +XXX,XX @@ vu_deinit(VuDev *dev)
21
}
22
23
if (vq->kick_fd != -1) {
24
+ dev->remove_watch(dev, vq->kick_fd);
25
close(vq->kick_fd);
26
vq->kick_fd = -1;
27
}
28
--
29
2.26.2
30
diff view generated by jsdifflib
New patch
[PULL v2 04/28] util/vhost-user-server: generic vhost user server
1
From: Coiby Xu <coiby.xu@gmail.com>
1
2
3
Sharing QEMU devices via vhost-user protocol.
4
5
Only one vhost-user client can connect to the server one time.
6
7
Suggested-by: Kevin Wolf <kwolf@redhat.com>
8
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
9
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
10
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
11
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
12
Message-id: 20200918080912.321299-4-coiby.xu@gmail.com
13
[Fixed size_t %lu -> %zu format string compiler error.
14
--Stefan]
15
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
16
---
17
util/vhost-user-server.h | 65 ++++++
18
util/vhost-user-server.c | 428 +++++++++++++++++++++++++++++++++++++++
19
util/meson.build | 1 +
20
3 files changed, 494 insertions(+)
21
create mode 100644 util/vhost-user-server.h
22
create mode 100644 util/vhost-user-server.c
23
24
diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
25
new file mode 100644
26
index XXXXXXX..XXXXXXX
27
--- /dev/null
28
+++ b/util/vhost-user-server.h
29
@@ -XXX,XX +XXX,XX @@
30
+/*
31
+ * Sharing QEMU devices via vhost-user protocol
32
+ *
33
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
34
+ * Copyright (c) 2020 Red Hat, Inc.
35
+ *
36
+ * This work is licensed under the terms of the GNU GPL, version 2 or
37
+ * later. See the COPYING file in the top-level directory.
38
+ */
39
+
40
+#ifndef VHOST_USER_SERVER_H
41
+#define VHOST_USER_SERVER_H
42
+
43
+#include "contrib/libvhost-user/libvhost-user.h"
44
+#include "io/channel-socket.h"
45
+#include "io/channel-file.h"
46
+#include "io/net-listener.h"
47
+#include "qemu/error-report.h"
48
+#include "qapi/error.h"
49
+#include "standard-headers/linux/virtio_blk.h"
50
+
51
+typedef struct VuFdWatch {
52
+ VuDev *vu_dev;
53
+ int fd; /*kick fd*/
54
+ void *pvt;
55
+ vu_watch_cb cb;
56
+ bool processing;
57
+ QTAILQ_ENTRY(VuFdWatch) next;
58
+} VuFdWatch;
59
+
60
+typedef struct VuServer VuServer;
61
+typedef void DevicePanicNotifierFn(VuServer *server);
62
+
63
+struct VuServer {
64
+ QIONetListener *listener;
65
+ AioContext *ctx;
66
+ DevicePanicNotifierFn *device_panic_notifier;
67
+ int max_queues;
68
+ const VuDevIface *vu_iface;
69
+ VuDev vu_dev;
70
+ QIOChannel *ioc; /* The I/O channel with the client */
71
+ QIOChannelSocket *sioc; /* The underlying data channel with the client */
72
+ /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
73
+ QIOChannel *ioc_slave;
74
+ QIOChannelSocket *sioc_slave;
75
+ Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
76
+ QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
77
+ /* restart coroutine co_trip if AIOContext is changed */
78
+ bool aio_context_changed;
79
+ bool processing_msg;
80
+};
81
+
82
+bool vhost_user_server_start(VuServer *server,
83
+ SocketAddress *unix_socket,
84
+ AioContext *ctx,
85
+ uint16_t max_queues,
86
+ DevicePanicNotifierFn *device_panic_notifier,
87
+ const VuDevIface *vu_iface,
88
+ Error **errp);
89
+
90
+void vhost_user_server_stop(VuServer *server);
91
+
92
+void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
93
+
94
+#endif /* VHOST_USER_SERVER_H */
95
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
96
new file mode 100644
97
index XXXXXXX..XXXXXXX
98
--- /dev/null
99
+++ b/util/vhost-user-server.c
100
@@ -XXX,XX +XXX,XX @@
101
+/*
102
+ * Sharing QEMU devices via vhost-user protocol
103
+ *
104
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
105
+ * Copyright (c) 2020 Red Hat, Inc.
106
+ *
107
+ * This work is licensed under the terms of the GNU GPL, version 2 or
108
+ * later. See the COPYING file in the top-level directory.
109
+ */
110
+#include "qemu/osdep.h"
111
+#include "qemu/main-loop.h"
112
+#include "vhost-user-server.h"
113
+
114
+static void vmsg_close_fds(VhostUserMsg *vmsg)
115
+{
116
+ int i;
117
+ for (i = 0; i < vmsg->fd_num; i++) {
118
+ close(vmsg->fds[i]);
119
+ }
120
+}
121
+
122
+static void vmsg_unblock_fds(VhostUserMsg *vmsg)
123
+{
124
+ int i;
125
+ for (i = 0; i < vmsg->fd_num; i++) {
126
+ qemu_set_nonblock(vmsg->fds[i]);
127
+ }
128
+}
129
+
130
+static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
131
+ gpointer opaque);
132
+
133
+static void close_client(VuServer *server)
134
+{
135
+ /*
136
+ * Before closing the client
137
+ *
138
+ * 1. Let vu_client_trip stop processing new vhost-user msg
139
+ *
140
+ * 2. remove kick_handler
141
+ *
142
+ * 3. wait for the kick handler to be finished
143
+ *
144
+ * 4. wait for the current vhost-user msg to be finished processing
145
+ */
146
+
147
+ QIOChannelSocket *sioc = server->sioc;
148
+ /* When this is set vu_client_trip will stop new processing vhost-user message */
149
+ server->sioc = NULL;
150
+
151
+ VuFdWatch *vu_fd_watch, *next;
152
+ QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
153
+ aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
154
+ NULL, NULL, NULL);
155
+ }
156
+
157
+ while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
158
+ QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
159
+ if (!vu_fd_watch->processing) {
160
+ QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
161
+ g_free(vu_fd_watch);
162
+ }
163
+ }
164
+ }
165
+
166
+ while (server->processing_msg) {
167
+ if (server->ioc->read_coroutine) {
168
+ server->ioc->read_coroutine = NULL;
169
+ qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
170
+ NULL, server->ioc);
171
+ server->processing_msg = false;
172
+ }
173
+ }
174
+
175
+ vu_deinit(&server->vu_dev);
176
+ object_unref(OBJECT(sioc));
177
+ object_unref(OBJECT(server->ioc));
178
+}
179
+
180
+static void panic_cb(VuDev *vu_dev, const char *buf)
181
+{
182
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
183
+
184
+ /* avoid while loop in close_client */
185
+ server->processing_msg = false;
186
+
187
+ if (buf) {
188
+ error_report("vu_panic: %s", buf);
189
+ }
190
+
191
+ if (server->sioc) {
192
+ close_client(server);
193
+ }
194
+
195
+ if (server->device_panic_notifier) {
196
+ server->device_panic_notifier(server);
197
+ }
198
+
199
+ /*
200
+ * Set the callback function for network listener so another
201
+ * vhost-user client can connect to this server
202
+ */
203
+ qio_net_listener_set_client_func(server->listener,
204
+ vu_accept,
205
+ server,
206
+ NULL);
207
+}
208
+
209
+static bool coroutine_fn
210
+vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
211
+{
212
+ struct iovec iov = {
213
+ .iov_base = (char *)vmsg,
214
+ .iov_len = VHOST_USER_HDR_SIZE,
215
+ };
216
+ int rc, read_bytes = 0;
217
+ Error *local_err = NULL;
218
+ /*
219
+ * Store fds/nfds returned from qio_channel_readv_full into
220
+ * temporary variables.
221
+ *
222
+ * VhostUserMsg is a packed structure, gcc will complain about passing
223
+ * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
224
+ * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
225
+ * thus two temporary variables nfds and fds are used here.
226
+ */
227
+ size_t nfds = 0, nfds_t = 0;
228
+ const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
229
+ int *fds_t = NULL;
230
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
231
+ QIOChannel *ioc = server->ioc;
232
+
233
+ if (!ioc) {
234
+ error_report_err(local_err);
235
+ goto fail;
236
+ }
237
+
238
+ assert(qemu_in_coroutine());
239
+ do {
240
+ /*
241
+ * qio_channel_readv_full may have short reads, keeping calling it
242
+ * until getting VHOST_USER_HDR_SIZE or 0 bytes in total
243
+ */
244
+ rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
245
+ if (rc < 0) {
246
+ if (rc == QIO_CHANNEL_ERR_BLOCK) {
247
+ qio_channel_yield(ioc, G_IO_IN);
248
+ continue;
249
+ } else {
250
+ error_report_err(local_err);
251
+ return false;
252
+ }
253
+ }
254
+ read_bytes += rc;
255
+ if (nfds_t > 0) {
256
+ if (nfds + nfds_t > max_fds) {
257
+ error_report("A maximum of %zu fds are allowed, "
258
+ "however got %zu fds now",
259
+ max_fds, nfds + nfds_t);
260
+ goto fail;
261
+ }
262
+ memcpy(vmsg->fds + nfds, fds_t,
263
+ nfds_t *sizeof(vmsg->fds[0]));
264
+ nfds += nfds_t;
265
+ g_free(fds_t);
266
+ }
267
+ if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
268
+ break;
269
+ }
270
+ iov.iov_base = (char *)vmsg + read_bytes;
271
+ iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
272
+ } while (true);
273
+
274
+ vmsg->fd_num = nfds;
275
+ /* qio_channel_readv_full will make socket fds blocking, unblock them */
276
+ vmsg_unblock_fds(vmsg);
277
+ if (vmsg->size > sizeof(vmsg->payload)) {
278
+ error_report("Error: too big message request: %d, "
279
+ "size: vmsg->size: %u, "
280
+ "while sizeof(vmsg->payload) = %zu",
281
+ vmsg->request, vmsg->size, sizeof(vmsg->payload));
282
+ goto fail;
283
+ }
284
+
285
+ struct iovec iov_payload = {
286
+ .iov_base = (char *)&vmsg->payload,
287
+ .iov_len = vmsg->size,
288
+ };
289
+ if (vmsg->size) {
290
+ rc = qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err);
291
+ if (rc == -1) {
292
+ error_report_err(local_err);
293
+ goto fail;
294
+ }
295
+ }
296
+
297
+ return true;
298
+
299
+fail:
300
+ vmsg_close_fds(vmsg);
301
+
302
+ return false;
303
+}
304
+
305
+
306
+static void vu_client_start(VuServer *server);
307
+static coroutine_fn void vu_client_trip(void *opaque)
308
+{
309
+ VuServer *server = opaque;
310
+
311
+ while (!server->aio_context_changed && server->sioc) {
312
+ server->processing_msg = true;
313
+ vu_dispatch(&server->vu_dev);
314
+ server->processing_msg = false;
315
+ }
316
+
317
+ if (server->aio_context_changed && server->sioc) {
318
+ server->aio_context_changed = false;
319
+ vu_client_start(server);
320
+ }
321
+}
322
+
323
+static void vu_client_start(VuServer *server)
324
+{
325
+ server->co_trip = qemu_coroutine_create(vu_client_trip, server);
326
+ aio_co_enter(server->ctx, server->co_trip);
327
+}
328
+
329
+/*
330
+ * a wrapper for vu_kick_cb
331
+ *
332
+ * since aio_dispatch can only pass one user data pointer to the
333
+ * callback function, pack VuDev and pvt into a struct. Then unpack it
334
+ * and pass them to vu_kick_cb
335
+ */
336
+static void kick_handler(void *opaque)
337
+{
338
+ VuFdWatch *vu_fd_watch = opaque;
339
+ vu_fd_watch->processing = true;
340
+ vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
341
+ vu_fd_watch->processing = false;
342
+}
343
+
344
+
345
+static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
346
+{
347
+
348
+ VuFdWatch *vu_fd_watch, *next;
349
+ QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
350
+ if (vu_fd_watch->fd == fd) {
351
+ return vu_fd_watch;
352
+ }
353
+ }
354
+ return NULL;
355
+}
356
+
357
+static void
358
+set_watch(VuDev *vu_dev, int fd, int vu_evt,
359
+ vu_watch_cb cb, void *pvt)
360
+{
361
+
362
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
363
+ g_assert(vu_dev);
364
+ g_assert(fd >= 0);
365
+ g_assert(cb);
366
+
367
+ VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
368
+
369
+ if (!vu_fd_watch) {
370
+ VuFdWatch *vu_fd_watch = g_new0(VuFdWatch, 1);
371
+
372
+ QTAILQ_INSERT_TAIL(&server->vu_fd_watches, vu_fd_watch, next);
373
+
374
+ vu_fd_watch->fd = fd;
375
+ vu_fd_watch->cb = cb;
376
+ qemu_set_nonblock(fd);
377
+ aio_set_fd_handler(server->ioc->ctx, fd, true, kick_handler,
378
+ NULL, NULL, vu_fd_watch);
379
+ vu_fd_watch->vu_dev = vu_dev;
380
+ vu_fd_watch->pvt = pvt;
381
+ }
382
+}
383
+
384
+
385
+static void remove_watch(VuDev *vu_dev, int fd)
386
+{
387
+ VuServer *server;
388
+ g_assert(vu_dev);
389
+ g_assert(fd >= 0);
390
+
391
+ server = container_of(vu_dev, VuServer, vu_dev);
392
+
393
+ VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
394
+
395
+ if (!vu_fd_watch) {
396
+ return;
397
+ }
398
+ aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL);
399
+
400
+ QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
401
+ g_free(vu_fd_watch);
402
+}
403
+
404
+
405
+static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
406
+ gpointer opaque)
407
+{
408
+ VuServer *server = opaque;
409
+
410
+ if (server->sioc) {
411
+ warn_report("Only one vhost-user client is allowed to "
412
+ "connect the server one time");
413
+ return;
414
+ }
415
+
416
+ if (!vu_init(&server->vu_dev, server->max_queues, sioc->fd, panic_cb,
417
+ vu_message_read, set_watch, remove_watch, server->vu_iface)) {
418
+ error_report("Failed to initialize libvhost-user");
419
+ return;
420
+ }
421
+
422
+ /*
423
+ * Unset the callback function for network listener to make another
424
+ * vhost-user client keeping waiting until this client disconnects
425
+ */
426
+ qio_net_listener_set_client_func(server->listener,
427
+ NULL,
428
+ NULL,
429
+ NULL);
430
+ server->sioc = sioc;
431
+ /*
432
+ * Increase the object reference, so sioc will not freed by
433
+ * qio_net_listener_channel_func which will call object_unref(OBJECT(sioc))
434
+ */
435
+ object_ref(OBJECT(server->sioc));
436
+ qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
437
+ server->ioc = QIO_CHANNEL(sioc);
438
+ object_ref(OBJECT(server->ioc));
439
+ qio_channel_attach_aio_context(server->ioc, server->ctx);
440
+ qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
441
+ vu_client_start(server);
442
+}
443
+
444
+
445
+void vhost_user_server_stop(VuServer *server)
446
+{
447
+ if (server->sioc) {
448
+ close_client(server);
449
+ }
450
+
451
+ if (server->listener) {
452
+ qio_net_listener_disconnect(server->listener);
453
+ object_unref(OBJECT(server->listener));
454
+ }
455
+
456
+}
457
+
458
+void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
459
+{
460
+ VuFdWatch *vu_fd_watch, *next;
461
+ void *opaque = NULL;
462
+ IOHandler *io_read = NULL;
463
+ bool attach;
464
+
465
+ server->ctx = ctx ? ctx : qemu_get_aio_context();
466
+
467
+ if (!server->sioc) {
468
+ /* not yet serving any client*/
469
+ return;
470
+ }
471
+
472
+ if (ctx) {
473
+ qio_channel_attach_aio_context(server->ioc, ctx);
474
+ server->aio_context_changed = true;
475
+ io_read = kick_handler;
476
+ attach = true;
477
+ } else {
478
+ qio_channel_detach_aio_context(server->ioc);
479
+ /* server->ioc->ctx keeps the old AioConext */
480
+ ctx = server->ioc->ctx;
481
+ attach = false;
482
+ }
483
+
484
+ QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
485
+ if (vu_fd_watch->cb) {
486
+ opaque = attach ? vu_fd_watch : NULL;
487
+ aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
488
+ io_read, NULL, NULL,
489
+ opaque);
490
+ }
491
+ }
492
+}
493
+
494
+
495
+bool vhost_user_server_start(VuServer *server,
496
+ SocketAddress *socket_addr,
497
+ AioContext *ctx,
498
+ uint16_t max_queues,
499
+ DevicePanicNotifierFn *device_panic_notifier,
500
+ const VuDevIface *vu_iface,
501
+ Error **errp)
502
+{
503
+ QIONetListener *listener = qio_net_listener_new();
504
+ if (qio_net_listener_open_sync(listener, socket_addr, 1,
505
+ errp) < 0) {
506
+ object_unref(OBJECT(listener));
507
+ return false;
508
+ }
509
+
510
+ /* zero out unspecified fileds */
511
+ *server = (VuServer) {
512
+ .listener = listener,
513
+ .vu_iface = vu_iface,
514
+ .max_queues = max_queues,
515
+ .ctx = ctx,
516
+ .device_panic_notifier = device_panic_notifier,
517
+ };
518
+
519
+ qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
520
+
521
+ qio_net_listener_set_client_func(server->listener,
522
+ vu_accept,
523
+ server,
524
+ NULL);
525
+
526
+ QTAILQ_INIT(&server->vu_fd_watches);
527
+ return true;
528
+}
529
diff --git a/util/meson.build b/util/meson.build
530
index XXXXXXX..XXXXXXX 100644
531
--- a/util/meson.build
532
+++ b/util/meson.build
533
@@ -XXX,XX +XXX,XX @@ if have_block
534
util_ss.add(files('main-loop.c'))
535
util_ss.add(files('nvdimm-utils.c'))
536
util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
537
+ util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
538
util_ss.add(files('qemu-coroutine-sleep.c'))
539
util_ss.add(files('qemu-co-shared-resource.c'))
540
util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
541
--
542
2.26.2
543
diff view generated by jsdifflib
New patch
[PULL v2 05/28] block: move logical block size check function to a common utility function
1
From: Coiby Xu <coiby.xu@gmail.com>
1
2
3
Move the constants from hw/core/qdev-properties.c to
4
util/block-helpers.h so that knowledge of the min/max values is
5
6
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
7
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
8
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
9
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
10
Acked-by: Eduardo Habkost <ehabkost@redhat.com>
11
Message-id: 20200918080912.321299-5-coiby.xu@gmail.com
12
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
13
---
14
util/block-helpers.h | 19 +++++++++++++
15
hw/core/qdev-properties-system.c | 31 ++++-----------------
16
util/block-helpers.c | 46 ++++++++++++++++++++++++++++++++
17
util/meson.build | 1 +
18
4 files changed, 71 insertions(+), 26 deletions(-)
19
create mode 100644 util/block-helpers.h
20
create mode 100644 util/block-helpers.c
21
22
diff --git a/util/block-helpers.h b/util/block-helpers.h
23
new file mode 100644
24
index XXXXXXX..XXXXXXX
25
--- /dev/null
26
+++ b/util/block-helpers.h
27
@@ -XXX,XX +XXX,XX @@
28
+#ifndef BLOCK_HELPERS_H
29
+#define BLOCK_HELPERS_H
30
+
31
+#include "qemu/units.h"
32
+
33
+/* lower limit is sector size */
34
+#define MIN_BLOCK_SIZE INT64_C(512)
35
+#define MIN_BLOCK_SIZE_STR "512 B"
36
+/*
37
+ * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
38
+ * matches qcow2 cluster size limit
39
+ */
40
+#define MAX_BLOCK_SIZE (2 * MiB)
41
+#define MAX_BLOCK_SIZE_STR "2 MiB"
42
+
43
+void check_block_size(const char *id, const char *name, int64_t value,
44
+ Error **errp);
45
+
46
+#endif /* BLOCK_HELPERS_H */
47
diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c
48
index XXXXXXX..XXXXXXX 100644
49
--- a/hw/core/qdev-properties-system.c
50
+++ b/hw/core/qdev-properties-system.c
51
@@ -XXX,XX +XXX,XX @@
52
#include "sysemu/blockdev.h"
53
#include "net/net.h"
54
#include "hw/pci/pci.h"
55
+#include "util/block-helpers.h"
56
57
static bool check_prop_still_unset(DeviceState *dev, const char *name,
58
const void *old_val, const char *new_val,
59
@@ -XXX,XX +XXX,XX @@ const PropertyInfo qdev_prop_losttickpolicy = {
60
61
/* --- blocksize --- */
62
63
-/* lower limit is sector size */
64
-#define MIN_BLOCK_SIZE 512
65
-#define MIN_BLOCK_SIZE_STR "512 B"
66
-/*
67
- * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
68
- * matches qcow2 cluster size limit
69
- */
70
-#define MAX_BLOCK_SIZE (2 * MiB)
71
-#define MAX_BLOCK_SIZE_STR "2 MiB"
72
-
73
static void set_blocksize(Object *obj, Visitor *v, const char *name,
74
void *opaque, Error **errp)
75
{
76
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
77
Property *prop = opaque;
78
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
79
uint64_t value;
80
+ Error *local_err = NULL;
81
82
if (dev->realized) {
83
qdev_prop_set_after_realize(dev, name, errp);
84
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
85
if (!visit_type_size(v, name, &value, errp)) {
86
return;
87
}
88
- /* value of 0 means "unset" */
89
- if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
90
- error_setg(errp,
91
- "Property %s.%s doesn't take value %" PRIu64
92
- " (minimum: " MIN_BLOCK_SIZE_STR
93
- ", maximum: " MAX_BLOCK_SIZE_STR ")",
94
- dev->id ? : "", name, value);
95
+ check_block_size(dev->id ? : "", name, value, &local_err);
96
+ if (local_err) {
97
+ error_propagate(errp, local_err);
98
return;
99
}
100
-
101
- /* We rely on power-of-2 blocksizes for bitmasks */
102
- if ((value & (value - 1)) != 0) {
103
- error_setg(errp,
104
- "Property %s.%s doesn't take value '%" PRId64 "', "
105
- "it's not a power of 2", dev->id ?: "", name, (int64_t)value);
106
- return;
107
- }
108
-
109
*ptr = value;
110
}
111
112
diff --git a/util/block-helpers.c b/util/block-helpers.c
113
new file mode 100644
114
index XXXXXXX..XXXXXXX
115
--- /dev/null
116
+++ b/util/block-helpers.c
117
@@ -XXX,XX +XXX,XX @@
118
+/*
119
+ * Block utility functions
120
+ *
121
+ * Copyright IBM, Corp. 2011
122
+ * Copyright (c) 2020 Coiby Xu <coiby.xu@gmail.com>
123
+ *
124
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
125
+ * See the COPYING file in the top-level directory.
126
+ */
127
+
128
+#include "qemu/osdep.h"
129
+#include "qapi/error.h"
130
+#include "qapi/qmp/qerror.h"
131
+#include "block-helpers.h"
132
+
133
+/**
134
+ * check_block_size:
135
+ * @id: The unique ID of the object
136
+ * @name: The name of the property being validated
137
+ * @value: The block size in bytes
138
+ * @errp: A pointer to an area to store an error
139
+ *
140
+ * This function checks that the block size meets the following conditions:
141
+ * 1. At least MIN_BLOCK_SIZE
142
+ * 2. No larger than MAX_BLOCK_SIZE
143
+ * 3. A power of 2
144
+ */
145
+void check_block_size(const char *id, const char *name, int64_t value,
146
+ Error **errp)
147
+{
148
+ /* value of 0 means "unset" */
149
+ if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
150
+ error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
151
+ id, name, value, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
152
+ return;
153
+ }
154
+
155
+ /* We rely on power-of-2 blocksizes for bitmasks */
156
+ if ((value & (value - 1)) != 0) {
157
+ error_setg(errp,
158
+ "Property %s.%s doesn't take value '%" PRId64
159
+ "', it's not a power of 2",
160
+ id, name, value);
161
+ return;
162
+ }
163
+}
164
diff --git a/util/meson.build b/util/meson.build
165
index XXXXXXX..XXXXXXX 100644
166
--- a/util/meson.build
167
+++ b/util/meson.build
168
@@ -XXX,XX +XXX,XX @@ if have_block
169
util_ss.add(files('nvdimm-utils.c'))
170
util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
171
util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
172
+ util_ss.add(files('block-helpers.c'))
173
util_ss.add(files('qemu-coroutine-sleep.c'))
174
util_ss.add(files('qemu-co-shared-resource.c'))
175
util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
176
--
177
2.26.2
178
diff view generated by jsdifflib
New patch
[PULL v2 06/28] block/export: vhost-user block device backend server
1
From: Coiby Xu <coiby.xu@gmail.com>
1
2
3
By making use of libvhost-user, block device drive can be shared to
4
the connected vhost-user client. Only one client can connect to the
5
server one time.
6
7
Since vhost-user-server needs a block drive to be created first, delay
8
the creation of this object.
9
10
Suggested-by: Kevin Wolf <kwolf@redhat.com>
11
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
12
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
13
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
14
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
15
Message-id: 20200918080912.321299-6-coiby.xu@gmail.com
16
[Shorten "vhost_user_blk_server" string to "vhost_user_blk" to avoid the
17
following compiler warning:
18
../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=]
19
and fix "Invalid size %ld ..." ssize_t format string arguments for
20
32-bit hosts.
21
--Stefan]
22
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
23
---
24
block/export/vhost-user-blk-server.h | 36 ++
25
block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++
26
softmmu/vl.c | 4 +
27
block/meson.build | 1 +
28
4 files changed, 702 insertions(+)
29
create mode 100644 block/export/vhost-user-blk-server.h
30
create mode 100644 block/export/vhost-user-blk-server.c
31
32
diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
33
new file mode 100644
34
index XXXXXXX..XXXXXXX
35
--- /dev/null
36
+++ b/block/export/vhost-user-blk-server.h
37
@@ -XXX,XX +XXX,XX @@
38
+/*
39
+ * Sharing QEMU block devices via vhost-user protocal
40
+ *
41
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
42
+ * Copyright (c) 2020 Red Hat, Inc.
43
+ *
44
+ * This work is licensed under the terms of the GNU GPL, version 2 or
45
+ * later. See the COPYING file in the top-level directory.
46
+ */
47
+
48
+#ifndef VHOST_USER_BLK_SERVER_H
49
+#define VHOST_USER_BLK_SERVER_H
50
+#include "util/vhost-user-server.h"
51
+
52
+typedef struct VuBlockDev VuBlockDev;
53
+#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
54
+#define VHOST_USER_BLK_SERVER(obj) \
55
+ OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
56
+
57
+/* vhost user block device */
58
+struct VuBlockDev {
59
+ Object parent_obj;
60
+ char *node_name;
61
+ SocketAddress *addr;
62
+ AioContext *ctx;
63
+ VuServer vu_server;
64
+ bool running;
65
+ uint32_t blk_size;
66
+ BlockBackend *backend;
67
+ QIOChannelSocket *sioc;
68
+ QTAILQ_ENTRY(VuBlockDev) next;
69
+ struct virtio_blk_config blkcfg;
70
+ bool writable;
71
+};
72
+
73
+#endif /* VHOST_USER_BLK_SERVER_H */
74
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
75
new file mode 100644
76
index XXXXXXX..XXXXXXX
77
--- /dev/null
78
+++ b/block/export/vhost-user-blk-server.c
79
@@ -XXX,XX +XXX,XX @@
80
+/*
81
+ * Sharing QEMU block devices via vhost-user protocal
82
+ *
83
+ * Parts of the code based on nbd/server.c.
84
+ *
85
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
86
+ * Copyright (c) 2020 Red Hat, Inc.
87
+ *
88
+ * This work is licensed under the terms of the GNU GPL, version 2 or
89
+ * later. See the COPYING file in the top-level directory.
90
+ */
91
+#include "qemu/osdep.h"
92
+#include "block/block.h"
93
+#include "vhost-user-blk-server.h"
94
+#include "qapi/error.h"
95
+#include "qom/object_interfaces.h"
96
+#include "sysemu/block-backend.h"
97
+#include "util/block-helpers.h"
98
+
99
+enum {
100
+ VHOST_USER_BLK_MAX_QUEUES = 1,
101
+};
102
+struct virtio_blk_inhdr {
103
+ unsigned char status;
104
+};
105
+
106
+typedef struct VuBlockReq {
107
+ VuVirtqElement *elem;
108
+ int64_t sector_num;
109
+ size_t size;
110
+ struct virtio_blk_inhdr *in;
111
+ struct virtio_blk_outhdr out;
112
+ VuServer *server;
113
+ struct VuVirtq *vq;
114
+} VuBlockReq;
115
+
116
+static void vu_block_req_complete(VuBlockReq *req)
117
+{
118
+ VuDev *vu_dev = &req->server->vu_dev;
119
+
120
+ /* IO size with 1 extra status byte */
121
+ vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
122
+ vu_queue_notify(vu_dev, req->vq);
123
+
124
+ if (req->elem) {
125
+ free(req->elem);
126
+ }
127
+
128
+ g_free(req);
129
+}
130
+
131
+static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
132
+{
133
+ return container_of(server, VuBlockDev, vu_server);
134
+}
135
+
136
+static int coroutine_fn
137
+vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
138
+ uint32_t iovcnt, uint32_t type)
139
+{
140
+ struct virtio_blk_discard_write_zeroes desc;
141
+ ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
142
+ if (unlikely(size != sizeof(desc))) {
143
+ error_report("Invalid size %zd, expect %zu", size, sizeof(desc));
144
+ return -EINVAL;
145
+ }
146
+
147
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
148
+ uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
149
+ le32_to_cpu(desc.num_sectors) << 9 };
150
+ if (type == VIRTIO_BLK_T_DISCARD) {
151
+ if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
152
+ return 0;
153
+ }
154
+ } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
155
+ if (blk_co_pwrite_zeroes(vdev_blk->backend,
156
+ range[0], range[1], 0) == 0) {
157
+ return 0;
158
+ }
159
+ }
160
+
161
+ return -EINVAL;
162
+}
163
+
164
+static void coroutine_fn vu_block_flush(VuBlockReq *req)
165
+{
166
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
167
+ BlockBackend *backend = vdev_blk->backend;
168
+ blk_co_flush(backend);
169
+}
170
+
171
+struct req_data {
172
+ VuServer *server;
173
+ VuVirtq *vq;
174
+ VuVirtqElement *elem;
175
+};
176
+
177
+static void coroutine_fn vu_block_virtio_process_req(void *opaque)
178
+{
179
+ struct req_data *data = opaque;
180
+ VuServer *server = data->server;
181
+ VuVirtq *vq = data->vq;
182
+ VuVirtqElement *elem = data->elem;
183
+ uint32_t type;
184
+ VuBlockReq *req;
185
+
186
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
187
+ BlockBackend *backend = vdev_blk->backend;
188
+
189
+ struct iovec *in_iov = elem->in_sg;
190
+ struct iovec *out_iov = elem->out_sg;
191
+ unsigned in_num = elem->in_num;
192
+ unsigned out_num = elem->out_num;
193
+ /* refer to hw/block/virtio_blk.c */
194
+ if (elem->out_num < 1 || elem->in_num < 1) {
195
+ error_report("virtio-blk request missing headers");
196
+ free(elem);
197
+ return;
198
+ }
199
+
200
+ req = g_new0(VuBlockReq, 1);
201
+ req->server = server;
202
+ req->vq = vq;
203
+ req->elem = elem;
204
+
205
+ if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
206
+ sizeof(req->out)) != sizeof(req->out))) {
207
+ error_report("virtio-blk request outhdr too short");
208
+ goto err;
209
+ }
210
+
211
+ iov_discard_front(&out_iov, &out_num, sizeof(req->out));
212
+
213
+ if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
214
+ error_report("virtio-blk request inhdr too short");
215
+ goto err;
216
+ }
217
+
218
+ /* We always touch the last byte, so just see how big in_iov is. */
219
+ req->in = (void *)in_iov[in_num - 1].iov_base
220
+ + in_iov[in_num - 1].iov_len
221
+ - sizeof(struct virtio_blk_inhdr);
222
+ iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
223
+
224
+ type = le32_to_cpu(req->out.type);
225
+ switch (type & ~VIRTIO_BLK_T_BARRIER) {
226
+ case VIRTIO_BLK_T_IN:
227
+ case VIRTIO_BLK_T_OUT: {
228
+ ssize_t ret = 0;
229
+ bool is_write = type & VIRTIO_BLK_T_OUT;
230
+ req->sector_num = le64_to_cpu(req->out.sector);
231
+
232
+ int64_t offset = req->sector_num * vdev_blk->blk_size;
233
+ QEMUIOVector qiov;
234
+ if (is_write) {
235
+ qemu_iovec_init_external(&qiov, out_iov, out_num);
236
+ ret = blk_co_pwritev(backend, offset, qiov.size,
237
+ &qiov, 0);
238
+ } else {
239
+ qemu_iovec_init_external(&qiov, in_iov, in_num);
240
+ ret = blk_co_preadv(backend, offset, qiov.size,
241
+ &qiov, 0);
242
+ }
243
+ if (ret >= 0) {
244
+ req->in->status = VIRTIO_BLK_S_OK;
245
+ } else {
246
+ req->in->status = VIRTIO_BLK_S_IOERR;
247
+ }
248
+ break;
249
+ }
250
+ case VIRTIO_BLK_T_FLUSH:
251
+ vu_block_flush(req);
252
+ req->in->status = VIRTIO_BLK_S_OK;
253
+ break;
254
+ case VIRTIO_BLK_T_GET_ID: {
255
+ size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
256
+ VIRTIO_BLK_ID_BYTES);
257
+ snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
258
+ req->in->status = VIRTIO_BLK_S_OK;
259
+ req->size = elem->in_sg[0].iov_len;
260
+ break;
261
+ }
262
+ case VIRTIO_BLK_T_DISCARD:
263
+ case VIRTIO_BLK_T_WRITE_ZEROES: {
264
+ int rc;
265
+ rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
266
+ out_num, type);
267
+ if (rc == 0) {
268
+ req->in->status = VIRTIO_BLK_S_OK;
269
+ } else {
270
+ req->in->status = VIRTIO_BLK_S_IOERR;
271
+ }
272
+ break;
273
+ }
274
+ default:
275
+ req->in->status = VIRTIO_BLK_S_UNSUPP;
276
+ break;
277
+ }
278
+
279
+ vu_block_req_complete(req);
280
+ return;
281
+
282
+err:
283
+ free(elem);
284
+ g_free(req);
285
+ return;
286
+}
287
+
288
+static void vu_block_process_vq(VuDev *vu_dev, int idx)
289
+{
290
+ VuServer *server;
291
+ VuVirtq *vq;
292
+ struct req_data *req_data;
293
+
294
+ server = container_of(vu_dev, VuServer, vu_dev);
295
+ assert(server);
296
+
297
+ vq = vu_get_queue(vu_dev, idx);
298
+ assert(vq);
299
+ VuVirtqElement *elem;
300
+ while (1) {
301
+ elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
302
+ sizeof(VuBlockReq));
303
+ if (elem) {
304
+ req_data = g_new0(struct req_data, 1);
305
+ req_data->server = server;
306
+ req_data->vq = vq;
307
+ req_data->elem = elem;
308
+ Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
309
+ req_data);
310
+ aio_co_enter(server->ioc->ctx, co);
311
+ } else {
312
+ break;
313
+ }
314
+ }
315
+}
316
+
317
+static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
318
+{
319
+ VuVirtq *vq;
320
+
321
+ assert(vu_dev);
322
+
323
+ vq = vu_get_queue(vu_dev, idx);
324
+ vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
325
+}
326
+
327
+static uint64_t vu_block_get_features(VuDev *dev)
328
+{
329
+ uint64_t features;
330
+ VuServer *server = container_of(dev, VuServer, vu_dev);
331
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
332
+ features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
333
+ 1ull << VIRTIO_BLK_F_SEG_MAX |
334
+ 1ull << VIRTIO_BLK_F_TOPOLOGY |
335
+ 1ull << VIRTIO_BLK_F_BLK_SIZE |
336
+ 1ull << VIRTIO_BLK_F_FLUSH |
337
+ 1ull << VIRTIO_BLK_F_DISCARD |
338
+ 1ull << VIRTIO_BLK_F_WRITE_ZEROES |
339
+ 1ull << VIRTIO_BLK_F_CONFIG_WCE |
340
+ 1ull << VIRTIO_F_VERSION_1 |
341
+ 1ull << VIRTIO_RING_F_INDIRECT_DESC |
342
+ 1ull << VIRTIO_RING_F_EVENT_IDX |
343
+ 1ull << VHOST_USER_F_PROTOCOL_FEATURES;
344
+
345
+ if (!vdev_blk->writable) {
346
+ features |= 1ull << VIRTIO_BLK_F_RO;
347
+ }
348
+
349
+ return features;
350
+}
351
+
352
+static uint64_t vu_block_get_protocol_features(VuDev *dev)
353
+{
354
+ return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
355
+ 1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
356
+}
357
+
358
+static int
359
+vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
360
+{
361
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
362
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
363
+ memcpy(config, &vdev_blk->blkcfg, len);
364
+
365
+ return 0;
366
+}
367
+
368
+static int
369
+vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
370
+ uint32_t offset, uint32_t size, uint32_t flags)
371
+{
372
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
373
+ VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
374
+ uint8_t wce;
375
+
376
+ /* don't support live migration */
377
+ if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
378
+ return -EINVAL;
379
+ }
380
+
381
+ if (offset != offsetof(struct virtio_blk_config, wce) ||
382
+ size != 1) {
383
+ return -EINVAL;
384
+ }
385
+
386
+ wce = *data;
387
+ vdev_blk->blkcfg.wce = wce;
388
+ blk_set_enable_write_cache(vdev_blk->backend, wce);
389
+ return 0;
390
+}
391
+
392
+/*
393
+ * When the client disconnects, it sends a VHOST_USER_NONE request
394
+ * and vu_process_message will simple call exit which cause the VM
395
+ * to exit abruptly.
396
+ * To avoid this issue, process VHOST_USER_NONE request ahead
397
+ * of vu_process_message.
398
+ *
399
+ */
400
+static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
401
+{
402
+ if (vmsg->request == VHOST_USER_NONE) {
403
+ dev->panic(dev, "disconnect");
404
+ return true;
405
+ }
406
+ return false;
407
+}
408
+
409
+static const VuDevIface vu_block_iface = {
410
+ .get_features = vu_block_get_features,
411
+ .queue_set_started = vu_block_queue_set_started,
412
+ .get_protocol_features = vu_block_get_protocol_features,
413
+ .get_config = vu_block_get_config,
414
+ .set_config = vu_block_set_config,
415
+ .process_msg = vu_block_process_msg,
416
+};
417
+
418
+static void blk_aio_attached(AioContext *ctx, void *opaque)
419
+{
420
+ VuBlockDev *vub_dev = opaque;
421
+ aio_context_acquire(ctx);
422
+ vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
423
+ aio_context_release(ctx);
424
+}
425
+
426
+static void blk_aio_detach(void *opaque)
427
+{
428
+ VuBlockDev *vub_dev = opaque;
429
+ AioContext *ctx = vub_dev->vu_server.ctx;
430
+ aio_context_acquire(ctx);
431
+ vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
432
+ aio_context_release(ctx);
433
+}
434
+
435
+static void
436
+vu_block_initialize_config(BlockDriverState *bs,
437
+ struct virtio_blk_config *config, uint32_t blk_size)
438
+{
439
+ config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
440
+ config->blk_size = blk_size;
441
+ config->size_max = 0;
442
+ config->seg_max = 128 - 2;
443
+ config->min_io_size = 1;
444
+ config->opt_io_size = 1;
445
+ config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
446
+ config->max_discard_sectors = 32768;
447
+ config->max_discard_seg = 1;
448
+ config->discard_sector_alignment = config->blk_size >> 9;
449
+ config->max_write_zeroes_sectors = 32768;
450
+ config->max_write_zeroes_seg = 1;
451
+}
452
+
453
+static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
454
+{
455
+
456
+ BlockBackend *blk;
457
+ Error *local_error = NULL;
458
+ const char *node_name = vu_block_device->node_name;
459
+ bool writable = vu_block_device->writable;
460
+ uint64_t perm = BLK_PERM_CONSISTENT_READ;
461
+ int ret;
462
+
463
+ AioContext *ctx;
464
+
465
+ BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
466
+
467
+ if (!bs) {
468
+ error_propagate(errp, local_error);
469
+ return NULL;
470
+ }
471
+
472
+ if (bdrv_is_read_only(bs)) {
473
+ writable = false;
474
+ }
475
+
476
+ if (writable) {
477
+ perm |= BLK_PERM_WRITE;
478
+ }
479
+
480
+ ctx = bdrv_get_aio_context(bs);
481
+ aio_context_acquire(ctx);
482
+ bdrv_invalidate_cache(bs, NULL);
483
+ aio_context_release(ctx);
484
+
485
+ /*
486
+ * Don't allow resize while the vhost user server is running,
487
+ * otherwise we don't care what happens with the node.
488
+ */
489
+ blk = blk_new(bdrv_get_aio_context(bs), perm,
490
+ BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
491
+ BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
492
+ ret = blk_insert_bs(blk, bs, errp);
493
+
494
+ if (ret < 0) {
495
+ goto fail;
496
+ }
497
+
498
+ blk_set_enable_write_cache(blk, false);
499
+
500
+ blk_set_allow_aio_context_change(blk, true);
501
+
502
+ vu_block_device->blkcfg.wce = 0;
503
+ vu_block_device->backend = blk;
504
+ if (!vu_block_device->blk_size) {
505
+ vu_block_device->blk_size = BDRV_SECTOR_SIZE;
506
+ }
507
+ vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
508
+ blk_set_guest_block_size(blk, vu_block_device->blk_size);
509
+ vu_block_initialize_config(bs, &vu_block_device->blkcfg,
510
+ vu_block_device->blk_size);
511
+ return vu_block_device;
512
+
513
+fail:
514
+ blk_unref(blk);
515
+ return NULL;
516
+}
517
+
518
+static void vu_block_deinit(VuBlockDev *vu_block_device)
519
+{
520
+ if (vu_block_device->backend) {
521
+ blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
522
+ blk_aio_detach, vu_block_device);
523
+ }
524
+
525
+ blk_unref(vu_block_device->backend);
526
+}
527
+
528
+static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
529
+{
530
+ vhost_user_server_stop(&vu_block_device->vu_server);
531
+ vu_block_deinit(vu_block_device);
532
+}
533
+
534
+static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
535
+ Error **errp)
536
+{
537
+ AioContext *ctx;
538
+ SocketAddress *addr = vu_block_device->addr;
539
+
540
+ if (!vu_block_init(vu_block_device, errp)) {
541
+ return;
542
+ }
543
+
544
+ ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
545
+
546
+ if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
547
+ VHOST_USER_BLK_MAX_QUEUES,
548
+ NULL, &vu_block_iface,
549
+ errp)) {
550
+ goto error;
551
+ }
552
+
553
+ blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
554
+ blk_aio_detach, vu_block_device);
555
+ vu_block_device->running = true;
556
+ return;
557
+
558
+ error:
559
+ vu_block_deinit(vu_block_device);
560
+}
561
+
562
+static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
563
+{
564
+ if (vus->running) {
565
+ error_setg(errp, "The property can't be modified "
566
+ "while the server is running");
567
+ return false;
568
+ }
569
+ return true;
570
+}
571
+
572
+static void vu_set_node_name(Object *obj, const char *value, Error **errp)
573
+{
574
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
575
+
576
+ if (!vu_prop_modifiable(vus, errp)) {
577
+ return;
578
+ }
579
+
580
+ if (vus->node_name) {
581
+ g_free(vus->node_name);
582
+ }
583
+
584
+ vus->node_name = g_strdup(value);
585
+}
586
+
587
+static char *vu_get_node_name(Object *obj, Error **errp)
588
+{
589
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
590
+ return g_strdup(vus->node_name);
591
+}
592
+
593
+static void free_socket_addr(SocketAddress *addr)
594
+{
595
+ g_free(addr->u.q_unix.path);
596
+ g_free(addr);
597
+}
598
+
599
+static void vu_set_unix_socket(Object *obj, const char *value,
600
+ Error **errp)
601
+{
602
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
603
+
604
+ if (!vu_prop_modifiable(vus, errp)) {
605
+ return;
606
+ }
607
+
608
+ if (vus->addr) {
609
+ free_socket_addr(vus->addr);
610
+ }
611
+
612
+ SocketAddress *addr = g_new0(SocketAddress, 1);
613
+ addr->type = SOCKET_ADDRESS_TYPE_UNIX;
614
+ addr->u.q_unix.path = g_strdup(value);
615
+ vus->addr = addr;
616
+}
617
+
618
+static char *vu_get_unix_socket(Object *obj, Error **errp)
619
+{
620
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
621
+ return g_strdup(vus->addr->u.q_unix.path);
622
+}
623
+
624
+static bool vu_get_block_writable(Object *obj, Error **errp)
625
+{
626
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
627
+ return vus->writable;
628
+}
629
+
630
+static void vu_set_block_writable(Object *obj, bool value, Error **errp)
631
+{
632
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
633
+
634
+ if (!vu_prop_modifiable(vus, errp)) {
635
+ return;
636
+ }
637
+
638
+ vus->writable = value;
639
+}
640
+
641
+static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
642
+ void *opaque, Error **errp)
643
+{
644
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
645
+ uint32_t value = vus->blk_size;
646
+
647
+ visit_type_uint32(v, name, &value, errp);
648
+}
649
+
650
+static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
651
+ void *opaque, Error **errp)
652
+{
653
+ VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
654
+
655
+ Error *local_err = NULL;
656
+ uint32_t value;
657
+
658
+ if (!vu_prop_modifiable(vus, errp)) {
659
+ return;
660
+ }
661
+
662
+ visit_type_uint32(v, name, &value, &local_err);
663
+ if (local_err) {
664
+ goto out;
665
+ }
666
+
667
+ check_block_size(object_get_typename(obj), name, value, &local_err);
668
+ if (local_err) {
669
+ goto out;
670
+ }
671
+
672
+ vus->blk_size = value;
673
+
674
+out:
675
+ error_propagate(errp, local_err);
676
+}
677
+
678
+static void vhost_user_blk_server_instance_finalize(Object *obj)
679
+{
680
+ VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
681
+
682
+ vhost_user_blk_server_stop(vub);
683
+
684
+ /*
685
+ * Unlike object_property_add_str, object_class_property_add_str
686
+ * doesn't have a release method. Thus manual memory freeing is
687
+ * needed.
688
+ */
689
+ free_socket_addr(vub->addr);
690
+ g_free(vub->node_name);
691
+}
692
+
693
+static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
694
+{
695
+ VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
696
+
697
+ vhost_user_blk_server_start(vub, errp);
698
+}
699
+
700
+static void vhost_user_blk_server_class_init(ObjectClass *klass,
701
+ void *class_data)
702
+{
703
+ UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
704
+ ucc->complete = vhost_user_blk_server_complete;
705
+
706
+ object_class_property_add_bool(klass, "writable",
707
+ vu_get_block_writable,
708
+ vu_set_block_writable);
709
+
710
+ object_class_property_add_str(klass, "node-name",
711
+ vu_get_node_name,
712
+ vu_set_node_name);
713
+
714
+ object_class_property_add_str(klass, "unix-socket",
715
+ vu_get_unix_socket,
716
+ vu_set_unix_socket);
717
+
718
+ object_class_property_add(klass, "logical-block-size", "uint32",
719
+ vu_get_blk_size, vu_set_blk_size,
720
+ NULL, NULL);
721
+}
722
+
723
+static const TypeInfo vhost_user_blk_server_info = {
724
+ .name = TYPE_VHOST_USER_BLK_SERVER,
725
+ .parent = TYPE_OBJECT,
726
+ .instance_size = sizeof(VuBlockDev),
727
+ .instance_finalize = vhost_user_blk_server_instance_finalize,
728
+ .class_init = vhost_user_blk_server_class_init,
729
+ .interfaces = (InterfaceInfo[]) {
730
+ {TYPE_USER_CREATABLE},
731
+ {}
732
+ },
733
+};
734
+
735
+static void vhost_user_blk_server_register_types(void)
736
+{
737
+ type_register_static(&vhost_user_blk_server_info);
738
+}
739
+
740
+type_init(vhost_user_blk_server_register_types)
741
diff --git a/softmmu/vl.c b/softmmu/vl.c
742
index XXXXXXX..XXXXXXX 100644
743
--- a/softmmu/vl.c
744
+++ b/softmmu/vl.c
745
@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
746
}
747
#endif
748
749
+ /* Reason: vhost-user-blk-server property "node-name" */
750
+ if (g_str_equal(type, "vhost-user-blk-server")) {
751
+ return false;
752
+ }
753
/*
754
* Reason: filter-* property "netdev" etc.
755
*/
756
diff --git a/block/meson.build b/block/meson.build
757
index XXXXXXX..XXXXXXX 100644
758
--- a/block/meson.build
759
+++ b/block/meson.build
760
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
761
block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
762
block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
763
block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
764
+block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
765
block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
766
block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
767
block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
768
--
769
2.26.2
770
diff view generated by jsdifflib
New patch
[PULL v2 07/28] MAINTAINERS: Add vhost-user block device backend server maintainer
1
From: Coiby Xu <coiby.xu@gmail.com>
1
2
3
Suggested-by: Stefano Garzarella <sgarzare@redhat.com>
4
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
5
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
6
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
7
Message-id: 20200918080912.321299-8-coiby.xu@gmail.com
8
[Removed reference to vhost-user-blk-test.c, it will be sent in a
9
separate pull request.
10
--Stefan]
11
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
12
---
13
MAINTAINERS | 7 +++++++
14
1 file changed, 7 insertions(+)
15
16
diff --git a/MAINTAINERS b/MAINTAINERS
17
index XXXXXXX..XXXXXXX 100644
18
--- a/MAINTAINERS
19
+++ b/MAINTAINERS
20
@@ -XXX,XX +XXX,XX @@ L: qemu-block@nongnu.org
21
S: Supported
22
F: tests/image-fuzzer/
23
24
+Vhost-user block device backend server
25
+M: Coiby Xu <Coiby.Xu@gmail.com>
26
+S: Maintained
27
+F: block/export/vhost-user-blk-server.c
28
+F: util/vhost-user-server.c
29
+F: tests/qtest/libqos/vhost-user-blk.c
30
+
31
Replication
32
M: Wen Congyang <wencongyang2@huawei.com>
33
M: Xie Changlong <xiechanglong.d@gmail.com>
34
--
35
2.26.2
36
diff view generated by jsdifflib
New patch
[PULL v2 08/28] util/vhost-user-server: s/fileds/fields/ typo fix
1
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
2
Message-id: 20200924151549.913737-3-stefanha@redhat.com
3
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
---
5
util/vhost-user-server.c | 2 +-
6
1 file changed, 1 insertion(+), 1 deletion(-)
1
7
8
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
9
index XXXXXXX..XXXXXXX 100644
10
--- a/util/vhost-user-server.c
11
+++ b/util/vhost-user-server.c
12
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
13
return false;
14
}
15
16
- /* zero out unspecified fileds */
17
+ /* zero out unspecified fields */
18
*server = (VuServer) {
19
.listener = listener,
20
.vu_iface = vu_iface,
21
--
22
2.26.2
23
diff view generated by jsdifflib
[Qemu-devel] [PULL 01/21] iotests: Fix a problem in common.filter
[PULL v2 09/28] util/vhost-user-server: drop unnecessary QOM cast
1
From: QingFeng Hao <haoqf@linux.vnet.ibm.com>
1
We already have access to the value with the correct type (ioc and sioc
2
are the same QIOChannel).
2
3
3
If TEST_DIR is set to /tmp, test case 144 will fail. The reason is that
4
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
TEST_DIR resembles 144's test image name tmp.qcow2.
5
Message-id: 20200924151549.913737-4-stefanha@redhat.com
5
When 144 is testing $TEST_DIR/tmp.qcow2, it wants to replace
6
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
$TEST_DIR/tmp.qcow2 to TEST_DIR/tmp.qcow2, but actually it will fail
7
and get TEST_DIRTEST_DIR.qcow2 in this case.
8
The fix is just to modify the code to replace $TEST_DIR/ with TEST_DIR/.
9
10
Signed-off-by: QingFeng Hao <haoqf@linux.vnet.ibm.com>
11
Message-id: 20161216054723.96055-2-haoqf@linux.vnet.ibm.com
12
Reviewed-by: Eric Blake <eblake@redhat.com>
13
[mreitz: Fixed commit message and dropped superfluous escaping]
14
Signed-off-by: Max Reitz <mreitz@redhat.com>
15
---
7
---
16
tests/qemu-iotests/common.filter | 2 +-
8
util/vhost-user-server.c | 2 +-
17
1 file changed, 1 insertion(+), 1 deletion(-)
9
1 file changed, 1 insertion(+), 1 deletion(-)
18
10
19
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
11
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
20
index XXXXXXX..XXXXXXX 100644
12
index XXXXXXX..XXXXXXX 100644
21
--- a/tests/qemu-iotests/common.filter
13
--- a/util/vhost-user-server.c
22
+++ b/tests/qemu-iotests/common.filter
14
+++ b/util/vhost-user-server.c
23
@@ -XXX,XX +XXX,XX @@ _filter_generated_node_ids()
15
@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
24
# replace occurrences of the actual TEST_DIR value with TEST_DIR
16
server->ioc = QIO_CHANNEL(sioc);
25
_filter_testdir()
17
object_ref(OBJECT(server->ioc));
26
{
18
qio_channel_attach_aio_context(server->ioc, server->ctx);
27
- sed -e "s#$TEST_DIR#TEST_DIR#g"
19
- qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
28
+ sed -e "s#$TEST_DIR/#TEST_DIR/#g"
20
+ qio_channel_set_blocking(server->ioc, false, NULL);
21
vu_client_start(server);
29
}
22
}
30
23
31
# replace occurrences of the actual IMGFMT value with IMGFMT
32
--
24
--
33
2.11.0
25
2.26.2
34
26
35
diff view generated by jsdifflib
[Qemu-devel] [PULL 11/21] block/qapi: reduce the execution time of qmp_query_blockstats
[PULL v2 10/28] util/vhost-user-server: drop unnecessary watch deletion
1
From: Dou Liyang <douly.fnst@cn.fujitsu.com>
1
Explicitly deleting watches is not necessary since libvhost-user calls
2
remove_watch() during vu_deinit(). Add an assertion to check this
3
though.
2
4
3
In order to reduce the execution time, this patch optimize
5
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
the qmp_query_blockstats():
6
Message-id: 20200924151549.913737-5-stefanha@redhat.com
5
Remove the next_query_bds function.
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
Remove the bdrv_query_stats function.
8
---
7
Remove some judgement sentence.
9
util/vhost-user-server.c | 19 ++++---------------
10
1 file changed, 4 insertions(+), 15 deletions(-)
8
11
9
The original qmp_query_blockstats calls next_query_bds to get
12
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
10
the next objects in each loops. In the next_query_bds, it checks
11
the query_nodes and blk. It also call bdrv_query_stats to get
12
the stats, In the bdrv_query_stats, it checks blk and bs each
13
times. This waste more times, which may stall the main loop a
14
bit. And if the disk is too many and donot use the dataplane
15
feature, this may affect the performance in main loop thread.
16
17
This patch removes that two functions, and makes the structure
18
clearly.
19
20
Signed-off-by: Dou Liyang <douly.fnst@cn.fujitsu.com>
21
Message-id: 1484467275-27919-3-git-send-email-douly.fnst@cn.fujitsu.com
22
Reviewed-by: Markus Armbruster <armbru@redhat.com>
23
[mreitz: Removed duplicate info->value assignment]
24
Signed-off-by: Max Reitz <mreitz@redhat.com>
25
---
26
block/qapi.c | 73 ++++++++++++++++++++++++------------------------------------
27
1 file changed, 29 insertions(+), 44 deletions(-)
28
29
diff --git a/block/qapi.c b/block/qapi.c
30
index XXXXXXX..XXXXXXX 100644
13
index XXXXXXX..XXXXXXX 100644
31
--- a/block/qapi.c
14
--- a/util/vhost-user-server.c
32
+++ b/block/qapi.c
15
+++ b/util/vhost-user-server.c
33
@@ -XXX,XX +XXX,XX @@ static BlockStats *bdrv_query_bds_stats(const BlockDriverState *bs,
16
@@ -XXX,XX +XXX,XX @@ static void close_client(VuServer *server)
34
return s;
17
/* When this is set vu_client_trip will stop new processing vhost-user message */
35
}
18
server->sioc = NULL;
36
19
37
-static BlockStats *bdrv_query_stats(BlockBackend *blk,
20
- VuFdWatch *vu_fd_watch, *next;
38
- const BlockDriverState *bs,
21
- QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
39
- bool query_backing)
22
- aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
40
-{
23
- NULL, NULL, NULL);
41
- BlockStats *s;
42
-
43
- s = bdrv_query_bds_stats(bs, query_backing);
44
-
45
- if (blk) {
46
- s->has_device = true;
47
- s->device = g_strdup(blk_name(blk));
48
- bdrv_query_blk_stats(s->stats, blk);
49
- }
24
- }
50
-
25
-
51
- return s;
26
- while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
52
-}
27
- QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
53
-
28
- if (!vu_fd_watch->processing) {
54
BlockInfoList *qmp_query_block(Error **errp)
29
- QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
55
{
30
- g_free(vu_fd_watch);
56
BlockInfoList *head = NULL, **p_next = &head;
31
- }
57
@@ -XXX,XX +XXX,XX @@ BlockInfoList *qmp_query_block(Error **errp)
32
- }
58
return head;
59
}
60
61
-static bool next_query_bds(BlockBackend **blk, BlockDriverState **bs,
62
- bool query_nodes)
63
-{
64
- if (query_nodes) {
65
- *bs = bdrv_next_node(*bs);
66
- return !!*bs;
67
- }
33
- }
68
-
34
-
69
- *blk = blk_next(*blk);
35
while (server->processing_msg) {
70
- *bs = *blk ? blk_bs(*blk) : NULL;
36
if (server->ioc->read_coroutine) {
71
-
37
server->ioc->read_coroutine = NULL;
72
- return !!*blk;
38
@@ -XXX,XX +XXX,XX @@ static void close_client(VuServer *server)
73
-}
39
}
74
-
40
75
BlockStatsList *qmp_query_blockstats(bool has_query_nodes,
41
vu_deinit(&server->vu_dev);
76
bool query_nodes,
77
Error **errp)
78
{
79
BlockStatsList *head = NULL, **p_next = &head;
80
- BlockBackend *blk = NULL;
81
- BlockDriverState *bs = NULL;
82
+ BlockBackend *blk;
83
+ BlockDriverState *bs;
84
85
/* Just to be safe if query_nodes is not always initialized */
86
- query_nodes = has_query_nodes && query_nodes;
87
-
88
- while (next_query_bds(&blk, &bs, query_nodes)) {
89
- BlockStatsList *info = g_malloc0(sizeof(*info));
90
- AioContext *ctx = blk ? blk_get_aio_context(blk)
91
- : bdrv_get_aio_context(bs);
92
+ if (has_query_nodes && query_nodes) {
93
+ for (bs = bdrv_next_node(NULL); bs; bs = bdrv_next_node(bs)) {
94
+ BlockStatsList *info = g_malloc0(sizeof(*info));
95
+ AioContext *ctx = bdrv_get_aio_context(bs);
96
97
- aio_context_acquire(ctx);
98
- info->value = bdrv_query_stats(blk, bs, !query_nodes);
99
- aio_context_release(ctx);
100
+ aio_context_acquire(ctx);
101
+ info->value = bdrv_query_bds_stats(bs, false);
102
+ aio_context_release(ctx);
103
104
- *p_next = info;
105
- p_next = &info->next;
106
+ *p_next = info;
107
+ p_next = &info->next;
108
+ }
109
+ } else {
110
+ for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
111
+ BlockStatsList *info = g_malloc0(sizeof(*info));
112
+ AioContext *ctx = blk_get_aio_context(blk);
113
+ BlockStats *s;
114
+
42
+
115
+ aio_context_acquire(ctx);
43
+ /* vu_deinit() should have called remove_watch() */
116
+ s = bdrv_query_bds_stats(blk_bs(blk), true);
44
+ assert(QTAILQ_EMPTY(&server->vu_fd_watches));
117
+ s->has_device = true;
118
+ s->device = g_strdup(blk_name(blk));
119
+ bdrv_query_blk_stats(s->stats, blk);
120
+ aio_context_release(ctx);
121
+
45
+
122
+ info->value = s;
46
object_unref(OBJECT(sioc));
123
+ *p_next = info;
47
object_unref(OBJECT(server->ioc));
124
+ p_next = &info->next;
48
}
125
+ }
126
}
127
128
return head;
129
--
49
--
130
2.11.0
50
2.26.2
131
51
132
diff view generated by jsdifflib
[Qemu-devel] [PULL 10/21] block/qapi: reduce the coupling between the bdrv_query_stats and bdrv_query_bds_stats
[PULL v2 11/28] block/export: consolidate request structs into VuBlockReq
1
From: Dou Liyang <douly.fnst@cn.fujitsu.com>
1
Only one struct is needed per request. Drop req_data and the separate
2
VuBlockReq instance. Instead let vu_queue_pop() allocate everything at
3
once.
2
4
3
The bdrv_query_stats and bdrv_query_bds_stats functions need to call
5
This fixes the req_data memory leak in vu_block_virtio_process_req().
4
each other, that increases the coupling. it also makes the program
5
complicated and makes some unnecessary tests.
6
6
7
Remove the call from bdrv_query_bds_stats to bdrv_query_stats, just
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
8
take some recursion to make it clearly.
8
Message-id: 20200924151549.913737-6-stefanha@redhat.com
9
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
10
---
11
block/export/vhost-user-blk-server.c | 68 +++++++++-------------------
12
1 file changed, 21 insertions(+), 47 deletions(-)
9
13
10
Avoid testing whether the blk is NULL during querying the bds stats.
14
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
11
It is unnecessary.
12
13
Signed-off-by: Dou Liyang <douly.fnst@cn.fujitsu.com>
14
Message-id: 1484467275-27919-2-git-send-email-douly.fnst@cn.fujitsu.com
15
Reviewed-by: Markus Armbruster <armbru@redhat.com>
16
Signed-off-by: Max Reitz <mreitz@redhat.com>
17
---
18
block/qapi.c | 26 ++++++++++++++------------
19
1 file changed, 14 insertions(+), 12 deletions(-)
20
21
diff --git a/block/qapi.c b/block/qapi.c
22
index XXXXXXX..XXXXXXX 100644
15
index XXXXXXX..XXXXXXX 100644
23
--- a/block/qapi.c
16
--- a/block/export/vhost-user-blk-server.c
24
+++ b/block/qapi.c
17
+++ b/block/export/vhost-user-blk-server.c
25
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
18
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
26
qapi_free_BlockInfo(info);
19
};
20
21
typedef struct VuBlockReq {
22
- VuVirtqElement *elem;
23
+ VuVirtqElement elem;
24
int64_t sector_num;
25
size_t size;
26
struct virtio_blk_inhdr *in;
27
@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
28
VuDev *vu_dev = &req->server->vu_dev;
29
30
/* IO size with 1 extra status byte */
31
- vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
32
+ vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
33
vu_queue_notify(vu_dev, req->vq);
34
35
- if (req->elem) {
36
- free(req->elem);
37
- }
38
-
39
- g_free(req);
40
+ free(req);
27
}
41
}
28
42
29
-static BlockStats *bdrv_query_stats(BlockBackend *blk,
43
static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
30
- const BlockDriverState *bs,
44
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_flush(VuBlockReq *req)
31
- bool query_backing);
45
blk_co_flush(backend);
46
}
47
48
-struct req_data {
49
- VuServer *server;
50
- VuVirtq *vq;
51
- VuVirtqElement *elem;
52
-};
32
-
53
-
33
static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
54
static void coroutine_fn vu_block_virtio_process_req(void *opaque)
34
{
55
{
35
BlockAcctStats *stats = blk_get_stats(blk);
56
- struct req_data *data = opaque;
36
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
57
- VuServer *server = data->server;
58
- VuVirtq *vq = data->vq;
59
- VuVirtqElement *elem = data->elem;
60
+ VuBlockReq *req = opaque;
61
+ VuServer *server = req->server;
62
+ VuVirtqElement *elem = &req->elem;
63
uint32_t type;
64
- VuBlockReq *req;
65
66
VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
67
BlockBackend *backend = vdev_blk->backend;
68
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
69
struct iovec *out_iov = elem->out_sg;
70
unsigned in_num = elem->in_num;
71
unsigned out_num = elem->out_num;
72
+
73
/* refer to hw/block/virtio_blk.c */
74
if (elem->out_num < 1 || elem->in_num < 1) {
75
error_report("virtio-blk request missing headers");
76
- free(elem);
77
- return;
78
+ goto err;
79
}
80
81
- req = g_new0(VuBlockReq, 1);
82
- req->server = server;
83
- req->vq = vq;
84
- req->elem = elem;
85
-
86
if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
87
sizeof(req->out)) != sizeof(req->out))) {
88
error_report("virtio-blk request outhdr too short");
89
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
90
91
err:
92
free(elem);
93
- g_free(req);
94
- return;
95
}
96
97
static void vu_block_process_vq(VuDev *vu_dev, int idx)
98
{
99
- VuServer *server;
100
- VuVirtq *vq;
101
- struct req_data *req_data;
102
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
103
+ VuVirtq *vq = vu_get_queue(vu_dev, idx);
104
105
- server = container_of(vu_dev, VuServer, vu_dev);
106
- assert(server);
107
-
108
- vq = vu_get_queue(vu_dev, idx);
109
- assert(vq);
110
- VuVirtqElement *elem;
111
while (1) {
112
- elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
113
- sizeof(VuBlockReq));
114
- if (elem) {
115
- req_data = g_new0(struct req_data, 1);
116
- req_data->server = server;
117
- req_data->vq = vq;
118
- req_data->elem = elem;
119
- Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
120
- req_data);
121
- aio_co_enter(server->ioc->ctx, co);
122
- } else {
123
+ VuBlockReq *req;
124
+
125
+ req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
126
+ if (!req) {
127
break;
128
}
129
+
130
+ req->server = server;
131
+ req->vq = vq;
132
+
133
+ Coroutine *co =
134
+ qemu_coroutine_create(vu_block_virtio_process_req, req);
135
+ qemu_coroutine_enter(co);
37
}
136
}
38
}
137
}
39
138
40
-static void bdrv_query_bds_stats(BlockStats *s, const BlockDriverState *bs,
41
+static BlockStats *bdrv_query_bds_stats(const BlockDriverState *bs,
42
bool query_backing)
43
{
44
+ BlockStats *s = NULL;
45
+
46
+ s = g_malloc0(sizeof(*s));
47
+ s->stats = g_malloc0(sizeof(*s->stats));
48
+
49
+ if (!bs) {
50
+ return s;
51
+ }
52
+
53
if (bdrv_get_node_name(bs)[0]) {
54
s->has_node_name = true;
55
s->node_name = g_strdup(bdrv_get_node_name(bs));
56
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_bds_stats(BlockStats *s, const BlockDriverState *bs,
57
58
if (bs->file) {
59
s->has_parent = true;
60
- s->parent = bdrv_query_stats(NULL, bs->file->bs, query_backing);
61
+ s->parent = bdrv_query_bds_stats(bs->file->bs, query_backing);
62
}
63
64
if (query_backing && bs->backing) {
65
s->has_backing = true;
66
- s->backing = bdrv_query_stats(NULL, bs->backing->bs, query_backing);
67
+ s->backing = bdrv_query_bds_stats(bs->backing->bs, query_backing);
68
}
69
70
+ return s;
71
}
72
73
static BlockStats *bdrv_query_stats(BlockBackend *blk,
74
@@ -XXX,XX +XXX,XX @@ static BlockStats *bdrv_query_stats(BlockBackend *blk,
75
{
76
BlockStats *s;
77
78
- s = g_malloc0(sizeof(*s));
79
- s->stats = g_malloc0(sizeof(*s->stats));
80
+ s = bdrv_query_bds_stats(bs, query_backing);
81
82
if (blk) {
83
s->has_device = true;
84
s->device = g_strdup(blk_name(blk));
85
bdrv_query_blk_stats(s->stats, blk);
86
}
87
- if (bs) {
88
- bdrv_query_bds_stats(s, bs, query_backing);
89
- }
90
91
return s;
92
}
93
--
139
--
94
2.11.0
140
2.26.2
95
141
96
diff view generated by jsdifflib
New patch
[PULL v2 12/28] util/vhost-user-server: drop unused DevicePanicNotifier
1
The device panic notifier callback is not used. Drop it.
1
2
3
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
Message-id: 20200924151549.913737-7-stefanha@redhat.com
5
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
---
7
util/vhost-user-server.h | 3 ---
8
block/export/vhost-user-blk-server.c | 3 +--
9
util/vhost-user-server.c | 6 ------
10
3 files changed, 1 insertion(+), 11 deletions(-)
11
12
diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
13
index XXXXXXX..XXXXXXX 100644
14
--- a/util/vhost-user-server.h
15
+++ b/util/vhost-user-server.h
16
@@ -XXX,XX +XXX,XX @@ typedef struct VuFdWatch {
17
} VuFdWatch;
18
19
typedef struct VuServer VuServer;
20
-typedef void DevicePanicNotifierFn(VuServer *server);
21
22
struct VuServer {
23
QIONetListener *listener;
24
AioContext *ctx;
25
- DevicePanicNotifierFn *device_panic_notifier;
26
int max_queues;
27
const VuDevIface *vu_iface;
28
VuDev vu_dev;
29
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
30
SocketAddress *unix_socket,
31
AioContext *ctx,
32
uint16_t max_queues,
33
- DevicePanicNotifierFn *device_panic_notifier,
34
const VuDevIface *vu_iface,
35
Error **errp);
36
37
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
38
index XXXXXXX..XXXXXXX 100644
39
--- a/block/export/vhost-user-blk-server.c
40
+++ b/block/export/vhost-user-blk-server.c
41
@@ -XXX,XX +XXX,XX @@ static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
42
ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
43
44
if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
45
- VHOST_USER_BLK_MAX_QUEUES,
46
- NULL, &vu_block_iface,
47
+ VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
48
errp)) {
49
goto error;
50
}
51
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
52
index XXXXXXX..XXXXXXX 100644
53
--- a/util/vhost-user-server.c
54
+++ b/util/vhost-user-server.c
55
@@ -XXX,XX +XXX,XX @@ static void panic_cb(VuDev *vu_dev, const char *buf)
56
close_client(server);
57
}
58
59
- if (server->device_panic_notifier) {
60
- server->device_panic_notifier(server);
61
- }
62
-
63
/*
64
* Set the callback function for network listener so another
65
* vhost-user client can connect to this server
66
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
67
SocketAddress *socket_addr,
68
AioContext *ctx,
69
uint16_t max_queues,
70
- DevicePanicNotifierFn *device_panic_notifier,
71
const VuDevIface *vu_iface,
72
Error **errp)
73
{
74
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
75
.vu_iface = vu_iface,
76
.max_queues = max_queues,
77
.ctx = ctx,
78
- .device_panic_notifier = device_panic_notifier,
79
};
80
81
qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
82
--
83
2.26.2
84
diff view generated by jsdifflib
New patch
[PULL v2 13/28] util/vhost-user-server: fix memory leak in vu_message_read()
1
fds[] is leaked when qio_channel_readv_full() fails.
1
2
3
Use vmsg->fds[] instead of keeping a local fds[] array. Then we can
4
reuse goto fail to clean up fds. vmsg->fd_num must be zeroed before the
5
loop to make this safe.
6
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
8
Message-id: 20200924151549.913737-8-stefanha@redhat.com
9
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
10
---
11
util/vhost-user-server.c | 50 ++++++++++++++++++----------------------
12
1 file changed, 23 insertions(+), 27 deletions(-)
13
14
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
15
index XXXXXXX..XXXXXXX 100644
16
--- a/util/vhost-user-server.c
17
+++ b/util/vhost-user-server.c
18
@@ -XXX,XX +XXX,XX @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
19
};
20
int rc, read_bytes = 0;
21
Error *local_err = NULL;
22
- /*
23
- * Store fds/nfds returned from qio_channel_readv_full into
24
- * temporary variables.
25
- *
26
- * VhostUserMsg is a packed structure, gcc will complain about passing
27
- * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
28
- * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
29
- * thus two temporary variables nfds and fds are used here.
30
- */
31
- size_t nfds = 0, nfds_t = 0;
32
const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
33
- int *fds_t = NULL;
34
VuServer *server = container_of(vu_dev, VuServer, vu_dev);
35
QIOChannel *ioc = server->ioc;
36
37
+ vmsg->fd_num = 0;
38
if (!ioc) {
39
error_report_err(local_err);
40
goto fail;
41
@@ -XXX,XX +XXX,XX @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
42
43
assert(qemu_in_coroutine());
44
do {
45
+ size_t nfds = 0;
46
+ int *fds = NULL;
47
+
48
/*
49
* qio_channel_readv_full may have short reads, keeping calling it
50
* until getting VHOST_USER_HDR_SIZE or 0 bytes in total
51
*/
52
- rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
53
+ rc = qio_channel_readv_full(ioc, &iov, 1, &fds, &nfds, &local_err);
54
if (rc < 0) {
55
if (rc == QIO_CHANNEL_ERR_BLOCK) {
56
+ assert(local_err == NULL);
57
qio_channel_yield(ioc, G_IO_IN);
58
continue;
59
} else {
60
error_report_err(local_err);
61
- return false;
62
+ goto fail;
63
}
64
}
65
- read_bytes += rc;
66
- if (nfds_t > 0) {
67
- if (nfds + nfds_t > max_fds) {
68
+
69
+ if (nfds > 0) {
70
+ if (vmsg->fd_num + nfds > max_fds) {
71
error_report("A maximum of %zu fds are allowed, "
72
"however got %zu fds now",
73
- max_fds, nfds + nfds_t);
74
+ max_fds, vmsg->fd_num + nfds);
75
+ g_free(fds);
76
goto fail;
77
}
78
- memcpy(vmsg->fds + nfds, fds_t,
79
- nfds_t *sizeof(vmsg->fds[0]));
80
- nfds += nfds_t;
81
- g_free(fds_t);
82
+ memcpy(vmsg->fds + vmsg->fd_num, fds, nfds * sizeof(vmsg->fds[0]));
83
+ vmsg->fd_num += nfds;
84
+ g_free(fds);
85
}
86
- if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
87
- break;
88
+
89
+ if (rc == 0) { /* socket closed */
90
+ goto fail;
91
}
92
- iov.iov_base = (char *)vmsg + read_bytes;
93
- iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
94
- } while (true);
95
96
- vmsg->fd_num = nfds;
97
+ iov.iov_base += rc;
98
+ iov.iov_len -= rc;
99
+ read_bytes += rc;
100
+ } while (read_bytes != VHOST_USER_HDR_SIZE);
101
+
102
/* qio_channel_readv_full will make socket fds blocking, unblock them */
103
vmsg_unblock_fds(vmsg);
104
if (vmsg->size > sizeof(vmsg->payload)) {
105
--
106
2.26.2
107
diff view generated by jsdifflib
[Qemu-devel] [PULL 15/21] qemu-io: Return non-zero exit code on failure
[PULL v2 14/28] util/vhost-user-server: check EOF when reading payload
1
From: Nir Soffer <nirsof@gmail.com>
1
Unexpected EOF is an error that must be reported.
2
2
3
The result of openfile was not checked, leading to failure deep in the
3
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
actual command with confusing error message, and exiting with exit code 0.
4
Message-id: 20200924151549.913737-9-stefanha@redhat.com
5
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
---
7
util/vhost-user-server.c | 6 ++++--
8
1 file changed, 4 insertions(+), 2 deletions(-)
5
9
6
Here is a simple example - trying to read with the wrong format:
10
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
7
8
$ touch file
9
$ qemu-io -f qcow2 -c 'read -P 1 0 1024' file; echo $?
10
can't open device file: Image is not in qcow2 format
11
no file open, try 'help open'
12
0
13
14
With this patch, we fail earlier with exit code 1:
15
16
$ ./qemu-io -f qcow2 -c 'read -P 1 0 1024' file; echo $?
17
can't open device file: Image is not in qcow2 format
18
1
19
20
Failing earlier, we don't log this error now:
21
22
no file open, try 'help open'
23
24
But some tests expected it; the line was removed from the test output.
25
26
Signed-off-by: Nir Soffer <nirsof@gmail.com>
27
Reviewed-by: Eric Blake <eblake@redhat.com>
28
Message-id: 20170201003120.23378-2-nirsof@gmail.com
29
Reviewed-by: Max Reitz <mreitz@redhat.com>
30
Signed-off-by: Max Reitz <mreitz@redhat.com>
31
---
32
qemu-io.c | 8 ++++++--
33
tests/qemu-iotests/059.out | 3 ---
34
tests/qemu-iotests/070.out | 1 -
35
tests/qemu-iotests/075.out | 7 -------
36
tests/qemu-iotests/076.out | 3 ---
37
tests/qemu-iotests/078.out | 6 ------
38
tests/qemu-iotests/080.out | 18 ------------------
39
tests/qemu-iotests/083.out | 17 -----------------
40
tests/qemu-iotests/088.out | 6 ------
41
tests/qemu-iotests/092.out | 12 ------------
42
tests/qemu-iotests/116.out | 7 -------
43
tests/qemu-iotests/131.out | 1 -
44
tests/qemu-iotests/140.out | 1 -
45
13 files changed, 6 insertions(+), 84 deletions(-)
46
47
diff --git a/qemu-io.c b/qemu-io.c
48
index XXXXXXX..XXXXXXX 100644
11
index XXXXXXX..XXXXXXX 100644
49
--- a/qemu-io.c
12
--- a/util/vhost-user-server.c
50
+++ b/qemu-io.c
13
+++ b/util/vhost-user-server.c
51
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
14
@@ -XXX,XX +XXX,XX @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
52
exit(1);
15
};
53
}
16
if (vmsg->size) {
54
opts = qemu_opts_to_qdict(qopts, NULL);
17
rc = qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err);
55
- openfile(NULL, flags, writethrough, opts);
18
- if (rc == -1) {
56
+ if (openfile(NULL, flags, writethrough, opts)) {
19
- error_report_err(local_err);
57
+ exit(1);
20
+ if (rc != 1) {
21
+ if (local_err) {
22
+ error_report_err(local_err);
58
+ }
23
+ }
59
} else {
24
goto fail;
60
if (format) {
61
opts = qdict_new();
62
qdict_put(opts, "driver", qstring_from_str(format));
63
}
64
- openfile(argv[optind], flags, writethrough, opts);
65
+ if (openfile(argv[optind], flags, writethrough, opts)) {
66
+ exit(1);
67
+ }
68
}
25
}
69
}
26
}
70
command_loop();
71
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
72
index XXXXXXX..XXXXXXX 100644
73
--- a/tests/qemu-iotests/059.out
74
+++ b/tests/qemu-iotests/059.out
75
@@ -XXX,XX +XXX,XX @@ QA output created by 059
76
=== Testing invalid granularity ===
77
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
78
can't open device TEST_DIR/t.vmdk: Invalid granularity, image may be corrupt
79
-no file open, try 'help open'
80
81
=== Testing too big L2 table size ===
82
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
83
can't open device TEST_DIR/t.vmdk: L2 table size too big
84
-no file open, try 'help open'
85
86
=== Testing too big L1 table size ===
87
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
88
can't open device TEST_DIR/t.vmdk: L1 size too big
89
-no file open, try 'help open'
90
91
=== Testing monolithicFlat creation and opening ===
92
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
93
diff --git a/tests/qemu-iotests/070.out b/tests/qemu-iotests/070.out
94
index XXXXXXX..XXXXXXX 100644
95
--- a/tests/qemu-iotests/070.out
96
+++ b/tests/qemu-iotests/070.out
97
@@ -XXX,XX +XXX,XX @@ QA output created by 070
98
can't open device TEST_DIR/iotest-dirtylog-10G-4M.vhdx: VHDX image file 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx' opened read-only, but contains a log that needs to be replayed
99
To replay the log, run:
100
qemu-img check -r all 'TEST_DIR/iotest-dirtylog-10G-4M.vhdx'
101
- no file open, try 'help open'
102
=== Verify open image replays log ===
103
read 18874368/18874368 bytes at offset 0
104
18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
105
diff --git a/tests/qemu-iotests/075.out b/tests/qemu-iotests/075.out
106
index XXXXXXX..XXXXXXX 100644
107
--- a/tests/qemu-iotests/075.out
108
+++ b/tests/qemu-iotests/075.out
109
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 1048064
110
111
== block_size must be a multiple of 512 ==
112
can't open device TEST_DIR/simple-pattern.cloop: block_size 513 must be a multiple of 512
113
-no file open, try 'help open'
114
115
== block_size cannot be zero ==
116
can't open device TEST_DIR/simple-pattern.cloop: block_size cannot be zero
117
-no file open, try 'help open'
118
119
== huge block_size ===
120
can't open device TEST_DIR/simple-pattern.cloop: block_size 4294966784 must be 64 MB or less
121
-no file open, try 'help open'
122
123
== offsets_size overflow ===
124
can't open device TEST_DIR/simple-pattern.cloop: n_blocks 4294967295 must be 536870911 or less
125
-no file open, try 'help open'
126
127
== refuse images that require too many offsets ===
128
can't open device TEST_DIR/simple-pattern.cloop: image requires too many offsets, try increasing block size
129
-no file open, try 'help open'
130
131
== refuse images with non-monotonically increasing offsets ==
132
can't open device TEST_DIR/simple-pattern.cloop: offsets not monotonically increasing at index 1, image file is corrupt
133
-no file open, try 'help open'
134
135
== refuse images with invalid compressed block size ==
136
can't open device TEST_DIR/simple-pattern.cloop: invalid compressed block size at index 1, image file is corrupt
137
-no file open, try 'help open'
138
*** done
139
diff --git a/tests/qemu-iotests/076.out b/tests/qemu-iotests/076.out
140
index XXXXXXX..XXXXXXX 100644
141
--- a/tests/qemu-iotests/076.out
142
+++ b/tests/qemu-iotests/076.out
143
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
144
145
== Negative catalog size ==
146
can't open device TEST_DIR/parallels-v1: Catalog too large
147
-no file open, try 'help open'
148
149
== Overflow in catalog allocation ==
150
can't open device TEST_DIR/parallels-v1: Catalog too large
151
-no file open, try 'help open'
152
153
== Zero sectors per track ==
154
can't open device TEST_DIR/parallels-v1: Invalid image: Zero sectors per track
155
-no file open, try 'help open'
156
157
== Read from a valid v2 image ==
158
read 65536/65536 bytes at offset 0
159
diff --git a/tests/qemu-iotests/078.out b/tests/qemu-iotests/078.out
160
index XXXXXXX..XXXXXXX 100644
161
--- a/tests/qemu-iotests/078.out
162
+++ b/tests/qemu-iotests/078.out
163
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 0
164
165
== Negative catalog size ==
166
can't open device TEST_DIR/empty.bochs: Catalog size is too large
167
-no file open, try 'help open'
168
169
== Overflow for catalog size * sizeof(uint32_t) ==
170
can't open device TEST_DIR/empty.bochs: Catalog size is too large
171
-no file open, try 'help open'
172
173
== Too small catalog bitmap for image size ==
174
can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size
175
-no file open, try 'help open'
176
can't open device TEST_DIR/empty.bochs: Catalog size is too small for this disk size
177
-no file open, try 'help open'
178
179
== Negative extent size ==
180
can't open device TEST_DIR/empty.bochs: Extent size 2147483648 is too large
181
-no file open, try 'help open'
182
183
== Zero extent size ==
184
can't open device TEST_DIR/empty.bochs: Extent size must be at least 512
185
-no file open, try 'help open'
186
*** done
187
diff --git a/tests/qemu-iotests/080.out b/tests/qemu-iotests/080.out
188
index XXXXXXX..XXXXXXX 100644
189
--- a/tests/qemu-iotests/080.out
190
+++ b/tests/qemu-iotests/080.out
191
@@ -XXX,XX +XXX,XX @@ QA output created by 080
192
== Huge header size ==
193
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
194
can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size
195
-no file open, try 'help open'
196
can't open device TEST_DIR/t.qcow2: qcow2 header exceeds cluster size
197
-no file open, try 'help open'
198
199
== Huge unknown header extension ==
200
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
201
can't open device TEST_DIR/t.qcow2: Invalid backing file offset
202
-no file open, try 'help open'
203
can't open device TEST_DIR/t.qcow2: Header extension too large
204
-no file open, try 'help open'
205
can't open device TEST_DIR/t.qcow2: Header extension too large
206
-no file open, try 'help open'
207
208
== Huge refcount table size ==
209
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
210
can't open device TEST_DIR/t.qcow2: Reference count table too large
211
-no file open, try 'help open'
212
can't open device TEST_DIR/t.qcow2: Reference count table too large
213
-no file open, try 'help open'
214
215
== Misaligned refcount table ==
216
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
217
can't open device TEST_DIR/t.qcow2: Invalid reference count table offset
218
-no file open, try 'help open'
219
220
== Huge refcount offset ==
221
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
222
can't open device TEST_DIR/t.qcow2: Invalid reference count table offset
223
-no file open, try 'help open'
224
225
== Invalid snapshot table ==
226
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
227
can't open device TEST_DIR/t.qcow2: Too many snapshots
228
-no file open, try 'help open'
229
can't open device TEST_DIR/t.qcow2: Too many snapshots
230
-no file open, try 'help open'
231
can't open device TEST_DIR/t.qcow2: Invalid snapshot table offset
232
-no file open, try 'help open'
233
can't open device TEST_DIR/t.qcow2: Invalid snapshot table offset
234
-no file open, try 'help open'
235
236
== Hitting snapshot table size limit ==
237
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
238
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 0
239
== Invalid L1 table ==
240
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
241
can't open device TEST_DIR/t.qcow2: Active L1 table too large
242
-no file open, try 'help open'
243
can't open device TEST_DIR/t.qcow2: Active L1 table too large
244
-no file open, try 'help open'
245
can't open device TEST_DIR/t.qcow2: Invalid L1 table offset
246
-no file open, try 'help open'
247
can't open device TEST_DIR/t.qcow2: Invalid L1 table offset
248
-no file open, try 'help open'
249
250
== Invalid L1 table (with internal snapshot in the image) ==
251
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
252
@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_DIR/t.IMGFMT': L1 table is too small
253
== Invalid backing file size ==
254
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
255
can't open device TEST_DIR/t.qcow2: Backing file name too long
256
-no file open, try 'help open'
257
258
== Invalid L2 entry (huge physical offset) ==
259
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
260
diff --git a/tests/qemu-iotests/083.out b/tests/qemu-iotests/083.out
261
index XXXXXXX..XXXXXXX 100644
262
--- a/tests/qemu-iotests/083.out
263
+++ b/tests/qemu-iotests/083.out
264
@@ -XXX,XX +XXX,XX @@ QA output created by 083
265
=== Check disconnect before neg1 ===
266
267
can't open device nbd:127.0.0.1:PORT:exportname=foo
268
-no file open, try 'help open'
269
270
=== Check disconnect after neg1 ===
271
272
can't open device nbd:127.0.0.1:PORT:exportname=foo
273
-no file open, try 'help open'
274
275
=== Check disconnect 8 neg1 ===
276
277
can't open device nbd:127.0.0.1:PORT:exportname=foo
278
-no file open, try 'help open'
279
280
=== Check disconnect 16 neg1 ===
281
282
can't open device nbd:127.0.0.1:PORT:exportname=foo
283
-no file open, try 'help open'
284
285
=== Check disconnect before export ===
286
287
can't open device nbd:127.0.0.1:PORT:exportname=foo
288
-no file open, try 'help open'
289
290
=== Check disconnect after export ===
291
292
can't open device nbd:127.0.0.1:PORT:exportname=foo
293
-no file open, try 'help open'
294
295
=== Check disconnect 4 export ===
296
297
can't open device nbd:127.0.0.1:PORT:exportname=foo
298
-no file open, try 'help open'
299
300
=== Check disconnect 12 export ===
301
302
can't open device nbd:127.0.0.1:PORT:exportname=foo
303
-no file open, try 'help open'
304
305
=== Check disconnect 16 export ===
306
307
can't open device nbd:127.0.0.1:PORT:exportname=foo
308
-no file open, try 'help open'
309
310
=== Check disconnect before neg2 ===
311
312
can't open device nbd:127.0.0.1:PORT:exportname=foo
313
-no file open, try 'help open'
314
315
=== Check disconnect after neg2 ===
316
317
@@ -XXX,XX +XXX,XX @@ read failed: Input/output error
318
=== Check disconnect 8 neg2 ===
319
320
can't open device nbd:127.0.0.1:PORT:exportname=foo
321
-no file open, try 'help open'
322
323
=== Check disconnect 10 neg2 ===
324
325
can't open device nbd:127.0.0.1:PORT:exportname=foo
326
-no file open, try 'help open'
327
328
=== Check disconnect before request ===
329
330
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 0
331
=== Check disconnect before neg-classic ===
332
333
can't open device nbd:127.0.0.1:PORT
334
-no file open, try 'help open'
335
336
=== Check disconnect 8 neg-classic ===
337
338
can't open device nbd:127.0.0.1:PORT
339
-no file open, try 'help open'
340
341
=== Check disconnect 16 neg-classic ===
342
343
can't open device nbd:127.0.0.1:PORT
344
-no file open, try 'help open'
345
346
=== Check disconnect 24 neg-classic ===
347
348
can't open device nbd:127.0.0.1:PORT
349
-no file open, try 'help open'
350
351
=== Check disconnect 28 neg-classic ===
352
353
can't open device nbd:127.0.0.1:PORT
354
-no file open, try 'help open'
355
356
=== Check disconnect after neg-classic ===
357
358
diff --git a/tests/qemu-iotests/088.out b/tests/qemu-iotests/088.out
359
index XXXXXXX..XXXXXXX 100644
360
--- a/tests/qemu-iotests/088.out
361
+++ b/tests/qemu-iotests/088.out
362
@@ -XXX,XX +XXX,XX @@ QA output created by 088
363
== Invalid block size ==
364
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
365
can't open device TEST_DIR/t.vpc: Invalid block size 0
366
-no file open, try 'help open'
367
can't open device TEST_DIR/t.vpc: Invalid block size 0
368
-no file open, try 'help open'
369
can't open device TEST_DIR/t.vpc: Invalid block size 128
370
-no file open, try 'help open'
371
can't open device TEST_DIR/t.vpc: Invalid block size 128
372
-no file open, try 'help open'
373
can't open device TEST_DIR/t.vpc: Invalid block size 305419896
374
-no file open, try 'help open'
375
can't open device TEST_DIR/t.vpc: Invalid block size 305419896
376
-no file open, try 'help open'
377
*** done
378
diff --git a/tests/qemu-iotests/092.out b/tests/qemu-iotests/092.out
379
index XXXXXXX..XXXXXXX 100644
380
--- a/tests/qemu-iotests/092.out
381
+++ b/tests/qemu-iotests/092.out
382
@@ -XXX,XX +XXX,XX @@ QA output created by 092
383
== Invalid cluster size ==
384
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
385
can't open device TEST_DIR/t.qcow: Cluster size must be between 512 and 64k
386
-no file open, try 'help open'
387
can't open device TEST_DIR/t.qcow: Cluster size must be between 512 and 64k
388
-no file open, try 'help open'
389
can't open device TEST_DIR/t.qcow: Cluster size must be between 512 and 64k
390
-no file open, try 'help open'
391
can't open device TEST_DIR/t.qcow: Cluster size must be between 512 and 64k
392
-no file open, try 'help open'
393
394
== Invalid L2 table size ==
395
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
396
can't open device TEST_DIR/t.qcow: L2 table size must be between 512 and 64k
397
-no file open, try 'help open'
398
can't open device TEST_DIR/t.qcow: L2 table size must be between 512 and 64k
399
-no file open, try 'help open'
400
can't open device TEST_DIR/t.qcow: L2 table size must be between 512 and 64k
401
-no file open, try 'help open'
402
can't open device TEST_DIR/t.qcow: L2 table size must be between 512 and 64k
403
-no file open, try 'help open'
404
405
== Invalid size ==
406
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
407
can't open device TEST_DIR/t.qcow: Image too large
408
-no file open, try 'help open'
409
can't open device TEST_DIR/t.qcow: Image too large
410
-no file open, try 'help open'
411
412
== Invalid backing file length ==
413
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
414
can't open device TEST_DIR/t.qcow: Backing file name too long
415
-no file open, try 'help open'
416
can't open device TEST_DIR/t.qcow: Backing file name too long
417
-no file open, try 'help open'
418
*** done
419
diff --git a/tests/qemu-iotests/116.out b/tests/qemu-iotests/116.out
420
index XXXXXXX..XXXXXXX 100644
421
--- a/tests/qemu-iotests/116.out
422
+++ b/tests/qemu-iotests/116.out
423
@@ -XXX,XX +XXX,XX @@ QA output created by 116
424
== truncated header cluster ==
425
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
426
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
427
-no file open, try 'help open'
428
429
== invalid header magic ==
430
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
431
can't open device TEST_DIR/t.qed: Image not in QED format
432
-no file open, try 'help open'
433
434
== invalid cluster size ==
435
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
436
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
437
-no file open, try 'help open'
438
439
== invalid table size ==
440
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
441
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
442
-no file open, try 'help open'
443
444
== invalid header size ==
445
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
446
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
447
-no file open, try 'help open'
448
449
== invalid L1 table offset ==
450
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
451
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
452
-no file open, try 'help open'
453
454
== invalid image size ==
455
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
456
can't open device TEST_DIR/t.qed: Could not open 'TEST_DIR/t.qed': Invalid argument
457
-no file open, try 'help open'
458
*** done
459
diff --git a/tests/qemu-iotests/131.out b/tests/qemu-iotests/131.out
460
index XXXXXXX..XXXXXXX 100644
461
--- a/tests/qemu-iotests/131.out
462
+++ b/tests/qemu-iotests/131.out
463
@@ -XXX,XX +XXX,XX @@ read 32768/32768 bytes at offset 0
464
32 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
465
== Corrupt image ==
466
can't open device TEST_DIR/t.parallels: parallels: Image was not closed correctly; cannot be opened read/write
467
-no file open, try 'help open'
468
ERROR image was not closed correctly
469
470
1 errors were found on the image.
471
diff --git a/tests/qemu-iotests/140.out b/tests/qemu-iotests/140.out
472
index XXXXXXX..XXXXXXX 100644
473
--- a/tests/qemu-iotests/140.out
474
+++ b/tests/qemu-iotests/140.out
475
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 0
476
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
477
{"return": {}}
478
can't open device nbd+unix:///drv?socket=TEST_DIR/nbd: No export with name 'drv' available
479
-no file open, try 'help open'
480
{"return": {}}
481
{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "SHUTDOWN"}
482
*** done
483
--
27
--
484
2.11.0
28
2.26.2
485
29
486
diff view generated by jsdifflib
New patch
[PULL v2 15/28] util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
1
The vu_client_trip() coroutine is leaked during AioContext switching. It
2
is also unsafe to destroy the vu_dev in panic_cb() since its callers
3
still access it in some cases.
1
4
5
Rework the lifecycle to solve these safety issues.
6
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
8
Message-id: 20200924151549.913737-10-stefanha@redhat.com
9
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
10
---
11
util/vhost-user-server.h | 29 ++--
12
block/export/vhost-user-blk-server.c | 9 +-
13
util/vhost-user-server.c | 245 +++++++++++++++------------
14
3 files changed, 155 insertions(+), 128 deletions(-)
15
16
diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
17
index XXXXXXX..XXXXXXX 100644
18
--- a/util/vhost-user-server.h
19
+++ b/util/vhost-user-server.h
20
@@ -XXX,XX +XXX,XX @@
21
#include "qapi/error.h"
22
#include "standard-headers/linux/virtio_blk.h"
23
24
+/* A kick fd that we monitor on behalf of libvhost-user */
25
typedef struct VuFdWatch {
26
VuDev *vu_dev;
27
int fd; /*kick fd*/
28
void *pvt;
29
vu_watch_cb cb;
30
- bool processing;
31
QTAILQ_ENTRY(VuFdWatch) next;
32
} VuFdWatch;
33
34
-typedef struct VuServer VuServer;
35
-
36
-struct VuServer {
37
+/**
38
+ * VuServer:
39
+ * A vhost-user server instance with user-defined VuDevIface callbacks.
40
+ * Vhost-user device backends can be implemented using VuServer. VuDevIface
41
+ * callbacks and virtqueue kicks run in the given AioContext.
42
+ */
43
+typedef struct {
44
QIONetListener *listener;
45
+ QEMUBH *restart_listener_bh;
46
AioContext *ctx;
47
int max_queues;
48
const VuDevIface *vu_iface;
49
+
50
+ /* Protected by ctx lock */
51
VuDev vu_dev;
52
QIOChannel *ioc; /* The I/O channel with the client */
53
QIOChannelSocket *sioc; /* The underlying data channel with the client */
54
- /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
55
- QIOChannel *ioc_slave;
56
- QIOChannelSocket *sioc_slave;
57
- Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
58
QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
59
- /* restart coroutine co_trip if AIOContext is changed */
60
- bool aio_context_changed;
61
- bool processing_msg;
62
-};
63
+
64
+ Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
65
+} VuServer;
66
67
bool vhost_user_server_start(VuServer *server,
68
SocketAddress *unix_socket,
69
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
70
71
void vhost_user_server_stop(VuServer *server);
72
73
-void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
74
+void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx);
75
+void vhost_user_server_detach_aio_context(VuServer *server);
76
77
#endif /* VHOST_USER_SERVER_H */
78
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
79
index XXXXXXX..XXXXXXX 100644
80
--- a/block/export/vhost-user-blk-server.c
81
+++ b/block/export/vhost-user-blk-server.c
82
@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_block_iface = {
83
static void blk_aio_attached(AioContext *ctx, void *opaque)
84
{
85
VuBlockDev *vub_dev = opaque;
86
- aio_context_acquire(ctx);
87
- vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
88
- aio_context_release(ctx);
89
+ vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
90
}
91
92
static void blk_aio_detach(void *opaque)
93
{
94
VuBlockDev *vub_dev = opaque;
95
- AioContext *ctx = vub_dev->vu_server.ctx;
96
- aio_context_acquire(ctx);
97
- vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
98
- aio_context_release(ctx);
99
+ vhost_user_server_detach_aio_context(&vub_dev->vu_server);
100
}
101
102
static void
103
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
104
index XXXXXXX..XXXXXXX 100644
105
--- a/util/vhost-user-server.c
106
+++ b/util/vhost-user-server.c
107
@@ -XXX,XX +XXX,XX @@
108
*/
109
#include "qemu/osdep.h"
110
#include "qemu/main-loop.h"
111
+#include "block/aio-wait.h"
112
#include "vhost-user-server.h"
113
114
+/*
115
+ * Theory of operation:
116
+ *
117
+ * VuServer is started and stopped by vhost_user_server_start() and
118
+ * vhost_user_server_stop() from the main loop thread. Starting the server
119
+ * opens a vhost-user UNIX domain socket and listens for incoming connections.
120
+ * Only one connection is allowed at a time.
121
+ *
122
+ * The connection is handled by the vu_client_trip() coroutine in the
123
+ * VuServer->ctx AioContext. The coroutine consists of a vu_dispatch() loop
124
+ * where libvhost-user calls vu_message_read() to receive the next vhost-user
125
+ * protocol messages over the UNIX domain socket.
126
+ *
127
+ * When virtqueues are set up libvhost-user calls set_watch() to monitor kick
128
+ * fds. These fds are also handled in the VuServer->ctx AioContext.
129
+ *
130
+ * Both vu_client_trip() and kick fd monitoring can be stopped by shutting down
131
+ * the socket connection. Shutting down the socket connection causes
132
+ * vu_message_read() to fail since no more data can be received from the socket.
133
+ * After vu_dispatch() fails, vu_client_trip() calls vu_deinit() to stop
134
+ * libvhost-user before terminating the coroutine. vu_deinit() calls
135
+ * remove_watch() to stop monitoring kick fds and this stops virtqueue
136
+ * processing.
137
+ *
138
+ * When vu_client_trip() has finished cleaning up it schedules a BH in the main
139
+ * loop thread to accept the next client connection.
140
+ *
141
+ * When libvhost-user detects an error it calls panic_cb() and sets the
142
+ * dev->broken flag. Both vu_client_trip() and kick fd processing stop when
143
+ * the dev->broken flag is set.
144
+ *
145
+ * It is possible to switch AioContexts using
146
+ * vhost_user_server_detach_aio_context() and
147
+ * vhost_user_server_attach_aio_context(). They stop monitoring fds in the old
148
+ * AioContext and resume monitoring in the new AioContext. The vu_client_trip()
149
+ * coroutine remains in a yielded state during the switch. This is made
150
+ * possible by QIOChannel's support for spurious coroutine re-entry in
151
+ * qio_channel_yield(). The coroutine will restart I/O when re-entered from the
152
+ * new AioContext.
153
+ */
154
+
155
static void vmsg_close_fds(VhostUserMsg *vmsg)
156
{
157
int i;
158
@@ -XXX,XX +XXX,XX @@ static void vmsg_unblock_fds(VhostUserMsg *vmsg)
159
}
160
}
161
162
-static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
163
- gpointer opaque);
164
-
165
-static void close_client(VuServer *server)
166
-{
167
- /*
168
- * Before closing the client
169
- *
170
- * 1. Let vu_client_trip stop processing new vhost-user msg
171
- *
172
- * 2. remove kick_handler
173
- *
174
- * 3. wait for the kick handler to be finished
175
- *
176
- * 4. wait for the current vhost-user msg to be finished processing
177
- */
178
-
179
- QIOChannelSocket *sioc = server->sioc;
180
- /* When this is set vu_client_trip will stop new processing vhost-user message */
181
- server->sioc = NULL;
182
-
183
- while (server->processing_msg) {
184
- if (server->ioc->read_coroutine) {
185
- server->ioc->read_coroutine = NULL;
186
- qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
187
- NULL, server->ioc);
188
- server->processing_msg = false;
189
- }
190
- }
191
-
192
- vu_deinit(&server->vu_dev);
193
-
194
- /* vu_deinit() should have called remove_watch() */
195
- assert(QTAILQ_EMPTY(&server->vu_fd_watches));
196
-
197
- object_unref(OBJECT(sioc));
198
- object_unref(OBJECT(server->ioc));
199
-}
200
-
201
static void panic_cb(VuDev *vu_dev, const char *buf)
202
{
203
- VuServer *server = container_of(vu_dev, VuServer, vu_dev);
204
-
205
- /* avoid while loop in close_client */
206
- server->processing_msg = false;
207
-
208
- if (buf) {
209
- error_report("vu_panic: %s", buf);
210
- }
211
-
212
- if (server->sioc) {
213
- close_client(server);
214
- }
215
-
216
- /*
217
- * Set the callback function for network listener so another
218
- * vhost-user client can connect to this server
219
- */
220
- qio_net_listener_set_client_func(server->listener,
221
- vu_accept,
222
- server,
223
- NULL);
224
+ error_report("vu_panic: %s", buf);
225
}
226
227
static bool coroutine_fn
228
@@ -XXX,XX +XXX,XX @@ fail:
229
return false;
230
}
231
232
-
233
-static void vu_client_start(VuServer *server);
234
static coroutine_fn void vu_client_trip(void *opaque)
235
{
236
VuServer *server = opaque;
237
+ VuDev *vu_dev = &server->vu_dev;
238
239
- while (!server->aio_context_changed && server->sioc) {
240
- server->processing_msg = true;
241
- vu_dispatch(&server->vu_dev);
242
- server->processing_msg = false;
243
+ while (!vu_dev->broken && vu_dispatch(vu_dev)) {
244
+ /* Keep running */
245
}
246
247
- if (server->aio_context_changed && server->sioc) {
248
- server->aio_context_changed = false;
249
- vu_client_start(server);
250
- }
251
-}
252
+ vu_deinit(vu_dev);
253
+
254
+ /* vu_deinit() should have called remove_watch() */
255
+ assert(QTAILQ_EMPTY(&server->vu_fd_watches));
256
+
257
+ object_unref(OBJECT(server->sioc));
258
+ server->sioc = NULL;
259
260
-static void vu_client_start(VuServer *server)
261
-{
262
- server->co_trip = qemu_coroutine_create(vu_client_trip, server);
263
- aio_co_enter(server->ctx, server->co_trip);
264
+ object_unref(OBJECT(server->ioc));
265
+ server->ioc = NULL;
266
+
267
+ server->co_trip = NULL;
268
+ if (server->restart_listener_bh) {
269
+ qemu_bh_schedule(server->restart_listener_bh);
270
+ }
271
+ aio_wait_kick();
272
}
273
274
/*
275
@@ -XXX,XX +XXX,XX @@ static void vu_client_start(VuServer *server)
276
static void kick_handler(void *opaque)
277
{
278
VuFdWatch *vu_fd_watch = opaque;
279
- vu_fd_watch->processing = true;
280
- vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
281
- vu_fd_watch->processing = false;
282
+ VuDev *vu_dev = vu_fd_watch->vu_dev;
283
+
284
+ vu_fd_watch->cb(vu_dev, 0, vu_fd_watch->pvt);
285
+
286
+ /* Stop vu_client_trip() if an error occurred in vu_fd_watch->cb() */
287
+ if (vu_dev->broken) {
288
+ VuServer *server = container_of(vu_dev, VuServer, vu_dev);
289
+
290
+ qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
291
+ }
292
}
293
294
-
295
static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
296
{
297
298
@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
299
qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
300
server->ioc = QIO_CHANNEL(sioc);
301
object_ref(OBJECT(server->ioc));
302
- qio_channel_attach_aio_context(server->ioc, server->ctx);
303
+
304
+ /* TODO vu_message_write() spins if non-blocking! */
305
qio_channel_set_blocking(server->ioc, false, NULL);
306
- vu_client_start(server);
307
+
308
+ server->co_trip = qemu_coroutine_create(vu_client_trip, server);
309
+
310
+ aio_context_acquire(server->ctx);
311
+ vhost_user_server_attach_aio_context(server, server->ctx);
312
+ aio_context_release(server->ctx);
313
}
314
315
-
316
void vhost_user_server_stop(VuServer *server)
317
{
318
+ aio_context_acquire(server->ctx);
319
+
320
+ qemu_bh_delete(server->restart_listener_bh);
321
+ server->restart_listener_bh = NULL;
322
+
323
if (server->sioc) {
324
- close_client(server);
325
+ VuFdWatch *vu_fd_watch;
326
+
327
+ QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
328
+ aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
329
+ NULL, NULL, NULL, vu_fd_watch);
330
+ }
331
+
332
+ qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
333
+
334
+ AIO_WAIT_WHILE(server->ctx, server->co_trip);
335
}
336
337
+ aio_context_release(server->ctx);
338
+
339
if (server->listener) {
340
qio_net_listener_disconnect(server->listener);
341
object_unref(OBJECT(server->listener));
342
}
343
+}
344
+
345
+/*
346
+ * Allow the next client to connect to the server. Called from a BH in the main
347
+ * loop.
348
+ */
349
+static void restart_listener_bh(void *opaque)
350
+{
351
+ VuServer *server = opaque;
352
353
+ qio_net_listener_set_client_func(server->listener, vu_accept, server,
354
+ NULL);
355
}
356
357
-void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
358
+/* Called with ctx acquired */
359
+void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx)
360
{
361
- VuFdWatch *vu_fd_watch, *next;
362
- void *opaque = NULL;
363
- IOHandler *io_read = NULL;
364
- bool attach;
365
+ VuFdWatch *vu_fd_watch;
366
367
- server->ctx = ctx ? ctx : qemu_get_aio_context();
368
+ server->ctx = ctx;
369
370
if (!server->sioc) {
371
- /* not yet serving any client*/
372
return;
373
}
374
375
- if (ctx) {
376
- qio_channel_attach_aio_context(server->ioc, ctx);
377
- server->aio_context_changed = true;
378
- io_read = kick_handler;
379
- attach = true;
380
- } else {
381
+ qio_channel_attach_aio_context(server->ioc, ctx);
382
+
383
+ QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
384
+ aio_set_fd_handler(ctx, vu_fd_watch->fd, true, kick_handler, NULL,
385
+ NULL, vu_fd_watch);
386
+ }
387
+
388
+ aio_co_schedule(ctx, server->co_trip);
389
+}
390
+
391
+/* Called with server->ctx acquired */
392
+void vhost_user_server_detach_aio_context(VuServer *server)
393
+{
394
+ if (server->sioc) {
395
+ VuFdWatch *vu_fd_watch;
396
+
397
+ QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
398
+ aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
399
+ NULL, NULL, NULL, vu_fd_watch);
400
+ }
401
+
402
qio_channel_detach_aio_context(server->ioc);
403
- /* server->ioc->ctx keeps the old AioConext */
404
- ctx = server->ioc->ctx;
405
- attach = false;
406
}
407
408
- QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
409
- if (vu_fd_watch->cb) {
410
- opaque = attach ? vu_fd_watch : NULL;
411
- aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
412
- io_read, NULL, NULL,
413
- opaque);
414
- }
415
- }
416
+ server->ctx = NULL;
417
}
418
419
-
420
bool vhost_user_server_start(VuServer *server,
421
SocketAddress *socket_addr,
422
AioContext *ctx,
423
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
424
const VuDevIface *vu_iface,
425
Error **errp)
426
{
427
+ QEMUBH *bh;
428
QIONetListener *listener = qio_net_listener_new();
429
if (qio_net_listener_open_sync(listener, socket_addr, 1,
430
errp) < 0) {
431
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
432
return false;
433
}
434
435
+ bh = qemu_bh_new(restart_listener_bh, server);
436
+
437
/* zero out unspecified fields */
438
*server = (VuServer) {
439
.listener = listener,
440
+ .restart_listener_bh = bh,
441
.vu_iface = vu_iface,
442
.max_queues = max_queues,
443
.ctx = ctx,
444
--
445
2.26.2
446
diff view generated by jsdifflib
New patch
[PULL v2 16/28] block/export: report flush errors
1
Propagate the flush return value since errors are possible.
1
2
3
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
Message-id: 20200924151549.913737-11-stefanha@redhat.com
5
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
---
7
block/export/vhost-user-blk-server.c | 11 +++++++----
8
1 file changed, 7 insertions(+), 4 deletions(-)
9
10
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
11
index XXXXXXX..XXXXXXX 100644
12
--- a/block/export/vhost-user-blk-server.c
13
+++ b/block/export/vhost-user-blk-server.c
14
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
15
return -EINVAL;
16
}
17
18
-static void coroutine_fn vu_block_flush(VuBlockReq *req)
19
+static int coroutine_fn vu_block_flush(VuBlockReq *req)
20
{
21
VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
22
BlockBackend *backend = vdev_blk->backend;
23
- blk_co_flush(backend);
24
+ return blk_co_flush(backend);
25
}
26
27
static void coroutine_fn vu_block_virtio_process_req(void *opaque)
28
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
29
break;
30
}
31
case VIRTIO_BLK_T_FLUSH:
32
- vu_block_flush(req);
33
- req->in->status = VIRTIO_BLK_S_OK;
34
+ if (vu_block_flush(req) == 0) {
35
+ req->in->status = VIRTIO_BLK_S_OK;
36
+ } else {
37
+ req->in->status = VIRTIO_BLK_S_IOERR;
38
+ }
39
break;
40
case VIRTIO_BLK_T_GET_ID: {
41
size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
42
--
43
2.26.2
44
diff view generated by jsdifflib
[Qemu-devel] [PULL 14/21] block/nfs: fix naming of runtime opts
[PULL v2 17/28] block/export: convert vhost-user-blk server to block export API
1
From: Peter Lieven <pl@kamp.de>
1
Use the new QAPI block exports API instead of defining our own QOM
2
2
objects.
3
commit 94d6a7a accidentally left the naming of runtime opts and QAPI
3
4
scheme inconsistent. As one consequence passing of parameters in the
4
This is a large change because the lifecycle of VuBlockDev needs to
5
URI is broken. Sync the naming of the runtime opts to the QAPI
5
follow BlockExportDriver. QOM properties are replaced by QAPI options
6
scheme.
6
objects.
7
7
8
Please note that this is technically backwards incompatible with the 2.8
8
VuBlockDev is renamed VuBlkExport and contains a BlockExport field.
9
release, but the 2.8 release is the only version that had the wrong naming.
9
Several fields can be dropped since BlockExport already has equivalents.
10
Furthermore release 2.8 suffered from a NULL pointer dereference during
10
11
URI parsing.
11
The file names and meson build integration will be adjusted in a future
12
12
patch. libvhost-user should probably be built as a static library that
13
Fixes: 94d6a7a76e9df9919629428f6c598e2b97d9426c
13
is linked into QEMU instead of as a .c file that results in duplicate
14
Cc: qemu-stable@nongnu.org
14
compilation.
15
Signed-off-by: Peter Lieven <pl@kamp.de>
15
16
Message-id: 1485942829-10756-3-git-send-email-pl@kamp.de
16
The new command-line syntax is:
17
[mreitz: Fixed commit message]
17
18
Reviewed-by: Eric Blake <eblake@redhat.com>
18
$ qemu-storage-daemon \
19
Signed-off-by: Max Reitz <mreitz@redhat.com>
19
--blockdev file,node-name=drive0,filename=test.img \
20
--export vhost-user-blk,node-name=drive0,id=export0,unix-socket=/tmp/vhost-user-blk.sock
21
22
Note that unix-socket is optional because we may wish to accept chardevs
23
too in the future.
24
25
Markus noted that supported address families are not explicit in the
26
QAPI schema. It is unlikely that support for more address families will
27
be added since file descriptor passing is required and few address
28
families support it. If a new address family needs to be added, then the
29
QAPI 'features' syntax can be used to advertize them.
30
31
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
32
Acked-by: Markus Armbruster <armbru@redhat.com>
33
Message-id: 20200924151549.913737-12-stefanha@redhat.com
34
[Skip test on big-endian host architectures because this device doesn't
35
support them yet (as already mentioned in a code comment).
36
--Stefan]
37
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
20
---
38
---
21
block/nfs.c | 46 +++++++++++++++++++++++-----------------------
39
qapi/block-export.json | 21 +-
22
1 file changed, 23 insertions(+), 23 deletions(-)
40
block/export/vhost-user-blk-server.h | 23 +-
23
41
block/export/export.c | 6 +
24
diff --git a/block/nfs.c b/block/nfs.c
42
block/export/vhost-user-blk-server.c | 452 +++++++--------------------
43
util/vhost-user-server.c | 10 +-
44
block/export/meson.build | 1 +
45
block/meson.build | 1 -
46
7 files changed, 156 insertions(+), 358 deletions(-)
47
48
diff --git a/qapi/block-export.json b/qapi/block-export.json
25
index XXXXXXX..XXXXXXX 100644
49
index XXXXXXX..XXXXXXX 100644
26
--- a/block/nfs.c
50
--- a/qapi/block-export.json
27
+++ b/block/nfs.c
51
+++ b/qapi/block-export.json
28
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
52
@@ -XXX,XX +XXX,XX @@
29
.help = "Path of the image on the host",
53
'data': { '*name': 'str', '*description': 'str',
30
},
54
'*bitmap': 'str' } }
31
{
55
32
- .name = "uid",
56
+##
33
+ .name = "user",
57
+# @BlockExportOptionsVhostUserBlk:
34
.type = QEMU_OPT_NUMBER,
58
+#
35
.help = "UID value to use when talking to the server",
59
+# A vhost-user-blk block export.
36
},
60
+#
37
{
61
+# @addr: The vhost-user socket on which to listen. Both 'unix' and 'fd'
38
- .name = "gid",
62
+# SocketAddress types are supported. Passed fds must be UNIX domain
39
+ .name = "group",
63
+# sockets.
40
.type = QEMU_OPT_NUMBER,
64
+# @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
41
.help = "GID value to use when talking to the server",
65
+#
42
},
66
+# Since: 5.2
43
{
67
+##
44
- .name = "tcp-syncnt",
68
+{ 'struct': 'BlockExportOptionsVhostUserBlk',
45
+ .name = "tcp-syn-count",
69
+ 'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
46
.type = QEMU_OPT_NUMBER,
70
+
47
.help = "Number of SYNs to send during the session establish",
71
##
48
},
72
# @NbdServerAddOptions:
49
{
73
#
50
- .name = "readahead",
74
@@ -XXX,XX +XXX,XX @@
51
+ .name = "readahead-size",
75
# An enumeration of block export types
52
.type = QEMU_OPT_NUMBER,
76
#
53
.help = "Set the readahead size in bytes",
77
# @nbd: NBD export
54
},
78
+# @vhost-user-blk: vhost-user-blk export (since 5.2)
55
{
79
#
56
- .name = "pagecache",
80
# Since: 4.2
57
+ .name = "page-cache-size",
81
##
58
.type = QEMU_OPT_NUMBER,
82
{ 'enum': 'BlockExportType',
59
.help = "Set the pagecache size in bytes",
83
- 'data': [ 'nbd' ] }
60
},
84
+ 'data': [ 'nbd', 'vhost-user-blk' ] }
61
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_client_open(NFSClient *client, QDict *options,
85
62
goto fail;
86
##
87
# @BlockExportOptions:
88
@@ -XXX,XX +XXX,XX @@
89
'*writethrough': 'bool' },
90
'discriminator': 'type',
91
'data': {
92
- 'nbd': 'BlockExportOptionsNbd'
93
+ 'nbd': 'BlockExportOptionsNbd',
94
+ 'vhost-user-blk': 'BlockExportOptionsVhostUserBlk'
95
} }
96
97
##
98
diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
99
index XXXXXXX..XXXXXXX 100644
100
--- a/block/export/vhost-user-blk-server.h
101
+++ b/block/export/vhost-user-blk-server.h
102
@@ -XXX,XX +XXX,XX @@
103
104
#ifndef VHOST_USER_BLK_SERVER_H
105
#define VHOST_USER_BLK_SERVER_H
106
-#include "util/vhost-user-server.h"
107
108
-typedef struct VuBlockDev VuBlockDev;
109
-#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
110
-#define VHOST_USER_BLK_SERVER(obj) \
111
- OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
112
+#include "block/export.h"
113
114
-/* vhost user block device */
115
-struct VuBlockDev {
116
- Object parent_obj;
117
- char *node_name;
118
- SocketAddress *addr;
119
- AioContext *ctx;
120
- VuServer vu_server;
121
- bool running;
122
- uint32_t blk_size;
123
- BlockBackend *backend;
124
- QIOChannelSocket *sioc;
125
- QTAILQ_ENTRY(VuBlockDev) next;
126
- struct virtio_blk_config blkcfg;
127
- bool writable;
128
-};
129
+/* For block/export/export.c */
130
+extern const BlockExportDriver blk_exp_vhost_user_blk;
131
132
#endif /* VHOST_USER_BLK_SERVER_H */
133
diff --git a/block/export/export.c b/block/export/export.c
134
index XXXXXXX..XXXXXXX 100644
135
--- a/block/export/export.c
136
+++ b/block/export/export.c
137
@@ -XXX,XX +XXX,XX @@
138
#include "sysemu/block-backend.h"
139
#include "block/export.h"
140
#include "block/nbd.h"
141
+#if CONFIG_LINUX
142
+#include "block/export/vhost-user-blk-server.h"
143
+#endif
144
#include "qapi/error.h"
145
#include "qapi/qapi-commands-block-export.h"
146
#include "qapi/qapi-events-block-export.h"
147
@@ -XXX,XX +XXX,XX @@
148
149
static const BlockExportDriver *blk_exp_drivers[] = {
150
&blk_exp_nbd,
151
+#if CONFIG_LINUX
152
+ &blk_exp_vhost_user_blk,
153
+#endif
154
};
155
156
/* Only accessed from the main thread */
157
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
158
index XXXXXXX..XXXXXXX 100644
159
--- a/block/export/vhost-user-blk-server.c
160
+++ b/block/export/vhost-user-blk-server.c
161
@@ -XXX,XX +XXX,XX @@
162
*/
163
#include "qemu/osdep.h"
164
#include "block/block.h"
165
+#include "contrib/libvhost-user/libvhost-user.h"
166
+#include "standard-headers/linux/virtio_blk.h"
167
+#include "util/vhost-user-server.h"
168
#include "vhost-user-blk-server.h"
169
#include "qapi/error.h"
170
#include "qom/object_interfaces.h"
171
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
172
unsigned char status;
173
};
174
175
-typedef struct VuBlockReq {
176
+typedef struct VuBlkReq {
177
VuVirtqElement elem;
178
int64_t sector_num;
179
size_t size;
180
@@ -XXX,XX +XXX,XX @@ typedef struct VuBlockReq {
181
struct virtio_blk_outhdr out;
182
VuServer *server;
183
struct VuVirtq *vq;
184
-} VuBlockReq;
185
+} VuBlkReq;
186
187
-static void vu_block_req_complete(VuBlockReq *req)
188
+/* vhost user block device */
189
+typedef struct {
190
+ BlockExport export;
191
+ VuServer vu_server;
192
+ uint32_t blk_size;
193
+ QIOChannelSocket *sioc;
194
+ struct virtio_blk_config blkcfg;
195
+ bool writable;
196
+} VuBlkExport;
197
+
198
+static void vu_blk_req_complete(VuBlkReq *req)
199
{
200
VuDev *vu_dev = &req->server->vu_dev;
201
202
@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
203
free(req);
204
}
205
206
-static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
207
-{
208
- return container_of(server, VuBlockDev, vu_server);
209
-}
210
-
211
static int coroutine_fn
212
-vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
213
- uint32_t iovcnt, uint32_t type)
214
+vu_blk_discard_write_zeroes(BlockBackend *blk, struct iovec *iov,
215
+ uint32_t iovcnt, uint32_t type)
216
{
217
struct virtio_blk_discard_write_zeroes desc;
218
ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
219
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
220
return -EINVAL;
63
}
221
}
64
222
65
- if (qemu_opt_get(opts, "uid")) {
223
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
66
- client->uid = qemu_opt_get_number(opts, "uid", 0);
224
uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
67
+ if (qemu_opt_get(opts, "user")) {
225
le32_to_cpu(desc.num_sectors) << 9 };
68
+ client->uid = qemu_opt_get_number(opts, "user", 0);
226
if (type == VIRTIO_BLK_T_DISCARD) {
69
nfs_set_uid(client->context, client->uid);
227
- if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
228
+ if (blk_co_pdiscard(blk, range[0], range[1]) == 0) {
229
return 0;
230
}
231
} else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
232
- if (blk_co_pwrite_zeroes(vdev_blk->backend,
233
- range[0], range[1], 0) == 0) {
234
+ if (blk_co_pwrite_zeroes(blk, range[0], range[1], 0) == 0) {
235
return 0;
236
}
70
}
237
}
71
238
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
72
- if (qemu_opt_get(opts, "gid")) {
239
return -EINVAL;
73
- client->gid = qemu_opt_get_number(opts, "gid", 0);
240
}
74
+ if (qemu_opt_get(opts, "group")) {
241
75
+ client->gid = qemu_opt_get_number(opts, "group", 0);
242
-static int coroutine_fn vu_block_flush(VuBlockReq *req)
76
nfs_set_gid(client->context, client->gid);
243
+static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
244
{
245
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
246
- BlockBackend *backend = vdev_blk->backend;
247
- return blk_co_flush(backend);
248
-}
249
-
250
-static void coroutine_fn vu_block_virtio_process_req(void *opaque)
251
-{
252
- VuBlockReq *req = opaque;
253
+ VuBlkReq *req = opaque;
254
VuServer *server = req->server;
255
VuVirtqElement *elem = &req->elem;
256
uint32_t type;
257
258
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
259
- BlockBackend *backend = vdev_blk->backend;
260
+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
261
+ BlockBackend *blk = vexp->export.blk;
262
263
struct iovec *in_iov = elem->in_sg;
264
struct iovec *out_iov = elem->out_sg;
265
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
266
bool is_write = type & VIRTIO_BLK_T_OUT;
267
req->sector_num = le64_to_cpu(req->out.sector);
268
269
- int64_t offset = req->sector_num * vdev_blk->blk_size;
270
+ if (is_write && !vexp->writable) {
271
+ req->in->status = VIRTIO_BLK_S_IOERR;
272
+ break;
273
+ }
274
+
275
+ int64_t offset = req->sector_num * vexp->blk_size;
276
QEMUIOVector qiov;
277
if (is_write) {
278
qemu_iovec_init_external(&qiov, out_iov, out_num);
279
- ret = blk_co_pwritev(backend, offset, qiov.size,
280
- &qiov, 0);
281
+ ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
282
} else {
283
qemu_iovec_init_external(&qiov, in_iov, in_num);
284
- ret = blk_co_preadv(backend, offset, qiov.size,
285
- &qiov, 0);
286
+ ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
287
}
288
if (ret >= 0) {
289
req->in->status = VIRTIO_BLK_S_OK;
290
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
291
break;
77
}
292
}
78
293
case VIRTIO_BLK_T_FLUSH:
79
- if (qemu_opt_get(opts, "tcp-syncnt")) {
294
- if (vu_block_flush(req) == 0) {
80
- client->tcp_syncnt = qemu_opt_get_number(opts, "tcp-syncnt", 0);
295
+ if (blk_co_flush(blk) == 0) {
81
+ if (qemu_opt_get(opts, "tcp-syn-count")) {
296
req->in->status = VIRTIO_BLK_S_OK;
82
+ client->tcp_syncnt = qemu_opt_get_number(opts, "tcp-syn-count", 0);
297
} else {
83
nfs_set_tcp_syncnt(client->context, client->tcp_syncnt);
298
req->in->status = VIRTIO_BLK_S_IOERR;
299
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
300
case VIRTIO_BLK_T_DISCARD:
301
case VIRTIO_BLK_T_WRITE_ZEROES: {
302
int rc;
303
- rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
304
- out_num, type);
305
+
306
+ if (!vexp->writable) {
307
+ req->in->status = VIRTIO_BLK_S_IOERR;
308
+ break;
309
+ }
310
+
311
+ rc = vu_blk_discard_write_zeroes(blk, &elem->out_sg[1], out_num, type);
312
if (rc == 0) {
313
req->in->status = VIRTIO_BLK_S_OK;
314
} else {
315
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
316
break;
84
}
317
}
85
318
86
#ifdef LIBNFS_FEATURE_READAHEAD
319
- vu_block_req_complete(req);
87
- if (qemu_opt_get(opts, "readahead")) {
320
+ vu_blk_req_complete(req);
88
+ if (qemu_opt_get(opts, "readahead-size")) {
321
return;
89
if (open_flags & BDRV_O_NOCACHE) {
322
90
error_setg(errp, "Cannot enable NFS readahead "
323
err:
91
"if cache.direct = on");
324
- free(elem);
92
goto fail;
325
+ free(req);
326
}
327
328
-static void vu_block_process_vq(VuDev *vu_dev, int idx)
329
+static void vu_blk_process_vq(VuDev *vu_dev, int idx)
330
{
331
VuServer *server = container_of(vu_dev, VuServer, vu_dev);
332
VuVirtq *vq = vu_get_queue(vu_dev, idx);
333
334
while (1) {
335
- VuBlockReq *req;
336
+ VuBlkReq *req;
337
338
- req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
339
+ req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
340
if (!req) {
341
break;
93
}
342
}
94
- client->readahead = qemu_opt_get_number(opts, "readahead", 0);
343
@@ -XXX,XX +XXX,XX @@ static void vu_block_process_vq(VuDev *vu_dev, int idx)
95
+ client->readahead = qemu_opt_get_number(opts, "readahead-size", 0);
344
req->vq = vq;
96
if (client->readahead > QEMU_NFS_MAX_READAHEAD_SIZE) {
345
97
error_report("NFS Warning: Truncating NFS readahead "
346
Coroutine *co =
98
"size to %d", QEMU_NFS_MAX_READAHEAD_SIZE);
347
- qemu_coroutine_create(vu_block_virtio_process_req, req);
99
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_client_open(NFSClient *client, QDict *options,
348
+ qemu_coroutine_create(vu_blk_virtio_process_req, req);
100
#endif
349
qemu_coroutine_enter(co);
101
102
#ifdef LIBNFS_FEATURE_PAGECACHE
103
- if (qemu_opt_get(opts, "pagecache")) {
104
+ if (qemu_opt_get(opts, "page-cache-size")) {
105
if (open_flags & BDRV_O_NOCACHE) {
106
error_setg(errp, "Cannot enable NFS pagecache "
107
"if cache.direct = on");
108
goto fail;
109
}
110
- client->pagecache = qemu_opt_get_number(opts, "pagecache", 0);
111
+ client->pagecache = qemu_opt_get_number(opts, "page-cache-size", 0);
112
if (client->pagecache > QEMU_NFS_MAX_PAGECACHE_SIZE) {
113
error_report("NFS Warning: Truncating NFS pagecache "
114
"size to %d pages", QEMU_NFS_MAX_PAGECACHE_SIZE);
115
@@ -XXX,XX +XXX,XX @@ static void nfs_refresh_filename(BlockDriverState *bs, QDict *options)
116
qdict_put(opts, "path", qstring_from_str(client->path));
117
118
if (client->uid) {
119
- qdict_put(opts, "uid", qint_from_int(client->uid));
120
+ qdict_put(opts, "user", qint_from_int(client->uid));
121
}
350
}
122
if (client->gid) {
351
}
123
- qdict_put(opts, "gid", qint_from_int(client->gid));
352
124
+ qdict_put(opts, "group", qint_from_int(client->gid));
353
-static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
354
+static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
355
{
356
VuVirtq *vq;
357
358
assert(vu_dev);
359
360
vq = vu_get_queue(vu_dev, idx);
361
- vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
362
+ vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
363
}
364
365
-static uint64_t vu_block_get_features(VuDev *dev)
366
+static uint64_t vu_blk_get_features(VuDev *dev)
367
{
368
uint64_t features;
369
VuServer *server = container_of(dev, VuServer, vu_dev);
370
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
371
+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
372
features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
373
1ull << VIRTIO_BLK_F_SEG_MAX |
374
1ull << VIRTIO_BLK_F_TOPOLOGY |
375
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_block_get_features(VuDev *dev)
376
1ull << VIRTIO_RING_F_EVENT_IDX |
377
1ull << VHOST_USER_F_PROTOCOL_FEATURES;
378
379
- if (!vdev_blk->writable) {
380
+ if (!vexp->writable) {
381
features |= 1ull << VIRTIO_BLK_F_RO;
125
}
382
}
126
if (client->tcp_syncnt) {
383
127
- qdict_put(opts, "tcp-syncnt",
384
return features;
128
- qint_from_int(client->tcp_syncnt));
385
}
129
+ qdict_put(opts, "tcp-syn-cnt",
386
130
+ qint_from_int(client->tcp_syncnt));
387
-static uint64_t vu_block_get_protocol_features(VuDev *dev)
388
+static uint64_t vu_blk_get_protocol_features(VuDev *dev)
389
{
390
return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
391
1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
392
}
393
394
static int
395
-vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
396
+vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
397
{
398
+ /* TODO blkcfg must be little-endian for VIRTIO 1.0 */
399
VuServer *server = container_of(vu_dev, VuServer, vu_dev);
400
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
401
- memcpy(config, &vdev_blk->blkcfg, len);
402
-
403
+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
404
+ memcpy(config, &vexp->blkcfg, len);
405
return 0;
406
}
407
408
static int
409
-vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
410
+vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
411
uint32_t offset, uint32_t size, uint32_t flags)
412
{
413
VuServer *server = container_of(vu_dev, VuServer, vu_dev);
414
- VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
415
+ VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
416
uint8_t wce;
417
418
/* don't support live migration */
419
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
131
}
420
}
132
if (client->readahead) {
421
133
- qdict_put(opts, "readahead",
422
wce = *data;
134
- qint_from_int(client->readahead));
423
- vdev_blk->blkcfg.wce = wce;
135
+ qdict_put(opts, "readahead-size",
424
- blk_set_enable_write_cache(vdev_blk->backend, wce);
136
+ qint_from_int(client->readahead));
425
+ vexp->blkcfg.wce = wce;
426
+ blk_set_enable_write_cache(vexp->export.blk, wce);
427
return 0;
428
}
429
430
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
431
* of vu_process_message.
432
*
433
*/
434
-static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
435
+static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
436
{
437
if (vmsg->request == VHOST_USER_NONE) {
438
dev->panic(dev, "disconnect");
439
@@ -XXX,XX +XXX,XX @@ static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
440
return false;
441
}
442
443
-static const VuDevIface vu_block_iface = {
444
- .get_features = vu_block_get_features,
445
- .queue_set_started = vu_block_queue_set_started,
446
- .get_protocol_features = vu_block_get_protocol_features,
447
- .get_config = vu_block_get_config,
448
- .set_config = vu_block_set_config,
449
- .process_msg = vu_block_process_msg,
450
+static const VuDevIface vu_blk_iface = {
451
+ .get_features = vu_blk_get_features,
452
+ .queue_set_started = vu_blk_queue_set_started,
453
+ .get_protocol_features = vu_blk_get_protocol_features,
454
+ .get_config = vu_blk_get_config,
455
+ .set_config = vu_blk_set_config,
456
+ .process_msg = vu_blk_process_msg,
457
};
458
459
static void blk_aio_attached(AioContext *ctx, void *opaque)
460
{
461
- VuBlockDev *vub_dev = opaque;
462
- vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
463
+ VuBlkExport *vexp = opaque;
464
+ vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
465
}
466
467
static void blk_aio_detach(void *opaque)
468
{
469
- VuBlockDev *vub_dev = opaque;
470
- vhost_user_server_detach_aio_context(&vub_dev->vu_server);
471
+ VuBlkExport *vexp = opaque;
472
+ vhost_user_server_detach_aio_context(&vexp->vu_server);
473
}
474
475
static void
476
-vu_block_initialize_config(BlockDriverState *bs,
477
+vu_blk_initialize_config(BlockDriverState *bs,
478
struct virtio_blk_config *config, uint32_t blk_size)
479
{
480
config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
481
@@ -XXX,XX +XXX,XX @@ vu_block_initialize_config(BlockDriverState *bs,
482
config->max_write_zeroes_seg = 1;
483
}
484
485
-static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
486
+static void vu_blk_exp_request_shutdown(BlockExport *exp)
487
{
488
+ VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
489
490
- BlockBackend *blk;
491
- Error *local_error = NULL;
492
- const char *node_name = vu_block_device->node_name;
493
- bool writable = vu_block_device->writable;
494
- uint64_t perm = BLK_PERM_CONSISTENT_READ;
495
- int ret;
496
-
497
- AioContext *ctx;
498
-
499
- BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
500
-
501
- if (!bs) {
502
- error_propagate(errp, local_error);
503
- return NULL;
504
- }
505
-
506
- if (bdrv_is_read_only(bs)) {
507
- writable = false;
508
- }
509
-
510
- if (writable) {
511
- perm |= BLK_PERM_WRITE;
512
- }
513
-
514
- ctx = bdrv_get_aio_context(bs);
515
- aio_context_acquire(ctx);
516
- bdrv_invalidate_cache(bs, NULL);
517
- aio_context_release(ctx);
518
-
519
- /*
520
- * Don't allow resize while the vhost user server is running,
521
- * otherwise we don't care what happens with the node.
522
- */
523
- blk = blk_new(bdrv_get_aio_context(bs), perm,
524
- BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
525
- BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
526
- ret = blk_insert_bs(blk, bs, errp);
527
-
528
- if (ret < 0) {
529
- goto fail;
530
- }
531
-
532
- blk_set_enable_write_cache(blk, false);
533
-
534
- blk_set_allow_aio_context_change(blk, true);
535
-
536
- vu_block_device->blkcfg.wce = 0;
537
- vu_block_device->backend = blk;
538
- if (!vu_block_device->blk_size) {
539
- vu_block_device->blk_size = BDRV_SECTOR_SIZE;
540
- }
541
- vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
542
- blk_set_guest_block_size(blk, vu_block_device->blk_size);
543
- vu_block_initialize_config(bs, &vu_block_device->blkcfg,
544
- vu_block_device->blk_size);
545
- return vu_block_device;
546
-
547
-fail:
548
- blk_unref(blk);
549
- return NULL;
550
-}
551
-
552
-static void vu_block_deinit(VuBlockDev *vu_block_device)
553
-{
554
- if (vu_block_device->backend) {
555
- blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
556
- blk_aio_detach, vu_block_device);
557
- }
558
-
559
- blk_unref(vu_block_device->backend);
560
-}
561
-
562
-static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
563
-{
564
- vhost_user_server_stop(&vu_block_device->vu_server);
565
- vu_block_deinit(vu_block_device);
566
-}
567
-
568
-static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
569
- Error **errp)
570
-{
571
- AioContext *ctx;
572
- SocketAddress *addr = vu_block_device->addr;
573
-
574
- if (!vu_block_init(vu_block_device, errp)) {
575
- return;
576
- }
577
-
578
- ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
579
-
580
- if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
581
- VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
582
- errp)) {
583
- goto error;
584
- }
585
-
586
- blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
587
- blk_aio_detach, vu_block_device);
588
- vu_block_device->running = true;
589
- return;
590
-
591
- error:
592
- vu_block_deinit(vu_block_device);
593
-}
594
-
595
-static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
596
-{
597
- if (vus->running) {
598
- error_setg(errp, "The property can't be modified "
599
- "while the server is running");
600
- return false;
601
- }
602
- return true;
603
-}
604
-
605
-static void vu_set_node_name(Object *obj, const char *value, Error **errp)
606
-{
607
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
608
-
609
- if (!vu_prop_modifiable(vus, errp)) {
610
- return;
611
- }
612
-
613
- if (vus->node_name) {
614
- g_free(vus->node_name);
615
- }
616
-
617
- vus->node_name = g_strdup(value);
618
-}
619
-
620
-static char *vu_get_node_name(Object *obj, Error **errp)
621
-{
622
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
623
- return g_strdup(vus->node_name);
624
-}
625
-
626
-static void free_socket_addr(SocketAddress *addr)
627
-{
628
- g_free(addr->u.q_unix.path);
629
- g_free(addr);
630
-}
631
-
632
-static void vu_set_unix_socket(Object *obj, const char *value,
633
- Error **errp)
634
-{
635
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
636
-
637
- if (!vu_prop_modifiable(vus, errp)) {
638
- return;
639
- }
640
-
641
- if (vus->addr) {
642
- free_socket_addr(vus->addr);
643
- }
644
-
645
- SocketAddress *addr = g_new0(SocketAddress, 1);
646
- addr->type = SOCKET_ADDRESS_TYPE_UNIX;
647
- addr->u.q_unix.path = g_strdup(value);
648
- vus->addr = addr;
649
+ vhost_user_server_stop(&vexp->vu_server);
650
}
651
652
-static char *vu_get_unix_socket(Object *obj, Error **errp)
653
+static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
654
+ Error **errp)
655
{
656
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
657
- return g_strdup(vus->addr->u.q_unix.path);
658
-}
659
-
660
-static bool vu_get_block_writable(Object *obj, Error **errp)
661
-{
662
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
663
- return vus->writable;
664
-}
665
-
666
-static void vu_set_block_writable(Object *obj, bool value, Error **errp)
667
-{
668
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
669
-
670
- if (!vu_prop_modifiable(vus, errp)) {
671
- return;
672
- }
673
-
674
- vus->writable = value;
675
-}
676
-
677
-static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
678
- void *opaque, Error **errp)
679
-{
680
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
681
- uint32_t value = vus->blk_size;
682
-
683
- visit_type_uint32(v, name, &value, errp);
684
-}
685
-
686
-static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
687
- void *opaque, Error **errp)
688
-{
689
- VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
690
-
691
+ VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
692
+ BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
693
Error *local_err = NULL;
694
- uint32_t value;
695
+ uint64_t logical_block_size;
696
697
- if (!vu_prop_modifiable(vus, errp)) {
698
- return;
699
- }
700
+ vexp->writable = opts->writable;
701
+ vexp->blkcfg.wce = 0;
702
703
- visit_type_uint32(v, name, &value, &local_err);
704
- if (local_err) {
705
- goto out;
706
+ if (vu_opts->has_logical_block_size) {
707
+ logical_block_size = vu_opts->logical_block_size;
708
+ } else {
709
+ logical_block_size = BDRV_SECTOR_SIZE;
137
}
710
}
138
if (client->pagecache) {
711
-
139
- qdict_put(opts, "pagecache",
712
- check_block_size(object_get_typename(obj), name, value, &local_err);
140
- qint_from_int(client->pagecache));
713
+ check_block_size(exp->id, "logical-block-size", logical_block_size,
141
+ qdict_put(opts, "page-cache-size",
714
+ &local_err);
142
+ qint_from_int(client->pagecache));
715
if (local_err) {
716
- goto out;
717
+ error_propagate(errp, local_err);
718
+ return -EINVAL;
719
+ }
720
+ vexp->blk_size = logical_block_size;
721
+ blk_set_guest_block_size(exp->blk, logical_block_size);
722
+ vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
723
+ logical_block_size);
724
+
725
+ blk_set_allow_aio_context_change(exp->blk, true);
726
+ blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
727
+ vexp);
728
+
729
+ if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
730
+ VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
731
+ errp)) {
732
+ blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
733
+ blk_aio_detach, vexp);
734
+ return -EADDRNOTAVAIL;
143
}
735
}
144
if (client->debug) {
736
145
qdict_put(opts, "debug", qint_from_int(client->debug));
737
- vus->blk_size = value;
738
-
739
-out:
740
- error_propagate(errp, local_err);
741
-}
742
-
743
-static void vhost_user_blk_server_instance_finalize(Object *obj)
744
-{
745
- VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
746
-
747
- vhost_user_blk_server_stop(vub);
748
-
749
- /*
750
- * Unlike object_property_add_str, object_class_property_add_str
751
- * doesn't have a release method. Thus manual memory freeing is
752
- * needed.
753
- */
754
- free_socket_addr(vub->addr);
755
- g_free(vub->node_name);
756
-}
757
-
758
-static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
759
-{
760
- VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
761
-
762
- vhost_user_blk_server_start(vub, errp);
763
+ return 0;
764
}
765
766
-static void vhost_user_blk_server_class_init(ObjectClass *klass,
767
- void *class_data)
768
+static void vu_blk_exp_delete(BlockExport *exp)
769
{
770
- UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
771
- ucc->complete = vhost_user_blk_server_complete;
772
-
773
- object_class_property_add_bool(klass, "writable",
774
- vu_get_block_writable,
775
- vu_set_block_writable);
776
-
777
- object_class_property_add_str(klass, "node-name",
778
- vu_get_node_name,
779
- vu_set_node_name);
780
-
781
- object_class_property_add_str(klass, "unix-socket",
782
- vu_get_unix_socket,
783
- vu_set_unix_socket);
784
+ VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
785
786
- object_class_property_add(klass, "logical-block-size", "uint32",
787
- vu_get_blk_size, vu_set_blk_size,
788
- NULL, NULL);
789
+ blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
790
+ vexp);
791
}
792
793
-static const TypeInfo vhost_user_blk_server_info = {
794
- .name = TYPE_VHOST_USER_BLK_SERVER,
795
- .parent = TYPE_OBJECT,
796
- .instance_size = sizeof(VuBlockDev),
797
- .instance_finalize = vhost_user_blk_server_instance_finalize,
798
- .class_init = vhost_user_blk_server_class_init,
799
- .interfaces = (InterfaceInfo[]) {
800
- {TYPE_USER_CREATABLE},
801
- {}
802
- },
803
+const BlockExportDriver blk_exp_vhost_user_blk = {
804
+ .type = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
805
+ .instance_size = sizeof(VuBlkExport),
806
+ .create = vu_blk_exp_create,
807
+ .delete = vu_blk_exp_delete,
808
+ .request_shutdown = vu_blk_exp_request_shutdown,
809
};
810
-
811
-static void vhost_user_blk_server_register_types(void)
812
-{
813
- type_register_static(&vhost_user_blk_server_info);
814
-}
815
-
816
-type_init(vhost_user_blk_server_register_types)
817
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
818
index XXXXXXX..XXXXXXX 100644
819
--- a/util/vhost-user-server.c
820
+++ b/util/vhost-user-server.c
821
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
822
Error **errp)
823
{
824
QEMUBH *bh;
825
- QIONetListener *listener = qio_net_listener_new();
826
+ QIONetListener *listener;
827
+
828
+ if (socket_addr->type != SOCKET_ADDRESS_TYPE_UNIX &&
829
+ socket_addr->type != SOCKET_ADDRESS_TYPE_FD) {
830
+ error_setg(errp, "Only socket address types 'unix' and 'fd' are supported");
831
+ return false;
832
+ }
833
+
834
+ listener = qio_net_listener_new();
835
if (qio_net_listener_open_sync(listener, socket_addr, 1,
836
errp) < 0) {
837
object_unref(OBJECT(listener));
838
diff --git a/block/export/meson.build b/block/export/meson.build
839
index XXXXXXX..XXXXXXX 100644
840
--- a/block/export/meson.build
841
+++ b/block/export/meson.build
842
@@ -1 +1,2 @@
843
block_ss.add(files('export.c'))
844
+block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
845
diff --git a/block/meson.build b/block/meson.build
846
index XXXXXXX..XXXXXXX 100644
847
--- a/block/meson.build
848
+++ b/block/meson.build
849
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
850
block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
851
block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
852
block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
853
-block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
854
block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
855
block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
856
block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
146
--
857
--
147
2.11.0
858
2.26.2
148
859
149
diff view generated by jsdifflib
New patch
[PULL v2 18/28] util/vhost-user-server: move header to include/
1
Headers used by other subsystems are located in include/. Also add the
2
vhost-user-server and vhost-user-blk-server headers to MAINTAINERS.
1
3
4
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
5
Message-id: 20200924151549.913737-13-stefanha@redhat.com
6
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
7
---
8
MAINTAINERS | 4 +++-
9
{util => include/qemu}/vhost-user-server.h | 0
10
block/export/vhost-user-blk-server.c | 2 +-
11
util/vhost-user-server.c | 2 +-
12
4 files changed, 5 insertions(+), 3 deletions(-)
13
rename {util => include/qemu}/vhost-user-server.h (100%)
14
15
diff --git a/MAINTAINERS b/MAINTAINERS
16
index XXXXXXX..XXXXXXX 100644
17
--- a/MAINTAINERS
18
+++ b/MAINTAINERS
19
@@ -XXX,XX +XXX,XX @@ Vhost-user block device backend server
20
M: Coiby Xu <Coiby.Xu@gmail.com>
21
S: Maintained
22
F: block/export/vhost-user-blk-server.c
23
-F: util/vhost-user-server.c
24
+F: block/export/vhost-user-blk-server.h
25
+F: include/qemu/vhost-user-server.h
26
F: tests/qtest/libqos/vhost-user-blk.c
27
+F: util/vhost-user-server.c
28
29
Replication
30
M: Wen Congyang <wencongyang2@huawei.com>
31
diff --git a/util/vhost-user-server.h b/include/qemu/vhost-user-server.h
32
similarity index 100%
33
rename from util/vhost-user-server.h
34
rename to include/qemu/vhost-user-server.h
35
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
36
index XXXXXXX..XXXXXXX 100644
37
--- a/block/export/vhost-user-blk-server.c
38
+++ b/block/export/vhost-user-blk-server.c
39
@@ -XXX,XX +XXX,XX @@
40
#include "block/block.h"
41
#include "contrib/libvhost-user/libvhost-user.h"
42
#include "standard-headers/linux/virtio_blk.h"
43
-#include "util/vhost-user-server.h"
44
+#include "qemu/vhost-user-server.h"
45
#include "vhost-user-blk-server.h"
46
#include "qapi/error.h"
47
#include "qom/object_interfaces.h"
48
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
49
index XXXXXXX..XXXXXXX 100644
50
--- a/util/vhost-user-server.c
51
+++ b/util/vhost-user-server.c
52
@@ -XXX,XX +XXX,XX @@
53
*/
54
#include "qemu/osdep.h"
55
#include "qemu/main-loop.h"
56
+#include "qemu/vhost-user-server.h"
57
#include "block/aio-wait.h"
58
-#include "vhost-user-server.h"
59
60
/*
61
* Theory of operation:
62
--
63
2.26.2
64
diff view generated by jsdifflib
New patch
[PULL v2 19/28] util/vhost-user-server: use static library in meson.build
1
Don't compile contrib/libvhost-user/libvhost-user.c again. Instead build
2
the static library once and then reuse it throughout QEMU.
1
3
4
Also switch from CONFIG_LINUX to CONFIG_VHOST_USER, which is what the
5
vhost-user tools (vhost-user-gpu, etc) do.
6
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
8
Message-id: 20200924151549.913737-14-stefanha@redhat.com
9
[Added CONFIG_LINUX again because libvhost-user doesn't build on macOS.
10
--Stefan]
11
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
12
---
13
block/export/export.c | 8 ++++----
14
block/export/meson.build | 2 +-
15
contrib/libvhost-user/meson.build | 1 +
16
meson.build | 6 +++++-
17
util/meson.build | 4 +++-
18
5 files changed, 14 insertions(+), 7 deletions(-)
19
20
diff --git a/block/export/export.c b/block/export/export.c
21
index XXXXXXX..XXXXXXX 100644
22
--- a/block/export/export.c
23
+++ b/block/export/export.c
24
@@ -XXX,XX +XXX,XX @@
25
#include "sysemu/block-backend.h"
26
#include "block/export.h"
27
#include "block/nbd.h"
28
-#if CONFIG_LINUX
29
-#include "block/export/vhost-user-blk-server.h"
30
-#endif
31
#include "qapi/error.h"
32
#include "qapi/qapi-commands-block-export.h"
33
#include "qapi/qapi-events-block-export.h"
34
#include "qemu/id.h"
35
+#ifdef CONFIG_VHOST_USER
36
+#include "vhost-user-blk-server.h"
37
+#endif
38
39
static const BlockExportDriver *blk_exp_drivers[] = {
40
&blk_exp_nbd,
41
-#if CONFIG_LINUX
42
+#ifdef CONFIG_VHOST_USER
43
&blk_exp_vhost_user_blk,
44
#endif
45
};
46
diff --git a/block/export/meson.build b/block/export/meson.build
47
index XXXXXXX..XXXXXXX 100644
48
--- a/block/export/meson.build
49
+++ b/block/export/meson.build
50
@@ -XXX,XX +XXX,XX @@
51
block_ss.add(files('export.c'))
52
-block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
53
+block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
54
diff --git a/contrib/libvhost-user/meson.build b/contrib/libvhost-user/meson.build
55
index XXXXXXX..XXXXXXX 100644
56
--- a/contrib/libvhost-user/meson.build
57
+++ b/contrib/libvhost-user/meson.build
58
@@ -XXX,XX +XXX,XX @@
59
libvhost_user = static_library('vhost-user',
60
files('libvhost-user.c', 'libvhost-user-glib.c'),
61
build_by_default: false)
62
+vhost_user = declare_dependency(link_with: libvhost_user)
63
diff --git a/meson.build b/meson.build
64
index XXXXXXX..XXXXXXX 100644
65
--- a/meson.build
66
+++ b/meson.build
67
@@ -XXX,XX +XXX,XX @@ trace_events_subdirs += [
68
'util',
69
]
70
71
+vhost_user = not_found
72
+if 'CONFIG_VHOST_USER' in config_host
73
+ subdir('contrib/libvhost-user')
74
+endif
75
+
76
subdir('qapi')
77
subdir('qobject')
78
subdir('stubs')
79
@@ -XXX,XX +XXX,XX @@ if have_tools
80
install: true)
81
82
if 'CONFIG_VHOST_USER' in config_host
83
- subdir('contrib/libvhost-user')
84
subdir('contrib/vhost-user-blk')
85
subdir('contrib/vhost-user-gpu')
86
subdir('contrib/vhost-user-input')
87
diff --git a/util/meson.build b/util/meson.build
88
index XXXXXXX..XXXXXXX 100644
89
--- a/util/meson.build
90
+++ b/util/meson.build
91
@@ -XXX,XX +XXX,XX @@ if have_block
92
util_ss.add(files('main-loop.c'))
93
util_ss.add(files('nvdimm-utils.c'))
94
util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
95
- util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
96
+ util_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: [
97
+ files('vhost-user-server.c'), vhost_user
98
+ ])
99
util_ss.add(files('block-helpers.c'))
100
util_ss.add(files('qemu-coroutine-sleep.c'))
101
util_ss.add(files('qemu-co-shared-resource.c'))
102
--
103
2.26.2
104
diff view generated by jsdifflib
New patch
[PULL v2 20/28] qemu-storage-daemon: avoid compiling blockdev_ss twice
1
Introduce libblkdev.fa to avoid recompiling blockdev_ss twice.
1
2
3
Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
4
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
5
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
6
Message-id: 20200929125516.186715-3-stefanha@redhat.com
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
8
---
9
meson.build | 12 ++++++++++--
10
storage-daemon/meson.build | 3 +--
11
2 files changed, 11 insertions(+), 4 deletions(-)
12
13
diff --git a/meson.build b/meson.build
14
index XXXXXXX..XXXXXXX 100644
15
--- a/meson.build
16
+++ b/meson.build
17
@@ -XXX,XX +XXX,XX @@ blockdev_ss.add(files(
18
# os-win32.c does not
19
blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
20
softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
21
-softmmu_ss.add_all(blockdev_ss)
22
23
common_ss.add(files('cpus-common.c'))
24
25
@@ -XXX,XX +XXX,XX @@ block = declare_dependency(link_whole: [libblock],
26
link_args: '@block.syms',
27
dependencies: [crypto, io])
28
29
+blockdev_ss = blockdev_ss.apply(config_host, strict: false)
30
+libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
31
+ dependencies: blockdev_ss.dependencies(),
32
+ name_suffix: 'fa',
33
+ build_by_default: false)
34
+
35
+blockdev = declare_dependency(link_whole: [libblockdev],
36
+ dependencies: [block])
37
+
38
qmp_ss = qmp_ss.apply(config_host, strict: false)
39
libqmp = static_library('qmp', qmp_ss.sources() + genh,
40
dependencies: qmp_ss.dependencies(),
41
@@ -XXX,XX +XXX,XX @@ foreach m : block_mods + softmmu_mods
42
install_dir: config_host['qemu_moddir'])
43
endforeach
44
45
-softmmu_ss.add(authz, block, chardev, crypto, io, qmp)
46
+softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
47
common_ss.add(qom, qemuutil)
48
49
common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
50
diff --git a/storage-daemon/meson.build b/storage-daemon/meson.build
51
index XXXXXXX..XXXXXXX 100644
52
--- a/storage-daemon/meson.build
53
+++ b/storage-daemon/meson.build
54
@@ -XXX,XX +XXX,XX @@
55
qsd_ss = ss.source_set()
56
qsd_ss.add(files('qemu-storage-daemon.c'))
57
-qsd_ss.add(block, chardev, qmp, qom, qemuutil)
58
-qsd_ss.add_all(blockdev_ss)
59
+qsd_ss.add(blockdev, chardev, qmp, qom, qemuutil)
60
61
subdir('qapi')
62
63
--
64
2.26.2
65
diff view generated by jsdifflib
[Qemu-devel] [PULL 17/21] qemu-io: Add failure regression tests
[PULL v2 21/28] block: move block exports to libblockdev
1
From: Nir Soffer <nirsof@gmail.com>
1
Block exports are used by softmmu, qemu-storage-daemon, and qemu-nbd.
2
They are not used by other programs and are not otherwise needed in
3
libblock.
2
4
3
Add regression tests checking that qemu-io fails with non-zero exit code
5
Undo the recent move of blockdev-nbd.c from blockdev_ss into block_ss.
4
when reading non-existing file or using the wrong image format.
6
Since bdrv_close_all() (libblock) calls blk_exp_close_all()
7
(libblockdev) a stub function is required..
5
8
6
Signed-off-by: Nir Soffer <nirsof@gmail.com>
9
Make qemu-nbd.c use signal handling utility functions instead of
7
Message-id: 20170201003120.23378-4-nirsof@gmail.com
10
duplicating the code. This helps because os-posix.c is in libblockdev
8
Reviewed-by: Max Reitz <mreitz@redhat.com>
11
and it depends on a qemu_system_killed() symbol that qemu-nbd.c lacks.
9
Signed-off-by: Max Reitz <mreitz@redhat.com>
12
Once we use the signal handling utility functions we also end up
13
providing the necessary symbol.
14
15
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
16
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
17
Reviewed-by: Eric Blake <eblake@redhat.com>
18
Message-id: 20200929125516.186715-4-stefanha@redhat.com
19
[Fixed s/ndb/nbd/ typo in commit description as suggested by Eric Blake
20
--Stefan]
21
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
10
---
22
---
11
tests/qemu-iotests/174 | 59 ++++++++++++++++++++++++++++++++++++++++++++++
23
qemu-nbd.c | 21 ++++++++-------------
12
tests/qemu-iotests/174.out | 7 ++++++
24
stubs/blk-exp-close-all.c | 7 +++++++
13
tests/qemu-iotests/group | 1 +
25
block/export/meson.build | 4 ++--
14
3 files changed, 67 insertions(+)
26
meson.build | 4 ++--
15
create mode 100755 tests/qemu-iotests/174
27
nbd/meson.build | 2 ++
16
create mode 100644 tests/qemu-iotests/174.out
28
stubs/meson.build | 1 +
29
6 files changed, 22 insertions(+), 17 deletions(-)
30
create mode 100644 stubs/blk-exp-close-all.c
17
31
18
diff --git a/tests/qemu-iotests/174 b/tests/qemu-iotests/174
32
diff --git a/qemu-nbd.c b/qemu-nbd.c
19
new file mode 100755
33
index XXXXXXX..XXXXXXX 100644
20
index XXXXXXX..XXXXXXX
34
--- a/qemu-nbd.c
21
--- /dev/null
35
+++ b/qemu-nbd.c
22
+++ b/tests/qemu-iotests/174
23
@@ -XXX,XX +XXX,XX @@
36
@@ -XXX,XX +XXX,XX @@
24
+#!/bin/bash
37
#include "qapi/error.h"
25
+#
38
#include "qemu/cutils.h"
26
+# Test that qemu-io fail with non-zero exit code
39
#include "sysemu/block-backend.h"
27
+#
40
+#include "sysemu/runstate.h" /* for qemu_system_killed() prototype */
28
+# Copyright (C) 2017 Nir Soffer <nirsof@gmail.com>
41
#include "block/block_int.h"
29
+#
42
#include "block/nbd.h"
30
+# This program is free software; you can redistribute it and/or modify
43
#include "qemu/main-loop.h"
31
+# it under the terms of the GNU General Public License as published by
44
@@ -XXX,XX +XXX,XX @@ QEMU_COPYRIGHT "\n"
32
+# the Free Software Foundation; either version 2 of the License, or
45
}
33
+# (at your option) any later version.
46
34
+#
47
#ifdef CONFIG_POSIX
35
+# This program is distributed in the hope that it will be useful,
48
-static void termsig_handler(int signum)
36
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
49
+/*
37
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
50
+ * The client thread uses SIGTERM to interrupt the server. A signal
38
+# GNU General Public License for more details.
51
+ * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
39
+#
52
+ */
40
+# You should have received a copy of the GNU General Public License
53
+void qemu_system_killed(int signum, pid_t pid)
41
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
54
{
42
+#
55
qatomic_cmpxchg(&state, RUNNING, TERMINATE);
43
+
56
qemu_notify_event();
44
+# creator
57
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
45
+owner=nirsof@gmail.com
58
BlockExportOptions *export_opts;
46
+
59
47
+seq=`basename $0`
60
#ifdef CONFIG_POSIX
48
+echo "QA output created by $seq"
61
- /*
49
+
62
- * Exit gracefully on various signals, which includes SIGTERM used
50
+here=`pwd`
63
- * by 'qemu-nbd -v -c'.
51
+status=1    # failure is the default!
64
- */
52
+
65
- struct sigaction sa_sigterm;
53
+_cleanup()
66
- memset(&sa_sigterm, 0, sizeof(sa_sigterm));
54
+{
67
- sa_sigterm.sa_handler = termsig_handler;
55
+    _cleanup_test_img
68
- sigaction(SIGTERM, &sa_sigterm, NULL);
56
+}
69
- sigaction(SIGINT, &sa_sigterm, NULL);
57
+trap "_cleanup; exit \$status" 0 1 2 3 15
70
- sigaction(SIGHUP, &sa_sigterm, NULL);
58
+
71
-
59
+# get standard environment, filters and checks
72
- signal(SIGPIPE, SIG_IGN);
60
+. ./common.rc
73
+ os_setup_early_signal_handling();
61
+. ./common.filter
74
+ os_setup_signal_handling();
62
+
75
#endif
63
+_unsupported_fmt raw
76
64
+
77
socket_init();
65
+
78
diff --git a/stubs/blk-exp-close-all.c b/stubs/blk-exp-close-all.c
66
+size=256K
67
+IMGFMT=raw IMGOPTS= _make_test_img $size | _filter_imgfmt
68
+
69
+echo
70
+echo "== reading wrong format should fail =="
71
+$QEMU_IO -f $IMGFMT -c "read 0 $size" "$TEST_IMG" 2>/dev/null
72
+test $? -eq 1 || _fail "did not fail"
73
+
74
+echo
75
+echo "== reading missing file should fail =="
76
+$QEMU_IO -c "read 0 $size" "$TEST_DIR/missing" 2>/dev/null
77
+test $? -eq 1 || _fail "did not fail"
78
+
79
+# success, all done
80
+echo "*** done"
81
+rm -f $seq.full
82
+status=0
83
diff --git a/tests/qemu-iotests/174.out b/tests/qemu-iotests/174.out
84
new file mode 100644
79
new file mode 100644
85
index XXXXXXX..XXXXXXX
80
index XXXXXXX..XXXXXXX
86
--- /dev/null
81
--- /dev/null
87
+++ b/tests/qemu-iotests/174.out
82
+++ b/stubs/blk-exp-close-all.c
88
@@ -XXX,XX +XXX,XX @@
83
@@ -XXX,XX +XXX,XX @@
89
+QA output created by 174
84
+#include "qemu/osdep.h"
90
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=262144
85
+#include "block/export.h"
91
+
86
+
92
+== reading wrong format should fail ==
87
+/* Only used in programs that support block exports (libblockdev.fa) */
93
+
88
+void blk_exp_close_all(void)
94
+== reading missing file should fail ==
89
+{
95
+*** done
90
+}
96
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
91
diff --git a/block/export/meson.build b/block/export/meson.build
97
index XXXXXXX..XXXXXXX 100644
92
index XXXXXXX..XXXXXXX 100644
98
--- a/tests/qemu-iotests/group
93
--- a/block/export/meson.build
99
+++ b/tests/qemu-iotests/group
94
+++ b/block/export/meson.build
100
@@ -XXX,XX +XXX,XX @@
95
@@ -XXX,XX +XXX,XX @@
101
171 rw auto quick
96
-block_ss.add(files('export.c'))
102
172 auto
97
-block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
103
173 rw auto
98
+blockdev_ss.add(files('export.c'))
104
+174 auto
99
+blockdev_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
100
diff --git a/meson.build b/meson.build
101
index XXXXXXX..XXXXXXX 100644
102
--- a/meson.build
103
+++ b/meson.build
104
@@ -XXX,XX +XXX,XX @@ subdir('dump')
105
106
block_ss.add(files(
107
'block.c',
108
- 'blockdev-nbd.c',
109
'blockjob.c',
110
'job.c',
111
'qemu-io-cmds.c',
112
@@ -XXX,XX +XXX,XX @@ subdir('block')
113
114
blockdev_ss.add(files(
115
'blockdev.c',
116
+ 'blockdev-nbd.c',
117
'iothread.c',
118
'job-qmp.c',
119
))
120
@@ -XXX,XX +XXX,XX @@ if have_tools
121
qemu_io = executable('qemu-io', files('qemu-io.c'),
122
dependencies: [block, qemuutil], install: true)
123
qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
124
- dependencies: [block, qemuutil], install: true)
125
+ dependencies: [blockdev, qemuutil], install: true)
126
127
subdir('storage-daemon')
128
subdir('contrib/rdmacm-mux')
129
diff --git a/nbd/meson.build b/nbd/meson.build
130
index XXXXXXX..XXXXXXX 100644
131
--- a/nbd/meson.build
132
+++ b/nbd/meson.build
133
@@ -XXX,XX +XXX,XX @@
134
block_ss.add(files(
135
'client.c',
136
'common.c',
137
+))
138
+blockdev_ss.add(files(
139
'server.c',
140
))
141
diff --git a/stubs/meson.build b/stubs/meson.build
142
index XXXXXXX..XXXXXXX 100644
143
--- a/stubs/meson.build
144
+++ b/stubs/meson.build
145
@@ -XXX,XX +XXX,XX @@
146
stub_ss.add(files('arch_type.c'))
147
stub_ss.add(files('bdrv-next-monitor-owned.c'))
148
stub_ss.add(files('blk-commit-all.c'))
149
+stub_ss.add(files('blk-exp-close-all.c'))
150
stub_ss.add(files('blockdev-close-all-bdrv-states.c'))
151
stub_ss.add(files('change-state-handler.c'))
152
stub_ss.add(files('cmos.c'))
105
--
153
--
106
2.11.0
154
2.26.2
107
155
108
diff view generated by jsdifflib
[Qemu-devel] [PULL 19/21] qemu-io: don't allow I/O operations larger than BDRV_REQUEST_MAX_BYTES
[PULL v2 22/28] block/export: add iothread and fixed-iothread options
1
From: Alberto Garcia <berto@igalia.com>
1
Make it possible to specify the iothread where the export will run. By
2
default the block node can be moved to other AioContexts later and the
3
export will follow. The fixed-iothread option forces strict behavior
4
that prevents changing AioContext while the export is active. See the
5
QAPI docs for details.
2
6
3
Passing a request size larger than BDRV_REQUEST_MAX_BYTES to any of the
7
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
4
I/O commands results in an error. While 'read' and 'write' handle the
8
Message-id: 20200929125516.186715-5-stefanha@redhat.com
5
error correctly, 'aio_read' and 'aio_write' hit an assertion:
9
[Fix stray '#' character in block-export.json and add missing "(since:
10
5.2)" as suggested by Eric Blake.
11
--Stefan]
12
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
13
---
14
qapi/block-export.json | 11 ++++++++++
15
block/export/export.c | 31 +++++++++++++++++++++++++++-
16
block/export/vhost-user-blk-server.c | 5 ++++-
17
nbd/server.c | 2 --
18
4 files changed, 45 insertions(+), 4 deletions(-)
6
19
7
blk_aio_read_entry: Assertion `rwco->qiov->size == acb->bytes' failed.
20
diff --git a/qapi/block-export.json b/qapi/block-export.json
8
9
The reason is that the QEMU I/O code cannot handle request sizes
10
larger than BDRV_REQUEST_MAX_BYTES, so this patch makes qemu-io check
11
that all values are within range.
12
13
Signed-off-by: Alberto Garcia <berto@igalia.com>
14
Message-id: 79f66648c685929a144396bda24d13a207131dcf.1485878688.git.berto@igalia.com
15
[mreitz: Use BDRV_REQUEST_MAX_BYTES instead of INT_MAX]
16
Signed-off-by: Max Reitz <mreitz@redhat.com>
17
---
18
qemu-io-cmds.c | 20 +++++++++++++-------
19
1 file changed, 13 insertions(+), 7 deletions(-)
20
21
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
22
index XXXXXXX..XXXXXXX 100644
21
index XXXXXXX..XXXXXXX 100644
23
--- a/qemu-io-cmds.c
22
--- a/qapi/block-export.json
24
+++ b/qemu-io-cmds.c
23
+++ b/qapi/block-export.json
25
@@ -XXX,XX +XXX,XX @@ create_iovec(BlockBackend *blk, QEMUIOVector *qiov, char **argv, int nr_iov,
24
@@ -XXX,XX +XXX,XX @@
26
goto fail;
25
# export before completion is signalled. (since: 5.2;
27
}
26
# default: false)
28
27
#
29
- if (len > SIZE_MAX) {
28
+# @iothread: The name of the iothread object where the export will run. The
30
- printf("Argument '%s' exceeds maximum size %llu\n", arg,
29
+# default is to use the thread currently associated with the
31
- (unsigned long long)SIZE_MAX);
30
+# block node. (since: 5.2)
32
+ if (len > BDRV_REQUEST_MAX_BYTES) {
31
+#
33
+ printf("Argument '%s' exceeds maximum size %" PRIu64 "\n", arg,
32
+# @fixed-iothread: True prevents the block node from being moved to another
34
+ (uint64_t)BDRV_REQUEST_MAX_BYTES);
33
+# thread while the export is active. If true and @iothread is
34
+# given, export creation fails if the block node cannot be
35
+# moved to the iothread. The default is false. (since: 5.2)
36
+#
37
# Since: 4.2
38
##
39
{ 'union': 'BlockExportOptions',
40
'base': { 'type': 'BlockExportType',
41
'id': 'str',
42
+     '*fixed-iothread': 'bool',
43
+     '*iothread': 'str',
44
'node-name': 'str',
45
'*writable': 'bool',
46
'*writethrough': 'bool' },
47
diff --git a/block/export/export.c b/block/export/export.c
48
index XXXXXXX..XXXXXXX 100644
49
--- a/block/export/export.c
50
+++ b/block/export/export.c
51
@@ -XXX,XX +XXX,XX @@
52
53
#include "block/block.h"
54
#include "sysemu/block-backend.h"
55
+#include "sysemu/iothread.h"
56
#include "block/export.h"
57
#include "block/nbd.h"
58
#include "qapi/error.h"
59
@@ -XXX,XX +XXX,XX @@ static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
60
61
BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
62
{
63
+ bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
64
const BlockExportDriver *drv;
65
BlockExport *exp = NULL;
66
BlockDriverState *bs;
67
- BlockBackend *blk;
68
+ BlockBackend *blk = NULL;
69
AioContext *ctx;
70
uint64_t perm;
71
int ret;
72
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
73
ctx = bdrv_get_aio_context(bs);
74
aio_context_acquire(ctx);
75
76
+ if (export->has_iothread) {
77
+ IOThread *iothread;
78
+ AioContext *new_ctx;
79
+
80
+ iothread = iothread_by_id(export->iothread);
81
+ if (!iothread) {
82
+ error_setg(errp, "iothread \"%s\" not found", export->iothread);
35
+ goto fail;
83
+ goto fail;
36
+ }
84
+ }
37
+
85
+
38
+ if (count > BDRV_REQUEST_MAX_BYTES - len) {
86
+ new_ctx = iothread_get_aio_context(iothread);
39
+ printf("The total number of bytes exceed the maximum size %" PRIu64
87
+
40
+ "\n", (uint64_t)BDRV_REQUEST_MAX_BYTES);
88
+ ret = bdrv_try_set_aio_context(bs, new_ctx, errp);
41
goto fail;
89
+ if (ret == 0) {
42
}
90
+ aio_context_release(ctx);
43
91
+ aio_context_acquire(new_ctx);
44
@@ -XXX,XX +XXX,XX @@ static int read_f(BlockBackend *blk, int argc, char **argv)
92
+ ctx = new_ctx;
45
if (count < 0) {
93
+ } else if (fixed_iothread) {
46
print_cvtnum_err(count, argv[optind]);
94
+ goto fail;
47
return 0;
95
+ }
48
- } else if (count > SIZE_MAX) {
96
+ }
49
+ } else if (count > BDRV_REQUEST_MAX_BYTES) {
97
+
50
printf("length cannot exceed %" PRIu64 ", given %s\n",
98
/*
51
- (uint64_t) SIZE_MAX, argv[optind]);
99
* Block exports are used for non-shared storage migration. Make sure
52
+ (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);
100
* that BDRV_O_INACTIVE is cleared and the image is ready for write
53
return 0;
101
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
54
}
102
}
55
103
56
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
104
blk = blk_new(ctx, perm, BLK_PERM_ALL);
57
if (count < 0) {
105
+
58
print_cvtnum_err(count, argv[optind]);
106
+ if (!fixed_iothread) {
59
return 0;
107
+ blk_set_allow_aio_context_change(blk, true);
60
- } else if (count > SIZE_MAX) {
108
+ }
61
+ } else if (count > BDRV_REQUEST_MAX_BYTES) {
109
+
62
printf("length cannot exceed %" PRIu64 ", given %s\n",
110
ret = blk_insert_bs(blk, bs, errp);
63
- (uint64_t) SIZE_MAX, argv[optind]);
111
if (ret < 0) {
64
+ (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);
112
goto fail;
65
return 0;
113
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
114
index XXXXXXX..XXXXXXX 100644
115
--- a/block/export/vhost-user-blk-server.c
116
+++ b/block/export/vhost-user-blk-server.c
117
@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_blk_iface = {
118
static void blk_aio_attached(AioContext *ctx, void *opaque)
119
{
120
VuBlkExport *vexp = opaque;
121
+
122
+ vexp->export.ctx = ctx;
123
vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
124
}
125
126
static void blk_aio_detach(void *opaque)
127
{
128
VuBlkExport *vexp = opaque;
129
+
130
vhost_user_server_detach_aio_context(&vexp->vu_server);
131
+ vexp->export.ctx = NULL;
132
}
133
134
static void
135
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
136
vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
137
logical_block_size);
138
139
- blk_set_allow_aio_context_change(exp->blk, true);
140
blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
141
vexp);
142
143
diff --git a/nbd/server.c b/nbd/server.c
144
index XXXXXXX..XXXXXXX 100644
145
--- a/nbd/server.c
146
+++ b/nbd/server.c
147
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
148
return ret;
66
}
149
}
67
150
151
- blk_set_allow_aio_context_change(blk, true);
152
-
153
QTAILQ_INIT(&exp->clients);
154
exp->name = g_strdup(arg->name);
155
exp->description = g_strdup(arg->description);
68
--
156
--
69
2.11.0
157
2.26.2
70
158
71
diff view generated by jsdifflib
[Qemu-devel] [PULL 13/21] block/nfs: fix NULL pointer dereference in URI parsing
[PULL v2 23/28] block/export: add vhost-user-blk multi-queue support
1
From: Peter Lieven <pl@kamp.de>
1
Allow the number of queues to be configured using --export
2
vhost-user-blk,num-queues=N. This setting should match the QEMU --device
3
vhost-user-blk-pci,num-queues=N setting but QEMU vhost-user-blk.c lowers
4
its own value if the vhost-user-blk backend offers fewer queues than
5
QEMU.
2
6
3
parse_uint_full wants to put the parsed value into the
7
The vhost-user-blk-server.c code is already capable of multi-queue. All
4
variable passed via its second argument which is NULL.
8
virtqueue processing runs in the same AioContext. No new locking is
9
needed.
5
10
6
Fixes: 94d6a7a76e9df9919629428f6c598e2b97d9426c
11
Add the num-queues=N option and set the VIRTIO_BLK_F_MQ feature bit.
7
Cc: qemu-stable@nongnu.org
12
Note that the feature bit only announces the presence of the num_queues
8
Signed-off-by: Peter Lieven <pl@kamp.de>
13
configuration space field. It does not promise that there is more than 1
9
Reviewed-by: Eric Blake <eblake@redhat.com>
14
virtqueue, so we can set it unconditionally.
10
Message-id: 1485942829-10756-2-git-send-email-pl@kamp.de
15
11
Signed-off-by: Max Reitz <mreitz@redhat.com>
16
I tested multi-queue by running a random read fio test with numjobs=4 on
17
an -smp 4 guest. After the benchmark finished the guest /proc/interrupts
18
file showed activity on all 4 virtio-blk MSI-X. The /sys/block/vda/mq/
19
directory shows that Linux blk-mq has 4 queues configured.
20
21
An automated test is included in the next commit.
22
23
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
24
Acked-by: Markus Armbruster <armbru@redhat.com>
25
Message-id: 20201001144604.559733-2-stefanha@redhat.com
26
[Fixed accidental tab characters as suggested by Markus Armbruster
27
--Stefan]
28
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
12
---
29
---
13
block/nfs.c | 3 ++-
30
qapi/block-export.json | 10 +++++++---
14
1 file changed, 2 insertions(+), 1 deletion(-)
31
block/export/vhost-user-blk-server.c | 24 ++++++++++++++++++------
32
2 files changed, 25 insertions(+), 9 deletions(-)
15
33
16
diff --git a/block/nfs.c b/block/nfs.c
34
diff --git a/qapi/block-export.json b/qapi/block-export.json
17
index XXXXXXX..XXXXXXX 100644
35
index XXXXXXX..XXXXXXX 100644
18
--- a/block/nfs.c
36
--- a/qapi/block-export.json
19
+++ b/block/nfs.c
37
+++ b/qapi/block-export.json
20
@@ -XXX,XX +XXX,XX @@ static int nfs_parse_uri(const char *filename, QDict *options, Error **errp)
38
@@ -XXX,XX +XXX,XX @@
21
qdict_put(options, "path", qstring_from_str(uri->path));
39
# SocketAddress types are supported. Passed fds must be UNIX domain
22
40
# sockets.
23
for (i = 0; i < qp->n; i++) {
41
# @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
24
+ unsigned long long val;
42
+# @num-queues: Number of request virtqueues. Must be greater than 0. Defaults
25
if (!qp->p[i].value) {
43
+# to 1.
26
error_setg(errp, "Value for NFS parameter expected: %s",
44
#
27
qp->p[i].name);
45
# Since: 5.2
28
goto out;
46
##
29
}
47
{ 'struct': 'BlockExportOptionsVhostUserBlk',
30
- if (parse_uint_full(qp->p[i].value, NULL, 0)) {
48
- 'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
31
+ if (parse_uint_full(qp->p[i].value, &val, 0)) {
49
+ 'data': { 'addr': 'SocketAddress',
32
error_setg(errp, "Illegal value for NFS parameter: %s",
50
+     '*logical-block-size': 'size',
33
qp->p[i].name);
51
+ '*num-queues': 'uint16'} }
34
goto out;
52
53
##
54
# @NbdServerAddOptions:
55
@@ -XXX,XX +XXX,XX @@
56
{ 'union': 'BlockExportOptions',
57
'base': { 'type': 'BlockExportType',
58
'id': 'str',
59
-     '*fixed-iothread': 'bool',
60
-     '*iothread': 'str',
61
+ '*fixed-iothread': 'bool',
62
+ '*iothread': 'str',
63
'node-name': 'str',
64
'*writable': 'bool',
65
'*writethrough': 'bool' },
66
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
67
index XXXXXXX..XXXXXXX 100644
68
--- a/block/export/vhost-user-blk-server.c
69
+++ b/block/export/vhost-user-blk-server.c
70
@@ -XXX,XX +XXX,XX @@
71
#include "util/block-helpers.h"
72
73
enum {
74
- VHOST_USER_BLK_MAX_QUEUES = 1,
75
+ VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
76
};
77
struct virtio_blk_inhdr {
78
unsigned char status;
79
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_blk_get_features(VuDev *dev)
80
1ull << VIRTIO_BLK_F_DISCARD |
81
1ull << VIRTIO_BLK_F_WRITE_ZEROES |
82
1ull << VIRTIO_BLK_F_CONFIG_WCE |
83
+ 1ull << VIRTIO_BLK_F_MQ |
84
1ull << VIRTIO_F_VERSION_1 |
85
1ull << VIRTIO_RING_F_INDIRECT_DESC |
86
1ull << VIRTIO_RING_F_EVENT_IDX |
87
@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)
88
89
static void
90
vu_blk_initialize_config(BlockDriverState *bs,
91
- struct virtio_blk_config *config, uint32_t blk_size)
92
+ struct virtio_blk_config *config,
93
+ uint32_t blk_size,
94
+ uint16_t num_queues)
95
{
96
config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
97
config->blk_size = blk_size;
98
@@ -XXX,XX +XXX,XX @@ vu_blk_initialize_config(BlockDriverState *bs,
99
config->seg_max = 128 - 2;
100
config->min_io_size = 1;
101
config->opt_io_size = 1;
102
- config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
103
+ config->num_queues = num_queues;
104
config->max_discard_sectors = 32768;
105
config->max_discard_seg = 1;
106
config->discard_sector_alignment = config->blk_size >> 9;
107
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
108
BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
109
Error *local_err = NULL;
110
uint64_t logical_block_size;
111
+ uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
112
113
vexp->writable = opts->writable;
114
vexp->blkcfg.wce = 0;
115
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
116
}
117
vexp->blk_size = logical_block_size;
118
blk_set_guest_block_size(exp->blk, logical_block_size);
119
+
120
+ if (vu_opts->has_num_queues) {
121
+ num_queues = vu_opts->num_queues;
122
+ }
123
+ if (num_queues == 0) {
124
+ error_setg(errp, "num-queues must be greater than 0");
125
+ return -EINVAL;
126
+ }
127
+
128
vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
129
- logical_block_size);
130
+ logical_block_size, num_queues);
131
132
blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
133
vexp);
134
135
if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
136
- VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
137
- errp)) {
138
+ num_queues, &vu_blk_iface, errp)) {
139
blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
140
blk_aio_detach, vexp);
141
return -EADDRNOTAVAIL;
35
--
142
--
36
2.11.0
143
2.26.2
37
144
38
diff view generated by jsdifflib
[Qemu-devel] [PULL 18/21] qcow2: Optimize the refcount-block overlap check
[PULL v2 24/28] block/io: fix bdrv_co_block_status_above
1
From: Alberto Garcia <berto@igalia.com>
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
2
2
3
The metadata overlap checks introduced in a40f1c2add help detect
3
bdrv_co_block_status_above has several design problems with handling
4
corruption in the qcow2 image by verifying that data writes don't
4
short backing files:
5
overlap with existing metadata sections.
6
5
7
The 'refcount-block' check in particular iterates over the refcount
6
1. With want_zeros=true, it may return ret with BDRV_BLOCK_ZERO but
8
table in order to get the addresses of all refcount blocks and check
7
without BDRV_BLOCK_ALLOCATED flag, when actually short backing file
9
that none of them overlap with the region where we want to write.
8
which produces these after-EOF zeros is inside requested backing
9
sequence.
10
10
11
The problem with the refcount table is that since it always occupies
11
2. With want_zero=false, it may return pnum=0 prior to actual EOF,
12
complete clusters its size is usually very big. With the default
12
because of EOF of short backing file.
13
values of cluster_size=64KB and refcount_bits=16 this table holds 8192
14
entries, each one of them enough to map 2GB worth of host clusters.
15
13
16
So unless we're using images with several TB of allocated data this
14
Fix these things, making logic about short backing files clearer.
17
table is going to be mostly empty, and iterating over it is a waste of
18
CPU. If the storage backend is fast enough this can have an effect on
19
I/O performance.
20
15
21
This patch keeps the index of the last used (i.e. non-zero) entry in
16
With fixed bdrv_block_status_above we also have to improve is_zero in
22
the refcount table and updates it every time the table changes. The
17
qcow2 code, otherwise iotest 154 will fail, because with this patch we
23
refcount-block overlap check then uses that index instead of reading
18
stop to merge zeros of different types (produced by fully unallocated
24
the whole table.
19
in the whole backing chain regions vs produced by short backing files).
25
20
26
In my tests with a 4GB qcow2 file stored in RAM this doubles the
21
Note also, that this patch leaves for another day the general problem
27
amount of write IOPS.
22
around block-status: misuse of BDRV_BLOCK_ALLOCATED as is-fs-allocated
23
vs go-to-backing.
28
24
29
Signed-off-by: Alberto Garcia <berto@igalia.com>
25
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
30
Message-id: 20170201123828.4815-1-berto@igalia.com
26
Reviewed-by: Alberto Garcia <berto@igalia.com>
31
Reviewed-by: Max Reitz <mreitz@redhat.com>
27
Reviewed-by: Eric Blake <eblake@redhat.com>
32
Signed-off-by: Max Reitz <mreitz@redhat.com>
28
Message-id: 20200924194003.22080-2-vsementsov@virtuozzo.com
29
[Fix s/comes/come/ as suggested by Eric Blake
30
--Stefan]
31
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
33
---
32
---
34
block/qcow2.h | 1 +
33
block/io.c | 68 ++++++++++++++++++++++++++++++++++++++++-----------
35
block/qcow2-refcount.c | 24 +++++++++++++++++++++++-
34
block/qcow2.c | 16 ++++++++++--
36
block/qcow2.c | 1 +
35
2 files changed, 68 insertions(+), 16 deletions(-)
37
3 files changed, 25 insertions(+), 1 deletion(-)
38
36
39
diff --git a/block/qcow2.h b/block/qcow2.h
37
diff --git a/block/io.c b/block/io.c
40
index XXXXXXX..XXXXXXX 100644
38
index XXXXXXX..XXXXXXX 100644
41
--- a/block/qcow2.h
39
--- a/block/io.c
42
+++ b/block/qcow2.h
40
+++ b/block/io.c
43
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVQcow2State {
41
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
44
uint64_t *refcount_table;
42
int64_t *map,
45
uint64_t refcount_table_offset;
43
BlockDriverState **file)
46
uint32_t refcount_table_size;
44
{
47
+ uint32_t max_refcount_table_index; /* Last used entry in refcount_table */
45
+ int ret;
48
uint64_t free_cluster_index;
46
BlockDriverState *p;
49
uint64_t free_byte_offset;
47
- int ret = 0;
50
48
- bool first = true;
51
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
49
+ int64_t eof = 0;
52
index XXXXXXX..XXXXXXX 100644
50
53
--- a/block/qcow2-refcount.c
51
assert(bs != base);
54
+++ b/block/qcow2-refcount.c
52
- for (p = bs; p != base; p = bdrv_filter_or_cow_bs(p)) {
55
@@ -XXX,XX +XXX,XX @@ static Qcow2SetRefcountFunc *const set_refcount_funcs[] = {
53
+
56
/*********************************************************/
54
+ ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
57
/* refcount handling */
55
+ if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
58
56
+ return ret;
59
+static void update_max_refcount_table_index(BDRVQcow2State *s)
60
+{
61
+ unsigned i = s->refcount_table_size - 1;
62
+ while (i > 0 && (s->refcount_table[i] & REFT_OFFSET_MASK) == 0) {
63
+ i--;
64
+ }
57
+ }
65
+ /* Set s->max_refcount_table_index to the index of the last used entry */
66
+ s->max_refcount_table_index = i;
67
+}
68
+
58
+
69
int qcow2_refcount_init(BlockDriverState *bs)
59
+ if (ret & BDRV_BLOCK_EOF) {
70
{
60
+ eof = offset + *pnum;
71
BDRVQcow2State *s = bs->opaque;
61
+ }
72
@@ -XXX,XX +XXX,XX @@ int qcow2_refcount_init(BlockDriverState *bs)
62
+
63
+ assert(*pnum <= bytes);
64
+ bytes = *pnum;
65
+
66
+ for (p = bdrv_filter_or_cow_bs(bs); p != base;
67
+ p = bdrv_filter_or_cow_bs(p))
68
+ {
69
ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
70
file);
71
if (ret < 0) {
72
- break;
73
+ return ret;
73
}
74
}
74
for(i = 0; i < s->refcount_table_size; i++)
75
- if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {
75
be64_to_cpus(&s->refcount_table[i]);
76
+ if (*pnum == 0) {
76
+ update_max_refcount_table_index(s);
77
/*
78
- * Reading beyond the end of the file continues to read
79
- * zeroes, but we can only widen the result to the
80
- * unallocated length we learned from an earlier
81
- * iteration.
82
+ * The top layer deferred to this layer, and because this layer is
83
+ * short, any zeroes that we synthesize beyond EOF behave as if they
84
+ * were allocated at this layer.
85
+ *
86
+ * We don't include BDRV_BLOCK_EOF into ret, as upper layer may be
87
+ * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
88
+ * below.
89
*/
90
+ assert(ret & BDRV_BLOCK_EOF);
91
*pnum = bytes;
92
+ if (file) {
93
+ *file = p;
94
+ }
95
+ ret = BDRV_BLOCK_ZERO | BDRV_BLOCK_ALLOCATED;
96
+ break;
97
}
98
- if (ret & (BDRV_BLOCK_ZERO | BDRV_BLOCK_DATA)) {
99
+ if (ret & BDRV_BLOCK_ALLOCATED) {
100
+ /*
101
+ * We've found the node and the status, we must break.
102
+ *
103
+ * Drop BDRV_BLOCK_EOF, as it's not for upper layer, which may be
104
+ * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
105
+ * below.
106
+ */
107
+ ret &= ~BDRV_BLOCK_EOF;
108
break;
109
}
110
- /* [offset, pnum] unallocated on this layer, which could be only
111
- * the first part of [offset, bytes]. */
112
- bytes = MIN(bytes, *pnum);
113
- first = false;
114
+
115
+ /*
116
+ * OK, [offset, offset + *pnum) region is unallocated on this layer,
117
+ * let's continue the diving.
118
+ */
119
+ assert(*pnum <= bytes);
120
+ bytes = *pnum;
121
+ }
122
+
123
+ if (offset + *pnum == eof) {
124
+ ret |= BDRV_BLOCK_EOF;
77
}
125
}
78
return 0;
126
+
79
fail:
127
return ret;
80
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
128
}
81
}
129
82
83
s->refcount_table[refcount_table_index] = new_block;
84
+ /* If there's a hole in s->refcount_table then it can happen
85
+ * that refcount_table_index < s->max_refcount_table_index */
86
+ s->max_refcount_table_index =
87
+ MAX(s->max_refcount_table_index, refcount_table_index);
88
89
/* The new refcount block may be where the caller intended to put its
90
* data, so let it restart the search. */
91
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
92
s->refcount_table = new_table;
93
s->refcount_table_size = table_size;
94
s->refcount_table_offset = table_offset;
95
+ update_max_refcount_table_index(s);
96
97
/* Free old table. */
98
qcow2_free_clusters(bs, old_table_offset, old_table_size * sizeof(uint64_t),
99
@@ -XXX,XX +XXX,XX @@ write_refblocks:
100
s->refcount_table = on_disk_reftable;
101
s->refcount_table_offset = reftable_offset;
102
s->refcount_table_size = reftable_size;
103
+ update_max_refcount_table_index(s);
104
105
return 0;
106
107
@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
108
}
109
110
if ((chk & QCOW2_OL_REFCOUNT_BLOCK) && s->refcount_table) {
111
- for (i = 0; i < s->refcount_table_size; i++) {
112
+ unsigned last_entry = s->max_refcount_table_index;
113
+ assert(last_entry < s->refcount_table_size);
114
+ assert(last_entry + 1 == s->refcount_table_size ||
115
+ (s->refcount_table[last_entry + 1] & REFT_OFFSET_MASK) == 0);
116
+ for (i = 0; i <= last_entry; i++) {
117
if ((s->refcount_table[i] & REFT_OFFSET_MASK) &&
118
overlaps_with(s->refcount_table[i] & REFT_OFFSET_MASK,
119
s->cluster_size)) {
120
@@ -XXX,XX +XXX,XX @@ int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
121
/* Now update the rest of the in-memory information */
122
old_reftable = s->refcount_table;
123
s->refcount_table = new_reftable;
124
+ update_max_refcount_table_index(s);
125
126
s->refcount_bits = 1 << refcount_order;
127
s->refcount_max = UINT64_C(1) << (s->refcount_bits - 1);
128
diff --git a/block/qcow2.c b/block/qcow2.c
130
diff --git a/block/qcow2.c b/block/qcow2.c
129
index XXXXXXX..XXXXXXX 100644
131
index XXXXXXX..XXXXXXX 100644
130
--- a/block/qcow2.c
132
--- a/block/qcow2.c
131
+++ b/block/qcow2.c
133
+++ b/block/qcow2.c
132
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
134
@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
133
135
if (!bytes) {
134
s->refcount_table_offset = s->cluster_size;
136
return true;
135
s->refcount_table_size = s->cluster_size / sizeof(uint64_t);
137
}
136
+ s->max_refcount_table_index = 0;
138
- res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
137
139
- return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
138
g_free(s->refcount_table);
140
+
139
s->refcount_table = new_reftable;
141
+ /*
142
+ * bdrv_block_status_above doesn't merge different types of zeros, for
143
+ * example, zeros which come from the region which is unallocated in
144
+ * the whole backing chain, and zeros which come because of a short
145
+ * backing file. So, we need a loop.
146
+ */
147
+ do {
148
+ res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
149
+ offset += nr;
150
+ bytes -= nr;
151
+ } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
152
+
153
+ return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
154
}
155
156
static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
140
--
157
--
141
2.11.0
158
2.26.2
142
159
143
diff view generated by jsdifflib
[Qemu-devel] [PULL 20/21] qemu-img: Use qemu_strtoul() rather than raw strtoul()
[PULL v2 25/28] block/io: bdrv_common_block_status_above: support include_base
1
From: Peter Maydell <peter.maydell@linaro.org>
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
2
2
3
Some of the argument parsing in qemu-img uses strtoul() to parse
3
In order to reuse bdrv_common_block_status_above in
4
integer arguments. This is tricky to get correct and in fact the
4
bdrv_is_allocated_above, let's support include_base parameter.
5
code does not get it right, because it assigns the result of
6
strtoul() to an 'int' variable and then tries to check for > INT_MAX.
7
Coverity correctly complains that the comparison is always false.
8
5
9
Rewrite to use qemu_strtoul(), which has a saner convention for
6
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
10
reporting conversion failures.
7
Reviewed-by: Alberto Garcia <berto@igalia.com>
8
Reviewed-by: Eric Blake <eblake@redhat.com>
9
Message-id: 20200924194003.22080-3-vsementsov@virtuozzo.com
10
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
11
---
12
block/coroutines.h | 2 ++
13
block/io.c | 21 ++++++++++++++-------
14
2 files changed, 16 insertions(+), 7 deletions(-)
11
15
12
(Fixes CID 1356421, CID 1356422, CID 1356423.)
16
diff --git a/block/coroutines.h b/block/coroutines.h
13
14
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
15
Message-id: 1486744104-15590-2-git-send-email-peter.maydell@linaro.org
16
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
17
Signed-off-by: Max Reitz <mreitz@redhat.com>
18
---
19
qemu-img.c | 32 ++++++++++++++++----------------
20
1 file changed, 16 insertions(+), 16 deletions(-)
21
22
diff --git a/qemu-img.c b/qemu-img.c
23
index XXXXXXX..XXXXXXX 100644
17
index XXXXXXX..XXXXXXX 100644
24
--- a/qemu-img.c
18
--- a/block/coroutines.h
25
+++ b/qemu-img.c
19
+++ b/block/coroutines.h
26
@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)
20
@@ -XXX,XX +XXX,XX @@ bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
27
break;
21
int coroutine_fn
28
case 'c':
22
bdrv_co_common_block_status_above(BlockDriverState *bs,
29
{
23
BlockDriverState *base,
30
- char *end;
24
+ bool include_base,
31
- errno = 0;
25
bool want_zero,
32
- count = strtoul(optarg, &end, 0);
26
int64_t offset,
33
- if (errno || *end || count > INT_MAX) {
27
int64_t bytes,
34
+ unsigned long res;
28
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
35
+
29
int generated_co_wrapper
36
+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
30
bdrv_common_block_status_above(BlockDriverState *bs,
37
error_report("Invalid request count specified");
31
BlockDriverState *base,
38
return 1;
32
+ bool include_base,
39
}
33
bool want_zero,
40
+ count = res;
34
int64_t offset,
35
int64_t bytes,
36
diff --git a/block/io.c b/block/io.c
37
index XXXXXXX..XXXXXXX 100644
38
--- a/block/io.c
39
+++ b/block/io.c
40
@@ -XXX,XX +XXX,XX @@ early_out:
41
int coroutine_fn
42
bdrv_co_common_block_status_above(BlockDriverState *bs,
43
BlockDriverState *base,
44
+ bool include_base,
45
bool want_zero,
46
int64_t offset,
47
int64_t bytes,
48
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
49
BlockDriverState *p;
50
int64_t eof = 0;
51
52
- assert(bs != base);
53
+ assert(include_base || bs != base);
54
+ assert(!include_base || base); /* Can't include NULL base */
55
56
ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
57
- if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
58
+ if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
59
return ret;
60
}
61
62
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
63
assert(*pnum <= bytes);
64
bytes = *pnum;
65
66
- for (p = bdrv_filter_or_cow_bs(bs); p != base;
67
+ for (p = bdrv_filter_or_cow_bs(bs); include_base || p != base;
68
p = bdrv_filter_or_cow_bs(p))
69
{
70
ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
71
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
41
break;
72
break;
42
}
73
}
43
case 'd':
74
44
{
75
+ if (p == base) {
45
- char *end;
76
+ assert(include_base);
46
- errno = 0;
77
+ break;
47
- depth = strtoul(optarg, &end, 0);
78
+ }
48
- if (errno || *end || depth > INT_MAX) {
49
+ unsigned long res;
50
+
79
+
51
+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
80
/*
52
error_report("Invalid queue depth specified");
81
* OK, [offset, offset + *pnum) region is unallocated on this layer,
53
return 1;
82
* let's continue the diving.
54
}
83
@@ -XXX,XX +XXX,XX @@ int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
55
+ depth = res;
84
int64_t offset, int64_t bytes, int64_t *pnum,
56
break;
85
int64_t *map, BlockDriverState **file)
57
}
86
{
58
case 'f':
87
- return bdrv_common_block_status_above(bs, base, true, offset, bytes,
59
@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)
88
+ return bdrv_common_block_status_above(bs, base, false, true, offset, bytes,
60
break;
89
pnum, map, file);
61
case OPTION_PATTERN:
90
}
62
{
91
63
- char *end;
92
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
64
- errno = 0;
93
int ret;
65
- pattern = strtoul(optarg, &end, 0);
94
int64_t dummy;
66
- if (errno || *end || pattern > 0xff) {
95
67
+ unsigned long res;
96
- ret = bdrv_common_block_status_above(bs, bdrv_filter_or_cow_bs(bs), false,
68
+
97
- offset, bytes, pnum ? pnum : &dummy,
69
+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > 0xff) {
98
- NULL, NULL);
70
error_report("Invalid pattern byte specified");
99
+ ret = bdrv_common_block_status_above(bs, bs, true, false, offset,
71
return 1;
100
+ bytes, pnum ? pnum : &dummy, NULL,
72
}
101
+ NULL);
73
+ pattern = res;
102
if (ret < 0) {
74
break;
103
return ret;
75
}
104
}
76
case OPTION_FLUSH_INTERVAL:
77
{
78
- char *end;
79
- errno = 0;
80
- flush_interval = strtoul(optarg, &end, 0);
81
- if (errno || *end || flush_interval > INT_MAX) {
82
+ unsigned long res;
83
+
84
+ if (qemu_strtoul(optarg, NULL, 0, &res) < 0 || res > INT_MAX) {
85
error_report("Invalid flush interval specified");
86
return 1;
87
}
88
+ flush_interval = res;
89
break;
90
}
91
case OPTION_NO_DRAIN:
92
--
105
--
93
2.11.0
106
2.26.2
94
107
95
diff view generated by jsdifflib
[Qemu-devel] [PULL 02/21] qemu-img: Improve commit invalid base message
[PULL v2 26/28] block/io: bdrv_common_block_status_above: support bs == base
1
When trying to invoke qemu-img commit with a base image file name that
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
2
is not part of the top image's backing chain, the user receives a rather
3
plain "Base not found" error message. This is not really helpful because
4
it does not explain what "not found" means, potentially leaving the user
5
wondering why qemu cannot find a file despite it clearly existing in the
6
file system.
7
2
8
Improve the error message by clarifying that "not found" means "not
3
We are going to reuse bdrv_common_block_status_above in
9
found in the top image's backing chain".
4
bdrv_is_allocated_above. bdrv_is_allocated_above may be called with
5
include_base == false and still bs == base (for ex. from img_rebase()).
10
6
11
Reported-by: Ala Hino <ahino@redhat.com>
7
So, support this corner case.
12
Signed-off-by: Max Reitz <mreitz@redhat.com>
8
13
Message-id: 20161201020508.24417-1-mreitz@redhat.com
9
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
10
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
14
Reviewed-by: Eric Blake <eblake@redhat.com>
11
Reviewed-by: Eric Blake <eblake@redhat.com>
15
Signed-off-by: Max Reitz <mreitz@redhat.com>
12
Reviewed-by: Alberto Garcia <berto@igalia.com>
13
Message-id: 20200924194003.22080-4-vsementsov@virtuozzo.com
14
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
16
---
15
---
17
qemu-img.c | 4 +++-
16
block/io.c | 6 +++++-
18
1 file changed, 3 insertions(+), 1 deletion(-)
17
1 file changed, 5 insertions(+), 1 deletion(-)
19
18
20
diff --git a/qemu-img.c b/qemu-img.c
19
diff --git a/block/io.c b/block/io.c
21
index XXXXXXX..XXXXXXX 100644
20
index XXXXXXX..XXXXXXX 100644
22
--- a/qemu-img.c
21
--- a/block/io.c
23
+++ b/qemu-img.c
22
+++ b/block/io.c
24
@@ -XXX,XX +XXX,XX @@ static int img_commit(int argc, char **argv)
23
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
25
if (base) {
24
BlockDriverState *p;
26
base_bs = bdrv_find_backing_image(bs, base);
25
int64_t eof = 0;
27
if (!base_bs) {
26
28
- error_setg(&local_err, QERR_BASE_NOT_FOUND, base);
27
- assert(include_base || bs != base);
29
+ error_setg(&local_err,
28
assert(!include_base || base); /* Can't include NULL base */
30
+ "Did not find '%s' in the backing chain of '%s'",
29
31
+ base, filename);
30
+ if (!include_base && bs == base) {
32
goto done;
31
+ *pnum = bytes;
33
}
32
+ return 0;
34
} else {
33
+ }
34
+
35
ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
36
if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
37
return ret;
35
--
38
--
36
2.11.0
39
2.26.2
37
40
38
diff view generated by jsdifflib
[Qemu-devel] [PULL 21/21] qemu-img: Avoid setting ret to unused value in img_convert()
[PULL v2 27/28] block/io: fix bdrv_is_allocated_above
1
From: Peter Maydell <peter.maydell@linaro.org>
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
2
2
3
Coverity points out that we assign the return value from
3
bdrv_is_allocated_above wrongly handles short backing files: it reports
4
bdrv_snapshot_load_tmp() to 'ret' in img_convert(), but then
4
after-EOF space as UNALLOCATED which is wrong, as on read the data is
5
never use that variable. (We check for failure by looking
5
generated on the level of short backing file (if all overlays have
6
at local_err instead.) Drop the unused assignment, bringing
6
unallocated areas at that place).
7
the call into line with the following call to
8
bdrv_snapshot_laod_tmp_by_id_or_name().
9
7
10
(Fixes CID 1247240.)
8
Reusing bdrv_common_block_status_above fixes the issue and unifies code
9
path.
11
10
12
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
11
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
13
Message-id: 1486744104-15590-3-git-send-email-peter.maydell@linaro.org
12
Reviewed-by: Eric Blake <eblake@redhat.com>
14
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
13
Reviewed-by: Alberto Garcia <berto@igalia.com>
15
Signed-off-by: Max Reitz <mreitz@redhat.com>
14
Message-id: 20200924194003.22080-5-vsementsov@virtuozzo.com
15
[Fix s/has/have/ as suggested by Eric Blake. Fix s/area/areas/.
16
--Stefan]
17
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
16
---
18
---
17
qemu-img.c | 8 ++++----
19
block/io.c | 43 +++++--------------------------------------
18
1 file changed, 4 insertions(+), 4 deletions(-)
20
1 file changed, 5 insertions(+), 38 deletions(-)
19
21
20
diff --git a/qemu-img.c b/qemu-img.c
22
diff --git a/block/io.c b/block/io.c
21
index XXXXXXX..XXXXXXX 100644
23
index XXXXXXX..XXXXXXX 100644
22
--- a/qemu-img.c
24
--- a/block/io.c
23
+++ b/qemu-img.c
25
+++ b/block/io.c
24
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
26
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
27
* at 'offset + *pnum' may return the same allocation status (in other
28
* words, the result is not necessarily the maximum possible range);
29
* but 'pnum' will only be 0 when end of file is reached.
30
- *
31
*/
32
int bdrv_is_allocated_above(BlockDriverState *top,
33
BlockDriverState *base,
34
bool include_base, int64_t offset,
35
int64_t bytes, int64_t *pnum)
36
{
37
- BlockDriverState *intermediate;
38
- int ret;
39
- int64_t n = bytes;
40
-
41
- assert(base || !include_base);
42
-
43
- intermediate = top;
44
- while (include_base || intermediate != base) {
45
- int64_t pnum_inter;
46
- int64_t size_inter;
47
-
48
- assert(intermediate);
49
- ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);
50
- if (ret < 0) {
51
- return ret;
52
- }
53
- if (ret) {
54
- *pnum = pnum_inter;
55
- return 1;
56
- }
57
-
58
- size_inter = bdrv_getlength(intermediate);
59
- if (size_inter < 0) {
60
- return size_inter;
61
- }
62
- if (n > pnum_inter &&
63
- (intermediate == top || offset + pnum_inter < size_inter)) {
64
- n = pnum_inter;
65
- }
66
-
67
- if (intermediate == base) {
68
- break;
69
- }
70
-
71
- intermediate = bdrv_filter_or_cow_bs(intermediate);
72
+ int ret = bdrv_common_block_status_above(top, base, include_base, false,
73
+ offset, bytes, pnum, NULL, NULL);
74
+ if (ret < 0) {
75
+ return ret;
25
}
76
}
26
77
27
if (sn_opts) {
78
- *pnum = n;
28
- ret = bdrv_snapshot_load_tmp(bs[0],
79
- return 0;
29
- qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
80
+ return !!(ret & BDRV_BLOCK_ALLOCATED);
30
- qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
81
}
31
- &local_err);
82
32
+ bdrv_snapshot_load_tmp(bs[0],
83
int coroutine_fn
33
+ qemu_opt_get(sn_opts, SNAPSHOT_OPT_ID),
34
+ qemu_opt_get(sn_opts, SNAPSHOT_OPT_NAME),
35
+ &local_err);
36
} else if (snapshot_name != NULL) {
37
if (bs_n > 1) {
38
error_report("No support for concatenating multiple snapshot");
39
--
84
--
40
2.11.0
85
2.26.2
41
86
42
diff view generated by jsdifflib
[Qemu-devel] [PULL 12/21] block: bdrv_invalidate_cache: invalidate children first
[PULL v2 28/28] iotests: add commit top->base cases to 274
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
1
From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
2
2
3
Current implementation invalidates firstly parent bds and then its
3
These cases are fixed by previous patches around block_status and
4
children. This leads to the following bug:
4
is_allocated.
5
6
after incoming migration, in bdrv_invalidate_cache_all:
7
1. invalidate parent bds - reopen it with BDRV_O_INACTIVE cleared
8
2. child is not yet invalidated
9
3. parent check that its BDRV_O_INACTIVE is cleared
10
4. parent writes to child
11
5. assert in bdrv_co_pwritev, as BDRV_O_INACTIVE is set for child
12
13
This patch fixes it by just changing invalidate sequence: invalidate
14
children first.
15
5
16
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
6
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
17
Message-id: 20170131112308.54189-1-vsementsov@virtuozzo.com
7
Reviewed-by: Eric Blake <eblake@redhat.com>
18
Reviewed-by: Max Reitz <mreitz@redhat.com>
8
Reviewed-by: Alberto Garcia <berto@igalia.com>
19
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
9
Message-id: 20200924194003.22080-6-vsementsov@virtuozzo.com
20
Signed-off-by: Max Reitz <mreitz@redhat.com>
10
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
21
---
11
---
22
block.c | 11 +++++------
12
tests/qemu-iotests/274 | 20 +++++++++++
23
1 file changed, 5 insertions(+), 6 deletions(-)
13
tests/qemu-iotests/274.out | 68 ++++++++++++++++++++++++++++++++++++++
14
2 files changed, 88 insertions(+)
24
15
25
diff --git a/block.c b/block.c
16
diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
17
index XXXXXXX..XXXXXXX 100755
18
--- a/tests/qemu-iotests/274
19
+++ b/tests/qemu-iotests/274
20
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('base') as base, \
21
iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
22
iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
23
24
+ iotests.log('=== Testing qemu-img commit (top -> base) ===')
25
+
26
+ create_chain()
27
+ iotests.qemu_img_log('commit', '-b', base, top)
28
+ iotests.img_info_log(base)
29
+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
30
+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
31
+
32
+ iotests.log('=== Testing QMP active commit (top -> base) ===')
33
+
34
+ create_chain()
35
+ with create_vm() as vm:
36
+ vm.launch()
37
+ vm.qmp_log('block-commit', device='top', base_node='base',
38
+ job_id='job0', auto_dismiss=False)
39
+ vm.run_job('job0', wait=5)
40
+
41
+ iotests.img_info_log(mid)
42
+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
43
+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
44
45
iotests.log('== Resize tests ==')
46
47
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
26
index XXXXXXX..XXXXXXX 100644
48
index XXXXXXX..XXXXXXX 100644
27
--- a/block.c
49
--- a/tests/qemu-iotests/274.out
28
+++ b/block.c
50
+++ b/tests/qemu-iotests/274.out
29
@@ -XXX,XX +XXX,XX @@ void bdrv_invalidate_cache(BlockDriverState *bs, Error **errp)
51
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
30
if (!(bs->open_flags & BDRV_O_INACTIVE)) {
52
read 1048576/1048576 bytes at offset 1048576
31
return;
53
1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
32
}
54
33
- bs->open_flags &= ~BDRV_O_INACTIVE;
55
+=== Testing qemu-img commit (top -> base) ===
34
56
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
35
- if (bs->drv->bdrv_invalidate_cache) {
57
+
36
- bs->drv->bdrv_invalidate_cache(bs, &local_err);
58
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
37
+ QLIST_FOREACH(child, &bs->children, next) {
59
+
38
+ bdrv_invalidate_cache(child->bs, &local_err);
60
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
39
if (local_err) {
61
+
40
- bs->open_flags |= BDRV_O_INACTIVE;
62
+wrote 2097152/2097152 bytes at offset 0
41
error_propagate(errp, local_err);
63
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
42
return;
64
+
43
}
65
+Image committed.
44
}
66
+
45
67
+image: TEST_IMG
46
- QLIST_FOREACH(child, &bs->children, next) {
68
+file format: IMGFMT
47
- bdrv_invalidate_cache(child->bs, &local_err);
69
+virtual size: 2 MiB (2097152 bytes)
48
+ bs->open_flags &= ~BDRV_O_INACTIVE;
70
+cluster_size: 65536
49
+ if (bs->drv->bdrv_invalidate_cache) {
71
+Format specific information:
50
+ bs->drv->bdrv_invalidate_cache(bs, &local_err);
72
+ compat: 1.1
51
if (local_err) {
73
+ compression type: zlib
52
bs->open_flags |= BDRV_O_INACTIVE;
74
+ lazy refcounts: false
53
error_propagate(errp, local_err);
75
+ refcount bits: 16
76
+ corrupt: false
77
+ extended l2: false
78
+
79
+read 1048576/1048576 bytes at offset 0
80
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
81
+
82
+read 1048576/1048576 bytes at offset 1048576
83
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
84
+
85
+=== Testing QMP active commit (top -> base) ===
86
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
87
+
88
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
89
+
90
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
91
+
92
+wrote 2097152/2097152 bytes at offset 0
93
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
94
+
95
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "base", "device": "top", "job-id": "job0"}}
96
+{"return": {}}
97
+{"execute": "job-complete", "arguments": {"id": "job0"}}
98
+{"return": {}}
99
+{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
100
+{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
101
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
102
+{"return": {}}
103
+image: TEST_IMG
104
+file format: IMGFMT
105
+virtual size: 1 MiB (1048576 bytes)
106
+cluster_size: 65536
107
+backing file: TEST_DIR/PID-base
108
+backing file format: IMGFMT
109
+Format specific information:
110
+ compat: 1.1
111
+ compression type: zlib
112
+ lazy refcounts: false
113
+ refcount bits: 16
114
+ corrupt: false
115
+ extended l2: false
116
+
117
+read 1048576/1048576 bytes at offset 0
118
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
119
+
120
+read 1048576/1048576 bytes at offset 1048576
121
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
122
+
123
== Resize tests ==
124
=== preallocation=off ===
125
Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=6442450944 lazy_refcounts=off refcount_bits=16
54
--
126
--
55
2.11.0
127
2.26.2
56
128
57
diff view generated by jsdifflib

Patchew 2.1-devel-b67e4c2

© 2016 - 2025 Red Hat, Inc.