The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)

for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:

qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)

Block layer patches:

- Fix resize (extending) of short overlays

- nvme: introduce PMR support from NVMe 1.4 spec

- qemu-storage-daemon: Fix non-string --object properties

Alberto Garcia (1):

qcow2: Add incompatibility note between backing files and raw external data files

Andrzej Jakowski (1):

nvme: introduce PMR support from NVMe 1.4 spec

Kevin Wolf (12):

block: Add flags to BlockDriver.bdrv_co_truncate()

block: Add flags to bdrv(_co)_truncate()

block-backend: Add flags to blk_truncate()

qcow2: Support BDRV_REQ_ZERO_WRITE for truncate

raw-format: Support BDRV_REQ_ZERO_WRITE for truncate

file-posix: Support BDRV_REQ_ZERO_WRITE for truncate

block: truncate: Don't make backing file data visible

iotests: Filter testfiles out in filter_img_info()

iotests: Test committing to short backing file

qcow2: Forward ZERO_WRITE flag for full preallocation

qom: Factor out user_creatable_add_dict()

qemu-storage-daemon: Fix non-string --object properties

Paolo Bonzini (1):

qemu-iotests: allow qcow2 external discarded clusters to contain stale data

docs/interop/qcow2.txt | 3 +

hw/block/nvme.h | 2 +

include/block/block.h | 5 +-

include/block/block_int.h | 10 +-

include/block/nvme.h | 172 ++++++++++++++++++++++++++

include/qom/object_interfaces.h | 16 +++

include/sysemu/block-backend.h | 2 +-

block.c | 3 +-

block/block-backend.c | 4 +-

block/commit.c | 4 +-

block/crypto.c | 7 +-

block/file-posix.c | 6 +-

block/file-win32.c | 2 +-

block/gluster.c | 1 +

block/io.c | 43 ++++++-

block/iscsi.c | 2 +-

block/mirror.c | 2 +-

block/nfs.c | 3 +-

block/parallels.c | 6 +-

block/qcow.c | 4 +-

block/qcow2-cluster.c | 2 +-

block/qcow2-refcount.c | 2 +-

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

block/qed.c | 3 +-

block/raw-format.c | 6 +-

block/rbd.c | 1 +

block/sheepdog.c | 4 +-

block/ssh.c | 2 +-

block/vdi.c | 2 +-

block/vhdx-log.c | 2 +-

block/vhdx.c | 6 +-

block/vmdk.c | 8 +-

block/vpc.c | 2 +-

blockdev.c | 2 +-

hw/block/nvme.c | 109 ++++++++++++++++

qemu-img.c | 2 +-

qemu-io-cmds.c | 2 +-

qemu-storage-daemon.c | 4 +-

qom/object_interfaces.c | 31 +++++

qom/qom-qmp-cmds.c | 24 +---

tests/test-block-iothread.c | 9 +-

tests/qemu-iotests/iotests.py | 5 +-

hw/block/Makefile.objs | 2 +-

hw/block/trace-events | 4 +

tests/qemu-iotests/244 | 10 +-

tests/qemu-iotests/244.out | 9 +-

tests/qemu-iotests/274 | 155 +++++++++++++++++++++++

tests/qemu-iotests/274.out | 268 ++++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/group | 1 +

49 files changed, 951 insertions(+), 96 deletions(-)

create mode 100755 tests/qemu-iotests/274

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

After processing the option string with the keyval parser, we get a

QDict that contains only strings. This QDict must be fed to a keyval

visitor which converts the strings into the right data types.

qmp_object_add(), however, uses the normal QObject input visitor, which

expects a QDict where all properties already have the QType that matches

the data type required by the QOM object type.

Change the --object implementation in qemu-storage-daemon so that it

doesn't call qmp_object_add(), but calls user_creatable_add_dict()

directly instead and pass it a new keyval boolean that decides which

visitor must be used.

Reported-by: Coiby Xu <coiby.xu@gmail.com>

include/qom/object_interfaces.h | 6 +++++-

qemu-storage-daemon.c | 4 +---

