The following changes since commit 8c1ecb590497b0349c550607db923972b37f6963:

Merge remote-tracking branch 'remotes/stsquad/tags/pull-testing-next-280519-2' into staging (2019-05-28 17:38:32 +0100)

https://github.com/XanClic/qemu.git tags/pull-block-2019-05-28

for you to fetch changes up to a2d665c1bc3624a8375e2f9a7d569f7565cc1358:

blockdev: loosen restrictions on drive-backup source node (2019-05-28 20:30:55 +0200)

- qcow2: Use threads for encrypted I/O

- qemu-img rebase: Optimizations

- backup job: Allow any source node, and some refactoring

- Some general simplifications in the block layer

Alberto Garcia (2):

block: Use bdrv_unref_child() for all children in bdrv_close()

block: Make bdrv_root_attach_child() unref child_bs on failure

Andrey Shinkevich (1):

qcow2-bitmap: initialize bitmap directory alignment

Anton Nefedov (1):

qcow2: skip writing zero buffers to empty COW areas

John Snow (1):

blockdev: loosen restrictions on drive-backup source node

Sam Eiderman (3):

qemu-img: rebase: Reuse parent BlockDriverState

qemu-img: rebase: Reduce reads on in-chain rebase

qemu-img: rebase: Reuse in-chain BlockDriverState

Vladimir Sementsov-Ogievskiy (13):

qcow2.h: add missing include

qcow2: add separate file for threaded data processing functions

qcow2-threads: use thread_pool_submit_co

qcow2-threads: qcow2_co_do_compress: protect queuing by mutex

qcow2-threads: split out generic path

qcow2: qcow2_co_preadv: improve locking

qcow2: bdrv_co_pwritev: move encryption code out of the lock

qcow2: do encryption in threads

block/backup: simplify backup_incremental_init_copy_bitmap

block/backup: move to copy_bitmap with granularity

block/backup: refactor and tolerate unallocated cluster skipping

block/backup: unify different modes code path

block/backup: refactor: split out backup_calculate_cluster_size

block/Makefile.objs | 2 +-

qapi/block-core.json | 4 +-

block/qcow2.h | 26 ++-

block.c | 46 +++---

block/backup.c | 243 ++++++++++++---------------

block/block-backend.c | 3 +-

block/qcow2-bitmap.c | 3 +-

block/qcow2-cache.c | 1 -

block/qcow2-cluster.c | 10 +-

block/qcow2-refcount.c | 1 -

block/qcow2-snapshot.c | 1 -

block/qcow2-threads.c | 268 ++++++++++++++++++++++++++++++

block/qcow2.c | 320 +++++++++++++-----------------------

block/quorum.c | 1 -

blockdev.c | 7 +-

blockjob.c | 2 +-

qemu-img.c | 85 ++++++----

tests/test-bdrv-drain.c | 6 -

tests/test-bdrv-graph-mod.c | 1 -

block/trace-events | 1 +

tests/qemu-iotests/056 | 2 +-

tests/qemu-iotests/060 | 7 +-

tests/qemu-iotests/060.out | 5 +-

23 files changed, 615 insertions(+), 430 deletions(-)

create mode 100644 block/qcow2-threads.c

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Split out cluster_size calculation. Move copy-bitmap creation above

block-job creation, as we are going to share it with upcoming

backup-top filter, which also should be created before actual block job

creation.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Message-id: 20190429090842.57910-6-vsementsov@virtuozzo.com

[mreitz: Dropped a paragraph from the commit message that was left over

from a previous version]

block/backup.c | 82 ++++++++++++++++++++++++++++++++------------------

1 file changed, 52 insertions(+), 30 deletions(-)

diff --git a/block/backup.c b/block/backup.c

--- a/block/backup.c

+++ b/block/backup.c

@@ -XXX,XX +XXX,XX @@ static const BlockJobDriver backup_job_driver = {

.drain = backup_drain,

};

+static int64_t backup_calculate_cluster_size(BlockDriverState *target,

+ Error **errp)

+ int ret;

+ BlockDriverInfo bdi;

+ /*

+ * If there is no backing file on the target, we cannot rely on COW if our

+ * backup cluster size is smaller than the target cluster size. Even for

+ * targets with a backing file, try to avoid COW if possible.

+ */

