* [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties
@ 2016-09-27 13:13 Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict Daniel P. Berrange
` (19 more replies)
0 siblings, 20 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
An update of a series previously posted
v1: https://lists.gnu.org/archive/html/qemu-devel/2016-02/msg04618.html
v2: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg01454.html
v3: https://lists.gnu.org/archive/html/qemu-devel/2016-03/msg02498.html
v4: https://lists.gnu.org/archive/html/qemu-devel/2016-05/msg01661.html
v5: https://lists.gnu.org/archive/html/qemu-devel/2016-06/msg00485.html
v6: https://lists.gnu.org/archive/html/qemu-devel/2016-06/msg03876.html
v7: https://lists.gnu.org/archive/html/qemu-devel/2016-07/msg00919.html
v8: https://lists.gnu.org/archive/html/qemu-devel/2016-07/msg03115.html
v9: https://lists.gnu.org/archive/html/qemu-devel/2016-08/msg02653.html
v10: https://lists.gnu.org/archive/html/qemu-devel/2016-08/msg02694.html
v11: https://lists.gnu.org/archive/html/qemu-devel/2016-09/msg00652.html
v12: https://lists.gnu.org/archive/html/qemu-devel/2016-09/msg03559.html
v13: https://lists.gnu.org/archive/html/qemu-devel/2016-09/msg04212.html
This series provides the infrastructure to allow use of non-scalar
properties with the -object CLI arg, and object_add monitor commands.
eg a property which is a list of structs. The syntax used for this is
intentionally compatible with the syntax used by the block layer. This
will allow the qdict_crumple method to be used by the block layer to
convert from QemuOpts into structured QAPI block layer structs at a
future date. It is already used by one of Max's patch series, by
Kevin's -blockdev series, and by my own ACL series.
This patch series has grown a fair bit larger since the previous
posting (19 patches instead of 6). This was to avoid trying to
squish too much into one patch, to make it easier to review.
It does not neccessarily need tobe merged in one go. Patches
1-12 deal with the QAPI visitor logic and can be merged
indendepedently which would unblock other people waiting on
this. Patches 13-19 deal with converting code over to use
the new visitor logic and can be fed in via various maintainers
trees if desired.
Once this is merged, there is also scope to further enhance the
QObjectInputVisitor to deal with visiting single-properties,
which would let us delete StringInputVisitor too. This would
mean we have a single input visitor class, instead of the
current three.
Changed in v14:
- Extend qemu_opts_to_qdict to optionally handle case of
repeated keys without dropping them.
- Support parsing of integer ranges for "list of int" visits
for back compat with OptsVisitor
- Support visiting nested structs which are represented as
a flat keyspace for back compat with OptsVisitor
- Add trace events for visitor functions to facilitate
debugging
- Add a QObjectInputVisitor constructor which takes a
QemuOpts object, to avoid repeated code patterns in callers
- Greater test coverage of -object to validate correct handling
of "list of ints" legacy OptsVisitor syntax
- Convert all other use of OptsVisitor to QObjectInputVisitor
- Delete OptsVisitor
Changed in v13:
- Fix typos (Kevin)
- Remove unneeded line breaks (Kevin)
Changed in v12:
- More user friendly error message for mixing dict/list
keys (Kevin)
- Report error instead of assert for non-contiguous list
keys (Kevin)
- Fix tests for non-contiguous list keys (Kevin)
- Add tests for escaping of '.' when crumpling (Kevin)
- Fix remaining references to Qmp(In|Out)putVisitor (Markus)
- Misc typos / whitespace fixes (Eric, Kevin)
- Avoid touching 'ret' when parsing int64 fails (Eric)
- Testing of more edge cases in QObjectInputVisitor (Eric)
- Simplify API doc format (Markus)
- Use parse_option_size instead of qemu_strtosz_suffix
for consistency (Kevin)
- Use safer qobject_to_qdict casts (Eric)
Changed in v11:
- Split QAPI/QOM patches off from the access control patches
Changed in v10:
- Fixed stupid build mistake
Changed in v9:
- Rename QmpInputVisitor -> QObjectInputVisitor (Markus/Eric)
- Rename QmpOutputVisitor -> QObjectOutputVisitor (Markus/Eric)
- Drop "strict" param from qobject_string_visitor_new() (Marus)
- Misc docs typos
- Add a visitor able to use strict or string types (for Eric's
netdev series)
- Add a authorization API implementation that uses PAM
Changed in v8:
- Rebase due to merge of Visitor API changes (Eric)
Changed in v7:
- Misc typos in API docs (Marc-André)
- Fix parsing of properties using type_size visitor (Marc-André)
- Mark based auth class as abstract (Marc-André)
- Fix QAPI version annotations to say 2.7 (Marc-André)
Changed in v6:
- Switch from while() to for() loop for iterating over
dicts (Markus)
- Avoid redundant strdup (Markus)
- Rewrap comments at 70 chars (Markus)
- Change qdict_list_size() to qdict_is_list() (Markus)
- Misc docs changes (Markus)
- Change QmpInputVisitor so the code for handling the
string types is separate from code using native
scalar types (Paolo)
- Centralize code parsing bool strings (Markus)
- Centralize code parsing int strings (Markus)
Changed in v5:
- Resolved conflicts with Eric's visitor refactoring which
made it stricter about struct begin/end calls
- Added support for ACLs to migration code now its TLS
support is merged.
- Fixed typos in example in commit message
Changed in v4:
- Ensure examples use shell escaping for '*' (Eric)
- Add more tests for crumple impl (Eric)
- Raise error if sasl-acl/tls-acl are requested but
sasl/tls auth are not enabled (Eric)
- Document return codes for auth check more clearly (Eric)
- Don't silently turn a glob match into a strcmp
- Other misc small typos/fixes (Eric)
Changed in v3:
- Created separate qdict_list_size method (Max)
- Added unit tests for case of empty dict (Max)
- Fix variable names to use underscore separator (Max)
- Fix potential free of uninitialized variables (Max)
- Use QObject APIs for casts, instead of C type casts (Max)
Changed in v2:
- Adapt to changes in qapi visitor APIs
- Add a 'bool recursive' flag to qdict_crumple (Max)
- Fix memory leaks in qdict_crumple (Max)
- Split out key splitting code from qdict_crumple (Max)
- Use saner variable names in qdict_crumple (Max)
- Added some tests for bad inputs to qdict_crumple
Daniel P. Berrange (19):
qdict: implement a qdict_crumple method for un-flattening a dict
option: make parse_option_bool/number non-static
option: allow qemu_opts_to_qdict to merge repeated options
qapi: add trace events for visitor
qapi: rename QmpInputVisitor to QObjectInputVisitor
qapi: rename QmpOutputVisitor to QObjectOutputVisitor
qapi: don't pass two copies of TestInputVisitorData to tests
qapi: permit scalar type conversions in QObjectInputVisitor
qapi: permit auto-creating single element lists
qapi: permit auto-creating nested structs
qapi: add integer range support for QObjectInputVisitor
qapi: allow QObjectInputVisitor to be created with QemuOpts
qom: support non-scalar properties with -object
hmp: support non-scalar properties with object_add
numa: convert to use QObjectInputVisitor for -numa
block: convert crypto driver to use QObjectInputVisitor
acpi: convert to QObjectInputVisitor for -acpi parsing
net: convert to QObjectInputVisitor for -net/-netdev parsing
qapi: delete unused OptsVisitor code
Makefile.objs | 1 +
block/crypto.c | 12 +-
block/qapi.c | 4 +-
blockdev.c | 11 +-
docs/qapi-code-gen.txt | 4 +-
hmp.c | 25 +-
hw/acpi/core.c | 14 +-
include/qapi/opts-visitor.h | 40 --
include/qapi/qmp-input-visitor.h | 30 -
include/qapi/qmp/qdict.h | 1 +
include/qapi/qobject-input-visitor.h | 124 ++++
...p-output-visitor.h => qobject-output-visitor.h} | 10 +-
include/qapi/visitor.h | 6 +-
include/qemu/option.h | 12 +-
include/sysemu/numa_int.h | 11 +
monitor.c | 5 +-
net/net.c | 17 +-
numa.c | 36 +-
qapi/Makefile.objs | 6 +-
qapi/opts-visitor.c | 561 ---------------
qapi/qapi-clone-visitor.c | 2 +-
qapi/qapi-visit-core.c | 27 +
qapi/qmp-input-visitor.c | 412 -----------
qapi/qmp-output-visitor.c | 256 -------
qapi/qobject-input-visitor.c | 778 +++++++++++++++++++++
qapi/qobject-output-visitor.c | 254 +++++++
qapi/trace-events | 33 +
qemu-img.c | 12 +-
qemu-io-cmds.c | 3 +-
qemu-io.c | 6 +-
qemu-nbd.c | 3 +-
qmp.c | 4 +-
qobject/qdict.c | 291 ++++++++
qom/object_interfaces.c | 41 +-
qom/qom-qobject.c | 8 +-
scripts/qapi-commands.py | 8 +-
scripts/qapi-event.py | 4 +-
stubs/Makefile.objs | 5 +
stubs/exec.c | 6 +
stubs/hostmem.c | 14 +
stubs/memory.c | 41 ++
stubs/qdev.c | 8 +
stubs/vl.c | 8 +
stubs/vmstate.c | 4 +
target-s390x/cpu_models.c | 4 +-
tests/.gitignore | 6 +-
tests/Makefile.include | 27 +-
tests/check-qdict.c | 260 +++++++
tests/check-qnull.c | 8 +-
tests/check-qom-proplist.c | 367 +++++++++-
tests/qemu-iotests/051.out | 6 +-
tests/qemu-iotests/051.pc.out | 6 +-
tests/qemu-iotests/137.out | 4 +-
tests/test-numa.c | 116 +++
tests/test-opts-visitor.c | 268 -------
tests/test-qemu-opts.c | 40 ++
tests/test-qmp-commands.c | 4 +-
...-input-strict.c => test-qobject-input-strict.c} | 6 +-
...nput-visitor.c => test-qobject-input-visitor.c} | 637 +++++++++++++++--
...put-visitor.c => test-qobject-output-visitor.c} | 6 +-
tests/test-replication.c | 9 +-
tests/test-string-input-visitor.c | 2 +-
tests/test-string-output-visitor.c | 2 +-
tests/test-visitor-serialization.c | 8 +-
util/qemu-option.c | 68 +-
util/qemu-sockets.c | 4 +-
vl.c | 1 -
67 files changed, 3246 insertions(+), 1771 deletions(-)
delete mode 100644 include/qapi/opts-visitor.h
delete mode 100644 include/qapi/qmp-input-visitor.h
create mode 100644 include/qapi/qobject-input-visitor.h
rename include/qapi/{qmp-output-visitor.h => qobject-output-visitor.h} (66%)
create mode 100644 include/sysemu/numa_int.h
delete mode 100644 qapi/opts-visitor.c
delete mode 100644 qapi/qmp-input-visitor.c
delete mode 100644 qapi/qmp-output-visitor.c
create mode 100644 qapi/qobject-input-visitor.c
create mode 100644 qapi/qobject-output-visitor.c
create mode 100644 qapi/trace-events
create mode 100644 stubs/exec.c
create mode 100644 stubs/hostmem.c
create mode 100644 stubs/memory.c
create mode 100644 stubs/qdev.c
create mode 100644 stubs/vl.c
create mode 100644 tests/test-numa.c
delete mode 100644 tests/test-opts-visitor.c
rename tests/{test-qmp-input-strict.c => test-qobject-input-strict.c} (98%)
rename tests/{test-qmp-input-visitor.c => test-qobject-input-visitor.c} (57%)
rename tests/{test-qmp-output-visitor.c => test-qobject-output-visitor.c} (99%)
--
2.7.4
^ permalink raw reply [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 21:22 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 02/19] option: make parse_option_bool/number non-static Daniel P. Berrange
` (18 subsequent siblings)
19 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The qdict_flatten() method will take a dict whose elements are
further nested dicts/lists and flatten them by concatenating
keys.
The qdict_crumple() method aims to do the reverse, taking a flat
qdict, and turning it into a set of nested dicts/lists. It will
apply nesting based on the key name, with a '.' indicating a
new level in the hierarchy. If the keys in the nested structure
are all numeric, it will create a list, otherwise it will create
a dict.
If the keys are a mixture of numeric and non-numeric, or the
numeric keys are not in strictly ascending order, an error will
be reported.
As an example, a flat dict containing
{
'foo.0.bar': 'one',
'foo.0.wizz': '1',
'foo.1.bar': 'two',
'foo.1.wizz': '2'
}
will get turned into a dict with one element 'foo' whose
value is a list. The list elements will each in turn be
dicts.
{
'foo': [
{ 'bar': 'one', 'wizz': '1' },
{ 'bar': 'two', 'wizz': '2' }
],
}
If the key is intended to contain a literal '.', then it must
be escaped as '..'. ie a flat dict
{
'foo..bar': 'wizz',
'bar.foo..bar': 'eek',
'bar.hello': 'world'
}
Will end up as
{
'foo.bar': 'wizz',
'bar': {
'foo.bar': 'eek',
'hello': 'world'
}
}
The intent of this function is that it allows a set of QemuOpts
to be turned into a nested data structure that mirrors the nesting
used when the same object is defined over QMP.
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qmp/qdict.h | 1 +
qobject/qdict.c | 291 +++++++++++++++++++++++++++++++++++++++++++++++
tests/check-qdict.c | 260 ++++++++++++++++++++++++++++++++++++++++++
3 files changed, 552 insertions(+)
diff --git a/include/qapi/qmp/qdict.h b/include/qapi/qmp/qdict.h
index 71b8eb0..e0d24e1 100644
--- a/include/qapi/qmp/qdict.h
+++ b/include/qapi/qmp/qdict.h
@@ -73,6 +73,7 @@ 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, bool recursive, Error **errp);
void qdict_join(QDict *dest, QDict *src, bool overwrite);
diff --git a/qobject/qdict.c b/qobject/qdict.c
index 60f158c..beef273 100644
--- a/qobject/qdict.c
+++ b/qobject/qdict.c
@@ -17,6 +17,7 @@
#include "qapi/qmp/qbool.h"
#include "qapi/qmp/qstring.h"
#include "qapi/qmp/qobject.h"
+#include "qapi/error.h"
#include "qemu/queue.h"
#include "qemu-common.h"
#include "qemu/cutils.h"
@@ -683,6 +684,296 @@ void qdict_array_split(QDict *src, QList **dst)
}
}
+
+/**
+ * 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.
+ *
+ * eg
+ * '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_strtoll(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 - eg 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 indexes 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
+ * @recursive: true to recursively crumple nested dictionaries
+ *
+ * Takes a flat dictionary whose keys use '.' separator to indicate
+ * nesting, and values are scalars, and crumples it into a nested
+ * structure. If the @recursive parameter is false, then only the
+ * first level of structure implied by the keys will be crumpled. If
+ * @recursive is true, then the input will be recursively crumpled to
+ * expand all levels of structure in the keys.
+ *
+ * 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 any 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. eg, "foo.0.bar" and "foo.eek.bar".
+ * - If keys in @src imply that a particular level is a list,
+ * but the indexes are non-contigous. eg "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. eg "foo.+0.bar"
+ *
+ * Returns: either a QDict or QList for the nested data structure, or NULL
+ * on error
+ */
+QObject *qdict_crumple(const QDict *src, bool recursive, 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)) {
+ /* Input should be totally flat, so if we see a dict/list as a
+ * value that's invalid usage of the API */
+ 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) {
+ if (child) {
+ if (qobject_type(child) != QTYPE_QDICT) {
+ error_setg(errp, "Key %s prefix is already set as a scalar",
+ prefix);
+ goto error;
+ }
+ } else {
+ child = QOBJECT(qdict_new());
+ qdict_put_obj(two_level, prefix, child);
+ }
+ qobject_incref(ent->value);
+ qdict_put_obj(qobject_to_qdict(child), suffix, ent->value);
+ } else {
+ if (child) {
+ error_setg(errp, "Key %s prefix is already set as a dict",
+ prefix);
+ goto error;
+ }
+ qobject_incref(ent->value);
+ qdict_put_obj(two_level, prefix, ent->value);
+ }
+
+ g_free(prefix);
+ prefix = NULL;
+ }
+
+ /* Step 2: optionally process the two level dict recursively
+ * into a multi-level dict */
+ if (recursive) {
+ multi_level = qdict_new();
+ for (ent = qdict_first(two_level); ent != NULL;
+ ent = qdict_next(two_level, ent)) {
+
+ if (qobject_type(ent->value) == QTYPE_QDICT) {
+ child = qdict_crumple(qobject_to_qdict(ent->value),
+ recursive, errp);
+ if (!child) {
+ goto error;
+ }
+
+ qdict_put_obj(multi_level, ent->key, child);
+ } else {
+ qobject_incref(ent->value);
+ qdict_put_obj(multi_level, ent->key, ent->value);
+ }
+ }
+ QDECREF(two_level);
+ } else {
+ multi_level = 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;
+ }
+
+ qobject_incref(child);
+ qlist_append_obj(qobject_to_qlist(dst), child);
+ }
+ QDECREF(multi_level);
+ multi_level = NULL;
+ } else {
+ dst = QOBJECT(multi_level);
+ }
+
+ return dst;
+
+ error:
+ g_free(prefix);
+ QDECREF(multi_level);
+ QDECREF(two_level);
+ qobject_decref(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
diff --git a/tests/check-qdict.c b/tests/check-qdict.c
index 42da1e6..bb0bf75 100644
--- a/tests/check-qdict.c
+++ b/tests/check-qdict.c
@@ -14,6 +14,7 @@
#include "qapi/qmp/qint.h"
#include "qapi/qmp/qdict.h"
#include "qapi/qmp/qstring.h"
+#include "qapi/error.h"
#include "qemu-common.h"
/*
@@ -595,6 +596,254 @@ static void qdict_join_test(void)
QDECREF(dict2);
}
+
+static void qdict_crumple_test_nonrecursive(void)
+{
+ QDict *src, *dst, *rules, *vnc, *acl;
+ QObject *child, *res;
+
+ src = qdict_new();
+ qdict_put(src, "vnc.listen.addr", qstring_from_str("127.0.0.1"));
+ qdict_put(src, "vnc.listen.port", qstring_from_str("5901"));
+ qdict_put(src, "rule.0.match", qstring_from_str("fred"));
+ qdict_put(src, "rule.0.policy", qstring_from_str("allow"));
+ qdict_put(src, "rule.1.match", qstring_from_str("bob"));
+ qdict_put(src, "rule.1.policy", qstring_from_str("deny"));
+ qdict_put(src, "acl..name", qstring_from_str("acl0"));
+ qdict_put(src, "acl.rule..name", qstring_from_str("acl0"));
+
+ res = qdict_crumple(src, false, &error_abort);
+
+ g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT);
+
+ dst = qobject_to_qdict(res);
+
+ g_assert_cmpint(qdict_size(dst), ==, 4);
+
+ child = qdict_get(dst, "vnc");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ vnc = qdict_get_qdict(dst, "vnc");
+
+ g_assert_cmpint(qdict_size(vnc), ==, 2);
+
+ g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(vnc, "listen.addr"));
+ g_assert_cmpstr("5901", ==, qdict_get_str(vnc, "listen.port"));
+
+ child = qdict_get(dst, "rule");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ rules = qdict_get_qdict(dst, "rule");
+
+ g_assert_cmpint(qdict_size(rules), ==, 4);
+
+ g_assert_cmpstr("fred", ==, qdict_get_str(rules, "0.match"));
+ g_assert_cmpstr("allow", ==, qdict_get_str(rules, "0.policy"));
+ g_assert_cmpstr("bob", ==, qdict_get_str(rules, "1.match"));
+ g_assert_cmpstr("deny", ==, qdict_get_str(rules, "1.policy"));
+
+ /* With non-recursive crumpling, we should only see the first
+ * level names unescaped */
+ g_assert_cmpstr("acl0", ==, qdict_get_str(dst, "acl.name"));
+ child = qdict_get(dst, "acl");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ acl = qdict_get_qdict(dst, "acl");
+ g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule..name"));
+
+ QDECREF(src);
+ QDECREF(dst);
+}
+
+
+static void qdict_crumple_test_listtop(void)
+{
+ QDict *src, *rule;
+ QList *rules;
+ QObject *res;
+
+ src = qdict_new();
+ qdict_put(src, "0.match.name", qstring_from_str("Fred"));
+ qdict_put(src, "0.match.email", qstring_from_str("fred@example.com"));
+ qdict_put(src, "0.policy", qstring_from_str("allow"));
+ qdict_put(src, "1.match.name", qstring_from_str("Bob"));
+ qdict_put(src, "1.match.email", qstring_from_str("bob@example.com"));
+ qdict_put(src, "1.policy", qstring_from_str("deny"));
+
+ res = qdict_crumple(src, false, &error_abort);
+
+ g_assert_cmpint(qobject_type(res), ==, QTYPE_QLIST);
+
+ rules = qobject_to_qlist(res);
+
+ g_assert_cmpint(qlist_size(rules), ==, 2);
+
+ g_assert_cmpint(qobject_type(qlist_peek(rules)), ==, QTYPE_QDICT);
+ rule = qobject_to_qdict(qlist_pop(rules));
+ g_assert_cmpint(qdict_size(rule), ==, 3);
+
+ g_assert_cmpstr("Fred", ==, qdict_get_str(rule, "match.name"));
+ g_assert_cmpstr("fred@example.com", ==, qdict_get_str(rule, "match.email"));
+ g_assert_cmpstr("allow", ==, qdict_get_str(rule, "policy"));
+ QDECREF(rule);
+
+ g_assert_cmpint(qobject_type(qlist_peek(rules)), ==, QTYPE_QDICT);
+ rule = qobject_to_qdict(qlist_pop(rules));
+ g_assert_cmpint(qdict_size(rule), ==, 3);
+
+ g_assert_cmpstr("Bob", ==, qdict_get_str(rule, "match.name"));
+ g_assert_cmpstr("bob@example.com", ==, qdict_get_str(rule, "match.email"));
+ g_assert_cmpstr("deny", ==, qdict_get_str(rule, "policy"));
+ QDECREF(rule);
+
+ QDECREF(src);
+ qobject_decref(res);
+}
+
+
+static void qdict_crumple_test_recursive(void)
+{
+ QDict *src, *dst, *rule, *vnc, *acl, *listen;
+ QObject *child, *res;
+ QList *rules;
+
+ src = qdict_new();
+ qdict_put(src, "vnc.listen.addr", qstring_from_str("127.0.0.1"));
+ qdict_put(src, "vnc.listen.port", qstring_from_str("5901"));
+ qdict_put(src, "vnc.acl.rules.0.match", qstring_from_str("fred"));
+ qdict_put(src, "vnc.acl.rules.0.policy", qstring_from_str("allow"));
+ qdict_put(src, "vnc.acl.rules.1.match", qstring_from_str("bob"));
+ qdict_put(src, "vnc.acl.rules.1.policy", qstring_from_str("deny"));
+ qdict_put(src, "vnc.acl.default", qstring_from_str("deny"));
+ qdict_put(src, "vnc.acl..name", qstring_from_str("acl0"));
+ qdict_put(src, "vnc.acl.rule..name", qstring_from_str("acl0"));
+
+ res = qdict_crumple(src, true, &error_abort);
+
+ g_assert_cmpint(qobject_type(res), ==, QTYPE_QDICT);
+
+ dst = qobject_to_qdict(res);
+
+ g_assert_cmpint(qdict_size(dst), ==, 1);
+
+ child = qdict_get(dst, "vnc");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ vnc = qobject_to_qdict(child);
+
+ child = qdict_get(vnc, "listen");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ listen = qobject_to_qdict(child);
+ g_assert_cmpstr("127.0.0.1", ==, qdict_get_str(listen, "addr"));
+ g_assert_cmpstr("5901", ==, qdict_get_str(listen, "port"));
+
+ child = qdict_get(vnc, "acl");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ acl = qobject_to_qdict(child);
+
+ child = qdict_get(acl, "rules");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QLIST);
+ rules = qobject_to_qlist(child);
+ g_assert_cmpint(qlist_size(rules), ==, 2);
+
+ rule = qobject_to_qdict(qlist_pop(rules));
+ 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"));
+ QDECREF(rule);
+
+ rule = qobject_to_qdict(qlist_pop(rules));
+ 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"));
+ QDECREF(rule);
+
+ /* With recursive crumpling, we should see all names unescaped */
+ g_assert_cmpstr("acl0", ==, qdict_get_str(vnc, "acl.name"));
+ child = qdict_get(vnc, "acl");
+ g_assert_cmpint(qobject_type(child), ==, QTYPE_QDICT);
+ acl = qdict_get_qdict(vnc, "acl");
+ g_assert_cmpstr("acl0", ==, qdict_get_str(acl, "rule.name"));
+
+ QDECREF(src);
+ QDECREF(dst);
+}
+
+
+static void qdict_crumple_test_empty(void)
+{
+ QDict *src, *dst;
+
+ src = qdict_new();
+
+ dst = (QDict *)qdict_crumple(src, true, &error_abort);
+
+ g_assert_cmpint(qdict_size(dst), ==, 0);
+
+ QDECREF(src);
+ QDECREF(dst);
+}
+
+
+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(src, "rule.0", qstring_from_str("fred"));
+ qdict_put(src, "rule.0.policy", qstring_from_str("allow"));
+
+ g_assert(qdict_crumple(src, true, &error) == NULL);
+ g_assert(error != NULL);
+ error_free(error);
+ error = NULL;
+ QDECREF(src);
+
+ src = qdict_new();
+ /* rule can't be both a list and a dict */
+ qdict_put(src, "rule.0", qstring_from_str("fred"));
+ qdict_put(src, "rule.a", qstring_from_str("allow"));
+
+ g_assert(qdict_crumple(src, true, &error) == NULL);
+ g_assert(error != NULL);
+ error_free(error);
+ error = NULL;
+ QDECREF(src);
+
+ src = qdict_new();
+ /* The input should be flat, ie no dicts or lists */
+ qdict_put(src, "rule.a", qdict_new());
+ qdict_put(src, "rule.b", qstring_from_str("allow"));
+
+ g_assert(qdict_crumple(src, true, &error) == NULL);
+ g_assert(error != NULL);
+ error_free(error);
+ error = NULL;
+ QDECREF(src);
+
+
+ src = qdict_new();
+ /* List indexes must not have gaps */
+ qdict_put(src, "rule.0", qstring_from_str("deny"));
+ qdict_put(src, "rule.3", qstring_from_str("allow"));
+
+ g_assert(qdict_crumple(src, true, &error) == NULL);
+ g_assert(error != NULL);
+ error_free(error);
+ error = NULL;
+ QDECREF(src);
+
+
+ src = qdict_new();
+ /* List indexes must be in %zu format */
+ qdict_put(src, "rule.0", qstring_from_str("deny"));
+ qdict_put(src, "rule.+1", qstring_from_str("allow"));
+
+ g_assert(qdict_crumple(src, true, &error) == NULL);
+ g_assert(error != NULL);
+ error_free(error);
+ error = NULL;
+ QDECREF(src);
+}
+
/*
* Errors test-cases
*/
@@ -742,6 +991,17 @@ int main(int argc, char **argv)
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/nonrecursive",
+ qdict_crumple_test_nonrecursive);
+ g_test_add_func("/public/crumple/recursive",
+ qdict_crumple_test_recursive);
+ g_test_add_func("/public/crumple/listtop",
+ qdict_crumple_test_listtop);
+ g_test_add_func("/public/crumple/empty",
+ qdict_crumple_test_empty);
+ g_test_add_func("/public/crumple/bad_inputs",
+ qdict_crumple_test_bad_inputs);
+
/* The Big one */
if (g_test_slow()) {
g_test_add_func("/stress/test", qdict_stress_test);
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 02/19] option: make parse_option_bool/number non-static
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options Daniel P. Berrange
` (17 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The opts-visitor.c opts_type_bool() method has code for
parsing a string to set a bool value, as does the
qemu-option.c parse_option_bool() method, except it
handles fewer cases.
To enable consistency across the codebase, extend
parse_option_bool() to handle "yes", "no", "y" and
"n", and make it non-static. Convert the opts
visitor to call this method directly.
Also make parse_option_number() non-static to allow
for similar reuse later.
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qemu/option.h | 4 ++++
qapi/opts-visitor.c | 19 +------------------
tests/qemu-iotests/051.out | 6 +++---
tests/qemu-iotests/051.pc.out | 6 +++---
tests/qemu-iotests/137.out | 4 ++--
util/qemu-option.c | 27 ++++++++++++++++-----------
6 files changed, 29 insertions(+), 37 deletions(-)
diff --git a/include/qemu/option.h b/include/qemu/option.h
index 1f9e3f9..2a5266f 100644
--- a/include/qemu/option.h
+++ b/include/qemu/option.h
@@ -37,6 +37,10 @@ int get_param_value(char *buf, int buf_size,
const char *tag, const char *str);
+void parse_option_bool(const char *name, const char *value, bool *ret,
+ Error **errp);
+void parse_option_number(const char *name, const char *value,
+ uint64_t *ret, Error **errp);
void parse_option_size(const char *name, const char *value,
uint64_t *ret, Error **errp);
bool has_help_option(const char *param);
diff --git a/qapi/opts-visitor.c b/qapi/opts-visitor.c
index 1048bbc..084f7cc 100644
--- a/qapi/opts-visitor.c
+++ b/qapi/opts-visitor.c
@@ -334,7 +334,6 @@ opts_type_str(Visitor *v, const char *name, char **obj, Error **errp)
}
-/* mimics qemu-option.c::parse_option_bool() */
static void
opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
{
@@ -346,23 +345,7 @@ opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
return;
}
- if (opt->str) {
- if (strcmp(opt->str, "on") == 0 ||
- strcmp(opt->str, "yes") == 0 ||
- strcmp(opt->str, "y") == 0) {
- *obj = true;
- } else if (strcmp(opt->str, "off") == 0 ||
- strcmp(opt->str, "no") == 0 ||
- strcmp(opt->str, "n") == 0) {
- *obj = false;
- } else {
- error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
- "on|yes|y|off|no|n");
- return;
- }
- } else {
- *obj = true;
- }
+ parse_option_bool(opt->name, opt->str, obj, errp);
processed(ov, name);
}
diff --git a/tests/qemu-iotests/051.out b/tests/qemu-iotests/051.out
index 408d613..ffdc0b9 100644
--- a/tests/qemu-iotests/051.out
+++ b/tests/qemu-iotests/051.out
@@ -86,13 +86,13 @@ QEMU X.Y.Z monitor - type 'help' for more information
(qemu) q^[[K^[[Dqu^[[K^[[D^[[Dqui^[[K^[[D^[[D^[[Dquit^[[K
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
=== With version 2 images enabling lazy refcounts must fail ===
diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out
index ec6d222..6abf1ab 100644
--- a/tests/qemu-iotests/051.pc.out
+++ b/tests/qemu-iotests/051.pc.out
@@ -86,13 +86,13 @@ QEMU X.Y.Z monitor - type 'help' for more information
(qemu) q^[[K^[[Dqu^[[K^[[D^[[Dqui^[[K^[[D^[[D^[[Dquit^[[K
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=42: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo
-QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo: Parameter 'lazy-refcounts' expects 'on' or 'off'
+QEMU_PROG: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=foo: Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
=== With version 2 images enabling lazy refcounts must fail ===
diff --git a/tests/qemu-iotests/137.out b/tests/qemu-iotests/137.out
index c0e7534..61c1f90 100644
--- a/tests/qemu-iotests/137.out
+++ b/tests/qemu-iotests/137.out
@@ -15,7 +15,7 @@ read 33554432/33554432 bytes at offset 0
=== Try setting some invalid values ===
-Parameter 'lazy-refcounts' expects 'on' or 'off'
+Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
cache-size, l2-cache-size and refcount-cache-size may not be set the same time
l2-cache-size may not exceed cache-size
refcount-cache-size may not exceed cache-size
@@ -40,7 +40,7 @@ incompatible_features 0x0
Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
wrote 65536/65536 bytes at offset 0
64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-Parameter 'lazy-refcounts' expects 'on' or 'off'
+Parameter 'lazy-refcounts' expects 'on', 'yes', 'y', 'off', 'no' or 'n'
qcow2: Marking image as corrupt: Preventing invalid write on metadata (overlaps with qcow2_header); further corruption events will be suppressed
write failed: Input/output error
*** done
diff --git a/util/qemu-option.c b/util/qemu-option.c
index 3467dc2..41b356c 100644
--- a/util/qemu-option.c
+++ b/util/qemu-option.c
@@ -125,25 +125,30 @@ int get_param_value(char *buf, int buf_size,
return get_next_param_value(buf, buf_size, tag, &str);
}
-static void parse_option_bool(const char *name, const char *value, bool *ret,
- Error **errp)
+void parse_option_bool(const char *name, const char *value, bool *ret,
+ Error **errp)
{
if (value != NULL) {
- if (!strcmp(value, "on")) {
- *ret = 1;
- } else if (!strcmp(value, "off")) {
- *ret = 0;
+ if (strcmp(value, "on") == 0 ||
+ strcmp(value, "yes") == 0 ||
+ strcmp(value, "y") == 0) {
+ *ret = true;
+ } else if (strcmp(value, "off") == 0 ||
+ strcmp(value, "no") == 0 ||
+ strcmp(value, "n") == 0) {
+ *ret = false;
} else {
- error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
- name, "'on' or 'off'");
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
+ "'on', 'yes', 'y', 'off', 'no' or 'n'");
+ return;
}
} else {
- *ret = 1;
+ *ret = true;
}
}
-static void parse_option_number(const char *name, const char *value,
- uint64_t *ret, Error **errp)
+void parse_option_number(const char *name, const char *value,
+ uint64_t *ret, Error **errp)
{
char *postfix;
uint64_t number;
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 02/19] option: make parse_option_bool/number non-static Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 22:03 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor Daniel P. Berrange
` (16 subsequent siblings)
19 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
If given an option string such as
size=1024,nodes=10,nodes=4-5,nodes=1-2,policy=bind
the qemu_opts_to_qdict() method will currently overwrite
the values for repeated option keys, so only the last
value is in the returned dict:
size=1024
nodes=1-2
policy=bind
This adds the ability for the caller to ask that the
repeated keys be turned into list indexes:
size=1024
nodes.0=10
nodes.1=4-5
nodes.2=1-2
policy=bind
Note that the conversion has no way of knowing whether
any given key is expected to be a list upfront - it can
only figure that out when seeing the first duplicated
key. Thus the caller has to be prepared to deal with the
fact that if a key 'foo' is a list, then the returned
qdict may contain either 'foo' (if only a single instance
of the key was seen) or 'foo.NN' (if multiple instances
of the key were seen).
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
blockdev.c | 7 ++++---
include/qemu/option.h | 8 +++++++-
monitor.c | 3 ++-
qemu-img.c | 4 +++-
qemu-io-cmds.c | 3 ++-
qemu-io.c | 6 ++++--
qemu-nbd.c | 3 ++-
qom/object_interfaces.c | 3 ++-
tests/test-qemu-opts.c | 40 ++++++++++++++++++++++++++++++++++++++++
tests/test-replication.c | 9 ++++++---
util/qemu-option.c | 41 ++++++++++++++++++++++++++++++++++++++---
11 files changed, 110 insertions(+), 17 deletions(-)
diff --git a/blockdev.c b/blockdev.c
index 3010393..5ef3193 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -911,7 +911,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
/* Get a QDict for processing the options */
bs_opts = qdict_new();
- qemu_opts_to_qdict(all_opts, bs_opts);
+ qemu_opts_to_qdict(all_opts, bs_opts,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
legacy_opts = qemu_opts_create(&qemu_legacy_drive_opts, NULL, 0,
&error_abort);
@@ -3758,8 +3759,8 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr)
return;
}
- qdict = qemu_opts_to_qdict(opts, NULL);
-
+ qdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
if (!qdict_get_try_str(qdict, "node-name")) {
QDECREF(qdict);
error_report("'node-name' needs to be specified");
diff --git a/include/qemu/option.h b/include/qemu/option.h
index 2a5266f..328c468 100644
--- a/include/qemu/option.h
+++ b/include/qemu/option.h
@@ -125,7 +125,13 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
int permit_abbrev);
QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
Error **errp);
-QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict);
+typedef enum {
+ QEMU_OPTS_REPEAT_POLICY_LAST,
+ QEMU_OPTS_REPEAT_POLICY_LIST,
+} QemuOptsRepeatPolicy;
+
+QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict,
+ QemuOptsRepeatPolicy repeatPolicy);
void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp);
typedef int (*qemu_opts_loopfunc)(void *opaque, QemuOpts *opts, Error **errp);
diff --git a/monitor.c b/monitor.c
index 83c4edf..7dcd66b 100644
--- a/monitor.c
+++ b/monitor.c
@@ -2642,7 +2642,8 @@ static QDict *monitor_parse_arguments(Monitor *mon,
if (!opts) {
goto fail;
}
- qemu_opts_to_qdict(opts, qdict);
+ qemu_opts_to_qdict(opts, qdict,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
qemu_opts_del(opts);
}
break;
diff --git a/qemu-img.c b/qemu-img.c
index ceffefe..b399ae5 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -273,7 +273,9 @@ static BlockBackend *img_open_opts(const char *optstr,
QDict *options;
Error *local_err = NULL;
BlockBackend *blk;
- options = qemu_opts_to_qdict(opts, NULL);
+ options = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
+
blk = blk_new_open(NULL, NULL, options, flags, &local_err);
if (!blk) {
error_reportf_err(local_err, "Could not open '%s': ", optstr);
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index 3a3838a..e14beed 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -1952,7 +1952,8 @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)
}
qopts = qemu_opts_find(&reopen_opts, NULL);
- opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
+ opts = qopts ? qemu_opts_to_qdict(qopts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST) : NULL;
qemu_opts_reset(&reopen_opts);
brq = bdrv_reopen_queue(NULL, bs, opts, flags);
diff --git a/qemu-io.c b/qemu-io.c
index db129ea..b295afa 100644
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -207,7 +207,8 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
}
qopts = qemu_opts_find(&empty_opts, NULL);
- opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
+ opts = qopts ? qemu_opts_to_qdict(qopts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST) : NULL;
qemu_opts_reset(&empty_opts);
if (optind == argc - 1) {
@@ -593,7 +594,8 @@ int main(int argc, char **argv)
if (!qopts) {
exit(1);
}
- opts = qemu_opts_to_qdict(qopts, NULL);
+ opts = qemu_opts_to_qdict(qopts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
openfile(NULL, flags, writethrough, opts);
} else {
if (format) {
diff --git a/qemu-nbd.c b/qemu-nbd.c
index 99297a5..54eb3ce 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -859,7 +859,8 @@ int main(int argc, char **argv)
qemu_opts_reset(&file_opts);
exit(EXIT_FAILURE);
}
- options = qemu_opts_to_qdict(opts, NULL);
+ options = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
qemu_opts_reset(&file_opts);
blk = blk_new_open(NULL, NULL, options, flags, &local_err);
} else {
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index bf59846..48edf2f 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -161,7 +161,8 @@ Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
Object *obj = NULL;
v = opts_visitor_new(opts);
- pdict = qemu_opts_to_qdict(opts, NULL);
+ pdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
obj = user_creatable_add(pdict, v, errp);
visit_free(v);
diff --git a/tests/test-qemu-opts.c b/tests/test-qemu-opts.c
index a505a3e..b68ef74 100644
--- a/tests/test-qemu-opts.c
+++ b/tests/test-qemu-opts.c
@@ -421,6 +421,45 @@ static void test_qemu_opts_set(void)
g_assert(opts == NULL);
}
+
+static void test_qemu_opts_to_qdict(void)
+{
+ QemuOpts *opts;
+ QDict *dict;
+
+ /* dynamically initialized (parsed) opts */
+ opts = qemu_opts_parse(&opts_list_03,
+ "size=1024,nodes=10,nodes=4-5,nodes=1-2,policy=bind",
+ false, NULL);
+ g_assert(opts);
+
+ dict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
+ g_assert(dict);
+
+ g_assert_cmpstr(qdict_get_str(dict, "size"), ==, "1024");
+ g_assert_cmpstr(qdict_get_str(dict, "nodes"), ==, "1-2");
+ g_assert(!qdict_haskey(dict, "nodes.0"));
+ g_assert(!qdict_haskey(dict, "nodes.1"));
+ g_assert(!qdict_haskey(dict, "nodes.2"));
+ g_assert_cmpstr(qdict_get_str(dict, "policy"), ==, "bind");
+ QDECREF(dict);
+
+ dict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LIST);
+ g_assert(dict);
+
+ g_assert_cmpstr(qdict_get_str(dict, "size"), ==, "1024");
+ g_assert(!qdict_haskey(dict, "nodes"));
+ g_assert_cmpstr(qdict_get_str(dict, "nodes.0"), ==, "10");
+ g_assert_cmpstr(qdict_get_str(dict, "nodes.1"), ==, "4-5");
+ g_assert_cmpstr(qdict_get_str(dict, "nodes.2"), ==, "1-2");
+ g_assert_cmpstr(qdict_get_str(dict, "policy"), ==, "bind");
+ QDECREF(dict);
+
+ qemu_opts_del(opts);
+}
+
int main(int argc, char *argv[])
{
register_opts();
@@ -435,6 +474,7 @@ int main(int argc, char *argv[])
g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set);
+ g_test_add_func("/qemu-opts/to_qdict", test_qemu_opts_to_qdict);
g_test_run();
return 0;
}
diff --git a/tests/test-replication.c b/tests/test-replication.c
index 0997bd8..6165ac9 100644
--- a/tests/test-replication.c
+++ b/tests/test-replication.c
@@ -181,7 +181,8 @@ static BlockBackend *start_primary(void)
opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
g_free(cmdline);
- qdict = qemu_opts_to_qdict(opts, NULL);
+ qdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
@@ -311,7 +312,8 @@ static BlockBackend *start_secondary(void)
opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
g_free(cmdline);
- qdict = qemu_opts_to_qdict(opts, NULL);
+ qdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
@@ -336,7 +338,8 @@ static BlockBackend *start_secondary(void)
opts = qemu_opts_parse_noisily(&qemu_drive_opts, cmdline, false);
g_free(cmdline);
- qdict = qemu_opts_to_qdict(opts, NULL);
+ qdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LAST);
qdict_set_default_str(qdict, BDRV_OPT_CACHE_DIRECT, "off");
qdict_set_default_str(qdict, BDRV_OPT_CACHE_NO_FLUSH, "off");
diff --git a/util/qemu-option.c b/util/qemu-option.c
index 41b356c..ad28d4e 100644
--- a/util/qemu-option.c
+++ b/util/qemu-option.c
@@ -1058,10 +1058,12 @@ void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
* TODO We'll want to use types appropriate for opt->desc->type, but
* this is enough for now.
*/
-QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
+QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict,
+ QemuOptsRepeatPolicy repeatPolicy)
{
QemuOpt *opt;
- QObject *val;
+ QObject *val, *prevval;
+ QDict *lists = qdict_new();
if (!qdict) {
qdict = qdict_new();
@@ -1070,9 +1072,42 @@ QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
qdict_put(qdict, "id", qstring_from_str(opts->id));
}
QTAILQ_FOREACH(opt, &opts->head, next) {
+ gchar *key = NULL;
val = QOBJECT(qstring_from_str(opt->str));
- qdict_put_obj(qdict, opt->name, val);
+ switch (repeatPolicy) {
+ case QEMU_OPTS_REPEAT_POLICY_LIST:
+ if (qdict_haskey(lists, opt->name)) {
+ /* Current val goes into 'foo.N' */
+ int64_t max = qdict_get_int(lists, opt->name);
+ max++;
+ key = g_strdup_printf("%s.%" PRId64, opt->name, max);
+ qdict_put_obj(lists, opt->name, QOBJECT(qint_from_int(max)));
+ qdict_put_obj(qdict, key, val);
+ } else if (qdict_haskey(qdict, opt->name)) {
+ /* Move previous val from 'foo' to 'foo.0' */
+ prevval = qdict_get(qdict, opt->name);
+ qobject_incref(prevval);
+ qdict_del(qdict, opt->name);
+ key = g_strdup_printf("%s.0", opt->name);
+ qdict_put_obj(qdict, key, prevval);
+ g_free(key);
+
+ /* Current val goes into 'foo.1' */
+ key = g_strdup_printf("%s.1", opt->name);
+ qdict_put_obj(lists, opt->name, QOBJECT(qint_from_int(1)));
+ qdict_put_obj(qdict, key, val);
+ } else {
+ qdict_put_obj(qdict, key ? key : opt->name, val);
+ }
+ break;
+
+ case QEMU_OPTS_REPEAT_POLICY_LAST:
+ qdict_put_obj(qdict, key ? key : opt->name, val);
+ break;
+ }
+ g_free(key);
}
+ QDECREF(lists);
return qdict;
}
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (2 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 22:05 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 05/19] qapi: rename QmpInputVisitor to QObjectInputVisitor Daniel P. Berrange
` (15 subsequent siblings)
19 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Allow tracing of the operation of visitors
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
Makefile.objs | 1 +
qapi/qapi-visit-core.c | 27 +++++++++++++++++++++++++++
qapi/trace-events | 33 +++++++++++++++++++++++++++++++++
3 files changed, 61 insertions(+)
create mode 100644 qapi/trace-events
diff --git a/Makefile.objs b/Makefile.objs
index 7301544..54da068 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -160,3 +160,4 @@ trace-events-y += target-s390x/trace-events
trace-events-y += target-ppc/trace-events
trace-events-y += qom/trace-events
trace-events-y += linux-user/trace-events
+trace-events-y += qapi/trace-events
diff --git a/qapi/qapi-visit-core.c b/qapi/qapi-visit-core.c
index 55f5876..bfcb276 100644
--- a/qapi/qapi-visit-core.c
+++ b/qapi/qapi-visit-core.c
@@ -19,10 +19,12 @@
#include "qapi/qmp/qerror.h"
#include "qapi/visitor.h"
#include "qapi/visitor-impl.h"
+#include "trace.h"
void visit_complete(Visitor *v, void *opaque)
{
assert(v->type != VISITOR_OUTPUT || v->complete);
+ trace_visit_complete(v, opaque);
if (v->complete) {
v->complete(v, opaque);
}
@@ -30,6 +32,7 @@ void visit_complete(Visitor *v, void *opaque)
void visit_free(Visitor *v)
{
+ trace_visit_free(v);
if (v) {
v->free(v);
}
@@ -40,6 +43,7 @@ void visit_start_struct(Visitor *v, const char *name, void **obj,
{
Error *err = NULL;
+ trace_visit_start_struct(v, name, obj, size);
if (obj) {
assert(size);
assert(!(v->type & VISITOR_OUTPUT) || *obj);
@@ -53,6 +57,7 @@ void visit_start_struct(Visitor *v, const char *name, void **obj,
void visit_check_struct(Visitor *v, Error **errp)
{
+ trace_visit_check_struct(v);
if (v->check_struct) {
v->check_struct(v, errp);
}
@@ -60,6 +65,7 @@ void visit_check_struct(Visitor *v, Error **errp)
void visit_end_struct(Visitor *v, void **obj)
{
+ trace_visit_end_struct(v, obj);
v->end_struct(v, obj);
}
@@ -69,6 +75,7 @@ void visit_start_list(Visitor *v, const char *name, GenericList **list,
Error *err = NULL;
assert(!list || size >= sizeof(GenericList));
+ trace_visit_start_list(v, name, list, size);
v->start_list(v, name, list, size, &err);
if (list && (v->type & VISITOR_INPUT)) {
assert(!(err && *list));
@@ -79,11 +86,13 @@ void visit_start_list(Visitor *v, const char *name, GenericList **list,
GenericList *visit_next_list(Visitor *v, GenericList *tail, size_t size)
{
assert(tail && size >= sizeof(GenericList));
+ trace_visit_next_list(v, tail, size);
return v->next_list(v, tail, size);
}
void visit_end_list(Visitor *v, void **obj)
{
+ trace_visit_end_list(v, obj);
v->end_list(v, obj);
}
@@ -95,6 +104,7 @@ void visit_start_alternate(Visitor *v, const char *name,
assert(obj && size >= sizeof(GenericAlternate));
assert(!(v->type & VISITOR_OUTPUT) || *obj);
+ trace_visit_start_alternate(v, name, obj, size, promote_int);
if (v->start_alternate) {
v->start_alternate(v, name, obj, size, promote_int, &err);
}
@@ -106,6 +116,7 @@ void visit_start_alternate(Visitor *v, const char *name,
void visit_end_alternate(Visitor *v, void **obj)
{
+ trace_visit_end_alternate(v, obj);
if (v->end_alternate) {
v->end_alternate(v, obj);
}
@@ -113,6 +124,7 @@ void visit_end_alternate(Visitor *v, void **obj)
bool visit_optional(Visitor *v, const char *name, bool *present)
{
+ trace_visit_optional(v, name, present);
if (v->optional) {
v->optional(v, name, present);
}
@@ -127,6 +139,7 @@ bool visit_is_input(Visitor *v)
void visit_type_int(Visitor *v, const char *name, int64_t *obj, Error **errp)
{
assert(obj);
+ trace_visit_type_int(v, name, obj);
v->type_int64(v, name, obj, errp);
}
@@ -151,6 +164,7 @@ void visit_type_uint8(Visitor *v, const char *name, uint8_t *obj,
Error **errp)
{
uint64_t value = *obj;
+ trace_visit_type_uint8(v, name, obj);
visit_type_uintN(v, &value, name, UINT8_MAX, "uint8_t", errp);
*obj = value;
}
@@ -159,6 +173,7 @@ void visit_type_uint16(Visitor *v, const char *name, uint16_t *obj,
Error **errp)
{
uint64_t value = *obj;
+ trace_visit_type_uint16(v, name, obj);
visit_type_uintN(v, &value, name, UINT16_MAX, "uint16_t", errp);
*obj = value;
}
@@ -167,6 +182,7 @@ void visit_type_uint32(Visitor *v, const char *name, uint32_t *obj,
Error **errp)
{
uint64_t value = *obj;
+ trace_visit_type_uint32(v, name, obj);
visit_type_uintN(v, &value, name, UINT32_MAX, "uint32_t", errp);
*obj = value;
}
@@ -175,6 +191,7 @@ void visit_type_uint64(Visitor *v, const char *name, uint64_t *obj,
Error **errp)
{
assert(obj);
+ trace_visit_type_uint64(v, name, obj);
v->type_uint64(v, name, obj, errp);
}
@@ -199,6 +216,7 @@ static void visit_type_intN(Visitor *v, int64_t *obj, const char *name,
void visit_type_int8(Visitor *v, const char *name, int8_t *obj, Error **errp)
{
int64_t value = *obj;
+ trace_visit_type_int8(v, name, obj);
visit_type_intN(v, &value, name, INT8_MIN, INT8_MAX, "int8_t", errp);
*obj = value;
}
@@ -207,6 +225,7 @@ void visit_type_int16(Visitor *v, const char *name, int16_t *obj,
Error **errp)
{
int64_t value = *obj;
+ trace_visit_type_int16(v, name, obj);
visit_type_intN(v, &value, name, INT16_MIN, INT16_MAX, "int16_t", errp);
*obj = value;
}
@@ -215,6 +234,7 @@ void visit_type_int32(Visitor *v, const char *name, int32_t *obj,
Error **errp)
{
int64_t value = *obj;
+ trace_visit_type_int32(v, name, obj);
visit_type_intN(v, &value, name, INT32_MIN, INT32_MAX, "int32_t", errp);
*obj = value;
}
@@ -223,6 +243,7 @@ void visit_type_int64(Visitor *v, const char *name, int64_t *obj,
Error **errp)
{
assert(obj);
+ trace_visit_type_int64(v, name, obj);
v->type_int64(v, name, obj, errp);
}
@@ -230,6 +251,7 @@ void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
Error **errp)
{
assert(obj);
+ trace_visit_type_size(v, name, obj);
if (v->type_size) {
v->type_size(v, name, obj, errp);
} else {
@@ -240,6 +262,7 @@ void visit_type_size(Visitor *v, const char *name, uint64_t *obj,
void visit_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
{
assert(obj);
+ trace_visit_type_bool(v, name, obj);
v->type_bool(v, name, obj, errp);
}
@@ -252,6 +275,7 @@ void visit_type_str(Visitor *v, const char *name, char **obj, Error **errp)
* can enable:
assert(!(v->type & VISITOR_OUTPUT) || *obj);
*/
+ trace_visit_type_str(v, name, obj);
v->type_str(v, name, obj, &err);
if (v->type & VISITOR_INPUT) {
assert(!err != !*obj);
@@ -263,6 +287,7 @@ void visit_type_number(Visitor *v, const char *name, double *obj,
Error **errp)
{
assert(obj);
+ trace_visit_type_number(v, name, obj);
v->type_number(v, name, obj, errp);
}
@@ -272,6 +297,7 @@ void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
assert(obj);
assert(v->type != VISITOR_OUTPUT || *obj);
+ trace_visit_type_any(v, name, obj);
v->type_any(v, name, obj, &err);
if (v->type == VISITOR_INPUT) {
assert(!err != !*obj);
@@ -281,6 +307,7 @@ void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
void visit_type_null(Visitor *v, const char *name, Error **errp)
{
+ trace_visit_type_null(v, name);
v->type_null(v, name, errp);
}
diff --git a/qapi/trace-events b/qapi/trace-events
new file mode 100644
index 0000000..2c5d3bc
--- /dev/null
+++ b/qapi/trace-events
@@ -0,0 +1,33 @@
+# qapi-visit-core.c
+visit_free(void *v) "v=%p"
+visit_complete(void *v, void *opaque) "v=%p opaque=%p"
+
+visit_start_struct(void *v, const char *name, void *obj, size_t size) "v=%p name=%s obj=%p size=%zu"
+visit_check_struct(void *v) "v=%p"
+visit_end_struct(void *v, void *obj) "v=%p obj=%p"
+
+visit_start_list(void *v, const char *name, void *obj, size_t size) "v=%p name=%s obj=%p size=%zu"
+visit_next_list(void *v, void *tail, size_t size) "v=%p tail=%p size=%zu"
+visit_end_list(void *v, void *obj) "v=%p obj=%p"
+
+visit_start_alternate(void *v, const char *name, void *obj, size_t size, bool promote_int) "v=%p name=%s obj=%p size=%zu promote_int=%d"
+visit_end_alternate(void *v, void *obj) "v=%p obj=%p"
+
+visit_optional(void *v, const char *name, bool *present) "v=%p name=%s present=%p"
+
+visit_type_enum(void *v, const char *name, int *obj) "v=%p name=%s obj=%p"
+visit_type_int(void *v, const char *name, int64_t *obj) "v=%p name=%s obj=%p"
+visit_type_uint8(void *v, const char *name, uint8_t *obj) "v=%p name=%s obj=%p"
+visit_type_uint16(void *v, const char *name, uint16_t *obj) "v=%p name=%s obj=%p"
+visit_type_uint32(void *v, const char *name, uint32_t *obj) "v=%p name=%s obj=%p"
+visit_type_uint64(void *v, const char *name, uint64_t *obj) "v=%p name=%s obj=%p"
+visit_type_int8(void *v, const char *name, int8_t *obj) "v=%p name=%s obj=%p"
+visit_type_int16(void *v, const char *name, int16_t *obj) "v=%p name=%s obj=%p"
+visit_type_int32(void *v, const char *name, int32_t *obj) "v=%p name=%s obj=%p"
+visit_type_int64(void *v, const char *name, int64_t *obj) "v=%p name=%s obj=%p"
+visit_type_size(void *v, const char *name, uint64_t *obj) "v=%p name=%s obj=%p"
+visit_type_bool(void *v, const char *name, bool *obj) "v=%p name=%s obj=%p"
+visit_type_str(void *v, const char *name, char **obj) "v=%p name=%s obj=%p"
+visit_type_number(void *v, const char *name, double *obj) "v=%p name=%s obj=%p"
+visit_type_any(void *v, const char *name, void *obj) "v=%p name=%s obj=%p"
+visit_type_null(void *v, const char *name) "v=%p name=%s"
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 05/19] qapi: rename QmpInputVisitor to QObjectInputVisitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (3 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 06/19] qapi: rename QmpOutputVisitor to QObjectOutputVisitor Daniel P. Berrange
` (14 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The QmpInputVisitor has no direct dependency on QMP. It is
valid to use it anywhere that one has a QObject. Rename it
to better reflect its functionality as a generic QObject
to QAPI converter.
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
docs/qapi-code-gen.txt | 2 +-
...qmp-input-visitor.h => qobject-input-visitor.h} | 10 +-
include/qapi/visitor.h | 6 +-
monitor.c | 2 +-
qapi/Makefile.objs | 2 +-
...qmp-input-visitor.c => qobject-input-visitor.c} | 171 +++++++++++----------
qmp.c | 4 +-
qom/qom-qobject.c | 4 +-
scripts/qapi-commands.py | 4 +-
target-s390x/cpu_models.c | 4 +-
tests/.gitignore | 4 +-
tests/Makefile.include | 12 +-
tests/check-qnull.c | 4 +-
tests/test-qmp-commands.c | 4 +-
...-input-strict.c => test-qobject-input-strict.c} | 6 +-
...nput-visitor.c => test-qobject-input-visitor.c} | 6 +-
tests/test-string-input-visitor.c | 2 +-
tests/test-visitor-serialization.c | 4 +-
util/qemu-sockets.c | 2 +-
19 files changed, 128 insertions(+), 125 deletions(-)
rename include/qapi/{qmp-input-visitor.h => qobject-input-visitor.h} (63%)
rename qapi/{qmp-input-visitor.c => qobject-input-visitor.c} (56%)
rename tests/{test-qmp-input-strict.c => test-qobject-input-strict.c} (98%)
rename tests/{test-qmp-input-visitor.c => test-qobject-input-visitor.c} (99%)
diff --git a/docs/qapi-code-gen.txt b/docs/qapi-code-gen.txt
index 5d4c2cd..d2604b6 100644
--- a/docs/qapi-code-gen.txt
+++ b/docs/qapi-code-gen.txt
@@ -1024,7 +1024,7 @@ Example:
Visitor *v;
UserDefOneList *arg1 = NULL;
- v = qmp_input_visitor_new(QOBJECT(args), true);
+ v = qobject_input_visitor_new(QOBJECT(args), true);
visit_start_struct(v, NULL, NULL, 0, &err);
if (err) {
goto out;
diff --git a/include/qapi/qmp-input-visitor.h b/include/qapi/qobject-input-visitor.h
similarity index 63%
rename from include/qapi/qmp-input-visitor.h
rename to include/qapi/qobject-input-visitor.h
index f3ff5f3..cde328d 100644
--- a/include/qapi/qmp-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -11,20 +11,20 @@
*
*/
-#ifndef QMP_INPUT_VISITOR_H
-#define QMP_INPUT_VISITOR_H
+#ifndef QOBJECT_INPUT_VISITOR_H
+#define QOBJECT_INPUT_VISITOR_H
#include "qapi/visitor.h"
#include "qapi/qmp/qobject.h"
-typedef struct QmpInputVisitor QmpInputVisitor;
+typedef struct QObjectInputVisitor QObjectInputVisitor;
/*
- * Return a new input visitor that converts QMP to QAPI.
+ * Return a new input visitor that converts a QObject to a QAPI object.
*
* Set @strict to reject a parse that doesn't consume all keys of a
* dictionary; otherwise excess input is ignored.
*/
-Visitor *qmp_input_visitor_new(QObject *obj, bool strict);
+Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
#endif
diff --git a/include/qapi/visitor.h b/include/qapi/visitor.h
index 6c77a91..9bb6cba 100644
--- a/include/qapi/visitor.h
+++ b/include/qapi/visitor.h
@@ -25,14 +25,14 @@
* for doing work at each node of a QAPI graph; it can also be used
* for a virtual walk, where there is no actual QAPI C struct.
*
- * There are four kinds of visitor classes: input visitors (QMP,
+ * There are four kinds of visitor classes: input visitors (QObject,
* string, and QemuOpts) parse an external representation and build
- * the corresponding QAPI graph, output visitors (QMP and string) take
+ * the corresponding QAPI graph, output visitors (QObject and string) take
* a completed QAPI graph and generate an external representation, the
* dealloc visitor can take a QAPI graph (possibly partially
* constructed) and recursively free its resources, and the clone
* visitor performs a deep clone of one QAPI object to another. While
- * the dealloc and QMP input/output visitors are general, the string,
+ * the dealloc and QObject input/output visitors are general, the string,
* QemuOpts, and clone visitors have some implementation limitations;
* see the documentation for each visitor for more details on what it
* supports. Also, see visitor-impl.h for the callback contracts
diff --git a/monitor.c b/monitor.c
index 7dcd66b..792b995 100644
--- a/monitor.c
+++ b/monitor.c
@@ -957,7 +957,7 @@ EventInfoList *qmp_query_events(Error **errp)
* directly into QObject instead of first parsing it with
* visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
* to QObject with generated output marshallers, every time. Instead,
- * we do it in test-qmp-input-visitor.c, just to make sure
+ * we do it in test-qobject-input-visitor.c, just to make sure
* qapi-introspect.py's output actually conforms to the schema.
*/
static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
diff --git a/qapi/Makefile.objs b/qapi/Makefile.objs
index 7ea4aeb..6ec7bdc 100644
--- a/qapi/Makefile.objs
+++ b/qapi/Makefile.objs
@@ -1,4 +1,4 @@
-util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qmp-input-visitor.o
+util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qobject-input-visitor.o
util-obj-y += qmp-output-visitor.o qmp-registry.o qmp-dispatch.o
util-obj-y += string-input-visitor.o string-output-visitor.o
util-obj-y += opts-visitor.o qapi-clone-visitor.o
diff --git a/qapi/qmp-input-visitor.c b/qapi/qobject-input-visitor.c
similarity index 56%
rename from qapi/qmp-input-visitor.c
rename to qapi/qobject-input-visitor.c
index 64dd392..5ff3db3 100644
--- a/qapi/qmp-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -14,7 +14,7 @@
#include "qemu/osdep.h"
#include "qapi/error.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/visitor-impl.h"
#include "qemu/queue.h"
#include "qemu-common.h"
@@ -34,7 +34,7 @@ typedef struct StackObject
QSLIST_ENTRY(StackObject) node;
} StackObject;
-struct QmpInputVisitor
+struct QObjectInputVisitor
{
Visitor visitor;
@@ -49,14 +49,14 @@ struct QmpInputVisitor
bool strict;
};
-static QmpInputVisitor *to_qiv(Visitor *v)
+static QObjectInputVisitor *to_qiv(Visitor *v)
{
- return container_of(v, QmpInputVisitor, visitor);
+ return container_of(v, QObjectInputVisitor, visitor);
}
-static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
- const char *name,
- bool consume)
+static QObject *qobject_input_get_object(QObjectInputVisitor *qiv,
+ const char *name,
+ bool consume)
{
StackObject *tos;
QObject *qobj;
@@ -97,8 +97,9 @@ static void qdict_add_key(const char *key, QObject *obj, void *opaque)
g_hash_table_insert(h, (gpointer) key, NULL);
}
-static const QListEntry *qmp_input_push(QmpInputVisitor *qiv, QObject *obj,
- void *qapi, Error **errp)
+static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv,
+ QObject *obj, void *qapi,
+ Error **errp)
{
GHashTable *h;
StackObject *tos = g_new0(StackObject, 1);
@@ -120,9 +121,9 @@ static const QListEntry *qmp_input_push(QmpInputVisitor *qiv, QObject *obj,
}
-static void qmp_input_check_struct(Visitor *v, Error **errp)
+static void qobject_input_check_struct(Visitor *v, Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
+ QObjectInputVisitor *qiv = to_qiv(v);
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(tos && !tos->entry);
@@ -140,7 +141,7 @@ static void qmp_input_check_struct(Visitor *v, Error **errp)
}
}
-static void qmp_input_stack_object_free(StackObject *tos)
+static void qobject_input_stack_object_free(StackObject *tos)
{
if (tos->h) {
g_hash_table_unref(tos->h);
@@ -149,21 +150,21 @@ static void qmp_input_stack_object_free(StackObject *tos)
g_free(tos);
}
-static void qmp_input_pop(Visitor *v, void **obj)
+static void qobject_input_pop(Visitor *v, void **obj)
{
- QmpInputVisitor *qiv = to_qiv(v);
+ QObjectInputVisitor *qiv = to_qiv(v);
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(tos && tos->qapi == obj);
QSLIST_REMOVE_HEAD(&qiv->stack, node);
- qmp_input_stack_object_free(tos);
+ qobject_input_stack_object_free(tos);
}
-static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
- size_t size, Error **errp)
+static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
+ size_t size, Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, true);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, true);
Error *err = NULL;
if (obj) {
@@ -175,7 +176,7 @@ static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
return;
}
- qmp_input_push(qiv, qobj, obj, &err);
+ qobject_input_push(qiv, qobj, obj, &err);
if (err) {
error_propagate(errp, err);
return;
@@ -187,11 +188,12 @@ static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
}
-static void qmp_input_start_list(Visitor *v, const char *name,
- GenericList **list, size_t size, Error **errp)
+static void qobject_input_start_list(Visitor *v, const char *name,
+ GenericList **list, size_t size,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, true);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, true);
const QListEntry *entry;
if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
@@ -203,7 +205,7 @@ static void qmp_input_start_list(Visitor *v, const char *name,
return;
}
- entry = qmp_input_push(qiv, qobj, list, errp);
+ entry = qobject_input_push(qiv, qobj, list, errp);
if (list) {
if (entry) {
*list = g_malloc0(size);
@@ -213,10 +215,10 @@ static void qmp_input_start_list(Visitor *v, const char *name,
}
}
-static GenericList *qmp_input_next_list(Visitor *v, GenericList *tail,
- size_t size)
+static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail,
+ size_t size)
{
- QmpInputVisitor *qiv = to_qiv(v);
+ QObjectInputVisitor *qiv = to_qiv(v);
StackObject *so = QSLIST_FIRST(&qiv->stack);
if (!so->entry) {
@@ -227,12 +229,12 @@ static GenericList *qmp_input_next_list(Visitor *v, GenericList *tail,
}
-static void qmp_input_start_alternate(Visitor *v, const char *name,
- GenericAlternate **obj, size_t size,
- bool promote_int, Error **errp)
+static void qobject_input_start_alternate(Visitor *v, const char *name,
+ GenericAlternate **obj, size_t size,
+ bool promote_int, Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, false);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, false);
if (!qobj) {
*obj = NULL;
@@ -246,11 +248,11 @@ static void qmp_input_start_alternate(Visitor *v, const char *name,
}
}
-static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
- Error **errp)
+static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QInt *qint = qobject_to_qint(qobject_input_get_object(qiv, name, true));
if (!qint) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
@@ -261,12 +263,12 @@ static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
*obj = qint_get_int(qint);
}
-static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
- Error **errp)
+static void qobject_input_type_uint64(Visitor *v, const char *name,
+ uint64_t *obj, Error **errp)
{
/* FIXME: qobject_to_qint mishandles values over INT64_MAX */
- QmpInputVisitor *qiv = to_qiv(v);
- QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QInt *qint = qobject_to_qint(qobject_input_get_object(qiv, name, true));
if (!qint) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
@@ -277,11 +279,11 @@ static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
*obj = qint_get_int(qint);
}
-static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
- Error **errp)
+static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QBool *qbool = qobject_to_qbool(qobject_input_get_object(qiv, name, true));
if (!qbool) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
@@ -292,11 +294,12 @@ static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
*obj = qbool_get_bool(qbool);
}
-static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
- Error **errp)
+static void qobject_input_type_str(Visitor *v, const char *name, char **obj,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
if (!qstr) {
*obj = NULL;
@@ -308,11 +311,11 @@ static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
*obj = g_strdup(qstring_get_str(qstr));
}
-static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
- Error **errp)
+static void qobject_input_type_number(Visitor *v, const char *name, double *obj,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, true);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, true);
QInt *qint;
QFloat *qfloat;
@@ -332,20 +335,20 @@ static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
"number");
}
-static void qmp_input_type_any(Visitor *v, const char *name, QObject **obj,
- Error **errp)
+static void qobject_input_type_any(Visitor *v, const char *name, QObject **obj,
+ Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, true);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, true);
qobject_incref(qobj);
*obj = qobj;
}
-static void qmp_input_type_null(Visitor *v, const char *name, Error **errp)
+static void qobject_input_type_null(Visitor *v, const char *name, Error **errp)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, true);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, true);
if (qobject_type(qobj) != QTYPE_QNULL) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
@@ -353,10 +356,10 @@ static void qmp_input_type_null(Visitor *v, const char *name, Error **errp)
}
}
-static void qmp_input_optional(Visitor *v, const char *name, bool *present)
+static void qobject_input_optional(Visitor *v, const char *name, bool *present)
{
- QmpInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qmp_input_get_object(qiv, name, false);
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QObject *qobj = qobject_input_get_object(qiv, name, false);
if (!qobj) {
*present = false;
@@ -366,43 +369,43 @@ static void qmp_input_optional(Visitor *v, const char *name, bool *present)
*present = true;
}
-static void qmp_input_free(Visitor *v)
+static void qobject_input_free(Visitor *v)
{
- QmpInputVisitor *qiv = to_qiv(v);
+ QObjectInputVisitor *qiv = to_qiv(v);
while (!QSLIST_EMPTY(&qiv->stack)) {
StackObject *tos = QSLIST_FIRST(&qiv->stack);
QSLIST_REMOVE_HEAD(&qiv->stack, node);
- qmp_input_stack_object_free(tos);
+ qobject_input_stack_object_free(tos);
}
qobject_decref(qiv->root);
g_free(qiv);
}
-Visitor *qmp_input_visitor_new(QObject *obj, bool strict)
+Visitor *qobject_input_visitor_new(QObject *obj, bool strict)
{
- QmpInputVisitor *v;
+ QObjectInputVisitor *v;
v = g_malloc0(sizeof(*v));
v->visitor.type = VISITOR_INPUT;
- v->visitor.start_struct = qmp_input_start_struct;
- v->visitor.check_struct = qmp_input_check_struct;
- v->visitor.end_struct = qmp_input_pop;
- v->visitor.start_list = qmp_input_start_list;
- v->visitor.next_list = qmp_input_next_list;
- v->visitor.end_list = qmp_input_pop;
- v->visitor.start_alternate = qmp_input_start_alternate;
- v->visitor.type_int64 = qmp_input_type_int64;
- v->visitor.type_uint64 = qmp_input_type_uint64;
- v->visitor.type_bool = qmp_input_type_bool;
- v->visitor.type_str = qmp_input_type_str;
- v->visitor.type_number = qmp_input_type_number;
- v->visitor.type_any = qmp_input_type_any;
- v->visitor.type_null = qmp_input_type_null;
- v->visitor.optional = qmp_input_optional;
- v->visitor.free = qmp_input_free;
+ v->visitor.start_struct = qobject_input_start_struct;
+ v->visitor.check_struct = qobject_input_check_struct;
+ v->visitor.end_struct = qobject_input_pop;
+ v->visitor.start_list = qobject_input_start_list;
+ v->visitor.next_list = qobject_input_next_list;
+ v->visitor.end_list = qobject_input_pop;
+ v->visitor.start_alternate = qobject_input_start_alternate;
+ v->visitor.type_int64 = qobject_input_type_int64;
+ v->visitor.type_uint64 = qobject_input_type_uint64;
+ v->visitor.type_bool = qobject_input_type_bool;
+ v->visitor.type_str = qobject_input_type_str;
+ v->visitor.type_number = qobject_input_type_number;
+ v->visitor.type_any = qobject_input_type_any;
+ v->visitor.type_null = qobject_input_type_null;
+ v->visitor.optional = qobject_input_optional;
+ v->visitor.free = qobject_input_free;
v->strict = strict;
v->root = obj;
diff --git a/qmp.c b/qmp.c
index 71f0c8b..dafd8e9 100644
--- a/qmp.c
+++ b/qmp.c
@@ -31,7 +31,7 @@
#include "qom/qom-qobject.h"
#include "qapi/qmp/qerror.h"
#include "qapi/qmp/qobject.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "hw/boards.h"
#include "qom/object_interfaces.h"
#include "hw/mem/pc-dimm.h"
@@ -672,7 +672,7 @@ void qmp_object_add(const char *type, const char *id,
}
}
- v = qmp_input_visitor_new(props, true);
+ v = qobject_input_visitor_new(props, true);
obj = user_creatable_add_type(type, id, pdict, v, errp);
visit_free(v);
if (obj) {
diff --git a/qom/qom-qobject.c b/qom/qom-qobject.c
index c225abc..81959e0 100644
--- a/qom/qom-qobject.c
+++ b/qom/qom-qobject.c
@@ -15,7 +15,7 @@
#include "qom/object.h"
#include "qom/qom-qobject.h"
#include "qapi/visitor.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp-output-visitor.h"
void object_property_set_qobject(Object *obj, QObject *value,
@@ -23,7 +23,7 @@ void object_property_set_qobject(Object *obj, QObject *value,
{
Visitor *v;
/* TODO: Should we reject, rather than ignore, excess input? */
- v = qmp_input_visitor_new(value, false);
+ v = qobject_input_visitor_new(value, false);
object_property_set(obj, v, name, errp);
visit_free(v);
}
diff --git a/scripts/qapi-commands.py b/scripts/qapi-commands.py
index 2f603b0..04158a3 100644
--- a/scripts/qapi-commands.py
+++ b/scripts/qapi-commands.py
@@ -130,7 +130,7 @@ def gen_marshal(name, arg_type, boxed, ret_type):
push_indent()
ret += mcgen('''
- v = qmp_input_visitor_new(QOBJECT(args), true);
+ v = qobject_input_visitor_new(QOBJECT(args), true);
visit_start_struct(v, NULL, NULL, 0, &err);
if (err) {
goto out;
@@ -294,7 +294,7 @@ fdef.write(mcgen('''
#include "qapi/qmp/dispatch.h"
#include "qapi/visitor.h"
#include "qapi/qmp-output-visitor.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/dealloc-visitor.h"
#include "%(prefix)sqapi-types.h"
#include "%(prefix)sqapi-visit.h"
diff --git a/target-s390x/cpu_models.c b/target-s390x/cpu_models.c
index 3ff6a70..c1e729d 100644
--- a/target-s390x/cpu_models.c
+++ b/target-s390x/cpu_models.c
@@ -17,7 +17,7 @@
#include "qapi/visitor.h"
#include "qemu/error-report.h"
#include "qapi/qmp/qerror.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp/qbool.h"
#ifndef CONFIG_USER_ONLY
#include "sysemu/arch_init.h"
@@ -345,7 +345,7 @@ static void cpu_model_from_info(S390CPUModel *model, const CpuModelInfo *info,
}
if (qdict) {
- visitor = qmp_input_visitor_new(info->props, true);
+ visitor = qobject_input_visitor_new(info->props, true);
visit_start_struct(visitor, NULL, NULL, 0, errp);
if (*errp) {
object_unref(obj);
diff --git a/tests/.gitignore b/tests/.gitignore
index 24ac6cf..2260d8a 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -57,8 +57,8 @@ test-qht-par
test-qmp-commands
test-qmp-commands.h
test-qmp-event
-test-qmp-input-strict
-test-qmp-input-visitor
+test-qobject-input-strict
+test-qobject-input-visitor
test-qmp-introspect.[ch]
test-qmp-marshal.c
test-qmp-output-visitor
diff --git a/tests/Makefile.include b/tests/Makefile.include
index d8101b3..c8d601b 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -24,9 +24,9 @@ check-unit-y += tests/test-qmp-output-visitor$(EXESUF)
gcov-files-test-qmp-output-visitor-y = qapi/qmp-output-visitor.c
check-unit-y += tests/test-clone-visitor$(EXESUF)
gcov-files-test-clone-visitor-y = qapi/qapi-clone-visitor.c
-check-unit-y += tests/test-qmp-input-visitor$(EXESUF)
-gcov-files-test-qmp-input-visitor-y = qapi/qmp-input-visitor.c
-check-unit-y += tests/test-qmp-input-strict$(EXESUF)
+check-unit-y += tests/test-qobject-input-visitor$(EXESUF)
+gcov-files-test-qobject-input-visitor-y = qapi/qobject-input-visitor.c
+check-unit-y += tests/test-qobject-input-strict$(EXESUF)
check-unit-y += tests/test-qmp-commands$(EXESUF)
gcov-files-test-qmp-commands-y = qapi/qmp-dispatch.c
check-unit-y += tests/test-string-input-visitor$(EXESUF)
@@ -440,7 +440,7 @@ test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
tests/test-coroutine.o tests/test-string-output-visitor.o \
tests/test-string-input-visitor.o tests/test-qmp-output-visitor.o \
tests/test-clone-visitor.o \
- tests/test-qmp-input-visitor.o tests/test-qmp-input-strict.o \
+ tests/test-qobject-input-visitor.o tests/test-qobject-input-strict.o \
tests/test-qmp-commands.o tests/test-visitor-serialization.o \
tests/test-x86-cpuid.o tests/test-mul64.o tests/test-int128.o \
tests/test-opts-visitor.o tests/test-qmp-event.o \
@@ -543,8 +543,8 @@ tests/test-string-input-visitor$(EXESUF): tests/test-string-input-visitor.o $(te
tests/test-qmp-event$(EXESUF): tests/test-qmp-event.o $(test-qapi-obj-y)
tests/test-qmp-output-visitor$(EXESUF): tests/test-qmp-output-visitor.o $(test-qapi-obj-y)
tests/test-clone-visitor$(EXESUF): tests/test-clone-visitor.o $(test-qapi-obj-y)
-tests/test-qmp-input-visitor$(EXESUF): tests/test-qmp-input-visitor.o $(test-qapi-obj-y)
-tests/test-qmp-input-strict$(EXESUF): tests/test-qmp-input-strict.o $(test-qapi-obj-y)
+tests/test-qobject-input-visitor$(EXESUF): tests/test-qobject-input-visitor.o $(test-qapi-obj-y)
+tests/test-qobject-input-strict$(EXESUF): tests/test-qobject-input-strict.o $(test-qapi-obj-y)
tests/test-qmp-commands$(EXESUF): tests/test-qmp-commands.o tests/test-qmp-marshal.o $(test-qapi-obj-y)
tests/test-visitor-serialization$(EXESUF): tests/test-visitor-serialization.o $(test-qapi-obj-y)
tests/test-opts-visitor$(EXESUF): tests/test-opts-visitor.o $(test-qapi-obj-y)
diff --git a/tests/check-qnull.c b/tests/check-qnull.c
index dc906b1..eeb803a 100644
--- a/tests/check-qnull.c
+++ b/tests/check-qnull.c
@@ -10,7 +10,7 @@
#include "qapi/qmp/qobject.h"
#include "qemu-common.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp-output-visitor.h"
#include "qapi/error.h"
@@ -47,7 +47,7 @@ static void qnull_visit_test(void)
g_assert(qnull_.refcnt == 1);
obj = qnull();
- v = qmp_input_visitor_new(obj, true);
+ v = qobject_input_visitor_new(obj, true);
qobject_decref(obj);
visit_type_null(v, NULL, &error_abort);
visit_free(v);
diff --git a/tests/test-qmp-commands.c b/tests/test-qmp-commands.c
index 81cbe54..ff94481 100644
--- a/tests/test-qmp-commands.c
+++ b/tests/test-qmp-commands.c
@@ -4,7 +4,7 @@
#include "test-qmp-commands.h"
#include "qapi/qmp/dispatch.h"
#include "qemu/module.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "tests/test-qapi-types.h"
#include "tests/test-qapi-visit.h"
@@ -244,7 +244,7 @@ static void test_dealloc_partial(void)
ud2_dict = qdict_new();
qdict_put_obj(ud2_dict, "string0", QOBJECT(qstring_from_str(text)));
- v = qmp_input_visitor_new(QOBJECT(ud2_dict), true);
+ v = qobject_input_visitor_new(QOBJECT(ud2_dict), true);
visit_type_UserDefTwo(v, NULL, &ud2, &err);
visit_free(v);
QDECREF(ud2_dict);
diff --git a/tests/test-qmp-input-strict.c b/tests/test-qobject-input-strict.c
similarity index 98%
rename from tests/test-qmp-input-strict.c
rename to tests/test-qobject-input-strict.c
index 814550a..8250365 100644
--- a/tests/test-qmp-input-strict.c
+++ b/tests/test-qobject-input-strict.c
@@ -1,5 +1,5 @@
/*
- * QMP Input Visitor unit-tests (strict mode).
+ * QObject Input Visitor unit-tests (strict mode).
*
* Copyright (C) 2011-2012, 2015 Red Hat Inc.
*
@@ -15,7 +15,7 @@
#include "qemu-common.h"
#include "qapi/error.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "test-qapi-types.h"
#include "test-qapi-visit.h"
#include "qapi/qmp/types.h"
@@ -53,7 +53,7 @@ static Visitor *validate_test_init_internal(TestInputVisitorData *data,
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
- data->qiv = qmp_input_visitor_new(data->obj, true);
+ data->qiv = qobject_input_visitor_new(data->obj, true);
g_assert(data->qiv);
return data->qiv;
}
diff --git a/tests/test-qmp-input-visitor.c b/tests/test-qobject-input-visitor.c
similarity index 99%
rename from tests/test-qmp-input-visitor.c
rename to tests/test-qobject-input-visitor.c
index f583dce..0e65e63 100644
--- a/tests/test-qmp-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -1,5 +1,5 @@
/*
- * QMP Input Visitor unit-tests.
+ * QObject Input Visitor unit-tests.
*
* Copyright (C) 2011-2016 Red Hat Inc.
*
@@ -14,7 +14,7 @@
#include "qemu-common.h"
#include "qapi/error.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "test-qapi-types.h"
#include "test-qapi-visit.h"
#include "qapi/qmp/types.h"
@@ -49,7 +49,7 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
- data->qiv = qmp_input_visitor_new(data->obj, false);
+ data->qiv = qobject_input_visitor_new(data->obj, false);
g_assert(data->qiv);
return data->qiv;
}
diff --git a/tests/test-string-input-visitor.c b/tests/test-string-input-visitor.c
index a679fbc..7f10e25 100644
--- a/tests/test-string-input-visitor.c
+++ b/tests/test-string-input-visitor.c
@@ -4,7 +4,7 @@
* Copyright (C) 2012 Red Hat Inc.
*
* Authors:
- * Paolo Bonzini <pbonzini@redhat.com> (based on test-qmp-input-visitor)
+ * Paolo Bonzini <pbonzini@redhat.com> (based on test-qobject-input-visitor)
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
diff --git a/tests/test-visitor-serialization.c b/tests/test-visitor-serialization.c
index dba4670..51df428 100644
--- a/tests/test-visitor-serialization.c
+++ b/tests/test-visitor-serialization.c
@@ -20,7 +20,7 @@
#include "qapi/error.h"
#include "qapi/qmp/types.h"
#include "qapi/qmp/qjson.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp-output-visitor.h"
#include "qapi/string-input-visitor.h"
#include "qapi/string-output-visitor.h"
@@ -1040,7 +1040,7 @@ static void qmp_deserialize(void **native_out, void *datap,
obj = qobject_from_json(qstring_get_str(output_json));
QDECREF(output_json);
- d->qiv = qmp_input_visitor_new(obj, true);
+ d->qiv = qobject_input_visitor_new(obj, true);
qobject_decref(obj_orig);
qobject_decref(obj);
visit(d->qiv, native_out, errp);
diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
index 6db48b3..9e30a21 100644
--- a/util/qemu-sockets.c
+++ b/util/qemu-sockets.c
@@ -21,7 +21,7 @@
#include "qapi/error.h"
#include "qemu/sockets.h"
#include "qemu/main-loop.h"
-#include "qapi/qmp-input-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp-output-visitor.h"
#include "qapi-visit.h"
#include "qemu/cutils.h"
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 06/19] qapi: rename QmpOutputVisitor to QObjectOutputVisitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (4 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 05/19] qapi: rename QmpInputVisitor to QObjectInputVisitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests Daniel P. Berrange
` (13 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The QmpOutputVisitor has no direct dependency on QMP. It is
valid to use it anywhere that one wants a QObject. Rename it
to better reflect its functionality as a generic QAPI
to QObject converter.
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
block/qapi.c | 4 +-
blockdev.c | 4 +-
docs/qapi-code-gen.txt | 2 +-
...p-output-visitor.h => qobject-output-visitor.h} | 10 +-
qapi/Makefile.objs | 2 +-
qapi/qapi-clone-visitor.c | 2 +-
qapi/qmp-output-visitor.c | 256 ---------------------
qapi/qobject-output-visitor.c | 254 ++++++++++++++++++++
qemu-img.c | 8 +-
qom/object_interfaces.c | 2 +-
qom/qom-qobject.c | 4 +-
scripts/qapi-commands.py | 4 +-
scripts/qapi-event.py | 4 +-
tests/.gitignore | 2 +-
tests/Makefile.include | 8 +-
tests/check-qnull.c | 4 +-
...put-visitor.c => test-qobject-output-visitor.c} | 6 +-
tests/test-string-output-visitor.c | 2 +-
tests/test-visitor-serialization.c | 4 +-
util/qemu-sockets.c | 2 +-
20 files changed, 291 insertions(+), 293 deletions(-)
rename include/qapi/{qmp-output-visitor.h => qobject-output-visitor.h} (66%)
delete mode 100644 qapi/qmp-output-visitor.c
create mode 100644 qapi/qobject-output-visitor.c
rename tests/{test-qmp-output-visitor.c => test-qobject-output-visitor.c} (99%)
diff --git a/block/qapi.c b/block/qapi.c
index 6f947e3..f35c89f 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -29,7 +29,7 @@
#include "block/write-threshold.h"
#include "qmp-commands.h"
#include "qapi-visit.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/qmp/types.h"
#include "sysemu/block-backend.h"
#include "qemu/cutils.h"
@@ -691,7 +691,7 @@ void bdrv_image_info_specific_dump(fprintf_function func_fprintf, void *f,
ImageInfoSpecific *info_spec)
{
QObject *obj, *data;
- Visitor *v = qmp_output_visitor_new(&obj);
+ Visitor *v = qobject_output_visitor_new(&obj);
visit_type_ImageInfoSpecific(v, NULL, &info_spec, &error_abort);
visit_complete(v, &obj);
diff --git a/blockdev.c b/blockdev.c
index 5ef3193..3f5d528 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -43,7 +43,7 @@
#include "qapi/qmp/types.h"
#include "qapi-visit.h"
#include "qapi/qmp/qerror.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/util.h"
#include "sysemu/sysemu.h"
#include "block/block_int.h"
@@ -3784,7 +3784,7 @@ void qmp_blockdev_add(BlockdevOptions *options, Error **errp)
BlockDriverState *bs;
BlockBackend *blk = NULL;
QObject *obj;
- Visitor *v = qmp_output_visitor_new(&obj);
+ Visitor *v = qobject_output_visitor_new(&obj);
QDict *qdict;
Error *local_err = NULL;
diff --git a/docs/qapi-code-gen.txt b/docs/qapi-code-gen.txt
index d2604b6..2841c51 100644
--- a/docs/qapi-code-gen.txt
+++ b/docs/qapi-code-gen.txt
@@ -1005,7 +1005,7 @@ Example:
Error *err = NULL;
Visitor *v;
- v = qmp_output_visitor_new(ret_out);
+ v = qobject_output_visitor_new(ret_out);
visit_type_UserDefOne(v, "unused", &ret_in, &err);
if (!err) {
visit_complete(v, ret_out);
diff --git a/include/qapi/qmp-output-visitor.h b/include/qapi/qobject-output-visitor.h
similarity index 66%
rename from include/qapi/qmp-output-visitor.h
rename to include/qapi/qobject-output-visitor.h
index 040fdda..358c959 100644
--- a/include/qapi/qmp-output-visitor.h
+++ b/include/qapi/qobject-output-visitor.h
@@ -11,20 +11,20 @@
*
*/
-#ifndef QMP_OUTPUT_VISITOR_H
-#define QMP_OUTPUT_VISITOR_H
+#ifndef QOBJECT_OUTPUT_VISITOR_H
+#define QOBJECT_OUTPUT_VISITOR_H
#include "qapi/visitor.h"
#include "qapi/qmp/qobject.h"
-typedef struct QmpOutputVisitor QmpOutputVisitor;
+typedef struct QObjectOutputVisitor QObjectOutputVisitor;
/*
- * Create a new QMP output visitor.
+ * Create a new QOBJECT output visitor.
*
* If everything else succeeds, pass @result to visit_complete() to
* collect the result of the visit.
*/
-Visitor *qmp_output_visitor_new(QObject **result);
+Visitor *qobject_output_visitor_new(QObject **result);
#endif
diff --git a/qapi/Makefile.objs b/qapi/Makefile.objs
index 6ec7bdc..33906ff 100644
--- a/qapi/Makefile.objs
+++ b/qapi/Makefile.objs
@@ -1,5 +1,5 @@
util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qobject-input-visitor.o
-util-obj-y += qmp-output-visitor.o qmp-registry.o qmp-dispatch.o
+util-obj-y += qobject-output-visitor.o qmp-registry.o qmp-dispatch.o
util-obj-y += string-input-visitor.o string-output-visitor.o
util-obj-y += opts-visitor.o qapi-clone-visitor.o
util-obj-y += qmp-event.o
diff --git a/qapi/qapi-clone-visitor.c b/qapi/qapi-clone-visitor.c
index 0bb8216..34086cb 100644
--- a/qapi/qapi-clone-visitor.c
+++ b/qapi/qapi-clone-visitor.c
@@ -110,7 +110,7 @@ static void qapi_clone_type_str(Visitor *v, const char *name, char **obj,
assert(qcv->depth);
/*
* Pointer was already cloned by g_memdup; create fresh copy.
- * Note that as long as qmp-output-visitor accepts NULL instead of
+ * Note that as long as qobject-output-visitor accepts NULL instead of
* "", then we must do likewise. However, we want to obey the
* input visitor semantics of never producing NULL when the empty
* string is intended.
diff --git a/qapi/qmp-output-visitor.c b/qapi/qmp-output-visitor.c
deleted file mode 100644
index 9e3b67c..0000000
--- a/qapi/qmp-output-visitor.c
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
- * Core Definitions for QAPI/QMP Command Registry
- *
- * Copyright (C) 2012-2016 Red Hat, Inc.
- * Copyright IBM, Corp. 2011
- *
- * Authors:
- * Anthony Liguori <aliguori@us.ibm.com>
- *
- * 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 "qapi/qmp-output-visitor.h"
-#include "qapi/visitor-impl.h"
-#include "qemu/queue.h"
-#include "qemu-common.h"
-#include "qapi/qmp/types.h"
-
-typedef struct QStackEntry
-{
- QObject *value;
- void *qapi; /* sanity check that caller uses same pointer */
- QSLIST_ENTRY(QStackEntry) node;
-} QStackEntry;
-
-struct QmpOutputVisitor
-{
- Visitor visitor;
- QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */
- QObject *root; /* Root of the output visit */
- QObject **result; /* User's storage location for result */
-};
-
-#define qmp_output_add(qov, name, value) \
- qmp_output_add_obj(qov, name, QOBJECT(value))
-#define qmp_output_push(qov, value, qapi) \
- qmp_output_push_obj(qov, QOBJECT(value), qapi)
-
-static QmpOutputVisitor *to_qov(Visitor *v)
-{
- return container_of(v, QmpOutputVisitor, visitor);
-}
-
-/* Push @value onto the stack of current QObjects being built */
-static void qmp_output_push_obj(QmpOutputVisitor *qov, QObject *value,
- void *qapi)
-{
- QStackEntry *e = g_malloc0(sizeof(*e));
-
- assert(qov->root);
- assert(value);
- e->value = value;
- e->qapi = qapi;
- QSLIST_INSERT_HEAD(&qov->stack, e, node);
-}
-
-/* Pop a value off the stack of QObjects being built, and return it. */
-static QObject *qmp_output_pop(QmpOutputVisitor *qov, void *qapi)
-{
- QStackEntry *e = QSLIST_FIRST(&qov->stack);
- QObject *value;
-
- assert(e);
- assert(e->qapi == qapi);
- QSLIST_REMOVE_HEAD(&qov->stack, node);
- value = e->value;
- assert(value);
- g_free(e);
- return value;
-}
-
-/* Add @value to the current QObject being built.
- * If the stack is visiting a dictionary or list, @value is now owned
- * by that container. Otherwise, @value is now the root. */
-static void qmp_output_add_obj(QmpOutputVisitor *qov, const char *name,
- QObject *value)
-{
- QStackEntry *e = QSLIST_FIRST(&qov->stack);
- QObject *cur = e ? e->value : NULL;
-
- if (!cur) {
- /* Don't allow reuse of visitor on more than one root */
- assert(!qov->root);
- qov->root = value;
- } else {
- switch (qobject_type(cur)) {
- case QTYPE_QDICT:
- assert(name);
- qdict_put_obj(qobject_to_qdict(cur), name, value);
- break;
- case QTYPE_QLIST:
- assert(!name);
- qlist_append_obj(qobject_to_qlist(cur), value);
- break;
- default:
- g_assert_not_reached();
- }
- }
-}
-
-static void qmp_output_start_struct(Visitor *v, const char *name, void **obj,
- size_t unused, Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- QDict *dict = qdict_new();
-
- qmp_output_add(qov, name, dict);
- qmp_output_push(qov, dict, obj);
-}
-
-static void qmp_output_end_struct(Visitor *v, void **obj)
-{
- QmpOutputVisitor *qov = to_qov(v);
- QObject *value = qmp_output_pop(qov, obj);
- assert(qobject_type(value) == QTYPE_QDICT);
-}
-
-static void qmp_output_start_list(Visitor *v, const char *name,
- GenericList **listp, size_t size,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- QList *list = qlist_new();
-
- qmp_output_add(qov, name, list);
- qmp_output_push(qov, list, listp);
-}
-
-static GenericList *qmp_output_next_list(Visitor *v, GenericList *tail,
- size_t size)
-{
- return tail->next;
-}
-
-static void qmp_output_end_list(Visitor *v, void **obj)
-{
- QmpOutputVisitor *qov = to_qov(v);
- QObject *value = qmp_output_pop(qov, obj);
- assert(qobject_type(value) == QTYPE_QLIST);
-}
-
-static void qmp_output_type_int64(Visitor *v, const char *name, int64_t *obj,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- qmp_output_add(qov, name, qint_from_int(*obj));
-}
-
-static void qmp_output_type_uint64(Visitor *v, const char *name, uint64_t *obj,
- Error **errp)
-{
- /* FIXME: QMP outputs values larger than INT64_MAX as negative */
- QmpOutputVisitor *qov = to_qov(v);
- qmp_output_add(qov, name, qint_from_int(*obj));
-}
-
-static void qmp_output_type_bool(Visitor *v, const char *name, bool *obj,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- qmp_output_add(qov, name, qbool_from_bool(*obj));
-}
-
-static void qmp_output_type_str(Visitor *v, const char *name, char **obj,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- if (*obj) {
- qmp_output_add(qov, name, qstring_from_str(*obj));
- } else {
- qmp_output_add(qov, name, qstring_from_str(""));
- }
-}
-
-static void qmp_output_type_number(Visitor *v, const char *name, double *obj,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- qmp_output_add(qov, name, qfloat_from_double(*obj));
-}
-
-static void qmp_output_type_any(Visitor *v, const char *name, QObject **obj,
- Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- qobject_incref(*obj);
- qmp_output_add_obj(qov, name, *obj);
-}
-
-static void qmp_output_type_null(Visitor *v, const char *name, Error **errp)
-{
- QmpOutputVisitor *qov = to_qov(v);
- qmp_output_add_obj(qov, name, qnull());
-}
-
-/* Finish building, and return the root object.
- * The root object is never null. The caller becomes the object's
- * owner, and should use qobject_decref() when done with it. */
-static void qmp_output_complete(Visitor *v, void *opaque)
-{
- QmpOutputVisitor *qov = to_qov(v);
-
- /* A visit must have occurred, with each start paired with end. */
- assert(qov->root && QSLIST_EMPTY(&qov->stack));
- assert(opaque == qov->result);
-
- qobject_incref(qov->root);
- *qov->result = qov->root;
- qov->result = NULL;
-}
-
-static void qmp_output_free(Visitor *v)
-{
- QmpOutputVisitor *qov = to_qov(v);
- QStackEntry *e;
-
- while (!QSLIST_EMPTY(&qov->stack)) {
- e = QSLIST_FIRST(&qov->stack);
- QSLIST_REMOVE_HEAD(&qov->stack, node);
- g_free(e);
- }
-
- qobject_decref(qov->root);
- g_free(qov);
-}
-
-Visitor *qmp_output_visitor_new(QObject **result)
-{
- QmpOutputVisitor *v;
-
- v = g_malloc0(sizeof(*v));
-
- v->visitor.type = VISITOR_OUTPUT;
- v->visitor.start_struct = qmp_output_start_struct;
- v->visitor.end_struct = qmp_output_end_struct;
- v->visitor.start_list = qmp_output_start_list;
- v->visitor.next_list = qmp_output_next_list;
- v->visitor.end_list = qmp_output_end_list;
- v->visitor.type_int64 = qmp_output_type_int64;
- v->visitor.type_uint64 = qmp_output_type_uint64;
- v->visitor.type_bool = qmp_output_type_bool;
- v->visitor.type_str = qmp_output_type_str;
- v->visitor.type_number = qmp_output_type_number;
- v->visitor.type_any = qmp_output_type_any;
- v->visitor.type_null = qmp_output_type_null;
- v->visitor.complete = qmp_output_complete;
- v->visitor.free = qmp_output_free;
-
- *result = NULL;
- v->result = result;
-
- return &v->visitor;
-}
diff --git a/qapi/qobject-output-visitor.c b/qapi/qobject-output-visitor.c
new file mode 100644
index 0000000..df43cb8
--- /dev/null
+++ b/qapi/qobject-output-visitor.c
@@ -0,0 +1,254 @@
+/*
+ * Core Definitions for QAPI/QMP Command Registry
+ *
+ * Copyright (C) 2012-2016 Red Hat, Inc.
+ * Copyright IBM, Corp. 2011
+ *
+ * Authors:
+ * Anthony Liguori <aliguori@us.ibm.com>
+ *
+ * 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 "qapi/qobject-output-visitor.h"
+#include "qapi/visitor-impl.h"
+#include "qemu/queue.h"
+#include "qemu-common.h"
+#include "qapi/qmp/types.h"
+
+typedef struct QStackEntry {
+ QObject *value;
+ void *qapi; /* sanity check that caller uses same pointer */
+ QSLIST_ENTRY(QStackEntry) node;
+} QStackEntry;
+
+struct QObjectOutputVisitor {
+ Visitor visitor;
+ QSLIST_HEAD(, QStackEntry) stack; /* Stack of unfinished containers */
+ QObject *root; /* Root of the output visit */
+ QObject **result; /* User's storage location for result */
+};
+
+#define qobject_output_add(qov, name, value) \
+ qobject_output_add_obj(qov, name, QOBJECT(value))
+#define qobject_output_push(qov, value, qapi) \
+ qobject_output_push_obj(qov, QOBJECT(value), qapi)
+
+static QObjectOutputVisitor *to_qov(Visitor *v)
+{
+ return container_of(v, QObjectOutputVisitor, visitor);
+}
+
+/* Push @value onto the stack of current QObjects being built */
+static void qobject_output_push_obj(QObjectOutputVisitor *qov, QObject *value,
+ void *qapi)
+{
+ QStackEntry *e = g_malloc0(sizeof(*e));
+
+ assert(qov->root);
+ assert(value);
+ e->value = value;
+ e->qapi = qapi;
+ QSLIST_INSERT_HEAD(&qov->stack, e, node);
+}
+
+/* Pop a value off the stack of QObjects being built, and return it. */
+static QObject *qobject_output_pop(QObjectOutputVisitor *qov, void *qapi)
+{
+ QStackEntry *e = QSLIST_FIRST(&qov->stack);
+ QObject *value;
+
+ assert(e);
+ assert(e->qapi == qapi);
+ QSLIST_REMOVE_HEAD(&qov->stack, node);
+ value = e->value;
+ assert(value);
+ g_free(e);
+ return value;
+}
+
+/* Add @value to the current QObject being built.
+ * If the stack is visiting a dictionary or list, @value is now owned
+ * by that container. Otherwise, @value is now the root. */
+static void qobject_output_add_obj(QObjectOutputVisitor *qov, const char *name,
+ QObject *value)
+{
+ QStackEntry *e = QSLIST_FIRST(&qov->stack);
+ QObject *cur = e ? e->value : NULL;
+
+ if (!cur) {
+ /* Don't allow reuse of visitor on more than one root */
+ assert(!qov->root);
+ qov->root = value;
+ } else {
+ switch (qobject_type(cur)) {
+ case QTYPE_QDICT:
+ assert(name);
+ qdict_put_obj(qobject_to_qdict(cur), name, value);
+ break;
+ case QTYPE_QLIST:
+ assert(!name);
+ qlist_append_obj(qobject_to_qlist(cur), value);
+ break;
+ default:
+ g_assert_not_reached();
+ }
+ }
+}
+
+static void qobject_output_start_struct(Visitor *v, const char *name,
+ void **obj, size_t unused, Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ QDict *dict = qdict_new();
+
+ qobject_output_add(qov, name, dict);
+ qobject_output_push(qov, dict, obj);
+}
+
+static void qobject_output_end_struct(Visitor *v, void **obj)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ QObject *value = qobject_output_pop(qov, obj);
+ assert(qobject_type(value) == QTYPE_QDICT);
+}
+
+static void qobject_output_start_list(Visitor *v, const char *name,
+ GenericList **listp, size_t size,
+ Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ QList *list = qlist_new();
+
+ qobject_output_add(qov, name, list);
+ qobject_output_push(qov, list, listp);
+}
+
+static GenericList *qobject_output_next_list(Visitor *v, GenericList *tail,
+ size_t size)
+{
+ return tail->next;
+}
+
+static void qobject_output_end_list(Visitor *v, void **obj)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ QObject *value = qobject_output_pop(qov, obj);
+ assert(qobject_type(value) == QTYPE_QLIST);
+}
+
+static void qobject_output_type_int64(Visitor *v, const char *name,
+ int64_t *obj, Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_output_add(qov, name, qint_from_int(*obj));
+}
+
+static void qobject_output_type_uint64(Visitor *v, const char *name,
+ uint64_t *obj, Error **errp)
+{
+ /* FIXME: QOBJECT outputs values larger than INT64_MAX as negative */
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_output_add(qov, name, qint_from_int(*obj));
+}
+
+static void qobject_output_type_bool(Visitor *v, const char *name, bool *obj,
+ Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_output_add(qov, name, qbool_from_bool(*obj));
+}
+
+static void qobject_output_type_str(Visitor *v, const char *name, char **obj,
+ Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ if (*obj) {
+ qobject_output_add(qov, name, qstring_from_str(*obj));
+ } else {
+ qobject_output_add(qov, name, qstring_from_str(""));
+ }
+}
+
+static void qobject_output_type_number(Visitor *v, const char *name,
+ double *obj, Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_output_add(qov, name, qfloat_from_double(*obj));
+}
+
+static void qobject_output_type_any(Visitor *v, const char *name,
+ QObject **obj, Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_incref(*obj);
+ qobject_output_add_obj(qov, name, *obj);
+}
+
+static void qobject_output_type_null(Visitor *v, const char *name, Error **errp)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ qobject_output_add_obj(qov, name, qnull());
+}
+
+/* Finish building, and return the root object.
+ * The root object is never null. The caller becomes the object's
+ * owner, and should use qobject_decref() when done with it. */
+static void qobject_output_complete(Visitor *v, void *opaque)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+
+ /* A visit must have occurred, with each start paired with end. */
+ assert(qov->root && QSLIST_EMPTY(&qov->stack));
+ assert(opaque == qov->result);
+
+ qobject_incref(qov->root);
+ *qov->result = qov->root;
+ qov->result = NULL;
+}
+
+static void qobject_output_free(Visitor *v)
+{
+ QObjectOutputVisitor *qov = to_qov(v);
+ QStackEntry *e;
+
+ while (!QSLIST_EMPTY(&qov->stack)) {
+ e = QSLIST_FIRST(&qov->stack);
+ QSLIST_REMOVE_HEAD(&qov->stack, node);
+ g_free(e);
+ }
+
+ qobject_decref(qov->root);
+ g_free(qov);
+}
+
+Visitor *qobject_output_visitor_new(QObject **result)
+{
+ QObjectOutputVisitor *v;
+
+ v = g_malloc0(sizeof(*v));
+
+ v->visitor.type = VISITOR_OUTPUT;
+ v->visitor.start_struct = qobject_output_start_struct;
+ v->visitor.end_struct = qobject_output_end_struct;
+ v->visitor.start_list = qobject_output_start_list;
+ v->visitor.next_list = qobject_output_next_list;
+ v->visitor.end_list = qobject_output_end_list;
+ v->visitor.type_int64 = qobject_output_type_int64;
+ v->visitor.type_uint64 = qobject_output_type_uint64;
+ v->visitor.type_bool = qobject_output_type_bool;
+ v->visitor.type_str = qobject_output_type_str;
+ v->visitor.type_number = qobject_output_type_number;
+ v->visitor.type_any = qobject_output_type_any;
+ v->visitor.type_null = qobject_output_type_null;
+ v->visitor.complete = qobject_output_complete;
+ v->visitor.free = qobject_output_free;
+
+ *result = NULL;
+ v->result = result;
+
+ return &v->visitor;
+}
diff --git a/qemu-img.c b/qemu-img.c
index b399ae5..182a7c1 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -25,7 +25,7 @@
#include "qemu-version.h"
#include "qapi/error.h"
#include "qapi-visit.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/qmp/qerror.h"
#include "qapi/qmp/qjson.h"
#include "qemu/cutils.h"
@@ -502,7 +502,7 @@ static void dump_json_image_check(ImageCheck *check, bool quiet)
{
QString *str;
QObject *obj;
- Visitor *v = qmp_output_visitor_new(&obj);
+ Visitor *v = qobject_output_visitor_new(&obj);
visit_type_ImageCheck(v, NULL, &check, &error_abort);
visit_complete(v, &obj);
@@ -2195,7 +2195,7 @@ static void dump_json_image_info_list(ImageInfoList *list)
{
QString *str;
QObject *obj;
- Visitor *v = qmp_output_visitor_new(&obj);
+ Visitor *v = qobject_output_visitor_new(&obj);
visit_type_ImageInfoList(v, NULL, &list, &error_abort);
visit_complete(v, &obj);
@@ -2211,7 +2211,7 @@ static void dump_json_image_info(ImageInfo *info)
{
QString *str;
QObject *obj;
- Visitor *v = qmp_output_visitor_new(&obj);
+ Visitor *v = qobject_output_visitor_new(&obj);
visit_type_ImageInfo(v, NULL, &info, &error_abort);
visit_complete(v, &obj);
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index 48edf2f..f7afe49 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -3,7 +3,7 @@
#include "qom/object_interfaces.h"
#include "qemu/module.h"
#include "qapi-visit.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/opts-visitor.h"
void user_creatable_complete(Object *obj, Error **errp)
diff --git a/qom/qom-qobject.c b/qom/qom-qobject.c
index 81959e0..447e4a0 100644
--- a/qom/qom-qobject.c
+++ b/qom/qom-qobject.c
@@ -16,7 +16,7 @@
#include "qom/qom-qobject.h"
#include "qapi/visitor.h"
#include "qapi/qobject-input-visitor.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
void object_property_set_qobject(Object *obj, QObject *value,
const char *name, Error **errp)
@@ -35,7 +35,7 @@ QObject *object_property_get_qobject(Object *obj, const char *name,
Error *local_err = NULL;
Visitor *v;
- v = qmp_output_visitor_new(&ret);
+ v = qobject_output_visitor_new(&ret);
object_property_get(obj, v, name, &local_err);
if (!local_err) {
visit_complete(v, &ret);
diff --git a/scripts/qapi-commands.py b/scripts/qapi-commands.py
index 04158a3..09e8467 100644
--- a/scripts/qapi-commands.py
+++ b/scripts/qapi-commands.py
@@ -68,7 +68,7 @@ static void qmp_marshal_output_%(c_name)s(%(c_type)s ret_in, QObject **ret_out,
Error *err = NULL;
Visitor *v;
- v = qmp_output_visitor_new(ret_out);
+ v = qobject_output_visitor_new(ret_out);
visit_type_%(c_name)s(v, "unused", &ret_in, &err);
if (!err) {
visit_complete(v, ret_out);
@@ -293,7 +293,7 @@ fdef.write(mcgen('''
#include "qapi/qmp/types.h"
#include "qapi/qmp/dispatch.h"
#include "qapi/visitor.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/qobject-input-visitor.h"
#include "qapi/dealloc-visitor.h"
#include "%(prefix)sqapi-types.h"
diff --git a/scripts/qapi-event.py b/scripts/qapi-event.py
index 38d8211..f4eb7f8 100644
--- a/scripts/qapi-event.py
+++ b/scripts/qapi-event.py
@@ -98,7 +98,7 @@ def gen_event_send(name, arg_type, boxed):
if arg_type and not arg_type.is_empty():
ret += mcgen('''
- v = qmp_output_visitor_new(&obj);
+ v = qobject_output_visitor_new(&obj);
''')
if not arg_type.is_implicit():
ret += mcgen('''
@@ -209,7 +209,7 @@ fdef.write(mcgen('''
#include "qemu-common.h"
#include "%(prefix)sqapi-event.h"
#include "%(prefix)sqapi-visit.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/qmp-event.h"
''',
diff --git a/tests/.gitignore b/tests/.gitignore
index 2260d8a..7cb2eb0 100644
--- a/tests/.gitignore
+++ b/tests/.gitignore
@@ -61,7 +61,7 @@ test-qobject-input-strict
test-qobject-input-visitor
test-qmp-introspect.[ch]
test-qmp-marshal.c
-test-qmp-output-visitor
+test-qobject-output-visitor
test-rcu-list
test-replication
test-rfifolock
diff --git a/tests/Makefile.include b/tests/Makefile.include
index c8d601b..6398678 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -20,8 +20,8 @@ check-unit-y += tests/check-qnull$(EXESUF)
gcov-files-check-qnull-y = qobject/qnull.c
check-unit-y += tests/check-qjson$(EXESUF)
gcov-files-check-qjson-y = qobject/qjson.c
-check-unit-y += tests/test-qmp-output-visitor$(EXESUF)
-gcov-files-test-qmp-output-visitor-y = qapi/qmp-output-visitor.c
+check-unit-y += tests/test-qobject-output-visitor$(EXESUF)
+gcov-files-test-qobject-output-visitor-y = qapi/qobject-output-visitor.c
check-unit-y += tests/test-clone-visitor$(EXESUF)
gcov-files-test-clone-visitor-y = qapi/qapi-clone-visitor.c
check-unit-y += tests/test-qobject-input-visitor$(EXESUF)
@@ -438,7 +438,7 @@ test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
tests/check-qlist.o tests/check-qfloat.o tests/check-qnull.o \
tests/check-qjson.o \
tests/test-coroutine.o tests/test-string-output-visitor.o \
- tests/test-string-input-visitor.o tests/test-qmp-output-visitor.o \
+ tests/test-string-input-visitor.o tests/test-qobject-output-visitor.o \
tests/test-clone-visitor.o \
tests/test-qobject-input-visitor.o tests/test-qobject-input-strict.o \
tests/test-qmp-commands.o tests/test-visitor-serialization.o \
@@ -541,7 +541,7 @@ $(SRC_PATH)/tests/qapi-schema/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-int
tests/test-string-output-visitor$(EXESUF): tests/test-string-output-visitor.o $(test-qapi-obj-y)
tests/test-string-input-visitor$(EXESUF): tests/test-string-input-visitor.o $(test-qapi-obj-y)
tests/test-qmp-event$(EXESUF): tests/test-qmp-event.o $(test-qapi-obj-y)
-tests/test-qmp-output-visitor$(EXESUF): tests/test-qmp-output-visitor.o $(test-qapi-obj-y)
+tests/test-qobject-output-visitor$(EXESUF): tests/test-qobject-output-visitor.o $(test-qapi-obj-y)
tests/test-clone-visitor$(EXESUF): tests/test-clone-visitor.o $(test-qapi-obj-y)
tests/test-qobject-input-visitor$(EXESUF): tests/test-qobject-input-visitor.o $(test-qapi-obj-y)
tests/test-qobject-input-strict$(EXESUF): tests/test-qobject-input-strict.o $(test-qapi-obj-y)
diff --git a/tests/check-qnull.c b/tests/check-qnull.c
index eeb803a..b50bb8a 100644
--- a/tests/check-qnull.c
+++ b/tests/check-qnull.c
@@ -11,7 +11,7 @@
#include "qapi/qmp/qobject.h"
#include "qemu-common.h"
#include "qapi/qobject-input-visitor.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/error.h"
/*
@@ -52,7 +52,7 @@ static void qnull_visit_test(void)
visit_type_null(v, NULL, &error_abort);
visit_free(v);
- v = qmp_output_visitor_new(&obj);
+ v = qobject_output_visitor_new(&obj);
visit_type_null(v, NULL, &error_abort);
visit_complete(v, &obj);
g_assert(obj == &qnull_);
diff --git a/tests/test-qmp-output-visitor.c b/tests/test-qobject-output-visitor.c
similarity index 99%
rename from tests/test-qmp-output-visitor.c
rename to tests/test-qobject-output-visitor.c
index 513d71f..4e2d79c 100644
--- a/tests/test-qmp-output-visitor.c
+++ b/tests/test-qobject-output-visitor.c
@@ -1,5 +1,5 @@
/*
- * QMP Output Visitor unit-tests.
+ * QObject Output Visitor unit-tests.
*
* Copyright (C) 2011-2016 Red Hat Inc.
*
@@ -14,7 +14,7 @@
#include "qemu-common.h"
#include "qapi/error.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "test-qapi-types.h"
#include "test-qapi-visit.h"
#include "qapi/qmp/types.h"
@@ -28,7 +28,7 @@ typedef struct TestOutputVisitorData {
static void visitor_output_setup(TestOutputVisitorData *data,
const void *unused)
{
- data->ov = qmp_output_visitor_new(&data->obj);
+ data->ov = qobject_output_visitor_new(&data->obj);
g_assert(data->ov);
}
diff --git a/tests/test-string-output-visitor.c b/tests/test-string-output-visitor.c
index 444844a..e736db3 100644
--- a/tests/test-string-output-visitor.c
+++ b/tests/test-string-output-visitor.c
@@ -4,7 +4,7 @@
* Copyright (C) 2012 Red Hat Inc.
*
* Authors:
- * Paolo Bonzini <pbonzini@redhat.com> (based on test-qmp-output-visitor)
+ * Paolo Bonzini <pbonzini@redhat.com> (based on test-qobject-output-visitor)
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
diff --git a/tests/test-visitor-serialization.c b/tests/test-visitor-serialization.c
index 51df428..66b2b1c 100644
--- a/tests/test-visitor-serialization.c
+++ b/tests/test-visitor-serialization.c
@@ -21,7 +21,7 @@
#include "qapi/qmp/types.h"
#include "qapi/qmp/qjson.h"
#include "qapi/qobject-input-visitor.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi/string-input-visitor.h"
#include "qapi/string-output-visitor.h"
#include "qapi-types.h"
@@ -1022,7 +1022,7 @@ static void qmp_serialize(void *native_in, void **datap,
{
QmpSerializeData *d = g_malloc0(sizeof(*d));
- d->qov = qmp_output_visitor_new(&d->obj);
+ d->qov = qobject_output_visitor_new(&d->obj);
visit(d->qov, &native_in, errp);
*datap = d;
}
diff --git a/util/qemu-sockets.c b/util/qemu-sockets.c
index 9e30a21..4cef549 100644
--- a/util/qemu-sockets.c
+++ b/util/qemu-sockets.c
@@ -22,7 +22,7 @@
#include "qemu/sockets.h"
#include "qemu/main-loop.h"
#include "qapi/qobject-input-visitor.h"
-#include "qapi/qmp-output-visitor.h"
+#include "qapi/qobject-output-visitor.h"
#include "qapi-visit.h"
#include "qemu/cutils.h"
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (5 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 06/19] qapi: rename QmpOutputVisitor to QObjectOutputVisitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 22:10 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 08/19] qapi: permit scalar type conversions in QObjectInputVisitor Daniel P. Berrange
` (12 subsequent siblings)
19 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The input_visitor_test_add() method was accepting an instance
of 'TestInputVisitorData' and passing it as the 'user_data'
parameter to test functions. The main 'TestInputVisitorData'
instance that was actually used, was meanwhile being allocated
automatically by the test framework fixture setup.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
tests/test-qobject-input-visitor.c | 76 ++++++++++++++++----------------------
1 file changed, 32 insertions(+), 44 deletions(-)
diff --git a/tests/test-qobject-input-visitor.c b/tests/test-qobject-input-visitor.c
index 0e65e63..26c5012 100644
--- a/tests/test-qobject-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -747,10 +747,11 @@ static void test_visitor_in_native_list_number(TestInputVisitorData *data,
}
static void input_visitor_test_add(const char *testpath,
- TestInputVisitorData *data,
- void (*test_func)(TestInputVisitorData *data, const void *user_data))
+ const void *user_data,
+ void (*test_func)(TestInputVisitorData *data,
+ const void *user_data))
{
- g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
+ g_test_add(testpath, TestInputVisitorData, user_data, NULL, test_func,
visitor_input_teardown);
}
@@ -833,77 +834,64 @@ static void test_visitor_in_wrong_type(TestInputVisitorData *data,
int main(int argc, char **argv)
{
- TestInputVisitorData in_visitor_data;
-
g_test_init(&argc, &argv, NULL);
input_visitor_test_add("/visitor/input/int",
- &in_visitor_data, test_visitor_in_int);
+ NULL, test_visitor_in_int);
input_visitor_test_add("/visitor/input/int_overflow",
- &in_visitor_data, test_visitor_in_int_overflow);
+ NULL, test_visitor_in_int_overflow);
input_visitor_test_add("/visitor/input/bool",
- &in_visitor_data, test_visitor_in_bool);
+ NULL, test_visitor_in_bool);
input_visitor_test_add("/visitor/input/number",
- &in_visitor_data, test_visitor_in_number);
+ NULL, test_visitor_in_number);
input_visitor_test_add("/visitor/input/string",
- &in_visitor_data, test_visitor_in_string);
+ NULL, test_visitor_in_string);
input_visitor_test_add("/visitor/input/enum",
- &in_visitor_data, test_visitor_in_enum);
+ NULL, test_visitor_in_enum);
input_visitor_test_add("/visitor/input/struct",
- &in_visitor_data, test_visitor_in_struct);
+ NULL, test_visitor_in_struct);
input_visitor_test_add("/visitor/input/struct-nested",
- &in_visitor_data, test_visitor_in_struct_nested);
+ NULL, test_visitor_in_struct_nested);
input_visitor_test_add("/visitor/input/list",
- &in_visitor_data, test_visitor_in_list);
+ NULL, test_visitor_in_list);
input_visitor_test_add("/visitor/input/any",
- &in_visitor_data, test_visitor_in_any);
+ NULL, test_visitor_in_any);
input_visitor_test_add("/visitor/input/null",
- &in_visitor_data, test_visitor_in_null);
+ NULL, test_visitor_in_null);
input_visitor_test_add("/visitor/input/union-flat",
- &in_visitor_data, test_visitor_in_union_flat);
+ NULL, test_visitor_in_union_flat);
input_visitor_test_add("/visitor/input/alternate",
- &in_visitor_data, test_visitor_in_alternate);
+ NULL, test_visitor_in_alternate);
input_visitor_test_add("/visitor/input/errors",
- &in_visitor_data, test_visitor_in_errors);
+ NULL, test_visitor_in_errors);
input_visitor_test_add("/visitor/input/wrong-type",
- &in_visitor_data, test_visitor_in_wrong_type);
+ NULL, test_visitor_in_wrong_type);
input_visitor_test_add("/visitor/input/alternate-number",
- &in_visitor_data, test_visitor_in_alternate_number);
+ NULL, test_visitor_in_alternate_number);
input_visitor_test_add("/visitor/input/native_list/int",
- &in_visitor_data,
- test_visitor_in_native_list_int);
+ NULL, test_visitor_in_native_list_int);
input_visitor_test_add("/visitor/input/native_list/int8",
- &in_visitor_data,
- test_visitor_in_native_list_int8);
+ NULL, test_visitor_in_native_list_int8);
input_visitor_test_add("/visitor/input/native_list/int16",
- &in_visitor_data,
- test_visitor_in_native_list_int16);
+ NULL, test_visitor_in_native_list_int16);
input_visitor_test_add("/visitor/input/native_list/int32",
- &in_visitor_data,
- test_visitor_in_native_list_int32);
+ NULL, test_visitor_in_native_list_int32);
input_visitor_test_add("/visitor/input/native_list/int64",
- &in_visitor_data,
- test_visitor_in_native_list_int64);
+ NULL, test_visitor_in_native_list_int64);
input_visitor_test_add("/visitor/input/native_list/uint8",
- &in_visitor_data,
- test_visitor_in_native_list_uint8);
+ NULL, test_visitor_in_native_list_uint8);
input_visitor_test_add("/visitor/input/native_list/uint16",
- &in_visitor_data,
- test_visitor_in_native_list_uint16);
+ NULL, test_visitor_in_native_list_uint16);
input_visitor_test_add("/visitor/input/native_list/uint32",
- &in_visitor_data,
- test_visitor_in_native_list_uint32);
+ NULL, test_visitor_in_native_list_uint32);
input_visitor_test_add("/visitor/input/native_list/uint64",
- &in_visitor_data,
- test_visitor_in_native_list_uint64);
+ NULL, test_visitor_in_native_list_uint64);
input_visitor_test_add("/visitor/input/native_list/bool",
- &in_visitor_data, test_visitor_in_native_list_bool);
+ NULL, test_visitor_in_native_list_bool);
input_visitor_test_add("/visitor/input/native_list/str",
- &in_visitor_data,
- test_visitor_in_native_list_string);
+ NULL, test_visitor_in_native_list_string);
input_visitor_test_add("/visitor/input/native_list/number",
- &in_visitor_data,
- test_visitor_in_native_list_number);
+ NULL, test_visitor_in_native_list_number);
g_test_run();
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 08/19] qapi: permit scalar type conversions in QObjectInputVisitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (6 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 09/19] qapi: permit auto-creating single element lists Daniel P. Berrange
` (11 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Currently the QObjectInputVisitor assumes that all scalar
values are directly represented as the final types declared
by the thing being visited. ie it assumes an 'int' is using
QInt, and a 'bool' is using QBool, etc. This is good when
QObjectInputVisitor is fed a QObject that came from a JSON
document on the QMP monitor, as it will strictly validate
correctness.
To allow QObjectInputVisitor to be reused for visiting
a QObject originating from QemuOpts, an alternative mode
is needed where all the scalars types are represented as
QString and converted on the fly to the final desired
type.
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qobject-input-visitor.h | 32 +++++-
qapi/qobject-input-visitor.c | 132 ++++++++++++++++++++++++
tests/test-qobject-input-visitor.c | 194 ++++++++++++++++++++++++++++++++++-
3 files changed, 350 insertions(+), 8 deletions(-)
diff --git a/include/qapi/qobject-input-visitor.h b/include/qapi/qobject-input-visitor.h
index cde328d..5022297 100644
--- a/include/qapi/qobject-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -19,12 +19,36 @@
typedef struct QObjectInputVisitor QObjectInputVisitor;
-/*
- * Return a new input visitor that converts a QObject to a QAPI object.
+/**
+ * Create a new input visitor that converts @obj to a QAPI object.
+ *
+ * Any scalar values in the @obj input data structure should be in the
+ * required type already. i.e. if visiting a bool, the value should
+ * already be a QBool instance.
*
- * Set @strict to reject a parse that doesn't consume all keys of a
- * dictionary; otherwise excess input is ignored.
+ * If @strict is set to true, then an error will be reported if any
+ * dict keys are not consumed during visitation. If @strict is false
+ * then extra dict keys are silently ignored.
+ *
+ * The returned input visitor should be released by calling
+ * visit_free() when no longer required.
*/
Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
+/**
+ * Create a new input visitor that converts @obj to a QAPI object.
+ *
+ * Any scalar values in the @obj input data structure should always be
+ * represented as strings. i.e. if visiting a boolean, the value should
+ * be a QString whose contents represent a valid boolean.
+ *
+ * The visitor always operates in strict mode, requiring all dict keys
+ * to be consumed during visitation. An error will be reported if this
+ * does not happen.
+ *
+ * The returned input visitor should be released by calling
+ * visit_free() when no longer required.
+ */
+Visitor *qobject_input_visitor_new_autocast(QObject *obj);
+
#endif
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index 5ff3db3..cf41df6 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -20,6 +20,7 @@
#include "qemu-common.h"
#include "qapi/qmp/types.h"
#include "qapi/qmp/qerror.h"
+#include "qemu/cutils.h"
#define QIV_STACK_SIZE 1024
@@ -263,6 +264,28 @@ static void qobject_input_type_int64(Visitor *v, const char *name, int64_t *obj,
*obj = qint_get_int(qint);
}
+
+static void qobject_input_type_int64_autocast(Visitor *v, const char *name,
+ int64_t *obj, Error **errp)
+{
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
+ int64_t ret;
+
+ if (!qstr || !qstr->string) {
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "string");
+ return;
+ }
+
+ if (qemu_strtoll(qstr->string, NULL, 0, &ret) < 0) {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
+ return;
+ }
+ *obj = ret;
+}
+
static void qobject_input_type_uint64(Visitor *v, const char *name,
uint64_t *obj, Error **errp)
{
@@ -279,6 +302,27 @@ static void qobject_input_type_uint64(Visitor *v, const char *name,
*obj = qint_get_int(qint);
}
+static void qobject_input_type_uint64_autocast(Visitor *v, const char *name,
+ uint64_t *obj, Error **errp)
+{
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
+ unsigned long long ret;
+
+ if (!qstr || !qstr->string) {
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "string");
+ return;
+ }
+
+ if (parse_uint_full(qstr->string, &ret, 0) < 0) {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
+ return;
+ }
+ *obj = ret;
+}
+
static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj,
Error **errp)
{
@@ -294,6 +338,22 @@ static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj,
*obj = qbool_get_bool(qbool);
}
+static void qobject_input_type_bool_autocast(Visitor *v, const char *name,
+ bool *obj, Error **errp)
+{
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
+
+ if (!qstr || !qstr->string) {
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "string");
+ return;
+ }
+
+ parse_option_bool(name, qstr->string, obj, errp);
+}
+
static void qobject_input_type_str(Visitor *v, const char *name, char **obj,
Error **errp)
{
@@ -335,6 +395,30 @@ static void qobject_input_type_number(Visitor *v, const char *name, double *obj,
"number");
}
+static void qobject_input_type_number_autocast(Visitor *v, const char *name,
+ double *obj, Error **errp)
+{
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
+ char *endp;
+
+ if (!qstr || !qstr->string) {
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "string");
+ return;
+ }
+
+ errno = 0;
+ *obj = strtod(qstr->string, &endp);
+ if (errno == 0 && endp != qstr->string && *endp == '\0') {
+ return;
+ }
+
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "number");
+}
+
static void qobject_input_type_any(Visitor *v, const char *name, QObject **obj,
Error **errp)
{
@@ -356,6 +440,22 @@ static void qobject_input_type_null(Visitor *v, const char *name, Error **errp)
}
}
+static void qobject_input_type_size_autocast(Visitor *v, const char *name,
+ uint64_t *obj, Error **errp)
+{
+ QObjectInputVisitor *qiv = to_qiv(v);
+ QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
+
+ if (!qstr || !qstr->string) {
+ error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
+ "string");
+ return;
+ }
+
+ parse_option_size(name, qstr->string, obj, errp);
+}
+
static void qobject_input_optional(Visitor *v, const char *name, bool *present)
{
QObjectInputVisitor *qiv = to_qiv(v);
@@ -413,3 +513,35 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict)
return &v->visitor;
}
+
+Visitor *qobject_input_visitor_new_autocast(QObject *obj)
+{
+ QObjectInputVisitor *v;
+
+ v = g_malloc0(sizeof(*v));
+
+ v->visitor.type = VISITOR_INPUT;
+ v->visitor.start_struct = qobject_input_start_struct;
+ v->visitor.check_struct = qobject_input_check_struct;
+ v->visitor.end_struct = qobject_input_pop;
+ v->visitor.start_list = qobject_input_start_list;
+ v->visitor.next_list = qobject_input_next_list;
+ v->visitor.end_list = qobject_input_pop;
+ v->visitor.start_alternate = qobject_input_start_alternate;
+ v->visitor.type_int64 = qobject_input_type_int64_autocast;
+ v->visitor.type_uint64 = qobject_input_type_uint64_autocast;
+ v->visitor.type_bool = qobject_input_type_bool_autocast;
+ v->visitor.type_str = qobject_input_type_str;
+ v->visitor.type_number = qobject_input_type_number_autocast;
+ v->visitor.type_any = qobject_input_type_any;
+ v->visitor.type_null = qobject_input_type_null;
+ v->visitor.type_size = qobject_input_type_size_autocast;
+ v->visitor.optional = qobject_input_optional;
+ v->visitor.free = qobject_input_free;
+ v->strict = true;
+
+ v->root = obj;
+ qobject_incref(obj);
+
+ return &v->visitor;
+}
diff --git a/tests/test-qobject-input-visitor.c b/tests/test-qobject-input-visitor.c
index 26c5012..d5b8044 100644
--- a/tests/test-qobject-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -41,6 +41,7 @@ static void visitor_input_teardown(TestInputVisitorData *data,
function so that the JSON string used by the tests are kept in the test
functions (and not in main()). */
static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
+ bool strict, bool autocast,
const char *json_string,
va_list *ap)
{
@@ -49,11 +50,31 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
- data->qiv = qobject_input_visitor_new(data->obj, false);
+ if (autocast) {
+ assert(strict);
+ data->qiv = qobject_input_visitor_new_autocast(data->obj);
+ } else {
+ data->qiv = qobject_input_visitor_new(data->obj, strict);
+ }
g_assert(data->qiv);
return data->qiv;
}
+static GCC_FMT_ATTR(4, 5)
+Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
+ bool strict, bool autocast,
+ const char *json_string, ...)
+{
+ Visitor *v;
+ va_list ap;
+
+ va_start(ap, json_string);
+ v = visitor_input_test_init_internal(data, strict, autocast,
+ json_string, &ap);
+ va_end(ap);
+ return v;
+}
+
static GCC_FMT_ATTR(2, 3)
Visitor *visitor_input_test_init(TestInputVisitorData *data,
const char *json_string, ...)
@@ -62,7 +83,8 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
va_list ap;
va_start(ap, json_string);
- v = visitor_input_test_init_internal(data, json_string, &ap);
+ v = visitor_input_test_init_internal(data, true, false,
+ json_string, &ap);
va_end(ap);
return v;
}
@@ -77,7 +99,8 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
- return visitor_input_test_init_internal(data, json_string, NULL);
+ return visitor_input_test_init_internal(data, true, false,
+ json_string, NULL);
}
static void test_visitor_in_int(TestInputVisitorData *data,
@@ -109,6 +132,45 @@ static void test_visitor_in_int_overflow(TestInputVisitorData *data,
error_free_or_abort(&err);
}
+static void test_visitor_in_int_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0, value = -42;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true,
+ "%" PRId64, value);
+ visit_type_int(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_int_str_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0, value = -42;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true,
+ "\"-42\"");
+
+ visit_type_int(v, NULL, &res, &error_abort);
+ g_assert_cmpint(res, ==, value);
+}
+
+static void test_visitor_in_int_str_noautocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"-42\"");
+
+ visit_type_int(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_bool(TestInputVisitorData *data,
const void *unused)
{
@@ -121,6 +183,44 @@ static void test_visitor_in_bool(TestInputVisitorData *data,
g_assert_cmpint(res, ==, true);
}
+static void test_visitor_in_bool_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, "true");
+
+ visit_type_bool(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_bool_str_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, "\"yes\"");
+
+ visit_type_bool(v, NULL, &res, &error_abort);
+ g_assert_cmpint(res, ==, true);
+}
+
+static void test_visitor_in_bool_str_noautocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"true\"");
+
+ visit_type_bool(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_number(TestInputVisitorData *data,
const void *unused)
{
@@ -133,6 +233,69 @@ static void test_visitor_in_number(TestInputVisitorData *data,
g_assert_cmpfloat(res, ==, value);
}
+static void test_visitor_in_number_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0, value = 3.14;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, "%f", value);
+
+ visit_type_number(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_number_str_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0, value = 3.14;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, "\"3.14\"");
+
+ visit_type_number(v, NULL, &res, &error_abort);
+ g_assert_cmpfloat(res, ==, value);
+}
+
+static void test_visitor_in_number_str_noautocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"3.14\"");
+
+ visit_type_number(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_size_str_autocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint64_t res, value = 500 * 1024 * 1024;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, "\"500M\"");
+
+ visit_type_size(v, NULL, &res, &error_abort);
+ g_assert_cmpfloat(res, ==, value);
+}
+
+static void test_visitor_in_size_str_noautocast(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint64_t res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"500M\"");
+
+ visit_type_size(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_string(TestInputVisitorData *data,
const void *unused)
{
@@ -289,7 +452,8 @@ static void test_visitor_in_null(TestInputVisitorData *data,
* when input is not null.
*/
- v = visitor_input_test_init(data, "{ 'a': null, 'b': '' }");
+ v = visitor_input_test_init_full(data, false, false,
+ "{ 'a': null, 'b': '' }");
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_null(v, "a", &error_abort);
visit_type_str(v, "a", &tmp, &err);
@@ -840,10 +1004,32 @@ int main(int argc, char **argv)
NULL, test_visitor_in_int);
input_visitor_test_add("/visitor/input/int_overflow",
NULL, test_visitor_in_int_overflow);
+ input_visitor_test_add("/visitor/input/int_autocast",
+ NULL, test_visitor_in_int_autocast);
+ input_visitor_test_add("/visitor/input/int_str_autocast",
+ NULL, test_visitor_in_int_str_autocast);
+ input_visitor_test_add("/visitor/input/int_str_noautocast",
+ NULL, test_visitor_in_int_str_noautocast);
input_visitor_test_add("/visitor/input/bool",
NULL, test_visitor_in_bool);
+ input_visitor_test_add("/visitor/input/bool_autocast",
+ NULL, test_visitor_in_bool_autocast);
+ input_visitor_test_add("/visitor/input/bool_str_autocast",
+ NULL, test_visitor_in_bool_str_autocast);
+ input_visitor_test_add("/visitor/input/bool_str_noautocast",
+ NULL, test_visitor_in_bool_str_noautocast);
input_visitor_test_add("/visitor/input/number",
NULL, test_visitor_in_number);
+ input_visitor_test_add("/visitor/input/number_autocast",
+ NULL, test_visitor_in_number_autocast);
+ input_visitor_test_add("/visitor/input/number_str_autocast",
+ NULL, test_visitor_in_number_str_autocast);
+ input_visitor_test_add("/visitor/input/number_str_noautocast",
+ NULL, test_visitor_in_number_str_noautocast);
+ input_visitor_test_add("/visitor/input/size_str_autocast",
+ NULL, test_visitor_in_size_str_autocast);
+ input_visitor_test_add("/visitor/input/size_str_noautocast",
+ NULL, test_visitor_in_size_str_noautocast);
input_visitor_test_add("/visitor/input/string",
NULL, test_visitor_in_string);
input_visitor_test_add("/visitor/input/enum",
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 09/19] qapi: permit auto-creating single element lists
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (7 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 08/19] qapi: permit scalar type conversions in QObjectInputVisitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 10/19] qapi: permit auto-creating nested structs Daniel P. Berrange
` (10 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
When converting QemuOpts to a QObject, there is no information
about compound types available, so when visiting a list, the
corresponding QObject is not guaranteed to be a QList. We
therefore need to be able to auto-create a single element QList
from whatever type we find.
This mode should only be enabled if you have compatibility
requirements for
-arg foo=hello,foo=world
to be treated as equivalent to the preferred syntax:
-arg foo.0=hello,foo.1=world
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qobject-input-visitor.h | 16 ++++++-
qapi/qobject-input-visitor.c | 23 ++++++++--
tests/test-qobject-input-visitor.c | 88 +++++++++++++++++++++++++++++++-----
3 files changed, 111 insertions(+), 16 deletions(-)
diff --git a/include/qapi/qobject-input-visitor.h b/include/qapi/qobject-input-visitor.h
index 5022297..fb52457 100644
--- a/include/qapi/qobject-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -42,6 +42,19 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
* represented as strings. i.e. if visiting a boolean, the value should
* be a QString whose contents represent a valid boolean.
*
+ * If @autocreate_list is true, then as an alternative to a normal QList,
+ * list values can be stored as a QString or QDict instead, which will
+ * be interpreted as representing single element lists. This should only
+ * by used if compatibility is required with the OptsVisitor which allowed
+ * repeated keys, without list indexes, to represent lists. e.g. set this
+ * to true if you have compatibility requirements for
+ *
+ * -arg foo=hello,foo=world
+ *
+ * to be treated as equivalent to the preferred syntax:
+ *
+ * -arg foo.0=hello,foo.1=world
+ *
* The visitor always operates in strict mode, requiring all dict keys
* to be consumed during visitation. An error will be reported if this
* does not happen.
@@ -49,6 +62,7 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
* The returned input visitor should be released by calling
* visit_free() when no longer required.
*/
-Visitor *qobject_input_visitor_new_autocast(QObject *obj);
+Visitor *qobject_input_visitor_new_autocast(QObject *obj,
+ bool autocreate_list);
#endif
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index cf41df6..e8afd1e 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -48,6 +48,10 @@ struct QObjectInputVisitor
/* True to reject parse in visit_end_struct() if unvisited keys remain. */
bool strict;
+
+ /* Whether we can auto-create single element lists when
+ * encountering a non-QList type */
+ bool autocreate_list;
};
static QObjectInputVisitor *to_qiv(Visitor *v)
@@ -108,6 +112,7 @@ static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv,
assert(obj);
tos->obj = obj;
tos->qapi = qapi;
+ qobject_incref(obj);
if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
h = g_hash_table_new(g_str_hash, g_str_equal);
@@ -147,6 +152,7 @@ static void qobject_input_stack_object_free(StackObject *tos)
if (tos->h) {
g_hash_table_unref(tos->h);
}
+ qobject_decref(tos->obj);
g_free(tos);
}
@@ -197,7 +203,7 @@ static void qobject_input_start_list(Visitor *v, const char *name,
QObject *qobj = qobject_input_get_object(qiv, name, true);
const QListEntry *entry;
- if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
+ if (!qobj || (!qiv->autocreate_list && qobject_type(qobj) != QTYPE_QLIST)) {
if (list) {
*list = NULL;
}
@@ -206,7 +212,16 @@ static void qobject_input_start_list(Visitor *v, const char *name,
return;
}
- entry = qobject_input_push(qiv, qobj, list, errp);
+ if (qobject_type(qobj) != QTYPE_QLIST) {
+ QList *tmplist = qlist_new();
+ qlist_append_obj(tmplist, qobj);
+ qobject_incref(qobj);
+ entry = qobject_input_push(qiv, QOBJECT(tmplist), list, errp);
+ QDECREF(tmplist);
+ } else {
+ entry = qobject_input_push(qiv, qobj, list, errp);
+ }
+
if (list) {
if (entry) {
*list = g_malloc0(size);
@@ -514,7 +529,8 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict)
return &v->visitor;
}
-Visitor *qobject_input_visitor_new_autocast(QObject *obj)
+Visitor *qobject_input_visitor_new_autocast(QObject *obj,
+ bool autocreate_list)
{
QObjectInputVisitor *v;
@@ -539,6 +555,7 @@ Visitor *qobject_input_visitor_new_autocast(QObject *obj)
v->visitor.optional = qobject_input_optional;
v->visitor.free = qobject_input_free;
v->strict = true;
+ v->autocreate_list = autocreate_list;
v->root = obj;
qobject_incref(obj);
diff --git a/tests/test-qobject-input-visitor.c b/tests/test-qobject-input-visitor.c
index d5b8044..c227565 100644
--- a/tests/test-qobject-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -42,6 +42,7 @@ static void visitor_input_teardown(TestInputVisitorData *data,
functions (and not in main()). */
static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
bool strict, bool autocast,
+ bool autocreate_list,
const char *json_string,
va_list *ap)
{
@@ -52,17 +53,20 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
if (autocast) {
assert(strict);
- data->qiv = qobject_input_visitor_new_autocast(data->obj);
+ data->qiv = qobject_input_visitor_new_autocast(data->obj,
+ autocreate_list);
} else {
+ assert(!autocreate_list);
data->qiv = qobject_input_visitor_new(data->obj, strict);
}
g_assert(data->qiv);
return data->qiv;
}
-static GCC_FMT_ATTR(4, 5)
+static GCC_FMT_ATTR(5, 6)
Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
bool strict, bool autocast,
+ bool autocreate_list,
const char *json_string, ...)
{
Visitor *v;
@@ -70,6 +74,7 @@ Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
va_start(ap, json_string);
v = visitor_input_test_init_internal(data, strict, autocast,
+ autocreate_list,
json_string, &ap);
va_end(ap);
return v;
@@ -83,7 +88,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
va_list ap;
va_start(ap, json_string);
- v = visitor_input_test_init_internal(data, true, false,
+ v = visitor_input_test_init_internal(data, true, false, false,
json_string, &ap);
va_end(ap);
return v;
@@ -99,7 +104,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
- return visitor_input_test_init_internal(data, true, false,
+ return visitor_input_test_init_internal(data, true, false, false,
json_string, NULL);
}
@@ -139,7 +144,7 @@ static void test_visitor_in_int_autocast(TestInputVisitorData *data,
Error *err = NULL;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true,
+ v = visitor_input_test_init_full(data, true, true, false,
"%" PRId64, value);
visit_type_int(v, NULL, &res, &err);
error_free_or_abort(&err);
@@ -151,7 +156,7 @@ static void test_visitor_in_int_str_autocast(TestInputVisitorData *data,
int64_t res = 0, value = -42;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true,
+ v = visitor_input_test_init_full(data, true, true, false,
"\"-42\"");
visit_type_int(v, NULL, &res, &error_abort);
@@ -190,7 +195,7 @@ static void test_visitor_in_bool_autocast(TestInputVisitorData *data,
Error *err = NULL;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true, "true");
+ v = visitor_input_test_init_full(data, true, true, false, "true");
visit_type_bool(v, NULL, &res, &err);
error_free_or_abort(&err);
@@ -202,7 +207,7 @@ static void test_visitor_in_bool_str_autocast(TestInputVisitorData *data,
bool res = false;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true, "\"yes\"");
+ v = visitor_input_test_init_full(data, true, true, false, "\"yes\"");
visit_type_bool(v, NULL, &res, &error_abort);
g_assert_cmpint(res, ==, true);
@@ -240,7 +245,7 @@ static void test_visitor_in_number_autocast(TestInputVisitorData *data,
Error *err = NULL;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true, "%f", value);
+ v = visitor_input_test_init_full(data, true, true, false, "%f", value);
visit_type_number(v, NULL, &res, &err);
error_free_or_abort(&err);
@@ -252,7 +257,7 @@ static void test_visitor_in_number_str_autocast(TestInputVisitorData *data,
double res = 0, value = 3.14;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true, "\"3.14\"");
+ v = visitor_input_test_init_full(data, true, true, false, "\"3.14\"");
visit_type_number(v, NULL, &res, &error_abort);
g_assert_cmpfloat(res, ==, value);
@@ -277,7 +282,7 @@ static void test_visitor_in_size_str_autocast(TestInputVisitorData *data,
uint64_t res, value = 500 * 1024 * 1024;
Visitor *v;
- v = visitor_input_test_init_full(data, true, true, "\"500M\"");
+ v = visitor_input_test_init_full(data, true, true, false, "\"500M\"");
visit_type_size(v, NULL, &res, &error_abort);
g_assert_cmpfloat(res, ==, value);
@@ -396,6 +401,59 @@ static void test_visitor_in_list(TestInputVisitorData *data,
g_assert(!head);
}
+static void test_visitor_in_list_autocreate_none(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefOneList *head = NULL;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init_full(data, true, true, false,
+ "{ 'string': 'string0', 'integer': 42 }");
+
+ visit_type_UserDefOneList(v, NULL, &head, &err);
+ error_free_or_abort(&err);
+ g_assert(head == NULL);
+}
+
+static void test_visitor_in_list_autocreate_dict(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefOneList *head = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, true, true,
+ "{ 'string': 'string0', 'integer': '42' }");
+
+ visit_type_UserDefOneList(v, NULL, &head, &error_abort);
+ g_assert(head != NULL);
+
+ g_assert_cmpstr(head->value->string, ==, "string0");
+ g_assert_cmpint(head->value->integer, ==, 42);
+ g_assert(head->next == NULL);
+
+ qapi_free_UserDefOneList(head);
+ head = NULL;
+}
+
+static void test_visitor_in_list_autocreate_int(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint32List *head = NULL;
+ Visitor *v;
+
+ /* Verify that we auto-create a single element list from the int */
+ v = visitor_input_test_init_full(data, true, true, true, "'42'");
+
+ visit_type_uint32List(v, NULL, &head, &error_abort);
+ g_assert(head != NULL);
+
+ g_assert_cmpint(head->value, ==, 42);
+
+ qapi_free_uint32List(head);
+ head = NULL;
+}
+
static void test_visitor_in_any(TestInputVisitorData *data,
const void *unused)
{
@@ -452,7 +510,7 @@ static void test_visitor_in_null(TestInputVisitorData *data,
* when input is not null.
*/
- v = visitor_input_test_init_full(data, false, false,
+ v = visitor_input_test_init_full(data, false, false, false,
"{ 'a': null, 'b': '' }");
visit_start_struct(v, NULL, NULL, 0, &error_abort);
visit_type_null(v, "a", &error_abort);
@@ -1040,6 +1098,12 @@ int main(int argc, char **argv)
NULL, test_visitor_in_struct_nested);
input_visitor_test_add("/visitor/input/list",
NULL, test_visitor_in_list);
+ input_visitor_test_add("/visitor/input/list-autocreate-noautocast",
+ NULL, test_visitor_in_list_autocreate_none);
+ input_visitor_test_add("/visitor/input/list-autocreate-autocast",
+ NULL, test_visitor_in_list_autocreate_dict);
+ input_visitor_test_add("/visitor/input/list-autocreate-int",
+ NULL, test_visitor_in_list_autocreate_int);
input_visitor_test_add("/visitor/input/any",
NULL, test_visitor_in_any);
input_visitor_test_add("/visitor/input/null",
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 10/19] qapi: permit auto-creating nested structs
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (8 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 09/19] qapi: permit auto-creating single element lists Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 11/19] qapi: add integer range support for QObjectInputVisitor Daniel P. Berrange
` (9 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Some of the historical command line opts that had their
keys in in a completely flat namespace are now represented
by QAPI schemas that use a nested structs. When converting
the QemuOpts to QObject, there is no information about
compound types available, so the QObject will be completely
flat, even after the qdict_crumple() call. So when starting
a struct, we may not have a QDict available in the input
data, so we auto-create a QDict containing all the currently
unvisited input data keys. Not all historical command line
opts require this, so the behaviour is opt-in, by specifying
how many levels of structs are permitted to be auto-created.
Note that this only works if the child struct is the last
field to the visited in the parent struct. This is always
the case for currently existing legacy command line options.
The example is the NetLegacy type which has 3 levels of
structs. The modern way to represent this in QemuOpts would
be the dot-separated component approach
-net vlan=1,id=foo,name=bar,opts.type=tap,\
opts.data.fd=3,opts.data.script=ifup
The legacy syntax will just be presenting
-net vlan=1,id=foo,name=bar,type=tap,fd=3,script=ifup
So we need to auto-create 3 levels of struct when visiting.
The implementation here will enable visiting in both the
modern and legacy syntax, compared to OptsVisitor which
only allows the legacy syntax.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qobject-input-visitor.h | 21 +++++-
qapi/qobject-input-visitor.c | 55 +++++++++++++--
tests/test-qobject-input-visitor.c | 130 ++++++++++++++++++++++++++++++++---
3 files changed, 190 insertions(+), 16 deletions(-)
diff --git a/include/qapi/qobject-input-visitor.h b/include/qapi/qobject-input-visitor.h
index fb52457..90989f4 100644
--- a/include/qapi/qobject-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -45,7 +45,7 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
* If @autocreate_list is true, then as an alternative to a normal QList,
* list values can be stored as a QString or QDict instead, which will
* be interpreted as representing single element lists. This should only
- * by used if compatibility is required with the OptsVisitor which allowed
+ * be used if compatibility is required with the OptsVisitor which allowed
* repeated keys, without list indexes, to represent lists. e.g. set this
* to true if you have compatibility requirements for
*
@@ -55,6 +55,22 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
*
* -arg foo.0=hello,foo.1=world
*
+ * If @autocreate_struct_levels is non-zero, then when visiting structs,
+ * if the corresponding QDict is not found, it will automatically create
+ * a QDict containing all remaining unvisited options. This should only
+ * be used if compatibility is required with the OptsVisitor which flatten
+ * structs so that all keys were at the same level. e.g. set this to a
+ * non-zero number if you compatibility requirements for
+ *
+ * -arg type=person,surname=blogs,forename=fred
+ *
+ * to be treated as equivalent to the perferred syntax
+ *
+ * -arg type=person,data.surname=blogs,data.forename=fred
+ *
+ * The value given determines how many levels of structs are allowed to
+ * be flattened in this way.
+ *
* The visitor always operates in strict mode, requiring all dict keys
* to be consumed during visitation. An error will be reported if this
* does not happen.
@@ -63,6 +79,7 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
* visit_free() when no longer required.
*/
Visitor *qobject_input_visitor_new_autocast(QObject *obj,
- bool autocreate_list);
+ bool autocreate_list,
+ size_t autocreate_struct_levels);
#endif
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index e8afd1e..6cacd4b 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -52,6 +52,14 @@ struct QObjectInputVisitor
/* Whether we can auto-create single element lists when
* encountering a non-QList type */
bool autocreate_list;
+
+ /* Current depth of recursion into structs */
+ size_t struct_level;
+
+ /* Numbers of levels at which we will
+ * consider auto-creating a struct containing
+ * remaining unvisited items */
+ size_t autocreate_struct_levels;
};
static QObjectInputVisitor *to_qiv(Visitor *v)
@@ -79,7 +87,12 @@ static QObject *qobject_input_get_object(QObjectInputVisitor *qiv,
if (qobject_type(qobj) == QTYPE_QDICT) {
assert(name);
- ret = qdict_get(qobject_to_qdict(qobj), name);
+ if (qiv->autocreate_struct_levels &&
+ !g_hash_table_contains(tos->h, name)) {
+ ret = NULL;
+ } else {
+ ret = qdict_get(qobject_to_qdict(qobj), name);
+ }
if (tos->h && consume && ret) {
bool removed = g_hash_table_remove(tos->h, name);
assert(removed);
@@ -114,7 +127,8 @@ static const QListEntry *qobject_input_push(QObjectInputVisitor *qiv,
tos->qapi = qapi;
qobject_incref(obj);
- if (qiv->strict && qobject_type(obj) == QTYPE_QDICT) {
+ if ((qiv->autocreate_struct_levels || qiv->strict) &&
+ qobject_type(obj) == QTYPE_QDICT) {
h = g_hash_table_new(g_str_hash, g_str_equal);
qdict_iter(qobject_to_qdict(obj), qdict_add_key, h);
tos->h = h;
@@ -163,6 +177,9 @@ static void qobject_input_pop(Visitor *v, void **obj)
StackObject *tos = QSLIST_FIRST(&qiv->stack);
assert(tos && tos->qapi == obj);
+ if (tos->h != NULL) {
+ qiv->struct_level--;
+ }
QSLIST_REMOVE_HEAD(&qiv->stack, node);
qobject_input_stack_object_free(tos);
}
@@ -171,12 +188,38 @@ static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
size_t size, Error **errp)
{
QObjectInputVisitor *qiv = to_qiv(v);
- QObject *qobj = qobject_input_get_object(qiv, name, true);
+ QObject *qobj;
+ QDict *subopts = NULL;
Error *err = NULL;
+ StackObject *tos = QSLIST_FIRST(&qiv->stack);
+ qobj = qobject_input_get_object(qiv, name, true);
if (obj) {
*obj = NULL;
}
+
+ if (!qobj && (qiv->struct_level < qiv->autocreate_struct_levels)) {
+ /* Create a new dict that contains all the currently
+ * unvisited items */
+ if (tos) {
+ GHashTableIter iter;
+ const char *key;
+
+ subopts = qdict_new();
+
+ g_hash_table_iter_init(&iter, tos->h);
+ while (g_hash_table_iter_next(&iter, (void **)&key, NULL)) {
+ QObject *val = qdict_get(qobject_to_qdict(tos->obj), key);
+ qobject_incref(val);
+ qdict_put_obj(subopts, key, val);
+ }
+ g_hash_table_remove_all(tos->h);
+ qobj = QOBJECT(subopts);
+ } else {
+ qobj = qiv->root;
+ }
+ }
+
if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"QDict");
@@ -184,6 +227,7 @@ static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
}
qobject_input_push(qiv, qobj, obj, &err);
+ qiv->struct_level++;
if (err) {
error_propagate(errp, err);
return;
@@ -192,6 +236,7 @@ static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
if (obj) {
*obj = g_malloc0(size);
}
+ QDECREF(subopts);
}
@@ -530,7 +575,8 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict)
}
Visitor *qobject_input_visitor_new_autocast(QObject *obj,
- bool autocreate_list)
+ bool autocreate_list,
+ size_t autocreate_struct_levels)
{
QObjectInputVisitor *v;
@@ -556,6 +602,7 @@ Visitor *qobject_input_visitor_new_autocast(QObject *obj,
v->visitor.free = qobject_input_free;
v->strict = true;
v->autocreate_list = autocreate_list;
+ v->autocreate_struct_levels = autocreate_struct_levels;
v->root = obj;
qobject_incref(obj);
diff --git a/tests/test-qobject-input-visitor.c b/tests/test-qobject-input-visitor.c
index c227565..ab55f99 100644
--- a/tests/test-qobject-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -40,11 +40,13 @@ static void visitor_input_teardown(TestInputVisitorData *data,
/* The various test_init functions are provided instead of a test setup
function so that the JSON string used by the tests are kept in the test
functions (and not in main()). */
-static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
- bool strict, bool autocast,
- bool autocreate_list,
- const char *json_string,
- va_list *ap)
+static Visitor *
+visitor_input_test_init_internal(TestInputVisitorData *data,
+ bool strict, bool autocast,
+ bool autocreate_list,
+ size_t autocreate_struct_levels,
+ const char *json_string,
+ va_list *ap)
{
visitor_input_teardown(data, NULL);
@@ -53,10 +55,11 @@ static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
if (autocast) {
assert(strict);
- data->qiv = qobject_input_visitor_new_autocast(data->obj,
- autocreate_list);
+ data->qiv = qobject_input_visitor_new_autocast(
+ data->obj, autocreate_list, autocreate_struct_levels);
} else {
assert(!autocreate_list);
+ assert(!autocreate_struct_levels);
data->qiv = qobject_input_visitor_new(data->obj, strict);
}
g_assert(data->qiv);
@@ -74,7 +77,7 @@ Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
va_start(ap, json_string);
v = visitor_input_test_init_internal(data, strict, autocast,
- autocreate_list,
+ autocreate_list, 0,
json_string, &ap);
va_end(ap);
return v;
@@ -88,7 +91,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
va_list ap;
va_start(ap, json_string);
- v = visitor_input_test_init_internal(data, true, false, false,
+ v = visitor_input_test_init_internal(data, true, false, false, 0,
json_string, &ap);
va_end(ap);
return v;
@@ -104,7 +107,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
- return visitor_input_test_init_internal(data, true, false, false,
+ return visitor_input_test_init_internal(data, true, false, false, 0,
json_string, NULL);
}
@@ -372,6 +375,109 @@ static void test_visitor_in_struct_nested(TestInputVisitorData *data,
qapi_free_UserDefTwo(udp);
}
+static void test_visitor_in_struct_autocreate(TestInputVisitorData *data,
+ const void *unused)
+{
+ Visitor *v;
+ int64_t vlan;
+ char *id = NULL;
+ char *type;
+ int64_t fd;
+ char *script = NULL;
+
+ v = visitor_input_test_init_internal(
+ data, true, true, false, 3,
+ "{ 'vlan': '1', 'id': 'foo', 'type': 'tap', 'fd': '3', "
+ "'script': 'ifup' }", NULL);
+
+ visit_start_struct(v, NULL, NULL, 0, &error_abort);
+
+ visit_type_int64(v, "vlan", &vlan, &error_abort);
+ visit_type_str(v, "id", &id, &error_abort);
+
+ visit_start_struct(v, "opts", NULL, 0, &error_abort);
+ visit_type_str(v, "type", &type, &error_abort);
+
+ visit_start_struct(v, "data", NULL, 0, &error_abort);
+
+ visit_type_int64(v, "fd", &fd, &error_abort);
+ visit_type_str(v, "script", &script, &error_abort);
+
+ visit_check_struct(v, &error_abort);
+ visit_end_struct(v, NULL);
+
+ visit_check_struct(v, &error_abort);
+ visit_end_struct(v, NULL);
+
+ visit_check_struct(v, &error_abort);
+ visit_end_struct(v, NULL);
+
+ g_assert_cmpstr(id, ==, "foo");
+ g_assert_cmpint(vlan, ==, 1);
+ g_assert_cmpstr(type, ==, "tap");
+ g_assert_cmpstr(script, ==, "ifup");
+ g_assert_cmpint(fd, ==, 3);
+
+ g_free(id);
+ g_free(type);
+ g_free(script);
+}
+
+static void test_visitor_in_struct_autocreate_extra(TestInputVisitorData *data,
+ const void *unused)
+{
+ Visitor *v;
+ int64_t vlan;
+ char *id = NULL;
+ char *type;
+ int64_t fd;
+ char *script = NULL;
+ Error *err = NULL;
+
+ v = visitor_input_test_init_internal(
+ data, true, true, false, 3,
+ "{ 'vlan': '1', 'id': 'foo', 'type': 'tap', 'fd': '3', "
+ "'script': 'ifup' }", NULL);
+
+ visit_start_struct(v, NULL, NULL, 0, &error_abort);
+
+ visit_type_int64(v, "vlan", &vlan, &error_abort);
+
+ visit_start_struct(v, "opts", NULL, 0, &error_abort);
+ visit_type_str(v, "type", &type, &error_abort);
+
+ visit_start_struct(v, "data", NULL, 0, &error_abort);
+
+ visit_type_int64(v, "fd", &fd, &error_abort);
+ visit_type_str(v, "script", &script, &error_abort);
+
+ /* We've not visited 'id' so should see a complaint */
+ visit_check_struct(v, &err);
+ error_free_or_abort(&err);
+ visit_end_struct(v, NULL);
+
+ visit_check_struct(v, &error_abort);
+ visit_end_struct(v, NULL);
+
+ /* We can't visit stuff in the base struct after
+ * we auto-created child structs */
+ visit_type_str(v, "id", &id, &err);
+ error_free_or_abort(&err);
+
+ visit_check_struct(v, &error_abort);
+ visit_end_struct(v, NULL);
+
+ g_assert_cmpstr(id, ==, NULL);
+ g_assert_cmpint(vlan, ==, 1);
+ g_assert_cmpstr(type, ==, "tap");
+ g_assert_cmpstr(script, ==, "ifup");
+ g_assert_cmpint(fd, ==, 3);
+
+ g_free(id);
+ g_free(type);
+ g_free(script);
+}
+
static void test_visitor_in_list(TestInputVisitorData *data,
const void *unused)
{
@@ -1096,6 +1202,10 @@ int main(int argc, char **argv)
NULL, test_visitor_in_struct);
input_visitor_test_add("/visitor/input/struct-nested",
NULL, test_visitor_in_struct_nested);
+ input_visitor_test_add("/visitor/input/struct-autocreate",
+ NULL, test_visitor_in_struct_autocreate);
+ input_visitor_test_add("/visitor/input/struct-autocreate-extra",
+ NULL, test_visitor_in_struct_autocreate_extra);
input_visitor_test_add("/visitor/input/list",
NULL, test_visitor_in_list);
input_visitor_test_add("/visitor/input/list-autocreate-noautocast",
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 11/19] qapi: add integer range support for QObjectInputVisitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (9 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 10/19] qapi: permit auto-creating nested structs Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 12/19] qapi: allow QObjectInputVisitor to be created with QemuOpts Daniel P. Berrange
` (8 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The traditional CLI arg syntax allows two ways to specify
integer lists, either one value per key, or a range of
values per key. eg the following are identical:
-arg foo=5,foo=6,foo=7
-arg foo=5-7
This extends the QObjectInputVisitor so that it is able
to parse ranges and turn them into distinct list entries.
This means that
-arg foo=5-7
is treated as equivalent to
-arg foo.0=5,foo.1=6,foo.2=7
Edge case tests are copied from test-opts-visitor to
ensure identical behaviour when parsing.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qobject-input-visitor.h | 22 +++-
qapi/qobject-input-visitor.c | 154 +++++++++++++++++++++++++--
tests/test-qobject-input-visitor.c | 195 +++++++++++++++++++++++++++++++++--
3 files changed, 356 insertions(+), 15 deletions(-)
diff --git a/include/qapi/qobject-input-visitor.h b/include/qapi/qobject-input-visitor.h
index 90989f4..63f3782 100644
--- a/include/qapi/qobject-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -19,6 +19,12 @@
typedef struct QObjectInputVisitor QObjectInputVisitor;
+/* Inclusive upper bound on the size of any flattened range. This is a safety
+ * (= anti-annoyance) measure; wrong ranges should not cause long startup
+ * delays nor exhaust virtual memory.
+ */
+#define QIV_RANGE_MAX 65536
+
/**
* Create a new input visitor that converts @obj to a QAPI object.
*
@@ -71,6 +77,19 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
* The value given determines how many levels of structs are allowed to
* be flattened in this way.
*
+ * If @permit_int_ranges is true, then when visiting a list of integers,
+ * the integer value strings may encode ranges eg a single element
+ * containing "5-7" is treated as if there were three elements "5", "6",
+ * "7". This should only be used if compatibility is required with the
+ * OptsVisitor which would allow integer ranges. e.g. set this to true
+ * if you have compatibility requirements for
+ *
+ * -arg val=5-8
+ *
+ * to be treated as equivalent to the preferred syntax:
+ *
+ * -arg val.0=5,val.1=6,val.2=7,val.3=8
+ *
* The visitor always operates in strict mode, requiring all dict keys
* to be consumed during visitation. An error will be reported if this
* does not happen.
@@ -80,6 +99,7 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict);
*/
Visitor *qobject_input_visitor_new_autocast(QObject *obj,
bool autocreate_list,
- size_t autocreate_struct_levels);
+ size_t autocreate_struct_levels,
+ bool permit_int_ranges);
#endif
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index 6cacd4b..a38e779 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -31,6 +31,8 @@ typedef struct StackObject
GHashTable *h; /* If obj is dict: unvisited keys */
const QListEntry *entry; /* If obj is list: unvisited tail */
+ uint64_t range_val;
+ uint64_t range_limit;
QSLIST_ENTRY(StackObject) node;
} StackObject;
@@ -60,6 +62,10 @@ struct QObjectInputVisitor
* consider auto-creating a struct containing
* remaining unvisited items */
size_t autocreate_struct_levels;
+
+ /* Whether int lists can have single values representing
+ * ranges of values */
+ bool permit_int_ranges;
};
static QObjectInputVisitor *to_qiv(Visitor *v)
@@ -282,7 +288,7 @@ static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail,
QObjectInputVisitor *qiv = to_qiv(v);
StackObject *so = QSLIST_FIRST(&qiv->stack);
- if (!so->entry) {
+ if ((so->range_val == so->range_limit) && !so->entry) {
return NULL;
}
tail->next = g_malloc0(size);
@@ -329,21 +335,87 @@ static void qobject_input_type_int64_autocast(Visitor *v, const char *name,
int64_t *obj, Error **errp)
{
QObjectInputVisitor *qiv = to_qiv(v);
- QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
- true));
+ QString *qstr;
int64_t ret;
+ const char *end = NULL;
+ StackObject *tos;
+ bool inlist = false;
+
+ /* Preferentially generate values from a range, before
+ * trying to consume another QList element */
+ tos = QSLIST_FIRST(&qiv->stack);
+ if (tos) {
+ if ((int64_t)tos->range_val < (int64_t)tos->range_limit) {
+ *obj = tos->range_val + 1;
+ tos->range_val++;
+ return;
+ } else {
+ inlist = tos->entry != NULL;
+ }
+ }
+ qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
if (!qstr || !qstr->string) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"string");
return;
}
- if (qemu_strtoll(qstr->string, NULL, 0, &ret) < 0) {
+ if (qemu_strtoll(qstr->string, &end, 0, &ret) < 0) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
return;
}
*obj = ret;
+
+ /*
+ * If we have string that represents an integer range (5-24),
+ * parse the end of the range and set things up so we'll process
+ * the rest of the range before consuming another element
+ * from the QList.
+ */
+ if (end && *end) {
+ if (!qiv->permit_int_ranges) {
+ error_setg(errp,
+ "Integer ranges are not permitted here");
+ return;
+ }
+ if (!inlist) {
+ error_setg(errp,
+ "Integer ranges are only permitted when "
+ "visiting list parameters");
+ return;
+ }
+ if (*end != '-') {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
+ "a number range");
+ return;
+ }
+ end++;
+ if (qemu_strtoll(end, NULL, 0, &ret) < 0) {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
+ return;
+ }
+ if (*obj > ret) {
+ error_setg(errp,
+ "Parameter '%s' range start %" PRIu64
+ " must be less than (or equal to) %" PRIu64,
+ name, *obj, ret);
+ return;
+ }
+
+ if ((*obj <= (INT64_MAX - QIV_RANGE_MAX)) &&
+ (ret >= (*obj + QIV_RANGE_MAX))) {
+ error_setg(errp,
+ "Parameter '%s' range must be less than %d",
+ name, QIV_RANGE_MAX);
+ return;
+ }
+ if (*obj != ret) {
+ tos->range_val = *obj;
+ tos->range_limit = ret;
+ }
+ }
}
static void qobject_input_type_uint64(Visitor *v, const char *name,
@@ -366,21 +438,85 @@ static void qobject_input_type_uint64_autocast(Visitor *v, const char *name,
uint64_t *obj, Error **errp)
{
QObjectInputVisitor *qiv = to_qiv(v);
- QString *qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
- true));
+ QString *qstr;
unsigned long long ret;
+ char *end = NULL;
+ StackObject *tos;
+ bool inlist = false;
+
+ /* Preferentially generate values from a range, before
+ * trying to consume another QList element */
+ tos = QSLIST_FIRST(&qiv->stack);
+ if (tos) {
+ if (tos->range_val < tos->range_limit) {
+ *obj = tos->range_val + 1;
+ tos->range_val++;
+ return;
+ } else {
+ inlist = tos->entry != NULL;
+ }
+ }
+ qstr = qobject_to_qstring(qobject_input_get_object(qiv, name,
+ true));
if (!qstr || !qstr->string) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"string");
return;
}
- if (parse_uint_full(qstr->string, &ret, 0) < 0) {
+ if (parse_uint(qstr->string, &ret, &end, 0) < 0) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
return;
}
*obj = ret;
+
+ /*
+ * If we have string that represents an integer range (5-24),
+ * parse the end of the range and set things up so we'll process
+ * the rest of the range before consuming another element
+ * from the QList.
+ */
+ if (end && *end) {
+ if (!qiv->permit_int_ranges) {
+ error_setg(errp,
+ "Integer ranges are not permitted here");
+ return;
+ }
+ if (!inlist) {
+ error_setg(errp,
+ "Integer ranges are only permitted when "
+ "visiting list parameters");
+ return;
+ }
+ if (*end != '-') {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name,
+ "a number range");
+ return;
+ }
+ end++;
+ if (parse_uint_full(end, &ret, 0) < 0) {
+ error_setg(errp, QERR_INVALID_PARAMETER_VALUE, name, "a number");
+ return;
+ }
+ if (*obj > ret) {
+ error_setg(errp,
+ "Parameter '%s' range start %" PRIu64
+ " must be less than (or equal to) %llu",
+ name, *obj, ret);
+ return;
+ }
+ if ((ret - *obj) > (QIV_RANGE_MAX - 1)) {
+ error_setg(errp,
+ "Parameter '%s' range must be less than %d",
+ name, QIV_RANGE_MAX);
+ return;
+ }
+ if (*obj != ret) {
+ tos->range_val = *obj;
+ tos->range_limit = ret;
+ }
+ }
}
static void qobject_input_type_bool(Visitor *v, const char *name, bool *obj,
@@ -576,7 +712,8 @@ Visitor *qobject_input_visitor_new(QObject *obj, bool strict)
Visitor *qobject_input_visitor_new_autocast(QObject *obj,
bool autocreate_list,
- size_t autocreate_struct_levels)
+ size_t autocreate_struct_levels,
+ bool permit_int_ranges)
{
QObjectInputVisitor *v;
@@ -603,6 +740,7 @@ Visitor *qobject_input_visitor_new_autocast(QObject *obj,
v->strict = true;
v->autocreate_list = autocreate_list;
v->autocreate_struct_levels = autocreate_struct_levels;
+ v->permit_int_ranges = permit_int_ranges;
v->root = obj;
qobject_incref(obj);
diff --git a/tests/test-qobject-input-visitor.c b/tests/test-qobject-input-visitor.c
index ab55f99..783ecd4 100644
--- a/tests/test-qobject-input-visitor.c
+++ b/tests/test-qobject-input-visitor.c
@@ -45,6 +45,7 @@ visitor_input_test_init_internal(TestInputVisitorData *data,
bool strict, bool autocast,
bool autocreate_list,
size_t autocreate_struct_levels,
+ bool permit_int_ranges,
const char *json_string,
va_list *ap)
{
@@ -56,10 +57,12 @@ visitor_input_test_init_internal(TestInputVisitorData *data,
if (autocast) {
assert(strict);
data->qiv = qobject_input_visitor_new_autocast(
- data->obj, autocreate_list, autocreate_struct_levels);
+ data->obj, autocreate_list, autocreate_struct_levels,
+ permit_int_ranges);
} else {
assert(!autocreate_list);
assert(!autocreate_struct_levels);
+ assert(!permit_int_ranges);
data->qiv = qobject_input_visitor_new(data->obj, strict);
}
g_assert(data->qiv);
@@ -77,7 +80,7 @@ Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
va_start(ap, json_string);
v = visitor_input_test_init_internal(data, strict, autocast,
- autocreate_list, 0,
+ autocreate_list, 0, false,
json_string, &ap);
va_end(ap);
return v;
@@ -91,7 +94,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
va_list ap;
va_start(ap, json_string);
- v = visitor_input_test_init_internal(data, true, false, false, 0,
+ v = visitor_input_test_init_internal(data, true, false, false, 0, false,
json_string, &ap);
va_end(ap);
return v;
@@ -107,7 +110,7 @@ Visitor *visitor_input_test_init(TestInputVisitorData *data,
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
- return visitor_input_test_init_internal(data, true, false, false, 0,
+ return visitor_input_test_init_internal(data, true, false, false, 0, false,
json_string, NULL);
}
@@ -386,7 +389,7 @@ static void test_visitor_in_struct_autocreate(TestInputVisitorData *data,
char *script = NULL;
v = visitor_input_test_init_internal(
- data, true, true, false, 3,
+ data, true, true, false, 3, false,
"{ 'vlan': '1', 'id': 'foo', 'type': 'tap', 'fd': '3', "
"'script': 'ifup' }", NULL);
@@ -435,7 +438,7 @@ static void test_visitor_in_struct_autocreate_extra(TestInputVisitorData *data,
Error *err = NULL;
v = visitor_input_test_init_internal(
- data, true, true, false, 3,
+ data, true, true, false, 3, false,
"{ 'vlan': '1', 'id': 'foo', 'type': 'tap', 'fd': '3', "
"'script': 'ifup' }", NULL);
@@ -560,6 +563,88 @@ static void test_visitor_in_list_autocreate_int(TestInputVisitorData *data,
head = NULL;
}
+typedef struct {
+ const char *range_str;
+ bool expect_fail;
+ int64_t *values;
+ size_t nvalues;
+} TestIntRangeData;
+
+static void test_visitor_in_list_autocast_int_range(TestInputVisitorData *data,
+ const void *opaque)
+{
+ const TestIntRangeData *idata = opaque;
+ int64List *item, *head = NULL;
+ Visitor *v;
+ size_t i;
+ Error *err = NULL;
+
+ /* Verify that we auto-expand signed int ranges */
+ v = visitor_input_test_init_internal(data, true, true, true, 0, true,
+ idata->range_str, NULL);
+
+ visit_type_int64List(v, NULL, &head, &err);
+ if (idata->expect_fail) {
+ error_free_or_abort(&err);
+ g_assert(head == NULL);
+ } else {
+ g_assert(err == NULL);
+ g_assert(head != NULL);
+ for (i = 0, item = head; item != NULL && i < idata->nvalues;
+ item = item->next, i++) {
+ if (idata->values != NULL) {
+ g_assert_cmpint(item->value, ==, idata->values[i]);
+ }
+ }
+ g_assert_cmpint(i, ==, idata->nvalues);
+
+ qapi_free_int64List(head);
+ head = NULL;
+ }
+}
+
+typedef struct {
+ const char *range_str;
+ bool expect_fail;
+ uint64_t *values;
+ size_t nvalues;
+} TestUIntRangeData;
+
+static void test_visitor_in_list_autocast_uint_range(TestInputVisitorData *data,
+ const void *opaque)
+{
+ const TestUIntRangeData *idata = opaque;
+ uint64List *item, *head = NULL;
+ Visitor *v;
+ size_t i;
+ Error *err = NULL;
+
+ /* Verify that we auto-expand signed int ranges */
+ v = visitor_input_test_init_internal(data, true, true, true, 0, true,
+ idata->range_str, NULL);
+
+ visit_type_uint64List(v, NULL, &head, &err);
+ if (idata->expect_fail) {
+ g_assert(err != NULL);
+ g_assert(head == NULL);
+ } else {
+ g_assert(err == NULL);
+ g_assert(head != NULL);
+
+ for (i = 0, item = head; item != NULL && i < idata->nvalues;
+ item = item->next, i++) {
+ if (idata->values != NULL) {
+ g_assert_cmpint(item->value, ==, idata->values[i]);
+ }
+ }
+ g_assert_cmpint(i, ==, idata->nvalues);
+
+ qapi_free_uint64List(head);
+ head = NULL;
+ }
+}
+
+
static void test_visitor_in_any(TestInputVisitorData *data,
const void *unused)
{
@@ -1253,6 +1338,104 @@ int main(int argc, char **argv)
input_visitor_test_add("/visitor/input/native_list/number",
NULL, test_visitor_in_native_list_number);
+#define INT_RANGE_TEST(suffix, str, expect_fail, values, nvalues) \
+ TestIntRangeData idata ## suffix = \
+ { str, expect_fail, values, nvalues }; \
+ input_visitor_test_add("/visitor/input/int-list-autocast-" #suffix, \
+ &idata ## suffix, \
+ test_visitor_in_list_autocast_int_range)
+
+#define UINT_RANGE_TEST(suffix, str, expect_fail, values, nvalues) \
+ TestUIntRangeData udata ## suffix = \
+ { str, expect_fail, values, nvalues }; \
+ input_visitor_test_add("/visitor/input/uint-list-autocast-" #suffix,\
+ &udata ## suffix, \
+ test_visitor_in_list_autocast_uint_range)
+
+
+ int64_t multvals[] = { -1, 0, -11, -10, -9, 5, -16, -15, -14, -13, 14,
+ 15, 7, 2, 3, 9, 10, 11, 12, -7, -6, -5, -4, -3 };
+ INT_RANGE_TEST(multiple,
+ "['-1-0','-11--9','5-5'," \
+ "'-16--13','14-15'," \
+ "'7','2-3','9-12','-7--3']",
+ false, multvals, G_N_ELEMENTS(multvals));
+
+ INT_RANGE_TEST(errno,
+ "'0x7fffffffffffffff-0x8000000000000000'",
+ true, NULL, 0);
+ INT_RANGE_TEST(incomplete, "'5-'",
+ true, NULL, 0);
+ INT_RANGE_TEST(trailing, "'5-6z'",
+ true, NULL, 0);
+ INT_RANGE_TEST(empty, "\"6-5\"",
+ true, NULL, 0);
+ int64_t negvals[] = { -10, -9, -8, -7 };
+ INT_RANGE_TEST(neg, "\"-10--7\"",
+ false, negvals, G_N_ELEMENTS(negvals));
+ INT_RANGE_TEST(minval,
+ "'-0x8000000000000000--0x8000000000000000'",
+ false, (int64_t[]){ -0x8000000000000000 }, 1);
+ INT_RANGE_TEST(maxval,
+ "'0x7fffffffffffffff-0x7fffffffffffffff'",
+ false, (int64_t[]){ 0x7fffffffffffffff }, 1);
+
+ UINT_RANGE_TEST(errno,
+ "'0xffffffffffffffff-0x10000000000000000'",
+ true, NULL, 0);
+ UINT_RANGE_TEST(incomplete, "'5-'",
+ true, NULL, 0);
+ UINT_RANGE_TEST(trailing, "'5-6z'",
+ true, NULL, 0);
+ UINT_RANGE_TEST(empty, "'6-5'",
+ true, NULL, 0);
+ UINT_RANGE_TEST(neg, "\"-10--7\"",
+ true, NULL, 0);
+ UINT_RANGE_TEST(minval, "'0-0'",
+ false, (uint64_t[]){ 0 }, 1);
+ UINT_RANGE_TEST(maxval,
+ "'0xffffffffffffffff-0xffffffffffffffff'",
+ false, (uint64_t[]){ 0xffffffffffffffff }, 1);
+
+ /* Test maximum range sizes. The macro value is open-coded here
+ * *intentionally*; the test case must use concrete values by design. If
+ * QIV_RANGE_MAX is changed, the following values need to be
+ * recalculated as well. The assert and this comment should help with it.
+ */
+ g_assert(QIV_RANGE_MAX == 65536);
+
+ /* The unsigned case is simple, a u64-u64 difference can always be
+ * represented as a u64.
+ */
+ UINT_RANGE_TEST(max,
+ "'0-65535'",
+ false, NULL, QIV_RANGE_MAX);
+ UINT_RANGE_TEST(2big,
+ "'0-65536'",
+ true, NULL, 0);
+
+ INT_RANGE_TEST(max_pos_a,
+ "'0x7fffffffffff0000-0x7fffffffffffffff'",
+ false, NULL, 100);
+ INT_RANGE_TEST(max_pos_b,
+ "'0x7ffffffffffeffff-0x7ffffffffffffffe'",
+ false, NULL, 100);
+ INT_RANGE_TEST(max_neg_a,
+ "'-0x8000000000000000--0x7fffffffffff0001'",
+ false, NULL, 100);
+ INT_RANGE_TEST(max_neg_b,
+ "'-0x7fffffffffffffff--0x7fffffffffff0000'",
+ false, NULL, 100);
+ INT_RANGE_TEST(2big_pos,
+ "'0x7ffffffffffeffff-0x7fffffffffffffff'",
+ true, NULL, 0);
+ INT_RANGE_TEST(2big_neg,
+ "'-0x8000000000000000--0x7fffffffffff0000'",
+ true, NULL, 0);
+ INT_RANGE_TEST(2big_neg_pos,
+ "'-0x8000000000000000-0x7fffffffffffffff'",
+ true, NULL, 0);
+
g_test_run();
return 0;
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 12/19] qapi: allow QObjectInputVisitor to be created with QemuOpts
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (10 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 11/19] qapi: add integer range support for QObjectInputVisitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 13/19] qom: support non-scalar properties with -object Daniel P. Berrange
` (7 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Instead of requiring all callers to go through the mutli-step
process of turning QemuOpts into a suitable QObject for visiting,
add a new constructor that encapsulates this logic. This will
allow QObjectInputVisitor to be a drop-in replacement for the
existing OptsVisitor with minimal code changes for callers.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/qobject-input-visitor.h | 19 +++++++++++++++++++
include/qemu/option.h | 2 +-
qapi/qobject-input-visitor.c | 29 +++++++++++++++++++++++++++++
util/qemu-option.c | 2 +-
4 files changed, 50 insertions(+), 2 deletions(-)
diff --git a/include/qapi/qobject-input-visitor.h b/include/qapi/qobject-input-visitor.h
index 63f3782..242b767 100644
--- a/include/qapi/qobject-input-visitor.h
+++ b/include/qapi/qobject-input-visitor.h
@@ -102,4 +102,23 @@ Visitor *qobject_input_visitor_new_autocast(QObject *obj,
size_t autocreate_struct_levels,
bool permit_int_ranges);
+
+/**
+ * Create a new input visitor that converts @opts to a QAPI object.
+ *
+ * The QemuOpts will be converted into a QObject using the
+ * qdict_crumple() method to automatically create structs
+ * and lists. The resulting QDict will then be passed to the
+ * qobject_input_visitor_new_autocast() method. See the docs
+ * of that method for further details on processing behaviour.
+ *
+ * The returned input visitor should be released by calling
+ * visit_free() when no longer required.
+ */
+Visitor *qobject_input_visitor_new_opts(const QemuOpts *opts,
+ bool autocreate_list,
+ size_t autocreate_struct_levels,
+ bool permit_int_ranges,
+ Error **errp);
+
#endif
diff --git a/include/qemu/option.h b/include/qemu/option.h
index 328c468..bf1f078 100644
--- a/include/qemu/option.h
+++ b/include/qemu/option.h
@@ -130,7 +130,7 @@ typedef enum {
QEMU_OPTS_REPEAT_POLICY_LIST,
} QemuOptsRepeatPolicy;
-QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict,
+QDict *qemu_opts_to_qdict(const QemuOpts *opts, QDict *qdict,
QemuOptsRepeatPolicy repeatPolicy);
void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp);
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index a38e779..0aef20e 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -747,3 +747,32 @@ Visitor *qobject_input_visitor_new_autocast(QObject *obj,
return &v->visitor;
}
+
+
+Visitor *qobject_input_visitor_new_opts(const QemuOpts *opts,
+ bool autocreate_list,
+ size_t autocreate_struct_levels,
+ bool permit_int_ranges,
+ Error **errp)
+{
+ QDict *pdict;
+ QObject *pobj;
+ Visitor *v = NULL;
+
+ pdict = qemu_opts_to_qdict(opts, NULL,
+ QEMU_OPTS_REPEAT_POLICY_LIST);
+
+ pobj = qdict_crumple(pdict, true, errp);
+ if (!pobj) {
+ goto cleanup;
+ }
+
+ v = qobject_input_visitor_new_autocast(pobj,
+ autocreate_list,
+ autocreate_struct_levels,
+ permit_int_ranges);
+ cleanup:
+ qobject_decref(pobj);
+ QDECREF(pdict);
+ return v;
+}
diff --git a/util/qemu-option.c b/util/qemu-option.c
index ad28d4e..db0fef2 100644
--- a/util/qemu-option.c
+++ b/util/qemu-option.c
@@ -1058,7 +1058,7 @@ void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
* TODO We'll want to use types appropriate for opt->desc->type, but
* this is enough for now.
*/
-QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict,
+QDict *qemu_opts_to_qdict(const QemuOpts *opts, QDict *qdict,
QemuOptsRepeatPolicy repeatPolicy)
{
QemuOpt *opt;
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 13/19] qom: support non-scalar properties with -object
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (11 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 12/19] qapi: allow QObjectInputVisitor to be created with QemuOpts Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 14/19] hmp: support non-scalar properties with object_add Daniel P. Berrange
` (6 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The current -object command line syntax only allows for
creation of objects with scalar properties, or a list
with a fixed scalar element type. Objects which have
properties that are represented as structs in the QAPI
schema cannot be created using -object.
This is a design limitation of the way the OptsVisitor
is written. It simply iterates over the QemuOpts values
as a flat list. The support for lists is enabled by
allowing the same key to be repeated in the opts string.
The QObjectInputVisitor now has functionality that allows
it to replace OptsVisitor, maintaining full backwards
compatibility for previous CLI syntax, while also allowing
use of new syntax for structs.
Thus -object can now support non-scalar properties,
for example the QMP object:
{
"execute": "object-add",
"arguments": {
"qom-type": "demo",
"id": "demo0",
"parameters": {
"foo": [
{ "bar": "one", "wizz": "1" },
{ "bar": "two", "wizz": "2" }
]
}
}
}
Would be creatable via the CLI now using
$QEMU \
-object demo,id=demo0,\
foo.0.bar=one,foo.0.wizz=1,\
foo.1.bar=two,foo.1.wizz=2
Notice that this syntax is intentionally compatible
with that currently used by block drivers. NB the
indentation seen here after line continuations should
not be used in reality, it is just for clarity in this
commit message.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
qapi/qobject-input-visitor.c | 2 +-
qom/object_interfaces.c | 38 ++++-
tests/check-qom-proplist.c | 367 ++++++++++++++++++++++++++++++++++++++++++-
3 files changed, 397 insertions(+), 10 deletions(-)
diff --git a/qapi/qobject-input-visitor.c b/qapi/qobject-input-visitor.c
index 0aef20e..a353d67 100644
--- a/qapi/qobject-input-visitor.c
+++ b/qapi/qobject-input-visitor.c
@@ -204,7 +204,7 @@ static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
*obj = NULL;
}
- if (!qobj && (qiv->struct_level < qiv->autocreate_struct_levels)) {
+ if (!qobj && (qiv->struct_level <= qiv->autocreate_struct_levels)) {
/* Create a new dict that contains all the currently
* unvisited items */
if (tos) {
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index f7afe49..faea1b1 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -4,7 +4,8 @@
#include "qemu/module.h"
#include "qapi-visit.h"
#include "qapi/qobject-output-visitor.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qemu/option.h"
void user_creatable_complete(Object *obj, Error **errp)
{
@@ -63,12 +64,16 @@ Object *user_creatable_add(const QDict *qdict,
if (local_err) {
goto out_visit;
}
- visit_check_struct(v, &local_err);
+
+ obj = user_creatable_add_type(type, id, pdict, v, &local_err);
if (local_err) {
goto out_visit;
}
- obj = user_creatable_add_type(type, id, pdict, v, &local_err);
+ visit_check_struct(v, &local_err);
+ if (local_err) {
+ goto out_visit;
+ }
out_visit:
visit_end_struct(v, NULL);
@@ -114,7 +119,7 @@ Object *user_creatable_add_type(const char *type, const char *id,
assert(qdict);
obj = object_new(type);
- visit_start_struct(v, NULL, NULL, 0, &local_err);
+ visit_start_struct(v, "props", NULL, 0, &local_err);
if (local_err) {
goto out;
}
@@ -158,14 +163,31 @@ Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
{
Visitor *v;
QDict *pdict;
+ QObject *pobj;
Object *obj = NULL;
- v = opts_visitor_new(opts);
pdict = qemu_opts_to_qdict(opts, NULL,
- QEMU_OPTS_REPEAT_POLICY_LAST);
-
- obj = user_creatable_add(pdict, v, errp);
+ QEMU_OPTS_REPEAT_POLICY_LIST);
+
+ pobj = qdict_crumple(pdict, true, errp);
+ if (!pobj) {
+ goto cleanup;
+ }
+ /*
+ * We need autocreate_list=true + permit_int_ranges=true
+ * in order to maintain compat with OptsVisitor creation
+ * of the 'numa' object which had an int16List property.
+ *
+ * We need autocreate_structs=1, because at the CLI level
+ * we have the object type + properties in the same flat
+ * struct, even though at the QMP level they are nested.
+ */
+ v = qobject_input_visitor_new_autocast(pobj, true, 1, true);
+
+ obj = user_creatable_add(qobject_to_qdict(pobj), v, errp);
visit_free(v);
+ qobject_decref(pobj);
+ cleanup:
QDECREF(pdict);
return obj;
}
diff --git a/tests/check-qom-proplist.c b/tests/check-qom-proplist.c
index a16cefc..20eb1d1 100644
--- a/tests/check-qom-proplist.c
+++ b/tests/check-qom-proplist.c
@@ -22,7 +22,16 @@
#include "qapi/error.h"
#include "qom/object.h"
+#include "qom/object_interfaces.h"
#include "qemu/module.h"
+#include "qapi/visitor.h"
+#include "qom/object_interfaces.h"
+#include "qemu/option.h"
+#include "qemu/config-file.h"
+#include "qapi/qmp/qjson.h"
+#include "qapi/qobject-input-visitor.h"
+#include "qapi-visit.h"
+#include "qapi/dealloc-visitor.h"
#define TYPE_DUMMY "qemu-dummy"
@@ -30,6 +39,11 @@
typedef struct DummyObject DummyObject;
typedef struct DummyObjectClass DummyObjectClass;
+typedef struct DummyPerson DummyPerson;
+typedef struct DummyAddr DummyAddr;
+typedef struct DummyAddrList DummyAddrList;
+typedef struct DummySizeList DummySizeList;
+
#define DUMMY_OBJECT(obj) \
OBJECT_CHECK(DummyObject, (obj), TYPE_DUMMY)
@@ -50,12 +64,35 @@ static const char *const dummy_animal_map[DUMMY_LAST + 1] = {
[DUMMY_LAST] = NULL,
};
+
+struct DummyAddr {
+ char *ip;
+ int64_t prefix;
+ bool ipv6only;
+};
+
+struct DummyAddrList {
+ DummyAddrList *next;
+ struct DummyAddr *value;
+};
+
+struct DummyPerson {
+ char *name;
+ int64_t age;
+};
+
struct DummyObject {
Object parent_obj;
bool bv;
DummyAnimal av;
char *sv;
+
+ intList *sizes;
+
+ DummyPerson *person;
+
+ DummyAddrList *addrs;
};
struct DummyObjectClass {
@@ -117,6 +154,157 @@ static char *dummy_get_sv(Object *obj,
return g_strdup(dobj->sv);
}
+static void visit_type_DummyPerson_fields(Visitor *v, DummyPerson **obj,
+ Error **errp)
+{
+ Error *err = NULL;
+
+ visit_type_str(v, "name", &(*obj)->name, &err);
+ if (err) {
+ goto out;
+ }
+ visit_type_int(v, "age", &(*obj)->age, &err);
+ if (err) {
+ goto out;
+ }
+
+out:
+ error_propagate(errp, err);
+}
+
+static void visit_type_DummyPerson(Visitor *v, const char *name,
+ DummyPerson **obj, Error **errp)
+{
+ Error *err = NULL;
+
+ visit_start_struct(v, name, (void **)obj, sizeof(DummyPerson), &err);
+ if (err) {
+ goto out;
+ }
+ if (!*obj) {
+ goto out_obj;
+ }
+ visit_type_DummyPerson_fields(v, obj, &err);
+ error_propagate(errp, err);
+ err = NULL;
+out_obj:
+ visit_end_struct(v, (void **)obj);
+out:
+ error_propagate(errp, err);
+}
+
+static void visit_type_DummyAddr_members(Visitor *v, DummyAddr **obj,
+ Error **errp)
+{
+ Error *err = NULL;
+
+ visit_type_str(v, "ip", &(*obj)->ip, &err);
+ if (err) {
+ goto out;
+ }
+ visit_type_int(v, "prefix", &(*obj)->prefix, &err);
+ if (err) {
+ goto out;
+ }
+ visit_type_bool(v, "ipv6only", &(*obj)->ipv6only, &err);
+ if (err) {
+ goto out;
+ }
+
+out:
+ error_propagate(errp, err);
+}
+
+static void visit_type_DummyAddr(Visitor *v, const char *name,
+ DummyAddr **obj, Error **errp)
+{
+ Error *err = NULL;
+
+ visit_start_struct(v, name, (void **)obj, sizeof(DummyAddr), &err);
+ if (err) {
+ goto out;
+ }
+ if (!*obj) {
+ goto out_obj;
+ }
+ visit_type_DummyAddr_members(v, obj, &err);
+ error_propagate(errp, err);
+ err = NULL;
+out_obj:
+ visit_end_struct(v, (void **)obj);
+out:
+ error_propagate(errp, err);
+}
+
+static void qapi_free_DummyAddrList(DummyAddrList *obj);
+
+static void visit_type_DummyAddrList(Visitor *v, const char *name,
+ DummyAddrList **obj, Error **errp)
+{
+ Error *err = NULL;
+ DummyAddrList *tail;
+ size_t size = sizeof(**obj);
+
+ visit_start_list(v, name, (GenericList **)obj, size, &err);
+ if (err) {
+ goto out;
+ }
+
+ for (tail = *obj; tail;
+ tail = (DummyAddrList *)visit_next_list(v,
+ (GenericList *)tail,
+ size)) {
+ visit_type_DummyAddr(v, NULL, &tail->value, &err);
+ if (err) {
+ break;
+ }
+ }
+
+ visit_end_list(v, (void **)obj);
+ if (err && visit_is_input(v)) {
+ qapi_free_DummyAddrList(*obj);
+ *obj = NULL;
+ }
+out:
+ error_propagate(errp, err);
+}
+
+static void qapi_free_DummyAddrList(DummyAddrList *obj)
+{
+ Visitor *v;
+
+ if (!obj) {
+ return;
+ }
+
+ v = qapi_dealloc_visitor_new();
+ visit_type_DummyAddrList(v, NULL, &obj, NULL);
+ visit_free(v);
+}
+
+static void dummy_set_sizes(Object *obj, Visitor *v, const char *name,
+ void *opaque, Error **errp)
+{
+ DummyObject *dobj = DUMMY_OBJECT(obj);
+
+ visit_type_intList(v, name, &dobj->sizes, errp);
+}
+
+static void dummy_set_person(Object *obj, Visitor *v, const char *name,
+ void *opaque, Error **errp)
+{
+ DummyObject *dobj = DUMMY_OBJECT(obj);
+
+ visit_type_DummyPerson(v, name, &dobj->person, errp);
+}
+
+static void dummy_set_addrs(Object *obj, Visitor *v, const char *name,
+ void *opaque, Error **errp)
+{
+ DummyObject *dobj = DUMMY_OBJECT(obj);
+
+ visit_type_DummyAddrList(v, name, &dobj->addrs, errp);
+}
static void dummy_init(Object *obj)
{
@@ -126,9 +314,16 @@ static void dummy_init(Object *obj)
NULL);
}
+static void
+dummy_complete(UserCreatable *uc, Error **errp)
+{
+}
static void dummy_class_init(ObjectClass *cls, void *data)
{
+ UserCreatableClass *ucc = USER_CREATABLE_CLASS(cls);
+ ucc->complete = dummy_complete;
+
object_class_property_add_bool(cls, "bv",
dummy_get_bv,
dummy_set_bv,
@@ -143,12 +338,34 @@ static void dummy_class_init(ObjectClass *cls, void *data)
dummy_get_av,
dummy_set_av,
NULL);
+ object_class_property_add(cls, "sizes",
+ "int[]",
+ NULL,
+ dummy_set_sizes,
+ NULL, NULL, NULL);
+ object_class_property_add(cls, "person",
+ "DummyPerson",
+ NULL,
+ dummy_set_person,
+ NULL, NULL, NULL);
+ object_class_property_add(cls, "addrs",
+ "DummyAddrList",
+ NULL,
+ dummy_set_addrs,
+ NULL, NULL, NULL);
}
static void dummy_finalize(Object *obj)
{
DummyObject *dobj = DUMMY_OBJECT(obj);
+ Visitor *v;
+
+ v = qapi_dealloc_visitor_new();
+ visit_type_intList(v, NULL, &dobj->sizes, NULL);
+ visit_type_DummyAddrList(v, NULL, &dobj->addrs, NULL);
+ visit_type_DummyPerson(v, NULL, &dobj->person, NULL);
+ visit_free(v);
g_free(dobj->sv);
}
@@ -162,6 +379,10 @@ static const TypeInfo dummy_info = {
.instance_finalize = dummy_finalize,
.class_size = sizeof(DummyObjectClass),
.class_init = dummy_class_init,
+ .interfaces = (InterfaceInfo[]) {
+ { TYPE_USER_CREATABLE },
+ { }
+ }
};
@@ -388,6 +609,128 @@ static void test_dummy_createlist(void)
object_unparent(OBJECT(dobj));
}
+
+static QemuOptsList dummy_opts = {
+ .name = "object",
+ .implied_opt_name = "qom-type",
+ .head = QTAILQ_HEAD_INITIALIZER(dummy_opts.head),
+ .desc = {
+ { }
+ },
+};
+
+static void test_dummy_create_complex(DummyObject *dummy)
+{
+ g_assert(dummy->person != NULL);
+ g_assert_cmpstr(dummy->person->name, ==, "fred");
+ g_assert_cmpint(dummy->person->age, ==, 52);
+
+ g_assert(dummy->sizes != NULL);
+ g_assert_cmpint(dummy->sizes->value, ==, 12);
+ g_assert_cmpint(dummy->sizes->next->value, ==, 13);
+ g_assert_cmpint(dummy->sizes->next->next->value, ==, 8139);
+
+ g_assert(dummy->addrs != NULL);
+ g_assert_cmpstr(dummy->addrs->value->ip, ==, "127.0.0.1");
+ g_assert_cmpint(dummy->addrs->value->prefix, ==, 24);
+ g_assert(dummy->addrs->value->ipv6only);
+ g_assert_cmpstr(dummy->addrs->next->value->ip, ==, "0.0.0.0");
+ g_assert_cmpint(dummy->addrs->next->value->prefix, ==, 16);
+ g_assert(!dummy->addrs->next->value->ipv6only);
+}
+
+
+static void _test_dummy_createopts(const char *optstr)
+{
+ QemuOpts *opts;
+ DummyObject *dummy;
+
+ opts = qemu_opts_parse_noisily(&dummy_opts,
+ optstr, true);
+ g_assert(opts != NULL);
+
+ dummy = DUMMY_OBJECT(user_creatable_add_opts(opts, &error_abort));
+
+ test_dummy_create_complex(dummy);
+
+ object_unparent(OBJECT(dummy));
+ object_unref(OBJECT(dummy));
+ qemu_opts_reset(&dummy_opts);
+}
+
+
+static void test_dummy_createopts(void)
+{
+ const char *optstr = "qemu-dummy,id=dummy0,bv=yes,av=alligator,sv=hiss,"
+ "person.name=fred,person.age=52,sizes.0=12,sizes.1=13,sizes.2=8139,"
+ "addrs.0.ip=127.0.0.1,addrs.0.prefix=24,addrs.0.ipv6only=yes,"
+ "addrs.1.ip=0.0.0.0,addrs.1.prefix=16,addrs.1.ipv6only=no";
+ _test_dummy_createopts(optstr);
+}
+
+static void test_dummy_createopts_repeat(void)
+{
+ const char *optstr = "qemu-dummy,id=dummy0,bv=yes,av=alligator,sv=hiss,"
+ "person.name=fred,person.age=52,sizes=12,sizes=13,sizes=8139,"
+ "addrs.0.ip=127.0.0.1,addrs.0.prefix=24,addrs.0.ipv6only=yes,"
+ "addrs.1.ip=0.0.0.0,addrs.1.prefix=16,addrs.1.ipv6only=no";
+ _test_dummy_createopts(optstr);
+}
+
+static void test_dummy_createopts_range(void)
+{
+ const char *optstr = "qemu-dummy,id=dummy0,bv=yes,av=alligator,sv=hiss,"
+ "person.name=fred,person.age=52,sizes=12-13,sizes=8139,"
+ "addrs.0.ip=127.0.0.1,addrs.0.prefix=24,addrs.0.ipv6only=yes,"
+ "addrs.1.ip=0.0.0.0,addrs.1.prefix=16,addrs.1.ipv6only=no";
+ _test_dummy_createopts(optstr);
+}
+
+
+static void test_dummy_createopts_bad(void)
+{
+ /* Something that tries to create a QList at the top level
+ * should be invalid. */
+ const char *optstr = "qemu-dummy,id=dummy0,1=foo,2=bar,3=wizz";
+ QemuOpts *opts;
+ DummyObject *dummy;
+ Error *err = NULL;
+
+ opts = qemu_opts_parse_noisily(&dummy_opts,
+ optstr, true);
+ g_assert(opts != NULL);
+
+ dummy = DUMMY_OBJECT(user_creatable_add_opts(opts, &err));
+ error_free_or_abort(&err);
+ g_assert(!dummy);
+ qemu_opts_reset(&dummy_opts);
+}
+
+
+static void test_dummy_createqmp(void)
+{
+ const char *jsonstr =
+ "{ 'bv': true, 'av': 'alligator', 'sv': 'hiss', "
+ " 'person': { 'name': 'fred', 'age': 52 }, "
+ " 'sizes': [12, 13, 8139], "
+ " 'addrs': [ { 'ip': '127.0.0.1', 'prefix': 24, 'ipv6only': true }, "
+ " { 'ip': '0.0.0.0', 'prefix': 16, 'ipv6only': false } ] }";
+ QObject *obj = qobject_from_json(jsonstr);
+ Visitor *v = qobject_input_visitor_new(obj, true);
+ DummyObject *dummy;
+ g_assert(obj);
+ dummy = DUMMY_OBJECT(user_creatable_add_type("qemu-dummy", "dummy0",
+ qobject_to_qdict(obj), v,
+ &error_abort));
+
+ test_dummy_create_complex(dummy);
+ visit_free(v);
+ object_unparent(OBJECT(dummy));
+ object_unref(OBJECT(dummy));
+ qobject_decref(obj);
+}
+
+
static void test_dummy_badenum(void)
{
Error *err = NULL;
@@ -473,7 +816,9 @@ static void test_dummy_iterator(void)
ObjectProperty *prop;
ObjectPropertyIterator iter;
- bool seenbv = false, seensv = false, seenav = false, seentype;
+ bool seenbv = false, seensv = false, seenav = false,
+ seentype = false, seenaddrs = false, seenperson = false,
+ seensizes = false;
object_property_iter_init(&iter, OBJECT(dobj));
while ((prop = object_property_iter_next(&iter))) {
@@ -486,6 +831,12 @@ static void test_dummy_iterator(void)
} else if (g_str_equal(prop->name, "type")) {
/* This prop comes from the base Object class */
seentype = true;
+ } else if (g_str_equal(prop->name, "addrs")) {
+ seenaddrs = true;
+ } else if (g_str_equal(prop->name, "person")) {
+ seenperson = true;
+ } else if (g_str_equal(prop->name, "sizes")) {
+ seensizes = true;
} else {
g_printerr("Found prop '%s'\n", prop->name);
g_assert_not_reached();
@@ -495,6 +846,9 @@ static void test_dummy_iterator(void)
g_assert(seenav);
g_assert(seensv);
g_assert(seentype);
+ g_assert(seenaddrs);
+ g_assert(seenperson);
+ g_assert(seensizes);
object_unparent(OBJECT(dobj));
}
@@ -513,11 +867,15 @@ static void test_dummy_delchild(void)
object_unparent(OBJECT(dev));
}
+
int main(int argc, char **argv)
{
g_test_init(&argc, &argv, NULL);
module_call_init(MODULE_INIT_QOM);
+
+ qemu_add_opts(&dummy_opts);
+
type_register_static(&dummy_info);
type_register_static(&dummy_dev_info);
type_register_static(&dummy_bus_info);
@@ -525,6 +883,13 @@ int main(int argc, char **argv)
g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
g_test_add_func("/qom/proplist/createv", test_dummy_createv);
+ g_test_add_func("/qom/proplist/createopts", test_dummy_createopts);
+ g_test_add_func("/qom/proplist/createoptsrepeat",
+ test_dummy_createopts_repeat);
+ g_test_add_func("/qom/proplist/createoptsrange",
+ test_dummy_createopts_range);
+ g_test_add_func("/qom/proplist/createoptsbad", test_dummy_createopts_bad);
+ g_test_add_func("/qom/proplist/createqmp", test_dummy_createqmp);
g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 14/19] hmp: support non-scalar properties with object_add
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (12 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 13/19] qom: support non-scalar properties with -object Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 15/19] numa: convert to use QObjectInputVisitor for -numa Daniel P. Berrange
` (5 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The current object_add HMP syntax only allows for
creation of objects with scalar properties, or a list
with a fixed scalar element type. Objects which have
properties that are represented as structs in the QAPI
schema cannot be created using -object.
This is a design limitation of the way the OptsVisitor
is written. It simply iterates over the QemuOpts values
as a flat list. The support for lists is enabled by
allowing the same key to be repeated in the opts string.
The QObjectInputVisitor now has functionality that allows
it to replace OptsVisitor, maintaining full backwards
compatibility for previous CLI syntax, while also allowing
use of new syntax for structs.
Thus -object can now support non-scalar properties,
for example the QMP object:
{
"execute": "object-add",
"arguments": {
"qom-type": "demo",
"id": "demo0",
"parameters": {
"foo": [
{ "bar": "one", "wizz": "1" },
{ "bar": "two", "wizz": "2" }
]
}
}
}
Would be creatable via the HMP now using
object_add demo,id=demo0,\
foo.0.bar=one,foo.0.wizz=1,\
foo.1.bar=two,foo.1.wizz=2
Notice that this syntax is intentionally compatible
with that currently used by block drivers. NB the
indentation seen here after line continuations should
not be used in reality, it is just for clarity in this
commit message.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
hmp.c | 25 +++++++++++++++++--------
1 file changed, 17 insertions(+), 8 deletions(-)
diff --git a/hmp.c b/hmp.c
index ad33b44..da77d4c 100644
--- a/hmp.c
+++ b/hmp.c
@@ -25,7 +25,7 @@
#include "qemu/sockets.h"
#include "monitor/monitor.h"
#include "monitor/qdev.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi/qmp/qerror.h"
#include "qapi/string-output-visitor.h"
#include "qapi/util.h"
@@ -1695,21 +1695,30 @@ void hmp_netdev_del(Monitor *mon, const QDict *qdict)
void hmp_object_add(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
- QemuOpts *opts;
Visitor *v;
Object *obj = NULL;
+ QObject *pobj;
- opts = qemu_opts_from_qdict(qemu_find_opts("object"), qdict, &err);
+ pobj = qdict_crumple(qdict, true, &err);
if (err) {
- hmp_handle_error(mon, &err);
- return;
+ goto cleanup;
}
- v = opts_visitor_new(opts);
- obj = user_creatable_add(qdict, v, &err);
+ /*
+ * We need autocreate_list=true + permit_int_ranges=true
+ * in order to maintain compat with OptsVisitor creation
+ * of the 'numa' object which had an int16List property.
+ *
+ * We need autocreate_structs=1, because at the CLI level
+ * we have the object type + properties in the same flat
+ * struct, even though at the QMP level they are nested.
+ */
+ v = qobject_input_visitor_new_autocast(pobj, true, 1, true);
+ obj = user_creatable_add(qobject_to_qdict(pobj), v, &err);
visit_free(v);
- qemu_opts_del(opts);
+ cleanup:
+ qobject_decref(pobj);
if (err) {
hmp_handle_error(mon, &err);
}
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 15/19] numa: convert to use QObjectInputVisitor for -numa
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (13 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 14/19] hmp: support non-scalar properties with object_add Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 16/19] block: convert crypto driver to use QObjectInputVisitor Daniel P. Berrange
` (4 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Switch away from using OptsVisitor to parse the -numa
argument processing. This enables use of the modern
list syntax for specifying CPUs. e.g. the old syntax
-numa node,nodeid=0,cpus=0-3,cpus=8-11,mem=107
is equivalent to
-numa node,nodeid=0,cpus.0=0,cpus.1=1,cpus.2=2,cpus.3=3,\
cpus.4=8,cpus.5=9,cpus.6=10,cpus.7=11,mem=107
Furthermore, the cli arg can now follow the QAPI schema
nesting, so the above is equivalent to the canonical
syntax:
-numa type=node,data.nodeid=0,data.cpus.0=0,data.cpus.1=1,\
data.cpus.2=2,data.cpus.3=3,data.cpus.4=8,data.cpus.5=9,\
data.cpus.6=10,data.cpus.7=11,data.mem=107
A test case is added to cover argument parsing to validate
that both the old and new syntax is correctly handled.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/sysemu/numa_int.h | 11 +++++
numa.c | 36 +++++++++-----
stubs/Makefile.objs | 5 ++
stubs/exec.c | 6 +++
stubs/hostmem.c | 14 ++++++
stubs/memory.c | 41 ++++++++++++++++
stubs/qdev.c | 8 ++++
stubs/vl.c | 8 ++++
stubs/vmstate.c | 4 ++
tests/Makefile.include | 2 +
tests/test-numa.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++
11 files changed, 240 insertions(+), 11 deletions(-)
create mode 100644 include/sysemu/numa_int.h
create mode 100644 stubs/exec.c
create mode 100644 stubs/hostmem.c
create mode 100644 stubs/memory.c
create mode 100644 stubs/qdev.c
create mode 100644 stubs/vl.c
create mode 100644 tests/test-numa.c
diff --git a/include/sysemu/numa_int.h b/include/sysemu/numa_int.h
new file mode 100644
index 0000000..93160da
--- /dev/null
+++ b/include/sysemu/numa_int.h
@@ -0,0 +1,11 @@
+#ifndef SYSEMU_NUMA_INT_H
+#define SYSEMU_NUMA_INT_H
+
+#include "sysemu/numa.h"
+
+extern int have_memdevs;
+extern int max_numa_nodeid;
+
+int parse_numa(void *opaque, QemuOpts *opts, Error **errp);
+
+#endif
diff --git a/numa.c b/numa.c
index 6289f46..5daa3d1 100644
--- a/numa.c
+++ b/numa.c
@@ -23,14 +23,14 @@
*/
#include "qemu/osdep.h"
-#include "sysemu/numa.h"
+#include "sysemu/numa_int.h"
#include "exec/cpu-common.h"
#include "qemu/bitmap.h"
#include "qom/cpu.h"
#include "qemu/error-report.h"
#include "include/exec/cpu-common.h" /* for RAM_ADDR_FMT */
#include "qapi-visit.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "hw/boards.h"
#include "sysemu/hostmem.h"
#include "qmp-commands.h"
@@ -45,10 +45,10 @@ QemuOptsList qemu_numa_opts = {
.desc = { { 0 } } /* validated with OptsVisitor */
};
-static int have_memdevs = -1;
-static int max_numa_nodeid; /* Highest specified NUMA node ID, plus one.
- * For all nodes, nodeid < max_numa_nodeid
- */
+int have_memdevs = -1;
+int max_numa_nodeid; /* Highest specified NUMA node ID, plus one.
+ * For all nodes, nodeid < max_numa_nodeid
+ */
int nb_numa_nodes;
NodeInfo numa_info[MAX_NODES];
@@ -189,6 +189,9 @@ static void numa_node_parse(NumaNodeOptions *node, QemuOpts *opts, Error **errp)
if (node->has_mem) {
uint64_t mem_size = node->mem;
const char *mem_str = qemu_opt_get(opts, "mem");
+ if (!mem_str) {
+ mem_str = qemu_opt_get(opts, "data.mem");
+ }
/* Fix up legacy suffix-less format */
if (g_ascii_isdigit(mem_str[strlen(mem_str) - 1])) {
mem_size <<= 20;
@@ -211,16 +214,27 @@ static void numa_node_parse(NumaNodeOptions *node, QemuOpts *opts, Error **errp)
max_numa_nodeid = MAX(max_numa_nodeid, nodenr + 1);
}
-static int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
+int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
{
NumaOptions *object = NULL;
Error *err = NULL;
+ Visitor *v;
- {
- Visitor *v = opts_visitor_new(opts);
- visit_type_NumaOptions(v, NULL, &object, &err);
- visit_free(v);
+ /*
+ * Needs autocreate_list=true and permit_int_ranges=true
+ * in order to support existing syntax for 'cpus' parameter
+ * which is an int list.
+ *
+ * Needs autocreate_struct_levels=1, because existing syntax
+ * used a nested struct in the QMP schema with a flat namespace
+ * in the CLI args.
+ */
+ v = qobject_input_visitor_new_opts(opts, true, 1, true, &err);
+ if (err) {
+ goto end;
}
+ visit_type_NumaOptions(v, NULL, &object, &err);
+ visit_free(v);
if (err) {
goto end;
diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs
index c5850e8..661b48a 100644
--- a/stubs/Makefile.objs
+++ b/stubs/Makefile.objs
@@ -48,3 +48,8 @@ stub-obj-y += iohandler.o
stub-obj-y += smbios_type_38.o
stub-obj-y += ipmi.o
stub-obj-y += pc_madt_cpu_entry.o
+stub-obj-y += vl.o
+stub-obj-y += exec.o
+stub-obj-y += memory.o
+stub-obj-y += hostmem.o
+stub-obj-y += qdev.o
diff --git a/stubs/exec.c b/stubs/exec.c
new file mode 100644
index 0000000..e37f002
--- /dev/null
+++ b/stubs/exec.c
@@ -0,0 +1,6 @@
+
+#include "qemu/osdep.h"
+#include "exec/cpu-common.h"
+#include "qom/cpu.h"
+
+struct CPUTailQ cpus = QTAILQ_HEAD_INITIALIZER(cpus);
diff --git a/stubs/hostmem.c b/stubs/hostmem.c
new file mode 100644
index 0000000..301d853
--- /dev/null
+++ b/stubs/hostmem.c
@@ -0,0 +1,14 @@
+
+#include "qemu/osdep.h"
+#include "sysemu/hostmem.h"
+
+void host_memory_backend_set_mapped(HostMemoryBackend *backend, bool mapped)
+{
+}
+
+
+MemoryRegion *host_memory_backend_get_memory(HostMemoryBackend *backend,
+ Error **errp)
+{
+ return NULL;
+}
diff --git a/stubs/memory.c b/stubs/memory.c
new file mode 100644
index 0000000..c849d9d
--- /dev/null
+++ b/stubs/memory.c
@@ -0,0 +1,41 @@
+
+#include "qemu/osdep.h"
+#include "exec/memory.h"
+
+void memory_region_init_ram(MemoryRegion *mr,
+ struct Object *owner,
+ const char *name,
+ uint64_t size,
+ Error **errp)
+{
+}
+
+#ifdef __linux__
+void memory_region_init_ram_from_file(MemoryRegion *mr,
+ struct Object *owner,
+ const char *name,
+ uint64_t size,
+ bool share,
+ const char *path,
+ Error **errp)
+{
+}
+#endif
+
+void memory_region_init(MemoryRegion *mr,
+ struct Object *owner,
+ const char *name,
+ uint64_t size)
+{
+}
+
+void memory_region_add_subregion(MemoryRegion *mr,
+ hwaddr offset,
+ MemoryRegion *subregion)
+{
+}
+
+bool memory_region_is_mapped(MemoryRegion *mr)
+{
+ return false;
+}
diff --git a/stubs/qdev.c b/stubs/qdev.c
new file mode 100644
index 0000000..e28fdf2
--- /dev/null
+++ b/stubs/qdev.c
@@ -0,0 +1,8 @@
+
+#include "qemu/osdep.h"
+#include "hw/qdev-core.h"
+
+Object *qdev_get_machine(void)
+{
+ return NULL;
+}
diff --git a/stubs/vl.c b/stubs/vl.c
new file mode 100644
index 0000000..698fa80
--- /dev/null
+++ b/stubs/vl.c
@@ -0,0 +1,8 @@
+
+#include "qemu/osdep.h"
+#include "exec/cpu-common.h"
+
+int max_cpus = 1;
+ram_addr_t ram_size;
+const char *mem_path;
+int mem_prealloc;
diff --git a/stubs/vmstate.c b/stubs/vmstate.c
index 94b831e..f2708ee 100644
--- a/stubs/vmstate.c
+++ b/stubs/vmstate.c
@@ -23,3 +23,7 @@ void vmstate_unregister(DeviceState *dev,
void *opaque)
{
}
+
+void vmstate_register_ram_global(struct MemoryRegion *memory)
+{
+}
diff --git a/tests/Makefile.include b/tests/Makefile.include
index 6398678..7625ef7 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -116,6 +116,7 @@ check-unit-$(CONFIG_REPLICATION) += tests/test-replication$(EXESUF)
check-unit-y += tests/test-bufferiszero$(EXESUF)
gcov-files-check-bufferiszero-y = util/bufferiszero.c
check-unit-y += tests/test-uuid$(EXESUF)
+check-unit-y += tests/test-numa$(EXESUF)
check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -583,6 +584,7 @@ tests/test-crypto-pbkdf$(EXESUF): tests/test-crypto-pbkdf.o $(test-crypto-obj-y)
tests/test-crypto-ivgen$(EXESUF): tests/test-crypto-ivgen.o $(test-crypto-obj-y)
tests/test-crypto-afsplit$(EXESUF): tests/test-crypto-afsplit.o $(test-crypto-obj-y)
tests/test-crypto-block$(EXESUF): tests/test-crypto-block.o $(test-crypto-obj-y)
+tests/test-numa$(EXESUF): tests/test-numa.o numa.o $(test-qom-obj-y)
libqos-obj-y = tests/libqos/pci.o tests/libqos/fw_cfg.o tests/libqos/malloc.o
libqos-obj-y += tests/libqos/i2c.o tests/libqos/libqos.o
diff --git a/tests/test-numa.c b/tests/test-numa.c
new file mode 100644
index 0000000..458681b
--- /dev/null
+++ b/tests/test-numa.c
@@ -0,0 +1,116 @@
+/*
+ * QEMU NUMA testing
+ *
+ * Copyright (c) 2016 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "qemu/osdep.h"
+
+#include "sysemu/numa_int.h"
+
+static void test_numa_parse(const char **nodestr)
+{
+ QemuOpts *opts;
+ size_t i;
+
+ DECLARE_BITMAP(node0cpus, MAX_CPUMASK_BITS);
+ DECLARE_BITMAP(node5cpus, MAX_CPUMASK_BITS);
+
+ bitmap_zero(node0cpus, MAX_CPUMASK_BITS);
+ bitmap_zero(node5cpus, MAX_CPUMASK_BITS);
+ for (i = 0; i <= 3; i++) {
+ bitmap_set(node0cpus, i, 1);
+ }
+ for (i = 8; i <= 11; i++) {
+ bitmap_set(node0cpus, i, 1);
+ }
+ for (i = 4; i <= 7; i++) {
+ bitmap_set(node5cpus, i, 1);
+ }
+ for (i = 12; i <= 15; i++) {
+ bitmap_set(node5cpus, i, 1);
+ }
+
+ max_cpus = 16;
+
+ opts = qemu_opts_parse_noisily(&qemu_numa_opts,
+ nodestr[0], true);
+ g_assert(opts != NULL);
+
+ opts = qemu_opts_parse_noisily(&qemu_numa_opts,
+ nodestr[1], true);
+ g_assert(opts != NULL);
+
+ qemu_opts_foreach(&qemu_numa_opts, parse_numa, NULL, NULL);
+
+ g_assert_cmpint(max_numa_nodeid, ==, 6);
+ g_assert(!have_memdevs);
+
+ g_assert_cmpint(nb_numa_nodes, ==, 2);
+ for (i = 0; i < MAX_NODES; i++) {
+ if (i == 0 || i == 5) {
+ g_assert(numa_info[i].present);
+ g_assert_cmpint(numa_info[i].node_mem, ==, 107 * 1024 * 1024);
+
+ if (i == 0) {
+ g_assert(bitmap_equal(node0cpus,
+ numa_info[i].node_cpu,
+ MAX_CPUMASK_BITS));
+ } else {
+ g_assert(bitmap_equal(node5cpus,
+ numa_info[i].node_cpu,
+ MAX_CPUMASK_BITS));
+ }
+ } else {
+ g_assert(!numa_info[i].present);
+ }
+ }
+
+ nb_numa_nodes = 0;
+ max_numa_nodeid = 0;
+ memset(&numa_info, 0, sizeof(numa_info));
+ g_assert(!numa_info[0].present);
+ qemu_opts_reset(&qemu_numa_opts);
+}
+
+static void test_numa_parse_legacy(void)
+{
+ const char *nodestr[] = {
+ "node,nodeid=0,cpus=0-3,cpus=8-11,mem=107",
+ "node,nodeid=5,cpus=4-7,cpus=12-15,mem=107"
+ };
+ test_numa_parse(nodestr);
+}
+
+static void test_numa_parse_modern(void)
+{
+ const char *nodestr[] = {
+ "type=node,data.nodeid=0,data.cpus.0=0,data.cpus.1=1,data.cpus.2=2,data.cpus.3=3,"
+ "data.cpus.4=8,data.cpus.5=9,data.cpus.6=10,data.cpus.7=11,data.mem=107",
+ "type=node,data.nodeid=5,data.cpus.0=4,data.cpus.1=5,data.cpus.2=6,data.cpus.3=7,"
+ "data.cpus.4=12,data.cpus.5=13,data.cpus.6=14,data.cpus.7=15,data.mem=107",
+ };
+ test_numa_parse(nodestr);
+}
+
+int main(int argc, char **argv)
+{
+ g_test_init(&argc, &argv, NULL);
+ g_test_add_func("/numa/parse/legacy", test_numa_parse_legacy);
+ g_test_add_func("/numa/parse/modern", test_numa_parse_modern);
+ return g_test_run();
+}
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 16/19] block: convert crypto driver to use QObjectInputVisitor
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (14 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 15/19] numa: convert to use QObjectInputVisitor for -numa Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 17/19] acpi: convert to QObjectInputVisitor for -acpi parsing Daniel P. Berrange
` (3 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The crypto block driver currently uses OptsVisitor to
convert from the block driver open/create options into
QCryptoBlockOpenOptions/QCryptoBlockCreateOptions. This
is easily replaced by use of QObjectInputVisitor with
no need to enable any compatibility options, since the
structs dealt with contain only scalars.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
block/crypto.c | 12 +++++++++---
1 file changed, 9 insertions(+), 3 deletions(-)
diff --git a/block/crypto.c b/block/crypto.c
index 7aa7eb5..fee6c99 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -23,7 +23,7 @@
#include "block/block_int.h"
#include "sysemu/block-backend.h"
#include "crypto/block.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi-visit.h"
#include "qapi/error.h"
@@ -206,7 +206,10 @@ block_crypto_open_opts_init(QCryptoBlockFormat format,
ret = g_new0(QCryptoBlockOpenOptions, 1);
ret->format = format;
- v = opts_visitor_new(opts);
+ v = qobject_input_visitor_new_opts(opts, false, 0, false, &local_err);
+ if (local_err) {
+ goto out;
+ }
visit_start_struct(v, NULL, NULL, 0, &local_err);
if (local_err) {
@@ -252,7 +255,10 @@ block_crypto_create_opts_init(QCryptoBlockFormat format,
ret = g_new0(QCryptoBlockCreateOptions, 1);
ret->format = format;
- v = opts_visitor_new(opts);
+ v = qobject_input_visitor_new_opts(opts, false, 0, false, &local_err);
+ if (local_err) {
+ goto out;
+ }
visit_start_struct(v, NULL, NULL, 0, &local_err);
if (local_err) {
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 17/19] acpi: convert to QObjectInputVisitor for -acpi parsing
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (15 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 16/19] block: convert crypto driver to use QObjectInputVisitor Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 18/19] net: convert to QObjectInputVisitor for -net/-netdev parsing Daniel P. Berrange
` (2 subsequent siblings)
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The -acpi command line option parsing uses the OptsVisitor
currently. This is easily replaced by the QObjectInputVisitor
instead. There is no need to enable any of the compatibility
options, since the AcpiTableOptions QAPI struct only contains
scalar properties.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
hw/acpi/core.c | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
diff --git a/hw/acpi/core.c b/hw/acpi/core.c
index e890a5d..480d3dd 100644
--- a/hw/acpi/core.c
+++ b/hw/acpi/core.c
@@ -25,7 +25,7 @@
#include "hw/acpi/acpi.h"
#include "hw/nvram/fw_cfg.h"
#include "qemu/config-file.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "qapi-visit.h"
#include "qapi-event.h"
@@ -237,14 +237,14 @@ void acpi_table_add(const QemuOpts *opts, Error **errp)
char **cur;
size_t bloblen = 0;
char unsigned *blob = NULL;
+ Visitor *v;
- {
- Visitor *v;
-
- v = opts_visitor_new(opts);
- visit_type_AcpiTableOptions(v, NULL, &hdrs, &err);
- visit_free(v);
+ v = qobject_input_visitor_new_opts(opts, false, 0, false, &err);
+ if (err) {
+ goto out;
}
+ visit_type_AcpiTableOptions(v, NULL, &hdrs, &err);
+ visit_free(v);
if (err) {
goto out;
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 18/19] net: convert to QObjectInputVisitor for -net/-netdev parsing
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (16 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 17/19] acpi: convert to QObjectInputVisitor for -acpi parsing Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 19/19] qapi: delete unused OptsVisitor code Daniel P. Berrange
2016-10-20 15:06 ` [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Markus Armbruster
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
The -net/-netdev command line parsing code uses OptsVisitor
for parsing options to populate NetLegacy or NetDev struct
respectively. Although those structs have nesting, the
OptsVisitor flattens them, so we must enable compatibility
options to auto-create structs. This allows the legacy
syntax
-net tap,id=net0,vlan=3,fd=3,script=/bin/ifup-qemu
to be treated as equivalent to the modern QAPI based
syntax
-net id=net0,vlan=3,opts.type=tap,opts.data.fd=3,opts.data.script=/bin/ifup-qemu
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
net/net.c | 17 +++++++++++++++--
1 file changed, 15 insertions(+), 2 deletions(-)
diff --git a/net/net.c b/net/net.c
index d51cb29..af3645b 100644
--- a/net/net.c
+++ b/net/net.c
@@ -43,7 +43,7 @@
#include "qemu/iov.h"
#include "qemu/main-loop.h"
#include "qapi-visit.h"
-#include "qapi/opts-visitor.h"
+#include "qapi/qobject-input-visitor.h"
#include "sysemu/sysemu.h"
#include "net/filter.h"
#include "qapi/string-output-visitor.h"
@@ -1065,7 +1065,20 @@ int net_client_init(QemuOpts *opts, bool is_netdev, Error **errp)
void *object = NULL;
Error *err = NULL;
int ret = -1;
- Visitor *v = opts_visitor_new(opts);
+ /*
+ * Needs autocreate_lists=true in order support existing
+ * syntax for list options where the bare key is repeated
+ *
+ * Needs autocreate_struct_levels=3 in order to deal with
+ * 3 level nesting in NetLegacy option args, which was
+ * exposed as a flat namespace with OptVisitor
+ */
+ Visitor *v = qobject_input_visitor_new_opts(opts, true, 3, false, &err);
+
+ if (err) {
+ error_propagate(errp, err);
+ return -1;
+ }
{
/* Parse convenience option format ip6-net=fec0::0[/64] */
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* [Qemu-devel] [PATCH v14 19/19] qapi: delete unused OptsVisitor code
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (17 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 18/19] net: convert to QObjectInputVisitor for -net/-netdev parsing Daniel P. Berrange
@ 2016-09-27 13:13 ` Daniel P. Berrange
2016-10-20 15:06 ` [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Markus Armbruster
19 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-27 13:13 UTC (permalink / raw)
To: qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber, Daniel P. Berrange
Now that all code has been converted to QObjectInputVisitor's
QemuOpts compatibility mode, there is no longer any reason
to keep OptsVisitor alive.
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
---
include/qapi/opts-visitor.h | 40 ----
qapi/Makefile.objs | 2 +-
qapi/opts-visitor.c | 544 --------------------------------------------
tests/Makefile.include | 5 +-
tests/test-opts-visitor.c | 268 ----------------------
vl.c | 1 -
6 files changed, 2 insertions(+), 858 deletions(-)
delete mode 100644 include/qapi/opts-visitor.h
delete mode 100644 qapi/opts-visitor.c
delete mode 100644 tests/test-opts-visitor.c
diff --git a/include/qapi/opts-visitor.h b/include/qapi/opts-visitor.h
deleted file mode 100644
index 6462c96..0000000
--- a/include/qapi/opts-visitor.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * Options Visitor
- *
- * Copyright Red Hat, Inc. 2012
- *
- * Author: Laszlo Ersek <lersek@redhat.com>
- *
- * 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 OPTS_VISITOR_H
-#define OPTS_VISITOR_H
-
-#include "qapi/visitor.h"
-#include "qemu/option.h"
-
-/* Inclusive upper bound on the size of any flattened range. This is a safety
- * (= anti-annoyance) measure; wrong ranges should not cause long startup
- * delays nor exhaust virtual memory.
- */
-#define OPTS_VISITOR_RANGE_MAX 65536
-
-typedef struct OptsVisitor OptsVisitor;
-
-/* Contrarily to qemu-option.c::parse_option_number(), OptsVisitor's "int"
- * parser relies on strtoll() instead of strtoull(). Consequences:
- * - string representations of negative numbers yield negative values,
- * - values below INT64_MIN or LLONG_MIN are rejected,
- * - values above INT64_MAX or LLONG_MAX are rejected.
- *
- * The Opts input visitor does not implement support for visiting QAPI
- * alternates, numbers (other than integers), null, or arbitrary
- * QTypes. It also requires a non-null list argument to
- * visit_start_list().
- */
-Visitor *opts_visitor_new(const QemuOpts *opts);
-
-#endif
diff --git a/qapi/Makefile.objs b/qapi/Makefile.objs
index 33906ff..4b820a7 100644
--- a/qapi/Makefile.objs
+++ b/qapi/Makefile.objs
@@ -1,6 +1,6 @@
util-obj-y = qapi-visit-core.o qapi-dealloc-visitor.o qobject-input-visitor.o
util-obj-y += qobject-output-visitor.o qmp-registry.o qmp-dispatch.o
util-obj-y += string-input-visitor.o string-output-visitor.o
-util-obj-y += opts-visitor.o qapi-clone-visitor.o
+util-obj-y += qapi-clone-visitor.o
util-obj-y += qmp-event.o
util-obj-y += qapi-util.o
diff --git a/qapi/opts-visitor.c b/qapi/opts-visitor.c
deleted file mode 100644
index 084f7cc..0000000
--- a/qapi/opts-visitor.c
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
- * Options Visitor
- *
- * Copyright Red Hat, Inc. 2012-2016
- *
- * Author: Laszlo Ersek <lersek@redhat.com>
- *
- * 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 "qapi/error.h"
-#include "qemu/cutils.h"
-#include "qapi/qmp/qerror.h"
-#include "qapi/opts-visitor.h"
-#include "qemu/queue.h"
-#include "qemu/option_int.h"
-#include "qapi/visitor-impl.h"
-
-
-enum ListMode
-{
- LM_NONE, /* not traversing a list of repeated options */
-
- LM_IN_PROGRESS, /* opts_next_list() ready to be called.
- *
- * Generating the next list link will consume the most
- * recently parsed QemuOpt instance of the repeated
- * option.
- *
- * Parsing a value into the list link will examine the
- * next QemuOpt instance of the repeated option, and
- * possibly enter LM_SIGNED_INTERVAL or
- * LM_UNSIGNED_INTERVAL.
- */
-
- LM_SIGNED_INTERVAL, /* opts_next_list() has been called.
- *
- * Generating the next list link will consume the most
- * recently stored element from the signed interval,
- * parsed from the most recent QemuOpt instance of the
- * repeated option. This may consume QemuOpt itself
- * and return to LM_IN_PROGRESS.
- *
- * Parsing a value into the list link will store the
- * next element of the signed interval.
- */
-
- LM_UNSIGNED_INTERVAL /* Same as above, only for an unsigned interval. */
-};
-
-typedef enum ListMode ListMode;
-
-struct OptsVisitor
-{
- Visitor visitor;
-
- /* Ownership remains with opts_visitor_new()'s caller. */
- const QemuOpts *opts_root;
-
- unsigned depth;
-
- /* Non-null iff depth is positive. Each key is a QemuOpt name. Each value
- * is a non-empty GQueue, enumerating all QemuOpt occurrences with that
- * name. */
- GHashTable *unprocessed_opts;
-
- /* The list currently being traversed with opts_start_list() /
- * opts_next_list(). The list must have a struct element type in the
- * schema, with a single mandatory scalar member. */
- ListMode list_mode;
- GQueue *repeated_opts;
-
- /* When parsing a list of repeating options as integers, values of the form
- * "a-b", representing a closed interval, are allowed. Elements in the
- * range are generated individually.
- */
- union {
- int64_t s;
- uint64_t u;
- } range_next, range_limit;
-
- /* If "opts_root->id" is set, reinstantiate it as a fake QemuOpt for
- * uniformity. Only its "name" and "str" fields are set. "fake_id_opt" does
- * not survive or escape the OptsVisitor object.
- */
- QemuOpt *fake_id_opt;
-};
-
-
-static OptsVisitor *to_ov(Visitor *v)
-{
- return container_of(v, OptsVisitor, visitor);
-}
-
-
-static void
-destroy_list(gpointer list)
-{
- g_queue_free(list);
-}
-
-
-static void
-opts_visitor_insert(GHashTable *unprocessed_opts, const QemuOpt *opt)
-{
- GQueue *list;
-
- list = g_hash_table_lookup(unprocessed_opts, opt->name);
- if (list == NULL) {
- list = g_queue_new();
-
- /* GHashTable will never try to free the keys -- we supply NULL as
- * "key_destroy_func" in opts_start_struct(). Thus cast away key
- * const-ness in order to suppress gcc's warning.
- */
- g_hash_table_insert(unprocessed_opts, (gpointer)opt->name, list);
- }
-
- /* Similarly, destroy_list() doesn't call g_queue_free_full(). */
- g_queue_push_tail(list, (gpointer)opt);
-}
-
-
-static void
-opts_start_struct(Visitor *v, const char *name, void **obj,
- size_t size, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
-
- if (obj) {
- *obj = g_malloc0(size);
- }
- if (ov->depth++ > 0) {
- return;
- }
-
- ov->unprocessed_opts = g_hash_table_new_full(&g_str_hash, &g_str_equal,
- NULL, &destroy_list);
- QTAILQ_FOREACH(opt, &ov->opts_root->head, next) {
- /* ensured by qemu-option.c::opts_do_parse() */
- assert(strcmp(opt->name, "id") != 0);
-
- opts_visitor_insert(ov->unprocessed_opts, opt);
- }
-
- if (ov->opts_root->id != NULL) {
- ov->fake_id_opt = g_malloc0(sizeof *ov->fake_id_opt);
-
- ov->fake_id_opt->name = g_strdup("id");
- ov->fake_id_opt->str = g_strdup(ov->opts_root->id);
- opts_visitor_insert(ov->unprocessed_opts, ov->fake_id_opt);
- }
-}
-
-
-static void
-opts_check_struct(Visitor *v, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- GHashTableIter iter;
- GQueue *any;
-
- if (ov->depth > 0) {
- return;
- }
-
- /* we should have processed all (distinct) QemuOpt instances */
- g_hash_table_iter_init(&iter, ov->unprocessed_opts);
- if (g_hash_table_iter_next(&iter, NULL, (void **)&any)) {
- const QemuOpt *first;
-
- first = g_queue_peek_head(any);
- error_setg(errp, QERR_INVALID_PARAMETER, first->name);
- }
-}
-
-
-static void
-opts_end_struct(Visitor *v, void **obj)
-{
- OptsVisitor *ov = to_ov(v);
-
- if (--ov->depth > 0) {
- return;
- }
-
- g_hash_table_destroy(ov->unprocessed_opts);
- ov->unprocessed_opts = NULL;
- if (ov->fake_id_opt) {
- g_free(ov->fake_id_opt->name);
- g_free(ov->fake_id_opt->str);
- g_free(ov->fake_id_opt);
- }
- ov->fake_id_opt = NULL;
-}
-
-
-static GQueue *
-lookup_distinct(const OptsVisitor *ov, const char *name, Error **errp)
-{
- GQueue *list;
-
- list = g_hash_table_lookup(ov->unprocessed_opts, name);
- if (!list) {
- error_setg(errp, QERR_MISSING_PARAMETER, name);
- }
- return list;
-}
-
-
-static void
-opts_start_list(Visitor *v, const char *name, GenericList **list, size_t size,
- Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
-
- /* we can't traverse a list in a list */
- assert(ov->list_mode == LM_NONE);
- /* we don't support visits without a list */
- assert(list);
- ov->repeated_opts = lookup_distinct(ov, name, errp);
- if (ov->repeated_opts) {
- ov->list_mode = LM_IN_PROGRESS;
- *list = g_malloc0(size);
- } else {
- *list = NULL;
- }
-}
-
-
-static GenericList *
-opts_next_list(Visitor *v, GenericList *tail, size_t size)
-{
- OptsVisitor *ov = to_ov(v);
-
- switch (ov->list_mode) {
- case LM_SIGNED_INTERVAL:
- case LM_UNSIGNED_INTERVAL:
- if (ov->list_mode == LM_SIGNED_INTERVAL) {
- if (ov->range_next.s < ov->range_limit.s) {
- ++ov->range_next.s;
- break;
- }
- } else if (ov->range_next.u < ov->range_limit.u) {
- ++ov->range_next.u;
- break;
- }
- ov->list_mode = LM_IN_PROGRESS;
- /* range has been completed, fall through in order to pop option */
-
- case LM_IN_PROGRESS: {
- const QemuOpt *opt;
-
- opt = g_queue_pop_head(ov->repeated_opts);
- if (g_queue_is_empty(ov->repeated_opts)) {
- g_hash_table_remove(ov->unprocessed_opts, opt->name);
- return NULL;
- }
- break;
- }
-
- default:
- abort();
- }
-
- tail->next = g_malloc0(size);
- return tail->next;
-}
-
-
-static void
-opts_end_list(Visitor *v, void **obj)
-{
- OptsVisitor *ov = to_ov(v);
-
- assert(ov->list_mode == LM_IN_PROGRESS ||
- ov->list_mode == LM_SIGNED_INTERVAL ||
- ov->list_mode == LM_UNSIGNED_INTERVAL);
- ov->repeated_opts = NULL;
- ov->list_mode = LM_NONE;
-}
-
-
-static const QemuOpt *
-lookup_scalar(const OptsVisitor *ov, const char *name, Error **errp)
-{
- if (ov->list_mode == LM_NONE) {
- GQueue *list;
-
- /* the last occurrence of any QemuOpt takes effect when queried by name
- */
- list = lookup_distinct(ov, name, errp);
- return list ? g_queue_peek_tail(list) : NULL;
- }
- assert(ov->list_mode == LM_IN_PROGRESS);
- return g_queue_peek_head(ov->repeated_opts);
-}
-
-
-static void
-processed(OptsVisitor *ov, const char *name)
-{
- if (ov->list_mode == LM_NONE) {
- g_hash_table_remove(ov->unprocessed_opts, name);
- return;
- }
- assert(ov->list_mode == LM_IN_PROGRESS);
- /* do nothing */
-}
-
-
-static void
-opts_type_str(Visitor *v, const char *name, char **obj, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
-
- opt = lookup_scalar(ov, name, errp);
- if (!opt) {
- *obj = NULL;
- return;
- }
- *obj = g_strdup(opt->str ? opt->str : "");
- /* Note that we consume a string even if this is called as part of
- * an enum visit that later fails because the string is not a
- * valid enum value; this is harmless because tracking what gets
- * consumed only matters to visit_end_struct() as the final error
- * check if there were no other failures during the visit. */
- processed(ov, name);
-}
-
-
-static void
-opts_type_bool(Visitor *v, const char *name, bool *obj, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
-
- opt = lookup_scalar(ov, name, errp);
- if (!opt) {
- return;
- }
-
- parse_option_bool(opt->name, opt->str, obj, errp);
-
- processed(ov, name);
-}
-
-
-static void
-opts_type_int64(Visitor *v, const char *name, int64_t *obj, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
- const char *str;
- long long val;
- char *endptr;
-
- if (ov->list_mode == LM_SIGNED_INTERVAL) {
- *obj = ov->range_next.s;
- return;
- }
-
- opt = lookup_scalar(ov, name, errp);
- if (!opt) {
- return;
- }
- str = opt->str ? opt->str : "";
-
- /* we've gotten past lookup_scalar() */
- assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
-
- errno = 0;
- val = strtoll(str, &endptr, 0);
- if (errno == 0 && endptr > str && INT64_MIN <= val && val <= INT64_MAX) {
- if (*endptr == '\0') {
- *obj = val;
- processed(ov, name);
- return;
- }
- if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
- long long val2;
-
- str = endptr + 1;
- val2 = strtoll(str, &endptr, 0);
- if (errno == 0 && endptr > str && *endptr == '\0' &&
- INT64_MIN <= val2 && val2 <= INT64_MAX && val <= val2 &&
- (val > INT64_MAX - OPTS_VISITOR_RANGE_MAX ||
- val2 < val + OPTS_VISITOR_RANGE_MAX)) {
- ov->range_next.s = val;
- ov->range_limit.s = val2;
- ov->list_mode = LM_SIGNED_INTERVAL;
-
- /* as if entering on the top */
- *obj = ov->range_next.s;
- return;
- }
- }
- }
- error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
- (ov->list_mode == LM_NONE) ? "an int64 value" :
- "an int64 value or range");
-}
-
-
-static void
-opts_type_uint64(Visitor *v, const char *name, uint64_t *obj, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
- const char *str;
- unsigned long long val;
- char *endptr;
-
- if (ov->list_mode == LM_UNSIGNED_INTERVAL) {
- *obj = ov->range_next.u;
- return;
- }
-
- opt = lookup_scalar(ov, name, errp);
- if (!opt) {
- return;
- }
- str = opt->str;
-
- /* we've gotten past lookup_scalar() */
- assert(ov->list_mode == LM_NONE || ov->list_mode == LM_IN_PROGRESS);
-
- if (parse_uint(str, &val, &endptr, 0) == 0 && val <= UINT64_MAX) {
- if (*endptr == '\0') {
- *obj = val;
- processed(ov, name);
- return;
- }
- if (*endptr == '-' && ov->list_mode == LM_IN_PROGRESS) {
- unsigned long long val2;
-
- str = endptr + 1;
- if (parse_uint_full(str, &val2, 0) == 0 &&
- val2 <= UINT64_MAX && val <= val2 &&
- val2 - val < OPTS_VISITOR_RANGE_MAX) {
- ov->range_next.u = val;
- ov->range_limit.u = val2;
- ov->list_mode = LM_UNSIGNED_INTERVAL;
-
- /* as if entering on the top */
- *obj = ov->range_next.u;
- return;
- }
- }
- }
- error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
- (ov->list_mode == LM_NONE) ? "a uint64 value" :
- "a uint64 value or range");
-}
-
-
-static void
-opts_type_size(Visitor *v, const char *name, uint64_t *obj, Error **errp)
-{
- OptsVisitor *ov = to_ov(v);
- const QemuOpt *opt;
- int64_t val;
- char *endptr;
-
- opt = lookup_scalar(ov, name, errp);
- if (!opt) {
- return;
- }
-
- val = qemu_strtosz_suffix(opt->str ? opt->str : "", &endptr,
- QEMU_STRTOSZ_DEFSUFFIX_B);
- if (val < 0 || *endptr) {
- error_setg(errp, QERR_INVALID_PARAMETER_VALUE, opt->name,
- "a size value representible as a non-negative int64");
- return;
- }
-
- *obj = val;
- processed(ov, name);
-}
-
-
-static void
-opts_optional(Visitor *v, const char *name, bool *present)
-{
- OptsVisitor *ov = to_ov(v);
-
- /* we only support a single mandatory scalar field in a list node */
- assert(ov->list_mode == LM_NONE);
- *present = (lookup_distinct(ov, name, NULL) != NULL);
-}
-
-
-static void
-opts_free(Visitor *v)
-{
- OptsVisitor *ov = to_ov(v);
-
- if (ov->unprocessed_opts != NULL) {
- g_hash_table_destroy(ov->unprocessed_opts);
- }
- g_free(ov->fake_id_opt);
- g_free(ov);
-}
-
-
-Visitor *
-opts_visitor_new(const QemuOpts *opts)
-{
- OptsVisitor *ov;
-
- ov = g_malloc0(sizeof *ov);
-
- ov->visitor.type = VISITOR_INPUT;
-
- ov->visitor.start_struct = &opts_start_struct;
- ov->visitor.check_struct = &opts_check_struct;
- ov->visitor.end_struct = &opts_end_struct;
-
- ov->visitor.start_list = &opts_start_list;
- ov->visitor.next_list = &opts_next_list;
- ov->visitor.end_list = &opts_end_list;
-
- ov->visitor.type_int64 = &opts_type_int64;
- ov->visitor.type_uint64 = &opts_type_uint64;
- ov->visitor.type_size = &opts_type_size;
- ov->visitor.type_bool = &opts_type_bool;
- ov->visitor.type_str = &opts_type_str;
-
- /* type_number() is not filled in, but this is not the first visitor to
- * skip some mandatory methods... */
-
- ov->visitor.optional = &opts_optional;
- ov->visitor.free = opts_free;
-
- ov->opts_root = opts;
-
- return &ov->visitor;
-}
diff --git a/tests/Makefile.include b/tests/Makefile.include
index 7625ef7..47c223b 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -35,8 +35,6 @@ check-unit-y += tests/test-string-output-visitor$(EXESUF)
gcov-files-test-string-output-visitor-y = qapi/string-output-visitor.c
check-unit-y += tests/test-qmp-event$(EXESUF)
gcov-files-test-qmp-event-y += qapi/qmp-event.c
-check-unit-y += tests/test-opts-visitor$(EXESUF)
-gcov-files-test-opts-visitor-y = qapi/opts-visitor.c
check-unit-y += tests/test-coroutine$(EXESUF)
gcov-files-test-coroutine-y = coroutine-$(CONFIG_COROUTINE_BACKEND).c
check-unit-y += tests/test-visitor-serialization$(EXESUF)
@@ -444,7 +442,7 @@ test-obj-y = tests/check-qint.o tests/check-qstring.o tests/check-qdict.o \
tests/test-qobject-input-visitor.o tests/test-qobject-input-strict.o \
tests/test-qmp-commands.o tests/test-visitor-serialization.o \
tests/test-x86-cpuid.o tests/test-mul64.o tests/test-int128.o \
- tests/test-opts-visitor.o tests/test-qmp-event.o \
+ tests/test-qmp-event.o \
tests/rcutorture.o tests/test-rcu-list.o \
tests/test-qdist.o \
tests/test-qht.o tests/qht-bench.o tests/test-qht-par.o
@@ -548,7 +546,6 @@ tests/test-qobject-input-visitor$(EXESUF): tests/test-qobject-input-visitor.o $(
tests/test-qobject-input-strict$(EXESUF): tests/test-qobject-input-strict.o $(test-qapi-obj-y)
tests/test-qmp-commands$(EXESUF): tests/test-qmp-commands.o tests/test-qmp-marshal.o $(test-qapi-obj-y)
tests/test-visitor-serialization$(EXESUF): tests/test-visitor-serialization.o $(test-qapi-obj-y)
-tests/test-opts-visitor$(EXESUF): tests/test-opts-visitor.o $(test-qapi-obj-y)
tests/test-mul64$(EXESUF): tests/test-mul64.o $(test-util-obj-y)
tests/test-bitops$(EXESUF): tests/test-bitops.o $(test-util-obj-y)
diff --git a/tests/test-opts-visitor.c b/tests/test-opts-visitor.c
deleted file mode 100644
index 0a9e75f..0000000
--- a/tests/test-opts-visitor.c
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
- * Options Visitor unit-tests.
- *
- * Copyright (C) 2013 Red Hat, Inc.
- *
- * Authors:
- * Laszlo Ersek <lersek@redhat.com> (based on test-string-output-visitor)
- *
- * This work is licensed under the terms of the GNU GPL, version 2 or later.
- * See the COPYING file in the top-level directory.
- */
-
-#include "qemu/osdep.h"
-
-#include "qemu/config-file.h" /* qemu_add_opts() */
-#include "qemu/option.h" /* qemu_opts_parse() */
-#include "qapi/error.h"
-#include "qapi/opts-visitor.h" /* opts_visitor_new() */
-#include "test-qapi-visit.h" /* visit_type_UserDefOptions() */
-
-static QemuOptsList userdef_opts = {
- .name = "userdef",
- .head = QTAILQ_HEAD_INITIALIZER(userdef_opts.head),
- .desc = { { 0 } } /* validated with OptsVisitor */
-};
-
-/* fixture (= glib test case context) and test case manipulation */
-
-typedef struct OptsVisitorFixture {
- UserDefOptions *userdef;
- Error *err;
-} OptsVisitorFixture;
-
-
-static void
-setup_fixture(OptsVisitorFixture *f, gconstpointer test_data)
-{
- const char *opts_string = test_data;
- QemuOpts *opts;
- Visitor *v;
-
- opts = qemu_opts_parse(qemu_find_opts("userdef"), opts_string, false,
- NULL);
- g_assert(opts != NULL);
-
- v = opts_visitor_new(opts);
- visit_type_UserDefOptions(v, NULL, &f->userdef, &f->err);
- visit_free(v);
- qemu_opts_del(opts);
-}
-
-
-static void
-teardown_fixture(OptsVisitorFixture *f, gconstpointer test_data)
-{
- qapi_free_UserDefOptions(f->userdef);
- error_free(f->err);
-}
-
-
-static void
-add_test(const char *testpath,
- void (*test_func)(OptsVisitorFixture *f, gconstpointer test_data),
- gconstpointer test_data)
-{
- g_test_add(testpath, OptsVisitorFixture, test_data, setup_fixture,
- test_func, teardown_fixture);
-}
-
-/* test output evaluation */
-
-static void
-expect_ok(OptsVisitorFixture *f, gconstpointer test_data)
-{
- g_assert(f->err == NULL);
- g_assert(f->userdef != NULL);
-}
-
-
-static void
-expect_fail(OptsVisitorFixture *f, gconstpointer test_data)
-{
- g_assert(f->err != NULL);
-
- /* The error message is printed when this test utility is invoked directly
- * (ie. without gtester) and the --verbose flag is passed:
- *
- * tests/test-opts-visitor --verbose
- */
- g_test_message("'%s': %s", (const char *)test_data,
- error_get_pretty(f->err));
-}
-
-
-static void
-test_value(OptsVisitorFixture *f, gconstpointer test_data)
-{
- uint64_t magic, bitval;
- intList *i64;
- uint64List *u64;
- uint16List *u16;
-
- expect_ok(f, test_data);
-
- magic = 0;
- for (i64 = f->userdef->i64; i64 != NULL; i64 = i64->next) {
- g_assert(-16 <= i64->value && i64->value < 64-16);
- bitval = 1ull << (i64->value + 16);
- g_assert((magic & bitval) == 0);
- magic |= bitval;
- }
- g_assert(magic == 0xDEADBEEF);
-
- magic = 0;
- for (u64 = f->userdef->u64; u64 != NULL; u64 = u64->next) {
- g_assert(u64->value < 64);
- bitval = 1ull << u64->value;
- g_assert((magic & bitval) == 0);
- magic |= bitval;
- }
- g_assert(magic == 0xBADC0FFEE0DDF00DULL);
-
- magic = 0;
- for (u16 = f->userdef->u16; u16 != NULL; u16 = u16->next) {
- g_assert(u16->value < 64);
- bitval = 1ull << u16->value;
- g_assert((magic & bitval) == 0);
- magic |= bitval;
- }
- g_assert(magic == 0xD15EA5E);
-}
-
-
-static void
-expect_i64_min(OptsVisitorFixture *f, gconstpointer test_data)
-{
- expect_ok(f, test_data);
- g_assert(f->userdef->has_i64);
- g_assert(f->userdef->i64->next == NULL);
- g_assert(f->userdef->i64->value == INT64_MIN);
-}
-
-
-static void
-expect_i64_max(OptsVisitorFixture *f, gconstpointer test_data)
-{
- expect_ok(f, test_data);
- g_assert(f->userdef->has_i64);
- g_assert(f->userdef->i64->next == NULL);
- g_assert(f->userdef->i64->value == INT64_MAX);
-}
-
-
-static void
-expect_zero(OptsVisitorFixture *f, gconstpointer test_data)
-{
- expect_ok(f, test_data);
- g_assert(f->userdef->has_u64);
- g_assert(f->userdef->u64->next == NULL);
- g_assert(f->userdef->u64->value == 0);
-}
-
-
-static void
-expect_u64_max(OptsVisitorFixture *f, gconstpointer test_data)
-{
- expect_ok(f, test_data);
- g_assert(f->userdef->has_u64);
- g_assert(f->userdef->u64->next == NULL);
- g_assert(f->userdef->u64->value == UINT64_MAX);
-}
-
-/* test cases */
-
-int
-main(int argc, char **argv)
-{
- g_test_init(&argc, &argv, NULL);
-
- qemu_add_opts(&userdef_opts);
-
- /* Three hexadecimal magic numbers, "dead beef", "bad coffee, odd food" and
- * "disease", from
- * <http://en.wikipedia.org/wiki/Magic_number_%28programming%29>, were
- * converted to binary and dissected into bit ranges. Each magic number is
- * going to be recomposed using the lists called "i64", "u64" and "u16",
- * respectively.
- *
- * (Note that these types pertain to the individual bit shift counts, not
- * the magic numbers themselves; the intent is to exercise opts_type_int()
- * and opts_type_uint64().)
- *
- * The "i64" shift counts have been decreased by 16 (decimal) in order to
- * test negative values as well. Finally, the full list of QemuOpt elements
- * has been permuted with "shuf".
- *
- * Both "i64" and "u64" have some (distinct) single-element ranges
- * represented as both "a" and "a-a". "u16" is a special case of "i64" (see
- * visit_type_uint16()), so it wouldn't add a separate test in this regard.
- */
-
- add_test("/visitor/opts/flatten/value", &test_value,
- "i64=-1-0,u64=12-16,u64=2-3,i64=-11--9,u64=57,u16=9,i64=5-5,"
- "u16=1-4,u16=20,u64=63-63,i64=-16--13,u64=50-52,i64=14-15,u16=11,"
- "i64=7,u16=18,i64=2-3,u16=6,u64=54-55,u64=0,u64=18-20,u64=33-43,"
- "i64=9-12,u16=26-27,u64=59-61,u16=13-16,u64=29-31,u64=22-23,"
- "u16=24,i64=-7--3");
-
- add_test("/visitor/opts/i64/val1/errno", &expect_fail,
- "i64=0x8000000000000000");
- add_test("/visitor/opts/i64/val1/empty", &expect_fail, "i64=");
- add_test("/visitor/opts/i64/val1/trailing", &expect_fail, "i64=5z");
- add_test("/visitor/opts/i64/nonlist", &expect_fail, "i64x=5-6");
- add_test("/visitor/opts/i64/val2/errno", &expect_fail,
- "i64=0x7fffffffffffffff-0x8000000000000000");
- add_test("/visitor/opts/i64/val2/empty", &expect_fail, "i64=5-");
- add_test("/visitor/opts/i64/val2/trailing", &expect_fail, "i64=5-6z");
- add_test("/visitor/opts/i64/range/empty", &expect_fail, "i64=6-5");
- add_test("/visitor/opts/i64/range/minval", &expect_i64_min,
- "i64=-0x8000000000000000--0x8000000000000000");
- add_test("/visitor/opts/i64/range/maxval", &expect_i64_max,
- "i64=0x7fffffffffffffff-0x7fffffffffffffff");
-
- add_test("/visitor/opts/u64/val1/errno", &expect_fail, "u64=-1");
- add_test("/visitor/opts/u64/val1/empty", &expect_fail, "u64=");
- add_test("/visitor/opts/u64/val1/trailing", &expect_fail, "u64=5z");
- add_test("/visitor/opts/u64/nonlist", &expect_fail, "u64x=5-6");
- add_test("/visitor/opts/u64/val2/errno", &expect_fail,
- "u64=0xffffffffffffffff-0x10000000000000000");
- add_test("/visitor/opts/u64/val2/empty", &expect_fail, "u64=5-");
- add_test("/visitor/opts/u64/val2/trailing", &expect_fail, "u64=5-6z");
- add_test("/visitor/opts/u64/range/empty", &expect_fail, "u64=6-5");
- add_test("/visitor/opts/u64/range/minval", &expect_zero, "u64=0-0");
- add_test("/visitor/opts/u64/range/maxval", &expect_u64_max,
- "u64=0xffffffffffffffff-0xffffffffffffffff");
-
- /* Test maximum range sizes. The macro value is open-coded here
- * *intentionally*; the test case must use concrete values by design. If
- * OPTS_VISITOR_RANGE_MAX is changed, the following values need to be
- * recalculated as well. The assert and this comment should help with it.
- */
- g_assert(OPTS_VISITOR_RANGE_MAX == 65536);
-
- /* The unsigned case is simple, a u64-u64 difference can always be
- * represented as a u64.
- */
- add_test("/visitor/opts/u64/range/max", &expect_ok, "u64=0-65535");
- add_test("/visitor/opts/u64/range/2big", &expect_fail, "u64=0-65536");
-
- /* The same cannot be said about an i64-i64 difference. */
- add_test("/visitor/opts/i64/range/max/pos/a", &expect_ok,
- "i64=0x7fffffffffff0000-0x7fffffffffffffff");
- add_test("/visitor/opts/i64/range/max/pos/b", &expect_ok,
- "i64=0x7ffffffffffeffff-0x7ffffffffffffffe");
- add_test("/visitor/opts/i64/range/2big/pos", &expect_fail,
- "i64=0x7ffffffffffeffff-0x7fffffffffffffff");
- add_test("/visitor/opts/i64/range/max/neg/a", &expect_ok,
- "i64=-0x8000000000000000--0x7fffffffffff0001");
- add_test("/visitor/opts/i64/range/max/neg/b", &expect_ok,
- "i64=-0x7fffffffffffffff--0x7fffffffffff0000");
- add_test("/visitor/opts/i64/range/2big/neg", &expect_fail,
- "i64=-0x8000000000000000--0x7fffffffffff0000");
- add_test("/visitor/opts/i64/range/2big/full", &expect_fail,
- "i64=-0x8000000000000000-0x7fffffffffffffff");
-
- g_test_run();
- return 0;
-}
diff --git a/vl.c b/vl.c
index 215a6f9..469cf8d 100644
--- a/vl.c
+++ b/vl.c
@@ -115,7 +115,6 @@ int main(int argc, char **argv)
#include "ui/qemu-spice.h"
#include "qapi/string-input-visitor.h"
-#include "qapi/opts-visitor.h"
#include "qom/object_interfaces.h"
#include "qapi-event.h"
#include "exec/semihost.h"
--
2.7.4
^ permalink raw reply related [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict Daniel P. Berrange
@ 2016-09-27 21:22 ` Eric Blake
0 siblings, 0 replies; 32+ messages in thread
From: Eric Blake @ 2016-09-27 21:22 UTC (permalink / raw)
To: Daniel P. Berrange, qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber
[-- Attachment #1: Type: text/plain, Size: 3315 bytes --]
On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> The qdict_flatten() method will take a dict whose elements are
> further nested dicts/lists and flatten them by concatenating
> keys.
>
> The qdict_crumple() method aims to do the reverse, taking a flat
> qdict, and turning it into a set of nested dicts/lists. It will
> apply nesting based on the key name, with a '.' indicating a
> new level in the hierarchy. If the keys in the nested structure
> are all numeric, it will create a list, otherwise it will create
> a dict.
>
> If the keys are a mixture of numeric and non-numeric, or the
> numeric keys are not in strictly ascending order, an error will
> be reported.
>
>
> The intent of this function is that it allows a set of QemuOpts
> to be turned into a nested data structure that mirrors the nesting
> used when the same object is defined over QMP.
>
> Reviewed-by: Kevin Wolf <kwolf@redhat.com>
> Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> ---
> +
> +/**
> + * 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.
> + *
> + * eg
s/eg/e.g./ or just spell it as 'for example'
> +static int qdict_is_list(QDict *maybe_list, Error **errp)
> +
> + /* NB this isn't a perfect check - eg it won't catch
Another such use.
> + * 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 indexes are not contiguous, "
s/indexes/indices/ ? (my spellchecker likes both, but indexes is a sign
that modern English speakers are getting lazy and drifting away from Latin)
> +/**
> + * qdict_crumple:
> + * @src: the original flat dictionary (only scalar values) to crumple
> + * @recursive: true to recursively crumple nested dictionaries
> + * For example, an input of:
> + *
> + * { 'foo.0.bar': 'one', 'foo.0.wizz': '1',
> + * 'foo.1.bar': 'two', 'foo.1.wizz': '2' }
> + *
> + * will result in any output of:
s/any/an/
> + *
> + * {
> + * '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. eg, "foo.0.bar" and "foo.eek.bar".
> + * - If keys in @src imply that a particular level is a list,
> + * but the indexes are non-contigous. eg "foo.0.bar" and
s/contigous/contiguous/
and another pesky 'eg'
Modulo typo fixes and potential grammar changes,
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options Daniel P. Berrange
@ 2016-09-27 22:03 ` Eric Blake
2016-09-28 9:35 ` Daniel P. Berrange
0 siblings, 1 reply; 32+ messages in thread
From: Eric Blake @ 2016-09-27 22:03 UTC (permalink / raw)
To: Daniel P. Berrange, qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber
[-- Attachment #1: Type: text/plain, Size: 6296 bytes --]
On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> If given an option string such as
>
> size=1024,nodes=10,nodes=4-5,nodes=1-2,policy=bind
>
> the qemu_opts_to_qdict() method will currently overwrite
> the values for repeated option keys, so only the last
> value is in the returned dict:
>
> size=1024
> nodes=1-2
> policy=bind
>
> This adds the ability for the caller to ask that the
> repeated keys be turned into list indexes:
>
> size=1024
> nodes.0=10
> nodes.1=4-5
> nodes.2=1-2
> policy=bind
>
> Note that the conversion has no way of knowing whether
> any given key is expected to be a list upfront - it can
> only figure that out when seeing the first duplicated
> key. Thus the caller has to be prepared to deal with the
> fact that if a key 'foo' is a list, then the returned
> qdict may contain either 'foo' (if only a single instance
> of the key was seen) or 'foo.NN' (if multiple instances
> of the key were seen).
>
> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> ---
If I'm not mistaken, this policy adds a new policy, but all existing
clients use the old policy, and the new policy is exercised only by the
testsuite additions. Might be useful to mention that in the commit
message, rather than making me read the whole commit before guessing that.
> +++ b/blockdev.c
> @@ -911,7 +911,8 @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
>
> /* Get a QDict for processing the options */
> bs_opts = qdict_new();
> - qemu_opts_to_qdict(all_opts, bs_opts);
> + qemu_opts_to_qdict(all_opts, bs_opts,
> + QEMU_OPTS_REPEAT_POLICY_LAST);
git send-email/format-patch -O/path/to/file (or the corresponding config
option) allows you to sort the diff to put the interesting stuff first
(in this case, the new enum).
> +++ b/include/qemu/option.h
> @@ -125,7 +125,13 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
> int permit_abbrev);
> QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
> Error **errp);
> -QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict);
> +typedef enum {
> + QEMU_OPTS_REPEAT_POLICY_LAST,
> + QEMU_OPTS_REPEAT_POLICY_LIST,
Hmm. I suspect this subtle difference (one vowel) to be the source of
typo bugs. Can we come up with more obvious policy names, such as
LAST_ONLY vs. INTO_LIST? Except that doing that makes it harder to fit
80 columns. So up to you if you want to ignore me here.
On the other hand, a documentation comment here would go a long ways to
helping future readers:
LAST: last occurrence of a duplicate option silently overwrites all earlier
LIST: each occurrence of a duplicate option converts it into a list
maybe you also want to add:
ERROR: an occurrence of a duplicate option is considered an error
Also, while you turn 'foo=a,foo=b' into 'foo.0=a,foo.1=b', does your
code correctly handle the cases of 'foo.0=a,foo=b' and 'foo=a,foo.1=b'?
(And what IS the correct handling of those cases logically supposed to be?)
> +++ b/tests/test-qemu-opts.c
> @@ -421,6 +421,45 @@ static void test_qemu_opts_set(void)
> g_assert(opts == NULL);
> }
>
> +
> +static void test_qemu_opts_to_qdict(void)
> +{
Here would be a good place to test the two mixed-use optstrings I
mentioned above (inconsistent use of plain vs. list syntax).
> +}
> +
> int main(int argc, char *argv[])
> {
> +++ b/util/qemu-option.c
> @@ -1058,10 +1058,12 @@ void qemu_opts_absorb_qdict(QemuOpts *opts, QDict *qdict, Error **errp)
> * TODO We'll want to use types appropriate for opt->desc->type, but
> * this is enough for now.
> */
> -QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
> +QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict,
> + QemuOptsRepeatPolicy repeatPolicy)
> {
> QemuOpt *opt;
> - QObject *val;
> + QObject *val, *prevval;
> + QDict *lists = qdict_new();
>
> if (!qdict) {
> qdict = qdict_new();
> @@ -1070,9 +1072,42 @@ QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict)
> qdict_put(qdict, "id", qstring_from_str(opts->id));
> }
> QTAILQ_FOREACH(opt, &opts->head, next) {
> + gchar *key = NULL;
> val = QOBJECT(qstring_from_str(opt->str));
> - qdict_put_obj(qdict, opt->name, val);
> + switch (repeatPolicy) {
> + case QEMU_OPTS_REPEAT_POLICY_LIST:
> + if (qdict_haskey(lists, opt->name)) {
> + /* Current val goes into 'foo.N' */
> + int64_t max = qdict_get_int(lists, opt->name);
> + max++;
> + key = g_strdup_printf("%s.%" PRId64, opt->name, max);
> + qdict_put_obj(lists, opt->name, QOBJECT(qint_from_int(max)));
> + qdict_put_obj(qdict, key, val);
> + } else if (qdict_haskey(qdict, opt->name)) {
> + /* Move previous val from 'foo' to 'foo.0' */
> + prevval = qdict_get(qdict, opt->name);
> + qobject_incref(prevval);
> + qdict_del(qdict, opt->name);
> + key = g_strdup_printf("%s.0", opt->name);
> + qdict_put_obj(qdict, key, prevval);
> + g_free(key);
> +
> + /* Current val goes into 'foo.1' */
> + key = g_strdup_printf("%s.1", opt->name);
> + qdict_put_obj(lists, opt->name, QOBJECT(qint_from_int(1)));
> + qdict_put_obj(qdict, key, val);
> + } else {
> + qdict_put_obj(qdict, key ? key : opt->name, val);
Dead ?: here; key is always NULL.
> + }
> + break;
> +
> + case QEMU_OPTS_REPEAT_POLICY_LAST:
> + qdict_put_obj(qdict, key ? key : opt->name, val);
Likewise.
> + break;
> + }
> + g_free(key);
> }
> + QDECREF(lists);
> return qdict;
> }
>
>
Overall, I like the idea.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor Daniel P. Berrange
@ 2016-09-27 22:05 ` Eric Blake
0 siblings, 0 replies; 32+ messages in thread
From: Eric Blake @ 2016-09-27 22:05 UTC (permalink / raw)
To: Daniel P. Berrange, qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber
[-- Attachment #1: Type: text/plain, Size: 587 bytes --]
On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> Allow tracing of the operation of visitors
Ooooh, shiny!
>
> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> ---
> Makefile.objs | 1 +
> qapi/qapi-visit-core.c | 27 +++++++++++++++++++++++++++
> qapi/trace-events | 33 +++++++++++++++++++++++++++++++++
> 3 files changed, 61 insertions(+)
> create mode 100644 qapi/trace-events
>
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests Daniel P. Berrange
@ 2016-09-27 22:10 ` Eric Blake
2016-09-27 22:12 ` Eric Blake
0 siblings, 1 reply; 32+ messages in thread
From: Eric Blake @ 2016-09-27 22:10 UTC (permalink / raw)
To: Daniel P. Berrange, qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber
[-- Attachment #1: Type: text/plain, Size: 732 bytes --]
On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> The input_visitor_test_add() method was accepting an instance
> of 'TestInputVisitorData' and passing it as the 'user_data'
> parameter to test functions. The main 'TestInputVisitorData'
> instance that was actually used, was meanwhile being allocated
> automatically by the test framework fixture setup.
>
> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> ---
> tests/test-qobject-input-visitor.c | 76 ++++++++++++++++----------------------
> 1 file changed, 32 insertions(+), 44 deletions(-)
>
Reviewed-by: Eric Blake <eblake@redhat.com>
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests
2016-09-27 22:10 ` Eric Blake
@ 2016-09-27 22:12 ` Eric Blake
2016-09-28 9:35 ` Daniel P. Berrange
0 siblings, 1 reply; 32+ messages in thread
From: Eric Blake @ 2016-09-27 22:12 UTC (permalink / raw)
To: Daniel P. Berrange, qemu-devel
Cc: qemu-block, Markus Armbruster, Max Reitz, Paolo Bonzini,
Andreas Färber
[-- Attachment #1: Type: text/plain, Size: 1108 bytes --]
On 09/27/2016 05:10 PM, Eric Blake wrote:
> On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
>> The input_visitor_test_add() method was accepting an instance
>> of 'TestInputVisitorData' and passing it as the 'user_data'
>> parameter to test functions. The main 'TestInputVisitorData'
>> instance that was actually used, was meanwhile being allocated
>> automatically by the test framework fixture setup.
>>
>> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
>> ---
>> tests/test-qobject-input-visitor.c | 76 ++++++++++++++++----------------------
>> 1 file changed, 32 insertions(+), 44 deletions(-)
>>
>
> Reviewed-by: Eric Blake <eblake@redhat.com>
>
Having said that, I note that ALL callers now pass NULL for user_data.
If you plan on using it later in the series for something other than
NULL for some of the (new?) tests added at that point, it would be wise
to say so in the commit message; if not, I would suggest eliminating the
parameter altogether.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 604 bytes --]
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options
2016-09-27 22:03 ` Eric Blake
@ 2016-09-28 9:35 ` Daniel P. Berrange
2016-09-28 13:44 ` Daniel P. Berrange
0 siblings, 1 reply; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-28 9:35 UTC (permalink / raw)
To: Eric Blake
Cc: qemu-devel, qemu-block, Markus Armbruster, Max Reitz,
Paolo Bonzini, Andreas Färber
On Tue, Sep 27, 2016 at 05:03:17PM -0500, Eric Blake wrote:
> On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> > If given an option string such as
> >
> > size=1024,nodes=10,nodes=4-5,nodes=1-2,policy=bind
> >
> > the qemu_opts_to_qdict() method will currently overwrite
> > the values for repeated option keys, so only the last
> > value is in the returned dict:
> >
> > size=1024
> > nodes=1-2
> > policy=bind
> >
> > This adds the ability for the caller to ask that the
> > repeated keys be turned into list indexes:
> >
> > size=1024
> > nodes.0=10
> > nodes.1=4-5
> > nodes.2=1-2
> > policy=bind
> >
> > Note that the conversion has no way of knowing whether
> > any given key is expected to be a list upfront - it can
> > only figure that out when seeing the first duplicated
> > key. Thus the caller has to be prepared to deal with the
> > fact that if a key 'foo' is a list, then the returned
> > qdict may contain either 'foo' (if only a single instance
> > of the key was seen) or 'foo.NN' (if multiple instances
> > of the key were seen).
> >
> > Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> > ---
>
> If I'm not mistaken, this policy adds a new policy, but all existing
> clients use the old policy, and the new policy is exercised only by the
> testsuite additions. Might be useful to mention that in the commit
> message, rather than making me read the whole commit before guessing that.
Correct, this will only be used in combination with the
later qdict_crumple method.
> > +++ b/include/qemu/option.h
> > @@ -125,7 +125,13 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
> > int permit_abbrev);
> > QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
> > Error **errp);
> > -QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict);
> > +typedef enum {
> > + QEMU_OPTS_REPEAT_POLICY_LAST,
> > + QEMU_OPTS_REPEAT_POLICY_LIST,
>
> Hmm. I suspect this subtle difference (one vowel) to be the source of
> typo bugs. Can we come up with more obvious policy names, such as
> LAST_ONLY vs. INTO_LIST? Except that doing that makes it harder to fit
> 80 columns. So up to you if you want to ignore me here.
I'll use POLICY_LAST and POLICY_ALL.
> ERROR: an occurrence of a duplicate option is considered an error
Yeah, sure can add that easily.
> Also, while you turn 'foo=a,foo=b' into 'foo.0=a,foo.1=b', does your
> code correctly handle the cases of 'foo.0=a,foo=b' and 'foo=a,foo.1=b'?
> (And what IS the correct handling of those cases logically supposed to be?)
I'd be inclined to say that is an error. We're only doing this
hack to maintain compatibility with existing OptsVisitor
semantics for repeated options, and the scenario you illustrate
is not possible with OptsVisitor. So I say we keep it an error.
Either use the old syntax or the new syntax, but not mix them
ever.
Regards,
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://entangle-photo.org -o- http://search.cpan.org/~danberr/ :|
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests
2016-09-27 22:12 ` Eric Blake
@ 2016-09-28 9:35 ` Daniel P. Berrange
0 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-28 9:35 UTC (permalink / raw)
To: Eric Blake
Cc: qemu-devel, qemu-block, Markus Armbruster, Max Reitz,
Paolo Bonzini, Andreas Färber
On Tue, Sep 27, 2016 at 05:12:04PM -0500, Eric Blake wrote:
> On 09/27/2016 05:10 PM, Eric Blake wrote:
> > On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> >> The input_visitor_test_add() method was accepting an instance
> >> of 'TestInputVisitorData' and passing it as the 'user_data'
> >> parameter to test functions. The main 'TestInputVisitorData'
> >> instance that was actually used, was meanwhile being allocated
> >> automatically by the test framework fixture setup.
> >>
> >> Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> >> ---
> >> tests/test-qobject-input-visitor.c | 76 ++++++++++++++++----------------------
> >> 1 file changed, 32 insertions(+), 44 deletions(-)
> >>
> >
> > Reviewed-by: Eric Blake <eblake@redhat.com>
> >
>
> Having said that, I note that ALL callers now pass NULL for user_data.
> If you plan on using it later in the series for something other than
> NULL for some of the (new?) tests added at that point, it would be wise
> to say so in the commit message; if not, I would suggest eliminating the
> parameter altogether.
Yep, later patches use this parameter for real, so I needed to move
this bogus usage out of the way.
Regards,
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://entangle-photo.org -o- http://search.cpan.org/~danberr/ :|
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options
2016-09-28 9:35 ` Daniel P. Berrange
@ 2016-09-28 13:44 ` Daniel P. Berrange
0 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-09-28 13:44 UTC (permalink / raw)
To: Eric Blake
Cc: qemu-block, Markus Armbruster, qemu-devel, Max Reitz,
Paolo Bonzini, Andreas Färber
On Wed, Sep 28, 2016 at 10:35:05AM +0100, Daniel P. Berrange wrote:
> On Tue, Sep 27, 2016 at 05:03:17PM -0500, Eric Blake wrote:
> > On 09/27/2016 08:13 AM, Daniel P. Berrange wrote:
> > > If given an option string such as
> > >
> > > size=1024,nodes=10,nodes=4-5,nodes=1-2,policy=bind
> > >
> > > the qemu_opts_to_qdict() method will currently overwrite
> > > the values for repeated option keys, so only the last
> > > value is in the returned dict:
> > >
> > > size=1024
> > > nodes=1-2
> > > policy=bind
> > >
> > > This adds the ability for the caller to ask that the
> > > repeated keys be turned into list indexes:
> > >
> > > size=1024
> > > nodes.0=10
> > > nodes.1=4-5
> > > nodes.2=1-2
> > > policy=bind
> > >
> > > Note that the conversion has no way of knowing whether
> > > any given key is expected to be a list upfront - it can
> > > only figure that out when seeing the first duplicated
> > > key. Thus the caller has to be prepared to deal with the
> > > fact that if a key 'foo' is a list, then the returned
> > > qdict may contain either 'foo' (if only a single instance
> > > of the key was seen) or 'foo.NN' (if multiple instances
> > > of the key were seen).
> > >
> > > Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
> > > ---
> >
> > If I'm not mistaken, this policy adds a new policy, but all existing
> > clients use the old policy, and the new policy is exercised only by the
> > testsuite additions. Might be useful to mention that in the commit
> > message, rather than making me read the whole commit before guessing that.
>
> Correct, this will only be used in combination with the
> later qdict_crumple method.
>
> > > +++ b/include/qemu/option.h
> > > @@ -125,7 +125,13 @@ void qemu_opts_set_defaults(QemuOptsList *list, const char *params,
> > > int permit_abbrev);
> > > QemuOpts *qemu_opts_from_qdict(QemuOptsList *list, const QDict *qdict,
> > > Error **errp);
> > > -QDict *qemu_opts_to_qdict(QemuOpts *opts, QDict *qdict);
> > > +typedef enum {
> > > + QEMU_OPTS_REPEAT_POLICY_LAST,
> > > + QEMU_OPTS_REPEAT_POLICY_LIST,
> >
> > Hmm. I suspect this subtle difference (one vowel) to be the source of
> > typo bugs. Can we come up with more obvious policy names, such as
> > LAST_ONLY vs. INTO_LIST? Except that doing that makes it harder to fit
> > 80 columns. So up to you if you want to ignore me here.
>
> I'll use POLICY_LAST and POLICY_ALL.
>
> > ERROR: an occurrence of a duplicate option is considered an error
>
> Yeah, sure can add that easily.
>
> > Also, while you turn 'foo=a,foo=b' into 'foo.0=a,foo.1=b', does your
> > code correctly handle the cases of 'foo.0=a,foo=b' and 'foo=a,foo.1=b'?
> > (And what IS the correct handling of those cases logically supposed to be?)
>
> I'd be inclined to say that is an error. We're only doing this
> hack to maintain compatibility with existing OptsVisitor
> semantics for repeated options, and the scenario you illustrate
> is not possible with OptsVisitor. So I say we keep it an error.
> Either use the old syntax or the new syntax, but not mix them
> ever.
Having looked at this again, I don't think this code should try to
detect 'foo.0=a,foo=b', because qemu_opts_to_qdict() is not placing
an semantic interpretation on the keys. Such semantics are defined
by the qdict_crumple() method, so that's where I'll have to do such
error detection.
Regards,
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://entangle-photo.org -o- http://search.cpan.org/~danberr/ :|
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
` (18 preceding siblings ...)
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 19/19] qapi: delete unused OptsVisitor code Daniel P. Berrange
@ 2016-10-20 15:06 ` Markus Armbruster
2016-10-20 15:14 ` Daniel P. Berrange
2016-10-21 9:35 ` Markus Armbruster
19 siblings, 2 replies; 32+ messages in thread
From: Markus Armbruster @ 2016-10-20 15:06 UTC (permalink / raw)
To: Daniel P. Berrange
Cc: qemu-devel, qemu-block, Max Reitz, Paolo Bonzini,
Andreas Färber, Kevin Wolf
I've warmed quite a bit to this series while reviewing it. In
particular, I've come around to like structuring the command line ->
QAPI pipeline exactly like the JSON -> QAPI pipeline, namely 1. parse
into QObject, 2. convert to QAPI with the QObject input visitor.
QObject serves as abstract syntax here. The differences between JSON
and command line result in different abstract syntax, which in turn
necessitates two cases in the input visitor. The series adds more than
two, to cater for option visitor funnies. Perhaps we can do without
some of them.
The other way to skin this cat would be an improved options visitor.
Has its advantages and disadvantages, but the big one is that you
already did the work for QObject input visitor solution.
The one major issue I have with the series is that it adds to the
growing body of QemuOpts hacks/workarounds.
We've pushed QemuOpts beyond well its design limits. What started as a
simple store for scalar configuration parameters structured as key=value
lists, plus command line and configuration file syntax, has grown three
ways to specify lists (repeated keys, basically an implementation
accident that got pressed into service; special integer list syntax in
the options visitor, later adopted by the string input visitor,
hopefully compatibly; and the block layer's dotted key convention) and a
way to specify arbitrary complex values (block layer's dotted key
convention again). Of these, only "repeated keys" is in QemuOpts
proper, all the others are bolted on and used only when needed. How
they interact is not obvious.
This series marries all the bolted-on stuff and puts it in the QObject
visitor. That's actually an improvement of sorts; at least it's in just
two places now. But it's still a smorgasbord of syntactical/semantic
options.
I feel it's time to stop working around the design limits of QemuOpts
and start replacing them by something that serves our current needs. We
basically need the expressive power of JSON on the command line. Syntax
is debatable, but it should be *one* concrete command-line syntax,
parsed by *one* parser into *one* kind of abstract syntax tree, where
the only optional variations are the ones forced upon us by backward
compatibility.
We can't do this for 2.8, obviously. We can try for 2.9. I have pretty
specific ideas on how it should be done, so I guess it's only fair I
give it a try myself.
I know the block layer wants to use bits of this series to save some
coding work for certain features targeting 2.8. I have no objections as
long as it doesn't create new ABI. Exception: I'm okay with applying
dotted key convention to more of the same, e.g. new block drivers.
Sounds sane?
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties
2016-10-20 15:06 ` [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Markus Armbruster
@ 2016-10-20 15:14 ` Daniel P. Berrange
2016-10-21 9:35 ` Markus Armbruster
1 sibling, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-10-20 15:14 UTC (permalink / raw)
To: Markus Armbruster
Cc: qemu-devel, qemu-block, Max Reitz, Paolo Bonzini,
Andreas Färber, Kevin Wolf
On Thu, Oct 20, 2016 at 05:06:33PM +0200, Markus Armbruster wrote:
> I've warmed quite a bit to this series while reviewing it. In
> particular, I've come around to like structuring the command line ->
> QAPI pipeline exactly like the JSON -> QAPI pipeline, namely 1. parse
> into QObject, 2. convert to QAPI with the QObject input visitor.
> QObject serves as abstract syntax here. The differences between JSON
> and command line result in different abstract syntax, which in turn
> necessitates two cases in the input visitor. The series adds more than
> two, to cater for option visitor funnies. Perhaps we can do without
> some of them.
>
> The other way to skin this cat would be an improved options visitor.
> Has its advantages and disadvantages, but the big one is that you
> already did the work for QObject input visitor solution.
>
> The one major issue I have with the series is that it adds to the
> growing body of QemuOpts hacks/workarounds.
>
> We've pushed QemuOpts beyond well its design limits. What started as a
> simple store for scalar configuration parameters structured as key=value
> lists, plus command line and configuration file syntax, has grown three
> ways to specify lists (repeated keys, basically an implementation
> accident that got pressed into service; special integer list syntax in
> the options visitor, later adopted by the string input visitor,
> hopefully compatibly; and the block layer's dotted key convention) and a
> way to specify arbitrary complex values (block layer's dotted key
> convention again). Of these, only "repeated keys" is in QemuOpts
> proper, all the others are bolted on and used only when needed. How
> they interact is not obvious.
>
> This series marries all the bolted-on stuff and puts it in the QObject
> visitor. That's actually an improvement of sorts; at least it's in just
> two places now. But it's still a smorgasbord of syntactical/semantic
> options.
>
> I feel it's time to stop working around the design limits of QemuOpts
> and start replacing them by something that serves our current needs. We
> basically need the expressive power of JSON on the command line. Syntax
> is debatable, but it should be *one* concrete command-line syntax,
> parsed by *one* parser into *one* kind of abstract syntax tree, where
> the only optional variations are the ones forced upon us by backward
> compatibility.
>
> We can't do this for 2.8, obviously. We can try for 2.9. I have pretty
> specific ideas on how it should be done, so I guess it's only fair I
> give it a try myself.
>
> I know the block layer wants to use bits of this series to save some
> coding work for certain features targeting 2.8. I have no objections as
> long as it doesn't create new ABI. Exception: I'm okay with applying
> dotted key convention to more of the same, e.g. new block drivers.
>
> Sounds sane?
It is all fine with me.
Of the patch series proposed, I think patches 1->6 ought to be safe to
take for 2.8, without exposing new ABI:
1. option: make parse_option_bool/number non-static
2. qdict: implement a qdict_crumple method for un-flattening a dict
3. qapi: add trace events for visitor
4. qapi: rename QmpInputVisitor to QObjectInputVisitor
5. qapi: rename QmpOutputVisitor to QObjectOutputVisitor
6. qapi: don't pass two copies of TestInputVisitorData to tests
The rest are clearly not an option for 2.8 since freeze is barely
1 week away, and I'm travelling all next week
Regards,
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://entangle-photo.org -o- http://search.cpan.org/~danberr/ :|
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties
2016-10-20 15:06 ` [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Markus Armbruster
2016-10-20 15:14 ` Daniel P. Berrange
@ 2016-10-21 9:35 ` Markus Armbruster
2016-10-21 9:38 ` Daniel P. Berrange
1 sibling, 1 reply; 32+ messages in thread
From: Markus Armbruster @ 2016-10-21 9:35 UTC (permalink / raw)
To: Daniel P. Berrange
Cc: qemu-devel, qemu-block, Max Reitz, Paolo Bonzini,
Andreas Färber, Kevin Wolf
Uh, replied to the wrong v14... The one I reviewed is actually v15,
Message-Id: <1475246744-29302-1-git-send-email-berrange@redhat.com>
http://lists.gnu.org/archive/html/qemu-devel/2016-09/msg08238.html
Markus Armbruster <armbru@redhat.com> writes:
> I've warmed quite a bit to this series while reviewing it. In
> particular, I've come around to like structuring the command line ->
> QAPI pipeline exactly like the JSON -> QAPI pipeline, namely 1. parse
> into QObject, 2. convert to QAPI with the QObject input visitor.
> QObject serves as abstract syntax here. The differences between JSON
> and command line result in different abstract syntax, which in turn
> necessitates two cases in the input visitor. The series adds more than
> two, to cater for option visitor funnies. Perhaps we can do without
> some of them.
>
> The other way to skin this cat would be an improved options visitor.
> Has its advantages and disadvantages, but the big one is that you
> already did the work for QObject input visitor solution.
>
> The one major issue I have with the series is that it adds to the
> growing body of QemuOpts hacks/workarounds.
>
> We've pushed QemuOpts beyond well its design limits. What started as a
> simple store for scalar configuration parameters structured as key=value
> lists, plus command line and configuration file syntax, has grown three
> ways to specify lists (repeated keys, basically an implementation
> accident that got pressed into service; special integer list syntax in
> the options visitor, later adopted by the string input visitor,
> hopefully compatibly; and the block layer's dotted key convention) and a
> way to specify arbitrary complex values (block layer's dotted key
> convention again). Of these, only "repeated keys" is in QemuOpts
> proper, all the others are bolted on and used only when needed. How
> they interact is not obvious.
>
> This series marries all the bolted-on stuff and puts it in the QObject
> visitor. That's actually an improvement of sorts; at least it's in just
> two places now. But it's still a smorgasbord of syntactical/semantic
> options.
>
> I feel it's time to stop working around the design limits of QemuOpts
> and start replacing them by something that serves our current needs. We
> basically need the expressive power of JSON on the command line. Syntax
> is debatable, but it should be *one* concrete command-line syntax,
> parsed by *one* parser into *one* kind of abstract syntax tree, where
> the only optional variations are the ones forced upon us by backward
> compatibility.
>
> We can't do this for 2.8, obviously. We can try for 2.9. I have pretty
> specific ideas on how it should be done, so I guess it's only fair I
> give it a try myself.
>
> I know the block layer wants to use bits of this series to save some
> coding work for certain features targeting 2.8. I have no objections as
> long as it doesn't create new ABI. Exception: I'm okay with applying
> dotted key convention to more of the same, e.g. new block drivers.
>
> Sounds sane?
^ permalink raw reply [flat|nested] 32+ messages in thread
* Re: [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties
2016-10-21 9:35 ` Markus Armbruster
@ 2016-10-21 9:38 ` Daniel P. Berrange
0 siblings, 0 replies; 32+ messages in thread
From: Daniel P. Berrange @ 2016-10-21 9:38 UTC (permalink / raw)
To: Markus Armbruster
Cc: qemu-devel, qemu-block, Max Reitz, Paolo Bonzini,
Andreas Färber, Kevin Wolf
On Fri, Oct 21, 2016 at 11:35:10AM +0200, Markus Armbruster wrote:
> Uh, replied to the wrong v14... The one I reviewed is actually v15,
> Message-Id: <1475246744-29302-1-git-send-email-berrange@redhat.com>
> http://lists.gnu.org/archive/html/qemu-devel/2016-09/msg08238.html
Sorry, my bad for screwing up the subject when i posted v15.
Regards,
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://entangle-photo.org -o- http://search.cpan.org/~danberr/ :|
^ permalink raw reply [flat|nested] 32+ messages in thread
end of thread, other threads:[~2016-10-21 9:39 UTC | newest]
Thread overview: 32+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-09-27 13:13 [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 01/19] qdict: implement a qdict_crumple method for un-flattening a dict Daniel P. Berrange
2016-09-27 21:22 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 02/19] option: make parse_option_bool/number non-static Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 03/19] option: allow qemu_opts_to_qdict to merge repeated options Daniel P. Berrange
2016-09-27 22:03 ` Eric Blake
2016-09-28 9:35 ` Daniel P. Berrange
2016-09-28 13:44 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 04/19] qapi: add trace events for visitor Daniel P. Berrange
2016-09-27 22:05 ` Eric Blake
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 05/19] qapi: rename QmpInputVisitor to QObjectInputVisitor Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 06/19] qapi: rename QmpOutputVisitor to QObjectOutputVisitor Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 07/19] qapi: don't pass two copies of TestInputVisitorData to tests Daniel P. Berrange
2016-09-27 22:10 ` Eric Blake
2016-09-27 22:12 ` Eric Blake
2016-09-28 9:35 ` Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 08/19] qapi: permit scalar type conversions in QObjectInputVisitor Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 09/19] qapi: permit auto-creating single element lists Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 10/19] qapi: permit auto-creating nested structs Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 11/19] qapi: add integer range support for QObjectInputVisitor Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 12/19] qapi: allow QObjectInputVisitor to be created with QemuOpts Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 13/19] qom: support non-scalar properties with -object Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 14/19] hmp: support non-scalar properties with object_add Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 15/19] numa: convert to use QObjectInputVisitor for -numa Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 16/19] block: convert crypto driver to use QObjectInputVisitor Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 17/19] acpi: convert to QObjectInputVisitor for -acpi parsing Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 18/19] net: convert to QObjectInputVisitor for -net/-netdev parsing Daniel P. Berrange
2016-09-27 13:13 ` [Qemu-devel] [PATCH v14 19/19] qapi: delete unused OptsVisitor code Daniel P. Berrange
2016-10-20 15:06 ` [Qemu-devel] [PATCH v14 00/19] QAPI/QOM work for non-scalar object properties Markus Armbruster
2016-10-20 15:14 ` Daniel P. Berrange
2016-10-21 9:35 ` Markus Armbruster
2016-10-21 9:38 ` Daniel P. Berrange
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.