qom/object_interfaces.c | 8 ++++++--

qom/qom-qmp-cmds.c | 2 +-

4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h

--- a/include/qom/object_interfaces.h

+++ b/include/qom/object_interfaces.h

@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,

/**

* user_creatable_add_dict:

* @qdict: the object definition

+ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.

+ * assume that all @qdict values are strings); otherwise, use

+ * the normal QObject visitor (i.e. assume all @qdict values

+ * have the QType expected by the QOM object type)

* @errp: if an error occurs, a pointer to an area to store the error

*

* Create an instance of the user creatable object that is defined by

@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,

* ID from the key 'id'. The remaining entries in @qdict are used to

* initialize the object properties.

*/

-void user_creatable_add_dict(QDict *qdict, Error **errp);

+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);

/**

* user_creatable_add_opts:

diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c

index XXXXXXX..XXXXXXX 100644

--- a/qemu-storage-daemon.c

+++ b/qemu-storage-daemon.c

@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])

QemuOpts *opts;

const char *type;

QDict *args;

- QObject *ret_data = NULL;

/* FIXME The keyval parser rejects 'help' arguments, so we must

* unconditionall try QemuOpts first. */

@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])

qemu_opts_del(opts);

args = keyval_parse(optarg, "qom-type", &error_fatal);

- qmp_object_add(args, &ret_data, &error_fatal);

+ user_creatable_add_dict(args, true, &error_fatal);

qobject_unref(args);

- qobject_unref(ret_data);

break;

}

default:

diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c

index XXXXXXX..XXXXXXX 100644

--- a/qom/object_interfaces.c

+++ b/qom/object_interfaces.c

@@ -XXX,XX +XXX,XX @@ out:

return obj;

}

-void user_creatable_add_dict(QDict *qdict, Error **errp)

+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)

Visitor *v;

Object *obj;

@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)

}

qdict_del(qdict, "id");

- v = qobject_input_visitor_new(QOBJECT(qdict));

+ if (keyval) {

+ v = qobject_input_visitor_new_keyval(QOBJECT(qdict));

+ } else {

+ v = qobject_input_visitor_new(QOBJECT(qdict));

+ }

obj = user_creatable_add_type(type, id, qdict, v, errp);

visit_free(v);

object_unref(obj);

diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c

index XXXXXXX..XXXXXXX 100644

--- a/qom/qom-qmp-cmds.c

+++ b/qom/qom-qmp-cmds.c

@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)

qobject_unref(pdict);

}

- user_creatable_add_dict(qdict, errp);

+ user_creatable_add_dict(qdict, false, errp);

}

void qmp_object_del(const char *id, Error **errp)

2.25.3

The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the

image is possibly preallocated and then the zero flag is added to all

clusters. This means that a copy-on-write operation may be needed when

writing to these clusters, despite having used preallocation, negating

one of the major benefits of preallocation.

Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,

and if the protocol driver can ensure that the new area reads as zeros,

we can skip setting the zero flag in the qcow2 layer.

Unfortunately, the same approach doesn't work for metadata

preallocation, so we'll still set the zero flag there.

Reviewed-by: Max Reitz <mreitz@redhat.com>

Message-Id: <20200424142701.67053-1-kwolf@redhat.com>

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

tests/qemu-iotests/274.out | 4 ++--

2 files changed, 21 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 coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,

/* Allocate the data area */

new_file_size = allocation_start +

nb_new_data_clusters * s->cluster_size;

- /* Image file grows, so @exact does not matter */

- ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,

- errp);

+ /*

+ * Image file grows, so @exact does not matter.

+ *

+ * If we need to zero out the new area, try first whether the protocol

+ * driver can already take care of this.

+ */

+ if (flags & BDRV_REQ_ZERO_WRITE) {

+ ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,

+ BDRV_REQ_ZERO_WRITE, NULL);

+ if (ret >= 0) {

+ flags &= ~BDRV_REQ_ZERO_WRITE;

+ }

+ } else {

+ ret = -1;

+ }

+ if (ret < 0) {

+ ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,

+ errp);

