qcow2: Support refcount orders != 4
v4 cover qcow2: Support refcount orders != 4
As of version 3, the qcow2 file format supports different widths for refcount entries, ranging from 1 to 64 bit (only powers of two). Currently, qemu only supports 16 bit, which is the only width supported by version 2 (compat=0.10) images.
This series adds support to qemu for all other valid refcount orders. This is mainly done by adding two function pointers into the BDRVQcowState structure for reading and writing refcount values independently of the current refcount entry width; all in-memory refcount arrays (mostly cached refcount blocks) now are void pointers and are accessed through these functions alone.
Thanks to previous work of making the qemu code agnostic of e.g. the number of refcount entries per refcount block, the rest is fairly trivial. The most complex patch in this series is patch 18 which implements changing the refcount order through qemu-img amend.
To test different refcount widths, simply invoke the qemu-iotests check program with -o refcount_width=${your_desired_width}. The final test in this series adds some tests for operations which do not work with certain refcount orders and for refcount order amendment.
v4:
- Patch 1: No longer limit to INT64_MAX but allow full range up to UINT64_MAX; also, use a non-overflowing shift to avoid the special case for s->refcount_order == 6 [Stefan]
- Patch 2: %s/refcount_width/refcount_bits/g (etc.) [Stefan]
- Patch 3: Added
- Patch 4: Added [Stefan]
- Patch 5: Added
- Patch 6 (prev. 3):
- Rebase conflicts due to patches 3, 4 and 5
- Always use uint64_t for refcounts instead of int64_t [Stefan]
- Patch 7 (prev. 4):
- Rebase conflicts due to patch 5
- qcow2_update_cluster_refcount() only returns an int (not an int64_t), thus "int ret" will suffice (due to patch 3)
- Patch 8 (prev. 5):
- Refcounts are always uint64_t [Stefan]
- Rebase conflict due to patch 4
- Patch 9 (prev. 6): Allow shrinking of the array in realloc_refcount_array() [Stefan]
- Patch 10 (prev. 7):
- Rebase conflicts due to patch 4
- Range checks are no longer necessary [Stefan]
- Refcounts are always uint64_t [Stefan]
- Patch 11 (prev 8): It is now allowed to set the MSb in 64 bit refcounts, therefore drop the assert() in set_refcount_ro6() [Stefan]
- Patch 13 (prev. 10): %s/refcount_width/refcount_bits/g [Stefan]
- Patch 14: Added
- Patch 15 (prev. 11): %s/refcount_width/refcount_bits/g [Stefan]
- Patch 16 (prev. 12):
- s/BLOCK_OPT_REFCOUNT_WIDTH/BLOCK_OPT_REFCOUNT_BITS/g [Stefan]
- s/"refcount_width"/BLOCK_OPT_REFCOUNT_BITS/
- %s/refcount_width/refcount_bits/g [Stefan]
- Patch 17 (prev. 13): As a very good example on why I am opposed to leaving the opening brace of an "if" block on the last line of multi-line conditions, I followed Eric's proposal and removed the superfluous parentheses in the condition touched by this patch [Eric]
- Patch 23 (prev. 19): Same change as in patch 1; and fixed an overly long line
- Patch 24 (prev. 20):
- s/"refcount_width"/BLOCK_OPT_REFCOUNT_BITS/
- %s/refcount_width/refcount_bits/g [Stefan]
- Patch 26 (prev. 22):
- %s/refcount_width/refcount_bits/g [Stefan]
- Setting the MSb in a 64 bit refcount value should work now [Stefan]
- Added a test for snapshotting a cluster with a refcount of 2^64 - 1
git-backport-diff against v3:
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/26:[0010] [FC] 'qcow2: Add two new fields to BDRVQcowState' 002/26:[down] 'qcow2: Add refcount_bits to format-specific info'
^^^^ wrong, should be:
[0054] [FC]003/26:[down] 'qcow2: Do not return new value after refcount update' 004/26:[down] 'qcow2: Only return status from qcow2_get_refcount' 005/26:[down] 'qcow2: Use unsigned addend for update_refcount()' 006/26:[0093] [FC] 'qcow2: Use 64 bits for refcount values' 007/26:[0011] [FC] 'qcow2: Respect error in qcow2_alloc_bytes()' 008/26:[0015] [FC] 'qcow2: Refcount overflow and qcow2_alloc_bytes()' 009/26:[0008] [FC] 'qcow2: Helper for refcount array reallocation' 010/26:[0017] [FC] 'qcow2: Helper function for refcount modification' 011/26:[0003] [FC] 'qcow2: More helpers for refcount modification' 012/26:[----] [--] 'qcow2: Open images with refcount order != 4' 013/26:[0006] [FC] 'qcow2: refcount_order parameter for qcow2_create2' 014/26:[down] 'qcow2: Use symbolic macros in qcow2_amend_options' 015/26:[down] 'iotests: Prepare for refcount_bits option'
^^^^ wrong, should be:
[0038] [FC]016/26:[0228] [FC] 'qcow2: Allow creation with refcount order != 4' 017/26:[0002] [FC] 'progress: Allow regressing progress' 018/26:[----] [--] 'block: Add opaque value to the amend CB' 019/26:[----] [-C] 'qcow2: Use error_report() in qcow2_amend_options()' 020/26:[----] [--] 'qcow2: Use abort() instead of assert(false)' 021/26:[----] [--] 'qcow2: Split upgrade/downgrade paths for amend' 022/26:[----] [--] 'qcow2: Use intermediate helper CB for amend' 023/26:[0010] [FC] 'qcow2: Add function for refcount order amendment' 024/26:[0020] [FC] 'qcow2: Invoke refcount order amendment function' 025/26:[----] [--] 'qcow2: Point to amend function in check' 026/26:[0212] [FC] 'iotests: Add test for different refcount widths'
Max Reitz (26):
qcow2: Add two new fields to BDRVQcowState
qcow2: Add refcount_bits to format-specific info
qcow2: Do not return new value after refcount update
qcow2: Only return status from qcow2_get_refcount
qcow2: Use unsigned addend for update_refcount()
qcow2: Use 64 bits for refcount values
qcow2: Respect error in qcow2_alloc_bytes()
qcow2: Refcount overflow and qcow2_alloc_bytes()
qcow2: Helper for refcount array reallocation
qcow2: Helper function for refcount modification
qcow2: More helpers for refcount modification
qcow2: Open images with refcount order != 4
qcow2: refcount_order parameter for qcow2_create2
qcow2: Use symbolic macros in qcow2_amend_options
iotests: Prepare for refcount_bits option
qcow2: Allow creation with refcount order != 4
progress: Allow regressing progress
block: Add opaque value to the amend CB
qcow2: Use error_report() in qcow2_amend_options()
qcow2: Use abort() instead of assert(false)
qcow2: Split upgrade/downgrade paths for amend
qcow2: Use intermediate helper CB for amend
qcow2: Add function for refcount order amendment
qcow2: Invoke refcount order amendment function
qcow2: Point to amend function in check
iotests: Add test for different refcount widths
block.c | 4 +- block/qcow2-cluster.c | 24 +- block/qcow2-refcount.c | 1052 +++++++++++++++++++++++++++++++------- block/qcow2.c | 286 ++++++++--- block/qcow2.h | 23 +- include/block/block.h | 4 +- include/block/block_int.h | 4 +- qapi/block-core.json | 5 +- qemu-img.c | 5 +- tests/qemu-iotests/007 | 3 + tests/qemu-iotests/015 | 2 + tests/qemu-iotests/026 | 7 + tests/qemu-iotests/029 | 2 + tests/qemu-iotests/049.out | 112 ++-- tests/qemu-iotests/051 | 3 + tests/qemu-iotests/058 | 2 + tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061.out | 14 +- tests/qemu-iotests/065 | 23 +- tests/qemu-iotests/067 | 2 + tests/qemu-iotests/067.out | 5 + tests/qemu-iotests/079 | 10 +- tests/qemu-iotests/079.out | 38 +- tests/qemu-iotests/080 | 2 + tests/qemu-iotests/082.out | 48 +- tests/qemu-iotests/085.out | 38 +- tests/qemu-iotests/089 | 2 + tests/qemu-iotests/089.out | 2 + tests/qemu-iotests/108 | 2 + tests/qemu-iotests/112 | 296 +++++++++++ tests/qemu-iotests/112.out | 155 ++++++ tests/qemu-iotests/common.filter | 3 +- tests/qemu-iotests/group | 1 + util/qemu-progress.c | 3 +- 34 files changed, 1783 insertions(+), 400 deletions(-) create mode 100755 tests/qemu-iotests/112 create mode 100644 tests/qemu-iotests/112.out
Signature · 1 line
1.9.3
PATCH v4 1/26 qcow2: Add two new fields to BDRVQcowState
Add two new fields regarding refcount information (the bit width of every entry and the maximum refcount value) to the BDRVQcowState.
--- block/qcow2-refcount.c | 2 +- block/qcow2.c | 3 +++ block/qcow2.h | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-)
block/qcow2-refcount.c +1 -1
@@ -584,7 +584,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, refcount =be16_to_cpu (refcount_block[block_index]); refcount += addend; -if (refcount <0 || refcount >0xffff ) { +if (refcount <0 || refcount > s->refcount_max) { ret = -EINVAL ; goto fail; }
block/qcow2.c +3 -0
@@ -684,6 +684,9 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, goto fail; } s->refcount_order = header.refcount_order; + s->refcount_bits =1 << s->refcount_order; + s->refcount_max =UINT64_C (1 ) << (s->refcount_bits -1 ); + s->refcount_max += s->refcount_max -1 ;if (header.crypt_method >QCOW_CRYPT_AES ) { error_setg(errp, "Unsupported encryption method: %" PRIu32,
block/qcow2.h +2 -0
@@ -258,6 +258,8 @@ typedef struct BDRVQcowState {int qcow_version;bool use_lazy_refcounts;int refcount_order; +int refcount_bits; +uint64_t refcount_max;bool discard_passthrough[QCOW2_DISCARD_MAX ];
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 01/26] qcow2: Add two new fields to BDRVQcowState
Quoted 9 lines · Max Reitz
Add two new fields regarding refcount information (the bit width of every entry and the maximum refcount value) to the BDRVQcowState.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 2 +- block/qcow2.c | 3 +++ block/qcow2.h | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 01/26] qcow2: Add two new fields to BDRVQcowState
In reply to Max ReitzQuoted 9 lines · Max Reitz
Add two new fields regarding refcount information (the bit width of every entry and the maximum refcount value) to the BDRVQcowState.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 2 +- block/qcow2.c | 3 +++ block/qcow2.h | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-)
PATCH v4 2/26 qcow2: Add refcount_bits to format-specific info
In reply to Max ReitzAdd the bit width of every refcount entry to the format-specific information.
In contrast to lazy_refcounts and the corrupt flag, this should be always emitted, even for compat=0.10 although it does not support any refcount width other than 16 bits. This is because if a boolean is optional, one normally assumes it to be false when omitted; but if an integer is not specified, it is rather difficult to guess its value.
This new field breaks some test outputs, fix them.
--- block/qcow2.c | 4 +++- qapi/block-core.json | 5 ++++- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/065 | 23 +++++++++++++++-------- tests/qemu-iotests/067.out | 5 +++++ tests/qemu-iotests/082.out | 7 +++++++ tests/qemu-iotests/089.out | 2 ++ 7 files changed, 37 insertions(+), 10 deletions(-)
block/qcow2.c +3 -1
@@ -2469,7 +2469,8 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs) };if (s->qcow_version ==2 ) { *spec_info->qcow2 = (ImageInfoSpecificQCow2 ){ - .compat =g_strdup ("0.10" ), + .compat =g_strdup ("0.10" ), + .refcount_bits = s->refcount_bits, }; }else if (s->qcow_version ==3 ) { *spec_info->qcow2 = (ImageInfoSpecificQCow2 ){
@@ -2480,6 +2481,7 @@ static ImageInfoSpecific *qcow2_get_specific_info(BlockDriverState *bs) .corrupt = s->incompatible_features & QCOW2_INCOMPAT_CORRUPT, .has_corrupt = true, + .refcount_bits = s->refcount_bits, }; }
qapi/block-core.json +4 -1
@@ -41,13 +41,16 @@ # @corrupt: #optional true if the image has been marked corrupt; only valid for # compat >= 1.1 (since 2.2) # +# @refcount-bits: width of a refcount entry in bits (since 2.3) +# # Since: 1.7 ## { 'type': 'ImageInfoSpecificQCow2', 'data': { 'compat': 'str', '*lazy-refcounts': 'bool', - '*corrupt': 'bool' + '*corrupt': 'bool', + 'refcount-bits': 'int' } } ##
tests/qemu-iotests/060.out +1 -0
@@ -18,6 +18,7 @@ cluster_size: 65536 Format specific information: compat: 1.1 lazy refcounts: false + refcount bits: 16 corrupt: true qemu-io: can't open device TEST_DIR/t.IMGFMT: IMGFMT: Image is corrupt; cannot be opened read/write read 512/512 bytes at offset 0
tests/qemu-iotests/065 +15 -8
@@ -88,34 +88,41 @@ class TestQMP(TestImageInfoSpecific): class TestQCow2(TestQemuImgInfo): '''Testing a qcow2 version 2 image''' img_options = 'compat=0.10' - json_compare = { 'compat': '0.10' } - human_compare = [ 'compat: 0.10' ] + json_compare = { 'compat': '0.10', 'refcount-bits': 16 } + human_compare = [ 'compat: 0.10', 'refcount bits: 16' ] class TestQCow3NotLazy(TestQemuImgInfo): '''Testing a qcow2 version 3 image with lazy refcounts disabled''' img_options = 'compat=1.1,lazy_refcounts=off' - json_compare = { 'compat': '1.1', 'lazy-refcounts': False, 'corrupt': False } - human_compare = [ 'compat: 1.1', 'lazy refcounts: false', 'corrupt: false' ] + json_compare = { 'compat': '1.1', 'lazy-refcounts': False, + 'refcount-bits': 16, 'corrupt': False } + human_compare = [ 'compat: 1.1', 'lazy refcounts: false', + 'refcount bits: 16', 'corrupt: false' ] class TestQCow3Lazy(TestQemuImgInfo): '''Testing a qcow2 version 3 image with lazy refcounts enabled''' img_options = 'compat=1.1,lazy_refcounts=on' - json_compare = { 'compat': '1.1', 'lazy-refcounts': True, 'corrupt': False } - human_compare = [ 'compat: 1.1', 'lazy refcounts: true', 'corrupt: false' ] + json_compare = { 'compat': '1.1', 'lazy-refcounts': True, + 'refcount-bits': 16, 'corrupt': False } + human_compare = [ 'compat: 1.1', 'lazy refcounts: true', + 'refcount bits: 16', 'corrupt: false' ] class TestQCow3NotLazyQMP(TestQMP): '''Testing a qcow2 version 3 image with lazy refcounts disabled, opening with lazy refcounts enabled''' img_options = 'compat=1.1,lazy_refcounts=off' qemu_options = 'lazy-refcounts=on' - compare = { 'compat': '1.1', 'lazy-refcounts': False, 'corrupt': False } + compare = { 'compat': '1.1', 'lazy-refcounts': False, + 'refcount-bits': 16, 'corrupt': False } + class TestQCow3LazyQMP(TestQMP): '''Testing a qcow2 version 3 image with lazy refcounts enabled, opening with lazy refcounts disabled''' img_options = 'compat=1.1,lazy_refcounts=on' qemu_options = 'lazy-refcounts=off' - compare = { 'compat': '1.1', 'lazy-refcounts': True, 'corrupt': False } + compare = { 'compat': '1.1', 'lazy-refcounts': True, + 'refcount-bits': 16, 'corrupt': False } TestImageInfoSpecific = None TestQemuImgInfo = None
tests/qemu-iotests/067.out +5 -0
@@ -32,6 +32,7 @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti "data": { "compat": "1.1", "lazy-refcounts": false, + "refcount-bits": 16, "corrupt": false } },
@@ -207,6 +208,7 @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk "data": { "compat": "1.1", "lazy-refcounts": false, + "refcount-bits": 16, "corrupt": false } },
@@ -412,6 +414,7 @@ Testing: "data": { "compat": "1.1", "lazy-refcounts": false, + "refcount-bits": 16, "corrupt": false } },
@@ -596,6 +599,7 @@ Testing: "data": { "compat": "1.1", "lazy-refcounts": false, + "refcount-bits": 16, "corrupt": false } },
@@ -706,6 +710,7 @@ Testing: "data": { "compat": "1.1", "lazy-refcounts": false, + "refcount-bits": 16, "corrupt": false } },
tests/qemu-iotests/082.out +7 -0
@@ -18,6 +18,7 @@ cluster_size: 4096 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: create -f qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 128M
@@ -29,6 +30,7 @@ cluster_size: 8192 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: create -f qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 128M
@@ -190,6 +192,7 @@ cluster_size: 4096 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: convert -O qcow2 -o cluster_size=4k -o lazy_refcounts=on -o cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
@@ -200,6 +203,7 @@ cluster_size: 8192 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: convert -O qcow2 -o cluster_size=4k,cluster_size=8k TEST_DIR/t.qcow2 TEST_DIR/t.qcow2.base
@@ -346,6 +350,7 @@ cluster_size: 65536 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: amend -f qcow2 -o size=130M -o lazy_refcounts=off TEST_DIR/t.qcow2
@@ -356,6 +361,7 @@ cluster_size: 65536 Format specific information: compat: 1.1 lazy refcounts: false + refcount bits: 16 corrupt: false Testing: amend -f qcow2 -o size=8M -o lazy_refcounts=on -o size=132M TEST_DIR/t.qcow2
@@ -366,6 +372,7 @@ cluster_size: 65536 Format specific information: compat: 1.1 lazy refcounts: true + refcount bits: 16 corrupt: false Testing: amend -f qcow2 -o size=4M,size=148M TEST_DIR/t.qcow2
tests/qemu-iotests/089.out +2 -0
@@ -41,6 +41,7 @@ vm state offset: 512 MiB Format specific information: compat: 1.1 lazy refcounts: false + refcount bits: 16 corrupt: false format name: IMGFMT cluster size: 64 KiB
@@ -48,5 +49,6 @@ vm state offset: 512 MiB Format specific information: compat: 1.1 lazy refcounts: false + refcount bits: 16 corrupt: false *** done
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 02/26] qcow2: Add refcount_bits to format-specific info
Quoted 9 lines · Max Reitz
Add the bit width of every refcount entry to the format-specific information.
In contrast to
lazy_refcountsand the corrupt flag, this should be always emitted, even for compat=0.10 although it does not support any refcount width other than 16 bits. This is because if a boolean is optional, one normally assumes it to be false when omitted; but if an integer is not specified, it is rather difficult to guess its value.
Quoted 4 lines
This new field breaks some test outputs, fix them.
Signed-off-by Max Reitz <[email protected]>---
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 02/26] qcow2: Add refcount_bits to format-specific info
In reply to Max ReitzQuoted 12 lines · Max Reitz
Add the bit width of every refcount entry to the format-specific information.
In contrast to
lazy_refcountsand the corrupt flag, this should be always emitted, even for compat=0.10 although it does not support any refcount width other than 16 bits. This is because if a boolean is optional, one normally assumes it to be false when omitted; but if an integer is not specified, it is rather difficult to guess its value.This new field breaks some test outputs, fix them.
Signed-off-by Max Reitz <[email protected]>
Quoted 9 lines
--- block/qcow2.c | 4 +++- qapi/block-core.json | 5 ++++- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/065 | 23 +++++++++++++++-------- tests/qemu-iotests/067.out | 5 +++++ tests/qemu-iotests/082.out | 7 +++++++ tests/qemu-iotests/089.out | 2 ++ 7 files changed, 37 insertions(+), 10 deletions(-)
PATCH v4 3/26 qcow2: Do not return new value after refcount update
In reply to Max Reitzqcow2_update_cluster_refcount() does not have any quick access to the new refcount value, it has to call qcow2_get_refcount(). Some callers do not need that new value at all, others call qcow2_get_refcount() themselves anyway (albeit in a different code path, which can however be easily changed), therefore there is no advantage in making qcow2_update_cluster_refcount() return the new value. Drop it.
--- block/qcow2-refcount.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
block/qcow2-refcount.c +15 -10
@@ -631,8 +631,7 @@ fail:/* * Increases or decreases the refcount of a given cluster. * -* If the return value is non-negative, it is the new refcount of the cluster. -* If it is negative, it is -errno and indicates an error. +* On success 0 is returned; on failure -errno is returned. */ int qcow2_update_cluster_refcount(BlockDriverState *bs, int64_t cluster_index,
@@ -648,7 +647,7 @@ int qcow2_update_cluster_refcount(BlockDriverState *bs,return ret; } -return qcow2_get_refcount (bs, cluster_index); +return 0 ; }
@@ -976,13 +975,15 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,break ; }if (addend !=0 ) { - refcount =qcow2_update_cluster_refcount (bs, + ret =qcow2_update_cluster_refcount (bs, cluster_index, addend,QCOW2_DISCARD_SNAPSHOT ); - }else { - refcount =qcow2_get_refcount (bs, cluster_index); +if (ret <0 ) { + goto fail; + } } + refcount =qcow2_get_refcount (bs, cluster_index);if (refcount <0 ) { ret = refcount; goto fail;
@@ -1017,11 +1018,15 @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,if (addend !=0 ) { - refcount =qcow2_update_cluster_refcount (bs, l2_offset >> - s->cluster_bits, addend,QCOW2_DISCARD_SNAPSHOT ); - }else { - refcount =qcow2_get_refcount (bs, l2_offset >> s->cluster_bits); + ret =qcow2_update_cluster_refcount (bs, l2_offset >> + s->cluster_bits, + addend, +QCOW2_DISCARD_SNAPSHOT ); +if (ret <0 ) { + goto fail; + } } + refcount =qcow2_get_refcount (bs, l2_offset >> s->cluster_bits);if (refcount <0 ) { ret = refcount; goto fail;
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 03/26] qcow2: Do not return new value after refcount update
Quoted 7 lines · Max Reitz
qcow2_update_cluster_refcount()does not have any quick access to the new refcount value, it has to callqcow2_get_refcount(). Some callers do not need that new value at all, others callqcow2_get_refcount()themselves anyway (albeit in a different code path, which can however be easily changed), therefore there is no advantage in makingqcow2_update_cluster_refcount()return the new value. Drop it.
Quoted 5 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 03/26] qcow2: Do not return new value after refcount update
In reply to Max ReitzQuoted 11 lines · Max Reitz
qcow2_update_cluster_refcount()does not have any quick access to the new refcount value, it has to callqcow2_get_refcount(). Some callers do not need that new value at all, others callqcow2_get_refcount()themselves anyway (albeit in a different code path, which can however be easily changed), therefore there is no advantage in makingqcow2_update_cluster_refcount()return the new value. Drop it.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-)
PATCH v4 4/26 qcow2: Only return status from qcow2_get_refcount
In reply to Max ReitzRefcounts can theoretically be of type uint64_t; in order to be able to represent the full range, qcow2_get_refcount() cannot use a single variable to represent both all refcount values and also keep some values reserved for errors.
One solution would be to add an Error pointer parameter to qcow2_get_refcount(); however, no caller could (currently) pass that error message, so it would have to be emitted immediately and be passed to the next caller by returning -EIO or something similar. Therefore, an Error parameter does not offer any advantages here.
The solution applied by this patch is simpler to use. Because no caller would be able to pass the error message, they would have to print it and free it, whereas with this patch the caller only needs to pass the returned integer (which is often a no-op from the code perspective, because that integer will be stored in a variable "ret" which will be returned by the fail path of many callers).
--- block/qcow2-cluster.c | 8 ++--- block/qcow2-refcount.c | 79 +++++++++++++++++++++++++++----------------------- block/qcow2.h | 3 +- 3 files changed, 49 insertions(+), 41 deletions(-)
block/qcow2-cluster.c +4 -4
@@ -1640,7 +1640,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,for (i =0 ; i < l1_size; i++) {uint64_t l2_offset = l1_table[i] &L1E_OFFSET_MASK ;bool l2_dirty = false; -int l2_refcount; +uint16_t l2_refcount;if (!l2_offset) {/* unallocated */
@@ -1664,9 +1664,9 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, goto fail; } - l2_refcount =qcow2_get_refcount (bs, l2_offset >> s->cluster_bits); -if (l2_refcount <0 ) { - ret = l2_refcount; + ret =qcow2_get_refcount (bs, l2_offset >> s->cluster_bits, + &l2_refcount); +if (ret <0 ) { goto fail; }
block/qcow2-refcount.c +43 -36
185 lines not on this page · raw message
block/qcow2.h +2 -1
@@ -489,7 +489,8 @@ void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,int qcow2_refcount_init (BlockDriverState *bs);void qcow2_refcount_close (BlockDriverState *bs); -int qcow2_get_refcount (BlockDriverState *bs,int64_t cluster_index); +int qcow2_get_refcount (BlockDriverState *bs,int64_t cluster_index, +uint16_t *refcount);int qcow2_update_cluster_refcount (BlockDriverState *bs,int64_t cluster_index,int addend,enum qcow2_discard_type type);
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 04/26] qcow2: Only return status from qcow2_get_refcount
Quoted 27 lines · Max Reitz
Refcounts can theoretically be of type
uint64_t; in order to be able to represent the full range,qcow2_get_refcount()cannot use a single variable to represent both all refcount values and also keep some values reserved for errors.One solution would be to add an Error pointer parameter to
qcow2_get_refcount(); however, no caller could (currently) pass that error message, so it would have to be emitted immediately and be passed to the next caller by returning-EIOor something similar. Therefore, an Error parameter does not offer any advantages here.The solution applied by this patch is simpler to use. Because no caller would be able to pass the error message, they would have to print it and free it, whereas with this patch the caller only needs to pass the returned integer (which is often a no-op from the code perspective, because that integer will be stored in a variable "ret" which will be returned by the fail path of many callers).
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 8 ++--- block/qcow2-refcount.c | 79 +++++++++++++++++++++++++++----------------------- block/qcow2.h | 3 +- 3 files changed, 49 insertions(+), 41 deletions(-)
block/qcow2-refcount.c static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, · line 1680
Quoted 5 lines
block/qcow2-refcount.c +1
-1@@ -1670,7 +1677,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,if (num_fixed) { ret = update_refcount(bs, i << s->cluster_bits, 1, - refcount2 - refcount1, + (int)refcount2 - (int)refcount1,
The casts look a bit odd (uint16_t already naturally promotes to int for 32-bit int), but keep it, since we'll have to re-think this operation when a later patch widens to 64 bits anyways.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 04/26] qcow2: Only return status from qcow2_get_refcount
In reply to Max ReitzQuoted 18 lines · Max Reitz
Refcounts can theoretically be of type
uint64_t; in order to be able to represent the full range,qcow2_get_refcount()cannot use a single variable to represent both all refcount values and also keep some values reserved for errors.One solution would be to add an Error pointer parameter to
qcow2_get_refcount(); however, no caller could (currently) pass that error message, so it would have to be emitted immediately and be passed to the next caller by returning-EIOor something similar. Therefore, an Error parameter does not offer any advantages here.The solution applied by this patch is simpler to use. Because no caller would be able to pass the error message, they would have to print it and free it, whereas with this patch the caller only needs to pass the returned integer (which is often a no-op from the code perspective, because that integer will be stored in a variable "ret" which will be returned by the fail path of many callers).
Quoted 6 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 8 ++--- block/qcow2-refcount.c | 79 +++++++++++++++++++++++++++----------------------- block/qcow2.h | 3 +- 3 files changed, 49 insertions(+), 41 deletions(-)
PATCH v4 5/26 qcow2: Use unsigned addend for update_refcount()
In reply to Max Reitzupdate_refcount() and qcow2_update_cluster_refcount() currently take a signed addend. At least one caller passes a value directly derived from an absolute refcount that should be reached ("l2_refcount - 1" in expand_zero_clusters_in_l1()). Therefore, the addend should be unsigned because unsigned overflow is well-defined in contrast to signed overflow. This will be especially important for 64 bit refcounts.
Because update_refcount() then no longer knows whether the refcount should be increased or decreased (which is important for setting the refblock-L2-table cache dependency and for overflow/underflow checks), it now requires an additional flag which specified exactly that. The same applies to qcow2_update_cluster_refcount().
--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 63 ++++++++++++++++++++++++++++++++------------------ block/qcow2.h | 3 ++- 3 files changed, 44 insertions(+), 24 deletions(-)
block/qcow2-cluster.c +1 -1
@@ -1699,7 +1699,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,/* For shared L2 tables, set the refcount accordingly (it is * already 1 and needs to be l2_refcount) */ ret =qcow2_update_cluster_refcount (bs, - offset >> s->cluster_bits, l2_refcount -1 , + offset >> s->cluster_bits, l2_refcount -1 , false,QCOW2_DISCARD_OTHER );if (ret <0 ) { qcow2_free_clusters(bs, offset, s->cluster_size,
block/qcow2-refcount.c +41 -22
185 lines not on this page · raw message
block/qcow2.h +2 -1
@@ -493,7 +493,8 @@ int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index, uint16_t *refcount);int qcow2_update_cluster_refcount (BlockDriverState *bs,int64_t cluster_index, -int addend,enum qcow2_discard_type type); +uint16_t addend,bool decrease, +enum qcow2_discard_type type);int64_t qcow2_alloc_clusters (BlockDriverState *bs,uint64_t size); int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 05/26] qcow2: Use unsigned addend for update_refcount()
Quoted 22 lines · Max Reitz
update_refcount()andqcow2_update_cluster_refcount()currently take a signed addend. At least one caller passes a value directly derived from an absolute refcount that should be reached ("l2_refcount- 1" inexpand_zero_clusters_in_l1()). Therefore, the addend should be unsigned because unsigned overflow is well-defined in contrast to signed overflow. This will be especially important for 64 bit refcounts.Because
update_refcount()then no longer knows whether the refcount should be increased or decreased (which is important for setting the refblock-L2-table cache dependency and for overflow/underflow checks), it now requires an additional flag which specified exactly that. The same applies toqcow2_update_cluster_refcount().Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 63 ++++++++++++++++++++++++++++++++------------------ block/qcow2.h | 3 ++- 3 files changed, 44 insertions(+), 24 deletions(-)
block/qcow2-refcount.c static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, · line 1700
Quoted 7 lines
block/qcow2-refcount.c +2
-1@@ -1677,7 +1695,8 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,if (num_fixed) { ret =update_refcount (bs, i << s->cluster_bits,1 , - (int )refcount2 - (int )refcount1, + refcount2 - refcount1, + refcount1 > refcount2,QCOW2_DISCARD_ALWAYS );
Nice - my comment on 4/26 is indeed addressed here (so I was correct in guessing that the series touched that area again, and no need to respin).
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 05/26] qcow2: Use unsigned addend for update_refcount()
In reply to Max Reitzblock/qcow2-refcount.c found: · line 536
Quoted 8 lines · Max Reitz
block/qcow2-refcount.c +4
-0@@ -530,8 +530,16 @@ found: }/* XXX: cache several refcount block clusters ? */ +/* In order to decrease refcounts, set @addend to the two's complement (giving a +* negative value and letting the implicit cast handle it is enough) and set +* @decrease to true. @decrease must be false if the refcount should be +* increased. */
The first time I read this patch I missed this quirk and thought that a lot of places seemed to be doing the wrong thing with addend.
This is likely to cause confusion, why not make uint16_t addend truly unsigned and leave the sign to bool decrease, as suggested by the function prototype?
Re: [Qemu-devel] [PATCH v4 05/26] qcow2: Use unsigned addend for update_refcount()
Quoted 12 lines · Stefan Hajnoczi
block/qcow2-refcount.c found: · line 536
Quoted 8 lines · Max Reitz
block/qcow2-refcount.c +4
-0@@ -530,8 +530,16 @@ found: }/* XXX: cache several refcount block clusters ? */ +/* In order to decrease refcounts, set @addend to the two's complement (giving a +* negative value and letting the implicit cast handle it is enough) and set +* @decrease to true. @decrease must be false if the refcount should be +* increased. */ The first time I read this patch I missed this quirk and thought that a lot of places seemed to be doing the wrong thing with addend.
Quoted 3 lines
This is likely to cause confusion, why not make
uint16_taddend truly unsigned and leave the sign to bool decrease, as suggested by the function prototype?
Because it's very easy to call it with e.g. target_refcount - current_refcount, and using an addition to apply the addend will always work.
So, the code is a bit shorter by doing this. On the other hand, I don't have trouble making all callers do llabs(addend) or imaxabs(addend) (if the absolute value is not known at compile time) and use addition or subtraction in this function, depending on the boolean.
Max
Re: [Qemu-devel] [PATCH v4 05/26] qcow2: Use unsigned addend for update_refcount()
Quoted 16 lines · Max Reitz
Quoted 11 lines · Stefan Hajnoczi
block/qcow2-refcount.c found: · line 535
Quoted 7 lines · Max Reitz
block/qcow2-refcount.c +4
-0@@ -530,8 +530,16 @@ found: }/* XXX: cache several refcount block clusters ? */ +/* In order to decrease refcounts, set @addend to the two's complement (giving a +* negative value and letting the implicit cast handle it is enough) and set +* @decrease to true. @decrease must be false if the refcount should be +* increased. */ The first time I read this patch I missed this quirk and thought that a lot of places seemed to be doing the wrong thing with addend.
Quoted 3 lines
This is likely to cause confusion, why not make
uint16_taddend truly unsigned and leave the sign to bool decrease, as suggested by the function prototype?
Quoted 8 lines
Because it's very easy to call it with e.g.
target_refcount-current_refcount, and using an addition to apply the addend will always work.So, the code is a bit shorter by doing this. On the other hand, I don't have trouble making all callers do llabs(addend) or imaxabs(addend) (if the absolute value is not known at compile time) and use addition or subtraction in this function, depending on the boolean.
I prefer the solution using the absolute value because it makes the code idiot-proof for me to read :).
Thanks,
Stefan
PATCH v4 6/26 qcow2: Use 64 bits for refcount values
In reply to Max ReitzRefcounts may have a width of up to 64 bits, so qemu should use the same width to represent refcount values internally.
--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 42 ++++++++++++++++++++---------------------- block/qcow2.h | 4 ++-- 3 files changed, 23 insertions(+), 25 deletions(-)
block/qcow2-cluster.c +1 -1
@@ -1640,7 +1640,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,for (i =0 ; i < l1_size; i++) {uint64_t l2_offset = l1_table[i] &L1E_OFFSET_MASK ;bool l2_dirty = false; -uint16_t l2_refcount; +uint64_t l2_refcount;if (!l2_offset) {/* unallocated */
block/qcow2-refcount.c +20 -22
142 lines not on this page · raw message
block/qcow2.h +2 -2
@@ -490,10 +490,10 @@ int qcow2_refcount_init(BlockDriverState *bs);void qcow2_refcount_close (BlockDriverState *bs);int qcow2_get_refcount (BlockDriverState *bs,int64_t cluster_index, -uint16_t *refcount); +uint64_t *refcount);int qcow2_update_cluster_refcount (BlockDriverState *bs,int64_t cluster_index, -uint16_t addend,bool decrease, +uint64_t addend,bool decrease,enum qcow2_discard_type type);int64_t qcow2_alloc_clusters (BlockDriverState *bs,uint64_t size);
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 06/26] qcow2: Use 64 bits for refcount values
Quoted 12 lines · Max Reitz
Refcounts may have a width of up to 64 bits, so qemu should use the same width to represent refcount values internally.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 42 ++++++++++++++++++++---------------------- block/qcow2.h | 4 ++-- 3 files changed, 23 insertions(+), 25 deletions(-)
block/qcow2-refcount.c static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, · line 1702
Quoted 8 lines
block/qcow2-refcount.c +1
-1@@ -1698,7 +1696,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, refcount2 - refcount1, refcount1 > refcount2, QCOW2_DISCARD_ALWAYS); -if (ret >=0 ) { +if (ret ==0 ) { (*num_fixed)++;continue ; }
This hunk looks a bit misplaced (it is unrelated to a sizing change). Patch 5 altered update_refcount, but does not document its return value.
But a careful step through update_refcount() shows that all error paths
return negative, and the only places where we do things like 'ret = alloc_refcount_block(...)" are later followed by an unconditional 'ret = 0' on success paths (so I didn't check whether alloc_refcount_block returns positive values, but didn't need to). If you have to respin, it might be better to add documentation of the return value and update callers to assume a non-positive return as a separate patch, rather than sliding it in with this one. But as I don't see any code faults, and am not sure it is worth a respin just for this issue,
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 06/26] qcow2: Use 64 bits for refcount values
Quoted 11 lines · Eric Blake
Quoted 10 lines · Max Reitz
Refcounts may have a width of up to 64 bits, so qemu should use the same width to represent refcount values internally.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 42 ++++++++++++++++++++---------------------- block/qcow2.h | 4 ++-- 3 files changed, 23 insertions(+), 25 deletions(-)
Quoted 10 lines
block/qcow2-refcount.c static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, · line 1702
Quoted 9 lines
block/qcow2-refcount.c +1
-1@@ -1698,7 +1696,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res, refcount2 - refcount1, refcount1 > refcount2, QCOW2_DISCARD_ALWAYS); -if (ret >=0 ) { +if (ret ==0 ) { (*num_fixed)++;continue ; }This hunk looks a bit misplaced (it is unrelated to a sizing change).
Ah, right, I think it should have been in patch 3. I even looked through the patches before sending them, but somehow I missed this...
Quoted 10 lines
Patch 5 altered
update_refcount, but does not document its return value.
But a careful step throughupdate_refcount()shows that all error paths
return negative, and the only places where we do things like 'ret =alloc_refcount_block(...)" are later followed by an unconditional 'ret = 0' on success paths (so I didn't check whetheralloc_refcount_blockreturns positive values, but didn't need to). If you have to respin, it might be better to add documentation of the return value and update callers to assume a non-positive return as a separate patch, rather than sliding it in with this one. But as I don't see any code faults, and am not sure it is worth a respin just for this issue,
Hm, I don't think this is something that should be fixed up by the applying maintainer. I will respin, even if it's just for this, but I'll wait until this series has been sufficiently looked at.
Quoted 1 line
Reviewed-by Eric Blake <[email protected]>
Once again, thank you!
Max
Re: [Qemu-devel] [PATCH v4 06/26] qcow2: Use 64 bits for refcount values
In reply to Max ReitzQuoted 9 lines · Max Reitz
Refcounts may have a width of up to 64 bits, so qemu should use the same width to represent refcount values internally.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-cluster.c | 2 +- block/qcow2-refcount.c | 42 ++++++++++++++++++++---------------------- block/qcow2.h | 4 ++-- 3 files changed, 23 insertions(+), 25 deletions(-)
PATCH v4 7/26 qcow2: Respect error in qcow2_alloc_bytes()
In reply to Max Reitzqcow2_update_cluster_refcount() may fail, and qcow2_alloc_bytes() should mind that case.
--- block/qcow2-refcount.c | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-)
block/qcow2-refcount.c +21 -12
@@ -778,8 +778,8 @@ int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,int64_t qcow2_alloc_bytes (BlockDriverState *bs,int size) {BDRVQcowState *s = bs->opaque; -int64_t offset, cluster_offset; -int free_in_cluster; +int64_t offset, cluster_offset, new_cluster; +int free_in_cluster, ret;BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_BYTES );assert (size >0 && size <= s->cluster_size);
@@ -800,23 +800,32 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) free_in_cluster -= size;if (free_in_cluster ==0 ) s->free_byte_offset =0 ; -if (offset_into_cluster (s, offset) !=0 ) -qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits,1 , - false,QCOW2_DISCARD_NEVER ); +if (offset_into_cluster (s, offset) !=0 ) { + ret =qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits, +1 , false,QCOW2_DISCARD_NEVER ); +if (ret <0 ) { +return ret; + } + } }else { - offset =qcow2_alloc_clusters (bs, s->cluster_size); -if (offset <0 ) { -return offset; + new_cluster =qcow2_alloc_clusters (bs, s->cluster_size); +if (new_cluster <0 ) { +return new_cluster; } cluster_offset =start_of_cluster (s, s->free_byte_offset); -if ((cluster_offset + s->cluster_size) == offset) { +if ((cluster_offset + s->cluster_size) == new_cluster) {/* we are lucky: contiguous data */ offset = s->free_byte_offset; -qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits,1 , - false,QCOW2_DISCARD_NEVER ); + ret =qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits, +1 , false,QCOW2_DISCARD_NEVER ); +if (ret <0 ) { +qcow2_free_clusters (bs, new_cluster, s->cluster_size, +QCOW2_DISCARD_NEVER ); +return ret; + } s->free_byte_offset += size; }else { - s->free_byte_offset = offset; + s->free_byte_offset = new_cluster; goto redo; } }
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 07/26] qcow2: Respect error in qcow2_alloc_bytes()
Quoted 8 lines · Max Reitz
qcow2_update_cluster_refcount()may fail, andqcow2_alloc_bytes()should mind that case.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 07/26] qcow2: Respect error in qcow2_alloc_bytes()
In reply to Max ReitzQuoted 7 lines · Max Reitz
qcow2_update_cluster_refcount()may fail, andqcow2_alloc_bytes()should mind that case.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 33 +++++++++++++++++++++------------ 1 file changed, 21 insertions(+), 12 deletions(-)
PATCH v4 8/26 qcow2: Refcount overflow and qcow2_alloc_bytes()
In reply to Max Reitzqcow2_alloc_bytes() may reuse a cluster multiple times, in which case the refcount is increased accordingly. However, if this would lead to an overflow the function should instead just not reuse this cluster and allocate a new one.
--- block/qcow2-refcount.c | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-)
block/qcow2-refcount.c +30 -1
@@ -780,9 +780,11 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)BDRVQcowState *s = bs->opaque;int64_t offset, cluster_offset, new_cluster;int free_in_cluster, ret; +uint64_t refcount;BLKDBG_EVENT (bs->file,BLKDBG_CLUSTER_ALLOC_BYTES );assert (size >0 && size <= s->cluster_size); + redo:if (s->free_byte_offset ==0 ) { offset =qcow2_alloc_clusters (bs, s->cluster_size);if (offset <0 ) {
@@ -790,12 +792,25 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size) } s->free_byte_offset = offset; } - redo: + free_in_cluster = s->cluster_size -offset_into_cluster (s, s->free_byte_offset);if (size <= free_in_cluster) {/* enough space in current cluster */ offset = s->free_byte_offset; + +if (offset_into_cluster (s, offset) !=0 ) { +/* We will have to increase the refcount of this cluster; if the +* maximum has been reached already, this cluster cannot be used */ + ret =qcow2_get_refcount (bs, offset >> s->cluster_bits, &refcount); +if (ret <0 ) { +return ret; + }else if (refcount == s->refcount_max) { + s->free_byte_offset =0 ; + goto redo; + } + } + s->free_byte_offset += size; free_in_cluster -= size;if (free_in_cluster ==0 )
@@ -816,6 +831,20 @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)if ((cluster_offset + s->cluster_size) == new_cluster) {/* we are lucky: contiguous data */ offset = s->free_byte_offset; + +/* Same as above: In order to reuse the cluster, the refcount has to +* be increased; if that will not work, we are not so lucky after +* all */ + ret =qcow2_get_refcount (bs, offset >> s->cluster_bits, &refcount); +if (ret <0 ) { +qcow2_free_clusters (bs, new_cluster, s->cluster_size, +QCOW2_DISCARD_NEVER ); +return ret; + }else if (refcount == s->refcount_max) { + s->free_byte_offset = offset; + goto redo; + } + ret =qcow2_update_cluster_refcount (bs, offset >> s->cluster_bits,1 , false,QCOW2_DISCARD_NEVER );if (ret <0 ) {
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 08/26] qcow2: Refcount overflow and qcow2_alloc_bytes()
Quoted 10 lines · Max Reitz
qcow2_alloc_bytes()may reuse a cluster multiple times, in which case the refcount is increased accordingly. However, if this would lead to an overflow the function should instead just not reuse this cluster and allocate a new one.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 08/26] qcow2: Refcount overflow and qcow2_alloc_bytes()
In reply to Max ReitzQuoted 9 lines · Max Reitz
qcow2_alloc_bytes()may reuse a cluster multiple times, in which case the refcount is increased accordingly. However, if this would lead to an overflow the function should instead just not reuse this cluster and allocate a new one.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-)
PATCH v4 9/26 qcow2: Helper for refcount array reallocation
In reply to Max ReitzAdd a helper function for reallocating a refcount array, independent of the refcount order. The newly allocated space is zeroed and the function handles failed reallocations gracefully.
The helper function will always align the buffer size to a cluster boundary; if storing the refcounts in such an array in big endian byte order, this makes it possible to write parts of the array directly as refcount blocks into the image file.
--- block/qcow2-refcount.c | 137 +++++++++++++++++++++++++++++++------------------ 1 file changed, 88 insertions(+), 49 deletions(-)
block/qcow2-refcount.c +88 -49
@@ -1130,6 +1130,70 @@ fail:/* refcount checking functions */ +static size_t refcount_array_byte_size (BDRVQcowState *s,uint64_t entries) +{ +if (s->refcount_order <3 ) { +/* sub-byte width */ +int shift =3 - s->refcount_order; +return (entries + (1 << shift) -1 ) >> shift; + }else if (s->refcount_order ==3 ) { +/* byte width */ +return entries; + }else { +/* multiple bytes wide */ + +/* This assertion holds because there is no way we can address more than +* 2^(64 - 9) clusters at once (with cluster size 512 = 2^9, and because +* offsets have to be representable in bytes); due to every cluster +* corresponding to one refcount entry and because refcount_order has to +* be below 7, we are far below that limit */ +assert (!(entries >> (64 - (s->refcount_order -3 )))); + +return entries << (s->refcount_order -3 ); + } +} + +/** +* Reallocates *array so that it can hold new_size entries. *size must contain +* the current number of entries in *array. If the reallocation fails, *array +* and *size will not be modified and -errno will be returned. If the +* reallocation is successful, *array will be set to the new buffer and *size +* will be set to new_size. The size of the reallocated refcount array buffer +* will be aligned to a cluster boundary, and the newly allocated area will be +* zeroed. +*/ +static int realloc_refcount_array (BDRVQcowState *s,uint16_t **array, +int64_t *size,int64_t new_size) +{ +/* Round to clusters so the array can be directly written to disk */ +size_t old_byte_size =ROUND_UP (refcount_array_byte_size (s, *size), + s->cluster_size); +size_t new_byte_size =ROUND_UP (refcount_array_byte_size (s, new_size), + s->cluster_size); +uint16_t *new_ptr; + +if (new_byte_size == old_byte_size) { + *size = new_size; +return 0 ; + } + +assert (new_byte_size >0 ); + + new_ptr =g_try_realloc (*array, new_byte_size); +if (!new_ptr) { +return -ENOMEM ; + } + +if (new_byte_size > old_byte_size) { +memset ((void *)((uintptr_t )new_ptr + old_byte_size),0 , + new_byte_size - old_byte_size); + } + + *array = new_ptr; + *size = new_size; + +return 0 ; +}/* * Increases the refcount for a range of clusters in a given refcount table.
@@ -1146,6 +1210,7 @@ static int inc_refcounts(BlockDriverState *bs, {BDRVQcowState *s = bs->opaque;uint64_t start, last, cluster_offset, k; +int ret;if (size <=0 ) {return 0 ;
@@ -1157,23 +1222,12 @@ static int inc_refcounts(BlockDriverState *bs, cluster_offset += s->cluster_size) { k = cluster_offset >> s->cluster_bits;if (k >= *refcount_table_size) { -int64_t old_refcount_table_size = *refcount_table_size; -uint16_t *new_refcount_table; - - *refcount_table_size = k +1 ; - new_refcount_table =g_try_realloc (*refcount_table, - *refcount_table_size * -sizeof (**refcount_table)); -if (!new_refcount_table) { - *refcount_table_size = old_refcount_table_size; + ret =realloc_refcount_array (s, refcount_table, + refcount_table_size, k +1 ); +if (ret <0 ) { res->check_errors++; -return -ENOMEM ; +return ret; } - *refcount_table = new_refcount_table; - -memset (*refcount_table + old_refcount_table_size,0 , - (*refcount_table_size - old_refcount_table_size) * -sizeof (**refcount_table)); }if (++(*refcount_table)[k] ==0 ) {
@@ -1542,8 +1596,7 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR", i);if (fix &BDRV_FIX_ERRORS ) { -int64_t old_nb_clusters = *nb_clusters; -uint16_t *new_refcount_table; +int64_t new_nb_clusters;if (offset >INT64_MAX - s->cluster_size) { ret = -EINVAL ;
@@ -1560,22 +1613,15 @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res, goto resize_fail; } - *nb_clusters =size_to_clusters (s, size); -assert (*nb_clusters >= old_nb_clusters); + new_nb_clusters =size_to_clusters (s, size); +assert (new_nb_clusters >= *nb_clusters); - new_refcount_table =g_try_realloc (*refcount_table, - *nb_clusters * -sizeof (**refcount_table)); -if (!new_refcount_table) { - *nb_clusters = old_nb_clusters; + ret =realloc_refcount_array (s, refcount_table, + nb_clusters, new_nb_clusters); +if (ret <0 ) { res->check_errors++; -return -ENOMEM ; +return ret; } - *refcount_table = new_refcount_table; - -memset (*refcount_table + old_nb_clusters,0 , - (*nb_clusters - old_nb_clusters) * -sizeof (**refcount_table));if (cluster >= *nb_clusters) { ret = -EINVAL ;
@@ -1635,10 +1681,12 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,int ret;if (!*refcount_table) { - *refcount_table =g_try_new0 (uint16_t, *nb_clusters); -if (*nb_clusters && *refcount_table ==NULL ) { +int64_t old_size =0 ; + ret =realloc_refcount_array (s, refcount_table, + &old_size, *nb_clusters); +if (ret <0 ) { res->check_errors++; -return -ENOMEM ; +return ret; } }
@@ -1772,6 +1820,7 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,int64_t cluster = *first_free_cluster, i;bool first_gap = true;int contiguous_free_clusters; +int ret;/* Starting at *first_free_cluster, find a range of at least cluster_count * continuously free clusters */
@@ -1801,28 +1850,18 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,/* If no such range could be found, grow the in-memory refcount table * accordingly to append free clusters at the end of the image */ if (contiguous_free_clusters < cluster_count) { -int64_t old_imrt_nb_clusters = *imrt_nb_clusters; -uint16_t *new_refcount_table; -/* contiguous_free_clusters clusters are already empty at the image end; * we need cluster_count clusters; therefore, we have to allocate * cluster_count - contiguous_free_clusters new clusters at the end of * the image (which is the current value of cluster; note that cluster * may exceed old_imrt_nb_clusters if *first_free_cluster pointed beyond * the image end) */ - *imrt_nb_clusters = cluster + cluster_count - contiguous_free_clusters; - new_refcount_table =g_try_realloc (*refcount_table, - *imrt_nb_clusters * -sizeof (**refcount_table)); -if (!new_refcount_table) { - *imrt_nb_clusters = old_imrt_nb_clusters; -return -ENOMEM ; - } - *refcount_table = new_refcount_table; - -memset (*refcount_table + old_imrt_nb_clusters,0 , - (*imrt_nb_clusters - old_imrt_nb_clusters) * -sizeof (**refcount_table)); + ret =realloc_refcount_array (s, refcount_table, imrt_nb_clusters, + cluster + cluster_count + - contiguous_free_clusters); +if (ret <0 ) { +return ret; + } }/* Go back to the first free cluster */
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 09/26] qcow2: Helper for refcount array reallocation
Quoted 19 lines · Max Reitz
Add a helper function for reallocating a refcount array, independent of the refcount order. The newly allocated space is zeroed and the function handles failed reallocations gracefully.
The helper function will always align the buffer size to a cluster boundary; if storing the refcounts in such an array in big endian byte order, this makes it possible to write parts of the array directly as refcount blocks into the image file.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 137 +++++++++++++++++++++++++++++++------------------ 1 file changed, 88 insertions(+), 49 deletions(-)block/qcow2-refcount.c +0
-0
block/qcow2-refcount.c fail: · line 1138
Quoted 9 lines
block/qcow2-refcount.c +6
-0@@ -1130,6 +1130,70 @@ fail:/* refcount checking functions */ +static size_t refcount_array_byte_size (BDRVQcowState *s,uint64_t entries) +{ +if (s->refcount_order <3 ) { +/* sub-byte width */ +int shift =3 - s->refcount_order; +return (entries + (1 << shift) -1 ) >> shift;
Bikeshedding: Should this use DIV_ROUND_UP(entries, 1 << shift)? Either way,
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 09/26] qcow2: Helper for refcount array reallocation
In reply to Max ReitzQuoted 9 lines · Max Reitz
Add a helper function for reallocating a refcount array, independent of the refcount order. The newly allocated space is zeroed and the function handles failed reallocations gracefully.
The helper function will always align the buffer size to a cluster boundary; if storing the refcounts in such an array in big endian byte order, this makes it possible to write parts of the array directly as refcount blocks into the image file.
Quoted 4 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 137 +++++++++++++++++++++++++++++++------------------ 1 file changed, 88 insertions(+), 49 deletions(-)
PATCH v4 10/26 qcow2: Helper function for refcount modification
In reply to Max ReitzSince refcounts do not always have to be a uint16_t, all refcount blocks and arrays in memory should not have a specific type (thus they become pointers to void) and for accessing them, two helper functions are used (a getter and a setter). Those functions are called indirectly through function pointers in the BDRVQcowState so they may later be exchanged for different refcount orders.
With the check and repair functions using this function, the refcount array they are creating will be in big endian byte order; additionally, using realloc_refcount_array() makes the size of this refcount array always cluster-aligned. Both combined allow rebuild_refcount_structure() to drop the bounce buffer which was used to convert parts of the refcount array to big endian byte order and store them on disk. Instead, those parts can now be written directly.
--- block/qcow2-refcount.c | 122 ++++++++++++++++++++++++++++--------------------- block/qcow2.h | 8 ++++ 2 files changed, 79 insertions(+), 51 deletions(-)
block/qcow2-refcount.c +71 -51
@@ -32,6 +32,11 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, int64_t offset, int64_t length, uint64_t addend, bool decrease, enum qcow2_discard_type type); +static uint64_t get_refcount_ro4 (const void *refcount_array,uint64_t index); + +static void set_refcount_ro4 (void *refcount_array,uint64_t index, +uint64_t value); +/*********************************************************/ /* refcount handling */
@@ -42,6 +47,9 @@ int qcow2_refcount_init(BlockDriverState *bs)unsigned int refcount_table_size2, i;int ret; + s->get_refcount = &get_refcount_ro4; + s->set_refcount = &set_refcount_ro4; +assert (s->refcount_table_size <=INT_MAX /sizeof (uint64_t )); refcount_table_size2 = s->refcount_table_size *sizeof (uint64_t ); s->refcount_table =g_try_malloc (refcount_table_size2);
@@ -72,6 +80,19 @@ void qcow2_refcount_close(BlockDriverState *bs) } +static uint64_t get_refcount_ro4 (const void *refcount_array,uint64_t index) +{ +return be16_to_cpu (((const uint16_t *)refcount_array)[index]); +} + +static void set_refcount_ro4 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>16 )); + ((uint16_t *)refcount_array)[index] =cpu_to_be16 (value); +} + +static int load_refcount_block (BlockDriverState *bs,int64_t refcount_block_offset,void **refcount_block)
@@ -97,7 +118,7 @@ int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index,uint64_t refcount_table_index, block_index;int64_t refcount_block_offset;int ret; -uint16_t *refcount_block; +void *refcount_block; refcount_table_index = cluster_index >> s->refcount_block_bits;if (refcount_table_index >= s->refcount_table_size) {
@@ -119,16 +140,15 @@ int qcow2_get_refcount(BlockDriverState *bs, int64_t cluster_index, } ret =qcow2_cache_get (bs, s->refcount_block_cache, refcount_block_offset, - (void **) &refcount_block); + &refcount_block);if (ret <0 ) {return ret; } block_index = cluster_index & (s->refcount_block_size -1 ); - *refcount =be16_to_cpu (refcount_block[block_index]); + *refcount = s->get_refcount (refcount_block, block_index); - ret =qcow2_cache_put (bs, s->refcount_block_cache, - (void **) &refcount_block); + ret =qcow2_cache_put (bs, s->refcount_block_cache, &refcount_block);if (ret <0 ) {return ret; }
@@ -172,7 +192,7 @@ static int in_same_refcount_block(BDRVQcowState *s, uint64_t offset_a,* Returns 0 on success or -errno in error case */ static int alloc_refcount_block (BlockDriverState *bs, -int64_t cluster_index,uint16_t **refcount_block) +int64_t cluster_index,void **refcount_block) {BDRVQcowState *s = bs->opaque;unsigned int refcount_table_index;
@@ -199,7 +219,7 @@ static int alloc_refcount_block(BlockDriverState *bs, }return load_refcount_block (bs, refcount_block_offset, - (void **) refcount_block); + refcount_block); } }
@@ -259,7 +279,7 @@ static int alloc_refcount_block(BlockDriverState *bs,/* The block describes itself, need to update the cache */ int block_index = (new_block >> s->cluster_bits) & (s->refcount_block_size -1 ); - (*refcount_block)[block_index] =cpu_to_be16 (1 ); + s->set_refcount (*refcount_block, block_index,1 ); }else {/* Described somewhere else. This can recurse at most twice before we * arrive at a block that describes itself. */
@@ -277,7 +297,7 @@ static int alloc_refcount_block(BlockDriverState *bs,/* Initialize the new refcount block only after updating its refcount, * update_refcount uses the refcount cache itself */ ret =qcow2_cache_get_empty (bs, s->refcount_block_cache, new_block, - (void **) refcount_block); + refcount_block);if (ret <0 ) { goto fail_block; }
@@ -311,7 +331,7 @@ static int alloc_refcount_block(BlockDriverState *bs,return -EAGAIN ; } - ret =qcow2_cache_put (bs, s->refcount_block_cache, (void **) refcount_block); + ret =qcow2_cache_put (bs, s->refcount_block_cache, refcount_block);if (ret <0 ) { goto fail_block; }
@@ -365,7 +385,7 @@ static int alloc_refcount_block(BlockDriverState *bs, s->cluster_size;uint64_t table_offset = meta_offset + blocks_clusters * s->cluster_size;uint64_t *new_table =g_try_new0 (uint64_t, table_size); -uint16_t *new_blocks =g_try_malloc0 (blocks_clusters * s->cluster_size); +void *new_blocks =g_try_malloc0_n (blocks_clusters, s->cluster_size);assert (table_size >0 && blocks_clusters >0 );if (new_table ==NULL || new_blocks ==NULL ) {
@@ -387,7 +407,7 @@ static int alloc_refcount_block(BlockDriverState *bs,uint64_t table_clusters =size_to_clusters (s, table_size *sizeof (uint64_t ));int block =0 ;for (i =0 ; i < table_clusters + blocks_clusters; i++) { - new_blocks[block++] =cpu_to_be16 (1 ); + s->set_refcount (new_blocks, block++,1 ); }/* Write refcount blocks to disk */
@@ -440,7 +460,7 @@ static int alloc_refcount_block(BlockDriverState *bs,qcow2_free_clusters (bs, old_table_offset, old_table_size *sizeof (uint64_t ),QCOW2_DISCARD_OTHER ); - ret =load_refcount_block (bs, new_block, (void **) refcount_block); + ret =load_refcount_block (bs, new_block, refcount_block);if (ret <0 ) {return ret; }
@@ -455,7 +475,7 @@ fail_table:g_free (new_table); fail_block:if (*refcount_block !=NULL ) { -qcow2_cache_put (bs, s->refcount_block_cache, (void **) refcount_block); +qcow2_cache_put (bs, s->refcount_block_cache, refcount_block); }return ret; }
@@ -543,7 +563,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, {BDRVQcowState *s = bs->opaque;int64_t start, last, cluster_offset; -uint16_t *refcount_block =NULL ; +void *refcount_block =NULL ;int64_t old_table_index =-1 ;int ret;
@@ -595,7 +615,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,/* we can update the count and save it */ block_index = cluster_index & (s->refcount_block_size -1 ); - refcount =be16_to_cpu (refcount_block[block_index]); + refcount = s->get_refcount (refcount_block, block_index);if (refcount + addend > s->refcount_max || (!decrease && refcount + addend < refcount) || ( decrease && refcount + addend > refcount))
@@ -607,7 +627,7 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,if (refcount ==0 && cluster_index < s->free_cluster_index) { s->free_cluster_index = cluster_index; } - refcount_block[block_index] =cpu_to_be16 (refcount); + s->set_refcount (refcount_block, block_index, refcount);if (refcount ==0 && s->discard_passthrough[type]) {update_refcount_discard (bs, cluster_offset, s->cluster_size);
@@ -623,8 +643,7 @@ fail:/* Write last changed block to disk */ if (refcount_block) {int wret; - wret =qcow2_cache_put (bs, s->refcount_block_cache, - (void **) &refcount_block); + wret =qcow2_cache_put (bs, s->refcount_block_cache, &refcount_block);if (wret <0 ) {return ret <0 ? ret : wret; }
@@ -1162,7 +1181,7 @@ static size_t refcount_array_byte_size(BDRVQcowState *s, uint64_t entries)* will be aligned to a cluster boundary, and the newly allocated area will be * zeroed. */ -static int realloc_refcount_array (BDRVQcowState *s,uint16_t **array, +static int realloc_refcount_array (BDRVQcowState *s,void **array,int64_t *size,int64_t new_size) {/* Round to clusters so the array can be directly written to disk */
@@ -1170,7 +1189,7 @@ static int realloc_refcount_array(BDRVQcowState *s, uint16_t **array, s->cluster_size);size_t new_byte_size =ROUND_UP (refcount_array_byte_size (s, new_size), s->cluster_size); -uint16_t *new_ptr; +void *new_ptr;if (new_byte_size == old_byte_size) { *size = new_size;
@@ -1204,12 +1223,12 @@ static int realloc_refcount_array(BDRVQcowState *s, uint16_t **array,*/ static int inc_refcounts (BlockDriverState *bs,BdrvCheckResult *res, -uint16_t **refcount_table, +void **refcount_table,int64_t *refcount_table_size,int64_t offset,int64_t size) {BDRVQcowState *s = bs->opaque; -uint64_t start, last, cluster_offset, k; +uint64_t start, last, cluster_offset, k, refcount;int ret;if (size <=0 ) {
@@ -1230,11 +1249,14 @@ static int inc_refcounts(BlockDriverState *bs, } } -if (++(*refcount_table)[k] ==0 ) { + refcount = s->get_refcount (*refcount_table, k); +if (refcount == s->refcount_max) {fprintf (stderr,"ERROR: overflow cluster offset=0x%" PRIx64"\n" , cluster_offset); res->corruptions++; +continue ; } + s->set_refcount (*refcount_table, k, refcount +1 ); }return 0 ;
@@ -1254,8 +1276,9 @@ enum {* error occurred. */ static int check_refcounts_l2 (BlockDriverState *bs,BdrvCheckResult *res, -uint16_t **refcount_table,int64_t *refcount_table_size,int64_t l2_offset, -int flags) +void **refcount_table, +int64_t *refcount_table_size,int64_t l2_offset, +int flags) {BDRVQcowState *s = bs->opaque;uint64_t *l2_table, l2_entry;
@@ -1372,7 +1395,7 @@ fail:*/ static int check_refcounts_l1 (BlockDriverState *bs,BdrvCheckResult *res, -uint16_t **refcount_table, +void **refcount_table,int64_t *refcount_table_size,int64_t l1_table_offset,int l1_size,int flags)
@@ -1571,7 +1594,7 @@ fail:*/ static int check_refblocks (BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix,bool *rebuild, -uint16_t **refcount_table,int64_t *nb_clusters) +void **refcount_table,int64_t *nb_clusters) {BDRVQcowState *s = bs->opaque;int64_t i, size;
@@ -1656,9 +1679,10 @@ resize_fail:if (ret <0 ) {return ret; } -if ((*refcount_table)[cluster] !=1 ) { +if (s->get_refcount (*refcount_table, cluster) !=1 ) {fprintf (stderr,"ERROR refcount block %" PRId64 -" refcount=%d\n" , i, (*refcount_table)[cluster]); +" refcount=%" PRIu64"\n" , i, + s->get_refcount (*refcount_table, cluster)); res->corruptions++; *rebuild = true; }
@@ -1673,7 +1697,7 @@ resize_fail:*/ static int calculate_refcounts (BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix,bool *rebuild, -uint16_t **refcount_table,int64_t *nb_clusters) +void **refcount_table,int64_t *nb_clusters) {BDRVQcowState *s = bs->opaque;int64_t i;
@@ -1737,7 +1761,7 @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,static void compare_refcounts (BlockDriverState *bs,BdrvCheckResult *res,BdrvCheckMode fix,bool *rebuild,int64_t *highest_cluster, -uint16_t *refcount_table,int64_t nb_clusters) +void *refcount_table,int64_t nb_clusters) {BDRVQcowState *s = bs->opaque;int64_t i;
@@ -1753,7 +1777,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,continue ; } - refcount2 = refcount_table[i]; + refcount2 = s->get_refcount (refcount_table, i);if (refcount1 >0 || refcount2 >0 ) { *highest_cluster = i;
@@ -1812,7 +1836,7 @@ static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,*/ static int64_t alloc_clusters_imrt (BlockDriverState *bs,int cluster_count, -uint16_t **refcount_table, +void **refcount_table,int64_t *imrt_nb_clusters,int64_t *first_free_cluster) {
@@ -1829,7 +1853,7 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs, contiguous_free_clusters < cluster_count; cluster++) { -if (!(*refcount_table)[cluster]) { +if (!s->get_refcount (*refcount_table, cluster)) { contiguous_free_clusters++;if (first_gap) {/* If this is the first free cluster found, update
@@ -1867,7 +1891,7 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,/* Go back to the first free cluster */ cluster -= contiguous_free_clusters;for (i =0 ; i < cluster_count; i++) { - (*refcount_table)[cluster + i] =1 ; + s->set_refcount (*refcount_table, cluster + i,1 ); }return cluster << s->cluster_bits;
@@ -1883,7 +1907,7 @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,*/ static int rebuild_refcount_structure (BlockDriverState *bs,BdrvCheckResult *res, -uint16_t **refcount_table, +void **refcount_table,int64_t *nb_clusters) {BDRVQcowState *s = bs->opaque;
@@ -1891,8 +1915,8 @@ static int rebuild_refcount_structure(BlockDriverState *bs,int64_t refblock_offset, refblock_start, refblock_index;uint32_t reftable_size =0 ;uint64_t *on_disk_reftable =NULL ; -uint16_t *on_disk_refblock; -int i, ret =0 ; +void *on_disk_refblock; +int ret =0 ;struct {uint64_t reftable_offset;uint32_t reftable_clusters;
@@ -1902,7 +1926,7 @@ static int rebuild_refcount_structure(BlockDriverState *bs, write_refblocks:for (; cluster < *nb_clusters; cluster++) { -if (!(*refcount_table)[cluster]) { +if (!s->get_refcount (*refcount_table, cluster)) {continue ; }
@@ -1975,17 +1999,13 @@ write_refblocks: goto fail; } - on_disk_refblock =qemu_blockalign0 (bs->file, s->cluster_size); -for (i =0 ; i < s->refcount_block_size && - refblock_start + i < *nb_clusters; i++) - { - on_disk_refblock[i] = -cpu_to_be16 ((*refcount_table)[refblock_start + i]); - } +/* The size of *refcount_table is always cluster-aligned, therefore the +* write operation will not overflow */ + on_disk_refblock = (void *)((uintptr_t )*refcount_table + + (refblock_index << s->refcount_block_bits)); ret =bdrv_write (bs->file, refblock_offset /BDRV_SECTOR_SIZE , - (void *)on_disk_refblock, s->cluster_sectors); -qemu_vfree (on_disk_refblock); + on_disk_refblock, s->cluster_sectors);if (ret <0 ) {fprintf (stderr,"ERROR writing refblock: %s\n" ,strerror (-ret)); goto fail;
@@ -2080,7 +2100,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,BDRVQcowState *s = bs->opaque;BdrvCheckResult pre_compare_res;int64_t size, highest_cluster, nb_clusters; -uint16_t *refcount_table =NULL ; +void *refcount_table =NULL ;bool rebuild = false;int ret;
@@ -2129,7 +2149,7 @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,/* Because the old reftable has been exchanged for a new one the * references have to be recalculated */ rebuild = false; -memset (refcount_table,0 , nb_clusters *sizeof (uint16_t )); +memset (refcount_table,0 ,refcount_array_byte_size (s, nb_clusters)); ret =calculate_refcounts (bs, res,0 , &rebuild, &refcount_table, &nb_clusters);if (ret <0 ) {
block/qcow2.h +8 -0
@@ -213,6 +213,11 @@ typedef struct Qcow2DiscardRegion {QTAILQ_ENTRY (Qcow2DiscardRegion) next; } Qcow2DiscardRegion; +typedef uint64_t Qcow2GetRefcountFunc (const void *refcount_array, +uint64_t index); +typedef void Qcow2SetRefcountFunc (void *refcount_array, +uint64_t index,uint64_t value); + typedef struct BDRVQcowState { int cluster_bits; int cluster_size;
@@ -261,6 +266,9 @@ typedef struct BDRVQcowState {int refcount_bits;uint64_t refcount_max; +Qcow2GetRefcountFunc *get_refcount; +Qcow2SetRefcountFunc *set_refcount; +bool discard_passthrough[QCOW2_DISCARD_MAX ];int overlap_check;/* bitmask of Qcow2MetadataOverlap values */
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 10/26] qcow2: Helper function for refcount modification
Quoted 15 lines · Max Reitz
Since refcounts do not always have to be a
uint16_t, all refcount blocks and arrays in memory should not have a specific type (thus they become pointers to void) and for accessing them, two helper functions are used (a getter and a setter). Those functions are called indirectly through function pointers in the BDRVQcowState so they may later be exchanged for different refcount orders.With the check and repair functions using this function, the refcount array they are creating will be in big endian byte order; additionally, using
realloc_refcount_array()makes the size of this refcount array always cluster-aligned. Both combined allowrebuild_refcount_structure()to drop the bounce buffer which was used to convert parts of the refcount array to big endian byte order and store them on disk. Instead, those parts can now be written directly.
Quoted 6 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 122 ++++++++++++++++++++++++++++--------------------- block/qcow2.h | 8 ++++ 2 files changed, 79 insertions(+), 51 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 10/26] qcow2: Helper function for refcount modification
In reply to Max ReitzQuoted 15 lines · Max Reitz
Since refcounts do not always have to be a
uint16_t, all refcount blocks and arrays in memory should not have a specific type (thus they become pointers to void) and for accessing them, two helper functions are used (a getter and a setter). Those functions are called indirectly through function pointers in the BDRVQcowState so they may later be exchanged for different refcount orders.With the check and repair functions using this function, the refcount array they are creating will be in big endian byte order; additionally, using
realloc_refcount_array()makes the size of this refcount array always cluster-aligned. Both combined allowrebuild_refcount_structure()to drop the bounce buffer which was used to convert parts of the refcount array to big endian byte order and store them on disk. Instead, those parts can now be written directly.
Quoted 5 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 122 ++++++++++++++++++++++++++++--------------------- block/qcow2.h | 8 ++++ 2 files changed, 79 insertions(+), 51 deletions(-)
PATCH v4 11/26 qcow2: More helpers for refcount modification
In reply to Max ReitzAdd helper functions for getting and setting refcounts in a refcount array for any possible refcount order, and choose the correct one during refcount initialization.
--- block/qcow2-refcount.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 119 insertions(+), 2 deletions(-)
block/qcow2-refcount.c +119 -2
@@ -32,10 +32,49 @@ static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs, int64_t offset, int64_t length, uint64_t addend, bool decrease, enum qcow2_discard_type type); +static uint64_t get_refcount_ro0 (const void *refcount_array,uint64_t index); +static uint64_t get_refcount_ro1 (const void *refcount_array,uint64_t index); +static uint64_t get_refcount_ro2 (const void *refcount_array,uint64_t index); +static uint64_t get_refcount_ro3 (const void *refcount_array,uint64_t index);static uint64_t get_refcount_ro4 (const void *refcount_array,uint64_t index); +static uint64_t get_refcount_ro5 (const void *refcount_array,uint64_t index); +static uint64_t get_refcount_ro6 (const void *refcount_array,uint64_t index); +static void set_refcount_ro0 (void *refcount_array,uint64_t index, +uint64_t value); +static void set_refcount_ro1 (void *refcount_array,uint64_t index, +uint64_t value); +static void set_refcount_ro2 (void *refcount_array,uint64_t index, +uint64_t value); +static void set_refcount_ro3 (void *refcount_array,uint64_t index, +uint64_t value);static void set_refcount_ro4 (void *refcount_array,uint64_t index,uint64_t value); +static void set_refcount_ro5 (void *refcount_array,uint64_t index, +uint64_t value); +static void set_refcount_ro6 (void *refcount_array,uint64_t index, +uint64_t value); + + +static Qcow2GetRefcountFunc *const get_refcount_funcs[] = { + &get_refcount_ro0, + &get_refcount_ro1, + &get_refcount_ro2, + &get_refcount_ro3, + &get_refcount_ro4, + &get_refcount_ro5, + &get_refcount_ro6 +}; + +static Qcow2SetRefcountFunc *const set_refcount_funcs[] = { + &set_refcount_ro0, + &set_refcount_ro1, + &set_refcount_ro2, + &set_refcount_ro3, + &set_refcount_ro4, + &set_refcount_ro5, + &set_refcount_ro6 +};/*********************************************************/
@@ -47,8 +86,10 @@ int qcow2_refcount_init(BlockDriverState *bs)unsigned int refcount_table_size2, i;int ret; - s->get_refcount = &get_refcount_ro4; - s->set_refcount = &set_refcount_ro4; +assert (s->refcount_order >=0 && s->refcount_order <=6 ); + + s->get_refcount = get_refcount_funcs[s->refcount_order]; + s->set_refcount = set_refcount_funcs[s->refcount_order];assert (s->refcount_table_size <=INT_MAX /sizeof (uint64_t )); refcount_table_size2 = s->refcount_table_size *sizeof (uint64_t );
@@ -80,6 +121,59 @@ void qcow2_refcount_close(BlockDriverState *bs) } +static uint64_t get_refcount_ro0 (const void *refcount_array,uint64_t index) +{ +return (((const uint8_t *)refcount_array)[index /8 ] >> (index %8 )) &0x1 ; +} + +static void set_refcount_ro0 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>1 )); + ((uint8_t *)refcount_array)[index /8 ] &= ~(0x1 << (index %8 )); + ((uint8_t *)refcount_array)[index /8 ] |= value << (index %8 ); +} + +static uint64_t get_refcount_ro1 (const void *refcount_array,uint64_t index) +{ +return (((const uint8_t *)refcount_array)[index /4 ] >> (2 * (index %4 ))) + &0x3 ; +} + +static void set_refcount_ro1 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>2 )); + ((uint8_t *)refcount_array)[index /4 ] &= ~(0x3 << (2 * (index %4 ))); + ((uint8_t *)refcount_array)[index /4 ] |= value << (2 * (index %4 )); +} + +static uint64_t get_refcount_ro2 (const void *refcount_array,uint64_t index) +{ +return (((const uint8_t *)refcount_array)[index /2 ] >> (4 * (index %2 ))) + &0xf ; +} + +static void set_refcount_ro2 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>4 )); + ((uint8_t *)refcount_array)[index /2 ] &= ~(0xf << (4 * (index %2 ))); + ((uint8_t *)refcount_array)[index /2 ] |= value << (4 * (index %2 )); +} + +static uint64_t get_refcount_ro3 (const void *refcount_array,uint64_t index) +{ +return ((const uint8_t *)refcount_array)[index]; +} + +static void set_refcount_ro3 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>8 )); + ((uint8_t *)refcount_array)[index] = value; +} +static uint64_t get_refcount_ro4 (const void *refcount_array,uint64_t index) {return be16_to_cpu (((const uint16_t *)refcount_array)[index]);
@@ -92,6 +186,29 @@ static void set_refcount_ro4(void *refcount_array, uint64_t index, ((uint16_t *)refcount_array)[index] =cpu_to_be16 (value); } +static uint64_t get_refcount_ro5 (const void *refcount_array,uint64_t index) +{ +return be32_to_cpu (((const uint32_t *)refcount_array)[index]); +} + +static void set_refcount_ro5 (void *refcount_array,uint64_t index, +uint64_t value) +{ +assert (!(value >>32 )); + ((uint32_t *)refcount_array)[index] =cpu_to_be32 (value); +} + +static uint64_t get_refcount_ro6 (const void *refcount_array,uint64_t index) +{ +return be64_to_cpu (((const uint64_t *)refcount_array)[index]); +} + +static void set_refcount_ro6 (void *refcount_array,uint64_t index, +uint64_t value) +{ + ((uint64_t *)refcount_array)[index] =cpu_to_be64 (value); +} + static int load_refcount_block(BlockDriverState *bs, int64_t refcount_block_offset,
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 11/26] qcow2: More helpers for refcount modification
Quoted 9 lines · Max Reitz
Add helper functions for getting and setting refcounts in a refcount array for any possible refcount order, and choose the correct one during refcount initialization.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 119 insertions(+), 2 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 11/26] qcow2: More helpers for refcount modification
In reply to Max ReitzQuoted 8 lines · Max Reitz
Add helper functions for getting and setting refcounts in a refcount array for any possible refcount order, and choose the correct one during refcount initialization.
Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 119 insertions(+), 2 deletions(-)
PATCH v4 12/26 qcow2: Open images with refcount order != 4
In reply to Max ReitzNo longer refuse to open images with a different refcount entry width than 16 bits; only reject images with a refcount width larger than 64 bits (which is prohibited by the specification).
--- block/qcow2.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
block/qcow2.c +4 -4
@@ -677,10 +677,10 @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags, }/* Check support for various header values */ -if (header.refcount_order !=4 ) { -report_unsupported (bs, errp,"%d bit reference counts" , -1 << header.refcount_order); - ret = -ENOTSUP ; +if (header.refcount_order >6 ) { +error_setg (errp,"Reference count entry width too large; may not " +"exceed 64 bits" ); + ret = -EINVAL ; goto fail; } s->refcount_order = header.refcount_order;
Signature · 1 line
1.9.3
PATCH v4 13/26 qcow2: refcount_order parameter for qcow2_create2
In reply to Max ReitzAdd a refcount_order parameter to qcow2_create2(), use that value for the image header and for calculating the size required for preallocation.
For now, always pass 4.
This addition requires changes to the calculation of the file size for the "full" and "falloc" preallocation modes. That in turn is a nice opportunity to add a comment about that calculation not necessarily being exact (and that being intentional).
--- block/qcow2.c | 46 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 35 insertions(+), 11 deletions(-)
block/qcow2.c +35 -11
@@ -1769,7 +1769,7 @@ static int preallocate(BlockDriverState *bs)static int qcow2_create2 (const char *filename,int64_t total_size,const char *backing_file,const char *backing_format,int flags,size_t cluster_size,PreallocMode prealloc, -QemuOpts *opts,int version, +QemuOpts *opts,int version,int refcount_order,Error **errp) {/* Calculate cluster_bits */
@@ -1802,9 +1802,21 @@ static int qcow2_create2(const char *filename, int64_t total_size,int ret;if (prealloc ==PREALLOC_MODE_FULL || prealloc ==PREALLOC_MODE_FALLOC ) { +/* Note: The following calculation does not need to be exact; if it is a +* bit off, either some bytes will be "leaked" (which is fine) or we +* will need to increase the file size by some bytes (which is fine, +* too, as long as the bulk is allocated here). Therefore, using +* floating point arithmetic is fine. */ int64_t meta_size =0 ;uint64_t nreftablee, nrefblocke, nl1e, nl2e;int64_t aligned_total_size =align_offset (total_size, cluster_size); +int refblock_bits, refblock_size; +/* refcount entry size in bytes */ +double rces = (1 << refcount_order) /8. ; + +/* see qcow2_open() */ + refblock_bits = cluster_bits - (refcount_order -3 ); + refblock_size =1 << refblock_bits;/* header: 1 cluster */ meta_size += cluster_size;
@@ -1829,20 +1841,20 @@ static int qcow2_create2(const char *filename, int64_t total_size,* c = cluster size * y1 = number of refcount blocks entries * y2 = meta size including everything +* rces = refcount entry size in bytes * then, * y1 = (y2 + a)/c -* y2 = y1 * sizeof(u16) + y1 * sizeof(u16) * sizeof(u64) / c + m +* y2 = y1 * rces + y1 * rces * sizeof(u64) / c + m * we can get y1: -* y1 = (a + m) / (c - sizeof(u16) - sizeof(u16) * sizeof(u64) / c) +* y1 = (a + m) / (c - rces - rces * sizeof(u64) / c) */ - nrefblocke = (aligned_total_size + meta_size + cluster_size) / - (cluster_size -sizeof (uint16_t ) - -1.0 *sizeof (uint16_t ) *sizeof (uint64_t ) / cluster_size); - nrefblocke =align_offset (nrefblocke, cluster_size /sizeof (uint16_t )); - meta_size += nrefblocke *sizeof (uint16_t ); + nrefblocke = (aligned_total_size + meta_size + cluster_size) + / (cluster_size - rces - rces *sizeof (uint64_t ) + / cluster_size); + meta_size +=DIV_ROUND_UP (nrefblocke, refblock_size) * cluster_size;/* total size of refcount tables */ - nreftablee = nrefblocke *sizeof (uint16_t ) / cluster_size; + nreftablee = nrefblocke / refblock_size; nreftablee =align_offset (nreftablee, cluster_size /sizeof (uint64_t )); meta_size += nreftablee *sizeof (uint64_t );
@@ -1877,7 +1889,7 @@ static int qcow2_create2(const char *filename, int64_t total_size, .l1_size = cpu_to_be32(0), .refcount_table_offset = cpu_to_be64(cluster_size), .refcount_table_clusters = cpu_to_be32(1), - .refcount_order = cpu_to_be32(4), + .refcount_order = cpu_to_be32(refcount_order), .header_length = cpu_to_be32(sizeof(*header)), };
@@ -1997,6 +2009,7 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)size_t cluster_size =DEFAULT_CLUSTER_SIZE ;PreallocMode prealloc;int version =3 ; +int refcount_bits =16 , refcount_order;Error *local_err =NULL ;int ret;
@@ -2051,8 +2064,19 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp) goto finish; } +if (version <3 && refcount_bits !=16 ) { +error_setg (errp,"Different refcount widths than 16 bits require " +"compatibility level 1.1 or above (use compat=1.1 or " +"greater)" ); + ret = -EINVAL ; + goto finish; + } + + refcount_order =ffs (refcount_bits) -1 ; + ret =qcow2_create2 (filename, size, backing_file, backing_fmt, flags, - cluster_size, prealloc, opts, version, &local_err); + cluster_size, prealloc, opts, version, refcount_order, + &local_err);if (local_err) {error_propagate (errp, local_err); }
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 13/26] qcow2: refcount_order parameter for qcow2_create2
Quoted 11 lines · Max Reitz
Add a
refcount_orderparameter toqcow2_create2(), use that value for the image header and for calculating the size required for preallocation.For now, always pass 4.
This addition requires changes to the calculation of the file size for the "full" and "falloc" preallocation modes. That in turn is a nice opportunity to add a comment about that calculation not necessarily being exact (and that being intentional).
Quoted 4 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 46 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 35 insertions(+), 11 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 13/26] qcow2: refcount_order parameter for qcow2_create2
In reply to Max ReitzQuoted 11 lines · Max Reitz
Add a
refcount_orderparameter toqcow2_create2(), use that value for the image header and for calculating the size required for preallocation.For now, always pass 4.
This addition requires changes to the calculation of the file size for the "full" and "falloc" preallocation modes. That in turn is a nice opportunity to add a comment about that calculation not necessarily being exact (and that being intentional).
Quoted 4 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 46 +++++++++++++++++++++++++++++++++++----------- 1 file changed, 35 insertions(+), 11 deletions(-)
PATCH v4 14/26 qcow2: Use symbolic macros in qcow2_amend_options
In reply to Max Reitzqcow2_amend_options() should not compare options against some inline strings but rather use the symbolic macros available for each of the creation options.
--- block/qcow2.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-)
block/qcow2.c +16 -15
@@ -2664,8 +2664,8 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,continue ; } -if (!strcmp (desc->name,"compat" )) { - compat =qemu_opt_get (opts,"compat" ); +if (!strcmp (desc->name,BLOCK_OPT_COMPAT_LEVEL )) { + compat =qemu_opt_get (opts,BLOCK_OPT_COMPAT_LEVEL );if (!compat) {/* preserve default */ }else if (!strcmp (compat,"0.10" )) {
@@ -2676,32 +2676,33 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,fprintf (stderr,"Unknown compatibility level %s.\n" , compat);return -EINVAL ; } - }else if (!strcmp (desc->name,"preallocation" )) { + }else if (!strcmp (desc->name,BLOCK_OPT_PREALLOC )) {fprintf (stderr,"Cannot change preallocation mode.\n" );return -ENOTSUP ; - }else if (!strcmp (desc->name,"size" )) { - new_size =qemu_opt_get_size (opts,"size" ,0 ); - }else if (!strcmp (desc->name,"backing_file" )) { - backing_file =qemu_opt_get (opts,"backing_file" ); - }else if (!strcmp (desc->name,"backing_fmt" )) { - backing_format =qemu_opt_get (opts,"backing_fmt" ); - }else if (!strcmp (desc->name,"encryption" )) { - encrypt =qemu_opt_get_bool (opts,"encryption" , s->crypt_method); + }else if (!strcmp (desc->name,BLOCK_OPT_SIZE )) { + new_size =qemu_opt_get_size (opts,BLOCK_OPT_SIZE ,0 ); + }else if (!strcmp (desc->name,BLOCK_OPT_BACKING_FILE )) { + backing_file =qemu_opt_get (opts,BLOCK_OPT_BACKING_FILE ); + }else if (!strcmp (desc->name,BLOCK_OPT_BACKING_FMT )) { + backing_format =qemu_opt_get (opts,BLOCK_OPT_BACKING_FMT ); + }else if (!strcmp (desc->name,BLOCK_OPT_ENCRYPT )) { + encrypt =qemu_opt_get_bool (opts,BLOCK_OPT_ENCRYPT , + s->crypt_method);if (encrypt != !!s->crypt_method) {fprintf (stderr,"Changing the encryption flag is not " "supported.\n" );return -ENOTSUP ; } - }else if (!strcmp (desc->name,"cluster_size" )) { - cluster_size =qemu_opt_get_size (opts,"cluster_size" , + }else if (!strcmp (desc->name,BLOCK_OPT_CLUSTER_SIZE )) { + cluster_size =qemu_opt_get_size (opts,BLOCK_OPT_CLUSTER_SIZE , cluster_size);if (cluster_size != s->cluster_size) {fprintf (stderr,"Changing the cluster size is not " "supported.\n" );return -ENOTSUP ; } - }else if (!strcmp (desc->name,"lazy_refcounts" )) { - lazy_refcounts =qemu_opt_get_bool (opts,"lazy_refcounts" , + }else if (!strcmp (desc->name,BLOCK_OPT_LAZY_REFCOUNTS )) { + lazy_refcounts =qemu_opt_get_bool (opts,BLOCK_OPT_LAZY_REFCOUNTS , lazy_refcounts); }else {/* if this assertion fails, this probably means a new option was
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 14/26] qcow2: Use symbolic macros in qcow2_amend_options
Quoted 8 lines · Max Reitz
qcow2_amend_options()should not compare options against some inline strings but rather use the symbolic macros available for each of the creation options.Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 14/26] qcow2: Use symbolic macros in qcow2_amend_options
In reply to Max ReitzQuoted 8 lines · Max Reitz
qcow2_amend_options()should not compare options against some inline strings but rather use the symbolic macros available for each of the creation options.Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-)
PATCH v4 15/26 iotests: Prepare for refcount_bits option
In reply to Max ReitzSome tests do not work well with certain refcount widths (i.e. you cannot create internal snapshots with refcount_bits=1), so make those widths unsupported.
Furthermore, add another filter to _filter_img_create in common.filter which filters out the refcount_bits value.
This is necessary for test 079, which does actually work with any refcount width, but invoking qemu-img directly leads to the refcount_bits value being visible in the output; use _make_test_img instead which will filter it out.
--- tests/qemu-iotests/007 | 3 +++ tests/qemu-iotests/015 | 2 ++ tests/qemu-iotests/026 | 7 +++++++ tests/qemu-iotests/029 | 2 ++ tests/qemu-iotests/051 | 3 +++ tests/qemu-iotests/058 | 2 ++ tests/qemu-iotests/067 | 2 ++ tests/qemu-iotests/079 | 10 ++-------- tests/qemu-iotests/079.out | 38 ++++++++++---------------------------- tests/qemu-iotests/080 | 2 ++ tests/qemu-iotests/089 | 2 ++ tests/qemu-iotests/108 | 2 ++ tests/qemu-iotests/common.filter | 3 ++- 13 files changed, 41 insertions(+), 37 deletions(-)
tests/qemu-iotests/007 +3 -0
@@ -43,6 +43,9 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto generic _supported_os Linux +# refcount_bits must be at least 4 so we can create ten internal snapshots +# (1 bit supports none, 2 bits support two, 4 bits support 14) +_unsupported_imgopts 'refcount_bits=\(1\|2\)[^0-9]' echo echo "creating image"
tests/qemu-iotests/015 +2 -0
@@ -43,6 +43,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto generic _supported_os Linux +# Internal snapshots are (currently) impossible with refcount_bits=1 +_unsupported_imgopts 'refcount_bits=1[^0-9]' echo echo "creating image"
tests/qemu-iotests/026 +7 -0
@@ -46,6 +46,13 @@ _supported_proto file _supported_os Linux _default_cache_mode "writethrough" _supported_cache_modes "writethrough" "none" +# The refcount table tests expect a certain minimum width for refcount entries +# (so that the refcount table actually needs to grow); that minimum is 16 bits, +# being the default refcount entry width. +# 32 and 64 bits do not work either, however, due to different leaked cluster +# count on error. +# Thus, the only remaining option is refcount_bits=16. +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' echo "Errors while writing 128 kB" echo
tests/qemu-iotests/029 +2 -0
@@ -44,6 +44,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto generic _supported_os Linux +# Internal snapshots are (currently) impossible with refcount_bits=1 +_unsupported_imgopts 'refcount_bits=1[^0-9]' offset_size=24 offset_l1_size=36
tests/qemu-iotests/051 +3 -0
@@ -41,6 +41,9 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto file _supported_os Linux +# A compat=0.10 image is created in this test which does not support anything +# other than refcount_bits=16 +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' function do_run_qemu() {
tests/qemu-iotests/058 +2 -0
@@ -88,6 +88,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto file _require_command QEMU_NBD +# Internal snapshots are (currently) impossible with refcount_bits=1 +_unsupported_imgopts 'refcount_bits=1[^0-9]' # Use -f raw instead of -f $IMGFMT for the NBD connection QEMU_IO_NBD="$QEMU_IO -f raw --cache=$CACHEMODE"
tests/qemu-iotests/067 +2 -0
@@ -35,6 +35,8 @@ status=1 # failure is the default! _supported_fmt qcow2 _supported_proto file _supported_os Linux +# Because anything other than 16 would change the output of query-block +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' function do_run_qemu() {
tests/qemu-iotests/079 +2 -8
@@ -42,19 +42,13 @@ _supported_fmt qcow2 _supported_proto file nfs _supported_os Linux -function test_qemu_img() -{ - echo qemu-img "$@" | _filter_testdir - $QEMU_IMG "$@" 2>&1 | _filter_testdir - echo -} - echo "=== Check option preallocation and cluster_size ===" echo cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304" for s in $cluster_sizes; do - test_qemu_img create -f $IMGFMT -o preallocation=metadata,cluster_size=$s "$TEST_IMG" 4G + IMGOPTS=$(_optstr_add "$IMGOPTS" "preallocation=metadata,cluster_size=$s") \ + _make_test_img 4G done # success, all done
tests/qemu-iotests/079.out +10 -28
@@ -1,32 +1,14 @@ QA output created by 079 === Check option preallocation and cluster_size === -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=16384 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=16384 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=32768 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=32768 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=65536 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=65536 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=131072 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=131072 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=262144 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=262144 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=524288 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=524288 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=1048576 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=1048576 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=2097152 TEST_DIR/t.qcow2 4G -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=2097152 preallocation='metadata' lazy_refcounts=off - -qemu-img create -f qcow2 -o preallocation=metadata,cluster_size=4194304 TEST_DIR/t.qcow2 4G -qemu-img: TEST_DIR/t.qcow2: Cluster size must be a power of two between 512 and 2048k -Formatting 'TEST_DIR/t.qcow2', fmt=qcow2 size=4294967296 encryption=off cluster_size=4194304 preallocation='metadata' lazy_refcounts=off - +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' +qemu-img: TEST_DIR/t.IMGFMT: Cluster size must be a power of two between 512 and 2048k +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4294967296 preallocation='metadata' *** done
tests/qemu-iotests/080 +2 -0
@@ -42,6 +42,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto file _supported_os Linux +# Internal snapshots are (currently) impossible with refcount_bits=1 +_unsupported_imgopts 'refcount_bits=1[^0-9]' header_size=104
tests/qemu-iotests/089 +2 -0
@@ -41,6 +41,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto file _supported_os Linux +# Because anything other than 16 would change the output of qemu_io -c info +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' # Using an image filename containing quotation marks will render the JSON data # below invalid. In that case, we have little choice but simply not to run this
tests/qemu-iotests/108 +2 -0
@@ -43,6 +43,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15 _supported_fmt qcow2 _supported_proto file _supported_os Linux +# This test directly modifies a refblock so it relies on refcount_bits being 16 +_unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)' echo echo '=== Repairing an image without any refcount table ==='
tests/qemu-iotests/common.filter +2 -1
@@ -191,7 +191,8 @@ _filter_img_create() -e "s# block_size=[0-9]\\+##g" \ -e "s# block_state_zero=\\(on\\|off\\)##g" \ -e "s# log_size=[0-9]\\+##g" \ - -e "s/archipelago:a/TEST_DIR\//g" + -e "s/archipelago:a/TEST_DIR\//g" \ + -e "s# refcount_bits=[0-9]\\+##g" } _filter_img_info()
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 15/26] iotests: Prepare for refcount_bits option
Quoted 7 lines · Max Reitz
Some tests do not work well with certain refcount widths (i.e. you cannot create internal snapshots with refcount_bits=1), so make those widths unsupported.
Furthermore, add another filter to
_filter_img_createin common.filter which filters out therefcount_bitsvalue.
Quoted 7 lines
This is necessary for test 079, which does actually work with any refcount width, but invoking qemu-img directly leads to the
refcount_bitsvalue being visible in the output; use_make_test_imginstead which will filter it out.Signed-off-by Max Reitz <[email protected]>---
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 15/26] iotests: Prepare for refcount_bits option
In reply to Max ReitzQuoted 13 lines · Max Reitz
Some tests do not work well with certain refcount widths (i.e. you cannot create internal snapshots with refcount_bits=1), so make those widths unsupported.
Furthermore, add another filter to
_filter_img_createin common.filter which filters out therefcount_bitsvalue.This is necessary for test 079, which does actually work with any refcount width, but invoking qemu-img directly leads to the
refcount_bitsvalue being visible in the output; use_make_test_imginstead which will filter it out.Signed-off-by Max Reitz <[email protected]>
Quoted 15 lines
--- tests/qemu-iotests/007 | 3 +++ tests/qemu-iotests/015 | 2 ++ tests/qemu-iotests/026 | 7 +++++++ tests/qemu-iotests/029 | 2 ++ tests/qemu-iotests/051 | 3 +++ tests/qemu-iotests/058 | 2 ++ tests/qemu-iotests/067 | 2 ++ tests/qemu-iotests/079 | 10 ++-------- tests/qemu-iotests/079.out | 38 ++++++++++---------------------------- tests/qemu-iotests/080 | 2 ++ tests/qemu-iotests/089 | 2 ++ tests/qemu-iotests/108 | 2 ++ tests/qemu-iotests/common.filter | 3 ++- 13 files changed, 41 insertions(+), 37 deletions(-)
PATCH v4 16/26 qcow2: Allow creation with refcount order != 4
In reply to Max ReitzAdd a creation option to qcow2 for setting the refcount order of images to be created, and respect that option's value.
This breaks some test outputs, fix them.
--- block/qcow2.c | 20 ++++++++ include/block/block_int.h | 1 + tests/qemu-iotests/049.out | 112 ++++++++++++++++++++++----------------------- tests/qemu-iotests/082.out | 41 ++++++++++++++--- tests/qemu-iotests/085.out | 38 +++++++-------- 5 files changed, 130 insertions(+), 82 deletions(-)
block/qcow2.c +20 -0
@@ -2064,6 +2064,17 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp) goto finish; } + refcount_bits =qemu_opt_get_number_del (opts,BLOCK_OPT_REFCOUNT_BITS , + refcount_bits); +if (refcount_bits <=0 || refcount_bits >64 || + !is_power_of_2 (refcount_bits)) + { +error_setg (errp,"Refcount width must be a power of two and may not " +"exceed 64 bits" ); + ret = -EINVAL ; + goto finish; + } +if (version <3 && refcount_bits !=16 ) {error_setg (errp,"Different refcount widths than 16 bits require " "compatibility level 1.1 or above (use compat=1.1 or "
@@ -2704,6 +2715,9 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, }else if (!strcmp (desc->name,BLOCK_OPT_LAZY_REFCOUNTS )) { lazy_refcounts =qemu_opt_get_bool (opts,BLOCK_OPT_LAZY_REFCOUNTS , lazy_refcounts); + }else if (!strcmp (desc->name,BLOCK_OPT_REFCOUNT_BITS )) { +error_report ("Cannot change refcount entry width" ); +return -ENOTSUP ; }else {/* if this assertion fails, this probably means a new option was * added without having it covered here */
@@ -2873,6 +2887,12 @@ static QemuOptsList qcow2_create_opts = { .help = "Postpone refcount updates", .def_value_str = "off" }, + { + .name = BLOCK_OPT_REFCOUNT_BITS, + .type = QEMU_OPT_NUMBER, + .help = "Width of a reference count entry in bits", + .def_value_str = "16" + }, {/* end of list */ } } };
include/block/block_int.h +1 -0
@@ -56,6 +56,7 @@#define BLOCK_OPT_ADAPTER_TYPE "adapter_type"#define BLOCK_OPT_REDUNDANCY "redundancy"#define BLOCK_OPT_NOCOW "nocow" +#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits"#define BLOCK_PROBE_BUF_SIZE 512
tests/qemu-iotests/049.out +56 -56
254 lines not on this page · raw message
tests/qemu-iotests/082.out +34 -7
238 lines not on this page · raw message
tests/qemu-iotests/085.out +19 -19
@@ -11,7 +11,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 === Create a single snapshot on virtio0 === -Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2.orig' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2.orig' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} === Invalid command - missing device and nodename ===
@@ -25,31 +25,31 @@ Formatting 'TEST_DIR/1-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file === Create several transactional group snapshots === -Formatting 'TEST_DIR/2-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/1-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/2-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/2-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/1-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/2-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/t.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/3-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/2-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/3-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/2-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/3-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/2-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/3-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/2-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/4-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/3-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/4-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/3-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/4-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/3-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/4-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/3-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/5-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/4-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/5-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/4-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/5-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/4-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/5-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/4-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/6-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/5-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/6-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/5-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/6-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/5-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/6-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/5-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/7-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/6-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/7-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/6-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/7-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/6-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/7-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/6-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/8-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/7-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/8-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/7-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/8-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/7-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/8-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/7-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/9-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/8-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/9-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/8-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/9-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/8-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/9-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/8-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} -Formatting 'TEST_DIR/10-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/9-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off -Formatting 'TEST_DIR/10-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/9-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off +Formatting 'TEST_DIR/10-snapshot-v0.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/9-snapshot-v0.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/10-snapshot-v1.qcow2', fmt=qcow2 size=134217728 backing_file='TEST_DIR/9-snapshot-v1.qcow2' backing_fmt='qcow2' encryption=off cluster_size=65536 lazy_refcounts=off refcount_bits=16 {"return": {}} *** done
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 16/26] qcow2: Allow creation with refcount order != 4
Quoted 5 lines · Max Reitz
Add a creation option to qcow2 for setting the refcount order of images to be created, and respect that option's value.
This breaks some test outputs, fix them.
Quoted 9 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 20 ++++++++ include/block/block_int.h | 1 + tests/qemu-iotests/049.out | 112 ++++++++++++++++++++++----------------------- tests/qemu-iotests/082.out | 41 ++++++++++++++--- tests/qemu-iotests/085.out | 38 +++++++-------- 5 files changed, 130 insertions(+), 82 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 16/26] qcow2: Allow creation with refcount order != 4
In reply to Max ReitzQuoted 5 lines · Max Reitz
Add a creation option to qcow2 for setting the refcount order of images to be created, and respect that option's value.
This breaks some test outputs, fix them.
Quoted 8 lines
Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 20 ++++++++ include/block/block_int.h | 1 + tests/qemu-iotests/049.out | 112 ++++++++++++++++++++++----------------------- tests/qemu-iotests/082.out | 41 ++++++++++++++--- tests/qemu-iotests/085.out | 38 +++++++-------- 5 files changed, 130 insertions(+), 82 deletions(-)
PATCH v4 17/26 progress: Allow regressing progress
In reply to Max ReitzProgress may regress; this should be displayed correctly by qemu_progress_print().
While touching that area of code, drop the redundant parentheses in the same condition.
--- util/qemu-progress.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
util/qemu-progress.c +2 -1
@@ -152,7 +152,8 @@ void qemu_progress_print(float delta, int max) state.current = current;if (current > (state.last_print + state.min_skip) || - (current ==100 ) || (current ==0 )) { + current < (state.last_print - state.min_skip) || + current ==100 || current ==0 ) { state.last_print = state.current; state.
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 17/26] progress: Allow regressing progress
Quoted 10 lines · Max Reitz
Progress may regress; this should be displayed correctly by
qemu_progress_print().While touching that area of code, drop the redundant parentheses in the same condition.
Signed-off-by Max Reitz <[email protected]>--- util/qemu-progress.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
Quoted 16 lines
util/qemu-progress.c +2
-1@@ -152,7 +152,8 @@ void qemu_progress_print(float delta, int max) state.current = current;if (current > (state.last_print + state.min_skip) || - (current ==100 ) || (current ==0 )) { + current < (state.last_print - state.min_skip) || + current ==100 || current ==0 ) { state.last_print = state.current; state.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 17/26] progress: Allow regressing progress
In reply to Max ReitzQuoted 10 lines · Max Reitz
Progress may regress; this should be displayed correctly by
qemu_progress_print().While touching that area of code, drop the redundant parentheses in the same condition.
Signed-off-by Max Reitz <[email protected]>--- util/qemu-progress.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
PATCH v4 18/26 block: Add opaque value to the amend CB
In reply to Max ReitzAdd an opaque value which is to be passed to the bdrv_amend_options() status callback.
--- block.c | 4 ++-- block/qcow2-cluster.c | 14 ++++++++------ block/qcow2.c | 9 +++++---- block/qcow2.h | 3 ++- include/block/block.h | 4 ++-- include/block/block_int.h | 3 ++- qemu-img.c | 5 +++-- 7 files changed, 24 insertions(+), 18 deletions(-)
block.c +2 -2
@@ -5812,12 +5812,12 @@ void bdrv_add_before_write_notifier(BlockDriverState *bs, }int bdrv_amend_options (BlockDriverState *bs,QemuOpts *opts, -BlockDriverAmendStatusCB *status_cb) +BlockDriverAmendStatusCB *status_cb,void *cb_opaque) {if (!bs->drv->bdrv_amend_options) {return -ENOTSUP ; } -return bs->drv->bdrv_amend_options (bs, opts, status_cb); +return bs->drv->bdrv_amend_options (bs, opts, status_cb, cb_opaque); }/* This function will be called by the bdrv_recurse_is_first_non_filter method
block/qcow2-cluster.c +8 -6
@@ -1620,7 +1620,8 @@ fail:static int expand_zero_clusters_in_l1 (BlockDriverState *bs,uint64_t *l1_table,int l1_size,int64_t *visited_l1_entries,int64_t l1_entries, -BlockDriverAmendStatusCB *status_cb) +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque) {BDRVQcowState *s = bs->opaque;bool is_active_l1 = (l1_table == s->l1_table);
@@ -1646,7 +1647,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table,/* unallocated */ (*visited_l1_entries)++;if (status_cb) { -status_cb (bs, *visited_l1_entries, l1_entries); +status_cb (bs, *visited_l1_entries, l1_entries, cb_opaque); }continue ; }
@@ -1765,7 +1766,7 @@ static int expand_zero_clusters_in_l1(BlockDriverState *bs, uint64_t *l1_table, (*visited_l1_entries)++;if (status_cb) { -status_cb (bs, *visited_l1_entries, l1_entries); +status_cb (bs, *visited_l1_entries, l1_entries, cb_opaque); } }
@@ -1794,7 +1795,8 @@ fail:* qcow2 version which doesn't yet support metadata zero clusters. */ int qcow2_expand_zero_clusters (BlockDriverState *bs, -BlockDriverAmendStatusCB *status_cb) +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque) {BDRVQcowState *s = bs->opaque;uint64_t *l1_table =NULL ;
@@ -1811,7 +1813,7 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs, ret =expand_zero_clusters_in_l1 (bs, s->l1_table, s->l1_size, &visited_l1_entries, l1_entries, - status_cb); + status_cb, cb_opaque);if (ret <0 ) { goto fail; }
@@ -1846,7 +1848,7 @@ int qcow2_expand_zero_clusters(BlockDriverState *bs, ret =expand_zero_clusters_in_l1 (bs, l1_table, s->snapshots[i].l1_size, &visited_l1_entries, l1_entries, - status_cb); + status_cb, cb_opaque);if (ret <0 ) { goto fail; }
block/qcow2.c +5 -4
@@ -2591,7 +2591,7 @@ static int qcow2_load_vmstate(BlockDriverState *bs, uint8_t *buf,* have to be removed. */ static int qcow2_downgrade (BlockDriverState *bs,int target_version, -BlockDriverAmendStatusCB *status_cb) +BlockDriverAmendStatusCB *status_cb,void *cb_opaque) {BDRVQcowState *s = bs->opaque;int current_version = s->qcow_version;
@@ -2640,7 +2640,7 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,/* clearing autoclear features is trivial */ s->autoclear_features =0 ; - ret =qcow2_expand_zero_clusters (bs, status_cb); + ret =qcow2_expand_zero_clusters (bs, status_cb, cb_opaque);if (ret <0 ) {return ret; }
@@ -2655,7 +2655,8 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version, }static int qcow2_amend_options (BlockDriverState *bs,QemuOpts *opts, -BlockDriverAmendStatusCB *status_cb) +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque) {BDRVQcowState *s = bs->opaque;int old_version = s->qcow_version, new_version = old_version;
@@ -2737,7 +2738,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,return ret; } }else { - ret =qcow2_downgrade (bs, new_version, status_cb); + ret =qcow2_downgrade (bs, new_version, status_cb, cb_opaque);if (ret <0 ) {return ret; }
block/qcow2.h +2 -1
@@ -552,7 +552,8 @@ int qcow2_discard_clusters(BlockDriverState *bs, uint64_t offset,int qcow2_zero_clusters (BlockDriverState *bs,uint64_t offset,int nb_sectors);int qcow2_expand_zero_clusters (BlockDriverState *bs, -BlockDriverAmendStatusCB *status_cb); +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque);/* qcow2-snapshot.c functions */ int qcow2_snapshot_create (BlockDriverState *bs,QEMUSnapshotInfo *sn_info);
include/block/block.h +2 -2
@@ -274,9 +274,9 @@ int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix);* block driver; total_work_size may change during the course of the amendment * operation */ typedef void BlockDriverAmendStatusCB (BlockDriverState *bs,int64_t offset, -int64_t total_work_size); +int64_t total_work_size,void *opaque);int bdrv_amend_options (BlockDriverState *bs_new,QemuOpts *opts, -BlockDriverAmendStatusCB *status_cb); +BlockDriverAmendStatusCB *status_cb,void *cb_opaque);/* external snapshots */ bool bdrv_recurse_is_first_non_filter(BlockDriverState *bs,
include/block/block_int.h +2 -1
@@ -236,7 +236,8 @@ struct BlockDriver { BdrvCheckMode fix);int (*bdrv_amend_options)(BlockDriverState *bs,QemuOpts *opts, -BlockDriverAmendStatusCB *status_cb); +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque);void (*bdrv_debug_event)(BlockDriverState *bs,BlkDebugEvent event);
qemu-img.c +3 -2
@@ -2869,7 +2869,8 @@ out: }static void amend_status_cb (BlockDriverState *bs, -int64_t offset,int64_t total_work_size) +int64_t offset,int64_t total_work_size, +void *opaque) {qemu_progress_print (100.f * offset / total_work_size,0 ); }
@@ -2982,7 +2983,7 @@ static int img_amend(int argc, char **argv)/* In case the driver does not call amend_status_cb() */ qemu_progress_print (0.f ,0 ); - ret =bdrv_amend_options (bs, opts, &amend_status_cb); + ret =bdrv_amend_options (bs, opts, &amend_status_cb,NULL );qemu_progress_print (100.f ,0 );if (ret <0 ) {error_report ("Error while amending options: %s" ,strerror (-ret));
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 18/26] block: Add opaque value to the amend CB
Quoted 5 lines · Max Reitz
Add an opaque value which is to be passed to the
bdrv_amend_options()status callback.Signed-off-by Max Reitz <[email protected]>Reviewed-by Eric Blake <[email protected]>
Quoted 9 lines
--- block.c | 4 ++-- block/qcow2-cluster.c | 14 ++++++++------ block/qcow2.c | 9 +++++---- block/qcow2.h | 3 ++- include/block/block.h | 4 ++-- include/block/block_int.h | 3 ++- qemu-img.c | 5 +++-- 7 files changed, 24 insertions(+), 18 deletions(-)
PATCH v4 19/26 qcow2: Use error_report() in qcow2_amend_options()
In reply to Max Reitz--- block/qcow2.c | 14 ++++++-------- tests/qemu-iotests/061.out | 14 +++++++------- 2 files changed, 13 insertions(+), 15 deletions(-)
block/qcow2.c +6 -8
@@ -2685,11 +2685,11 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, }else if (!strcmp (compat,"1.1" )) { new_version =3 ; }else { -fprintf (stderr,"Unknown compatibility level %s.\n" , compat); +error_report ("Unknown compatibility level %s" , compat);return -EINVAL ; } }else if (!strcmp (desc->name,BLOCK_OPT_PREALLOC )) { -fprintf (stderr,"Cannot change preallocation mode.\n" ); +error_report ("Cannot change preallocation mode" );return -ENOTSUP ; }else if (!strcmp (desc->name,BLOCK_OPT_SIZE )) { new_size =qemu_opt_get_size (opts,BLOCK_OPT_SIZE ,0 );
@@ -2701,16 +2701,14 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, encrypt =qemu_opt_get_bool (opts,BLOCK_OPT_ENCRYPT , s->crypt_method);if (encrypt != !!s->crypt_method) { -fprintf (stderr,"Changing the encryption flag is not " -"supported.\n" ); +error_report ("Changing the encryption flag is not supported" );return -ENOTSUP ; } }else if (!strcmp (desc->name,BLOCK_OPT_CLUSTER_SIZE )) { cluster_size =qemu_opt_get_size (opts,BLOCK_OPT_CLUSTER_SIZE , cluster_size);if (cluster_size != s->cluster_size) { -fprintf (stderr,"Changing the cluster size is not " -"supported.\n" ); +error_report ("Changing the cluster size is not supported" );return -ENOTSUP ; } }else if (!strcmp (desc->name,BLOCK_OPT_LAZY_REFCOUNTS )) {
@@ -2756,8 +2754,8 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,if (s->use_lazy_refcounts != lazy_refcounts) {if (lazy_refcounts) {if (s->qcow_version <3 ) { -fprintf (stderr,"Lazy refcounts only supported with compatibility " -"level 1.1 and above (use compat=1.1 or greater)\n" ); +error_report ("Lazy refcounts only supported with compatibility " +"level 1.1 and above (use compat=1.1 or greater)" );return -EINVAL ; } s->compatible_features |=QCOW2_COMPAT_LAZY_REFCOUNTS ;
tests/qemu-iotests/061.out +7 -7
@@ -281,19 +281,19 @@ No errors were found on the image. === Testing invalid configurations === Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 -Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) +qemu-img: Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) qemu-img: Error while amending options: Invalid argument -Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) +qemu-img: Lazy refcounts only supported with compatibility level 1.1 and above (use compat=1.1 or greater) qemu-img: Error while amending options: Invalid argument -Unknown compatibility level 0.42. +qemu-img: Unknown compatibility level 0.42 qemu-img: Error while amending options: Invalid argument qemu-img: Invalid parameter 'foo' qemu-img: Invalid options for file format 'qcow2' -Changing the cluster size is not supported. +qemu-img: Changing the cluster size is not supported qemu-img: Error while amending options: Operation not supported -Changing the encryption flag is not supported. +qemu-img: Changing the encryption flag is not supported qemu-img: Error while amending options: Operation not supported -Cannot change preallocation mode. +qemu-img: Cannot change preallocation mode qemu-img: Error while amending options: Operation not supported === Testing correct handling of unset value ===
@@ -301,7 +301,7 @@ qemu-img: Error while amending options: Operation not supported Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 Should work: Should not work: -Changing the cluster size is not supported. +qemu-img: Changing the cluster size is not supported qemu-img: Error while amending options: Operation not supported === Testing zero expansion on inactive clusters ===
Signature · 1 line
1.9.3
PATCH v4 20/26 qcow2: Use abort() instead of assert(false)
In reply to Max Reitz--- block/qcow2.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
block/qcow2.c +2 -2
@@ -2718,9 +2718,9 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,error_report ("Cannot change refcount entry width" );return -ENOTSUP ; }else { -/* if this assertion fails, this probably means a new option was +/* if this point is reached, this probably means a new option was * added without having it covered here */ -assert (false); +abort (); } desc++;
Signature · 1 line
1.9.3
PATCH v4 21/26 qcow2: Split upgrade/downgrade paths for amend
In reply to Max ReitzIf the image version should be upgraded, that is the first we should do; if it should be downgraded, that is the last we should do. So split the version change block into an upgrade part at the start and a downgrade part at the end.
--- block/qcow2.c | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-)
block/qcow2.c +16 -15
@@ -2726,20 +2726,13 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, desc++; } -if (new_version != old_version) { -if (new_version > old_version) { -/* Upgrade */ - s->qcow_version = new_version; - ret =qcow2_update_header (bs); -if (ret <0 ) { - s->qcow_version = old_version; -return ret; - } - }else { - ret =qcow2_downgrade (bs, new_version, status_cb, cb_opaque); -if (ret <0 ) { -return ret; - } +/* Upgrade first (some features may require compat=1.1) */ +if (new_version > old_version) { + s->qcow_version = new_version; + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->qcow_version = old_version; +return ret; } }
@@ -2753,7 +2746,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,if (s->use_lazy_refcounts != lazy_refcounts) {if (lazy_refcounts) { -if (s->qcow_version <3 ) { +if (new_version <3 ) {error_report ("Lazy refcounts only supported with compatibility " "level 1.1 and above (use compat=1.1 or greater)" );return -EINVAL ;
@@ -2789,6 +2782,14 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, } } +/* Downgrade last (so unsupported features can be removed before) */ +if (new_version < old_version) { + ret =qcow2_downgrade (bs, new_version, status_cb, cb_opaque); +if (ret <0 ) { +return ret; + } + } +return 0 ; }
Signature · 1 line
1.9.3
PATCH v4 22/26 qcow2: Use intermediate helper CB for amend
In reply to Max ReitzIf there is more than one time-consuming operation to be performed for qcow2_amend_options(), we need an intermediate CB which coordinates the progress of the individual operations and passes the result to the original status callback.
--- block/qcow2.c | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-)
block/qcow2.c +79 -1
@@ -2654,6 +2654,75 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version,return 0 ; } +typedef enum Qcow2AmendOperation { +/* This is the value Qcow2AmendHelperCBInfo::last_operation will be +* statically initialized to so that the helper CB can discern the first +* invocation from an operation change */ +QCOW2_NO_OPERATION =0 , + +QCOW2_DOWNGRADING , +}Qcow2AmendOperation ; + +typedef struct Qcow2AmendHelperCBInfo { +/* The code coordinating the amend operations should only modify +* these four fields; the rest will be managed by the CB */ +BlockDriverAmendStatusCB *original_status_cb; +void *original_cb_opaque; + +Qcow2AmendOperation current_operation; + +/* Total number of operations to perform (only set once) */ +int total_operations; + +/* The following fields are managed by the CB */ + +/* Number of operations completed */ +int operations_completed; + +/* Cumulative offset of all completed operations */ +int64_t offset_completed; + +Qcow2AmendOperation last_operation; +int64_t last_work_size; +}Qcow2AmendHelperCBInfo ; + +static void qcow2_amend_helper_cb (BlockDriverState *bs, +int64_t operation_offset, +int64_t operation_work_size,void *opaque) +{ +Qcow2AmendHelperCBInfo *info = opaque; +int64_t current_work_size; +int64_t projected_work_size; + +if (info->current_operation != info->last_operation) { +if (info->last_operation !=QCOW2_NO_OPERATION ) { + info->offset_completed += info->last_work_size; + info->operations_completed++; + } + + info->last_operation = info->current_operation; + } + +assert (info->total_operations >0 ); +assert (info->operations_completed < info->total_operations); + + info->last_work_size = operation_work_size; + + current_work_size = info->offset_completed + operation_work_size; + +/* current_work_size is the total work size for (operations_completed + 1) +* operations (which includes this one), so multiply it by the number of +* operations not covered and divide it by the number of operations +* covered to get a projection for the operations not covered */ + projected_work_size = current_work_size * (info->total_operations - + info->operations_completed -1 ) + / (info->operations_completed +1 ); + + info->original_status_cb (bs, info->offset_completed + operation_offset, + current_work_size + projected_work_size, + info->original_cb_opaque); +} +static int qcow2_amend_options (BlockDriverState *bs,QemuOpts *opts,BlockDriverAmendStatusCB *status_cb,void *cb_opaque)
@@ -2668,6 +2737,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,bool encrypt;int ret;QemuOptDesc *desc = opts->list->desc; +Qcow2AmendHelperCBInfo helper_cb_info;while (desc && desc->name) {if (!qemu_opt_find (opts, desc->name)) {
@@ -2726,6 +2796,12 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, desc++; } + helper_cb_info = (Qcow2AmendHelperCBInfo ){ + .original_status_cb = status_cb, + .original_cb_opaque = cb_opaque, + .total_operations = (new_version < old_version) + }; +/* Upgrade first (some features may require compat=1.1) */ if (new_version > old_version) { s->qcow_version = new_version;
@@ -2784,7 +2860,9 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,/* Downgrade last (so unsupported features can be removed before) */ if (new_version < old_version) { - ret =qcow2_downgrade (bs, new_version, status_cb, cb_opaque); + helper_cb_info.current_operation =QCOW2_DOWNGRADING ; + ret =qcow2_downgrade (bs, new_version, &qcow2_amend_helper_cb, + &helper_cb_info);if (ret <0 ) {return ret; }
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 22/26] qcow2: Use intermediate helper CB for amend
Quoted 10 lines · Max Reitz
If there is more than one time-consuming operation to be performed for
qcow2_amend_options(), we need an intermediate CB which coordinates the progress of the individual operations and passes the result to the original status callback.Signed-off-by Max Reitz <[email protected]>Reviewed-by Eric Blake <[email protected]>--- block/qcow2.c | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 79 insertions(+), 1 deletion(-)
PATCH v4 23/26 qcow2: Add function for refcount order amendment
In reply to Max ReitzAdd a function qcow2_change_refcount_order() which allows changing the refcount order of a qcow2 image.
--- block/qcow2-refcount.c | 452 +++++++++++++++++++++++++++++++++++++++++++++++++ block/qcow2.h | 4 + 2 files changed, 456 insertions(+)
block/qcow2-refcount.c +452 -0
@@ -2491,3 +2491,455 @@ int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,return 0 ; } + +/* A pointer to a function of this type is given to walk_over_reftable(). That +* function will create refblocks and pass them to a RefblockFinishOp once they +* are completed (@refblock). @refblock_empty is set if the refblock is +* completely empty. +* +* Along with the refblock, a corresponding reftable entry is passed, in the +* reftable @reftable (which may be reallocated) at @reftable_index. +* +* @allocated should be set to true if a new cluster has been allocated. +*/ +typedef int (RefblockFinishOp )(BlockDriverState *bs,uint64_t **reftable, +uint64_t reftable_index,uint64_t *reftable_size, +void *refblock,bool refblock_empty, +bool *allocated,Error **errp); + +/** +* This "operation" for walk_over_reftable() allocates the refblock on disk (if +* it is not empty) and inserts its offset into the new reftable. The size of +* this new reftable is increased as required. +*/ +static int alloc_refblock (BlockDriverState *bs,uint64_t **reftable, +uint64_t reftable_index,uint64_t *reftable_size, +void *refblock,bool refblock_empty,bool *allocated, +Error **errp) +{ +BDRVQcowState *s = bs->opaque; +int64_t offset; + +if (!refblock_empty && reftable_index >= *reftable_size) { +uint64_t *new_reftable; +uint64_t new_reftable_size; + + new_reftable_size =ROUND_UP (reftable_index +1 , + s->cluster_size /sizeof (uint64_t )); +if (new_reftable_size >QCOW_MAX_REFTABLE_SIZE /sizeof (uint64_t )) { +error_setg (errp, +"This operation would make the refcount table grow " +"beyond the maximum size supported by QEMU, aborting" ); +return -ENOTSUP ; + } + + new_reftable =g_try_realloc (*reftable, new_reftable_size * +sizeof (uint64_t )); +if (!new_reftable) { +error_setg (errp,"Failed to increase reftable buffer size" ); +return -ENOMEM ; + } + +memset (new_reftable + *reftable_size,0 , + (new_reftable_size - *reftable_size) *sizeof (uint64_t )); + + *reftable = new_reftable; + *reftable_size = new_reftable_size; + } + +if (!refblock_empty && !(*reftable)[reftable_index]) { + offset =qcow2_alloc_clusters (bs, s->cluster_size); +if (offset <0 ) { +error_setg_errno (errp, -offset,"Failed to allocate refblock" ); +return offset; + } + (*reftable)[reftable_index] = offset; + *allocated = true; + } + +return 0 ; +} + +/** +* This "operation" for walk_over_reftable() writes the refblock to disk at the +* offset specified by the new reftable's entry. It does not modify the new +* reftable or change any refcounts. +*/ +static int flush_refblock (BlockDriverState *bs,uint64_t **reftable, +uint64_t reftable_index,uint64_t *reftable_size, +void *refblock,bool refblock_empty,bool *allocated, +Error **errp) +{ +BDRVQcowState *s = bs->opaque; +int64_t offset; +int ret; + +if (reftable_index < *reftable_size && (*reftable)[reftable_index]) { + offset = (*reftable)[reftable_index]; + + ret =qcow2_pre_write_overlap_check (bs,0 , offset, s->cluster_size); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Overlap check failed" ); +return ret; + } + + ret =bdrv_pwrite (bs->file, offset, refblock, s->cluster_size); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to write refblock" ); +return ret; + } + }else { +assert (refblock_empty); + } + +return 0 ; +} + +/** +* This function walks over the existing reftable and every referenced refblock; +* if @new_set_refcount is non-NULL, it is called for every refcount entry to +* create an equal new entry in the passed @new_refblock. Once that +* @new_refblock is completely filled, @operation will be called. +* +* @status_cb and @cb_opaque are used for the amend operation's status callback. +* @index is the index of the walk_over_reftable() calls and @total is the total +* number of walk_over_reftable() calls per amend operation. Both are used for +* calculating the parameters for the status callback. +* +* @allocated is set to true if a new cluster has been allocated. +*/ +static int walk_over_reftable (BlockDriverState *bs,uint64_t **new_reftable, +uint64_t *new_reftable_index, +uint64_t *new_reftable_size, +void *new_refblock,int new_refblock_size, +int new_refcount_bits, +RefblockFinishOp *operation,bool *allocated, +Qcow2SetRefcountFunc *new_set_refcount, +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque,int index,int total, +Error **errp) +{ +BDRVQcowState *s = bs->opaque; +uint64_t reftable_index; +bool new_refblock_empty = true; +int refblock_index; +int new_refblock_index =0 ; +int ret; + +for (reftable_index =0 ; reftable_index < s->refcount_table_size; + reftable_index++) + { +uint64_t refblock_offset = s->refcount_table[reftable_index] + &REFT_OFFSET_MASK ; + +status_cb (bs, (uint64_t )index * s->refcount_table_size + reftable_index, + (uint64_t )total * s->refcount_table_size, cb_opaque); + +if (refblock_offset) { +void *refblock; + +if (offset_into_cluster (s, refblock_offset)) { +qcow2_signal_corruption (bs, true,-1 ,-1 ,"Refblock offset %#" + PRIx64" unaligned (reftable index: %#" + PRIx64")" , refblock_offset, + reftable_index); +error_setg (errp, +"Image is corrupt (unaligned refblock offset)" ); +return -EIO ; + } + + ret =qcow2_cache_get (bs, s->refcount_block_cache, refblock_offset, + &refblock); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to retrieve refblock" ); +return ret; + } + +for (refblock_index =0 ; refblock_index < s->refcount_block_size; + refblock_index++) + { +uint64_t refcount; + +if (new_refblock_index >= new_refblock_size) { +/* new_refblock is now complete */ + ret =operation (bs, new_reftable, *new_reftable_index, + new_reftable_size, new_refblock, + new_refblock_empty, allocated, errp); +if (ret <0 ) { +qcow2_cache_put (bs, s->refcount_block_cache, &refblock); +return ret; + } + + (*new_reftable_index)++; + new_refblock_index =0 ; + new_refblock_empty = true; + } + + refcount = s->get_refcount (refblock, refblock_index); +if (new_refcount_bits <64 && refcount >> new_refcount_bits) { +uint64_t offset; + +qcow2_cache_put (bs, s->refcount_block_cache, &refblock); + + offset = ((reftable_index << s->refcount_block_bits) + + refblock_index) << s->cluster_bits; + +error_setg (errp,"Cannot decrease refcount entry width to " +"%i bits: Cluster at offset %#" PRIx64" has a " +"refcount of %" PRIu64, new_refcount_bits, + offset, refcount); +return -EINVAL ; + } + +if (new_set_refcount) { +new_set_refcount (new_refblock, new_refblock_index++, + refcount); + }else { + new_refblock_index++; + } + new_refblock_empty = new_refblock_empty && refcount ==0 ; + } + + ret =qcow2_cache_put (bs, s->refcount_block_cache, &refblock); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to put refblock back into " +"the cache" ); +return ret; + } + }else { +/* No refblock means every refcount is 0 */ +for (refblock_index =0 ; refblock_index < s->refcount_block_size; + refblock_index++) + { +if (new_refblock_index >= new_refblock_size) { +/* new_refblock is now complete */ + ret =operation (bs, new_reftable, *new_reftable_index, + new_reftable_size, new_refblock, + new_refblock_empty, allocated, errp); +if (ret <0 ) { +return ret; + } + + (*new_reftable_index)++; + new_refblock_index =0 ; + new_refblock_empty = true; + } + +if (new_set_refcount) { +new_set_refcount (new_refblock, new_refblock_index++,0 ); + }else { + new_refblock_index++; + } + } + } + } + +if (new_refblock_index >0 ) { +/* Complete the potentially existing partially filled final refblock */ +if (new_set_refcount) { +for (; new_refblock_index < new_refblock_size; + new_refblock_index++) + { +new_set_refcount (new_refblock, new_refblock_index,0 ); + } + } + + ret =operation (bs, new_reftable, *new_reftable_index, + new_reftable_size, new_refblock, new_refblock_empty, + allocated, errp); +if (ret <0 ) { +return ret; + } + + (*new_reftable_index)++; + } + +status_cb (bs, (uint64_t )(index +1 ) * s->refcount_table_size, + (uint64_t )total * s->refcount_table_size, cb_opaque); + +return 0 ; +} + +int qcow2_change_refcount_order (BlockDriverState *bs,int refcount_order, +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque,Error **errp) +{ +BDRVQcowState *s = bs->opaque; +Qcow2GetRefcountFunc *new_get_refcount; +Qcow2SetRefcountFunc *new_set_refcount; +void *new_refblock =qemu_blockalign (bs->file, s->cluster_size); +uint64_t *new_reftable =NULL , new_reftable_size =0 ; +uint64_t *old_reftable, old_reftable_size, old_reftable_offset; +uint64_t new_reftable_index =0 ; +uint64_t i; +int64_t new_reftable_offset =0 , allocated_reftable_size =0 ; +int new_refblock_size, new_refcount_bits =1 << refcount_order; +int old_refcount_order; +int walk_index =0 ; +int ret; +bool new_allocation; + +assert (s->qcow_version >=3 ); +assert (refcount_order >=0 && refcount_order <=6 ); + +/* see qcow2_open() */ + new_refblock_size =1 << (s->cluster_bits - (refcount_order -3 )); + + new_get_refcount = get_refcount_funcs[refcount_order]; + new_set_refcount = set_refcount_funcs[refcount_order]; + + +do { +int total_walks; + + new_allocation = false; + +/* At least we have to do this walk and the one which writes the +* refblocks; also, at least we have to do this loop here at least +* twice (normally), first to do the allocations, and second to +* determine that everything is correctly allocated, this then makes +* three walks in total */ + total_walks =MAX (walk_index +2 ,3 ); + +/* First, allocate the structures so they are present in the refcount +* structures */ + ret =walk_over_reftable (bs, &new_reftable, &new_reftable_index, + &new_reftable_size,NULL , new_refblock_size, + new_refcount_bits, &alloc_refblock, + &new_allocation,NULL , status_cb, cb_opaque, + walk_index++, total_walks, errp); +if (ret <0 ) { + goto done; + } + + new_reftable_index =0 ; + +if (new_allocation) { +if (new_reftable_offset) { +qcow2_free_clusters (bs, new_reftable_offset, + allocated_reftable_size *sizeof (uint64_t ), +QCOW2_DISCARD_NEVER ); + } + + new_reftable_offset =qcow2_alloc_clusters (bs, new_reftable_size * +sizeof (uint64_t )); +if (new_reftable_offset <0 ) { +error_setg_errno (errp, -new_reftable_offset, +"Failed to allocate the new reftable" ); + ret = new_reftable_offset; + goto done; + } + allocated_reftable_size = new_reftable_size; + } + }while (new_allocation); + +/* Second, write the new refblocks */ + ret =walk_over_reftable (bs, &new_reftable, &new_reftable_index, + &new_reftable_size, new_refblock, + new_refblock_size, new_refcount_bits, + &flush_refblock, &new_allocation, new_set_refcount, + status_cb, cb_opaque, walk_index, walk_index +1 , + errp); +if (ret <0 ) { + goto done; + } +assert (!new_allocation); + + +/* Write the new reftable */ + ret =qcow2_pre_write_overlap_check (bs,0 , new_reftable_offset, + new_reftable_size *sizeof (uint64_t )); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Overlap check failed" ); + goto done; + } + +for (i =0 ; i < new_reftable_size; i++) { +cpu_to_be64s (&new_reftable[i]); + } + + ret =bdrv_pwrite (bs->file, new_reftable_offset, new_reftable, + new_reftable_size *sizeof (uint64_t )); + +for (i =0 ; i < new_reftable_size; i++) { +be64_to_cpus (&new_reftable[i]); + } + +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to write the new reftable" ); + goto done; + } + + +/* Empty the refcount cache */ + ret =qcow2_cache_flush (bs, s->refcount_block_cache); +if (ret <0 ) { +error_setg_errno (errp, -ret,"Failed to flush the refblock cache" ); + goto done; + } + +/* Update the image header to point to the new reftable; this only updates +* the fields which are relevant to qcow2_update_header(); other fields +* such as s->refcount_table or s->refcount_bits stay stale for now +* (because we have to restore everything if qcow2_update_header() fails) */ + old_refcount_order = s->refcount_order; + old_reftable_size = s->refcount_table_size; + old_reftable_offset = s->refcount_table_offset; + + s->refcount_order = refcount_order; + s->refcount_table_size = new_reftable_size; + s->refcount_table_offset = new_reftable_offset; + + ret =qcow2_update_header (bs); +if (ret <0 ) { + s->refcount_order = old_refcount_order; + s->refcount_table_size = old_reftable_size; + s->refcount_table_offset = old_reftable_offset; +error_setg_errno (errp, -ret,"Failed to update the qcow2 header" ); + goto done; + } + +/* Now update the rest of the in-memory information */ + old_reftable = s->refcount_table; + s->refcount_table = new_reftable; + + s->refcount_bits =1 << refcount_order; + s->refcount_max =UINT64_C (1 ) << (s->refcount_bits -1 ); + s->refcount_max += s->refcount_max -1 ; + + s->refcount_block_bits = s->cluster_bits - (refcount_order -3 ); + s->refcount_block_size =1 << s->refcount_block_bits; + + s->get_refcount = new_get_refcount; + s->set_refcount = new_set_refcount; + +/* For cleaning up all old refblocks and the old reftable below the "done" +* label */ + new_reftable = old_reftable; + new_reftable_size = old_reftable_size; + new_reftable_offset = old_reftable_offset; + +done: +if (new_reftable) { +/* On success, new_reftable actually points to the old reftable (and +* new_reftable_size is the old reftable's size); but that is just +* fine */ +for (i =0 ; i < new_reftable_size; i++) { +uint64_t offset = new_reftable[i] &REFT_OFFSET_MASK ; +if (offset) { +qcow2_free_clusters (bs, offset, s->cluster_size, +QCOW2_DISCARD_OTHER ); + } + } +g_free (new_reftable); + +if (new_reftable_offset >0 ) { +qcow2_free_clusters (bs, new_reftable_offset, + new_reftable_size *sizeof (uint64_t ), +QCOW2_DISCARD_OTHER ); + } + } + +qemu_vfree (new_refblock); +return ret; +}
block/qcow2.h +4 -0
@@ -527,6 +527,10 @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,int qcow2_pre_write_overlap_check (BlockDriverState *bs,int ign,int64_t offset,int64_t size); +int qcow2_change_refcount_order (BlockDriverState *bs,int refcount_order, +BlockDriverAmendStatusCB *status_cb, +void *cb_opaque,Error **errp); +/* qcow2-cluster.c functions */ int qcow2_grow_l1_table (BlockDriverState *bs,uint64_t min_size,bool exact_size);
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 23/26] qcow2: Add function for refcount order amendment
Quoted 9 lines · Max Reitz
Add a function
qcow2_change_refcount_order()which allows changing the refcount order of a qcow2 image.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 452 +++++++++++++++++++++++++++++++++++++++++++++++++ block/qcow2.h | 4 + 2 files changed, 456 insertions(+)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 23/26] qcow2: Add function for refcount order amendment
In reply to Max ReitzQuoted 8 lines · Max Reitz
Add a function
qcow2_change_refcount_order()which allows changing the refcount order of a qcow2 image.Signed-off-by Max Reitz <[email protected]>--- block/qcow2-refcount.c | 452 +++++++++++++++++++++++++++++++++++++++++++++++++ block/qcow2.h | 4 + 2 files changed, 456 insertions(+)
PATCH v4 24/26 qcow2: Invoke refcount order amendment function
In reply to Max ReitzMake use of qcow2_change_refcount_order() to support changing the refcount order with qemu-img amend.
--- block/qcow2.c | 44 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-)
block/qcow2.c +35 -9
@@ -2606,13 +2606,7 @@ static int qcow2_downgrade(BlockDriverState *bs, int target_version, }if (s->refcount_order !=4 ) { -/* we would have to convert the image to a refcount_order == 4 image -* here; however, since qemu (at the time of writing this) does not -* support anything different than 4 anyway, there is no point in doing -* so right now; however, we should error out (if qemu supports this in -* the future and this code has not been adapted) */ -error_report ("qcow2_downgrade: Image refcount orders other than 4 are " -"currently not supported." ); +error_report ("compat=0.10 requires refcount_bits=16" );return -ENOTSUP ; }
@@ -2660,6 +2654,7 @@ typedef enum Qcow2AmendOperation {* invocation from an operation change */ QCOW2_NO_OPERATION =0 , +QCOW2_CHANGING_REFCOUNT_ORDER ,QCOW2_DOWNGRADING , } Qcow2AmendOperation;
@@ -2735,6 +2730,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,const char *compat =NULL ;uint64_t cluster_size = s->cluster_size;bool encrypt; +int refcount_bits = s->refcount_bits;int ret;QemuOptDesc *desc = opts->list->desc;Qcow2AmendHelperCBInfo helper_cb_info;
@@ -2785,8 +2781,16 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, lazy_refcounts =qemu_opt_get_bool (opts,BLOCK_OPT_LAZY_REFCOUNTS , lazy_refcounts); }else if (!strcmp (desc->name,BLOCK_OPT_REFCOUNT_BITS )) { -error_report ("Cannot change refcount entry width" ); -return -ENOTSUP ; + refcount_bits =qemu_opt_get_number (opts,BLOCK_OPT_REFCOUNT_BITS , + refcount_bits); + +if (refcount_bits <=0 || refcount_bits >64 || + !is_power_of_2 (refcount_bits)) + { +error_report ("Refcount width must be a power of two and may " +"not exceed 64 bits" ); +return -EINVAL ; + } }else {/* if this point is reached, this probably means a new option was * added without having it covered here */
@@ -2800,6 +2804,7 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, .original_status_cb = status_cb, .original_cb_opaque = cb_opaque, .total_operations = (new_version < old_version) + + (s->refcount_bits != refcount_bits) };/* Upgrade first (some features may require compat=1.1) */
@@ -2812,6 +2817,27 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, } } +if (s->refcount_bits != refcount_bits) { +int refcount_order =ffs (refcount_bits) -1 ; +Error *local_error =NULL ; + +if (new_version <3 && refcount_bits !=16 ) { +error_report ("Different refcount widths than 16 bits require " +"compatibility level 1.1 or above (use compat=1.1 or " +"greater)" ); +return -EINVAL ; + } + + helper_cb_info.current_operation =QCOW2_CHANGING_REFCOUNT_ORDER ; + ret =qcow2_change_refcount_order (bs, refcount_order, + &qcow2_amend_helper_cb, + &helper_cb_info, &local_error); +if (ret <0 ) { +qerror_report_err (local_error); +return ret; + } + } +if (backing_file || backing_format) { ret =qcow2_change_backing_file (bs, backing_file ?: bs->backing_file, backing_format ?: bs->backing_format);
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 24/26] qcow2: Invoke refcount order amendment function
Quoted 8 lines · Max Reitz
Make use of
qcow2_change_refcount_order()to support changing the refcount order with qemu-img amend.Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 44 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-)
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 24/26] qcow2: Invoke refcount order amendment function
In reply to Max ReitzQuoted 7 lines · Max Reitz
Make use of
qcow2_change_refcount_order()to support changing the refcount order with qemu-img amend.Signed-off-by Max Reitz <[email protected]>--- block/qcow2.c | 44 +++++++++++++++++++++++++++++++++++--------- 1 file changed, 35 insertions(+), 9 deletions(-)
PATCH v4 25/26 qcow2: Point to amend function in check
In reply to Max ReitzIf a reference count is not representable with the current refcount order, the image check should point to qemu-img amend for increasing the refcount order. However, qemu-img amend needs write access to the image which cannot be provided if the image is marked corrupt; and the image check will not mark the image consistent unless everything actually is consistent.
Therefore, if an image is marked corrupt and the image check encounters a reference count overflow, it cannot be fixed by using qemu-img amend to increase the refcount order. Instead, one has to use qemu-img convert to create a completely new copy of the image in this case.
Alternatively, we may want to give the user a way of manually removing the corrupt flag, maybe through qemu-img amend, but this is not part of this patch.
--- block/qcow2-refcount.c | 3 +++ 1 file changed, 3 insertions(+)
block/qcow2-refcount.c +3 -0
@@ -1370,6 +1370,9 @@ static int inc_refcounts(BlockDriverState *bs,if (refcount == s->refcount_max) {fprintf (stderr,"ERROR: overflow cluster offset=0x%" PRIx64"\n" , cluster_offset); +fprintf (stderr,"Use qemu-img amend to increase the refcount entry " +"width or qemu-img convert to create a clean copy if the " +"image cannot be opened for writing\n" ); res->corruptions++;continue ; }
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 25/26] qcow2: Point to amend function in check
Quoted 16 lines · Max Reitz
If a reference count is not representable with the current refcount order, the image check should point to qemu-img amend for increasing the refcount order. However, qemu-img amend needs write access to the image which cannot be provided if the image is marked corrupt; and the image check will not mark the image consistent unless everything actually is consistent.
Therefore, if an image is marked corrupt and the image check encounters a reference count overflow, it cannot be fixed by using qemu-img amend to increase the refcount order. Instead, one has to use qemu-img convert to create a completely new copy of the image in this case.
Alternatively, we may want to give the user a way of manually removing the corrupt flag, maybe through qemu-img amend, but this is not part of this patch.
Quoted 5 lines
Signed-off-by Max Reitz <[email protected]>Reviewed-by Eric Blake <[email protected]>--- block/qcow2-refcount.c | 3 +++ 1 file changed, 3 insertions(+)
PATCH v4 26/26 iotests: Add test for different refcount widths
In reply to Max ReitzAdd a test for conversion between different refcount widths and errors specific to certain widths (i.e. snapshots with refcount_bits=1).
--- tests/qemu-iotests/112 | 296 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/112.out | 155 ++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 452 insertions(+) create mode 100755 tests/qemu-iotests/112 create mode 100644 tests/qemu-iotests/112.out
tests/qemu-iotests/112 new file +296 -0
@@ -0,0 +1,296 @@ +#!/bin/bash +# +# Test cases for different refcount_bits values +# +# Copyright (C) 2014 Red Hat, Inc. +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. +# + +# creator [email protected] + +seq="$(basename $0)" +echo "QA output created by $seq" + +here="$PWD" +tmp=/tmp/$$ +status=1 # failure is the default! + +_cleanup() +{ + _cleanup_test_img +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# get standard environment, filters and checks +. ./common.rc +. ./common.filter + +# This tests qcow2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os Linux +# This test will set refcount_bits on its own which would conflict with the +# manual setting; compat will be overridden as well +_unsupported_imgopts refcount_bits 'compat=0.10' + +function print_refcount_bits() +{ + $QEMU_IMG info "$TEST_IMG" | sed -n '/refcount bits:/ s/^ *//p' +} + +echo +echo '=== refcount_bits limits ===' +echo + +# Must be positive (non-zero) +IMGOPTS="$IMGOPTS,refcount_bits=0" _make_test_img 64M +# Must be positive (non-negative) +IMGOPTS="$IMGOPTS,refcount_bits=-1" _make_test_img 64M +# May not exceed 64 +IMGOPTS="$IMGOPTS,refcount_bits=128" _make_test_img 64M +# Must be a power of two +IMGOPTS="$IMGOPTS,refcount_bits=42" _make_test_img 64M + +# 1 is the minimum +IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M +print_refcount_bits + +# 64 is the maximum +IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M +print_refcount_bits + +# 16 is the default +_make_test_img 64M +print_refcount_bits + +echo +echo '=== refcount_bits and compat=0.10 ===' +echo + +# Should work +IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=16" _make_test_img 64M +print_refcount_bits + +# Should not work +IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=1" _make_test_img 64M +IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=64" _make_test_img 64M + + +echo +echo '=== Snapshot limit on refcount_bits=1 ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M +print_refcount_bits + +$QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io + +# Should fail for now; in the future, this might be supported by automatically +# copying all clusters with overflowing refcount +$QEMU_IMG snapshot -c foo "$TEST_IMG" + +# The new L1 table could/should be leaked +_check_test_img + +echo +echo '=== Snapshot limit on refcount_bits=2 ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=2" _make_test_img 64M +print_refcount_bits + +$QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io + +# Should succeed +$QEMU_IMG snapshot -c foo "$TEST_IMG" +$QEMU_IMG snapshot -c bar "$TEST_IMG" +# Should fail (4th reference) +$QEMU_IMG snapshot -c baz "$TEST_IMG" + +# The new L1 table could/should be leaked +_check_test_img + +echo +echo '=== Compressed clusters with refcount_bits=1 ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M +print_refcount_bits + +# Both should fit into a single host cluster; instead of failing to increase the +# refcount of that cluster, qemu should just allocate a new cluster and make +# this operation succeed +$QEMU_IO -c 'write -P 0 -c 0 64k' \ + -c 'write -P 1 -c 64k 64k' \ + "$TEST_IMG" | _filter_qemu_io + +_check_test_img + +echo +echo '=== MSb set in 64 bit refcount ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M +print_refcount_bits + +$QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io + +# Set the MSb in the refblock entry of the data cluster +poke_file "$TEST_IMG" $((0x20028)) "\x80\x00\x00\x00\x00\x00\x00\x00" + +# Clear OFLAG_COPIED in the L2 entry of the data cluster +poke_file "$TEST_IMG" $((0x40000)) "\x00\x00\x00\x00\x00\x05\x00\x00" + +# Try to write to that cluster (should work, even though the MSb is set) +$QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io + +echo +echo '=== Snapshot on maximum 64 bit refcount value ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=64" _make_test_img 64M +print_refcount_bits + +$QEMU_IO -c 'write 0 512' "$TEST_IMG" | _filter_qemu_io + +# Set the refblock entry to the maximum value possible +poke_file "$TEST_IMG" $((0x20028)) "\xff\xff\xff\xff\xff\xff\xff\xff" + +# Clear OFLAG_COPIED in the L2 entry of the data cluster +poke_file "$TEST_IMG" $((0x40000)) "\x00\x00\x00\x00\x00\x05\x00\x00" + +# Try a snapshot (should correctly identify the overflow; may work in the future +# by falling back to COW) +$QEMU_IMG snapshot -c foo "$TEST_IMG" + +# The new L1 table could/should be leaked; and obviously the data cluster is +# leaked (refcount=UINT64_MAX reference=1) +_check_test_img + +echo +echo '=== Amend from refcount_bits=16 to refcount_bits=1 ===' +echo + +_make_test_img 64M +print_refcount_bits + +$QEMU_IO -c 'write 16M 32M' "$TEST_IMG" | _filter_qemu_io +$QEMU_IMG amend -o refcount_bits=1 "$TEST_IMG" +_check_test_img +print_refcount_bits + +echo +echo '=== Amend from refcount_bits=1 to refcount_bits=64 ===' +echo + +$QEMU_IMG amend -o refcount_bits=64 "$TEST_IMG" +_check_test_img +print_refcount_bits + +echo +echo '=== Amend to compat=0.10 ===' +echo + +# Should not work because refcount_bits needs to be 16 for compat=0.10 +$QEMU_IMG amend -o compat=0.10 "$TEST_IMG" +print_refcount_bits +# Should work +$QEMU_IMG amend -o compat=0.10,refcount_bits=16 "$TEST_IMG" +_check_test_img +print_refcount_bits + +# Get back to compat=1.1 and refcount_bits=16 +$QEMU_IMG amend -o compat=1.1 "$TEST_IMG" +print_refcount_bits +# Should not work +$QEMU_IMG amend -o refcount_bits=32,compat=0.10 "$TEST_IMG" +print_refcount_bits + +echo +echo '=== Amend with snapshot ===' +echo + +$QEMU_IMG snapshot -c foo "$TEST_IMG" +# Just to have different refcounts across the image +$QEMU_IO -c 'write 0 16M' "$TEST_IMG" | _filter_qemu_io + +# Should not work (may work in the future by first decreasing all refcounts so +# they fit into the target range by copying them) +$QEMU_IMG amend -o refcount_bits=1 "$TEST_IMG" +_check_test_img +print_refcount_bits + +# Should work +$QEMU_IMG amend -o refcount_bits=2 "$TEST_IMG" +_check_test_img +print_refcount_bits + +echo +echo '=== Testing too many references for check ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=1" _make_test_img 64M +print_refcount_bits + +# This cluster should be created at 0x50000 +$QEMU_IO -c 'write 0 64k' "$TEST_IMG" | _filter_qemu_io +# Now make the second L2 entry (the L2 table should be at 0x40000) point to that +# cluster, so we have two references +poke_file "$TEST_IMG" $((0x40008)) "\x80\x00\x00\x00\x00\x05\x00\x00" + +# This should say "please use amend" +_check_test_img -r all + +# So we do that +$QEMU_IMG amend -o refcount_bits=2 "$TEST_IMG" +print_refcount_bits + +# And try again +_check_test_img -r all + +echo +echo '=== Multiple walks necessary during amend ===' +echo + +IMGOPTS="$IMGOPTS,refcount_bits=1,cluster_size=512" _make_test_img 64k + +# Cluster 0 is the image header, clusters 1 to 4 are used by the L1 table, a +# single L2 table, the reftable and a single refblock. This creates 58 data +# clusters (actually, the L2 table is created here, too), so in total there are +# then 63 used clusters in the image. With a refcount width of 64, one refblock +# describes 64 clusters (512 bytes / 64 bits/entry = 64 entries), so this will +# make the first refblock in the amended image have exactly one free entry. +$QEMU_IO -c "write 0 $((58 * 512))" "$TEST_IMG" | _filter_qemu_io + +# Now change the refcount width; since the first new refblock will have exactly +# one free entry, that entry will be used to store its own reference. No other +# refblocks are needed, so then the new reftable will be allocated; since the +# first new refblock is completely filled up, this will require a new refblock +# which is why the refcount width changing function will need to run through +# everything one more time until the allocations are stable. +# Having more walks than usual should be visible as regressing progress (from +# 66.67 % (2/3 walks) to 50.00 % (2/4 walks)). +$QEMU_IMG amend -o refcount_bits=64 -p "$TEST_IMG" | tr '\r' '\n' \ + | grep -A 1 '66.67' +print_refcount_bits + +_check_test_img + + +# success, all done +echo '*** done' +rm -f $seq.full +status=0
tests/qemu-iotests/112.out new file +155 -0
155 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -113,4 +113,5 @@ 108 rw auto quick 109 rw auto 111 rw auto quick +112 rw auto 114 rw auto quick
Signature · 1 line
1.9.3
Re: [Qemu-devel] [PATCH v4 26/26] iotests: Add test for different refcount widths
Quoted 13 lines · Max Reitz
Add a test for conversion between different refcount widths and errors specific to certain widths (i.e. snapshots with refcount_bits=1).
Signed-off-by Max Reitz <[email protected]>--- tests/qemu-iotests/112 | 296 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/112.out | 155 ++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 452 insertions(+) create mode 100755 tests/qemu-iotests/112 create mode 100644 tests/qemu-iotests/112.out
tests/qemu-iotests/112 line 47
Quoted 3 lines
tests/qemu-iotests/112 new file +3
-0+# This test will set refcount_bits on its own which would conflict with the +# manual setting; compat will be overridden as well +_unsupported_imgopts refcount_bits 'compat=0.10'
Should this be 'compat' rather than 'compat=0.10' as the filter? The reason I ask is that if I can pass an explicit 'compat=1.1'...
tests/qemu-iotests/112 line 84
Quoted 6 lines
tests/qemu-iotests/112 new file +6
-0+echo +echo '=== refcount_bits and compat=0.10 ===' +echo + +# Should work +IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=16" _make_test_img 64M
...is it going to conflict with this explicit compat=0.10?
I didn't actually try this setup, though, so if the test passes with an explicit imgopt request for compat=1.1, then I'm fine with it as-is.
Side note:
Now that we can produce MUCH smaller images where the reftable can easily require enough contiguous clusters to require the creation of at least one refblock that cannot be self-referential, it would probably be good to modify an existing test and/or add a new test to prove that we don't trip up when trying to create and read such an image. But I'm fine with doing that as a later patch, so don't hold up this series for it (unless you want to add a 27/26). See my mail here where I calculate the minimum size required to guarantee that situation at just under 256 megabytes with 512 byte clusters:
https://lists.gnu.org/archive/html/qemu-devel/2014-11/msg03455.html
But now that I looked that up, I just realized that that email did not calculate what it would take to get an L1 table to likewise occupy enough contiguous clusters to guarantee a refblock where every entry is pointing to clusters of the L1 table and therefore cannot be self-referential. But as both L1 and L2 table entries are 64 bits, it looks like the math is the same as for 64-bit width refcounts, so it happens to be the same magic size of just under 256 megabytes - and in this case, the magic value is hit even without relying on this series' addition of 64-bit refcount widths.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 26/26] iotests: Add test for different refcount widths
Quoted 27 lines · Eric Blake
Quoted 12 lines · Max Reitz
Add a test for conversion between different refcount widths and errors specific to certain widths (i.e. snapshots with refcount_bits=1).
Signed-off-by Max Reitz <[email protected]>--- tests/qemu-iotests/112 | 296 +++++++++++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/112.out | 155 ++++++++++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 452 insertions(+)create mode 100755 tests/qemu-iotests/112
create mode 100644 tests/qemu-iotests/112.outtests/qemu-iotests/112 line 47
Quoted 3 lines
tests/qemu-iotests/112 new file +3
-0+# This test will set refcount_bits on its own which would conflict with the +# manual setting; compat will be overridden as well +_unsupported_imgopts refcount_bits 'compat=0.10'Should this be 'compat' rather than 'compat=0.10' as the filter? The reason I ask is that if I can pass an explicit 'compat=1.1'...
tests/qemu-iotests/112 line 84
Quoted 6 lines
tests/qemu-iotests/112 new file +6
-0+echo +echo '=== refcount_bits and compat=0.10 ===' +echo + +# Should work +IMGOPTS="$IMGOPTS,compat=0.10,refcount_bits=16" _make_test_img 64M...is it going to conflict with this explicit compat=0.10?
Quoted 2 lines
I didn't actually try this setup, though, so if the test passes with an explicit imgopt request for compat=1.1, then I'm fine with it as-is.
Yes, it works; the last option given counts (see iotest 082).
Quoted 1 line
Reviewed-by Eric Blake <[email protected]>
Thank you!
Quoted 7 lines
Side note:
Now that we can produce MUCH smaller images where the reftable can easily require enough contiguous clusters to require the creation of at least one refblock that cannot be self-referential, it would probably be good to modify an existing test and/or add a new test to prove that we don't trip up when trying to create and read such an image.
Reading is rarely a problem because we don't even need to read the refcounts then. However, creation may indeed be (or better: it should not be), so I will see to add a test later on.
Max
Quoted 17 lines
But I'm
fine with doing that as a later patch, so don't hold up this series for it (unless you want to add a 27/26). See my mail here where I calculate the minimum size required to guarantee that situation at just under 256 megabytes with 512 byte clusters:
https://lists.gnu.org/archive/html/qemu-devel/2014-11/msg03455.htmlBut now that I looked that up, I just realized that that email did not calculate what it would take to get an L1 table to likewise occupy enough contiguous clusters to guarantee a refblock where every entry is pointing to clusters of the L1 table and therefore cannot be self-referential. But as both L1 and L2 table entries are 64 bits, it looks like the math is the same as for 64-bit width refcounts, so it happens to be the same magic size of just under 256 megabytes - and in this case, the magic value is hit even without relying on this series' addition of 64-bit refcount widths.
Re: [Qemu-devel] [PATCH v4 26/26] iotests: Add test for different refcount widths
Quoted 11 lines · Max Reitz
Quoted 7 lines
Side note:
Now that we can produce MUCH smaller images where the reftable can easily require enough contiguous clusters to require the creation of at least one refblock that cannot be self-referential, it would probably be good to modify an existing test and/or add a new test to prove that we don't trip up when trying to create and read such an image.
Reading is rarely a problem because we don't even need to read the refcounts then. However, creation may indeed be (or better: it should not be), so I will see to add a test later on.
Such a test is not necessarily quick. On my machine with a spinning rust disk,
qemu-img create -f qcow2 -ocluster_size=512 image 256M qemu-io -c 'write -P 0x22 0 256M' image
took several minutes (I'm not sure if that is all because of 512-byte operations needing read-modify-write operations on the underlying filesystem, or I ended up with a safer-but-slower cache mode that was flushing a lot more often than necessary). And running 'qemu-img map image' in another terminal during that time to watch progress sometimes dumped core due to assertion failures about unexpected nb_clusters (but that's to be expected - reading an image in one process while another is actively modifying it is prone to cause grief to the reader).
But the resulting image was successfully completed, and appears to be valid. Although I didn't find an easy way to determine where the L1 table actually ended up, and whether it really did cause the creation of at least one refblock that was not self-referential.
Signature · 2 lines
Eric Blake eblake redhat com +1-919-301-3266 Libvirt virtualization library http://libvirt.org
Re: [Qemu-devel] [PATCH v4 26/26] iotests: Add test for different refcount widths
Quoted 15 lines · Eric Blake
Quoted 10 lines · Max Reitz
Quoted 7 lines
Side note:
Now that we can produce MUCH smaller images where the reftable can easily require enough contiguous clusters to require the creation of at least one refblock that cannot be self-referential, it would probably be good to modify an existing test and/or add a new test to prove that we don't trip up when trying to create and read such an image.
Reading is rarely a problem because we don't even need to read the refcounts then. However, creation may indeed be (or better: it should not be), so I will see to add a test later on.
Such a test is not necessarily quick. On my machine with a spinning rust disk,
Quoted 7 lines
qemu-img create -f qcow2 -ocluster_size=512 image 256M qemu-io -c 'write -P
0x220 256M' imagetook several minutes (I'm not sure if that is all because of 512-byte operations needing read-modify-write operations on the underlying filesystem, or I ended up with a safer-but-slower cache mode that was flushing a lot more often than necessary).
Maybe preallocation=metadata is enough. Also, preallocation=metadata makes later write operations much faster.
But actually I didn't even plan to write all the data. The L1 table should cover the whole image even without any data being there; and for adjusting the reftable size, it should be enough to write some data at some large offset.
Max
Quoted 11 lines
And running 'qemu-img map
image' in another terminal during that time to watch progress sometimes dumped core due to assertion failures about unexpectednb_clusters(but that's to be expected - reading an image in one process while another is actively modifying it is prone to cause grief to the reader).But the resulting image was successfully completed, and appears to be valid. Although I didn't find an easy way to determine where the L1 table actually ended up, and whether it really did cause the creation of at least one refblock that was not self-referential.