The following changes since commit 672f9d0df10a68a5c5f2b32cbc8284abf9f5ee18:

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (2020-02-18 14:23:43 +0000)

https://github.com/XanClic/qemu.git tags/pull-block-2020-02-20

for you to fetch changes up to dff8d44c96f128480430b0c59ed8760917dbd427:

iotests: Test snapshot -l field separation (2020-02-20 16:43:42 +0100)

Block patches:

- qemu-img convert: New --target-is-zero parameter

- qcow2: Specify non-default compression type flag

- optionally flat output for query-named-block-nodes

- some fixes

- pseudo-creation of images on block devices is now done by a generic

block layer function

David Edmondson (1):

qemu-img: Add --target-is-zero to convert

Max Reitz (11):

iotests/147: Fix drive parameters

iotests/279: Fix for non-qcow2 formats

block/nbd: Fix hang in .bdrv_close()

block: Generic file creation fallback

file-posix: Drop hdev_co_create_opts()

iscsi: Drop iscsi_co_create_opts()

iotests: Add test for image creation fallback

qemu-img: Fix convert -n -B for backing-less targets

iotests: Test convert -n -B to backing-less target

block: Fix VM size field width in snapshot dump

iotests: Test snapshot -l field separation

Peter Krempa (1):

qapi: Allow getting flat output from 'query-named-block-nodes'

Thomas Huth (1):

iotests: Remove the superfluous 2nd check for the availability of

quorum

Vladimir Sementsov-Ogievskiy (3):

docs: improve qcow2 spec about extending image header

docs: qcow2: introduce compression type feature

block/backup-top: fix flags handling

block.c | 164 +++++++++++++++++++++++++++++++++----

block/backup-top.c | 31 ++++---

block/file-posix.c | 67 ---------------

block/iscsi.c | 56 -------------

block/nbd.c | 14 +++-

block/qapi.c | 15 +++-

block/qcow2.c | 11 ++-

blockdev.c | 8 +-

docs/interop/qcow2.txt | 64 ++++++++++++++-

docs/interop/qemu-img.rst | 9 +-

include/block/block.h | 2 +-

include/block/qapi.h | 4 +-

monitor/hmp-cmds.c | 2 +-

qapi/block-core.json | 7 +-

qemu-img-cmds.hx | 4 +-

qemu-img.c | 28 ++++++-

tests/qemu-iotests/122 | 14 ++++

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

tests/qemu-iotests/139 | 3 -

tests/qemu-iotests/147 | 2 +-

tests/qemu-iotests/259 | 62 ++++++++++++++

tests/qemu-iotests/259.out | 14 ++++

tests/qemu-iotests/279 | 7 +-

tests/qemu-iotests/284 | 97 ++++++++++++++++++++++

tests/qemu-iotests/284.out | 62 ++++++++++++++

tests/qemu-iotests/286 | 76 +++++++++++++++++

tests/qemu-iotests/286.out | 8 ++

tests/qemu-iotests/group | 3 +

28 files changed, 659 insertions(+), 180 deletions(-)

create mode 100755 tests/qemu-iotests/259

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

create mode 100755 tests/qemu-iotests/284

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

create mode 100755 tests/qemu-iotests/286

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

2.24.1

8dff69b94 added an aio parameter to the drive parameter but forgot to

add a comma before, thus breaking the test. Fix it again.

Fixes: 8dff69b9415b4287e900358744b732195e1ab2e2

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

Message-Id: <20200206130812.612960-1-mreitz@redhat.com>

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

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

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

tests/qemu-iotests/147 | 2 +-

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

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

index XXXXXXX..XXXXXXX 100755

--- a/tests/qemu-iotests/147

+++ b/tests/qemu-iotests/147

@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):

self.server.add_drive_raw('if=none,id=nbd-export,' +

'file=%s,' % test_img +

'format=%s,' % imgfmt +

- 'cache=%s' % cachemode +

+ 'cache=%s,' % cachemode +

'aio=%s' % aiomode)

self.server.launch()

2.24.1

In many cases the target of a convert operation is a newly provisioned

target that the user knows is blank (reads as zero). In this situation

there is no requirement for qemu-img to wastefully zero out the entire

device.

Add a new option, --target-is-zero, allowing the user to indicate that

an existing target device will return zeros for all reads.

Message-Id: <20200205110248.2009589-2-david.edmondson@oracle.com>

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

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

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

docs/interop/qemu-img.rst | 9 ++++++++-

qemu-img-cmds.hx | 4 ++--

qemu-img.c | 26 +++++++++++++++++++++++---

3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/docs/interop/qemu-img.rst b/docs/interop/qemu-img.rst

