Series comparison

-[Qemu-devel] [PULL 00/19] Block layer patches
+[Qemu-devel] [PULL 00/26] Block layer patches
-The following changes since commit 63f495beb4007de5444614125fd6fd178ca6e2b1:
+The following changes since commit 91fe7a376ad46e3cc5e82d418aad22173c948a3c:
-  Merge remote-tracking branch 'remotes/kraxel/tags/pull-cve-2017-2620-20170224-1' into staging (2017-02-24 13:55:26 +0000)
+  Merge remote-tracking branch 'remotes/jasowang/tags/net-pull-request' into staging (2018-06-15 11:41:44 +0100)
 are available in the git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to d185cf0ec64cd183218ca7e0810d9130c96ebebc:
+for you to fetch changes up to 6266e900b8083945cb766b45c124fb3c42932cb3:
-  tests: Use opened block node for block job tests (2017-02-24 16:09:23 +0100)
+  block: Remove dead deprecation warning code (2018-06-15 14:49:44 +0200)
 ----------------------------------------------------------------
-Block layer patches
+Block layer patches:
 - Fix options that work only with -drive or -blockdev, but not with
   both, because of QDict type confusion
 - rbd: Add options 'auth-client-required' and 'key-secret'
 - Remove deprecated -drive options serial/addr/cyls/heads/secs/trans
 - rbd, iscsi: Remove deprecated 'filename' option
 - Fix 'qemu-img map' crash with unaligned image size
 - Improve QMP documentation for jobs
 ----------------------------------------------------------------
-Jeff Cody (3):
+Eric Blake (2):
-      qemu-iotests: Test 137 only supports 'file' protocol
+      qemu-img: Fix assert when mapping unaligned raw file
-      qemu-iotests: add ability to exclude certain protocols from tests
+      iotests: Add test 221 to catch qemu-img map regression
       qemu-iotests: redirect nbd server stdout to /dev/null
-John Snow (1):
+John Snow (2):
-      iotests: Fix another race in 030
+      jobs: fix stale wording
       jobs: fix verb references in docs
-Kevin Wolf (11):
+Kevin Wolf (4):
-      blockdev: Use BlockBackend to resize in qmp_block_resize()
+      block: Remove deprecated -drive geometry options
-      qcow2: Use BB for resizing in qcow2_amend_options()
+      block: Remove deprecated -drive option addr
-      mirror: Resize active commit base in mirror_run()
+      block: Remove deprecated -drive option serial
-      block: Pass BdrvChild to bdrv_truncate()
+      block: Remove dead deprecation warning code
       block: Attach bs->file only during .bdrv_open()
       block: Factor out bdrv_open_child_bs()
       block: Use BlockBackend for image probing
       block: Factor out bdrv_open_driver()
       block: Add bdrv_new_open_driver()
       vvfat: Use opened node as backing file
       tests: Use opened block node for block job tests
-Nir Soffer (4):
+Markus Armbruster (17):
-      qemu-img: Do not truncate before preallocation
+      rbd: Drop deprecated -drive parameter "filename"
-      qemu-img: Add tests for raw image preallocation
+      iscsi: Drop deprecated -drive parameter "filename"
-      qemu-img: Truncate before full preallocation
+      qobject: Move block-specific qdict code to block-qdict.c
-      qemu-img: Improve documentation for PREALLOC_MODE_FALLOC
+      block: Fix -blockdev for certain non-string scalars
       block: Fix -drive for certain non-string scalars
       block: Clean up a misuse of qobject_to() in .bdrv_co_create_opts()
       block: Factor out qobject_input_visitor_new_flat_confused()
       block: Make remaining uses of qobject input visitor more robust
       block-qdict: Simplify qdict_flatten_qdict()
       block-qdict: Tweak qdict_flatten_qdict(), qdict_flatten_qlist()
       block-qdict: Clean up qdict_crumple() a bit
       block-qdict: Simplify qdict_is_list() some
       check-block-qdict: Rename qdict_flatten()'s variables for clarity
       check-block-qdict: Cover flattening of empty lists and dictionaries
       block: Fix -blockdev / blockdev-add for empty objects and arrays
       rbd: New parameter auth-client-required
       rbd: New parameter key-secret
- block.c                       | 265 +++++++++++++++++++++++++++---------------
+Max Reitz (1):
- block/blkdebug.c              |   2 +-
+      block: Add block-specific QDict header
  block/block-backend.c         |   2 +-
  block/bochs.c                 |   6 +
  block/cloop.c                 |   6 +
  block/crypto.c                |   8 +-
  block/dmg.c                   |   6 +
  block/file-posix.c            |  28 +++--
  block/mirror.c                |  50 ++++----
  block/parallels.c             |  14 ++-
  block/qcow.c                  |  10 +-
  block/qcow2-refcount.c        |   2 +-
  block/qcow2.c                 |  28 ++++-
  block/qed.c                   |  18 ++-
  block/raw-format.c            |   8 +-
  block/replication.c           |   6 +
  block/vdi.c                   |   6 +
  block/vhdx-log.c              |   2 +-
  block/vhdx.c                  |   8 +-
  block/vmdk.c                  |   6 +
  block/vpc.c                   |   6 +
  block/vvfat.c                 |  10 +-
  blockdev.c                    |   7 +-
  include/block/block.h         |   4 +-
  tests/qemu-iotests/030        |   5 +-
  tests/qemu-iotests/051.out    |   4 +-
  tests/qemu-iotests/051.pc.out |   4 +-
  tests/qemu-iotests/137        |   2 +-
  tests/qemu-iotests/175        |  61 ++++++++++
  tests/qemu-iotests/175.out    |  18 +++
  tests/qemu-iotests/common.rc  |  14 ++-
  tests/qemu-iotests/group      |   1 +
  tests/test-blockjob-txn.c     |   6 +-
  tests/test-blockjob.c         |   6 +-
 files changed, 461 insertions(+), 168 deletions(-)
  create mode 100755 tests/qemu-iotests/175
  create mode 100644 tests/qemu-iotests/175.out
+ qapi/block-core.json       |  19 ++
+ qapi/job.json              |  23 +-
+ include/block/qdict.h      |  34 +++
+ include/hw/block/block.h   |   1 -
+ include/qapi/qmp/qdict.h   |  17 --
+ include/sysemu/blockdev.h  |   3 -
+ block.c                    |   1 +
+ block/block-backend.c      |   1 -
+ block/crypto.c             |  12 +-
+ block/gluster.c            |   1 +
+ block/iscsi.c              |  24 +-
+ block/nbd.c                |  16 +-
+ block/nfs.c                |   8 +-
+ block/parallels.c          |  11 +-
+ block/qcow.c               |  11 +-
+ block/qcow2.c              |  11 +-
+ block/qed.c                |  11 +-
+ block/quorum.c             |   1 +
+ block/rbd.c                |  85 +++---
+ block/sheepdog.c           |  23 +-
+ block/snapshot.c           |   1 +
+ block/ssh.c                |  16 +-
+ block/vdi.c                |   8 +-
+ block/vhdx.c               |  11 +-
+ block/vpc.c                |  11 +-
+ block/vvfat.c              |   1 +
+ block/vxhs.c               |   1 +
+ blockdev.c                 | 111 +------
+ device-hotplug.c           |   4 -
+ hw/block/block.c           |  27 --
+ hw/block/nvme.c            |   1 -
+ hw/block/virtio-blk.c      |   1 -
+ hw/ide/qdev.c              |   1 -
+ hw/scsi/scsi-disk.c        |   1 -
+ hw/usb/dev-storage.c       |   1 -
+ qemu-img.c                 |   2 +-
+ qobject/block-qdict.c      | 722 +++++++++++++++++++++++++++++++++++++++++++++
+ qobject/qdict.c            | 628 ---------------------------------------
+ tests/ahci-test.c          |   6 +-
+ tests/check-block-qdict.c  | 690 +++++++++++++++++++++++++++++++++++++++++++
+ tests/check-qdict.c        | 641 ----------------------------------------
+ tests/check-qobject.c      |   1 +
+ tests/hd-geo-test.c        |  37 +--
+ tests/ide-test.c           |   8 +-
+ tests/test-replication.c   |   1 +
+ util/qemu-config.c         |   1 +
+ MAINTAINERS                |   2 +
+ hmp-commands.hx            |   1 -
+ qemu-doc.texi              |  15 -
+ qemu-options.hx            |  14 +-
+ qobject/Makefile.objs      |   1 +
+ tests/Makefile.include     |   4 +
+ tests/qemu-iotests/221     |  60 ++++
+ tests/qemu-iotests/221.out |  16 +
+ tests/qemu-iotests/group   |   1 +
+files changed, 1692 insertions(+), 1668 deletions(-)
+ create mode 100644 include/block/qdict.h
+ create mode 100644 qobject/block-qdict.c
+ create mode 100644 tests/check-block-qdict.c
+ create mode 100755 tests/qemu-iotests/221
+ create mode 100644 tests/qemu-iotests/221.out

-New patch
+[Qemu-devel] [PULL 01/26] qemu-img: Fix assert when mapping unaligned raw file
+From: Eric Blake <eblake@redhat.com>
+Commit a290f085 exposed a latent bug in qemu-img map introduced
+during the conversion of block status to be byte-based.  Earlier in
+commit 5e344dd8, the internal interface get_block_status() switched
+to take byte-based parameters, but still called a sector-based
+block layer function; as such, rounding was added in the lone
+caller to obey the contract.  However, commit 237d78f8 changed
+get_block_status() to truly be byte-based, at which point rounding
+to sector boundaries can result in calling bdrv_block_status() with
+'bytes == 0' (a coding error) when the boundary between data and a
+hole falls mid-sector (true for the past-EOF implicit hole present
+in POSIX files).  Fix things by removing the rounding that is now
+no longer necessary.
+See also https://bugzilla.redhat.com/1589738
+Fixes: 237d78f8
+Reported-by: Dan Kenigsberg <danken@redhat.com>
+Reported-by: Nir Soffer <nsoffer@redhat.com>
+Reported-by: Maor Lipchuk <mlipchuk@redhat.com>
+CC: qemu-stable@nongnu.org
+Signed-off-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ qemu-img.c | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+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 @@ static int img_map(int argc, char **argv)
+         int64_t n;
+         /* Probe up to 1 GiB at a time.  */
+-        n = QEMU_ALIGN_DOWN(MIN(1 << 30, length - offset), BDRV_SECTOR_SIZE);
++        n = MIN(1 << 30, length - offset);
+         ret = get_block_status(bs, offset, n, &next);
+         if (ret < 0) {
+--
+.13.6

-[Qemu-devel] [PULL 05/19] qemu-img: Add tests for raw image preallocation
+[Qemu-devel] [PULL 02/26] iotests: Add test 221 to catch qemu-img map regression
-From: Nir Soffer <nirsof@gmail.com>
+From: Eric Blake <eblake@redhat.com>
-Add tests for creating raw image with and without the preallocation
+Although qemu-img creates aligned files (by rounding up), it
-option.
+must also gracefully handle files that are not sector-aligned.
 Test that the bug fixed in the previous patch does not recur.
-Signed-off-by: Nir Soffer <nirsof@gmail.com>
+It's a bit annoying that we can see the (implicit) hole past
 the end of the file on to the next sector boundary, so if we
 ever reach the point where we report a byte-accurate size rather
 than our current behavior of always rounding up, this test will
 probably need a slight modification.
 Signed-off-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/175     | 61 ++++++++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/221     | 60 ++++++++++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/175.out | 18 ++++++++++++++
+ tests/qemu-iotests/221.out | 16 +++++++++++++
  tests/qemu-iotests/group   |  1 +
-files changed, 80 insertions(+)
+files changed, 77 insertions(+)
- create mode 100755 tests/qemu-iotests/175
+ create mode 100755 tests/qemu-iotests/221
- create mode 100644 tests/qemu-iotests/175.out
+ create mode 100644 tests/qemu-iotests/221.out
-diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
+diff --git a/tests/qemu-iotests/221 b/tests/qemu-iotests/221
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/175
++++ b/tests/qemu-iotests/221
 @@ -XXX,XX +XXX,XX @@
 +#!/bin/bash
 +#
-+# Test creating raw image preallocation mode
++# Test qemu-img vs. unaligned images
 +#
-+# Copyright (C) 2017 Nir Soffer <nirsof@gmail.com>
++# Copyright (C) 2018 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.
 ...
 +#
 +# 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
++seq="$(basename $0)"
 +owner=nirsof@gmail.com
 +
 +seq=`basename $0`
 +echo "QA output created by $seq"
 +
-+here=`pwd`
++here="$PWD"
-+status=1    # failure is the default!
++status=1 # failure is the default!
 +
 +_cleanup()
 +{
-+    _cleanup_test_img
++    _cleanup_test_img
 +}
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
 +
 +_supported_fmt raw
 +_supported_proto file
 +_supported_os Linux
 +
-+size=1m
++echo
 +echo "=== Check mapping of unaligned raw image ==="
 +echo
 +
-+echo
++_make_test_img 43009 # qemu-img create rounds size up
-+echo "== creating image with default preallocation =="
++$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
 +_make_test_img $size | _filter_imgfmt
 +stat -c "size=%s, blocks=%b" $TEST_IMG
 +
-+for mode in off full falloc; do
++truncate --size=43009 "$TEST_IMG" # so we resize it and check again
-+    echo
++$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
-+    echo "== creating image with preallocation $mode =="
++
-+    IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
++$QEMU_IO -c 'w 43008 1' "$TEST_IMG" | _filter_qemu_io # writing also rounds up
-+    stat -c "size=%s, blocks=%b" $TEST_IMG
++$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
-+done
++
 +truncate --size=43009 "$TEST_IMG" # so we resize it and check again
 +$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
 +
 +# success, all done
-+echo "*** done"
++echo '*** done'
 +rm -f $seq.full
 +status=0
-diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
+diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/175.out
++++ b/tests/qemu-iotests/221.out
 @@ -XXX,XX +XXX,XX @@
-+QA output created by 175
++QA output created by 221
 +
-+== creating image with default preallocation ==
++=== Check mapping of unaligned raw image ===
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
 +size=1048576, blocks=0
 +
-+== creating image with preallocation off ==
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=43009
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
++[{ "start": 0, "length": 43520, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-+size=1048576, blocks=0
++[{ "start": 0, "length": 43520, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-+
++wrote 1/1 bytes at offset 43008
-+== creating image with preallocation full ==
++1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
++[{ "start": 0, "length": 40960, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
-+size=1048576, blocks=2048
++{ "start": 40960, "length": 2049, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
-+
++{ "start": 43009, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-+== creating image with preallocation falloc ==
++[{ "start": 0, "length": 40960, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
++{ "start": 40960, "length": 2049, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
-+size=1048576, blocks=2048
++{ "start": 43009, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-+ *** done
++*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
 @@ -XXX,XX +XXX,XX @@
-auto
+rw auto quick
-rw auto
+rw auto quick
-auto
+rw auto
-+175 auto quick
++221 rw auto quick
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 03/26] jobs: fix stale wording
+From: John Snow <jsnow@redhat.com>
+During the design for manual completion, we decided not to use the
+"manual" property as a shorthand for both auto-dismiss and auto-finalize.
+Fix the wording.
+Signed-off-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ qapi/job.json | 11 ++++++-----
+file changed, 6 insertions(+), 5 deletions(-)
+diff --git a/qapi/job.json b/qapi/job.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/job.json
++++ b/qapi/job.json
+@@ -XXX,XX +XXX,XX @@
+ #           the last job in a transaction.
+ #
+ # @pending: The job has finished its work, but has finalization steps that it
+-#           needs to make prior to completing. These changes may require
+-#           manual intervention by the management process if manual was set
+-#           to true. These changes may still fail.
++#           needs to make prior to completing. These changes will require
++#           manual intervention via @job-finalize if auto-finalize was set to
++#           false. These pending changes may still fail.
+ #
+ # @aborting: The job is in the process of being aborted, and will finish with
+ #            an error. The job will afterwards report that it is @concluded.
+ #            This status may not be visible to the management process.
+ #
+-# @concluded: The job has finished all work. If manual was set to true, the job
+-#             will remain in the query list until it is dismissed.
++# @concluded: The job has finished all work. If auto-dismiss was set to false,
++#             the job will remain in the query list until it is dismissed via
++#             @job-dismiss.
+ #
+ # @null: The job is in the process of being dismantled. This state should not
+ #        ever be visible externally.
+--
+.13.6

-[Qemu-devel] [PULL 08/19] iotests: Fix another race in 030
+[Qemu-devel] [PULL 04/26] jobs: fix verb references in docs
 From: John Snow <jsnow@redhat.com>
-We can't rely on a non-paused job to be present and running for us.
+These point to the job versions now, not the blockjob versions which
-Assume that if the job is not present that it completed already.
+don't really exist anymore.
 Except set-speed, which does. It sticks out like a sore thumb. This
 patch doesn't fix that, but it doesn't make it any worse, either.
 Signed-off-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Reviewed-by: Jeff Cody <jcody@redhat.com>
 Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/030 | 5 ++++-
+ qapi/job.json | 12 ++++++------
-file changed, 4 insertions(+), 1 deletion(-)
+file changed, 6 insertions(+), 6 deletions(-)
-diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
+diff --git a/qapi/job.json b/qapi/job.json
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/030
+--- a/qapi/job.json
-+++ b/tests/qemu-iotests/030
++++ b/qapi/job.json
-@@ -XXX,XX +XXX,XX @@ class TestEIO(TestErrors):
+@@ -XXX,XX +XXX,XX @@
-         while not completed:
+ #
-             for event in self.vm.get_qmp_events(wait=True):
+ # Represents command verbs that can be applied to a job.
-                 if event['event'] == 'BLOCK_JOB_ERROR':
+ #
-+                    error = True
+-# @cancel: see @block-job-cancel
-                     self.assert_qmp(event, 'data/device', 'drive0')
++# @cancel: see @job-cancel
-                     self.assert_qmp(event, 'data/operation', 'read')
+ #
-                     result = self.vm.qmp('query-block-jobs')
+-# @pause: see @block-job-pause
-+                    if result == {'return': []}:
++# @pause: see @job-pause
-+                        # Job finished too quickly
+ #
-+                        continue
+-# @resume: see @block-job-resume
-                     self.assert_qmp(result, 'return[0]/paused', False)
++# @resume: see @job-resume
--                    error = True
+ #
-                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
+ # @set-speed: see @block-job-set-speed
-                     self.assertTrue(error, 'job completed unexpectedly')
+ #
-                     self.assert_qmp(event, 'data/type', 'stream')
+-# @complete: see @block-job-complete
 +# @complete: see @job-complete
  #
 -# @dismiss: see @block-job-dismiss
 +# @dismiss: see @job-dismiss
  #
 -# @finalize: see @block-job-finalize
 +# @finalize: see @job-finalize
  #
  # Since: 2.12
  ##
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 05/26] rbd: Drop deprecated -drive parameter "filename"
+From: Markus Armbruster <armbru@redhat.com>
+Parameter "filename" is deprecated since commit 91589d9e5ca, v2.10.0.
+Time to get rid of it.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/rbd.c | 16 ----------------
+file changed, 16 deletions(-)
+diff --git a/block/rbd.c b/block/rbd.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/rbd.c
++++ b/block/rbd.c
+@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
+     QObject *crumpled = NULL;
+     const QDictEntry *e;
+     Error *local_err = NULL;
+-    const char *filename;
+     char *keypairs, *secretid;
+     int r;
+-    /* If we are given a filename, parse the filename, with precedence given to
+-     * filename encoded options */
+-    filename = qdict_get_try_str(options, "filename");
+-    if (filename) {
+-        warn_report("'filename' option specified. "
+-                    "This is an unsupported option, and may be deprecated "
+-                    "in the future");
+-        qemu_rbd_parse_filename(filename, options, &local_err);
+-        qdict_del(options, "filename");
+-        if (local_err) {
+-            error_propagate(errp, local_err);
+-            return -EINVAL;
+-        }
+-    }
+-
+     keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs"));
+     if (keypairs) {
+         qdict_del(options, "=keyvalue-pairs");
+--
+.13.6

-[Qemu-devel] [PULL 19/19] tests: Use opened block node for block job tests
+[Qemu-devel] [PULL 06/26] iscsi: Drop deprecated -drive parameter "filename"
-blk_insert_bs() and block job related functions will soon require an
+From: Markus Armbruster <armbru@redhat.com>
 opened block node (permission calculations will involve the block
 driver), so let our tests be consistent with the real users in this
 respect.
+Parameter "filename" is deprecated since commit 5c3ad1a6a8f, v2.10.0.
+Time to get rid of it.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/test-blockjob-txn.c | 6 +++++-
+ block/iscsi.c | 23 ++---------------------
- tests/test-blockjob.c     | 6 +++++-
+file changed, 2 insertions(+), 21 deletions(-)
 files changed, 10 insertions(+), 2 deletions(-)
-diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
+diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-blockjob-txn.c
+--- a/block/iscsi.c
-+++ b/tests/test-blockjob-txn.c
++++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static BlockJob *test_block_job_start(unsigned int iterations,
+@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
-     char job_id[24];
+             .name = "timeout",
+             .type = QEMU_OPT_NUMBER,
-     data = g_new0(TestBlockJobCBData, 1);
+         },
--    bs = bdrv_new();
+-        {
 -            .name = "filename",
 -            .type = QEMU_OPT_STRING,
 -        },
          { /* end of list */ }
      },
  };
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
      char *initiator_name = NULL;
      QemuOpts *opts;
      Error *local_err = NULL;
 -    const char *transport_name, *portal, *target, *filename;
 +    const char *transport_name, *portal, *target;
  #if LIBISCSI_API_VERSION >= (20160603)
      enum iscsi_transport_type transport;
  #endif
      int i, ret = 0, timeout = 0, lun;
 -    /* If we are given a filename, parse the filename, with precedence given to
 -     * filename encoded options */
 -    filename = qdict_get_try_str(options, "filename");
 -    if (filename) {
 -        warn_report("'filename' option specified. "
 -                    "This is an unsupported option, and may be deprecated "
 -                    "in the future");
 -        iscsi_parse_filename(filename, options, &local_err);
 -        if (local_err) {
 -            ret = -EINVAL;
 -            error_propagate(errp, local_err);
 -            goto exit;
 -        }
 -    }
 -
      opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
      qemu_opts_absorb_qdict(opts, options, &local_err);
      if (local_err) {
@@ -XXX,XX +XXX,XX @@ out:
          }
          memset(iscsilun, 0, sizeof(IscsiLun));
      }
 -exit:
 +
-+    bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
+     return ret;
-+    g_assert_nonnull(bs);
+ }
-+
      snprintf(job_id, sizeof(job_id), "job%u", counter++);
      s = block_job_create(job_id, &test_block_job_driver, bs, 0,
                           BLOCK_JOB_DEFAULT, test_block_job_cb,
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
  int main(int argc, char **argv)
  {
      qemu_init_main_loop(&error_abort);
 +    bdrv_init();
      g_test_init(&argc, &argv, NULL);
      g_test_add_func("/single/success", test_single_job_success);
 diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-blockjob.c
 +++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
  static BlockBackend *create_blk(const char *name)
  {
      BlockBackend *blk = blk_new();
 -    BlockDriverState *bs = bdrv_new();
 +    BlockDriverState *bs;
 +
 +    bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
 +    g_assert_nonnull(bs);
      blk_insert_bs(blk, bs);
      bdrv_unref(bs);
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
  int main(int argc, char **argv)
  {
      qemu_init_main_loop(&error_abort);
 +    bdrv_init();
      g_test_init(&argc, &argv, NULL);
      g_test_add_func("/blockjob/ids", test_job_ids);
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 13/19] block: Attach bs->file only during .bdrv_open()
+[Qemu-devel] [PULL 07/26] block: Add block-specific QDict header
-The way that attaching bs->file worked was a bit unusual in that it was
+From: Max Reitz <mreitz@redhat.com>
-the only child that would be attached to a node which is not opened yet.
-Because of this, the block layer couldn't know yet which permissions the
+There are numerous QDict functions that have been introduced for and are
-driver would eventually need.
+used only by the block layer.  Move their declarations into an own
+header file to reflect that.
-This patch moves the point where bs->file is attached to the beginning
-of the individual .bdrv_open() implementations, so drivers already know
+While qdict_extract_subqdict() is in fact used outside of the block
-what they are going to do with the child. This is also more consistent
+layer (in util/qemu-config.c), it is still a function related very
-with how driver-specific children work.
+closely to how the block layer works with nested QDicts, namely by
+sometimes flattening them.  Therefore, its declaration is put into this
-For a moment, bdrv_open() gets its own BdrvChild to perform image
+header as well and util/qemu-config.c includes it with a comment stating
-probing, but instead of directly assigning this BdrvChild to the BDS, it
+exactly which function it needs.
-becomes a temporary one and the node name is passed as an option to the
-drivers, so that they can simply use bdrv_open_child() to create another
+Suggested-by: Markus Armbruster <armbru@redhat.com>
-reference for their own use.
+Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20180509165530.29561-7-mreitz@redhat.com>
-This duplicated child for (the not opened yet) bs is not the final
+[Copyright note tweaked, superfluous includes dropped]
-state, a follow-up patch will change the image probing code to use a
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
-BlockBackend, which is completely independent of bs.
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c                       | 35 ++++++++++++++++++++++++-----------
+ include/block/qdict.h    | 32 ++++++++++++++++++++++++++++++++
- block/bochs.c                 |  6 ++++++
+ include/qapi/qmp/qdict.h | 17 -----------------
- block/cloop.c                 |  6 ++++++
+ block.c                  |  1 +
- block/crypto.c                |  6 ++++++
+ block/gluster.c          |  1 +
- block/dmg.c                   |  6 ++++++
+ block/iscsi.c            |  1 +
- block/parallels.c             |  6 ++++++
+ block/nbd.c              |  1 +
- block/qcow.c                  |  6 ++++++
+ block/nfs.c              |  1 +
- block/qcow2.c                 | 18 +++++++++++++++---
+ block/parallels.c        |  1 +
- block/qed.c                   | 18 +++++++++++++++---
+ block/qcow.c             |  1 +
- block/raw-format.c            |  6 ++++++
+ block/qcow2.c            |  1 +
- block/replication.c           |  6 ++++++
+ block/qed.c              |  1 +
- block/vdi.c                   |  6 ++++++
+ block/quorum.c           |  1 +
- block/vhdx.c                  |  6 ++++++
+ block/rbd.c              |  1 +
- block/vmdk.c                  |  6 ++++++
+ block/sheepdog.c         |  1 +
- block/vpc.c                   |  6 ++++++
+ block/snapshot.c         |  1 +
- tests/qemu-iotests/051.out    |  4 ++--
+ block/ssh.c              |  1 +
- tests/qemu-iotests/051.pc.out |  4 ++--
+ block/vhdx.c             |  1 +
-files changed, 130 insertions(+), 21 deletions(-)
+ block/vpc.c              |  1 +
+ block/vvfat.c            |  1 +
  block/vxhs.c             |  1 +
  blockdev.c               |  1 +
  qobject/qdict.c          |  1 +
  tests/check-qdict.c      |  1 +
  tests/check-qobject.c    |  1 +
  tests/test-replication.c |  1 +
  util/qemu-config.c       |  1 +
 files changed, 56 insertions(+), 17 deletions(-)
  create mode 100644 include/block/qdict.h
 diff --git a/include/block/qdict.h b/include/block/qdict.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/include/block/qdict.h
@@ -XXX,XX +XXX,XX @@
 +/*
 + * Special QDict functions used by the block layer
 + *
 + * Copyright (c) 2013-2018 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 + * See the COPYING.LIB file in the top-level directory.
 + */
 +
 +#ifndef BLOCK_QDICT_H
 +#define BLOCK_QDICT_H
 +
 +#include "qapi/qmp/qdict.h"
 +
 +void qdict_copy_default(QDict *dst, QDict *src, const char *key);
 +void qdict_set_default_str(QDict *dst, const char *key, const char *val);
 +
 +void qdict_join(QDict *dest, QDict *src, bool overwrite);
 +
 +void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
 +void qdict_array_split(QDict *src, QList **dst);
 +int qdict_array_entries(QDict *src, const char *subqdict);
 +QObject *qdict_crumple(const QDict *src, Error **errp);
 +void qdict_flatten(QDict *qdict);
 +
 +typedef struct QDictRenames {
 +    const char *from;
 +    const char *to;
 +} QDictRenames;
 +bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
 +
 +#endif
 diff --git a/include/qapi/qmp/qdict.h b/include/qapi/qmp/qdict.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qapi/qmp/qdict.h
 +++ b/include/qapi/qmp/qdict.h
@@ -XXX,XX +XXX,XX @@ int64_t qdict_get_try_int(const QDict *qdict, const char *key,
  bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value);
  const char *qdict_get_try_str(const QDict *qdict, const char *key);
 -void qdict_copy_default(QDict *dst, QDict *src, const char *key);
 -void qdict_set_default_str(QDict *dst, const char *key, const char *val);
 -
  QDict *qdict_clone_shallow(const QDict *src);
 -void qdict_flatten(QDict *qdict);
 -
 -void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
 -void qdict_array_split(QDict *src, QList **dst);
 -int qdict_array_entries(QDict *src, const char *subqdict);
 -QObject *qdict_crumple(const QDict *src, Error **errp);
 -
 -void qdict_join(QDict *dest, QDict *src, bool overwrite);
 -
 -typedef struct QDictRenames {
 -    const char *from;
 -    const char *to;
 -} QDictRenames;
 -bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
  #endif /* QDICT_H */
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
+@@ -XXX,XX +XXX,XX @@
-         assert(!drv->bdrv_needs_filename || filename != NULL);
+ #include "block/block_int.h"
-         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
+ #include "block/blockjob.h"
-     } else {
+ #include "block/nbd.h"
--        if (file == NULL) {
++#include "block/qdict.h"
--            error_setg(errp, "Can't use '%s' as a block driver for the "
+ #include "qemu/error-report.h"
--                       "protocol level", drv->format_name);
+ #include "module_block.h"
--            ret = -EINVAL;
+ #include "qemu/module.h"
--            goto free_and_fail;
+diff --git a/block/gluster.c b/block/gluster.c
--        }
+index XXXXXXX..XXXXXXX 100644
--        bs->file = file;
+--- a/block/gluster.c
-         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
++++ b/block/gluster.c
-     }
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/osdep.h"
-@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
+ #include <glusterfs/api/glfs.h>
-     return 0;
+ #include "block/block_int.h"
++#include "block/qdict.h"
- free_and_fail:
+ #include "qapi/error.h"
--    bs->file = NULL;
+ #include "qapi/qmp/qdict.h"
-     g_free(bs->opaque);
+ #include "qapi/qmp/qerror.h"
-     bs->opaque = NULL;
+diff --git a/block/iscsi.c b/block/iscsi.c
-     bs->drv = NULL;
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
+--- a/block/iscsi.c
-     }
++++ b/block/iscsi.c
+@@ -XXX,XX +XXX,XX @@
-     if (child->bs->inherits_from == parent) {
+ #include "qemu/bitops.h"
--        child->bs->inherits_from = NULL;
+ #include "qemu/bitmap.h"
-+        BdrvChild *c;
+ #include "block/block_int.h"
-+
++#include "block/qdict.h"
-+        /* Remove inherits_from only when the last reference between parent and
+ #include "scsi/constants.h"
-+         * child->bs goes away. */
+ #include "qemu/iov.h"
-+        QLIST_FOREACH(c, &parent->children, next) {
+ #include "qemu/option.h"
-+            if (c != child && c->bs == child->bs) {
+diff --git a/block/nbd.c b/block/nbd.c
-+                break;
+index XXXXXXX..XXXXXXX 100644
-+            }
+--- a/block/nbd.c
-+        }
++++ b/block/nbd.c
-+        if (c == NULL) {
+@@ -XXX,XX +XXX,XX @@
-+            child->bs->inherits_from = NULL;
-+        }
+ #include "qemu/osdep.h"
-     }
+ #include "nbd-client.h"
++#include "block/qdict.h"
-     bdrv_root_unref_child(child);
+ #include "qapi/error.h"
-@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
+ #include "qemu/uri.h"
-         qdict_del(options, "backing");
+ #include "block/block_int.h"
-     }
+diff --git a/block/nfs.c b/block/nfs.c
+index XXXXXXX..XXXXXXX 100644
--    /* Open image file without format layer */
+--- a/block/nfs.c
-+    /* Open image file without format layer. This BdrvChild is only used for
++++ b/block/nfs.c
-+     * probing, the block drivers will do their own bdrv_open_child() for the
+@@ -XXX,XX +XXX,XX @@
-+     * same BDS, which is why we put the node name back into options. */
+ #include "qemu/error-report.h"
-     if ((flags & BDRV_O_PROTOCOL) == 0) {
+ #include "qapi/error.h"
-+        /* FIXME Shouldn't attach a child to a node that isn't opened yet. */
+ #include "block/block_int.h"
-         file = bdrv_open_child(filename, options, "file", bs,
++#include "block/qdict.h"
-                                &child_file, true, &local_err);
+ #include "trace.h"
-         if (local_err) {
+ #include "qemu/iov.h"
-             goto fail;
+ #include "qemu/option.h"
          }
 +        if (file != NULL) {
 +            qdict_put(options, "file",
 +                      qstring_from_str(bdrv_get_node_name(file->bs)));
 +        }
      }
      /* Image format probing */
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
          goto fail;
      }
 -    if (file && (bs->file != file)) {
 +    if (file) {
          bdrv_unref_child(bs, file);
          file = NULL;
      }
@@ -XXX,XX +XXX,XX @@ fail:
      if (file != NULL) {
          bdrv_unref_child(bs, file);
      }
 +    if (bs->file != NULL) {
 +        bdrv_unref_child(bs, bs->file);
 +    }
      QDECREF(snapshot_options);
      QDECREF(bs->explicit_options);
      QDECREF(bs->options);
 diff --git a/block/bochs.c b/block/bochs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/bochs.c
 +++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
      struct bochs_header bochs;
      int ret;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      bs->read_only = true; /* no write support yet */
      ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
 diff --git a/block/cloop.c b/block/cloop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/cloop.c
 +++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
      uint32_t offsets_size, max_compressed_block_size = 1, i;
      int ret;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      bs->read_only = true;
      /* read header */
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
      QCryptoBlockOpenOptions *open_opts = NULL;
      unsigned int cflags = 0;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
      qemu_opts_absorb_qdict(opts, options, &local_err);
      if (local_err) {
 diff --git a/block/dmg.c b/block/dmg.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/dmg.c
 +++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
      int64_t offset;
      int ret;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      block_module_load_one("dmg-bz2");
      bs->read_only = true;
 diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
-@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@
-     Error *local_err = NULL;
+ #include "qemu/osdep.h"
-     char *buf;
+ #include "qapi/error.h"
+ #include "block/block_int.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++#include "block/qdict.h"
-+                               false, errp);
+ #include "sysemu/block-backend.h"
-+    if (!bs->file) {
+ #include "qemu/module.h"
-+        return -EINVAL;
+ #include "qemu/option.h"
 +    }
 +
      ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
      if (ret < 0) {
          goto fail;
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
-@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@
-     QCowHeader header;
+ #include "qapi/error.h"
-     Error *local_err = NULL;
+ #include "qemu/error-report.h"
+ #include "block/block_int.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++#include "block/qdict.h"
-+                               false, errp);
+ #include "sysemu/block-backend.h"
-+    if (!bs->file) {
+ #include "qemu/module.h"
-+        return -EINVAL;
+ #include "qemu/option.h"
 +    }
 +
      ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
      if (ret < 0) {
          goto fail;
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_update_options(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@
-     return ret;
- }
+ #include "qemu/osdep.h"
+ #include "block/block_int.h"
--static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
++#include "block/qdict.h"
--                      Error **errp)
+ #include "sysemu/block-backend.h"
-+static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+ #include "qemu/module.h"
-+                         Error **errp)
+ #include <zlib.h>
  {
      BDRVQcow2State *s = bs->opaque;
      unsigned int len, i;
@@ -XXX,XX +XXX,XX @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
      return ret;
  }
 +static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
 +                      Error **errp)
 +{
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
 +    return qcow2_do_open(bs, options, flags, errp);
 +}
 +
  static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
  {
      BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
      options = qdict_clone_shallow(bs->options);
      flags &= ~BDRV_O_INACTIVE;
 -    ret = qcow2_open(bs, options, flags, &local_err);
 +    ret = qcow2_do_open(bs, options, flags, &local_err);
      QDECREF(options);
      if (local_err) {
          error_propagate(errp, local_err);
 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 void bdrv_qed_drain(BlockDriverState *bs)
+@@ -XXX,XX +XXX,XX @@
-     }
+  */
- }
+ #include "qemu/osdep.h"
--static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
++#include "block/qdict.h"
--                         Error **errp)
+ #include "qapi/error.h"
-+static int bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags,
+ #include "qemu/timer.h"
-+                            Error **errp)
+ #include "qemu/bswap.h"
- {
+diff --git a/block/quorum.c b/block/quorum.c
-     BDRVQEDState *s = bs->opaque;
+index XXXXXXX..XXXXXXX 100644
-     QEDHeader le_header;
+--- a/block/quorum.c
-@@ -XXX,XX +XXX,XX @@ out:
++++ b/block/quorum.c
-     return ret;
+@@ -XXX,XX +XXX,XX @@
- }
+ #include "qemu/cutils.h"
+ #include "qemu/option.h"
-+static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
+ #include "block/block_int.h"
-+                         Error **errp)
++#include "block/qdict.h"
-+{
+ #include "qapi/error.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+ #include "qapi/qapi-events-block.h"
-+                               false, errp);
+ #include "qapi/qmp/qdict.h"
-+    if (!bs->file) {
+diff --git a/block/rbd.c b/block/rbd.c
-+        return -EINVAL;
+index XXXXXXX..XXXXXXX 100644
-+    }
+--- a/block/rbd.c
-+
++++ b/block/rbd.c
-+    return bdrv_qed_do_open(bs, options, flags, errp);
+@@ -XXX,XX +XXX,XX @@
-+}
+ #include "qemu/error-report.h"
-+
+ #include "qemu/option.h"
- static void bdrv_qed_refresh_limits(BlockDriverState *bs, Error **errp)
+ #include "block/block_int.h"
- {
++#include "block/qdict.h"
-     BDRVQEDState *s = bs->opaque;
+ #include "crypto/secret.h"
-@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_invalidate_cache(BlockDriverState *bs, Error **errp)
+ #include "qemu/cutils.h"
-     bdrv_qed_close(bs);
+ #include "qapi/qmp/qstring.h"
+diff --git a/block/sheepdog.c b/block/sheepdog.c
-     memset(s, 0, sizeof(BDRVQEDState));
+index XXXXXXX..XXXXXXX 100644
--    ret = bdrv_qed_open(bs, NULL, bs->open_flags, &local_err);
+--- a/block/sheepdog.c
-+    ret = bdrv_qed_do_open(bs, NULL, bs->open_flags, &local_err);
++++ b/block/sheepdog.c
-     if (local_err) {
+@@ -XXX,XX +XXX,XX @@
-         error_propagate(errp, local_err);
+ #include "qemu/option.h"
-         error_prepend(errp, "Could not reopen qed layer: ");
+ #include "qemu/sockets.h"
-diff --git a/block/raw-format.c b/block/raw-format.c
+ #include "block/block_int.h"
-index XXXXXXX..XXXXXXX 100644
++#include "block/qdict.h"
---- a/block/raw-format.c
+ #include "sysemu/block-backend.h"
-+++ b/block/raw-format.c
+ #include "qemu/bitops.h"
-@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
+ #include "qemu/cutils.h"
-     BDRVRawState *s = bs->opaque;
+diff --git a/block/snapshot.c b/block/snapshot.c
-     int ret;
+index XXXXXXX..XXXXXXX 100644
+--- a/block/snapshot.c
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++++ b/block/snapshot.c
-+                               false, errp);
+@@ -XXX,XX +XXX,XX @@
-+    if (!bs->file) {
+ #include "qemu/osdep.h"
-+        return -EINVAL;
+ #include "block/snapshot.h"
-+    }
+ #include "block/block_int.h"
-+
++#include "block/qdict.h"
-     bs->sg = bs->file->bs->sg;
+ #include "qapi/error.h"
-     bs->supported_write_flags = BDRV_REQ_FUA &
+ #include "qapi/qmp/qdict.h"
-         bs->file->bs->supported_write_flags;
+ #include "qapi/qmp/qerror.h"
-diff --git a/block/replication.c b/block/replication.c
+diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/replication.c
+--- a/block/ssh.c
-+++ b/block/replication.c
++++ b/block/ssh.c
-@@ -XXX,XX +XXX,XX @@ static int replication_open(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@
-     const char *mode;
+ #include <libssh2_sftp.h>
-     const char *top_id;
+ #include "block/block_int.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++#include "block/qdict.h"
-+                               false, errp);
+ #include "qapi/error.h"
-+    if (!bs->file) {
+ #include "qemu/error-report.h"
-+        return -EINVAL;
+ #include "qemu/option.h"
 +    }
 +
      ret = -EINVAL;
      opts = qemu_opts_create(&replication_runtime_opts, NULL, 0, &error_abort);
      qemu_opts_absorb_qdict(opts, options, &local_err);
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
      int ret;
      Error *local_err = NULL;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      logout("\n");
      ret = bdrv_read(bs->file, 0, (uint8_t *)&header, 1);
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
-@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@
-     uint64_t signature;
+ #include "qemu/osdep.h"
-     Error *local_err = NULL;
+ #include "qapi/error.h"
+ #include "block/block_int.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++#include "block/qdict.h"
-+                               false, errp);
+ #include "sysemu/block-backend.h"
-+    if (!bs->file) {
+ #include "qemu/module.h"
-+        return -EINVAL;
+ #include "qemu/option.h"
 +    }
 +
      s->bat = NULL;
      s->first_visible_write = true;
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
      uint32_t magic;
      Error *local_err = NULL;
 +    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
 +                               false, errp);
 +    if (!bs->file) {
 +        return -EINVAL;
 +    }
 +
      buf = vmdk_read_desc(bs->file, 0, errp);
      if (!buf) {
          return -EINVAL;
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
-@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@
-     int disk_type = VHD_DYNAMIC;
+ #include "qemu/osdep.h"
-     int ret;
+ #include "qapi/error.h"
+ #include "block/block_int.h"
-+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
++#include "block/qdict.h"
-+                               false, errp);
+ #include "sysemu/block-backend.h"
-+    if (!bs->file) {
+ #include "qemu/module.h"
-+        return -EINVAL;
+ #include "qemu/option.h"
-+    }
+diff --git a/block/vvfat.c b/block/vvfat.c
-+
+index XXXXXXX..XXXXXXX 100644
-     opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
+--- a/block/vvfat.c
-     qemu_opts_absorb_qdict(opts, options, &local_err);
++++ b/block/vvfat.c
-     if (local_err) {
+@@ -XXX,XX +XXX,XX @@
-diff --git a/tests/qemu-iotests/051.out b/tests/qemu-iotests/051.out
+ #include <dirent.h>
-index XXXXXXX..XXXXXXX 100644
+ #include "qapi/error.h"
---- a/tests/qemu-iotests/051.out
+ #include "block/block_int.h"
-+++ b/tests/qemu-iotests/051.out
++#include "block/qdict.h"
-@@ -XXX,XX +XXX,XX @@ Testing: -drive driver=nbd
+ #include "qemu/module.h"
- QEMU_PROG: -drive driver=nbd: NBD server address missing
+ #include "qemu/option.h"
+ #include "qemu/bswap.h"
- Testing: -drive driver=raw
+diff --git a/block/vxhs.c b/block/vxhs.c
--QEMU_PROG: -drive driver=raw: Can't use 'raw' as a block driver for the protocol level
+index XXXXXXX..XXXXXXX 100644
-+QEMU_PROG: -drive driver=raw: A block device must be specified for "file"
+--- a/block/vxhs.c
++++ b/block/vxhs.c
- Testing: -drive file.driver=file
+@@ -XXX,XX +XXX,XX @@
- QEMU_PROG: -drive file.driver=file: The 'file' block driver requires a file name
+ #include <qnio/qnio_api.h>
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file.driver=nbd
+ #include <sys/param.h>
- QEMU_PROG: -drive file.driver=nbd: NBD server address missing
+ #include "block/block_int.h"
++#include "block/qdict.h"
- Testing: -drive file.driver=raw
+ #include "qapi/qmp/qerror.h"
--QEMU_PROG: -drive file.driver=raw: Can't use 'raw' as a block driver for the protocol level
+ #include "qapi/qmp/qdict.h"
-+QEMU_PROG: -drive file.driver=raw: A block device must be specified for "file"
+ #include "qapi/qmp/qstring.h"
+diff --git a/blockdev.c b/blockdev.c
- Testing: -drive foo=bar
+index XXXXXXX..XXXXXXX 100644
- QEMU_PROG: -drive foo=bar: Must specify either driver or file
+--- a/blockdev.c
-diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out
++++ b/blockdev.c
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@
---- a/tests/qemu-iotests/051.pc.out
+ #include "sysemu/blockdev.h"
-+++ b/tests/qemu-iotests/051.pc.out
+ #include "hw/block/block.h"
-@@ -XXX,XX +XXX,XX @@ Testing: -drive driver=nbd
+ #include "block/blockjob.h"
- QEMU_PROG: -drive driver=nbd: NBD server address missing
++#include "block/qdict.h"
+ #include "block/throttle-groups.h"
- Testing: -drive driver=raw
+ #include "monitor/monitor.h"
--QEMU_PROG: -drive driver=raw: Can't use 'raw' as a block driver for the protocol level
+ #include "qemu/error-report.h"
-+QEMU_PROG: -drive driver=raw: A block device must be specified for "file"
+diff --git a/qobject/qdict.c b/qobject/qdict.c
+index XXXXXXX..XXXXXXX 100644
- Testing: -drive file.driver=file
+--- a/qobject/qdict.c
- QEMU_PROG: -drive file.driver=file: The 'file' block driver requires a file name
++++ b/qobject/qdict.c
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file.driver=nbd
+@@ -XXX,XX +XXX,XX @@
- QEMU_PROG: -drive file.driver=nbd: NBD server address missing
+  */
- Testing: -drive file.driver=raw
+ #include "qemu/osdep.h"
--QEMU_PROG: -drive file.driver=raw: Can't use 'raw' as a block driver for the protocol level
++#include "block/qdict.h"
-+QEMU_PROG: -drive file.driver=raw: A block device must be specified for "file"
+ #include "qapi/qmp/qnum.h"
+ #include "qapi/qmp/qdict.h"
- Testing: -drive foo=bar
+ #include "qapi/qmp/qbool.h"
- QEMU_PROG: -drive foo=bar: Must specify either driver or file
+diff --git a/tests/check-qdict.c b/tests/check-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/check-qdict.c
 +++ b/tests/check-qdict.c
@@ -XXX,XX +XXX,XX @@
   */
  #include "qemu/osdep.h"
 +#include "block/qdict.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qlist.h"
  #include "qapi/qmp/qnum.h"
 diff --git a/tests/check-qobject.c b/tests/check-qobject.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/check-qobject.c
 +++ b/tests/check-qobject.c
@@ -XXX,XX +XXX,XX @@
   */
  #include "qemu/osdep.h"
 +#include "block/qdict.h"
  #include "qapi/qmp/qbool.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qlist.h"
 diff --git a/tests/test-replication.c b/tests/test-replication.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-replication.c
 +++ b/tests/test-replication.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/option.h"
  #include "replication.h"
  #include "block/block_int.h"
 +#include "block/qdict.h"
  #include "sysemu/block-backend.h"
  #define IMG_SIZE (64 * 1024 * 1024)
 diff --git a/util/qemu-config.c b/util/qemu-config.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-config.c
 +++ b/util/qemu-config.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
 +#include "block/qdict.h" /* for qdict_extract_subqdict() */
  #include "qapi/error.h"
  #include "qapi/qapi-commands-misc.h"
  #include "qapi/qmp/qdict.h"
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 11/19] mirror: Resize active commit base in mirror_run()
+[Qemu-devel] [PULL 08/26] qobject: Move block-specific qdict code to block-qdict.c
-This is more consistent with the commit block job, and it moves the code
+From: Markus Armbruster <armbru@redhat.com>
 to a place where we already have the necessary BlockBackends to resize
 the base image when bdrv_truncate() is changed to require a BdrvChild.
+Pure code motion, except for two brace placements and a comment
+tweaked to appease checkpatch.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block/mirror.c | 50 ++++++++++++++++++++++----------------------------
+ qobject/block-qdict.c     | 640 ++++++++++++++++++++++++++++++++++++++++++++
-file changed, 22 insertions(+), 28 deletions(-)
+ qobject/qdict.c           | 629 --------------------------------------------
  tests/check-block-qdict.c | 655 ++++++++++++++++++++++++++++++++++++++++++++++
  tests/check-qdict.c       | 642 ---------------------------------------------
  MAINTAINERS               |   2 +
  qobject/Makefile.objs     |   1 +
  tests/Makefile.include    |   4 +
 files changed, 1302 insertions(+), 1271 deletions(-)
  create mode 100644 qobject/block-qdict.c
  create mode 100644 tests/check-block-qdict.c
-diff --git a/block/mirror.c b/block/mirror.c
+diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
-index XXXXXXX..XXXXXXX 100644
+new file mode 100644
---- a/block/mirror.c
+index XXXXXXX..XXXXXXX
-+++ b/block/mirror.c
+--- /dev/null
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_run(void *opaque)
++++ b/qobject/block-qdict.c
-     if (s->bdev_length < 0) {
+@@ -XXX,XX +XXX,XX @@
-         ret = s->bdev_length;
++/*
-         goto immediate_exit;
++ * Special QDict functions used by the block layer
--    } else if (s->bdev_length == 0) {
++ *
 + * Copyright (c) 2013-2018 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 + * See the COPYING.LIB file in the top-level directory.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "block/qdict.h"
 +#include "qapi/qmp/qlist.h"
 +#include "qemu/cutils.h"
 +#include "qapi/error.h"
 +
 +/**
 + * qdict_copy_default(): If no entry mapped by 'key' exists in 'dst' yet, the
 + * value of 'key' in 'src' is copied there (and the refcount increased
 + * accordingly).
 + */
 +void qdict_copy_default(QDict *dst, QDict *src, const char *key)
 +{
 +    QObject *val;
 +
 +    if (qdict_haskey(dst, key)) {
 +        return;
 +    }
 +
-+    /* Active commit must resize the base image if its size differs from the
++    val = qdict_get(src, key);
-+     * active layer. */
++    if (val) {
-+    if (s->base == blk_bs(s->target)) {
++        qdict_put_obj(dst, key, qobject_ref(val));
-+        int64_t base_length;
++    }
-+
++}
-+        base_length = blk_getlength(s->target);
++
-+        if (base_length < 0) {
++/**
-+            ret = base_length;
++ * qdict_set_default_str(): If no entry mapped by 'key' exists in 'dst' yet, a
-+            goto immediate_exit;
++ * new QString initialised by 'val' is put there.
 + */
 +void qdict_set_default_str(QDict *dst, const char *key, const char *val)
 +{
 +    if (qdict_haskey(dst, key)) {
 +        return;
 +    }
 +
 +    qdict_put_str(dst, key, val);
 +}
 +
 +static void qdict_flatten_qdict(QDict *qdict, QDict *target,
 +                                const char *prefix);
 +
 +static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
 +{
 +    QObject *value;
 +    const QListEntry *entry;
 +    char *new_key;
 +    int i;
 +
 +    /* This function is never called with prefix == NULL, i.e., it is always
 +     * called from within qdict_flatten_q(list|dict)(). Therefore, it does not
 +     * need to remove list entries during the iteration (the whole list will be
 +     * deleted eventually anyway from qdict_flatten_qdict()). */
 +    assert(prefix);
 +
 +    entry = qlist_first(qlist);
 +
 +    for (i = 0; entry; entry = qlist_next(entry), i++) {
 +        value = qlist_entry_obj(entry);
 +        new_key = g_strdup_printf("%s.%i", prefix, i);
 +
 +        if (qobject_type(value) == QTYPE_QDICT) {
 +            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
 +        } else if (qobject_type(value) == QTYPE_QLIST) {
 +            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
 +        } else {
 +            /* All other types are moved to the target unchanged. */
 +            qdict_put_obj(target, new_key, qobject_ref(value));
 +        }
 +
-+        if (s->bdev_length > base_length) {
++        g_free(new_key);
-+            ret = blk_truncate(s->target, s->bdev_length);
++    }
-+            if (ret < 0) {
++}
-+                goto immediate_exit;
++
 +static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
 +{
 +    QObject *value;
 +    const QDictEntry *entry, *next;
 +    char *new_key;
 +    bool delete;
 +
 +    entry = qdict_first(qdict);
 +
 +    while (entry != NULL) {
 +
 +        next = qdict_next(qdict, entry);
 +        value = qdict_entry_value(entry);
 +        new_key = NULL;
 +        delete = false;
 +
 +        if (prefix) {
 +            new_key = g_strdup_printf("%s.%s", prefix, entry->key);
 +        }
 +
 +        if (qobject_type(value) == QTYPE_QDICT) {
 +            /* Entries of QDicts are processed recursively, the QDict object
 +             * itself disappears. */
 +            qdict_flatten_qdict(qobject_to(QDict, value), target,
 +                                new_key ? new_key : entry->key);
 +            delete = true;
 +        } else if (qobject_type(value) == QTYPE_QLIST) {
 +            qdict_flatten_qlist(qobject_to(QList, value), target,
 +                                new_key ? new_key : entry->key);
 +            delete = true;
 +        } else if (prefix) {
 +            /* All other objects are moved to the target unchanged. */
 +            qdict_put_obj(target, new_key, qobject_ref(value));
 +            delete = true;
 +        }
 +
 +        g_free(new_key);
 +
 +        if (delete) {
 +            qdict_del(qdict, entry->key);
 +
 +            /* Restart loop after modifying the iterated QDict */
 +            entry = qdict_first(qdict);
 +            continue;
 +        }
 +
 +        entry = next;
 +    }
 +}
 +
 +/**
 + * qdict_flatten(): For each nested QDict with key x, all fields with key y
 + * are moved to this QDict and their key is renamed to "x.y". For each nested
 + * QList with key x, the field at index y is moved to this QDict with the key
 + * "x.y" (i.e., the reverse of what qdict_array_split() does).
 + * This operation is applied recursively for nested QDicts and QLists.
 + */
 +void qdict_flatten(QDict *qdict)
 +{
 +    qdict_flatten_qdict(qdict, qdict, NULL);
 +}
 +
 +/* extract all the src QDict entries starting by start into dst */
 +void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
 +
 +{
 +    const QDictEntry *entry, *next;
 +    const char *p;
 +
 +    *dst = qdict_new();
 +    entry = qdict_first(src);
 +
 +    while (entry != NULL) {
 +        next = qdict_next(src, entry);
 +        if (strstart(entry->key, start, &p)) {
 +            qdict_put_obj(*dst, p, qobject_ref(entry->value));
 +            qdict_del(src, entry->key);
 +        }
 +        entry = next;
 +    }
 +}
 +
 +static int qdict_count_prefixed_entries(const QDict *src, const char *start)
 +{
 +    const QDictEntry *entry;
 +    int count = 0;
 +
 +    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
 +        if (strstart(entry->key, start, NULL)) {
 +            if (count == INT_MAX) {
 +                return -ERANGE;
 +            }
 +            count++;
 +        }
 +    }
 +
 +    return count;
 +}
 +
 +/**
 + * qdict_array_split(): This function moves array-like elements of a QDict into
 + * a new QList. Every entry in the original QDict with a key "%u" or one
 + * prefixed "%u.", where %u designates an unsigned integer starting at 0 and
 + * incrementally counting up, will be moved to a new QDict at index %u in the
 + * output QList with the key prefix removed, if that prefix is "%u.". If the
 + * whole key is just "%u", the whole QObject will be moved unchanged without
 + * creating a new QDict. The function terminates when there is no entry in the
 + * QDict with a prefix directly (incrementally) following the last one; it also
 + * returns if there are both entries with "%u" and "%u." for the same index %u.
 + * Example: {"0.a": 42, "0.b": 23, "1.x": 0, "4.y": 1, "o.o": 7, "2": 66}
 + *      (or {"1.x": 0, "4.y": 1, "0.a": 42, "o.o": 7, "0.b": 23, "2": 66})
 + *       => [{"a": 42, "b": 23}, {"x": 0}, 66]
 + *      and {"4.y": 1, "o.o": 7} (remainder of the old QDict)
 + */
 +void qdict_array_split(QDict *src, QList **dst)
 +{
 +    unsigned i;
 +
 +    *dst = qlist_new();
 +
 +    for (i = 0; i < UINT_MAX; i++) {
 +        QObject *subqobj;
 +        bool is_subqdict;
 +        QDict *subqdict;
 +        char indexstr[32], prefix[32];
 +        size_t snprintf_ret;
 +
 +        snprintf_ret = snprintf(indexstr, 32, "%u", i);
 +        assert(snprintf_ret < 32);
 +
 +        subqobj = qdict_get(src, indexstr);
 +
 +        snprintf_ret = snprintf(prefix, 32, "%u.", i);
 +        assert(snprintf_ret < 32);
 +
 +        /* Overflow is the same as positive non-zero results */
 +        is_subqdict = qdict_count_prefixed_entries(src, prefix);
 +
 +        /*
 +         * There may be either a single subordinate object (named
 +         * "%u") or multiple objects (each with a key prefixed "%u."),
 +         * but not both.
 +         */
 +        if (!subqobj == !is_subqdict) {
 +            break;
 +        }
 +
 +        if (is_subqdict) {
 +            qdict_extract_subqdict(src, &subqdict, prefix);
 +            assert(qdict_size(subqdict) > 0);
 +        } else {
 +            qobject_ref(subqobj);
 +            qdict_del(src, indexstr);
 +        }
 +
 +        qlist_append_obj(*dst, subqobj ?: QOBJECT(subqdict));
 +    }
 +}
 +
 +/**
 + * qdict_split_flat_key:
 + * @key: the key string to split
 + * @prefix: non-NULL pointer to hold extracted prefix
 + * @suffix: non-NULL pointer to remaining suffix
 + *
 + * Given a flattened key such as 'foo.0.bar', split it into two parts
 + * at the first '.' separator. Allows double dot ('..') to escape the
 + * normal separator.
 + *
 + * e.g.
 + *    'foo.0.bar' -> prefix='foo' and suffix='0.bar'
 + *    'foo..0.bar' -> prefix='foo.0' and suffix='bar'
 + *
 + * The '..' sequence will be unescaped in the returned 'prefix'
 + * string. The 'suffix' string will be left in escaped format, so it
 + * can be fed back into the qdict_split_flat_key() key as the input
 + * later.
 + *
 + * The caller is responsible for freeing the string returned in @prefix
 + * using g_free().
 + */
 +static void qdict_split_flat_key(const char *key, char **prefix,
 +                                 const char **suffix)
 +{
 +    const char *separator;
 +    size_t i, j;
 +
 +    /* Find first '.' separator, but if there is a pair '..'
 +     * that acts as an escape, so skip over '..' */
 +    separator = NULL;
 +    do {
 +        if (separator) {
 +            separator += 2;
 +        } else {
 +            separator = key;
 +        }
 +        separator = strchr(separator, '.');
 +    } while (separator && separator[1] == '.');
 +
 +    if (separator) {
 +        *prefix = g_strndup(key, separator - key);
 +        *suffix = separator + 1;
 +    } else {
 +        *prefix = g_strdup(key);
 +        *suffix = NULL;
 +    }
 +
 +    /* Unescape the '..' sequence into '.' */
 +    for (i = 0, j = 0; (*prefix)[i] != '\0'; i++, j++) {
 +        if ((*prefix)[i] == '.') {
 +            assert((*prefix)[i + 1] == '.');
 +            i++;
 +        }
 +        (*prefix)[j] = (*prefix)[i];
 +    }
 +    (*prefix)[j] = '\0';
 +}
 +
 +/**
 + * qdict_is_list:
 + * @maybe_list: dict to check if keys represent list elements.
 + *
 + * Determine whether all keys in @maybe_list are valid list elements.
 + * If @maybe_list is non-zero in length and all the keys look like
 + * valid list indexes, this will return 1. If @maybe_list is zero
 + * length or all keys are non-numeric then it will return 0 to indicate
 + * it is a normal qdict. If there is a mix of numeric and non-numeric
 + * keys, or the list indexes are non-contiguous, an error is reported.
 + *
 + * Returns: 1 if a valid list, 0 if a dict, -1 on error
 + */
 +static int qdict_is_list(QDict *maybe_list, Error **errp)
 +{
 +    const QDictEntry *ent;
 +    ssize_t len = 0;
 +    ssize_t max = -1;
 +    int is_list = -1;
 +    int64_t val;
 +
 +    for (ent = qdict_first(maybe_list); ent != NULL;
 +         ent = qdict_next(maybe_list, ent)) {
 +
 +        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
 +            if (is_list == -1) {
 +                is_list = 1;
 +            } else if (!is_list) {
 +                error_setg(errp,
 +                           "Cannot mix list and non-list keys");
 +                return -1;
 +            }
 +            len++;
 +            if (val > max) {
 +                max = val;
 +            }
 +        } else {
 +            if (is_list == -1) {
 +                is_list = 0;
 +            } else if (is_list) {
 +                error_setg(errp,
 +                           "Cannot mix list and non-list keys");
 +                return -1;
 +            }
 +        }
 +    }
 +
-+    if (s->bdev_length == 0) {
++    if (is_list == -1) {
-         /* Report BLOCK_JOB_READY and wait for complete. */
++        assert(!qdict_size(maybe_list));
-         block_job_event_ready(&s->common);
++        is_list = 0;
-         s->synced = true;
++    }
-@@ -XXX,XX +XXX,XX @@ void commit_active_start(const char *job_id, BlockDriverState *bs,
++
-                          BlockCompletionFunc *cb, void *opaque, Error **errp,
++    /* NB this isn't a perfect check - e.g. it won't catch
-                          bool auto_complete)
++     * a list containing '1', '+1', '01', '3', but that
- {
++     * does not matter - we've still proved that the
--    int64_t length, base_length;
++     * input is a list. It is up the caller to do a
-     int orig_base_flags;
++     * stricter check if desired */
--    int ret;
++    if (len != (max + 1)) {
-     Error *local_err = NULL;
++        error_setg(errp, "List indices are not contiguous, "
++                   "saw %zd elements but %zd largest index",
-     orig_base_flags = bdrv_get_flags(base);
++                   len, max);
-@@ -XXX,XX +XXX,XX @@ void commit_active_start(const char *job_id, BlockDriverState *bs,
++        return -1;
-         return;
++    }
-     }
++
++    return is_list;
--    length = bdrv_getlength(bs);
++}
--    if (length < 0) {
++
--        error_setg_errno(errp, -length,
++/**
--                         "Unable to determine length of %s", bs->filename);
++ * qdict_crumple:
--        goto error_restore_flags;
++ * @src: the original flat dictionary (only scalar values) to crumple
 + *
 + * Takes a flat dictionary whose keys use '.' separator to indicate
 + * nesting, and values are scalars, and crumples it into a nested
 + * structure.
 + *
 + * To include a literal '.' in a key name, it must be escaped as '..'
 + *
 + * For example, an input of:
 + *
 + * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
 + *   'foo.1.bar': 'two', 'foo.1.wizz': '2' }
 + *
 + * will result in an output of:
 + *
 + * {
 + *   'foo': [
 + *      { 'bar': 'one', 'wizz': '1' },
 + *      { 'bar': 'two', 'wizz': '2' }
 + *   ],
 + * }
 + *
 + * The following scenarios in the input dict will result in an
 + * error being returned:
 + *
 + *  - Any values in @src are non-scalar types
 + *  - If keys in @src imply that a particular level is both a
 + *    list and a dict. e.g., "foo.0.bar" and "foo.eek.bar".
 + *  - If keys in @src imply that a particular level is a list,
 + *    but the indices are non-contiguous. e.g. "foo.0.bar" and
 + *    "foo.2.bar" without any "foo.1.bar" present.
 + *  - If keys in @src represent list indexes, but are not in
 + *    the "%zu" format. e.g. "foo.+0.bar"
 + *
 + * Returns: either a QDict or QList for the nested data structure, or NULL
 + * on error
 + */
 +QObject *qdict_crumple(const QDict *src, Error **errp)
 +{
 +    const QDictEntry *ent;
 +    QDict *two_level, *multi_level = NULL;
 +    QObject *dst = NULL, *child;
 +    size_t i;
 +    char *prefix = NULL;
 +    const char *suffix = NULL;
 +    int is_list;
 +
 +    two_level = qdict_new();
 +
 +    /* Step 1: split our totally flat dict into a two level dict */
 +    for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
 +        if (qobject_type(ent->value) == QTYPE_QDICT ||
 +            qobject_type(ent->value) == QTYPE_QLIST) {
 +            error_setg(errp, "Value %s is not a scalar",
 +                       ent->key);
 +            goto error;
 +        }
 +
 +        qdict_split_flat_key(ent->key, &prefix, &suffix);
 +
 +        child = qdict_get(two_level, prefix);
 +        if (suffix) {
 +            QDict *child_dict = qobject_to(QDict, child);
 +            if (!child_dict) {
 +                if (child) {
 +                    error_setg(errp, "Key %s prefix is already set as a scalar",
 +                               prefix);
 +                    goto error;
 +                }
 +
 +                child_dict = qdict_new();
 +                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
 +            }
 +
 +            qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
 +        } else {
 +            if (child) {
 +                error_setg(errp, "Key %s prefix is already set as a dict",
 +                           prefix);
 +                goto error;
 +            }
 +            qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
 +        }
 +
 +        g_free(prefix);
 +        prefix = NULL;
 +    }
 +
 +    /* Step 2: optionally process the two level dict recursively
 +     * into a multi-level dict */
 +    multi_level = qdict_new();
 +    for (ent = qdict_first(two_level); ent != NULL;
 +         ent = qdict_next(two_level, ent)) {
 +        QDict *dict = qobject_to(QDict, ent->value);
 +        if (dict) {
 +            child = qdict_crumple(dict, errp);
 +            if (!child) {
 +                goto error;
 +            }
 +
 +            qdict_put_obj(multi_level, ent->key, child);
 +        } else {
 +            qdict_put_obj(multi_level, ent->key, qobject_ref(ent->value));
 +        }
 +    }
 +    qobject_unref(two_level);
 +    two_level = NULL;
 +
 +    /* Step 3: detect if we need to turn our dict into list */
 +    is_list = qdict_is_list(multi_level, errp);
 +    if (is_list < 0) {
 +        goto error;
 +    }
 +
 +    if (is_list) {
 +        dst = QOBJECT(qlist_new());
 +
 +        for (i = 0; i < qdict_size(multi_level); i++) {
 +            char *key = g_strdup_printf("%zu", i);
 +
 +            child = qdict_get(multi_level, key);
 +            g_free(key);
 +
 +            if (!child) {
 +                error_setg(errp, "Missing list index %zu", i);
 +                goto error;
 +            }
 +
 +            qlist_append_obj(qobject_to(QList, dst), qobject_ref(child));
 +        }
 +        qobject_unref(multi_level);
 +        multi_level = NULL;
 +    } else {
 +        dst = QOBJECT(multi_level);
 +    }
 +
 +    return dst;
 +
 + error:
 +    g_free(prefix);
 +    qobject_unref(multi_level);
 +    qobject_unref(two_level);
 +    qobject_unref(dst);
 +    return NULL;
 +}
 +
 +/**
 + * qdict_array_entries(): Returns the number of direct array entries if the
 + * sub-QDict of src specified by the prefix in subqdict (or src itself for
 + * prefix == "") is valid as an array, i.e. the length of the created list if
 + * the sub-QDict would become empty after calling qdict_array_split() on it. If
 + * the array is not valid, -EINVAL is returned.
 + */
 +int qdict_array_entries(QDict *src, const char *subqdict)
 +{
 +    const QDictEntry *entry;
 +    unsigned i;
 +    unsigned entries = 0;
 +    size_t subqdict_len = strlen(subqdict);
 +
 +    assert(!subqdict_len || subqdict[subqdict_len - 1] == '.');
 +
 +    /* qdict_array_split() loops until UINT_MAX, but as we want to return
 +     * negative errors, we only have a signed return value here. Any additional
 +     * entries will lead to -EINVAL. */
 +    for (i = 0; i < INT_MAX; i++) {
 +        QObject *subqobj;
 +        int subqdict_entries;
 +        char *prefix = g_strdup_printf("%s%u.", subqdict, i);
 +
 +        subqdict_entries = qdict_count_prefixed_entries(src, prefix);
 +
 +        /* Remove ending "." */
 +        prefix[strlen(prefix) - 1] = 0;
 +        subqobj = qdict_get(src, prefix);
 +
 +        g_free(prefix);
 +
 +        if (subqdict_entries < 0) {
 +            return subqdict_entries;
 +        }
 +
 +        /* There may be either a single subordinate object (named "%u") or
 +         * multiple objects (each with a key prefixed "%u."), but not both. */
 +        if (subqobj && subqdict_entries) {
 +            return -EINVAL;
 +        } else if (!subqobj && !subqdict_entries) {
 +            break;
 +        }
 +
 +        entries += subqdict_entries ? subqdict_entries : 1;
 +    }
 +
 +    /* Consider everything handled that isn't part of the given sub-QDict */
 +    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
 +        if (!strstart(qdict_entry_key(entry), subqdict, NULL)) {
 +            entries++;
 +        }
 +    }
 +
 +    /* Anything left in the sub-QDict that wasn't handled? */
 +    if (qdict_size(src) != entries) {
 +        return -EINVAL;
 +    }
 +
 +    return i;
 +}
 +
 +/**
 + * qdict_join(): Absorb the src QDict into the dest QDict, that is, move all
 + * elements from src to dest.
 + *
 + * If an element from src has a key already present in dest, it will not be
 + * moved unless overwrite is true.
 + *
 + * If overwrite is true, the conflicting values in dest will be discarded and
 + * replaced by the corresponding values from src.
 + *
 + * Therefore, with overwrite being true, the src QDict will always be empty when
 + * this function returns. If overwrite is false, the src QDict will be empty
 + * iff there were no conflicts.
 + */
 +void qdict_join(QDict *dest, QDict *src, bool overwrite)
 +{
 +    const QDictEntry *entry, *next;
 +
 +    entry = qdict_first(src);
 +    while (entry) {
 +        next = qdict_next(src, entry);
 +
 +        if (overwrite || !qdict_haskey(dest, entry->key)) {
 +            qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
 +            qdict_del(src, entry->key);
 +        }
 +
 +        entry = next;
 +    }
 +}
 +
 +/**
 + * qdict_rename_keys(): Rename keys in qdict according to the replacements
 + * specified in the array renames. The array must be terminated by an entry
 + * with from = NULL.
 + *
 + * The renames are performed individually in the order of the array, so entries
 + * may be renamed multiple times and may or may not conflict depending on the
 + * order of the renames array.
 + *
 + * Returns true for success, false in error cases.
 + */
 +bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
 +{
 +    QObject *qobj;
 +
 +    while (renames->from) {
 +        if (qdict_haskey(qdict, renames->from)) {
 +            if (qdict_haskey(qdict, renames->to)) {
 +                error_setg(errp, "'%s' and its alias '%s' can't be used at the "
 +                           "same time", renames->to, renames->from);
 +                return false;
 +            }
 +
 +            qobj = qdict_get(qdict, renames->from);
 +            qdict_put_obj(qdict, renames->to, qobject_ref(qobj));
 +            qdict_del(qdict, renames->from);
 +        }
 +
 +        renames++;
 +    }
 +    return true;
 +}
 diff --git a/qobject/qdict.c b/qobject/qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qobject/qdict.c
 +++ b/qobject/qdict.c
@@ -XXX,XX +XXX,XX @@
   */
  #include "qemu/osdep.h"
 -#include "block/qdict.h"
  #include "qapi/qmp/qnum.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qbool.h"
 -#include "qapi/qmp/qlist.h"
  #include "qapi/qmp/qnull.h"
  #include "qapi/qmp/qstring.h"
 -#include "qapi/error.h"
 -#include "qemu/queue.h"
 -#include "qemu-common.h"
 -#include "qemu/cutils.h"
  /**
   * qdict_new(): Create a new QDict
@@ -XXX,XX +XXX,XX @@ void qdict_destroy_obj(QObject *obj)
      g_free(qdict);
  }
 -
 -/**
 - * qdict_copy_default(): If no entry mapped by 'key' exists in 'dst' yet, the
 - * value of 'key' in 'src' is copied there (and the refcount increased
 - * accordingly).
 - */
 -void qdict_copy_default(QDict *dst, QDict *src, const char *key)
 -{
 -    QObject *val;
 -
 -    if (qdict_haskey(dst, key)) {
 -        return;
 -    }
 -
--    base_length = bdrv_getlength(base);
+-    val = qdict_get(src, key);
--    if (base_length < 0) {
+-    if (val) {
--        error_setg_errno(errp, -base_length,
+-        qdict_put_obj(dst, key, qobject_ref(val));
 -                         "Unable to determine length of %s", base->filename);
 -        goto error_restore_flags;
 -    }
--
+-}
--    if (length > base_length) {
+-
--        ret = bdrv_truncate(base, length);
+-/**
--        if (ret < 0) {
+- * qdict_set_default_str(): If no entry mapped by 'key' exists in 'dst' yet, a
--            error_setg_errno(errp, -ret,
+- * new QString initialised by 'val' is put there.
--                            "Top image %s is larger than base image %s, and "
+- */
--                             "resize of base image failed",
+-void qdict_set_default_str(QDict *dst, const char *key, const char *val)
--                             bs->filename, base->filename);
+-{
--            goto error_restore_flags;
+-    if (qdict_haskey(dst, key)) {
 -        return;
 -    }
 -
 -    qdict_put_str(dst, key, val);
 -}
 -
 -static void qdict_flatten_qdict(QDict *qdict, QDict *target,
 -                                const char *prefix);
 -
 -static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
 -{
 -    QObject *value;
 -    const QListEntry *entry;
 -    char *new_key;
 -    int i;
 -
 -    /* This function is never called with prefix == NULL, i.e., it is always
 -     * called from within qdict_flatten_q(list|dict)(). Therefore, it does not
 -     * need to remove list entries during the iteration (the whole list will be
 -     * deleted eventually anyway from qdict_flatten_qdict()). */
 -    assert(prefix);
 -
 -    entry = qlist_first(qlist);
 -
 -    for (i = 0; entry; entry = qlist_next(entry), i++) {
 -        value = qlist_entry_obj(entry);
 -        new_key = g_strdup_printf("%s.%i", prefix, i);
 -
 -        if (qobject_type(value) == QTYPE_QDICT) {
 -            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
 -        } else if (qobject_type(value) == QTYPE_QLIST) {
 -            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
 -        } else {
 -            /* All other types are moved to the target unchanged. */
 -            qdict_put_obj(target, new_key, qobject_ref(value));
 -        }
 -
 -        g_free(new_key);
 -    }
 -}
 -
 -static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
 -{
 -    QObject *value;
 -    const QDictEntry *entry, *next;
 -    char *new_key;
 -    bool delete;
 -
 -    entry = qdict_first(qdict);
 -
 -    while (entry != NULL) {
 -
 -        next = qdict_next(qdict, entry);
 -        value = qdict_entry_value(entry);
 -        new_key = NULL;
 -        delete = false;
 -
 -        if (prefix) {
 -            new_key = g_strdup_printf("%s.%s", prefix, entry->key);
 -        }
 -
 -        if (qobject_type(value) == QTYPE_QDICT) {
 -            /* Entries of QDicts are processed recursively, the QDict object
 -             * itself disappears. */
 -            qdict_flatten_qdict(qobject_to(QDict, value), target,
 -                                new_key ? new_key : entry->key);
 -            delete = true;
 -        } else if (qobject_type(value) == QTYPE_QLIST) {
 -            qdict_flatten_qlist(qobject_to(QList, value), target,
 -                                new_key ? new_key : entry->key);
 -            delete = true;
 -        } else if (prefix) {
 -            /* All other objects are moved to the target unchanged. */
 -            qdict_put_obj(target, new_key, qobject_ref(value));
 -            delete = true;
 -        }
 -
 -        g_free(new_key);
 -
 -        if (delete) {
 -            qdict_del(qdict, entry->key);
 -
 -            /* Restart loop after modifying the iterated QDict */
 -            entry = qdict_first(qdict);
 -            continue;
 -        }
 -
 -        entry = next;
 -    }
 -}
 -
 -/**
 - * qdict_flatten(): For each nested QDict with key x, all fields with key y
 - * are moved to this QDict and their key is renamed to "x.y". For each nested
 - * QList with key x, the field at index y is moved to this QDict with the key
 - * "x.y" (i.e., the reverse of what qdict_array_split() does).
 - * This operation is applied recursively for nested QDicts and QLists.
 - */
 -void qdict_flatten(QDict *qdict)
 -{
 -    qdict_flatten_qdict(qdict, qdict, NULL);
 -}
 -
 -/* extract all the src QDict entries starting by start into dst */
 -void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
 -
 -{
 -    const QDictEntry *entry, *next;
 -    const char *p;
 -
 -    *dst = qdict_new();
 -    entry = qdict_first(src);
 -
 -    while (entry != NULL) {
 -        next = qdict_next(src, entry);
 -        if (strstart(entry->key, start, &p)) {
 -            qdict_put_obj(*dst, p, qobject_ref(entry->value));
 -            qdict_del(src, entry->key);
 -        }
 -        entry = next;
 -    }
 -}
 -
 -static int qdict_count_prefixed_entries(const QDict *src, const char *start)
 -{
 -    const QDictEntry *entry;
 -    int count = 0;
 -
 -    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
 -        if (strstart(entry->key, start, NULL)) {
 -            if (count == INT_MAX) {
 -                return -ERANGE;
 -            }
 -            count++;
 -        }
 -    }
 -
-     mirror_start_job(job_id, bs, creation_flags, base, NULL, speed, 0, 0,
+-    return count;
-                      MIRROR_LEAVE_BACKING_CHAIN,
+-}
-                      on_error, on_error, true, cb, opaque, &local_err,
+-
 -/**
 - * qdict_array_split(): This function moves array-like elements of a QDict into
 - * a new QList. Every entry in the original QDict with a key "%u" or one
 - * prefixed "%u.", where %u designates an unsigned integer starting at 0 and
 - * incrementally counting up, will be moved to a new QDict at index %u in the
 - * output QList with the key prefix removed, if that prefix is "%u.". If the
 - * whole key is just "%u", the whole QObject will be moved unchanged without
 - * creating a new QDict. The function terminates when there is no entry in the
 - * QDict with a prefix directly (incrementally) following the last one; it also
 - * returns if there are both entries with "%u" and "%u." for the same index %u.
 - * Example: {"0.a": 42, "0.b": 23, "1.x": 0, "4.y": 1, "o.o": 7, "2": 66}
 - *      (or {"1.x": 0, "4.y": 1, "0.a": 42, "o.o": 7, "0.b": 23, "2": 66})
 - *       => [{"a": 42, "b": 23}, {"x": 0}, 66]
 - *      and {"4.y": 1, "o.o": 7} (remainder of the old QDict)
 - */
 -void qdict_array_split(QDict *src, QList **dst)
 -{
 -    unsigned i;
 -
 -    *dst = qlist_new();
 -
 -    for (i = 0; i < UINT_MAX; i++) {
 -        QObject *subqobj;
 -        bool is_subqdict;
 -        QDict *subqdict;
 -        char indexstr[32], prefix[32];
 -        size_t snprintf_ret;
 -
 -        snprintf_ret = snprintf(indexstr, 32, "%u", i);
 -        assert(snprintf_ret < 32);
 -
 -        subqobj = qdict_get(src, indexstr);
 -
 -        snprintf_ret = snprintf(prefix, 32, "%u.", i);
 -        assert(snprintf_ret < 32);
 -
 -        /* Overflow is the same as positive non-zero results */
 -        is_subqdict = qdict_count_prefixed_entries(src, prefix);
 -
 -        // There may be either a single subordinate object (named "%u") or
 -        // multiple objects (each with a key prefixed "%u."), but not both.
 -        if (!subqobj == !is_subqdict) {
 -            break;
 -        }
 -
 -        if (is_subqdict) {
 -            qdict_extract_subqdict(src, &subqdict, prefix);
 -            assert(qdict_size(subqdict) > 0);
 -        } else {
 -            qobject_ref(subqobj);
 -            qdict_del(src, indexstr);
 -        }
 -
 -        qlist_append_obj(*dst, subqobj ?: QOBJECT(subqdict));
 -    }
 -}
 -
 -/**
 - * qdict_split_flat_key:
 - * @key: the key string to split
 - * @prefix: non-NULL pointer to hold extracted prefix
 - * @suffix: non-NULL pointer to remaining suffix
 - *
 - * Given a flattened key such as 'foo.0.bar', split it into two parts
 - * at the first '.' separator. Allows double dot ('..') to escape the
 - * normal separator.
 - *
 - * e.g.
 - *    'foo.0.bar' -> prefix='foo' and suffix='0.bar'
 - *    'foo..0.bar' -> prefix='foo.0' and suffix='bar'
 - *
 - * The '..' sequence will be unescaped in the returned 'prefix'
 - * string. The 'suffix' string will be left in escaped format, so it
 - * can be fed back into the qdict_split_flat_key() key as the input
 - * later.
 - *
 - * The caller is responsible for freeing the string returned in @prefix
 - * using g_free().
 - */
 -static void qdict_split_flat_key(const char *key, char **prefix,
 -                                 const char **suffix)
 -{
 -    const char *separator;
 -    size_t i, j;
 -
 -    /* Find first '.' separator, but if there is a pair '..'
 -     * that acts as an escape, so skip over '..' */
 -    separator = NULL;
 -    do {
 -        if (separator) {
 -            separator += 2;
 -        } else {
 -            separator = key;
 -        }
 -        separator = strchr(separator, '.');
 -    } while (separator && separator[1] == '.');
 -
 -    if (separator) {
 -        *prefix = g_strndup(key, separator - key);
 -        *suffix = separator + 1;
 -    } else {
 -        *prefix = g_strdup(key);
 -        *suffix = NULL;
 -    }
 -
 -    /* Unescape the '..' sequence into '.' */
 -    for (i = 0, j = 0; (*prefix)[i] != '\0'; i++, j++) {
 -        if ((*prefix)[i] == '.') {
 -            assert((*prefix)[i + 1] == '.');
 -            i++;
 -        }
 -        (*prefix)[j] = (*prefix)[i];
 -    }
 -    (*prefix)[j] = '\0';
 -}
 -
 -/**
 - * qdict_is_list:
 - * @maybe_list: dict to check if keys represent list elements.
 - *
 - * Determine whether all keys in @maybe_list are valid list elements.
 - * If @maybe_list is non-zero in length and all the keys look like
 - * valid list indexes, this will return 1. If @maybe_list is zero
 - * length or all keys are non-numeric then it will return 0 to indicate
 - * it is a normal qdict. If there is a mix of numeric and non-numeric
 - * keys, or the list indexes are non-contiguous, an error is reported.
 - *
 - * Returns: 1 if a valid list, 0 if a dict, -1 on error
 - */
 -static int qdict_is_list(QDict *maybe_list, Error **errp)
 -{
 -    const QDictEntry *ent;
 -    ssize_t len = 0;
 -    ssize_t max = -1;
 -    int is_list = -1;
 -    int64_t val;
 -
 -    for (ent = qdict_first(maybe_list); ent != NULL;
 -         ent = qdict_next(maybe_list, ent)) {
 -
 -        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
 -            if (is_list == -1) {
 -                is_list = 1;
 -            } else if (!is_list) {
 -                error_setg(errp,
 -                           "Cannot mix list and non-list keys");
 -                return -1;
 -            }
 -            len++;
 -            if (val > max) {
 -                max = val;
 -            }
 -        } else {
 -            if (is_list == -1) {
 -                is_list = 0;
 -            } else if (is_list) {
 -                error_setg(errp,
 -                           "Cannot mix list and non-list keys");
 -                return -1;
 -            }
 -        }
 -    }
 -
 -    if (is_list == -1) {
 -        assert(!qdict_size(maybe_list));
 -        is_list = 0;
 -    }
 -
 -    /* NB this isn't a perfect check - e.g. it won't catch
 -     * a list containing '1', '+1', '01', '3', but that
 -     * does not matter - we've still proved that the
 -     * input is a list. It is up the caller to do a
 -     * stricter check if desired */
 -    if (len != (max + 1)) {
 -        error_setg(errp, "List indices are not contiguous, "
 -                   "saw %zd elements but %zd largest index",
 -                   len, max);
 -        return -1;
 -    }
 -
 -    return is_list;
 -}
 -
 -/**
 - * qdict_crumple:
 - * @src: the original flat dictionary (only scalar values) to crumple
 - *
 - * Takes a flat dictionary whose keys use '.' separator to indicate
 - * nesting, and values are scalars, and crumples it into a nested
 - * structure.
 - *
 - * To include a literal '.' in a key name, it must be escaped as '..'
 - *
 - * For example, an input of:
 - *
 - * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
 - *   'foo.1.bar': 'two', 'foo.1.wizz': '2' }
 - *
 - * will result in an output of:
 - *
 - * {
 - *   'foo': [
 - *      { 'bar': 'one', 'wizz': '1' },
 - *      { 'bar': 'two', 'wizz': '2' }
 - *   ],
 - * }
 - *
 - * The following scenarios in the input dict will result in an
 - * error being returned:
 - *
 - *  - Any values in @src are non-scalar types
 - *  - If keys in @src imply that a particular level is both a
 - *    list and a dict. e.g., "foo.0.bar" and "foo.eek.bar".
 - *  - If keys in @src imply that a particular level is a list,
 - *    but the indices are non-contiguous. e.g. "foo.0.bar" and
 - *    "foo.2.bar" without any "foo.1.bar" present.
 - *  - If keys in @src represent list indexes, but are not in
 - *    the "%zu" format. e.g. "foo.+0.bar"
 - *
 - * Returns: either a QDict or QList for the nested data structure, or NULL
 - * on error
 - */
 -QObject *qdict_crumple(const QDict *src, Error **errp)
 -{
 -    const QDictEntry *ent;
 -    QDict *two_level, *multi_level = NULL;
 -    QObject *dst = NULL, *child;
 -    size_t i;
 -    char *prefix = NULL;
 -    const char *suffix = NULL;
 -    int is_list;
 -
 -    two_level = qdict_new();
 -
 -    /* Step 1: split our totally flat dict into a two level dict */
 -    for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
 -        if (qobject_type(ent->value) == QTYPE_QDICT ||
 -            qobject_type(ent->value) == QTYPE_QLIST) {
 -            error_setg(errp, "Value %s is not a scalar",
 -                       ent->key);
 -            goto error;
 -        }
 -
 -        qdict_split_flat_key(ent->key, &prefix, &suffix);
 -
 -        child = qdict_get(two_level, prefix);
 -        if (suffix) {
 -            QDict *child_dict = qobject_to(QDict, child);
 -            if (!child_dict) {
 -                if (child) {
 -                    error_setg(errp, "Key %s prefix is already set as a scalar",
 -                               prefix);
 -                    goto error;
 -                }
 -
 -                child_dict = qdict_new();
 -                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
 -            }
 -
 -            qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
 -        } else {
 -            if (child) {
 -                error_setg(errp, "Key %s prefix is already set as a dict",
 -                           prefix);
 -                goto error;
 -            }
 -            qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
 -        }
 -
 -        g_free(prefix);
 -        prefix = NULL;
 -    }
 -
 -    /* Step 2: optionally process the two level dict recursively
 -     * into a multi-level dict */
 -    multi_level = qdict_new();
 -    for (ent = qdict_first(two_level); ent != NULL;
 -         ent = qdict_next(two_level, ent)) {
 -        QDict *dict = qobject_to(QDict, ent->value);
 -        if (dict) {
 -            child = qdict_crumple(dict, errp);
 -            if (!child) {
 -                goto error;
 -            }
 -
 -            qdict_put_obj(multi_level, ent->key, child);
 -        } else {
 -            qdict_put_obj(multi_level, ent->key, qobject_ref(ent->value));
 -        }
 -    }
 -    qobject_unref(two_level);
 -    two_level = NULL;
 -
 -    /* Step 3: detect if we need to turn our dict into list */
 -    is_list = qdict_is_list(multi_level, errp);
 -    if (is_list < 0) {
 -        goto error;
 -    }
 -
 -    if (is_list) {
 -        dst = QOBJECT(qlist_new());
 -
 -        for (i = 0; i < qdict_size(multi_level); i++) {
 -            char *key = g_strdup_printf("%zu", i);
 -
 -            child = qdict_get(multi_level, key);
 -            g_free(key);
 -
 -            if (!child) {
 -                error_setg(errp, "Missing list index %zu", i);
 -                goto error;
 -            }
 -
 -            qlist_append_obj(qobject_to(QList, dst), qobject_ref(child));
 -        }
 -        qobject_unref(multi_level);
 -        multi_level = NULL;
 -    } else {
 -        dst = QOBJECT(multi_level);
 -    }
 -
 -    return dst;
 -
 - error:
 -    g_free(prefix);
 -    qobject_unref(multi_level);
 -    qobject_unref(two_level);
 -    qobject_unref(dst);
 -    return NULL;
 -}
 -
 -/**
 - * qdict_array_entries(): Returns the number of direct array entries if the
 - * sub-QDict of src specified by the prefix in subqdict (or src itself for
 - * prefix == "") is valid as an array, i.e. the length of the created list if
 - * the sub-QDict would become empty after calling qdict_array_split() on it. If
 - * the array is not valid, -EINVAL is returned.
 - */
 -int qdict_array_entries(QDict *src, const char *subqdict)
 -{
 -    const QDictEntry *entry;
 -    unsigned i;
 -    unsigned entries = 0;
 -    size_t subqdict_len = strlen(subqdict);
 -
 -    assert(!subqdict_len || subqdict[subqdict_len - 1] == '.');
 -
 -    /* qdict_array_split() loops until UINT_MAX, but as we want to return
 -     * negative errors, we only have a signed return value here. Any additional
 -     * entries will lead to -EINVAL. */
 -    for (i = 0; i < INT_MAX; i++) {
 -        QObject *subqobj;
 -        int subqdict_entries;
 -        char *prefix = g_strdup_printf("%s%u.", subqdict, i);
 -
 -        subqdict_entries = qdict_count_prefixed_entries(src, prefix);
 -
 -        /* Remove ending "." */
 -        prefix[strlen(prefix) - 1] = 0;
 -        subqobj = qdict_get(src, prefix);
 -
 -        g_free(prefix);
 -
 -        if (subqdict_entries < 0) {
 -            return subqdict_entries;
 -        }
 -
 -        /* There may be either a single subordinate object (named "%u") or
 -         * multiple objects (each with a key prefixed "%u."), but not both. */
 -        if (subqobj && subqdict_entries) {
 -            return -EINVAL;
 -        } else if (!subqobj && !subqdict_entries) {
 -            break;
 -        }
 -
 -        entries += subqdict_entries ? subqdict_entries : 1;
 -    }
 -
 -    /* Consider everything handled that isn't part of the given sub-QDict */
 -    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
 -        if (!strstart(qdict_entry_key(entry), subqdict, NULL)) {
 -            entries++;
 -        }
 -    }
 -
 -    /* Anything left in the sub-QDict that wasn't handled? */
 -    if (qdict_size(src) != entries) {
 -        return -EINVAL;
 -    }
 -
 -    return i;
 -}
 -
 -/**
 - * qdict_join(): Absorb the src QDict into the dest QDict, that is, move all
 - * elements from src to dest.
 - *
 - * If an element from src has a key already present in dest, it will not be
 - * moved unless overwrite is true.
 - *
 - * If overwrite is true, the conflicting values in dest will be discarded and
 - * replaced by the corresponding values from src.
 - *
 - * Therefore, with overwrite being true, the src QDict will always be empty when
 - * this function returns. If overwrite is false, the src QDict will be empty
 - * iff there were no conflicts.
 - */
 -void qdict_join(QDict *dest, QDict *src, bool overwrite)
 -{
 -    const QDictEntry *entry, *next;
 -
 -    entry = qdict_first(src);
 -    while (entry) {
 -        next = qdict_next(src, entry);
 -
 -        if (overwrite || !qdict_haskey(dest, entry->key)) {
 -            qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
 -            qdict_del(src, entry->key);
 -        }
 -
 -        entry = next;
 -    }
 -}
 -
 -/**
 - * qdict_rename_keys(): Rename keys in qdict according to the replacements
 - * specified in the array renames. The array must be terminated by an entry
 - * with from = NULL.
 - *
 - * The renames are performed individually in the order of the array, so entries
 - * may be renamed multiple times and may or may not conflict depending on the
 - * order of the renames array.
 - *
 - * Returns true for success, false in error cases.
 - */
 -bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
 -{
 -    QObject *qobj;
 -
 -    while (renames->from) {
 -        if (qdict_haskey(qdict, renames->from)) {
 -            if (qdict_haskey(qdict, renames->to)) {
 -                error_setg(errp, "'%s' and its alias '%s' can't be used at the "
 -                           "same time", renames->to, renames->from);
 -                return false;
 -            }
 -
 -            qobj = qdict_get(qdict, renames->from);
 -            qdict_put_obj(qdict, renames->to, qobject_ref(qobj));
 -            qdict_del(qdict, renames->from);
 -        }
 -
 -        renames++;
 -    }
 -    return true;
 -}
 diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/check-block-qdict.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * Unit-tests for Block layer QDict extras
 + *
 + * Copyright (c) 2013-2018 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 + * See the COPYING.LIB file in the top-level directory.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "block/qdict.h"
 +#include "qapi/qmp/qlist.h"
 +#include "qapi/qmp/qnum.h"
 +#include "qapi/error.h"
 +
 +static void qdict_defaults_test(void)
 +{
 +    QDict *dict, *copy;
 +
 +    dict = qdict_new();
 +    copy = qdict_new();
 +
 +    qdict_set_default_str(dict, "foo", "abc");
 +    qdict_set_default_str(dict, "foo", "def");
 +    g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
 +    qdict_set_default_str(dict, "bar", "ghi");
 +
 +    qdict_copy_default(copy, dict, "foo");
 +    g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
 +    qdict_set_default_str(copy, "bar", "xyz");
 +    qdict_copy_default(copy, dict, "bar");
 +    g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
 +
 +    qobject_unref(copy);
 +    qobject_unref(dict);
 +}
 +
 +static void qdict_flatten_test(void)
 +{
 +    QList *list1 = qlist_new();
 +    QList *list2 = qlist_new();
 +    QDict *dict1 = qdict_new();
 +    QDict *dict2 = qdict_new();
 +    QDict *dict3 = qdict_new();
 +
 +    /*
 +     * Test the flattening of
 +     *
 +     * {
 +     *     "e": [
 +     *         42,
 +     *         [
 +     *             23,
 +     *             66,
 +     *             {
 +     *                 "a": 0,
 +     *                 "b": 1
 +     *             }
 +     *         ]
 +     *     ],
 +     *     "f": {
 +     *         "c": 2,
 +     *         "d": 3,
 +     *     },
 +     *     "g": 4
 +     * }
 +     *
 +     * to
 +     *
 +     * {
 +     *     "e.0": 42,
 +     *     "e.1.0": 23,
 +     *     "e.1.1": 66,
 +     *     "e.1.2.a": 0,
 +     *     "e.1.2.b": 1,
 +     *     "f.c": 2,
 +     *     "f.d": 3,
 +     *     "g": 4
 +     * }
 +     */
 +
 +    qdict_put_int(dict1, "a", 0);
 +    qdict_put_int(dict1, "b", 1);
 +
 +    qlist_append_int(list1, 23);
 +    qlist_append_int(list1, 66);
 +    qlist_append(list1, dict1);
 +    qlist_append_int(list2, 42);
 +    qlist_append(list2, list1);
 +
 +    qdict_put_int(dict2, "c", 2);
 +    qdict_put_int(dict2, "d", 3);
 +    qdict_put(dict3, "e", list2);
 +    qdict_put(dict3, "f", dict2);
 +    qdict_put_int(dict3, "g", 4);
 +
 +    qdict_flatten(dict3);
 +
 +    g_assert(qdict_get_int(dict3, "e.0") == 42);
 +    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
 +    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
 +    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
 +    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
 +    g_assert(qdict_get_int(dict3, "f.c") == 2);
 +    g_assert(qdict_get_int(dict3, "f.d") == 3);
 +    g_assert(qdict_get_int(dict3, "g") == 4);
 +
 +    g_assert(qdict_size(dict3) == 8);
 +
 +    qobject_unref(dict3);
 +}
 +
 +static void qdict_array_split_test(void)
 +{
 +    QDict *test_dict = qdict_new();
 +    QDict *dict1, *dict2;
 +    QNum *int1;
 +    QList *test_list;
 +
 +    /*
 +     * Test the split of
 +     *
 +     * {
 +     *     "1.x": 0,
 +     *     "4.y": 1,
 +     *     "0.a": 42,
 +     *     "o.o": 7,
 +     *     "0.b": 23,
 +     *     "2": 66
 +     * }
 +     *
 +     * to
 +     *
 +     * [
 +     *     {
 +     *         "a": 42,
 +     *         "b": 23
 +     *     },
 +     *     {
 +     *         "x": 0
 +     *     },
 +     *     66
 +     * ]
 +     *
 +     * and
 +     *
 +     * {
 +     *     "4.y": 1,
 +     *     "o.o": 7
 +     * }
 +     *
 +     * (remaining in the old QDict)
 +     *
 +     * This example is given in the comment of qdict_array_split().
 +     */
 +
 +    qdict_put_int(test_dict, "1.x", 0);
 +    qdict_put_int(test_dict, "4.y", 1);
 +    qdict_put_int(test_dict, "0.a", 42);
 +    qdict_put_int(test_dict, "o.o", 7);
 +    qdict_put_int(test_dict, "0.b", 23);
 +    qdict_put_int(test_dict, "2", 66);
 +
 +    qdict_array_split(test_dict, &test_list);
 +
 +    dict1 = qobject_to(QDict, qlist_pop(test_list));
 +    dict2 = qobject_to(QDict, qlist_pop(test_list));
 +    int1 = qobject_to(QNum, qlist_pop(test_list));
 +
 +    g_assert(dict1);
 +    g_assert(dict2);
 +    g_assert(int1);
 +    g_assert(qlist_empty(test_list));
 +
 +    qobject_unref(test_list);
 +
 +    g_assert(qdict_get_int(dict1, "a") == 42);
 +    g_assert(qdict_get_int(dict1, "b") == 23);
 +
 +    g_assert(qdict_size(dict1) == 2);
 +
 +    qobject_unref(dict1);
 +
 +    g_assert(qdict_get_int(dict2, "x") == 0);
 +
 +    g_assert(qdict_size(dict2) == 1);
 +
 +    qobject_unref(dict2);
 +
 +    g_assert_cmpint(qnum_get_int(int1), ==, 66);
 +
 +    qobject_unref(int1);
 +
 +    g_assert(qdict_get_int(test_dict, "4.y") == 1);
 +    g_assert(qdict_get_int(test_dict, "o.o") == 7);
 +
 +    g_assert(qdict_size(test_dict) == 2);
 +
 +    qobject_unref(test_dict);
 +
 +    /*
 +     * Test the split of
 +     *
 +     * {
 +     *     "0": 42,
 +     *     "1": 23,
 +     *     "1.x": 84
 +     * }
 +     *
 +     * to
 +     *
 +     * [
 +     *     42
 +     * ]
 +     *
 +     * and
 +     *
 +     * {
 +     *     "1": 23,
 +     *     "1.x": 84
 +     * }
 +     *
 +     * That is, test whether splitting stops if there is both an entry with key
 +     * of "%u" and other entries with keys prefixed "%u." for the same index.
 +     */
 +
 +    test_dict = qdict_new();
 +
 +    qdict_put_int(test_dict, "0", 42);
 +    qdict_put_int(test_dict, "1", 23);
 +    qdict_put_int(test_dict, "1.x", 84);
 +
 +    qdict_array_split(test_dict, &test_list);
 +
 +    int1 = qobject_to(QNum, qlist_pop(test_list));
 +
 +    g_assert(int1);
 +    g_assert(qlist_empty(test_list));
 +
 +    qobject_unref(test_list);
 +
 +    g_assert_cmpint(qnum_get_int(int1), ==, 42);
 +
 +    qobject_unref(int1);
 +
 +    g_assert(qdict_get_int(test_dict, "1") == 23);
 +    g_assert(qdict_get_int(test_dict, "1.x") == 84);
 +
 +    g_assert(qdict_size(test_dict) == 2);
 +
 +    qobject_unref(test_dict);
 +}
 +
 +static void qdict_array_entries_test(void)
 +{
 +    QDict *dict = qdict_new();
 +
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 +
 +    qdict_put_int(dict, "bar", 0);
 +    qdict_put_int(dict, "baz.0", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 +
 +    qdict_put_int(dict, "foo.1", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 +    qdict_put_int(dict, "foo.0", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
 +    qdict_put_int(dict, "foo.bar", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 +    qdict_del(dict, "foo.bar");
 +
 +    qdict_put_int(dict, "foo.2.a", 0);
 +    qdict_put_int(dict, "foo.2.b", 0);
 +    qdict_put_int(dict, "foo.2.c", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
 +    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 +
 +    qobject_unref(dict);
 +
 +    dict = qdict_new();
 +    qdict_put_int(dict, "1", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 +    qdict_put_int(dict, "0", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
 +    qdict_put_int(dict, "bar", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 +    qdict_del(dict, "bar");
 +
 +    qdict_put_int(dict, "2.a", 0);
 +    qdict_put_int(dict, "2.b", 0);
 +    qdict_put_int(dict, "2.c", 0);
 +    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
 +
 +    qobject_unref(dict);
 +}
 +
 +static void qdict_join_test(void)
 +{
 +    QDict *dict1, *dict2;
 +    bool overwrite = false;
 +    int i;
 +
 +    dict1 = qdict_new();
 +    dict2 = qdict_new();
 +
 +    /* Test everything once without overwrite and once with */
 +    do {
 +        /* Test empty dicts */
 +        qdict_join(dict1, dict2, overwrite);
 +
 +        g_assert(qdict_size(dict1) == 0);
 +        g_assert(qdict_size(dict2) == 0);
 +
 +        /* First iteration: Test movement */
 +        /* Second iteration: Test empty source and non-empty destination */
 +        qdict_put_int(dict2, "foo", 42);
 +
 +        for (i = 0; i < 2; i++) {
 +            qdict_join(dict1, dict2, overwrite);
 +
 +            g_assert(qdict_size(dict1) == 1);
 +            g_assert(qdict_size(dict2) == 0);
 +
 +            g_assert(qdict_get_int(dict1, "foo") == 42);
 +        }
 +
 +        /* Test non-empty source and destination without conflict */
 +        qdict_put_int(dict2, "bar", 23);
 +
 +        qdict_join(dict1, dict2, overwrite);
 +
 +        g_assert(qdict_size(dict1) == 2);
 +        g_assert(qdict_size(dict2) == 0);
 +
 +        g_assert(qdict_get_int(dict1, "foo") == 42);
 +        g_assert(qdict_get_int(dict1, "bar") == 23);
 +
 +        /* Test conflict */
 +        qdict_put_int(dict2, "foo", 84);
 +
 +        qdict_join(dict1, dict2, overwrite);
 +
 +        g_assert(qdict_size(dict1) == 2);
 +        g_assert(qdict_size(dict2) == !overwrite);
 +
 +        g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
 +        g_assert(qdict_get_int(dict1, "bar") == 23);
 +
 +        if (!overwrite) {
 +            g_assert(qdict_get_int(dict2, "foo") == 84);
 +        }
 +
 +        /* Check the references */
 +        g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
 +        g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
 +
 +        if (!overwrite) {
 +            g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
 +        }
 +
 +        /* Clean up */
 +        qdict_del(dict1, "foo");
 +        qdict_del(dict1, "bar");
 +
 +        if (!overwrite) {
 +            qdict_del(dict2, "foo");
 +        }
 +    } while (overwrite ^= true);
 +
 +    qobject_unref(dict1);
 +    qobject_unref(dict2);
 +}
 +
 +static void qdict_crumple_test_recursive(void)
 +{
 +    QDict *src, *dst, *rule, *vnc, *acl, *listen;
 +    QList *rules;
 +
 +    src = qdict_new();
 +    qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
 +    qdict_put_str(src, "vnc.listen.port", "5901");
 +    qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
 +    qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
 +    qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
 +    qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
 +    qdict_put_str(src, "vnc.acl.default", "deny");
 +    qdict_put_str(src, "vnc.acl..name", "acl0");
 +    qdict_put_str(src, "vnc.acl.rule..name", "acl0");
 +
 +    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 +    g_assert(dst);
 +    g_assert_cmpint(qdict_size(dst), ==, 1);
 +
 +    vnc = qdict_get_qdict(dst, "vnc");
 +    g_assert(vnc);
 +    g_assert_cmpint(qdict_size(vnc), ==, 3);
 +
 +    listen = qdict_get_qdict(vnc, "listen");
 +    g_assert(listen);
 +    g_assert_cmpint(qdict_size(listen), ==, 2);
 +    g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
 +    g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
 +
 +    acl = qdict_get_qdict(vnc, "acl");
 +    g_assert(acl);
 +    g_assert_cmpint(qdict_size(acl), ==, 3);
 +
 +    rules = qdict_get_qlist(acl, "rules");
 +    g_assert(rules);
 +    g_assert_cmpint(qlist_size(rules), ==, 2);
 +
 +    rule = qobject_to(QDict, qlist_pop(rules));
 +    g_assert(rule);
 +    g_assert_cmpint(qdict_size(rule), ==, 2);
 +    g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
 +    g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
 +    qobject_unref(rule);
 +
 +    rule = qobject_to(QDict, qlist_pop(rules));
 +    g_assert(rule);
 +    g_assert_cmpint(qdict_size(rule), ==, 2);
 +    g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
 +    g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
 +    qobject_unref(rule);
 +
 +    /* With recursive crumpling, we should see all names unescaped */
 +    g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
 +    g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
 +
 +    qobject_unref(src);
 +    qobject_unref(dst);
 +}
 +
 +static void qdict_crumple_test_empty(void)
 +{
 +    QDict *src, *dst;
 +
 +    src = qdict_new();
 +
 +    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 +
 +    g_assert_cmpint(qdict_size(dst), ==, 0);
 +
 +    qobject_unref(src);
 +    qobject_unref(dst);
 +}
 +
 +static int qdict_count_entries(QDict *dict)
 +{
 +    const QDictEntry *e;
 +    int count = 0;
 +
 +    for (e = qdict_first(dict); e; e = qdict_next(dict, e)) {
 +        count++;
 +    }
 +
 +    return count;
 +}
 +
 +static void qdict_rename_keys_test(void)
 +{
 +    QDict *dict = qdict_new();
 +    QDict *copy;
 +    QDictRenames *renames;
 +    Error *local_err = NULL;
 +
 +    qdict_put_str(dict, "abc", "foo");
 +    qdict_put_str(dict, "abcdef", "bar");
 +    qdict_put_int(dict, "number", 42);
 +    qdict_put_bool(dict, "flag", true);
 +    qdict_put_null(dict, "nothing");
 +
 +    /* Empty rename list */
 +    renames = (QDictRenames[]) {
 +        { NULL, "this can be anything" }
 +    };
 +    copy = qdict_clone_shallow(dict);
 +    qdict_rename_keys(copy, renames, &error_abort);
 +
 +    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 +    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 +    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 +    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 +    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 +    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 +
 +    qobject_unref(copy);
 +
 +    /* Simple rename of all entries */
 +    renames = (QDictRenames[]) {
 +        { "abc",        "str1" },
 +        { "abcdef",     "str2" },
 +        { "number",     "int" },
 +        { "flag",       "bool" },
 +        { "nothing",    "null" },
 +        { NULL , NULL }
 +    };
 +    copy = qdict_clone_shallow(dict);
 +    qdict_rename_keys(copy, renames, &error_abort);
 +
 +    g_assert(!qdict_haskey(copy, "abc"));
 +    g_assert(!qdict_haskey(copy, "abcdef"));
 +    g_assert(!qdict_haskey(copy, "number"));
 +    g_assert(!qdict_haskey(copy, "flag"));
 +    g_assert(!qdict_haskey(copy, "nothing"));
 +
 +    g_assert_cmpstr(qdict_get_str(copy, "str1"), ==, "foo");
 +    g_assert_cmpstr(qdict_get_str(copy, "str2"), ==, "bar");
 +    g_assert_cmpint(qdict_get_int(copy, "int"), ==, 42);
 +    g_assert_cmpint(qdict_get_bool(copy, "bool"), ==, true);
 +    g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
 +    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 +
 +    qobject_unref(copy);
 +
 +    /* Renames are processed top to bottom */
 +    renames = (QDictRenames[]) {
 +        { "abc",        "tmp" },
 +        { "abcdef",     "abc" },
 +        { "number",     "abcdef" },
 +        { "flag",       "number" },
 +        { "nothing",    "flag" },
 +        { "tmp",        "nothing" },
 +        { NULL , NULL }
 +    };
 +    copy = qdict_clone_shallow(dict);
 +    qdict_rename_keys(copy, renames, &error_abort);
 +
 +    g_assert_cmpstr(qdict_get_str(copy, "nothing"), ==, "foo");
 +    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "bar");
 +    g_assert_cmpint(qdict_get_int(copy, "abcdef"), ==, 42);
 +    g_assert_cmpint(qdict_get_bool(copy, "number"), ==, true);
 +    g_assert(qobject_type(qdict_get(copy, "flag")) == QTYPE_QNULL);
 +    g_assert(!qdict_haskey(copy, "tmp"));
 +    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 +
 +    qobject_unref(copy);
 +
 +    /* Conflicting rename */
 +    renames = (QDictRenames[]) {
 +        { "abcdef",     "abc" },
 +        { NULL , NULL }
 +    };
 +    copy = qdict_clone_shallow(dict);
 +    qdict_rename_keys(copy, renames, &local_err);
 +
 +    g_assert(local_err != NULL);
 +    error_free(local_err);
 +    local_err = NULL;
 +
 +    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 +    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 +    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 +    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 +    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 +    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 +
 +    qobject_unref(copy);
 +
 +    /* Renames in an empty dict */
 +    renames = (QDictRenames[]) {
 +        { "abcdef",     "abc" },
 +        { NULL , NULL }
 +    };
 +
 +    qobject_unref(dict);
 +    dict = qdict_new();
 +
 +    qdict_rename_keys(dict, renames, &error_abort);
 +    g_assert(qdict_first(dict) == NULL);
 +
 +    qobject_unref(dict);
 +}
 +
 +static void qdict_crumple_test_bad_inputs(void)
 +{
 +    QDict *src;
 +    Error *error = NULL;
 +
 +    src = qdict_new();
 +    /* rule.0 can't be both a string and a dict */
 +    qdict_put_str(src, "rule.0", "fred");
 +    qdict_put_str(src, "rule.0.policy", "allow");
 +
 +    g_assert(qdict_crumple(src, &error) == NULL);
 +    g_assert(error != NULL);
 +    error_free(error);
 +    error = NULL;
 +    qobject_unref(src);
 +
 +    src = qdict_new();
 +    /* rule can't be both a list and a dict */
 +    qdict_put_str(src, "rule.0", "fred");
 +    qdict_put_str(src, "rule.a", "allow");
 +
 +    g_assert(qdict_crumple(src, &error) == NULL);
 +    g_assert(error != NULL);
 +    error_free(error);
 +    error = NULL;
 +    qobject_unref(src);
 +
 +    src = qdict_new();
 +    /* The input should be flat, ie no dicts or lists */
 +    qdict_put(src, "rule.a", qdict_new());
 +    qdict_put_str(src, "rule.b", "allow");
 +
 +    g_assert(qdict_crumple(src, &error) == NULL);
 +    g_assert(error != NULL);
 +    error_free(error);
 +    error = NULL;
 +    qobject_unref(src);
 +
 +    src = qdict_new();
 +    /* List indexes must not have gaps */
 +    qdict_put_str(src, "rule.0", "deny");
 +    qdict_put_str(src, "rule.3", "allow");
 +
 +    g_assert(qdict_crumple(src, &error) == NULL);
 +    g_assert(error != NULL);
 +    error_free(error);
 +    error = NULL;
 +    qobject_unref(src);
 +
 +    src = qdict_new();
 +    /* List indexes must be in %zu format */
 +    qdict_put_str(src, "rule.0", "deny");
 +    qdict_put_str(src, "rule.+1", "allow");
 +
 +    g_assert(qdict_crumple(src, &error) == NULL);
 +    g_assert(error != NULL);
 +    error_free(error);
 +    error = NULL;
 +    qobject_unref(src);
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    g_test_init(&argc, &argv, NULL);
 +
 +    g_test_add_func("/public/defaults", qdict_defaults_test);
 +    g_test_add_func("/public/flatten", qdict_flatten_test);
 +    g_test_add_func("/public/array_split", qdict_array_split_test);
 +    g_test_add_func("/public/array_entries", qdict_array_entries_test);
 +    g_test_add_func("/public/join", qdict_join_test);
 +    g_test_add_func("/public/crumple/recursive",
 +                    qdict_crumple_test_recursive);
 +    g_test_add_func("/public/crumple/empty",
 +                    qdict_crumple_test_empty);
 +    g_test_add_func("/public/crumple/bad_inputs",
 +                    qdict_crumple_test_bad_inputs);
 +
 +    g_test_add_func("/public/rename_keys", qdict_rename_keys_test);
 +
 +    return g_test_run();
 +}
 diff --git a/tests/check-qdict.c b/tests/check-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/check-qdict.c
 +++ b/tests/check-qdict.c
@@ -XXX,XX +XXX,XX @@
   */
  #include "qemu/osdep.h"
 -#include "block/qdict.h"
  #include "qapi/qmp/qdict.h"
 -#include "qapi/qmp/qlist.h"
 -#include "qapi/qmp/qnum.h"
 -#include "qapi/qmp/qstring.h"
 -#include "qapi/error.h"
 -#include "qemu-common.h"
  /*
   * Public Interface test-cases
@@ -XXX,XX +XXX,XX @@ static void qdict_get_try_str_test(void)
      qobject_unref(tests_dict);
  }
 -static void qdict_defaults_test(void)
 -{
 -    QDict *dict, *copy;
 -
 -    dict = qdict_new();
 -    copy = qdict_new();
 -
 -    qdict_set_default_str(dict, "foo", "abc");
 -    qdict_set_default_str(dict, "foo", "def");
 -    g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
 -    qdict_set_default_str(dict, "bar", "ghi");
 -
 -    qdict_copy_default(copy, dict, "foo");
 -    g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
 -    qdict_set_default_str(copy, "bar", "xyz");
 -    qdict_copy_default(copy, dict, "bar");
 -    g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
 -
 -    qobject_unref(copy);
 -    qobject_unref(dict);
 -}
 -
  static void qdict_haskey_not_test(void)
  {
      QDict *tests_dict = qdict_new();
@@ -XXX,XX +XXX,XX @@ static void qdict_iterapi_test(void)
      qobject_unref(tests_dict);
  }
 -static void qdict_flatten_test(void)
 -{
 -    QList *list1 = qlist_new();
 -    QList *list2 = qlist_new();
 -    QDict *dict1 = qdict_new();
 -    QDict *dict2 = qdict_new();
 -    QDict *dict3 = qdict_new();
 -
 -    /*
 -     * Test the flattening of
 -     *
 -     * {
 -     *     "e": [
 -     *         42,
 -     *         [
 -     *             23,
 -     *             66,
 -     *             {
 -     *                 "a": 0,
 -     *                 "b": 1
 -     *             }
 -     *         ]
 -     *     ],
 -     *     "f": {
 -     *         "c": 2,
 -     *         "d": 3,
 -     *     },
 -     *     "g": 4
 -     * }
 -     *
 -     * to
 -     *
 -     * {
 -     *     "e.0": 42,
 -     *     "e.1.0": 23,
 -     *     "e.1.1": 66,
 -     *     "e.1.2.a": 0,
 -     *     "e.1.2.b": 1,
 -     *     "f.c": 2,
 -     *     "f.d": 3,
 -     *     "g": 4
 -     * }
 -     */
 -
 -    qdict_put_int(dict1, "a", 0);
 -    qdict_put_int(dict1, "b", 1);
 -
 -    qlist_append_int(list1, 23);
 -    qlist_append_int(list1, 66);
 -    qlist_append(list1, dict1);
 -    qlist_append_int(list2, 42);
 -    qlist_append(list2, list1);
 -
 -    qdict_put_int(dict2, "c", 2);
 -    qdict_put_int(dict2, "d", 3);
 -    qdict_put(dict3, "e", list2);
 -    qdict_put(dict3, "f", dict2);
 -    qdict_put_int(dict3, "g", 4);
 -
 -    qdict_flatten(dict3);
 -
 -    g_assert(qdict_get_int(dict3, "e.0") == 42);
 -    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
 -    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
 -    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
 -    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
 -    g_assert(qdict_get_int(dict3, "f.c") == 2);
 -    g_assert(qdict_get_int(dict3, "f.d") == 3);
 -    g_assert(qdict_get_int(dict3, "g") == 4);
 -
 -    g_assert(qdict_size(dict3) == 8);
 -
 -    qobject_unref(dict3);
 -}
 -
 -static void qdict_array_split_test(void)
 -{
 -    QDict *test_dict = qdict_new();
 -    QDict *dict1, *dict2;
 -    QNum *int1;
 -    QList *test_list;
 -
 -    /*
 -     * Test the split of
 -     *
 -     * {
 -     *     "1.x": 0,
 -     *     "4.y": 1,
 -     *     "0.a": 42,
 -     *     "o.o": 7,
 -     *     "0.b": 23,
 -     *     "2": 66
 -     * }
 -     *
 -     * to
 -     *
 -     * [
 -     *     {
 -     *         "a": 42,
 -     *         "b": 23
 -     *     },
 -     *     {
 -     *         "x": 0
 -     *     },
 -     *     66
 -     * ]
 -     *
 -     * and
 -     *
 -     * {
 -     *     "4.y": 1,
 -     *     "o.o": 7
 -     * }
 -     *
 -     * (remaining in the old QDict)
 -     *
 -     * This example is given in the comment of qdict_array_split().
 -     */
 -
 -    qdict_put_int(test_dict, "1.x", 0);
 -    qdict_put_int(test_dict, "4.y", 1);
 -    qdict_put_int(test_dict, "0.a", 42);
 -    qdict_put_int(test_dict, "o.o", 7);
 -    qdict_put_int(test_dict, "0.b", 23);
 -    qdict_put_int(test_dict, "2", 66);
 -
 -    qdict_array_split(test_dict, &test_list);
 -
 -    dict1 = qobject_to(QDict, qlist_pop(test_list));
 -    dict2 = qobject_to(QDict, qlist_pop(test_list));
 -    int1 = qobject_to(QNum, qlist_pop(test_list));
 -
 -    g_assert(dict1);
 -    g_assert(dict2);
 -    g_assert(int1);
 -    g_assert(qlist_empty(test_list));
 -
 -    qobject_unref(test_list);
 -
 -    g_assert(qdict_get_int(dict1, "a") == 42);
 -    g_assert(qdict_get_int(dict1, "b") == 23);
 -
 -    g_assert(qdict_size(dict1) == 2);
 -
 -    qobject_unref(dict1);
 -
 -    g_assert(qdict_get_int(dict2, "x") == 0);
 -
 -    g_assert(qdict_size(dict2) == 1);
 -
 -    qobject_unref(dict2);
 -
 -    g_assert_cmpint(qnum_get_int(int1), ==, 66);
 -
 -    qobject_unref(int1);
 -
 -    g_assert(qdict_get_int(test_dict, "4.y") == 1);
 -    g_assert(qdict_get_int(test_dict, "o.o") == 7);
 -
 -    g_assert(qdict_size(test_dict) == 2);
 -
 -    qobject_unref(test_dict);
 -
 -    /*
 -     * Test the split of
 -     *
 -     * {
 -     *     "0": 42,
 -     *     "1": 23,
 -     *     "1.x": 84
 -     * }
 -     *
 -     * to
 -     *
 -     * [
 -     *     42
 -     * ]
 -     *
 -     * and
 -     *
 -     * {
 -     *     "1": 23,
 -     *     "1.x": 84
 -     * }
 -     *
 -     * That is, test whether splitting stops if there is both an entry with key
 -     * of "%u" and other entries with keys prefixed "%u." for the same index.
 -     */
 -
 -    test_dict = qdict_new();
 -
 -    qdict_put_int(test_dict, "0", 42);
 -    qdict_put_int(test_dict, "1", 23);
 -    qdict_put_int(test_dict, "1.x", 84);
 -
 -    qdict_array_split(test_dict, &test_list);
 -
 -    int1 = qobject_to(QNum, qlist_pop(test_list));
 -
 -    g_assert(int1);
 -    g_assert(qlist_empty(test_list));
 -
 -    qobject_unref(test_list);
 -
 -    g_assert_cmpint(qnum_get_int(int1), ==, 42);
 -
 -    qobject_unref(int1);
 -
 -    g_assert(qdict_get_int(test_dict, "1") == 23);
 -    g_assert(qdict_get_int(test_dict, "1.x") == 84);
 -
 -    g_assert(qdict_size(test_dict) == 2);
 -
 -    qobject_unref(test_dict);
 -}
 -
 -static void qdict_array_entries_test(void)
 -{
 -    QDict *dict = qdict_new();
 -
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 -
 -    qdict_put_int(dict, "bar", 0);
 -    qdict_put_int(dict, "baz.0", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
 -
 -    qdict_put_int(dict, "foo.1", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 -    qdict_put_int(dict, "foo.0", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
 -    qdict_put_int(dict, "foo.bar", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
 -    qdict_del(dict, "foo.bar");
 -
 -    qdict_put_int(dict, "foo.2.a", 0);
 -    qdict_put_int(dict, "foo.2.b", 0);
 -    qdict_put_int(dict, "foo.2.c", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
 -    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 -
 -    qobject_unref(dict);
 -
 -    dict = qdict_new();
 -    qdict_put_int(dict, "1", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 -    qdict_put_int(dict, "0", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
 -    qdict_put_int(dict, "bar", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
 -    qdict_del(dict, "bar");
 -
 -    qdict_put_int(dict, "2.a", 0);
 -    qdict_put_int(dict, "2.b", 0);
 -    qdict_put_int(dict, "2.c", 0);
 -    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
 -
 -    qobject_unref(dict);
 -}
 -
 -static void qdict_join_test(void)
 -{
 -    QDict *dict1, *dict2;
 -    bool overwrite = false;
 -    int i;
 -
 -    dict1 = qdict_new();
 -    dict2 = qdict_new();
 -
 -    /* Test everything once without overwrite and once with */
 -    do
 -    {
 -        /* Test empty dicts */
 -        qdict_join(dict1, dict2, overwrite);
 -
 -        g_assert(qdict_size(dict1) == 0);
 -        g_assert(qdict_size(dict2) == 0);
 -
 -        /* First iteration: Test movement */
 -        /* Second iteration: Test empty source and non-empty destination */
 -        qdict_put_int(dict2, "foo", 42);
 -
 -        for (i = 0; i < 2; i++) {
 -            qdict_join(dict1, dict2, overwrite);
 -
 -            g_assert(qdict_size(dict1) == 1);
 -            g_assert(qdict_size(dict2) == 0);
 -
 -            g_assert(qdict_get_int(dict1, "foo") == 42);
 -        }
 -
 -        /* Test non-empty source and destination without conflict */
 -        qdict_put_int(dict2, "bar", 23);
 -
 -        qdict_join(dict1, dict2, overwrite);
 -
 -        g_assert(qdict_size(dict1) == 2);
 -        g_assert(qdict_size(dict2) == 0);
 -
 -        g_assert(qdict_get_int(dict1, "foo") == 42);
 -        g_assert(qdict_get_int(dict1, "bar") == 23);
 -
 -        /* Test conflict */
 -        qdict_put_int(dict2, "foo", 84);
 -
 -        qdict_join(dict1, dict2, overwrite);
 -
 -        g_assert(qdict_size(dict1) == 2);
 -        g_assert(qdict_size(dict2) == !overwrite);
 -
 -        g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
 -        g_assert(qdict_get_int(dict1, "bar") == 23);
 -
 -        if (!overwrite) {
 -            g_assert(qdict_get_int(dict2, "foo") == 84);
 -        }
 -
 -        /* Check the references */
 -        g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
 -        g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
 -
 -        if (!overwrite) {
 -            g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
 -        }
 -
 -        /* Clean up */
 -        qdict_del(dict1, "foo");
 -        qdict_del(dict1, "bar");
 -
 -        if (!overwrite) {
 -            qdict_del(dict2, "foo");
 -        }
 -    }
 -    while (overwrite ^= true);
 -
 -    qobject_unref(dict1);
 -    qobject_unref(dict2);
 -}
 -
 -static void qdict_crumple_test_recursive(void)
 -{
 -    QDict *src, *dst, *rule, *vnc, *acl, *listen;
 -    QList *rules;
 -
 -    src = qdict_new();
 -    qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
 -    qdict_put_str(src, "vnc.listen.port", "5901");
 -    qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
 -    qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
 -    qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
 -    qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
 -    qdict_put_str(src, "vnc.acl.default", "deny");
 -    qdict_put_str(src, "vnc.acl..name", "acl0");
 -    qdict_put_str(src, "vnc.acl.rule..name", "acl0");
 -
 -    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 -    g_assert(dst);
 -    g_assert_cmpint(qdict_size(dst), ==, 1);
 -
 -    vnc = qdict_get_qdict(dst, "vnc");
 -    g_assert(vnc);
 -    g_assert_cmpint(qdict_size(vnc), ==, 3);
 -
 -    listen = qdict_get_qdict(vnc, "listen");
 -    g_assert(listen);
 -    g_assert_cmpint(qdict_size(listen), ==, 2);
 -    g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
 -    g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
 -
 -    acl = qdict_get_qdict(vnc, "acl");
 -    g_assert(acl);
 -    g_assert_cmpint(qdict_size(acl), ==, 3);
 -
 -    rules = qdict_get_qlist(acl, "rules");
 -    g_assert(rules);
 -    g_assert_cmpint(qlist_size(rules), ==, 2);
 -
 -    rule = qobject_to(QDict, qlist_pop(rules));
 -    g_assert(rule);
 -    g_assert_cmpint(qdict_size(rule), ==, 2);
 -    g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
 -    g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
 -    qobject_unref(rule);
 -
 -    rule = qobject_to(QDict, qlist_pop(rules));
 -    g_assert(rule);
 -    g_assert_cmpint(qdict_size(rule), ==, 2);
 -    g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
 -    g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
 -    qobject_unref(rule);
 -
 -    /* With recursive crumpling, we should see all names unescaped */
 -    g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
 -    g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
 -
 -    qobject_unref(src);
 -    qobject_unref(dst);
 -}
 -
 -static void qdict_crumple_test_empty(void)
 -{
 -    QDict *src, *dst;
 -
 -    src = qdict_new();
 -
 -    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
 -
 -    g_assert_cmpint(qdict_size(dst), ==, 0);
 -
 -    qobject_unref(src);
 -    qobject_unref(dst);
 -}
 -
 -static int qdict_count_entries(QDict *dict)
 -{
 -    const QDictEntry *e;
 -    int count = 0;
 -
 -    for (e = qdict_first(dict); e; e = qdict_next(dict, e)) {
 -        count++;
 -    }
 -
 -    return count;
 -}
 -
 -static void qdict_rename_keys_test(void)
 -{
 -    QDict *dict = qdict_new();
 -    QDict *copy;
 -    QDictRenames *renames;
 -    Error *local_err = NULL;
 -
 -    qdict_put_str(dict, "abc", "foo");
 -    qdict_put_str(dict, "abcdef", "bar");
 -    qdict_put_int(dict, "number", 42);
 -    qdict_put_bool(dict, "flag", true);
 -    qdict_put_null(dict, "nothing");
 -
 -    /* Empty rename list */
 -    renames = (QDictRenames[]) {
 -        { NULL, "this can be anything" }
 -    };
 -    copy = qdict_clone_shallow(dict);
 -    qdict_rename_keys(copy, renames, &error_abort);
 -
 -    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 -    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 -    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 -    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 -    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 -    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 -
 -    qobject_unref(copy);
 -
 -    /* Simple rename of all entries */
 -    renames = (QDictRenames[]) {
 -        { "abc",        "str1" },
 -        { "abcdef",     "str2" },
 -        { "number",     "int" },
 -        { "flag",       "bool" },
 -        { "nothing",    "null" },
 -        { NULL , NULL }
 -    };
 -    copy = qdict_clone_shallow(dict);
 -    qdict_rename_keys(copy, renames, &error_abort);
 -
 -    g_assert(!qdict_haskey(copy, "abc"));
 -    g_assert(!qdict_haskey(copy, "abcdef"));
 -    g_assert(!qdict_haskey(copy, "number"));
 -    g_assert(!qdict_haskey(copy, "flag"));
 -    g_assert(!qdict_haskey(copy, "nothing"));
 -
 -    g_assert_cmpstr(qdict_get_str(copy, "str1"), ==, "foo");
 -    g_assert_cmpstr(qdict_get_str(copy, "str2"), ==, "bar");
 -    g_assert_cmpint(qdict_get_int(copy, "int"), ==, 42);
 -    g_assert_cmpint(qdict_get_bool(copy, "bool"), ==, true);
 -    g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
 -    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 -
 -    qobject_unref(copy);
 -
 -    /* Renames are processed top to bottom */
 -    renames = (QDictRenames[]) {
 -        { "abc",        "tmp" },
 -        { "abcdef",     "abc" },
 -        { "number",     "abcdef" },
 -        { "flag",       "number" },
 -        { "nothing",    "flag" },
 -        { "tmp",        "nothing" },
 -        { NULL , NULL }
 -    };
 -    copy = qdict_clone_shallow(dict);
 -    qdict_rename_keys(copy, renames, &error_abort);
 -
 -    g_assert_cmpstr(qdict_get_str(copy, "nothing"), ==, "foo");
 -    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "bar");
 -    g_assert_cmpint(qdict_get_int(copy, "abcdef"), ==, 42);
 -    g_assert_cmpint(qdict_get_bool(copy, "number"), ==, true);
 -    g_assert(qobject_type(qdict_get(copy, "flag")) == QTYPE_QNULL);
 -    g_assert(!qdict_haskey(copy, "tmp"));
 -    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 -
 -    qobject_unref(copy);
 -
 -    /* Conflicting rename */
 -    renames = (QDictRenames[]) {
 -        { "abcdef",     "abc" },
 -        { NULL , NULL }
 -    };
 -    copy = qdict_clone_shallow(dict);
 -    qdict_rename_keys(copy, renames, &local_err);
 -
 -    g_assert(local_err != NULL);
 -    error_free(local_err);
 -    local_err = NULL;
 -
 -    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
 -    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
 -    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
 -    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
 -    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
 -    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
 -
 -    qobject_unref(copy);
 -
 -    /* Renames in an empty dict */
 -    renames = (QDictRenames[]) {
 -        { "abcdef",     "abc" },
 -        { NULL , NULL }
 -    };
 -
 -    qobject_unref(dict);
 -    dict = qdict_new();
 -
 -    qdict_rename_keys(dict, renames, &error_abort);
 -    g_assert(qdict_first(dict) == NULL);
 -
 -    qobject_unref(dict);
 -}
 -
 -static void qdict_crumple_test_bad_inputs(void)
 -{
 -    QDict *src;
 -    Error *error = NULL;
 -
 -    src = qdict_new();
 -    /* rule.0 can't be both a string and a dict */
 -    qdict_put_str(src, "rule.0", "fred");
 -    qdict_put_str(src, "rule.0.policy", "allow");
 -
 -    g_assert(qdict_crumple(src, &error) == NULL);
 -    g_assert(error != NULL);
 -    error_free(error);
 -    error = NULL;
 -    qobject_unref(src);
 -
 -    src = qdict_new();
 -    /* rule can't be both a list and a dict */
 -    qdict_put_str(src, "rule.0", "fred");
 -    qdict_put_str(src, "rule.a", "allow");
 -
 -    g_assert(qdict_crumple(src, &error) == NULL);
 -    g_assert(error != NULL);
 -    error_free(error);
 -    error = NULL;
 -    qobject_unref(src);
 -
 -    src = qdict_new();
 -    /* The input should be flat, ie no dicts or lists */
 -    qdict_put(src, "rule.a", qdict_new());
 -    qdict_put_str(src, "rule.b", "allow");
 -
 -    g_assert(qdict_crumple(src, &error) == NULL);
 -    g_assert(error != NULL);
 -    error_free(error);
 -    error = NULL;
 -    qobject_unref(src);
 -
 -    src = qdict_new();
 -    /* List indexes must not have gaps */
 -    qdict_put_str(src, "rule.0", "deny");
 -    qdict_put_str(src, "rule.3", "allow");
 -
 -    g_assert(qdict_crumple(src, &error) == NULL);
 -    g_assert(error != NULL);
 -    error_free(error);
 -    error = NULL;
 -    qobject_unref(src);
 -
 -    src = qdict_new();
 -    /* List indexes must be in %zu format */
 -    qdict_put_str(src, "rule.0", "deny");
 -    qdict_put_str(src, "rule.+1", "allow");
 -
 -    g_assert(qdict_crumple(src, &error) == NULL);
 -    g_assert(error != NULL);
 -    error_free(error);
 -    error = NULL;
 -    qobject_unref(src);
 -}
 -
  /*
   * Errors test-cases
   */
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
      g_test_add_func("/public/get_str", qdict_get_str_test);
      g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
 -    g_test_add_func("/public/defaults", qdict_defaults_test);
      g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
      g_test_add_func("/public/haskey", qdict_haskey_test);
      g_test_add_func("/public/del", qdict_del_test);
      g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
      g_test_add_func("/public/iterapi", qdict_iterapi_test);
 -    g_test_add_func("/public/flatten", qdict_flatten_test);
 -    g_test_add_func("/public/array_split", qdict_array_split_test);
 -    g_test_add_func("/public/array_entries", qdict_array_entries_test);
 -    g_test_add_func("/public/join", qdict_join_test);
      g_test_add_func("/errors/put_exists", qdict_put_exists_test);
      g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
 -    g_test_add_func("/public/crumple/recursive",
 -                    qdict_crumple_test_recursive);
 -    g_test_add_func("/public/crumple/empty",
 -                    qdict_crumple_test_empty);
 -    g_test_add_func("/public/crumple/bad_inputs",
 -                    qdict_crumple_test_bad_inputs);
 -
 -    g_test_add_func("/public/rename_keys", qdict_rename_keys_test);
 -
      /* The Big one */
      if (g_test_slow()) {
          g_test_add_func("/stress/test", qdict_stress_test);
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: qemu-img*
  F: qemu-io*
  F: tests/qemu-iotests/
  F: util/qemu-progress.c
 +F: qobject/block-qdict.c
 +F: test/check-block-qdict.c
  T: git git://repo.or.cz/qemu/kevin.git block
  Block I/O path
 diff --git a/qobject/Makefile.objs b/qobject/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/qobject/Makefile.objs
 +++ b/qobject/Makefile.objs
@@ -XXX,XX +XXX,XX @@
  util-obj-y = qnull.o qnum.o qstring.o qdict.o qlist.o qbool.o qlit.o
  util-obj-y += qjson.o qobject.o json-lexer.o json-streamer.o json-parser.o
 +util-obj-y += block-qdict.o
 diff --git a/tests/Makefile.include b/tests/Makefile.include
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/Makefile.include
 +++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ SYSEMU_TARGET_LIST := $(subst -softmmu.mak,,$(notdir \
  check-unit-y = tests/check-qdict$(EXESUF)
  gcov-files-check-qdict-y = qobject/qdict.c
 +check-unit-y = tests/check-block-qdict$(EXESUF)
 +gcov-files-check-block-qdict-y = qobject/block-qdict.c
  check-unit-y += tests/test-char$(EXESUF)
  gcov-files-check-qdict-y = chardev/char.c
  check-unit-y += tests/check-qnum$(EXESUF)
@@ -XXX,XX +XXX,XX @@ GENERATED_FILES += tests/test-qapi-types.h tests/test-qapi-visit.h \
  test-obj-y = tests/check-qnum.o tests/check-qstring.o tests/check-qdict.o \
      tests/check-qlist.o tests/check-qnull.o tests/check-qobject.o \
      tests/check-qjson.o tests/check-qlit.o \
 +    tests/check-block-qtest.o \
      tests/test-coroutine.o tests/test-string-output-visitor.o \
      tests/test-string-input-visitor.o tests/test-qobject-output-visitor.o \
      tests/test-clone-visitor.o \
@@ -XXX,XX +XXX,XX @@ test-block-obj-y = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
  tests/check-qnum$(EXESUF): tests/check-qnum.o $(test-util-obj-y)
  tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
  tests/check-qdict$(EXESUF): tests/check-qdict.o $(test-util-obj-y)
 +tests/check-block-qdict$(EXESUF): tests/check-block-qdict.o $(test-util-obj-y)
  tests/check-qlist$(EXESUF): tests/check-qlist.o $(test-util-obj-y)
  tests/check-qnull$(EXESUF): tests/check-qnull.o $(test-util-obj-y)
  tests/check-qobject$(EXESUF): tests/check-qobject.o $(test-util-obj-y)
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 12/19] block: Pass BdrvChild to bdrv_truncate()
+[Qemu-devel] [PULL 09/26] block: Fix -blockdev for certain non-string scalars
+From: Markus Armbruster <armbru@redhat.com>
+Configuration flows through the block subsystem in a rather peculiar
+way.  Configuration made with -drive enters it as QemuOpts.
+Configuration made with -blockdev / blockdev-add enters it as QAPI
+type BlockdevOptions.  The block subsystem uses QDict, QemuOpts and
+QAPI types internally.  The precise flow is next to impossible to
+explain (I tried for this commit message, but gave up after wasting
+several hours).  What I can explain is a flaw in the BlockDriver
+interface that leads to this bug:
+    $ qemu-system-x86_64 -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234
+    qemu-system-x86_64: -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234: Internal error: parameter user invalid
+QMP blockdev-add is broken the same way.
+Here's what happens.  The block layer passes configuration represented
+as flat QDict (with dotted keys) to BlockDriver methods
+.bdrv_file_open().  The QDict's members are typed according to the
+QAPI schema.
+nfs_file_open() converts it to QAPI type BlockdevOptionsNfs, with
+qdict_crumple() and a qobject input visitor.
+This visitor comes in two flavors.  The plain flavor requires scalars
+to be typed according to the QAPI schema.  That's the case here.  The
+keyval flavor requires string scalars.  That's not the case here.
+nfs_file_open() uses the latter, and promptly falls apart for members
+@user, @group, @tcp-syn-count, @readahead-size, @page-cache-size,
+@debug.
+Switching to the plain flavor would fix -blockdev, but break -drive,
+because there the scalars arrive in nfs_file_open() as strings.
+The proper fix would be to replace the QDict by QAPI type
+BlockdevOptions in the BlockDriver interface.  Sadly, that's beyond my
+reach right now.
+Next best would be to fix the block layer to always pass correctly
+typed QDicts to the BlockDriver methods.  Also beyond my reach.
+What I can do is throw another hack onto the pile: have
+nfs_file_open() convert all members to string, so use of the keyval
+flavor actually works, by replacing qdict_crumple() by new function
+qdict_crumple_for_keyval_qiv().
+The pattern "pass result of qdict_crumple() to
+qobject_input_visitor_new_keyval()" occurs several times more:
+* qemu_rbd_open()
+  Same issue as nfs_file_open(), but since BlockdevOptionsRbd has only
+  string members, its only a latent bug.  Fix it anyway.
+* parallels_co_create_opts(), qcow_co_create_opts(),
+  qcow2_co_create_opts(), bdrv_qed_co_create_opts(),
+  sd_co_create_opts(), vhdx_co_create_opts(), vpc_co_create_opts()
+  These work, because they create the QDict with
+  qemu_opts_to_qdict_filtered(), which creates only string scalars.
+  The function sports a TODO comment asking for better typing; that's
+  going to be fun.  Use qdict_crumple_for_keyval_qiv() to be safe.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c                | 3 ++-
+ include/block/qdict.h |  1 +
- block/blkdebug.c       | 2 +-
+ block/nfs.c           |  2 +-
- block/block-backend.c  | 2 +-
+ block/parallels.c     |  2 +-
- block/crypto.c         | 2 +-
+ block/qcow.c          |  2 +-
- block/parallels.c      | 8 ++++----
+ block/qcow2.c         |  2 +-
- block/qcow.c           | 4 ++--
+ block/qed.c           |  2 +-
- block/qcow2-refcount.c | 2 +-
+ block/rbd.c           |  2 +-
- block/qcow2.c          | 4 ++--
+ block/sheepdog.c      |  2 +-
- block/raw-format.c     | 2 +-
+ block/vhdx.c          |  2 +-
- block/vhdx-log.c       | 2 +-
+ block/vpc.c           |  2 +-
- block/vhdx.c           | 2 +-
+ qobject/block-qdict.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++
- include/block/block.h  | 2 +-
+files changed, 67 insertions(+), 9 deletions(-)
-files changed, 18 insertions(+), 17 deletions(-)
+diff --git a/include/block/qdict.h b/include/block/qdict.h
-diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
-index XXXXXXX..XXXXXXX 100644
+--- a/include/block/qdict.h
---- a/block.c
++++ b/include/block/qdict.h
-+++ b/block.c
+@@ -XXX,XX +XXX,XX @@ void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
-@@ -XXX,XX +XXX,XX @@ exit:
+ void qdict_array_split(QDict *src, QList **dst);
- /**
+ int qdict_array_entries(QDict *src, const char *subqdict);
-  * Truncate file to 'offset' bytes (needed only for file protocols)
+ QObject *qdict_crumple(const QDict *src, Error **errp);
-  */
++QObject *qdict_crumple_for_keyval_qiv(QDict *qdict, Error **errp);
--int bdrv_truncate(BlockDriverState *bs, int64_t offset)
+ void qdict_flatten(QDict *qdict);
-+int bdrv_truncate(BdrvChild *child, int64_t offset)
- {
+ typedef struct QDictRenames {
-+    BlockDriverState *bs = child->bs;
+diff --git a/block/nfs.c b/block/nfs.c
-     BlockDriver *drv = bs->drv;
+index XXXXXXX..XXXXXXX 100644
-     int ret;
+--- a/block/nfs.c
-     if (!drv)
++++ b/block/nfs.c
-diff --git a/block/blkdebug.c b/block/blkdebug.c
+@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
-index XXXXXXX..XXXXXXX 100644
+     const QDictEntry *e;
---- a/block/blkdebug.c
+     Error *local_err = NULL;
-+++ b/block/blkdebug.c
-@@ -XXX,XX +XXX,XX @@ static int64_t blkdebug_getlength(BlockDriverState *bs)
+-    crumpled = qdict_crumple(options, errp);
++    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
- static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)
+     if (crumpled == NULL) {
- {
+         return NULL;
 -    return bdrv_truncate(bs->file->bs, offset);
 +    return bdrv_truncate(bs->file, offset);
  }
  static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset)
          return -ENOMEDIUM;
      }
--    return bdrv_truncate(blk_bs(blk), offset);
-+    return bdrv_truncate(blk->root, offset);
- }
- static void blk_pdiscard_entry(void *opaque)
-diff --git a/block/crypto.c b/block/crypto.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
-+++ b/block/crypto.c
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
-     offset += payload_offset;
--    return bdrv_truncate(bs->file->bs, offset);
-+    return bdrv_truncate(bs->file, offset);
- }
- static void block_crypto_close(BlockDriverState *bs)
 diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
-@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
-                                      s->data_end << BDRV_SECTOR_BITS,
+     qdict_put_str(qdict, "driver", "parallels");
-                                      space << BDRV_SECTOR_BITS, 0);
+     qdict_put_str(qdict, "file", bs->node_name);
-         } else {
--            ret = bdrv_truncate(bs->file->bs,
+-    qobj = qdict_crumple(qdict, errp);
-+            ret = bdrv_truncate(bs->file,
++    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-                                 (s->data_end + space) << BDRV_SECTOR_BITS);
+     qobject_unref(qdict);
-         }
+     qdict = qobject_to(QDict, qobj);
-         if (ret < 0) {
+     if (qdict == NULL) {
@@ -XXX,XX +XXX,XX @@ static int parallels_check(BlockDriverState *bs, BdrvCheckResult *res,
                  size - res->image_end_offset);
          res->leaks += count;
          if (fix & BDRV_FIX_LEAKS) {
 -            ret = bdrv_truncate(bs->file->bs, res->image_end_offset);
 +            ret = bdrv_truncate(bs->file, res->image_end_offset);
              if (ret < 0) {
                  res->check_errors++;
                  return ret;
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
          goto fail_options;
      }
      if (!bdrv_has_zero_init(bs->file->bs) ||
 -            bdrv_truncate(bs->file->bs, bdrv_getlength(bs->file->bs)) != 0) {
 +            bdrv_truncate(bs->file, bdrv_getlength(bs->file->bs)) != 0) {
          s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
      }
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
      }
      if (bs->open_flags & BDRV_O_RDWR) {
 -        bdrv_truncate(bs->file->bs, s->data_end << BDRV_SECTOR_BITS);
 +        bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS);
      }
      g_free(s->bat_dirty_bmap);
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
-@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
-                 /* round to cluster size */
+     qdict_put_str(qdict, "driver", "qcow");
-                 cluster_offset = (cluster_offset + s->cluster_size - 1) &
+     qdict_put_str(qdict, "file", bs->node_name);
-                     ~(s->cluster_size - 1);
--                bdrv_truncate(bs->file->bs, cluster_offset + s->cluster_size);
+-    qobj = qdict_crumple(qdict, errp);
-+                bdrv_truncate(bs->file, cluster_offset + s->cluster_size);
++    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-                 /* if encrypted, we must initialize the cluster
+     qobject_unref(qdict);
-                    content which won't be written */
+     qdict = qobject_to(QDict, qobj);
-                 if (bs->encrypted &&
+     if (qdict == NULL) {
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
      if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
              l1_length) < 0)
          return -1;
 -    ret = bdrv_truncate(bs->file->bs, s->l1_table_offset + l1_length);
 +    ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
      if (ret < 0)
          return ret;
 diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-refcount.c
 +++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                      goto resize_fail;
                  }
 -                ret = bdrv_truncate(bs->file->bs, offset + s->cluster_size);
 +                ret = bdrv_truncate(bs->file, offset + s->cluster_size);
                  if (ret < 0) {
                      goto resize_fail;
                  }
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
-         /* align end of file to a sector boundary to ease reading with
+     qdict_put_str(qdict, "file", bs->node_name);
-            sector based I/Os */
-         cluster_offset = bdrv_getlength(bs->file->bs);
+     /* Now get the QAPI type BlockdevCreateOptions */
--        return bdrv_truncate(bs->file->bs, cluster_offset);
+-    qobj = qdict_crumple(qdict, errp);
-+        return bdrv_truncate(bs->file, cluster_offset);
++    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
      qobject_unref(qdict);
      qdict = qobject_to(QDict, qobj);
      if (qdict == NULL) {
 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 bdrv_qed_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "qed");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple(qdict, errp);
 +    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
      qobject_unref(qdict);
      qdict = qobject_to(QDict, qobj);
      if (qdict == NULL) {
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
      }
-     buf = qemu_blockalign(bs, s->cluster_size);
+     /* Convert the remaining options into a QAPI object */
-@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
+-    crumpled = qdict_crumple(options, errp);
 +    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
      if (crumpled == NULL) {
          r = -EINVAL;
          goto out;
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
      }
      /* Get the QAPI object */
 -    crumpled = qdict_crumple(qdict, errp);
 +    crumpled = qdict_crumple_for_keyval_qiv(qdict, errp);
      if (crumpled == NULL) {
          ret = -EINVAL;
          goto fail;
-     }
--    ret = bdrv_truncate(bs->file->bs, (3 + l1_clusters) * s->cluster_size);
-+    ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size);
-     if (ret < 0) {
-         goto fail;
-     }
-diff --git a/block/raw-format.c b/block/raw-format.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/raw-format.c
-+++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@ static int raw_truncate(BlockDriverState *bs, int64_t offset)
-     s->size = offset;
-     offset += s->offset;
--    return bdrv_truncate(bs->file->bs, offset);
-+    return bdrv_truncate(bs->file, offset);
- }
- static int raw_media_changed(BlockDriverState *bs)
-diff --git a/block/vhdx-log.c b/block/vhdx-log.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vhdx-log.c
-+++ b/block/vhdx-log.c
-@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
-             if (new_file_size % (1024*1024)) {
-                 /* round up to nearest 1MB boundary */
-                 new_file_size = ((new_file_size >> 20) + 1) << 20;
--                bdrv_truncate(bs->file->bs, new_file_size);
-+                bdrv_truncate(bs->file, new_file_size);
-             }
-         }
-         qemu_vfree(desc_entries);
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
-@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
-     /* per the spec, the address for a block is in units of 1MB */
+     qdict_put_str(qdict, "driver", "vhdx");
-     *new_offset = ROUND_UP(*new_offset, 1024 * 1024);
+     qdict_put_str(qdict, "file", bs->node_name);
--    return bdrv_truncate(bs->file->bs, *new_offset + s->block_size);
+-    qobj = qdict_crumple(qdict, errp);
-+    return bdrv_truncate(bs->file, *new_offset + s->block_size);
++    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
      qobject_unref(qdict);
      qdict = qobject_to(QDict, qobj);
      if (qdict == NULL) {
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "vpc");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple(qdict, errp);
 +    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
      qobject_unref(qdict);
      qdict = qobject_to(QDict, qobj);
      if (qdict == NULL) {
 diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qobject/block-qdict.c
 +++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "block/qdict.h"
 +#include "qapi/qmp/qbool.h"
  #include "qapi/qmp/qlist.h"
 +#include "qapi/qmp/qnum.h"
 +#include "qapi/qmp/qstring.h"
  #include "qemu/cutils.h"
  #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
  }
- /*
+ /**
-diff --git a/include/block/block.h b/include/block/block.h
++ * qdict_crumple_for_keyval_qiv:
-index XXXXXXX..XXXXXXX 100644
++ * @src: the flat dictionary (only scalar values) to crumple
---- a/include/block/block.h
++ * @errp: location to store error
-+++ b/include/block/block.h
++ *
-@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
++ * Like qdict_crumple(), but additionally transforms scalar values so
-     const char *backing_file);
++ * the result can be passed to qobject_input_visitor_new_keyval().
- int bdrv_get_backing_file_depth(BlockDriverState *bs);
++ *
- void bdrv_refresh_filename(BlockDriverState *bs);
++ * The block subsystem uses this function to prepare its flat QDict
--int bdrv_truncate(BlockDriverState *bs, int64_t offset);
++ * with possibly confused scalar types for a visit.  It should not be
-+int bdrv_truncate(BdrvChild *child, int64_t offset);
++ * used for anything else, and it should go away once the block
- int64_t bdrv_nb_sectors(BlockDriverState *bs);
++ * subsystem has been cleaned up.
- int64_t bdrv_getlength(BlockDriverState *bs);
++ */
- int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
++QObject *qdict_crumple_for_keyval_qiv(QDict *src, Error **errp)
 +{
 +    QDict *tmp = NULL;
 +    char *buf;
 +    const char *s;
 +    const QDictEntry *ent;
 +    QObject *dst;
 +
 +    for (ent = qdict_first(src); ent; ent = qdict_next(src, ent)) {
 +        buf = NULL;
 +        switch (qobject_type(ent->value)) {
 +        case QTYPE_QNULL:
 +        case QTYPE_QSTRING:
 +            continue;
 +        case QTYPE_QNUM:
 +            s = buf = qnum_to_string(qobject_to(QNum, ent->value));
 +            break;
 +        case QTYPE_QDICT:
 +        case QTYPE_QLIST:
 +            /* @src isn't flat; qdict_crumple() will fail */
 +            continue;
 +        case QTYPE_QBOOL:
 +            s = qbool_get_bool(qobject_to(QBool, ent->value))
 +                ? "on" : "off";
 +            break;
 +        default:
 +            abort();
 +        }
 +
 +        if (!tmp) {
 +            tmp = qdict_clone_shallow(src);
 +        }
 +        qdict_put(tmp, ent->key, qstring_from_str(s));
 +        g_free(buf);
 +    }
 +
 +    dst = qdict_crumple(tmp ?: src, errp);
 +    qobject_unref(tmp);
 +    return dst;
 +}
 +
 +/**
   * qdict_array_entries(): Returns the number of direct array entries if the
   * sub-QDict of src specified by the prefix in subqdict (or src itself for
   * prefix == "") is valid as an array, i.e. the length of the created list if
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 04/19] qemu-img: Do not truncate before preallocation
+[Qemu-devel] [PULL 10/26] block: Fix -drive for certain non-string scalars
-From: Nir Soffer <nirsof@gmail.com>
+From: Markus Armbruster <armbru@redhat.com>
-When using file system that does not support fallocate() (e.g. NFS <
+The previous commit fixed -blockdev breakage due to misuse of the
-.2), truncating the file only when preallocation=OFF speeds up creating
+qobject input visitor's keyval flavor in bdrv_file_open().  The commit
-raw file.
+message explain why using the plain flavor would be just as wrong; it
 would break -drive.  Turns out we break it in three places:
 nbd_open(), sd_open() and ssh_file_open().  They are even marked
 FIXME.  Example breakage:
-Here is example run, tested on Fedora 24 machine, creating raw file on
+    $ qemu-system-x86 -drive node-name=n1,driver=nbd,server.type=inet,server.host=localhost,server.port=1234,server.numeric=off
-NFS version 3 server.
+    qemu-system-x86: -drive node-name=n1,driver=nbd,server.type=inet,server.host=localhost,server.port=1234,server.numeric=off: Invalid parameter type for 'numeric', expected: boolean
-$ time ./qemu-img-master create -f raw -o preallocation=falloc mnt/test 1g
+Fix it the same way: replace qdict_crumple() by
-Formatting 'mnt/test', fmt=raw size=1073741824 preallocation=falloc
+qdict_crumple_for_keyval_qiv(), and switch from plain to the keyval
 flavor.
-real    0m21.185s
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
-user    0m0.022s
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 sys    0m0.574s
 $ time ./qemu-img-fix create -f raw -o preallocation=falloc mnt/test 1g
 Formatting 'mnt/test', fmt=raw size=1073741824 preallocation=falloc
 real    0m11.601s
 user    0m0.016s
 sys    0m0.525s
 $ time dd if=/dev/zero of=mnt/test bs=1M count=1024 oflag=direct
 +0 records in
 +0 records out
 1073741824 bytes (1.1 GB, 1.0 GiB) copied, 15.6627 s, 68.6 MB/s
 real    0m16.104s
 user    0m0.009s
 sys    0m0.220s
 Running with strace we can see that without this change we do one
 pread() and one pwrite() for each block. With this change, we do only
 one pwrite() per block.
 $ strace ./qemu-img-master create -f raw -o preallocation=falloc mnt/test 8192
 ...
 pread64(9, "\0", 1, 4095)               = 1
 pwrite64(9, "\0", 1, 4095)              = 1
 pread64(9, "\0", 1, 8191)               = 1
 pwrite64(9, "\0", 1, 8191)              = 1
 $ strace ./qemu-img-fix create -f raw -o preallocation=falloc mnt/test 8192
 ...
 pwrite64(9, "\0", 1, 4095)              = 1
 pwrite64(9, "\0", 1, 8191)              = 1
 This happens because posix_fallocate is checking if each block is
 allocated before writing a byte to the block, and when truncating the
 file before preallocation, all blocks are unallocated.
 Signed-off-by: Nir Soffer <nirsof@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/file-posix.c | 11 ++++-------
+ block/nbd.c      | 12 ++----------
-file changed, 4 insertions(+), 7 deletions(-)
+ block/sheepdog.c | 12 ++----------
  block/ssh.c      | 12 ++----------
 files changed, 6 insertions(+), 30 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/block/nbd.c b/block/nbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/block/nbd.c
-+++ b/block/file-posix.c
++++ b/block/nbd.c
-@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
- #endif
+         goto done;
      }
--    if (ftruncate(fd, total_size) != 0) {
+-    crumpled_addr = qdict_crumple(addr, errp);
--        result = -errno;
++    crumpled_addr = qdict_crumple_for_keyval_qiv(addr, errp);
--        error_setg_errno(errp, -result, "Could not resize file");
+     if (!crumpled_addr) {
--        goto out_close;
+         goto done;
 -    }
 -
      switch (prealloc) {
  #ifdef CONFIG_POSIX_FALLOCATE
      case PREALLOC_MODE_FALLOC:
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
          break;
      }
-     case PREALLOC_MODE_OFF:
-+        if (ftruncate(fd, total_size) != 0) {
+-    /*
-+            result = -errno;
+-     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
-+            error_setg_errno(errp, -result, "Could not resize file");
+-     * server.type=inet.  .to doesn't matter, it's ignored anyway.
-+        }
+-     * That's because when @options come from -blockdev or
-         break;
+-     * blockdev_add, members are typed according to the QAPI schema,
-     default:
+-     * but when they come from -drive, they're all QString.  The
-         result = -EINVAL;
+-     * visitor expects the former.
-@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
+-     */
-         break;
+-    iv = qobject_input_visitor_new(crumpled_addr);
 +    iv = qobject_input_visitor_new_keyval(crumpled_addr);
      visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
      if (local_err) {
          error_propagate(errp, local_err);
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
      qdict_extract_subqdict(options, &server, "server.");
 -    crumpled_server = qdict_crumple(server, errp);
 +    crumpled_server = qdict_crumple_for_keyval_qiv(server, errp);
      if (!crumpled_server) {
          goto done;
      }
--out_close:
+-    /*
-     if (qemu_close(fd) != 0 && result == 0) {
+-     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
-         result = -errno;
+-     * server.type=inet.  .to doesn't matter, it's ignored anyway.
-         error_setg_errno(errp, -result, "Could not close the new file");
+-     * That's because when @options come from -blockdev or
 -     * blockdev_add, members are typed according to the QAPI schema,
 -     * but when they come from -drive, they're all QString.  The
 -     * visitor expects the former.
 -     */
 -    iv = qobject_input_visitor_new(crumpled_server);
 +    iv = qobject_input_visitor_new_keyval(crumpled_server);
      visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
      if (local_err) {
          error_propagate(errp, local_err);
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
      }
      /* Create the QAPI object */
 -    crumpled = qdict_crumple(options, errp);
 +    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
      if (crumpled == NULL) {
          goto fail;
      }
 -    /*
 -     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive.
 -     * .to doesn't matter, it's ignored anyway.
 -     * That's because when @options come from -blockdev or
 -     * blockdev_add, members are typed according to the QAPI schema,
 -     * but when they come from -drive, they're all QString.  The
 -     * visitor expects the former.
 -     */
 -    v = qobject_input_visitor_new(crumpled);
 +    v = qobject_input_visitor_new_keyval(crumpled);
      visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
      visit_free(v);
      qobject_unref(crumpled);
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 10/19] qcow2: Use BB for resizing in qcow2_amend_options()
+[Qemu-devel] [PULL 11/26] block: Clean up a misuse of qobject_to() in .bdrv_co_create_opts()
-In order to able to convert bdrv_truncate() to take a BdrvChild and
+From: Markus Armbruster <armbru@redhat.com>
-later to correctly check the resize permission here, we need to use a
-BlockBackend for resizing the image.
+The following pattern occurs in the .bdrv_co_create_opts() methods of
+parallels, qcow, qcow2, qed, vhdx and vpc:
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
     qobject_unref(qdict);
     qdict = qobject_to(QDict, qobj);
     if (qdict == NULL) {
          ret = -EINVAL;
          goto done;
     }
     v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
     [...]
     ret = 0;
 done:
     qobject_unref(qdict);
     [...]
     return ret;
 If qobject_to() fails, we return failure without setting errp.  That's
 wrong.  As far as I can tell, it cannot fail here.  Clean it up
 anyway, by removing the useless conversion.
 Signed-off-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block/qcow2.c | 6 +++++-
+ block/parallels.c | 9 ++++-----
-file changed, 5 insertions(+), 1 deletion(-)
+ block/qcow.c      | 9 ++++-----
+ block/qcow2.c     | 9 ++++-----
  block/qed.c       | 9 ++++-----
  block/vhdx.c      | 9 ++++-----
  block/vpc.c       | 9 ++++-----
 files changed, 24 insertions(+), 30 deletions(-)
 diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
      BlockdevCreateOptions *create_options = NULL;
      Error *local_err = NULL;
      BlockDriverState *bs = NULL;
 -    QDict *qdict = NULL;
 +    QDict *qdict;
      QObject *qobj;
      Visitor *v;
      int ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
      qdict_put_str(qdict, "file", bs->node_name);
      qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto done;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
  {
      BlockdevCreateOptions *create_options = NULL;
      BlockDriverState *bs = NULL;
 -    QDict *qdict = NULL;
 +    QDict *qdict;
      QObject *qobj;
      Visitor *v;
      const char *val;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
      qdict_put_str(qdict, "file", bs->node_name);
      qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
-     }
+                                              Error **errp)
+ {
-     if (new_size) {
+     BlockdevCreateOptions *create_options = NULL;
--        ret = bdrv_truncate(bs, new_size);
+-    QDict *qdict = NULL;
-+        BlockBackend *blk = blk_new();
++    QDict *qdict;
-+        blk_insert_bs(blk, bs);
+     QObject *qobj;
-+        ret = blk_truncate(blk, new_size);
+     Visitor *v;
-+        blk_unref(blk);
+     BlockDriverState *bs = NULL;
-+
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
-         if (ret < 0) {
-             return ret;
+     /* Now get the QAPI type BlockdevCreateOptions */
-         }
+     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto finish;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 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 bdrv_qed_co_create_opts(const char *filename,
                                                  Error **errp)
  {
      BlockdevCreateOptions *create_options = NULL;
 -    QDict *qdict = NULL;
 +    QDict *qdict;
      QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
      qdict_put_str(qdict, "file", bs->node_name);
      qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
                                              Error **errp)
  {
      BlockdevCreateOptions *create_options = NULL;
 -    QDict *qdict = NULL;
 +    QDict *qdict;
      QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
      qdict_put_str(qdict, "file", bs->node_name);
      qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
                                             QemuOpts *opts, Error **errp)
  {
      BlockdevCreateOptions *create_options = NULL;
 -    QDict *qdict = NULL;
 +    QDict *qdict;
      QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
      qdict_put_str(qdict, "file", bs->node_name);
      qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    qobject_unref(qdict);
 -    qdict = qobject_to(QDict, qobj);
 -    if (qdict == NULL) {
 +    if (!qobj) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_keyval(qobj);
 +    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 14/19] block: Factor out bdrv_open_child_bs()
+[Qemu-devel] [PULL 12/26] block: Factor out qobject_input_visitor_new_flat_confused()
-This is the part of bdrv_open_child() that opens a BDS with option
+From: Markus Armbruster <armbru@redhat.com>
 inheritance, but doesn't attach it as a child to the parent yet.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 61 +++++++++++++++++++++++++++++++++++++------------------------
+ include/block/qdict.h |  3 ++-
-file changed, 37 insertions(+), 24 deletions(-)
+ block/nbd.c           |  7 ++-----
  block/nfs.c           |  7 ++-----
  block/parallels.c     |  7 ++-----
  block/qcow.c          |  7 ++-----
  block/qcow2.c         |  7 ++-----
  block/qed.c           |  7 ++-----
  block/rbd.c           |  7 ++-----
  block/sheepdog.c      | 14 ++++----------
  block/ssh.c           |  7 ++-----
  block/vhdx.c          |  7 ++-----
  block/vpc.c           |  7 ++-----
  qobject/block-qdict.c | 28 +++++++++++++++++++++++++++-
 files changed, 53 insertions(+), 62 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/include/block/qdict.h b/include/block/qdict.h
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/include/block/qdict.h
-+++ b/block.c
++++ b/include/block/qdict.h
-@@ -XXX,XX +XXX,XX @@ free_exit:
+@@ -XXX,XX +XXX,XX @@ void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
-     return ret;
+ void qdict_array_split(QDict *src, QList **dst);
  int qdict_array_entries(QDict *src, const char *subqdict);
  QObject *qdict_crumple(const QDict *src, Error **errp);
 -QObject *qdict_crumple_for_keyval_qiv(QDict *qdict, Error **errp);
  void qdict_flatten(QDict *qdict);
  typedef struct QDictRenames {
@@ -XXX,XX +XXX,XX @@ typedef struct QDictRenames {
  } QDictRenames;
  bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
 +Visitor *qobject_input_visitor_new_flat_confused(QDict *qdict,
 +                                                 Error **errp);
  #endif
 diff --git a/block/nbd.c b/block/nbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nbd.c
 +++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
  {
      SocketAddress *saddr = NULL;
      QDict *addr = NULL;
 -    QObject *crumpled_addr = NULL;
      Visitor *iv = NULL;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
          goto done;
      }
 -    crumpled_addr = qdict_crumple_for_keyval_qiv(addr, errp);
 -    if (!crumpled_addr) {
 +    iv = qobject_input_visitor_new_flat_confused(addr, errp);
 +    if (!iv) {
          goto done;
      }
 -    iv = qobject_input_visitor_new_keyval(crumpled_addr);
      visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
      if (local_err) {
          error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
  done:
      qobject_unref(addr);
 -    qobject_unref(crumpled_addr);
      visit_free(iv);
      return saddr;
  }
+diff --git a/block/nfs.c b/block/nfs.c
--/*
+index XXXXXXX..XXXXXXX 100644
-- * Opens a disk image whose options are given as BlockdevRef in another block
+--- a/block/nfs.c
-- * device's options.
++++ b/block/nfs.c
-- *
+@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
-- * If allow_none is true, no image will be opened if filename is false and no
+                                                      Error **errp)
-- * BlockdevRef is given. NULL will be returned, but errp remains unset.
+ {
-- *
+     BlockdevOptionsNfs *opts = NULL;
-- * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
+-    QObject *crumpled = NULL;
-- * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
+     Visitor *v;
-- * itself, all options starting with "${bdref_key}." are considered part of the
+     const QDictEntry *e;
-- * BlockdevRef.
+     Error *local_err = NULL;
-- *
-- * The BlockdevRef will be removed from the options QDict.
+-    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
-- */
+-    if (crumpled == NULL) {
--BdrvChild *bdrv_open_child(const char *filename,
++    v = qobject_input_visitor_new_flat_confused(options, errp);
--                           QDict *options, const char *bdref_key,
++    if (!v) {
--                           BlockDriverState* parent,
+         return NULL;
--                           const BdrvChildRole *child_role,
+     }
--                           bool allow_none, Error **errp)
-+static BlockDriverState *
+-    v = qobject_input_visitor_new_keyval(crumpled);
-+bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
+     visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
-+                   BlockDriverState *parent, const BdrvChildRole *child_role,
+     visit_free(v);
-+                   bool allow_none, Error **errp)
+-    qobject_unref(crumpled);
- {
--    BdrvChild *c = NULL;
+     if (local_err) {
--    BlockDriverState *bs;
+         error_propagate(errp, local_err);
-+    BlockDriverState *bs = NULL;
+diff --git a/block/parallels.c b/block/parallels.c
-     QDict *image_options;
+index XXXXXXX..XXXXXXX 100644
-     char *bdref_key_dot;
+--- a/block/parallels.c
-     const char *reference;
++++ b/block/parallels.c
-@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
      Error *local_err = NULL;
      BlockDriverState *bs = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      int ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "parallels");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto done;
      }
--    c = bdrv_attach_child(parent, bs, bdref_key, child_role);
+-    v = qobject_input_visitor_new_keyval(qobj);
--
+-    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
      BlockdevCreateOptions *create_options = NULL;
      BlockDriverState *bs = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      const char *val;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "qcow");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(qobj);
 -    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
  {
      BlockdevCreateOptions *create_options = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
      qdict_put_str(qdict, "file", bs->node_name);
      /* Now get the QAPI type BlockdevCreateOptions */
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto finish;
      }
 -    v = qobject_input_visitor_new_keyval(qobj);
 -    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 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 bdrv_qed_co_create_opts(const char *filename,
  {
      BlockdevCreateOptions *create_options = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "qed");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(qobj);
 -    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
      BDRVRBDState *s = bs->opaque;
      BlockdevOptionsRbd *opts = NULL;
      Visitor *v;
 -    QObject *crumpled = NULL;
      const QDictEntry *e;
      Error *local_err = NULL;
      char *keypairs, *secretid;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
      }
      /* Convert the remaining options into a QAPI object */
 -    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
 -    if (crumpled == NULL) {
 +    v = qobject_input_visitor_new_flat_confused(options, errp);
 +    if (!v) {
          r = -EINVAL;
          goto out;
      }
 -    v = qobject_input_visitor_new_keyval(crumpled);
      visit_type_BlockdevOptionsRbd(v, NULL, &opts, &local_err);
      visit_free(v);
 -    qobject_unref(crumpled);
      if (local_err) {
          error_propagate(errp, local_err);
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static void sd_aio_setup(SheepdogAIOCB *acb, BDRVSheepdogState *s,
  static SocketAddress *sd_server_config(QDict *options, Error **errp)
  {
      QDict *server = NULL;
 -    QObject *crumpled_server = NULL;
      Visitor *iv = NULL;
      SocketAddress *saddr = NULL;
      Error *local_err = NULL;
      qdict_extract_subqdict(options, &server, "server.");
 -    crumpled_server = qdict_crumple_for_keyval_qiv(server, errp);
 -    if (!crumpled_server) {
 +    iv = qobject_input_visitor_new_flat_confused(server, errp);
 +    if (!iv) {
          goto done;
      }
 -    iv = qobject_input_visitor_new_keyval(crumpled_server);
      visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
      if (local_err) {
          error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
  done:
-     qdict_del(options, bdref_key);
+     visit_free(iv);
--    return c;
+-    qobject_unref(crumpled_server);
-+    return bs;
+     qobject_unref(server);
-+}
+     return saddr;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
  {
      BlockdevCreateOptions *create_options = NULL;
      QDict *qdict, *location_qdict;
 -    QObject *crumpled;
      Visitor *v;
      char *redundancy;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
      }
      /* Get the QAPI object */
 -    crumpled = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (crumpled == NULL) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(crumpled);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 -    qobject_unref(crumpled);
      if (local_err) {
          error_propagate(errp, local_err);
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
      BlockdevOptionsSsh *result = NULL;
      QemuOpts *opts = NULL;
      Error *local_err = NULL;
 -    QObject *crumpled;
      const QDictEntry *e;
      Visitor *v;
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
      }
      /* Create the QAPI object */
 -    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
 -    if (crumpled == NULL) {
 +    v = qobject_input_visitor_new_flat_confused(options, errp);
 +    if (!v) {
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(crumpled);
      visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
      visit_free(v);
 -    qobject_unref(crumpled);
      if (local_err) {
          error_propagate(errp, local_err);
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
  {
      BlockdevCreateOptions *create_options = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "vhdx");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(qobj);
 -    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
  {
      BlockdevCreateOptions *create_options = NULL;
      QDict *qdict;
 -    QObject *qobj;
      Visitor *v;
      BlockDriverState *bs = NULL;
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
      qdict_put_str(qdict, "driver", "vpc");
      qdict_put_str(qdict, "file", bs->node_name);
 -    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
 -    if (!qobj) {
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
          ret = -EINVAL;
          goto fail;
      }
 -    v = qobject_input_visitor_new_keyval(qobj);
 -    qobject_unref(qobj);
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qobject/block-qdict.c
 +++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qmp/qlist.h"
  #include "qapi/qmp/qnum.h"
  #include "qapi/qmp/qstring.h"
 +#include "qapi/qobject-input-visitor.h"
  #include "qemu/cutils.h"
  #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
   * used for anything else, and it should go away once the block
   * subsystem has been cleaned up.
   */
 -QObject *qdict_crumple_for_keyval_qiv(QDict *src, Error **errp)
 +static QObject *qdict_crumple_for_keyval_qiv(QDict *src, Error **errp)
  {
      QDict *tmp = NULL;
      char *buf;
@@ -XXX,XX +XXX,XX @@ bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
      }
      return true;
  }
 +
 +/*
-+ * Opens a disk image whose options are given as BlockdevRef in another block
++ * Create a QObject input visitor for flat @qdict with possibly
-+ * device's options.
++ * confused scalar types.
 + *
-+ * If allow_none is true, no image will be opened if filename is false and no
++ * The block subsystem uses this function to visit its flat QDict with
-+ * BlockdevRef is given. NULL will be returned, but errp remains unset.
++ * possibly confused scalar types.  It should not be used for anything
-+ *
++ * else, and it should go away once the block subsystem has been
-+ * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
++ * cleaned up.
 + * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
 + * itself, all options starting with "${bdref_key}." are considered part of the
 + * BlockdevRef.
 + *
 + * The BlockdevRef will be removed from the options QDict.
 + */
-+BdrvChild *bdrv_open_child(const char *filename,
++Visitor *qobject_input_visitor_new_flat_confused(QDict *qdict,
-+                           QDict *options, const char *bdref_key,
++                                                 Error **errp)
 +                           BlockDriverState *parent,
 +                           const BdrvChildRole *child_role,
 +                           bool allow_none, Error **errp)
 +{
-+    BlockDriverState *bs;
++    QObject *crumpled;
 +    Visitor *v;
 +
-+    bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
++    crumpled = qdict_crumple_for_keyval_qiv(qdict, errp);
-+                            allow_none, errp);
++    if (!crumpled) {
 +    if (bs == NULL) {
 +        return NULL;
 +    }
 +
-+    return bdrv_attach_child(parent, bs, bdref_key, child_role);
++    v = qobject_input_visitor_new_keyval(crumpled);
- }
++    qobject_unref(crumpled);
++    return v;
- static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
++}
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 18/19] vvfat: Use opened node as backing file
+[Qemu-devel] [PULL 13/26] block: Make remaining uses of qobject input visitor more robust
-We should not try to assign a not yet opened node as the backing file,
+From: Markus Armbruster <armbru@redhat.com>
 because as soon as the permission system is added it will fail.  The
 just added bdrv_new_open_driver() function is the right tool to open a
 file with an internal driver, use it.
-In case anyone wonders whether that magic fake backing file to trigger a
+Remaining uses of qobject_input_visitor_new_keyval() in the block
-special action on 'commit' actually works today: No, not for me. One
+subsystem:
 reason is that we've been adding a raw format driver on top for several
 years now and raw doesn't support commit. Other reasons include that the
 backing file isn't writable and the driver doesn't support reopen, and
 it's also size 0 and the driver doesn't support bdrv_truncate. All of
 these are easily fixable, but then 'commit' ended up in an infinite loop
 deep in the vvfat code for me, so I thought I'd best leave it alone. I'm
 not really sure what it was supposed to do anyway.
+* block_crypto_open_opts_init()
+  Currently doesn't visit any non-string scalars, thus safe.  It's
+  called from
+  - block_crypto_open_luks()
+    Creates the QDict with qemu_opts_to_qdict_filtered(), which
+    creates only string scalars, but has a TODO asking for other types.
+  - qcow_open()
+  - qcow2_open(), qcow2_co_invalidate_cache(), qcow2_reopen_prepare()
+* block_crypto_create_opts_init(), called from
+  - block_crypto_co_create_opts_luks()
+    Also creates the QDict with qemu_opts_to_qdict_filtered().
+* vdi_co_create_opts()
+  Also creates the QDict with qemu_opts_to_qdict_filtered().
+Replace these uses by qobject_input_visitor_new_flat_confused() for
+robustness.  This adds crumpling.  Right now, that's a no-op, but if
+we ever extend these things in non-flat ways, crumpling will be
+needed.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block/vvfat.c | 10 +++++-----
+ block/crypto.c | 12 +++++++++---
-file changed, 5 insertions(+), 5 deletions(-)
+ block/vdi.c    |  8 ++++++--
 files changed, 15 insertions(+), 5 deletions(-)
-diff --git a/block/vvfat.c b/block/vvfat.c
+diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/vvfat.c
+--- a/block/crypto.c
-+++ b/block/vvfat.c
++++ b/block/crypto.c
-@@ -XXX,XX +XXX,XX @@ static void write_target_close(BlockDriverState *bs) {
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/osdep.h"
- static BlockDriver vvfat_write_target = {
-     .format_name        = "vvfat_write_target",
+ #include "block/block_int.h"
-+    .instance_size      = sizeof(void*),
++#include "block/qdict.h"
-     .bdrv_co_pwritev    = write_target_commit,
+ #include "sysemu/block-backend.h"
-     .bdrv_close         = write_target_close,
+ #include "crypto/block.h"
- };
+ #include "qapi/opts-visitor.h"
-@@ -XXX,XX +XXX,XX @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
+ #include "qapi/qapi-visit-crypto.h"
-     unlink(s->qcow_filename);
+-#include "qapi/qmp/qdict.h"
- #endif
+ #include "qapi/qobject-input-visitor.h"
+ #include "qapi/error.h"
--    backing = bdrv_new();
+ #include "qemu/option.h"
-+    backing = bdrv_new_open_driver(&vvfat_write_target, NULL, BDRV_O_ALLOW_RDWR,
+@@ -XXX,XX +XXX,XX @@ block_crypto_open_opts_init(QCryptoBlockFormat format,
-+                                   &error_abort);
+     ret = g_new0(QCryptoBlockOpenOptions, 1);
-+    *(void**) backing->opaque = s;
+     ret->format = format;
-+
-     bdrv_set_backing_hd(s->bs, backing);
+-    v = qobject_input_visitor_new_keyval(QOBJECT(opts));
-     bdrv_unref(backing);
++    v = qobject_input_visitor_new_flat_confused(opts, &local_err);
++    if (local_err) {
--    s->bs->backing->bs->drv = &vvfat_write_target;
++        goto out;
--    s->bs->backing->bs->opaque = g_new(void *, 1);
++    }
--    *(void**)s->bs->backing->bs->opaque = s;
--
+     visit_start_struct(v, NULL, NULL, 0, &local_err);
-     return 0;
+     if (local_err) {
+@@ -XXX,XX +XXX,XX @@ block_crypto_create_opts_init(QCryptoBlockFormat format,
- err:
+     ret = g_new0(QCryptoBlockCreateOptions, 1);
      ret->format = format;
 -    v = qobject_input_visitor_new_keyval(QOBJECT(opts));
 +    v = qobject_input_visitor_new_flat_confused(opts, &local_err);
 +    if (local_err) {
 +        goto out;
 +    }
      visit_start_struct(v, NULL, NULL, 0, &local_err);
      if (local_err) {
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qapi/error.h"
 -#include "qapi/qmp/qdict.h"
  #include "qapi/qobject-input-visitor.h"
  #include "qapi/qapi-visit-block-core.h"
  #include "block/block_int.h"
 +#include "block/qdict.h"
  #include "sysemu/block-backend.h"
  #include "qemu/module.h"
  #include "qemu/option.h"
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
      }
      /* Get the QAPI object */
 -    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    v = qobject_input_visitor_new_flat_confused(qdict, errp);
 +    if (!v) {
 +        ret = -EINVAL;
 +        goto done;
 +    }
      visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
      visit_free(v);
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 03/19] qemu-iotests: redirect nbd server stdout to /dev/null
+[Qemu-devel] [PULL 14/26] block-qdict: Simplify qdict_flatten_qdict()
-From: Jeff Cody <jcody@redhat.com>
+From: Markus Armbruster <armbru@redhat.com>
-Some iotests (e.g. 174) try to filter the output of _make_test_image by
+There's no need to restart the loop.  We don't elsewhere, e.g. in
-piping the stdout.  Pipe the server stdout to /dev/null, so that filter
+qdict_extract_subqdict(), qdict_join() and qemu_opts_absorb_qdict().
-pipe does not need to wait until process completion.
+Simplify accordingly.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/common.rc | 2 +-
+ qobject/block-qdict.c | 18 +++---------------
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 3 insertions(+), 15 deletions(-)
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
+diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
+--- a/qobject/block-qdict.c
-+++ b/tests/qemu-iotests/common.rc
++++ b/qobject/block-qdict.c
-@@ -XXX,XX +XXX,XX @@ _make_test_img()
+@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
+     QObject *value;
-     # Start an NBD server on the image file, which is what we'll be talking to
+     const QDictEntry *entry, *next;
-     if [ $IMGPROTO = "nbd" ]; then
+     char *new_key;
--        eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE &"
+-    bool delete;
-+        eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
-         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
+     entry = qdict_first(qdict);
-     fi
      while (entry != NULL) {
 -
          next = qdict_next(qdict, entry);
          value = qdict_entry_value(entry);
          new_key = NULL;
 -        delete = false;
          if (prefix) {
              new_key = g_strdup_printf("%s.%s", prefix, entry->key);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
               * itself disappears. */
              qdict_flatten_qdict(qobject_to(QDict, value), target,
                                  new_key ? new_key : entry->key);
 -            delete = true;
 +            qdict_del(qdict, entry->key);
          } else if (qobject_type(value) == QTYPE_QLIST) {
              qdict_flatten_qlist(qobject_to(QList, value), target,
                                  new_key ? new_key : entry->key);
 -            delete = true;
 +            qdict_del(qdict, entry->key);
          } else if (prefix) {
              /* All other objects are moved to the target unchanged. */
              qdict_put_obj(target, new_key, qobject_ref(value));
 -            delete = true;
 -        }
 -
 -        g_free(new_key);
 -
 -        if (delete) {
              qdict_del(qdict, entry->key);
 -
 -            /* Restart loop after modifying the iterated QDict */
 -            entry = qdict_first(qdict);
 -            continue;
          }
 +        g_free(new_key);
          entry = next;
      }
  }
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 07/19] qemu-img: Improve documentation for PREALLOC_MODE_FALLOC
+[Qemu-devel] [PULL 15/26] block-qdict: Tweak qdict_flatten_qdict(), qdict_flatten_qlist()
-From: Nir Soffer <nirsof@gmail.com>
+From: Markus Armbruster <armbru@redhat.com>
-Now that we are truncating the file in both PREALLOC_MODE_FULL and
+qdict_flatten_qdict() skips copying scalars from @qdict to @target
-PREALLOC_MODE_OFF, not truncating in PREALLOC_MODE_FALLOC looks odd.
+when the two are the same.  Fair enough, but it uses a non-obvious
-Add a comment explaining why we do not truncate in this case.
+test for "same".  Replace it by the obvious one.  While there, improve
 comments.
-Signed-off-by: Nir Soffer <nirsof@gmail.com>
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/file-posix.c | 7 ++++++-
+ qobject/block-qdict.c | 14 +++++++++-----
-file changed, 6 insertions(+), 1 deletion(-)
+file changed, 9 insertions(+), 5 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/qobject/block-qdict.c
-+++ b/block/file-posix.c
++++ b/qobject/block-qdict.c
-@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
-     switch (prealloc) {
+         value = qlist_entry_obj(entry);
- #ifdef CONFIG_POSIX_FALLOCATE
+         new_key = g_strdup_printf("%s.%i", prefix, i);
-     case PREALLOC_MODE_FALLOC:
 -        /* posix_fallocate() doesn't set errno. */
 +        /*
-+         * Truncating before posix_fallocate() makes it about twice slower on
++         * Flatten non-empty QDict and QList recursively into @target,
-+         * file systems that do not support fallocate(), trying to check if a
++         * copy other objects to @target
 +         * block is allocated before allocating it, so don't do that here.
 +         */
-         result = -posix_fallocate(fd, 0, total_size);
+         if (qobject_type(value) == QTYPE_QDICT) {
-         if (result != 0) {
+             qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
-+            /* posix_fallocate() doesn't set errno. */
+         } else if (qobject_type(value) == QTYPE_QLIST) {
-             error_setg_errno(errp, -result,
+             qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
-                              "Could not preallocate data for the new file");
+         } else {
 -            /* All other types are moved to the target unchanged. */
              qdict_put_obj(target, new_key, qobject_ref(value));
          }
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
              new_key = g_strdup_printf("%s.%s", prefix, entry->key);
          }
 +        /*
 +         * Flatten non-empty QDict and QList recursively into @target,
 +         * copy other objects to @target
 +         */
          if (qobject_type(value) == QTYPE_QDICT) {
 -            /* Entries of QDicts are processed recursively, the QDict object
 -             * itself disappears. */
              qdict_flatten_qdict(qobject_to(QDict, value), target,
                                  new_key ? new_key : entry->key);
              qdict_del(qdict, entry->key);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
              qdict_flatten_qlist(qobject_to(QList, value), target,
                                  new_key ? new_key : entry->key);
              qdict_del(qdict, entry->key);
 -        } else if (prefix) {
 -            /* All other objects are moved to the target unchanged. */
 +        } else if (target != qdict) {
              qdict_put_obj(target, new_key, qobject_ref(value));
              qdict_del(qdict, entry->key);
          }
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 16/26] block-qdict: Clean up qdict_crumple() a bit
+From: Markus Armbruster <armbru@redhat.com>
+When you mix scalar and non-scalar keys, whether you get an "already
+set as scalar" or an "already set as dict" error depends on qdict
+iteration order.  Neither message makes much sense.  Replace by
+""Cannot mix scalar and non-scalar keys".  This is similar to the
+message we get for mixing list and non-list keys.
+I find qdict_crumple()'s first loop hard to understand.  Rearrange it
+and add a comment.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ qobject/block-qdict.c | 32 ++++++++++++++++----------------
+file changed, 16 insertions(+), 16 deletions(-)
+diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qobject/block-qdict.c
++++ b/qobject/block-qdict.c
+@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
+ QObject *qdict_crumple(const QDict *src, Error **errp)
+ {
+     const QDictEntry *ent;
+-    QDict *two_level, *multi_level = NULL;
++    QDict *two_level, *multi_level = NULL, *child_dict;
+     QObject *dst = NULL, *child;
+     size_t i;
+     char *prefix = NULL;
+@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
+         }
+         qdict_split_flat_key(ent->key, &prefix, &suffix);
+-
+         child = qdict_get(two_level, prefix);
++        child_dict = qobject_to(QDict, child);
++
++        if (child) {
++            /*
++             * If @child_dict, then all previous keys with this prefix
++             * had a suffix.  If @suffix, this one has one as well,
++             * and we're good, else there's a clash.
++             */
++            if (!child_dict || !suffix) {
++                error_setg(errp, "Cannot mix scalar and non-scalar keys");
++                goto error;
++            }
++        }
++
+         if (suffix) {
+-            QDict *child_dict = qobject_to(QDict, child);
+             if (!child_dict) {
+-                if (child) {
+-                    error_setg(errp, "Key %s prefix is already set as a scalar",
+-                               prefix);
+-                    goto error;
+-                }
+-
+                 child_dict = qdict_new();
+-                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
++                qdict_put(two_level, prefix, child_dict);
+             }
+-
+             qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
+         } else {
+-            if (child) {
+-                error_setg(errp, "Key %s prefix is already set as a dict",
+-                           prefix);
+-                goto error;
+-            }
+             qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
+         }
+--
+.13.6

-[Qemu-devel] [PULL 06/19] qemu-img: Truncate before full preallocation
+[Qemu-devel] [PULL 17/26] block-qdict: Simplify qdict_is_list() some
-From: Nir Soffer <nirsof@gmail.com>
+From: Markus Armbruster <armbru@redhat.com>
-In a previous commit (qemu-img: Do not truncate before preallocation) we
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
-moved truncate to the PREALLOC_MODE_OFF branch to avoid slowdown in
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 posix_fallocate().
 However this change is not optimal when using PREALLOC_MODE_FULL, since
 knowing the final size from the beginning could allow the file system
 driver to do less allocations and possibly avoid fragmentation of the
 file.
 Now we truncate also before doing full preallocation.
 Signed-off-by: Nir Soffer <nirsof@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/file-posix.c | 12 ++++++++++++
+ qobject/block-qdict.c | 27 +++++++++++----------------
-file changed, 12 insertions(+)
+file changed, 11 insertions(+), 16 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/qobject/block-qdict.c
-+++ b/block/file-posix.c
++++ b/qobject/block-qdict.c
-@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
- #endif
-     case PREALLOC_MODE_FULL:
+     for (ent = qdict_first(maybe_list); ent != NULL;
-     {
+          ent = qdict_next(maybe_list, ent)) {
-+        /*
++        int is_index = !qemu_strtoi64(ent->key, NULL, 10, &val);
-+         * Knowing the final size from the beginning could allow the file
-+         * system driver to do less allocations and possibly avoid
+-        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
-+         * fragmentation of the file.
+-            if (is_list == -1) {
-+         */
+-                is_list = 1;
-+        if (ftruncate(fd, total_size) != 0) {
+-            } else if (!is_list) {
-+            result = -errno;
+-                error_setg(errp,
-+            error_setg_errno(errp, -result, "Could not resize file");
+-                           "Cannot mix list and non-list keys");
-+            goto out_close;
+-                return -1;
 -            }
 +        if (is_list == -1) {
 +            is_list = is_index;
 +        }
 +
-         int64_t num = 0, left = total_size;
++        if (is_index != is_list) {
-         buf = g_malloc0(65536);
++            error_setg(errp, "Cannot mix list and non-list keys");
++            return -1;
-@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
++        }
-         break;
++
 +        if (is_index) {
              len++;
              if (val > max) {
                  max = val;
              }
 -        } else {
 -            if (is_list == -1) {
 -                is_list = 0;
 -            } else if (is_list) {
 -                error_setg(errp,
 -                           "Cannot mix list and non-list keys");
 -                return -1;
 -            }
          }
      }
-+out_close:
-     if (qemu_close(fd) != 0 && result == 0) {
-         result = -errno;
-         error_setg_errno(errp, -result, "Could not close the new file");
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 02/19] qemu-iotests: add ability to exclude certain protocols from tests
+[Qemu-devel] [PULL 18/26] check-block-qdict: Rename qdict_flatten()'s variables for clarity
-From: Jeff Cody <jcody@redhat.com>
+From: Markus Armbruster <armbru@redhat.com>
-Add the ability for shell script tests to exclude specific
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
-protocols.  This is useful to allow all protocols except ones known to
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 not support a feature used in the test (e.g. .bdrv_create).
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/common.rc | 12 ++++++++++++
+ tests/check-block-qdict.c | 57 ++++++++++++++++++++++++-----------------------
-file changed, 12 insertions(+)
+file changed, 29 insertions(+), 28 deletions(-)
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
+diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
+--- a/tests/check-block-qdict.c
-+++ b/tests/qemu-iotests/common.rc
++++ b/tests/check-block-qdict.c
-@@ -XXX,XX +XXX,XX @@ _supported_proto()
+@@ -XXX,XX +XXX,XX @@ static void qdict_defaults_test(void)
-     _notrun "not suitable for this image protocol: $IMGPROTO"
  static void qdict_flatten_test(void)
  {
 -    QList *list1 = qlist_new();
 -    QList *list2 = qlist_new();
 -    QDict *dict1 = qdict_new();
 -    QDict *dict2 = qdict_new();
 -    QDict *dict3 = qdict_new();
 +    QList *e_1 = qlist_new();
 +    QList *e = qlist_new();
 +    QDict *e_1_2 = qdict_new();
 +    QDict *f = qdict_new();
 +    QDict *root = qdict_new();
      /*
       * Test the flattening of
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
       * }
       */
 -    qdict_put_int(dict1, "a", 0);
 -    qdict_put_int(dict1, "b", 1);
 +    qdict_put_int(e_1_2, "a", 0);
 +    qdict_put_int(e_1_2, "b", 1);
 -    qlist_append_int(list1, 23);
 -    qlist_append_int(list1, 66);
 -    qlist_append(list1, dict1);
 -    qlist_append_int(list2, 42);
 -    qlist_append(list2, list1);
 +    qlist_append_int(e_1, 23);
 +    qlist_append_int(e_1, 66);
 +    qlist_append(e_1, e_1_2);
 +    qlist_append_int(e, 42);
 +    qlist_append(e, e_1);
 -    qdict_put_int(dict2, "c", 2);
 -    qdict_put_int(dict2, "d", 3);
 -    qdict_put(dict3, "e", list2);
 -    qdict_put(dict3, "f", dict2);
 -    qdict_put_int(dict3, "g", 4);
 +    qdict_put_int(f, "c", 2);
 +    qdict_put_int(f, "d", 3);
 -    qdict_flatten(dict3);
 +    qdict_put(root, "e", e);
 +    qdict_put(root, "f", f);
 +    qdict_put_int(root, "g", 4);
 -    g_assert(qdict_get_int(dict3, "e.0") == 42);
 -    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
 -    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
 -    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
 -    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
 -    g_assert(qdict_get_int(dict3, "f.c") == 2);
 -    g_assert(qdict_get_int(dict3, "f.d") == 3);
 -    g_assert(qdict_get_int(dict3, "g") == 4);
 +    qdict_flatten(root);
 -    g_assert(qdict_size(dict3) == 8);
 +    g_assert(qdict_get_int(root, "e.0") == 42);
 +    g_assert(qdict_get_int(root, "e.1.0") == 23);
 +    g_assert(qdict_get_int(root, "e.1.1") == 66);
 +    g_assert(qdict_get_int(root, "e.1.2.a") == 0);
 +    g_assert(qdict_get_int(root, "e.1.2.b") == 1);
 +    g_assert(qdict_get_int(root, "f.c") == 2);
 +    g_assert(qdict_get_int(root, "f.d") == 3);
 +    g_assert(qdict_get_int(root, "g") == 4);
 -    qobject_unref(dict3);
 +    g_assert(qdict_size(root) == 8);
 +
 +    qobject_unref(root);
  }
-+# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
+ static void qdict_array_split_test(void)
 +#
 +_unsupported_proto()
 +{
 +    for f; do
 +        if [ "$f" = "$IMGPROTO" ]; then
 +            _notrun "not suitable for this image protocol: $IMGPROTO"
 +            return
 +        fi
 +    done
 +}
 +
  # tests whether the host OS is one of the supported OSes for a test
  #
  _supported_os()
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 01/19] qemu-iotests: Test 137 only supports 'file' protocol
+[Qemu-devel] [PULL 19/26] check-block-qdict: Cover flattening of empty lists and dictionaries
-From: Jeff Cody <jcody@redhat.com>
+From: Markus Armbruster <armbru@redhat.com>
-Since test 137 make uses of qcow2.py, only local files are supported.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/137 | 2 +-
+ tests/check-block-qdict.c | 14 +++++++++++++-
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 13 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137
+diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/137
+--- a/tests/check-block-qdict.c
-+++ b/tests/qemu-iotests/137
++++ b/tests/check-block-qdict.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
- . ./common.qemu
+     QList *e = qlist_new();
+     QDict *e_1_2 = qdict_new();
- _supported_fmt qcow2
+     QDict *f = qdict_new();
--_supported_proto generic
++    QList *y = qlist_new();
-+_supported_proto file
++    QDict *z = qdict_new();
- _supported_os Linux
+     QDict *root = qdict_new();
      /*
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
       *         "c": 2,
       *         "d": 3,
       *     },
 -     *     "g": 4
 +     *     "g": 4,
 +     *     "y": [{}],
 +     *     "z": {"a": []}
       * }
       *
       * to
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
       *     "f.d": 3,
       *     "g": 4
       * }
 +     *
 +     * Note that "y" and "z" get eaten.
       */
      qdict_put_int(e_1_2, "a", 0);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
      qdict_put_int(f, "c", 2);
      qdict_put_int(f, "d", 3);
 +    qlist_append(y, qdict_new());
 +
 +    qdict_put(z, "a", qlist_new());
 +
      qdict_put(root, "e", e);
      qdict_put(root, "f", f);
      qdict_put_int(root, "g", 4);
 +    qdict_put(root, "y", y);
 +    qdict_put(root, "z", z);
      qdict_flatten(root);
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 20/26] block: Fix -blockdev / blockdev-add for empty objects and arrays
+From: Markus Armbruster <armbru@redhat.com>
 -blockdev and blockdev-add silently ignore empty objects and arrays in
 their argument.  That's because qmp_blockdev_add() converts the
 argument to a flat QDict, and qdict_flatten() eats empty QDict and
 QList members.  For instance, we ignore an empty BlockdevOptions
 member @cache.  No real harm, as absent means the same as empty there.
 Thus, the flaw puts an artificial restriction on the QAPI schema: we
 can't have potentially empty objects and arrays within
 BlockdevOptions, except when they're optional and "empty" has the same
 meaning as "absent".
 Our QAPI schema satisfies this restriction (I checked), but it's a
 trap for the unwary, and a temptation to employ awkward workarounds
 for the wary.  Let's get rid of it.
 Change qdict_flatten() and qdict_crumple() to treat empty dictionaries
 and lists exactly like scalars.
 Signed-off-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  qobject/block-qdict.c     | 54 +++++++++++++++++++++++++++++------------------
  tests/check-block-qdict.c | 38 ++++++++++++++++++++++++++-------
 files changed, 63 insertions(+), 29 deletions(-)
 diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qobject/block-qdict.c
 +++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
  {
      QObject *value;
      const QListEntry *entry;
 +    QDict *dict_val;
 +    QList *list_val;
      char *new_key;
      int i;
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
      for (i = 0; entry; entry = qlist_next(entry), i++) {
          value = qlist_entry_obj(entry);
 +        dict_val = qobject_to(QDict, value);
 +        list_val = qobject_to(QList, value);
          new_key = g_strdup_printf("%s.%i", prefix, i);
          /*
           * Flatten non-empty QDict and QList recursively into @target,
           * copy other objects to @target
           */
 -        if (qobject_type(value) == QTYPE_QDICT) {
 -            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
 -        } else if (qobject_type(value) == QTYPE_QLIST) {
 -            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
 +        if (dict_val && qdict_size(dict_val)) {
 +            qdict_flatten_qdict(dict_val, target, new_key);
 +        } else if (list_val && !qlist_empty(list_val)) {
 +            qdict_flatten_qlist(list_val, target, new_key);
          } else {
              qdict_put_obj(target, new_key, qobject_ref(value));
          }
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
  {
      QObject *value;
      const QDictEntry *entry, *next;
 +    QDict *dict_val;
 +    QList *list_val;
      char *new_key;
      entry = qdict_first(qdict);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
      while (entry != NULL) {
          next = qdict_next(qdict, entry);
          value = qdict_entry_value(entry);
 +        dict_val = qobject_to(QDict, value);
 +        list_val = qobject_to(QList, value);
          new_key = NULL;
          if (prefix) {
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
           * Flatten non-empty QDict and QList recursively into @target,
           * copy other objects to @target
           */
 -        if (qobject_type(value) == QTYPE_QDICT) {
 -            qdict_flatten_qdict(qobject_to(QDict, value), target,
 +        if (dict_val && qdict_size(dict_val)) {
 +            qdict_flatten_qdict(dict_val, target,
                                  new_key ? new_key : entry->key);
              qdict_del(qdict, entry->key);
 -        } else if (qobject_type(value) == QTYPE_QLIST) {
 -            qdict_flatten_qlist(qobject_to(QList, value), target,
 +        } else if (list_val && !qlist_empty(list_val)) {
 +            qdict_flatten_qlist(list_val, target,
                                  new_key ? new_key : entry->key);
              qdict_del(qdict, entry->key);
          } else if (target != qdict) {
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
  }
  /**
 - * qdict_flatten(): For each nested QDict with key x, all fields with key y
 - * are moved to this QDict and their key is renamed to "x.y". For each nested
 - * QList with key x, the field at index y is moved to this QDict with the key
 - * "x.y" (i.e., the reverse of what qdict_array_split() does).
 + * qdict_flatten(): For each nested non-empty QDict with key x, all
 + * fields with key y are moved to this QDict and their key is renamed
 + * to "x.y". For each nested non-empty QList with key x, the field at
 + * index y is moved to this QDict with the key "x.y" (i.e., the
 + * reverse of what qdict_array_split() does).
   * This operation is applied recursively for nested QDicts and QLists.
   */
  void qdict_flatten(QDict *qdict)
@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
   * @src: the original flat dictionary (only scalar values) to crumple
   *
   * Takes a flat dictionary whose keys use '.' separator to indicate
 - * nesting, and values are scalars, and crumples it into a nested
 - * structure.
 + * nesting, and values are scalars, empty dictionaries or empty lists,
 + * and crumples it into a nested structure.
   *
   * To include a literal '.' in a key name, it must be escaped as '..'
   *
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
  {
      const QDictEntry *ent;
      QDict *two_level, *multi_level = NULL, *child_dict;
 +    QDict *dict_val;
 +    QList *list_val;
      QObject *dst = NULL, *child;
      size_t i;
      char *prefix = NULL;
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
      /* Step 1: split our totally flat dict into a two level dict */
      for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
 -        if (qobject_type(ent->value) == QTYPE_QDICT ||
 -            qobject_type(ent->value) == QTYPE_QLIST) {
 -            error_setg(errp, "Value %s is not a scalar",
 -                       ent->key);
 +        dict_val = qobject_to(QDict, ent->value);
 +        list_val = qobject_to(QList, ent->value);
 +        if ((dict_val && qdict_size(dict_val))
 +            || (list_val && !qlist_empty(list_val))) {
 +            error_setg(errp, "Value %s is not flat", ent->key);
              goto error;
          }
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
      multi_level = qdict_new();
      for (ent = qdict_first(two_level); ent != NULL;
           ent = qdict_next(two_level, ent)) {
 -        QDict *dict = qobject_to(QDict, ent->value);
 -        if (dict) {
 -            child = qdict_crumple(dict, errp);
 +        dict_val = qobject_to(QDict, ent->value);
 +        if (dict_val && qdict_size(dict_val)) {
 +            child = qdict_crumple(dict_val, errp);
              if (!child) {
                  goto error;
              }
 diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/check-block-qdict.c
 +++ b/tests/check-block-qdict.c
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
       *     "e.1.2.b": 1,
       *     "f.c": 2,
       *     "f.d": 3,
 -     *     "g": 4
 +     *     "g": 4,
 +     *     "y.0": {},
 +     *     "z.a": []
       * }
 -     *
 -     * Note that "y" and "z" get eaten.
       */
      qdict_put_int(e_1_2, "a", 0);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
      g_assert(qdict_get_int(root, "f.c") == 2);
      g_assert(qdict_get_int(root, "f.d") == 3);
      g_assert(qdict_get_int(root, "g") == 4);
 +    g_assert(!qdict_size(qdict_get_qdict(root, "y.0")));
 +    g_assert(qlist_empty(qdict_get_qlist(root, "z.a")));
 -    g_assert(qdict_size(root) == 8);
 +    g_assert(qdict_size(root) == 10);
      qobject_unref(root);
  }
@@ -XXX,XX +XXX,XX @@ static void qdict_join_test(void)
  static void qdict_crumple_test_recursive(void)
  {
      QDict *src, *dst, *rule, *vnc, *acl, *listen;
 -    QList *rules;
 +    QDict *empty, *empty_dict, *empty_list_0;
 +    QList *rules, *empty_list, *empty_dict_a;
      src = qdict_new();
      qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_recursive(void)
      qdict_put_str(src, "vnc.acl.default", "deny");
      qdict_put_str(src, "vnc.acl..name", "acl0");
      qdict_put_str(src, "vnc.acl.rule..name", "acl0");
 +    qdict_put(src, "empty.dict.a", qlist_new());
 +    qdict_put(src, "empty.list.0", qdict_new());
      dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
      g_assert(dst);
 -    g_assert_cmpint(qdict_size(dst), ==, 1);
 +    g_assert_cmpint(qdict_size(dst), ==, 2);
      vnc = qdict_get_qdict(dst, "vnc");
      g_assert(vnc);
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_recursive(void)
      g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
      g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
 +    empty = qdict_get_qdict(dst, "empty");
 +    g_assert(empty);
 +    g_assert_cmpint(qdict_size(empty), ==, 2);
 +    empty_dict = qdict_get_qdict(empty, "dict");
 +    g_assert(empty_dict);
 +    g_assert_cmpint(qdict_size(empty_dict), ==, 1);
 +    empty_dict_a = qdict_get_qlist(empty_dict, "a");
 +    g_assert(empty_dict_a && qlist_empty(empty_dict_a));
 +    empty_list = qdict_get_qlist(empty, "list");
 +    g_assert(empty_list);
 +    g_assert_cmpint(qlist_size(empty_list), ==, 1);
 +    empty_list_0 = qobject_to(QDict, qlist_pop(empty_list));
 +    g_assert(empty_list_0);
 +    g_assert_cmpint(qdict_size(empty_list_0), ==, 0);
 +
      qobject_unref(src);
      qobject_unref(dst);
  }
@@ -XXX,XX +XXX,XX @@ static void qdict_rename_keys_test(void)
  static void qdict_crumple_test_bad_inputs(void)
  {
 -    QDict *src;
 +    QDict *src, *nested;
      Error *error = NULL;
      src = qdict_new();
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_bad_inputs(void)
      src = qdict_new();
      /* The input should be flat, ie no dicts or lists */
 -    qdict_put(src, "rule.a", qdict_new());
 +    nested = qdict_new();
 +    qdict_put(nested, "x", qdict_new());
 +    qdict_put(src, "rule.a", nested);
      qdict_put_str(src, "rule.b", "allow");
      g_assert(qdict_crumple(src, &error) == NULL);
 --
 .13.6

-[Qemu-devel] [PULL 17/19] block: Add bdrv_new_open_driver()
+[Qemu-devel] [PULL 21/26] rbd: New parameter auth-client-required
-This function allows to create more or less normal BlockDriverStates
+From: Markus Armbruster <armbru@redhat.com>
 even for BlockDrivers that aren't globally registered (e.g. helper
 filters for block jobs).
+Parameter auth-client-required lets you configure authentication
+methods.  We tried to provide that in v2.9.0, but backed out due to
+interface design doubts (commit 464444fcc16).
+This commit is similar to what we backed out, but simpler: we use a
+list of enumeration values instead of a list of objects with a member
+of enumeration type.
+Let's review our reasons for backing out the first try, as stated in
+the commit message:
+    * The implementation uses deprecated rados_conf_set() key
+      "auth_supported".  No biggie.
+Fixed: we use "auth-client-required".
+    * The implementation makes -drive silently ignore invalid parameters
+      "auth" and "auth-supported.*.X" where X isn't "auth".  Fixable (in
+      fact I'm going to fix similar bugs around parameter server), so
+      again no biggie.
+That fix is commit 2836284db60.  This commit doesn't bring the bugs
+back.
+    * BlockdevOptionsRbd member @password-secret applies only to
+      authentication method cephx.  Should it be a variant member of
+      RbdAuthMethod?
+We've had time to ponder, and we decided to stick to the way Ceph
+configuration works: the key configured separately, and silently
+ignored if the authentication method doesn't use it.
+    * BlockdevOptionsRbd member @user could apply to both methods cephx
+      and none, but I'm not sure it's actually used with none.  If it
+      isn't, should it be a variant member of RbdAuthMethod?
+Likewise.
+    * The client offers a *set* of authentication methods, not a list.
+      Should the methods be optional members of BlockdevOptionsRbd instead
+      of members of list @auth-supported?  The latter begs the question
+      what multiple entries for the same method mean.  Trivial question
+      now that RbdAuthMethod contains nothing but @type, but less so when
+      RbdAuthMethod acquires other members, such the ones discussed above.
+Again, we decided to stick to the way Ceph configuration works, except
+we make auth-client-required a list of enumeration values instead of a
+string containing keywords separated by delimiters.
+    * How BlockdevOptionsRbd member @auth-supported interacts with
+      settings from a configuration file specified with @conf is
+      undocumented.  I suspect it's untested, too.
+Not actually true, the documentation for @conf says "Values in the
+configuration file will be overridden by options specified via QAPI",
+and we've tested this.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c               | 30 +++++++++++++++++++++++++++++-
+ qapi/block-core.json | 13 +++++++++++++
- include/block/block.h |  2 ++
+ block/rbd.c          | 42 ++++++++++++++++++++++++++++++++----------
-files changed, 31 insertions(+), 1 deletion(-)
+files changed, 45 insertions(+), 10 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/qapi/block-core.json
-+++ b/block.c
++++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@ static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
+@@ -XXX,XX +XXX,XX @@
  ##
 +# @RbdAuthMode:
 +#
 +# Since: 3.0
 +##
 +{ 'enum': 'RbdAuthMode',
 +  'data': [ 'cephx', 'none' ] }
 +
 +##
  # @BlockdevOptionsRbd:
  #
  # @pool:               Ceph pool name.
@@ -XXX,XX +XXX,XX @@
  #
  # @user:               Ceph id name.
  #
 +# @auth-client-required: Acceptable authentication modes.
 +#                      This maps to Ceph configuration option
 +#                      "auth_client_required".  (Since 3.0)
 +#
  # @server:             Monitor host address and port.  This maps
  #                      to the "mon_host" Ceph option.
  #
@@ -XXX,XX +XXX,XX @@
              '*conf': 'str',
              '*snapshot': 'str',
              '*user': 'str',
 +            '*auth-client-required': ['RbdAuthMode'],
              '*server': ['InetSocketAddressBase'] } }
  ##
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_refresh_limits(BlockDriverState *bs, Error **errp)
  static int qemu_rbd_set_auth(rados_t cluster, const char *secretid,
 +                             BlockdevOptionsRbd *opts,
                               Error **errp)
  {
 -    if (secretid == 0) {
 -        return 0;
 -    }
 +    char *acr;
 +    int r;
 +    GString *accu;
 +    RbdAuthModeList *auth;
 +
 +    if (secretid) {
 +        gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
 +                                                        errp);
 +        if (!secret) {
 +            return -1;
 +        }
 -    gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
 -                                                    errp);
 -    if (!secret) {
 -        return -1;
 +        rados_conf_set(cluster, "key", secret);
 +        g_free(secret);
      }
-     bs->drv = drv;
+-    rados_conf_set(cluster, "key", secret);
-+    bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
+-    g_free(secret);
-     bs->opaque = g_malloc0(drv->instance_size);
++    if (opts->has_auth_client_required) {
++        accu = g_string_new("");
-     if (drv->bdrv_file_open) {
++        for (auth = opts->auth_client_required; auth; auth = auth->next) {
-         assert(!drv->bdrv_needs_filename || bs->filename[0]);
++            if (accu->str[0]) {
-         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
++                g_string_append_c(accu, ';');
--    } else {
++            }
-+    } else if (drv->bdrv_open) {
++            g_string_append(accu, RbdAuthMode_str(auth->value));
-         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
++        }
-+    } else {
++        acr = g_string_free(accu, FALSE);
-+        ret = 0;
++        r = rados_conf_set(cluster, "auth_client_required", acr);
 +        g_free(acr);
 +        if (r < 0) {
 +            error_setg_errno(errp, -r,
 +                             "Could not set 'auth_client_required'");
 +            return r;
 +        }
 +    }
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
          }
      }
-     if (ret < 0) {
+-    if (qemu_rbd_set_auth(*cluster, secretid, errp) < 0) {
-@@ -XXX,XX +XXX,XX @@ free_and_fail:
++    if (qemu_rbd_set_auth(*cluster, secretid, opts, errp) < 0) {
-     return ret;
+         r = -EIO;
- }
+         goto failed_shutdown;
+     }
 +BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
 +                                       int flags, Error **errp)
 +{
 +    BlockDriverState *bs;
 +    int ret;
 +
 +    bs = bdrv_new();
 +    bs->open_flags = flags;
 +    bs->explicit_options = qdict_new();
 +    bs->options = qdict_new();
 +    bs->opaque = NULL;
 +
 +    update_options_from_flags(bs->options, flags);
 +
 +    ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
 +    if (ret < 0) {
 +        QDECREF(bs->explicit_options);
 +        QDECREF(bs->options);
 +        bdrv_unref(bs);
 +        return NULL;
 +    }
 +
 +    return bs;
 +}
 +
  QemuOptsList bdrv_runtime_opts = {
      .name = "bdrv_common",
      .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
 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 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
                             const char *bdref_key, Error **errp);
  BlockDriverState *bdrv_open(const char *filename, const char *reference,
                              QDict *options, int flags, Error **errp);
 +BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
 +                                       int flags, Error **errp);
  BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
                                      BlockDriverState *bs,
                                      QDict *options, int flags);
 --
-.8.3.1
+.13.6

-[Qemu-devel] [PULL 15/19] block: Use BlockBackend for image probing
+[Qemu-devel] [PULL 22/26] rbd: New parameter key-secret
-This fixes the use of a parent-less BdrvChild in bdrv_open_inherit() by
+From: Markus Armbruster <armbru@redhat.com>
 converting it into a BlockBackend. Which is exactly what it should be,
 image probing is an external, standalone user of a node. The requests
 can't be considered to originate from the format driver node because
 that one isn't even opened yet.
+Legacy -drive supports "password-secret" parameter that isn't
+available with -blockdev / blockdev-add.  That's because we backed out
+our first try to provide it there due to interface design doubts, in
+commit 577d8c9a811, v2.9.0.
+This is the second try.  It brings back the parameter, except it's
+named "key-secret" now.
+Let's review our reasons for backing out the first try, as stated in
+the commit message:
+    * BlockdevOptionsRbd member @password-secret isn't actually a
+      password, it's a key generated by Ceph.
+Addressed by the rename.
+    * We're not sure where member @password-secret belongs (see the
+      previous commit).
+See previous commit.
+    * How @password-secret interacts with settings from a configuration
+      file specified with @conf is undocumented.
+Not actually true, the documentation for @conf says "Values in the
+configuration file will be overridden by options specified via QAPI",
+and we've tested this.
+Signed-off-by: Markus Armbruster <armbru@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 36 +++++++++++++++++++-----------------
+ qapi/block-core.json |  6 ++++++
-file changed, 19 insertions(+), 17 deletions(-)
+ block/rbd.c          | 41 +++++++++++++++++++++++++----------------
 files changed, 31 insertions(+), 16 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/qapi/block-core.json
-+++ b/block.c
++++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@ BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
+@@ -XXX,XX +XXX,XX @@
-     return drv;
+ #                      This maps to Ceph configuration option
  #                      "auth_client_required".  (Since 3.0)
  #
 +# @key-secret:         ID of a QCryptoSecret object providing a key
 +#                      for cephx authentication.
 +#                      This maps to Ceph configuration option
 +#                      "key".  (Since 3.0)
 +#
  # @server:             Monitor host address and port.  This maps
  #                      to the "mon_host" Ceph option.
  #
@@ -XXX,XX +XXX,XX @@
              '*snapshot': 'str',
              '*user': 'str',
              '*auth-client-required': ['RbdAuthMode'],
 +            '*key-secret': 'str',
              '*server': ['InetSocketAddressBase'] } }
  ##
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_refresh_limits(BlockDriverState *bs, Error **errp)
  }
--static int find_image_format(BdrvChild *file, const char *filename,
-+static int find_image_format(BlockBackend *file, const char *filename,
+-static int qemu_rbd_set_auth(rados_t cluster, const char *secretid,
-                              BlockDriver **pdrv, Error **errp)
+-                             BlockdevOptionsRbd *opts,
 +static int qemu_rbd_set_auth(rados_t cluster, BlockdevOptionsRbd *opts,
                               Error **errp)
  {
--    BlockDriverState *bs = file->bs;
+-    char *acr;
-     BlockDriver *drv;
++    char *key, *acr;
-     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
+     int r;
-     int ret = 0;
+     GString *accu;
+     RbdAuthModeList *auth;
-     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
--    if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
+-    if (secretid) {
-+    if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
+-        gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
-         *pdrv = &bdrv_raw;
+-                                                        errp);
-         return ret;
+-        if (!secret) {
 -            return -1;
 +    if (opts->key_secret) {
 +        key = qcrypto_secret_lookup_as_base64(opts->key_secret, errp);
 +        if (!key) {
 +            return -EIO;
 +        }
 +        r = rados_conf_set(cluster, "key", key);
 +        g_free(key);
 +        if (r < 0) {
 +            error_setg_errno(errp, -r, "Could not set 'key'");
 +            return r;
          }
 -
 -        rados_conf_set(cluster, "key", secret);
 -        g_free(secret);
      }
--    ret = bdrv_pread(file, 0, buf, sizeof(buf));
+     if (opts->has_auth_client_required) {
-+    ret = blk_pread(file, 0, buf, sizeof(buf));
+@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
-     if (ret < 0) {
+     },
-         error_setg_errno(errp, -ret, "Could not read image for determining its "
+ };
-                          "format");
-@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
+-/* FIXME Deprecate and remove keypairs or make it available in QMP.
-  *
+- * password_secret should eventually be configurable in opts->location. Support
-  * Removes all processed options from *options.
+- * for it in .bdrv_open will make it work here as well. */
-  */
++/* FIXME Deprecate and remove keypairs or make it available in QMP. */
--static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
+ static int qemu_rbd_do_create(BlockdevCreateOptions *options,
-+static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
+                               const char *keypairs, const char *password_secret,
-                             QDict *options, Error **errp)
+                               Error **errp)
- {
+@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
-     int ret, open_flags;
+     Error *local_err = NULL;
-@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
+     int r;
-     assert(drv != NULL);
++    if (secretid) {
-     if (file != NULL) {
++        if (opts->key_secret) {
--        filename = file->bs->filename;
++            error_setg(errp,
-+        filename = blk_bs(file)->filename;
++                       "Legacy 'password-secret' clashes with 'key-secret'");
-     } else {
++            return -EINVAL;
-         filename = qdict_get_try_str(options, "filename");
++        }
-     }
++        opts->key_secret = g_strdup(secretid);
-@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
++        opts->has_key_secret = true;
-                                            Error **errp)
++    }
  {
      int ret;
 -    BdrvChild *file = NULL;
 +    BlockBackend *file = NULL;
      BlockDriverState *bs;
      BlockDriver *drv = NULL;
      const char *drvname;
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
          qdict_del(options, "backing");
      }
 -    /* Open image file without format layer. This BdrvChild is only used for
 +    /* Open image file without format layer. This BlockBackend is only used for
       * probing, the block drivers will do their own bdrv_open_child() for the
       * same BDS, which is why we put the node name back into options. */
      if ((flags & BDRV_O_PROTOCOL) == 0) {
 -        /* FIXME Shouldn't attach a child to a node that isn't opened yet. */
 -        file = bdrv_open_child(filename, options, "file", bs,
 -                               &child_file, true, &local_err);
 +        BlockDriverState *file_bs;
 +
-+        file_bs = bdrv_open_child_bs(filename, options, "file", bs,
+     mon_host = qemu_rbd_mon_host(opts, &local_err);
-+                                     &child_file, true, &local_err);
+     if (local_err) {
-         if (local_err) {
+         error_propagate(errp, local_err);
-             goto fail;
+@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
          }
 -        if (file != NULL) {
 +        if (file_bs != NULL) {
 +            file = blk_new();
 +            blk_insert_bs(file, file_bs);
 +            bdrv_unref(file_bs);
 +
              qdict_put(options, "file",
 -                      qstring_from_str(bdrv_get_node_name(file->bs)));
 +                      qstring_from_str(bdrv_get_node_name(file_bs)));
          }
      }
-@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
+-    if (qemu_rbd_set_auth(*cluster, secretid, opts, errp) < 0) {
 -        r = -EIO;
 +    r = qemu_rbd_set_auth(*cluster, opts, errp);
 +    if (r < 0) {
          goto failed_shutdown;
      }
-     if (file) {
--        bdrv_unref_child(bs, file);
-+        blk_unref(file);
-         file = NULL;
-     }
-@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
-     return bs;
- fail:
--    if (file != NULL) {
--        bdrv_unref_child(bs, file);
--    }
-+    blk_unref(file);
-     if (bs->file != NULL) {
-         bdrv_unref_child(bs, bs->file);
-     }
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 23/26] block: Remove deprecated -drive geometry options
+The -drive options cyls, heads, secs and trans were deprecated in
 QEMU 2.10. It's time to remove them.
 hd-geo-test tested both the old version with geometry options in -drive
 and the new one with -device. Therefore the code using -drive doesn't
 have to be replaced there, we just need to remove the -drive test cases.
 This in turn allows some simplification of the code.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Markus Armbruster <armbru@redhat.com>
 ---
  include/sysemu/blockdev.h |  1 -
  blockdev.c                | 75 +----------------------------------------------
  hw/block/block.c          | 14 ---------
  tests/hd-geo-test.c       | 37 +++++------------------
  hmp-commands.hx           |  1 -
  qemu-doc.texi             |  5 ----
  qemu-options.hx           |  7 +----
 files changed, 9 insertions(+), 131 deletions(-)
 diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/blockdev.h
 +++ b/include/sysemu/blockdev.h
@@ -XXX,XX +XXX,XX @@ struct DriveInfo {
      int auto_del;               /* see blockdev_mark_auto_del() */
      bool is_default;            /* Added by default_drive() ?  */
      int media_cd;
 -    int cyls, heads, secs, trans;
      QemuOpts *opts;
      char *serial;
      QTAILQ_ENTRY(DriveInfo) next;
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
              .type = QEMU_OPT_STRING,
              .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
          },{
 -            .name = "cyls",
 -            .type = QEMU_OPT_NUMBER,
 -            .help = "number of cylinders (ide disk geometry)",
 -        },{
 -            .name = "heads",
 -            .type = QEMU_OPT_NUMBER,
 -            .help = "number of heads (ide disk geometry)",
 -        },{
 -            .name = "secs",
 -            .type = QEMU_OPT_NUMBER,
 -            .help = "number of sectors (ide disk geometry)",
 -        },{
 -            .name = "trans",
 -            .type = QEMU_OPT_STRING,
 -            .help = "chs translation (auto, lba, none)",
 -        },{
              .name = "addr",
              .type = QEMU_OPT_STRING,
              .help = "pci address (virtio only)",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
      QemuOpts *legacy_opts;
      DriveMediaType media = MEDIA_DISK;
      BlockInterfaceType type;
 -    int cyls, heads, secs, translation;
      int max_devs, bus_id, unit_id, index;
      const char *devaddr;
      const char *werror, *rerror;
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
      Error *local_err = NULL;
      int i;
      const char *deprecated[] = {
 -        "serial", "trans", "secs", "heads", "cyls", "addr"
 +        "serial", "addr"
      };
      /* Change legacy command line options into QMP ones */
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
          type = block_default_type;
      }
 -    /* Geometry */
 -    cyls  = qemu_opt_get_number(legacy_opts, "cyls", 0);
 -    heads = qemu_opt_get_number(legacy_opts, "heads", 0);
 -    secs  = qemu_opt_get_number(legacy_opts, "secs", 0);
 -
 -    if (cyls || heads || secs) {
 -        if (cyls < 1) {
 -            error_report("invalid physical cyls number");
 -            goto fail;
 -        }
 -        if (heads < 1) {
 -            error_report("invalid physical heads number");
 -            goto fail;
 -        }
 -        if (secs < 1) {
 -            error_report("invalid physical secs number");
 -            goto fail;
 -        }
 -    }
 -
 -    translation = BIOS_ATA_TRANSLATION_AUTO;
 -    value = qemu_opt_get(legacy_opts, "trans");
 -    if (value != NULL) {
 -        if (!cyls) {
 -            error_report("'%s' trans must be used with cyls, heads and secs",
 -                         value);
 -            goto fail;
 -        }
 -        if (!strcmp(value, "none")) {
 -            translation = BIOS_ATA_TRANSLATION_NONE;
 -        } else if (!strcmp(value, "lba")) {
 -            translation = BIOS_ATA_TRANSLATION_LBA;
 -        } else if (!strcmp(value, "large")) {
 -            translation = BIOS_ATA_TRANSLATION_LARGE;
 -        } else if (!strcmp(value, "rechs")) {
 -            translation = BIOS_ATA_TRANSLATION_RECHS;
 -        } else if (!strcmp(value, "auto")) {
 -            translation = BIOS_ATA_TRANSLATION_AUTO;
 -        } else {
 -            error_report("'%s' invalid translation type", value);
 -            goto fail;
 -        }
 -    }
 -
 -    if (media == MEDIA_CDROM) {
 -        if (cyls || secs || heads) {
 -            error_report("CHS can't be set with media=cdrom");
 -            goto fail;
 -        }
 -    }
 -
      /* Device address specified by bus/unit or index.
       * If none was specified, try to find the first free one. */
      bus_id  = qemu_opt_get_number(legacy_opts, "bus", 0);
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
      dinfo = g_malloc0(sizeof(*dinfo));
      dinfo->opts = all_opts;
 -    dinfo->cyls = cyls;
 -    dinfo->heads = heads;
 -    dinfo->secs = secs;
 -    dinfo->trans = translation;
 -
      dinfo->type = type;
      dinfo->bus = bus_id;
      dinfo->unit = unit_id;
 diff --git a/hw/block/block.c b/hw/block/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/block.c
 +++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_geometry(BlockConf *conf, int *ptrans,
                        unsigned cyls_max, unsigned heads_max, unsigned secs_max,
                        Error **errp)
  {
 -    DriveInfo *dinfo;
 -
 -    if (!conf->cyls && !conf->heads && !conf->secs) {
 -        /* try to fall back to value set with legacy -drive cyls=... */
 -        dinfo = blk_legacy_dinfo(conf->blk);
 -        if (dinfo) {
 -            conf->cyls  = dinfo->cyls;
 -            conf->heads = dinfo->heads;
 -            conf->secs  = dinfo->secs;
 -            if (ptrans) {
 -                *ptrans = dinfo->trans;
 -            }
 -        }
 -    }
      if (!conf->cyls && !conf->heads && !conf->secs) {
          hd_geometry_guess(conf->blk,
                            &conf->cyls, &conf->heads, &conf->secs,
 diff --git a/tests/hd-geo-test.c b/tests/hd-geo-test.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/hd-geo-test.c
 +++ b/tests/hd-geo-test.c
@@ -XXX,XX +XXX,XX @@ static void setup_mbr(int img_idx, MBRcontents mbr)
  static int setup_ide(int argc, char *argv[], int argv_sz,
                       int ide_idx, const char *dev, int img_idx,
 -                     MBRcontents mbr, const char *opts)
 +                     MBRcontents mbr)
  {
      char *s1, *s2, *s3;
@@ -XXX,XX +XXX,XX @@ static int setup_ide(int argc, char *argv[], int argv_sz,
          s3 = g_strdup(",media=cdrom");
      }
      argc = append_arg(argc, argv, argv_sz,
 -                      g_strdup_printf("%s%s%s%s", s1, s2, s3, opts));
 +                      g_strdup_printf("%s%s%s", s1, s2, s3));
      g_free(s1);
      g_free(s2);
      g_free(s3);
@@ -XXX,XX +XXX,XX @@ static void test_ide_mbr(bool use_device, MBRcontents mbr)
      for (i = 0; i < backend_last; i++) {
          cur_ide[i] = &hd_chst[i][mbr];
          dev = use_device ? (is_hd(cur_ide[i]) ? "ide-hd" : "ide-cd") : NULL;
 -        argc = setup_ide(argc, argv, ARGV_SIZE, i, dev, i, mbr, "");
 +        argc = setup_ide(argc, argv, ARGV_SIZE, i, dev, i, mbr);
      }
      args = g_strjoinv(" ", argv);
      qtest_start(args);
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_user(const char *dev, bool trans)
      const CHST expected_chst = { secs / (4 * 32) , 4, 32, trans };
      argc = setup_common(argv, ARGV_SIZE);
 -    opts = g_strdup_printf("%s,%s%scyls=%d,heads=%d,secs=%d",
 -                           dev ?: "",
 -                           trans && dev ? "bios-chs-" : "",
 -                           trans ? "trans=lba," : "",
 +    opts = g_strdup_printf("%s,%scyls=%d,heads=%d,secs=%d",
 +                           dev, trans ? "bios-chs-trans=lba," : "",
                             expected_chst.cyls, expected_chst.heads,
                             expected_chst.secs);
      cur_ide[0] = &expected_chst;
 -    argc = setup_ide(argc, argv, ARGV_SIZE,
 -                     0, dev ? opts : NULL, backend_small, mbr_chs,
 -                     dev ? "" : opts);
 +    argc = setup_ide(argc, argv, ARGV_SIZE, 0, opts, backend_small, mbr_chs);
      g_free(opts);
      args = g_strjoinv(" ", argv);
      qtest_start(args);
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_user(const char *dev, bool trans)
  }
  /*
 - * Test case: IDE device (if=ide) with explicit CHS
 - */
 -static void test_ide_drive_user_chs(void)
 -{
 -    test_ide_drive_user(NULL, false);
 -}
 -
 -/*
 - * Test case: IDE device (if=ide) with explicit CHS and translation
 - */
 -static void test_ide_drive_user_chst(void)
 -{
 -    test_ide_drive_user(NULL, true);
 -}
 -
 -/*
   * Test case: IDE device (if=none) with explicit CHS
   */
  static void test_ide_device_user_chs(void)
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_cd_0(void)
      for (i = 0; i <= backend_empty; i++) {
          ide_idx = backend_empty - i;
          cur_ide[ide_idx] = &hd_chst[i][mbr_blank];
 -        argc = setup_ide(argc, argv, ARGV_SIZE,
 -                         ide_idx, NULL, i, mbr_blank, "");
 +        argc = setup_ide(argc, argv, ARGV_SIZE, ide_idx, NULL, i, mbr_blank);
      }
      args = g_strjoinv(" ", argv);
      qtest_start(args);
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      qtest_add_func("hd-geo/ide/drive/mbr/blank", test_ide_drive_mbr_blank);
      qtest_add_func("hd-geo/ide/drive/mbr/lba", test_ide_drive_mbr_lba);
      qtest_add_func("hd-geo/ide/drive/mbr/chs", test_ide_drive_mbr_chs);
 -    qtest_add_func("hd-geo/ide/drive/user/chs", test_ide_drive_user_chs);
 -    qtest_add_func("hd-geo/ide/drive/user/chst", test_ide_drive_user_chst);
      qtest_add_func("hd-geo/ide/drive/cd_0", test_ide_drive_cd_0);
      qtest_add_func("hd-geo/ide/device/mbr/blank", test_ide_device_mbr_blank);
      qtest_add_func("hd-geo/ide/device/mbr/lba", test_ide_device_mbr_lba);
 diff --git a/hmp-commands.hx b/hmp-commands.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/hmp-commands.hx
 +++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
          .params     = "[-n] [[<domain>:]<bus>:]<slot>\n"
                        "[file=file][,if=type][,bus=n]\n"
                        "[,unit=m][,media=d][,index=i]\n"
 -                      "[,cyls=c,heads=h,secs=s[,trans=t]]\n"
                        "[,snapshot=on|off][,cache=on|off]\n"
                        "[,readonly=on|off][,copy-on-read=on|off]",
          .help       = "add drive to PCI storage controller",
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-doc.texi
 +++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ with ``-device ...,netdev=x''), or ``-nic user,smb=/some/dir''
  (for embedded NICs). The new syntax allows different settings to be
  provided per NIC.
 -@subsection -drive cyls=...,heads=...,secs=...,trans=... (since 2.10.0)
 -
 -The drive geometry arguments are replaced by the the geometry arguments
 -that can be specified with the ``-device'' parameter.
 -
  @subsection -drive serial=... (since 2.10.0)
  The drive serial argument is replaced by the the serial argument
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
  DEF("drive", HAS_ARG, QEMU_OPTION_drive,
      "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
 -    "       [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
      "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
 -    "       [,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
 +    "       [,snapshot=on|off][,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
      "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
      "       [,readonly=on|off][,copy-on-read=on|off]\n"
      "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
@@ -XXX,XX +XXX,XX @@ This option defines where is connected the drive by using an index in the list
  of available connectors of a given interface type.
  @item media=@var{media}
  This option defines the type of the media: disk or cdrom.
 -@item cyls=@var{c},heads=@var{h},secs=@var{s}[,trans=@var{t}]
 -Force disk physical geometry and the optional BIOS translation (trans=none or
 -lba). These parameters are deprecated, use the corresponding parameters
 -of @code{-device} instead.
  @item snapshot=@var{snapshot}
  @var{snapshot} is "on" or "off" and controls snapshot mode for the given drive
  (see @option{-snapshot}).
 --
 .13.6

-[Qemu-devel] [PULL 16/19] block: Factor out bdrv_open_driver()
+[Qemu-devel] [PULL 24/26] block: Remove deprecated -drive option addr
-This is a function that doesn't do any option parsing, but just does
+The -drive option addr was deprecated in QEMU 2.10. It's time to remove
-some basic BlockDriverState setup and calls the .bdrv_open() function of
+it.
 the block driver.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
- block.c | 112 +++++++++++++++++++++++++++++++++++++---------------------------
+ include/sysemu/blockdev.h |  1 -
-file changed, 65 insertions(+), 47 deletions(-)
+ blockdev.c                | 17 +----------------
  device-hotplug.c          |  4 ----
  qemu-doc.texi             |  5 -----
  qemu-options.hx           |  5 +----
 files changed, 2 insertions(+), 30 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/include/sysemu/blockdev.h
-+++ b/block.c
++++ b/include/sysemu/blockdev.h
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@ typedef enum {
-     g_free(gen_node_name);
+ } BlockInterfaceType;
- }
+ struct DriveInfo {
-+static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
+-    const char *devaddr;
-+                            const char *node_name, QDict *options,
+     BlockInterfaceType type;
-+                            int open_flags, Error **errp)
+     int bus;
-+{
+     int unit;
-+    Error *local_err = NULL;
+diff --git a/blockdev.c b/blockdev.c
-+    int ret;
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/blockdev.c
-+    bdrv_assign_node_name(bs, node_name, &local_err);
++++ b/blockdev.c
-+    if (local_err) {
+@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
-+        error_propagate(errp, local_err);
+             .type = QEMU_OPT_STRING,
-+        return -EINVAL;
+             .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
-+    }
+         },{
-+
+-            .name = "addr",
-+    bs->drv = drv;
+-            .type = QEMU_OPT_STRING,
-+    bs->opaque = g_malloc0(drv->instance_size);
+-            .help = "pci address (virtio only)",
-+
+-        },{
-+    if (drv->bdrv_file_open) {
+             .name = "serial",
-+        assert(!drv->bdrv_needs_filename || bs->filename[0]);
+             .type = QEMU_OPT_STRING,
-+        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
+             .help = "disk serial number",
-+    } else {
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-+        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
+     DriveMediaType media = MEDIA_DISK;
-+    }
+     BlockInterfaceType type;
-+
+     int max_devs, bus_id, unit_id, index;
-+    if (ret < 0) {
+-    const char *devaddr;
-+        if (local_err) {
+     const char *werror, *rerror;
-+            error_propagate(errp, local_err);
+     bool read_only = false;
-+        } else if (bs->filename[0]) {
+     bool copy_on_read;
-+            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-+        } else {
+     Error *local_err = NULL;
-+            error_setg_errno(errp, -ret, "Could not open image");
+     int i;
-+        }
+     const char *deprecated[] = {
-+        goto free_and_fail;
+-        "serial", "addr"
-+    }
++        "serial"
-+
+     };
-+    ret = refresh_total_sectors(bs, bs->total_sectors);
-+    if (ret < 0) {
+     /* Change legacy command line options into QMP ones */
-+        error_setg_errno(errp, -ret, "Could not refresh total sector count");
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-+        goto free_and_fail;
+     }
-+    }
-+
+     /* Add virtio block device */
-+    bdrv_refresh_limits(bs, &local_err);
+-    devaddr = qemu_opt_get(legacy_opts, "addr");
-+    if (local_err) {
+-    if (devaddr && type != IF_VIRTIO) {
-+        error_propagate(errp, local_err);
+-        error_report("addr is not supported by this bus type");
-+        ret = -EINVAL;
+-        goto fail;
 +        goto free_and_fail;
 +    }
 +
 +    assert(bdrv_opt_mem_align(bs) != 0);
 +    assert(bdrv_min_mem_align(bs) != 0);
 +    assert(is_power_of_2(bs->bl.request_alignment));
 +
 +    return 0;
 +
 +free_and_fail:
 +    /* FIXME Close bs first if already opened*/
 +    g_free(bs->opaque);
 +    bs->opaque = NULL;
 +    bs->drv = NULL;
 +    return ret;
 +}
 +
  QemuOptsList bdrv_runtime_opts = {
      .name = "bdrv_common",
      .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
      trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
                             drv->format_name);
 -    node_name = qemu_opt_get(opts, "node-name");
 -    bdrv_assign_node_name(bs, node_name, &local_err);
 -    if (local_err) {
 -        error_propagate(errp, local_err);
 -        ret = -EINVAL;
 -        goto fail_opts;
 -    }
 -
-     bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
+     if (type == IF_VIRTIO) {
+         QemuOpts *devopts;
-     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
+         devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
-@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
          }
          qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
                       &error_abort);
 -        if (devaddr) {
 -            qemu_opt_set(devopts, "addr", devaddr, &error_abort);
 -        }
      }
-     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
+     filename = qemu_opt_get(legacy_opts, "file");
--    bs->drv = drv;
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
--    bs->opaque = g_malloc0(drv->instance_size);
+     dinfo->type = type;
      dinfo->bus = bus_id;
      dinfo->unit = unit_id;
 -    dinfo->devaddr = devaddr;
      dinfo->serial = g_strdup(serial);
      blk_set_legacy_dinfo(blk, dinfo);
 diff --git a/device-hotplug.c b/device-hotplug.c
 index XXXXXXX..XXXXXXX 100644
 --- a/device-hotplug.c
 +++ b/device-hotplug.c
@@ -XXX,XX +XXX,XX @@ void hmp_drive_add(Monitor *mon, const QDict *qdict)
      if (!dinfo) {
          goto err;
      }
 -    if (dinfo->devaddr) {
 -        monitor_printf(mon, "Parameter addr not supported\n");
 -        goto err;
 -    }
      switch (dinfo->type) {
      case IF_NONE:
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-doc.texi
 +++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ provided per NIC.
  The drive serial argument is replaced by the the serial argument
  that can be specified with the ``-device'' parameter.
 -@subsection -drive addr=... (since 2.10.0)
 -
-     /* Open the image, either directly or using a protocol */
+-The drive addr argument is replaced by the the addr argument
-     open_flags = bdrv_open_flags(bs, bs->open_flags);
+-that can be specified with the ``-device'' parameter.
 -    if (drv->bdrv_file_open) {
 -        assert(file == NULL);
 -        assert(!drv->bdrv_needs_filename || filename != NULL);
 -        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
 -    } else {
 -        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
 -    }
 -
--    if (ret < 0) {
+ @subsection -usbdevice (since 2.10.0)
--        if (local_err) {
--            error_propagate(errp, local_err);
+ The ``-usbdevice DEV'' argument is now a synonym for setting
--        } else if (bs->filename[0]) {
+diff --git a/qemu-options.hx b/qemu-options.hx
--            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
+index XXXXXXX..XXXXXXX 100644
--        } else {
+--- a/qemu-options.hx
--            error_setg_errno(errp, -ret, "Could not open image");
++++ b/qemu-options.hx
--        }
+@@ -XXX,XX +XXX,XX @@ ETEXI
--        goto free_and_fail;
+ DEF("drive", HAS_ARG, QEMU_OPTION_drive,
--    }
+     "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
-+    node_name = qemu_opt_get(opts, "node-name");
+     "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
+-    "       [,snapshot=on|off][,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
--    ret = refresh_total_sectors(bs, bs->total_sectors);
++    "       [,snapshot=on|off][,serial=s][,rerror=ignore|stop|report]\n"
-+    assert(!drv->bdrv_file_open || file == NULL);
+     "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
-+    ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
+     "       [,readonly=on|off][,copy-on-read=on|off]\n"
-     if (ret < 0) {
+     "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
--        error_setg_errno(errp, -ret, "Could not refresh total sector count");
+@@ -XXX,XX +XXX,XX @@ an untrusted format header.
--        goto free_and_fail;
+ This option specifies the serial number to assign to the device. This
--    }
+ parameter is deprecated, use the corresponding parameter of @code{-device}
--
+ instead.
--    bdrv_refresh_limits(bs, &local_err);
+-@item addr=@var{addr}
--    if (local_err) {
+-Specify the controller's PCI address (if=virtio only). This parameter is
--        error_propagate(errp, local_err);
+-deprecated, use the corresponding parameter of @code{-device} instead.
--        ret = -EINVAL;
+ @item werror=@var{action},rerror=@var{action}
--        goto free_and_fail;
+ Specify which @var{action} to take on write and read errors. Valid actions are:
-+        goto fail_opts;
+ "ignore" (ignore the error and try to continue), "stop" (pause QEMU),
      }
 -    assert(bdrv_opt_mem_align(bs) != 0);
 -    assert(bdrv_min_mem_align(bs) != 0);
 -    assert(is_power_of_2(bs->bl.request_alignment));
 -
      qemu_opts_del(opts);
      return 0;
 -free_and_fail:
 -    g_free(bs->opaque);
 -    bs->opaque = NULL;
 -    bs->drv = NULL;
  fail_opts:
      qemu_opts_del(opts);
      return ret;
 --
-.8.3.1
+.13.6

-New patch
+[Qemu-devel] [PULL 25/26] block: Remove deprecated -drive option serial
+The -drive option serial was deprecated in QEMU 2.10. It's time to
 remove it.
 Tests need to be updated to set the serial number with -global instead
 of using the -drive option.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 ---
  include/hw/block/block.h  |  1 -
  include/sysemu/blockdev.h |  1 -
  block/block-backend.c     |  1 -
  blockdev.c                | 10 ----------
  hw/block/block.c          | 13 -------------
  hw/block/nvme.c           |  1 -
  hw/block/virtio-blk.c     |  1 -
  hw/ide/qdev.c             |  1 -
  hw/scsi/scsi-disk.c       |  1 -
  hw/usb/dev-storage.c      |  1 -
  tests/ahci-test.c         |  6 +++---
  tests/ide-test.c          |  8 ++++----
  qemu-doc.texi             |  5 -----
  qemu-options.hx           |  6 +-----
 files changed, 8 insertions(+), 48 deletions(-)
 diff --git a/include/hw/block/block.h b/include/hw/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/hw/block/block.h
 +++ b/include/hw/block/block.h
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
  /* Configuration helpers */
 -void blkconf_serial(BlockConf *conf, char **serial);
  bool blkconf_geometry(BlockConf *conf, int *trans,
                        unsigned cyls_max, unsigned heads_max, unsigned secs_max,
                        Error **errp);
 diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/blockdev.h
 +++ b/include/sysemu/blockdev.h
@@ -XXX,XX +XXX,XX @@ struct DriveInfo {
      bool is_default;            /* Added by default_drive() ?  */
      int media_cd;
      QemuOpts *opts;
 -    char *serial;
      QTAILQ_ENTRY(DriveInfo) next;
  };
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static void drive_info_del(DriveInfo *dinfo)
          return;
      }
      qemu_opts_del(dinfo->opts);
 -    g_free(dinfo->serial);
      g_free(dinfo);
  }
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
              .type = QEMU_OPT_STRING,
              .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
          },{
 -            .name = "serial",
 -            .type = QEMU_OPT_STRING,
 -            .help = "disk serial number",
 -        },{
              .name = "file",
              .type = QEMU_OPT_STRING,
              .help = "file name",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
      const char *werror, *rerror;
      bool read_only = false;
      bool copy_on_read;
 -    const char *serial;
      const char *filename;
      Error *local_err = NULL;
      int i;
      const char *deprecated[] = {
 -        "serial"
      };
      /* Change legacy command line options into QMP ones */
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
          goto fail;
      }
 -    /* Serial number */
 -    serial = qemu_opt_get(legacy_opts, "serial");
 -
      /* no id supplied -> create one */
      if (qemu_opts_id(all_opts) == NULL) {
          char *new_id;
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
      dinfo->type = type;
      dinfo->bus = bus_id;
      dinfo->unit = unit_id;
 -    dinfo->serial = g_strdup(serial);
      blk_set_legacy_dinfo(blk, dinfo);
 diff --git a/hw/block/block.c b/hw/block/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/block.c
 +++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qapi-types-block.h"
  #include "qemu/error-report.h"
 -void blkconf_serial(BlockConf *conf, char **serial)
 -{
 -    DriveInfo *dinfo;
 -
 -    if (!*serial) {
 -        /* try to fall back to value set with legacy -drive serial=... */
 -        dinfo = blk_legacy_dinfo(conf->blk);
 -        if (dinfo) {
 -            *serial = g_strdup(dinfo->serial);
 -        }
 -    }
 -}
 -
  void blkconf_blocksizes(BlockConf *conf)
  {
      BlockBackend *blk = conf->blk;
 diff --git a/hw/block/nvme.c b/hw/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/nvme.c
 +++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
          return;
      }
 -    blkconf_serial(&n->conf, &n->serial);
      if (!n->serial) {
          error_setg(errp, "serial property not set");
          return;
 diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/virtio-blk.c
 +++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
          return;
      }
 -    blkconf_serial(&conf->conf, &conf->serial);
      if (!blkconf_apply_backend_options(&conf->conf,
                                         blk_is_read_only(conf->conf.blk), true,
                                         errp)) {
 diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/ide/qdev.c
 +++ b/hw/ide/qdev.c
@@ -XXX,XX +XXX,XX @@ static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp)
          return;
      }
 -    blkconf_serial(&dev->conf, &dev->serial);
      if (kind != IDE_CD) {
          if (!blkconf_geometry(&dev->conf, &dev->chs_trans, 65535, 16, 255,
                                errp)) {
 diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/scsi-disk.c
 +++ b/hw/scsi/scsi-disk.c
@@ -XXX,XX +XXX,XX @@ static void scsi_realize(SCSIDevice *dev, Error **errp)
          return;
      }
 -    blkconf_serial(&s->qdev.conf, &s->serial);
      blkconf_blocksizes(&s->qdev.conf);
      if (s->qdev.conf.logical_block_size >
 diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/usb/dev-storage.c
 +++ b/hw/usb/dev-storage.c
@@ -XXX,XX +XXX,XX @@ static void usb_msd_storage_realize(USBDevice *dev, Error **errp)
          return;
      }
 -    blkconf_serial(&s->conf, &dev->serial);
      blkconf_blocksizes(&s->conf);
      if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true,
                                         errp)) {
 diff --git a/tests/ahci-test.c b/tests/ahci-test.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/ahci-test.c
 +++ b/tests/ahci-test.c
@@ -XXX,XX +XXX,XX @@ static AHCIQState *ahci_boot(const char *cli, ...)
          s = ahci_vboot(cli, ap);
          va_end(ap);
      } else {
 -        cli = "-drive if=none,id=drive0,file=%s,cache=writeback,serial=%s"
 -            ",format=%s"
 +        cli = "-drive if=none,id=drive0,file=%s,cache=writeback,format=%s"
              " -M q35 "
              "-device ide-hd,drive=drive0 "
 +            "-global ide-hd.serial=%s "
              "-global ide-hd.ver=%s";
 -        s = ahci_boot(cli, tmp_path, "testdisk", imgfmt, "version");
 +        s = ahci_boot(cli, tmp_path, imgfmt, "testdisk", "version");
      }
      return s;
 diff --git a/tests/ide-test.c b/tests/ide-test.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/ide-test.c
 +++ b/tests/ide-test.c
@@ -XXX,XX +XXX,XX @@ static void test_bmdma_no_busmaster(void)
  static void test_bmdma_setup(void)
  {
      ide_test_start(
 -        "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
 -        "-global ide-hd.ver=%s",
 +        "-drive file=%s,if=ide,cache=writeback,format=raw "
 +        "-global ide-hd.serial=%s -global ide-hd.ver=%s",
          tmp_path, "testdisk", "version");
      qtest_irq_intercept_in(global_qtest, "ioapic");
  }
@@ -XXX,XX +XXX,XX @@ static void test_identify(void)
      int ret;
      ide_test_start(
 -        "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
 -        "-global ide-hd.ver=%s",
 +        "-drive file=%s,if=ide,cache=writeback,format=raw "
 +        "-global ide-hd.serial=%s -global ide-hd.ver=%s",
          tmp_path, "testdisk", "version");
      dev = get_pci_device(&bmdma_bar, &ide_bar);
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-doc.texi
 +++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ with ``-device ...,netdev=x''), or ``-nic user,smb=/some/dir''
  (for embedded NICs). The new syntax allows different settings to be
  provided per NIC.
 -@subsection -drive serial=... (since 2.10.0)
 -
 -The drive serial argument is replaced by the the serial argument
 -that can be specified with the ``-device'' parameter.
 -
  @subsection -usbdevice (since 2.10.0)
  The ``-usbdevice DEV'' argument is now a synonym for setting
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
  DEF("drive", HAS_ARG, QEMU_OPTION_drive,
      "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
      "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
 -    "       [,snapshot=on|off][,serial=s][,rerror=ignore|stop|report]\n"
 +    "       [,snapshot=on|off][,rerror=ignore|stop|report]\n"
      "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
      "       [,readonly=on|off][,copy-on-read=on|off]\n"
      "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
@@ -XXX,XX +XXX,XX @@ The default mode is @option{cache=writeback}.
  Specify which disk @var{format} will be used rather than detecting
  the format.  Can be used to specify format=raw to avoid interpreting
  an untrusted format header.
 -@item serial=@var{serial}
 -This option specifies the serial number to assign to the device. This
 -parameter is deprecated, use the corresponding parameter of @code{-device}
 -instead.
  @item werror=@var{action},rerror=@var{action}
  Specify which @var{action} to take on write and read errors. Valid actions are:
  "ignore" (ignore the error and try to continue), "stop" (pause QEMU),
 --
 .13.6

-[Qemu-devel] [PULL 09/19] blockdev: Use BlockBackend to resize in qmp_block_resize()
+[Qemu-devel] [PULL 26/26] block: Remove dead deprecation warning code
-In order to be able to do permission checking and to keep working with
+We removed all options from the 'deprecated' array, so the code is dead
-the BdrvChild based bdrv_truncate() that this involves, we need to
+and can be removed as well.
 create a temporary BlockBackend to resize the image.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
 ---
- blockdev.c | 7 ++++++-
+ blockdev.c | 12 ------------
-file changed, 6 insertions(+), 1 deletion(-)
+file changed, 12 deletions(-)
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-                       int64_t size, Error **errp)
+     const char *filename;
  {
      Error *local_err = NULL;
-+    BlockBackend *blk = NULL;
+     int i;
-     BlockDriverState *bs;
+-    const char *deprecated[] = {
-     AioContext *aio_context;
+-    };
-     int ret;
-@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
+     /* Change legacy command line options into QMP ones */
-         goto out;
+     static const struct {
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
          goto fail;
      }
-+    blk = blk_new();
+-    /* Other deprecated options */
-+    blk_insert_bs(blk, bs);
+-    if (!qtest_enabled()) {
-+
+-        for (i = 0; i < ARRAY_SIZE(deprecated); i++) {
-     /* complete all in-flight operations before resizing the device */
+-            if (qemu_opt_get(legacy_opts, deprecated[i]) != NULL) {
-     bdrv_drain_all();
+-                error_report("'%s' is deprecated, please use the corresponding "
+-                             "option of '-device' instead", deprecated[i]);
--    ret = bdrv_truncate(bs, size);
+-            }
-+    ret = blk_truncate(blk, size);
+-        }
-     switch (ret) {
+-    }
-     case 0:
+-
-         break;
+     /* Media type */
-@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
+     value = qemu_opt_get(legacy_opts, "media");
-     }
+     if (value) {
  out:
 +    blk_unref(blk);
      aio_context_release(aio_context);
  }
 --
-.8.3.1
+.13.6

The following changes since commit 63f495beb4007de5444614125fd6fd178ca6e2b1:

Merge remote-tracking branch 'remotes/kraxel/tags/pull-cve-2017-2620-20170224-1' into staging (2017-02-24 13:55:26 +0000)

are available in the git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to d185cf0ec64cd183218ca7e0810d9130c96ebebc:

tests: Use opened block node for block job tests (2017-02-24 16:09:23 +0100)

----------------------------------------------------------------
Block layer patches

----------------------------------------------------------------
Jeff Cody (3):
      qemu-iotests: Test 137 only supports 'file' protocol
      qemu-iotests: add ability to exclude certain protocols from tests
      qemu-iotests: redirect nbd server stdout to /dev/null

John Snow (1):
      iotests: Fix another race in 030

Kevin Wolf (11):
      blockdev: Use BlockBackend to resize in qmp_block_resize()
      qcow2: Use BB for resizing in qcow2_amend_options()
      mirror: Resize active commit base in mirror_run()
      block: Pass BdrvChild to bdrv_truncate()
      block: Attach bs->file only during .bdrv_open()
      block: Factor out bdrv_open_child_bs()
      block: Use BlockBackend for image probing
      block: Factor out bdrv_open_driver()
      block: Add bdrv_new_open_driver()
      vvfat: Use opened node as backing file
      tests: Use opened block node for block job tests

Nir Soffer (4):
      qemu-img: Do not truncate before preallocation
      qemu-img: Add tests for raw image preallocation
      qemu-img: Truncate before full preallocation
      qemu-img: Improve documentation for PREALLOC_MODE_FALLOC

From: Jeff Cody <jcody@redhat.com>

Add the ability for shell script tests to exclude specific
protocols.  This is useful to allow all protocols except ones known to
not support a feature used in the test (e.g. .bdrv_create).

Signed-off-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/common.rc | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _supported_proto()
     _notrun "not suitable for this image protocol: $IMGPROTO"
 }
 
+# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
+#
+_unsupported_proto()
+{
+    for f; do
+        if [ "$f" = "$IMGPROTO" ]; then
+            _notrun "not suitable for this image protocol: $IMGPROTO"
+            return
+        fi
+    done
+}
+
 # tests whether the host OS is one of the supported OSes for a test
 #
 _supported_os()
-- 
1.8.3.1

From: Jeff Cody <jcody@redhat.com>

Some iotests (e.g. 174) try to filter the output of _make_test_image by
piping the stdout.  Pipe the server stdout to /dev/null, so that filter
pipe does not need to wait until process completion.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/common.rc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _make_test_img()
 
     # Start an NBD server on the image file, which is what we'll be talking to
     if [ $IMGPROTO = "nbd" ]; then
-        eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE &"
+        eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
     fi
 }
-- 
1.8.3.1

From: Nir Soffer <nirsof@gmail.com>

When using file system that does not support fallocate() (e.g. NFS <
4.2), truncating the file only when preallocation=OFF speeds up creating
raw file.

Here is example run, tested on Fedora 24 machine, creating raw file on
NFS version 3 server.

$ time ./qemu-img-master create -f raw -o preallocation=falloc mnt/test 1g
Formatting 'mnt/test', fmt=raw size=1073741824 preallocation=falloc

real	0m21.185s
user	0m0.022s
sys	0m0.574s

$ time ./qemu-img-fix create -f raw -o preallocation=falloc mnt/test 1g
Formatting 'mnt/test', fmt=raw size=1073741824 preallocation=falloc

real	0m11.601s
user	0m0.016s
sys	0m0.525s

$ time dd if=/dev/zero of=mnt/test bs=1M count=1024 oflag=direct
1024+0 records in
1024+0 records out
1073741824 bytes (1.1 GB, 1.0 GiB) copied, 15.6627 s, 68.6 MB/s

real	0m16.104s
user	0m0.009s
sys	0m0.220s

Running with strace we can see that without this change we do one
pread() and one pwrite() for each block. With this change, we do only
one pwrite() per block.

$ strace ./qemu-img-master create -f raw -o preallocation=falloc mnt/test 8192
...
pread64(9, "\0", 1, 4095)               = 1
pwrite64(9, "\0", 1, 4095)              = 1
pread64(9, "\0", 1, 8191)               = 1
pwrite64(9, "\0", 1, 8191)              = 1

$ strace ./qemu-img-fix create -f raw -o preallocation=falloc mnt/test 8192
...
pwrite64(9, "\0", 1, 4095)              = 1
pwrite64(9, "\0", 1, 8191)              = 1

This happens because posix_fallocate is checking if each block is
allocated before writing a byte to the block, and when truncating the
file before preallocation, all blocks are unallocated.

Signed-off-by: Nir Soffer <nirsof@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
 #endif
     }
 
-    if (ftruncate(fd, total_size) != 0) {
-        result = -errno;
-        error_setg_errno(errp, -result, "Could not resize file");
-        goto out_close;
-    }
-
     switch (prealloc) {
 #ifdef CONFIG_POSIX_FALLOCATE
     case PREALLOC_MODE_FALLOC:
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
         break;
     }
     case PREALLOC_MODE_OFF:
+        if (ftruncate(fd, total_size) != 0) {
+            result = -errno;
+            error_setg_errno(errp, -result, "Could not resize file");
+        }
         break;
     default:
         result = -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
         break;
     }
 
-out_close:
     if (qemu_close(fd) != 0 && result == 0) {
         result = -errno;
         error_setg_errno(errp, -result, "Could not close the new file");
-- 
1.8.3.1

From: Nir Soffer <nirsof@gmail.com>

Add tests for creating raw image with and without the preallocation
option.

Signed-off-by: Nir Soffer <nirsof@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/175     | 61 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/175.out | 18 ++++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 80 insertions(+)
 create mode 100755 tests/qemu-iotests/175
 create mode 100644 tests/qemu-iotests/175.out

diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test creating raw image preallocation mode
+#
+# Copyright (C) 2017 Nir Soffer <nirsof@gmail.com>
+#
+# 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=nirsof@gmail.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+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
+
+_supported_fmt raw
+_supported_proto file
+_supported_os Linux
+
+size=1m
+
+echo
+echo "== creating image with default preallocation =="
+_make_test_img $size | _filter_imgfmt
+stat -c "size=%s, blocks=%b" $TEST_IMG
+
+for mode in off full falloc; do
+    echo
+    echo "== creating image with preallocation $mode =="
+    IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
+    stat -c "size=%s, blocks=%b" $TEST_IMG
+done
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 175
+
+== creating image with default preallocation ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
+size=1048576, blocks=0
+
+== creating image with preallocation off ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
+size=1048576, blocks=0
+
+== creating image with preallocation full ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
+size=1048576, blocks=2048
+
+== creating image with preallocation falloc ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
+size=1048576, blocks=2048
+ *** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 172 auto
 173 rw auto
 174 auto
+175 auto quick
-- 
1.8.3.1

From: Nir Soffer <nirsof@gmail.com>

In a previous commit (qemu-img: Do not truncate before preallocation) we
moved truncate to the PREALLOC_MODE_OFF branch to avoid slowdown in
posix_fallocate().

However this change is not optimal when using PREALLOC_MODE_FULL, since
knowing the final size from the beginning could allow the file system
driver to do less allocations and possibly avoid fragmentation of the
file.

Now we truncate also before doing full preallocation.

Signed-off-by: Nir Soffer <nirsof@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
 #endif
     case PREALLOC_MODE_FULL:
     {
+        /*
+         * Knowing the final size from the beginning could allow the file
+         * system driver to do less allocations and possibly avoid
+         * fragmentation of the file.
+         */
+        if (ftruncate(fd, total_size) != 0) {
+            result = -errno;
+            error_setg_errno(errp, -result, "Could not resize file");
+            goto out_close;
+        }
+
         int64_t num = 0, left = total_size;
         buf = g_malloc0(65536);
 
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
         break;
     }
 
+out_close:
     if (qemu_close(fd) != 0 && result == 0) {
         result = -errno;
         error_setg_errno(errp, -result, "Could not close the new file");
-- 
1.8.3.1

From: Nir Soffer <nirsof@gmail.com>

Now that we are truncating the file in both PREALLOC_MODE_FULL and
PREALLOC_MODE_OFF, not truncating in PREALLOC_MODE_FALLOC looks odd.
Add a comment explaining why we do not truncate in this case.

Signed-off-by: Nir Soffer <nirsof@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_create(const char *filename, QemuOpts *opts, Error **errp)
     switch (prealloc) {
 #ifdef CONFIG_POSIX_FALLOCATE
     case PREALLOC_MODE_FALLOC:
-        /* posix_fallocate() doesn't set errno. */
+        /*
+         * Truncating before posix_fallocate() makes it about twice slower on
+         * file systems that do not support fallocate(), trying to check if a
+         * block is allocated before allocating it, so don't do that here.
+         */
         result = -posix_fallocate(fd, 0, total_size);
         if (result != 0) {
+            /* posix_fallocate() doesn't set errno. */
             error_setg_errno(errp, -result,
                              "Could not preallocate data for the new file");
         }
-- 
1.8.3.1

From: John Snow <jsnow@redhat.com>

We can't rely on a non-paused job to be present and running for us.
Assume that if the job is not present that it completed already.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/030 | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -XXX,XX +XXX,XX @@ class TestEIO(TestErrors):
         while not completed:
             for event in self.vm.get_qmp_events(wait=True):
                 if event['event'] == 'BLOCK_JOB_ERROR':
+                    error = True
                     self.assert_qmp(event, 'data/device', 'drive0')
                     self.assert_qmp(event, 'data/operation', 'read')
                     result = self.vm.qmp('query-block-jobs')
+                    if result == {'return': []}:
+                        # Job finished too quickly
+                        continue
                     self.assert_qmp(result, 'return[0]/paused', False)
-                    error = True
                 elif event['event'] == 'BLOCK_JOB_COMPLETED':
                     self.assertTrue(error, 'job completed unexpectedly')
                     self.assert_qmp(event, 'data/type', 'stream')
-- 
1.8.3.1

In order to be able to do permission checking and to keep working with
the BdrvChild based bdrv_truncate() that this involves, we need to
create a temporary BlockBackend to resize the image.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 blockdev.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
                       int64_t size, Error **errp)
 {
     Error *local_err = NULL;
+    BlockBackend *blk = NULL;
     BlockDriverState *bs;
     AioContext *aio_context;
     int ret;
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
         goto out;
     }
 
+    blk = blk_new();
+    blk_insert_bs(blk, bs);
+
     /* complete all in-flight operations before resizing the device */
     bdrv_drain_all();
 
-    ret = bdrv_truncate(bs, size);
+    ret = blk_truncate(blk, size);
     switch (ret) {
     case 0:
         break;
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
     }
 
 out:
+    blk_unref(blk);
     aio_context_release(aio_context);
 }
 
-- 
1.8.3.1

This is more consistent with the commit block job, and it moves the code
to a place where we already have the necessary BlockBackends to resize
the base image when bdrv_truncate() is changed to require a BdrvChild.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block/mirror.c | 50 ++++++++++++++++++++++----------------------------
 1 file changed, 22 insertions(+), 28 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn mirror_run(void *opaque)
     if (s->bdev_length < 0) {
         ret = s->bdev_length;
         goto immediate_exit;
-    } else if (s->bdev_length == 0) {
+    }
+
+    /* Active commit must resize the base image if its size differs from the
+     * active layer. */
+    if (s->base == blk_bs(s->target)) {
+        int64_t base_length;
+
+        base_length = blk_getlength(s->target);
+        if (base_length < 0) {
+            ret = base_length;
+            goto immediate_exit;
+        }
+
+        if (s->bdev_length > base_length) {
+            ret = blk_truncate(s->target, s->bdev_length);
+            if (ret < 0) {
+                goto immediate_exit;
+            }
+        }
+    }
+
+    if (s->bdev_length == 0) {
         /* Report BLOCK_JOB_READY and wait for complete. */
         block_job_event_ready(&s->common);
         s->synced = true;
@@ -XXX,XX +XXX,XX @@ void commit_active_start(const char *job_id, BlockDriverState *bs,
                          BlockCompletionFunc *cb, void *opaque, Error **errp,
                          bool auto_complete)
 {
-    int64_t length, base_length;
     int orig_base_flags;
-    int ret;
     Error *local_err = NULL;
 
     orig_base_flags = bdrv_get_flags(base);
@@ -XXX,XX +XXX,XX @@ void commit_active_start(const char *job_id, BlockDriverState *bs,
         return;
     }
 
-    length = bdrv_getlength(bs);
-    if (length < 0) {
-        error_setg_errno(errp, -length,
-                         "Unable to determine length of %s", bs->filename);
-        goto error_restore_flags;
-    }
-
-    base_length = bdrv_getlength(base);
-    if (base_length < 0) {
-        error_setg_errno(errp, -base_length,
-                         "Unable to determine length of %s", base->filename);
-        goto error_restore_flags;
-    }
-
-    if (length > base_length) {
-        ret = bdrv_truncate(base, length);
-        if (ret < 0) {
-            error_setg_errno(errp, -ret,
-                            "Top image %s is larger than base image %s, and "
-                             "resize of base image failed",
-                             bs->filename, base->filename);
-            goto error_restore_flags;
-        }
-    }
-
     mirror_start_job(job_id, bs, creation_flags, base, NULL, speed, 0, 0,
                      MIRROR_LEAVE_BACKING_CHAIN,
                      on_error, on_error, true, cb, opaque, &local_err,
-- 
1.8.3.1

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ exit:
 /**
  * Truncate file to 'offset' bytes (needed only for file protocols)
  */
-int bdrv_truncate(BlockDriverState *bs, int64_t offset)
+int bdrv_truncate(BdrvChild *child, int64_t offset)
 {
+    BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     int ret;
     if (!drv)
diff --git a/block/blkdebug.c b/block/blkdebug.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -XXX,XX +XXX,XX @@ static int64_t blkdebug_getlength(BlockDriverState *bs)
 
 static int blkdebug_truncate(BlockDriverState *bs, int64_t offset)
 {
-    return bdrv_truncate(bs->file->bs, offset);
+    return bdrv_truncate(bs->file, offset);
 }
 
 static void blkdebug_refresh_filename(BlockDriverState *bs, QDict *options)
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset)
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk_bs(blk), offset);
+    return bdrv_truncate(blk->root, offset);
 }
 
 static void blk_pdiscard_entry(void *opaque)
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_truncate(BlockDriverState *bs, int64_t offset)
 
     offset += payload_offset;
 
-    return bdrv_truncate(bs->file->bs, offset);
+    return bdrv_truncate(bs->file, offset);
 }
 
 static void block_crypto_close(BlockDriverState *bs)
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
                                      s->data_end << BDRV_SECTOR_BITS,
                                      space << BDRV_SECTOR_BITS, 0);
         } else {
-            ret = bdrv_truncate(bs->file->bs,
+            ret = bdrv_truncate(bs->file,
                                 (s->data_end + space) << BDRV_SECTOR_BITS);
         }
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int parallels_check(BlockDriverState *bs, BdrvCheckResult *res,
                 size - res->image_end_offset);
         res->leaks += count;
         if (fix & BDRV_FIX_LEAKS) {
-            ret = bdrv_truncate(bs->file->bs, res->image_end_offset);
+            ret = bdrv_truncate(bs->file, res->image_end_offset);
             if (ret < 0) {
                 res->check_errors++;
                 return ret;
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail_options;
     }
     if (!bdrv_has_zero_init(bs->file->bs) ||
-            bdrv_truncate(bs->file->bs, bdrv_getlength(bs->file->bs)) != 0) {
+            bdrv_truncate(bs->file, bdrv_getlength(bs->file->bs)) != 0) {
         s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
     }
 
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
     }
 
     if (bs->open_flags & BDRV_O_RDWR) {
-        bdrv_truncate(bs->file->bs, s->data_end << BDRV_SECTOR_BITS);
+        bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS);
     }
 
     g_free(s->bat_dirty_bmap);
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
                 /* round to cluster size */
                 cluster_offset = (cluster_offset + s->cluster_size - 1) &
                     ~(s->cluster_size - 1);
-                bdrv_truncate(bs->file->bs, cluster_offset + s->cluster_size);
+                bdrv_truncate(bs->file, cluster_offset + s->cluster_size);
                 /* if encrypted, we must initialize the cluster
                    content which won't be written */
                 if (bs->encrypted &&
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
     if (bdrv_pwrite_sync(bs->file, s->l1_table_offset, s->l1_table,
             l1_length) < 0)
         return -1;
-    ret = bdrv_truncate(bs->file->bs, s->l1_table_offset + l1_length);
+    ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length);
     if (ret < 0)
         return ret;
 
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                     goto resize_fail;
                 }
 
-                ret = bdrv_truncate(bs->file->bs, offset + s->cluster_size);
+                ret = bdrv_truncate(bs->file, offset + s->cluster_size);
                 if (ret < 0) {
                     goto resize_fail;
                 }
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
         /* align end of file to a sector boundary to ease reading with
            sector based I/Os */
         cluster_offset = bdrv_getlength(bs->file->bs);
-        return bdrv_truncate(bs->file->bs, cluster_offset);
+        return bdrv_truncate(bs->file, cluster_offset);
     }
 
     buf = qemu_blockalign(bs, s->cluster_size);
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
         goto fail;
     }
 
-    ret = bdrv_truncate(bs->file->bs, (3 + l1_clusters) * s->cluster_size);
+    ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size);
     if (ret < 0) {
         goto fail;
     }
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int raw_truncate(BlockDriverState *bs, int64_t offset)
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_truncate(bs->file->bs, offset);
+    return bdrv_truncate(bs->file, offset);
 }
 
 static int raw_media_changed(BlockDriverState *bs)
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
             if (new_file_size % (1024*1024)) {
                 /* round up to nearest 1MB boundary */
                 new_file_size = ((new_file_size >> 20) + 1) << 20;
-                bdrv_truncate(bs->file->bs, new_file_size);
+                bdrv_truncate(bs->file, new_file_size);
             }
         }
         qemu_vfree(desc_entries);
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
     /* per the spec, the address for a block is in units of 1MB */
     *new_offset = ROUND_UP(*new_offset, 1024 * 1024);
 
-    return bdrv_truncate(bs->file->bs, *new_offset + s->block_size);
+    return bdrv_truncate(bs->file, *new_offset + s->block_size);
 }
 
 /*
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 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
     const char *backing_file);
 int bdrv_get_backing_file_depth(BlockDriverState *bs);
 void bdrv_refresh_filename(BlockDriverState *bs);
-int bdrv_truncate(BlockDriverState *bs, int64_t offset);
+int bdrv_truncate(BdrvChild *child, int64_t offset);
 int64_t bdrv_nb_sectors(BlockDriverState *bs);
 int64_t bdrv_getlength(BlockDriverState *bs);
 int64_t bdrv_get_allocated_file_size(BlockDriverState *bs);
-- 
1.8.3.1

The way that attaching bs->file worked was a bit unusual in that it was
the only child that would be attached to a node which is not opened yet.
Because of this, the block layer couldn't know yet which permissions the
driver would eventually need.

This patch moves the point where bs->file is attached to the beginning
of the individual .bdrv_open() implementations, so drivers already know
what they are going to do with the child. This is also more consistent
with how driver-specific children work.

For a moment, bdrv_open() gets its own BdrvChild to perform image
probing, but instead of directly assigning this BdrvChild to the BDS, it
becomes a temporary one and the node name is passed as an option to the
drivers, so that they can simply use bdrv_open_child() to create another
reference for their own use.

This duplicated child for (the not opened yet) bs is not the final
state, a follow-up patch will change the image probing code to use a
BlockBackend, which is completely independent of bs.

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
         assert(!drv->bdrv_needs_filename || filename != NULL);
         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
     } else {
-        if (file == NULL) {
-            error_setg(errp, "Can't use '%s' as a block driver for the "
-                       "protocol level", drv->format_name);
-            ret = -EINVAL;
-            goto free_and_fail;
-        }
-        bs->file = file;
         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
     }
 
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
     return 0;
 
 free_and_fail:
-    bs->file = NULL;
     g_free(bs->opaque);
     bs->opaque = NULL;
     bs->drv = NULL;
@@ -XXX,XX +XXX,XX @@ void bdrv_unref_child(BlockDriverState *parent, BdrvChild *child)
     }
 
     if (child->bs->inherits_from == parent) {
-        child->bs->inherits_from = NULL;
+        BdrvChild *c;
+
+        /* Remove inherits_from only when the last reference between parent and
+         * child->bs goes away. */
+        QLIST_FOREACH(c, &parent->children, next) {
+            if (c != child && c->bs == child->bs) {
+                break;
+            }
+        }
+        if (c == NULL) {
+            child->bs->inherits_from = NULL;
+        }
     }
 
     bdrv_root_unref_child(child);
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
         qdict_del(options, "backing");
     }
 
-    /* Open image file without format layer */
+    /* Open image file without format layer. This BdrvChild is only used for
+     * probing, the block drivers will do their own bdrv_open_child() for the
+     * same BDS, which is why we put the node name back into options. */
     if ((flags & BDRV_O_PROTOCOL) == 0) {
+        /* FIXME Shouldn't attach a child to a node that isn't opened yet. */
         file = bdrv_open_child(filename, options, "file", bs,
                                &child_file, true, &local_err);
         if (local_err) {
             goto fail;
         }
+        if (file != NULL) {
+            qdict_put(options, "file",
+                      qstring_from_str(bdrv_get_node_name(file->bs)));
+        }
     }
 
     /* Image format probing */
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
         goto fail;
     }
 
-    if (file && (bs->file != file)) {
+    if (file) {
         bdrv_unref_child(bs, file);
         file = NULL;
     }
@@ -XXX,XX +XXX,XX @@ fail:
     if (file != NULL) {
         bdrv_unref_child(bs, file);
     }
+    if (bs->file != NULL) {
+        bdrv_unref_child(bs, bs->file);
+    }
     QDECREF(snapshot_options);
     QDECREF(bs->explicit_options);
     QDECREF(bs->options);
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
     struct bochs_header bochs;
     int ret;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     bs->read_only = true; /* no write support yet */
 
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
     uint32_t offsets_size, max_compressed_block_size = 1, i;
     int ret;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     bs->read_only = true;
 
     /* read header */
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
     QCryptoBlockOpenOptions *open_opts = NULL;
     unsigned int cflags = 0;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     opts = qemu_opts_create(opts_spec, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, options, &local_err);
     if (local_err) {
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
     int64_t offset;
     int ret;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     block_module_load_one("dmg-bz2");
     bs->read_only = true;
 
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
     Error *local_err = NULL;
     char *buf;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     ret = bdrv_pread(bs->file, 0, &ph, sizeof(ph));
     if (ret < 0) {
         goto fail;
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int qcow_open(BlockDriverState *bs, QDict *options, int flags,
     QCowHeader header;
     Error *local_err = NULL;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     ret = bdrv_pread(bs->file, 0, &header, sizeof(header));
     if (ret < 0) {
         goto fail;
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_update_options(BlockDriverState *bs, QDict *options,
     return ret;
 }
 
-static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
-                      Error **errp)
+static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+                         Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     unsigned int len, i;
@@ -XXX,XX +XXX,XX @@ static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
     return ret;
 }
 
+static int qcow2_open(BlockDriverState *bs, QDict *options, int flags,
+                      Error **errp)
+{
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
+    return qcow2_do_open(bs, options, flags, errp);
+}
+
 static void qcow2_refresh_limits(BlockDriverState *bs, Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void qcow2_invalidate_cache(BlockDriverState *bs, Error **errp)
     options = qdict_clone_shallow(bs->options);
 
     flags &= ~BDRV_O_INACTIVE;
-    ret = qcow2_open(bs, options, flags, &local_err);
+    ret = qcow2_do_open(bs, options, flags, &local_err);
     QDECREF(options);
     if (local_err) {
         error_propagate(errp, local_err);
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 void bdrv_qed_drain(BlockDriverState *bs)
     }
 }
 
-static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
-                         Error **errp)
+static int bdrv_qed_do_open(BlockDriverState *bs, QDict *options, int flags,
+                            Error **errp)
 {
     BDRVQEDState *s = bs->opaque;
     QEDHeader le_header;
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
+static int bdrv_qed_open(BlockDriverState *bs, QDict *options, int flags,
+                         Error **errp)
+{
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
+    return bdrv_qed_do_open(bs, options, flags, errp);
+}
+
 static void bdrv_qed_refresh_limits(BlockDriverState *bs, Error **errp)
 {
     BDRVQEDState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_invalidate_cache(BlockDriverState *bs, Error **errp)
     bdrv_qed_close(bs);
 
     memset(s, 0, sizeof(BDRVQEDState));
-    ret = bdrv_qed_open(bs, NULL, bs->open_flags, &local_err);
+    ret = bdrv_qed_do_open(bs, NULL, bs->open_flags, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
         error_prepend(errp, "Could not reopen qed layer: ");
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
     BDRVRawState *s = bs->opaque;
     int ret;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     bs->sg = bs->file->bs->sg;
     bs->supported_write_flags = BDRV_REQ_FUA &
         bs->file->bs->supported_write_flags;
diff --git a/block/replication.c b/block/replication.c
index XXXXXXX..XXXXXXX 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -XXX,XX +XXX,XX @@ static int replication_open(BlockDriverState *bs, QDict *options,
     const char *mode;
     const char *top_id;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     ret = -EINVAL;
     opts = qemu_opts_create(&replication_runtime_opts, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, options, &local_err);
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int vdi_open(BlockDriverState *bs, QDict *options, int flags,
     int ret;
     Error *local_err = NULL;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     logout("\n");
 
     ret = bdrv_read(bs->file, 0, (uint8_t *)&header, 1);
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_open(BlockDriverState *bs, QDict *options, int flags,
     uint64_t signature;
     Error *local_err = NULL;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     s->bat = NULL;
     s->first_visible_write = true;
 
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_open(BlockDriverState *bs, QDict *options, int flags,
     uint32_t magic;
     Error *local_err = NULL;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     buf = vmdk_read_desc(bs->file, 0, errp);
     if (!buf) {
         return -EINVAL;
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
     int disk_type = VHD_DYNAMIC;
     int ret;
 
+    bs->file = bdrv_open_child(NULL, options, "file", bs, &child_file,
+                               false, errp);
+    if (!bs->file) {
+        return -EINVAL;
+    }
+
     opts = qemu_opts_create(&vpc_runtime_opts, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, options, &local_err);
     if (local_err) {
diff --git a/tests/qemu-iotests/051.out b/tests/qemu-iotests/051.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/051.out
+++ b/tests/qemu-iotests/051.out
@@ -XXX,XX +XXX,XX @@ Testing: -drive driver=nbd
 QEMU_PROG: -drive driver=nbd: NBD server address missing
 
 Testing: -drive driver=raw
-QEMU_PROG: -drive driver=raw: Can't use 'raw' as a block driver for the protocol level
+QEMU_PROG: -drive driver=raw: A block device must be specified for "file"
 
 Testing: -drive file.driver=file
 QEMU_PROG: -drive file.driver=file: The 'file' block driver requires a file name
@@ -XXX,XX +XXX,XX @@ Testing: -drive file.driver=nbd
 QEMU_PROG: -drive file.driver=nbd: NBD server address missing
 
 Testing: -drive file.driver=raw
-QEMU_PROG: -drive file.driver=raw: Can't use 'raw' as a block driver for the protocol level
+QEMU_PROG: -drive file.driver=raw: A block device must be specified for "file"
 
 Testing: -drive foo=bar
 QEMU_PROG: -drive foo=bar: Must specify either driver or file
diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/051.pc.out
+++ b/tests/qemu-iotests/051.pc.out
@@ -XXX,XX +XXX,XX @@ Testing: -drive driver=nbd
 QEMU_PROG: -drive driver=nbd: NBD server address missing
 
 Testing: -drive driver=raw
-QEMU_PROG: -drive driver=raw: Can't use 'raw' as a block driver for the protocol level
+QEMU_PROG: -drive driver=raw: A block device must be specified for "file"
 
 Testing: -drive file.driver=file
 QEMU_PROG: -drive file.driver=file: The 'file' block driver requires a file name
@@ -XXX,XX +XXX,XX @@ Testing: -drive file.driver=nbd
 QEMU_PROG: -drive file.driver=nbd: NBD server address missing
 
 Testing: -drive file.driver=raw
-QEMU_PROG: -drive file.driver=raw: Can't use 'raw' as a block driver for the protocol level
+QEMU_PROG: -drive file.driver=raw: A block device must be specified for "file"
 
 Testing: -drive foo=bar
 QEMU_PROG: -drive foo=bar: Must specify either driver or file
-- 
1.8.3.1

This is the part of bdrv_open_child() that opens a BDS with option
inheritance, but doesn't attach it as a child to the parent yet.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 61 +++++++++++++++++++++++++++++++++++++------------------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ free_exit:
     return ret;
 }
 
-/*
- * Opens a disk image whose options are given as BlockdevRef in another block
- * device's options.
- *
- * If allow_none is true, no image will be opened if filename is false and no
- * BlockdevRef is given. NULL will be returned, but errp remains unset.
- *
- * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
- * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
- * itself, all options starting with "${bdref_key}." are considered part of the
- * BlockdevRef.
- *
- * The BlockdevRef will be removed from the options QDict.
- */
-BdrvChild *bdrv_open_child(const char *filename,
-                           QDict *options, const char *bdref_key,
-                           BlockDriverState* parent,
-                           const BdrvChildRole *child_role,
-                           bool allow_none, Error **errp)
+static BlockDriverState *
+bdrv_open_child_bs(const char *filename, QDict *options, const char *bdref_key,
+                   BlockDriverState *parent, const BdrvChildRole *child_role,
+                   bool allow_none, Error **errp)
 {
-    BdrvChild *c = NULL;
-    BlockDriverState *bs;
+    BlockDriverState *bs = NULL;
     QDict *image_options;
     char *bdref_key_dot;
     const char *reference;
@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
         goto done;
     }
 
-    c = bdrv_attach_child(parent, bs, bdref_key, child_role);
-
 done:
     qdict_del(options, bdref_key);
-    return c;
+    return bs;
+}
+
+/*
+ * Opens a disk image whose options are given as BlockdevRef in another block
+ * device's options.
+ *
+ * If allow_none is true, no image will be opened if filename is false and no
+ * BlockdevRef is given. NULL will be returned, but errp remains unset.
+ *
+ * bdrev_key specifies the key for the image's BlockdevRef in the options QDict.
+ * That QDict has to be flattened; therefore, if the BlockdevRef is a QDict
+ * itself, all options starting with "${bdref_key}." are considered part of the
+ * BlockdevRef.
+ *
+ * The BlockdevRef will be removed from the options QDict.
+ */
+BdrvChild *bdrv_open_child(const char *filename,
+                           QDict *options, const char *bdref_key,
+                           BlockDriverState *parent,
+                           const BdrvChildRole *child_role,
+                           bool allow_none, Error **errp)
+{
+    BlockDriverState *bs;
+
+    bs = bdrv_open_child_bs(filename, options, bdref_key, parent, child_role,
+                            allow_none, errp);
+    if (bs == NULL) {
+        return NULL;
+    }
+
+    return bdrv_attach_child(parent, bs, bdref_key, child_role);
 }
 
 static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
-- 
1.8.3.1

This fixes the use of a parent-less BdrvChild in bdrv_open_inherit() by
converting it into a BlockBackend. Which is exactly what it should be,
image probing is an external, standalone user of a node. The requests
can't be considered to originate from the format driver node because
that one isn't even opened yet.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 36 +++++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 17 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
     return drv;
 }
 
-static int find_image_format(BdrvChild *file, const char *filename,
+static int find_image_format(BlockBackend *file, const char *filename,
                              BlockDriver **pdrv, Error **errp)
 {
-    BlockDriverState *bs = file->bs;
     BlockDriver *drv;
     uint8_t buf[BLOCK_PROBE_BUF_SIZE];
     int ret = 0;
 
     /* Return the raw BlockDriver * to scsi-generic devices or empty drives */
-    if (bdrv_is_sg(bs) || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
+    if (blk_is_sg(file) || !blk_is_inserted(file) || blk_getlength(file) == 0) {
         *pdrv = &bdrv_raw;
         return ret;
     }
 
-    ret = bdrv_pread(file, 0, buf, sizeof(buf));
+    ret = blk_pread(file, 0, buf, sizeof(buf));
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not read image for determining its "
                          "format");
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
  *
  * Removes all processed options from *options.
  */
-static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
+static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
                             QDict *options, Error **errp)
 {
     int ret, open_flags;
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BdrvChild *file,
     assert(drv != NULL);
 
     if (file != NULL) {
-        filename = file->bs->filename;
+        filename = blk_bs(file)->filename;
     } else {
         filename = qdict_get_try_str(options, "filename");
     }
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
                                            Error **errp)
 {
     int ret;
-    BdrvChild *file = NULL;
+    BlockBackend *file = NULL;
     BlockDriverState *bs;
     BlockDriver *drv = NULL;
     const char *drvname;
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
         qdict_del(options, "backing");
     }
 
-    /* Open image file without format layer. This BdrvChild is only used for
+    /* Open image file without format layer. This BlockBackend is only used for
      * probing, the block drivers will do their own bdrv_open_child() for the
      * same BDS, which is why we put the node name back into options. */
     if ((flags & BDRV_O_PROTOCOL) == 0) {
-        /* FIXME Shouldn't attach a child to a node that isn't opened yet. */
-        file = bdrv_open_child(filename, options, "file", bs,
-                               &child_file, true, &local_err);
+        BlockDriverState *file_bs;
+
+        file_bs = bdrv_open_child_bs(filename, options, "file", bs,
+                                     &child_file, true, &local_err);
         if (local_err) {
             goto fail;
         }
-        if (file != NULL) {
+        if (file_bs != NULL) {
+            file = blk_new();
+            blk_insert_bs(file, file_bs);
+            bdrv_unref(file_bs);
+
             qdict_put(options, "file",
-                      qstring_from_str(bdrv_get_node_name(file->bs)));
+                      qstring_from_str(bdrv_get_node_name(file_bs)));
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
     }
 
     if (file) {
-        bdrv_unref_child(bs, file);
+        blk_unref(file);
         file = NULL;
     }
 
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,
     return bs;
 
 fail:
-    if (file != NULL) {
-        bdrv_unref_child(bs, file);
-    }
+    blk_unref(file);
     if (bs->file != NULL) {
         bdrv_unref_child(bs, bs->file);
     }
-- 
1.8.3.1

This is a function that doesn't do any option parsing, but just does
some basic BlockDriverState setup and calls the .bdrv_open() function of
the block driver.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 112 +++++++++++++++++++++++++++++++++++++---------------------------
 1 file changed, 65 insertions(+), 47 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ out:
     g_free(gen_node_name);
 }
 
+static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
+                            const char *node_name, QDict *options,
+                            int open_flags, Error **errp)
+{
+    Error *local_err = NULL;
+    int ret;
+
+    bdrv_assign_node_name(bs, node_name, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        return -EINVAL;
+    }
+
+    bs->drv = drv;
+    bs->opaque = g_malloc0(drv->instance_size);
+
+    if (drv->bdrv_file_open) {
+        assert(!drv->bdrv_needs_filename || bs->filename[0]);
+        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
+    } else {
+        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
+    }
+
+    if (ret < 0) {
+        if (local_err) {
+            error_propagate(errp, local_err);
+        } else if (bs->filename[0]) {
+            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
+        } else {
+            error_setg_errno(errp, -ret, "Could not open image");
+        }
+        goto free_and_fail;
+    }
+
+    ret = refresh_total_sectors(bs, bs->total_sectors);
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "Could not refresh total sector count");
+        goto free_and_fail;
+    }
+
+    bdrv_refresh_limits(bs, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        ret = -EINVAL;
+        goto free_and_fail;
+    }
+
+    assert(bdrv_opt_mem_align(bs) != 0);
+    assert(bdrv_min_mem_align(bs) != 0);
+    assert(is_power_of_2(bs->bl.request_alignment));
+
+    return 0;
+
+free_and_fail:
+    /* FIXME Close bs first if already opened*/
+    g_free(bs->opaque);
+    bs->opaque = NULL;
+    bs->drv = NULL;
+    return ret;
+}
+
 QemuOptsList bdrv_runtime_opts = {
     .name = "bdrv_common",
     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
     trace_bdrv_open_common(bs, filename ?: "", bs->open_flags,
                            drv->format_name);
 
-    node_name = qemu_opt_get(opts, "node-name");
-    bdrv_assign_node_name(bs, node_name, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-        goto fail_opts;
-    }
-
     bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
 
     if (use_bdrv_whitelist && !bdrv_is_whitelisted(drv, bs->read_only)) {
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_common(BlockDriverState *bs, BlockBackend *file,
     }
     pstrcpy(bs->exact_filename, sizeof(bs->exact_filename), bs->filename);
 
-    bs->drv = drv;
-    bs->opaque = g_malloc0(drv->instance_size);
-
     /* Open the image, either directly or using a protocol */
     open_flags = bdrv_open_flags(bs, bs->open_flags);
-    if (drv->bdrv_file_open) {
-        assert(file == NULL);
-        assert(!drv->bdrv_needs_filename || filename != NULL);
-        ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
-    } else {
-        ret = drv->bdrv_open(bs, options, open_flags, &local_err);
-    }
-
-    if (ret < 0) {
-        if (local_err) {
-            error_propagate(errp, local_err);
-        } else if (bs->filename[0]) {
-            error_setg_errno(errp, -ret, "Could not open '%s'", bs->filename);
-        } else {
-            error_setg_errno(errp, -ret, "Could not open image");
-        }
-        goto free_and_fail;
-    }
+    node_name = qemu_opt_get(opts, "node-name");
 
-    ret = refresh_total_sectors(bs, bs->total_sectors);
+    assert(!drv->bdrv_file_open || file == NULL);
+    ret = bdrv_open_driver(bs, drv, node_name, options, open_flags, errp);
     if (ret < 0) {
-        error_setg_errno(errp, -ret, "Could not refresh total sector count");
-        goto free_and_fail;
-    }
-
-    bdrv_refresh_limits(bs, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-        goto free_and_fail;
+        goto fail_opts;
     }
 
-    assert(bdrv_opt_mem_align(bs) != 0);
-    assert(bdrv_min_mem_align(bs) != 0);
-    assert(is_power_of_2(bs->bl.request_alignment));
-
     qemu_opts_del(opts);
     return 0;
 
-free_and_fail:
-    g_free(bs->opaque);
-    bs->opaque = NULL;
-    bs->drv = NULL;
 fail_opts:
     qemu_opts_del(opts);
     return ret;
-- 
1.8.3.1

This function allows to create more or less normal BlockDriverStates
even for BlockDrivers that aren't globally registered (e.g. helper
filters for block jobs).

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c               | 30 +++++++++++++++++++++++++++++-
 include/block/block.h |  2 ++
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv,
     }
 
     bs->drv = drv;
+    bs->read_only = !(bs->open_flags & BDRV_O_RDWR);
     bs->opaque = g_malloc0(drv->instance_size);
 
     if (drv->bdrv_file_open) {
         assert(!drv->bdrv_needs_filename || bs->filename[0]);
         ret = drv->bdrv_file_open(bs, options, open_flags, &local_err);
-    } else {
+    } else if (drv->bdrv_open) {
         ret = drv->bdrv_open(bs, options, open_flags, &local_err);
+    } else {
+        ret = 0;
     }
 
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ free_and_fail:
     return ret;
 }
 
+BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
+                                       int flags, Error **errp)
+{
+    BlockDriverState *bs;
+    int ret;
+
+    bs = bdrv_new();
+    bs->open_flags = flags;
+    bs->explicit_options = qdict_new();
+    bs->options = qdict_new();
+    bs->opaque = NULL;
+
+    update_options_from_flags(bs->options, flags);
+
+    ret = bdrv_open_driver(bs, drv, node_name, bs->options, flags, errp);
+    if (ret < 0) {
+        QDECREF(bs->explicit_options);
+        QDECREF(bs->options);
+        bdrv_unref(bs);
+        return NULL;
+    }
+
+    return bs;
+}
+
 QemuOptsList bdrv_runtime_opts = {
     .name = "bdrv_common",
     .head = QTAILQ_HEAD_INITIALIZER(bdrv_runtime_opts.head),
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 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
                            const char *bdref_key, Error **errp);
 BlockDriverState *bdrv_open(const char *filename, const char *reference,
                             QDict *options, int flags, Error **errp);
+BlockDriverState *bdrv_new_open_driver(BlockDriver *drv, const char *node_name,
+                                       int flags, Error **errp);
 BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
                                     BlockDriverState *bs,
                                     QDict *options, int flags);
-- 
1.8.3.1

We should not try to assign a not yet opened node as the backing file,
because as soon as the permission system is added it will fail.  The
just added bdrv_new_open_driver() function is the right tool to open a
file with an internal driver, use it.

In case anyone wonders whether that magic fake backing file to trigger a
special action on 'commit' actually works today: No, not for me. One
reason is that we've been adding a raw format driver on top for several
years now and raw doesn't support commit. Other reasons include that the
backing file isn't writable and the driver doesn't support reopen, and
it's also size 0 and the driver doesn't support bdrv_truncate. All of
these are easily fixable, but then 'commit' ended up in an infinite loop
deep in the vvfat code for me, so I thought I'd best leave it alone. I'm
not really sure what it was supposed to do anyway.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block/vvfat.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static void write_target_close(BlockDriverState *bs) {
 
 static BlockDriver vvfat_write_target = {
     .format_name        = "vvfat_write_target",
+    .instance_size      = sizeof(void*),
     .bdrv_co_pwritev    = write_target_commit,
     .bdrv_close         = write_target_close,
 };
@@ -XXX,XX +XXX,XX @@ static int enable_write_target(BlockDriverState *bs, Error **errp)
     unlink(s->qcow_filename);
 #endif
 
-    backing = bdrv_new();
+    backing = bdrv_new_open_driver(&vvfat_write_target, NULL, BDRV_O_ALLOW_RDWR,
+                                   &error_abort);
+    *(void**) backing->opaque = s;
+
     bdrv_set_backing_hd(s->bs, backing);
     bdrv_unref(backing);
 
-    s->bs->backing->bs->drv = &vvfat_write_target;
-    s->bs->backing->bs->opaque = g_new(void *, 1);
-    *(void**)s->bs->backing->bs->opaque = s;
-
     return 0;
 
 err:
-- 
1.8.3.1

blk_insert_bs() and block job related functions will soon require an
opened block node (permission calculations will involve the block
driver), so let our tests be consistent with the real users in this
respect.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/test-blockjob-txn.c | 6 +++++-
 tests/test-blockjob.c     | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/tests/test-blockjob-txn.c b/tests/test-blockjob-txn.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob-txn.c
+++ b/tests/test-blockjob-txn.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *test_block_job_start(unsigned int iterations,
     char job_id[24];
 
     data = g_new0(TestBlockJobCBData, 1);
-    bs = bdrv_new();
+
+    bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
+    g_assert_nonnull(bs);
+
     snprintf(job_id, sizeof(job_id), "job%u", counter++);
     s = block_job_create(job_id, &test_block_job_driver, bs, 0,
                          BLOCK_JOB_DEFAULT, test_block_job_cb,
@@ -XXX,XX +XXX,XX @@ static void test_pair_jobs_fail_cancel_race(void)
 int main(int argc, char **argv)
 {
     qemu_init_main_loop(&error_abort);
+    bdrv_init();
 
     g_test_init(&argc, &argv, NULL);
     g_test_add_func("/single/success", test_single_job_success);
diff --git a/tests/test-blockjob.c b/tests/test-blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-blockjob.c
+++ b/tests/test-blockjob.c
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,
 static BlockBackend *create_blk(const char *name)
 {
     BlockBackend *blk = blk_new();
-    BlockDriverState *bs = bdrv_new();
+    BlockDriverState *bs;
+
+    bs = bdrv_open("null-co://", NULL, NULL, 0, &error_abort);
+    g_assert_nonnull(bs);
 
     blk_insert_bs(blk, bs);
     bdrv_unref(bs);
@@ -XXX,XX +XXX,XX @@ static void test_job_ids(void)
 int main(int argc, char **argv)
 {
     qemu_init_main_loop(&error_abort);
+    bdrv_init();
 
     g_test_init(&argc, &argv, NULL);
     g_test_add_func("/blockjob/ids", test_job_ids);
-- 
1.8.3.1

The following changes since commit 91fe7a376ad46e3cc5e82d418aad22173c948a3c:

Merge remote-tracking branch 'remotes/jasowang/tags/net-pull-request' into staging (2018-06-15 11:41:44 +0100)

are available in the git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to 6266e900b8083945cb766b45c124fb3c42932cb3:

block: Remove dead deprecation warning code (2018-06-15 14:49:44 +0200)

----------------------------------------------------------------
Block layer patches:

- Fix options that work only with -drive or -blockdev, but not with
  both, because of QDict type confusion
- rbd: Add options 'auth-client-required' and 'key-secret'
- Remove deprecated -drive options serial/addr/cyls/heads/secs/trans
- rbd, iscsi: Remove deprecated 'filename' option
- Fix 'qemu-img map' crash with unaligned image size
- Improve QMP documentation for jobs

----------------------------------------------------------------
Eric Blake (2):
      qemu-img: Fix assert when mapping unaligned raw file
      iotests: Add test 221 to catch qemu-img map regression

John Snow (2):
      jobs: fix stale wording
      jobs: fix verb references in docs

Kevin Wolf (4):
      block: Remove deprecated -drive geometry options
      block: Remove deprecated -drive option addr
      block: Remove deprecated -drive option serial
      block: Remove dead deprecation warning code

Markus Armbruster (17):
      rbd: Drop deprecated -drive parameter "filename"
      iscsi: Drop deprecated -drive parameter "filename"
      qobject: Move block-specific qdict code to block-qdict.c
      block: Fix -blockdev for certain non-string scalars
      block: Fix -drive for certain non-string scalars
      block: Clean up a misuse of qobject_to() in .bdrv_co_create_opts()
      block: Factor out qobject_input_visitor_new_flat_confused()
      block: Make remaining uses of qobject input visitor more robust
      block-qdict: Simplify qdict_flatten_qdict()
      block-qdict: Tweak qdict_flatten_qdict(), qdict_flatten_qlist()
      block-qdict: Clean up qdict_crumple() a bit
      block-qdict: Simplify qdict_is_list() some
      check-block-qdict: Rename qdict_flatten()'s variables for clarity
      check-block-qdict: Cover flattening of empty lists and dictionaries
      block: Fix -blockdev / blockdev-add for empty objects and arrays
      rbd: New parameter auth-client-required
      rbd: New parameter key-secret

Max Reitz (1):
      block: Add block-specific QDict header

From: Eric Blake <eblake@redhat.com>

Commit a290f085 exposed a latent bug in qemu-img map introduced
during the conversion of block status to be byte-based.  Earlier in
commit 5e344dd8, the internal interface get_block_status() switched
to take byte-based parameters, but still called a sector-based
block layer function; as such, rounding was added in the lone
caller to obey the contract.  However, commit 237d78f8 changed
get_block_status() to truly be byte-based, at which point rounding
to sector boundaries can result in calling bdrv_block_status() with
'bytes == 0' (a coding error) when the boundary between data and a
hole falls mid-sector (true for the past-EOF implicit hole present
in POSIX files).  Fix things by removing the rounding that is now
no longer necessary.

See also https://bugzilla.redhat.com/1589738

Fixes: 237d78f8
Reported-by: Dan Kenigsberg <danken@redhat.com>
Reported-by: Nir Soffer <nsoffer@redhat.com>
Reported-by: Maor Lipchuk <mlipchuk@redhat.com>
CC: qemu-stable@nongnu.org
Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qemu-img.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 @@ static int img_map(int argc, char **argv)
         int64_t n;
 
         /* Probe up to 1 GiB at a time.  */
-        n = QEMU_ALIGN_DOWN(MIN(1 << 30, length - offset), BDRV_SECTOR_SIZE);
+        n = MIN(1 << 30, length - offset);
         ret = get_block_status(bs, offset, n, &next);
 
         if (ret < 0) {
-- 
2.13.6

From: Eric Blake <eblake@redhat.com>

Although qemu-img creates aligned files (by rounding up), it
must also gracefully handle files that are not sector-aligned.
Test that the bug fixed in the previous patch does not recur.

It's a bit annoying that we can see the (implicit) hole past
the end of the file on to the next sector boundary, so if we
ever reach the point where we report a byte-accurate size rather
than our current behavior of always rounding up, this test will
probably need a slight modification.

Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/221     | 60 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/221.out | 16 +++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 77 insertions(+)
 create mode 100755 tests/qemu-iotests/221
 create mode 100644 tests/qemu-iotests/221.out

diff --git a/tests/qemu-iotests/221 b/tests/qemu-iotests/221
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/221
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test qemu-img vs. unaligned images
+#
+# Copyright (C) 2018 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"
+
+here="$PWD"
+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
+
+_supported_fmt raw
+_supported_proto file
+_supported_os Linux
+
+echo
+echo "=== Check mapping of unaligned raw image ==="
+echo
+
+_make_test_img 43009 # qemu-img create rounds size up
+$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
+
+truncate --size=43009 "$TEST_IMG" # so we resize it and check again
+$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
+
+$QEMU_IO -c 'w 43008 1' "$TEST_IMG" | _filter_qemu_io # writing also rounds up
+$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
+
+truncate --size=43009 "$TEST_IMG" # so we resize it and check again
+$QEMU_IMG map --output=json "$TEST_IMG" | _filter_qemu_img_map
+
+# success, all done
+echo '*** done'
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/221.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 221
+
+=== Check mapping of unaligned raw image ===
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=43009
+[{ "start": 0, "length": 43520, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 43520, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+wrote 1/1 bytes at offset 43008
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+[{ "start": 0, "length": 40960, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+{ "start": 40960, "length": 2049, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 43009, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 40960, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+{ "start": 40960, "length": 2049, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 43009, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 217 rw auto quick
 218 rw auto quick
 219 rw auto
+221 rw auto quick
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

During the design for manual completion, we decided not to use the
"manual" property as a shorthand for both auto-dismiss and auto-finalize.

Fix the wording.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/job.json | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/qapi/job.json b/qapi/job.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/job.json
+++ b/qapi/job.json
@@ -XXX,XX +XXX,XX @@
 #           the last job in a transaction.
 #
 # @pending: The job has finished its work, but has finalization steps that it
-#           needs to make prior to completing. These changes may require
-#           manual intervention by the management process if manual was set
-#           to true. These changes may still fail.
+#           needs to make prior to completing. These changes will require
+#           manual intervention via @job-finalize if auto-finalize was set to
+#           false. These pending changes may still fail.
 #
 # @aborting: The job is in the process of being aborted, and will finish with
 #            an error. The job will afterwards report that it is @concluded.
 #            This status may not be visible to the management process.
 #
-# @concluded: The job has finished all work. If manual was set to true, the job
-#             will remain in the query list until it is dismissed.
+# @concluded: The job has finished all work. If auto-dismiss was set to false,
+#             the job will remain in the query list until it is dismissed via
+#             @job-dismiss.
 #
 # @null: The job is in the process of being dismantled. This state should not
 #        ever be visible externally.
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

These point to the job versions now, not the blockjob versions which
don't really exist anymore.

Except set-speed, which does. It sticks out like a sore thumb. This
patch doesn't fix that, but it doesn't make it any worse, either.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/job.json | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/qapi/job.json b/qapi/job.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/job.json
+++ b/qapi/job.json
@@ -XXX,XX +XXX,XX @@
 #
 # Represents command verbs that can be applied to a job.
 #
-# @cancel: see @block-job-cancel
+# @cancel: see @job-cancel
 #
-# @pause: see @block-job-pause
+# @pause: see @job-pause
 #
-# @resume: see @block-job-resume
+# @resume: see @job-resume
 #
 # @set-speed: see @block-job-set-speed
 #
-# @complete: see @block-job-complete
+# @complete: see @job-complete
 #
-# @dismiss: see @block-job-dismiss
+# @dismiss: see @job-dismiss
 #
-# @finalize: see @block-job-finalize
+# @finalize: see @job-finalize
 #
 # Since: 2.12
 ##
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Parameter "filename" is deprecated since commit 91589d9e5ca, v2.10.0.
Time to get rid of it.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/rbd.c | 16 ----------------
 1 file changed, 16 deletions(-)

diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     QObject *crumpled = NULL;
     const QDictEntry *e;
     Error *local_err = NULL;
-    const char *filename;
     char *keypairs, *secretid;
     int r;
 
-    /* If we are given a filename, parse the filename, with precedence given to
-     * filename encoded options */
-    filename = qdict_get_try_str(options, "filename");
-    if (filename) {
-        warn_report("'filename' option specified. "
-                    "This is an unsupported option, and may be deprecated "
-                    "in the future");
-        qemu_rbd_parse_filename(filename, options, &local_err);
-        qdict_del(options, "filename");
-        if (local_err) {
-            error_propagate(errp, local_err);
-            return -EINVAL;
-        }
-    }
-
     keypairs = g_strdup(qdict_get_try_str(options, "=keyvalue-pairs"));
     if (keypairs) {
         qdict_del(options, "=keyvalue-pairs");
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Parameter "filename" is deprecated since commit 5c3ad1a6a8f, v2.10.0.
Time to get rid of it.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/iscsi.c | 23 ++---------------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
             .name = "timeout",
             .type = QEMU_OPT_NUMBER,
         },
-        {
-            .name = "filename",
-            .type = QEMU_OPT_STRING,
-        },
         { /* end of list */ }
     },
 };
@@ -XXX,XX +XXX,XX @@ static int iscsi_open(BlockDriverState *bs, QDict *options, int flags,
     char *initiator_name = NULL;
     QemuOpts *opts;
     Error *local_err = NULL;
-    const char *transport_name, *portal, *target, *filename;
+    const char *transport_name, *portal, *target;
 #if LIBISCSI_API_VERSION >= (20160603)
     enum iscsi_transport_type transport;
 #endif
     int i, ret = 0, timeout = 0, lun;
 
-    /* If we are given a filename, parse the filename, with precedence given to
-     * filename encoded options */
-    filename = qdict_get_try_str(options, "filename");
-    if (filename) {
-        warn_report("'filename' option specified. "
-                    "This is an unsupported option, and may be deprecated "
-                    "in the future");
-        iscsi_parse_filename(filename, options, &local_err);
-        if (local_err) {
-            ret = -EINVAL;
-            error_propagate(errp, local_err);
-            goto exit;
-        }
-    }
-
     opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
     qemu_opts_absorb_qdict(opts, options, &local_err);
     if (local_err) {
@@ -XXX,XX +XXX,XX @@ out:
         }
         memset(iscsilun, 0, sizeof(IscsiLun));
     }
-exit:
+
     return ret;
 }
 
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

There are numerous QDict functions that have been introduced for and are
used only by the block layer.  Move their declarations into an own
header file to reflect that.

While qdict_extract_subqdict() is in fact used outside of the block
layer (in util/qemu-config.c), it is still a function related very
closely to how the block layer works with nested QDicts, namely by
sometimes flattening them.  Therefore, its declaration is put into this
header as well and util/qemu-config.c includes it with a comment stating
exactly which function it needs.

diff --git a/include/block/qdict.h b/include/block/qdict.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/block/qdict.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Special QDict functions used by the block layer
+ *
+ * Copyright (c) 2013-2018 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ */
+
+#ifndef BLOCK_QDICT_H
+#define BLOCK_QDICT_H
+
+#include "qapi/qmp/qdict.h"
+
+void qdict_copy_default(QDict *dst, QDict *src, const char *key);
+void qdict_set_default_str(QDict *dst, const char *key, const char *val);
+
+void qdict_join(QDict *dest, QDict *src, bool overwrite);
+
+void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
+void qdict_array_split(QDict *src, QList **dst);
+int qdict_array_entries(QDict *src, const char *subqdict);
+QObject *qdict_crumple(const QDict *src, Error **errp);
+void qdict_flatten(QDict *qdict);
+
+typedef struct QDictRenames {
+    const char *from;
+    const char *to;
+} QDictRenames;
+bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
+
+#endif
diff --git a/include/qapi/qmp/qdict.h b/include/qapi/qmp/qdict.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qapi/qmp/qdict.h
+++ b/include/qapi/qmp/qdict.h
@@ -XXX,XX +XXX,XX @@ int64_t qdict_get_try_int(const QDict *qdict, const char *key,
 bool qdict_get_try_bool(const QDict *qdict, const char *key, bool def_value);
 const char *qdict_get_try_str(const QDict *qdict, const char *key);
 
-void qdict_copy_default(QDict *dst, QDict *src, const char *key);
-void qdict_set_default_str(QDict *dst, const char *key, const char *val);
-
 QDict *qdict_clone_shallow(const QDict *src);
-void qdict_flatten(QDict *qdict);
-
-void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
-void qdict_array_split(QDict *src, QList **dst);
-int qdict_array_entries(QDict *src, const char *subqdict);
-QObject *qdict_crumple(const QDict *src, Error **errp);
-
-void qdict_join(QDict *dest, QDict *src, bool overwrite);
-
-typedef struct QDictRenames {
-    const char *from;
-    const char *to;
-} QDictRenames;
-bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
 
 #endif /* QDICT_H */
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@
 #include "block/block_int.h"
 #include "block/blockjob.h"
 #include "block/nbd.h"
+#include "block/qdict.h"
 #include "qemu/error-report.h"
 #include "module_block.h"
 #include "qemu/module.h"
diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include <glusterfs/api/glfs.h>
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qerror.h"
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/bitops.h"
 #include "qemu/bitmap.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "scsi/constants.h"
 #include "qemu/iov.h"
 #include "qemu/option.h"
diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "nbd-client.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qemu/uri.h"
 #include "block/block_int.h"
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qapi/error.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "trace.h"
 #include "qemu/iov.h"
 #include "qemu/option.h"
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qapi/error.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "qemu/error-report.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include <zlib.h>
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 @@
  */
 
 #include "qemu/osdep.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qemu/timer.h"
 #include "qemu/bswap.h"
diff --git a/block/quorum.c b/block/quorum.c
index XXXXXXX..XXXXXXX 100644
--- a/block/quorum.c
+++ b/block/quorum.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/cutils.h"
 #include "qemu/option.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qapi/qapi-events-block.h"
 #include "qapi/qmp/qdict.h"
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qemu/option.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "crypto/secret.h"
 #include "qemu/cutils.h"
 #include "qapi/qmp/qstring.h"
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/option.h"
 #include "qemu/sockets.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/bitops.h"
 #include "qemu/cutils.h"
diff --git a/block/snapshot.c b/block/snapshot.c
index XXXXXXX..XXXXXXX 100644
--- a/block/snapshot.c
+++ b/block/snapshot.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "block/snapshot.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qerror.h"
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@
 #include <libssh2_sftp.h>
 
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qapi/error.h"
 #include "qemu/error-report.h"
 #include "qemu/option.h"
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qapi/error.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qapi/error.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@
 #include <dirent.h>
 #include "qapi/error.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
 #include "qemu/bswap.h"
diff --git a/block/vxhs.c b/block/vxhs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vxhs.c
+++ b/block/vxhs.c
@@ -XXX,XX +XXX,XX @@
 #include <qnio/qnio_api.h>
 #include <sys/param.h>
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qstring.h"
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/blockdev.h"
 #include "hw/block/block.h"
 #include "block/blockjob.h"
+#include "block/qdict.h"
 #include "block/throttle-groups.h"
 #include "monitor/monitor.h"
 #include "qemu/error-report.h"
diff --git a/qobject/qdict.c b/qobject/qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/qdict.c
+++ b/qobject/qdict.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "block/qdict.h"
 #include "qapi/qmp/qnum.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qbool.h"
diff --git a/tests/check-qdict.c b/tests/check-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/check-qdict.c
+++ b/tests/check-qdict.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "block/qdict.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qlist.h"
 #include "qapi/qmp/qnum.h"
diff --git a/tests/check-qobject.c b/tests/check-qobject.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/check-qobject.c
+++ b/tests/check-qobject.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
+#include "block/qdict.h"
 #include "qapi/qmp/qbool.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qlist.h"
diff --git a/tests/test-replication.c b/tests/test-replication.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-replication.c
+++ b/tests/test-replication.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/option.h"
 #include "replication.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 
 #define IMG_SIZE (64 * 1024 * 1024)
diff --git a/util/qemu-config.c b/util/qemu-config.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-config.c
+++ b/util/qemu-config.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
+#include "block/qdict.h" /* for qdict_extract_subqdict() */
 #include "qapi/error.h"
 #include "qapi/qapi-commands-misc.h"
 #include "qapi/qmp/qdict.h"
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Pure code motion, except for two brace placements and a comment
tweaked to appease checkpatch.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qobject/block-qdict.c     | 640 ++++++++++++++++++++++++++++++++++++++++++++
 qobject/qdict.c           | 629 --------------------------------------------
 tests/check-block-qdict.c | 655 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/check-qdict.c       | 642 ---------------------------------------------
 MAINTAINERS               |   2 +
 qobject/Makefile.objs     |   1 +
 tests/Makefile.include    |   4 +
 7 files changed, 1302 insertions(+), 1271 deletions(-)
 create mode 100644 qobject/block-qdict.c
 create mode 100644 tests/check-block-qdict.c

diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Special QDict functions used by the block layer
+ *
+ * Copyright (c) 2013-2018 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "block/qdict.h"
+#include "qapi/qmp/qlist.h"
+#include "qemu/cutils.h"
+#include "qapi/error.h"
+
+/**
+ * qdict_copy_default(): If no entry mapped by 'key' exists in 'dst' yet, the
+ * value of 'key' in 'src' is copied there (and the refcount increased
+ * accordingly).
+ */
+void qdict_copy_default(QDict *dst, QDict *src, const char *key)
+{
+    QObject *val;
+
+    if (qdict_haskey(dst, key)) {
+        return;
+    }
+
+    val = qdict_get(src, key);
+    if (val) {
+        qdict_put_obj(dst, key, qobject_ref(val));
+    }
+}
+
+/**
+ * qdict_set_default_str(): If no entry mapped by 'key' exists in 'dst' yet, a
+ * new QString initialised by 'val' is put there.
+ */
+void qdict_set_default_str(QDict *dst, const char *key, const char *val)
+{
+    if (qdict_haskey(dst, key)) {
+        return;
+    }
+
+    qdict_put_str(dst, key, val);
+}
+
+static void qdict_flatten_qdict(QDict *qdict, QDict *target,
+                                const char *prefix);
+
+static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
+{
+    QObject *value;
+    const QListEntry *entry;
+    char *new_key;
+    int i;
+
+    /* This function is never called with prefix == NULL, i.e., it is always
+     * called from within qdict_flatten_q(list|dict)(). Therefore, it does not
+     * need to remove list entries during the iteration (the whole list will be
+     * deleted eventually anyway from qdict_flatten_qdict()). */
+    assert(prefix);
+
+    entry = qlist_first(qlist);
+
+    for (i = 0; entry; entry = qlist_next(entry), i++) {
+        value = qlist_entry_obj(entry);
+        new_key = g_strdup_printf("%s.%i", prefix, i);
+
+        if (qobject_type(value) == QTYPE_QDICT) {
+            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
+        } else if (qobject_type(value) == QTYPE_QLIST) {
+            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
+        } else {
+            /* All other types are moved to the target unchanged. */
+            qdict_put_obj(target, new_key, qobject_ref(value));
+        }
+
+        g_free(new_key);
+    }
+}
+
+static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
+{
+    QObject *value;
+    const QDictEntry *entry, *next;
+    char *new_key;
+    bool delete;
+
+    entry = qdict_first(qdict);
+
+    while (entry != NULL) {
+
+        next = qdict_next(qdict, entry);
+        value = qdict_entry_value(entry);
+        new_key = NULL;
+        delete = false;
+
+        if (prefix) {
+            new_key = g_strdup_printf("%s.%s", prefix, entry->key);
+        }
+
+        if (qobject_type(value) == QTYPE_QDICT) {
+            /* Entries of QDicts are processed recursively, the QDict object
+             * itself disappears. */
+            qdict_flatten_qdict(qobject_to(QDict, value), target,
+                                new_key ? new_key : entry->key);
+            delete = true;
+        } else if (qobject_type(value) == QTYPE_QLIST) {
+            qdict_flatten_qlist(qobject_to(QList, value), target,
+                                new_key ? new_key : entry->key);
+            delete = true;
+        } else if (prefix) {
+            /* All other objects are moved to the target unchanged. */
+            qdict_put_obj(target, new_key, qobject_ref(value));
+            delete = true;
+        }
+
+        g_free(new_key);
+
+        if (delete) {
+            qdict_del(qdict, entry->key);
+
+            /* Restart loop after modifying the iterated QDict */
+            entry = qdict_first(qdict);
+            continue;
+        }
+
+        entry = next;
+    }
+}
+
+/**
+ * qdict_flatten(): For each nested QDict with key x, all fields with key y
+ * are moved to this QDict and their key is renamed to "x.y". For each nested
+ * QList with key x, the field at index y is moved to this QDict with the key
+ * "x.y" (i.e., the reverse of what qdict_array_split() does).
+ * This operation is applied recursively for nested QDicts and QLists.
+ */
+void qdict_flatten(QDict *qdict)
+{
+    qdict_flatten_qdict(qdict, qdict, NULL);
+}
+
+/* extract all the src QDict entries starting by start into dst */
+void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
+
+{
+    const QDictEntry *entry, *next;
+    const char *p;
+
+    *dst = qdict_new();
+    entry = qdict_first(src);
+
+    while (entry != NULL) {
+        next = qdict_next(src, entry);
+        if (strstart(entry->key, start, &p)) {
+            qdict_put_obj(*dst, p, qobject_ref(entry->value));
+            qdict_del(src, entry->key);
+        }
+        entry = next;
+    }
+}
+
+static int qdict_count_prefixed_entries(const QDict *src, const char *start)
+{
+    const QDictEntry *entry;
+    int count = 0;
+
+    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
+        if (strstart(entry->key, start, NULL)) {
+            if (count == INT_MAX) {
+                return -ERANGE;
+            }
+            count++;
+        }
+    }
+
+    return count;
+}
+
+/**
+ * qdict_array_split(): This function moves array-like elements of a QDict into
+ * a new QList. Every entry in the original QDict with a key "%u" or one
+ * prefixed "%u.", where %u designates an unsigned integer starting at 0 and
+ * incrementally counting up, will be moved to a new QDict at index %u in the
+ * output QList with the key prefix removed, if that prefix is "%u.". If the
+ * whole key is just "%u", the whole QObject will be moved unchanged without
+ * creating a new QDict. The function terminates when there is no entry in the
+ * QDict with a prefix directly (incrementally) following the last one; it also
+ * returns if there are both entries with "%u" and "%u." for the same index %u.
+ * Example: {"0.a": 42, "0.b": 23, "1.x": 0, "4.y": 1, "o.o": 7, "2": 66}
+ *      (or {"1.x": 0, "4.y": 1, "0.a": 42, "o.o": 7, "0.b": 23, "2": 66})
+ *       => [{"a": 42, "b": 23}, {"x": 0}, 66]
+ *      and {"4.y": 1, "o.o": 7} (remainder of the old QDict)
+ */
+void qdict_array_split(QDict *src, QList **dst)
+{
+    unsigned i;
+
+    *dst = qlist_new();
+
+    for (i = 0; i < UINT_MAX; i++) {
+        QObject *subqobj;
+        bool is_subqdict;
+        QDict *subqdict;
+        char indexstr[32], prefix[32];
+        size_t snprintf_ret;
+
+        snprintf_ret = snprintf(indexstr, 32, "%u", i);
+        assert(snprintf_ret < 32);
+
+        subqobj = qdict_get(src, indexstr);
+
+        snprintf_ret = snprintf(prefix, 32, "%u.", i);
+        assert(snprintf_ret < 32);
+
+        /* Overflow is the same as positive non-zero results */
+        is_subqdict = qdict_count_prefixed_entries(src, prefix);
+
+        /*
+         * There may be either a single subordinate object (named
+         * "%u") or multiple objects (each with a key prefixed "%u."),
+         * but not both.
+         */
+        if (!subqobj == !is_subqdict) {
+            break;
+        }
+
+        if (is_subqdict) {
+            qdict_extract_subqdict(src, &subqdict, prefix);
+            assert(qdict_size(subqdict) > 0);
+        } else {
+            qobject_ref(subqobj);
+            qdict_del(src, indexstr);
+        }
+
+        qlist_append_obj(*dst, subqobj ?: QOBJECT(subqdict));
+    }
+}
+
+/**
+ * qdict_split_flat_key:
+ * @key: the key string to split
+ * @prefix: non-NULL pointer to hold extracted prefix
+ * @suffix: non-NULL pointer to remaining suffix
+ *
+ * Given a flattened key such as 'foo.0.bar', split it into two parts
+ * at the first '.' separator. Allows double dot ('..') to escape the
+ * normal separator.
+ *
+ * e.g.
+ *    'foo.0.bar' -> prefix='foo' and suffix='0.bar'
+ *    'foo..0.bar' -> prefix='foo.0' and suffix='bar'
+ *
+ * The '..' sequence will be unescaped in the returned 'prefix'
+ * string. The 'suffix' string will be left in escaped format, so it
+ * can be fed back into the qdict_split_flat_key() key as the input
+ * later.
+ *
+ * The caller is responsible for freeing the string returned in @prefix
+ * using g_free().
+ */
+static void qdict_split_flat_key(const char *key, char **prefix,
+                                 const char **suffix)
+{
+    const char *separator;
+    size_t i, j;
+
+    /* Find first '.' separator, but if there is a pair '..'
+     * that acts as an escape, so skip over '..' */
+    separator = NULL;
+    do {
+        if (separator) {
+            separator += 2;
+        } else {
+            separator = key;
+        }
+        separator = strchr(separator, '.');
+    } while (separator && separator[1] == '.');
+
+    if (separator) {
+        *prefix = g_strndup(key, separator - key);
+        *suffix = separator + 1;
+    } else {
+        *prefix = g_strdup(key);
+        *suffix = NULL;
+    }
+
+    /* Unescape the '..' sequence into '.' */
+    for (i = 0, j = 0; (*prefix)[i] != '\0'; i++, j++) {
+        if ((*prefix)[i] == '.') {
+            assert((*prefix)[i + 1] == '.');
+            i++;
+        }
+        (*prefix)[j] = (*prefix)[i];
+    }
+    (*prefix)[j] = '\0';
+}
+
+/**
+ * qdict_is_list:
+ * @maybe_list: dict to check if keys represent list elements.
+ *
+ * Determine whether all keys in @maybe_list are valid list elements.
+ * If @maybe_list is non-zero in length and all the keys look like
+ * valid list indexes, this will return 1. If @maybe_list is zero
+ * length or all keys are non-numeric then it will return 0 to indicate
+ * it is a normal qdict. If there is a mix of numeric and non-numeric
+ * keys, or the list indexes are non-contiguous, an error is reported.
+ *
+ * Returns: 1 if a valid list, 0 if a dict, -1 on error
+ */
+static int qdict_is_list(QDict *maybe_list, Error **errp)
+{
+    const QDictEntry *ent;
+    ssize_t len = 0;
+    ssize_t max = -1;
+    int is_list = -1;
+    int64_t val;
+
+    for (ent = qdict_first(maybe_list); ent != NULL;
+         ent = qdict_next(maybe_list, ent)) {
+
+        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
+            if (is_list == -1) {
+                is_list = 1;
+            } else if (!is_list) {
+                error_setg(errp,
+                           "Cannot mix list and non-list keys");
+                return -1;
+            }
+            len++;
+            if (val > max) {
+                max = val;
+            }
+        } else {
+            if (is_list == -1) {
+                is_list = 0;
+            } else if (is_list) {
+                error_setg(errp,
+                           "Cannot mix list and non-list keys");
+                return -1;
+            }
+        }
+    }
+
+    if (is_list == -1) {
+        assert(!qdict_size(maybe_list));
+        is_list = 0;
+    }
+
+    /* NB this isn't a perfect check - e.g. it won't catch
+     * a list containing '1', '+1', '01', '3', but that
+     * does not matter - we've still proved that the
+     * input is a list. It is up the caller to do a
+     * stricter check if desired */
+    if (len != (max + 1)) {
+        error_setg(errp, "List indices are not contiguous, "
+                   "saw %zd elements but %zd largest index",
+                   len, max);
+        return -1;
+    }
+
+    return is_list;
+}
+
+/**
+ * qdict_crumple:
+ * @src: the original flat dictionary (only scalar values) to crumple
+ *
+ * Takes a flat dictionary whose keys use '.' separator to indicate
+ * nesting, and values are scalars, and crumples it into a nested
+ * structure.
+ *
+ * To include a literal '.' in a key name, it must be escaped as '..'
+ *
+ * For example, an input of:
+ *
+ * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
+ *   'foo.1.bar': 'two', 'foo.1.wizz': '2' }
+ *
+ * will result in an output of:
+ *
+ * {
+ *   'foo': [
+ *      { 'bar': 'one', 'wizz': '1' },
+ *      { 'bar': 'two', 'wizz': '2' }
+ *   ],
+ * }
+ *
+ * The following scenarios in the input dict will result in an
+ * error being returned:
+ *
+ *  - Any values in @src are non-scalar types
+ *  - If keys in @src imply that a particular level is both a
+ *    list and a dict. e.g., "foo.0.bar" and "foo.eek.bar".
+ *  - If keys in @src imply that a particular level is a list,
+ *    but the indices are non-contiguous. e.g. "foo.0.bar" and
+ *    "foo.2.bar" without any "foo.1.bar" present.
+ *  - If keys in @src represent list indexes, but are not in
+ *    the "%zu" format. e.g. "foo.+0.bar"
+ *
+ * Returns: either a QDict or QList for the nested data structure, or NULL
+ * on error
+ */
+QObject *qdict_crumple(const QDict *src, Error **errp)
+{
+    const QDictEntry *ent;
+    QDict *two_level, *multi_level = NULL;
+    QObject *dst = NULL, *child;
+    size_t i;
+    char *prefix = NULL;
+    const char *suffix = NULL;
+    int is_list;
+
+    two_level = qdict_new();
+
+    /* Step 1: split our totally flat dict into a two level dict */
+    for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
+        if (qobject_type(ent->value) == QTYPE_QDICT ||
+            qobject_type(ent->value) == QTYPE_QLIST) {
+            error_setg(errp, "Value %s is not a scalar",
+                       ent->key);
+            goto error;
+        }
+
+        qdict_split_flat_key(ent->key, &prefix, &suffix);
+
+        child = qdict_get(two_level, prefix);
+        if (suffix) {
+            QDict *child_dict = qobject_to(QDict, child);
+            if (!child_dict) {
+                if (child) {
+                    error_setg(errp, "Key %s prefix is already set as a scalar",
+                               prefix);
+                    goto error;
+                }
+
+                child_dict = qdict_new();
+                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
+            }
+
+            qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
+        } else {
+            if (child) {
+                error_setg(errp, "Key %s prefix is already set as a dict",
+                           prefix);
+                goto error;
+            }
+            qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
+        }
+
+        g_free(prefix);
+        prefix = NULL;
+    }
+
+    /* Step 2: optionally process the two level dict recursively
+     * into a multi-level dict */
+    multi_level = qdict_new();
+    for (ent = qdict_first(two_level); ent != NULL;
+         ent = qdict_next(two_level, ent)) {
+        QDict *dict = qobject_to(QDict, ent->value);
+        if (dict) {
+            child = qdict_crumple(dict, errp);
+            if (!child) {
+                goto error;
+            }
+
+            qdict_put_obj(multi_level, ent->key, child);
+        } else {
+            qdict_put_obj(multi_level, ent->key, qobject_ref(ent->value));
+        }
+    }
+    qobject_unref(two_level);
+    two_level = NULL;
+
+    /* Step 3: detect if we need to turn our dict into list */
+    is_list = qdict_is_list(multi_level, errp);
+    if (is_list < 0) {
+        goto error;
+    }
+
+    if (is_list) {
+        dst = QOBJECT(qlist_new());
+
+        for (i = 0; i < qdict_size(multi_level); i++) {
+            char *key = g_strdup_printf("%zu", i);
+
+            child = qdict_get(multi_level, key);
+            g_free(key);
+
+            if (!child) {
+                error_setg(errp, "Missing list index %zu", i);
+                goto error;
+            }
+
+            qlist_append_obj(qobject_to(QList, dst), qobject_ref(child));
+        }
+        qobject_unref(multi_level);
+        multi_level = NULL;
+    } else {
+        dst = QOBJECT(multi_level);
+    }
+
+    return dst;
+
+ error:
+    g_free(prefix);
+    qobject_unref(multi_level);
+    qobject_unref(two_level);
+    qobject_unref(dst);
+    return NULL;
+}
+
+/**
+ * qdict_array_entries(): Returns the number of direct array entries if the
+ * sub-QDict of src specified by the prefix in subqdict (or src itself for
+ * prefix == "") is valid as an array, i.e. the length of the created list if
+ * the sub-QDict would become empty after calling qdict_array_split() on it. If
+ * the array is not valid, -EINVAL is returned.
+ */
+int qdict_array_entries(QDict *src, const char *subqdict)
+{
+    const QDictEntry *entry;
+    unsigned i;
+    unsigned entries = 0;
+    size_t subqdict_len = strlen(subqdict);
+
+    assert(!subqdict_len || subqdict[subqdict_len - 1] == '.');
+
+    /* qdict_array_split() loops until UINT_MAX, but as we want to return
+     * negative errors, we only have a signed return value here. Any additional
+     * entries will lead to -EINVAL. */
+    for (i = 0; i < INT_MAX; i++) {
+        QObject *subqobj;
+        int subqdict_entries;
+        char *prefix = g_strdup_printf("%s%u.", subqdict, i);
+
+        subqdict_entries = qdict_count_prefixed_entries(src, prefix);
+
+        /* Remove ending "." */
+        prefix[strlen(prefix) - 1] = 0;
+        subqobj = qdict_get(src, prefix);
+
+        g_free(prefix);
+
+        if (subqdict_entries < 0) {
+            return subqdict_entries;
+        }
+
+        /* There may be either a single subordinate object (named "%u") or
+         * multiple objects (each with a key prefixed "%u."), but not both. */
+        if (subqobj && subqdict_entries) {
+            return -EINVAL;
+        } else if (!subqobj && !subqdict_entries) {
+            break;
+        }
+
+        entries += subqdict_entries ? subqdict_entries : 1;
+    }
+
+    /* Consider everything handled that isn't part of the given sub-QDict */
+    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
+        if (!strstart(qdict_entry_key(entry), subqdict, NULL)) {
+            entries++;
+        }
+    }
+
+    /* Anything left in the sub-QDict that wasn't handled? */
+    if (qdict_size(src) != entries) {
+        return -EINVAL;
+    }
+
+    return i;
+}
+
+/**
+ * qdict_join(): Absorb the src QDict into the dest QDict, that is, move all
+ * elements from src to dest.
+ *
+ * If an element from src has a key already present in dest, it will not be
+ * moved unless overwrite is true.
+ *
+ * If overwrite is true, the conflicting values in dest will be discarded and
+ * replaced by the corresponding values from src.
+ *
+ * Therefore, with overwrite being true, the src QDict will always be empty when
+ * this function returns. If overwrite is false, the src QDict will be empty
+ * iff there were no conflicts.
+ */
+void qdict_join(QDict *dest, QDict *src, bool overwrite)
+{
+    const QDictEntry *entry, *next;
+
+    entry = qdict_first(src);
+    while (entry) {
+        next = qdict_next(src, entry);
+
+        if (overwrite || !qdict_haskey(dest, entry->key)) {
+            qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
+            qdict_del(src, entry->key);
+        }
+
+        entry = next;
+    }
+}
+
+/**
+ * qdict_rename_keys(): Rename keys in qdict according to the replacements
+ * specified in the array renames. The array must be terminated by an entry
+ * with from = NULL.
+ *
+ * The renames are performed individually in the order of the array, so entries
+ * may be renamed multiple times and may or may not conflict depending on the
+ * order of the renames array.
+ *
+ * Returns true for success, false in error cases.
+ */
+bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
+{
+    QObject *qobj;
+
+    while (renames->from) {
+        if (qdict_haskey(qdict, renames->from)) {
+            if (qdict_haskey(qdict, renames->to)) {
+                error_setg(errp, "'%s' and its alias '%s' can't be used at the "
+                           "same time", renames->to, renames->from);
+                return false;
+            }
+
+            qobj = qdict_get(qdict, renames->from);
+            qdict_put_obj(qdict, renames->to, qobject_ref(qobj));
+            qdict_del(qdict, renames->from);
+        }
+
+        renames++;
+    }
+    return true;
+}
diff --git a/qobject/qdict.c b/qobject/qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/qdict.c
+++ b/qobject/qdict.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
-#include "block/qdict.h"
 #include "qapi/qmp/qnum.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qbool.h"
-#include "qapi/qmp/qlist.h"
 #include "qapi/qmp/qnull.h"
 #include "qapi/qmp/qstring.h"
-#include "qapi/error.h"
-#include "qemu/queue.h"
-#include "qemu-common.h"
-#include "qemu/cutils.h"
 
 /**
  * qdict_new(): Create a new QDict
@@ -XXX,XX +XXX,XX @@ void qdict_destroy_obj(QObject *obj)
 
     g_free(qdict);
 }
-
-/**
- * qdict_copy_default(): If no entry mapped by 'key' exists in 'dst' yet, the
- * value of 'key' in 'src' is copied there (and the refcount increased
- * accordingly).
- */
-void qdict_copy_default(QDict *dst, QDict *src, const char *key)
-{
-    QObject *val;
-
-    if (qdict_haskey(dst, key)) {
-        return;
-    }
-
-    val = qdict_get(src, key);
-    if (val) {
-        qdict_put_obj(dst, key, qobject_ref(val));
-    }
-}
-
-/**
- * qdict_set_default_str(): If no entry mapped by 'key' exists in 'dst' yet, a
- * new QString initialised by 'val' is put there.
- */
-void qdict_set_default_str(QDict *dst, const char *key, const char *val)
-{
-    if (qdict_haskey(dst, key)) {
-        return;
-    }
-
-    qdict_put_str(dst, key, val);
-}
-
-static void qdict_flatten_qdict(QDict *qdict, QDict *target,
-                                const char *prefix);
-
-static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
-{
-    QObject *value;
-    const QListEntry *entry;
-    char *new_key;
-    int i;
-
-    /* This function is never called with prefix == NULL, i.e., it is always
-     * called from within qdict_flatten_q(list|dict)(). Therefore, it does not
-     * need to remove list entries during the iteration (the whole list will be
-     * deleted eventually anyway from qdict_flatten_qdict()). */
-    assert(prefix);
-
-    entry = qlist_first(qlist);
-
-    for (i = 0; entry; entry = qlist_next(entry), i++) {
-        value = qlist_entry_obj(entry);
-        new_key = g_strdup_printf("%s.%i", prefix, i);
-
-        if (qobject_type(value) == QTYPE_QDICT) {
-            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
-        } else if (qobject_type(value) == QTYPE_QLIST) {
-            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
-        } else {
-            /* All other types are moved to the target unchanged. */
-            qdict_put_obj(target, new_key, qobject_ref(value));
-        }
-
-        g_free(new_key);
-    }
-}
-
-static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
-{
-    QObject *value;
-    const QDictEntry *entry, *next;
-    char *new_key;
-    bool delete;
-
-    entry = qdict_first(qdict);
-
-    while (entry != NULL) {
-
-        next = qdict_next(qdict, entry);
-        value = qdict_entry_value(entry);
-        new_key = NULL;
-        delete = false;
-
-        if (prefix) {
-            new_key = g_strdup_printf("%s.%s", prefix, entry->key);
-        }
-
-        if (qobject_type(value) == QTYPE_QDICT) {
-            /* Entries of QDicts are processed recursively, the QDict object
-             * itself disappears. */
-            qdict_flatten_qdict(qobject_to(QDict, value), target,
-                                new_key ? new_key : entry->key);
-            delete = true;
-        } else if (qobject_type(value) == QTYPE_QLIST) {
-            qdict_flatten_qlist(qobject_to(QList, value), target,
-                                new_key ? new_key : entry->key);
-            delete = true;
-        } else if (prefix) {
-            /* All other objects are moved to the target unchanged. */
-            qdict_put_obj(target, new_key, qobject_ref(value));
-            delete = true;
-        }
-
-        g_free(new_key);
-
-        if (delete) {
-            qdict_del(qdict, entry->key);
-
-            /* Restart loop after modifying the iterated QDict */
-            entry = qdict_first(qdict);
-            continue;
-        }
-
-        entry = next;
-    }
-}
-
-/**
- * qdict_flatten(): For each nested QDict with key x, all fields with key y
- * are moved to this QDict and their key is renamed to "x.y". For each nested
- * QList with key x, the field at index y is moved to this QDict with the key
- * "x.y" (i.e., the reverse of what qdict_array_split() does).
- * This operation is applied recursively for nested QDicts and QLists.
- */
-void qdict_flatten(QDict *qdict)
-{
-    qdict_flatten_qdict(qdict, qdict, NULL);
-}
-
-/* extract all the src QDict entries starting by start into dst */
-void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start)
-
-{
-    const QDictEntry *entry, *next;
-    const char *p;
-
-    *dst = qdict_new();
-    entry = qdict_first(src);
-
-    while (entry != NULL) {
-        next = qdict_next(src, entry);
-        if (strstart(entry->key, start, &p)) {
-            qdict_put_obj(*dst, p, qobject_ref(entry->value));
-            qdict_del(src, entry->key);
-        }
-        entry = next;
-    }
-}
-
-static int qdict_count_prefixed_entries(const QDict *src, const char *start)
-{
-    const QDictEntry *entry;
-    int count = 0;
-
-    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
-        if (strstart(entry->key, start, NULL)) {
-            if (count == INT_MAX) {
-                return -ERANGE;
-            }
-            count++;
-        }
-    }
-
-    return count;
-}
-
-/**
- * qdict_array_split(): This function moves array-like elements of a QDict into
- * a new QList. Every entry in the original QDict with a key "%u" or one
- * prefixed "%u.", where %u designates an unsigned integer starting at 0 and
- * incrementally counting up, will be moved to a new QDict at index %u in the
- * output QList with the key prefix removed, if that prefix is "%u.". If the
- * whole key is just "%u", the whole QObject will be moved unchanged without
- * creating a new QDict. The function terminates when there is no entry in the
- * QDict with a prefix directly (incrementally) following the last one; it also
- * returns if there are both entries with "%u" and "%u." for the same index %u.
- * Example: {"0.a": 42, "0.b": 23, "1.x": 0, "4.y": 1, "o.o": 7, "2": 66}
- *      (or {"1.x": 0, "4.y": 1, "0.a": 42, "o.o": 7, "0.b": 23, "2": 66})
- *       => [{"a": 42, "b": 23}, {"x": 0}, 66]
- *      and {"4.y": 1, "o.o": 7} (remainder of the old QDict)
- */
-void qdict_array_split(QDict *src, QList **dst)
-{
-    unsigned i;
-
-    *dst = qlist_new();
-
-    for (i = 0; i < UINT_MAX; i++) {
-        QObject *subqobj;
-        bool is_subqdict;
-        QDict *subqdict;
-        char indexstr[32], prefix[32];
-        size_t snprintf_ret;
-
-        snprintf_ret = snprintf(indexstr, 32, "%u", i);
-        assert(snprintf_ret < 32);
-
-        subqobj = qdict_get(src, indexstr);
-
-        snprintf_ret = snprintf(prefix, 32, "%u.", i);
-        assert(snprintf_ret < 32);
-
-        /* Overflow is the same as positive non-zero results */
-        is_subqdict = qdict_count_prefixed_entries(src, prefix);
-
-        // There may be either a single subordinate object (named "%u") or
-        // multiple objects (each with a key prefixed "%u."), but not both.
-        if (!subqobj == !is_subqdict) {
-            break;
-        }
-
-        if (is_subqdict) {
-            qdict_extract_subqdict(src, &subqdict, prefix);
-            assert(qdict_size(subqdict) > 0);
-        } else {
-            qobject_ref(subqobj);
-            qdict_del(src, indexstr);
-        }
-
-        qlist_append_obj(*dst, subqobj ?: QOBJECT(subqdict));
-    }
-}
-
-/**
- * qdict_split_flat_key:
- * @key: the key string to split
- * @prefix: non-NULL pointer to hold extracted prefix
- * @suffix: non-NULL pointer to remaining suffix
- *
- * Given a flattened key such as 'foo.0.bar', split it into two parts
- * at the first '.' separator. Allows double dot ('..') to escape the
- * normal separator.
- *
- * e.g.
- *    'foo.0.bar' -> prefix='foo' and suffix='0.bar'
- *    'foo..0.bar' -> prefix='foo.0' and suffix='bar'
- *
- * The '..' sequence will be unescaped in the returned 'prefix'
- * string. The 'suffix' string will be left in escaped format, so it
- * can be fed back into the qdict_split_flat_key() key as the input
- * later.
- *
- * The caller is responsible for freeing the string returned in @prefix
- * using g_free().
- */
-static void qdict_split_flat_key(const char *key, char **prefix,
-                                 const char **suffix)
-{
-    const char *separator;
-    size_t i, j;
-
-    /* Find first '.' separator, but if there is a pair '..'
-     * that acts as an escape, so skip over '..' */
-    separator = NULL;
-    do {
-        if (separator) {
-            separator += 2;
-        } else {
-            separator = key;
-        }
-        separator = strchr(separator, '.');
-    } while (separator && separator[1] == '.');
-
-    if (separator) {
-        *prefix = g_strndup(key, separator - key);
-        *suffix = separator + 1;
-    } else {
-        *prefix = g_strdup(key);
-        *suffix = NULL;
-    }
-
-    /* Unescape the '..' sequence into '.' */
-    for (i = 0, j = 0; (*prefix)[i] != '\0'; i++, j++) {
-        if ((*prefix)[i] == '.') {
-            assert((*prefix)[i + 1] == '.');
-            i++;
-        }
-        (*prefix)[j] = (*prefix)[i];
-    }
-    (*prefix)[j] = '\0';
-}
-
-/**
- * qdict_is_list:
- * @maybe_list: dict to check if keys represent list elements.
- *
- * Determine whether all keys in @maybe_list are valid list elements.
- * If @maybe_list is non-zero in length and all the keys look like
- * valid list indexes, this will return 1. If @maybe_list is zero
- * length or all keys are non-numeric then it will return 0 to indicate
- * it is a normal qdict. If there is a mix of numeric and non-numeric
- * keys, or the list indexes are non-contiguous, an error is reported.
- *
- * Returns: 1 if a valid list, 0 if a dict, -1 on error
- */
-static int qdict_is_list(QDict *maybe_list, Error **errp)
-{
-    const QDictEntry *ent;
-    ssize_t len = 0;
-    ssize_t max = -1;
-    int is_list = -1;
-    int64_t val;
-
-    for (ent = qdict_first(maybe_list); ent != NULL;
-         ent = qdict_next(maybe_list, ent)) {
-
-        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
-            if (is_list == -1) {
-                is_list = 1;
-            } else if (!is_list) {
-                error_setg(errp,
-                           "Cannot mix list and non-list keys");
-                return -1;
-            }
-            len++;
-            if (val > max) {
-                max = val;
-            }
-        } else {
-            if (is_list == -1) {
-                is_list = 0;
-            } else if (is_list) {
-                error_setg(errp,
-                           "Cannot mix list and non-list keys");
-                return -1;
-            }
-        }
-    }
-
-    if (is_list == -1) {
-        assert(!qdict_size(maybe_list));
-        is_list = 0;
-    }
-
-    /* NB this isn't a perfect check - e.g. it won't catch
-     * a list containing '1', '+1', '01', '3', but that
-     * does not matter - we've still proved that the
-     * input is a list. It is up the caller to do a
-     * stricter check if desired */
-    if (len != (max + 1)) {
-        error_setg(errp, "List indices are not contiguous, "
-                   "saw %zd elements but %zd largest index",
-                   len, max);
-        return -1;
-    }
-
-    return is_list;
-}
-
-/**
- * qdict_crumple:
- * @src: the original flat dictionary (only scalar values) to crumple
- *
- * Takes a flat dictionary whose keys use '.' separator to indicate
- * nesting, and values are scalars, and crumples it into a nested
- * structure.
- *
- * To include a literal '.' in a key name, it must be escaped as '..'
- *
- * For example, an input of:
- *
- * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
- *   'foo.1.bar': 'two', 'foo.1.wizz': '2' }
- *
- * will result in an output of:
- *
- * {
- *   'foo': [
- *      { 'bar': 'one', 'wizz': '1' },
- *      { 'bar': 'two', 'wizz': '2' }
- *   ],
- * }
- *
- * The following scenarios in the input dict will result in an
- * error being returned:
- *
- *  - Any values in @src are non-scalar types
- *  - If keys in @src imply that a particular level is both a
- *    list and a dict. e.g., "foo.0.bar" and "foo.eek.bar".
- *  - If keys in @src imply that a particular level is a list,
- *    but the indices are non-contiguous. e.g. "foo.0.bar" and
- *    "foo.2.bar" without any "foo.1.bar" present.
- *  - If keys in @src represent list indexes, but are not in
- *    the "%zu" format. e.g. "foo.+0.bar"
- *
- * Returns: either a QDict or QList for the nested data structure, or NULL
- * on error
- */
-QObject *qdict_crumple(const QDict *src, Error **errp)
-{
-    const QDictEntry *ent;
-    QDict *two_level, *multi_level = NULL;
-    QObject *dst = NULL, *child;
-    size_t i;
-    char *prefix = NULL;
-    const char *suffix = NULL;
-    int is_list;
-
-    two_level = qdict_new();
-
-    /* Step 1: split our totally flat dict into a two level dict */
-    for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
-        if (qobject_type(ent->value) == QTYPE_QDICT ||
-            qobject_type(ent->value) == QTYPE_QLIST) {
-            error_setg(errp, "Value %s is not a scalar",
-                       ent->key);
-            goto error;
-        }
-
-        qdict_split_flat_key(ent->key, &prefix, &suffix);
-
-        child = qdict_get(two_level, prefix);
-        if (suffix) {
-            QDict *child_dict = qobject_to(QDict, child);
-            if (!child_dict) {
-                if (child) {
-                    error_setg(errp, "Key %s prefix is already set as a scalar",
-                               prefix);
-                    goto error;
-                }
-
-                child_dict = qdict_new();
-                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
-            }
-
-            qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
-        } else {
-            if (child) {
-                error_setg(errp, "Key %s prefix is already set as a dict",
-                           prefix);
-                goto error;
-            }
-            qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
-        }
-
-        g_free(prefix);
-        prefix = NULL;
-    }
-
-    /* Step 2: optionally process the two level dict recursively
-     * into a multi-level dict */
-    multi_level = qdict_new();
-    for (ent = qdict_first(two_level); ent != NULL;
-         ent = qdict_next(two_level, ent)) {
-        QDict *dict = qobject_to(QDict, ent->value);
-        if (dict) {
-            child = qdict_crumple(dict, errp);
-            if (!child) {
-                goto error;
-            }
-
-            qdict_put_obj(multi_level, ent->key, child);
-        } else {
-            qdict_put_obj(multi_level, ent->key, qobject_ref(ent->value));
-        }
-    }
-    qobject_unref(two_level);
-    two_level = NULL;
-
-    /* Step 3: detect if we need to turn our dict into list */
-    is_list = qdict_is_list(multi_level, errp);
-    if (is_list < 0) {
-        goto error;
-    }
-
-    if (is_list) {
-        dst = QOBJECT(qlist_new());
-
-        for (i = 0; i < qdict_size(multi_level); i++) {
-            char *key = g_strdup_printf("%zu", i);
-
-            child = qdict_get(multi_level, key);
-            g_free(key);
-
-            if (!child) {
-                error_setg(errp, "Missing list index %zu", i);
-                goto error;
-            }
-
-            qlist_append_obj(qobject_to(QList, dst), qobject_ref(child));
-        }
-        qobject_unref(multi_level);
-        multi_level = NULL;
-    } else {
-        dst = QOBJECT(multi_level);
-    }
-
-    return dst;
-
- error:
-    g_free(prefix);
-    qobject_unref(multi_level);
-    qobject_unref(two_level);
-    qobject_unref(dst);
-    return NULL;
-}
-
-/**
- * qdict_array_entries(): Returns the number of direct array entries if the
- * sub-QDict of src specified by the prefix in subqdict (or src itself for
- * prefix == "") is valid as an array, i.e. the length of the created list if
- * the sub-QDict would become empty after calling qdict_array_split() on it. If
- * the array is not valid, -EINVAL is returned.
- */
-int qdict_array_entries(QDict *src, const char *subqdict)
-{
-    const QDictEntry *entry;
-    unsigned i;
-    unsigned entries = 0;
-    size_t subqdict_len = strlen(subqdict);
-
-    assert(!subqdict_len || subqdict[subqdict_len - 1] == '.');
-
-    /* qdict_array_split() loops until UINT_MAX, but as we want to return
-     * negative errors, we only have a signed return value here. Any additional
-     * entries will lead to -EINVAL. */
-    for (i = 0; i < INT_MAX; i++) {
-        QObject *subqobj;
-        int subqdict_entries;
-        char *prefix = g_strdup_printf("%s%u.", subqdict, i);
-
-        subqdict_entries = qdict_count_prefixed_entries(src, prefix);
-
-        /* Remove ending "." */
-        prefix[strlen(prefix) - 1] = 0;
-        subqobj = qdict_get(src, prefix);
-
-        g_free(prefix);
-
-        if (subqdict_entries < 0) {
-            return subqdict_entries;
-        }
-
-        /* There may be either a single subordinate object (named "%u") or
-         * multiple objects (each with a key prefixed "%u."), but not both. */
-        if (subqobj && subqdict_entries) {
-            return -EINVAL;
-        } else if (!subqobj && !subqdict_entries) {
-            break;
-        }
-
-        entries += subqdict_entries ? subqdict_entries : 1;
-    }
-
-    /* Consider everything handled that isn't part of the given sub-QDict */
-    for (entry = qdict_first(src); entry; entry = qdict_next(src, entry)) {
-        if (!strstart(qdict_entry_key(entry), subqdict, NULL)) {
-            entries++;
-        }
-    }
-
-    /* Anything left in the sub-QDict that wasn't handled? */
-    if (qdict_size(src) != entries) {
-        return -EINVAL;
-    }
-
-    return i;
-}
-
-/**
- * qdict_join(): Absorb the src QDict into the dest QDict, that is, move all
- * elements from src to dest.
- *
- * If an element from src has a key already present in dest, it will not be
- * moved unless overwrite is true.
- *
- * If overwrite is true, the conflicting values in dest will be discarded and
- * replaced by the corresponding values from src.
- *
- * Therefore, with overwrite being true, the src QDict will always be empty when
- * this function returns. If overwrite is false, the src QDict will be empty
- * iff there were no conflicts.
- */
-void qdict_join(QDict *dest, QDict *src, bool overwrite)
-{
-    const QDictEntry *entry, *next;
-
-    entry = qdict_first(src);
-    while (entry) {
-        next = qdict_next(src, entry);
-
-        if (overwrite || !qdict_haskey(dest, entry->key)) {
-            qdict_put_obj(dest, entry->key, qobject_ref(entry->value));
-            qdict_del(src, entry->key);
-        }
-
-        entry = next;
-    }
-}
-
-/**
- * qdict_rename_keys(): Rename keys in qdict according to the replacements
- * specified in the array renames. The array must be terminated by an entry
- * with from = NULL.
- *
- * The renames are performed individually in the order of the array, so entries
- * may be renamed multiple times and may or may not conflict depending on the
- * order of the renames array.
- *
- * Returns true for success, false in error cases.
- */
-bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
-{
-    QObject *qobj;
-
-    while (renames->from) {
-        if (qdict_haskey(qdict, renames->from)) {
-            if (qdict_haskey(qdict, renames->to)) {
-                error_setg(errp, "'%s' and its alias '%s' can't be used at the "
-                           "same time", renames->to, renames->from);
-                return false;
-            }
-
-            qobj = qdict_get(qdict, renames->from);
-            qdict_put_obj(qdict, renames->to, qobject_ref(qobj));
-            qdict_del(qdict, renames->from);
-        }
-
-        renames++;
-    }
-    return true;
-}
diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/check-block-qdict.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Unit-tests for Block layer QDict extras
+ *
+ * Copyright (c) 2013-2018 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "block/qdict.h"
+#include "qapi/qmp/qlist.h"
+#include "qapi/qmp/qnum.h"
+#include "qapi/error.h"
+
+static void qdict_defaults_test(void)
+{
+    QDict *dict, *copy;
+
+    dict = qdict_new();
+    copy = qdict_new();
+
+    qdict_set_default_str(dict, "foo", "abc");
+    qdict_set_default_str(dict, "foo", "def");
+    g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
+    qdict_set_default_str(dict, "bar", "ghi");
+
+    qdict_copy_default(copy, dict, "foo");
+    g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
+    qdict_set_default_str(copy, "bar", "xyz");
+    qdict_copy_default(copy, dict, "bar");
+    g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
+
+    qobject_unref(copy);
+    qobject_unref(dict);
+}
+
+static void qdict_flatten_test(void)
+{
+    QList *list1 = qlist_new();
+    QList *list2 = qlist_new();
+    QDict *dict1 = qdict_new();
+    QDict *dict2 = qdict_new();
+    QDict *dict3 = qdict_new();
+
+    /*
+     * Test the flattening of
+     *
+     * {
+     *     "e": [
+     *         42,
+     *         [
+     *             23,
+     *             66,
+     *             {
+     *                 "a": 0,
+     *                 "b": 1
+     *             }
+     *         ]
+     *     ],
+     *     "f": {
+     *         "c": 2,
+     *         "d": 3,
+     *     },
+     *     "g": 4
+     * }
+     *
+     * to
+     *
+     * {
+     *     "e.0": 42,
+     *     "e.1.0": 23,
+     *     "e.1.1": 66,
+     *     "e.1.2.a": 0,
+     *     "e.1.2.b": 1,
+     *     "f.c": 2,
+     *     "f.d": 3,
+     *     "g": 4
+     * }
+     */
+
+    qdict_put_int(dict1, "a", 0);
+    qdict_put_int(dict1, "b", 1);
+
+    qlist_append_int(list1, 23);
+    qlist_append_int(list1, 66);
+    qlist_append(list1, dict1);
+    qlist_append_int(list2, 42);
+    qlist_append(list2, list1);
+
+    qdict_put_int(dict2, "c", 2);
+    qdict_put_int(dict2, "d", 3);
+    qdict_put(dict3, "e", list2);
+    qdict_put(dict3, "f", dict2);
+    qdict_put_int(dict3, "g", 4);
+
+    qdict_flatten(dict3);
+
+    g_assert(qdict_get_int(dict3, "e.0") == 42);
+    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
+    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
+    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
+    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
+    g_assert(qdict_get_int(dict3, "f.c") == 2);
+    g_assert(qdict_get_int(dict3, "f.d") == 3);
+    g_assert(qdict_get_int(dict3, "g") == 4);
+
+    g_assert(qdict_size(dict3) == 8);
+
+    qobject_unref(dict3);
+}
+
+static void qdict_array_split_test(void)
+{
+    QDict *test_dict = qdict_new();
+    QDict *dict1, *dict2;
+    QNum *int1;
+    QList *test_list;
+
+    /*
+     * Test the split of
+     *
+     * {
+     *     "1.x": 0,
+     *     "4.y": 1,
+     *     "0.a": 42,
+     *     "o.o": 7,
+     *     "0.b": 23,
+     *     "2": 66
+     * }
+     *
+     * to
+     *
+     * [
+     *     {
+     *         "a": 42,
+     *         "b": 23
+     *     },
+     *     {
+     *         "x": 0
+     *     },
+     *     66
+     * ]
+     *
+     * and
+     *
+     * {
+     *     "4.y": 1,
+     *     "o.o": 7
+     * }
+     *
+     * (remaining in the old QDict)
+     *
+     * This example is given in the comment of qdict_array_split().
+     */
+
+    qdict_put_int(test_dict, "1.x", 0);
+    qdict_put_int(test_dict, "4.y", 1);
+    qdict_put_int(test_dict, "0.a", 42);
+    qdict_put_int(test_dict, "o.o", 7);
+    qdict_put_int(test_dict, "0.b", 23);
+    qdict_put_int(test_dict, "2", 66);
+
+    qdict_array_split(test_dict, &test_list);
+
+    dict1 = qobject_to(QDict, qlist_pop(test_list));
+    dict2 = qobject_to(QDict, qlist_pop(test_list));
+    int1 = qobject_to(QNum, qlist_pop(test_list));
+
+    g_assert(dict1);
+    g_assert(dict2);
+    g_assert(int1);
+    g_assert(qlist_empty(test_list));
+
+    qobject_unref(test_list);
+
+    g_assert(qdict_get_int(dict1, "a") == 42);
+    g_assert(qdict_get_int(dict1, "b") == 23);
+
+    g_assert(qdict_size(dict1) == 2);
+
+    qobject_unref(dict1);
+
+    g_assert(qdict_get_int(dict2, "x") == 0);
+
+    g_assert(qdict_size(dict2) == 1);
+
+    qobject_unref(dict2);
+
+    g_assert_cmpint(qnum_get_int(int1), ==, 66);
+
+    qobject_unref(int1);
+
+    g_assert(qdict_get_int(test_dict, "4.y") == 1);
+    g_assert(qdict_get_int(test_dict, "o.o") == 7);
+
+    g_assert(qdict_size(test_dict) == 2);
+
+    qobject_unref(test_dict);
+
+    /*
+     * Test the split of
+     *
+     * {
+     *     "0": 42,
+     *     "1": 23,
+     *     "1.x": 84
+     * }
+     *
+     * to
+     *
+     * [
+     *     42
+     * ]
+     *
+     * and
+     *
+     * {
+     *     "1": 23,
+     *     "1.x": 84
+     * }
+     *
+     * That is, test whether splitting stops if there is both an entry with key
+     * of "%u" and other entries with keys prefixed "%u." for the same index.
+     */
+
+    test_dict = qdict_new();
+
+    qdict_put_int(test_dict, "0", 42);
+    qdict_put_int(test_dict, "1", 23);
+    qdict_put_int(test_dict, "1.x", 84);
+
+    qdict_array_split(test_dict, &test_list);
+
+    int1 = qobject_to(QNum, qlist_pop(test_list));
+
+    g_assert(int1);
+    g_assert(qlist_empty(test_list));
+
+    qobject_unref(test_list);
+
+    g_assert_cmpint(qnum_get_int(int1), ==, 42);
+
+    qobject_unref(int1);
+
+    g_assert(qdict_get_int(test_dict, "1") == 23);
+    g_assert(qdict_get_int(test_dict, "1.x") == 84);
+
+    g_assert(qdict_size(test_dict) == 2);
+
+    qobject_unref(test_dict);
+}
+
+static void qdict_array_entries_test(void)
+{
+    QDict *dict = qdict_new();
+
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
+
+    qdict_put_int(dict, "bar", 0);
+    qdict_put_int(dict, "baz.0", 0);
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
+
+    qdict_put_int(dict, "foo.1", 0);
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
+    qdict_put_int(dict, "foo.0", 0);
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
+    qdict_put_int(dict, "foo.bar", 0);
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
+    qdict_del(dict, "foo.bar");
+
+    qdict_put_int(dict, "foo.2.a", 0);
+    qdict_put_int(dict, "foo.2.b", 0);
+    qdict_put_int(dict, "foo.2.c", 0);
+    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
+    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
+
+    qobject_unref(dict);
+
+    dict = qdict_new();
+    qdict_put_int(dict, "1", 0);
+    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
+    qdict_put_int(dict, "0", 0);
+    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
+    qdict_put_int(dict, "bar", 0);
+    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
+    qdict_del(dict, "bar");
+
+    qdict_put_int(dict, "2.a", 0);
+    qdict_put_int(dict, "2.b", 0);
+    qdict_put_int(dict, "2.c", 0);
+    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
+
+    qobject_unref(dict);
+}
+
+static void qdict_join_test(void)
+{
+    QDict *dict1, *dict2;
+    bool overwrite = false;
+    int i;
+
+    dict1 = qdict_new();
+    dict2 = qdict_new();
+
+    /* Test everything once without overwrite and once with */
+    do {
+        /* Test empty dicts */
+        qdict_join(dict1, dict2, overwrite);
+
+        g_assert(qdict_size(dict1) == 0);
+        g_assert(qdict_size(dict2) == 0);
+
+        /* First iteration: Test movement */
+        /* Second iteration: Test empty source and non-empty destination */
+        qdict_put_int(dict2, "foo", 42);
+
+        for (i = 0; i < 2; i++) {
+            qdict_join(dict1, dict2, overwrite);
+
+            g_assert(qdict_size(dict1) == 1);
+            g_assert(qdict_size(dict2) == 0);
+
+            g_assert(qdict_get_int(dict1, "foo") == 42);
+        }
+
+        /* Test non-empty source and destination without conflict */
+        qdict_put_int(dict2, "bar", 23);
+
+        qdict_join(dict1, dict2, overwrite);
+
+        g_assert(qdict_size(dict1) == 2);
+        g_assert(qdict_size(dict2) == 0);
+
+        g_assert(qdict_get_int(dict1, "foo") == 42);
+        g_assert(qdict_get_int(dict1, "bar") == 23);
+
+        /* Test conflict */
+        qdict_put_int(dict2, "foo", 84);
+
+        qdict_join(dict1, dict2, overwrite);
+
+        g_assert(qdict_size(dict1) == 2);
+        g_assert(qdict_size(dict2) == !overwrite);
+
+        g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
+        g_assert(qdict_get_int(dict1, "bar") == 23);
+
+        if (!overwrite) {
+            g_assert(qdict_get_int(dict2, "foo") == 84);
+        }
+
+        /* Check the references */
+        g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
+        g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
+
+        if (!overwrite) {
+            g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
+        }
+
+        /* Clean up */
+        qdict_del(dict1, "foo");
+        qdict_del(dict1, "bar");
+
+        if (!overwrite) {
+            qdict_del(dict2, "foo");
+        }
+    } while (overwrite ^= true);
+
+    qobject_unref(dict1);
+    qobject_unref(dict2);
+}
+
+static void qdict_crumple_test_recursive(void)
+{
+    QDict *src, *dst, *rule, *vnc, *acl, *listen;
+    QList *rules;
+
+    src = qdict_new();
+    qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
+    qdict_put_str(src, "vnc.listen.port", "5901");
+    qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
+    qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
+    qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
+    qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
+    qdict_put_str(src, "vnc.acl.default", "deny");
+    qdict_put_str(src, "vnc.acl..name", "acl0");
+    qdict_put_str(src, "vnc.acl.rule..name", "acl0");
+
+    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
+    g_assert(dst);
+    g_assert_cmpint(qdict_size(dst), ==, 1);
+
+    vnc = qdict_get_qdict(dst, "vnc");
+    g_assert(vnc);
+    g_assert_cmpint(qdict_size(vnc), ==, 3);
+
+    listen = qdict_get_qdict(vnc, "listen");
+    g_assert(listen);
+    g_assert_cmpint(qdict_size(listen), ==, 2);
+    g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
+    g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
+
+    acl = qdict_get_qdict(vnc, "acl");
+    g_assert(acl);
+    g_assert_cmpint(qdict_size(acl), ==, 3);
+
+    rules = qdict_get_qlist(acl, "rules");
+    g_assert(rules);
+    g_assert_cmpint(qlist_size(rules), ==, 2);
+
+    rule = qobject_to(QDict, qlist_pop(rules));
+    g_assert(rule);
+    g_assert_cmpint(qdict_size(rule), ==, 2);
+    g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
+    g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
+    qobject_unref(rule);
+
+    rule = qobject_to(QDict, qlist_pop(rules));
+    g_assert(rule);
+    g_assert_cmpint(qdict_size(rule), ==, 2);
+    g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
+    g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
+    qobject_unref(rule);
+
+    /* With recursive crumpling, we should see all names unescaped */
+    g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
+    g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
+
+    qobject_unref(src);
+    qobject_unref(dst);
+}
+
+static void qdict_crumple_test_empty(void)
+{
+    QDict *src, *dst;
+
+    src = qdict_new();
+
+    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
+
+    g_assert_cmpint(qdict_size(dst), ==, 0);
+
+    qobject_unref(src);
+    qobject_unref(dst);
+}
+
+static int qdict_count_entries(QDict *dict)
+{
+    const QDictEntry *e;
+    int count = 0;
+
+    for (e = qdict_first(dict); e; e = qdict_next(dict, e)) {
+        count++;
+    }
+
+    return count;
+}
+
+static void qdict_rename_keys_test(void)
+{
+    QDict *dict = qdict_new();
+    QDict *copy;
+    QDictRenames *renames;
+    Error *local_err = NULL;
+
+    qdict_put_str(dict, "abc", "foo");
+    qdict_put_str(dict, "abcdef", "bar");
+    qdict_put_int(dict, "number", 42);
+    qdict_put_bool(dict, "flag", true);
+    qdict_put_null(dict, "nothing");
+
+    /* Empty rename list */
+    renames = (QDictRenames[]) {
+        { NULL, "this can be anything" }
+    };
+    copy = qdict_clone_shallow(dict);
+    qdict_rename_keys(copy, renames, &error_abort);
+
+    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
+    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
+    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
+    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
+    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
+    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
+
+    qobject_unref(copy);
+
+    /* Simple rename of all entries */
+    renames = (QDictRenames[]) {
+        { "abc",        "str1" },
+        { "abcdef",     "str2" },
+        { "number",     "int" },
+        { "flag",       "bool" },
+        { "nothing",    "null" },
+        { NULL , NULL }
+    };
+    copy = qdict_clone_shallow(dict);
+    qdict_rename_keys(copy, renames, &error_abort);
+
+    g_assert(!qdict_haskey(copy, "abc"));
+    g_assert(!qdict_haskey(copy, "abcdef"));
+    g_assert(!qdict_haskey(copy, "number"));
+    g_assert(!qdict_haskey(copy, "flag"));
+    g_assert(!qdict_haskey(copy, "nothing"));
+
+    g_assert_cmpstr(qdict_get_str(copy, "str1"), ==, "foo");
+    g_assert_cmpstr(qdict_get_str(copy, "str2"), ==, "bar");
+    g_assert_cmpint(qdict_get_int(copy, "int"), ==, 42);
+    g_assert_cmpint(qdict_get_bool(copy, "bool"), ==, true);
+    g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
+    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
+
+    qobject_unref(copy);
+
+    /* Renames are processed top to bottom */
+    renames = (QDictRenames[]) {
+        { "abc",        "tmp" },
+        { "abcdef",     "abc" },
+        { "number",     "abcdef" },
+        { "flag",       "number" },
+        { "nothing",    "flag" },
+        { "tmp",        "nothing" },
+        { NULL , NULL }
+    };
+    copy = qdict_clone_shallow(dict);
+    qdict_rename_keys(copy, renames, &error_abort);
+
+    g_assert_cmpstr(qdict_get_str(copy, "nothing"), ==, "foo");
+    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "bar");
+    g_assert_cmpint(qdict_get_int(copy, "abcdef"), ==, 42);
+    g_assert_cmpint(qdict_get_bool(copy, "number"), ==, true);
+    g_assert(qobject_type(qdict_get(copy, "flag")) == QTYPE_QNULL);
+    g_assert(!qdict_haskey(copy, "tmp"));
+    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
+
+    qobject_unref(copy);
+
+    /* Conflicting rename */
+    renames = (QDictRenames[]) {
+        { "abcdef",     "abc" },
+        { NULL , NULL }
+    };
+    copy = qdict_clone_shallow(dict);
+    qdict_rename_keys(copy, renames, &local_err);
+
+    g_assert(local_err != NULL);
+    error_free(local_err);
+    local_err = NULL;
+
+    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
+    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
+    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
+    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
+    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
+    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
+
+    qobject_unref(copy);
+
+    /* Renames in an empty dict */
+    renames = (QDictRenames[]) {
+        { "abcdef",     "abc" },
+        { NULL , NULL }
+    };
+
+    qobject_unref(dict);
+    dict = qdict_new();
+
+    qdict_rename_keys(dict, renames, &error_abort);
+    g_assert(qdict_first(dict) == NULL);
+
+    qobject_unref(dict);
+}
+
+static void qdict_crumple_test_bad_inputs(void)
+{
+    QDict *src;
+    Error *error = NULL;
+
+    src = qdict_new();
+    /* rule.0 can't be both a string and a dict */
+    qdict_put_str(src, "rule.0", "fred");
+    qdict_put_str(src, "rule.0.policy", "allow");
+
+    g_assert(qdict_crumple(src, &error) == NULL);
+    g_assert(error != NULL);
+    error_free(error);
+    error = NULL;
+    qobject_unref(src);
+
+    src = qdict_new();
+    /* rule can't be both a list and a dict */
+    qdict_put_str(src, "rule.0", "fred");
+    qdict_put_str(src, "rule.a", "allow");
+
+    g_assert(qdict_crumple(src, &error) == NULL);
+    g_assert(error != NULL);
+    error_free(error);
+    error = NULL;
+    qobject_unref(src);
+
+    src = qdict_new();
+    /* The input should be flat, ie no dicts or lists */
+    qdict_put(src, "rule.a", qdict_new());
+    qdict_put_str(src, "rule.b", "allow");
+
+    g_assert(qdict_crumple(src, &error) == NULL);
+    g_assert(error != NULL);
+    error_free(error);
+    error = NULL;
+    qobject_unref(src);
+
+    src = qdict_new();
+    /* List indexes must not have gaps */
+    qdict_put_str(src, "rule.0", "deny");
+    qdict_put_str(src, "rule.3", "allow");
+
+    g_assert(qdict_crumple(src, &error) == NULL);
+    g_assert(error != NULL);
+    error_free(error);
+    error = NULL;
+    qobject_unref(src);
+
+    src = qdict_new();
+    /* List indexes must be in %zu format */
+    qdict_put_str(src, "rule.0", "deny");
+    qdict_put_str(src, "rule.+1", "allow");
+
+    g_assert(qdict_crumple(src, &error) == NULL);
+    g_assert(error != NULL);
+    error_free(error);
+    error = NULL;
+    qobject_unref(src);
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+
+    g_test_add_func("/public/defaults", qdict_defaults_test);
+    g_test_add_func("/public/flatten", qdict_flatten_test);
+    g_test_add_func("/public/array_split", qdict_array_split_test);
+    g_test_add_func("/public/array_entries", qdict_array_entries_test);
+    g_test_add_func("/public/join", qdict_join_test);
+    g_test_add_func("/public/crumple/recursive",
+                    qdict_crumple_test_recursive);
+    g_test_add_func("/public/crumple/empty",
+                    qdict_crumple_test_empty);
+    g_test_add_func("/public/crumple/bad_inputs",
+                    qdict_crumple_test_bad_inputs);
+
+    g_test_add_func("/public/rename_keys", qdict_rename_keys_test);
+
+    return g_test_run();
+}
diff --git a/tests/check-qdict.c b/tests/check-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/check-qdict.c
+++ b/tests/check-qdict.c
@@ -XXX,XX +XXX,XX @@
  */
 
 #include "qemu/osdep.h"
-#include "block/qdict.h"
 #include "qapi/qmp/qdict.h"
-#include "qapi/qmp/qlist.h"
-#include "qapi/qmp/qnum.h"
-#include "qapi/qmp/qstring.h"
-#include "qapi/error.h"
-#include "qemu-common.h"
 
 /*
  * Public Interface test-cases
@@ -XXX,XX +XXX,XX @@ static void qdict_get_try_str_test(void)
     qobject_unref(tests_dict);
 }
 
-static void qdict_defaults_test(void)
-{
-    QDict *dict, *copy;
-
-    dict = qdict_new();
-    copy = qdict_new();
-
-    qdict_set_default_str(dict, "foo", "abc");
-    qdict_set_default_str(dict, "foo", "def");
-    g_assert_cmpstr(qdict_get_str(dict, "foo"), ==, "abc");
-    qdict_set_default_str(dict, "bar", "ghi");
-
-    qdict_copy_default(copy, dict, "foo");
-    g_assert_cmpstr(qdict_get_str(copy, "foo"), ==, "abc");
-    qdict_set_default_str(copy, "bar", "xyz");
-    qdict_copy_default(copy, dict, "bar");
-    g_assert_cmpstr(qdict_get_str(copy, "bar"), ==, "xyz");
-
-    qobject_unref(copy);
-    qobject_unref(dict);
-}
-
 static void qdict_haskey_not_test(void)
 {
     QDict *tests_dict = qdict_new();
@@ -XXX,XX +XXX,XX @@ static void qdict_iterapi_test(void)
     qobject_unref(tests_dict);
 }
 
-static void qdict_flatten_test(void)
-{
-    QList *list1 = qlist_new();
-    QList *list2 = qlist_new();
-    QDict *dict1 = qdict_new();
-    QDict *dict2 = qdict_new();
-    QDict *dict3 = qdict_new();
-
-    /*
-     * Test the flattening of
-     *
-     * {
-     *     "e": [
-     *         42,
-     *         [
-     *             23,
-     *             66,
-     *             {
-     *                 "a": 0,
-     *                 "b": 1
-     *             }
-     *         ]
-     *     ],
-     *     "f": {
-     *         "c": 2,
-     *         "d": 3,
-     *     },
-     *     "g": 4
-     * }
-     *
-     * to
-     *
-     * {
-     *     "e.0": 42,
-     *     "e.1.0": 23,
-     *     "e.1.1": 66,
-     *     "e.1.2.a": 0,
-     *     "e.1.2.b": 1,
-     *     "f.c": 2,
-     *     "f.d": 3,
-     *     "g": 4
-     * }
-     */
-
-    qdict_put_int(dict1, "a", 0);
-    qdict_put_int(dict1, "b", 1);
-
-    qlist_append_int(list1, 23);
-    qlist_append_int(list1, 66);
-    qlist_append(list1, dict1);
-    qlist_append_int(list2, 42);
-    qlist_append(list2, list1);
-
-    qdict_put_int(dict2, "c", 2);
-    qdict_put_int(dict2, "d", 3);
-    qdict_put(dict3, "e", list2);
-    qdict_put(dict3, "f", dict2);
-    qdict_put_int(dict3, "g", 4);
-
-    qdict_flatten(dict3);
-
-    g_assert(qdict_get_int(dict3, "e.0") == 42);
-    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
-    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
-    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
-    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
-    g_assert(qdict_get_int(dict3, "f.c") == 2);
-    g_assert(qdict_get_int(dict3, "f.d") == 3);
-    g_assert(qdict_get_int(dict3, "g") == 4);
-
-    g_assert(qdict_size(dict3) == 8);
-
-    qobject_unref(dict3);
-}
-
-static void qdict_array_split_test(void)
-{
-    QDict *test_dict = qdict_new();
-    QDict *dict1, *dict2;
-    QNum *int1;
-    QList *test_list;
-
-    /*
-     * Test the split of
-     *
-     * {
-     *     "1.x": 0,
-     *     "4.y": 1,
-     *     "0.a": 42,
-     *     "o.o": 7,
-     *     "0.b": 23,
-     *     "2": 66
-     * }
-     *
-     * to
-     *
-     * [
-     *     {
-     *         "a": 42,
-     *         "b": 23
-     *     },
-     *     {
-     *         "x": 0
-     *     },
-     *     66
-     * ]
-     *
-     * and
-     *
-     * {
-     *     "4.y": 1,
-     *     "o.o": 7
-     * }
-     *
-     * (remaining in the old QDict)
-     *
-     * This example is given in the comment of qdict_array_split().
-     */
-
-    qdict_put_int(test_dict, "1.x", 0);
-    qdict_put_int(test_dict, "4.y", 1);
-    qdict_put_int(test_dict, "0.a", 42);
-    qdict_put_int(test_dict, "o.o", 7);
-    qdict_put_int(test_dict, "0.b", 23);
-    qdict_put_int(test_dict, "2", 66);
-
-    qdict_array_split(test_dict, &test_list);
-
-    dict1 = qobject_to(QDict, qlist_pop(test_list));
-    dict2 = qobject_to(QDict, qlist_pop(test_list));
-    int1 = qobject_to(QNum, qlist_pop(test_list));
-
-    g_assert(dict1);
-    g_assert(dict2);
-    g_assert(int1);
-    g_assert(qlist_empty(test_list));
-
-    qobject_unref(test_list);
-
-    g_assert(qdict_get_int(dict1, "a") == 42);
-    g_assert(qdict_get_int(dict1, "b") == 23);
-
-    g_assert(qdict_size(dict1) == 2);
-
-    qobject_unref(dict1);
-
-    g_assert(qdict_get_int(dict2, "x") == 0);
-
-    g_assert(qdict_size(dict2) == 1);
-
-    qobject_unref(dict2);
-
-    g_assert_cmpint(qnum_get_int(int1), ==, 66);
-
-    qobject_unref(int1);
-
-    g_assert(qdict_get_int(test_dict, "4.y") == 1);
-    g_assert(qdict_get_int(test_dict, "o.o") == 7);
-
-    g_assert(qdict_size(test_dict) == 2);
-
-    qobject_unref(test_dict);
-
-    /*
-     * Test the split of
-     *
-     * {
-     *     "0": 42,
-     *     "1": 23,
-     *     "1.x": 84
-     * }
-     *
-     * to
-     *
-     * [
-     *     42
-     * ]
-     *
-     * and
-     *
-     * {
-     *     "1": 23,
-     *     "1.x": 84
-     * }
-     *
-     * That is, test whether splitting stops if there is both an entry with key
-     * of "%u" and other entries with keys prefixed "%u." for the same index.
-     */
-
-    test_dict = qdict_new();
-
-    qdict_put_int(test_dict, "0", 42);
-    qdict_put_int(test_dict, "1", 23);
-    qdict_put_int(test_dict, "1.x", 84);
-
-    qdict_array_split(test_dict, &test_list);
-
-    int1 = qobject_to(QNum, qlist_pop(test_list));
-
-    g_assert(int1);
-    g_assert(qlist_empty(test_list));
-
-    qobject_unref(test_list);
-
-    g_assert_cmpint(qnum_get_int(int1), ==, 42);
-
-    qobject_unref(int1);
-
-    g_assert(qdict_get_int(test_dict, "1") == 23);
-    g_assert(qdict_get_int(test_dict, "1.x") == 84);
-
-    g_assert(qdict_size(test_dict) == 2);
-
-    qobject_unref(test_dict);
-}
-
-static void qdict_array_entries_test(void)
-{
-    QDict *dict = qdict_new();
-
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
-
-    qdict_put_int(dict, "bar", 0);
-    qdict_put_int(dict, "baz.0", 0);
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 0);
-
-    qdict_put_int(dict, "foo.1", 0);
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
-    qdict_put_int(dict, "foo.0", 0);
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 2);
-    qdict_put_int(dict, "foo.bar", 0);
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, -EINVAL);
-    qdict_del(dict, "foo.bar");
-
-    qdict_put_int(dict, "foo.2.a", 0);
-    qdict_put_int(dict, "foo.2.b", 0);
-    qdict_put_int(dict, "foo.2.c", 0);
-    g_assert_cmpint(qdict_array_entries(dict, "foo."), ==, 3);
-    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
-
-    qobject_unref(dict);
-
-    dict = qdict_new();
-    qdict_put_int(dict, "1", 0);
-    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
-    qdict_put_int(dict, "0", 0);
-    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 2);
-    qdict_put_int(dict, "bar", 0);
-    g_assert_cmpint(qdict_array_entries(dict, ""), ==, -EINVAL);
-    qdict_del(dict, "bar");
-
-    qdict_put_int(dict, "2.a", 0);
-    qdict_put_int(dict, "2.b", 0);
-    qdict_put_int(dict, "2.c", 0);
-    g_assert_cmpint(qdict_array_entries(dict, ""), ==, 3);
-
-    qobject_unref(dict);
-}
-
-static void qdict_join_test(void)
-{
-    QDict *dict1, *dict2;
-    bool overwrite = false;
-    int i;
-
-    dict1 = qdict_new();
-    dict2 = qdict_new();
-
-    /* Test everything once without overwrite and once with */
-    do
-    {
-        /* Test empty dicts */
-        qdict_join(dict1, dict2, overwrite);
-
-        g_assert(qdict_size(dict1) == 0);
-        g_assert(qdict_size(dict2) == 0);
-
-        /* First iteration: Test movement */
-        /* Second iteration: Test empty source and non-empty destination */
-        qdict_put_int(dict2, "foo", 42);
-
-        for (i = 0; i < 2; i++) {
-            qdict_join(dict1, dict2, overwrite);
-
-            g_assert(qdict_size(dict1) == 1);
-            g_assert(qdict_size(dict2) == 0);
-
-            g_assert(qdict_get_int(dict1, "foo") == 42);
-        }
-
-        /* Test non-empty source and destination without conflict */
-        qdict_put_int(dict2, "bar", 23);
-
-        qdict_join(dict1, dict2, overwrite);
-
-        g_assert(qdict_size(dict1) == 2);
-        g_assert(qdict_size(dict2) == 0);
-
-        g_assert(qdict_get_int(dict1, "foo") == 42);
-        g_assert(qdict_get_int(dict1, "bar") == 23);
-
-        /* Test conflict */
-        qdict_put_int(dict2, "foo", 84);
-
-        qdict_join(dict1, dict2, overwrite);
-
-        g_assert(qdict_size(dict1) == 2);
-        g_assert(qdict_size(dict2) == !overwrite);
-
-        g_assert(qdict_get_int(dict1, "foo") == (overwrite ? 84 : 42));
-        g_assert(qdict_get_int(dict1, "bar") == 23);
-
-        if (!overwrite) {
-            g_assert(qdict_get_int(dict2, "foo") == 84);
-        }
-
-        /* Check the references */
-        g_assert(qdict_get(dict1, "foo")->base.refcnt == 1);
-        g_assert(qdict_get(dict1, "bar")->base.refcnt == 1);
-
-        if (!overwrite) {
-            g_assert(qdict_get(dict2, "foo")->base.refcnt == 1);
-        }
-
-        /* Clean up */
-        qdict_del(dict1, "foo");
-        qdict_del(dict1, "bar");
-
-        if (!overwrite) {
-            qdict_del(dict2, "foo");
-        }
-    }
-    while (overwrite ^= true);
-
-    qobject_unref(dict1);
-    qobject_unref(dict2);
-}
-
-static void qdict_crumple_test_recursive(void)
-{
-    QDict *src, *dst, *rule, *vnc, *acl, *listen;
-    QList *rules;
-
-    src = qdict_new();
-    qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
-    qdict_put_str(src, "vnc.listen.port", "5901");
-    qdict_put_str(src, "vnc.acl.rules.0.match", "fred");
-    qdict_put_str(src, "vnc.acl.rules.0.policy", "allow");
-    qdict_put_str(src, "vnc.acl.rules.1.match", "bob");
-    qdict_put_str(src, "vnc.acl.rules.1.policy", "deny");
-    qdict_put_str(src, "vnc.acl.default", "deny");
-    qdict_put_str(src, "vnc.acl..name", "acl0");
-    qdict_put_str(src, "vnc.acl.rule..name", "acl0");
-
-    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
-    g_assert(dst);
-    g_assert_cmpint(qdict_size(dst), ==, 1);
-
-    vnc = qdict_get_qdict(dst, "vnc");
-    g_assert(vnc);
-    g_assert_cmpint(qdict_size(vnc), ==, 3);
-
-    listen = qdict_get_qdict(vnc, "listen");
-    g_assert(listen);
-    g_assert_cmpint(qdict_size(listen), ==, 2);
-    g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
-    g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
-
-    acl = qdict_get_qdict(vnc, "acl");
-    g_assert(acl);
-    g_assert_cmpint(qdict_size(acl), ==, 3);
-
-    rules = qdict_get_qlist(acl, "rules");
-    g_assert(rules);
-    g_assert_cmpint(qlist_size(rules), ==, 2);
-
-    rule = qobject_to(QDict, qlist_pop(rules));
-    g_assert(rule);
-    g_assert_cmpint(qdict_size(rule), ==, 2);
-    g_assert_cmpstr("fred", ==, qdict_get_str(rule, "match"));
-    g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
-    qobject_unref(rule);
-
-    rule = qobject_to(QDict, qlist_pop(rules));
-    g_assert(rule);
-    g_assert_cmpint(qdict_size(rule), ==, 2);
-    g_assert_cmpstr("bob", ==, qdict_get_str(rule, "match"));
-    g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
-    qobject_unref(rule);
-
-    /* With recursive crumpling, we should see all names unescaped */
-    g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
-    g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
-
-    qobject_unref(src);
-    qobject_unref(dst);
-}
-
-static void qdict_crumple_test_empty(void)
-{
-    QDict *src, *dst;
-
-    src = qdict_new();
-
-    dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
-
-    g_assert_cmpint(qdict_size(dst), ==, 0);
-
-    qobject_unref(src);
-    qobject_unref(dst);
-}
-
-static int qdict_count_entries(QDict *dict)
-{
-    const QDictEntry *e;
-    int count = 0;
-
-    for (e = qdict_first(dict); e; e = qdict_next(dict, e)) {
-        count++;
-    }
-
-    return count;
-}
-
-static void qdict_rename_keys_test(void)
-{
-    QDict *dict = qdict_new();
-    QDict *copy;
-    QDictRenames *renames;
-    Error *local_err = NULL;
-
-    qdict_put_str(dict, "abc", "foo");
-    qdict_put_str(dict, "abcdef", "bar");
-    qdict_put_int(dict, "number", 42);
-    qdict_put_bool(dict, "flag", true);
-    qdict_put_null(dict, "nothing");
-
-    /* Empty rename list */
-    renames = (QDictRenames[]) {
-        { NULL, "this can be anything" }
-    };
-    copy = qdict_clone_shallow(dict);
-    qdict_rename_keys(copy, renames, &error_abort);
-
-    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
-    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
-    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
-    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
-    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
-    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
-
-    qobject_unref(copy);
-
-    /* Simple rename of all entries */
-    renames = (QDictRenames[]) {
-        { "abc",        "str1" },
-        { "abcdef",     "str2" },
-        { "number",     "int" },
-        { "flag",       "bool" },
-        { "nothing",    "null" },
-        { NULL , NULL }
-    };
-    copy = qdict_clone_shallow(dict);
-    qdict_rename_keys(copy, renames, &error_abort);
-
-    g_assert(!qdict_haskey(copy, "abc"));
-    g_assert(!qdict_haskey(copy, "abcdef"));
-    g_assert(!qdict_haskey(copy, "number"));
-    g_assert(!qdict_haskey(copy, "flag"));
-    g_assert(!qdict_haskey(copy, "nothing"));
-
-    g_assert_cmpstr(qdict_get_str(copy, "str1"), ==, "foo");
-    g_assert_cmpstr(qdict_get_str(copy, "str2"), ==, "bar");
-    g_assert_cmpint(qdict_get_int(copy, "int"), ==, 42);
-    g_assert_cmpint(qdict_get_bool(copy, "bool"), ==, true);
-    g_assert(qobject_type(qdict_get(copy, "null")) == QTYPE_QNULL);
-    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
-
-    qobject_unref(copy);
-
-    /* Renames are processed top to bottom */
-    renames = (QDictRenames[]) {
-        { "abc",        "tmp" },
-        { "abcdef",     "abc" },
-        { "number",     "abcdef" },
-        { "flag",       "number" },
-        { "nothing",    "flag" },
-        { "tmp",        "nothing" },
-        { NULL , NULL }
-    };
-    copy = qdict_clone_shallow(dict);
-    qdict_rename_keys(copy, renames, &error_abort);
-
-    g_assert_cmpstr(qdict_get_str(copy, "nothing"), ==, "foo");
-    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "bar");
-    g_assert_cmpint(qdict_get_int(copy, "abcdef"), ==, 42);
-    g_assert_cmpint(qdict_get_bool(copy, "number"), ==, true);
-    g_assert(qobject_type(qdict_get(copy, "flag")) == QTYPE_QNULL);
-    g_assert(!qdict_haskey(copy, "tmp"));
-    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
-
-    qobject_unref(copy);
-
-    /* Conflicting rename */
-    renames = (QDictRenames[]) {
-        { "abcdef",     "abc" },
-        { NULL , NULL }
-    };
-    copy = qdict_clone_shallow(dict);
-    qdict_rename_keys(copy, renames, &local_err);
-
-    g_assert(local_err != NULL);
-    error_free(local_err);
-    local_err = NULL;
-
-    g_assert_cmpstr(qdict_get_str(copy, "abc"), ==, "foo");
-    g_assert_cmpstr(qdict_get_str(copy, "abcdef"), ==, "bar");
-    g_assert_cmpint(qdict_get_int(copy, "number"), ==, 42);
-    g_assert_cmpint(qdict_get_bool(copy, "flag"), ==, true);
-    g_assert(qobject_type(qdict_get(copy, "nothing")) == QTYPE_QNULL);
-    g_assert_cmpint(qdict_count_entries(copy), ==, 5);
-
-    qobject_unref(copy);
-
-    /* Renames in an empty dict */
-    renames = (QDictRenames[]) {
-        { "abcdef",     "abc" },
-        { NULL , NULL }
-    };
-
-    qobject_unref(dict);
-    dict = qdict_new();
-
-    qdict_rename_keys(dict, renames, &error_abort);
-    g_assert(qdict_first(dict) == NULL);
-
-    qobject_unref(dict);
-}
-
-static void qdict_crumple_test_bad_inputs(void)
-{
-    QDict *src;
-    Error *error = NULL;
-
-    src = qdict_new();
-    /* rule.0 can't be both a string and a dict */
-    qdict_put_str(src, "rule.0", "fred");
-    qdict_put_str(src, "rule.0.policy", "allow");
-
-    g_assert(qdict_crumple(src, &error) == NULL);
-    g_assert(error != NULL);
-    error_free(error);
-    error = NULL;
-    qobject_unref(src);
-
-    src = qdict_new();
-    /* rule can't be both a list and a dict */
-    qdict_put_str(src, "rule.0", "fred");
-    qdict_put_str(src, "rule.a", "allow");
-
-    g_assert(qdict_crumple(src, &error) == NULL);
-    g_assert(error != NULL);
-    error_free(error);
-    error = NULL;
-    qobject_unref(src);
-
-    src = qdict_new();
-    /* The input should be flat, ie no dicts or lists */
-    qdict_put(src, "rule.a", qdict_new());
-    qdict_put_str(src, "rule.b", "allow");
-
-    g_assert(qdict_crumple(src, &error) == NULL);
-    g_assert(error != NULL);
-    error_free(error);
-    error = NULL;
-    qobject_unref(src);
-
-    src = qdict_new();
-    /* List indexes must not have gaps */
-    qdict_put_str(src, "rule.0", "deny");
-    qdict_put_str(src, "rule.3", "allow");
-
-    g_assert(qdict_crumple(src, &error) == NULL);
-    g_assert(error != NULL);
-    error_free(error);
-    error = NULL;
-    qobject_unref(src);
-
-    src = qdict_new();
-    /* List indexes must be in %zu format */
-    qdict_put_str(src, "rule.0", "deny");
-    qdict_put_str(src, "rule.+1", "allow");
-
-    g_assert(qdict_crumple(src, &error) == NULL);
-    g_assert(error != NULL);
-    error_free(error);
-    error = NULL;
-    qobject_unref(src);
-}
-
 /*
  * Errors test-cases
  */
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/public/get_try_int", qdict_get_try_int_test);
     g_test_add_func("/public/get_str", qdict_get_str_test);
     g_test_add_func("/public/get_try_str", qdict_get_try_str_test);
-    g_test_add_func("/public/defaults", qdict_defaults_test);
     g_test_add_func("/public/haskey_not", qdict_haskey_not_test);
     g_test_add_func("/public/haskey", qdict_haskey_test);
     g_test_add_func("/public/del", qdict_del_test);
     g_test_add_func("/public/to_qdict", qobject_to_qdict_test);
     g_test_add_func("/public/iterapi", qdict_iterapi_test);
-    g_test_add_func("/public/flatten", qdict_flatten_test);
-    g_test_add_func("/public/array_split", qdict_array_split_test);
-    g_test_add_func("/public/array_entries", qdict_array_entries_test);
-    g_test_add_func("/public/join", qdict_join_test);
 
     g_test_add_func("/errors/put_exists", qdict_put_exists_test);
     g_test_add_func("/errors/get_not_exists", qdict_get_not_exists_test);
 
-    g_test_add_func("/public/crumple/recursive",
-                    qdict_crumple_test_recursive);
-    g_test_add_func("/public/crumple/empty",
-                    qdict_crumple_test_empty);
-    g_test_add_func("/public/crumple/bad_inputs",
-                    qdict_crumple_test_bad_inputs);
-
-    g_test_add_func("/public/rename_keys", qdict_rename_keys_test);
-
     /* The Big one */
     if (g_test_slow()) {
         g_test_add_func("/stress/test", qdict_stress_test);
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: qemu-img*
 F: qemu-io*
 F: tests/qemu-iotests/
 F: util/qemu-progress.c
+F: qobject/block-qdict.c
+F: test/check-block-qdict.c
 T: git git://repo.or.cz/qemu/kevin.git block
 
 Block I/O path
diff --git a/qobject/Makefile.objs b/qobject/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/qobject/Makefile.objs
+++ b/qobject/Makefile.objs
@@ -XXX,XX +XXX,XX @@
 util-obj-y = qnull.o qnum.o qstring.o qdict.o qlist.o qbool.o qlit.o
 util-obj-y += qjson.o qobject.o json-lexer.o json-streamer.o json-parser.o
+util-obj-y += block-qdict.o
diff --git a/tests/Makefile.include b/tests/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ SYSEMU_TARGET_LIST := $(subst -softmmu.mak,,$(notdir \
 
 check-unit-y = tests/check-qdict$(EXESUF)
 gcov-files-check-qdict-y = qobject/qdict.c
+check-unit-y = tests/check-block-qdict$(EXESUF)
+gcov-files-check-block-qdict-y = qobject/block-qdict.c
 check-unit-y += tests/test-char$(EXESUF)
 gcov-files-check-qdict-y = chardev/char.c
 check-unit-y += tests/check-qnum$(EXESUF)
@@ -XXX,XX +XXX,XX @@ GENERATED_FILES += tests/test-qapi-types.h tests/test-qapi-visit.h \
 test-obj-y = tests/check-qnum.o tests/check-qstring.o tests/check-qdict.o \
 	tests/check-qlist.o tests/check-qnull.o tests/check-qobject.o \
 	tests/check-qjson.o tests/check-qlit.o \
+	tests/check-block-qtest.o \
 	tests/test-coroutine.o tests/test-string-output-visitor.o \
 	tests/test-string-input-visitor.o tests/test-qobject-output-visitor.o \
 	tests/test-clone-visitor.o \
@@ -XXX,XX +XXX,XX @@ test-block-obj-y = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
 tests/check-qnum$(EXESUF): tests/check-qnum.o $(test-util-obj-y)
 tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
 tests/check-qdict$(EXESUF): tests/check-qdict.o $(test-util-obj-y)
+tests/check-block-qdict$(EXESUF): tests/check-block-qdict.o $(test-util-obj-y)
 tests/check-qlist$(EXESUF): tests/check-qlist.o $(test-util-obj-y)
 tests/check-qnull$(EXESUF): tests/check-qnull.o $(test-util-obj-y)
 tests/check-qobject$(EXESUF): tests/check-qobject.o $(test-util-obj-y)
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Configuration flows through the block subsystem in a rather peculiar
way.  Configuration made with -drive enters it as QemuOpts.
Configuration made with -blockdev / blockdev-add enters it as QAPI
type BlockdevOptions.  The block subsystem uses QDict, QemuOpts and
QAPI types internally.  The precise flow is next to impossible to
explain (I tried for this commit message, but gave up after wasting
several hours).  What I can explain is a flaw in the BlockDriver
interface that leads to this bug:

$ qemu-system-x86_64 -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234
    qemu-system-x86_64: -blockdev node-name=n1,driver=nfs,server.type=inet,server.host=localhost,path=/foo/bar,user=1234: Internal error: parameter user invalid

QMP blockdev-add is broken the same way.

Here's what happens.  The block layer passes configuration represented
as flat QDict (with dotted keys) to BlockDriver methods
.bdrv_file_open().  The QDict's members are typed according to the
QAPI schema.

nfs_file_open() converts it to QAPI type BlockdevOptionsNfs, with
qdict_crumple() and a qobject input visitor.

This visitor comes in two flavors.  The plain flavor requires scalars
to be typed according to the QAPI schema.  That's the case here.  The
keyval flavor requires string scalars.  That's not the case here.
nfs_file_open() uses the latter, and promptly falls apart for members
@user, @group, @tcp-syn-count, @readahead-size, @page-cache-size,
@debug.

Switching to the plain flavor would fix -blockdev, but break -drive,
because there the scalars arrive in nfs_file_open() as strings.

The proper fix would be to replace the QDict by QAPI type
BlockdevOptions in the BlockDriver interface.  Sadly, that's beyond my
reach right now.

Next best would be to fix the block layer to always pass correctly
typed QDicts to the BlockDriver methods.  Also beyond my reach.

What I can do is throw another hack onto the pile: have
nfs_file_open() convert all members to string, so use of the keyval
flavor actually works, by replacing qdict_crumple() by new function
qdict_crumple_for_keyval_qiv().

The pattern "pass result of qdict_crumple() to
qobject_input_visitor_new_keyval()" occurs several times more:

* qemu_rbd_open()

Same issue as nfs_file_open(), but since BlockdevOptionsRbd has only
  string members, its only a latent bug.  Fix it anyway.

* parallels_co_create_opts(), qcow_co_create_opts(),
  qcow2_co_create_opts(), bdrv_qed_co_create_opts(),
  sd_co_create_opts(), vhdx_co_create_opts(), vpc_co_create_opts()

These work, because they create the QDict with
  qemu_opts_to_qdict_filtered(), which creates only string scalars.
  The function sports a TODO comment asking for better typing; that's
  going to be fun.  Use qdict_crumple_for_keyval_qiv() to be safe.

From: Markus Armbruster <armbru@redhat.com>

The previous commit fixed -blockdev breakage due to misuse of the
qobject input visitor's keyval flavor in bdrv_file_open().  The commit
message explain why using the plain flavor would be just as wrong; it
would break -drive.  Turns out we break it in three places:
nbd_open(), sd_open() and ssh_file_open().  They are even marked
FIXME.  Example breakage:

$ qemu-system-x86 -drive node-name=n1,driver=nbd,server.type=inet,server.host=localhost,server.port=1234,server.numeric=off
    qemu-system-x86: -drive node-name=n1,driver=nbd,server.type=inet,server.host=localhost,server.port=1234,server.numeric=off: Invalid parameter type for 'numeric', expected: boolean

Fix it the same way: replace qdict_crumple() by
qdict_crumple_for_keyval_qiv(), and switch from plain to the keyval
flavor.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/nbd.c      | 12 ++----------
 block/sheepdog.c | 12 ++----------
 block/ssh.c      | 12 ++----------
 3 files changed, 6 insertions(+), 30 deletions(-)

diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
         goto done;
     }
 
-    crumpled_addr = qdict_crumple(addr, errp);
+    crumpled_addr = qdict_crumple_for_keyval_qiv(addr, errp);
     if (!crumpled_addr) {
         goto done;
     }
 
-    /*
-     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
-     * server.type=inet.  .to doesn't matter, it's ignored anyway.
-     * That's because when @options come from -blockdev or
-     * blockdev_add, members are typed according to the QAPI schema,
-     * but when they come from -drive, they're all QString.  The
-     * visitor expects the former.
-     */
-    iv = qobject_input_visitor_new(crumpled_addr);
+    iv = qobject_input_visitor_new_keyval(crumpled_addr);
     visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
 
     qdict_extract_subqdict(options, &server, "server.");
 
-    crumpled_server = qdict_crumple(server, errp);
+    crumpled_server = qdict_crumple_for_keyval_qiv(server, errp);
     if (!crumpled_server) {
         goto done;
     }
 
-    /*
-     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
-     * server.type=inet.  .to doesn't matter, it's ignored anyway.
-     * That's because when @options come from -blockdev or
-     * blockdev_add, members are typed according to the QAPI schema,
-     * but when they come from -drive, they're all QString.  The
-     * visitor expects the former.
-     */
-    iv = qobject_input_visitor_new(crumpled_server);
+    iv = qobject_input_visitor_new_keyval(crumpled_server);
     visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
     }
 
     /* Create the QAPI object */
-    crumpled = qdict_crumple(options, errp);
+    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
     if (crumpled == NULL) {
         goto fail;
     }
 
-    /*
-     * FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive.
-     * .to doesn't matter, it's ignored anyway.
-     * That's because when @options come from -blockdev or
-     * blockdev_add, members are typed according to the QAPI schema,
-     * but when they come from -drive, they're all QString.  The
-     * visitor expects the former.
-     */
-    v = qobject_input_visitor_new(crumpled);
+    v = qobject_input_visitor_new_keyval(crumpled);
     visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
     visit_free(v);
     qobject_unref(crumpled);
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

The following pattern occurs in the .bdrv_co_create_opts() methods of
parallels, qcow, qcow2, qed, vhdx and vpc:

qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
    qobject_unref(qdict);
    qdict = qobject_to(QDict, qobj);
    if (qdict == NULL) {
         ret = -EINVAL;
         goto done;
    }

v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
    [...]
    ret = 0;
done:
    qobject_unref(qdict);
    [...]
    return ret;

If qobject_to() fails, we return failure without setting errp.  That's
wrong.  As far as I can tell, it cannot fail here.  Clean it up
anyway, by removing the useless conversion.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/parallels.c | 9 ++++-----
 block/qcow.c      | 9 ++++-----
 block/qcow2.c     | 9 ++++-----
 block/qed.c       | 9 ++++-----
 block/vhdx.c      | 9 ++++-----
 block/vpc.c       | 9 ++++-----
 6 files changed, 24 insertions(+), 30 deletions(-)

diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
     BlockdevCreateOptions *create_options = NULL;
     Error *local_err = NULL;
     BlockDriverState *bs = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
     qdict_put_str(qdict, "file", bs->node_name);
 
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto done;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
 {
     BlockdevCreateOptions *create_options = NULL;
     BlockDriverState *bs = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     const char *val;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
     qdict_put_str(qdict, "file", bs->node_name);
 
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
                                              Error **errp)
 {
     BlockdevCreateOptions *create_options = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
 
     /* Now get the QAPI type BlockdevCreateOptions */
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto finish;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
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 bdrv_qed_co_create_opts(const char *filename,
                                                 Error **errp)
 {
     BlockdevCreateOptions *create_options = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
     qdict_put_str(qdict, "file", bs->node_name);
 
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
                                             Error **errp)
 {
     BlockdevCreateOptions *create_options = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
     qdict_put_str(qdict, "file", bs->node_name);
 
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
                                            QemuOpts *opts, Error **errp)
 {
     BlockdevCreateOptions *create_options = NULL;
-    QDict *qdict = NULL;
+    QDict *qdict;
     QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
     qdict_put_str(qdict, "file", bs->node_name);
 
     qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    qobject_unref(qdict);
-    qdict = qobject_to(QDict, qobj);
-    if (qdict == NULL) {
+    if (!qobj) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_keyval(qobj);
+    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

diff --git a/include/block/qdict.h b/include/block/qdict.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/qdict.h
+++ b/include/block/qdict.h
@@ -XXX,XX +XXX,XX @@ void qdict_extract_subqdict(QDict *src, QDict **dst, const char *start);
 void qdict_array_split(QDict *src, QList **dst);
 int qdict_array_entries(QDict *src, const char *subqdict);
 QObject *qdict_crumple(const QDict *src, Error **errp);
-QObject *qdict_crumple_for_keyval_qiv(QDict *qdict, Error **errp);
 void qdict_flatten(QDict *qdict);
 
 typedef struct QDictRenames {
@@ -XXX,XX +XXX,XX @@ typedef struct QDictRenames {
 } QDictRenames;
 bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp);
 
+Visitor *qobject_input_visitor_new_flat_confused(QDict *qdict,
+                                                 Error **errp);
 #endif
diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
 {
     SocketAddress *saddr = NULL;
     QDict *addr = NULL;
-    QObject *crumpled_addr = NULL;
     Visitor *iv = NULL;
     Error *local_err = NULL;
 
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
         goto done;
     }
 
-    crumpled_addr = qdict_crumple_for_keyval_qiv(addr, errp);
-    if (!crumpled_addr) {
+    iv = qobject_input_visitor_new_flat_confused(addr, errp);
+    if (!iv) {
         goto done;
     }
 
-    iv = qobject_input_visitor_new_keyval(crumpled_addr);
     visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ static SocketAddress *nbd_config(BDRVNBDState *s, QDict *options,
 
 done:
     qobject_unref(addr);
-    qobject_unref(crumpled_addr);
     visit_free(iv);
     return saddr;
 }
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsNfs *nfs_options_qdict_to_qapi(QDict *options,
                                                      Error **errp)
 {
     BlockdevOptionsNfs *opts = NULL;
-    QObject *crumpled = NULL;
     Visitor *v;
     const QDictEntry *e;
     Error *local_err = NULL;
 
-    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
-    if (crumpled == NULL) {
+    v = qobject_input_visitor_new_flat_confused(options, errp);
+    if (!v) {
         return NULL;
     }
 
-    v = qobject_input_visitor_new_keyval(crumpled);
     visit_type_BlockdevOptionsNfs(v, NULL, &opts, &local_err);
     visit_free(v);
-    qobject_unref(crumpled);
 
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
     Error *local_err = NULL;
     BlockDriverState *bs = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_create_opts(const char *filename,
     qdict_put_str(qdict, "driver", "parallels");
     qdict_put_str(qdict, "file", bs->node_name);
 
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto done;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
     BlockdevCreateOptions *create_options = NULL;
     BlockDriverState *bs = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     const char *val;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow_co_create_opts(const char *filename,
     qdict_put_str(qdict, "driver", "qcow");
     qdict_put_str(qdict, "file", bs->node_name);
 
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
 {
     BlockdevCreateOptions *create_options = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_create_opts(const char *filename, QemuOpts *opt
     qdict_put_str(qdict, "file", bs->node_name);
 
     /* Now get the QAPI type BlockdevCreateOptions */
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto finish;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
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 bdrv_qed_co_create_opts(const char *filename,
 {
     BlockdevCreateOptions *create_options = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create_opts(const char *filename,
     qdict_put_str(qdict, "driver", "qed");
     qdict_put_str(qdict, "file", bs->node_name);
 
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     BDRVRBDState *s = bs->opaque;
     BlockdevOptionsRbd *opts = NULL;
     Visitor *v;
-    QObject *crumpled = NULL;
     const QDictEntry *e;
     Error *local_err = NULL;
     char *keypairs, *secretid;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* Convert the remaining options into a QAPI object */
-    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
-    if (crumpled == NULL) {
+    v = qobject_input_visitor_new_flat_confused(options, errp);
+    if (!v) {
         r = -EINVAL;
         goto out;
     }
 
-    v = qobject_input_visitor_new_keyval(crumpled);
     visit_type_BlockdevOptionsRbd(v, NULL, &opts, &local_err);
     visit_free(v);
-    qobject_unref(crumpled);
 
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static void sd_aio_setup(SheepdogAIOCB *acb, BDRVSheepdogState *s,
 static SocketAddress *sd_server_config(QDict *options, Error **errp)
 {
     QDict *server = NULL;
-    QObject *crumpled_server = NULL;
     Visitor *iv = NULL;
     SocketAddress *saddr = NULL;
     Error *local_err = NULL;
 
     qdict_extract_subqdict(options, &server, "server.");
 
-    crumpled_server = qdict_crumple_for_keyval_qiv(server, errp);
-    if (!crumpled_server) {
+    iv = qobject_input_visitor_new_flat_confused(server, errp);
+    if (!iv) {
         goto done;
     }
 
-    iv = qobject_input_visitor_new_keyval(crumpled_server);
     visit_type_SocketAddress(iv, NULL, &saddr, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ static SocketAddress *sd_server_config(QDict *options, Error **errp)
 
 done:
     visit_free(iv);
-    qobject_unref(crumpled_server);
     qobject_unref(server);
     return saddr;
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
 {
     BlockdevCreateOptions *create_options = NULL;
     QDict *qdict, *location_qdict;
-    QObject *crumpled;
     Visitor *v;
     char *redundancy;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn sd_co_create_opts(const char *filename, QemuOpts *opts,
     }
 
     /* Get the QAPI object */
-    crumpled = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (crumpled == NULL) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(crumpled);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
-    qobject_unref(crumpled);
 
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
     BlockdevOptionsSsh *result = NULL;
     QemuOpts *opts = NULL;
     Error *local_err = NULL;
-    QObject *crumpled;
     const QDictEntry *e;
     Visitor *v;
 
@@ -XXX,XX +XXX,XX @@ static BlockdevOptionsSsh *ssh_parse_options(QDict *options, Error **errp)
     }
 
     /* Create the QAPI object */
-    crumpled = qdict_crumple_for_keyval_qiv(options, errp);
-    if (crumpled == NULL) {
+    v = qobject_input_visitor_new_flat_confused(options, errp);
+    if (!v) {
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(crumpled);
     visit_type_BlockdevOptionsSsh(v, NULL, &result, &local_err);
     visit_free(v);
-    qobject_unref(crumpled);
 
     if (local_err) {
         error_propagate(errp, local_err);
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
 {
     BlockdevCreateOptions *create_options = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vhdx_co_create_opts(const char *filename,
     qdict_put_str(qdict, "driver", "vhdx");
     qdict_put_str(qdict, "file", bs->node_name);
 
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
 {
     BlockdevCreateOptions *create_options = NULL;
     QDict *qdict;
-    QObject *qobj;
     Visitor *v;
     BlockDriverState *bs = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vpc_co_create_opts(const char *filename,
     qdict_put_str(qdict, "driver", "vpc");
     qdict_put_str(qdict, "file", bs->node_name);
 
-    qobj = qdict_crumple_for_keyval_qiv(qdict, errp);
-    if (!qobj) {
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
         ret = -EINVAL;
         goto fail;
     }
 
-    v = qobject_input_visitor_new_keyval(qobj);
-    qobject_unref(qobj);
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/block-qdict.c
+++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qmp/qlist.h"
 #include "qapi/qmp/qnum.h"
 #include "qapi/qmp/qstring.h"
+#include "qapi/qobject-input-visitor.h"
 #include "qemu/cutils.h"
 #include "qapi/error.h"
 
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
  * used for anything else, and it should go away once the block
  * subsystem has been cleaned up.
  */
-QObject *qdict_crumple_for_keyval_qiv(QDict *src, Error **errp)
+static QObject *qdict_crumple_for_keyval_qiv(QDict *src, Error **errp)
 {
     QDict *tmp = NULL;
     char *buf;
@@ -XXX,XX +XXX,XX @@ bool qdict_rename_keys(QDict *qdict, const QDictRenames *renames, Error **errp)
     }
     return true;
 }
+
+/*
+ * Create a QObject input visitor for flat @qdict with possibly
+ * confused scalar types.
+ *
+ * The block subsystem uses this function to visit its flat QDict with
+ * possibly confused scalar types.  It should not be used for anything
+ * else, and it should go away once the block subsystem has been
+ * cleaned up.
+ */
+Visitor *qobject_input_visitor_new_flat_confused(QDict *qdict,
+                                                 Error **errp)
+{
+    QObject *crumpled;
+    Visitor *v;
+
+    crumpled = qdict_crumple_for_keyval_qiv(qdict, errp);
+    if (!crumpled) {
+        return NULL;
+    }
+
+    v = qobject_input_visitor_new_keyval(crumpled);
+    qobject_unref(crumpled);
+    return v;
+}
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Remaining uses of qobject_input_visitor_new_keyval() in the block
subsystem:

* block_crypto_open_opts_init()
  Currently doesn't visit any non-string scalars, thus safe.  It's
  called from
  - block_crypto_open_luks()
    Creates the QDict with qemu_opts_to_qdict_filtered(), which
    creates only string scalars, but has a TODO asking for other types.
  - qcow_open()
  - qcow2_open(), qcow2_co_invalidate_cache(), qcow2_reopen_prepare()

* block_crypto_create_opts_init(), called from
  - block_crypto_co_create_opts_luks()
    Also creates the QDict with qemu_opts_to_qdict_filtered().

* vdi_co_create_opts()
  Also creates the QDict with qemu_opts_to_qdict_filtered().

Replace these uses by qobject_input_visitor_new_flat_confused() for
robustness.  This adds crumpling.  Right now, that's a no-op, but if
we ever extend these things in non-flat ways, crumpling will be
needed.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/crypto.c | 12 +++++++++---
 block/vdi.c    |  8 ++++++--
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "crypto/block.h"
 #include "qapi/opts-visitor.h"
 #include "qapi/qapi-visit-crypto.h"
-#include "qapi/qmp/qdict.h"
 #include "qapi/qobject-input-visitor.h"
 #include "qapi/error.h"
 #include "qemu/option.h"
@@ -XXX,XX +XXX,XX @@ block_crypto_open_opts_init(QCryptoBlockFormat format,
     ret = g_new0(QCryptoBlockOpenOptions, 1);
     ret->format = format;
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(opts));
+    v = qobject_input_visitor_new_flat_confused(opts, &local_err);
+    if (local_err) {
+        goto out;
+    }
 
     visit_start_struct(v, NULL, NULL, 0, &local_err);
     if (local_err) {
@@ -XXX,XX +XXX,XX @@ block_crypto_create_opts_init(QCryptoBlockFormat format,
     ret = g_new0(QCryptoBlockCreateOptions, 1);
     ret->format = format;
 
-    v = qobject_input_visitor_new_keyval(QOBJECT(opts));
+    v = qobject_input_visitor_new_flat_confused(opts, &local_err);
+    if (local_err) {
+        goto out;
+    }
 
     visit_start_struct(v, NULL, NULL, 0, &local_err);
     if (local_err) {
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "qapi/error.h"
-#include "qapi/qmp/qdict.h"
 #include "qapi/qobject-input-visitor.h"
 #include "qapi/qapi-visit-block-core.h"
 #include "block/block_int.h"
+#include "block/qdict.h"
 #include "sysemu/block-backend.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_create_opts(const char *filename, QemuOpts *opts,
     }
 
     /* Get the QAPI object */
-    v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    v = qobject_input_visitor_new_flat_confused(qdict, errp);
+    if (!v) {
+        ret = -EINVAL;
+        goto done;
+    }
     visit_type_BlockdevCreateOptions(v, NULL, &create_options, &local_err);
     visit_free(v);
 
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

There's no need to restart the loop.  We don't elsewhere, e.g. in
qdict_extract_subqdict(), qdict_join() and qemu_opts_absorb_qdict().
Simplify accordingly.

From: Markus Armbruster <armbru@redhat.com>

qdict_flatten_qdict() skips copying scalars from @qdict to @target
when the two are the same.  Fair enough, but it uses a non-obvious
test for "same".  Replace it by the obvious one.  While there, improve
comments.

From: Markus Armbruster <armbru@redhat.com>

When you mix scalar and non-scalar keys, whether you get an "already
set as scalar" or an "already set as dict" error depends on qdict
iteration order.  Neither message makes much sense.  Replace by
""Cannot mix scalar and non-scalar keys".  This is similar to the
message we get for mixing list and non-list keys.

I find qdict_crumple()'s first loop hard to understand.  Rearrange it
and add a comment.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qobject/block-qdict.c | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/block-qdict.c
+++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
 QObject *qdict_crumple(const QDict *src, Error **errp)
 {
     const QDictEntry *ent;
-    QDict *two_level, *multi_level = NULL;
+    QDict *two_level, *multi_level = NULL, *child_dict;
     QObject *dst = NULL, *child;
     size_t i;
     char *prefix = NULL;
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
         }
 
         qdict_split_flat_key(ent->key, &prefix, &suffix);
-
         child = qdict_get(two_level, prefix);
+        child_dict = qobject_to(QDict, child);
+
+        if (child) {
+            /*
+             * If @child_dict, then all previous keys with this prefix
+             * had a suffix.  If @suffix, this one has one as well,
+             * and we're good, else there's a clash.
+             */
+            if (!child_dict || !suffix) {
+                error_setg(errp, "Cannot mix scalar and non-scalar keys");
+                goto error;
+            }
+        }
+
         if (suffix) {
-            QDict *child_dict = qobject_to(QDict, child);
             if (!child_dict) {
-                if (child) {
-                    error_setg(errp, "Key %s prefix is already set as a scalar",
-                               prefix);
-                    goto error;
-                }
-
                 child_dict = qdict_new();
-                qdict_put_obj(two_level, prefix, QOBJECT(child_dict));
+                qdict_put(two_level, prefix, child_dict);
             }
-
             qdict_put_obj(child_dict, suffix, qobject_ref(ent->value));
         } else {
-            if (child) {
-                error_setg(errp, "Key %s prefix is already set as a dict",
-                           prefix);
-                goto error;
-            }
             qdict_put_obj(two_level, prefix, qobject_ref(ent->value));
         }
 
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/block-qdict.c
+++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
 
     for (ent = qdict_first(maybe_list); ent != NULL;
          ent = qdict_next(maybe_list, ent)) {
+        int is_index = !qemu_strtoi64(ent->key, NULL, 10, &val);
 
-        if (qemu_strtoi64(ent->key, NULL, 10, &val) == 0) {
-            if (is_list == -1) {
-                is_list = 1;
-            } else if (!is_list) {
-                error_setg(errp,
-                           "Cannot mix list and non-list keys");
-                return -1;
-            }
+        if (is_list == -1) {
+            is_list = is_index;
+        }
+
+        if (is_index != is_list) {
+            error_setg(errp, "Cannot mix list and non-list keys");
+            return -1;
+        }
+
+        if (is_index) {
             len++;
             if (val > max) {
                 max = val;
             }
-        } else {
-            if (is_list == -1) {
-                is_list = 0;
-            } else if (is_list) {
-                error_setg(errp,
-                           "Cannot mix list and non-list keys");
-                return -1;
-            }
         }
     }
 
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/check-block-qdict.c | 57 ++++++++++++++++++++++++-----------------------
 1 file changed, 29 insertions(+), 28 deletions(-)

diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/check-block-qdict.c
+++ b/tests/check-block-qdict.c
@@ -XXX,XX +XXX,XX @@ static void qdict_defaults_test(void)
 
 static void qdict_flatten_test(void)
 {
-    QList *list1 = qlist_new();
-    QList *list2 = qlist_new();
-    QDict *dict1 = qdict_new();
-    QDict *dict2 = qdict_new();
-    QDict *dict3 = qdict_new();
+    QList *e_1 = qlist_new();
+    QList *e = qlist_new();
+    QDict *e_1_2 = qdict_new();
+    QDict *f = qdict_new();
+    QDict *root = qdict_new();
 
     /*
      * Test the flattening of
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
      * }
      */
 
-    qdict_put_int(dict1, "a", 0);
-    qdict_put_int(dict1, "b", 1);
+    qdict_put_int(e_1_2, "a", 0);
+    qdict_put_int(e_1_2, "b", 1);
 
-    qlist_append_int(list1, 23);
-    qlist_append_int(list1, 66);
-    qlist_append(list1, dict1);
-    qlist_append_int(list2, 42);
-    qlist_append(list2, list1);
+    qlist_append_int(e_1, 23);
+    qlist_append_int(e_1, 66);
+    qlist_append(e_1, e_1_2);
+    qlist_append_int(e, 42);
+    qlist_append(e, e_1);
 
-    qdict_put_int(dict2, "c", 2);
-    qdict_put_int(dict2, "d", 3);
-    qdict_put(dict3, "e", list2);
-    qdict_put(dict3, "f", dict2);
-    qdict_put_int(dict3, "g", 4);
+    qdict_put_int(f, "c", 2);
+    qdict_put_int(f, "d", 3);
 
-    qdict_flatten(dict3);
+    qdict_put(root, "e", e);
+    qdict_put(root, "f", f);
+    qdict_put_int(root, "g", 4);
 
-    g_assert(qdict_get_int(dict3, "e.0") == 42);
-    g_assert(qdict_get_int(dict3, "e.1.0") == 23);
-    g_assert(qdict_get_int(dict3, "e.1.1") == 66);
-    g_assert(qdict_get_int(dict3, "e.1.2.a") == 0);
-    g_assert(qdict_get_int(dict3, "e.1.2.b") == 1);
-    g_assert(qdict_get_int(dict3, "f.c") == 2);
-    g_assert(qdict_get_int(dict3, "f.d") == 3);
-    g_assert(qdict_get_int(dict3, "g") == 4);
+    qdict_flatten(root);
 
-    g_assert(qdict_size(dict3) == 8);
+    g_assert(qdict_get_int(root, "e.0") == 42);
+    g_assert(qdict_get_int(root, "e.1.0") == 23);
+    g_assert(qdict_get_int(root, "e.1.1") == 66);
+    g_assert(qdict_get_int(root, "e.1.2.a") == 0);
+    g_assert(qdict_get_int(root, "e.1.2.b") == 1);
+    g_assert(qdict_get_int(root, "f.c") == 2);
+    g_assert(qdict_get_int(root, "f.d") == 3);
+    g_assert(qdict_get_int(root, "g") == 4);
 
-    qobject_unref(dict3);
+    g_assert(qdict_size(root) == 8);
+
+    qobject_unref(root);
 }
 
 static void qdict_array_split_test(void)
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/check-block-qdict.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

From: Markus Armbruster <armbru@redhat.com>

-blockdev and blockdev-add silently ignore empty objects and arrays in
their argument.  That's because qmp_blockdev_add() converts the
argument to a flat QDict, and qdict_flatten() eats empty QDict and
QList members.  For instance, we ignore an empty BlockdevOptions
member @cache.  No real harm, as absent means the same as empty there.

Thus, the flaw puts an artificial restriction on the QAPI schema: we
can't have potentially empty objects and arrays within
BlockdevOptions, except when they're optional and "empty" has the same
meaning as "absent".

Our QAPI schema satisfies this restriction (I checked), but it's a
trap for the unwary, and a temptation to employ awkward workarounds
for the wary.  Let's get rid of it.

Change qdict_flatten() and qdict_crumple() to treat empty dictionaries
and lists exactly like scalars.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qobject/block-qdict.c     | 54 +++++++++++++++++++++++++++++------------------
 tests/check-block-qdict.c | 38 ++++++++++++++++++++++++++-------
 2 files changed, 63 insertions(+), 29 deletions(-)

diff --git a/qobject/block-qdict.c b/qobject/block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/qobject/block-qdict.c
+++ b/qobject/block-qdict.c
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
 {
     QObject *value;
     const QListEntry *entry;
+    QDict *dict_val;
+    QList *list_val;
     char *new_key;
     int i;
 
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qlist(QList *qlist, QDict *target, const char *prefix)
 
     for (i = 0; entry; entry = qlist_next(entry), i++) {
         value = qlist_entry_obj(entry);
+        dict_val = qobject_to(QDict, value);
+        list_val = qobject_to(QList, value);
         new_key = g_strdup_printf("%s.%i", prefix, i);
 
         /*
          * Flatten non-empty QDict and QList recursively into @target,
          * copy other objects to @target
          */
-        if (qobject_type(value) == QTYPE_QDICT) {
-            qdict_flatten_qdict(qobject_to(QDict, value), target, new_key);
-        } else if (qobject_type(value) == QTYPE_QLIST) {
-            qdict_flatten_qlist(qobject_to(QList, value), target, new_key);
+        if (dict_val && qdict_size(dict_val)) {
+            qdict_flatten_qdict(dict_val, target, new_key);
+        } else if (list_val && !qlist_empty(list_val)) {
+            qdict_flatten_qlist(list_val, target, new_key);
         } else {
             qdict_put_obj(target, new_key, qobject_ref(value));
         }
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
 {
     QObject *value;
     const QDictEntry *entry, *next;
+    QDict *dict_val;
+    QList *list_val;
     char *new_key;
 
     entry = qdict_first(qdict);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
     while (entry != NULL) {
         next = qdict_next(qdict, entry);
         value = qdict_entry_value(entry);
+        dict_val = qobject_to(QDict, value);
+        list_val = qobject_to(QList, value);
         new_key = NULL;
 
         if (prefix) {
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
          * Flatten non-empty QDict and QList recursively into @target,
          * copy other objects to @target
          */
-        if (qobject_type(value) == QTYPE_QDICT) {
-            qdict_flatten_qdict(qobject_to(QDict, value), target,
+        if (dict_val && qdict_size(dict_val)) {
+            qdict_flatten_qdict(dict_val, target,
                                 new_key ? new_key : entry->key);
             qdict_del(qdict, entry->key);
-        } else if (qobject_type(value) == QTYPE_QLIST) {
-            qdict_flatten_qlist(qobject_to(QList, value), target,
+        } else if (list_val && !qlist_empty(list_val)) {
+            qdict_flatten_qlist(list_val, target,
                                 new_key ? new_key : entry->key);
             qdict_del(qdict, entry->key);
         } else if (target != qdict) {
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_qdict(QDict *qdict, QDict *target, const char *prefix)
 }
 
 /**
- * qdict_flatten(): For each nested QDict with key x, all fields with key y
- * are moved to this QDict and their key is renamed to "x.y". For each nested
- * QList with key x, the field at index y is moved to this QDict with the key
- * "x.y" (i.e., the reverse of what qdict_array_split() does).
+ * qdict_flatten(): For each nested non-empty QDict with key x, all
+ * fields with key y are moved to this QDict and their key is renamed
+ * to "x.y". For each nested non-empty QList with key x, the field at
+ * index y is moved to this QDict with the key "x.y" (i.e., the
+ * reverse of what qdict_array_split() does).
  * This operation is applied recursively for nested QDicts and QLists.
  */
 void qdict_flatten(QDict *qdict)
@@ -XXX,XX +XXX,XX @@ static int qdict_is_list(QDict *maybe_list, Error **errp)
  * @src: the original flat dictionary (only scalar values) to crumple
  *
  * Takes a flat dictionary whose keys use '.' separator to indicate
- * nesting, and values are scalars, and crumples it into a nested
- * structure.
+ * nesting, and values are scalars, empty dictionaries or empty lists,
+ * and crumples it into a nested structure.
  *
  * To include a literal '.' in a key name, it must be escaped as '..'
  *
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
 {
     const QDictEntry *ent;
     QDict *two_level, *multi_level = NULL, *child_dict;
+    QDict *dict_val;
+    QList *list_val;
     QObject *dst = NULL, *child;
     size_t i;
     char *prefix = NULL;
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
 
     /* Step 1: split our totally flat dict into a two level dict */
     for (ent = qdict_first(src); ent != NULL; ent = qdict_next(src, ent)) {
-        if (qobject_type(ent->value) == QTYPE_QDICT ||
-            qobject_type(ent->value) == QTYPE_QLIST) {
-            error_setg(errp, "Value %s is not a scalar",
-                       ent->key);
+        dict_val = qobject_to(QDict, ent->value);
+        list_val = qobject_to(QList, ent->value);
+        if ((dict_val && qdict_size(dict_val))
+            || (list_val && !qlist_empty(list_val))) {
+            error_setg(errp, "Value %s is not flat", ent->key);
             goto error;
         }
 
@@ -XXX,XX +XXX,XX @@ QObject *qdict_crumple(const QDict *src, Error **errp)
     multi_level = qdict_new();
     for (ent = qdict_first(two_level); ent != NULL;
          ent = qdict_next(two_level, ent)) {
-        QDict *dict = qobject_to(QDict, ent->value);
-        if (dict) {
-            child = qdict_crumple(dict, errp);
+        dict_val = qobject_to(QDict, ent->value);
+        if (dict_val && qdict_size(dict_val)) {
+            child = qdict_crumple(dict_val, errp);
             if (!child) {
                 goto error;
             }
diff --git a/tests/check-block-qdict.c b/tests/check-block-qdict.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/check-block-qdict.c
+++ b/tests/check-block-qdict.c
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
      *     "e.1.2.b": 1,
      *     "f.c": 2,
      *     "f.d": 3,
-     *     "g": 4
+     *     "g": 4,
+     *     "y.0": {},
+     *     "z.a": []
      * }
-     *
-     * Note that "y" and "z" get eaten.
      */
 
     qdict_put_int(e_1_2, "a", 0);
@@ -XXX,XX +XXX,XX @@ static void qdict_flatten_test(void)
     g_assert(qdict_get_int(root, "f.c") == 2);
     g_assert(qdict_get_int(root, "f.d") == 3);
     g_assert(qdict_get_int(root, "g") == 4);
+    g_assert(!qdict_size(qdict_get_qdict(root, "y.0")));
+    g_assert(qlist_empty(qdict_get_qlist(root, "z.a")));
 
-    g_assert(qdict_size(root) == 8);
+    g_assert(qdict_size(root) == 10);
 
     qobject_unref(root);
 }
@@ -XXX,XX +XXX,XX @@ static void qdict_join_test(void)
 static void qdict_crumple_test_recursive(void)
 {
     QDict *src, *dst, *rule, *vnc, *acl, *listen;
-    QList *rules;
+    QDict *empty, *empty_dict, *empty_list_0;
+    QList *rules, *empty_list, *empty_dict_a;
 
     src = qdict_new();
     qdict_put_str(src, "vnc.listen.addr", "127.0.0.1");
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_recursive(void)
     qdict_put_str(src, "vnc.acl.default", "deny");
     qdict_put_str(src, "vnc.acl..name", "acl0");
     qdict_put_str(src, "vnc.acl.rule..name", "acl0");
+    qdict_put(src, "empty.dict.a", qlist_new());
+    qdict_put(src, "empty.list.0", qdict_new());
 
     dst = qobject_to(QDict, qdict_crumple(src, &error_abort));
     g_assert(dst);
-    g_assert_cmpint(qdict_size(dst), ==, 1);
+    g_assert_cmpint(qdict_size(dst), ==, 2);
 
     vnc = qdict_get_qdict(dst, "vnc");
     g_assert(vnc);
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_recursive(void)
     g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
     g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
 
+    empty = qdict_get_qdict(dst, "empty");
+    g_assert(empty);
+    g_assert_cmpint(qdict_size(empty), ==, 2);
+    empty_dict = qdict_get_qdict(empty, "dict");
+    g_assert(empty_dict);
+    g_assert_cmpint(qdict_size(empty_dict), ==, 1);
+    empty_dict_a = qdict_get_qlist(empty_dict, "a");
+    g_assert(empty_dict_a && qlist_empty(empty_dict_a));
+    empty_list = qdict_get_qlist(empty, "list");
+    g_assert(empty_list);
+    g_assert_cmpint(qlist_size(empty_list), ==, 1);
+    empty_list_0 = qobject_to(QDict, qlist_pop(empty_list));
+    g_assert(empty_list_0);
+    g_assert_cmpint(qdict_size(empty_list_0), ==, 0);
+
     qobject_unref(src);
     qobject_unref(dst);
 }
@@ -XXX,XX +XXX,XX @@ static void qdict_rename_keys_test(void)
 
 static void qdict_crumple_test_bad_inputs(void)
 {
-    QDict *src;
+    QDict *src, *nested;
     Error *error = NULL;
 
     src = qdict_new();
@@ -XXX,XX +XXX,XX @@ static void qdict_crumple_test_bad_inputs(void)
 
     src = qdict_new();
     /* The input should be flat, ie no dicts or lists */
-    qdict_put(src, "rule.a", qdict_new());
+    nested = qdict_new();
+    qdict_put(nested, "x", qdict_new());
+    qdict_put(src, "rule.a", nested);
     qdict_put_str(src, "rule.b", "allow");
 
     g_assert(qdict_crumple(src, &error) == NULL);
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Parameter auth-client-required lets you configure authentication
methods.  We tried to provide that in v2.9.0, but backed out due to
interface design doubts (commit 464444fcc16).

This commit is similar to what we backed out, but simpler: we use a
list of enumeration values instead of a list of objects with a member
of enumeration type.

Let's review our reasons for backing out the first try, as stated in
the commit message:

* The implementation uses deprecated rados_conf_set() key
      "auth_supported".  No biggie.

Fixed: we use "auth-client-required".

* The implementation makes -drive silently ignore invalid parameters
      "auth" and "auth-supported.*.X" where X isn't "auth".  Fixable (in
      fact I'm going to fix similar bugs around parameter server), so
      again no biggie.

That fix is commit 2836284db60.  This commit doesn't bring the bugs
back.

* BlockdevOptionsRbd member @password-secret applies only to
      authentication method cephx.  Should it be a variant member of
      RbdAuthMethod?

We've had time to ponder, and we decided to stick to the way Ceph
configuration works: the key configured separately, and silently
ignored if the authentication method doesn't use it.

* BlockdevOptionsRbd member @user could apply to both methods cephx
      and none, but I'm not sure it's actually used with none.  If it
      isn't, should it be a variant member of RbdAuthMethod?

Likewise.

* The client offers a *set* of authentication methods, not a list.
      Should the methods be optional members of BlockdevOptionsRbd instead
      of members of list @auth-supported?  The latter begs the question
      what multiple entries for the same method mean.  Trivial question
      now that RbdAuthMethod contains nothing but @type, but less so when
      RbdAuthMethod acquires other members, such the ones discussed above.

Again, we decided to stick to the way Ceph configuration works, except
we make auth-client-required a list of enumeration values instead of a
string containing keywords separated by delimiters.

* How BlockdevOptionsRbd member @auth-supported interacts with
      settings from a configuration file specified with @conf is
      undocumented.  I suspect it's untested, too.

Not actually true, the documentation for @conf says "Values in the
configuration file will be overridden by options specified via QAPI",
and we've tested this.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json | 13 +++++++++++++
 block/rbd.c          | 42 ++++++++++++++++++++++++++++++++----------
 2 files changed, 45 insertions(+), 10 deletions(-)

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 @@
 
 
 ##
+# @RbdAuthMode:
+#
+# Since: 3.0
+##
+{ 'enum': 'RbdAuthMode',
+  'data': [ 'cephx', 'none' ] }
+
+##
 # @BlockdevOptionsRbd:
 #
 # @pool:               Ceph pool name.
@@ -XXX,XX +XXX,XX @@
 #
 # @user:               Ceph id name.
 #
+# @auth-client-required: Acceptable authentication modes.
+#                      This maps to Ceph configuration option
+#                      "auth_client_required".  (Since 3.0)
+#
 # @server:             Monitor host address and port.  This maps
 #                      to the "mon_host" Ceph option.
 #
@@ -XXX,XX +XXX,XX @@
             '*conf': 'str',
             '*snapshot': 'str',
             '*user': 'str',
+            '*auth-client-required': ['RbdAuthMode'],
             '*server': ['InetSocketAddressBase'] } }
 
 ##
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_refresh_limits(BlockDriverState *bs, Error **errp)
 
 
 static int qemu_rbd_set_auth(rados_t cluster, const char *secretid,
+                             BlockdevOptionsRbd *opts,
                              Error **errp)
 {
-    if (secretid == 0) {
-        return 0;
-    }
+    char *acr;
+    int r;
+    GString *accu;
+    RbdAuthModeList *auth;
+
+    if (secretid) {
+        gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
+                                                        errp);
+        if (!secret) {
+            return -1;
+        }
 
-    gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
-                                                    errp);
-    if (!secret) {
-        return -1;
+        rados_conf_set(cluster, "key", secret);
+        g_free(secret);
     }
 
-    rados_conf_set(cluster, "key", secret);
-    g_free(secret);
+    if (opts->has_auth_client_required) {
+        accu = g_string_new("");
+        for (auth = opts->auth_client_required; auth; auth = auth->next) {
+            if (accu->str[0]) {
+                g_string_append_c(accu, ';');
+            }
+            g_string_append(accu, RbdAuthMode_str(auth->value));
+        }
+        acr = g_string_free(accu, FALSE);
+        r = rados_conf_set(cluster, "auth_client_required", acr);
+        g_free(acr);
+        if (r < 0) {
+            error_setg_errno(errp, -r,
+                             "Could not set 'auth_client_required'");
+            return r;
+        }
+    }
 
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
         }
     }
 
-    if (qemu_rbd_set_auth(*cluster, secretid, errp) < 0) {
+    if (qemu_rbd_set_auth(*cluster, secretid, opts, errp) < 0) {
         r = -EIO;
         goto failed_shutdown;
     }
-- 
2.13.6

From: Markus Armbruster <armbru@redhat.com>

Legacy -drive supports "password-secret" parameter that isn't
available with -blockdev / blockdev-add.  That's because we backed out
our first try to provide it there due to interface design doubts, in
commit 577d8c9a811, v2.9.0.

This is the second try.  It brings back the parameter, except it's
named "key-secret" now.

Let's review our reasons for backing out the first try, as stated in
the commit message:

* BlockdevOptionsRbd member @password-secret isn't actually a
      password, it's a key generated by Ceph.

Addressed by the rename.

* We're not sure where member @password-secret belongs (see the
      previous commit).

See previous commit.

* How @password-secret interacts with settings from a configuration
      file specified with @conf is undocumented.

Not actually true, the documentation for @conf says "Values in the
configuration file will be overridden by options specified via QAPI",
and we've tested this.

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json |  6 ++++++
 block/rbd.c          | 41 +++++++++++++++++++++++++----------------
 2 files changed, 31 insertions(+), 16 deletions(-)

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 @@
 #                      This maps to Ceph configuration option
 #                      "auth_client_required".  (Since 3.0)
 #
+# @key-secret:         ID of a QCryptoSecret object providing a key
+#                      for cephx authentication.
+#                      This maps to Ceph configuration option
+#                      "key".  (Since 3.0)
+#
 # @server:             Monitor host address and port.  This maps
 #                      to the "mon_host" Ceph option.
 #
@@ -XXX,XX +XXX,XX @@
             '*snapshot': 'str',
             '*user': 'str',
             '*auth-client-required': ['RbdAuthMode'],
+            '*key-secret': 'str',
             '*server': ['InetSocketAddressBase'] } }
 
 ##
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_refresh_limits(BlockDriverState *bs, Error **errp)
 }
 
 
-static int qemu_rbd_set_auth(rados_t cluster, const char *secretid,
-                             BlockdevOptionsRbd *opts,
+static int qemu_rbd_set_auth(rados_t cluster, BlockdevOptionsRbd *opts,
                              Error **errp)
 {
-    char *acr;
+    char *key, *acr;
     int r;
     GString *accu;
     RbdAuthModeList *auth;
 
-    if (secretid) {
-        gchar *secret = qcrypto_secret_lookup_as_base64(secretid,
-                                                        errp);
-        if (!secret) {
-            return -1;
+    if (opts->key_secret) {
+        key = qcrypto_secret_lookup_as_base64(opts->key_secret, errp);
+        if (!key) {
+            return -EIO;
+        }
+        r = rados_conf_set(cluster, "key", key);
+        g_free(key);
+        if (r < 0) {
+            error_setg_errno(errp, -r, "Could not set 'key'");
+            return r;
         }
-
-        rados_conf_set(cluster, "key", secret);
-        g_free(secret);
     }
 
     if (opts->has_auth_client_required) {
@@ -XXX,XX +XXX,XX @@ static QemuOptsList runtime_opts = {
     },
 };
 
-/* FIXME Deprecate and remove keypairs or make it available in QMP.
- * password_secret should eventually be configurable in opts->location. Support
- * for it in .bdrv_open will make it work here as well. */
+/* FIXME Deprecate and remove keypairs or make it available in QMP. */
 static int qemu_rbd_do_create(BlockdevCreateOptions *options,
                               const char *keypairs, const char *password_secret,
                               Error **errp)
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
     Error *local_err = NULL;
     int r;
 
+    if (secretid) {
+        if (opts->key_secret) {
+            error_setg(errp,
+                       "Legacy 'password-secret' clashes with 'key-secret'");
+            return -EINVAL;
+        }
+        opts->key_secret = g_strdup(secretid);
+        opts->has_key_secret = true;
+    }
+
     mon_host = qemu_rbd_mon_host(opts, &local_err);
     if (local_err) {
         error_propagate(errp, local_err);
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_connect(rados_t *cluster, rados_ioctx_t *io_ctx,
         }
     }
 
-    if (qemu_rbd_set_auth(*cluster, secretid, opts, errp) < 0) {
-        r = -EIO;
+    r = qemu_rbd_set_auth(*cluster, opts, errp);
+    if (r < 0) {
         goto failed_shutdown;
     }
 
-- 
2.13.6

The -drive options cyls, heads, secs and trans were deprecated in
QEMU 2.10. It's time to remove them.

hd-geo-test tested both the old version with geometry options in -drive
and the new one with -device. Therefore the code using -drive doesn't
have to be replaced there, we just need to remove the -drive test cases.
This in turn allows some simplification of the code.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
---
 include/sysemu/blockdev.h |  1 -
 blockdev.c                | 75 +----------------------------------------------
 hw/block/block.c          | 14 ---------
 tests/hd-geo-test.c       | 37 +++++------------------
 hmp-commands.hx           |  1 -
 qemu-doc.texi             |  5 ----
 qemu-options.hx           |  7 +----
 7 files changed, 9 insertions(+), 131 deletions(-)

diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/blockdev.h
+++ b/include/sysemu/blockdev.h
@@ -XXX,XX +XXX,XX @@ struct DriveInfo {
     int auto_del;               /* see blockdev_mark_auto_del() */
     bool is_default;            /* Added by default_drive() ?  */
     int media_cd;
-    int cyls, heads, secs, trans;
     QemuOpts *opts;
     char *serial;
     QTAILQ_ENTRY(DriveInfo) next;
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
             .type = QEMU_OPT_STRING,
             .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
         },{
-            .name = "cyls",
-            .type = QEMU_OPT_NUMBER,
-            .help = "number of cylinders (ide disk geometry)",
-        },{
-            .name = "heads",
-            .type = QEMU_OPT_NUMBER,
-            .help = "number of heads (ide disk geometry)",
-        },{
-            .name = "secs",
-            .type = QEMU_OPT_NUMBER,
-            .help = "number of sectors (ide disk geometry)",
-        },{
-            .name = "trans",
-            .type = QEMU_OPT_STRING,
-            .help = "chs translation (auto, lba, none)",
-        },{
             .name = "addr",
             .type = QEMU_OPT_STRING,
             .help = "pci address (virtio only)",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     QemuOpts *legacy_opts;
     DriveMediaType media = MEDIA_DISK;
     BlockInterfaceType type;
-    int cyls, heads, secs, translation;
     int max_devs, bus_id, unit_id, index;
     const char *devaddr;
     const char *werror, *rerror;
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     Error *local_err = NULL;
     int i;
     const char *deprecated[] = {
-        "serial", "trans", "secs", "heads", "cyls", "addr"
+        "serial", "addr"
     };
 
     /* Change legacy command line options into QMP ones */
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
         type = block_default_type;
     }
 
-    /* Geometry */
-    cyls  = qemu_opt_get_number(legacy_opts, "cyls", 0);
-    heads = qemu_opt_get_number(legacy_opts, "heads", 0);
-    secs  = qemu_opt_get_number(legacy_opts, "secs", 0);
-
-    if (cyls || heads || secs) {
-        if (cyls < 1) {
-            error_report("invalid physical cyls number");
-            goto fail;
-        }
-        if (heads < 1) {
-            error_report("invalid physical heads number");
-            goto fail;
-        }
-        if (secs < 1) {
-            error_report("invalid physical secs number");
-            goto fail;
-        }
-    }
-
-    translation = BIOS_ATA_TRANSLATION_AUTO;
-    value = qemu_opt_get(legacy_opts, "trans");
-    if (value != NULL) {
-        if (!cyls) {
-            error_report("'%s' trans must be used with cyls, heads and secs",
-                         value);
-            goto fail;
-        }
-        if (!strcmp(value, "none")) {
-            translation = BIOS_ATA_TRANSLATION_NONE;
-        } else if (!strcmp(value, "lba")) {
-            translation = BIOS_ATA_TRANSLATION_LBA;
-        } else if (!strcmp(value, "large")) {
-            translation = BIOS_ATA_TRANSLATION_LARGE;
-        } else if (!strcmp(value, "rechs")) {
-            translation = BIOS_ATA_TRANSLATION_RECHS;
-        } else if (!strcmp(value, "auto")) {
-            translation = BIOS_ATA_TRANSLATION_AUTO;
-        } else {
-            error_report("'%s' invalid translation type", value);
-            goto fail;
-        }
-    }
-
-    if (media == MEDIA_CDROM) {
-        if (cyls || secs || heads) {
-            error_report("CHS can't be set with media=cdrom");
-            goto fail;
-        }
-    }
-
     /* Device address specified by bus/unit or index.
      * If none was specified, try to find the first free one. */
     bus_id  = qemu_opt_get_number(legacy_opts, "bus", 0);
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     dinfo = g_malloc0(sizeof(*dinfo));
     dinfo->opts = all_opts;
 
-    dinfo->cyls = cyls;
-    dinfo->heads = heads;
-    dinfo->secs = secs;
-    dinfo->trans = translation;
-
     dinfo->type = type;
     dinfo->bus = bus_id;
     dinfo->unit = unit_id;
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_geometry(BlockConf *conf, int *ptrans,
                       unsigned cyls_max, unsigned heads_max, unsigned secs_max,
                       Error **errp)
 {
-    DriveInfo *dinfo;
-
-    if (!conf->cyls && !conf->heads && !conf->secs) {
-        /* try to fall back to value set with legacy -drive cyls=... */
-        dinfo = blk_legacy_dinfo(conf->blk);
-        if (dinfo) {
-            conf->cyls  = dinfo->cyls;
-            conf->heads = dinfo->heads;
-            conf->secs  = dinfo->secs;
-            if (ptrans) {
-                *ptrans = dinfo->trans;
-            }
-        }
-    }
     if (!conf->cyls && !conf->heads && !conf->secs) {
         hd_geometry_guess(conf->blk,
                           &conf->cyls, &conf->heads, &conf->secs,
diff --git a/tests/hd-geo-test.c b/tests/hd-geo-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/hd-geo-test.c
+++ b/tests/hd-geo-test.c
@@ -XXX,XX +XXX,XX @@ static void setup_mbr(int img_idx, MBRcontents mbr)
 
 static int setup_ide(int argc, char *argv[], int argv_sz,
                      int ide_idx, const char *dev, int img_idx,
-                     MBRcontents mbr, const char *opts)
+                     MBRcontents mbr)
 {
     char *s1, *s2, *s3;
 
@@ -XXX,XX +XXX,XX @@ static int setup_ide(int argc, char *argv[], int argv_sz,
         s3 = g_strdup(",media=cdrom");
     }
     argc = append_arg(argc, argv, argv_sz,
-                      g_strdup_printf("%s%s%s%s", s1, s2, s3, opts));
+                      g_strdup_printf("%s%s%s", s1, s2, s3));
     g_free(s1);
     g_free(s2);
     g_free(s3);
@@ -XXX,XX +XXX,XX @@ static void test_ide_mbr(bool use_device, MBRcontents mbr)
     for (i = 0; i < backend_last; i++) {
         cur_ide[i] = &hd_chst[i][mbr];
         dev = use_device ? (is_hd(cur_ide[i]) ? "ide-hd" : "ide-cd") : NULL;
-        argc = setup_ide(argc, argv, ARGV_SIZE, i, dev, i, mbr, "");
+        argc = setup_ide(argc, argv, ARGV_SIZE, i, dev, i, mbr);
     }
     args = g_strjoinv(" ", argv);
     qtest_start(args);
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_user(const char *dev, bool trans)
     const CHST expected_chst = { secs / (4 * 32) , 4, 32, trans };
 
     argc = setup_common(argv, ARGV_SIZE);
-    opts = g_strdup_printf("%s,%s%scyls=%d,heads=%d,secs=%d",
-                           dev ?: "",
-                           trans && dev ? "bios-chs-" : "",
-                           trans ? "trans=lba," : "",
+    opts = g_strdup_printf("%s,%scyls=%d,heads=%d,secs=%d",
+                           dev, trans ? "bios-chs-trans=lba," : "",
                            expected_chst.cyls, expected_chst.heads,
                            expected_chst.secs);
     cur_ide[0] = &expected_chst;
-    argc = setup_ide(argc, argv, ARGV_SIZE,
-                     0, dev ? opts : NULL, backend_small, mbr_chs,
-                     dev ? "" : opts);
+    argc = setup_ide(argc, argv, ARGV_SIZE, 0, opts, backend_small, mbr_chs);
     g_free(opts);
     args = g_strjoinv(" ", argv);
     qtest_start(args);
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_user(const char *dev, bool trans)
 }
 
 /*
- * Test case: IDE device (if=ide) with explicit CHS
- */
-static void test_ide_drive_user_chs(void)
-{
-    test_ide_drive_user(NULL, false);
-}
-
-/*
- * Test case: IDE device (if=ide) with explicit CHS and translation
- */
-static void test_ide_drive_user_chst(void)
-{
-    test_ide_drive_user(NULL, true);
-}
-
-/*
  * Test case: IDE device (if=none) with explicit CHS
  */
 static void test_ide_device_user_chs(void)
@@ -XXX,XX +XXX,XX @@ static void test_ide_drive_cd_0(void)
     for (i = 0; i <= backend_empty; i++) {
         ide_idx = backend_empty - i;
         cur_ide[ide_idx] = &hd_chst[i][mbr_blank];
-        argc = setup_ide(argc, argv, ARGV_SIZE,
-                         ide_idx, NULL, i, mbr_blank, "");
+        argc = setup_ide(argc, argv, ARGV_SIZE, ide_idx, NULL, i, mbr_blank);
     }
     args = g_strjoinv(" ", argv);
     qtest_start(args);
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     qtest_add_func("hd-geo/ide/drive/mbr/blank", test_ide_drive_mbr_blank);
     qtest_add_func("hd-geo/ide/drive/mbr/lba", test_ide_drive_mbr_lba);
     qtest_add_func("hd-geo/ide/drive/mbr/chs", test_ide_drive_mbr_chs);
-    qtest_add_func("hd-geo/ide/drive/user/chs", test_ide_drive_user_chs);
-    qtest_add_func("hd-geo/ide/drive/user/chst", test_ide_drive_user_chst);
     qtest_add_func("hd-geo/ide/drive/cd_0", test_ide_drive_cd_0);
     qtest_add_func("hd-geo/ide/device/mbr/blank", test_ide_device_mbr_blank);
     qtest_add_func("hd-geo/ide/device/mbr/lba", test_ide_device_mbr_lba);
diff --git a/hmp-commands.hx b/hmp-commands.hx
index XXXXXXX..XXXXXXX 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
         .params     = "[-n] [[<domain>:]<bus>:]<slot>\n"
                       "[file=file][,if=type][,bus=n]\n"
                       "[,unit=m][,media=d][,index=i]\n"
-                      "[,cyls=c,heads=h,secs=s[,trans=t]]\n"
                       "[,snapshot=on|off][,cache=on|off]\n"
                       "[,readonly=on|off][,copy-on-read=on|off]",
         .help       = "add drive to PCI storage controller",
diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ with ``-device ...,netdev=x''), or ``-nic user,smb=/some/dir''
 (for embedded NICs). The new syntax allows different settings to be
 provided per NIC.
 
-@subsection -drive cyls=...,heads=...,secs=...,trans=... (since 2.10.0)
-
-The drive geometry arguments are replaced by the the geometry arguments
-that can be specified with the ``-device'' parameter.
-
 @subsection -drive serial=... (since 2.10.0)
 
 The drive serial argument is replaced by the the serial argument
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
 
 DEF("drive", HAS_ARG, QEMU_OPTION_drive,
     "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
-    "       [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
     "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
-    "       [,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
+    "       [,snapshot=on|off][,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
     "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
     "       [,readonly=on|off][,copy-on-read=on|off]\n"
     "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
@@ -XXX,XX +XXX,XX @@ This option defines where is connected the drive by using an index in the list
 of available connectors of a given interface type.
 @item media=@var{media}
 This option defines the type of the media: disk or cdrom.
-@item cyls=@var{c},heads=@var{h},secs=@var{s}[,trans=@var{t}]
-Force disk physical geometry and the optional BIOS translation (trans=none or
-lba). These parameters are deprecated, use the corresponding parameters
-of @code{-device} instead.
 @item snapshot=@var{snapshot}
 @var{snapshot} is "on" or "off" and controls snapshot mode for the given drive
 (see @option{-snapshot}).
-- 
2.13.6

The -drive option addr was deprecated in QEMU 2.10. It's time to remove
it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
---
 include/sysemu/blockdev.h |  1 -
 blockdev.c                | 17 +----------------
 device-hotplug.c          |  4 ----
 qemu-doc.texi             |  5 -----
 qemu-options.hx           |  5 +----
 5 files changed, 2 insertions(+), 30 deletions(-)

diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/blockdev.h
+++ b/include/sysemu/blockdev.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
 } BlockInterfaceType;
 
 struct DriveInfo {
-    const char *devaddr;
     BlockInterfaceType type;
     int bus;
     int unit;
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
             .type = QEMU_OPT_STRING,
             .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
         },{
-            .name = "addr",
-            .type = QEMU_OPT_STRING,
-            .help = "pci address (virtio only)",
-        },{
             .name = "serial",
             .type = QEMU_OPT_STRING,
             .help = "disk serial number",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     DriveMediaType media = MEDIA_DISK;
     BlockInterfaceType type;
     int max_devs, bus_id, unit_id, index;
-    const char *devaddr;
     const char *werror, *rerror;
     bool read_only = false;
     bool copy_on_read;
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     Error *local_err = NULL;
     int i;
     const char *deprecated[] = {
-        "serial", "addr"
+        "serial"
     };
 
     /* Change legacy command line options into QMP ones */
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     }
 
     /* Add virtio block device */
-    devaddr = qemu_opt_get(legacy_opts, "addr");
-    if (devaddr && type != IF_VIRTIO) {
-        error_report("addr is not supported by this bus type");
-        goto fail;
-    }
-
     if (type == IF_VIRTIO) {
         QemuOpts *devopts;
         devopts = qemu_opts_create(qemu_find_opts("device"), NULL, 0,
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
         }
         qemu_opt_set(devopts, "drive", qdict_get_str(bs_opts, "id"),
                      &error_abort);
-        if (devaddr) {
-            qemu_opt_set(devopts, "addr", devaddr, &error_abort);
-        }
     }
 
     filename = qemu_opt_get(legacy_opts, "file");
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     dinfo->type = type;
     dinfo->bus = bus_id;
     dinfo->unit = unit_id;
-    dinfo->devaddr = devaddr;
     dinfo->serial = g_strdup(serial);
 
     blk_set_legacy_dinfo(blk, dinfo);
diff --git a/device-hotplug.c b/device-hotplug.c
index XXXXXXX..XXXXXXX 100644
--- a/device-hotplug.c
+++ b/device-hotplug.c
@@ -XXX,XX +XXX,XX @@ void hmp_drive_add(Monitor *mon, const QDict *qdict)
     if (!dinfo) {
         goto err;
     }
-    if (dinfo->devaddr) {
-        monitor_printf(mon, "Parameter addr not supported\n");
-        goto err;
-    }
 
     switch (dinfo->type) {
     case IF_NONE:
diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ provided per NIC.
 The drive serial argument is replaced by the the serial argument
 that can be specified with the ``-device'' parameter.
 
-@subsection -drive addr=... (since 2.10.0)
-
-The drive addr argument is replaced by the the addr argument
-that can be specified with the ``-device'' parameter.
-
 @subsection -usbdevice (since 2.10.0)
 
 The ``-usbdevice DEV'' argument is now a synonym for setting
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
 DEF("drive", HAS_ARG, QEMU_OPTION_drive,
     "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
     "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
-    "       [,snapshot=on|off][,serial=s][,addr=A][,rerror=ignore|stop|report]\n"
+    "       [,snapshot=on|off][,serial=s][,rerror=ignore|stop|report]\n"
     "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
     "       [,readonly=on|off][,copy-on-read=on|off]\n"
     "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
@@ -XXX,XX +XXX,XX @@ an untrusted format header.
 This option specifies the serial number to assign to the device. This
 parameter is deprecated, use the corresponding parameter of @code{-device}
 instead.
-@item addr=@var{addr}
-Specify the controller's PCI address (if=virtio only). This parameter is
-deprecated, use the corresponding parameter of @code{-device} instead.
 @item werror=@var{action},rerror=@var{action}
 Specify which @var{action} to take on write and read errors. Valid actions are:
 "ignore" (ignore the error and try to continue), "stop" (pause QEMU),
-- 
2.13.6

The -drive option serial was deprecated in QEMU 2.10. It's time to
remove it.

Tests need to be updated to set the serial number with -global instead
of using the -drive option.

diff --git a/include/hw/block/block.h b/include/hw/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/block/block.h
+++ b/include/hw/block/block.h
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
 
 /* Configuration helpers */
 
-void blkconf_serial(BlockConf *conf, char **serial);
 bool blkconf_geometry(BlockConf *conf, int *trans,
                       unsigned cyls_max, unsigned heads_max, unsigned secs_max,
                       Error **errp);
diff --git a/include/sysemu/blockdev.h b/include/sysemu/blockdev.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/blockdev.h
+++ b/include/sysemu/blockdev.h
@@ -XXX,XX +XXX,XX @@ struct DriveInfo {
     bool is_default;            /* Added by default_drive() ?  */
     int media_cd;
     QemuOpts *opts;
-    char *serial;
     QTAILQ_ENTRY(DriveInfo) next;
 };
 
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static void drive_info_del(DriveInfo *dinfo)
         return;
     }
     qemu_opts_del(dinfo->opts);
-    g_free(dinfo->serial);
     g_free(dinfo);
 }
 
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
             .type = QEMU_OPT_STRING,
             .help = "interface (ide, scsi, sd, mtd, floppy, pflash, virtio)",
         },{
-            .name = "serial",
-            .type = QEMU_OPT_STRING,
-            .help = "disk serial number",
-        },{
             .name = "file",
             .type = QEMU_OPT_STRING,
             .help = "file name",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     const char *werror, *rerror;
     bool read_only = false;
     bool copy_on_read;
-    const char *serial;
     const char *filename;
     Error *local_err = NULL;
     int i;
     const char *deprecated[] = {
-        "serial"
     };
 
     /* Change legacy command line options into QMP ones */
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
         goto fail;
     }
 
-    /* Serial number */
-    serial = qemu_opt_get(legacy_opts, "serial");
-
     /* no id supplied -> create one */
     if (qemu_opts_id(all_opts) == NULL) {
         char *new_id;
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     dinfo->type = type;
     dinfo->bus = bus_id;
     dinfo->unit = unit_id;
-    dinfo->serial = g_strdup(serial);
 
     blk_set_legacy_dinfo(blk, dinfo);
 
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qapi-types-block.h"
 #include "qemu/error-report.h"
 
-void blkconf_serial(BlockConf *conf, char **serial)
-{
-    DriveInfo *dinfo;
-
-    if (!*serial) {
-        /* try to fall back to value set with legacy -drive serial=... */
-        dinfo = blk_legacy_dinfo(conf->blk);
-        if (dinfo) {
-            *serial = g_strdup(dinfo->serial);
-        }
-    }
-}
-
 void blkconf_blocksizes(BlockConf *conf)
 {
     BlockBackend *blk = conf->blk;
diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
         return;
     }
 
-    blkconf_serial(&n->conf, &n->serial);
     if (!n->serial) {
         error_setg(errp, "serial property not set");
         return;
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
         return;
     }
 
-    blkconf_serial(&conf->conf, &conf->serial);
     if (!blkconf_apply_backend_options(&conf->conf,
                                        blk_is_read_only(conf->conf.blk), true,
                                        errp)) {
diff --git a/hw/ide/qdev.c b/hw/ide/qdev.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/ide/qdev.c
+++ b/hw/ide/qdev.c
@@ -XXX,XX +XXX,XX @@ static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp)
         return;
     }
 
-    blkconf_serial(&dev->conf, &dev->serial);
     if (kind != IDE_CD) {
         if (!blkconf_geometry(&dev->conf, &dev->chs_trans, 65535, 16, 255,
                               errp)) {
diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/scsi-disk.c
+++ b/hw/scsi/scsi-disk.c
@@ -XXX,XX +XXX,XX @@ static void scsi_realize(SCSIDevice *dev, Error **errp)
         return;
     }
 
-    blkconf_serial(&s->qdev.conf, &s->serial);
     blkconf_blocksizes(&s->qdev.conf);
 
     if (s->qdev.conf.logical_block_size >
diff --git a/hw/usb/dev-storage.c b/hw/usb/dev-storage.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/usb/dev-storage.c
+++ b/hw/usb/dev-storage.c
@@ -XXX,XX +XXX,XX @@ static void usb_msd_storage_realize(USBDevice *dev, Error **errp)
         return;
     }
 
-    blkconf_serial(&s->conf, &dev->serial);
     blkconf_blocksizes(&s->conf);
     if (!blkconf_apply_backend_options(&s->conf, blk_is_read_only(blk), true,
                                        errp)) {
diff --git a/tests/ahci-test.c b/tests/ahci-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/ahci-test.c
+++ b/tests/ahci-test.c
@@ -XXX,XX +XXX,XX @@ static AHCIQState *ahci_boot(const char *cli, ...)
         s = ahci_vboot(cli, ap);
         va_end(ap);
     } else {
-        cli = "-drive if=none,id=drive0,file=%s,cache=writeback,serial=%s"
-            ",format=%s"
+        cli = "-drive if=none,id=drive0,file=%s,cache=writeback,format=%s"
             " -M q35 "
             "-device ide-hd,drive=drive0 "
+            "-global ide-hd.serial=%s "
             "-global ide-hd.ver=%s";
-        s = ahci_boot(cli, tmp_path, "testdisk", imgfmt, "version");
+        s = ahci_boot(cli, tmp_path, imgfmt, "testdisk", "version");
     }
 
     return s;
diff --git a/tests/ide-test.c b/tests/ide-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/ide-test.c
+++ b/tests/ide-test.c
@@ -XXX,XX +XXX,XX @@ static void test_bmdma_no_busmaster(void)
 static void test_bmdma_setup(void)
 {
     ide_test_start(
-        "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
-        "-global ide-hd.ver=%s",
+        "-drive file=%s,if=ide,cache=writeback,format=raw "
+        "-global ide-hd.serial=%s -global ide-hd.ver=%s",
         tmp_path, "testdisk", "version");
     qtest_irq_intercept_in(global_qtest, "ioapic");
 }
@@ -XXX,XX +XXX,XX @@ static void test_identify(void)
     int ret;
 
     ide_test_start(
-        "-drive file=%s,if=ide,serial=%s,cache=writeback,format=raw "
-        "-global ide-hd.ver=%s",
+        "-drive file=%s,if=ide,cache=writeback,format=raw "
+        "-global ide-hd.serial=%s -global ide-hd.ver=%s",
         tmp_path, "testdisk", "version");
 
     dev = get_pci_device(&bmdma_bar, &ide_bar);
diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ with ``-device ...,netdev=x''), or ``-nic user,smb=/some/dir''
 (for embedded NICs). The new syntax allows different settings to be
 provided per NIC.
 
-@subsection -drive serial=... (since 2.10.0)
-
-The drive serial argument is replaced by the the serial argument
-that can be specified with the ``-device'' parameter.
-
 @subsection -usbdevice (since 2.10.0)
 
 The ``-usbdevice DEV'' argument is now a synonym for setting
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
 DEF("drive", HAS_ARG, QEMU_OPTION_drive,
     "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
     "       [,cache=writethrough|writeback|none|directsync|unsafe][,format=f]\n"
-    "       [,snapshot=on|off][,serial=s][,rerror=ignore|stop|report]\n"
+    "       [,snapshot=on|off][,rerror=ignore|stop|report]\n"
     "       [,werror=ignore|stop|report|enospc][,id=name][,aio=threads|native]\n"
     "       [,readonly=on|off][,copy-on-read=on|off]\n"
     "       [,discard=ignore|unmap][,detect-zeroes=on|off|unmap]\n"
@@ -XXX,XX +XXX,XX @@ The default mode is @option{cache=writeback}.
 Specify which disk @var{format} will be used rather than detecting
 the format.  Can be used to specify format=raw to avoid interpreting
 an untrusted format header.
-@item serial=@var{serial}
-This option specifies the serial number to assign to the device. This
-parameter is deprecated, use the corresponding parameter of @code{-device}
-instead.
 @item werror=@var{action},rerror=@var{action}
 Specify which @var{action} to take on write and read errors. Valid actions are:
 "ignore" (ignore the error and try to continue), "stop" (pause QEMU),
-- 
2.13.6

We removed all options from the 'deprecated' array, so the code is dead
and can be removed as well.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
---
 blockdev.c | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
     const char *filename;
     Error *local_err = NULL;
     int i;
-    const char *deprecated[] = {
-    };
 
     /* Change legacy command line options into QMP ones */
     static const struct {
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
         goto fail;
     }
 
-    /* Other deprecated options */
-    if (!qtest_enabled()) {
-        for (i = 0; i < ARRAY_SIZE(deprecated); i++) {
-            if (qemu_opt_get(legacy_opts, deprecated[i]) != NULL) {
-                error_report("'%s' is deprecated, please use the corresponding "
-                             "option of '-device' instead", deprecated[i]);
-            }
-        }
-    }
-
     /* Media type */
     value = qemu_opt_get(legacy_opts, "media");
     if (value) {
-- 
2.13.6