Make blockdev-reopen stable
v6 cover Make blockdev-reopen stable
This series picks up the remaining patches from Berto's series "[PATCH v4 0/6] Allow changing bs->file on reopen", which are not merged into master yet.
Apart from renaming 'x-blockdev-reopen' into 'blockdev-reopen', the remaining functional change in this series is taking a list of nodes to reopen as an argument so that multiple changes to the graph can be made atomically that would be invalid separately (e.g. due to permission checks on the intermediate state).
It also contains a qcow2 fix for a bug introduced by the part of the series that was already picked up in Vladimir's "[PATCH v6 0/9] Allow changing bs->file on reopen".
v6:
- Changed qcow2 fix to set s->data_file = NULL between .prepare and .commit instead of using a separate bool [Vladimir]
- Coding style fixes [Vladimir]
Alberto Garcia (4):
block: Add bdrv_reopen_queue_free()
block: Support multiple reopening with x-blockdev-reopen
iotests: Test reopening multiple devices at the same time
block: Make blockdev-reopen stable API
Kevin Wolf (2):
qcow2: Fix dangling pointer after reopen for 'file'
block: Acquire AioContexts during bdrv_reopen_multiple()
qapi/block-core.json | 24 +++--- include/block/block.h | 3 + block.c | 71 +++++++++++++---- block/qcow2.c | 29 +++++++ block/replication.c | 7 ++ blockdev.c | 76 ++++++++++-------- qemu-io-cmds.c | 7 +- tests/qemu-iotests/155 | 9 ++- tests/qemu-iotests/165 | 4 +- tests/qemu-iotests/245 | 78 +++++++++++++++---- tests/qemu-iotests/245.out | 4 +- tests/qemu-iotests/248 | 4 +- tests/qemu-iotests/248.out | 2 +- tests/qemu-iotests/296 | 11 ++- tests/qemu-iotests/298 | 4 +- .../tests/remove-bitmap-from-backing | 22 +++--- 16 files changed, 255 insertions(+), 100 deletions(-)
Signature · 1 line
2.31.1
PATCH v6 1/6 qcow2: Fix dangling pointer after reopen for 'file'
Without an external data file, s->data_file is a second pointer with the same value as bs->file. When changing bs->file to a different BdrvChild and freeing the old BdrvChild, s->data_file must also be updated, otherwise it points to freed memory and causes crashes.
This problem was caught by iotests case 245.
--- block/qcow2.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
block/qcow2.c +29 -0
@@ -1926,6 +1926,7 @@ static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)static int qcow2_reopen_prepare (BDRVReopenState *state,BlockReopenQueue *queue,Error **errp) { +BDRVQcow2State *s = state->bs->opaque;Qcow2ReopenState *r;int ret;
@@ -1956,6 +1957,16 @@ static int qcow2_reopen_prepare(BDRVReopenState *state, } } +/* +* Without an external data file, s->data_file points to the same BdrvChild +* as bs->file. It needs to be resynced after reopen because bs->file may +* be changed. We can't use it in the meantime. +*/ +if (!has_data_file (state->bs)) { +assert (s->data_file == state->bs->file); + s->data_file =NULL ; + } +return 0 ; fail:
@@ -1966,7 +1977,16 @@ fail:static void qcow2_reopen_commit (BDRVReopenState *state) { +BDRVQcow2State *s = state->bs->opaque; +qcow2_update_options_commit (state->bs, state->opaque); +if (!s->data_file) { +/* +* If we don't have an external data file, s->data_file was cleared by +* qcow2_reopen_prepare() and needs to be updated. +*/ + s->data_file = state->bs->file; + }g_free (state->opaque); }
@@ -1990,6 +2010,15 @@ static void qcow2_reopen_commit_post(BDRVReopenState *state)static void qcow2_reopen_abort (BDRVReopenState *state) { +BDRVQcow2State *s = state->bs->opaque; + +if (!s->data_file) { +/* +* If we don't have an external data file, s->data_file was cleared by +* qcow2_reopen_prepare() and needs to be restored. +*/ + s->data_file = state->bs->file; + }qcow2_update_options_abort (state->bs, state->opaque);g_free (state->opaque); }
Signature · 1 line
2.31.1
Re: [PATCH v6 1/6] qcow2: Fix dangling pointer after reopen for 'file'
Quoted 5 lines · Kevin Wolf
Without an external data file,
s->data_fileis a second pointer with the same value asbs->file. When changingbs->fileto a different BdrvChild and freeing the old BdrvChild,s->data_filemust also be updated, otherwise it points to freed memory and causes crashes.
Quoted 7 lines
This problem was caught by iotests case 245.
Fixes df2b7086f169239ebad5d150efa29c9bb6d4f820Signed-off-by Kevin Wolf <[email protected]>--- block/qcow2.c | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org
Re: [PATCH v6 1/6] qcow2: Fix dangling pointer after reopen for 'file'
In reply to Kevin WolfQuoted 9 lines · Kevin Wolf
Without an external data file,
s->data_fileis a second pointer with the same value asbs->file. When changingbs->fileto a different BdrvChild and freeing the old BdrvChild,s->data_filemust also be updated, otherwise it points to freed memory and causes crashes.This problem was caught by iotests case 245.
Fixes df2b7086f169239ebad5d150efa29c9bb6d4f820Signed-off-by Kevin Wolf<[email protected]>
Signature · 2 lines
Best regards, Vladimir
PATCH v6 2/6 block: Add bdrv_reopen_queue_free()
In reply to Kevin WolfFrom: Alberto Garcia <[email protected]>
Move the code to free a BlockReopenQueue to a separate function. It will be used in a subsequent patch.
[ kwolf: Also free explicit_options and options, and explicitly
qobject_ref() the value when it continues to be used. This makes future memory leaks less likely. ]
--- include/block/block.h | 1 + block.c | 22 ++++++++++++++++------ 2 files changed, 17 insertions(+), 6 deletions(-)
include/block/block.h +1 -0
@@ -386,6 +386,7 @@ BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,BlockReopenQueue *bdrv_reopen_queue (BlockReopenQueue *bs_queue,BlockDriverState *bs,QDict *options,bool keep_old_opts); +void bdrv_reopen_queue_free (BlockReopenQueue *bs_queue);int bdrv_reopen_multiple (BlockReopenQueue *bs_queue,Error **errp);int bdrv_reopen_set_read_only (BlockDriverState *bs,bool read_only,Error **errp);
block.c +16 -6
@@ -4095,6 +4095,19 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, NULL, 0, keep_old_opts); } +void bdrv_reopen_queue_free (BlockReopenQueue *bs_queue) +{ +if (bs_queue) { +BlockReopenQueueEntry *bs_entry, *next; + QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { +qobject_unref (bs_entry->state.explicit_options); +qobject_unref (bs_entry->state.options); +g_free (bs_entry); + } +g_free (bs_queue); + } +} +/* * Reopen multiple BlockDriverStates atomically & transactionally. *
@@ -4197,15 +4210,10 @@ abort:if (bs_entry->prepared) {bdrv_reopen_abort (&bs_entry->state); } -qobject_unref (bs_entry->state.explicit_options); -qobject_unref (bs_entry->state.options); } cleanup: - QTAILQ_FOREACH_SAFE(bs_entry, bs_queue, entry, next) { -g_free (bs_entry); - } -g_free (bs_queue); +bdrv_reopen_queue_free (bs_queue);return ret; }
@@ -4573,6 +4581,8 @@ static void bdrv_reopen_commit(BDRVReopenState *reopen_state)/* set BDS specific flags now */ qobject_unref (bs->explicit_options);qobject_unref (bs->options); +qobject_ref (reopen_state->explicit_options); +qobject_ref (reopen_state->options); bs->explicit_options = reopen_state->explicit_options; bs->options = reopen_state->options;
Signature · 1 line
2.31.1
PATCH v6 3/6 block: Acquire AioContexts during bdrv_reopen_multiple()
In reply to Kevin WolfAs the BlockReopenQueue can contain nodes in multiple AioContexts, only one of which may be locked when AIO_WAIT_WHILE() can be called, we can't let the caller lock the right contexts. Instead, individually lock the AioContext of a single node when iterating the queue.
Reintroduce bdrv_reopen() as a wrapper for reopening a single node that drains the node and temporarily drops the AioContext lock for bdrv_reopen_multiple().
--- include/block/block.h | 2 ++ block.c | 49 ++++++++++++++++++++++++++++++++++++------- block/replication.c | 7 +++++++ blockdev.c | 5 +++++ qemu-io-cmds.c | 7 +------ 5 files changed, 57 insertions(+), 13 deletions(-)
include/block/block.h +2 -0
@@ -388,6 +388,8 @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue, bool keep_old_opts);void bdrv_reopen_queue_free (BlockReopenQueue *bs_queue);int bdrv_reopen_multiple (BlockReopenQueue *bs_queue,Error **errp); +int bdrv_reopen (BlockDriverState *bs,QDict *opts,bool keep_old_opts, +Error **errp);int bdrv_reopen_set_read_only (BlockDriverState *bs,bool read_only,Error **errp); int bdrv_pwrite_zeroes(BdrvChild *child, int64_t offset,
block.c +42 -7
112 lines not on this page · raw message
block/replication.c +7 -0
@@ -390,7 +390,14 @@ static void reopen_backing_file(BlockDriverState *bs, bool writable, }if (reopen_queue) { +AioContext *ctx =bdrv_get_aio_context (bs); +if (ctx !=qemu_get_aio_context ()) { +aio_context_release (ctx); + }bdrv_reopen_multiple (reopen_queue, errp); +if (ctx !=qemu_get_aio_context ()) { +aio_context_acquire (ctx); + } }bdrv_subtree_drained_end (s->hidden_disk->bs);
blockdev.c +5 -0
@@ -3593,8 +3593,13 @@ void qmp_x_blockdev_reopen(BlockdevOptions *options, Error **errp) ctx =bdrv_get_aio_context (bs);aio_context_acquire (ctx);bdrv_subtree_drained_begin (bs); +aio_context_release (ctx); + queue =bdrv_reopen_queue (NULL , bs, qdict, false);bdrv_reopen_multiple (queue, errp); + + ctx =bdrv_get_aio_context (bs); +aio_context_acquire (ctx);bdrv_subtree_drained_end (bs);aio_context_release (ctx);
qemu-io-cmds.c +1 -6
@@ -2116,8 +2116,6 @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)bool writethrough = !blk_enable_write_cache (blk);bool has_rw_option = false;bool has_cache_option = false; - -BlockReopenQueue *brq;Error *local_err =NULL ;while ((c =getopt (argc, argv,"c:o:rw" )) !=-1 ) {
@@ -2210,10 +2208,7 @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)qdict_put_bool (opts,BDRV_OPT_CACHE_NO_FLUSH , flags &BDRV_O_NO_FLUSH ); } -bdrv_subtree_drained_begin (bs); - brq =bdrv_reopen_queue (NULL , bs, opts, true); -bdrv_reopen_multiple (brq, &local_err); -bdrv_subtree_drained_end (bs); +bdrv_reopen (bs, opts, true, &local_err);if (local_err) {error_report_err (local_err);
Signature · 1 line
2.31.1
PATCH v6 4/6 block: Support multiple reopening with x-blockdev-reopen
In reply to Kevin WolfFrom: Alberto Garcia <[email protected]>
[ kwolf: Fixed AioContext locking ]
--- qapi/block-core.json | 18 +++-- blockdev.c | 81 ++++++++++--------- tests/qemu-iotests/155 | 9 ++- tests/qemu-iotests/165 | 4 +- tests/qemu-iotests/245 | 27 ++++--- tests/qemu-iotests/248 | 2 +- tests/qemu-iotests/248.out | 2 +- tests/qemu-iotests/296 | 9 ++- tests/qemu-iotests/298 | 4 +- .../tests/remove-bitmap-from-backing | 18 +++-- 10 files changed, 99 insertions(+), 75 deletions(-)
qapi/block-core.json +10 -8
@@ -4221,13 +4221,15 @@ ## # @x-blockdev-reopen: # -# Reopens a block device using the given set of options. Any option -# not specified will be reset to its default value regardless of its -# previous status. If an option cannot be changed or a particular +# Reopens one or more block devices using the given set of options. +# Any option not specified will be reset to its default value regardless +# of its previous status. If an option cannot be changed or a particular # driver does not support reopening then the command will return an -# error. +# error. All devices in the list are reopened in one transaction, so +# if one of them fails then the whole transaction is cancelled. # -# The top-level @node-name option (from BlockdevOptions) must be +# The command receives a list of block devices to reopen. For each one +# of them, the top-level @node-name option (from BlockdevOptions) must be # specified and is used to select the block device to be reopened. # Other @node-name options must be either omitted or set to the # current name of the appropriate node. This command won't change any
@@ -4247,8 +4249,8 @@ # # 4) NULL: the current child (if any) is detached. # -# Options (1) and (2) are supported in all cases, but at the moment -# only @backing allows replacing or detaching an existing child. +# Options (1) and (2) are supported in all cases. Option (3) is +# supported for @file and @backing, and option (4) for @backing only. # # Unlike with blockdev-add, the @backing option must always be present # unless the node being reopened does not have a backing file and its
@@ -4258,7 +4260,7 @@ # Since: 4.0 ## { 'command': 'x-blockdev-reopen', - 'data': 'BlockdevOptions', 'boxed': true } + 'data': { 'options': ['BlockdevOptions'] } } ## # @blockdev-del:
blockdev.c +45 -36
96 lines not on this page · raw message
tests/qemu-iotests/155 +6 -3
@@ -261,9 +261,12 @@ class TestBlockdevMirrorReopen(MirrorBaseClass): result = self.vm.qmp('blockdev-add', node_name="backing", driver="null-co") self.assert_qmp(result, 'return', {}) - result = self.vm.qmp('x-blockdev-reopen', node_name="target", - driver=iotests.imgfmt, file="target-file", - backing="backing") + result = self.vm.qmp('x-blockdev-reopen', options=[{ + 'node-name': "target", + 'driver': iotests.imgfmt, + 'file': "target-file", + 'backing': "backing" + }]) self.assert_qmp(result, 'return', {}) class TestBlockdevMirrorReopenIothread(TestBlockdevMirrorReopen):
tests/qemu-iotests/165 +2 -2
@@ -137,7 +137,7 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): assert sha256_1 == self.getSha256() # Reopen to RW - result = self.vm.qmp('x-blockdev-reopen', **{ + result = self.vm.qmp('x-blockdev-reopen', options=[{ 'node-name': 'node0', 'driver': iotests.imgfmt, 'file': {
@@ -145,7 +145,7 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): 'filename': disk }, 'read-only': False - }) + }]) self.assert_qmp(result, 'return', {}) # Check that bitmap is reopened to RW and we can write to it.
tests/qemu-iotests/245 +16 -11
@@ -85,8 +85,18 @@ class TestBlockdevReopen(iotests.QMPTestCase): "Expected output of %d qemu-io commands, found %d" % (found, self.total_io_cmds)) - # Run x-blockdev-reopen with 'opts' but applying 'newopts' - # on top of it. The original 'opts' dict is unmodified + # Run x-blockdev-reopen on a list of block devices + def reopenMultiple(self, opts, errmsg = None): + result = self.vm.qmp('x-blockdev-reopen', conv_keys=False, options=opts) + if errmsg: + self.assert_qmp(result, 'error/class', 'GenericError') + self.assert_qmp(result, 'error/desc', errmsg) + else: + self.assert_qmp(result, 'return', {}) + + # Run x-blockdev-reopen on a single block device (specified by + # 'opts') but applying 'newopts' on top of it. The original 'opts' + # dict is unmodified def reopen(self, opts, newopts = {}, errmsg = None): opts = copy.deepcopy(opts)
@@ -101,12 +111,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): subdict = opts[prefix] subdict[key] = value - result = self.vm.qmp('x-blockdev-reopen', conv_keys = False, **opts) - if errmsg: - self.assert_qmp(result, 'error/class', 'GenericError') - self.assert_qmp(result, 'error/desc', errmsg) - else: - self.assert_qmp(result, 'return', {}) + self.reopenMultiple([ opts ], errmsg) # Run query-named-block-nodes and return the specified entry
@@ -142,10 +147,10 @@ class TestBlockdevReopen(iotests.QMPTestCase): # We cannot change any of these self.reopen(opts, {'node-name': 'not-found'}, "Failed to find node with node-name='not-found'") self.reopen(opts, {'node-name': ''}, "Failed to find node with node-name=''") - self.reopen(opts, {'node-name': None}, "Invalid parameter type for 'node-name', expected: string") + self.reopen(opts, {'node-name': None}, "Invalid parameter type for 'options[0].node-name', expected: string") self.reopen(opts, {'driver': 'raw'}, "Cannot change the option 'driver'") self.reopen(opts, {'driver': ''}, "Invalid parameter ''") - self.reopen(opts, {'driver': None}, "Invalid parameter type for 'driver', expected: string") + self.reopen(opts, {'driver': None}, "Invalid parameter type for 'options[0].driver', expected: string") self.reopen(opts, {'file': 'not-found'}, "Cannot find device='' nor node-name='not-found'") self.reopen(opts, {'file': ''}, "Cannot find device='' nor node-name=''") self.reopen(opts, {'file': None}, "Invalid parameter type for 'file', expected: BlockdevRef")
@@ -154,7 +159,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, {'file.filename': hd_path[1]}, "Cannot change the option 'filename'") self.reopen(opts, {'file.aio': 'native'}, "Cannot change the option 'aio'") self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'") - self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'file.filename', expected: string") + self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'options[0].file.filename', expected: string") # node-name is optional in BlockdevOptions, but x-blockdev-reopen needs it del opts['node-name']
tests/qemu-iotests/248 +1 -1
@@ -63,7 +63,7 @@ vm.get_qmp_events() del blockdev_opts['file']['size'] vm.qmp_log('x-blockdev-reopen', filters=[filter_qmp_testfiles], - **blockdev_opts) + options = [ blockdev_opts ]) vm.qmp_log('block-job-resume', device='drive0') vm.event_wait('JOB_STATUS_CHANGE', timeout=1.0,
tests/qemu-iotests/248.out +1 -1
@@ -2,7 +2,7 @@ {"return": {}} {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "on-target-error": "enospc", "sync": "full", "target": "target"}} {"return": {}} -{"execute": "x-blockdev-reopen", "arguments": {"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}}, "node-name": "target"}} +{"execute": "x-blockdev-reopen", "arguments": {"options": [{"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}}, "node-name": "target"}]}} {"return": {}} {"execute": "block-job-resume", "arguments": {"device": "drive0"}} {"return": {}}
tests/qemu-iotests/296 +6 -3
@@ -120,8 +120,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): command = 'x-blockdev-reopen' if reOpen else 'blockdev-add' - result = vm.qmp(command, ** - { + opts = { 'driver': iotests.imgfmt, 'node-name': id, 'read-only': readOnly,
@@ -131,7 +130,11 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): 'filename': test_img, } } - ) + + if reOpen: + result = vm.qmp(command, options=[opts]) + else: + result = vm.qmp(command, **opts) self.assert_qmp(result, 'return', {})
tests/qemu-iotests/298 +2 -2
@@ -98,7 +98,7 @@ class TestPreallocateFilter(TestPreallocateBase): self.check_big() def test_reopen_opts(self): - result = self.vm.qmp('x-blockdev-reopen', **{ + result = self.vm.qmp('x-blockdev-reopen', options=[{ 'node-name': 'disk', 'driver': iotests.imgfmt, 'file': {
@@ -112,7 +112,7 @@ class TestPreallocateFilter(TestPreallocateBase): 'filename': disk } } - }) + }]) self.assert_qmp(result, 'return', {}) self.vm.hmp_qemu_io('drive0', 'write 0 1M')
tests/qemu-iotests/tests/remove-bitmap-from-backing +10 -8
@@ -41,13 +41,15 @@ log('Trying to remove persistent bitmap from r-o base node, should fail:') vm.qmp_log('block-dirty-bitmap-remove', node='base', name='bitmap0') new_base_opts = { - 'node-name': 'base', - 'driver': 'qcow2', - 'file': { - 'driver': 'file', - 'filename': base - }, - 'read-only': False + 'options': [{ + 'node-name': 'base', + 'driver': 'qcow2', + 'file': { + 'driver': 'file', + 'filename': base + }, + 'read-only': False + }] } # Don't want to bother with filtering qmp_log for reopen command
@@ -58,7 +60,7 @@ if result != {'return': {}}: log('Remove persistent bitmap from base node reopened to RW:') vm.qmp_log('block-dirty-bitmap-remove', node='base', name='bitmap0') -new_base_opts['read-only'] = True +new_base_opts['options'][0]['read-only'] = True result = vm.qmp('x-blockdev-reopen', **new_base_opts) if result != {'return': {}}: log('Failed to reopen: ' + str(result))
Signature · 1 line
2.31.1
PATCH v6 5/6 iotests: Test reopening multiple devices at the same time
In reply to Kevin WolfFrom: Alberto Garcia <[email protected]>
This test swaps the images used by two active block devices.
This is now possible thanks to the new ability to run x-blockdev-reopen on multiple devices at the same time.
--- tests/qemu-iotests/245 | 47 ++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/245.out | 4 ++-- 2 files changed, 49 insertions(+), 2 deletions(-)
tests/qemu-iotests/245 +47 -0
@@ -649,6 +649,53 @@ class TestBlockdevReopen(iotests.QMPTestCase): '-c', 'read -P 0x40 0x40008 1', '-c', 'read -P 0x80 0x40010 1', hd_path[0]) + # Swap the disk images of two active block devices + def test_swap_files(self): + # Add hd0 and hd2 (none of them with backing files) + opts0 = hd_opts(0) + result = self.vm.qmp('blockdev-add', conv_keys = False, **opts0) + self.assert_qmp(result, 'return', {}) + + opts2 = hd_opts(2) + result = self.vm.qmp('blockdev-add', conv_keys = False, **opts2) + self.assert_qmp(result, 'return', {}) + + # Write different data to both block devices + self.run_qemu_io("hd0", "write -P 0xa0 0 1k") + self.run_qemu_io("hd2", "write -P 0xa2 0 1k") + + # Check that the data reads correctly + self.run_qemu_io("hd0", "read -P 0xa0 0 1k") + self.run_qemu_io("hd2", "read -P 0xa2 0 1k") + + # It's not possible to make a block device use an image that + # is already being used by the other device. + self.reopen(opts0, {'file': 'hd2-file'}, + "Permission conflict on node 'hd2-file': permissions " + "'write, resize' are both required by node 'hd2' (uses " + "node 'hd2-file' as 'file' child) and unshared by node " + "'hd0' (uses node 'hd2-file' as 'file' child).") + self.reopen(opts2, {'file': 'hd0-file'}, + "Permission conflict on node 'hd0-file': permissions " + "'write, resize' are both required by node 'hd0' (uses " + "node 'hd0-file' as 'file' child) and unshared by node " + "'hd2' (uses node 'hd0-file' as 'file' child).") + + # But we can swap the images if we reopen both devices at the + # same time + opts0['file'] = 'hd2-file' + opts2['file'] = 'hd0-file' + self.reopenMultiple([opts0, opts2]) + self.run_qemu_io("hd0", "read -P 0xa2 0 1k") + self.run_qemu_io("hd2", "read -P 0xa0 0 1k") + + # And we can of course come back to the original state + opts0['file'] = 'hd0-file' + opts2['file'] = 'hd2-file' + self.reopenMultiple([opts0, opts2]) + self.run_qemu_io("hd0", "read -P 0xa0 0 1k") + self.run_qemu_io("hd2", "read -P 0xa2 0 1k") + # Misc reopen tests with different block drivers @iotests.skip_if_unsupported(['quorum', 'throttle']) def test_misc_drivers(self):
tests/qemu-iotests/245.out +2 -2
@@ -17,8 +17,8 @@ read 1/1 bytes at offset 262152 read 1/1 bytes at offset 262160 1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) -.............. +............... ---------------------------------------------------------------------- -Ran 24 tests +Ran 25 tests OK
Signature · 1 line
2.31.1
PATCH v6 6/6 block: Make blockdev-reopen stable API
In reply to Kevin WolfFrom: Alberto Garcia <[email protected]>
This patch drops the 'x-' prefix from x-blockdev-reopen.
--- qapi/block-core.json | 6 +++--- blockdev.c | 2 +- tests/qemu-iotests/155 | 2 +- tests/qemu-iotests/165 | 2 +- tests/qemu-iotests/245 | 10 +++++----- tests/qemu-iotests/248 | 2 +- tests/qemu-iotests/248.out | 2 +- tests/qemu-iotests/296 | 2 +- tests/qemu-iotests/298 | 2 +- tests/qemu-iotests/tests/remove-bitmap-from-backing | 4 ++-- 10 files changed, 17 insertions(+), 17 deletions(-)
qapi/block-core.json +3 -3
@@ -4219,7 +4219,7 @@ { 'command': 'blockdev-add', 'data': 'BlockdevOptions', 'boxed': true } ## -# @x-blockdev-reopen: +# @blockdev-reopen: # # Reopens one or more block devices using the given set of options. # Any option not specified will be reset to its default value regardless
@@ -4257,9 +4257,9 @@ # image does not have a default backing file name as part of its # metadata. # -# Since: 4.0 +# Since: 6.0 ## -{ 'command': 'x-blockdev-reopen', +{ 'command': 'blockdev-reopen', 'data': { 'options': ['BlockdevOptions'] } } ##
blockdev.c +1 -1
@@ -3560,7 +3560,7 @@ fail:visit_free (v); } -void qmp_x_blockdev_reopen (BlockdevOptionsList *reopen_list,Error **errp) +void qmp_blockdev_reopen (BlockdevOptionsList *reopen_list,Error **errp) {BlockReopenQueue *queue =NULL ;GSList *drained =NULL ;
tests/qemu-iotests/155 +1 -1
@@ -261,7 +261,7 @@ class TestBlockdevMirrorReopen(MirrorBaseClass): result = self.vm.qmp('blockdev-add', node_name="backing", driver="null-co") self.assert_qmp(result, 'return', {}) - result = self.vm.qmp('x-blockdev-reopen', options=[{ + result = self.vm.qmp('blockdev-reopen', options=[{ 'node-name': "target", 'driver': iotests.imgfmt, 'file': "target-file",
tests/qemu-iotests/165 +1 -1
@@ -137,7 +137,7 @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase): assert sha256_1 == self.getSha256() # Reopen to RW - result = self.vm.qmp('x-blockdev-reopen', options=[{ + result = self.vm.qmp('blockdev-reopen', options=[{ 'node-name': 'node0', 'driver': iotests.imgfmt, 'file': {
tests/qemu-iotests/245 +5 -5
@@ -1,7 +1,7 @@ #!/usr/bin/env python3 # group: rw # -# Test cases for the QMP 'x-blockdev-reopen' command +# Test cases for the QMP 'blockdev-reopen' command # # Copyright (C) 2018-2019 Igalia, S.L. # Author: Alberto Garcia <[email protected]>
@@ -85,16 +85,16 @@ class TestBlockdevReopen(iotests.QMPTestCase): "Expected output of %d qemu-io commands, found %d" % (found, self.total_io_cmds)) - # Run x-blockdev-reopen on a list of block devices + # Run blockdev-reopen on a list of block devices def reopenMultiple(self, opts, errmsg = None): - result = self.vm.qmp('x-blockdev-reopen', conv_keys=False, options=opts) + result = self.vm.qmp('blockdev-reopen', conv_keys=False, options=opts) if errmsg: self.assert_qmp(result, 'error/class', 'GenericError') self.assert_qmp(result, 'error/desc', errmsg) else: self.assert_qmp(result, 'return', {}) - # Run x-blockdev-reopen on a single block device (specified by + # Run blockdev-reopen on a single block device (specified by # 'opts') but applying 'newopts' on top of it. The original 'opts' # dict is unmodified def reopen(self, opts, newopts = {}, errmsg = None):
@@ -161,7 +161,7 @@ class TestBlockdevReopen(iotests.QMPTestCase): self.reopen(opts, {'file.locking': 'off'}, "Cannot change the option 'locking'") self.reopen(opts, {'file.filename': None}, "Invalid parameter type for 'options[0].file.filename', expected: string") - # node-name is optional in BlockdevOptions, but x-blockdev-reopen needs it + # node-name is optional in BlockdevOptions, but blockdev-reopen needs it del opts['node-name'] self.reopen(opts, {}, "node-name not specified")
tests/qemu-iotests/248 +1 -1
@@ -62,7 +62,7 @@ vm.event_wait('JOB_STATUS_CHANGE', timeout=3.0, vm.get_qmp_events() del blockdev_opts['file']['size'] -vm.qmp_log('x-blockdev-reopen', filters=[filter_qmp_testfiles], +vm.qmp_log('blockdev-reopen', filters=[filter_qmp_testfiles], options = [ blockdev_opts ]) vm.qmp_log('block-job-resume', device='drive0')
tests/qemu-iotests/248.out +1 -1
@@ -2,7 +2,7 @@ {"return": {}} {"execute": "blockdev-mirror", "arguments": {"device": "drive0", "on-target-error": "enospc", "sync": "full", "target": "target"}} {"return": {}} -{"execute": "x-blockdev-reopen", "arguments": {"options": [{"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}}, "node-name": "target"}]}} +{"execute": "blockdev-reopen", "arguments": {"options": [{"driver": "qcow2", "file": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-target"}}, "node-name": "target"}]}} {"return": {}} {"execute": "block-job-resume", "arguments": {"device": "drive0"}} {"return": {}}
tests/qemu-iotests/296 +1 -1
@@ -118,7 +118,7 @@ class EncryptionSetupTestCase(iotests.QMPTestCase): def openImageQmp(self, vm, id, file, secret, readOnly = False, reOpen = False): - command = 'x-blockdev-reopen' if reOpen else 'blockdev-add' + command = 'blockdev-reopen' if reOpen else 'blockdev-add' opts = { 'driver': iotests.imgfmt,
tests/qemu-iotests/298 +1 -1
@@ -98,7 +98,7 @@ class TestPreallocateFilter(TestPreallocateBase): self.check_big() def test_reopen_opts(self): - result = self.vm.qmp('x-blockdev-reopen', options=[{ + result = self.vm.qmp('blockdev-reopen', options=[{ 'node-name': 'disk', 'driver': iotests.imgfmt, 'file': {
tests/qemu-iotests/tests/remove-bitmap-from-backing +2 -2
@@ -53,7 +53,7 @@ new_base_opts = { } # Don't want to bother with filtering qmp_log for reopen command -result = vm.qmp('x-blockdev-reopen', **new_base_opts) +result = vm.qmp('blockdev-reopen', **new_base_opts) if result != {'return': {}}: log('Failed to reopen: ' + str(result))
@@ -61,7 +61,7 @@ log('Remove persistent bitmap from base node reopened to RW:') vm.qmp_log('block-dirty-bitmap-remove', node='base', name='bitmap0') new_base_opts['options'][0]['read-only'] = True -result = vm.qmp('x-blockdev-reopen', **new_base_opts) +result = vm.qmp('blockdev-reopen', **new_base_opts) if result != {'return': {}}: log('Failed to reopen: ' + str(result))
Signature · 1 line
2.31.1
Re: [PATCH v6 6/6] block: Make blockdev-reopen stable API
Quoted 20 lines · Kevin Wolf
From: Alberto Garcia <[email protected]>
This patch drops the 'x-' prefix from x-blockdev-reopen.
Signed-off-by Alberto Garcia <[email protected]>Signed-off-by Kevin Wolf <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>---
+++
b/qapi/block-core.jsonqapi/block-core.json +1
-1@@ -4219,7 +4219,7 @@ { 'command': 'blockdev-add', 'data': 'BlockdevOptions', 'boxed': true } ## -# @x-blockdev-reopen: +# @blockdev-reopen: # # Reopens one or more block devices using the given set of options. # Any option not specified will be reset to its default value regardless
qapi/block-core.json line 4260
Quoted 5 lines
qapi/block-core.json +1
-1@@ -4257,9 +4257,9 @@ # image does not have a default backing file name as part of its # metadata. # -# Since: 4.0 +# Since: 6.0
6.1 now
And yay! We are finally getting here!
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3266 Virtualization: qemu.org | libvirt.org