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

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 +

55 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

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>

include/block/qdict.h | 1 +

block/nfs.c | 2 +-

block/parallels.c | 2 +-

block/qcow.c | 2 +-

block/qcow2.c | 2 +-

block/qed.c | 2 +-

block/rbd.c | 2 +-

block/sheepdog.c | 2 +-

block/vhdx.c | 2 +-

block/vpc.c | 2 +-

qobject/block-qdict.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++++

11 files changed, 67 insertions(+), 9 deletions(-)

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

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

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,

const QDictEntry *e;

Error *local_err = NULL;

- crumpled = qdict_crumple(options, errp);

+ crumpled = qdict_crumple_for_keyval_qiv(options, errp);

if (crumpled == NULL) {

return NULL;

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,

qdict_put_str(qdict, "driver", "parallels");

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/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,

qdict_put_str(qdict, "driver", "qcow");

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

qdict_put_str(qdict, "file", bs->node_name);

/* Now get the QAPI type BlockdevCreateOptions */

- 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/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,

/* Convert the remaining options into a QAPI object */

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

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,

qdict_put_str(qdict, "driver", "vhdx");

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/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)

}

/**

+ * qdict_crumple_for_keyval_qiv:

+ * @src: the flat dictionary (only scalar values) to crumple

+ * @errp: location to store error

+ *

+ * Like qdict_crumple(), but additionally transforms scalar values so

+ * the result can be passed to qobject_input_visitor_new_keyval().

+ *

+ * The block subsystem uses this function to prepare its flat QDict

+ * with possibly confused scalar types for a visit. It should not be

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

+{

+ 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

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>

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

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

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>

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

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

Signed-off-by: Markus Armbruster <armbru@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

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

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

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

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