The following changes since commit 22d96eac64877c4d96f9928babb6f2fcc68faacf:

Merge remote-tracking branch 'remotes/stefanha/tags/tracing-pull-request' into staging (2019-04-29 19:11:15 +0100)

are available in the Git repository at:

for you to fetch changes up to 54277a2aab876aba7b55c7e88e2b372691849741:

block/qed: add missed coroutine_fn markers (2019-04-30 15:29:00 +0200)

Block layer patches:

- iotests: Fix output of qemu-io related tests

- Don't ignore bdrv_set_aio_context() for nodes with bs->drv = NUL

- vmdk: Set vmdk parent backing_format to vmdk

- qcow2: Preallocation fixes (especially for external data files)

- Add linear-buffer-based APIs (as wrappers around qiov-based ones)

- Various code cleanups and small corner case fixes

Alberto Garcia (3):

qcow2: Fix error handling in the compression code

commit: Make base read-only if there is an early failure

iotests: Check that images are in read-only mode after block-commit

Eric Blake (2):

cutils: Fix size_to_str() on 32-bit platforms

qemu-img: Saner printing of large file sizes

Kevin Wolf (5):

block: Fix AioContext switch for bs->drv == NULL

qcow2: Avoid COW during metadata preallocation

qcow2: Add errp to preallocate_co()

qcow2: Fix full preallocation with external data file

qcow2: Fix qcow2_make_empty() with external data file

Max Reitz (2):

iotests: Perform the correct test in 082

qemu-img: Make create hint at protocol options

Sam Eiderman (1):

vmdk: Set vmdk parent backing_format to vmdk

Stefano Garzarella (2):

block/vhdx: Remove redundant IEC binary prefixes definition

block/vhdx: Use IEC binary prefixes for size constants

Thomas Huth (1):

tests/qemu-iotests: Fix output of qemu-io related tests

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

Move to _co_ versions of io functions qed_read_table() and

qed_write_table(), as we use qemu_co_mutex_unlock()

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

block/qed-table.c | 12 +++++-------

block/qed.c | 6 ++----

2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/block/qed-table.c b/block/qed-table.c

--- a/block/qed-table.c

+++ b/block/qed-table.c

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

/* Called with table_lock held. */

static int qed_read_table(BDRVQEDState *s, uint64_t offset, QEDTable *table)

- QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(

- qiov, table->offsets, s->header.cluster_size * s->header.table_size);

+ unsigned int bytes = s->header.cluster_size * s->header.table_size;

int noffsets;

int i, ret;

trace_qed_read_table(s, offset, table);

qemu_co_mutex_unlock(&s->table_lock);

- ret = bdrv_preadv(s->bs->file, offset, &qiov);

+ ret = bdrv_co_pread(s->bs->file, offset, bytes, table->offsets, 0);

qemu_co_mutex_lock(&s->table_lock);

