2015-08-21 07:04:50 +00:00
|
|
|
/*
|
|
|
|
* Input Visitor
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-02-19 06:29:26 +00:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Backports commit da34e65cb4025728566d6504a99916f6e7e1dd6a from qemu
2018-02-22 04:05:15 +00:00
|
|
|
#include "qapi/error.h"
|
2015-08-21 07:04:50 +00:00
|
|
|
#include "qapi/qmp-input-visitor.h"
|
|
|
|
#include "qapi/visitor-impl.h"
|
|
|
|
#include "qemu/queue.h"
|
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "qapi/qmp/types.h"
|
|
|
|
#include "qapi/qmp/qerror.h"
|
|
|
|
|
|
|
|
#define QIV_STACK_SIZE 1024
|
|
|
|
|
|
|
|
typedef struct StackObject
|
|
|
|
{
|
|
|
|
QObject *obj;
|
|
|
|
const QListEntry *entry;
|
|
|
|
GHashTable *h;
|
|
|
|
} StackObject;
|
|
|
|
|
|
|
|
struct QmpInputVisitor
|
|
|
|
{
|
|
|
|
Visitor visitor;
|
|
|
|
StackObject stack[QIV_STACK_SIZE];
|
|
|
|
int nb_stack;
|
|
|
|
bool strict;
|
|
|
|
};
|
|
|
|
|
|
|
|
static QmpInputVisitor *to_qiv(Visitor *v)
|
|
|
|
{
|
|
|
|
return container_of(v, QmpInputVisitor, visitor);
|
|
|
|
}
|
|
|
|
|
|
|
|
static QObject *qmp_input_get_object(QmpInputVisitor *qiv,
|
|
|
|
const char *name,
|
|
|
|
bool consume)
|
|
|
|
{
|
|
|
|
QObject *qobj = qiv->stack[qiv->nb_stack - 1].obj;
|
|
|
|
|
|
|
|
if (qobj) {
|
|
|
|
if (name && qobject_type(qobj) == QTYPE_QDICT) {
|
|
|
|
if (qiv->stack[qiv->nb_stack - 1].h && consume) {
|
|
|
|
g_hash_table_remove(qiv->stack[qiv->nb_stack - 1].h, name);
|
|
|
|
}
|
|
|
|
return qdict_get(qobject_to_qdict(qobj), name);
|
|
|
|
} else if (qiv->stack[qiv->nb_stack - 1].entry) {
|
|
|
|
return qlist_entry_obj(qiv->stack[qiv->nb_stack - 1].entry);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return qobj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qdict_add_key(const char *key, QObject *obj, void *opaque)
|
|
|
|
{
|
|
|
|
GHashTable *h = opaque;
|
|
|
|
g_hash_table_insert(h, (gpointer) key, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_input_push(QmpInputVisitor *qiv, QObject *obj, Error **errp)
|
|
|
|
{
|
|
|
|
GHashTable *h;
|
|
|
|
|
|
|
|
if (qiv->nb_stack >= QIV_STACK_SIZE) {
|
|
|
|
error_setg(errp, "An internal buffer overran");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qiv->stack[qiv->nb_stack].obj = obj;
|
|
|
|
qiv->stack[qiv->nb_stack].entry = NULL;
|
|
|
|
qiv->stack[qiv->nb_stack].h = NULL;
|
|
|
|
|
|
|
|
if (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);
|
|
|
|
qiv->stack[qiv->nb_stack].h = h;
|
|
|
|
}
|
|
|
|
|
|
|
|
qiv->nb_stack++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/** Only for qmp_input_pop. */
|
|
|
|
static gboolean always_true(gpointer key, gpointer val, gpointer user_pkey)
|
|
|
|
{
|
|
|
|
*(const char **)user_pkey = (const char *)key;
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_input_pop(QmpInputVisitor *qiv, Error **errp)
|
|
|
|
{
|
|
|
|
assert(qiv->nb_stack > 0);
|
|
|
|
|
|
|
|
if (qiv->strict) {
|
|
|
|
GHashTable * const top_ht = qiv->stack[qiv->nb_stack - 1].h;
|
|
|
|
if (top_ht) {
|
|
|
|
if (g_hash_table_size(top_ht)) {
|
|
|
|
const char *key;
|
2017-01-19 11:50:28 +00:00
|
|
|
g_hash_table_find(top_ht, always_true, (gpointer)&key);
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
g_hash_table_unref(top_ht);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
qiv->nb_stack--;
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_start_struct(Visitor *v, const char *name, void **obj,
|
2018-02-20 04:42:59 +00:00
|
|
|
size_t size, Error **errp)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, true);
|
|
|
|
Error *err = NULL;
|
|
|
|
|
2018-02-23 19:53:21 +00:00
|
|
|
if (obj) {
|
|
|
|
*obj = NULL;
|
|
|
|
}
|
2015-08-21 07:04:50 +00:00
|
|
|
if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"QDict");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qmp_input_push(qiv, qobj, &err);
|
|
|
|
if (err) {
|
|
|
|
error_propagate(errp, err);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj) {
|
|
|
|
*obj = g_malloc0(size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_input_end_struct(Visitor *v, Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
|
2018-02-20 04:44:41 +00:00
|
|
|
qmp_input_pop(qiv, &error_abort);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_input_start_implicit_struct(Visitor *v, void **obj,
|
|
|
|
size_t size, Error **errp)
|
|
|
|
{
|
|
|
|
if (obj) {
|
|
|
|
*obj = g_malloc0(size);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
static void qmp_input_end_implicit_struct(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_input_start_list(Visitor *v, const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, true);
|
|
|
|
|
|
|
|
if (!qobj || qobject_type(qobj) != QTYPE_QLIST) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"list");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qmp_input_push(qiv, qobj, errp);
|
|
|
|
}
|
|
|
|
|
qapi: Adjust layout of FooList types
By sticking the next pointer first, we don't need a union with
64-bit padding for smaller types. On 32-bit platforms, this
can reduce the size of uint8List from 16 bytes (or 12, depending
on whether 64-bit ints can tolerate 4-byte alignment) down to 8.
It has no effect on 64-bit platforms (where alignment still
dictates a 16-byte struct); but fewer anonymous unions is still
a win in my book.
It requires visit_next_list() to gain a size parameter, to know
what size element to allocate; comparable to the size parameter
of visit_start_struct().
I debated about going one step further, to allow for fewer casts,
by doing:
typedef GenericList GenericList;
struct GenericList {
GenericList *next;
};
struct FooList {
GenericList base;
Foo *value;
};
so that you convert to 'GenericList *' by '&foolist->base', and
back by 'container_of(generic, GenericList, base)' (as opposed to
the existing '(GenericList *)foolist' and '(FooList *)generic').
But doing that would require hoisting the declaration of
GenericList prior to inclusion of qapi-types.h, rather than its
current spot in visitor.h; it also makes iteration a bit more
verbose through 'foolist->base.next' instead of 'foolist->next'.
Note that for lists of objects, the 'value' payload is still
hidden behind a boxed pointer. Someday, it would be nice to do:
struct FooList {
FooList *next;
Foo value;
};
for one less level of malloc for each list element. This patch
is a step in that direction (now that 'next' is no longer at a
fixed non-zero offset within the struct, we can store more than
just a pointer's-worth of data as the value payload), but the
actual conversion would be a task for another series, as it will
touch a lot of code.
Backports commit e65d89bf1a4484e0db0f3dc820a8b209f2fb1e8b from qemu
2018-02-23 19:48:57 +00:00
|
|
|
static GenericList *qmp_input_next_list(Visitor *v, GenericList **list,
|
|
|
|
size_t size)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
GenericList *entry;
|
|
|
|
StackObject *so = &qiv->stack[qiv->nb_stack - 1];
|
|
|
|
bool first;
|
|
|
|
|
|
|
|
if (so->entry == NULL) {
|
|
|
|
so->entry = qlist_first(qobject_to_qlist(so->obj));
|
|
|
|
first = true;
|
|
|
|
} else {
|
|
|
|
so->entry = qlist_next(so->entry);
|
|
|
|
first = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (so->entry == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
qapi: Adjust layout of FooList types
By sticking the next pointer first, we don't need a union with
64-bit padding for smaller types. On 32-bit platforms, this
can reduce the size of uint8List from 16 bytes (or 12, depending
on whether 64-bit ints can tolerate 4-byte alignment) down to 8.
It has no effect on 64-bit platforms (where alignment still
dictates a 16-byte struct); but fewer anonymous unions is still
a win in my book.
It requires visit_next_list() to gain a size parameter, to know
what size element to allocate; comparable to the size parameter
of visit_start_struct().
I debated about going one step further, to allow for fewer casts,
by doing:
typedef GenericList GenericList;
struct GenericList {
GenericList *next;
};
struct FooList {
GenericList base;
Foo *value;
};
so that you convert to 'GenericList *' by '&foolist->base', and
back by 'container_of(generic, GenericList, base)' (as opposed to
the existing '(GenericList *)foolist' and '(FooList *)generic').
But doing that would require hoisting the declaration of
GenericList prior to inclusion of qapi-types.h, rather than its
current spot in visitor.h; it also makes iteration a bit more
verbose through 'foolist->base.next' instead of 'foolist->next'.
Note that for lists of objects, the 'value' payload is still
hidden behind a boxed pointer. Someday, it would be nice to do:
struct FooList {
FooList *next;
Foo value;
};
for one less level of malloc for each list element. This patch
is a step in that direction (now that 'next' is no longer at a
fixed non-zero offset within the struct, we can store more than
just a pointer's-worth of data as the value payload), but the
actual conversion would be a task for another series, as it will
touch a lot of code.
Backports commit e65d89bf1a4484e0db0f3dc820a8b209f2fb1e8b from qemu
2018-02-23 19:48:57 +00:00
|
|
|
entry = g_malloc0(size);
|
2015-08-21 07:04:50 +00:00
|
|
|
if (first) {
|
|
|
|
*list = entry;
|
|
|
|
} else {
|
|
|
|
(*list)->next = entry;
|
|
|
|
}
|
|
|
|
|
|
|
|
return entry;
|
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
static void qmp_input_end_list(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
|
2018-02-19 17:48:38 +00:00
|
|
|
qmp_input_pop(qiv, &error_abort);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_get_next_type(Visitor *v, const char *name, QType *type,
|
|
|
|
bool promote_int, Error **errp)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, false);
|
|
|
|
|
|
|
|
if (!qobj) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2018-02-20 02:57:23 +00:00
|
|
|
if (promote_int && *type == QTYPE_QINT) {
|
|
|
|
*type = QTYPE_QFLOAT;
|
|
|
|
}
|
qapi: Simplify visiting of alternate types
Previously, working with alternates required two lookup arrays
and some indirection: for type Foo, we created Foo_qtypes[]
which maps each qtype to a value of the generated FooKind enum,
then look up that value in FooKind_lookup[] like we do for other
union types.
This has a couple of subtle bugs. First, the generator was
creating a call with a parameter '(int *) &(*obj)->type' where
type is an enum type; this is unsafe if the compiler chooses
to store the enum type in a different size than int, where
assigning through the wrong size pointer can corrupt data or
cause a SIGBUS.
Related bug, not not fixed in this patch: qapi-visit.py's
gen_visit_enum() generates a cast of its enum * argument to
int *. Marked FIXME.
Second, since the values of the FooKind enum start at zero, all
entries of the Foo_qtypes[] array that were not explicitly
initialized will map to the same branch of the union as the
first member of the alternate, rather than triggering a desired
failure in visit_get_next_type(). Fortunately, the bug seldom
bites; the very next thing the input visitor does is try to
parse the incoming JSON with the wrong parser, which normally
fails; the output visitor is not used with a C struct in that
state, and the dealloc visitor has nothing to clean up (so
there is no leak).
However, the second bug IS observable in one case: parsing an
integer causes unusual behavior in an alternate that contains
at least a 'number' member but no 'int' member, because the
'number' parser accepts QTYPE_QINT in addition to the expected
QTYPE_QFLOAT (that is, since 'int' is not a member, the type
QTYPE_QINT accidentally maps to FooKind 0; if this enum value
is the 'number' branch the integer parses successfully, but if
the 'number' branch is not first, some other branch tries to
parse the integer and rejects it). A later patch will worry
about fixing alternates to always parse all inputs that a
non-alternate 'number' would accept, for now this is still
marked FIXME in the updated test-qmp-input-visitor.c, to
merely point out that new undesired behavior of 'ans' matches
the existing undesired behavior of 'asn'.
This patch fixes the default-initialization bug by deleting the
indirection, and modifying get_next_type() to directly assign a
QTypeCode parameter. This in turn fixes the type-casting bug,
as we are no longer casting a pointer to enum to a questionable
size. There is no longer a need to generate an implicit FooKind
enum associated with the alternate type (since the QMP wire
format never uses the stringized counterparts of the C union
member names). Since the updated visit_get_next_type() does not
know which qtypes are expected, the generated visitor is
modified to generate an error statement if an unexpected type is
encountered.
Callers now have to know the QTYPE_* mapping when looking at the
discriminator; but so far, only the testsuite was even using the
C struct of an alternate types. I considered the possibility of
keeping the internal enum FooKind, but initialized differently
than most generated arrays, as in:
typedef enum FooKind {
FOO_KIND_A = QTYPE_QDICT,
FOO_KIND_B = QTYPE_QINT,
} FooKind;
to create nicer aliases for knowing when to use foo->a or foo->b
when inspecting foo->type; but it turned out to add too much
complexity, especially without a client.
There is a user-visible side effect to this change, but I
consider it to be an improvement. Previously,
the invalid QMP command:
{"execute":"blockdev-add", "arguments":{"options":
{"driver":"raw", "id":"a", "file":true}}}
failed with:
{"error": {"class": "GenericError",
"desc": "Invalid parameter type for 'file', expected: QDict"}}
(visit_get_next_type() succeeded, and the error comes from the
visit_type_BlockdevOptions() expecting {}; there is no mention of
the fact that a string would also work). Now it fails with:
{"error": {"class": "GenericError",
"desc": "Invalid parameter type for 'file', expected: BlockdevRef"}}
(the error when the next type doesn't match any expected types for
the overall alternate).
Backports commit 0426d53c6530606bf7641b83f2b755fe61c280ee from qemu
2018-02-20 02:51:35 +00:00
|
|
|
*type = qobject_type(qobj);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_int64(Visitor *v, const char *name, int64_t *obj,
|
qapi: Prefer type_int64 over type_int in visitors
The qapi builtin type 'int' is basically shorthand for the type
'int64'. In fact, since no visitor was providing the optional
type_int64() callback, visit_type_int64() was just always falling
back to type_int(), cementing the equivalence between the types.
However, some visitors are providing a type_uint64() callback.
For purposes of code consistency, it is nicer if all visitors
use the paired type_int64/type_uint64 names rather than the
mismatched type_int/type_uint64. So this patch just renames
the signed int callbacks in place, dropping the type_int()
callback as redundant, and a later patch will focus on the
unsigned int callbacks.
Add some FIXMEs to questionable reuse of errp in code touched
by the rename, while at it (the reuse works as long as the
callbacks don't modify value when setting an error, but it's not
a good example to set) - a later patch will then fix those.
No change in functionality here, although further cleanups are
in the pipeline.
Backports commit 4c40314a35816de635e7170eaacdc0c35be83a8a from qemu
2018-02-19 16:53:19 +00:00
|
|
|
Error **errp)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
2018-02-17 19:20:20 +00:00
|
|
|
QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-17 19:20:20 +00:00
|
|
|
if (!qint) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"integer");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-17 19:20:20 +00:00
|
|
|
*obj = qint_get_int(qint);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_uint64(Visitor *v, const char *name, uint64_t *obj,
|
qapi: Make all visitors supply uint64 callbacks
Our qapi visitor contract supports multiple integer visitors,
but left the type_uint64 visitor as optional (falling back on
type_int64); which in turn can lead to awkward behavior with
numbers larger than INT64_MAX (the user has to be aware of
twos complement, and deal with negatives).
This patch does not address the disparity in handling large
values as negatives. It merely moves the fallback from uint64
to int64 from the visitor core to the visitors, where the issue
can actually be fixed, by implementing the missing type_uint64()
callbacks on top of the respective type_int64() callbacks, and
with a FIXME comment explaining why that's wrong.
With that done, we now have a type_uint64() callback in every
driver, so we can make it mandatory from the core. And although
the type_int64() callback can cover the entire valid range of
type_uint{8,16,32} on valid user input, using type_uint64() to
avoid mixed signedness makes more sense.
Backports commit f755dea79dc81b0d6a8f6414e0672e165e28d8ba from qemu
2018-02-19 16:57:56 +00:00
|
|
|
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));
|
|
|
|
|
|
|
|
if (!qint) {
|
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"integer");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*obj = qint_get_int(qint);
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_bool(Visitor *v, const char *name, bool *obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
2018-02-17 19:15:06 +00:00
|
|
|
QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-17 19:15:06 +00:00
|
|
|
if (!qbool) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"boolean");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-17 19:15:06 +00:00
|
|
|
*obj = qbool_get_bool(qbool);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_str(Visitor *v, const char *name, char **obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
2018-02-17 19:23:15 +00:00
|
|
|
QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-17 19:23:15 +00:00
|
|
|
if (!qstr) {
|
2018-02-23 19:53:21 +00:00
|
|
|
*obj = NULL;
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"string");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-17 19:23:15 +00:00
|
|
|
*obj = g_strdup(qstring_get_str(qstr));
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_number(Visitor *v, const char *name, double *obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, true);
|
2018-02-17 19:20:20 +00:00
|
|
|
QInt *qint;
|
|
|
|
QFloat *qfloat;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-17 19:20:20 +00:00
|
|
|
qint = qobject_to_qint(qobj);
|
|
|
|
if (qint) {
|
|
|
|
*obj = qint_get_int(qobject_to_qint(qobj));
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-02-17 19:20:20 +00:00
|
|
|
qfloat = qobject_to_qfloat(qobj);
|
|
|
|
if (qfloat) {
|
2015-08-21 07:04:50 +00:00
|
|
|
*obj = qfloat_get_double(qobject_to_qfloat(qobj));
|
2018-02-17 19:20:20 +00:00
|
|
|
return;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
2018-02-17 19:20:20 +00:00
|
|
|
|
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
|
|
|
|
"number");
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_type_any(Visitor *v, const char *name, QObject **obj,
|
2018-02-19 22:45:25 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, true);
|
|
|
|
|
|
|
|
qobject_incref(qobj);
|
|
|
|
*obj = qobj;
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_input_optional(Visitor *v, const char *name, bool *present)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpInputVisitor *qiv = to_qiv(v);
|
|
|
|
QObject *qobj = qmp_input_get_object(qiv, name, true);
|
|
|
|
|
|
|
|
if (!qobj) {
|
|
|
|
*present = false;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*present = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
Visitor *qmp_input_get_visitor(QmpInputVisitor *v)
|
|
|
|
{
|
|
|
|
return &v->visitor;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_input_visitor_cleanup(QmpInputVisitor *v)
|
|
|
|
{
|
|
|
|
qobject_decref(v->stack[0].obj);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *v;
|
|
|
|
|
|
|
|
v = g_malloc0(sizeof(*v));
|
|
|
|
|
2018-02-23 19:25:19 +00:00
|
|
|
v->visitor.type = VISITOR_INPUT;
|
2015-08-21 07:04:50 +00:00
|
|
|
v->visitor.start_struct = qmp_input_start_struct;
|
|
|
|
v->visitor.end_struct = qmp_input_end_struct;
|
|
|
|
v->visitor.start_implicit_struct = qmp_input_start_implicit_struct;
|
|
|
|
v->visitor.end_implicit_struct = qmp_input_end_implicit_struct;
|
|
|
|
v->visitor.start_list = qmp_input_start_list;
|
|
|
|
v->visitor.next_list = qmp_input_next_list;
|
|
|
|
v->visitor.end_list = qmp_input_end_list;
|
qapi: Prefer type_int64 over type_int in visitors
The qapi builtin type 'int' is basically shorthand for the type
'int64'. In fact, since no visitor was providing the optional
type_int64() callback, visit_type_int64() was just always falling
back to type_int(), cementing the equivalence between the types.
However, some visitors are providing a type_uint64() callback.
For purposes of code consistency, it is nicer if all visitors
use the paired type_int64/type_uint64 names rather than the
mismatched type_int/type_uint64. So this patch just renames
the signed int callbacks in place, dropping the type_int()
callback as redundant, and a later patch will focus on the
unsigned int callbacks.
Add some FIXMEs to questionable reuse of errp in code touched
by the rename, while at it (the reuse works as long as the
callbacks don't modify value when setting an error, but it's not
a good example to set) - a later patch will then fix those.
No change in functionality here, although further cleanups are
in the pipeline.
Backports commit 4c40314a35816de635e7170eaacdc0c35be83a8a from qemu
2018-02-19 16:53:19 +00:00
|
|
|
v->visitor.type_int64 = qmp_input_type_int64;
|
qapi: Make all visitors supply uint64 callbacks
Our qapi visitor contract supports multiple integer visitors,
but left the type_uint64 visitor as optional (falling back on
type_int64); which in turn can lead to awkward behavior with
numbers larger than INT64_MAX (the user has to be aware of
twos complement, and deal with negatives).
This patch does not address the disparity in handling large
values as negatives. It merely moves the fallback from uint64
to int64 from the visitor core to the visitors, where the issue
can actually be fixed, by implementing the missing type_uint64()
callbacks on top of the respective type_int64() callbacks, and
with a FIXME comment explaining why that's wrong.
With that done, we now have a type_uint64() callback in every
driver, so we can make it mandatory from the core. And although
the type_int64() callback can cover the entire valid range of
type_uint{8,16,32} on valid user input, using type_uint64() to
avoid mixed signedness makes more sense.
Backports commit f755dea79dc81b0d6a8f6414e0672e165e28d8ba from qemu
2018-02-19 16:57:56 +00:00
|
|
|
v->visitor.type_uint64 = qmp_input_type_uint64;
|
2015-08-21 07:04:50 +00:00
|
|
|
v->visitor.type_bool = qmp_input_type_bool;
|
|
|
|
v->visitor.type_str = qmp_input_type_str;
|
|
|
|
v->visitor.type_number = qmp_input_type_number;
|
2018-02-19 22:45:25 +00:00
|
|
|
v->visitor.type_any = qmp_input_type_any;
|
2015-08-21 07:04:50 +00:00
|
|
|
v->visitor.optional = qmp_input_optional;
|
|
|
|
v->visitor.get_next_type = qmp_input_get_next_type;
|
|
|
|
|
|
|
|
qmp_input_push(v, obj, NULL);
|
|
|
|
qobject_incref(obj);
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
QmpInputVisitor *qmp_input_visitor_new_strict(QObject *obj)
|
|
|
|
{
|
|
|
|
QmpInputVisitor *v;
|
|
|
|
|
|
|
|
v = qmp_input_visitor_new(obj);
|
|
|
|
v->strict = true;
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|