+ }

if (ret < 0) {

error_prepend(errp, "Failed to resize underlying file: ");

qcow2_free_clusters(bs, allocation_start,

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

--- a/tests/qemu-iotests/274.out

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

@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184

10 MiB (0xa00000) bytes allocated at offset 5 MiB (0x500000)

[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},

-{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]

+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]

=== preallocation=full ===

Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16

@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336

4 MiB (0x400000) bytes allocated at offset 8 MiB (0x800000)

[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},

-{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]

+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]

=== preallocation=off ===

Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16

2.25.3

When extending the size of an image that has a backing file larger than

its old size, make sure that the backing file data doesn't become

visible in the guest, but the added area is properly zeroed out.

Consider the following scenario where the overlay is shorter than its

backing file:

base.qcow2: AAAAAAAA

overlay.qcow2: BBBB

When resizing (extending) overlay.qcow2, the new blocks should not stay

unallocated and make the additional As from base.qcow2 visible like

before this patch, but zeros should be read.

A similar case happens with the various variants of a commit job when an

intermediate file is short (- for unallocated):

base.qcow2: A-A-AAAA

mid.qcow2: BB-B

top.qcow2: C--C--C-

After commit top.qcow2 to mid.qcow2, the following happens:

mid.qcow2: CB-C00C0 (correct result)

mid.qcow2: CB-C--C- (before this fix)

Without the fix, blocks that previously read as zeros on top.qcow2

suddenly turn into A.

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

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

Message-Id: <20200424125448.63318-8-kwolf@redhat.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

block/io.c | 25 +++++++++++++++++++++++++

1 file changed, 25 insertions(+)

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

--- a/block/io.c

+++ b/block/io.c

@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,

goto out;

}

+ * If the image has a backing file that is large enough that it would

+ * provide data for the new area, we cannot leave it unallocated because

+ * then the backing file content would become visible. Instead, zero-fill

+ * the new area.

+ *

+ * Note that if the image has a backing file, but was opened without the

+ * backing file, taking care of keeping things consistent with that backing

+ * file is the user's responsibility.

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

+ int64_t backing_len;

+ backing_len = bdrv_getlength(backing_bs(bs));

+ if (backing_len < 0) {

+ ret = backing_len;

+ error_setg_errno(errp, -ret, "Could not get backing file size");

+ goto out;

+ }

+

+ if (backing_len > old_size) {

+ flags |= BDRV_REQ_ZERO_WRITE;

+ }