if (ret < 0) {

goto out;

/* Byteswap offsets */

- noffsets = qiov.size / sizeof(uint64_t);

+ noffsets = bytes / sizeof(uint64_t);

for (i = 0; i < noffsets; i++) {

table->offsets[i] = le64_to_cpu(table->offsets[i]);

@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,

unsigned int sector_mask = BDRV_SECTOR_SIZE / sizeof(uint64_t) - 1;

unsigned int start, end, i;

QEDTable *new_table;

- QEMUIOVector qiov;

size_t len_bytes;

int ret;

@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,

len_bytes = (end - start) * sizeof(uint64_t);

new_table = qemu_blockalign(s->bs, len_bytes);

- qemu_iovec_init_buf(&qiov, new_table->offsets, len_bytes);

/* Byteswap table */

for (i = start; i < end; i++) {

@@ -XXX,XX +XXX,XX @@ static int qed_write_table(BDRVQEDState *s, uint64_t offset, QEDTable *table,

offset += start * sizeof(uint64_t);

qemu_co_mutex_unlock(&s->table_lock);

- ret = bdrv_pwritev(s->bs->file, offset, &qiov);

+ ret = bdrv_co_pwrite(s->bs->file, offset, len_bytes, new_table->offsets, 0);

qemu_co_mutex_lock(&s->table_lock);

trace_qed_write_table_cb(s, table, flush, ret);

if (ret < 0) {

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qed.c

+++ b/block/qed.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)

int nsectors = DIV_ROUND_UP(sizeof(QEDHeader), BDRV_SECTOR_SIZE);

size_t len = nsectors * BDRV_SECTOR_SIZE;

uint8_t *buf;

- QEMUIOVector qiov;

int ret;

assert(s->allocating_acb || s->allocating_write_reqs_plugged);

buf = qemu_blockalign(s->bs, len);

- qemu_iovec_init_buf(&qiov, buf, len);

- ret = bdrv_co_preadv(s->bs->file, 0, qiov.size, &qiov, 0);

+ ret = bdrv_co_pread(s->bs->file, 0, len, buf, 0);

if (ret < 0) {

goto out;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qed_write_header(BDRVQEDState *s)

/* Update header */

qed_header_cpu_to_le(&s->header, (QEDHeader *) buf);

- ret = bdrv_co_pwritev(s->bs->file, 0, qiov.size, &qiov, 0);

+ ret = bdrv_co_pwrite(s->bs->file, 0, len, buf, 0);

if (ret < 0) {

goto out;

2.20.1

Limiting the allocation to INT_MAX bytes isn't particularly clever

because it means that the final cluster will be a partial cluster which

will be completed through a COW operation. This results in unnecessary

data read and write requests which lead to an unwanted non-sparse

filesystem block for metadata preallocation.

Align the maximum allocation size down to the cluster size to avoid this

situation.

Reviewed-by: Eric Blake <eblake@redhat.com>

block/qcow2.c | 2 +-

1 file changed, 1 insertion(+), 1 deletion(-)

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

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,

bytes = new_length - offset;

while (bytes) {

- cur_bytes = MIN(bytes, INT_MAX);

+ cur_bytes = MIN(bytes, QEMU_ALIGN_DOWN(INT_MAX, s->cluster_size));

ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,

&host_offset, &meta);

if (ret < 0) {

2.20.1

From: Alberto Garcia <berto@igalia.com>

This tests the fix from the previous patch.

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

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

tests/qemu-iotests/249 | 115 +++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/249.out | 35 +++++++++++

tests/qemu-iotests/group | 1 +

3 files changed, 151 insertions(+)

create mode 100755 tests/qemu-iotests/249

create mode 100644 tests/qemu-iotests/249.out

diff --git a/tests/qemu-iotests/249 b/tests/qemu-iotests/249

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/249

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

+#!/usr/bin/env bash

+#

+# Test that a backing image is put back in read-only mode after

+# block-commit (both when it fails and when it succeeds).

+#

+# Copyright (C) 2019 Igalia, S.L.

+#

+# 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

+owner=berto@igalia.com

+

+seq="$(basename $0)"

+echo "QA output created by $seq"

+

+status=1    # failure is the default!

+

+_cleanup()

+{

+ _cleanup_test_img

+ rm -f "$TEST_IMG.base"

+ rm -f "$TEST_IMG.int"

+}

+trap "_cleanup; exit \$status" 0 1 2 3 15

+

+# get standard environment, filters and checks

+. ./common.rc

+. ./common.filter

+. ./common.qemu

+

+# Any format implementing BlockDriver.bdrv_change_backing_file

+_supported_fmt qcow2 qed

+_supported_proto file

+_supported_os Linux

+

+IMG_SIZE=1M

+

+# Create the images: base <- int <- active

+TEST_IMG="$TEST_IMG.base" _make_test_img $IMG_SIZE | _filter_imgfmt

+TEST_IMG="$TEST_IMG.int" _make_test_img -b "$TEST_IMG.base" | _filter_imgfmt

+_make_test_img -b "$TEST_IMG.int" | _filter_imgfmt

+

+# Launch QEMU with these two drives:

+# none0: base (read-only)

+# none1: base <- int <- active

+_launch_qemu -drive if=none,file="${TEST_IMG}.base",node-name=base,read-only=on \

+ -drive if=none,file="${TEST_IMG}",backing.node-name=int,backing.backing=base

+

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'qmp_capabilities' }" \

+ 'return'

+

+echo

+echo '=== Send a write command to a drive opened in read-only mode (1)'

+echo

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'human-monitor-command',

+ 'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \

+ 'return'

+

+echo

+echo '=== Run block-commit on base using an invalid filter node name'

+echo

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'block-commit',

+ 'arguments': {'job-id': 'job0', 'device': 'none1', 'top-node': 'int',

+ 'filter-node-name': '1234'}}" \

+ 'error'

+

+echo

+echo '=== Send a write command to a drive opened in read-only mode (2)'

+echo

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'human-monitor-command',

+ 'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \

+ 'return'

+

+echo

+echo '=== Run block-commit on base using the default filter node name'

+echo

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'block-commit',

+ 'arguments': {'job-id': 'job0', 'device': 'none1', 'top-node': 'int'}}" \

+ 'return'

+

+# Wait for block-commit to finish

+_send_qemu_cmd $QEMU_HANDLE '' \

+ '"status": "null"'

+

+echo

+echo '=== Send a write command to a drive opened in read-only mode (3)'

+echo

+_send_qemu_cmd $QEMU_HANDLE \

+ "{ 'execute': 'human-monitor-command',

+ 'arguments': {'command-line': 'qemu-io none0 \"aio_write 0 2k\"'}}" \

+ 'return'

+

+_cleanup_qemu

+

+# success, all done

+echo "*** done"

+rm -f $seq.full

+status=0

diff --git a/tests/qemu-iotests/249.out b/tests/qemu-iotests/249.out

+++ b/tests/qemu-iotests/249.out

+QA output created by 249

+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576

+Formatting 'TEST_DIR/t.IMGFMT.int', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base

+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.int

+{"return": {}}

+=== Send a write command to a drive opened in read-only mode (1)

+{"return": "Block node is read-onlyrn"}

+=== Run block-commit on base using an invalid filter node name

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}}

+{"error": {"class": "GenericError", "desc": "Invalid node name"}}

+=== Send a write command to a drive opened in read-only mode (2)

+{"return": "Block node is read-onlyrn"}

+=== Run block-commit on base using the default filter node name

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "created", "id": "job0"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "running", "id": "job0"}}