--- a/docs/interop/qemu-img.rst

+++ b/docs/interop/qemu-img.rst

@@ -XXX,XX +XXX,XX @@ Parameters to convert subcommand:

will still be printed. Areas that cannot be read from the source will be

treated as containing only zeroes.

+.. option:: --target-is-zero

+ Assume that reading the destination image will always return

+ zeros. This parameter is mutually exclusive with a destination image

+ that has a backing file. It is required to also use the ``-n``

+ parameter to skip image creation.

+

Parameters to dd subcommand:

.. program:: qemu-img-dd

@@ -XXX,XX +XXX,XX @@ Command description:

4

Error on reading data

-.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME

+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME

Convert the disk image *FILENAME* or a snapshot *SNAPSHOT_PARAM*

to disk image *OUTPUT_FILENAME* using format *OUTPUT_FMT*. It can

diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx

index XXXXXXX..XXXXXXX 100644

--- a/qemu-img-cmds.hx

+++ b/qemu-img-cmds.hx

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

ERST

DEF("convert", img_convert,

- "convert [--object objectdef] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")

+ "convert [--object objectdef] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")

SRST

-.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME

+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME

ERST

DEF("create", img_create,

diff --git a/qemu-img.c b/qemu-img.c

index XXXXXXX..XXXXXXX 100644

--- a/qemu-img.c

+++ b/qemu-img.c

@@ -XXX,XX +XXX,XX @@ enum {

OPTION_PREALLOCATION = 265,

OPTION_SHRINK = 266,

OPTION_SALVAGE = 267,

+ OPTION_TARGET_IS_ZERO = 268,

};

typedef enum OutputFormat {

@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)

int64_t sector_num = 0;

/* Check whether we have zero initialisation or can get it efficiently */

- if (s->target_is_new && s->min_sparse && !s->target_has_backing) {

+ if (!s->has_zero_init && s->target_is_new && s->min_sparse &&

+ !s->target_has_backing) {

s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));

- } else {

- s->has_zero_init = false;

}

if (!s->has_zero_init && !s->target_has_backing &&

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

{"force-share", no_argument, 0, 'U'},

{"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},

{"salvage", no_argument, 0, OPTION_SALVAGE},

+ {"target-is-zero", no_argument, 0, OPTION_TARGET_IS_ZERO},

{0, 0, 0, 0}

};

c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

case OPTION_TARGET_IMAGE_OPTS:

tgt_image_opts = true;

break;

+ case OPTION_TARGET_IS_ZERO:

+ /*

+ * The user asserting that the target is blank has the

+ * same effect as the target driver supporting zero

+ * initialisation.

+ */

+ s.has_zero_init = true;

+ break;

}

}

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

warn_report("This will become an error in future QEMU versions.");

}

+ if (s.has_zero_init && !skip_create) {

+ error_report("--target-is-zero requires use of -n flag");

+ goto fail_getopt;

+ }

+

s.src_num = argc - optind - 1;

out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;

@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)

}

s.target_has_backing = (bool) out_baseimg;

+ if (s.has_zero_init && s.target_has_backing) {

+ error_report("Cannot use --target-is-zero when the destination "

+ "image has a backing file");

+ goto out;

+ }

+

