The following changes since commit 718d7f4f9cf772e5784093d8e6085680a235acdb:

Merge remote-tracking branch 'remotes/stefanha/tags/block-pull-request' into staging (2017-07-18 13:09:51 +0100)

are available in the git repository at:

for you to fetch changes up to 6e6e55f5c2e5b520d6506c2716287ba3b5d1bbc8:

qemu-img: Check for backing image if specified during create (2017-07-18 15:27:37 +0200)

Block layer patches

Hervé Poussineau (4):

vvfat: add constants for special values of name[0]

vvfat: add a constant for bootsector name

vvfat: correctly parse non-ASCII short and long file names

vvfat: initialize memory after allocating it

John Snow (2):

blockdev: move BDRV_O_NO_BACKING option forward

qemu-img: Check for backing image if specified during create

Kevin Wolf (10):

commit: Add NULL check for overlay_bs

block: Make blk_get_attached_dev_id() public

block/qapi: Add qdev device name to query-block

block: Make blk_all_next() public

block/qapi: Use blk_all_next() for query-block

block: List anonymous device BBs in query-block

ide: bdrv_attach_dev() for empty CD-ROM

scsi-disk: bdrv_attach_dev() for empty CD-ROM

qemu-iotests: Test 'info block'

qemu-iotests: Test unplug of -device without drive

Manos Pitsidianakis (2):

block: add clock_type field to ThrottleGroup

block: remove timer canceling in throttle_config()

Max Reitz (1):

block/vvfat: Fix compiler warning with gcc 7

From: John Snow <jsnow@redhat.com>

For both external_snapshot_prepare and qmp_drive_mirror, we eventually

append the option BDRV_O_NO_BACKING. However, we generally do so after

we create the image.

To accommodate image creation wanting to verify that a backing file

exists or not, add this option prior to create to override checking

the existence of the backing file. This prevents QEMU from trying to

re-open a backing file that's already in use (thanks to qcow2 locking).

Signed-off-by: John Snow <jsnow@redhat.com>

blockdev.c | 11 ++++++-----

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

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

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

}

flags = state->old_bs->open_flags;

- flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING | BDRV_O_COPY_ON_READ);

+ flags &= ~(BDRV_O_SNAPSHOT | BDRV_O_COPY_ON_READ);

+ flags |= BDRV_O_NO_BACKING;

/* create new image w/backing file */

mode = s->has_mode ? s->mode : NEW_IMAGE_MODE_ABSOLUTE_PATHS;

@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,

qdict_put_str(options, "node-name", snapshot_node_name);

}

qdict_put_str(options, "driver", format);

-

- flags |= BDRV_O_NO_BACKING;

}

state->new_bs = bdrv_open(new_image_file, snapshot_ref, options, flags,

@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)

backing_mode = MIRROR_OPEN_BACKING_CHAIN;

}

+ /* Don't open backing image in create() */

+ flags |= BDRV_O_NO_BACKING;

if ((arg->sync == MIRROR_SYNC_MODE_FULL || !source)

&& arg->mode != NEW_IMAGE_MODE_EXISTING)

{

@@ -XXX,XX +XXX,XX @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)

/* Mirroring takes care of copy-on-write using the source's backing

* file.

*/

- target_bs = bdrv_open(arg->target, NULL, options,

- flags | BDRV_O_NO_BACKING, errp);

+ target_bs = bdrv_open(arg->target, NULL, options, flags, errp);

if (!target_bs) {

goto out;

}

1.8.3.1

From: Hervé Poussineau <hpoussin@reactos.org>

This prevents some host to guest memory content leaks.

Fixes: https://bugs.launchpad.net/qemu/+bug/1599539

Signed-off-by: Hervé Poussineau <hpoussin@reactos.org>

block/vvfat.c | 1 +

1 file changed, 1 insertion(+)

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

--- a/block/vvfat.c

+++ b/block/vvfat.c

@@ -XXX,XX +XXX,XX @@ static inline int array_ensure_allocated(array_t* array, int index)

array->pointer = g_realloc(array->pointer, new_size);

if (!array->pointer)

return -1;

+ memset(array->pointer + array->size, 0, new_size - array->size);

array->size = new_size;

array->next = index + 1;

}

1.8.3.1

With -blockdev/-device, users can indirectly create anonymous

BlockBackends, while the state of such backends is still of interest. As

a preparation for making such BBs visible in query-block, make sure that

they can be identified even without a name by adding the ID/QOM path of