+ ret = bdrv_get_info(target, &bdi);

+ if (ret == -ENOTSUP && !target->backing) {

+ /* Cluster size is not defined */

+ warn_report("The target block device doesn't provide "

+ "information about the block size and it doesn't have a "

+ "backing file. The default block size of %u bytes is "

+ "used. If the actual block size of the target exceeds "

+ "this default, the backup may be unusable",

+ BACKUP_CLUSTER_SIZE_DEFAULT);

+ return BACKUP_CLUSTER_SIZE_DEFAULT;

+ } else if (ret < 0 && !target->backing) {

+ error_setg_errno(errp, -ret,

+ "Couldn't determine the cluster size of the target image, "

+ "which has no backing file");

+ error_append_hint(errp,

+ "Aborting, since this may create an unusable destination image\n");

+ return ret;

+ } else if (ret < 0 && target->backing) {

+ /* Not fatal; just trudge on ahead. */

+ return BACKUP_CLUSTER_SIZE_DEFAULT;

+ return MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);

+}

BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

BlockDriverState *target, int64_t speed,

MirrorSyncMode sync_mode, BdrvDirtyBitmap *sync_bitmap,

@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

JobTxn *txn, Error **errp)

{

int64_t len;

- BlockDriverInfo bdi;

BackupBlockJob *job = NULL;

int ret;

+ int64_t cluster_size;

+ HBitmap *copy_bitmap = NULL;

assert(bs);

assert(target);

@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

goto error;

}

+ cluster_size = backup_calculate_cluster_size(target, errp);