if (s.src_num > 1 && out_baseimg) {

error_report("Having a backing file for the target makes no sense when "

"concatenating multiple input images");

2.24.1

Add a test that all fields in "qemu-img snapshot -l"s output are

separated by spaces.

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

Message-Id: <20200117105859.241818-3-mreitz@redhat.com>

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

[mreitz: Renamed test from 284 to 286]

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

tests/qemu-iotests/286 | 76 ++++++++++++++++++++++++++++++++++++++

tests/qemu-iotests/286.out | 8 ++++

tests/qemu-iotests/group | 1 +

3 files changed, 85 insertions(+)

create mode 100755 tests/qemu-iotests/286

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

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

new file mode 100755

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/tests/qemu-iotests/286

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

+#!/usr/bin/env bash

+#

+# Test qemu-img snapshot -l

+#

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

+#

+

+seq=$(basename "$0")

+echo "QA output created by $seq"

+

+status=1    # failure is the default!

+

+_cleanup()

+{

+ _cleanup_test_img

+}

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

+

+# get standard environment, filters and checks

+. ./common.rc

+. ./common.filter

+. ./common.qemu

+

+_supported_fmt qcow2

+_supported_proto file

+# Internal snapshots are (currently) impossible with refcount_bits=1,

+# and generally impossible with external data files

+_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file

+

+_make_test_img 64M

+

+# Should be so long as to take up the whole field width

+sn_name=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

+

+# More memory will give us a larger VM state, i.e. one above 1 MB.

+# This way, we get a number with a decimal point.

+qemu_comm_method=monitor _launch_qemu -m 512 "$TEST_IMG"

+

+_send_qemu_cmd $QEMU_HANDLE "savevm $sn_name" '(qemu)'

+_send_qemu_cmd $QEMU_HANDLE 'quit' '(qemu)'

+wait=yes _cleanup_qemu

+

+# Check that all fields are separated by spaces.

+# We first collapse all space sequences into one space each;

+# then we turn every space-separated field into a '.';

+# and finally, we name the '.'s so the output is not just a confusing

+# sequence of dots.

+

+echo 'Output structure:'

+$QEMU_IMG snapshot -l "$TEST_IMG" | tail -n 1 | tr -s ' ' \

+ | sed -e 's/\S\+/./g' \

+ | sed -e 's/\./(snapshot ID)/' \

+ -e 's/\./(snapshot name)/' \

+ -e 's/\./(VM state size value)/' \

+ -e 's/\./(VM state size unit)/' \

+ -e 's/\./(snapshot date)/' \

+ -e 's/\./(snapshot time)/' \

+ -e 's/\./(VM clock)/'

+

+# success, all done

+echo "*** done"

+rm -f $seq.full

+status=0

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

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

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

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

+QA output created by 286

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

+QEMU X.Y.Z monitor - type 'help' for more information

+(qemu) savevm abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz

+(qemu) quit

+Output structure:

+(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock)

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

281 rw quick

283 auto quick

284 rw

+286 rw quick

2.24.1

If a protocol driver does not support image creation, we can see whether

maybe the file exists already. If so, just truncating it will be

sufficient.

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

Message-Id: <20200122164532.178040-3-mreitz@redhat.com>

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

block.c | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++-----

1 file changed, 147 insertions(+), 12 deletions(-)

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

--- a/block.c

+++ b/block.c

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

return ret;

}

-int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)

+/**

+ * Helper function for bdrv_create_file_fallback(): Resize @blk to at

+ * least the given @minimum_size.

+ *

+ * On success, return @blk's actual length.

+ * Otherwise, return -errno.

+ */

+static int64_t create_file_fallback_truncate(BlockBackend *blk,

+ int64_t minimum_size, Error **errp)

{

- BlockDriver *drv;

+ Error *local_err = NULL;

+ int64_t size;

+ int ret;

+

+ ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);

+ if (ret < 0 && ret != -ENOTSUP) {

+ error_propagate(errp, local_err);

+ return ret;

+ }

+

+ size = blk_getlength(blk);

+ if (size < 0) {

+ error_free(local_err);

+ error_setg_errno(errp, -size,

+ "Failed to inquire the new image file's length");

+ return size;

+ }

+

+ if (size < minimum_size) {

+ /* Need to grow the image, but we failed to do that */

+ error_propagate(errp, local_err);

+ return -ENOTSUP;

+ }

+

+ error_free(local_err);

+ local_err = NULL;

+

+ return size;

+/**

+ * Helper function for bdrv_create_file_fallback(): Zero the first

+ * sector to remove any potentially pre-existing image header.

+ */

+static int create_file_fallback_zero_first_sector(BlockBackend *blk,

+ int64_t current_size,

+ Error **errp)

+ int64_t bytes_to_clear;

+ int ret;

+

+ bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);

+ if (bytes_to_clear) {

+ ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);

+ if (ret < 0) {

+ error_setg_errno(errp, -ret,

+ "Failed to clear the new image's first sector");

+ return ret;

+ return 0;

+static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,

+ QemuOpts *opts, Error **errp)

+ BlockBackend *blk;

+ QDict *options = qdict_new();

+ int64_t size = 0;

+ char *buf = NULL;

+ PreallocMode prealloc;

Error *local_err = NULL;

int ret;

+ size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);

+ buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

+ prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,

+ PREALLOC_MODE_OFF, &local_err);

+ g_free(buf);

+ if (local_err) {

+ error_propagate(errp, local_err);

+ return -EINVAL;

+ if (prealloc != PREALLOC_MODE_OFF) {

+ error_setg(errp, "Unsupported preallocation mode '%s'",

+ PreallocMode_str(prealloc));

+ return -ENOTSUP;

+ }

+

+ qdict_put_str(options, "driver", drv->format_name);

+

+ blk = blk_new_open(filename, NULL, options,

+ BDRV_O_RDWR | BDRV_O_RESIZE, errp);

+ if (!blk) {

+ error_prepend(errp, "Protocol driver '%s' does not support image "

+ "creation, and opening the image failed: ",

+ drv->format_name);

+ return -EINVAL;

+ }

+

+ size = create_file_fallback_truncate(blk, size, errp);

+ if (size < 0) {

+ ret = size;

+ goto out;

+ }

+

+ ret = create_file_fallback_zero_first_sector(blk, size, errp);

+ if (ret < 0) {

+ goto out;

+ }

+

+ ret = 0;

+out:

+ blk_unref(blk);

+ return ret;

+}

