block: Deal with filters
v8 cover block: Deal with filters
v6: https://lists.nongnu.org/archive/html/qemu-devel/2019-08/msg01715.html
v7: https://lists.nongnu.org/archive/html/qemu-block/2020-06/msg01357.html
Branch: https://github.com/XanClic/qemu.git child-access-functions-v8
Branch: https://git.xanclic.moe/XanClic/qemu.git child-access-functions-v8
Hi,
In v8, there is not too much that has changed in respect to v7. I tried to address all of your comments and hope I got it right. I also hope I got the R-bs right.
Changes from v7:
- Patch 1: Let bdrv_primary_child() assert that there’s only a single primary child
- Patch 2: Assert that bdrv_do_skip_filters() will not return a filter node
- Patch 3: Drop bdrv_unallocated_blocks_are_zero() hunk (that function no longer exists)
- Old patch 10: Dropped, it isn’t really important to let mirror-top support compressed writes, and bdrv_supports_compressed_writes() doesn’t really work with this patch
- Old patch 11: Dropped, it isn’t really important to let backup-top support compressed writes
- Patch 10: Rebase conflict in init_dirty_bitmap_migration() (The modified block is now nested one level deeper)
- Patch 11: Rebase conflict in bdrv_co_block_status() (bdrv_unallocated_blocks_are_zero() is no longer used)
- Patch 12:
- Fix documentation on what the backing node after streaming is going to be
- bdrv_change_backing_file() rebase conflict
- Patch 13: Try to clarify what bdrv_find_overlay() returns in its doc comment
- Patch 15: Optimize the overlay_bs finding loop
- Old patch 25: Rolled into the next patch (now patch 23)
- Patch 23:
- Inline two of the three functions introduced in the old patch 25
- The other one (bdrv_sum_allocated_file_size()) stays, but is static now
(Turns out we don’t need to let block drivers use any of these functions for their BlockDriver.bdrv_get_allocated_File_size().)
- Old patch 27: Dropped, just let blkverify be handled like any other filter, because it doesn’t matter, really (and this allows us squashing the previous to patches)
- Patch 24: Remove _filter_actual_image_size from iotest 184
- Patch 27: Reference output change due to 184 no longer invoking _filter_actual_image_size
- Patch 29:
- Let the commit message explain why base_overlay is introduced
- Drop @replaces_node_name from qmp_drive_mirror(), because it isn’t needed
- Patch 31:
- Let blk_commit_all() only commit those nodes that have a backing file; and ignore all filters on top of them (instead of just implicit filters)
- In commit_start: %s/\<perms\>/base_perms/
- Under commit_start.ro_cleanup: Restore the original backing file only if necessary, so we do not run into an abort because the backing chain is frozen
- Patch 33: Let img_rebase() refer to the unfiltered_bs in three more places
- Patch 35:
- Documentation modifications:
- Move a chunk of it up where it belongs (from below @backing-file to the general area of @block-commit)
- Explain that you now need to issue block-job-complete whenever there’s a writer on @top
- Also, @backing-file is no longer allowed whenever there’s a writer on @top
- In the code, this should cause a different error message than when @top is in the active layer, though
- Comment note: If @top is a root node without any writers on it, we still need to do an active commit, because everything else would be an incompatible change
- Patch 36: Trivial rebase conflict in block_int.h (necessary because the old patch 25 was dropped)
- Patch 37: Don’t try to fetch ImageInfo.backing-filename-format from the backing file open at runtime. If the image header does not specify a format, just leave it empty.
- Patch 40: Use format string instead of ''.format()
- Patch 42: Add -F $IMGFMT to _make_test_img -b
git-backport-diff against v7:
Key:
[----] : patches are identical
[####] : number of functional differences between upstream/downstream patch [down] : patch is downstream-only
The flags [FC] indicate (F)unctional and (C)ontextual differences, respectively
001/43:[0007] [FC] 'block: Add child access functions' 002/43:[0007] [FC] 'block: Add chain helper functions' 003/43:[0002] [FC] 'block: bdrv_cow_child() for bdrv_has_zero_init()' 004/43:[----] [--] 'block: bdrv_set_backing_hd() is about bs->backing' 005/43:[----] [--] 'block: Include filters when freezing backing chain' 006/43:[----] [--] 'block: Drop bdrv_is_encrypted()' 007/43:[----] [--] 'block: Add bdrv_supports_compressed_writes()' 008/43:[----] [--] 'throttle: Support compressed writes' 009/43:[----] [--] 'copy-on-read: Support compressed writes' 010/43:[0016] [FC] 'block: Use bdrv_filter_(bs|child) where obvious' 011/43:[0008] [FC] 'block: Use CAFs in block status functions' 012/43:[0017] [FC] 'stream: Deal with filters'
013/43:[0007] [FC] 'block: Use CAFs when working with backing chains' 014/43:[----] [--] 'block: Use bdrv_cow_child() in bdrv_co_truncate()' 015/43:[0009] [FC] 'block: Re-evaluate backing file handling in reopen' 016/43:[----] [--] 'block: Flush all children in generic code' 017/43:[----] [--] 'vmdk: Drop vmdk_co_flush()' 018/43:[----] [--] 'block: Iterate over children in refresh_limits' 019/43:[----] [--] 'block: Use CAFs in bdrv_refresh_filename()' 020/43:[----] [--] 'block: Use CAF in bdrv_co_rw_vmstate()' 021/43:[----] [--] 'block/snapshot: Fix fallback' 022/43:[----] [--] 'block: Use CAFs for debug breakpoints' 023/43:[0031] [FC] 'block: Improve get_allocated_file_size's default' 024/43:[0007] [FC] 'block/null: Implement bdrv_get_allocated_file_size' 025/43:[----] [--] 'blockdev: Use CAF in external_snapshot_prepare()' 026/43:[----] [--] 'block: Report data child for query-blockstats' 027/43:[0002] [FC] 'block: Use child access functions for QAPI queries' 028/43:[----] [--] 'block-copy: Use CAF to find sync=top base' 029/43:[0004] [FC] 'mirror: Deal with filters'
030/43:[----] [--] 'backup: Deal with filters'
031/43:[0020] [FC] 'commit: Deal with filters'
032/43:[----] [--] 'nbd: Use CAF when looking for dirty bitmap' 033/43:[0007] [FC] 'qemu-img: Use child access functions' 034/43:[----] [--] 'block: Drop backing_bs()'
035/43:[0052] [FC] 'blockdev: Fix active commit choice' 036/43:[0001] [FC] 'block: Inline bdrv_co_block_status_from_*()' 037/43:[0013] [FC] 'block: Leave BDS.backing_file constant' 038/43:[----] [--] 'iotests: Test that qcow2's data-file is flushed' 039/43:[----] [--] 'iotests: Let complete_and_wait() work with commit' 040/43:[0004] [FC] 'iotests: Add filter commit test cases' 041/43:[----] [--] 'iotests: Add filter mirror test cases' 042/43:[0008] [FC] 'iotests: Add test for commit in sub directory' 043/43:[----] [--] 'iotests: Test committing to overridden backing'
Max Reitz (43):
block: Add child access functions
block: Add chain helper functions
block: bdrv_cow_child() for bdrv_has_zero_init()
block: bdrv_set_backing_hd() is about bs->backing
block: Include filters when freezing backing chain
block: Drop bdrv_is_encrypted()
block: Add bdrv_supports_compressed_writes()
throttle: Support compressed writes
copy-on-read: Support compressed writes
block: Use bdrv_filter_(bs|child) where obvious
block: Use CAFs in block status functions
stream: Deal with filters
block: Use CAFs when working with backing chains
block: Use bdrv_cow_child() in bdrv_co_truncate()
block: Re-evaluate backing file handling in reopen
block: Flush all children in generic code
vmdk: Drop vmdk_co_flush()
block: Iterate over children in refresh_limits
block: Use CAFs in bdrv_refresh_filename()
block: Use CAF in bdrv_co_rw_vmstate() block/snapshot: Fix fallback
block: Use CAFs for debug breakpoints
block: Improve get_allocated_file_size's default block/null: Implement bdrv_get_allocated_file_size
blockdev: Use CAF in external_snapshot_prepare()
block: Report data child for query-blockstats
block: Use child access functions for QAPI queries
block-copy: Use CAF to find sync=top base
mirror: Deal with filters
backup: Deal with filters
commit: Deal with filters
nbd: Use CAF when looking for dirty bitmap
qemu-img: Use child access functions
block: Drop backing_bs()
blockdev: Fix active commit choice
block: Inline bdrv_co_block_status_from_*()
block: Leave BDS.backing_{file,format} constant
iotests: Test that qcow2's data-file is flushed
iotests: Let complete_and_wait() work with commit
iotests: Add filter commit test cases
iotests: Add filter mirror test cases
iotests: Add test for commit in sub directory
iotests: Test committing to overridden backing
qapi/block-core.json | 58 ++-- include/block/block.h | 2 +- include/block/block_int.h | 95 ++++--- block.c | 488 ++++++++++++++++++++++++++------- block/backup-top.c | 4 +- block/backup.c | 9 +- block/blkdebug.c | 7 +- block/blklogwrites.c | 1 - block/block-backend.c | 7 +- block/block-copy.c | 4 +- block/commit.c | 95 +++++-- block/copy-on-read.c | 13 +- block/filter-compress.c | 2 - block/io.c | 142 +++++----- block/mirror.c | 119 ++++++-- block/monitor/block-hmp-cmds.c | 2 +- block/null.c | 7 + block/qapi.c | 74 +++-- block/snapshot.c | 104 +++++-- block/stream.c | 63 +++-- block/throttle.c | 11 +- block/vmdk.c | 16 -- blockdev.c | 101 +++++-- migration/block-dirty-bitmap.c | 8 +- nbd/server.c | 6 +- qemu-img.c | 43 +-- tests/qemu-iotests/020 | 44 +++ tests/qemu-iotests/020.out | 10 + tests/qemu-iotests/040 | 238 ++++++++++++++++ tests/qemu-iotests/040.out | 4 +- tests/qemu-iotests/041 | 146 +++++++++- tests/qemu-iotests/041.out | 4 +- tests/qemu-iotests/153.out | 2 +- tests/qemu-iotests/184 | 3 +- tests/qemu-iotests/184.out | 14 +- tests/qemu-iotests/204.out | 1 + tests/qemu-iotests/228 | 6 +- tests/qemu-iotests/228.out | 6 +- tests/qemu-iotests/244 | 49 ++++ tests/qemu-iotests/244.out | 7 + tests/qemu-iotests/245 | 4 +- tests/qemu-iotests/273.out | 4 +- tests/qemu-iotests/iotests.py | 10 +- 43 files changed, 1591 insertions(+), 442 deletions(-)
Signature · 1 line
2.26.2
PATCH v8 1/43 block: Add child access functions
There are BDS children that the general block layer code can access, namely bs->file and bs->backing. Since the introduction of filters and external data files, their meaning is not quite clear. bs->backing can be a COW source, or it can be a filtered child; bs->file can be a filtered child, it can be data and metadata storage, or it can be just metadata storage.
This overloading really is not helpful. This patch adds functions that retrieve the correct child for each exact purpose. Later patches in this series will make use of them. Doing so will allow us to handle filter nodes in a meaningful way.
--- include/block/block_int.h | 44 +++++++++++++++++-- block.c | 91 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 132 insertions(+), 3 deletions(-)
include/block/block_int.h +41 -3
@@ -92,9 +92,17 @@ struct BlockDriver {int instance_size;/* set to true if the BlockDriver is a block filter. Block filters pass -* certain callbacks that refer to data (see block.c) to their bs->file if -* the driver doesn't implement them. Drivers that do not wish to forward -* must implement them and return -ENOTSUP. +* certain callbacks that refer to data (see block.c) to their bs->file +* or bs->backing (whichever one exists) if the driver doesn't implement +* them. Drivers that do not wish to forward must implement them and return +* -ENOTSUP. +* Note that filters are not allowed to modify data. +* +* Filters generally cannot have more than a single filtered child, +* because the data they present must at all times be the same as +* that on their filtered child. That would be impossible to +* achieve for multiple filtered children. +* (And this filtered child must then be bs->file or bs->backing.) */ bool is_filter;/*
@@ -1382,4 +1390,34 @@ BdrvDirtyBitmap *block_dirty_bitmap_remove(const char *node, const char *name, BlockDriverState **bitmap_bs, Error **errp); +BdrvChild *bdrv_cow_child (BlockDriverState *bs); +BdrvChild *bdrv_filter_child (BlockDriverState *bs); +BdrvChild *bdrv_filter_or_cow_child (BlockDriverState *bs); +BdrvChild *bdrv_primary_child (BlockDriverState *bs); + +static inline BlockDriverState *child_bs (BdrvChild *child) +{ +return child ? child->bs :NULL ; +} + +static inline BlockDriverState *bdrv_cow_bs (BlockDriverState *bs) +{ +return child_bs (bdrv_cow_child (bs)); +} + +static inline BlockDriverState *bdrv_filter_bs (BlockDriverState *bs) +{ +return child_bs (bdrv_filter_child (bs)); +} + +static inline BlockDriverState *bdrv_filter_or_cow_bs (BlockDriverState *bs) +{ +return child_bs (bdrv_filter_or_cow_child (bs)); +} + +static inline BlockDriverState *bdrv_primary_bs (BlockDriverState *bs) +{ +return child_bs (bdrv_primary_child (bs)); +} +#endif /* BLOCK_INT_H */
block.c +91 -0
94 lines not on this page · raw message
Signature · 1 line
2.26.2
PATCH v8 2/43 block: Add chain helper functions
In reply to Max ReitzAdd some helper functions for skipping filters in a chain of block nodes.
--- include/block/block_int.h | 3 ++ block.c | 62 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+)
include/block/block_int.h +3 -0
@@ -1394,6 +1394,9 @@ BdrvChild *bdrv_cow_child(BlockDriverState *bs);BdrvChild *bdrv_filter_child (BlockDriverState *bs);BdrvChild *bdrv_filter_or_cow_child (BlockDriverState *bs);BdrvChild *bdrv_primary_child (BlockDriverState *bs); +BlockDriverState *bdrv_skip_implicit_filters (BlockDriverState *bs); +BlockDriverState *bdrv_skip_filters (BlockDriverState *bs); +BlockDriverState *bdrv_backing_chain_next (BlockDriverState *bs);static inline BlockDriverState *child_bs (BdrvChild *child) {
block.c +62 -0
65 lines not on this page · raw message
Signature · 1 line
2.26.2
PATCH v8 3/43 block: bdrv_cow_child() for bdrv_has_zero_init()
In reply to Max Reitzbdrv_has_zero_init() should use bdrv_cow_child() if it wants to check whether the given BDS has a COW backing file.
--- block.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
block.c +1 -1
@@ -5415,7 +5415,7 @@ int bdrv_has_zero_init(BlockDriverState *bs)/* If BS is a copy on write image, it is initialized to the contents of the base image, which may not be zeroes. */ -if (bs->backing) { +if (bdrv_cow_child (bs)) {return 0 ; }if (bs->drv->bdrv_has_zero_init) {
Signature · 1 line
2.26.2
PATCH v8 4/43 block: bdrv_set_backing_hd() is about bs->backing
In reply to Max Reitzbdrv_set_backing_hd() is a function that explicitly cares about the bs->backing child. Highlight that in its description and use child_bs(bs->backing) instead of backing_bs(bs) to make it more obvious.
--- block.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
block.c +2 -2
@@ -2863,7 +2863,7 @@ static BdrvChildRole bdrv_backing_role(BlockDriverState *bs) }/* -* Sets the backing file link of a BDS. A new reference is created; callers +* Sets the bs->backing link of a BDS. A new reference is created; callers * which don't need their own reference any more must call bdrv_unref(). */ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,
@@ -2872,7 +2872,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,bool update_inherits_from =bdrv_chain_contains (bs, backing_hd) &&bdrv_inherits_from_recursive (backing_hd, bs); -if (bdrv_is_backing_chain_frozen (bs,backing_bs (bs), errp)) { +if (bdrv_is_backing_chain_frozen (bs,child_bs (bs->backing), errp)) {return ; }
Signature · 1 line
2.26.2
PATCH v8 5/43 block: Include filters when freezing backing chain
In reply to Max ReitzIn order to make filters work in backing chains, the associated functions must be able to deal with them and freeze both COW and filter child links.
While at it, add some comments that note which functions require their caller to ensure that a given child link is not frozen, and how the callers do so.
--- block.c | 60 +++++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 39 insertions(+), 21 deletions(-)
block.c +39 -21
@@ -2612,12 +2612,15 @@ static void bdrv_replace_child_noperm(BdrvChild *child,* If @new_bs is not NULL, bdrv_check_perm() must be called beforehand, as this * function uses bdrv_set_perm() to update the permissions according to the new * reference that @new_bs gets. +* +* Callers must ensure that child->frozen is false. */ static void bdrv_replace_child (BdrvChild *child,BlockDriverState *new_bs) {BlockDriverState *old_bs = child->bs;uint64_t perm, shared_perm; +/* Asserts that child->frozen == false */ bdrv_replace_child_noperm (child, new_bs);/*
@@ -2778,6 +2781,7 @@ static void bdrv_detach_child(BdrvChild *child)g_free (child); } +/* Callers must ensure that child->frozen is false. */ void bdrv_root_unref_child (BdrvChild *child) {BlockDriverState *child_bs;
@@ -2815,6 +2819,7 @@ static void bdrv_unset_inherits_from(BlockDriverState *root, BdrvChild *child) } } +/* Callers must ensure that child->frozen is false. */ void bdrv_unref_child (BlockDriverState *parent,BdrvChild *child) {if (child ==NULL ) {
@@ -2881,6 +2886,7 @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd, }if (bs->backing) { +/* Cannot be frozen, we checked that above */ bdrv_unref_child (bs, bs->backing); bs->backing =NULL ; }
@@ -4387,6 +4393,7 @@ static void bdrv_close(BlockDriverState *bs)if (bs->drv) {if (bs->drv->bdrv_close) { +/* Must unfreeze all children, so bdrv_unref_child() works */ bs->drv->bdrv_close (bs); } bs->drv =NULL ;
@@ -4762,20 +4769,22 @@ BlockDriverState *bdrv_find_base(BlockDriverState *bs) }/* -* Return true if at least one of the backing links between @bs and -* @base is frozen. @errp is set if that's the case. +* Return true if at least one of the COW (backing) and filter links +* between @bs and @base is frozen. @errp is set if that's the case. * @base must be reachable from @bs, or NULL. */ bool bdrv_is_backing_chain_frozen (BlockDriverState *bs,BlockDriverState *base,Error **errp) {BlockDriverState *i; +BdrvChild *child; -for (i = bs; i != base; i =backing_bs (i)) { -if (i->backing && i->backing->frozen) { +for (i = bs; i != base; i =child_bs (child)) { + child =bdrv_filter_or_cow_child (i); + +if (child && child->frozen) {error_setg (errp,"Cannot change '%s' link from '%s' to '%s'" , - i->backing->name, i->node_name, -backing_bs (i)->node_name); + child->name, i->node_name, child->bs->node_name);return true; } }
@@ -4784,7 +4793,7 @@ bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base, }/* -* Freeze all backing links between @bs and @base. +* Freeze all COW (backing) and filter links between @bs and @base. * If any of the links is already frozen the operation is aborted and * none of the links are modified. * @base must be reachable from @bs, or NULL.
@@ -4794,22 +4803,25 @@ int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base, Error **errp) {BlockDriverState *i; +BdrvChild *child;if (bdrv_is_backing_chain_frozen (bs, base, errp)) {return -EPERM ; } -for (i = bs; i != base; i =backing_bs (i)) { -if (i->backing &&backing_bs (i)->never_freeze) { +for (i = bs; i != base; i =child_bs (child)) { + child =bdrv_filter_or_cow_child (i); +if (child && child->bs->never_freeze) {error_setg (errp,"Cannot freeze '%s' link to '%s'" , - i->backing->name,backing_bs (i)->node_name); + child->name, child->bs->node_name);return -EPERM ; } } -for (i = bs; i != base; i =backing_bs (i)) { -if (i->backing) { - i->backing->frozen = true; +for (i = bs; i != base; i =child_bs (child)) { + child =bdrv_filter_or_cow_child (i); +if (child) { + child->frozen = true; } }
@@ -4817,18 +4829,21 @@ int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base, }/* -* Unfreeze all backing links between @bs and @base. The caller must -* ensure that all links are frozen before using this function. +* Unfreeze all COW (backing) and filter links between @bs and @base. +* The caller must ensure that all links are frozen before using this +* function. * @base must be reachable from @bs, or NULL. */ void bdrv_unfreeze_backing_chain (BlockDriverState *bs,BlockDriverState *base) {BlockDriverState *i; +BdrvChild *child; -for (i = bs; i != base; i =backing_bs (i)) { -if (i->backing) { -assert (i->backing->frozen); - i->backing->frozen = false; +for (i = bs; i != base; i =child_bs (child)) { + child =bdrv_filter_or_cow_child (i); +if (child) { +assert (child->frozen); + child->frozen = false; } } }
@@ -4931,8 +4946,11 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base, } } -/* Do the actual switch in the in-memory graph. -* Completes bdrv_check_update_perm() transaction internally. */ +/* +* Do the actual switch in the in-memory graph. +* Completes bdrv_check_update_perm() transaction internally. +* c->frozen is false, we have checked that above. +*/ bdrv_ref (base);bdrv_replace_child (c, base);bdrv_unref (top);
Signature · 1 line
2.26.2
PATCH v8 6/43 block: Drop bdrv_is_encrypted()
In reply to Max ReitzThe original purpose of bdrv_is_encrypted() was to inquire whether a BDS can be used without the user entering a password or not. It has not been used for that purpose for quite some time.
Actually, it is not even fit for that purpose, because to answer that question, it would have recursively query all of the given node's children.
So now we have to decide in which direction we want to fix bdrv_is_encrypted(): Recursively query all children, or drop it and just use bs->encrypted to get the current node's status?
Nowadays, its only purpose is to report through bdrv_query_image_info() whether the given image is encrypted or not. For this purpose, it is probably more interesting to see whether a given node itself is encrypted or not (otherwise, a management application cannot discern for certain which nodes are really encrypted and which just have encrypted children).
--- include/block/block.h | 1 - block.c | 8 -------- block/qapi.c | 2 +- 3 files changed, 1 insertion(+), 10 deletions(-)
include/block/block.h +0 -1
@@ -532,7 +532,6 @@ BlockDriverState *bdrv_next(BdrvNextIterator *it);void bdrv_next_cleanup (BdrvNextIterator *it);BlockDriverState *bdrv_next_monitor_owned (BlockDriverState *bs); -bool bdrv_is_encrypted (BlockDriverState *bs);void bdrv_iterate_format (void (*it)(void *opaque,const char *name),void *opaque,bool read_only);const char *bdrv_get_node_name (const BlockDriverState *bs);
block.c +0 -8
@@ -5065,14 +5065,6 @@ bool bdrv_is_sg(BlockDriverState *bs)return bs->sg; } -bool bdrv_is_encrypted (BlockDriverState *bs) -{ -if (bs->backing && bs->backing->bs->encrypted) { -return true; - } -return bs->encrypted; -} -const char *bdrv_get_format_name (BlockDriverState *bs) {return bs->drv ? bs->drv->format_name :NULL ;
block/qapi.c +1 -1
@@ -288,7 +288,7 @@ void bdrv_query_image_info(BlockDriverState *bs, info->virtual_size = size; info->actual_size =bdrv_get_allocated_file_size (bs); info->has_actual_size = info->actual_size >=0 ; -if (bdrv_is_encrypted (bs)) { +if (bs->encrypted) { info->encrypted = true; info->has_encrypted = true; }
Signature · 1 line
2.26.2
PATCH v8 7/43 block: Add bdrv_supports_compressed_writes()
In reply to Max ReitzFilters cannot compress data themselves but they have to implement .bdrv_co_pwritev_compressed() still (or they cannot forward compressed writes). Therefore, checking whether bs->drv->bdrv_co_pwritev_compressed is non-NULL is not sufficient to know whether the node can actually handle compressed writes. This function looks down the filter chain to see whether there is a non-filter that can actually convert the compressed writes into compressed data (and thus normal writes).
--- include/block/block.h | 1 + block.c | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+)
include/block/block.h +1 -0
@@ -532,6 +532,7 @@ BlockDriverState *bdrv_next(BdrvNextIterator *it);void bdrv_next_cleanup (BdrvNextIterator *it);BlockDriverState *bdrv_next_monitor_owned (BlockDriverState *bs); +bool bdrv_supports_compressed_writes (BlockDriverState *bs);void bdrv_iterate_format (void (*it)(void *opaque,const char *name),void *opaque,bool read_only);const char *bdrv_get_node_name (const BlockDriverState *bs);
block.c +23 -0
@@ -5065,6 +5065,29 @@ bool bdrv_is_sg(BlockDriverState *bs)return bs->sg; } +/** +* Return whether the given node supports compressed writes. +*/ +bool bdrv_supports_compressed_writes (BlockDriverState *bs) +{ +BlockDriverState *filtered; + +if (!bs->drv || !block_driver_can_compress (bs->drv)) { +return false; + } + + filtered =bdrv_filter_bs (bs); +if (filtered) { +/* +* Filters can only forward compressed writes, so we have to +* check the child. +*/ +return bdrv_supports_compressed_writes (filtered); + } + +return true; +} +const char *bdrv_get_format_name (BlockDriverState *bs) {return bs->drv ? bs->drv->format_name :NULL ;
Signature · 1 line
2.26.2
PATCH v8 8/43 throttle: Support compressed writes
In reply to Max Reitz--- block/throttle.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
block/throttle.c +10 -0
@@ -151,6 +151,15 @@ static int coroutine_fn throttle_co_pdiscard(BlockDriverState *bs,return bdrv_co_pdiscard (bs->file, offset, bytes); } +static int coroutine_fn throttle_co_pwritev_compressed(BlockDriverState *bs, +uint64_t offset, +uint64_t bytes, +QEMUIOVector *qiov) +{ +return throttle_co_pwritev (bs, offset, bytes, qiov, +BDRV_REQ_WRITE_COMPRESSED ); +} +static int throttle_co_flush (BlockDriverState *bs) {return bdrv_co_flush (bs->file->bs);
@@ -243,6 +252,7 @@ static BlockDriver bdrv_throttle = { .bdrv_co_pwrite_zeroes = throttle_co_pwrite_zeroes, .bdrv_co_pdiscard = throttle_co_pdiscard, + .bdrv_co_pwritev_compressed = throttle_co_pwritev_compressed, .bdrv_attach_aio_context = throttle_attach_aio_context, .bdrv_detach_aio_context = throttle_detach_aio_context,
Signature · 1 line
2.26.2
PATCH v8 9/43 copy-on-read: Support compressed writes
In reply to Max Reitz--- block/copy-on-read.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
block/copy-on-read.c +11 -0
@@ -107,6 +107,16 @@ static int coroutine_fn cor_co_pdiscard(BlockDriverState *bs, } +static int coroutine_fn cor_co_pwritev_compressed(BlockDriverState *bs, +uint64_t offset, +uint64_t bytes, +QEMUIOVector *qiov) +{ +return bdrv_co_pwritev (bs->file, offset, bytes, qiov, +BDRV_REQ_WRITE_COMPRESSED ); +} + +static void cor_eject (BlockDriverState *bs,bool eject_flag) {bdrv_eject (bs->file->bs, eject_flag);
@@ -131,6 +141,7 @@ static BlockDriver bdrv_copy_on_read = { .bdrv_co_pwritev = cor_co_pwritev, .bdrv_co_pwrite_zeroes = cor_co_pwrite_zeroes, .bdrv_co_pdiscard = cor_co_pdiscard, + .bdrv_co_pwritev_compressed = cor_co_pwritev_compressed, .bdrv_eject = cor_eject, .bdrv_lock_medium = cor_lock_medium,
Signature · 1 line
2.26.2
PATCH v8 10/43 block: Use bdrv_filter_(bs|child) where obvious
In reply to Max ReitzPlaces that use patterns like
if (bs->drv->is_filter && bs->file) {
... something about bs->file->bs ...
}should be
BlockDriverState *filtered = bdrv_filter_bs(bs);
if (filtered) {
... something about @filtered ...
}instead.
--- block.c | 31 ++++++++++++++++++++----------- block/io.c | 7 +++++-- migration/block-dirty-bitmap.c | 8 +------- 3 files changed, 26 insertions(+), 20 deletions(-)
block.c +20 -11
@@ -712,11 +712,12 @@ int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)int bdrv_probe_blocksizes (BlockDriverState *bs,BlockSizes *bsz) {BlockDriver *drv = bs->drv; +BlockDriverState *filtered =bdrv_filter_bs (bs);if (drv && drv->bdrv_probe_blocksizes) {return drv->bdrv_probe_blocksizes (bs, bsz); - }else if (drv && drv->is_filter && bs->file) { -return bdrv_probe_blocksizes (bs->file->bs, bsz); + }else if (filtered) { +return bdrv_probe_blocksizes (filtered, bsz); }return -ENOTSUP ;
@@ -731,11 +732,12 @@ int bdrv_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)int bdrv_probe_geometry (BlockDriverState *bs,HDGeometry *geo) {BlockDriver *drv = bs->drv; +BlockDriverState *filtered =bdrv_filter_bs (bs);if (drv && drv->bdrv_probe_geometry) {return drv->bdrv_probe_geometry (bs, geo); - }else if (drv && drv->is_filter && bs->file) { -return bdrv_probe_geometry (bs->file->bs, geo); + }else if (filtered) { +return bdrv_probe_geometry (filtered, geo); }return -ENOTSUP ;
@@ -5442,6 +5444,8 @@ int bdrv_has_zero_init_1(BlockDriverState *bs)int bdrv_has_zero_init (BlockDriverState *bs) { +BlockDriverState *filtered; +if (!bs->drv) {return 0 ; }
@@ -5454,8 +5458,10 @@ int bdrv_has_zero_init(BlockDriverState *bs)if (bs->drv->bdrv_has_zero_init) {return bs->drv->bdrv_has_zero_init (bs); } -if (bs->file && bs->drv->is_filter) { -return bdrv_has_zero_init (bs->file->bs); + + filtered =bdrv_filter_bs (bs); +if (filtered) { +return bdrv_has_zero_init (filtered); }/* safe default */
@@ -5485,8 +5491,9 @@ int bdrv_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)return -ENOMEDIUM ; }if (!drv->bdrv_get_info) { -if (bs->file && drv->is_filter) { -return bdrv_get_info (bs->file->bs, bdi); +BlockDriverState *filtered =bdrv_filter_bs (bs); +if (filtered) { +return bdrv_get_info (filtered, bdi); }return -ENOTSUP ; }
@@ -6571,6 +6578,8 @@ int bdrv_amend_options(BlockDriverState *bs, QemuOpts *opts,bool bdrv_recurse_can_replace (BlockDriverState *bs,BlockDriverState *to_replace) { +BlockDriverState *filtered; +if (!bs || !bs->drv) {return false; }
@@ -6585,9 +6594,9 @@ bool bdrv_recurse_can_replace(BlockDriverState *bs, }/* For filters without an own implementation, we can recurse on our own */ -if (bs->drv->is_filter) { -BdrvChild *child = bs->file ?: bs->backing; -return bdrv_recurse_can_replace (child->bs, to_replace); + filtered =bdrv_filter_bs (bs); +if (filtered) { +return bdrv_recurse_can_replace (filtered, to_replace); }/* Safe default */
block/io.c +5 -2
@@ -3309,6 +3309,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, Error **errp) {BlockDriverState *bs = child->bs; +BdrvChild *filtered;BlockDriver *drv = bs->drv;BdrvTrackedRequest req;int64_t old_size, new_bytes;
@@ -3360,6 +3361,8 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } + filtered =bdrv_filter_child (bs); +/* * If the image has a backing file that is large enough that it would * provide data for the new area, we cannot leave it unallocated because
@@ -3392,8 +3395,8 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, goto out; } ret = drv->bdrv_co_truncate (bs, offset, exact, prealloc, flags, errp); - }else if (bs->file && drv->is_filter) { - ret =bdrv_co_truncate (bs->file, offset, exact, prealloc, flags, errp); + }else if (filtered) { + ret =bdrv_co_truncate (filtered, offset, exact, prealloc, flags, errp); }else {error_setg (errp,"Image format driver does not support resize" ); ret = -ENOTSUP ;
migration/block-dirty-bitmap.c +1 -7
@@ -615,13 +615,7 @@ static int init_dirty_bitmap_migration(DBMSaveState *s)while (bs && bs->drv && bs->drv->is_filter && !bdrv_has_named_bitmaps (bs)) { -if (bs->backing) { - bs = bs->backing->bs; - }else if (bs->file) { - bs = bs->file->bs; - }else { - bs =NULL ; - } + bs =bdrv_filter_bs (bs); }if (bs && bs->drv && !bs->drv->is_filter) {
Signature · 1 line
2.26.2
PATCH v8 11/43 block: Use CAFs in block status functions
In reply to Max ReitzUse the child access functions in the block status inquiry functions as appropriate.
--- block/io.c | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-)
block/io.c +10 -9
@@ -2409,9 +2409,10 @@ static int coroutine_fn bdrv_co_block_status(BlockDriverState *bs,if (ret & (BDRV_BLOCK_DATA |BDRV_BLOCK_ZERO )) { ret |=BDRV_BLOCK_ALLOCATED ; }else if (want_zero && bs->drv->supports_backing) { -if (bs->backing) { -BlockDriverState *bs2 = bs->backing->bs; -int64_t size2 =bdrv_getlength (bs2); +BlockDriverState *cow_bs =bdrv_cow_bs (bs); + +if (cow_bs) { +int64_t size2 =bdrv_getlength (cow_bs);if (size2 >=0 && offset >= size2) { ret |=BDRV_BLOCK_ZERO ;
@@ -2479,7 +2480,7 @@ static int coroutine_fn bdrv_co_block_status_above(BlockDriverState *bs,bool first = true;assert (bs != base); -for (p = bs; p != base; p =backing_bs (p)) { +for (p = bs; p != base; p =bdrv_filter_or_cow_bs (p)) { ret =bdrv_co_block_status (p, want_zero, offset, bytes, pnum, map, file);if (ret <0 ) {
@@ -2553,7 +2554,7 @@ int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,int bdrv_block_status (BlockDriverState *bs,int64_t offset,int64_t bytes,int64_t *pnum,int64_t *map,BlockDriverState **file) { -return bdrv_block_status_above (bs,backing_bs (bs), +return bdrv_block_status_above (bs,bdrv_filter_or_cow_bs (bs), offset, bytes, pnum, map, file); }
@@ -2563,9 +2564,9 @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,int ret;int64_t dummy; - ret =bdrv_common_block_status_above (bs,backing_bs (bs), false, offset, - bytes, pnum ? pnum : &dummy,NULL , -NULL ); + ret =bdrv_common_block_status_above (bs,bdrv_filter_or_cow_bs (bs), false, + offset, bytes, pnum ? pnum : &dummy, +NULL ,NULL );if (ret <0 ) {return ret; }
@@ -2628,7 +2629,7 @@ int bdrv_is_allocated_above(BlockDriverState *top,break ; } - intermediate =backing_bs (intermediate); + intermediate =bdrv_filter_or_cow_bs (intermediate); } *pnum = n;
Signature · 1 line
2.26.2
PATCH v8 12/43 stream: Deal with filters
In reply to Max ReitzBecause of the (not so recent anymore) changes that make the stream job independent of the base node and instead track the node above it, we have to split that "bottom" node into two cases: The bottom COW node, and the node directly above the base node (which may be an R/W filter or the bottom COW node).
--- qapi/block-core.json | 13 ++++++--- block/stream.c | 63 ++++++++++++++++++++++++++++++++------------ blockdev.c | 4 ++- 3 files changed, 59 insertions(+), 21 deletions(-)
qapi/block-core.json +10 -3
@@ -2484,13 +2484,20 @@ # of 'device'. # # If a base file is specified then sectors are not copied from that base file and -# its backing chain. When streaming completes the image file will have the base -# file as its backing file. This can be used to stream a subset of the backing -# file chain instead of flattening the entire image. +# its backing chain. This can be used to stream a subset of the backing file +# chain instead of flattening the entire image. +# When streaming completes the image file will have the base file as its backing +# file, unless that node was changed while the job was running. In that case, +# base's parent's backing (or filtered, whichever exists) child (i.e., base at +# the beginning of the job) will be the new backing file. # # On successful completion the image file is updated to drop the backing file # and the BLOCK_JOB_COMPLETED event is emitted. # +# In case @device is a filter node, block-stream modifies the first non-filter +# overlay node below it to point to the new backing node instead of modifying +# @device itself. +# # @job-id: identifier for the newly-created block job. If # omitted, the device name will be used. (Since 2.7) #
block/stream.c +46 -17
137 lines not on this page · raw message
blockdev.c +3 -1
@@ -2528,7 +2528,9 @@ void qmp_block_stream(bool has_job_id, const char *job_id, const char *device, }/* Check for op blockers in the whole chain between bs and base */ -for (iter = bs; iter && iter != base_bs; iter =backing_bs (iter)) { +for (iter = bs; iter && iter != base_bs; + iter =bdrv_filter_or_cow_bs (iter)) + {if (bdrv_op_is_blocked (iter,BLOCK_OP_TYPE_STREAM , errp)) { goto out; }
Signature · 1 line
2.26.2
PATCH v8 13/43 block: Use CAFs when working with backing chains
In reply to Max ReitzUse child access functions when iterating through backing chains so filters do not break the chain.
In addition, bdrv_find_overlay() will now always return the actual overlay; that is, it will never return a filter node but only one with a COW backing file (there may be filter nodes between that node and @bs).
--- block.c | 44 ++++++++++++++++++++++++++++++-------------- 1 file changed, 30 insertions(+), 14 deletions(-)
block.c +30 -14
@@ -4745,9 +4745,9 @@ int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file, }/* -* Finds the image layer in the chain that has 'bs' as its backing file. -* -* active is the current topmost image. +* Finds the first non-filter node above bs in the chain between +* active and bs. The returned node is either an immediate parent of +* bs, or there are only filter nodes between the two. * * Returns NULL if bs is not found in active's image chain, * or if active == bs.
@@ -4757,11 +4757,18 @@ int bdrv_change_backing_file(BlockDriverState *bs, const char *backing_file,BlockDriverState *bdrv_find_overlay (BlockDriverState *active,BlockDriverState *bs) { -while (active && bs !=backing_bs (active)) { - active =backing_bs (active); + bs =bdrv_skip_filters (bs); + active =bdrv_skip_filters (active); + +while (active) { +BlockDriverState *next =bdrv_backing_chain_next (active); +if (bs == next) { +return active; + } + active = next; } -return active; +return NULL ; }/* Given a BDS, searches for the base layer. */
@@ -4913,9 +4920,7 @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,* other intermediate nodes have been dropped. * If 'top' is an implicit node (e.g. "commit_top") we should skip * it because no one inherits from it. We use explicit_top for that. */ -while (explicit_top && explicit_top->implicit) { - explicit_top =backing_bs (explicit_top); - } + explicit_top =bdrv_skip_implicit_filters (explicit_top); update_inherits_from =bdrv_inherits_from_recursive (base, explicit_top);/* success - we can delete the intermediate states, and link top->base */
@@ -5372,7 +5377,7 @@ BlockDriverState *bdrv_lookup_bs(const char *device,bool bdrv_chain_contains (BlockDriverState *top,BlockDriverState *base) {while (top && top != base) { - top =backing_bs (top); + top =bdrv_filter_or_cow_bs (top); }return top !=NULL ;
@@ -5613,6 +5618,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,int is_protocol =0 ;BlockDriverState *curr_bs =NULL ;BlockDriverState *retval =NULL ; +BlockDriverState *bs_below;if (!bs || !bs->drv || !backing_file) {return NULL ;
@@ -5623,7 +5629,17 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, is_protocol =path_has_protocol (backing_file); -for (curr_bs = bs; curr_bs->backing; curr_bs = curr_bs->backing->bs) { +/* +* Being largely a legacy function, skip any filters here +* (because filters do not have normal filenames, so they cannot +* match anyway; and allowing json:{} filenames is a bit out of +* scope). +*/ +for (curr_bs =bdrv_skip_filters (bs); +bdrv_cow_child (curr_bs) !=NULL ; + curr_bs = bs_below) + { + bs_below =bdrv_backing_chain_next (curr_bs);/* If either of the filename paths is actually a protocol, then * compare unmodified paths; otherwise make paths relative */
@@ -5631,7 +5647,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,char *backing_file_full_ret;if (strcmp (backing_file, curr_bs->backing_file) ==0 ) { - retval = curr_bs->backing->bs; + retval = bs_below;break ; }/* Also check against the full backing filename for the image */
@@ -5641,7 +5657,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,bool equal =strcmp (backing_file, backing_file_full_ret) ==0 ;g_free (backing_file_full_ret);if (equal) { - retval = curr_bs->backing->bs; + retval = bs_below;break ; } }
@@ -5667,7 +5683,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,g_free (filename_tmp);if (strcmp (backing_file_full, filename_full) ==0 ) { - retval = curr_bs->backing->bs; + retval = bs_below;break ; } }
Signature · 1 line
2.26.2
PATCH v8 14/43 block: Use bdrv_cow_child() in bdrv_co_truncate()
In reply to Max ReitzThe condition modified here is not about potentially filtered children, but only about COW sources (i.e. traditional backing files).
--- block/io.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-)
block/io.c +4 -3
@@ -3310,7 +3310,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, Error **errp) {BlockDriverState *bs = child->bs; -BdrvChild *filtered; +BdrvChild *filtered, *backing;BlockDriver *drv = bs->drv;BdrvTrackedRequest req;int64_t old_size, new_bytes;
@@ -3363,6 +3363,7 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact, } filtered =bdrv_filter_child (bs); + backing =bdrv_cow_child (bs);/* * If the image has a backing file that is large enough that it would
@@ -3374,10 +3375,10 @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,* backing file, taking care of keeping things consistent with that backing * file is the user's responsibility. */ -if (new_bytes && bs->backing) { +if (new_bytes && backing) {int64_t backing_len; - backing_len =bdrv_getlength (backing_bs (bs)); + backing_len =bdrv_getlength (backing->bs);if (backing_len <0 ) { ret = backing_len;error_setg_errno (errp, -ret,"Could not get backing file size" );
Signature · 1 line
2.26.2
PATCH v8 15/43 block: Re-evaluate backing file handling in reopen
In reply to Max ReitzReopening a node's backing child needs a bit of special handling because the "backing" child has different defaults than all other children (among other things). Adding filter support here is a bit more difficult than just using the child access functions. In fact, we often have to directly use bs->backing because these functions are about the "backing" child (which may or may not be the COW backing file).
--- block.c | 49 ++++++++++++++++++++++++++++++++++++++++--------- 1 file changed, 40 insertions(+), 9 deletions(-)
block.c +40 -9
@@ -4004,7 +4004,7 @@ static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state, Error **errp) {BlockDriverState *bs = reopen_state->bs; -BlockDriverState *overlay_bs, *new_backing_bs; +BlockDriverState *overlay_bs, *below_bs, *new_backing_bs;QObject *value;const char *str;
@@ -4043,26 +4043,57 @@ static int bdrv_reopen_parse_backing(BDRVReopenState *reopen_state, } } +/* +* Ensure that @bs can really handle backing files, because we are +* about to give it one (or swap the existing one) +*/ +if (bs->drv->is_filter) { +/* Filters always have a file or a backing child */ +if (!bs->backing) { +error_setg (errp,"'%s' is a %s filter node that does not support a " +"backing child" , bs->node_name, bs->drv->format_name); +return -EINVAL ; + } + }else if (!bs->drv->supports_backing) { +error_setg (errp,"Driver '%s' of node '%s' does not support backing " +"files" , bs->drv->format_name, bs->node_name); +return -EINVAL ; + } +/* * Find the "actual" backing file by skipping all links that point * to an implicit node, if any (e.g. a commit filter node). +* We cannot use any of the bdrv_skip_*() functions here because +* those return the first explicit node, while we are looking for +* its overlay here. */ overlay_bs = bs; -while (backing_bs (overlay_bs) &&backing_bs (overlay_bs)->implicit) { - overlay_bs =backing_bs (overlay_bs); +for (below_bs =bdrv_filter_or_cow_bs (overlay_bs); + below_bs && below_bs->implicit; + below_bs =bdrv_filter_or_cow_bs (overlay_bs)) + { + overlay_bs = below_bs; }/* If we want to replace the backing file we need some extra checks */ -if (new_backing_bs !=backing_bs (overlay_bs)) { +if (new_backing_bs !=bdrv_filter_or_cow_bs (overlay_bs)) {/* Check for implicit nodes between bs and its backing file */ if (bs != overlay_bs) {error_setg (errp,"Cannot change backing link if '%s' has " "an implicit backing file" , bs->node_name);return -EPERM ; } -/* Check if the backing link that we want to replace is frozen */ -if (bdrv_is_backing_chain_frozen (overlay_bs,backing_bs (overlay_bs), - errp)) { +/* +* Check if the backing link that we want to replace is frozen. +* Note that +* bdrv_filter_or_cow_child(overlay_bs) == overlay_bs->backing, +* because we know that overlay_bs == bs, and that @bs +* either is a filter that uses ->backing or a COW format BDS +* with bs->drv->supports_backing == true. +*/ +if (bdrv_is_backing_chain_frozen (overlay_bs, +child_bs (overlay_bs->backing), errp)) + {return -EPERM ; } reopen_state->replace_backing_bs = true;
@@ -4211,7 +4242,7 @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,* its metadata. Otherwise the 'backing' option can be omitted. */ if (drv->supports_backing && reopen_state->backing_missing && - (backing_bs (reopen_state->bs) || reopen_state->bs->backing_file[0 ])) { + (reopen_state->bs->backing || reopen_state->bs->backing_file[0 ])) {error_setg (errp,"backing is missing for '%s'" , reopen_state->bs->node_name); ret = -EINVAL ;
@@ -4352,7 +4383,7 @@ void bdrv_reopen_commit(BDRVReopenState *reopen_state)* from bdrv_set_backing_hd()) has the new values. */ if (reopen_state->replace_backing_bs) { -BlockDriverState *old_backing_bs =backing_bs (bs); +BlockDriverState *old_backing_bs =child_bs (bs->backing);assert (!old_backing_bs || !old_backing_bs->implicit);/* Abort the permission update on the backing bs we're detaching */ if (old_backing_bs) {
Signature · 1 line
2.26.2
PATCH v8 16/43 block: Flush all children in generic code
In reply to Max ReitzIf the driver does not support .bdrv_co_flush() so bdrv_co_flush() itself has to flush the children of the given node, it should not flush just bs->file->bs, but in fact all children that might have been written to (judging from the permissions taken on them).
This is a bug fix for qcow2 images with an external data file, as they so far did not flush that data_file node.
In any case, the BLKDBG_EVENT() should be emitted on the primary child, because that is where a blkdebug node would be if there is any.
--- block/io.c | 23 +++++++++++++++++------ 1 file changed, 17 insertions(+), 6 deletions(-)
block/io.c +17 -6
@@ -2771,6 +2771,8 @@ static int coroutine_fn bdrv_flush_co_entry(void *opaque) int coroutine_fn bdrv_co_flush(BlockDriverState *bs) { +BdrvChild *primary_child =bdrv_primary_child (bs); +BdrvChild *child;int current_gen;int ret =0 ;
@@ -2800,7 +2802,7 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs) }/* Write back cached data to the OS even with cache=unsafe */ -BLKDBG_EVENT (bs->file,BLKDBG_FLUSH_TO_OS ); +BLKDBG_EVENT (primary_child,BLKDBG_FLUSH_TO_OS );if (bs->drv->bdrv_co_flush_to_os) { ret = bs->drv->bdrv_co_flush_to_os (bs);if (ret <0 ) {
@@ -2810,15 +2812,15 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)/* But don't actually force it to the disk with cache=unsafe */ if (bs->open_flags &BDRV_O_NO_FLUSH ) { - goto flush_parent; + goto flush_children; }/* Check if we really need to flush anything */ if (bs->flushed_gen == current_gen) { - goto flush_parent; + goto flush_children; } -BLKDBG_EVENT (bs->file,BLKDBG_FLUSH_TO_DISK ); +BLKDBG_EVENT (primary_child,BLKDBG_FLUSH_TO_DISK );if (!bs->drv) {/* bs->drv->bdrv_co_flush() might have ejected the BDS * (even in case of apparent success) */
@@ -2862,8 +2864,17 @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)/* Now flush the underlying protocol. It will also have BDRV_O_NO_FLUSH * in the case of cache=unsafe, so there are no useless flushes. */ -flush_parent: - ret = bs->file ?bdrv_co_flush (bs->file->bs) :0 ; +flush_children: + ret =0 ; + QLIST_FOREACH(child, &bs->children, next) { +if (child->perm & (BLK_PERM_WRITE |BLK_PERM_WRITE_UNCHANGED )) { +int this_child_ret =bdrv_co_flush (child->bs); +if (!ret) { + ret = this_child_ret; + } + } + } + out:/* Notify any pending flushes that we have completed */ if (ret ==0 ) {
Signature · 1 line
2.26.2
PATCH v8 17/43 vmdk: Drop vmdk_co_flush()
In reply to Max ReitzBefore HEAD^, we needed this because bdrv_co_flush() by itself would only flush bs->file. With HEAD^, bdrv_co_flush() will flush all children on which a WRITE or WRITE_UNCHANGED permission has been taken. Thus, vmdk no longer needs to do it itself.
--- block/vmdk.c | 16 ---------------- 1 file changed, 16 deletions(-)
block/vmdk.c +0 -16
@@ -2806,21 +2806,6 @@ static void vmdk_close(BlockDriverState *bs)error_free (s->migration_blocker); } -static coroutine_fn int vmdk_co_flush(BlockDriverState *bs) -{ -BDRVVmdkState *s = bs->opaque; -int i, err; -int ret =0 ; - -for (i =0 ; i < s->num_extents; i++) { - err =bdrv_co_flush (s->extents[i].file->bs); -if (err <0 ) { - ret = err; - } - } -return ret; -} -static int64_t vmdk_get_allocated_file_size (BlockDriverState *bs) {int i;
@@ -3084,7 +3069,6 @@ static BlockDriver bdrv_vmdk = { .bdrv_close = vmdk_close, .bdrv_co_create_opts = vmdk_co_create_opts, .bdrv_co_create = vmdk_co_create, - .bdrv_co_flush_to_disk = vmdk_co_flush, .bdrv_co_block_status = vmdk_co_block_status, .bdrv_get_allocated_file_size = vmdk_get_allocated_file_size, .bdrv_has_zero_init = vmdk_has_zero_init,
Signature · 1 line
2.26.2
PATCH v8 18/43 block: Iterate over children in refresh_limits
In reply to Max ReitzInstead of looking at just bs->file and bs->backing, we should look at all children that could end up receiving forwarded requests.
--- block/io.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)
block/io.c +16 -16
@@ -135,6 +135,8 @@ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)void bdrv_refresh_limits (BlockDriverState *bs,Error **errp) {BlockDriver *drv = bs->drv; +BdrvChild *c; +bool have_limits;Error *local_err =NULL ;memset (&bs->bl,0 ,sizeof (bs->bl));
@@ -149,14 +151,21 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) drv->bdrv_co_preadv_part) ? 1 : 512;/* Take some limits from the children as a default */ -if (bs->file) { -bdrv_refresh_limits (bs->file->bs, &local_err); -if (local_err) { -error_propagate (errp, local_err); -return ; + have_limits = false; + QLIST_FOREACH(c, &bs->children, next) { +if (c->role & (BDRV_CHILD_DATA |BDRV_CHILD_FILTERED |BDRV_CHILD_COW )) + { +bdrv_refresh_limits (c->bs, &local_err); +if (local_err) { +error_propagate (errp, local_err); +return ; + } +bdrv_merge_limits (&bs->bl, &c->bs->bl); + have_limits = true; } -bdrv_merge_limits (&bs->bl, &bs->file->bs->bl); - }else { + } + +if (!have_limits) { bs->bl.min_mem_alignment =512 ; bs->bl.opt_mem_alignment = qemu_real_host_page_size;
@@ -164,15 +173,6 @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp) bs->bl.max_iov =IOV_MAX ; } -if (bs->backing) { -bdrv_refresh_limits (bs->backing->bs, &local_err); -if (local_err) { -error_propagate (errp, local_err); -return ; - } -bdrv_merge_limits (&bs->bl, &bs->backing->bs->bl); - } -/* Then let the driver override it */ if (drv->bdrv_refresh_limits) { drv->bdrv_refresh_limits (bs, errp);
Signature · 1 line
2.26.2
PATCH v8 19/43 block: Use CAFs in bdrv_refresh_filename()
In reply to Max Reitzbdrv_refresh_filename() and the kind of related bdrv_dirname() should look to the primary child when they wish to copy the underlying file's filename.
--- block.c | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-)
block.c +21 -8
@@ -6822,6 +6822,7 @@ void bdrv_refresh_filename(BlockDriverState *bs) {BlockDriver *drv = bs->drv;BdrvChild *child; +BlockDriverState *primary_child_bs;QDict *opts;bool backing_overridden;bool generate_json_filename;/* Whether our default implementation should
@@ -6891,20 +6892,30 @@ void bdrv_refresh_filename(BlockDriverState *bs)qobject_unref (bs->full_open_options); bs->full_open_options = opts; + primary_child_bs =bdrv_primary_bs (bs); +if (drv->bdrv_refresh_filename) {/* Obsolete information is of no use here, so drop the old file name * information before refreshing it */ bs->exact_filename[0 ] ='\0' ; drv->bdrv_refresh_filename (bs); - }else if (bs->file) { -/* Try to reconstruct valid information from the underlying file */ + }else if (primary_child_bs) { +/* +* Try to reconstruct valid information from the underlying +* file -- this only works for format nodes (filter nodes +* cannot be probed and as such must be selected by the user +* either through an options dict, or through a special +* filename which the filter driver must construct in its +* .bdrv_refresh_filename() implementation). +*/ bs->exact_filename[0 ] ='\0' ;/* * We can use the underlying file's filename if: * - it has a filename, +* - the current BDS is not a filter, * - the file is a protocol BDS, and * - opening that file (as this BDS's format) will automatically create * the BDS tree we have right now, that is:
@@ -6913,11 +6924,11 @@ void bdrv_refresh_filename(BlockDriverState *bs)* - no non-file child of this BDS has been overridden by the user * Both of these conditions are represented by generate_json_filename. */ -if (bs->file->bs->exact_filename[0 ] && - bs->file->bs->drv->bdrv_file_open && - !generate_json_filename) +if (primary_child_bs->exact_filename[0 ] && + primary_child_bs->drv->bdrv_file_open && + !drv->is_filter && !generate_json_filename) { -strcpy (bs->exact_filename, bs->file->bs->exact_filename); +strcpy (bs->exact_filename, primary_child_bs->exact_filename); } }
@@ -6937,6 +6948,7 @@ void bdrv_refresh_filename(BlockDriverState *bs)char *bdrv_dirname (BlockDriverState *bs,Error **errp) {BlockDriver *drv = bs->drv; +BlockDriverState *child_bs;if (!drv) {error_setg (errp,"Node '%s' is ejected" , bs->node_name);
@@ -6947,8 +6959,9 @@ char *bdrv_dirname(BlockDriverState *bs, Error **errp)return drv->bdrv_dirname (bs, errp); } -if (bs->file) { -return bdrv_dirname (bs->file->bs, errp); + child_bs =bdrv_primary_bs (bs); +if (child_bs) { +return bdrv_dirname (child_bs, errp); }bdrv_refresh_filename (bs);
Signature · 1 line
2.26.2
PATCH v8 20/43 block: Use CAF in bdrv_co_rw_vmstate()
In reply to Max ReitzIf a node whose driver does not provide VM state functions has a metadata child, the VM state should probably go there; if it is a filter, the VM state should probably go there. It follows that we should generally go down to the primary child.
--- block/io.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)
block/io.c +3 -2
@@ -2648,6 +2648,7 @@ bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos, bool is_read) {BlockDriver *drv = bs->drv; +BlockDriverState *child_bs =bdrv_primary_bs (bs);int ret = -ENOTSUP ;bdrv_inc_in_flight (bs);
@@ -2660,8 +2661,8 @@ bdrv_co_rw_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos, }else { ret = drv->bdrv_save_vmstate (bs, qiov, pos); } - }else if (bs->file) { - ret =bdrv_co_rw_vmstate (bs->file->bs, qiov, pos, is_read); + }else if (child_bs) { + ret =bdrv_co_rw_vmstate (child_bs, qiov, pos, is_read); }bdrv_dec_in_flight (bs);
Signature · 1 line
2.26.2
PATCH v8 21/43 block/snapshot: Fix fallback
In reply to Max ReitzIf the top node's driver does not provide snapshot functionality and we want to fall back to a node down the chain, we need to snapshot all non-COW children. For simplicity's sake, just do not fall back if there is more than one such child. Furthermore, we really only can fall back to bs->file and bs->backing, because bdrv_snapshot_goto() has to modify the child link (notably, set it to NULL).
--- block/snapshot.c | 104 +++++++++++++++++++++++++++++++++++++---------- 1 file changed, 83 insertions(+), 21 deletions(-)
block/snapshot.c +83 -21
@@ -147,6 +147,56 @@ bool bdrv_snapshot_find_by_id_and_name(BlockDriverState *bs,return ret; } +/** +* Return a pointer to the child BDS pointer to which we can fall +* back if the given BDS does not support snapshots. +* Return NULL if there is no BDS to (safely) fall back to. +* +* We need to return an indirect pointer because bdrv_snapshot_goto() +* has to modify the BdrvChild pointer. +*/ +static BdrvChild **bdrv_snapshot_fallback_ptr (BlockDriverState *bs) +{ +BdrvChild **fallback; +BdrvChild *child; + +/* +* The only BdrvChild pointers that are safe to modify (and which +* we can thus return a reference to) are bs->file and +* bs->backing. +*/ + fallback = &bs->file; +if (!*fallback && bs->drv && bs->drv->is_filter) { + fallback = &bs->backing; + } + +if (!*fallback) { +return NULL ; + } + +/* +* Check that there are no other children that would need to be +* snapshotted. If there are, it is not safe to fall back to +* *fallback. +*/ + QLIST_FOREACH(child, &bs->children, next) { +if (child->role & (BDRV_CHILD_DATA |BDRV_CHILD_METADATA | +BDRV_CHILD_FILTERED ) && + child != *fallback) + { +return NULL ; + } + } + +return fallback; +} + +static BlockDriverState *bdrv_snapshot_fallback (BlockDriverState *bs) +{ +BdrvChild **child_ptr =bdrv_snapshot_fallback_ptr (bs); +return child_ptr ? (*child_ptr)->bs :NULL ; +} +int bdrv_can_snapshot (BlockDriverState *bs) {BlockDriver *drv = bs->drv;
@@ -155,8 +205,9 @@ int bdrv_can_snapshot(BlockDriverState *bs) }if (!drv->bdrv_snapshot_create) { -if (bs->file !=NULL ) { -return bdrv_can_snapshot (bs->file->bs); +BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs); +if (fallback_bs) { +return bdrv_can_snapshot (fallback_bs); }return 0 ; }
@@ -168,14 +219,15 @@ int bdrv_snapshot_create(BlockDriverState *bs, QEMUSnapshotInfo *sn_info) {BlockDriver *drv = bs->drv; +BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs);if (!drv) {return -ENOMEDIUM ; }if (drv->bdrv_snapshot_create) {return drv->bdrv_snapshot_create (bs, sn_info); } -if (bs->file) { -return bdrv_snapshot_create (bs->file->bs, sn_info); +if (fallback_bs) { +return bdrv_snapshot_create (fallback_bs, sn_info); }return -ENOTSUP ; }
@@ -185,6 +237,7 @@ int bdrv_snapshot_goto(BlockDriverState *bs, Error **errp) {BlockDriver *drv = bs->drv; +BdrvChild **fallback_ptr;int ret, open_ret;if (!drv) {
@@ -205,39 +258,46 @@ int bdrv_snapshot_goto(BlockDriverState *bs,return ret; } -if (bs->file) { -BlockDriverState *file; -QDict *options =qdict_clone_shallow (bs->options); + fallback_ptr =bdrv_snapshot_fallback_ptr (bs); +if (fallback_ptr) { +QDict *options;QDict *file_options;Error *local_err =NULL ; +BlockDriverState *fallback_bs = (*fallback_ptr)->bs; +char *subqdict_prefix =g_strdup_printf ("%s." , (*fallback_ptr)->name); + + options =qdict_clone_shallow (bs->options); - file = bs->file->bs;/* Prevent it from getting deleted when detached from bs */ -bdrv_ref (file); +bdrv_ref (fallback_bs); -qdict_extract_subqdict (options, &file_options,"file." ); +qdict_extract_subqdict (options, &file_options, subqdict_prefix);qobject_unref (file_options); -qdict_put_str (options,"file" ,bdrv_get_node_name (file)); +g_free (subqdict_prefix); + +qdict_put_str (options, (*fallback_ptr)->name, +bdrv_get_node_name (fallback_bs));if (drv->bdrv_close) { drv->bdrv_close (bs); } -bdrv_unref_child (bs, bs->file); - bs->file =NULL ; - ret =bdrv_snapshot_goto (file, snapshot_id, errp); +bdrv_unref_child (bs, *fallback_ptr); + *fallback_ptr =NULL ; + + ret =bdrv_snapshot_goto (fallback_bs, snapshot_id, errp); open_ret = drv->bdrv_open (bs, options, bs->open_flags, &local_err);qobject_unref (options);if (open_ret <0 ) { -bdrv_unref (file); +bdrv_unref (fallback_bs); bs->drv =NULL ;/* A bdrv_snapshot_goto() error takes precedence */ error_propagate (errp, local_err);return ret <0 ? ret : open_ret; } -assert (bs->file->bs == file); -bdrv_unref (file); +assert (fallback_bs == (*fallback_ptr)->bs); +bdrv_unref (fallback_bs);return ret; }
@@ -273,6 +333,7 @@ int bdrv_snapshot_delete(BlockDriverState *bs, Error **errp) {BlockDriver *drv = bs->drv; +BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs);int ret;if (!drv) {
@@ -289,8 +350,8 @@ int bdrv_snapshot_delete(BlockDriverState *bs,if (drv->bdrv_snapshot_delete) { ret = drv->bdrv_snapshot_delete (bs, snapshot_id, name, errp); - }else if (bs->file) { - ret =bdrv_snapshot_delete (bs->file->bs, snapshot_id, name, errp); + }else if (fallback_bs) { + ret =bdrv_snapshot_delete (fallback_bs, snapshot_id, name, errp); }else { error_setg(errp, "Block format '%s' used by device '%s' " "does not support internal snapshot deletion",
@@ -306,14 +367,15 @@ int bdrv_snapshot_list(BlockDriverState *bs, QEMUSnapshotInfo **psn_info) {BlockDriver *drv = bs->drv; +BlockDriverState *fallback_bs =bdrv_snapshot_fallback (bs);if (!drv) {return -ENOMEDIUM ; }if (drv->bdrv_snapshot_list) {return drv->bdrv_snapshot_list (bs, psn_info); } -if (bs->file) { -return bdrv_snapshot_list (bs->file->bs, psn_info); +if (fallback_bs) { +return bdrv_snapshot_list (fallback_bs, psn_info); }return -ENOTSUP ; }
Signature · 1 line
2.26.2
PATCH v8 22/43 block: Use CAFs for debug breakpoints
In reply to Max ReitzWhen looking for a blkdebug node (which implements debug breakpoints), use bdrv_primary_bs() to iterate through the graph, because that is where a blkdebug node would be.
--- block.c | 16 +++------------- 1 file changed, 3 insertions(+), 13 deletions(-)
block.c +3 -13
@@ -5568,17 +5568,7 @@ void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event)static BlockDriverState *bdrv_find_debug_node (BlockDriverState *bs) {while (bs && bs->drv && !bs->drv->bdrv_debug_breakpoint) { -if (bs->file) { - bs = bs->file->bs; -continue ; - } - -if (bs->drv->is_filter && bs->backing) { - bs = bs->backing->bs; -continue ; - } - -break ; + bs =bdrv_primary_bs (bs); }if (bs && bs->drv && bs->drv->bdrv_debug_breakpoint) {
@@ -5613,7 +5603,7 @@ int bdrv_debug_remove_breakpoint(BlockDriverState *bs, const char *tag)int bdrv_debug_resume (BlockDriverState *bs,const char *tag) {while (bs && (!bs->drv || !bs->drv->bdrv_debug_resume)) { - bs = bs->file ? bs->file->bs :NULL ; + bs =bdrv_primary_bs (bs); }if (bs && bs->drv && bs->drv->bdrv_debug_resume) {
@@ -5626,7 +5616,7 @@ int bdrv_debug_resume(BlockDriverState *bs, const char *tag)bool bdrv_debug_is_suspended (BlockDriverState *bs,const char *tag) {while (bs && bs->drv && !bs->drv->bdrv_debug_is_suspended) { - bs = bs->file ? bs->file->bs :NULL ; + bs =bdrv_primary_bs (bs); }if (bs && bs->drv && bs->drv->bdrv_debug_is_suspended) {
Signature · 1 line
2.26.2
PATCH v8 23/43 block: Improve get_allocated_file_size's default
In reply to Max ReitzThere are two practical problems with bdrv_get_allocated_file_size()'s default right now:
(1) For drivers with children, we should generally sum all their sizes instead of just passing the request through to bs->file. The latter is good for filters, but not so much for format drivers.
(2) Filters need not have bs->file, so we should actually go to the
filtered child instead of hard-coding bs->file.
Fix this by splitting the default implementation into three branches:
(1) For filter drivers: Return the size of the filtered child
(2) For protocol drivers: Return -ENOTSUP, because the default implementation cannot make a guess
(3) For other drivers: Sum all data-bearing children's sizes
--- block.c | 42 +++++++++++++++++++++++++++++++++++++++--- 1 file changed, 39 insertions(+), 3 deletions(-)
block.c +39 -3
@@ -5005,6 +5005,31 @@ exit:return ret; } +/** +* Implementation of BlockDriver.bdrv_get_allocated_file_size() that +* sums the size of all data-bearing children. (This excludes backing +* children.) +*/ +static int64_t bdrv_sum_allocated_file_size (BlockDriverState *bs) +{ +BdrvChild *child; +int64_t child_size, sum =0 ; + + QLIST_FOREACH(child, &bs->children, next) { +if (child->role & (BDRV_CHILD_DATA |BDRV_CHILD_METADATA | +BDRV_CHILD_FILTERED )) + { + child_size =bdrv_get_allocated_file_size (child->bs); +if (child_size <0 ) { +return child_size; + } + sum += child_size; + } + } + +return sum; +} +/** * Length of a allocated file in bytes. Sparse files are counted by actual * allocated space. Return < 0 if error or unknown.
@@ -5018,10 +5043,21 @@ int64_t bdrv_get_allocated_file_size(BlockDriverState *bs)if (drv->bdrv_get_allocated_file_size) {return drv->bdrv_get_allocated_file_size (bs); } -if (bs->file) { -return bdrv_get_allocated_file_size (bs->file->bs); + +if (drv->bdrv_file_open) { +/* +* Protocol drivers default to -ENOTSUP (most of their data is +* not stored in any of their children (if they even have any), +* so there is no generic way to figure it out). +*/ +return -ENOTSUP ; + }else if (drv->is_filter) { +/* Filter drivers default to the size of their filtered child */ +return bdrv_get_allocated_file_size (bdrv_filter_bs (bs)); + }else { +/* Other drivers default to summing their children's sizes */ +return bdrv_sum_allocated_file_size (bs); } -return -ENOTSUP ; }/*
Signature · 1 line
2.26.2
PATCH v8 24/43 block/null: Implement bdrv_get_allocated_file_size
In reply to Max ReitzIt is trivial, so we might as well do it.
Remove _filter_actual_image_size from iotest 184, so we get to see the result in its reference output.
--- block/null.c | 7 +++++++ tests/qemu-iotests/153.out | 2 +- tests/qemu-iotests/184 | 3 +-- tests/qemu-iotests/184.out | 6 ++++-- 4 files changed, 13 insertions(+), 5 deletions(-)
block/null.c +7 -0
@@ -262,6 +262,11 @@ static void null_refresh_filename(BlockDriverState *bs) bs->drv->format_name); } +static int64_t null_allocated_file_size (BlockDriverState *bs) +{ +return 0 ; +} +static const char *const null_strong_runtime_opts[] = {BLOCK_OPT_SIZE ,NULL_OPT_ZEROES ,
@@ -277,6 +282,7 @@ static BlockDriver bdrv_null_co = { .bdrv_file_open = null_file_open, .bdrv_parse_filename = null_co_parse_filename, .bdrv_getlength = null_getlength, + .bdrv_get_allocated_file_size = null_allocated_file_size, .bdrv_co_preadv = null_co_preadv, .bdrv_co_pwritev = null_co_pwritev,
@@ -297,6 +303,7 @@ static BlockDriver bdrv_null_aio = { .bdrv_file_open = null_file_open, .bdrv_parse_filename = null_aio_parse_filename, .bdrv_getlength = null_getlength, + .bdrv_get_allocated_file_size = null_allocated_file_size, .bdrv_aio_preadv = null_aio_preadv, .bdrv_aio_pwritev = null_aio_pwritev,
tests/qemu-iotests/153.out +1 -1
@@ -464,7 +464,7 @@ No conflict: image: null-co:// file format: null-co virtual size: 1 GiB (1073741824 bytes) -disk size: unavailable +disk size: 0 B Conflict: qemu-img: --force-share/-U conflicts with image options
tests/qemu-iotests/184 +1 -2
@@ -45,8 +45,7 @@ do_run_qemu() run_qemu() { do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_qmp\ - | _filter_qemu_io | _filter_generated_node_ids \ - | _filter_actual_image_size + | _filter_qemu_io | _filter_generated_node_ids } test_throttle=$($QEMU_IMG --help|grep throttle)
tests/qemu-iotests/184.out +4 -2
@@ -29,7 +29,8 @@ Testing: "image": { "virtual-size": 1073741824, "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}", - "format": "throttle" + "format": "throttle", + "actual-size": 0 }, "iops_wr": 0, "ro": false,
@@ -56,7 +57,8 @@ Testing: "image": { "virtual-size": 1073741824, "filename": "null-co://", - "format": "null-co" + "format": "null-co", + "actual-size": 0 }, "iops_wr": 0, "ro": false,
Signature · 1 line
2.26.2
PATCH v8 25/43 blockdev: Use CAF in external_snapshot_prepare()
In reply to Max ReitzThis allows us to differentiate between filters and nodes with COW backing files: Filters cannot be used as overlays at all (for this function).
--- blockdev.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
blockdev.c +6 -1
@@ -1562,7 +1562,12 @@ static void external_snapshot_prepare(BlkActionState *common, goto out; } -if (state->new_bs->backing !=NULL ) { +if (state->new_bs->drv->is_filter) { +error_setg (errp,"Filters cannot be used as overlays" ); + goto out; + } + +if (bdrv_cow_child (state->new_bs)) {error_setg (errp,"The overlay already has a backing image" ); goto out; }
Signature · 1 line
2.26.2
PATCH v8 26/43 block: Report data child for query-blockstats
In reply to Max ReitzIt makes no sense to report the block stats of a purely metadata-storing child in query-blockstats. So if the primary child does not have any data, try to find a unique data-storing child.
--- block/qapi.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-)
block/qapi.c +29 -2
@@ -526,6 +526,7 @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)static BlockStats *bdrv_query_bds_stats (BlockDriverState *bs,bool blk_level) { +BdrvChild *parent_child;BlockStats *s =NULL ; s =g_malloc0 (sizeof (*s));
@@ -555,9 +556,35 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, s->has_driver_specific = true; } -if (bs->file) { + parent_child =bdrv_primary_child (bs); +if (!parent_child || + !(parent_child->role & (BDRV_CHILD_DATA |BDRV_CHILD_FILTERED ))) + { +BdrvChild *c; + +/* +* Look for a unique data-storing child. We do not need to look for +* filtered children, as there would be only one and it would have been +* the primary child. +*/ + parent_child =NULL ; + QLIST_FOREACH(c, &bs->children, next) { +if (c->role &BDRV_CHILD_DATA ) { +if (parent_child) { +/* +* There are multiple data-storing children and we cannot +* choose between them. +*/ + parent_child =NULL ; +break ; + } + parent_child = c; + } + } + } +if (parent_child) { s->has_parent = true; - s->parent =bdrv_query_bds_stats (bs->file->bs, blk_level); + s->parent =bdrv_query_bds_stats (parent_child->bs, blk_level); }if (blk_level && bs->backing) {
Signature · 1 line
2.26.2
PATCH v8 27/43 block: Use child access functions for QAPI queries
In reply to Max Reitzquery-block, query-named-block-nodes, and query-blockstats now return any filtered child under "backing", not just bs->backing or COW children. This is so that filters do not interrupt the reported backing chain. This changes the output for iotest 184, as the throttled node now appears as a backing child.
--- block/qapi.c | 33 ++++++++++++++++++++------------- tests/qemu-iotests/184.out | 8 +++++++- 2 files changed, 27 insertions(+), 14 deletions(-)
block/qapi.c +20 -13
@@ -163,9 +163,13 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,break ; } -if (bs0->drv && bs0->backing) { +if (bs0->drv &&bdrv_filter_or_cow_child (bs0)) { +/* +* Put any filtered child here (for backwards compatibility to when +* we put bs0->backing here, which might be any filtered child). +*/ info->backing_file_depth++; - bs0 = bs0->backing->bs; + bs0 =bdrv_filter_or_cow_bs (bs0); (*p_image_info)->has_backing_image = true; p_image_info = &((*p_image_info)->backing_image); }else {
@@ -174,9 +178,8 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,/* Skip automatically inserted nodes that the user isn't aware of for * query-block (blk != NULL), but not for query-named-block-nodes */ -while (blk && bs0->drv && bs0->implicit) { - bs0 =backing_bs (bs0); -assert (bs0); +if (blk) { + bs0 =bdrv_skip_implicit_filters (bs0); } }
@@ -362,9 +365,7 @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,char *qdev;/* Skip automatically inserted nodes that the user isn't aware of */ -while (bs && bs->drv && bs->implicit) { - bs =backing_bs (bs); - } + bs =bdrv_skip_implicit_filters (bs); info->device =g_strdup (blk_name (blk)); info->type =g_strdup ("unknown" );
@@ -527,6 +528,7 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, bool blk_level) {BdrvChild *parent_child; +BlockDriverState *filter_or_cow_bs;BlockStats *s =NULL ; s =g_malloc0 (sizeof (*s));
@@ -539,9 +541,8 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs,/* Skip automatically inserted nodes that the user isn't aware of in * a BlockBackend-level command. Stay at the exact node for a node-level * command. */ -while (blk_level && bs->drv && bs->implicit) { - bs =backing_bs (bs); -assert (bs); +if (blk_level) { + bs =bdrv_skip_implicit_filters (bs); }if (bdrv_get_node_name (bs)[0 ]) {
@@ -587,9 +588,15 @@ static BlockStats *bdrv_query_bds_stats(BlockDriverState *bs, s->parent =bdrv_query_bds_stats (parent_child->bs, blk_level); } -if (blk_level && bs->backing) { + filter_or_cow_bs =bdrv_filter_or_cow_bs (bs); +if (blk_level && filter_or_cow_bs) { +/* +* Put any filtered or COW child here (for backwards +* compatibility to when we put bs0->backing here, which might +* be either) +*/ s->has_backing = true; - s->backing =bdrv_query_bds_stats (bs->backing->bs, blk_level); + s->backing =bdrv_query_bds_stats (filter_or_cow_bs, blk_level); }return s;
tests/qemu-iotests/184.out +7 -1
@@ -27,6 +27,12 @@ Testing: "iops_rd": 0, "detect_zeroes": "off", "image": { + "backing-image": { + "virtual-size": 1073741824, + "filename": "null-co://", + "format": "null-co", + "actual-size": 0 + }, "virtual-size": 1073741824, "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}", "format": "throttle",
@@ -35,7 +41,7 @@ Testing: "iops_wr": 0, "ro": false, "node-name": "throttle0", - "backing_file_depth": 0, + "backing_file_depth": 1, "drv": "throttle", "iops": 0, "bps_wr": 0,
Signature · 1 line
2.26.2
PATCH v8 28/43 block-copy: Use CAF to find sync=top base
In reply to Max Reitz--- block/block-copy.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
block/block-copy.c +2 -2
@@ -440,8 +440,8 @@ static int block_copy_block_status(BlockCopyState *s, int64_t offset,BlockDriverState *base;int ret; -if (s->skip_unallocated && s->source->bs->backing) { - base = s->source->bs->backing->bs; +if (s->skip_unallocated) { + base =bdrv_backing_chain_next (s->source->bs); }else { base =NULL ; }
Signature · 1 line
2.26.2
PATCH v8 29/43 mirror: Deal with filters
In reply to Max ReitzThis includes some permission limiting (for example, we only need to take the RESIZE permission for active commits where the base is smaller than the top).
base_overlay is introduced so we can query bdrv_is_allocated_above() on it - we cannot do that with base itself, because a filter's block_status is the same as its child node, so if there are filters on base, bdrv_is_allocated_above() on base would return information including base.
Use this opportunity to rename qmp_drive_mirror()'s "source" BDS to "target_backing_bs", because that is what it really refers to.
--- qapi/block-core.json | 6 ++- block/mirror.c | 118 +++++++++++++++++++++++++++++++++---------- blockdev.c | 32 ++++++++---- 3 files changed, 118 insertions(+), 38 deletions(-)
qapi/block-core.json +4 -2
@@ -1948,7 +1948,8 @@ # # @replaces: with sync=full graph node name to be replaced by the new # image when a whole image copy is done. This can be used to repair -# broken Quorum files. (Since 2.1) +# broken Quorum files. By default, @device is replaced, although +# implicitly created filters on it are kept. (Since 2.1) # # @mode: whether and how QEMU should create a new image, default is # 'absolute-paths'.
@@ -2259,7 +2260,8 @@ # # @replaces: with sync=full graph node name to be replaced by the new # image when a whole image copy is done. This can be used to repair -# broken Quorum files. +# broken Quorum files. By default, @device is replaced, although +# implicitly created filters on it are kept. # # @speed: the maximum speed, in bytes per second #
block/mirror.c +91 -27
206 lines not on this page · raw message
blockdev.c +23 -9
@@ -2899,6 +2899,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs, bool has_auto_dismiss, bool auto_dismiss, Error **errp) { + BlockDriverState *unfiltered_bs;int job_flags =JOB_DEFAULT ;if (!has_speed) {
@@ -2950,10 +2951,19 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,return ; } -if (!bs->backing && sync ==MIRROR_SYNC_MODE_TOP ) { +if (!bdrv_backing_chain_next (bs) && sync ==MIRROR_SYNC_MODE_TOP ) { sync =MIRROR_SYNC_MODE_FULL ; } +if (!has_replaces) { +/* We want to mirror from @bs, but keep implicit filters on top */ + unfiltered_bs =bdrv_skip_implicit_filters (bs); +if (unfiltered_bs != bs) { + replaces = unfiltered_bs->node_name; + has_replaces = true; + } + } +if (has_replaces) {BlockDriverState *to_replace_bs;AioContext *replace_aio_context;
@@ -3000,7 +3010,7 @@ static void blockdev_mirror_common(const char *job_id, BlockDriverState *bs,void qmp_drive_mirror (DriveMirror *arg,Error **errp) {BlockDriverState *bs; -BlockDriverState *source, *target_bs; +BlockDriverState *target_backing_bs, *target_bs;AioContext *aio_context;AioContext *old_context;BlockMirrorBackingMode backing_mode;
@@ -3035,12 +3045,12 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp) } flags = bs->open_flags |BDRV_O_RDWR ; - source =backing_bs (bs); -if (!source && arg->sync ==MIRROR_SYNC_MODE_TOP ) { + target_backing_bs =bdrv_cow_bs (bdrv_skip_filters (bs)); +if (!target_backing_bs && arg->sync ==MIRROR_SYNC_MODE_TOP ) { arg->sync =MIRROR_SYNC_MODE_FULL ; }if (arg->sync ==MIRROR_SYNC_MODE_NONE ) { - source = bs; + target_backing_bs = bs; } size =bdrv_getlength (bs);
@@ -3066,7 +3076,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)/* Don't open backing image in create() */ flags |=BDRV_O_NO_BACKING ; -if ((arg->sync ==MIRROR_SYNC_MODE_FULL || !source) +if ((arg->sync ==MIRROR_SYNC_MODE_FULL || !target_backing_bs) && arg->mode !=NEW_IMAGE_MODE_EXISTING ) {/* create new image w/o backing file */
@@ -3074,15 +3084,19 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)bdrv_img_create (arg->target, format,NULL ,NULL ,NULL , size, flags, false, &local_err); }else { +/* Implicit filters should not appear in the filename */ +BlockDriverState *explicit_backing = +bdrv_skip_implicit_filters (target_backing_bs); +switch (arg->mode) {case NEW_IMAGE_MODE_EXISTING :break ;case NEW_IMAGE_MODE_ABSOLUTE_PATHS :/* create new image with backing file */ -bdrv_refresh_filename (source); +bdrv_refresh_filename (explicit_backing);bdrv_img_create (arg->target, format, - source->filename, - source->drv->format_name, + explicit_backing->filename, + explicit_backing->drv->format_name,NULL , size, flags, false, &local_err);break ;default :
Signature · 1 line
2.26.2
Re: [PATCH v8 29/43] mirror: Deal with filters
Am 01.09.2020 um 16:34 hat Max Reitz geschrieben:
Quoted 10 lines
This includes some permission limiting (for example, we only need to take the RESIZE permission for active commits where the base is smaller than the top).
base_overlayis introduced so we can querybdrv_is_allocated_above()on it - we cannot do that with base itself, because a filter'sblock_statusis the same as its child node, so if there are filters on base,bdrv_is_allocated_above()on base would return information including base.
Quoted 4 lines
Use this opportunity to rename qmp_drive_mirror()'s "source" BDS to "
target_backing_bs", because that is what it really refers to.Signed-off-by Max Reitz <[email protected]>
I see that you decided not to fix the missing freeze of the backing chain on the source side. I'm willing to view this as a pre-existing issue that shouldn't stop this series, but are you going to send a separate patch for it?
Kevin
Re: [PATCH v8 29/43] mirror: Deal with filters
Quoted 11 lines · Kevin Wolf
Am 01.09.2020 um 16:34 hat Max Reitz geschrieben:
Quoted 10 lines
This includes some permission limiting (for example, we only need to take the RESIZE permission for active commits where the base is smaller than the top).
base_overlayis introduced so we can querybdrv_is_allocated_above()on it - we cannot do that with base itself, because a filter'sblock_statusis the same as its child node, so if there are filters on base,bdrv_is_allocated_above()on base would return information including base.
Quoted 8 lines
Quoted 4 lines
Use this opportunity to rename qmp_drive_mirror()'s "source" BDS to "
target_backing_bs", because that is what it really refers to.Signed-off-by Max Reitz <[email protected]>I see that you decided not to fix the missing freeze of the backing chain on the source side. I'm willing to view this as a pre-existing issue
Yes, that’s how I regarded it.
Quoted 2 lines
that shouldn't stop this series, but are you going to send a separate patch for it?
Why not.
Max
PATCH v8 30/43 backup: Deal with filters
In reply to Max Reitz--- block/backup-top.c | 2 +- block/backup.c | 9 +++++---- blockdev.c | 19 +++++++++++++++---- 3 files changed, 21 insertions(+), 9 deletions(-)
block/backup-top.c +1 -1
@@ -281,7 +281,7 @@ void bdrv_backup_top_drop(BlockDriverState *bs) s->active = false;bdrv_child_refresh_perms (bs, bs->backing, &error_abort); -bdrv_replace_node (bs,backing_bs (bs), &error_abort); +bdrv_replace_node (bs, bs->backing->bs, &error_abort);bdrv_set_backing_hd (bs,NULL , &error_abort);bdrv_drained_end (bs);
block/backup.c +5 -4
@@ -297,6 +297,7 @@ static int64_t backup_calculate_cluster_size(BlockDriverState *target, {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
@@ -304,7 +305,7 @@ static int64_t backup_calculate_cluster_size(BlockDriverState *target,* targets with a backing file, try to avoid COW if possible. */ ret =bdrv_get_info (target, &bdi); -if (ret == -ENOTSUP && !target->backing) { +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 "
@@ -313,14 +314,14 @@ static int64_t backup_calculate_cluster_size(BlockDriverState *target,"this default, the backup may be unusable" , BACKUP_CLUSTER_SIZE_DEFAULT);return BACKUP_CLUSTER_SIZE_DEFAULT ; - }else if (ret <0 && !target->backing) { + }else if (ret <0 && !target_does_cow) {error_setg_errno (errp, -ret,"Couldn't determine the cluster size of the target image, " "which has no backing file" );error_append_hint (errp,"Aborting, since this may create an unusable destination image\n" );return ret; - }else if (ret <0 && target->backing) { + }else if (ret <0 && target_does_cow) {/* Not fatal; just trudge on ahead. */ return BACKUP_CLUSTER_SIZE_DEFAULT ; }
@@ -371,7 +372,7 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,return NULL ; } -if (compress && !block_driver_can_compress (target->drv)) { +if (compress && !bdrv_supports_compressed_writes (target)) {error_setg (errp,"Compression is not supported for this drive %s" ,bdrv_get_device_name (target));return NULL ;
blockdev.c +15 -4
@@ -1741,7 +1741,13 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)* on top of. */ if (backup->sync ==MIRROR_SYNC_MODE_TOP ) { - source =backing_bs (bs); +/* +* Backup will not replace the source by the target, so none +* of the filters skipped here will be removed (in contrast to +* mirror). Therefore, we can skip all of them when looking +* for the first COW relationship. +*/ + source =bdrv_cow_bs (bdrv_skip_filters (bs));if (!source) { backup->sync =MIRROR_SYNC_MODE_FULL ; }
@@ -1761,9 +1767,14 @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)if (backup->mode !=NEW_IMAGE_MODE_EXISTING ) {assert (backup->format);if (source) { -bdrv_refresh_filename (source); -bdrv_img_create (backup->target, backup->format, source->filename, - source->drv->format_name,NULL , +/* Implicit filters should not appear in the filename */ +BlockDriverState *explicit_backing = +bdrv_skip_implicit_filters (source); + +bdrv_refresh_filename (explicit_backing); +bdrv_img_create (backup->target, backup->format, + explicit_backing->filename, + explicit_backing->drv->format_name,NULL , size, flags, false, &local_err); }else { bdrv_img_create(backup->target, backup->format, NULL, NULL, NULL,
Signature · 1 line
2.26.2
PATCH v8 31/43 commit: Deal with filters
In reply to Max ReitzThis includes some permission limiting (for example, we only need to take the RESIZE permission if the base is smaller than the top).
--- block/block-backend.c | 7 ++- block/commit.c | 94 +++++++++++++++++++++++++--------- block/monitor/block-hmp-cmds.c | 2 +- blockdev.c | 4 +- 4 files changed, 79 insertions(+), 28 deletions(-)
block/block-backend.c +5 -2
@@ -2279,10 +2279,13 @@ int blk_commit_all(void)while ((blk =blk_all_next (blk)) !=NULL ) {AioContext *aio_context =blk_get_aio_context (blk); +BlockDriverState *unfiltered_bs =bdrv_skip_filters (blk_bs (blk));aio_context_acquire (aio_context); -if (blk_is_inserted (blk) && blk->root->bs->backing) { -int ret =bdrv_commit (blk->root->bs); +if (blk_is_inserted (blk) &&bdrv_cow_child (unfiltered_bs)) { +int ret; + + ret =bdrv_commit (unfiltered_bs);if (ret <0 ) {aio_context_release (aio_context);return ret;
block/commit.c +70 -24
172 lines not on this page · raw message
block/monitor/block-hmp-cmds.c +1 -1
@@ -217,7 +217,7 @@ void hmp_commit(Monitor *mon, const QDict *qdict)return ; } - bs =blk_bs (blk); + bs =bdrv_skip_implicit_filters (blk_bs (blk)); aio_context =bdrv_get_aio_context (bs);aio_context_acquire (aio_context);
blockdev.c +3 -1
@@ -2703,7 +2703,9 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,assert (bdrv_get_aio_context (base_bs) == aio_context); -for (iter = top_bs; iter !=backing_bs (base_bs); iter =backing_bs (iter)) { +for (iter = top_bs; iter !=bdrv_filter_or_cow_bs (base_bs); + iter =bdrv_filter_or_cow_bs (iter)) + {if (bdrv_op_is_blocked (iter,BLOCK_OP_TYPE_COMMIT_TARGET , errp)) { goto out; }
Signature · 1 line
2.26.2
PATCH v8 32/43 nbd: Use CAF when looking for dirty bitmap
In reply to Max ReitzWhen looking for a dirty bitmap to share, we should handle filters by just including them in the search (so they do not break backing chains).
--- nbd/server.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
nbd/server.c +3 -3
@@ -1567,13 +1567,13 @@ NBDExport *nbd_export_new(BlockDriverState *bs, uint64_t dev_offset,if (bitmap) {BdrvDirtyBitmap *bm =NULL ; -while (true) { +while (bs) { bm =bdrv_find_dirty_bitmap (bs, bitmap); -if (bm !=NULL || bs->backing ==NULL ) { +if (bm !=NULL ) {break ; } - bs = bs->backing->bs; + bs =bdrv_filter_or_cow_bs (bs); }if (bm ==NULL ) {
Signature · 1 line
2.26.2
PATCH v8 33/43 qemu-img: Use child access functions
In reply to Max ReitzThis changes iotest 204's output, because blkdebug on top of a COW node used to make qemu-img map disregard the rest of the backing chain (the backing chain was broken by the filter). With this patch, the allocation in the base image is reported correctly.
--- qemu-img.c | 43 +++++++++++++++++++++++--------------- tests/qemu-iotests/204.out | 1 + 2 files changed, 27 insertions(+), 17 deletions(-)
qemu-img.c +26 -17
@@ -1084,7 +1084,7 @@ static int img_commit(int argc, char **argv)/* This is different from QMP, which by default uses the deepest file in * the backing chain (i.e., the very base); however, the traditional * behavior of qemu-img commit is using the immediate backing file. */ - base_bs =backing_bs (bs); + base_bs =bdrv_backing_chain_next (bs);if (!base_bs) {error_setg (&local_err,"Image does not have a backing file" ); goto done;
@@ -1731,18 +1731,20 @@ static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)if (s->sector_next_status <= sector_num) {uint64_t offset = (sector_num - src_cur_offset) *BDRV_SECTOR_SIZE ;int64_t count; +BlockDriverState *src_bs =blk_bs (s->src[src_cur]); +BlockDriverState *base; + +if (s->target_has_backing) { + base =bdrv_cow_bs (bdrv_skip_filters (src_bs)); + }else { + base =NULL ; + } do { count = n * BDRV_SECTOR_SIZE; - if (s->target_has_backing) { - ret = bdrv_block_status(blk_bs(s->src[src_cur]), offset, - count, &count, NULL, NULL); - } else { - ret = bdrv_block_status_above(blk_bs(s->src[src_cur]), NULL, - offset, count, &count, NULL, - NULL); - } + ret = bdrv_block_status_above(src_bs, base, offset, count, &count, + NULL, NULL); if (ret < 0) { if (s->salvage) {
@@ -2664,7 +2666,8 @@ static int img_convert(int argc, char **argv)* s.target_backing_sectors has to be negative, which it will * be automatically). The backing file length is used only * for optimizations, so such a case is not fatal. */ - s.target_backing_sectors =bdrv_nb_sectors (out_bs->backing->bs); + s.target_backing_sectors = +bdrv_nb_sectors (bdrv_backing_chain_next (out_bs)); }else { s.target_backing_sectors =-1 ; }
@@ -3034,6 +3037,7 @@ static int get_block_status(BlockDriverState *bs, int64_t offset, depth =0 ;for (;;) { + bs =bdrv_skip_filters (bs); ret =bdrv_block_status (bs, offset, bytes, &bytes, &map, &file);if (ret <0 ) {return ret;
@@ -3042,7 +3046,7 @@ static int get_block_status(BlockDriverState *bs, int64_t offset,if (ret & (BDRV_BLOCK_ZERO |BDRV_BLOCK_DATA )) {break ; } - bs =backing_bs (bs); + bs =bdrv_cow_bs (bs);if (bs ==NULL ) { ret =0 ;break ;
@@ -3424,6 +3428,7 @@ static int img_rebase(int argc, char **argv)uint8_t *buf_old =NULL ;uint8_t *buf_new =NULL ;BlockDriverState *bs =NULL , *prefix_chain_bs =NULL ; +BlockDriverState *unfiltered_bs;char *filename;const char *fmt, *cache, *src_cache, *out_basefmt, *out_baseimg;int c, flags, src_flags, ret;
@@ -3558,6 +3563,8 @@ static int img_rebase(int argc, char **argv) } bs =blk_bs (blk); + unfiltered_bs =bdrv_skip_filters (bs); +if (out_basefmt !=NULL ) {if (bdrv_find_format (out_basefmt) ==NULL ) {error_report ("Invalid format name: '%s'" , out_basefmt);
@@ -3569,7 +3576,7 @@ static int img_rebase(int argc, char **argv)/* For safe rebasing we need to compare old and new backing file */ if (!unsafe) {QDict *options =NULL ; -BlockDriverState *base_bs =backing_bs (bs); +BlockDriverState *base_bs =bdrv_cow_bs (unfiltered_bs);if (base_bs) { blk_old_backing = blk_new(qemu_get_aio_context(),
@@ -3710,7 +3717,7 @@ static int img_rebase(int argc, char **argv) n =MIN (IO_BUF_SIZE , size - offset);/* If the cluster is allocated, we don't need to take action */ - ret =bdrv_is_allocated (bs, offset, n, &n); + ret =bdrv_is_allocated (unfiltered_bs, offset, n, &n);if (ret <0 ) {error_report ("error while reading image metadata: %s" ,strerror (-ret));
@@ -3725,8 +3732,9 @@ static int img_rebase(int argc, char **argv)* If cluster wasn't changed since prefix_chain, we don't need * to take action */ - ret =bdrv_is_allocated_above (backing_bs (bs), prefix_chain_bs, - false, offset, n, &n); + ret =bdrv_is_allocated_above (bdrv_cow_bs (unfiltered_bs), + prefix_chain_bs, false, + offset, n, &n);if (ret <0 ) {error_report ("error while reading image metadata: %s" ,strerror (-ret));
@@ -3804,9 +3812,10 @@ static int img_rebase(int argc, char **argv)* doesn't change when we switch the backing file. */ if (out_baseimg && *out_baseimg) { - ret =bdrv_change_backing_file (bs, out_baseimg, out_basefmt, true); + ret =bdrv_change_backing_file (unfiltered_bs, out_baseimg, out_basefmt, + true); }else { - ret =bdrv_change_backing_file (bs,NULL ,NULL , false); + ret =bdrv_change_backing_file (unfiltered_bs,NULL ,NULL , false); }if (ret == -ENOSPC ) {
tests/qemu-iotests/204.out +1 -0
@@ -59,5 +59,6 @@ Offset Length File 0x900000 0x2400000 TEST_DIR/t.IMGFMT 0x3c00000 0x1100000 TEST_DIR/t.IMGFMT 0x6a00000 0x400000 TEST_DIR/t.IMGFMT +0x6e00000 0x1200000 TEST_DIR/t.IMGFMT.base No errors were found on the image. *** done
Signature · 1 line
2.26.2
PATCH v8 34/43 block: Drop backing_bs()
In reply to Max ReitzWe want to make it explicit where bs->backing is used, and we have done so. The old role of backing_bs() is now effectively taken by bdrv_cow_bs().
--- include/block/block_int.h | 5 ----- 1 file changed, 5 deletions(-)
include/block/block_int.h +0 -5
@@ -1003,11 +1003,6 @@ typedef enum BlockMirrorBackingMode { MIRROR_LEAVE_BACKING_CHAIN, } BlockMirrorBackingMode; -static inline BlockDriverState *backing_bs (BlockDriverState *bs) -{ -return bs->backing ? bs->backing->bs :NULL ; -} -/* Essential block drivers which must always be statically linked into qemu, and * which therefore can be accessed without using bdrv_find_format() */
Signature · 1 line
2.26.2
PATCH v8 35/43 blockdev: Fix active commit choice
In reply to Max ReitzWe have to perform an active commit whenever the top node has a parent that has taken the WRITE permission on it.
This means that block-commit's @backing-file parameter is longer allowed for such nodes, and that users will have to issue a block-job-complete command. Neither should pose a problem in practice, because this case was basically just broken until now.
(Since this commit already touches block-commit's documentation, it also moves up the chunk explaining general block-commit behavior that for some reason was situated under @backing-file.)
--- qapi/block-core.json | 39 ++++++++++++++++++++------------------- blockdev.c | 35 ++++++++++++++++++++++++++++++----- 2 files changed, 50 insertions(+), 24 deletions(-)
qapi/block-core.json +20 -19
@@ -1569,6 +1569,18 @@ # Live commit of data from overlay image nodes into backing nodes - i.e., # writes data between 'top' and 'base' into 'base'. # +# If top == base, that is an error. +# If top has no overlays on top of it, or if it is in use by a writer, +# the job will not be completed by itself. The user needs to complete +# the job with the block-job-complete command after getting the ready +# event. (Since 2.0) +# +# If the base image is smaller than top, then the base image will be +# resized to be the same size as top. If top is smaller than the base +# image, the base will not be truncated. If you want the base image +# size to match the size of the smaller top, you can safely truncate +# it yourself once the commit operation successfully completes. +# # @job-id: identifier for the newly-created block job. If # omitted, the device name will be used. (Since 2.7) #
@@ -1593,14 +1605,15 @@ # accepted # # @backing-file: The backing file string to write into the overlay -# image of 'top'. If 'top' is the active layer, -# specifying a backing file string is an error. This -# filename is not validated. +# image of 'top'. If 'top' does not have an overlay +# image, or if 'top' is in use by a writer, specifying +# a backing file string is an error. # -# If a pathname string is such that it cannot be -# resolved by QEMU, that means that subsequent QMP or -# HMP commands must use node-names for the image in -# question, as filename lookup methods will fail. +# This filename is not validated. If a pathname string +# is such that it cannot be resolved by QEMU, that +# means that subsequent QMP or HMP commands must use +# node-names for the image in question, as filename +# lookup methods will fail. # # If not specified, QEMU will automatically determine # the backing file string to use, or error out if
@@ -1609,18 +1622,6 @@ # filename or protocol. # (Since 2.1) # -# If top == base, that is an error. -# If top == active, the job will not be completed by itself, -# user needs to complete the job with the block-job-complete -# command after getting the ready event. (Since 2.0) -# -# If the base image is smaller than top, then the base image -# will be resized to be the same size as top. If top is -# smaller than the base image, the base will not be -# truncated. If you want the base image size to match the -# size of the smaller top, you can safely truncate it -# yourself once the commit operation successfully completes. -# # @speed: the maximum speed, in bytes per second # # @on-error: the action to take on an error. 'ignore' means that the request
blockdev.c +30 -5
@@ -2602,6 +2602,7 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device,AioContext *aio_context;Error *local_err =NULL ;int job_flags =JOB_DEFAULT ; +uint64_t top_perm, top_shared;if (!has_speed) { speed =0 ;
@@ -2717,14 +2718,38 @@ void qmp_block_commit(bool has_job_id, const char *job_id, const char *device, goto out; } -if (top_bs == bs) { +/* +* Active commit is required if and only if someone has taken a +* WRITE permission on the top node. Historically, we have always +* used active commit for top nodes, so continue that practice +* lest we possibly break clients that rely on this behavior, e.g. +* to later attach this node to a writing parent. +* (Active commit is never really wrong.) +*/ +bdrv_get_cumulative_perm (top_bs, &top_perm, &top_shared); +if (top_perm &BLK_PERM_WRITE || +bdrv_skip_filters (top_bs) ==bdrv_skip_filters (bs)) + {if (has_backing_file) { -error_setg (errp,"'backing-file' specified," -" but 'top' is the active layer" ); +if (bdrv_skip_filters (top_bs) ==bdrv_skip_filters (bs)) { +error_setg (errp,"'backing-file' specified," +" but 'top' is the active layer" ); + }else { +error_setg (errp,"'backing-file' specified, but 'top' has a " +"writer on it" ); + } goto out; } -commit_active_start (has_job_id ? job_id :NULL , bs, base_bs, - job_flags, speed, on_error, +if (!has_job_id) { +/* +* Emulate here what block_job_create() does, because it +* is possible that @bs != @top_bs (the block job should +* be named after @bs, even if @top_bs is the actual +* source) +*/ + job_id =bdrv_get_device_name (bs); + } +commit_active_start (job_id, top_bs, base_bs, job_flags, speed, on_error, filter_node_name,NULL ,NULL , false, &local_err); }else {BlockDriverState *overlay_bs =bdrv_find_overlay (bs, top_bs);
Signature · 1 line
2.26.2
Re: [PATCH v8 35/43] blockdev: Fix active commit choice
Am 01.09.2020 um 16:34 hat Max Reitz geschrieben:
Quoted 4 lines
We have to perform an active commit whenever the top node has a parent that has taken the WRITE permission on it.
This means that block-commit's @backing-file parameter is longer allowed
s/longer/no longer/
Quoted 9 lines
for such nodes, and that users will have to issue a block-job-complete command. Neither should pose a problem in practice, because this case was basically just broken until now.
(Since this commit already touches block-commit's documentation, it also moves up the chunk explaining general block-commit behavior that for some reason was situated under @backing-file.)
Signed-off-by Max Reitz <[email protected]>
Kevin
PATCH v8 36/43 block: Inline bdrv_co_block_status_from_*()
In reply to Max ReitzWith bdrv_filter_bs(), we can easily handle this default filter behavior in bdrv_co_block_status().
blkdebug wants to have an additional assertion, so it keeps its own implementation, except bdrv_co_block_status_from_file() needs to be inlined there.
--- include/block/block_int.h | 22 ----------------- block/backup-top.c | 2 -- block/blkdebug.c | 7 ++++-- block/blklogwrites.c | 1 - block/commit.c | 1 - block/copy-on-read.c | 2 -- block/filter-compress.c | 2 -- block/io.c | 51 +++++++++++++-------------------------- block/mirror.c | 1 - block/throttle.c | 1 - 10 files changed, 22 insertions(+), 68 deletions(-)
include/block/block_int.h +0 -22
@@ -1303,28 +1303,6 @@ void bdrv_default_perms(BlockDriverState *bs, BdrvChild *c, uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared); -/* -* Default implementation for drivers to pass bdrv_co_block_status() to -* their file. -*/ -int coroutine_fn bdrv_co_block_status_from_file(BlockDriverState *bs, -bool want_zero, -int64_t offset, -int64_t bytes, -int64_t *pnum, -int64_t *map, -BlockDriverState **file); -/* -* Default implementation for drivers to pass bdrv_co_block_status() to -* their backing file. -*/ -int coroutine_fn bdrv_co_block_status_from_backing(BlockDriverState *bs, -bool want_zero, -int64_t offset, -int64_t bytes, -int64_t *pnum, -int64_t *map, -BlockDriverState **file);const char *bdrv_get_parent_name (const BlockDriverState *bs);void blk_dev_change_media_cb (BlockBackend *blk,bool load,Error **errp);bool blk_dev_has_removable_media (BlockBackend *blk);
block/backup-top.c +0 -2
@@ -175,8 +175,6 @@ BlockDriver bdrv_backup_top_filter = { .bdrv_co_pdiscard = backup_top_co_pdiscard, .bdrv_co_flush = backup_top_co_flush, - .bdrv_co_block_status = bdrv_co_block_status_from_backing, - .bdrv_refresh_filename = backup_top_refresh_filename, .bdrv_child_perm = backup_top_child_perm,
block/blkdebug.c +5 -2
@@ -752,8 +752,11 @@ static int coroutine_fn blkdebug_co_block_status(BlockDriverState *bs,return err; } -return bdrv_co_block_status_from_file (bs, want_zero, offset, bytes, - pnum, map, file); +assert (bs->file && bs->file->bs); + *pnum = bytes; + *map = offset; + *file = bs->file->bs; +return BDRV_BLOCK_RAW |BDRV_BLOCK_OFFSET_VALID ; }static void blkdebug_close (BlockDriverState *bs)
block/blklogwrites.c +0 -1
@@ -515,7 +515,6 @@ static BlockDriver bdrv_blk_log_writes = { .bdrv_co_pwrite_zeroes = blk_log_writes_co_pwrite_zeroes, .bdrv_co_flush_to_disk = blk_log_writes_co_flush_to_disk, .bdrv_co_pdiscard = blk_log_writes_co_pdiscard, - .bdrv_co_block_status = bdrv_co_block_status_from_file, .is_filter = true, .strong_runtime_opts = blk_log_writes_strong_runtime_opts,
block/commit.c +0 -1
@@ -238,7 +238,6 @@ static void bdrv_commit_top_child_perm(BlockDriverState *bs, BdrvChild *c,static BlockDriver bdrv_commit_top = { .format_name ="commit_top" , .bdrv_co_preadv = bdrv_commit_top_preadv, - .bdrv_co_block_status = bdrv_co_block_status_from_backing, .bdrv_refresh_filename = bdrv_commit_top_refresh_filename, .bdrv_child_perm = bdrv_commit_top_child_perm,
block/copy-on-read.c +0 -2
@@ -146,8 +146,6 @@ static BlockDriver bdrv_copy_on_read = { .bdrv_eject = cor_eject, .bdrv_lock_medium = cor_lock_medium, - .bdrv_co_block_status = bdrv_co_block_status_from_file, - .has_variable_length = true, .is_filter = true, };
block/filter-compress.c +0 -2
@@ -146,8 +146,6 @@ static BlockDriver bdrv_compress = { .bdrv_eject = compress_eject, .bdrv_lock_medium = compress_lock_medium, - .bdrv_co_block_status = bdrv_co_block_status_from_file, - .has_variable_length = true, .is_filter = true, };
block/io.c +17 -34
75 lines not on this page · raw message
block/mirror.c +0 -1
@@ -1531,7 +1531,6 @@ static BlockDriver bdrv_mirror_top = { .bdrv_co_pwrite_zeroes = bdrv_mirror_top_pwrite_zeroes, .bdrv_co_pdiscard = bdrv_mirror_top_pdiscard, .bdrv_co_flush = bdrv_mirror_top_flush, - .bdrv_co_block_status = bdrv_co_block_status_from_backing, .bdrv_refresh_filename = bdrv_mirror_top_refresh_filename, .bdrv_child_perm = bdrv_mirror_top_child_perm,
block/throttle.c +0 -1
@@ -260,7 +260,6 @@ static BlockDriver bdrv_throttle = { .bdrv_reopen_prepare = throttle_reopen_prepare, .bdrv_reopen_commit = throttle_reopen_commit, .bdrv_reopen_abort = throttle_reopen_abort, - .bdrv_co_block_status = bdrv_co_block_status_from_file, .bdrv_co_drain_begin = throttle_co_drain_begin, .bdrv_co_drain_end = throttle_co_drain_end,
Signature · 1 line
2.26.2
PATCH v8 37/43 block: Leave BDS.backing_{file,format} constant
In reply to Max ReitzParts of the block layer treat BDS.backing_file as if it were whatever the image header says (i.e., if it is a relative path, it is relative to the overlay), other parts treat it like a cache for bs->backing->bs->filename (relative paths are relative to the CWD). Considering bs->backing->bs->filename exists, let us make it mean the former.
Among other things, this now allows the user to specify a base when using qemu-img to commit an image file in a directory that is not the CWD (assuming, everything uses relative filenames).
Before this patch:
$ ./qemu-img create -f qcow2 foo/bot.qcow2 1M $ ./qemu-img create -f qcow2 -b bot.qcow2 foo/mid.qcow2 $ ./qemu-img create -f qcow2 -b mid.qcow2 foo/top.qcow2 $ ./qemu-img commit -b mid.qcow2 foo/top.qcow2 qemu-img: Did not find 'mid.qcow2' in the backing chain of 'foo/top.qcow2' $ ./qemu-img commit -b foo/mid.qcow2 foo/top.qcow2 qemu-img: Did not find 'foo/mid.qcow2' in the backing chain of 'foo/top.qcow2' $ ./qemu-img commit -b $PWD/foo/mid.qcow2 foo/top.qcow2 qemu-img: Did not find '[...]/foo/mid.qcow2' in the backing chain of 'foo/top.qcow2'
After this patch:
$ ./qemu-img commit -b mid.qcow2 foo/top.qcow2 Image committed. $ ./qemu-img commit -b foo/mid.qcow2 foo/top.qcow2 qemu-img: Did not find 'foo/mid.qcow2' in the backing chain of 'foo/top.qcow2' $ ./qemu-img commit -b $PWD/foo/mid.qcow2 foo/top.qcow2 Image committed.
With this change, bdrv_find_backing_image() must look at whether the user has overridden a BDS's backing file. If so, it can no longer use bs->backing_file, but must instead compare the given filename against the backing node's filename directly.
Note that this changes the QAPI output for a node's backing_file. We had very inconsistent output there (sometimes what the image header said, sometimes the actual filename of the backing image). This inconsistent output was effectively useless, so we have to decide one way or the other. Considering that bs->backing_file usually at runtime contained the path to the image relative to qemu's CWD (or absolute), this patch changes QAPI's backing_file to always report the bs->backing->bs->filename from now on. If you want to receive the image header information, you have to refer to full-backing-filename.
This necessitates a change to iotest 228. The interesting information it really wanted is the image header, and it can get that now, but it has to use full-backing-filename instead of backing_file. Because of this patch's changes to bs->backing_file's behavior, we also need some reference output changes.
Along with the changes to bs->backing_file, stop updating BDS.backing_format in bdrv_backing_attach() as well. This way, ImageInfo's backing-filename and backing-filename-format fields will represent what the image header says and nothing else.
iotest 245 changes in behavior: With the backing node no longer overriding the parent node's backing_file string, you can now omit the @backing option when reopening a node with neither a default nor a current backing file even if it used to have a backing node at some point.
273 also changes: The base image is opened without a format layer, so ImageInfo.backing-filename-format used to report "file" for the base image's overlay after blockdev-snapshot. However, the image header never says "file" anywhere, so it now reports $IMGFMT.
--- include/block/block_int.h | 21 ++++++++++++++++----- block.c | 35 +++++++++++++++++++++++++++-------- block/qapi.c | 8 +++++--- tests/qemu-iotests/228 | 6 +++--- tests/qemu-iotests/228.out | 6 +++--- tests/qemu-iotests/245 | 4 +++- tests/qemu-iotests/273.out | 4 ++-- 7 files changed, 59 insertions(+), 25 deletions(-)
include/block/block_int.h +16 -5
@@ -847,11 +847,20 @@ struct BlockDriverState {bool walking_aio_notifiers;/* to make removal during iteration safe */ char filename[PATH_MAX ]; -char backing_file[PATH_MAX ];/* if non zero, the image is a diff of -this file image */ -/* The backing filename indicated by the image header; if we ever -* open this file, then this is replaced by the resulting BDS's -* filename (i.e. after a bdrv_refresh_filename() run). */ +/* +* If not empty, this image is a diff in relation to backing_file. +* Note that this is the name given in the image header and +* therefore may or may not be equal to .backing->bs->filename. +* If this field contains a relative path, it is to be resolved +* relatively to the overlay's location. +*/ +char backing_file[PATH_MAX ]; +/* +* The backing filename indicated by the image header. Contrary +* to backing_file, if we ever open this file, auto_backing_file +* is replaced by the resulting BDS's filename (i.e. after a +* bdrv_refresh_filename() run). +*/ char auto_backing_file[PATH_MAX ];char backing_format[16 ];/* if non-zero and backing_file exists */
@@ -1053,6 +1062,8 @@ BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,void bdrv_parse_filename_strip_prefix (const char *filename,const char *prefix,QDict *options); +bool bdrv_backing_overridden (BlockDriverState *bs); +/** * bdrv_add_before_write_notifier:
block.c +27 -8
@@ -1155,10 +1155,6 @@ static void bdrv_backing_attach(BdrvChild *c)bdrv_refresh_filename (backing_hd); parent->open_flags &= ~BDRV_O_NO_BACKING ; -pstrcpy (parent->backing_file,sizeof (parent->backing_file), - backing_hd->filename); -pstrcpy (parent->backing_format,sizeof (parent->backing_format), - backing_hd->drv ? backing_hd->drv->format_name :"" );bdrv_op_block_all (backing_hd, parent->backing_blocker);/* Otherwise we won't be able to commit or stream */
@@ -5673,6 +5669,7 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,char *backing_file_full =NULL ;char *filename_tmp =NULL ;int is_protocol =0 ; +bool filenames_refreshed = false;BlockDriverState *curr_bs =NULL ;BlockDriverState *retval =NULL ;BlockDriverState *bs_below;
@@ -5698,9 +5695,31 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs, { bs_below =bdrv_backing_chain_next (curr_bs); -/* If either of the filename paths is actually a protocol, then -* compare unmodified paths; otherwise make paths relative */ -if (is_protocol ||path_has_protocol (curr_bs->backing_file)) { +if (bdrv_backing_overridden (curr_bs)) { +/* +* If the backing file was overridden, we can only compare +* directly against the backing node's filename. +*/ + +if (!filenames_refreshed) { +/* +* This will automatically refresh all of the +* filenames in the rest of the backing chain, so we +* only need to do this once. +*/ +bdrv_refresh_filename (bs_below); + filenames_refreshed = true; + } + +if (strcmp (backing_file, bs_below->filename) ==0 ) { + retval = bs_below; +break ; + } + }else if (is_protocol ||path_has_protocol (curr_bs->backing_file)) { +/* +* If either of the filename paths is actually a protocol, then +* compare unmodified paths; otherwise make paths relative. +*/ char *backing_file_full_ret;if (strcmp (backing_file, curr_bs->backing_file) ==0 ) {
@@ -6820,7 +6839,7 @@ static bool append_strong_runtime_options(QDict *d, BlockDriverState *bs)/* Note: This function may return false positives; it may return true * even if opening the backing file specified by bs's image header * would result in exactly bs->backing. */ -static bool bdrv_backing_overridden (BlockDriverState *bs) +bool bdrv_backing_overridden (BlockDriverState *bs) {if (bs->backing) { return strcmp(bs->auto_backing_file,
block/qapi.c +5 -3
@@ -47,7 +47,7 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, Error **errp) {ImageInfo **p_image_info; -BlockDriverState *bs0; +BlockDriverState *bs0, *backing;BlockDeviceInfo *info;if (!bs->drv) {
@@ -76,9 +76,10 @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk, info->node_name =g_strdup (bs->node_name); } -if (bs->backing_file[0 ]) { + backing =bdrv_cow_bs (bs); +if (backing) { info->has_backing_file = true; - info->backing_file =g_strdup (bs->backing_file); + info->backing_file =g_strdup (backing->filename); }if (!QLIST_EMPTY (&bs->dirty_bitmaps)) {
@@ -314,6 +315,7 @@ void bdrv_query_image_info(BlockDriverState *bs, backing_filename = bs->backing_file;if (backing_filename[0 ] !='\0' ) {char *backing_filename2; + info->backing_filename =g_strdup (backing_filename); info->has_backing_filename = true; backing_filename2 =bdrv_get_full_backing_filename (bs,NULL );
tests/qemu-iotests/228 +3 -3
@@ -36,7 +36,7 @@ def log_node_info(node): log('bs->filename: ' + node['image']['filename'], filters=[filter_testfiles, filter_imgfmt]) - log('bs->backing_file: ' + node['backing_file'], + log('bs->backing_file: ' + node['image']['full-backing-filename'], filters=[filter_testfiles, filter_imgfmt]) if 'backing-image' in node['image']:
@@ -73,8 +73,8 @@ with iotests.FilePath('base.img') as base_img_path, \ }, filters=[filter_qmp_testfiles, filter_qmp_imgfmt]) - # Filename should be plain, and the backing filename should not - # contain the "file:" prefix + # Filename should be plain, and the backing node filename should + # not contain the "file:" prefix log_node_info(vm.node_info('node0')) vm.qmp_log('blockdev-del', node_name='node0')
tests/qemu-iotests/228.out +3 -3
@@ -4,7 +4,7 @@ {"return": {}} bs->filename: TEST_DIR/PID-top.img -bs->backing_file: TEST_DIR/PID-base.img +bs->backing_file: file:TEST_DIR/PID-base.img bs->backing->bs->filename: TEST_DIR/PID-base.img {"execute": "blockdev-del", "arguments": {"node-name": "node0"}}
@@ -41,7 +41,7 @@ bs->backing->bs->filename: TEST_DIR/PID-base.img {"return": {}} bs->filename: TEST_DIR/PID-top.img -bs->backing_file: TEST_DIR/PID-base.img +bs->backing_file: file:TEST_DIR/PID-base.img bs->backing->bs->filename: TEST_DIR/PID-base.img {"execute": "blockdev-del", "arguments": {"node-name": "node0"}}
@@ -55,7 +55,7 @@ bs->backing->bs->filename: TEST_DIR/PID-base.img {"return": {}} bs->filename: json:{"backing": {"driver": "null-co"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-top.img"}} -bs->backing_file: null-co:// +bs->backing_file: TEST_DIR/PID-base.img bs->backing->bs->filename: null-co:// {"execute": "blockdev-del", "arguments": {"node-name": "node0"}}
tests/qemu-iotests/245 +3 -1
@@ -725,7 +725,9 @@ class TestBlockdevReopen(iotests.QMPTestCase): # Detach hd2 from hd0. self.reopen(opts, {'backing': None}) - self.reopen(opts, {}, "backing is missing for 'hd0'") + + # Without a backing file, we can omit 'backing' again + self.reopen(opts) # Remove both hd0 and hd2 result = self.vm.qmp('blockdev-del', conv_keys = True, node_name = 'hd0')
tests/qemu-iotests/273.out +2 -2
@@ -32,7 +32,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev "actual-size": SIZE, "dirty-flag": false }, - "backing-filename-format": "file", + "backing-filename-format": "IMGFMT", "virtual-size": 67108864, "filename": "TEST_DIR/t.IMGFMT.mid", "cluster-size": 65536,
@@ -112,7 +112,7 @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev "actual-size": SIZE, "dirty-flag": false }, - "backing-filename-format": "file", + "backing-filename-format": "IMGFMT", "virtual-size": 67108864, "filename": "TEST_DIR/t.IMGFMT.mid", "cluster-size": 65536,
Signature · 1 line
2.26.2
PATCH v8 38/43 iotests: Test that qcow2's data-file is flushed
In reply to Max ReitzFlushing a qcow2 node must lead to the data-file node being flushed as well.
--- tests/qemu-iotests/244 | 49 ++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/244.out | 7 ++++++ 2 files changed, 56 insertions(+)
tests/qemu-iotests/244 +49 -0
@@ -217,6 +217,55 @@ $QEMU_IMG amend -f $IMGFMT -o "data_file=blkdebug::$TEST_IMG.data" "$TEST_IMG" $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n -C "$TEST_IMG.src" "$TEST_IMG" $QEMU_IMG compare -f $IMGFMT -F $IMGFMT "$TEST_IMG.src" "$TEST_IMG" +echo +echo "=== Flushing should flush the data file ===" +echo + +# We are going to flush a qcow2 file with a blkdebug node inserted +# between the qcow2 node and its data file node. The blkdebug node +# will return an error for all flushes and so we if the data file is +# flushed, we will see qemu-io return an error. + +# We need to write something or the flush will not do anything; we +# also need -t writeback so the write is not done as a FUA write +# (which would then fail thanks to the implicit flush) +$QEMU_IO -c 'write 0 512' -c flush \ + -t writeback \ + "json:{ + 'driver': 'qcow2', + 'file': { + 'driver': 'file', + 'filename': '$TEST_IMG' + }, + 'data-file': { + 'driver': 'blkdebug', + 'inject-error': [{ + 'event': 'none', + 'iotype': 'flush' + }], + 'image': { + 'driver': 'file', + 'filename': '$TEST_IMG.data' + } + } + }" \ + | _filter_qemu_io + +result=${PIPESTATUS[0]} +echo + +case $result in + 0) + echo "ERROR: qemu-io succeeded, so the data file was not flushed" + ;; + 1) + echo "Success: qemu-io failed, so the data file was flushed" + ;; + *) + echo "ERROR: qemu-io returned unknown exit code $result" + ;; +esac + # success, all done echo "*** done" rm -f $seq.full
tests/qemu-iotests/244.out +7 -0
@@ -131,4 +131,11 @@ Offset Length Mapped to File Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 data_file=TEST_DIR/t.IMGFMT.data Images are identical. Images are identical. + +=== Flushing should flush the data file === + +wrote 512/512 bytes at offset 0 +512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) + +Success: qemu-io failed, so the data file was flushed *** done
Signature · 1 line
2.26.2
PATCH v8 39/43 iotests: Let complete_and_wait() work with commit
In reply to Max Reitzcomplete_and_wait() and wait_ready() currently only work for mirror jobs. Let them work for active commit jobs, too.
--- tests/qemu-iotests/iotests.py | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
tests/qemu-iotests/iotests.py +7 -3
@@ -972,8 +972,12 @@ class QMPTestCase(unittest.TestCase): def wait_ready(self, drive='drive0'): """Wait until a BLOCK_JOB_READY event, and return the event.""" - f = {'data': {'type': 'mirror', 'device': drive}} - return self.vm.event_wait(name='BLOCK_JOB_READY', match=f) + return self.vm.events_wait([ + ('BLOCK_JOB_READY', + {'data': {'type': 'mirror', 'device': drive}}), + ('BLOCK_JOB_READY', + {'data': {'type': 'commit', 'device': drive}}) + ]) def wait_ready_and_cancel(self, drive='drive0'): self.wait_ready(drive=drive)
@@ -992,7 +996,7 @@ class QMPTestCase(unittest.TestCase): self.assert_qmp(result, 'return', {}) event = self.wait_until_completed(drive=drive, error=completion_error) - self.assert_qmp(event, 'data/type', 'mirror') + self.assertTrue(event['data']['type'] in ['mirror', 'commit']) def pause_wait(self, job_id='job0'): with Timeout(3, "Timeout waiting for job to pause"):
Signature · 1 line
2.26.2
PATCH v8 40/43 iotests: Add filter commit test cases
In reply to Max ReitzThis patch adds some tests on how commit copes with filter nodes.
--- tests/qemu-iotests/040 | 177 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/040.out | 4 +- 2 files changed, 179 insertions(+), 2 deletions(-)
tests/qemu-iotests/040 +177 -0
@@ -734,6 +734,183 @@ class TestErrorHandling(iotests.QMPTestCase): self.assertTrue(iotests.compare_images(mid_img, backing_img, fmt2='raw'), 'target image does not match source after commit') +class TestCommitWithFilters(iotests.QMPTestCase): + img0 = os.path.join(iotests.test_dir, '0.img') + img1 = os.path.join(iotests.test_dir, '1.img') + img2 = os.path.join(iotests.test_dir, '2.img') + img3 = os.path.join(iotests.test_dir, '3.img') + + def do_test_io(self, read_or_write): + for index, pattern_file in enumerate(self.pattern_files): + result = qemu_io('-f', iotests.imgfmt, + '-c', + f'{read_or_write} -P {index + 1} {index}M 1M', + pattern_file) + self.assertFalse('Pattern verification failed' in result) + + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, self.img0, '64M') + qemu_img('create', '-f', iotests.imgfmt, self.img1, '64M') + qemu_img('create', '-f', iotests.imgfmt, self.img2, '64M') + qemu_img('create', '-f', iotests.imgfmt, self.img3, '64M') + + # Distributions of the patterns in the files; this is checked + # by tearDown() and should be changed by the test cases as is + # necessary + self.pattern_files = [self.img0, self.img1, self.img2, self.img3] + + self.do_test_io('write') + + self.vm = iotests.VM() + self.vm.launch() + + result = self.vm.qmp('object-add', qom_type='throttle-group', id='tg') + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('blockdev-add', **{ + 'node-name': 'top-filter', + 'driver': 'throttle', + 'throttle-group': 'tg', + 'file': { + 'node-name': 'cow-3', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img3 + }, + 'backing': { + 'node-name': 'cow-2', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img2 + }, + 'backing': { + 'node-name': 'cow-1', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img1 + }, + 'backing': { + 'node-name': 'bottom-filter', + 'driver': 'throttle', + 'throttle-group': 'tg', + 'file': { + 'node-name': 'cow-0', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img0 + } + } + } + } + } + } + }) + self.assert_qmp(result, 'return', {}) + + def tearDown(self): + self.vm.shutdown() + self.do_test_io('read') + + os.remove(self.img3) + os.remove(self.img2) + os.remove(self.img1) + os.remove(self.img0) + + # Filters make for funny filenames, so we cannot just use + # self.imgX to get them + def get_filename(self, node): + return self.vm.node_info(node)['image']['filename'] + + def test_filterless_commit(self): + result = self.vm.qmp('block-commit', + job_id='commit', + device='top-filter', + top_node='cow-2', + base_node='cow-1') + self.assert_qmp(result, 'return', {}) + self.wait_until_completed(drive='commit') + + self.assertIsNotNone(self.vm.node_info('cow-3')) + self.assertIsNone(self.vm.node_info('cow-2')) + self.assertIsNotNone(self.vm.node_info('cow-1')) + + # 2 has been comitted into 1 + self.pattern_files[2] = self.img1 + + def test_commit_through_filter(self): + result = self.vm.qmp('block-commit', + job_id='commit', + device='top-filter', + top_node='cow-1', + base_node='cow-0') + self.assert_qmp(result, 'return', {}) + self.wait_until_completed(drive='commit') + + self.assertIsNotNone(self.vm.node_info('cow-2')) + self.assertIsNone(self.vm.node_info('cow-1')) + self.assertIsNone(self.vm.node_info('bottom-filter')) + self.assertIsNotNone(self.vm.node_info('cow-0')) + + # 1 has been comitted into 0 + self.pattern_files[1] = self.img0 + + def test_filtered_active_commit_with_filter(self): + # Add a device, so the commit job finds a parent it can change + # to point to the base node (so we can test that top-filter is + # dropped from the graph) + result = self.vm.qmp('device_add', id='drv0', driver='virtio-blk', + drive='top-filter') + self.assert_qmp(result, 'return', {}) + + # Try to release our reference to top-filter; that should not + # work because drv0 uses it + result = self.vm.qmp('blockdev-del', node_name='top-filter') + self.assert_qmp(result, 'error/class', 'GenericError') + self.assert_qmp(result, 'error/desc', 'Node top-filter is in use') + + result = self.vm.qmp('block-commit', + job_id='commit', + device='top-filter', + base_node='cow-2') + self.assert_qmp(result, 'return', {}) + self.complete_and_wait(drive='commit') + + # Try to release our reference to top-filter again + result = self.vm.qmp('blockdev-del', node_name='top-filter') + self.assert_qmp(result, 'return', {}) + + self.assertIsNone(self.vm.node_info('top-filter')) + self.assertIsNone(self.vm.node_info('cow-3')) + self.assertIsNotNone(self.vm.node_info('cow-2')) + + # Check that drv0 is now connected to cow-2 + blockdevs = self.vm.qmp('query-block')['return'] + drv0 = next(dev for dev in blockdevs if '/drv0' in dev['qdev']) + self.assertEqual(drv0['inserted']['node-name'], 'cow-2') + + # 3 has been comitted into 2 + self.pattern_files[3] = self.img2 + + def test_filtered_active_commit_without_filter(self): + result = self.vm.qmp('block-commit', + job_id='commit', + device='top-filter', + top_node='cow-3', + base_node='cow-2') + self.assert_qmp(result, 'return', {}) + self.complete_and_wait(drive='commit') + + self.assertIsNotNone(self.vm.node_info('top-filter')) + self.assertIsNone(self.vm.node_info('cow-3')) + self.assertIsNotNone(self.vm.node_info('cow-2')) + + # 3 has been comitted into 2 + self.pattern_files[3] = self.img2 + if __name__ == '__main__': iotests.main(supported_fmts=['qcow2', 'qed'], supported_protocols=['file'])
tests/qemu-iotests/040.out +2 -2
@@ -1,5 +1,5 @@ -........................................................... +............................................................... ---------------------------------------------------------------------- -Ran 59 tests +Ran 63 tests OK
Signature · 1 line
2.26.2
PATCH v8 41/43 iotests: Add filter mirror test cases
In reply to Max ReitzThis patch adds some test cases how mirroring relates to filters. One of them tests what happens when you mirror off a filtered COW node, two others use the mirror filter node as basically our only example of an implicitly created filter node so far (besides the commit filter).
--- tests/qemu-iotests/041 | 146 ++++++++++++++++++++++++++++++++++++- tests/qemu-iotests/041.out | 4 +- 2 files changed, 147 insertions(+), 3 deletions(-)
tests/qemu-iotests/041 +145 -1
@@ -21,8 +21,9 @@ import time import os import re +import json import iotests -from iotests import qemu_img, qemu_io +from iotests import qemu_img, qemu_img_pipe, qemu_io backing_img = os.path.join(iotests.test_dir, 'backing.img') target_backing_img = os.path.join(iotests.test_dir, 'target-backing.img')
@@ -1288,6 +1289,149 @@ class TestReplaces(iotests.QMPTestCase): self.vm.assert_block_path('filter0', '/file', 'target') +# Tests for mirror with filters (and how the mirror filter behaves, as +# an example for an implicit filter) +class TestFilters(iotests.QMPTestCase): + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, backing_img, '1M') + qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img, test_img) + qemu_img('create', '-f', iotests.imgfmt, '-b', backing_img, target_img) + + qemu_io('-c', 'write -P 1 0 512k', backing_img) + qemu_io('-c', 'write -P 2 512k 512k', test_img) + + self.vm = iotests.VM() + self.vm.launch() + + result = self.vm.qmp('blockdev-add', **{ + 'node-name': 'target', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': target_img + }, + 'backing': None + }) + self.assert_qmp(result, 'return', {}) + + self.filterless_chain = { + 'node-name': 'source', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': test_img + }, + 'backing': { + 'node-name': 'backing', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': backing_img + } + } + } + + def tearDown(self): + self.vm.shutdown() + + os.remove(test_img) + os.remove(target_img) + os.remove(backing_img) + + def test_cor(self): + result = self.vm.qmp('blockdev-add', **{ + 'node-name': 'filter', + 'driver': 'copy-on-read', + 'file': self.filterless_chain + }) + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('blockdev-mirror', + job_id='mirror', + device='filter', + target='target', + sync='top') + self.assert_qmp(result, 'return', {}) + + self.complete_and_wait('mirror') + + self.vm.qmp('blockdev-del', node_name='target') + + target_map = qemu_img_pipe('map', '--output=json', target_img) + target_map = json.loads(target_map) + + assert target_map[0]['start'] == 0 + assert target_map[0]['length'] == 512 * 1024 + assert target_map[0]['depth'] == 1 + + assert target_map[1]['start'] == 512 * 1024 + assert target_map[1]['length'] == 512 * 1024 + assert target_map[1]['depth'] == 0 + + def test_implicit_mirror_filter(self): + result = self.vm.qmp('blockdev-add', **self.filterless_chain) + self.assert_qmp(result, 'return', {}) + + # We need this so we can query from above the mirror node + result = self.vm.qmp('device_add', + driver='virtio-blk', + id='virtio', + bus='pci.0', + drive='source') + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('blockdev-mirror', + job_id='mirror', + device='source', + target='target', + sync='top') + self.assert_qmp(result, 'return', {}) + + # The mirror filter is now an implicit node, so it should be + # invisible when querying the backing chain + device_info = self.vm.qmp('query-block')['return'][0] + assert device_info['qdev'] == '/machine/peripheral/virtio/virtio-backend' + + assert device_info['inserted']['node-name'] == 'source' + + image_info = device_info['inserted']['image'] + assert image_info['filename'] == test_img + assert image_info['backing-image']['filename'] == backing_img + + self.complete_and_wait('mirror') + + def test_explicit_mirror_filter(self): + # Same test as above, but this time we give the mirror filter + # a node-name so it will not be invisible + result = self.vm.qmp('blockdev-add', **self.filterless_chain) + self.assert_qmp(result, 'return', {}) + + # We need this so we can query from above the mirror node + result = self.vm.qmp('device_add', + driver='virtio-blk', + id='virtio', + bus='pci.0', + drive='source') + self.assert_qmp(result, 'return', {}) + + result = self.vm.qmp('blockdev-mirror', + job_id='mirror', + device='source', + target='target', + sync='top', + filter_node_name='mirror-filter') + self.assert_qmp(result, 'return', {}) + + # With a node-name given to it, the mirror filter should now + # be visible + device_info = self.vm.qmp('query-block')['return'][0] + assert device_info['qdev'] == '/machine/peripheral/virtio/virtio-backend' + + assert device_info['inserted']['node-name'] == 'mirror-filter' + + self.complete_and_wait('mirror') + + if __name__ == '__main__': iotests.main(supported_fmts=['qcow2', 'qed'], supported_protocols=['file'],
tests/qemu-iotests/041.out +2 -2
@@ -1,5 +1,5 @@ -........................................................................................................ +........................................................................................................... ---------------------------------------------------------------------- -Ran 104 tests +Ran 107 tests OK
Signature · 1 line
2.26.2
PATCH v8 42/43 iotests: Add test for commit in sub directory
In reply to Max ReitzAdd a test for committing an overlay in a sub directory to one of the images in its backing chain, using both relative and absolute filenames.
--- tests/qemu-iotests/020 | 44 ++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/020.out | 10 +++++++++ 2 files changed, 54 insertions(+)
tests/qemu-iotests/020 +44 -0
@@ -31,6 +31,11 @@ _cleanup() _cleanup_test_img _rm_test_img "$TEST_IMG.base" _rm_test_img "$TEST_IMG.orig" + + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT.base" + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT.mid" + _rm_test_img "$TEST_DIR/subdir/t.$IMGFMT" + rmdir "$TEST_DIR/subdir" &> /dev/null } trap "_cleanup; exit \$status" 0 1 2 3 15
@@ -139,6 +144,45 @@ $QEMU_IO -c 'writev 0 64k' "$TEST_IMG" | _filter_qemu_io $QEMU_IMG commit "$TEST_IMG" _cleanup + +echo +echo 'Testing commit in sub-directory with relative filenames' +echo + +pushd "$TEST_DIR" > /dev/null + +mkdir subdir + +TEST_IMG="subdir/t.$IMGFMT.base" _make_test_img 1M +TEST_IMG="subdir/t.$IMGFMT.mid" _make_test_img -b "t.$IMGFMT.base" -F $IMGFMT +TEST_IMG="subdir/t.$IMGFMT" _make_test_img -b "t.$IMGFMT.mid" -F $IMGFMT + +# Should work +$QEMU_IMG commit -b "t.$IMGFMT.mid" "subdir/t.$IMGFMT" + +# Might theoretically work, but does not in practice (we have to +# decide between this and the above; and since we always represent +# backing file names as relative to the overlay, we go for the above) +$QEMU_IMG commit -b "subdir/t.$IMGFMT.mid" "subdir/t.$IMGFMT" 2>&1 | \ + _filter_imgfmt + +# This should work as well +$QEMU_IMG commit -b "$TEST_DIR/subdir/t.$IMGFMT.mid" "subdir/t.$IMGFMT" + +popd > /dev/null + +# Now let's try with just absolute filenames +# (This will not work with external data files, though, because when +# using relative paths for those, qemu will always resolve them +# relative to its CWD. Therefore, it cannot find those data files now +# that we left $TEST_DIR.) +if _get_data_file '' > /dev/null; then + echo 'Image committed.' # Skip test +else + $QEMU_IMG commit -b "$TEST_DIR/subdir/t.$IMGFMT.mid" \ + "$TEST_DIR/subdir/t.$IMGFMT" +fi + # success, all done echo "*** done" rm -f $seq.full
tests/qemu-iotests/020.out +10 -0
@@ -1083,4 +1083,14 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=json:{'driv wrote 65536/65536 bytes at offset 0 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec) qemu-img: Block job failed: No space left on device + +Testing commit in sub-directory with relative filenames + +Formatting 'subdir/t.IMGFMT.base', fmt=IMGFMT size=1048576 +Formatting 'subdir/t.IMGFMT.mid', fmt=IMGFMT size=1048576 backing_file=t.IMGFMT.base backing_fmt=IMGFMT +Formatting 'subdir/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=t.IMGFMT.mid backing_fmt=IMGFMT +Image committed. +qemu-img: Did not find 'subdir/t.IMGFMT.mid' in the backing chain of 'subdir/t.IMGFMT' +Image committed. +Image committed. *** done
Signature · 1 line
2.26.2
PATCH v8 43/43 iotests: Test committing to overridden backing
In reply to Max Reitz--- tests/qemu-iotests/040 | 61 ++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/040.out | 4 +-- 2 files changed, 63 insertions(+), 2 deletions(-)
tests/qemu-iotests/040 +61 -0
@@ -911,6 +911,67 @@ class TestCommitWithFilters(iotests.QMPTestCase): # 3 has been comitted into 2 self.pattern_files[3] = self.img2 +class TestCommitWithOverriddenBacking(iotests.QMPTestCase): + img_base_a = os.path.join(iotests.test_dir, 'base_a.img') + img_base_b = os.path.join(iotests.test_dir, 'base_b.img') + img_top = os.path.join(iotests.test_dir, 'top.img') + + def setUp(self): + qemu_img('create', '-f', iotests.imgfmt, self.img_base_a, '1M') + qemu_img('create', '-f', iotests.imgfmt, self.img_base_b, '1M') + qemu_img('create', '-f', iotests.imgfmt, '-b', self.img_base_a, \ + self.img_top) + + self.vm = iotests.VM() + self.vm.launch() + + # Use base_b instead of base_a as the backing of top + result = self.vm.qmp('blockdev-add', **{ + 'node-name': 'top', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img_top + }, + 'backing': { + 'node-name': 'base', + 'driver': iotests.imgfmt, + 'file': { + 'driver': 'file', + 'filename': self.img_base_b + } + } + }) + self.assert_qmp(result, 'return', {}) + + def tearDown(self): + self.vm.shutdown() + os.remove(self.img_top) + os.remove(self.img_base_a) + os.remove(self.img_base_b) + + def test_commit_to_a(self): + # Try committing to base_a (which should fail, as top's + # backing image is base_b instead) + result = self.vm.qmp('block-commit', + job_id='commit', + device='top', + base=self.img_base_a) + self.assert_qmp(result, 'error/class', 'GenericError') + + def test_commit_to_b(self): + # Try committing to base_b (which should work, since that is + # actually top's backing image) + result = self.vm.qmp('block-commit', + job_id='commit', + device='top', + base=self.img_base_b) + self.assert_qmp(result, 'return', {}) + + self.vm.event_wait('BLOCK_JOB_READY') + self.vm.qmp('block-job-complete', device='commit') + self.vm.event_wait('BLOCK_JOB_COMPLETED') + if __name__ == '__main__': iotests.main(supported_fmts=['qcow2', 'qed'], supported_protocols=['file'])
tests/qemu-iotests/040.out +2 -2
@@ -1,5 +1,5 @@ -............................................................... +................................................................. ---------------------------------------------------------------------- -Ran 63 tests +Ran 65 tests OK
Signature · 1 line
2.26.2
Am 01.09.2020 um 16:33 hat Max Reitz geschrieben:
Quoted 7 lines
v6: https://lists.nongnu.org/archive/html/qemu-devel/2019-08/msg01715.html
v7: https://lists.nongnu.org/archive/html/qemu-block/2020-06/msg01357.htmlBranch: https://github.com/XanClic/qemu.git child-access-functions-v8
Branch: https://git.xanclic.moe/XanClic/qemu.git child-access-functions-v8
Quoted 5 lines
Hi,
In v8, there is not too much that has changed in respect to v7. I tried to address all of your comments and hope I got it right. I also hope I got the R-bs right.
Thanks, fixed up the typo in the commit message of patch 35 and applied to the block branch.
Kevin
Quoted 8 lines · Kevin Wolf
Am 01.09.2020 um 16:33 hat Max Reitz geschrieben:
Quoted 7 lines
v6: https://lists.nongnu.org/archive/html/qemu-devel/2019-08/msg01715.html
v7: https://lists.nongnu.org/archive/html/qemu-block/2020-06/msg01357.htmlBranch: https://github.com/XanClic/qemu.git child-access-functions-v8
Branch: https://git.xanclic.moe/XanClic/qemu.git child-access-functions-v8
Quoted 8 lines
Quoted 5 lines
Hi,
In v8, there is not too much that has changed in respect to v7. I tried to address all of your comments and hope I got it right. I also hope I got the R-bs right.
Thanks, fixed up the typo in the commit message of patch 35 and applied to the block branch.
A day to celebrate! :)