+ if (cluster_size < 0) {

+ copy_bitmap = hbitmap_alloc(len, ctz32(cluster_size));

/* job->len is fixed, so we can't allow resize */

job = block_job_create(job_id, &backup_job_driver, txn, bs,

BLK_PERM_CONSISTENT_READ,

@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

/* Detect image-fleecing (and similar) schemes */

job->serialize_target_writes = bdrv_chain_contains(target, bs);

-

- /* If there is no backing file on the target, we cannot rely on COW if our

- * backup cluster size is smaller than the target cluster size. Even for

- * targets with a backing file, try to avoid COW if possible. */

- ret = bdrv_get_info(target, &bdi);

- if (ret == -ENOTSUP && !target->backing) {

- /* Cluster size is not defined */

- warn_report("The target block device doesn't provide "

- "information about the block size and it doesn't have a "

- "backing file. The default block size of %u bytes is "

- "used. If the actual block size of the target exceeds "

- "this default, the backup may be unusable",

- BACKUP_CLUSTER_SIZE_DEFAULT);

- job->cluster_size = BACKUP_CLUSTER_SIZE_DEFAULT;

- } else if (ret < 0 && !target->backing) {

- error_setg_errno(errp, -ret,

- "Couldn't determine the cluster size of the target image, "

- "which has no backing file");

- error_append_hint(errp,

- "Aborting, since this may create an unusable destination image\n");

- goto error;

- } else if (ret < 0 && target->backing) {

- /* Not fatal; just trudge on ahead. */

- job->cluster_size = BACKUP_CLUSTER_SIZE_DEFAULT;

- } else {

- job->cluster_size = MAX(BACKUP_CLUSTER_SIZE_DEFAULT, bdi.cluster_size);

- }

-

- job->copy_bitmap = hbitmap_alloc(len, ctz32(job->cluster_size));

+ job->cluster_size = cluster_size;

+ job->copy_bitmap = copy_bitmap;

+ copy_bitmap = NULL;

job->use_copy_range = true;

job->copy_range_size = MIN_NON_ZERO(blk_get_max_transfer(job->common.blk),

blk_get_max_transfer(job->target));

@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,

return &job->common;

error:

+ if (copy_bitmap) {

+ assert(!job || !job->copy_bitmap);

+ hbitmap_free(copy_bitmap);

if (sync_bitmap) {

bdrv_reclaim_dirty_bitmap(bs, sync_bitmap, NULL);

From: Alberto Garcia <berto@igalia.com>

A consequence of the previous patch is that bdrv_attach_child()

transfers the reference to child_bs from the caller to parent_bs,

which will drop it on bdrv_close() or when someone calls

bdrv_unref_child().

But this only happens when bdrv_attach_child() succeeds. If it fails

then the caller is responsible for dropping the reference to child_bs.

This patch makes bdrv_attach_child() take the reference also when

there is an error, freeing the caller for having to do it.

A similar situation happens with bdrv_root_attach_child(), so the

changes on this patch affect both functions.

Signed-off-by: Alberto Garcia <berto@igalia.com>

Message-id: 20dfb3d9ccec559cdd1a9690146abad5d204a186.1557754872.git.berto@igalia.com

[mreitz: Removed now superfluous BdrvChild * variable in

bdrv_open_child()]

block.c | 30 ++++++++++++++++++------------

block/block-backend.c | 3 +--

block/quorum.c | 1 -

blockjob.c | 2 +-

4 files changed, 20 insertions(+), 16 deletions(-)

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)

}

+/*

+ * This function steals the reference to child_bs from the caller.

+ * That reference is later dropped by bdrv_root_unref_child().

+ *

+ * On failure NULL is returned, errp is set and the reference to

+ * child_bs is also dropped.

+ */

BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,

const char *child_name,

const BdrvChildRole *child_role,

@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,

ret = bdrv_check_update_perm(child_bs, NULL, perm, shared_perm, NULL, errp);

if (ret < 0) {

bdrv_abort_perm_update(child_bs);

+ bdrv_unref(child_bs);

return NULL;

}

@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,

return child;

}

+/*

+ * This function transfers the reference to child_bs from the caller

+ * to parent_bs. That reference is later dropped by parent_bs on

+ * bdrv_close() or if someone calls bdrv_unref_child().

+ *

+ * On failure NULL is returned, errp is set and the reference to

+ * child_bs is also dropped.

+ */

BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,

BlockDriverState *child_bs,

const char *child_name,

@@ -XXX,XX +XXX,XX @@ void bdrv_set_backing_hd(BlockDriverState *bs, BlockDriverState *backing_hd,

/* If backing_hd was already part of bs's backing chain, and

* inherits_from pointed recursively to bs then let's update it to

* point directly to bs (else it will become NULL). */

- if (update_inherits_from) {

+ if (bs->backing && update_inherits_from) {

backing_hd->inherits_from = bs;

}

- if (!bs->backing) {

- bdrv_unref(backing_hd);

- }

bdrv_refresh_limits(bs, NULL);

@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,

const BdrvChildRole *child_role,

bool allow_none, Error **errp)

{

- BdrvChild *c;

BlockDriverState *bs;

bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,

@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,

return NULL;

}

- c = bdrv_attach_child(parent, bs, bdref_key, child_role, errp);

- if (!c) {

- bdrv_unref(bs);

- return NULL;

- }

-

- return c;

+ return bdrv_attach_child(parent, bs, bdref_key, child_role, errp);

}

/* TODO Future callers may need to specify parent/child_role in order for

diff --git a/block/block-backend.c b/block/block-backend.c

index XXXXXXX..XXXXXXX 100644

--- a/block/block-backend.c

+++ b/block/block-backend.c

@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new_open(const char *filename, const char *reference,

blk->root = bdrv_root_attach_child(bs, "root", &child_root,

perm, BLK_PERM_ALL, blk, errp);

if (!blk->root) {

- bdrv_unref(bs);

blk_unref(blk);

return NULL;

}

@@ -XXX,XX +XXX,XX @@ void blk_remove_bs(BlockBackend *blk)

int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)

{

ThrottleGroupMember *tgm = &blk->public.throttle_group_member;

+ bdrv_ref(bs);

blk->root = bdrv_root_attach_child(bs, "root", &child_root,

blk->perm, blk->shared_perm, blk, errp);

if (blk->root == NULL) {

return -EPERM;

}

- bdrv_ref(bs);

notifier_list_notify(&blk->insert_bs_notifiers, blk);

if (tgm->throttle_state) {

diff --git a/block/quorum.c b/block/quorum.c

index XXXXXXX..XXXXXXX 100644

--- a/block/quorum.c

+++ b/block/quorum.c

@@ -XXX,XX +XXX,XX @@ static void quorum_add_child(BlockDriverState *bs, BlockDriverState *child_bs,

child = bdrv_attach_child(bs, child_bs, indexstr, &child_format, errp);

if (child == NULL) {

s->next_child_index--;

- bdrv_unref(child_bs);

goto out;

}

s->children = g_renew(BdrvChild *, s->children, s->num_children + 1);

diff --git a/blockjob.c b/blockjob.c

index XXXXXXX..XXXXXXX 100644

--- a/blockjob.c

+++ b/blockjob.c

@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,

{

BdrvChild *c;

+ bdrv_ref(bs);

c = bdrv_root_attach_child(bs, name, &child_job, perm, shared_perm,

job, errp);

if (c == NULL) {

@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,

}

job->nodes = g_slist_prepend(job->nodes, c);

- bdrv_ref(bs);

bdrv_op_block_all(bs, job->blocker);

return 0;

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Move compression-on-threads to separate file. Encryption will be in it

too.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Reviewed-by: Alberto Garcia <berto@igalia.com>

block/Makefile.objs | 2 +-

block/qcow2.h | 7 ++

block/qcow2-threads.c | 201 ++++++++++++++++++++++++++++++++++++++++++

block/qcow2.c | 169 -----------------------------------

4 files changed, 209 insertions(+), 170 deletions(-)

create mode 100644 block/qcow2-threads.c

diff --git a/block/Makefile.objs b/block/Makefile.objs

index XXXXXXX..XXXXXXX 100644

--- a/block/Makefile.objs

+++ b/block/Makefile.objs

@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_BOCHS) += bochs.o

block-obj-$(CONFIG_VVFAT) += vvfat.o

block-obj-$(CONFIG_DMG) += dmg.o

-block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o qcow2-bitmap.o

+block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o qcow2-bitmap.o qcow2-threads.o

block-obj-$(CONFIG_QED) += qed.o qed-l2-cache.o qed-table.o qed-cluster.o

block-obj-$(CONFIG_QED) += qed-check.o

block-obj-y += vhdx.o vhdx-endian.o vhdx-log.o

diff --git a/block/qcow2.h b/block/qcow2.h

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2.h

+++ b/block/qcow2.h

@@ -XXX,XX +XXX,XX @@ void qcow2_remove_persistent_dirty_bitmap(BlockDriverState *bs,

const char *name,

Error **errp);

+ssize_t coroutine_fn

+qcow2_co_compress(BlockDriverState *bs, void *dest, size_t dest_size,

+ const void *src, size_t src_size);

+ssize_t coroutine_fn

+qcow2_co_decompress(BlockDriverState *bs, void *dest, size_t dest_size,

+ const void *src, size_t src_size);

+

#endif

diff --git a/block/qcow2-threads.c b/block/qcow2-threads.c

+++ b/block/qcow2-threads.c

+/*

+ * Threaded data processing for Qcow2: compression, encryption

+ *

+ * Copyright (c) 2004-2006 Fabrice Bellard

+ * Copyright (c) 2018 Virtuozzo International GmbH. All rights reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy

+ * of this software and associated documentation files (the "Software"), to deal

+ * in the Software without restriction, including without limitation the rights

+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

+ * copies of the Software, and to permit persons to whom the Software is

+ * furnished to do so, subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in

+ * all copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

+ * THE SOFTWARE.

+ */

+

+#include "qemu/osdep.h"

+

+#define ZLIB_CONST

+#include <zlib.h>

+

+#include "qcow2.h"

+#include "block/thread-pool.h"

+

+#define MAX_COMPRESS_THREADS 4

+

+typedef ssize_t (*Qcow2CompressFunc)(void *dest, size_t dest_size,

+ const void *src, size_t src_size);

+typedef struct Qcow2CompressData {

+ void *dest;

+ size_t dest_size;

+ const void *src;

+ size_t src_size;

+ ssize_t ret;

+

+ Qcow2CompressFunc func;

+} Qcow2CompressData;

+

+/*

+ * qcow2_compress()

+ *

+ * @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

+ */

+static ssize_t qcow2_compress(void *dest, size_t dest_size,

+ const void *src, size_t src_size)

+{

+ ssize_t ret;

+ z_stream strm;

+

+ /* 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 != Z_OK) {

+ return -EIO;

+ }

+

+ /*

+ * strm.next_in is not const in old zlib versions, such as those used on

+ * OpenBSD/NetBSD, so cast the const away

+ */

+ strm.avail_in = src_size;

+ strm.next_in = (void *) src;

+ strm.avail_out = dest_size;

+ strm.next_out = dest;

+

+ ret = deflate(&strm, Z_FINISH);

+ if (ret == Z_STREAM_END) {

+ ret = dest_size - strm.avail_out;

+ } else {

+ ret = (ret == Z_OK ? -ENOMEM : -EIO);

+ }

+

+ deflateEnd(&strm);

+

+ return ret;

+}

+

+/*

+ * qcow2_decompress()

+ *

+ * Decompress some data (not more than @src_size bytes) to produce exactly

+ * @dest_size bytes.

+ *

+ * @dest - destination buffer, @dest_size bytes

+ * @src - source buffer, @src_size bytes

+ *

+ * Returns: 0 on success

+ * -1 on fail

+ */

+static ssize_t qcow2_decompress(void *dest, size_t dest_size,

+ const void *src, size_t src_size)

+{

+ int ret = 0;

+ z_stream strm;

+

+ memset(&strm, 0, sizeof(strm));

+ strm.avail_in = src_size;

+ strm.next_in = (void *) src;

+ strm.avail_out = dest_size;

+ strm.next_out = dest;

+

+ ret = inflateInit2(&strm, -12);

+ if (ret != Z_OK) {

+ return -1;

+ }

+

+ ret = inflate(&strm, Z_FINISH);

+ if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || strm.avail_out != 0) {

+ /*

+ * We approve Z_BUF_ERROR because we need @dest buffer to be filled, but

+ * @src buffer may be processed partly (because in qcow2 we know size of

+ * compressed data with precision of one sector)

+ */

+ ret = -1;

+ }

+

+ inflateEnd(&strm);

+

+ return ret;

+}

