yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2024-12-23 17:35:33 +00:00
Code Issues Packages Projects Releases Wiki Activity
unicorn/qemu/qapi/qmp-input-visitor.c

384 lines
9.6 KiB
C
Raw Normal View History

import
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.
*
*/
qapi: Clean up includes Clean up includes so that osdep.h is included first and headers which it implies are not included manually. This commit was created with scripts/clean-includes. Backports commit cbf21151906c935d4276268b59429c58546462ae from qemu
2018-02-19 06:29:26 +00:00
#include "qemu/osdep.h"
import
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;
This code should now build the x86_x64-softmmu part 2.
2017-01-19 11:50:28 +00:00
g_hash_table_find(top_ht, always_true, (gpointer)&key);
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_QMP_EXTRA_MEMBER, key);
import
2015-08-21 07:04:50 +00:00
}
g_hash_table_unref(top_ht);
}
}
qiv->nb_stack--;
}
static void qmp_input_start_struct(Visitor *v, void **obj, const char *kind,
const char *name, size_t size, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, true);
Error *err = NULL;
if (!qobj || qobject_type(qobj) != QTYPE_QDICT) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"QDict");
import
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);
qmp_input_pop(qiv, errp);
}
static void qmp_input_start_implicit_struct(Visitor *v, void **obj,
size_t size, Error **errp)
{
if (obj) {
*obj = g_malloc0(size);
}
}
qapi: Drop unused error argument for list and implicit struct No backend was setting an error when ending the visit of a list or implicit struct, or when moving to the next list node. Make the callers a bit easier to follow by making this a part of the contract, and removing the errp argument - callers can then unconditionally end an object as part of cleanup without having to think about whether a second error is dominated by a first, because there is no second error. A later patch will then tackle the larger task of splitting visit_end_struct(), which can indeed set an error. Backports commit 08f9541dec51700abef0c37994213164ca4e4fc9 from qemu
2018-02-19 17:58:24 +00:00
static void qmp_input_end_implicit_struct(Visitor *v)
import
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) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"list");
import
2015-08-21 07:04:50 +00:00
return;
}
qmp_input_push(qiv, qobj, errp);
}
qapi: Drop unused error argument for list and implicit struct No backend was setting an error when ending the visit of a list or implicit struct, or when moving to the next list node. Make the callers a bit easier to follow by making this a part of the contract, and removing the errp argument - callers can then unconditionally end an object as part of cleanup without having to think about whether a second error is dominated by a first, because there is no second error. A later patch will then tackle the larger task of splitting visit_end_struct(), which can indeed set an error. Backports commit 08f9541dec51700abef0c37994213164ca4e4fc9 from qemu
2018-02-19 17:58:24 +00:00
static GenericList *qmp_input_next_list(Visitor *v, GenericList **list)
import
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;
}
entry = g_malloc0(sizeof(*entry));
if (first) {
*list = entry;
} else {
(*list)->next = entry;
}
return entry;
}
qapi: Drop unused error argument for list and implicit struct No backend was setting an error when ending the visit of a list or implicit struct, or when moving to the next list node. Make the callers a bit easier to follow by making this a part of the contract, and removing the errp argument - callers can then unconditionally end an object as part of cleanup without having to think about whether a second error is dominated by a first, because there is no second error. A later patch will then tackle the larger task of splitting visit_end_struct(), which can indeed set an error. Backports commit 08f9541dec51700abef0c37994213164ca4e4fc9 from qemu
2018-02-19 17:58:24 +00:00
static void qmp_input_end_list(Visitor *v)
import
2015-08-21 07:04:50 +00:00
{
QmpInputVisitor *qiv = to_qiv(v);
qapi: Tighten qmp_input_end_list() The only way that qmp_input_pop() will set errp is if a dictionary was the most recent thing pushed. Since we don't have any push(struct)/pop(list) or push(list)/pop(struct) mismatches (such a mismatch is a programming bug), we therefore cannot set errp inside qmp_input_end_list(). Make this obvious by using &error_abort. A later patch will then remove the errp parameter of qmp_input_pop(), but that will first require the larger task of splitting visit_end_struct(). Backports commit bdd8e6b5d8a9def83d491a3f41c10424fc366258 from qemu
2018-02-19 17:48:38 +00:00
qmp_input_pop(qiv, &error_abort);
import
2015-08-21 07:04:50 +00:00
}
qapi: Fix alternates that accept 'number' but not 'int' The QMP input visitor allows integral values to be assigned by promotion to a QTYPE_QFLOAT. However, when parsing an alternate, we did not take this into account, such that an alternate that accepts 'number' and some other type, but not 'int', would reject integral values. With this patch, we now have the following desirable table: alternate has case selected for 'int' 'number' QTYPE_QINT QTYPE_QFLOAT no no error error no yes 'number' 'number' yes no 'int' error yes yes 'int' 'number' While it is unlikely that we will ever use 'number' in an alternate other than in the testsuite, it never hurts to be more precise in what we allow. Backports commit d00341af384665d259af475b14c96bb8414df415 from qemu
2018-02-20 02:57:23 +00:00
static void qmp_input_get_next_type(Visitor *v, QType *type, bool promote_int,
import
2015-08-21 07:04:50 +00:00
const char *name, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, false);
if (!qobj) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_MISSING_PARAMETER, name ? name : "null");
import
2015-08-21 07:04:50 +00:00
return;
}
qapi: Fix alternates that accept 'number' but not 'int' The QMP input visitor allows integral values to be assigned by promotion to a QTYPE_QFLOAT. However, when parsing an alternate, we did not take this into account, such that an alternate that accepts 'number' and some other type, but not 'int', would reject integral values. With this patch, we now have the following desirable table: alternate has case selected for 'int' 'number' QTYPE_QINT QTYPE_QFLOAT no no error error no yes 'number' 'number' yes no 'int' error yes yes 'int' 'number' While it is unlikely that we will ever use 'number' in an alternate other than in the testsuite, it never hurts to be more precise in what we allow. Backports commit d00341af384665d259af475b14c96bb8414df415 from qemu
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);
import
2015-08-21 07:04:50 +00:00
}
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
static void qmp_input_type_int64(Visitor *v, int64_t *obj, const char *name,
Error **errp)
import
2015-08-21 07:04:50 +00:00
{
QmpInputVisitor *qiv = to_qiv(v);
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
QInt *qint = qobject_to_qint(qmp_input_get_object(qiv, name, true));
import
2015-08-21 07:04:50 +00:00
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
if (!qint) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"integer");
import
2015-08-21 07:04:50 +00:00
return;
}
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
*obj = qint_get_int(qint);
import
2015-08-21 07:04:50 +00:00
}
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
static void qmp_input_type_uint64(Visitor *v, uint64_t *obj, const char *name,
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);
}
import
2015-08-21 07:04:50 +00:00
static void qmp_input_type_bool(Visitor *v, bool *obj, const char *name,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
qbool: Make conversion from QObject * accept null qobject_to_qbool() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 14b6160099f0caf5dc9d62e637b007bc5d719a96 from qemu
2018-02-17 19:15:06 +00:00
QBool *qbool = qobject_to_qbool(qmp_input_get_object(qiv, name, true));
import
2015-08-21 07:04:50 +00:00
qbool: Make conversion from QObject * accept null qobject_to_qbool() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 14b6160099f0caf5dc9d62e637b007bc5d719a96 from qemu
2018-02-17 19:15:06 +00:00
if (!qbool) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"boolean");
import
2015-08-21 07:04:50 +00:00
return;
}
qbool: Make conversion from QObject * accept null qobject_to_qbool() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 14b6160099f0caf5dc9d62e637b007bc5d719a96 from qemu
2018-02-17 19:15:06 +00:00
*obj = qbool_get_bool(qbool);
import
2015-08-21 07:04:50 +00:00
}
static void qmp_input_type_str(Visitor *v, char **obj, const char *name,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
qstring: Make conversion from QObject * accept null qobject_to_qstring() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 7f0278435df1fa845b3bd9556942f89296d4246b from qemu
2018-02-17 19:23:15 +00:00
QString *qstr = qobject_to_qstring(qmp_input_get_object(qiv, name, true));
import
2015-08-21 07:04:50 +00:00
qstring: Make conversion from QObject * accept null qobject_to_qstring() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 7f0278435df1fa845b3bd9556942f89296d4246b from qemu
2018-02-17 19:23:15 +00:00
if (!qstr) {
qerror: Clean up QERR_ macros to expand into a single string These macros expand into error class enumeration constant, comma, string. Unclean. Has been that way since commit 13f59ae. The error class is always ERROR_CLASS_GENERIC_ERROR since the previous commit. * Prepend every use of a QERR_ macro by ERROR_CLASS_GENERIC_ERROR, and delete it from the QERR_ macro. No change after preprocessing. * Rewrite error_set(ERROR_CLASS_GENERIC_ERROR, ...) into error_setg(...). Again, no change after preprocessing. Backports commit c6bd8c706a799eb0fece99f468aaa22b818036f3 from qemu
2018-02-13 22:34:32 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"string");
import
2015-08-21 07:04:50 +00:00
return;
}
qstring: Make conversion from QObject * accept null qobject_to_qstring() crashes on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit 7f0278435df1fa845b3bd9556942f89296d4246b from qemu
2018-02-17 19:23:15 +00:00
*obj = g_strdup(qstring_get_str(qstr));
import
2015-08-21 07:04:50 +00:00
}
static void qmp_input_type_number(Visitor *v, double *obj, const char *name,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, true);
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
QInt *qint;
QFloat *qfloat;
import
2015-08-21 07:04:50 +00:00
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
qint = qobject_to_qint(qobj);
if (qint) {
*obj = qint_get_int(qobject_to_qint(qobj));
import
2015-08-21 07:04:50 +00:00
return;
}
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
qfloat = qobject_to_qfloat(qobj);
if (qfloat) {
import
2015-08-21 07:04:50 +00:00
*obj = qfloat_get_double(qobject_to_qfloat(qobj));
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
return;
import
2015-08-21 07:04:50 +00:00
}
qfloat qint: Make conversion from QObject * accept null qobject_to_qfloat() and qobject_to_qint() crash on null, which is a trap for the unwary. Return null instead, and simplify a few callers. Backports commit fcf73f66a67f5e58c18216f8c8651e38cf4d90af from qemu
2018-02-17 19:20:20 +00:00
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"number");
import
2015-08-21 07:04:50 +00:00
}
qapi: Introduce a first class 'any' type It's first class, because unlike '**', it actually works, i.e. doesn't require 'gen': false. '**' will go away next. Backports commit 28770e057f265a4e70bcbdfc2447cce7b5f2dc19 from qemu
2018-02-19 22:45:25 +00:00
static void qmp_input_type_any(Visitor *v, QObject **obj, const char *name,
Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, true);
qobject_incref(qobj);
*obj = qobj;
}
qapi: Simplify visits of optional fields None of the visitor callbacks would set an error when testing if an optional field was present; make this part of the interface contract by eliminating the errp argument. The resulting generated code has a nice diff: |- visit_optional(v, &has_fdset_id, "fdset-id", &err); |- if (err) { |- goto out; |- } |+ visit_optional(v, &has_fdset_id, "fdset-id"); | if (has_fdset_id) { | visit_type_int(v, &fdset_id, "fdset-id", &err); | if (err) { | goto out; | } | } Backports commit 5cdc8831a795fb8452d7e34f644202fd724e122a from qemu
2018-02-20 03:00:34 +00:00
static void qmp_input_optional(Visitor *v, bool *present, const char *name)
import
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);
revert to use of g_free to make future qemu integrations easier (#695) * revert to use of g_free to make future qemu integrations easier * bracing
2016-12-21 14:28:36 +00:00
g_free(v);
import
2015-08-21 07:04:50 +00:00
}
QmpInputVisitor *qmp_input_visitor_new(QObject *obj)
{
QmpInputVisitor *v;
v = g_malloc0(sizeof(*v));
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;
v->visitor.type_enum = input_type_enum;
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;
import
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;
qapi: Introduce a first class 'any' type It's first class, because unlike '**', it actually works, i.e. doesn't require 'gen': false. '**' will go away next. Backports commit 28770e057f265a4e70bcbdfc2447cce7b5f2dc19 from qemu
2018-02-19 22:45:25 +00:00
v->visitor.type_any = qmp_input_type_any;
import
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;
}
Reference in a new issue Copy permalink