if (drv->bdrv_co_truncate) {

if (flags & ~bs->supported_truncate_flags) {

error_setg(errp, "Block driver does not support requested flags");

2.25.3

The QMP handler qmp_object_add() and the implementation of --object in

qemu-storage-daemon can share most of the code. Currently,

qemu-storage-daemon calls qmp_object_add(), but this is not correct

because different visitors need to be used.

As a first step towards a fix, make qmp_object_add() a wrapper around a

new function user_creatable_add_dict() that can get an additional

parameter. The handling of "props" is only required for compatibility

and not required for the qemu-storage-daemon command line, so it stays

in qmp_object_add().

include/qom/object_interfaces.h | 12 ++++++++++++

qom/object_interfaces.c | 27 +++++++++++++++++++++++++++

qom/qom-qmp-cmds.c | 24 +-----------------------

3 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h

--- a/include/qom/object_interfaces.h

+++ b/include/qom/object_interfaces.h

@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,

const QDict *qdict,

Visitor *v, Error **errp);

+/**

+ * user_creatable_add_dict:

+ * @qdict: the object definition

+ * @errp: if an error occurs, a pointer to an area to store the error

+ *

+ * Create an instance of the user creatable object that is defined by

+ * @qdict. The object type is taken from the QDict key 'qom-type', its

+ * ID from the key 'id'. The remaining entries in @qdict are used to

+ * initialize the object properties.

+ */

+void user_creatable_add_dict(QDict *qdict, Error **errp);

+

/**

* user_creatable_add_opts:

* @opts: the object definition

diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c

index XXXXXXX..XXXXXXX 100644

--- a/qom/object_interfaces.c

+++ b/qom/object_interfaces.c

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

#include "qapi/qmp/qerror.h"

#include "qapi/qmp/qjson.h"

#include "qapi/qmp/qstring.h"

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

#include "qom/object_interfaces.h"

#include "qemu/help_option.h"

#include "qemu/module.h"

@@ -XXX,XX +XXX,XX @@ out:

return obj;

}

+void user_creatable_add_dict(QDict *qdict, Error **errp)

+{

+ Visitor *v;

+ Object *obj;

+ g_autofree char *type = NULL;

+ g_autofree char *id = NULL;

+

+ type = g_strdup(qdict_get_try_str(qdict, "qom-type"));

+ if (!type) {

+ error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");

+ return;

+ qdict_del(qdict, "qom-type");

+

+ id = g_strdup(qdict_get_try_str(qdict, "id"));

+ if (!id) {

+ error_setg(errp, QERR_MISSING_PARAMETER, "id");

+ return;

+ }

+ qdict_del(qdict, "id");

+

+ v = qobject_input_visitor_new(QOBJECT(qdict));

+ obj = user_creatable_add_type(type, id, qdict, v, errp);

+ visit_free(v);

+ object_unref(obj);

+}

Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)

{

diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c

index XXXXXXX..XXXXXXX 100644

--- a/qom/qom-qmp-cmds.c

+++ b/qom/qom-qmp-cmds.c

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

#include "qapi/qapi-commands-qom.h"

#include "qapi/qmp/qdict.h"

#include "qapi/qmp/qerror.h"

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

#include "qemu/cutils.h"

#include "qom/object_interfaces.h"

#include "qom/qom-qobject.h"

@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)

{

QObject *props;

QDict *pdict;

- Visitor *v;

- Object *obj;

- g_autofree char *type = NULL;

- g_autofree char *id = NULL;

-

- type = g_strdup(qdict_get_try_str(qdict, "qom-type"));

- if (!type) {

- error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");

- return;

- }

- qdict_del(qdict, "qom-type");

-

- id = g_strdup(qdict_get_try_str(qdict, "id"));

- if (!id) {

- error_setg(errp, QERR_MISSING_PARAMETER, "id");

- return;

- }

- qdict_del(qdict, "id");

props = qdict_get(qdict, "props");

if (props) {

@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)

qobject_unref(pdict);

}

- v = qobject_input_visitor_new(QOBJECT(qdict));

- obj = user_creatable_add_type(type, id, qdict, v, errp);

- visit_free(v);

- object_unref(obj);

+ user_creatable_add_dict(qdict, errp);

}

void qmp_object_del(const char *id, Error **errp)

2.25.3

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

Message-Id: <20200424125448.63318-10-kwolf@redhat.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

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

tests/qemu-iotests/274 | 155 +++++++++++++++++++++

tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/group | 1 +

3 files changed, 424 insertions(+)

create mode 100755 tests/qemu-iotests/274

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

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

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/274

+#!/usr/bin/env python3

+#

+# Copyright (C) 2019 Red Hat, Inc.

+#

+# This program is free software; you can redistribute it and/or modify

+# it under the terms of the GNU General Public License as published by

+# the Free Software Foundation; either version 2 of the License, or

+# (at your option) any later version.

+#

+# This program is distributed in the hope that it will be useful,

+# but WITHOUT ANY WARRANTY; without even the implied warranty of

+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+# GNU General Public License for more details.

+#

+# You should have received a copy of the GNU General Public License

+# along with this program. If not, see <http://www.gnu.org/licenses/>.

+#

+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>

+#

+# Some tests for short backing files and short overlays

+import iotests

+

+iotests.verify_image_format(supported_fmts=['qcow2'])

+iotests.verify_platform(['linux'])

+

+size_short = 1 * 1024 * 1024

+size_long = 2 * 1024 * 1024

+size_diff = size_long - size_short

+

+def create_chain() -> None:

+ iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,

+ str(size_long))

+ iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,

+ str(size_short))

+ iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,

+ str(size_long))

+

+ iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)

+

+def create_vm() -> iotests.VM:

+ vm = iotests.VM()

+ vm.add_blockdev('file,filename=%s,node-name=base-file' % base)

+ vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)

+ vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)

+ vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'

+ % iotests.imgfmt)

+ vm.add_drive(top, 'backing=mid,node-name=top')

+ return vm

+

+with iotests.FilePath('base') as base, \

+ iotests.FilePath('mid') as mid, \

+ iotests.FilePath('top') as top:

+

+ iotests.log('== Commit tests ==')

+

+ create_chain()

+

+ iotests.log('=== Check visible data ===')

+

+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)

+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)

+

+ iotests.log('=== Checking allocation status ===')

+

+ iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,

+ '-c', 'alloc %d %d' % (size_short, size_diff),

+ base)

+

+ iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,

+ '-c', 'alloc %d %d' % (size_short, size_diff),

+ mid)

+

+ iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,

+ '-c', 'alloc %d %d' % (size_short, size_diff),

+ top)

+

+ iotests.log('=== Checking map ===')

+

+ iotests.qemu_img_log('map', '--output=json', base)

+ iotests.qemu_img_log('map', '--output=human', base)

+ iotests.qemu_img_log('map', '--output=json', mid)

+ iotests.qemu_img_log('map', '--output=human', mid)

+ iotests.qemu_img_log('map', '--output=json', top)

+ iotests.qemu_img_log('map', '--output=human', top)

+

+ iotests.log('=== Testing qemu-img commit (top -> mid) ===')

+

+ iotests.qemu_img_log('commit', top)

+ iotests.img_info_log(mid)

+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)

+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)

+

+ iotests.log('=== Testing HMP commit (top -> mid) ===')

+

+ create_chain()

+ with create_vm() as vm:

+ vm.launch()

+ vm.qmp_log('human-monitor-command', command_line='commit drive0')

+

+ iotests.img_info_log(mid)

+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)

+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)

+

+ iotests.log('=== Testing QMP active commit (top -> mid) ===')

+

+ create_chain()

+ with create_vm() as vm:

+ vm.launch()

+ vm.qmp_log('block-commit', device='top', base_node='mid',

+ job_id='job0', auto_dismiss=False)

+ vm.run_job('job0', wait=5)

+

+ iotests.img_info_log(mid)

+ iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)

+ iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)

+

+

+ iotests.log('== Resize tests ==')

+

+ # Use different sizes for different allocation modes:

+ #

+ # We want to have at least one test where 32 bit truncation in the size of

+ # the overlapping area becomes visible. This is covered by the

+ # prealloc='off' case (1G to 6G is an overlap of 5G).

+ #

+ # However, we can only do this for modes that don't preallocate data

+ # because otherwise we might run out of space on the test host.

+ #

+ # We also want to test some unaligned combinations.

+ for (prealloc, base_size, top_size_old, top_size_new, off) in [

+ ('off', '6G', '1G', '8G', '5G'),

+ ('metadata', '32G', '30G', '33G', '31G'),

+ ('falloc', '10M', '5M', '15M', '9M'),

+ ('full', '16M', '8M', '12M', '11M'),

+ ('off', '384k', '253k', '512k', '253k'),

+ ('off', '400k', '256k', '512k', '336k'),

+ ('off', '512k', '256k', '500k', '436k')]:

+

+ iotests.log('=== preallocation=%s ===' % prealloc)

+ iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)

+ iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,

+ top_size_old)

+ iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)

+

+ # After this, top_size_old to base_size should be allocated/zeroed.

+ #

+ # In theory, leaving base_size to top_size_new unallocated would be

+ # correct, but in practice, if we zero out anything, we zero out

+ # everything up to top_size_new.

+ iotests.qemu_img_log('resize', '-f', iotests.imgfmt,

+ '--preallocation', prealloc, top, top_size_new)

+ iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)

+ iotests.qemu_io_log('-c', 'map', top)

+ iotests.qemu_img_log('map', '--output=json', top)

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

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

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

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

+== Commit tests ==

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 2097152/2097152 bytes at offset 0

+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+=== Check visible data ===

+read 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+read 1048576/1048576 bytes at offset 1048576

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+=== Checking allocation status ===

+1048576/1048576 bytes allocated at offset 0 bytes

+1048576/1048576 bytes allocated at offset 1 MiB

+

+0/1048576 bytes allocated at offset 0 bytes

+0/0 bytes allocated at offset 1 MiB

+

+0/1048576 bytes allocated at offset 0 bytes

+0/1048576 bytes allocated at offset 1 MiB

+

+=== Checking map ===

+[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]

+

+Offset Length Mapped to File

+0 0x200000 0x50000 TEST_DIR/PID-base

+

+[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]

+

+Offset Length Mapped to File

+0 0x100000 0x50000 TEST_DIR/PID-base

+

+[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},

+{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]

+

+Offset Length Mapped to File

+0 0x100000 0x50000 TEST_DIR/PID-base

+

+=== Testing qemu-img commit (top -> mid) ===

+Image committed.

+

+image: TEST_IMG

+file format: IMGFMT

+virtual size: 2 MiB (2097152 bytes)

+cluster_size: 65536

+backing file: TEST_DIR/PID-base

+Format specific information:

+ compat: 1.1

+ lazy refcounts: false

+ refcount bits: 16

+ corrupt: false

+

+read 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+read 1048576/1048576 bytes at offset 1048576

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+=== Testing HMP commit (top -> mid) ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 2097152/2097152 bytes at offset 0

+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}

+{"return": ""}

+image: TEST_IMG

+file format: IMGFMT

+virtual size: 2 MiB (2097152 bytes)

+cluster_size: 65536

+backing file: TEST_DIR/PID-base

+Format specific information:

+ compat: 1.1

+ lazy refcounts: false

+ refcount bits: 16

+ corrupt: false

+

+read 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+read 1048576/1048576 bytes at offset 1048576

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+=== Testing QMP active commit (top -> mid) ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 2097152/2097152 bytes at offset 0

+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}

+{"return": {}}

+{"execute": "job-complete", "arguments": {"id": "job0"}}

+{"return": {}}

+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}

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

+{"execute": "job-dismiss", "arguments": {"id": "job0"}}

+{"return": {}}

+image: TEST_IMG

+file format: IMGFMT

+virtual size: 2 MiB (2097152 bytes)

+cluster_size: 65536

+backing file: TEST_DIR/PID-base

+Format specific information:

+ compat: 1.1

+ lazy refcounts: false

+ refcount bits: 16

+ corrupt: false

+

+read 1048576/1048576 bytes at offset 0

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+read 1048576/1048576 bytes at offset 1048576

+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+== Resize tests ==

+=== preallocation=off ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 65536/65536 bytes at offset 5368709120

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+Image resized.

+

+read 65536/65536 bytes at offset 5368709120

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)

+7 GiB (0x1c0000000) bytes allocated at offset 1 GiB (0x40000000)

+

+[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},

+{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]

+

+=== preallocation=metadata ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 65536/65536 bytes at offset 33285996544

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+Image resized.

+

+read 65536/65536 bytes at offset 33285996544

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)

+3 GiB (0xc0000000) bytes allocated at offset 30 GiB (0x780000000)

+

+[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},

+{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},

+{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},

+{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},

+{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},

+{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},

+{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]

+

+=== preallocation=falloc ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 65536/65536 bytes at offset 9437184

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+Image resized.

+

+read 65536/65536 bytes at offset 9437184

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)

+10 MiB (0xa00000) bytes allocated at offset 5 MiB (0x500000)

+

+[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},

+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]

+

+=== preallocation=full ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+wrote 65536/65536 bytes at offset 11534336

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+Image resized.

+

+read 65536/65536 bytes at offset 11534336

+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

+

+8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)

+4 MiB (0x400000) bytes allocated at offset 8 MiB (0x800000)

+

+[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},

+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]

+

+=== preallocation=off ===

+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16

+

+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16

+