+

+static int qcow2_compress_pool_func(void *opaque)

+{

+ Qcow2CompressData *data = opaque;

+

+ data->ret = data->func(data->dest, data->dest_size,

+ data->src, data->src_size);

+

+ return 0;

+}

+

+static void qcow2_compress_complete(void *opaque, int ret)

+{

+ qemu_coroutine_enter(opaque);

+}

+

+static ssize_t coroutine_fn

+qcow2_co_do_compress(BlockDriverState *bs, void *dest, size_t dest_size,

+ const void *src, size_t src_size, Qcow2CompressFunc func)

+{

+ BDRVQcow2State *s = bs->opaque;

+ BlockAIOCB *acb;

+ ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));

+ Qcow2CompressData arg = {

+ .dest = dest,

+ .dest_size = dest_size,

+ .src = src,

+ .src_size = src_size,

+ .func = func,

+ };

+

+ while (s->nb_compress_threads >= MAX_COMPRESS_THREADS) {

+ qemu_co_queue_wait(&s->compress_wait_queue, NULL);

+ }

+

+ s->nb_compress_threads++;

+ acb = thread_pool_submit_aio(pool, qcow2_compress_pool_func, &arg,

+ qcow2_compress_complete,

+ qemu_coroutine_self());

+

+ if (!acb) {

+ s->nb_compress_threads--;

+ return -EINVAL;

+ }

