* [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add compress format extension
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 14:52 ` Eric Blake
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 2/9] qapi/block-core: add Qcow2Compress parameters Peter Lieven
` (7 subsequent siblings)
8 siblings, 1 reply; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
Signed-off-by: Peter Lieven <pl@kamp.de>
---
docs/interop/qcow2.txt | 35 ++++++++++++++++++++++++++++++++++-
1 file changed, 34 insertions(+), 1 deletion(-)
diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index d7fdb1f..c2d3dab 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -86,7 +86,12 @@ in the description of a field.
be written to (unless for regaining
consistency).
- Bits 2-63: Reserved (set to 0)
+ Bit 2: Compress format bit. If and only if this bit
+ is set then the compress format extension
+ MUST be present and MUST be parsed and checked
+ for compatibility.
+
+ Bits 3-63: Reserved (set to 0)
80 - 87: compatible_features
Bitmask of compatible features. An implementation can
@@ -137,6 +142,7 @@ be stored. Each extension has a structure like the following:
0x6803f857 - Feature name table
0x23852875 - Bitmaps extension
0x0537be77 - Full disk encryption header pointer
+ 0xC03183A3 - Compress format extension
other - Unknown header extension, can be safely
ignored
@@ -311,6 +317,33 @@ The algorithms used for encryption vary depending on the method
in the LUKS header, with the physical disk sector as the
input tweak.
+
+== Compress format extension ==
+
+The compress format extension is an optional header extension. It provides
+the ability to specify the compress algorithm and compress parameters
+that are used for compressed clusters. This new header MUST be present if
+the incompatible-feature bit "compress format bit" is set and MUST be absent
+otherwise.
+
+The fields of the compress format extension are:
+
+ Byte 0 - 15: compress_format_name (padded with zeros, but not
+ necessarily null terminated if it has full length).
+ Valid compression format names currently are:
+
+ zlib: Standard zlib deflate compression
+
+ 16: compress_level (uint8_t)
+
+ 0 = default compress level (valid for all formats, default)
+
+ Additional valid compression levels for zlib compression:
+
+ All values between 1 and 9. 1 gives best speed, 9 gives best
+ compression.
+
+
== Host cluster management ==
qcow2 manages the allocation of host clusters by maintaining a reference count
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add compress format extension
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add " Peter Lieven
@ 2017-07-14 14:52 ` Eric Blake
2017-07-14 21:56 ` Peter Lieven
0 siblings, 1 reply; 12+ messages in thread
From: Eric Blake @ 2017-07-14 14:52 UTC (permalink / raw)
To: Peter Lieven, qemu-block; +Cc: qemu-devel, kwolf, lersek, den, mreitz, berrange
[-- Attachment #1: Type: text/plain, Size: 3533 bytes --]
On 07/14/2017 04:56 AM, Peter Lieven wrote:
> Signed-off-by: Peter Lieven <pl@kamp.de>
> ---
> docs/interop/qcow2.txt | 35 ++++++++++++++++++++++++++++++++++-
> 1 file changed, 34 insertions(+), 1 deletion(-)
>
> diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
> index d7fdb1f..c2d3dab 100644
> --- a/docs/interop/qcow2.txt
> +++ b/docs/interop/qcow2.txt
> @@ -86,7 +86,12 @@ in the description of a field.
> be written to (unless for regaining
> consistency).
>
> - Bits 2-63: Reserved (set to 0)
> + Bit 2: Compress format bit. If and only if this bit
> + is set then the compress format extension
> + MUST be present and MUST be parsed and checked
> + for compatibility.
> +
> + Bits 3-63: Reserved (set to 0)
>
> 80 - 87: compatible_features
> Bitmask of compatible features. An implementation can
> @@ -137,6 +142,7 @@ be stored. Each extension has a structure like the following:
> 0x6803f857 - Feature name table
> 0x23852875 - Bitmaps extension
> 0x0537be77 - Full disk encryption header pointer
> + 0xC03183A3 - Compress format extension
> other - Unknown header extension, can be safely
> ignored
>
> @@ -311,6 +317,33 @@ The algorithms used for encryption vary depending on the method
> in the LUKS header, with the physical disk sector as the
> input tweak.
>
> +
> +== Compress format extension ==
> +
> +The compress format extension is an optional header extension. It provides
> +the ability to specify the compress algorithm and compress parameters
> +that are used for compressed clusters. This new header MUST be present if
> +the incompatible-feature bit "compress format bit" is set and MUST be absent
> +otherwise.
Probably worth mentioning that omitting the incompatible "Compress
format bit" is the same as setting it and populating the Compress format
extension with "zlib"/0. Don't know if that fits better here, or up
above at the incompatible feature bit section.
> +
> +The fields of the compress format extension are:
> +
> + Byte 0 - 15: compress_format_name (padded with zeros, but not
> + necessarily null terminated if it has full length).
> + Valid compression format names currently are:
> +
> + zlib: Standard zlib deflate compression
16 bytes,
> +
> + 16: compress_level (uint8_t)
+ 1, means you now have to pad the struct. I'd make the
compress_format_name be only 15 bits (bytes 0-14, compress_level at 15),
so that you have nice alignment without wasting padding.
> +
> + 0 = default compress level (valid for all formats, default)
> +
> + Additional valid compression levels for zlib compression:
> +
> + All values between 1 and 9. 1 gives best speed, 9 gives best
> + compression.
Is there a particular value between 1 and 9 that matches the output you
get when using 0?
--
Eric Blake, Principal Software Engineer
Red Hat, Inc. +1-919-301-3266
Virtualization: qemu.org | libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread
* Re: [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add compress format extension
2017-07-14 14:52 ` Eric Blake
@ 2017-07-14 21:56 ` Peter Lieven
0 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 21:56 UTC (permalink / raw)
To: Eric Blake, qemu-block; +Cc: qemu-devel, kwolf, lersek, den, mreitz, berrange
Am 14.07.2017 um 16:52 schrieb Eric Blake:
> On 07/14/2017 04:56 AM, Peter Lieven wrote:
>> Signed-off-by: Peter Lieven <pl@kamp.de>
>> ---
>> docs/interop/qcow2.txt | 35 ++++++++++++++++++++++++++++++++++-
>> 1 file changed, 34 insertions(+), 1 deletion(-)
>>
>> diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
>> index d7fdb1f..c2d3dab 100644
>> --- a/docs/interop/qcow2.txt
>> +++ b/docs/interop/qcow2.txt
>> @@ -86,7 +86,12 @@ in the description of a field.
>> be written to (unless for regaining
>> consistency).
>>
>> - Bits 2-63: Reserved (set to 0)
>> + Bit 2: Compress format bit. If and only if this bit
>> + is set then the compress format extension
>> + MUST be present and MUST be parsed and checked
>> + for compatibility.
>> +
>> + Bits 3-63: Reserved (set to 0)
>>
>> 80 - 87: compatible_features
>> Bitmask of compatible features. An implementation can
>> @@ -137,6 +142,7 @@ be stored. Each extension has a structure like the following:
>> 0x6803f857 - Feature name table
>> 0x23852875 - Bitmaps extension
>> 0x0537be77 - Full disk encryption header pointer
>> + 0xC03183A3 - Compress format extension
>> other - Unknown header extension, can be safely
>> ignored
>>
>> @@ -311,6 +317,33 @@ The algorithms used for encryption vary depending on the method
>> in the LUKS header, with the physical disk sector as the
>> input tweak.
>>
>> +
>> +== Compress format extension ==
>> +
>> +The compress format extension is an optional header extension. It provides
>> +the ability to specify the compress algorithm and compress parameters
>> +that are used for compressed clusters. This new header MUST be present if
>> +the incompatible-feature bit "compress format bit" is set and MUST be absent
>> +otherwise.
> Probably worth mentioning that omitting the incompatible "Compress
> format bit" is the same as setting it and populating the Compress format
> extension with "zlib"/0. Don't know if that fits better here, or up
> above at the incompatible feature bit section.
Its not exactly the same. Its zlib with default compression, but the old
default was to use 12 windowBits whereas windowBits are 15 when
the header is present. The reason behind this is that the inflate call
needs the maximum alllowed windowBits as parameter. In theory
it should fail if it has a 12 as parameter and receives an input stream
with 15. My zlib doesn't, but the docs say something else.
The change of the windowBits to 15 yields in about 15% better compression
time and about 5% better compression ratio.
>
>> +
>> +The fields of the compress format extension are:
>> +
>> + Byte 0 - 15: compress_format_name (padded with zeros, but not
>> + necessarily null terminated if it has full length).
>> + Valid compression format names currently are:
>> +
>> + zlib: Standard zlib deflate compression
> 16 bytes,
>
>> +
>> + 16: compress_level (uint8_t)
> + 1, means you now have to pad the struct. I'd make the
> compress_format_name be only 15 bits (bytes 0-14, compress_level at 15),
> so that you have nice alignment without wasting padding.
Good point, I will change that.
>
>> +
>> + 0 = default compress level (valid for all formats, default)
>> +
>> + Additional valid compression levels for zlib compression:
>> +
>> + All values between 1 and 9. 1 gives best speed, 9 gives best
>> + compression.
> Is there a particular value between 1 and 9 that matches the output you
> get when using 0?
>
Thats depending on what the macro Z_DEFAULT_COMPRESSION points to.
Its provided by libz. The zlib docs say it currently is set to level 6.
Peter
^ permalink raw reply [flat|nested] 12+ messages in thread
* [Qemu-devel] [PATCH V3 2/9] qapi/block-core: add Qcow2Compress parameters
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add " Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 3/9] block/qcow2: parse compress create options Peter Lieven
` (6 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
Signed-off-by: Peter Lieven <pl@kamp.de>
---
qapi/block-core.json | 38 ++++++++++++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/qapi/block-core.json b/qapi/block-core.json
index c437aa5..d6703a2 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -2447,6 +2447,44 @@
'*encrypt': 'BlockdevQcow2Encryption' } }
##
+# @Qcow2CompressFormat:
+# @zlib: standard zlib deflate compression
+#
+# Since: 2.10
+##
+{ 'enum': 'Qcow2CompressFormat',
+ 'data': [ 'zlib' ] }
+
+##
+# @Qcow2CompressZLib:
+#
+# Since: 2.10
+##
+{ 'struct': 'Qcow2CompressZLib',
+ 'data': { } }
+
+##
+# @Qcow2Compress:
+#
+# Specifies the compression format and compression level that should
+# be used for compressed Qcow2 clusters.
+#
+# @format: specifies the compression format to use. (defaults to zlib)
+#
+# @level: specifies the compression level. 0 = default compression,
+# 1 = fastest compression, x = highest compresion (x may very between
+# different compression formats)
+#
+# Since: 2.10
+##
+{ 'union': 'Qcow2Compress',
+ 'base': { 'format': 'Qcow2CompressFormat',
+ '*level': 'uint8' },
+ 'discriminator': 'format',
+ 'data': { 'zlib': 'Qcow2CompressZLib' } }
+
+
+##
# @BlockdevOptionsSsh:
#
# @server: host address
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 3/9] block/qcow2: parse compress create options
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 1/9] specs/qcow2: add " Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 2/9] qapi/block-core: add Qcow2Compress parameters Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 4/9] qemu-img: add documentation for compress settings Peter Lieven
` (5 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
this adds parsing and validation for the compress create
options. They are only validated but not yet used.
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2.c | 53 +++++++++++++++++++++++++++++++++++++++++++++--
include/block/block_int.h | 2 ++
2 files changed, 53 insertions(+), 2 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index c144ea5..6bf4ea5 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -31,6 +31,8 @@
#include "qapi/qmp/qerror.h"
#include "qapi/qmp/qbool.h"
#include "qapi/util.h"
+#include "qapi-visit.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp/types.h"
#include "qapi-event.h"
#include "trace.h"
@@ -2706,7 +2708,8 @@ 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, int refcount_order,
- const char *encryptfmt, Error **errp)
+ const char *encryptfmt, Qcow2Compress *compress,
+ Error **errp)
{
QDict *options;
@@ -2898,6 +2901,7 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
char *backing_file = NULL;
char *backing_fmt = NULL;
char *buf = NULL;
+ Qcow2Compress compress, *compress_ptr = NULL;
uint64_t size = 0;
int flags = 0;
size_t cluster_size = DEFAULT_CLUSTER_SIZE;
@@ -2975,9 +2979,43 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
refcount_order = ctz32(refcount_bits);
+ if (qemu_opt_get(opts, BLOCK_OPT_COMPRESS_FORMAT) ||
+ qemu_opt_get(opts, BLOCK_OPT_COMPRESS_LEVEL)) {
+ QDict *options, *compressopts = NULL;
+ Visitor *v;
+ options = qemu_opts_to_qdict(opts, NULL);
+ qdict_extract_subqdict(options, &compressopts, "compress.");
+ v = qobject_input_visitor_new_keyval(QOBJECT(compressopts));
+ visit_start_struct(v, NULL, NULL, 0, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ ret = -EINVAL;
+ goto finish;
+ }
+ visit_type_Qcow2Compress_members(v, &compress, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ ret = -EINVAL;
+ goto finish;
+ }
+ visit_end_struct(v, NULL);
+ visit_free(v);
+ QDECREF(compressopts);
+ QDECREF(options);
+ if (compress.format == QCOW2_COMPRESS_FORMAT_ZLIB &&
+ compress.level > 9) {
+ error_setg(errp, "Compress level %" PRIu8 " is not supported for"
+ " format '%s'", compress.level,
+ Qcow2CompressFormat_lookup[compress.format]);
+ ret = -EINVAL;
+ goto finish;
+ }
+ compress_ptr = &compress;
+ }
+
ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
cluster_size, prealloc, opts, version, refcount_order,
- encryptfmt, &local_err);
+ encryptfmt, compress_ptr, &local_err);
error_propagate(errp, local_err);
finish:
@@ -4287,6 +4325,17 @@ static QemuOptsList qcow2_create_opts = {
.help = "Width of a reference count entry in bits",
.def_value_str = "16"
},
+ {
+ .name = BLOCK_OPT_COMPRESS_FORMAT,
+ .type = QEMU_OPT_STRING,
+ .help = "Compress format used for compressed clusters (zlib)",
+ },
+ {
+ .name = BLOCK_OPT_COMPRESS_LEVEL,
+ .type = QEMU_OPT_NUMBER,
+ .help = "Compress level used for compressed clusters (0 = default,"
+ " 1=fastest, x=best; x varies depending on compress.format)",
+ },
{ /* end of list */ }
}
};
diff --git a/include/block/block_int.h b/include/block/block_int.h
index 669a279..eac61cd 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -57,6 +57,8 @@
#define BLOCK_OPT_NOCOW "nocow"
#define BLOCK_OPT_OBJECT_SIZE "object_size"
#define BLOCK_OPT_REFCOUNT_BITS "refcount_bits"
+#define BLOCK_OPT_COMPRESS_FORMAT "compress.format"
+#define BLOCK_OPT_COMPRESS_LEVEL "compress.level"
#define BLOCK_PROBE_BUF_SIZE 512
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 4/9] qemu-img: add documentation for compress settings
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (2 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 3/9] block/qcow2: parse compress create options Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 5/9] block/qcow2: read and write the compress format extension Peter Lieven
` (4 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
Signed-off-by: Peter Lieven <pl@kamp.de>
---
qemu-img.texi | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
diff --git a/qemu-img.texi b/qemu-img.texi
index f11f603..79b0182 100644
--- a/qemu-img.texi
+++ b/qemu-img.texi
@@ -669,6 +669,26 @@ file which is COW and has data blocks already, it couldn't be changed to NOCOW
by setting @code{nocow=on}. One can issue @code{lsattr filename} to check if
the NOCOW flag is set or not (Capital 'C' is NOCOW flag).
+@item compress.format
+Defines which compression algorithm is should be used for compressed clusters.
+The following options are available if support for the respective libraries
+has been enabled at compile time:
+
+ zlib Uses standard zlib compression
+
+The compression algorithm can only be defined at image create time and cannot
+be changed later.
+
+Note: defining a compression format will result in the compression format
+ extension being written to the Qcow2 image. Versions of QEMU before 2.10
+ will not be able to open images with this extension.
+
+@item compress.level
+Valid for compress.format=zlib defines the compression level to use for
+selected compression format. The default of @code{compress.level=0} will use
+the default compression level for the format. Alternate values range from 1 for
+fastest compression to 9 for the best compression.
+
@end table
@item Other
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 5/9] block/qcow2: read and write the compress format extension
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (3 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 4/9] qemu-img: add documentation for compress settings Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 6/9] block/qcow2: simplify ret usage in qcow2_create Peter Lieven
` (3 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
we now read the extension on open and write it on update, but
do not yet use it.
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2.c | 94 +++++++++++++++++++++++++++++++++++++++++++++++++++++++----
block/qcow2.h | 21 +++++++++----
2 files changed, 105 insertions(+), 10 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index 6bf4ea5..1dd2a48 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -70,6 +70,7 @@ typedef struct {
#define QCOW2_EXT_MAGIC_FEATURE_TABLE 0x6803f857
#define QCOW2_EXT_MAGIC_CRYPTO_HEADER 0x0537be77
#define QCOW2_EXT_MAGIC_BITMAPS 0x23852875
+#define QCOW2_EXT_MAGIC_COMPRESS_FORMAT 0xC03183A3
static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
{
@@ -164,6 +165,17 @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
}
+static void qcow2_compress_level_supported(int format, uint8_t level,
+ Error **errp)
+{
+ if (format == QCOW2_COMPRESS_FORMAT_ZLIB && level > 9) {
+ error_setg(errp, "ERROR: compress level %" PRIu8 " is not"
+ " supported for format '%s'", level,
+ Qcow2CompressFormat_lookup[format]);
+ }
+}
+
+
/*
* read qcow2 extension and fill bs
* start reading from start_offset
@@ -241,6 +253,48 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
#endif
break;
+ case QCOW2_EXT_MAGIC_COMPRESS_FORMAT:
+ {
+ Qcow2CompressFormatExt compress_ext;
+ Error *local_err = NULL;
+ if (ext.len != sizeof(compress_ext)) {
+ error_setg(errp, "ERROR: ext_compress_format: len=%"
+ PRIu32 " invalid (!=%zu)", ext.len,
+ sizeof(compress_ext));
+ return 2;
+ }
+ ret = bdrv_pread(bs->file, offset, &compress_ext,
+ ext.len);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret, "ERROR: ext_compress_fromat:"
+ " Could not read extension");
+ return 3;
+ }
+
+ s->compress_format =
+ qapi_enum_parse(Qcow2CompressFormat_lookup,
+ compress_ext.name, QCOW2_COMPRESS_FORMAT__MAX,
+ -1, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return 4;
+ }
+
+ qcow2_compress_level_supported(s->compress_format,
+ compress_ext.level, &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
+ return 5;
+ }
+ s->compress_level = compress_ext.level;
+
+#ifdef DEBUG_EXT
+ printf("Qcow2: Got compress format %s with compress level %"
+ PRIu8 "\n", Qcow2CompressFormat_lookup[s->compress_format],
+ s->compress_level);
+#endif
+ break;
+ }
case QCOW2_EXT_MAGIC_FEATURE_TABLE:
if (p_feature_table != NULL) {
void* feature_table = g_malloc0(ext.len + 2 * sizeof(Qcow2Feature));
@@ -1374,6 +1428,7 @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
s->cluster_cache_offset = -1;
s->flags = flags;
+ s->compress_format = -1;
ret = qcow2_refcount_init(bs);
if (ret != 0) {
@@ -2292,6 +2347,25 @@ int qcow2_update_header(BlockDriverState *bs)
buflen -= ret;
}
+ /* Compress Format header extension */
+ if (s->compress_format >= 0) {
+ Qcow2CompressFormatExt ext;
+ assert(s->compress_format < QCOW2_COMPRESS_FORMAT__MAX);
+ strncpy((char *) &ext.name,
+ Qcow2CompressFormat_lookup[s->compress_format],
+ sizeof(ext.name));
+ ext.level = s->compress_level;
+ ret = header_ext_add(buf, QCOW2_EXT_MAGIC_COMPRESS_FORMAT,
+ &ext, sizeof(ext),
+ buflen);
+ if (ret < 0) {
+ goto fail;
+ }
+ buf += ret;
+ buflen -= ret;
+ header->incompatible_features |= cpu_to_be64(QCOW2_INCOMPAT_COMPRESS);
+ }
+
/* Feature table */
if (s->qcow_version >= 3) {
Qcow2Feature features[] = {
@@ -2306,6 +2380,11 @@ int qcow2_update_header(BlockDriverState *bs)
.name = "corrupt bit",
},
{
+ .type = QCOW2_FEAT_TYPE_INCOMPATIBLE,
+ .bit = QCOW2_INCOMPAT_COMPRESS_BITNR,
+ .name = "compress format bit",
+ },
+ {
.type = QCOW2_FEAT_TYPE_COMPATIBLE,
.bit = QCOW2_COMPAT_LAZY_REFCOUNTS_BITNR,
.name = "lazy refcounts",
@@ -2827,6 +2906,12 @@ static int qcow2_create2(const char *filename, int64_t total_size,
abort();
}
+ if (compress) {
+ BDRVQcow2State *s = blk_bs(blk)->opaque;
+ s->compress_format = compress->format;
+ s->compress_level = compress->level;
+ }
+
/* Create a full header (including things like feature table) */
ret = qcow2_update_header(blk_bs(blk));
if (ret < 0) {
@@ -3002,11 +3087,10 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
visit_free(v);
QDECREF(compressopts);
QDECREF(options);
- if (compress.format == QCOW2_COMPRESS_FORMAT_ZLIB &&
- compress.level > 9) {
- error_setg(errp, "Compress level %" PRIu8 " is not supported for"
- " format '%s'", compress.level,
- Qcow2CompressFormat_lookup[compress.format]);
+ qcow2_compress_level_supported(compress.format, compress.level,
+ &local_err);
+ if (local_err) {
+ error_propagate(errp, local_err);
ret = -EINVAL;
goto finish;
}
diff --git a/block/qcow2.h b/block/qcow2.h
index 96a8d43..c48d29e 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -188,13 +188,16 @@ enum {
/* Incompatible feature bits */
enum {
- QCOW2_INCOMPAT_DIRTY_BITNR = 0,
- QCOW2_INCOMPAT_CORRUPT_BITNR = 1,
- QCOW2_INCOMPAT_DIRTY = 1 << QCOW2_INCOMPAT_DIRTY_BITNR,
- QCOW2_INCOMPAT_CORRUPT = 1 << QCOW2_INCOMPAT_CORRUPT_BITNR,
+ QCOW2_INCOMPAT_DIRTY_BITNR = 0,
+ QCOW2_INCOMPAT_CORRUPT_BITNR = 1,
+ QCOW2_INCOMPAT_COMPRESS_BITNR = 2,
+ QCOW2_INCOMPAT_DIRTY = 1 << QCOW2_INCOMPAT_DIRTY_BITNR,
+ QCOW2_INCOMPAT_CORRUPT = 1 << QCOW2_INCOMPAT_CORRUPT_BITNR,
+ QCOW2_INCOMPAT_COMPRESS = 1 << QCOW2_INCOMPAT_COMPRESS_BITNR,
QCOW2_INCOMPAT_MASK = QCOW2_INCOMPAT_DIRTY
- | QCOW2_INCOMPAT_CORRUPT,
+ | QCOW2_INCOMPAT_CORRUPT
+ | QCOW2_INCOMPAT_COMPRESS,
};
/* Compatible feature bits */
@@ -228,6 +231,11 @@ typedef struct Qcow2Feature {
char name[46];
} QEMU_PACKED Qcow2Feature;
+typedef struct Qcow2CompressFormatExt {
+ char name[16];
+ uint8_t level;
+} QEMU_PACKED Qcow2CompressFormatExt;
+
typedef struct Qcow2DiscardRegion {
BlockDriverState *bs;
uint64_t offset;
@@ -304,6 +312,9 @@ typedef struct BDRVQcow2State {
int refcount_bits;
uint64_t refcount_max;
+ int compress_format;
+ uint8_t compress_level;
+
Qcow2GetRefcountFunc *get_refcount;
Qcow2SetRefcountFunc *set_refcount;
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 6/9] block/qcow2: simplify ret usage in qcow2_create
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (4 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 5/9] block/qcow2: read and write the compress format extension Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 7/9] block/qcow2: optimize qcow2_co_pwritev_compressed Peter Lieven
` (2 subsequent siblings)
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2.c | 13 ++-----------
1 file changed, 2 insertions(+), 11 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index 1dd2a48..04b03de 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -2996,7 +2996,7 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
int refcount_order;
const char *encryptfmt = NULL;
Error *local_err = NULL;
- int ret;
+ int ret = -EINVAL;
/* Read out options */
size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
@@ -3008,7 +3008,6 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
if (qemu_opt_get_del(opts, BLOCK_OPT_ENCRYPT)) {
error_setg(errp, "Options " BLOCK_OPT_ENCRYPT " and "
BLOCK_OPT_ENCRYPT_FORMAT " are mutually exclusive");
- ret = -EINVAL;
goto finish;
}
} else if (qemu_opt_get_bool_del(opts, BLOCK_OPT_ENCRYPT, false)) {
@@ -3017,7 +3016,6 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
cluster_size = qcow2_opt_get_cluster_size_del(opts, &local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
@@ -3026,14 +3024,12 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
&local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
version = qcow2_opt_get_version_del(opts, &local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
@@ -3044,21 +3040,18 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
if (backing_file && prealloc != PREALLOC_MODE_OFF) {
error_setg(errp, "Backing file and preallocation cannot be used at "
"the same time");
- ret = -EINVAL;
goto finish;
}
if (version < 3 && (flags & BLOCK_FLAG_LAZY_REFCOUNTS)) {
error_setg(errp, "Lazy refcounts only supported with compatibility "
"level 1.1 and above (use compat=1.1 or greater)");
- ret = -EINVAL;
goto finish;
}
refcount_bits = qcow2_opt_get_refcount_bits_del(opts, version, &local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
@@ -3074,13 +3067,11 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
visit_start_struct(v, NULL, NULL, 0, &local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
visit_type_Qcow2Compress_members(v, &compress, &local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
visit_end_struct(v, NULL);
@@ -3091,12 +3082,12 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
&local_err);
if (local_err) {
error_propagate(errp, local_err);
- ret = -EINVAL;
goto finish;
}
compress_ptr = &compress;
}
+ /* ret is still -EINVAL until here */
ret = qcow2_create2(filename, size, backing_file, backing_fmt, flags,
cluster_size, prealloc, opts, version, refcount_order,
encryptfmt, compress_ptr, &local_err);
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 7/9] block/qcow2: optimize qcow2_co_pwritev_compressed
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (5 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 6/9] block/qcow2: simplify ret usage in qcow2_create Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 8/9] block/qcow2: start using the compress format extension Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 9/9] block/qcow2: add lzo compress format Peter Lieven
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
if we specify exactly one iov of s->cluster_size bytes we can avoid
the bounce buffer.
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2.c | 12 +++++++-----
1 file changed, 7 insertions(+), 5 deletions(-)
diff --git a/block/qcow2.c b/block/qcow2.c
index 04b03de..ecb4bd6 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -3393,7 +3393,7 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
struct iovec iov;
z_stream strm;
int ret, out_len;
- uint8_t *buf, *out_buf;
+ uint8_t *buf, *out_buf, *local_buf = NULL;
uint64_t cluster_offset;
if (bytes == 0) {
@@ -3403,8 +3403,8 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
return bdrv_truncate(bs->file, cluster_offset, PREALLOC_MODE_OFF, NULL);
}
- buf = qemu_blockalign(bs, s->cluster_size);
- if (bytes != s->cluster_size) {
+ if (bytes != s->cluster_size || qiov->niov != 1) {
+ buf = local_buf = qemu_blockalign(bs, s->cluster_size);
if (bytes > s->cluster_size ||
offset + bytes != bs->total_sectors << BDRV_SECTOR_BITS)
{
@@ -3413,8 +3413,10 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
}
/* Zero-pad last write if image size is not cluster aligned */
memset(buf + bytes, 0, s->cluster_size - bytes);
+ qemu_iovec_to_buf(qiov, 0, buf, bytes);
+ } else {
+ buf = qiov->iov[0].iov_base;
}
- qemu_iovec_to_buf(qiov, 0, buf, bytes);
out_buf = g_malloc(s->cluster_size);
@@ -3482,7 +3484,7 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
success:
ret = 0;
fail:
- qemu_vfree(buf);
+ qemu_vfree(local_buf);
g_free(out_buf);
return ret;
}
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 8/9] block/qcow2: start using the compress format extension
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (6 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 7/9] block/qcow2: optimize qcow2_co_pwritev_compressed Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 9/9] block/qcow2: add lzo compress format Peter Lieven
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
we now pass the parameters to the zlib compressor if the
extension is present and use the old default values if
the extension is absent.
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2-cluster.c | 58 ++++++++++++++++++++++++++++++---------------------
block/qcow2.c | 57 +++++++++++++++++++++++++++-----------------------
2 files changed, 65 insertions(+), 50 deletions(-)
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index f06c08f..6c14d59 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -1479,30 +1479,39 @@ again:
}
static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
- const uint8_t *buf, int buf_size)
+ const uint8_t *buf, int buf_size,
+ int compress_format)
{
- z_stream strm1, *strm = &strm1;
- int ret, out_len;
-
- memset(strm, 0, sizeof(*strm));
-
- strm->next_in = (uint8_t *)buf;
- strm->avail_in = buf_size;
- strm->next_out = out_buf;
- strm->avail_out = out_buf_size;
-
- ret = inflateInit2(strm, -12);
- if (ret != Z_OK)
- return -1;
- ret = inflate(strm, Z_FINISH);
- out_len = strm->next_out - out_buf;
- if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) ||
- out_len != out_buf_size) {
- inflateEnd(strm);
- return -1;
- }
- inflateEnd(strm);
- return 0;
+ int ret = 0, out_len;
+
+ switch (compress_format) {
+ case QCOW2_COMPRESS_FORMAT_ZLIB:
+ case -1: {
+ z_stream z_strm = {};
+
+ z_strm.next_in = (uint8_t *)buf;
+ z_strm.avail_in = buf_size;
+ z_strm.next_out = out_buf;
+ z_strm.avail_out = out_buf_size;
+
+ ret = inflateInit2(&z_strm, -15);
+ if (ret != Z_OK) {
+ return -1;
+ }
+ ret = inflate(&z_strm, Z_FINISH);
+ out_len = z_strm.next_out - out_buf;
+ ret = -(ret != Z_STREAM_END);
+ inflateEnd(&z_strm);
+ break;
+ }
+ default:
+ abort(); /* should never reach this point */
+ }
+
+ if (out_len != out_buf_size) {
+ ret = -1;
+ }
+ return ret;
}
int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
@@ -1523,7 +1532,8 @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
return ret;
}
if (decompress_buffer(s->cluster_cache, s->cluster_size,
- s->cluster_data + sector_offset, csize) < 0) {
+ s->cluster_data + sector_offset, csize,
+ s->compress_format) < 0) {
return -EIO;
}
s->cluster_cache_offset = coffset;
diff --git a/block/qcow2.c b/block/qcow2.c
index ecb4bd6..68b8d3a 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -3391,9 +3391,10 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
BDRVQcow2State *s = bs->opaque;
QEMUIOVector hd_qiov;
struct iovec iov;
- z_stream strm;
- int ret, out_len;
- uint8_t *buf, *out_buf, *local_buf = NULL;
+ z_stream z_strm = {};
+ int z_windowBits = -15, z_level = Z_DEFAULT_COMPRESSION;
+ int ret, out_len = 0;
+ uint8_t *buf, *out_buf = NULL, *local_buf = NULL;
uint64_t cluster_offset;
if (bytes == 0) {
@@ -3418,34 +3419,38 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
buf = qiov->iov[0].iov_base;
}
- out_buf = g_malloc(s->cluster_size);
+ switch (s->compress_format) {
+ case -1:
+ z_windowBits = -12;
+ case QCOW2_COMPRESS_FORMAT_ZLIB:
+ out_buf = g_malloc(s->cluster_size);
+ if (s->compress_level > 0) {
+ z_level = s->compress_level;
+ }
- /* best compression, small window, no zlib header */
- memset(&strm, 0, sizeof(strm));
- ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION,
- Z_DEFLATED, -12,
- 9, Z_DEFAULT_STRATEGY);
- if (ret != 0) {
- ret = -EINVAL;
- goto fail;
- }
+ ret = deflateInit2(&z_strm, z_level, Z_DEFLATED, z_windowBits, 9,
+ Z_DEFAULT_STRATEGY);
+ if (ret != Z_OK) {
+ ret = -EINVAL;
+ goto fail;
+ }
- strm.avail_in = s->cluster_size;
- strm.next_in = (uint8_t *)buf;
- strm.avail_out = s->cluster_size;
- strm.next_out = out_buf;
+ z_strm.avail_in = s->cluster_size;
+ z_strm.next_in = (uint8_t *)buf;
+ z_strm.avail_out = s->cluster_size;
+ z_strm.next_out = out_buf;
- ret = deflate(&strm, Z_FINISH);
- if (ret != Z_STREAM_END && ret != Z_OK) {
- deflateEnd(&strm);
- ret = -EINVAL;
- goto fail;
- }
- out_len = strm.next_out - out_buf;
+ ret = deflate(&z_strm, Z_FINISH);
+ out_len = z_strm.next_out - out_buf;
+ deflateEnd(&z_strm);
- deflateEnd(&strm);
+ ret = ret != Z_STREAM_END;
+ break;
+ default:
+ abort(); /* should never reach this point */
+ }
- if (ret != Z_STREAM_END || out_len >= s->cluster_size) {
+ if (ret || out_len >= s->cluster_size) {
/* could not compress: write normal cluster */
ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
if (ret < 0) {
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [Qemu-devel] [PATCH V3 9/9] block/qcow2: add lzo compress format
2017-07-14 9:56 [Qemu-devel] [PATCH V3 0/9] add Qcow2 compress format extension Peter Lieven
` (7 preceding siblings ...)
2017-07-14 9:56 ` [Qemu-devel] [PATCH V3 8/9] block/qcow2: start using the compress format extension Peter Lieven
@ 2017-07-14 9:56 ` Peter Lieven
8 siblings, 0 replies; 12+ messages in thread
From: Peter Lieven @ 2017-07-14 9:56 UTC (permalink / raw)
To: qemu-block
Cc: qemu-devel, kwolf, lersek, den, mreitz, eblake, berrange,
Peter Lieven
Signed-off-by: Peter Lieven <pl@kamp.de>
---
block/qcow2-cluster.c | 15 +++++++++++++++
block/qcow2.c | 42 +++++++++++++++++++++++++++++++++++-------
configure | 2 +-
qapi/block-core.json | 14 ++++++++++++--
qemu-img.texi | 1 +
5 files changed, 64 insertions(+), 10 deletions(-)
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index 6c14d59..7d47dde 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -24,6 +24,9 @@
#include "qemu/osdep.h"
#include <zlib.h>
+#ifdef CONFIG_LZO
+#include <lzo/lzo1x.h>
+#endif
#include "qapi/error.h"
#include "qemu-common.h"
@@ -1504,6 +1507,18 @@ static int decompress_buffer(uint8_t *out_buf, int out_buf_size,
inflateEnd(&z_strm);
break;
}
+#ifdef CONFIG_LZO
+ case QCOW2_COMPRESS_FORMAT_LZO:
+ out_len = out_buf_size;
+ ret = lzo1x_decompress_safe(buf, buf_size, out_buf,
+ (lzo_uint *) &out_len, NULL);
+ if (ret == LZO_E_INPUT_NOT_CONSUMED) {
+ /* We always read up to the next sector boundary. Thus
+ * buf_size may be larger than the original compressed size. */
+ ret = 0;
+ }
+ break;
+#endif
default:
abort(); /* should never reach this point */
}
diff --git a/block/qcow2.c b/block/qcow2.c
index 68b8d3a..2571f05 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -26,6 +26,9 @@
#include "sysemu/block-backend.h"
#include "qemu/module.h"
#include <zlib.h>
+#ifdef CONFIG_LZO
+#include <lzo/lzo1x.h>
+#endif
#include "block/qcow2.h"
#include "qemu/error-report.h"
#include "qapi/qmp/qerror.h"
@@ -165,10 +168,18 @@ static ssize_t qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
}
-static void qcow2_compress_level_supported(int format, uint8_t level,
+static void qcow2_compress_settings_supported(int format, uint8_t level,
Error **errp)
{
- if (format == QCOW2_COMPRESS_FORMAT_ZLIB && level > 9) {
+#ifndef CONFIG_LZO
+ if (format == QCOW2_COMPRESS_FORMAT_LZO) {
+ error_setg(errp, "ERROR: compress format '%s' is not supported",
+ Qcow2CompressFormat_lookup[format]);
+ return;
+ }
+#endif
+ if ((format == QCOW2_COMPRESS_FORMAT_ZLIB && level > 9) ||
+ (format == QCOW2_COMPRESS_FORMAT_LZO && level > 0)) {
error_setg(errp, "ERROR: compress level %" PRIu8 " is not"
" supported for format '%s'", level,
Qcow2CompressFormat_lookup[format]);
@@ -280,14 +291,22 @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
return 4;
}
- qcow2_compress_level_supported(s->compress_format,
- compress_ext.level, &local_err);
+ qcow2_compress_settings_supported(s->compress_format,
+ compress_ext.level, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return 5;
}
s->compress_level = compress_ext.level;
+#ifdef CONFIG_LZO
+ if (s->compress_format == QCOW2_COMPRESS_FORMAT_LZO &&
+ lzo_init() != LZO_E_OK) {
+ error_setg(errp, "ERROR: internal error - lzo_init() failed");
+ return 6;
+ }
+#endif
+
#ifdef DEBUG_EXT
printf("Qcow2: Got compress format %s with compress level %"
PRIu8 "\n", Qcow2CompressFormat_lookup[s->compress_format],
@@ -3078,8 +3097,8 @@ static int qcow2_create(const char *filename, QemuOpts *opts, Error **errp)
visit_free(v);
QDECREF(compressopts);
QDECREF(options);
- qcow2_compress_level_supported(compress.format, compress.level,
- &local_err);
+ qcow2_compress_settings_supported(compress.format, compress.level,
+ &local_err);
if (local_err) {
error_propagate(errp, local_err);
goto finish;
@@ -3394,7 +3413,7 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
z_stream z_strm = {};
int z_windowBits = -15, z_level = Z_DEFAULT_COMPRESSION;
int ret, out_len = 0;
- uint8_t *buf, *out_buf = NULL, *local_buf = NULL;
+ uint8_t *buf, *out_buf = NULL, *local_buf = NULL, *work_buf = NULL;
uint64_t cluster_offset;
if (bytes == 0) {
@@ -3446,6 +3465,14 @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
ret = ret != Z_STREAM_END;
break;
+#ifdef CONFIG_LZO
+ case QCOW2_COMPRESS_FORMAT_LZO:
+ out_buf = g_malloc(s->cluster_size + s->cluster_size / 16 + 64 + 3);
+ work_buf = g_malloc(LZO1X_1_MEM_COMPRESS);
+ ret = lzo1x_1_compress(buf, s->cluster_size, out_buf,
+ (lzo_uint *) &out_len, work_buf);
+ break;
+#endif
default:
abort(); /* should never reach this point */
}
@@ -3491,6 +3518,7 @@ success:
fail:
qemu_vfree(local_buf);
g_free(out_buf);
+ g_free(work_buf);
return ret;
}
diff --git a/configure b/configure
index 902653a..42e6ad0 100755
--- a/configure
+++ b/configure
@@ -1976,7 +1976,7 @@ if test "$lzo" != "no" ; then
int main(void) { lzo_version(); return 0; }
EOF
if compile_prog "" "-llzo2" ; then
- libs_softmmu="$libs_softmmu -llzo2"
+ LIBS="$LIBS -llzo2"
lzo="yes"
else
if test "$lzo" = "yes"; then
diff --git a/qapi/block-core.json b/qapi/block-core.json
index d6703a2..a368829 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -2449,11 +2449,12 @@
##
# @Qcow2CompressFormat:
# @zlib: standard zlib deflate compression
+# @lzo: lzo1x compression
#
# Since: 2.10
##
{ 'enum': 'Qcow2CompressFormat',
- 'data': [ 'zlib' ] }
+ 'data': [ 'zlib', 'lzo' ] }
##
# @Qcow2CompressZLib:
@@ -2464,6 +2465,14 @@
'data': { } }
##
+# @Qcow2CompressLZO:
+#
+# Since: 2.10
+##
+{ 'struct': 'Qcow2CompressLZO',
+ 'data': { } }
+
+##
# @Qcow2Compress:
#
# Specifies the compression format and compression level that should
@@ -2481,7 +2490,8 @@
'base': { 'format': 'Qcow2CompressFormat',
'*level': 'uint8' },
'discriminator': 'format',
- 'data': { 'zlib': 'Qcow2CompressZLib' } }
+ 'data': { 'zlib': 'Qcow2CompressZLib',
+ 'lzo': 'Qcow2CompressLZO' } }
##
diff --git a/qemu-img.texi b/qemu-img.texi
index 79b0182..6ce2a02 100644
--- a/qemu-img.texi
+++ b/qemu-img.texi
@@ -675,6 +675,7 @@ The following options are available if support for the respective libraries
has been enabled at compile time:
zlib Uses standard zlib compression
+ lzo Uses LZO1X compression
The compression algorithm can only be defined at image create time and cannot
be changed later.
--
1.9.1
^ permalink raw reply related [flat|nested] 12+ messages in thread