2015-08-21 07:04:50 +00:00
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2018-02-19 06:29:26 +00:00
|
|
|
#include "qemu/osdep.h"
|
2015-08-21 07:04:50 +00:00
|
|
|
#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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
void visit_end_implicit_struct(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
|
|
|
if (v->end_implicit_struct) {
|
2018-02-19 17:58:24 +00:00
|
|
|
v->end_implicit_struct(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_start_list(Visitor *v, const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
v->start_list(v, name, errp);
|
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
GenericList *visit_next_list(Visitor *v, GenericList **list)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
2018-02-19 17:58:24 +00:00
|
|
|
return v->next_list(v, list);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-19 17:58:24 +00:00
|
|
|
void visit_end_list(Visitor *v)
|
2015-08-21 07:04:50 +00:00
|
|
|
{
|
2018-02-19 17:58:24 +00:00
|
|
|
v->end_list(v);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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, int *obj, const int *qtypes,
|
|
|
|
const char *name, Error **errp)
|
|
|
|
{
|
|
|
|
if (v->get_next_type) {
|
|
|
|
v->get_next_type(v, obj, qtypes, name, errp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-19 21:02:14 +00:00
|
|
|
void visit_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)
|
|
|
|
{
|
|
|
|
v->type_enum(v, obj, strings, kind, name, errp);
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_int(Visitor *v, int64_t *obj, 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
|
|
|
v->type_int64(v, obj, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_uint8(Visitor *v, uint8_t *obj, const char *name, Error **errp)
|
|
|
|
{
|
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
|
|
|
uint64_t value;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
if (v->type_uint8) {
|
|
|
|
v->type_uint8(v, obj, name, errp);
|
|
|
|
} else {
|
|
|
|
value = *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
|
|
|
v->type_uint64(v, &value, name, errp);
|
|
|
|
if (value > UINT8_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "uint8_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (uint8_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp)
|
|
|
|
{
|
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
|
|
|
uint64_t value;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
if (v->type_uint16) {
|
|
|
|
v->type_uint16(v, obj, name, errp);
|
|
|
|
} else {
|
|
|
|
value = *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
|
|
|
v->type_uint64(v, &value, name, errp);
|
|
|
|
if (value > UINT16_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "uint16_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (uint16_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_uint32(Visitor *v, uint32_t *obj, const char *name, Error **errp)
|
|
|
|
{
|
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
|
|
|
uint64_t value;
|
2015-08-21 07:04:50 +00:00
|
|
|
|
|
|
|
if (v->type_uint32) {
|
|
|
|
v->type_uint32(v, obj, name, errp);
|
|
|
|
} else {
|
|
|
|
value = *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
|
|
|
v->type_uint64(v, &value, name, errp);
|
|
|
|
if (value > UINT32_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "uint32_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (uint32_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_uint64(Visitor *v, uint64_t *obj, const char *name, Error **errp)
|
|
|
|
{
|
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->type_uint64(v, obj, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
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->type_int64(v, &value, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
if (value < INT8_MIN || value > INT8_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "int8_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (int8_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
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->type_int64(v, &value, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
if (value < INT16_MIN || value > INT16_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "int16_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (int16_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
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->type_int64(v, &value, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
if (value < INT32_MIN || value > INT32_MAX) {
|
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
|
|
|
/* FIXME questionable reuse of errp if callback changed
|
|
|
|
value on error */
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
|
|
|
|
name ? name : "null", "int32_t");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (int32_t)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void visit_type_int64(Visitor *v, int64_t *obj, 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
|
|
|
v->type_int64(v, obj, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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 {
|
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->type_uint64(v, obj, name, errp);
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-02-19 22:45:25 +00:00
|
|
|
void visit_type_any(Visitor *v, QObject **obj, const char *name,
|
|
|
|
Error **errp)
|
|
|
|
{
|
|
|
|
v->type_any(v, obj, name, 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)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
int value = *obj;
|
|
|
|
char *enum_str;
|
|
|
|
|
|
|
|
assert(strings);
|
|
|
|
while (strings[i++] != NULL);
|
|
|
|
if (value < 0 || value >= i - 1) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, name ? name : "null");
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
enum_str = (char *)strings[value];
|
|
|
|
visit_type_str(v, &enum_str, name, 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)
|
|
|
|
{
|
|
|
|
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) {
|
2018-02-13 22:34:32 +00:00
|
|
|
error_setg(errp, QERR_INVALID_PARAMETER, enum_str);
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(enum_str);
|
2015-08-21 07:04:50 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-12-21 14:28:36 +00:00
|
|
|
g_free(enum_str);
|
2017-01-19 11:50:28 +00:00
|
|
|
*obj = (int)value;
|
2015-08-21 07:04:50 +00:00
|
|
|
}
|