mirror of
https://github.com/yuzu-mirror/unicorn.git
synced 2025-12-06 07:12:03 +01:00
2ee6c960ee
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
315 lines
7.9 KiB
C
315 lines
7.9 KiB
C
/*
|
|
* Core Definitions for QAPI Visitor Classes
|
|
*
|
|
* 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 "qemu-common.h"
|
|
#include "qapi/qmp/qobject.h"
|
|
#include "qapi/qmp/qerror.h"
|
|
#include "qapi/visitor.h"
|
|
#include "qapi/visitor-impl.h"
|
|
|
|
void visit_start_struct(Visitor *v, void **obj, const char *kind,
|
|
const char *name, size_t size, Error **errp)
|
|
{
|
|
v->start_struct(v, obj, kind, name, size, errp);
|
|
}
|
|
|
|
void visit_end_struct(Visitor *v, Error **errp)
|
|
{
|
|
v->end_struct(v, errp);
|
|
}
|
|
|
|
void visit_start_implicit_struct(Visitor *v, void **obj, size_t size,
|
|
Error **errp)
|
|
{
|
|
if (v->start_implicit_struct) {
|
|
v->start_implicit_struct(v, obj, size, errp);
|
|
}
|
|
}
|
|
|
|
void visit_end_implicit_struct(Visitor *v)
|
|
{
|
|
if (v->end_implicit_struct) {
|
|
v->end_implicit_struct(v);
|
|
}
|
|
}
|
|
|
|
void visit_start_list(Visitor *v, const char *name, Error **errp)
|
|
{
|
|
v->start_list(v, name, errp);
|
|
}
|
|
|
|
GenericList *visit_next_list(Visitor *v, GenericList **list)
|
|
{
|
|
return v->next_list(v, list);
|
|
}
|
|
|
|
void visit_end_list(Visitor *v)
|
|
{
|
|
v->end_list(v);
|
|
}
|
|
|
|
bool visit_start_union(Visitor *v, bool data_present, Error **errp)
|
|
{
|
|
if (v->start_union) {
|
|
return v->start_union(v, data_present, errp);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void visit_end_union(Visitor *v, bool data_present, Error **errp)
|
|
{
|
|
if (v->end_union) {
|
|
v->end_union(v, data_present, errp);
|
|
}
|
|
}
|
|
|
|
void visit_optional(Visitor *v, bool *present, const char *name,
|
|
Error **errp)
|
|
{
|
|
if (v->optional) {
|
|
v->optional(v, present, name, errp);
|
|
}
|
|
}
|
|
|
|
void visit_get_next_type(Visitor *v, QType *type,
|
|
const char *name, Error **errp)
|
|
{
|
|
if (v->get_next_type) {
|
|
v->get_next_type(v, type, name, errp);
|
|
}
|
|
}
|
|
|
|
void visit_type_enum(Visitor *v, int *obj, const char * const strings[],
|
|
const char *kind, const char *name, Error **errp)
|
|
{
|
|
v->type_enum(v, obj, strings, kind, name, errp);
|
|
}
|
|
|
|
void visit_type_int(Visitor *v, int64_t *obj, const char *name, Error **errp)
|
|
{
|
|
v->type_int64(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_uint8(Visitor *v, uint8_t *obj, const char *name, Error **errp)
|
|
{
|
|
uint64_t value;
|
|
|
|
if (v->type_uint8) {
|
|
v->type_uint8(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_uint64(v, &value, name, errp);
|
|
if (value > UINT8_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "uint8_t");
|
|
return;
|
|
}
|
|
*obj = (uint8_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp)
|
|
{
|
|
uint64_t value;
|
|
|
|
if (v->type_uint16) {
|
|
v->type_uint16(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_uint64(v, &value, name, errp);
|
|
if (value > UINT16_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "uint16_t");
|
|
return;
|
|
}
|
|
*obj = (uint16_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_uint32(Visitor *v, uint32_t *obj, const char *name, Error **errp)
|
|
{
|
|
uint64_t value;
|
|
|
|
if (v->type_uint32) {
|
|
v->type_uint32(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_uint64(v, &value, name, errp);
|
|
if (value > UINT32_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "uint32_t");
|
|
return;
|
|
}
|
|
*obj = (uint32_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp)
|
|
{
|
|
v->type_uint64(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_int8(Visitor *v, int8_t *obj, const char *name, Error **errp)
|
|
{
|
|
int64_t value;
|
|
|
|
if (v->type_int8) {
|
|
v->type_int8(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_int64(v, &value, name, errp);
|
|
if (value < INT8_MIN || value > INT8_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "int8_t");
|
|
return;
|
|
}
|
|
*obj = (int8_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_int16(Visitor *v, int16_t *obj, const char *name, Error **errp)
|
|
{
|
|
int64_t value;
|
|
|
|
if (v->type_int16) {
|
|
v->type_int16(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_int64(v, &value, name, errp);
|
|
if (value < INT16_MIN || value > INT16_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "int16_t");
|
|
return;
|
|
}
|
|
*obj = (int16_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_int32(Visitor *v, int32_t *obj, const char *name, Error **errp)
|
|
{
|
|
int64_t value;
|
|
|
|
if (v->type_int32) {
|
|
v->type_int32(v, obj, name, errp);
|
|
} else {
|
|
value = *obj;
|
|
v->type_int64(v, &value, name, errp);
|
|
if (value < INT32_MIN || value > INT32_MAX) {
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
value on error */
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
name ? name : "null", "int32_t");
|
|
return;
|
|
}
|
|
*obj = (int32_t)value;
|
|
}
|
|
}
|
|
|
|
void visit_type_int64(Visitor *v, int64_t *obj, const char *name, Error **errp)
|
|
{
|
|
v->type_int64(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_size(Visitor *v, uint64_t *obj, const char *name, Error **errp)
|
|
{
|
|
if (v->type_size) {
|
|
v->type_size(v, obj, name, errp);
|
|
} else {
|
|
v->type_uint64(v, obj, name, errp);
|
|
}
|
|
}
|
|
|
|
void visit_type_bool(Visitor *v, bool *obj, const char *name, Error **errp)
|
|
{
|
|
v->type_bool(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_str(Visitor *v, char **obj, const char *name, Error **errp)
|
|
{
|
|
v->type_str(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_number(Visitor *v, double *obj, const char *name, Error **errp)
|
|
{
|
|
v->type_number(v, obj, name, errp);
|
|
}
|
|
|
|
void visit_type_any(Visitor *v, QObject **obj, const char *name,
|
|
Error **errp)
|
|
{
|
|
v->type_any(v, obj, name, errp);
|
|
}
|
|
|
|
void output_type_enum(Visitor *v, int *obj, const char * const strings[],
|
|
const char *kind, const char *name,
|
|
Error **errp)
|
|
{
|
|
int i = 0;
|
|
int value = *obj;
|
|
char *enum_str;
|
|
|
|
assert(strings);
|
|
while (strings[i++] != NULL);
|
|
if (value < 0 || value >= i - 1) {
|
|
error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
|
|
return;
|
|
}
|
|
|
|
enum_str = (char *)strings[value];
|
|
visit_type_str(v, &enum_str, name, errp);
|
|
}
|
|
|
|
void input_type_enum(Visitor *v, int *obj, const char * const strings[],
|
|
const char *kind, const char *name,
|
|
Error **errp)
|
|
{
|
|
Error *local_err = NULL;
|
|
int64_t value = 0;
|
|
char *enum_str;
|
|
|
|
assert(strings);
|
|
|
|
visit_type_str(v, &enum_str, name, &local_err);
|
|
if (local_err) {
|
|
error_propagate(errp, local_err);
|
|
return;
|
|
}
|
|
|
|
while (strings[value] != NULL) {
|
|
if (strcmp(strings[value], enum_str) == 0) {
|
|
break;
|
|
}
|
|
value++;
|
|
}
|
|
|
|
if (strings[value] == NULL) {
|
|
error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
|
|
g_free(enum_str);
|
|
return;
|
|
}
|
|
|
|
g_free(enum_str);
|
|
*obj = (int)value;
|
|
}
|