2015-08-21 07:04:50 +00:00
|
|
|
/*
|
|
|
|
* Core Definitions for QAPI/QMP Command Registry
|
|
|
|
*
|
|
|
|
* 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-output-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"
|
|
|
|
|
|
|
|
typedef struct QStackEntry
|
|
|
|
{
|
|
|
|
QObject *value;
|
|
|
|
bool is_list_head;
|
|
|
|
QTAILQ_ENTRY(QStackEntry) node;
|
|
|
|
} QStackEntry;
|
|
|
|
|
|
|
|
typedef QTAILQ_HEAD(QStack, QStackEntry) QStack;
|
|
|
|
|
|
|
|
struct QmpOutputVisitor
|
|
|
|
{
|
|
|
|
Visitor visitor;
|
2018-02-20 13:09:55 +00:00
|
|
|
QStack stack; /* Stack of containers that haven't yet been finished */
|
|
|
|
QObject *root; /* Root of the output visit */
|
2015-08-21 07:04:50 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define qmp_output_add(qov, name, value) \
|
|
|
|
qmp_output_add_obj(qov, name, QOBJECT(value))
|
|
|
|
#define qmp_output_push(qov, value) qmp_output_push_obj(qov, QOBJECT(value))
|
|
|
|
|
|
|
|
static QmpOutputVisitor *to_qov(Visitor *v)
|
|
|
|
{
|
|
|
|
return container_of(v, QmpOutputVisitor, visitor);
|
|
|
|
}
|
|
|
|
|
2018-02-20 13:07:24 +00:00
|
|
|
/* Push @value onto the stack of current QObjects being built */
|
2015-08-21 07:04:50 +00:00
|
|
|
static void qmp_output_push_obj(QmpOutputVisitor *qov, QObject *value)
|
|
|
|
{
|
|
|
|
QStackEntry *e = g_malloc0(sizeof(*e));
|
|
|
|
|
2018-02-20 13:09:55 +00:00
|
|
|
assert(qov->root);
|
2018-02-20 13:07:24 +00:00
|
|
|
assert(value);
|
2015-08-21 07:04:50 +00:00
|
|
|
e->value = value;
|
|
|
|
if (qobject_type(e->value) == QTYPE_QLIST) {
|
|
|
|
e->is_list_head = true;
|
|
|
|
}
|
|
|
|
QTAILQ_INSERT_HEAD(&qov->stack, e, node);
|
|
|
|
}
|
|
|
|
|
2018-02-20 13:07:24 +00:00
|
|
|
/* Pop a value off the stack of QObjects being built, and return it. */
|
2015-08-21 07:04:50 +00:00
|
|
|
static QObject *qmp_output_pop(QmpOutputVisitor *qov)
|
|
|
|
{
|
|
|
|
QStackEntry *e = QTAILQ_FIRST(&qov->stack);
|
|
|
|
QObject *value;
|
2018-02-20 13:07:24 +00:00
|
|
|
|
|
|
|
assert(e);
|
2015-08-21 07:04:50 +00:00
|
|
|
QTAILQ_REMOVE(&qov->stack, e, node);
|
|
|
|
value = e->value;
|
2018-02-20 13:07:24 +00:00
|
|
|
assert(value);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(e);
|
2015-08-21 07:04:50 +00:00
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
2018-02-20 13:07:24 +00:00
|
|
|
/* 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. */
|
2015-08-21 07:04:50 +00:00
|
|
|
static void qmp_output_add_obj(QmpOutputVisitor *qov, const char *name,
|
|
|
|
QObject *value)
|
|
|
|
{
|
2018-02-20 13:09:55 +00:00
|
|
|
QStackEntry *e = QTAILQ_FIRST(&qov->stack);
|
|
|
|
QObject *cur = e ? e->value : NULL;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-20 13:09:55 +00:00
|
|
|
if (!cur) {
|
2018-02-24 00:04:38 +00:00
|
|
|
/* Don't allow reuse of visitor on more than one root */
|
|
|
|
assert(!qov->root);
|
2018-02-20 13:09:55 +00:00
|
|
|
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:
|
2018-02-24 00:04:38 +00:00
|
|
|
assert(!name);
|
2018-02-20 13:09:55 +00:00
|
|
|
qlist_append_obj(qobject_to_qlist(cur), value);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_start_struct(Visitor *v, const char *name, void **obj,
|
2018-02-20 04:42:59 +00:00
|
|
|
size_t unused, Error **errp)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
QDict *dict = qdict_new();
|
|
|
|
|
|
|
|
qmp_output_add(qov, name, dict);
|
|
|
|
qmp_output_push(qov, dict);
|
|
|
|
}
|
|
|
|
|
qapi: Split visit_end_struct() into pieces
As mentioned in previous patches, we want to call visit_end_struct()
functions unconditionally, so that visitors can release resources
tied up since the matching visit_start_struct() without also having
to worry about error priority if more than one error occurs.
Even though error_propagate() can be safely used to ignore a second
error during cleanup caused by a first error, it is simpler if the
cleanup cannot set an error. So, split out the error checking
portion (basically, input visitors checking for unvisited keys) into
a new function visit_check_struct(), which can be safely skipped if
any earlier errors are encountered, and leave the cleanup portion
(which never fails, but must be called unconditionally if
visit_start_struct() succeeded) in visit_end_struct().
Generated code in qapi-visit.c has diffs resembling:
|@@ -59,10 +59,12 @@ void visit_type_ACPIOSTInfo(Visitor *v,
| goto out_obj;
| }
| visit_type_ACPIOSTInfo_members(v, obj, &err);
|- error_propagate(errp, err);
|- err = NULL;
|+ if (err) {
|+ goto out_obj;
|+ }
|+ visit_check_struct(v, &err);
| out_obj:
|- visit_end_struct(v, &err);
|+ visit_end_struct(v);
| out:
and in qapi-event.c:
@@ -47,7 +47,10 @@ void qapi_event_send_acpi_device_ost(ACP
| goto out;
| }
| visit_type_q_obj_ACPI_DEVICE_OST_arg_members(v, ¶m, &err);
|- visit_end_struct(v, err ? NULL : &err);
|+ if (!err) {
|+ visit_check_struct(v, &err);
|+ }
|+ visit_end_struct(v);
| if (err) {
| goto out;
Backports commit 15c2f669e3fb2bc97f7b42d1871f595c0ac24af8 from qemu
2018-02-24 00:12:23 +00:00
|
|
|
static void qmp_output_end_struct(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
2018-02-24 00:04:38 +00:00
|
|
|
QObject *value = qmp_output_pop(qov);
|
|
|
|
assert(qobject_type(value) == QTYPE_QDICT);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_output_start_list(Visitor *v, const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
QList *list = qlist_new();
|
|
|
|
|
|
|
|
qmp_output_add(qov, name, list);
|
|
|
|
qmp_output_push(qov, list);
|
|
|
|
}
|
|
|
|
|
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_output_next_list(Visitor *v, GenericList **listp,
|
|
|
|
size_t size)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
GenericList *list = *listp;
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
QStackEntry *e = QTAILQ_FIRST(&qov->stack);
|
|
|
|
|
|
|
|
assert(e);
|
|
|
|
if (e->is_list_head) {
|
|
|
|
e->is_list_head = false;
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list ? list->next : NULL;
|
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
static void qmp_output_end_list(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
2018-02-24 00:04:38 +00:00
|
|
|
QObject *value = qmp_output_pop(qov);
|
|
|
|
assert(qobject_type(value) == QTYPE_QLIST);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_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
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
qmp_output_add(qov, name, qint_from_int(*obj));
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_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: QMP outputs values larger than INT64_MAX as negative */
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
qmp_output_add(qov, name, qint_from_int(*obj));
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_type_bool(Visitor *v, const char *name, bool *obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
2018-02-13 22:13:24 +00:00
|
|
|
qmp_output_add(qov, name, qbool_from_bool(*obj));
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_type_str(Visitor *v, const char *name, char **obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
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(""));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_type_number(Visitor *v, const char *name, double *obj,
|
2015-08-21 07:04:50 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
qmp_output_add(qov, name, qfloat_from_double(*obj));
|
|
|
|
}
|
|
|
|
|
2018-02-20 04:28:33 +00:00
|
|
|
static void qmp_output_type_any(Visitor *v, const char *name, QObject **obj,
|
2018-02-19 22:45:25 +00:00
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
qobject_incref(*obj);
|
|
|
|
qmp_output_add_obj(qov, name, *obj);
|
|
|
|
}
|
|
|
|
|
qapi: Add visit_type_null() visitor
Right now, qmp-output-visitor happens to produce a QNull result
if nothing is actually visited between the creation of the visitor
and the request for the resulting QObject. A stronger protocol
would require that a QMP output visit MUST visit something. But
to still be able to produce a JSON 'null' output, we need a new
visitor function that states our intentions. Yes, we could say
that such a visit must go through visit_type_any(), but that
feels clunky.
So this patch introduces the new visit_type_null() interface and
its no-op interface in the dealloc visitor, and stubs in the
qmp visitors (the next patch will finish the implementation).
For the visitors that will not implement the callback, document
the situation. The code in qapi-visit-core unconditionally
dereferences the callback pointer, so that a segfault will inform
a developer if they need to implement the callback for their
choice of visitor.
Note that JSON has a primitive null type, with the single value
null; likewise with the QNull type for QObject; but for QAPI,
we just have the 'null' value without a null type. We may
eventually want to add more support in QAPI for null (most likely,
we'd use it via an alternate type that permits 'null' or an
object); but we'll create that usage when we need it.
Backports commit 3bc97fd5924561d92f32758c67eaffd2e4e25038 from qemu
2018-02-23 20:48:53 +00:00
|
|
|
static void qmp_output_type_null(Visitor *v, const char *name, Error **errp)
|
|
|
|
{
|
2018-02-24 00:02:11 +00:00
|
|
|
QmpOutputVisitor *qov = to_qov(v);
|
|
|
|
qmp_output_add_obj(qov, name, qnull());
|
qapi: Add visit_type_null() visitor
Right now, qmp-output-visitor happens to produce a QNull result
if nothing is actually visited between the creation of the visitor
and the request for the resulting QObject. A stronger protocol
would require that a QMP output visit MUST visit something. But
to still be able to produce a JSON 'null' output, we need a new
visitor function that states our intentions. Yes, we could say
that such a visit must go through visit_type_any(), but that
feels clunky.
So this patch introduces the new visit_type_null() interface and
its no-op interface in the dealloc visitor, and stubs in the
qmp visitors (the next patch will finish the implementation).
For the visitors that will not implement the callback, document
the situation. The code in qapi-visit-core unconditionally
dereferences the callback pointer, so that a segfault will inform
a developer if they need to implement the callback for their
choice of visitor.
Note that JSON has a primitive null type, with the single value
null; likewise with the QNull type for QObject; but for QAPI,
we just have the 'null' value without a null type. We may
eventually want to add more support in QAPI for null (most likely,
we'd use it via an alternate type that permits 'null' or an
object); but we'll create that usage when we need it.
Backports commit 3bc97fd5924561d92f32758c67eaffd2e4e25038 from qemu
2018-02-23 20:48:53 +00:00
|
|
|
}
|
|
|
|
|
2018-02-24 00:04:38 +00:00
|
|
|
/* 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. */
|
2015-08-21 07:04:50 +00:00
|
|
|
QObject *qmp_output_get_qobject(QmpOutputVisitor *qov)
|
|
|
|
{
|
2018-02-24 00:04:38 +00:00
|
|
|
/* A visit must have occurred, with each start paired with end. */
|
|
|
|
assert(qov->root && QTAILQ_EMPTY(&qov->stack));
|
|
|
|
|
|
|
|
qobject_incref(qov->root);
|
|
|
|
return qov->root;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Visitor *qmp_output_get_visitor(QmpOutputVisitor *v)
|
|
|
|
{
|
|
|
|
return &v->visitor;
|
|
|
|
}
|
|
|
|
|
|
|
|
void qmp_output_visitor_cleanup(QmpOutputVisitor *v)
|
|
|
|
{
|
|
|
|
QStackEntry *e, *tmp;
|
|
|
|
|
|
|
|
QTAILQ_FOREACH_SAFE(e, &v->stack, node, tmp) {
|
|
|
|
QTAILQ_REMOVE(&v->stack, e, node);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(e);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-20 13:09:55 +00:00
|
|
|
qobject_decref(v->root);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
QmpOutputVisitor *qmp_output_visitor_new(void)
|
|
|
|
{
|
|
|
|
QmpOutputVisitor *v;
|
|
|
|
|
|
|
|
v = g_malloc0(sizeof(*v));
|
|
|
|
|
2018-02-23 19:25:19 +00:00
|
|
|
v->visitor.type = VISITOR_OUTPUT;
|
2015-08-21 07:04:50 +00:00
|
|
|
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;
|
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_output_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_output_type_uint64;
|
2015-08-21 07:04:50 +00:00
|
|
|
v->visitor.type_bool = qmp_output_type_bool;
|
|
|
|
v->visitor.type_str = qmp_output_type_str;
|
|
|
|
v->visitor.type_number = qmp_output_type_number;
|
2018-02-19 22:45:25 +00:00
|
|
|
v->visitor.type_any = qmp_output_type_any;
|
qapi: Add visit_type_null() visitor
Right now, qmp-output-visitor happens to produce a QNull result
if nothing is actually visited between the creation of the visitor
and the request for the resulting QObject. A stronger protocol
would require that a QMP output visit MUST visit something. But
to still be able to produce a JSON 'null' output, we need a new
visitor function that states our intentions. Yes, we could say
that such a visit must go through visit_type_any(), but that
feels clunky.
So this patch introduces the new visit_type_null() interface and
its no-op interface in the dealloc visitor, and stubs in the
qmp visitors (the next patch will finish the implementation).
For the visitors that will not implement the callback, document
the situation. The code in qapi-visit-core unconditionally
dereferences the callback pointer, so that a segfault will inform
a developer if they need to implement the callback for their
choice of visitor.
Note that JSON has a primitive null type, with the single value
null; likewise with the QNull type for QObject; but for QAPI,
we just have the 'null' value without a null type. We may
eventually want to add more support in QAPI for null (most likely,
we'd use it via an alternate type that permits 'null' or an
object); but we'll create that usage when we need it.
Backports commit 3bc97fd5924561d92f32758c67eaffd2e4e25038 from qemu
2018-02-23 20:48:53 +00:00
|
|
|
v->visitor.type_null = qmp_output_type_null;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
QTAILQ_INIT(&v->stack);
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|