+ qemu_coroutine_yield();

+ s->nb_compress_threads--;

+ qemu_co_queue_next(&s->compress_wait_queue);

+

+ return arg.ret;

+}

+

+ssize_t coroutine_fn

+qcow2_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);

+}

+

+ssize_t coroutine_fn

+qcow2_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);

+}

diff --git a/block/qcow2.c b/block/qcow2.c

index XXXXXXX..XXXXXXX 100644

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@

#include "qemu/osdep.h"

-#define ZLIB_CONST

-#include <zlib.h>

-

#include "block/qdict.h"

#include "sysemu/block-backend.h"

#include "qemu/module.h"

@@ -XXX,XX +XXX,XX @@

#include "qapi/qobject-input-visitor.h"

#include "qapi/qapi-visit-block-core.h"

#include "crypto.h"

-#include "block/thread-pool.h"

/*

Differences with QCOW:

@@ -XXX,XX +XXX,XX @@ fail:

return ret;

-/*

- * qcow2_compress()

- *

- * @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

- */

-static ssize_t qcow2_compress(void *dest, size_t dest_size,

- const void *src, size_t src_size)

-{

- ssize_t ret;

- z_stream strm;

-

- /* 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 != Z_OK) {

- return -EIO;

- }

-

- /* strm.next_in is not const in old zlib versions, such as those used on

- * OpenBSD/NetBSD, so cast the const away */

- strm.avail_in = src_size;

- strm.next_in = (void *) src;

- strm.avail_out = dest_size;

- strm.next_out = dest;

-

- ret = deflate(&strm, Z_FINISH);

- if (ret == Z_STREAM_END) {

- ret = dest_size - strm.avail_out;

- } else {

- ret = (ret == Z_OK ? -ENOMEM : -EIO);

- }

-

- deflateEnd(&strm);

-

- return ret;

-}