+{"return": {}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "waiting", "id": "job0"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "pending", "id": "job0"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "BLOCK_JOB_COMPLETED", "data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "concluded", "id": "job0"}}

+{"timestamp": {"seconds": TIMESTAMP, "microseconds": TIMESTAMP}, "event": "JOB_STATUS_CHANGE", "data": {"status": "null", "id": "job0"}}

+=== Send a write command to a drive opened in read-only mode (3)

+{"return": "Block node is read-onlyrn"}

+*** done

diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group

--- a/tests/qemu-iotests/group

+++ b/tests/qemu-iotests/group

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

246 rw auto quick

247 rw auto quick

248 rw auto quick

+249 rw auto quick

2.20.1

make_completely_empty() is an optimisated path for bdrv_make_empty()

where completely new metadata is created inside the image file instead

of going through all clusters and discarding them. For an external data

file, however, we actually need to do discard operations on the data

file; just overwriting the qcow2 file doesn't get rid of the data.

The necessary slow path with an explicit discard operation already

exists for other cases. Use it for external data files, too.

Reviewed-by: Eric Blake <eblake@redhat.com>

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

1 file changed, 5 insertions(+), 2 deletions(-)

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

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static int qcow2_make_empty(BlockDriverState *bs)

if (s->qcow_version >= 3 && !s->snapshots && !s->nb_bitmaps &&

3 + l1_clusters <= s->refcount_block_size &&

- s->crypt_method_header != QCOW_CRYPT_LUKS) {

+ s->crypt_method_header != QCOW_CRYPT_LUKS &&

+ !has_data_file(bs)) {

/* The following function only works for qcow2 v3 images (it

* requires the dirty flag) and only as long as there are no

* features that reserve extra clusters (such as snapshots,

* LUKS header, or persistent bitmaps), because it completely

* empties the image. Furthermore, the L1 table and three

* additional clusters (image header, refcount table, one

- * refcount block) have to fit inside one refcount block. */

+ * refcount block) have to fit inside one refcount block. It

+ * only resets the image file, i.e. does not work with an

+ * external data file. */

return make_completely_empty(bs);

2.20.1

From: Alberto Garcia <berto@igalia.com>

This patch fixes a few things in the way error codes are handled in

the qcow2 compression code:

a) qcow2_co_pwritev_compressed() expects qcow2_co_compress() to only

return -1 or -2 on failure, but this is not correct. Since the

change from qcow2_compress() to qcow2_co_compress() in commit

ceb029cd6feccf9f7607 the new code can also return -EINVAL (although

there does not seem to exist any code path that would cause that

error in the current implementation).

b) -1 and -2 are ad-hoc error codes defined in qcow2_compress().

This patch replaces them with standard constants from errno.h.

c) Both qcow2_compress() and qcow2_co_do_compress() return a negative

value on failure, but qcow2_co_pwritev_compressed() stores the

value in an unsigned data type.

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

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

---

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

1 file changed, 9 insertions(+), 9 deletions(-)

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

--- a/block/qcow2.c

+++ b/block/qcow2.c

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

* @src - source buffer, @src_size bytes

*

* Returns: compressed size on success

- * -1 destination buffer is not enough to store compressed data

