block: publish backup-top filter
Subsystems (2)
v8 cover block: publish backup-top filter
Hi all!
v8:
06: add Hanna's r-b
07: keep is_fleecing detection in _new() function
08,17,18: add Hanna's r-b
19: wording, s/6.1/6.2/, add Markus's a-b
25: new
29: add John's r-b
34: new
Patches without r-b: 07, 25, 34
Vladimir Sementsov-Ogievskiy (34):
block: introduce bdrv_replace_child_bs()
block: introduce blk_replace_bs
qdev-properties: PropertyInfo: add realized_set_allowed field
qdev: allow setting drive property for realized device
block: rename backup-top to copy-before-write
block-copy: move detecting fleecing scheme to block-copy block/block-copy: introduce block_copy_set_copy_opts() block/backup: set copy_range and compress after filter insertion block/backup: move cluster size calculation to block-copy block/copy-before-write: relax permission requirements when no parents block/copy-before-write: drop extra bdrv_unref on failure path block/copy-before-write: use file child instead of backing block/copy-before-write: bdrv_cbw_append(): replace child at last block/copy-before-write: introduce cbw_init() block/copy-before-write: cbw_init(): rename variables block/copy-before-write: cbw_init(): use file child after attaching block/copy-before-write: bdrv_cbw_append(): drop unused compress arg block/copy-before-write: cbw_init(): use options block/copy-before-write: initialize block-copy bitmap block/block-copy: make setting progress optional block/copy-before-write: make public block driver
qapi: publish copy-before-write filter python/qemu/machine.py: refactor _qemu_args() python/qemu/machine: QEMUMachine: improve qmp() method python:QEMUMachine: template typing for self returning methods iotests/222: fix pylint and mypy complains
iotests/222: constantly use single quotes for strings
iotests: move 222 to tests/image-fleecing
iotests.py: hmp_qemu_io: support qdev iotests/image-fleecing: proper source device iotests/image-fleecing: rename tgt_node iotests/image-fleecing: prepare for adding new test-case iotests/image-fleecing: add test-case for copy-before-write filter block/block-copy: block_copy_state_new(): drop extra arguments
qapi/block-core.json | 25 +-
block/{backup-top.h => copy-before-write.h} | 25 +-
include/block/block-copy.h | 6 +-
include/block/block.h | 2 +
include/hw/qdev-properties.h | 1 +
include/sysemu/block-backend.h | 1 +
block.c | 31 +++
block/backup-top.c | 253 -------------------
block/backup.c | 116 ++-------
block/block-backend.c | 8 +
block/block-copy.c | 135 ++++++++---
block/copy-before-write.c | 256 ++++++++++++++++++++
hw/core/qdev-properties-system.c | 43 +++-
hw/core/qdev-properties.c | 6 +-
MAINTAINERS | 4 +-
block/meson.build | 2 +-
python/qemu/machine/machine.py | 40 +--
tests/qemu-iotests/222 | 159 ------------
tests/qemu-iotests/222.out | 67 -----
tests/qemu-iotests/283 | 35 ++-
tests/qemu-iotests/283.out | 4 +-
tests/qemu-iotests/297 | 2 +-
tests/qemu-iotests/iotests.py | 5 +-
tests/qemu-iotests/tests/image-fleecing | 192 +++++++++++++++
tests/qemu-iotests/tests/image-fleecing.out | 139 +++++++++++
25 files changed, 885 insertions(+), 672 deletions(-)
rename block/{backup-top.h => copy-before-write.h} (56%)
delete mode 100644 block/backup-top.c
create mode 100644 block/copy-before-write.c
delete mode 100755 tests/qemu-iotests/222
delete mode 100644 tests/qemu-iotests/222.out
create mode 100755 tests/qemu-iotests/tests/image-fleecing
create mode 100644 tests/qemu-iotests/tests/image-fleecing.outSignature · 1 line
2.29.2
PATCH v8 1/34 block: introduce bdrv_replace_child_bs()
Add function to transactionally replace bs inside BdrvChild.
--- include/block/block.h | 2 ++ block.c | 31 +++++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+)
include/block/block.h +2 -0
@@ -361,6 +361,8 @@ int bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top, Error **errp);int bdrv_replace_node (BlockDriverState *from,BlockDriverState *to,Error **errp); +int bdrv_replace_child_bs (BdrvChild *child,BlockDriverState *new_bs, +Error **errp);BlockDriverState *bdrv_insert_node (BlockDriverState *bs,QDict *node_options,int flags,Error **errp);int bdrv_drop_filter (BlockDriverState *bs,Error **errp);
block.c +31 -0
@@ -5048,6 +5048,37 @@ out:return ret; } +/* Not for empty child */ +int bdrv_replace_child_bs (BdrvChild *child,BlockDriverState *new_bs, +Error **errp) +{ +int ret; +Transaction *tran =tran_new (); +g_autoptr (GHashTable) found =NULL ; +g_autoptr (GSList) refresh_list =NULL ; +BlockDriverState *old_bs = child->bs; + +bdrv_ref (old_bs); +bdrv_drained_begin (old_bs); +bdrv_drained_begin (new_bs); + +bdrv_replace_child_tran (child, new_bs, tran); + + found =g_hash_table_new (NULL ,NULL ); + refresh_list =bdrv_topological_dfs (refresh_list, found, old_bs); + refresh_list =bdrv_topological_dfs (refresh_list, found, new_bs); + + ret =bdrv_list_refresh_perms (refresh_list,NULL , tran, errp); + +tran_finalize (tran, ret); + +bdrv_drained_end (old_bs); +bdrv_drained_end (new_bs); +bdrv_unref (old_bs); + +return ret; +} +static void bdrv_delete (BlockDriverState *bs) {assert (bdrv_op_blocker_is_empty (bs));
Signature · 1 line
2.29.2
PATCH v8 2/34 block: introduce blk_replace_bs
In reply to Vladimir Sementsov-OgievskiyAdd function to change bs inside blk.
--- include/sysemu/block-backend.h | 1 + block/block-backend.c | 8 ++++++++ 2 files changed, 9 insertions(+)
include/sysemu/block-backend.h +1 -0
@@ -102,6 +102,7 @@ BlockBackend *blk_by_public(BlockBackendPublic *public);BlockDriverState *blk_bs (BlockBackend *blk);void blk_remove_bs (BlockBackend *blk);int blk_insert_bs (BlockBackend *blk,BlockDriverState *bs,Error **errp); +int blk_replace_bs (BlockBackend *blk,BlockDriverState *new_bs,Error **errp);bool bdrv_has_blk (BlockDriverState *bs);bool bdrv_is_root_node (BlockDriverState *bs); int blk_set_perm(BlockBackend *blk, uint64_t perm, uint64_t shared_perm,
block/block-backend.c +8 -0
@@ -869,6 +869,14 @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)return 0 ; } +/* +* Change BlockDriverState associated with @blk. +*/ +int blk_replace_bs (BlockBackend *blk,BlockDriverState *new_bs,Error **errp) +{ +return bdrv_replace_child_bs (blk->root, new_bs, errp); +} +/* * Sets the permission bitmasks that the user of the BlockBackend needs. */
Signature · 1 line
2.29.2
PATCH v8 3/34 qdev-properties: PropertyInfo: add realized_set_allowed field
In reply to Vladimir Sementsov-OgievskiyAdd field, so property can declare support for setting the property when device is realized. To be used in the following commit.
--- include/hw/qdev-properties.h | 1 + hw/core/qdev-properties.c | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-)
include/hw/qdev-properties.h +1 -0
@@ -32,6 +32,7 @@ struct PropertyInfo {const char *name;const char *description;const QEnumLookup *enum_table; +bool realized_set_allowed;/* allow setting property on realized device */ int (*print)(Object *obj,Property *prop,char *dest,size_t len);void (*set_default_value)(ObjectProperty *op,const Property *prop); ObjectProperty *(*create)(ObjectClass *oc, const char *name,
hw/core/qdev-properties.c +3 -3
@@ -26,11 +26,11 @@ void qdev_prop_set_after_realize(DeviceState *dev, const char *name,/* returns: true if property is allowed to be set, false otherwise */ static bool qdev_prop_allow_set (Object *obj,const char *name, -Error **errp) +const PropertyInfo *info,Error **errp) {DeviceState *dev =DEVICE (obj); -if (dev->realized) { +if (dev->realized && !info->realized_set_allowed) {qdev_prop_set_after_realize (dev, name, errp);return false; }
@@ -79,7 +79,7 @@ static void field_prop_set(Object *obj, Visitor *v, const char *name, {Property *prop = opaque; -if (!qdev_prop_allow_set (obj, name, errp)) { +if (!qdev_prop_allow_set (obj, name, prop->info, errp)) {return ; }
Signature · 1 line
2.29.2
PATCH v8 4/34 qdev: allow setting drive property for realized device
In reply to Vladimir Sementsov-OgievskiyWe need an ability to insert filters above top block node, attached to block device. It can't be achieved with blockdev-reopen command. So, we want do it with help of qom-set.
Intended usage:
Assume there is a node A that is attached to some guest device.
1. blockdev-add to create a filter node B that has A as its child.
2. qom-set to change the node attached to the guest device’s BlockBackend from A to B.
--- hw/core/qdev-properties-system.c | 43 +++++++++++++++++++++++--------- 1 file changed, 31 insertions(+), 12 deletions(-)
hw/core/qdev-properties-system.c +31 -12
@@ -36,11 +36,11 @@static bool check_prop_still_unset (Object *obj,const char *name,const void *old_val,const char *new_val, -Error **errp) +bool allow_override,Error **errp) {const GlobalProperty *prop =qdev_find_global_prop (obj, name); -if (!old_val) { +if (!old_val || (!prop && allow_override)) {return true; }
@@ -93,16 +93,34 @@ static void set_drive_helper(Object *obj, Visitor *v, const char *name,BlockBackend *blk;bool blk_created = false;int ret; +BlockDriverState *bs; +AioContext *ctx;if (!visit_type_str (v, name, &str, errp)) {return ; } -/* -* TODO Should this really be an error? If no, the old value -* needs to be released before we store the new one. -*/ -if (!check_prop_still_unset (obj, name, *ptr, str, errp)) { +if (!check_prop_still_unset (obj, name, *ptr, str, true, errp)) { +return ; + } + +if (*ptr) { +/* BlockBackend alread exists. So, we want to change attached node */ + blk = *ptr; + ctx =blk_get_aio_context (blk); + bs =bdrv_lookup_bs (NULL , str, errp); +if (!bs) { +return ; + } + +if (ctx !=bdrv_get_aio_context (bs)) { +error_setg (errp,"Different aio context is not supported for new " +"node" ); + } + +aio_context_acquire (ctx); +blk_replace_bs (blk, bs, errp); +aio_context_release (ctx);return ; }
@@ -114,7 +132,7 @@ static void set_drive_helper(Object *obj, Visitor *v, const char *name, blk =blk_by_name (str);if (!blk) { -BlockDriverState *bs =bdrv_lookup_bs (NULL , str,NULL ); + bs =bdrv_lookup_bs (NULL , str,NULL );if (bs) {/* * If the device supports iothreads, it will make sure to move the
@@ -123,8 +141,7 @@ static void set_drive_helper(Object *obj, Visitor *v, const char *name,* aware of iothreads require their BlockBackends to be in the main * AioContext. */ -AioContext *ctx = iothread ?bdrv_get_aio_context (bs) : -qemu_get_aio_context (); + ctx = iothread ?bdrv_get_aio_context (bs) :qemu_get_aio_context (); blk =blk_new (ctx,0 ,BLK_PERM_ALL ); blk_created = true;
@@ -196,6 +213,7 @@ static void release_drive(Object *obj, const char *name, void *opaque)const PropertyInfo qdev_prop_drive = { .name ="str" , .description ="Node name or ID of a block device to use as a backend" , + .realized_set_allowed = true, .get = get_drive, .set = set_drive, .release = release_drive,
@@ -204,6 +222,7 @@ const PropertyInfo qdev_prop_drive = {const PropertyInfo qdev_prop_drive_iothread = { .name ="str" , .description ="Node name or ID of a block device to use as a backend" , + .realized_set_allowed = true, .get = get_drive, .set = set_drive_iothread, .release = release_drive,
@@ -238,7 +257,7 @@ static void set_chr(Object *obj, Visitor *v, const char *name, void *opaque,* TODO Should this really be an error? If no, the old value * needs to be released before we store the new one. */ -if (!check_prop_still_unset (obj, name, be->chr, str, errp)) { +if (!check_prop_still_unset (obj, name, be->chr, str, false, errp)) {return ; }
@@ -408,7 +427,7 @@ static void set_netdev(Object *obj, Visitor *v, const char *name,* TODO Should this really be an error? If no, the old value * needs to be released before we store the new one. */ -if (!check_prop_still_unset (obj, name, ncs[i], str, errp)) { +if (!check_prop_still_unset (obj, name, ncs[i], str, false, errp)) { goto out; }
Signature · 1 line
2.29.2
PATCH v8 5/34 block: rename backup-top to copy-before-write
In reply to Vladimir Sementsov-OgievskiyWe are going to convert backup_top to full featured public filter, which can be used in separate of backup job. Start from renaming from "how it used" to "what it does".
While updating comments in 283 iotest, drop and rephrase also things about ".active", as this field is now dropped, and filter doesn't have "inactive" mode.
Note that this change may be considered as incompatible interface change, as backup-top filter format name was visible through query-block and query-named-block-nodes.
Still, consider the following reasoning:
1. backup-top was never documented, so if someone depends on format name (for driver that can't be used other than it is automatically inserted on backup job start), it's a kind of "undocumented feature use". So I think we are free to change it.
2. There is a hope, that there is no such users: it's a lot more native to give a good node-name to backup-top filter if need to operate with it somehow, and don't touch format name.
3. Another "incompatible" change in further commit would be moving copy-before-write filter from using backing child to file child. And this is even more reasonable than renaming: for now all public filters are file-child based.
So, it's a risky change, but risk seems small and good interface worth it.
---
block/{backup-top.h => copy-before-write.h} | 28 +++---
block/backup.c | 22 ++---
block/{backup-top.c => copy-before-write.c} | 100 ++++++++++----------
MAINTAINERS | 4 +-
block/meson.build | 2 +-
tests/qemu-iotests/283 | 35 +++----
tests/qemu-iotests/283.out | 4 +-
7 files changed, 95 insertions(+), 100 deletions(-)
rename block/{backup-top.h => copy-before-write.h} (56%)
rename block/{backup-top.c => copy-before-write.c} (62%)block/copy-before-write.h renamed from block/backup-top.h +14 -14
@@ -1,10 +1,10 @@/* -* backup-top filter driver +* copy-before-write filter driver * * The driver performs Copy-Before-Write (CBW) operation: it is injected above * some node, and before each write it copies _old_ data to the target node. * -* Copyright (c) 2018-2019 Virtuozzo International GmbH. +* Copyright (c) 2018-2021 Virtuozzo International GmbH. * * Author: * Sementsov-Ogievskiy Vladimir <[email protected]>
@@ -23,20 +23,20 @@* along with this program. If not, see <http://www.gnu.org/licenses/>. */ -#ifndef BACKUP_TOP_H -#define BACKUP_TOP_H +#ifndef COPY_BEFORE_WRITE_H +#define COPY_BEFORE_WRITE_H #include "block/block_int.h" #include "block/block-copy.h" -BlockDriverState *bdrv_backup_top_append (BlockDriverState *source, -BlockDriverState *target, -const char *filter_node_name, -uint64_t cluster_size, -BackupPerf *perf, -BdrvRequestFlags write_flags, -BlockCopyState **bcs, -Error **errp); -void bdrv_backup_top_drop (BlockDriverState *bs); +BlockDriverState *bdrv_cbw_append (BlockDriverState *source, +BlockDriverState *target, +const char *filter_node_name, +uint64_t cluster_size, +BackupPerf *perf, +BdrvRequestFlags write_flags, +BlockCopyState **bcs, +Error **errp); +void bdrv_cbw_drop (BlockDriverState *bs); -#endif /* BACKUP_TOP_H */ +#endif /* COPY_BEFORE_WRITE_H */
block/backup.c +11 -11
@@ -27,13 +27,13 @@#include "qemu/bitmap.h" #include "qemu/error-report.h" -#include "block/backup-top.h" +#include "block/copy-before-write.h" #define BACKUP_CLUSTER_SIZE_DEFAULT (1 << 16) typedef struct BackupBlockJob { BlockJob common; - BlockDriverState *backup_top; + BlockDriverState *cbw; BlockDriverState *source_bs; BlockDriverState *target_bs;
@@ -104,7 +104,7 @@ static void backup_clean(Job *job) {BackupBlockJob *s =container_of (job, BackupBlockJob, common.job);block_job_remove_all_bdrv (&s->common); -bdrv_backup_top_drop (s->backup_top); +bdrv_cbw_drop (s->cbw); }void backup_do_checkpoint (BlockJob *job,Error **errp)
@@ -408,7 +408,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,BackupBlockJob *job =NULL ;int64_t cluster_size;BdrvRequestFlags write_flags; -BlockDriverState *backup_top =NULL ; +BlockDriverState *cbw =NULL ;BlockCopyState *bcs =NULL ;assert (bs);
@@ -521,22 +521,22 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, write_flags = (bdrv_chain_contains (target, bs) ?BDRV_REQ_SERIALISING :0 ) | (compress ?BDRV_REQ_WRITE_COMPRESSED :0 ), - backup_top =bdrv_backup_top_append (bs, target, filter_node_name, + cbw =bdrv_cbw_append (bs, target, filter_node_name, cluster_size, perf, write_flags, &bcs, errp); -if (!backup_top) { +if (!cbw) { goto error; }/* job->len is fixed, so we can't allow resize */ - job =block_job_create (job_id, &backup_job_driver, txn, backup_top, + job =block_job_create (job_id, &backup_job_driver, txn, cbw,0 ,BLK_PERM_ALL , speed, creation_flags, cb, opaque, errp);if (!job) { goto error; } - job->backup_top = backup_top; + job->cbw = cbw; job->source_bs = bs; job->target_bs = target; job->on_source_error = on_source_error;
@@ -552,7 +552,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,block_copy_set_progress_meter (bcs, &job->common.job.progress);block_copy_set_speed (bcs, speed); -/* Required permissions are already taken by backup-top target */ +/* Required permissions are taken by copy-before-write filter target */ block_job_add_bdrv (&job->common,"target" , target,0 ,BLK_PERM_ALL , &error_abort);
@@ -562,8 +562,8 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,if (sync_bitmap) {bdrv_reclaim_dirty_bitmap (sync_bitmap,NULL ); } -if (backup_top) { -bdrv_backup_top_drop (backup_top); +if (cbw) { +bdrv_cbw_drop (cbw); }return NULL ;
block/copy-before-write.c renamed from block/backup-top.c +50 -50
206 lines not on this page · raw message
MAINTAINERS +2 -2
@@ -2337,8 +2337,8 @@ F: block/mirror.c F: qapi/job.json F: block/block-copy.c F: include/block/block-copy.c -F: block/backup-top.h -F: block/backup-top.c +F: block/copy-before-write.h +F: block/copy-before-write.c F: include/block/aio_task.h F: block/aio_task.c F: util/qemu-co-shared-resource.c
block/meson.build +1 -1
@@ -4,7 +4,7 @@ block_ss.add(files( 'aio_task.c', 'amend.c', 'backup.c', - 'backup-top.c', + 'copy-before-write.c', 'blkdebug.c', 'blklogwrites.c', 'blkverify.c',
tests/qemu-iotests/283 +15 -20
@@ -1,7 +1,7 @@ #!/usr/bin/env python3 # group: auto quick # -# Test for backup-top filter permission activation failure +# Test for copy-before-write filter permission conflict # # Copyright (c) 2019 Virtuozzo International GmbH. #
@@ -31,13 +31,13 @@ size = 1024 * 1024 """ Test description When performing a backup, all writes on the source subtree must go through the -backup-top filter so it can copy all data to the target before it is changed. -backup-top filter is appended above source node, to achieve this thing, so all -parents of source node are handled. A configuration with side parents of source -sub-tree with write permission is unsupported (we'd have append several -backup-top filter like nodes to handle such parents). The test create an -example of such configuration and checks that a backup is then not allowed -(blockdev-backup command should fail). +copy-before-write filter so it can copy all data to the target before it is +changed. copy-before-write filter is appended above source node, to achieve +this thing, so all parents of source node are handled. A configuration with +side parents of source sub-tree with write permission is unsupported (we'd have +append several copy-before-write filter like nodes to handle such parents). The +test create an example of such configuration and checks that a backup is then +not allowed (blockdev-backup command should fail). The configuration:
@@ -57,11 +57,10 @@ The configuration: │ base │ ◀──────────── │ other │ └─────────────┘ └───────┘ -On activation (see .active field of backup-top state in block/backup-top.c), -backup-top is going to unshare write permission on its source child. Write -unsharing will be propagated to the "source->base" link and will conflict with -other node write permission. So permission update will fail and backup job will -not be started. +copy-before-write filter wants to unshare write permission on its source child. +Write unsharing will be propagated to the "source->base" link and will conflict +with other node write permission. So permission update will fail and backup job +will not be started. Note, that the only thing which prevents backup of running on such configuration is default permission propagation scheme. It may be altered by
@@ -99,13 +98,9 @@ vm.qmp_log('blockdev-backup', sync='full', device='source', target='target') vm.shutdown() -print('\n=== backup-top should be gone after job-finalize ===\n') +print('\n=== copy-before-write filter should be gone after job-finalize ===\n') -# Check that the backup-top node is gone after job-finalize. -# -# During finalization, the node becomes inactive and can no longer -# function. If it is still present, new parents might be attached, and -# there would be no meaningful way to handle their I/O requests. +# Check that the copy-before-write node is gone after job-finalize. vm = iotests.VM() vm.launch()
@@ -131,7 +126,7 @@ vm.qmp_log('blockdev-backup', vm.event_wait('BLOCK_JOB_PENDING', 5.0) -# The backup-top filter should still be present prior to finalization +# The copy-before-write filter should still be present prior to finalization assert vm.node_info('backup-filter') is not None vm.qmp_log('job-finalize', id='backup')
tests/qemu-iotests/283.out +2 -2
@@ -5,9 +5,9 @@ {"execute": "blockdev-add", "arguments": {"driver": "blkdebug", "image": "base", "node-name": "other", "take-child-perms": ["write"]}} {"return": {}} {"execute": "blockdev-backup", "arguments": {"device": "source", "sync": "full", "target": "target"}} -{"error": {"class": "GenericError", "desc": "Cannot append backup-top filter: Permission conflict on node 'base': permissions 'write' are both required by node 'other' (uses node 'base' as 'image' child) and unshared by node 'source' (uses node 'base' as 'image' child)."}} +{"error": {"class": "GenericError", "desc": "Cannot append copy-before-write filter: Permission conflict on node 'base': permissions 'write' are both required by node 'other' (uses node 'base' as 'image' child) and unshared by node 'source' (uses node 'base' as 'image' child)."}} -=== backup-top should be gone after job-finalize === +=== copy-before-write filter should be gone after job-finalize === {"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "source"}} {"return": {}}
Signature · 1 line
2.29.2
PATCH v8 6/34 block-copy: move detecting fleecing scheme to block-copy
In reply to Vladimir Sementsov-OgievskiyWe want to simplify initialization interface of copy-before-write filter as we are going to make it public. So, let's detect fleecing scheme exactly in block-copy code, to not pass this information through extra levels.
Why not just set BDRV_REQ_SERIALISING unconditionally: because we are going to implement new more efficient fleecing scheme which will not rely on backing feature.
--- block/copy-before-write.h | 2 +- include/block/block-copy.h | 3 +-- block/backup.c | 21 +-------------------- block/block-copy.c | 24 +++++++++++++++++++++--- block/copy-before-write.c | 4 ++-- 5 files changed, 26 insertions(+), 28 deletions(-)
block/copy-before-write.h +1 -1
@@ -34,7 +34,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,const char *filter_node_name, uint64_t cluster_size, BackupPerf *perf, - BdrvRequestFlags write_flags, + bool compress, BlockCopyState **bcs, Error **errp);void bdrv_cbw_drop (BlockDriverState *bs);
include/block/block-copy.h +1 -2
@@ -26,8 +26,7 @@ typedef struct BlockCopyCallState BlockCopyCallState;BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target,int64_t cluster_size,bool use_copy_range, -BdrvRequestFlags write_flags, -Error **errp); +bool compress,Error **errp);void block_copy_set_progress_meter (BlockCopyState *s,ProgressMeter *pm);
block/backup.c +1 -20
@@ -407,7 +407,6 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,int64_t len, target_len;BackupBlockJob *job =NULL ;int64_t cluster_size; -BdrvRequestFlags write_flags;BlockDriverState *cbw =NULL ;BlockCopyState *bcs =NULL ;
@@ -504,26 +503,8 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, goto error; } -/* -* If source is in backing chain of target assume that target is going to be -* used for "image fleecing", i.e. it should represent a kind of snapshot of -* source at backup-start point in time. And target is going to be read by -* somebody (for example, used as NBD export) during backup job. -* -* In this case, we need to add BDRV_REQ_SERIALISING write flag to avoid -* intersection of backup writes and third party reads from target, -* otherwise reading from target we may occasionally read already updated by -* guest data. -* -* For more information see commit f8d59dfb40bb and test -* tests/qemu-iotests/222 -*/ - write_flags = (bdrv_chain_contains (target, bs) ?BDRV_REQ_SERIALISING :0 ) | - (compress ?BDRV_REQ_WRITE_COMPRESSED :0 ), - cbw =bdrv_cbw_append (bs, target, filter_node_name, - cluster_size, perf, - write_flags, &bcs, errp); + cluster_size, perf, compress, &bcs, errp);if (!cbw) { goto error; }
block/block-copy.c +21 -3
@@ -317,10 +317,11 @@ static uint32_t block_copy_max_transfer(BdrvChild *source, BdrvChild *target)BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target,int64_t cluster_size,bool use_copy_range, -BdrvRequestFlags write_flags,Error **errp) +bool compress,Error **errp) {BlockCopyState *s;BdrvDirtyBitmap *copy_bitmap; +bool is_fleecing; copy_bitmap =bdrv_create_dirty_bitmap (source->bs, cluster_size,NULL , errp);
@@ -329,6 +330,22 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, }bdrv_disable_dirty_bitmap (copy_bitmap); +/* +* If source is in backing chain of target assume that target is going to be +* used for "image fleecing", i.e. it should represent a kind of snapshot of +* source at backup-start point in time. And target is going to be read by +* somebody (for example, used as NBD export) during backup job. +* +* In this case, we need to add BDRV_REQ_SERIALISING write flag to avoid +* intersection of backup writes and third party reads from target, +* otherwise reading from target we may occasionally read already updated by +* guest data. +* +* For more information see commit f8d59dfb40bb and test +* tests/qemu-iotests/222 +*/ + is_fleecing =bdrv_chain_contains (target->bs, source->bs); + s =g_new (BlockCopyState,1 ); *s = (BlockCopyState ) { .source = source,
@@ -336,7 +353,8 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, .copy_bitmap = copy_bitmap, .cluster_size = cluster_size, .len = bdrv_dirty_bitmap_size(copy_bitmap), - .write_flags = write_flags, + .write_flags = (is_fleecing ?BDRV_REQ_SERIALISING :0 ) | + (compress ? BDRV_REQ_WRITE_COMPRESSED : 0), .mem = shres_create(BLOCK_COPY_MAX_MEM), .max_transfer = QEMU_ALIGN_DOWN( block_copy_max_transfer(source, target),
@@ -351,7 +369,7 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,* behalf). */ s->method =COPY_READ_WRITE_CLUSTER ; - }else if (write_flags &BDRV_REQ_WRITE_COMPRESSED ) { + }else if (compress) {/* Compression supports only cluster-size writes and no copy-range. */ s->method =COPY_READ_WRITE_CLUSTER ; }else {
block/copy-before-write.c +2 -2
@@ -171,7 +171,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,const char *filter_node_name, uint64_t cluster_size, BackupPerf *perf, - BdrvRequestFlags write_flags, + bool compress, BlockCopyState **bcs, Error **errp) {
@@ -218,7 +218,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, state->cluster_size = cluster_size; state->bcs =block_copy_state_new (top->backing, state->target, cluster_size, perf->use_copy_range, - write_flags, errp); + compress, errp);if (!state->bcs) {error_prepend (errp,"Cannot create block-copy-state: " ); goto fail;
Signature · 1 line
2.29.2
PATCH v8 7/34 block/block-copy: introduce block_copy_set_copy_opts()
In reply to Vladimir Sementsov-OgievskiyWe'll need a possibility to set compress and use_copy_range options after initialization of the state. So make corresponding part of block_copy_state_new() separate and public.
--- include/block/block-copy.h | 3 +++ block/block-copy.c | 49 ++++++++++++++++++++++---------------- 2 files changed, 32 insertions(+), 20 deletions(-)
include/block/block-copy.h +3 -0
@@ -28,6 +28,9 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, int64_t cluster_size, bool use_copy_range, bool compress, Error **errp); +/* Function should be called prior any actual copy request */ +void block_copy_set_copy_opts (BlockCopyState *s,bool use_copy_range, +bool compress);void block_copy_set_progress_meter (BlockCopyState *s,ProgressMeter *pm);void block_copy_state_free (BlockCopyState *s);
block/block-copy.c +29 -20
67 lines not on this page · raw message
Signature · 1 line
2.29.2
Re: [PATCH v8 07/34] block/block-copy: introduce block_copy_set_copy_opts()
Quoted 9 lines · Vladimir Sementsov-Ogievskiy
We'll need a possibility to set compress and
use_copy_rangeoptions after initialization of the state. So make corresponding part ofblock_copy_state_new()separate and public.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/block-copy.h | 3 +++ block/block-copy.c | 49 ++++++++++++++++++++++---------------- 2 files changed, 32 insertions(+), 20 deletions(-)
PATCH v8 8/34 block/backup: set copy_range and compress after filter insertion
In reply to Vladimir Sementsov-OgievskiyWe are going to publish copy-before-write filter, so it would be initialized through options. Still we don't want to publish compress and copy-range options, as
1. Modern way to enable compression is to use compress filter.
2. For copy-range it's unclean how to make proper interface:
- it's has experimental prefix for backup job anyway
- the whole BackupPerf structure doesn't make sense for the filter So, let's just add copy-range possibility to the filter later if needed.
Still, we are going to continue support for compression and experimental copy-range in backup job. So, set these options after filter creation.
Note, that we can drop "compress" argument of bdrv_cbw_append() now, as well as "perf". The only reason not doing so is that now, when I prepare this patch the big series around it is already reviewed and I want to avoid extra rebase conflicts to simplify review of the following version.
--- block/copy-before-write.h | 1 - block/backup.c | 3 ++- block/copy-before-write.c | 4 +--- 3 files changed, 3 insertions(+), 5 deletions(-)
block/copy-before-write.h +0 -1
@@ -33,7 +33,6 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,BlockDriverState *target, const char *filter_node_name, uint64_t cluster_size, - BackupPerf *perf, bool compress, BlockCopyState **bcs, Error **errp);
block/backup.c +2 -1
@@ -504,7 +504,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, } cbw =bdrv_cbw_append (bs, target, filter_node_name, - cluster_size, perf, compress, &bcs, errp); + cluster_size, false, &bcs, errp);if (!cbw) { goto error; }
@@ -530,6 +530,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, job->len = len; job->perf = *perf; +block_copy_set_copy_opts (bcs, perf->use_copy_range, compress);block_copy_set_progress_meter (bcs, &job->common.job.progress);block_copy_set_speed (bcs, speed);
block/copy-before-write.c +1 -3
@@ -170,7 +170,6 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,BlockDriverState *target, const char *filter_node_name, uint64_t cluster_size, - BackupPerf *perf, bool compress, BlockCopyState **bcs, Error **errp)
@@ -217,8 +216,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, state->cluster_size = cluster_size; state->bcs =block_copy_state_new (top->backing, state->target, - cluster_size, perf->use_copy_range, - compress, errp); + cluster_size, false, compress, errp);if (!state->bcs) {error_prepend (errp,"Cannot create block-copy-state: " ); goto fail;
Signature · 1 line
2.29.2
PATCH v8 9/34 block/backup: move cluster size calculation to block-copy
In reply to Vladimir Sementsov-OgievskiyThe main consumer of cluster-size is block-copy. Let's calculate it here instead of passing through backup-top.
We are going to publish copy-before-write filter soon, so it will be created through options. But we don't want for now to make explicit option for cluster-size, let's continue to calculate it automatically. So, now is the time to get rid of cluster_size argument for bdrv_cbw_append().
--- block/copy-before-write.h | 1 - include/block/block-copy.h | 5 +-- block/backup.c | 62 ++++++-------------------------------- block/block-copy.c | 51 ++++++++++++++++++++++++++++++- block/copy-before-write.c | 10 +++--- 5 files changed, 66 insertions(+), 63 deletions(-)
block/copy-before-write.h +0 -1
@@ -32,7 +32,6 @@BlockDriverState *bdrv_cbw_append (BlockDriverState *source,BlockDriverState *target,const char *filter_node_name, -uint64_t cluster_size,bool compress,BlockCopyState **bcs,Error **errp);
include/block/block-copy.h +3 -2
@@ -25,8 +25,8 @@ typedef struct BlockCopyState BlockCopyState;typedef struct BlockCopyCallState BlockCopyCallState ;BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target, -int64_t cluster_size,bool use_copy_range, -bool compress,Error **errp); +bool use_copy_range,bool compress, +Error **errp);/* Function should be called prior any actual copy request */ void block_copy_set_copy_opts(BlockCopyState *s, bool use_copy_range,
@@ -91,6 +91,7 @@ void block_copy_kick(BlockCopyCallState *call_state);void block_copy_call_cancel (BlockCopyCallState *call_state);BdrvDirtyBitmap *block_copy_dirty_bitmap (BlockCopyState *s); +int64_t block_copy_cluster_size (BlockCopyState *s);void block_copy_set_skip_unallocated (BlockCopyState *s,bool skip);#endif /* BLOCK_COPY_H */
block/backup.c +9 -53
96 lines not on this page · raw message
block/block-copy.c +50 -1
76 lines not on this page · raw message
block/copy-before-write.c +4 -6
@@ -37,7 +37,6 @@typedef struct BDRVCopyBeforeWriteState {BlockCopyState *bcs;BdrvChild *target; -int64_t cluster_size; }BDRVCopyBeforeWriteState ; static coroutine_fn int cbw_co_preadv(
@@ -52,13 +51,14 @@ static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs, {BDRVCopyBeforeWriteState *s = bs->opaque;uint64_t off, end; +int64_t cluster_size =block_copy_cluster_size (s->bcs);if (flags &BDRV_REQ_WRITE_UNCHANGED ) {return 0 ; } - off =QEMU_ALIGN_DOWN (offset, s->cluster_size); - end =QEMU_ALIGN_UP (offset + bytes, s->cluster_size); + off =QEMU_ALIGN_DOWN (offset, cluster_size); + end =QEMU_ALIGN_UP (offset + bytes, cluster_size);return block_copy (s->bcs, off, end - off, true); }
@@ -169,7 +169,6 @@ BlockDriver bdrv_cbw_filter = {BlockDriverState *bdrv_cbw_append (BlockDriverState *source,BlockDriverState *target,const char *filter_node_name, -uint64_t cluster_size,bool compress,BlockCopyState **bcs,Error **errp)
@@ -214,9 +213,8 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, } appended = true; - state->cluster_size = cluster_size; state->bcs =block_copy_state_new (top->backing, state->target, - cluster_size, false, compress, errp); + false, compress, errp);if (!state->bcs) {error_prepend (errp,"Cannot create block-copy-state: " ); goto fail;
Signature · 1 line
2.29.2
Re: [PATCH v8 09/34] block/backup: move cluster size calculation to block-copy
Quoted 18 lines · Vladimir Sementsov-Ogievskiy
The main consumer of cluster-size is block-copy. Let's calculate it here instead of passing through backup-top.
We are going to publish copy-before-write filter soon, so it will be created through options. But we don't want for now to make explicit option for cluster-size, let's continue to calculate it automatically. So, now is the time to get rid of
cluster_sizeargument forbdrv_cbw_append().Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>--- block/copy-before-write.h | 1 - include/block/block-copy.h | 5 +-- block/backup.c | 62 ++++++-------------------------------- block/block-copy.c | 51 ++++++++++++++++++++++++++++++- block/copy-before-write.c | 10 +++--- 5 files changed, 66 insertions(+), 63 deletions(-)
[...]
Quoted 4 lines
block/block-copy.c +0
-0
[...]
Quoted 15 lines
block/block-copy.c +11
-0@@ -342,14 +343,57 @@ void block_copy_set_copy_opts(BlockCopyState *s, bool use_copy_range, } } +static int64_t block_copy_calculate_cluster_size (BlockDriverState *target, +Error **errp) +{ +int ret; +BlockDriverInfo bdi; +bool target_does_cow =bdrv_backing_chain_next (target); + +/* +* If there is no backing file on the target, we cannot rely on COW if our +* backup cluster size is smaller than the target cluster size. Even for +* targets with a backing file, try to avoid COW if possible.
block/block-copy.c void block_copy_set_copy_opts(BlockCopyState *s, bool use_copy_range, · line 366
Quoted 10 lines
block/block-copy.c +10
-0+*/ + ret =bdrv_get_info (target, &bdi); +if (ret == -ENOTSUP && !target_does_cow) { +/* Cluster size is not defined */ +warn_report ("The target block device doesn't provide " +"information about the block size and it doesn't have a " +"backing file. The default block size of %u bytes is " +"used. If the actual block size of the target exceeds " +"this default, the backup may be unusable" , +BLOCK_COPY_CLUSTER_SIZE_DEFAULT );
I get some build errors in the gitlab CI because of this – I think we need to add a qemu/error-report.h include in block/block-copy.c now. (I don’t know why this works for some configurations, apparently, but not for others...)
Is it OK if I add it to this patch?
block/block-copy.c +0 -0
@@ -21,6 +21,7 @@
#include "qemu/units.h"
#include "qemu/coroutine.h"
#include "block/aio_task.h"
+#include "qemu/error-report.h"
#define BLOCK_COPY_MAX_COPY_RANGE (16 * MiB)
#define BLOCK_COPY_MAX_BUFFER (1 * MiB)
Hanna
Re: [PATCH v8 09/34] block/backup: move cluster size calculation to block-copy
Quoted 56 lines · Hanna Reitz
Quoted 18 lines · Vladimir Sementsov-Ogievskiy
The main consumer of cluster-size is block-copy. Let's calculate it here instead of passing through backup-top.
We are going to publish copy-before-write filter soon, so it will be created through options. But we don't want for now to make explicit option for cluster-size, let's continue to calculate it automatically. So, now is the time to get rid of
cluster_sizeargument forbdrv_cbw_append().Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>---
block/copy-before-write.h | 1 -include/block/block-copy.h| 5 +--
block/backup.c | 62 ++++++-------------------------------- block/block-copy.c | 51 ++++++++++++++++++++++++++++++- block/copy-before-write.c | 10 +++---5 files changed, 66 insertions(+), 63 deletions(-)[...]
Quoted 4 lines
block/block-copy.c +0
-0[...]
Quoted 14 lines
block/block-copy.c +11
-0@@ -342,14 +343,57 @@ void block_copy_set_copy_opts(BlockCopyState *s, bool use_copy_range, } } +static int64_t block_copy_calculate_cluster_size (BlockDriverState *target, + Error **errp) +{ + int ret; + BlockDriverInfo bdi; + bool target_does_cow = bdrv_backing_chain_next(target); + + /* +* If there is no backing file on the target, we cannot rely on COW if our +* backup cluster size is smaller than the target cluster size. Even for +* targets with a backing file, try to avoid COW if possible. block/block-copy.c void block_copy_set_copy_opts(BlockCopyState *s, bool use_copy_range, · line 365
Quoted 10 lines
block/block-copy.c +10
-0+*/ + ret = bdrv_get_info(target, &bdi); + if (ret == -ENOTSUP && !target_does_cow) { + /* Cluster size is not defined */ + warn_report("The target block device doesn't provide " + "information about the block size and it doesn't have a " + "backing file. The default block size of %u bytes is " + "used. If the actual block size of the target exceeds " + "this default, the backup may be unusable", + BLOCK_COPY_CLUSTER_SIZE_DEFAULT);I get some build errors in the gitlab CI because of this – I think we need to add a
qemu/error-report.hinclude inblock/block-copy.cnow. (I don’t know why this works for some configurations, apparently, but not for others...)
Quoted 1 line
Is it OK if I add it to this patch?
If it helps, than OK of course, thanks!
Quoted 16 lines
block/block-copy.c +1
-0@@ -21,6 +21,7 @@ #include "qemu/units.h" #include "qemu/coroutine.h" #include "block/aio_task.h" +#include "qemu/error-report.h" #define BLOCK_COPY_MAX_COPY_RANGE (16 * MiB) #define BLOCK_COPY_MAX_BUFFER (1 * MiB)Hanna
Signature · 2 lines
Best regards, Vladimir
PATCH v8 10/34 block/copy-before-write: relax permission requirements when no parents
In reply to Vladimir Sementsov-OgievskiyWe are going to publish copy-before-write filter. So, user should be able to create it with blockdev-add first, specifying both filtered and target children. And then do blockdev-reopen, to actually insert the filter where needed.
Currently, filter unshares write permission unconditionally on source node. It's good, but it will not allow to do blockdev-add. So, let's relax restrictions when filter doesn't have any parent.
Test output is modified, as now permission conflict happens only when job creates a blk parent for filter node.
--- block/copy-before-write.c | 8 +++++--- tests/qemu-iotests/283.out | 2 +- 2 files changed, 6 insertions(+), 4 deletions(-)
block/copy-before-write.c +5 -3
@@ -142,10 +142,12 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,bdrv_default_perms (bs, c, role, reopen_queue, perm, shared, nperm, nshared); -if (perm &BLK_PERM_WRITE ) { - *nperm = *nperm |BLK_PERM_CONSISTENT_READ ; +if (!QLIST_EMPTY (&bs->parents)) { +if (perm &BLK_PERM_WRITE ) { + *nperm = *nperm |BLK_PERM_CONSISTENT_READ ; + } + *nshared &= ~(BLK_PERM_WRITE |BLK_PERM_RESIZE ); } - *nshared &= ~(BLK_PERM_WRITE |BLK_PERM_RESIZE ); } }
tests/qemu-iotests/283.out +1 -1
@@ -5,7 +5,7 @@ {"execute": "blockdev-add", "arguments": {"driver": "blkdebug", "image": "base", "node-name": "other", "take-child-perms": ["write"]}} {"return": {}} {"execute": "blockdev-backup", "arguments": {"device": "source", "sync": "full", "target": "target"}} -{"error": {"class": "GenericError", "desc": "Cannot append copy-before-write filter: Permission conflict on node 'base': permissions 'write' are both required by node 'other' (uses node 'base' as 'image' child) and unshared by node 'source' (uses node 'base' as 'image' child)."}} +{"error": {"class": "GenericError", "desc": "Permission conflict on node 'base': permissions 'write' are both required by node 'other' (uses node 'base' as 'image' child) and unshared by node 'source' (uses node 'base' as 'image' child)."}} === copy-before-write filter should be gone after job-finalize ===
Signature · 1 line
2.29.2
PATCH v8 11/34 block/copy-before-write: drop extra bdrv_unref on failure path
In reply to Vladimir Sementsov-Ogievskiybdrv_attach_child() do bdrv_unref() on failure, so we shouldn't do it by hand here.
--- block/copy-before-write.c | 1 - 1 file changed, 1 deletion(-)
block/copy-before-write.c +0 -1
@@ -201,7 +201,6 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, state->target =bdrv_attach_child (top, target,"target" , &child_of_bds,BDRV_CHILD_DATA , errp);if (!state->target) { -bdrv_unref (target);bdrv_unref (top);return NULL ; }
Signature · 1 line
2.29.2
PATCH v8 12/34 block/copy-before-write: use file child instead of backing
In reply to Vladimir Sementsov-OgievskiyWe are going to publish copy-before-write filter, and there no public backing-child-based filter in Qemu. No reason to create a precedent, so let's refactor copy-before-write filter instead.
--- block/copy-before-write.c | 39 ++++++++++++++++++++++----------------- 1 file changed, 22 insertions(+), 17 deletions(-)
block/copy-before-write.c +22 -17
@@ -43,7 +43,7 @@ static coroutine_fn int cbw_co_preadv( BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags) { - return bdrv_co_preadv(bs->backing, offset, bytes, qiov, flags); + return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags); } static coroutine_fn int cbw_do_copy_before_write(BlockDriverState *bs,
@@ -71,7 +71,7 @@ static int coroutine_fn cbw_co_pdiscard(BlockDriverState *bs,return ret; } -return bdrv_co_pdiscard (bs->backing, offset, bytes); +return bdrv_co_pdiscard (bs->file, offset, bytes); } static int coroutine_fn cbw_co_pwrite_zeroes(BlockDriverState *bs,
@@ -82,7 +82,7 @@ static int coroutine_fn cbw_co_pwrite_zeroes(BlockDriverState *bs,return ret; } -return bdrv_co_pwrite_zeroes (bs->backing, offset, bytes, flags); +return bdrv_co_pwrite_zeroes (bs->file, offset, bytes, flags); } static coroutine_fn int cbw_co_pwritev(BlockDriverState *bs,
@@ -95,29 +95,22 @@ static coroutine_fn int cbw_co_pwritev(BlockDriverState *bs,return ret; } -return bdrv_co_pwritev (bs->backing, offset, bytes, qiov, flags); +return bdrv_co_pwritev (bs->file, offset, bytes, qiov, flags); } static int coroutine_fn cbw_co_flush(BlockDriverState *bs) { -if (!bs->backing) { +if (!bs->file) {return 0 ; } -return bdrv_co_flush (bs->backing->bs); +return bdrv_co_flush (bs->file->bs); }static void cbw_refresh_filename (BlockDriverState *bs) { -if (bs->backing ==NULL ) { -/* -* we can be here after failed bdrv_attach_child in -* bdrv_set_backing_hd -*/ -return ; - }pstrcpy (bs->exact_filename,sizeof (bs->exact_filename), - bs->backing->bs->filename); + bs->file->bs->filename); } static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,
@@ -186,6 +179,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, top =bdrv_new_open_driver (&bdrv_cbw_filter, filter_node_name,BDRV_O_RDWR , errp);if (!top) { +error_prepend (errp,"Cannot open driver: " );return NULL ; }
@@ -201,21 +195,32 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, state->target =bdrv_attach_child (top, target,"target" , &child_of_bds,BDRV_CHILD_DATA , errp);if (!state->target) { +error_prepend (errp,"Cannot attach target child: " ); +bdrv_unref (top); +return NULL ; + } + +bdrv_ref (source); + top->file =bdrv_attach_child (top, source,"file" , &child_of_bds, +BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , + errp); +if (!top->file) { +error_prepend (errp,"Cannot attach file child: " );bdrv_unref (top);return NULL ; }bdrv_drained_begin (source); - ret =bdrv_append (top, source, errp); + ret =bdrv_replace_node (source, top, errp);if (ret <0 ) {error_prepend (errp,"Cannot append copy-before-write filter: " ); goto fail; } appended = true; - state->bcs =block_copy_state_new (top->backing, state->target, - false, compress, errp); + state->bcs =block_copy_state_new (top->file, state->target, false, compress, + errp);if (!state->bcs) {error_prepend (errp,"Cannot create block-copy-state: " ); goto fail;
Signature · 1 line
2.29.2
PATCH v8 13/34 block/copy-before-write: bdrv_cbw_append(): replace child at last
In reply to Vladimir Sementsov-OgievskiyRefactor the function to replace child at last. Thus we don't need to revert it and code is simplified.
block-copy state initialization being done before replacing the child doesn't need any drained section.
--- block/copy-before-write.c | 33 +++++++++++---------------------- 1 file changed, 11 insertions(+), 22 deletions(-)
block/copy-before-write.c +11 -22
@@ -172,7 +172,6 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,int ret;BDRVCopyBeforeWriteState *state;BlockDriverState *top; -bool appended = false;assert (source->total_sectors == target->total_sectors);
@@ -196,8 +195,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, BDRV_CHILD_DATA, errp);if (!state->target) {error_prepend (errp,"Cannot attach target child: " ); -bdrv_unref (top); -return NULL ; + goto fail; }bdrv_ref (source);
@@ -206,18 +204,8 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, errp);if (!top->file) {error_prepend (errp,"Cannot attach file child: " ); -bdrv_unref (top); -return NULL ; - } - -bdrv_drained_begin (source); - - ret =bdrv_replace_node (source, top, errp); -if (ret <0 ) { -error_prepend (errp,"Cannot append copy-before-write filter: " ); goto fail; } - appended = true; state->bcs =block_copy_state_new (top->file, state->target, false, compress, errp);
@@ -225,21 +213,22 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,error_prepend (errp,"Cannot create block-copy-state: " ); goto fail; } - *bcs = state->bcs; +bdrv_drained_begin (source); + ret =bdrv_replace_node (source, top, errp);bdrv_drained_end (source); +if (ret <0 ) { +error_prepend (errp,"Cannot append copy-before-write filter: " ); + goto fail; + } + + *bcs = state->bcs;return top; fail: -if (appended) { -bdrv_cbw_drop (top); - }else { -bdrv_unref (top); - } - -bdrv_drained_end (source); - +block_copy_state_free (state->bcs); +bdrv_unref (top);return NULL ; }
Signature · 1 line
2.29.2
PATCH v8 14/34 block/copy-before-write: introduce cbw_init()
In reply to Vladimir Sementsov-OgievskiyMove part of bdrv_cbw_append() to new function cbw_open(). It's an intermediate step for adding normal .bdrv_open() handler to the filter. With this commit no logic is changed, but we have a function which will be turned into .bdrv_open() handler in future commit.
--- block/copy-before-write.c | 69 +++++++++++++++++++++++---------------- 1 file changed, 41 insertions(+), 28 deletions(-)
block/copy-before-write.c +41 -28
@@ -144,6 +144,45 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c, } } +static int cbw_init (BlockDriverState *top,BlockDriverState *source, +BlockDriverState *target,bool compress,Error **errp) +{ +BDRVCopyBeforeWriteState *state = top->opaque; + + top->total_sectors = source->total_sectors; + top->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | + (BDRV_REQ_FUA & source->supported_write_flags); + top->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | + ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & + source->supported_zero_flags); + +bdrv_ref (target); + state->target =bdrv_attach_child (top, target,"target" , &child_of_bds, +BDRV_CHILD_DATA , errp); +if (!state->target) { +error_prepend (errp,"Cannot attach target child: " ); +return -EINVAL ; + } + +bdrv_ref (source); + top->file =bdrv_attach_child (top, source,"file" , &child_of_bds, +BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , + errp); +if (!top->file) { +error_prepend (errp,"Cannot attach file child: " ); +return -EINVAL ; + } + + state->bcs =block_copy_state_new (top->file, state->target, false, compress, + errp); +if (!state->bcs) { +error_prepend (errp,"Cannot create block-copy-state: " ); +return -EINVAL ; + } + +return 0 ; +} +BlockDriver bdrv_cbw_filter = { .format_name ="copy-before-write" , .instance_size =sizeof (BDRVCopyBeforeWriteState),
@@ -181,36 +220,10 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,error_prepend (errp,"Cannot open driver: " );return NULL ; } - state = top->opaque; - top->total_sectors = source->total_sectors; - top->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | - (BDRV_REQ_FUA & source->supported_write_flags); - top->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | - ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & - source->supported_zero_flags); - -bdrv_ref (target); - state->target =bdrv_attach_child (top, target,"target" , &child_of_bds, -BDRV_CHILD_DATA , errp); -if (!state->target) { -error_prepend (errp,"Cannot attach target child: " ); - goto fail; - } -bdrv_ref (source); - top->file =bdrv_attach_child (top, source,"file" , &child_of_bds, -BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , - errp); -if (!top->file) { -error_prepend (errp,"Cannot attach file child: " ); - goto fail; - } - - state->bcs =block_copy_state_new (top->file, state->target, false, compress, - errp); -if (!state->bcs) { -error_prepend (errp,"Cannot create block-copy-state: " ); + ret =cbw_init (top, source, target, compress, errp); +if (ret <0 ) { goto fail; }
Signature · 1 line
2.29.2
PATCH v8 15/34 block/copy-before-write: cbw_init(): rename variables
In reply to Vladimir Sementsov-OgievskiyOne more step closer to real .bdrv_open() handler: use more usual names for bs being initialized and its state.
--- block/copy-before-write.c | 29 ++++++++++++++--------------- 1 file changed, 14 insertions(+), 15 deletions(-)
block/copy-before-write.c +14 -15
@@ -144,38 +144,37 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c, } } -static int cbw_init (BlockDriverState *top,BlockDriverState *source, +static int cbw_init (BlockDriverState *bs,BlockDriverState *source,BlockDriverState *target,bool compress,Error **errp) { -BDRVCopyBeforeWriteState *state = top->opaque; +BDRVCopyBeforeWriteState *s = bs->opaque; - top->total_sectors = source->total_sectors; - top->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | + bs->total_sectors = source->total_sectors; + bs->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | (BDRV_REQ_FUA & source->supported_write_flags); - top->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | + bs->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & source->supported_zero_flags);bdrv_ref (target); - state->target =bdrv_attach_child (top, target,"target" , &child_of_bds, -BDRV_CHILD_DATA , errp); -if (!state->target) { + s->target =bdrv_attach_child (bs, target,"target" , &child_of_bds, +BDRV_CHILD_DATA , errp); +if (!s->target) {error_prepend (errp,"Cannot attach target child: " );return -EINVAL ; }bdrv_ref (source); - top->file =bdrv_attach_child (top, source,"file" , &child_of_bds, -BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , - errp); -if (!top->file) { + bs->file =bdrv_attach_child (bs, source,"file" , &child_of_bds, +BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , + errp); +if (!bs->file) {error_prepend (errp,"Cannot attach file child: " );return -EINVAL ; } - state->bcs =block_copy_state_new (top->file, state->target, false, compress, - errp); -if (!state->bcs) { + s->bcs =block_copy_state_new (bs->file, s->target, false, compress, errp); +if (!s->bcs) {error_prepend (errp,"Cannot create block-copy-state: " );return -EINVAL ; }
Signature · 1 line
2.29.2
PATCH v8 16/34 block/copy-before-write: cbw_init(): use file child after attaching
In reply to Vladimir Sementsov-OgievskiyIn the next commit we'll get rid of source argument of cbw_init(). Prepare to it now, to make next commit simpler: move the code block that uses source below attaching the child and use bs->file->bs instead of source variable.
--- block/copy-before-write.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
block/copy-before-write.c +7 -7
@@ -149,13 +149,6 @@ static int cbw_init(BlockDriverState *bs, BlockDriverState *source, {BDRVCopyBeforeWriteState *s = bs->opaque; - bs->total_sectors = source->total_sectors; - bs->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | - (BDRV_REQ_FUA & source->supported_write_flags); - bs->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | - ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & - source->supported_zero_flags); -bdrv_ref (target); s->target =bdrv_attach_child (bs, target,"target" , &child_of_bds,BDRV_CHILD_DATA , errp);
@@ -173,6 +166,13 @@ static int cbw_init(BlockDriverState *bs, BlockDriverState *source,return -EINVAL ; } + bs->total_sectors = bs->file->bs->total_sectors; + bs->supported_write_flags =BDRV_REQ_WRITE_UNCHANGED | + (BDRV_REQ_FUA & bs->file->bs->supported_write_flags); + bs->supported_zero_flags =BDRV_REQ_WRITE_UNCHANGED | + ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & + bs->file->bs->supported_zero_flags); + s->bcs =block_copy_state_new (bs->file, s->target, false, compress, errp);if (!s->bcs) {error_prepend (errp,"Cannot create block-copy-state: " );
Signature · 1 line
2.29.2
PATCH v8 17/34 block/copy-before-write: bdrv_cbw_append(): drop unused compress arg
In reply to Vladimir Sementsov-Ogievskiy--- block/copy-before-write.h | 1 - block/backup.c | 2 +- block/copy-before-write.c | 7 +++---- 3 files changed, 4 insertions(+), 6 deletions(-)
block/copy-before-write.h +0 -1
@@ -32,7 +32,6 @@BlockDriverState *bdrv_cbw_append (BlockDriverState *source,BlockDriverState *target,const char *filter_node_name, -bool compress,BlockCopyState **bcs,Error **errp);void bdrv_cbw_drop (BlockDriverState *bs);
block/backup.c +1 -1
@@ -452,7 +452,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, goto error; } - cbw =bdrv_cbw_append (bs, target, filter_node_name, false, &bcs, errp); + cbw =bdrv_cbw_append (bs, target, filter_node_name, &bcs, errp);if (!cbw) { goto error; }
block/copy-before-write.c +3 -4
@@ -145,7 +145,7 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c, }static int cbw_init (BlockDriverState *bs,BlockDriverState *source, -BlockDriverState *target,bool compress,Error **errp) +BlockDriverState *target,Error **errp) {BDRVCopyBeforeWriteState *s = bs->opaque;
@@ -173,7 +173,7 @@ static int cbw_init(BlockDriverState *bs, BlockDriverState *source, ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & bs->file->bs->supported_zero_flags); - s->bcs =block_copy_state_new (bs->file, s->target, false, compress, errp); + s->bcs =block_copy_state_new (bs->file, s->target, false, false, errp);if (!s->bcs) {error_prepend (errp,"Cannot create block-copy-state: " );return -EINVAL ;
@@ -202,7 +202,6 @@ BlockDriver bdrv_cbw_filter = {BlockDriverState *bdrv_cbw_append (BlockDriverState *source,BlockDriverState *target,const char *filter_node_name, -bool compress,BlockCopyState **bcs,Error **errp) {
@@ -221,7 +220,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, } state = top->opaque; - ret =cbw_init (top, source, target, compress, errp); + ret =cbw_init (top, source, target, errp);if (ret <0 ) { goto fail; }
Signature · 1 line
2.29.2
PATCH v8 18/34 block/copy-before-write: cbw_init(): use options
In reply to Vladimir Sementsov-OgievskiyOne more step closer to .bdrv_open(): use options instead of plain arguments. Move to bdrv_open_child() calls, native for drive open handlers.
--- block/copy-before-write.c | 29 +++++++++++++++-------------- 1 file changed, 15 insertions(+), 14 deletions(-)
block/copy-before-write.c +15 -14
@@ -144,25 +144,20 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c, } } -static int cbw_init (BlockDriverState *bs,BlockDriverState *source, -BlockDriverState *target,Error **errp) +static int cbw_init (BlockDriverState *bs,QDict *options,Error **errp) {BDRVCopyBeforeWriteState *s = bs->opaque; -bdrv_ref (target); - s->target =bdrv_attach_child (bs, target,"target" , &child_of_bds, -BDRV_CHILD_DATA , errp); -if (!s->target) { -error_prepend (errp,"Cannot attach target child: " ); + bs->file =bdrv_open_child (NULL , options,"file" , bs, &child_of_bds, +BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , + false, errp); +if (!bs->file) {return -EINVAL ; } -bdrv_ref (source); - bs->file =bdrv_attach_child (bs, source,"file" , &child_of_bds, -BDRV_CHILD_FILTERED |BDRV_CHILD_PRIMARY , - errp); -if (!bs->file) { -error_prepend (errp,"Cannot attach file child: " ); + s->target =bdrv_open_child (NULL , options,"target" , bs, &child_of_bds, +BDRV_CHILD_DATA , false, errp); +if (!s->target) {return -EINVAL ; }
@@ -209,6 +204,7 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source,int ret;BDRVCopyBeforeWriteState *state;BlockDriverState *top; +QDict *opts;assert (source->total_sectors == target->total_sectors);
@@ -220,7 +216,12 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, } state = top->opaque; - ret =cbw_init (top, source, target, errp); + opts =qdict_new (); +qdict_put_str (opts,"file" ,bdrv_get_node_name (source)); +qdict_put_str (opts,"target" ,bdrv_get_node_name (target)); + + ret =cbw_init (top, opts, errp); +qobject_unref (opts);if (ret <0 ) { goto fail; }
Signature · 1 line
2.29.2
PATCH v8 19/34 block/copy-before-write: initialize block-copy bitmap
In reply to Vladimir Sementsov-OgievskiyWe are going to publish copy-before-write filter to be used in separate of backup. Future step would support bitmap for the filter. But let's start from full set bitmap.
We have to modify backup, as bitmap is first initialized by copy-before-write filter, and then backup modifies it.
--- block/backup.c | 16 +++++++--------- block/copy-before-write.c | 4 ++++ 2 files changed, 11 insertions(+), 9 deletions(-)
block/backup.c +7 -9
@@ -233,18 +233,16 @@ static void backup_init_bcs_bitmap(BackupBlockJob *job)BdrvDirtyBitmap *bcs_bitmap =block_copy_dirty_bitmap (job->bcs);if (job->sync_mode ==MIRROR_SYNC_MODE_BITMAP ) { +bdrv_clear_dirty_bitmap (bcs_bitmap,NULL ); ret =bdrv_dirty_bitmap_merge_internal (bcs_bitmap, job->sync_bitmap,NULL , true);assert (ret); - }else { -if (job->sync_mode ==MIRROR_SYNC_MODE_TOP ) { -/* -* We can't hog the coroutine to initialize this thoroughly. -* Set a flag and resume work when we are able to yield safely. -*/ -block_copy_set_skip_unallocated (job->bcs, true); - } -bdrv_set_dirty_bitmap (bcs_bitmap,0 , job->len); + }else if (job->sync_mode ==MIRROR_SYNC_MODE_TOP ) { +/* +* We can't hog the coroutine to initialize this thoroughly. +* Set a flag and resume work when we are able to yield safely. +*/ +block_copy_set_skip_unallocated (job->bcs, true); } estimate =bdrv_get_dirty_count (bcs_bitmap);
block/copy-before-write.c +4 -0
@@ -147,6 +147,7 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c,static int cbw_init (BlockDriverState *bs,QDict *options,Error **errp) {BDRVCopyBeforeWriteState *s = bs->opaque; +BdrvDirtyBitmap *copy_bitmap; bs->file = bdrv_open_child(NULL, options, "file", bs, &child_of_bds, BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
@@ -174,6 +175,9 @@ static int cbw_init(BlockDriverState *bs, QDict *options, Error **errp)return -EINVAL ; } + copy_bitmap =block_copy_dirty_bitmap (s->bcs); +bdrv_set_dirty_bitmap (copy_bitmap,0 ,bdrv_dirty_bitmap_size (copy_bitmap)); +return 0 ; }
Signature · 1 line
2.29.2
PATCH v8 20/34 block/block-copy: make setting progress optional
In reply to Vladimir Sementsov-OgievskiyNow block-copy will crash if user don't set progress meter by block_copy_set_progress_meter(). copy-before-write filter will be used in separate of backup job, and it doesn't want any progress meter (for now). So, allow not setting it.
--- block/block-copy.c | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-)
block/block-copy.c +11 -7
@@ -291,9 +291,11 @@ static void coroutine_fn block_copy_task_end(BlockCopyTask *task, int ret)bdrv_set_dirty_bitmap (task->s->copy_bitmap, task->offset, task->bytes); }QLIST_REMOVE (task, list); -progress_set_remaining (task->s->progress, -bdrv_get_dirty_count (task->s->copy_bitmap) + - task->s->in_flight_bytes); +if (task->s->progress) { +progress_set_remaining (task->s->progress, +bdrv_get_dirty_count (task->s->copy_bitmap) + + task->s->in_flight_bytes); + }qemu_co_queue_restart_all (&task->wait_queue); }
@@ -593,7 +595,7 @@ static coroutine_fn int block_copy_task_entry(AioTask *task) t->call_state->ret = ret; t->call_state->error_is_read = error_is_read; } - }else { + }else if (s->progress) {progress_work_done (s->progress, t->bytes); } }
@@ -699,9 +701,11 @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,if (!ret) {qemu_co_mutex_lock (&s->lock);bdrv_reset_dirty_bitmap (s->copy_bitmap, offset, bytes); -progress_set_remaining (s->progress, -bdrv_get_dirty_count (s->copy_bitmap) + - s->in_flight_bytes); +if (s->progress) { +progress_set_remaining (s->progress, +bdrv_get_dirty_count (s->copy_bitmap) + + s->in_flight_bytes); + }qemu_co_mutex_unlock (&s->lock); }
Signature · 1 line
2.29.2
PATCH v8 21/34 block/copy-before-write: make public block driver
In reply to Vladimir Sementsov-OgievskiyFinally, copy-before-write gets own .bdrv_open and .bdrv_close handlers, block_init() call and becomes available through bdrv_open().
To achieve this:
- cbw_init gets unused flags argument and becomes cbw_open
- block_copy_state_free() call moved to new cbw_close()
- in bdrv_cbw_append:
- options are completed with driver and node-name, and we can simply use bdrv_insert_node() to do both open and drained replacing
- in bdrv_cbw_drop:
- cbw_close() is now responsible for freeing s->bcs, so don't do it here
--- block/copy-before-write.c | 60 ++++++++++++++++++--------------------- 1 file changed, 28 insertions(+), 32 deletions(-)
block/copy-before-write.c +28 -32
@@ -144,7 +144,8 @@ static void cbw_child_perm(BlockDriverState *bs, BdrvChild *c, } } -static int cbw_init (BlockDriverState *bs,QDict *options,Error **errp) +static int cbw_open (BlockDriverState *bs,QDict *options,int flags, +Error **errp) {BDRVCopyBeforeWriteState *s = bs->opaque;BdrvDirtyBitmap *copy_bitmap;
@@ -181,10 +182,21 @@ static int cbw_init(BlockDriverState *bs, QDict *options, Error **errp)return 0 ; } +static void cbw_close (BlockDriverState *bs) +{ +BDRVCopyBeforeWriteState *s = bs->opaque; + +block_copy_state_free (s->bcs); + s->bcs =NULL ; +} +BlockDriver bdrv_cbw_filter = { .format_name ="copy-before-write" , .instance_size =sizeof (BDRVCopyBeforeWriteState), + .bdrv_open = cbw_open, + .bdrv_close = cbw_close, + .bdrv_co_preadv = cbw_co_preadv, .bdrv_co_pwritev = cbw_co_pwritev, .bdrv_co_pwrite_zeroes = cbw_co_pwrite_zeroes,
@@ -205,56 +217,40 @@ BlockDriverState *bdrv_cbw_append(BlockDriverState *source, Error **errp) {ERRP_GUARD (); -int ret;BDRVCopyBeforeWriteState *state;BlockDriverState *top;QDict *opts;assert (source->total_sectors == target->total_sectors); - top =bdrv_new_open_driver (&bdrv_cbw_filter, filter_node_name, -BDRV_O_RDWR , errp); -if (!top) { -error_prepend (errp,"Cannot open driver: " ); -return NULL ; - } - state = top->opaque; - opts =qdict_new (); +qdict_put_str (opts,"driver" ,"copy-before-write" ); +if (filter_node_name) { +qdict_put_str (opts,"node-name" , filter_node_name); + }qdict_put_str (opts,"file" ,bdrv_get_node_name (source));qdict_put_str (opts,"target" ,bdrv_get_node_name (target)); - ret =cbw_init (top, opts, errp); -qobject_unref (opts); -if (ret <0 ) { - goto fail; - } - -bdrv_drained_begin (source); - ret =bdrv_replace_node (source, top, errp); -bdrv_drained_end (source); -if (ret <0 ) { -error_prepend (errp,"Cannot append copy-before-write filter: " ); - goto fail; + top =bdrv_insert_node (source, opts,BDRV_O_RDWR , errp); +if (!top) { +return NULL ; } + state = top->opaque; *bcs = state->bcs;return top; - -fail: -block_copy_state_free (state->bcs); -bdrv_unref (top); -return NULL ; }void bdrv_cbw_drop (BlockDriverState *bs) { -BDRVCopyBeforeWriteState *s = bs->opaque; -bdrv_drop_filter (bs, &error_abort); - -block_copy_state_free (s->bcs); -bdrv_unref (bs); } + +static void cbw_init (void ) +{ +bdrv_register (&bdrv_cbw_filter); +} + +block_init (cbw_init);
Signature · 1 line
2.29.2
PATCH v8 22/34 qapi: publish copy-before-write filter
In reply to Vladimir Sementsov-Ogievskiy--- qapi/block-core.json | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-)
qapi/block-core.json +23 -2
@@ -2825,13 +2825,14 @@ # @blklogwrites: Since 3.0 # @blkreplay: Since 4.2 # @compress: Since 5.0 +# @copy-before-write: Since 6.2 # # Since: 2.9 ## { 'enum': 'BlockdevDriver', 'data': [ 'blkdebug', 'blklogwrites', 'blkreplay', 'blkverify', 'bochs', - 'cloop', 'compress', 'copy-on-read', 'dmg', 'file', 'ftp', 'ftps', - 'gluster', + 'cloop', 'compress', 'copy-before-write', 'copy-on-read', 'dmg', + 'file', 'ftp', 'ftps', 'gluster', {'name': 'host_cdrom', 'if': 'defined(HAVE_HOST_BLOCK_DEVICE)' }, {'name': 'host_device', 'if': 'defined(HAVE_HOST_BLOCK_DEVICE)' }, 'http', 'https', 'iscsi',
@@ -4049,6 +4050,25 @@ 'base': 'BlockdevOptionsGenericFormat', 'data': { '*bottom': 'str' } } +## +# @BlockdevOptionsCbw: +# +# Driver specific block device options for the copy-before-write driver, +# which does so called copy-before-write operations: when data is +# written to the filter, the filter first reads corresponding blocks +# from its file child and copies them to @target child. After successfully +# copying, the write request is propagated to file child. If copying +# fails, the original write request is failed too and no data is written +# to file child. +# +# @target: The target for copy-before-write operations. +# +# Since: 6.2 +## +{ 'struct': 'BlockdevOptionsCbw', + 'base': 'BlockdevOptionsGenericFormat', + 'data': { 'target': 'BlockdevRef' } } + ## # @BlockdevOptions: #
@@ -4101,6 +4121,7 @@ 'bochs': 'BlockdevOptionsGenericFormat', 'cloop': 'BlockdevOptionsGenericFormat', 'compress': 'BlockdevOptionsGenericFormat', + 'copy-before-write':'BlockdevOptionsCbw', 'copy-on-read':'BlockdevOptionsCor', 'dmg': 'BlockdevOptionsGenericFormat', 'file': 'BlockdevOptionsFile',
Signature · 1 line
2.29.2
PATCH v8 23/34 python/qemu/machine.py: refactor _qemu_args()
In reply to Vladimir Sementsov-Ogievskiy - use shorter construction
- don't create new dict if not needed
- drop extra unpacking key-val arguments
- drop extra default values
--- python/qemu/machine/machine.py | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-)
python/qemu/machine/machine.py +8 -10
@@ -564,14 +564,12 @@ def _qmp(self) -> QEMUMonitorProtocol: return self._qmp_connection @classmethod - def _qmp_args(cls, _conv_keys: bool = True, **args: Any) -> Dict[str, Any]: - qmp_args = dict() - for key, value in args.items(): - if _conv_keys: - qmp_args[key.replace('_', '-')] = value - else: - qmp_args[key] = value - return qmp_args + def _qmp_args(cls, conv_keys: bool, + args: Dict[str, Any]) -> Dict[str, object]: + if conv_keys: + return {k.replace('_', '-'): v for k, v in args.items()} + + return args def qmp(self, cmd: str, conv_keys: bool = True,
@@ -579,7 +577,7 @@ def qmp(self, cmd: str, """ Invoke a QMP command and return the response dict """ - qmp_args = self._qmp_args(conv_keys, **args) + qmp_args = self._qmp_args(conv_keys, args) return self._qmp.cmd(cmd, args=qmp_args) def command(self, cmd: str,
@@ -590,7 +588,7 @@ def command(self, cmd: str, On success return the response dict. On failure raise an exception. """ - qmp_args = self._qmp_args(conv_keys, **args) + qmp_args = self._qmp_args(conv_keys, args) return self._qmp.command(cmd, **qmp_args) def get_qmp_event(self, wait: bool = False) -> Optional[QMPMessage]:
Signature · 1 line
2.29.2
PATCH v8 24/34 python/qemu/machine: QEMUMachine: improve qmp() method
In reply to Vladimir Sementsov-OgievskiyWe often call qmp() with unpacking dict, like qmp('foo', **{...}). mypy don't really like it, it thinks that passed unpacked dict is a positional argument and complains that it type should be bool (because second argument of qmp() is conv_keys: bool).
Allow passing dict directly, simplifying interface, and giving a way to satisfy mypy.
--- python/qemu/machine/machine.py | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-)
python/qemu/machine/machine.py +11 -1
@@ -572,11 +572,21 @@ def _qmp_args(cls, conv_keys: bool, return args def qmp(self, cmd: str, - conv_keys: bool = True, + args_dict: Optional[Dict[str, object]] = None, + conv_keys: Optional[bool] = None, **args: Any) -> QMPMessage: """ Invoke a QMP command and return the response dict """ + if args_dict is not None: + assert not args + assert conv_keys is None + args = args_dict + conv_keys = False + + if conv_keys is None: + conv_keys = True + qmp_args = self._qmp_args(conv_keys, args) return self._qmp.cmd(cmd, args=qmp_args)
Signature · 1 line
2.29.2
PATCH v8 25/34 python:QEMUMachine: template typing for self returning methods
In reply to Vladimir Sementsov-Ogievskiymypy thinks that return value of these methods in subclusses is QEMUMachine, which is wrong. So, make typing smarter.
--- python/qemu/machine/machine.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
python/qemu/machine/machine.py +7 -3
@@ -36,6 +36,7 @@ Sequence, Tuple, Type, + TypeVar, ) from qemu.qmp import ( # pylint: disable=import-error
@@ -73,6 +74,9 @@ class AbnormalShutdown(QEMUMachineError): """ +_T = TypeVar('_T', bound='QEMUMachine') + + class QEMUMachine: """ A QEMU VM.
@@ -166,7 +170,7 @@ def __init__(self, self._remove_files: List[str] = [] self._user_killed = False - def __enter__(self) -> 'QEMUMachine': + def __enter__(self: _T) -> _T: return self def __exit__(self,
@@ -182,8 +186,8 @@ def add_monitor_null(self) -> None: self._args.append('-monitor') self._args.append('null') - def add_fd(self, fd: int, fdset: int, - opaque: str, opts: str = '') -> 'QEMUMachine': + def add_fd(self: _T, fd: int, fdset: int, + opaque: str, opts: str = '') -> _T: """ Pass a file descriptor to the VM """
Signature · 1 line
2.29.2
Re: [PATCH v8 25/34] python:QEMUMachine: template typing for self returning methods
Quoted 8 lines · Vladimir Sementsov-Ogievskiy
mypy thinks that return value of these methods in subclusses is QEMUMachine, which is wrong. So, make typing smarter.
Suggested-by John Snow <[email protected]>Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- python/qemu/machine/machine.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
PATCH v8 26/34 iotests/222: fix pylint and mypy complains
In reply to Vladimir Sementsov-OgievskiyHere:
- long line
- move to new interface of vm.qmp() (direct passing dict), to avoid mypy false-positive, as it thinks that unpacked dict is a positional argument.
- extra parenthesis
- handle event_wait possible None value
--- tests/qemu-iotests/222 | 20 +++++++++++--------- tests/qemu-iotests/297 | 2 +- 2 files changed, 12 insertions(+), 10 deletions(-)
tests/qemu-iotests/222 +11 -9
@@ -50,7 +50,8 @@ remainder = [("0xd5", "0x108000", "32k"), # Right-end of partial-left [1] with iotests.FilePath('base.img') as base_img_path, \ iotests.FilePath('fleece.img') as fleece_img_path, \ - iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock_path, \ + iotests.FilePath('nbd.sock', + base_dir=iotests.sock_dir) as nbd_sock_path, \ iotests.VM() as vm: log('--- Setting up images ---')
@@ -81,7 +82,7 @@ with iotests.FilePath('base.img') as base_img_path, \ tgt_node = "fleeceNode" # create tgt_node backed by src_node - log(vm.qmp("blockdev-add", **{ + log(vm.qmp("blockdev-add", { "driver": "qcow2", "node-name": tgt_node, "file": {
@@ -103,8 +104,8 @@ with iotests.FilePath('base.img') as base_img_path, \ nbd_uri = 'nbd+unix:///%s?socket=%s' % (tgt_node, nbd_sock_path) log(vm.qmp("nbd-server-start", - **{"addr": { "type": "unix", - "data": { "path": nbd_sock_path } } })) + {"addr": { "type": "unix", + "data": { "path": nbd_sock_path } } })) log(vm.qmp("nbd-server-add", device=tgt_node))
@@ -112,7 +113,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Sanity Check ---') log('') - for p in (patterns + zeroes): + for p in patterns + zeroes: cmd = "read -P%s %s %s" % p log(cmd) assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
@@ -130,7 +131,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Verifying Data ---') log('') - for p in (patterns + zeroes): + for p in patterns + zeroes: cmd = "read -P%s %s %s" % p log(cmd) assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
@@ -140,8 +141,9 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') log(vm.qmp('block-job-cancel', device=src_node)) - log(vm.event_wait('BLOCK_JOB_CANCELLED'), - filters=[iotests.filter_qmp_event]) + e = vm.event_wait('BLOCK_JOB_CANCELLED') + assert e is not None + log(e, filters=[iotests.filter_qmp_event]) log(vm.qmp('nbd-server-stop')) log(vm.qmp('blockdev-del', node_name=tgt_node)) vm.shutdown()
@@ -150,7 +152,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Confirming writes ---') log('') - for p in (overwrite + remainder): + for p in overwrite + remainder: cmd = "read -P%s %s %s" % p log(cmd) assert qemu_io_silent(base_img_path, '-c', cmd) == 0
tests/qemu-iotests/297 +1 -1
@@ -31,7 +31,7 @@ SKIP_FILES = ( '096', '118', '124', '132', '136', '139', '147', '148', '149', '151', '152', '155', '163', '165', '169', '194', '196', '199', '202', '203', '205', '206', '207', '208', '210', '211', '212', '213', '216', - '218', '219', '222', '224', '228', '234', '235', '236', '237', '238', + '218', '219', '224', '228', '234', '235', '236', '237', '238', '240', '242', '245', '246', '248', '255', '256', '257', '258', '260', '262', '264', '266', '274', '277', '280', '281', '295', '296', '298', '299', '302', '303', '304', '307',
Signature · 1 line
2.29.2
PATCH v8 27/34 iotests/222: constantly use single quotes for strings
In reply to Vladimir Sementsov-OgievskiyThe file use both single and double quotes for strings. Let's be consistent.
--- tests/qemu-iotests/222 | 68 +++++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 34 deletions(-)
tests/qemu-iotests/222 +34 -34
@@ -30,23 +30,23 @@ iotests.script_initialize( supported_platforms=['linux'], ) -patterns = [("0x5d", "0", "64k"), - ("0xd5", "1M", "64k"), - ("0xdc", "32M", "64k"), - ("0xcd", "0x3ff0000", "64k")] # 64M - 64K +patterns = [('0x5d', '0', '64k'), + ('0xd5', '1M', '64k'), + ('0xdc', '32M', '64k'), + ('0xcd', '0x3ff0000', '64k')] # 64M - 64K -overwrite = [("0xab", "0", "64k"), # Full overwrite - ("0xad", "0x00f8000", "64k"), # Partial-left (1M-32K) - ("0x1d", "0x2008000", "64k"), # Partial-right (32M+32K) - ("0xea", "0x3fe0000", "64k")] # Adjacent-left (64M - 128K) +overwrite = [('0xab', '0', '64k'), # Full overwrite + ('0xad', '0x00f8000', '64k'), # Partial-left (1M-32K) + ('0x1d', '0x2008000', '64k'), # Partial-right (32M+32K) + ('0xea', '0x3fe0000', '64k')] # Adjacent-left (64M - 128K) -zeroes = [("0", "0x00f8000", "32k"), # Left-end of partial-left (1M-32K) - ("0", "0x2010000", "32k"), # Right-end of partial-right (32M+64K) - ("0", "0x3fe0000", "64k")] # overwrite[3] +zeroes = [('0', '0x00f8000', '32k'), # Left-end of partial-left (1M-32K) + ('0', '0x2010000', '32k'), # Right-end of partial-right (32M+64K) + ('0', '0x3fe0000', '64k')] # overwrite[3] -remainder = [("0xd5", "0x108000", "32k"), # Right-end of partial-left [1] - ("0xdc", "32M", "32k"), # Left-end of partial-right [2] - ("0xcd", "0x3ff0000", "64k")] # patterns[3] +remainder = [('0xd5', '0x108000', '32k'), # Right-end of partial-left [1] + ('0xdc', '32M', '32k'), # Left-end of partial-right [2] + ('0xcd', '0x3ff0000', '64k')] # patterns[3] with iotests.FilePath('base.img') as base_img_path, \ iotests.FilePath('fleece.img') as fleece_img_path, \
@@ -58,7 +58,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') assert qemu_img('create', '-f', iotests.imgfmt, base_img_path, '64M') == 0 - assert qemu_img('create', '-f', "qcow2", fleece_img_path, '64M') == 0 + assert qemu_img('create', '-f', 'qcow2', fleece_img_path, '64M') == 0 for p in patterns: qemu_io('-f', iotests.imgfmt,
@@ -78,43 +78,43 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Setting up Fleecing Graph ---') log('') - src_node = "drive0" - tgt_node = "fleeceNode" + src_node = 'drive0' + tgt_node = 'fleeceNode' # create tgt_node backed by src_node - log(vm.qmp("blockdev-add", { - "driver": "qcow2", - "node-name": tgt_node, - "file": { - "driver": "file", - "filename": fleece_img_path, + log(vm.qmp('blockdev-add', { + 'driver': 'qcow2', + 'node-name': tgt_node, + 'file': { + 'driver': 'file', + 'filename': fleece_img_path, }, - "backing": src_node, + 'backing': src_node, })) # Establish COW from source to fleecing node - log(vm.qmp("blockdev-backup", + log(vm.qmp('blockdev-backup', device=src_node, target=tgt_node, - sync="none")) + sync='none')) log('') log('--- Setting up NBD Export ---') log('') nbd_uri = 'nbd+unix:///%s?socket=%s' % (tgt_node, nbd_sock_path) - log(vm.qmp("nbd-server-start", - {"addr": { "type": "unix", - "data": { "path": nbd_sock_path } } })) + log(vm.qmp('nbd-server-start', + {'addr': { 'type': 'unix', + 'data': { 'path': nbd_sock_path } } })) - log(vm.qmp("nbd-server-add", device=tgt_node)) + log(vm.qmp('nbd-server-add', device=tgt_node)) log('') log('--- Sanity Check ---') log('') for p in patterns + zeroes: - cmd = "read -P%s %s %s" % p + cmd = 'read -P%s %s %s' % p log(cmd) assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
@@ -123,7 +123,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') for p in overwrite: - cmd = "write -P%s %s %s" % p + cmd = 'write -P%s %s %s' % p log(cmd) log(vm.hmp_qemu_io(src_node, cmd))
@@ -132,7 +132,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') for p in patterns + zeroes: - cmd = "read -P%s %s %s" % p + cmd = 'read -P%s %s %s' % p log(cmd) assert qemu_io_silent('-r', '-f', 'raw', '-c', cmd, nbd_uri) == 0
@@ -153,7 +153,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') for p in overwrite + remainder: - cmd = "read -P%s %s %s" % p + cmd = 'read -P%s %s %s' % p log(cmd) assert qemu_io_silent(base_img_path, '-c', cmd) == 0
Signature · 1 line
2.29.2
PATCH v8 28/34 iotests: move 222 to tests/image-fleecing
In reply to Vladimir Sementsov-OgievskiyGive a good name to test file.
---
tests/qemu-iotests/{222 => tests/image-fleecing} | 0
tests/qemu-iotests/{222.out => tests/image-fleecing.out} | 0
2 files changed, 0 insertions(+), 0 deletions(-)
rename tests/qemu-iotests/{222 => tests/image-fleecing} (100%)
rename tests/qemu-iotests/{222.out => tests/image-fleecing.out} (100%)tests/qemu-iotests/tests/image-fleecing renamed from tests/qemu-iotests/222 +0 -0
tests/qemu-iotests/tests/image-fleecing.out renamed from tests/qemu-iotests/222.out +0 -0
Signature · 1 line
2.29.2
Re: [PATCH v8 28/34] iotests: move 222 to tests/image-fleecing
tests/qemu-iotests/tests/image-fleecing.out
Quoted 19 lines · Vladimir Sementsov-Ogievskiy
Give a good name to test file.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>--- tests/qemu-iotests/{222 => tests/image-fleecing} | 0 tests/qemu-iotests/{222.out => tests/image-fleecing.out} | 0 2 files changed, 0 insertions(+), 0 deletions(-)rename tests/qemu-iotests/{222 => tests/image-fleecing} (100%) rename tests/qemu-iotests/{222.out => tests/image-fleecing.out} (100%)
tests/qemu-iotests/tests/image-fleecing renamed from tests/qemu-iotests/222 +0
-0tests/qemu-iotests/tests/image-fleecing.out renamed from tests/qemu-iotests/222.out +0
-0
Good news: Including error-report.h helped with most of the CI errors.
“Bad” news: .gitlab-ci.d/buildtest.yml has a complete ./check command line including test numbers... Not sure if that’s a great idea, but in any case, this means that build-tcg-disabled fails because that command line includes 222. I think the fix should be simply to replace 222 by image-fleecing. I hope that’s alright for you?
Hanna
Re: [PATCH v8 28/34] iotests: move 222 to tests/image-fleecing
Quoted 23 lines · Hanna Reitz
tests/qemu-iotests/tests/image-fleecing.out
Quoted 19 lines · Vladimir Sementsov-Ogievskiy
Give a good name to test file.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>---
tests/qemu-iotests/{222 => tests/image-fleecing} | 0 tests/qemu-iotests/{222.out => tests/image-fleecing.out} | 02 files changed, 0 insertions(+), 0 deletions(-)rename tests/qemu-iotests/{222 => tests/image-fleecing} (100%) rename tests/qemu-iotests/{222.out => tests/image-fleecing.out} (100%)
tests/qemu-iotests/tests/image-fleecing renamed from tests/qemu-iotests/222 +0
-0tests/qemu-iotests/tests/image-fleecing.out renamed from tests/qemu-iotests/222.out +0
-0Good news: Including
error-report.hhelped with most of the CI errors.
Quoted 2 lines
“Bad” news:
.gitlab-ci.d/buildtest.ymlhas a complete ./check command line including test numbers... Not sure if that’s a great idea, but in any case, this means that build-tcg-disabled fails because that command line includes 222. I think the fix should be simply to replace 222 by image-fleecing. I hope that’s alright for you?
Yes, that's OK, thanks
Unpredictable thing :( A reminder to always grep for file name when rename it..
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v8 28/34] iotests: move 222 to tests/image-fleecing
Quoted 24 lines · Vladimir Sementsov-Ogievskiy
Quoted 23 lines · Hanna Reitz
tests/qemu-iotests/tests/image-fleecing.out
Quoted 19 lines · Vladimir Sementsov-Ogievskiy
Give a good name to test file.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>---
tests/qemu-iotests/{222 => tests/image-fleecing} | 0 tests/qemu-iotests/{222.out => tests/image-fleecing.out} | 02 files changed, 0 insertions(+), 0 deletions(-)rename tests/qemu-iotests/{222 => tests/image-fleecing} (100%) rename tests/qemu-iotests/{222.out => tests/image-fleecing.out} (100%)
tests/qemu-iotests/tests/image-fleecing renamed from tests/qemu-iotests/222 +0
-0tests/qemu-iotests/tests/image-fleecing.out renamed from tests/qemu-iotests/222.out +0
-0Good news: Including
error-report.hhelped with most of the CI errors.
Quoted 6 lines
Quoted 2 lines
“Bad” news:
.gitlab-ci.d/buildtest.ymlhas a complete ./check command line including test numbers... Not sure if that’s a great idea, but in any case, this means that build-tcg-disabled fails because that command line includes 222. I think the fix should be simply to replace 222 by image-fleecing. I hope that’s alright for you?Yes, that's OK, thanks
Unpredictable thing :( A reminder to always grep for file name when rename it..
Yeah, but in this case... Grepping for three-digit-numbers is just a pain. (And grepping for “check” is not much better. “./check” works reasonably well, but if someone invokes it differently somewhere, I will have missed it.)
Hanna
Re: [PATCH v8 28/34] iotests: move 222 to tests/image-fleecing
In reply to Hanna ReitzQuoted 23 lines · Hanna Reitz
tests/qemu-iotests/tests/image-fleecing.out
Quoted 19 lines · Vladimir Sementsov-Ogievskiy
Give a good name to test file.
Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Max Reitz <[email protected]>--- tests/qemu-iotests/{222 => tests/image-fleecing} | 0 tests/qemu-iotests/{222.out => tests/image-fleecing.out} | 0 2 files changed, 0 insertions(+), 0 deletions(-)rename tests/qemu-iotests/{222 => tests/image-fleecing} (100%) rename tests/qemu-iotests/{222.out => tests/image-fleecing.out} (100%)
tests/qemu-iotests/tests/image-fleecing renamed from tests/qemu-iotests/222 +0
-0tests/qemu-iotests/tests/image-fleecing.out renamed from tests/qemu-iotests/222.out +0
-0Good news: Including
error-report.hhelped with most of the CI errors.
Quoted 5 lines
“Bad” news:
.gitlab-ci.d/buildtest.ymlhas a complete ./check command line including test numbers... Not sure if that’s a great idea, but in any case, this means that build-tcg-disabled fails because that command line includes 222. I think the fix should be simply to replace 222 by image-fleecing. I hope that’s alright for you?
Yeah, I don't really like that we have a set of test numbers in the gitlab CI config file.
We have a 'group' concept for IO tests that works perfectly well.
If one of the existing groups doesn't work, then we should create a new "ci" group, so users running 'check' directly can accurately replicate the CI env without typiing out a set of test numbers.
Regards,
Daniel
Signature · 3 lines
|: https://berrange.com -o- https://www.flickr.com/photos/dberrange :| |: https://libvirt.org -o- https://fstop138.berrange.com :| |: https://entangle-photo.org -o- https://www.instagram.com/dberrange :|
PATCH v8 29/34 iotests.py: hmp_qemu_io: support qdev
In reply to Vladimir Sementsov-Ogievskiy--- tests/qemu-iotests/iotests.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
tests/qemu-iotests/iotests.py +3 -2
@@ -651,9 +651,10 @@ def resume_drive(self, drive: str) -> None: self.hmp(f'qemu-io {drive} "remove_break bp_{drive}"') def hmp_qemu_io(self, drive: str, cmd: str, - use_log: bool = False) -> QMPMessage: + use_log: bool = False, qdev: bool = False) -> QMPMessage: """Write to a given drive using an HMP command""" - return self.hmp(f'qemu-io {drive} "{cmd}"', use_log=use_log) + d = '-d ' if qdev else '' + return self.hmp(f'qemu-io {d}{drive} "{cmd}"', use_log=use_log) def flatten_qmp_object(self, obj, output=None, basestr=''): if output is None:
Signature · 1 line
2.29.2
PATCH v8 30/34 iotests/image-fleecing: proper source device
In reply to Vladimir Sementsov-OgievskiyDefine scsi device to operate with it by qom-set in further patch.
Give a new node-name to source block node, to not look like device name.
Job now don't want to work without giving explicit id, so, let's call it "fleecing".
--- tests/qemu-iotests/tests/image-fleecing | 12 ++++++++---- tests/qemu-iotests/tests/image-fleecing.out | 2 +- 2 files changed, 9 insertions(+), 5 deletions(-)
tests/qemu-iotests/tests/image-fleecing +8 -4
@@ -70,7 +70,11 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Launching VM ---') log('') - vm.add_drive(base_img_path) + src_node = 'source' + vm.add_blockdev(f'driver={iotests.imgfmt},file.driver=file,' + f'file.filename={base_img_path},node-name={src_node}') + vm.add_device('virtio-scsi') + vm.add_device(f'scsi-hd,id=sda,drive={src_node}') vm.launch() log('Done')
@@ -78,7 +82,6 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Setting up Fleecing Graph ---') log('') - src_node = 'drive0' tgt_node = 'fleeceNode' # create tgt_node backed by src_node
@@ -94,6 +97,7 @@ with iotests.FilePath('base.img') as base_img_path, \ # Establish COW from source to fleecing node log(vm.qmp('blockdev-backup', + job_id='fleecing', device=src_node, target=tgt_node, sync='none'))
@@ -125,7 +129,7 @@ with iotests.FilePath('base.img') as base_img_path, \ for p in overwrite: cmd = 'write -P%s %s %s' % p log(cmd) - log(vm.hmp_qemu_io(src_node, cmd)) + log(vm.hmp_qemu_io('/machine/peripheral/sda', cmd, qdev=True)) log('') log('--- Verifying Data ---')
@@ -140,7 +144,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Cleanup ---') log('') - log(vm.qmp('block-job-cancel', device=src_node)) + log(vm.qmp('block-job-cancel', device='fleecing')) e = vm.event_wait('BLOCK_JOB_CANCELLED') assert e is not None log(e, filters=[iotests.filter_qmp_event])
tests/qemu-iotests/tests/image-fleecing.out +1 -1
@@ -50,7 +50,7 @@ read -P0 0x3fe0000 64k --- Cleanup --- {"return": {}} -{"data": {"device": "drive0", "len": 67108864, "offset": 393216, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} +{"data": {"device": "fleecing", "len": 67108864, "offset": 393216, "speed": 0, "type": "backup"}, "event": "BLOCK_JOB_CANCELLED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}} {"return": {}} {"return": {}}
Signature · 1 line
2.29.2
PATCH v8 31/34 iotests/image-fleecing: rename tgt_node
In reply to Vladimir Sementsov-OgievskiyActually target of backup(sync=None) is not a final backup target:
image fleecing is intended to be used with external tool, which will copy data from fleecing node to some real backup target.
Also, we are going to add a test case for "push backup with fleecing", where instead of exporting fleecing node by NBD, we'll start a backup job from fleecing node to real backup target.
To avoid confusion, let's rename temporary fleecing node now.
--- tests/qemu-iotests/tests/image-fleecing | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
tests/qemu-iotests/tests/image-fleecing +7 -7
@@ -71,6 +71,7 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') src_node = 'source' + tmp_node = 'temp' vm.add_blockdev(f'driver={iotests.imgfmt},file.driver=file,' f'file.filename={base_img_path},node-name={src_node}') vm.add_device('virtio-scsi')
@@ -82,12 +83,11 @@ with iotests.FilePath('base.img') as base_img_path, \ log('--- Setting up Fleecing Graph ---') log('') - tgt_node = 'fleeceNode' - # create tgt_node backed by src_node + # create tmp_node backed by src_node log(vm.qmp('blockdev-add', { 'driver': 'qcow2', - 'node-name': tgt_node, + 'node-name': tmp_node, 'file': { 'driver': 'file', 'filename': fleece_img_path,
@@ -99,19 +99,19 @@ with iotests.FilePath('base.img') as base_img_path, \ log(vm.qmp('blockdev-backup', job_id='fleecing', device=src_node, - target=tgt_node, + target=tmp_node, sync='none')) log('') log('--- Setting up NBD Export ---') log('') - nbd_uri = 'nbd+unix:///%s?socket=%s' % (tgt_node, nbd_sock_path) + nbd_uri = 'nbd+unix:///%s?socket=%s' % (tmp_node, nbd_sock_path) log(vm.qmp('nbd-server-start', {'addr': { 'type': 'unix', 'data': { 'path': nbd_sock_path } } })) - log(vm.qmp('nbd-server-add', device=tgt_node)) + log(vm.qmp('nbd-server-add', device=tmp_node)) log('') log('--- Sanity Check ---')
@@ -149,7 +149,7 @@ with iotests.FilePath('base.img') as base_img_path, \ assert e is not None log(e, filters=[iotests.filter_qmp_event]) log(vm.qmp('nbd-server-stop')) - log(vm.qmp('blockdev-del', node_name=tgt_node)) + log(vm.qmp('blockdev-del', node_name=tmp_node)) vm.shutdown() log('')
Signature · 1 line
2.29.2
PATCH v8 32/34 iotests/image-fleecing: prepare for adding new test-case
In reply to Vladimir Sementsov-OgievskiyWe are going to add a test-case with some behavior modifications. So, let's prepare a function to be reused.
--- tests/qemu-iotests/tests/image-fleecing | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-)
tests/qemu-iotests/tests/image-fleecing +13 -6
@@ -48,12 +48,7 @@ remainder = [('0xd5', '0x108000', '32k'), # Right-end of partial-left [1] ('0xdc', '32M', '32k'), # Left-end of partial-right [2] ('0xcd', '0x3ff0000', '64k')] # patterns[3] -with iotests.FilePath('base.img') as base_img_path, \ - iotests.FilePath('fleece.img') as fleece_img_path, \ - iotests.FilePath('nbd.sock', - base_dir=iotests.sock_dir) as nbd_sock_path, \ - iotests.VM() as vm: - +def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): log('--- Setting up images ---') log('')
@@ -163,3 +158,15 @@ with iotests.FilePath('base.img') as base_img_path, \ log('') log('Done') + + +def test(): + with iotests.FilePath('base.img') as base_img_path, \ + iotests.FilePath('fleece.img') as fleece_img_path, \ + iotests.FilePath('nbd.sock', + base_dir=iotests.sock_dir) as nbd_sock_path, \ + iotests.VM() as vm: + do_test(base_img_path, fleece_img_path, nbd_sock_path, vm) + + +test()
Signature · 1 line
2.29.2
PATCH v8 33/34 iotests/image-fleecing: add test-case for copy-before-write filter
In reply to Vladimir Sementsov-OgievskiyNew fleecing method becomes available: copy-before-write filter.
Actually we don't need backup job to setup image fleecing. Add test for new recommended way of image fleecing.
--- tests/qemu-iotests/tests/image-fleecing | 50 +++++++++----- tests/qemu-iotests/tests/image-fleecing.out | 72 +++++++++++++++++++++ 2 files changed, 107 insertions(+), 15 deletions(-)
tests/qemu-iotests/tests/image-fleecing +35 -15
@@ -48,7 +48,7 @@ remainder = [('0xd5', '0x108000', '32k'), # Right-end of partial-left [1] ('0xdc', '32M', '32k'), # Left-end of partial-right [2] ('0xcd', '0x3ff0000', '64k')] # patterns[3] -def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): +def do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm): log('--- Setting up images ---') log('')
@@ -67,6 +67,7 @@ def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): src_node = 'source' tmp_node = 'temp' + qom_path = '/machine/peripheral/sda' vm.add_blockdev(f'driver={iotests.imgfmt},file.driver=file,' f'file.filename={base_img_path},node-name={src_node}') vm.add_device('virtio-scsi')
@@ -90,12 +91,22 @@ def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): 'backing': src_node, })) - # Establish COW from source to fleecing node - log(vm.qmp('blockdev-backup', - job_id='fleecing', - device=src_node, - target=tmp_node, - sync='none')) + # Establish CBW from source to fleecing node + if use_cbw: + log(vm.qmp('blockdev-add', { + 'driver': 'copy-before-write', + 'node-name': 'fl-cbw', + 'file': src_node, + 'target': tmp_node + })) + + log(vm.qmp('qom-set', path=qom_path, property='drive', value='fl-cbw')) + else: + log(vm.qmp('blockdev-backup', + job_id='fleecing', + device=src_node, + target=tmp_node, + sync='none')) log('') log('--- Setting up NBD Export ---')
@@ -124,7 +135,7 @@ def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): for p in overwrite: cmd = 'write -P%s %s %s' % p log(cmd) - log(vm.hmp_qemu_io('/machine/peripheral/sda', cmd, qdev=True)) + log(vm.hmp_qemu_io(qom_path, cmd, qdev=True)) log('') log('--- Verifying Data ---')
@@ -139,10 +150,15 @@ def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): log('--- Cleanup ---') log('') - log(vm.qmp('block-job-cancel', device='fleecing')) - e = vm.event_wait('BLOCK_JOB_CANCELLED') - assert e is not None - log(e, filters=[iotests.filter_qmp_event]) + if use_cbw: + log(vm.qmp('qom-set', path=qom_path, property='drive', value=src_node)) + log(vm.qmp('blockdev-del', node_name='fl-cbw')) + else: + log(vm.qmp('block-job-cancel', device='fleecing')) + e = vm.event_wait('BLOCK_JOB_CANCELLED') + assert e is not None + log(e, filters=[iotests.filter_qmp_event]) + log(vm.qmp('nbd-server-stop')) log(vm.qmp('blockdev-del', node_name=tmp_node)) vm.shutdown()
@@ -160,13 +176,17 @@ def do_test(base_img_path, fleece_img_path, nbd_sock_path, vm): log('Done') -def test(): +def test(use_cbw): with iotests.FilePath('base.img') as base_img_path, \ iotests.FilePath('fleece.img') as fleece_img_path, \ iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock_path, \ iotests.VM() as vm: - do_test(base_img_path, fleece_img_path, nbd_sock_path, vm) + do_test(use_cbw, base_img_path, fleece_img_path, nbd_sock_path, vm) + +log('=== Test backup(sync=none) based fleecing ===\n') +test(False) -test() +log('=== Test filter based fleecing ===\n') +test(True)
tests/qemu-iotests/tests/image-fleecing.out +72 -0
78 lines not on this page · raw message
Signature · 1 line
2.29.2
PATCH v8 34/34 block/block-copy: block_copy_state_new(): drop extra arguments
In reply to Vladimir Sementsov-OgievskiyThe only caller pass copy_range and compress both false. Let's just drop these arguments.
--- include/block/block-copy.h | 1 - block/block-copy.c | 5 ++--- block/copy-before-write.c | 2 +- 3 files changed, 3 insertions(+), 5 deletions(-)
include/block/block-copy.h +0 -1
@@ -25,7 +25,6 @@ typedef struct BlockCopyState BlockCopyState;typedef struct BlockCopyCallState BlockCopyCallState ;BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target, -bool use_copy_range,bool compress,Error **errp);/* Function should be called prior any actual copy request */
block/block-copy.c +2 -3
@@ -383,8 +383,7 @@ static int64_t block_copy_calculate_cluster_size(BlockDriverState *target, }BlockCopyState *block_copy_state_new (BdrvChild *source,BdrvChild *target, -bool use_copy_range, -bool compress,Error **errp) +Error **errp) {BlockCopyState *s;int64_t cluster_size;
@@ -433,7 +432,7 @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target, cluster_size), }; -block_copy_set_copy_opts (s, use_copy_range, compress); +block_copy_set_copy_opts (s, false, false);ratelimit_init (&s->rate_limit);qemu_co_mutex_init (&s->lock);
block/copy-before-write.c +1 -1
@@ -170,7 +170,7 @@ static int cbw_open(BlockDriverState *bs, QDict *options, int flags, ((BDRV_REQ_FUA |BDRV_REQ_MAY_UNMAP |BDRV_REQ_NO_FALLBACK ) & bs->file->bs->supported_zero_flags); - s->bcs =block_copy_state_new (bs->file, s->target, false, false, errp); + s->bcs =block_copy_state_new (bs->file, s->target, errp);if (!s->bcs) {error_prepend (errp,"Cannot create block-copy-state: " );return -EINVAL ;
Signature · 1 line
2.29.2
Re: [PATCH v8 34/34] block/block-copy: block_copy_state_new(): drop extra arguments
Quoted 9 lines · Vladimir Sementsov-Ogievskiy
The only caller pass
copy_rangeand compress both false. Let's just drop these arguments.Signed-off-by Vladimir Sementsov-Ogievskiy <[email protected]>--- include/block/block-copy.h | 1 - block/block-copy.c | 5 ++--- block/copy-before-write.c | 2 +- 3 files changed, 3 insertions(+), 5 deletions(-)
Quoted 12 lines · Vladimir Sementsov-Ogievskiy
Hi all!
v8:
06: add Hanna's r-b
07: keepis_fleecingdetection in_new()function
08,17,18: add Hanna's r-b
19: wording, s/6.1/6.2/, add Markus's a-b
25: new
29: add John's r-b
34: new
Quoted 1 line
Patches without r-b: 07, 25, 34
Thanks! I’ve applied the series to my block-next branch:
https://github.com/XanClic/qemu/commits/block-next
Hanna
Quoted 13 lines · Hanna Reitz
Quoted 12 lines · Vladimir Sementsov-Ogievskiy
Hi all!
v8:
06: add Hanna's r-b
07: keepis_fleecingdetection in_new()function
08,17,18: add Hanna's r-b
19: wording, s/6.1/6.2/, add Markus's a-b
25: new
29: add John's r-b
34: new
Quoted 8 lines
Quoted 1 line
Patches without r-b: 07, 25, 34
Thanks! I’ve applied the series to my block-next branch:
https://github.com/XanClic/qemu/commits/block-next
Hanna
Thanks for reviewing!
Signature · 2 lines
Best regards, Vladimir