-

-/*

- * qcow2_decompress()

- *

- * Decompress some data (not more than @src_size bytes) to produce exactly

- * @dest_size bytes.

- *

- * @dest - destination buffer, @dest_size bytes

- * @src - source buffer, @src_size bytes

- *

- * Returns: 0 on success

- * -1 on fail

- */

-static ssize_t qcow2_decompress(void *dest, size_t dest_size,

- const void *src, size_t src_size)

-{

- int ret = 0;

- z_stream strm;

-

- memset(&strm, 0, sizeof(strm));

- strm.avail_in = src_size;

- strm.next_in = (void *) src;

- strm.avail_out = dest_size;

- strm.next_out = dest;

-

- ret = inflateInit2(&strm, -12);

- if (ret != Z_OK) {

- return -1;

- }

-

- ret = inflate(&strm, Z_FINISH);

- if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || strm.avail_out != 0) {

- /* We approve Z_BUF_ERROR because we need @dest buffer to be filled, but

- * @src buffer may be processed partly (because in qcow2 we know size of

- * compressed data with precision of one sector) */

- ret = -1;

- }

-

- inflateEnd(&strm);

-

- return ret;

-}

-

-#define MAX_COMPRESS_THREADS 4

-

-typedef ssize_t (*Qcow2CompressFunc)(void *dest, size_t dest_size,

- const void *src, size_t src_size);

-typedef struct Qcow2CompressData {

- void *dest;

- size_t dest_size;

- const void *src;

- size_t src_size;

- ssize_t ret;

-

- Qcow2CompressFunc func;

-} Qcow2CompressData;

-

-static int qcow2_compress_pool_func(void *opaque)

-{

- Qcow2CompressData *data = opaque;

-

- data->ret = data->func(data->dest, data->dest_size,

- data->src, data->src_size);

-

- return 0;

-}

-

-static void qcow2_compress_complete(void *opaque, int ret)

-{

- qemu_coroutine_enter(opaque);

-}

-

-static ssize_t coroutine_fn

-qcow2_co_do_compress(BlockDriverState *bs, void *dest, size_t dest_size,

- const void *src, size_t src_size, Qcow2CompressFunc func)

-{

- BDRVQcow2State *s = bs->opaque;

- BlockAIOCB *acb;

- ThreadPool *pool = aio_get_thread_pool(bdrv_get_aio_context(bs));

- Qcow2CompressData arg = {

- .dest = dest,

- .dest_size = dest_size,

- .src = src,

- .src_size = src_size,

- .func = func,

- };

-

- while (s->nb_compress_threads >= MAX_COMPRESS_THREADS) {

- qemu_co_queue_wait(&s->compress_wait_queue, NULL);

- }

-

- s->nb_compress_threads++;

- acb = thread_pool_submit_aio(pool, qcow2_compress_pool_func, &arg,

- qcow2_compress_complete,

- qemu_coroutine_self());

-

- if (!acb) {

- s->nb_compress_threads--;

- return -EINVAL;

- }

- qemu_coroutine_yield();

- s->nb_compress_threads--;

- qemu_co_queue_next(&s->compress_wait_queue);

-

- return arg.ret;

-}

-

-static ssize_t coroutine_fn

-qcow2_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);

-}

-

-static ssize_t coroutine_fn

-qcow2_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);

-}

-

/* XXX: put compressed sectors first, then all the cluster aligned

tables to avoid losing bytes in alignment */

static coroutine_fn int