- * -2 on any other error

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

@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,

ret = deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED,

-12, 9, Z_DEFAULT_STRATEGY);

if (ret != Z_OK) {

- return -2;

+ return -EIO;

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

@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,

if (ret == Z_STREAM_END) {

ret = dest_size - strm.avail_out;

} else {

- ret = (ret == Z_OK ? -1 : -2);

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

deflateEnd(&strm);

@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

BDRVQcow2State *s = bs->opaque;

QEMUIOVector hd_qiov;

int ret;

- size_t out_len;

+ ssize_t out_len;

uint8_t *buf, *out_buf;

uint64_t cluster_offset;

@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

out_len = qcow2_co_compress(bs, out_buf, s->cluster_size - 1,

buf, s->cluster_size);

- if (out_len == -2) {

- ret = -EINVAL;

- goto fail;

- } else if (out_len == -1) {

+ if (out_len == -ENOMEM) {

/* could not compress: write normal cluster */

ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);

if (ret < 0) {

goto fail;

}

goto success;

+ } else if (out_len < 0) {

+ ret = -EINVAL;

+ goto fail;

2.20.1

We'll add a bdrv_co_truncate() call in the next patch which can return

an Error that we don't want to discard. So add an errp parameter to

preallocate_co().

Cc: qemu-stable@nongnu.org

Reviewed-by: Eric Blake <eblake@redhat.com>

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

1 file changed, 6 insertions(+), 5 deletions(-)

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

--- a/block/qcow2.c

+++ b/block/qcow2.c

@@ -XXX,XX +XXX,XX @@ static int qcow2_set_up_encryption(BlockDriverState *bs,

* Returns: 0 on success, -errno on failure.

*/

static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,

- uint64_t new_length)

+ uint64_t new_length, Error **errp)

BDRVQcow2State *s = bs->opaque;

uint64_t bytes;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,

ret = qcow2_alloc_cluster_offset(bs, offset, &cur_bytes,

&host_offset, &meta);

if (ret < 0) {

+ error_setg_errno(errp, -ret, "Allocating clusters failed");

return ret;

}

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,

ret = qcow2_alloc_cluster_link_l2(bs, meta);

if (ret < 0) {

+ error_setg_errno(errp, -ret, "Mapping clusters failed");

qcow2_free_any_clusters(bs, meta->alloc_offset,

meta->nb_clusters, QCOW2_DISCARD_NEVER);

return ret;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,

ret = bdrv_pwrite(s->data_file, (host_offset + cur_bytes) - 1,

&data, 1);

if (ret < 0) {

+ error_setg_errno(errp, -ret, "Writing to EOF failed");

return ret;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,

break;

case PREALLOC_MODE_METADATA:

- ret = preallocate_co(bs, old_length, offset);

+ ret = preallocate_co(bs, old_length, offset, errp);

if (ret < 0) {

- error_setg_errno(errp, -ret, "Preallocation failed");

goto fail;

}

break;

@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,

/* With a data file, preallocation means just allocating the metadata

* and forwarding the truncate request to the data file */

if (has_data_file(bs)) {

- ret = preallocate_co(bs, old_length, offset);

+ ret = preallocate_co(bs, old_length, offset, errp);

if (ret < 0) {

- error_setg_errno(errp, -ret, "Preallocation failed");

goto fail;

}

break;

2.20.1

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

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

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>

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

1 file changed, 2 insertions(+), 7 deletions(-)

@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

uint64_t bytes, QEMUIOVector *qiov)

- QEMUIOVector hd_qiov;

ssize_t out_len;

uint8_t *buf, *out_buf;

@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,

goto fail;

}

- qemu_iovec_init_buf(&hd_qiov, out_buf, out_len);

BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);

- ret = bdrv_co_pwritev(s->data_file, cluster_offset, out_len, &hd_qiov, 0);

+ ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);

if (ret < 0) {

goto fail;

}

@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,

int ret = 0, csize, nb_csectors;

uint64_t coffset;

uint8_t *buf, *out_buf;

- QEMUIOVector local_qiov;

int offset_in_cluster = offset_into_cluster(s, offset);

coffset = file_cluster_offset & s->cluster_offset_mask;

@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,

if (!buf) {

return -ENOMEM;

}

- qemu_iovec_init_buf(&local_qiov, buf, csize);

out_buf = qemu_blockalign(bs, s->cluster_size);

BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);

- ret = bdrv_co_preadv(bs->file, coffset, csize, &local_qiov, 0);

+ ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);

if (ret < 0) {

goto fail;

}

2.20.1