qcow2: Implement zstd cluster compression methodi
PATCH v20 2/4 qcow2: rework the cluster compression routine
In reply to Denis PlotnikovThe patch enables processing the image compression type defined for the image and chooses an appropriate method for image clusters (de)compression.
--- block/qcow2-threads.c | 71 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 60 insertions(+), 11 deletions(-)
block/qcow2-threads.c +60 -11
@@ -74,7 +74,9 @@ typedef struct Qcow2CompressData { } Qcow2CompressData;/* -* qcow2_compress() +* qcow2_zlib_compress() +* +* Compress @src_size bytes of data using zlib compression method * * @dest - destination buffer, @dest_size bytes * @src - source buffer, @src_size bytes
@@ -83,8 +85,8 @@ typedef struct Qcow2CompressData {* -ENOMEM destination buffer is not enough to store compressed data * -EIO on any other error */ -static ssize_t qcow2_compress (void *dest,size_t dest_size, -const void *src,size_t src_size) +static ssize_t qcow2_zlib_compress (void *dest,size_t dest_size, +const void *src,size_t src_size) {ssize_t ret;z_stream strm;
@@ -119,10 +121,10 @@ static ssize_t qcow2_compress(void *dest, size_t dest_size, }/* -* qcow2_decompress() +* qcow2_zlib_decompress() * * Decompress some data (not more than @src_size bytes) to produce exactly -* @dest_size bytes. +* @dest_size bytes using zlib compression method * * @dest - destination buffer, @dest_size bytes * @src - source buffer, @src_size bytes
@@ -130,8 +132,8 @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,* Returns: 0 on success * -EIO on fail */ -static ssize_t qcow2_decompress (void *dest,size_t dest_size, -const void *src,size_t src_size) +static ssize_t qcow2_zlib_decompress (void *dest,size_t dest_size, +const void *src,size_t src_size) {int ret;z_stream strm;
@@ -191,20 +193,67 @@ qcow2_co_do_compress(BlockDriverState *bs, void *dest, size_t dest_size,return arg.ret; } +/* +* qcow2_co_compress() +* +* Compress @src_size bytes of data using the compression +* method defined by the image compression type +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* +* Returns: compressed size on success +* a negative error code on failure +*/ ssize_t coroutine_fnqcow2_co_compress (BlockDriverState *bs,void *dest,size_t dest_size,const void *src,size_t src_size) { -return qcow2_co_do_compress (bs, dest, dest_size, src, src_size, - qcow2_compress); +BDRVQcow2State *s = bs->opaque; +Qcow2CompressFunc fn; + +switch (s->compression_type) { +case QCOW2_COMPRESSION_TYPE_ZLIB : + fn = qcow2_zlib_compress; +break ; + +default : +abort (); + } + +return qcow2_co_do_compress (bs, dest, dest_size, src, src_size, fn); } +/* +* qcow2_co_decompress() +* +* Decompress some data (not more than @src_size bytes) to produce exactly +* @dest_size bytes using the compression method defined by the image +* compression type +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* +* Returns: 0 on success +* a negative error code on failure +*/ ssize_t coroutine_fnqcow2_co_decompress (BlockDriverState *bs,void *dest,size_t dest_size,const void *src,size_t src_size) { -return qcow2_co_do_compress (bs, dest, dest_size, src, src_size, - qcow2_decompress); +BDRVQcow2State *s = bs->opaque; +Qcow2CompressFunc fn; + +switch (s->compression_type) { +case QCOW2_COMPRESSION_TYPE_ZLIB : + fn = qcow2_zlib_decompress; +break ; + +default : +abort (); + } + +return qcow2_co_do_compress (bs, dest, dest_size, src, src_size, fn); }
Signature · 1 line
2.17.0
v20 cover qcow2: Implement zstd cluster compression methodi
v20:
04: fix a number of flaws [Vladimir]
* don't use $RAND_FILE passing to qemu-io,
so check $TEST_DIR is redundant
* re-arrage $RAND_FILE writing
* fix a typo
v19:
04: fix a number of flaws [Eric]
* remove rudundant test case descriptions
* fix stdout redirect
* don't use (())
* use peek_file_be instead of od
* check $TEST_DIR for spaces and other before using
* use $RAND_FILE safer
v18:
* 04: add quotes to all file name variables [Vladimir]
* 04: add Vladimir's comment according to "qemu-io write -s" option issue.
v17:
* 03: remove incorrect comment in zstd decompress [Vladimir]
* 03: remove "paraniod" and rewrite the comment on decompress [Vladimir]
* 03: fix dead assignment [Vladimir]
* 04: add and remove quotes [Vladimir]
* 04: replace long offset form with the short one [Vladimir]
v16:
* 03: ssize_t for ret, size_t for zstd_ret [Vladimir]
* 04: small fixes according to the comments [Vladimir]
v15:
* 01: aiming qemu 5.1 [Eric]
* 03: change zstd_res definition place [Vladimir]
* 04: add two new test cases [Eric]
1. test adjacent cluster compression with zstd
2. test incompressible cluster processing
* 03, 04: many rewording and gramma fixing [Eric]
v14:
* fix bug on compression - looping until compress == 0 [Me]
* apply reworked Vladimir's suggestions:
1. not mixing ssize_t with size_t
2. safe check for ENOMEM in compression part - avoid overflow
3. tolerate sanity check allow zstd to make progress only on one of the buffers
v13:
* 03: add progress sanity check to decompression loop [Vladimir] 03: add successful decompression check [Me]
v12:
* 03: again, rework compression and decompression loops
to make them more correct [Vladimir]
03: move assert in compression to more appropriate place
[Vladimir]
v11:
* 03: the loops don't need "do{}while" form anymore and
the they were buggy (missed "do" in the beginning)
replace them with usual "while(){}" loops [Vladimir]
v10:
* 03: fix zstd (de)compressed loops for multi-frame
cases [Vladimir]
v9:
* 01: fix error checking and reporting in qcow2_amend compression type part [Vladimir]
* 03: replace asserts with -EIO in qcow2_zstd_decompression [Vladimir, Alberto]
* 03: reword/amend/add comments, fix typos [Vladimir]
v8:
* 03: switch zstd API from simple to stream [Eric] No need to state a special cluster layout for zstd compressed clusters.
v7:
* use qapi_enum_parse instead of the open-coding [Eric]
* fix wording, typos and spelling [Eric]
v6:
* "block/qcow2-threads: fix qcow2_decompress" is removed from the series since it has been accepted by Max already
* add compile time checking for Qcow2Header to be a multiple of 8 [Max, Alberto]
* report error on qcow2 amending when the compression type is actually chnged [Max]
* remove the extra space and the extra new line [Max]
* re-arrange acks and signed-off-s [Vladimir]
v5:
* replace -ENOTSUP with abort in qcow2_co_decompress [Vladimir]
* set cluster size for all test cases in the beginning of the 287 test
v4:
* the series is rebased on top of 01 "block/qcow2-threads: fix qcow2_decompress"
* 01 is just a no-change resend to avoid extra dependencies. Still, it may be merged in separate
v3:
* remove redundant max compression type value check [Vladimir, Eric] (the switch below checks everything)
* prevent compression type changing on "qemu-img amend" [Vladimir]
* remove zstd config setting, since it has been added already by "migration" patches [Vladimir]
* change the compression type error message [Vladimir]
* fix alignment and 80-chars exceeding [Vladimir]
v2:
* rework compression type setting [Vladimir]
* squash iotest changes to the compression type introduction patch [Vladimir, Eric]
* fix zstd availability checking in zstd iotest [Vladimir]
* remove unnecessry casting [Eric]
* remove rudundant checks [Eric]
* fix compressed cluster layout in qcow2 spec [Vladimir]
* fix wording [Eric, Vladimir]
* fix compression type filtering in iotests [Eric]
v1:
the initial series
Denis Plotnikov (4):
qcow2: introduce compression type feature
qcow2: rework the cluster compression routine
qcow2: add zstd cluster compression
iotests: 287: add qcow2 compression type test
docs/interop/qcow2.txt | 1 + configure | 2 +- qapi/block-core.json | 23 +++- block/qcow2.h | 20 ++- include/block/block_int.h | 1 + block/qcow2-threads.c | 228 +++++++++++++++++++++++++++++-- block/qcow2.c | 120 ++++++++++++++++ tests/qemu-iotests/031.out | 14 +- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 +++++++------- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061.out | 34 +++-- tests/qemu-iotests/065 | 28 ++-- tests/qemu-iotests/080 | 2 +- tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/242.out | 5 + tests/qemu-iotests/255.out | 8 +- tests/qemu-iotests/287 | 146 ++++++++++++++++++++ tests/qemu-iotests/287.out | 67 +++++++++ tests/qemu-iotests/common.filter | 3 +- tests/qemu-iotests/group | 1 + 22 files changed, 708 insertions(+), 108 deletions(-) create mode 100755 tests/qemu-iotests/287 create mode 100644 tests/qemu-iotests/287.out
Signature · 1 line
2.17.0
PATCH v20 4/4 iotests: 287: add qcow2 compression type test
The test checks fulfilling qcow2 requirements for the compression type feature and zstd compression type operability.
--- tests/qemu-iotests/287 | 146 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/287.out | 67 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 214 insertions(+) create mode 100755 tests/qemu-iotests/287 create mode 100644 tests/qemu-iotests/287.out
tests/qemu-iotests/287 new file +146 -0
@@ -0,0 +1,146 @@ +#!/usr/bin/env bash +# +# Test case for an image using zstd compression +# +# Copyright (c) 2020 Virtuozzo International GmbH +# +# 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" + +status=1 # failure is the default! + +# standard environment +. ./common.rc +. ./common.filter + +# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os Linux + +COMPR_IMG="$TEST_IMG.compressed" +RAND_FILE="$TEST_DIR/rand_data" + +_cleanup() +{ + _cleanup_test_img + rm -f "$COMPR_IMG" + rm -f "$RAND_FILE" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# for all the cases +CLUSTER_SIZE=65536 + +# Check if we can run this test. +if IMGOPTS='compression_type=zstd' _make_test_img 64M | + grep "Invalid parameter 'zstd'"; then + _notrun "ZSTD is disabled" +fi + +echo +echo "=== Testing compression type incompatible bit setting for zlib ===" +echo +IMGOPTS='compression_type=zlib' _make_test_img 64M +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + +echo +echo "=== Testing compression type incompatible bit setting for zstd ===" +echo +IMGOPTS='compression_type=zstd' _make_test_img 64M +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + +echo +echo "=== Testing zlib with incompatible bit set ===" +echo +IMGOPTS='compression_type=zlib' _make_test_img 64M +$PYTHON qcow2.py "$TEST_IMG" set-feature-bit incompatible 3 +# to make sure the bit was actually set +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + +if $QEMU_IMG info "$TEST_IMG" >/dev/null 2>&1 ; then + echo "Error: The image opened successfully. The image must not be opened." +fi + +echo +echo "=== Testing zstd with incompatible bit unset ===" +echo +IMGOPTS='compression_type=zstd' _make_test_img 64M +$PYTHON qcow2.py "$TEST_IMG" set-header incompatible_features 0 +# to make sure the bit was actually unset +$PYTHON qcow2.py "$TEST_IMG" dump-header | grep incompatible_features + +if $QEMU_IMG info "$TEST_IMG" >/dev/null 2>&1 ; then + echo "Error: The image opened successfully. The image must not be opened." +fi + +echo +echo "=== Testing compression type values ===" +echo +# zlib=0 +IMGOPTS='compression_type=zlib' _make_test_img 64M +peek_file_be "$TEST_IMG" 104 1 +echo + +# zstd=1 +IMGOPTS='compression_type=zstd' _make_test_img 64M +peek_file_be "$TEST_IMG" 104 1 +echo + +echo +echo "=== Testing simple reading and writing with zstd ===" +echo +IMGOPTS='compression_type=zstd' _make_test_img 64M +$QEMU_IO -c "write -c -P 0xAC 64K 64K " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "read -P 0xAC 64K 64K " "$TEST_IMG" | _filter_qemu_io +# read on the cluster boundaries +$QEMU_IO -c "read -v 131070 8 " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "read -v 65534 8" "$TEST_IMG" | _filter_qemu_io + +echo +echo "=== Testing adjacent clusters reading and writing with zstd ===" +echo +IMGOPTS='compression_type=zstd' _make_test_img 64M +$QEMU_IO -c "write -c -P 0xAB 0 64K " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "write -c -P 0xAC 64K 64K " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "write -c -P 0xAD 128K 64K " "$TEST_IMG" | _filter_qemu_io + +$QEMU_IO -c "read -P 0xAB 0 64k " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "read -P 0xAC 64K 64k " "$TEST_IMG" | _filter_qemu_io +$QEMU_IO -c "read -P 0xAD 128K 64k " "$TEST_IMG" | _filter_qemu_io + +echo +echo "=== Testing incompressible cluster processing with zstd ===" +echo +# create a 2M image and fill it with 1M likely incompressible data +# and 1M compressible data +dd if=/dev/urandom of="$RAND_FILE" bs=1M count=1 seek=1 +QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS_NO_FMT" \ +$QEMU_IO -f raw -c "write -P 0xFA 0 1M" "$RAND_FILE" | _filter_qemu_io +$QEMU_IMG convert -f raw -O $IMGFMT -c "$RAND_FILE" "$TEST_IMG" | _filter_qemu_io + +$QEMU_IMG convert -O $IMGFMT -c -o compression_type=zstd \ + "$TEST_IMG" "$COMPR_IMG" +$QEMU_IMG compare "$TEST_IMG" "$COMPR_IMG" + +# success, all done +echo "*** done" +rm -f $seq.full +status=0
tests/qemu-iotests/287.out new file +67 -0
67 lines not on this page · raw message
tests/qemu-iotests/group +1 -0
@@ -294,6 +294,7 @@ 283 auto quick 284 rw 286 rw quick +287 auto quick 288 quick 289 rw quick 290 rw auto quick
Signature · 1 line
2.17.0
PATCH v20 1/4 qcow2: introduce compression type feature
In reply to Denis PlotnikovThe patch adds some preparation parts for incompatible compression type feature to qcow2 allowing the use different compression methods for image clusters (de)compressing.
It is implied that the compression type is set on the image creation and can be changed only later by image conversion, thus compression type defines the only compression algorithm used for the image, and thus, for all image clusters.
The goal of the feature is to add support of other compression methods to qcow2. For example, ZSTD which is more effective on compression than ZLIB.
The default compression is ZLIB. Images created with ZLIB compression type are backward compatible with older qemu versions.
Adding of the compression type breaks a number of tests because now the compression type is reported on image creation and there are some changes in the qcow2 header in size and offsets.
The tests are fixed in the following ways:
* filter out compression_type for many tests
* fix header size, feature table size and backing file offset
affected tests: 031, 036, 061, 080
header_size +=8: 1 byte compression type
7 bytes padding
feature_table += 48: incompatible feature compression type
backing_file_offset += 56 (8 + 48 -> header_change + feature_table_change)
* add "compression type" for test output matching when it isn't filtered
affected tests: 049, 060, 061, 065, 144, 182, 242, 255QAPI part:
--- qapi/block-core.json | 22 +++++- block/qcow2.h | 20 +++++- include/block/block_int.h | 1 + block/qcow2.c | 113 +++++++++++++++++++++++++++++++ tests/qemu-iotests/031.out | 14 ++-- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 ++++++++++++++-------------- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061.out | 34 ++++++---- tests/qemu-iotests/065 | 28 +++++--- tests/qemu-iotests/080 | 2 +- tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/242.out | 5 ++ tests/qemu-iotests/255.out | 8 +-- tests/qemu-iotests/common.filter | 3 +- 16 files changed, 267 insertions(+), 96 deletions(-)
qapi/block-core.json +20 -2
@@ -78,6 +78,8 @@ # # @bitmaps: A list of qcow2 bitmap details (since 4.0) # +# @compression-type: the image cluster compression method (since 5.1) +# # Since: 1.7 ## { 'struct': 'ImageInfoSpecificQCow2',
@@ -89,7 +91,8 @@ '*corrupt': 'bool', 'refcount-bits': 'int', '*encrypt': 'ImageInfoSpecificQCow2Encryption', - '*bitmaps': ['Qcow2BitmapInfo'] + '*bitmaps': ['Qcow2BitmapInfo'], + 'compression-type': 'Qcow2CompressionType' } } ##
@@ -4284,6 +4287,18 @@ 'data': [ 'v2', 'v3' ] } +## +# @Qcow2CompressionType: +# +# Compression type used in qcow2 image file +# +# @zlib: zlib compression, see <http://zlib.net/> +# +# Since: 5.1 +## +{ 'enum': 'Qcow2CompressionType', + 'data': [ 'zlib' ] } + ## # @BlockdevCreateOptionsQcow2: #
@@ -4307,6 +4322,8 @@ # allowed values: off, falloc, full, metadata) # @lazy-refcounts: True if refcounts may be updated lazily (default: off) # @refcount-bits: Width of reference counts in bits (default: 16) +# @compression-type: The image cluster compression method +# (default: zlib, since 5.1) # # Since: 2.12 ##
@@ -4322,7 +4339,8 @@ '*cluster-size': 'size', '*preallocation': 'PreallocMode', '*lazy-refcounts': 'bool', - '*refcount-bits': 'int' } } + '*refcount-bits': 'int', + '*compression-type':'Qcow2CompressionType' } } ## # @BlockdevCreateOptionsQed:
block/qcow2.h +19 -1
@@ -146,8 +146,16 @@ typedef struct QCowHeader {uint32_t refcount_order;uint32_t header_length; + +/* Additional fields */ +uint8_t compression_type; + +/* header must be a multiple of 8 */ +uint8_t padding[7 ]; }QEMU_PACKED QCowHeader; +QEMU_BUILD_BUG_ON (!QEMU_IS_ALIGNED (sizeof (QCowHeader),8 )); + typedef struct QEMU_PACKED QCowSnapshotHeader {/* header is 8 byte aligned */ uint64_t l1_table_offset;
@@ -216,13 +224,16 @@ enum {QCOW2_INCOMPAT_DIRTY_BITNR =0 ,QCOW2_INCOMPAT_CORRUPT_BITNR =1 ,QCOW2_INCOMPAT_DATA_FILE_BITNR =2 , +QCOW2_INCOMPAT_COMPRESSION_BITNR =3 ,QCOW2_INCOMPAT_DIRTY =1 <<QCOW2_INCOMPAT_DIRTY_BITNR ,QCOW2_INCOMPAT_CORRUPT =1 <<QCOW2_INCOMPAT_CORRUPT_BITNR ,QCOW2_INCOMPAT_DATA_FILE =1 <<QCOW2_INCOMPAT_DATA_FILE_BITNR , +QCOW2_INCOMPAT_COMPRESSION =1 <<QCOW2_INCOMPAT_COMPRESSION_BITNR ,QCOW2_INCOMPAT_MASK =QCOW2_INCOMPAT_DIRTY |QCOW2_INCOMPAT_CORRUPT - | QCOW2_INCOMPAT_DATA_FILE, + |QCOW2_INCOMPAT_DATA_FILE + | QCOW2_INCOMPAT_COMPRESSION, };/* Compatible feature bits */
@@ -366,6 +377,13 @@ typedef struct BDRVQcow2State {bool metadata_preallocation_checked;bool metadata_preallocation; +/* +* Compression type used for the image. Default: 0 - ZLIB +* The image compression type is set on image creation. +* For now, the only way to change the compression type +* is to convert the image with the desired compression type set. +*/ +Qcow2CompressionType compression_type; } BDRVQcow2State; typedef struct Qcow2COWRegion {
include/block/block_int.h +1 -0
@@ -57,6 +57,7 @@#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits"#define BLOCK_OPT_DATA_FILE "data_file"#define BLOCK_OPT_DATA_FILE_RAW "data_file_raw" +#define BLOCK_OPT_COMPRESSION_TYPE "compression_type"#define BLOCK_PROBE_BUF_SIZE 512
block/qcow2.c +113 -0
191 lines not on this page · raw message
tests/qemu-iotests/031.out +7 -7
@@ -113,11 +113,11 @@ incompatible_features [] compatible_features [] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
@@ -146,11 +146,11 @@ incompatible_features [] compatible_features [] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
@@ -164,7 +164,7 @@ No errors were found on the image. magic 0x514649fb version 3 -backing_file_offset 0x1d8 +backing_file_offset 0x210 backing_file_size 0x17 cluster_bits 16 size 67108864
@@ -179,7 +179,7 @@ incompatible_features [] compatible_features [] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0xe2792aca
@@ -188,7 +188,7 @@ data 'host_device' Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> Header extension:
tests/qemu-iotests/036.out +2 -2
@@ -26,7 +26,7 @@ compatible_features [] autoclear_features [63] Header extension: magic 0x6803f857 -length 288 +length 336 data <binary>
@@ -38,7 +38,7 @@ compatible_features [] autoclear_features [] Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> *** done
tests/qemu-iotests/049.out +51 -51
225 lines not on this page · raw message
tests/qemu-iotests/060.out +1 -0
@@ -17,6 +17,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 corrupt: true
tests/qemu-iotests/061.out +20 -14
@@ -22,11 +22,11 @@ incompatible_features [] compatible_features [0] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -80,11 +80,11 @@ incompatible_features [] compatible_features [0] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -136,11 +136,11 @@ incompatible_features [0] compatible_features [0] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> ERROR cluster 5 refcount=0 reference=1
@@ -191,11 +191,11 @@ incompatible_features [] compatible_features [42] autoclear_features [42] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> magic 0x514649fb
@@ -260,11 +260,11 @@ incompatible_features [] compatible_features [0] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> read 65536/65536 bytes at offset 44040192
@@ -294,11 +294,11 @@ incompatible_features [0] compatible_features [0] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> ERROR cluster 5 refcount=0 reference=1
@@ -323,11 +323,11 @@ incompatible_features [] compatible_features [] autoclear_features [] refcount_order 4 -header_length 104 +header_length 112 Header extension: magic 0x6803f857 -length 288 +length 336 data <binary> read 131072/131072 bytes at offset 0
@@ -491,6 +491,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file: TEST_DIR/t.IMGFMT.data
@@ -511,6 +512,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file: foo
@@ -524,6 +526,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file raw: false
@@ -538,6 +541,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file: TEST_DIR/t.IMGFMT.data
@@ -550,6 +554,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file: TEST_DIR/t.IMGFMT.data
@@ -563,6 +568,7 @@ virtual size: 64 MiB (67108864 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 data file: TEST_DIR/t.IMGFMT.data
tests/qemu-iotests/065 +18 -10
@@ -88,24 +88,30 @@ class TestQMP(TestImageInfoSpecific): class TestQCow2(TestQemuImgInfo): '''Testing a qcow2 version 2 image''' img_options = 'compat=0.10' - json_compare = { 'compat': '0.10', 'refcount-bits': 16 } - human_compare = [ 'compat: 0.10', 'refcount bits: 16' ] + json_compare = { 'compat': '0.10', 'refcount-bits': 16, + 'compression-type': 'zlib' } + human_compare = [ 'compat: 0.10', 'compression type: zlib', + '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, - 'refcount-bits': 16, 'corrupt': False } - human_compare = [ 'compat: 1.1', 'lazy refcounts: false', - 'refcount bits: 16', 'corrupt: false' ] + 'refcount-bits': 16, 'corrupt': False, + 'compression-type': 'zlib' } + human_compare = [ 'compat: 1.1', 'compression type: zlib', + '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, - 'refcount-bits': 16, 'corrupt': False } - human_compare = [ 'compat: 1.1', 'lazy refcounts: true', - 'refcount bits: 16', 'corrupt: false' ] + 'refcount-bits': 16, 'corrupt': False, + 'compression-type': 'zlib' } + human_compare = [ 'compat: 1.1', 'compression type: zlib', + 'lazy refcounts: true', 'refcount bits: 16', + 'corrupt: false' ] class TestQCow3NotLazyQMP(TestQMP): '''Testing a qcow2 version 3 image with lazy refcounts disabled, opening
@@ -113,7 +119,8 @@ class TestQCow3NotLazyQMP(TestQMP): img_options = 'compat=1.1,lazy_refcounts=off' qemu_options = 'lazy-refcounts=on' compare = { 'compat': '1.1', 'lazy-refcounts': False, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'compression-type': 'zlib' } class TestQCow3LazyQMP(TestQMP):
@@ -122,7 +129,8 @@ class TestQCow3LazyQMP(TestQMP): img_options = 'compat=1.1,lazy_refcounts=on' qemu_options = 'lazy-refcounts=off' compare = { 'compat': '1.1', 'lazy-refcounts': True, - 'refcount-bits': 16, 'corrupt': False } + 'refcount-bits': 16, 'corrupt': False, + 'compression-type': 'zlib' } TestImageInfoSpecific = None TestQemuImgInfo = None
tests/qemu-iotests/080 +1 -1
@@ -45,7 +45,7 @@ _supported_os Linux # - This is generally a test for compat=1.1 images _unsupported_imgopts 'refcount_bits=1[^0-9]' data_file 'compat=0.10' -header_size=104 +header_size=112 offset_backing_file_offset=8 offset_backing_file_size=16
tests/qemu-iotests/144.out +2 -2
@@ -9,7 +9,7 @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=536870912 { 'execute': 'qmp_capabilities' } {"return": {}} { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'virtio0', 'snapshot-file':'TEST_DIR/tmp.IMGFMT', 'format': 'IMGFMT' } } -Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib {"return": {}} === Performing block-commit on active layer ===
@@ -31,6 +31,6 @@ Formatting 'TEST_DIR/tmp.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/ === Performing Live Snapshot 2 === { 'execute': 'blockdev-snapshot-sync', 'arguments': { 'device': 'virtio0', 'snapshot-file':'TEST_DIR/tmp2.IMGFMT', 'format': 'IMGFMT' } } -Formatting 'TEST_DIR/tmp2.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/tmp2.qcow2', fmt=qcow2 size=536870912 backing_file=TEST_DIR/t.qcow2 backing_fmt=qcow2 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib {"return": {}} *** done
tests/qemu-iotests/182.out +1 -1
@@ -13,7 +13,7 @@ Is another process using the image [TEST_DIR/t.qcow2]? {'execute': 'blockdev-add', 'arguments': { 'node-name': 'node0', 'driver': 'file', 'filename': 'TEST_DIR/t.IMGFMT', 'locking': 'on' } } {"return": {}} {'execute': 'blockdev-snapshot-sync', 'arguments': { 'node-name': 'node0', 'snapshot-file': 'TEST_DIR/t.IMGFMT.overlay', 'snapshot-node-name': 'node1' } } -Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib {"return": {}} {'execute': 'blockdev-add', 'arguments': { 'node-name': 'node1', 'driver': 'file', 'filename': 'TEST_DIR/t.IMGFMT', 'locking': 'on' } } {"return": {}}
tests/qemu-iotests/242.out +5 -0
@@ -12,6 +12,7 @@ virtual size: 1 MiB (1048576 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false refcount bits: 16 corrupt: false
@@ -32,6 +33,7 @@ virtual size: 1 MiB (1048576 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false bitmaps: [0]:
@@ -64,6 +66,7 @@ virtual size: 1 MiB (1048576 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false bitmaps: [0]:
@@ -104,6 +107,7 @@ virtual size: 1 MiB (1048576 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false bitmaps: [0]:
@@ -153,6 +157,7 @@ virtual size: 1 MiB (1048576 bytes) cluster_size: 65536 Format specific information: compat: 1.1 + compression type: zlib lazy refcounts: false bitmaps: [0]:
tests/qemu-iotests/255.out +4 -4
@@ -3,9 +3,9 @@ Finishing a commit job with background reads === Create backing chain and start VM === -Formatting 'TEST_DIR/PID-t.qcow2.mid', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-t.qcow2.mid', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib -Formatting 'TEST_DIR/PID-t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-t.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib === Start background read requests ===
@@ -23,9 +23,9 @@ Closing the VM while a job is being cancelled === Create images and start VM === -Formatting 'TEST_DIR/PID-src.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-src.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib -Formatting 'TEST_DIR/PID-dst.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 +Formatting 'TEST_DIR/PID-dst.qcow2', fmt=qcow2 size=134217728 cluster_size=65536 lazy_refcounts=off refcount_bits=16 compression_type=zlib wrote 1048576/1048576 bytes at offset 0 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
tests/qemu-iotests/common.filter +2 -1
@@ -152,7 +152,8 @@ _filter_img_create() -e "s# refcount_bits=[0-9]\\+##g" \ -e "s# key-secret=[a-zA-Z0-9]\\+##g" \ -e "s# iter-time=[0-9]\\+##g" \ - -e "s# force_size=\\(on\\|off\\)##g" + -e "s# force_size=\\(on\\|off\\)##g" \ + -e "s# compression_type=[a-zA-Z0-9]\\+##g" } _filter_img_info()
Signature · 1 line
2.17.0
PATCH v20 3/4 qcow2: add zstd cluster compression
In reply to Denis Plotnikovzstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2G
The test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.
compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd]
src.img [zlib|zstd]_compressed.img
decompress cmd
time ./qemu-img convert -O qcow2
[zlib|zstd]_compressed.img uncompressed.img
compression decompression
zlib zstd zlib zstd
------------------------------------------------------------
real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0
Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
QAPI part:
--- docs/interop/qcow2.txt | 1 + configure | 2 +- qapi/block-core.json | 3 +- block/qcow2-threads.c | 157 +++++++++++++++++++++++++++++++++++++++++ block/qcow2.c | 7 ++ 5 files changed, 168 insertions(+), 2 deletions(-)
docs/interop/qcow2.txt +1 -0
@@ -209,6 +209,7 @@ version 2. Available compression type values: 0: zlib <https://www.zlib.net/> + 1: zstd <http://github.com/facebook/zstd> === Header padding ===
configure +1 -1
@@ -1861,7 +1861,7 @@ disabled with --disable-FEATURE, default is enabled if available: lzfse support of lzfse compression library (for reading lzfse-compressed dmg images) zstd support for zstd compression library - (for migration compression) + (for migration compression and qcow2 cluster compression) seccomp seccomp support coroutine-pool coroutine freelist (better performance) glusterfs GlusterFS backend
qapi/block-core.json +2 -1
@@ -4293,11 +4293,12 @@ # Compression type used in qcow2 image file # # @zlib: zlib compression, see <http://zlib.net/> +# @zstd: zstd compression, see <http://github.com/facebook/zstd> # # Since: 5.1 ## { 'enum': 'Qcow2CompressionType', - 'data': [ 'zlib' ] } + 'data': [ 'zlib', { 'name': 'zstd', 'if': 'defined(CONFIG_ZSTD)' } ] } ## # @BlockdevCreateOptionsQcow2:
block/qcow2-threads.c +157 -0
181 lines not on this page · raw message
block/qcow2.c +7 -0
@@ -1246,6 +1246,9 @@ static int validate_compression_type(BDRVQcow2State *s, Error **errp) {switch (s->compression_type) {case QCOW2_COMPRESSION_TYPE_ZLIB : +#ifdef CONFIG_ZSTD +case QCOW2_COMPRESSION_TYPE_ZSTD : +#endif break ;default :
@@ -3478,6 +3481,10 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) }switch (qcow2_opts->compression_type) { +#ifdef CONFIG_ZSTD +case QCOW2_COMPRESSION_TYPE_ZSTD : +break ; +#endif default :error_setg (errp,"Unknown compression type" ); goto out;
Signature · 1 line
2.17.0
Re: [PATCH v20 1/4] qcow2: introduce compression type feature
In reply to Denis PlotnikovQuoted 30 lines · Denis Plotnikov
The patch adds some preparation parts for incompatible compression type feature to qcow2 allowing the use different compression methods for image clusters (de)compressing.
It is implied that the compression type is set on the image creation and can be changed only later by image conversion, thus compression type defines the only compression algorithm used for the image, and thus, for all image clusters.
The goal of the feature is to add support of other compression methods to qcow2. For example, ZSTD which is more effective on compression than ZLIB.
The default compression is ZLIB. Images created with ZLIB compression type are backward compatible with older qemu versions.
Adding of the compression type breaks a number of tests because now the compression type is reported on image creation and there are some changes in the qcow2 header in size and offsets.
The tests are fixed in the following ways:
* filter out compression_type for many tests * fix header size, feature table size and backing file offset affected tests: 031, 036, 061, 080 header_size +=8: 1 byte compression type 7 bytes padding feature_table += 48: incompatible feature compression type backing_file_offset += 56 (8 + 48 -> header_change + feature_table_change) * add "compression type" for test output matching when it isn't filtered affected tests: 049, 060, 061, 065, 144, 182, 242, 255
Quoted 5 lines
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Eric Blake <[email protected]>QAPI part:
Berto
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
In reply to Denis PlotnikovQuoted 4 lines · Denis Plotnikov
The test checks fulfilling qcow2 requirements for the compression type feature and zstd compression type operability.
Signed-off-by Denis Plotnikov<[email protected]>
Signature · 2 lines
Best regards, Vladimir
Re: [PATCH v20 3/4] qcow2: add zstd cluster compression
In reply to Denis PlotnikovQuoted 44 lines · Denis Plotnikov
zstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2GThe test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd]
src.img [zlib|zstd]_compressed.img
decompress cmd
time ./qemu-img convert -O qcow2
[zlib|zstd]_compressed.img uncompressed.imgcompression decompression
zlib zstd zlib zstd
------------------------------------------------------------real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>QAPI part:
--- docs/interop/qcow2.txt | 1 + configure | 2 +- qapi/block-core.json | 3 +- block/qcow2-threads.c | 157 +++++++++++++++++++++++++++++++++++++++++ block/qcow2.c | 7 ++ 5 files changed, 168 insertions(+), 2 deletions(-)
[...]
Quoted 30 lines
block/qcow2-threads.c +15
-0@@ -28,6 +28,11 @@#define ZLIB_CONST #include <zlib.h> +#ifdef CONFIG_ZSTD +#include <zstd.h> +#include <zstd_errors.h> +#endif +#include "qcow2.h" #include "block/thread-pool.h" #include "crypto.h" @@ -166,6 +171,148 @@ static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size,return ret; } +#ifdef CONFIG_ZSTD + +/* +* qcow2_zstd_compress() +* +* Compress @src_size bytes of data using zstd compression method +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +*
block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 193
Quoted 10 lines
block/qcow2-threads.c +10
-0+* Returns: compressed size on success +* -ENOMEM destination buffer is not enough to store compressed data +* -EIO on any other error +*/ +static ssize_t qcow2_zstd_compress (void *dest,size_t dest_size, +const void *src,size_t src_size) +{ +ssize_t ret; +ZSTD_outBuffer output = { dest, dest_size,0 }; +ZSTD_inBuffer input = { src, src_size,0 };
Minor style note: I think it’d be nicer to use designated initializers here.
Quoted 16 lines
block/qcow2-threads.c +16
-0+ZSTD_CCtx *cctx =ZSTD_createCCtx (); + +if (!cctx) { +return -EIO ; + } +/* +* Use the zstd streamed interface for symmetry with decompression, +* where streaming is essential since we don't record the exact +* compressed size. +* +* In the loop, we try to compress all the data into one zstd frame. +* ZSTD_compressStream2 potentially can finish a frame earlier +* than the full input data is consumed. That's why we are looping +* until all the input data is consumed. +*/ +while (input.pos < input.size) {
block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 219
Quoted 10 lines
block/qcow2-threads.c +10
-0+size_t zstd_ret; +/* +* ZSTD spec: "You must continue calling ZSTD_compressStream2() +* with ZSTD_e_end until it returns 0, at which point you are +* free to start a new frame". We assume that "start a new frame" +* means call ZSTD_compressStream2 in the very beginning or when +* ZSTD_compressStream2 has returned with 0. +*/ + do { + zstd_ret = ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);
The spec makes it sound to me like ZSTD_e_end will always complete in a single call if there’s enough space in the output buffer. So the only team we have to loop would be when there isn’t enough space anyway:
It says this about ZSTD_e_end:
Quoted 2 lines
flush operation is the same, and follows same rules as calling
ZSTD_compressStream2()withZSTD_e_flush.
Those rules being:
Quoted 2 lines
Note that, if
output->sizeis too small, a single invocation withZSTD_e_flushmight not be enough (return code > 0).
So it seems like it will only return a value > 0 if the output buffer is definitely too small.
The spec also notes that the return value is greater than 0 if:
Quoted 2 lines
Quoted 1 line
0 if some data still present within internal buffer (the value is
minimal estimation of remaining size),
So it’s a minimum estimate. That’s another point that heavily implies to me that if the return value were less than what’s left in the buffer, the function wouldn’t return but still try to write it out, until it realizes that there isn’t enough space in the output buffer, and then return a value that exceeds the remaining output buffer size.
(Because if the function just played it safe, I would expect it to return a maximum estimate.)
OTOH, if it were actually possible for ZSTD_e_end to finish a frame earlier than the end of the input, I think it would make more sense to use ZSTD_e_continue until the input is done and then finish with ZSTD_e_end, like the spec seems to propose. That way, we’d always end up with a single frame to make decompression simpler (and I think it would also make more sense overall).
But anyway. From how I understand the spec, this code simply always ends up creating a single frame or erroring out, without looping ever. So it isn’t exactly wrong, it just seems overly complicated. (Again, assuming I understand the spec correctly. Which seems like a tough thing to assume, because the spec is not exactly obvious to read...)
(Running some quick tests by converting some images with zstd compression seems to confirm that whenever ZSTD_compressStream2() returns, either zstd_ret > output.size - output.pos, or zstd_ret == 0 and input.pos == input.size. So none of the loops ever loop.)
Max
Quoted 19 lines
block/qcow2-threads.c +19
-0+ +if (ZSTD_isError (zstd_ret)) { + ret = -EIO ; + goto out; + } +/* Dest buffer isn't big enough to store compressed content */ +if (zstd_ret > output.size - output.pos) { + ret = -ENOMEM ; + goto out; + } + }while (zstd_ret); + } +/* make sure we can safely return compressed buffer size with ssize_t */ +assert (output.pos <=SSIZE_MAX ); + ret = output.pos; +out: +ZSTD_freeCCtx (cctx); +return ret; +}
Re: [PATCH v20 2/4] qcow2: rework the cluster compression routine
In reply to Denis PlotnikovQuoted 10 lines · Denis Plotnikov
The patch enables processing the image compression type defined for the image and chooses an appropriate method for image clusters (de)compression.
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>--- block/qcow2-threads.c | 71 ++++++++++++++++++++++++++++++++++++------- 1 file changed, 60 insertions(+), 11 deletions(-)
Re: [PATCH v20 1/4] qcow2: introduce compression type feature
In reply to Denis PlotnikovQuoted 45 lines · Denis Plotnikov
The patch adds some preparation parts for incompatible compression type feature to qcow2 allowing the use different compression methods for image clusters (de)compressing.
It is implied that the compression type is set on the image creation and can be changed only later by image conversion, thus compression type defines the only compression algorithm used for the image, and thus, for all image clusters.
The goal of the feature is to add support of other compression methods to qcow2. For example, ZSTD which is more effective on compression than ZLIB.
The default compression is ZLIB. Images created with ZLIB compression type are backward compatible with older qemu versions.
Adding of the compression type breaks a number of tests because now the compression type is reported on image creation and there are some changes in the qcow2 header in size and offsets.
The tests are fixed in the following ways:
* filter out compression_type for many tests * fix header size, feature table size and backing file offset affected tests: 031, 036, 061, 080 header_size +=8: 1 byte compression type 7 bytes padding feature_table += 48: incompatible feature compression type backing_file_offset += 56 (8 + 48 -> header_change + feature_table_change) * add "compression type" for test output matching when it isn't filtered affected tests: 049, 060, 061, 065, 144, 182, 242, 255Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Eric Blake <[email protected]>QAPI part:
--- qapi/block-core.json | 22 +++++- block/qcow2.h | 20 +++++- include/block/block_int.h | 1 + block/qcow2.c | 113 +++++++++++++++++++++++++++++++ tests/qemu-iotests/031.out | 14 ++-- tests/qemu-iotests/036.out | 4 +- tests/qemu-iotests/049.out | 102 ++++++++++++++-------------- tests/qemu-iotests/060.out | 1 + tests/qemu-iotests/061.out | 34 ++++++----
Quoted 8 lines
tests/qemu-iotests/065 | 28 +++++--- tests/qemu-iotests/080 | 2 +- tests/qemu-iotests/144.out | 4 +- tests/qemu-iotests/182.out | 2 +- tests/qemu-iotests/242.out | 5 ++ tests/qemu-iotests/255.out | 8 +-- tests/qemu-iotests/common.filter | 3 +- 16 files changed, 267 insertions(+), 96 deletions(-)
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
In reply to Denis PlotnikovQuoted 44 lines · Denis Plotnikov
The test checks fulfilling qcow2 requirements for the compression type feature and zstd compression type operability.
Signed-off-by Denis Plotnikov <[email protected]>--- tests/qemu-iotests/287 | 146 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/287.out | 67 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 214 insertions(+) create mode 100755 tests/qemu-iotests/287 create mode 100644 tests/qemu-iotests/287.outtests/qemu-iotests/287 new file +26
-0@@ -0,0 +1,146 @@ +#!/usr/bin/env bash +# +# Test case for an image using zstd compression +# +# Copyright (c) 2020 Virtuozzo International GmbH +# +# 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" +
tests/qemu-iotests/287 line 36
Quoted 10 lines
tests/qemu-iotests/287 new file +10
-0+status=1 # failure is the default! + +# standard environment +. ./common.rc +. ./common.filter + +# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os Linux
This test doesn’t work with compat=0.10 (because we can’t store a non-default compression type there) or data_file (because those don’t support compression), so those options should be marked as unsupported.
(It does seem to work with any refcount_bits, though.)
tests/qemu-iotests/287 line 44
Quoted 8 lines
tests/qemu-iotests/287 new file +8
-0+ +COMPR_IMG="$TEST_IMG.compressed" +RAND_FILE="$TEST_DIR/rand_data" + +_cleanup() +{ + _cleanup_test_img + rm -f "$COMPR_IMG"
Using _rm_test_img() would be nicer. There shouldn’t be a functional difference here because there’d only be one with external data files (I think), which won’t work with this test, but still.
Quoted 7 lines
tests/qemu-iotests/287 new file +7
-0+ rm -f "$RAND_FILE" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# for all the cases +CLUSTER_SIZE=65536 +
tests/qemu-iotests/287 line 61
Quoted 10 lines
tests/qemu-iotests/287 new file +10
-0+# Check if we can run this test. +if IMGOPTS='compression_type=zstd' _make_test_img 64M | + grep "Invalid parameter 'zstd'"; then + _notrun "ZSTD is disabled" +fi + +echo +echo "=== Testing compression type incompatible bit setting for zlib ===" +echo +IMGOPTS='compression_type=zlib' _make_test_img 64M
Please use -o so user options are still considered.
(i.e., _make_test_img -o compression_type=zlib)
[...]
tests/qemu-iotests/287 line 140
Quoted 12 lines
tests/qemu-iotests/287 new file +12
-0+echo +echo "=== Testing incompressible cluster processing with zstd ===" +echo +# create a 2M image and fill it with 1M likely incompressible data +# and 1M compressible data +dd if=/dev/urandom of="$RAND_FILE" bs=1M count=1 seek=1 +QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS_NO_FMT" \ +$QEMU_IO -f raw -c "write -P 0xFA 0 1M" "$RAND_FILE" | _filter_qemu_io +$QEMU_IMG convert -f raw -O $IMGFMT -c "$RAND_FILE" "$TEST_IMG" | _filter_qemu_io + +$QEMU_IMG convert -O $IMGFMT -c -o compression_type=zstd \ + "$TEST_IMG" "$COMPR_IMG"
Again, it would be nice to not discard the user-supplied options here, and maybe it would also be nicer to explicitly pass the compression type for the first convert, too. So we’d use
-o "$(_optstr_add "$IMGOPTS" "compression_type=zlib")"
for the first convert, and
-o "$(_optstr_add "$IMGOPTS" "compression_type=zstd")"
for the second one.
Max
Re: [PATCH v20 3/4] qcow2: add zstd cluster compression
In reply to Max ReitzQuoted 155 lines · Max Reitz
Quoted 44 lines · Denis Plotnikov
zstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2GThe test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd]
src.img [zlib|zstd]_compressed.img
decompress cmd
time ./qemu-img convert -O qcow2
[zlib|zstd]_compressed.img uncompressed.imgcompression decompression
zlib zstd zlib zstd
------------------------------------------------------------real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>QAPI part:
--- docs/interop/qcow2.txt | 1 + configure | 2 +- qapi/block-core.json | 3 +- block/qcow2-threads.c | 157 +++++++++++++++++++++++++++++++++++++++++ block/qcow2.c | 7 ++ 5 files changed, 168 insertions(+), 2 deletions(-)[...]
Quoted 30 lines
block/qcow2-threads.c +15
-0@@ -28,6 +28,11 @@#define ZLIB_CONST #include <zlib.h> +#ifdef CONFIG_ZSTD +#include <zstd.h> +#include <zstd_errors.h> +#endif +#include "qcow2.h" #include "block/thread-pool.h" #include "crypto.h" @@ -166,6 +171,148 @@ static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size,return ret; } +#ifdef CONFIG_ZSTD + +/* +* qcow2_zstd_compress() +* +* Compress @src_size bytes of data using zstd compression method +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 193
Quoted 10 lines
block/qcow2-threads.c +10
-0+* Returns: compressed size on success +* -ENOMEM destination buffer is not enough to store compressed data +* -EIO on any other error +*/ +static ssize_t qcow2_zstd_compress (void *dest,size_t dest_size, +const void *src,size_t src_size) +{ +ssize_t ret; +ZSTD_outBuffer output = { dest, dest_size,0 }; +ZSTD_inBuffer input = { src, src_size,0 };Minor style note: I think it’d be nicer to use designated initializers here.
Quoted 16 lines
block/qcow2-threads.c +16
-0+ZSTD_CCtx *cctx =ZSTD_createCCtx (); + +if (!cctx) { +return -EIO ; + } +/* +* Use the zstd streamed interface for symmetry with decompression, +* where streaming is essential since we don't record the exact +* compressed size. +* +* In the loop, we try to compress all the data into one zstd frame. +* ZSTD_compressStream2 potentially can finish a frame earlier +* than the full input data is consumed. That's why we are looping +* until all the input data is consumed. +*/ +while (input.pos < input.size) {block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 219
Quoted 10 lines
block/qcow2-threads.c +10
-0+size_t zstd_ret; +/* +* ZSTD spec: "You must continue calling ZSTD_compressStream2() +* with ZSTD_e_end until it returns 0, at which point you are +* free to start a new frame". We assume that "start a new frame" +* means call ZSTD_compressStream2 in the very beginning or when +* ZSTD_compressStream2 has returned with 0. +*/ + do { + zstd_ret = ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);The spec makes it sound to me like
ZSTD_e_endwill always complete in a single call if there’s enough space in the output buffer. So the only team we have to loop would be when there isn’t enough space anyway:It says this about
ZSTD_e_end:Quoted 2 lines
flush operation is the same, and follows same rules as calling
ZSTD_compressStream2()withZSTD_e_flush.Those rules being:
Quoted 2 lines
Note that, if
output->sizeis too small, a single invocation withZSTD_e_flushmight not be enough (return code > 0).So it seems like it will only return a value > 0 if the output buffer is definitely too small.
The spec also notes that the return value is greater than 0 if:
Quoted 2 lines
Quoted 1 line
0 if some data still present within internal buffer (the value is
minimal estimation of remaining size),
So it’s a minimum estimate. That’s another point that heavily implies to me that if the return value were less than what’s left in the buffer, the function wouldn’t return but still try to write it out, until it realizes that there isn’t enough space in the output buffer, and then return a value that exceeds the remaining output buffer size.
(Because if the function just played it safe, I would expect it to return a maximum estimate.)
OTOH, if it were actually possible for
ZSTD_e_endto finish a frame earlier than the end of the input, I think it would make more sense to useZSTD_e_continueuntil the input is done and then finish withZSTD_e_end, like the spec seems to propose. That way, we’d always end up with a single frame to make decompression simpler (and I think it would also make more sense overall).But anyway. From how I understand the spec, this code simply always ends up creating a single frame or erroring out, without looping ever. So it isn’t exactly wrong, it just seems overly complicated. (Again, assuming I understand the spec correctly. Which seems like a tough thing to assume, because the spec is not exactly obvious to read...)
Quoted 6 lines
(Running some quick tests by converting some images with zstd compression seems to confirm that whenever
ZSTD_compressStream2()returns, eitherzstd_ret> output.size - output.pos, orzstd_ret== 0 and input.pos == input.size. So none of the loops ever loop.)Max
So, what should we do?
1. Rely on the test that there's no need for the loop:
* make one ZSTD_compressStream2() call
* make sure it returned with zstd_ret == 0 and input.pos == input.size.
if so, return with the size
* if not, check that zstd_ret > output.size - output.pos if so, return with -ENOMEM
* if none above return with -EIO
This should cover the majority of the compressing cases
2. Leave the loop as is, because of the documentation:
"You *must* continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to start a new frame."
This fulfills the documentation requirements.
3. Any other option?
Denis
Quoted 20 lines
Quoted 20 lines
block/qcow2-threads.c +19
-0+ +if (ZSTD_isError (zstd_ret)) { + ret = -EIO ; + goto out; + } +/* Dest buffer isn't big enough to store compressed content */ +if (zstd_ret > output.size - output.pos) { + ret = -ENOMEM ; + goto out; + } + }while (zstd_ret); + } +/* make sure we can safely return compressed buffer size with ssize_t */ +assert (output.pos <=SSIZE_MAX ); + ret = output.pos; +out: +ZSTD_freeCCtx (cctx); +return ret; +}
Re: [PATCH v20 3/4] qcow2: add zstd cluster compression
Quoted 181 lines · Denis Plotnikov
Quoted 160 lines · Max Reitz
Quoted 44 lines · Denis Plotnikov
zstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2GThe test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd] src.img [zlib|zstd]_compressed.img decompress cmd
time ./qemu-img convert -O qcow2 [zlib|zstd]_compressed.img uncompressed.imgcompression decompression zlib zstd zlib zstd
------------------------------------------------------------
real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>QAPI part:
---
docs/interop/qcow2.txt| 1 +
configure | 2 +-
qapi/block-core.json | 3 +-
block/qcow2-threads.c | 157 +++++++++++++++++++++++++++++++++++++++++ block/qcow2.c | 7 ++5 files changed, 168 insertions(+), 2 deletions(-)[...]
Quoted 34 lines
block/qcow2-threads.c +0
-0@@ -28,6 +28,11 @@ #define ZLIB_CONST #include <zlib.h>+#ifdef
CONFIG_ZSTDblock/qcow2-threads.c +4
-0+#include <zstd.h> +#include <zstd_errors.h> +#endif +#include "
qcow2.h"
#include "block/thread-pool.h"
#include "crypto.h"block/qcow2-threads.c +0
-0@@ -166,6 +171,148 @@ static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, return ret; }+#ifdef
CONFIG_ZSTDblock/qcow2-threads.c +11
-0+ +/* +* qcow2_zstd_compress() +* +* Compress @src_size bytes of data using zstd compression method +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* +* Returns: compressed size on success +* -ENOMEM destination buffer is not enough to store compressed data
+ * -EIO on any other error
+ */block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 193
Quoted 6 lines
block/qcow2-threads.c +6
-0+static ssize_t qcow2_zstd_compress (void *dest,size_t dest_size, + const void *src, size_t src_size) +{ + ssize_t ret; + ZSTD_outBuffer output = { dest, dest_size, 0 }; + ZSTD_inBuffer input = { src, src_size, 0 };Minor style note: I think it’d be nicer to use designated initializers here.
Quoted 22 lines
+
ZSTD_CCtx*cctx =ZSTD_createCCtx();
+
+ if (!cctx) {
+ return-EIO;
+ }
+ /*
+ * Use the zstd streamed interface for symmetry with decompression, + * where streaming is essential since we don't record the exact + * compressed size.
+ *
+ * In the loop, we try to compress all the data into one zstd frame.
+ *ZSTD_compressStream2potentially can finish a frame earlier + * than the full input data is consumed. That's why we are looping + * until all the input data is consumed.
+ */
+ while (input.pos < input.size) {
+size_tzstd_ret;
+ /*
+ * ZSTD spec: "You must continue callingZSTD_compressStream2()+ * withZSTD_e_enduntil it returns 0, at which point you are + * free to start a new frame". We assume that "start a newQuoted 8 lines
frame"
+ * means callZSTD_compressStream2in the very beginning or when
+ *ZSTD_compressStream2has returned with 0.
+ */
+ do {
+zstd_ret=ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);The spec makes it sound to me like
ZSTD_e_endwill always complete in a single call if there’s enough space in the output buffer. So the only team we have to loop would be when there isn’t enough space anyway:It says this about
ZSTD_e_end:Quoted 2 lines
flush operation is the same, and follows same rules as calling
ZSTD_compressStream2()withZSTD_e_flush.Those rules being:
Quoted 2 lines
Note that, if
output->sizeis too small, a single invocation withZSTD_e_flushmight not be enough (return code > 0).So it seems like it will only return a value > 0 if the output buffer is definitely too small.
The spec also notes that the return value is greater than 0 if:
Quoted 2 lines
Quoted 1 line
0 if some data still present within internal buffer (the value is
minimal estimation of remaining size),
So it’s a minimum estimate. That’s another point that heavily implies to me that if the return value were less than what’s left in the buffer, the function wouldn’t return but still try to write it out, until it realizes that there isn’t enough space in the output buffer, and then return a value that exceeds the remaining output buffer size.
(Because if the function just played it safe, I would expect it to return a maximum estimate.)
OTOH, if it were actually possible for
ZSTD_e_endto finish a frame earlier than the end of the input, I think it would make more sense to useZSTD_e_continueuntil the input is done and then finish withZSTD_e_end, like the spec seems to propose. That way, we’d always end up with a single frame to make decompression simpler (and I think it would also make more sense overall).But anyway. From how I understand the spec, this code simply always ends up creating a single frame or erroring out, without looping ever. So it isn’t exactly wrong, it just seems overly complicated. (Again, assuming I understand the spec correctly. Which seems like a tough thing to assume, because the spec is not exactly obvious to read...)
Quoted 6 lines
(Running some quick tests by converting some images with zstd compression seems to confirm that whenever
ZSTD_compressStream2()returns, eitherzstd_ret> output.size - output.pos, orzstd_ret== 0 and input.pos == input.size. So none of the loops ever loop.)Max
So, what should we do?
1. Rely on the test that there's no need for the loop:
* make oneZSTD_compressStream2()call
* make sure it returned withzstd_ret== 0 and input.pos == input.size.
if so, return with the size
* if not, check thatzstd_ret> output.size - output.pos if so, return with-ENOMEM
* if none above return with-EIO
Quoted 1 line
This should cover the majority of the compressing cases
According to how I interpret the spec, “none of the above” should never happen except for ZSTD_isError(zstd_ret), so this should cover all compressing cases, actually.
Quoted 4 lines
2. Leave the loop as is, because of the documentation:
"You *must* continue callingZSTD_compressStream2()withZSTD_e_enduntil it returns 0,
at which point you are free to start a new frame."
As far as I can see, the return value is always 0 or greater than the remaining buffer space, so this will always be satisfied even without a loop. (We will always have one of three cases: (1) Success and all input has been consumed, (2) ZSTD_isError(zstd_ret), so we return -EIO,
(3) zstd_ret > output.size - output.pos, so we return -ENOMEM.
I interpret the “You *must* continue until it returns 0” as “If there is no sufficient space in the output buffer, this function will return a value greater than 0 indicating how much space is at least still required. The caller is free to supply a greater output buffer for the next call (by supplying a different ZSTD_outBuffer structure), and then we’ll try again.”
(I.e., retrying with the same ZSTD_outBuffer will make the function return immediately because it knows that it’s insufficient.)
Max
Re: [PATCH v20 3/4] qcow2: add zstd cluster compression
Quoted 204 lines · Max Reitz
Quoted 179 lines · Denis Plotnikov
Quoted 160 lines · Max Reitz
Quoted 44 lines · Denis Plotnikov
zstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2GThe test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd] src.img [zlib|zstd]_compressed.img
decompress cmd
time ./qemu-img convert -O qcow2 [zlib|zstd]_compressed.img uncompressed.imgcompression decompression zlib zstd zlib zstd
------------------------------------------------------------
real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>QAPI part:
--- docs/interop/qcow2.txt | 1 + configure | 2 +- qapi/block-core.json | 3 +- block/qcow2-threads.c | 157 +++++++++++++++++++++++++++++++++++++++++ block/qcow2.c | 7 ++ 5 files changed, 168 insertions(+), 2 deletions(-)[...]
Quoted 34 lines
block/qcow2-threads.c +15
-0@@ -28,6 +28,11 @@ #define ZLIB_CONST #include <zlib.h> +#ifdef CONFIG_ZSTD +#include <zstd.h> +#include <zstd_errors.h> +#endif + #include "qcow2.h" #include "block/thread-pool.h" #include "crypto.h"@@ -166,6 +171,148 @@ static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, return ret; } +#ifdef CONFIG_ZSTD + +/* +* qcow2_zstd_compress() +* +* Compress @src_size bytes of data using zstd compression method +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* +* Returns: compressed size on success +* -ENOMEM destination buffer is not enough to store compressed data
+ * -EIO on any other error
+ */block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 193
Quoted 6 lines
block/qcow2-threads.c +6
-0+static ssize_t qcow2_zstd_compress (void *dest,size_t dest_size, + const void *src, size_t src_size) +{ + ssize_t ret; + ZSTD_outBuffer output = { dest, dest_size, 0 }; + ZSTD_inBuffer input = { src, src_size, 0 };Minor style note: I think it’d be nicer to use designated initializers here.
Quoted 22 lines
+
ZSTD_CCtx*cctx =ZSTD_createCCtx();
+
+ if (!cctx) {
+ return-EIO;
+ }
+ /*
+ * Use the zstd streamed interface for symmetry with decompression, + * where streaming is essential since we don't record the exact + * compressed size.
+ *
+ * In the loop, we try to compress all the data into one zstd frame.
+ *ZSTD_compressStream2potentially can finish a frame earlier + * than the full input data is consumed. That's why we are looping + * until all the input data is consumed.
+ */
+ while (input.pos < input.size) {
+size_tzstd_ret;
+ /*
+ * ZSTD spec: "You must continue callingZSTD_compressStream2()+ * withZSTD_e_enduntil it returns 0, at which point you are + * free to start a new frame". We assume that "start a newQuoted 8 lines
frame"
+ * means callZSTD_compressStream2in the very beginning or when
+ *ZSTD_compressStream2has returned with 0.
+ */
+ do {
+zstd_ret=ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);The spec makes it sound to me like
ZSTD_e_endwill always complete in a single call if there’s enough space in the output buffer. So the only team we have to loop would be when there isn’t enough space anyway:It says this about
ZSTD_e_end:Quoted 2 lines
flush operation is the same, and follows same rules as calling
ZSTD_compressStream2()withZSTD_e_flush.Those rules being:
Quoted 2 lines
Note that, if
output->sizeis too small, a single invocation withZSTD_e_flushmight not be enough (return code > 0).So it seems like it will only return a value > 0 if the output buffer is definitely too small.
The spec also notes that the return value is greater than 0 if:
Quoted 2 lines
Quoted 1 line
0 if some data still present within internal buffer (the value is
minimal estimation of remaining size),
So it’s a minimum estimate. That’s another point that heavily implies to me that if the return value were less than what’s left in the buffer, the function wouldn’t return but still try to write it out, until it realizes that there isn’t enough space in the output buffer, and then return a value that exceeds the remaining output buffer size.
(Because if the function just played it safe, I would expect it to return a maximum estimate.)
OTOH, if it were actually possible for
ZSTD_e_endto finish a frame earlier than the end of the input, I think it would make more sense to useZSTD_e_continueuntil the input is done and then finish withZSTD_e_end, like the spec seems to propose. That way, we’d always end up with a single frame to make decompression simpler (and I think it would also make more sense overall).But anyway. From how I understand the spec, this code simply always ends up creating a single frame or erroring out, without looping ever. So it isn’t exactly wrong, it just seems overly complicated. (Again, assuming I understand the spec correctly. Which seems like a tough thing to assume, because the spec is not exactly obvious to read...)
Quoted 6 lines
(Running some quick tests by converting some images with zstd compression seems to confirm that whenever
ZSTD_compressStream2()returns, eitherzstd_ret> output.size - output.pos, orzstd_ret== 0 and input.pos == input.size. So none of the loops ever loop.)Max
So, what should we do?
1. Rely on the test that there's no need for the loop:
* make oneZSTD_compressStream2()call
* make sure it returned withzstd_ret== 0 and input.pos == input.size.
if so, return with the size
* if not, check thatzstd_ret> output.size - output.pos if so, return with-ENOMEM
* if none above return with-EIOQuoted 1 line
This should cover the majority of the compressing cases
According to how I interpret the spec, “none of the above” should never happen except for
ZSTD_isError(zstd_ret), so this should cover all compressing cases, actually.Quoted 4 lines
2. Leave the loop as is, because of the documentation:
"You *must* continue callingZSTD_compressStream2()withZSTD_e_end
until it returns 0,
at which point you are free to start a new frame."As far as I can see, the return value is always 0 or greater than the remaining buffer space, so this will always be satisfied even without a loop. (We will always have one of three cases: (1) Success and all input has been consumed, (2)
ZSTD_isError(zstd_ret), so we return-EIO,
(3)zstd_ret> output.size - output.pos, so we return-ENOMEM.I interpret the “You *must* continue until it returns 0” as “If there is no sufficient space in the output buffer, this function will return a value greater than 0 indicating how much space is at least still required. The caller is free to supply a greater output buffer for the next call (by supplying a different
ZSTD_outBufferstructure), and then we’ll try again.”
(I.e., retrying with the sameZSTD_outBufferwill make the function return immediately because it knows that it’s insufficient.)
Quoted 1 line
Max
ok, removing the loop sounds reasonable.
My only concern is that *must* in the doc.
Could ZSTD-lib change the logic in the future relying on the fact that they make users use ZSTD_compressStream() in a loop. Honestly, I can't imagine the case when they would want to do that, but still.
Without the loop we're protected even in this case. The worst thing could happen because of that is qcow2_zstd_compress() would return with -EIO more frequently.
So, if I understand correctly, you are ok with removing the loop.
Denis
Quoted 1 line
Re: [PATCH v20 3/4] qcow2: add zstd cluster compression
Quoted 214 lines · Denis Plotnikov
Quoted 211 lines · Max Reitz
Quoted 186 lines · Denis Plotnikov
Quoted 167 lines · Max Reitz
Quoted 46 lines · Denis Plotnikov
zstd significantly reduces cluster compression time. It provides better compression performance maintaining the same level of the compression ratio in comparison with zlib, which, at the moment, is the only compression method available.
The performance test results:
Test compresses and decompresses qemu qcow2 image with just installed rhel-7.6 guest.
Image cluster size: 64K. Image on disk size: 2.2GThe test was conducted with brd disk to reduce the influence of disk subsystem to the test results.
The results is given in seconds.compress cmd:
time ./qemu-img convert -O qcow2 -c -o compression_type=[zlib|zstd]
src.img [zlib|zstd]_compressed.img decompress cmd
time ./qemu-img convert -O qcow2 [zlib|zstd]_compressed.img uncompressed.imgcompression decompression zlib zstd zlib zstd
------------------------------------------------------------
real 65.5 16.3 (-75 %) 1.9 1.6 (-16 %) user 65.0 15.8 5.3 2.5 sys 3.3 0.2 2.0 2.0Both ZLIB and ZSTD gave the same compression ratio: 1.57 compressed image size in both cases: 1.4G
Signed-off-by Denis Plotnikov <[email protected]>Reviewed-by Vladimir Sementsov-Ogievskiy <[email protected]>Reviewed-by Alberto Garcia <[email protected]>QAPI part:
---
docs/interop/qcow2.txt| 1 +
configure | 2 +-
qapi/block-core.json | 3 +-
block/qcow2-threads.c | 157
+++++++++++++++++++++++++++++++++++++++++
block/qcow2.c | 7 ++5 files changed, 168 insertions(+), 2 deletions(-)[...]
Quoted 34 lines
block/qcow2-threads.c +0
-0@@ -28,6 +28,11 @@ #define ZLIB_CONST #include <zlib.h>+#ifdef
CONFIG_ZSTDblock/qcow2-threads.c +4
-0+#include <zstd.h> +#include <zstd_errors.h> +#endif +#include "
qcow2.h"
#include "block/thread-pool.h"
#include "crypto.h"block/qcow2-threads.c +0
-0@@ -166,6 +171,148 @@ static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, return ret; }+#ifdef
CONFIG_ZSTDblock/qcow2-threads.c +11
-0+ +/* +* qcow2_zstd_compress() +* +* Compress @src_size bytes of data using zstd compression method +* +* @dest - destination buffer, @dest_size bytes +* @src - source buffer, @src_size bytes +* +* Returns: compressed size on success +* -ENOMEM destination buffer is not enough to store compressed data
+ * -EIO on any other error
+ */block/qcow2-threads.c static ssize_t qcow2_zlib_decompress(void *dest, size_t dest_size, · line 193
Quoted 6 lines
block/qcow2-threads.c +6
-0+static ssize_t qcow2_zstd_compress (void *dest,size_t dest_size, + const void *src, size_t src_size) +{ + ssize_t ret; + ZSTD_outBuffer output = { dest, dest_size, 0 }; + ZSTD_inBuffer input = { src, src_size, 0 };Minor style note: I think it’d be nicer to use designated initializers here.
Quoted 25 lines
+
ZSTD_CCtx*cctx =ZSTD_createCCtx();
+
+ if (!cctx) {
+ return-EIO;
+ }
+ /*
+ * Use the zstd streamed interface for symmetry with decompression,
+ * where streaming is essential since we don't record the exact + * compressed size.
+ *
+ * In the loop, we try to compress all the data into one zstd frame.
+ *ZSTD_compressStream2potentially can finish a frame earlier + * than the full input data is consumed. That's why we are looping
+ * until all the input data is consumed.
+ */
+ while (input.pos < input.size) {
+size_tzstd_ret;
+ /*
+ * ZSTD spec: "You must continue callingZSTD_compressStream2()
+ * withZSTD_e_enduntil it returns 0, at which point you are + * free to start a new frame". We assume that "start a newQuoted 8 lines
frame"
+ * means callZSTD_compressStream2in the very beginning or when
+ *ZSTD_compressStream2has returned with 0.
+ */
+ do {
+zstd_ret=ZSTD_compressStream2(cctx, &output, &input, ZSTD_e_end);The spec makes it sound to me like
ZSTD_e_endwill always complete in a single call if there’s enough space in the output buffer. So the only team we have to loop would be when there isn’t enough space anyway:It says this about
ZSTD_e_end:Quoted 2 lines
flush operation is the same, and follows same rules as calling
ZSTD_compressStream2()withZSTD_e_flush.Those rules being:
Quoted 2 lines
Note that, if
output->sizeis too small, a single invocation withZSTD_e_flushmight not be enough (return code > 0).So it seems like it will only return a value > 0 if the output buffer is
definitely too small.The spec also notes that the return value is greater than 0 if:
Quoted 2 lines
Quoted 1 line
0 if some data still present within internal buffer (the value is
minimal estimation of remaining size),
So it’s a minimum estimate. That’s another point that heavily implies to me that if the return value were less than what’s left in the buffer,
the function wouldn’t return but still try to write it out, until it realizes that there isn’t enough space in the output buffer, and then return a value that exceeds the remaining output buffer size.(Because if the function just played it safe, I would expect it to return a maximum estimate.)
OTOH, if it were actually possible for
ZSTD_e_endto finish a frame earlier than the end of the input, I think it would make more sense to useZSTD_e_continueuntil the input is done and then finish withZSTD_e_end, like the spec seems to propose. That way, we’d always end up with a single frame to make decompression simpler (and I think it would also make more sense overall).But anyway. From how I understand the spec, this code simply always ends up creating a single frame or erroring out, without looping ever. So it isn’t exactly wrong, it just seems overly complicated. (Again, assuming I understand the spec correctly. Which seems like a tough thing to assume, because the spec is not exactly obvious to read...)
Quoted 6 lines
(Running some quick tests by converting some images with zstd compression seems to confirm that whenever
ZSTD_compressStream2()returns, eitherzstd_ret> output.size - output.pos, orzstd_ret== 0 and input.pos == input.size. So none of the loops ever loop.)Max
So, what should we do?
1. Rely on the test that there's no need for the loop:
* make oneZSTD_compressStream2()call
* make sure it returned withzstd_ret== 0 and input.pos == input.size.
if so, return with the size
* if not, check thatzstd_ret> output.size - output.pos if so, return with-ENOMEM
* if none above return with-EIOQuoted 1 line
This should cover the majority of the compressing cases
According to how I interpret the spec, “none of the above” should never happen except for
ZSTD_isError(zstd_ret), so this should cover all compressing cases, actually.Quoted 4 lines
2. Leave the loop as is, because of the documentation:
"You *must* continue callingZSTD_compressStream2()withZSTD_e_enduntil it returns 0,
at which point you are free to start a new frame."As far as I can see, the return value is always 0 or greater than the remaining buffer space, so this will always be satisfied even without a loop. (We will always have one of three cases: (1) Success and all input has been consumed, (2)
ZSTD_isError(zstd_ret), so we return-EIO,
(3)zstd_ret> output.size - output.pos, so we return-ENOMEM.I interpret the “You *must* continue until it returns 0” as “If there is no sufficient space in the output buffer, this function will return a value greater than 0 indicating how much space is at least still required. The caller is free to supply a greater output buffer for the next call (by supplying a different
ZSTD_outBufferstructure), and then we’ll try again.”
(I.e., retrying with the sameZSTD_outBufferwill make the function return immediately because it knows that it’s insufficient.)
Quoted 4 lines
Quoted 1 line
Max
ok, removing the loop sounds reasonable.
My only concern is that *must* in the doc.
Well, if we just return an error whenever we get a return value != 0, then we shouldn’t have to care what we must and mustn’t do, because we’ll just abort the compression process then.
Quoted 2 lines
Could ZSTD-lib change the logic in the future relying on the fact that they make users use
ZSTD_compressStream()in a loop.
It isn’t like I just wondered whether the loop is necessary and saw that with the current implementation, it didn’t seem necessary for any of the test images I have.
My reasoning is based on the specification, which says for ZSTD_e_flush that it will only return a value > 0 if output->size is too small; and that ZSTD_e_end follows the same rules.
So I think if they were to change behavior, they’d violate the spec.
Quoted 5 lines
Honestly, I can't imagine the case when they would want to do that, but still.
Without the loop we're protected even in this case. The worst thing could happen because of that isqcow2_zstd_compress()would return with-EIOmore frequently.
I think so, too.
Quoted 1 line
So, if I understand correctly, you are ok with removing the loop.
Yes.
Max
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
In reply to Max ReitzQuoted 59 lines · Max Reitz
Quoted 44 lines · Denis Plotnikov
The test checks fulfilling qcow2 requirements for the compression type feature and zstd compression type operability.
Signed-off-by Denis Plotnikov <[email protected]>--- tests/qemu-iotests/287 | 146 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/287.out | 67 +++++++++++++++++ tests/qemu-iotests/group | 1 + 3 files changed, 214 insertions(+)create mode 100755 tests/qemu-iotests/287
create mode 100644 tests/qemu-iotests/287.outtests/qemu-iotests/287 new file +26
-0@@ -0,0 +1,146 @@ +#!/usr/bin/env bash +# +# Test case for an image using zstd compression +# +# Copyright (c) 2020 Virtuozzo International GmbH +# +# 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" +tests/qemu-iotests/287 line 36
Quoted 10 lines
tests/qemu-iotests/287 new file +10
-0+status=1 # failure is the default! + +# standard environment +. ./common.rc +. ./common.filter + +# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os LinuxThis test doesn’t work with compat=0.10 (because we can’t store a non-default compression type there) or
data_file(because those don’t support compression), so those options should be marked as unsupported.
Quoted 1 line
(It does seem to work with any
refcount_bits, though.)
Could I ask how to achieve that?
I can't find any _supported_* related.
Denis
Quoted 58 lines
tests/qemu-iotests/287 line 44
Quoted 9 lines
tests/qemu-iotests/287 new file +8
-0+ +COMPR_IMG="$TEST_IMG.compressed" +RAND_FILE="$TEST_DIR/rand_data" + +_cleanup() +{ + _cleanup_test_img + rm -f "$COMPR_IMG"Using
_rm_test_img()would be nicer. There shouldn’t be a functional difference here because there’d only be one with external data files (I think), which won’t work with this test, but still.Quoted 7 lines
tests/qemu-iotests/287 new file +7
-0+ rm -f "$RAND_FILE" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + +# for all the cases +CLUSTER_SIZE=65536 +tests/qemu-iotests/287 line 61
Quoted 10 lines
tests/qemu-iotests/287 new file +10
-0+# Check if we can run this test. +if IMGOPTS='compression_type=zstd' _make_test_img 64M | + grep "Invalid parameter 'zstd'"; then + _notrun "ZSTD is disabled" +fi + +echo +echo "=== Testing compression type incompatible bit setting for zlib ===" +echo +IMGOPTS='compression_type=zlib' _make_test_img 64MPlease use -o so user options are still considered.
(i.e.,
_make_test_img-o compression_type=zlib)[...]
tests/qemu-iotests/287 line 140
Quoted 12 lines
tests/qemu-iotests/287 new file +12
-0+echo +echo "=== Testing incompressible cluster processing with zstd ===" +echo +# create a 2M image and fill it with 1M likely incompressible data +# and 1M compressible data +dd if=/dev/urandom of="$RAND_FILE" bs=1M count=1 seek=1 +QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS_NO_FMT" \ +$QEMU_IO -f raw -c "write -P 0xFA 0 1M" "$RAND_FILE" | _filter_qemu_io +$QEMU_IMG convert -f raw -O $IMGFMT -c "$RAND_FILE" "$TEST_IMG" | _filter_qemu_io + +$QEMU_IMG convert -O $IMGFMT -c -o compression_type=zstd \ + "$TEST_IMG" "$COMPR_IMG"Again, it would be nice to not discard the user-supplied options here, and maybe it would also be nicer to explicitly pass the compression type for the first convert, too. So we’d use
-o "$(_optstr_add "$IMGOPTS" "compression_type=zlib")"
for the first convert, and
-o "$(_optstr_add "$IMGOPTS" "compression_type=zstd")"
for the second one.Max
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
Quoted 62 lines · Denis Plotnikov
Quoted 59 lines · Max Reitz
Quoted 44 lines · Denis Plotnikov
The test checks fulfilling qcow2 requirements for the compression type feature and zstd compression type operability.
Signed-off-by Denis Plotnikov <[email protected]>---
tests/qemu-iotests/287 | 146 +++++++++++++++++++++++++++++++++++++ tests/qemu-iotests/287.out | 67 +++++++++++++++++ tests/qemu-iotests/group | 1 +3 files changed, 214 insertions(+)create mode 100755 tests/qemu-iotests/287
create mode 100644 tests/qemu-iotests/287.outtests/qemu-iotests/287 new file +26
-0@@ -0,0 +1,146 @@ +#!/usr/bin/env bash +# +# Test case for an image using zstd compression +# +# Copyright (c) 2020 Virtuozzo International GmbH +# +# 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" +tests/qemu-iotests/287 line 36
Quoted 10 lines
tests/qemu-iotests/287 new file +10
-0+status=1 # failure is the default! + +# standard environment +. ./common.rc +. ./common.filter + +# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os LinuxThis test doesn’t work with compat=0.10 (because we can’t store a non-default compression type there) or
data_file(because those don’t support compression), so those options should be marked as unsupported.
Quoted 4 lines
Quoted 1 line
(It does seem to work with any
refcount_bits, though.)Could I ask how to achieve that?
I can't find any _supported_* related.
It’s _unsupported_imgopts.
Max
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
Quoted 8 lines · Max Reitz
Quoted 8 lines
Quoted 8 lines
tests/qemu-iotests/287 line 36
Quoted 4 lines
tests/qemu-iotests/287 new file +4
-0+# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os LinuxThis test doesn’t work with compat=0.10 (because we can’t store a non-default compression type there) or
data_file(because those don’t support compression), so those options should be marked as unsupported.
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
(It does seem to work with any
refcount_bits, though.)Could I ask how to achieve that?
I can't find any _supported_* related.It’s
_unsupported_imgopts.
Test 036 is an example of this.
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Re: [PATCH v20 4/4] iotests: 287: add qcow2 compression type test
Quoted 12 lines · Eric Blake
Quoted 10 lines · Max Reitz
Quoted 10 lines
Quoted 9 lines
tests/qemu-iotests/287 line 36
Quoted 4 lines
tests/qemu-iotests/287 new file +4
-0+# This tests qocw2-specific low-level functionality +_supported_fmt qcow2 +_supported_proto file +_supported_os LinuxThis test doesn’t work with compat=0.10 (because we can’t store a non-default compression type there) or
data_file(because those don’t support compression), so those options should be marked as unsupported.(It does seem to work with any
refcount_bits, though.)
Quoted 7 lines
Quoted 5 lines
Quoted 2 lines
Could I ask how to achieve that?
I can't find any _supported_* related.It’s
_unsupported_imgopts.Test 036 is an example of this.
Max, Eric
Thanks!
Denis