+

+int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)

+{

+ BlockDriver *drv;

+

drv = bdrv_find_protocol(filename, true, errp);

if (drv == NULL) {

return -ENOENT;

- ret = bdrv_create(drv, filename, opts, &local_err);

- error_propagate(errp, local_err);

- return ret;

+ if (drv->bdrv_co_create_opts) {

+ return bdrv_create(drv, filename, opts, errp);

+ } else {

+ return bdrv_create_file_fallback(filename, drv, opts, errp);

+ }

}

/**

@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {

},

};

+static QemuOptsList fallback_create_opts = {

+ .name = "fallback-create-opts",

+ .head = QTAILQ_HEAD_INITIALIZER(fallback_create_opts.head),

+ .desc = {

+ {

+ .name = BLOCK_OPT_SIZE,

+ .type = QEMU_OPT_SIZE,

+ .help = "Virtual disk size"

+ },

+ {

+ .name = BLOCK_OPT_PREALLOC,

+ .type = QEMU_OPT_STRING,

+ .help = "Preallocation mode (allowed values: off)"

+ },

+ { /* end of list */ }

+ }

+};

+

/*

* Common part for opening disk images and files

*

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

return;

- if (!proto_drv->create_opts) {

- error_setg(errp, "Protocol driver '%s' does not support image creation",

- proto_drv->format_name);

- return;

- }

-

/* Create parameter list */

create_opts = qemu_opts_append(create_opts, drv->create_opts);

- create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);

+ if (proto_drv->create_opts) {

+ create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);

+ } else {

+ create_opts = qemu_opts_append(create_opts, &fallback_create_opts);

+ }

opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);

2.24.1

The generic fallback implementation effectively does the same.

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>

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

Message-Id: <20200122164532.178040-5-mreitz@redhat.com>

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

block/iscsi.c | 56 ---------------------------------------------------

1 file changed, 56 deletions(-)

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

--- a/block/iscsi.c

+++ b/block/iscsi.c

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

return 0;

-static int coroutine_fn iscsi_co_create_opts(const char *filename, QemuOpts *opts,

- Error **errp)

-{

- int ret = 0;

- int64_t total_size = 0;

- BlockDriverState *bs;

- IscsiLun *iscsilun = NULL;

- QDict *bs_options;

- Error *local_err = NULL;

-

- bs = bdrv_new();

-

- /* Read out options */

- total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

- BDRV_SECTOR_SIZE);

- bs->opaque = g_new0(struct IscsiLun, 1);

- iscsilun = bs->opaque;

-

- bs_options = qdict_new();

- iscsi_parse_filename(filename, bs_options, &local_err);

- if (local_err) {

- error_propagate(errp, local_err);

- ret = -EINVAL;

- } else {

- ret = iscsi_open(bs, bs_options, 0, NULL);

- }

- qobject_unref(bs_options);

-

- if (ret != 0) {

- goto out;

- }

- iscsi_detach_aio_context(bs);

- if (iscsilun->type != TYPE_DISK) {

- ret = -ENODEV;

- goto out;

- }

- if (bs->total_sectors < total_size) {

- ret = -ENOSPC;

- goto out;

- }

-

- ret = 0;

-out:

- if (iscsilun->iscsi != NULL) {

- iscsi_destroy_context(iscsilun->iscsi);

- }

- g_free(bs->opaque);

- bs->opaque = NULL;

- bdrv_unref(bs);

- return ret;

-}

-

static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)