their qdev device to BlockInfo.

Reviewed-by: John Snow <jsnow@redhat.com>

block/qapi.c | 10 ++++++++++

hmp.c | 3 +++

qapi/block-core.json | 9 ++++++++-

tests/qemu-iotests/067.out | 1 +

4 files changed, 22 insertions(+), 1 deletion(-)

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

index XXXXXXX..XXXXXXX 100644

--- a/block/qapi.c

+++ b/block/qapi.c

@@ -XXX,XX +XXX,XX @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,

{

BlockInfo *info = g_malloc0(sizeof(*info));

BlockDriverState *bs = blk_bs(blk);

+ char *qdev;

+

info->device = g_strdup(blk_name(blk));

info->type = g_strdup("unknown");

info->locked = blk_dev_is_medium_locked(blk);

info->removable = blk_dev_has_removable_media(blk);

+ qdev = blk_get_attached_dev_id(blk);

+ if (qdev && *qdev) {

+ info->has_qdev = true;

+ info->qdev = qdev;

+ } else {

+ g_free(qdev);

+ }

+

if (blk_dev_has_tray(blk)) {

info->has_tray_open = true;

info->tray_open = blk_dev_is_tray_open(blk);

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

index XXXXXXX..XXXXXXX 100644

--- a/hmp.c

+++ b/hmp.c

@@ -XXX,XX +XXX,XX @@ static void print_block_info(Monitor *mon, BlockInfo *info,

if (info) {

+ if (info->has_qdev) {

+ monitor_printf(mon, " Attached to: %s\n", info->qdev);

if (info->has_io_status && info->io_status != BLOCK_DEVICE_IO_STATUS_OK) {

monitor_printf(mon, " I/O status: %s\n",

BlockDeviceIoStatus_lookup[info->io_status]);

diff --git a/qapi/block-core.json b/qapi/block-core.json

index XXXXXXX..XXXXXXX 100644

--- a/qapi/block-core.json

+++ b/qapi/block-core.json

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

#

# @device: The device name associated with the virtual device.

#

+# @qdev: The qdev ID, or if no ID is assigned, the QOM path of the block

+# device. (since 2.10)

+#

# @type: This field is returned only for compatibility reasons, it should

# not be used (always returns 'unknown')

#

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

# Since: 0.14.0

##

{ 'struct': 'BlockInfo',

- 'data': {'device': 'str', 'type': 'str', 'removable': 'bool',

+ 'data': {'device': 'str', '*qdev': 'str', 'type': 'str', 'removable': 'bool',

'locked': 'bool', '*inserted': 'BlockDeviceInfo',

'*tray_open': 'bool', '*io-status': 'BlockDeviceIoStatus',

'*dirty-bitmaps': ['BlockDirtyInfo'] } }

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

# }

# }

# },

+# "qdev": "ide_disk",

# "type":"unknown"

# },

# {

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

# "device":"ide1-cd0",

# "locked":false,

# "removable":true,

+# "qdev": "/machine/unattached/device[23]",

+# "tray_open": false,

# "type":"unknown"

# },

# {

# "device":"floppy0",

# "locked":false,

# "removable":true,

+# "qdev": "/machine/unattached/device[20]",

# "type":"unknown"

# },

# {

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

index XXXXXXX..XXXXXXX 100644

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

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

@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti

"file": "TEST_DIR/t.qcow2",

"encryption_key_missing": false

},

+ "qdev": "/machine/peripheral/virtio0/virtio-backend",

"type": "unknown"

]

1.8.3.1

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

Reviewed-by: John Snow <jsnow@redhat.com>

block/block-backend.c | 2 +-

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

2 files changed, 2 insertions(+), 1 deletion(-)

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

* Behaves similarly to blk_next() but iterates over all BlockBackends, even the

* ones which are hidden (i.e. are not referenced by the monitor).

-static BlockBackend *blk_all_next(BlockBackend *blk)

+BlockBackend *blk_all_next(BlockBackend *blk)

return blk ? QTAILQ_NEXT(blk, link)

: QTAILQ_FIRST(&block_backends);

diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h

index XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/block-backend.h

+++ b/include/sysemu/block-backend.h

@@ -XXX,XX +XXX,XX @@ void blk_remove_all_bs(void);

const char *blk_name(const BlockBackend *blk);

BlockBackend *blk_by_name(const char *name);

BlockBackend *blk_next(BlockBackend *blk);

+BlockBackend *blk_all_next(BlockBackend *blk);

bool monitor_add_blk(BlockBackend *blk, const char *name, Error **errp);

void monitor_remove_blk(BlockBackend *blk);

1.8.3.1

From: John Snow <jsnow@redhat.com>

Or, rather, force the open of a backing image if one was specified

for creation. Using a similar -unsafe option as rebase, allow qemu-img

to ignore the backing file validation if possible.

It may not always be possible, as in the existing case when a filesize

for the new image was not specified.

This is accomplished by shifting around the conditionals in

bdrv_img_create, such that a backing file is always opened unless we

provide BDRV_O_NO_BACKING. qemu-img is adjusted to pass this new flag

when -u is provided to create.

Sorry for the heinous looking diffstat, but it's mostly whitespace.

Inspired by: https://bugzilla.redhat.com/show_bug.cgi?id=1213786

Signed-off-by: John Snow <jsnow@redhat.com>

block.c | 94 +++++++++++++++++++++++++---------------------

qemu-img-cmds.hx | 4 +-

qemu-img.c | 16 +++++---

qemu-img.texi | 9 ++++-

tests/qemu-iotests/082 | 4 +-

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

tests/qemu-iotests/085 | 2 +-

tests/qemu-iotests/111.out | 1 +

tests/qemu-iotests/139 | 2 +-

tests/qemu-iotests/156 | 2 +-

tests/qemu-iotests/158 | 2 +-

tests/qemu-iotests/189 | 2 +-

12 files changed, 83 insertions(+), 59 deletions(-)

@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,

backing_fmt = qemu_opt_get(opts, BLOCK_OPT_BACKING_FMT);

- // The size for the image must always be specified, with one exception:

- // If we are using a backing file, we can obtain the size from there

+ /* The size for the image must always be specified, unless we have a backing

+ * file and we have not been forbidden from opening it. */

size = qemu_opt_get_size(opts, BLOCK_OPT_SIZE, 0);

- if (size == -1) {

- if (backing_file) {

- BlockDriverState *bs;

- char *full_backing = g_new0(char, PATH_MAX);

- int64_t size;

- int back_flags;

- QDict *backing_options = NULL;

-

- bdrv_get_full_backing_filename_from_filename(filename, backing_file,

- full_backing, PATH_MAX,

- &local_err);

- if (local_err) {

- g_free(full_backing);

- goto out;

- }

+ if (backing_file && !(flags & BDRV_O_NO_BACKING)) {

+ BlockDriverState *bs;

+ char *full_backing = g_new0(char, PATH_MAX);

+ int back_flags;

+ QDict *backing_options = NULL;

+

+ bdrv_get_full_backing_filename_from_filename(filename, backing_file,

+ full_backing, PATH_MAX,

+ &local_err);

+ if (local_err) {

+ g_free(full_backing);

+ goto out;

+ }

- /* backing files always opened read-only */

- back_flags = flags;

- back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

+ /* backing files always opened read-only */

+ back_flags = flags;

+ back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);

- if (backing_fmt) {

- backing_options = qdict_new();

- qdict_put_str(backing_options, "driver", backing_fmt);

- }

+ if (backing_fmt) {

+ backing_options = qdict_new();

+ qdict_put_str(backing_options, "driver", backing_fmt);

+ }

- bs = bdrv_open(full_backing, NULL, backing_options, back_flags,

- &local_err);

- g_free(full_backing);

- if (!bs) {

- goto out;

- }

- size = bdrv_getlength(bs);

- if (size < 0) {

- error_setg_errno(errp, -size, "Could not get size of '%s'",

- backing_file);

- bdrv_unref(bs);

- goto out;

+ bs = bdrv_open(full_backing, NULL, backing_options, back_flags,

+ g_free(full_backing);

+ if (!bs && size != -1) {

+ /* Couldn't open BS, but we have a size, so it's nonfatal */

+ warn_reportf_err(local_err,

+ "Could not verify backing image. "

+ "This may become an error in future versions.\n");

+ local_err = NULL;

+ } else if (!bs) {

+ /* Couldn't open bs, do not have size */

+ error_append_hint(&local_err,

+ "Could not open backing image to determine size.\n");

+ goto out;

+ } else {

+ if (size == -1) {

+ /* Opened BS, have no size */

+ size = bdrv_getlength(bs);

+ if (size < 0) {

+ error_setg_errno(errp, -size, "Could not get size of '%s'",

+ backing_file);

+ bdrv_unref(bs);

+ goto out;

+ }

+ qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);