2015-08-21 07:04:50 +00:00
|
|
|
/*
|
|
|
|
|
* Core Definitions for QAPI Visitor implementations
|
|
|
|
|
*
|
2018-02-19 17:58:24 +00:00
|
|
|
* Copyright (C) 2012-2016 Red Hat, Inc.
|
2015-08-21 07:04:50 +00:00
|
|
|
*
|
|
|
|
|
* Author: Paolo Bonizni <pbonzini@redhat.com>
|
|
|
|
|
*
|
|
|
|
|
* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
|
|
|
|
|
* See the COPYING.LIB file in the top-level directory.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
#ifndef QAPI_VISITOR_IMPL_H
|
|
|
|
|
#define QAPI_VISITOR_IMPL_H
|
|
|
|
|
|
|
|
|
|
#include "qapi/error.h"
|
|
|
|
|
#include "qapi/visitor.h"
|
|
|
|
|
|
|
|
|
|
struct Visitor
|
|
|
|
|
{
|
|
|
|
|
/* Must be set */
|
|
|
|
|
void (*start_struct)(Visitor *v, void **obj, const char *kind,
|
|
|
|
|
const char *name, size_t size, Error **errp);
|
|
|
|
|
void (*end_struct)(Visitor *v, Error **errp);
|
|
|
|
|
|
|
|
|
|
void (*start_implicit_struct)(Visitor *v, void **obj, size_t size,
|
|
|
|
|
Error **errp);
|
2018-02-19 17:58:24 +00:00
|
|
|
void (*end_implicit_struct)(Visitor *v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
|
void (*start_list)(Visitor *v, const char *name, Error **errp);
|
2018-02-19 17:58:24 +00:00
|
|
|
GenericList *(*next_list)(Visitor *v, GenericList **list);
|
|
|
|
|
void (*end_list)(Visitor *v);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
2018-02-19 21:02:14 +00:00
|
|
|
void (*type_enum)(Visitor *v, int *obj, const char * const strings[],
|
2015-08-21 07:04:50 +00:00
|
|
|
const char *kind, const char *name, Error **errp);
|
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
|
|
|
/* May be NULL; only needed for input visitors. */
|
|
|
|
|
void (*get_next_type)(Visitor *v, QType *type,
|
2015-08-21 07:04:50 +00:00
|
|
|
const char *name, Error **errp);
|
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
|
|
|
/* Must be set. */
|
|
|
|
|
void (*type_int64)(Visitor *v, int64_t *obj, const char *name,
|
|
|
|
|
Error **errp);
|
|
|
|
|
/* Must be set. */
|
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
|
|
|
void (*type_uint64)(Visitor *v, uint64_t *obj, const char *name,
|
|
|
|
|
Error **errp);
|
|
|
|
|
/* Optional; fallback is type_uint64(). */
|
|
|
|
|
void (*type_size)(Visitor *v, uint64_t *obj, const char *name,
|
|
|
|
|
Error **errp);
|
|
|
|
|
/* Must be set. */
|
2015-08-21 07:04:50 +00:00
|
|
|
void (*type_bool)(Visitor *v, bool *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_str)(Visitor *v, char **obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_number)(Visitor *v, double *obj, const char *name,
|
|
|
|
|
Error **errp);
|
2018-02-19 22:45:25 +00:00
|
|
|
void (*type_any)(Visitor *v, QObject **obj, const char *name,
|
|
|
|
|
Error **errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
|
/* May be NULL */
|
|
|
|
|
void (*optional)(Visitor *v, bool *present, const char *name,
|
|
|
|
|
Error **errp);
|
|
|
|
|
|
|
|
|
|
void (*type_uint8)(Visitor *v, uint8_t *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_uint16)(Visitor *v, uint16_t *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_uint32)(Visitor *v, uint32_t *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_int8)(Visitor *v, int8_t *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_int16)(Visitor *v, int16_t *obj, const char *name, Error **errp);
|
|
|
|
|
void (*type_int32)(Visitor *v, int32_t *obj, const char *name, Error **errp);
|
|
|
|
|
bool (*start_union)(Visitor *v, bool data_present, Error **errp);
|
|
|
|
|
void (*end_union)(Visitor *v, bool data_present, Error **errp);
|
|
|
|
|
};
|
|
|
|
|
|
2018-02-19 21:02:14 +00:00
|
|
|
void input_type_enum(Visitor *v, int *obj, const char * const strings[],
|
2015-08-21 07:04:50 +00:00
|
|
|
const char *kind, const char *name, Error **errp);
|
2018-02-19 21:02:14 +00:00
|
|
|
void output_type_enum(Visitor *v, int *obj, const char * const strings[],
|
2015-08-21 07:04:50 +00:00
|
|
|
const char *kind, const char *name, Error **errp);
|
|
|
|
|
|
|
|
|
|
#endif
|