{

IscsiLun *iscsilun = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {

.bdrv_parse_filename = iscsi_parse_filename,

.bdrv_file_open = iscsi_open,

.bdrv_close = iscsi_close,

- .bdrv_co_create_opts = iscsi_co_create_opts,

- .create_opts = &iscsi_create_opts,

.bdrv_reopen_prepare = iscsi_reopen_prepare,

.bdrv_reopen_commit = iscsi_reopen_commit,

.bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {

.bdrv_parse_filename = iscsi_parse_filename,

.bdrv_file_open = iscsi_open,

.bdrv_close = iscsi_close,

- .bdrv_co_create_opts = iscsi_co_create_opts,

- .create_opts = &iscsi_create_opts,

.bdrv_reopen_prepare = iscsi_reopen_prepare,

.bdrv_reopen_commit = iscsi_reopen_commit,

.bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,

2.24.1

From: Peter Krempa <pkrempa@redhat.com>

When a management application manages node names there's no reason to

recurse into backing images in the output of query-named-block-nodes.

Add a parameter to the command which will return just the top level

structs.

Signed-off-by: Peter Krempa <pkrempa@redhat.com>

Message-Id: <4470f8c779abc404dcf65e375db195cd91a80651.1579509782.git.pkrempa@redhat.com>

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

[mreitz: Fixed coding style]

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

block.c | 5 +++--

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

blockdev.c | 8 ++++++--

include/block/block.h | 2 +-

include/block/qapi.h | 4 +++-

monitor/hmp-cmds.c | 2 +-

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

7 files changed, 29 insertions(+), 10 deletions(-)

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

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_node(const char *node_name)

/* Put this QMP function here so it can access the static graph_bdrv_states. */

-BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)

+BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,

+ Error **errp)

{

BlockDeviceInfoList *list, *entry;

BlockDriverState *bs;

list = NULL;

QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {

- BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);

+ BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);

if (!info) {

qapi_free_BlockDeviceInfoList(list);

return NULL;

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

#include "qemu/cutils.h"

BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,

- BlockDriverState *bs, Error **errp)

+ BlockDriverState *bs,

+ bool flat,

+ Error **errp)

{

ImageInfo **p_image_info;

BlockDriverState *bs0;

@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,

return NULL;

}

+ /* stop gathering data for flat output */

+ if (flat) {

+ break;

+ }

if (bs0->drv && bs0->backing) {

info->backing_file_depth++;

bs0 = bs0->backing->bs;

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

if (bs && bs->drv) {

info->has_inserted = true;

- info->inserted = bdrv_block_device_info(blk, bs, errp);

+ info->inserted = bdrv_block_device_info(blk, bs, false, errp);

if (info->inserted == NULL) {

goto err;

}

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

index XXXXXXX..XXXXXXX 100644

--- a/blockdev.c

+++ b/blockdev.c

@@ -XXX,XX +XXX,XX @@ void qmp_drive_backup(DriveBackup *backup, Error **errp)

blockdev_do_action(&action, errp);

}

-BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)

+BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat,

+ bool flat,

+ Error **errp)

{

- return bdrv_named_nodes_list(errp);

+ bool return_flat = has_flat && flat;

+ return bdrv_named_nodes_list(return_flat, errp);

}

XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)

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

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block.h

+++ b/include/block/block.h

@@ -XXX,XX +XXX,XX @@ void bdrv_lock_medium(BlockDriverState *bs, bool locked);

void bdrv_eject(BlockDriverState *bs, bool eject_flag);

const char *bdrv_get_format_name(BlockDriverState *bs);

BlockDriverState *bdrv_find_node(const char *node_name);

-BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);

+BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp);

XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);

BlockDriverState *bdrv_lookup_bs(const char *device,

const char *node_name,

diff --git a/include/block/qapi.h b/include/block/qapi.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/qapi.h

+++ b/include/block/qapi.h

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

#include "block/snapshot.h"

BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,

- BlockDriverState *bs, Error **errp);

+ BlockDriverState *bs,

+ bool flat,

+ Error **errp);

int bdrv_query_snapshot_info_list(BlockDriverState *bs,

SnapshotInfoList **p_list,

Error **errp);

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

index XXXXXXX..XXXXXXX 100644

--- a/monitor/hmp-cmds.c

+++ b/monitor/hmp-cmds.c

@@ -XXX,XX +XXX,XX @@ void hmp_info_block(Monitor *mon, const QDict *qdict)

}

/* Print node information */

- blockdev_list = qmp_query_named_block_nodes(NULL);

+ blockdev_list = qmp_query_named_block_nodes(false, false, NULL);

for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {

assert(blockdev->value->has_node_name);

if (device && strcmp(device, blockdev->value->node_name)) {

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

#

# Get the named block driver list

#

+# @flat: Omit the nested data about backing image ("backing-image" key) if true.

+# Default is false (Since 5.0)

+#

# Returns: the list of BlockDeviceInfo

#

# Since: 2.0

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

# } } ] }

#

##

-{ 'command': 'query-named-block-nodes', 'returns': [ 'BlockDeviceInfo' ] }

+{ 'command': 'query-named-block-nodes',

+ 'returns': [ 'BlockDeviceInfo' ],

+ 'data': { '*flat': 'bool' } }

##

# @XDbgBlockGraphNodeType: